app/: the web app in its own folder, with the Images and Labeling pages (D-138)

- app/serveur/ (FastAPI) and app/web/ (React, Mantine) moved out of API/, which keeps
  only the agents; the Support page drives them
- Images page: view.py in React (slider, zoom, sensor names, displacement arrows on a range)
- Labeling page: labeling.py in React (two aligned plots, label bar, add, edit, delete);
  labels are written to labeling/{auto,manual}/ of the repo (AIMSIGHT_LABELS)
- shared station and date selector kept in the address; buttons from a support session
- app/serveur/station.py: the data of both pages, copied computations listed in app/README.md
- app/serveur/check.py: server and station checks (labels in a temporary folder)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
maximeandClaude Opus 5.5 committed 2026-11-05 14:25:57 +01:00
1 parent 374d91eb15
commit bd93e708d2
26 files changed
+1263 -206

No files matched your search

+14
View File
@@ -0,0 +1,14 @@
<!doctype html>
<html lang="fr">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Support AIMsight</title>
<link rel="preconnect" href="https://fonts.googleapis.com">
<link href="https://fonts.googleapis.com/css2?family=Roboto:wght@300;400;500;700&display=swap" rel="stylesheet">
</head>
<body>
<div id="racine"></div>
<script type="module" src="/src/main.jsx"></script>
</body>
</html>
+1192
View File
File diff suppressed because it is too large. Load diff
+22
View File
@@ -0,0 +1,22 @@
{
"name": "support-aimsight",
"private": true,
"type": "module",
"scripts": {
"dev": "vite",
"build": "vite build"
},
"dependencies": {
"@mantine/core": "^9.7.5",
"@mantine/hooks": "^9.7.5",
"@mantine/notifications": "^9.7.5",
"@tabler/icons-react": "^3.50.0",
"plotly.js-dist-min": "^4.2.0",
"react": "^19.3.1",
"react-dom": "^19.3.1"
},
"devDependencies": {
"@vitejs/plugin-react": "^6.2.1",
"vite": "^8.3.6"
}
}
+117
View File
@@ -0,0 +1,117 @@
import { lazy, Suspense, useEffect, useState } from "react";
import {
ActionIcon, AppShell, Burger, Group, Loader, NavLink, ScrollArea, Text, Tooltip, useComputedColorScheme, useMantineColorScheme,
} from "@mantine/core";
import { useDisclosure } from "@mantine/hooks";
import { IconChartLine, IconMessages, IconMoon, IconPhoto, IconSun } from "@tabler/icons-react";
import Support, { AGENTS, Etat, NOMS } from "./pages/Support.jsx";
import Images from "./pages/Images.jsx";
const Etiquetage = lazy(() => import("./pages/Etiquetage.jsx")); // Plotly, chargé seulement ici
const PAGES = [["support", "Support", IconMessages], ["images", "Images", IconPhoto], ["etiquetage", "Étiquetage", IconChartLine]];
// L'adresse : #/<page>?station=…&du=…&au=… ; recharger garde la page et la sélection, Retour marche
function lireAdresse() {
const [page, q = ""] = location.hash.replace(/^#\/?/, "").split("?");
const p = new URLSearchParams(q);
return { page: PAGES.some(([n]) => n === page) ? page : "support",
selection: { station: p.get("station") || "", du: p.get("du") || "", au: p.get("au") || "" } };
}
function adresse(page, s) {
const q = new URLSearchParams(Object.entries(s).filter(([, v]) => v)).toString();
return `#/${page}${q ? "?" + q : ""}`;
}
function Entete({ dossier, mobile, bureau, basculer }) {
const { setColorScheme } = useMantineColorScheme(), schema = useComputedColorScheme("light");
return (
<AppShell.Header className="entete">
<Group h="100%" px="md" justify="space-between" wrap="nowrap">
<Group gap="sm" wrap="nowrap">
<Burger opened={mobile} onClick={basculer.mobile} hiddenFrom="sm" size="sm" color="white" aria-label="Menu" />
<Burger opened={bureau} onClick={basculer.bureau} visibleFrom="sm" size="sm" color="white" aria-label="Barre latérale" />
<Text fw={700} size="lg">AIMsight</Text>
<Text size="sm" opacity={0.6}>Support</Text>
</Group>
<Group gap="sm" wrap="nowrap">
{dossier && <Text ff="monospace" size="sm" opacity={0.75} visibleFrom="sm">{dossier}</Text>}
<Tooltip label={schema === "dark" ? "Mode clair" : "Mode sombre"}>
<ActionIcon variant="subtle" color="white" size="lg" aria-label="Changer de thème"
onClick={() => setColorScheme(schema === "dark" ? "light" : "dark")}>
{schema === "dark" ? <IconSun size={20} /> : <IconMoon size={20} />}
</ActionIcon>
</Tooltip>
</Group>
</Group>
</AppShell.Header>
);
}
function Barre({ page, selection, etat, fermer }) {
const c = etat.cout, dollars = v => `${(v ?? 0).toFixed(2)} $`;
const titre = t => <Text size="xs" fw={700} tt="uppercase" c="dimmed" px="sm" pt="lg" pb="xs">{t}</Text>;
return (
<AppShell.Navbar p="xs">
<ScrollArea type="scroll">
{titre("Pages")}
{PAGES.map(([n, nom, Icone]) => (
<NavLink key={n} label={nom} leftSection={<Icone size={18} />} active={page === n} onClick={fermer}
href={adresse(n, n === "support" ? {} : selection)} />
))}
{page === "support" && <>
{titre("Séance")}
{AGENTS.map(a => <NavLink key={a} label={NOMS[a]} rightSection={<Etat occupe={etat.occupe[a]} />} />)}
{titre("Coût")}
{AGENTS.map(a => <NavLink key={a} label={NOMS[a]} rightSection={<Text size="sm">{dollars(c?.[a])}</Text>} />)}
<NavLink label={<b>Total</b>} rightSection={<Text size="sm" fw={700}>{dollars(c?.total)}</Text>} />
</>}
</ScrollArea>
</AppShell.Navbar>
);
}
export default function App() {
const [{ page, selection }, setLieu] = useState(lireAdresse);
const [etat, setEtat] = useState({ occupe: { support: false, analyste: false } });
const [evenements, setEvenements] = useState([]);
const [mobile, { toggle: basculerMobile, close: fermerMobile }] = useDisclosure(false);
const [bureau, { toggle: basculerBureau }] = useDisclosure(true);
// La dernière station et plage vues, pour revenir à Images ou Étiquetage depuis Support
const [derniere, setDerniere] = useState(selection);
useEffect(() => {
const suivre = () => setLieu(lireAdresse());
addEventListener("hashchange", suivre);
return () => removeEventListener("hashchange", suivre);
}, []);
useEffect(() => { if (page !== "support") setDerniere(selection); }, [page, selection.station, selection.du, selection.au]);
// La séance tourne même quand on regarde une autre page : le flux reste ouvert
useEffect(() => {
const flux = new EventSource("/api/flux");
flux.onmessage = ev => {
const r = JSON.parse(ev.data), nouveaux = r.evenements.filter(e => e.type !== "cout");
// depuis = 0 : tout l'historique de la séance (nouvelle séance, ou reconnexion) ; sinon la suite
setEvenements(evs => (r.depuis === 0 ? nouveaux : [...evs, ...nouveaux]));
setEtat(r);
};
return () => flux.close();
}, []);
const choisir = s => { location.hash = adresse(page, s); };
return (
<AppShell header={{ height: 64 }} padding="lg"
navbar={{ width: 260, breakpoint: "sm", collapsed: { mobile: !mobile, desktop: !bureau } }}>
<Entete dossier={etat.dossier} mobile={mobile} bureau={bureau} basculer={{ mobile: basculerMobile, bureau: basculerBureau }} />
<Barre page={page} selection={page === "support" ? derniere : selection} etat={etat} fermer={fermerMobile} />
<AppShell.Main bg="var(--mantine-color-default-hover)">
{page === "support" && <Support etat={etat} evenements={evenements} />}
{page === "images" && <Images selection={selection} choisir={choisir} />}
{page === "etiquetage" && (
<Suspense fallback={<Loader m="xl" />}><Etiquetage selection={selection} choisir={choisir} /></Suspense>
)}
</AppShell.Main>
</AppShell>
);
}
+52
View File
@@ -0,0 +1,52 @@
import { useEffect, useState } from "react";
import { Button, Card, Group, Select, Text, TextInput } from "@mantine/core";
import { notifications } from "@mantine/notifications";
// Une requête à l'API ; un refus du serveur s'affiche en notification -> le JSON rendu, ou null
export async function appel(chemin, methode = "GET", corps) {
try {
const r = await fetch(chemin, corps === undefined ? { method: methode }
: { method: methode, headers: { "Content-Type": "application/json" }, body: JSON.stringify(corps) });
const json = await r.json().catch(() => ({ erreur: r.statusText }));
if (r.ok) return json;
notifications.show({ color: "red", title: "Refusé", message: json.erreur || r.statusText });
} catch (e) {
notifications.show({ color: "red", title: "Serveur injoignable", message: e.message });
}
return null;
}
export const poster = async (chemin, corps) => (await appel(chemin, "POST", corps)) !== null;
export function Carte({ surtitre, titre, action, children, ...reste }) {
return (
<Card shadow="sm" padding={0} withBorder {...reste}>
<Group px="lg" py="md" justify="space-between" wrap="nowrap" style={{ borderBottom: "1px solid var(--mantine-color-default-border)" }}>
<div>
<Text size="xs" fw={700} tt="uppercase" c="dimmed">{surtitre}</Text>
<Text fw={500}>{titre}</Text>
</div>
{action}
</Group>
{children}
</Card>
);
}
// La station et la plage (UTC, Au exclue ; vides : toute la période), partagées par Images et Étiquetage via l'adresse
export function Selecteur({ selection, choisir }) {
const [stations, setStations] = useState([]), [s, setS] = useState(selection);
useEffect(() => { appel("/api/stations").then(l => l && setStations(l)); }, []);
useEffect(() => setS(selection), [selection.station, selection.du, selection.au]);
return (
<Card shadow="sm" withBorder>
<Group align="flex-end" gap="md">
<Select label="Station" placeholder="Choisir" data={stations} value={s.station || null} searchable w={200}
onChange={v => setS({ ...s, station: v || "" })} />
<TextInput label="Du (UTC)" type="date" value={s.du} onChange={e => setS({ ...s, du: e.currentTarget.value })} />
<TextInput label="Au (exclu)" type="date" value={s.au} onChange={e => setS({ ...s, au: e.currentTarget.value })} />
<Button onClick={() => choisir(s)} disabled={!s.station}>Charger</Button>
</Group>
</Card>
);
}
+24
View File
@@ -0,0 +1,24 @@
import { createRoot } from "react-dom/client";
import { MantineProvider, createTheme } from "@mantine/core";
import { Notifications } from "@mantine/notifications";
import "@mantine/core/styles.css";
import "@mantine/notifications/styles.css";
import "./style.css";
import App from "./App.jsx";
// Bleu primaire #5383ff (shade 5), la palette retenue pour la page
const theme = createTheme({
primaryColor: "aimsight",
primaryShade: 5,
colors: { aimsight: ["#eef3ff", "#dce5ff", "#b8c9ff", "#91abff", "#6f92ff", "#5383ff", "#4574f5", "#3863dc", "#2c55c4", "#1d45ab"] },
fontFamily: "Roboto, Helvetica, Arial, sans-serif",
headings: { fontFamily: "Roboto, Helvetica, Arial, sans-serif" },
defaultRadius: "md",
});
createRoot(document.getElementById("racine")).render(
<MantineProvider theme={theme} defaultColorScheme="auto">
<Notifications position="top-right" />
<App />
</MantineProvider>,
);
+212
View File
@@ -0,0 +1,212 @@
import { useEffect, useRef, useState } from "react";
import { Button, Card, Group, Loader, NativeSelect, Stack, Text, Textarea, TextInput, Title } from "@mantine/core";
import { appel, Selecteur } from "../commun.jsx";
// L'étiquetage (labeling/labeling.py) : deux plots alignés, la barre des étiquettes ; y glisser sélectionne une plage,
// un clic ouvre une étiquette. Les étiquettes sont dans labeling/<auto|manual>/<STATION>.jsonl, relues à chaque chargement.
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) }))];
const GRIS = "#6b6b66", BLEU = "#2a78d6", VOIE = 22; // VOIE : px par rangée d'étiquettes
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 });
export default function Etiquetage({ selection, choisir }) {
const [donnees, setDonnees] = useState(null), [charge, setCharge] = useState(false);
const { station, du, au } = selection;
useEffect(() => {
setDonnees(null);
if (!station) return;
setCharge(true);
appel(`/api/courbes?${new URLSearchParams({ station, du, au })}`).then(d => { setDonnees(d); setCharge(false); });
}, [station, du, au]);
return (
<Stack gap="lg">
<div>
<Title order={2}>Étiquetage</Title>
<Text c="dimmed">Glisser sur la barre des étiquettes sélectionne une plage ; un clic sur une étiquette l'ouvre.</Text>
</div>
<Selecteur selection={selection} choisir={choisir} />
{charge && <Loader />}
{donnees && <Etiqueteur key={`${station}${du}${au}`} station={station} d={donnees} />}
</Stack>
);
}
function Etiqueteur({ station, d }) {
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 [source, setSource] = useState("auto"), [labels, setLabels] = useState([]), [choix, setChoix] = useState(null);
const [m1, setM1] = useState(indice("Relative Corrected Horizontal Shift", 0));
const [m2, setM2] = useState(indice("Relative Corrected Vertical Shift", PLOTS.length > 1 ? 1 : 0));
const [ajout, setAjout] = useState({ categorie: "", texte: "" });
const [ouverte, setOuverte] = useState(null), [edit, setEdit] = useState(null), [note, setNote] = useState("");
const fig = useRef(), fig2 = useRef(), barre = useRef(), tries = useRef([]), courant = useRef({});
courant.current = { labels, choix, ouvrir }; // ce que lisent les événements Plotly, installés une fois
useEffect(() => { import("plotly.js-dist-min").then(m => setPlotly(() => m.default)); }, []);
function zones() {
const { labels, choix } = courant.current;
const z = (a, b, c, o) => ({ type: "rect", xref: "x", yref: "paper", x0: lisible(a), x1: lisible(b), y0: 0, y1: 1,
fillcolor: c, opacity: o, line: { width: 0 }, layer: "below" });
return labels.map(l => z(l.debut, l.fin, couleur(l), 0.12)).concat(choix ? [z(choix[0], choix[1], BLEU, 0.25)] : []);
}
// Les deux plots et la barre partagent plage et marges : celui qui change impose les siens aux deux autres (rien si déjà
// alignés, sinon le relayout appelle aligne en boucle).
function aligne(src = fig.current) {
const g1 = fig.current, g2 = fig2.current, b = barre.current;
if (!b?._fullLayout || !g2?._fullLayout || !g1?._fullLayout) return;
const rg = src._fullLayout.xaxis.range.slice();
const l = Math.max(g1._fullLayout._size.l, g2._fullLayout._size.l), r = Math.max(g1._fullLayout._size.r, g2._fullLayout._size.r);
return Promise.all([g1, g2, b].map(g => {
const m = g._fullLayout.margin, x = g._fullLayout.xaxis.range;
if (m.l === l && m.r === r && Date.parse(x[0]) === Date.parse(rg[0]) && Date.parse(x[1]) === Date.parse(rg[1])) return;
return Plotly.relayout(g, { "xaxis.range": rg, "margin.l": l, "margin.r": r });
}));
}
function dessineFig(g, m) {
const p = PLOTS[m];
// uirevision : le zoom et les capteurs cachés restent d'un plot à l'autre ; l'ordonnée, propre à chaque plot, se recale
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,
hovertemplate: `${t.name} : %{y}<br>%{x|%Y-%m-%d %H:%M} UTC<extra></extra>` })),
{ height: 420, 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(g));
}
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), f = fig.current._fullLayout, g = fig2.current._fullLayout;
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.85, marker: { color: t.map(couleur), line: { color: "white", width: 2 } },
text: t.map(l => (l.categorie ? `[${NOM_FAMILLE(l.categorie)}] ` : "") + l.description),
textposition: "inside", insidetextanchor: "start", textangle: 0, unselected: { marker: { opacity: 1 } }, // sinon une sélection les pâlit
hoverinfo: "none" }], // pas de bulle (le clic lit l'étiquette) ; 'none' garde les événements
{ height: 40 + VOIE * n, dragmode: "select", selectdirection: "h", hovermode: "closest", plot_bgcolor: "#f2f2ef", showlegend: false,
margin: { ...marge(), l: Math.max(f._size.l, g._size.l), r: Math.max(f._size.r, g._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 });
}
// Le premier dessin, puis les événements, une fois
useEffect(() => {
if (!Plotly) return;
Promise.all([dessineFig(fig.current, m1), dessineFig(fig2.current, m2)]).then(dessineBarre).then(() => aligne()).then(() => {
fig.current.on("plotly_relayout", () => aligne(fig.current));
fig2.current.on("plotly_relayout", () => aligne(fig2.current));
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_click", ev => courant.current.ouvrir(tries.current[ev.points[0].pointIndex]));
setPret(true);
});
return () => [fig, fig2, barre].forEach(g => g.current && Plotly.purge(g.current));
}, [Plotly]);
useEffect(() => { if (pret) dessineFig(fig.current, m1); }, [m1]);
useEffect(() => { if (pret) dessineFig(fig2.current, m2); }, [m2]);
useEffect(() => { if (pret) dessineBarre(); }, [pret, labels]);
useEffect(() => { if (pret) [fig, fig2].forEach(g => Plotly.relayout(g.current, { shapes: zones() })); }, [pret, labels, choix]);
// Lues à chaque chargement et à chaque changement de dossier : la page montre toujours le fichier
useEffect(() => {
appel(`/api/etiquettes?${new URLSearchParams({ station, dossier: source })}`)
.then(l => setLabels(l ? l.filter(x => x.debut < B && x.fin > A) : []));
}, [source]);
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("");
setEdit(l && { debut: l.debut.slice(0, 16), fin: l.fin.slice(0, 16), categorie: l.categorie || "", texte: l.description });
return true;
}
async function ajouter() {
const l = await appel("/api/etiquettes", "POST", { station, dossier: source, debut: choix[0], fin: choix[1],
categorie: ajout.categorie, description: ajout.texte.trim() });
if (!l) return; // rien n'est perdu : le texte et la plage restent dans la page
setLabels(ls => [...ls, l]);
setAjout({ categorie: "", texte: "" });
await Plotly.relayout(barre.current, { selections: [] });
setChoix(null);
}
async function enregistrer() {
const l = await appel("/api/etiquettes", "PUT", { station, dossier: source, 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
setLabels(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: source, avant: ouverte }) === null) return;
setLabels(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;
return (
<Card shadow="sm" withBorder>
<Stack gap="sm">
<Group gap="md" align="flex-end">
<NativeSelect label="Étiquettes" data={[{ value: "auto", label: "auto (l'étiqueteur)" }, { value: "manual", label: "manual (les tiennes)" }]}
value={source} onChange={e => { const v = e.currentTarget.value; if (ouvrir(null)) setSource(v); }} />
{!pret && <Loader size="sm" />}
</Group>
<NativeSelect label="Plot" data={options} value={String(m1)} onChange={e => setM1(+e.currentTarget.value)} maw={420} />
<div ref={fig} />
<NativeSelect label="Plot" data={options} value={String(m2)} onChange={e => setM2(+e.currentTarget.value)} maw={420} />
<div ref={fig2} />
<div ref={barre} />
{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>
<Text size="sm" c="teal">{note}</Text>
<Button color="red" variant="light" ml="auto" onClick={supprimer}>Supprimer</Button>
</Group>
</Stack>
</Card>
)}
<Text size="sm">{choix ? `${lisible(choix[0])} → ${lisible(choix[1])} UTC` : "Glisser sur la barre ci-dessus pour sélectionner une plage."}</Text>
<NativeSelect label="Famille" data={CHOIX_FAMILLE} value={ajout.categorie} onChange={e => setAjout({ ...ajout, categorie: e.currentTarget.value })} maw={300} />
<Textarea autosize minRows={3} placeholder="Que voit-on sur cette plage ?" value={ajout.texte}
onChange={e => setAjout({ ...ajout, texte: e.currentTarget.value })} />
<Group><Button onClick={ajouter} disabled={!(choix && choix[0] < choix[1] && ajout.texte.trim())}>Ajouter</Button></Group>
</Stack>
</Card>
);
}
+231
View File
@@ -0,0 +1,231 @@
import { useEffect, useRef, useState } from "react";
import { ActionIcon, Card, Group, Input, Loader, Stack, Text, Title } from "@mantine/core";
import { IconChevronLeft, IconChevronRight } from "@tabler/icons-react";
import { appel, Selecteur } from "../commun.jsx";
// Les images de la caméra (view/view.py) : glisseur, ◀ ▶, flèches du clavier ; molette pour zoomer autour du pointeur,
// glisser pour se déplacer, double clic pour l'image entière ; une plage sur la barre : la flèche de déplacement de chaque capteur.
export default function Images({ selection, choisir }) {
const [donnees, setDonnees] = useState(null), [charge, setCharge] = useState(false);
const { station, du, au } = selection;
useEffect(() => {
setDonnees(null);
if (!station) return;
setCharge(true);
appel(`/api/images?${new URLSearchParams({ station, du, au })}`).then(d => { setDonnees(d); setCharge(false); });
}, [station, du, au]);
return (
<Stack gap="lg">
<div>
<Title order={2}>Images</Title>
<Text c="dimmed">Les images de la caméra ; une plage sur la barre montre le déplacement de chaque capteur.</Text>
</div>
<Selecteur selection={selection} choisir={choisir} />
{charge && <Loader />}
{donnees && <Visionneuse key={`${station}${du}${au}`} station={station} d={donnees} />}
</Stack>
);
}
function Visionneuse({ station, d }) {
const r = { cadre: useRef(), couche: useRef(), img: useRef(), marques: useRef(), vecteurs: useRef(), glis: useRef(),
heure: useRef(), noms: useRef(), barre: useRef(), bande: useRef(), plage: useRef(), echelle: useRef(),
prec: useRef(), suiv: useRef() };
const XY = d.positions, refs = new Set(d.references), avecPositions = Object.keys(XY).length > 0;
useEffect(() => installer(r, station, d), [d]);
return (
<Card shadow="sm" withBorder padding={0}>
<div className="cadre" ref={r.cadre}>
<div className="couche" ref={r.couche}>
<img ref={r.img} alt="" draggable="false" />
<svg className="marques" ref={r.marques} style={{ display: "none" }}>
{Object.entries(XY).map(([s, [x, y]]) => (
<g key={s} className={refs.has(s) ? "ref" : "cible"}>
<circle cx={x} cy={y} r=".7em" /><text x={x} y={y} dy="-1em">{s}</text>
</g>
))}
</svg>
<svg className="vecteurs" ref={r.vecteurs} style={{ display: "none" }}>
<defs><marker id="pointe" viewBox="0 0 10 14" refX="9" refY="7" markerWidth="5" markerHeight="7" orient="auto">
<path d="M0,0 L10,7 L0,14 z" fill="#2ecc40" /></marker></defs>
</svg>
</div>
</div>
<Stack gap={6} p="md">
<Group gap="sm" wrap="nowrap">
<ActionIcon ref={r.prec} variant="light" aria-label="Image précédente"><IconChevronLeft size={18} /></ActionIcon>
<input ref={r.glis} className="glisseur" type="range" min="0" max={d.images.length - 1} defaultValue="0" />
<ActionIcon ref={r.suiv} variant="light" aria-label="Image suivante"><IconChevronRight size={18} /></ActionIcon>
</Group>
<div className="barre-plages" ref={r.barre}><div className="bande" ref={r.bande} style={{ display: "none" }} /></div>
<Group gap="lg" justify="space-between">
<Text ref={r.heure} ff="monospace" size="sm" />
<Group gap="md">
<label className="case"><input type="checkbox" ref={r.noms} disabled={!avecPositions} /> Noms</label>
{avecPositions
? <span className="legende"><span className="cible">○ Cible</span> <span className="ref">◌ Référence</span></span>
: <Text size="sm" c="dimmed">x, y ne sont pas des positions dans l'image sur cette station</Text>}
</Group>
</Group>
<Group gap="lg" justify="space-between">
<Text ref={r.plage} size="sm" />
<Group gap="xs" wrap="nowrap">
<Text size="sm">Flèches ×</Text>
<Input ref={r.echelle} type="number" min={1} defaultValue={100} w={90} size="xs" />
</Group>
</Group>
<Text size="xs" c="dimmed">← → image · molette : zoom · glisser : se déplacer · double clic : image entière · flèche :
corr_x, corr_y à la fin moins au début (px), dans les axes de l'image</Text>
</Stack>
</Card>
);
}
// Le code de view/view.py (PAGE_JS), sur les éléments de la page -> la fonction qui défait ce qu'il a installé
function installer(r, station, d) {
const IM = d.images.map(i => ({ t: i.t, src: `/api/image/${encodeURIComponent(station)}/${encodeURIComponent(i.nom)}` }));
const C = d.corr, XY = d.positions;
const cadre = r.cadre.current, couche = r.couche.current, img = r.img.current, glis = r.glis.current, heure = r.heure.current;
const marques = r.marques.current, vecteurs = r.vecteurs.current, labels = r.noms.current;
const barre = r.barre.current, bande = r.bande.current, plage = r.plage.current, echelle = r.echelle.current;
let V = 0, Z = { k: 1, x: 0, y: 0 }, P = null;
function zoom() {
Z.x = Math.min(0, Math.max(1 - Z.k, Z.x)); // l'image couvre toujours le cadre : on ne la perd pas en la glissant
Z.y = Math.min(0, Math.max(1 - Z.k, Z.y));
couche.style.transform = `translate(${Z.x * 100}%, ${Z.y * 100}%) scale(${Z.k})`;
// Les noms restent à 12 px à l'écran : les tailles des marques sont en em, et 1 px du svg vaut 1 px de l'image.
const W = img.naturalWidth, H = img.naturalHeight;
if (W) marques.style.fontSize = vecteurs.style.fontSize = `${12 / (Z.k * Math.min(cadre.clientWidth / W, cadre.clientHeight / H))}px`;
cale();
}
const affiche = () => { marques.style.display = labels.checked && img.naturalWidth ? "" : "none"; };
labels.onchange = affiche;
function montre(i) {
V = Math.max(0, Math.min(IM.length - 1, i));
glis.value = V;
img.src = IM[V].src;
for (const n of [V - 1, V + 1]) if (IM[n]) new Image().src = IM[n].src; // les voisines, en cache
}
// L'heure change avec l'image, pas avant : l'image d'avant reste affichée tant que la nouvelle se charge.
img.onload = () => {
heure.textContent = `${IM[V].t} UTC (${V + 1}/${IM.length})`;
marques.setAttribute("viewBox", `0 0 ${img.naturalWidth} ${img.naturalHeight}`); // cadré comme l'image, object-fit: contain
vecteurs.setAttribute("viewBox", marques.getAttribute("viewBox"));
fleches(); zoom(); affiche();
};
img.onerror = () => {
img.removeAttribute("src");
heure.textContent = `${IM[V].t} UTC (${V + 1}/${IM.length}) : image illisible`;
affiche();
};
glis.oninput = () => montre(+glis.value);
r.prec.current.onclick = () => montre(V - 1);
r.suiv.current.onclick = () => montre(V + 1);
const clavier = e => {
if (e.target.matches("textarea, select, input:not([type=range])") || !["ArrowLeft", "ArrowRight"].includes(e.key)) return;
e.preventDefault(); // sinon le glisseur, s'il a le focus, avance une seconde fois
montre(V + (e.key === "ArrowLeft" ? -1 : 1));
};
document.addEventListener("keydown", clavier);
const molette = ev => { // zoom autour du pointeur
ev.preventDefault();
const b = cadre.getBoundingClientRect(), u = (ev.clientX - b.left) / b.width, v = (ev.clientY - b.top) / b.height;
const k = Math.min(40, Math.max(1, Z.k * Math.exp(-ev.deltaY / 500)));
Z = { k, x: u - k * (u - Z.x) / Z.k, y: v - k * (v - Z.y) / Z.k };
zoom();
};
cadre.addEventListener("wheel", molette, { passive: false });
cadre.onpointerdown = ev => { // déplacement à la souris
cadre.setPointerCapture(ev.pointerId);
const b = cadre.getBoundingClientRect(), de = { ...Z, cx: ev.clientX, cy: ev.clientY };
cadre.onpointermove = e => { Z.x = de.x + (e.clientX - de.cx) / b.width; Z.y = de.y + (e.clientY - de.cy) / b.height; zoom(); };
cadre.onpointerup = () => { cadre.onpointermove = null; };
};
cadre.ondblclick = () => { Z = { k: 1, x: 0, y: 0 }; zoom(); };
// La plage : glisser sur la barre, alignée sur le glisseur ; les flèches vont de la position du capteur à position + k × déplacement.
function cale() {
const g = glis.getBoundingClientRect(), b = barre.getBoundingClientRect();
barre.style.marginLeft = `${(parseFloat(barre.style.marginLeft) || 0) + g.left - b.left}px`; barre.style.width = `${g.width}px`;
}
const indice = ev => { const b = barre.getBoundingClientRect(); return Math.round(Math.max(0, Math.min(1, (ev.clientX - b.left) / b.width)) * (IM.length - 1)); };
function bandeau() {
const n = Math.max(1, IM.length - 1), [i, j] = P ? [Math.min(...P), Math.max(...P)] : [0, 0];
bande.style.left = `${i / n * 100}%`; bande.style.width = `${(j - i) / n * 100}%`; bande.style.display = P ? "" : "none";
}
function deplacements() {
if (!P || P[0] === P[1]) return {};
const [i, j] = [Math.min(...P), Math.max(...P)], dep = {};
for (const [s, c] of Object.entries(C)) if (c[i] && c[j]) dep[s] = [c[j][0] - c[i][0], c[j][1] - c[i][1]];
return dep;
}
function fleches() {
const dep = deplacements(), W = img.naturalWidth, k = +echelle.value;
vecteurs.style.display = Object.keys(dep).length && W ? "" : "none";
vecteurs.querySelectorAll("line").forEach(l => l.remove());
for (const [s, [dx, dy]] of Object.entries(dep)) {
const [x, y] = XY[s], l = document.createElementNS("http://www.w3.org/2000/svg", "line");
Object.entries({ x1: x, y1: y, x2: x + k * dx, y2: y + k * dy }).forEach(([a, v]) => l.setAttribute(a, v));
const titre = document.createElementNS("http://www.w3.org/2000/svg", "title");
titre.textContent = `${s} : corr_x ${dx.toFixed(3)} px, corr_y ${dy.toFixed(3)} px`;
l.appendChild(titre);
vecteurs.appendChild(l);
}
if (P && P[0] !== P[1]) {
const [i, j] = [Math.min(...P), Math.max(...P)], manque = Object.keys(C).filter(s => !(s in dep));
plage.textContent = `${IM[i].t} → ${IM[j].t} UTC` + (manque.length ? ` · pas de mesure valide à une borne : ${manque.join(", ")}` : "");
} else plage.textContent = Object.keys(C).length ? "Glisser sur la barre pour choisir une plage" : "Pas de flèches : x, y ne sont pas des positions dans l'image";
}
// Ce que saisit le pointeur sur une plage placée : 0 son début, 1 sa fin (à 6 px près), 2 la bande entière, null rien.
function prise(ev) {
if (!P) return null;
const x = ev.clientX - barre.getBoundingClientRect().left, px = i => i / Math.max(1, IM.length - 1) * barre.clientWidth;
return Math.abs(x - px(P[0])) < 6 ? 0 : Math.abs(x - px(P[1])) < 6 ? 1 : x > px(P[0]) && x < px(P[1]) ? 2 : null;
}
barre.onpointermove = e => {
if (!barre.hasPointerCapture(e.pointerId)) barre.style.cursor = ["ew-resize", "ew-resize", "grab"][prise(e)] || "crosshair";
};
barre.onpointerdown = ev => {
barre.setPointerCapture(ev.pointerId);
const g = prise(ev), i0 = indice(ev), de = P && [...P];
if (g === null) P = [i0, i0];
bandeau(); montre(i0);
const survol = barre.onpointermove;
barre.onpointermove = e => {
const i = indice(e);
if (g === 2) { // la bande glisse sans sortir de la barre
const dd = Math.max(-de[0], Math.min(IM.length - 1 - de[1], i - i0));
P = [de[0] + dd, de[1] + dd];
} else P[g === null ? 1 : g] = i;
bandeau(); fleches(); montre(i);
};
barre.onpointerup = () => {
barre.onpointermove = survol;
P = [Math.min(...P), Math.max(...P)];
if (P[0] === P[1]) P = null;
else if (g === null) { // nouvelle plage, facteur proposé : la plus grande flèche fait 8 % de la largeur de l'image
const m = Math.max(...Object.values(deplacements()).map(([a, b]) => Math.hypot(a, b)), 0);
if (m && img.naturalWidth) echelle.value = Math.max(1, Math.round(0.08 * img.naturalWidth / m));
}
bandeau(); fleches();
};
};
echelle.oninput = fleches;
addEventListener("resize", zoom);
const observateur = new ResizeObserver(zoom); // la barre latérale qui se replie change la largeur sans resize
observateur.observe(cadre);
montre(0); cale(); fleches();
return () => {
document.removeEventListener("keydown", clavier);
removeEventListener("resize", zoom);
cadre.removeEventListener("wheel", molette);
observateur.disconnect();
};
}
+141
View File
@@ -0,0 +1,141 @@
import { useEffect, useRef, useState } from "react";
import { ActionIcon, Badge, Button, Grid, Group, Image, Paper, ScrollArea, SimpleGrid, Stack, Text, Textarea, Title, Tooltip } from "@mantine/core";
import { notifications } from "@mantine/notifications";
import { IconChartLine, IconDownload, IconPhoto, IconSend } from "@tabler/icons-react";
import { Carte, poster } from "../commun.jsx";
export const AGENTS = ["support", "analyste"];
export const NOMS = { support: "Support", analyste: "Analyste" };
// Un événement d'un agent → ce que montre son fil
function message(e) {
if (e.type === "outil") return { genre: "outil", texte: "→ " + e.texte };
if (e.type === "erreur") return { genre: "erreur", texte: e.texte };
if (e.type === "entree") {
if (e.source === "marc") return { genre: "marc", qui: "Toi", texte: e.texte.replace(/^<mail>\n?|\n?<\/mail>[\s\S]*$/g, "") };
return { genre: "relai", qui: "Demande du support", texte: e.texte };
}
return { genre: e.agent, qui: NOMS[e.agent], texte: e.texte };
}
export function Etat({ occupe }) {
return <Badge variant="light" color={occupe ? "orange" : "teal"}>{occupe ? "occupé…" : "prêt"}</Badge>;
}
function Saisie({ occupe }) {
const [mail, setMail] = useState(""), [contexte, setContexte] = useState(""), [images, setImages] = useState([]);
function coller(ev) {
for (const item of ev.clipboardData.items) {
if (!item.type.startsWith("image/")) continue;
const lecteur = new FileReader();
lecteur.onload = () => setImages(im => [...im, { type: item.type, url: lecteur.result, base64: lecteur.result.split(",")[1] }]);
lecteur.readAsDataURL(item.getAsFile());
}
}
async function analyser() {
if (!mail.trim()) return notifications.show({ color: "orange", message: "Colle d'abord le mail du client." });
const envoi = images.map(({ type, base64 }, i) => ({ nom: `capture-${i + 1}`, type, base64 }));
if (await poster("/api/analyser", { mail, contexte, images: envoi })) setImages([]); // pas de captures d'un client à l'autre
}
return (
<Carte surtitre="Demande" titre="Le mail du client" action={<Button onClick={analyser} disabled={occupe}>Analyser</Button>}>
<Grid p="lg" gutter="lg">
<Grid.Col span={{ base: 12, md: 8 }}>
<Textarea label="Mail du client" description="Le texte ; colle les captures ici, elles s'ajoutent en vignettes"
placeholder="Bonjour, …" autosize minRows={6} maxRows={16} value={mail}
onChange={e => setMail(e.currentTarget.value)} onPaste={coller} />
{images.length > 0 && (
<Group gap="xs" mt="xs">{images.map((im, i) => <Image key={i} src={im.url} h={52} w="auto" radius="sm" alt={`Capture ${i + 1}`} />)}</Group>
)}
</Grid.Col>
<Grid.Col span={{ base: 12, md: 4 }}>
<Textarea label="Ton contexte" description="Station, plage, ce que tu sais du cas" autosize minRows={6} maxRows={16}
value={contexte} onChange={e => setContexte(e.currentTarget.value)} />
</Grid.Col>
</Grid>
</Carte>
);
}
function Fil({ agent, evenements, occupe, seance }) {
const [texte, setTexte] = useState(""), vue = useRef(null);
useEffect(() => { vue.current?.scrollTo({ top: vue.current.scrollHeight, behavior: "smooth" }); }, [evenements.length]);
async function envoyer() {
if (texte.trim() && await poster("/api/message", { agent, texte })) setTexte("");
}
return (
<Carte surtitre={agent === "support" ? "Pilote la séance" : "Diagnostic"} titre={NOMS[agent]} action={<Etat occupe={occupe} />}
h="62vh" style={{ display: "flex", flexDirection: "column" }}>
<ScrollArea flex={1} viewportRef={vue} type="scroll">
<Stack gap="xs" p="lg">
{evenements.map((e, i) => {
const m = message(e);
if (m.genre === "outil") return <Text key={i} size="xs" c="dimmed" ff="monospace" style={{ overflowWrap: "anywhere" }}>{m.texte}</Text>;
if (m.genre === "erreur") return <Paper key={i} p="xs" bg="var(--mantine-color-red-light)" c="red"><Text size="sm">Erreur : {m.texte}</Text></Paper>;
return (
<Paper key={i} px="md" py="xs" className={`message ${m.genre}`}>
<Text size="xs" fw={700} tt="uppercase" c="dimmed">{m.qui}</Text>
<Text size="sm">{m.texte}</Text>
</Paper>
);
})}
</Stack>
</ScrollArea>
<Group gap="sm" px="lg" py="md" wrap="nowrap" align="flex-end" style={{ borderTop: "1px solid var(--mantine-color-default-border)" }}>
<Textarea flex={1} autosize minRows={1} maxRows={6} placeholder={agent === "support" ? "Au support…" : "À l'analyste…"}
value={texte} onChange={e => setTexte(e.currentTarget.value)} disabled={occupe} />
<Tooltip label="Envoyer">
<ActionIcon size="input-sm" onClick={envoyer} disabled={occupe || !seance} aria-label="Envoyer"><IconSend size={18} /></ActionIcon>
</Tooltip>
</Group>
</Carte>
);
}
function Rapport({ version, dossier }) {
const src = `/api/pdf?v=${version}`;
return (
<Carte surtitre="Rapport" titre={version ? `Version ${version.replace(".pdf", "").slice(1)}` : "Pas encore de PDF"}
action={version && <Button component="a" href={src} download={`${dossier}_${version}`} variant="light"
leftSection={<IconDownload size={16} />}>Télécharger</Button>}>
{version ? <iframe key={version} className="rapport" src={src} title="Rapport" />
: <Text c="dimmed" ta="center" p="xl">Le PDF s'affiche ici dès que le support l'a compilé.</Text>}
</Carte>
);
}
// Les 7 derniers jours, sur la station de la séance : la plage du client se règle ensuite dans la page
function lien(page, station) {
const du = new Date(Date.now() - 7 * 864e5).toISOString().slice(0, 10);
return `#/${page}?station=${encodeURIComponent(station)}&du=${du}`;
}
export default function Support({ etat, evenements }) {
return (
<Stack gap="lg">
<Group justify="space-between" align="flex-end">
<div>
<Title order={2}>Support</Title>
<Text c="dimmed">Colle le mail du client et ton contexte, puis Analyser ; parle au support ou à l'analyste dans leur fil.</Text>
</div>
{etat.station && (
<Group gap="xs">
<Button component="a" href={lien("images", etat.station)} variant="light" leftSection={<IconPhoto size={16} />}>Images de {etat.station}</Button>
<Button component="a" href={lien("etiquetage", etat.station)} variant="light" leftSection={<IconChartLine size={16} />}>Étiquetage</Button>
</Group>
)}
</Group>
<Saisie occupe={etat.occupe.support || etat.occupe.analyste} />
<SimpleGrid cols={{ base: 1, md: 2 }} spacing="lg">
{AGENTS.map(a => <Fil key={a} agent={a} occupe={etat.occupe[a]} seance={etat.dossier}
evenements={evenements.filter(e => e.agent === a)} />)}
</SimpleGrid>
<Rapport version={etat.version} dossier={etat.dossier} />
</Stack>
);
}
+29
View File
@@ -0,0 +1,29 @@
/* Le reste du visuel vient de Mantine (thème dans main.jsx) */
.entete { background: #3d4977; color: #fff; border-bottom: 0; }
.message { white-space: pre-wrap; overflow-wrap: anywhere; }
.message.support, .message.relai { background: var(--mantine-color-aimsight-light); }
.message.analyste { background: var(--mantine-color-teal-light); }
.message.marc { background: var(--mantine-color-yellow-light); align-self: flex-end; max-width: 85%; }
.message.relai { border-left: 3px solid var(--mantine-color-aimsight-filled); }
.rapport { width: 100%; height: 78vh; border: 0; display: block; background: #fff; }
/* La page Images (view/view.py) */
.cadre { position: relative; height: calc(100vh - 420px); min-height: 300px; background: #000; overflow: hidden; cursor: grab;
touch-action: none; border-radius: var(--mantine-radius-md) var(--mantine-radius-md) 0 0; }
.cadre:active { cursor: grabbing; }
.couche { position: absolute; inset: 0; transform-origin: 0 0; }
.couche > * { position: absolute; inset: 0; width: 100%; height: 100%; }
.couche img { object-fit: contain; user-select: none; }
.marques { overflow: visible; pointer-events: none; font-family: sans-serif; }
.marques circle { fill: none; stroke: currentColor; stroke-width: .12em; }
.marques .ref circle { stroke-dasharray: .3em .2em; }
.marques text { fill: currentColor; text-anchor: middle; paint-order: stroke; stroke: rgba(0, 0, 0, .85); stroke-width: .25em; stroke-linejoin: round; }
.cible { color: #ffd400; } .ref { color: #3cc8ff; }
.legende { background: #000; padding: 2px 8px; border-radius: 3px; white-space: nowrap; font-size: var(--mantine-font-size-sm); }
.vecteurs { overflow: visible; pointer-events: none; }
.vecteurs line { stroke: #2ecc40; stroke-width: .18em; marker-end: url(#pointe); }
.glisseur { flex: 1; min-width: 0; accent-color: var(--mantine-primary-color-filled); }
.barre-plages { position: relative; height: 22px; background: var(--mantine-color-default-hover); border: 1px solid var(--mantine-color-default-border);
border-radius: 3px; cursor: crosshair; touch-action: none; }
.bande { position: absolute; top: 0; bottom: 0; background: #e0730080; border-left: 2px solid #e07300; border-right: 2px solid #e07300; }
.case { display: flex; gap: 6px; align-items: center; font-size: var(--mantine-font-size-sm); }
+8
View File
@@ -0,0 +1,8 @@
import { defineConfig } from "vite";
import react from "@vitejs/plugin-react";
// npm run dev : la page sur http://localhost:5173, l'API demandée au serveur Python (port 8770)
export default defineConfig({
plugins: [react()],
server: { proxy: { "/api": "http://127.0.0.1:8770" } },
});