2026-11-03 14:57:52 +01:00
|
|
|
|
"""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.
|
2026-10-23 21:52:08 +02:00
|
|
|
|
|
|
|
|
|
|
Méthode (seuils provisoires ci-dessous) :
|
2026-10-26 18:19:23 +01:00
|
|
|
|
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.
|
2026-10-26 15:37:54 +01:00
|
|
|
|
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
|
2026-11-05 10:08:11 +01:00
|
|
|
|
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).
|
2026-10-23 21:52:08 +02:00
|
|
|
|
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.
|
2026-10-24 12:22:06 +02:00
|
|
|
|
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
|
2026-10-29 07:25:29 +01:00
|
|
|
|
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.
|
2026-10-27 09:49:47 +01:00
|
|
|
|
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 :
|
2026-10-29 07:25:29 +01:00
|
|
|
|
le seul épisode perdu est celui, faux, de E-010.
|
2026-11-03 14:34:48 +01:00
|
|
|
|
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.
|
2026-10-23 21:52:08 +02:00
|
|
|
|
|
2026-11-03 14:57:52 +01:00
|
|
|
|
Résultats (2026-10-23) :
|
2026-10-29 07:25:29 +01:00
|
|
|
|
- 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
|
2026-10-23 21:52:08 +02:00
|
|
|
|
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).
|
2026-10-29 07:25:29 +01:00
|
|
|
|
- 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)
|
2026-10-23 21:52:08 +02:00
|
|
|
|
et 31.07 20:30 → fin (18), références comprises.
|
2026-10-29 07:25:29 +01:00
|
|
|
|
- WILDSTRUBEL (E-003, turbulence de jour) : pas de Poor visibility (error_value ×1,5 à ×3 seulement : laissé au détecteur turbulence) ;
|
2026-10-26 15:37:54 +01:00
|
|
|
|
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
|
2026-10-23 21:52:08 +02:00
|
|
|
|
Target obscured chaque matin dès 04:30, jusqu'à 06:45, 08:15 ou 12:00 (soleil sur la cible, probable).
|
2026-10-29 07:25:29 +01:00
|
|
|
|
- CLARIDEN (E-004, mouvement réel) : rien sur le groupe à error_value durablement haute (bon) ; Brief obstruction 18.09 13:40
|
2026-10-26 15:37:54 +01:00
|
|
|
|
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.
|
2026-10-29 07:25:29 +01:00
|
|
|
|
- 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é) ;
|
2026-10-23 21:52:08 +02:00
|
|
|
|
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
|
2026-10-26 15:37:54 +01:00
|
|
|
|
(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.
|
2026-10-26 18:19:23 +01:00
|
|
|
|
- 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).
|
2026-10-24 12:22:06 +02:00
|
|
|
|
|
|
|
|
|
|
Version simple essayée le 2026-10-24 (point 11 du plan), à la demande de l'utilisateur : part des cibles rejetées au-dessus
|
2026-10-29 07:25:29 +01:00
|
|
|
|
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 :
|
2026-10-24 12:22:06 +02:00
|
|
|
|
l'utilisateur a remis cette version en service ; la simple est gardée dans archive/visibilite_simple.py.
|
2026-10-23 21:52:08 +02:00
|
|
|
|
"""
|
|
|
|
|
|
import os
|
|
|
|
|
|
import statistics
|
|
|
|
|
|
import sys
|
|
|
|
|
|
from datetime import timedelta
|
|
|
|
|
|
|
2026-10-28 17:19:51 +01:00
|
|
|
|
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "agent-tools"))
|
2026-10-23 21:52:08 +02:00
|
|
|
|
from donnees import charger, iso # noqa: E402
|
|
|
|
|
|
|
2026-10-29 07:25:29 +01:00
|
|
|
|
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)
|
2026-10-23 21:52:08 +02:00
|
|
|
|
CIBLE_MIN = 3 # provisoire : rejets répétés d'une cible
|
2026-10-29 07:25:29 +01:00
|
|
|
|
FRAC = 0.15 # provisoire : coupe les queues de PR09 + CTR01 (NORDEND octobre) sans couper la toile (E-002)
|
2026-10-23 21:52:08 +02:00
|
|
|
|
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)
|
2026-10-29 07:25:29 +01:00
|
|
|
|
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)
|
2026-10-26 18:19:23 +01:00
|
|
|
|
FACTEUR_REJET = 1.2 # provisoire : un rejet à 10 MAD compte aussi (boucle FLORIDA, lot 01 : niveaux de 0,6, ×2 hors d'atteinte) ;
|
2026-10-29 07:25:29 +01:00
|
|
|
|
# é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 %)
|
2026-11-03 14:34:48 +01:00
|
|
|
|
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)
|
2026-10-23 21:52:08 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
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
|
|
|
|
|
|
|
|
|
|
|
|
|
2026-10-24 12:22:06 +02:00
|
|
|
|
def _episode(debut, fin, label, text, capteurs, level=None):
|
2026-11-03 14:57:52 +01:00
|
|
|
|
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
|
2026-10-24 12:22:06 +02:00
|
|
|
|
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}
|
2026-10-23 21:52:08 +02:00
|
|
|
|
|
|
|
|
|
|
|
2026-11-03 14:57:52 +01:00
|
|
|
|
def episodes(mesures):
|
|
|
|
|
|
"""Tous les épisodes de l'error_value : Visibility (Poor visibility), Obstruction (Brief obstruction, Target obscured)."""
|
2026-10-23 21:52:08 +02:00
|
|
|
|
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]
|
2026-10-27 09:49:47 +01:00
|
|
|
|
refuses = set() # instants où une cible (pas une global_ref) est au-dessus de son seuil
|
2026-11-05 10:08:11 +01:00
|
|
|
|
rejetees = {} # t -> {cibles au-dessus de leur seuil}
|
2026-10-23 21:52:08 +02:00
|
|
|
|
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
|
2026-10-26 18:19:23 +01:00
|
|
|
|
rejete = m["error_threshold"] and x > m["error_threshold"]
|
2026-10-27 09:49:47 +01:00
|
|
|
|
if rejete and s not in refs:
|
|
|
|
|
|
refuses.add(m["t"])
|
2026-11-05 10:08:11 +01:00
|
|
|
|
rejetees.setdefault(m["t"], set()).add(s)
|
2026-10-26 18:19:23 +01:00
|
|
|
|
if x > med + K_MAD * mad and (x > FACTEUR * med or rejete and x > FACTEUR_REJET * med):
|
2026-10-23 21:52:08 +02:00
|
|
|
|
hautes.setdefault(s, []).append(m["t"])
|
2026-10-26 18:19:23 +01:00
|
|
|
|
if s not in refs and rejete and x > med + K_CIBLE * mad:
|
2026-10-23 21:52:08 +02:00
|
|
|
|
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)
|
2026-11-05 10:08:11 +01:00
|
|
|
|
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
|
2026-10-23 21:52:08 +02:00
|
|
|
|
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]
|
2026-10-27 09:49:47 +01:00
|
|
|
|
# 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])]
|
2026-10-24 12:22:06 +02:00
|
|
|
|
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
|
2026-11-03 14:34:48 +01:00
|
|
|
|
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
|
2026-10-24 12:22:06 +02:00
|
|
|
|
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)
|
2026-10-23 21:52:08 +02:00
|
|
|
|
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
|
|
|
|
|
|
|
|
|
|
|
|
|
2026-11-03 14:57:52 +01:00
|
|
|
|
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
|
|
|
|
|
|
|
2026-10-23 21:52:08 +02:00
|
|
|
|
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"])
|