2026-11-13 11:32:43 +01:00
import { useEffect , useMemo , useRef , useState } from "react" ;
import {
ActionIcon , Badge , Button , Card , Checkbox , Grid , Group , Loader , NativeSelect , SegmentedControl , SimpleGrid , Stack , Switch , Text , Textarea , TextInput , Title , Tooltip ,
useComputedColorScheme ,
} from "@mantine/core" ;
import { IconPlus , IconX } from "@tabler/icons-react" ;
import { appel , Selecteur } from "../commun.jsx" ;
import { ImagesDe } from "./Images.jsx" ;
// Data, le visualiseur de courbes (et l'étiquetage de labeling/labeling.py) : un plot au départ, d'autres à ajouter ou enlever,
// tous alignés sur le temps ; sous eux les étiquettes : Detectors (les événements du journal), LLM (labeling/auto/, en lecture)
// ou Analysis (les mêmes, à modifier, supprimer ; glisser sur la barre sélectionne une plage, que l'analyste diagnostique et
// étiquette ; ailleurs, glisser zoome) ; un clic ouvre une
// étiquette et la met en évidence. À droite, les images de la station, et sous elles les paramètres du diagnostic.
const FAMILLES = { "Visibility" : "#8ec5e8" , "Obstruction" : "#f0b072" , "Thermal displacement" : "#f08a7e" , "Displacement" : "#b39ddb" ,
"Target issue" : "#e6d46a" , "No data" : "#c4c4be" , "None" : "#a8d5a2" };
const NOM_FAMILLE = f => ( f === "None" ? "None (courbes intactes)" : f );
const CHOIX_FAMILLE = [{ value : "" , label : "(sans famille)" }, ... Object . keys ( FAMILLES ). map ( f => ({ value : f , label : NOM_FAMILLE ( f ) }))];
// LLM et Analysis : les mêmes étiquettes, labeling/auto/ ; LLM les lit, Analysis les modifie, supprime, et en fait faire par
// l'analyste sur une plage (app/serveur/analyse.py)
const SOURCES = [{ value : "detecteurs" , label : "Detectors" }, { value : "auto" , label : "LLM" }, { value : "analysis" , label : "Analysis" }];
const GRIS = "#b0b0aa" , BLEU = "#2a78d6" , VOIE = 26 , HAUT = 330 ; // VOIE : px par rangée d'étiquettes ; HAUT : d'un plot
const couleur = l => FAMILLES [ l . categorie ] || GRIS ;
const lisible = s => s . slice ( 0 , 16 ). replace ( "T" , " " );
const marge = () => ({ l : 60 , r : 20 , t : 10 , b : 30 });
// L'habillage, aux couleurs de Mantine (dark.0 à dark.7 en sombre, gray en clair)
const COULEURS = { clair : { texte : "#495057" , faible : "#868e96" , grille : "#eef0f2" , axe : "#dee2e6" , fond : "#f1f3f5" , bulle : "#ffffff" , zone : 0.05 },
sombre : { texte : "#c9c9c9" , faible : "#828282" , grille : "#2e2e2e" , axe : "#424242" , fond : "#3b3b3b" , bulle : "#242424" , zone : 0.07 } };
const POLICE = "Roboto, sans-serif" ;
const habillage = c => ({ paper_bgcolor : "rgba(0,0,0,0)" , plot_bgcolor : "rgba(0,0,0,0)" , font : { family : POLICE , size : 11 , color : c . texte },
hoverlabel : { bgcolor : c . bulle , bordercolor : c . axe , align : "left" , font : { family : POLICE , size : 12 , color : c . texte } },
modebar : { bgcolor : "rgba(0,0,0,0)" , color : c . faible , activecolor : "#5383ff" } });
const axe = c => ({ gridcolor : c . grille , linecolor : c . axe , showline : true , zeroline : false , ticks : "" });
const OUTILS = { responsive : true , doubleClick : "reset" , displaylogo : false , showTips : false ,
modeBarButtonsToRemove : [ "lasso2d" , "select2d" , "autoScale2d" , "zoomIn2d" , "zoomOut2d" , "hoverClosestCartesian" , "hoverCompareCartesian" , "toggleSpikelines" ] };
const date = v => Date . parse ( String ( v ). replace ( " " , "T" ). replace ( /Z?$/ , "Z" )); // une date Plotly ou d'étiquette -> ms UTC
const coupe = s => s . replace ( /(.{1,80})(\s|$)/g , "$1<br>" ); // la bulle : des lignes de 80 caractères au plus
const DETECTEES = Object . keys ( FAMILLES ). filter ( f => f !== "None" ); // les familles des détecteurs (categories.py)
export default function Data ({ selection , choisir , analyse , setAnalyse }) {
const [ donnees , setDonnees ] = useState ( null ), [ charge , setCharge ] = useState ( false ), [ large , setLarge ] = useState ( false );
const gauche = useRef (), [ instant , setInstant ] = useState ( null ); // instant : où caler les images (le début de l'événement cliqué)
// Les paramètres du diagnostic, sous l'image (Detectors et LLM) : familles montrées (filtre de la page) ; cibles gardées ("" :
// toutes ; sinon les détecteurs retournent sans les autres)
const [ source , setSource ] = useState ( "detecteurs" ), [ familles , setFamilles ] = useState ( DETECTEES ), [ cibles , setCibles ] = useState ( "" );
const [ focus , setFocus ] = useState ( false ); // un événement ouvert : les plots ne montrent que ses capteurs
const { station , du , au } = selection ;
useEffect (() => {
setDonnees ( null ); setCibles ( "" );
if ( ! station ) return ;
setCharge ( true );
appel ( `/api/courbes? ${ new URLSearchParams ({ station , du , au } )}` ). then ( d => { setDonnees ( d ); setCharge ( false ); });
}, [ station , du , au ]);
// Les colonnes glissent (style.css) ; Plotly ne suit que la fenêtre : à la fin du glissement, les plots se recalent sur leur
// nouvelle largeur (les redessiner à chaque image du glissement serait trop lourd)
const finGlissement = e => { if ( e . target === gauche . current && e . propertyName === "max-width" ) dispatchEvent ( new Event ( "resize" )); };
return (
< Grid gutter = "lg" className = "data-grille" onTransitionEnd = { finGlissement }>
< Grid.Col span = {{ base : 12 , lg : large ? 5 : 8 }} ref = { gauche }>
< Stack gap = "lg" >
< div >
< Title order = { 2 }> Data </ Title >
< Text c = "dimmed" > Les courbes d 'une station, un plot ou plusieurs ; sous eux les étiquettes : un clic sur l' une la met en évidence et
l 'ouvre.</Text>
</div>
<Selecteur selection={selection} choisir={choisir} />
{charge && <Loader />}
{donnees && <Courbes key={`${station}${du}${au}`} selection={selection} d={donnees} caler={(t, proche) => setInstant({ t, proche })}
source={source} setSource={setSource} familles={familles} cibles={cibles} focus={focus}
analyse={analyse} setAnalyse={setAnalyse} />}
</Stack>
</Grid.Col>
<Grid.Col span={{ base: 12, lg: large ? 7 : 4 }}>
<div className="colle">
<Stack gap="lg">
<ImagesDe selection={selection} compacte large={large} basculer={() => setLarge(!large)} instant={instant} />
{donnees && <Parametres key={`${station}${du}${au}`} d={donnees} familles={familles} setFamilles={setFamilles}
cibles={cibles} setCibles={setCibles} detect={source === "detecteurs"}
focus={focus} setFocus={setFocus} />}
</Stack>
</div>
</Grid.Col>
</Grid>
);
}
// Les familles s' appliquent tout de suite ( filtre de la page , Detectors et LLM ) ; les cibles , au bouton : chaque jeu de cibles
// relance les détecteurs (les étiquettes LLM ne disent pas leurs capteurs : elles ne les filtrent pas)
function Parametres ({ d , familles , setFamilles , cibles , setCibles , detect , focus , setFocus }) {
const capteurs = Object . keys ( d . T ). filter ( k => k && ! k . startsWith ( "system:" ));
const refs = new Set ( d . plots . flatMap ( p => p . traces ). filter ( t => t . name . endsWith ( " (ref.)" )). map ( t => t . t ));
const [ coches , setCoches ] = useState ( cibles ? cibles . split ( "," ) : capteurs );
const voulu = coches . length === capteurs . length ? "" : capteurs . filter ( c => coches . includes ( c )). join ( "," );
return (
< Card shadow = "sm" withBorder >
< Stack gap = "sm" >
< Title order = { 5 }> Paramètres du diagnostic </ Title >
< Switch label = "Focus on event curves" description = "Un événement ouvert : les plots ne montrent que ses capteurs"
checked = { focus } onChange = { e => setFocus ( e . currentTarget . checked )} />
< Checkbox.Group label = "Familles montrées" value = { familles } onChange = { setFamilles }>
< SimpleGrid cols = { 2 } spacing = { 6 } verticalSpacing = { 6 } mt = { 6 }>
{ DETECTEES . map ( f => < Checkbox key = { f } size = "xs" value = { f } label = { f } color = { FAMILLES [ f ]} iconColor = "#1a1b1e" />)}
</ SimpleGrid >
</ Checkbox.Group >
< Checkbox.Group label = "Cibles considérées (les autres sont écartées)" value = { coches } onChange = { setCoches }>
< SimpleGrid cols = { 3 } spacing = { 6 } verticalSpacing = { 6 } mt = { 6 }>
{ capteurs . map ( c => < Checkbox key = { c } size = "xs" value = { c } label = { c + ( refs . has ( c ) ? " (ref.)" : "" )} />)}
</ SimpleGrid >
</ Checkbox.Group >
{ ! detect && < Text size = "xs" c = "dimmed" > Les étiquettes ne disent pas leurs cibles : ce choix ne vaut que pour Detectors .</ Text >}
< Group gap = "sm" >
< Button size = "xs" onClick = {() => setCibles ( voulu )} disabled = { ! coches . length || voulu === cibles }> Relancer les détecteurs </ Button >
< Button size = "xs" variant = "default" onClick = {() => setCoches ( coches . length ? [] : capteurs )}>{ coches . length ? "Tout décocher" : "Tout cocher" }</ Button >
</ Group >
</ Stack >
</ Card >
);
}
// Une ligne de la fiche d'un événement des détecteurs : son nom, puis sa valeur
const Champ = ({ nom , children }) => (
< Group gap = "sm" align = "flex-start" wrap = "nowrap" >
< Text size = "sm" c = "dimmed" w = { 80 } style = {{ flexShrink : 0 }}>{ nom }</ Text >
< Text size = "sm" component = "div" >{ children }</ Text >
</ Group >
);
// Les capteurs d'un événement : ceux des détecteurs, sinon ceux que nomme le texte de l'étiquette (LLM, Analysis)
const nomme = ( texte , s ) => new RegExp ( `(^|[^\\w]) ${ s . replace ( /[^\w]/g , "\\$&" ) } (?![\\w])` ). test ( texte );
const capteursDe = ( l , noms ) => l . capteurs ?? noms . filter ( s => nomme ( l . description , s ));
// analyse : le dossier de l'analyse montrée, tenu par App (la barre latérale en ouvre une)
function Courbes ({ selection : { station , du , au }, d , caler , source , setSource , familles , cibles , focus , analyse , setAnalyse }) {
const { A , B , T , plots : PLOTS } = d ;
const indice = ( titre , sinon ) => { const i = PLOTS . findIndex ( p => p . titre === titre ); return i < 0 ? sinon : i ; };
const [ Plotly , setPlotly ] = useState ( null ), [ pret , setPret ] = useState ( false );
const [ vues , setVues ] = useState ([{ id : 1 , m : indice ( "Relative Corrected Horizontal Shift" , 0 ) }]); // les plots affichés
const [ choix , setChoix ] = useState ( null );
const [ indices , setIndices ] = useState ( "" ), [ rev , setRev ] = useState ( 0 );
const [ ouverte , setOuverte ] = useState ( null ), [ edit , setEdit ] = useState ( null ), [ note , setNote ] = useState ( "" );
const [ toutes , setToutes ] = useState ([]), [ lecture , setLecture ] = useState ( true ), sombre = useComputedColorScheme ( "light" ) === "dark" ;
// toutes : le fichier (ou les détecteurs) ; labels : sur la plage, dans les familles cochées (sans famille ou None : toujours)
const labels = useMemo (() => toutes . filter ( x => x . debut < B && x . fin > A
&& ( ! DETECTEES . includes ( x . categorie ) || familles . includes ( x . categorie ))), [ toutes , familles ]);
const detect = source === "detecteurs" , lecteur = source !== "analysis" ; // seul Analysis écrit
const dossier = source === "analysis" ? "auto" : source ; // le dossier de labeling/ des étiquettes
// figs : id -> div du plot ; dessines : id -> plot qu'il montre ; vue : la plage et la largeur où le texte des étiquettes a été tronqué
const figs = useRef ({}), dessines = useRef ({}), prochain = useRef ( 2 ), barre = useRef (), tries = useRef ([]), vue = useRef ( "" ), courant = useRef ({});
// le focus : les capteurs de l'événement ouvert (aucun : tous, comme pour No data) ; montres, leur clé
const noms = useMemo (() => Object . keys ( T ). filter ( k => k && ! k . startsWith ( "system:" )), [ T ]);
const gardes = focus && ouverte ? capteursDe ( ouverte , noms ) : [], montres = gardes . join ( "," );
courant . current = { vues , labels , choix , ouverte , ouvrir , gardes : new Set ( gardes ), montres , c : COULEURS [ sombre ? "sombre" : "clair" ] }; // ce que lisent les événements Plotly
useEffect (() => { import ( "plotly.js-dist-min" ). then ( m => setPlotly (() => m . default )); }, []);
const liste = () => courant . current . vues . map ( v => figs . current [ v . id ]). filter ( g => g ? . _fullLayout );
// Les zones des étiquettes, la plage choisie, et l'étiquette ouverte : plus marquée, entourée
function zones () {
const { labels , choix , ouverte , c } = courant . current ;
const z = ( a , b , f , o , ligne = { width : 0 }, couche = "below" ) => ({ type : "rect" , xref : "x" , yref : "paper" , x0 : lisible ( a ), x1 : lisible ( b ),
y0 : 0 , y1 : 1 , fillcolor : f , opacity : o , line : ligne , layer : couche });
return labels . map ( l => z ( l . debut , l . fin , couleur ( l ), c . zone )). concat ( choix ? [ z ( choix [ 0 ], choix [ 1 ], BLEU , 0.25 )] : [])
. concat ( ouverte ? [ z ( ouverte . debut , ouverte . fin , couleur ( ouverte ), 0.3 ),
z ( ouverte . debut , ouverte . fin , "rgba(0,0,0,0)" , 1 , { color : c . texte , width : 1.5 , dash : "dot" }, "above" )] : []);
}
// Le contour des barres : épais pour l'étiquette ouverte
const contour = t => {
const { ouverte , c } = courant . current ;
return { color : t . map ( l => ( l === ouverte ? c . texte : c . fond )), width : t . map ( l => ( l === ouverte ? 3 : 1 )) };
};
// Les plots et la barre partagent plage et marges : celui qui change impose les siens aux autres (rien si déjà alignés,
// sinon le relayout appelle aligne en boucle).
function aligne ( src ) {
const gs = liste (), b = barre . current ;
if ( ! b ? . _fullLayout || ! gs . length ) return ;
const rg = ( src ? . _fullLayout ? src : gs [ 0 ]). _fullLayout . xaxis . range . slice ();
const l = Math . max (... gs . map ( g => g . _fullLayout . _size . l )), r = Math . max (... gs . map ( g => g . _fullLayout . _size . r ));
return Promise . all ([... gs , b ]. map ( g => {
const m = g . _fullLayout . margin , x = g . _fullLayout . xaxis . range ;
if ( m . l === l && m . r === r && date ( x [ 0 ]) === date ( rg [ 0 ]) && date ( x [ 1 ]) === date ( rg [ 1 ])) return ;
return Plotly . relayout ( g , { "xaxis.range" : rg , "margin.l" : l , "margin.r" : r });
})). then ( recaleTexte );
}
// Le texte des étiquettes suit le zoom et la largeur de la barre (rien si les deux n'ont pas changé)
function recaleTexte () {
const b = barre . current , L = b ? . _fullLayout ;
if ( ! L ) return ;
const v = ` ${ L . xaxis . range } | ${ L . _size . w } ` ;
if ( v !== vue . current ) { vue . current = v ; return Plotly . restyle ( b , { text : [ textes ( tries . current , L )] }); }
}
// Le texte de chaque étiquette, tronqué à la largeur visible de sa barre (~6 px par caractère en 11 px) ; pour un événement
// des détecteurs, sa famille seulement (ses capteurs dans la bulle, le reste au clic)
function textes ( t , L ) {
const [ r0 , r1 ] = L . xaxis . range . map ( date ), w = L . _size . w ;
return t . map ( l => {
const x = l . message ? l . categorie : l . description ;
const px = ( Math . min ( date ( l . fin ), r1 ) - Math . max ( date ( l . debut ), r0 )) / ( r1 - r0 ) * w , n = Math . floor (( px - 10 ) / 6 );
return n < 3 ? "" : x . length <= n ? x : x . slice ( 0 , n - 1 ) + "…" ;
});
}
// Une trace de capteur sous le focus : visible si c'est l'un des siens, sinon dans la légende seulement ; uirevision de la
// trace : le focus qui change l'emporte sur les clics de légende, qui restent tant qu'il ne change pas
function focalise ( t ) {
const { gardes , montres } = courant . current ;
if ( ! montres || ! t . t || t . t . startsWith ( "system:" )) return { uirevision : montres || 1 };
return { visible : gardes . has ( t . t ) ? true : "legendonly" , uirevision : montres };
}
function dessineFig ( g , m ) {
const p = PLOTS [ m ], { c } = courant . current , b = barre . current ? . _fullLayout ;
g . style . height = ` ${ HAUT } px` ; // responsive : Plotly reprend la hauteur du div à chaque restyle, il lui en faut une
// uirevision : le zoom et les capteurs cachés restent quand on change de plot ; l'ordonnée, propre à chaque plot, se recale.
// Un nouveau plot prend la plage déjà affichée. t : la place du menu du plot (à gauche) et de la barre d'outils (à droite).
return Plotly . react ( g , 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 , "_" ), line : t . line , ... focalise ( t ),
hovertemplate : ` ${ t . name } : %{y}<br>%{x|%Y-%m-%d %H:%M} UTC<extra></extra>` })),
{ ... habillage ( c ), height : HAUT , hovermode : "closest" , margin : { ... marge (), t : 42 , b : 36 }, uirevision : 1 , shapes : zones (),
legend : { x : 1.01 , y : 1 , itemwidth : 30 , font : { size : 11 } },
xaxis : { type : "date" , range : b ? b . xaxis . range . slice () : [ lisible ( A ), lisible ( B )], ... axe ( c ) },
yaxis : { title : { text : p . titre , font : { size : 11 , color : c . faible } }, uirevision : p . titre , ... axe ( c ) } },
OUTILS ). then (() => {
if ( ! g . suivi ) {
g . suivi = true ;
g . on ( "plotly_relayout" , () => aligne ( g ));
g . on ( "plotly_click" , ev => caler ( String ( ev . points [ 0 ]. x ), true )); // un clic sur une courbe : l'image la plus proche
}
return aligne ( g );
});
}
// Les plots nouveaux ou changés (tous : au changement de thème)
function dessinePlots ( tous ) {
return Promise . all ( courant . current . vues . filter ( v => tous || dessines . current [ v . id ] !== v . m )
. map ( v => { dessines . current [ v . id ] = v . m ; return dessineFig ( figs . current [ v . id ], v . m ); }));
}
function dessineBarre () {
const t = [... courant . current . labels ]. sort (( a , b ) => ( a . debut < b . debut ? - 1 : 1 ));
tries . current = t ;
const voies = [], voie = t . map ( l => { // la première rangée libre, sinon une nouvelle
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 ), gs = liste (), f = gs [ 0 ]. _fullLayout , { c } = courant . current ;
vue . current = "" ;
barre . current . style . height = ` ${ 40 + VOIE * n } px` ; // comme les plots
return Plotly . react ( barre . current , [{ type : "bar" , orientation : "h" , y : voie , base : t . map ( l => lisible ( l . debut )),
x : t . map ( l => Date . parse ( l . fin ) - Date . parse ( l . debut )), width : 0.8 ,
marker : { color : t . map ( couleur ), cornerradius : 4 , line : contour ( t ) },
text : textes ( t , barre . current . _fullLayout || f ), textposition : "inside" , insidetextanchor : "start" , textangle : 0 ,
textfont : { family : POLICE , size : 11 , color : "#1a1b1e" },
unselected : { marker : { opacity : 1 } }, // sinon une sélection les pâlit
// la bulle : pour un détecteur, ses cibles seulement ; sinon la famille et tout le texte, que la barre tronque
customdata : t . map ( l => ( l . message ? coupe ( l . cibles . length ? l . cibles . join ( ", " ) : l . references . length
? l . references . map ( s => s + " (ref.)" ). join ( ", " ) : "Tous les capteurs" )
: ( l . categorie ? `<b> ${ NOM_FAMILLE ( l . categorie ) } </b><br>` : "" ) + coupe ( l . description ))),
hovertemplate : "%{customdata}<extra></extra>" }],
{ ... habillage ( c ), height : 40 + VOIE * n , dragmode : lecteur ? "zoom" : "select" , selectdirection : "h" , hovermode : "closest" , plot_bgcolor : c . fond , showlegend : false ,
margin : { ... marge (), l : Math . max (... gs . map ( g => g . _fullLayout . _size . l )), r : Math . max (... gs . map ( g => g . _fullLayout . _size . r )) },
xaxis : { type : "date" , range : f . xaxis . range . slice (), showgrid : false , ticks : "" , color : c . texte },
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 });
}
// Le premier dessin, puis les événements de la barre, une fois
useEffect (() => {
if ( ! Plotly ) return ;
dessinePlots (). then ( dessineBarre ). then (() => aligne ()). then (() => {
barre . current . on ( "plotly_selected" , ev => {
const r = ev ? . range ? . x ;
if ( r ) setChoix ( r . map ( v => String ( v ). slice ( 0 , 16 ). replace ( " " , "T" ) + "Z" ));
});
barre . current . on ( "plotly_deselect" , () => setChoix ( null ));
barre . current . on ( "plotly_relayout" , () => aligne ( barre . current )); // zoomée (Detectors, LLM) ou redimensionnée seule (l'image agrandie)
// Un clic sur une étiquette l'ouvre ; un clic ailleurs sur la barre (pas un glisser) la referme
let surEtiquette = false , x0 = 0 ;
barre . current . on ( "plotly_click" , ev => { surEtiquette = true ; courant . current . ouvrir ( tries . current [ ev . points [ 0 ]. pointIndex ]); });
barre . current . addEventListener ( "mousedown" , e => { x0 = e . clientX ; }, true );
barre . current . addEventListener ( "click" , e => {
if ( ! surEtiquette && Math . abs ( e . clientX - x0 ) < 4 ) courant . current . ouvrir ( null );
surEtiquette = false ;
});
setPret ( true );
});
return () => [... Object . values ( figs . current ), barre . current ]. forEach ( g => g && Plotly . purge ( g ));
}, [ Plotly ]);
useEffect (() => { if ( pret ) dessinePlots (). then (() => aligne ( barre . current )); }, [ vues ]);
useEffect (() => { if ( pret ) dessineBarre (); }, [ pret , labels ]);
// Glisser sur la barre : sélectionner une plage (Labelling), sinon zoomer dans le temps
useEffect (() => { if ( pret ) Plotly . relayout ( barre . current , { dragmode : lecteur ? "zoom" : "select" , selections : [] }); }, [ pret , lecteur ]);
useEffect (() => { if ( pret ) dessinePlots ( true ). then ( dessineBarre ); }, [ sombre ]);
useEffect (() => { if ( pret ) dessinePlots ( true ); }, [ montres ]);
useEffect (() => { if ( pret ) liste (). forEach ( g => Plotly . relayout ( g , { shapes : zones () })); }, [ pret , labels , choix , ouverte ]);
useEffect (() => {
if ( ! pret || ! barre . current . _fullLayout ) return ;
const k = contour ( tries . current );
Plotly . restyle ( barre . current , { "marker.line.color" : [ k . color ], "marker.line.width" : [ k . width ] });
}, [ ouverte ]);
// Lues à chaque chargement et à chaque changement de source : la page montre toujours le fichier ; les détecteurs tournent
// sur la plage la première fois (une minute ou plus), le serveur garde leur résultat
useEffect (() => {
let vivant = true ;
setLecture ( true );
const url = source === "detecteurs" ? `/api/detecteurs? ${ new URLSearchParams ({ station , du , au , cibles } )}`
: `/api/etiquettes? ${ new URLSearchParams ({ station , dossier } )}` ;
appel ( url ). then ( l => {
if ( ! vivant ) return ; // une autre source a été choisie entre-temps
setLecture ( false ); setToutes ( l || []);
});
return () => { vivant = false ; };
}, [ source , cibles , rev ]);
// Un plot de plus : le premier que la page ne montre pas encore, déplacement vertical d'abord
function ajouterPlot () {
const pris = vues . map ( v => v . m ), id = prochain . current ++ ;
const m = [ indice ( "Relative Corrected Vertical Shift" , 0 ), ... PLOTS . keys ()]. find ( i => ! pris . includes ( i )) ?? 0 ;
setVues ([... vues , { id , m }]);
}
function enleverPlot ( id ) {
Plotly . purge ( figs . current [ id ]);
delete figs . current [ id ]; delete dessines . current [ id ];
setVues ( vues . filter ( v => v . id !== id ));
}
const modifiee = () => ouverte && edit && ( edit . texte . trim () !== ouverte . description || edit . categorie !== ( ouverte . categorie || "" )
|| edit . debut + "Z" !== ouverte . debut || edit . fin + "Z" !== ouverte . fin );
// l : l'étiquette à afficher, null pour fermer -> false si Marc garde ses changements non enregistrés
function ouvrir ( l ) {
if ( modifiee () && ! confirm ( "Abandonner les changements de cette étiquette ?" )) return false ;
setOuverte ( l ); setNote ( "" );
if ( l ) caler ( l . debut ); // un nouvel objet à chaque clic : recliquer le même événement y ramène les images
setEdit ( l && ! lecteur ? { debut : l . debut . slice ( 0 , 16 ), fin : l . fin . slice ( 0 , 16 ), categorie : l . categorie || "" , texte : l . description } : null );
return true ;
}
async function analyser () {
const r = await appel ( "/api/analyses" , "POST" , { station , debut : choix [ 0 ], fin : choix [ 1 ], indices });
if ( ! r ) return ; // rien n'est perdu : les indices et la plage restent dans la page
setAnalyse ( r . nom ); setIndices ( "" );
await Plotly . relayout ( barre . current , { selections : [] });
setChoix ( null );
}
async function enregistrer () {
const l = await appel ( "/api/etiquettes" , "PUT" , { station , dossier , avant : ouverte , debut : edit . debut + "Z" , fin : edit . fin + "Z" ,
categorie : edit . categorie , description : edit . texte . trim () });
if ( ! l ) return ; // rien n'est perdu : le texte et les bornes restent dans la fenêtre
setToutes ( ls => ls . map ( x => ( x === ouverte ? l : x )));
setOuverte ( l ); setNote ( "Enregistrée" );
}
async function supprimer () {
if ( ! confirm ( "Supprimer cette étiquette ?" )) return ;
if ( await appel ( "/api/etiquettes" , "DELETE" , { station , dossier , avant : ouverte }) === null ) return ;
setToutes ( ls => ls . filter ( x => x !== ouverte ));
setOuverte ( null ); setEdit ( null );
}
const options = PLOTS . map (( p , i ) => ({ value : String ( i ), label : p . titre }));
const peutEnregistrer = modifiee () && edit . texte . trim () && edit . debut && edit . fin && edit . debut < edit . fin ;
const bornes = ( champ , plus ) => lisible ( toutes . reduce (( m , l ) => ( plus ( l [ champ ], m ) ? l [ champ ] : m ), toutes [ 0 ][ champ ]));
return (
< Card shadow = "sm" withBorder >
< Stack gap = "sm" >
< div >
{ vues . map ( v => (
< div key = { v . id } className = "plot" >
< div ref = { el => { if ( el ) figs . current [ v . id ] = el ; }} />
< Group gap = { 4 } wrap = "nowrap" className = "plot-menu" >
< NativeSelect size = "xs" aria - label = "Plot" data = { options } value = { String ( v . m )} w = { 300 }
onChange = { e => { const m = + e . currentTarget . value ; setVues ( vues . map ( x => ( x . id === v . id ? { ... x , m } : x ))); }} />
{ vues . length > 1 && (
< Tooltip label = "Enlever ce plot" >
< ActionIcon variant = "subtle" color = "gray" aria - label = "Enlever ce plot" onClick = {() => enleverPlot ( v . id )}>< IconX size = { 16 } /></ ActionIcon >
</ Tooltip >
)}
</ Group >
</ div >
))}
{ ! pret && < Loader size = "sm" />}
</ div >
< Group justify = "space-between" gap = "sm" >
< Group gap = "sm" >
< SegmentedControl size = "xs" data = { SOURCES } value = { source } onChange = { v => { if ( ouvrir ( null )) { setSource ( v ); setChoix ( null ); } }} />
{ lecture && < Group gap = { 6 }>< Loader size = "xs" />< Text size = "xs" c = "dimmed" >{ detect ? "Les détecteurs tournent sur la plage…" : "Lecture…" }</ Text ></ Group >}
</ Group >
< Button size = "xs" variant = "light" leftSection = {< IconPlus size = { 14 } />} onClick = { ajouterPlot } disabled = { ! pret }> Ajouter un plot </ Button >
</ Group >
< div ref = { barre } />
{ pret && ! lecture && ! labels . length && ( // sinon une barre vide ne dit pas pourquoi
< Text size = "sm" c = "orange" >{ detect ? `Les détecteurs ne trouvent aucun événement sur cette plage ${ toutes . length ? " dans les familles cochées" : "" } .`
: toutes . length ? `Aucune étiquette dans les familles cochées sur cette plage : celles de ${ station } vont du ${ bornes ( "debut" , ( a , b ) => a < b ) } au ${ bornes ( "fin" , ( a , b ) => a > b ) } UTC.`
: ` ${ station } n'a aucune étiquette dans labeling/ ${ dossier } /.` }</ Text >
)}
< div >
{ ! ouverte && lecteur && < Text size = "sm" c = "dimmed" > Cliquer sur un événement pour l 'ouvrir.</Text>}
{ouverte && lecteur && (
<Card withBorder bg="var(--mantine-color-default-hover)">
<Stack gap={6}>
<Group gap="xs">
<Badge color={couleur(ouverte)} c="#1a1b1e">{ouverte.categorie}</Badge>
<Text size="sm" fw={500}>{ouverte.sorte}</Text>
{ouverte.ignore && <Badge variant="outline" color="gray">grisé au journal</Badge>}
</Group>
<Text size="sm" ff="monospace" fw={600}>{lisible(ouverte.debut)} → {lisible(ouverte.fin)} UTC</Text>
{ouverte.message ? <>
<Champ nom="Capteurs">{ouverte.capteurs.length ? <>
{ouverte.cibles.length > 0 && <div>Cibles ({ouverte.cibles.length}) : {ouverte.cibles.join(", ")}</div>}
{ouverte.references.length > 0 && <div>Références ({ouverte.references.length}) : {ouverte.references.join(", ")}</div>}
</> : "tous les capteurs"}</Champ>
<Champ nom="Message">{ouverte.message}</Champ>
<Champ nom="Action">{ouverte.action}</Champ>
</> : <Champ nom="Description">{ouverte.description}</Champ>}
<Group>
<Button size="xs" variant="default" onClick={() => ouvrir(null)}>Fermer</Button>
{ouverte.analyse && <Button size="xs" variant="light" onClick={() => setAnalyse(ouverte.analyse)}>Voir le rapport</Button>}
</Group>
</Stack>
</Card>
)}
{ouverte && edit && (
<Card withBorder bg="var(--mantine-color-default-hover)">
<Stack gap="xs">
<Group gap="sm" align="flex-end">
<TextInput label="Du (UTC)" type="datetime-local" step={60} value={edit.debut} onChange={e => setEdit({ ...edit, debut: e.currentTarget.value })} />
<TextInput label="Au (UTC)" type="datetime-local" step={60} value={edit.fin} onChange={e => setEdit({ ...edit, fin: e.currentTarget.value })} />
<NativeSelect label="Famille" data={CHOIX_FAMILLE} value={edit.categorie} onChange={e => setEdit({ ...edit, categorie: e.currentTarget.value })} />
</Group>
<Textarea autosize minRows={3} value={edit.texte} onChange={e => setEdit({ ...edit, texte: e.currentTarget.value })} />
<Group gap="sm">
<Button onClick={enregistrer} disabled={!peutEnregistrer}>Enregistrer</Button>
<Button variant="default" onClick={() => ouvrir(null)}>Fermer</Button>
{ouverte.analyse && <Button variant="light" onClick={() => setAnalyse(ouverte.analyse)}>Voir le rapport</Button>}
<Text size="sm" c="teal">{note}</Text>
<Button color="red" variant="light" ml="auto" onClick={supprimer}>Supprimer</Button>
</Group>
</Stack>
</Card>
)}
</div>
{!lecteur && <>
<Text size="sm">{choix ? `${lisible(choix[0])} → ${lisible(choix[1])} UTC` : "Glisser sur la barre des étiquettes pour sélectionner la plage à analyser."}</Text>
<Textarea autosize minRows={2} placeholder="Indices pour l' analyste ( facultatif ) : ce que tu as vu , ce qu 'il faut regarder"
value={indices} onChange={e => setIndices(e.currentTarget.value)} />
<Group><Button onClick={analyser} disabled={!(choix && choix[0] < choix[1])}>Analyser la plage</Button></Group>
</>}
{analyse && <Analyse key={analyse} nom={analyse} sombre={sombre} fini={() => setRev(r => r + 1)} fermer={() => setAnalyse(null)} />}
</Stack>
</Card>
);
}
// Le fil d' un agent ( analyste , optimisation ) : les messages de l 'utilisateur (« › ») en gras, le reste en petit, défilé jusqu' en bas
function Fil ({ lignes }) {
const fil = useRef ();
useEffect (() => { if ( fil . current ) fil . current . scrollTop = fil . current . scrollHeight ; }, [ lignes . length ]);
if ( ! lignes . length ) return null ;
return (
< div ref = { fil } style = {{ maxHeight : 260 , overflowY : "auto" }}>
{ lignes . map (( l , i ) => l . startsWith ( "› " )
? < Text key = { i } size = "sm" fw = { 500 } mt = { 6 }>{ l }</ Text >
: < Text key = { i } size = "xs" ff = "monospace" c = "dimmed" style = {{ whiteSpace : "pre-wrap" }}>{ l }</ Text >)}
</ div >
);
}
// Un markdown rendu par le serveur (rapport, bilan), à la hauteur de son contenu une fois ses images chargées
function Page ({ titre , src }) {
const cadre = useRef ();
const ajuste = () => { const b = cadre . current ? . contentDocument ? . body ; if ( b ) cadre . current . style . height = ` ${ b . scrollHeight + 20 } px` ; };
return < iframe ref = { cadre } title = { titre } sandbox = "allow-same-origin" onLoad = { ajuste } style = {{ border : 0 , width : "100%" , height : 400 }} src = { src } />;
}
const COULEUR_ETAT = { "en cours" : "blue" , fini : "teal" , erreur : "red" , interrompue : "orange" };
// Une analyse de l'onglet Analysis : son fil (relu toutes les 3 s tant qu'elle travaille), son rapport, et un message à
// l'analyste, qui reprend sa session ; à la fin de chaque tour, les étiquettes se relisent. Une analyse finie s'optimise
2026-11-13 11:51:16 +01:00
// (/detectors:detector-learner <analyse>, puis le tool-builder) : le fil de la séance, puis ses bilans sous le rapport
2026-11-13 11:32:43 +01:00
function Analyse ({ nom , sombre , fini , fermer }) {
const [ a , setA ] = useState ( null ), [ tour , setTour ] = useState ( 0 ), [ texte , setTexte ] = useState ( "" );
const boite = useRef (), charge = !! a ;
useEffect (() => { if ( charge ) boite . current ? . scrollIntoView ({ behavior : "smooth" , block : "start" }); }, [ nom , charge ]); // ouverte : on la voit
useEffect (() => {
let vivant = true , minuterie ;
const lire = () => appel ( `/api/analyses/ ${ nom } ` ). then ( r => {
if ( ! vivant || ! r ) return ;
setA ( r );
if ( r . etat === "en cours" || r . optimisation ? . etat === "en cours" ) minuterie = setTimeout ( lire , 3000 );
else if ( r . versees !== null ) fini ();
});
lire ();
return () => { vivant = false ; clearTimeout ( minuterie ); };
}, [ nom , tour ]);
async function envoyer () {
if ( await appel ( `/api/analyses/ ${ nom } /message` , "POST" , { texte }) == null ) return ; // le texte reste dans le champ
setTexte ( "" ); setTour ( t => t + 1 );
}
async function optimiser () {
if ( await appel ( `/api/analyses/ ${ nom } /optimiser` , "POST" ) != null ) setTour ( t => t + 1 );
}
if ( ! a ) return < Loader size = "sm" />;
const d = a . demande , o = a . optimisation , occupe = a . etat === "en cours" , optimise = o ? . etat === "en cours" ;
const au = new Date ( Date . parse ( d . fin . slice ( 0 , 10 )) + 864 e5 ). toISOString (). slice ( 0 , 10 );
return (
< Card withBorder ref = { boite }>
< Stack gap = "xs" >
< Group justify = "space-between" >
< Group gap = "xs" >
< Title order = { 5 }> Analyse { lisible ( d . debut )} → { lisible ( d . fin )} UTC </ Title >
< Badge color = { COULEUR_ETAT [ a . etat ] || "gray" }>{ a . etat }</ Badge >
{ occupe && < Loader size = "xs" />}
</ Group >
< Group gap = "xs" >
{ a . etat === "fini" && < Tooltip label = "Améliorer les détecteurs, puis les outils de lecture, depuis cette analyse (/detector-learner)" >
< Button size = "xs" variant = "light" onClick = { optimiser } disabled = { optimise }> Optimiser les détecteurs </ Button ></ Tooltip >}
< ActionIcon variant = "subtle" color = "gray" aria - label = "Fermer le rapport" onClick = { fermer }>< IconX size = { 16 } /></ ActionIcon >
</ Group >
</ Group >
{ d . indices && < Text size = "sm" c = "dimmed" > Indices : { d . indices }</ Text >}
{ a . etat === "interrompue" && < Text size = "sm" c = "orange" > Arrêtée avec le serveur avant la fin .{ a . dialogue
? " Sa session est gardée : écrire « continue » ci-dessous pour la reprendre là où elle en était." : "" }</ Text >}
{ a . versees !== null && a . etat === "fini" && < Text size = "sm" >{ a . versees } étiquette ( s ) de cette analyse dans labeling / auto / { d . station }. jsonl , à relire .</ Text >}
{ a . rapport && < Page titre = "Rapport" src = { `/api/analyses/ ${ nom } /rapport.html?sombre= ${ sombre } &v= ${ a . rapport } ` } />}
< Fil lignes = { a . lignes } />
{ a . dialogue && (
< Group align = "flex-end" gap = "sm" wrap = "nowrap" >
< Textarea autosize minRows = { 1 } style = {{ flex : 1 }} placeholder = "Une question, une correction pour l'analyste"
value = { texte } onChange = { e => setTexte ( e . currentTarget . value )} />
< Button onClick = { envoyer } disabled = { occupe || optimise || ! texte . trim ()}> Envoyer </ Button >
</ Group >
)}
{ o && (
< Stack gap = "xs" mt = "sm" >
< Group gap = "xs" >
< Title order = { 5 }> Optimisation </ Title >
< Badge color = { COULEUR_ETAT [ o . etat ] || "gray" }>{ o . etat }</ Badge >
{ optimise && < Loader size = "xs" />}
</ Group >
{ o . etat === "interrompue" && < Text size = "sm" c = "orange" > Arrêtée avec le serveur ; la relancer par le bouton .</ Text >}
< Fil lignes = { o . lignes } />
{ o . bilan && < Page titre = "Bilan" src = { `/api/analyses/ ${ nom } /bilan.html?sombre= ${ sombre } &v= ${ o . bilan } ` } />}
{ o . bilan && < Text size = "xs" c = "dimmed" ff = "monospace" > python3 detectors - view / compare . py data / { d . station } -- du { d . debut . slice ( 0 , 10 )} -- au { au }</ Text >}
</ Stack >
)}
< Text size = "xs" c = "dimmed" > labeling / auto / analyses / { nom } / </ Text >
</ Stack >
</ Card >
);
}