2026-11-02 16:25:44 +01:00
"""Les détecteurs du journal seuls, sur une plage d'un dossier de station : la page de comparaison.py sans les étiquettes.
2026-10-27 08:28:19 +01:00
2026-10-27 10:15:26 +01:00
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
2026-10-28 09:17:48 +01:00
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
2026-10-28 08:49:51 +01:00
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],
2026-10-27 10:15:26 +01:00
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
2026-10-27 12:10:43 +01:00
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
2026-10-27 12:23:18 +01:00
(un clic sur « ▾ Status » la replie ; un clic sur un bloc zoome la plage sur lui et montre ses détails sous la figure,
2026-10-27 13:27:42 +01:00
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
2026-10-29 10:26:49 +01:00
leur état actuel (la plage classée avec ses 3 jours d'historique, comme un lot de /events-learner), et la ligne « Error rate » :
2026-10-27 09:00:34 +01:00
à chaque instant, l'error_value moyenne de tous les capteurs (du vert au rouge, échelle fixe de 0 à 1) ; en bas, la liste des
2026-10-27 08:28:19 +01:00
événements et leur phrase. Ne modifie rien et n'écrit dans aucun historique.
2026-10-29 10:37:37 +01:00
Usage : python3 detectors-view/detecteurs.py <dossier de station> [--du AAAA-MM-JJ] [--au AAAA-MM-JJ]
2026-10-27 08:28:19 +01:00
(--au exclu ; sans dates, toute la période du dossier ; page : out/detecteurs_<STATION>_<du>_<au>.html, ouverte)
"""
import argparse
2026-10-29 12:45:08 +01:00
import bisect
2026-10-27 08:28:19 +01:00
import html
2026-10-27 11:52:17 +01:00
import itertools
2026-10-27 10:15:26 +01:00
import json
2026-10-27 08:28:19 +01:00
import os
import statistics
2026-10-29 10:37:37 +01:00
import sys
import textwrap
2026-10-27 11:52:17 +01:00
from collections import Counter
2026-10-27 10:15:26 +01:00
from pathlib import Path
from urllib.parse import quote
2026-10-27 08:28:19 +01:00
2026-10-29 10:37:37 +01:00
ICI = os . path . dirname ( os . path . abspath ( __file__ ))
2026-11-03 15:12:24 +01:00
sys . path [: 0 ] = [ os . path . join ( ICI , ".." , "src" ), os . path . join ( ICI , ".." , ".claude" , "skills" , "detector-learner" )]
2026-10-29 10:37:37 +01:00
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
2026-11-03 15:12:24 +01:00
import score # noqa: E402 (détecteurs, chargement et version, comme /detector-learner ; met detectors/ et les outils sur le chemin)
2026-10-27 10:15:26 +01:00
import donnees # noqa: E402
2026-10-29 10:37:37 +01:00
AGENT , SCRIPTS = "#2a78d6" , "#eb6834" # palette catégorielle de référence, slots 1 et 2 (skill dataviz)
2026-11-03 14:57:52 +01:00
HORS , GRIS = "hors catégorie" , "#a3a29c" # étiquettes « None » : aucun détecteur ne peut les rejoindre
2026-10-29 10:37:37 +01:00
# 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" ]
2026-10-27 10:15:26 +01:00
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
2026-10-27 11:52:17 +01:00
# Ligne Status (point 50 du plan) : ce qui se passe, en un mot (l'utilisateur, 2026-10-27) : bleu clair, aucun événement ;
2026-11-03 14:57:52 +01:00
# 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" }
2026-10-27 11:52:17 +01:00
CALME , EVENEMENT = "#d3e4f5" , "#1f4e8c"
2026-10-27 12:10:43 +01:00
ESPACE = 30 # px entre deux lignes de la figure : le titre de la suivante y tient
2026-10-27 15:50:42 +01:00
HEURES = 30 # px de plus sous une courbe : ses heures (l'utilisateur, 2026-10-27 : l'heure sous chaque courbe, pas seulement en bas)
2026-10-27 10:15:26 +01:00
2026-10-29 12:14:18 +01:00
# 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 = """
2026-10-27 10:15:26 +01:00
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.
2026-10-28 08:54:46 +01:00
const G_MARGE = [3600e3, 6 * 3600e3], G_FPS = 4, G_MAX = 150, MARGE = __MARGE__; // à régler à l'œil (comme la maquette Explore)
2026-10-29 12:45:08 +01:00
// 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))})`;
}
2026-10-27 10:15:26 +01:00
const gv = document.getElementById('gif'), gc = gv.querySelector('canvas'), gi = document.getElementById('gif-info');
2026-10-29 12:14:18 +01:00
const ROLE = {avant: 'before', pendant: 'DURING', apres: 'after'};
2026-10-27 13:27:42 +01:00
let G = {f: [], imgs: [], k: 0, run: 0, joue: false, titre: '', capteurs: []};
2026-10-27 15:50:42 +01:00
// 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)};
}
2026-10-27 10:15:26 +01:00
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;
2026-10-27 15:50:42 +01:00
const v = cadre(im);
2026-10-27 10:15:26 +01:00
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;
2026-10-27 15:50:42 +01:00
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';
2026-10-29 12:45:08 +01:00
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)
2026-10-27 13:27:42 +01:00
ctx.drawImage(im, x0, y0, w, h, 0, 0, w, h);
2026-10-29 12:45:08 +01:00
ctx.lineWidth = Math.max(3, w / 330); ctx.font = `${Math.round(t * 1.3)}px sans-serif`;
2026-10-27 13:27:42 +01:00
for (const s of G.capteurs) {
2026-10-29 12:45:08 +01:00
ctx.strokeStyle = ctx.fillStyle = teinte(f.e?.[s]);
ctx.setLineDash(REFS.includes(s) ? [r * 0.5, r * 0.35] : []);
2026-10-27 13:27:42 +01:00
ctx.beginPath(); ctx.arc(POS[s][0] - x0, POS[s][1] - y0, r, 0, 2 * Math.PI); ctx.stroke();
2026-10-29 12:45:08 +01:00
ctx.fillText(s, POS[s][0] - x0 + r * 1.1, POS[s][1] - y0 - r * 0.6);
2026-10-27 13:27:42 +01:00
}
2026-10-27 10:15:26 +01:00
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);
}
2026-10-27 12:31:53 +01:00
// 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;
2026-10-27 13:27:42 +01:00
function gif([debut, fin, titre, capteurs], ici) {
2026-10-27 10:15:26 +01:00
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;
2026-10-27 13:27:42 +01:00
G.capteurs = (capteurs || []).filter(s => s in POS);
2026-10-29 12:14:18 +01:00
if (!G.f.length) return ici ? ici.replaceChildren('No camera image for this event.') : alert('No camera image for this event.');
2026-10-27 10:15:26 +01:00
G.imgs = G.f.map(f => Object.assign(new Image(), {src: f.src})); // chargées d'avance
2026-10-27 12:31:53 +01:00
if (ici) ici.replaceChildren(lecteur); else { gv.append(lecteur); gv.hidden = false; }
2026-10-27 10:15:26 +01:00
image(0).then(() => joue(true));
}
2026-10-27 12:31:53 +01:00
function ferme() { joue(false); gv.hidden = true; gv.append(lecteur); }
2026-10-27 10:15:26 +01:00
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); };
2026-10-28 08:54:46 +01:00
// ⤓ 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
2026-10-28 08:49:51 +01:00
// 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);
2026-10-28 08:54:46 +01:00
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);
2026-10-28 08:49:51 +01:00
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();
2026-10-29 12:14:18 +01:00
const nom = `${document.title.replace(/^ \\ S+ /, '')}_$ {G.titre} _$ {G.f[0].t} `.replace(/[^A-Za-z0-9_.-]+/g, '_') + '.gif';
2026-10-28 08:49:51 +01:00
Object.assign(document.createElement('a'), {href: URL.createObjectURL(new Blob([enc.bytes()], {type: 'image/gif'})), download: nom}).click();
} catch (e) {
2026-10-29 12:14:18 +01:00
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));
2026-10-28 08:49:51 +01:00
} finally {
exp.disabled = false; exp.textContent = '⤓ GIF'; image(k0);
}
}
2026-10-29 12:14:18 +01:00
"""
# 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);
});
2026-10-27 10:15:26 +01:00
gd.on('plotly_click', ev => {
const p = ev.points[0];
2026-10-28 09:17:48 +01:00
if (p.customdata) return; // un bloc du Status ou une barre : zoom et détails (DEROULEUR_JS)
2026-10-27 10:15:26 +01:00
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);
"""
2026-10-27 08:28:19 +01:00
2026-10-29 12:14:18 +01:00
# 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}"""
2026-10-28 09:17:48 +01:00
# 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.
2026-10-27 10:42:34 +01:00
CAPTEURS_JS = """
2026-10-28 09:17:48 +01:00
function capteurs(s) {
2026-10-27 10:42:34 +01:00
const k = gd.data.flatMap((t, i) => t.legendgroup ? [i] : []);
2026-10-27 12:02:05 +01:00
Plotly.restyle(gd, {visible: k.map(i => !s.length || s.includes(gd.data[i].legendgroup) ? true : 'legendonly')}, k);
2026-10-27 10:42:34 +01:00
}
"""
2026-10-27 08:28:19 +01:00
2026-10-27 12:10:43 +01:00
# 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);
});
2026-10-28 09:17:48 +01:00
// 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.
2026-11-02 16:25:44 +01:00
// customdata : [début, fin, nom, détails HTML, capteurs (null : barre d'une étiquette)].
2026-10-27 12:14:20 +01:00
gd.on('plotly_click', ev => {
const p = ev.points[0];
2026-10-28 09:17:48 +01:00
if (!p.customdata) return;
const [debut, fin, nom, corps, cs] = p.customdata;
if (p.data.name !== 'Status' && cs) capteurs(cs);
2026-10-27 12:23:18 +01:00
Plotly.relayout(gd, {'xaxis.range': [debut, fin]});
2026-10-27 12:31:53 +01:00
document.getElementById('details').innerHTML = `<p><b>$ {nom} </b> : $ {debut} → $ {fin} UTC</p>` + corps;
2026-10-28 09:17:48 +01:00
if (typeof gif === 'function') gif([debut, fin, nom, cs], document.getElementById('det-images'));
2026-10-27 12:14:20 +01:00
});
2026-10-27 12:10:43 +01:00
"""
2026-10-30 14:18:14 +01:00
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)."""
2026-10-29 12:14:18 +01:00
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)
2026-10-30 14:18:14 +01:00
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 )
2026-10-29 12:45:08 +01:00
# 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 )
2026-10-29 12:14:18 +01:00
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."""
2026-10-29 12:45:08 +01:00
echelle = [[ int ( c [ i : i + 2 ], 16 ) for i in ( 1 , 3 , 5 )] for c in VERT_ROUGE ]
2026-10-29 12:14:18 +01:00
return ( TIMELAPSE_JS . replace ( "__IMAGES__" , json . dumps ( images )) . replace ( "__MARGE__" , str ( MARGE_PX ))
2026-10-29 12:45:08 +01:00
. replace ( "__POS__" , json . dumps ( maisons )) . replace ( "__REFS__" , json . dumps ( sorted ( refs )))
. replace ( "__ECHELLE__" , json . dumps ( echelle )) . replace ( "__GRIS__" , GRIS ))
2026-10-29 12:14:18 +01:00
2026-10-27 15:50:42 +01:00
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)."""
2026-10-27 12:10:43 +01:00
vues = [ i for i in range ( len ( hauteurs )) if ouvert or i != cachee ]
2026-10-27 15:50:42 +01:00
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 ])
2026-10-27 12:10:43 +01:00
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 ]
2026-10-27 15:50:42 +01:00
haut -= hauteurs [ i ] + ecart [ i ]
2026-10-27 12:10:43 +01:00
return d
2026-10-29 10:37:37 +01:00
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" )
2026-10-28 09:17:48 +01:00
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" )
2026-10-27 12:23:18 +01:00
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>" )
2026-10-28 11:48:12 +01:00
def references ( mesures , a , b ):
2026-11-05 08:21:57 +01:00
"""Capteurs de la compensation sur la plage : ceux qui ont un reproj_err (labeling/connaissances/colonnes-des-deplacements.md :
2026-10-28 11:48:12 +01:00
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 )}
2026-10-29 12:14:18 +01:00
# 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 ):
2026-10-28 11:48:12 +01:00
"""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
2026-10-29 12:14:18 +01:00
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)."""
2026-10-28 11:48:12 +01:00
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 ):
2026-10-29 12:14:18 +01:00
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>"
2026-10-28 11:48:12 +01:00
+ "" . join ( l [ 0 ] for l in lignes ) + "</table>" )
out = ""
2026-10-29 12:14:18 +01:00
for nom , ref , role in (( "References" , True , T [ "ref" ]), ( "Targets" , False , T [ "cible" ])):
2026-10-28 11:48:12 +01:00
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 )
2026-10-29 12:14:18 +01:00
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>"
2026-10-28 11:48:12 +01:00
+ ( table ( touches , ref ) if touches else "" )
2026-10-29 12:14:18 +01:00
+ ( f "<details><summary> { T [ 'autres' ] . format ( n = len ( autres )) } </summary> { table ( autres , ref ) } </details>" if autres else "" ))
2026-10-28 11:48:12 +01:00
return out
def statut ( evts , temps , pas , mesures , refs ):
2026-10-27 11:52:17 +01:00
"""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
2026-10-27 12:23:18 +01:00
première de CATEGORIES) ; le survol dit tous ses événements et leurs capteurs, ses détails (customdata) leur table."""
2026-10-27 11:52:17 +01:00
cats = [ c for c in score . categories . CATEGORIES if c not in STATUT_HORS ]
2026-10-27 10:56:52 +01:00
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 )]
2026-10-27 11:52:17 +01:00
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 ]
2026-10-27 13:27:42 +01:00
blocs = [] # (début, fin, nom, couleur, survol, détails, capteurs)
2026-10-27 11:52:17 +01:00
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 :
2026-10-27 13:27:42 +01:00
blocs . append (( debut , fin , "" , CALME , f " { heures } <br>aucun événement" , "<p>Aucun événement.</p>" , []))
2026-10-27 11:52:17 +01:00
continue
2026-11-03 14:57:52 +01:00
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__ )
2026-10-27 11:52:17 +01:00
vus = list ({ id ( v ): v for _ , actifs , _ in bloc for v in actifs } . values ())
2026-11-03 14:57:52 +01:00
sans_mesure = any ( i [ 2 ] for i in bloc ) and all ( v [ "category" ] != "No data" for v in vus )
2026-10-28 11:48:12 +01:00
cs = [] if any ( not v [ "sensors" ] for v in vus ) else list ( dict . fromkeys ( c for v in vus for c in v [ "sensors" ]))
2026-10-27 11:52:17 +01:00
lignes = [ f " { v [ 'label' ] } : { ', ' . join ( v [ 'sensors' ]) if 0 < len ( v [ 'sensors' ]) <= 4 else f ' { len ( v [ 'sensors' ]) } capteurs' if v [ 'sensors' ] else 'tous' } "
2026-10-27 12:23:18 +01:00
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 ),
2026-10-28 11:48:12 +01:00
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)
2026-10-27 11:52:17 +01:00
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 ,
2026-10-27 12:23:18 +01:00
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 ,
2026-10-27 13:27:42 +01:00
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 ])
2026-10-27 10:56:52 +01:00
2026-11-02 16:25:44 +01:00
def page ( dossier , du = None , au = None , entete = "" , annexe = "" , chemin = None , analyste = (), lignes = None ):
2026-10-29 07:25:29 +01:00
"""entete, annexe : HTML ajouté avant et après la figure (page de /review-event) ; chemin : la page, sinon out/detecteurs_… ;
2026-11-02 16:25:44 +01:00
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)."""
2026-10-27 08:28:19 +01:00
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 :]))
2026-10-28 11:48:12 +01:00
refs = references ( mesures , a , b )
2026-10-27 08:28:19 +01:00
2026-11-05 10:43:35 +01:00
evts = score . evenements ( mesures , score . iso ( a ), score . iso ( b ), dossier )
2026-11-02 16:25:44 +01:00
spans = [( v [ "start" ], v [ "end" ], ( lignes or {}) . get ( v [ "category" ], v [ "category" ]),
2026-10-29 10:37:37 +01:00
survol ( v [ "label" ], v [ "start" ], v [ "end" ], v [ "sensors" ], v [ "text" ])) for v in evts ]
hors = HORS
2026-11-02 16:25:44 +01:00
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
2026-10-27 10:15:26 +01:00
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" )
2026-10-29 12:14:18 +01:00
images , maisons = camera ( dossier , mesures , a , b , chemin )
2026-10-27 08:28:19 +01:00
2026-10-27 10:15:26 +01:00
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
2026-10-27 12:10:43 +01:00
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)" , "" ,
2026-11-02 16:25:44 +01:00
"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)
2026-10-27 12:10:43 +01:00
fig = make_subplots ( rows = 5 + c , cols = 1 , shared_xaxes = True )
2026-10-27 10:15:26 +01:00
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
2026-10-27 08:28:19 +01:00
ms = [ m for m in mesures [ s ] if a <= m [ "t" ] < b ]
2026-10-28 11:48:12 +01:00
ref = s in refs
2026-10-27 10:15:26 +01:00
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" },
2026-10-27 08:28:19 +01:00
hovertemplate = f " { s } : % {{ y:.3f }} px<extra></extra>" ), row = row , col = 1 )
if spans :
2026-10-29 10:37:37 +01:00
d = barres ( "Détecteurs" , SCRIPTS , spans , pas , 1 , "d" )
2026-10-28 11:48:12 +01:00
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" ]),
2026-10-28 09:17:48 +01:00
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 ]
2026-10-27 12:10:43 +01:00
fig . add_trace ( d , row = k_ , col = 1 ) # en mode group, le 1er groupe en bas
2026-11-02 16:25:44 +01:00
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 ])):
2026-10-27 10:30:18 +01:00
if sel :
2026-10-29 10:37:37 +01:00
t = barres ( nom_a , couleur , sel , pas , rang , "a" )
2026-11-02 16:25:44 +01:00
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 ]
2026-10-28 09:17:48 +01:00
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 ]
2026-10-27 12:10:43 +01:00
fig . add_trace ( t , row = k_ , col = 1 )
2026-10-27 10:45:55 +01:00
fig . add_trace ( go . Scatter ( x = [ a ] * len ( ordre ), y = ordre , mode = "markers" , marker = { "opacity" : 0 }, hoverinfo = "skip" ,
2026-10-27 12:10:43 +01:00
showlegend = False ), row = k_ , col = 1 ) # invisible : toutes les catégories ont leur ligne, même vides
2026-10-28 11:48:12 +01:00
fig . add_trace ( statut ( evts , temps , pas , mesures , refs ), row = s_ , col = 1 )
2026-10-29 10:37:37 +01:00
fig . add_trace ( taux_erreur ( mesures , a , b ), row = 5 + c , col = 1 )
2026-10-27 12:10:43 +01:00
fig . update_layout ( barmode = "group" , bargap = 0.3 , bargroupgap = 0.1 , hovermode = "closest" ,
2026-10-27 11:52:17 +01:00
uniformtext = { "minsize" : 9 , "mode" : "hide" }, # le nom d'un bloc trop court pour lui : au survol seul
2026-10-27 10:24:09 +01:00
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" }})
2026-10-27 10:15:26 +01:00
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 )
2026-10-27 08:28:19 +01:00
fig . update_xaxes ( type = "date" , range = [ a , b ], showgrid = True , gridcolor = "#e6e6e2" )
fig . update_yaxes ( showgrid = True , gridcolor = "#eeeeea" , zeroline = False )
2026-10-27 12:10:43 +01:00
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
2026-10-27 15:50:42 +01:00
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 )
2026-10-27 12:10:43 +01:00
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
2026-10-27 15:50:42 +01:00
dispo = [{ ** disposition ( hauteurs , k_ - 1 , o , range ( 2 + c )), ** ({ titre_k : o } if analyste else {}),
2026-10-27 12:10:43 +01:00
f "annotations[ { i_der } ].text" : "▾ Status" if o else "▸ Status" } for o in ( False , True )]
fig . plotly_relayout ( dispo [ 1 ])
2026-10-27 08:28:19 +01:00
2026-10-27 12:10:43 +01:00
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_ } " ])))
2026-10-27 10:15:26 +01:00
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 })
2026-10-29 12:14:18 +01:00
script += timelapse_js ( images , maisons , refs ) + IMAGES_JS
2026-10-27 10:24:09 +01:00
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"
2026-10-27 10:15:26 +01:00
style="width:min(60em,70vw);vertical-align:middle"> <button id="suiv">▶</button> <span id="heure" style="font-variant-numeric:tabular-nums"></span></div>
2026-10-29 12:14:18 +01:00
""" + LECTEUR_HTML
2026-10-27 10:15:26 +01:00
corps = fig . to_html ( include_plotlyjs = "cdn" , full_html = False , div_id = "fig" , post_script = script , config = { "scrollZoom" : False })
2026-10-27 08:28:19 +01:00
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 }}
2026-10-29 12:14:18 +01:00
{ DETAILS_CSS } </style></head><body>
2026-10-27 10:05:04 +01:00
{ entete }
2026-10-27 08:28:19 +01:00
<h2>Détecteurs, { html . escape ( station ) } : { score . iso ( a ) } → { score . iso ( b ) } (UTC)</h2>
2026-11-03 15:12:24 +01:00
<p>Les détecteurs du journal tels qu'ils sont (version { score . version () } ), la plage classée avec ses 3 jours d'historique.
2026-10-27 10:56:52 +01:00
Survol d'une barre : capteurs et phrase ;
2026-10-27 12:10:43 +01:00
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
2026-10-27 13:27:42 +01:00
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.
2026-10-27 10:15:26 +01:00
Images : glisseur ou flèches ← → ; un clic sur une courbe va à l'image la plus proche, marquée par la ligne rouge ;
2026-10-28 09:17:48 +01:00
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>
2026-10-27 12:23:18 +01:00
{ vue }{ corps } <h3>Details</h3>
2026-10-27 12:31:53 +01:00
<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>
2026-10-27 12:23:18 +01:00
<h3> { len ( evts ) } événement(s)</h3>
{ tableau ( evts ) }
2026-10-27 10:05:04 +01:00
{ annexe }
2026-10-27 08:28:19 +01:00
</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" )
2026-10-27 15:50:42 +01:00
p . add_argument ( "--sans-ouvrir" , action = "store_true" , help = "écrit la page sans l'ouvrir (revue de cas)" )
2026-10-27 08:28:19 +01:00
o = p . parse_args ()
chemin = page ( o . dossier , o . du , o . au )
print ( chemin )
2026-10-27 15:50:42 +01:00
if not o . sans_ouvrir :
2026-10-28 08:49:51 +01:00
open_served ( chemin )