Stable ids for auto labels, a summary for the label map, reading tools improved (D-131)
- Every auto label carries an id (<STATION>-<n>, labeling/ids.py), kept on edit, given to new labels by labeling.py and by the reviews; controle.py requires it, unique. The cross-review matches labels by id, and an applied review is locked (applique.md). - The label map starts with a summary (labels-map/sommaire.py): readers take the summary and sections 2-4 in full, then only the cards of the phenomena they meet. - Tool-builder session on the reviewers' difficulties: jours.py --lissage/--fraction, ensemble.py --suivre and rejected measures left out of --rigide, --residus non, zero noise after a lost reference, new agent-tools/stations.py (several stations on one timeline), long outputs convention in lire-les-donnees. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
d55de98746
commit
c6e9df0e46
41 files changed
+1596
-1075
No files matched your search
+52
-26
@@ -2,7 +2,7 @@
|
||||
|
||||
Usage : .venv/bin/python agent-tools/ensemble.py data/PS_DES_COUDRES/
|
||||
[--colonnes x,y,sigma0] [--colonne error_value] [--pas 15min] [--k 5] [--min 5]
|
||||
[--residus corr_x,corr_y,error_value] [--hors T1/T2] [--autres] [--rigide BASE [--sans A,B]] [--table T1/T2|non] [--capteurs A,B] [--debut ...] [--fin ...] [--sortie DOSSIER]
|
||||
[--residus corr_x,corr_y,error_value] [--hors T1/T2] [--autres] [--rigide BASE [--sans A,B] [--suivre A,B]] [--table T1/T2|non] [--capteurs A,B] [--debut ...] [--fin ...] [--sortie DOSSIER]
|
||||
|
||||
Chaque capteur est comparé à son propre niveau sur la fenêtre --debut/--fin (médiane et MAD de la fenêtre).
|
||||
Deux PNG, dont les chemins sont imprimés :
|
||||
@@ -20,7 +20,8 @@ Deux PNG, dont les chemins sont imprimés :
|
||||
donné : le niveau est alors celui du reste de la fenêtre, pas celui du moment lu), une échelle par capteur, zéro en
|
||||
pointillé ; un écart de quelques centièmes sur une colonne `corr` que les bandes parallèles de `graphique.py` cachent
|
||||
s'y voit. Imprime, par capteur, le niveau, le bruit propre (médiane des écarts entre deux mesures consécutives) et
|
||||
l'écart minimum et maximum de la médiane par pas de --pas, avec leur instant, en unités de la colonne et en bruits.
|
||||
l'écart minimum et maximum de la médiane par pas de --pas, avec leur instant, en unités de la colonne et en bruits
|
||||
(bruit 0 et « - » en bruits : valeurs constantes à l'arrondi près, 1e-9 ; --residus non : aucun PNG de résidus).
|
||||
Avec --autres, chaque capteur est de plus ramené à l'écart à la médiane des AUTRES capteurs au même instant (on
|
||||
retranche, à chaque mesure, la médiane des autres capteurs de la même colonne moins leur niveau propre) : ce qui est
|
||||
partagé par tous (le reste de la compensation d'un mouvement commun) s'annule, ce qui est propre au capteur reste.
|
||||
@@ -32,8 +33,11 @@ Deux PNG, dont les chemins sont imprimés :
|
||||
capteur, le résidu dx, dy = position brute moins sa position à BASE transportée par ce mouvement [px]. Panneaux :
|
||||
dx et dy de chaque référence globale (un trait chacune) face à la médiane et au 10e-90e centile des cibles ;
|
||||
médiane et 90e centile de |résidu| des cibles ; rotation et échelle ajustées ; reproj_err des références. Imprime
|
||||
la table par pas de --pas (rot_deg, echelle, tx, ty, cib_med, cib_max, puis dx, dy de chaque référence), puis par
|
||||
capteur le min et le max de dx, dy avec leur instant et la valeur au dernier instant.
|
||||
la table par pas de --pas (rot_deg, echelle, tx, ty, cib_med, cib_max, puis dx, dy de chaque référence et de chaque
|
||||
capteur de --suivre A,B), puis par capteur le min et le max de dx, dy avec leur instant et la valeur au dernier
|
||||
instant. Les mesures rejetées n'entrent ni dans l'ajustement, ni dans la bande et la médiane des cibles, cib_med,
|
||||
cib_max, ni dans les colonnes de la table ; sur le PNG, celles des références sont des croix, qui ne fixent pas l'échelle ; dans le résumé par
|
||||
capteur, elles viennent à part (nombre, min et max).
|
||||
Imprime aussi la table de la médiane commune (une ligne par pas de --pas : heure, écart à la médiane de la fenêtre
|
||||
pour chaque colonne de --colonnes, puis <colonne>_cibles, la médiane des cibles seules, puis la pose brute de la caméra, vide sans recalage) puis le minimum et le maximum de chaque colonne avec leur instant, et ceux de chaque référence globale ; pour dater
|
||||
un début ou une fin, la table est au pas de --pas (défaut 15min, la cadence des mesures ; un pas plus large,
|
||||
@@ -60,7 +64,7 @@ import matplotlib.pyplot as plt # noqa: E402
|
||||
|
||||
from donnees import POSE, charger, charger_camera, est_reference, filtrer, instant, iso, rejetee # noqa: E402
|
||||
from graphique import COLONNES, RACINE, borne # noqa: E402
|
||||
from resume import duree # noqa: E402
|
||||
from resume import bruit_propre, duree # noqa: E402
|
||||
|
||||
|
||||
def niveau(ms, col):
|
||||
@@ -90,12 +94,14 @@ def rigide(o, noms, series, temps, base, station):
|
||||
t_b = min(temps, key=lambda t: abs(t - o.rigide))
|
||||
pos = {s: {m["t"]: (m["x"], m["y"]) for m in series[s] if m["x"] is not None and m["y"] is not None} for s in noms}
|
||||
sans = set(o.sans.split(",")) - {""}
|
||||
acc = {s: {m["t"] for m in series[s] if not rejetee(m)} for s in noms} # mesures acceptées : seules à entrer dans l'ajustement et les statistiques des cibles
|
||||
refs = [s for s in noms if series[s] and est_reference(series[s])]
|
||||
cib = [s for s in noms if s not in refs and t_b in pos[s]]
|
||||
ajust = [s for s in cib if s not in sans]
|
||||
ajust = [s for s in cib if s not in sans and t_b in acc[s]]
|
||||
suivis = [s for s in o.suivre.split(",") if s and s not in refs]
|
||||
res, fit = {s: {} for s in noms}, {} # res : {capteur: {t: (dx, dy)}} ; fit : {t: (rotation deg, échelle, tx, ty, |r| médiane, max des cibles)}
|
||||
for t in temps:
|
||||
ok = [s for s in ajust if t in pos[s]]
|
||||
ok = [s for s in ajust if t in pos[s] and t in acc[s]]
|
||||
if len(ok) < 2:
|
||||
continue
|
||||
a, b, tx, ty = similitude([pos[s][t_b] for s in ok], [pos[s][t] for s in ok])
|
||||
@@ -103,7 +109,7 @@ def rigide(o, noms, series, temps, base, station):
|
||||
if t in pos[s] and t_b in pos[s]:
|
||||
(x0, y0), (x, y) = pos[s][t_b], pos[s][t]
|
||||
res[s][t] = (x - (a * x0 - b * y0 + tx), y - (b * x0 + a * y0 + ty))
|
||||
r = [math.hypot(*res[s][t]) for s in cib if t in res[s]]
|
||||
r = [math.hypot(*res[s][t]) for s in cib if t in res[s] and t in acc[s]]
|
||||
fit[t] = (math.degrees(math.atan2(b, a)), math.hypot(a, b), tx, ty, statistics.median(r), max(r))
|
||||
if not fit:
|
||||
print(f"\n--rigide : moins de deux cibles avec x, y à {iso(t_b)} et ensuite.")
|
||||
@@ -113,16 +119,23 @@ def rigide(o, noms, series, temps, base, station):
|
||||
panneaux = [("dx", 0), ("dy", 1)]
|
||||
fig, axes = plt.subplots(6, 1, sharex=True, figsize=(14, 18), squeeze=False)
|
||||
for ax, (nom, k) in zip(axes[:2, 0], panneaux):
|
||||
band = [sorted(res[s][t][k] for s in cib if t in res[s]) for t in tf]
|
||||
band = [sorted(res[s][t][k] for s in cib if t in res[s] and t in acc[s]) for t in tf]
|
||||
q = [statistics.quantiles(v, n=10, method="inclusive") if len(v) >= 2 else [v[0]] * 9 for v in band]
|
||||
ax.fill_between(tf, [x[0] for x in q], [x[-1] for x in q], color="0.85", label="cibles : 10e-90e centile")
|
||||
ax.plot(tf, [statistics.median(v) for v in band], "-", lw=1.2, color="k", label="cibles : médiane")
|
||||
for i, s in enumerate(refs):
|
||||
ax.plot(list(res[s]), [v[k] for v in res[s].values()], "-", lw=0.9, color=f"C{(i + 1) % 10}", label=f"{s} (réf.)")
|
||||
ta = [t for t in res[s] if t in acc[s]]
|
||||
ax.plot(ta, [res[s][t][k] for t in ta], "-", lw=0.9, color=f"C{(i + 1) % 10}", label=f"{s} (réf.)")
|
||||
cadre = ax.get_ylim() # l'échelle des mesures acceptées : une référence rejetée loin est hors cadre
|
||||
for i, s in enumerate(refs):
|
||||
tr = [t for t in res[s] if t not in acc[s]]
|
||||
if tr: # mesures rejetées : à part, une croix chacune, hors du trait
|
||||
ax.plot(tr, [res[s][t][k] for t in tr], "x", ms=3, color=f"C{(i + 1) % 10}", label=f"{s} rejetée")
|
||||
ax.set_ylim(cadre)
|
||||
ax.set_ylabel(f"{nom} [px]\nposition brute moins\nle mouvement des cibles")
|
||||
ax.legend(loc="upper left", fontsize=8, ncol=1 + len(refs) // 4)
|
||||
axes[2, 0].plot(tf, [fit[t][4] for t in tf], "-", lw=1, color="k", label="cibles : médiane de |résidu|")
|
||||
p90 = {t: statistics.quantiles([math.hypot(*res[s][t]) for s in cib if t in res[s]], n=10, method="inclusive")[-1] for t in tf}
|
||||
p90 = {t: statistics.quantiles([math.hypot(*res[s][t]) for s in cib if t in res[s] and t in acc[s]], n=10, method="inclusive")[-1] for t in tf}
|
||||
axes[2, 0].plot(tf, [p90[t] for t in tf], "-", lw=0.8, color="C3", label="cibles : 90e centile de |résidu| (le max est dans la table)")
|
||||
axes[2, 0].set_ylabel("|résidu| des cibles [px]")
|
||||
axes[2, 0].legend(loc="upper left", fontsize=8)
|
||||
@@ -141,7 +154,7 @@ def rigide(o, noms, series, temps, base, station):
|
||||
axes[-1, 0].set_xlim(tf[0], tf[-1])
|
||||
axes[-1, 0].xaxis.set_major_formatter(mdates.DateFormatter("%d/%m\n%H:%MZ"))
|
||||
fig.suptitle(f"{station} : mouvement d'ensemble (translation, rotation, échelle) ajusté sur {len(ajust)} cibles depuis {iso(t_b)} (pointillé), "
|
||||
"résidu de chaque capteur (heures UTC)")
|
||||
"résidu de chaque capteur, mesures acceptées (croix : référence rejetée) (heures UTC)")
|
||||
fig.tight_layout(rect=(0, 0, 1, 1 - 0.4 / fig.get_figheight()))
|
||||
chemin = base.format("rigide")
|
||||
fig.savefig(chemin, dpi=100, bbox_inches="tight")
|
||||
@@ -150,8 +163,9 @@ def rigide(o, noms, series, temps, base, station):
|
||||
|
||||
print(f"\nMouvement d'ensemble ajusté sur les cibles depuis {iso(t_b)} : {', '.join(ajust)}"
|
||||
+ (f" (hors ajustement : {', '.join(sorted(sans & set(cib)))})" if sans & set(cib) else "")
|
||||
+ f".\nRésidu = position brute moins la position de {iso(t_b)} transportée par ce mouvement [px] ; médiane par pas de {int(o.pas.total_seconds() // 60)} min{' (table : ' + o.table + ')' if o.table else ''} :")
|
||||
cols = ["rot_deg", "echelle", "tx", "ty", "cib_med", "cib_max"] + [f"{s}_{c}" for s in refs for c in ("dx", "dy")]
|
||||
+ f".\nRésidu = position brute moins la position de {iso(t_b)} transportée par ce mouvement [px] ; mesures rejetées hors de l'ajustement, "
|
||||
f"de cib_med, cib_max et des colonnes des capteurs (à part dans le résumé par capteur) ; médiane par pas de {int(o.pas.total_seconds() // 60)} min{' (table : ' + o.table + ')' if o.table else ''} :")
|
||||
cols = ["rot_deg", "echelle", "tx", "ty", "cib_med", "cib_max"] + [f"{s}_{c}" for s in refs + suivis for c in ("dx", "dy")]
|
||||
minuit = tf[0].replace(hour=0, minute=0, second=0, microsecond=0)
|
||||
t0 = minuit + ((tf[0] - minuit) // o.pas) * o.pas
|
||||
par_pas = {}
|
||||
@@ -159,8 +173,8 @@ def rigide(o, noms, series, temps, base, station):
|
||||
ligne = par_pas.setdefault(t0 + ((t - t0) // o.pas) * o.pas, {})
|
||||
for c, v in zip(cols, fit[t]):
|
||||
ligne.setdefault(c, []).append(v)
|
||||
for s in refs:
|
||||
if t in res[s]:
|
||||
for s in refs + suivis:
|
||||
if t in res[s] and t in acc[s]:
|
||||
ligne.setdefault(f"{s}_dx", []).append(res[s][t][0]), ligne.setdefault(f"{s}_dy", []).append(res[s][t][1])
|
||||
w = max(10, max(len(c) for c in cols) + 1)
|
||||
entete = f"{'instant':17}" + "".join(f"{c:>{w}}" for c in cols)
|
||||
@@ -168,12 +182,24 @@ def rigide(o, noms, series, temps, base, station):
|
||||
if i % 24 == 0:
|
||||
print(entete)
|
||||
print(f"{iso(t):17}" + "".join(f"{statistics.median(par_pas[t][c]):{w}.{7 if c == 'echelle' else 3}g}" if c in par_pas[t] else " " * w for c in cols))
|
||||
print("\nPar capteur, mesures acceptées : min et max de dx, dy, valeur au dernier instant ; puis les rejetées à part :")
|
||||
for s in noms:
|
||||
if res[s]:
|
||||
for k, c in ((0, "dx"), (1, "dy")):
|
||||
lo = min(res[s].items(), key=lambda x: x[1][k])
|
||||
hi = max(res[s].items(), key=lambda x: x[1][k])
|
||||
print(f"{s:9}{' (réf.)' if s in refs else ' '} {c} min {lo[1][k]:+.3g} à {iso(lo[0])}, max {hi[1][k]:+.3g} à {iso(hi[0])}, au dernier instant {res[s][tf[-1]][k] if tf[-1] in res[s] else math.nan:+.3g}")
|
||||
bons = {t: v for t, v in res[s].items() if t in acc[s]}
|
||||
rej = {t: v for t, v in res[s].items() if t not in acc[s]}
|
||||
for k, c in ((0, "dx"), (1, "dy")):
|
||||
ligne = f"{s:9}{' (réf.)' if s in refs else ' '} {c}"
|
||||
if bons:
|
||||
lo, hi = min(bons.items(), key=lambda x: x[1][k]), max(bons.items(), key=lambda x: x[1][k])
|
||||
der = res[s].get(tf[-1])
|
||||
ligne += (f" min {lo[1][k]:+.3g} à {iso(lo[0])}, max {hi[1][k]:+.3g} à {iso(hi[0])}, au dernier instant "
|
||||
f"{der[k] if der else math.nan:+.3g}{' (rejetée)' if der and tf[-1] not in acc[s] else ''}")
|
||||
else:
|
||||
ligne += " aucune mesure acceptée"
|
||||
if rej:
|
||||
lo, hi = min(rej.items(), key=lambda x: x[1][k]), max(rej.items(), key=lambda x: x[1][k])
|
||||
ligne += f" ; {len(rej)} rejetées : min {lo[1][k]:+.3g} à {iso(lo[0])}, max {hi[1][k]:+.3g} à {iso(hi[0])}"
|
||||
if bons or rej:
|
||||
print(ligne)
|
||||
|
||||
|
||||
def main():
|
||||
@@ -184,11 +210,12 @@ def main():
|
||||
a.add_argument("--pas", default="15min", type=duree, help="pas des tables et des courbes en bleu (défaut 15min, la cadence des mesures : un pas plus large aplatit et décale les événements courts)")
|
||||
a.add_argument("--k", type=float, default=5, help="écart compté, en MAD de la fenêtre")
|
||||
a.add_argument("--min", type=int, default=5, help="nombre de capteurs à partir duquel un instant est imprimé")
|
||||
a.add_argument("--residus", default="corr_x,corr_y,error_value", help="colonnes tracées moins le niveau propre de chaque capteur ('' : aucune)")
|
||||
a.add_argument("--residus", default="corr_x,corr_y,error_value", help="colonnes tracées moins le niveau propre de chaque capteur (« non » ou '' : aucune)")
|
||||
a.add_argument("--hors", help="T1/T2 : le niveau propre des résidus se calcule hors de ce moment")
|
||||
a.add_argument("--autres", action="store_true", help="résidus de plus ramenés à la médiane des autres capteurs au même instant, avec pente et corrélation sur le mouvement commun")
|
||||
a.add_argument("--rigide", type=instant, metavar="BASE", help="résidus face au mouvement d'ensemble des cibles (translation, rotation, échelle) depuis l'instant BASE")
|
||||
a.add_argument("--sans", default="", help="A,B : cibles laissées hors de l'ajustement de --rigide (leur résidu reste tracé)")
|
||||
a.add_argument("--suivre", default="", help="A,B : avec --rigide, dx, dy de ces capteurs ajoutés à la table au pas (les références y sont déjà)")
|
||||
a.add_argument("--table", default="", metavar="T1/T2|non",
|
||||
help="tables par pas imprimées seulement entre T1 et T2 (« non » : pas du tout) ; le reste sur toute la fenêtre")
|
||||
a.add_argument("--capteurs", help="liste séparée par des virgules (défaut : tous)")
|
||||
@@ -202,7 +229,7 @@ def main():
|
||||
sys.exit(f"Aucun export « advanced » dans {o.dossier} (voir inventaire.py).")
|
||||
noms = o.capteurs.split(",") if o.capteurs else sorted(par, key=lambda s: (not est_reference(par[s]), s))
|
||||
colonnes = o.colonnes.split(",")
|
||||
residus = [c for c in o.residus.split(",") if c]
|
||||
residus = [c for c in o.residus.split(",") if c and c != "non"] # '' ou « non » : aucune, comme --table
|
||||
hors = tuple(instant(x) for x in o.hors.split("/")) if o.hors else None
|
||||
if hors and len(hors) != 2:
|
||||
sys.exit("--hors attend T1/T2.")
|
||||
@@ -213,7 +240,7 @@ def main():
|
||||
if len(bornes) != 2:
|
||||
sys.exit("--table attend T1/T2 ou non.")
|
||||
o.dans_table = lambda t: bornes[0] <= t <= bornes[1]
|
||||
for demandes, connus, quoi in ((noms, par, "Capteurs"), (colonnes + residus + [o.colonne], COLONNES, "Colonnes")):
|
||||
for demandes, connus, quoi in ((noms, par, "Capteurs"), ([s for s in o.suivre.split(",") if s], noms, "Capteurs de --suivre (pris parmi --capteurs)"), (colonnes + residus + [o.colonne], COLONNES, "Colonnes")):
|
||||
absents = [x for x in demandes if x not in connus]
|
||||
if absents:
|
||||
sys.exit(f"{quoi} inconnus : {', '.join(absents)}. Connus : {', '.join(sorted(connus))}.")
|
||||
@@ -404,8 +431,7 @@ def main():
|
||||
if not lv:
|
||||
ax.axis("off")
|
||||
continue
|
||||
d = [abs(b[col] - a_[col]) for a_, b in zip(ms, ms[1:])]
|
||||
bruit = statistics.median(d) if d else 0
|
||||
bruit = bruit_propre([m[col] for m in ms])
|
||||
if autres:
|
||||
res = {}
|
||||
for m in ms:
|
||||
|
||||
+40
-21
@@ -1,7 +1,8 @@
|
||||
"""Ce qui revient d'un jour à l'autre : niveau de chaque nuit, et jours superposés par heure du jour, pour l'agent de diagnostic.
|
||||
|
||||
Usage : .venv/bin/python agent-tools/jours.py data/PS_DES_COUDRES/ [--colonnes corr_x,corr_y,error_value]
|
||||
[--nuit 20-3] [--k 5] [--jours 2] [--pas 15min] [--capteurs A,B] [--bornes] [--debut ...] [--fin ...] [--sortie DOSSIER]
|
||||
[--nuit 20-3] [--k 5] [--jours 2] [--pas 15min] [--capteurs A,B] [--bornes [--lissage N] [--fraction F]]
|
||||
[--debut ...] [--fin ...] [--sortie DOSSIER]
|
||||
|
||||
Mesures acceptées seulement : une mesure rejetée (error_value au-dessus du seuil) n'entre nulle part. Une « nuit » :
|
||||
les heures --nuit H1-H2 (UTC, H1 inclus, H2 exclu, à cheval sur minuit si H1 > H2), datée du jour où elle commence ;
|
||||
@@ -30,7 +31,13 @@ la nuit en cours au début de la fenêtre compte aussi (ses heures après minuit
|
||||
instant où |écart| dépasse --k bruits, avec la mesure juste avant et juste après (au pas natif) ; le maximum et le
|
||||
minimum signés et leur instant ; autour du plus grand des deux en valeur absolue, la suite de mesures consécutives
|
||||
au-delà de --k bruits du même côté qui le contient, avec la mesure juste avant et juste après ; la nuit suivante
|
||||
moins la nuit de référence. Un jour sans mesure le dit. PNG
|
||||
moins la nuit de référence. Un jour sans mesure le dit. Chaque ligne de jour commence par le nom court de la suite
|
||||
(la colonne, ou pose_tilt…) : `| grep '^pose_tilt '` en garde une, `| grep ' 12/10 '` un jour. Avec --lissage N,
|
||||
l'écart de chaque mesure est la médiane des N mesures du jour centrées sur elle (le bruit reste celui des mesures,
|
||||
la figure trace aussi l'écart brut en gris) : un point isolé ne coupe plus la suite autour de l'extrême et ne fait
|
||||
plus un premier ou un dernier dépassement. Avec --fraction F, le seuil de chaque jour est F fois le plus grand
|
||||
|écart| de ce jour (au lieu de --k bruits ; il est imprimé sur la ligne du jour) : sur une suite très bruitée, ou
|
||||
dont le bruit au pas natif est sans rapport avec l'ampleur du cycle. PNG
|
||||
« bornes » : un panneau par suite, l'écart sur le lot, ±k bruits en pointillé, de chaque jour [premier, dernier]
|
||||
grisé clair et la suite autour de l'extrême grisée foncé, le maximum et le minimum marqués ; cadré du 1er au 99e
|
||||
centile élargi de moitié (le titre dit combien de mesures sortent du cadre).
|
||||
@@ -50,7 +57,7 @@ import matplotlib.pyplot as plt # noqa: E402
|
||||
|
||||
from donnees import POSE, charger, charger_camera, est_reference, filtrer, instant, iso, rejetee # noqa: E402
|
||||
from graphique import COLONNES, RACINE, borne # noqa: E402
|
||||
from resume import duree # noqa: E402
|
||||
from resume import ARRONDI, bruit_propre, duree # noqa: E402
|
||||
|
||||
|
||||
def heures(texte):
|
||||
@@ -89,6 +96,8 @@ def main():
|
||||
a.add_argument("--pas", default="15min", type=duree, help="largeur des créneaux de l'heure du jour (défaut 15min)")
|
||||
a.add_argument("--capteurs", help="liste séparée par des virgules (défaut : tous)")
|
||||
a.add_argument("--bornes", action="store_true", help="ajoute, jour par jour, les bornes de l'écart au niveau de la nuit précédente")
|
||||
a.add_argument("--lissage", type=int, default=1, metavar="N", help="--bornes : écart lissé par la médiane de N mesures centrées (défaut 1 : aucun)")
|
||||
a.add_argument("--fraction", type=float, metavar="F", help="--bornes : seuil de chaque jour = F fois son plus grand |écart| (au lieu de --k bruits)")
|
||||
a.add_argument("--debut", type=instant)
|
||||
a.add_argument("--fin", type=instant)
|
||||
a.add_argument("--sortie", default=os.path.join(RACINE, "out", "diagnostic"), help="dossier des PNG")
|
||||
@@ -123,7 +132,7 @@ def main():
|
||||
print(f"{s:9}(moins de 2 valeurs acceptées)")
|
||||
ax.axis("off")
|
||||
continue
|
||||
bruit = bruits[s] = statistics.median(abs(b[1] - a_[1]) for a_, b in zip(ms, ms[1:]))
|
||||
bruit = bruits[s] = bruit_propre([v for _, v in ms])
|
||||
nuits = {}
|
||||
for t, v in ms:
|
||||
if de_nuit(t, h1, h2):
|
||||
@@ -222,21 +231,23 @@ def bornes(o, noms, series, colonnes, station):
|
||||
h1, h2 = o.nuit
|
||||
duree_nuit = timedelta(hours=(h2 - h1) % 24)
|
||||
choisis = noms if o.capteurs else [s for s in noms if series[s] and not est_reference(series[s])] or noms
|
||||
suites = [(f"{col} médiane de {len(choisis)} capteur(s)" if len(choisis) > 1 else f"{col} {choisis[0]}",
|
||||
suites = [(f"{col} médiane de {len(choisis)} capteur(s)" if len(choisis) > 1 else f"{col} {choisis[0]}", col,
|
||||
{s: [(m["t"], m[col]) for m in series[s] if m[col] is not None] for s in choisis}) for col in colonnes]
|
||||
poses = filtrer(charger_camera(o.dossier), o.debut, o.fin)
|
||||
suites += [(f"pose {c}", {c: [(p["t"], p[c]) for p in poses if p[c] is not None]}) for c in POSE
|
||||
suites += [(f"pose {c}", f"pose_{c}", {c: [(p["t"], p[c]) for p in poses if p[c] is not None]}) for c in POSE
|
||||
if any(p[c] is not None for p in poses)]
|
||||
tous = [t for _, d in suites for p in d.values() for t, _ in p]
|
||||
tous = [t for _, _, d in suites for p in d.values() for t, _ in p]
|
||||
t0, t1 = min(tous), max(tous)
|
||||
nuit_de = lambda t: (t - duree_nuit - timedelta(hours=h1)).date() # nuit qui finit avant t (le jour de t commence à sa fin)
|
||||
jours = [nuit_de(t0) + timedelta(days=i) for i in range((nuit_de(t1) - nuit_de(t0)).days + 1)]
|
||||
hm = lambda t: f"{t:%d/%m %H:%M}"
|
||||
print(f"\n== Bornes de chaque jour : écart au niveau de la nuit qui le précède ({h1} h → {h2} h UTC), seuil {o.k:g} bruits ==")
|
||||
seuil_txt = f"seuil {o.fraction:g} fois le plus grand |écart| du jour" if o.fraction else f"seuil {o.k:g} bruits"
|
||||
print(f"\n== Bornes de chaque jour : écart au niveau de la nuit qui le précède ({h1} h → {h2} h UTC), {seuil_txt}"
|
||||
+ (f", écart lissé sur {o.lissage} mesures" if o.lissage > 1 else "") + " ==")
|
||||
print("jour : de la fin d'une nuit à la fin de la suivante, daté de son début ; « avant », « après » : mesure juste avant le premier "
|
||||
"dépassement, juste après le dernier ; nuit suivante : son niveau moins celui de la nuit de référence")
|
||||
fig, axes = plt.subplots(len(suites), 1, sharex=True, figsize=(18, 2.2 * len(suites)), squeeze=False)
|
||||
for ax, (nom, par_capteur) in zip(axes.flat, suites):
|
||||
for ax, (nom, court, par_capteur) in zip(axes.flat, suites):
|
||||
niv = {s: niveaux_de_nuit(p, h1, h2) for s, p in par_capteur.items()}
|
||||
nuits = sorted({d for n in niv.values() for d in n})
|
||||
ecarts = [] # (jour, nuit de réf., [(t, écart)], écart de la nuit suivante)
|
||||
@@ -255,39 +266,46 @@ def bornes(o, noms, series, colonnes, station):
|
||||
statistics.median(suivante) if suivante else None))
|
||||
diffs = [abs(b[1] - a_[1]) for *_, p, _ in ecarts for a_, b in zip(p, p[1:])]
|
||||
bruit = statistics.median(diffs) if diffs else 0
|
||||
bruit = bruit if bruit >= ARRONDI else 0
|
||||
print(f"\n{nom} : bruit {bruit:.3g}")
|
||||
enb = lambda e: f"{e:+.4g} ({e / bruit:+.1f})" if bruit else f"{e:+.4g}"
|
||||
for jour, d, ref, p, suiv in ecarts:
|
||||
if not p:
|
||||
print(f"{jour:%d/%m} aucune mesure" + ("" if nuits else " de nuit"))
|
||||
h = o.lissage // 2
|
||||
for jour, d, ref, brut, suiv in ecarts:
|
||||
if not brut:
|
||||
print(f"{court} {jour:%d/%m} aucune mesure" + ("" if nuits else " de nuit"))
|
||||
continue
|
||||
ligne = f"{jour:%d/%m} nuit {ref:%d/%m}" + (" (pas la précédente)" if ref != d else "") + f" | {len(p)} mesures {hm(p[0][0])} → {hm(p[-1][0])} | "
|
||||
hors = [i for i, (_, e) in enumerate(p) if bruit and abs(e) > o.k * bruit]
|
||||
p = [(t, statistics.median(e for _, e in brut[max(0, i - h):i + h + 1])) for i, (t, _) in enumerate(brut)] if h else brut
|
||||
seuil = o.fraction * max(abs(e) for _, e in p) if o.fraction else o.k * bruit
|
||||
ligne = (f"{court} {jour:%d/%m} nuit {ref:%d/%m}" + (" (pas la précédente)" if ref != d else "") + f" | {len(p)} mesures {hm(p[0][0])} → {hm(p[-1][0])} | "
|
||||
+ (f"seuil {seuil:.4g} | " if o.fraction else ""))
|
||||
hors = [i for i, (_, e) in enumerate(p) if seuil and abs(e) > seuil]
|
||||
if hors:
|
||||
i, j = hors[0], hors[-1]
|
||||
ligne += (f"> {o.k:g} bruits : {len(hors)} mesures, de {hm(p[i][0])} (avant {hm(p[i - 1][0]) if i else '-'}) "
|
||||
ligne += (f"> {'seuil' if o.fraction else f'{o.k:g} bruits'} : {len(hors)} mesures, de {hm(p[i][0])} (avant {hm(p[i - 1][0]) if i else '-'}) "
|
||||
f"à {hm(p[j][0])} (après {hm(p[j + 1][0]) if j + 1 < len(p) else '-'})")
|
||||
ax.axvspan(p[i][0], p[j][0], color="0.85", lw=0)
|
||||
else:
|
||||
ligne += f"jamais > {o.k:g} bruits"
|
||||
ligne += f"jamais > {'seuil' if o.fraction else f'{o.k:g} bruits'}"
|
||||
haut, bas = max(p, key=lambda x: x[1]), min(p, key=lambda x: x[1])
|
||||
ligne += f" | max {enb(haut[1])} à {hm(haut[0])}, min {enb(bas[1])} à {hm(bas[0])}"
|
||||
x = max(range(len(p)), key=lambda i: abs(p[i][1]))
|
||||
signe = 1 if p[x][1] > 0 else -1
|
||||
if bruit and signe * p[x][1] > o.k * bruit:
|
||||
if seuil and signe * p[x][1] > seuil:
|
||||
i = j = x
|
||||
while i > 0 and signe * p[i - 1][1] > o.k * bruit:
|
||||
while i > 0 and signe * p[i - 1][1] > seuil:
|
||||
i -= 1
|
||||
while j + 1 < len(p) and signe * p[j + 1][1] > o.k * bruit:
|
||||
while j + 1 < len(p) and signe * p[j + 1][1] > seuil:
|
||||
j += 1
|
||||
ligne += (f" | autour du {'max' if signe > 0 else 'min'} : {j - i + 1} mesures, de {hm(p[i][0])} (avant {hm(p[i - 1][0]) if i else '-'}) "
|
||||
f"à {hm(p[j][0])} (après {hm(p[j + 1][0]) if j + 1 < len(p) else '-'})")
|
||||
ax.axvspan(p[i][0], p[j][0], color="0.7", lw=0)
|
||||
ligne += f" | nuit suivante {enb(suiv)}" if suiv is not None else " | nuit suivante non mesurée"
|
||||
print(ligne)
|
||||
if h:
|
||||
ax.plot([t for t, _ in brut], [e for _, e in brut], "-", lw=0.5, color="0.6")
|
||||
ax.plot([t for t, _ in p], [e for _, e in p], "-", lw=0.8, color="C0")
|
||||
ax.plot([haut[0], bas[0]], [haut[1], bas[1]], "o", ms=3, color="C3")
|
||||
if bruit:
|
||||
if bruit and not o.fraction:
|
||||
for y in (o.k * bruit, -o.k * bruit):
|
||||
ax.axhline(y, color="0.4", ls=":", lw=0.8)
|
||||
ax.axhline(0, color="0.3", lw=0.5)
|
||||
@@ -302,7 +320,8 @@ def bornes(o, noms, series, colonnes, station):
|
||||
ax.grid(alpha=0.3)
|
||||
ax.tick_params(labelsize=7)
|
||||
fig.suptitle(f"{station} : écart au niveau de la nuit qui précède chaque jour ({h1} h → {h2} h) ; "
|
||||
f"grisé clair : du premier au dernier dépassement de {o.k:g} bruits, foncé : la suite autour de l'extrême ; points : max et min du jour")
|
||||
f"grisé clair : du premier au dernier dépassement {'du seuil (' + seuil_txt + ')' if o.fraction else f'de {o.k:g} bruits'}, foncé : la suite autour de l'extrême ; points : max et min du jour"
|
||||
+ (f" ; écart lissé sur {o.lissage} mesures (bleu), brut (gris)" if o.lissage > 1 else ""))
|
||||
fig.tight_layout()
|
||||
chemin = os.path.join(o.sortie, f"{station}_bornes_{borne(o.debut, 'debut')}_{borne(o.fin, 'fin')}.png")
|
||||
fig.savefig(chemin, dpi=100, bbox_inches="tight")
|
||||
|
||||
@@ -34,7 +34,7 @@ import statistics
|
||||
import sys
|
||||
|
||||
from donnees import charger, est_reference, filtrer, instant, iso, rejetee
|
||||
from resume import COLONNES, duree
|
||||
from resume import COLONNES, bruit_propre, duree
|
||||
|
||||
ABREGE = {"corr_x": "cx", "corr_y": "cy", "error_value": "ev"}
|
||||
|
||||
@@ -101,7 +101,7 @@ def main():
|
||||
continue
|
||||
niv = statistics.median(v for _, v in ref)
|
||||
sauts = [(b[1] - a_[1], a_[0], b[0]) for a_, b in zip(ms, ms[1:])]
|
||||
bruit = statistics.median(abs(b[1] - a_[1]) for a_, b in zip(ref, ref[1:]))
|
||||
bruit = bruit_propre([v for _, v in ref])
|
||||
d, t1, t2 = max(sauts, key=lambda x: abs(x[0]))
|
||||
bru = f"{d / bruit:9.1f}" if bruit else f"{'-':>9}"
|
||||
marque = [iso(x) for x in (t1, t2) if x in rej]
|
||||
|
||||
@@ -39,6 +39,18 @@ def duree(texte):
|
||||
return {"min": timedelta(minutes=n), "h": timedelta(hours=n), "d": timedelta(days=n)}[unite]
|
||||
|
||||
|
||||
ARRONDI = 1e-9 # en deçà, un écart entre deux mesures est l'arrondi du calcul de la station, pas un bruit
|
||||
|
||||
|
||||
def bruit_propre(vs):
|
||||
"""Médiane des écarts absolus entre deux valeurs consécutives ; 0 quand elle est sous ARRONDI (valeurs constantes
|
||||
à l'arrondi près : le corr des références quand la compensation passe exactement par elles, deux références
|
||||
retenues), pour qu'un écart ne s'écrive pas en milliards de bruits ; 0 aussi avec moins de deux valeurs."""
|
||||
d = [abs(b - a) for a, b in zip(vs, vs[1:])]
|
||||
b = statistics.median(d) if d else 0
|
||||
return b if b >= ARRONDI else 0
|
||||
|
||||
|
||||
def valeurs(ms, col):
|
||||
return [m[col] for m in ms if m[col] is not None]
|
||||
|
||||
|
||||
@@ -0,0 +1,194 @@
|
||||
"""Plusieurs stations sur une même ligne de temps : température du boîtier, pose de la caméra, corr des cibles, rejets, trous.
|
||||
|
||||
Usage : .venv/bin/python agent-tools/stations.py data/BREITHORN data/MICHIGAN data/NEBRASKA
|
||||
[--colonnes temperature,cam_tilt,cam_rotation,cam_scale,cib_corr_x,cib_corr_y] [--pas 1h] [--stat median|min|max]
|
||||
[--table T1/T2|non] [--debut ...] [--fin ...] [--sortie DOSSIER]
|
||||
|
||||
Pour chaque station (un dossier de station chacune), sur la fenêtre --debut/--fin :
|
||||
- colonnes possibles : temperature (médiane des composants sensor_*_deg_c, comme metriques.py), cam_pan, cam_tilt,
|
||||
cam_rotation, cam_scale, cam_sigma0 (pose brute de la caméra), cib_corr_x, cib_corr_y (médiane sur les cibles de
|
||||
corr moins le niveau propre de chaque cible, mesures acceptées, comme metriques.py), rej_cibles, rej_refs (nombre de
|
||||
cibles, de références rejetées : le plus grand des instants de mesure du pas) ;
|
||||
- imprime, par station, la période des mesures, la cadence (pas médian) et le nombre d'instants ; puis les **trous** :
|
||||
les suites de pas de --pas sans mesure ou sans température, avec les stations où elles manquent (un trou commun à
|
||||
plusieurs stations y est sur une seule ligne) ; puis la table, une ligne par pas (début du pas, UTC ; --stat des
|
||||
valeurs du pas ; « - » : aucune valeur), une colonne par station et par colonne, séparées par des tabulations
|
||||
(--table T1/T2 : seulement entre T1 et T2, « non » : pas du tout ; le reste porte sur toute la fenêtre) ; puis, pour
|
||||
chaque colonne et chaque paire de stations, la corrélation r des valeurs et celle des pas (différence d'une valeur à
|
||||
la suivante, sur les pas où les deux stations ont une valeur : un mouvement commun se voit sur les pas, une tendance
|
||||
commune sur les valeurs), avec le nombre de pas ;
|
||||
- un PNG « stations » : un panneau par colonne, un trait par station (température brute ; les autres colonnes moins
|
||||
leur médiane sur la fenêtre, pour se superposer), coupé sur un trou ; trous de mesure grisés sous l'axe, une bande
|
||||
par station.
|
||||
Jamais d'identifiant de metrics/ (SIM_CCID, ip*) : seules les températures y sont lues. Rend des valeurs, pas de verdict.
|
||||
"""
|
||||
import argparse
|
||||
import os
|
||||
import statistics
|
||||
import sys
|
||||
|
||||
import matplotlib
|
||||
|
||||
matplotlib.use("Agg")
|
||||
import matplotlib.dates as mdates # noqa: E402
|
||||
import matplotlib.pyplot as plt # noqa: E402
|
||||
|
||||
from donnees import POSE, charger, charger_camera, charger_temperature, est_reference, filtrer, instant, iso, rejetee # noqa: E402
|
||||
from graphique import RACINE, borne # noqa: E402
|
||||
from metriques import cibles, coupe, suites # noqa: E402
|
||||
from resume import STATS, duree # noqa: E402
|
||||
|
||||
COLONNES = ("temperature",) + tuple("cam_" + c for c in POSE) + ("cib_corr_x", "cib_corr_y", "rej_cibles", "rej_refs")
|
||||
|
||||
|
||||
def lire(dossier, debut, fin):
|
||||
"""Dossier de station -> ({colonne: [{'t', 'v'}]}, [instants de mesure])."""
|
||||
par = charger(dossier)
|
||||
series = {"temperature": filtrer([{"t": t, "v": v} for t, v in charger_temperature(dossier)], debut, fin)}
|
||||
for p in filtrer(charger_camera(dossier), debut, fin):
|
||||
for c in POSE:
|
||||
if p[c] is not None:
|
||||
series.setdefault("cam_" + c, []).append({"t": p["t"], "v": p[c]})
|
||||
for c in ("corr_x", "corr_y"):
|
||||
series["cib_" + c] = cibles(par, c, debut, fin)
|
||||
rej = {} # t -> [cibles rejetées, références rejetées]
|
||||
for s, ms in par.items():
|
||||
ref = est_reference(ms)
|
||||
for m in filtrer(ms, debut, fin):
|
||||
n = rej.setdefault(m["t"], [0, 0])
|
||||
n[ref] += rejetee(m)
|
||||
series["rej_cibles"] = [{"t": t, "v": float(n[0])} for t, n in sorted(rej.items())]
|
||||
series["rej_refs"] = [{"t": t, "v": float(n[1])} for t, n in sorted(rej.items())]
|
||||
return series, sorted(rej)
|
||||
|
||||
|
||||
def correlation(a, b):
|
||||
try:
|
||||
return f"{statistics.correlation(a, b):+.2f}"
|
||||
except (statistics.StatisticsError, ValueError):
|
||||
return "-"
|
||||
|
||||
|
||||
def main():
|
||||
a = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
|
||||
a.add_argument("dossiers", nargs="+", help="dossiers de station, au moins deux")
|
||||
a.add_argument("--colonnes", default="temperature,cam_tilt,cam_rotation,cam_scale,cib_corr_x,cib_corr_y")
|
||||
a.add_argument("--pas", default="1h", type=duree)
|
||||
a.add_argument("--stat", default="median", choices=STATS)
|
||||
a.add_argument("--table", default="", metavar="T1/T2|non", help="table imprimée seulement entre T1 et T2 (« non » : pas du tout)")
|
||||
a.add_argument("--debut", type=instant)
|
||||
a.add_argument("--fin", type=instant)
|
||||
a.add_argument("--sortie", default=os.path.join(RACINE, "out", "diagnostic"), help="dossier du PNG")
|
||||
o = a.parse_args()
|
||||
colonnes = o.colonnes.split(",")
|
||||
if absents := [c for c in colonnes if c not in COLONNES]:
|
||||
sys.exit(f"Colonnes inconnues : {', '.join(absents)}. Connues : {', '.join(COLONNES)}.")
|
||||
if o.table in ("", "non"):
|
||||
dans_table = lambda t: o.table == "" # noqa: E731
|
||||
else:
|
||||
bornes = [instant(x) for x in o.table.split("/")]
|
||||
if len(bornes) != 2:
|
||||
sys.exit("--table attend T1/T2 ou non.")
|
||||
dans_table = lambda t: bornes[0] <= t <= bornes[1] # noqa: E731
|
||||
|
||||
noms = [os.path.basename(os.path.normpath(d)) for d in o.dossiers]
|
||||
donnees, mesures = {}, {}
|
||||
for n, d in zip(noms, o.dossiers):
|
||||
donnees[n], mesures[n] = lire(d, o.debut, o.fin)
|
||||
tous = [p["t"] for s in donnees.values() for c in s.values() for p in c]
|
||||
if not tous:
|
||||
sys.exit("Aucune valeur dans la fenêtre demandée.")
|
||||
t0 = (o.debut or min(tous)).replace(minute=0, second=0, microsecond=0)
|
||||
t1 = o.fin or max(tous)
|
||||
grille = [t0 + i * o.pas for i in range(int((t1 - t0) / o.pas) + 1)]
|
||||
case = lambda t: t0 + ((t - t0) // o.pas) * o.pas # noqa: E731
|
||||
|
||||
print("Stations :")
|
||||
for n in noms:
|
||||
ts = mesures[n]
|
||||
if not ts:
|
||||
print(f" {n} : aucune mesure dans la fenêtre")
|
||||
continue
|
||||
cad = statistics.median(b - a_ for a_, b in zip(ts, ts[1:])) if len(ts) > 1 else None
|
||||
print(f" {n} : mesures {iso(ts[0])} → {iso(ts[-1])}, {len(ts)} instants, cadence {round(cad.total_seconds() / 60) if cad else '-'} min ; "
|
||||
+ ", ".join(f"{c} {len(donnees[n].get(c, []))}" for c in colonnes))
|
||||
|
||||
# trous : pas sans mesure, sans température, et les stations concernées
|
||||
avec = {n: {case(t) for t in mesures[n]} for n in noms}
|
||||
avec_t = {n: {case(p["t"]) for p in donnees[n]["temperature"]} for n in noms}
|
||||
print(f"\nTrous (pas de {int(o.pas.total_seconds() // 60)} min sans mesure ou sans température), avec les stations où ils manquent :")
|
||||
cles = {}
|
||||
for k in grille:
|
||||
m = tuple(n for n in noms if k not in avec[n])
|
||||
t = tuple(n for n in noms if k not in avec_t[n])
|
||||
if m or t:
|
||||
cles.setdefault((m, t), []).append(k)
|
||||
lignes = []
|
||||
for (m, t), ks in cles.items():
|
||||
for d, f, nb in suites(ks, o.pas):
|
||||
lignes.append((d, f, nb, m, t))
|
||||
for d, f, nb, m, t in sorted(lignes):
|
||||
print(f" {iso(d)} → {iso(f)} ({nb} pas) : sans mesure {','.join(m) or '-'} ; sans température {','.join(t) or '-'}")
|
||||
if not lignes:
|
||||
print(" (aucun)")
|
||||
|
||||
stat = STATS[o.stat]
|
||||
table = {} # (station, colonne) -> {pas: valeur}
|
||||
for n in noms:
|
||||
for c in colonnes:
|
||||
cases = {}
|
||||
for p in donnees[n].get(c, []):
|
||||
cases.setdefault(case(p["t"]), []).append(p["v"])
|
||||
table[n, c] = {k: stat(v) for k, v in cases.items()}
|
||||
entete = [f"{n}:{c}" for n in noms for c in colonnes]
|
||||
print(f"\n{o.stat} par pas de {int(o.pas.total_seconds() // 60)} min (début du pas, UTC) ; « - » : aucune valeur"
|
||||
+ (f" (table : {o.table})" if o.table else "") + " :")
|
||||
if o.table != "non":
|
||||
print("\t".join(["heure"] + entete))
|
||||
for k in grille:
|
||||
if dans_table(k):
|
||||
v = [table[n, c].get(k) for n in noms for c in colonnes]
|
||||
if any(x is not None for x in v):
|
||||
print("\t".join([iso(k)] + ["-" if x is None else f"{x:.6g}" for x in v]))
|
||||
|
||||
print("\nCorrélation entre stations, r des valeurs, puis r des pas d'une valeur à la suivante (n : pas où les deux ont une valeur) :")
|
||||
for c in colonnes:
|
||||
for i, s1 in enumerate(noms):
|
||||
for s2 in noms[i + 1:]:
|
||||
ks = sorted(set(table[s1, c]) & set(table[s2, c]))
|
||||
v1, v2 = [table[s1, c][k] for k in ks], [table[s2, c][k] for k in ks]
|
||||
d1, d2 = [b - a_ for a_, b in zip(v1, v1[1:])], [b - a_ for a_, b in zip(v2, v2[1:])]
|
||||
print(f" {c:12} {s1}-{s2} : r valeurs {correlation(v1, v2)}, r pas {correlation(d1, d2)} (n = {len(ks)})")
|
||||
|
||||
fig, axes = plt.subplots(len(colonnes) + 1, 1, sharex=True, figsize=(14, 2.4 * (len(colonnes) + 1)), squeeze=False,
|
||||
layout="constrained", gridspec_kw={"height_ratios": [3] * len(colonnes) + [0.3 * len(noms)]})
|
||||
for ax, c in zip(axes[:-1, 0], colonnes):
|
||||
for i, n in enumerate(noms):
|
||||
s = donnees[n].get(c, [])
|
||||
if not s:
|
||||
continue
|
||||
med = 0 if c == "temperature" else statistics.median(p["v"] for p in s)
|
||||
ts, vs = coupe([{"t": p["t"], "v": p["v"] - med} for p in s])
|
||||
ax.plot(ts, vs, ".-", ms=2, lw=0.8, color=f"C{i % 10}", label=n)
|
||||
ax.set_ylabel(c if c == "temperature" else f"{c}\nmoins sa médiane", fontsize=8)
|
||||
ax.grid(alpha=0.3)
|
||||
ax.legend(loc="upper left", bbox_to_anchor=(1.0, 1.0), fontsize=8)
|
||||
ax = axes[-1, 0]
|
||||
for i, n in enumerate(noms):
|
||||
for k in grille:
|
||||
if k not in avec[n]:
|
||||
ax.axvspan(k, k + o.pas, ymin=i / len(noms), ymax=(i + 1) / len(noms), color=f"C{i % 10}", lw=0)
|
||||
ax.set_yticks([(i + 0.5) / len(noms) for i in range(len(noms))], noms, fontsize=7)
|
||||
ax.set_ylim(0, 1)
|
||||
ax.set_ylabel("sans mesure", fontsize=8)
|
||||
ax.set_xlim(grille[0], grille[-1] + o.pas)
|
||||
ax.xaxis.set_major_formatter(mdates.DateFormatter("%d/%m\n%H:%MZ"))
|
||||
fig.suptitle(f"{', '.join(noms)} : même ligne de temps (heures UTC)")
|
||||
os.makedirs(o.sortie, exist_ok=True)
|
||||
chemin = os.path.join(o.sortie, f"{'-'.join(noms)}_stations_{borne(o.debut, 'debut')}_{borne(o.fin, 'fin')}.png")
|
||||
fig.savefig(chemin, dpi=100, bbox_inches="tight")
|
||||
print(f"\n{chemin}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
Reference in new issue
Block a user