588 lines
41 KiB
Python
588 lines
41 KiB
Python
"""Les détecteurs du journal seuls, sur une plage d'un dossier de station : la page de comparaison.py sans les étiquettes.
|
||
|
||
En tête, les images de la caméra sur la plage (glisseur, flèches du clavier ; un clic sur la figure va à l'image la plus
|
||
proche, une ligne verticale la marque sur la figure). Un clic sur la barre d'un événement des détecteurs, comme sur un bloc
|
||
du Status, zoome la plage sur lui, ne garde que ses capteurs sur les courbes (la légende rend les autres) et montre sous la
|
||
figure ses détails et le timelapse des images de l'événement, recadré sur ses capteurs (Focused image) ou entier (Global image), avec une marge avant et après (comme ▶ Images de la
|
||
maquette Explore). ⤓ GIF le télécharge tel qu'il est montré (la page est servie par
|
||
http://127.0.0.1 : en file://, le navigateur ne lit pas les pixels des images). En haut de la figure, la pose de la caméra (pan, tilt, rotation [deg],
|
||
camera/ du pompage, si le dossier en a), puis corr_x et corr_y de chaque capteur (px, une couleur par capteur, les références
|
||
en pointillé ; la légende cache un capteur dans les deux) ; dessous, la ligne « Status » (ce qui se passe : bleu clair, rien ;
|
||
bleu foncé, un bloc d'événements nommé par celui qui l'englobe, sans À vérifier ni Dérive lente), puis, dépliée au départ
|
||
(un clic sur « ▾ Status » la replie ; un clic sur un bloc zoome la plage sur lui et montre ses détails sous la figure,
|
||
le timelapse de ses images à droite, ses capteurs entourés), une ligne par catégorie (toutes, même sans événement), les événements des détecteurs dans
|
||
leur état actuel (la plage classée avec ses 3 jours d'historique, comme un lot de /events-learner), et la ligne « Error rate » :
|
||
à chaque instant, l'error_value moyenne de tous les capteurs (du vert au rouge, échelle fixe de 0 à 1) ; en bas, la liste des
|
||
événements et leur phrase. Ne modifie rien et n'écrit dans aucun historique.
|
||
Usage : python3 detectors-view/detecteurs.py <dossier de station> [--du AAAA-MM-JJ] [--au AAAA-MM-JJ]
|
||
(--au exclu ; sans dates, toute la période du dossier ; page : out/detecteurs_<STATION>_<du>_<au>.html, ouverte)
|
||
"""
|
||
import argparse
|
||
import bisect
|
||
import html
|
||
import itertools
|
||
import json
|
||
import os
|
||
import statistics
|
||
import sys
|
||
import textwrap
|
||
from collections import Counter
|
||
from pathlib import Path
|
||
from urllib.parse import quote
|
||
|
||
ICI = os.path.dirname(os.path.abspath(__file__))
|
||
sys.path[:0] = [os.path.join(ICI, "..", "src"), os.path.join(ICI, "..", ".claude", "skills", "detector-learner")]
|
||
from common.page import ROOT, open_served # noqa: E402 (bascule seule sur .venv si plotly manque)
|
||
import plotly.graph_objects as go # noqa: E402
|
||
from plotly.subplots import make_subplots # noqa: E402
|
||
import score # noqa: E402 (détecteurs, chargement et version, comme /detector-learner ; met detectors/ et les outils sur le chemin)
|
||
import donnees # noqa: E402
|
||
|
||
AGENT, SCRIPTS = "#2a78d6", "#eb6834" # palette catégorielle de référence, slots 1 et 2 (skill dataviz)
|
||
HORS, GRIS = "hors catégorie", "#a3a29c" # étiquettes « None » : aucun détecteur ne peut les rejoindre
|
||
# du vert au rouge (demande de l'utilisateur, 2026-10-27) : couleurs d'état de la palette de référence (skill dataviz)
|
||
VERT_ROUGE = ["#0ca30c", "#fab219", "#ec835a", "#d03b3b"]
|
||
MARGE_PX = 150 # marge autour des capteurs, recadrage du timelapse (comme MARGIN_PX de la maquette Explore)
|
||
COULEURS = ["#2a78d6", "#eb6834", "#1baf7a", "#8a5cd6", "#d6a12a", "#d63b8a", "#3bb3d6", "#6b6b66"] # un capteur chacun
|
||
POSE = (("pan", "#1a1a19"), ("tilt", "#8a8a85"), ("rotation", "#b5651d")) # sombres : à part des couleurs des capteurs
|
||
# Ligne Status (point 50 du plan) : ce qui se passe, en un mot (l'utilisateur, 2026-10-27) : bleu clair, aucun événement ;
|
||
# bleu foncé, un bloc d'événements qui se touchent, nommé par la famille qui l'englobe. Displacement n'y entre pas : un
|
||
# mouvement possible a ses lignes.
|
||
STATUT_HORS = {"Displacement"}
|
||
CALME, EVENEMENT = "#d3e4f5", "#1f4e8c"
|
||
ESPACE = 30 # px entre deux lignes de la figure : le titre de la suivante y tient
|
||
HEURES = 30 # px de plus sous une courbe : ses heures (l'utilisateur, 2026-10-27 : l'heure sous chaque courbe, pas seulement en bas)
|
||
|
||
# Le timelapse d'un événement, dans le lecteur (LECTEUR_HTML) : gif([début, fin, titre, capteurs], ici) ; repris par
|
||
# status.py. IM : les images de la caméra sur la plage (camera()).
|
||
TIMELAPSE_JS = """
|
||
const IM = __IMAGES__, ms = s => Date.parse(s.replace(' ', 'T') + (/[Z+]/.test(s.slice(10)) ? '' : 'Z'));
|
||
// Timelapse d'un événement (clic sur sa barre) : les images de son début moins une marge à sa fin plus la marge (la moitié de la
|
||
// durée, de 1 h à 6 h), une sur n au-delà de G_MAX, G_FPS par seconde, en boucle ; bord rouge pendant l'événement.
|
||
const G_MARGE = [3600e3, 6 * 3600e3], G_FPS = 4, G_MAX = 150, MARGE = __MARGE__; // à régler à l'œil (comme la maquette Explore)
|
||
// Les capteurs de l'événement entourés sur les images, à leur position médiane sur la plage ; aucune marque si x, y ne sont
|
||
// pas des positions dans l'image (POS vide). La couleur d'un cercle : l'error_value du capteur à l'heure de l'image (e,
|
||
// camera()), du vert au rouge de 0 à 1 comme la ligne Error rate (l'utilisateur, 2026-10-29), gris sans mesure ; les
|
||
// références en pointillé, comme leurs courbes (cibles en jaune et références en bleu jusque-là, 2026-10-27).
|
||
const POS = __POS__, REFS = __REFS__, ECHELLE = __ECHELLE__;
|
||
function teinte(v) {
|
||
if (v == null) return '__GRIS__';
|
||
const x = Math.max(0, Math.min(1, v)) * (ECHELLE.length - 1), i = Math.min(Math.floor(x), ECHELLE.length - 2), u = x - i;
|
||
return `rgb(${ECHELLE[i].map((c, j) => Math.round(c + (ECHELLE[i + 1][j] - c) * u))})`;
|
||
}
|
||
const gv = document.getElementById('gif'), gc = gv.querySelector('canvas'), gi = document.getElementById('gif-info');
|
||
const ROLE = {avant: 'before', pendant: 'DURING', apres: 'after'};
|
||
let G = {f: [], imgs: [], k: 0, run: 0, joue: false, titre: '', capteurs: []};
|
||
// Focused image : recadrée sur les capteurs de l'événement (tous, s'il n'en nomme aucun), MARGE autour ; Global image :
|
||
// l'image entière (l'utilisateur, 2026-10-27). Sans position des capteurs, l'image entière seule.
|
||
const zoom = document.getElementById('gif-z');
|
||
zoom.hidden = !Object.keys(POS).length;
|
||
zoom.onchange = () => { zoom.blur(); image(G.k); };
|
||
function cadre(im) {
|
||
const s = G.capteurs.length ? G.capteurs : Object.keys(POS);
|
||
if (zoom.value === 'global' || !s.length) return {x: [0, im.naturalWidth], y: [0, im.naturalHeight]};
|
||
const b = i => [Math.min(...s.map(c => POS[c][i])) - MARGE, Math.max(...s.map(c => POS[c][i])) + MARGE];
|
||
return {x: b(0), y: b(1)};
|
||
}
|
||
function image(k) {
|
||
G.k = (k + G.f.length) % G.f.length;
|
||
const f = G.f[G.k], im = G.imgs[G.k];
|
||
return im.decode().catch(() => {}).then(() => {
|
||
if (!im.naturalWidth) return;
|
||
const v = cadre(im);
|
||
const x0 = Math.max(0, v.x[0]), y0 = Math.max(0, v.y[0]);
|
||
const w = Math.min(im.naturalWidth, v.x[1]) - x0, h = Math.min(im.naturalHeight, v.y[1]) - y0;
|
||
gc.width = w; gc.height = h; // le recadrage agrandi à la fenêtre (un zoom), l'image entière à sa taille au plus
|
||
gc.style.width = zoom.value === 'global' ? '' : Math.min(innerWidth * 0.85, innerHeight * 0.75 * w / h) + 'px';
|
||
const ctx = gc.getContext('2d'), t = Math.max(10, w / 90), r = 1.5 * t; // t : la taille du nom ; le cercle, plus grand (2026-10-29)
|
||
ctx.drawImage(im, x0, y0, w, h, 0, 0, w, h);
|
||
ctx.lineWidth = Math.max(3, w / 330); ctx.font = `${Math.round(t * 1.3)}px sans-serif`;
|
||
for (const s of G.capteurs) {
|
||
ctx.strokeStyle = ctx.fillStyle = teinte(f.e?.[s]);
|
||
ctx.setLineDash(REFS.includes(s) ? [r * 0.5, r * 0.35] : []);
|
||
ctx.beginPath(); ctx.arc(POS[s][0] - x0, POS[s][1] - y0, r, 0, 2 * Math.PI); ctx.stroke();
|
||
ctx.fillText(s, POS[s][0] - x0 + r * 1.1, POS[s][1] - y0 - r * 0.6);
|
||
}
|
||
gc.style.outlineColor = f.role === 'pendant' ? '#d03b3b' : 'transparent';
|
||
gi.textContent = `${G.titre} · ${f.t} UTC · ${ROLE[f.role]} · ${G.k + 1} / ${G.f.length}`;
|
||
});
|
||
}
|
||
function joue(on) {
|
||
G.joue = on;
|
||
const moi = ++G.run;
|
||
document.getElementById('gif-p').textContent = on ? '❚❚' : '▶';
|
||
const pas = () => { if (moi === G.run) image(G.k + 1).then(() => setTimeout(pas, 1000 / G_FPS)); };
|
||
if (on) setTimeout(pas, 1000 / G_FPS);
|
||
}
|
||
// ici : où jouer le timelapse (les images de Details) ; sans lui, par-dessus la page. Le lecteur (canvas, boutons,
|
||
// légende) passe de l'un à l'autre ; ✕ le range dans la fenêtre fermée.
|
||
const lecteur = gv.firstElementChild;
|
||
function gif([debut, fin, titre, capteurs], ici) {
|
||
const a = ms(debut), b = ms(fin), m = Math.min(G_MARGE[1], Math.max(G_MARGE[0], (b - a) / 2));
|
||
const ims = IM.filter(im => ms(im.t) >= a - m && ms(im.t) <= b + m), n = Math.ceil(ims.length / G_MAX);
|
||
G.f = ims.filter((_, k) => k % n === 0).map(im => ({...im, role: ms(im.t) < a ? 'avant' : ms(im.t) > b ? 'apres' : 'pendant'}));
|
||
G.titre = titre;
|
||
G.capteurs = (capteurs || []).filter(s => s in POS);
|
||
if (!G.f.length) return ici ? ici.replaceChildren('No camera image for this event.') : alert('No camera image for this event.');
|
||
G.imgs = G.f.map(f => Object.assign(new Image(), {src: f.src})); // chargées d'avance
|
||
if (ici) ici.replaceChildren(lecteur); else { gv.append(lecteur); gv.hidden = false; }
|
||
image(0).then(() => joue(true));
|
||
}
|
||
function ferme() { joue(false); gv.hidden = true; gv.append(lecteur); }
|
||
gv.onclick = e => { if (e.target === gv) ferme(); };
|
||
document.getElementById('gif-x').onclick = ferme;
|
||
document.getElementById('gif-p').onclick = () => joue(!G.joue);
|
||
document.getElementById('gif-av').onclick = () => { joue(false); image(G.k - 1); };
|
||
document.getElementById('gif-ap').onclick = () => { joue(false); image(G.k + 1); };
|
||
// ⤓ GIF : le timelapse tel qu'il est montré (Focused ou Global), réduit à GIF_PX de large, sans bord rouge, date et heure
|
||
// en bas à droite (l'utilisateur, 2026-10-28), dans les téléchargements du navigateur (l'utilisateur, 2026-10-27). En file://, le navigateur interdit de lire
|
||
// les pixels des images : la page est servie par http://127.0.0.1 (open_served).
|
||
const GIF_PX = 1000, exp = document.getElementById('gif-e');
|
||
exp.onclick = exporte;
|
||
async function exporte() {
|
||
joue(false); exp.disabled = true;
|
||
const k0 = G.k;
|
||
try {
|
||
const {GIFEncoder, quantize, applyPalette} = await import('https://cdn.jsdelivr.net/npm/gifenc@1.0.3/dist/gifenc.esm.js');
|
||
const enc = GIFEncoder(), ex = document.createElement('canvas');
|
||
for (let k = 0; k < G.f.length; k++) {
|
||
exp.textContent = `⤓ ${k + 1}/${G.f.length}`;
|
||
await image(k);
|
||
const s = Math.min(1, GIF_PX / gc.width), w = ex.width = Math.round(gc.width * s), h = ex.height = Math.round(gc.height * s);
|
||
const c = ex.getContext('2d', {willReadFrequently: true}), t = Math.max(14, Math.round(w / 40));
|
||
c.drawImage(gc, 0, 0, w, h);
|
||
c.font = `${t}px sans-serif`;
|
||
const l = c.measureText(G.f[k].t + ' UTC').width + t;
|
||
c.fillStyle = 'rgba(0,0,0,.6)'; c.fillRect(w - l, h - t * 1.5, l, t * 1.5);
|
||
c.fillStyle = '#fff'; c.fillText(G.f[k].t + ' UTC', w - l + t / 2, h - t * 0.45);
|
||
const px = c.getImageData(0, 0, w, h).data, pal = quantize(px, 256);
|
||
enc.writeFrame(applyPalette(px, pal), w, h, {palette: pal, delay: 1000 / G_FPS});
|
||
}
|
||
enc.finish();
|
||
const nom = `${document.title.replace(/^\\S+ /, '')}_${G.titre}_${G.f[0].t}`.replace(/[^A-Za-z0-9_.-]+/g, '_') + '.gif';
|
||
Object.assign(document.createElement('a'), {href: URL.createObjectURL(new Blob([enc.bytes()], {type: 'image/gif'})), download: nom}).click();
|
||
} catch (e) {
|
||
alert('GIF export failed: ' + (e.name === 'SecurityError' ? 'from file://, the browser cannot read the images; open the page through its script (http://127.0.0.1).' : e.message));
|
||
} finally {
|
||
exp.disabled = false; exp.textContent = '⤓ GIF'; image(k0);
|
||
}
|
||
}
|
||
"""
|
||
|
||
# Le glisseur des images et la ligne verticale de la figure (shapes[0]) ; un clic sur la figure va à l'image la plus proche.
|
||
# Après TIMELAPSE_JS (IM, ms et le lecteur).
|
||
IMAGES_JS = """
|
||
const glis = document.getElementById('glis'), img = document.getElementById('img'), heure = document.getElementById('heure');
|
||
const montre = i => {
|
||
i = Math.max(0, Math.min(IM.length - 1, i)); glis.value = i;
|
||
img.src = IM[i].src; heure.textContent = IM[i].t + ' UTC (' + (i + 1) + '/' + IM.length + ')';
|
||
Plotly.relayout(gd, {'shapes[0].x0': IM[i].t, 'shapes[0].x1': IM[i].t});
|
||
};
|
||
glis.oninput = () => montre(+glis.value);
|
||
document.getElementById('prec').onclick = () => montre(+glis.value - 1);
|
||
document.getElementById('suiv').onclick = () => montre(+glis.value + 1);
|
||
document.addEventListener('keydown', e => {
|
||
if (!gv.hidden) { // le timelapse ouvert : ses touches
|
||
if (e.key === 'Escape') ferme(); else if (e.key === ' ') { e.preventDefault(); joue(!G.joue); }
|
||
else if (e.key === 'ArrowLeft' || e.key === 'ArrowRight') { joue(false); image(G.k + (e.key === 'ArrowLeft' ? -1 : 1)); }
|
||
return;
|
||
}
|
||
if (e.key === 'ArrowLeft') montre(+glis.value - 1); if (e.key === 'ArrowRight') montre(+glis.value + 1);
|
||
});
|
||
gd.on('plotly_click', ev => {
|
||
const p = ev.points[0];
|
||
if (p.customdata) return; // un bloc du Status ou une barre : zoom et détails (DEROULEUR_JS)
|
||
const x = ms(String(p.x));
|
||
let best = 0;
|
||
IM.forEach((m, i) => { if (Math.abs(ms(m.t) - x) < Math.abs(ms(IM[best].t) - x)) best = i; });
|
||
montre(best);
|
||
});
|
||
montre(0);
|
||
"""
|
||
|
||
# Le lecteur du timelapse (TIMELAPSE_JS), caché par-dessus la page jusqu'à ce que gif() le place ; repris par status.py.
|
||
LECTEUR_HTML = """<div id="gif" hidden><div class="lecteur"><canvas></canvas><div><button id="gif-av">◀</button> <button id="gif-p">❚❚</button>
|
||
<button id="gif-ap">▶</button> <button id="gif-x">✕</button> <button id="gif-e" title="download the timelapse as a GIF">⤓ GIF</button> <select id="gif-z"><option value="focused">Focused image</option>
|
||
<option value="global">Global image</option></select> <span id="gif-info"></span></div></div></div>"""
|
||
# Les tables, le lecteur et la zone Details (détails à gauche, timelapse à droite) ; repris par status.py.
|
||
DETAILS_CSS = """table{border-collapse:collapse;font-size:14px} th,td{padding:4px 10px;border-bottom:1px solid #e6e6e2;text-align:left;vertical-align:top}
|
||
th{font-weight:600;color:#3d3d3a}
|
||
#gif{position:fixed;inset:0;background:rgba(0,0,0,.6);display:flex;align-items:center;justify-content:center;z-index:10} #gif[hidden]{display:none}
|
||
#gif>div{background:#fff;padding:12px;border-radius:6px;max-width:94vw} .lecteur canvas{max-width:100%;max-height:78vh;display:block;outline:4px solid transparent;outline-offset:-4px;margin-bottom:8px}
|
||
#gif-info{font-variant-numeric:tabular-nums;color:#3d3d3a}
|
||
.details{display:grid;grid-template-columns:minmax(0,1fr) minmax(0,1fr);gap:24px;align-items:start}"""
|
||
|
||
# Le clic sur la barre d'un événement des détecteurs garde ses seuls capteurs sur les courbes (aucun capteur : tous),
|
||
# les autres cachés dans la légende, qui les rend.
|
||
CAPTEURS_JS = """
|
||
function capteurs(s) {
|
||
const k = gd.data.flatMap((t, i) => t.legendgroup ? [i] : []);
|
||
Plotly.restyle(gd, {visible: k.map(i => !s.length || s.includes(gd.data[i].legendgroup) ? true : 'legendonly')}, k);
|
||
}
|
||
"""
|
||
|
||
|
||
# Le dérouleur (l'utilisateur, 2026-10-27) : un clic sur « ▾ Status » replie ou déplie la ligne des catégories, dépliée au départ.
|
||
DEROULEUR_JS = """
|
||
const DISPO = __DISPO__, CACHEES = __CACHEES__; // [repliée, dépliée] ; les traces de la ligne des catégories
|
||
let deplie = true;
|
||
gd.on('plotly_clickannotation', ev => {
|
||
if (ev.index !== __INDEX__) return;
|
||
deplie = !deplie;
|
||
Plotly.update(gd, {visible: deplie}, DISPO[+deplie], CACHEES);
|
||
});
|
||
// Un clic sur un bloc du Status (l'utilisateur, 2026-10-27), ou sur une barre d'événement (2026-10-28), zoome la plage sur
|
||
// lui et montre ses détails sous la figure, à gauche, et le timelapse de ses images, marge avant et après comprise, à
|
||
// droite ; la barre d'un événement des détecteurs ne garde aussi que ses capteurs sur les courbes.
|
||
// customdata : [début, fin, nom, détails HTML, capteurs (null : barre d'une étiquette)].
|
||
gd.on('plotly_click', ev => {
|
||
const p = ev.points[0];
|
||
if (!p.customdata) return;
|
||
const [debut, fin, nom, corps, cs] = p.customdata;
|
||
if (p.data.name !== 'Status' && cs) capteurs(cs);
|
||
Plotly.relayout(gd, {'xaxis.range': [debut, fin]});
|
||
document.getElementById('details').innerHTML = `<p><b>${nom}</b> : ${debut} → ${fin} UTC</p>` + corps;
|
||
if (typeof gif === 'function') gif([debut, fin, nom, cs], document.getElementById('det-images'));
|
||
});
|
||
"""
|
||
|
||
|
||
def positions(mesures, a, b):
|
||
"""La position médiane de chaque capteur dans l'image sur [a, b) ({} si x, y n'y sont pas des positions)."""
|
||
maisons = {s: (statistics.median(xs), statistics.median(ys)) for s, ms in mesures.items()
|
||
if (xs := [m["x"] for m in ms if a <= m["t"] < b and m["x"] is not None])
|
||
and (ys := [m["y"] for m in ms if a <= m["t"] < b and m["y"] is not None])}
|
||
# x, y ne sont des positions dans l'image que loin du coin : sur LENZSPITZE, des écarts de moins d'un pixel ;
|
||
# alors le timelapse montre l'image entière, sans marque (l'utilisateur, 2026-10-27 : des timelapses minuscules)
|
||
return maisons if any(abs(x) > MARGE_PX or abs(y) > MARGE_PX for x, y in maisons.values()) else {}
|
||
|
||
|
||
def camera(dossier, mesures, a, b, chemin):
|
||
"""Les images de la caméra sur [a, b) ({t, src, e}, src relatif à la page chemin, e l'error_value des capteurs) et la
|
||
position médiane de chaque capteur dans l'image (positions())."""
|
||
vues = [(t, im) for im in donnees.trouver(dossier)["images"] if (t := donnees.heure_image(im)) and a <= t < b]
|
||
images = [{"t": score.iso(t).replace("T", " ").rstrip("Z"), "src": quote(Path(os.path.relpath(im, os.path.dirname(chemin))).as_posix())}
|
||
for t, im in vues]
|
||
maisons = positions(mesures, a, b)
|
||
# e : l'error_value de chaque capteur entouré à l'heure de l'image, celle de la mesure la plus proche à moins d'un
|
||
# demi-pas (les mesures ont quelques secondes de retard sur l'heure de l'image) ; la couleur de son cercle
|
||
tous = sorted({m["t"] for ms in mesures.values() for m in ms if a <= m["t"] < b})
|
||
demi = statistics.median(y - x for x, y in zip(tous, tous[1:])) / 2 if len(tous) > 1 else None
|
||
series = {s: [(m["t"], m["error_value"]) for m in mesures[s] if m["error_value"] is not None] for s in maisons}
|
||
for (t, _), image in zip(vues, images) if maisons and demi else ():
|
||
image["e"] = {}
|
||
for s, serie in series.items():
|
||
i = bisect.bisect_left(serie, (t,))
|
||
proches = [serie[j] for j in (i - 1, i) if 0 <= j < len(serie) and abs(serie[j][0] - t) <= demi]
|
||
if proches:
|
||
image["e"][s] = round(min(proches, key=lambda m: abs(m[0] - t))[1], 2)
|
||
return images, maisons
|
||
|
||
|
||
def timelapse_js(images, maisons, refs):
|
||
"""TIMELAPSE_JS rempli : les images, la marge du recadrage, les positions des capteurs, les références."""
|
||
echelle = [[int(c[i:i + 2], 16) for i in (1, 3, 5)] for c in VERT_ROUGE]
|
||
return (TIMELAPSE_JS.replace("__IMAGES__", json.dumps(images)).replace("__MARGE__", str(MARGE_PX))
|
||
.replace("__POS__", json.dumps(maisons)).replace("__REFS__", json.dumps(sorted(refs)))
|
||
.replace("__ECHELLE__", json.dumps(echelle)).replace("__GRIS__", GRIS))
|
||
|
||
|
||
def disposition(hauteurs, cachee, ouvert, heures=()):
|
||
"""Hauteurs des lignes de la figure en px, de haut en bas ; cachee : l'index de la ligne qui se replie ; heures : les
|
||
lignes qui ont leurs heures dessous (HEURES de plus) -> relayout Plotly : hauteur de la figure et domaine de chaque
|
||
ordonnée (repliée : ordonnée cachée, sur un domaine minuscule, Plotly refusant un domaine nul)."""
|
||
vues = [i for i in range(len(hauteurs)) if ouvert or i != cachee]
|
||
ecart = {i: ESPACE + HEURES * (i in heures) for i in vues}
|
||
p = sum(hauteurs[i] for i in vues) + sum(ecart[i] for i in vues[:-1])
|
||
d = {"height": p + 80, f"yaxis{cachee + 1}.domain": [0, 0.001], f"yaxis{cachee + 1}.visible": ouvert} # 80 : marges t et b
|
||
haut = p
|
||
for i in vues:
|
||
d[f"yaxis{i + 1 if i else ''}.domain"] = [max(0.0, (haut - hauteurs[i]) / p), haut / p]
|
||
haut -= hauteurs[i] + ecart[i]
|
||
return d
|
||
|
||
|
||
def taux_erreur(mesures, a, b):
|
||
"""Ligne « Error rate » : à chaque instant de [a, b), l'error_value moyenne de tous les capteurs, du vert au rouge sur
|
||
une échelle fixe de 0 à 1, avec sa barre de couleur. Dans sa propre rangée : une heatmap sur les axes des barres fait
|
||
planter plotly.js 4.1.1."""
|
||
par_t = {}
|
||
for ms in mesures.values():
|
||
for m in ms:
|
||
if a <= m["t"] < b and m["error_value"] is not None:
|
||
par_t.setdefault(m["t"], []).append((m["error_value"], m["error_threshold"]))
|
||
erreurs = sorted(par_t.items())
|
||
return go.Heatmap(
|
||
x=[t for t, _ in erreurs], y=["Error rate"], z=[[statistics.mean(e for e, _ in v) for _, v in erreurs]],
|
||
text=[[f"{len(v)} capteurs, {sum(1 for e, th in v if th is not None and e > th)} rejetés" for _, v in erreurs]],
|
||
zmin=0, zmax=1, colorscale=[[i / (len(VERT_ROUGE) - 1), c] for i, c in enumerate(VERT_ROUGE)],
|
||
colorbar={"title": {"text": "Error rate", "side": "right"}, "thickness": 12, "len": 0.3, "y": 0, "yanchor": "bottom"},
|
||
hovertemplate="%{x|%Y-%m-%d %H:%M} UTC<br>error_value moyenne : %{z:.3f}<br>%{text}<extra></extra>")
|
||
|
||
|
||
def survol(titre, debut, fin, capteurs, *lignes):
|
||
return "<br>".join([f"<b>{titre}</b>", f"{debut} → {fin}", f"capteurs : {', '.join(capteurs) or 'tous'}",
|
||
*("<br>".join(textwrap.wrap(x, 90)) for x in lignes if x)])
|
||
|
||
|
||
def barres(nom, couleur, spans, pas, rang, groupe):
|
||
"""[(début, fin, catégorie, survol)] -> barres horizontales, de la première mesure à la dernière plus un pas ; même
|
||
groupe : même place dans la ligne."""
|
||
debuts = [score.instant(s[0]) for s in spans]
|
||
return go.Bar(name=nom, orientation="h", y=[s[2] for s in spans], base=debuts, marker_color=couleur, legendrank=rang,
|
||
offsetgroup=groupe,
|
||
x=[(score.instant(s[1]) + pas - d).total_seconds() * 1000 for s, d in zip(spans, debuts)],
|
||
hovertext=[s[3] for s in spans], hoverinfo="text")
|
||
|
||
|
||
def plotly_t(iso):
|
||
"""« 2026-09-25T12:00Z » -> « 2026-09-25 12:00 » : Plotly ne lit pas le Z (le zoom du clic sur une barre)."""
|
||
return iso.replace("T", " ").rstrip("Z")
|
||
|
||
|
||
def tableau(evts):
|
||
"""Événements -> table HTML : début, fin, catégorie, capteurs, phrase."""
|
||
return ("<table><tr><th>Début</th><th>Fin</th><th>Catégorie</th><th>Capteurs</th><th>Phrase</th></tr>"
|
||
+ "".join(f"<tr><td>{v['start']}</td><td>{v['end']}</td><td>{html.escape(v['label'])}</td>"
|
||
f"<td>{html.escape(', '.join(v['sensors']) or 'tous')}</td><td>{html.escape(v['text'])}</td></tr>"
|
||
for v in evts) + "</table>")
|
||
|
||
|
||
def references(mesures, a, b):
|
||
"""Capteurs de la compensation sur la plage : ceux qui ont un reproj_err (docs/domaine/colonnes-des-deplacements.md :
|
||
références seulement), quel que soit pattern_type, vide sur LENZSPITZE et « target » sur des capteurs de CLARIDEN
|
||
qui compensent pourtant (l'utilisateur, 2026-10-28 : retrouver les groupes par les données)."""
|
||
return {s for s, ms in mesures.items() if any(m["reproj_err"] is not None for m in ms if a <= m["t"] < b)}
|
||
|
||
|
||
# Les textes de groupes() : en français pour cette page, en anglais pour la page Status du site (status.py, D-023).
|
||
GROUPES_FR = {"capteur": "Capteur", "rejetees": "Rejetées", "ev": "error_value max / seuil", "ax": "Ampl. corr_x (px)",
|
||
"ay": "Ampl. corr_y (px)", "rp": "reproj_err méd.", "dans": " : {n} / {m} dans l'événement",
|
||
"ref": "Elles compensent le mouvement de la caméra (reproj_err rempli)", "cible": "Elles mesurent l'ouvrage",
|
||
"rej": " Mesures rejetées des capteurs de l'événement : {r} / {n}.", "autres": "Les {n} autres, hors de l'événement"}
|
||
GROUPES_EN = {"capteur": "Sensor", "rejetees": "Rejected", "ev": "max error_value / threshold", "ax": "corr_x range (px)",
|
||
"ay": "corr_y range (px)", "rp": "median reproj_err", "dans": ": {n} / {m} in the event",
|
||
"ref": "They compensate the camera movement (reproj_err filled)", "cible": "They measure the structure",
|
||
"rej": " Rejected measurements of the event's sensors: {r} / {n}.", "autres": "The {n} others, outside the event"}
|
||
|
||
|
||
def groupes(mesures, refs, debut, fin, capteurs, T=GROUPES_FR):
|
||
"""Détail d'un événement ou d'un bloc (debut, fin inclus ; capteurs vides : tous) : References puis Targets, chacun avec
|
||
ses capteurs de l'événement, puis les autres repliés ; par capteur, sur l'événement : mesures rejetées, error_value
|
||
maximale face au seuil, amplitude de corr_x et corr_y, et pour une référence reproj_err médian et part des inlier.
|
||
T : les textes (GROUPES_FR ou GROUPES_EN)."""
|
||
dans = set(capteurs) or set(mesures)
|
||
f = lambda v, n=2: "–" if v is None else f"{v:.{n}f}"
|
||
|
||
def ligne(s):
|
||
ms = donnees.filtrer(mesures[s], debut, fin) # fin à la minute près, comme les événements la donnent
|
||
val = lambda c: [m[c] for m in ms if m[c] is not None]
|
||
amp = lambda c: max(val(c)) - min(val(c)) if val(c) else None
|
||
ev, seuil, rp, inl = val("error_value"), val("error_threshold"), val("reproj_err"), val("inlier")
|
||
rej = sum(donnees.rejetee(m) for m in ms)
|
||
return (f"<tr><td>{html.escape(s)}</td><td>{rej} / {len(ms)}</td><td>{f(max(ev) if ev else None)} / {f(statistics.median(seuil) if seuil else None, 1)}</td>"
|
||
f"<td>{f(amp('corr_x'))}</td><td>{f(amp('corr_y'))}</td>"
|
||
+ (f"<td>{f(statistics.median(rp) if rp else None, 3)}</td><td>{f(statistics.mean(x == 1 for x in inl) * 100 if inl else None, 0)} %</td>"
|
||
if s in refs else "") + "</tr>"), rej, len(ms)
|
||
|
||
def table(lignes, ref):
|
||
return (f"<table><tr><th>{T['capteur']}</th><th>{T['rejetees']}</th><th>{T['ev']}</th><th>{T['ax']}</th>"
|
||
f"<th>{T['ay']}</th>" + f"<th>{T['rp']}</th><th>Inlier</th>" * ref + "</tr>"
|
||
+ "".join(l[0] for l in lignes) + "</table>")
|
||
|
||
out = ""
|
||
for nom, ref, role in (("References", True, T["ref"]), ("Targets", False, T["cible"])):
|
||
tous = sorted(s for s in mesures if (s in refs) == ref)
|
||
touches = [ligne(s) for s in tous if s in dans]
|
||
autres = [ligne(s) for s in tous if s not in dans]
|
||
rej, n = sum(l[1] for l in touches), sum(l[2] for l in touches)
|
||
out += (f"<h4>{nom}{T['dans'].format(n=len(touches), m=len(tous))}</h4><p>{role}."
|
||
+ (T["rej"].format(r=rej, n=n) if touches else "") + "</p>"
|
||
+ (table(touches, ref) if touches else "")
|
||
+ (f"<details><summary>{T['autres'].format(n=len(autres))}</summary>{table(autres, ref)}</details>" if autres else ""))
|
||
return out
|
||
|
||
|
||
def statut(evts, temps, pas, mesures, refs):
|
||
"""Ligne Status : la plage en blocs (les trous de toutes les cibles comblés au pas comptent comme « No data »). Un bloc
|
||
d'événements porte le nom de la catégorie qui en couvre le plus d'instants, celle qui englobe les autres (à égalité, la
|
||
première de CATEGORIES) ; le survol dit tous ses événements et leurs capteurs, ses détails (customdata) leur table."""
|
||
cats = [c for c in score.categories.CATEGORIES if c not in STATUT_HORS]
|
||
grille = [(temps[0], True)]
|
||
for t0, t1 in zip(temps, temps[1:]):
|
||
grille += [(t0 + k * pas, False) for k in range(1, round((t1 - t0) / pas))] + [(t1, True)]
|
||
instants = [(t, [v for v in evts if v["category"] in cats and v["start"] <= score.iso(t) <= v["end"]], not mesure)
|
||
for t, mesure in grille]
|
||
blocs = [] # (début, fin, nom, couleur, survol, détails, capteurs)
|
||
for evenement, bloc in itertools.groupby(instants, key=lambda i: bool(i[1] or i[2])):
|
||
bloc = list(bloc)
|
||
debut, fin = bloc[0][0], bloc[-1][0] + pas
|
||
heures = f"{debut:%Y-%m-%d %H:%M} → {fin:%Y-%m-%d %H:%M} UTC"
|
||
if not evenement:
|
||
blocs.append((debut, fin, "", CALME, f"{heures}<br>aucun événement", "<p>Aucun événement.</p>", []))
|
||
continue
|
||
compte = Counter(c for _, actifs, trou in bloc for c in {v["category"] for v in actifs} | ({"No data"} if trou else set()))
|
||
nom = max((c for c in cats if compte[c]), key=compte.__getitem__)
|
||
vus = list({id(v): v for _, actifs, _ in bloc for v in actifs}.values())
|
||
sans_mesure = any(i[2] for i in bloc) and all(v["category"] != "No data" for v in vus)
|
||
cs = [] if any(not v["sensors"] for v in vus) else list(dict.fromkeys(c for v in vus for c in v["sensors"]))
|
||
lignes = [f"{v['label']} : {', '.join(v['sensors']) if 0 < len(v['sensors']) <= 4 else f'{len(v['sensors'])} capteurs' if v['sensors'] else 'tous'}"
|
||
for v in vus] + ["No data : aucune mesure"] * sans_mesure
|
||
blocs.append((debut, fin, nom, EVENEMENT, f"{heures}<br><b>{nom}</b><br>" + "<br>".join(lignes),
|
||
tableau(vus) + "<p>No data : aucune mesure sur une partie du bloc.</p>" * sans_mesure
|
||
+ groupes(mesures, refs, debut, fin - pas, cs), cs)) # ses capteurs (« tous » : aucun)
|
||
return go.Bar(name="Status", orientation="h", y=["Status"] * len(blocs), base=[b[0] for b in blocs],
|
||
x=[(b[1] - b[0]).total_seconds() * 1000 for b in blocs], marker_color=[b[3] for b in blocs],
|
||
text=[b[2] for b in blocs], textposition="inside", insidetextanchor="middle", textangle=0,
|
||
textfont={"color": "white"}, hovertext=[b[4] + "<br><i>clic : zoom sur le bloc, ses détails sous la figure</i>" for b in blocs],
|
||
hoverinfo="text", showlegend=False,
|
||
customdata=[[f"{b[0]:%Y-%m-%d %H:%M:%S}", f"{b[1]:%Y-%m-%d %H:%M:%S}", b[2] or "Aucun événement", b[5], b[6]] for b in blocs])
|
||
|
||
|
||
def page(dossier, du=None, au=None, entete="", annexe="", chemin=None, analyste=(), lignes=None):
|
||
"""entete, annexe : HTML ajouté avant et après la figure (page de /review-event) ; chemin : la page, sinon out/detecteurs_… ;
|
||
analyste : des étiquettes [(début, fin, ligne, survol)], en barres au-dessus de celles des détecteurs, chaque ligne
|
||
dédoublée ; lignes : {catégorie du journal: ligne}, les lignes à la place des catégories, dans l'ordre de leurs valeurs,
|
||
une catégorie absente gardant la sienne (page de fin de séance de /events-learner, comparaison.py : les familles des
|
||
étiquettes)."""
|
||
mesures = score.charger(dossier)
|
||
if not mesures:
|
||
raise SystemExit(f"Aucun export « advanced » dans {dossier}.")
|
||
tous = sorted({m["t"] for ms in mesures.values() for m in ms})
|
||
a = score.instant(du) if du else tous[0]
|
||
b = score.instant(au) if au else tous[-1] + (tous[-1] - tous[-2])
|
||
temps = [t for t in tous if a <= t < b]
|
||
if len(temps) < 2:
|
||
raise SystemExit(f"Pas de mesures dans {dossier} entre {score.iso(a)} et {score.iso(b)}.")
|
||
pas = statistics.median(y - x for x, y in zip(temps, temps[1:]))
|
||
refs = references(mesures, a, b)
|
||
|
||
evts = score.evenements(mesures, score.iso(a), score.iso(b), score.charger_temperature(dossier))
|
||
spans = [(v["start"], v["end"], (lignes or {}).get(v["category"], v["category"]),
|
||
survol(v["label"], v["start"], v["end"], v["sensors"], v["text"])) for v in evts]
|
||
hors = HORS
|
||
base = [*dict.fromkeys(lignes.values())] if lignes else list(score.categories.CATEGORIES)
|
||
presentes = {s[2] for s in spans} | {s[2] for s in analyste}
|
||
ordre = [*base, *sorted(presentes - set(base) - {hors}), *[hors] * (hors in presentes)]
|
||
haut = 40 if analyste else 30 # deux barres par ligne avec les étiquettes
|
||
station = os.path.basename(os.path.normpath(dossier))
|
||
nom = f"{station}_{score.iso(a)[:10]}_{score.iso(b)[:10]}"
|
||
chemin = chemin or os.path.join(ROOT, "out", f"detecteurs_{nom}.html")
|
||
images, maisons = camera(dossier, mesures, a, b, chemin)
|
||
|
||
poses = [p for p in donnees.charger_camera(dossier) if a <= p["t"] < b]
|
||
c = 1 if poses else 0 # la ligne de la caméra, seulement si le dossier a des poses sur la plage
|
||
s_, k_ = 3 + c, 4 + c # les lignes du Status et des catégories, sous les courbes
|
||
hauteurs = [200] * c + [260, 260, 44, haut * len(ordre) + 20, 30]
|
||
titres = [*["Caméra : pan, tilt, rotation (deg)"] * c, "corr_x (px)", "corr_y (px)", "",
|
||
"Classification : étiquettes (bleu, en haut ; gris : hors catégorie), détecteurs (orange, en bas)"
|
||
if analyste else "", ""] # sans étiquettes, pas de titre aux catégories (l'utilisateur, 2026-10-27)
|
||
fig = make_subplots(rows=5 + c, cols=1, shared_xaxes=True)
|
||
for col, couleur in POSE if poses else ():
|
||
fig.add_trace(go.Scatter(x=[p["t"] for p in poses], y=[p[col] for p in poses], name=col, mode="lines",
|
||
line={"width": 1.2, "color": couleur}, hovertemplate=f"{col} : %{{y:.4f}}°<extra></extra>"), row=1, col=1)
|
||
for i, s in enumerate(sorted(mesures)): # une couleur par capteur ; la légende cache le capteur dans corr_x et corr_y à la fois
|
||
ms = [m for m in mesures[s] if a <= m["t"] < b]
|
||
ref = s in refs
|
||
for row, col in ((1 + c, "corr_x"), (2 + c, "corr_y")):
|
||
fig.add_trace(go.Scatter(x=[m["t"] for m in ms], y=[m[col] for m in ms], name=s + " (réf.)" * ref, mode="lines",
|
||
legendgroup=s, showlegend=col == "corr_x",
|
||
line={"width": 1.2, "color": COULEURS[i % len(COULEURS)], "dash": "dot" if ref else "solid"},
|
||
hovertemplate=f"{s} : %{{y:.3f}} px<extra></extra>"), row=row, col=1)
|
||
if spans:
|
||
d = barres("Détecteurs", SCRIPTS, spans, pas, 1, "d")
|
||
d.customdata = [[plotly_t(v["start"]), plotly_t(score.iso(score.instant(v["end"]) + pas)), v["label"],
|
||
tableau([v]) + groupes(mesures, refs, score.instant(v["start"]), score.instant(v["end"]), v["sensors"]),
|
||
v["sensors"]] for v in evts]
|
||
d.hovertext = [h + "<br><i>clic : zoom, ses capteurs seuls, ses détails" + " et son timelapse" * bool(images)
|
||
+ " sous la figure</i>" for h in d.hovertext]
|
||
fig.add_trace(d, row=k_, col=1) # en mode group, le 1er groupe en bas
|
||
for nom_a, couleur, rang, sel in (("Étiquettes", AGENT, 2, [s for s in analyste if s[2] != hors]),
|
||
(f"Étiquettes, {hors}", GRIS, 3, [s for s in analyste if s[2] == hors])):
|
||
if sel:
|
||
t = barres(nom_a, couleur, sel, pas, rang, "a")
|
||
t.customdata = [[plotly_t(s[0]), plotly_t(score.iso(score.instant(s[1]) + pas)), f"Étiquette : {s[2]}", f"<p>{s[3]}</p>", None]
|
||
for s in sel]
|
||
t.hovertext = [h + "<br><i>clic : zoom, ses détails" + " et son timelapse" * bool(images) + " sous la figure</i>"
|
||
for h in t.hovertext]
|
||
fig.add_trace(t, row=k_, col=1)
|
||
fig.add_trace(go.Scatter(x=[a] * len(ordre), y=ordre, mode="markers", marker={"opacity": 0}, hoverinfo="skip",
|
||
showlegend=False), row=k_, col=1) # invisible : toutes les catégories ont leur ligne, même vides
|
||
fig.add_trace(statut(evts, temps, pas, mesures, refs), row=s_, col=1)
|
||
fig.add_trace(taux_erreur(mesures, a, b), row=5 + c, col=1)
|
||
fig.update_layout(barmode="group", bargap=0.3, bargroupgap=0.1, hovermode="closest",
|
||
uniformtext={"minsize": 9, "mode": "hide"}, # le nom d'un bloc trop court pour lui : au survol seul
|
||
plot_bgcolor="white", margin={"l": 170, "r": 90, "t": 40, "b": 40},
|
||
legend={"orientation": "h", "x": 0, "y": 1.02, "yanchor": "bottom", # au-dessus : à droite, la barre de l'Error rate
|
||
"title": {"text": "clic : cacher, double clic : seul", "side": "top left"}})
|
||
for t in fig.data: # légende : la pose de la caméra et les capteurs seuls
|
||
if t.showlegend is None:
|
||
t.showlegend = t.name in dict(POSE)
|
||
fig.update_xaxes(type="date", range=[a, b], showgrid=True, gridcolor="#e6e6e2")
|
||
fig.update_yaxes(showgrid=True, gridcolor="#eeeeea", zeroline=False)
|
||
fig.update_yaxes(categoryorder="array", categoryarray=ordre[::-1], row=k_, col=1)
|
||
fig.update_yaxes(showticklabels=False, row=s_, col=1) # le dérouleur tient lieu d'étiquette
|
||
for r in range(1, 3 + c): # l'heure sous chaque courbe (pose, corr_x, corr_y), pas seulement sous la dernière ligne
|
||
fig.update_xaxes(showticklabels=True, row=r, col=1)
|
||
for r, titre in enumerate(titres, 1): # chaque titre sur le domaine de sa ligne : il la suit quand le dérouleur bouge
|
||
if titre:
|
||
fig.add_annotation(text=titre, x=0.5, y=1, xref="x domain", yref="y domain", yanchor="bottom", showarrow=False,
|
||
font={"size": 16}, row=r, col=1)
|
||
if r == k_: # le titre des catégories se replie avec elles
|
||
titre_k = f"annotations[{len(fig.layout.annotations) - 1}].visible"
|
||
fig.add_annotation(text="▾ Status", x=0, y=0.5, xref="x domain", yref="y domain", xanchor="right", xshift=-8,
|
||
showarrow=False, captureevents=True, font={"size": 13}, row=s_, col=1)
|
||
i_der = len(fig.layout.annotations) - 1
|
||
dispo = [{**disposition(hauteurs, k_ - 1, o, range(2 + c)), **({titre_k: o} if analyste else {}),
|
||
f"annotations[{i_der}].text": "▾ Status" if o else "▸ Status"} for o in (False, True)]
|
||
fig.plotly_relayout(dispo[1])
|
||
|
||
script = ("const gd = document.getElementById('{plot_id}');" + CAPTEURS_JS # ordonnée sans recalage au zoom (2026-10-27)
|
||
+ DEROULEUR_JS.replace("__DISPO__", json.dumps(dispo)).replace("__INDEX__", str(i_der))
|
||
.replace("__CACHEES__", json.dumps([i for i, t in enumerate(fig.data) if t.yaxis == f"y{k_}"])))
|
||
vue = ""
|
||
if images:
|
||
fig.add_shape(type="line", xref="x", yref="paper", x0=images[0]["t"], x1=images[0]["t"], y0=0, y1=1,
|
||
line={"color": "#d03b3b", "width": 1.5})
|
||
script += timelapse_js(images, maisons, refs) + IMAGES_JS
|
||
vue = f"""<img id="img" alt="image de la caméra" style="max-width:100%;max-height:60vh;margin:8px auto;display:block">
|
||
<div style="text-align:center"><button id="prec">◀</button> <input id="glis" type="range" min="0" max="{len(images) - 1}" value="0"
|
||
style="width:min(60em,70vw);vertical-align:middle"> <button id="suiv">▶</button> <span id="heure" style="font-variant-numeric:tabular-nums"></span></div>
|
||
""" + LECTEUR_HTML
|
||
corps = fig.to_html(include_plotlyjs="cdn", full_html=False, div_id="fig", post_script=script, config={"scrollZoom": False})
|
||
os.makedirs(os.path.dirname(chemin), exist_ok=True)
|
||
with open(chemin, "w", encoding="utf-8") as f:
|
||
f.write(f"""<!doctype html><html lang="fr"><head><meta charset="utf-8"><title>Détecteurs {html.escape(nom)}</title>
|
||
<style>body{{font-family:system-ui,sans-serif;margin:16px;background:#fff;color:#1a1a19}} p{{color:#5f5e5a;max-width:70em}}
|
||
{DETAILS_CSS}</style></head><body>
|
||
{entete}
|
||
<h2>Détecteurs, {html.escape(station)} : {score.iso(a)} → {score.iso(b)} (UTC)</h2>
|
||
<p>Les détecteurs du journal tels qu'ils sont (version {score.version()}), la plage classée avec ses 3 jours d'historique.
|
||
Survol d'une barre : capteurs et phrase ;
|
||
ligne Status, sous les courbes : ce qui se passe (bleu clair : aucun événement ; bleu foncé : un bloc d'événements qui se touchent, nommé par la catégorie
|
||
qui en couvre le plus, celle qui englobe les autres ; le survol dit tous ses événements ; sans À vérifier ni Dérive lente) ; un clic sur « ▾ Status » replie ou déplie les catégories, un clic sur un bloc zoome la plage sur lui et montre ses détails sous la figure (Details : ses événements à gauche, le timelapse de ses images à droite, ses capteurs entourés, jaune les cibles, bleu les références, si x et y sont des positions dans l'image) ; ligne Error rate : error_value moyenne de tous les capteurs à chaque instant. Zoom par sélection ; la liste complète est sous la figure.
|
||
Images : glisseur ou flèches ← → ; un clic sur une courbe va à l'image la plus proche, marquée par la ligne rouge ;
|
||
un clic sur la barre d'un événement fait comme un clic sur un bloc du Status (zoom, ses détails et son timelapse sous la figure)
|
||
et, pour un événement des détecteurs, ne garde que ses capteurs sur les courbes (la légende rend les autres) ; le timelapse : marge avant et après, bord rouge pendant ; Focused image : recadré sur ses capteurs, Global image : l'image entière ; espace : pause, ← → : image par image, Échap : fermer ; ⤓ GIF : le télécharger.</p>
|
||
{vue}{corps}<h3>Details</h3>
|
||
<div class="details"><div id="details"><p>Un clic sur un bloc du Status : ses événements ici, le timelapse de ses images à droite.</p></div>
|
||
<div id="det-images"></div></div>
|
||
<h3>{len(evts)} événement(s)</h3>
|
||
{tableau(evts)}
|
||
{annexe}
|
||
</body></html>""")
|
||
return chemin
|
||
|
||
|
||
if __name__ == "__main__":
|
||
p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
|
||
p.add_argument("dossier")
|
||
p.add_argument("--du")
|
||
p.add_argument("--au")
|
||
p.add_argument("--sans-ouvrir", action="store_true", help="écrit la page sans l'ouvrir (revue de cas)")
|
||
o = p.parse_args()
|
||
chemin = page(o.dossier, o.du, o.au)
|
||
print(chemin)
|
||
if not o.sans_ouvrir:
|
||
open_served(chemin)
|