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

+3
View File
@@ -0,0 +1,3 @@
web/node_modules/
web/dist/
__pycache__/
+46
View File
@@ -0,0 +1,46 @@
# La web app AIMsight
L'outil interne du support et du diagnostic manuel (D-137, D-138) : trois pages dans la barre latérale.
- **Support** : coller le mail du client et son contexte, Analyser ; les fils du support et de l'analyste (les agents de `API/`, `API/README.md`), le PDF par version. Dès que la séance a sa station, deux boutons ouvrent Images et Étiquetage sur elle.
- **Images** : les images de la caméra, comme `view/view.py` : glisseur, ◀ ▶ et flèches du clavier ; molette pour zoomer, glisser pour se déplacer, double clic pour l'image entière ; case Noms (cibles en jaune, références en bleu) ; une plage sur la barre sous le glisseur dessine la flèche de déplacement de chaque capteur (corr_x, corr_y, facteur modifiable).
- **Étiquetage** : comme `labeling/labeling.py` : deux plots alignés (déplacements, caméra, qualité, métriques système), la barre des étiquettes (`auto` ou `manual`) ; y glisser sélectionne une plage, puis famille, texte, Ajouter ; un clic ouvre une étiquette : bornes, famille, texte, Enregistrer, Supprimer. Écrit dans `labeling/<auto|manual>/<STATION>.jsonl`.
Images et Étiquetage partagent la station et la plage (UTC, Au exclue), dans l'adresse : `#/images?station=NIEDERHORN&du=2026-09-25&au=2026-10-08`.
## Lancer
Une fois, et après chaque changement de la page : construire le front (Node 22).
```bash
cd app/web && npm install && npm run build
```
Puis le serveur, avec l'environnement Python des agents (`API/.venv`, plus `app/requirements.txt`) :
```bash
API/.venv/bin/python app/serveur/serveur.py
```
La page s'ouvre sur `http://127.0.0.1:8770`. Réglages par variables : `AIMSIGHT_DATA` (données, défaut `data/`), `AIMSIGHT_LABELS` (étiquettes, défaut `labeling/`), `AIMSIGHT_CASES` (séances, défaut `API/cases/`), `AIMSIGHT_PORT` (8770). Pour travailler sur la page : `npm run dev` dans `app/web/` (http://localhost:5173), le serveur Python lancé à côté.
## Les dossiers
- `serveur/serveur.py` : FastAPI ; sert la page construite et l'API sous `/api` (séance, flux des agents, PDF, stations, images, courbes, étiquettes) ; ne répond qu'aux pages du poste (Host local, JSON déclaré).
- `serveur/station.py` : les données des pages Images et Étiquetage ; lecture seule sur `data/`, écrit seulement dans `labeling/{auto,manual}/`.
- `serveur/check.py` : vérifications, sans appel à l'API : `API/.venv/bin/python app/serveur/check.py`.
- `web/` : React (Vite) et Mantine ; `src/App.jsx` (en-tête, barre latérale, pages, adresse), `src/pages/` (une page par fichier), `src/commun.jsx` (requêtes, cartes, sélecteur), `src/main.jsx` (thème). Plotly ne se charge qu'avec Étiquetage. `dist/` et `node_modules/` hors de git.
- `docs/` : la conception des pages Images et Étiquetage.
## Copies
Le calcul des pages Images et Étiquetage reprend les outils du projet ; ce qui en est copié dans `serveur/station.py` vieillit avec eux.
| Source | Copie | Commit | Date | Adaptation |
|---|---|---|---|---|
| `view/view.py` : `page()` (images, corr à l'heure de chaque image) | `images()` | 6e9f69a | 2026-11-05 | rend du JSON, pas une page |
| `labeling/labeling.py` : `metriques()`, `plots()`, `ajouter()`, `modifier()`, `supprimer()`, `remplace()` | `metriques()`, `courbes()`, et les fonctions des étiquettes | 6e9f69a | 2026-11-05 | rend du JSON ; métriques lues sans `common.stations` |
| `detectors-view/detecteurs.py` : `positions()`, `references()`, `COULEURS`, `POSE`, `MARGE_PX` | idem | 6e9f69a | 2026-11-05 | aucune |
| `labeling/ids.py` : `attribuer()`, `en_tete()` | `attribuer()` | 6e9f69a | 2026-11-05 | sans `retires` (inutile à l'ajout) |
La lecture des données est celle des agents : `API/tools/agent-tools/donnees.py`.
@@ -0,0 +1,76 @@
# Les pages Images et Étiquetage dans la web app support
Conception validée par Marc le 2026-11-05 ; l'app a ensuite quitté `API/` pour `app/` (D-138). Complète D-133 et D-137.
## L'intention
Marc fait son diagnostic à la main avec deux outils du projet : `view/view.py` (les images de la caméra) et `labeling/labeling.py` (les courbes et les étiquettes). Il veut que **tout soit centralisé dans l'app** : la page Support, plus ces deux pages, refaites en React dans la même app (Mantine, FastAPI), avec les mêmes gestes. Pas de nouvelle fonction : les deux outils, à l'identique, dans l'app.
## Les buts et les limites
- **Buts** : trois pages dans la barre latérale (Support, Images, Étiquetage) ; un seul sélecteur de station et de dates pour Images et Étiquetage ; depuis une séance de support, un accès direct à Images et à Étiquetage sur la station du cas.
- **Hors du périmètre** : rien de neuf dans les deux pages (pas de nouveau plot, pas de nouvelle fonction d'image) ; pas de PostgreSQL ni d'authentification ; les anciens outils restent dans le dépôt (le projet Claude Code s'en sert : `run.sh`, `/review-labels`), Marc cesse simplement de les utiliser.
- **À éviter** : deux vérités pour les étiquettes. Les étiquettes restent dans `labeling/` du dépôt, là où les détecteurs et les agents les lisent ; l'app y écrit, rien n'est copié.
## Ce que Marc a décidé
- Les deux pages refaites en React dans l'app, pas intégrées telles quelles (2026-11-05).
- L'app écrit les étiquettes dans `labeling/` du projet (proposé, accepté avec React).
## La navigation
- **Barre latérale** : trois liens, Support, Images, Étiquetage, avec une icône chacun. La section « Séance » (état des agents, coût) ne s'affiche que sur la page Support.
- **L'adresse suit la page** : `#/support`, `#/images?station=LENZSPITZE&du=2026-10-26&au=2026-10-28`, `#/etiquetage?…`. Recharger garde la page, la station et les dates ; le bouton Retour du navigateur marche. Pas de bibliothèque de routage : un `hashchange` suffit pour trois pages.
- **Le sélecteur** (Images, Étiquetage) : en haut de la page, une ligne : Station (menu des dossiers de `data/`), Du, Au (dates UTC, Au exclue, vides : toute la période), Charger. Il est partagé : passer d'Images à Étiquetage garde la station et les dates, et recharge la page sur elles.
- **Depuis le support** : dès que la séance a sa station (`poser_station`), deux boutons en tête des fils, « Images » et « Étiquetage », ouvrent la page sur cette station et les 7 derniers jours de ses données (la séance ne garde pas la plage du client ; Marc la règle ensuite).
## La page Images (comme `view.py`)
- L'image dans un cadre noir : molette pour zoomer autour du pointeur (×1 à ×40), glisser pour se déplacer, double clic pour l'image entière ; le zoom reste d'une image à l'autre.
- Glisseur, ◀ ▶ et les flèches du clavier ; l'heure UTC et le rang (« 12/288 ») ; les deux images voisines préchargées ; l'heure change quand la nouvelle image est chargée ; une image illisible le dit.
- Case **Noms** : chaque capteur à sa position médiane sur la plage, cible en jaune, référence en bleu et cercle pointillé (référence : `reproj_err` rempli) ; les noms restent à 12 px à l'écran quel que soit le zoom ; case grisée, avec la phrase « x, y ne sont pas des positions dans l'image », sur les stations où x, y ne sont pas des pixels (NADELHORN par endroits).
- **La barre des plages** sous le glisseur : y glisser choisit une plage d'images ; une plage placée se modifie par ses bords ou se déplace en entier ; un clic hors d'elle l'efface. Chaque capteur porte alors sa flèche verte : corr_x, corr_y à la fin moins au début (mesure valide la plus proche de l'heure de l'image, à 30 min près), amplifiée par un facteur modifiable, proposé pour que la plus grande flèche fasse 8 % de la largeur de l'image ; au survol d'une flèche, ses valeurs ; la plage en texte, et les capteurs sans mesure valide à une borne.
## La page Étiquetage (comme `labeling.py`)
- **Étiquettes** : un menu, `auto` (celles de l'étiqueteur, par défaut) ou `manual` (celles de Marc).
- **Deux plots** l'un sous l'autre, chacun avec son menu, dans l'ordre de `labeling.py` : error_value, x, y, relative_x, relative_y, corr_x, corr_y, reproj_err, mouvement de la caméra, métriques de qualité, puis les métriques système numériques (sans les identifiants). À l'ouverture : corr_x en haut, corr_y en bas. Le zoom de l'un s'applique à l'autre et à la barre (mêmes abscisses, mêmes marges) ; les capteurs cachés et le zoom restent d'un plot à l'autre ; au survol : capteur, valeur, heure UTC. Les zones étiquetées grisées sur les deux plots, la sélection en bleu.
- **La barre des étiquettes** sous les plots : une barre par étiquette, couleur de sa famille, son texte dedans, celles qui se chevauchent sur des rangées différentes ; y glisser sélectionne une plage ; un clic sur une étiquette l'ouvre.
- **Ajouter** : la plage sélectionnée (en texte), la famille (menu, facultative : les six familles et « None »), le texte ; Ajouter écrit aussitôt une ligne dans `labeling/<auto|manual>/<STATION>.jsonl`. Dans `auto`, l'étiquette reçoit son id stable (D-131).
- **Modifier** : l'étiquette ouverte montre ses bornes (UTC), sa famille, son texte ; Enregistrer (actif seulement si quelque chose a changé ; retire le champ `revue`, D-103), Fermer (demande confirmation si un changement n'est pas enregistré), Supprimer (avec confirmation). L'étiquette est retrouvée dans le fichier par son contenu, pas par son rang ; si le fichier a changé entre-temps, l'app le dit et ne touche à rien. Écriture par fichier temporaire puis remplacement.
- Les étiquettes sont relues à chaque chargement : la page montre toujours le fichier.
## Le serveur
Nouvelles routes de `app/serveur/serveur.py` (le calcul dans `app/serveur/station.py`), toutes en lecture seule sur `data/` :
| Route | Rend |
|---|---|
| `GET /api/stations` | les dossiers de `data/` |
| `GET /api/images?station&du&au` | les images de la plage (heure, adresse), les positions médianes, les références, corr_x/corr_y de chaque capteur à l'heure de chaque image |
| `GET /api/image/<station>/<fichier>` | une image de `data/<station>/images/` |
| `GET /api/courbes?station&du&au` | les plots de la page Étiquetage (heures une fois par série, valeurs, titres, couleurs) et les bornes de la plage |
| `GET /api/etiquettes?station&dossier` | les étiquettes du fichier |
| `POST`, `PUT`, `DELETE /api/etiquettes` | ajouter, modifier, retirer |
- Station : seulement un dossier de `data/` ; `dossier` : `auto` ou `manual` ; image : seulement un fichier de `images/` (chemins contenus).
- La garde actuelle (Host local, JSON déclaré) s'étend à PUT et DELETE.
- Les calculs viennent des outils existants, **copiés** dans `app/serveur/station.py`, leur provenance dans `app/README.md` : `positions`, `references`, les couleurs des capteurs et de la pose (`detectors-view/detecteurs.py`), `attribuer` (`labeling/ids.py`) ; la lecture des données par `API/tools/agent-tools/donnees.py` (déjà copié : `charger`, `charger_camera`, `charger_metriques`, `heure_image`).
- Réglage : `AIMSIGHT_LABELS` (défaut : `labeling/` du dépôt), comme `AIMSIGHT_DATA`. `API/` ne lit toujours que `data/` ; c'est l'app qui lit `data/` et écrit dans `labeling/{auto,manual}/` (D-138).
## Le front
- Une page par fichier dans `app/web/src/pages/` (`Support.jsx`, `Images.jsx`, `Etiquetage.jsx`), le reste dans `App.jsx`.
- Les courbes : Plotly (`plotly.js-dist-min`, la bibliothèque des outils actuels), chargé seulement à l'ouverture d'Étiquetage, pour que Support reste léger.
- Textes de l'interface en français (outil interne).
- Les heures partout en UTC.
## Vérifier
- `check.py` : les routes `stations`, `images`, `courbes` sur une station de `data/` ; ajouter, modifier, retirer une étiquette dans un dossier `labeling/` temporaire (avec l'id en `auto`) ; une station ou un chemin hors de `data/` refusés.
- Par captures (Chrome headless) : Images et Étiquetage sur NIEDERHORN du 2026-09-25 au 2026-10-08 (le jeu de test des détecteurs) et sur LENZSPITZE et NADELHORN, sur ordinateur et téléphone.
- Marc compare avec ses outils actuels sur une plage qu'il connaît.
## Laissé au constructeur
La forme exacte des réponses JSON, le découpage en composants, la façon d'aligner les plots (celle de `labeling.py` marche : relayout des trois figures sur la plage et les marges de celle qui change).
+2
View File
@@ -0,0 +1,2 @@
fastapi
uvicorn
+116
View File
@@ -0,0 +1,116 @@
"""Vérifications de la web app, sans appel à l'API (faux client) : API/.venv/bin/python app/serveur/check.py [nom]"""
import json
import shutil
import socket
import sys
import threading
import time
import urllib.request
from pathlib import Path
from urllib.error import HTTPError
ICI = Path(__file__).resolve().parent
sys.path[:0] = [str(ICI), str(ICI.parents[1] / "API" / "support")]
import uvicorn # noqa: E402
import seance # noqa: E402
import serveur # noqa: E402
import station # noqa: E402
from check import Bloc, FauxClient, reponse, seance_temporaire # noqa: E402 (les faux de API/support/check.py)
def check_serveur():
# le vrai serveur sur un port libre, une séance au faux client : la garde, l'analyse, le flux, le PDF absent
with socket.socket() as so:
so.bind(("127.0.0.1", 0))
port = so.getsockname()[1]
cases = seance.CASES
seance.CASES, serveur.CLIENT = seance_temporaire(), FauxClient(reponse([Bloc(type="text", text="Bonjour Marc")], "end_turn"))
srv = uvicorn.Server(uvicorn.Config(serveur.app, host="127.0.0.1", port=port, log_level="error"))
threading.Thread(target=srv.run, daemon=True).start()
while not srv.started:
time.sleep(0.05)
base = f"http://127.0.0.1:{port}"
def appel(chemin, corps=None, entetes=None):
r = urllib.request.Request(base + chemin, json.dumps(corps).encode() if corps is not None else None,
{"Content-Type": "application/json", **(entetes or {})})
try:
with urllib.request.urlopen(r) as rep:
return rep.status
except HTTPError as e:
return e.code
try:
assert appel("/api/pdf", entetes={"Host": "evil.example:80"}) == 403
assert appel("/api/analyser", {"mail": "x"}, {"Content-Type": "text/plain"}) == 403
assert appel("/api/analyser", {"mail": " "}) == 400
assert appel("/api/analyser", {"mail": "Bonjour", "contexte": "", "images": []}) == 200
with urllib.request.urlopen(base + "/api/flux", timeout=10) as f:
premier, textes = None, []
for ligne in f:
if ligne.startswith(b"data: "):
m = json.loads(ligne[6:])
premier = premier or m
textes += [e["texte"] for e in m["evenements"]]
if "Bonjour Marc" in textes and not m["occupe"]["support"]:
break
assert premier["depuis"] == 0 and premier["id"], premier
assert appel("/api/pdf") == 404
(serveur.etat["seance"].dossier / "v1.pdf").write_bytes(b"%PDF-1.4")
with urllib.request.urlopen(base + "/api/pdf") as rep:
assert rep.read() == b"%PDF-1.4" and rep.headers["Content-Disposition"].startswith("inline"), rep.headers
finally:
srv.should_exit = True
shutil.rmtree(seance.CASES)
seance.CASES = cases
def leve(f, *a):
try:
f(*a)
except station.Refus as e:
return str(e)
raise AssertionError(f"{f.__name__}{a} n'a pas refusé")
def check_station():
# les données des pages Images et Étiquetage, sur les vraies données ; les étiquettes dans un dossier temporaire
assert "NIEDERHORN" in station.stations()
im = station.images("NIEDERHORN", "2026-09-25", "2026-09-26")
assert im["images"] and im["positions"] and set(im["corr"]) == set(im["positions"]), list(im)
assert all(len(c) == len(im["images"]) for c in im["corr"].values())
assert station.image("NIEDERHORN", im["images"][0]["nom"]).is_file()
leve(station.image, "NIEDERHORN", "../../../.env")
leve(station.images, "../API", "", "")
assert station.images("LENZSPITZE", "2026-10-26", "2026-10-27")["images"]
c = station.courbes("LENZSPITZE", "2026-10-26", "2026-10-27")
titres = [p["titre"] for p in c["plots"]]
assert "Relative Corrected Vertical Shift" in titres and any(t.startswith("System: ") for t in titres), titres
assert not any("SIM_CCID" in t or t.startswith("System: ip") for t in titres)
assert all(len(c["T"][tr["t"]]) == len(tr["y"]) for p in c["plots"] for tr in p["traces"])
avant, station.ETIQUETTES = station.ETIQUETTES, seance_temporaire()
try:
e = station.ajouter({"station": "NIEDERHORN", "dossier": "auto", "debut": "2026-09-25T01:00Z",
"fin": "2026-09-25T02:00Z", "categorie": "Visibility", "description": "brouillard"})
assert e["id"] == "NIEDERHORN-1" and next(iter(e)) == "id", e
e2 = station.modifier({"station": "NIEDERHORN", "dossier": "auto", "avant": e,
"debut": e["debut"], "fin": e["fin"], "categorie": "", "description": "pluie"})
assert e2 == {"id": "NIEDERHORN-1", "debut": e["debut"], "fin": e["fin"], "description": "pluie"}, e2
assert station.lire("NIEDERHORN", "auto") == [e2]
assert "plus dans le fichier" in leve(station.supprimer, {"station": "NIEDERHORN", "dossier": "auto", "avant": e})
station.supprimer({"station": "NIEDERHORN", "dossier": "auto", "avant": e2})
assert station.lire("NIEDERHORN", "auto") == []
leve(station.ajouter, {"station": "NIEDERHORN", "dossier": "../x", "debut": "a", "fin": "b", "description": "x"})
leve(station.ajouter, {"station": "NIEDERHORN", "debut": "2026-09-25T02:00Z", "fin": "2026-09-25T01:00Z", "description": "x"})
finally:
shutil.rmtree(station.ETIQUETTES)
station.ETIQUETTES = avant
CHECKS = [check_serveur, check_station]
if __name__ == "__main__":
nom = sys.argv[1] if len(sys.argv) > 1 else None
for f in CHECKS:
if nom in (None, f.__name__):
f()
print("ok", f.__name__)
+211
View File
@@ -0,0 +1,211 @@
"""La web app : API/.venv/bin/python app/serveur/serveur.py → http://127.0.0.1:8770
Le serveur FastAPI sert la page React construite (app/web/dist, `npm run build` dans app/web) et l'API sous /api.
La page Support pilote les agents de API/ (API/support/seance.py).
Une séance à la fois, en mémoire ; /api/flux pousse à la page les événements des agents (server-sent events).
Les pages Images et Étiquetage lisent data/ et les étiquettes de labeling/ (station.py).
Réglages : AIMSIGHT_DATA (données), AIMSIGHT_LABELS (étiquettes), AIMSIGHT_CASES (séances), AIMSIGHT_PORT (port, 8770).
"""
import asyncio
import base64
import json
import os
import platform
import subprocess
import sys
import threading
import webbrowser
from pathlib import Path
import uvicorn
from fastapi import FastAPI, Query, Request
from fastapi.responses import FileResponse, JSONResponse, StreamingResponse
import station
from fastapi.staticfiles import StaticFiles
APP = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(APP.parent / "API" / "support")) # les agents du support
from seance import Seance, donnees_par_defaut # noqa: E402
PORT = int(os.environ.get("AIMSIGHT_PORT", 8770))
HOTES = {"127.0.0.1", "localhost"} # contre le DNS rebinding : un autre site ne lit ni mails ni PDF
PAGE = APP / "web" / "dist"
CLIENT = None # le client Anthropic des séances ; None : le vrai (check.py y met un faux)
verrou = threading.Lock()
etat = {"seance": None, "evenements": []}
app = FastAPI(docs_url=None, redoc_url=None, openapi_url=None)
def journal(e: dict) -> None:
with verrou:
etat["evenements"].append(e)
def en_fond(f, *args):
def lancer():
try:
f(*args)
except Exception as e: # noqa: BLE001 — une erreur de la séance s'affiche dans la page, le serveur continue
journal({"agent": "support", "type": "erreur", "texte": f"{type(e).__name__}: {e}"})
threading.Thread(target=lancer, daemon=True).start()
def erreur(code: int, texte: str) -> JSONResponse:
return JSONResponse({"erreur": texte}, code)
@app.middleware("http")
async def garde(request: Request, suite):
"""Seule la page elle-même parle au serveur : bon Host ; en POST, un JSON déclaré (une page d'un autre site ne
peut l'envoyer sans requête préalable, à laquelle le serveur ne répond pas)."""
hote = request.headers.get("host", "").rsplit(":", 1)[0]
if hote not in HOTES or (request.method in ("POST", "PUT", "DELETE")
and not request.headers.get("content-type", "").startswith("application/json")):
return erreur(403, "requête refusée")
return await suite(request)
def instantane(depuis: int) -> dict:
s = etat["seance"]
with verrou:
evs, n = etat["evenements"][depuis:], len(etat["evenements"])
v = s.derniere_version() if s else None
return {"evenements": evs, "n": n, "cout": s.cout() if s else None, "version": v.name if v else None,
"dossier": s.dossier.name if s else None, "id": s.id if s else None,
"station": s.station if s else None,
"occupe": {a: bool(s and s.occupe(a)) for a in ("support", "analyste")}}
@app.get("/api/flux")
async def flux(request: Request):
"""Un message à chaque changement : les nouveaux événements et l'état de la séance. Une nouvelle séance repart de
zéro (son id change) : la page vide alors ses fils."""
async def messages():
n, id_vu, dernier, calme = 0, None, None, 0
while not await request.is_disconnected():
s = etat["seance"]
if s and s.id != id_vu:
n, id_vu = 0, s.id
m = instantane(n)
reste = {k: v for k, v in m.items() if k != "evenements"}
if m["evenements"] or reste != dernier or dernier is None:
m["depuis"] = n # 0 : tout l'historique de la séance, la page remplace ses fils au lieu d'ajouter
n, dernier, calme = m["n"], reste, 0
yield f"data: {json.dumps(m, ensure_ascii=False)}\n\n"
elif (calme := calme + 1) >= 60: # ~15 s sans rien : un commentaire garde la connexion ouverte
calme = 0
yield ": calme\n\n"
await asyncio.sleep(0.25)
return StreamingResponse(messages(), media_type="text/event-stream", headers={"Cache-Control": "no-cache"})
@app.get("/api/pdf")
def pdf():
s = etat["seance"]
v = s.derniere_version() if s else None
if not v:
return erreur(404, "pas encore de PDF")
return FileResponse(v, media_type="application/pdf", filename=f"{s.dossier.name}_{v.name}",
content_disposition_type="inline")
@app.post("/api/analyser")
def analyser(corps: dict):
s = etat["seance"]
if s and (s.occupe("support") or s.occupe("analyste")):
return erreur(409, "une séance travaille encore")
if not corps.get("mail", "").strip():
return erreur(400, "le mail est vide")
images = [(i["type"], base64.b64decode(i["base64"])) for i in corps.get("images", [])]
s = Seance(corps["mail"], images, corps.get("contexte", ""), donnees_par_defaut(), journal, client=CLIENT)
with verrou:
etat["seance"], etat["evenements"] = s, []
en_fond(s.demarrer)
return {"dossier": s.dossier.name}
@app.post("/api/message")
def message(corps: dict):
s, agent, texte = etat["seance"], corps.get("agent"), corps.get("texte", "").strip()
if not s:
return erreur(400, "pas de séance : coller un mail et Analyser")
if agent not in ("support", "analyste") or not texte:
return erreur(400, "agent ou texte manquant")
if s.occupe(agent):
return erreur(409, f"{agent} occupé")
en_fond(s.parler, agent, texte)
return {}
# --- les pages Images et Étiquetage (station.py)
@app.exception_handler(station.Refus)
def refus(_, e):
return erreur(400, str(e))
@app.get("/api/stations")
def stations():
return station.stations()
@app.get("/api/images")
def images(station_: str = Query(alias="station"), du: str = "", au: str = ""):
return station.images(station_, du, au)
@app.get("/api/image/{station_}/{nom}")
def image(station_: str, nom: str):
return FileResponse(station.image(station_, nom), headers={"Cache-Control": "max-age=86400"})
@app.get("/api/courbes")
def courbes(station_: str = Query(alias="station"), du: str = "", au: str = ""):
return station.courbes(station_, du, au)
@app.get("/api/etiquettes")
def etiquettes(station_: str = Query(alias="station"), dossier: str = "manual"):
try:
return station.lire(station_, dossier)
except json.JSONDecodeError as e: # une ligne abîmée à la main : le dire, sans toucher au fichier
return erreur(500, f"labeling/{dossier}/{station_}.jsonl illisible : {e}")
@app.post("/api/etiquettes")
def ajouter(corps: dict):
return station.ajouter(corps)
@app.put("/api/etiquettes")
def modifier(corps: dict):
return station.modifier(corps)
@app.delete("/api/etiquettes")
def supprimer(corps: dict):
return station.supprimer(corps)
if PAGE.is_dir():
app.mount("/", StaticFiles(directory=PAGE, html=True), name="page")
else:
@app.get("/")
def sans_page():
return erreur(503, "la page n'est pas construite : cd app/web && npm install && npm run build")
def ouvrir(url: str) -> None:
if "microsoft" in platform.uname().release.lower(): # WSL : le navigateur Windows
subprocess.Popen(["explorer.exe", url], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
else:
webbrowser.open(url)
if __name__ == "__main__":
url = f"http://127.0.0.1:{PORT}"
print(f"Support AIMsight : {url}")
if "--sans-navigateur" not in sys.argv:
threading.Timer(1, ouvrir, [url]).start()
uvicorn.run(app, host="127.0.0.1", port=PORT, log_level="warning", timeout_graceful_shutdown=1)
+257
View File
@@ -0,0 +1,257 @@
"""Les données des pages Images et Étiquetage : les images d'une station, ses courbes, ses étiquettes.
Repris de view/view.py et labeling/labeling.py (le calcul, pas les pages) ; positions, references, COULEURS, POSE et
attribuer sont copiés de detectors-view/detecteurs.py et labeling/ids.py (app/README.md, « Copies »). La lecture des données est
celle des agents, API/tools/agent-tools/donnees.py. Lecture seule sur data/ ; écrit seulement dans labeling/{auto,manual}/.
"""
import bisect
import csv
import glob
import json
import os
import re
import statistics
import sys
from datetime import datetime, timedelta
from pathlib import Path
RACINE = Path(__file__).resolve().parents[2]
sys.path.insert(0, str(RACINE / "API" / "tools" / "agent-tools"))
import donnees # noqa: E402
DONNEES = Path(os.environ.get("AIMSIGHT_DATA", RACINE / "data")).resolve()
ETIQUETTES = Path(os.environ.get("AIMSIGHT_LABELS", RACINE / "labeling")).resolve()
DOSSIERS = ("auto", "manual") # celles de l'étiqueteur (D-105), celles de Marc (D-102)
FAMILLES = ("Visibility", "Obstruction", "Thermal displacement", "Displacement", "Target issue", "No data", "None") # D-109
FORMAT = "%Y-%m-%dT%H:%MZ"
MARGE_PX = 150 # detecteurs.MARGE_PX : x, y ne sont des positions dans l'image que loin du coin
COULEURS = ["#2a78d6", "#eb6834", "#1baf7a", "#8a5cd6", "#d6a12a", "#d63b8a", "#3bb3d6", "#6b6b66"] # un capteur chacun
POSE = (("pan", "#1a1a19"), ("tilt", "#8a8a85"), ("rotation", "#b5651d"))
# Le menu Advanced d'Explore, dans son ordre (labeling.PLOTS, QUALITE)
PLOTS = (("error_value", "Error value"), ("x", "X [px]"), ("y", "Y [px]"),
("relative_x", "Relative Horizontal Shift"), ("relative_y", "Relative Vertical Shift"),
("corr_x", "Relative Corrected Horizontal Shift"), ("corr_y", "Relative Corrected Vertical Shift"),
("reproj_err", "References (reproj. error)"))
QUALITE = (("peak", "Quality: Peak"), ("flux", "Quality: Flux"), ("sharpness", "Quality: Sharpness"),
("fwhm", "Quality: FWHM [px]"), ("dominance", "Quality: Dominance"), ("snr", "Quality: SNR"))
IDENTIFIANT = re.compile(r"(SIM_CCID|ip(_.*)?)$") # jamais lus (CLAUDE.md, « data/ »)
METRIQUE = re.compile(r"^(.+?)_\d{4}_\d{2}_\d{2}_")
class Refus(ValueError):
"""Une demande à refuser (400), avec sa raison."""
def stations():
return sorted(d.name for d in DONNEES.iterdir() if d.is_dir())
def dossier(station):
if station not in stations(): # le nom devient un chemin : un dossier de data/, rien d'autre
raise Refus(f"station inconnue : {station}")
return DONNEES / station
def bornes(du, au):
return donnees.instant(du or "0001-01-01"), donnees.instant(au or "9999-01-01")
# --- detectors-view/detecteurs.py
def positions(mesures, a, b):
"""La position médiane de chaque capteur dans l'image sur [a, b) ({} si x, y n'y sont pas des positions)."""
maisons = {s: (statistics.median(xs), statistics.median(ys)) for s, ms in mesures.items()
if (xs := [m["x"] for m in ms if a <= m["t"] < b and m["x"] is not None])
and (ys := [m["y"] for m in ms if a <= m["t"] < b and m["y"] is not None])}
return maisons if any(abs(x) > MARGE_PX or abs(y) > MARGE_PX for x, y in maisons.values()) else {}
def references(mesures, a, b):
"""Capteurs de la compensation sur la plage : ceux qui ont un reproj_err (références seulement)."""
return {s for s, ms in mesures.items() if any(m["reproj_err"] is not None for m in ms if a <= m["t"] < b)}
# --- la page Images (view/view.py)
def images(station, du, au):
"""Les images de [du, au), les positions médianes des capteurs, les références, et par capteur entouré son corr_x,
corr_y à l'heure de chaque image : la mesure valide la plus proche, à 30 min près, sinon 0."""
d, (a, b) = dossier(station), bornes(du, au)
vues = [(t, im) for im in sorted(glob.glob(str(d / "images" / "*"))) if (t := donnees.heure_image(im)) and a <= t < b]
if not vues:
raise Refus(f"aucune image de {station} sur cette plage")
mesures = donnees.charger(d)
maisons, refs = positions(mesures, a, b), references(mesures, a, b)
# ponytail: une seule mesure à chaque borne, bruitée ; une médiane sur une fenêtre si les flèches tremblent trop
marge, corr = timedelta(minutes=30), {}
for s in maisons:
serie = [(m["t"], m["corr_x"], m["corr_y"]) for m in mesures[s] if m["corr_x"] is not None and m["corr_y"] is not None]
temps, corr[s] = [m[0] for m in serie], []
for t, _ in vues:
k = bisect.bisect_left(temps, t)
k = min((n for n in (k - 1, k) if 0 <= n < len(serie)), key=lambda n: abs(temps[n] - t), default=None)
corr[s].append([round(serie[k][1], 4), round(serie[k][2], 4)] if k is not None and abs(temps[k] - t) <= marge else 0)
return {"images": [{"t": donnees.iso(t).replace("T", " ").rstrip("Z"), "nom": os.path.basename(im)} for t, im in vues],
"positions": {s: [round(x, 1), round(y, 1)] for s, (x, y) in sorted(maisons.items())},
"references": sorted(refs), "corr": corr}
def image(station, nom):
f = (dossier(station) / "images" / nom).resolve()
if f.parent != (DONNEES / station / "images").resolve() or not f.is_file():
raise Refus("image inconnue")
return f
# --- la page Étiquetage (labeling/labeling.py)
def metriques(d, a, b):
"""Les métriques système numériques de metrics/ sur [a, b) -> {nom: {t: valeur ou None}} (une valeur vide : None, le
trou se voit), sans les métriques texte, les identifiants, ni celles qui n'ont aucune valeur."""
station, series, texte = d.name + "_", {}, set()
for p in sorted(glob.glob(str(d / "metrics" / "*.csv"))):
if not (m := METRIQUE.match(os.path.basename(p))) or IDENTIFIANT.match(nom := m.group(1).removeprefix(station)):
continue
with open(p, newline="") as f:
for r in csv.DictReader(f):
t, v = donnees.instant(r["time_utc"]), (r.get("metric") or "").strip("[]'\" ")
if not a <= t < b:
continue
try:
series.setdefault(nom, {})[t] = float(v) if v else None
except ValueError:
texte.add(nom) # link, mode… : pas de courbe
return {n: dict(sorted(s.items())) for n, s in series.items()
if n not in texte and any(v is not None for v in s.values())}
def courbes(station, du, au):
"""-> {A, B, T, plots} : T, les heures de chaque série, une fois (clé : le capteur, "" pour la caméra, « system: »
et son nom pour une métrique) ; plot : titre et traces (name, t, y, line, mode), sans plots ni capteurs vides."""
d = dossier(station)
mesures = donnees.charger(d)
if not mesures:
raise Refus(f"aucun export « advanced » pour {station}")
tous = sorted({m["t"] for ms in mesures.values() for m in ms})
a = donnees.instant(du) if du else tous[0]
b = donnees.instant(au) if au else tous[-1] + (tous[-1] - tous[-2] if len(tous) > 1 else timedelta(hours=1))
poses = [p for p in donnees.charger_camera(d) if a <= p["t"] < b]
heure = lambda t: t.strftime("%Y-%m-%d %H:%M") # noqa: E731 (UTC, sans fuseau : comme l'affiche Plotly)
valeurs = lambda s, c: [None if m[c] is None else round(m[c], 5) for m in s] # noqa: E731
dans = {s: [m for m in mesures[s] if a <= m["t"] < b] for s in sorted(mesures)}
refs, out = references(mesures, a, b), []
def par_capteur(colonnes):
for col, titre in colonnes:
traces = [{"name": s + " (ref.)" * (s in refs), "t": s, "y": y,
"line": {"width": 1.2, "color": COULEURS[i % len(COULEURS)], "dash": "dot" if s in refs else "solid"}}
for i, (s, y) in enumerate((s, valeurs(ms, col)) for s, ms in dans.items()) if any(v is not None for v in y)]
if traces:
out.append({"titre": titre, "traces": traces})
par_capteur(PLOTS)
if poses:
out.append({"titre": "Camera movement (deg)", "traces": [{"name": c, "t": "", "y": valeurs(poses, c),
"line": {"width": 1.2, "color": col}} for c, col in POSE]})
par_capteur(QUALITE)
T = {"": [heure(p["t"]) for p in poses], **{s: [heure(m["t"]) for m in ms] for s, ms in dans.items()}}
systeme = metriques(d, a, b)
for nom in sorted(systeme, key=str.lower):
T["system:" + nom] = [heure(t) for t in systeme[nom]]
out.append({"titre": "System: " + nom, "traces": [{"name": nom, "t": "system:" + nom, "mode": "lines+markers",
"y": [None if v is None else round(v, 5) for v in systeme[nom].values()],
"line": {"width": 1.2, "color": COULEURS[0]}}]})
if not out:
raise Refus(f"aucune mesure de {station} sur cette plage")
return {"A": donnees.iso(a), "B": donnees.iso(b), "T": T, "plots": out}
# --- les étiquettes (labeling/labeling.py, labeling/ids.py)
def fichier(station, source):
if source not in DOSSIERS:
raise Refus("dossier d'étiquettes inconnu")
dossier(station)
return ETIQUETTES / source / f"{station}.jsonl"
def lire(station, source):
f = fichier(station, source)
# split et non splitlines : celui-ci couperait aussi sur les séparateurs Unicode que le texte peut contenir
return [json.loads(l) for l in f.read_text(encoding="utf-8").split("\n") if l.strip()] if f.exists() else []
def attribuer(station, etiquettes):
"""labeling/ids.attribuer (D-131) : un id aux étiquettes qui n'en ont pas, le suivant de la station, en premier champ."""
n = max((int(e["id"].rsplit("-", 1)[1]) for e in etiquettes if "id" in e), default=0)
for e in etiquettes:
if "id" not in e:
n += 1
e["id"] = f"{station}-{n}"
if next(iter(e)) != "id":
reste = {k: v for k, v in e.items() if k != "id"}
ident = e["id"]
e.clear()
e.update({"id": ident}, **reste)
def _valide(corps, debut, fin):
description = (corps.get("description") or "").strip()
try:
vide = datetime.strptime(debut, FORMAT) >= datetime.strptime(fin, FORMAT)
except (TypeError, ValueError):
raise Refus("bornes illisibles (AAAA-MM-JJTHH:MMZ)") from None
if not description or vide:
raise Refus("texte vide ou plage vide")
c = corps.get("categorie") or ""
if c and c not in FAMILLES:
raise Refus("famille inconnue")
return description, c
def ajouter(corps):
station, source = corps.get("station"), corps.get("dossier", "manual")
f = fichier(station, source)
description, c = _valide(corps, corps.get("debut"), corps.get("fin"))
label = {"debut": corps["debut"], "fin": corps["fin"]} | ({"categorie": c} if c else {}) | {"description": description}
if source == "auto": # une étiquette automatique porte un id stable, le suivant de sa station (D-131)
attribuer(station, lire(station, "auto") + [label])
f.parent.mkdir(parents=True, exist_ok=True)
avant = f.read_bytes() if f.exists() else b"" # une ligne retirée à la main peut laisser le fichier sans fin de ligne
with open(f, "ab") as sortie:
sortie.write(b"\n" * bool(avant and not avant.endswith(b"\n")) + json.dumps(label, ensure_ascii=False).encode() + b"\n")
return label
def modifier(corps):
avant = corps.get("avant") or {}
debut, fin = corps.get("debut", avant.get("debut")), corps.get("fin", avant.get("fin"))
description, c = _valide(corps, debut, fin)
label = dict.fromkeys(("id", "debut", "fin", "categorie")) | avant | {"debut": debut, "fin": fin, "categorie": c,
"description": description}
if label["id"] is None:
del label["id"]
if not c:
del label["categorie"]
label.pop("revue", None) # changée : à revoir par /review-labels (D-103)
return remplace(corps.get("station"), corps.get("dossier", "manual"), avant, label)
def supprimer(corps):
remplace(corps.get("station"), corps.get("dossier", "manual"), corps.get("avant"), None)
return corps.get("avant")
def remplace(station, source, avant, label):
"""Remplace l'étiquette avant par label (None : la retire), retrouvée par son contenu, pas par son rang : le fichier
a pu changer depuis le chargement de la page. Écrit à côté puis remplace : une coupure n'abîme pas le fichier."""
f = fichier(station, source)
lignes = f.read_text(encoding="utf-8").split("\n") if f.exists() else []
for i, ligne in enumerate(lignes):
if ligne.strip() and json.loads(ligne) == avant:
lignes[i:i + 1] = [] if label is None else [json.dumps(label, ensure_ascii=False)]
provisoire = f.with_name(f.name + ".tmp")
provisoire.write_text("\n".join(lignes), encoding="utf-8")
os.replace(provisoire, f)
return label
raise Refus("cette étiquette n'est plus dans le fichier : recharger la page")
+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" } },
});