Files
Support-Agent/vues-deplacements/maquette/explore.py
T
maximeandClaude Opus 5.5 261f8c9038 Add the Displacements page: permanent displacements of the targets (D-055)
Mechanical anomaly detection on the hourly displacements in mm, data
unchanged: for each target and axis, the largest gap between the median
of the next 24 h and the previous 24 h, kept above 3 times the target's
daily swing (provisional). Jumps within 6 h form one event, so a common
jump is not several anomalies. Grey curves for all targets, colour for
those that jumped; a click opens Explore, Diagnosis.

Note on the idea, first trial and leads in
vues-deplacements/contexte/detection-d-anomalies.md.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 17:59:42 +02:00

160 lines
9.0 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""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)