2026-10-30 08:59:38 +01:00
"""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
2026-10-30 11:23:31 +01:00
Status ; un menu déroulant, un plot à la fois, comme le menu Advanced d'Explore, plus les métriques système numériques de
metrics/ (« System: … », sans les identifiants) ; 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
2026-10-30 08:59:38 +01:00
labeling/<STATION>.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 [<dossier de station> [--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_<STATION>_<du>_<au>.html, ouverte)
"""
import argparse
2026-10-30 11:23:31 +01:00
import glob
2026-10-30 08:59:38 +01:00
import html
import http.server
import json
import os
2026-10-30 11:23:31 +01:00
import re
2026-10-30 08:59:38 +01:00
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)
2026-10-30 11:23:31 +01:00
from common.stations import load_csv , parse_name # noqa: E402
2026-10-30 08:59:38 +01:00
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"
2026-10-30 11:23:31 +01:00
# Pas de copie des identifiants (CLAUDE.md, « data/ ») : ces fichiers ne sont pas lus ; SIM_CCID a souvent l'air d'un nombre.
IDENTIFIANT = re . compile ( r "SIM_CCID$|ip(_|$)" )
2026-10-30 08:59:38 +01:00
FORMAT = "%Y-%m- %d T%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
2026-10-30 11:23:31 +01:00
return Plotly.react(fig, p.traces.map(t => ({type: 'scatter', mode: t.mode || 'lines', marker: {size: 4} , x: T[t.t], y: t.y, name: t.name, uid: t.name.replace(/ \\ W/g, '_'),
2026-10-30 08:59:38 +01:00
line: t.line, hovertemplate: `$ {t.name} : % {y} <extra></extra>`})),
{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<br>${l.description.replace(/ \\ n/g, '<br>')}`)}],
{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));
});
"""
2026-10-30 11:23:31 +01:00
def metriques ( dossier , a , b ):
"""Les métriques système numériques de metrics/ sur [a, b) -> {nom: {t: valeur ou None}}, sans celles qui n'ont aucune valeur."""
series = {}
for p in sorted ( glob . glob ( os . path . join ( dossier , "metrics" , "*.csv" ))):
n = parse_name ( p )
if n and not IDENTIFIANT . match ( n [ 1 ]):
try :
series . setdefault ( n [ 1 ], {}) . update ( load_csv ( p )) # à heure égale, le dernier fichier, comme load_stations
except ValueError : # une métrique texte (link, mode…) : pas de courbe
pass
dans = { m : { t : v if isinstance ( v , float ) else None for t , v in sorted ( s . items ()) if a <= t < b } for m , s in series . items ()}
return { m : s for m , s in dans . items () if any ( v is not None for v in s . values ())}
def plots ( mesures , poses , systeme , a , b ):
2026-10-30 08:59:38 +01:00
"""-> (T, [plot]) : T, les heures de chaque série, une fois, elles reviennent dans chaque plot (clé : le capteur, "" pour la
2026-10-30 11:23:31 +01:00
caméra, « system: » et son nom pour une métrique) ; plot : titre et traces (name, t : sa clé dans T, y, line ; mode pour
les métriques, horaires : une valeur seule entre deux trous ne se verrait pas sans marqueur), sans les plots ni les capteurs vides."""
2026-10-30 08:59:38 +01:00
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 ]})
2026-10-30 11:23:31 +01:00
T = { "" : [ heure ( p [ "t" ]) for p in poses ], ** { s : [ heure ( m [ "t" ]) for m in ms ] for s , ms in dans . items ()}}
for nom in sorted ( systeme , key = str . lower ):
s = systeme [ nom ]
T [ "system:" + nom ] = [ heure ( t ) for t in s ]
out . append ({ "titre" : "System: " + nom , "traces" : [{ "name" : nom , "t" : "system:" + nom , "mode" : "lines+markers" ,
"y" : [ None if v is None else round ( v , 5 ) for v in s . values ()],
"line" : { "width" : 1.2 , "color" : detecteurs . COULEURS [ 0 ]}}]})
return T , out
2026-10-30 08:59:38 +01:00
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 ])
2026-10-30 11:23:31 +01:00
T , liste = plots ( mesures , [ p for p in donnees . charger_camera ( dossier ) if a <= p [ "t" ] < b ], metriques ( dossier , a , b ), a , b )
2026-10-30 08:59:38 +01:00
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 ( "</" , "< \\ /" ) # noqa: E731
options = "" . join ( f '<option value=" { i } "> { html . escape ( p [ "titre" ]) } </option>' for i , p in enumerate ( liste ))
chemin . write_text ( f """<!doctype html><html lang="en"><head><meta charset="utf-8"><title>Labeling { html . escape ( nom ) } </title>
<script src="https://cdn.plot.ly/plotly- { get_plotlyjs_version () } .min.js"></script>
<style>body {{ font-family:system-ui,sans-serif;margin:16px;background:#fff;color:#1a1a19 }}
textarea {{ width:100%;box-sizing:border-box;font:inherit;padding:6px }} select,button {{ font:inherit }} #plage {{ margin:8px 0 }} </style></head><body>
<h2>Labeling, { html . escape ( station ) } </h2>
{ chargeur . formulaire ( station , du or "" , au or "" ) }
<label>Plot <select id="plot"> { options } </select></label>
<div id="fig"></div>
<div id="barre"></div>
<p id="plage">Drag on the bar above to select a time range.</p>
<textarea id="texte" rows="3" placeholder="What do we see in this range?"></textarea>
<p><button id="add" disabled>Add</button></p>
<script>const T = { js ( T ) } , PLOTS = { js ( liste ) } , STATION = { js ( station ) } , A = { js ( donnees . iso ( a )) } , B = { js ( donnees . iso ( b )) } ;
{ PAGE_JS } </script>
</body></html>""" , 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__ )