215 lines
14 KiB
Python
215 lines
14 KiB
Python
"""Journal du matin : visibilité / taux d'erreur de reconnaissance (error_value), un épisode grisé par moment douteux.
|
||
|
||
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é.
|
||
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 ; vérité : events/INDEX.md) :
|
||
- 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": "visibilite", "label": label, "text": text,
|
||
"ignore": True, "sensors": sorted(capteurs)}
|
||
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 detect(mesures):
|
||
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
|
||
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"])
|
||
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)
|
||
if par_t[t] & refs: # références touchées : pas un obstacle devant des cibles (carte : références intactes)
|
||
continue
|
||
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
|
||
|
||
|
||
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"])
|