Files
aimsight-tools/scripts/jours.py
T

333 lines
21 KiB
Python
Raw Normal View History

"""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 tools/scripts/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 [--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 ;
la nuit en cours au début de la fenêtre compte aussi (ses heures après minuit). Bruit propre du capteur : médiane des
écarts entre deux mesures consécutives sur la fenêtre. Pour chaque colonne de --colonnes :
1. Niveau de chaque nuit, par capteur : médiane, MAD et nombre de mesures ; puis, d'une nuit à la suivante, la
marche (différence des médianes, en unités et en bruits) et où elle se place : la suite des mesures de nuit des
deux nuits est coupée là où la somme des écarts absolus au niveau de la première nuit (avant) et de la seconde
(après) est la plus petite ; « entre A et B » : dernière mesure de nuit avant la coupure et première après (B en
début de nuit : la coupure tombe entre deux nuits, de jour).
2. Jours superposés : chaque mesure moins le niveau de la dernière nuit commencée à son instant (la précédente, ou
celle en cours ; sans elle, la nuit la plus proche). PNG « parheure-<colonne> » : un petit graphique par capteur,
en abscisse l'heure du jour (UTC), une courbe par jour, heures de nuit grisées, une échelle par capteur, cadrée du 1er au 99e centile élargi de moitié (le titre dit
combien de mesures sortent du cadre : un pic isolé n'écrase pas l'échelle ; sa valeur est dans les tables).
Table : par créneau de --pas de l'heure du jour, les capteurs dont l'écart dépasse --k bruits à ce créneau, du
même côté, au moins --jours jours différents, avec le nombre de ces jours sur le nombre de jours mesurés et la
médiane de ces écarts (signée, en unités et en bruits) ; un capteur au-dessus certains jours et au-dessous
d'autres est cité deux fois.
3. Avec --bornes : chaque jour face à la nuit qui le précède, pour la médiane des cibles de chaque colonne (avec
--capteurs : la médiane de ces capteurs, références comprises ; un seul capteur : le sien) et pour la pose de la
caméra (pan, tilt, rotation, scale, sigma0) si camera/ existe. Un « jour » : de la fin d'une nuit à la fin de la
suivante (24 h), daté du jour où il commence ; son niveau de référence est celui de la nuit qui vient de finir (sans
elle, la dernière nuit mesurée avant, ou au début du lot la première : nommée, « pas la précédente »). Écart de chaque mesure à ce niveau (médiane des cibles : à chaque
instant, médiane des écarts de chaque cible à son propre niveau de cette nuit) ; bruit : médiane des écarts entre
deux valeurs consécutives de cette suite. Par jour : nombre de mesures, première et dernière ; premier et dernier
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. 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).
Rend des valeurs, pas de verdict.
"""
import argparse
import math
import os
import statistics
import sys
from datetime import datetime, timedelta, timezone
import matplotlib
matplotlib.use("Agg")
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, borne # noqa: E402
from resume import ARRONDI, bruit_propre, duree # noqa: E402
def heures(texte):
"""'20-3' -> (20, 3)."""
try:
h1, h2 = (int(x) for x in texte.split("-"))
except ValueError:
raise argparse.ArgumentTypeError(f"heures invalides : {texte!r} (ex. 20-3)")
return h1, h2
def de_nuit(t, h1, h2):
return (h1 <= t.hour or t.hour < h2) if h1 > h2 else h1 <= t.hour < h2
def coupure(pts, la, lb):
"""Indice j (1..n-1) où sum|v-la| avant j + sum|v-lb| à partir de j est le plus petit."""
avant, apres = 0.0, sum(abs(v - lb) for _, v in pts)
meilleur = None
for j in range(1, len(pts)):
v = pts[j - 1][1]
avant += abs(v - la)
apres -= abs(v - lb)
if meilleur is None or avant + apres < meilleur[0]:
meilleur = (avant + apres, j)
return meilleur[1]
def main():
a = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
a.add_argument("dossier")
a.add_argument("--colonnes", default="corr_x,corr_y,error_value")
a.add_argument("--nuit", default="20-3", type=heures, help="heures de nuit H1-H2, UTC (défaut 20-3)")
a.add_argument("--k", type=float, default=5, help="écart au niveau de la nuit compté, en bruits propres du capteur")
a.add_argument("--jours", type=int, default=2, help="nombre de jours à partir duquel un capteur est cité à un créneau")
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("out", "diagnostic"), help="dossier des PNG")
o = a.parse_args()
par = charger(o.dossier)
if not par:
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(",")
for demandes, connus, quoi in ((noms, par, "Capteurs"), (colonnes, 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))}.")
series = {s: [m for m in filtrer(par[s], o.debut, o.fin) if not rejetee(m)] for s in noms}
if not any(series.values()):
sys.exit("Aucune mesure acceptée dans la fenêtre demandée.")
h1, h2 = o.nuit
pas = int(o.pas.total_seconds() // 60)
station = os.path.basename(os.path.normpath(o.dossier))
os.makedirs(o.sortie, exist_ok=True)
lignes = math.ceil(len(noms) / 5)
for col in colonnes:
print(f"\n== {col} : niveau de chaque nuit ({h1} h → {h2} h UTC), médiane ±MAD (mesures) ; marches d'une nuit à la suivante ==")
creneaux = {} # minute du jour -> {(capteur, au-dessus): {jour: écart}}
bruits = {}
fig, axes = plt.subplots(lignes, 5, sharex=True, figsize=(18, 2.5 * lignes), squeeze=False)
for ax, s in zip(axes.flat, noms):
ms = [(m["t"], m[col]) for m in series[s] if m[col] is not None]
if len(ms) < 2:
print(f"{s:9}(moins de 2 valeurs acceptées)")
ax.axis("off")
continue
bruit = bruits[s] = bruit_propre([v for _, v in ms])
nuits = {}
for t, v in ms:
if de_nuit(t, h1, h2):
nuits.setdefault((t - timedelta(hours=h1)).date(), []).append((t, v))
niv = {d: statistics.median(v for _, v in p) for d, p in nuits.items()}
cases = []
for d in sorted(nuits):
vs = [v for _, v in nuits[d]]
cases.append(f"{d:%d/%m} {niv[d]:+.6g} ±{statistics.median(abs(v - niv[d]) for v in vs):.2g} ({len(vs)})")
print(f"{s:9}bruit {bruit:.3g} | " + (" | ".join(cases) if cases else "aucune mesure de nuit"))
jours = sorted(nuits)
for da, db in zip(jours, jours[1:]):
pts = nuits[da] + nuits[db]
j = coupure(pts, niv[da], niv[db])
d = niv[db] - niv[da]
enb = f"{d / bruit:+.1f}" if bruit else "-"
print(f"{'':9}{da:%d/%m} → {db:%d/%m} : {d:+.4g} ({enb} bruits), entre {iso(pts[j - 1][0])} et {iso(pts[j][0])}")
def niveau_de(t):
d = (t - timedelta(hours=h1)).date()
if d in niv:
return niv[d]
return niv[min(niv, key=lambda x: abs((x - d).days))] if niv else statistics.median(v for _, v in ms)
par_jour = {}
for t, v in ms:
e = v - niveau_de(t)
par_jour.setdefault(t.date(), []).append((t.hour + t.minute / 60, e))
if bruit and abs(e) > o.k * bruit:
c = (t.hour * 60 + t.minute) // pas * pas
creneaux.setdefault(c, {}).setdefault((s, e > 0), {})[t.date()] = e
for i, (d, p) in enumerate(sorted(par_jour.items())):
ax.plot([x for x, _ in p], [e for _, e in p], "-", lw=0.8, color=f"C{i % 10}", label=f"{d:%d/%m}")
ax.axhline(0, color="0.3", ls=":", lw=0.8)
tous = sorted(e for p in par_jour.values() for _, e in p)
q1, q2 = tous[len(tous) // 100], tous[-1 - len(tous) // 100] # cadre du 1er au 99e centile : un pic isolé n'écrase pas l'échelle
marge = (q2 - q1) * 0.5 or 1
ax.set_ylim(q1 - marge, q2 + marge)
hors_cadre = sum(not q1 - marge <= e <= q2 + marge for e in tous)
for x0, x1 in ((h1, 24), (0, h2)) if h1 > h2 else ((h1, h2),):
ax.axvspan(x0, x1, color="0.9", lw=0)
ax.set_title(s + (" (réf.)" if est_reference(series[s]) else "") + f" bruit {bruit:.2g}"
+ (f" ({hors_cadre} hors cadre)" if hors_cadre else ""), fontsize=9)
ax.set_xlim(0, 24)
ax.set_xticks(range(0, 25, 3))
ax.grid(alpha=0.3)
ax.tick_params(labelsize=7)
if ax is axes.flat[0]:
ax.legend(fontsize=6, ncol=2)
for ax in list(axes.flat)[len(noms):]:
ax.axis("off")
fig.suptitle(f"{station} : {col} moins le niveau de la dernière nuit ({h1} h → {h2} h, grisée), "
"une courbe par jour, en abscisse l'heure du jour (UTC) ; une échelle par capteur")
fig.tight_layout()
chemin = os.path.join(o.sortie, f"{station}_parheure-{col}_{borne(o.debut, 'debut')}_{borne(o.fin, 'fin')}.png")
fig.savefig(chemin, dpi=100, bbox_inches="tight")
plt.close(fig)
print(chemin)
nb_jours = {s: {} for s in noms} # capteur -> créneau -> jours mesurés
for s in noms:
for m in series[s]:
if m[col] is not None:
nb_jours[s].setdefault((m["t"].hour * 60 + m["t"].minute) // pas * pas, set()).add(m["t"].date())
print(f"\n{col} : par créneau de {pas} min de l'heure du jour, capteurs à plus de {o.k:g} bruits du niveau de la nuit "
f"au moins {o.jours} jours (jours / jours mesurés, médiane de ces écarts, en bruits)")
vide = True
for c in sorted(creneaux):
cites = []
for s, haut in ((s, h) for s in noms for h in (True, False)):
ec = creneaux[c].get((s, haut), {})
if len(ec) >= o.jours:
med = statistics.median(ec.values())
cites.append(f"{s} {len(ec)}/{len(nb_jours[s].get(c, ()))} {med:+.3g} ({med / bruits[s]:+.1f})")
if cites:
vide = False
print(f"{c // 60:02d}:{c % 60:02d} {len(cites):2} capteurs : " + ", ".join(cites))
if vide:
print("(aucun)")
if o.bornes:
bornes(o, noms, series, colonnes, station)
def niveaux_de_nuit(pts, h1, h2):
"""[(t, v)] -> {date de la nuit: médiane}."""
nuits = {}
for t, v in pts:
if de_nuit(t, h1, h2):
nuits.setdefault((t - timedelta(hours=h1)).date(), []).append(v)
return {d: statistics.median(v) for d, v in nuits.items()}
def bornes(o, noms, series, colonnes, station):
"""Section 3 : par jour, l'écart au niveau de la nuit qui le précède, pour la médiane des cibles et la pose."""
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]}", 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}", 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]
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}"
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, 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)
for d in jours:
debut = datetime.combine(d, datetime.min.time(), tzinfo=timezone.utc) + timedelta(hours=h1) + duree_nuit
fin = debut + timedelta(days=1)
ref = max((n for n in nuits if n <= d), default=None) or (min(nuits) if nuits else None)
par_t = {}
for s, p in par_capteur.items():
if ref in niv[s]:
for t, v in p:
if debut <= t < fin:
par_t.setdefault(t, []).append(v - niv[s][ref])
suivante = [niv[s][d + timedelta(days=1)] - niv[s][ref] for s in niv if ref in niv[s] and d + timedelta(days=1) in niv[s]]
ecarts.append((debut.date(), d, ref, [(t, statistics.median(e)) for t, e in sorted(par_t.items())],
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}"
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
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"> {'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 > {'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 seuil and signe * p[x][1] > seuil:
i = j = x
while i > 0 and signe * p[i - 1][1] > seuil:
i -= 1
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 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)
tous_e = sorted(e for *_, p, _ in ecarts for _, e in p)
hors_cadre = 0
if tous_e: # cadre du 1er au 99e centile élargi de moitié, comme parheure : un pic isolé n'écrase pas l'échelle
q1, q2 = tous_e[len(tous_e) // 100], tous_e[-1 - len(tous_e) // 100]
marge = (q2 - q1) * 0.5 or 1
ax.set_ylim(q1 - marge, q2 + marge)
hors_cadre = sum(not q1 - marge <= e <= q2 + marge for e in tous_e)
ax.set_title(f"{nom} bruit {bruit:.2g}" + (f" ({hors_cadre} hors cadre)" if hors_cadre else ""), fontsize=9)
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 {'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")
plt.close(fig)
print(chemin)
if __name__ == "__main__":
main()