commit c0c4519ceac35287c4391ccf4215edd6ba7f930c Author: maxime Date: Fri Oct 30 08:59:38 2026 +0100 Labeling tool: the expert labels ranges in plain text, one plot at a time (D-098, point 68) Co-Authored-By: Claude Opus 5.5 diff --git a/labeling.py b/labeling.py new file mode 100644 index 0000000..09d577b --- /dev/null +++ b/labeling.py @@ -0,0 +1,270 @@ +"""L'outil d'étiquetage de l'expert (D-098, point 68 du plan du journal du matin) : se repérer dans le temps et écrire ce qu'on +voit, en langage naturel, sans catégorie ; les données se consultent sur le monitoring. En haut, le data loader de la page +Status ; un menu déroulant, un plot à la fois, comme le menu Advanced d'Explore ; dessous, une barre de temps aux mêmes +abscisses, qui suit le zoom : y glisser sélectionne une plage, puis du texte et Add. Add écrit aussitôt une ligne dans +labeling/.jsonl : {"debut": "2026-10-08T01:00Z", "fin": "2026-10-08T02:45Z", "description": "…"}, en UTC, les noms +de champs de l'analyste (etiquettes.json). Une étiquette se corrige dans ce fichier, puis recharger la page. Les zones +étiquetées sont grisées sur tous les plots ; sur la barre, une barre chacune, son texte au survol, celles qui se chevauchent +l'une sous l'autre. Son serveur local (http://127.0.0.1:8767, lancé en tâche de fond) sert out/ et data/, plus /analyse +(ce script lancé à chaque fois, comme le data loader) et /labels (lire et ajouter). +Usage : python3 labeling/labeling.py [ [--du AAAA-MM-JJ] [--au AAAA-MM-JJ]] + (sans dossier : le data loader seul ; --au exclu ; sans dates, toute la période du dossier ; page : + out/labeling___.html, ouverte) +""" +import argparse +import html +import http.server +import json +import os +import sys +from datetime import datetime +from pathlib import Path +from urllib.parse import parse_qs, urlsplit + +ICI = Path(__file__).resolve().parent +sys.path[:0] = [str(ICI.parent / "detectors-view"), str(ICI.parent / "detectors-view" / "data-loader")] +import chargeur # noqa: E402 (son formulaire, son serveur ; bascule seule sur .venv si plotly manque) +import detecteurs # noqa: E402 (les couleurs et les références de la page Status) +from detecteurs import ROOT, donnees # noqa: E402 +from plotly.offline import get_plotlyjs_version # noqa: E402 + +PORT = 8767 # ni celui de common.page (8765), ni celui du data loader (8766) +# Le menu Advanced d'Explore (select_graph, Dashboard/layouts/ExploreLayout.py de l'application de référence), dans son ordre +PLOTS = (("error_value", "Error value"), ("x", "X [px]"), ("y", "Y [px]"), + ("relative_x", "Relative Horizontal Shift"), ("relative_y", "Relative Vertical Shift"), + ("corr_x", "Relative Corrected Horizontal Shift"), ("corr_y", "Relative Corrected Vertical Shift"), + ("reproj_err", "References (reproj. error)")) +CAMERA = "Camera movement" +FORMAT = "%Y-%m-%dT%H:%MZ" + +# Une figure Plotly n'a qu'un mode de glissement : le plot zoome, la barre, figure à part, sélectionne. Elle reprend à chaque +# changement du plot sa plage et ses marges, la légende pouvant les élargir : c'est ce qui garde les abscisses alignées. +PAGE_JS = """ +const GRIS = '#6b6b66', BLEU = '#2a78d6', VOIE = 22; // VOIE : px par rangée d'étiquettes +const fig = document.getElementById('fig'), barre = document.getElementById('barre'), menu = document.getElementById('plot'); +const texte = document.getElementById('texte'), add = document.getElementById('add'), plage = document.getElementById('plage'); +const AIDE = plage.textContent; +let labels = [], choix = null; // choix : la plage sélectionnée, [debut, fin] au format des étiquettes +const lisible = s => s.slice(0, 16).replace('T', ' '); +const marge = () => ({l: 60, r: 20, t: 10, b: 30}); + +function zones() { + const z = (a, b, couleur, o) => ({type: 'rect', xref: 'x', yref: 'paper', x0: lisible(a), x1: lisible(b), y0: 0, y1: 1, + fillcolor: couleur, opacity: o, line: {width: 0}, layer: 'below'}); + return labels.map(l => z(l.debut, l.fin, GRIS, 0.2)).concat(choix ? [z(choix[0], choix[1], BLEU, 0.25)] : []); +} + +function aligne() { + const f = fig._fullLayout; + if (!barre._fullLayout) return; // au chargement, la barre se dessine juste après le plot + return Plotly.relayout(barre, {'xaxis.range': f.xaxis.range.slice(), 'margin.l': f._size.l, 'margin.r': f._size.r}); +} + +function dessineFig() { + const p = PLOTS[menu.value]; + // uirevision : le zoom et les capteurs cachés restent d'un plot à l'autre ; l'ordonnée, propre à chaque plot, se recale + // uid sans espace ni parenthèse : Plotly s'en sert comme d'un sélecteur CSS + return Plotly.react(fig, p.traces.map(t => ({type: 'scatter', mode: 'lines', x: T[t.t], y: t.y, name: t.name, uid: t.name.replace(/\\W/g, '_'), + line: t.line, hovertemplate: `${t.name}: %{y}`})), + {height: 460, hovermode: 'closest', plot_bgcolor: 'white', margin: marge(), legend: {x: 1.01, y: 1}, uirevision: 1, shapes: zones(), + xaxis: {type: 'date', range: [lisible(A), lisible(B)], gridcolor: '#e6e6e2'}, + yaxis: {title: {text: p.titre}, uirevision: p.titre, gridcolor: '#eeeeea', zeroline: false}}, + {responsive: true, doubleClick: 'reset'}).then(aligne); +} + +function dessineBarre() { + const tries = [...labels].sort((a, b) => a.debut < b.debut ? -1 : 1), voies = []; + const voie = tries.map(l => { // la première rangée libre, sinon une nouvelle, comme les status + const r = voies.findIndex(f => f <= l.debut), i = r < 0 ? voies.length : r; + voies[i] = l.fin; + return i; + }); + const n = Math.max(1, voies.length), f = fig._fullLayout; + return Plotly.react(barre, [{type: 'bar', orientation: 'h', y: voie, base: tries.map(l => lisible(l.debut)), + x: tries.map(l => Date.parse(l.fin) - Date.parse(l.debut)), width: 0.85, marker: {color: GRIS}, text: tries.map(l => l.description), + textposition: 'inside', insidetextanchor: 'start', textangle: 0, unselected: {marker: {opacity: 1}}, // sinon une sélection les pâlit + hoverinfo: 'text', hovertext: tries.map(l => `${lisible(l.debut)} → ${lisible(l.fin)} UTC
${l.description.replace(/\\n/g, '
')}`)}], + {height: 40 + VOIE * n, dragmode: 'select', selectdirection: 'h', hovermode: 'closest', plot_bgcolor: '#f2f2ef', showlegend: false, + margin: {...marge(), l: f._size.l, r: f._size.r}, uniformtext: {minsize: 9, mode: 'hide'}, + xaxis: {type: 'date', range: f.xaxis.range.slice(), showgrid: false}, + yaxis: {range: [n - 0.5, -0.5], fixedrange: true, showticklabels: false, showgrid: false, zeroline: false}, + newselection: {line: {color: BLEU, width: 1}}, activeselection: {fillcolor: BLEU, opacity: 0.25}}, + {responsive: true, displayModeBar: false, doubleClick: false}); +} + +function maj() { + plage.textContent = choix ? `${lisible(choix[0])} → ${lisible(choix[1])} UTC` : AIDE; + add.disabled = !(choix && choix[0] < choix[1] && texte.value.trim()); +} + +function choisit(c) { + choix = c; + maj(); + return Plotly.relayout(fig, {shapes: zones()}); +} + +menu.onchange = dessineFig; +texte.oninput = maj; +add.onclick = async () => { + add.disabled = true; + const corps = {station: STATION, debut: choix[0], fin: choix[1], description: texte.value.trim()}; + const r = await fetch('/labels', {method: 'POST', body: JSON.stringify(corps)}).catch(e => e); + if (!r.ok) { // rien n'est perdu : le texte et la plage restent dans la page + maj(); + return alert('Not saved: ' + (r.statusText || r.message)); + } + labels.push(await r.json()); + texte.value = ''; + await dessineBarre(); + await Plotly.relayout(barre, {selections: []}); + await choisit(null); +}; + +dessineFig().then(dessineBarre).then(() => { + fig.on('plotly_relayout', aligne); + barre.on('plotly_selected', ev => { + const r = ev && ev.range && ev.range.x; + if (r) choisit(r.map(v => String(v).slice(0, 16).replace(' ', 'T') + 'Z')); + }); + barre.on('plotly_deselect', () => choisit(null)); + // Lues à chaque chargement, pas écrites dans la page : recharger montre toujours le fichier. + fetch('/labels?station=' + encodeURIComponent(STATION)) + .then(r => r.ok ? r.json() : Promise.reject(new Error(r.statusText))) + .then(l => { + labels = l.filter(x => x.debut < B && x.fin > A); + return dessineBarre().then(() => Plotly.relayout(fig, {shapes: zones()})); + }) + .catch(e => alert('Labels not read: ' + e.message)); +}); +""" + + +def plots(mesures, poses, a, b): + """-> (T, [plot]) : T, les heures de chaque série, une fois, elles reviennent dans chaque plot (clé : le capteur, "" pour la + caméra) ; plot : titre et traces (name, t : sa clé dans T, y, line), sans les plots ni les capteurs vides.""" + heure = lambda t: t.strftime("%Y-%m-%d %H:%M") # noqa: E731 (UTC, sans fuseau : comme l'affiche Plotly) + valeurs = lambda s, c: [None if m[c] is None else round(m[c], 5) for m in s] # noqa: E731 + dans = {s: [m for m in mesures[s] if a <= m["t"] < b] for s in sorted(mesures)} + refs = detecteurs.references(mesures, a, b) + out = [] + for col, titre in PLOTS: + series = {s: valeurs(ms, col) for s, ms in dans.items()} + traces = [{"name": s + " (ref.)" * (s in refs), "t": s, "y": y, + "line": {"width": 1.2, "color": detecteurs.COULEURS[i % len(detecteurs.COULEURS)], "dash": "dot" if s in refs else "solid"}} + for i, (s, y) in enumerate(series.items()) if any(v is not None for v in y)] + if traces: + out.append({"titre": titre, "traces": traces}) + if poses: + out.append({"titre": CAMERA + " (deg)", "traces": [{"name": c, "t": "", "y": valeurs(poses, c), "line": {"width": 1.2, "color": couleur}} + for c, couleur in detecteurs.POSE]}) + return {"": [heure(p["t"]) for p in poses], **{s: [heure(m["t"]) for m in ms] for s, ms in dans.items()}}, 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]) + T, liste = plots(mesures, [p for p in donnees.charger_camera(dossier) if a <= p["t"] < b], a, b) + if not liste: + raise SystemExit(f"Aucune mesure dans {dossier} du {du} au {au}.") + station = os.path.basename(os.path.normpath(dossier)) + nom = f"{station}_{donnees.iso(a)[:10]}_{donnees.iso(b)[:10]}" + chemin = ROOT / "out" / f"labeling_{nom}.html" + chemin.parent.mkdir(exist_ok=True) + js = lambda v: json.dumps(v, separators=(",", ":")).replace("{html.escape(p["titre"])}' for i, p in enumerate(liste)) + chemin.write_text(f"""Labeling {html.escape(nom)} + + +

Labeling, {html.escape(station)}

+{chargeur.formulaire(station, du or "", au or "")} + +
+
+

Drag on the bar above to select a time range.

+ +

+ +""", encoding="utf-8") + return chemin + + +def fichier(station): + return ICI / f"{station}.jsonl" + + +def lire(station): + f = fichier(station) + # split et non splitlines : celui-ci couperait aussi sur les séparateurs Unicode que le texte peut contenir + return [json.loads(l) for l in f.read_text(encoding="utf-8").split("\n") if l.strip()] if f.exists() else [] + + +def ajouter(corps): + """Le corps d'un Add (station, debut, fin, description) -> l'étiquette écrite ; ValueError s'il n'est pas bon.""" + station, debut, fin, description = corps["station"], corps["debut"], corps["fin"], corps["description"].strip() + if station not in chargeur.stations(): # le nom devient un chemin : une station de data/, rien d'autre + raise ValueError("unknown station") + if not description or datetime.strptime(debut, FORMAT) >= datetime.strptime(fin, FORMAT): + raise ValueError("empty text or range") + label = {"debut": debut, "fin": fin, "description": description} + f = fichier(station) + # Une ligne retirée à la main peut laisser le fichier sans fin de ligne : la suivante se collerait à elle. + avant = f.read_bytes() if f.exists() else b"" + with open(f, "ab") as sortie: + sortie.write(b"\n" * bool(avant and not avant.endswith(b"\n")) + json.dumps(label, ensure_ascii=False).encode() + b"\n") + return label + + +class Serveur(chargeur.Chargeur): + SCRIPT = __file__ + + def repond(self, valeur): + corps = json.dumps(valeur, ensure_ascii=False).encode() + self.send_response(200) + self.send_header("Content-Type", "application/json; charset=utf-8") + self.send_header("Content-Length", str(len(corps))) + self.end_headers() + self.wfile.write(corps) + + def do_GET(self): + url = urlsplit(self.path) + if url.path != "/labels": + return super().do_GET() + station = parse_qs(url.query).get("station", [""])[0] + if station not in chargeur.stations(): + return self.send_error(400, "Unknown station") + try: + self.repond(lire(station)) + except ValueError as e: # une ligne abîmée à la main : le dire, sans toucher au fichier + self.send_error(500, f"labeling/{station}.jsonl unreadable: {e}") + + def do_POST(self): + if self.path != "/labels": + return self.send_error(404) + # Ce fichier sera lu par l'analyste : une autre page du navigateur ne doit pas pouvoir y écrire. + if self.headers.get("Origin") not in (None, f"http://127.0.0.1:{PORT}"): + return self.send_error(403) + try: + self.repond(ajouter(json.loads(self.rfile.read(int(self.headers["Content-Length"]))))) + except (KeyError, TypeError, AttributeError, ValueError) as e: + self.send_error(400, f"Not a label: {e}") + + +if __name__ == "__main__": + if sys.argv[1:] == ["serve"]: + http.server.ThreadingHTTPServer(("127.0.0.1", PORT), Serveur).serve_forever() + 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("Labeling", "labeling-loader") + print(chemin) + if not o.sans_ouvrir: + chargeur.open_served(chemin, PORT, __file__)