API: support page with two Claude API clients, support and analyst (D-133)

Self-contained sub-project API/: a local support page where Marc pastes a
client's mail; a support agent and an analyst agent stay alive for the session
and produce a slide PDF that answers the client's question. Tools, detectors,
knowledge and Typst brand are copied (API/PROVENANCE.md). First real case:
Crissier (LENZSPITZE), workflow validated.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
maximeandClaude Opus 5.5 committed 2026-11-05 12:58:39 +01:00
1 parent 874f6bf7ea
commit 8ba75b92fa
130 files changed
+42094

No files matched your search

+235
View File
@@ -0,0 +1,235 @@
"""Journal du matin : des épisodes des détecteurs aux événements, un par famille.
Un détecteur par famille des étiquettes (labeling/familles.md) : visibility.py, obstruction.py, target_issue.py,
thermal_displacement.py, no_data.py, displacement.py. La catégorie d'un événement est sa famille, le champ kind de ses
épisodes ; leur label en dit la sorte (Poor visibility, Heat shimmer, Brief obstruction, Slow drift…). Règles :
- un saut revenu à la normale (SAUT) qui chevauche un épisode de HOTES (perte de visibilité, passage, turbulence, et en
dernier l'effet thermique, s'il touche plusieurs cibles) y est absorbé : il en prend la cause et la famille ; sinon il
reste Displacement, sans cause établie, à vérifier sur les images (familles.md, « Un saut puis le retour ») ; un passage
(Brief obstruction, un seul instant) n'absorbe que les sauts qui commencent à son instant, pas ceux de plusieurs jours
qu'il croise (/detector-learner Displacement, modification 1, S5) ;
- une dérive lente ou un saut revenu dont toutes les cibles sont dans un épisode Target issue qui le chevauche y est absorbé
(la courbe d'une cible à problème est à ignorer, familles.md) ;
- un décalage qui dure, ou trop récent pour savoir (DECALAGES), n'est jamais absorbé ;
- une turbulence qui chevauche un décalage n'est pas gardée : un vrai mouvement agite aussi les courbes ;
- deux événements de même sorte à moins de MERGE n'en font qu'un.
Chaque événement reçoit sa phrase, en anglais (le site) : ce qui s'est passé et quoi en faire, comme le dit la colonne
« Pour le client » de familles.md ; la cause n'est dite que si la sorte l'établit, sinon les images la montrent.
Pas de fonction detect : le chargeur ne prend pas ce fichier pour un détecteur.
Usage : python3 detectors/categories.py <dossier de station> (une ligne par événement : famille, sorte, capteurs)
... <dossier> [--du AAAA-MM-JJ] [--au AAAA-MM-JJ] [--tranche 3] [--historique N] (tri en lot : chaque tranche
de N jours classée seule, avec les jours d'historique d'avant s'ils existent ; seuls les événements qui touchent
la tranche sont montrés ; « rien » pour une tranche calme)
"""
import functools
import importlib.util
import inspect
import os
import sys
from datetime import datetime, timedelta, timezone
from pathlib import Path
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "agent-tools"))
from donnees import charger, charger_camera, charger_metriques, charger_temperature, iso # noqa: E402
# Ce qu'un détecteur peut lire de la station en plus des mesures, s'il le déclare dans detect (D-124, D-134) :
# temperature [(t, °C)], médiane horaire des composants ; camera [pose] (pan, tilt, rotation, scale, sigma0) ;
# metriques {nom: [(t, valeur)]}, toutes les métriques numériques (sensor_CPU_deg_c, sensor_GPU_deg_c, BusVoltage…).
CONTEXTE = {"temperature": charger_temperature, "camera": charger_camera, "metriques": charger_metriques}
@functools.lru_cache(maxsize=None)
def _contexte(dossier, cle):
return CONTEXTE[cle](dossier)
# Les familles de labeling/familles.md, dans l'ordre des lignes de la frise ; ignore : zone grisée (None : comme le
# disent ses épisodes : une perte de visibilité totale, une turbulence forte) ; process : bouton Images, rien, ou Images
# et lien vers Diagnosis.
CATEGORIES = {
"Visibility": {"ignore": None, "process": "images"},
"Obstruction": {"ignore": True, "process": "images"},
"Target issue": {"ignore": True, "process": "images"},
"Thermal displacement": {"ignore": False, "process": "aucun"},
"No data": {"ignore": False, "process": "aucun"},
"Displacement": {"ignore": False, "process": "verifier"},
}
SAUT = "Sudden jump, back to normal" # un saut revenu : sa cause, s'il chevauche un hôte ; sinon Displacement
DECALAGES = {"Lasting shift", "Jump, not back yet", "Large shift"} # à vérifier : jamais absorbés
HOTES = {"Poor visibility", "Brief obstruction", "Heat shimmer", "Thermal expansion", "Thermal contraction",
"Camera thermal expansion", "Camera thermal contraction", "Camera thermal movement"} # disent la cause d'un saut revenu qui les chevauche
MERGE = timedelta(hours=1) # même sorte à moins d'une heure : un seul événement (règle validée, 2026-10-24)
def detecteurs():
"""Modules de detectors/*.py qui ont detect ; un fichier qui ne se charge pas est sauté avec un
message."""
mods = []
for path in sorted(Path(__file__).resolve().parent.glob("*.py")):
if path == Path(__file__).resolve():
continue
try:
spec = importlib.util.spec_from_file_location(f"journal_{path.stem}", path)
mod = importlib.util.module_from_spec(spec)
spec.loader.exec_module(mod)
except Exception as e: # noqa: BLE001 (prototype : un détecteur cassé ne bloque pas la page)
print(f"Journal : {path.name} sauté ({type(e).__name__}: {e})", file=sys.stderr)
continue
if hasattr(mod, "detect"):
mods.append(mod)
return mods
def categorie(ep):
return ep["kind"]
def sorte(ep):
"""La sorte d'un épisode dans sa famille : les décalages ensemble, l'effet thermique sans « Camera », la perte de
visibilité par niveau."""
label = "shift" if ep["label"] in DECALAGES else ep["label"].removeprefix("Camera ").capitalize()
return ep["kind"], label, ep.get("level")
def thermique(ep):
return ep["kind"] == "Thermal displacement"
def overlap(a, b):
return a["start"] <= b["end"] and a["end"] >= b["start"] # heures donnees.iso : l'ordre du texte est celui du temps
def targets(n):
return "one target" if n == 1 else f"{n} targets"
def phrase(groupe, sensors, references):
"""Phrase du journal d'un événement (validées par l'utilisateur le 2026-10-24), d'après la sorte de son épisode
principal ; un saut absorbé ajoute qu'il a la même cause."""
n, one, ep = len(sensors), len(sensors) == 1, groupe[0]
sauts = [e for e in groupe[1:] if e["label"] == SAUT]
jumped = len({s for e in sauts for s in e["sensors"]})
lasting = len({s for e in groupe if e["label"] in DECALAGES for s in e.get("lasting", [])})
refs = ", including the reference targets" if references & set(sensors) else ""
camera = ep["label"].startswith("Camera")
large = any(e["label"] == "Large shift" for e in groupe)
sort = "shift" if ep["label"] in DECALAGES else f"{ep['label']} {ep['level']}" if ep.get("level") else ep["label"]
text = {
"Poor visibility none": f"The camera could not see {targets(n)} clearly{refs}. "
"The curves in this period are not reliable: ignore them.",
"Poor visibility reduced": f"The camera saw {targets(n)} less clearly than usual{refs}. "
"The data in this period are less precise: use them with care.",
"Brief obstruction": f"Something passed in front of {targets(n)} for a single measurement. Ignore this point on the curves.",
"Target obscured": f"{', '.join(sensors)} {'was' if one else 'were'} hidden several times while the targets around "
f"{'it' if one else 'them'} stayed clear. Ignore {'its curve' if one else 'their curves'} in this period.",
"Heat shimmer": "Warm air made the readings shake. The small fast wiggles are not movement.",
"expansion": ("The camera support expands in the day heat; the curves are corrected for it."
if camera else "The structure expands in the day heat.") + " This daily wave is normal: nothing to do.",
"contraction": ("The camera support contracts as it cools down; the curves are corrected for it."
if camera else "The structure contracts as it cools down.") + " This daily wave is normal: nothing to do.",
SAUT: f"{targets(n).capitalize()} jumped and came back. The cause is not established: look at the images.",
"shift": (f"{targets(n).capitalize()}, most of the targets, shifted together: everything moved." if large
else f"{targets(n).capitalize()} shifted and {'has' if one else 'have'} not come back yet." if not lasting
else f"{targets(n).capitalize()} shifted and stayed shifted." if lasting == n
else f"{targets(n).capitalize()} shifted; {lasting} of them stayed shifted.")
+ " Check whether the structure moved: look at the images.",
}.get(sort.split()[-1] if thermique(ep) else sort, ep["text"]) # No data, Target issue, Slow drift : le texte du détecteur
if ep["kind"] == "Target issue":
text += f" Ignore {'its curve' if one else 'their curves'} in this period and look at the images of the target."
if not jumped:
return text
return text + (f" The jump of {targets(jumped)} in this period has the same cause." if len(sauts) == 1
else f" The jumps of {targets(jumped)} in this period have the same cause.")
def evenement(groupe, references):
"""Épisodes d'un même événement, le principal en tête -> événement."""
cat, so = categorie(groupe[0]), sorte(groupe[0])
c = CATEGORIES.get(cat, {"ignore": None, "process": "aucun"})
sensors = [] if any(not e["sensors"] for e in groupe) else list(dict.fromkeys(s for e in groupe for s in e["sensors"]))
main = [e for e in groupe if sorte(e) == so] # la durée est celle des épisodes principaux, pas des sauts absorbés
return {"start": min(e["start"] for e in main), "end": max(e["end"] for e in main), "category": cat,
"label": cat, "text": phrase(groupe, sensors, references),
"ignore": c["ignore"] if c["ignore"] is not None else any(e["ignore"] for e in main),
"sensors": sensors, "process": c["process"], "episodes": groupe}
def classer(episodes, references=frozenset()):
"""Épisodes de tous les détecteurs -> événements triés par début (règles : docstring du module) ; references : les
capteurs global_ref, pour la phrase."""
eps = sorted(episodes, key=lambda e: e["start"])
checks = [e for e in eps if e["label"] in DECALAGES] # un vrai mouvement n'est jamais pris pour de la turbulence
eps = [e for e in eps if e["label"] != "Heat shimmer" or not any(overlap(e, c) for c in checks)]
# la vague thermique n'absorbe qu'en dernier (un saut d'un passage ou d'une pluie va à eux), et que les sauts de
# plusieurs cibles : la vague les fait bouger ensemble, une cible seule qui saute n'est pas la vague (C2 de E-003)
hosts = sorted((e for e in eps if e["label"] in HOTES), key=thermique)
host = {id(e): next((h for h in hosts if overlap(e, h) and (len(e["sensors"]) > 1 or not thermique(h))
and (h["label"] != "Brief obstruction" or e["start"] == h["start"])), None)
for e in eps if e["label"] == SAUT}
# une dérive ou un saut revenu dont toutes les cibles sont dans un épisode Target issue qui le chevauche : sa courbe
# est à ignorer, il en prend la famille (/detector-learner Displacement, modification 1, S6)
host.update({id(e): h for e in eps if e["label"] in (SAUT, "Slow drift") and not host.get(id(e))
and (h := next((h for h in eps if h["kind"] == "Target issue" and overlap(e, h)
and set(e["sensors"]) <= set(h["sensors"])), None))})
groupes = {id(e): [e] for e in eps if not host.get(id(e))}
for e in eps:
if host.get(id(e)):
groupes[id(host[id(e)])].append(e)
merged = []
for g in groupes.values():
prev = next((m for m in reversed(merged) if sorte(m[0]) == sorte(g[0])), None)
end = max((e["end"] for e in prev if sorte(e) == sorte(g[0])), default=None) if prev else None
if end and datetime.fromisoformat(g[0]["start"]) - datetime.fromisoformat(end) < MERGE:
prev += g
else:
merged.append(g)
return sorted((evenement(g, references) for g in merged), key=lambda v: v["start"])
def evenements(mesures, fin=None, dossier=None):
"""Mesures (donnees.charger) -> événements de tous les détecteurs : ce que la page reçoit dans D.journal. Un détecteur
reçoit en plus ce que sa fonction detect déclare : fin, la fin de la fenêtre lue (tri en lot), pour un trou qui la
touche ; une clé de CONTEXTE, lue dans le dossier de la station (une fois par dossier), vide sans dossier."""
episodes = []
for mod in detecteurs():
try:
params = inspect.signature(mod.detect).parameters
kw = {k: _contexte(dossier, k) if dossier else {} if k == "metriques" else [] for k in CONTEXTE if k in params}
if "fin" in params:
kw["fin"] = fin
episodes += mod.detect(mesures, **kw)
except Exception as e: # noqa: BLE001
print(f"Journal : {mod.__name__} sauté ({type(e).__name__}: {e})", file=sys.stderr)
return classer(episodes, {s for s, ms in mesures.items() if ms[0]["pattern_type"] == "global_ref"})
if __name__ == "__main__":
import argparse
p = argparse.ArgumentParser(description="Une ligne par événement ; --tranche : chaque tranche classée seule.")
p.add_argument("dossier")
p.add_argument("--du", help="premier jour UTC, AAAA-MM-JJ (défaut : début des données)")
p.add_argument("--au", help="dernier jour UTC exclu, AAAA-MM-JJ (défaut : fin des données)")
p.add_argument("--tranche", type=int, default=0, help="jours par tranche (défaut : un seul passage)")
# sans historique, une tranche qui commence juste avant un vrai saut le prend pour un saut revenu (PR17 à NORDEND,
# le 08/10 à 02:30 : absorbé dans la buée) ; 3 jours le rendent ; règle de l'utilisateur (2026-10-24) : 3 jours
# d'historique par défaut, dans la boucle comme dans la vraie application
p.add_argument("--historique", type=int, default=3, help="jours de mesures d'avant donnés aux détecteurs (défaut 3)")
a = p.parse_args()
mesures = charger(a.dossier)
ts = [m["t"] for ms in mesures.values() for m in ms]
jour = lambda d: datetime.strptime(d[:10], "%Y-%m-%d").replace(tzinfo=timezone.utc) # noqa: E731
debut = jour(a.du) if a.du else min(ts).replace(hour=0, minute=0, second=0, microsecond=0)
fin = jour(a.au) if a.au else max(ts) + timedelta(seconds=1)
t = debut
while t < fin:
b = min(t + timedelta(days=a.tranche), fin) if a.tranche else fin
h = t - timedelta(days=a.historique)
tranche = {s: k for s, ms in mesures.items() if (k := [m for m in ms if h <= m["t"] < b])}
evs = [v for v in evenements(tranche, b, a.dossier) if v["end"] >= iso(t)] if tranche else []
if a.tranche:
print(f"== {iso(t)} → {iso(b)} : {len(evs) or 'rien'}")
for v in evs:
print(v["start"], "→", v["end"], f"{v['category']:<20}", "grisé" if v["ignore"] else "gardé",
f"| {v['episodes'][0]['label']}", # la sorte : la règle du détecteur de la famille
f"| {len(v['sensors']) or 'tous les'} capteurs", "| absorbés :", ", ".join(
f"{e['label']} {e['start'][5:16]}" for e in v["episodes"][1:]) or "—")
t = b
+355
View File
@@ -0,0 +1,355 @@
"""Journal du matin : le détecteur de la famille Displacement (labeling/familles.md) : les sauts brutaux de corr_x /
corr_y (px) de chaque cible, à la cadence native de l'export « advanced », et la dérive lente (en fin de fichier). Une
cible qui bascule (« Target flipping ») est de la famille Target issue : episodes() la rend, detect() la laisse à
target_issue.py.
1. Bruit de la série = médiane des écarts d'une mesure à la suivante ; saut = mesure à K bruits ou plus du niveau
d'avant (médiane des BASE mesures précédentes) ; les BASE premières mesures, faute de niveau d'avant, face au niveau
d'après (médiane des BASE suivantes), un écart y est un saut revenu aussitôt (point 12 du plan, 2026-10-24).
2. Revenu (une heure de mesures de suite à moins de la moitié du saut : BASE à 15 min, une seule à 4 h, boucle
/detector-learner MICHIGAN, modification 1) en moins d'un jour, ou un jour après de retour à sa place
habituelle (premier jour de l'export) ou du jour d'avant : « Sudden jump, back to normal », grisé ; sa cause n'est pas
établie ici (categories.py lui donne celle de la catégorie qui le chevauche, sinon : à vérifier sur les images).
3. Sinon « Lasting shift », jamais grisé (peut-être un vrai mouvement) ; moins d'un jour de recul :
« Jump, not back yet », pas grisé non plus.
4. Les sauts qui se suivent à moins d'une heure, toutes cibles confondues, font un seul épisode (mode commun) ;
une seule cible durable (ou trop récente) suffit à ne pas griser l'épisode.
5. Références globales exclues ; mesures rejetées (corr vides) sautées.
6. Pic commun (lot 01 de la boucle NORDEND, 2026-10-26) : au même instant, au moins PIC_MIN cibles s'écartent d'au moins
K_PIC bruits de leurs deux mesures voisines, du même côté (toute l'image secouée un pas) : un saut revenu pour chacune,
même sous K. Il entre dans les épisodes du point 4 (près d'un saut durable, il ne grise rien).
7. Boucle CLARIDEN, lot 01 (2026-10-26) : un saut jamais revenu ne clôt plus la lecture de la série, son nouveau niveau
devient le niveau d'avant ; un épisode qui n'est pas grisé finit à son dernier saut, pas aux retours (ils ne sont
plus à griser) ; une cible qui bascule (REPET sauts revenus ou plus, chacun à moins d'un jour du précédent) fait un
épisode « back to normal » à elle seule, de la première à la dernière bascule, hors des épisodes communs.
Résultats (2026-10-23, K = 20) :
- E-001 PS des Coudres : rien (vérité : rien côté sauts).
- E-002 NORDEND juillet : grisés 28/07 21:00 → 29/07 10:45 (18 cibles) et 30/07 13:30 → 31/07 01:15 (18) ; toile revenue
31/07 20:30 : « not back yet » (13 cibles, 1 h avant la fin des données).
- E-003 WILDSTRUBEL : un saut d'un pas grisé, 04/09 06:45 (le C2 de la fiche) ; les autres sont sur des références
ou rejetés.
- E-004 CLARIDEN : « Lasting shift » 19/09 06:10, 18 cibles, non grisé ; faux positif probable : une cible agitée seule,
18/09 15:40, non grisé ; la dérive de nuit de corr_x (lente) n'est pas un saut.
- E-005 NIEDERHORN : train du 01/10 12:00 grisé (1 cible sur 3 : les deux autres à 17 et 19 bruits) ; train du
30/09 22:00 vu depuis le 2026-10-24 (2 cibles, première mesure de l'export) ; feuilles, pluie : rien (error_value, pas
des sauts). Les trains sont de toute façon attrapés par visibilite (« Passing obstacle ») et le classement y absorbe
leurs sauts : ne pas baisser K pour eux (point 12 du plan).
- NORDEND octobre : PR17 seule en « Lasting shift » le 08/10 02:30 ; cinq épisodes communs grisés (07/10 19:45,
08/10 07:15, 09/10 08:45 et 21:15, 14/10 05:15 : 4 à 15 cibles, aller-retour en moins de 5 h) ; PR15 08/10 04:45,
un instant grisé.
Pic commun (K_PIC = 6, PIC_MIN = 3, 2026-10-26) : NORDEND, lot du 01 au 04/09 : secousses du 03/09 13:30 (3 cibles) et
16:45 (4) grisées, aussi 01/09 15:45 → 16:00 et 02/09 09:45, mêmes secousses d'un pas pendant la bascule de la caméra ;
NORDEND octobre : un pic de 3 cibles le 13/10 12:30, et PR17 (08/10 02:30) groupé avec le pic de 02:15, « 3 targets,
1 stayed shifted », toujours non grisé ; E-002, E-005 : pics absorbés par la toile et les trains ; E-004 : les pics du
mouvement (19/09 06:30, 06:50) restent dans le « Lasting shift » ; E-001, E-003 : rien.
Point 7 (REPET = 5, 2026-10-26) : CLARIDEN, lot du 18 au 22/09 : PR_BG grisé 19/09 06:40 → 21/09 23:20 (28 bascules de
12 px ; les autres cibles en font 3 au plus) ; le saut seul de D-303-A le 18/09 15:40 vu ; le « Lasting shift » du
matin garde 05:40 → 10:30 ; E-001 à E-003, E-005 à E-008 : inchangés.
Catégories du terrain (D-074, 2026-10-27) : la cible qui bascule pendant BASCULE au moins, avec SEULES cibles au plus en même temps, devient « Target flipping » (Target issue, plus un
saut bref) ; un saut durable d'au moins GROS des cibles, « Large shift » (gros saut : tout a bougé), toujours à vérifier.
8. Saut sous K qui reste (boucle NIEDERHORN, lot 01, 2026-10-27 ; K_DURABLE = 7, PALIER = 8) : un saut d'au moins
K_DURABLE bruits compte s'il est durable au point 3 et que la médiane du jour d'après s'écarte de celle du jour d'avant,
du côté du saut, d'au moins PALIER fois la variation ordinaire du niveau d'un jour UTC au suivant (médiane des écarts
entre niveaux journaliers) ; sinon il est ignoré (ni revenu ni trop récent : seuls les sauts de K bruits ou plus le
sont). NIEDERHORN : e09, corr_y −0,19 px le 02/10 20:00 (8 bruits, 13 variations ordinaires), « Lasting shift », avec
e10 au même instant (corr_x +0,22 px, resté) ; E-001 : rien (cibles saines à 6 variations ordinaires au plus) ;
E-004 : le mouvement du 19/09 couvre deux fois plus de mesures à vérifier ; les autres events inchangés.
"""
import statistics
import sys
from datetime import timedelta
from pathlib import Path
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "agent-tools"))
import donnees # noqa: E402
K = 20 # provisoire, réglé sur E-001 : à 15, deux cibles saines y sont grisées (17 et 18 bruits) ; les trains de
# E-005 (17 et 19 bruits) sont attrapés par visibilite : ne pas baisser K
K_DURABLE = 7 # provisoire : sous K, un saut qui reste compte dès K_DURABLE bruits (boucle NIEDERHORN, lot 01 : e09,
# corr_y −0,18 px d'un coup, 8 bruits, resté 5 jours)
PALIER = 8 # provisoire : ... s'il reste : médiane du jour d'après, du côté du saut, à PALIER fois la variation
# ordinaire du niveau d'un jour au suivant de celle du jour d'avant (e09 : 13 ; E-001, cibles saines : 6 au plus)
K_PIC = 6 # provisoire : pic d'un pas commun à plusieurs cibles (secousses de NORDEND, 6 à 11 bruits, lot 01 de la boucle)
PIC_MIN = 3 # provisoire : cibles qui piquent au même pas pour un pic commun (une ou deux : bruit ordinaire)
BASE = 4 # mesures qui font le niveau d'avant (1 h à 15 min)
GAP = timedelta(hours=1) # deux sauts à moins d'une heure, toutes cibles confondues : un seul épisode
BACK_H = 24 # provisoire : retour en moins d'un jour = artefact (E-002 : paliers jusqu'à 11 h 30)
BASCULE = timedelta(hours=6) # provisoire : une cible à problème bascule des heures (PR_BG : 2,5 jours) ; en moins,
# c'est un matin agité (E-009 : C8 et C13, 5 bascules en 1 h 20 pendant le mouvement), un saut bref
SEULES = 2 # provisoire : cibles qui basculent en même temps, au plus (FLORIDA : les deux collées ; E-002, toile sur les
# références : 15 à la fois)
GROS = 0.5 # provisoire : part des cibles d'un saut durable pour un gros saut (E-004 : presque toutes)
REPET = 5 # provisoire : sauts revenus d'une même cible, à moins d'un jour l'un de l'autre, qui en font une cible qui
# bascule (PR_BG de CLARIDEN, boucle lot 01 : une trentaine en 2,5 jours)
def _sauts(t, v):
"""Une série (instants, valeurs) -> [(i début, i fin, état)], état 'back', 'lasting' ou 'recent'."""
day = timedelta(hours=BACK_H)
noise = statistics.median(abs(y - x) for x, y in zip(v, v[1:]))
pas = statistics.median(b - a for a, b in zip(t, t[1:])) # cadence de la série
retour = max(1, min(BASE, round(timedelta(hours=1) / pas))) # mesures d'une heure (BASE à 15 min, une à 4 h)
# ponytail: place habituelle = premier jour de l'export, faux s'il commence dans un artefact
ref = statistics.median(x for x, u in zip(v, t) if u < t[0] + day)
lv = {} # niveau de chaque jour UTC ; sa variation ordinaire d'un jour au suivant juge un saut sous K
for x, u in zip(v, t):
lv.setdefault(u.date(), []).append(x)
lv = [statistics.median(x) for _, x in sorted(lv.items())]
ordinaire = statistics.median(abs(b - a) for a, b in zip(lv, lv[1:])) if len(lv) > 2 else 0
# les BASE premières mesures, faute de niveau d'avant, face au niveau d'après : un écart y est revenu aussitôt
out = [(k, k, "back") for k in range(min(BASE, len(v) - BASE))
if noise and abs(v[k] - statistics.median(v[k + 1:k + 1 + BASE])) >= K * noise]
i = BASE
while noise and i < len(v):
base = statistics.median(v[i - BASE:i])
if abs(v[i] - base) < K_DURABLE * noise:
i += 1
continue
tol = abs(v[i] - base) / 2 # revenu : une heure de mesures de suite à moins de la moitié du saut du niveau d'avant
j = next((k for k in range(i + 1, len(v)) if all(abs(x - base) < tol for x in v[k:k + retour])), len(v))
before = statistics.median([x for x, u in zip(v, t) if t[i] - day <= u < t[i]] or [base])
after = statistics.median(x for x, u in zip(v, t) if t[i] <= u < t[i] + day)
if j < len(v) and t[j] - t[i] <= day:
state = "back"
elif abs(after - ref) < tol or abs(after - before) < tol: # le jour d'après, la cible est à sa place
state, j = "back", i + 1 # habituelle, ou là où elle était le jour d'avant : le saut finissait un creux
else:
state = "lasting" if t[-1] - t[i] >= day else "recent" # moins d'un jour de recul : on ne sait pas encore
if abs(v[i] - base) < K * noise and (state != "lasting" or (after - before) * (v[i] - base) < 0
or not ordinaire or abs(after - before) < PALIER * ordinaire):
i += 1 # sous K, seul compte un saut qui reste : le jour d'après loin du jour d'avant, de son côté
continue
out.append((i, j - 1, state))
# niveau d'avant refait après le retour ; jamais revenu : le nouveau niveau devient celui d'avant, la suite
# reste lue (PR_BG de CLARIDEN, lot 01 : ses bascules après le saut de 10:30 étaient invisibles)
i = (j if j < len(v) else i) + BASE
return out
def _pics(t, v):
"""Instants où la mesure s'écarte d'au moins K_PIC bruits de ses deux voisines, du même côté (pic d'un pas)."""
noise = statistics.median(abs(y - x) for x, y in zip(v, v[1:]))
return [t[i] for i in range(1, len(v) - 1) if noise and (v[i] - v[i - 1]) * (v[i] - v[i + 1]) > 0
and min(abs(v[i] - v[i - 1]), abs(v[i] - v[i + 1])) >= K_PIC * noise]
def episodes(mesures):
"""{capteur: [mesure]} (donnees.charger) -> épisodes des sauts, triés par début : Displacement, et Target issue pour
une cible qui bascule."""
found = [] # (début, fin, état, capteur)
pics = {} # instant -> cibles qui y font un pic d'un pas
for name, ms in mesures.items():
if donnees.est_reference(ms):
continue
for axe in ("corr_x", "corr_y"):
kept = [m for m in ms if m[axe] is not None]
if len(kept) <= BASE:
continue
t, v = [m["t"] for m in kept], [m[axe] for m in kept]
# un saut qui n'est pas revenu finit avec lui-même, pas avec les données (sa barre cachait les autres)
found += [(t[a], t[b] if state == "back" else t[a], state, name) for a, b, state in _sauts(t, v)]
for u in _pics(t, v):
pics.setdefault(u, set()).add(name)
found += [(u, u, "back", s) for u, cs in pics.items() if len(cs) >= PIC_MIN for s in cs] # pic commun : revenu
seuls = _bascules(found) # une cible qui saute et revient sans cesse : un épisode à elle seule, hors des communs
found = [f for f in found if f[2] != "back" or not any(f[3] in g["sensors"] and g["start"] <= f[0] <= g["end"]
for g in seuls)]
groups = [] # un saut qui n'est pas revenu ne compte que par son instant : sa fin est souvent celle des données
for s, e, state, name in sorted(found):
if groups and s <= groups[-1]["until"] + GAP:
g = groups[-1]
else:
g = {"start": s, "end": e, "until": s, "last": s, "sensors": {}}
groups.append(g)
g["end"], g["until"], g["last"] = max(g["end"], e), max(g["until"], e if state == "back" else s), s
g["sensors"].setdefault(name, set()).add(state)
longues = [g for g in seuls if g["flip"]] # bascules de nombreuses cibles en même temps : la compensation, pas une
for g in longues: # cible à problème
if sum(h["start"] <= g["end"] and h["end"] >= g["start"] for h in longues) > SEULES:
g["flip"] = 0
total = sum(not donnees.est_reference(ms) for ms in mesures.values())
return sorted((_episode(g, total) for g in groups + seuls), key=lambda ep: ep["start"])
def _bascules(found):
"""Sauts revenus d'une même cible, chacun à moins de BACK_H du précédent : REPET ou plus -> un groupe, de la
première à la dernière bascule."""
day, seuls = timedelta(hours=BACK_H), []
for name in {f[3] for f in found}:
chain = [] # (début, fin) ; corr_x et corr_y en double : comptés par instant
for s, e in sorted({(s, e) for s, e, state, n in found if n == name and state == "back"}) + [(None, None)]:
if chain and s is not None and s <= max(c[1] for c in chain) + day:
chain.append((s, e))
continue
if len({c[0] for c in chain}) >= REPET:
seuls.append({"start": chain[0][0], "end": max(c[1] for c in chain), "sensors": {name: {"back"}},
"flip": len({c[0] for c in chain}) if max(c[1] for c in chain) - chain[0][0] >= BASCULE else 0})
chain = [(s, e)]
return seuls
def _episode(g, total):
"""Un groupe -> épisode du journal ; un seul saut durable (ou trop récent) suffit à ne pas griser ; une cible qui
bascule : « Target flipping » (Target issue, D-074) ; un saut durable de GROS cibles ou plus : « Large shift »
(le gros saut, sous-groupe de « À vérifier »)."""
n = len(g["sensors"])
lasting = sum("lasting" in st for st in g["sensors"].values())
recent = any("recent" in st for st in g["sensors"].values())
who = "One target" if n == 1 else f"{n} targets together (a single event)"
if g.get("flip"):
name = next(iter(g["sensors"]))
return {"start": donnees.iso(g["start"]), "end": donnees.iso(g["end"]), "kind": "Target issue", "label": "Target flipping",
"text": f"{name} jumped and came back {g['flip']} times: its tracking is not reliable, look at the images "
"of the target.", "ignore": True, "sensors": [name], "lasting": []}
if lasting and n >= GROS * total:
label = "Large shift"
text = f"{n} targets jumped together and {lasting} of them stayed shifted: everything moved, please check it."
elif lasting:
label = "Lasting shift"
some = "" if lasting == n else f", {lasting} of them stayed shifted for more than a day"
text = (f"{who} jumped{some}" if some else f"{who} jumped and stayed shifted for more than a day") + \
": this may be a real movement, please check it."
elif recent:
label = "Jump, not back yet"
text = f"{who} jumped less than a day before the last measurement and has not come back yet: check again later."
else:
label = "Sudden jump, back to normal"
text = f"{who} jumped and came back within a day: the cause is not established, look at the images."
end = g["last"] if lasting or recent else g["end"] # pas grisé : le dernier saut, pas les retours
return {"start": donnees.iso(g["start"]), "end": donnees.iso(end), "kind": "Displacement", "label": label,
"text": text, "ignore": not lasting and not recent, "sensors": sorted(g["sensors"]),
"lasting": sorted(s for s, st in g["sensors"].items() if "lasting" in st)} # restées décalées (phrase du journal)
def detect(mesures):
return sorted([e for e in episodes(mesures) if e["kind"] == "Displacement"] + derive(mesures), key=lambda ep: ep["start"])
# --- Dérive lente ---------------------------------------------------------------------------------------------------
# Dérive lente : une cible qui bouge peu à peu, jour après jour.
#
# Reprend la tendance de l'onglet Displacements (D-055, explore.find_trend) sur l'export « advanced » (corr_x, corr_y, px),
# pour que la boucle puisse l'entraîner comme les autres détecteurs. Méthode, par cible (hors références globales) et par
# axe (seuils provisoires, ceux de D-055) :
# 1. Niveau du jour : médiane des mesures de chaque jour UTC d'au moins HEURES heures mesurées sur 24, en part des heures
# que la station mesure (boucle /detector-learner MICHIGAN, modification 1 : à une mesure toutes les 4 h, 5 des 6
# heures ; avant, aucun jour ne comptait) ; au moins JOURS jours.
# 2. Pente de Theil-Sen et tau de Kendall des niveaux journaliers ; amplitude du jour : écart entre ses déciles 9 et 1.
# 3. Dérive : |pente| × durée ≥ TAILLE fois l'amplitude médiane du jour, |tau| ≥ REGULIER, et aucun pas d'un jour au
# suivant de plus de la moitié de la dérive (un saut qui dure n'est pas une dérive : le détecteur sauts le prend).
# 4. Un épisode par cible (un axe suffit), de la première mesure du premier jour à la dernière du dernier ; pas grisé.
# 4 bis. Par morceaux (/detector-learner Displacement, modification 1, S1) : une cible sans dérive sur toute la fenêtre
# peut dériver quelques jours, puis se poser ou repartir en arrière. Sur chaque suite d'au moins JOURS jours retenus,
# dérive = niveau du dernier jour moins celui du premier, au moins MORCEAU amplitudes du jour (médiane de la série),
# |tau| ≥ REGULIER du même signe, aucun pas d'un jour retenu au suivant de plus de la moitié de la dérive ; les
# morceaux pris de la plus grande dérive à la plus petite, sans se chevaucher (ils peuvent partager le jour où le
# niveau tourne) : chacun va d'un extrême du niveau à l'autre, un épisode par morceau et par axe. À MORCEAU = 1, les
# cycles thermiques de quelques jours et le bruit des niveaux passent (JUNGFRAU, NORDEND) : 3,5 garde les rangées de
# CLARIDEN (3,8 à 8,3 amplitudes), écarte JUNGFRAU (3,1 au plus). Les morceaux ne remplacent pas l'étape 3 : à leur
# place, la fin des dérives de MICHIGAN et ce que couvraient les tendances de WILDSTRUBEL étaient perdus.
# Un morceau ne franchit pas un trou : deux jours retenus qui se suivent sont à TROU jours au plus l'un de l'autre
# (modification 2, remarque 1 du contrôle : l'écart d'un niveau à travers trois jours sans mesure est un pas, pas une
# pente ; il faisait des morceaux de toute la fenêtre, CLARIDEN 09-28 → 11-01). Un jour manquant ne coupe pas.
# 5. Dérive de la caméra (même modification) : au moins GROS des cibles dérivent du même côté sur corr_x ou corr_y, et au
# moins GROS des capteurs, références comprises, sur leurs positions brutes x ou y : seuls les morceaux du point 4 bis
# sont signalés, pas la tendance de toute la fenêtre (/detector-learner Displacement, modification 1, S2 : la caméra
# mal compensée qui dérive, NEBRASKA, est un Displacement pour les étiquettes ; avant, rien n'était signalé). Les
# cibles d'un pont qui suivent la saison (JUNGFRAU, étiquetées Thermal displacement jour après jour) passent l'étape 3
# mais pas MORCEAU ; NEBRASKA les deux. BREITHORN (5 capteurs sur 16 en x comme en y) et MICHIGAN ne sont pas
# concernées.
HEURES = 20 # un jour compte s'il a au moins 20 heures mesurées sur 24 (comme D-055), en part des heures mesurées
JOURS = 5 # jours au minimum pour une tendance (TREND_DAYS de D-055)
TAILLE = 1.0 # dérive ≥ TAILLE amplitudes journalières (TREND_SIZE de D-055)
REGULIER = 0.6 # |tau de Kendall| des niveaux journaliers (TREND_STEADY de D-055)
MORCEAU = 3.5 # dérive par morceaux ≥ MORCEAU amplitudes journalières (point 4 bis)
TROU = 2 # un morceau ne passe pas d'un jour retenu au suivant à plus de TROU jours (point 4 bis)
def _decile(vs, q):
vs = sorted(vs)
return vs[min(len(vs) - 1, int(q * len(vs)))]
def _jours(ms, col):
"""-> {jour UTC: ses mesures}, les jours retenus (point 1)."""
jours = {}
for m in ms:
if m[col] is not None:
jours.setdefault(m["t"].date(), []).append(m)
creneaux = len({m["t"].hour for js in jours.values() for m in js}) # heures que la station mesure (6 à 4 h de pas)
return {d: js for d, js in jours.items() if len({m["t"].hour for m in js}) >= HEURES / 24 * creneaux}
def _derive(ms, col):
"""-> (dérive en px, jours, premier instant, dernier) ou None."""
jours = _jours(ms, col)
if len(jours) < JOURS:
return None
niv = sorted((d.toordinal(), statistics.median(m[col] for m in js)) for d, js in jours.items())
paires = [(a, b) for k, a in enumerate(niv) for b in niv[k + 1:]]
pente = statistics.median((b[1] - a[1]) / (b[0] - a[0]) for a, b in paires)
tau = sum((b[1] > a[1]) - (b[1] < a[1]) for a, b in paires) / len(paires)
derive = pente * (niv[-1][0] - niv[0][0])
ampl = statistics.median(_decile([m[col] for m in js], 0.9) - _decile([m[col] for m in js], 0.1) for js in jours.values())
pas = max(abs(b[1] - a[1]) for a, b in zip(niv, niv[1:]))
if abs(derive) < TAILLE * ampl or abs(tau) < REGULIER or pas > abs(derive) / 2:
return None
d0, d1 = min(jours), max(jours)
return derive, len(jours), min(m["t"] for m in jours[d0]), max(m["t"] for m in jours[d1])
def _morceaux(ms, col):
"""-> [(dérive en px, jours, premier instant, dernier)] : les morceaux de dérive (point 4 bis)."""
jours = _jours(ms, col)
if len(jours) < JOURS:
return []
ds = sorted(jours)
niv = [statistics.median(m[col] for m in jours[d]) for d in ds]
ampl = statistics.median(_decile([m[col] for m in js], 0.9) - _decile([m[col] for m in js], 0.1) for js in jours.values())
morceaux = [] # (dérive, i, j)
for i in range(len(ds)):
signes = pas = 0
for j in range(i + 1, len(ds)):
if (ds[j] - ds[j - 1]).days > TROU:
break # un écart à travers un trou est un pas (le détecteur des sauts le prend), pas une pente
signes += sum((niv[j] > niv[k]) - (niv[j] < niv[k]) for k in range(i, j)) # tau de Kendall, pas à pas
pas = max(pas, abs(niv[j] - niv[j - 1]))
n, d = j - i + 1, niv[j] - niv[i]
if n >= JOURS and d and abs(d) >= MORCEAU * ampl and pas <= abs(d) / 2 \
and signes * (1 if d > 0 else -1) >= REGULIER * n * (n - 1) / 2:
morceaux.append((d, i, j))
pris = []
for d, i, j in sorted(morceaux, key=lambda x: (-abs(x[0]), x[2] - x[1])):
if all(j <= a or i >= b for _, a, b in pris):
pris.append((d, i, j))
return [(d, j - i + 1, min(m["t"] for m in jours[ds[i]]), max(m["t"] for m in jours[ds[j]])) for d, i, j in pris]
def _commune(mesures, cols):
"""Au moins GROS des capteurs dérivent du même côté sur un même axe de cols."""
for col in cols:
signes = [x[0] > 0 for ms in mesures.values() if (x := _derive(ms, col))]
if max(signes.count(True), signes.count(False)) >= GROS * len(mesures):
return True
return False
def derive(mesures):
cibles = {s: ms for s, ms in mesures.items() if not donnees.est_reference(ms)}
camera = _commune(cibles, ("corr_x", "corr_y")) and _commune(mesures, ("x", "y")) # point 5 : morceaux seuls
out = []
for s, ms in sorted(mesures.items()):
if donnees.est_reference(ms):
continue
r = [] if camera else [x for col in ("corr_x", "corr_y") if (x := _derive(ms, col))]
r = [max(r, key=lambda x: abs(x[0]))] if r else [x for col in ("corr_x", "corr_y") for x in _morceaux(ms, col)]
out += [{"start": donnees.iso(a), "end": donnees.iso(b), "kind": "Displacement", "label": "Slow drift",
"text": f"{s} drifts slowly and steadily: {derive:+.2f} px in {n} days. Keep watching it.",
"ignore": False, "sensors": [s]} for derive, n, a, b in r]
return out
if __name__ == "__main__":
for ep in detect(donnees.charger(sys.argv[1])):
print(ep["start"], ep["end"], "ignore" if ep["ignore"] else "KEEP ", ep["label"], "|", len(ep["sensors"]),
",".join(ep["sensors"][:6]), "|", ep["text"])
+43
View File
@@ -0,0 +1,43 @@
"""Journal du matin : le détecteur de la famille No data (labeling/familles.md) : moments sans mesure (cadence de l'export « advanced » rompue).
Cadence : écart médian entre deux instants de mesure, tous capteurs confondus. Un trou : plus de 2 pas manquants entre
deux mesures (écart > 3 cadences) ; l'épisode va de la dernière mesure à la suivante. Fin de la fenêtre lue (fin, si
l'appelant la donne : le tri en lot de categories.py) : la même règle entre la dernière mesure et fin, l'épisode allant
jusqu'à fin (boucle CLARIDEN, lot 01 : 44 h sans mesure jusqu'à la fin du lot, non signalées). Pas de mesure dans
l'export ne veut pas dire station arrêtée (CLAUDE.md) : le texte dit seulement que l'export n'a rien.
Usage : python3 detectors/no_data.py <dossier de station> (affiche les épisodes)
"""
import os
import statistics
import sys
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "agent-tools"))
from donnees import charger, iso # noqa: E402
MISSING = 2 # au-delà de 2 pas manquants, c'est un trou (consigne de l'utilisateur, 2026-10-23)
def duration(s):
h, m = divmod(round(s / 60), 60)
return f"{h} h {m:02d} min" if h else f"{m} min"
def detect(mesures, fin=None):
"""fin : fin de la fenêtre lue (datetime, exclue), facultative ; sans elle, un trou final n'est pas vu."""
ts = sorted({m["t"].replace(second=0, microsecond=0) for ms in mesures.values() for m in ms})
if len(ts) < 3:
return []
gaps = [(b - a).total_seconds() for a, b in zip(ts, ts[1:])]
step = statistics.median(gaps)
out = [(a, b, g, "") for a, b, g in zip(ts, ts[1:], gaps)]
if fin: # fin exclue : la dernière mesure attendue est à fin − 1 pas, l'écart se compte comme entre deux mesures
out.append((ts[-1], fin, (fin - ts[-1]).total_seconds(), ", up to the end of the period"))
return [{"start": iso(a), "end": iso(b), "kind": "No data", "label": "No data",
"text": f"No measurement in the export for {duration(g)}{fin_txt} (usually one every {duration(step)}).",
"ignore": False, "sensors": []}
for a, b, g, fin_txt in out if g > (MISSING + 1) * step]
if __name__ == "__main__":
for e in detect(charger(sys.argv[1])):
print(e)
+25
View File
@@ -0,0 +1,25 @@
"""Journal du matin : le détecteur de la famille Obstruction (labeling/familles.md) : un objet cache une ou quelques
cibles, un instant ou longtemps. Il reprend deux calculs partagés avec d'autres familles :
- l'error_value de visibility.py : Brief obstruction (un passage, un instant) et Target obscured (une cible rejetée à
répétition quand les autres restent vues, ou une gêne qui ne touche que quelques cibles, sans référence) ;
- les rejets jour après jour de target_issue.py : une cible rejetée moins d'une semaine, Target obscured.
Usage : python3 detectors/obstruction.py <dossier de station> (affiche les épisodes)
"""
import os
import sys
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "agent-tools"))
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
import target_issue # noqa: E402
import visibility # noqa: E402
from donnees import charger # noqa: E402
def detect(mesures):
return sorted((e for e in visibility.episodes(mesures) + target_issue.episodes(mesures) if e["kind"] == "Obstruction"),
key=lambda e: e["start"])
if __name__ == "__main__":
for e in detect(charger(sys.argv[1])):
print(e["start"], "→", e["end"], e["label"], f"| {len(e['sensors'])} :", ",".join(e["sensors"][:8]), "|", e["text"])
+165
View File
@@ -0,0 +1,165 @@
"""Journal du matin : le détecteur de la famille Target issue (labeling/familles.md) : une cible constamment
problématique : rejetée la plupart du temps, jour après jour, quand les autres sont vues (cible dégradée), collée (en
fin de fichier), ou qui bascule (les sauts de displacement.py, « Target flipping »). Une cible rejetée moins d'une
semaine est cachée par moments (point 4) : episodes() la rend avec la famille Obstruction, que detect() laisse à
obstruction.py.
Le détecteur visibilite compare chaque capteur à son propre niveau habituel : une cible presque toujours rejetée lui
paraît normale (FLORIDA, octobre 2026 : Massif 2 et Sellette 6 rejetées la moitié des mesures ou plus, chaque jour).
Méthode (seuils provisoires, Claude, 2026-10-27) :
1. Instant calme pour un capteur : au plus CALME des autres capteurs rejetés (error_value > error_threshold) ; la météo et
la buée, qui touchent tout le monde, sont ainsi mises de côté.
2. Par jour UTC et par capteur, sur ses instants calmes (au moins MIN_HEURES heures d'instants à la cadence de la
station, écart médian entre deux instants de mesure ; sinon le jour ne compte pas) : jour dégradé si au moins PART
d'entre eux sont rejetés. Cadence (boucle /detector-learner NEBRASKA, lot 01) : 12 instants fixes, « 3 h à 15 min »,
ne comptaient aucun jour à une mesure toutes les 4 h ; REFCOLH22, rejetée sans cesse depuis sa perte, n'était pas vue.
3. Épisode : au moins MIN_JOURS jours dégradés de suite (un jour qui ne compte pas ne coupe pas la suite), de la première
mesure rejetée de ces jours à la dernière ; ignore = True : la courbe de la cible n'est pas fiable.
4. Gênée tout le temps ou par moments (frontière « Target issue ou Obstruction » de labeling/familles.md ; boucle
/detector-learner NEBRASKA, lot 01) : une suite d'au moins SEMAINE jours est une cible à problème, « Degraded target » ;
plus courte, une cible cachée par moments, « Target obscured » (famille Obstruction), un épisode par suite de
mesures rejetées (les heures où elle est vue n'en sont pas). BREITHORN : véhicules garés
devant COLI24 et POUI22, 2 à 5 jours ; NEBRASKA et MICHIGAN : une référence perdue, 25 jours ; JUNGFRAU : PM_G, 63.
Sur les jeux de data/ (2026-10-27) : FLORIDA Massif 2 21 → 25.10, Sellette 6 16 → 17.10 et 19 → 20.10 ; NIEDERHORN e03 à
e12 toute la période (jamais vues) ; NORDEND CTR01 plusieurs suites en juin-juillet (déjà « souvent rejetée ») ; rien
sur LENZSPITZE ; CLARIDEN PR-283 du 12 au 16.09. La cause (salissure, végétation, réglage) ne se lit que sur les images.
Cible collée (E-011, FLORIDA : une cible définie sur le prisme d'une référence) : par jour UTC,
le bruit de ses corr_x et corr_y (médiane des écarts d'une mesure à la suivante) à moins de COLLE fois le bruit médian
des autres cibles, sur les deux axes, un jour suffit (une journée sans bruit n'arrive pas par accident) ; label « Target stuck ». Sur E-011 : C2 à
7e-5 px et C3 à 2e-4 contre 0,013 pour les autres ; FLORIDA : les mêmes, Pont Ernen et Sellette 3.
Usage : python3 detectors/target_issue.py <dossier de station> (affiche les épisodes)
"""
import os
import statistics
import sys
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "agent-tools"))
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
import displacement # noqa: E402
from donnees import charger, est_reference, iso # noqa: E402
CALME = 0.25 # part des autres capteurs rejetés au plus, pour un instant calme
PART = 0.5 # la moitié des instants calmes rejetés : « la plupart du temps »
MIN_HEURES = 3 # heures d'instants calmes, à la cadence de la station : en dessous, le jour ne compte pas
MIN_JOURS = 2 # un jour seul est trop souvent un accident (NORDEND : jours isolés sur 16 capteurs)
SEMAINE = 7 # provisoire : jours dégradés de suite pour une cible à problème ; en dessous, une cible cachée par moments
COLLE = 0.05 # provisoire : bruit d'une cible collée face aux autres (E-011 : 0,006 ; NORDEND, E-001 : 0,7 au plus bas)
def rejete(m):
return m["error_value"] is not None and m["error_threshold"] is not None and m["error_value"] > m["error_threshold"]
def cadence(mesures):
"""Écart médian entre deux instants de mesure, tous capteurs confondus, en heures (comme no_data)."""
ts = sorted({m["t"].replace(second=0, microsecond=0) for ms in mesures.values() for m in ms})
return statistics.median((b - a).total_seconds() for a, b in zip(ts, ts[1:])) / 3600 if len(ts) > 1 else 1
def episodes(mesures):
"""Cibles rejetées jour après jour : Target issue (une semaine ou plus) et Obstruction (moins), puis les collées."""
min_instants = MIN_HEURES / cadence(mesures)
par_t = {}
for s, ms in mesures.items():
for m in ms:
par_t.setdefault(m["t"], {})[s] = rejete(m)
jours = {} # capteur -> jour -> [rejetés, calmes, première mesure, dernière]
for t in sorted(par_t):
d = par_t[t]
for s, r in d.items():
autres = [v for k, v in d.items() if k != s]
c = jours.setdefault(s, {}).setdefault(t.date(), [0, 0, t, t])
c[3] = t
if autres and sum(autres) / len(autres) <= CALME:
c[0] += r
c[1] += 1
out = []
for s, js in sorted(jours.items()):
suites, cur = [], []
for j in sorted(js):
rej, calmes = js[j][:2]
if calmes < min_instants:
continue
if rej / calmes >= PART:
cur.append(js[j])
elif cur:
suites.append(cur)
cur = []
suites += [cur] if cur else []
for su in suites:
if len(su) < MIN_JOURS:
continue
part = round(100 * sum(c[0] for c in su) / sum(c[1] for c in su))
text = f"{s} was rejected in {part} % of the measurements when the other targets were seen, {len(su)} days in a row."
r = _rejets([m for m in mesures[s] if su[0][2] <= m["t"] <= su[-1][3]])
if len(su) >= SEMAINE: # de la première à la dernière mesure rejetée
bornes, label = [(r[0][0], r[-1][1])], "Degraded target"
else: # par moments : un épisode par suite de mesures rejetées
bornes, label = r, "Target obscured"
out += [{"start": iso(a), "end": iso(b), "kind": "Target issue" if label == "Degraded target" else "Obstruction",
"label": label, "text": text, "ignore": True,
"sensors": [s]} for a, b in bornes]
return sorted(out + colles(mesures, min_instants), key=lambda e: e["start"])
def _rejets(ms):
"""Mesures d'un capteur -> [(début, fin)] de ses suites de mesures rejetées."""
out, cur = [], []
for m in ms + [None]:
if m and rejete(m):
cur.append(m["t"])
elif cur:
out.append((cur[0], cur[-1]))
cur = []
return out
def _bruit(v):
return statistics.median(abs(y - x) for x, y in zip(v, v[1:])) if len(v) > 2 else None
def colles(mesures, min_instants):
"""Cibles dont corr_x et corr_y ne bougent presque pas, jour après jour, quand les autres bougent."""
jours = {} # jour -> cible -> (bruit x, bruit y, première mesure, dernière)
for s, ms in mesures.items():
if est_reference(ms):
continue
par_j = {}
for m in ms:
par_j.setdefault(m["t"].date(), []).append(m)
for d, js in par_j.items():
b = [_bruit([m[c] for m in js if m[c] is not None]) for c in ("corr_x", "corr_y")]
if None not in b and len(js) >= min_instants:
jours.setdefault(d, {})[s] = (*b, js[0]["t"], js[-1]["t"])
suites = {} # cible -> [[jours collés de suite]]
for d in sorted(jours):
cs = jours[d]
for s, (bx, by, a, b) in cs.items():
autres = [v for k, (x, y, *_) in cs.items() if k != s for v in (x, y)]
if len(autres) < 4:
continue
ref = statistics.median(autres)
su = suites.setdefault(s, [[]])
if ref and max(bx, by) <= COLLE * ref:
su[-1].append((a, b))
elif su[-1]:
su.append([])
out = []
for s, su in sorted(suites.items()):
for k in su:
if k:
out.append({"start": iso(k[0][0]), "end": iso(k[-1][1]), "kind": "Target issue", "label": "Target stuck",
"text": f"{s} barely moved while the other targets did ({len(k)} day{'s' if len(k) > 1 else ''}): it may be "
"set on a reference prism.", "ignore": True, "sensors": [s]})
return out
def detect(mesures):
return sorted((e for e in episodes(mesures) + displacement.episodes(mesures) if e["kind"] == "Target issue"),
key=lambda e: e["start"])
if __name__ == "__main__":
for e in detect(charger(sys.argv[1])):
print(e)
+260
View File
@@ -0,0 +1,260 @@
"""Journal du matin : le détecteur de la famille Thermal displacement (labeling/familles.md) : la vague quotidienne des
déplacements corrigés (dilatation le jour, contraction le soir : l'utilisateur, 2026-10-24 ; point 41 du plan).
Méthode, par cible (hors références globales) et par axe (corr_x, corr_y) :
1. Chaque jour UTC d'au moins 20 h : moyenne de chaque heure moins la médiane du jour (enlève sauts et dérive).
2. Profil = médiane, heure par heure, sur les jours ; « répétabilité » = médiane, sur les jours, de la corrélation
entre le jour et le profil des autres jours. Axe concerné si répétabilité ≥ 0,6.
3. Cycle de la station si au moins la moitié des cibles ont un axe concerné, **et** (seconde méthode, demandée par
l'utilisateur) si une sinusoïde de 24 h, a + b·sin(2πt/24 h) + c·cos(2πt/24 h) par moindres carrés, explique au
moins R2_MIN de la courbe d'un axe pour au moins la moitié des cibles.
4. Heures chaudes : niveau de nuit = médiane des 8 heures consécutives les plus plates du profil ; une heure est
chaude si, en médiane sur les axes concernés, le profil s'en écarte d'au moins 0,3 fois son amplitude.
5. Deux épisodes par jour complet qui ressemble aux autres (corrélation médiane ≥ 0,5 sur les axes concernés) :
« Thermal expansion » de la première heure chaude à l'heure du plus grand écart au niveau de nuit, puis « Thermal
contraction » jusqu'à la fin de la dernière heure chaude. Le sens (une courbe qui monte ou qui descend) dépend de la
direction de la cible : on ne le regarde pas, seulement l'écart au niveau de nuit.
Sinusoïde (2026-10-24), axes des courbes corrigées où elle explique ≥ 30 % : PS des Coudres 14/22, NORDEND d'octobre
0/38, juillet 1/38, WILDSTRUBEL 1/14, CLARIDEN 0/48, NIEDERHORN 14/40 (3 jours, deux nuits de pluie aux mêmes heures,
écarté par la première méthode) ; PS des Coudres seule a son effet périodique, 5 jours, dilatation puis contraction.
Résultats (2026-10-23 ; « cibles » = part des cibles concernées, amplitude = médiane max − min du profil, en px) :
| Jeu | corr (ce que voit le client) | x, y bruts |
|---|---|---|
| PS_DES_COUDRES | 11/11 cibles, 0,17 px, 08-17 h, 5 épisodes | 12/12, 0,55 px, 08-16 h |
| NORDEND (juillet, E-002) | 2/18, rien | 18/19, 1,8 px, 06-18 h |
| WILDSTRUBEL (E-003) | 3/7, rien | 6/7, 3,2 px, 04-08 h |
| CLARIDEN (E-004) | 1/24, rien | 1/24, aucun cycle |
| NIEDERHORN (E-005, horaire) | 3/11, rien | 19/30, 4,6 px, ~12 h |
| cas 2026-10_NORDEND (11 j) | 9/19, 0,02 px, 08-17 h, sous le seuil (PART = 0,4 : 8 épisodes, sans 08 ni 09/10) | 17/19, 0,78 px, 09-17 h |
Lecture : le cycle est presque partout dans les positions brutes (mode commun) et la compensation l'enlève,
sauf à PS des Coudres où il reste dans corr, de même forme que dans les positions brutes.
Effet thermique (D-074, 2026-10-27) : sans cycle dans corr, la même méthode sur les positions brutes x, y donne
« Camera thermal expansion » et « Camera thermal contraction » : la caméra bouge avec la chaleur de son support, la
compensation l'enlève ; mêmes catégories du journal, phrase propre.
Caméra sans sinusoïde (boucle WILDSTRUBEL, lot 01) : sur les positions brutes, la seconde méthode n'est plus demandée ;
la caméra y montait d'un bloc de 3 px au lever, tenait 3 h et retombait en un pas vers 09:30, six jours de suite, que
la sinusoïde n'explique pas (une cible sur sept, les pointés faux de 30 px écrasent l'ajustement) ; la répétition
d'un jour à l'autre (méthode 1, 6 cibles sur 7) suffit. En échange, une seule heure chaude n'est pas un cycle
(CHAUDES_MIN) : NIEDERHORN (E-005, horaire) avait sinon son heure de midi (trains, trous) en contraction de la caméra.
L'épisode de la caméra porte sur tous les capteurs, références comprises : toute l'image bouge.
Glissade commune, sans cycle (boucle /detector-learner MICHIGAN, modification 1) : faute de cycle dans les courbes
corrigées comme dans les positions brutes, un instant est une glissade de la caméra si les positions brutes (x ou y) d'au
moins PART des capteurs, références comprises, **et** les courbes corrigées (corr_x ou corr_y) d'au moins PART des cibles
s'écartent du même côté d'au moins ECART bruits (médiane des pas de la série) de leur médiane du jour d'avant ; les
glissades à moins d'un jour l'une de l'autre font un épisode, « Camera thermal movement », sur tous les capteurs, hôte
des sauts revenus (categories.HOTES). La caméra bouge avec la température sans revenir chaque jour à la même heure (une
mesure toutes les 4 h, refroidissements brefs), et la compensation ne l'enlève pas toute. La condition sur les positions
brutes laisse aux sauts une bascule de la seule pose calculée (positions brutes immobiles). MICHIGAN : 9 épisodes du 09
au 30.10, tous dans la dérive thermique étiquetée ; NEBRASKA : 13 instants, tous justes ; BREITHORN, JUNGFRAU, NORDEND,
WILDSTRUBEL inchangés (cycle trouvé, ou rien) ; ECART = 2 prenait 2 instants Displacement de BREITHORN.
"""
import math
import os
import statistics
import sys
from datetime import datetime, timedelta, timezone
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "agent-tools"))
from donnees import charger, iso # noqa: E402
HEURES_MIN = 20 # provisoire : un jour UTC compte s'il a au moins 20 heures mesurées
REPRO = 0.6 # provisoire : un axe a un cycle si chaque jour ressemble aux autres (bruit pur ≈ 0)
PART = 0.5 # provisoire : part des cibles concernées ; 2026-10_NORDEND est juste dessous (9/19)
CHAUD = 0.3 # provisoire : écart au niveau de nuit, en part de l'amplitude du profil
JOUR = 0.5 # provisoire : ressemblance d'un jour aux autres pour lui donner son épisode
NUIT = 8 # heures consécutives du profil les plus plates = niveau de nuit
R2_MIN = 0.3 # provisoire, ébauche du 2026-10-24 : PS des Coudres 14 axes sur 22 au-dessus, CLARIDEN 0 sur 48
CHAUDES_MIN = 2 # provisoire : boucle WILDSTRUBEL, lot 01 ; NIEDERHORN (E-005) n'a qu'une heure chaude (midi)
ECART = 3 # provisoire : glissade commune, en bruits (médiane des pas) d'écart à la médiane du jour d'avant
W = 2 * math.pi / 86400 # pulsation d'un cycle de 24 h, en rad/s
def _corr(a, b):
ma, mb = statistics.mean(a), statistics.mean(b)
num = sum((x - ma) * (y - mb) for x, y in zip(a, b))
den = (sum((x - ma) ** 2 for x in a) * sum((y - mb) ** 2 for y in b)) ** 0.5
return num / den if den else 0.0
def _axe(ms, col):
"""-> (profil sur 24 h, {jour: corrélation au profil des autres jours}) ou None."""
jours = {}
for m in ms:
if m[col] is not None:
jours.setdefault(m["t"].date(), {}).setdefault(m["t"].hour, []).append(m[col])
J = {}
for d, hs in jours.items():
if len(hs) >= HEURES_MIN:
med = statistics.median(v for l in hs.values() for v in l)
J[d] = {h: statistics.mean(l) - med for h, l in hs.items()}
if len(J) < 2:
return None
profil = [statistics.median(q[h] for q in J.values() if h in q) for h in range(24) if any(h in q for q in J.values())]
if len(profil) < 24:
return None
ressemblance = {}
for d, p in J.items():
autres = [q for e, q in J.items() if e != d]
hs = [h for h in p if all(h in q for q in autres)]
ressemblance[d] = _corr([p[h] for h in hs], [statistics.median(q[h] for q in autres) for h in hs])
return profil, ressemblance
def sinus_r2(ms, col):
"""Part de la courbe expliquée par une sinusoïde de 24 h (moindres carrés, 3 inconnues), ou None si trop court."""
pts = [(m["t"].timestamp(), m[col]) for m in ms if m[col] is not None]
if len(pts) <= 48:
return None
rows = [(1.0, math.sin(W * t), math.cos(W * t)) for t, _ in pts]
A = [[sum(r[i] * r[j] for r in rows) for j in range(3)] for i in range(3)]
B = [sum(r[i] * y for r, (_, y) in zip(rows, pts)) for i in range(3)]
for i in range(3): # élimination de Gauss
for k in range(i + 1, 3):
f = A[k][i] / A[i][i]
A[k] = [x - f * y for x, y in zip(A[k], A[i])]
B[k] -= f * B[i]
x = [0.0] * 3
for i in (2, 1, 0):
x[i] = (B[i] - sum(A[i][j] * x[j] for j in range(i + 1, 3))) / A[i][i]
m = statistics.mean(y for _, y in pts)
sst = sum((y - m) ** 2 for _, y in pts)
sse = sum((y - sum(c * v for c, v in zip(x, r))) ** 2 for r, (_, y) in zip(rows, pts))
return 1 - sse / sst if sst else None
def sinus(mesures, cols=("corr_x", "corr_y")):
"""-> (cibles dont un axe suit une sinusoïde de 24 h, cibles évaluées)."""
oui, evaluees = set(), set()
for s, ms in mesures.items():
if ms[0]["pattern_type"] == "global_ref":
continue
for col in cols:
r2 = sinus_r2(ms, col)
if r2 is not None:
evaluees.add(s)
if r2 >= R2_MIN:
oui.add(s)
return oui, evaluees
def cycle(mesures, cols=("corr_x", "corr_y")):
"""-> (axes concernés [(capteur, col, profil, ressemblance)], nombre de cibles évaluées)."""
concernes, cibles = [], set()
for s, ms in mesures.items():
if ms[0]["pattern_type"] == "global_ref":
continue
for col in cols:
r = _axe(ms, col)
if r is None:
continue
cibles.add(s)
if statistics.median(r[1].values()) >= REPRO:
concernes.append((s, col) + r)
return concernes, len(cibles)
def ecarts(concernes):
"""Écart médian (sur les axes concernés) au niveau de nuit, heure par heure, en part de l'amplitude du profil."""
def score(p, h):
debut = min(range(24), key=lambda i: max(p[(i + k) % 24] for k in range(NUIT)) - min(p[(i + k) % 24] for k in range(NUIT)))
nuit = statistics.median(p[(debut + k) % 24] for k in range(NUIT))
return abs(p[h] - nuit) / (max(p) - min(p))
return [statistics.median(score(c[2], h) for c in concernes) for h in range(24)]
def heures_chaudes(concernes):
return [h for h, e in enumerate(ecarts(concernes)) if e >= CHAUD]
def detect(mesures):
"""Cycle des courbes corrigées (l'ouvrage) ; sinon, celui des positions brutes (la caméra qui bouge par dilatation
de son support, compensée : D-074, 2026-10-27)."""
return (_episodes(mesures, ("corr_x", "corr_y"), "Thermal", False) or
_episodes(mesures, ("x", "y"), "Camera thermal", True) or glissades(mesures))
def _signes(ms, col):
"""{instant: +1 ou -1} où la mesure s'écarte d'au moins ECART bruits de la médiane du jour d'avant."""
k = [(m["t"], m[col]) for m in ms if m[col] is not None]
if len(k) < 3:
return {}
bruit = statistics.median(abs(b - a) for (_, a), (_, b) in zip(k, k[1:]))
out, j = {}, 0
for i, (t, v) in enumerate(k):
while k[j][0] < t - timedelta(days=1):
j += 1
avant = [w for _, w in k[j:i]]
if bruit and len(avant) >= 3 and abs(v - statistics.median(avant)) >= ECART * bruit:
out[t] = 1 if v > statistics.median(avant) else -1
return out
def _communs(series):
"""[{instant: signe}] d'un groupe de capteurs -> instants où au moins PART d'entre eux s'écartent du même côté."""
n, compte = len(series), {}
for sg in series:
for t, x in sg.items():
compte.setdefault((t, x), 0)
compte[(t, x)] += 1
return {t for (t, x), c in compte.items() if n and c >= PART * n}
def glissades(mesures):
"""Glissade commune de la caméra, sans cycle de 24 h : les positions brutes de la plupart des capteurs, références
comprises, et les courbes corrigées de la plupart des cibles s'écartent ensemble, du même côté, de leur jour d'avant."""
cibles = [ms for ms in mesures.values() if ms[0]["pattern_type"] != "global_ref"]
brut = set().union(*(_communs([_signes(ms, c) for ms in mesures.values()]) for c in ("x", "y")))
corr = set().union(*(_communs([_signes(ms, c) for ms in cibles]) for c in ("corr_x", "corr_y")))
episodes = []
for t in sorted(brut & corr):
if episodes and t - episodes[-1][1] <= timedelta(days=1): # moins d'un jour entre deux : la même glissade
episodes[-1][1] = t
else:
episodes.append([t, t])
return [{"start": iso(a), "end": iso(b), "kind": "Thermal displacement", "label": "Camera thermal movement",
"text": "The camera moved with a change of temperature and all the curves moved with it; this is not a "
"movement of the structure, nothing to do.", "ignore": False, "sensors": sorted(mesures)}
for a, b in episodes]
def _episodes(mesures, cols, nom, camera):
concernes, n = cycle(mesures, cols)
capteurs = sorted({c[0] for c in concernes})
if not n or len(capteurs) < PART * n:
return []
if not camera: # seconde méthode, pour l'ouvrage seul : la sinusoïde doit le voir aussi
oui, evaluees = sinus(mesures, cols)
if not evaluees or len(oui) < PART * len(evaluees):
return []
chaudes = heures_chaudes(concernes)
if len(chaudes) < CHAUDES_MIN:
return []
e = ecarts(concernes)
pic = max(chaudes, key=lambda h: e[h]) # le plus grand écart au niveau de nuit : fin de la dilatation
jours = sorted({d for c in concernes for d in c[3]})
if camera: # toute l'image bouge, références comprises
capteurs = sorted(mesures)
episodes = []
for d in jours: # ponytail: jours complets seulement, les bouts d'export (22:00 → minuit) n'ont pas d'épisode
if statistics.median(c[3][d] for c in concernes if d in c[3]) < JOUR:
continue
minuit = datetime(d.year, d.month, d.day, tzinfo=timezone.utc)
for label, a, b in ((f"{nom} expansion", chaudes[0], pic), (f"{nom} contraction", pic, chaudes[-1] + 1)):
if b > a:
episodes.append({"start": iso(minuit + timedelta(hours=a)), "end": iso(minuit + timedelta(hours=b)),
"kind": "Thermal displacement", "label": label, "text": "", "ignore": False, "sensors": capteurs})
return episodes
if __name__ == "__main__":
mesures = charger(sys.argv[1])
for e in detect(mesures):
print(e["start"], "→", e["end"], e["label"], len(e["sensors"]), "cibles")
for cols in (("corr_x", "corr_y"), ("x", "y")):
concernes, n = cycle(mesures, cols)
k = len({c[0] for c in concernes})
amp = statistics.median(max(c[2]) - min(c[2]) for c in concernes) if concernes else 0
oui, evaluees = sinus(mesures, cols)
print(f"{cols[0][:-2] or 'brut'} : cibles {k}/{n}, amplitude médiane {amp:.3f} px, heures chaudes (UTC) "
f"{heures_chaudes(concernes) if concernes else '-'} ; sinusoïde : cibles {len(oui)}/{len(evaluees)}")
+324
View File
@@ -0,0 +1,324 @@
"""Journal du matin : le détecteur de la famille Visibility (labeling/familles.md) : on voit moins bien, l'image est faible
ou floue (error_value), ou elle tremble (turbulence, en fin de fichier). Le même calcul de l'error_value trouve aussi les
objets devant quelques cibles (Brief obstruction, Target obscured) : episodes() les rend avec la famille Obstruction, que
detect() laisse à obstruction.py.
Méthode (seuils provisoires ci-dessous) :
1. Mesure « haute » : error_value > médiane + 10 MAD du capteur sur l'export, et > 2 × médiane, ou rejetée (> error_threshold)
et > 1,2 × médiane : un capteur au niveau habituel de 0,6 ne double jamais, et FLORIDA (boucle, lot 01) montrait ses brouillards
en Target obscured.
2. Brief obstruction : un instant où au moins 3 capteurs sont hauts, 3 fois plus qu'aux instants voisins (train, véhicule),
sans référence (global_ref) parmi eux : un pic d'un pas qui touche les références n'est pas un obstacle devant des
cibles (pic de toute l'image, NORDEND le 01.09 11:15, lot 01 de la boucle) ; il n'est pas montré. Sauf si au moins
BREF_MIN cibles sont rejetées (> error_threshold) à cet instant et ni à l'instant d'avant ni à celui d'après : un
passage devant elles, une référence touchée en plus (/detector-learner Displacement, modification 1, S5 : trains de
NIEDERHORN, 12 et 13 cibles rejetées ; NORDEND le 01.09 11:15 n'a aucun rejet).
3. Poor visibility : suites d'au moins 3 mesures hautes par capteur, réunies entre capteurs (au moins 2), réduites aux instants
où au moins 15 % du pic de l'épisode est haut ; le texte dit si des références (global_ref) sont touchées.
4. Target obscured : une cible (pas une global_ref) rejetée (> error_threshold) et à plus de 5 MAD, au moins 3 fois à moins de 6 h
d'écart, la plupart hors des épisodes 2 et 3 (feuilles, neige, reflet sur une cible). Tous les épisodes : ignore = True.
5. Niveau d'une Poor visibility (point 38 du plan, validé le 2026-10-24), mesure par mesure : « none » (on ne voit rien) quand
au moins MOITIE des cibles habituellement vues (sous leur seuil la moitié du temps au moins) sont rejetées, « reduced »
(données moyennes) sinon ; un épisode par période de même niveau, avec le champ level. Sur les cas : NORDEND le 09.10
08:45 → 10:30 et 21:30 → 23:15, le 14.10 05:15 → 06:00 en none ; buées de NORDEND et de E-001, toile de E-002, pluie
de E-005 en reduced.
6. Bornes d'une Poor visibility (boucle WILDSTRUBEL, lot 01) : de la première à la dernière mesure où une cible est
rejetée (> error_threshold), et pas d'épisode sans cible rejetée. Sur une chaussée en plein soleil, l'error_value de
jour (×1,5 à ×3, la turbulence) faisait durer la visibilité réduite des heures sans aucun rejet (28.09 10:00 → 12:15,
29.09 jusqu'à 14:15) ; les références ne comptent pas : R3 y passe son seuil presque toute la journée. Benchmark :
le seul épisode perdu est celui, faux, de E-010.
7. Poor visibility ou objet (frontière « Visibility ou Obstruction » de labeling/familles.md ; boucle /detector-learner
BREITHORN, lot 01) : une gêne qui ne touche qu'au plus QUELQUES cibles, et aucune référence, n'est pas diffuse : c'est
un objet devant elles (un véhicule stationné), un épisode « Target obscured » de toute sa durée, sans niveau.
Résultats (2026-10-23) :
- PS_DES_COUDRES (E-001, buée 13.10 23:45 → 14.10 05:15, 2 références sur 3) : Poor visibility 13.10 23:45 → 14.10 04:45, REF_G et
REF_D ; aussi la nuit d'avant, 13.10 01:15 → 03:30, mêmes références (hors vérité, pas d'image : sans doute la même buée).
- NORDEND juillet (E-002, toile 28.07 20:45 → 31.07 03:00, reprise 31.07 20:30) : Poor visibility 28.07 20:45 → 31.07 02:45 (20 capteurs)
et 31.07 20:30 → fin (18), références comprises.
- WILDSTRUBEL (E-003, turbulence de jour) : pas de Poor visibility (error_value ×1,5 à ×3 seulement : laissé au détecteur turbulence) ;
3 Brief obstruction de jour (02.09 12:00, 03.09 08:15, 04.09 14:00 : un véhicule sur la route à 14:00, image ; les deux
premières touchent des références et ne sont plus montrées depuis le lot 01 de la boucle NORDEND) ; PA_9 en
Target obscured chaque matin dès 04:30, jusqu'à 06:45, 08:15 ou 12:00 (soleil sur la cible, probable).
- CLARIDEN (E-004, mouvement réel) : rien sur le groupe à error_value durablement haute (bon) ; Brief obstruction 18.09 13:40
et 20.09 06:20 (tunnel : taches assombries, non établi ; références touchées, plus montrées depuis le lot 01) ;
Target obscured PR-284 19.09 18:30 → 18:50.
- NIEDERHORN (E-005) : trains 30.09 22:00, 01.10 12:00 et 21:00, 02.10 21:00 (celui du 03.10 10:00, 2 cibles, manqué) ;
pluie 01.10 06:00 → 11:00 et 02.10 03:00 → 11:00 (vérité 05:00 et 03:00 → 11:00), références intactes ; feuilles 02.10 10:00 → 22:00.
- NORDEND octobre (cas/2026-10_NORDEND) : Poor visibility 07.10 17:15 → 08.10 12:15 (buée du 08.10 02:30), 09.10 07:45 → 14:00
(parois ruisselantes), 09.10 20:45 → 23:45 (17 rejets à 23:00, retour à 00:00), 13.10 09:45 → 10:30, 14.10 05:15 → 06:30
(taches pâles à l'aube) ; Brief obstruction 12.10 14:15 (09.10 18:45 touche CTR04 : plus montrée depuis le lot 01) ;
Target obscured surtout CTR01, PR04, PR09 (souvent rejetées) : à vérifier.
- FLORIDA (boucle, lot 01 ; cibles au niveau 0,6 pour un seuil de 0,7) : les brouillards du 18.10, du 20-21.10, du 23.10 et
du 24-25.10, avant en Target obscured, en Poor visibility (none et reduced en alternance, cœur seul : à 10 MAD) ; la référence
r1_r au-dessus de son seuil du 22.10 au 24.10 reste manquée (son MAD de 0,15 rend 10 MAD hors d'atteinte).
Version simple essayée le 2026-10-24 (point 11 du plan), à la demande de l'utilisateur : part des cibles rejetées au-dessus
de leur seuil, sans comparer chaque capteur à son propre niveau. Moins bonne sur cinq jeux sur six (buée de E-001 manquée,
toile de E-002 morcelée, turbulence de E-003 prise pour une perte de visibilité) et grisait le vrai mouvement de E-004 :
l'utilisateur a remis cette version en service ; la simple est gardée dans archive/visibilite_simple.py.
"""
import os
import statistics
import sys
from datetime import timedelta
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "agent-tools"))
from donnees import charger, iso # noqa: E402
K_MAD = 10 # provisoire, réglé sur E-001 (buée : 11 à 57 MAD) et E-005 (pluie, trains : 10 à 70 MAD)
FACTEUR = 2 # provisoire : écarte les capteurs à MAD quasi nulle (E-004 : PWD_REF10 ×1,6 à 14 MAD, E-005)
SUITE_MIN = 3 # provisoire : mesures hautes d'affilée pour une mauvaise visibilité (E-001, E-005 pluie)
BREF_MIN = 3 # provisoire, réglé sur E-005 (trains : 5 à 17 capteurs ; celui de 2 cibles est manqué)
K_CIBLE = 5 # provisoire, réglé sur E-005 (feuilles : 6 à 25 MAD, rejetées)
CIBLE_MIN = 3 # provisoire : rejets répétés d'une cible
FRAC = 0.15 # provisoire : coupe les queues de PR09 + CTR01 (NORDEND octobre) sans couper la toile (E-002)
ECART = 2.5 # provisoire : pas tolérés entre deux mesures hautes d'une même suite (un pas manquant, horloge à la seconde près)
COUPURE = timedelta(hours=2) # provisoire : accalmie qui sépare deux épisodes (NORDEND octobre, nuit du 13 au 14.10)
SAILLIE = 3 # provisoire : un train ressort d'au moins 3 fois les instants voisins (E-005 : 5 à 17 contre 0 à 2 ;
# la toile de E-002 varie de 2 à 9 d'un pas à l'autre)
CIBLE_ECART = timedelta(hours=6) # provisoire, réglé sur E-005 (feuilles : 7 rejets en 12 h, jusqu'à 5 h d'écart)
FACTEUR_REJET = 1.2 # provisoire : un rejet à 10 MAD compte aussi (boucle FLORIDA, lot 01 : niveaux de 0,6, ×2 hors d'atteinte) ;
# écarte C24 de E-009 (niveau 0,68 au ras du seuil 0,7, rejeté à ×1,04)
MOITIE = 0.5 # provisoire : « on ne voit rien » ; réglé sur NORDEND (09.10 23:00 : 68 % rejetées) et E-005 (pluie : 24 à 33 %)
QUELQUES = 3 # provisoire : Poor visibility sur au plus 3 cibles, sans référence : un objet, Target obscured (7) ;
# boucle /detector-learner BREITHORN, lot 01 (véhicules stationnés devant 2 ou 3 cibles sur 12)
def _pas(mesures):
ts = sorted({m["t"] for v in mesures.values() for m in v})
return statistics.median(b - a for a, b in zip(ts, ts[1:]))
def _grouper(points, ecart):
"""[(t, capteur)] triés par t -> groupes [(début, fin, {capteurs}, [t])] dont les points sont à ≤ ecart les uns des autres."""
groupes = []
for t, s in points:
if groupes and t - groupes[-1][1] <= ecart:
g = groupes[-1]
groupes[-1] = (g[0], t, g[2] | {s}, g[3] + [t])
else:
groupes.append((t, t, {s}, [t]))
return groupes
def _episode(debut, fin, label, text, capteurs, level=None):
e = {"start": iso(debut), "end": iso(fin), "kind": "Visibility" if label == "Poor visibility" else "Obstruction",
"label": label, "text": text,
"ignore": level != "reduced", "sensors": sorted(capteurs)} # visibilité réduite : données moyennes, pas grisées
return {**e, "level": level} if level else e
def _niveaux(mesures, instants):
"""t -> "none" si au moins MOITIE des cibles habituellement vues sont rejetées à t, "reduced" sinon."""
ratios = []
for v in mesures.values():
r = {m["t"]: m["error_value"] / m["error_threshold"] for m in v if m["error_value"] is not None and m["error_threshold"]}
if r and statistics.median(r.values()) < 1:
ratios.append(r)
return {t: "none" if sum(r.get(t, 0) > 1 for r in ratios) >= MOITIE * max(1, sum(t in r for r in ratios)) else "reduced"
for t in instants}
def episodes(mesures):
"""Tous les épisodes de l'error_value : Visibility (Poor visibility), Obstruction (Brief obstruction, Target obscured)."""
ecart = ECART * _pas(mesures)
refs = {s for s, v in mesures.items() if v[0]["pattern_type"] == "global_ref"}
instants = sorted({m["t"] for v in mesures.values() for m in v})
hautes, rejets = {}, {} # capteur -> [t]
refuses = set() # instants où une cible (pas une global_ref) est au-dessus de son seuil
rejetees = {} # t -> {cibles au-dessus de leur seuil}
for s, v in mesures.items():
e = [m["error_value"] for m in v if m["error_value"] is not None]
if len(e) < 10:
continue
med = statistics.median(e)
mad = statistics.median(abs(x - med) for x in e) or 1e-9
for m in v:
x = m["error_value"]
if x is None:
continue
rejete = m["error_threshold"] and x > m["error_threshold"]
if rejete and s not in refs:
refuses.add(m["t"])
rejetees.setdefault(m["t"], set()).add(s)
if x > med + K_MAD * mad and (x > FACTEUR * med or rejete and x > FACTEUR_REJET * med):
hautes.setdefault(s, []).append(m["t"])
if s not in refs and rejete and x > med + K_CIBLE * mad:
rejets.setdefault(s, []).append(m["t"])
par_t = {} # t -> {capteurs hauts}
for s, ts in hautes.items():
for t in ts:
par_t.setdefault(t, set()).add(s)
n = lambda t: len(par_t.get(t, ())) # noqa: E731
out = []
# 2. Brief obstruction : un instant où beaucoup de capteurs sont hauts, au moins SAILLIE fois plus qu'aux instants voisins.
brefs = set()
for i, t in enumerate(instants):
voisins = [n(instants[j]) for j in (i - 1, i + 1) if 0 <= j < len(instants)]
if n(t) >= BREF_MIN and n(t) >= SAILLIE * max(voisins):
brefs.add(t)
seules = rejetees.get(t, set()).difference(*(rejetees.get(instants[j], set()) for j in (i - 1, i + 1)
if 0 <= j < len(instants)))
if par_t[t] & refs and len(seules) < BREF_MIN: # références touchées sans cibles rejetées à ce seul instant :
continue # pas un obstacle devant des cibles, l'image entière
out.append(_episode(t, t, "Brief obstruction", f"{n(t)} points were poorly seen for a single measurement, then came "
"back: probably a train, a vehicle or an animal passing; ignore this point on the curves.", par_t[t]))
# 3. Poor visibility : suites longues par capteur (sans les instants brefs), réunies entre capteurs,
# puis réduites aux instants où au moins FRAC du pic de l'épisode est haut (coupe les queues d'un ou deux capteurs
# et les longues accalmies, plus de COUPURE).
suites = []
for s, ts in hautes.items():
pts = [(t, s) for t in ts if t not in brefs]
suites += [(a, b, s) for a, b, _, l in _grouper(pts, ecart) if len(l) >= SUITE_MIN]
zones = [z for z in _grouper_intervalles(sorted(suites), ecart) if len(z[2]) >= 2]
gardees = []
for a, b, _ in zones:
dans = [t for t in instants if a <= t <= b and t not in brefs]
pic = max(n(t) for t in dans)
pts = [(t, s) for t in dans if n(t) >= max(1, FRAC * pic) for s in par_t[t]]
gardees += [(d, f, cs) for d, f, cs, l in _grouper(pts, max(ecart, COUPURE)) if len(cs) >= 2 and len(set(l)) >= SUITE_MIN]
# Bornes : de la première à la dernière cible rejetée ; sans rejet, pas d'épisode (6).
gardees = [(r[0], r[-1], cs) for a, b, cs in gardees if (r := [t for t in instants if a <= t <= b and t in refuses])]
niveau = _niveaux(mesures, instants)
for a, b, cs in gardees: # un épisode par période de même niveau (5) ; le texte vient de categories.py
if len(cs) <= QUELQUES and not cs & refs: # un objet devant quelques cibles, pas une gêne diffuse (7)
out.append(_episode(a, b, "Target obscured", "", cs))
continue
seg = []
for t in [t for t in instants if a <= t <= b] + [None]:
if seg and (t is None or niveau[t] != niveau[seg[0]]):
qui = cs & set().union(*(par_t.get(u, set()) for u in seg)) or cs
out.append(_episode(seg[0], seg[-1], "Poor visibility", "", qui, niveau[seg[0]]))
seg = []
if t is not None:
seg.append(t)
dedans = lambda t: t in brefs or any(a <= t <= b for a, b, _ in gardees) # noqa: E731
# 4. Target obscured : une cible rejetée à répétition, surtout hors des épisodes ci-dessus.
cibles = []
for s, ts in rejets.items():
for a, b, _, l in _grouper([(t, s) for t in ts], CIBLE_ECART):
if len(l) >= CIBLE_MIN and sum(map(dedans, l)) * 2 < len(l):
cibles.append((a, b, s))
for a, b, cs in _grouper_intervalles(sorted(cibles), timedelta(0)):
qui, it, its = ("One target was", "it", "its") if len(cs) == 1 else (f"{len(cs)} targets were", "them", "their")
out.append(_episode(a, b, "Target obscured", f"{qui} repeatedly lost while the targets around stayed clear: probably "
f"something in front of {it} (leaves, snow) or glare; {its} displacements in this period are unreliable.", cs))
return sorted(out, key=lambda e: e["start"])
def _grouper_intervalles(intervalles, ecart):
"""[(début, fin, capteur)] triés -> [(début, fin, {capteurs})] des intervalles qui se chevauchent (à ecart près)."""
out = []
for a, b, s in intervalles:
if out and a - out[-1][1] <= ecart:
out[-1] = (out[-1][0], max(out[-1][1], b), out[-1][2] | {s})
else:
out.append((a, b, {s}))
return out
def detect(mesures):
return [e for e in episodes(mesures) if e["kind"] == "Visibility"] + turbulence(mesures)
# --- Turbulence ----------------------------------------------------------------------------------------------------
# Turbulence atmosphérique (bruit rapide sur les déplacements corrigés).
#
# Méthode :
# 1. Par capteur et par heure H, sur les mesures de [H − 1 h, H + 2 h) : agitation = médiane de |Δcorr_x| + |Δcorr_y|
# entre mesures successives (robuste aux sauts d'un seul pas), et médiane de l'error_value.
# 2. Chacune est rapportée au calme du capteur : le quartile bas de ses valeurs horaires sur l'export (souvent la nuit).
# 3. Heure turbulente : au moins la moitié des capteurs à ≥ 1,5 fois leur agitation calme, et error_value médiane
# des capteurs à ≥ 1,5 fois la calme (l'air chaud brouille les taches : E-003, critère 1).
# 4. Heures voisines fusionnées (trou d'une heure toléré), épisode d'au moins 3 h, écarté si plus de 15 % des mesures
# sont rejetées (c'est alors de la mauvaise visibilité, autre détecteur). Grisé si l'agitation médiane ≥ 2×.
#
# Résultats (2026-10-23, seuils ci-dessous) :
# - WILDSTRUBEL (E-003, vérité : chaque jour ~03:30 → 16:00) : 3 épisodes, 02.09 04:00-15:00, 03.09 05:00-15:00,
# 04.09 04:00-15:00, les 13 capteurs, ×2,3 à ×2,6, tous grisés.
# - PS_DES_COUDRES (sain, buée une nuit), NORDEND juillet (toile d'araignée), CLARIDEN (mouvement réel),
# NIEDERHORN (trains, pluie), NORDEND octobre (11 jours) : aucun épisode. Écartés en route : midis agités sans
# error_value en hausse (PS des Coudres, NORDEND octobre), toile et pluie par les rejets (18 à 43 %), le matin du
# mouvement de CLARIDEN (06:00-08:00) par la durée.
RATIO = 1.5 # provisoire, réglé sur E-003 (WILDSTRUBEL : de jour, corr ×1,7 à ×3 la nuit)
PART = 0.5 # provisoire : part des capteurs agités en même temps
RATIO_ERR = 1.5 # provisoire, réglé sur E-003 (error_value ×1,7 à ×3,2 la nuit ; ≈ ×1 à midi ailleurs)
REJET_MAX = 0.15 # provisoire : E-003 ≤ 7 % ; toile d'araignée (E-002) et pluie (E-005) ≥ 18 %
FORT = 2.0 # provisoire : E-003 (×2,3 à ×2,6) est fort ; un épisode entre ×1,5 et ×2 reste visible
DUREE_MIN = timedelta(hours=3) # provisoire : E-003 dure 10-11 h ; écarte le matin du mouvement réel de E-004 (2 h),
# que le classement écarte aussi, quelle que soit la durée (point 14 du plan)
HEURE = timedelta(hours=1)
def _heure(t):
return t.replace(minute=0, second=0, microsecond=0)
def _rapports(points):
"""[(t, valeur)] -> {heure H: médiane sur [H − 1 h, H + 2 h) / quartile bas de ces médianes}."""
par = {}
for t, v in points:
for k in (-1, 0, 1):
par.setdefault(_heure(t) + k * HEURE, []).append(v)
med = {h: statistics.median(v) for h, v in par.items() if len(v) >= 3}
if len(med) < 8:
return {}
calme = statistics.quantiles(med.values(), n=4)[0]
return {h: v / calme for h, v in med.items()} if calme > 0 else {}
def heures(mesures):
"""-> {heure: {capteur: (agitation / calme, error_value / calme)}}."""
out = {}
for s, ms in mesures.items():
ag = _rapports([(b["t"], abs(b["corr_x"] - a["corr_x"]) + abs(b["corr_y"] - a["corr_y"]))
for a, b in zip(ms, ms[1:]) if a["corr_x"] is not None and b["corr_x"] is not None])
er = _rapports([(m["t"], m["error_value"]) for m in ms if m["error_value"] is not None])
for h, r in ag.items():
if h in er:
out.setdefault(h, {})[s] = (r, er[h])
return out
def _turbulente(r):
return (sum(a >= RATIO for a, _ in r.values()) >= PART * len(r)
and statistics.median(e for _, e in r.values()) >= RATIO_ERR)
def turbulence(mesures):
H = heures(mesures)
blocs = []
for h in sorted(h for h, r in H.items() if _turbulente(r)):
if blocs and h - blocs[-1][-1] <= 2 * HEURE:
blocs[-1].append(h)
else:
blocs.append([h])
episodes = []
for b in blocs:
debut, fin = b[0], b[-1] + HEURE
dedans = [m for ms in mesures.values() for m in ms if debut <= m["t"] < fin]
if fin - debut < DUREE_MIN or sum(m["corr_x"] is None for m in dedans) > REJET_MAX * len(dedans):
continue
par_capteur = {}
for h in b:
for s, (a, _) in H[h].items():
par_capteur.setdefault(s, []).append(a)
agit = {s: statistics.median(v) for s, v in par_capteur.items()}
fort = statistics.median(agit.values())
episodes.append({
"start": iso(debut), "end": iso(fin), "kind": "Visibility",
"label": "Heat shimmer",
"text": f"Readings were about {fort:.1f}× noisier than in calm hours because of heat shimmer "
"(warm air trembling in the line of sight); the small fast wiggles are not movement.",
"ignore": fort >= FORT,
"sensors": sorted(s for s, v in agit.items() if v >= RATIO),
})
return episodes
if __name__ == "__main__":
for e in detect(charger(sys.argv[1])):
print(e["start"], "→", e["end"], e["label"], f"| {len(e['sensors'])} :", ",".join(e["sensors"][:8]), "|", e["text"])