418 lines
22 KiB
Python
418 lines
22 KiB
Python
"""Les six métriques de qualité d'image (peak, flux, sharpness, fwhm, dominance, snr) par capteur, face à sa référence calme.
|
|||
|
|
|
||
|
|
Usage : python3 agent-tools/qualite.py <dossier> [--debut T] [--fin T] [--capteurs A,B] [--calme T1/T2,T3/T4]
|
||
|
|
[--commun] [--table METRIQUE] [--pas 15min] [--seuil 0.5]
|
||
|
|
python3 agent-tools/qualite.py <dossier> --etiquettes labeling/auto/X.jsonl [--calme ...] [--debut T] [--fin T]
|
||
|
|
[--numeros 3,7] [--seuil 0.5] [--marge 60] [--bords] | [--hors [--min 1] [--sauf "Thermal displacement"]]
|
||
|
|
.venv/bin/python agent-tools/qualite.py <dossier> --figure [--calme ...] [--debut T] [--fin T]
|
||
|
|
[--metriques flux,snr,dominance] [--etiquettes F] [--zone T1/T2 ...] [--sortie D]
|
||
|
|
python3 agent-tools/qualite.py --essai (contrôle du calcul du rapport)
|
||
|
|
|
||
|
|
Définitions : docs/domaine/metriques-de-qualite.md. Colonnes remplies sur les caméras récentes seulement ; sur un dossier où
|
||
|
|
elles sont vides, l'outil le dit et s'arrête.
|
||
|
|
Référence d'un capteur : la médiane de chaque métrique sur ses mesures des fenêtres --calme, à la même heure UTC du jour
|
||
|
|
(24 créneaux ; un créneau sans mesure calme prend la médiane de toutes les heures calmes). Sans --calme : tout le dossier.
|
||
|
|
Chaque mesure devient un rapport valeur / référence : 1 = comme la référence ; < 1 plus bas ; > 1 plus haut. Pour fwhm et
|
||
|
|
dominance, c'est la hausse qui dit une image dégradée (tache plus large, second pic plus fort). Mesures rejetées comprises
|
||
|
|
(la qualité de leur image reste mesurée).
|
||
|
|
|
||
|
|
Sans --etiquettes ni --figure :
|
||
|
|
1. le peak maximal du dossier, puis le résumé par capteur : mesures rejetées, « pk/max » (peak médian du capteur sur la
|
||
|
|
fenêtre divisé par ce maximum : une tache au plafond de l'image a un peak constant), et pour chaque métrique le rapport médian sur la fenêtre et l'extrême (min pour peak, flux, sharpness, snr ; max pour
|
||
|
|
fwhm, dominance) avec son instant ; puis les lignes « cibles » et « références » : la médiane des rapports médians ;
|
||
|
|
2. --commun : par pas de --pas, la médiane des rapports des cibles et celle des références, pour chaque métrique ;
|
||
|
|
3. --table M : par pas, le rapport de M de chaque capteur (« * » : une mesure du pas rejetée), « méd » (médiane sur les
|
||
|
|
capteurs) et le nombre de capteurs sous --seuil (au-dessus de 1/--seuil pour fwhm et dominance).
|
||
|
|
--etiquettes F (un JSON par ligne, debut, fin, categorie), sans --figure : par étiquette (numérotée dans l'ordre du
|
||
|
|
fichier ; --debut/--fin gardent celles qui y commencent), le rapport médian des cibles et des références sur l'heure
|
||
|
|
d'avant, la plage et l'heure d'après (--marge minutes) : « cib 0.95|0.40|0.97 » ; puis les capteurs « touchés » sur la
|
||
|
|
plage (flux ou snr sous --seuil, ou dominance au-dessus de 1/--seuil), avec leur pire rapport de flux, du plus bas au plus
|
||
|
|
haut (r = référence). --bords : par instant de la plage élargie de --marge, le nombre de capteurs touchés et la médiane
|
||
|
|
des cibles de flux, snr, dominance (« < » : dans la plage). --hors : à la place, les suites d'instants de --debut à --fin
|
||
|
|
qu'aucune étiquette ne couvre (hors familles --sauf), où au moins --min capteurs sont touchés (instants à moins de 15 min
|
||
|
|
groupés), avec les capteurs touchés et leur pire flux.
|
||
|
|
--figure (matplotlib) : PNG « qualite-commun » : un panneau par métrique, échelle logarithmique, médiane des cibles (noir),
|
||
|
|
des références (rouge) et bande du 10e au 90e centile des cibles ; PNG « qualite-<métrique> » par --metriques : un petit
|
||
|
|
graphique par capteur, références en rouge. --etiquettes grise chaque étiquette d'une couleur par famille ; --zone grise
|
||
|
|
des plages. Trait coupé sur un trou de plus de 30 min. Imprime le chemin de chaque PNG.
|
||
|
|
Rend des valeurs, pas de verdict. Lancé depuis la racine du dépôt.
|
||
|
|
"""
|
||
|
|
import argparse
|
||
|
|
import bisect
|
||
|
|
import json
|
||
|
|
import os
|
||
|
|
import statistics
|
||
|
|
import sys
|
||
|
|
from datetime import timedelta
|
||
|
|
|
||
|
|
import donnees
|
||
|
|
from resume import QUALITE as METRIQUES, duree
|
||
|
|
|
||
|
|
HAUT_MAUVAIS = ("fwhm", "dominance") # pour ces deux-là, c'est la hausse qui dit une image dégradée
|
||
|
|
RACINE = os.path.normpath(os.path.join(os.path.dirname(os.path.abspath(__file__)), ".."))
|
||
|
|
COULEURS = {"Visibility": "tab:blue", "Obstruction": "tab:orange", "Thermal displacement": "tab:red",
|
||
|
|
"Displacement": "tab:purple", "Target issue": "tab:brown", "No data": "black"}
|
||
|
|
|
||
|
|
|
||
|
|
def fenetres(texte):
|
||
|
|
"""'T1/T2,T3/T4' -> [(début, fin)]."""
|
||
|
|
return [tuple(donnees.instant(b) for b in f.split("/")) for f in texte.split(",")] if texte else []
|
||
|
|
|
||
|
|
|
||
|
|
def dans(t, fen):
|
||
|
|
return any(a <= t <= b for a, b in fen)
|
||
|
|
|
||
|
|
|
||
|
|
def references(par, calme):
|
||
|
|
"""{capteur: {métrique: {heure: médiane, None: médiane toutes heures}}} sur les mesures calmes."""
|
||
|
|
ref = {}
|
||
|
|
for s, ms in par.items():
|
||
|
|
ref[s] = {}
|
||
|
|
for c in METRIQUES:
|
||
|
|
parh, tout = {}, []
|
||
|
|
for m in ms:
|
||
|
|
if m[c] is None or (calme and not dans(m["t"], calme)):
|
||
|
|
continue
|
||
|
|
parh.setdefault(m["t"].hour, []).append(m[c])
|
||
|
|
tout.append(m[c])
|
||
|
|
r = {h: statistics.median(v) for h, v in parh.items()}
|
||
|
|
r[None] = statistics.median(tout) if tout else None
|
||
|
|
ref[s][c] = r
|
||
|
|
return ref
|
||
|
|
|
||
|
|
|
||
|
|
def rapport(ref, s, c, m):
|
||
|
|
r = ref[s][c].get(m["t"].hour, ref[s][c][None])
|
||
|
|
return m[c] / r if m[c] is not None and r else None
|
||
|
|
|
||
|
|
|
||
|
|
def touche(r, c, seuil):
|
||
|
|
return r is not None and ((c in ("flux", "snr") and r < seuil) or (c == "dominance" and r > 1 / seuil))
|
||
|
|
|
||
|
|
|
||
|
|
def med(v):
|
||
|
|
return f"{statistics.median(v):.2f}" if v else "-"
|
||
|
|
|
||
|
|
|
||
|
|
def resume(par, ref, noms, refs, pmax):
|
||
|
|
print(f"peak maximal du dossier : {pmax if pmax is None else f'{pmax:g}'} ; pk/max : peak médian du capteur sur la "
|
||
|
|
"fenêtre, divisé par ce maximum")
|
||
|
|
print("Résumé : rapport médian à la référence calme, puis l'extrême et son instant (UTC)")
|
||
|
|
print(f"{'capteur':>12} {'rej':>4} {'pk/max':>6} " + " ".join(f"{c:>26}" for c in METRIQUES))
|
||
|
|
meds = {c: {"cibles": [], "références": []} for c in METRIQUES}
|
||
|
|
for s in noms:
|
||
|
|
ms = par[s]
|
||
|
|
if not ms:
|
||
|
|
continue
|
||
|
|
cases = []
|
||
|
|
for c in METRIQUES:
|
||
|
|
rs = [(rapport(ref, s, c, m), m["t"]) for m in ms]
|
||
|
|
rs = [x for x in rs if x[0] is not None]
|
||
|
|
if not rs:
|
||
|
|
cases.append(f"{'vide':>26}")
|
||
|
|
continue
|
||
|
|
md = statistics.median(r for r, _ in rs)
|
||
|
|
ext = (max if c in HAUT_MAUVAIS else min)(rs, key=lambda x: x[0])
|
||
|
|
meds[c]["références" if s in refs else "cibles"].append(md)
|
||
|
|
cases.append(f"{md:6.2f} ({ext[0]:6.2f} {ext[1]:%d/%m %H:%M})")
|
||
|
|
rej = sum(1 for m in ms if donnees.rejetee(m))
|
||
|
|
pk = [m["peak"] for m in ms if m["peak"] is not None]
|
||
|
|
pk = f"{statistics.median(pk) / pmax:6.2f}" if pk and pmax else f"{'-':>6}"
|
||
|
|
print(f"{s + ('r' if s in refs else ''):>12} {rej:>4} {pk} " + " ".join(cases))
|
||
|
|
for g in ("cibles", "références"):
|
||
|
|
print(f"{g:>24} " + " ".join(f"{statistics.median(meds[c][g]):26.2f}" if meds[c][g] else f"{'-':>26}"
|
||
|
|
for c in METRIQUES))
|
||
|
|
|
||
|
|
|
||
|
|
def par_pas(par, noms, pas):
|
||
|
|
pas = duree(pas)
|
||
|
|
debut = min(m["t"] for s in noms for m in par[s]).replace(hour=0, minute=0, second=0, microsecond=0)
|
||
|
|
return lambda t: debut + (t - debut) // pas * pas
|
||
|
|
|
||
|
|
|
||
|
|
def table(par, ref, noms, c, pas, seuil):
|
||
|
|
cle, cases = par_pas(par, noms, pas), {}
|
||
|
|
for s in noms:
|
||
|
|
for m in par[s]:
|
||
|
|
r = rapport(ref, s, c, m)
|
||
|
|
if r is not None:
|
||
|
|
cases.setdefault(cle(m["t"]), {}).setdefault(s, []).append((r, donnees.rejetee(m)))
|
||
|
|
haut = c in HAUT_MAUVAIS
|
||
|
|
print(f"\nTable de {c} / référence, pas de {pas} ('*' : une mesure du pas rejetée)")
|
||
|
|
w = max(7, *map(len, noms))
|
||
|
|
entete = f"{'instant':16} " + " ".join(f"{s:>{w}}" for s in noms) + f" {'méd':>6} {'n' + ('>' if haut else '<') + str(seuil):>6}"
|
||
|
|
for i, k in enumerate(sorted(cases)):
|
||
|
|
if i % 24 == 0:
|
||
|
|
print(entete)
|
||
|
|
ligne, vals = [], []
|
||
|
|
for s in noms:
|
||
|
|
v = cases[k].get(s)
|
||
|
|
if not v:
|
||
|
|
ligne.append(f"{'':>{w}}")
|
||
|
|
continue
|
||
|
|
r = statistics.median(x for x, _ in v)
|
||
|
|
vals.append(r)
|
||
|
|
ligne.append(f"{r:{w - 1}.2f}" + ("*" if any(j for _, j in v) else " "))
|
||
|
|
n = sum(1 for r in vals if (r > 1 / seuil if haut else r < seuil))
|
||
|
|
print(f"{k:%Y-%m-%d %H:%M} " + " ".join(ligne) + f" {statistics.median(vals):6.2f} {n:>6}")
|
||
|
|
|
||
|
|
|
||
|
|
def commun(par, ref, noms, refs, pas):
|
||
|
|
"""Par pas : médiane des rapports des cibles, puis des références, pour chaque métrique."""
|
||
|
|
cle, cases = par_pas(par, noms, pas), {}
|
||
|
|
for s in noms:
|
||
|
|
for m in par[s]:
|
||
|
|
d = cases.setdefault(cle(m["t"]), {c: ([], []) for c in METRIQUES})
|
||
|
|
for c in METRIQUES:
|
||
|
|
r = rapport(ref, s, c, m)
|
||
|
|
if r is not None:
|
||
|
|
d[c][s in refs].append(r)
|
||
|
|
print(f"\nMédianes des rapports par pas de {pas} : cibles / références")
|
||
|
|
entete = f"{'instant':16} " + " ".join(f"{c:>13}" for c in METRIQUES)
|
||
|
|
for i, k in enumerate(sorted(cases)):
|
||
|
|
if i % 24 == 0:
|
||
|
|
print(entete)
|
||
|
|
print(f"{k:%Y-%m-%d %H:%M} " + " ".join(
|
||
|
|
f"{statistics.median(cases[k][c][0]) if cases[k][c][0] else float('nan'):6.2f}/"
|
||
|
|
f"{statistics.median(cases[k][c][1]) if cases[k][c][1] else float('nan'):<6.2f}" for c in METRIQUES))
|
||
|
|
|
||
|
|
|
||
|
|
def lire_etiquettes(chemin):
|
||
|
|
return [json.loads(ligne) for ligne in open(chemin) if ligne.strip()]
|
||
|
|
|
||
|
|
|
||
|
|
def etiquettes(a, tout, ref, refs, noms, deb, fin):
|
||
|
|
marge = timedelta(minutes=a.marge)
|
||
|
|
temps = {s: [m["t"] for m in tout[s]] for s in noms}
|
||
|
|
garder = {int(n) for n in a.numeros.split(",")} if a.numeros else None
|
||
|
|
print(f"Référence calme : {a.calme or 'tout le dossier'} ; rapports médians avant|plage|après ({a.marge} min)")
|
||
|
|
for n, e in enumerate(lire_etiquettes(a.etiquettes), 1):
|
||
|
|
t0, t1 = donnees.instant(e["debut"]), donnees.instant(e["fin"])
|
||
|
|
if (garder and n not in garder) or (deb and t0 < deb) or (fin and t0 > fin):
|
||
|
|
continue
|
||
|
|
print(f"\n{n}. {e['debut']} → {e['fin']}, {e['categorie']}")
|
||
|
|
win = {s: tout[s][bisect.bisect_left(temps[s], t0 - marge):bisect.bisect_right(temps[s], t1 + marge)] for s in noms}
|
||
|
|
parties = [(t0 - marge, t0 - timedelta(seconds=1)), (t0, t1), (t1 + timedelta(seconds=1), t1 + marge)]
|
||
|
|
for c in METRIQUES:
|
||
|
|
cases = []
|
||
|
|
for g in (False, True):
|
||
|
|
vals = []
|
||
|
|
for a0, a1 in parties:
|
||
|
|
v = [rapport(ref, s, c, m) for s in win if (s in refs) == g for m in win[s] if a0 <= m["t"] <= a1]
|
||
|
|
vals.append(med([x for x in v if x is not None]))
|
||
|
|
cases.append(("ref " if g else "cib ") + "|".join(vals))
|
||
|
|
print(f" {c:>9} " + " ".join(cases))
|
||
|
|
pires = []
|
||
|
|
for s in noms:
|
||
|
|
ms = [m for m in win[s] if t0 <= m["t"] <= t1]
|
||
|
|
if any(touche(rapport(ref, s, c, m), c, a.seuil) for m in ms for c in ("flux", "snr", "dominance")):
|
||
|
|
fl = [x for x in (rapport(ref, s, "flux", m) for m in ms) if x is not None]
|
||
|
|
pires.append((min(fl) if fl else 1, s + ("r" if s in refs else "")))
|
||
|
|
pires.sort()
|
||
|
|
print(f" touchés ({len(pires)}) : " + ", ".join(f"{s} {f:.2f}" for f, s in pires) if pires else " touchés : aucun")
|
||
|
|
if a.bords:
|
||
|
|
inst = {}
|
||
|
|
for s in win:
|
||
|
|
for m in win[s]:
|
||
|
|
d = inst.setdefault(m["t"], {"n": 0, "flux": [], "snr": [], "dominance": []})
|
||
|
|
rs = {c: rapport(ref, s, c, m) for c in ("flux", "snr", "dominance")}
|
||
|
|
d["n"] += any(touche(rs[c], c, a.seuil) for c in rs)
|
||
|
|
if s not in refs:
|
||
|
|
for c in rs:
|
||
|
|
if rs[c] is not None:
|
||
|
|
d[c].append(rs[c])
|
||
|
|
print(" instant n flux snr dom")
|
||
|
|
for t in sorted(inst):
|
||
|
|
d = inst[t]
|
||
|
|
print(f" {t:%Y-%m-%d %H:%M} {d['n']:>3} {med(d['flux']):>5} {med(d['snr']):>5} {med(d['dominance']):>5}"
|
||
|
|
+ (" <" if t0 <= t <= t1 else ""))
|
||
|
|
|
||
|
|
|
||
|
|
def hors(a, tout, ref, refs, noms, deb, fin):
|
||
|
|
sauf = set(a.sauf.split(",")) if a.sauf else set()
|
||
|
|
couvert = [(donnees.instant(e["debut"]), donnees.instant(e["fin"])) for e in lire_etiquettes(a.etiquettes)
|
||
|
|
if e["categorie"] not in sauf]
|
||
|
|
inst = {}
|
||
|
|
for s in noms:
|
||
|
|
for m in donnees.filtrer(tout[s], deb, fin):
|
||
|
|
if dans(m["t"], couvert):
|
||
|
|
continue
|
||
|
|
if any(touche(rapport(ref, s, c, m), c, a.seuil) for c in ("flux", "snr", "dominance")):
|
||
|
|
inst.setdefault(m["t"], {})[s + ("r" if s in refs else "")] = rapport(ref, s, "flux", m) or 0
|
||
|
|
suites = []
|
||
|
|
for t in sorted(t for t in inst if len(inst[t]) >= a.min):
|
||
|
|
if suites and t - suites[-1][-1] <= timedelta(minutes=15):
|
||
|
|
suites[-1].append(t)
|
||
|
|
else:
|
||
|
|
suites.append([t])
|
||
|
|
print(f"Hors des étiquettes (sauf {a.sauf}) : instants où au moins {a.min} capteurs sont touchés ; {len(suites)} suites")
|
||
|
|
for su in suites:
|
||
|
|
pire = {}
|
||
|
|
for t in su:
|
||
|
|
for s, f in inst[t].items():
|
||
|
|
pire[s] = min(pire.get(s, 9), f)
|
||
|
|
print(f"{su[0]:%Y-%m-%d %H:%M} → {su[-1]:%H:%M} ({len(su)}) : "
|
||
|
|
+ ", ".join(f"{s} {f:.2f}" for s, f in sorted(pire.items(), key=lambda x: x[1])))
|
||
|
|
|
||
|
|
|
||
|
|
def morceaux(pts, trou=timedelta(minutes=30)):
|
||
|
|
"""[(t, ...)] -> listes coupées là où deux instants sont à plus de `trou` : un trait ne traverse pas un trou de mesures."""
|
||
|
|
out = []
|
||
|
|
for i, x in enumerate(pts):
|
||
|
|
if not out or x[0] - pts[i - 1][0] > trou:
|
||
|
|
out.append([])
|
||
|
|
out[-1].append(x)
|
||
|
|
return out
|
||
|
|
|
||
|
|
|
||
|
|
def figure(a, par, ref, noms, refs, deb, fin):
|
||
|
|
import matplotlib
|
||
|
|
matplotlib.use("Agg")
|
||
|
|
import matplotlib.dates as mdates
|
||
|
|
import matplotlib.pyplot as plt
|
||
|
|
|
||
|
|
plages = [(x, y, "grey") for x, y in fenetres(",".join(a.zone or []))]
|
||
|
|
if a.etiquettes:
|
||
|
|
for e in lire_etiquettes(a.etiquettes):
|
||
|
|
x, y = donnees.instant(e["debut"]), donnees.instant(e["fin"])
|
||
|
|
if (deb is None or y >= deb) and (fin is None or x <= fin):
|
||
|
|
plages.append((x, y, COULEURS.get(e["categorie"], "grey")))
|
||
|
|
station = os.path.basename(os.path.normpath(a.dossier))
|
||
|
|
t0 = min(m["t"] for s in noms for m in par[s])
|
||
|
|
t1 = max(m["t"] for s in noms for m in par[s])
|
||
|
|
suffixe = f"{t0:%Y%m%dT%H%MZ}_{t1:%Y%m%dT%H%MZ}"
|
||
|
|
os.makedirs(a.sortie, exist_ok=True)
|
||
|
|
|
||
|
|
def axe(ax):
|
||
|
|
for x, y, couleur in plages:
|
||
|
|
ax.axvspan(x, y, color=couleur, alpha=0.12, lw=0)
|
||
|
|
ax.xaxis.set_major_formatter(mdates.DateFormatter("%d/%m\n%H:%M"))
|
||
|
|
ax.set_yscale("log")
|
||
|
|
ax.axhline(1, ls=":", c="k", lw=0.8)
|
||
|
|
ax.set_xlim(t0, t1)
|
||
|
|
|
||
|
|
fig, axes = plt.subplots(len(METRIQUES), 1, figsize=(16, 2.4 * len(METRIQUES)), sharex=True)
|
||
|
|
for ax, c in zip(axes, METRIQUES):
|
||
|
|
inst = {}
|
||
|
|
for s in noms:
|
||
|
|
for m in par[s]:
|
||
|
|
r = rapport(ref, s, c, m)
|
||
|
|
if r is not None and r > 0:
|
||
|
|
inst.setdefault(m["t"], ([], []))[s in refs].append(r)
|
||
|
|
ts = sorted(inst)
|
||
|
|
cib = [(t, sorted(inst[t][0])) for t in ts if inst[t][0]]
|
||
|
|
rfs = [(t, statistics.median(inst[t][1])) for t in ts if inst[t][1]]
|
||
|
|
for i, mc in enumerate(morceaux(cib)):
|
||
|
|
ax.fill_between([t for t, _ in mc], [v[len(v) // 10] for _, v in mc], [v[(len(v) * 9) // 10] for _, v in mc],
|
||
|
|
color="0.8", lw=0, step="mid")
|
||
|
|
ax.plot([t for t, _ in mc], [statistics.median(v) for _, v in mc], c="k", lw=0.7,
|
||
|
|
label="cibles (médiane, bande 10-90 %)" if i == 0 else None)
|
||
|
|
for i, mc in enumerate(morceaux(rfs)):
|
||
|
|
ax.plot([t for t, _ in mc], [v for _, v in mc], c="tab:red", lw=0.7, label="références (médiane)" if i == 0 else None)
|
||
|
|
axe(ax)
|
||
|
|
ax.set_ylabel(c)
|
||
|
|
axes[0].legend(loc="upper right", fontsize=8)
|
||
|
|
axes[0].set_title(f"{station} : métriques de qualité / référence calme ({a.calme or 'tout le dossier'}), même heure UTC")
|
||
|
|
chemin = os.path.join(a.sortie, f"{station}_qualite-commun_{suffixe}.png")
|
||
|
|
fig.tight_layout()
|
||
|
|
fig.savefig(chemin, dpi=90)
|
||
|
|
plt.close(fig)
|
||
|
|
print(chemin)
|
||
|
|
|
||
|
|
for c in a.metriques.split(","):
|
||
|
|
col = 6
|
||
|
|
lig = (len(noms) + col - 1) // col
|
||
|
|
fig, axes = plt.subplots(lig, col, figsize=(3.2 * col, 1.9 * lig), sharex=True, squeeze=False)
|
||
|
|
for ax, s in zip(axes.flat, noms):
|
||
|
|
pts = [(m["t"], rapport(ref, s, c, m)) for m in par[s]]
|
||
|
|
pts = [(t, r) for t, r in pts if r is not None and r > 0]
|
||
|
|
for mc in morceaux(pts):
|
||
|
|
ax.plot([t for t, _ in mc], [r for _, r in mc], lw=0.5, c="tab:red" if s in refs else "k")
|
||
|
|
axe(ax)
|
||
|
|
ax.set_title(s, fontsize=8, color="tab:red" if s in refs else "k")
|
||
|
|
ax.tick_params(labelsize=6)
|
||
|
|
for ax in list(axes.flat)[len(noms):]:
|
||
|
|
ax.axis("off")
|
||
|
|
fig.suptitle(f"{station} : {c} / référence calme, par capteur (références en rouge)")
|
||
|
|
chemin = os.path.join(a.sortie, f"{station}_qualite-{c}_{suffixe}.png")
|
||
|
|
fig.tight_layout()
|
||
|
|
fig.savefig(chemin, dpi=80)
|
||
|
|
plt.close(fig)
|
||
|
|
print(chemin)
|
||
|
|
|
||
|
|
|
||
|
|
def main():
|
||
|
|
p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
|
||
|
|
p.add_argument("dossier")
|
||
|
|
p.add_argument("--debut", type=donnees.instant)
|
||
|
|
p.add_argument("--fin", type=donnees.instant)
|
||
|
|
p.add_argument("--capteurs", help="liste séparée par des virgules (défaut : tous)")
|
||
|
|
p.add_argument("--calme", help="fenêtres de la référence, T1/T2,T3/T4 (défaut : tout le dossier)")
|
||
|
|
p.add_argument("--commun", action="store_true", help="médianes des cibles et des références par pas")
|
||
|
|
p.add_argument("--table", choices=METRIQUES, help="rapport d'une métrique par pas et par capteur")
|
||
|
|
p.add_argument("--pas", default="15min", type=lambda x: duree(x) and x, help="15min, 1h, 1d")
|
||
|
|
p.add_argument("--seuil", type=float, default=0.5, help="« touché » : flux ou snr sous seuil, dominance au-dessus de 1/seuil")
|
||
|
|
p.add_argument("--etiquettes", help="fichier d'étiquettes (JSON par ligne)")
|
||
|
|
p.add_argument("--numeros", help="numéros d'étiquettes à lire, 3,7")
|
||
|
|
p.add_argument("--marge", type=int, default=60, help="minutes avant et après chaque étiquette")
|
||
|
|
p.add_argument("--bords", action="store_true")
|
||
|
|
p.add_argument("--hors", action="store_true", help="instants touchés qu'aucune étiquette ne couvre")
|
||
|
|
p.add_argument("--min", type=int, default=1)
|
||
|
|
p.add_argument("--sauf", default="Thermal displacement", help="familles ignorées par --hors, A,B")
|
||
|
|
p.add_argument("--figure", action="store_true", help="PNG (matplotlib : .venv/bin/python)")
|
||
|
|
p.add_argument("--metriques", default="flux,snr,dominance", help="PNG par capteur de --figure")
|
||
|
|
p.add_argument("--zone", action="append", help="plage à griser sur les PNG, T1/T2 (répétable)")
|
||
|
|
p.add_argument("--sortie", default=os.path.join(RACINE, "out", "diagnostic"), help="dossier des PNG")
|
||
|
|
a = p.parse_args()
|
||
|
|
if a.hors and not a.etiquettes:
|
||
|
|
p.error("--hors demande --etiquettes")
|
||
|
|
inconnues = [c for c in a.metriques.split(",") if c not in METRIQUES]
|
||
|
|
if inconnues:
|
||
|
|
p.error(f"métriques inconnues : {', '.join(inconnues)} ; connues : {', '.join(METRIQUES)}")
|
||
|
|
|
||
|
|
tout = donnees.charger(a.dossier)
|
||
|
|
if not tout:
|
||
|
|
sys.exit(f"Aucun export « advanced » dans {a.dossier} (voir inventaire.py).")
|
||
|
|
if not any(m[c] is not None for ms in tout.values() for m in ms for c in METRIQUES):
|
||
|
|
sys.exit(f"Aucune métrique de qualité dans {a.dossier} : peak à snr vides (caméra ancienne ; "
|
||
|
|
"docs/domaine/metriques-de-qualite.md).")
|
||
|
|
noms = a.capteurs.split(",") if a.capteurs else sorted(tout, key=lambda s: (not donnees.est_reference(tout[s]), s))
|
||
|
|
absents = [s for s in noms if s not in tout]
|
||
|
|
if absents:
|
||
|
|
sys.exit(f"Capteurs absents : {', '.join(absents)}. Présents : {', '.join(sorted(tout))}.")
|
||
|
|
ref = references(tout, fenetres(a.calme))
|
||
|
|
refs = {s for s in tout if donnees.est_reference(tout[s])}
|
||
|
|
par = {s: donnees.filtrer(tout[s], a.debut, a.fin) for s in noms}
|
||
|
|
if not any(par.values()):
|
||
|
|
sys.exit("Aucune mesure dans la fenêtre demandée.")
|
||
|
|
if a.figure:
|
||
|
|
return figure(a, par, ref, noms, refs, a.debut, a.fin)
|
||
|
|
if a.etiquettes:
|
||
|
|
return (hors if a.hors else etiquettes)(a, tout, ref, refs, noms, a.debut, a.fin)
|
||
|
|
pmax = max((m["peak"] for ms in tout.values() for m in ms if m["peak"] is not None), default=None)
|
||
|
|
print(f"Référence calme : {a.calme or 'tout le dossier'}, par heure UTC du jour (r = référence)")
|
||
|
|
resume(par, ref, noms, refs, pmax)
|
||
|
|
if a.commun:
|
||
|
|
commun(par, ref, noms, refs, a.pas)
|
||
|
|
if a.table:
|
||
|
|
table(par, ref, noms, a.table, a.pas, a.seuil)
|
||
|
|
|
||
|
|
|
||
|
|
def essai():
|
||
|
|
"""Contrôle du rapport à la référence : même heure, repli sur toutes les heures, fenêtre calme respectée."""
|
||
|
|
from datetime import datetime, timezone
|
||
|
|
t = lambda j, h: datetime(2026, 10, j, h, tzinfo=timezone.utc) # noqa: E731
|
||
|
|
vide = dict.fromkeys(METRIQUES)
|
||
|
|
par = {"A": [dict(vide, t=t(1, 3), flux=10.0), dict(vide, t=t(2, 3), flux=30.0), dict(vide, t=t(2, 5), flux=100.0),
|
||
|
|
dict(vide, t=t(9, 3), flux=1000.0)]}
|
||
|
|
ref = references(par, [(t(1, 0), t(3, 0))])
|
||
|
|
assert ref["A"]["flux"][3] == 20.0 and ref["A"]["flux"][None] == 30.0, ref
|
||
|
|
assert rapport(ref, "A", "flux", dict(vide, t=t(9, 3), flux=10.0)) == 0.5
|
||
|
|
assert rapport(ref, "A", "flux", dict(vide, t=t(9, 7), flux=60.0)) == 2.0 # heure sans calme : toutes les heures
|
||
|
|
assert rapport(ref, "A", "snr", dict(vide, t=t(9, 3), snr=5.0)) is None
|
||
|
|
assert touche(0.4, "flux", 0.5) and touche(2.5, "dominance", 0.5) and not touche(2.5, "flux", 0.5)
|
||
|
|
print("essai : ok")
|
||
|
|
|
||
|
|
|
||
|
|
if __name__ == "__main__":
|
||
|
|
essai() if sys.argv[1:] == ["--essai"] else main()
|