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:
1 parent
6fbd7510b7
commit
efbc5f15d7
9 files changed
+670
-80
No files matched your search
@@ -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
@@ -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
@@ -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
@@ -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()
|
||||
@@ -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
@@ -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
@@ -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
@@ -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)
|
||||
|
||||
Reference in new issue
Block a user