From 23dd7299ea368fe3561144890b49b40a64460ec5 Mon Sep 17 00:00:00 2001 From: maxime Date: Fri, 13 Nov 2026 11:13:04 +0100 Subject: [PATCH] =?UTF-8?q?Les=20d=C3=A9tecteurs=20du=20journal=20du=20mat?= =?UTF-8?q?in,=20copi=C3=A9s=20de=20Support-Agent=20(48a3092)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-Authored-By: Claude Opus 5.5 --- .gitignore | 1 + README.md | 13 ++ archive/visibilite_simple.py | 92 +++++++++ categories.py | 246 +++++++++++++++++++++++ displacement.py | 359 +++++++++++++++++++++++++++++++++ donnees.py | 162 +++++++++++++++ no_data.py | 43 ++++ obstruction.py | 38 ++++ target_issue.py | 193 ++++++++++++++++++ thermal_displacement.py | 313 +++++++++++++++++++++++++++++ visibility.py | 377 +++++++++++++++++++++++++++++++++++ 11 files changed, 1837 insertions(+) create mode 100644 .gitignore create mode 100644 archive/visibilite_simple.py create mode 100644 categories.py create mode 100644 displacement.py create mode 100644 donnees.py create mode 100644 no_data.py create mode 100644 obstruction.py create mode 100644 target_issue.py create mode 100644 thermal_displacement.py create mode 100644 visibility.py diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..c18dd8d --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +__pycache__/ diff --git a/README.md b/README.md index e69de29..b55819d 100644 --- a/README.md +++ b/README.md @@ -0,0 +1,13 @@ +# detectors + +Les détecteurs du journal du matin AIMsight : un détecteur par famille d'anomalie des déplacements (`visibility.py`, `obstruction.py`, `target_issue.py`, `thermal_displacement.py`, `no_data.py`, `displacement.py`), classés en événements par `categories.py`. Bibliothèque standard seulement (Python 3). + +`donnees.py` est la lecture des données qu'ils utilisent (dans Support-Agent, `agent-tools/donnees.py`). + +```bash +python3 categories.py --du AAAA-MM-JJ --au AAAA-MM-JJ +``` + +Le dossier de station a le format de `data//` de Support-Agent (`displacement/`, `metrics/`, `camera/`). + +Copie de `detectors/` et `agent-tools/donnees.py` de Support-Agent (commit 48a3092, 2026-11-13). C'est Support-Agent qui fait évoluer les détecteurs (`/detector-learner`) : resynchroniser cette copie après une optimisation. diff --git a/archive/visibilite_simple.py b/archive/visibilite_simple.py new file mode 100644 index 0000000..010e71c --- /dev/null +++ b/archive/visibilite_simple.py @@ -0,0 +1,92 @@ +"""Essai archivé le 2026-10-24 : version simple de la visibilité (point 11 du plan), moins bonne que la v0 restée en service +(detectors/visibilite.py) ; comparaison sur les six jeux : point 11 du plan. + +Journal du matin : visibilité, version simple. + +Une cible est rejetée quand son error_value dépasse son error_threshold. Seules comptent les cibles habituellement vues +(sous leur seuil au moins la moitié du temps sur l'export) : une cible que la caméra ne voit presque jamais ne dit rien +de la visibilité du moment (PS des Coudres : PM_G ; NIEDERHORN : sept références « e »). +1. Poor visibility : au moins NIVEAU des cibles rejetées, sur deux mesures d'affilée ou plus (une mesure plus basse entre + deux hautes compte haute : la part rejetée oscille autour du niveau, E-002). +2. Brief obstruction : la même chose sur une seule mesure (un passage). +3. Target obscured : une cible rejetée la plupart du temps (au moins la moitié de ses mesures), au moins CIBLE_MIN fois à + moins de CIBLE_ECART d'écart, quand la station, elle, voit clair. +Tous les épisodes sont grisés (ignore = True) ; les labels sont ceux que lit categories.py. +Usage : python3 detectors/visibilite.py (affiche les épisodes) +""" +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 + +NIVEAU = 0.2 # provisoire, réglé sur NORDEND d'octobre (buée du 08/10 : 10 à 20 % rejetées), E-002 (toile : 30 à 40 %) + # et E-005 (pluie : 30 à 60 %) ; balayé de 0,15 à 0,3 le 2026-10-24 +CIBLE_MIN = 3 # provisoire : rejets répétés d'une cible (v0) +CIBLE_ECART = timedelta(hours=6) # provisoire, réglé sur E-005 (feuilles : 7 rejets en 12 h, jusqu'à 5 h d'écart ; v0) + + +def _episode(debut, fin, label, capteurs): + return {"start": iso(debut), "end": iso(fin), "kind": "visibilite", "label": label, "text": "", + "ignore": True, "sensors": sorted(capteurs)} + + +def detect(mesures): + ratios = {} # capteur -> {t: error_value / error_threshold} + for s, v in mesures.items(): + r = {m["t"].replace(second=0, microsecond=0): 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: # habituellement vue + ratios[s] = r + instants = sorted({t for r in ratios.values() for t in r}) + rejetes = {t: {s for s, r in ratios.items() if r.get(t, 0) > 1} for t in instants} + vus = {t: sum(t in r for r in ratios.values()) for t in instants} + haut = [len(rejetes[t]) >= NIVEAU * vus[t] > 0 for t in instants] + for k in range(1, len(instants) - 1): # une mesure basse entre deux hautes + haut[k] = haut[k] or (haut[k - 1] and haut[k + 1]) + out = [] + + # 1 et 2 : suites de mesures où la station voit mal ; une seule mesure, c'est un passage. + k = 0 + while k < len(instants): + if not haut[k]: + k += 1 + continue + j = k + while j + 1 < len(instants) and haut[j + 1]: + j += 1 + cs = set().union(*(rejetes[instants[i]] for i in range(k, j + 1))) + out.append(_episode(instants[k], instants[j], "Poor visibility" if j > k else "Brief obstruction", cs)) + k = j + 1 + + # 3 : une cible rejetée la plupart du temps pendant que la station voit clair. + clair = {t for t, h in zip(instants, haut) if not h} + refs = {s for s, v in mesures.items() if v[0]["pattern_type"] == "global_ref"} + cibles = [] + for s, r in ratios.items(): + if s in refs: + continue + ts = [t for t in sorted(r) if t in clair and r[t] > 1] + groupe = ts[:1] + for t in ts[1:] + [None]: + if t is not None and t - groupe[-1] <= CIBLE_ECART: + groupe.append(t) + continue + mesurees = [u for u in r if groupe and groupe[0] <= u <= groupe[-1]] + if len(groupe) >= CIBLE_MIN and 2 * len(groupe) >= len(mesurees): + cibles.append((groupe[0], groupe[-1], s)) + groupe = [t] + for a, b, s in sorted(cibles): # les cibles masquées en même temps forment un seul épisode + if out and out[-1]["label"] == "Target obscured" and iso(a) <= out[-1]["end"]: + out[-1]["end"] = max(out[-1]["end"], iso(b)) + out[-1]["sensors"] = sorted(set(out[-1]["sensors"]) | {s}) + else: + out.append(_episode(a, b, "Target obscured", {s})) + return sorted(out, 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])) diff --git a/categories.py b/categories.py new file mode 100644 index 0000000..5cafa35 --- /dev/null +++ b/categories.py @@ -0,0 +1,246 @@ +"""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 de plusieurs cibles n'est pas gardée : un vrai mouvement agite aussi les courbes ; + le décalage d'une seule cible ne retire pas la turbulence de toute la scène, et une turbulence n'absorbe que les sauts + revenus qui commencent pendant elle, pas celui de la veille qui revient dans sa journée (/detector-learner Visibility, + modification 1, S1 : WILDSTRUBEL) ; +- deux événements de même sorte à moins de MERGE n'en font qu'un ; deux Obstruction (Target obscured, Brief + obstruction), seulement s'ils partagent un capteur (/detector-learner Obstruction, modification 1 : S1, des cibles + différentes enchaînées en un événement de plusieurs jours ; S3, des passages de quelques minutes en une heure entière) ; + deux Target issue aussi : chaque cible à problème garde ses bornes (/detector-learner Target issue, modification 1, S3) ; + un passage n'absorbe que les sauts revenus dans MERGE après son instant (S3 : pas le saut de 30 h d'une autre cible). +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 (une ligne par événement : famille, sorte, capteurs) + ... [--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"]) + # un vrai mouvement n'est jamais pris pour de la turbulence ; le décalage d'une seule cible n'est pas un mouvement de la scène + checks = [e for e in eps if e["label"] in DECALAGES and len(e["sensors"]) > 1] + 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"] != "Heat shimmer" or h["start"] <= e["start"]) + and (h["label"] != "Brief obstruction" or e["start"] == h["start"] + and datetime.fromisoformat(e["end"]) - datetime.fromisoformat(h["start"]) <= MERGE)), 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]) and (g[0]["kind"] not in ("Obstruction", "Target issue") + or set(g[0]["sensors"]) & {s for e in m for s in e["sensors"]})), 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 diff --git a/displacement.py b/displacement.py new file mode 100644 index 0000000..d050b70 --- /dev/null +++ b/displacement.py @@ -0,0 +1,359 @@ +"""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. +/detector-learner Target issue, modification 1, S2 : BASCULE de 6 h à 36 h ; une cible qui bascule un jour, pendant une +gêne de toute la scène (pluie, brouillard, nuit de mauvaise visibilité), n'est pas une cible à problème (familles.md : des +rejets propres presque chaque jour) ; ses sauts revenus vont à la gêne qui les chevauche, sinon restent Displacement. +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=36) # provisoire : une cible à problème bascule plusieurs jours (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) ou une nuit de gêne + # (NORDEND, JUNGFRAU : 12 à 28 h dans une perte de visibilité), un saut revenu, absorbé par son hôte +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"]) diff --git a/donnees.py b/donnees.py new file mode 100644 index 0000000..cdae427 --- /dev/null +++ b/donnees.py @@ -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") diff --git a/no_data.py b/no_data.py new file mode 100644 index 0000000..7646e2d --- /dev/null +++ b/no_data.py @@ -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 (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) diff --git a/obstruction.py b/obstruction.py new file mode 100644 index 0000000..d8fe016 --- /dev/null +++ b/obstruction.py @@ -0,0 +1,38 @@ +"""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. +Un capteur déjà dans un épisode Target issue (Degraded target, Target stuck) qui le chevauche n'est pas rendu en +Obstruction : sa courbe est déjà à ignorer, la famille est Target issue (frontière « Target issue ou épisode d'une autre +famille » de labeling/familles.md ; /detector-learner Obstruction, modification 1 : S1, cibles à problème de FLORIDA, +NORDEND, SNCF01, NIEDERHORN, JUNGFRAU, CLARIDEN découpées en Target obscured ; S3, leurs rejets isolés en Brief obstruction). +Usage : python3 detectors/obstruction.py (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): + ti = target_issue.episodes(mesures) + issues = [e for e in ti if e["kind"] == "Target issue"] + out = [] + for e in visibility.episodes(mesures) + ti: + if e["kind"] != "Obstruction": + continue + pris = {s for h in issues if h["start"] <= e["end"] and h["end"] >= e["start"] for s in h["sensors"]} + if not (e := {**e, "sensors": [s for s in e["sensors"] if s not in pris]})["sensors"]: # sans les capteurs déjà + continue # en Target issue + out.append(e) + return sorted(out, 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"]) diff --git a/target_issue.py b/target_issue.py new file mode 100644 index 0000000..9315c75 --- /dev/null +++ b/target_issue.py @@ -0,0 +1,193 @@ +"""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. + Pour la cible à problème, la suite est reliée : au plus PONT jours non dégradés de suite ne la coupent pas, et elle + demande alors SEMAINE jours de son premier à son dernier jour dégradé, à PART de rejets sur tous ses jours (« des rejets + propres à la cible presque chaque jour de la plage ») ; les Target obscured qu'elle couvre n'existent plus + (/detector-learner Obstruction, modification 1, S1 : FLORIDA Sellette 6 et Massif 2, SNCF01 F4.3 et F4.4, NORDEND + CTR01, NIEDERHORN e01, découpées en Target obscured par un jour sous PART ; BREITHORN, véhicules garés, inchangé). + La cible à problème juge la régularité plutôt que la part du jour : un jour y est dégradé dès PART_SEMAINE (le quart) + de ses instants calmes rejetés, et PONT vaut un jour ; la cible cachée par moments garde PART. Une cible rejetée chaque + jour aux mêmes heures, le jour seulement ou la nuit seulement, reste sous la moitié et n'était pas vue + (/detector-learner Target issue, modification 1, S1 : WILDSTRUBEL R3, de 04:00 à 16:00 chaque jour, vue seulement les + jours sans mesure de nuit ; NORDEND PR04 et CTR01, NIEDERHORN PWD_IMP_B08_024_C09 et e01, SNCF01 F4.3, plus tôt). +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 (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 » +PART_SEMAINE = 0.25 # le quart des instants calmes rejetés, chaque jour d'une semaine ou plus : une cible à problème, + # même rejetée seulement le jour ou seulement la nuit (/detector-learner Target issue, modification 1, S1) +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) +PONT = 1 # provisoire : jour non dégradé qui ne coupe pas une suite de jours dégradés (4) ; à 2, les véhicules garés + # de BREITHORN (deux jours, puis rien deux jours, puis un) feraient une semaine au quart +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()): + cache = [] # suites reliées d'au moins SEMAINE jours, à part de rejets PART_SEMAINE : une cible à problème + for su in _suites(js, min_instants, PONT, PART_SEMAINE): + part = sum(c[0] for c in su) / sum(c[1] for c in su) + if len(su) < SEMAINE or part < PART_SEMAINE: + continue + n = sum(c[0] / c[1] >= PART_SEMAINE for c in su) + r = _rejets([m for m in mesures[s] if su[0][2] <= m["t"] <= su[-1][3]]) + cache.append((su[0][2], su[-1][3])) + out.append({"start": iso(r[0][0]), "end": iso(r[-1][1]), "kind": "Target issue", "label": "Degraded target", + "text": f"{s} was rejected in {round(100 * part)} % of the measurements when the other targets were " + f"seen, on {n} of {len(su)} days.", "ignore": True, "sensors": [s]}) + for su in _suites(js, min_instants, 0, PART): # par moments : un épisode par suite de mesures rejetées + if len(su) < MIN_JOURS or any(a <= su[0][2] <= b for a, b in cache): + 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." + out += [{"start": iso(a), "end": iso(b), "kind": "Obstruction", "label": "Target obscured", "text": text, + "ignore": True, "sensors": [s]} + for a, b in _rejets([m for m in mesures[s] if su[0][2] <= m["t"] <= su[-1][3]])] + return sorted(out + colles(mesures, min_instants), key=lambda e: e["start"]) + + +def _suites(js, min_instants, pont, part): + """{jour: [rejetés, calmes, première, dernière]} -> suites de jours dégradés ; au plus pont jours non dégradés de suite + entre deux jours dégradés ne coupent pas la suite (ils en sont) ; un jour qui ne compte pas ne la coupe pas.""" + suites, cur, creux = [], [], [] + for j in sorted(js): + rej, calmes = js[j][:2] + if calmes < min_instants: + continue + if rej / calmes >= part: + cur += creux + [js[j]] + creux = [] + elif cur: + creux.append(js[j]) + if len(creux) > pont: + suites.append(cur) + cur, creux = [], [] + return suites + ([cur] if cur else []) + + +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) diff --git a/thermal_displacement.py b/thermal_displacement.py new file mode 100644 index 0000000..27ef80d --- /dev/null +++ b/thermal_displacement.py @@ -0,0 +1,313 @@ +"""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. Un jour incomplet (au moins + PARTIEL heures, moins de 20) n'entre pas dans le profil, mais sa ressemblance se mesure sur les heures qu'il a : un + trou d'une demi-journée ne lui ôte plus son épisode (/detector-learner Thermal displacement, modification 1, S4 ; + à HEURES_MIN = 12 ou 16, les jours incomplets faussaient le profil, NIEDERHORN reculait). +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 » du départ à l'heure du plus grand écart au niveau de nuit (le pic), puis « Thermal + contraction » jusqu'au retour. Les heures chaudes disent qu'il y a un cycle ; ses bornes se lisent plus bas, à BORD + fois l'amplitude : le départ, en remontant du pic tant que l'écart reste ≥ BORD (au plus jusqu'à l'heure la plus + calme du profil) ; le retour, en descendant du pic jusqu'à ce qu'il repasse sous BORD, après minuit s'il le faut, au + plus jusqu'au départ du lendemain : un retour lent la nuit enchaîne les cycles (/detector-learner Thermal + displacement, modification 1, S1 : avant, la vague s'arrêtait à la dernière heure chaude, le soir et la nuit + manquaient). 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. +La caméra bouge avec le froid (/detector-learner Thermal displacement, modification 1, S3) : faute de cycle, aussi un +« Camera thermal movement » là où la pose de la caméra (tilt, rotation ou échelle) s'écarte de sa médiane du jour d'avant +d'au moins FROID bruits, pendant que la température de la station (detect la déclare, D-124) tombe sous la sienne d'au +moins FROID bruits la même heure ; bruit : la médiane des variations sur une heure (sur un pas, à une mesure toutes les +4 h), pour que le seuil ne dépende pas de la cadence. Les cibles peuvent s'écarter en sens opposés ou rester presque +immobiles (la compensation absorbe le mouvement) : la règle des glissades ne le voit pas. Les instants qui se suivent dans +la pose font un épisode. Sans pose ou sans température, rien. FROID = 3 prenait plus d'instants Displacement de NEBRASKA +et de MICHIGAN ; la chaleur n'est pas prise : par beau temps, c'est le cycle du jour. +""" +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 dans le profil s'il a au moins 20 heures mesurées +PARTIEL = 12 # provisoire : un jour incomplet d'au moins 12 heures reçoit son épisode s'il ressemble au profil +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) +BORD = 0.1 # provisoire : bornes de la vague (départ, retour), en part de l'amplitude ; CHAUD dit s'il y a un cycle +ECART = 3 # provisoire : glissade commune, en bruits (médiane des pas) d'écart à la médiane du jour d'avant +FROID = 4 # provisoire : la caméra bouge avec le froid, en bruits d'une heure d'écart au jour d'avant (pose, température) +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, tous = {}, {} + for d, hs in jours.items(): + if len(hs) >= PARTIEL: + med = statistics.median(v for l in hs.values() for v in l) + tous[d] = {h: statistics.mean(l) - med for h, l in hs.items()} + if len(hs) >= HEURES_MIN: + J[d] = tous[d] + 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 tous.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)] + if len(hs) >= 3: + 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, temperature=(), camera=()): + """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) ; sinon, les glissades de la caméra (avec le froid).""" + return (_episodes(mesures, ("corr_x", "corr_y"), "Thermal", False) or + _episodes(mesures, ("x", "y"), "Camera thermal", True) or glissades(mesures, temperature, camera)) + + +def _signes(ms, col, heure=False, seuil=None): + """{instant: +1 ou -1} où la mesure s'écarte d'au moins ECART bruits de la médiane du jour d'avant ; bruit : la + médiane des pas d'une mesure à la suivante, ou, heure, des variations sur une heure (un pas si la cadence est lente).""" + k = [(m["t"], m[col]) for m in ms if m[col] is not None] + if len(k) < 3: + return {} + pas = statistics.median((b - a).total_seconds() for (a, _), (b, _) in zip(k, k[1:])) if heure else 0 + n = max(1, round(3600 / pas)) if pas else 1 + bruit = statistics.median(abs(k[i + n][1] - k[i][1]) for i in range(len(k) - n)) if len(k) > n else 0 + 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)) >= (seuil or 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 _froid(mesures, temperature, camera): + """[(début, fin)] des suites d'instants où la pose de la caméra (tilt, rotation ou échelle) s'écarte de son jour + d'avant pendant que la température tombe sous le sien, d'au moins FROID bruits d'une heure ; vide sans l'une d'elles.""" + ts = [m["t"] for ms in mesures.values() for m in ms] + heure = lambda t: t.replace(minute=0, second=0, microsecond=0) # noqa: E731 + froid = {heure(t) for t, x in _signes([{"t": t, "T": v} for t, v in temperature], "T", True, FROID).items() if x < 0} + pose = [p for p in camera if min(ts) <= p["t"] <= max(ts)] if ts else [] + vus = {t for c in ("tilt", "rotation", "scale") for t in _signes(pose, c, True, FROID) if heure(t) in froid} + episodes = [] # les instants qui se suivent dans la pose font un épisode + for i, p in enumerate(pose): + if p["t"] in vus: + if episodes and episodes[-1][2] == i - 1: + episodes[-1][1:] = [p["t"], i] + else: + episodes.append([p["t"], p["t"], i]) + return [(a, b) for a, b, _ in episodes] + + +def glissades(mesures, temperature=(), camera=()): + """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 ; + ou la pose de la caméra s'en écarte avec le froid (_froid).""" + 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 + _froid(mesures, temperature, camera)] + + +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 + repos = min(range(24), key=lambda h: e[h]) + a = pic # départ : on remonte du pic tant que le profil reste au-dessus de BORD, jusqu'à l'heure la plus calme + while (a - 1) % 24 != repos and e[(a - 1) % 24] >= BORD: + a -= 1 + b = pic + 1 # retour : jusqu'à ce que le profil repasse sous BORD, au plus jusqu'au départ suivant + while b < a + 24 and e[b % 24] >= BORD: + b += 1 + derniere = max(m["t"] for ms in mesures.values() for m in ms) + 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 d'au moins PARTIEL heures, 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, u, v in ((f"{nom} expansion", a, pic), (f"{nom} contraction", pic, b)): + debut, fin = minuit + timedelta(hours=u), min(minuit + timedelta(hours=v), derniere) + if fin > debut: + episodes.append({"start": iso(debut), "end": iso(fin), + "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)}") diff --git a/visibility.py b/visibility.py new file mode 100644 index 0000000..103caa0 --- /dev/null +++ b/visibility.py @@ -0,0 +1,377 @@ +"""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). + Aussi, un passage devant une ou deux cibles, ou une seule référence : à un instant, moins de BREF_MIN capteurs + rejetés à plus de FACTEUR fois leur médiane (sans K_MAD : de jour, la turbulence gonfle la MAD), au plus une + référence, aucun d'eux rejeté à l'instant d'avant ni à celui d'après, et moins de BREF_MIN capteurs hauts + (/detector-learner Obstruction, modification 1, S3 : véhicules, passants, insectes devant une ou deux cibles de + WILDSTRUBEL, NIEDERHORN, LENZSPITZE ; une référence cachée par un camion à JUNGFRAU, BREITHORN). +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. + L'écart est d'au moins deux pas de mesure, et deux rejets suffisent quand CIBLE_MIN pas ne tiennent pas dans + CIBLE_ECART (/detector-learner Obstruction, modification 1, S6 : à une mesure toutes les 4 h, les véhicules garés + la nuit devant COLI22, COLI24, POUI22 de BREITHORN ne font que deux ou trois rejets). +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. +8. Gêne diffuse, rejets ou non (/detector-learner Visibility, modification 1, S2) : à chaque instant, la médiane, sur les + capteurs, de l'error_value en MAD au-dessus de la médiane de chacun ; au moins SUITE_MIN instants de suite à K_DIFFUS + ou plus font une Poor visibility « reduced ». Une gêne diffuse tout entière dans une turbulence est la turbulence : pas + d'épisode (sinon elle absorbait le saut revenu de la veille, WILDSTRUBEL le 04.10). Trouve les baisses de visibilité de + toute la scène sans rejet de JUNGFRAU, FLORIDA, NORDEND ; à 2, des nuits étiquetées thermiques à JUNGFRAU, à 3 la + moitié du gain. + +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 %) +K_DIFFUS = 2.5 # provisoire : gêne diffuse (8) ; /detector-learner Visibility, modification 1, S2 +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).""" + pas = _pas(mesures) + ecart = ECART * pas + 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} + forts, refus = {}, {} # t -> {capteurs rejetés à plus de FACTEUR fois leur médiane}, {capteurs rejetés} + 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 rejete: + refus.setdefault(m["t"], set()).add(s) + if x > FACTEUR * med: + forts.setdefault(m["t"], set()).add(s) + 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])) + elif 0 < len(f := forts.get(t, set())) < BREF_MIN and n(t) < BREF_MIN and len(f & refs) <= 1 and not f & set().union( + *(refus.get(instants[j], set()) for j in (i - 1, i + 1) if 0 <= j < len(instants))): + # une ou deux cibles, ou une référence, rejetées à cette seule mesure, à FACTEUR fois leur médiane + out.append(_episode(t, t, "Brief obstruction", f"{len(f)} point{'s were' if len(f) > 1 else ' was'} poorly seen " + "for a single measurement, then came back: probably something passing; ignore this point on the " + "curves.", f)) + + # 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], max(CIBLE_ECART, 2 * pas)): + if len(l) >= (CIBLE_MIN if CIBLE_MIN * pas <= CIBLE_ECART else 2) 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 diffuse(mesures): + """Gêne diffuse (8) : les suites d'au moins SUITE_MIN instants où la médiane, sur les capteurs, de l'error_value en MAD + au-dessus de la médiane de chacun atteint K_DIFFUS, rejets ou non -> Poor visibility « reduced ».""" + z = {} # t -> {capteur: écart en MAD} + 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: + if m["error_value"] is not None: + z.setdefault(m["t"], {})[s] = (m["error_value"] - med) / mad + hauts = [(t, None) for t in sorted(z) if statistics.median(z[t].values()) >= K_DIFFUS] + return [_episode(a, b, "Poor visibility", "", {s for t in l for s, x in z[t].items() if x >= K_DIFFUS}, "reduced") + for a, b, _, l in _grouper(hauts, ECART * _pas(mesures)) if len(l) >= SUITE_MIN] + + +def detect(mesures): + tremble = turbulence(mesures) # une gêne diffuse pendant une turbulence est la turbulence (8) + return ([e for e in episodes(mesures) if e["kind"] == "Visibility"] + tremble + + [e for e in diffuse(mesures) if not any(t["start"] <= e["start"] and e["end"] <= t["end"] for t in tremble)]) + + +# --- 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 en plus de l'habitude de leur capteur (sa part de rejets sur l'export) : c'est alors de la mauvaise +# visibilité, autre règle. Une cible toujours rejetée (Target issue) ne compte pas (/detector-learner Visibility, +# modification 1, S1 : WILDSTRUBEL, R3 rejetée toute la journée, les jours de turbulence étaient écartés). +# 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 % ; rejets en plus de l'habitude + # depuis /detector-learner Visibility, modification 1, S1 (WILDSTRUBEL : 4 à 14 %, contre 9 à 22 % bruts) +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]) + taux = {s: sum(m["corr_x"] is None for m in ms) / len(ms) for s, ms in mesures.items()} # rejets habituels + episodes = [] + for b in blocs: + debut, fin = b[0], b[-1] + HEURE + par = {s: [m for m in ms if debut <= m["t"] < fin] for s, ms in mesures.items()} + nouveaux = sum(max(0, sum(m["corr_x"] is None for m in d) - taux[s] * len(d)) for s, d in par.items()) + if fin - debut < DUREE_MIN or nouveaux > REJET_MAX * sum(map(len, par.values())): + 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"])