260 lines
17 KiB
Python
260 lines
17 KiB
Python
"""La page Status d'une station : version pseudo finale de la page de l'onglet Explore du site (en anglais, D-023).
|
|
En haut, la rangée des status : les événements des détecteurs (la plage classée avec ses 3 jours d'historique ; sans Shift to
|
|
check ni Slow drift, comme le Status de detecteurs.py), occultés selon hierarchie-des-status.md (D-095, sans le regroupement thermique, suspendu) ; une
|
|
étiquette par status, à son heure, de la couleur de sa catégorie, épaisse de la part des capteurs qu'il touche, les status
|
|
qui se chevauchent l'un sous l'autre. Dessous,
|
|
corr_x et corr_y de chaque capteur (px, une couleur par capteur, les références en pointillé ; la légende, à droite, cache un
|
|
capteur dans les deux), puis le mouvement de la caméra (pan, tilt, rotation [deg], camera/ du pompage, si le dossier en a).
|
|
Sur les courbes, chaque status en plage colorée transparente, la légende des catégories au-dessus (un clic cache une
|
|
catégorie). Un clic sur une étiquette sélectionne le status, sans zoom (l'utilisateur, 2026-10-29) : ses seuls capteurs sur
|
|
les courbes, ses plages soulignées ; un second clic rend tout ; un clic ailleurs, hors des légendes, rend toutes les plages
|
|
selon les cibles tracées, sans toucher aux cibles. Des cibles cachées dans la légende (clic, ou double clic pour
|
|
n'en garder qu'une) : seuls restent les status qui touchent une cible visible, ou tous les capteurs. En bas, le bouton
|
|
« Load details » montre les détails du status choisi (ses capteurs, References et Targets) et, à droite, le timelapse de ses images (comme detecteurs.py :
|
|
marge avant et après, bord rouge pendant, Focused ou Global image, ⤓ GIF) ; la page est servie par http://127.0.0.1. Tout
|
|
en haut, le data loader (data-loader/chargeur.py) : une autre station, d'autres dates, et « Analyse » refait la page.
|
|
Usage : python3 detectors-view/status.py [<dossier de station> [--du AAAA-MM-JJ] [--au AAAA-MM-JJ]]
|
|
(sans dossier : le data loader seul, comme detectors-view/status.sh ; --au exclu ; sans dates, toute la période du
|
|
dossier ; page : out/status_<STATION>_<du>_<au>.html, ouverte)
|
|
"""
|
|
import argparse
|
|
import html
|
|
import json
|
|
import os
|
|
import statistics
|
|
import sys
|
|
import textwrap
|
|
|
|
import detecteurs # la page des détecteurs : chargement, couleurs, références (bascule seule sur .venv si plotly manque)
|
|
from detecteurs import ROOT, donnees, go, make_subplots, plotly_t
|
|
|
|
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "data-loader"))
|
|
import chargeur # noqa: E402 (le data loader : son formulaire en haut de la page, son serveur pour l'ouvrir)
|
|
|
|
# Les plages du Status (l'utilisateur, 2026-10-29) : palette catégorielle de référence (skill dataviz), 8 teintes pour
|
|
# 10 status : les deux phases thermiques partagent l'orange, No data en gris.
|
|
TEINTES = {"visibilite_reduite": "#2a78d6", "visibilite_nulle": "#6250d6", "passage": "#1baf7a", "cible_masquee": "#e87ba4",
|
|
"cible_degradee": "#e34948", "turbulence": "#eda100", "dilatation_thermique": "#eb6834",
|
|
"contraction_thermique": "#eb6834", "saut_bref": "#008300", "trou": detecteurs.GRIS}
|
|
# La hiérarchie des status (hierarchie-des-status.md, validée par l'utilisateur le 2026-10-29) : un status occulte les plus
|
|
# faibles qu'il chevauche ; tout le reste se superpose. Le regroupement des deux phases thermiques en Thermal movements est
|
|
# suspendu (l'utilisateur, 2026-10-29 : il ne vaut que pour des phases aux mêmes cibles ; le document le garde).
|
|
OCCULTE = {"visibilite_nulle": {"visibilite_reduite", "cible_masquee"}, "cible_degradee": {"cible_masquee"},
|
|
"trou": set(TEINTES) - {"trou"}}
|
|
VOIE = 24 # px par rangée d'étiquettes
|
|
# L'épaisseur d'une étiquette suit la part des capteurs qu'elle touche (l'utilisateur, 2026-10-29) : EPAISSEUR de la rangée
|
|
# pour tous, PLANCHER de celle-ci au moins pour rester visible ; sous ~9 px, son nom ne se lit plus qu'au survol.
|
|
EPAISSEUR, PLANCHER = 0.85, 0.25
|
|
|
|
# Un clic sur l'étiquette d'un status (customdata : début, fin, capteurs, rang, nom) le sélectionne, sans zoom ; un second clic
|
|
# rend tout. EV : le rang du status de chaque shape. Des cibles cachées dans la légende (l'utilisateur, 2026-10-29) : seuls restent, en étiquette et en plage,
|
|
# les status qui touchent une cible visible, ou tous les capteurs.
|
|
SELECTION_JS = """
|
|
const EV = __EV__;
|
|
const TEXTE = Array.from(gd.data[0].text), CD = Array.from(gd.data[0].customdata), S = {};
|
|
CD.forEach(c => S[c[3]] = c[2]); // les capteurs de chaque status (vide : tous)
|
|
let choisi = null, vus = null; // vus : les cibles visibles (null : toutes)
|
|
const touche = k => !vus || !S[k].length || S[k].some(s => vus.has(s));
|
|
// Les axes x suivent celui du bas (matches), mais pas dans un relayout avec les shapes : chaque mise à jour leur redonne à
|
|
// tous la plage r, par défaut celle de l'axe du bas. Une étiquette écartée devient transparente, sans texte, survol ni clic :
|
|
// changer x ou base de la rangée ferait deviner à Plotly un axe linéaire au lieu de dates.
|
|
const AXES = Object.keys(gd._fullLayout).filter(x => /^xaxis\\d*$/.test(x)), BAS = AXES.find(x => !gd._fullLayout[x].matches);
|
|
function applique(r = gd._fullLayout[BAS].range.slice()) {
|
|
const d = {}, vis = CD.map(c => touche(c[3]));
|
|
Plotly.restyle(gd, {'marker.opacity': [vis.map(v => +v)], text: [TEXTE.map((t, i) => vis[i] ? t : '')],
|
|
customdata: [CD.map((c, i) => vis[i] ? c : null)], hoverinfo: [vis.map(v => v ? 'text' : 'skip')]}, [0]);
|
|
gd.layout.shapes.forEach((_, i) => d[`shapes[${i}].opacity`] = !touche(EV[i]) ? 0 : choisi === null ? 0.2 : EV[i] === choisi ? 0.4 : 0.05);
|
|
AXES.forEach(x => d[x + '.range'] = r);
|
|
Plotly.relayout(gd, d);
|
|
}
|
|
const visibles = () => { // les cibles visibles, null : toutes
|
|
const g = gd.data.filter(t => t.legendgroup), v = g.filter(t => t.visible === true || t.visible === undefined);
|
|
return v.length === g.length ? null : new Set(v.map(t => t.legendgroup));
|
|
};
|
|
gd.on('plotly_restyle', () => { // la légende des capteurs : les cibles visibles ont-elles changé ?
|
|
const n = visibles();
|
|
if (String(n && [...n].sort()) === String(vus && [...vus].sort())) return;
|
|
vus = n;
|
|
applique();
|
|
});
|
|
// Les détails du status choisi sous la figure, à gauche, et le timelapse de ses images à droite, comme detecteurs.py ; aucun
|
|
// status choisi : l'aide. cd : son customdata (début, fin, capteurs, rang, nom). Ils ne viennent que par le bouton « Load
|
|
// details » (l'utilisateur, 2026-10-29), et s'effacent quand la sélection change.
|
|
const DET = __DET__;
|
|
let AIDE = null, selection = null;
|
|
function choix(cd) {
|
|
selection = cd;
|
|
details(null);
|
|
document.getElementById('charge').disabled = !cd;
|
|
}
|
|
function details(cd) {
|
|
const det = document.getElementById('details'), ims = document.getElementById('det-images');
|
|
AIDE = AIDE ?? det.innerHTML;
|
|
if (typeof ferme === 'function') ferme(); // le lecteur arrêté, rangé dans la fenêtre cachée : il reste dans la page
|
|
det.innerHTML = cd ? DET[cd[3]] : AIDE;
|
|
ims.replaceChildren();
|
|
if (cd && typeof gif === 'function') gif([cd[0], cd[1], cd[4], cd[2]], ims);
|
|
}
|
|
let surEtiquette = false; // ce clic a touché une étiquette : plotly_click passe entre le mousedown et le click du document
|
|
document.addEventListener('mousedown', () => surEtiquette = false, true);
|
|
gd.on('plotly_click', ev => {
|
|
const p = ev.points[0];
|
|
if (!p.customdata) return;
|
|
surEtiquette = true;
|
|
const [, , cs, k] = p.customdata, un = choisi !== k;
|
|
choisi = un ? k : null;
|
|
capteurs(un ? cs : []);
|
|
vus = visibles(); // déjà à jour : l'événement plotly_restyle de capteurs(), plus tard, ne refait rien
|
|
applique();
|
|
choix(un ? p.customdata : null);
|
|
});
|
|
// Un clic ailleurs, hors des légendes et des détails (l'utilisateur, 2026-10-29), défait la sélection : les plages
|
|
// reviennent toutes, selon les cibles tracées, qu'il laisse comme elles sont. #gif : ✕ y range le lecteur avant ce clic.
|
|
document.addEventListener('click', e => {
|
|
if (e.target.id === 'charge') return details(selection);
|
|
if (surEtiquette || choisi === null || e.target.closest('.legend, #det, #gif')) return;
|
|
choisi = null;
|
|
applique();
|
|
choix(null);
|
|
});
|
|
"""
|
|
|
|
|
|
def status(evts, pas):
|
|
"""Événements des détecteurs -> status affichés (hierarchie-des-status.md) : [(status, morceaux)] ; status : category,
|
|
label, sensors, text, d0, d1 (un pas après la dernière mesure) ; morceaux : ses plages [(début, fin)] non occultées."""
|
|
ss = [{"category": v["category"], "label": v["label"], "sensors": v["sensors"], "text": v["text"],
|
|
"d0": donnees.instant(v["start"]), "d1": donnees.instant(v["end"]) + pas}
|
|
for v in sorted(evts, key=lambda v: v["start"]) if v["category"] not in detecteurs.STATUT_HORS]
|
|
|
|
def occulte(f, s): # règles 2 et 4 : f est plus fort, et concerne tous les capteurs ou au moins tous ceux de s
|
|
return s["category"] in OCCULTE.get(f["category"], ()) and (
|
|
not f["sensors"] or bool(s["sensors"]) and set(s["sensors"]) <= set(f["sensors"]))
|
|
|
|
out = []
|
|
for s in ss:
|
|
morceaux = [(s["d0"], s["d1"])]
|
|
for f in ss:
|
|
if occulte(f, s): # s coupé : ce qui reste avant f, ce qui reste après
|
|
morceaux = [m for a, b in morceaux for m in ((a, min(b, f["d0"])), (max(a, f["d1"]), b)) if m[0] < m[1]]
|
|
if morceaux:
|
|
out.append((s, morceaux))
|
|
return out
|
|
|
|
|
|
def details(s, mesures, refs, pas):
|
|
"""Les détails d'un status sous la figure, en anglais (D-023) : son nom, ses heures, ses capteurs et sa phrase, puis ses
|
|
capteurs, References et Targets, comme detecteurs.groupes."""
|
|
return (f"<p><b>{html.escape(s['label'])}</b>: {plotly_t(donnees.iso(s['d0']))} → {plotly_t(donnees.iso(s['d1']))} UTC"
|
|
f"<br>Sensors: {html.escape(', '.join(s['sensors']) or 'all')}</p><p>{html.escape(s['text'])}</p>"
|
|
+ detecteurs.groupes(mesures, refs, s["d0"], s["d1"] - pas, s["sensors"], detecteurs.GROUPES_EN))
|
|
|
|
|
|
def page(dossier, du=None, au=None):
|
|
mesures = donnees.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 = donnees.instant(du) if du else tous[0]
|
|
b = donnees.instant(au) if au else tous[-1] + (tous[-1] - tous[-2])
|
|
refs = detecteurs.references(mesures, a, b)
|
|
poses = [p for p in donnees.charger_camera(dossier) if a <= p["t"] < b]
|
|
station = os.path.basename(os.path.normpath(dossier))
|
|
nom = f"{station}_{donnees.iso(a)[:10]}_{donnees.iso(b)[:10]}"
|
|
chemin = os.path.join(ROOT, "out", f"status_{nom}.html")
|
|
images, maisons = detecteurs.camera(dossier, mesures, a, b, chemin)
|
|
|
|
# Un événement par plage, pas les blocs du Status : sur NIEDERHORN, une cible défaillante tout du long en fait un seul bloc.
|
|
pas = statistics.median(y - x for x, y in zip(tous, tous[1:])) # une plage finit un pas après sa dernière mesure
|
|
affiches = status(detecteurs.score.evenements(mesures, donnees.iso(a), donnees.iso(b)), pas)
|
|
morceaux = sorted(((k, d0, d1) for k, (_, ms) in enumerate(affiches) for d0, d1 in ms), key=lambda m: m[1])
|
|
voies, voie = [], [] # fin de la dernière étiquette de chaque rangée ; la rangée de chaque morceau
|
|
for _, d0, d1 in morceaux:
|
|
r = next((i for i, f in enumerate(voies) if f <= d0), len(voies)) # la première rangée libre, sinon une nouvelle
|
|
voies[r:r + 1] = [d1]
|
|
voie.append(r)
|
|
|
|
titres = ["", "corr_x (px)", "corr_y (px)", *["Camera movement: pan, tilt, rotation (deg)"] * bool(poses)]
|
|
hauteurs = [VOIE * max(1, len(voies)), 260, 260, 200][:len(titres)] # px
|
|
fig = make_subplots(rows=len(titres), cols=1, shared_xaxes=True, subplot_titles=titres, vertical_spacing=0.06,
|
|
row_heights=hauteurs)
|
|
survol = {k: f"<b>{s['label']}</b><br>{plotly_t(donnees.iso(s['d0']))} → {plotly_t(donnees.iso(s['d1']))} UTC<br>sensors: "
|
|
+ (", ".join(s["sensors"]) or "all") + "<br>" + "<br>".join(textwrap.wrap(s["text"], 90))
|
|
+ "<br><i>click: select (Load details at the bottom); again: show all</i>" for k, (s, _) in enumerate(affiches)}
|
|
fig.add_trace(go.Bar(
|
|
orientation="h", y=voie, base=[d0 for _, d0, _ in morceaux], x=[(d1 - d0).total_seconds() * 1000 for _, d0, d1 in morceaux],
|
|
width=[EPAISSEUR * max(PLANCHER, len(affiches[k][0]["sensors"]) / len(mesures) if affiches[k][0]["sensors"] else 1)
|
|
for k, _, _ in morceaux],
|
|
marker_color=[TEINTES.get(affiches[k][0]["category"], detecteurs.GRIS) for k, _, _ in morceaux],
|
|
text=[affiches[k][0]["label"] for k, _, _ in morceaux], textposition="inside", insidetextanchor="middle", textangle=0,
|
|
hoverinfo="text", showlegend=False, name="Events", hovertext=[survol[k] for k, _, _ in morceaux],
|
|
customdata=[[plotly_t(donnees.iso(s["d0"])), plotly_t(donnees.iso(s["d1"])), s["sensors"], k, s["label"]]
|
|
for k, s in ((k, affiches[k][0]) for k, _, _ in morceaux)]), row=1, col=1)
|
|
for i, s in enumerate(sorted(mesures)):
|
|
ms = [m for m in mesures[s] if a <= m["t"] < b]
|
|
ref = s in refs
|
|
for row, col in ((2, "corr_x"), (3, "corr_y")):
|
|
fig.add_trace(go.Scatter(x=[m["t"] for m in ms], y=[m[col] for m in ms], name=s + " (ref.)" * ref, mode="lines",
|
|
legendgroup=s, showlegend=col == "corr_x",
|
|
line={"width": 1.2, "color": detecteurs.COULEURS[i % len(detecteurs.COULEURS)],
|
|
"dash": "dot" if ref else "solid"},
|
|
hovertemplate=f"{s}: %{{y:.3f}} px<extra></extra>"), row=row, col=1)
|
|
for col, couleur in detecteurs.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=4, col=1)
|
|
|
|
rang = {k: i for i, k in enumerate(detecteurs.score.categories.CATEGORIES)}
|
|
vus, ev, plages = set(), [], []
|
|
for k, d0, d1 in morceaux:
|
|
s = affiches[k][0]
|
|
for r in range(2, len(titres) + 1): # les plages d'un coup : add_vrect revalide toutes les précédentes à chaque appel (~7 s sur 2 semaines)
|
|
plages.append({"type": "rect", "xref": f"x{r}", "yref": f"y{r} domain", "x0": d0, "x1": d1, "y0": 0, "y1": 1,
|
|
"fillcolor": TEINTES.get(s["category"], detecteurs.GRIS), "opacity": 0.2, "line": {"width": 0},
|
|
"layer": "below", "legend": "legend2", "legendgroup": s["label"], "name": s["label"],
|
|
"legendrank": rang.get(s["category"], 99), "showlegend": s["label"] not in vus})
|
|
vus.add(s["label"])
|
|
ev.append(k)
|
|
fig.update_layout(shapes=plages)
|
|
fig.update_layout(height=sum(hauteurs) + 260, hovermode="closest", plot_bgcolor="white",
|
|
margin={"l": 60, "r": 20, "t": 100, "b": 40}, bargap=0.15,
|
|
uniformtext={"minsize": 9, "mode": "hide"}, # une étiquette trop courte pour son nom : au survol seul
|
|
legend={"x": 1.01, "y": 1, "yanchor": "top"}, # à droite des courbes (l'utilisateur, 2026-10-29)
|
|
legend2={"orientation": "h", "x": 0, "y": 1.02, "yanchor": "bottom", "title": {"text": "Status"}})
|
|
fig.update_xaxes(type="date", range=[a, b], showgrid=True, gridcolor="#e6e6e2", showticklabels=True) # l'heure sous chaque courbe
|
|
fig.update_xaxes(showticklabels=False, row=1, col=1)
|
|
fig.update_yaxes(showgrid=True, gridcolor="#eeeeea", zeroline=False)
|
|
fig.update_yaxes(autorange="reversed", showticklabels=False, showgrid=False, fixedrange=True, row=1, col=1)
|
|
|
|
script = ("const gd = document.getElementById('{plot_id}');" + detecteurs.CAPTEURS_JS
|
|
+ SELECTION_JS.replace("__EV__", json.dumps(ev))
|
|
.replace("__DET__", json.dumps([details(s, mesures, refs, pas) for s, _ in affiches]))
|
|
+ (detecteurs.timelapse_js(images, maisons, refs) if images else ""))
|
|
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="en"><head><meta charset="utf-8"><title>Status {html.escape(nom)}</title>
|
|
<style>body{{font-family:system-ui,sans-serif;margin:16px;background:#fff;color:#1a1a19}} p{{max-width:70em}}
|
|
{detecteurs.DETAILS_CSS}</style></head><body>
|
|
<h2>Status, {html.escape(station)}</h2>
|
|
{chargeur.formulaire(station, du or "", au or "")}
|
|
{detecteurs.LECTEUR_HTML if images else ""}
|
|
{fig.to_html(include_plotlyjs="cdn", full_html=False, div_id="fig", post_script=script, config={"scrollZoom": False})}
|
|
<section id="det"><h3>Details</h3><button id="charge" disabled>Load details</button>
|
|
<div class="details"><div id="details"><p>Select a status above the curves, then Load details: its details here{
|
|
", the timelapse of its camera images on the right" if images else ""}.</p></div><div id="det-images"></div></div></section>
|
|
</body></html>""")
|
|
return chemin
|
|
|
|
|
|
if __name__ == "__main__":
|
|
p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
|
|
p.add_argument("dossier", nargs="?", help="sans dossier : le data loader seul")
|
|
p.add_argument("--du")
|
|
p.add_argument("--au")
|
|
p.add_argument("--sans-ouvrir", action="store_true", help="écrit la page sans l'ouvrir")
|
|
o = p.parse_args()
|
|
chemin = page(o.dossier, o.du, o.au) if o.dossier else chargeur.accueil()
|
|
print(chemin)
|
|
if not o.sans_ouvrir:
|
|
chargeur.ouvrir(chemin)
|