Grade visibility, add the periodic effect and the slow drift to the morning journal (D-056)

- Visibility: v0 kept after a measured trial of a simpler version (archived); two levels, Reduced and No visibility
- Thermal: a 24-hour sinusoid confirms the daily wave, split into thermal expansion and contraction events
- Jumps tested from the first measurement; turbulence never kept over a shift to check (CLARIDEN)
- Data gaps say whether camera images exist; Displacements trends become slow drift events
- Threshold registry moved to vues-deplacements/contexte/seuils-du-journal.md; plan points 11 to 17, 38 and 41 validated

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
maximeandClaude Opus 5.5 committed 2026-10-24 12:22:06 +02:00
1 parent 4ac95ae1ca
commit 86547f089b
16 files changed
+475 -143

No files matched your search

+1 -1
View File
@@ -18,7 +18,7 @@ Le code et les maquettes du chantier vivent dans `maquette/` (D-053, D-054) : `e
Détection mécanique des anomalies (D-055) : faire ressortir les courbes qui comptent, sans toucher aux données : les sauts (décalage soudain qui dure) et les tendances (hausse ou baisse lente), ce que regarde le client ; onglet `Displacements` de la maquette ; idée, méthode, résultats et pistes dans `contexte/detection-d-anomalies.md`, savoir métier dans `docs/displacement/domaine/ce-que-regarde-le-client.md`.
Journal du matin du client (D-056), le cap actuel : onglet `Journal` de la maquette ; un détecteur élémentaire par fichier dans `journal/` (`detect(mesures)` -> épisodes `start`, `end`, `kind`, `label`, `text`, `ignore`, `sensors`), chargés et classés en événements des huit catégories du journal par `journal/categories.py` (`python3 vues-deplacements/journal/categories.py <dossier>` : une ligne par événement), que `explore.py` affiche ; brainstorming et pistes dans `contexte/journal-du-matin.md`, lissage dans `contexte/lissage.md`, données en masse et boucle Claude dans `contexte/donnees-et-boucle.md`.
Journal du matin du client (D-056), le cap actuel : onglet `Journal` de la maquette ; un détecteur élémentaire par fichier dans `journal/` (`detect(mesures)` -> épisodes `start`, `end`, `kind`, `label`, `text`, `ignore`, `sensors`), chargés et classés en événements des huit catégories du journal par `journal/categories.py` (`python3 vues-deplacements/journal/categories.py <dossier>` : une ligne par événement), que `explore.py` affiche ; brainstorming et pistes dans `contexte/journal-du-matin.md`, registre des seuils provisoires dans `contexte/seuils-du-journal.md`, lissage dans `contexte/lissage.md`, données en masse et boucle Claude dans `contexte/donnees-et-boucle.md`.
## Règles
@@ -88,3 +88,7 @@ Un orchestrateur (la conversation principale) et un agent par piste, qui rapport
## Page Journal simplifiée (point 8 du plan, 2026-10-24)
- Frise d'une seule ligne « What happened » et journal en cartes : validé, mais l'utilisateur n'est « pas entièrement satisfait » ; on pourrait **déplier** au lieu de tout mettre sur une même ligne (point 40 du plan).
## Cycle thermique et effet périodique (point 13 du plan, 2026-10-24)
- Des ouvrages bougent beaucoup le jour par dilatation thermique et redescendent la nuit : de grosses vagues, tout à fait normales (l'utilisateur ne se souvient plus du projet qui le montrait).
- Idée de l'utilisateur : un « effet périodique » qui explique ces anomalies ; la vague est un événement de dilatation ou de contraction thermique ; le reconnaître en ajustant une sinusoïde de 24 h (ou un polynôme en vague) : si elle colle, l'événement est cyclique, calqué sur le jour et la nuit. Point 41 du plan ; note `docs/displacement/domaine/cycle-thermique.md`.
@@ -0,0 +1,44 @@
# Seuils du journal du matin : le registre
Tous les seuils des détecteurs du journal (`vues-deplacements/journal/`) sont **provisoires** : réglés sur les six jeux des cas C-001 à C-005 et de NORDEND d'octobre. Quand les données en masse arriveront (partie VI du plan `docs/superpowers/plans/2026-10-23-journal-du-matin.md`), c'est la liste à revoir. Une constante ajoutée ou changée met à jour ce fichier dans le même changement. Contrôle : `grep -nE "^[A-Z_0-9]+ = " vues-deplacements/journal/*.py`.
Registre au 2026-10-24 (point 17 du plan), vérifié contre le code.
| Détecteur | Constante | Valeur | Réglée sur |
|---|---|---|---|
| `visibilite` | `K_MAD` | 10 | C-001 (buée 11 à 57 MAD), C-005 (10 à 70 MAD) |
| | `FACTEUR` | 2 | écarte les capteurs à MAD quasi nulle (C-004, C-005) |
| | `SUITE_MIN` | 3 | C-001, pluie de C-005 |
| | `BREF_MIN` | 3 | trains de C-005 (5 à 17 capteurs) |
| | `SAILLIE` | 3 | trains (5 à 17) contre toile de C-002 (2 à 9) |
| | `FRAC` | 0,15 | queues de PR09 et CTR01 (NORDEND octobre) |
| | `COUPURE` | 2 h | NORDEND octobre, nuit du 13 au 14 |
| | `K_CIBLE` | 5 | feuilles de C-005 (6 à 25 MAD) |
| | `CIBLE_MIN` | 3 | — |
| | `CIBLE_ECART` | 6 h | feuilles de C-005 (7 rejets en 12 h) |
| | `ECART` | 2,5 pas | gigue des horodatages |
| | `MOITIE` | 0,5 | niveau « none » (point 38) : NORDEND 09/10 23:00 (68 % rejetées) contre pluie de C-005 (24 à 33 %) |
| `sauts` | `K` | 20 bruits | C-001 (à 15, deux cibles saines grisées) ; ne pas baisser pour les trains, vus par `visibilite` (point 12) |
| | `BASE` | 4 mesures | 1 h à 15 min |
| | `GAP` | 1 h | — |
| | `BACK_H` | 24 h | C-002 (paliers jusqu'à 11 h 30) |
| `thermique` | `HEURES_MIN` | 20 h | — |
| | `REPRO` | 0,6 | bruit pur ≈ 0 |
| | `PART` | 0,5 | NORDEND octobre juste dessous (9/19), laissé dessous (point 13) |
| | `CHAUD` | 0,3 | — |
| | `JOUR` | 0,5 | — |
| | `NUIT` | 8 h | — |
| | `R2_MIN` | 0,3 | sinusoïde de 24 h (point 41) : PS des Coudres 14 axes sur 22 au-dessus, CLARIDEN 0 sur 48 |
| `turbulence` | `RATIO` | 1,5 | C-003 (×1,7 à ×3 la nuit) |
| | `PART` | 0,5 | — |
| | `RATIO_ERR` | 1,5 | C-003 (×1,7 à ×3,2) |
| | `REJET_MAX` | 15 % | C-003 ≤ 7 % ; toile et pluie ≥ 18 % |
| | `FORT` | 2× | C-003 (×2,3 à ×2,6) |
| | `DUREE_MIN` | 3 h | C-003 (10-11 h) contre matin de C-004 (2 h) ; le classement écarte aussi ce matin, quelle que soit la durée (point 14) |
| `trous` | `MISSING` | 2 pas | consigne de l'utilisateur, 2026-10-23 |
| `categories` (classement) | `MERGE` | 1 h | règle validée par l'utilisateur (point 5) : même catégorie à moins d'une heure, un seul événement |
| dérive lente (`explore.py`, onglet Displacements, D-055) | `TREND_DAYS` | 5 jours | une tendance demande au moins 5 jours UTC |
| | `TREND_SIZE` | 1 | dérive sur la période ≥ une amplitude journalière |
| | `TREND_STEADY` | 0,6 | tau de Kendall des niveaux journaliers |
Essais archivés (`vues-deplacements/journal/archive/`) : la version simple de `visibilite` (`NIVEAU` 0,2, `CIBLE_MIN` 3, `CIBLE_ECART` 6 h), écartée au point 11 ; ses constantes ne sont pas en service.
@@ -0,0 +1,92 @@
"""Essai archivé le 2026-10-24 : version simple de la visibilité (point 11 du plan), moins bonne que la v0 restée en service
(journal/visibilite.py) ; comparaison sur les six jeux : point 11 du plan.
Journal du matin : visibilité, version simple.
Une cible est rejetée quand son error_value dépasse son error_threshold. Seules comptent les cibles habituellement vues
(sous leur seuil au moins la moitié du temps sur l'export) : une cible que la caméra ne voit presque jamais ne dit rien
de la visibilité du moment (PS des Coudres : PM_G ; NIEDERHORN : sept références « e »).
1. Poor visibility : au moins NIVEAU des cibles rejetées, sur deux mesures d'affilée ou plus (une mesure plus basse entre
deux hautes compte haute : la part rejetée oscille autour du niveau, C-002).
2. Brief obstruction : la même chose sur une seule mesure (un passage).
3. Target obscured : une cible rejetée la plupart du temps (au moins la moitié de ses mesures), au moins CIBLE_MIN fois à
moins de CIBLE_ECART d'écart, quand la station, elle, voit clair.
Tous les épisodes sont grisés (ignore = True) ; les labels sont ceux que lit categories.py.
Usage : python3 vues-deplacements/journal/visibilite.py <dossier de station> (affiche les épisodes)
"""
import os
import statistics
import sys
from datetime import timedelta
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..", "..", "agents", "diagnostic", "outils"))
from donnees import charger, iso # noqa: E402
NIVEAU = 0.2 # provisoire, réglé sur NORDEND d'octobre (buée du 08/10 : 10 à 20 % rejetées), C-002 (toile : 30 à 40 %)
# et C-005 (pluie : 30 à 60 %) ; balayé de 0,15 à 0,3 le 2026-10-24
CIBLE_MIN = 3 # provisoire : rejets répétés d'une cible (v0)
CIBLE_ECART = timedelta(hours=6) # provisoire, réglé sur C-005 (feuilles : 7 rejets en 12 h, jusqu'à 5 h d'écart ; v0)
def _episode(debut, fin, label, capteurs):
return {"start": iso(debut), "end": iso(fin), "kind": "visibilite", "label": label, "text": "",
"ignore": True, "sensors": sorted(capteurs)}
def detect(mesures):
ratios = {} # capteur -> {t: error_value / error_threshold}
for s, v in mesures.items():
r = {m["t"].replace(second=0, microsecond=0): m["error_value"] / m["error_threshold"]
for m in v if m["error_value"] is not None and m["error_threshold"]}
if r and statistics.median(r.values()) < 1: # habituellement vue
ratios[s] = r
instants = sorted({t for r in ratios.values() for t in r})
rejetes = {t: {s for s, r in ratios.items() if r.get(t, 0) > 1} for t in instants}
vus = {t: sum(t in r for r in ratios.values()) for t in instants}
haut = [len(rejetes[t]) >= NIVEAU * vus[t] > 0 for t in instants]
for k in range(1, len(instants) - 1): # une mesure basse entre deux hautes
haut[k] = haut[k] or (haut[k - 1] and haut[k + 1])
out = []
# 1 et 2 : suites de mesures où la station voit mal ; une seule mesure, c'est un passage.
k = 0
while k < len(instants):
if not haut[k]:
k += 1
continue
j = k
while j + 1 < len(instants) and haut[j + 1]:
j += 1
cs = set().union(*(rejetes[instants[i]] for i in range(k, j + 1)))
out.append(_episode(instants[k], instants[j], "Poor visibility" if j > k else "Brief obstruction", cs))
k = j + 1
# 3 : une cible rejetée la plupart du temps pendant que la station voit clair.
clair = {t for t, h in zip(instants, haut) if not h}
refs = {s for s, v in mesures.items() if v[0]["pattern_type"] == "global_ref"}
cibles = []
for s, r in ratios.items():
if s in refs:
continue
ts = [t for t in sorted(r) if t in clair and r[t] > 1]
groupe = ts[:1]
for t in ts[1:] + [None]:
if t is not None and t - groupe[-1] <= CIBLE_ECART:
groupe.append(t)
continue
mesurees = [u for u in r if groupe and groupe[0] <= u <= groupe[-1]]
if len(groupe) >= CIBLE_MIN and 2 * len(groupe) >= len(mesurees):
cibles.append((groupe[0], groupe[-1], s))
groupe = [t]
for a, b, s in sorted(cibles): # les cibles masquées en même temps forment un seul épisode
if out and out[-1]["label"] == "Target obscured" and iso(a) <= out[-1]["end"]:
out[-1]["end"] = max(out[-1]["end"], iso(b))
out[-1]["sensors"] = sorted(set(out[-1]["sensors"]) | {s})
else:
out.append(_episode(a, b, "Target obscured", {s}))
return sorted(out, key=lambda e: e["start"])
if __name__ == "__main__":
for e in detect(charger(sys.argv[1])):
print(e["start"], "→", e["end"], e["label"], f"| {len(e['sensors'])} :", ",".join(e["sensors"][:8]))
+31 -17
View File
@@ -3,7 +3,9 @@
Chaque épisode reçoit sa catégorie d'après son détecteur et son label. Un saut revenu à la normale qui chevauche une
perte de visibilité, un passage ou une turbulence y est absorbé ; un saut qui dure ou trop récent pour savoir ne l'est
jamais. Deux événements de même catégorie à moins d'une heure n'en font qu'un. Chaque événement reçoit sa phrase
jamais ; une turbulence qui chevauche un saut à vérifier n'est pas gardée (un vrai mouvement agite aussi les courbes :
le matin du mouvement de CLARIDEN, point 14 du plan). Deux événements de même catégorie à moins d'une heure n'en font
qu'un. Chaque événement reçoit sa phrase
(point 9, validées le 2026-10-24) : ce qui s'est passé et quoi en faire, sans conditionnel ; la cause n'est dite que si la
catégorie l'établit, sinon les images la montrent. Pas de fonction detect : le chargeur ne prend pas ce fichier pour un
détecteur.
@@ -21,21 +23,27 @@ from donnees import charger # noqa: E402
# ignore : zone grisée (None : comme le dit le détecteur, la turbulence n'est grisée que forte) ; process : bouton
# Images, rien, ou Images et lien vers Diagnosis. L'ordre est celui des lignes de la frise.
CATEGORIES = {
"visibilite_perdue": {"label": "Loss of visibility", "ignore": True, "process": "images"},
"visibilite_reduite": {"label": "Reduced visibility", "ignore": False, "process": "images"}, # en retrait (point 38)
"visibilite_nulle": {"label": "No visibility", "ignore": True, "process": "images"},
"passage": {"label": "Passing obstacle", "ignore": True, "process": "images"},
"cible_masquee": {"label": "Target hidden", "ignore": True, "process": "images"},
"turbulence": {"label": "Heat haze", "ignore": None, "process": "aucun"},
"cycle_thermique": {"label": "Daily thermal cycle", "ignore": False, "process": "aucun"},
"dilatation_thermique": {"label": "Thermal expansion", "ignore": False, "process": "aucun"}, # effet périodique
"contraction_thermique": {"label": "Thermal contraction", "ignore": False, "process": "aucun"}, # (point 41)
"trou": {"label": "No data", "ignore": False, "process": "aucun"},
"saut_bref": {"label": "Brief jump", "ignore": True, "process": "images"},
"a_verifier": {"label": "Shift to check", "ignore": False, "process": "verifier"},
}
# (détecteur, label de l'épisode) -> catégorie ; puis détecteur seul ; un détecteur inconnu garde son nom
LABELS = {("visibilite", "Poor visibility"): "visibilite_perdue", ("visibilite", "Brief obstruction"): "passage",
("visibilite", "Target obscured"): "cible_masquee", ("sauts", "Sudden jump, back to normal"): "saut_bref",
("sauts", "Lasting shift"): "a_verifier", ("sauts", "Jump, not back yet"): "a_verifier"}
KINDS = {"turbulence": "turbulence", "thermique": "cycle_thermique", "trous": "trou"}
HOSTS = {"visibilite_perdue", "passage", "turbulence"} # ce qui absorbe un saut revenu à la normale (point 5)
# (détecteur, label, niveau de l'épisode) -> catégorie ; puis détecteur seul ; un détecteur inconnu garde son nom
LABELS = {("visibilite", "Poor visibility", "reduced"): "visibilite_reduite",
("visibilite", "Poor visibility", "none"): "visibilite_nulle",
("visibilite", "Brief obstruction", None): "passage", ("visibilite", "Target obscured", None): "cible_masquee",
("sauts", "Sudden jump, back to normal", None): "saut_bref", ("sauts", "Lasting shift", None): "a_verifier",
("sauts", "Jump, not back yet", None): "a_verifier",
("thermique", "Thermal expansion", None): "dilatation_thermique",
("thermique", "Thermal contraction", None): "contraction_thermique"}
KINDS = {"turbulence": "turbulence", "trous": "trou"}
HOSTS = {"visibilite_reduite", "visibilite_nulle", "passage", "turbulence"} # absorbent un saut revenu (point 5)
MERGE = timedelta(hours=1) # même catégorie à moins d'une heure : un seul événement (point 5, 2026-10-24)
@@ -59,7 +67,7 @@ def detecteurs():
def categorie(ep):
return LABELS.get((ep["kind"], ep["label"])) or KINDS.get(ep["kind"]) or ep["kind"]
return LABELS.get((ep["kind"], ep["label"], ep.get("level"))) or KINDS.get(ep["kind"]) or ep["kind"]
def overlap(a, b):
@@ -77,16 +85,18 @@ def phrase(cat, groupe, sensors, references):
sauts = [e for e in groupe[1:] if categorie(e) == "saut_bref"]
jumped = len({s for e in sauts for s in e["sensors"]})
lasting = len({s for e in groupe if categorie(e) == "a_verifier" for s in e.get("lasting", [])})
refs = ", including the reference targets" if references & set(sensors) else ""
text = {
"visibilite_perdue": f"The camera could not see {targets(n)} clearly"
f"{', including the reference targets' if references & set(sensors) else ''}. "
"The curves in this period are not reliable: ignore them.",
"visibilite_nulle": f"The camera could not see {targets(n)} clearly{refs}. "
"The curves in this period are not reliable: ignore them.",
"visibilite_reduite": f"The camera saw {targets(n)} less clearly than usual{refs}. "
"The data in this period are less precise: use them with care.",
"passage": f"Something passed in front of {targets(n)} for a single measurement. Ignore this point on the curves.",
"cible_masquee": 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.",
"turbulence": "Warm air made the readings shake. The small fast wiggles are not movement.",
"cycle_thermique": "The structure and the camera warm up during the day and cool down at night. "
"This wave comes back every day: nothing to do.",
"dilatation_thermique": "The structure expands in the day heat. This daily wave is normal: nothing to do.",
"contraction_thermique": "The structure contracts as it cools down. This daily wave is normal: nothing to do.",
"saut_bref": f"{targets(n).capitalize()} jumped and came back. This is not a movement: ignore it.",
"a_verifier": (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
@@ -104,7 +114,8 @@ def evenement(groupe, references):
cat = categorie(groupe[0])
c = CATEGORIES.get(cat, {"label": groupe[0]["label"], "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"]))
return {"start": min(e["start"] for e in groupe), "end": max(e["end"] for e in groupe), "category": cat,
main = [e for e in groupe if categorie(e) == cat] # 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": c["label"], "text": phrase(cat, groupe, sensors, references),
"ignore": c["ignore"] if c["ignore"] is not None else any(e["ignore"] for e in groupe if categorie(e) == cat),
"sensors": sensors, "process": c["process"], "episodes": groupe}
@@ -114,6 +125,8 @@ 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 categorie(e) == "a_verifier"] # un vrai mouvement n'est jamais pris pour de la turbulence
eps = [e for e in eps if categorie(e) != "turbulence" or not any(overlap(e, c) for c in checks)]
hosts = [e for e in eps if categorie(e) in HOSTS]
host = {id(e): next((h for h in hosts if overlap(e, h)), None) for e in eps if categorie(e) == "saut_bref"}
groupes = {id(e): [e] for e in eps if not host.get(id(e))}
@@ -123,7 +136,8 @@ def classer(episodes, references=frozenset()):
merged = []
for g in groupes.values():
prev = next((m for m in reversed(merged) if categorie(m[0]) == categorie(g[0])), None)
if prev and datetime.fromisoformat(g[0]["start"]) - datetime.fromisoformat(max(e["end"] for e in prev)) < MERGE:
end = max((e["end"] for e in prev if categorie(e) == categorie(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)
+11 -4
View File
@@ -1,7 +1,8 @@
"""Sauts brutaux du journal du matin : corr_x / corr_y (px) de chaque cible, cadence native de l'export « advanced ».
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).
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 (BASE mesures de suite à moins de la moitié du saut) 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é (artefact).
3. Sinon « Lasting shift », jamais grisé (peut-être un vrai mouvement) ; moins d'un jour de recul :
@@ -19,7 +20,9 @@ Résultats (2026-10-23, K = 20) :
- C-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.
- C-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 manqué (première mesure) ; feuilles, pluie : rien (error_value, pas des sauts).
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é.
@@ -32,7 +35,8 @@ from pathlib import Path
sys.path.insert(0, str(Path(__file__).resolve().parents[2] / "agents" / "diagnostic" / "outils"))
import donnees # noqa: E402
K = 20 # provisoire, réglé sur C-001 : à 15, deux cibles saines y sont grisées (17 et 18 bruits)
K = 20 # provisoire, réglé sur C-001 : à 15, deux cibles saines y sont grisées (17 et 18 bruits) ; les trains de
# C-005 (17 et 19 bruits) sont attrapés par visibilite : ne pas baisser K
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 (C-002 : paliers jusqu'à 11 h 30)
@@ -44,7 +48,10 @@ def _sauts(t, v):
noise = statistics.median(abs(y - x) for x, y in zip(v, v[1:]))
# 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)
out, i = [], BASE # ponytail: les BASE premières mesures ne sont pas testées (train du 30/09 22:00 manqué)
# 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 * noise:
+72 -15
View File
@@ -1,14 +1,22 @@
"""Journal du matin : cycle thermique jour / nuit (la vague quotidienne des déplacements corrigés).
"""Journal du matin : effet périodique, 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é.
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. Un épisode par jour complet, de la première à la dernière heure chaude, si ce jour ressemble aux autres
(corrélation médiane ≥ 0,5 sur les axes concernés).
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 |
@@ -22,6 +30,7 @@ Résultats (2026-10-23 ; « cibles » = part des cibles concernées, amplitude =
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.
"""
import math
import os
import statistics
import sys
@@ -36,6 +45,8 @@ PART = 0.5 # provisoire : part des cibles concernées ; 2026-10_NORDEND
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
W = 2 * math.pi / 86400 # pulsation d'un cycle de 24 h, en rad/s
def _corr(a, b):
@@ -69,6 +80,43 @@ def _axe(ms, col):
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()
@@ -85,12 +133,17 @@ def cycle(mesures, cols=("corr_x", "corr_y")):
return concernes, len(cibles)
def heures_chaudes(concernes):
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 [h for h in range(24) if statistics.median(score(c[2], h) for c in concernes) >= CHAUD]
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):
@@ -98,31 +151,35 @@ def detect(mesures):
capteurs = sorted({c[0] for c in concernes})
if not n or len(capteurs) < PART * n:
return []
oui, evaluees = sinus(mesures)
if not evaluees or len(oui) < PART * len(evaluees): # seconde méthode : la sinusoïde doit le voir aussi
return []
chaudes = heures_chaudes(concernes)
if not chaudes:
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]})
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)
episodes.append({
"start": iso(minuit + timedelta(hours=chaudes[0])), "end": iso(minuit + timedelta(hours=chaudes[-1] + 1)),
"kind": "thermique", "label": "Daily thermal cycle",
"text": "The structure, the mast and the camera warm up during the day and move very slightly, "
"then cool down in the evening: this wave comes back every day and is normal.",
"ignore": False, "sensors": capteurs,
})
for label, a, b in (("Thermal expansion", chaudes[0], pic), ("Thermal contraction", pic, chaudes[-1] + 1)):
if b > a:
episodes.append({"start": iso(minuit + timedelta(hours=a)), "end": iso(minuit + timedelta(hours=b)),
"kind": "thermique", "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 |", e["text"])
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
print(f"{cols[0][:-2] or 'brut'} : cibles {k}/{n}, amplitude médiane {amp:.3f} px, heures chaudes (UTC) {heures_chaudes(concernes) if concernes else '-'}")
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)}")
+2 -1
View File
@@ -30,7 +30,8 @@ PART = 0.5 # provisoire : part des capteurs agités en même temps
RATIO_ERR = 1.5 # provisoire, réglé sur C-003 (error_value ×1,7 à ×3,2 la nuit ; ≈ ×1 à midi ailleurs)
REJET_MAX = 0.15 # provisoire : C-003 ≤ 7 % ; toile d'araignée (C-002) et pluie (C-005) ≥ 18 %
FORT = 2.0 # provisoire : C-003 (×2,3 à ×2,6) est fort ; un épisode entre ×1,5 et ×2 reste visible
DUREE_MIN = timedelta(hours=3) # provisoire : C-003 dure 10-11 h ; écarte le matin du mouvement réel de C-004 (2 h)
DUREE_MIN = timedelta(hours=3) # provisoire : C-003 dure 10-11 h ; écarte le matin du mouvement réel de C-004 (2 h),
# que le classement écarte aussi, quelle que soit la durée (point 14 du plan)
HEURE = timedelta(hours=1)
+36 -12
View File
@@ -7,6 +7,11 @@ Méthode (seuils provisoires ci-dessous) :
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 C-001, toile de C-002, pluie
de C-005 en reduced.
Résultats (2026-10-23 ; vérité : agents/diagnostic/cas/INDEX.md) :
- PS_DES_COUDRES (C-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
@@ -24,6 +29,11 @@ Résultats (2026-10-23 ; vérité : agents/diagnostic/cas/INDEX.md) :
(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 09.10 18:45 et 12.10 14:15 ; Target obscured surtout CTR01, PR04, PR09
(souvent rejetées) : à vérifier.
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 C-001 manquée,
toile de C-002 morcelée, turbulence de C-003 prise pour une perte de visibilité) et grisait le vrai mouvement de C-004 :
l'utilisateur a remis cette version en service ; la simple est gardée dans archive/visibilite_simple.py.
"""
import os
import statistics
@@ -45,6 +55,7 @@ COUPURE = timedelta(hours=2) # provisoire : accalmie qui sépare deux épisodes
SAILLIE = 3 # provisoire : un train ressort d'au moins 3 fois les instants voisins (C-005 : 5 à 17 contre 0 à 2 ;
# la toile de C-002 varie de 2 à 9 d'un pas à l'autre)
CIBLE_ECART = timedelta(hours=6) # provisoire, réglé sur C-005 (feuilles : 7 rejets en 12 h, jusqu'à 5 h d'écart)
MOITIE = 0.5 # provisoire : « on ne voit rien » ; réglé sur NORDEND (09.10 23:00 : 68 % rejetées) et C-005 (pluie : 24 à 33 %)
def _pas(mesures):
@@ -64,9 +75,21 @@ def _grouper(points, ecart):
return groupes
def _episode(debut, fin, label, text, capteurs):
return {"start": iso(debut), "end": iso(fin), "kind": "visibilite", "label": label, "text": text,
"ignore": True, "sensors": sorted(capteurs)}
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):
@@ -118,15 +141,16 @@ def detect(mesures):
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]
for a, b, cs in gardees:
r = cs & refs
if r:
text = (f"{len(cs)} points, including {len(r)} of the {len(refs)} reference points, were poorly seen: probably rain, "
"fog, condensation or something in front of the camera; all displacements in this period are unreliable.")
else:
text = (f"{len(cs)} targets were poorly seen, the reference points stayed clear: probably rain, fog or condensation; "
"the displacements of these targets in this period are unreliable.")
out.append(_episode(a, b, "Poor visibility", text, cs))
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
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.
+13 -1
View File
@@ -206,12 +206,24 @@ def build(folder):
plateforme = Path(folder).resolve().parent / "plateforme"
captures = {tab: [url(p) for n in prefixes for p in sorted(plateforme.glob(f"{n}_*"))[:1]]
for tab, prefixes in CAPTURES.items()}
journal = categories.evenements(mesures)
for e in journal: # un trou de mesures : des images pendant disent que la caméra tournait (point 15 du plan)
if e["category"] == "trou":
n = sum(e["start"] < im["t"] < e["end"] for im in images)
e["text"] += f" The camera still took {n} images in this period, so it was running." if n \
else " There is no camera image for this period either."
hr = hourly(files["horaire"][0]) if files["horaire"] else {"times": [], "sensors": {}}
regime, trends = regime_changes(hr)
for tr in trends: # dérive lente : les tendances de l'onglet Displacements (D-055), à vérifier (point 16 du plan)
journal.append({"start": tr["levels"][0][0], "end": tr["levels"][-1][0], "category": "derive_lente",
"label": "Slow drift", "text": f"{tr['target']} drifts slowly and steadily: {tr['drift']:+.1f} mm "
f"in {len(tr['levels'])} days. Keep watching it.", "ignore": False, "sensors": [tr["target"]],
"process": "aucun", "episodes": []})
journal.sort(key=lambda e: e["start"])
return {"platform": Path(files["advanced"][0]).name.split("_advanced_")[0], "times": [donnees.iso(t) for t in instants],
"sensors": sensors, "images": images, "view": view, "captures": captures,
"folder": Path(os.path.relpath(Path(folder).resolve(), ROOT)).as_posix(), # pour la demande à l'agent
"hourly": hr, "regime": regime, "trends": trends, "journal": categories.evenements(mesures),
"hourly": hr, "regime": regime, "trends": trends, "journal": journal,
"rules": {"abrupt": ABRUPT, "size": SIZE, "trend_size": TREND_SIZE, "trend_days": TREND_DAYS}}
@@ -929,12 +929,16 @@ drawRegime();
// ignorer grisées, une frise d'une seule ligne « What happened » (une barre par événement, sa catégorie dedans), puis le
// journal de la plage visible, une carte par événement.
const J = D.journal, J_ROW = "What happened";
// une couleur par famille d'événement : gris-bleu ce qu'il faut ignorer (zone grisée), vert ce qui est normal, gris clair
// l'absence de données, rouge ce qu'il faut vérifier
const J_FAM = { ignore: "#6f8aa3", normal: "#2ca02c", gap: "#c8c8c8", check: "#d62728" };
// ordre de dessin de la frise, de dessous à dessus : ce qui touche une cible, puis toute la scène, « Shift to check » en haut
const J_ORDER = ["cible_masquee", "cycle_thermique", "turbulence", "trou", "visibilite_perdue", "passage", "saut_bref", "a_verifier"];
const jFam = e => e.category === "a_verifier" ? "check" : e.category === "trou" ? "gap" : e.ignore ? "ignore" : "normal";
// une couleur par famille d'événement : gris-bleu ce qu'il faut ignorer (zone grisée), orange les données moyennes
// (visibilité réduite, zone en léger retrait), vert ce qui est normal (l'effet périodique), gris clair l'absence de données, rouge ce qu'il faut
// vérifier
const J_FAM = { ignore: "#6f8aa3", reduced: "#f0a030", normal: "#2ca02c", gap: "#c8c8c8", check: "#d62728" };
// ordre de dessin de la frise, de dessous à dessus : la dérive lente (longue, des jours), ce qui touche une cible, puis
// toute la scène, « Shift to check » en haut
const J_ORDER = ["derive_lente", "cible_masquee", "dilatation_thermique", "contraction_thermique", "turbulence", "trou", "visibilite_reduite", "visibilite_nulle", "passage",
"saut_bref", "a_verifier"];
const jFam = e => ["a_verifier", "derive_lente"].includes(e.category) ? "check" : e.category === "trou" ? "gap"
: e.category === "visibilite_reduite" ? "reduced" : e.ignore ? "ignore" : "normal";
const MON = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
const jWhen = t => `${MON[+t.slice(5, 7) - 1]} ${+t.slice(8, 10)}, ${t.slice(11, 16)}`;
const plotT = ms => new Date(ms).toISOString().slice(0, 19).replace("T", " "); // instant en ms -> date Plotly (UTC)
@@ -954,13 +958,15 @@ function drawJournal() {
traces.push({ type: "bar", orientation: "h", yaxis: "y3", name: "events", showlegend: false,
y: bars.map(() => J_ROW), base: bars.map(e => e.start), x: bars.map(e => jEnd(e) - Date.parse(e.start)),
marker: { color: bars.map(e => J_FAM[jFam(e)]), line: { color: "#fff", width: 1 } },
width: bars.map(e => e.category === "derive_lente" ? 0.2 : 0.75), // la dérive, longue, en trait fin sous les autres
text: bars.map(e => covered(e) ? "" : e.label), textposition: "inside", insidetextanchor: "middle",
insidetextfont: { color: bars.map(e => jFam(e) === "gap" ? "#333" : "#fff") }, customdata: bars.map(e => J.indexOf(e)),
hovertext: bars.map(e => `<b>${e.label}</b><br>${e.text}<br>Sensors: ${e.sensors.length ? e.sensors.join(", ") : "all"}`),
hovertemplate: "%{hovertext}<extra></extra>" });
const C = 220, G = 24, F = 40, A = 2 * C + 2 * G + F; // hauteurs en px, A : zone tracée
const grey = J.filter(e => e.ignore).flatMap(e => ["y domain", "y2 domain"].map(yref => ({ type: "rect", xref: "x", yref,
x0: e.start, x1: plotT(jEnd(e)), y0: 0, y1: 1, fillcolor: "#888", opacity: 0.25, line: { width: 0 }, layer: "below" })));
const grey = J.filter(e => e.ignore || jFam(e) === "reduced").flatMap(e => ["y domain", "y2 domain"].map(yref => ({ type: "rect",
xref: "x", yref, x0: e.start, x1: plotT(jEnd(e)), y0: 0, y1: 1, fillcolor: "#888", opacity: e.ignore ? 0.25 : 0.1,
line: { width: 0 }, layer: "below" }))); // grisé ; en léger retrait pour une visibilité réduite
const end = Date.parse(D.times[D.times.length - 1]);
Plotly.newPlot("j-curves", traces, {
height: A + 70, margin: { l: 110, r: 10, t: 20, b: 50 }, barmode: "overlay", bargap: 0.25, uniformtext: { mode: "hide", minsize: 10 },
+3 -3
View File
@@ -116,9 +116,9 @@ Le « journal du matin » du client (utilisateur, 2026-10-23) : il ouvre Explore
- **Événements** (2026-10-24, point 6 du plan) : `categories.evenements(mesures)` classe les épisodes en événements des huit catégories du journal (`docs/displacement/domaine/carte-des-evenements.md`, section 4) : un saut revenu à la normale pendant une perte de visibilité, un passage ou une turbulence y est absorbé, un saut qui dure jamais ; même catégorie à moins d'une heure, un seul événement. Événement : `{start, end, category, label, text, ignore, sensors, process, episodes}` (`episodes` : les épisodes d'origine, le principal en tête) ; c'est ce que la page reçoit dans `D.journal`.
- **`trous.py`** : les moments sans mesure, cadence de l'export rompue (plus de 2 pas manquants, cadence = écart médian), de la dernière mesure à la suivante ; label `No data`, pas grisé. Les autres (`visibilite`, `sauts`, `turbulence`, `thermique`) sont écrits à part.
- **Courbes** : `Horizontal (px)` = `corr_x`, `Vertical (px)` = `corr_y` de l'export « advanced », cibles seules (`target` et `ref`, pas les `global_ref`), lignes fines, axe du temps partagé ; vue de départ : les 3 derniers jours (`#from=AAAA-MM-JJ` dans l'adresse la fait partir d'un autre jour, pour les captures) ; zoom à la molette ou au cadre sur toute la plage, double-clic pour tout voir ; ordonnées recalées sur la plage visible (D-013).
- **Zones grisées** : un rectangle gris sur les deux courbes par épisode `ignore`.
- **Frise** sous les courbes, même axe du temps (2026-10-24, point 8 du plan ; avant : une ligne par détecteur, puis par catégorie) : **une seule ligne**, « What happened », une barre par événement, sa catégorie dedans si elle tient (`uniformtext` : sinon cachée) ; couleur par famille (`J_FAM`) : gris-bleu ce qui est grisé, vert ce qui est normal (cycle thermique, turbulence faible), gris clair « No data », rouge « Shift to check ». Les barres sont dessinées par portée (`J_ORDER`) : ce qui touche une cible en dessous, ce qui touche toute la scène au-dessus, « Shift to check » tout en haut ; une barre perd son étiquette quand une barre dessinée par-dessus couvre son milieu ; liseré blanc entre les barres. Survol : catégorie, texte et capteurs. Un événement plus court qu'une heure est dessiné sur 1 h, sinon il serait invisible.
- **Journal** : une carte par événement de la plage visible, dans l'ordre du temps, mise à jour à chaque zoom : bord gauche à la couleur de sa famille, date et heures UTC en petit, **catégorie en gras**, le texte (provisoire, point 9), le bouton `▶ Images` ; plus de liste de capteurs (elle reste au survol de la barre et viendra dans la couche support, point 23). `Nothing to report on this period.` sinon ; clic sur une carte : les courbes zooment sur l'événement, avec une marge (la moitié de sa durée, 2 h au moins).
- **Zones grisées** : un rectangle gris sur les deux courbes par événement `ignore` ; un rectangle très clair (en léger retrait) pour « Reduced visibility », dont les données sont gardées (point 38).
- **Frise** sous les courbes, même axe du temps (2026-10-24, point 8 du plan ; avant : une ligne par détecteur, puis par catégorie) : **une seule ligne**, « What happened », une barre par événement, sa catégorie dedans si elle tient (`uniformtext` : sinon cachée) ; couleur par famille (`J_FAM`) : gris-bleu ce qui est grisé, vert ce qui est normal (effet périodique : dilatation puis contraction thermiques ; turbulence faible), gris clair « No data », rouge « Shift to check » et « Slow drift » (la dérive, longue, en trait fin sous les autres barres, point 16), orange « Reduced visibility » (point 38). Les barres sont dessinées par portée (`J_ORDER`) : ce qui touche une cible en dessous, ce qui touche toute la scène au-dessus, « Shift to check » tout en haut ; une barre perd son étiquette quand une barre dessinée par-dessus couvre son milieu ; liseré blanc entre les barres. Survol : catégorie, texte et capteurs. Un événement plus court qu'une heure est dessiné sur 1 h, sinon il serait invisible.
- **Journal** : une carte par événement de la plage visible, dans l'ordre du temps, mise à jour à chaque zoom : bord gauche à la couleur de sa famille, date et heures UTC en petit, **catégorie en gras**, le texte (provisoire, point 9), le bouton `▶ Images` ; plus de liste de capteurs (elle reste au survol de la barre et viendra dans la couche support, point 23). Un trou de données dit en plus s'il y a des images pendant (`explore.build`, point 15 : « The camera still took N images in this period, so it was running. » ou « There is no camera image for this period either. »). `Nothing to report on this period.` sinon ; clic sur une carte : les courbes zooment sur l'événement, avec une marge (la moitié de sa durée, 2 h au moins).
- **Bouton `▶ Images`** (2026-10-24, point 7 du plan) : sur chaque entrée dont la catégorie a un processus d'images (toutes sauf turbulence, cycle thermique et trou), et au clic sur sa barre de la frise ; il ouvre une fenêtre par-dessus la page qui joue le timelapse des images de l'événement, de son début moins une marge à sa fin plus la marge (la moitié de la durée, 1 h au moins, 6 h au plus : `J_MARGIN`), pour encadrer l'événement de moments où tout va bien. Images recadrées sur les cibles (`D.view`, comme le zoom « Targets » de View), 4 par seconde (`J_FPS`), en boucle, une sur n au-delà de 60 (`J_MAX`) ; sous l'image, l'heure UTC, `Before` / `During` / `After` et le rang ; bord rouge pendant l'événement ; pause, image par image, `Close`, Échap ou clic à côté. Pas d'image dans la plage : bouton grisé et « No camera image for this period. ». Pas de fichier GIF : tout est joué dans la page. `#tab=journal&play=<n>` ouvre le timelapse de l'événement n au chargement, `&frame=<k>` l'arrête sur l'image k (captures). Vérifié par captures : NORDEND d'octobre le 14/10 (nuit à 04:30, aube grise à 05:45, jour à 07:15) ; PS des Coudres, nuit du 13/10 sans image (bouton grisé).
- **Vérifié** par captures Chrome headless le 2026-10-23 (`#tab=journal`, `#tab=journal&from=2026-10-07`) : NORDEND (cas d'octobre) et NIEDERHORN (`data/NIEDERHORN/`), avec `trous`, `visibilite` et `sauts` ; courbes, zones grisées, frise, libellés, journal de la plage visible ; le trou de NORDEND (15/10 22:30 → 16/10 01:15) en barre `No data`.
- **Pas encore vérifié** : le clic sur une entrée (zoom), le survol des barres, le zoom à la souris ; `turbulence` et `thermique` n'ont rien rendu sur ces deux cas.