import faq as f
+def initialise_mode_beta():
+ global beta
+ hote = flask.request.host
+ if hote[:4] == "beta":
+ print("** Mode bêta !**")
+ return True
+ else:
+ return False
+
+
app = flask.Flask(__name__)
+
+
@app.route('/',methods=['POST','GET'])
def index():
+ beta=initialise_mode_beta()
liste_err = initialise_erreurs()
val_form = config_init()
if flask.request.method=="POST":
if val_form2 == {}:
return flask.render_template("index.html",err=liste_err[2]+liste_err[1]+liste_err[0],valform=val_form)
val_form.update(val_form2)
- #return str(val_form['nb_data'])
- return flask.render_template("index.html",err=liste_err[1],valform=val_form)
+
+ return flask.render_template("index.html",err=liste_err[1],valform=val_form, CONFIG=CONFIG, beta=beta)
@app.route('/apropos')
def apropos():
-
- return flask.render_template("apropos.html",err=[])
+ beta=initialise_mode_beta()
+ return flask.render_template("apropos.html",err=[], beta=beta)
@app.route("/courbe/<ext>", methods=['POST'])
try:
debug("création des figures...",liste_err)
textes_images = {}
+ liste_extracalculs = []
for typed in CONFIG["liste_typedonnees"]:
if config["tracevide"] == "oui" or listes_jours[typed] != []:
debug("On trace la courbe de "+typed,liste_err)
- fig = cree_figure(config,listes_jours[typed],listes_donnees[typed],typed,liste_err)
+ fig = cree_figure(config,listes_jours[typed],listes_donnees[typed],typed,liste_extracalculs, liste_err)
output = io.BytesIO()
FigureCanvas(fig).print_png(output)
plt.close(fig)
"export_txt": texte,
"nomenfant": nomenfant}
if result == "success":
- reponse["messages"] = liste_err[0]
+ reponse["messages"] = liste_err[0]+liste_err[1]
+ reponse["calculextra"] = liste_extracalculs
else:
reponse["messages"] = liste_err[2]+liste_err[1]+liste_err[0]
for typed in CONFIG["liste_typedonnees"]:
reponse["image_"+typed] = textes_images.get(typed,"")
+
+
return flask.jsonify(reponse)
elif ext == "png" and result == "success": # à voir cette partie car il faudrait voir ce qu'on y renvoie... vu
# qu'il n'y a plus une courbe mais plusieurs. Là ça renverra la dernière générée.
@app.route("/contact")
def contact():
- return flask.render_template("contact.html",err=[])
+ beta=initialise_mode_beta()
+ return flask.render_template("contact.html",err=[], beta=beta)
@app.route("/faq")
def faq():
+ beta=initialise_mode_beta()
table_faq = f.lire_fichier_csv_simple(f.fichier_FAQ)
l_categ,table_qr = f.extraire_tables_par_cat(table_faq)
- return flask.render_template("faq.html",lcateg=l_categ,tableqr=table_qr,err=[])
+ return flask.render_template("faq.html",lcateg=l_categ,tableqr=table_qr,err=[], beta=beta)
@app.route("/changelog")
def changelog():
+ beta=initialise_mode_beta()
table_version = f.lire_fichier_csv_simple(f.fichier_changelog)
- return flask.render_template("changelog.html",table = table_version,err=[])
+ return flask.render_template("changelog.html",table = table_version,err=[], beta=beta)
if __name__ == "__main__":
print("Mode debug maison : "+str(niveau_debug))
--- /dev/null
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Thu Feb 18 18:25:11 2021
+
+@author: sekhmet
+"""
+
+from gestion_erreurs import warning, debug
+from configuration import CONFIG
+from gestion_donnees import convertit_age_vers_texte
+import gestion_unites as u
+
+#### Les fonctions qui permettent de faire les calculs additionnels une fois qu'on a l'extrapolation
+
+def met_s(chaine):
+ """ renvoie un s si pluriel, rien sinon"""
+ if int(chaine)>1:
+ return "s"
+ else:
+ return ""
+
+def joliechaine_age(age):
+ """ prend en argument une chaîne du type 6a3m2j et renvoie une chaîne un peu
+ plus jolie à lire genre 6 ans, 3mois, 2 jours"""
+ retour = ""
+ nombre = ""
+ for char in age:
+ if char=="a":
+ retour+=nombre+" année"+met_s(nombre)+", "
+ nombre=""
+ elif char=="m":
+ retour+=nombre+" mois, "
+ nombre=""
+ elif char=="s":
+ retour+=nombre+" semaine"+met_s(nombre)+", "
+ nombre=""
+ elif char=="j":
+ retour+=nombre+" jour"+met_s(nombre)+", "
+ nombre=""
+ else:
+ nombre+=char
+ #print(retour)
+ return retour[:-2]
+
+
+
+def calcule_donnee_extrapolee(dates_extrapole, donnees_extrapole, age_voulu, typedonnee, liste_err):
+ """ prend en argument les données extrapolées, l'âge voulu en jours,
+ et le type de données qu'on veut afficher, et renvoie une jolie phrase
+ à afficher"""
+ age_voulu = int(age_voulu) # pour avoir les choses bien
+ debug("On veut la donnée à l'âge "+str(age_voulu), liste_err)
+ try:
+ i_date_voulue = dates_extrapole.index(age_voulu)
+ donnee_voulue = donnees_extrapole[i_date_voulue]
+ donnee_arrondie = u.arrondit_donnee(donnee_voulue, typedonnee)
+ chaine = "À "+joliechaine_age(convertit_age_vers_texte(age_voulu))
+
+ if typedonnee == "poids":
+ return chaine+", l'enfant pèsera "+str(donnee_arrondie)+" kg."
+ elif typedonnee == "taille":
+ return chaine+", l'enfant mesurera "+str(donnee_arrondie)+" cm."
+ else: # phrase générique
+ return chaine+", la donnée sera : "+str(donnee_arrondie)+" "+CONFIG["unites_typedonnees"][typedonnee]+"."
+ except:
+ warning("Impossible de calculer la donnée à l'âge "+age_voulu, liste_err)
+ return ""
+
+def calcule_age_extrapole(dates_extrapole, donnees_extrapole, donnee_voulue, typedonnee, liste_err):
+ """ prend en argument les données extrapolées, la donnée voulue (dans l'unité adaptée)
+ et son type, et renvoie la jolie phrase à afficher"""
+
+ debug("On veut savoir à quel âge on a "+str(donnee_voulue), liste_err)
+ try:
+ i=0
+ while i<len(donnees_extrapole) and donnees_extrapole[i]<donnee_voulue:
+ i+=1
+
+ age_joli = joliechaine_age(convertit_age_vers_texte(dates_extrapole[i]))
+ if typedonnee=="poids":
+ return "L'enfant atteindra un poids de "+str(donnee_voulue)+" kg à l'âge de "+age_joli+"."
+ elif typedonnee=="taille":
+ return "L'enfant atteindra la taille "+str(donnee_voulue)+ "cm à l'âge de "+age_joli+"."
+ else:# phrase générique
+ return "L'enfant atteindra la donnée "+typedonnee+" "+str(donnee_voulue)+" à l'âge de "+age_joli+"."
+ except:
+ warning("Impossible de calculer l'âge pour la donnée "+str(donnee_voulue), liste_err)
+ return ""
CONFIG["liste_unites"] = ["jours", "semaines", "mois", "années"]
CONFIG["liste_typedonnees"] = ["poids","taille"]
CONFIG["unites_typedonnees"] = {"poids": "kg", "taille":"cm"}
+# à combien on arrondit par défaut les dnnées
+CONFIG["arrondis_typedonnees"] = {"poids": 0.01, "taille": 1}
+# Liste des calculs additionnels
+CONFIG["extradata"] = ["calculextradata", "calculextratemps"]
# fichiers
+"Version 2.5","18/02/2021","<p>Nouveauté : extrapolation de la courbe améliorée et calculs possibles ! En bêta, à tester !</p>"
+
"Version 2.261","16/02/2021","<p>Du mieux sur la gestion de la grille améliorée, qui passe en ""par défaut"" maintenant. Plus une correction de bug sur l'échelle du graphique, et du code nettoyé. On dirait pas comme ça, hein ? N'hésitez pas à me signaler tout vilain bug persistant !</p>"
"Version 2.26","15/02/2021","<p>Nouveauté en bêta-test : grille améliorée. Pour le moment on peut cocher pour avoir cette fonctionnalité.</p>"
return table
-def extraire_colonne(table,ncol,maxi):
+def extraire_colonne(table,ncol,maxi=-1):
""" extrait une colonne d'un tableau double, de taille maximum maxi"""
t = []
+ if maxi==-1:
+ maxi = len(table)
for i in range( min(len(table),maxi) ):
t.append(table[i][ncol])
return t
if not(positionlegende in ['upper left','upper right','lower left','lower right']):
positionlegende = "upper left"
configuration["positionlegende"] = positionlegende
-
- configuration["prolongercourbes"] = gere_checkbox(data.get("prolongercourbes",""))
-
- # Ceci n'a pas besoin d'être sauvé
- configuration["non_sauve"]["grilleamelio"] = gere_checkbox(data.get("grilleamelio",""))
configuration["couleurs"] = {}
# gérer les couleurs
coul = rgb_vers_tuple(data.get("couleur_"+clecouleur,""),CONFIG["couleurs"][clecouleur],liste_err)
configuration["couleurs"][clecouleur] = coul
+
+ configuration["non_sauve"]["grilleamelio"] = gere_checkbox(data.get("grilleamelio",""))
+
+
+ #### La partie extrapolation n'a pas besoin d'être sauvée
+ configuration["non_sauve"]["prolongercourbes"] = gere_checkbox(data.get("prolongercourbes",""))
+
+ # Valeur par défaut : 1
+ debug(data.get("nbextradata", "aaargh"), liste_err)
+ nbextradata = data.get("nbextradata",1)
+ try:
+ nbextradata = int(nbextradata)
+ except:
+ warning("Le nombre de données sur lequel on extrapole est invalide : "+nbextradata, liste_err)
+ nbextradata = 1
+ configuration["non_sauve"]["nbextradata"] = nbextradata
+
+ if data.get("calculextradata_type","") in CONFIG["liste_typedonnees"]:
+ configuration["non_sauve"]["calculextradata_type"] = data.get("calculextradata_type","")
+ configuration["non_sauve"]["calculextradata_age"] = convertit_jours_vers_python(data.get("calculextradata_age","0j"),liste_err)
+ else:
+ configuration["non_sauve"]["calculextradata_type"] = ""
+ # On ne met rien dans l'âge, pas la peine
+
+ ctyped = data.get("calculextratemps_type","")
+ if ctyped in CONFIG["liste_typedonnees"]:
+ configuration["non_sauve"]["calculextratemps_type"] = ctyped
+ configuration["non_sauve"]["calculextratemps_val"] = convertit_donnee_vers_python(data.get("calculextratemps_val",""), ctyped, liste_err)
+ else:
+ configuration["non_sauve"]["calculextratemps_type"] = ""
return configuration
+
+
## web vers python : données
def gere_donnees(data,naissance,typedonnee,liste_err):
""" prend en argument le dictionnaire de requête, et la date de
from configuration import CONFIG
from gestion_erreurs import warning
+from math import log
##################### outils pour affichage et choix de l'unité
def convertit_tableau(tableau,unite,liste_err):
""" convertit un tableau de jours en une autre unité.
Renvoie le nouveau tableau"""
- return [convertitunite(elt,unite,liste_err) for elt in tableau]
\ No newline at end of file
+ return [convertitunite(elt,unite,liste_err) for elt in tableau]
+
+def arrondit_donnee(donnee, typed, arrondi=0):
+ """ on arrondit la donnée de type typed (à voir dans CONFIG)
+ à arrondit près. SI y'a 0 on va voir dans la config.
+ Pour l'arrondit on met par ex 1 pour arrondir à 1 pr_s, 0.1 pour arrondir
+ au dixième etc"""
+ if arrondi==0:
+ arrondi = CONFIG["arrondis_typedonnees"][typed]
+ if arrondi==0:
+ print("Euuuh ça va merder, y'a une div par 0 dans arrondit_donnees !")
+
+ d_arr = round(donnee/arrondi)*arrondi
+ nbchiffresvoulus = int(log(1/arrondi, 10))+1 # max sur le nombre de chiffres après la virgule qu'on doit avoir
+ return round(d_arr, nbchiffresvoulus)
\ No newline at end of file
var liste_warnings = this.response.messages
var texte = this.response.export_txt;
var nomenfant = this.response.nomenfant ;
+ var calculextra = this.response.calculextra ;
// on affiche l'export des données
document.getElementById('export').innerHTML = texte;
li.appendChild(document.createTextNode(liste_warnings[i]));
ul.appendChild(li);
}
- }
+ }
+ // S'il y a des calculs faits, à afficher !
+ if(calculextra.length != 0)
+ {
+ var elem_extr = document.getElementById("section_extradonnees")
+ elem_extr.style.display = "block" ;
+ var ul2=elem_extr.children[1] ;
+ for(i=0; i<calculextra.length; i++) {
+ var li = document.createElement("li");
+ li.appendChild(document.createTextNode(calculextra[i]));
+ ul2.appendChild(li);
+ }
+ }
}
else{ // si la génération de l'image a merdé
text-align: center;
}
+.bandeau_beta {
+ background: #F5BF62;
+ border-style: solid;
+ border-width: 3px ;
+ padding: 0px 5px ;
+}
+
#warnings {
background: #ff8060;
}
max-width: 100%
}
-#sectioncourbe, #section_courbe_poids, #section_courbe_taille {
+#sectioncourbe, #section_courbe_poids, #section_courbe_taille, #section_extradonnees {
display: none;
}
display: none;
}
-#pref_graphique {
+#pref_graphique, #extra {
display: none;
}
</div>
{% endif %}
+ {% if beta %}
+ <div class="bandeau_beta">
+ <p>Attention !</p>
+ </p>Ceci est la version « Bêta-test » du site. Il se peut que l'outil ait un comportement inattendu ou buggue. Si vous ne savez pas ce que vous
+ faites là, retournez sur le site normal <a href="https://oms.syanni.eu">en cliquant ici</a></p>
+ </div>
+ {% endif %}
<div id="content">
{% block contenu %}{% endblock %}
<a href="/contact">Contact</a> |
<a href="/apropos">À propos</a> |
<a href="/changelog">Changelog</a>
-
</nav>
</body>
<p id="changemode" class="petit"><span onclick="change_mode_dates('text')" class="bouton">Cliquer ici</span> pour saisir les dates comme du texte.</p> </li>
<li>Prématuré ? <span class="petit">(expérimental)</span> <span class="bouton" onclick="affiche_cache('prema',this)">Afficher</span>
<div id="prema"><p class="petit">Si l'enfant est né prématuré (avant 37 semaines d'aménorrhée), indiquer de « combien » en durée (même syntaxe que pour les âges, voir plus bas). Sinon, laisser 0j.</p>
-<label>Prématurité</label> <input type="text" name="prematurite" value="{{ valform.prematurite }}"> <input type="checkbox" name="agecorrige" {% if valform.agecorrige == "oui"%}checked{%endif%}> Afficher l'âge corrigé sur la courbe (plutôt que l'âge réel).
+<label>Prématurité</label> <input type="text" name="prematurite" value="{{ valform.prematurite }}"> <input type="checkbox" name="agecorrige"{% if valform.agecorrige == "oui"%} checked{%endif%}> Afficher l'âge corrigé sur la courbe (plutôt que l'âge réel).
</div></li>
</ul>
-<h3>Données de l'enfant</h3>
+<h3>Saisir les données</h3>
<p><span id="bouton_afficher_donneesplus" class="bouton" onclick="affiche_cache_classe('donneesplus')">Afficher</span> la saisie des tailles.</p>
<p>Syntaxe pour l'âge : utiliser j, s, m, a comme des "unités" (jours, semaines, mois, années). Vous pouvez mixer les unités, par exemple "3a2m5j" pour 3 ans, 2 mois et 5 jours. Les espaces sont ignorées, et il faut saisir des nombres entiers.</p>
<p>Saisir le poids en kilogrammes (par exemple "2.62" ou "2,62" pour 2 kilogrammes et 620 grammes).</p>
{% endfor %}
</select></label></li>
<li><label>valeur maximum du graphique (facultatif, syntaxe similaire à l'âge) </label><input type="text" name="maxi" value="{{ valform.maxi }}"></li>
- <li>Prolonger les courbes (expérimental) : <input type="checkbox" name="prolongercourbes" {% if valform.prolongercourbes == "oui" %} checked{% endif%}></li>
<li><label>Même échelle sur tous les graphiques : </label><input type="checkbox" name="memechelle" {% if valform.memechelle == 'oui' %} checked{% endif %}></li>
- <li><label>Grille améliorée (bêta) :</label><input type="checkbox" name="grilleamelio" {% if valform.grilleamelio == 'oui' %} checked{% endif %}></li>
+ <li><label>Grille améliorée :</label><input type="checkbox" name="grilleamelio" {% if valform.grilleamelio == 'oui' %} checked{% endif %}></li>
+
<li>Dimensions du graphique : <label>largeur : </label><input type="text" name="largeur" value="{{ valform.largeur }}">
<label>hauteur : </label><input type="text" name="hauteur" value="{{ valform.hauteur }}"></li>
<li><label>Légende : <input type="checkbox" name="legende" {% if valform.legende == 'oui' %} checked{% endif %}> </label>
</ul>
+
+<!-- Section calculs/Extrapolation !-->
+
+<h3>Extrapolation</h3>
+<div class="bouton" onclick="affiche_cache('extra',this)">Afficher</div>
+
+<ul id="extra">
+ <li>Calculer le prolongement de la courbe à partir des <input type="text" name="nbextradata" size="4" value="1"> dernières données (mettre 0 pour "toutes").</li>
+ <li><input type="checkbox" name="prolongercourbes">Tracer l'extrapolation sur le graphique.</li>
+ <li>Calculer <select name="calculextradata_type">
+ <option value="">Choisir la donnée</option>
+ {% for val in CONFIG.liste_typedonnees %}
+ <option value="{{val}}">{{val}}</option>
+ {% endfor %}
+ </select> à l'âge <input type="text" name="calculextradata_age" value="6m"></li>
+ <li>Calculer l'âge auquel l'enfant aura <input type="text" name="calculextratemps_val">
+ <select name="calculextratemps_type">
+ <option value="">Choisir la donnée</option>
+ {% for val in CONFIG.liste_typedonnees %}
+ <option value="{{val}}">{{ CONFIG.unites_typedonnees[val]}} ({{val}})</option>
+ {% endfor %}
+ </select></li>
+
+</ul>
+
+
</form>
<!-- section retour -->
<hr>
</div>
+<div id="section_extradonnees">
+ <h2>Calculs sur les courbes</h2>
+ <ul id="extradata">
+
+ </ul>
+</div>
+
<div id="sectionexport">
<h2>Export des données</h2>
from configuration import CONFIG
import gestionOMS as oms
import gestion_unites as u
-from gestion_donnees import calcule_max_graphique, convertit_jours_vers_python
+from gestion_donnees import calcule_max_graphique, convertit_jours_vers_python, convertit_age_vers_texte
from gestion_erreurs import debug, erreur, warning
from numpy import arange
+from calculs_extrapole import calcule_donnee_extrapolee, calcule_age_extrapole
import matplotlib.pyplot as plt
-# Essentiellement, la fonction qui trace la courbe
+# Essentiellement, la fonction qui trace la courbe, mais on y trouve également les fonctions d'extrapolation.
+# Ainsi que les calculs additionnels.
-def cree_figure(conf,l_jours,l_poids,typedonnee,liste_err):
+def cree_figure(conf,l_jours,l_poids,typedonnee,liste_extracalculs, liste_err):
""" conf est le dictionnaire de config. l_jours et l_poids les listes des temps (en jours) et de données
(donc pas forcément du poids)
typedonnee est le type de données (voir CONFIG["liste_typedonnees"]
liste_err la liste des erreurs à compléter (voir gestion_erreurs))
- Renvoie la figure tracée"""
+ Renvoie la figure tracée, et les calculs additionnels sont mis sous forme de chaîne dans la liste
+ liste_extracalculs"""
debug("debut de cree_figure. Config : "+str(conf),liste_err)
try:
liste_data_labels_p,liste_data_labels_z = oms.renvoie_liste_labels(conf,CONFIG["liste_data_choisie_p"],CONFIG["liste_data_choisie_z"],liste_err)
debug("Tracé de la courbe enfant, avec les jours "+str(l_jours_conv),liste_err)
#### extrapolatios éventuelles
- #print("prolongercourbes" in conf)
- if conf["prolongercourbes"] == "oui":
- #print("coucou")
- # les dates, on prend tous les jours tant qu'à faire
- date_fin = int(l_jours[-1])
- dates_extrapole = list(range(date_fin, jour_maxi))
- donnees_extrapole = prolongecourbe(t, date_fin, l_poids[-1], dates_extrapole, conf["typecourbe"], liste_err)
- #print("données extrapolées !")
- dates_extrapole = u.convertit_tableau(dates_extrapole,unite,liste_err)
-
- # tracé des données extrapolées
- plt.plot(dates_extrapole, donnees_extrapole,color=conf["couleurs"]["cadretxt"], linestyle=(0, (5,7)), marker=None)
- debug("Tracé de la courbe extrapolée ok", liste_err)
+ # a-t-on demndé des calculs ?
+ jextrapole = conf["non_sauve"]["prolongercourbes"] == "oui"
+ # Est-ce qu'on a demandé un calcul sur cette donnée ?
+ print()
+ for calextra in CONFIG["extradata"]:
+ jextrapole = jextrapole or conf["non_sauve"][calextra+"_type"] == typedonnee
+
+ #print(jextrapole)
+ if jextrapole:
+ try:
+ debug("Il faut extrapoler les courbes !", liste_err)
+ # Prendre l'ensemble des dates "source"
+ # print(conf["non_sauve"]["nbdataextra"])
+ if conf["non_sauve"]["nbextradata"] == 0:
+ sources_extrap = l_jours
+ sources_extrap_data = l_poids
+ else:
+ sources_extrap = l_jours[-conf["non_sauve"]["nbextradata"]:] # les derniers jours
+ sources_extrap_data = l_poids[-conf["non_sauve"]["nbextradata"]:]
+
+ debug("On extrapole sur les jours : "+str(sources_extrap), liste_err)
+
+ dates_extrapole, donnees_extrapole = prolongecourbe(t, sources_extrap, sources_extrap_data, conf["typecourbe"], liste_err)
+ debug("données extrapolées !", liste_err)
+ #debug(str(dates_extrapole[0:10])+str(donnees_extrapole[0:10]), liste_err)
+
+ # QUe veut-on maintenant sur ces données extrapolées ?
+ # Afficher la courbe
+ if conf["non_sauve"]["prolongercourbes"] == "oui":
+ # On va prendre les extrapolations de la dernière donnée jusqu'à l fin du graphe
+ debut_extr = int(l_jours[-conf["non_sauve"]["nbextradata"]])
+ i_debut_extr = dates_extrapole.index(debut_extr)
+ i_fin_extr = dates_extrapole.index(jour_maxi)
+ # Voilà ce qu'on veut tracer
+ dates_extrapole_trace = dates_extrapole[i_debut_extr:i_fin_extr+1]
+ donnees_extrapole_trace = donnees_extrapole[i_debut_extr:i_fin_extr+1]
+ dates_extrapole_trace = u.convertit_tableau(dates_extrapole_trace,unite,liste_err)
+
+ # tracé des données extrapolées
+ plt.plot(dates_extrapole_trace, donnees_extrapole_trace,color=conf["couleurs"]["cadretxt"], linestyle=(0, (5,7)), marker=None)
+ debug("Tracé de la courbe extrapolée ok", liste_err)
+
+ # Calculer une donnée à l'âge x
+ if conf["non_sauve"]["calculextradata_type"] == typedonnee:
+ r = calcule_donnee_extrapolee(dates_extrapole, donnees_extrapole, conf["non_sauve"]["calculextradata_age"], typedonnee, liste_err)
+ if r!="":
+ liste_extracalculs.append(r)
+ print(liste_extracalculs)
+
+ # Calculer un âge où on atteint cette donnée
+ if conf["non_sauve"]["calculextratemps_type"] == typedonnee:
+ r = calcule_age_extrapole(dates_extrapole, donnees_extrapole, conf["non_sauve"]["calculextratemps_val"], typedonnee, liste_err)
+ if r!="":
+ liste_extracalculs.append(r)
+ print(liste_extracalculs)
+
+ except:
+ warning("Des problèmes pour extrapoler...", liste_err)
else:
debug("On ne trace pas de courbe enfant", liste_err)
plt.xlabel("Âge en "+unite,color=conf["couleurs"]["cadretxt"])
plt.ylabel(typedonnee.capitalize()+" en "+CONFIG["unites_typedonnees"][typedonnee],color=conf["couleurs"]["cadretxt"])
- #print("bla")
plt.title(titre,color=conf["couleurs"]["cadretxt"])
- #print("ble")
if l_jours_conv == []:
plt.axis([0,age_maxi, poids_min, poids_max])
else:
plt.axis([min(0,l_jours_conv[0]),age_maxi,poids_min,poids_max])
- #print("bli")
if conf['legende']=="oui":
######################################## Pour extrapoler la courbe
-def prolongecourbe(tableauOMS, date, donnee, nouvdates, typecourbe, liste_err):
- """ tableauOMS est le ableau des données OMS. date et donnee sont la date (jours)
- et la dernière donnée d'où on extrapole. On veut les extrapolations à nouvdate
+def prolongecourbe(tableauOMS, dates, donnees, typecourbe, liste_err):
+ """ tableauOMS est le ableau des données OMS. dates et donnees sont les dates (jours)
+ et les données d'où on extrapole. On calcule toutes les dates comme des sauvages.
+ On renvoie la liste des jours totale et la liste des data_totales
(tableaux de jours)
typecourbe est P ou Z. Pour P il faut commencer à regarder à l'indice 4, pour Z
à l'indice 1
- On renvoie [] si pas pu extrapoler. """
+ On renvoie [],[] si pas pu extrapoler. """
+ # les lignes OMS correspondant aux dates données
+ lignesoms = [tableauOMS[int(date)] for date in dates]
+ debug("prolongecourbe : Lignes OMS :"+str(lignesoms)+" valeur de données : "+str(donnees), liste_err)
- # la ligne OMS
- ligneoms = tableauOMS[date]
- debug("prolongecourbe : Ligne OMS :"+str(ligneoms)+" valeur de donnée : "+str(donnee), liste_err)
- # On cherche dans quel intervalle on se situe
+ # Principe : on cherche dans quel intervalle de "colonnes" on se situe.
+ # On va donc regarder pour chaque donnée entre quels i on se situe,et après
+ # prendre le plus grand intervalle.
+ # Numéros de colonnes d'où on part. Pour la fin c'est forcément longueur-1
if typecourbe == "P":
idep=4
else:
idep = 1
- i = idep
- while i<len(ligneoms) and ligneoms[i]<donnee:
- i+=1
- debug("prolongecourbe : on a trouvé la valeur de i : "+str(i),liste_err)
- if i>=len(ligneoms):
- warning("prolongation de courbe : pas réussi... donnée trop haute !", liste_err)
- return []
- if i==idep:
- warning("prolongation de courbe : pas réussi... donnée trop basse !", liste_err)
- return []
+
+ liste_indices = []
+ for k in range(len(dates)):
+ i= idep
+ ligne = lignesoms[k]
+ while i<len(ligne) and ligne[i]<donnees[k]:
+ i+=1
+ debug("prolongecourbe : on a trouvé la valeur de i : "+str(i),liste_err)
+ if i>=len(ligne):
+ warning("prolongation de courbe : pas réussi... donnée trop haute !", liste_err)
+ return [],[]
+ if i==idep:
+ warning("prolongation de courbe : pas réussi... donnée trop basse !", liste_err)
+ return [],[]
+ liste_indices.append(i)
+ imin=min(liste_indices) -1
+ imax=max(liste_indices)
+ debug("Les données se situent dans les indices : "+str(imin)+", "+str(imax),liste_err)
+ # Maintenant on doit trouver les coeffs : on se situe en coeff * l[imin]+ (1-coeff)*ligne[imax]
+ # Et faire la moyenne de ces coeffs
+ total = 0
+ for k in range(len(dates)):
+ ligne = lignesoms[k]
+ donnee = donnees[k]
+ total += (donnee - ligne[imax])/(ligne[imin] - ligne[imax])
+ #print(k)
+ coeff_moyen = total/len(dates)
+
+ debug("Coeff moyen calculé : "+str(coeff_moyen), liste_err)
- # Le coeff : donnee = coeff * l[i-1]+ (1-coeff)*ligne[i]
- # On utilisera la même chose pour la nouvelle donnee
- coeff = (donnee - ligneoms[i])/(ligneoms[i-1] - ligneoms[i])
+ # On utilisera la même chose pour les nouvelle donnee
# extrapolations
+ nouvdates =oms.extraire_colonne(tableauOMS,0) # On sort tout.
+ #print(nouvdates)
nouvdonnees = []
for j in nouvdates:
- ligne2 = tableauOMS[j]
- nouvdonnees.append(coeff*ligne2[i-1]+ (1-coeff)*ligne2[i])
+ ligne2 = tableauOMS[int(j)]
+ nouvdonnees.append(coeff_moyen*ligne2[imin]+ (1-coeff_moyen)*ligne2[imax])
- return nouvdonnees
\ No newline at end of file
+ return nouvdates,nouvdonnees
\ No newline at end of file
projects / perso / Denise / oms.git / commitdiff
