296 lines
21 KiB
Python
296 lines
21 KiB
Python
"""Les détecteurs du journal seuls, sur une plage d'un dossier de station : la page de comparaison.py sans l'analyste.
|
||
|
||
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 premier clic sur la barre d'un événement des détecteurs ne garde que
|
||
ses capteurs sur les courbes (la légende rend les autres), un second joue
|
||
le timelapse des images de l'événement, recadré sur les capteurs, avec une marge avant et après (comme ▶ Images de la
|
||
maquette Explore). 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, 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 /boucle), 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), 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 .claude/skills/boucle/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 html
|
||
import itertools
|
||
import json
|
||
import os
|
||
import statistics
|
||
from collections import Counter
|
||
from pathlib import Path
|
||
from urllib.parse import quote
|
||
|
||
import comparaison # noqa: E402 (met src/, detectors/ et les outils sur le chemin ; barres, survol, couleurs)
|
||
from comparaison import AUTOSCALE_Y_JS, ROOT, est_reference, go, make_subplots, open_html, score
|
||
import donnees # noqa: E402
|
||
|
||
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 catégorie qui l'englobe. « À vérifier » et « Dérive lente »
|
||
# n'y entrent pas : un mouvement possible a ses lignes.
|
||
STATUT_HORS = {"a_verifier", "derive_lente"}
|
||
CALME, EVENEMENT = "#d3e4f5", "#1f4e8c"
|
||
|
||
# Le glisseur des images et la ligne verticale de la figure (shapes[0]) ; un clic sur la figure va à l'image la plus proche.
|
||
IMAGES_JS = """
|
||
const IM = __IMAGES__, ms = s => Date.parse(s.replace(' ', 'T') + (/[Z+]/.test(s.slice(10)) ? '' : 'Z'));
|
||
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);
|
||
});
|
||
|
||
// 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 = 60, VUE = __VUE__; // à régler à l'œil (comme la maquette Explore)
|
||
const gv = document.getElementById('gif'), gc = gv.querySelector('canvas'), gi = document.getElementById('gif-info');
|
||
const ROLE = {avant: 'avant', pendant: 'PENDANT', apres: 'après'};
|
||
let G = {f: [], imgs: [], k: 0, run: 0, joue: false, titre: ''};
|
||
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 = VUE || {x: [0, im.naturalWidth], y: [0, im.naturalHeight]};
|
||
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;
|
||
gc.getContext('2d').drawImage(im, x0, y0, w, h, 0, 0, w, h);
|
||
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);
|
||
}
|
||
function gif([debut, fin, titre]) {
|
||
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;
|
||
if (!G.f.length) return alert('Pas d’image de la caméra pour cet événement.');
|
||
G.imgs = G.f.map(f => Object.assign(new Image(), {src: f.src})); // chargées d'avance
|
||
gv.hidden = false;
|
||
image(0).then(() => joue(true));
|
||
}
|
||
function ferme() { joue(false); gv.hidden = true; }
|
||
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); };
|
||
gd.on('plotly_click', ev => {
|
||
const p = ev.points[0];
|
||
if (p.customdata) return capteurs(p.customdata) || gif(p.customdata); // une barre : ses capteurs d'abord, puis son timelapse
|
||
if (p.data.type === 'bar') return; // un bloc du Status : son x est une durée, pas une heure
|
||
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 premier 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 ; la plage ne change pas, l'ordonnée se recale sur les capteurs gardés.
|
||
# capteurs() rend false si la barre n'est pas un événement des détecteurs ou s'il est déjà choisi : au clic suivant, le timelapse.
|
||
CAPTEURS_JS = """
|
||
let choisi = null;
|
||
function capteurs(cd) {
|
||
const s = (cd || [])[3], cle = JSON.stringify(cd);
|
||
if (!s || cle === choisi) return false;
|
||
choisi = cle;
|
||
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)
|
||
.then(() => Plotly.relayout(gd, {'xaxis.range': gd._fullLayout.xaxis.range.slice()}));
|
||
return true;
|
||
}
|
||
"""
|
||
|
||
|
||
def statut(evts, temps, pas):
|
||
"""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."""
|
||
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)
|
||
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"))
|
||
continue
|
||
compte = Counter(c for _, actifs, trou in bloc for c in {v["category"] for v in actifs} | ({"trou"} if trou else set()))
|
||
nom = score.categories.CATEGORIES[max((c for c in cats if compte[c]), key=compte.__getitem__)]["label"]
|
||
vus = list({id(v): v for _, actifs, _ in bloc for v in actifs}.values())
|
||
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"] * (any(i[2] for i in bloc) and all(v["category"] != "trou" for v in vus))
|
||
blocs.append((debut, fin, nom, EVENEMENT, f"{heures}<br><b>{nom}</b><br>" + "<br>".join(lignes)))
|
||
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] for b in blocs], hoverinfo="text", showlegend=False)
|
||
|
||
|
||
def page(dossier, du=None, au=None, entete="", annexe="", chemin=None, analyste=()):
|
||
"""entete, annexe : HTML ajouté avant et après la figure (page de /revue-cas) ; chemin : la page, sinon out/detecteurs_… ;
|
||
analyste : ses moments [(début, fin, catégorie, survol)], en barres au-dessus de celles des détecteurs, chaque ligne de
|
||
catégorie dédoublée (page de fin de séance de /boucle, comparaison.py)."""
|
||
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:]))
|
||
|
||
evts = score.evenements(mesures, score.iso(a), score.iso(b))
|
||
spans = [(v["start"], v["end"], v["category"],
|
||
comparaison.survol(v["label"], v["start"], v["end"], v["sensors"], v["text"])) for v in evts]
|
||
hors = comparaison.HORS
|
||
presentes = {v["category"] for v in evts} | {s[2] for s in analyste}
|
||
ordre = [*score.categories.CATEGORIES, *sorted(presentes - set(score.categories.CATEGORIES) - {hors}), *[hors] * (hors in presentes)]
|
||
haut = 40 if analyste else 30 # deux barres par ligne avec l'analyste
|
||
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 = [{"t": score.iso(t).replace("T", " ").rstrip("Z"), "src": quote(Path(os.path.relpath(im, os.path.dirname(chemin))).as_posix())}
|
||
for im in donnees.trouver(dossier)["images"] if (t := donnees.heure_image(im)) and a <= t < b]
|
||
|
||
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
|
||
fig = make_subplots(rows=5 + c, cols=1, shared_xaxes=True, vertical_spacing=0.025,
|
||
row_heights=[200] * c + [260, 260, haut * len(ordre) + 20, 44, 30],
|
||
subplot_titles=(*["Caméra : pan, tilt, rotation (deg)"] * c, "corr_x (px)", "corr_y (px)",
|
||
"Classification : analyste (bleu, en haut ; gris : hors catégorie), détecteurs (orange, en bas)"
|
||
if analyste else "Événements des détecteurs, par catégorie", "", ""))
|
||
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 = est_reference(mesures[s])
|
||
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 = comparaison.barres("Détecteurs", comparaison.SCRIPTS, spans, pas, 1, "d")
|
||
d.customdata = [[v["start"], score.iso(score.instant(v["end"]) + pas), v["label"], v["sensors"]] # 1er clic : ses capteurs
|
||
for v in evts] # seuls, 2e : son timelapse
|
||
d.hovertext = [h + "<br><i>clic : ses capteurs seuls" + ", 2e clic : timelapse des images" * bool(images) + "</i>"
|
||
for h in d.hovertext]
|
||
fig.add_trace(d, row=3 + c, col=1) # en mode group, le 1er groupe en bas
|
||
for nom_a, couleur, rang, sel in (("Analyste", comparaison.AGENT, 2, [s for s in analyste if s[2] != hors]),
|
||
(f"Analyste, {hors}", comparaison.GRIS, 3, [s for s in analyste if s[2] == hors])):
|
||
if sel:
|
||
t = comparaison.barres(nom_a, couleur, sel, pas, rang, "a")
|
||
t.customdata = [[s[0], score.iso(score.instant(s[1]) + pas), f"Analyste : {s[2]}"] for s in sel]
|
||
if images:
|
||
t.hovertext = [h + "<br><i>clic : timelapse des images</i>" for h in t.hovertext]
|
||
fig.add_trace(t, row=3 + c, col=1)
|
||
fig.add_trace(go.Scatter(x=[a] * len(ordre), y=ordre, mode="markers", marker={"opacity": 0}, hoverinfo="skip",
|
||
showlegend=False), row=3 + c, col=1) # invisible : toutes les catégories ont leur ligne, même vides
|
||
fig.add_trace(statut(evts, temps, pas), row=4 + c, col=1)
|
||
fig.add_trace(comparaison.taux_erreur(mesures, a, b), row=5 + c, col=1)
|
||
fig.update_layout(barmode="group", bargap=0.3, bargroupgap=0.1, height=734 + 230 * c + haut * len(ordre), 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=3 + c, col=1)
|
||
|
||
lignes = "".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)
|
||
script = AUTOSCALE_Y_JS + CAPTEURS_JS
|
||
if not images:
|
||
script += "gd.on('plotly_click', ev => capteurs(ev.points[0].customdata));"
|
||
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})
|
||
maisons = [(statistics.median(xs), statistics.median(ys)) for ms in mesures.values()
|
||
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])]
|
||
cadre = {k: [min(h[i] for h in maisons) - MARGE_PX, max(h[i] for h in maisons) + MARGE_PX]
|
||
for i, k in enumerate("xy")} if maisons else None
|
||
script += IMAGES_JS.replace("__IMAGES__", json.dumps(images)).replace("__VUE__", json.dumps(cadre))
|
||
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>
|
||
<div id="gif" hidden><div><canvas></canvas><div><button id="gif-av">◀</button> <button id="gif-p">❚❚</button>
|
||
<button id="gif-ap">▶</button> <button id="gif-x">✕</button> <span id="gif-info"></span></div></div></div>"""
|
||
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}}
|
||
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}} #gif canvas{{max-width:90vw;max-height:78vh;display:block;outline:4px solid transparent;outline-offset:-4px;margin-bottom:8px}}
|
||
#gif-info{{font-variant-numeric:tabular-nums;color:#3d3d3a}}</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 {comparaison.benchmark.version()}), la plage classée avec ses 3 jours d'historique.
|
||
Survol d'une barre : capteurs et phrase ;
|
||
ligne Status : 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) ; 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 premier clic sur la barre d'un événement des détecteurs ne garde que ses capteurs sur les courbes (la légende rend les autres) ;
|
||
un second clic, ou un clic sur une barre de l'analyste, joue le timelapse de l'événement (marge avant et après, bord rouge pendant ; espace : pause, ← → : image par image, Échap : fermer).</p>
|
||
{vue}{corps}<h3>{len(evts)} événement(s)</h3>
|
||
<table><tr><th>Début</th><th>Fin</th><th>Catégorie</th><th>Capteurs</th><th>Phrase</th></tr>{lignes}</table>
|
||
{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")
|
||
o = p.parse_args()
|
||
chemin = page(o.dossier, o.du, o.au)
|
||
print(chemin)
|
||
open_html(chemin)
|