Copie des agents de Support-Agent/API (sortie mail)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
cbaab49d3f
commit
5e3faa47b4
49 files changed
+6662
No files matched your search
@@ -0,0 +1,162 @@
|
||||
"""Lecture des données d'une station pour l'agent de diagnostic (bibliothèque standard).
|
||||
|
||||
Formats : labeling/connaissances/colonnes-des-deplacements.md. Toute heure est en UTC.
|
||||
"""
|
||||
import csv
|
||||
import glob
|
||||
import os
|
||||
import re
|
||||
import statistics
|
||||
from datetime import datetime, timezone
|
||||
|
||||
# Colonnes numériques de l'export « advanced » ; une case vide devient None.
|
||||
NUM = ("x", "y", "error_value", "error_threshold", "relative_x", "relative_y",
|
||||
"corr_x", "corr_y", "reproj_err", "inlier", "sigma0",
|
||||
"peak", "flux", "sharpness", "fwhm", "dominance", "snr") # qualité de l'image : caméras récentes seulement (LENZSPITZE)
|
||||
# Pose de la caméra (camera/, pompage) : pan, tilt, rotation [deg], scale, sigma0 (résidu du recalage).
|
||||
POSE = ("pan", "tilt", "rotation", "scale", "sigma0")
|
||||
IMAGE_RE = re.compile(r"^(\d{8}T\d{4})Z_")
|
||||
|
||||
|
||||
def _entete(chemin):
|
||||
with open(chemin, newline="") as f:
|
||||
return next(csv.reader(f), [])
|
||||
|
||||
|
||||
def trouver(dossier):
|
||||
"""Dossier de station -> {'advanced', 'horaire', 'camera', 'images', 'autres'} : chemins triés, sous-dossiers compris."""
|
||||
out = {"advanced": [], "horaire": [], "camera": [], "images": [], "autres": []}
|
||||
for p in sorted(glob.glob(os.path.join(dossier, "**", "*"), recursive=True)):
|
||||
if os.path.isdir(p) or "images_diff" in p.split(os.sep): # images différentielles du pompage (--diff) : pas des vues de la caméra
|
||||
continue
|
||||
entete = _entete(p) if p.endswith(".csv") else []
|
||||
if p.lower().endswith((".jpg", ".jpeg", ".png")):
|
||||
out["images"].append(p)
|
||||
elif "sensor_name" in entete and "corr_x" in entete: # quality/ (optical_emulator) a sensor_name, pas corr_x
|
||||
out["advanced"].append(p)
|
||||
elif "timestamp" in entete:
|
||||
out["horaire"].append(p)
|
||||
elif "median_pan" in entete:
|
||||
out["camera"].append(p)
|
||||
else:
|
||||
out["autres"].append(p)
|
||||
return out
|
||||
|
||||
|
||||
def _nombre(v):
|
||||
v = v.strip()
|
||||
return float(v) if v else None
|
||||
|
||||
|
||||
def charger(dossier):
|
||||
"""Exports « advanced » du dossier -> {capteur: [mesure]}, triées par t, un seul relevé par instant.
|
||||
|
||||
Mesure : dict avec t (datetime UTC), pattern_type, et les colonnes de NUM (float ou None).
|
||||
Une mesure rejetée (voir rejetee) a corr_x, corr_y vides, comme le dit la doc des colonnes : la station
|
||||
les vide pour une cible, mais en laisse de remplis (souvent absurdes) pour une référence ; on les vide ici.
|
||||
"""
|
||||
par = {}
|
||||
for chemin in trouver(dossier)["advanced"]:
|
||||
with open(chemin, newline="") as f:
|
||||
for r in csv.DictReader(f):
|
||||
m = {c: _nombre(r.get(c) or "") for c in NUM} # inlier manque dans les exports anciens
|
||||
m["t"] = instant(r["time_utc"])
|
||||
m["pattern_type"] = r["pattern_type"]
|
||||
if rejetee(m):
|
||||
m["corr_x"] = m["corr_y"] = None
|
||||
par.setdefault(r["sensor_name"].strip(), {})[m["t"]] = m # certains exports finissent le nom par un saut de ligne
|
||||
return {s: [d[t] for t in sorted(d)] for s, d in par.items()}
|
||||
|
||||
|
||||
def charger_temperature(dossier):
|
||||
"""Températures de la carte de la station (metrics/, sensor_*_deg_c) -> [(t, °C)] triées : la médiane des composants à
|
||||
chaque heure ; [] sans ces métriques. Les composants montent et descendent ensemble (l'étiqueteur lit « les
|
||||
températures de tous les composants ») ; la médiane écarte la pointe d'un seul, le GPU qui calcule (D-124)."""
|
||||
par = {}
|
||||
for chemin in glob.glob(os.path.join(dossier, "metrics", "*_deg_c_*.csv")):
|
||||
with open(chemin, newline="") as f:
|
||||
for r in csv.DictReader(f):
|
||||
if (v := _nombre(r.get("metric") or "")) is not None:
|
||||
par.setdefault(instant(r["time_utc"]), []).append(v)
|
||||
return [(t, statistics.median(v)) for t, v in sorted(par.items())]
|
||||
|
||||
|
||||
def charger_camera(dossier):
|
||||
"""Mouvements de la caméra du dossier -> [pose] triées par t ; pose : t et les colonnes de POSE (float ou None).
|
||||
|
||||
Une ligne par recalage de la caméra ; on lit les médianes (min = max dans les fichiers reçus : une mesure par minute).
|
||||
Un instant de mesure sans pose : la caméra n'a pas été recalée.
|
||||
"""
|
||||
par = {}
|
||||
for chemin in trouver(dossier)["camera"]:
|
||||
with open(chemin, newline="") as f:
|
||||
for r in csv.DictReader(f):
|
||||
p = {c: _nombre(r.get("median_" + c, "")) for c in POSE}
|
||||
p["t"] = instant(r["time_utc"])
|
||||
par[p["t"]] = p
|
||||
return [par[t] for t in sorted(par)]
|
||||
|
||||
|
||||
IDENTIFIANTS = re.compile(r"^(SIM_CCID|ip(_.*)?)$") # identifiants de la station : jamais lus
|
||||
METRIQUE_RE = re.compile(r"^(.+?)_\d{4}_\d{2}_\d{2}_")
|
||||
|
||||
|
||||
def charger_metriques(dossier):
|
||||
"""Métriques de la station (metrics/, un CSV par métrique et par jour) -> {nom: [(t, valeur)]} triées : les
|
||||
valeurs numériques seulement (BusVoltage, sensor_CPU_deg_c, rsrp_dBm…) ; les métriques texte (link, mode…) et les
|
||||
identifiants (SIM_CCID, ip*) ne sont pas lus. Nom : celui du fichier, sans la station ni la date."""
|
||||
# ponytail: les métriques texte sont sautées ; les lire (link up/down) quand un détecteur en a besoin
|
||||
station, par = os.path.basename(os.path.normpath(dossier)) + "_", {}
|
||||
for chemin in glob.glob(os.path.join(dossier, "metrics", "*.csv")):
|
||||
if not (m := METRIQUE_RE.match(os.path.basename(chemin))):
|
||||
continue
|
||||
nom = m.group(1).removeprefix(station)
|
||||
if IDENTIFIANTS.match(nom):
|
||||
continue
|
||||
with open(chemin, newline="") as f:
|
||||
for r in csv.DictReader(f):
|
||||
try:
|
||||
v = float((r.get("metric") or "").strip("[]'\" ")) # certaines métriques arrivent en liste : ['-95']
|
||||
except ValueError:
|
||||
continue
|
||||
par.setdefault(nom, {})[instant(r["time_utc"])] = v
|
||||
return {n: sorted(d.items()) for n, d in sorted(par.items())}
|
||||
|
||||
|
||||
def est_reference(mesures):
|
||||
"""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 : labeling/connaissances/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):
|
||||
"""Mesure rejetée par la station : error_value au-dessus du seuil du capteur (error_threshold) ; sans ces deux valeurs, corr_x vide."""
|
||||
if m["error_value"] is not None and m["error_threshold"] is not None:
|
||||
return m["error_value"] > m["error_threshold"]
|
||||
return m["corr_x"] is None
|
||||
|
||||
|
||||
def filtrer(mesures, debut, fin):
|
||||
"""Mesures entre debut et fin inclus, à la minute près (comme iso() les affiche) ; None = pas de borne."""
|
||||
return [m for m in mesures if (debut is None or m["t"] >= debut)
|
||||
and (fin is None or m["t"].replace(second=0, microsecond=0) <= fin)]
|
||||
|
||||
|
||||
def heure_image(chemin):
|
||||
"""'20261013T1200Z_10167931.jpg' -> datetime UTC ; None si le nom ne suit pas ce format (D-045)."""
|
||||
m = IMAGE_RE.match(os.path.basename(chemin))
|
||||
return datetime.strptime(m.group(1), "%Y%m%dT%H%M").replace(tzinfo=timezone.utc) if m else None
|
||||
|
||||
|
||||
def instant(texte):
|
||||
"""'2026-01-01T00:00Z' ou '2026-01-01 00:00' -> datetime UTC ; une heure sans fuseau est lue en UTC."""
|
||||
t = datetime.fromisoformat(texte)
|
||||
return t.astimezone(timezone.utc) if t.tzinfo else t.replace(tzinfo=timezone.utc)
|
||||
|
||||
|
||||
def iso(t):
|
||||
return t.astimezone(timezone.utc).strftime("%Y-%m-%dT%H:%MZ")
|
||||
@@ -0,0 +1,491 @@
|
||||
"""Vue d'ensemble de tous les capteurs d'un export « advanced » : ce que font les capteurs ensemble.
|
||||
|
||||
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] [--suivre A,B]] [--table T1/T2|non] [--capteurs A,B] [--debut ...] [--fin ...] [--sortie DOSSIER]
|
||||
|
||||
Chaque capteur est comparé à son propre niveau sur la fenêtre --debut/--fin (médiane et MAD de la fenêtre).
|
||||
Deux PNG, dont les chemins sont imprimés :
|
||||
1. « commun » : d'abord, si le dossier a des mouvements de la caméra (camera/), un panneau par grandeur de la pose
|
||||
(pan, tilt, rotation [deg], scale, sigma0 du recalage), valeurs brutes, un point par recalage ; puis un panneau par colonne de --colonnes (défaut x,y,sigma0 : position brute et sigma0 de la
|
||||
caméra) : médiane, sur les capteurs, de l'écart de chaque capteur à sa médiane ; bande grise = 10e à 90e
|
||||
centile entre capteurs (la dispersion) ; sur chaque panneau sauf sigma0, en plus, chaque référence globale à part
|
||||
(son écart à sa médiane, un trait par référence) et la médiane des cibles seules (trait noir) : on voit si les
|
||||
références bougent dans l'image avec les cibles ou sans elles ; dernier panneau : nombre de capteurs dont --colonne
|
||||
(défaut error_value) dépasse sa médiane de plus de --k MAD à chaque pas.
|
||||
2. « multiples » : un petit graphique par capteur (références d'abord) de --colonne, médiane par pas de --pas,
|
||||
trait pointillé = médiane de la fenêtre ; chaque graphique a son échelle, un palier se voit.
|
||||
3. « residus-<colonne> » (un PNG par colonne de --residus, défaut corr_x,corr_y,error_value) : un petit graphique par
|
||||
capteur de la colonne moins le niveau propre du capteur (sa médiane sur la fenêtre, ou hors de --hors T1/T2 si
|
||||
donné : le niveau est alors celui du reste de la fenêtre, pas celui du moment lu), une échelle par capteur, zéro en
|
||||
pointillé ; un écart de quelques centièmes sur une colonne `corr` que les bandes parallèles de `graphique.py` cachent
|
||||
s'y voit. Imprime, par capteur, le niveau, le bruit propre (médiane des écarts entre deux mesures consécutives) et
|
||||
l'écart minimum et maximum de la médiane par pas de --pas, avec leur instant, en unités de la colonne et en bruits
|
||||
(bruit 0 et « - » en bruits : valeurs constantes à l'arrondi près, 1e-9 ; --residus non : aucun PNG de résidus).
|
||||
Avec --autres, chaque capteur est de plus ramené à l'écart à la médiane des AUTRES capteurs au même instant (on
|
||||
retranche, à chaque mesure, la médiane des autres capteurs de la même colonne moins leur niveau propre) : ce qui est
|
||||
partagé par tous (le reste de la compensation d'un mouvement commun) s'annule, ce qui est propre au capteur reste.
|
||||
PNG « residus-<colonne>-autres » ; la table imprime en plus, par capteur, la pente de ce résidu sur chaque
|
||||
colonne de --colonnes (médiane commune, ex. y) et la corrélation r : un résidu proportionnel au mouvement commun
|
||||
(même s'il n'est pas partagé par tous) a une pente non nulle et un r élevé.
|
||||
4. « rigide » (avec --rigide BASE) : à chaque mesure, le mouvement d'ensemble des cibles depuis l'instant BASE
|
||||
(similitude : translation, rotation, échelle, estimée par médianes sur les cibles, hors --sans) ; pour chaque
|
||||
capteur, le résidu dx, dy = position brute moins sa position à BASE transportée par ce mouvement [px]. Panneaux :
|
||||
dx et dy de chaque référence globale (un trait chacune) face à la médiane et au 10e-90e centile des cibles ;
|
||||
médiane et 90e centile de |résidu| des cibles ; rotation et échelle ajustées ; reproj_err des références. Imprime
|
||||
la table par pas de --pas (rot_deg, echelle, tx, ty, cib_med, cib_max, puis dx, dy de chaque référence et de chaque
|
||||
capteur de --suivre A,B), puis par capteur le min et le max de dx, dy avec leur instant et la valeur au dernier
|
||||
instant. Les mesures rejetées n'entrent ni dans l'ajustement, ni dans la bande et la médiane des cibles, cib_med,
|
||||
cib_max, ni dans les colonnes de la table ; sur le PNG, celles des références sont des croix, qui ne fixent pas l'échelle ; dans le résumé par
|
||||
capteur, elles viennent à part (nombre, min et max).
|
||||
Imprime aussi la table de la médiane commune (une ligne par pas de --pas : heure, écart à la médiane de la fenêtre
|
||||
pour chaque colonne de --colonnes, puis <colonne>_cibles, la médiane des cibles seules, puis la pose brute de la caméra, vide sans recalage) puis le minimum et le maximum de chaque colonne avec leur instant, et ceux de chaque référence globale ; pour dater
|
||||
un début ou une fin, la table est au pas de --pas (défaut 15min, la cadence des mesures ; un pas plus large,
|
||||
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).
|
||||
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
|
||||
import os
|
||||
import statistics
|
||||
import sys
|
||||
|
||||
import matplotlib
|
||||
|
||||
matplotlib.use("Agg")
|
||||
import matplotlib.dates as mdates # noqa: E402
|
||||
import matplotlib.pyplot as plt # noqa: E402
|
||||
|
||||
from donnees import POSE, charger, charger_camera, est_reference, filtrer, instant, iso, rejetee # noqa: E402
|
||||
from graphique import COLONNES, RACINE, borne # noqa: E402
|
||||
from resume import bruit_propre, duree # noqa: E402
|
||||
|
||||
|
||||
def niveau(ms, col):
|
||||
"""(médiane, MAD) des valeurs non vides ; None si aucune."""
|
||||
v = [m[col] for m in ms if m[col] is not None]
|
||||
if not v:
|
||||
return None
|
||||
med = statistics.median(v)
|
||||
return med, statistics.median(abs(x - med) for x in v)
|
||||
|
||||
|
||||
def similitude(p, q):
|
||||
"""Similitude (a, b, tx, ty) qui envoie les points p sur q : q ≈ (a·x − b·y + tx, b·x + a·y + ty).
|
||||
|
||||
Estimation par médianes (une cible qui saute seule ne tire pas l'ajustement) : rotation et échelle, médiane sur
|
||||
toutes les paires de cibles du rapport complexe (qi − qj) / (pi − pj) ; translation, médiane de q − (rotation, échelle)·p.
|
||||
"""
|
||||
p, q = [complex(*u) for u in p], [complex(*u) for u in q]
|
||||
z = [(q[i] - q[j]) / (p[i] - p[j]) for i in range(len(p)) for j in range(i) if p[i] != p[j]]
|
||||
r = complex(statistics.median(v.real for v in z), statistics.median(v.imag for v in z))
|
||||
d = [w - r * u for u, w in zip(p, q)]
|
||||
return r.real, r.imag, statistics.median(v.real for v in d), statistics.median(v.imag for v in d)
|
||||
|
||||
|
||||
def rigide(o, noms, series, temps, base, station):
|
||||
"""4. Chaque capteur face au mouvement d'ensemble des cibles depuis l'instant --rigide : PNG « rigide » et table."""
|
||||
t_b = min(temps, key=lambda t: abs(t - o.rigide))
|
||||
pos = {s: {m["t"]: (m["x"], m["y"]) for m in series[s] if m["x"] is not None and m["y"] is not None} for s in noms}
|
||||
sans = set(o.sans.split(",")) - {""}
|
||||
acc = {s: {m["t"] for m in series[s] if not rejetee(m)} for s in noms} # mesures acceptées : seules à entrer dans l'ajustement et les statistiques des cibles
|
||||
refs = [s for s in noms if series[s] and est_reference(series[s])]
|
||||
cib = [s for s in noms if s not in refs and t_b in pos[s]]
|
||||
ajust = [s for s in cib if s not in sans and t_b in acc[s]]
|
||||
suivis = [s for s in o.suivre.split(",") if s and s not in refs]
|
||||
res, fit = {s: {} for s in noms}, {} # res : {capteur: {t: (dx, dy)}} ; fit : {t: (rotation deg, échelle, tx, ty, |r| médiane, max des cibles)}
|
||||
for t in temps:
|
||||
ok = [s for s in ajust if t in pos[s] and t in acc[s]]
|
||||
if len(ok) < 2:
|
||||
continue
|
||||
a, b, tx, ty = similitude([pos[s][t_b] for s in ok], [pos[s][t] for s in ok])
|
||||
for s in noms:
|
||||
if t in pos[s] and t_b in pos[s]:
|
||||
(x0, y0), (x, y) = pos[s][t_b], pos[s][t]
|
||||
res[s][t] = (x - (a * x0 - b * y0 + tx), y - (b * x0 + a * y0 + ty))
|
||||
r = [math.hypot(*res[s][t]) for s in cib if t in res[s] and t in acc[s]]
|
||||
fit[t] = (math.degrees(math.atan2(b, a)), math.hypot(a, b), tx, ty, statistics.median(r), max(r))
|
||||
if not fit:
|
||||
print(f"\n--rigide : moins de deux cibles avec x, y à {iso(t_b)} et ensuite.")
|
||||
return
|
||||
tf = sorted(fit)
|
||||
reproj = {s: {m["t"]: m["reproj_err"] for m in series[s] if m["reproj_err"] is not None} for s in refs}
|
||||
panneaux = [("dx", 0), ("dy", 1)]
|
||||
fig, axes = plt.subplots(6, 1, sharex=True, figsize=(14, 18), squeeze=False)
|
||||
for ax, (nom, k) in zip(axes[:2, 0], panneaux):
|
||||
band = [sorted(res[s][t][k] for s in cib if t in res[s] and t in acc[s]) for t in tf]
|
||||
q = [statistics.quantiles(v, n=10, method="inclusive") if len(v) >= 2 else [v[0]] * 9 for v in band]
|
||||
ax.fill_between(tf, [x[0] for x in q], [x[-1] for x in q], color="0.85", label="cibles : 10e-90e centile")
|
||||
ax.plot(tf, [statistics.median(v) for v in band], "-", lw=1.2, color="k", label="cibles : médiane")
|
||||
for i, s in enumerate(refs):
|
||||
ta = [t for t in res[s] if t in acc[s]]
|
||||
ax.plot(ta, [res[s][t][k] for t in ta], "-", lw=0.9, color=f"C{(i + 1) % 10}", label=f"{s} (réf.)")
|
||||
cadre = ax.get_ylim() # l'échelle des mesures acceptées : une référence rejetée loin est hors cadre
|
||||
for i, s in enumerate(refs):
|
||||
tr = [t for t in res[s] if t not in acc[s]]
|
||||
if tr: # mesures rejetées : à part, une croix chacune, hors du trait
|
||||
ax.plot(tr, [res[s][t][k] for t in tr], "x", ms=3, color=f"C{(i + 1) % 10}", label=f"{s} rejetée")
|
||||
ax.set_ylim(cadre)
|
||||
ax.set_ylabel(f"{nom} [px]\nposition brute moins\nle mouvement des cibles")
|
||||
ax.legend(loc="upper left", fontsize=8, ncol=1 + len(refs) // 4)
|
||||
axes[2, 0].plot(tf, [fit[t][4] for t in tf], "-", lw=1, color="k", label="cibles : médiane de |résidu|")
|
||||
p90 = {t: statistics.quantiles([math.hypot(*res[s][t]) for s in cib if t in res[s] and t in acc[s]], n=10, method="inclusive")[-1] for t in tf}
|
||||
axes[2, 0].plot(tf, [p90[t] for t in tf], "-", lw=0.8, color="C3", label="cibles : 90e centile de |résidu| (le max est dans la table)")
|
||||
axes[2, 0].set_ylabel("|résidu| des cibles [px]")
|
||||
axes[2, 0].legend(loc="upper left", fontsize=8)
|
||||
axes[3, 0].plot(tf, [fit[t][0] for t in tf], "-", lw=1, color="C2")
|
||||
axes[3, 0].set_ylabel("rotation ajustée [deg]")
|
||||
axes[4, 0].plot(tf, [fit[t][1] for t in tf], "-", lw=1, color="C2")
|
||||
axes[4, 0].set_ylabel("échelle ajustée")
|
||||
for i, s in enumerate(refs):
|
||||
axes[5, 0].plot(list(reproj[s]), list(reproj[s].values()), "-", lw=0.9, color=f"C{(i + 1) % 10}", label=f"{s} (réf.)")
|
||||
axes[5, 0].set_ylabel("reproj_err\ndes références")
|
||||
if refs:
|
||||
axes[5, 0].legend(loc="upper left", fontsize=8, ncol=1 + len(refs) // 4)
|
||||
for ax in axes[:, 0]:
|
||||
ax.grid(alpha=0.4)
|
||||
ax.axvline(t_b, color="C3", ls=":", lw=0.8)
|
||||
axes[-1, 0].set_xlim(tf[0], tf[-1])
|
||||
axes[-1, 0].xaxis.set_major_formatter(mdates.DateFormatter("%d/%m\n%H:%MZ"))
|
||||
fig.suptitle(f"{station} : mouvement d'ensemble (translation, rotation, échelle) ajusté sur {len(ajust)} cibles depuis {iso(t_b)} (pointillé), "
|
||||
"résidu de chaque capteur, mesures acceptées (croix : référence rejetée) (heures UTC)")
|
||||
fig.tight_layout(rect=(0, 0, 1, 1 - 0.4 / fig.get_figheight()))
|
||||
chemin = base.format("rigide")
|
||||
fig.savefig(chemin, dpi=100, bbox_inches="tight")
|
||||
plt.close(fig)
|
||||
print(chemin)
|
||||
|
||||
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] ; mesures rejetées hors de l'ajustement, "
|
||||
f"de cib_med, cib_max et des colonnes des capteurs (à part dans le résumé par capteur) ; médiane par pas de {int(o.pas.total_seconds() // 60)} min{' (table : ' + o.table + ')' if o.table else ''} :")
|
||||
cols = ["rot_deg", "echelle", "tx", "ty", "cib_med", "cib_max"] + [f"{s}_{c}" for s in refs + suivis for c in ("dx", "dy")]
|
||||
minuit = tf[0].replace(hour=0, minute=0, second=0, microsecond=0)
|
||||
t0 = minuit + ((tf[0] - minuit) // o.pas) * o.pas
|
||||
par_pas = {}
|
||||
for t in tf:
|
||||
ligne = par_pas.setdefault(t0 + ((t - t0) // o.pas) * o.pas, {})
|
||||
for c, v in zip(cols, fit[t]):
|
||||
ligne.setdefault(c, []).append(v)
|
||||
for s in refs + suivis:
|
||||
if t in res[s] and t in acc[s]:
|
||||
ligne.setdefault(f"{s}_dx", []).append(res[s][t][0]), ligne.setdefault(f"{s}_dy", []).append(res[s][t][1])
|
||||
w = max(10, max(len(c) for c in cols) + 1)
|
||||
entete = f"{'instant':17}" + "".join(f"{c:>{w}}" for c in cols)
|
||||
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))
|
||||
print("\nPar capteur, mesures acceptées : min et max de dx, dy, valeur au dernier instant ; puis les rejetées à part :")
|
||||
for s in noms:
|
||||
bons = {t: v for t, v in res[s].items() if t in acc[s]}
|
||||
rej = {t: v for t, v in res[s].items() if t not in acc[s]}
|
||||
for k, c in ((0, "dx"), (1, "dy")):
|
||||
ligne = f"{s:9}{' (réf.)' if s in refs else ' '} {c}"
|
||||
if bons:
|
||||
lo, hi = min(bons.items(), key=lambda x: x[1][k]), max(bons.items(), key=lambda x: x[1][k])
|
||||
der = res[s].get(tf[-1])
|
||||
ligne += (f" min {lo[1][k]:+.3g} à {iso(lo[0])}, max {hi[1][k]:+.3g} à {iso(hi[0])}, au dernier instant "
|
||||
f"{der[k] if der else math.nan:+.3g}{' (rejetée)' if der and tf[-1] not in acc[s] else ''}")
|
||||
else:
|
||||
ligne += " aucune mesure acceptée"
|
||||
if rej:
|
||||
lo, hi = min(rej.items(), key=lambda x: x[1][k]), max(rej.items(), key=lambda x: x[1][k])
|
||||
ligne += f" ; {len(rej)} rejetées : min {lo[1][k]:+.3g} à {iso(lo[0])}, max {hi[1][k]:+.3g} à {iso(hi[0])}"
|
||||
if bons or rej:
|
||||
print(ligne)
|
||||
|
||||
|
||||
def main():
|
||||
a = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
|
||||
a.add_argument("dossier")
|
||||
a.add_argument("--colonnes", default="x,y,sigma0")
|
||||
a.add_argument("--colonne", default="error_value", choices=COLONNES)
|
||||
a.add_argument("--pas", default="15min", type=duree, help="pas des tables et des courbes en bleu (défaut 15min, la cadence des mesures : un pas plus large aplatit et décale les événements courts)")
|
||||
a.add_argument("--k", type=float, default=5, help="écart compté, en MAD de la fenêtre")
|
||||
a.add_argument("--min", type=int, default=5, help="nombre de capteurs à partir duquel un instant est imprimé")
|
||||
a.add_argument("--residus", default="corr_x,corr_y,error_value", help="colonnes tracées moins le niveau propre de chaque capteur (« non » ou '' : aucune)")
|
||||
a.add_argument("--hors", help="T1/T2 : le niveau propre des résidus se calcule hors de ce moment")
|
||||
a.add_argument("--autres", action="store_true", help="résidus de plus ramenés à la médiane des autres capteurs au même instant, avec pente et corrélation sur le mouvement commun")
|
||||
a.add_argument("--rigide", type=instant, metavar="BASE", help="résidus face au mouvement d'ensemble des cibles (translation, rotation, échelle) depuis l'instant BASE")
|
||||
a.add_argument("--sans", default="", help="A,B : cibles laissées hors de l'ajustement de --rigide (leur résidu reste tracé)")
|
||||
a.add_argument("--suivre", default="", help="A,B : avec --rigide, dx, dy de ces capteurs ajoutés à la table au pas (les références y sont déjà)")
|
||||
a.add_argument("--table", default="", metavar="T1/T2|non",
|
||||
help="tables par pas imprimées seulement entre T1 et T2 (« non » : pas du tout) ; le reste sur toute la fenêtre")
|
||||
a.add_argument("--capteurs", help="liste séparée par des virgules (défaut : tous)")
|
||||
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")
|
||||
o = a.parse_args()
|
||||
|
||||
par = charger(o.dossier)
|
||||
if not par:
|
||||
sys.exit(f"Aucun export « advanced » dans {o.dossier} (voir inventaire.py).")
|
||||
noms = o.capteurs.split(",") if o.capteurs else sorted(par, key=lambda s: (not est_reference(par[s]), s))
|
||||
colonnes = o.colonnes.split(",")
|
||||
residus = [c for c in o.residus.split(",") if c and c != "non"] # '' ou « non » : aucune, comme --table
|
||||
hors = tuple(instant(x) for x in o.hors.split("/")) if o.hors else None
|
||||
if hors and len(hors) != 2:
|
||||
sys.exit("--hors attend T1/T2.")
|
||||
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"), ([s for s in o.suivre.split(",") if s], noms, "Capteurs de --suivre (pris parmi --capteurs)"), (colonnes + residus + [o.colonne], COLONNES, "Colonnes")):
|
||||
absents = [x for x in demandes if x not in connus]
|
||||
if absents:
|
||||
sys.exit(f"{quoi} inconnus : {', '.join(absents)}. Connus : {', '.join(sorted(connus))}.")
|
||||
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.")
|
||||
temps = sorted({m["t"] for s in noms for m in series[s]})
|
||||
poses = filtrer(charger_camera(o.dossier), temps[0].replace(second=0, microsecond=0), temps[-1]) # poses à la minute, mesures à la seconde
|
||||
pose_cols = POSE if poses else ()
|
||||
station = os.path.basename(os.path.normpath(o.dossier))
|
||||
os.makedirs(o.sortie, exist_ok=True)
|
||||
base = os.path.join(o.sortie, f"{station}_{{}}_{borne(o.debut, 'debut')}_{borne(o.fin, 'fin')}.png")
|
||||
|
||||
def ecarts(col):
|
||||
"""{capteur: {t: valeur - médiane de la fenêtre}}, et les MAD."""
|
||||
e, mad = {}, {}
|
||||
for s in noms:
|
||||
n = niveau(series[s], col)
|
||||
if n:
|
||||
e[s] = {m["t"]: m[col] - n[0] for m in series[s] if m[col] is not None}
|
||||
mad[s] = n[1]
|
||||
return e, mad
|
||||
|
||||
# 1. commun
|
||||
n_ax = len(pose_cols) + len(colonnes) + 1
|
||||
fig, axes = plt.subplots(n_ax, 1, sharex=True, figsize=(14, 3 * n_ax), squeeze=False)
|
||||
for ax, col in zip(axes[:, 0], pose_cols):
|
||||
pose_t = {p["t"].replace(second=0, microsecond=0): p[col] for p in poses if p[col] is not None}
|
||||
cam_t = sorted(set(pose_t) | {t.replace(second=0, microsecond=0) for t in temps})
|
||||
# trait coupé aux instants de mesure sans recalage : il ne relie pas deux poses par-dessus un trou
|
||||
ax.plot(cam_t, [pose_t.get(t, math.nan) for t in cam_t], ".-", ms=3, lw=0.5, color="C2", label="pose de la caméra (un point par recalage)")
|
||||
ax.set_ylabel(f"caméra : {col}" + (" [deg]" if col in ("pan", "tilt", "rotation") else ""))
|
||||
ax.legend(loc="upper left", fontsize=8)
|
||||
communes, refs_par_col, ref_ecarts = {}, {}, {}
|
||||
for ax, col in zip(axes[len(pose_cols):, 0], colonnes):
|
||||
e, _ = ecarts(col)
|
||||
med, bas, haut, tt = [], [], [], []
|
||||
for t in temps:
|
||||
v = sorted(e[s][t] for s in e if t in e[s])
|
||||
if len(v) >= 2:
|
||||
q = statistics.quantiles(v, n=10, method="inclusive")
|
||||
tt.append(t), med.append(statistics.median(v)), bas.append(q[0]), haut.append(q[-1])
|
||||
communes[col] = dict(zip(tt, med))
|
||||
ax.fill_between(tt, bas, haut, color="0.85", label="10e-90e centile entre capteurs")
|
||||
ax.plot(tt, med, ".-", ms=2, lw=0.8, label="médiane des capteurs")
|
||||
refs = [s for s in e if est_reference(series[s])]
|
||||
if refs and col != "sigma0": # sigma0 est le même pour tous : rien à séparer
|
||||
# références globales une à une, et médiane des seules cibles : qui bouge dans l'image, les références ou tout
|
||||
cib = {}
|
||||
for t in temps:
|
||||
v = [e[s][t] for s in e if s not in refs and t in e[s]]
|
||||
if v:
|
||||
cib[t] = statistics.median(v)
|
||||
communes[col + "_cibles"] = cib
|
||||
ax.plot(list(cib), list(cib.values()), "-", lw=1.2, color="k", label="médiane des cibles seules")
|
||||
for i, s in enumerate(refs):
|
||||
ax.plot(list(e[s]), list(e[s].values()), "-", lw=0.9, color=f"C{(i + 1) % 10}", label=f"{s} (réf.)")
|
||||
refs_par_col[col] = refs
|
||||
ref_ecarts[col] = {s: e[s] for s in refs}
|
||||
ax.set_ylabel(f"{col}\nécart à sa médiane")
|
||||
ax.grid(alpha=0.3)
|
||||
ax.legend(loc="upper left", fontsize=8, ncol=1 + len(refs_par_col.get(col, [])) // 4)
|
||||
e, mad = ecarts(o.colonne)
|
||||
compte, qui = [], {}
|
||||
for t in temps:
|
||||
hauts = [s for s in e if t in e[s] and mad[s] > 0 and e[s][t] > o.k * mad[s]]
|
||||
compte.append(len(hauts))
|
||||
if len(hauts) >= o.min:
|
||||
qui[t] = hauts
|
||||
axes[-1, 0].step(temps, compte, where="mid", lw=0.8)
|
||||
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)
|
||||
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]:
|
||||
ax.grid(alpha=0.5, which="major")
|
||||
fig.suptitle(f"{station} : {len(e)} capteurs ensemble, chacun face à son niveau sur la fenêtre (heures UTC)")
|
||||
fig.tight_layout(rect=(0, 0, 1, 1 - 0.4 / fig.get_figheight())) # place du titre
|
||||
commun = base.format("commun")
|
||||
fig.savefig(commun, dpi=100, bbox_inches="tight")
|
||||
plt.close(fig)
|
||||
print(commun)
|
||||
|
||||
# table de la médiane commune, par pas
|
||||
minuit = temps[0].replace(hour=0, minute=0, second=0, microsecond=0)
|
||||
t0 = minuit + ((temps[0] - minuit) // o.pas) * o.pas # pas calés sur l'horloge (hh:00, hh:15…), pas sur la 1re mesure
|
||||
lignes_t = {}
|
||||
for col in colonnes:
|
||||
for t, v in communes[col].items():
|
||||
lignes_t.setdefault(t0 + ((t - t0) // o.pas) * o.pas, {}).setdefault(col, []).append(v)
|
||||
for col in pose_cols:
|
||||
communes["cam_" + col] = {p["t"]: p[col] for p in poses if p[col] is not None}
|
||||
for t, v in communes["cam_" + col].items():
|
||||
lignes_t.setdefault(t0 + ((t - t0) // o.pas) * o.pas, {}).setdefault("cam_" + col, []).append(v)
|
||||
for col in refs_par_col:
|
||||
for t, v in communes[col + "_cibles"].items():
|
||||
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{' (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]:
|
||||
lo, hi = min(communes[col].items(), key=lambda x: x[1]), max(communes[col].items(), key=lambda x: x[1])
|
||||
g = 6 if col.startswith("cam_") else 4
|
||||
print(f"{col} (mesures) : min {lo[1]:.{g}g} à {iso(lo[0])}, max {hi[1]:.{g}g} à {iso(hi[0])}")
|
||||
|
||||
for col, refs in refs_par_col.items():
|
||||
print(f"\n{col} brut des références globales, écart à leur médiane de la fenêtre (mesures) ; {col}_cibles : médiane des cibles seules :")
|
||||
for s in refs:
|
||||
d = ref_ecarts[col][s]
|
||||
lo, hi = min(d.items(), key=lambda x: x[1]), max(d.items(), key=lambda x: x[1])
|
||||
rej = {m["t"] for m in series[s] if rejetee(m)}
|
||||
r = lambda t: " (rejetée)" if t in rej else ""
|
||||
print(f"{s:9} min {lo[1]:+.3g} à {iso(lo[0])}{r(lo[0])}, max {hi[1]:+.3g} à {iso(hi[0])}{r(hi[0])}"
|
||||
+ (f" ; {len(rej)} mesures rejetées dans la fenêtre" if rej else ""))
|
||||
if not pose_cols:
|
||||
print("Pose de la caméra : aucune dans la fenêtre (pas de camera/ dans le dossier, ou pas de recalage).")
|
||||
else:
|
||||
avec = {p["t"].replace(second=0, microsecond=0) for p in poses}
|
||||
suites = [] # suites d'instants de mesure consécutifs sans pose : [début, fin, nombre]
|
||||
for i, t in enumerate(temps):
|
||||
if t.replace(second=0, microsecond=0) in avec:
|
||||
continue
|
||||
if suites and suites[-1][3] == i - 1:
|
||||
suites[-1][1], suites[-1][2], suites[-1][3] = t, suites[-1][2] + 1, i
|
||||
else:
|
||||
suites.append([t, t, 1, i])
|
||||
print(f"Instants de mesure sans pose de la caméra (pas de recalage) : {sum(x[2] for x in suites)} sur {len(temps)}"
|
||||
+ (" : " + "; ".join(iso(a) if n == 1 else f"{iso(a)} → {iso(b)} ({n})" for a, b, n, _ in suites) if suites else ""))
|
||||
|
||||
# 2. petits multiples
|
||||
col = o.colonne
|
||||
n = len(noms)
|
||||
lignes = math.ceil(n / 5)
|
||||
fig, axes = plt.subplots(lignes, 5, sharex=True, figsize=(18, 2.5 * lignes), squeeze=False)
|
||||
for ax, s in zip(axes.flat, noms):
|
||||
ms = [m for m in series[s] if m[col] is not None]
|
||||
ax.plot([m["t"] for m in ms], [m[col] for m in ms], "-", lw=0.4, color="0.7")
|
||||
pas = {}
|
||||
for m in ms:
|
||||
pas.setdefault(t0 + ((m["t"] - t0) // o.pas) * o.pas, []).append(m[col])
|
||||
ax.plot(list(pas), [statistics.median(v) for v in pas.values()], "-", lw=1.1, color="C0")
|
||||
lv = niveau(series[s], col)
|
||||
if lv:
|
||||
ax.axhline(lv[0], color="C3", ls=":", lw=0.8)
|
||||
ax.set_title(s + (" (réf.)" if series[s] and est_reference(series[s]) else ""), fontsize=9)
|
||||
ax.grid(alpha=0.3)
|
||||
ax.tick_params(labelsize=7)
|
||||
ax.xaxis.set_major_locator(mdates.AutoDateLocator(minticks=2, maxticks=5))
|
||||
ax.xaxis.set_major_formatter(mdates.DateFormatter("%d/%m\n%Hh"))
|
||||
for ax in list(axes.flat)[n:]:
|
||||
ax.axis("off")
|
||||
fig.suptitle(f"{station} : {col}, médiane par pas de {int(o.pas.total_seconds() // 60)} min (bleu), mesures (gris), "
|
||||
f"médiane de la fenêtre (pointillé) ; une échelle par capteur (heures UTC)")
|
||||
fig.tight_layout()
|
||||
multiples = base.format(f"multiples-{col}")
|
||||
fig.savefig(multiples, dpi=100, bbox_inches="tight")
|
||||
print(multiples)
|
||||
|
||||
# 3. résidus : chaque capteur moins son propre niveau
|
||||
for col, autres in [(c, False) for c in residus] + [(c, True) for c in residus if o.autres]:
|
||||
fig, axes = plt.subplots(lignes, 5, sharex=True, figsize=(18, 2.5 * lignes), squeeze=False)
|
||||
dev = {}
|
||||
if autres: # {capteur: {t: valeur - niveau propre}} pour la médiane des autres
|
||||
for q in noms:
|
||||
mq = [m for m in series[q] if m[col] is not None]
|
||||
rq = [m for m in mq if not hors or not hors[0] <= m["t"] <= hors[1]] or mq
|
||||
nq = niveau(rq, col)
|
||||
if nq:
|
||||
dev[q] = {m["t"]: m[col] - nq[0] for m in mq}
|
||||
print(f"\n{col} moins le niveau propre{' et moins la médiane des autres capteurs au même instant' if autres else ''} ({'hors ' + o.hors if hors else 'médiane de la fenêtre'}), médiane par pas de "
|
||||
f"{int(o.pas.total_seconds() // 60)} min :")
|
||||
pentes = []
|
||||
print(f"{'capteur':9}{'niveau':>10}{'bruit':>10}{'écart min':>11} {'à':<17}{'(bruits)':>9}{'écart max':>11} {'à':<17}{'(bruits)':>9}")
|
||||
for ax, s in zip(axes.flat, noms):
|
||||
ms = [m for m in series[s] if m[col] is not None]
|
||||
ref = [m for m in ms if not hors or not hors[0] <= m["t"] <= hors[1]] or ms
|
||||
lv = niveau(ref, col)
|
||||
if not lv:
|
||||
ax.axis("off")
|
||||
continue
|
||||
bruit = bruit_propre([m[col] for m in ms])
|
||||
if autres:
|
||||
res = {}
|
||||
for m in ms:
|
||||
v = [dev[q][m["t"]] for q in dev if q != s and m["t"] in dev[q]]
|
||||
if len(v) >= 2:
|
||||
res[m["t"]] = m[col] - lv[0] - statistics.median(v)
|
||||
if len(res) < 2:
|
||||
ax.axis("off")
|
||||
continue
|
||||
else:
|
||||
res = {m["t"]: m[col] - lv[0] for m in ms}
|
||||
pas = {}
|
||||
for t, v in res.items():
|
||||
pas.setdefault(t0 + ((t - t0) // o.pas) * o.pas, []).append(v)
|
||||
pm = {t: statistics.median(v) for t, v in pas.items()}
|
||||
ax.plot(list(res), list(res.values()), "-", lw=0.4, color="0.7")
|
||||
ax.plot(list(pm), list(pm.values()), "-", lw=1.1, color="C0")
|
||||
ax.axhline(0, color="C3", ls=":", lw=0.8)
|
||||
ax.set_title(s + (" (réf.)" if est_reference(ms) else "") + f" bruit {bruit:.2g}", fontsize=9)
|
||||
ax.grid(alpha=0.3)
|
||||
ax.tick_params(labelsize=7)
|
||||
ax.xaxis.set_major_locator(mdates.AutoDateLocator(minticks=2, maxticks=5))
|
||||
ax.xaxis.set_major_formatter(mdates.DateFormatter("%d/%m\n%Hh"))
|
||||
lo, hi = min(pm.items(), key=lambda x: x[1]), max(pm.items(), key=lambda x: x[1])
|
||||
f = lambda v: f"{v / bruit:9.1f}" if bruit else f"{'-':>9}"
|
||||
print(f"{s:9}{lv[0]:10.4g}{bruit:10.3g}{lo[1]:11.3g} {iso(lo[0]):<17}{f(lo[1])}{hi[1]:11.3g} {iso(hi[0]):<17}{f(hi[1])}")
|
||||
if autres:
|
||||
for c in colonnes:
|
||||
tt = [t for t in res if t in communes[c]]
|
||||
if len(tt) > 2 and len({communes[c][t] for t in tt}) > 1:
|
||||
xs, ys = [communes[c][t] for t in tt], [res[t] for t in tt]
|
||||
pente = statistics.linear_regression(xs, ys).slope
|
||||
pentes.append(f"{s:9}pente sur {c} commun {pente:+.4g} par unité, r = {statistics.correlation(xs, ys):+.2f}")
|
||||
for ax in list(axes.flat)[n:]:
|
||||
ax.axis("off")
|
||||
if pentes:
|
||||
print("\n".join(pentes))
|
||||
fig.suptitle(f"{station} : {col} moins le niveau propre{' et la médiane des autres' if autres else ''} de chaque capteur, médiane par pas de "
|
||||
f"{int(o.pas.total_seconds() // 60)} min (bleu), mesures (gris) ; une échelle par capteur (heures UTC)")
|
||||
fig.tight_layout()
|
||||
chemin = base.format(f"residus-{col}" + ("-autres" if autres else ""))
|
||||
fig.savefig(chemin, dpi=100, bbox_inches="tight")
|
||||
plt.close(fig)
|
||||
print(chemin)
|
||||
|
||||
if o.rigide:
|
||||
rigide(o, noms, series, temps, base, station)
|
||||
|
||||
print(f"\nInstants où au moins {o.min} capteurs ont {o.colonne} > médiane de la fenêtre + {o.k:g} MAD :")
|
||||
for t, hauts in qui.items():
|
||||
print(f"{iso(t)} {len(hauts):3} {','.join(hauts)}")
|
||||
if not qui:
|
||||
print("(aucun)")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,70 @@
|
||||
"""GIF des images de la caméra sur une plage, pour joindre à une réponse au client (skill /support).
|
||||
|
||||
Usage : .venv/bin/python agent-tools/gif.py data/LENZSPITZE/
|
||||
--debut 2026-10-26T18:00Z --fin 2026-10-27T08:00Z [--largeur 720] [--duree 700] [--max 150] [--zone X,Y,L,H] [--sortie DOSSIER]
|
||||
Prend les images du dossier dont l'heure (nom du fichier, UTC) est entre --debut et --fin inclus, dans l'ordre, les
|
||||
recadre au besoin sur --zone (pixels de l'image d'origine : coin haut gauche, largeur, hauteur), les met à --largeur px,
|
||||
écrit la date et l'heure UTC en bas à droite de chacune et les ramène à 64 teintes sans tramage
|
||||
(le bruit des JPEG gonfle un GIF : ~3 Mo pour une nuit d'images horaires à 720 px). Au-delà de --max images, en garde
|
||||
--max à intervalle régulier. Imprime l'heure de chaque image retenue, puis le chemin du GIF et sa taille.
|
||||
"""
|
||||
import argparse
|
||||
import os
|
||||
import sys
|
||||
|
||||
from PIL import Image, ImageDraw, ImageFont
|
||||
|
||||
from donnees import heure_image, instant, iso, trouver
|
||||
|
||||
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("--debut", required=True, help="première heure (UTC)")
|
||||
a.add_argument("--fin", required=True, help="dernière heure (UTC), incluse")
|
||||
a.add_argument("--largeur", type=int, default=720, help="largeur du GIF en pixels (défaut 720)")
|
||||
a.add_argument("--duree", type=int, default=700, help="durée de chaque image en ms (défaut 700)")
|
||||
a.add_argument("--max", type=int, default=150, help="nombre maximal d'images (défaut 150)")
|
||||
a.add_argument("--zone", help="X,Y,L,H : recadrage en pixels de l'image d'origine (défaut : image entière)")
|
||||
a.add_argument("--sortie", default=os.path.join(RACINE, "out", "diagnostic"), help="dossier du GIF")
|
||||
o = a.parse_args()
|
||||
|
||||
debut, fin = instant(o.debut), instant(o.fin)
|
||||
toutes = sorted((h, p) for p in trouver(o.dossier)["images"] if (h := heure_image(p)))
|
||||
choisies = [(h, p) for h, p in toutes if debut <= h <= fin]
|
||||
if not choisies:
|
||||
dispo = f" (images du {iso(toutes[0][0])} au {iso(toutes[-1][0])})" if toutes else ""
|
||||
sys.exit(f"Aucune image entre {iso(debut)} et {iso(fin)} dans {o.dossier}{dispo}.")
|
||||
n = len(choisies)
|
||||
if n > o.max:
|
||||
choisies = [choisies[round(i * (n - 1) / (o.max - 1))] for i in range(o.max)]
|
||||
print(f"{o.max} images sur {n} gardées")
|
||||
|
||||
vues = []
|
||||
for h, p in choisies:
|
||||
im = Image.open(p).convert("RGB")
|
||||
if o.zone:
|
||||
x, y, l, h_ = map(int, o.zone.split(","))
|
||||
im = im.crop((x, y, x + l, y + h_))
|
||||
im = im.resize((o.largeur, round(im.height * o.largeur / im.width)), Image.LANCZOS)
|
||||
d = ImageDraw.Draw(im)
|
||||
texte = h.strftime("%Y-%m-%d %H:%M UTC")
|
||||
police = ImageFont.load_default(size=max(12, o.largeur // 45))
|
||||
g, haut, dr, bas = d.textbbox((0, 0), texte, font=police)
|
||||
x, y, marge = im.width - (dr - g) - 10, im.height - (bas - haut) - 10, 4
|
||||
d.rectangle((x - marge, y - marge, x + dr - g + marge, y + bas - haut + marge), fill="black")
|
||||
d.text((x - g, y - haut), texte, fill="white", font=police)
|
||||
vues.append(im.quantize(64, dither=Image.Dither.NONE))
|
||||
print(iso(h))
|
||||
|
||||
os.makedirs(o.sortie, exist_ok=True)
|
||||
nom = f"images_{choisies[0][0]:%Y%m%dT%H%MZ}_{choisies[-1][0]:%Y%m%dT%H%MZ}.gif"
|
||||
chemin = os.path.join(o.sortie, nom)
|
||||
vues[0].save(chemin, save_all=True, append_images=vues[1:], duration=o.duree, loop=0, optimize=True)
|
||||
print(f"GIF : {chemin} ({os.path.getsize(chemin) / 1e6:.1f} Mo, {len(vues)} images)")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,94 @@
|
||||
"""Graphique PNG des séries d'un export « advanced », pour que l'agent de diagnostic les regarde.
|
||||
|
||||
Usage : .venv/bin/python agent-tools/graphique.py data/PS_DES_COUDRES/
|
||||
[--capteurs CAPTEUR_A,CAPTEUR_B] [--colonnes error_value,corr_x,corr_y] [--debut ...] [--fin ...]
|
||||
[--zone DEBUT/FIN ...] [--sortie DOSSIER]
|
||||
Un panneau par colonne, une courbe par capteur, heures UTC ; chaque --zone est grisée. Colonnes : error_value, corr_x, corr_y,
|
||||
relative_x, relative_y, x, y, sigma0, reproj_err, et les six métriques de qualité d'image (peak à snr, valeurs brutes ; face à une référence calme : qualite.py).
|
||||
Imprime le chemin du PNG (out/diagnostic/, ou --sortie : le dossier du rapport, pour une figure de preuve).
|
||||
"""
|
||||
import argparse
|
||||
import os
|
||||
import sys
|
||||
|
||||
import matplotlib
|
||||
|
||||
matplotlib.use("Agg")
|
||||
import matplotlib.dates as mdates # noqa: E402
|
||||
import matplotlib.pyplot as plt # noqa: E402
|
||||
|
||||
from donnees import charger, est_reference, filtrer, instant # noqa: E402
|
||||
from resume import QUALITE # noqa: E402
|
||||
|
||||
RACINE = os.path.normpath(os.path.join(os.path.dirname(os.path.abspath(__file__)), ".."))
|
||||
COLONNES = ("error_value", "corr_x", "corr_y", "relative_x", "relative_y", "x", "y", "sigma0", "reproj_err")
|
||||
|
||||
|
||||
def zone(texte):
|
||||
"""'2026-10-13T01:00Z/2026-10-13T03:00Z' -> (début, fin)."""
|
||||
debut, sep, fin = texte.partition("/")
|
||||
if not sep:
|
||||
raise argparse.ArgumentTypeError(f"zone invalide : {texte!r} (ex. 2026-10-13T01:00Z/2026-10-13T03:00Z)")
|
||||
return instant(debut), instant(fin)
|
||||
|
||||
|
||||
def borne(t, defaut):
|
||||
return t.strftime("%Y%m%dT%H%MZ") if t else defaut
|
||||
|
||||
|
||||
def main():
|
||||
a = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
|
||||
a.add_argument("dossier")
|
||||
a.add_argument("--capteurs", help="liste séparée par des virgules (défaut : tous)")
|
||||
a.add_argument("--colonnes", default="error_value,corr_x,corr_y")
|
||||
a.add_argument("--debut", type=instant)
|
||||
a.add_argument("--fin", type=instant)
|
||||
a.add_argument("--zone", type=zone, action="append", default=[], help="fenêtre à griser, DEBUT/FIN (répétable)")
|
||||
a.add_argument("--sortie", default=os.path.join(RACINE, "out", "diagnostic"), help="dossier du PNG")
|
||||
o = a.parse_args()
|
||||
|
||||
par = charger(o.dossier)
|
||||
if not par:
|
||||
sys.exit(f"Aucun export « advanced » dans {o.dossier} (voir inventaire.py).")
|
||||
noms = o.capteurs.split(",") if o.capteurs else sorted(par, key=lambda s: (not est_reference(par[s]), s))
|
||||
colonnes = o.colonnes.split(",")
|
||||
for demandes, connus, quoi in ((noms, par, "Capteurs"), (colonnes, COLONNES + QUALITE, "Colonnes")):
|
||||
absents = [x for x in demandes if x not in connus]
|
||||
if absents:
|
||||
sys.exit(f"{quoi} inconnus : {', '.join(absents)}. Connus : {', '.join(sorted(connus))}.")
|
||||
series = {s: 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.")
|
||||
vides = [c for c in colonnes if all(m[c] is None for s in noms for m in series[s])]
|
||||
if len(vides) == len(colonnes):
|
||||
sys.exit(f"Rien à tracer : {', '.join(colonnes)} vide(s) pour ces capteurs dans la fenêtre.")
|
||||
if vides:
|
||||
print(f"Panneaux vides (aucune valeur pour ces capteurs) : {', '.join(vides)}")
|
||||
|
||||
fig, axes = plt.subplots(len(colonnes), 1, sharex=True, figsize=(14, 3.2 * len(colonnes)), squeeze=False)
|
||||
tab20 = plt.get_cmap("tab20").colors
|
||||
couleurs = tab20[::2] + tab20[1::2] # teintes foncées d'abord : deux capteurs voisins ne partagent pas une teinte
|
||||
for ax, col in zip(axes[:, 0], colonnes):
|
||||
for i, s in enumerate(noms):
|
||||
ms = series[s] # une valeur vide devient NaN : la courbe s'interrompt au lieu de relier le trou
|
||||
ax.plot([m["t"] for m in ms], [float("nan") if m[col] is None else m[col] for m in ms], ".-", ms=2, lw=0.7,
|
||||
color=couleurs[i % len(couleurs)], label=s)
|
||||
for debut, fin in o.zone:
|
||||
ax.axvspan(debut, fin, color="0.85", zorder=0)
|
||||
ax.set_ylabel(col)
|
||||
ax.grid(alpha=0.3)
|
||||
axes[0, 0].legend(loc="upper left", bbox_to_anchor=(1.0, 1.0), fontsize=8)
|
||||
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} : {', '.join(colonnes)} (heures UTC)")
|
||||
|
||||
os.makedirs(o.sortie, exist_ok=True)
|
||||
qui = "-".join(noms) if o.capteurs else "tous"
|
||||
sortie = os.path.join(o.sortie, f"{station}_{'-'.join(colonnes)}_{qui}_"
|
||||
f"{borne(o.debut, 'debut')}_{borne(o.fin, 'fin')}.png")
|
||||
fig.savefig(sortie, dpi=100, bbox_inches="tight")
|
||||
print(sortie)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,314 @@
|
||||
"""Inventaire d'un dossier de station : ce qui est disponible, ce qui manque.
|
||||
|
||||
Usage : python3 agent-tools/inventaire.py data/PS_DES_COUDRES/ [--debut T] [--fin T] [--fichiers]
|
||||
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 ; 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 (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
|
||||
import csv
|
||||
import glob
|
||||
import os
|
||||
import re
|
||||
import statistics
|
||||
from datetime import datetime, timedelta, timezone
|
||||
|
||||
from donnees import charger, charger_camera, est_reference, filtrer, heure_image, instant, iso, rejetee, trouver
|
||||
from resume import QUALITE
|
||||
|
||||
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:
|
||||
shown = chemins
|
||||
else:
|
||||
shown = [chemins[0], chemins[-1]]
|
||||
print(f" {len(chemins)} fichiers, du premier au dernier (--fichiers pour la liste complète) :")
|
||||
for p in shown:
|
||||
print(f" {p}")
|
||||
|
||||
|
||||
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 labeling/connaissances/colonnes-des-deplacements.md)")
|
||||
liste(f["horaire"], tout)
|
||||
print(f"Mouvements de la caméra (pose à chaque recalage) : {len(f['camera'])}")
|
||||
liste(f["camera"], tout)
|
||||
print(f"Autres fichiers : {len(f['autres'])}")
|
||||
liste(f["autres"], tout)
|
||||
|
||||
|
||||
def remplies(chemins, debut, fin):
|
||||
"""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)
|
||||
for c in r.fieldnames or []:
|
||||
if c not in ("", "time_utc", "sensor_name"):
|
||||
compte.setdefault(c, 0)
|
||||
for row in r:
|
||||
if (debut or fin) and filtrer([{"t": instant(row["time_utc"])}], debut, fin) == []:
|
||||
continue
|
||||
lignes += 1
|
||||
for c in compte:
|
||||
if (row.get(c) or "").strip():
|
||||
compte[c] += 1
|
||||
if row.get("sensor_name"):
|
||||
qui[c].add(row["sensor_name"].strip())
|
||||
return lignes, compte, qui
|
||||
|
||||
|
||||
def contenu(dossier, f, debut=None, fin=None):
|
||||
"""Ce que contient chaque source sur la fenêtre : ses colonnes, remplies ou vides, et les noms des métriques.
|
||||
Des noms et des comptes, jamais de valeurs (metrics/ porte des identifiants : SIM_CCID, ip_*)."""
|
||||
quoi = "sur la fenêtre" if debut or fin else "sur toute la période"
|
||||
print(f"\nCe que contiennent les données, {quoi} (par colonne, les lignes qui ont une valeur ; « vide » : aucune) :")
|
||||
autres = collections.defaultdict(list)
|
||||
for p in f["autres"]:
|
||||
autres[os.path.relpath(p, dossier).split(os.sep)[0]].append(p)
|
||||
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, 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()))
|
||||
if chemins is f["advanced"]:
|
||||
q = [c for c in QUALITE if compte.get(c)]
|
||||
print(f" Qualité d'image de l'export (peak à snr) : " + (f"remplie ({', '.join(q)}) ; lue par qualite.py, "
|
||||
"labeling/connaissances/metriques-de-qualite.md" if q else "vide"))
|
||||
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))
|
||||
if not m:
|
||||
continue
|
||||
jour = datetime(*map(int, m.group(2, 3, 4)), tzinfo=timezone.utc)
|
||||
if (debut is None or jour.date() >= debut.date()) and (fin is None or jour.date() <= fin.date()):
|
||||
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 ; 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", "*")))):
|
||||
heures = [h for h in map(heure_image, chemins) if h and filtrer([{"t": h}], debut, fin)]
|
||||
if chemins:
|
||||
print(f" {titre} : {len(heures)}")
|
||||
if autres:
|
||||
print(" Autres : " + ", ".join(f"{k} ({len(v)})" for k, v in sorted(autres.items())))
|
||||
|
||||
|
||||
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)}")
|
||||
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):
|
||||
if not par:
|
||||
print("\nAucune mesure : pas d'export « advanced » dans ce dossier.")
|
||||
return
|
||||
instants = sorted({m["t"] for ms in par.values() for m in ms})
|
||||
cadence = statistics.median(b - a for a, b in zip(instants, instants[1:]))
|
||||
print(f"\nPériode des mesures : {iso(instants[0])} → {iso(instants[-1])}, {len(instants)} instants")
|
||||
print(f"Cadence (pas médian) : {cadence.total_seconds() / 60:.0f} min")
|
||||
trous = [(a, b, round((b - a) / cadence) - 1) for a, b in zip(instants, instants[1:])]
|
||||
trous = [x for x in trous if x[2] > 0]
|
||||
print(f"Mesures manquantes (instants absents de la cadence) : {sum(n for *_, n in trous)}")
|
||||
for a, b, n in trous:
|
||||
print(f" entre {iso(a)} et {iso(b)} : {n}")
|
||||
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, labeling/connaissances/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]
|
||||
seuil = "/".join(f"{x:g}" for x in sorted({m['error_threshold'] for m in ms}))
|
||||
print(f"{s:10} {'référence' if est_reference(ms) else 'cible':10} {ms[0]['pattern_type']:11} "
|
||||
f"{seuil:>5} {len(ms):7} {sum(map(rejetee, ms)):8}")
|
||||
|
||||
|
||||
def camera(dossier, par, debut=None, fin=None):
|
||||
"""Poses de la caméra, et les instants de mesure sans pose (la caméra n'a pas été recalée)."""
|
||||
poses = filtrer(charger_camera(dossier), debut, fin)
|
||||
instants = sorted({m["t"] for ms in par.values() for m in filtrer(ms, debut, fin)})
|
||||
quoi = "dans la fenêtre" if debut or fin else "sur toute la période"
|
||||
if not poses:
|
||||
print(f"\nPose de la caméra {quoi} : aucune")
|
||||
return
|
||||
avec = {p["t"].replace(second=0, microsecond=0) for p in poses}
|
||||
print(f"\nPose de la caméra {quoi} : {len(poses)} recalages, {iso(poses[0]['t'])} → {iso(poses[-1]['t'])}")
|
||||
suites = [] # [début, fin, nombre, rang] des instants de mesure consécutifs sans pose
|
||||
for i, t in enumerate(instants):
|
||||
if t.replace(second=0, microsecond=0) in avec:
|
||||
continue
|
||||
if suites and suites[-1][3] == i - 1:
|
||||
suites[-1][1], suites[-1][2], suites[-1][3] = t, suites[-1][2] + 1, i
|
||||
else:
|
||||
suites.append([t, t, 1, i])
|
||||
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" {suite(a, b, n)}")
|
||||
|
||||
|
||||
def fenetre(par, debut, fin):
|
||||
"""Pas absents et rejets datés sur la fenêtre debut/fin."""
|
||||
instants = sorted({m["t"] for ms in par.values() for m in ms})
|
||||
cadence = statistics.median(b - a for a, b in zip(instants, instants[1:]))
|
||||
series = {s: {m["t"]: m for m in filtrer(ms, debut, fin)} for s, ms in par.items()}
|
||||
dans = sorted({t for d in series.values() for t in d})
|
||||
print(f"\nFenêtre {iso(dans[0])} → {iso(dans[-1])} : {len(dans)} instants présents")
|
||||
noms = sorted(par, key=lambda s: (not est_reference(par[s]), s))
|
||||
print(f"Pas absents pour tous les capteurs, entre deux instants présents (cadence de {cadence.total_seconds() / 60:.0f} min) :")
|
||||
trous = [(a, b, round((b - a) / cadence) - 1) for a, b in zip(dans, dans[1:])]
|
||||
trous = [x for x in trous if x[2] > 0]
|
||||
for a, b, n in trous:
|
||||
print(f" entre {iso(a)} et {iso(b)} : {n}")
|
||||
if not trous:
|
||||
print(" (aucun)")
|
||||
print("Instants présents où des capteurs n'ont pas de mesure :")
|
||||
partiels = [(t, [s for s in noms if t not in series[s]]) for t in dans]
|
||||
for t, manque in partiels:
|
||||
if manque:
|
||||
print(f" {iso(t)} : {len(manque)} capteurs : {','.join(manque)}")
|
||||
if not any(m for _, m in partiels):
|
||||
print(" (aucun)")
|
||||
print("Mesures rejetées dans la fenêtre, par capteur (début → fin de chaque suite de pas consécutifs, nombre) :")
|
||||
for s in noms:
|
||||
rej = [t for t in sorted(series[s]) if rejetee(series[s][t])]
|
||||
suites = []
|
||||
for t in rej:
|
||||
if suites and t - suites[-1][1] <= cadence * 1.5:
|
||||
suites[-1][1], suites[-1][2] = t, suites[-1][2] + 1
|
||||
else:
|
||||
suites.append([t, t, 1])
|
||||
if rej:
|
||||
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])]
|
||||
# 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 "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)
|
||||
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 ; "
|
||||
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:
|
||||
suites[-1][1], suites[-1][2], suites[-1][4] = t, suites[-1][2] + 1, i
|
||||
elif h:
|
||||
suites.append([t, t, 1, h, i])
|
||||
for a, b, n, h, _ in suites:
|
||||
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)")
|
||||
|
||||
|
||||
def main(dossier, debut=None, fin=None, tout=False):
|
||||
print(f"Dossier : {dossier}")
|
||||
f = trouver(dossier)
|
||||
fichiers(f, tout)
|
||||
contenu(dossier, f, debut, fin)
|
||||
images(f["images"], debut, fin)
|
||||
par = charger(dossier)
|
||||
mesures(par)
|
||||
if par:
|
||||
camera(dossier, par)
|
||||
if par and (debut or fin):
|
||||
fenetre(par, debut, fin)
|
||||
camera(dossier, par, debut, fin)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
a = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
|
||||
a.add_argument("dossier")
|
||||
a.add_argument("--debut", type=instant)
|
||||
a.add_argument("--fin", type=instant)
|
||||
a.add_argument("--fichiers", action="store_true", help="liste complète des fichiers (sinon : le premier et le dernier au-delà de 5)")
|
||||
o = a.parse_args()
|
||||
main(o.dossier, o.debut, o.fin, o.fichiers)
|
||||
@@ -0,0 +1,333 @@
|
||||
"""Ce qui revient d'un jour à l'autre : niveau de chaque nuit, et jours superposés par heure du jour, pour l'agent de diagnostic.
|
||||
|
||||
Usage : .venv/bin/python agent-tools/jours.py data/PS_DES_COUDRES/ [--colonnes corr_x,corr_y,error_value]
|
||||
[--nuit 20-3] [--k 5] [--jours 2] [--pas 15min] [--capteurs A,B] [--bornes [--lissage N] [--fraction F]]
|
||||
[--debut ...] [--fin ...] [--sortie DOSSIER]
|
||||
|
||||
Mesures acceptées seulement : une mesure rejetée (error_value au-dessus du seuil) n'entre nulle part. Une « nuit » :
|
||||
les heures --nuit H1-H2 (UTC, H1 inclus, H2 exclu, à cheval sur minuit si H1 > H2), datée du jour où elle commence ;
|
||||
la nuit en cours au début de la fenêtre compte aussi (ses heures après minuit). Bruit propre du capteur : médiane des
|
||||
écarts entre deux mesures consécutives sur la fenêtre. Pour chaque colonne de --colonnes :
|
||||
1. Niveau de chaque nuit, par capteur : médiane, MAD et nombre de mesures ; puis, d'une nuit à la suivante, la
|
||||
marche (différence des médianes, en unités et en bruits) et où elle se place : la suite des mesures de nuit des
|
||||
deux nuits est coupée là où la somme des écarts absolus au niveau de la première nuit (avant) et de la seconde
|
||||
(après) est la plus petite ; « entre A et B » : dernière mesure de nuit avant la coupure et première après (B en
|
||||
début de nuit : la coupure tombe entre deux nuits, de jour).
|
||||
2. Jours superposés : chaque mesure moins le niveau de la dernière nuit commencée à son instant (la précédente, ou
|
||||
celle en cours ; sans elle, la nuit la plus proche). PNG « parheure-<colonne> » : un petit graphique par capteur,
|
||||
en abscisse l'heure du jour (UTC), une courbe par jour, heures de nuit grisées, une échelle par capteur, cadrée du 1er au 99e centile élargi de moitié (le titre dit
|
||||
combien de mesures sortent du cadre : un pic isolé n'écrase pas l'échelle ; sa valeur est dans les tables).
|
||||
Table : par créneau de --pas de l'heure du jour, les capteurs dont l'écart dépasse --k bruits à ce créneau, du
|
||||
même côté, au moins --jours jours différents, avec le nombre de ces jours sur le nombre de jours mesurés et la
|
||||
médiane de ces écarts (signée, en unités et en bruits) ; un capteur au-dessus certains jours et au-dessous
|
||||
d'autres est cité deux fois.
|
||||
3. Avec --bornes : chaque jour face à la nuit qui le précède, pour la médiane des cibles de chaque colonne (avec
|
||||
--capteurs : la médiane de ces capteurs, références comprises ; un seul capteur : le sien) et pour la pose de la
|
||||
caméra (pan, tilt, rotation, scale, sigma0) si camera/ existe. Un « jour » : de la fin d'une nuit à la fin de la
|
||||
suivante (24 h), daté du jour où il commence ; son niveau de référence est celui de la nuit qui vient de finir (sans
|
||||
elle, la dernière nuit mesurée avant, ou au début du lot la première : nommée, « pas la précédente »). Écart de chaque mesure à ce niveau (médiane des cibles : à chaque
|
||||
instant, médiane des écarts de chaque cible à son propre niveau de cette nuit) ; bruit : médiane des écarts entre
|
||||
deux valeurs consécutives de cette suite. Par jour : nombre de mesures, première et dernière ; premier et dernier
|
||||
instant où |écart| dépasse --k bruits, avec la mesure juste avant et juste après (au pas natif) ; le maximum et le
|
||||
minimum signés et leur instant ; autour du plus grand des deux en valeur absolue, la suite de mesures consécutives
|
||||
au-delà de --k bruits du même côté qui le contient, avec la mesure juste avant et juste après ; la nuit suivante
|
||||
moins la nuit de référence. Un jour sans mesure le dit. Chaque ligne de jour commence par le nom court de la suite
|
||||
(la colonne, ou pose_tilt…) : `| grep '^pose_tilt '` en garde une, `| grep ' 12/10 '` un jour. Avec --lissage N,
|
||||
l'écart de chaque mesure est la médiane des N mesures du jour centrées sur elle (le bruit reste celui des mesures,
|
||||
la figure trace aussi l'écart brut en gris) : un point isolé ne coupe plus la suite autour de l'extrême et ne fait
|
||||
plus un premier ou un dernier dépassement. Avec --fraction F, le seuil de chaque jour est F fois le plus grand
|
||||
|écart| de ce jour (au lieu de --k bruits ; il est imprimé sur la ligne du jour) : sur une suite très bruitée, ou
|
||||
dont le bruit au pas natif est sans rapport avec l'ampleur du cycle. PNG
|
||||
« bornes » : un panneau par suite, l'écart sur le lot, ±k bruits en pointillé, de chaque jour [premier, dernier]
|
||||
grisé clair et la suite autour de l'extrême grisée foncé, le maximum et le minimum marqués ; cadré du 1er au 99e
|
||||
centile élargi de moitié (le titre dit combien de mesures sortent du cadre).
|
||||
Rend des valeurs, pas de verdict.
|
||||
"""
|
||||
import argparse
|
||||
import math
|
||||
import os
|
||||
import statistics
|
||||
import sys
|
||||
from datetime import datetime, timedelta, timezone
|
||||
|
||||
import matplotlib
|
||||
|
||||
matplotlib.use("Agg")
|
||||
import matplotlib.pyplot as plt # noqa: E402
|
||||
|
||||
from donnees import POSE, charger, charger_camera, est_reference, filtrer, instant, iso, rejetee # noqa: E402
|
||||
from graphique import COLONNES, RACINE, borne # noqa: E402
|
||||
from resume import ARRONDI, bruit_propre, duree # noqa: E402
|
||||
|
||||
|
||||
def heures(texte):
|
||||
"""'20-3' -> (20, 3)."""
|
||||
try:
|
||||
h1, h2 = (int(x) for x in texte.split("-"))
|
||||
except ValueError:
|
||||
raise argparse.ArgumentTypeError(f"heures invalides : {texte!r} (ex. 20-3)")
|
||||
return h1, h2
|
||||
|
||||
|
||||
def de_nuit(t, h1, h2):
|
||||
return (h1 <= t.hour or t.hour < h2) if h1 > h2 else h1 <= t.hour < h2
|
||||
|
||||
|
||||
def coupure(pts, la, lb):
|
||||
"""Indice j (1..n-1) où sum|v-la| avant j + sum|v-lb| à partir de j est le plus petit."""
|
||||
avant, apres = 0.0, sum(abs(v - lb) for _, v in pts)
|
||||
meilleur = None
|
||||
for j in range(1, len(pts)):
|
||||
v = pts[j - 1][1]
|
||||
avant += abs(v - la)
|
||||
apres -= abs(v - lb)
|
||||
if meilleur is None or avant + apres < meilleur[0]:
|
||||
meilleur = (avant + apres, j)
|
||||
return meilleur[1]
|
||||
|
||||
|
||||
def main():
|
||||
a = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
|
||||
a.add_argument("dossier")
|
||||
a.add_argument("--colonnes", default="corr_x,corr_y,error_value")
|
||||
a.add_argument("--nuit", default="20-3", type=heures, help="heures de nuit H1-H2, UTC (défaut 20-3)")
|
||||
a.add_argument("--k", type=float, default=5, help="écart au niveau de la nuit compté, en bruits propres du capteur")
|
||||
a.add_argument("--jours", type=int, default=2, help="nombre de jours à partir duquel un capteur est cité à un créneau")
|
||||
a.add_argument("--pas", default="15min", type=duree, help="largeur des créneaux de l'heure du jour (défaut 15min)")
|
||||
a.add_argument("--capteurs", help="liste séparée par des virgules (défaut : tous)")
|
||||
a.add_argument("--bornes", action="store_true", help="ajoute, jour par jour, les bornes de l'écart au niveau de la nuit précédente")
|
||||
a.add_argument("--lissage", type=int, default=1, metavar="N", help="--bornes : écart lissé par la médiane de N mesures centrées (défaut 1 : aucun)")
|
||||
a.add_argument("--fraction", type=float, metavar="F", help="--bornes : seuil de chaque jour = F fois son plus grand |écart| (au lieu de --k bruits)")
|
||||
a.add_argument("--debut", type=instant)
|
||||
a.add_argument("--fin", type=instant)
|
||||
a.add_argument("--sortie", default=os.path.join(RACINE, "out", "diagnostic"), help="dossier des PNG")
|
||||
o = a.parse_args()
|
||||
|
||||
par = charger(o.dossier)
|
||||
if not par:
|
||||
sys.exit(f"Aucun export « advanced » dans {o.dossier} (voir inventaire.py).")
|
||||
noms = o.capteurs.split(",") if o.capteurs else sorted(par, key=lambda s: (not est_reference(par[s]), s))
|
||||
colonnes = o.colonnes.split(",")
|
||||
for demandes, connus, quoi in ((noms, par, "Capteurs"), (colonnes, COLONNES, "Colonnes")):
|
||||
absents = [x for x in demandes if x not in connus]
|
||||
if absents:
|
||||
sys.exit(f"{quoi} inconnus : {', '.join(absents)}. Connus : {', '.join(sorted(connus))}.")
|
||||
series = {s: [m for m in filtrer(par[s], o.debut, o.fin) if not rejetee(m)] for s in noms}
|
||||
if not any(series.values()):
|
||||
sys.exit("Aucune mesure acceptée dans la fenêtre demandée.")
|
||||
h1, h2 = o.nuit
|
||||
pas = int(o.pas.total_seconds() // 60)
|
||||
station = os.path.basename(os.path.normpath(o.dossier))
|
||||
os.makedirs(o.sortie, exist_ok=True)
|
||||
lignes = math.ceil(len(noms) / 5)
|
||||
|
||||
for col in colonnes:
|
||||
print(f"\n== {col} : niveau de chaque nuit ({h1} h → {h2} h UTC), médiane ±MAD (mesures) ; marches d'une nuit à la suivante ==")
|
||||
creneaux = {} # minute du jour -> {(capteur, au-dessus): {jour: écart}}
|
||||
bruits = {}
|
||||
fig, axes = plt.subplots(lignes, 5, sharex=True, figsize=(18, 2.5 * lignes), squeeze=False)
|
||||
for ax, s in zip(axes.flat, noms):
|
||||
ms = [(m["t"], m[col]) for m in series[s] if m[col] is not None]
|
||||
if len(ms) < 2:
|
||||
print(f"{s:9}(moins de 2 valeurs acceptées)")
|
||||
ax.axis("off")
|
||||
continue
|
||||
bruit = bruits[s] = bruit_propre([v for _, v in ms])
|
||||
nuits = {}
|
||||
for t, v in ms:
|
||||
if de_nuit(t, h1, h2):
|
||||
nuits.setdefault((t - timedelta(hours=h1)).date(), []).append((t, v))
|
||||
niv = {d: statistics.median(v for _, v in p) for d, p in nuits.items()}
|
||||
cases = []
|
||||
for d in sorted(nuits):
|
||||
vs = [v for _, v in nuits[d]]
|
||||
cases.append(f"{d:%d/%m} {niv[d]:+.6g} ±{statistics.median(abs(v - niv[d]) for v in vs):.2g} ({len(vs)})")
|
||||
print(f"{s:9}bruit {bruit:.3g} | " + (" | ".join(cases) if cases else "aucune mesure de nuit"))
|
||||
jours = sorted(nuits)
|
||||
for da, db in zip(jours, jours[1:]):
|
||||
pts = nuits[da] + nuits[db]
|
||||
j = coupure(pts, niv[da], niv[db])
|
||||
d = niv[db] - niv[da]
|
||||
enb = f"{d / bruit:+.1f}" if bruit else "-"
|
||||
print(f"{'':9}{da:%d/%m} → {db:%d/%m} : {d:+.4g} ({enb} bruits), entre {iso(pts[j - 1][0])} et {iso(pts[j][0])}")
|
||||
|
||||
def niveau_de(t):
|
||||
d = (t - timedelta(hours=h1)).date()
|
||||
if d in niv:
|
||||
return niv[d]
|
||||
return niv[min(niv, key=lambda x: abs((x - d).days))] if niv else statistics.median(v for _, v in ms)
|
||||
|
||||
par_jour = {}
|
||||
for t, v in ms:
|
||||
e = v - niveau_de(t)
|
||||
par_jour.setdefault(t.date(), []).append((t.hour + t.minute / 60, e))
|
||||
if bruit and abs(e) > o.k * bruit:
|
||||
c = (t.hour * 60 + t.minute) // pas * pas
|
||||
creneaux.setdefault(c, {}).setdefault((s, e > 0), {})[t.date()] = e
|
||||
for i, (d, p) in enumerate(sorted(par_jour.items())):
|
||||
ax.plot([x for x, _ in p], [e for _, e in p], "-", lw=0.8, color=f"C{i % 10}", label=f"{d:%d/%m}")
|
||||
ax.axhline(0, color="0.3", ls=":", lw=0.8)
|
||||
tous = sorted(e for p in par_jour.values() for _, e in p)
|
||||
q1, q2 = tous[len(tous) // 100], tous[-1 - len(tous) // 100] # cadre du 1er au 99e centile : un pic isolé n'écrase pas l'échelle
|
||||
marge = (q2 - q1) * 0.5 or 1
|
||||
ax.set_ylim(q1 - marge, q2 + marge)
|
||||
hors_cadre = sum(not q1 - marge <= e <= q2 + marge for e in tous)
|
||||
for x0, x1 in ((h1, 24), (0, h2)) if h1 > h2 else ((h1, h2),):
|
||||
ax.axvspan(x0, x1, color="0.9", lw=0)
|
||||
ax.set_title(s + (" (réf.)" if est_reference(series[s]) else "") + f" bruit {bruit:.2g}"
|
||||
+ (f" ({hors_cadre} hors cadre)" if hors_cadre else ""), fontsize=9)
|
||||
ax.set_xlim(0, 24)
|
||||
ax.set_xticks(range(0, 25, 3))
|
||||
ax.grid(alpha=0.3)
|
||||
ax.tick_params(labelsize=7)
|
||||
if ax is axes.flat[0]:
|
||||
ax.legend(fontsize=6, ncol=2)
|
||||
for ax in list(axes.flat)[len(noms):]:
|
||||
ax.axis("off")
|
||||
fig.suptitle(f"{station} : {col} moins le niveau de la dernière nuit ({h1} h → {h2} h, grisée), "
|
||||
"une courbe par jour, en abscisse l'heure du jour (UTC) ; une échelle par capteur")
|
||||
fig.tight_layout()
|
||||
chemin = os.path.join(o.sortie, f"{station}_parheure-{col}_{borne(o.debut, 'debut')}_{borne(o.fin, 'fin')}.png")
|
||||
fig.savefig(chemin, dpi=100, bbox_inches="tight")
|
||||
plt.close(fig)
|
||||
print(chemin)
|
||||
|
||||
nb_jours = {s: {} for s in noms} # capteur -> créneau -> jours mesurés
|
||||
for s in noms:
|
||||
for m in series[s]:
|
||||
if m[col] is not None:
|
||||
nb_jours[s].setdefault((m["t"].hour * 60 + m["t"].minute) // pas * pas, set()).add(m["t"].date())
|
||||
print(f"\n{col} : par créneau de {pas} min de l'heure du jour, capteurs à plus de {o.k:g} bruits du niveau de la nuit "
|
||||
f"au moins {o.jours} jours (jours / jours mesurés, médiane de ces écarts, en bruits)")
|
||||
vide = True
|
||||
for c in sorted(creneaux):
|
||||
cites = []
|
||||
for s, haut in ((s, h) for s in noms for h in (True, False)):
|
||||
ec = creneaux[c].get((s, haut), {})
|
||||
if len(ec) >= o.jours:
|
||||
med = statistics.median(ec.values())
|
||||
cites.append(f"{s} {len(ec)}/{len(nb_jours[s].get(c, ()))} {med:+.3g} ({med / bruits[s]:+.1f})")
|
||||
if cites:
|
||||
vide = False
|
||||
print(f"{c // 60:02d}:{c % 60:02d} {len(cites):2} capteurs : " + ", ".join(cites))
|
||||
if vide:
|
||||
print("(aucun)")
|
||||
|
||||
if o.bornes:
|
||||
bornes(o, noms, series, colonnes, station)
|
||||
|
||||
|
||||
def niveaux_de_nuit(pts, h1, h2):
|
||||
"""[(t, v)] -> {date de la nuit: médiane}."""
|
||||
nuits = {}
|
||||
for t, v in pts:
|
||||
if de_nuit(t, h1, h2):
|
||||
nuits.setdefault((t - timedelta(hours=h1)).date(), []).append(v)
|
||||
return {d: statistics.median(v) for d, v in nuits.items()}
|
||||
|
||||
|
||||
def bornes(o, noms, series, colonnes, station):
|
||||
"""Section 3 : par jour, l'écart au niveau de la nuit qui le précède, pour la médiane des cibles et la pose."""
|
||||
h1, h2 = o.nuit
|
||||
duree_nuit = timedelta(hours=(h2 - h1) % 24)
|
||||
choisis = noms if o.capteurs else [s for s in noms if series[s] and not est_reference(series[s])] or noms
|
||||
suites = [(f"{col} médiane de {len(choisis)} capteur(s)" if len(choisis) > 1 else f"{col} {choisis[0]}", col,
|
||||
{s: [(m["t"], m[col]) for m in series[s] if m[col] is not None] for s in choisis}) for col in colonnes]
|
||||
poses = filtrer(charger_camera(o.dossier), o.debut, o.fin)
|
||||
suites += [(f"pose {c}", f"pose_{c}", {c: [(p["t"], p[c]) for p in poses if p[c] is not None]}) for c in POSE
|
||||
if any(p[c] is not None for p in poses)]
|
||||
tous = [t for _, _, d in suites for p in d.values() for t, _ in p]
|
||||
t0, t1 = min(tous), max(tous)
|
||||
nuit_de = lambda t: (t - duree_nuit - timedelta(hours=h1)).date() # nuit qui finit avant t (le jour de t commence à sa fin)
|
||||
jours = [nuit_de(t0) + timedelta(days=i) for i in range((nuit_de(t1) - nuit_de(t0)).days + 1)]
|
||||
hm = lambda t: f"{t:%d/%m %H:%M}"
|
||||
seuil_txt = f"seuil {o.fraction:g} fois le plus grand |écart| du jour" if o.fraction else f"seuil {o.k:g} bruits"
|
||||
print(f"\n== Bornes de chaque jour : écart au niveau de la nuit qui le précède ({h1} h → {h2} h UTC), {seuil_txt}"
|
||||
+ (f", écart lissé sur {o.lissage} mesures" if o.lissage > 1 else "") + " ==")
|
||||
print("jour : de la fin d'une nuit à la fin de la suivante, daté de son début ; « avant », « après » : mesure juste avant le premier "
|
||||
"dépassement, juste après le dernier ; nuit suivante : son niveau moins celui de la nuit de référence")
|
||||
fig, axes = plt.subplots(len(suites), 1, sharex=True, figsize=(18, 2.2 * len(suites)), squeeze=False)
|
||||
for ax, (nom, court, par_capteur) in zip(axes.flat, suites):
|
||||
niv = {s: niveaux_de_nuit(p, h1, h2) for s, p in par_capteur.items()}
|
||||
nuits = sorted({d for n in niv.values() for d in n})
|
||||
ecarts = [] # (jour, nuit de réf., [(t, écart)], écart de la nuit suivante)
|
||||
for d in jours:
|
||||
debut = datetime.combine(d, datetime.min.time(), tzinfo=timezone.utc) + timedelta(hours=h1) + duree_nuit
|
||||
fin = debut + timedelta(days=1)
|
||||
ref = max((n for n in nuits if n <= d), default=None) or (min(nuits) if nuits else None)
|
||||
par_t = {}
|
||||
for s, p in par_capteur.items():
|
||||
if ref in niv[s]:
|
||||
for t, v in p:
|
||||
if debut <= t < fin:
|
||||
par_t.setdefault(t, []).append(v - niv[s][ref])
|
||||
suivante = [niv[s][d + timedelta(days=1)] - niv[s][ref] for s in niv if ref in niv[s] and d + timedelta(days=1) in niv[s]]
|
||||
ecarts.append((debut.date(), d, ref, [(t, statistics.median(e)) for t, e in sorted(par_t.items())],
|
||||
statistics.median(suivante) if suivante else None))
|
||||
diffs = [abs(b[1] - a_[1]) for *_, p, _ in ecarts for a_, b in zip(p, p[1:])]
|
||||
bruit = statistics.median(diffs) if diffs else 0
|
||||
bruit = bruit if bruit >= ARRONDI else 0
|
||||
print(f"\n{nom} : bruit {bruit:.3g}")
|
||||
enb = lambda e: f"{e:+.4g} ({e / bruit:+.1f})" if bruit else f"{e:+.4g}"
|
||||
h = o.lissage // 2
|
||||
for jour, d, ref, brut, suiv in ecarts:
|
||||
if not brut:
|
||||
print(f"{court} {jour:%d/%m} aucune mesure" + ("" if nuits else " de nuit"))
|
||||
continue
|
||||
p = [(t, statistics.median(e for _, e in brut[max(0, i - h):i + h + 1])) for i, (t, _) in enumerate(brut)] if h else brut
|
||||
seuil = o.fraction * max(abs(e) for _, e in p) if o.fraction else o.k * bruit
|
||||
ligne = (f"{court} {jour:%d/%m} nuit {ref:%d/%m}" + (" (pas la précédente)" if ref != d else "") + f" | {len(p)} mesures {hm(p[0][0])} → {hm(p[-1][0])} | "
|
||||
+ (f"seuil {seuil:.4g} | " if o.fraction else ""))
|
||||
hors = [i for i, (_, e) in enumerate(p) if seuil and abs(e) > seuil]
|
||||
if hors:
|
||||
i, j = hors[0], hors[-1]
|
||||
ligne += (f"> {'seuil' if o.fraction else f'{o.k:g} bruits'} : {len(hors)} mesures, de {hm(p[i][0])} (avant {hm(p[i - 1][0]) if i else '-'}) "
|
||||
f"à {hm(p[j][0])} (après {hm(p[j + 1][0]) if j + 1 < len(p) else '-'})")
|
||||
ax.axvspan(p[i][0], p[j][0], color="0.85", lw=0)
|
||||
else:
|
||||
ligne += f"jamais > {'seuil' if o.fraction else f'{o.k:g} bruits'}"
|
||||
haut, bas = max(p, key=lambda x: x[1]), min(p, key=lambda x: x[1])
|
||||
ligne += f" | max {enb(haut[1])} à {hm(haut[0])}, min {enb(bas[1])} à {hm(bas[0])}"
|
||||
x = max(range(len(p)), key=lambda i: abs(p[i][1]))
|
||||
signe = 1 if p[x][1] > 0 else -1
|
||||
if seuil and signe * p[x][1] > seuil:
|
||||
i = j = x
|
||||
while i > 0 and signe * p[i - 1][1] > seuil:
|
||||
i -= 1
|
||||
while j + 1 < len(p) and signe * p[j + 1][1] > seuil:
|
||||
j += 1
|
||||
ligne += (f" | autour du {'max' if signe > 0 else 'min'} : {j - i + 1} mesures, de {hm(p[i][0])} (avant {hm(p[i - 1][0]) if i else '-'}) "
|
||||
f"à {hm(p[j][0])} (après {hm(p[j + 1][0]) if j + 1 < len(p) else '-'})")
|
||||
ax.axvspan(p[i][0], p[j][0], color="0.7", lw=0)
|
||||
ligne += f" | nuit suivante {enb(suiv)}" if suiv is not None else " | nuit suivante non mesurée"
|
||||
print(ligne)
|
||||
if h:
|
||||
ax.plot([t for t, _ in brut], [e for _, e in brut], "-", lw=0.5, color="0.6")
|
||||
ax.plot([t for t, _ in p], [e for _, e in p], "-", lw=0.8, color="C0")
|
||||
ax.plot([haut[0], bas[0]], [haut[1], bas[1]], "o", ms=3, color="C3")
|
||||
if bruit and not o.fraction:
|
||||
for y in (o.k * bruit, -o.k * bruit):
|
||||
ax.axhline(y, color="0.4", ls=":", lw=0.8)
|
||||
ax.axhline(0, color="0.3", lw=0.5)
|
||||
tous_e = sorted(e for *_, p, _ in ecarts for _, e in p)
|
||||
hors_cadre = 0
|
||||
if tous_e: # cadre du 1er au 99e centile élargi de moitié, comme parheure : un pic isolé n'écrase pas l'échelle
|
||||
q1, q2 = tous_e[len(tous_e) // 100], tous_e[-1 - len(tous_e) // 100]
|
||||
marge = (q2 - q1) * 0.5 or 1
|
||||
ax.set_ylim(q1 - marge, q2 + marge)
|
||||
hors_cadre = sum(not q1 - marge <= e <= q2 + marge for e in tous_e)
|
||||
ax.set_title(f"{nom} bruit {bruit:.2g}" + (f" ({hors_cadre} hors cadre)" if hors_cadre else ""), fontsize=9)
|
||||
ax.grid(alpha=0.3)
|
||||
ax.tick_params(labelsize=7)
|
||||
fig.suptitle(f"{station} : écart au niveau de la nuit qui précède chaque jour ({h1} h → {h2} h) ; "
|
||||
f"grisé clair : du premier au dernier dépassement {'du seuil (' + seuil_txt + ')' if o.fraction else f'de {o.k:g} bruits'}, foncé : la suite autour de l'extrême ; points : max et min du jour"
|
||||
+ (f" ; écart lissé sur {o.lissage} mesures (bleu), brut (gris)" if o.lissage > 1 else ""))
|
||||
fig.tight_layout()
|
||||
chemin = os.path.join(o.sortie, f"{station}_bornes_{borne(o.debut, 'debut')}_{borne(o.fin, 'fin')}.png")
|
||||
fig.savefig(chemin, dpi=100, bbox_inches="tight")
|
||||
plt.close(fig)
|
||||
print(chemin)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -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()
|
||||
@@ -0,0 +1,156 @@
|
||||
"""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] [--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
|
||||
long fausse la médiane) et à son bruit propre (médiane des écarts entre deux mesures consécutives non vides, hors --hors).
|
||||
1. Un tableau par colonne : niveau, bruit, et le plus grand saut d'une mesure à la suivante (valeur, en bruits,
|
||||
les deux instants).
|
||||
2. Les plages où la colonne s'écarte de son niveau de plus de --k bruits : début et fin (première et dernière
|
||||
mesure hors niveau), nombre de mesures hors niveau, valeur extrême (écart signé au niveau, en unités et en
|
||||
bruits) et son instant. Deux plages du même sens séparées de moins de --fusion (défaut 1h) n'en font qu'une
|
||||
(un écart vers le bas puis vers le haut font deux plages) ; les mesures rejetées (colonne vide) ne coupent pas
|
||||
une plage. Colonne « rejetées » : combien des mesures de la plage sont rejetées par la station (error_value
|
||||
au-dessus du seuil), et « extrême rejetée » si l'extrême l'est ; un saut dont un bout est rejeté le dit.
|
||||
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, bruit_propre, 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)
|
||||
a.add_argument("dossier")
|
||||
a.add_argument("--colonnes", default="error_value,corr_x,corr_y")
|
||||
a.add_argument("--k", type=float, default=5, help="écart au niveau compté, en bruits propres du capteur")
|
||||
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)
|
||||
o = a.parse_args()
|
||||
|
||||
par = charger(o.dossier)
|
||||
if not par:
|
||||
sys.exit(f"Aucun export « advanced » dans {o.dossier} (voir inventaire.py).")
|
||||
noms = o.capteurs.split(",") if o.capteurs else sorted(par, key=lambda s: (not est_reference(par[s]), s))
|
||||
colonnes = o.colonnes.split(",")
|
||||
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.")
|
||||
for demandes, connus, quoi in ((noms, par, "Capteurs"), (colonnes, COLONNES, "Colonnes")):
|
||||
absents = [x for x in demandes if x not in connus]
|
||||
if absents:
|
||||
sys.exit(f"{quoi} inconnus : {', '.join(absents)}. Connus : {', '.join(sorted(connus))}.")
|
||||
series = {s: 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 ==")
|
||||
print(f"{'capteur':9}{'n':>5}{'niveau':>10}{'bruit':>10}{'saut':>10}{'(bruits)':>9} entre")
|
||||
plages = []
|
||||
for s in noms:
|
||||
ms = [(m["t"], m[col]) for m in series[s] if m[col] is not None]
|
||||
rej = {m["t"] for m in series[s] if rejetee(m)}
|
||||
if len(ms) < 2:
|
||||
print(f"{s:9}{len(ms):5} (moins de 2 valeurs)")
|
||||
continue
|
||||
ref = [x for x in ms if not hors or not hors[0] <= x[0] <= hors[1]]
|
||||
if len(ref) < 2:
|
||||
print(f"{s:9}{len(ms):5} (moins de 2 valeurs hors --hors)")
|
||||
continue
|
||||
niv = statistics.median(v for _, v in ref)
|
||||
sauts = [(b[1] - a_[1], a_[0], b[0]) for a_, b in zip(ms, ms[1:])]
|
||||
bruit = bruit_propre([v for _, v in ref])
|
||||
d, t1, t2 = max(sauts, key=lambda x: abs(x[0]))
|
||||
bru = f"{d / bruit:9.1f}" if bruit else f"{'-':>9}"
|
||||
marque = [iso(x) for x in (t1, t2) if x in rej]
|
||||
print(f"{s:9}{len(ms):5}{niv:10.4g}{bruit:10.3g}{d:+10.4g}{bru} {iso(t1)} et {iso(t2)}"
|
||||
+ (f" (rejetée : {', '.join(marque)})" if marque else ""))
|
||||
if not bruit:
|
||||
continue
|
||||
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 - 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, 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{' 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, 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()
|
||||
@@ -0,0 +1,418 @@
|
||||
"""Les six métriques de qualité d'image (peak, flux, sharpness, fwhm, dominance, snr) par capteur, face à sa référence calme.
|
||||
|
||||
Usage : python3 agent-tools/qualite.py <dossier> [--debut T] [--fin T] [--capteurs A,B] [--calme T1/T2,T3/T4]
|
||||
[--commun] [--table METRIQUE] [--pas 15min] [--seuil 0.5]
|
||||
python3 agent-tools/qualite.py <dossier> --etiquettes labeling/auto/X.jsonl [--calme ...] [--debut T] [--fin T]
|
||||
[--numeros 3,7] [--seuil 0.5] [--marge 60] [--bords] | [--hors [--min 1] [--sauf "Thermal displacement"]]
|
||||
.venv/bin/python agent-tools/qualite.py <dossier> --figure [--calme ...] [--debut T] [--fin T]
|
||||
[--metriques flux,snr,dominance] [--etiquettes F] [--zone T1/T2 ...] [--sortie D]
|
||||
python3 agent-tools/qualite.py --essai (contrôle du calcul du rapport)
|
||||
|
||||
Définitions : labeling/connaissances/metriques-de-qualite.md. Colonnes remplies sur les caméras récentes seulement ; sur un dossier où
|
||||
elles sont vides, l'outil le dit et s'arrête.
|
||||
Référence d'un capteur : la médiane de chaque métrique sur ses mesures des fenêtres --calme, à la même heure UTC du jour
|
||||
(24 créneaux ; un créneau sans mesure calme prend la médiane de toutes les heures calmes). Sans --calme : tout le dossier.
|
||||
Chaque mesure devient un rapport valeur / référence : 1 = comme la référence ; < 1 plus bas ; > 1 plus haut. Pour fwhm et
|
||||
dominance, c'est la hausse qui dit une image dégradée (tache plus large, second pic plus fort). Mesures rejetées comprises
|
||||
(la qualité de leur image reste mesurée).
|
||||
|
||||
Sans --etiquettes ni --figure :
|
||||
1. le peak maximal du dossier, puis le résumé par capteur : mesures rejetées, « pk/max » (peak médian du capteur sur la
|
||||
fenêtre divisé par ce maximum : une tache au plafond de l'image a un peak constant), et pour chaque métrique le rapport médian sur la fenêtre et l'extrême (min pour peak, flux, sharpness, snr ; max pour
|
||||
fwhm, dominance) avec son instant ; puis les lignes « cibles » et « références » : la médiane des rapports médians ;
|
||||
2. --commun : par pas de --pas, la médiane des rapports des cibles et celle des références, pour chaque métrique ;
|
||||
3. --table M : par pas, le rapport de M de chaque capteur (« * » : une mesure du pas rejetée), « méd » (médiane sur les
|
||||
capteurs) et le nombre de capteurs sous --seuil (au-dessus de 1/--seuil pour fwhm et dominance).
|
||||
--etiquettes F (un JSON par ligne, debut, fin, categorie), sans --figure : par étiquette (numérotée dans l'ordre du
|
||||
fichier ; --debut/--fin gardent celles qui y commencent), le rapport médian des cibles et des références sur l'heure
|
||||
d'avant, la plage et l'heure d'après (--marge minutes) : « cib 0.95|0.40|0.97 » ; puis les capteurs « touchés » sur la
|
||||
plage (flux ou snr sous --seuil, ou dominance au-dessus de 1/--seuil), avec leur pire rapport de flux, du plus bas au plus
|
||||
haut (r = référence). --bords : par instant de la plage élargie de --marge, le nombre de capteurs touchés et la médiane
|
||||
des cibles de flux, snr, dominance (« < » : dans la plage). --hors : à la place, les suites d'instants de --debut à --fin
|
||||
qu'aucune étiquette ne couvre (hors familles --sauf), où au moins --min capteurs sont touchés (instants à moins de 15 min
|
||||
groupés), avec les capteurs touchés et leur pire flux.
|
||||
--figure (matplotlib) : PNG « qualite-commun » : un panneau par métrique, échelle logarithmique, médiane des cibles (noir),
|
||||
des références (rouge) et bande du 10e au 90e centile des cibles ; PNG « qualite-<métrique> » par --metriques : un petit
|
||||
graphique par capteur, références en rouge. --etiquettes grise chaque étiquette d'une couleur par famille ; --zone grise
|
||||
des plages. Trait coupé sur un trou de plus de 30 min. Imprime le chemin de chaque PNG.
|
||||
Rend des valeurs, pas de verdict. Lancé depuis la racine du dépôt.
|
||||
"""
|
||||
import argparse
|
||||
import bisect
|
||||
import json
|
||||
import os
|
||||
import statistics
|
||||
import sys
|
||||
from datetime import timedelta
|
||||
|
||||
import donnees
|
||||
from resume import QUALITE as METRIQUES, duree
|
||||
|
||||
HAUT_MAUVAIS = ("fwhm", "dominance") # pour ces deux-là, c'est la hausse qui dit une image dégradée
|
||||
RACINE = os.path.normpath(os.path.join(os.path.dirname(os.path.abspath(__file__)), ".."))
|
||||
COULEURS = {"Visibility": "tab:blue", "Obstruction": "tab:orange", "Thermal displacement": "tab:red",
|
||||
"Displacement": "tab:purple", "Target issue": "tab:brown", "No data": "black"}
|
||||
|
||||
|
||||
def fenetres(texte):
|
||||
"""'T1/T2,T3/T4' -> [(début, fin)]."""
|
||||
return [tuple(donnees.instant(b) for b in f.split("/")) for f in texte.split(",")] if texte else []
|
||||
|
||||
|
||||
def dans(t, fen):
|
||||
return any(a <= t <= b for a, b in fen)
|
||||
|
||||
|
||||
def references(par, calme):
|
||||
"""{capteur: {métrique: {heure: médiane, None: médiane toutes heures}}} sur les mesures calmes."""
|
||||
ref = {}
|
||||
for s, ms in par.items():
|
||||
ref[s] = {}
|
||||
for c in METRIQUES:
|
||||
parh, tout = {}, []
|
||||
for m in ms:
|
||||
if m[c] is None or (calme and not dans(m["t"], calme)):
|
||||
continue
|
||||
parh.setdefault(m["t"].hour, []).append(m[c])
|
||||
tout.append(m[c])
|
||||
r = {h: statistics.median(v) for h, v in parh.items()}
|
||||
r[None] = statistics.median(tout) if tout else None
|
||||
ref[s][c] = r
|
||||
return ref
|
||||
|
||||
|
||||
def rapport(ref, s, c, m):
|
||||
r = ref[s][c].get(m["t"].hour, ref[s][c][None])
|
||||
return m[c] / r if m[c] is not None and r else None
|
||||
|
||||
|
||||
def touche(r, c, seuil):
|
||||
return r is not None and ((c in ("flux", "snr") and r < seuil) or (c == "dominance" and r > 1 / seuil))
|
||||
|
||||
|
||||
def med(v):
|
||||
return f"{statistics.median(v):.2f}" if v else "-"
|
||||
|
||||
|
||||
def resume(par, ref, noms, refs, pmax):
|
||||
print(f"peak maximal du dossier : {pmax if pmax is None else f'{pmax:g}'} ; pk/max : peak médian du capteur sur la "
|
||||
"fenêtre, divisé par ce maximum")
|
||||
print("Résumé : rapport médian à la référence calme, puis l'extrême et son instant (UTC)")
|
||||
print(f"{'capteur':>12} {'rej':>4} {'pk/max':>6} " + " ".join(f"{c:>26}" for c in METRIQUES))
|
||||
meds = {c: {"cibles": [], "références": []} for c in METRIQUES}
|
||||
for s in noms:
|
||||
ms = par[s]
|
||||
if not ms:
|
||||
continue
|
||||
cases = []
|
||||
for c in METRIQUES:
|
||||
rs = [(rapport(ref, s, c, m), m["t"]) for m in ms]
|
||||
rs = [x for x in rs if x[0] is not None]
|
||||
if not rs:
|
||||
cases.append(f"{'vide':>26}")
|
||||
continue
|
||||
md = statistics.median(r for r, _ in rs)
|
||||
ext = (max if c in HAUT_MAUVAIS else min)(rs, key=lambda x: x[0])
|
||||
meds[c]["références" if s in refs else "cibles"].append(md)
|
||||
cases.append(f"{md:6.2f} ({ext[0]:6.2f} {ext[1]:%d/%m %H:%M})")
|
||||
rej = sum(1 for m in ms if donnees.rejetee(m))
|
||||
pk = [m["peak"] for m in ms if m["peak"] is not None]
|
||||
pk = f"{statistics.median(pk) / pmax:6.2f}" if pk and pmax else f"{'-':>6}"
|
||||
print(f"{s + ('r' if s in refs else ''):>12} {rej:>4} {pk} " + " ".join(cases))
|
||||
for g in ("cibles", "références"):
|
||||
print(f"{g:>24} " + " ".join(f"{statistics.median(meds[c][g]):26.2f}" if meds[c][g] else f"{'-':>26}"
|
||||
for c in METRIQUES))
|
||||
|
||||
|
||||
def par_pas(par, noms, pas):
|
||||
pas = duree(pas)
|
||||
debut = min(m["t"] for s in noms for m in par[s]).replace(hour=0, minute=0, second=0, microsecond=0)
|
||||
return lambda t: debut + (t - debut) // pas * pas
|
||||
|
||||
|
||||
def table(par, ref, noms, c, pas, seuil):
|
||||
cle, cases = par_pas(par, noms, pas), {}
|
||||
for s in noms:
|
||||
for m in par[s]:
|
||||
r = rapport(ref, s, c, m)
|
||||
if r is not None:
|
||||
cases.setdefault(cle(m["t"]), {}).setdefault(s, []).append((r, donnees.rejetee(m)))
|
||||
haut = c in HAUT_MAUVAIS
|
||||
print(f"\nTable de {c} / référence, pas de {pas} ('*' : une mesure du pas rejetée)")
|
||||
w = max(7, *map(len, noms))
|
||||
entete = f"{'instant':16} " + " ".join(f"{s:>{w}}" for s in noms) + f" {'méd':>6} {'n' + ('>' if haut else '<') + str(seuil):>6}"
|
||||
for i, k in enumerate(sorted(cases)):
|
||||
if i % 24 == 0:
|
||||
print(entete)
|
||||
ligne, vals = [], []
|
||||
for s in noms:
|
||||
v = cases[k].get(s)
|
||||
if not v:
|
||||
ligne.append(f"{'':>{w}}")
|
||||
continue
|
||||
r = statistics.median(x for x, _ in v)
|
||||
vals.append(r)
|
||||
ligne.append(f"{r:{w - 1}.2f}" + ("*" if any(j for _, j in v) else " "))
|
||||
n = sum(1 for r in vals if (r > 1 / seuil if haut else r < seuil))
|
||||
print(f"{k:%Y-%m-%d %H:%M} " + " ".join(ligne) + f" {statistics.median(vals):6.2f} {n:>6}")
|
||||
|
||||
|
||||
def commun(par, ref, noms, refs, pas):
|
||||
"""Par pas : médiane des rapports des cibles, puis des références, pour chaque métrique."""
|
||||
cle, cases = par_pas(par, noms, pas), {}
|
||||
for s in noms:
|
||||
for m in par[s]:
|
||||
d = cases.setdefault(cle(m["t"]), {c: ([], []) for c in METRIQUES})
|
||||
for c in METRIQUES:
|
||||
r = rapport(ref, s, c, m)
|
||||
if r is not None:
|
||||
d[c][s in refs].append(r)
|
||||
print(f"\nMédianes des rapports par pas de {pas} : cibles / références")
|
||||
entete = f"{'instant':16} " + " ".join(f"{c:>13}" for c in METRIQUES)
|
||||
for i, k in enumerate(sorted(cases)):
|
||||
if i % 24 == 0:
|
||||
print(entete)
|
||||
print(f"{k:%Y-%m-%d %H:%M} " + " ".join(
|
||||
f"{statistics.median(cases[k][c][0]) if cases[k][c][0] else float('nan'):6.2f}/"
|
||||
f"{statistics.median(cases[k][c][1]) if cases[k][c][1] else float('nan'):<6.2f}" for c in METRIQUES))
|
||||
|
||||
|
||||
def lire_etiquettes(chemin):
|
||||
return [json.loads(ligne) for ligne in open(chemin) if ligne.strip()]
|
||||
|
||||
|
||||
def etiquettes(a, tout, ref, refs, noms, deb, fin):
|
||||
marge = timedelta(minutes=a.marge)
|
||||
temps = {s: [m["t"] for m in tout[s]] for s in noms}
|
||||
garder = {int(n) for n in a.numeros.split(",")} if a.numeros else None
|
||||
print(f"Référence calme : {a.calme or 'tout le dossier'} ; rapports médians avant|plage|après ({a.marge} min)")
|
||||
for n, e in enumerate(lire_etiquettes(a.etiquettes), 1):
|
||||
t0, t1 = donnees.instant(e["debut"]), donnees.instant(e["fin"])
|
||||
if (garder and n not in garder) or (deb and t0 < deb) or (fin and t0 > fin):
|
||||
continue
|
||||
print(f"\n{n}. {e['debut']} → {e['fin']}, {e['categorie']}")
|
||||
win = {s: tout[s][bisect.bisect_left(temps[s], t0 - marge):bisect.bisect_right(temps[s], t1 + marge)] for s in noms}
|
||||
parties = [(t0 - marge, t0 - timedelta(seconds=1)), (t0, t1), (t1 + timedelta(seconds=1), t1 + marge)]
|
||||
for c in METRIQUES:
|
||||
cases = []
|
||||
for g in (False, True):
|
||||
vals = []
|
||||
for a0, a1 in parties:
|
||||
v = [rapport(ref, s, c, m) for s in win if (s in refs) == g for m in win[s] if a0 <= m["t"] <= a1]
|
||||
vals.append(med([x for x in v if x is not None]))
|
||||
cases.append(("ref " if g else "cib ") + "|".join(vals))
|
||||
print(f" {c:>9} " + " ".join(cases))
|
||||
pires = []
|
||||
for s in noms:
|
||||
ms = [m for m in win[s] if t0 <= m["t"] <= t1]
|
||||
if any(touche(rapport(ref, s, c, m), c, a.seuil) for m in ms for c in ("flux", "snr", "dominance")):
|
||||
fl = [x for x in (rapport(ref, s, "flux", m) for m in ms) if x is not None]
|
||||
pires.append((min(fl) if fl else 1, s + ("r" if s in refs else "")))
|
||||
pires.sort()
|
||||
print(f" touchés ({len(pires)}) : " + ", ".join(f"{s} {f:.2f}" for f, s in pires) if pires else " touchés : aucun")
|
||||
if a.bords:
|
||||
inst = {}
|
||||
for s in win:
|
||||
for m in win[s]:
|
||||
d = inst.setdefault(m["t"], {"n": 0, "flux": [], "snr": [], "dominance": []})
|
||||
rs = {c: rapport(ref, s, c, m) for c in ("flux", "snr", "dominance")}
|
||||
d["n"] += any(touche(rs[c], c, a.seuil) for c in rs)
|
||||
if s not in refs:
|
||||
for c in rs:
|
||||
if rs[c] is not None:
|
||||
d[c].append(rs[c])
|
||||
print(" instant n flux snr dom")
|
||||
for t in sorted(inst):
|
||||
d = inst[t]
|
||||
print(f" {t:%Y-%m-%d %H:%M} {d['n']:>3} {med(d['flux']):>5} {med(d['snr']):>5} {med(d['dominance']):>5}"
|
||||
+ (" <" if t0 <= t <= t1 else ""))
|
||||
|
||||
|
||||
def hors(a, tout, ref, refs, noms, deb, fin):
|
||||
sauf = set(a.sauf.split(",")) if a.sauf else set()
|
||||
couvert = [(donnees.instant(e["debut"]), donnees.instant(e["fin"])) for e in lire_etiquettes(a.etiquettes)
|
||||
if e["categorie"] not in sauf]
|
||||
inst = {}
|
||||
for s in noms:
|
||||
for m in donnees.filtrer(tout[s], deb, fin):
|
||||
if dans(m["t"], couvert):
|
||||
continue
|
||||
if any(touche(rapport(ref, s, c, m), c, a.seuil) for c in ("flux", "snr", "dominance")):
|
||||
inst.setdefault(m["t"], {})[s + ("r" if s in refs else "")] = rapport(ref, s, "flux", m) or 0
|
||||
suites = []
|
||||
for t in sorted(t for t in inst if len(inst[t]) >= a.min):
|
||||
if suites and t - suites[-1][-1] <= timedelta(minutes=15):
|
||||
suites[-1].append(t)
|
||||
else:
|
||||
suites.append([t])
|
||||
print(f"Hors des étiquettes (sauf {a.sauf}) : instants où au moins {a.min} capteurs sont touchés ; {len(suites)} suites")
|
||||
for su in suites:
|
||||
pire = {}
|
||||
for t in su:
|
||||
for s, f in inst[t].items():
|
||||
pire[s] = min(pire.get(s, 9), f)
|
||||
print(f"{su[0]:%Y-%m-%d %H:%M} → {su[-1]:%H:%M} ({len(su)}) : "
|
||||
+ ", ".join(f"{s} {f:.2f}" for s, f in sorted(pire.items(), key=lambda x: x[1])))
|
||||
|
||||
|
||||
def morceaux(pts, trou=timedelta(minutes=30)):
|
||||
"""[(t, ...)] -> listes coupées là où deux instants sont à plus de `trou` : un trait ne traverse pas un trou de mesures."""
|
||||
out = []
|
||||
for i, x in enumerate(pts):
|
||||
if not out or x[0] - pts[i - 1][0] > trou:
|
||||
out.append([])
|
||||
out[-1].append(x)
|
||||
return out
|
||||
|
||||
|
||||
def figure(a, par, ref, noms, refs, deb, fin):
|
||||
import matplotlib
|
||||
matplotlib.use("Agg")
|
||||
import matplotlib.dates as mdates
|
||||
import matplotlib.pyplot as plt
|
||||
|
||||
plages = [(x, y, "grey") for x, y in fenetres(",".join(a.zone or []))]
|
||||
if a.etiquettes:
|
||||
for e in lire_etiquettes(a.etiquettes):
|
||||
x, y = donnees.instant(e["debut"]), donnees.instant(e["fin"])
|
||||
if (deb is None or y >= deb) and (fin is None or x <= fin):
|
||||
plages.append((x, y, COULEURS.get(e["categorie"], "grey")))
|
||||
station = os.path.basename(os.path.normpath(a.dossier))
|
||||
t0 = min(m["t"] for s in noms for m in par[s])
|
||||
t1 = max(m["t"] for s in noms for m in par[s])
|
||||
suffixe = f"{t0:%Y%m%dT%H%MZ}_{t1:%Y%m%dT%H%MZ}"
|
||||
os.makedirs(a.sortie, exist_ok=True)
|
||||
|
||||
def axe(ax):
|
||||
for x, y, couleur in plages:
|
||||
ax.axvspan(x, y, color=couleur, alpha=0.12, lw=0)
|
||||
ax.xaxis.set_major_formatter(mdates.DateFormatter("%d/%m\n%H:%M"))
|
||||
ax.set_yscale("log")
|
||||
ax.axhline(1, ls=":", c="k", lw=0.8)
|
||||
ax.set_xlim(t0, t1)
|
||||
|
||||
fig, axes = plt.subplots(len(METRIQUES), 1, figsize=(16, 2.4 * len(METRIQUES)), sharex=True)
|
||||
for ax, c in zip(axes, METRIQUES):
|
||||
inst = {}
|
||||
for s in noms:
|
||||
for m in par[s]:
|
||||
r = rapport(ref, s, c, m)
|
||||
if r is not None and r > 0:
|
||||
inst.setdefault(m["t"], ([], []))[s in refs].append(r)
|
||||
ts = sorted(inst)
|
||||
cib = [(t, sorted(inst[t][0])) for t in ts if inst[t][0]]
|
||||
rfs = [(t, statistics.median(inst[t][1])) for t in ts if inst[t][1]]
|
||||
for i, mc in enumerate(morceaux(cib)):
|
||||
ax.fill_between([t for t, _ in mc], [v[len(v) // 10] for _, v in mc], [v[(len(v) * 9) // 10] for _, v in mc],
|
||||
color="0.8", lw=0, step="mid")
|
||||
ax.plot([t for t, _ in mc], [statistics.median(v) for _, v in mc], c="k", lw=0.7,
|
||||
label="cibles (médiane, bande 10-90 %)" if i == 0 else None)
|
||||
for i, mc in enumerate(morceaux(rfs)):
|
||||
ax.plot([t for t, _ in mc], [v for _, v in mc], c="tab:red", lw=0.7, label="références (médiane)" if i == 0 else None)
|
||||
axe(ax)
|
||||
ax.set_ylabel(c)
|
||||
axes[0].legend(loc="upper right", fontsize=8)
|
||||
axes[0].set_title(f"{station} : métriques de qualité / référence calme ({a.calme or 'tout le dossier'}), même heure UTC")
|
||||
chemin = os.path.join(a.sortie, f"{station}_qualite-commun_{suffixe}.png")
|
||||
fig.tight_layout()
|
||||
fig.savefig(chemin, dpi=90)
|
||||
plt.close(fig)
|
||||
print(chemin)
|
||||
|
||||
for c in a.metriques.split(","):
|
||||
col = 6
|
||||
lig = (len(noms) + col - 1) // col
|
||||
fig, axes = plt.subplots(lig, col, figsize=(3.2 * col, 1.9 * lig), sharex=True, squeeze=False)
|
||||
for ax, s in zip(axes.flat, noms):
|
||||
pts = [(m["t"], rapport(ref, s, c, m)) for m in par[s]]
|
||||
pts = [(t, r) for t, r in pts if r is not None and r > 0]
|
||||
for mc in morceaux(pts):
|
||||
ax.plot([t for t, _ in mc], [r for _, r in mc], lw=0.5, c="tab:red" if s in refs else "k")
|
||||
axe(ax)
|
||||
ax.set_title(s, fontsize=8, color="tab:red" if s in refs else "k")
|
||||
ax.tick_params(labelsize=6)
|
||||
for ax in list(axes.flat)[len(noms):]:
|
||||
ax.axis("off")
|
||||
fig.suptitle(f"{station} : {c} / référence calme, par capteur (références en rouge)")
|
||||
chemin = os.path.join(a.sortie, f"{station}_qualite-{c}_{suffixe}.png")
|
||||
fig.tight_layout()
|
||||
fig.savefig(chemin, dpi=80)
|
||||
plt.close(fig)
|
||||
print(chemin)
|
||||
|
||||
|
||||
def main():
|
||||
p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
|
||||
p.add_argument("dossier")
|
||||
p.add_argument("--debut", type=donnees.instant)
|
||||
p.add_argument("--fin", type=donnees.instant)
|
||||
p.add_argument("--capteurs", help="liste séparée par des virgules (défaut : tous)")
|
||||
p.add_argument("--calme", help="fenêtres de la référence, T1/T2,T3/T4 (défaut : tout le dossier)")
|
||||
p.add_argument("--commun", action="store_true", help="médianes des cibles et des références par pas")
|
||||
p.add_argument("--table", choices=METRIQUES, help="rapport d'une métrique par pas et par capteur")
|
||||
p.add_argument("--pas", default="15min", type=lambda x: duree(x) and x, help="15min, 1h, 1d")
|
||||
p.add_argument("--seuil", type=float, default=0.5, help="« touché » : flux ou snr sous seuil, dominance au-dessus de 1/seuil")
|
||||
p.add_argument("--etiquettes", help="fichier d'étiquettes (JSON par ligne)")
|
||||
p.add_argument("--numeros", help="numéros d'étiquettes à lire, 3,7")
|
||||
p.add_argument("--marge", type=int, default=60, help="minutes avant et après chaque étiquette")
|
||||
p.add_argument("--bords", action="store_true")
|
||||
p.add_argument("--hors", action="store_true", help="instants touchés qu'aucune étiquette ne couvre")
|
||||
p.add_argument("--min", type=int, default=1)
|
||||
p.add_argument("--sauf", default="Thermal displacement", help="familles ignorées par --hors, A,B")
|
||||
p.add_argument("--figure", action="store_true", help="PNG (matplotlib : .venv/bin/python)")
|
||||
p.add_argument("--metriques", default="flux,snr,dominance", help="PNG par capteur de --figure")
|
||||
p.add_argument("--zone", action="append", help="plage à griser sur les PNG, T1/T2 (répétable)")
|
||||
p.add_argument("--sortie", default=os.path.join(RACINE, "out", "diagnostic"), help="dossier des PNG")
|
||||
a = p.parse_args()
|
||||
if a.hors and not a.etiquettes:
|
||||
p.error("--hors demande --etiquettes")
|
||||
inconnues = [c for c in a.metriques.split(",") if c not in METRIQUES]
|
||||
if inconnues:
|
||||
p.error(f"métriques inconnues : {', '.join(inconnues)} ; connues : {', '.join(METRIQUES)}")
|
||||
|
||||
tout = donnees.charger(a.dossier)
|
||||
if not tout:
|
||||
sys.exit(f"Aucun export « advanced » dans {a.dossier} (voir inventaire.py).")
|
||||
if not any(m[c] is not None for ms in tout.values() for m in ms for c in METRIQUES):
|
||||
sys.exit(f"Aucune métrique de qualité dans {a.dossier} : peak à snr vides (caméra ancienne ; "
|
||||
"labeling/connaissances/metriques-de-qualite.md).")
|
||||
noms = a.capteurs.split(",") if a.capteurs else sorted(tout, key=lambda s: (not donnees.est_reference(tout[s]), s))
|
||||
absents = [s for s in noms if s not in tout]
|
||||
if absents:
|
||||
sys.exit(f"Capteurs absents : {', '.join(absents)}. Présents : {', '.join(sorted(tout))}.")
|
||||
ref = references(tout, fenetres(a.calme))
|
||||
refs = {s for s in tout if donnees.est_reference(tout[s])}
|
||||
par = {s: donnees.filtrer(tout[s], a.debut, a.fin) for s in noms}
|
||||
if not any(par.values()):
|
||||
sys.exit("Aucune mesure dans la fenêtre demandée.")
|
||||
if a.figure:
|
||||
return figure(a, par, ref, noms, refs, a.debut, a.fin)
|
||||
if a.etiquettes:
|
||||
return (hors if a.hors else etiquettes)(a, tout, ref, refs, noms, a.debut, a.fin)
|
||||
pmax = max((m["peak"] for ms in tout.values() for m in ms if m["peak"] is not None), default=None)
|
||||
print(f"Référence calme : {a.calme or 'tout le dossier'}, par heure UTC du jour (r = référence)")
|
||||
resume(par, ref, noms, refs, pmax)
|
||||
if a.commun:
|
||||
commun(par, ref, noms, refs, a.pas)
|
||||
if a.table:
|
||||
table(par, ref, noms, a.table, a.pas, a.seuil)
|
||||
|
||||
|
||||
def essai():
|
||||
"""Contrôle du rapport à la référence : même heure, repli sur toutes les heures, fenêtre calme respectée."""
|
||||
from datetime import datetime, timezone
|
||||
t = lambda j, h: datetime(2026, 10, j, h, tzinfo=timezone.utc) # noqa: E731
|
||||
vide = dict.fromkeys(METRIQUES)
|
||||
par = {"A": [dict(vide, t=t(1, 3), flux=10.0), dict(vide, t=t(2, 3), flux=30.0), dict(vide, t=t(2, 5), flux=100.0),
|
||||
dict(vide, t=t(9, 3), flux=1000.0)]}
|
||||
ref = references(par, [(t(1, 0), t(3, 0))])
|
||||
assert ref["A"]["flux"][3] == 20.0 and ref["A"]["flux"][None] == 30.0, ref
|
||||
assert rapport(ref, "A", "flux", dict(vide, t=t(9, 3), flux=10.0)) == 0.5
|
||||
assert rapport(ref, "A", "flux", dict(vide, t=t(9, 7), flux=60.0)) == 2.0 # heure sans calme : toutes les heures
|
||||
assert rapport(ref, "A", "snr", dict(vide, t=t(9, 3), snr=5.0)) is None
|
||||
assert touche(0.4, "flux", 0.5) and touche(2.5, "dominance", 0.5) and not touche(2.5, "flux", 0.5)
|
||||
print("essai : ok")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
essai() if sys.argv[1:] == ["--essai"] else main()
|
||||
@@ -0,0 +1,124 @@
|
||||
"""Résumé chiffré compact des séries d'un export « advanced », pour l'agent de diagnostic.
|
||||
|
||||
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).
|
||||
Colonnes : error_value, corr_x, corr_y, relative_x, relative_y, x, y, sigma0, reproj_err, et les six métriques de qualité d'image (peak à snr, valeurs brutes ; vides sur les
|
||||
caméras anciennes ; face à une référence calme : qualite.py).
|
||||
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. 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
|
||||
import re
|
||||
import statistics
|
||||
import sys
|
||||
from datetime import timedelta
|
||||
|
||||
from donnees import charger, est_reference, filtrer, instant, iso, rejetee
|
||||
|
||||
COLONNES = ("error_value", "corr_x", "corr_y", "relative_x", "relative_y", "x", "y", "sigma0", "reproj_err")
|
||||
QUALITE = ("peak", "flux", "sharpness", "fwhm", "dominance", "snr") # qualité de l'image : caméras récentes ; lue par qualite.py
|
||||
STATS = {"median": statistics.median, "min": min, "max": max}
|
||||
|
||||
|
||||
def duree(texte):
|
||||
"""'15min', '1h', '6h', '1d' -> timedelta."""
|
||||
m = re.fullmatch(r"(\d+)(min|h|d)", texte)
|
||||
if not m:
|
||||
raise argparse.ArgumentTypeError(f"pas invalide : {texte!r} (ex. 15min, 1h, 1d)")
|
||||
n, unite = int(m.group(1)), m.group(2)
|
||||
return {"min": timedelta(minutes=n), "h": timedelta(hours=n), "d": timedelta(days=n)}[unite]
|
||||
|
||||
|
||||
ARRONDI = 1e-9 # en deçà, un écart entre deux mesures est l'arrondi du calcul de la station, pas un bruit
|
||||
|
||||
|
||||
def bruit_propre(vs):
|
||||
"""Médiane des écarts absolus entre deux valeurs consécutives ; 0 quand elle est sous ARRONDI (valeurs constantes
|
||||
à l'arrondi près : le corr des références quand la compensation passe exactement par elles, deux références
|
||||
retenues), pour qu'un écart ne s'écrive pas en milliards de bruits ; 0 aussi avec moins de deux valeurs."""
|
||||
d = [abs(b - a) for a, b in zip(vs, vs[1:])]
|
||||
b = statistics.median(d) if d else 0
|
||||
return b if b >= ARRONDI else 0
|
||||
|
||||
|
||||
def valeurs(ms, col):
|
||||
return [m[col] for m in ms if m[col] is not None]
|
||||
|
||||
|
||||
def main():
|
||||
a = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
|
||||
a.add_argument("dossier")
|
||||
a.add_argument("--colonne", default="error_value", choices=COLONNES + QUALITE)
|
||||
a.add_argument("--stat", default="median", choices=STATS)
|
||||
a.add_argument("--pas", default="1h", type=duree)
|
||||
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()
|
||||
|
||||
par = charger(o.dossier)
|
||||
if not par:
|
||||
sys.exit(f"Aucun export « advanced » dans {o.dossier} (voir inventaire.py).")
|
||||
noms = o.capteurs.split(",") if o.capteurs else sorted(par, key=lambda s: (not est_reference(par[s]), s))
|
||||
inconnus = [s for s in noms if s not in par]
|
||||
if inconnus:
|
||||
sys.exit(f"Capteurs absents : {', '.join(inconnus)}. Présents : {', '.join(sorted(par))}.")
|
||||
|
||||
t0 = min(m["t"] for s in noms for m in par[s]).replace(hour=0, minute=0, second=0, microsecond=0)
|
||||
cases = {}
|
||||
for s in noms:
|
||||
for m in filtrer(par[s], o.debut, o.fin):
|
||||
debut_du_pas = t0 + ((m["t"] - t0) // o.pas) * o.pas
|
||||
cases.setdefault(debut_du_pas, {}).setdefault(s, []).append(m)
|
||||
if not cases:
|
||||
sys.exit("Aucune mesure dans la fenêtre demandée.")
|
||||
|
||||
sur = "la fenêtre --debut/--fin" if o.niveau == "fenetre" else "toute la période"
|
||||
print(f"Colonne : {o.colonne}. Niveau habituel sur {sur} (mesures non vides) :")
|
||||
print(f"{'capteur':10} {'n':>5} {'médiane':>10} {'MAD':>10} {'min':>10} {'max':>10}")
|
||||
for s in noms:
|
||||
v = valeurs(filtrer(par[s], o.debut, o.fin) if o.niveau == "fenetre" else par[s], o.colonne)
|
||||
if not v:
|
||||
print(f"{s:10} {0:5} (aucune valeur)")
|
||||
continue
|
||||
med = statistics.median(v)
|
||||
mad = statistics.median(abs(x - med) for x in v)
|
||||
print(f"{s:10} {len(v):5} {med:10.5g} {mad:10.5g} {min(v):10.5g} {max(v):10.5g}")
|
||||
|
||||
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")
|
||||
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:
|
||||
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))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,194 @@
|
||||
"""Plusieurs stations sur une même ligne de temps : température du boîtier, pose de la caméra, corr des cibles, rejets, trous.
|
||||
|
||||
Usage : .venv/bin/python agent-tools/stations.py data/BREITHORN data/MICHIGAN data/NEBRASKA
|
||||
[--colonnes temperature,cam_tilt,cam_rotation,cam_scale,cib_corr_x,cib_corr_y] [--pas 1h] [--stat median|min|max]
|
||||
[--table T1/T2|non] [--debut ...] [--fin ...] [--sortie DOSSIER]
|
||||
|
||||
Pour chaque station (un dossier de station chacune), sur la fenêtre --debut/--fin :
|
||||
- colonnes possibles : temperature (médiane des composants sensor_*_deg_c, comme metriques.py), cam_pan, cam_tilt,
|
||||
cam_rotation, cam_scale, cam_sigma0 (pose brute de la caméra), cib_corr_x, cib_corr_y (médiane sur les cibles de
|
||||
corr moins le niveau propre de chaque cible, mesures acceptées, comme metriques.py), rej_cibles, rej_refs (nombre de
|
||||
cibles, de références rejetées : le plus grand des instants de mesure du pas) ;
|
||||
- imprime, par station, la période des mesures, la cadence (pas médian) et le nombre d'instants ; puis les **trous** :
|
||||
les suites de pas de --pas sans mesure ou sans température, avec les stations où elles manquent (un trou commun à
|
||||
plusieurs stations y est sur une seule ligne) ; puis la table, une ligne par pas (début du pas, UTC ; --stat des
|
||||
valeurs du pas ; « - » : aucune valeur), une colonne par station et par colonne, séparées par des tabulations
|
||||
(--table T1/T2 : seulement entre T1 et T2, « non » : pas du tout ; le reste porte sur toute la fenêtre) ; puis, pour
|
||||
chaque colonne et chaque paire de stations, la corrélation r des valeurs et celle des pas (différence d'une valeur à
|
||||
la suivante, sur les pas où les deux stations ont une valeur : un mouvement commun se voit sur les pas, une tendance
|
||||
commune sur les valeurs), avec le nombre de pas ;
|
||||
- un PNG « stations » : un panneau par colonne, un trait par station (température brute ; les autres colonnes moins
|
||||
leur médiane sur la fenêtre, pour se superposer), coupé sur un trou ; trous de mesure grisés sous l'axe, une bande
|
||||
par station.
|
||||
Jamais d'identifiant de metrics/ (SIM_CCID, ip*) : seules les températures y sont lues. Rend des valeurs, pas de verdict.
|
||||
"""
|
||||
import argparse
|
||||
import os
|
||||
import statistics
|
||||
import sys
|
||||
|
||||
import matplotlib
|
||||
|
||||
matplotlib.use("Agg")
|
||||
import matplotlib.dates as mdates # noqa: E402
|
||||
import matplotlib.pyplot as plt # noqa: E402
|
||||
|
||||
from donnees import POSE, charger, charger_camera, charger_temperature, est_reference, filtrer, instant, iso, rejetee # noqa: E402
|
||||
from graphique import RACINE, borne # noqa: E402
|
||||
from metriques import cibles, coupe, suites # noqa: E402
|
||||
from resume import STATS, duree # noqa: E402
|
||||
|
||||
COLONNES = ("temperature",) + tuple("cam_" + c for c in POSE) + ("cib_corr_x", "cib_corr_y", "rej_cibles", "rej_refs")
|
||||
|
||||
|
||||
def lire(dossier, debut, fin):
|
||||
"""Dossier de station -> ({colonne: [{'t', 'v'}]}, [instants de mesure])."""
|
||||
par = charger(dossier)
|
||||
series = {"temperature": filtrer([{"t": t, "v": v} for t, v in charger_temperature(dossier)], debut, fin)}
|
||||
for p in filtrer(charger_camera(dossier), debut, fin):
|
||||
for c in POSE:
|
||||
if p[c] is not None:
|
||||
series.setdefault("cam_" + c, []).append({"t": p["t"], "v": p[c]})
|
||||
for c in ("corr_x", "corr_y"):
|
||||
series["cib_" + c] = cibles(par, c, debut, fin)
|
||||
rej = {} # t -> [cibles rejetées, références rejetées]
|
||||
for s, ms in par.items():
|
||||
ref = est_reference(ms)
|
||||
for m in filtrer(ms, debut, fin):
|
||||
n = rej.setdefault(m["t"], [0, 0])
|
||||
n[ref] += rejetee(m)
|
||||
series["rej_cibles"] = [{"t": t, "v": float(n[0])} for t, n in sorted(rej.items())]
|
||||
series["rej_refs"] = [{"t": t, "v": float(n[1])} for t, n in sorted(rej.items())]
|
||||
return series, sorted(rej)
|
||||
|
||||
|
||||
def correlation(a, b):
|
||||
try:
|
||||
return f"{statistics.correlation(a, b):+.2f}"
|
||||
except (statistics.StatisticsError, ValueError):
|
||||
return "-"
|
||||
|
||||
|
||||
def main():
|
||||
a = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
|
||||
a.add_argument("dossiers", nargs="+", help="dossiers de station, au moins deux")
|
||||
a.add_argument("--colonnes", default="temperature,cam_tilt,cam_rotation,cam_scale,cib_corr_x,cib_corr_y")
|
||||
a.add_argument("--pas", default="1h", type=duree)
|
||||
a.add_argument("--stat", default="median", choices=STATS)
|
||||
a.add_argument("--table", default="", metavar="T1/T2|non", help="table imprimée seulement entre T1 et T2 (« non » : pas du tout)")
|
||||
a.add_argument("--debut", type=instant)
|
||||
a.add_argument("--fin", type=instant)
|
||||
a.add_argument("--sortie", default=os.path.join(RACINE, "out", "diagnostic"), help="dossier du PNG")
|
||||
o = a.parse_args()
|
||||
colonnes = o.colonnes.split(",")
|
||||
if absents := [c for c in colonnes if c not in COLONNES]:
|
||||
sys.exit(f"Colonnes inconnues : {', '.join(absents)}. Connues : {', '.join(COLONNES)}.")
|
||||
if o.table in ("", "non"):
|
||||
dans_table = lambda t: o.table == "" # noqa: E731
|
||||
else:
|
||||
bornes = [instant(x) for x in o.table.split("/")]
|
||||
if len(bornes) != 2:
|
||||
sys.exit("--table attend T1/T2 ou non.")
|
||||
dans_table = lambda t: bornes[0] <= t <= bornes[1] # noqa: E731
|
||||
|
||||
noms = [os.path.basename(os.path.normpath(d)) for d in o.dossiers]
|
||||
donnees, mesures = {}, {}
|
||||
for n, d in zip(noms, o.dossiers):
|
||||
donnees[n], mesures[n] = lire(d, o.debut, o.fin)
|
||||
tous = [p["t"] for s in donnees.values() for c in s.values() for p in c]
|
||||
if not tous:
|
||||
sys.exit("Aucune valeur dans la fenêtre demandée.")
|
||||
t0 = (o.debut or min(tous)).replace(minute=0, second=0, microsecond=0)
|
||||
t1 = o.fin or max(tous)
|
||||
grille = [t0 + i * o.pas for i in range(int((t1 - t0) / o.pas) + 1)]
|
||||
case = lambda t: t0 + ((t - t0) // o.pas) * o.pas # noqa: E731
|
||||
|
||||
print("Stations :")
|
||||
for n in noms:
|
||||
ts = mesures[n]
|
||||
if not ts:
|
||||
print(f" {n} : aucune mesure dans la fenêtre")
|
||||
continue
|
||||
cad = statistics.median(b - a_ for a_, b in zip(ts, ts[1:])) if len(ts) > 1 else None
|
||||
print(f" {n} : mesures {iso(ts[0])} → {iso(ts[-1])}, {len(ts)} instants, cadence {round(cad.total_seconds() / 60) if cad else '-'} min ; "
|
||||
+ ", ".join(f"{c} {len(donnees[n].get(c, []))}" for c in colonnes))
|
||||
|
||||
# trous : pas sans mesure, sans température, et les stations concernées
|
||||
avec = {n: {case(t) for t in mesures[n]} for n in noms}
|
||||
avec_t = {n: {case(p["t"]) for p in donnees[n]["temperature"]} for n in noms}
|
||||
print(f"\nTrous (pas de {int(o.pas.total_seconds() // 60)} min sans mesure ou sans température), avec les stations où ils manquent :")
|
||||
cles = {}
|
||||
for k in grille:
|
||||
m = tuple(n for n in noms if k not in avec[n])
|
||||
t = tuple(n for n in noms if k not in avec_t[n])
|
||||
if m or t:
|
||||
cles.setdefault((m, t), []).append(k)
|
||||
lignes = []
|
||||
for (m, t), ks in cles.items():
|
||||
for d, f, nb in suites(ks, o.pas):
|
||||
lignes.append((d, f, nb, m, t))
|
||||
for d, f, nb, m, t in sorted(lignes):
|
||||
print(f" {iso(d)} → {iso(f)} ({nb} pas) : sans mesure {','.join(m) or '-'} ; sans température {','.join(t) or '-'}")
|
||||
if not lignes:
|
||||
print(" (aucun)")
|
||||
|
||||
stat = STATS[o.stat]
|
||||
table = {} # (station, colonne) -> {pas: valeur}
|
||||
for n in noms:
|
||||
for c in colonnes:
|
||||
cases = {}
|
||||
for p in donnees[n].get(c, []):
|
||||
cases.setdefault(case(p["t"]), []).append(p["v"])
|
||||
table[n, c] = {k: stat(v) for k, v in cases.items()}
|
||||
entete = [f"{n}:{c}" for n in noms for c in colonnes]
|
||||
print(f"\n{o.stat} par pas de {int(o.pas.total_seconds() // 60)} min (début du pas, UTC) ; « - » : aucune valeur"
|
||||
+ (f" (table : {o.table})" if o.table else "") + " :")
|
||||
if o.table != "non":
|
||||
print("\t".join(["heure"] + entete))
|
||||
for k in grille:
|
||||
if dans_table(k):
|
||||
v = [table[n, c].get(k) for n in noms for c in colonnes]
|
||||
if any(x is not None for x in v):
|
||||
print("\t".join([iso(k)] + ["-" if x is None else f"{x:.6g}" for x in v]))
|
||||
|
||||
print("\nCorrélation entre stations, r des valeurs, puis r des pas d'une valeur à la suivante (n : pas où les deux ont une valeur) :")
|
||||
for c in colonnes:
|
||||
for i, s1 in enumerate(noms):
|
||||
for s2 in noms[i + 1:]:
|
||||
ks = sorted(set(table[s1, c]) & set(table[s2, c]))
|
||||
v1, v2 = [table[s1, c][k] for k in ks], [table[s2, c][k] for k in ks]
|
||||
d1, d2 = [b - a_ for a_, b in zip(v1, v1[1:])], [b - a_ for a_, b in zip(v2, v2[1:])]
|
||||
print(f" {c:12} {s1}-{s2} : r valeurs {correlation(v1, v2)}, r pas {correlation(d1, d2)} (n = {len(ks)})")
|
||||
|
||||
fig, axes = plt.subplots(len(colonnes) + 1, 1, sharex=True, figsize=(14, 2.4 * (len(colonnes) + 1)), squeeze=False,
|
||||
layout="constrained", gridspec_kw={"height_ratios": [3] * len(colonnes) + [0.3 * len(noms)]})
|
||||
for ax, c in zip(axes[:-1, 0], colonnes):
|
||||
for i, n in enumerate(noms):
|
||||
s = donnees[n].get(c, [])
|
||||
if not s:
|
||||
continue
|
||||
med = 0 if c == "temperature" else statistics.median(p["v"] for p in s)
|
||||
ts, vs = coupe([{"t": p["t"], "v": p["v"] - med} for p in s])
|
||||
ax.plot(ts, vs, ".-", ms=2, lw=0.8, color=f"C{i % 10}", label=n)
|
||||
ax.set_ylabel(c if c == "temperature" else f"{c}\nmoins sa médiane", fontsize=8)
|
||||
ax.grid(alpha=0.3)
|
||||
ax.legend(loc="upper left", bbox_to_anchor=(1.0, 1.0), fontsize=8)
|
||||
ax = axes[-1, 0]
|
||||
for i, n in enumerate(noms):
|
||||
for k in grille:
|
||||
if k not in avec[n]:
|
||||
ax.axvspan(k, k + o.pas, ymin=i / len(noms), ymax=(i + 1) / len(noms), color=f"C{i % 10}", lw=0)
|
||||
ax.set_yticks([(i + 0.5) / len(noms) for i in range(len(noms))], noms, fontsize=7)
|
||||
ax.set_ylim(0, 1)
|
||||
ax.set_ylabel("sans mesure", fontsize=8)
|
||||
ax.set_xlim(grille[0], grille[-1] + o.pas)
|
||||
ax.xaxis.set_major_formatter(mdates.DateFormatter("%d/%m\n%H:%MZ"))
|
||||
fig.suptitle(f"{', '.join(noms)} : même ligne de temps (heures UTC)")
|
||||
os.makedirs(o.sortie, exist_ok=True)
|
||||
chemin = os.path.join(o.sortie, f"{'-'.join(noms)}_stations_{borne(o.debut, 'debut')}_{borne(o.fin, 'fin')}.png")
|
||||
fig.savefig(chemin, dpi=100, bbox_inches="tight")
|
||||
print(f"\n{chemin}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,172 @@
|
||||
"""Vignettes des images de la caméra autour de capteurs, à pleine résolution, pour l'agent de diagnostic.
|
||||
|
||||
Usage : .venv/bin/python agent-tools/vignettes.py data/PS_DES_COUDRES/
|
||||
--capteurs REF_G,REF_D --heures 2026-10-13T22:00Z,2026-10-14T02:00Z [--rayon 100] [--contraste [MIN,MAX]] [--sortie DOSSIER]
|
||||
Une ligne par capteur, une colonne par heure. Quand il n'y a pas d'image à l'heure demandée, la plus proche est
|
||||
prise : l'écart est imprimé et l'heure réelle de l'image est dans le titre de la vignette. Chaque vignette est centrée sur la position brute (x, y) du capteur
|
||||
dans l'export « advanced », lue à la mesure la plus proche de l'image ; les pixels ne sont pas retouchés, l'éclat
|
||||
se compare donc d'une vignette à l'autre. Imprime les positions utilisées, le fond (médiane des pixels de la
|
||||
vignette), le 99e centile et le pic (maximum) du niveau de gris de chaque vignette (0 à 255), puis le chemin du PNG.
|
||||
--contraste : toutes les vignettes en niveaux de gris, avec le même étirement pour toute la planche, pour qu'une
|
||||
tache faible se voie et se compare d'une vignette à l'autre. Sans valeur, l'étirement va du 1er centile au maximum
|
||||
de la planche (un pixel saturé quelque part l'écrase : redonner alors --contraste MIN,MAX, en s'aidant du fond et du
|
||||
pic imprimés pour chaque vignette). Un --rayon plus petit (30 à 50) grossit. Les bornes sont imprimées.
|
||||
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. 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
|
||||
import sys
|
||||
|
||||
import matplotlib
|
||||
|
||||
matplotlib.use("Agg")
|
||||
import matplotlib.pyplot as plt # noqa: E402
|
||||
|
||||
from donnees import charger, heure_image, instant, iso, trouver # noqa: E402
|
||||
|
||||
|
||||
|
||||
def centile(gris, p):
|
||||
"""Centile p (0 à 100) des pixels d'une vignette, sans interpolation."""
|
||||
v = sorted(gris.ravel().tolist())
|
||||
return v[min(int(p / 100 * len(v)), len(v) - 1)]
|
||||
|
||||
|
||||
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", 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 = [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))}.")
|
||||
connues = sorted(h for h in images if h)
|
||||
if not connues:
|
||||
sys.exit(f"Aucune image dans {o.dossier}.")
|
||||
proche = {h: min(connues, key=lambda i: abs(i - h)) for h in heures} # image à l'heure demandée, sinon la plus proche
|
||||
for h in heures:
|
||||
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 = 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 = 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", cadre coupé par le bord de l'image ({larg} × {haut} px)" if coupe else ""))
|
||||
bornes = {}
|
||||
if o.contraste:
|
||||
if o.contraste == "auto":
|
||||
bornes = dict(vmin=min(centile(g, 1) for _, g in coupes.values()), vmax=max(g.max() for _, g in coupes.values()))
|
||||
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)")
|
||||
# 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[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"{'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)
|
||||
ax.set_xlabel(f"centre du cadre {x}, {y}" + (f"\nx, y {cx + max(x - r, 0):.1f}, {cy + max(y - r, 0):.1f}" if o.fixe else ""), fontsize=7)
|
||||
ax.set_xticks([])
|
||||
ax.set_yticks([])
|
||||
station = os.path.basename(os.path.normpath(o.dossier))
|
||||
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)
|
||||
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)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,235 @@
|
||||
"""Journal du matin : des épisodes des détecteurs aux événements, un par famille.
|
||||
|
||||
Un détecteur par famille des étiquettes (labeling/familles.md) : visibility.py, obstruction.py, target_issue.py,
|
||||
thermal_displacement.py, no_data.py, displacement.py. La catégorie d'un événement est sa famille, le champ kind de ses
|
||||
épisodes ; leur label en dit la sorte (Poor visibility, Heat shimmer, Brief obstruction, Slow drift…). Règles :
|
||||
- un saut revenu à la normale (SAUT) qui chevauche un épisode de HOTES (perte de visibilité, passage, turbulence, et en
|
||||
dernier l'effet thermique, s'il touche plusieurs cibles) y est absorbé : il en prend la cause et la famille ; sinon il
|
||||
reste Displacement, sans cause établie, à vérifier sur les images (familles.md, « Un saut puis le retour ») ; un passage
|
||||
(Brief obstruction, un seul instant) n'absorbe que les sauts qui commencent à son instant, pas ceux de plusieurs jours
|
||||
qu'il croise (/detector-learner Displacement, modification 1, S5) ;
|
||||
- une dérive lente ou un saut revenu dont toutes les cibles sont dans un épisode Target issue qui le chevauche y est absorbé
|
||||
(la courbe d'une cible à problème est à ignorer, familles.md) ;
|
||||
- un décalage qui dure, ou trop récent pour savoir (DECALAGES), n'est jamais absorbé ;
|
||||
- une turbulence qui chevauche un décalage n'est pas gardée : un vrai mouvement agite aussi les courbes ;
|
||||
- deux événements de même sorte à moins de MERGE n'en font qu'un.
|
||||
Chaque événement reçoit sa phrase, en anglais (le site) : ce qui s'est passé et quoi en faire, comme le dit la colonne
|
||||
« Pour le client » de familles.md ; la cause n'est dite que si la sorte l'établit, sinon les images la montrent.
|
||||
Pas de fonction detect : le chargeur ne prend pas ce fichier pour un détecteur.
|
||||
Usage : python3 detectors/categories.py <dossier de station> (une ligne par événement : famille, sorte, capteurs)
|
||||
... <dossier> [--du AAAA-MM-JJ] [--au AAAA-MM-JJ] [--tranche 3] [--historique N] (tri en lot : chaque tranche
|
||||
de N jours classée seule, avec les jours d'historique d'avant s'ils existent ; seuls les événements qui touchent
|
||||
la tranche sont montrés ; « rien » pour une tranche calme)
|
||||
"""
|
||||
import functools
|
||||
import importlib.util
|
||||
import inspect
|
||||
import os
|
||||
import sys
|
||||
from datetime import datetime, timedelta, timezone
|
||||
from pathlib import Path
|
||||
|
||||
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "agent-tools"))
|
||||
from donnees import charger, charger_camera, charger_metriques, charger_temperature, iso # noqa: E402
|
||||
|
||||
# Ce qu'un détecteur peut lire de la station en plus des mesures, s'il le déclare dans detect (D-124, D-134) :
|
||||
# temperature [(t, °C)], médiane horaire des composants ; camera [pose] (pan, tilt, rotation, scale, sigma0) ;
|
||||
# metriques {nom: [(t, valeur)]}, toutes les métriques numériques (sensor_CPU_deg_c, sensor_GPU_deg_c, BusVoltage…).
|
||||
CONTEXTE = {"temperature": charger_temperature, "camera": charger_camera, "metriques": charger_metriques}
|
||||
|
||||
|
||||
@functools.lru_cache(maxsize=None)
|
||||
def _contexte(dossier, cle):
|
||||
return CONTEXTE[cle](dossier)
|
||||
|
||||
# Les familles de labeling/familles.md, dans l'ordre des lignes de la frise ; ignore : zone grisée (None : comme le
|
||||
# disent ses épisodes : une perte de visibilité totale, une turbulence forte) ; process : bouton Images, rien, ou Images
|
||||
# et lien vers Diagnosis.
|
||||
CATEGORIES = {
|
||||
"Visibility": {"ignore": None, "process": "images"},
|
||||
"Obstruction": {"ignore": True, "process": "images"},
|
||||
"Target issue": {"ignore": True, "process": "images"},
|
||||
"Thermal displacement": {"ignore": False, "process": "aucun"},
|
||||
"No data": {"ignore": False, "process": "aucun"},
|
||||
"Displacement": {"ignore": False, "process": "verifier"},
|
||||
}
|
||||
SAUT = "Sudden jump, back to normal" # un saut revenu : sa cause, s'il chevauche un hôte ; sinon Displacement
|
||||
DECALAGES = {"Lasting shift", "Jump, not back yet", "Large shift"} # à vérifier : jamais absorbés
|
||||
HOTES = {"Poor visibility", "Brief obstruction", "Heat shimmer", "Thermal expansion", "Thermal contraction",
|
||||
"Camera thermal expansion", "Camera thermal contraction", "Camera thermal movement"} # disent la cause d'un saut revenu qui les chevauche
|
||||
MERGE = timedelta(hours=1) # même sorte à moins d'une heure : un seul événement (règle validée, 2026-10-24)
|
||||
|
||||
|
||||
def detecteurs():
|
||||
"""Modules de detectors/*.py qui ont detect ; un fichier qui ne se charge pas est sauté avec un
|
||||
message."""
|
||||
mods = []
|
||||
for path in sorted(Path(__file__).resolve().parent.glob("*.py")):
|
||||
if path == Path(__file__).resolve():
|
||||
continue
|
||||
try:
|
||||
spec = importlib.util.spec_from_file_location(f"journal_{path.stem}", path)
|
||||
mod = importlib.util.module_from_spec(spec)
|
||||
spec.loader.exec_module(mod)
|
||||
except Exception as e: # noqa: BLE001 (prototype : un détecteur cassé ne bloque pas la page)
|
||||
print(f"Journal : {path.name} sauté ({type(e).__name__}: {e})", file=sys.stderr)
|
||||
continue
|
||||
if hasattr(mod, "detect"):
|
||||
mods.append(mod)
|
||||
return mods
|
||||
|
||||
|
||||
def categorie(ep):
|
||||
return ep["kind"]
|
||||
|
||||
|
||||
def sorte(ep):
|
||||
"""La sorte d'un épisode dans sa famille : les décalages ensemble, l'effet thermique sans « Camera », la perte de
|
||||
visibilité par niveau."""
|
||||
label = "shift" if ep["label"] in DECALAGES else ep["label"].removeprefix("Camera ").capitalize()
|
||||
return ep["kind"], label, ep.get("level")
|
||||
|
||||
|
||||
def thermique(ep):
|
||||
return ep["kind"] == "Thermal displacement"
|
||||
|
||||
|
||||
def overlap(a, b):
|
||||
return a["start"] <= b["end"] and a["end"] >= b["start"] # heures donnees.iso : l'ordre du texte est celui du temps
|
||||
|
||||
|
||||
def targets(n):
|
||||
return "one target" if n == 1 else f"{n} targets"
|
||||
|
||||
|
||||
def phrase(groupe, sensors, references):
|
||||
"""Phrase du journal d'un événement (validées par l'utilisateur le 2026-10-24), d'après la sorte de son épisode
|
||||
principal ; un saut absorbé ajoute qu'il a la même cause."""
|
||||
n, one, ep = len(sensors), len(sensors) == 1, groupe[0]
|
||||
sauts = [e for e in groupe[1:] if e["label"] == SAUT]
|
||||
jumped = len({s for e in sauts for s in e["sensors"]})
|
||||
lasting = len({s for e in groupe if e["label"] in DECALAGES for s in e.get("lasting", [])})
|
||||
refs = ", including the reference targets" if references & set(sensors) else ""
|
||||
camera = ep["label"].startswith("Camera")
|
||||
large = any(e["label"] == "Large shift" for e in groupe)
|
||||
sort = "shift" if ep["label"] in DECALAGES else f"{ep['label']} {ep['level']}" if ep.get("level") else ep["label"]
|
||||
text = {
|
||||
"Poor visibility none": f"The camera could not see {targets(n)} clearly{refs}. "
|
||||
"The curves in this period are not reliable: ignore them.",
|
||||
"Poor visibility reduced": f"The camera saw {targets(n)} less clearly than usual{refs}. "
|
||||
"The data in this period are less precise: use them with care.",
|
||||
"Brief obstruction": f"Something passed in front of {targets(n)} for a single measurement. Ignore this point on the curves.",
|
||||
"Target obscured": f"{', '.join(sensors)} {'was' if one else 'were'} hidden several times while the targets around "
|
||||
f"{'it' if one else 'them'} stayed clear. Ignore {'its curve' if one else 'their curves'} in this period.",
|
||||
"Heat shimmer": "Warm air made the readings shake. The small fast wiggles are not movement.",
|
||||
"expansion": ("The camera support expands in the day heat; the curves are corrected for it."
|
||||
if camera else "The structure expands in the day heat.") + " This daily wave is normal: nothing to do.",
|
||||
"contraction": ("The camera support contracts as it cools down; the curves are corrected for it."
|
||||
if camera else "The structure contracts as it cools down.") + " This daily wave is normal: nothing to do.",
|
||||
SAUT: f"{targets(n).capitalize()} jumped and came back. The cause is not established: look at the images.",
|
||||
"shift": (f"{targets(n).capitalize()}, most of the targets, shifted together: everything moved." if large
|
||||
else f"{targets(n).capitalize()} shifted and {'has' if one else 'have'} not come back yet." if not lasting
|
||||
else f"{targets(n).capitalize()} shifted and stayed shifted." if lasting == n
|
||||
else f"{targets(n).capitalize()} shifted; {lasting} of them stayed shifted.")
|
||||
+ " Check whether the structure moved: look at the images.",
|
||||
}.get(sort.split()[-1] if thermique(ep) else sort, ep["text"]) # No data, Target issue, Slow drift : le texte du détecteur
|
||||
if ep["kind"] == "Target issue":
|
||||
text += f" Ignore {'its curve' if one else 'their curves'} in this period and look at the images of the target."
|
||||
if not jumped:
|
||||
return text
|
||||
return text + (f" The jump of {targets(jumped)} in this period has the same cause." if len(sauts) == 1
|
||||
else f" The jumps of {targets(jumped)} in this period have the same cause.")
|
||||
|
||||
|
||||
def evenement(groupe, references):
|
||||
"""Épisodes d'un même événement, le principal en tête -> événement."""
|
||||
cat, so = categorie(groupe[0]), sorte(groupe[0])
|
||||
c = CATEGORIES.get(cat, {"ignore": None, "process": "aucun"})
|
||||
sensors = [] if any(not e["sensors"] for e in groupe) else list(dict.fromkeys(s for e in groupe for s in e["sensors"]))
|
||||
main = [e for e in groupe if sorte(e) == so] # la durée est celle des épisodes principaux, pas des sauts absorbés
|
||||
return {"start": min(e["start"] for e in main), "end": max(e["end"] for e in main), "category": cat,
|
||||
"label": cat, "text": phrase(groupe, sensors, references),
|
||||
"ignore": c["ignore"] if c["ignore"] is not None else any(e["ignore"] for e in main),
|
||||
"sensors": sensors, "process": c["process"], "episodes": groupe}
|
||||
|
||||
|
||||
def classer(episodes, references=frozenset()):
|
||||
"""Épisodes de tous les détecteurs -> événements triés par début (règles : docstring du module) ; references : les
|
||||
capteurs global_ref, pour la phrase."""
|
||||
eps = sorted(episodes, key=lambda e: e["start"])
|
||||
checks = [e for e in eps if e["label"] in DECALAGES] # un vrai mouvement n'est jamais pris pour de la turbulence
|
||||
eps = [e for e in eps if e["label"] != "Heat shimmer" or not any(overlap(e, c) for c in checks)]
|
||||
# la vague thermique n'absorbe qu'en dernier (un saut d'un passage ou d'une pluie va à eux), et que les sauts de
|
||||
# plusieurs cibles : la vague les fait bouger ensemble, une cible seule qui saute n'est pas la vague (C2 de E-003)
|
||||
hosts = sorted((e for e in eps if e["label"] in HOTES), key=thermique)
|
||||
host = {id(e): next((h for h in hosts if overlap(e, h) and (len(e["sensors"]) > 1 or not thermique(h))
|
||||
and (h["label"] != "Brief obstruction" or e["start"] == h["start"])), None)
|
||||
for e in eps if e["label"] == SAUT}
|
||||
# une dérive ou un saut revenu dont toutes les cibles sont dans un épisode Target issue qui le chevauche : sa courbe
|
||||
# est à ignorer, il en prend la famille (/detector-learner Displacement, modification 1, S6)
|
||||
host.update({id(e): h for e in eps if e["label"] in (SAUT, "Slow drift") and not host.get(id(e))
|
||||
and (h := next((h for h in eps if h["kind"] == "Target issue" and overlap(e, h)
|
||||
and set(e["sensors"]) <= set(h["sensors"])), None))})
|
||||
groupes = {id(e): [e] for e in eps if not host.get(id(e))}
|
||||
for e in eps:
|
||||
if host.get(id(e)):
|
||||
groupes[id(host[id(e)])].append(e)
|
||||
merged = []
|
||||
for g in groupes.values():
|
||||
prev = next((m for m in reversed(merged) if sorte(m[0]) == sorte(g[0])), None)
|
||||
end = max((e["end"] for e in prev if sorte(e) == sorte(g[0])), default=None) if prev else None
|
||||
if end and datetime.fromisoformat(g[0]["start"]) - datetime.fromisoformat(end) < MERGE:
|
||||
prev += g
|
||||
else:
|
||||
merged.append(g)
|
||||
return sorted((evenement(g, references) for g in merged), key=lambda v: v["start"])
|
||||
|
||||
|
||||
def evenements(mesures, fin=None, dossier=None):
|
||||
"""Mesures (donnees.charger) -> événements de tous les détecteurs : ce que la page reçoit dans D.journal. Un détecteur
|
||||
reçoit en plus ce que sa fonction detect déclare : fin, la fin de la fenêtre lue (tri en lot), pour un trou qui la
|
||||
touche ; une clé de CONTEXTE, lue dans le dossier de la station (une fois par dossier), vide sans dossier."""
|
||||
episodes = []
|
||||
for mod in detecteurs():
|
||||
try:
|
||||
params = inspect.signature(mod.detect).parameters
|
||||
kw = {k: _contexte(dossier, k) if dossier else {} if k == "metriques" else [] for k in CONTEXTE if k in params}
|
||||
if "fin" in params:
|
||||
kw["fin"] = fin
|
||||
episodes += mod.detect(mesures, **kw)
|
||||
except Exception as e: # noqa: BLE001
|
||||
print(f"Journal : {mod.__name__} sauté ({type(e).__name__}: {e})", file=sys.stderr)
|
||||
return classer(episodes, {s for s, ms in mesures.items() if ms[0]["pattern_type"] == "global_ref"})
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
import argparse
|
||||
p = argparse.ArgumentParser(description="Une ligne par événement ; --tranche : chaque tranche classée seule.")
|
||||
p.add_argument("dossier")
|
||||
p.add_argument("--du", help="premier jour UTC, AAAA-MM-JJ (défaut : début des données)")
|
||||
p.add_argument("--au", help="dernier jour UTC exclu, AAAA-MM-JJ (défaut : fin des données)")
|
||||
p.add_argument("--tranche", type=int, default=0, help="jours par tranche (défaut : un seul passage)")
|
||||
# sans historique, une tranche qui commence juste avant un vrai saut le prend pour un saut revenu (PR17 à NORDEND,
|
||||
# le 08/10 à 02:30 : absorbé dans la buée) ; 3 jours le rendent ; règle de l'utilisateur (2026-10-24) : 3 jours
|
||||
# d'historique par défaut, dans la boucle comme dans la vraie application
|
||||
p.add_argument("--historique", type=int, default=3, help="jours de mesures d'avant donnés aux détecteurs (défaut 3)")
|
||||
a = p.parse_args()
|
||||
mesures = charger(a.dossier)
|
||||
ts = [m["t"] for ms in mesures.values() for m in ms]
|
||||
jour = lambda d: datetime.strptime(d[:10], "%Y-%m-%d").replace(tzinfo=timezone.utc) # noqa: E731
|
||||
debut = jour(a.du) if a.du else min(ts).replace(hour=0, minute=0, second=0, microsecond=0)
|
||||
fin = jour(a.au) if a.au else max(ts) + timedelta(seconds=1)
|
||||
t = debut
|
||||
while t < fin:
|
||||
b = min(t + timedelta(days=a.tranche), fin) if a.tranche else fin
|
||||
h = t - timedelta(days=a.historique)
|
||||
tranche = {s: k for s, ms in mesures.items() if (k := [m for m in ms if h <= m["t"] < b])}
|
||||
evs = [v for v in evenements(tranche, b, a.dossier) if v["end"] >= iso(t)] if tranche else []
|
||||
if a.tranche:
|
||||
print(f"== {iso(t)} → {iso(b)} : {len(evs) or 'rien'}")
|
||||
for v in evs:
|
||||
print(v["start"], "→", v["end"], f"{v['category']:<20}", "grisé" if v["ignore"] else "gardé",
|
||||
f"| {v['episodes'][0]['label']}", # la sorte : la règle du détecteur de la famille
|
||||
f"| {len(v['sensors']) or 'tous les'} capteurs", "| absorbés :", ", ".join(
|
||||
f"{e['label']} {e['start'][5:16]}" for e in v["episodes"][1:]) or "—")
|
||||
t = b
|
||||
@@ -0,0 +1,355 @@
|
||||
"""Journal du matin : le détecteur de la famille Displacement (labeling/familles.md) : les sauts brutaux de corr_x /
|
||||
corr_y (px) de chaque cible, à la cadence native de l'export « advanced », et la dérive lente (en fin de fichier). Une
|
||||
cible qui bascule (« Target flipping ») est de la famille Target issue : episodes() la rend, detect() la laisse à
|
||||
target_issue.py.
|
||||
|
||||
1. Bruit de la série = médiane des écarts d'une mesure à la suivante ; saut = mesure à K bruits ou plus du niveau
|
||||
d'avant (médiane des BASE mesures précédentes) ; les BASE premières mesures, faute de niveau d'avant, face au niveau
|
||||
d'après (médiane des BASE suivantes), un écart y est un saut revenu aussitôt (point 12 du plan, 2026-10-24).
|
||||
2. Revenu (une heure de mesures de suite à moins de la moitié du saut : BASE à 15 min, une seule à 4 h, boucle
|
||||
/detector-learner MICHIGAN, modification 1) en moins d'un jour, ou un jour après de retour à sa place
|
||||
habituelle (premier jour de l'export) ou du jour d'avant : « Sudden jump, back to normal », grisé ; sa cause n'est pas
|
||||
établie ici (categories.py lui donne celle de la catégorie qui le chevauche, sinon : à vérifier sur les images).
|
||||
3. Sinon « Lasting shift », jamais grisé (peut-être un vrai mouvement) ; moins d'un jour de recul :
|
||||
« Jump, not back yet », pas grisé non plus.
|
||||
4. Les sauts qui se suivent à moins d'une heure, toutes cibles confondues, font un seul épisode (mode commun) ;
|
||||
une seule cible durable (ou trop récente) suffit à ne pas griser l'épisode.
|
||||
5. Références globales exclues ; mesures rejetées (corr vides) sautées.
|
||||
6. Pic commun (lot 01 de la boucle NORDEND, 2026-10-26) : au même instant, au moins PIC_MIN cibles s'écartent d'au moins
|
||||
K_PIC bruits de leurs deux mesures voisines, du même côté (toute l'image secouée un pas) : un saut revenu pour chacune,
|
||||
même sous K. Il entre dans les épisodes du point 4 (près d'un saut durable, il ne grise rien).
|
||||
7. Boucle CLARIDEN, lot 01 (2026-10-26) : un saut jamais revenu ne clôt plus la lecture de la série, son nouveau niveau
|
||||
devient le niveau d'avant ; un épisode qui n'est pas grisé finit à son dernier saut, pas aux retours (ils ne sont
|
||||
plus à griser) ; une cible qui bascule (REPET sauts revenus ou plus, chacun à moins d'un jour du précédent) fait un
|
||||
épisode « back to normal » à elle seule, de la première à la dernière bascule, hors des épisodes communs.
|
||||
|
||||
Résultats (2026-10-23, K = 20) :
|
||||
- E-001 PS des Coudres : rien (vérité : rien côté sauts).
|
||||
- E-002 NORDEND juillet : grisés 28/07 21:00 → 29/07 10:45 (18 cibles) et 30/07 13:30 → 31/07 01:15 (18) ; toile revenue
|
||||
31/07 20:30 : « not back yet » (13 cibles, 1 h avant la fin des données).
|
||||
- E-003 WILDSTRUBEL : un saut d'un pas grisé, 04/09 06:45 (le C2 de la fiche) ; les autres sont sur des références
|
||||
ou rejetés.
|
||||
- E-004 CLARIDEN : « Lasting shift » 19/09 06:10, 18 cibles, non grisé ; faux positif probable : une cible agitée seule,
|
||||
18/09 15:40, non grisé ; la dérive de nuit de corr_x (lente) n'est pas un saut.
|
||||
- E-005 NIEDERHORN : train du 01/10 12:00 grisé (1 cible sur 3 : les deux autres à 17 et 19 bruits) ; train du
|
||||
30/09 22:00 vu depuis le 2026-10-24 (2 cibles, première mesure de l'export) ; feuilles, pluie : rien (error_value, pas
|
||||
des sauts). Les trains sont de toute façon attrapés par visibilite (« Passing obstacle ») et le classement y absorbe
|
||||
leurs sauts : ne pas baisser K pour eux (point 12 du plan).
|
||||
- NORDEND octobre : PR17 seule en « Lasting shift » le 08/10 02:30 ; cinq épisodes communs grisés (07/10 19:45,
|
||||
08/10 07:15, 09/10 08:45 et 21:15, 14/10 05:15 : 4 à 15 cibles, aller-retour en moins de 5 h) ; PR15 08/10 04:45,
|
||||
un instant grisé.
|
||||
Pic commun (K_PIC = 6, PIC_MIN = 3, 2026-10-26) : NORDEND, lot du 01 au 04/09 : secousses du 03/09 13:30 (3 cibles) et
|
||||
16:45 (4) grisées, aussi 01/09 15:45 → 16:00 et 02/09 09:45, mêmes secousses d'un pas pendant la bascule de la caméra ;
|
||||
NORDEND octobre : un pic de 3 cibles le 13/10 12:30, et PR17 (08/10 02:30) groupé avec le pic de 02:15, « 3 targets,
|
||||
1 stayed shifted », toujours non grisé ; E-002, E-005 : pics absorbés par la toile et les trains ; E-004 : les pics du
|
||||
mouvement (19/09 06:30, 06:50) restent dans le « Lasting shift » ; E-001, E-003 : rien.
|
||||
Point 7 (REPET = 5, 2026-10-26) : CLARIDEN, lot du 18 au 22/09 : PR_BG grisé 19/09 06:40 → 21/09 23:20 (28 bascules de
|
||||
12 px ; les autres cibles en font 3 au plus) ; le saut seul de D-303-A le 18/09 15:40 vu ; le « Lasting shift » du
|
||||
matin garde 05:40 → 10:30 ; E-001 à E-003, E-005 à E-008 : inchangés.
|
||||
Catégories du terrain (D-074, 2026-10-27) : la cible qui bascule pendant BASCULE au moins, avec SEULES cibles au plus en même temps, devient « Target flipping » (Target issue, plus un
|
||||
saut bref) ; un saut durable d'au moins GROS des cibles, « Large shift » (gros saut : tout a bougé), toujours à vérifier.
|
||||
8. Saut sous K qui reste (boucle NIEDERHORN, lot 01, 2026-10-27 ; K_DURABLE = 7, PALIER = 8) : un saut d'au moins
|
||||
K_DURABLE bruits compte s'il est durable au point 3 et que la médiane du jour d'après s'écarte de celle du jour d'avant,
|
||||
du côté du saut, d'au moins PALIER fois la variation ordinaire du niveau d'un jour UTC au suivant (médiane des écarts
|
||||
entre niveaux journaliers) ; sinon il est ignoré (ni revenu ni trop récent : seuls les sauts de K bruits ou plus le
|
||||
sont). NIEDERHORN : e09, corr_y −0,19 px le 02/10 20:00 (8 bruits, 13 variations ordinaires), « Lasting shift », avec
|
||||
e10 au même instant (corr_x +0,22 px, resté) ; E-001 : rien (cibles saines à 6 variations ordinaires au plus) ;
|
||||
E-004 : le mouvement du 19/09 couvre deux fois plus de mesures à vérifier ; les autres events inchangés.
|
||||
"""
|
||||
import statistics
|
||||
import sys
|
||||
from datetime import timedelta
|
||||
from pathlib import Path
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "agent-tools"))
|
||||
import donnees # noqa: E402
|
||||
|
||||
K = 20 # provisoire, réglé sur E-001 : à 15, deux cibles saines y sont grisées (17 et 18 bruits) ; les trains de
|
||||
# E-005 (17 et 19 bruits) sont attrapés par visibilite : ne pas baisser K
|
||||
K_DURABLE = 7 # provisoire : sous K, un saut qui reste compte dès K_DURABLE bruits (boucle NIEDERHORN, lot 01 : e09,
|
||||
# corr_y −0,18 px d'un coup, 8 bruits, resté 5 jours)
|
||||
PALIER = 8 # provisoire : ... s'il reste : médiane du jour d'après, du côté du saut, à PALIER fois la variation
|
||||
# ordinaire du niveau d'un jour au suivant de celle du jour d'avant (e09 : 13 ; E-001, cibles saines : 6 au plus)
|
||||
K_PIC = 6 # provisoire : pic d'un pas commun à plusieurs cibles (secousses de NORDEND, 6 à 11 bruits, lot 01 de la boucle)
|
||||
PIC_MIN = 3 # provisoire : cibles qui piquent au même pas pour un pic commun (une ou deux : bruit ordinaire)
|
||||
BASE = 4 # mesures qui font le niveau d'avant (1 h à 15 min)
|
||||
GAP = timedelta(hours=1) # deux sauts à moins d'une heure, toutes cibles confondues : un seul épisode
|
||||
BACK_H = 24 # provisoire : retour en moins d'un jour = artefact (E-002 : paliers jusqu'à 11 h 30)
|
||||
BASCULE = timedelta(hours=6) # provisoire : une cible à problème bascule des heures (PR_BG : 2,5 jours) ; en moins,
|
||||
# c'est un matin agité (E-009 : C8 et C13, 5 bascules en 1 h 20 pendant le mouvement), un saut bref
|
||||
SEULES = 2 # provisoire : cibles qui basculent en même temps, au plus (FLORIDA : les deux collées ; E-002, toile sur les
|
||||
# références : 15 à la fois)
|
||||
GROS = 0.5 # provisoire : part des cibles d'un saut durable pour un gros saut (E-004 : presque toutes)
|
||||
REPET = 5 # provisoire : sauts revenus d'une même cible, à moins d'un jour l'un de l'autre, qui en font une cible qui
|
||||
# bascule (PR_BG de CLARIDEN, boucle lot 01 : une trentaine en 2,5 jours)
|
||||
|
||||
|
||||
def _sauts(t, v):
|
||||
"""Une série (instants, valeurs) -> [(i début, i fin, état)], état 'back', 'lasting' ou 'recent'."""
|
||||
day = timedelta(hours=BACK_H)
|
||||
noise = statistics.median(abs(y - x) for x, y in zip(v, v[1:]))
|
||||
pas = statistics.median(b - a for a, b in zip(t, t[1:])) # cadence de la série
|
||||
retour = max(1, min(BASE, round(timedelta(hours=1) / pas))) # mesures d'une heure (BASE à 15 min, une à 4 h)
|
||||
# ponytail: place habituelle = premier jour de l'export, faux s'il commence dans un artefact
|
||||
ref = statistics.median(x for x, u in zip(v, t) if u < t[0] + day)
|
||||
lv = {} # niveau de chaque jour UTC ; sa variation ordinaire d'un jour au suivant juge un saut sous K
|
||||
for x, u in zip(v, t):
|
||||
lv.setdefault(u.date(), []).append(x)
|
||||
lv = [statistics.median(x) for _, x in sorted(lv.items())]
|
||||
ordinaire = statistics.median(abs(b - a) for a, b in zip(lv, lv[1:])) if len(lv) > 2 else 0
|
||||
# les BASE premières mesures, faute de niveau d'avant, face au niveau d'après : un écart y est revenu aussitôt
|
||||
out = [(k, k, "back") for k in range(min(BASE, len(v) - BASE))
|
||||
if noise and abs(v[k] - statistics.median(v[k + 1:k + 1 + BASE])) >= K * noise]
|
||||
i = BASE
|
||||
while noise and i < len(v):
|
||||
base = statistics.median(v[i - BASE:i])
|
||||
if abs(v[i] - base) < K_DURABLE * noise:
|
||||
i += 1
|
||||
continue
|
||||
tol = abs(v[i] - base) / 2 # revenu : une heure de mesures de suite à moins de la moitié du saut du niveau d'avant
|
||||
j = next((k for k in range(i + 1, len(v)) if all(abs(x - base) < tol for x in v[k:k + retour])), len(v))
|
||||
before = statistics.median([x for x, u in zip(v, t) if t[i] - day <= u < t[i]] or [base])
|
||||
after = statistics.median(x for x, u in zip(v, t) if t[i] <= u < t[i] + day)
|
||||
if j < len(v) and t[j] - t[i] <= day:
|
||||
state = "back"
|
||||
elif abs(after - ref) < tol or abs(after - before) < tol: # le jour d'après, la cible est à sa place
|
||||
state, j = "back", i + 1 # habituelle, ou là où elle était le jour d'avant : le saut finissait un creux
|
||||
else:
|
||||
state = "lasting" if t[-1] - t[i] >= day else "recent" # moins d'un jour de recul : on ne sait pas encore
|
||||
if abs(v[i] - base) < K * noise and (state != "lasting" or (after - before) * (v[i] - base) < 0
|
||||
or not ordinaire or abs(after - before) < PALIER * ordinaire):
|
||||
i += 1 # sous K, seul compte un saut qui reste : le jour d'après loin du jour d'avant, de son côté
|
||||
continue
|
||||
out.append((i, j - 1, state))
|
||||
# niveau d'avant refait après le retour ; jamais revenu : le nouveau niveau devient celui d'avant, la suite
|
||||
# reste lue (PR_BG de CLARIDEN, lot 01 : ses bascules après le saut de 10:30 étaient invisibles)
|
||||
i = (j if j < len(v) else i) + BASE
|
||||
return out
|
||||
|
||||
|
||||
def _pics(t, v):
|
||||
"""Instants où la mesure s'écarte d'au moins K_PIC bruits de ses deux voisines, du même côté (pic d'un pas)."""
|
||||
noise = statistics.median(abs(y - x) for x, y in zip(v, v[1:]))
|
||||
return [t[i] for i in range(1, len(v) - 1) if noise and (v[i] - v[i - 1]) * (v[i] - v[i + 1]) > 0
|
||||
and min(abs(v[i] - v[i - 1]), abs(v[i] - v[i + 1])) >= K_PIC * noise]
|
||||
|
||||
|
||||
def episodes(mesures):
|
||||
"""{capteur: [mesure]} (donnees.charger) -> épisodes des sauts, triés par début : Displacement, et Target issue pour
|
||||
une cible qui bascule."""
|
||||
found = [] # (début, fin, état, capteur)
|
||||
pics = {} # instant -> cibles qui y font un pic d'un pas
|
||||
for name, ms in mesures.items():
|
||||
if donnees.est_reference(ms):
|
||||
continue
|
||||
for axe in ("corr_x", "corr_y"):
|
||||
kept = [m for m in ms if m[axe] is not None]
|
||||
if len(kept) <= BASE:
|
||||
continue
|
||||
t, v = [m["t"] for m in kept], [m[axe] for m in kept]
|
||||
# un saut qui n'est pas revenu finit avec lui-même, pas avec les données (sa barre cachait les autres)
|
||||
found += [(t[a], t[b] if state == "back" else t[a], state, name) for a, b, state in _sauts(t, v)]
|
||||
for u in _pics(t, v):
|
||||
pics.setdefault(u, set()).add(name)
|
||||
found += [(u, u, "back", s) for u, cs in pics.items() if len(cs) >= PIC_MIN for s in cs] # pic commun : revenu
|
||||
seuls = _bascules(found) # une cible qui saute et revient sans cesse : un épisode à elle seule, hors des communs
|
||||
found = [f for f in found if f[2] != "back" or not any(f[3] in g["sensors"] and g["start"] <= f[0] <= g["end"]
|
||||
for g in seuls)]
|
||||
groups = [] # un saut qui n'est pas revenu ne compte que par son instant : sa fin est souvent celle des données
|
||||
for s, e, state, name in sorted(found):
|
||||
if groups and s <= groups[-1]["until"] + GAP:
|
||||
g = groups[-1]
|
||||
else:
|
||||
g = {"start": s, "end": e, "until": s, "last": s, "sensors": {}}
|
||||
groups.append(g)
|
||||
g["end"], g["until"], g["last"] = max(g["end"], e), max(g["until"], e if state == "back" else s), s
|
||||
g["sensors"].setdefault(name, set()).add(state)
|
||||
longues = [g for g in seuls if g["flip"]] # bascules de nombreuses cibles en même temps : la compensation, pas une
|
||||
for g in longues: # cible à problème
|
||||
if sum(h["start"] <= g["end"] and h["end"] >= g["start"] for h in longues) > SEULES:
|
||||
g["flip"] = 0
|
||||
total = sum(not donnees.est_reference(ms) for ms in mesures.values())
|
||||
return sorted((_episode(g, total) for g in groups + seuls), key=lambda ep: ep["start"])
|
||||
|
||||
|
||||
def _bascules(found):
|
||||
"""Sauts revenus d'une même cible, chacun à moins de BACK_H du précédent : REPET ou plus -> un groupe, de la
|
||||
première à la dernière bascule."""
|
||||
day, seuls = timedelta(hours=BACK_H), []
|
||||
for name in {f[3] for f in found}:
|
||||
chain = [] # (début, fin) ; corr_x et corr_y en double : comptés par instant
|
||||
for s, e in sorted({(s, e) for s, e, state, n in found if n == name and state == "back"}) + [(None, None)]:
|
||||
if chain and s is not None and s <= max(c[1] for c in chain) + day:
|
||||
chain.append((s, e))
|
||||
continue
|
||||
if len({c[0] for c in chain}) >= REPET:
|
||||
seuls.append({"start": chain[0][0], "end": max(c[1] for c in chain), "sensors": {name: {"back"}},
|
||||
"flip": len({c[0] for c in chain}) if max(c[1] for c in chain) - chain[0][0] >= BASCULE else 0})
|
||||
chain = [(s, e)]
|
||||
return seuls
|
||||
|
||||
|
||||
def _episode(g, total):
|
||||
"""Un groupe -> épisode du journal ; un seul saut durable (ou trop récent) suffit à ne pas griser ; une cible qui
|
||||
bascule : « Target flipping » (Target issue, D-074) ; un saut durable de GROS cibles ou plus : « Large shift »
|
||||
(le gros saut, sous-groupe de « À vérifier »)."""
|
||||
n = len(g["sensors"])
|
||||
lasting = sum("lasting" in st for st in g["sensors"].values())
|
||||
recent = any("recent" in st for st in g["sensors"].values())
|
||||
who = "One target" if n == 1 else f"{n} targets together (a single event)"
|
||||
if g.get("flip"):
|
||||
name = next(iter(g["sensors"]))
|
||||
return {"start": donnees.iso(g["start"]), "end": donnees.iso(g["end"]), "kind": "Target issue", "label": "Target flipping",
|
||||
"text": f"{name} jumped and came back {g['flip']} times: its tracking is not reliable, look at the images "
|
||||
"of the target.", "ignore": True, "sensors": [name], "lasting": []}
|
||||
if lasting and n >= GROS * total:
|
||||
label = "Large shift"
|
||||
text = f"{n} targets jumped together and {lasting} of them stayed shifted: everything moved, please check it."
|
||||
elif lasting:
|
||||
label = "Lasting shift"
|
||||
some = "" if lasting == n else f", {lasting} of them stayed shifted for more than a day"
|
||||
text = (f"{who} jumped{some}" if some else f"{who} jumped and stayed shifted for more than a day") + \
|
||||
": this may be a real movement, please check it."
|
||||
elif recent:
|
||||
label = "Jump, not back yet"
|
||||
text = f"{who} jumped less than a day before the last measurement and has not come back yet: check again later."
|
||||
else:
|
||||
label = "Sudden jump, back to normal"
|
||||
text = f"{who} jumped and came back within a day: the cause is not established, look at the images."
|
||||
end = g["last"] if lasting or recent else g["end"] # pas grisé : le dernier saut, pas les retours
|
||||
return {"start": donnees.iso(g["start"]), "end": donnees.iso(end), "kind": "Displacement", "label": label,
|
||||
"text": text, "ignore": not lasting and not recent, "sensors": sorted(g["sensors"]),
|
||||
"lasting": sorted(s for s, st in g["sensors"].items() if "lasting" in st)} # restées décalées (phrase du journal)
|
||||
|
||||
|
||||
def detect(mesures):
|
||||
return sorted([e for e in episodes(mesures) if e["kind"] == "Displacement"] + derive(mesures), key=lambda ep: ep["start"])
|
||||
|
||||
|
||||
# --- Dérive lente ---------------------------------------------------------------------------------------------------
|
||||
# Dérive lente : une cible qui bouge peu à peu, jour après jour.
|
||||
#
|
||||
# Reprend la tendance de l'onglet Displacements (D-055, explore.find_trend) sur l'export « advanced » (corr_x, corr_y, px),
|
||||
# pour que la boucle puisse l'entraîner comme les autres détecteurs. Méthode, par cible (hors références globales) et par
|
||||
# axe (seuils provisoires, ceux de D-055) :
|
||||
# 1. Niveau du jour : médiane des mesures de chaque jour UTC d'au moins HEURES heures mesurées sur 24, en part des heures
|
||||
# que la station mesure (boucle /detector-learner MICHIGAN, modification 1 : à une mesure toutes les 4 h, 5 des 6
|
||||
# heures ; avant, aucun jour ne comptait) ; au moins JOURS jours.
|
||||
# 2. Pente de Theil-Sen et tau de Kendall des niveaux journaliers ; amplitude du jour : écart entre ses déciles 9 et 1.
|
||||
# 3. Dérive : |pente| × durée ≥ TAILLE fois l'amplitude médiane du jour, |tau| ≥ REGULIER, et aucun pas d'un jour au
|
||||
# suivant de plus de la moitié de la dérive (un saut qui dure n'est pas une dérive : le détecteur sauts le prend).
|
||||
# 4. Un épisode par cible (un axe suffit), de la première mesure du premier jour à la dernière du dernier ; pas grisé.
|
||||
# 4 bis. Par morceaux (/detector-learner Displacement, modification 1, S1) : une cible sans dérive sur toute la fenêtre
|
||||
# peut dériver quelques jours, puis se poser ou repartir en arrière. Sur chaque suite d'au moins JOURS jours retenus,
|
||||
# dérive = niveau du dernier jour moins celui du premier, au moins MORCEAU amplitudes du jour (médiane de la série),
|
||||
# |tau| ≥ REGULIER du même signe, aucun pas d'un jour retenu au suivant de plus de la moitié de la dérive ; les
|
||||
# morceaux pris de la plus grande dérive à la plus petite, sans se chevaucher (ils peuvent partager le jour où le
|
||||
# niveau tourne) : chacun va d'un extrême du niveau à l'autre, un épisode par morceau et par axe. À MORCEAU = 1, les
|
||||
# cycles thermiques de quelques jours et le bruit des niveaux passent (JUNGFRAU, NORDEND) : 3,5 garde les rangées de
|
||||
# CLARIDEN (3,8 à 8,3 amplitudes), écarte JUNGFRAU (3,1 au plus). Les morceaux ne remplacent pas l'étape 3 : à leur
|
||||
# place, la fin des dérives de MICHIGAN et ce que couvraient les tendances de WILDSTRUBEL étaient perdus.
|
||||
# Un morceau ne franchit pas un trou : deux jours retenus qui se suivent sont à TROU jours au plus l'un de l'autre
|
||||
# (modification 2, remarque 1 du contrôle : l'écart d'un niveau à travers trois jours sans mesure est un pas, pas une
|
||||
# pente ; il faisait des morceaux de toute la fenêtre, CLARIDEN 09-28 → 11-01). Un jour manquant ne coupe pas.
|
||||
# 5. Dérive de la caméra (même modification) : au moins GROS des cibles dérivent du même côté sur corr_x ou corr_y, et au
|
||||
# moins GROS des capteurs, références comprises, sur leurs positions brutes x ou y : seuls les morceaux du point 4 bis
|
||||
# sont signalés, pas la tendance de toute la fenêtre (/detector-learner Displacement, modification 1, S2 : la caméra
|
||||
# mal compensée qui dérive, NEBRASKA, est un Displacement pour les étiquettes ; avant, rien n'était signalé). Les
|
||||
# cibles d'un pont qui suivent la saison (JUNGFRAU, étiquetées Thermal displacement jour après jour) passent l'étape 3
|
||||
# mais pas MORCEAU ; NEBRASKA les deux. BREITHORN (5 capteurs sur 16 en x comme en y) et MICHIGAN ne sont pas
|
||||
# concernées.
|
||||
HEURES = 20 # un jour compte s'il a au moins 20 heures mesurées sur 24 (comme D-055), en part des heures mesurées
|
||||
JOURS = 5 # jours au minimum pour une tendance (TREND_DAYS de D-055)
|
||||
TAILLE = 1.0 # dérive ≥ TAILLE amplitudes journalières (TREND_SIZE de D-055)
|
||||
REGULIER = 0.6 # |tau de Kendall| des niveaux journaliers (TREND_STEADY de D-055)
|
||||
MORCEAU = 3.5 # dérive par morceaux ≥ MORCEAU amplitudes journalières (point 4 bis)
|
||||
TROU = 2 # un morceau ne passe pas d'un jour retenu au suivant à plus de TROU jours (point 4 bis)
|
||||
|
||||
|
||||
def _decile(vs, q):
|
||||
vs = sorted(vs)
|
||||
return vs[min(len(vs) - 1, int(q * len(vs)))]
|
||||
|
||||
|
||||
def _jours(ms, col):
|
||||
"""-> {jour UTC: ses mesures}, les jours retenus (point 1)."""
|
||||
jours = {}
|
||||
for m in ms:
|
||||
if m[col] is not None:
|
||||
jours.setdefault(m["t"].date(), []).append(m)
|
||||
creneaux = len({m["t"].hour for js in jours.values() for m in js}) # heures que la station mesure (6 à 4 h de pas)
|
||||
return {d: js for d, js in jours.items() if len({m["t"].hour for m in js}) >= HEURES / 24 * creneaux}
|
||||
|
||||
|
||||
def _derive(ms, col):
|
||||
"""-> (dérive en px, jours, premier instant, dernier) ou None."""
|
||||
jours = _jours(ms, col)
|
||||
if len(jours) < JOURS:
|
||||
return None
|
||||
niv = sorted((d.toordinal(), statistics.median(m[col] for m in js)) for d, js in jours.items())
|
||||
paires = [(a, b) for k, a in enumerate(niv) for b in niv[k + 1:]]
|
||||
pente = statistics.median((b[1] - a[1]) / (b[0] - a[0]) for a, b in paires)
|
||||
tau = sum((b[1] > a[1]) - (b[1] < a[1]) for a, b in paires) / len(paires)
|
||||
derive = pente * (niv[-1][0] - niv[0][0])
|
||||
ampl = statistics.median(_decile([m[col] for m in js], 0.9) - _decile([m[col] for m in js], 0.1) for js in jours.values())
|
||||
pas = max(abs(b[1] - a[1]) for a, b in zip(niv, niv[1:]))
|
||||
if abs(derive) < TAILLE * ampl or abs(tau) < REGULIER or pas > abs(derive) / 2:
|
||||
return None
|
||||
d0, d1 = min(jours), max(jours)
|
||||
return derive, len(jours), min(m["t"] for m in jours[d0]), max(m["t"] for m in jours[d1])
|
||||
|
||||
|
||||
def _morceaux(ms, col):
|
||||
"""-> [(dérive en px, jours, premier instant, dernier)] : les morceaux de dérive (point 4 bis)."""
|
||||
jours = _jours(ms, col)
|
||||
if len(jours) < JOURS:
|
||||
return []
|
||||
ds = sorted(jours)
|
||||
niv = [statistics.median(m[col] for m in jours[d]) for d in ds]
|
||||
ampl = statistics.median(_decile([m[col] for m in js], 0.9) - _decile([m[col] for m in js], 0.1) for js in jours.values())
|
||||
morceaux = [] # (dérive, i, j)
|
||||
for i in range(len(ds)):
|
||||
signes = pas = 0
|
||||
for j in range(i + 1, len(ds)):
|
||||
if (ds[j] - ds[j - 1]).days > TROU:
|
||||
break # un écart à travers un trou est un pas (le détecteur des sauts le prend), pas une pente
|
||||
signes += sum((niv[j] > niv[k]) - (niv[j] < niv[k]) for k in range(i, j)) # tau de Kendall, pas à pas
|
||||
pas = max(pas, abs(niv[j] - niv[j - 1]))
|
||||
n, d = j - i + 1, niv[j] - niv[i]
|
||||
if n >= JOURS and d and abs(d) >= MORCEAU * ampl and pas <= abs(d) / 2 \
|
||||
and signes * (1 if d > 0 else -1) >= REGULIER * n * (n - 1) / 2:
|
||||
morceaux.append((d, i, j))
|
||||
pris = []
|
||||
for d, i, j in sorted(morceaux, key=lambda x: (-abs(x[0]), x[2] - x[1])):
|
||||
if all(j <= a or i >= b for _, a, b in pris):
|
||||
pris.append((d, i, j))
|
||||
return [(d, j - i + 1, min(m["t"] for m in jours[ds[i]]), max(m["t"] for m in jours[ds[j]])) for d, i, j in pris]
|
||||
|
||||
|
||||
def _commune(mesures, cols):
|
||||
"""Au moins GROS des capteurs dérivent du même côté sur un même axe de cols."""
|
||||
for col in cols:
|
||||
signes = [x[0] > 0 for ms in mesures.values() if (x := _derive(ms, col))]
|
||||
if max(signes.count(True), signes.count(False)) >= GROS * len(mesures):
|
||||
return True
|
||||
return False
|
||||
|
||||
|
||||
def derive(mesures):
|
||||
cibles = {s: ms for s, ms in mesures.items() if not donnees.est_reference(ms)}
|
||||
camera = _commune(cibles, ("corr_x", "corr_y")) and _commune(mesures, ("x", "y")) # point 5 : morceaux seuls
|
||||
out = []
|
||||
for s, ms in sorted(mesures.items()):
|
||||
if donnees.est_reference(ms):
|
||||
continue
|
||||
r = [] if camera else [x for col in ("corr_x", "corr_y") if (x := _derive(ms, col))]
|
||||
r = [max(r, key=lambda x: abs(x[0]))] if r else [x for col in ("corr_x", "corr_y") for x in _morceaux(ms, col)]
|
||||
out += [{"start": donnees.iso(a), "end": donnees.iso(b), "kind": "Displacement", "label": "Slow drift",
|
||||
"text": f"{s} drifts slowly and steadily: {derive:+.2f} px in {n} days. Keep watching it.",
|
||||
"ignore": False, "sensors": [s]} for derive, n, a, b in r]
|
||||
return out
|
||||
|
||||
if __name__ == "__main__":
|
||||
for ep in detect(donnees.charger(sys.argv[1])):
|
||||
print(ep["start"], ep["end"], "ignore" if ep["ignore"] else "KEEP ", ep["label"], "|", len(ep["sensors"]),
|
||||
",".join(ep["sensors"][:6]), "|", ep["text"])
|
||||
@@ -0,0 +1,43 @@
|
||||
"""Journal du matin : le détecteur de la famille No data (labeling/familles.md) : moments sans mesure (cadence de l'export « advanced » rompue).
|
||||
|
||||
Cadence : écart médian entre deux instants de mesure, tous capteurs confondus. Un trou : plus de 2 pas manquants entre
|
||||
deux mesures (écart > 3 cadences) ; l'épisode va de la dernière mesure à la suivante. Fin de la fenêtre lue (fin, si
|
||||
l'appelant la donne : le tri en lot de categories.py) : la même règle entre la dernière mesure et fin, l'épisode allant
|
||||
jusqu'à fin (boucle CLARIDEN, lot 01 : 44 h sans mesure jusqu'à la fin du lot, non signalées). Pas de mesure dans
|
||||
l'export ne veut pas dire station arrêtée (CLAUDE.md) : le texte dit seulement que l'export n'a rien.
|
||||
Usage : python3 detectors/no_data.py <dossier de station> (affiche les épisodes)
|
||||
"""
|
||||
import os
|
||||
import statistics
|
||||
import sys
|
||||
|
||||
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "agent-tools"))
|
||||
from donnees import charger, iso # noqa: E402
|
||||
|
||||
MISSING = 2 # au-delà de 2 pas manquants, c'est un trou (consigne de l'utilisateur, 2026-10-23)
|
||||
|
||||
|
||||
def duration(s):
|
||||
h, m = divmod(round(s / 60), 60)
|
||||
return f"{h} h {m:02d} min" if h else f"{m} min"
|
||||
|
||||
|
||||
def detect(mesures, fin=None):
|
||||
"""fin : fin de la fenêtre lue (datetime, exclue), facultative ; sans elle, un trou final n'est pas vu."""
|
||||
ts = sorted({m["t"].replace(second=0, microsecond=0) for ms in mesures.values() for m in ms})
|
||||
if len(ts) < 3:
|
||||
return []
|
||||
gaps = [(b - a).total_seconds() for a, b in zip(ts, ts[1:])]
|
||||
step = statistics.median(gaps)
|
||||
out = [(a, b, g, "") for a, b, g in zip(ts, ts[1:], gaps)]
|
||||
if fin: # fin exclue : la dernière mesure attendue est à fin − 1 pas, l'écart se compte comme entre deux mesures
|
||||
out.append((ts[-1], fin, (fin - ts[-1]).total_seconds(), ", up to the end of the period"))
|
||||
return [{"start": iso(a), "end": iso(b), "kind": "No data", "label": "No data",
|
||||
"text": f"No measurement in the export for {duration(g)}{fin_txt} (usually one every {duration(step)}).",
|
||||
"ignore": False, "sensors": []}
|
||||
for a, b, g, fin_txt in out if g > (MISSING + 1) * step]
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
for e in detect(charger(sys.argv[1])):
|
||||
print(e)
|
||||
@@ -0,0 +1,25 @@
|
||||
"""Journal du matin : le détecteur de la famille Obstruction (labeling/familles.md) : un objet cache une ou quelques
|
||||
cibles, un instant ou longtemps. Il reprend deux calculs partagés avec d'autres familles :
|
||||
- l'error_value de visibility.py : Brief obstruction (un passage, un instant) et Target obscured (une cible rejetée à
|
||||
répétition quand les autres restent vues, ou une gêne qui ne touche que quelques cibles, sans référence) ;
|
||||
- les rejets jour après jour de target_issue.py : une cible rejetée moins d'une semaine, Target obscured.
|
||||
Usage : python3 detectors/obstruction.py <dossier de station> (affiche les épisodes)
|
||||
"""
|
||||
import os
|
||||
import sys
|
||||
|
||||
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "agent-tools"))
|
||||
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
|
||||
import target_issue # noqa: E402
|
||||
import visibility # noqa: E402
|
||||
from donnees import charger # noqa: E402
|
||||
|
||||
|
||||
def detect(mesures):
|
||||
return sorted((e for e in visibility.episodes(mesures) + target_issue.episodes(mesures) if e["kind"] == "Obstruction"),
|
||||
key=lambda e: e["start"])
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
for e in detect(charger(sys.argv[1])):
|
||||
print(e["start"], "→", e["end"], e["label"], f"| {len(e['sensors'])} :", ",".join(e["sensors"][:8]), "|", e["text"])
|
||||
@@ -0,0 +1,165 @@
|
||||
"""Journal du matin : le détecteur de la famille Target issue (labeling/familles.md) : une cible constamment
|
||||
problématique : rejetée la plupart du temps, jour après jour, quand les autres sont vues (cible dégradée), collée (en
|
||||
fin de fichier), ou qui bascule (les sauts de displacement.py, « Target flipping »). Une cible rejetée moins d'une
|
||||
semaine est cachée par moments (point 4) : episodes() la rend avec la famille Obstruction, que detect() laisse à
|
||||
obstruction.py.
|
||||
|
||||
Le détecteur visibilite compare chaque capteur à son propre niveau habituel : une cible presque toujours rejetée lui
|
||||
paraît normale (FLORIDA, octobre 2026 : Massif 2 et Sellette 6 rejetées la moitié des mesures ou plus, chaque jour).
|
||||
Méthode (seuils provisoires, Claude, 2026-10-27) :
|
||||
1. Instant calme pour un capteur : au plus CALME des autres capteurs rejetés (error_value > error_threshold) ; la météo et
|
||||
la buée, qui touchent tout le monde, sont ainsi mises de côté.
|
||||
2. Par jour UTC et par capteur, sur ses instants calmes (au moins MIN_HEURES heures d'instants à la cadence de la
|
||||
station, écart médian entre deux instants de mesure ; sinon le jour ne compte pas) : jour dégradé si au moins PART
|
||||
d'entre eux sont rejetés. Cadence (boucle /detector-learner NEBRASKA, lot 01) : 12 instants fixes, « 3 h à 15 min »,
|
||||
ne comptaient aucun jour à une mesure toutes les 4 h ; REFCOLH22, rejetée sans cesse depuis sa perte, n'était pas vue.
|
||||
3. Épisode : au moins MIN_JOURS jours dégradés de suite (un jour qui ne compte pas ne coupe pas la suite), de la première
|
||||
mesure rejetée de ces jours à la dernière ; ignore = True : la courbe de la cible n'est pas fiable.
|
||||
4. Gênée tout le temps ou par moments (frontière « Target issue ou Obstruction » de labeling/familles.md ; boucle
|
||||
/detector-learner NEBRASKA, lot 01) : une suite d'au moins SEMAINE jours est une cible à problème, « Degraded target » ;
|
||||
plus courte, une cible cachée par moments, « Target obscured » (famille Obstruction), un épisode par suite de
|
||||
mesures rejetées (les heures où elle est vue n'en sont pas). BREITHORN : véhicules garés
|
||||
devant COLI24 et POUI22, 2 à 5 jours ; NEBRASKA et MICHIGAN : une référence perdue, 25 jours ; JUNGFRAU : PM_G, 63.
|
||||
Sur les jeux de data/ (2026-10-27) : FLORIDA Massif 2 21 → 25.10, Sellette 6 16 → 17.10 et 19 → 20.10 ; NIEDERHORN e03 à
|
||||
e12 toute la période (jamais vues) ; NORDEND CTR01 plusieurs suites en juin-juillet (déjà « souvent rejetée ») ; rien
|
||||
sur LENZSPITZE ; CLARIDEN PR-283 du 12 au 16.09. La cause (salissure, végétation, réglage) ne se lit que sur les images.
|
||||
Cible collée (E-011, FLORIDA : une cible définie sur le prisme d'une référence) : par jour UTC,
|
||||
le bruit de ses corr_x et corr_y (médiane des écarts d'une mesure à la suivante) à moins de COLLE fois le bruit médian
|
||||
des autres cibles, sur les deux axes, un jour suffit (une journée sans bruit n'arrive pas par accident) ; label « Target stuck ». Sur E-011 : C2 à
|
||||
7e-5 px et C3 à 2e-4 contre 0,013 pour les autres ; FLORIDA : les mêmes, Pont Ernen et Sellette 3.
|
||||
Usage : python3 detectors/target_issue.py <dossier de station> (affiche les épisodes)
|
||||
"""
|
||||
import os
|
||||
import statistics
|
||||
import sys
|
||||
|
||||
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "agent-tools"))
|
||||
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
|
||||
import displacement # noqa: E402
|
||||
from donnees import charger, est_reference, iso # noqa: E402
|
||||
|
||||
CALME = 0.25 # part des autres capteurs rejetés au plus, pour un instant calme
|
||||
PART = 0.5 # la moitié des instants calmes rejetés : « la plupart du temps »
|
||||
MIN_HEURES = 3 # heures d'instants calmes, à la cadence de la station : en dessous, le jour ne compte pas
|
||||
MIN_JOURS = 2 # un jour seul est trop souvent un accident (NORDEND : jours isolés sur 16 capteurs)
|
||||
SEMAINE = 7 # provisoire : jours dégradés de suite pour une cible à problème ; en dessous, une cible cachée par moments
|
||||
COLLE = 0.05 # provisoire : bruit d'une cible collée face aux autres (E-011 : 0,006 ; NORDEND, E-001 : 0,7 au plus bas)
|
||||
|
||||
|
||||
def rejete(m):
|
||||
return m["error_value"] is not None and m["error_threshold"] is not None and m["error_value"] > m["error_threshold"]
|
||||
|
||||
|
||||
def cadence(mesures):
|
||||
"""Écart médian entre deux instants de mesure, tous capteurs confondus, en heures (comme no_data)."""
|
||||
ts = sorted({m["t"].replace(second=0, microsecond=0) for ms in mesures.values() for m in ms})
|
||||
return statistics.median((b - a).total_seconds() for a, b in zip(ts, ts[1:])) / 3600 if len(ts) > 1 else 1
|
||||
|
||||
|
||||
def episodes(mesures):
|
||||
"""Cibles rejetées jour après jour : Target issue (une semaine ou plus) et Obstruction (moins), puis les collées."""
|
||||
min_instants = MIN_HEURES / cadence(mesures)
|
||||
par_t = {}
|
||||
for s, ms in mesures.items():
|
||||
for m in ms:
|
||||
par_t.setdefault(m["t"], {})[s] = rejete(m)
|
||||
jours = {} # capteur -> jour -> [rejetés, calmes, première mesure, dernière]
|
||||
for t in sorted(par_t):
|
||||
d = par_t[t]
|
||||
for s, r in d.items():
|
||||
autres = [v for k, v in d.items() if k != s]
|
||||
c = jours.setdefault(s, {}).setdefault(t.date(), [0, 0, t, t])
|
||||
c[3] = t
|
||||
if autres and sum(autres) / len(autres) <= CALME:
|
||||
c[0] += r
|
||||
c[1] += 1
|
||||
out = []
|
||||
for s, js in sorted(jours.items()):
|
||||
suites, cur = [], []
|
||||
for j in sorted(js):
|
||||
rej, calmes = js[j][:2]
|
||||
if calmes < min_instants:
|
||||
continue
|
||||
if rej / calmes >= PART:
|
||||
cur.append(js[j])
|
||||
elif cur:
|
||||
suites.append(cur)
|
||||
cur = []
|
||||
suites += [cur] if cur else []
|
||||
for su in suites:
|
||||
if len(su) < MIN_JOURS:
|
||||
continue
|
||||
part = round(100 * sum(c[0] for c in su) / sum(c[1] for c in su))
|
||||
text = f"{s} was rejected in {part} % of the measurements when the other targets were seen, {len(su)} days in a row."
|
||||
r = _rejets([m for m in mesures[s] if su[0][2] <= m["t"] <= su[-1][3]])
|
||||
if len(su) >= SEMAINE: # de la première à la dernière mesure rejetée
|
||||
bornes, label = [(r[0][0], r[-1][1])], "Degraded target"
|
||||
else: # par moments : un épisode par suite de mesures rejetées
|
||||
bornes, label = r, "Target obscured"
|
||||
out += [{"start": iso(a), "end": iso(b), "kind": "Target issue" if label == "Degraded target" else "Obstruction",
|
||||
"label": label, "text": text, "ignore": True,
|
||||
"sensors": [s]} for a, b in bornes]
|
||||
return sorted(out + colles(mesures, min_instants), key=lambda e: e["start"])
|
||||
|
||||
|
||||
def _rejets(ms):
|
||||
"""Mesures d'un capteur -> [(début, fin)] de ses suites de mesures rejetées."""
|
||||
out, cur = [], []
|
||||
for m in ms + [None]:
|
||||
if m and rejete(m):
|
||||
cur.append(m["t"])
|
||||
elif cur:
|
||||
out.append((cur[0], cur[-1]))
|
||||
cur = []
|
||||
return out
|
||||
|
||||
|
||||
def _bruit(v):
|
||||
return statistics.median(abs(y - x) for x, y in zip(v, v[1:])) if len(v) > 2 else None
|
||||
|
||||
|
||||
def colles(mesures, min_instants):
|
||||
"""Cibles dont corr_x et corr_y ne bougent presque pas, jour après jour, quand les autres bougent."""
|
||||
jours = {} # jour -> cible -> (bruit x, bruit y, première mesure, dernière)
|
||||
for s, ms in mesures.items():
|
||||
if est_reference(ms):
|
||||
continue
|
||||
par_j = {}
|
||||
for m in ms:
|
||||
par_j.setdefault(m["t"].date(), []).append(m)
|
||||
for d, js in par_j.items():
|
||||
b = [_bruit([m[c] for m in js if m[c] is not None]) for c in ("corr_x", "corr_y")]
|
||||
if None not in b and len(js) >= min_instants:
|
||||
jours.setdefault(d, {})[s] = (*b, js[0]["t"], js[-1]["t"])
|
||||
suites = {} # cible -> [[jours collés de suite]]
|
||||
for d in sorted(jours):
|
||||
cs = jours[d]
|
||||
for s, (bx, by, a, b) in cs.items():
|
||||
autres = [v for k, (x, y, *_) in cs.items() if k != s for v in (x, y)]
|
||||
if len(autres) < 4:
|
||||
continue
|
||||
ref = statistics.median(autres)
|
||||
su = suites.setdefault(s, [[]])
|
||||
if ref and max(bx, by) <= COLLE * ref:
|
||||
su[-1].append((a, b))
|
||||
elif su[-1]:
|
||||
su.append([])
|
||||
out = []
|
||||
for s, su in sorted(suites.items()):
|
||||
for k in su:
|
||||
if k:
|
||||
out.append({"start": iso(k[0][0]), "end": iso(k[-1][1]), "kind": "Target issue", "label": "Target stuck",
|
||||
"text": f"{s} barely moved while the other targets did ({len(k)} day{'s' if len(k) > 1 else ''}): it may be "
|
||||
"set on a reference prism.", "ignore": True, "sensors": [s]})
|
||||
return out
|
||||
|
||||
|
||||
|
||||
def detect(mesures):
|
||||
return sorted((e for e in episodes(mesures) + displacement.episodes(mesures) if e["kind"] == "Target issue"),
|
||||
key=lambda e: e["start"])
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
for e in detect(charger(sys.argv[1])):
|
||||
print(e)
|
||||
@@ -0,0 +1,260 @@
|
||||
"""Journal du matin : le détecteur de la famille Thermal displacement (labeling/familles.md) : la vague quotidienne des
|
||||
déplacements corrigés (dilatation le jour, contraction le soir : l'utilisateur, 2026-10-24 ; point 41 du plan).
|
||||
|
||||
Méthode, par cible (hors références globales) et par axe (corr_x, corr_y) :
|
||||
1. Chaque jour UTC d'au moins 20 h : moyenne de chaque heure moins la médiane du jour (enlève sauts et dérive).
|
||||
2. Profil = médiane, heure par heure, sur les jours ; « répétabilité » = médiane, sur les jours, de la corrélation
|
||||
entre le jour et le profil des autres jours. Axe concerné si répétabilité ≥ 0,6.
|
||||
3. Cycle de la station si au moins la moitié des cibles ont un axe concerné, **et** (seconde méthode, demandée par
|
||||
l'utilisateur) si une sinusoïde de 24 h, a + b·sin(2πt/24 h) + c·cos(2πt/24 h) par moindres carrés, explique au
|
||||
moins R2_MIN de la courbe d'un axe pour au moins la moitié des cibles.
|
||||
4. Heures chaudes : niveau de nuit = médiane des 8 heures consécutives les plus plates du profil ; une heure est
|
||||
chaude si, en médiane sur les axes concernés, le profil s'en écarte d'au moins 0,3 fois son amplitude.
|
||||
5. Deux épisodes par jour complet qui ressemble aux autres (corrélation médiane ≥ 0,5 sur les axes concernés) :
|
||||
« Thermal expansion » de la première heure chaude à l'heure du plus grand écart au niveau de nuit, puis « Thermal
|
||||
contraction » jusqu'à la fin de la dernière heure chaude. Le sens (une courbe qui monte ou qui descend) dépend de la
|
||||
direction de la cible : on ne le regarde pas, seulement l'écart au niveau de nuit.
|
||||
Sinusoïde (2026-10-24), axes des courbes corrigées où elle explique ≥ 30 % : PS des Coudres 14/22, NORDEND d'octobre
|
||||
0/38, juillet 1/38, WILDSTRUBEL 1/14, CLARIDEN 0/48, NIEDERHORN 14/40 (3 jours, deux nuits de pluie aux mêmes heures,
|
||||
écarté par la première méthode) ; PS des Coudres seule a son effet périodique, 5 jours, dilatation puis contraction.
|
||||
|
||||
Résultats (2026-10-23 ; « cibles » = part des cibles concernées, amplitude = médiane max − min du profil, en px) :
|
||||
| Jeu | corr (ce que voit le client) | x, y bruts |
|
||||
|---|---|---|
|
||||
| PS_DES_COUDRES | 11/11 cibles, 0,17 px, 08-17 h, 5 épisodes | 12/12, 0,55 px, 08-16 h |
|
||||
| NORDEND (juillet, E-002) | 2/18, rien | 18/19, 1,8 px, 06-18 h |
|
||||
| WILDSTRUBEL (E-003) | 3/7, rien | 6/7, 3,2 px, 04-08 h |
|
||||
| CLARIDEN (E-004) | 1/24, rien | 1/24, aucun cycle |
|
||||
| NIEDERHORN (E-005, horaire) | 3/11, rien | 19/30, 4,6 px, ~12 h |
|
||||
| cas 2026-10_NORDEND (11 j) | 9/19, 0,02 px, 08-17 h, sous le seuil (PART = 0,4 : 8 épisodes, sans 08 ni 09/10) | 17/19, 0,78 px, 09-17 h |
|
||||
Lecture : le cycle est presque partout dans les positions brutes (mode commun) et la compensation l'enlève,
|
||||
sauf à PS des Coudres où il reste dans corr, de même forme que dans les positions brutes.
|
||||
Effet thermique (D-074, 2026-10-27) : sans cycle dans corr, la même méthode sur les positions brutes x, y donne
|
||||
« Camera thermal expansion » et « Camera thermal contraction » : la caméra bouge avec la chaleur de son support, la
|
||||
compensation l'enlève ; mêmes catégories du journal, phrase propre.
|
||||
Caméra sans sinusoïde (boucle WILDSTRUBEL, lot 01) : sur les positions brutes, la seconde méthode n'est plus demandée ;
|
||||
la caméra y montait d'un bloc de 3 px au lever, tenait 3 h et retombait en un pas vers 09:30, six jours de suite, que
|
||||
la sinusoïde n'explique pas (une cible sur sept, les pointés faux de 30 px écrasent l'ajustement) ; la répétition
|
||||
d'un jour à l'autre (méthode 1, 6 cibles sur 7) suffit. En échange, une seule heure chaude n'est pas un cycle
|
||||
(CHAUDES_MIN) : NIEDERHORN (E-005, horaire) avait sinon son heure de midi (trains, trous) en contraction de la caméra.
|
||||
L'épisode de la caméra porte sur tous les capteurs, références comprises : toute l'image bouge.
|
||||
Glissade commune, sans cycle (boucle /detector-learner MICHIGAN, modification 1) : faute de cycle dans les courbes
|
||||
corrigées comme dans les positions brutes, un instant est une glissade de la caméra si les positions brutes (x ou y) d'au
|
||||
moins PART des capteurs, références comprises, **et** les courbes corrigées (corr_x ou corr_y) d'au moins PART des cibles
|
||||
s'écartent du même côté d'au moins ECART bruits (médiane des pas de la série) de leur médiane du jour d'avant ; les
|
||||
glissades à moins d'un jour l'une de l'autre font un épisode, « Camera thermal movement », sur tous les capteurs, hôte
|
||||
des sauts revenus (categories.HOTES). La caméra bouge avec la température sans revenir chaque jour à la même heure (une
|
||||
mesure toutes les 4 h, refroidissements brefs), et la compensation ne l'enlève pas toute. La condition sur les positions
|
||||
brutes laisse aux sauts une bascule de la seule pose calculée (positions brutes immobiles). MICHIGAN : 9 épisodes du 09
|
||||
au 30.10, tous dans la dérive thermique étiquetée ; NEBRASKA : 13 instants, tous justes ; BREITHORN, JUNGFRAU, NORDEND,
|
||||
WILDSTRUBEL inchangés (cycle trouvé, ou rien) ; ECART = 2 prenait 2 instants Displacement de BREITHORN.
|
||||
"""
|
||||
import math
|
||||
import os
|
||||
import statistics
|
||||
import sys
|
||||
from datetime import datetime, timedelta, timezone
|
||||
|
||||
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "agent-tools"))
|
||||
from donnees import charger, iso # noqa: E402
|
||||
|
||||
HEURES_MIN = 20 # provisoire : un jour UTC compte s'il a au moins 20 heures mesurées
|
||||
REPRO = 0.6 # provisoire : un axe a un cycle si chaque jour ressemble aux autres (bruit pur ≈ 0)
|
||||
PART = 0.5 # provisoire : part des cibles concernées ; 2026-10_NORDEND est juste dessous (9/19)
|
||||
CHAUD = 0.3 # provisoire : écart au niveau de nuit, en part de l'amplitude du profil
|
||||
JOUR = 0.5 # provisoire : ressemblance d'un jour aux autres pour lui donner son épisode
|
||||
NUIT = 8 # heures consécutives du profil les plus plates = niveau de nuit
|
||||
R2_MIN = 0.3 # provisoire, ébauche du 2026-10-24 : PS des Coudres 14 axes sur 22 au-dessus, CLARIDEN 0 sur 48
|
||||
CHAUDES_MIN = 2 # provisoire : boucle WILDSTRUBEL, lot 01 ; NIEDERHORN (E-005) n'a qu'une heure chaude (midi)
|
||||
ECART = 3 # provisoire : glissade commune, en bruits (médiane des pas) d'écart à la médiane du jour d'avant
|
||||
W = 2 * math.pi / 86400 # pulsation d'un cycle de 24 h, en rad/s
|
||||
|
||||
|
||||
def _corr(a, b):
|
||||
ma, mb = statistics.mean(a), statistics.mean(b)
|
||||
num = sum((x - ma) * (y - mb) for x, y in zip(a, b))
|
||||
den = (sum((x - ma) ** 2 for x in a) * sum((y - mb) ** 2 for y in b)) ** 0.5
|
||||
return num / den if den else 0.0
|
||||
|
||||
|
||||
def _axe(ms, col):
|
||||
"""-> (profil sur 24 h, {jour: corrélation au profil des autres jours}) ou None."""
|
||||
jours = {}
|
||||
for m in ms:
|
||||
if m[col] is not None:
|
||||
jours.setdefault(m["t"].date(), {}).setdefault(m["t"].hour, []).append(m[col])
|
||||
J = {}
|
||||
for d, hs in jours.items():
|
||||
if len(hs) >= HEURES_MIN:
|
||||
med = statistics.median(v for l in hs.values() for v in l)
|
||||
J[d] = {h: statistics.mean(l) - med for h, l in hs.items()}
|
||||
if len(J) < 2:
|
||||
return None
|
||||
profil = [statistics.median(q[h] for q in J.values() if h in q) for h in range(24) if any(h in q for q in J.values())]
|
||||
if len(profil) < 24:
|
||||
return None
|
||||
ressemblance = {}
|
||||
for d, p in J.items():
|
||||
autres = [q for e, q in J.items() if e != d]
|
||||
hs = [h for h in p if all(h in q for q in autres)]
|
||||
ressemblance[d] = _corr([p[h] for h in hs], [statistics.median(q[h] for q in autres) for h in hs])
|
||||
return profil, ressemblance
|
||||
|
||||
|
||||
def sinus_r2(ms, col):
|
||||
"""Part de la courbe expliquée par une sinusoïde de 24 h (moindres carrés, 3 inconnues), ou None si trop court."""
|
||||
pts = [(m["t"].timestamp(), m[col]) for m in ms if m[col] is not None]
|
||||
if len(pts) <= 48:
|
||||
return None
|
||||
rows = [(1.0, math.sin(W * t), math.cos(W * t)) for t, _ in pts]
|
||||
A = [[sum(r[i] * r[j] for r in rows) for j in range(3)] for i in range(3)]
|
||||
B = [sum(r[i] * y for r, (_, y) in zip(rows, pts)) for i in range(3)]
|
||||
for i in range(3): # élimination de Gauss
|
||||
for k in range(i + 1, 3):
|
||||
f = A[k][i] / A[i][i]
|
||||
A[k] = [x - f * y for x, y in zip(A[k], A[i])]
|
||||
B[k] -= f * B[i]
|
||||
x = [0.0] * 3
|
||||
for i in (2, 1, 0):
|
||||
x[i] = (B[i] - sum(A[i][j] * x[j] for j in range(i + 1, 3))) / A[i][i]
|
||||
m = statistics.mean(y for _, y in pts)
|
||||
sst = sum((y - m) ** 2 for _, y in pts)
|
||||
sse = sum((y - sum(c * v for c, v in zip(x, r))) ** 2 for r, (_, y) in zip(rows, pts))
|
||||
return 1 - sse / sst if sst else None
|
||||
|
||||
|
||||
def sinus(mesures, cols=("corr_x", "corr_y")):
|
||||
"""-> (cibles dont un axe suit une sinusoïde de 24 h, cibles évaluées)."""
|
||||
oui, evaluees = set(), set()
|
||||
for s, ms in mesures.items():
|
||||
if ms[0]["pattern_type"] == "global_ref":
|
||||
continue
|
||||
for col in cols:
|
||||
r2 = sinus_r2(ms, col)
|
||||
if r2 is not None:
|
||||
evaluees.add(s)
|
||||
if r2 >= R2_MIN:
|
||||
oui.add(s)
|
||||
return oui, evaluees
|
||||
|
||||
|
||||
def cycle(mesures, cols=("corr_x", "corr_y")):
|
||||
"""-> (axes concernés [(capteur, col, profil, ressemblance)], nombre de cibles évaluées)."""
|
||||
concernes, cibles = [], set()
|
||||
for s, ms in mesures.items():
|
||||
if ms[0]["pattern_type"] == "global_ref":
|
||||
continue
|
||||
for col in cols:
|
||||
r = _axe(ms, col)
|
||||
if r is None:
|
||||
continue
|
||||
cibles.add(s)
|
||||
if statistics.median(r[1].values()) >= REPRO:
|
||||
concernes.append((s, col) + r)
|
||||
return concernes, len(cibles)
|
||||
|
||||
|
||||
def ecarts(concernes):
|
||||
"""Écart médian (sur les axes concernés) au niveau de nuit, heure par heure, en part de l'amplitude du profil."""
|
||||
def score(p, h):
|
||||
debut = min(range(24), key=lambda i: max(p[(i + k) % 24] for k in range(NUIT)) - min(p[(i + k) % 24] for k in range(NUIT)))
|
||||
nuit = statistics.median(p[(debut + k) % 24] for k in range(NUIT))
|
||||
return abs(p[h] - nuit) / (max(p) - min(p))
|
||||
return [statistics.median(score(c[2], h) for c in concernes) for h in range(24)]
|
||||
|
||||
|
||||
def heures_chaudes(concernes):
|
||||
return [h for h, e in enumerate(ecarts(concernes)) if e >= CHAUD]
|
||||
|
||||
|
||||
def detect(mesures):
|
||||
"""Cycle des courbes corrigées (l'ouvrage) ; sinon, celui des positions brutes (la caméra qui bouge par dilatation
|
||||
de son support, compensée : D-074, 2026-10-27)."""
|
||||
return (_episodes(mesures, ("corr_x", "corr_y"), "Thermal", False) or
|
||||
_episodes(mesures, ("x", "y"), "Camera thermal", True) or glissades(mesures))
|
||||
|
||||
|
||||
def _signes(ms, col):
|
||||
"""{instant: +1 ou -1} où la mesure s'écarte d'au moins ECART bruits de la médiane du jour d'avant."""
|
||||
k = [(m["t"], m[col]) for m in ms if m[col] is not None]
|
||||
if len(k) < 3:
|
||||
return {}
|
||||
bruit = statistics.median(abs(b - a) for (_, a), (_, b) in zip(k, k[1:]))
|
||||
out, j = {}, 0
|
||||
for i, (t, v) in enumerate(k):
|
||||
while k[j][0] < t - timedelta(days=1):
|
||||
j += 1
|
||||
avant = [w for _, w in k[j:i]]
|
||||
if bruit and len(avant) >= 3 and abs(v - statistics.median(avant)) >= ECART * bruit:
|
||||
out[t] = 1 if v > statistics.median(avant) else -1
|
||||
return out
|
||||
|
||||
|
||||
def _communs(series):
|
||||
"""[{instant: signe}] d'un groupe de capteurs -> instants où au moins PART d'entre eux s'écartent du même côté."""
|
||||
n, compte = len(series), {}
|
||||
for sg in series:
|
||||
for t, x in sg.items():
|
||||
compte.setdefault((t, x), 0)
|
||||
compte[(t, x)] += 1
|
||||
return {t for (t, x), c in compte.items() if n and c >= PART * n}
|
||||
|
||||
|
||||
def glissades(mesures):
|
||||
"""Glissade commune de la caméra, sans cycle de 24 h : les positions brutes de la plupart des capteurs, références
|
||||
comprises, et les courbes corrigées de la plupart des cibles s'écartent ensemble, du même côté, de leur jour d'avant."""
|
||||
cibles = [ms for ms in mesures.values() if ms[0]["pattern_type"] != "global_ref"]
|
||||
brut = set().union(*(_communs([_signes(ms, c) for ms in mesures.values()]) for c in ("x", "y")))
|
||||
corr = set().union(*(_communs([_signes(ms, c) for ms in cibles]) for c in ("corr_x", "corr_y")))
|
||||
episodes = []
|
||||
for t in sorted(brut & corr):
|
||||
if episodes and t - episodes[-1][1] <= timedelta(days=1): # moins d'un jour entre deux : la même glissade
|
||||
episodes[-1][1] = t
|
||||
else:
|
||||
episodes.append([t, t])
|
||||
return [{"start": iso(a), "end": iso(b), "kind": "Thermal displacement", "label": "Camera thermal movement",
|
||||
"text": "The camera moved with a change of temperature and all the curves moved with it; this is not a "
|
||||
"movement of the structure, nothing to do.", "ignore": False, "sensors": sorted(mesures)}
|
||||
for a, b in episodes]
|
||||
|
||||
|
||||
def _episodes(mesures, cols, nom, camera):
|
||||
concernes, n = cycle(mesures, cols)
|
||||
capteurs = sorted({c[0] for c in concernes})
|
||||
if not n or len(capteurs) < PART * n:
|
||||
return []
|
||||
if not camera: # seconde méthode, pour l'ouvrage seul : la sinusoïde doit le voir aussi
|
||||
oui, evaluees = sinus(mesures, cols)
|
||||
if not evaluees or len(oui) < PART * len(evaluees):
|
||||
return []
|
||||
chaudes = heures_chaudes(concernes)
|
||||
if len(chaudes) < CHAUDES_MIN:
|
||||
return []
|
||||
e = ecarts(concernes)
|
||||
pic = max(chaudes, key=lambda h: e[h]) # le plus grand écart au niveau de nuit : fin de la dilatation
|
||||
jours = sorted({d for c in concernes for d in c[3]})
|
||||
if camera: # toute l'image bouge, références comprises
|
||||
capteurs = sorted(mesures)
|
||||
episodes = []
|
||||
for d in jours: # ponytail: jours complets seulement, les bouts d'export (22:00 → minuit) n'ont pas d'épisode
|
||||
if statistics.median(c[3][d] for c in concernes if d in c[3]) < JOUR:
|
||||
continue
|
||||
minuit = datetime(d.year, d.month, d.day, tzinfo=timezone.utc)
|
||||
for label, a, b in ((f"{nom} expansion", chaudes[0], pic), (f"{nom} contraction", pic, chaudes[-1] + 1)):
|
||||
if b > a:
|
||||
episodes.append({"start": iso(minuit + timedelta(hours=a)), "end": iso(minuit + timedelta(hours=b)),
|
||||
"kind": "Thermal displacement", "label": label, "text": "", "ignore": False, "sensors": capteurs})
|
||||
return episodes
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
mesures = charger(sys.argv[1])
|
||||
for e in detect(mesures):
|
||||
print(e["start"], "→", e["end"], e["label"], len(e["sensors"]), "cibles")
|
||||
for cols in (("corr_x", "corr_y"), ("x", "y")):
|
||||
concernes, n = cycle(mesures, cols)
|
||||
k = len({c[0] for c in concernes})
|
||||
amp = statistics.median(max(c[2]) - min(c[2]) for c in concernes) if concernes else 0
|
||||
oui, evaluees = sinus(mesures, cols)
|
||||
print(f"{cols[0][:-2] or 'brut'} : cibles {k}/{n}, amplitude médiane {amp:.3f} px, heures chaudes (UTC) "
|
||||
f"{heures_chaudes(concernes) if concernes else '-'} ; sinusoïde : cibles {len(oui)}/{len(evaluees)}")
|
||||
@@ -0,0 +1,324 @@
|
||||
"""Journal du matin : le détecteur de la famille Visibility (labeling/familles.md) : on voit moins bien, l'image est faible
|
||||
ou floue (error_value), ou elle tremble (turbulence, en fin de fichier). Le même calcul de l'error_value trouve aussi les
|
||||
objets devant quelques cibles (Brief obstruction, Target obscured) : episodes() les rend avec la famille Obstruction, que
|
||||
detect() laisse à obstruction.py.
|
||||
|
||||
Méthode (seuils provisoires ci-dessous) :
|
||||
1. Mesure « haute » : error_value > médiane + 10 MAD du capteur sur l'export, et > 2 × médiane, ou rejetée (> error_threshold)
|
||||
et > 1,2 × médiane : un capteur au niveau habituel de 0,6 ne double jamais, et FLORIDA (boucle, lot 01) montrait ses brouillards
|
||||
en Target obscured.
|
||||
2. Brief obstruction : un instant où au moins 3 capteurs sont hauts, 3 fois plus qu'aux instants voisins (train, véhicule),
|
||||
sans référence (global_ref) parmi eux : un pic d'un pas qui touche les références n'est pas un obstacle devant des
|
||||
cibles (pic de toute l'image, NORDEND le 01.09 11:15, lot 01 de la boucle) ; il n'est pas montré. Sauf si au moins
|
||||
BREF_MIN cibles sont rejetées (> error_threshold) à cet instant et ni à l'instant d'avant ni à celui d'après : un
|
||||
passage devant elles, une référence touchée en plus (/detector-learner Displacement, modification 1, S5 : trains de
|
||||
NIEDERHORN, 12 et 13 cibles rejetées ; NORDEND le 01.09 11:15 n'a aucun rejet).
|
||||
3. Poor visibility : suites d'au moins 3 mesures hautes par capteur, réunies entre capteurs (au moins 2), réduites aux instants
|
||||
où au moins 15 % du pic de l'épisode est haut ; le texte dit si des références (global_ref) sont touchées.
|
||||
4. Target obscured : une cible (pas une global_ref) rejetée (> error_threshold) et à plus de 5 MAD, au moins 3 fois à moins de 6 h
|
||||
d'écart, la plupart hors des épisodes 2 et 3 (feuilles, neige, reflet sur une cible). Tous les épisodes : ignore = True.
|
||||
5. Niveau d'une Poor visibility (point 38 du plan, validé le 2026-10-24), mesure par mesure : « none » (on ne voit rien) quand
|
||||
au moins MOITIE des cibles habituellement vues (sous leur seuil la moitié du temps au moins) sont rejetées, « reduced »
|
||||
(données moyennes) sinon ; un épisode par période de même niveau, avec le champ level. Sur les cas : NORDEND le 09.10
|
||||
08:45 → 10:30 et 21:30 → 23:15, le 14.10 05:15 → 06:00 en none ; buées de NORDEND et de E-001, toile de E-002, pluie
|
||||
de E-005 en reduced.
|
||||
6. Bornes d'une Poor visibility (boucle WILDSTRUBEL, lot 01) : de la première à la dernière mesure où une cible est
|
||||
rejetée (> error_threshold), et pas d'épisode sans cible rejetée. Sur une chaussée en plein soleil, l'error_value de
|
||||
jour (×1,5 à ×3, la turbulence) faisait durer la visibilité réduite des heures sans aucun rejet (28.09 10:00 → 12:15,
|
||||
29.09 jusqu'à 14:15) ; les références ne comptent pas : R3 y passe son seuil presque toute la journée. Benchmark :
|
||||
le seul épisode perdu est celui, faux, de E-010.
|
||||
7. Poor visibility ou objet (frontière « Visibility ou Obstruction » de labeling/familles.md ; boucle /detector-learner
|
||||
BREITHORN, lot 01) : une gêne qui ne touche qu'au plus QUELQUES cibles, et aucune référence, n'est pas diffuse : c'est
|
||||
un objet devant elles (un véhicule stationné), un épisode « Target obscured » de toute sa durée, sans niveau.
|
||||
|
||||
Résultats (2026-10-23) :
|
||||
- PS_DES_COUDRES (E-001, buée 13.10 23:45 → 14.10 05:15, 2 références sur 3) : Poor visibility 13.10 23:45 → 14.10 04:45, REF_G et
|
||||
REF_D ; aussi la nuit d'avant, 13.10 01:15 → 03:30, mêmes références (hors vérité, pas d'image : sans doute la même buée).
|
||||
- NORDEND juillet (E-002, toile 28.07 20:45 → 31.07 03:00, reprise 31.07 20:30) : Poor visibility 28.07 20:45 → 31.07 02:45 (20 capteurs)
|
||||
et 31.07 20:30 → fin (18), références comprises.
|
||||
- WILDSTRUBEL (E-003, turbulence de jour) : pas de Poor visibility (error_value ×1,5 à ×3 seulement : laissé au détecteur turbulence) ;
|
||||
3 Brief obstruction de jour (02.09 12:00, 03.09 08:15, 04.09 14:00 : un véhicule sur la route à 14:00, image ; les deux
|
||||
premières touchent des références et ne sont plus montrées depuis le lot 01 de la boucle NORDEND) ; PA_9 en
|
||||
Target obscured chaque matin dès 04:30, jusqu'à 06:45, 08:15 ou 12:00 (soleil sur la cible, probable).
|
||||
- CLARIDEN (E-004, mouvement réel) : rien sur le groupe à error_value durablement haute (bon) ; Brief obstruction 18.09 13:40
|
||||
et 20.09 06:20 (tunnel : taches assombries, non établi ; références touchées, plus montrées depuis le lot 01) ;
|
||||
Target obscured PR-284 19.09 18:30 → 18:50.
|
||||
- NIEDERHORN (E-005) : trains 30.09 22:00, 01.10 12:00 et 21:00, 02.10 21:00 (celui du 03.10 10:00, 2 cibles, manqué) ;
|
||||
pluie 01.10 06:00 → 11:00 et 02.10 03:00 → 11:00 (vérité 05:00 et 03:00 → 11:00), références intactes ; feuilles 02.10 10:00 → 22:00.
|
||||
- NORDEND octobre (cas/2026-10_NORDEND) : Poor visibility 07.10 17:15 → 08.10 12:15 (buée du 08.10 02:30), 09.10 07:45 → 14:00
|
||||
(parois ruisselantes), 09.10 20:45 → 23:45 (17 rejets à 23:00, retour à 00:00), 13.10 09:45 → 10:30, 14.10 05:15 → 06:30
|
||||
(taches pâles à l'aube) ; Brief obstruction 12.10 14:15 (09.10 18:45 touche CTR04 : plus montrée depuis le lot 01) ;
|
||||
Target obscured surtout CTR01, PR04, PR09 (souvent rejetées) : à vérifier.
|
||||
- FLORIDA (boucle, lot 01 ; cibles au niveau 0,6 pour un seuil de 0,7) : les brouillards du 18.10, du 20-21.10, du 23.10 et
|
||||
du 24-25.10, avant en Target obscured, en Poor visibility (none et reduced en alternance, cœur seul : à 10 MAD) ; la référence
|
||||
r1_r au-dessus de son seuil du 22.10 au 24.10 reste manquée (son MAD de 0,15 rend 10 MAD hors d'atteinte).
|
||||
|
||||
Version simple essayée le 2026-10-24 (point 11 du plan), à la demande de l'utilisateur : part des cibles rejetées au-dessus
|
||||
de leur seuil, sans comparer chaque capteur à son propre niveau. Moins bonne sur cinq jeux sur six (buée de E-001 manquée,
|
||||
toile de E-002 morcelée, turbulence de E-003 prise pour une perte de visibilité) et grisait le vrai mouvement de E-004 :
|
||||
l'utilisateur a remis cette version en service ; la simple est gardée dans archive/visibilite_simple.py.
|
||||
"""
|
||||
import os
|
||||
import statistics
|
||||
import sys
|
||||
from datetime import timedelta
|
||||
|
||||
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "agent-tools"))
|
||||
from donnees import charger, iso # noqa: E402
|
||||
|
||||
K_MAD = 10 # provisoire, réglé sur E-001 (buée : 11 à 57 MAD) et E-005 (pluie, trains : 10 à 70 MAD)
|
||||
FACTEUR = 2 # provisoire : écarte les capteurs à MAD quasi nulle (E-004 : PWD_REF10 ×1,6 à 14 MAD, E-005)
|
||||
SUITE_MIN = 3 # provisoire : mesures hautes d'affilée pour une mauvaise visibilité (E-001, E-005 pluie)
|
||||
BREF_MIN = 3 # provisoire, réglé sur E-005 (trains : 5 à 17 capteurs ; celui de 2 cibles est manqué)
|
||||
K_CIBLE = 5 # provisoire, réglé sur E-005 (feuilles : 6 à 25 MAD, rejetées)
|
||||
CIBLE_MIN = 3 # provisoire : rejets répétés d'une cible
|
||||
FRAC = 0.15 # provisoire : coupe les queues de PR09 + CTR01 (NORDEND octobre) sans couper la toile (E-002)
|
||||
ECART = 2.5 # provisoire : pas tolérés entre deux mesures hautes d'une même suite (un pas manquant, horloge à la seconde près)
|
||||
COUPURE = timedelta(hours=2) # provisoire : accalmie qui sépare deux épisodes (NORDEND octobre, nuit du 13 au 14.10)
|
||||
SAILLIE = 3 # provisoire : un train ressort d'au moins 3 fois les instants voisins (E-005 : 5 à 17 contre 0 à 2 ;
|
||||
# la toile de E-002 varie de 2 à 9 d'un pas à l'autre)
|
||||
CIBLE_ECART = timedelta(hours=6) # provisoire, réglé sur E-005 (feuilles : 7 rejets en 12 h, jusqu'à 5 h d'écart)
|
||||
FACTEUR_REJET = 1.2 # provisoire : un rejet à 10 MAD compte aussi (boucle FLORIDA, lot 01 : niveaux de 0,6, ×2 hors d'atteinte) ;
|
||||
# écarte C24 de E-009 (niveau 0,68 au ras du seuil 0,7, rejeté à ×1,04)
|
||||
MOITIE = 0.5 # provisoire : « on ne voit rien » ; réglé sur NORDEND (09.10 23:00 : 68 % rejetées) et E-005 (pluie : 24 à 33 %)
|
||||
QUELQUES = 3 # provisoire : Poor visibility sur au plus 3 cibles, sans référence : un objet, Target obscured (7) ;
|
||||
# boucle /detector-learner BREITHORN, lot 01 (véhicules stationnés devant 2 ou 3 cibles sur 12)
|
||||
|
||||
|
||||
def _pas(mesures):
|
||||
ts = sorted({m["t"] for v in mesures.values() for m in v})
|
||||
return statistics.median(b - a for a, b in zip(ts, ts[1:]))
|
||||
|
||||
|
||||
def _grouper(points, ecart):
|
||||
"""[(t, capteur)] triés par t -> groupes [(début, fin, {capteurs}, [t])] dont les points sont à ≤ ecart les uns des autres."""
|
||||
groupes = []
|
||||
for t, s in points:
|
||||
if groupes and t - groupes[-1][1] <= ecart:
|
||||
g = groupes[-1]
|
||||
groupes[-1] = (g[0], t, g[2] | {s}, g[3] + [t])
|
||||
else:
|
||||
groupes.append((t, t, {s}, [t]))
|
||||
return groupes
|
||||
|
||||
|
||||
def _episode(debut, fin, label, text, capteurs, level=None):
|
||||
e = {"start": iso(debut), "end": iso(fin), "kind": "Visibility" if label == "Poor visibility" else "Obstruction",
|
||||
"label": label, "text": text,
|
||||
"ignore": level != "reduced", "sensors": sorted(capteurs)} # visibilité réduite : données moyennes, pas grisées
|
||||
return {**e, "level": level} if level else e
|
||||
|
||||
|
||||
def _niveaux(mesures, instants):
|
||||
"""t -> "none" si au moins MOITIE des cibles habituellement vues sont rejetées à t, "reduced" sinon."""
|
||||
ratios = []
|
||||
for v in mesures.values():
|
||||
r = {m["t"]: m["error_value"] / m["error_threshold"] for m in v if m["error_value"] is not None and m["error_threshold"]}
|
||||
if r and statistics.median(r.values()) < 1:
|
||||
ratios.append(r)
|
||||
return {t: "none" if sum(r.get(t, 0) > 1 for r in ratios) >= MOITIE * max(1, sum(t in r for r in ratios)) else "reduced"
|
||||
for t in instants}
|
||||
|
||||
|
||||
def episodes(mesures):
|
||||
"""Tous les épisodes de l'error_value : Visibility (Poor visibility), Obstruction (Brief obstruction, Target obscured)."""
|
||||
ecart = ECART * _pas(mesures)
|
||||
refs = {s for s, v in mesures.items() if v[0]["pattern_type"] == "global_ref"}
|
||||
instants = sorted({m["t"] for v in mesures.values() for m in v})
|
||||
hautes, rejets = {}, {} # capteur -> [t]
|
||||
refuses = set() # instants où une cible (pas une global_ref) est au-dessus de son seuil
|
||||
rejetees = {} # t -> {cibles au-dessus de leur seuil}
|
||||
for s, v in mesures.items():
|
||||
e = [m["error_value"] for m in v if m["error_value"] is not None]
|
||||
if len(e) < 10:
|
||||
continue
|
||||
med = statistics.median(e)
|
||||
mad = statistics.median(abs(x - med) for x in e) or 1e-9
|
||||
for m in v:
|
||||
x = m["error_value"]
|
||||
if x is None:
|
||||
continue
|
||||
rejete = m["error_threshold"] and x > m["error_threshold"]
|
||||
if rejete and s not in refs:
|
||||
refuses.add(m["t"])
|
||||
rejetees.setdefault(m["t"], set()).add(s)
|
||||
if x > med + K_MAD * mad and (x > FACTEUR * med or rejete and x > FACTEUR_REJET * med):
|
||||
hautes.setdefault(s, []).append(m["t"])
|
||||
if s not in refs and rejete and x > med + K_CIBLE * mad:
|
||||
rejets.setdefault(s, []).append(m["t"])
|
||||
par_t = {} # t -> {capteurs hauts}
|
||||
for s, ts in hautes.items():
|
||||
for t in ts:
|
||||
par_t.setdefault(t, set()).add(s)
|
||||
n = lambda t: len(par_t.get(t, ())) # noqa: E731
|
||||
out = []
|
||||
|
||||
# 2. Brief obstruction : un instant où beaucoup de capteurs sont hauts, au moins SAILLIE fois plus qu'aux instants voisins.
|
||||
brefs = set()
|
||||
for i, t in enumerate(instants):
|
||||
voisins = [n(instants[j]) for j in (i - 1, i + 1) if 0 <= j < len(instants)]
|
||||
if n(t) >= BREF_MIN and n(t) >= SAILLIE * max(voisins):
|
||||
brefs.add(t)
|
||||
seules = rejetees.get(t, set()).difference(*(rejetees.get(instants[j], set()) for j in (i - 1, i + 1)
|
||||
if 0 <= j < len(instants)))
|
||||
if par_t[t] & refs and len(seules) < BREF_MIN: # références touchées sans cibles rejetées à ce seul instant :
|
||||
continue # pas un obstacle devant des cibles, l'image entière
|
||||
out.append(_episode(t, t, "Brief obstruction", f"{n(t)} points were poorly seen for a single measurement, then came "
|
||||
"back: probably a train, a vehicle or an animal passing; ignore this point on the curves.", par_t[t]))
|
||||
|
||||
# 3. Poor visibility : suites longues par capteur (sans les instants brefs), réunies entre capteurs,
|
||||
# puis réduites aux instants où au moins FRAC du pic de l'épisode est haut (coupe les queues d'un ou deux capteurs
|
||||
# et les longues accalmies, plus de COUPURE).
|
||||
suites = []
|
||||
for s, ts in hautes.items():
|
||||
pts = [(t, s) for t in ts if t not in brefs]
|
||||
suites += [(a, b, s) for a, b, _, l in _grouper(pts, ecart) if len(l) >= SUITE_MIN]
|
||||
zones = [z for z in _grouper_intervalles(sorted(suites), ecart) if len(z[2]) >= 2]
|
||||
gardees = []
|
||||
for a, b, _ in zones:
|
||||
dans = [t for t in instants if a <= t <= b and t not in brefs]
|
||||
pic = max(n(t) for t in dans)
|
||||
pts = [(t, s) for t in dans if n(t) >= max(1, FRAC * pic) for s in par_t[t]]
|
||||
gardees += [(d, f, cs) for d, f, cs, l in _grouper(pts, max(ecart, COUPURE)) if len(cs) >= 2 and len(set(l)) >= SUITE_MIN]
|
||||
# Bornes : de la première à la dernière cible rejetée ; sans rejet, pas d'épisode (6).
|
||||
gardees = [(r[0], r[-1], cs) for a, b, cs in gardees if (r := [t for t in instants if a <= t <= b and t in refuses])]
|
||||
niveau = _niveaux(mesures, instants)
|
||||
for a, b, cs in gardees: # un épisode par période de même niveau (5) ; le texte vient de categories.py
|
||||
if len(cs) <= QUELQUES and not cs & refs: # un objet devant quelques cibles, pas une gêne diffuse (7)
|
||||
out.append(_episode(a, b, "Target obscured", "", cs))
|
||||
continue
|
||||
seg = []
|
||||
for t in [t for t in instants if a <= t <= b] + [None]:
|
||||
if seg and (t is None or niveau[t] != niveau[seg[0]]):
|
||||
qui = cs & set().union(*(par_t.get(u, set()) for u in seg)) or cs
|
||||
out.append(_episode(seg[0], seg[-1], "Poor visibility", "", qui, niveau[seg[0]]))
|
||||
seg = []
|
||||
if t is not None:
|
||||
seg.append(t)
|
||||
dedans = lambda t: t in brefs or any(a <= t <= b for a, b, _ in gardees) # noqa: E731
|
||||
|
||||
# 4. Target obscured : une cible rejetée à répétition, surtout hors des épisodes ci-dessus.
|
||||
cibles = []
|
||||
for s, ts in rejets.items():
|
||||
for a, b, _, l in _grouper([(t, s) for t in ts], CIBLE_ECART):
|
||||
if len(l) >= CIBLE_MIN and sum(map(dedans, l)) * 2 < len(l):
|
||||
cibles.append((a, b, s))
|
||||
for a, b, cs in _grouper_intervalles(sorted(cibles), timedelta(0)):
|
||||
qui, it, its = ("One target was", "it", "its") if len(cs) == 1 else (f"{len(cs)} targets were", "them", "their")
|
||||
out.append(_episode(a, b, "Target obscured", f"{qui} repeatedly lost while the targets around stayed clear: probably "
|
||||
f"something in front of {it} (leaves, snow) or glare; {its} displacements in this period are unreliable.", cs))
|
||||
return sorted(out, key=lambda e: e["start"])
|
||||
|
||||
|
||||
def _grouper_intervalles(intervalles, ecart):
|
||||
"""[(début, fin, capteur)] triés -> [(début, fin, {capteurs})] des intervalles qui se chevauchent (à ecart près)."""
|
||||
out = []
|
||||
for a, b, s in intervalles:
|
||||
if out and a - out[-1][1] <= ecart:
|
||||
out[-1] = (out[-1][0], max(out[-1][1], b), out[-1][2] | {s})
|
||||
else:
|
||||
out.append((a, b, {s}))
|
||||
return out
|
||||
|
||||
|
||||
def detect(mesures):
|
||||
return [e for e in episodes(mesures) if e["kind"] == "Visibility"] + turbulence(mesures)
|
||||
|
||||
|
||||
# --- Turbulence ----------------------------------------------------------------------------------------------------
|
||||
# Turbulence atmosphérique (bruit rapide sur les déplacements corrigés).
|
||||
#
|
||||
# Méthode :
|
||||
# 1. Par capteur et par heure H, sur les mesures de [H − 1 h, H + 2 h) : agitation = médiane de |Δcorr_x| + |Δcorr_y|
|
||||
# entre mesures successives (robuste aux sauts d'un seul pas), et médiane de l'error_value.
|
||||
# 2. Chacune est rapportée au calme du capteur : le quartile bas de ses valeurs horaires sur l'export (souvent la nuit).
|
||||
# 3. Heure turbulente : au moins la moitié des capteurs à ≥ 1,5 fois leur agitation calme, et error_value médiane
|
||||
# des capteurs à ≥ 1,5 fois la calme (l'air chaud brouille les taches : E-003, critère 1).
|
||||
# 4. Heures voisines fusionnées (trou d'une heure toléré), épisode d'au moins 3 h, écarté si plus de 15 % des mesures
|
||||
# sont rejetées (c'est alors de la mauvaise visibilité, autre détecteur). Grisé si l'agitation médiane ≥ 2×.
|
||||
#
|
||||
# Résultats (2026-10-23, seuils ci-dessous) :
|
||||
# - WILDSTRUBEL (E-003, vérité : chaque jour ~03:30 → 16:00) : 3 épisodes, 02.09 04:00-15:00, 03.09 05:00-15:00,
|
||||
# 04.09 04:00-15:00, les 13 capteurs, ×2,3 à ×2,6, tous grisés.
|
||||
# - PS_DES_COUDRES (sain, buée une nuit), NORDEND juillet (toile d'araignée), CLARIDEN (mouvement réel),
|
||||
# NIEDERHORN (trains, pluie), NORDEND octobre (11 jours) : aucun épisode. Écartés en route : midis agités sans
|
||||
# error_value en hausse (PS des Coudres, NORDEND octobre), toile et pluie par les rejets (18 à 43 %), le matin du
|
||||
# mouvement de CLARIDEN (06:00-08:00) par la durée.
|
||||
RATIO = 1.5 # provisoire, réglé sur E-003 (WILDSTRUBEL : de jour, corr ×1,7 à ×3 la nuit)
|
||||
PART = 0.5 # provisoire : part des capteurs agités en même temps
|
||||
RATIO_ERR = 1.5 # provisoire, réglé sur E-003 (error_value ×1,7 à ×3,2 la nuit ; ≈ ×1 à midi ailleurs)
|
||||
REJET_MAX = 0.15 # provisoire : E-003 ≤ 7 % ; toile d'araignée (E-002) et pluie (E-005) ≥ 18 %
|
||||
FORT = 2.0 # provisoire : E-003 (×2,3 à ×2,6) est fort ; un épisode entre ×1,5 et ×2 reste visible
|
||||
DUREE_MIN = timedelta(hours=3) # provisoire : E-003 dure 10-11 h ; écarte le matin du mouvement réel de E-004 (2 h),
|
||||
# que le classement écarte aussi, quelle que soit la durée (point 14 du plan)
|
||||
HEURE = timedelta(hours=1)
|
||||
|
||||
|
||||
def _heure(t):
|
||||
return t.replace(minute=0, second=0, microsecond=0)
|
||||
|
||||
|
||||
def _rapports(points):
|
||||
"""[(t, valeur)] -> {heure H: médiane sur [H − 1 h, H + 2 h) / quartile bas de ces médianes}."""
|
||||
par = {}
|
||||
for t, v in points:
|
||||
for k in (-1, 0, 1):
|
||||
par.setdefault(_heure(t) + k * HEURE, []).append(v)
|
||||
med = {h: statistics.median(v) for h, v in par.items() if len(v) >= 3}
|
||||
if len(med) < 8:
|
||||
return {}
|
||||
calme = statistics.quantiles(med.values(), n=4)[0]
|
||||
return {h: v / calme for h, v in med.items()} if calme > 0 else {}
|
||||
|
||||
|
||||
def heures(mesures):
|
||||
"""-> {heure: {capteur: (agitation / calme, error_value / calme)}}."""
|
||||
out = {}
|
||||
for s, ms in mesures.items():
|
||||
ag = _rapports([(b["t"], abs(b["corr_x"] - a["corr_x"]) + abs(b["corr_y"] - a["corr_y"]))
|
||||
for a, b in zip(ms, ms[1:]) if a["corr_x"] is not None and b["corr_x"] is not None])
|
||||
er = _rapports([(m["t"], m["error_value"]) for m in ms if m["error_value"] is not None])
|
||||
for h, r in ag.items():
|
||||
if h in er:
|
||||
out.setdefault(h, {})[s] = (r, er[h])
|
||||
return out
|
||||
|
||||
|
||||
def _turbulente(r):
|
||||
return (sum(a >= RATIO for a, _ in r.values()) >= PART * len(r)
|
||||
and statistics.median(e for _, e in r.values()) >= RATIO_ERR)
|
||||
|
||||
|
||||
def turbulence(mesures):
|
||||
H = heures(mesures)
|
||||
blocs = []
|
||||
for h in sorted(h for h, r in H.items() if _turbulente(r)):
|
||||
if blocs and h - blocs[-1][-1] <= 2 * HEURE:
|
||||
blocs[-1].append(h)
|
||||
else:
|
||||
blocs.append([h])
|
||||
episodes = []
|
||||
for b in blocs:
|
||||
debut, fin = b[0], b[-1] + HEURE
|
||||
dedans = [m for ms in mesures.values() for m in ms if debut <= m["t"] < fin]
|
||||
if fin - debut < DUREE_MIN or sum(m["corr_x"] is None for m in dedans) > REJET_MAX * len(dedans):
|
||||
continue
|
||||
par_capteur = {}
|
||||
for h in b:
|
||||
for s, (a, _) in H[h].items():
|
||||
par_capteur.setdefault(s, []).append(a)
|
||||
agit = {s: statistics.median(v) for s, v in par_capteur.items()}
|
||||
fort = statistics.median(agit.values())
|
||||
episodes.append({
|
||||
"start": iso(debut), "end": iso(fin), "kind": "Visibility",
|
||||
"label": "Heat shimmer",
|
||||
"text": f"Readings were about {fort:.1f}× noisier than in calm hours because of heat shimmer "
|
||||
"(warm air trembling in the line of sight); the small fast wiggles are not movement.",
|
||||
"ignore": fort >= FORT,
|
||||
"sensors": sorted(s for s, v in agit.items() if v >= RATIO),
|
||||
})
|
||||
return episodes
|
||||
|
||||
if __name__ == "__main__":
|
||||
for e in detect(charger(sys.argv[1])):
|
||||
print(e["start"], "→", e["end"], e["label"], f"| {len(e['sensors'])} :", ",".join(e["sensors"][:8]), "|", e["text"])
|
||||
@@ -0,0 +1,80 @@
|
||||
"""Figure de présentation : panneaux caméra (tilt, pan, rotation), température, puis corr_y des cibles.
|
||||
|
||||
Usage : .venv/bin/python .claude/skills/presentation/figure-y.py data/STATION sortie.png DEBUT FIN --cam tilt,pan --temp --cibles A,B
|
||||
[--zone D/F ...] [--ligne T] [--toutes] (--toutes : corr_y de toutes les cibles, pour explorer)
|
||||
"""
|
||||
import argparse
|
||||
import os
|
||||
import sys
|
||||
|
||||
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "agent-tools"))
|
||||
import matplotlib
|
||||
|
||||
matplotlib.use("Agg")
|
||||
import matplotlib.dates as mdates # noqa: E402
|
||||
import matplotlib.pyplot as plt # noqa: E402
|
||||
|
||||
from donnees import charger, charger_camera, charger_temperature, est_reference, filtrer, instant # noqa: E402
|
||||
|
||||
NOMS = {"tilt": "Tilt de la caméra (°)", "pan": "Pan de la caméra (°)", "rotation": "Rotation de la caméra (°)"}
|
||||
|
||||
|
||||
def coupee(points, trou_h=6):
|
||||
"""[(t, v)] -> listes x, y avec None aux trous de plus de trou_h heures (le trait ne relie pas le trou)."""
|
||||
xs, ys, prec = [], [], None
|
||||
for t, v in points:
|
||||
if prec and (t - prec).total_seconds() > trou_h * 3600:
|
||||
xs.append(prec)
|
||||
ys.append(None)
|
||||
xs.append(t)
|
||||
ys.append(v)
|
||||
prec = t
|
||||
return xs, [float("nan") if v is None else v for v in ys]
|
||||
|
||||
|
||||
a = argparse.ArgumentParser()
|
||||
a.add_argument("dossier")
|
||||
a.add_argument("sortie")
|
||||
a.add_argument("debut", type=instant)
|
||||
a.add_argument("fin", type=instant)
|
||||
a.add_argument("--cam", default="")
|
||||
a.add_argument("--temp", action="store_true")
|
||||
a.add_argument("--cibles", default="")
|
||||
a.add_argument("--toutes", action="store_true")
|
||||
a.add_argument("--zone", action="append", default=[])
|
||||
a.add_argument("--ligne", action="append", default=[])
|
||||
a.add_argument("--hauteur", type=float, default=6.4)
|
||||
o = a.parse_args()
|
||||
|
||||
mes = charger(o.dossier)
|
||||
cibles = [c for c in mes if not est_reference(mes[c])] if o.toutes else [c for c in o.cibles.split(",") if c]
|
||||
panneaux = [c for c in o.cam.split(",") if c] + (["temp"] if o.temp else []) + (["y"] if cibles else [])
|
||||
fig, axes = plt.subplots(len(panneaux), 1, figsize=(12.5, o.hauteur), sharex=True, squeeze=False,
|
||||
gridspec_kw={"height_ratios": [1] * (len(panneaux) - 1) + [2 if cibles else 1]})
|
||||
axes = axes[:, 0]
|
||||
cam = [p for p in charger_camera(o.dossier) if o.debut <= p["t"] <= o.fin]
|
||||
for ax, p in zip(axes, panneaux):
|
||||
if p in NOMS:
|
||||
ax.plot(*coupee([(q["t"], q[p]) for q in cam if q[p] is not None]), color="#444", lw=1.2)
|
||||
ax.set_ylabel(NOMS[p].replace(" (", "\n("), fontsize=10)
|
||||
elif p == "temp":
|
||||
ax.plot(*coupee([(t, v) for t, v in charger_temperature(o.dossier) if o.debut <= t <= o.fin]), color="#c0392b", lw=1.2)
|
||||
ax.set_ylabel("Température de\nla station (°C)", fontsize=10)
|
||||
else:
|
||||
for c in cibles:
|
||||
pts = [(m["t"], m["corr_y"]) for m in filtrer(mes[c], o.debut, o.fin) if m["corr_y"] is not None]
|
||||
ax.plot(*coupee(pts), lw=1.3, label=f"{c} (corr_y)")
|
||||
ax.set_ylabel("Déplacement vertical\ncorr_y (px)", fontsize=10)
|
||||
ax.legend(fontsize=8 if o.toutes else 10, ncol=4 if o.toutes else len(cibles), loc="best")
|
||||
for z in o.zone:
|
||||
d, f = z.split("/")
|
||||
ax.axvspan(instant(d), instant(f), color="#bbb", alpha=0.45, lw=0)
|
||||
for t in o.ligne:
|
||||
ax.axvline(instant(t), color="#333", ls="--", lw=1)
|
||||
ax.grid(alpha=0.3)
|
||||
axes[-1].set_xlim(o.debut, o.fin)
|
||||
axes[-1].xaxis.set_major_locator(mdates.DayLocator(interval=max(1, (o.fin - o.debut).days // 8)))
|
||||
axes[-1].xaxis.set_major_formatter(mdates.DateFormatter("%d.%m"))
|
||||
fig.tight_layout()
|
||||
fig.savefig(o.sortie, dpi=110)
|
||||
print(o.sortie)
|
||||
@@ -0,0 +1,54 @@
|
||||
"""Montrer la cause qui se voit dans l'image (véhicule, obstacle, phares) : recadrages côte à côte,
|
||||
éclaircis, autour d'une cible marquée d'un cercle rouge.
|
||||
|
||||
.venv/bin/python .claude/skills/presentation/image-de-la-cause.py data/<STATION> <x> <y> <sortie.png> \
|
||||
<AAAAMMJJTHHMMZ>="<légende>" [<AAAAMMJJTHHMMZ>="<légende>" ...] [--demi 350]
|
||||
|
||||
x, y : pixel de la cible dans l'image entière (« centre du cadre » d'une vignette de vignettes.py).
|
||||
Une image par instant, prise dans <dossier>/images/<instant>_*.jpg ; mettre d'abord un instant sans la cause.
|
||||
"""
|
||||
import glob, os, sys
|
||||
from datetime import datetime, timedelta, timezone
|
||||
import matplotlib; matplotlib.use("Agg")
|
||||
import matplotlib.pyplot as plt, matplotlib.image as mi
|
||||
|
||||
args = sys.argv[1:]
|
||||
nommees = None # --cibles A,B : seulement ces noms écrits (les autres encombrent l'image) ; sans : tous
|
||||
if "--cibles" in args:
|
||||
i = args.index("--cibles"); nommees = set(args[i + 1].split(",")); del args[i:i + 2]
|
||||
demi = 350
|
||||
if "--demi" in args:
|
||||
i = args.index("--demi"); demi = int(args[i + 1]); del args[i:i + 2]
|
||||
dossier, x, y, sortie, *instants = args
|
||||
x, y = int(x), int(y)
|
||||
station = dossier.rstrip("/").split("/")[-1]
|
||||
|
||||
# le nom de chaque cible à sa position dans l'image (x, y de l'export, à la mesure la plus proche du premier instant)
|
||||
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "agent-tools"))
|
||||
from donnees import charger # noqa: E402
|
||||
t0 = datetime.strptime(instants[0].partition("=")[0], "%Y%m%dT%H%MZ").replace(tzinfo=timezone.utc)
|
||||
positions = {}
|
||||
for capteur, ms in charger(dossier).items():
|
||||
if nommees is not None and capteur not in nommees:
|
||||
continue
|
||||
proches = [m for m in ms if m.get("x") is not None and m.get("y") is not None and abs(m["t"] - t0) <= timedelta(hours=2)]
|
||||
if proches:
|
||||
m = min(proches, key=lambda m: abs(m["t"] - t0))
|
||||
positions[capteur] = (m["x"], m["y"])
|
||||
|
||||
fig, axs = plt.subplots(1, len(instants), figsize=(4 * len(instants), 4.3), squeeze=False)
|
||||
for ax, inst in zip(axs[0], instants):
|
||||
k, _, lab = inst.partition("=")
|
||||
img = mi.imread(glob.glob(f"{dossier}/images/{k}_*.jpg")[0]).astype(float)
|
||||
y0, x0 = max(y - demi, 0), max(x - demi, 0)
|
||||
img = img[y0:y + demi, x0:x + demi]
|
||||
img = (img / img.max()) ** 0.45 # éclaircir les ombres, les scènes de nuit sont sombres
|
||||
ax.imshow(img, cmap="gray", vmin=0, vmax=1)
|
||||
ax.add_patch(plt.Circle((x - x0, y - y0), 28, fill=False, color="red", lw=1.5))
|
||||
for capteur, (cx, cy) in positions.items():
|
||||
if x0 <= cx < x0 + img.shape[1] and y0 <= cy < y0 + img.shape[0]:
|
||||
ax.text(cx - x0, cy - y0 - 22, capteur, color="yellow", fontsize=8, ha="center", va="bottom",
|
||||
bbox={"facecolor": "black", "alpha": 0.5, "pad": 1, "edgecolor": "none"})
|
||||
ax.set_title(lab, fontsize=11); ax.axis("off")
|
||||
fig.suptitle("Image éclaircie ; en jaune, le nom des cibles", fontsize=12) # pas de nom de station : il va au client
|
||||
fig.tight_layout(); fig.savefig(sortie, dpi=100); print(sortie)
|
||||
@@ -0,0 +1,38 @@
|
||||
"""Les événements des détecteurs sur une plage, pour l'analyste : comme `detectors/categories.py`, mais chaque événement
|
||||
avec ses capteurs et sa phrase (la ligne de categories.py n'en donne que le nombre).
|
||||
|
||||
Usage : python tools/journal.py <dossier de station> --du AAAA-MM-JJ --au AAAA-MM-JJ (--au : jour exclu)
|
||||
"""
|
||||
import argparse
|
||||
import os
|
||||
import sys
|
||||
from datetime import datetime, timedelta, timezone
|
||||
|
||||
ICI = os.path.dirname(os.path.abspath(__file__))
|
||||
sys.path[:0] = [os.path.join(ICI, "detectors"), os.path.join(ICI, "agent-tools")]
|
||||
from categories import evenements # noqa: E402
|
||||
from donnees import charger, iso # noqa: E402
|
||||
|
||||
HISTORIQUE = timedelta(days=3) # jours d'avant donnés aux détecteurs, comme categories.py (règle du 2026-10-24)
|
||||
|
||||
p = argparse.ArgumentParser()
|
||||
p.add_argument("dossier")
|
||||
p.add_argument("--du", required=True)
|
||||
p.add_argument("--au", required=True)
|
||||
a = p.parse_args()
|
||||
if not os.path.isdir(a.dossier):
|
||||
sys.exit(f"Pas de dossier de données : {a.dossier}")
|
||||
jour = lambda d: datetime.strptime(d[:10], "%Y-%m-%d").replace(tzinfo=timezone.utc) # noqa: E731
|
||||
debut, fin = jour(a.du), jour(a.au)
|
||||
mesures = {s: k for s, ms in charger(a.dossier).items() if (k := [m for m in ms if debut - HISTORIQUE <= m["t"] < fin])}
|
||||
if not mesures:
|
||||
sys.exit(f"Aucune mesure de déplacement du {a.du} au {a.au} (exclu) dans {a.dossier}")
|
||||
evs = [v for v in evenements(mesures, fin, a.dossier) if v["end"] >= iso(debut)]
|
||||
print(f"{len(evs)} événement(s) du {a.du} au {a.au} (exclu), UTC" + ("" if evs else " : rien"))
|
||||
for v in evs:
|
||||
print(f"\n- {v['start']} → {v['end']} | {v['category']} | {v['episodes'][0]['label']}"
|
||||
f" | {'grisé' if v['ignore'] else 'gardé'}")
|
||||
print(f" capteurs : {', '.join(v['sensors']) or 'tous'}")
|
||||
print(f" phrase : {v['text']}")
|
||||
if len(v["episodes"]) > 1:
|
||||
print(" absorbés : " + ", ".join(f"{e['label']} {e['start'][5:16]}" for e in v["episodes"][1:]))
|
||||
@@ -0,0 +1,59 @@
|
||||
"""La stabilité verticale chiffrée de chaque cible : la médiane de corr_y jour par jour, et l'étendue de ces médianes.
|
||||
|
||||
Ce qui sert à dire au client « vos cibles sont restées à ±k px sur la période ». Mesures rejetées écartées
|
||||
(donnees.rejetee), plages --hors écartées (les nuits de visibilité réduite, un trou) ; un jour garde sa médiane s'il a
|
||||
au moins MIN mesures. Les références (global_ref) sont listées à part : elles ne mesurent pas l'ouvrage. Pas de verdict.
|
||||
|
||||
Usage : python tools/stabilite.py <dossier de station> --du AAAA-MM-JJ --au AAAA-MM-JJ [--hors D/F ...] (--au exclu)
|
||||
"""
|
||||
import argparse
|
||||
import os
|
||||
import statistics
|
||||
import sys
|
||||
from datetime import datetime, timedelta, timezone
|
||||
|
||||
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "agent-tools"))
|
||||
from donnees import charger, instant, rejetee # noqa: E402
|
||||
|
||||
MIN = 12 # mesures par jour : en dessous, la médiane du jour n'est pas gardée (une heure à 5 min)
|
||||
|
||||
p = argparse.ArgumentParser()
|
||||
p.add_argument("dossier")
|
||||
p.add_argument("--du", required=True)
|
||||
p.add_argument("--au", required=True)
|
||||
p.add_argument("--hors", nargs="*", default=[], help="plages écartées, D/F en AAAA-MM-JJTHH:MMZ")
|
||||
a = p.parse_args()
|
||||
if not os.path.isdir(a.dossier):
|
||||
sys.exit(f"Pas de dossier de données : {a.dossier}")
|
||||
jour = lambda d: datetime.strptime(d[:10], "%Y-%m-%d").replace(tzinfo=timezone.utc) # noqa: E731
|
||||
debut, fin = jour(a.du), jour(a.au)
|
||||
hors = [tuple(instant(x) for x in h.split("/")) for h in a.hors]
|
||||
|
||||
lignes, refs = [], []
|
||||
for capteur, ms in sorted(charger(a.dossier).items()):
|
||||
par_jour = {}
|
||||
for m in ms:
|
||||
if debut <= m["t"] < fin and m.get("corr_y") is not None and not rejetee(m) \
|
||||
and not any(d <= m["t"] < f for d, f in hors):
|
||||
par_jour.setdefault(m["t"].date(), []).append(m["corr_y"])
|
||||
medianes = [statistics.median(v) for v in par_jour.values() if len(v) >= MIN]
|
||||
if not medianes:
|
||||
continue
|
||||
ligne = (capteur, len(medianes), statistics.median(medianes), max(medianes) - min(medianes))
|
||||
(refs if ms[0].get("pattern_type") == "global_ref" else lignes).append(ligne)
|
||||
|
||||
if not lignes and not refs:
|
||||
sys.exit(f"Aucune mesure gardée du {a.du} au {a.au} (exclu) dans {a.dossier}")
|
||||
print(f"corr_y, médiane jour par jour, du {a.du} au {a.au} (exclu), UTC ; mesures rejetées"
|
||||
+ (f" et {len(hors)} plage(s) écartées" if hors else " écartées") + f" ; un jour compte s'il a ≥ {MIN} mesures")
|
||||
print("étendue = la plus haute médiane journalière moins la plus basse : de combien la cible a varié d'un jour à l'autre")
|
||||
for titre, groupe in (("Cibles", lignes), ("Références (ne mesurent pas l'ouvrage)", refs)):
|
||||
if groupe:
|
||||
print(f"\n{titre}\ncapteur jours médiane(px) étendue(px)")
|
||||
for c, n, med, et in groupe:
|
||||
print(f"{c} {n} {med:+.3f} {et:.3f}")
|
||||
if lignes:
|
||||
etendues = sorted(et for *_, et in lignes)
|
||||
print(f"\nCibles : étendue médiane {statistics.median(etendues):.3f} px, la plus grande {etendues[-1]:.3f} px "
|
||||
f"({max(lignes, key=lambda l: l[3])[0]}) ; {sum(e <= 0.05 for e in etendues)} cibles sur {len(etendues)} "
|
||||
f"à 0,05 px ou moins, {sum(e <= 0.1 for e in etendues)} à 0,1 px ou moins")
|
||||
Reference in new issue
Block a user