Files
Support-Agent/vues-deplacements/maquette/explore.py
T

159 lines
9.0 KiB
Python
Raw Normal View History

"""Maquette de la page Explore (onglets View et Diagnosis, D-053, D-054) et de la page Displacements (D-055) ;
spec : vues-deplacements/maquette/spec.md.
Lit l'export « advanced » d'un dossier de station avec l'outil donnees.py de l'agent (positions, error_value) et son
export horaire (déplacements en mm), liste les images et les captures de la plateforme, puis remplit
explore_template.html. Écrit out/vues_deplacements_<STATION>.html et l'ouvre dans le navigateur.
Usage : python3 vues-deplacements/maquette/explore.py [dossier de station] (défaut : le cas NORDEND d'octobre 2026)
"""
import csv
import html
import json
import os
import statistics
import sys
from datetime import datetime
from pathlib import Path
from urllib.parse import quote
from zoneinfo import ZoneInfo
HERE = Path(__file__).resolve().parent
ROOT = HERE.parents[1]
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"))
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)
COLUMNS = ("error_value",) # 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
MARGIN_PX = 150 # marge autour des capteurs, zoom de départ de l'image (spec §1)
HOURLY_TZ = ZoneInfo("Europe/Zurich") # horodatage de l'export horaire : heure suisse, sans fuseau (docs/domaine/colonnes-des-deplacements.md)
CAPTURES = {"time_series": ("01", "02", "03"), "advanced": ("04", "05")} # captures de cas/<cas>/plateforme/ par onglet
# Page Displacements (D-055, vues-deplacements/contexte/detection-d-anomalies.md) : sauts de niveau qui durent.
WINDOW = 24 # heures de part et d'autre d'un saut : une journée entière absorbe le cycle jour et nuit
RATIO = 3 # saut montré s'il dépasse RATIO fois l'amplitude journalière de la cible ; provisoire, sans source :
# entre 1,5 (plus grand saut des jeux sains) et 4 (PR17) sur les jeux de la note
TOGETHER_S = 6 * 3600 # sauts à moins de 6 h l'un de l'autre (de proche en proche) : un même événement ; le plus grand
# écart d'un axe tombe parfois quelques heures après la marche (PR17, marche à 02:30 : 03:00 en
# vertical, 07:00 en horizontal)
def hourly(path):
"""Export horaire -> déplacements en mm de chaque cible, heure par heure, en UTC (début de l'heure) ;
les références n'y sont pas."""
with open(path, newline="") as f:
rows = list(csv.DictReader(f))
if not rows:
return {"times": [], "sensors": {}}
num = lambda v: float(v) if v and v.strip() else None # noqa: E731
names = sorted(c[:-len("_vertical_displacement")] for c in rows[0] if c.endswith("_vertical_displacement"))
times = [datetime.fromisoformat(r["timestamp"]).replace(tzinfo=HOURLY_TZ) for r in rows]
return {"times": [donnees.iso(t) for t in times],
"sensors": {n: {"h": [num(r[f"{n}_horizontal_displacement"]) for r in rows],
"v": [num(r[f"{n}_vertical_displacement"]) for r in rows]} for n in names}}
def regime_changes(hr):
"""Déplacements horaires (sortie de hourly) -> événements de sauts de niveau qui durent, du plus net au moins net,
chacun avec ses sauts (sauts à moins de TOGETHER_S de proche en proche : plusieurs cibles qui sautent ensemble font
un seul événement, pas plusieurs anomalies, règle du mode commun dans CLAUDE.md). Pour chaque cible
et chaque axe : le plus grand écart entre la médiane des WINDOW heures qui suivent et celle des WINDOW heures qui
précèdent, gardé s'il dépasse RATIO fois l'amplitude journalière de la cible (médiane, sur les jours UTC, de max − min).
Les données ne sont pas modifiées."""
found = []
for name, axes in hr["sensors"].items():
for key, axis in (("h", "horizontal"), ("v", "vertical")):
# ponytail: fenêtres comptées en heures mesurées, un trou les allonge ; un seul saut par axe (le plus grand)
s = [(t, v) for t, v in zip(hr["times"], axes[key]) if v is not None]
if len(s) < 3 * WINDOW:
continue
days = {}
for t, v in s:
days.setdefault(t[:10], []).append(v)
swings = [max(vs) - min(vs) for vs in days.values() if len(vs) >= 20]
swing = statistics.median(swings) if swings else 0
if not swing:
continue
med = lambda a, b: statistics.median(v for _, v in s[a:b]) # noqa: E731
jump, k = max(((med(k, k + WINDOW) - med(k - WINDOW, k), k) for k in range(WINDOW, len(s) - WINDOW + 1)),
key=lambda j: abs(j[0]))
if abs(jump) >= RATIO * swing:
found.append({"target": name, "axis": axis, "t": s[k][0], "jump": jump, "swing": swing,
"left": med(len(s) - WINDOW, len(s)) - med(k - WINDOW, k)})
at = lambda f: datetime.fromisoformat(f["t"]).timestamp() # noqa: E731
net = lambda f: abs(f["jump"]) / f["swing"] # noqa: E731
events = []
for f in sorted(found, key=lambda f: f["t"]):
if events and at(f) - at(events[-1]["jumps"][-1]) <= TOGETHER_S:
events[-1]["jumps"].append(f)
else:
events.append({"jumps": [f]})
for e in events:
e["start"], e["end"] = e["jumps"][0]["t"], e["jumps"][-1]["t"]
e["targets"] = sorted({f["target"] for f in e["jumps"]})
e["jumps"].sort(key=net, reverse=True)
return sorted(events, key=lambda e: net(e["jumps"][0]), reverse=True)
def url(path):
"""Chemin -> URL relative depuis out/, où la page est écrite."""
return quote(Path(os.path.relpath(path, OUT)).as_posix())
def build(folder):
"""Dossier de station -> données de la page ; quitte avec un message s'il n'a pas d'export « advanced »."""
files = donnees.trouver(str(folder))
if not files["advanced"]:
sys.exit(f"Pas d'export « advanced » dans {folder}")
mesures = donnees.charger(str(folder))
minute = lambda t: t.replace(second=0, microsecond=0) # noqa: E731 (instants à la minute, comme donnees.iso)
instants = sorted({minute(m["t"]) for ms in mesures.values() for m in ms})
col = {t: j for j, t in enumerate(instants)}
order = lambda s: (KINDS.index(mesures[s][0]["pattern_type"]) if mesures[s][0]["pattern_type"] in KINDS # noqa: E731
else len(KINDS), s)
sensors = []
for name in sorted(mesures, key=order):
ms = mesures[name]
row = {c: [None] * len(instants) for c in ("x", "y") + COLUMNS}
for m in ms:
for c in row:
row[c][col[minute(m["t"])]] = m[c]
xs, ys = [v for v in row["x"] if v is not None], [v for v in row["y"] if v is not None]
sensors.append({"name": name, "kind": ms[0]["pattern_type"], "threshold": ms[0]["error_threshold"],
"x": row["x"], "y": row["y"],
"home": [statistics.median(xs), statistics.median(ys)] if xs and ys else None,
"values": {c: row[c] for c in COLUMNS}})
homes = [s["home"] for s in sensors if s["home"]]
view = {a: [min(h[k] for h in homes) - MARGIN_PX, max(h[k] for h in homes) + MARGIN_PX]
for k, a in enumerate(("x", "y"))} if homes else None
images = sorted(({"t": donnees.iso(t), "src": url(p)} for p in files["images"] if (t := donnees.heure_image(p))),
key=lambda im: im["t"])
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()}
hr = hourly(files["horaire"][0]) if files["horaire"] else {"times": [], "sensors": {}}
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_changes(hr), "ratio": RATIO}
def page(folder):
"""Dossier de station -> chemin de la page écrite dans out/."""
data = build(folder)
text = (HERE / "explore_template.html").read_text()
text = text.replace("<!--PLATFORM-->", html.escape(data["platform"]))
text = text.replace("/*DATA*/null", json.dumps(data).replace("</", "<\\/"))
text = text.replace("/*AUTOSCALE*/", AUTOSCALE_Y_JS.replace("'{plot_id}'", "plotId")) # ordonnée recalée (D-013)
OUT.mkdir(exist_ok=True)
out = OUT / f"vues_deplacements_{Path(folder).resolve().name}.html"
out.write_text(text)
return out
if __name__ == "__main__":
out = page(sys.argv[1] if len(sys.argv) > 1 else DEFAULT)
print(out)
open_html(out)