detectors-view/hierarchie-des-status.md, validated by the user: No visibility hides Reduced visibility, Faulty target hides Target hidden, No data hides everything, No visibility hides Target hidden; the two thermal phases form one status, Thermal movements. A hidden status is cut, not removed, and only when the stronger one covers all its sensors. status.py transcribes it. Hiding or isolating targets in the sensor legend keeps only the statuses that touch a visible target, or all sensors. Discarded labels become transparent, without text, hover or click: restyling x or base of the label row made Plotly retype its axis as linear. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
212 lines
14 KiB
Python
212 lines
14 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), regroupés et occultés selon hierarchie-des-status.md (D-095) ; une
|
|
étiquette par status, à son heure, de la couleur de sa catégorie, 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 : zoom sur lui (marge avant et après), ses seuls capteurs sur les
|
|
courbes, ses plages soulignées ; un second clic rend tout. 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.
|
|
Usage : python3 detectors-view/status.py <dossier de station> [--du AAAA-MM-JJ] [--au AAAA-MM-JJ]
|
|
(--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 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, open_served, plotly_t
|
|
|
|
# Les plages du Status (l'utilisateur, 2026-10-29) : palette catégorielle de référence (skill dataviz), 8 teintes pour
|
|
# 9 status, No data en gris.
|
|
TEINTES = {"visibilite_reduite": "#2a78d6", "visibilite_nulle": "#6250d6", "passage": "#1baf7a", "cible_masquee": "#e87ba4",
|
|
"cible_degradee": "#e34948", "turbulence": "#eda100", "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) : les deux phases thermiques
|
|
# en un status ; un status occulte les plus faibles qu'il chevauche ; tout le reste se superpose.
|
|
FUSION = {"dilatation_thermique": "thermique", "contraction_thermique": "thermique"}
|
|
NOMS = {"thermique": "Thermal movements"}
|
|
OCCULTE = {"visibilite_nulle": {"visibilite_reduite", "cible_masquee"}, "cible_degradee": {"cible_masquee"},
|
|
"trou": set(TEINTES) - {"trou"}}
|
|
VOIE = 24 # px par rangée d'étiquettes
|
|
|
|
# Un clic sur l'étiquette d'un status (customdata : début, fin, capteurs, rang) le sélectionne ; un second clic rend tout.
|
|
# Marge du zoom : la moitié de la durée, de 1 h à 6 h (comme le timelapse de detecteurs.py). 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__, PLAGE = __PLAGE__, ms = s => Date.parse(s.replace(' ', 'T') + 'Z');
|
|
const iso = t => new Date(t).toISOString().slice(0, 16).replace('T', ' ');
|
|
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();
|
|
});
|
|
gd.on('plotly_click', ev => {
|
|
const p = ev.points[0];
|
|
if (!p.customdata) return;
|
|
const [debut, fin, cs, k] = p.customdata, un = choisi !== k;
|
|
choisi = un ? k : null;
|
|
const m = Math.min(6 * 3600e3, Math.max(3600e3, (ms(fin) - ms(debut)) / 2));
|
|
capteurs(un ? cs : []);
|
|
vus = visibles(); // déjà à jour : l'événement plotly_restyle de capteurs(), plus tard, ne refait rien
|
|
applique(un ? [iso(ms(debut) - m), iso(ms(fin) + m)] : PLAGE);
|
|
});
|
|
"""
|
|
|
|
|
|
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 = []
|
|
for v in sorted(evts, key=lambda v: v["start"]):
|
|
if v["category"] in detecteurs.STATUT_HORS:
|
|
continue
|
|
c = FUSION.get(v["category"], v["category"])
|
|
s = {"category": c, "label": NOMS.get(c, v["label"]), "sensors": v["sensors"], "text": v["text"],
|
|
"d0": donnees.instant(v["start"]), "d1": donnees.instant(v["end"]) + pas}
|
|
p = next((p for p in reversed(ss) if p["category"] == c), None)
|
|
if c in NOMS and p and s["d0"] <= p["d1"]: # deux phases thermiques qui se touchent : un seul Thermal movements
|
|
p["d1"] = max(p["d1"], s["d1"])
|
|
p["sensors"] = sorted(set(p["sensors"]) | set(s["sensors"])) if p["sensors"] and s["sensors"] else []
|
|
p["text"] += " " + s["text"]
|
|
else:
|
|
ss.append(s)
|
|
|
|
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 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]
|
|
|
|
# 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, 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],
|
|
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]
|
|
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)}
|
|
rang["thermique"] = rang["dilatation_thermique"]
|
|
vus, ev = set(), []
|
|
for k, d0, d1 in morceaux:
|
|
s = affiches[k][0]
|
|
for r in range(2, len(titres) + 1):
|
|
fig.add_vrect(x0=d0, x1=d1, row=r, col=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(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("__PLAGE__", json.dumps([plotly_t(donnees.iso(a)), plotly_t(donnees.iso(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")
|
|
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}}</style></head><body>
|
|
<h2>Status, {html.escape(station)}</h2>
|
|
{fig.to_html(include_plotlyjs="cdn", full_html=False, div_id="fig", post_script=script, config={"scrollZoom": False})}
|
|
</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")
|
|
o = p.parse_args()
|
|
chemin = page(o.dossier, o.du, o.au)
|
|
print(chemin)
|
|
if not o.sans_ouvrir:
|
|
open_served(chemin)
|