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
@@ -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