Reading tools: what the etiqueteur had to script itself (metrics, daily bounds, local level, zone, references)

- metriques.py: new, reads metrics/ (temperatures, voltage) against targets and camera pose
- jours.py --bornes: per-day first/last excursion, extreme, from the previous night
- plages.py --glissant, --instants: deviations from a local level, per-instant view
- ensemble.py --table, resume.py --marque/--instants: shorter outputs, repeated headers
- inventaire.py: image gaps as runs, references on reproj_err when inlier is empty
- vignettes.py --zone: same scene area across hours
- donnees.py: references recognised when pattern_type is empty (benchmark unchanged)
- lire-les-donnees: new options documented, gif.py row added

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
maximeandClaude Opus 5.5 committed 2026-11-03 16:56:59 +01:00
1 parent 6fbd7510b7
commit efbc5f15d7
9 files changed
+670 -80

No files matched your search

+7 -2
View File
@@ -97,8 +97,13 @@ def charger_camera(dossier):
def est_reference(mesures):
"""Référence du réseau de compensation (pattern_type global_ref), sinon cible."""
return mesures[0]["pattern_type"] == "global_ref"
"""Référence du réseau de compensation (pattern_type global_ref), sinon cible. Certains exports ont pattern_type vide,
sur toute la période ou au début : on lit alors le premier pattern_type rempli et, s'il n'y en a aucun, reproj_err
ou inlier remplis (références seulement : docs/domaine/colonnes-des-deplacements.md)."""
t = next((m["pattern_type"] for m in mesures if m["pattern_type"]), None)
if t is not None:
return t == "global_ref"
return any(m["reproj_err"] is not None or m["inlier"] is not None for m in mesures)
def rejetee(m):
+28 -9
View File
@@ -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]] [--capteurs A,B] [--debut ...] [--fin ...] [--sortie DOSSIER]
[--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]
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 :
@@ -40,7 +40,11 @@ un début ou une fin, la table est au pas de --pas (défaut 15min, la cadence de
1h par ex., aplatit un pic d'un à quatre pas et date à l'heure).
Imprime aussi, pour chaque instant où au moins --min capteurs dépassent leur médiane de plus de --k MAD,
le nombre et les capteurs (--min 1 : aussi les instants où un seul capteur sort de son niveau), et les instants de
mesure sans pose de la caméra (pas de recalage). Rend des valeurs, pas de verdict.
mesure sans pose de la caméra (pas de recalage).
Les tables par pas (médiane commune, --rigide) répètent leur en-tête toutes les 24 lignes. Avec --table T1/T2, elles ne
s'impriment qu'entre T1 et T2 (« non » : pas du tout) ; niveaux, minimum et maximum, PNG et le reste portent toujours sur
toute la fenêtre --debut/--fin : sur un mois, on lit tout le reste, puis la table d'un jour aux mêmes niveaux.
Rend des valeurs, pas de verdict.
"""
import argparse
import math
@@ -146,7 +150,7 @@ 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 :")
+ 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")]
minuit = tf[0].replace(hour=0, minute=0, second=0, microsecond=0)
t0 = minuit + ((tf[0] - minuit) // o.pas) * o.pas
@@ -159,8 +163,10 @@ def rigide(o, noms, series, temps, base, station):
if t in res[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)
print(f"{'instant':17}" + "".join(f"{c:>{w}}" for c in cols))
for t in sorted(par_pas):
entete = f"{'instant':17}" + "".join(f"{c:>{w}}" for c in cols)
for i, t in enumerate(t for t in sorted(par_pas) if o.dans_table(t)):
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))
for s in noms:
if res[s]:
@@ -183,6 +189,8 @@ def main():
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("--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)")
a.add_argument("--debut", type=instant)
a.add_argument("--fin", type=instant)
@@ -198,6 +206,13 @@ def main():
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.")
if o.table in ("", "non"):
o.dans_table = lambda t: o.table == ""
else:
bornes = [instant(x) for x in o.table.split("/")]
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")):
absents = [x for x in demandes if x not in connus]
if absents:
@@ -272,7 +287,9 @@ def main():
axes[-1, 0].set_ylabel(f"capteurs au-dessus\nde médiane + {o.k:g} MAD\n({o.colonne})")
axes[-1, 0].grid(alpha=0.3)
h = next((h for h in (1, 2, 3, 6, 12) if (temps[-1] - temps[0]).total_seconds() / 3600 / h <= 20), 24)
axes[-1, 0].xaxis.set_major_locator(mdates.HourLocator(byhour=range(0, 24, h)))
jours = (temps[-1] - temps[0]).total_seconds() / 86400
# au-delà de 20 jours, une graduation par jour se chevauche : tous les n jours, au plus 20 graduations
axes[-1, 0].xaxis.set_major_locator(mdates.HourLocator(byhour=range(0, 24, h)) if h < 24 else mdates.DayLocator(interval=math.ceil(jours / 20)))
axes[-1, 0].set_xlim(temps[0], temps[-1])
axes[-1, 0].xaxis.set_major_formatter(mdates.DateFormatter("%d/%m\n%H:%MZ"))
for ax in axes[:, 0]:
@@ -300,9 +317,11 @@ def main():
lignes_t.setdefault(t0 + ((t - t0) // o.pas) * o.pas, {}).setdefault(col + "_cibles", []).append(v)
cols_t = colonnes + [c + "_cibles" for c in refs_par_col] + ["cam_" + c for c in pose_cols]
print(f"\nMédiane commune (écart à la médiane de la fenêtre){' et pose brute de la caméra (cam_, vide sans recalage)' if pose_cols else ''}, "
f"médiane par pas de {int(o.pas.total_seconds() // 60)} min :")
print(f"{'instant':17}" + "".join(f"{c:>13}" for c in cols_t))
for t in sorted(lignes_t):
f"médiane par pas de {int(o.pas.total_seconds() // 60)} min{' (table : ' + o.table + ')' if o.table else ''} :")
entete = f"{'instant':17}" + "".join(f"{c:>13}" for c in cols_t)
for i, t in enumerate(t for t in sorted(lignes_t) if o.dans_table(t)):
if i % 24 == 0:
print(entete)
print(f"{iso(t):17}" + "".join(f"{statistics.median(lignes_t[t][c]):13.{6 if c.startswith('cam_') else 4}g}" if c in lignes_t[t] else " " * 13 for c in cols_t))
for col in cols_t:
if communes[col]:
+88 -29
View File
@@ -4,11 +4,16 @@ Usage : python3 agent-tools/inventaire.py data/PS_DES_COUDRES/ [--debut T] [--fi
Les comptes portent sur toute la période. Avec --debut et/ou --fin, une section de plus liste, sur cette fenêtre,
les pas absents (datés, avec les capteurs qui n'ont pas de mesure) et, par capteur, les mesures rejetées (datées,
en suites de pas consécutifs ; rejetée : error_value au-dessus du seuil, références comprises), puis le nombre de
références retenues par la compensation (inlier = 1) à chaque instant et, datées, les suites d'instants où des
références ne le sont pas (lesquelles, et pourquoi : rejetée, inlier 0, inlier vide). Mouvements de la caméra (camera/) : nombre de poses, période, et les instants de mesure
références retenues par la compensation (inlier = 1 ; inlier vide sur la fenêtre : reproj_err rempli) à chaque instant
et, datées, les suites d'instants où des références ne le sont pas (lesquelles, et pourquoi : rejetée, valeur d'inlier,
vide). Mouvements de la caméra (camera/) : nombre de poses, période, et les instants de mesure
sans pose (pas de recalage), sur toute la période puis sur la fenêtre. Avant les comptes, ce que contient chaque source
(sur la fenêtre, sinon toute la période) : les colonnes de l'export, de la pose et de quality/, remplies ou vides, les noms
des métriques système de metrics/, les images et les images différentielles. Rend des valeurs, pas de verdict.
(sur la fenêtre, sinon toute la période) : les colonnes de l'export, de la pose et de quality/, remplies ou vides (avec,
pour une colonne de l'export que tous les capteurs ne portent pas, combien la portent), les noms des métriques système
de metrics/, les images et les images différentielles. Les relevés en double (même capteur, même instant dans deux
exports, ou deux fois dans un) sont comptés par export. Images : par suite d'écarts égaux entre deux images (à 5 min
près ; sur la fenêtre si elle est donnée). Une suite datée qui finit le même jour n'écrit que l'heure de sa fin.
Rend des valeurs, pas de verdict.
"""
import argparse
import collections
@@ -24,6 +29,36 @@ from donnees import charger, charger_camera, est_reference, filtrer, heure_image
METRIQUE_RE = re.compile(r"^(.+?)_(\d{4})_(\d{2})_(\d{2})_\d{2}_\d{2}") # NIEDERHORN_BusCurrent_2026_09_22_00_00 to ….csv
def suite(a, b, n):
"""Une suite datée : le début en entier, la fin sans la date quand elle tombe le même jour."""
if n == 1:
return iso(a)
return f"{iso(a)} → {iso(b)[11:] if iso(a)[:10] == iso(b)[:10] else iso(b)} ({n})"
def doubles(chemins):
"""Relevés (même capteur, même instant) déjà lus dans un export précédent ou plus haut dans le même : charger n'en
garde qu'un, celui du dernier fichier dans l'ordre des noms. Une ligne par export qui en a."""
vus, lignes = {}, []
for p in chemins:
n = deja = autres = 0
with open(p, newline="") as fh:
for r in csv.DictReader(fh):
n += 1
cle = (r["sensor_name"].strip(), r["time_utc"])
val = tuple(v.strip() for k, v in r.items() if k not in ("sensor_name", None))
if cle in vus:
deja += 1
autres += vus[cle] != val
vus[cle] = val
if deja:
lignes.append(f" {os.path.basename(p)} : {deja} sur {n} déjà lus, dont {autres} de valeurs différentes")
if lignes:
print("Relevés en double (même capteur, même instant dans un export déjà lu, dans l'ordre des noms ; "
"les outils gardent celui du dernier fichier) :")
print("\n".join(lignes))
def liste(chemins, tout):
"""Un dossier de pompage compte des centaines de fichiers : au-delà de 5, le premier et le dernier seulement."""
if tout or len(chemins) <= 5:
@@ -38,6 +73,7 @@ def liste(chemins, tout):
def fichiers(f, tout=False):
print(f"Exports « advanced » (source des mesures) : {len(f['advanced'])}")
liste(f["advanced"], tout)
doubles(f["advanced"])
print(f"Exports horaires : {len(f['horaire'])} (non lus par les outils : moyennes horaires, "
"heure locale sans fuseau ; voir docs/domaine/colonnes-des-deplacements.md)")
liste(f["horaire"], tout)
@@ -48,8 +84,9 @@ def fichiers(f, tout=False):
def remplies(chemins, debut, fin):
"""CSV d'une source -> (lignes de la fenêtre, {colonne: lignes avec une valeur}), colonnes dans l'ordre des en-têtes."""
lignes, compte = 0, {}
"""CSV d'une source -> (lignes de la fenêtre, {colonne: lignes avec une valeur}, {colonne: capteurs qui en ont une}),
colonnes dans l'ordre des en-têtes ; capteurs : sensor_name, s'il y en a."""
lignes, compte, qui = 0, {}, collections.defaultdict(set)
for p in chemins:
with open(p, newline="") as fh:
r = csv.DictReader(fh)
@@ -63,7 +100,9 @@ def remplies(chemins, debut, fin):
for c in compte:
if (row.get(c) or "").strip():
compte[c] += 1
return lignes, compte
if row.get("sensor_name"):
qui[c].add(row["sensor_name"].strip())
return lignes, compte, qui
def contenu(dossier, f, debut=None, fin=None):
@@ -77,8 +116,11 @@ def contenu(dossier, f, debut=None, fin=None):
for titre, chemins in (("Export « advanced »", f["advanced"]), ("Pose de la caméra (camera/)", f["camera"]),
("Qualité d'image (quality/)", autres.pop("quality", []))):
if chemins:
n, compte = remplies(chemins, debut, fin)
print(f" {titre} : {n} lignes ; " + ", ".join(f"{c} {k}" if k else f"{c} vide" for c, k in compte.items()))
n, compte, qui = remplies(chemins, debut, fin)
tous = set().union(*qui.values())
def porte(c): # nombre de capteurs qui portent la colonne, quand ce ne sont pas tous
return f" ({len(qui[c])} capteurs sur {len(tous)})" if tous and len(qui[c]) < len(tous) else ""
print(f" {titre} : {n} lignes ; " + ", ".join(f"{c} {k}{porte(c)}" if k else f"{c} vide" for c, k in compte.items()))
jours = collections.Counter() # métrique -> jours (un CSV par métrique et par jour) dans la fenêtre
for p in autres.pop("metrics", []):
m = METRIQUE_RE.match(os.path.basename(p))
@@ -89,7 +131,7 @@ def contenu(dossier, f, debut=None, fin=None):
nom = m.group(1)
jours[nom.split("_", 1)[1] if "_" in nom else nom] += 1
if jours:
print(f" Métriques système (metrics/, un CSV par métrique et par jour ; aucun outil ne les lit) : {len(jours)} : "
print(f" Métriques système (metrics/, un CSV par métrique et par jour ; lues par metriques.py) : {len(jours)} : "
+ ", ".join(f"{k} ({n} j)" for k, n in sorted(jours.items())))
for titre, chemins in (("Images de la caméra", f["images"]),
("Images différentielles (images_diff/ ; aucun outil ne les lit)", glob.glob(os.path.join(dossier, "images_diff", "*")))):
@@ -100,20 +142,28 @@ def contenu(dossier, f, debut=None, fin=None):
print(" Autres : " + ", ".join(f"{k} ({len(v)})" for k, v in sorted(autres.items())))
def images(chemins):
def images(chemins, debut=None, fin=None):
heures = sorted(h for h in map(heure_image, chemins) if h)
print(f"Images : {len(chemins)}" + (f", du {iso(heures[0])} au {iso(heures[-1])}" if heures else ""))
inconnues = [p for p in chemins if heure_image(p) is None]
if inconnues:
print(f" noms sans heure reconnue : {len(inconnues)}")
if heures:
manquantes = []
for a, b in zip(heures, heures[1:]):
h = a + timedelta(hours=1)
while h < b:
manquantes.append(iso(h))
h += timedelta(hours=1)
print(f" heures pleines sans image entre la première et la dernière : {', '.join(manquantes) or 'aucune'}")
heures = [h for h in heures if filtrer([{"t": h}], debut, fin)]
if len(heures) < 2:
return
# Suites d'images à écart régulier (arrondi à 5 min, ce qui absorbe les quelques secondes de retard d'une prise) :
# une ligne par changement d'écart, sans rien perdre des heures couvertes.
suites = [] # [première, dernière, écart en min, nombre d'écarts]
for a, b in zip(heures, heures[1:]):
e = round((b - a).total_seconds() / 300) * 5
if suites and suites[-1][2] == e:
suites[-1][1], suites[-1][3] = b, suites[-1][3] + 1
else:
suites.append([a, b, e, 1])
quoi = "sur la fenêtre" if debut or fin else "entre la première et la dernière"
print(f" écart entre deux images {quoi}, par suite d'écarts égaux (à 5 min près) :")
for a, b, e, n in suites:
print(f" {iso(a)} → {iso(b)} : " + (f"{n + 1} images, toutes les {e} min" if n > 1 else f"un écart de {e} min"))
def mesures(par):
@@ -132,6 +182,10 @@ def mesures(par):
noms = sorted(par, key=lambda s: (not est_reference(par[s]), s))
refs = [s for s in noms if est_reference(par[s])]
print(f"\nCapteurs : {len(par)} ({len(refs)} références, {len(par) - len(refs)} cibles)")
vides = [s for s in noms if not any(m["pattern_type"] for m in par[s])]
if vides:
print(f" pattern_type vide pour {len(vides)} capteurs : référence quand reproj_err ou inlier est rempli "
"(références seulement, docs/domaine/colonnes-des-deplacements.md)")
print(f"{'capteur':10} {'type':10} {'motif':11} {'seuil':>5} {'mesures':>7} {'rejetées':>8}")
for s in noms:
ms = par[s]
@@ -161,7 +215,7 @@ def camera(dossier, par, debut=None, fin=None):
print(f"Instants de mesure sans pose (pas de recalage) : {sum(x[2] for x in suites)} sur {len(instants)}")
if debut or fin:
for a, b, n, _ in suites:
print(f" {iso(a)}" + ("" if n == 1 else f" → {iso(b)} ({n})"))
print(f" {suite(a, b, n)}")
def fenetre(par, debut, fin):
@@ -196,22 +250,27 @@ def fenetre(par, debut, fin):
else:
suites.append([t, t, 1])
if rej:
print(f" {s} ({len(rej)}) : " + "; ".join(iso(a) if a == b else f"{iso(a)} → {iso(b)} ({n})" for a, b, n in suites))
print(f" {s} ({len(rej)}) : " + "; ".join(suite(a, b, n) for a, b, n in suites))
if not any(rejetee(m) for d in series.values() for m in d.values()):
print(" (aucune)")
refs = [s for s in noms if est_reference(par[s])]
if not any(m["inlier"] is not None for s in refs for m in series[s].values()):
print("Références retenues par la compensation : colonne inlier absente ou vide.")
# inlier dit quelles références la compensation retient ; certains exports ne le remplissent pas (et parfois
# reproj_err seulement) : on prend alors reproj_err rempli, et le titre le dit.
col = next((c for c in ("inlier", "reproj_err") if any(m[c] is not None for s in refs for m in series[s].values())), None)
if col is None:
print("Références retenues par la compensation : colonnes inlier et reproj_err absentes ou vides.")
return
retenue = (lambda m: m["inlier"] == 1) if col == "inlier" else (lambda m: m["reproj_err"] is not None)
def marque(s, t):
m = series[s].get(t)
return "absente" if m is None else "r" if rejetee(m) else "0" if m["inlier"] == 0 else "vide"
hors = [(t, tuple((s, marque(s, t)) for s in refs if t not in series[s] or series[s][t]["inlier"] != 1)) for t in dans]
return "absente" if m is None else "r" if rejetee(m) else "vide" if m[col] is None else f"{m[col]:g}"
hors = [(t, tuple((s, marque(s, t)) for s in refs if t not in series[s] or not retenue(series[s][t]))) for t in dans]
compte = collections.Counter(len(refs) - len(h) for _, h in hors)
print(f"Références retenues par la compensation (inlier = 1) sur {len(refs)}, nombre d'instants : "
quoi = "inlier = 1" if col == "inlier" else "inlier vide sur la fenêtre : reproj_err rempli à la place"
print(f"Références retenues par la compensation ({quoi}) sur {len(refs)}, nombre d'instants : "
+ ", ".join(f"{k} : {compte[k]}" for k in sorted(compte, reverse=True)))
print("Instants où des références ne sont pas retenues (suites de pas consécutifs avec les mêmes références hors ; "
"r = rejetée, 0 = inlier 0, vide = inlier vide) :")
f"r = rejetée, vide = {col} vide, sinon la valeur d'inlier) :")
suites = []
for i, (t, h) in enumerate(hors):
if h and suites and suites[-1][3] == h and suites[-1][4] == i - 1:
@@ -219,7 +278,7 @@ def fenetre(par, debut, fin):
elif h:
suites.append([t, t, 1, h, i])
for a, b, n, h, _ in suites:
print(f" {iso(a) if n == 1 else f'{iso(a)} → {iso(b)} ({n})'} : {len(refs) - len(h)} retenues ; hors : "
print(f" {suite(a, b, n)} : {len(refs) - len(h)} retenues ; hors : "
+ ", ".join(f"{s} ({q})" for s, q in h))
if not suites:
print(" (aucun)")
@@ -230,7 +289,7 @@ def main(dossier, debut=None, fin=None, tout=False):
f = trouver(dossier)
fichiers(f, tout)
contenu(dossier, f, debut, fin)
images(f["images"])
images(f["images"], debut, fin)
par = charger(dossier)
mesures(par)
if par:
+123 -3
View File
@@ -1,7 +1,7 @@
"""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] [--debut ...] [--fin ...] [--sortie DOSSIER]
[--nuit 20-3] [--k 5] [--jours 2] [--pas 15min] [--capteurs A,B] [--bornes] [--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 ;
@@ -20,6 +20,20 @@ la nuit en cours au début de la fenêtre compte aussi (ses heures après minuit
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. 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
@@ -27,14 +41,14 @@ import math
import os
import statistics
import sys
from datetime import timedelta
from datetime import datetime, timedelta, timezone
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt # noqa: E402
from donnees import charger, est_reference, filtrer, instant, iso, rejetee # 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
@@ -74,6 +88,7 @@ def main():
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("--debut", type=instant)
a.add_argument("--fin", type=instant)
a.add_argument("--sortie", default=os.path.join(RACINE, "out", "diagnostic"), help="dossier des PNG")
@@ -189,6 +204,111 @@ def main():
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]}",
{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
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}"
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 ==")
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):
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
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"))
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]
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 '-'}) "
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"
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:
i = j = x
while i > 0 and signe * p[i - 1][1] > o.k * bruit:
i -= 1
while j + 1 < len(p) and signe * p[j + 1][1] > o.k * bruit:
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)
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:
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 de {o.k:g} bruits, foncé : la suite autour de l'extrême ; points : max et min du jour")
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()
+264
View File
@@ -0,0 +1,264 @@
"""Métriques système de la station (metrics/ : températures, tension, batterie, lien…), en table et en figure,
face à la médiane des cibles de corr_x, corr_y et à la pose de la caméra.
Usage : .venv/bin/python agent-tools/metriques.py data/PS_DES_COUDRES/
[--noms sensor_A0_deg_c,BusVoltage] [--pas 1h] [--stat median|min|max] [--contre temperature] [--lissage 24h]
[--metriques-seules] [--debut ...] [--fin ...] [--sortie DOSSIER]
Colonnes : `temperature` (médiane des composants sensor_*_deg_c à chaque heure, comme la lisent les détecteurs,
donnees.charger_temperature), puis chaque métrique de --noms (défaut : les *_deg_c et BusVoltage présents), puis,
sauf --metriques-seules, cib_corr_x, cib_corr_y (à chaque mesure, médiane sur les cibles de corr moins le niveau
propre de la cible, sa médiane sur la fenêtre ; mesures acceptées seulement) et la pose brute de la caméra (cam_pan,
cam_tilt, cam_rotation, cam_scale, cam_sigma0). Une case vide d'un CSV de metrics/ est sautée, pas lue comme zéro.
Une métrique texte (BatteryState, link, last_sync…) est rendue telle quelle (la dernière du pas).
Jamais d'identifiant : SIM_CCID et ip* ne sont ni lus ni listés.
Imprime : les métriques disponibles ; la table, une ligne par pas de --pas (début du pas, UTC ; --stat des valeurs du
pas ; « - » : aucune valeur), les pas où aucune métrique n'a de valeur n'y sont pas ; par colonne, le nombre de pas
remplis, le minimum et le maximum avec leur instant ; la corrélation r et la pente (moindres carrés, sur les pas où
les deux ont une valeur) de chaque colonne numérique sur --contre (défaut temperature ; avec --lissage D, sur sa
moyenne glissante centrée sur D, colonne <contre>_lisse) ; les suites datées de pas sans aucune métrique.
Un PNG, chemin imprimé : températures sur un panneau, chaque autre métrique numérique sur le sien, puis cib_corr_x,
cib_corr_y et la pose, aux instants natifs (trait coupé sur un trou). Rend des valeurs, pas de verdict.
"""
import argparse
import csv
import glob
import os
import statistics
import sys
from datetime import date, timedelta
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 # noqa: E402
from graphique import RACINE, borne # noqa: E402
from inventaire import METRIQUE_RE # noqa: E402
from resume import STATS, duree # noqa: E402
def identifiant(nom):
"""Métrique qui porte un identifiant (carte SIM, adresses IP) : jamais lue."""
return nom == "SIM_CCID" or nom.startswith("ip")
def valeur(texte):
v = texte.strip().strip("[]").strip("'\"")
try:
return float(v)
except ValueError:
return v or None
def lire_metriques(dossier, debut, fin):
"""metrics/ -> {nom: [{'t', 'v'}]} triées, sur la fenêtre ; v float ou texte ; case vide sautée ; nom sans valeur : []."""
prefixe = os.path.basename(os.path.normpath(dossier)) + "_"
par = {}
for p in glob.glob(os.path.join(dossier, "metrics", "*.csv")):
m = METRIQUE_RE.match(os.path.basename(p))
if not m:
continue
nom = m.group(1)
nom = nom[len(prefixe):] if nom.startswith(prefixe) else nom.split("_", 1)[-1]
if identifiant(nom):
continue
jour = date(*map(int, m.group(2, 3, 4)))
serie = par.setdefault(nom, {})
if (debut and jour < debut.date() - timedelta(days=1)) or (fin and jour > fin.date()):
continue
with open(p, newline="") as f:
for r in csv.DictReader(f):
if (v := valeur(r.get("metric") or "")) is not None:
serie[instant(r["time_utc"])] = v
return {n: filtrer([{"t": t, "v": s[t]} for t in sorted(s)], debut, fin) for n, s in par.items()}
def cibles(par, col, debut, fin):
"""À chaque mesure, médiane sur les cibles de col moins le niveau propre de la cible (médiane sur la fenêtre)."""
ecarts = {}
for s, ms in par.items():
if est_reference(ms):
continue
ms = [m for m in filtrer(ms, debut, fin) if m[col] is not None]
if ms:
niveau = statistics.median(m[col] for m in ms)
for m in ms:
ecarts.setdefault(m["t"], []).append(m[col] - niveau)
return [{"t": t, "v": statistics.median(v)} for t, v in sorted(ecarts.items())]
def lisser(serie, largeur):
"""Moyenne glissante centrée sur largeur (valeurs numériques)."""
pts = [p for p in serie if isinstance(p["v"], float)]
# ponytail: O(n²), assez pour des métriques horaires sur quelques semaines
return [{"t": p["t"], "v": statistics.fmean(q["v"] for q in pts if abs(q["t"] - p["t"]) <= largeur / 2)} for p in pts]
def fmt(v):
return "-" if v is None else f"{v:.6g}" if isinstance(v, float) else str(v)
def suites(pas_vides, pas):
"""[t] triés -> [(début, fin, n)] de pas consécutifs."""
out = []
for t in pas_vides:
if out and t - out[-1][1] == pas:
out[-1] = (out[-1][0], t, out[-1][2] + 1)
else:
out.append((t, t, 1))
return out
def coupe(serie):
"""Instants et valeurs numériques, NaN inséré sur un écart de plus de 1,5 fois le pas habituel (le trait se coupe)."""
pts = [(p["t"], p["v"]) for p in serie if isinstance(p["v"], float)]
if len(pts) < 3:
return [t for t, _ in pts], [v for _, v in pts]
pas = statistics.median(b[0] - a[0] for a, b in zip(pts, pts[1:]))
ts, vs = [pts[0][0]], [pts[0][1]]
for (a, _), (b, v) in zip(pts, pts[1:]):
if b - a > 1.5 * pas:
ts.append(a + (b - a) / 2)
vs.append(float("nan"))
ts.append(b)
vs.append(v)
return ts, vs
def main():
a = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
a.add_argument("dossier")
a.add_argument("--noms", help="métriques, séparées par des virgules (défaut : les *_deg_c et BusVoltage présents)")
a.add_argument("--pas", default="1h")
a.add_argument("--stat", default="median", choices=STATS)
a.add_argument("--contre", default="temperature", help="colonne sur laquelle r et la pente sont calculés")
a.add_argument("--lissage", type=duree, help="moyenne glissante centrée de --contre, ex. 24h")
a.add_argument("--metriques-seules", action="store_true", help="sans cib_corr_x, cib_corr_y ni la pose")
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()
pas = duree(o.pas)
met = lire_metriques(o.dossier, o.debut, o.fin)
if not met:
print(f"Pas de metrics/ dans {o.dossier}.")
else:
print("Métriques disponibles (valeurs sur la fenêtre ; identifiants SIM_CCID, ip* exclus) : "
+ ", ".join(f"{n} ({len(s)})" if s else f"{n} (vide)" for n, s in sorted(met.items())))
if o.noms:
noms = o.noms.split(",")
if interdits := [n for n in noms if identifiant(n)]:
sys.exit(f"Identifiants, jamais lus : {', '.join(interdits)}.")
if absents := [n for n in noms if n not in met]:
sys.exit(f"Métriques inconnues : {', '.join(absents)}. Connues : {', '.join(sorted(met))}.")
else:
noms = sorted(n for n in met if n.endswith("_deg_c")) + [n for n in ("BusVoltage",) if n in met]
series = {"temperature": filtrer([{"t": t, "v": v} for t, v in charger_temperature(o.dossier)], o.debut, o.fin)}
series.update({n: met[n] for n in noms})
if o.lissage:
if o.contre not in series:
sys.exit(f"--contre {o.contre} : pas une colonne ({', '.join(series)}).")
series[o.contre + "_lisse"] = lisser(series[o.contre], o.lissage)
metriques = list(series)
if not o.metriques_seules:
par = charger(o.dossier)
for c in ("corr_x", "corr_y"):
series["cib_" + c] = cibles(par, c, o.debut, o.fin)
poses = filtrer(charger_camera(o.dossier), o.debut, o.fin)
for c in POSE:
series["cam_" + c] = [{"t": p["t"], "v": p[c]} for p in poses if p[c] is not None]
reference = o.contre + "_lisse" if o.lissage else o.contre
if reference not in series:
sys.exit(f"--contre {o.contre} : pas une colonne ({', '.join(series)}).")
tous = [p["t"] for s in series.values() for p in s]
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)
cases = {} # colonne -> début du pas -> valeurs
for c, s in series.items():
for p in s:
cases.setdefault(c, {}).setdefault(t0 + ((p["t"] - t0) // pas) * pas, []).append(p["v"])
stat = STATS[o.stat]
table = {c: {k: (stat(v) if all(isinstance(x, float) for x in v) else v[-1]) for k, v in d.items()}
for c, d in cases.items()}
grille = [t0 + i * pas for i in range(int((t1 - t0) / pas) + 1)]
colonnes = list(series)
print(f"\n{o.stat} par pas de {o.pas} (début du pas, UTC) ; « - » : aucune valeur ; cib_ : écart au niveau propre des cibles")
print("\t".join(["heure"] + colonnes))
for k in grille:
ligne = [table.get(c, {}).get(k) for c in colonnes]
if any(v is not None for v in ligne):
print("\t".join([iso(k)] + [fmt(v) for v in ligne]))
print(f"\nPar colonne ({len(grille)} pas) :")
for c in colonnes:
d = table.get(c, {})
nums = [(v, k) for k, v in d.items() if isinstance(v, float)]
if not d:
print(f" {c} : vide")
elif nums:
(vmin, kmin), (vmax, kmax) = min(nums), max(nums)
print(f" {c} : {len(d)} pas ; min {fmt(vmin)} ({iso(kmin)}) ; max {fmt(vmax)} ({iso(kmax)})")
else:
ks = sorted(d)
print(f" {c} : {len(d)} pas, texte ; {len(set(d.values()))} valeurs distinctes ; "
f"première {d[ks[0]]} ({iso(ks[0])}) ; dernière {d[ks[-1]]} ({iso(ks[-1])})")
ref = table.get(reference, {})
print(f"\nCorrélation r et pente sur {reference} (par pas où les deux ont une valeur) :")
if not any(isinstance(v, float) for v in ref.values()):
print(f" {reference} vide : aucune")
for c in colonnes:
if c == reference or not ref or not any(isinstance(v, float) for v in table.get(c, {}).values()):
continue
paires = [(ref[k], v) for k, v in table.get(c, {}).items()
if isinstance(v, float) and isinstance(ref.get(k), float)]
try:
r = statistics.correlation(*zip(*paires))
pente = statistics.linear_regression(*zip(*paires)).slope
print(f" {c} : r = {r:+.2f} ; pente = {pente:.4g} par unité de {reference} ; n = {len(paires)}")
except (statistics.StatisticsError, TypeError, ValueError):
print(f" {c} : - (n = {len(paires)})")
vides = [k for k in grille if all(k not in table.get(c, {}) for c in metriques)]
print(f"\nPas sans aucune métrique ({', '.join(metriques)}) : {len(vides)} sur {len(grille)}")
for d, f, n in suites(vides, pas):
print(f" {iso(d)} → {iso(f)} ({n} pas)")
panneaux = {} # titre -> colonnes
for c in colonnes:
if any(isinstance(p["v"], float) for p in series[c]):
cle = "°C" if c.startswith("temperature") or "_deg_c" in c else c
panneaux.setdefault(cle, []).append(c)
if not panneaux:
print("\nRien à tracer.")
return
fig, axes = plt.subplots(len(panneaux), 1, sharex=True, figsize=(14, 2.4 * len(panneaux)), squeeze=False,
layout="constrained")
for ax, (titre, cols) in zip(axes[:, 0], panneaux.items()):
for c in cols:
noir = c in ("temperature", reference)
ax.plot(*coupe(series[c]), ".-", ms=2, lw=1.4 if noir else 0.7, label=c, zorder=3 if noir else 2,
color="k" if c == "temperature" else None)
if len(cols) > 1:
ax.legend(loc="upper left", bbox_to_anchor=(1.0, 1.0), fontsize=8)
ax.set_ylabel(titre if titre == "°C" else titre.replace("_", "_\n", 1), fontsize=8)
ax.grid(alpha=0.3)
axes[-1, 0].xaxis.set_major_formatter(mdates.DateFormatter("%d/%m\n%H:%MZ"))
station = os.path.basename(os.path.normpath(o.dossier))
fig.suptitle(f"{station} : métriques, cibles et pose (heures UTC)")
os.makedirs(o.sortie, exist_ok=True)
sortie = os.path.join(o.sortie, f"{station}_metriques_{borne(o.debut, 'debut')}_{borne(o.fin, 'fin')}.png")
fig.savefig(sortie, dpi=100, bbox_inches="tight")
print(f"\n{sortie}")
if __name__ == "__main__":
main()
+62 -12
View File
@@ -1,7 +1,8 @@
"""Plages datées par capteur et par colonne, au pas natif des mesures, pour l'agent de diagnostic.
Usage : python3 agent-tools/plages.py data/PS_DES_COUDRES/ [--colonnes error_value,corr_x,corr_y]
[--k 5] [--fusion 1h] [--min-mesures 1] [--hors T1/T2] [--capteurs A,B] [--debut ...] [--fin ...]
[--k 5] [--fusion 1h] [--min-mesures 1] [--hors T1/T2] [--glissant N|DUREE] [--instants N]
[--capteurs A,B] [--debut ...] [--fin ...]
Pour chaque colonne, chaque capteur est comparé à son propre niveau sur la fenêtre --debut/--fin (médiane des
valeurs non vides ; avec --hors T1/T2, celle du reste de la fenêtre, hors du moment lu : utile quand un épisode
@@ -17,15 +18,38 @@ long fausse la médiane) et à son bruit propre (médiane des écarts entre deux
corr_x, corr_y d'une mesure rejetée sont vides, références comprises (donnees.charger). Une plage qui touche le bord de la fenêtre est datée au
bord (le niveau est celui de la fenêtre : un palier durable peut faire de l'autre moitié la « plage »).
Avec --min-mesures N, seules les plages d'au moins N mesures hors niveau sont imprimées (leur nombre total aussi).
Avec --glissant N (un entier : N mesures non vides de part et d'autre) ou --glissant DUREE (6h, 1d : les mesures
à moins de DUREE avant et après), le niveau de chaque mesure est la médiane de ses voisines, sans elle (niveau
local) : une dérive longue ou un palier suivent le niveau, seuls restent les écarts plus brefs que la fenêtre.
La colonne « niveau » du tableau 1 reste la médiane de la fenêtre ; le bruit ne change pas.
3. Avec --instants N : les instants où au moins N capteurs sont hors niveau (sur l'une des colonnes), avec, pour
chacun, les capteurs et l'écart en bruits (cx corr_x, cy corr_y, ev error_value, sinon le nom de la colonne),
les capteurs rejetés à cet instant (parmi --capteurs : en retirer les capteurs toujours rejetés allège la liste),
et chaque référence de la station, --capteurs ou non : error_value (« r » si rejetée) / inlier (« - » vide).
Chaque colonne est lue aux mesures, jamais moyennée par pas. Rend des valeurs, pas de verdict.
"""
import argparse
import bisect
import statistics
import sys
from donnees import charger, est_reference, filtrer, instant, iso, rejetee
from resume import COLONNES, duree
ABREGE = {"corr_x": "cx", "corr_y": "cy", "error_value": "ev"}
def locaux(ms, g):
"""Niveau local de chaque mesure (t, v) : médiane des voisines non vides, sans elle ; g entier (mesures de part et
d'autre) ou timedelta (mesures à moins de g) ; None sans voisine."""
ts, vs = [t for t, _ in ms], [v for _, v in ms]
out = []
for i, t in enumerate(ts):
lo, hi = (max(0, i - g), i + g + 1) if isinstance(g, int) else (bisect.bisect_left(ts, t - g), bisect.bisect_right(ts, t + g))
w = vs[lo:i] + vs[i + 1:hi]
out.append(statistics.median(w) if w else None)
return out
def main():
a = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
@@ -35,6 +59,9 @@ def main():
a.add_argument("--fusion", default="1h", type=duree, help="deux plages séparées de moins que cela n'en font qu'une")
a.add_argument("--min-mesures", type=int, default=1, help="n'imprime que les plages d'au moins N mesures hors niveau")
a.add_argument("--hors", help="T1/T2 : niveau et bruit se calculent hors de ce moment (les plages se cherchent partout)")
a.add_argument("--glissant", type=lambda x: int(x) if x.isdigit() else duree(x),
help="N (mesures de part et d'autre) ou durée (6h, 1d) : niveau local, médiane des voisines sans la mesure")
a.add_argument("--instants", type=int, help="N : instants où au moins N capteurs sont hors niveau, avec rejets et références")
a.add_argument("--capteurs", help="liste séparée par des virgules (défaut : tous)")
a.add_argument("--debut", type=instant)
a.add_argument("--fin", type=instant)
@@ -55,6 +82,8 @@ def main():
series = {s: filtrer(par[s], o.debut, o.fin) for s in noms}
if not any(series.values()):
sys.exit("Aucune mesure dans la fenêtre demandée.")
glis = (f"{o.glissant} mesures" if isinstance(o.glissant, int) else f"{int(o.glissant.total_seconds() // 60)} min") if o.glissant is not None else ""
par_instant = {} # iso(t) -> ["capteur.col+écart"] (--instants)
for col in colonnes:
print(f"\n== {col} : niveau, bruit, plus grand saut d'une mesure à la suivante ==")
@@ -80,27 +109,48 @@ def main():
+ (f" (rejetée : {', '.join(marque)})" if marque else ""))
if not bruit:
continue
groupe = []
for t, v in ms + [(None, 0)]:
if t is not None and abs(v - niv) > o.k * bruit:
if groupe and (t - groupe[-1][0] > o.fusion or (v > niv) != (groupe[-1][1] > niv)): # même sens seul
plages.append((s, groupe, niv, bruit, rej))
lv = locaux(ms, o.glissant) if o.glissant is not None else [niv] * len(ms)
groupe = [] # (t, écart au niveau)
for (t, v), n in zip(ms + [(None, 0)], lv + [None]):
if t is not None and n is not None and abs(v - n) > o.k * bruit:
if groupe and (t - groupe[-1][0] > o.fusion or (v > n) != (groupe[-1][1] > 0)): # même sens seul
plages.append((s, groupe, bruit, rej))
groupe = []
groupe.append((t, v))
groupe.append((t, v - n))
par_instant.setdefault(iso(t), {}).setdefault(s, []).append(f"{ABREGE.get(col, col)}{(v - n) / bruit:+.0f}")
elif t is None and groupe:
plages.append((s, groupe, niv, bruit, rej))
plages.append((s, groupe, bruit, rej))
toutes = len(plages)
plages = [p for p in plages if len(p[1]) >= o.min_mesures]
print(f"\n{col} : plages à plus de {o.k:g} bruits du niveau{' (niveau hors ' + o.hors + ')' if hors else ''} (fusion {int(o.fusion.total_seconds() // 60)} min)"
print(f"\n{col} : plages à plus de {o.k:g} bruits du niveau{' glissant ±' + glis + ' (médiane des voisines)' if glis else ''}{' (niveau hors ' + o.hors + ')' if hors and not glis else ''}{' (bruit hors ' + o.hors + ')' if hors and glis else ''} (fusion {int(o.fusion.total_seconds() // 60)} min)"
+ (f" ; {len(plages)} d'au moins {o.min_mesures} mesures sur {toutes}" if o.min_mesures > 1 else ""))
print(f"{'capteur':9}{'début':<18}{'fin':<18}{'mesures':>8}{'extrême':>10}{'(bruits)':>9} {'à':<17}{'rejetées':>9}")
for s, g, niv, bruit, rej in plages:
t, v = max(g, key=lambda x: abs(x[1] - niv))
print(f"{s:9}{iso(g[0][0]):<18}{iso(g[-1][0]):<18}{len(g):8}{v - niv:+10.4g}{(v - niv) / bruit:9.1f} {iso(t):<17}"
for s, g, bruit, rej in plages:
t, d = max(g, key=lambda x: abs(x[1]))
print(f"{s:9}{iso(g[0][0]):<18}{iso(g[-1][0]):<18}{len(g):8}{d:+10.4g}{d / bruit:9.1f} {iso(t):<17}"
f"{sum(x[0] in rej for x in g):9}{' extrême rejetée' if t in rej else ''}")
if not plages:
print("(aucune)")
if o.instants is not None:
refs = sorted(s for s in par if est_reference(par[s]))
rej_t, ref_t = {}, {s: {} for s in refs}
for s in set(noms) | set(refs):
for m in filtrer(par[s], o.debut, o.fin):
if rejetee(m) and s in noms:
rej_t.setdefault(iso(m["t"]), []).append(s)
if s in ref_t:
ref_t[s][iso(m["t"])] = m
f = lambda v, fmt: "-" if v is None else format(v, fmt)
lignes = [(t, c) for t, c in sorted(par_instant.items()) if len(c) >= o.instants]
print(f"\nInstants où au moins {o.instants} capteurs sont à plus de {o.k:g} bruits du niveau{' glissant ±' + glis if glis else ''} "
f"({', '.join(colonnes)}) : {len(lignes)} sur {len(par_instant)} instants avec au moins un capteur hors niveau")
print("instant n capteurs hors niveau (écart en bruits) | rejetés | références : error_value (r rejetée) / inlier")
for t, c in lignes:
r = " ".join(f"{s} {f(ref_t[s][t]['error_value'], '.3g')}{'r' if rejetee(ref_t[s][t]) else ''}/{f(ref_t[s][t]['inlier'], 'g')}"
for s in refs if t in ref_t[s])
print(f"{t} {len(c):3} {' '.join(s + '.' + ','.join(v) for s, v in c.items())} | {','.join(rej_t.get(t, [])) or '-'} | {r or '-'}")
if __name__ == "__main__":
main()
+16 -4
View File
@@ -2,13 +2,17 @@
Usage : python3 agent-tools/resume.py data/PS_DES_COUDRES/ [--colonne error_value]
[--stat median|min|max] [--pas 1h] [--niveau periode|fenetre] [--capteurs CAPTEUR_A,CAPTEUR_B] [--debut 2026-01-01T00:00Z] [--fin ...]
[--instants T1,T2] [--marque]
1. Niveau habituel de chaque capteur : médiane, MAD (écart absolu médian), min, max, sur toute la période
(défaut) ou, avec --niveau fenetre, sur la fenêtre --debut/--fin seulement (un changement de niveau
dans la fenêtre ne se compare pas à des semaines d'autres mesures).
2. Tableau : une ligne par pas de temps (début du pas, UTC), une colonne par capteur, la statistique
choisie sur les mesures du pas. « rej » : toutes les mesures du pas sont rejetées ; « vide » : des mesures,
mais la colonne est vide (ex. reproj_err d'une cible) ; « - » : aucune mesure.
mais la colonne est vide (ex. reproj_err d'une cible) ; « - » : aucune mesure. L'en-tête des capteurs se répète
toutes les 24 lignes. Avec --instants T1,T2 : seulement les pas qui contiennent ces instants. Avec --marque : « * »
après la valeur quand une mesure du pas est rejetée (x, y, error_value d'une mesure rejetée restent remplis),
« o » quand une mesure du pas a inlier = 0 (référence écartée par la compensation).
Rend des valeurs, pas de verdict.
"""
import argparse
@@ -45,6 +49,8 @@ def main():
a.add_argument("--niveau", default="periode", choices=("periode", "fenetre"),
help="période sur laquelle médiane et MAD sont calculées (défaut : toutes les mesures)")
a.add_argument("--capteurs", help="liste séparée par des virgules (défaut : tous)")
a.add_argument("--instants", help="T1,T2 : seulement les pas qui contiennent ces instants")
a.add_argument("--marque", action="store_true", help="* : une mesure du pas rejetée ; o : une mesure du pas avec inlier = 0")
a.add_argument("--debut", type=instant)
a.add_argument("--fin", type=instant)
o = a.parse_args()
@@ -80,14 +86,20 @@ def main():
print(f"\n{o.stat} de {o.colonne} par pas de {o.pas} (début du pas, UTC) :")
print("rej : mesures du pas toutes rejetées ; vide : colonne vide ; - : aucune mesure")
print(f"{'début':17} " + " ".join(f"{s:>9}" for s in noms))
for k in sorted(cases):
if o.marque:
print("* : une mesure du pas au moins est rejetée ; o : une mesure du pas au moins a inlier = 0")
entete = f"{'début':17} " + " ".join(f"{s:>9}" for s in noms)
voulus = {t0 + ((instant(x) - t0) // o.pas) * o.pas for x in o.instants.split(",")} if o.instants else None
for i, k in enumerate(k for k in sorted(cases) if voulus is None or k in voulus):
if i % 24 == 0:
print(entete)
cellules = []
for s in noms:
ms = cases[k].get(s, [])
v = valeurs(ms, o.colonne)
if v:
cellules.append(f"{STATS[o.stat](v):9.5g}")
marque = ("*" if any(map(rejetee, ms)) else "") + ("o" if any(m["inlier"] == 0 for m in ms) else "") if o.marque else ""
cellules.append(f"{STATS[o.stat](v):.5g}{marque}".rjust(9))
else:
cellules.append(f"{'-' if not ms else 'rej' if all(map(rejetee, ms)) else 'vide':>9}")
print(f"{iso(k):17} " + " ".join(cellules))
+70 -12
View File
@@ -14,7 +14,14 @@ pic imprimés pour chaque vignette). Un --rayon plus petit (30 à 50) grossit. L
Le centre du cadre (px) est écrit sous chaque vignette : quand les x, y de l'export sautent, le cadre se déplace
d'autant. --fixe garde, sur chaque ligne, le cadre centré sur la position de la première heure demandée, et marque
d'une croix rouge les x, y de l'export à chaque heure : une tache qui entre dans le cadre ou en sort ne s'y confond
pas avec une tache qui apparaît.
pas avec une tache qui apparaît. Un cadre que le bord de l'image coupe est signalé (taille de l'image) : sur certains
exports, x, y ne sont pas des pixels (valeurs proches de 0), et le cadre tombe dans le coin de l'image.
--zone X,Y,L,H : la même zone de l'image (pixels de l'image d'origine : coin haut gauche, largeur, hauteur, comme
gif.py) à chaque heure, côte à côte (jusqu'à 4 par ligne, moins quand la zone est large), même étirement avec --contraste ; --capteurs devient facultatif :
ceux qui sont donnés sont marqués d'une croix rouge et de leur nom à leurs x, y de chaque heure. Pour la scène autour
des cibles (premier plan, objet, éclairage), qu'un grand --rayon rendrait trop petite.
Chaque vignette est rendue à sa taille en pixels (un pixel de l'image pour un pixel du PNG) de 260 à 1000 px de côté ;
Read réduit un PNG trop large : avec un grand --rayon ou une grande --zone, peu d'heures par planche.
"""
import argparse
import os
@@ -41,17 +48,21 @@ RACINE = os.path.normpath(os.path.join(os.path.dirname(os.path.abspath(__file__)
def main():
a = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
a.add_argument("dossier")
a.add_argument("--capteurs", required=True, help="liste séparée par des virgules")
a.add_argument("--capteurs", default="", help="liste séparée par des virgules (facultative avec --zone)")
a.add_argument("--heures", required=True, help="heures des images, séparées par des virgules (UTC)")
a.add_argument("--rayon", type=int, default=100, help="demi-côté de la vignette en pixels (défaut 100)")
a.add_argument("--contraste", nargs="?", const="auto", metavar="MIN,MAX", help="niveaux de gris, même étirement pour toute la planche : MIN,MAX (0 à 255) ou, sans valeur, du 1er centile au maximum de la planche")
a.add_argument("--fixe", action="store_true", help="un cadre fixe par capteur (position à la première heure), x, y de chaque heure marqués d'une croix")
a.add_argument("--zone", metavar="X,Y,L,H", help="la même zone de l'image à chaque heure (pixels de l'image d'origine : coin haut gauche, largeur, hauteur)")
a.add_argument("--sortie", default=os.path.join(RACINE, "out", "diagnostic"), help="dossier du PNG")
o = a.parse_args()
par = charger(o.dossier)
images = {heure_image(p): p for p in trouver(o.dossier)["images"]}
noms, heures = o.capteurs.split(","), [instant(h) for h in o.heures.split(",")]
noms, heures = [s for s in o.capteurs.split(",") if s], [instant(h) for h in o.heures.split(",")]
zone = tuple(map(int, o.zone.split(","))) if o.zone else None
if not noms and not zone:
sys.exit("Donne --capteurs, ou --zone X,Y,L,H.")
absents = [s for s in noms if s not in par]
if absents:
sys.exit(f"Capteurs inconnus : {', '.join(absents)}. Connus : {', '.join(sorted(par))}.")
@@ -63,22 +74,47 @@ def main():
if proche[h] != h:
print(f"Pas d'image à {iso(h)} : la plus proche est celle de {iso(proche[h])} (écart {abs(proche[h] - h)}).")
def niveaux(c):
gris = c[..., :3].mean(axis=-1) if c.ndim == 3 else c
return gris * 255 if gris.max() <= 1 and c.dtype.kind == "f" else gris
def mesure(s, t):
return min((m for m in par[s] if m["x"] is not None), key=lambda m: abs(m["t"] - t))
r = o.rayon
coupes, centres, croix = {}, {}, {}
for j, h in enumerate(heures):
img = plt.imread(images[proche[h]])
haut, larg = img.shape[:2]
if zone:
X, Y, L, H = zone
c = img[max(Y, 0):Y + H, max(X, 0):X + L]
if c.size == 0:
sys.exit(f"--zone {o.zone} hors de l'image ({larg} × {haut} px).")
gris = niveaux(c)
coupes[0, j] = (c, gris)
croix[0, j] = [(s, m["x"] - max(X, 0), m["y"] - max(Y, 0)) for s in noms for m in [mesure(s, proche[h])]]
print(f"zone {o.zone} {iso(h)} : {os.path.basename(images[proche[h]])}, fond {centile(gris, 50):.0f}, "
f"p99 {centile(gris, 99):.0f}, pic {gris.max():.0f}"
+ ("" if c.shape[:2] == (H, L) else f", coupée par le bord de l'image ({larg} × {haut} px)")
+ "".join(f" ; {s} x={x + max(X, 0):.1f} y={y + max(Y, 0):.1f}" for s, x, y in croix[0, j]))
continue
for i, s in enumerate(noms):
m = min((m for m in par[s] if m["x"] is not None), key=lambda m: abs(m["t"] - proche[h]))
m = mesure(s, proche[h])
x, y = centres[i] if o.fixe and j else (round(m["x"]), round(m["y"]))
if j == 0:
centres[i] = (x, y)
c = img[max(y - r, 0):y + r, max(x - r, 0):x + r]
if c.size == 0:
sys.exit(f"{s} {iso(h)} : x={m['x']:.1f} y={m['y']:.1f} hors de l'image ({larg} × {haut} px) ; "
"--zone X,Y,L,H regarde une zone fixe.")
croix[i, j] = (m["x"] - max(x - r, 0), m["y"] - max(y - r, 0), x, y)
gris = c[..., :3].mean(axis=-1) if c.ndim == 3 else c
gris = gris * 255 if gris.max() <= 1 and c.dtype.kind == "f" else gris
gris = niveaux(c)
coupes[i, j] = (c, gris)
coupe = x - r < 0 or y - r < 0 or x + r > larg or y + r > haut
print(f"{s} {iso(h)} : x={m['x']:.1f} y={m['y']:.1f} (mesure de {iso(m['t'])}), {os.path.basename(images[proche[h]])}, "
f"fond {centile(gris, 50):.0f}, p99 {centile(gris, 99):.0f}, pic {gris.max():.0f}")
f"fond {centile(gris, 50):.0f}, p99 {centile(gris, 99):.0f}, pic {gris.max():.0f}"
+ (f", cadre coupé par le bord de l'image ({larg} × {haut} px)" if coupe else ""))
bornes = {}
if o.contraste:
if o.contraste == "auto":
@@ -86,14 +122,34 @@ def main():
else:
bornes = dict(zip(("vmin", "vmax"), map(float, o.contraste.split(","))))
print(f"Étirement commun : {bornes['vmin']:.0f} à {bornes['vmax']:.0f} (niveaux de gris, 0 à 255)")
fig, axes = plt.subplots(len(noms), len(heures), figsize=(2.6 * len(heures), 2.8 * len(noms)), squeeze=False)
# Une vignette à sa taille en pixels (à 100 dpi) dès qu'elle dépasse 2,6 pouces : un grand --rayon n'est plus réduit.
cote = max(c.shape[1] for c, _ in coupes.values()) / 100, max(c.shape[0] for c, _ in coupes.values()) / 100
cote = tuple(v * min(1, 10 / max(cote)) for v in cote) # au plus 1000 px de côté par vignette
if zone:
nc = max(1, min(4, len(heures), int(20 // max(2.6, cote[0])))) # planche d'au plus ~2000 px de large : Read la réduit au-delà
nl = -(-len(heures) // nc)
fig, axes = plt.subplots(nl, nc, figsize=(max(2.6, cote[0]) * nc, (max(2.6, cote[1]) + 0.4) * nl), squeeze=False)
for ax in axes.ravel()[len(heures):]:
ax.axis("off")
else:
fig, axes = plt.subplots(len(noms), len(heures), figsize=(max(2.6, cote[0]) * len(heures), (max(2.6, cote[1]) + 0.2) * len(noms)), squeeze=False)
for (i, j), (c, gris) in coupes.items():
ax = axes[i, j]
ax = axes[j // nc, j % nc] if zone else axes[i, j]
if o.contraste:
ax.imshow(gris, cmap="gray", interpolation="nearest", **bornes)
else:
ax.imshow(c, interpolation="nearest")
ax.set_title(f"{noms[i]} {proche[heures[j]].strftime('%d/%m %H:%MZ')}" + ("" if proche[heures[j]] == heures[j] else " (demandée " + heures[j].strftime('%H:%MZ') + ")"), fontsize=9)
ax.set_title(f"{'zone' if zone else noms[i]} {proche[heures[j]].strftime('%d/%m %H:%MZ')}" + ("" if proche[heures[j]] == heures[j] else " (demandée " + heures[j].strftime('%H:%MZ') + ")"), fontsize=9)
if zone:
for s, cx, cy in croix[i, j]:
ax.plot(cx, cy, "+", color="r", ms=10, mew=1)
ax.annotate(s, (cx, cy), xytext=(4, 4), textcoords="offset points", color="r", fontsize=7)
ax.set_xlim(-0.5, c.shape[1] - 0.5)
ax.set_ylim(c.shape[0] - 0.5, -0.5)
ax.set_xlabel(f"zone {o.zone}", fontsize=7)
ax.set_xticks([])
ax.set_yticks([])
continue
cx, cy, x, y = croix[i, j]
if o.fixe:
ax.plot(cx, cy, "+", color="r", ms=10, mew=1)
@@ -101,10 +157,12 @@ def main():
ax.set_xticks([])
ax.set_yticks([])
station = os.path.basename(os.path.normpath(o.dossier))
fig.suptitle(f"{station} : vignettes de {2 * r} px autour de chaque capteur (heures UTC)", fontsize=10)
fig.suptitle(f"{station} : zone {o.zone} (x, y, largeur, hauteur en px ; heures UTC)" if zone else
f"{station} : vignettes de {2 * r} px autour de chaque capteur (heures UTC)", fontsize=10)
os.makedirs(o.sortie, exist_ok=True)
sortie = os.path.join(o.sortie, f"{station}_vignettes_{'-'.join(noms)}_"
quoi = f"zone{o.zone.replace(',', '-')}" + ("_" + "-".join(noms) if noms else "") if zone else "-".join(noms)
sortie = os.path.join(o.sortie, f"{station}_vignettes_{quoi}_"
f"{'-'.join(h.strftime('%d%H%M') for h in heures)}{'_contraste' if o.contraste else ''}{'_fixe' if o.fixe else ''}.png")
fig.savefig(sortie, dpi=100, bbox_inches="tight")
print(sortie)