Classify the morning journal into eight categories and validate plan points 1 to 10 (D-056)
- Event map regrouped into six families, 33 events including hypothetical ones, with the journal categories (section 4) - categories.py turns detector episodes into categorised events: absorption of brief jumps, merging, catégorique phrases - Journal tab: one "What happened" row coloured by family, cards, and an Images button playing the event's timelapse - Plan: user-validated points marked, points 39 and 40 added; anomaly definition clarified in D-056 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
ebcdb30375
commit
4ac95ae1ca
12 files changed
+480
-123
No files matched your search
@@ -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 seuls par `explore.py` ; 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`, lissage dans `contexte/lissage.md`, données en masse et boucle Claude dans `contexte/donnees-et-boucle.md`.
|
||||
|
||||
## Règles
|
||||
|
||||
|
||||
@@ -7,6 +7,7 @@ Notes de la conversation vocale du 2026-10-23 (utilisateur, après échange avec
|
||||
- Le projet s'est éparpillé : beaucoup d'analyses fines (sauts, tendances, compensation, agent de diagnostic) ; important, mais on s'y perd.
|
||||
- Revenir à du simple, terre à terre, côté **support** : des analyses élémentaires, qui **discréditent** certaines zones plutôt qu'elles ne mesurent des variations.
|
||||
- Changement de regard sur l'anomalie : ce n'est pas d'abord un vrai déplacement de l'ouvrage, ce sont surtout des « trucs nuls » : un train qui passe, de la neige ou une toile d'araignée sur une cible, la pluie, la buée, le soleil, la turbulence, plus assez de références (alors tout bouge un peu). **Une anomalie = un moment où il ne faut pas prendre les données en compte.**
|
||||
- **Précision de l'utilisateur (2026-10-24)** : une anomalie, c'est **tout ce qui sort de la norme**, tout ce qui fait que les courbes ne sont pas plates alors que rien ne bouge. Dans l'écrasante majorité des cas, ce n'est absolument pas grave (perte de visibilité et toutes les catégories de la carte) ; mais parfois c'est grave, d'un autre type : à Barcelone, la voûte du pont s'affaisse vraiment.
|
||||
|
||||
## L'idée : le journal du matin
|
||||
|
||||
@@ -19,7 +20,7 @@ Notes de la conversation vocale du 2026-10-23 (utilisateur, après échange avec
|
||||
- Garder les **images** et la technique des petits **GIF** (vignettes animées) : on voit tout de suite qu'on a perdu les cibles. Pas dans la v0.
|
||||
- Objectif de contrôle : si on donnait les mêmes données à Claude, il devrait voir de lui-même les mêmes catégories ; notre solution doit dire ce que Claude dirait.
|
||||
|
||||
## Les pistes, une par agent [en cours]
|
||||
## Les pistes, une par agent (toutes rendues le 2026-10-23)
|
||||
|
||||
Un orchestrateur (la conversation principale) et un agent par piste, qui rapporte à l'orchestrateur ; l'orchestrateur en discute avec l'utilisateur. Contrat commun des détecteurs : un fichier par détecteur dans `vues-deplacements/journal/`, `detect(mesures)` rend des épisodes (`start`, `end`, `label`, `text`, `ignore`, `sensors`).
|
||||
|
||||
@@ -74,3 +75,16 @@ Un orchestrateur (la conversation principale) et un agent par piste, qui rapport
|
||||
- la **preuve** : le gros saut, c'est généralement une mauvaise visibilité (souvent, pendant des heures, on ne voit rien) ; un bouton `Images` sur l'épisode ouvre une petite vidéo (timelapse, « GIF ») qui commence un peu avant et finit un peu après, sur des moments où tout va bien : le client voit tout de suite ;
|
||||
- des **statuts de visibilité**, comme les statuts des métriques système : visibilité moyenne (« quand il pleut, les données sont moyennes ») et visibilité nulle (« on ne voit rien »), par cible et pour la station.
|
||||
- Dans le plan : points 7, 11 et 38.
|
||||
|
||||
## Retours de la visite guidée (point 1 du plan, 2026-10-24)
|
||||
|
||||
- NORDEND d'octobre : rien à ajouter au constat de l'agent : les vrais épisodes sont grisés (buée du 08/10, parois ruisselantes du 09/10, aube du 14/10), PR17 reste à part ; mais « Target obscured » grise toutes les courbes pour une à quatre cibles (presque une journée du 13 au 14/10), deux étiquettes se contredisent le 14/10 à 05:15, les phrases ne sont pas catégoriques, une étiquette de la frise est illisible.
|
||||
- PS des Coudres : les deux nuits de buée sur REF_G et REF_D grisées, le cycle thermique de 08:00 à 18:00 non grisé ; défaut vu : 3 cibles sur 11 seulement dans les courbes (point 39 du plan).
|
||||
- Les quatre autres jeux : l'utilisateur les considère comme validés sans les voir un par un ; point 1 validé.
|
||||
|
||||
## Carte des événements (point 3 du plan, 2026-10-24)
|
||||
|
||||
- La carte n'a pas à s'appuyer sur des cas vus dans les données (peu de données passées dans le projet) : elle doit **englober toutes les possibilités**, un ouvrier qui abîme une cible, « tout et n'importe quoi », rangées en **familles**. On part de la base et on complète au fur et à mesure : `docs/displacement/domaine/carte-des-evenements.md` (33 événements, six familles).
|
||||
## 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).
|
||||
@@ -0,0 +1,148 @@
|
||||
"""Journal du matin : des épisodes des détecteurs aux événements catégorisés (point 6 du plan ; catégories validées le
|
||||
2026-10-24 : docs/displacement/domaine/carte-des-evenements.md, section 4).
|
||||
|
||||
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
|
||||
(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.
|
||||
Usage : python3 vues-deplacements/journal/categories.py <dossier de station> (une ligne par événement)
|
||||
"""
|
||||
import importlib.util
|
||||
import os
|
||||
import sys
|
||||
from datetime import datetime, timedelta
|
||||
from pathlib import Path
|
||||
|
||||
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..", "agents", "diagnostic", "outils"))
|
||||
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"},
|
||||
"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"},
|
||||
"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)
|
||||
MERGE = timedelta(hours=1) # même catégorie à moins d'une heure : un seul événement (point 5, 2026-10-24)
|
||||
|
||||
|
||||
def detecteurs():
|
||||
"""Modules de vues-deplacements/journal/*.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 LABELS.get((ep["kind"], ep["label"])) or KINDS.get(ep["kind"]) or ep["kind"]
|
||||
|
||||
|
||||
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(cat, groupe, sensors, references):
|
||||
"""Phrase du journal d'un événement (validées par l'utilisateur le 2026-10-24) ; un saut absorbé ajoute qu'il n'est
|
||||
pas un mouvement."""
|
||||
n, one = len(sensors), len(sensors) == 1
|
||||
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", [])})
|
||||
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.",
|
||||
"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.",
|
||||
"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
|
||||
else f"{targets(n).capitalize()} shifted; {lasting} of them stayed shifted.")
|
||||
+ " Check whether the structure moved: look at the images.",
|
||||
}.get(cat, groupe[0]["text"]) # trou, et un détecteur inconnu : le texte du détecteur
|
||||
if not jumped:
|
||||
return text
|
||||
return text + (f" The jump of {targets(jumped)} in this period is not a movement." if len(sauts) == 1
|
||||
else f" The jumps of {targets(jumped)} in this period are not movements.")
|
||||
|
||||
|
||||
def evenement(groupe, references):
|
||||
"""Épisodes d'un même événement, le principal en tête -> événement."""
|
||||
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,
|
||||
"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}
|
||||
|
||||
|
||||
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"])
|
||||
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))}
|
||||
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 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:
|
||||
prev += g
|
||||
else:
|
||||
merged.append(g)
|
||||
return sorted((evenement(g, references) for g in merged), key=lambda v: v["start"])
|
||||
|
||||
|
||||
def evenements(mesures):
|
||||
"""Mesures (donnees.charger) -> événements de tous les détecteurs : ce que la page reçoit dans D.journal."""
|
||||
episodes = []
|
||||
for mod in detecteurs():
|
||||
try:
|
||||
episodes += mod.detect(mesures)
|
||||
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__":
|
||||
for v in evenements(charger(sys.argv[1])):
|
||||
print(v["start"], "→", v["end"], f"{v['category']:<17}", "grisé" if v["ignore"] else "gardé",
|
||||
f"| {len(v['sensors']) or 'tous les'} capteurs", "| absorbés :", ", ".join(
|
||||
f"{e['kind']} {e['start'][5:16]}" for e in v["episodes"][1:]) or "—")
|
||||
@@ -108,7 +108,8 @@ def _episode(g):
|
||||
label = "Sudden jump, back to normal"
|
||||
text = f"{who} jumped and came back within a day: most likely a measurement artefact, not a movement."
|
||||
return {"start": donnees.iso(g["start"]), "end": donnees.iso(g["end"]), "kind": "sauts", "label": label,
|
||||
"text": text, "ignore": not lasting and not recent, "sensors": sorted(g["sensors"])}
|
||||
"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)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
|
||||
@@ -8,7 +8,6 @@ Usage : python3 vues-deplacements/maquette/explore.py [dossier de station] (d
|
||||
"""
|
||||
import csv
|
||||
import html
|
||||
import importlib.util
|
||||
import json
|
||||
import os
|
||||
import statistics
|
||||
@@ -24,8 +23,10 @@ OUT = ROOT / "out"
|
||||
DEFAULT = ROOT / "vues-deplacements" / "cas" / "2026-10_NORDEND" / "NORDEND"
|
||||
sys.path.insert(0, str(ROOT / "src"))
|
||||
sys.path.insert(0, str(ROOT / "agents" / "diagnostic" / "outils"))
|
||||
sys.path.insert(0, str(ROOT / "vues-deplacements" / "journal"))
|
||||
from common.page import AUTOSCALE_Y_JS, open_html # noqa: E402 (bascule seule sur .venv si plotly manque)
|
||||
import donnees # noqa: E402 (lecture des exports, bibliothèque standard)
|
||||
import categories # noqa: E402 (onglet Journal : détecteurs et classement en événements)
|
||||
|
||||
COLUMNS = ("error_value", "corr_x", "corr_y") # grandeurs de l'export « advanced » gardées pour la page, en plus de x, y
|
||||
KINDS = ("global_ref", "ref", "target") # ordre des lignes : références de la compensation, local reference, cibles
|
||||
@@ -169,22 +170,6 @@ def regime_changes(hr):
|
||||
return events, sorted(trends, key=lambda f: abs(f["drift"]) / f["swing"], reverse=True)
|
||||
|
||||
|
||||
def journal(mesures):
|
||||
"""Épisodes de tous les détecteurs de vues-deplacements/journal/*.py (onglet Journal), triés par début ; un détecteur
|
||||
qui plante est sauté avec un message."""
|
||||
episodes = []
|
||||
for path in sorted((HERE.parent / "journal").glob("*.py")):
|
||||
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)
|
||||
if hasattr(mod, "detect"):
|
||||
episodes += mod.detect(mesures)
|
||||
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)
|
||||
return sorted(episodes, key=lambda e: e["start"])
|
||||
|
||||
|
||||
def url(path):
|
||||
"""Chemin -> URL relative depuis out/, où la page est écrite."""
|
||||
return quote(Path(os.path.relpath(path, OUT)).as_posix())
|
||||
@@ -226,7 +211,7 @@ def build(folder):
|
||||
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": journal(mesures),
|
||||
"hourly": hr, "regime": regime, "trends": trends, "journal": categories.evenements(mesures),
|
||||
"rules": {"abrupt": ABRUPT, "size": SIZE, "trend_size": TREND_SIZE, "trend_days": TREND_DAYS}}
|
||||
|
||||
|
||||
|
||||
@@ -124,9 +124,20 @@
|
||||
|
||||
/* Onglet Journal (spec « L'onglet Journal ») : courbes, frise des épisodes, journal en texte de la plage visible. */
|
||||
#journal .hint { color: var(--muted); font-size: 12px; margin: 2px 0 10px; }
|
||||
.jentry { padding: 6px 4px; border-bottom: 1px solid var(--line); color: var(--text); cursor: pointer; }
|
||||
.jentry { margin: 0 0 8px; padding: 8px 10px; border: 1px solid var(--line); border-left: 5px solid; border-radius: 4px;
|
||||
background: #fff; color: var(--text); cursor: pointer; }
|
||||
.jentry:hover { background: #e8f0fb; }
|
||||
.jentry i { display: inline-block; width: 10px; height: 10px; border-radius: 2px; margin-right: 6px; }
|
||||
.jentry .when { color: var(--muted); font-size: 12px; }
|
||||
.jentry b { font-size: 14px; }
|
||||
.jentry button { margin-left: 6px; font-size: 12px; cursor: pointer; }
|
||||
/* Timelapse d'un événement (bouton ▶ Images) : fenêtre par-dessus la page, bord rouge pendant l'événement. */
|
||||
#j-video { position: fixed; inset: 0; z-index: 10; display: grid; place-items: center; background: rgba(0, 0, 0, .6); }
|
||||
#j-video[hidden] { display: none; }
|
||||
#j-video .box { background: #fff; padding: 12px; border-radius: 6px; }
|
||||
#j-video canvas { display: block; max-width: 88vw; max-height: 78vh; border: 5px solid transparent; }
|
||||
#j-video canvas.during { border-color: #d62728; }
|
||||
#j-video .bar { display: flex; gap: 8px; align-items: center; margin-top: 8px; color: var(--text); }
|
||||
#j-video .bar span { flex: 1; }
|
||||
.rtable { border-collapse: collapse; width: 100%; margin-top: 4px; color: var(--text); }
|
||||
.rtable th, .rtable td { padding: 5px 6px; border-bottom: 1px solid var(--line); text-align: left; white-space: nowrap; }
|
||||
.rtable th { color: var(--muted); font-weight: normal; white-space: normal; vertical-align: bottom; }
|
||||
@@ -253,9 +264,12 @@
|
||||
</div>
|
||||
<div class="pane" id="journal">
|
||||
<div id="j-curves"></div>
|
||||
<p class="hint">Grey zones: do not trust the data there (they are kept, not removed). Hover a bar for details; zoom the curves
|
||||
<p class="hint">Grey zones: do not trust the data there (they are kept, not removed). Hover a bar for details, ▶ Images to see the camera; zoom the curves
|
||||
with the wheel or by dragging, double-click for the whole period.</p>
|
||||
<div id="j-list"></div>
|
||||
<div id="j-video" hidden><div class="box"><canvas></canvas><div class="bar"><button type="button" data-v="-1">◀</button>
|
||||
<button type="button" data-v="p">❚❚ Pause</button><button type="button" data-v="1">▶</button><span></span>
|
||||
<button type="button" data-v="x">✕ Close</button></div></div></div>
|
||||
</div>
|
||||
</section>
|
||||
</main>
|
||||
@@ -912,13 +926,15 @@ function drawRegime() { // toutes les cibles en gris fin, celles qui ont sauté
|
||||
drawRegime();
|
||||
|
||||
// Onglet Journal (spec « L'onglet Journal ») : le journal du matin du client. Courbes corr_x et corr_y des cibles, zones à
|
||||
// ignorer grisées, une frise des épisodes (une ligne par détecteur), puis le journal en texte de la plage visible.
|
||||
const J = D.journal;
|
||||
const J_NAMES = { visibilite: "Visibility", sauts: "Jumps", turbulence: "Turbulence", thermique: "Thermal", trous: "Missing data" };
|
||||
const J_KINDS = [...new Set([...Object.keys(J_NAMES), ...J.map(e => e.kind)])].filter(k => J.some(e => e.kind === k));
|
||||
// une couleur fixe par détecteur, d'une station à l'autre ; vert pour ce qui est normal (le cycle thermique)
|
||||
const J_COLORS = { visibilite: "#1f77b4", sauts: "#d62728", turbulence: "#ff7f0e", thermique: "#2ca02c", trous: "#7f7f7f" };
|
||||
const jName = k => J_NAMES[k] || k, jColor = k => J_COLORS[k] || PALETTE[J_KINDS.indexOf(k) % PALETTE.length];
|
||||
// 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";
|
||||
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)
|
||||
@@ -930,15 +946,19 @@ function drawJournal() {
|
||||
type: "scatter", mode: "lines", x: D.times, y: s.values[c], yaxis: `y${r ? 2 : ""}`, name: s.name, showlegend: false,
|
||||
line: { color: PALETTE[n % PALETTE.length], width: 1 },
|
||||
hovertemplate: `${s.name} · %{x|%d %b %H:%M} UTC<br>${label} %{y:.2f} px<extra></extra>` })));
|
||||
for (const k of J_KINDS) { // frise : une barre par épisode, de son début à sa fin
|
||||
const eps = J.filter(e => e.kind === k);
|
||||
traces.push({ type: "bar", orientation: "h", yaxis: "y3", name: jName(k), showlegend: false,
|
||||
y: eps.map(() => jName(k)), base: eps.map(e => e.start), x: eps.map(e => jEnd(e) - Date.parse(e.start)),
|
||||
marker: { color: jColor(k) }, text: eps.map(e => e.label), textposition: "inside", insidetextanchor: "middle",
|
||||
insidetextfont: { color: "#fff" }, hovertext: eps.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 = 30 * Math.max(J_KINDS.length, 1), A = 2 * C + 2 * G + F; // hauteurs en px, A : zone tracée
|
||||
// frise : une barre par événement, de son début à sa fin, dans l'ordre de J_ORDER ; une barre perd son étiquette quand
|
||||
// une barre dessinée par-dessus couvre son milieu (sinon les textes se mêlent ; le survol dit tout)
|
||||
const bars = [...J].sort((u, v) => J_ORDER.indexOf(u.category) - J_ORDER.indexOf(v.category));
|
||||
const mid = e => (Date.parse(e.start) + jEnd(e)) / 2;
|
||||
const covered = e => bars.slice(bars.indexOf(e) + 1).some(o => Date.parse(o.start) <= mid(e) && jEnd(o) >= mid(e));
|
||||
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 } },
|
||||
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 end = Date.parse(D.times[D.times.length - 1]);
|
||||
@@ -947,33 +967,92 @@ function drawJournal() {
|
||||
xaxis: { type: "date", anchor: "y3", range: [ASKED.get("from") || plotT(end - 3 * 864e5), plotT(end)] }, // départ : les 3 derniers jours (#from=AAAA-MM-JJ : captures)
|
||||
yaxis: { domain: [1 - C / A, 1], fixedrange: true, title: { text: "Horizontal (px)" } },
|
||||
yaxis2: { domain: [1 - (2 * C + G) / A, 1 - (C + G) / A], fixedrange: true, title: { text: "Vertical (px)" } },
|
||||
yaxis3: { domain: [0, F / A], fixedrange: true, type: "category", categoryorder: "array",
|
||||
categoryarray: J_KINDS.map(jName).reverse(), showgrid: false }, // inversé : le premier détecteur en haut
|
||||
yaxis3: { domain: [0, F / A], fixedrange: true, type: "category", showgrid: false },
|
||||
shapes: grey,
|
||||
}, CONFIG).then(() => {
|
||||
autoscale("j-curves"); // les barres de la frise (ordonnées en texte) n'entrent pas dans le recalage
|
||||
const gd = document.getElementById("j-curves");
|
||||
gd.on("plotly_relayout", () => listJournal(gd.layout.xaxis.range.map(v => Date.parse(minute(v)))));
|
||||
gd.on("plotly_click", d => { // clic sur une barre de la frise : son timelapse, s'il y a des images à montrer
|
||||
const e = J[d.points[0].customdata];
|
||||
if (e && e.process !== "aucun" && jFrames(e).length) openTimelapse(e);
|
||||
});
|
||||
Plotly.relayout(gd, { "xaxis.range": gd.layout.xaxis.range.slice() }); // ordonnées et journal dès l'ouverture
|
||||
});
|
||||
}
|
||||
|
||||
function listJournal([a, b]) { // les épisodes de la plage visible, dans l'ordre du temps ; clic : zoom sur l'épisode
|
||||
function listJournal([a, b]) { // les événements de la plage visible, dans l'ordre du temps ; clic : zoom sur l'événement
|
||||
const eps = J.filter(e => Date.parse(e.end) >= a && Date.parse(e.start) <= b);
|
||||
document.getElementById("j-list").innerHTML = eps.length ? eps.map(e => `<div class="jentry" data-n="${J.indexOf(e)}">
|
||||
<i style="background:${jColor(e.kind)}"></i>${jWhen(e.start)}${e.end === e.start ? "" : ` – ${
|
||||
e.end.slice(0, 10) === e.start.slice(0, 10) ? e.end.slice(11, 16) : jWhen(e.end)}`} UTC · <b>${e.label}</b> · ${e.text}${
|
||||
e.sensors.length ? ` <span class="meta">(${e.sensors.join(", ")})</span>` : ""}</div>`).join("")
|
||||
document.getElementById("j-list").innerHTML = eps.length ? eps.map(e => `<div class="jentry" data-n="${J.indexOf(e)}"
|
||||
style="border-left-color:${J_FAM[jFam(e)]}"><div class="when">${jWhen(e.start)}${e.end === e.start ? "" : ` – ${
|
||||
e.end.slice(0, 10) === e.start.slice(0, 10) ? e.end.slice(11, 16) : jWhen(e.end)}`} UTC</div><b>${e.label}</b> · ${
|
||||
e.text}${e.process === "aucun" ? ""
|
||||
: jFrames(e).length ? '<button type="button">▶ Images</button>'
|
||||
: '<button type="button" disabled>▶ Images</button> <span class="meta">No camera image for this period.</span>'}</div>`).join("")
|
||||
: '<p class="empty">Nothing to report on this period.</p>';
|
||||
}
|
||||
document.getElementById("j-list").addEventListener("click", ev => {
|
||||
const el = ev.target.closest("[data-n]");
|
||||
if (!el) return;
|
||||
if (ev.target.closest("button")) return openTimelapse(J[+el.dataset.n]);
|
||||
const e = J[+el.dataset.n], a = Date.parse(e.start), b = Date.parse(e.end), m = Math.max((b - a) / 2, 2 * 3600e3); // marge
|
||||
Plotly.relayout("j-curves", { "xaxis.range": [plotT(a - m), plotT(b + m)] });
|
||||
});
|
||||
|
||||
// Bouton ▶ Images (point 7 du plan) : le timelapse des images de l'événement, encadré d'une marge avant et après où tout
|
||||
// va bien, pour que le client voie tout de suite qu'on ne distinguait plus les cibles. Recadré sur les cibles (D.view,
|
||||
// comme le zoom « Targets » de View), en boucle ; pas de fichier GIF, tout est joué ici.
|
||||
const J_MARGIN = [3600e3, 6 * 3600e3], J_FPS = 4, J_MAX = 60; // marge : la moitié de la durée, de 1 h à 6 h ; à régler à l'œil
|
||||
function jFrames(ev) { // images de la plage, une sur n au-delà de J_MAX, avec leur rôle : avant, pendant ou après
|
||||
const a = Date.parse(ev.start), b = Date.parse(ev.end), m = Math.min(J_MARGIN[1], Math.max(J_MARGIN[0], (b - a) / 2));
|
||||
const ims = IM.filter(im => Date.parse(im.t) >= a - m && Date.parse(im.t) <= b + m), n = Math.ceil(ims.length / J_MAX);
|
||||
return ims.filter((_, k) => k % n === 0).map(im => ({ ...im,
|
||||
role: Date.parse(im.t) < a ? "before" : Date.parse(im.t) > b ? "after" : "during" }));
|
||||
}
|
||||
const jv = document.getElementById("j-video"), jvCanvas = jv.querySelector("canvas"), jvInfo = jv.querySelector(".bar span");
|
||||
const jvPause = jv.querySelector('[data-v="p"]'), ROLE = { before: "Before", during: "During", after: "After" };
|
||||
let JV = { frames: [], imgs: [], k: 0, run: 0, playing: false };
|
||||
function jvShow(k) { // affiche l'image k une fois décodée
|
||||
JV.k = (k + JV.frames.length) % JV.frames.length;
|
||||
const f = JV.frames[JV.k], img = JV.imgs[JV.k];
|
||||
return img.decode().catch(() => {}).then(() => {
|
||||
if (!img.naturalWidth) return;
|
||||
const v = D.view || { x: [0, img.naturalWidth], y: [0, img.naturalHeight] };
|
||||
const x0 = Math.max(0, v.x[0]), y0 = Math.max(0, v.y[0]);
|
||||
const w = Math.min(img.naturalWidth, v.x[1]) - x0, h = Math.min(img.naturalHeight, v.y[1]) - y0;
|
||||
jvCanvas.width = w; jvCanvas.height = h;
|
||||
jvCanvas.getContext("2d").drawImage(img, x0, y0, w, h, 0, 0, w, h);
|
||||
jvCanvas.className = f.role === "during" ? "during" : "";
|
||||
jvInfo.textContent = `${utc(f.t)} · ${ROLE[f.role]} · ${JV.k + 1} / ${JV.frames.length}`;
|
||||
});
|
||||
}
|
||||
function jvPlay(on) { // lecture en boucle, l'image suivante une fois la précédente affichée
|
||||
JV.playing = on;
|
||||
const me = ++JV.run;
|
||||
jvPause.textContent = on ? "❚❚ Pause" : "▶ Play";
|
||||
const step = () => { if (me === JV.run) jvShow(JV.k + 1).then(() => setTimeout(step, 1000 / J_FPS)); };
|
||||
if (on) setTimeout(step, 1000 / J_FPS);
|
||||
}
|
||||
function openTimelapse(ev, k = 0, on = true) {
|
||||
JV.frames = jFrames(ev);
|
||||
if (!JV.frames.length) return;
|
||||
JV.imgs = JV.frames.map(f => Object.assign(new Image(), { src: f.src })); // chargées d'avance
|
||||
jv.hidden = false;
|
||||
jvShow(k).then(() => jvPlay(on));
|
||||
}
|
||||
function closeTimelapse() { jvPlay(false); jv.hidden = true; }
|
||||
jv.addEventListener("click", ev => {
|
||||
if (ev.target === jv) return closeTimelapse(); // clic à côté de la fenêtre
|
||||
const b = ev.target.closest("button");
|
||||
if (!b) return;
|
||||
if (b.dataset.v === "x") closeTimelapse();
|
||||
else if (b.dataset.v === "p") jvPlay(!JV.playing);
|
||||
else { jvPlay(false); jvShow(JV.k + +b.dataset.v); } // image par image
|
||||
});
|
||||
document.addEventListener("keydown", ev => { if (ev.key === "Escape" && !jv.hidden) closeTimelapse(); });
|
||||
|
||||
drawJournal();
|
||||
if (J[ASKED.get("play")]) openTimelapse(J[ASKED.get("play")], +ASKED.get("frame") || 0, !ASKED.has("frame")); // #play=n&frame=k : captures
|
||||
</script>
|
||||
</body>
|
||||
</html>
|
||||
@@ -112,12 +112,14 @@ Ajouté le 2026-10-16 à la demande de l'utilisateur : faire ressortir seules le
|
||||
|
||||
Le « journal du matin » du client (utilisateur, 2026-10-23) : il ouvre Explore, voit ses courbes sur quelques jours et, dessous, des barres étiquetées qui disent ce qui s'est passé. Un épisode n'est pas un vrai déplacement : c'est un moment où il ne faut pas se fier aux données. On garde toutes les données ; les zones à ignorer sont grisées. Prototype, au plus simple, en attente des retours de l'utilisateur.
|
||||
|
||||
- **Détecteurs** : un fichier par détecteur dans `vues-deplacements/journal/<nom>.py`, qui expose `detect(mesures)` (`mesures = donnees.charger(dossier)`) et rend des épisodes `{start, end, kind, label, text, ignore, sensors}` (heures `donnees.iso`, UTC ; `kind` = nom du fichier ; `ignore` vrai = zone grisée ; `sensors` vide = tous). `explore.py` (`journal`) charge tous les fichiers qui ont `detect`, appelle chacun sur les mesures déjà lues et trie les épisodes par début ; un détecteur qui plante est sauté avec un message, la page se fait quand même.
|
||||
- **Détecteurs** : un fichier par détecteur dans `vues-deplacements/journal/<nom>.py`, qui expose `detect(mesures)` (`mesures = donnees.charger(dossier)`) et rend des épisodes `{start, end, kind, label, text, ignore, sensors}` (heures `donnees.iso`, UTC ; `kind` = nom du fichier ; `ignore` vrai = zone grisée ; `sensors` vide = tous). `vues-deplacements/journal/categories.py` (`detecteurs`) charge tous les fichiers qui ont `detect` ; un détecteur qui plante est sauté avec un message, la page se fait quand même.
|
||||
- **É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 : une ligne par détecteur (Visibility, Jumps, Turbulence, Thermal, Missing data, puis les autres), seulement ceux qui ont des épisodes ; une barre colorée par épisode, son label dedans s'il tient ; survol : label, texte et capteurs. Un épisode plus court qu'une heure est dessiné sur 1 h, sinon il serait invisible.
|
||||
- **Journal en texte** : les épisodes de la plage visible, dans l'ordre du temps (`Oct 14, 23:45 – 05:15 UTC · Poor visibility · <text> (capteurs)`), mis à jour à chaque zoom ; `Nothing to report on this period.` sinon ; clic sur une entrée : les courbes zooment sur l'épisode, avec une marge (la moitié de sa durée, 2 h au moins).
|
||||
- **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).
|
||||
- **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.
|
||||
- **Corrigé le jour même** : un `Lasting shift` durait jusqu'à la fin des données et sa barre cachait les autres sauts (il finit maintenant avec le saut) ; les couleurs de la frise sont fixes par détecteur (`J_COLORS` : bleu visibilité, rouge sauts, orange turbulence, vert cycle thermique, gris trous). Vérifié ensuite par captures sur les six jeux, avec les cinq détecteurs.
|
||||
|
||||
Reference in new issue
Block a user