Clean the journal curves, unfold its timeline and sort it in batches (D-056)

Plan points 18 to 26, 30, 39, 40 and the point 37 housekeeping:
- greyed zones per target, vertical scale without the zones to ignore, Fit all,
  mm by default with a px switch, Support view, Expand (one row per category);
- cleaned curves: cut in the zones to ignore, raw data kept there in thin grey;
- target02 to target05 count as targets; smoothing questions answered;
- categories.py sorts in slices with 3 days of history by default;
- the pumping script points to ~/monitoring-dashboard and skips diff images;
- CLAUDE.md back under 200 lines; a case page is named after its case.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
maximeandClaude Opus 5.5 committed 2026-10-24 14:31:42 +02:00
1 parent 86547f089b
commit 955566d86f
14 files changed
+303 -98

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`, 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`.
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 onze 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
@@ -1,6 +1,6 @@
# Données en masse et boucle Claude : ce qui existe et ce qu'on recommande
Étude du 2026-10-23, en lecture seule dans `~/monitoring-dashboard-displacement` (branche `displacement`, doc dans `CLAUDE.md` et `docs/diagnostics/`). Rien lancé, aucun secret lu ; les variables d'environnement ne sont citées que par leur nom.
Étude du 2026-10-23, en lecture seule dans `~/monitoring-dashboard-displacement` (branche `displacement` ; depuis le 2026-10-24, l'application de référence est `~/monitoring-dashboard`, les autres dossiers ne sont que des branches, à ignorer ; doc dans `CLAUDE.md` et `docs/diagnostics/`). Rien lancé, aucun secret lu ; les variables d'environnement ne sont citées que par leur nom.
## Recommandation
+6
View File
@@ -59,3 +59,9 @@
1. Le client voit-il la nettoyée par défaut avec la brute en option, ou l'inverse ? Elle ne remplace jamais la brute à l'écran (cadrage Q4).
2. Le journal paraît une fois le matin : un lissage **centré** (côté serveur, sans retard) vous convient-il, ou garde-t-on le calcul **causal** des analyses, avec 1 à 2 h de retard (cadrage Q5) ?
3. Le cycle thermique du jour reste-t-il tel quel (choix par défaut, cadrage Q8), ou faut-il une vue « sans le cycle » ? Seule cette réponse justifie l'option D.
**Réponses de l'utilisateur (2026-10-24, point 24 du plan, D-056).**
1. **Les deux ensemble** : la nettoyée en couleur, coupée dans les zones à ignorer ; la brute en gris fin, visible dans ces zones seulement. Pas de sélecteur « Brute / Nettoyée / Les deux » pour commencer.
2. **Calcul au moment où le client regarde les courbes**, sur tout ce qui est disponible jusque-là : chaque instant est jugé avec ce qui le suit (comme les détecteurs, `sauts` regarde 24 h après), les dernières heures restent provisoires. Rien n'est écrit dans la base de la plateforme : on ne le peut pas à ce stade. Le temps de calcul au chargement est à mesurer (point 36 du plan).
3. **Le cycle thermique reste tel quel** : le journal le nomme (« Thermal expansion », « Thermal contraction », point 41) ; pas de vue « sans le cycle », l'option D reste en réserve.
+34 -6
View File
@@ -10,15 +10,18 @@ qu'un. Chaque événement reçoit sa phrase
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)
... <dossier> [--du AAAA-MM-JJ] [--au AAAA-MM-JJ] [--tranche 3] [--historique N] (tri en lot, point 30 :
chaque tranche de 3 jours classée seule, avec les jours d'historique d'avant s'ils existent ; seuls les événements
qui touchent la tranche sont montrés ; « rien » pour une tranche calme)
"""
import importlib.util
import os
import sys
from datetime import datetime, timedelta
from datetime import datetime, timedelta, timezone
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
from donnees import charger, iso # 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.
@@ -156,7 +159,32 @@ def evenements(mesures):
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 "—")
import argparse
p = argparse.ArgumentParser(description="Une ligne par événement ; --tranche : chaque tranche classée seule.")
p.add_argument("dossier")
p.add_argument("--du", help="premier jour UTC, AAAA-MM-JJ (défaut : début des données)")
p.add_argument("--au", help="dernier jour UTC exclu, AAAA-MM-JJ (défaut : fin des données)")
p.add_argument("--tranche", type=int, default=0, help="jours par tranche (défaut : un seul passage)")
# sans historique, une tranche qui commence juste avant un vrai saut le prend pour un saut revenu (PR17 à NORDEND,
# le 08/10 à 02:30 : absorbé dans la buée) ; 3 jours le rendent ; règle de l'utilisateur (2026-10-24) : 3 jours
# d'historique par défaut, dans la boucle comme dans la vraie application
p.add_argument("--historique", type=int, default=3, help="jours de mesures d'avant donnés aux détecteurs (défaut 3)")
a = p.parse_args()
mesures = charger(a.dossier)
ts = [m["t"] for ms in mesures.values() for m in ms]
jour = lambda d: datetime.strptime(d, "%Y-%m-%d").replace(tzinfo=timezone.utc) # noqa: E731
debut = jour(a.du) if a.du else min(ts).replace(hour=0, minute=0, second=0, microsecond=0)
fin = jour(a.au) if a.au else max(ts) + timedelta(seconds=1)
t = debut
while t < fin:
b = min(t + timedelta(days=a.tranche), fin) if a.tranche else fin
h = t - timedelta(days=a.historique)
tranche = {s: k for s, ms in mesures.items() if (k := [m for m in ms if h <= m["t"] < b])}
evs = [v for v in evenements(tranche) if v["end"] >= iso(t)] if tranche else []
if a.tranche:
print(f"== {iso(t)} → {iso(b)} : {len(evs) or 'rien'}")
for v in evs:
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 "—")
t = b
+10 -6
View File
@@ -3,7 +3,7 @@ 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.
explore_template.html. Écrit out/vues_deplacements_<STATION>.html (<cas> pour un dossier de cas) 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
@@ -57,7 +57,7 @@ def hourly(path):
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],
"sensors": {n.strip(): {"h": [num(r[f"{n}_horizontal_displacement"]) for r in rows], # NIEDERHORN : « …_C09\r »
"v": [num(r[f"{n}_vertical_displacement"]) for r in rows]} for n in names}}
@@ -184,8 +184,9 @@ def build(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)
# les cibles d'un autre motif (target02 à target05 à PS des Coudres) sont des cibles comme les autres (point 39)
kind = lambda s: "target" if mesures[s][0]["pattern_type"].startswith("target") else mesures[s][0]["pattern_type"] # noqa: E731
order = lambda s: (KINDS.index(kind(s)) if kind(s) in KINDS else len(KINDS), s) # noqa: E731
sensors = []
for name in sorted(mesures, key=order):
ms = mesures[name]
@@ -194,7 +195,7 @@ def build(folder):
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"],
sensors.append({"name": name, "kind": kind(name), "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}})
@@ -235,7 +236,10 @@ def page(folder):
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"
# nom du dossier, ou du cas pour un dossier de vues-deplacements/cas/<cas>/<STATION> : data/NORDEND et le cas
# 2026-10_NORDEND n'écrivent plus la même page (point 37 du plan)
d = Path(folder).resolve()
out = OUT / f"vues_deplacements_{d.parent.name if d.parent.parent.name == 'cas' else d.name}.html"
out.write_text(text)
return out
@@ -129,6 +129,8 @@
.jentry:hover { background: #e8f0fb; }
.jentry .when { color: var(--muted); font-size: 12px; }
.jentry b { font-size: 14px; }
.jentry details { margin-top: 4px; }
.jentry summary { cursor: pointer; color: var(--muted); font-size: 12px; }
.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); }
@@ -263,8 +265,15 @@
</div>
</div>
<div class="pane" id="journal">
<div class="toolbar">Unit <button type="button" data-unit="mm">mm</button><button type="button" data-unit="px">px</button>
&nbsp; <button type="button" id="j-fit">Fit all</button>
&nbsp; <label><input type="checkbox" id="j-expand"> Expand</label>
&nbsp; <label><input type="checkbox" id="j-support"> Support view</label>
<span class="meta">mm: hourly averages, what the platform shows · px: every measurement, short peaks included ·
the vertical scale leaves out the greyed zones and the hidden targets</span></div>
<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, ▶ Images to see the camera; zoom the curves
<p class="hint">Cleaned curves: the periods to ignore are removed, nothing else changed; the raw data stays there in thin grey,
on a grey zone. 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>
@@ -944,36 +953,85 @@ const jWhen = t => `${MON[+t.slice(5, 7) - 1]} ${+t.slice(8, 10)}, ${t.slice(11,
const plotT = ms => new Date(ms).toISOString().slice(0, 19).replace("T", " "); // instant en ms -> date Plotly (UTC)
const jEnd = e => Math.max(Date.parse(e.end), Date.parse(e.start) + 3600e3); // dessin : 1 h au moins, sinon invisible
function drawJournal() {
const targets = S.filter(s => s.kind === "target" || s.kind === "ref");
const traces = targets.flatMap((s, n) => [["corr_x", "Horizontal"], ["corr_y", "Vertical"]].map(([c, label], r) => ({
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>` })));
// unité des courbes (point 20) : mm par défaut, les moyennes horaires que la plateforme montre au client (export
// horaire) ; px, chaque mesure de l'export « advanced » (corr_x, corr_y), pics d'une mesure compris ; #unit=px : captures
// vue support (point 23) : une ligne par détecteur sous « What happened » et le repli Details de chaque carte, avec les
// épisodes d'origine ; la vue client reste celle du point 8 ; #support pour les captures
let J_SUPPORT = ASKED.has("support");
// frise dépliée (point 40) : une ligne par catégorie présente, dans l'ordre de J_ORDER (« Shift to check » en haut) ;
// repliée, la ligne unique du point 8 ; #expand pour les captures
let J_EXPAND = ASKED.has("expand");
const J_DET = { visibilite: ["Visibility", "#1f77b4"], sauts: ["Jumps", "#d62728"], turbulence: ["Turbulence", "#ff7f0e"],
thermique: ["Thermal", "#2ca02c"], trous: ["Missing data", "#7f7f7f"] };
let J_UNIT = ASKED.get("unit") === "px" || !Object.keys(D.hourly.sensors).length ? "px" : "mm"; // px sans export horaire
const J_PAL = PALETTE.filter(c => c !== "#7f7f7f"); // sans le gris, réservé à la brute à ignorer (point 25)
const jColor = name => J_PAL[Math.max(0, S.findIndex(s => s.name === name)) % J_PAL.length]; // même couleur en mm et en px
function jSeries() { // [{name, times, h, v}] : les courbes dans l'unité choisie
if (J_UNIT === "px") return S.filter(s => s.kind === "target" || s.kind === "ref")
.map(s => ({ name: s.name, times: D.times, h: s.values.corr_x, v: s.values.corr_y }));
return Object.entries(D.hourly.sensors).map(([name, mm]) => ({ name, times: D.hourly.times, h: mm.h, v: mm.v }));
}
function drawJournal(range) {
const series = jSeries(), AXES = [["h", "Horizontal"], ["v", "Vertical"]];
// l'échelle verticale laisse de côté les points des zones grisées et des cibles masquées (point 19) : un pic qu'on
// doit ignorer n'écrase plus les autres courbes ; ils restent dessinés, hors cadre si besoin
const step = J_UNIT === "mm" ? 3599e3 : 0; // en mm, une moyenne horaire couvre toute son heure (point 25)
const inside = (e, t) => { const T = Date.parse(t); return T <= Date.parse(e.end) && T + step >= Date.parse(e.start); };
const scene = J.filter(e => e.ignore && e.category !== "cible_masquee");
const skip = s => { const h = J.filter(e => e.category === "cible_masquee" && e.sensors.includes(s.name));
return s.times.map(t => scene.some(e => inside(e, t)) || h.some(e => inside(e, t))); };
// courbe nettoyée (point 25, option A) : la brute sans les points à ignorer, coupée là, rien d'interpolé ; la brute y
// reste en gris fin, reliée aux points gardés de part et d'autre (sinon un point seul, un passage, ne se verrait pas) ;
// une cible masquée n'est coupée que sur sa courbe, pas sur tout le fond (point 18)
const traces = series.flatMap(s => { const yskip = skip(s), near = yskip.map((v, k) => v || yskip[k - 1] || yskip[k + 1]);
return AXES.flatMap(([c, label], r) => [{
type: "scatter", mode: "lines", x: s.times, y: s[c].map((v, k) => yskip[k] ? null : v), yaxis: `y${r ? 2 : ""}`,
name: s.name, showlegend: false, line: { color: jColor(s.name), width: 1 }, meta: { yskip },
hovertemplate: `${s.name} · %{x|%d %b %H:%M} UTC<br>${label} %{y:.2f} ${J_UNIT}<extra></extra>` }, {
type: "scatter", mode: "lines", x: s.times, y: s[c].map((v, k) => near[k] ? v : null), yaxis: `y${r ? 2 : ""}`,
name: s.name, showlegend: false, line: { color: "#b0b0b0", width: 1 }, meta: { yskip: s.times.map(() => true) },
hovertemplate: `${s.name} (raw, to ignore) · %{x|%d %b %H:%M} UTC<br>${label} %{y:.2f} ${J_UNIT}<extra></extra>` }]); });
// 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));
const covered = e => !J_EXPAND && 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)),
y: bars.map(e => J_EXPAND ? e.label : 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
width: bars.map(e => e.category === "derive_lente" && !J_EXPAND ? 0.2 : 0.75), // repliée, 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 || jFam(e) === "reduced").flatMap(e => ["y domain", "y2 domain"].map(yref => ({ type: "rect",
const eps = J_SUPPORT ? J.flatMap(e => e.episodes) : []; // vue support : les épisodes bruts, une ligne par détecteur
const kinds = [...new Set([...Object.keys(J_DET), ...eps.map(p => p.kind)])].filter(k => eps.some(p => p.kind === k));
const row = k => (J_DET[k] || [k])[0];
for (const k of kinds) {
const ps = eps.filter(p => p.kind === k);
traces.push({ type: "bar", orientation: "h", yaxis: "y3", name: k, showlegend: false, y: ps.map(() => row(k)),
base: ps.map(p => p.start), x: ps.map(p => jEnd(p) - Date.parse(p.start)), marker: { color: (J_DET[k] || [, "#999"])[1] },
text: ps.map(p => p.label), textposition: "inside", insidetextanchor: "middle", insidetextfont: { color: "#fff" },
hovertext: ps.map(p => `<b>${p.label}</b> (${k})${p.text ? "<br>" + p.text : ""}<br>Sensors: ${
p.sensors.length ? p.sensors.join(", ") : "all"}`), hovertemplate: "%{hovertext}<extra></extra>" });
}
const cats = J_EXPAND ? [...new Set(bars.map(e => e.label))].reverse() : [J_ROW];
const rows = [...cats, ...kinds.map(row)];
const C = 220, G = 24, F = 10 + 30 * rows.length, A = 2 * C + 2 * G + F; // hauteurs en px, A : zone tracée
const grey = J.filter(e => (e.ignore || jFam(e) === "reduced") && e.category !== "cible_masquee").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]);
document.querySelectorAll("#journal [data-unit]").forEach(b => b.classList.toggle("active", b.dataset.unit === J_UNIT));
Plotly.purge("j-curves"); // redessin au changement d'unité : sans les écouteurs du dessin d'avant
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 },
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", showgrid: false },
xaxis: { type: "date", anchor: "y3", range: 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 (${J_UNIT})` } },
yaxis2: { domain: [1 - (2 * C + G) / A, 1 - (C + G) / A], fixedrange: true, title: { text: `Vertical (${J_UNIT})` } },
yaxis3: { domain: [0, F / A], fixedrange: true, type: "category", categoryorder: "array", categoryarray: rows.slice().reverse(),
showgrid: false }, // « What happened » (ou une ligne par catégorie) en haut, les détecteurs dessous (vue support)
shapes: grey,
}, CONFIG).then(() => {
autoscale("j-curves"); // les barres de la frise (ordonnées en texte) n'entrent pas dans le recalage
@@ -992,15 +1050,36 @@ function listJournal([a, b]) { // les événements de la plage visible, dans l'
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" ? ""
e.text}${J_SUPPORT && e.episodes.length ? `<details><summary>Details</summary>${e.episodes.map(p => `<div class="meta">${
p.kind} · ${p.label} · ${jWhen(p.start)}${p.end === p.start ? "" : ` – ${jWhen(p.end)}`} UTC${
p.sensors.length ? ` · ${p.sensors.join(", ")}` : ""}</div>`).join("")}</details>` : ""}${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.querySelectorAll("#journal [data-unit]").forEach(b => b.addEventListener("click", () => { // même plage de temps
J_UNIT = b.dataset.unit;
drawJournal(document.getElementById("j-curves").layout.xaxis.range.slice());
}));
const jExpand = document.getElementById("j-expand");
jExpand.checked = J_EXPAND;
jExpand.addEventListener("change", () => { // même plage de temps
J_EXPAND = jExpand.checked;
drawJournal(document.getElementById("j-curves").layout.xaxis.range.slice());
});
const jSupport = document.getElementById("j-support");
jSupport.checked = J_SUPPORT;
jSupport.addEventListener("change", () => { // même plage de temps
J_SUPPORT = jSupport.checked;
drawJournal(document.getElementById("j-curves").layout.xaxis.range.slice());
});
document.getElementById("j-fit").addEventListener("click", () =>
Plotly.relayout("j-curves", { "yaxis.autorange": true, "yaxis2.autorange": true })); // tous les points, pics compris
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]);
if (ev.target.closest("details")) return; // le repli Details s'ouvre sans zoomer
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)] });
});
+7 -2
View File
@@ -116,7 +116,12 @@ 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 é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 dépliée** (point 40, 2026-10-24) : case `Expand` (décochée par défaut ; `#expand` pour les captures) : « What happened » devient une ligne par catégorie présente dans les données, dans l'ordre de dessin (« Shift to check » en haut, « Slow drift » en bas, en barre pleine) ; plus aucun événement n'en cache un autre. Décochée, la ligne unique du point 8. Les lignes sont celles de toute la période : une catégorie absente de la plage visible garde sa ligne, vide. Combinable avec `Support view`, dont les lignes par détecteur viennent dessous.
- **Vue support** (point 23, 2026-10-24) : case `Support view` (décochée par défaut ; `#support` pour les captures) : la frise ajoute sous « What happened » une ligne par détecteur (Visibility, Jumps, Turbulence, Thermal, Missing data) avec les épisodes bruts, leur label d'origine au survol ; chaque carte reçoit un repli `Details` (fermé) qui liste ses épisodes (détecteur, label, heures, capteurs), dont l'ouverture ne zoome pas. Décochée, la page est celle du client.
- **Unité** (point 20, 2026-10-24) : sélecteur `mm` / `px` au-dessus des courbes, **mm par défaut** : les moyennes horaires de l'export horaire, ce que la plateforme montre au client (`D.hourly`) ; `px` : chaque mesure de l'export « advanced » (`corr_x`, `corr_y`), pics d'une mesure compris. Même couleur par cible dans les deux unités ; la plage de temps est gardée au changement ; `#unit=px` pour les captures ; px d'office sans export horaire. Les événements ne changent pas (détectés en px, heures UTC).
- **Échelle** (point 19, 2026-10-24) : le recalage de l'ordonnée laisse de côté les points des zones grisées et des cibles masquées pendant leur événement (`meta.yskip`, lu par `AUTOSCALE_Y_JS`) ; ils restent dessinés, hors cadre si besoin ; bouton `Fit all` au-dessus des courbes pour tout voir.
- **Zones grisées** : un rectangle gris sur les deux courbes par événement `ignore`, sauf « Target hidden », dont seules les courbes des cibles concernées passent en gris pendant l'événement (point 18, 2026-10-24) ; un rectangle très clair (en léger retrait) pour « Reduced visibility », dont les données sont gardées (point 38).
- **Courbes nettoyées** (point 25, option A du lissage, 2026-10-24) : chaque courbe est en couleur **sauf** pendant les événements `ignore` (pour « Target hidden », seulement sur les courbes de ses cibles) : là, elle est coupée, rien n'est interpolé, et la brute reste en gris fin, reliée aux points gardés de part et d'autre (un passage d'une seule mesure se voit ainsi). Les deux courbes sont toujours ensemble, sans sélecteur (point 24). En mm, une moyenne horaire couvre toute son heure : elle est coupée si un événement à ignorer commence dans l'heure. Le gris de la palette est retiré des couleurs des courbes du Journal (`J_PAL`), pour qu'aucune cible ne passe pour de la brute à ignorer. Légende sous la frise : « Cleaned curves: the periods to ignore are removed, nothing else changed; the raw data stays there in thin grey, on a grey zone. »
- **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é).
@@ -130,7 +135,7 @@ Le « journal du matin » du client (utilisateur, 2026-10-23) : il ouvre Explore
- `vues-deplacements/maquette/explore.py [dossier de station]` (défaut `vues-deplacements/cas/2026-10_NORDEND/NORDEND/`) :
- lit l'export « advanced » avec `agents/diagnostic/outils/donnees.py` (`charger`, `trouver`, `heure_image`), sans le copier ;
- lit l'export horaire (déplacements en mm, heure suisse convertie en UTC), calcule la position médiane de chaque capteur et liste les images avec leur heure ;
- injecte un JSON dans `explore_template.html` et écrit `out/vues_deplacements_<STATION>.html` (`<STATION>` : nom du dossier), puis l'ouvre (`src/common/page.py`, `open_html`).
- injecte un JSON dans `explore_template.html` et écrit `out/vues_deplacements_<STATION>.html` (`<STATION>` : nom du dossier ; pour un dossier de cas, le nom du cas, par exemple `2026-10_NORDEND`), puis l'ouvre (`src/common/page.py`, `open_html`).
- `vues-deplacements/maquette/explore_template.html` : habillage, onglets, plotly.js 4.1.1 par CDN (comme les maquettes existantes), JS de la liaison.
- Images et captures référencées par chemin relatif depuis `out/`, sans copie : la page ne marche que sur ce poste, assez pour une maquette.
- Bibliothèque standard côté Python ; ni pandas ni nouvelle dépendance.