563 lines
36 KiB
React
563 lines
36 KiB
React
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
|
||
// (/detectors:detector-learner <analyse>, puis le tool-builder) : le fil de la séance, puis ses bilans sous le rapport
|
||
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)) + 864e5).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>
|
||
);
|
||
}
|