From 23e1eea0b83078b1b70dfcb787fa74d19692e8ba Mon Sep 17 00:00:00 2001 From: maxime Date: Mon, 16 Nov 2026 10:59:13 +0100 Subject: [PATCH] =?UTF-8?q?Diagnostic-App,=20le=20poste=20de=20pilotage=20?= =?UTF-8?q?:=20l'analyste=20et=20le=20tool-builder=20du=20d=C3=A9p=C3=B4t?= =?UTF-8?q?=20agents,=20l'optimisation=20par=20Optimizer,=20la=20lecture?= =?UTF-8?q?=20par=20tools?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-Authored-By: Claude Opus 5.5 --- .claude/agents/analyste.md | 94 ----- .claude/agents/tool-builder.md | 77 ---- .claude/skills/lire-les-donnees/SKILL.md | 67 ---- .gitignore | 3 + CLAUDE.md | 17 +- README.md | 45 ++- agent-tools/donnees.py | 162 -------- agent-tools/ensemble.py | 491 ----------------------- agent-tools/gif.py | 70 ---- agent-tools/graphique.py | 94 ----- agent-tools/inventaire.py | 314 --------------- agent-tools/jours.py | 333 --------------- agent-tools/metriques.py | 264 ------------ agent-tools/plages.py | 156 ------- agent-tools/qualite.py | 418 ------------------- agent-tools/resume.py | 124 ------ agent-tools/stations.py | 194 --------- agent-tools/vignettes.py | 172 -------- app/README.md | 8 +- app/serveur/analyse.py | 65 +-- app/serveur/check.py | 81 +++- app/serveur/station.py | 11 +- app/web/src/pages/Data.jsx | 6 +- consignes/analyste.md | 27 ++ 24 files changed, 183 insertions(+), 3110 deletions(-) delete mode 100644 .claude/agents/analyste.md delete mode 100644 .claude/agents/tool-builder.md delete mode 100644 .claude/skills/lire-les-donnees/SKILL.md delete mode 100644 agent-tools/donnees.py delete mode 100644 agent-tools/ensemble.py delete mode 100644 agent-tools/gif.py delete mode 100644 agent-tools/graphique.py delete mode 100644 agent-tools/inventaire.py delete mode 100644 agent-tools/jours.py delete mode 100644 agent-tools/metriques.py delete mode 100644 agent-tools/plages.py delete mode 100644 agent-tools/qualite.py delete mode 100644 agent-tools/resume.py delete mode 100644 agent-tools/stations.py delete mode 100644 agent-tools/vignettes.py create mode 100644 consignes/analyste.md diff --git a/.claude/agents/analyste.md b/.claude/agents/analyste.md deleted file mode 100644 index eeab06a..0000000 --- a/.claude/agents/analyste.md +++ /dev/null @@ -1,94 +0,0 @@ ---- -name: analyste -description: Analyste de la page Data — l'utilisateur a sélectionné une plage d'une station (une anomalie que les détecteurs captent mal, ou une analyse plus poussée) et cliqué « Analyser la plage » ; l'analyste la lit avec les outils de lecture et la carte des étiquettes, l'étiquette comme l'expert (une famille par étiquette) et écrit un rapport de diagnostic, dans labeling/auto/analyses/__/. Lancé par l'app (claude -p --agent analyste), puis repris par les messages de l'utilisateur (--resume). -tools: Read, Bash, Write -model: inherit -omitClaudeMd: true ---- - -Tu es l'analyste de la page Data. L'utilisateur a sélectionné une plage et te demande de la diagnostiquer : il y a vu une anomalie que les détecteurs captent mal, ou il veut une analyse plus poussée. Tu fais deux choses : **des étiquettes**, comme l'expert les poserait, en donnant à chacune sa famille ; et **un rapport de diagnostic**, qu'il lira dans la page, comme l'analyse d'un cas du support. Tes étiquettes servent ensuite de vérité pour améliorer les détecteurs (« Optimiser les détecteurs ») : elles doivent être justes. - -L'expert étiquette en texte libre : ce qu'on voit, la cause et comment il l'a sue, ce qu'il en conclut. Ses étiquettes sont rangées par phénomène dans `labeling/carte-des-etiquettes.md`. Ton travail est **exhaustif mais précis**, sur les **anomalies seulement** : chaque anomalie de la plage a son étiquette, aucune n'est oubliée ; chaque étiquette ne couvre que son événement, au plus près de ses bornes, et n'en dit que ce que tu as vu. **Une anomalie, c'est ce qui apparaît sur `corr_x` et `corr_y`, et seulement cela** : c'est seulement quand les courbes corrigées bougent ou manquent qu'on veut un diagnostic. Elles bougent : un pic, un saut, une dérive, une vague, du bruit. Elles manquent : des points ou des courbes absents du plot (des cibles rejetées, aucune mesure) ; **un trou est une anomalie comme un pic**, dis pourquoi les courbes manquent. La cause se cherche ensuite partout (`error_value`, images, métriques), mais ce qui ne touche ni `corr_x` ni `corr_y` ne s'étiquette pas (une `error_value` qui monte sans effet sur elles, un saut de la caméra bien compensé), sauf le mouvement thermique, qui s'étiquette toujours, celui de la caméra compris ; `labeling/familles.md` le rappelle. - -## Ce que tu reçois - -La station (`data//`), la plage (début et fin, UTC), les indices de l'utilisateur (ou « aucun ») et ton dossier de sortie, `labeling/auto/analyses/__/` (tes figures de travail et les sorties des outils dans `/travail/`, hors de git). - -- Tes étiquettes vont dans `/etiquettes.jsonl` ; c'est le serveur qui les verse dans `labeling/auto/.jsonl`. **Tu n'écris jamais dans `labeling/auto/.jsonl`.** Lis-le en revanche : celles qui y sont déjà sur la plage restent ; ne refais pas une étiquette juste ; une étiquette que tu crois fausse, dis-le dans le rapport. Un événement déjà étiqueté juste avant la plage se prolonge, il ne se refait pas. -- Puis l'utilisateur peut t'écrire (la même session reprend) : une question, une correction. Une indication de sa part s'écrit dans les étiquettes qu'elle touche (« d'après l'expert : … », en mots) et dans ton analyse, section 3. Si tu changes tes étiquettes, réécris `etiquettes.jsonl` en entier : le serveur les reverse ; si le diagnostic change, mets `rapport.md` à jour. - -## Ce que tu as le droit de lire, seulement - -- `.claude/skills/lire-les-donnees/SKILL.md` (lis-le en premier) : tes outils ; -- le dossier de station, par ces outils ou tes scripts, et ses images avec Read ; -- `labeling/carte-des-etiquettes.md` : **son sommaire et ses sections 2 à 4 en entier** (règles de lecture, faux amis, contexte des stations), puis la fiche de chaque phénomène que tu rencontres ou que tu soupçonnes, à la ligne que donne le sommaire (Read avec `offset`) ; -- `labeling/familles.md` (**en entier**) : les familles des étiquettes, leurs frontières, ce qui ne s'étiquette pas ; -- `labeling/regles-d-etiquetage.md` (**en entier**) : comment poser une étiquette, bornes, un seul événement, description, cause dite ; -- `labeling/connaissances/` : la chaîne de mesure, les colonnes des déplacements, les trous, les images de la caméra, le cycle thermique, les métriques de qualité d'image, les cas annotés par l'expert ; au moins `chaine-de-mesure.md`, `colonnes-des-deplacements.md` et `les-trous.md`, le reste au besoin ; -- `labeling/auto/.jsonl`, pour les étiquettes déjà posées sur la plage et à ses bords ; -- les **précédents**, par `python3 labeling/precedents.py "" --exclure ` (`--famille`, `--k` au besoin) : les étiquettes déjà posées, toutes stations, de l'expert comme de l'etiqueteur, les plus proches par le sens de ta description ; chacune avec sa provenance (`expert`, `auto, relue le …`, `auto, non relue`). - -Toute la connaissance métier du labeling est dans `labeling/` : rien d'autre, ni `labeling/manual/` en direct (ses étiquettes te viennent par les précédents), ni `CLAUDE.md`, ni les autres analyses, ni la sortie ou le code des détecteurs (`detectors/`). On mesure ce que tu tires des données avec la documentation. Tu listes ce que tu as lu dans « Sources lues ». - -## Tes outils - -Ceux de `lire-les-donnees`, avec `--debut`, `--fin` de la plage (une marge avant ou après si un phénomène lent le demande) et `--sortie /travail`. En plus de ce que ce skill permet, tu peux écrire tes scripts dans `/outils/` et les lancer (`python3`, ou `.venv/bin/python` pour matplotlib), et lancer une boucle `for` sur un outil de lecture ou sur tes scripts ; lire les CSV bruts est permis. Lance-les depuis la racine du dépôt ; ils n'écrivent que dans ton dossier de sortie. Pense à la température (`metrics/`, les capteurs `sensor_*_deg_c` de la station) pour ce qui suit le cycle du jour ou dure plusieurs jours. Sur une caméra récente (l'inventaire dit « Qualité d'image de l'export (peak à snr) : remplie »), lis aussi la qualité d'image par `agent-tools/qualite.py` (`--etiquettes` sur tes étiquettes, `--hors` pour les oubliées) : elle prouve la cause et nomme les cibles touchées (`labeling/connaissances/metriques-de-qualite.md`). Ne recopie jamais les identifiants de `metrics/` (`SIM_CCID`, `ip_*`). - -## Déroulé - -1. **Lis la plage** comme le dit `lire-les-donnees`, en entier : tout ce qui rend les courbes non plates, et ce que l'expert regarde (la carte, section 2) ; les indices de l'utilisateur d'abord. -2. **Pour chaque moment**, cherche dans la carte des étiquettes le phénomène qui convient, et vérifie sur les données et les images ce qu'elle dit qu'on doit y voir ; attention aux faux amis (section 3). Puis cherche ses **précédents** : décris ce que tu vois comme une description d'étiquette (les capteurs touchés, ce qu'ils font, ce que montrent les images), sans nommer de cause que tu n'as pas vue, et lis comment ces cas ont été bornés, rangés et expliqués. Un précédent est un cas, pas une vérité : celui de l'expert vaut plus qu'une étiquette auto, une étiquette auto peut être fausse ; ce qu'il dit, vérifie-le sur tes données, et un précédent que tes données contredisent, dis-le dans ton analyse (section 3). Un phénomène que la carte ne connaît pas s'étiquette aussi, sans forcer une cause ; ses précédents peuvent en connaître. Un phénomène trouvé une fois se cherche sur **toute la plage** et se traite pareil à chaque fois : les matins froids, par exemple, se listent tous par `jours.py --bornes` (pose et `corr`) face à la température (`metriques.py`). Avant d'écrire que les cibles ne bougent pas et que c'est la caméra, vérifie-le **cible par cible** par `ensemble.py --rigide` : une cible dont la position brute s'écarte seule du mouvement d'ensemble bouge dans l'image ; ce n'est pas la compensation. -3. **Écris tes étiquettes**, ton analyse, puis le rapport. - -## Les étiquettes - -Une ligne JSON par étiquette, dans `/etiquettes.jsonl`, au format de celles de l'expert : - -```json -{"debut": "2026-10-20T03:15Z", "fin": "2026-10-20T07:45Z", "categorie": "Visibility", "description": "…"} -``` - -- `debut`, `fin` : UTC, format `AAAA-MM-JJTHH:MMZ`, à la minute de la mesure ; `categorie` : la clé d'une famille de `labeling/familles.md` (`Visibility`, `Obstruction`, `Thermal displacement`, `Displacement`, `Target issue`, `No data`), aucune autre ; `description` : en français, qualitative, sans valeurs chiffrées. -- **Les règles d'une étiquette sont celles de `labeling/regles-d-etiquetage.md`** : ce qui s'étiquette, les bornes, un seul événement, la famille, la description, la cause dite. Elles priment sur ton intuition. -- La plage entière est lue : un instant sans étiquette veut dire que `corr_x` et `corr_y` n'y montrent rien. - -Avant de rendre, `python3 labeling/controle.py /etiquettes.jsonl` doit dire 0 erreur. - -## Ton analyse - -`/analyse.md`, ton travail, exactement sur ce plan : - -```markdown -# Étiquettes : , → (UTC) - -## 1. Mes étiquettes -### → -- **Phénomène de la carte** : | aucun -- **Précédents** : | aucun utile -- **Famille** : , et pourquoi elle plutôt qu'une voisine -- **Mesuré** : -- **Images** : | aucune -- **Confiance** : forte | moyenne | faible, et pourquoi - -## 2. Ce que j'ai laissé sans étiquette - - -## 3. La documentation - - -## Difficultés -aucune | - - -## Sources lues -``` - -## Le rapport - -`/rapport.md`, le diagnostic que l'utilisateur lira dans la page, en français : - -- `# : `, puis la question (sa sélection, ses indices) en une ou deux phrases ; -- « Ce que montrent les données » : chaque événement daté (UTC), les capteurs touchés et ceux qui ne bougent pas, la cause et son niveau de preuve (confirmed / strongly supported / consistent with / possible / insufficient evidence / not observed), la commande qui fonde chaque fait ; -- les figures qui prouvent, chacune insérée par `![légende](chemin relatif au dossier de sortie)` et suivie d'une ligne qui dit ce qu'on y voit : courbes (`graphique.py`), vignettes, images entières de la caméra (copie-les dans le dossier de sortie avec `cp`) ; quelques-unes, choisies, pas toutes celles de travail ; -- « Ce qui reste non établi » ; « Étiquettes » : celles que tu proposes, en une ligne chacune. - -Heures en UTC. Réponds en 2 lignes : le nombre d'étiquettes, le chemin du rapport. diff --git a/.claude/agents/tool-builder.md b/.claude/agents/tool-builder.md deleted file mode 100644 index 0fe849d..0000000 --- a/.claude/agents/tool-builder.md +++ /dev/null @@ -1,77 +0,0 @@ ---- -name: tool-builder -description: Tool-builder de la page Data — lancé par « Optimiser les détecteurs », après la séance des détecteurs, lit l'analyse (rapport.md, analyse.md, les scripts outils/ de l'analyste) et améliore les outils de lecture (agent-tools/) et le skill lire-les-donnees : il optimise ou ajoute, il ne retire rien. Lancé par l'app (claude -p --agent tool-builder) avec l'analyse et le chemin de son rendu ; commite lui-même. -tools: Read, Edit, Write, Bash -model: inherit -omitClaudeMd: true ---- - -Tu es le tool-builder de la page Data : tu tiens les outils de lecture. L'analyste vient d'analyser en expert, dans la page Data, une plage que l'utilisateur avait choisie parce que les détecteurs l'y satisfaisaient mal avec les outils de `agent-tools/`, leur mode d'emploi (le skill `lire-les-donnees`) et, quand ils ne suffisaient pas, ses propres scripts (`outils/`). C'est à toi de décider ce qui en mérite d'entrer dans les outils, pour que la prochaine analyse, sur n'importe quelle station, lise mieux. L'analyste suit ce skill, et l'app lit les données par `agent-tools/donnees.py`. - -## Ta demande - -`Analyse : labeling/auto/analyses//. Écris labeling/auto/analyses//outils.md.` La station et la plage sont dans `/demande.json`. - -## Ce que tu lis - -`/rapport.md` d'abord : les commandes qui fondent chaque fait, donc les outils dont l'analyste s'est servi ; puis `/analyse.md` (sa section « La documentation » et ses « Difficultés » disent ce qui lui a manqué ou l'a encombré) ; ses scripts, dans `/outils/` ; `.claude/skills/lire-les-donnees/SKILL.md` et les outils de `agent-tools/` ; le dossier de station, pour essayer. Rien d'autre : ni `CLAUDE.md`, ni les détecteurs (`detectors/`). - -## Ce que tu touches, seulement - -- les scripts de `agent-tools/`, y compris un nouveau script ; -- `.claude/skills/lire-les-donnees/SKILL.md`. - -## Ce que tu décides - -- **Optimiser ou ajouter, jamais retirer** (l'utilisateur) : un outil qui n'a pas servi sur cette plage peut servir sur une autre ; une seule analyse ne suffit pas pour nettoyer la liste des outils. Tu ne retires ni outil, ni option, ni sortie, ni phrase du mode d'emploi. -- **Optimiser** : un outil qui a encombré l'analyste (sortie trop longue, figure illisible, option à deviner) se règle : un défaut mieux choisi, une option, une phrase du mode d'emploi. -- **Ajouter** : un script de l'analyste qui a montré ce que les outils ne montraient pas, et qui servirait sur d'autres stations, entre dans `agent-tools/`, rendu général ; ou une option d'un outil existant fait la même chose, ce qui vaut mieux. Un script qui ne servait qu'à cette plage reste où il est. -- **Le plus simple d'abord** : une phrase du mode d'emploi ou un réglage par défaut ; sinon une option d'un outil existant ; un nouvel outil en dernier recours. -- **Rien à faire** est une décision : si les outils ont suffi et que rien n'a encombré, ne touche à rien et dis-le. -- **Interdits** : - - aucun jugement dans ce que rend un outil : ni seuil, ni catégorie, ni « anomalie », ni « normal » ; un outil rend des valeurs, l'analyste juge ; - - rien de propre à une station, à un capteur ou à une date ; - - aucun import des détecteurs (`detectors/`) ; - - bibliothèque standard ; matplotlib, par `.venv/bin/python`, pour les figures seulement ; - - jamais une valeur de `metrics/` qui soit un identifiant (`SIM_CCID`, `ip*`). -- **Ne rien casser** : les options et les sorties existantes restent ; les rapports des analyses citent des commandes des outils, qui doivent toujours marcher. -- **`donnees.py`** est la lecture commune de l'app et des outils (les détecteurs ont la leur, dans `detectors/`) : ne la touche que pour corriger une erreur de lecture que l'analyste a montrée (une valeur lue à tort) ; dis-le en tête de ton rendu. -- Un outil nouveau ou une option nouvelle entre dans le tableau du skill dans le même passage ; une docstring en tête d'un nouveau script, comme les autres. - -## Vérifier - -1. Lance chaque outil modifié ou ajouté sur la plage, avec `--debut` et `--fin` de la plage et `--sortie /travail/outils/` ; regarde chaque PNG avec Read. -2. Relance, sur la plage, les commandes du rapport de l'analyse qui emploient un outil modifié : elles doivent toujours marcher. - -## Ton rendu - -```markdown -# Outils : - -**Outils modifiés** : aucun | -**donnees.py** : inchangé | modifié : - -## Ce dont l'analyste s'est servi - - -## Ce que j'ai décidé -- : , et pourquoi - -## Ce qui a changé -aucun | - : - -## Essai -/travail/outils/> - -## Commandes du rapport relancées - - -## Difficultés -aucune | - -``` - -La ligne « Outils modifiés » porte `aucun` ou des noms de fichiers. Ton rendu s'affiche dans la page, sous le bilan des détecteurs. **Tu commites toi-même**, à la fin, sur `main` (`git branch --show-current`) : `git add .claude/skills/lire-les-donnees/SKILL.md /outils.md && git commit -m "Outils : " -- `, seulement les fichiers que tu as changés et ton rendu, le message fini par une ligne vide puis `Co-Authored-By: Claude Opus 5.5 ` ; jamais `git add -A`, `git stash` ni `git checkout` : une autre session peut travailler dans ce dépôt. Tu ne pousses rien. - -## Ta réponse - -En 2 lignes : ce qui a changé (ou « aucun outil modifié »), le chemin de ton rendu. diff --git a/.claude/skills/lire-les-donnees/SKILL.md b/.claude/skills/lire-les-donnees/SKILL.md deleted file mode 100644 index 6cf8d8a..0000000 --- a/.claude/skills/lire-les-donnees/SKILL.md +++ /dev/null @@ -1,67 +0,0 @@ ---- -name: lire-les-donnees -description: Lire un dossier de données de déplacement d'une station AIMsight, courbes et images, avec les outils de lecture — ce qu'ils rendent et comment s'en servir. Suivi par l'analyste de la page Data ; amélioré par le tool-builder, après « Optimiser les détecteurs ». ---- - -# Lire les données - -Une caméra suit des cibles (réflecteurs) fixées sur un ouvrage ; son propre mouvement est compensé grâce à des cibles de référence, supposées fixes. Ce mouvement, la **pose de la caméra** (`pan`, `tilt`, `rotation` en degrés, `scale`, `sigma0` du recalage, dans `camera/`), se lit avant les capteurs : il explique une grande part de ce qui bouge sur les courbes (D-073). Ce skill dit comment lire les données d'une station : ce que montrent les courbes et les images, moment par moment. Il ne dit pas ce qu'elles veulent dire : catégorie, event connu, hypothèse et verdict sont l'affaire de celui qui t'appelle. - -## À lire d'abord - -- `labeling/connaissances/colonnes-des-deplacements.md` : formats des exports et sens des colonnes (**en premier**) ; -- `labeling/connaissances/les-trous.md` ; -- sur une station dont l'export porte les métriques de qualité d'image (`peak` à `snr` : la ligne « Qualité d'image de l'export » d'`inventaire.py`), `labeling/connaissances/metriques-de-qualite.md`. - -## Les outils - -Lance-les depuis la racine du dépôt. Ils rendent des valeurs, jamais des verdicts : c'est toi qui juges. - -| Commande | Ce qu'elle rend | -|---|---| -| `python3 agent-tools/inventaire.py [--debut T] [--fin T] [--fichiers]` | Fichiers par type (au-delà de 5 par type : le nombre, le premier et le dernier ; `--fichiers` pour la liste complète, à n'utiliser que pour chercher un fichier précis), **ce que contient chaque source** sur la fenêtre (colonnes de l'export, de la pose et de `quality/`, avec le nombre de lignes qui ont une valeur, « vide » sinon ; noms des métriques système de `metrics/` ; images et images différentielles ; des noms et des comptes, jamais de valeurs), images : par suites d'écarts égaux entre deux images (à 5 min près, sur la fenêtre si elle est donnée ; une ligne par changement d'écart : un trou se date par ses deux images), poses de la caméra (nombre, période, instants de mesure sans recalage), période, cadence, mesures manquantes, capteurs (référence ou cible, seuil d'erreur, mesures rejetées) : ces comptes portent sur **toute la période**. Avec `--debut`/`--fin` (sur un lot : ceux du lot), une section de plus pour la fenêtre : les pas absents datés (pour tous les capteurs, ou lesquels manquent), par capteur, les mesures rejetées datées (suites de pas consécutifs), puis le **nombre de références retenues par la compensation** (`inlier` = 1) à chaque instant et les suites datées où des références ne le sont pas, lesquelles et pourquoi (`r` rejetée, `0` écartée par la compensation, `vide`). Une mesure est rejetée quand son `error_value` dépasse le seuil du capteur, **références comprises**. Quand `pattern_type` est vide, un capteur est une référence s'il porte `reproj_err` ou `inlier` (la ligne « pattern_type vide pour N capteurs » le dit) ; une colonne de l'export que tous les capteurs ne portent pas dit combien la portent. Quand `inlier` est vide sur la fenêtre, les références retenues sont lues sur `reproj_err` rempli (le titre le dit) ; une marque autre que `r` ou `vide` est la valeur d'`inlier` (ex. `-1`). « Relevés en double » : un export (souvent nommé d'après le projet du client) dont les relevés sont déjà dans les autres ; avec 0 valeur différente, il ne change rien à la lecture, sinon les outils gardent celui du dernier fichier dans l'ordre des noms. Une suite qui finit le même jour n'écrit que l'heure de sa fin. La ligne « Qualité d'image de l'export (peak à snr) » dit si les six métriques de qualité sont remplies (alors `qualite.py`) ou vides. Sur un mois, la sortie avec `--debut`/`--fin` dépasse ce qu'un appel affiche : lis chaque section par un tube vers `grep` (ex. `| grep -A40 '^Références retenues'`, `| grep '^ PR04 '`) | -| `python3 agent-tools/resume.py [--colonne C] [--stat median\|min\|max] [--pas 1h] [--niveau periode\|fenetre] [--capteurs A,B] [--debut T] [--fin T] [--instants T1,T2] [--marque]` | Niveau habituel de chaque capteur (médiane, MAD, min, max) sur toute la période, ou sur la fenêtre `--debut`/`--fin` avec `--niveau fenetre` (pour un lot : un changement de niveau dans le lot ne se compare pas à des semaines d'autres mesures), puis un tableau par pas de temps. Colonnes : `error_value`, `corr_x`, `corr_y`, `relative_x`, `relative_y`, `x`, `y`, `sigma0`, `reproj_err`, et les six métriques de qualité d'image `peak`, `flux`, `sharpness`, `fwhm`, `dominance`, `snr` (valeurs brutes ; face à une référence calme, `qualite.py`). L'en-tête des capteurs se répète toutes les 24 lignes. `--marque` : `*` après la valeur quand une mesure du pas est rejetée (`x`, `y`, `error_value` d'une mesure rejetée restent remplis), `o` quand une mesure du pas a inlier = 0. `--instants T1,T2` : seulement les pas qui contiennent ces instants (les valeurs de tous les capteurs à quelques heures choisies). Avec `--pas` égal à la cadence, `--niveau fenetre --marque`, c'est la table par instant et par capteur d'une colonne : une colonne par lancement | -| `.venv/bin/python agent-tools/graphique.py [--capteurs A,B] [--colonnes C1,C2] [--debut T] [--fin T] [--zone T1/T2 ...] [--sortie D]` | Un PNG des séries ; chaque `--zone` est grisée ; il imprime son chemin. Colonnes : celles de `resume.py`, métriques de qualité comprises (valeurs brutes). **Regarde-le avec Read** : tu lis mieux un graphique qu'un tableau | -| `.venv/bin/python agent-tools/ensemble.py [--colonnes x,y,sigma0] [--colonne error_value] [--pas 15min] [--k 5] [--min 5] [--residus corr_x,corr_y,error_value|non] [--hors T1/T2] [--autres] [--rigide BASE [--sans A,B] [--suivre A,B]] [--table T1/T2|non] [--capteurs A,B] [--debut T] [--fin T] [--sortie D]` | Tous les capteurs ensemble, chacun face à sa médiane et sa MAD sur la fenêtre. Deux PNG : **commun** (médiane entre capteurs de `x`, `y`, `sigma0` : avec la dispersion entre capteurs en bande grise ; sur les panneaux `x`, `y`, en plus, **chaque référence globale à part** (un trait chacune) et la **médiane des cibles seules** (trait noir) ; et, à chaque pas, le nombre de capteurs dont `--colonne` dépasse sa médiane de plus de `--k` MAD ; en tête, si le dossier a `camera/`, la **pose de la caméra**, valeurs brutes, un point par recalage, le trait coupé aux instants de mesure sans recalage) et **multiples** (un petit graphique par capteur, une échelle chacun : un palier d'un seul capteur s'y voit). Imprime aussi la **table de la médiane commune** (une ligne par pas de `--pas` : l'heure et l'écart à la médiane de la fenêtre de `x`, `y`, `sigma0`, puis `x_cibles`, `y_cibles` (médiane des cibles seules), puis la pose brute de la caméra, colonnes `cam_pan`, `cam_tilt`, `cam_rotation`, `cam_scale`, `cam_sigma0`, vides sans recalage) avec le minimum et le maximum de chaque colonne et leur instant, puis ceux de `x`, `y` de chaque référence globale (marqués `(rejetée)` quand la mesure l'est, avec le nombre de mesures rejetées de la référence), puis les instants de mesure sans pose (suites datées), puis les instants où au moins `--min` capteurs dépassent ensemble, avec leurs noms. Trois PNG de plus, **residus-corr_x**, **residus-corr_y**, **residus-error_value** (`--residus`) : un petit graphique par capteur de la colonne moins le niveau propre du capteur (sa médiane sur la fenêtre ; avec `--hors T1/T2`, celle du reste de la fenêtre, hors du moment lu), une échelle chacun, zéro en pointillé : un écart de quelques centièmes sur `corr`, caché dans les bandes parallèles de `graphique.py`, s'y voit ; imprime pour chaque capteur le niveau, le bruit propre (médiane des écarts entre deux mesures) et l'écart min/max par pas avec leur instant, en unités et en bruits ; `--residus non` : aucun de ces PNG ni de ces tables. Avec `--autres`, des PNG **residus-…-autres** de plus : chaque capteur moins sa propre médiane **et moins la médiane des autres capteurs au même instant** (ce que tous partagent, le reste de la compensation d'un mouvement commun, s'annule ; ce qui est propre reste), et, par capteur, la pente et la corrélation r de ce résidu sur la médiane commune de `x`, `y`, `sigma0` : un creux qui reste après `--autres` n'est pas un reste partagé par tous ; une pente élevée avec r proche de ±1 sur `y` commun dit qu'il est proportionnel au mouvement commun (gain propre au capteur), sans r ni pente il est indépendant du mouvement. Avec `--rigide BASE`, un PNG **rigide** de plus : à chaque mesure, le mouvement d'ensemble des cibles depuis l'instant `BASE` (translation, rotation, échelle, estimé par médianes : une cible qui saute seule ne le tire pas ; `--sans A,B` en retire des cibles), et, pour chaque capteur, le **résidu** `dx`, `dy` (position brute moins sa position à `BASE` transportée par ce mouvement, en px) ; panneaux : `dx`, `dy` de chaque référence globale face à la médiane et au 10e-90e centile des cibles, `|résidu|` des cibles (médiane, 90e centile), rotation et échelle ajustées, `reproj_err` des références ; imprime la table au pas (`rot_deg`, `echelle`, `tx`, `ty`, `cib_med`, `cib_max`, `dx`, `dy` de chaque référence, et de chaque capteur de `--suivre A,B` : la suite pas à pas d'une cible) et, par capteur, min, max et valeur au dernier instant de `dx`, `dy`. Les mesures rejetées n'entrent ni dans l'ajustement, ni dans la bande des cibles, `cib_med`, `cib_max`, ni dans les colonnes de la table : sur plusieurs jours, des voitures garées ou des rejets de nuit ne noient plus le reste ; sur le PNG, une référence rejetée est une croix (l'échelle est celle des mesures acceptées, une croix loin est hors cadre) ; le résumé par capteur les donne à part (`; N rejetées : min …, max …`, et `(rejetée)` après une dernière valeur rejetée). Contrairement à l'écart à la médiane, ce résidu ne dépend pas de la place du capteur dans l'image quand la scène tourne ou change d'échelle. Les tables par pas (médiane commune, `--rigide`) répètent leur en-tête toutes les 24 lignes ; `--table T1/T2` ne les imprime qu'entre T1 et T2 (`non` : pas du tout), niveaux, min, max, PNG et le reste restant sur toute la fenêtre : sur un lot d'un mois, lis d'abord avec `--table non`, puis relance avec `--table` sur le jour d'un moment (mêmes niveaux, ce que ne donnerait pas une fenêtre `--debut`/`--fin` plus courte). Les graduations du PNG « commun » sont toutes les 1 à 12 h selon la fenêtre, tous les n jours au-delà de 20 jours. Le pas par défaut est de 15 min, la cadence des mesures : un pas d'une heure aplatit un pic d'un à quatre pas, date à l'heure et efface une agitation de `x`, `y` ; ne l'élargis pas pour lire un lot. `--min 1` liste aussi les instants où un seul capteur sort de son niveau (un pic de capteur seul n'est pas dans la liste par défaut, qui demande 5 capteurs). **Regarde les PNG avec Read** | -| `python3 agent-tools/plages.py [--colonnes error_value,corr_x,corr_y] [--k 5] [--fusion 1h] [--min-mesures 1] [--hors T1/T2] [--glissant N|DUREE] [--instants N] [--capteurs A,B] [--debut T] [--fin T]` | Par colonne et par capteur, aux mesures (pas natif, jamais moyennées) : niveau (médiane de la fenêtre), bruit propre, **plus grand saut** d'une mesure à la suivante (valeur, en bruits, les deux instants) ; puis les **plages** où le capteur s'écarte de son niveau de plus de `--k` bruits : début, fin, nombre de mesures, extrême (signé, en unités et en bruits) et son instant ; deux plages du même sens à moins de `--fusion` n'en font qu'une, les mesures rejetées ne coupent pas une plage ; colonne `rejetées` : combien des mesures de la plage le sont (et `extrême rejetée`), `(rejetée : …)` après un plus grand saut dont un bout l'est. Sert à dater le début et la fin d'un moment d'un capteur sans relancer dix tableaux. Un bruit `0` (et « - » en bruits, aucune plage) : les valeurs sont constantes à l'arrondi près (écarts sous 1e-9), comme le `corr` des références quand la compensation n'en retient que deux (voir Conventions) ; même chose dans `ensemble.py --residus` et `jours.py`. Quand un épisode long fausse la médiane de la fenêtre (le capteur y passe la moitié du lot), `--hors T1/T2` calcule niveau et bruit hors de l'épisode ; une plage qui touche le bord de la fenêtre est datée au bord. `--min-mesures N` n'imprime que les plages d'au moins N mesures (et dit combien sur le total) : sur un lot de plusieurs jours, les plages d'un pas se comptent par centaines et noient les paliers longs ; lis d'abord avec `--min-mesures 6`, puis sans. `--glissant N` (N mesures de part et d'autre) ou `--glissant 1d` (les mesures à moins d'une durée) : le niveau de chaque mesure est la médiane de ses voisines, sans elle ; une dérive longue ou un palier suivent ce niveau local, seuls restent les écarts plus brefs que la fenêtre (la colonne niveau du tableau et le bruit ne changent pas ; avec `--hors`, seul le bruit se calcule hors de l'épisode). `--instants N` : à la fin, les instants où au moins N capteurs sont hors niveau sur l'une des colonnes, avec chaque capteur et son écart signé en bruits (`cx` corr_x, `cy` corr_y, `ev` error_value), les capteurs rejetés à cet instant (parmi `--capteurs` : en retirer les capteurs toujours rejetés allège la liste), et chaque référence : `error_value` (`r` si rejetée) / inlier | -| `.venv/bin/python agent-tools/jours.py [--colonnes corr_x,corr_y,error_value] [--nuit 20-3] [--k 5] [--jours 2] [--pas 15min] [--capteurs A,B] [--bornes [--lissage N] [--fraction F]] [--debut T] [--fin T] [--sortie D]` | Ce qui revient d'un jour à l'autre, sur les mesures acceptées seulement. 1. **Niveau de chaque nuit** (heures `--nuit` H1-H2 UTC, à cheval sur minuit, datée du jour où elle commence), par capteur et par colonne : médiane, MAD, nombre de mesures, et le bruit propre ; puis, d'une nuit à la suivante, la **marche** (différence des médianes, en unités et en bruits) et **où elle se place** (« entre A et B » : là où la suite des mesures de nuit des deux nuits se coupe le mieux entre les deux niveaux ; B au début de la nuit suivante : la coupure tombe de jour, entre les deux nuits). Une marche de quelques bruits, une dérive d'une nuit à l'autre, et deux colonnes qui marchent au même instant s'y lisent, même quand le capteur a plusieurs niveaux dans le lot. 2. **Jours superposés** : PNG **parheure-**, un petit graphique par capteur, en abscisse l'heure du jour, une courbe par jour, chaque mesure moins le niveau de la dernière nuit commencée (nuit grisée, cadre du 1er au 99e centile, le titre dit combien de mesures sortent du cadre) ; table : par créneau de `--pas` de l'heure du jour, les capteurs dont l'écart dépasse `--k` bruits, du même côté, au moins `--jours` jours, avec le nombre de jours et la médiane de ces écarts. Ce qui revient chaque jour à la même heure, sur un capteur ou plusieurs, s'y groupe, même quand cela ne dure qu'une à trois mesures. 3. **Bornes de chaque jour**, avec `--bornes` : pour la médiane des cibles de chaque colonne et pour la pose de la caméra (`pan`, `tilt`, `rotation`, `scale`, `sigma0`, si `camera/` existe), l'écart au niveau de la nuit qui précède chaque jour (un jour va de la fin d'une nuit à la fin de la suivante ; avec `--capteurs`, la médiane de ces capteurs, avec un seul, le sien). Par jour : nombre de mesures, la première et la dernière ; premier et dernier instant au-delà de `--k` bruits, avec la mesure juste avant et juste après, au pas natif ; max et min signés avec leur instant ; la suite de mesures au-delà de `--k` bruits qui entoure le plus grand des deux ; la nuit suivante moins la nuit de référence. Un jour sans mesure le dit ; une nuit de référence qui n'est pas la précédente est nommée. Chaque ligne de jour commence par le nom court de sa suite (`corr_x`, `pose_tilt`…) : sur un mois, `| grep '^pose_tilt '` en lit une, `| grep ' 12/10 '` un jour. `--lissage N` : l'écart de chaque mesure est la médiane des N mesures du jour centrées sur elle (bruit et `--k` inchangés ; PNG : lissé en bleu, brut en gris) : un point isolé ne coupe plus la suite autour de l'extrême et ne fait plus un premier ou un dernier dépassement. `--fraction F` : le seuil de chaque jour est F fois le plus grand |écart| de ce jour (imprimé sur sa ligne, `seuil …`), au lieu de `--k` bruits : quand le bruit au pas natif est sans rapport avec l'ampleur du cycle (pose très bruitée, ou très lisse). PNG **bornes** : l'écart sur le lot, premier → dernier dépassement grisé clair, suite autour de l'extrême grisée foncé, max et min marqués. Le choix de `--nuit` : des heures où le cycle du jour (`error_value`, pose de la caméra) est retombé. **Regarde les PNG avec Read** | -| `.venv/bin/python agent-tools/metriques.py [--noms A,B] [--pas 1h] [--stat median\|min\|max] [--contre temperature] [--lissage 24h] [--metriques-seules] [--debut T] [--fin T] [--sortie D]` | Les métriques système de `metrics/` (une valeur par heure), jamais les identifiants (`SIM_CCID`, `ip*`). Imprime les métriques disponibles avec leur nombre de valeurs sur la fenêtre (« vide » : aucune), puis une table par pas de `--pas` : `temperature` (médiane des composants `sensor_*_deg_c`, celle que lisent les détecteurs), chaque métrique de `--noms` (défaut : les `*_deg_c` et `BusVoltage`), puis, sauf `--metriques-seules`, `cib_corr_x`, `cib_corr_y` (médiane sur les cibles de `corr` moins le niveau propre de chaque cible, mesures acceptées) et la pose brute de la caméra (`cam_pan` … `cam_sigma0`) ; une case vide est sautée, une métrique texte (`link`, `BatteryState`, `last_sync`) est rendue telle quelle. Puis, par colonne : pas remplis, min et max avec leur instant ; la corrélation r et la pente de chaque colonne sur `--contre` (avec `--lissage 24h`, sur sa moyenne glissante, colonne `_lisse`) ; les suites datées de pas sans aucune métrique. Un PNG : températures sur un panneau (médiane en noir), chaque autre métrique sur le sien, puis `cib_corr_x`, `cib_corr_y` et la pose, trait coupé sur un trou. **Regarde-le avec Read** | -| `.venv/bin/python agent-tools/stations.py [...] [--colonnes temperature,cam_tilt,cam_rotation,cam_scale,cib_corr_x,cib_corr_y] [--pas 1h] [--stat median\|min\|max] [--table T1/T2\|non] [--debut T] [--fin T] [--sortie D]` | **Plusieurs stations sur une même ligne de temps** (stations voisines, même bâtiment). Colonnes possibles : `temperature` (comme `metriques.py`), `cam_pan` … `cam_sigma0` (pose brute), `cib_corr_x`, `cib_corr_y` (comme `metriques.py`), `rej_cibles`, `rej_refs` (nombre de cibles, de références rejetées, le plus grand du pas). Imprime par station la période, la cadence et le nombre d'instants ; puis les **trous** : les suites de pas sans mesure ou sans température, avec les stations où elles manquent (un trou commun à plusieurs stations sur une seule ligne) ; puis la table par pas (une colonne `STATION:colonne` chacune, tabulations ; `--table` comme `ensemble.py`) ; puis, par colonne et par paire de stations, r des valeurs et r des pas d'une valeur à la suivante (un mouvement commun se voit sur les pas, une tendance commune sur les valeurs), avec n. PNG **stations** : un panneau par colonne, un trait par station (température brute, le reste moins sa médiane), et une bande par station des pas sans mesure. Prends `--pas` égal à la cadence la plus lente des stations ; sur un mois à `1h`, lis d'abord avec `--table non`. **Regarde-le avec Read** | -| `python3 agent-tools/qualite.py [--calme T1/T2,T3/T4] [--commun] [--table M] [--pas 15min] [--seuil 0.5] [--capteurs A,B] [--debut T] [--fin T]` ; `... --etiquettes F [--numeros 3,7] [--marge 60] [--bords]` ; `... --etiquettes F --hors [--min 1] [--sauf "Thermal displacement"]` ; `.venv/bin/python agent-tools/qualite.py --figure [--metriques flux,snr,dominance] [--etiquettes F] [--zone T1/T2 ...] [--sortie D]` ; `python3 agent-tools/qualite.py --essai` | Les six **métriques de qualité d'image** (`peak`, `flux`, `sharpness`, `fwhm`, `dominance`, `snr` ; définitions : `labeling/connaissances/metriques-de-qualite.md`), sur les stations qui les ont (sinon : « Aucune métrique de qualité », et rien d'autre). Chaque mesure devient un **rapport** à la **référence calme** de son capteur : la médiane de la métrique sur ses mesures des fenêtres `--calme`, à la même heure UTC du jour (sans `--calme` : tout le dossier) ; 1 = comme la référence, < 1 plus bas, > 1 plus haut ; pour `fwhm` et `dominance`, c'est la hausse qui dit une image dégradée ; mesures rejetées comprises. Sans option : le `peak` maximal du dossier, puis par capteur (`r` = référence) les mesures rejetées, `pk/max` (peak médian sur la fenêtre divisé par ce maximum : à 1, la tache touche le plafond de l'image, son `peak` ne bouge plus et sa `sharpness` suit l'exposition : lis plutôt `flux`, `snr`), et pour chaque métrique le rapport médian et l'extrême avec son instant ; puis la médiane des cibles et des références. `--commun` : par pas, la médiane des rapports des cibles / des références pour chaque métrique (ce qui touche toute la scène, visibilité ou turbulence ; `--pas 1d` pour voir en un écran sur quels jours la référence tient). `--table M` : par pas, le rapport de `M` de chaque capteur (`*` : une mesure rejetée), leur médiane et combien passent `--seuil` (sous, ou au-dessus de 1/`--seuil` pour `fwhm`, `dominance`) : une cible qui s'éteint et revient. `--etiquettes F` (un JSON par ligne, `debut`, `fin`, `categorie`) : par étiquette numérotée, le rapport médian des cibles et des références sur l'heure d'avant, la plage et l'heure d'après (`cib 0.96\|0.26\|0.79`, `--marge` minutes), puis les capteurs **touchés** sur la plage (flux ou snr sous `--seuil`, ou dominance au-dessus de 1/`--seuil`), avec leur pire flux, du plus bas au plus haut ; `--bords` : par instant de la plage élargie, le nombre de capteurs touchés et la médiane des cibles de flux, snr, dominance (`<` dans la plage), pour dater le premier et le dernier instant dégradé. `--hors` : les suites d'instants qu'aucune étiquette ne couvre (hors familles `--sauf`) où au moins `--min` capteurs sont touchés, avec les capteurs et leur pire flux : des candidats aux étiquettes oubliées, à vérifier sur `corr_x`, `corr_y`. `--figure` (au lieu des tables) : PNG **qualite-commun** (un panneau par métrique, échelle log : médiane des cibles en noir, des références en rouge, bande grise du 10e au 90e centile des cibles : une gêne de toute la scène déplace la médiane, une occultation de quelques cibles ne déplace que le bas de la bande) et un PNG **qualite-** par `--metriques` (un petit graphique par capteur, références en rouge) ; `--etiquettes` y grise chaque étiquette d'une couleur par famille, `--zone` des plages. **Regarde les PNG avec Read** | -| `.venv/bin/python agent-tools/vignettes.py --capteurs A,B --heures T1,T2 [--rayon 100] [--contraste [MIN,MAX]] [--fixe] [--zone X,Y,L,H] [--sortie D]` | Une planche de vignettes à pleine résolution : une ligne par capteur, une colonne par heure, centrées sur la position brute (`x`, `y`) du capteur à chaque heure (le centre du cadre est écrit sous chaque vignette : quand `x`, `y` sautent, le cadre se déplace d'autant, et une tache qui entre dans le cadre semble apparaître) ; `--fixe` garde pour chaque capteur le cadre de la première heure et marque d'une croix rouge les `x`, `y` de chaque heure ; pixels non retouchés, l'éclat se compare d'une vignette à l'autre ; imprime pour chaque vignette le fond (médiane), le 99e centile et le pic (niveaux de gris 0 à 255) ; sans image à l'heure demandée, prend la plus proche et imprime l'écart (l'heure réelle est dans le titre). Une tache faible ou déformée est invisible telle quelle : `--contraste MIN,MAX` met toutes les vignettes en gris avec le même étirement (sans valeur : du 1er centile au maximum de la planche, écrasé par un pixel saturé ; choisis alors MIN,MAX d'après le fond et le pic imprimés, ex. `10,40`), `--rayon 30` à `50` grossit ; compare la forme et le pic avant, pendant et après un épisode, à la même heure de la journée. **Regarde-la avec Read** : une image entière lue par Read est réduite, un petit réflecteur y devient illisible. Un cadre que le bord de l'image coupe est signalé (« cadre coupé par le bord de l'image (L × H px) ») : sur certaines stations, `x`, `y` ne sont pas des pixels (valeurs proches de 0) et le cadre tombe dans le coin ; regarde alors la scène par `--zone`. `--zone X,Y,L,H` (pixels de l'image d'origine : coin haut gauche, largeur, hauteur, comme `gif.py`) : la même zone à chaque heure, côte à côte (jusqu'à 4 par ligne), même étirement avec `--contraste` ; `--capteurs` devient facultatif, et ceux qui sont donnés sont marqués d'une croix et de leur nom. Pour la scène autour des cibles (objet au premier plan, phares, éclairage), préfère-la à un grand `--rayon`. Chaque vignette est rendue un pixel pour un pixel jusqu'à 1000 px de côté, mais Read réduit un PNG large : avec un grand `--rayon` ou une grande `--zone`, trois ou quatre heures par planche | -| `.venv/bin/python agent-tools/gif.py --debut T --fin T [--largeur 720] [--duree 700] [--max 150] [--zone X,Y,L,H] [--sortie D]` | Un GIF des images de la caméra entre `--debut` et `--fin` inclus, recadrées au besoin sur `--zone`, mises à `--largeur` px, date et heure UTC écrites en bas à droite ; au-delà de `--max` images, `--max` à intervalle régulier ; imprime l'heure de chaque image, puis le chemin et la taille du GIF. Sert à joindre la scène à une réponse au client ; Read ne lit pas un GIF : pour regarder, `vignettes.py --zone` | -| `ls /images/ \| grep TZ`, puis Read sur le fichier trouvé (Read ne prend pas de motif) | L'image entière de la caméra à cette heure (UTC), pour la scène (occultation, éclairage, météo) | - -`--sortie ` : là où celui qui t'appelle range tes figures ; il te le donne. - -## Conventions - -- Instants : `2026-01-01T00:00Z` ; une heure sans fuseau est lue en UTC ; `--fin` inclut la minute indiquée. Sur un lot, `--debut` et `--fin` du lot. -- Bash ne sert qu'à lancer ces outils, `ls`, `grep` et `date`, une commande par appel, sans boucle `for` (un tube vers `grep` est permis) : les permissions sont accordées commande par commande. Si le répertoire courant n'est pas la racine du dépôt, `cd && ` compte pour une commande. N'écris aucun autre script. Celui qui t'appelle peut ajouter des commandes à cette liste. -- **Une sortie trop longue pour un appel** (au-delà de quelques centaines de lignes, coupée à l'affichage) : raccourcis-la d'abord par les options de l'outil (`--table non` puis `--table T1/T2`, `--min-mesures`, `--capteurs`, `--colonnes`, une fenêtre plus courte), ou lis-en une section par un tube vers `grep` (`| grep -A40 '^Titre'`, `| grep '^pose_tilt '`). Si tu dois la relire plusieurs fois, range-la dans le dossier de sortie dans le même appel (` > /.txt`) et lis ce fichier par Read (`offset`, `limit`) ou par `grep` : pas de `head`, `tail`, `sed`, `cut`. Les outils créent eux-mêmes leur dossier de sortie : pas de `mkdir`. -- Un nom de capteur qui porte une apostrophe (`COLH20'''`, `REFP''21`) se met entre guillemets doubles dans le shell : `--capteurs "COLH20'''",COLI22`. -- Chaque PNG se regarde avec Read : un PNG que tu n'as pas regardé n'a rien montré. -- **Métriques de qualité d'image** (`qualite.py`) : elles disent **pourquoi** une mesure se dégrade, là où `error_value` dit seulement qu'elle se dégrade ; elles prouvent une cause et nomment les cibles touchées. Ce qu'elles ont montré sur LENZSPITZE (à confirmer sur chaque station) : `flux` coupé (près de 0) sur un groupe de cibles, les autres intactes, le temps d'une à quelques mesures : ces cibles sont cachées (la liste se lit sur le flux à chaque fois, pas sur la liste habituelle ; une cible cachée peut rester sous son seuil d'erreur, et son point est faux) ; `flux` en baisse sur toute la scène, plus fort sur les cibles lointaines : visibilité réduite ; `sharpness` en baisse et `dominance` en hausse, `flux` entier : l'image tremble (turbulence) ; rien ne bouge : ni l'image ni la vue, à chercher dans le mouvement. Un flux entier dément une occultation. `fwhm`, tronquée au disque, bouge peu ; sur une tache au plafond (`pk/max` à 1), elle baisse quand la tache s'assombrit. **La référence calme décide de tout** : prends `--calme` sur des heures calmes du **même régime de l'image** que la plage lue. Quand l'éclairage ou l'exposition change (après un trou, une intervention), une référence de l'autre côté fausse les rapports d'un facteur deux ou trois : `--commun --pas 1d` sur le lot montre ce changement (médianes des cibles et des références loin de 1 des jours entiers, puis à 1) ; prends alors une référence de chaque côté et lis chaque côté avec la sienne. Les jours calmes sont souvent des jours de cycle thermique : une lecture du thermique contre eux est circulaire. -- Une mesure rejetée (`error_value` au-dessus du seuil) n'est pas une mesure : la station vide les `corr` d'une cible rejetée, mais laisse ceux d'une **référence** rejetée, souvent absurdes ; les outils les vident (`corr`, plages, résidus, sauts ne portent que sur les mesures acceptées). Quand la compensation ne retient que **deux références**, leur `corr` vaut 0 (à 1e-13 près) : elle passe exactement par elles ; leur bruit s'imprime `0` et leurs écarts en bruits « - » ; ne lis rien dans ces valeurs, lis les références par `x`, `y` (`ensemble.py --rigide`) et `error_value`. Ses `x`, `y` restent : avant de citer un saut de `x`, `y`, regarde s'il est marqué `(rejetée)` ; une mesure rejetée ne se cite pas comme un mouvement. - -## La méthode - -1. **Inventaire** : ce qui est disponible, ce qui manque (fichiers, ce que contient chaque source, images, poses de la caméra, période, cadence, capteurs). Une colonne remplie que les outils ne montrent pas ou une source qu'aucun outil ne lit (`images_diff/`) reste une donnée : sache qu'elle existe. Les six colonnes de qualité d'image (`peak` à `snr`), remplies sur les caméras récentes, se lisent par `qualite.py`. `metrics/` se lit par `metriques.py` : une coupure des mesures se lit face aux pas sans métrique et à la tension (`--noms BusVoltage,BusCurrent,Power,BatteryPercent --metriques-seules` sur la coupure) ; des métriques toutes vides (« vide » sur chaque nom) sont une donnée absente, pas une température stable. Sur un lot, relance-le avec `--debut`/`--fin` du lot : les pas absents et les rejets du lot, datés ; ceux de la période entière ne disent rien du lot. Lis les rejets des **références** autant que ceux des cibles : un capteur rejeté aux mêmes heures chaque jour fait un moment à lui seul (dis sa part de mesures rejetées et ses heures, jour par jour) ; quand c'est une référence, dis avec combien de références la compensation tourne alors (la liste des références retenues). Quand plusieurs cibles sautent ensemble d'un pas, ou que la compensation tombe (pas de pose), regarde d'abord dans cette liste quelles références ont été perdues à cet instant. -2. **Large d'abord** : `ensemble.py` sur le lot, d'abord (sur un lot de plus de quelques jours, avec `--table non`, puis `--table T1/T2` sur les jours à lire) ; **la pose de la caméra en premier** (panneaux du haut, colonnes `cam_` de la table) : quand la caméra tourne (`pan`, `tilt`, `rotation`), change d'échelle (`scale`), quand son recalage se dégrade (`sigma0`) et quand elle n'est pas recalée (trait coupé, instants sans pose), datés au pas natif ; chaque moment des capteurs se lit ensuite face à elle : pendant un mouvement ou un trou de recalage, ou caméra immobile. La pose est calculée à partir des références globales : un changement de pose (ou une montée de `sigma0`) ne se lit comme un mouvement de la caméra que si **les cibles bougent aussi dans l'image** ; regarde, sur les panneaux `x`, `y`, les traits des références face au trait noir des cibles seules (et la colonne `x_cibles`, `y_cibles` de la table). Si seules des références bougent dans l'image et que les cibles restent immobiles, ce sont ces références qui ont bougé : la pose et les `corr` de toutes les cibles en sont faussés, sans mouvement brut des cibles ; dis quelles références et de combien. Si tout bouge ensemble, références et cibles, c'est la caméra ou la scène ; regarde alors si les `corr` reviennent. Dès que la pose tourne ou change d'échelle, l'écart à la médiane ne dit plus qui bouge seul (chaque capteur s'en écarte selon sa place dans l'image) : avant d'écrire « tout bouge ensemble », relance avec `--rigide BASE`, `BASE` un instant calme avant le premier mouvement, et lis le PNG **rigide** et sa table : une référence dont le résidu reste loin du 10e-90e centile des cibles, ou un `reproj_err` des références qui ne revient pas, veut dire que la compensation reste faussée par ces références et que les paliers de `corr` en viennent en partie ; dis lesquelles, de combien, jusqu'à quand ; un `|résidu|` des cibles qui monte dit qu'elles ne bougent pas comme un bloc. Puis la médiane de `x`, `y` (position brute, références comprises), les références une à une, les cibles seules et `sigma0` disent ce qui bouge dans l'image, avant de lire `corr` ; lis la table imprimée (heure, valeur) pour dater le début, la fin et le retour du mouvement et pour voir un niveau qui ne revient pas, et ne les devine pas sur l'axe du PNG : un creux de `corr` qui suit un mouvement de la médiane brute est le reste de la compensation, pas un mouvement propre des capteurs touchés ; les petits multiples d'`error_value` montrent un palier durable d'un capteur, le compte les instants où beaucoup de capteurs montent ensemble. Sur tout lot, sans attendre un soupçon, regarde les PNG **residus** (`corr_x`, `corr_y`, `error_value`) : chaque capteur face à son propre niveau, c'est là que se voient un capteur seul qui monte ou descend, un `corr` qui dérive de quelques centièmes, un palier propre à un capteur sous un mouvement commun ; la table dit de combien (en bruits) et quand. Pour séparer, sur une cible dont `corr` baisse sous un mouvement commun fort, un reste de compensation d'un mouvement propre, relance avec `--autres` (le reste partagé disparaît, la pente sur `x`, `y` commun dit s'il est proportionnel). Sur un lot de plus de deux jours, lance ensuite `jours.py` (avant de lire les pas isolés de `plages.py`) : ce qui revient chaque jour à la même heure se lit d'abord sur ses PNG **parheure** et sa table par créneau, et fait un moment par heure du jour (dis quels capteurs, combien de jours sur combien, l'ampleur, ce que fait la pose de la caméra à cette heure-là), pas un moment par jour ni rien du tout parce que chaque pas est court ; puis lis sa table des **niveaux de nuit**, pour tout capteur qui a déjà fait un palier ou dont `--hors` ne suffit pas (plusieurs niveaux dans le lot) : chaque marche d'une nuit à l'autre se date par son « entre A et B », et une marche d'`error_value` et une de `corr` au même instant se relient ; une dérive lente se lit d'une nuit à l'autre. Pour ce qui revient chaque jour et s'étiquette jour par jour (cycle thermique, réchauffement et refroidissement), relance `jours.py --bornes` plutôt que de fixer les mêmes heures pour tous les jours : chaque jour se date sur sa ligne, la suite autour de l'extrême pour le cycle, le max et le min pour un aller et un retour (le matin et l'après-midi) ; les mesures « avant » et « après » donnent les bornes au pas natif (à une cadence de 1 h ou de 4 h, un événement va de la mesure d'avant à celle d'après). Prends `--nuit` sur des heures où la pose et `error_value` sont retombées (figure **parheure**) : si le premier dépassement tombe au début du jour (« avant - ») et le dernier à sa fin chaque jour, la nuit choisie n'est pas calme ; change `--nuit` ou passe à `--capteurs` pour les cibles qui portent le cycle. Quand la caméra dérive toute la nuit, prends une nuit courte juste avant le matin (`--nuit 3-5` : le niveau est celui du repos qui précède le départ) ; sur une suite bruitée ou piquée de points isolés, ajoute `--lissage 5` ; quand le seuil en bruits ne mord pas (jamais dépassé, ou dépassé tout le jour), `--fraction 0.3` ; lis alors la suite autour de l'extrême, pas le premier et le dernier dépassement. Une ligne « 1 mesures » est un pic, pas un cycle. Quand celui qui t'appelle te donne plusieurs stations voisines, pose-les sur une même ligne de temps par `stations.py` (températures, poses, `corr` des cibles, rejets et trous communs, aux mêmes heures) avant de comparer leurs moments. Quand la pose ou les `corr` des cibles dérivent sur plusieurs jours, ou bougent sans cycle jour/nuit, lance `metriques.py` sur le lot : la température face à `cib_corr_x`, `cib_corr_y` et à la pose, sur le PNG, puis r et la pente ; sur une station où la température varie peu et vite (intérieur), relance avec `--lissage 24h`. Un r ne dit pas une cause : dis-le comme une valeur, avec la fenêtre où il est calculé. `--pas 1d --stat min` (ou `max`) donne le minimum ou le maximum de chaque jour. Sur une station qui a les métriques de qualité d'image, lance `qualite.py --commun --pas 1d` sur le lot (choix de la référence calme, voir Conventions), puis `qualite.py --figure` avec cette référence : la médiane du `flux` des cibles et des références date les heures de visibilité réduite, la bande grise qui plonge seule, les occultations ; avec un fichier d'étiquettes, `--etiquettes F --hors` donne les instants dégradés qu'aucune étiquette ne couvre. Puis `graphique.py` sur tous les capteurs, `error_value` puis `corr_x`, `corr_y` (ou `relative_x`, `relative_y`), références et cibles ; `resume.py` sur ces colonnes avec un pas large (6h ou 1d). -3. **Puis zoome** : `resume.py` à 15min (`--stat max` pour le pic réel d'un capteur), et `graphique.py` sur les fenêtres et les capteurs qui bougent. -4. **Chaque capteur face à son propre niveau habituel** (sa médiane et sa MAD), jamais à un seuil absolu ; sur un lot, le niveau se calcule sur le lot (`--niveau fenetre`, `ensemble.py`), pas sur la période entière. -5. **Chaque moment retenu se date et se mesure au pas natif de 15 min** : début, fin et maximum lus sur la table à 15 min (`ensemble.py` par défaut, `resume.py --pas 15min`), jamais sur un tableau à l'heure ; lis aussi `ensemble.py --min 1` pour les capteurs seuls, et `plages.py` sur le lot (d'abord avec `--min-mesures 6`) pour avoir, par capteur, début, fin, extrême et plus grand saut au pas natif (relance-le avec `--hors` autour d'un épisode long pour dater son retour au niveau, ne conclus pas « ne revient pas » sans l'avoir lu ; quand le lot a une dérive longue ou plusieurs paliers (les plages se comptent par centaines, ou une moitié du lot est « hors niveau »), relance-le avec `--glissant` (quelques mesures, ou une durée de quelques heures à un jour selon la cadence) et `--instants 2` : les écarts brefs sous la dérive sortent seuls, et la liste par instant dit quels capteurs s'écartent ensemble, lesquels sont rejetés et ce que font les références à cet instant ; un écart de toutes les cibles avec les références au même instant se lit face à la pose de la caméra), et les tables de `x`, `y` sur les fenêtres où ils s'agitent. Sur une station qui a les métriques de qualité, pour chaque moment : `qualite.py --table flux --capteurs …` (ou `--etiquettes F --numeros N --bords` sur une étiquette) dit quelles cibles sont cachées (flux coupé) ou voilées, de quel instant à quel instant ; écris-les par leur nom. -6. **Les images** : vignettes (avec `--contraste` pour une cible faible) espacées, une toutes les 2 à 3 h, plus serrées là où les courbes bougent, toujours avec un capteur témoin non touché, à une heure avant, pendant et après (à la même heure de la journée si possible) ; quand `x`, `y` d'un capteur sautent entre deux vignettes (centre du cadre écrit sous chacune), relance avec `--fixe` avant de dire qu'une tache apparaît ou disparaît ; l'image entière pour la scène (occultation, éclairage, météo). - -## Ce que la lecture rend - -Une ligne par moment. Un moment : un capteur ou un groupe de capteurs qui sort de son niveau habituel pendant une fenêtre que tu peux dater. - -| Début | Fin | Capteurs | Colonnes | Ce que je vois | Images | -|---|---|---|---|---|---| - -- **Capteurs** : références ou cibles, combien, lesquels. -- **Ce que je vois** : la forme (pic d'un pas, palier, montée lente, agitation), l'ampleur face au niveau habituel (en MAD ou en fois la médiane), le retour à la normale ou non, ce que font les autres capteurs, **ce que fait la caméra** au même moment (pose qui bouge, de combien, ou immobile ; recalage absent ; « pas de `camera/` » si le dossier n'en a pas). -- **Images** : ce que montrent les vignettes et l'image entière à ce moment, ou « pas d'image ». - -Heures en UTC. diff --git a/.gitignore b/.gitignore index e1eb2aa..e79ac27 100644 --- a/.gitignore +++ b/.gitignore @@ -7,3 +7,6 @@ labeling detectors .env /out/ +tools +agents +optimizer diff --git a/CLAUDE.md b/CLAUDE.md index 55a2c96..ee29d1c 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -1,19 +1,20 @@ # CLAUDE.md -Diagnostic-app : la web app de diagnostic AIMsight et les agents qu'elle lance par `claude -p` (`README.md`). Une caméra suit des cibles sur un ouvrage ; les détecteurs (`detectors/`, un lien vers le dépôt `~/detectors`, partagé avec Optimizer) lisent les séries de déplacement des stations (`data//`, un lien vers `~/aimsight-data/data`, rempli par le pompage de ce dépôt) et signalent les moments où il ne faut pas se fier aux courbes (pluie, buée, toile d'araignée, turbulence…) ou un vrai mouvement. +Diagnostic-app : le poste de pilotage du diagnostic AIMsight (`README.md`) : la web app, et le lancement de processus dont le code vit ailleurs. Une caméra suit des cibles sur un ouvrage ; les détecteurs lisent les séries de déplacement des stations et signalent les moments où il ne faut pas se fier aux courbes (pluie, buée, toile d'araignée, turbulence…) ou un vrai mouvement. L'architecture des dépôts : `docs/architecture.drawio`. -- **Les processus** : l'onglet Analysis lance l'`analyste` sur une plage (étiquettes et rapport dans `labeling/auto/analyses/__/`, versées dans `labeling/auto/.jsonl`) ; « Optimiser les détecteurs » lance `/detectors:wf-improve` sur la plage de l'analyse (le plugin du dépôt detectors, `claude --plugin-dir detectors` ; la requête dans `app/serveur/analyse.py`, son bilan dans `/detectors//summary.md`), qui commite dans `detectors/`, puis le `tool-builder`, qui commite les outils ici. -- **La vérité** : les étiquettes de `labeling/auto/` ; le savoir du labeling est dans `labeling/` (règles, familles, carte, connaissances). `labeling/` est un lien vers le dépôt `~/labeling`, partagé avec Optimizer : on y commite les étiquettes, pas ici. -- **Les détecteurs** : le contrat entre l'app et eux est dans `detectors/CLAUDE.md` (`categories.events`, la requête de `/detectors:wf-improve`, les CLI `--from/--to`) ; un renommage là-bas demande le changement ici. `agent-tools/donnees.py` et `detectors/scripts/data.py` lisent les mêmes mesures : une correction de lecture dans l'un se reporte dans l'autre. Un commit dans `detectors/` est un commit du dépôt `~/detectors` : rien à commiter ici, et Optimizer a aussitôt la même version. -- **Le benchmark** : `python3 detectors/skills/wf-improve/scripts/regression.py --labels labeling/auto --data data` (~3 min) ; le score d'une plage : `python3 detectors/skills/wf-improve/scripts/score.py data/ --labels labeling/auto/.jsonl --from AAAA-MM-JJ --to AAAA-MM-JJ` (`--to` exclu). +- **Les processus** : l'onglet Analysis lance `agents:analyste` (plugin `agents/`) sur une plage, avec `consignes/analyste.md` et `DETECTEURS : non` (étiquettes et rapport dans `labeling/auto/analyses/__/`, versées dans `labeling/auto/.jsonl`) ; « Optimiser les détecteurs » lance `/improve` dans `optimizer/` (sa requête dans `app/serveur/analyse.py`, son bilan dans `optimizer/seances/_/summary.md`), qui commite dans `detectors/`, puis `agents:tool-builder`, qui commite dans `tools/`. +- **Les liens** (ignorés par git, un exemplaire de chaque dépôt sur le poste) : `data/`, `labeling/`, `detectors/`, `tools/`, `agents/`, `optimizer/` ; on commite chaque chose dans son dépôt, jamais ici. Ce dépôt ne porte ni agent, ni outil de lecture, ni workflow. +- **La vérité** : les étiquettes de `labeling/auto/` ; le savoir du labeling est dans `labeling/`. +- **Les contrats** : avec les détecteurs, `detectors/CLAUDE.md` (`categories.events`, `bench/score.py`) ; avec les agents, `agents/README.md` (les requêtes de l'analyste et du tool-builder) ; avec Optimizer, `optimizer/README.md` (la requête de `/improve`). Un renommage là-bas demande le changement ici. +- **Le benchmark** : `python3 detectors/bench/regression.py --labels labeling/auto --data data` (~3 min) ; le score d'une plage : `python3 detectors/bench/score.py data/ --labels labeling/auto/.jsonl --from AAAA-MM-JJ --to AAAA-MM-JJ` (`--to` exclu). - **Le pompage** : dans `~/aimsight-data` (`extraction/pomper.sh`, tâches VS Code **pomper**, **pomper une plage**), en lecture seule sur la plateforme ; mode d'emploi `~/aimsight-data/extraction/README.md`. Claude peut le lancer sur de petites plages ; une longue plage ou un historique, hors des heures chargées. -- **Vérifier un changement de l'app** : `.venv/bin/python app/serveur/check.py`, puis `cd app/web && npm run build` et lancer le serveur. Les étiquettes : `python3 labeling/controle.py` (les 18 étiquettes versées par l'app n'ont pas encore `revue`, qu'elle exige : 18 erreurs attendues). +- **Vérifier un changement de l'app** : `.venv/bin/python app/serveur/check.py`, puis `cd app/web && npm run build` et lancer le serveur. Les étiquettes : `python3 labeling/controle.py`. Règles : - Toute heure est en UTC. -- Bibliothèque standard pour les détecteurs et les outils de lecture ; matplotlib par `.venv/bin/python`, pour les figures seulement. -- Pas de règle propre à une station, une cible ou une date dans les détecteurs. +- Pas de règle propre à une station, une cible ou une date. - Lecture seule sur `data/`, sauf le pompage ; ne jamais recopier les identifiants des métriques (`SIM_CCID`, `ip*`). - Ne jamais lire `.env` (les identifiants de la plateforme). +- Les agents tournent sur l'abonnement Claude, jamais sur une clé d'API. - Commits par chemin, jamais `git add -A` : une autre session peut travailler dans ce dépôt. - Langue : documents et échanges en français ; ce qui va au client en anglais. diff --git a/README.md b/README.md index dca92e9..b9ffa39 100644 --- a/README.md +++ b/README.md @@ -1,34 +1,39 @@ # Diagnostic-app -La web app de diagnostic AIMsight : la page Data (courbes, images de la caméra, étiquettes, événements des détecteurs) et son onglet Analysis, qui lance par `claude -p` : +Le poste de pilotage du diagnostic AIMsight : voir, analyser, lancer. La page Data montre les courbes, les images de la caméra, les étiquettes et les événements des détecteurs ; son onglet Analysis lance, par `claude -p`, des processus dont le code vit dans les autres dépôts : -- l'`analyste`, sur une plage choisie (« Analyser la plage ») : un rapport de diagnostic et des étiquettes ; -- « Optimiser les détecteurs », sur une analyse finie : `/detectors:wf-improve` (le plugin du dépôt detectors) améliore les détecteurs sur la plage de l'analyse, ses étiquettes pour vérité, sans sur-apprentissage, contrôlé par le benchmark de toutes les étiquettes ; puis le `tool-builder` fait entrer les scripts de l'analyste dans les outils de lecture. +- **« Analyser la plage »** : l'`analyste` du dépôt agents, sur une plage choisie, avec les consignes de l'app (`consignes/analyste.md`) et sans les détecteurs (`DETECTEURS : non`) : des étiquettes, versées dans `labeling/auto/`, et un rapport de diagnostic ; +- **« Optimiser les détecteurs »**, sur une analyse finie : `/improve` dans Optimizer améliore les détecteurs sur la plage de l'analyse, ses étiquettes pour vérité, sans sur-apprentissage ; puis le `tool-builder` du dépôt agents fait entrer les scripts de l'analyste dans le harnais de lecture (dépôt tools). + +L'architecture des dépôts, une responsabilité chacun : `docs/architecture.drawio`. ## Le dépôt - `app/` : la web app (serveur FastAPI, page React et Mantine) ; sa doc dans `app/README.md`. -- `.claude/` : les agents de l'app, `analyste` et `tool-builder`, et le skill `lire-les-donnees` (le mode d'emploi des outils de lecture). -- `agent-tools/` : les outils de lecture ; `donnees.py`, la lecture commune, sert aussi à l'app. -- `labeling/` : un lien vers le dépôt `~/labeling`, partagé avec Optimizer (on y commite les étiquettes) : le savoir du labeling (`regles-d-etiquetage.md`, `familles.md`, `carte-des-etiquettes.md`, `connaissances/`), les étiquettes (`auto/.jsonl`, la vérité du benchmark ; `manual/`), les analyses de l'app (`auto/analyses/`), et `controle.py`, `ids.py`. -- `detectors/` : un lien vers le dépôt **detectors** (`~/detectors`), partagé avec Optimizer (voir plus bas). -- `data/` : un lien vers `~/aimsight-data/data`, les données des stations, **hors de git**, un dossier par station (`displacement/`, `metrics/`, `camera/`, `images/`). +- `consignes/analyste.md` : ce que l'app demande à l'analyste (dossier de sortie, rapport, dialogue). +- `docs/` : l'architecture des dépôts, les plans. -## Les détecteurs (`detectors/`) +Et six liens, ignorés par git, vers les dépôts voisins (un seul exemplaire de chacun sur le poste) : -Le dépôt detectors : un détecteur par famille d'étiquettes (`scripts/`), `scripts/categories.py` qui les lance et range leurs épisodes en événements, et le plugin Claude Code qui les améliore (`/detectors:wf-improve`, avec `skills/wf-improve/scripts/score.py` et `regression.py`). Son contrat avec l'app est dans `detectors/CLAUDE.md` ; ici : +| Lien | Dépôt | Ce que l'app en fait | +|---|---|---| +| `data/` | `~/aimsight-data/data` | lit les données des stations (hors de git) | +| `labeling/` | `~/labeling` | lit et écrit les étiquettes ; les analyses vont dans `labeling/auto/analyses/` | +| `detectors/` | `~/detectors` | lit les événements des détecteurs (`scripts/categories.py`) | +| `tools/` | `~/tools` | lit les données par `tools/donnees.py` ; l'analyste s'en sert, le tool-builder y écrit | +| `agents/` | `~/agents` | le plugin des agents (`--plugin-dir agents`, `--agent agents:analyste`) | +| `optimizer/` | `~/Optimizer` | y lance `/improve` ; lit les bilans dans `optimizer/seances/` | -- la page Data montre les événements de `categories.events`, calculés sur les mesures lues par `agent-tools/donnees.py` (les mêmes que celles de `detectors/scripts/data.py`) ; -- « Optimiser les détecteurs » donne à `/detectors:wf-improve` la plage, les étiquettes (`labeling/auto/.jsonl`), la vérité de référence (`labeling/auto`, `data`), les familles (`labeling/familles.md`), le rapport de l'analyse et le dossier de sortie, `/detectors//` (la requête : `app/serveur/analyse.py`) ; -- la séance commite dans `detectors/`, donc dans le dépôt `~/detectors`, sur sa branche courante, sans pousser : Optimizer a aussitôt les nouveaux détecteurs. Pousser : `git -C detectors push`. - -Mettre à jour les détecteurs : `git -C detectors pull`. +On commite chaque chose dans son dépôt : les étiquettes dans `~/labeling`, les détecteurs dans `~/detectors` (la séance d'optimisation le fait, sans pousser), les outils dans `~/tools` (le tool-builder le fait). ## Installer et lancer -La tâche VS Code **Run app** crée `.venv` et construit le front s'ils manquent, puis lance le serveur. Il faut les liens vers les données, les étiquettes et les détecteurs : `ln -s ~/aimsight-data/data data`, `ln -s ~/labeling labeling` et `ln -s ~/detectors detectors` (les dépôts aimsight-data, labeling et detectors, clonés à côté). +```bash +ln -s ~/aimsight-data/data data && ln -s ~/labeling labeling && ln -s ~/detectors detectors +ln -s ~/tools tools && ln -s ~/agents agents && ln -s ~/Optimizer optimizer +``` -À la main : +La tâche VS Code **Run app** crée `.venv` et construit le front s'ils manquent, puis lance le serveur. À la main : ```bash python3 -m venv .venv && .venv/bin/pip install -r app/requirements.txt @@ -36,7 +41,7 @@ cd app/web && npm install && npm run build && cd ../.. .venv/bin/python app/serveur/serveur.py ``` -La page s'ouvre sur `http://127.0.0.1:8770`. `claude` (Claude Code, connecté) doit être sur le `PATH` pour l'onglet Analysis. +La page s'ouvre sur `http://127.0.0.1:8770`. `claude` (Claude Code, connecté à l'abonnement) doit être sur le `PATH` pour l'onglet Analysis. ## Pomper les données @@ -45,5 +50,5 @@ Le pompage est dans le dépôt `~/aimsight-data` (`extraction/`, tâches VS Code ## Vérifier - l'app : `.venv/bin/python app/serveur/check.py` ; -- les étiquettes : `python3 labeling/controle.py` (les 18 étiquettes versées par l'app n'ont pas encore `revue`, qu'elle exige : 18 erreurs attendues) ; -- les détecteurs (benchmark, ~3 min) : `python3 detectors/skills/wf-improve/scripts/regression.py --labels labeling/auto --data data`. +- les étiquettes : `python3 labeling/controle.py` (les étiquettes versées par l'app n'ont pas encore `revue`, qu'elle exige : autant d'erreurs attendues) ; +- les détecteurs (benchmark, ~3 min) : `python3 detectors/bench/regression.py --labels labeling/auto --data data`. diff --git a/agent-tools/donnees.py b/agent-tools/donnees.py deleted file mode 100644 index cdae427..0000000 --- a/agent-tools/donnees.py +++ /dev/null @@ -1,162 +0,0 @@ -"""Lecture des données d'une station pour l'agent de diagnostic (bibliothèque standard). - -Formats : labeling/connaissances/colonnes-des-deplacements.md. Toute heure est en UTC. -""" -import csv -import glob -import os -import re -import statistics -from datetime import datetime, timezone - -# Colonnes numériques de l'export « advanced » ; une case vide devient None. -NUM = ("x", "y", "error_value", "error_threshold", "relative_x", "relative_y", - "corr_x", "corr_y", "reproj_err", "inlier", "sigma0", - "peak", "flux", "sharpness", "fwhm", "dominance", "snr") # qualité de l'image : caméras récentes seulement (LENZSPITZE) -# Pose de la caméra (camera/, pompage) : pan, tilt, rotation [deg], scale, sigma0 (résidu du recalage). -POSE = ("pan", "tilt", "rotation", "scale", "sigma0") -IMAGE_RE = re.compile(r"^(\d{8}T\d{4})Z_") - - -def _entete(chemin): - with open(chemin, newline="") as f: - return next(csv.reader(f), []) - - -def trouver(dossier): - """Dossier de station -> {'advanced', 'horaire', 'camera', 'images', 'autres'} : chemins triés, sous-dossiers compris.""" - out = {"advanced": [], "horaire": [], "camera": [], "images": [], "autres": []} - for p in sorted(glob.glob(os.path.join(dossier, "**", "*"), recursive=True)): - if os.path.isdir(p) or "images_diff" in p.split(os.sep): # images différentielles du pompage (--diff) : pas des vues de la caméra - continue - entete = _entete(p) if p.endswith(".csv") else [] - if p.lower().endswith((".jpg", ".jpeg", ".png")): - out["images"].append(p) - elif "sensor_name" in entete and "corr_x" in entete: # quality/ (optical_emulator) a sensor_name, pas corr_x - out["advanced"].append(p) - elif "timestamp" in entete: - out["horaire"].append(p) - elif "median_pan" in entete: - out["camera"].append(p) - else: - out["autres"].append(p) - return out - - -def _nombre(v): - v = v.strip() - return float(v) if v else None - - -def charger(dossier): - """Exports « advanced » du dossier -> {capteur: [mesure]}, triées par t, un seul relevé par instant. - - Mesure : dict avec t (datetime UTC), pattern_type, et les colonnes de NUM (float ou None). - Une mesure rejetée (voir rejetee) a corr_x, corr_y vides, comme le dit la doc des colonnes : la station - les vide pour une cible, mais en laisse de remplis (souvent absurdes) pour une référence ; on les vide ici. - """ - par = {} - for chemin in trouver(dossier)["advanced"]: - with open(chemin, newline="") as f: - for r in csv.DictReader(f): - m = {c: _nombre(r.get(c) or "") for c in NUM} # inlier manque dans les exports anciens - m["t"] = instant(r["time_utc"]) - m["pattern_type"] = r["pattern_type"] - if rejetee(m): - m["corr_x"] = m["corr_y"] = None - par.setdefault(r["sensor_name"].strip(), {})[m["t"]] = m # certains exports finissent le nom par un saut de ligne - return {s: [d[t] for t in sorted(d)] for s, d in par.items()} - - -def charger_temperature(dossier): - """Températures de la carte de la station (metrics/, sensor_*_deg_c) -> [(t, °C)] triées : la médiane des composants à - chaque heure ; [] sans ces métriques. Les composants montent et descendent ensemble (l'étiqueteur lit « les - températures de tous les composants ») ; la médiane écarte la pointe d'un seul, le GPU qui calcule (D-124).""" - par = {} - for chemin in glob.glob(os.path.join(dossier, "metrics", "*_deg_c_*.csv")): - with open(chemin, newline="") as f: - for r in csv.DictReader(f): - if (v := _nombre(r.get("metric") or "")) is not None: - par.setdefault(instant(r["time_utc"]), []).append(v) - return [(t, statistics.median(v)) for t, v in sorted(par.items())] - - -def charger_camera(dossier): - """Mouvements de la caméra du dossier -> [pose] triées par t ; pose : t et les colonnes de POSE (float ou None). - - Une ligne par recalage de la caméra ; on lit les médianes (min = max dans les fichiers reçus : une mesure par minute). - Un instant de mesure sans pose : la caméra n'a pas été recalée. - """ - par = {} - for chemin in trouver(dossier)["camera"]: - with open(chemin, newline="") as f: - for r in csv.DictReader(f): - p = {c: _nombre(r.get("median_" + c, "")) for c in POSE} - p["t"] = instant(r["time_utc"]) - par[p["t"]] = p - return [par[t] for t in sorted(par)] - - -IDENTIFIANTS = re.compile(r"^(SIM_CCID|ip(_.*)?)$") # identifiants de la station : jamais lus -METRIQUE_RE = re.compile(r"^(.+?)_\d{4}_\d{2}_\d{2}_") - - -def charger_metriques(dossier): - """Métriques de la station (metrics/, un CSV par métrique et par jour) -> {nom: [(t, valeur)]} triées : les - valeurs numériques seulement (BusVoltage, sensor_CPU_deg_c, rsrp_dBm…) ; les métriques texte (link, mode…) et les - identifiants (SIM_CCID, ip*) ne sont pas lus. Nom : celui du fichier, sans la station ni la date.""" - # ponytail: les métriques texte sont sautées ; les lire (link up/down) quand un détecteur en a besoin - station, par = os.path.basename(os.path.normpath(dossier)) + "_", {} - for chemin in glob.glob(os.path.join(dossier, "metrics", "*.csv")): - if not (m := METRIQUE_RE.match(os.path.basename(chemin))): - continue - nom = m.group(1).removeprefix(station) - if IDENTIFIANTS.match(nom): - continue - with open(chemin, newline="") as f: - for r in csv.DictReader(f): - try: - v = float((r.get("metric") or "").strip("[]'\" ")) # certaines métriques arrivent en liste : ['-95'] - except ValueError: - continue - par.setdefault(nom, {})[instant(r["time_utc"])] = v - return {n: sorted(d.items()) for n, d in sorted(par.items())} - - -def est_reference(mesures): - """Référence du réseau de compensation (pattern_type global_ref), sinon cible. Certains exports ont pattern_type vide, - sur toute la période ou au début : on lit alors le premier pattern_type rempli et, s'il n'y en a aucun, reproj_err - ou inlier remplis (références seulement : labeling/connaissances/colonnes-des-deplacements.md).""" - t = next((m["pattern_type"] for m in mesures if m["pattern_type"]), None) - if t is not None: - return t == "global_ref" - return any(m["reproj_err"] is not None or m["inlier"] is not None for m in mesures) - - -def rejetee(m): - """Mesure rejetée par la station : error_value au-dessus du seuil du capteur (error_threshold) ; sans ces deux valeurs, corr_x vide.""" - if m["error_value"] is not None and m["error_threshold"] is not None: - return m["error_value"] > m["error_threshold"] - return m["corr_x"] is None - - -def filtrer(mesures, debut, fin): - """Mesures entre debut et fin inclus, à la minute près (comme iso() les affiche) ; None = pas de borne.""" - return [m for m in mesures if (debut is None or m["t"] >= debut) - and (fin is None or m["t"].replace(second=0, microsecond=0) <= fin)] - - -def heure_image(chemin): - """'20261013T1200Z_10167931.jpg' -> datetime UTC ; None si le nom ne suit pas ce format (D-045).""" - m = IMAGE_RE.match(os.path.basename(chemin)) - return datetime.strptime(m.group(1), "%Y%m%dT%H%M").replace(tzinfo=timezone.utc) if m else None - - -def instant(texte): - """'2026-01-01T00:00Z' ou '2026-01-01 00:00' -> datetime UTC ; une heure sans fuseau est lue en UTC.""" - t = datetime.fromisoformat(texte) - return t.astimezone(timezone.utc) if t.tzinfo else t.replace(tzinfo=timezone.utc) - - -def iso(t): - return t.astimezone(timezone.utc).strftime("%Y-%m-%dT%H:%MZ") diff --git a/agent-tools/ensemble.py b/agent-tools/ensemble.py deleted file mode 100644 index e9622b5..0000000 --- a/agent-tools/ensemble.py +++ /dev/null @@ -1,491 +0,0 @@ -"""Vue d'ensemble de tous les capteurs d'un export « advanced » : ce que font les capteurs ensemble. - -Usage : .venv/bin/python agent-tools/ensemble.py data/PS_DES_COUDRES/ - [--colonnes x,y,sigma0] [--colonne error_value] [--pas 15min] [--k 5] [--min 5] - [--residus corr_x,corr_y,error_value] [--hors T1/T2] [--autres] [--rigide BASE [--sans A,B] [--suivre A,B]] [--table T1/T2|non] [--capteurs A,B] [--debut ...] [--fin ...] [--sortie DOSSIER] - -Chaque capteur est comparé à son propre niveau sur la fenêtre --debut/--fin (médiane et MAD de la fenêtre). -Deux PNG, dont les chemins sont imprimés : -1. « commun » : d'abord, si le dossier a des mouvements de la caméra (camera/), un panneau par grandeur de la pose - (pan, tilt, rotation [deg], scale, sigma0 du recalage), valeurs brutes, un point par recalage ; puis un panneau par colonne de --colonnes (défaut x,y,sigma0 : position brute et sigma0 de la - caméra) : médiane, sur les capteurs, de l'écart de chaque capteur à sa médiane ; bande grise = 10e à 90e - centile entre capteurs (la dispersion) ; sur chaque panneau sauf sigma0, en plus, chaque référence globale à part - (son écart à sa médiane, un trait par référence) et la médiane des cibles seules (trait noir) : on voit si les - références bougent dans l'image avec les cibles ou sans elles ; dernier panneau : nombre de capteurs dont --colonne - (défaut error_value) dépasse sa médiane de plus de --k MAD à chaque pas. -2. « multiples » : un petit graphique par capteur (références d'abord) de --colonne, médiane par pas de --pas, - trait pointillé = médiane de la fenêtre ; chaque graphique a son échelle, un palier se voit. -3. « residus- » (un PNG par colonne de --residus, défaut corr_x,corr_y,error_value) : un petit graphique par - capteur de la colonne moins le niveau propre du capteur (sa médiane sur la fenêtre, ou hors de --hors T1/T2 si - donné : le niveau est alors celui du reste de la fenêtre, pas celui du moment lu), une échelle par capteur, zéro en - pointillé ; un écart de quelques centièmes sur une colonne `corr` que les bandes parallèles de `graphique.py` cachent - s'y voit. Imprime, par capteur, le niveau, le bruit propre (médiane des écarts entre deux mesures consécutives) et - l'écart minimum et maximum de la médiane par pas de --pas, avec leur instant, en unités de la colonne et en bruits - (bruit 0 et « - » en bruits : valeurs constantes à l'arrondi près, 1e-9 ; --residus non : aucun PNG de résidus). - Avec --autres, chaque capteur est de plus ramené à l'écart à la médiane des AUTRES capteurs au même instant (on - retranche, à chaque mesure, la médiane des autres capteurs de la même colonne moins leur niveau propre) : ce qui est - partagé par tous (le reste de la compensation d'un mouvement commun) s'annule, ce qui est propre au capteur reste. - PNG « residus--autres » ; la table imprime en plus, par capteur, la pente de ce résidu sur chaque - colonne de --colonnes (médiane commune, ex. y) et la corrélation r : un résidu proportionnel au mouvement commun - (même s'il n'est pas partagé par tous) a une pente non nulle et un r élevé. -4. « rigide » (avec --rigide BASE) : à chaque mesure, le mouvement d'ensemble des cibles depuis l'instant BASE - (similitude : translation, rotation, échelle, estimée par médianes sur les cibles, hors --sans) ; pour chaque - capteur, le résidu dx, dy = position brute moins sa position à BASE transportée par ce mouvement [px]. Panneaux : - dx et dy de chaque référence globale (un trait chacune) face à la médiane et au 10e-90e centile des cibles ; - médiane et 90e centile de |résidu| des cibles ; rotation et échelle ajustées ; reproj_err des références. Imprime - la table par pas de --pas (rot_deg, echelle, tx, ty, cib_med, cib_max, puis dx, dy de chaque référence et de chaque - capteur de --suivre A,B), puis par capteur le min et le max de dx, dy avec leur instant et la valeur au dernier - instant. Les mesures rejetées n'entrent ni dans l'ajustement, ni dans la bande et la médiane des cibles, cib_med, - cib_max, ni dans les colonnes de la table ; sur le PNG, celles des références sont des croix, qui ne fixent pas l'échelle ; dans le résumé par - capteur, elles viennent à part (nombre, min et max). -Imprime aussi la table de la médiane commune (une ligne par pas de --pas : heure, écart à la médiane de la fenêtre -pour chaque colonne de --colonnes, puis _cibles, la médiane des cibles seules, puis la pose brute de la caméra, vide sans recalage) puis le minimum et le maximum de chaque colonne avec leur instant, et ceux de chaque référence globale ; pour dater -un début ou une fin, la table est au pas de --pas (défaut 15min, la cadence des mesures ; un pas plus large, -1h par ex., aplatit un pic d'un à quatre pas et date à l'heure). -Imprime aussi, pour chaque instant où au moins --min capteurs dépassent leur médiane de plus de --k MAD, -le nombre et les capteurs (--min 1 : aussi les instants où un seul capteur sort de son niveau), et les instants de -mesure sans pose de la caméra (pas de recalage). -Les tables par pas (médiane commune, --rigide) répètent leur en-tête toutes les 24 lignes. Avec --table T1/T2, elles ne -s'impriment qu'entre T1 et T2 (« non » : pas du tout) ; niveaux, minimum et maximum, PNG et le reste portent toujours sur -toute la fenêtre --debut/--fin : sur un mois, on lit tout le reste, puis la table d'un jour aux mêmes niveaux. -Rend des valeurs, pas de verdict. -""" -import argparse -import math -import os -import statistics -import sys - -import matplotlib - -matplotlib.use("Agg") -import matplotlib.dates as mdates # noqa: E402 -import matplotlib.pyplot as plt # noqa: E402 - -from donnees import POSE, charger, charger_camera, est_reference, filtrer, instant, iso, rejetee # noqa: E402 -from graphique import COLONNES, RACINE, borne # noqa: E402 -from resume import bruit_propre, duree # noqa: E402 - - -def niveau(ms, col): - """(médiane, MAD) des valeurs non vides ; None si aucune.""" - v = [m[col] for m in ms if m[col] is not None] - if not v: - return None - med = statistics.median(v) - return med, statistics.median(abs(x - med) for x in v) - - -def similitude(p, q): - """Similitude (a, b, tx, ty) qui envoie les points p sur q : q ≈ (a·x − b·y + tx, b·x + a·y + ty). - - Estimation par médianes (une cible qui saute seule ne tire pas l'ajustement) : rotation et échelle, médiane sur - toutes les paires de cibles du rapport complexe (qi − qj) / (pi − pj) ; translation, médiane de q − (rotation, échelle)·p. - """ - p, q = [complex(*u) for u in p], [complex(*u) for u in q] - z = [(q[i] - q[j]) / (p[i] - p[j]) for i in range(len(p)) for j in range(i) if p[i] != p[j]] - r = complex(statistics.median(v.real for v in z), statistics.median(v.imag for v in z)) - d = [w - r * u for u, w in zip(p, q)] - return r.real, r.imag, statistics.median(v.real for v in d), statistics.median(v.imag for v in d) - - -def rigide(o, noms, series, temps, base, station): - """4. Chaque capteur face au mouvement d'ensemble des cibles depuis l'instant --rigide : PNG « rigide » et table.""" - t_b = min(temps, key=lambda t: abs(t - o.rigide)) - pos = {s: {m["t"]: (m["x"], m["y"]) for m in series[s] if m["x"] is not None and m["y"] is not None} for s in noms} - sans = set(o.sans.split(",")) - {""} - acc = {s: {m["t"] for m in series[s] if not rejetee(m)} for s in noms} # mesures acceptées : seules à entrer dans l'ajustement et les statistiques des cibles - refs = [s for s in noms if series[s] and est_reference(series[s])] - cib = [s for s in noms if s not in refs and t_b in pos[s]] - ajust = [s for s in cib if s not in sans and t_b in acc[s]] - suivis = [s for s in o.suivre.split(",") if s and s not in refs] - res, fit = {s: {} for s in noms}, {} # res : {capteur: {t: (dx, dy)}} ; fit : {t: (rotation deg, échelle, tx, ty, |r| médiane, max des cibles)} - for t in temps: - ok = [s for s in ajust if t in pos[s] and t in acc[s]] - if len(ok) < 2: - continue - a, b, tx, ty = similitude([pos[s][t_b] for s in ok], [pos[s][t] for s in ok]) - for s in noms: - if t in pos[s] and t_b in pos[s]: - (x0, y0), (x, y) = pos[s][t_b], pos[s][t] - res[s][t] = (x - (a * x0 - b * y0 + tx), y - (b * x0 + a * y0 + ty)) - r = [math.hypot(*res[s][t]) for s in cib if t in res[s] and t in acc[s]] - fit[t] = (math.degrees(math.atan2(b, a)), math.hypot(a, b), tx, ty, statistics.median(r), max(r)) - if not fit: - print(f"\n--rigide : moins de deux cibles avec x, y à {iso(t_b)} et ensuite.") - return - tf = sorted(fit) - reproj = {s: {m["t"]: m["reproj_err"] for m in series[s] if m["reproj_err"] is not None} for s in refs} - panneaux = [("dx", 0), ("dy", 1)] - fig, axes = plt.subplots(6, 1, sharex=True, figsize=(14, 18), squeeze=False) - for ax, (nom, k) in zip(axes[:2, 0], panneaux): - band = [sorted(res[s][t][k] for s in cib if t in res[s] and t in acc[s]) for t in tf] - q = [statistics.quantiles(v, n=10, method="inclusive") if len(v) >= 2 else [v[0]] * 9 for v in band] - ax.fill_between(tf, [x[0] for x in q], [x[-1] for x in q], color="0.85", label="cibles : 10e-90e centile") - ax.plot(tf, [statistics.median(v) for v in band], "-", lw=1.2, color="k", label="cibles : médiane") - for i, s in enumerate(refs): - ta = [t for t in res[s] if t in acc[s]] - ax.plot(ta, [res[s][t][k] for t in ta], "-", lw=0.9, color=f"C{(i + 1) % 10}", label=f"{s} (réf.)") - cadre = ax.get_ylim() # l'échelle des mesures acceptées : une référence rejetée loin est hors cadre - for i, s in enumerate(refs): - tr = [t for t in res[s] if t not in acc[s]] - if tr: # mesures rejetées : à part, une croix chacune, hors du trait - ax.plot(tr, [res[s][t][k] for t in tr], "x", ms=3, color=f"C{(i + 1) % 10}", label=f"{s} rejetée") - ax.set_ylim(cadre) - ax.set_ylabel(f"{nom} [px]\nposition brute moins\nle mouvement des cibles") - ax.legend(loc="upper left", fontsize=8, ncol=1 + len(refs) // 4) - axes[2, 0].plot(tf, [fit[t][4] for t in tf], "-", lw=1, color="k", label="cibles : médiane de |résidu|") - p90 = {t: statistics.quantiles([math.hypot(*res[s][t]) for s in cib if t in res[s] and t in acc[s]], n=10, method="inclusive")[-1] for t in tf} - axes[2, 0].plot(tf, [p90[t] for t in tf], "-", lw=0.8, color="C3", label="cibles : 90e centile de |résidu| (le max est dans la table)") - axes[2, 0].set_ylabel("|résidu| des cibles [px]") - axes[2, 0].legend(loc="upper left", fontsize=8) - axes[3, 0].plot(tf, [fit[t][0] for t in tf], "-", lw=1, color="C2") - axes[3, 0].set_ylabel("rotation ajustée [deg]") - axes[4, 0].plot(tf, [fit[t][1] for t in tf], "-", lw=1, color="C2") - axes[4, 0].set_ylabel("échelle ajustée") - for i, s in enumerate(refs): - axes[5, 0].plot(list(reproj[s]), list(reproj[s].values()), "-", lw=0.9, color=f"C{(i + 1) % 10}", label=f"{s} (réf.)") - axes[5, 0].set_ylabel("reproj_err\ndes références") - if refs: - axes[5, 0].legend(loc="upper left", fontsize=8, ncol=1 + len(refs) // 4) - for ax in axes[:, 0]: - ax.grid(alpha=0.4) - ax.axvline(t_b, color="C3", ls=":", lw=0.8) - axes[-1, 0].set_xlim(tf[0], tf[-1]) - axes[-1, 0].xaxis.set_major_formatter(mdates.DateFormatter("%d/%m\n%H:%MZ")) - fig.suptitle(f"{station} : mouvement d'ensemble (translation, rotation, échelle) ajusté sur {len(ajust)} cibles depuis {iso(t_b)} (pointillé), " - "résidu de chaque capteur, mesures acceptées (croix : référence rejetée) (heures UTC)") - fig.tight_layout(rect=(0, 0, 1, 1 - 0.4 / fig.get_figheight())) - chemin = base.format("rigide") - fig.savefig(chemin, dpi=100, bbox_inches="tight") - plt.close(fig) - print(chemin) - - print(f"\nMouvement d'ensemble ajusté sur les cibles depuis {iso(t_b)} : {', '.join(ajust)}" - + (f" (hors ajustement : {', '.join(sorted(sans & set(cib)))})" if sans & set(cib) else "") - + f".\nRésidu = position brute moins la position de {iso(t_b)} transportée par ce mouvement [px] ; mesures rejetées hors de l'ajustement, " - f"de cib_med, cib_max et des colonnes des capteurs (à part dans le résumé par capteur) ; médiane par pas de {int(o.pas.total_seconds() // 60)} min{' (table : ' + o.table + ')' if o.table else ''} :") - cols = ["rot_deg", "echelle", "tx", "ty", "cib_med", "cib_max"] + [f"{s}_{c}" for s in refs + suivis for c in ("dx", "dy")] - minuit = tf[0].replace(hour=0, minute=0, second=0, microsecond=0) - t0 = minuit + ((tf[0] - minuit) // o.pas) * o.pas - par_pas = {} - for t in tf: - ligne = par_pas.setdefault(t0 + ((t - t0) // o.pas) * o.pas, {}) - for c, v in zip(cols, fit[t]): - ligne.setdefault(c, []).append(v) - for s in refs + suivis: - if t in res[s] and t in acc[s]: - ligne.setdefault(f"{s}_dx", []).append(res[s][t][0]), ligne.setdefault(f"{s}_dy", []).append(res[s][t][1]) - w = max(10, max(len(c) for c in cols) + 1) - entete = f"{'instant':17}" + "".join(f"{c:>{w}}" for c in cols) - for i, t in enumerate(t for t in sorted(par_pas) if o.dans_table(t)): - if i % 24 == 0: - print(entete) - print(f"{iso(t):17}" + "".join(f"{statistics.median(par_pas[t][c]):{w}.{7 if c == 'echelle' else 3}g}" if c in par_pas[t] else " " * w for c in cols)) - print("\nPar capteur, mesures acceptées : min et max de dx, dy, valeur au dernier instant ; puis les rejetées à part :") - for s in noms: - bons = {t: v for t, v in res[s].items() if t in acc[s]} - rej = {t: v for t, v in res[s].items() if t not in acc[s]} - for k, c in ((0, "dx"), (1, "dy")): - ligne = f"{s:9}{' (réf.)' if s in refs else ' '} {c}" - if bons: - lo, hi = min(bons.items(), key=lambda x: x[1][k]), max(bons.items(), key=lambda x: x[1][k]) - der = res[s].get(tf[-1]) - ligne += (f" min {lo[1][k]:+.3g} à {iso(lo[0])}, max {hi[1][k]:+.3g} à {iso(hi[0])}, au dernier instant " - f"{der[k] if der else math.nan:+.3g}{' (rejetée)' if der and tf[-1] not in acc[s] else ''}") - else: - ligne += " aucune mesure acceptée" - if rej: - lo, hi = min(rej.items(), key=lambda x: x[1][k]), max(rej.items(), key=lambda x: x[1][k]) - ligne += f" ; {len(rej)} rejetées : min {lo[1][k]:+.3g} à {iso(lo[0])}, max {hi[1][k]:+.3g} à {iso(hi[0])}" - if bons or rej: - print(ligne) - - -def main(): - a = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) - a.add_argument("dossier") - a.add_argument("--colonnes", default="x,y,sigma0") - a.add_argument("--colonne", default="error_value", choices=COLONNES) - a.add_argument("--pas", default="15min", type=duree, help="pas des tables et des courbes en bleu (défaut 15min, la cadence des mesures : un pas plus large aplatit et décale les événements courts)") - a.add_argument("--k", type=float, default=5, help="écart compté, en MAD de la fenêtre") - a.add_argument("--min", type=int, default=5, help="nombre de capteurs à partir duquel un instant est imprimé") - a.add_argument("--residus", default="corr_x,corr_y,error_value", help="colonnes tracées moins le niveau propre de chaque capteur (« non » ou '' : aucune)") - a.add_argument("--hors", help="T1/T2 : le niveau propre des résidus se calcule hors de ce moment") - a.add_argument("--autres", action="store_true", help="résidus de plus ramenés à la médiane des autres capteurs au même instant, avec pente et corrélation sur le mouvement commun") - a.add_argument("--rigide", type=instant, metavar="BASE", help="résidus face au mouvement d'ensemble des cibles (translation, rotation, échelle) depuis l'instant BASE") - a.add_argument("--sans", default="", help="A,B : cibles laissées hors de l'ajustement de --rigide (leur résidu reste tracé)") - a.add_argument("--suivre", default="", help="A,B : avec --rigide, dx, dy de ces capteurs ajoutés à la table au pas (les références y sont déjà)") - a.add_argument("--table", default="", metavar="T1/T2|non", - help="tables par pas imprimées seulement entre T1 et T2 (« non » : pas du tout) ; le reste sur toute la fenêtre") - a.add_argument("--capteurs", help="liste séparée par des virgules (défaut : tous)") - a.add_argument("--debut", type=instant) - a.add_argument("--fin", type=instant) - a.add_argument("--sortie", default=os.path.join(RACINE, "out", "diagnostic"), help="dossier des PNG") - o = a.parse_args() - - par = charger(o.dossier) - if not par: - sys.exit(f"Aucun export « advanced » dans {o.dossier} (voir inventaire.py).") - noms = o.capteurs.split(",") if o.capteurs else sorted(par, key=lambda s: (not est_reference(par[s]), s)) - colonnes = o.colonnes.split(",") - residus = [c for c in o.residus.split(",") if c and c != "non"] # '' ou « non » : aucune, comme --table - hors = tuple(instant(x) for x in o.hors.split("/")) if o.hors else None - if hors and len(hors) != 2: - sys.exit("--hors attend T1/T2.") - if o.table in ("", "non"): - o.dans_table = lambda t: o.table == "" - else: - bornes = [instant(x) for x in o.table.split("/")] - if len(bornes) != 2: - sys.exit("--table attend T1/T2 ou non.") - o.dans_table = lambda t: bornes[0] <= t <= bornes[1] - for demandes, connus, quoi in ((noms, par, "Capteurs"), ([s for s in o.suivre.split(",") if s], noms, "Capteurs de --suivre (pris parmi --capteurs)"), (colonnes + residus + [o.colonne], COLONNES, "Colonnes")): - absents = [x for x in demandes if x not in connus] - if absents: - sys.exit(f"{quoi} inconnus : {', '.join(absents)}. Connus : {', '.join(sorted(connus))}.") - series = {s: filtrer(par[s], o.debut, o.fin) for s in noms} - if not any(series.values()): - sys.exit("Aucune mesure dans la fenêtre demandée.") - temps = sorted({m["t"] for s in noms for m in series[s]}) - poses = filtrer(charger_camera(o.dossier), temps[0].replace(second=0, microsecond=0), temps[-1]) # poses à la minute, mesures à la seconde - pose_cols = POSE if poses else () - station = os.path.basename(os.path.normpath(o.dossier)) - os.makedirs(o.sortie, exist_ok=True) - base = os.path.join(o.sortie, f"{station}_{{}}_{borne(o.debut, 'debut')}_{borne(o.fin, 'fin')}.png") - - def ecarts(col): - """{capteur: {t: valeur - médiane de la fenêtre}}, et les MAD.""" - e, mad = {}, {} - for s in noms: - n = niveau(series[s], col) - if n: - e[s] = {m["t"]: m[col] - n[0] for m in series[s] if m[col] is not None} - mad[s] = n[1] - return e, mad - - # 1. commun - n_ax = len(pose_cols) + len(colonnes) + 1 - fig, axes = plt.subplots(n_ax, 1, sharex=True, figsize=(14, 3 * n_ax), squeeze=False) - for ax, col in zip(axes[:, 0], pose_cols): - pose_t = {p["t"].replace(second=0, microsecond=0): p[col] for p in poses if p[col] is not None} - cam_t = sorted(set(pose_t) | {t.replace(second=0, microsecond=0) for t in temps}) - # trait coupé aux instants de mesure sans recalage : il ne relie pas deux poses par-dessus un trou - ax.plot(cam_t, [pose_t.get(t, math.nan) for t in cam_t], ".-", ms=3, lw=0.5, color="C2", label="pose de la caméra (un point par recalage)") - ax.set_ylabel(f"caméra : {col}" + (" [deg]" if col in ("pan", "tilt", "rotation") else "")) - ax.legend(loc="upper left", fontsize=8) - communes, refs_par_col, ref_ecarts = {}, {}, {} - for ax, col in zip(axes[len(pose_cols):, 0], colonnes): - e, _ = ecarts(col) - med, bas, haut, tt = [], [], [], [] - for t in temps: - v = sorted(e[s][t] for s in e if t in e[s]) - if len(v) >= 2: - q = statistics.quantiles(v, n=10, method="inclusive") - tt.append(t), med.append(statistics.median(v)), bas.append(q[0]), haut.append(q[-1]) - communes[col] = dict(zip(tt, med)) - ax.fill_between(tt, bas, haut, color="0.85", label="10e-90e centile entre capteurs") - ax.plot(tt, med, ".-", ms=2, lw=0.8, label="médiane des capteurs") - refs = [s for s in e if est_reference(series[s])] - if refs and col != "sigma0": # sigma0 est le même pour tous : rien à séparer - # références globales une à une, et médiane des seules cibles : qui bouge dans l'image, les références ou tout - cib = {} - for t in temps: - v = [e[s][t] for s in e if s not in refs and t in e[s]] - if v: - cib[t] = statistics.median(v) - communes[col + "_cibles"] = cib - ax.plot(list(cib), list(cib.values()), "-", lw=1.2, color="k", label="médiane des cibles seules") - for i, s in enumerate(refs): - ax.plot(list(e[s]), list(e[s].values()), "-", lw=0.9, color=f"C{(i + 1) % 10}", label=f"{s} (réf.)") - refs_par_col[col] = refs - ref_ecarts[col] = {s: e[s] for s in refs} - ax.set_ylabel(f"{col}\nécart à sa médiane") - ax.grid(alpha=0.3) - ax.legend(loc="upper left", fontsize=8, ncol=1 + len(refs_par_col.get(col, [])) // 4) - e, mad = ecarts(o.colonne) - compte, qui = [], {} - for t in temps: - hauts = [s for s in e if t in e[s] and mad[s] > 0 and e[s][t] > o.k * mad[s]] - compte.append(len(hauts)) - if len(hauts) >= o.min: - qui[t] = hauts - axes[-1, 0].step(temps, compte, where="mid", lw=0.8) - axes[-1, 0].set_ylabel(f"capteurs au-dessus\nde médiane + {o.k:g} MAD\n({o.colonne})") - axes[-1, 0].grid(alpha=0.3) - h = next((h for h in (1, 2, 3, 6, 12) if (temps[-1] - temps[0]).total_seconds() / 3600 / h <= 20), 24) - jours = (temps[-1] - temps[0]).total_seconds() / 86400 - # au-delà de 20 jours, une graduation par jour se chevauche : tous les n jours, au plus 20 graduations - axes[-1, 0].xaxis.set_major_locator(mdates.HourLocator(byhour=range(0, 24, h)) if h < 24 else mdates.DayLocator(interval=math.ceil(jours / 20))) - axes[-1, 0].set_xlim(temps[0], temps[-1]) - axes[-1, 0].xaxis.set_major_formatter(mdates.DateFormatter("%d/%m\n%H:%MZ")) - for ax in axes[:, 0]: - ax.grid(alpha=0.5, which="major") - fig.suptitle(f"{station} : {len(e)} capteurs ensemble, chacun face à son niveau sur la fenêtre (heures UTC)") - fig.tight_layout(rect=(0, 0, 1, 1 - 0.4 / fig.get_figheight())) # place du titre - commun = base.format("commun") - fig.savefig(commun, dpi=100, bbox_inches="tight") - plt.close(fig) - print(commun) - - # table de la médiane commune, par pas - minuit = temps[0].replace(hour=0, minute=0, second=0, microsecond=0) - t0 = minuit + ((temps[0] - minuit) // o.pas) * o.pas # pas calés sur l'horloge (hh:00, hh:15…), pas sur la 1re mesure - lignes_t = {} - for col in colonnes: - for t, v in communes[col].items(): - lignes_t.setdefault(t0 + ((t - t0) // o.pas) * o.pas, {}).setdefault(col, []).append(v) - for col in pose_cols: - communes["cam_" + col] = {p["t"]: p[col] for p in poses if p[col] is not None} - for t, v in communes["cam_" + col].items(): - lignes_t.setdefault(t0 + ((t - t0) // o.pas) * o.pas, {}).setdefault("cam_" + col, []).append(v) - for col in refs_par_col: - for t, v in communes[col + "_cibles"].items(): - lignes_t.setdefault(t0 + ((t - t0) // o.pas) * o.pas, {}).setdefault(col + "_cibles", []).append(v) - cols_t = colonnes + [c + "_cibles" for c in refs_par_col] + ["cam_" + c for c in pose_cols] - print(f"\nMédiane commune (écart à la médiane de la fenêtre){' et pose brute de la caméra (cam_, vide sans recalage)' if pose_cols else ''}, " - f"médiane par pas de {int(o.pas.total_seconds() // 60)} min{' (table : ' + o.table + ')' if o.table else ''} :") - entete = f"{'instant':17}" + "".join(f"{c:>13}" for c in cols_t) - for i, t in enumerate(t for t in sorted(lignes_t) if o.dans_table(t)): - if i % 24 == 0: - print(entete) - print(f"{iso(t):17}" + "".join(f"{statistics.median(lignes_t[t][c]):13.{6 if c.startswith('cam_') else 4}g}" if c in lignes_t[t] else " " * 13 for c in cols_t)) - for col in cols_t: - if communes[col]: - lo, hi = min(communes[col].items(), key=lambda x: x[1]), max(communes[col].items(), key=lambda x: x[1]) - g = 6 if col.startswith("cam_") else 4 - print(f"{col} (mesures) : min {lo[1]:.{g}g} à {iso(lo[0])}, max {hi[1]:.{g}g} à {iso(hi[0])}") - - for col, refs in refs_par_col.items(): - print(f"\n{col} brut des références globales, écart à leur médiane de la fenêtre (mesures) ; {col}_cibles : médiane des cibles seules :") - for s in refs: - d = ref_ecarts[col][s] - lo, hi = min(d.items(), key=lambda x: x[1]), max(d.items(), key=lambda x: x[1]) - rej = {m["t"] for m in series[s] if rejetee(m)} - r = lambda t: " (rejetée)" if t in rej else "" - print(f"{s:9} min {lo[1]:+.3g} à {iso(lo[0])}{r(lo[0])}, max {hi[1]:+.3g} à {iso(hi[0])}{r(hi[0])}" - + (f" ; {len(rej)} mesures rejetées dans la fenêtre" if rej else "")) - if not pose_cols: - print("Pose de la caméra : aucune dans la fenêtre (pas de camera/ dans le dossier, ou pas de recalage).") - else: - avec = {p["t"].replace(second=0, microsecond=0) for p in poses} - suites = [] # suites d'instants de mesure consécutifs sans pose : [début, fin, nombre] - for i, t in enumerate(temps): - if t.replace(second=0, microsecond=0) in avec: - continue - if suites and suites[-1][3] == i - 1: - suites[-1][1], suites[-1][2], suites[-1][3] = t, suites[-1][2] + 1, i - else: - suites.append([t, t, 1, i]) - print(f"Instants de mesure sans pose de la caméra (pas de recalage) : {sum(x[2] for x in suites)} sur {len(temps)}" - + (" : " + "; ".join(iso(a) if n == 1 else f"{iso(a)} → {iso(b)} ({n})" for a, b, n, _ in suites) if suites else "")) - - # 2. petits multiples - col = o.colonne - n = len(noms) - lignes = math.ceil(n / 5) - fig, axes = plt.subplots(lignes, 5, sharex=True, figsize=(18, 2.5 * lignes), squeeze=False) - for ax, s in zip(axes.flat, noms): - ms = [m for m in series[s] if m[col] is not None] - ax.plot([m["t"] for m in ms], [m[col] for m in ms], "-", lw=0.4, color="0.7") - pas = {} - for m in ms: - pas.setdefault(t0 + ((m["t"] - t0) // o.pas) * o.pas, []).append(m[col]) - ax.plot(list(pas), [statistics.median(v) for v in pas.values()], "-", lw=1.1, color="C0") - lv = niveau(series[s], col) - if lv: - ax.axhline(lv[0], color="C3", ls=":", lw=0.8) - ax.set_title(s + (" (réf.)" if series[s] and est_reference(series[s]) else ""), fontsize=9) - ax.grid(alpha=0.3) - ax.tick_params(labelsize=7) - ax.xaxis.set_major_locator(mdates.AutoDateLocator(minticks=2, maxticks=5)) - ax.xaxis.set_major_formatter(mdates.DateFormatter("%d/%m\n%Hh")) - for ax in list(axes.flat)[n:]: - ax.axis("off") - fig.suptitle(f"{station} : {col}, médiane par pas de {int(o.pas.total_seconds() // 60)} min (bleu), mesures (gris), " - f"médiane de la fenêtre (pointillé) ; une échelle par capteur (heures UTC)") - fig.tight_layout() - multiples = base.format(f"multiples-{col}") - fig.savefig(multiples, dpi=100, bbox_inches="tight") - print(multiples) - - # 3. résidus : chaque capteur moins son propre niveau - for col, autres in [(c, False) for c in residus] + [(c, True) for c in residus if o.autres]: - fig, axes = plt.subplots(lignes, 5, sharex=True, figsize=(18, 2.5 * lignes), squeeze=False) - dev = {} - if autres: # {capteur: {t: valeur - niveau propre}} pour la médiane des autres - for q in noms: - mq = [m for m in series[q] if m[col] is not None] - rq = [m for m in mq if not hors or not hors[0] <= m["t"] <= hors[1]] or mq - nq = niveau(rq, col) - if nq: - dev[q] = {m["t"]: m[col] - nq[0] for m in mq} - print(f"\n{col} moins le niveau propre{' et moins la médiane des autres capteurs au même instant' if autres else ''} ({'hors ' + o.hors if hors else 'médiane de la fenêtre'}), médiane par pas de " - f"{int(o.pas.total_seconds() // 60)} min :") - pentes = [] - print(f"{'capteur':9}{'niveau':>10}{'bruit':>10}{'écart min':>11} {'à':<17}{'(bruits)':>9}{'écart max':>11} {'à':<17}{'(bruits)':>9}") - for ax, s in zip(axes.flat, noms): - ms = [m for m in series[s] if m[col] is not None] - ref = [m for m in ms if not hors or not hors[0] <= m["t"] <= hors[1]] or ms - lv = niveau(ref, col) - if not lv: - ax.axis("off") - continue - bruit = bruit_propre([m[col] for m in ms]) - if autres: - res = {} - for m in ms: - v = [dev[q][m["t"]] for q in dev if q != s and m["t"] in dev[q]] - if len(v) >= 2: - res[m["t"]] = m[col] - lv[0] - statistics.median(v) - if len(res) < 2: - ax.axis("off") - continue - else: - res = {m["t"]: m[col] - lv[0] for m in ms} - pas = {} - for t, v in res.items(): - pas.setdefault(t0 + ((t - t0) // o.pas) * o.pas, []).append(v) - pm = {t: statistics.median(v) for t, v in pas.items()} - ax.plot(list(res), list(res.values()), "-", lw=0.4, color="0.7") - ax.plot(list(pm), list(pm.values()), "-", lw=1.1, color="C0") - ax.axhline(0, color="C3", ls=":", lw=0.8) - ax.set_title(s + (" (réf.)" if est_reference(ms) else "") + f" bruit {bruit:.2g}", fontsize=9) - ax.grid(alpha=0.3) - ax.tick_params(labelsize=7) - ax.xaxis.set_major_locator(mdates.AutoDateLocator(minticks=2, maxticks=5)) - ax.xaxis.set_major_formatter(mdates.DateFormatter("%d/%m\n%Hh")) - lo, hi = min(pm.items(), key=lambda x: x[1]), max(pm.items(), key=lambda x: x[1]) - f = lambda v: f"{v / bruit:9.1f}" if bruit else f"{'-':>9}" - print(f"{s:9}{lv[0]:10.4g}{bruit:10.3g}{lo[1]:11.3g} {iso(lo[0]):<17}{f(lo[1])}{hi[1]:11.3g} {iso(hi[0]):<17}{f(hi[1])}") - if autres: - for c in colonnes: - tt = [t for t in res if t in communes[c]] - if len(tt) > 2 and len({communes[c][t] for t in tt}) > 1: - xs, ys = [communes[c][t] for t in tt], [res[t] for t in tt] - pente = statistics.linear_regression(xs, ys).slope - pentes.append(f"{s:9}pente sur {c} commun {pente:+.4g} par unité, r = {statistics.correlation(xs, ys):+.2f}") - for ax in list(axes.flat)[n:]: - ax.axis("off") - if pentes: - print("\n".join(pentes)) - fig.suptitle(f"{station} : {col} moins le niveau propre{' et la médiane des autres' if autres else ''} de chaque capteur, médiane par pas de " - f"{int(o.pas.total_seconds() // 60)} min (bleu), mesures (gris) ; une échelle par capteur (heures UTC)") - fig.tight_layout() - chemin = base.format(f"residus-{col}" + ("-autres" if autres else "")) - fig.savefig(chemin, dpi=100, bbox_inches="tight") - plt.close(fig) - print(chemin) - - if o.rigide: - rigide(o, noms, series, temps, base, station) - - print(f"\nInstants où au moins {o.min} capteurs ont {o.colonne} > médiane de la fenêtre + {o.k:g} MAD :") - for t, hauts in qui.items(): - print(f"{iso(t)} {len(hauts):3} {','.join(hauts)}") - if not qui: - print("(aucun)") - - -if __name__ == "__main__": - main() diff --git a/agent-tools/gif.py b/agent-tools/gif.py deleted file mode 100644 index 42da0de..0000000 --- a/agent-tools/gif.py +++ /dev/null @@ -1,70 +0,0 @@ -"""GIF des images de la caméra sur une plage, pour joindre à une réponse au client. - -Usage : .venv/bin/python agent-tools/gif.py data/LENZSPITZE/ - --debut 2026-10-26T18:00Z --fin 2026-10-27T08:00Z [--largeur 720] [--duree 700] [--max 150] [--zone X,Y,L,H] [--sortie DOSSIER] -Prend les images du dossier dont l'heure (nom du fichier, UTC) est entre --debut et --fin inclus, dans l'ordre, les -recadre au besoin sur --zone (pixels de l'image d'origine : coin haut gauche, largeur, hauteur), les met à --largeur px, -écrit la date et l'heure UTC en bas à droite de chacune et les ramène à 64 teintes sans tramage -(le bruit des JPEG gonfle un GIF : ~3 Mo pour une nuit d'images horaires à 720 px). Au-delà de --max images, en garde ---max à intervalle régulier. Imprime l'heure de chaque image retenue, puis le chemin du GIF et sa taille. -""" -import argparse -import os -import sys - -from PIL import Image, ImageDraw, ImageFont - -from donnees import heure_image, instant, iso, trouver - -RACINE = os.path.normpath(os.path.join(os.path.dirname(os.path.abspath(__file__)), "..")) - - -def main(): - a = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) - a.add_argument("dossier") - a.add_argument("--debut", required=True, help="première heure (UTC)") - a.add_argument("--fin", required=True, help="dernière heure (UTC), incluse") - a.add_argument("--largeur", type=int, default=720, help="largeur du GIF en pixels (défaut 720)") - a.add_argument("--duree", type=int, default=700, help="durée de chaque image en ms (défaut 700)") - a.add_argument("--max", type=int, default=150, help="nombre maximal d'images (défaut 150)") - a.add_argument("--zone", help="X,Y,L,H : recadrage en pixels de l'image d'origine (défaut : image entière)") - a.add_argument("--sortie", default=os.path.join(RACINE, "out", "diagnostic"), help="dossier du GIF") - o = a.parse_args() - - debut, fin = instant(o.debut), instant(o.fin) - toutes = sorted((h, p) for p in trouver(o.dossier)["images"] if (h := heure_image(p))) - choisies = [(h, p) for h, p in toutes if debut <= h <= fin] - if not choisies: - dispo = f" (images du {iso(toutes[0][0])} au {iso(toutes[-1][0])})" if toutes else "" - sys.exit(f"Aucune image entre {iso(debut)} et {iso(fin)} dans {o.dossier}{dispo}.") - n = len(choisies) - if n > o.max: - choisies = [choisies[round(i * (n - 1) / (o.max - 1))] for i in range(o.max)] - print(f"{o.max} images sur {n} gardées") - - vues = [] - for h, p in choisies: - im = Image.open(p).convert("RGB") - if o.zone: - x, y, l, h_ = map(int, o.zone.split(",")) - im = im.crop((x, y, x + l, y + h_)) - im = im.resize((o.largeur, round(im.height * o.largeur / im.width)), Image.LANCZOS) - d = ImageDraw.Draw(im) - texte = h.strftime("%Y-%m-%d %H:%M UTC") - police = ImageFont.load_default(size=max(12, o.largeur // 45)) - g, haut, dr, bas = d.textbbox((0, 0), texte, font=police) - x, y, marge = im.width - (dr - g) - 10, im.height - (bas - haut) - 10, 4 - d.rectangle((x - marge, y - marge, x + dr - g + marge, y + bas - haut + marge), fill="black") - d.text((x - g, y - haut), texte, fill="white", font=police) - vues.append(im.quantize(64, dither=Image.Dither.NONE)) - print(iso(h)) - - os.makedirs(o.sortie, exist_ok=True) - nom = f"images_{choisies[0][0]:%Y%m%dT%H%MZ}_{choisies[-1][0]:%Y%m%dT%H%MZ}.gif" - chemin = os.path.join(o.sortie, nom) - vues[0].save(chemin, save_all=True, append_images=vues[1:], duration=o.duree, loop=0, optimize=True) - print(f"GIF : {chemin} ({os.path.getsize(chemin) / 1e6:.1f} Mo, {len(vues)} images)") - - -if __name__ == "__main__": - main() diff --git a/agent-tools/graphique.py b/agent-tools/graphique.py deleted file mode 100644 index dca8a69..0000000 --- a/agent-tools/graphique.py +++ /dev/null @@ -1,94 +0,0 @@ -"""Graphique PNG des séries d'un export « advanced », pour que l'agent de diagnostic les regarde. - -Usage : .venv/bin/python agent-tools/graphique.py data/PS_DES_COUDRES/ - [--capteurs CAPTEUR_A,CAPTEUR_B] [--colonnes error_value,corr_x,corr_y] [--debut ...] [--fin ...] - [--zone DEBUT/FIN ...] [--sortie DOSSIER] -Un panneau par colonne, une courbe par capteur, heures UTC ; chaque --zone est grisée. Colonnes : error_value, corr_x, corr_y, -relative_x, relative_y, x, y, sigma0, reproj_err, et les six métriques de qualité d'image (peak à snr, valeurs brutes ; face à une référence calme : qualite.py). -Imprime le chemin du PNG (out/diagnostic/, ou --sortie : le dossier du rapport, pour une figure de preuve). -""" -import argparse -import os -import sys - -import matplotlib - -matplotlib.use("Agg") -import matplotlib.dates as mdates # noqa: E402 -import matplotlib.pyplot as plt # noqa: E402 - -from donnees import charger, est_reference, filtrer, instant # noqa: E402 -from resume import QUALITE # noqa: E402 - -RACINE = os.path.normpath(os.path.join(os.path.dirname(os.path.abspath(__file__)), "..")) -COLONNES = ("error_value", "corr_x", "corr_y", "relative_x", "relative_y", "x", "y", "sigma0", "reproj_err") - - -def zone(texte): - """'2026-10-13T01:00Z/2026-10-13T03:00Z' -> (début, fin).""" - debut, sep, fin = texte.partition("/") - if not sep: - raise argparse.ArgumentTypeError(f"zone invalide : {texte!r} (ex. 2026-10-13T01:00Z/2026-10-13T03:00Z)") - return instant(debut), instant(fin) - - -def borne(t, defaut): - return t.strftime("%Y%m%dT%H%MZ") if t else defaut - - -def main(): - a = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) - a.add_argument("dossier") - a.add_argument("--capteurs", help="liste séparée par des virgules (défaut : tous)") - a.add_argument("--colonnes", default="error_value,corr_x,corr_y") - a.add_argument("--debut", type=instant) - a.add_argument("--fin", type=instant) - a.add_argument("--zone", type=zone, action="append", default=[], help="fenêtre à griser, DEBUT/FIN (répétable)") - a.add_argument("--sortie", default=os.path.join(RACINE, "out", "diagnostic"), help="dossier du PNG") - o = a.parse_args() - - par = charger(o.dossier) - if not par: - sys.exit(f"Aucun export « advanced » dans {o.dossier} (voir inventaire.py).") - noms = o.capteurs.split(",") if o.capteurs else sorted(par, key=lambda s: (not est_reference(par[s]), s)) - colonnes = o.colonnes.split(",") - for demandes, connus, quoi in ((noms, par, "Capteurs"), (colonnes, COLONNES + QUALITE, "Colonnes")): - absents = [x for x in demandes if x not in connus] - if absents: - sys.exit(f"{quoi} inconnus : {', '.join(absents)}. Connus : {', '.join(sorted(connus))}.") - series = {s: filtrer(par[s], o.debut, o.fin) for s in noms} - if not any(series.values()): - sys.exit("Aucune mesure dans la fenêtre demandée.") - vides = [c for c in colonnes if all(m[c] is None for s in noms for m in series[s])] - if len(vides) == len(colonnes): - sys.exit(f"Rien à tracer : {', '.join(colonnes)} vide(s) pour ces capteurs dans la fenêtre.") - if vides: - print(f"Panneaux vides (aucune valeur pour ces capteurs) : {', '.join(vides)}") - - fig, axes = plt.subplots(len(colonnes), 1, sharex=True, figsize=(14, 3.2 * len(colonnes)), squeeze=False) - tab20 = plt.get_cmap("tab20").colors - couleurs = tab20[::2] + tab20[1::2] # teintes foncées d'abord : deux capteurs voisins ne partagent pas une teinte - for ax, col in zip(axes[:, 0], colonnes): - for i, s in enumerate(noms): - ms = series[s] # une valeur vide devient NaN : la courbe s'interrompt au lieu de relier le trou - ax.plot([m["t"] for m in ms], [float("nan") if m[col] is None else m[col] for m in ms], ".-", ms=2, lw=0.7, - color=couleurs[i % len(couleurs)], label=s) - for debut, fin in o.zone: - ax.axvspan(debut, fin, color="0.85", zorder=0) - ax.set_ylabel(col) - ax.grid(alpha=0.3) - axes[0, 0].legend(loc="upper left", bbox_to_anchor=(1.0, 1.0), fontsize=8) - axes[-1, 0].xaxis.set_major_formatter(mdates.DateFormatter("%d/%m\n%H:%MZ")) - station = os.path.basename(os.path.normpath(o.dossier)) - fig.suptitle(f"{station} : {', '.join(colonnes)} (heures UTC)") - - os.makedirs(o.sortie, exist_ok=True) - qui = "-".join(noms) if o.capteurs else "tous" - sortie = os.path.join(o.sortie, f"{station}_{'-'.join(colonnes)}_{qui}_" - f"{borne(o.debut, 'debut')}_{borne(o.fin, 'fin')}.png") - fig.savefig(sortie, dpi=100, bbox_inches="tight") - print(sortie) - - -if __name__ == "__main__": - main() diff --git a/agent-tools/inventaire.py b/agent-tools/inventaire.py deleted file mode 100644 index 49136c1..0000000 --- a/agent-tools/inventaire.py +++ /dev/null @@ -1,314 +0,0 @@ -"""Inventaire d'un dossier de station : ce qui est disponible, ce qui manque. - -Usage : python3 agent-tools/inventaire.py data/PS_DES_COUDRES/ [--debut T] [--fin T] [--fichiers] -Les comptes portent sur toute la période. Avec --debut et/ou --fin, une section de plus liste, sur cette fenêtre, -les pas absents (datés, avec les capteurs qui n'ont pas de mesure) et, par capteur, les mesures rejetées (datées, -en suites de pas consécutifs ; rejetée : error_value au-dessus du seuil, références comprises), puis le nombre de -références retenues par la compensation (inlier = 1 ; inlier vide sur la fenêtre : reproj_err rempli) à chaque instant -et, datées, les suites d'instants où des références ne le sont pas (lesquelles, et pourquoi : rejetée, valeur d'inlier, -vide). Mouvements de la caméra (camera/) : nombre de poses, période, et les instants de mesure -sans pose (pas de recalage), sur toute la période puis sur la fenêtre. Avant les comptes, ce que contient chaque source -(sur la fenêtre, sinon toute la période) : les colonnes de l'export, de la pose et de quality/, remplies ou vides (avec, -pour une colonne de l'export que tous les capteurs ne portent pas, combien la portent), les noms des métriques système -de metrics/, les images et les images différentielles. Les relevés en double (même capteur, même instant dans deux -exports, ou deux fois dans un) sont comptés par export. Images : par suite d'écarts égaux entre deux images (à 5 min -près ; sur la fenêtre si elle est donnée). Une suite datée qui finit le même jour n'écrit que l'heure de sa fin. -Rend des valeurs, pas de verdict. -""" -import argparse -import collections -import csv -import glob -import os -import re -import statistics -from datetime import datetime, timedelta, timezone - -from donnees import charger, charger_camera, est_reference, filtrer, heure_image, instant, iso, rejetee, trouver -from resume import QUALITE - -METRIQUE_RE = re.compile(r"^(.+?)_(\d{4})_(\d{2})_(\d{2})_\d{2}_\d{2}") # NIEDERHORN_BusCurrent_2026_09_22_00_00 to ….csv - - -def suite(a, b, n): - """Une suite datée : le début en entier, la fin sans la date quand elle tombe le même jour.""" - if n == 1: - return iso(a) - return f"{iso(a)} → {iso(b)[11:] if iso(a)[:10] == iso(b)[:10] else iso(b)} ({n})" - - -def doubles(chemins): - """Relevés (même capteur, même instant) déjà lus dans un export précédent ou plus haut dans le même : charger n'en - garde qu'un, celui du dernier fichier dans l'ordre des noms. Une ligne par export qui en a.""" - vus, lignes = {}, [] - for p in chemins: - n = deja = autres = 0 - with open(p, newline="") as fh: - for r in csv.DictReader(fh): - n += 1 - cle = (r["sensor_name"].strip(), r["time_utc"]) - val = tuple(v.strip() for k, v in r.items() if k not in ("sensor_name", None)) - if cle in vus: - deja += 1 - autres += vus[cle] != val - vus[cle] = val - if deja: - lignes.append(f" {os.path.basename(p)} : {deja} sur {n} déjà lus, dont {autres} de valeurs différentes") - if lignes: - print("Relevés en double (même capteur, même instant dans un export déjà lu, dans l'ordre des noms ; " - "les outils gardent celui du dernier fichier) :") - print("\n".join(lignes)) - - -def liste(chemins, tout): - """Un dossier de pompage compte des centaines de fichiers : au-delà de 5, le premier et le dernier seulement.""" - if tout or len(chemins) <= 5: - shown = chemins - else: - shown = [chemins[0], chemins[-1]] - print(f" {len(chemins)} fichiers, du premier au dernier (--fichiers pour la liste complète) :") - for p in shown: - print(f" {p}") - - -def fichiers(f, tout=False): - print(f"Exports « advanced » (source des mesures) : {len(f['advanced'])}") - liste(f["advanced"], tout) - doubles(f["advanced"]) - print(f"Exports horaires : {len(f['horaire'])} (non lus par les outils : moyennes horaires, " - "heure locale sans fuseau ; voir labeling/connaissances/colonnes-des-deplacements.md)") - liste(f["horaire"], tout) - print(f"Mouvements de la caméra (pose à chaque recalage) : {len(f['camera'])}") - liste(f["camera"], tout) - print(f"Autres fichiers : {len(f['autres'])}") - liste(f["autres"], tout) - - -def remplies(chemins, debut, fin): - """CSV d'une source -> (lignes de la fenêtre, {colonne: lignes avec une valeur}, {colonne: capteurs qui en ont une}), - colonnes dans l'ordre des en-têtes ; capteurs : sensor_name, s'il y en a.""" - lignes, compte, qui = 0, {}, collections.defaultdict(set) - for p in chemins: - with open(p, newline="") as fh: - r = csv.DictReader(fh) - for c in r.fieldnames or []: - if c not in ("", "time_utc", "sensor_name"): - compte.setdefault(c, 0) - for row in r: - if (debut or fin) and filtrer([{"t": instant(row["time_utc"])}], debut, fin) == []: - continue - lignes += 1 - for c in compte: - if (row.get(c) or "").strip(): - compte[c] += 1 - if row.get("sensor_name"): - qui[c].add(row["sensor_name"].strip()) - return lignes, compte, qui - - -def contenu(dossier, f, debut=None, fin=None): - """Ce que contient chaque source sur la fenêtre : ses colonnes, remplies ou vides, et les noms des métriques. - Des noms et des comptes, jamais de valeurs (metrics/ porte des identifiants : SIM_CCID, ip_*).""" - quoi = "sur la fenêtre" if debut or fin else "sur toute la période" - print(f"\nCe que contiennent les données, {quoi} (par colonne, les lignes qui ont une valeur ; « vide » : aucune) :") - autres = collections.defaultdict(list) - for p in f["autres"]: - autres[os.path.relpath(p, dossier).split(os.sep)[0]].append(p) - for titre, chemins in (("Export « advanced »", f["advanced"]), ("Pose de la caméra (camera/)", f["camera"]), - ("Qualité d'image (quality/)", autres.pop("quality", []))): - if chemins: - n, compte, qui = remplies(chemins, debut, fin) - tous = set().union(*qui.values()) - def porte(c): # nombre de capteurs qui portent la colonne, quand ce ne sont pas tous - return f" ({len(qui[c])} capteurs sur {len(tous)})" if tous and len(qui[c]) < len(tous) else "" - print(f" {titre} : {n} lignes ; " + ", ".join(f"{c} {k}{porte(c)}" if k else f"{c} vide" for c, k in compte.items())) - if chemins is f["advanced"]: - q = [c for c in QUALITE if compte.get(c)] - print(f" Qualité d'image de l'export (peak à snr) : " + (f"remplie ({', '.join(q)}) ; lue par qualite.py, " - "labeling/connaissances/metriques-de-qualite.md" if q else "vide")) - jours = collections.Counter() # métrique -> jours (un CSV par métrique et par jour) dans la fenêtre - for p in autres.pop("metrics", []): - m = METRIQUE_RE.match(os.path.basename(p)) - if not m: - continue - jour = datetime(*map(int, m.group(2, 3, 4)), tzinfo=timezone.utc) - if (debut is None or jour.date() >= debut.date()) and (fin is None or jour.date() <= fin.date()): - nom = m.group(1) - jours[nom.split("_", 1)[1] if "_" in nom else nom] += 1 - if jours: - print(f" Métriques système (metrics/, un CSV par métrique et par jour ; lues par metriques.py) : {len(jours)} : " - + ", ".join(f"{k} ({n} j)" for k, n in sorted(jours.items()))) - for titre, chemins in (("Images de la caméra", f["images"]), - ("Images différentielles (images_diff/ ; aucun outil ne les lit)", glob.glob(os.path.join(dossier, "images_diff", "*")))): - heures = [h for h in map(heure_image, chemins) if h and filtrer([{"t": h}], debut, fin)] - if chemins: - print(f" {titre} : {len(heures)}") - if autres: - print(" Autres : " + ", ".join(f"{k} ({len(v)})" for k, v in sorted(autres.items()))) - - -def images(chemins, debut=None, fin=None): - heures = sorted(h for h in map(heure_image, chemins) if h) - print(f"Images : {len(chemins)}" + (f", du {iso(heures[0])} au {iso(heures[-1])}" if heures else "")) - inconnues = [p for p in chemins if heure_image(p) is None] - if inconnues: - print(f" noms sans heure reconnue : {len(inconnues)}") - heures = [h for h in heures if filtrer([{"t": h}], debut, fin)] - if len(heures) < 2: - return - # Suites d'images à écart régulier (arrondi à 5 min, ce qui absorbe les quelques secondes de retard d'une prise) : - # une ligne par changement d'écart, sans rien perdre des heures couvertes. - suites = [] # [première, dernière, écart en min, nombre d'écarts] - for a, b in zip(heures, heures[1:]): - e = round((b - a).total_seconds() / 300) * 5 - if suites and suites[-1][2] == e: - suites[-1][1], suites[-1][3] = b, suites[-1][3] + 1 - else: - suites.append([a, b, e, 1]) - quoi = "sur la fenêtre" if debut or fin else "entre la première et la dernière" - print(f" écart entre deux images {quoi}, par suite d'écarts égaux (à 5 min près) :") - for a, b, e, n in suites: - print(f" {iso(a)} → {iso(b)} : " + (f"{n + 1} images, toutes les {e} min" if n > 1 else f"un écart de {e} min")) - - -def mesures(par): - if not par: - print("\nAucune mesure : pas d'export « advanced » dans ce dossier.") - return - instants = sorted({m["t"] for ms in par.values() for m in ms}) - cadence = statistics.median(b - a for a, b in zip(instants, instants[1:])) - print(f"\nPériode des mesures : {iso(instants[0])} → {iso(instants[-1])}, {len(instants)} instants") - print(f"Cadence (pas médian) : {cadence.total_seconds() / 60:.0f} min") - trous = [(a, b, round((b - a) / cadence) - 1) for a, b in zip(instants, instants[1:])] - trous = [x for x in trous if x[2] > 0] - print(f"Mesures manquantes (instants absents de la cadence) : {sum(n for *_, n in trous)}") - for a, b, n in trous: - print(f" entre {iso(a)} et {iso(b)} : {n}") - noms = sorted(par, key=lambda s: (not est_reference(par[s]), s)) - refs = [s for s in noms if est_reference(par[s])] - print(f"\nCapteurs : {len(par)} ({len(refs)} références, {len(par) - len(refs)} cibles)") - vides = [s for s in noms if not any(m["pattern_type"] for m in par[s])] - if vides: - print(f" pattern_type vide pour {len(vides)} capteurs : référence quand reproj_err ou inlier est rempli " - "(références seulement, labeling/connaissances/colonnes-des-deplacements.md)") - print(f"{'capteur':10} {'type':10} {'motif':11} {'seuil':>5} {'mesures':>7} {'rejetées':>8}") - for s in noms: - ms = par[s] - seuil = "/".join(f"{x:g}" for x in sorted({m['error_threshold'] for m in ms})) - print(f"{s:10} {'référence' if est_reference(ms) else 'cible':10} {ms[0]['pattern_type']:11} " - f"{seuil:>5} {len(ms):7} {sum(map(rejetee, ms)):8}") - - -def camera(dossier, par, debut=None, fin=None): - """Poses de la caméra, et les instants de mesure sans pose (la caméra n'a pas été recalée).""" - poses = filtrer(charger_camera(dossier), debut, fin) - instants = sorted({m["t"] for ms in par.values() for m in filtrer(ms, debut, fin)}) - quoi = "dans la fenêtre" if debut or fin else "sur toute la période" - if not poses: - print(f"\nPose de la caméra {quoi} : aucune") - return - avec = {p["t"].replace(second=0, microsecond=0) for p in poses} - print(f"\nPose de la caméra {quoi} : {len(poses)} recalages, {iso(poses[0]['t'])} → {iso(poses[-1]['t'])}") - suites = [] # [début, fin, nombre, rang] des instants de mesure consécutifs sans pose - for i, t in enumerate(instants): - if t.replace(second=0, microsecond=0) in avec: - continue - if suites and suites[-1][3] == i - 1: - suites[-1][1], suites[-1][2], suites[-1][3] = t, suites[-1][2] + 1, i - else: - suites.append([t, t, 1, i]) - print(f"Instants de mesure sans pose (pas de recalage) : {sum(x[2] for x in suites)} sur {len(instants)}") - if debut or fin: - for a, b, n, _ in suites: - print(f" {suite(a, b, n)}") - - -def fenetre(par, debut, fin): - """Pas absents et rejets datés sur la fenêtre debut/fin.""" - instants = sorted({m["t"] for ms in par.values() for m in ms}) - cadence = statistics.median(b - a for a, b in zip(instants, instants[1:])) - series = {s: {m["t"]: m for m in filtrer(ms, debut, fin)} for s, ms in par.items()} - dans = sorted({t for d in series.values() for t in d}) - print(f"\nFenêtre {iso(dans[0])} → {iso(dans[-1])} : {len(dans)} instants présents") - noms = sorted(par, key=lambda s: (not est_reference(par[s]), s)) - print(f"Pas absents pour tous les capteurs, entre deux instants présents (cadence de {cadence.total_seconds() / 60:.0f} min) :") - trous = [(a, b, round((b - a) / cadence) - 1) for a, b in zip(dans, dans[1:])] - trous = [x for x in trous if x[2] > 0] - for a, b, n in trous: - print(f" entre {iso(a)} et {iso(b)} : {n}") - if not trous: - print(" (aucun)") - print("Instants présents où des capteurs n'ont pas de mesure :") - partiels = [(t, [s for s in noms if t not in series[s]]) for t in dans] - for t, manque in partiels: - if manque: - print(f" {iso(t)} : {len(manque)} capteurs : {','.join(manque)}") - if not any(m for _, m in partiels): - print(" (aucun)") - print("Mesures rejetées dans la fenêtre, par capteur (début → fin de chaque suite de pas consécutifs, nombre) :") - for s in noms: - rej = [t for t in sorted(series[s]) if rejetee(series[s][t])] - suites = [] - for t in rej: - if suites and t - suites[-1][1] <= cadence * 1.5: - suites[-1][1], suites[-1][2] = t, suites[-1][2] + 1 - else: - suites.append([t, t, 1]) - if rej: - print(f" {s} ({len(rej)}) : " + "; ".join(suite(a, b, n) for a, b, n in suites)) - if not any(rejetee(m) for d in series.values() for m in d.values()): - print(" (aucune)") - refs = [s for s in noms if est_reference(par[s])] - # inlier dit quelles références la compensation retient ; certains exports ne le remplissent pas (et parfois - # reproj_err seulement) : on prend alors reproj_err rempli, et le titre le dit. - col = next((c for c in ("inlier", "reproj_err") if any(m[c] is not None for s in refs for m in series[s].values())), None) - if col is None: - print("Références retenues par la compensation : colonnes inlier et reproj_err absentes ou vides.") - return - retenue = (lambda m: m["inlier"] == 1) if col == "inlier" else (lambda m: m["reproj_err"] is not None) - def marque(s, t): - m = series[s].get(t) - return "absente" if m is None else "r" if rejetee(m) else "vide" if m[col] is None else f"{m[col]:g}" - hors = [(t, tuple((s, marque(s, t)) for s in refs if t not in series[s] or not retenue(series[s][t]))) for t in dans] - compte = collections.Counter(len(refs) - len(h) for _, h in hors) - quoi = "inlier = 1" if col == "inlier" else "inlier vide sur la fenêtre : reproj_err rempli à la place" - print(f"Références retenues par la compensation ({quoi}) sur {len(refs)}, nombre d'instants : " - + ", ".join(f"{k} : {compte[k]}" for k in sorted(compte, reverse=True))) - print("Instants où des références ne sont pas retenues (suites de pas consécutifs avec les mêmes références hors ; " - f"r = rejetée, vide = {col} vide, sinon la valeur d'inlier) :") - suites = [] - for i, (t, h) in enumerate(hors): - if h and suites and suites[-1][3] == h and suites[-1][4] == i - 1: - suites[-1][1], suites[-1][2], suites[-1][4] = t, suites[-1][2] + 1, i - elif h: - suites.append([t, t, 1, h, i]) - for a, b, n, h, _ in suites: - print(f" {suite(a, b, n)} : {len(refs) - len(h)} retenues ; hors : " - + ", ".join(f"{s} ({q})" for s, q in h)) - if not suites: - print(" (aucun)") - - -def main(dossier, debut=None, fin=None, tout=False): - print(f"Dossier : {dossier}") - f = trouver(dossier) - fichiers(f, tout) - contenu(dossier, f, debut, fin) - images(f["images"], debut, fin) - par = charger(dossier) - mesures(par) - if par: - camera(dossier, par) - if par and (debut or fin): - fenetre(par, debut, fin) - camera(dossier, par, debut, fin) - - -if __name__ == "__main__": - a = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) - a.add_argument("dossier") - a.add_argument("--debut", type=instant) - a.add_argument("--fin", type=instant) - a.add_argument("--fichiers", action="store_true", help="liste complète des fichiers (sinon : le premier et le dernier au-delà de 5)") - o = a.parse_args() - main(o.dossier, o.debut, o.fin, o.fichiers) diff --git a/agent-tools/jours.py b/agent-tools/jours.py deleted file mode 100644 index 5379937..0000000 --- a/agent-tools/jours.py +++ /dev/null @@ -1,333 +0,0 @@ -"""Ce qui revient d'un jour à l'autre : niveau de chaque nuit, et jours superposés par heure du jour, pour l'agent de diagnostic. - -Usage : .venv/bin/python agent-tools/jours.py data/PS_DES_COUDRES/ [--colonnes corr_x,corr_y,error_value] - [--nuit 20-3] [--k 5] [--jours 2] [--pas 15min] [--capteurs A,B] [--bornes [--lissage N] [--fraction F]] - [--debut ...] [--fin ...] [--sortie DOSSIER] - -Mesures acceptées seulement : une mesure rejetée (error_value au-dessus du seuil) n'entre nulle part. Une « nuit » : -les heures --nuit H1-H2 (UTC, H1 inclus, H2 exclu, à cheval sur minuit si H1 > H2), datée du jour où elle commence ; -la nuit en cours au début de la fenêtre compte aussi (ses heures après minuit). Bruit propre du capteur : médiane des -écarts entre deux mesures consécutives sur la fenêtre. Pour chaque colonne de --colonnes : -1. Niveau de chaque nuit, par capteur : médiane, MAD et nombre de mesures ; puis, d'une nuit à la suivante, la - marche (différence des médianes, en unités et en bruits) et où elle se place : la suite des mesures de nuit des - deux nuits est coupée là où la somme des écarts absolus au niveau de la première nuit (avant) et de la seconde - (après) est la plus petite ; « entre A et B » : dernière mesure de nuit avant la coupure et première après (B en - début de nuit : la coupure tombe entre deux nuits, de jour). -2. Jours superposés : chaque mesure moins le niveau de la dernière nuit commencée à son instant (la précédente, ou - celle en cours ; sans elle, la nuit la plus proche). PNG « parheure- » : un petit graphique par capteur, - en abscisse l'heure du jour (UTC), une courbe par jour, heures de nuit grisées, une échelle par capteur, cadrée du 1er au 99e centile élargi de moitié (le titre dit - combien de mesures sortent du cadre : un pic isolé n'écrase pas l'échelle ; sa valeur est dans les tables). - Table : par créneau de --pas de l'heure du jour, les capteurs dont l'écart dépasse --k bruits à ce créneau, du - même côté, au moins --jours jours différents, avec le nombre de ces jours sur le nombre de jours mesurés et la - médiane de ces écarts (signée, en unités et en bruits) ; un capteur au-dessus certains jours et au-dessous - d'autres est cité deux fois. -3. Avec --bornes : chaque jour face à la nuit qui le précède, pour la médiane des cibles de chaque colonne (avec - --capteurs : la médiane de ces capteurs, références comprises ; un seul capteur : le sien) et pour la pose de la - caméra (pan, tilt, rotation, scale, sigma0) si camera/ existe. Un « jour » : de la fin d'une nuit à la fin de la - suivante (24 h), daté du jour où il commence ; son niveau de référence est celui de la nuit qui vient de finir (sans - elle, la dernière nuit mesurée avant, ou au début du lot la première : nommée, « pas la précédente »). Écart de chaque mesure à ce niveau (médiane des cibles : à chaque - instant, médiane des écarts de chaque cible à son propre niveau de cette nuit) ; bruit : médiane des écarts entre - deux valeurs consécutives de cette suite. Par jour : nombre de mesures, première et dernière ; premier et dernier - instant où |écart| dépasse --k bruits, avec la mesure juste avant et juste après (au pas natif) ; le maximum et le - minimum signés et leur instant ; autour du plus grand des deux en valeur absolue, la suite de mesures consécutives - au-delà de --k bruits du même côté qui le contient, avec la mesure juste avant et juste après ; la nuit suivante - moins la nuit de référence. Un jour sans mesure le dit. Chaque ligne de jour commence par le nom court de la suite - (la colonne, ou pose_tilt…) : `| grep '^pose_tilt '` en garde une, `| grep ' 12/10 '` un jour. Avec --lissage N, - l'écart de chaque mesure est la médiane des N mesures du jour centrées sur elle (le bruit reste celui des mesures, - la figure trace aussi l'écart brut en gris) : un point isolé ne coupe plus la suite autour de l'extrême et ne fait - plus un premier ou un dernier dépassement. Avec --fraction F, le seuil de chaque jour est F fois le plus grand - |écart| de ce jour (au lieu de --k bruits ; il est imprimé sur la ligne du jour) : sur une suite très bruitée, ou - dont le bruit au pas natif est sans rapport avec l'ampleur du cycle. PNG - « bornes » : un panneau par suite, l'écart sur le lot, ±k bruits en pointillé, de chaque jour [premier, dernier] - grisé clair et la suite autour de l'extrême grisée foncé, le maximum et le minimum marqués ; cadré du 1er au 99e - centile élargi de moitié (le titre dit combien de mesures sortent du cadre). -Rend des valeurs, pas de verdict. -""" -import argparse -import math -import os -import statistics -import sys -from datetime import datetime, timedelta, timezone - -import matplotlib - -matplotlib.use("Agg") -import matplotlib.pyplot as plt # noqa: E402 - -from donnees import POSE, charger, charger_camera, est_reference, filtrer, instant, iso, rejetee # noqa: E402 -from graphique import COLONNES, RACINE, borne # noqa: E402 -from resume import ARRONDI, bruit_propre, duree # noqa: E402 - - -def heures(texte): - """'20-3' -> (20, 3).""" - try: - h1, h2 = (int(x) for x in texte.split("-")) - except ValueError: - raise argparse.ArgumentTypeError(f"heures invalides : {texte!r} (ex. 20-3)") - return h1, h2 - - -def de_nuit(t, h1, h2): - return (h1 <= t.hour or t.hour < h2) if h1 > h2 else h1 <= t.hour < h2 - - -def coupure(pts, la, lb): - """Indice j (1..n-1) où sum|v-la| avant j + sum|v-lb| à partir de j est le plus petit.""" - avant, apres = 0.0, sum(abs(v - lb) for _, v in pts) - meilleur = None - for j in range(1, len(pts)): - v = pts[j - 1][1] - avant += abs(v - la) - apres -= abs(v - lb) - if meilleur is None or avant + apres < meilleur[0]: - meilleur = (avant + apres, j) - return meilleur[1] - - -def main(): - a = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) - a.add_argument("dossier") - a.add_argument("--colonnes", default="corr_x,corr_y,error_value") - a.add_argument("--nuit", default="20-3", type=heures, help="heures de nuit H1-H2, UTC (défaut 20-3)") - a.add_argument("--k", type=float, default=5, help="écart au niveau de la nuit compté, en bruits propres du capteur") - a.add_argument("--jours", type=int, default=2, help="nombre de jours à partir duquel un capteur est cité à un créneau") - a.add_argument("--pas", default="15min", type=duree, help="largeur des créneaux de l'heure du jour (défaut 15min)") - a.add_argument("--capteurs", help="liste séparée par des virgules (défaut : tous)") - a.add_argument("--bornes", action="store_true", help="ajoute, jour par jour, les bornes de l'écart au niveau de la nuit précédente") - a.add_argument("--lissage", type=int, default=1, metavar="N", help="--bornes : écart lissé par la médiane de N mesures centrées (défaut 1 : aucun)") - a.add_argument("--fraction", type=float, metavar="F", help="--bornes : seuil de chaque jour = F fois son plus grand |écart| (au lieu de --k bruits)") - a.add_argument("--debut", type=instant) - a.add_argument("--fin", type=instant) - a.add_argument("--sortie", default=os.path.join(RACINE, "out", "diagnostic"), help="dossier des PNG") - o = a.parse_args() - - par = charger(o.dossier) - if not par: - sys.exit(f"Aucun export « advanced » dans {o.dossier} (voir inventaire.py).") - noms = o.capteurs.split(",") if o.capteurs else sorted(par, key=lambda s: (not est_reference(par[s]), s)) - colonnes = o.colonnes.split(",") - for demandes, connus, quoi in ((noms, par, "Capteurs"), (colonnes, COLONNES, "Colonnes")): - absents = [x for x in demandes if x not in connus] - if absents: - sys.exit(f"{quoi} inconnus : {', '.join(absents)}. Connus : {', '.join(sorted(connus))}.") - series = {s: [m for m in filtrer(par[s], o.debut, o.fin) if not rejetee(m)] for s in noms} - if not any(series.values()): - sys.exit("Aucune mesure acceptée dans la fenêtre demandée.") - h1, h2 = o.nuit - pas = int(o.pas.total_seconds() // 60) - station = os.path.basename(os.path.normpath(o.dossier)) - os.makedirs(o.sortie, exist_ok=True) - lignes = math.ceil(len(noms) / 5) - - for col in colonnes: - print(f"\n== {col} : niveau de chaque nuit ({h1} h → {h2} h UTC), médiane ±MAD (mesures) ; marches d'une nuit à la suivante ==") - creneaux = {} # minute du jour -> {(capteur, au-dessus): {jour: écart}} - bruits = {} - fig, axes = plt.subplots(lignes, 5, sharex=True, figsize=(18, 2.5 * lignes), squeeze=False) - for ax, s in zip(axes.flat, noms): - ms = [(m["t"], m[col]) for m in series[s] if m[col] is not None] - if len(ms) < 2: - print(f"{s:9}(moins de 2 valeurs acceptées)") - ax.axis("off") - continue - bruit = bruits[s] = bruit_propre([v for _, v in ms]) - nuits = {} - for t, v in ms: - if de_nuit(t, h1, h2): - nuits.setdefault((t - timedelta(hours=h1)).date(), []).append((t, v)) - niv = {d: statistics.median(v for _, v in p) for d, p in nuits.items()} - cases = [] - for d in sorted(nuits): - vs = [v for _, v in nuits[d]] - cases.append(f"{d:%d/%m} {niv[d]:+.6g} ±{statistics.median(abs(v - niv[d]) for v in vs):.2g} ({len(vs)})") - print(f"{s:9}bruit {bruit:.3g} | " + (" | ".join(cases) if cases else "aucune mesure de nuit")) - jours = sorted(nuits) - for da, db in zip(jours, jours[1:]): - pts = nuits[da] + nuits[db] - j = coupure(pts, niv[da], niv[db]) - d = niv[db] - niv[da] - enb = f"{d / bruit:+.1f}" if bruit else "-" - print(f"{'':9}{da:%d/%m} → {db:%d/%m} : {d:+.4g} ({enb} bruits), entre {iso(pts[j - 1][0])} et {iso(pts[j][0])}") - - def niveau_de(t): - d = (t - timedelta(hours=h1)).date() - if d in niv: - return niv[d] - return niv[min(niv, key=lambda x: abs((x - d).days))] if niv else statistics.median(v for _, v in ms) - - par_jour = {} - for t, v in ms: - e = v - niveau_de(t) - par_jour.setdefault(t.date(), []).append((t.hour + t.minute / 60, e)) - if bruit and abs(e) > o.k * bruit: - c = (t.hour * 60 + t.minute) // pas * pas - creneaux.setdefault(c, {}).setdefault((s, e > 0), {})[t.date()] = e - for i, (d, p) in enumerate(sorted(par_jour.items())): - ax.plot([x for x, _ in p], [e for _, e in p], "-", lw=0.8, color=f"C{i % 10}", label=f"{d:%d/%m}") - ax.axhline(0, color="0.3", ls=":", lw=0.8) - tous = sorted(e for p in par_jour.values() for _, e in p) - q1, q2 = tous[len(tous) // 100], tous[-1 - len(tous) // 100] # cadre du 1er au 99e centile : un pic isolé n'écrase pas l'échelle - marge = (q2 - q1) * 0.5 or 1 - ax.set_ylim(q1 - marge, q2 + marge) - hors_cadre = sum(not q1 - marge <= e <= q2 + marge for e in tous) - for x0, x1 in ((h1, 24), (0, h2)) if h1 > h2 else ((h1, h2),): - ax.axvspan(x0, x1, color="0.9", lw=0) - ax.set_title(s + (" (réf.)" if est_reference(series[s]) else "") + f" bruit {bruit:.2g}" - + (f" ({hors_cadre} hors cadre)" if hors_cadre else ""), fontsize=9) - ax.set_xlim(0, 24) - ax.set_xticks(range(0, 25, 3)) - ax.grid(alpha=0.3) - ax.tick_params(labelsize=7) - if ax is axes.flat[0]: - ax.legend(fontsize=6, ncol=2) - for ax in list(axes.flat)[len(noms):]: - ax.axis("off") - fig.suptitle(f"{station} : {col} moins le niveau de la dernière nuit ({h1} h → {h2} h, grisée), " - "une courbe par jour, en abscisse l'heure du jour (UTC) ; une échelle par capteur") - fig.tight_layout() - chemin = os.path.join(o.sortie, f"{station}_parheure-{col}_{borne(o.debut, 'debut')}_{borne(o.fin, 'fin')}.png") - fig.savefig(chemin, dpi=100, bbox_inches="tight") - plt.close(fig) - print(chemin) - - nb_jours = {s: {} for s in noms} # capteur -> créneau -> jours mesurés - for s in noms: - for m in series[s]: - if m[col] is not None: - nb_jours[s].setdefault((m["t"].hour * 60 + m["t"].minute) // pas * pas, set()).add(m["t"].date()) - print(f"\n{col} : par créneau de {pas} min de l'heure du jour, capteurs à plus de {o.k:g} bruits du niveau de la nuit " - f"au moins {o.jours} jours (jours / jours mesurés, médiane de ces écarts, en bruits)") - vide = True - for c in sorted(creneaux): - cites = [] - for s, haut in ((s, h) for s in noms for h in (True, False)): - ec = creneaux[c].get((s, haut), {}) - if len(ec) >= o.jours: - med = statistics.median(ec.values()) - cites.append(f"{s} {len(ec)}/{len(nb_jours[s].get(c, ()))} {med:+.3g} ({med / bruits[s]:+.1f})") - if cites: - vide = False - print(f"{c // 60:02d}:{c % 60:02d} {len(cites):2} capteurs : " + ", ".join(cites)) - if vide: - print("(aucun)") - - if o.bornes: - bornes(o, noms, series, colonnes, station) - - -def niveaux_de_nuit(pts, h1, h2): - """[(t, v)] -> {date de la nuit: médiane}.""" - nuits = {} - for t, v in pts: - if de_nuit(t, h1, h2): - nuits.setdefault((t - timedelta(hours=h1)).date(), []).append(v) - return {d: statistics.median(v) for d, v in nuits.items()} - - -def bornes(o, noms, series, colonnes, station): - """Section 3 : par jour, l'écart au niveau de la nuit qui le précède, pour la médiane des cibles et la pose.""" - h1, h2 = o.nuit - duree_nuit = timedelta(hours=(h2 - h1) % 24) - choisis = noms if o.capteurs else [s for s in noms if series[s] and not est_reference(series[s])] or noms - suites = [(f"{col} médiane de {len(choisis)} capteur(s)" if len(choisis) > 1 else f"{col} {choisis[0]}", col, - {s: [(m["t"], m[col]) for m in series[s] if m[col] is not None] for s in choisis}) for col in colonnes] - poses = filtrer(charger_camera(o.dossier), o.debut, o.fin) - suites += [(f"pose {c}", f"pose_{c}", {c: [(p["t"], p[c]) for p in poses if p[c] is not None]}) for c in POSE - if any(p[c] is not None for p in poses)] - tous = [t for _, _, d in suites for p in d.values() for t, _ in p] - t0, t1 = min(tous), max(tous) - nuit_de = lambda t: (t - duree_nuit - timedelta(hours=h1)).date() # nuit qui finit avant t (le jour de t commence à sa fin) - jours = [nuit_de(t0) + timedelta(days=i) for i in range((nuit_de(t1) - nuit_de(t0)).days + 1)] - hm = lambda t: f"{t:%d/%m %H:%M}" - seuil_txt = f"seuil {o.fraction:g} fois le plus grand |écart| du jour" if o.fraction else f"seuil {o.k:g} bruits" - print(f"\n== Bornes de chaque jour : écart au niveau de la nuit qui le précède ({h1} h → {h2} h UTC), {seuil_txt}" - + (f", écart lissé sur {o.lissage} mesures" if o.lissage > 1 else "") + " ==") - print("jour : de la fin d'une nuit à la fin de la suivante, daté de son début ; « avant », « après » : mesure juste avant le premier " - "dépassement, juste après le dernier ; nuit suivante : son niveau moins celui de la nuit de référence") - fig, axes = plt.subplots(len(suites), 1, sharex=True, figsize=(18, 2.2 * len(suites)), squeeze=False) - for ax, (nom, court, par_capteur) in zip(axes.flat, suites): - niv = {s: niveaux_de_nuit(p, h1, h2) for s, p in par_capteur.items()} - nuits = sorted({d for n in niv.values() for d in n}) - ecarts = [] # (jour, nuit de réf., [(t, écart)], écart de la nuit suivante) - for d in jours: - debut = datetime.combine(d, datetime.min.time(), tzinfo=timezone.utc) + timedelta(hours=h1) + duree_nuit - fin = debut + timedelta(days=1) - ref = max((n for n in nuits if n <= d), default=None) or (min(nuits) if nuits else None) - par_t = {} - for s, p in par_capteur.items(): - if ref in niv[s]: - for t, v in p: - if debut <= t < fin: - par_t.setdefault(t, []).append(v - niv[s][ref]) - suivante = [niv[s][d + timedelta(days=1)] - niv[s][ref] for s in niv if ref in niv[s] and d + timedelta(days=1) in niv[s]] - ecarts.append((debut.date(), d, ref, [(t, statistics.median(e)) for t, e in sorted(par_t.items())], - statistics.median(suivante) if suivante else None)) - diffs = [abs(b[1] - a_[1]) for *_, p, _ in ecarts for a_, b in zip(p, p[1:])] - bruit = statistics.median(diffs) if diffs else 0 - bruit = bruit if bruit >= ARRONDI else 0 - print(f"\n{nom} : bruit {bruit:.3g}") - enb = lambda e: f"{e:+.4g} ({e / bruit:+.1f})" if bruit else f"{e:+.4g}" - h = o.lissage // 2 - for jour, d, ref, brut, suiv in ecarts: - if not brut: - print(f"{court} {jour:%d/%m} aucune mesure" + ("" if nuits else " de nuit")) - continue - p = [(t, statistics.median(e for _, e in brut[max(0, i - h):i + h + 1])) for i, (t, _) in enumerate(brut)] if h else brut - seuil = o.fraction * max(abs(e) for _, e in p) if o.fraction else o.k * bruit - ligne = (f"{court} {jour:%d/%m} nuit {ref:%d/%m}" + (" (pas la précédente)" if ref != d else "") + f" | {len(p)} mesures {hm(p[0][0])} → {hm(p[-1][0])} | " - + (f"seuil {seuil:.4g} | " if o.fraction else "")) - hors = [i for i, (_, e) in enumerate(p) if seuil and abs(e) > seuil] - if hors: - i, j = hors[0], hors[-1] - ligne += (f"> {'seuil' if o.fraction else f'{o.k:g} bruits'} : {len(hors)} mesures, de {hm(p[i][0])} (avant {hm(p[i - 1][0]) if i else '-'}) " - f"à {hm(p[j][0])} (après {hm(p[j + 1][0]) if j + 1 < len(p) else '-'})") - ax.axvspan(p[i][0], p[j][0], color="0.85", lw=0) - else: - ligne += f"jamais > {'seuil' if o.fraction else f'{o.k:g} bruits'}" - haut, bas = max(p, key=lambda x: x[1]), min(p, key=lambda x: x[1]) - ligne += f" | max {enb(haut[1])} à {hm(haut[0])}, min {enb(bas[1])} à {hm(bas[0])}" - x = max(range(len(p)), key=lambda i: abs(p[i][1])) - signe = 1 if p[x][1] > 0 else -1 - if seuil and signe * p[x][1] > seuil: - i = j = x - while i > 0 and signe * p[i - 1][1] > seuil: - i -= 1 - while j + 1 < len(p) and signe * p[j + 1][1] > seuil: - j += 1 - ligne += (f" | autour du {'max' if signe > 0 else 'min'} : {j - i + 1} mesures, de {hm(p[i][0])} (avant {hm(p[i - 1][0]) if i else '-'}) " - f"à {hm(p[j][0])} (après {hm(p[j + 1][0]) if j + 1 < len(p) else '-'})") - ax.axvspan(p[i][0], p[j][0], color="0.7", lw=0) - ligne += f" | nuit suivante {enb(suiv)}" if suiv is not None else " | nuit suivante non mesurée" - print(ligne) - if h: - ax.plot([t for t, _ in brut], [e for _, e in brut], "-", lw=0.5, color="0.6") - ax.plot([t for t, _ in p], [e for _, e in p], "-", lw=0.8, color="C0") - ax.plot([haut[0], bas[0]], [haut[1], bas[1]], "o", ms=3, color="C3") - if bruit and not o.fraction: - for y in (o.k * bruit, -o.k * bruit): - ax.axhline(y, color="0.4", ls=":", lw=0.8) - ax.axhline(0, color="0.3", lw=0.5) - tous_e = sorted(e for *_, p, _ in ecarts for _, e in p) - hors_cadre = 0 - if tous_e: # cadre du 1er au 99e centile élargi de moitié, comme parheure : un pic isolé n'écrase pas l'échelle - q1, q2 = tous_e[len(tous_e) // 100], tous_e[-1 - len(tous_e) // 100] - marge = (q2 - q1) * 0.5 or 1 - ax.set_ylim(q1 - marge, q2 + marge) - hors_cadre = sum(not q1 - marge <= e <= q2 + marge for e in tous_e) - ax.set_title(f"{nom} bruit {bruit:.2g}" + (f" ({hors_cadre} hors cadre)" if hors_cadre else ""), fontsize=9) - ax.grid(alpha=0.3) - ax.tick_params(labelsize=7) - fig.suptitle(f"{station} : écart au niveau de la nuit qui précède chaque jour ({h1} h → {h2} h) ; " - f"grisé clair : du premier au dernier dépassement {'du seuil (' + seuil_txt + ')' if o.fraction else f'de {o.k:g} bruits'}, foncé : la suite autour de l'extrême ; points : max et min du jour" - + (f" ; écart lissé sur {o.lissage} mesures (bleu), brut (gris)" if o.lissage > 1 else "")) - fig.tight_layout() - chemin = os.path.join(o.sortie, f"{station}_bornes_{borne(o.debut, 'debut')}_{borne(o.fin, 'fin')}.png") - fig.savefig(chemin, dpi=100, bbox_inches="tight") - plt.close(fig) - print(chemin) - - -if __name__ == "__main__": - main() diff --git a/agent-tools/metriques.py b/agent-tools/metriques.py deleted file mode 100644 index 1a6160f..0000000 --- a/agent-tools/metriques.py +++ /dev/null @@ -1,264 +0,0 @@ -"""Métriques système de la station (metrics/ : températures, tension, batterie, lien…), en table et en figure, -face à la médiane des cibles de corr_x, corr_y et à la pose de la caméra. - -Usage : .venv/bin/python agent-tools/metriques.py data/PS_DES_COUDRES/ - [--noms sensor_A0_deg_c,BusVoltage] [--pas 1h] [--stat median|min|max] [--contre temperature] [--lissage 24h] - [--metriques-seules] [--debut ...] [--fin ...] [--sortie DOSSIER] - -Colonnes : `temperature` (médiane des composants sensor_*_deg_c à chaque heure, comme la lisent les détecteurs, -donnees.charger_temperature), puis chaque métrique de --noms (défaut : les *_deg_c et BusVoltage présents), puis, -sauf --metriques-seules, cib_corr_x, cib_corr_y (à chaque mesure, médiane sur les cibles de corr moins le niveau -propre de la cible, sa médiane sur la fenêtre ; mesures acceptées seulement) et la pose brute de la caméra (cam_pan, -cam_tilt, cam_rotation, cam_scale, cam_sigma0). Une case vide d'un CSV de metrics/ est sautée, pas lue comme zéro. -Une métrique texte (BatteryState, link, last_sync…) est rendue telle quelle (la dernière du pas). -Jamais d'identifiant : SIM_CCID et ip* ne sont ni lus ni listés. -Imprime : les métriques disponibles ; la table, une ligne par pas de --pas (début du pas, UTC ; --stat des valeurs du -pas ; « - » : aucune valeur), les pas où aucune métrique n'a de valeur n'y sont pas ; par colonne, le nombre de pas -remplis, le minimum et le maximum avec leur instant ; la corrélation r et la pente (moindres carrés, sur les pas où -les deux ont une valeur) de chaque colonne numérique sur --contre (défaut temperature ; avec --lissage D, sur sa -moyenne glissante centrée sur D, colonne _lisse) ; les suites datées de pas sans aucune métrique. -Un PNG, chemin imprimé : températures sur un panneau, chaque autre métrique numérique sur le sien, puis cib_corr_x, -cib_corr_y et la pose, aux instants natifs (trait coupé sur un trou). Rend des valeurs, pas de verdict. -""" -import argparse -import csv -import glob -import os -import statistics -import sys -from datetime import date, timedelta - -import matplotlib - -matplotlib.use("Agg") -import matplotlib.dates as mdates # noqa: E402 -import matplotlib.pyplot as plt # noqa: E402 - -from donnees import POSE, charger, charger_camera, charger_temperature, est_reference, filtrer, instant, iso # noqa: E402 -from graphique import RACINE, borne # noqa: E402 -from inventaire import METRIQUE_RE # noqa: E402 -from resume import STATS, duree # noqa: E402 - - -def identifiant(nom): - """Métrique qui porte un identifiant (carte SIM, adresses IP) : jamais lue.""" - return nom == "SIM_CCID" or nom.startswith("ip") - - -def valeur(texte): - v = texte.strip().strip("[]").strip("'\"") - try: - return float(v) - except ValueError: - return v or None - - -def lire_metriques(dossier, debut, fin): - """metrics/ -> {nom: [{'t', 'v'}]} triées, sur la fenêtre ; v float ou texte ; case vide sautée ; nom sans valeur : [].""" - prefixe = os.path.basename(os.path.normpath(dossier)) + "_" - par = {} - for p in glob.glob(os.path.join(dossier, "metrics", "*.csv")): - m = METRIQUE_RE.match(os.path.basename(p)) - if not m: - continue - nom = m.group(1) - nom = nom[len(prefixe):] if nom.startswith(prefixe) else nom.split("_", 1)[-1] - if identifiant(nom): - continue - jour = date(*map(int, m.group(2, 3, 4))) - serie = par.setdefault(nom, {}) - if (debut and jour < debut.date() - timedelta(days=1)) or (fin and jour > fin.date()): - continue - with open(p, newline="") as f: - for r in csv.DictReader(f): - if (v := valeur(r.get("metric") or "")) is not None: - serie[instant(r["time_utc"])] = v - return {n: filtrer([{"t": t, "v": s[t]} for t in sorted(s)], debut, fin) for n, s in par.items()} - - -def cibles(par, col, debut, fin): - """À chaque mesure, médiane sur les cibles de col moins le niveau propre de la cible (médiane sur la fenêtre).""" - ecarts = {} - for s, ms in par.items(): - if est_reference(ms): - continue - ms = [m for m in filtrer(ms, debut, fin) if m[col] is not None] - if ms: - niveau = statistics.median(m[col] for m in ms) - for m in ms: - ecarts.setdefault(m["t"], []).append(m[col] - niveau) - return [{"t": t, "v": statistics.median(v)} for t, v in sorted(ecarts.items())] - - -def lisser(serie, largeur): - """Moyenne glissante centrée sur largeur (valeurs numériques).""" - pts = [p for p in serie if isinstance(p["v"], float)] - # ponytail: O(n²), assez pour des métriques horaires sur quelques semaines - return [{"t": p["t"], "v": statistics.fmean(q["v"] for q in pts if abs(q["t"] - p["t"]) <= largeur / 2)} for p in pts] - - -def fmt(v): - return "-" if v is None else f"{v:.6g}" if isinstance(v, float) else str(v) - - -def suites(pas_vides, pas): - """[t] triés -> [(début, fin, n)] de pas consécutifs.""" - out = [] - for t in pas_vides: - if out and t - out[-1][1] == pas: - out[-1] = (out[-1][0], t, out[-1][2] + 1) - else: - out.append((t, t, 1)) - return out - - -def coupe(serie): - """Instants et valeurs numériques, NaN inséré sur un écart de plus de 1,5 fois le pas habituel (le trait se coupe).""" - pts = [(p["t"], p["v"]) for p in serie if isinstance(p["v"], float)] - if len(pts) < 3: - return [t for t, _ in pts], [v for _, v in pts] - pas = statistics.median(b[0] - a[0] for a, b in zip(pts, pts[1:])) - ts, vs = [pts[0][0]], [pts[0][1]] - for (a, _), (b, v) in zip(pts, pts[1:]): - if b - a > 1.5 * pas: - ts.append(a + (b - a) / 2) - vs.append(float("nan")) - ts.append(b) - vs.append(v) - return ts, vs - - -def main(): - a = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) - a.add_argument("dossier") - a.add_argument("--noms", help="métriques, séparées par des virgules (défaut : les *_deg_c et BusVoltage présents)") - a.add_argument("--pas", default="1h") - a.add_argument("--stat", default="median", choices=STATS) - a.add_argument("--contre", default="temperature", help="colonne sur laquelle r et la pente sont calculés") - a.add_argument("--lissage", type=duree, help="moyenne glissante centrée de --contre, ex. 24h") - a.add_argument("--metriques-seules", action="store_true", help="sans cib_corr_x, cib_corr_y ni la pose") - a.add_argument("--debut", type=instant) - a.add_argument("--fin", type=instant) - a.add_argument("--sortie", default=os.path.join(RACINE, "out", "diagnostic"), help="dossier du PNG") - o = a.parse_args() - pas = duree(o.pas) - - met = lire_metriques(o.dossier, o.debut, o.fin) - if not met: - print(f"Pas de metrics/ dans {o.dossier}.") - else: - print("Métriques disponibles (valeurs sur la fenêtre ; identifiants SIM_CCID, ip* exclus) : " - + ", ".join(f"{n} ({len(s)})" if s else f"{n} (vide)" for n, s in sorted(met.items()))) - if o.noms: - noms = o.noms.split(",") - if interdits := [n for n in noms if identifiant(n)]: - sys.exit(f"Identifiants, jamais lus : {', '.join(interdits)}.") - if absents := [n for n in noms if n not in met]: - sys.exit(f"Métriques inconnues : {', '.join(absents)}. Connues : {', '.join(sorted(met))}.") - else: - noms = sorted(n for n in met if n.endswith("_deg_c")) + [n for n in ("BusVoltage",) if n in met] - series = {"temperature": filtrer([{"t": t, "v": v} for t, v in charger_temperature(o.dossier)], o.debut, o.fin)} - series.update({n: met[n] for n in noms}) - if o.lissage: - if o.contre not in series: - sys.exit(f"--contre {o.contre} : pas une colonne ({', '.join(series)}).") - series[o.contre + "_lisse"] = lisser(series[o.contre], o.lissage) - metriques = list(series) - if not o.metriques_seules: - par = charger(o.dossier) - for c in ("corr_x", "corr_y"): - series["cib_" + c] = cibles(par, c, o.debut, o.fin) - poses = filtrer(charger_camera(o.dossier), o.debut, o.fin) - for c in POSE: - series["cam_" + c] = [{"t": p["t"], "v": p[c]} for p in poses if p[c] is not None] - reference = o.contre + "_lisse" if o.lissage else o.contre - if reference not in series: - sys.exit(f"--contre {o.contre} : pas une colonne ({', '.join(series)}).") - tous = [p["t"] for s in series.values() for p in s] - if not tous: - sys.exit("Aucune valeur dans la fenêtre demandée.") - - t0 = (o.debut or min(tous)).replace(minute=0, second=0, microsecond=0) - t1 = o.fin or max(tous) - cases = {} # colonne -> début du pas -> valeurs - for c, s in series.items(): - for p in s: - cases.setdefault(c, {}).setdefault(t0 + ((p["t"] - t0) // pas) * pas, []).append(p["v"]) - stat = STATS[o.stat] - table = {c: {k: (stat(v) if all(isinstance(x, float) for x in v) else v[-1]) for k, v in d.items()} - for c, d in cases.items()} - grille = [t0 + i * pas for i in range(int((t1 - t0) / pas) + 1)] - colonnes = list(series) - - print(f"\n{o.stat} par pas de {o.pas} (début du pas, UTC) ; « - » : aucune valeur ; cib_ : écart au niveau propre des cibles") - print("\t".join(["heure"] + colonnes)) - for k in grille: - ligne = [table.get(c, {}).get(k) for c in colonnes] - if any(v is not None for v in ligne): - print("\t".join([iso(k)] + [fmt(v) for v in ligne])) - - print(f"\nPar colonne ({len(grille)} pas) :") - for c in colonnes: - d = table.get(c, {}) - nums = [(v, k) for k, v in d.items() if isinstance(v, float)] - if not d: - print(f" {c} : vide") - elif nums: - (vmin, kmin), (vmax, kmax) = min(nums), max(nums) - print(f" {c} : {len(d)} pas ; min {fmt(vmin)} ({iso(kmin)}) ; max {fmt(vmax)} ({iso(kmax)})") - else: - ks = sorted(d) - print(f" {c} : {len(d)} pas, texte ; {len(set(d.values()))} valeurs distinctes ; " - f"première {d[ks[0]]} ({iso(ks[0])}) ; dernière {d[ks[-1]]} ({iso(ks[-1])})") - - ref = table.get(reference, {}) - print(f"\nCorrélation r et pente sur {reference} (par pas où les deux ont une valeur) :") - if not any(isinstance(v, float) for v in ref.values()): - print(f" {reference} vide : aucune") - for c in colonnes: - if c == reference or not ref or not any(isinstance(v, float) for v in table.get(c, {}).values()): - continue - paires = [(ref[k], v) for k, v in table.get(c, {}).items() - if isinstance(v, float) and isinstance(ref.get(k), float)] - try: - r = statistics.correlation(*zip(*paires)) - pente = statistics.linear_regression(*zip(*paires)).slope - print(f" {c} : r = {r:+.2f} ; pente = {pente:.4g} par unité de {reference} ; n = {len(paires)}") - except (statistics.StatisticsError, TypeError, ValueError): - print(f" {c} : - (n = {len(paires)})") - - vides = [k for k in grille if all(k not in table.get(c, {}) for c in metriques)] - print(f"\nPas sans aucune métrique ({', '.join(metriques)}) : {len(vides)} sur {len(grille)}") - for d, f, n in suites(vides, pas): - print(f" {iso(d)} → {iso(f)} ({n} pas)") - - panneaux = {} # titre -> colonnes - for c in colonnes: - if any(isinstance(p["v"], float) for p in series[c]): - cle = "°C" if c.startswith("temperature") or "_deg_c" in c else c - panneaux.setdefault(cle, []).append(c) - if not panneaux: - print("\nRien à tracer.") - return - fig, axes = plt.subplots(len(panneaux), 1, sharex=True, figsize=(14, 2.4 * len(panneaux)), squeeze=False, - layout="constrained") - for ax, (titre, cols) in zip(axes[:, 0], panneaux.items()): - for c in cols: - noir = c in ("temperature", reference) - ax.plot(*coupe(series[c]), ".-", ms=2, lw=1.4 if noir else 0.7, label=c, zorder=3 if noir else 2, - color="k" if c == "temperature" else None) - if len(cols) > 1: - ax.legend(loc="upper left", bbox_to_anchor=(1.0, 1.0), fontsize=8) - ax.set_ylabel(titre if titre == "°C" else titre.replace("_", "_\n", 1), fontsize=8) - ax.grid(alpha=0.3) - axes[-1, 0].xaxis.set_major_formatter(mdates.DateFormatter("%d/%m\n%H:%MZ")) - station = os.path.basename(os.path.normpath(o.dossier)) - fig.suptitle(f"{station} : métriques, cibles et pose (heures UTC)") - os.makedirs(o.sortie, exist_ok=True) - sortie = os.path.join(o.sortie, f"{station}_metriques_{borne(o.debut, 'debut')}_{borne(o.fin, 'fin')}.png") - fig.savefig(sortie, dpi=100, bbox_inches="tight") - print(f"\n{sortie}") - - -if __name__ == "__main__": - main() diff --git a/agent-tools/plages.py b/agent-tools/plages.py deleted file mode 100644 index 8fe7768..0000000 --- a/agent-tools/plages.py +++ /dev/null @@ -1,156 +0,0 @@ -"""Plages datées par capteur et par colonne, au pas natif des mesures, pour l'agent de diagnostic. - -Usage : python3 agent-tools/plages.py data/PS_DES_COUDRES/ [--colonnes error_value,corr_x,corr_y] - [--k 5] [--fusion 1h] [--min-mesures 1] [--hors T1/T2] [--glissant N|DUREE] [--instants N] - [--capteurs A,B] [--debut ...] [--fin ...] - -Pour chaque colonne, chaque capteur est comparé à son propre niveau sur la fenêtre --debut/--fin (médiane des -valeurs non vides ; avec --hors T1/T2, celle du reste de la fenêtre, hors du moment lu : utile quand un épisode -long fausse la médiane) et à son bruit propre (médiane des écarts entre deux mesures consécutives non vides, hors --hors). -1. Un tableau par colonne : niveau, bruit, et le plus grand saut d'une mesure à la suivante (valeur, en bruits, - les deux instants). -2. Les plages où la colonne s'écarte de son niveau de plus de --k bruits : début et fin (première et dernière - mesure hors niveau), nombre de mesures hors niveau, valeur extrême (écart signé au niveau, en unités et en - bruits) et son instant. Deux plages du même sens séparées de moins de --fusion (défaut 1h) n'en font qu'une - (un écart vers le bas puis vers le haut font deux plages) ; les mesures rejetées (colonne vide) ne coupent pas - une plage. Colonne « rejetées » : combien des mesures de la plage sont rejetées par la station (error_value - au-dessus du seuil), et « extrême rejetée » si l'extrême l'est ; un saut dont un bout est rejeté le dit. - corr_x, corr_y d'une mesure rejetée sont vides, références comprises (donnees.charger). Une plage qui touche le bord de la fenêtre est datée au - bord (le niveau est celui de la fenêtre : un palier durable peut faire de l'autre moitié la « plage »). - Avec --min-mesures N, seules les plages d'au moins N mesures hors niveau sont imprimées (leur nombre total aussi). - Avec --glissant N (un entier : N mesures non vides de part et d'autre) ou --glissant DUREE (6h, 1d : les mesures - à moins de DUREE avant et après), le niveau de chaque mesure est la médiane de ses voisines, sans elle (niveau - local) : une dérive longue ou un palier suivent le niveau, seuls restent les écarts plus brefs que la fenêtre. - La colonne « niveau » du tableau 1 reste la médiane de la fenêtre ; le bruit ne change pas. -3. Avec --instants N : les instants où au moins N capteurs sont hors niveau (sur l'une des colonnes), avec, pour - chacun, les capteurs et l'écart en bruits (cx corr_x, cy corr_y, ev error_value, sinon le nom de la colonne), - les capteurs rejetés à cet instant (parmi --capteurs : en retirer les capteurs toujours rejetés allège la liste), - et chaque référence de la station, --capteurs ou non : error_value (« r » si rejetée) / inlier (« - » vide). -Chaque colonne est lue aux mesures, jamais moyennée par pas. Rend des valeurs, pas de verdict. -""" -import argparse -import bisect -import statistics -import sys - -from donnees import charger, est_reference, filtrer, instant, iso, rejetee -from resume import COLONNES, bruit_propre, duree - -ABREGE = {"corr_x": "cx", "corr_y": "cy", "error_value": "ev"} - - -def locaux(ms, g): - """Niveau local de chaque mesure (t, v) : médiane des voisines non vides, sans elle ; g entier (mesures de part et - d'autre) ou timedelta (mesures à moins de g) ; None sans voisine.""" - ts, vs = [t for t, _ in ms], [v for _, v in ms] - out = [] - for i, t in enumerate(ts): - lo, hi = (max(0, i - g), i + g + 1) if isinstance(g, int) else (bisect.bisect_left(ts, t - g), bisect.bisect_right(ts, t + g)) - w = vs[lo:i] + vs[i + 1:hi] - out.append(statistics.median(w) if w else None) - return out - - -def main(): - a = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) - a.add_argument("dossier") - a.add_argument("--colonnes", default="error_value,corr_x,corr_y") - a.add_argument("--k", type=float, default=5, help="écart au niveau compté, en bruits propres du capteur") - a.add_argument("--fusion", default="1h", type=duree, help="deux plages séparées de moins que cela n'en font qu'une") - a.add_argument("--min-mesures", type=int, default=1, help="n'imprime que les plages d'au moins N mesures hors niveau") - a.add_argument("--hors", help="T1/T2 : niveau et bruit se calculent hors de ce moment (les plages se cherchent partout)") - a.add_argument("--glissant", type=lambda x: int(x) if x.isdigit() else duree(x), - help="N (mesures de part et d'autre) ou durée (6h, 1d) : niveau local, médiane des voisines sans la mesure") - a.add_argument("--instants", type=int, help="N : instants où au moins N capteurs sont hors niveau, avec rejets et références") - a.add_argument("--capteurs", help="liste séparée par des virgules (défaut : tous)") - a.add_argument("--debut", type=instant) - a.add_argument("--fin", type=instant) - o = a.parse_args() - - par = charger(o.dossier) - if not par: - sys.exit(f"Aucun export « advanced » dans {o.dossier} (voir inventaire.py).") - noms = o.capteurs.split(",") if o.capteurs else sorted(par, key=lambda s: (not est_reference(par[s]), s)) - colonnes = o.colonnes.split(",") - hors = tuple(instant(x) for x in o.hors.split("/")) if o.hors else None - if hors and len(hors) != 2: - sys.exit("--hors attend T1/T2.") - for demandes, connus, quoi in ((noms, par, "Capteurs"), (colonnes, COLONNES, "Colonnes")): - absents = [x for x in demandes if x not in connus] - if absents: - sys.exit(f"{quoi} inconnus : {', '.join(absents)}. Connus : {', '.join(sorted(connus))}.") - series = {s: filtrer(par[s], o.debut, o.fin) for s in noms} - if not any(series.values()): - sys.exit("Aucune mesure dans la fenêtre demandée.") - glis = (f"{o.glissant} mesures" if isinstance(o.glissant, int) else f"{int(o.glissant.total_seconds() // 60)} min") if o.glissant is not None else "" - par_instant = {} # iso(t) -> ["capteur.col+écart"] (--instants) - - for col in colonnes: - print(f"\n== {col} : niveau, bruit, plus grand saut d'une mesure à la suivante ==") - print(f"{'capteur':9}{'n':>5}{'niveau':>10}{'bruit':>10}{'saut':>10}{'(bruits)':>9} entre") - plages = [] - for s in noms: - ms = [(m["t"], m[col]) for m in series[s] if m[col] is not None] - rej = {m["t"] for m in series[s] if rejetee(m)} - if len(ms) < 2: - print(f"{s:9}{len(ms):5} (moins de 2 valeurs)") - continue - ref = [x for x in ms if not hors or not hors[0] <= x[0] <= hors[1]] - if len(ref) < 2: - print(f"{s:9}{len(ms):5} (moins de 2 valeurs hors --hors)") - continue - niv = statistics.median(v for _, v in ref) - sauts = [(b[1] - a_[1], a_[0], b[0]) for a_, b in zip(ms, ms[1:])] - bruit = bruit_propre([v for _, v in ref]) - d, t1, t2 = max(sauts, key=lambda x: abs(x[0])) - bru = f"{d / bruit:9.1f}" if bruit else f"{'-':>9}" - marque = [iso(x) for x in (t1, t2) if x in rej] - print(f"{s:9}{len(ms):5}{niv:10.4g}{bruit:10.3g}{d:+10.4g}{bru} {iso(t1)} et {iso(t2)}" - + (f" (rejetée : {', '.join(marque)})" if marque else "")) - if not bruit: - continue - lv = locaux(ms, o.glissant) if o.glissant is not None else [niv] * len(ms) - groupe = [] # (t, écart au niveau) - for (t, v), n in zip(ms + [(None, 0)], lv + [None]): - if t is not None and n is not None and abs(v - n) > o.k * bruit: - if groupe and (t - groupe[-1][0] > o.fusion or (v > n) != (groupe[-1][1] > 0)): # même sens seul - plages.append((s, groupe, bruit, rej)) - groupe = [] - groupe.append((t, v - n)) - par_instant.setdefault(iso(t), {}).setdefault(s, []).append(f"{ABREGE.get(col, col)}{(v - n) / bruit:+.0f}") - elif t is None and groupe: - plages.append((s, groupe, bruit, rej)) - toutes = len(plages) - plages = [p for p in plages if len(p[1]) >= o.min_mesures] - print(f"\n{col} : plages à plus de {o.k:g} bruits du niveau{' glissant ±' + glis + ' (médiane des voisines)' if glis else ''}{' (niveau hors ' + o.hors + ')' if hors and not glis else ''}{' (bruit hors ' + o.hors + ')' if hors and glis else ''} (fusion {int(o.fusion.total_seconds() // 60)} min)" - + (f" ; {len(plages)} d'au moins {o.min_mesures} mesures sur {toutes}" if o.min_mesures > 1 else "")) - print(f"{'capteur':9}{'début':<18}{'fin':<18}{'mesures':>8}{'extrême':>10}{'(bruits)':>9} {'à':<17}{'rejetées':>9}") - for s, g, bruit, rej in plages: - t, d = max(g, key=lambda x: abs(x[1])) - print(f"{s:9}{iso(g[0][0]):<18}{iso(g[-1][0]):<18}{len(g):8}{d:+10.4g}{d / bruit:9.1f} {iso(t):<17}" - f"{sum(x[0] in rej for x in g):9}{' extrême rejetée' if t in rej else ''}") - if not plages: - print("(aucune)") - - if o.instants is not None: - refs = sorted(s for s in par if est_reference(par[s])) - rej_t, ref_t = {}, {s: {} for s in refs} - for s in set(noms) | set(refs): - for m in filtrer(par[s], o.debut, o.fin): - if rejetee(m) and s in noms: - rej_t.setdefault(iso(m["t"]), []).append(s) - if s in ref_t: - ref_t[s][iso(m["t"])] = m - f = lambda v, fmt: "-" if v is None else format(v, fmt) - lignes = [(t, c) for t, c in sorted(par_instant.items()) if len(c) >= o.instants] - print(f"\nInstants où au moins {o.instants} capteurs sont à plus de {o.k:g} bruits du niveau{' glissant ±' + glis if glis else ''} " - f"({', '.join(colonnes)}) : {len(lignes)} sur {len(par_instant)} instants avec au moins un capteur hors niveau") - print("instant n capteurs hors niveau (écart en bruits) | rejetés | références : error_value (r rejetée) / inlier") - for t, c in lignes: - r = " ".join(f"{s} {f(ref_t[s][t]['error_value'], '.3g')}{'r' if rejetee(ref_t[s][t]) else ''}/{f(ref_t[s][t]['inlier'], 'g')}" - for s in refs if t in ref_t[s]) - print(f"{t} {len(c):3} {' '.join(s + '.' + ','.join(v) for s, v in c.items())} | {','.join(rej_t.get(t, [])) or '-'} | {r or '-'}") - - -if __name__ == "__main__": - main() diff --git a/agent-tools/qualite.py b/agent-tools/qualite.py deleted file mode 100644 index d8910a6..0000000 --- a/agent-tools/qualite.py +++ /dev/null @@ -1,418 +0,0 @@ -"""Les six métriques de qualité d'image (peak, flux, sharpness, fwhm, dominance, snr) par capteur, face à sa référence calme. - -Usage : python3 agent-tools/qualite.py [--debut T] [--fin T] [--capteurs A,B] [--calme T1/T2,T3/T4] - [--commun] [--table METRIQUE] [--pas 15min] [--seuil 0.5] - python3 agent-tools/qualite.py --etiquettes labeling/auto/X.jsonl [--calme ...] [--debut T] [--fin T] - [--numeros 3,7] [--seuil 0.5] [--marge 60] [--bords] | [--hors [--min 1] [--sauf "Thermal displacement"]] - .venv/bin/python agent-tools/qualite.py --figure [--calme ...] [--debut T] [--fin T] - [--metriques flux,snr,dominance] [--etiquettes F] [--zone T1/T2 ...] [--sortie D] - python3 agent-tools/qualite.py --essai (contrôle du calcul du rapport) - -Définitions : labeling/connaissances/metriques-de-qualite.md. Colonnes remplies sur les caméras récentes seulement ; sur un dossier où -elles sont vides, l'outil le dit et s'arrête. -Référence d'un capteur : la médiane de chaque métrique sur ses mesures des fenêtres --calme, à la même heure UTC du jour -(24 créneaux ; un créneau sans mesure calme prend la médiane de toutes les heures calmes). Sans --calme : tout le dossier. -Chaque mesure devient un rapport valeur / référence : 1 = comme la référence ; < 1 plus bas ; > 1 plus haut. Pour fwhm et -dominance, c'est la hausse qui dit une image dégradée (tache plus large, second pic plus fort). Mesures rejetées comprises -(la qualité de leur image reste mesurée). - -Sans --etiquettes ni --figure : -1. le peak maximal du dossier, puis le résumé par capteur : mesures rejetées, « pk/max » (peak médian du capteur sur la - fenêtre divisé par ce maximum : une tache au plafond de l'image a un peak constant), et pour chaque métrique le rapport médian sur la fenêtre et l'extrême (min pour peak, flux, sharpness, snr ; max pour - fwhm, dominance) avec son instant ; puis les lignes « cibles » et « références » : la médiane des rapports médians ; -2. --commun : par pas de --pas, la médiane des rapports des cibles et celle des références, pour chaque métrique ; -3. --table M : par pas, le rapport de M de chaque capteur (« * » : une mesure du pas rejetée), « méd » (médiane sur les - capteurs) et le nombre de capteurs sous --seuil (au-dessus de 1/--seuil pour fwhm et dominance). ---etiquettes F (un JSON par ligne, debut, fin, categorie), sans --figure : par étiquette (numérotée dans l'ordre du -fichier ; --debut/--fin gardent celles qui y commencent), le rapport médian des cibles et des références sur l'heure -d'avant, la plage et l'heure d'après (--marge minutes) : « cib 0.95|0.40|0.97 » ; puis les capteurs « touchés » sur la -plage (flux ou snr sous --seuil, ou dominance au-dessus de 1/--seuil), avec leur pire rapport de flux, du plus bas au plus -haut (r = référence). --bords : par instant de la plage élargie de --marge, le nombre de capteurs touchés et la médiane -des cibles de flux, snr, dominance (« < » : dans la plage). --hors : à la place, les suites d'instants de --debut à --fin -qu'aucune étiquette ne couvre (hors familles --sauf), où au moins --min capteurs sont touchés (instants à moins de 15 min -groupés), avec les capteurs touchés et leur pire flux. ---figure (matplotlib) : PNG « qualite-commun » : un panneau par métrique, échelle logarithmique, médiane des cibles (noir), -des références (rouge) et bande du 10e au 90e centile des cibles ; PNG « qualite- » par --metriques : un petit -graphique par capteur, références en rouge. --etiquettes grise chaque étiquette d'une couleur par famille ; --zone grise -des plages. Trait coupé sur un trou de plus de 30 min. Imprime le chemin de chaque PNG. -Rend des valeurs, pas de verdict. Lancé depuis la racine du dépôt. -""" -import argparse -import bisect -import json -import os -import statistics -import sys -from datetime import timedelta - -import donnees -from resume import QUALITE as METRIQUES, duree - -HAUT_MAUVAIS = ("fwhm", "dominance") # pour ces deux-là, c'est la hausse qui dit une image dégradée -RACINE = os.path.normpath(os.path.join(os.path.dirname(os.path.abspath(__file__)), "..")) -COULEURS = {"Visibility": "tab:blue", "Obstruction": "tab:orange", "Thermal displacement": "tab:red", - "Displacement": "tab:purple", "Target issue": "tab:brown", "No data": "black"} - - -def fenetres(texte): - """'T1/T2,T3/T4' -> [(début, fin)].""" - return [tuple(donnees.instant(b) for b in f.split("/")) for f in texte.split(",")] if texte else [] - - -def dans(t, fen): - return any(a <= t <= b for a, b in fen) - - -def references(par, calme): - """{capteur: {métrique: {heure: médiane, None: médiane toutes heures}}} sur les mesures calmes.""" - ref = {} - for s, ms in par.items(): - ref[s] = {} - for c in METRIQUES: - parh, tout = {}, [] - for m in ms: - if m[c] is None or (calme and not dans(m["t"], calme)): - continue - parh.setdefault(m["t"].hour, []).append(m[c]) - tout.append(m[c]) - r = {h: statistics.median(v) for h, v in parh.items()} - r[None] = statistics.median(tout) if tout else None - ref[s][c] = r - return ref - - -def rapport(ref, s, c, m): - r = ref[s][c].get(m["t"].hour, ref[s][c][None]) - return m[c] / r if m[c] is not None and r else None - - -def touche(r, c, seuil): - return r is not None and ((c in ("flux", "snr") and r < seuil) or (c == "dominance" and r > 1 / seuil)) - - -def med(v): - return f"{statistics.median(v):.2f}" if v else "-" - - -def resume(par, ref, noms, refs, pmax): - print(f"peak maximal du dossier : {pmax if pmax is None else f'{pmax:g}'} ; pk/max : peak médian du capteur sur la " - "fenêtre, divisé par ce maximum") - print("Résumé : rapport médian à la référence calme, puis l'extrême et son instant (UTC)") - print(f"{'capteur':>12} {'rej':>4} {'pk/max':>6} " + " ".join(f"{c:>26}" for c in METRIQUES)) - meds = {c: {"cibles": [], "références": []} for c in METRIQUES} - for s in noms: - ms = par[s] - if not ms: - continue - cases = [] - for c in METRIQUES: - rs = [(rapport(ref, s, c, m), m["t"]) for m in ms] - rs = [x for x in rs if x[0] is not None] - if not rs: - cases.append(f"{'vide':>26}") - continue - md = statistics.median(r for r, _ in rs) - ext = (max if c in HAUT_MAUVAIS else min)(rs, key=lambda x: x[0]) - meds[c]["références" if s in refs else "cibles"].append(md) - cases.append(f"{md:6.2f} ({ext[0]:6.2f} {ext[1]:%d/%m %H:%M})") - rej = sum(1 for m in ms if donnees.rejetee(m)) - pk = [m["peak"] for m in ms if m["peak"] is not None] - pk = f"{statistics.median(pk) / pmax:6.2f}" if pk and pmax else f"{'-':>6}" - print(f"{s + ('r' if s in refs else ''):>12} {rej:>4} {pk} " + " ".join(cases)) - for g in ("cibles", "références"): - print(f"{g:>24} " + " ".join(f"{statistics.median(meds[c][g]):26.2f}" if meds[c][g] else f"{'-':>26}" - for c in METRIQUES)) - - -def par_pas(par, noms, pas): - pas = duree(pas) - debut = min(m["t"] for s in noms for m in par[s]).replace(hour=0, minute=0, second=0, microsecond=0) - return lambda t: debut + (t - debut) // pas * pas - - -def table(par, ref, noms, c, pas, seuil): - cle, cases = par_pas(par, noms, pas), {} - for s in noms: - for m in par[s]: - r = rapport(ref, s, c, m) - if r is not None: - cases.setdefault(cle(m["t"]), {}).setdefault(s, []).append((r, donnees.rejetee(m))) - haut = c in HAUT_MAUVAIS - print(f"\nTable de {c} / référence, pas de {pas} ('*' : une mesure du pas rejetée)") - w = max(7, *map(len, noms)) - entete = f"{'instant':16} " + " ".join(f"{s:>{w}}" for s in noms) + f" {'méd':>6} {'n' + ('>' if haut else '<') + str(seuil):>6}" - for i, k in enumerate(sorted(cases)): - if i % 24 == 0: - print(entete) - ligne, vals = [], [] - for s in noms: - v = cases[k].get(s) - if not v: - ligne.append(f"{'':>{w}}") - continue - r = statistics.median(x for x, _ in v) - vals.append(r) - ligne.append(f"{r:{w - 1}.2f}" + ("*" if any(j for _, j in v) else " ")) - n = sum(1 for r in vals if (r > 1 / seuil if haut else r < seuil)) - print(f"{k:%Y-%m-%d %H:%M} " + " ".join(ligne) + f" {statistics.median(vals):6.2f} {n:>6}") - - -def commun(par, ref, noms, refs, pas): - """Par pas : médiane des rapports des cibles, puis des références, pour chaque métrique.""" - cle, cases = par_pas(par, noms, pas), {} - for s in noms: - for m in par[s]: - d = cases.setdefault(cle(m["t"]), {c: ([], []) for c in METRIQUES}) - for c in METRIQUES: - r = rapport(ref, s, c, m) - if r is not None: - d[c][s in refs].append(r) - print(f"\nMédianes des rapports par pas de {pas} : cibles / références") - entete = f"{'instant':16} " + " ".join(f"{c:>13}" for c in METRIQUES) - for i, k in enumerate(sorted(cases)): - if i % 24 == 0: - print(entete) - print(f"{k:%Y-%m-%d %H:%M} " + " ".join( - f"{statistics.median(cases[k][c][0]) if cases[k][c][0] else float('nan'):6.2f}/" - f"{statistics.median(cases[k][c][1]) if cases[k][c][1] else float('nan'):<6.2f}" for c in METRIQUES)) - - -def lire_etiquettes(chemin): - return [json.loads(ligne) for ligne in open(chemin) if ligne.strip()] - - -def etiquettes(a, tout, ref, refs, noms, deb, fin): - marge = timedelta(minutes=a.marge) - temps = {s: [m["t"] for m in tout[s]] for s in noms} - garder = {int(n) for n in a.numeros.split(",")} if a.numeros else None - print(f"Référence calme : {a.calme or 'tout le dossier'} ; rapports médians avant|plage|après ({a.marge} min)") - for n, e in enumerate(lire_etiquettes(a.etiquettes), 1): - t0, t1 = donnees.instant(e["debut"]), donnees.instant(e["fin"]) - if (garder and n not in garder) or (deb and t0 < deb) or (fin and t0 > fin): - continue - print(f"\n{n}. {e['debut']} → {e['fin']}, {e['categorie']}") - win = {s: tout[s][bisect.bisect_left(temps[s], t0 - marge):bisect.bisect_right(temps[s], t1 + marge)] for s in noms} - parties = [(t0 - marge, t0 - timedelta(seconds=1)), (t0, t1), (t1 + timedelta(seconds=1), t1 + marge)] - for c in METRIQUES: - cases = [] - for g in (False, True): - vals = [] - for a0, a1 in parties: - v = [rapport(ref, s, c, m) for s in win if (s in refs) == g for m in win[s] if a0 <= m["t"] <= a1] - vals.append(med([x for x in v if x is not None])) - cases.append(("ref " if g else "cib ") + "|".join(vals)) - print(f" {c:>9} " + " ".join(cases)) - pires = [] - for s in noms: - ms = [m for m in win[s] if t0 <= m["t"] <= t1] - if any(touche(rapport(ref, s, c, m), c, a.seuil) for m in ms for c in ("flux", "snr", "dominance")): - fl = [x for x in (rapport(ref, s, "flux", m) for m in ms) if x is not None] - pires.append((min(fl) if fl else 1, s + ("r" if s in refs else ""))) - pires.sort() - print(f" touchés ({len(pires)}) : " + ", ".join(f"{s} {f:.2f}" for f, s in pires) if pires else " touchés : aucun") - if a.bords: - inst = {} - for s in win: - for m in win[s]: - d = inst.setdefault(m["t"], {"n": 0, "flux": [], "snr": [], "dominance": []}) - rs = {c: rapport(ref, s, c, m) for c in ("flux", "snr", "dominance")} - d["n"] += any(touche(rs[c], c, a.seuil) for c in rs) - if s not in refs: - for c in rs: - if rs[c] is not None: - d[c].append(rs[c]) - print(" instant n flux snr dom") - for t in sorted(inst): - d = inst[t] - print(f" {t:%Y-%m-%d %H:%M} {d['n']:>3} {med(d['flux']):>5} {med(d['snr']):>5} {med(d['dominance']):>5}" - + (" <" if t0 <= t <= t1 else "")) - - -def hors(a, tout, ref, refs, noms, deb, fin): - sauf = set(a.sauf.split(",")) if a.sauf else set() - couvert = [(donnees.instant(e["debut"]), donnees.instant(e["fin"])) for e in lire_etiquettes(a.etiquettes) - if e["categorie"] not in sauf] - inst = {} - for s in noms: - for m in donnees.filtrer(tout[s], deb, fin): - if dans(m["t"], couvert): - continue - if any(touche(rapport(ref, s, c, m), c, a.seuil) for c in ("flux", "snr", "dominance")): - inst.setdefault(m["t"], {})[s + ("r" if s in refs else "")] = rapport(ref, s, "flux", m) or 0 - suites = [] - for t in sorted(t for t in inst if len(inst[t]) >= a.min): - if suites and t - suites[-1][-1] <= timedelta(minutes=15): - suites[-1].append(t) - else: - suites.append([t]) - print(f"Hors des étiquettes (sauf {a.sauf}) : instants où au moins {a.min} capteurs sont touchés ; {len(suites)} suites") - for su in suites: - pire = {} - for t in su: - for s, f in inst[t].items(): - pire[s] = min(pire.get(s, 9), f) - print(f"{su[0]:%Y-%m-%d %H:%M} → {su[-1]:%H:%M} ({len(su)}) : " - + ", ".join(f"{s} {f:.2f}" for s, f in sorted(pire.items(), key=lambda x: x[1]))) - - -def morceaux(pts, trou=timedelta(minutes=30)): - """[(t, ...)] -> listes coupées là où deux instants sont à plus de `trou` : un trait ne traverse pas un trou de mesures.""" - out = [] - for i, x in enumerate(pts): - if not out or x[0] - pts[i - 1][0] > trou: - out.append([]) - out[-1].append(x) - return out - - -def figure(a, par, ref, noms, refs, deb, fin): - import matplotlib - matplotlib.use("Agg") - import matplotlib.dates as mdates - import matplotlib.pyplot as plt - - plages = [(x, y, "grey") for x, y in fenetres(",".join(a.zone or []))] - if a.etiquettes: - for e in lire_etiquettes(a.etiquettes): - x, y = donnees.instant(e["debut"]), donnees.instant(e["fin"]) - if (deb is None or y >= deb) and (fin is None or x <= fin): - plages.append((x, y, COULEURS.get(e["categorie"], "grey"))) - station = os.path.basename(os.path.normpath(a.dossier)) - t0 = min(m["t"] for s in noms for m in par[s]) - t1 = max(m["t"] for s in noms for m in par[s]) - suffixe = f"{t0:%Y%m%dT%H%MZ}_{t1:%Y%m%dT%H%MZ}" - os.makedirs(a.sortie, exist_ok=True) - - def axe(ax): - for x, y, couleur in plages: - ax.axvspan(x, y, color=couleur, alpha=0.12, lw=0) - ax.xaxis.set_major_formatter(mdates.DateFormatter("%d/%m\n%H:%M")) - ax.set_yscale("log") - ax.axhline(1, ls=":", c="k", lw=0.8) - ax.set_xlim(t0, t1) - - fig, axes = plt.subplots(len(METRIQUES), 1, figsize=(16, 2.4 * len(METRIQUES)), sharex=True) - for ax, c in zip(axes, METRIQUES): - inst = {} - for s in noms: - for m in par[s]: - r = rapport(ref, s, c, m) - if r is not None and r > 0: - inst.setdefault(m["t"], ([], []))[s in refs].append(r) - ts = sorted(inst) - cib = [(t, sorted(inst[t][0])) for t in ts if inst[t][0]] - rfs = [(t, statistics.median(inst[t][1])) for t in ts if inst[t][1]] - for i, mc in enumerate(morceaux(cib)): - ax.fill_between([t for t, _ in mc], [v[len(v) // 10] for _, v in mc], [v[(len(v) * 9) // 10] for _, v in mc], - color="0.8", lw=0, step="mid") - ax.plot([t for t, _ in mc], [statistics.median(v) for _, v in mc], c="k", lw=0.7, - label="cibles (médiane, bande 10-90 %)" if i == 0 else None) - for i, mc in enumerate(morceaux(rfs)): - ax.plot([t for t, _ in mc], [v for _, v in mc], c="tab:red", lw=0.7, label="références (médiane)" if i == 0 else None) - axe(ax) - ax.set_ylabel(c) - axes[0].legend(loc="upper right", fontsize=8) - axes[0].set_title(f"{station} : métriques de qualité / référence calme ({a.calme or 'tout le dossier'}), même heure UTC") - chemin = os.path.join(a.sortie, f"{station}_qualite-commun_{suffixe}.png") - fig.tight_layout() - fig.savefig(chemin, dpi=90) - plt.close(fig) - print(chemin) - - for c in a.metriques.split(","): - col = 6 - lig = (len(noms) + col - 1) // col - fig, axes = plt.subplots(lig, col, figsize=(3.2 * col, 1.9 * lig), sharex=True, squeeze=False) - for ax, s in zip(axes.flat, noms): - pts = [(m["t"], rapport(ref, s, c, m)) for m in par[s]] - pts = [(t, r) for t, r in pts if r is not None and r > 0] - for mc in morceaux(pts): - ax.plot([t for t, _ in mc], [r for _, r in mc], lw=0.5, c="tab:red" if s in refs else "k") - axe(ax) - ax.set_title(s, fontsize=8, color="tab:red" if s in refs else "k") - ax.tick_params(labelsize=6) - for ax in list(axes.flat)[len(noms):]: - ax.axis("off") - fig.suptitle(f"{station} : {c} / référence calme, par capteur (références en rouge)") - chemin = os.path.join(a.sortie, f"{station}_qualite-{c}_{suffixe}.png") - fig.tight_layout() - fig.savefig(chemin, dpi=80) - plt.close(fig) - print(chemin) - - -def main(): - p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) - p.add_argument("dossier") - p.add_argument("--debut", type=donnees.instant) - p.add_argument("--fin", type=donnees.instant) - p.add_argument("--capteurs", help="liste séparée par des virgules (défaut : tous)") - p.add_argument("--calme", help="fenêtres de la référence, T1/T2,T3/T4 (défaut : tout le dossier)") - p.add_argument("--commun", action="store_true", help="médianes des cibles et des références par pas") - p.add_argument("--table", choices=METRIQUES, help="rapport d'une métrique par pas et par capteur") - p.add_argument("--pas", default="15min", type=lambda x: duree(x) and x, help="15min, 1h, 1d") - p.add_argument("--seuil", type=float, default=0.5, help="« touché » : flux ou snr sous seuil, dominance au-dessus de 1/seuil") - p.add_argument("--etiquettes", help="fichier d'étiquettes (JSON par ligne)") - p.add_argument("--numeros", help="numéros d'étiquettes à lire, 3,7") - p.add_argument("--marge", type=int, default=60, help="minutes avant et après chaque étiquette") - p.add_argument("--bords", action="store_true") - p.add_argument("--hors", action="store_true", help="instants touchés qu'aucune étiquette ne couvre") - p.add_argument("--min", type=int, default=1) - p.add_argument("--sauf", default="Thermal displacement", help="familles ignorées par --hors, A,B") - p.add_argument("--figure", action="store_true", help="PNG (matplotlib : .venv/bin/python)") - p.add_argument("--metriques", default="flux,snr,dominance", help="PNG par capteur de --figure") - p.add_argument("--zone", action="append", help="plage à griser sur les PNG, T1/T2 (répétable)") - p.add_argument("--sortie", default=os.path.join(RACINE, "out", "diagnostic"), help="dossier des PNG") - a = p.parse_args() - if a.hors and not a.etiquettes: - p.error("--hors demande --etiquettes") - inconnues = [c for c in a.metriques.split(",") if c not in METRIQUES] - if inconnues: - p.error(f"métriques inconnues : {', '.join(inconnues)} ; connues : {', '.join(METRIQUES)}") - - tout = donnees.charger(a.dossier) - if not tout: - sys.exit(f"Aucun export « advanced » dans {a.dossier} (voir inventaire.py).") - if not any(m[c] is not None for ms in tout.values() for m in ms for c in METRIQUES): - sys.exit(f"Aucune métrique de qualité dans {a.dossier} : peak à snr vides (caméra ancienne ; " - "labeling/connaissances/metriques-de-qualite.md).") - noms = a.capteurs.split(",") if a.capteurs else sorted(tout, key=lambda s: (not donnees.est_reference(tout[s]), s)) - absents = [s for s in noms if s not in tout] - if absents: - sys.exit(f"Capteurs absents : {', '.join(absents)}. Présents : {', '.join(sorted(tout))}.") - ref = references(tout, fenetres(a.calme)) - refs = {s for s in tout if donnees.est_reference(tout[s])} - par = {s: donnees.filtrer(tout[s], a.debut, a.fin) for s in noms} - if not any(par.values()): - sys.exit("Aucune mesure dans la fenêtre demandée.") - if a.figure: - return figure(a, par, ref, noms, refs, a.debut, a.fin) - if a.etiquettes: - return (hors if a.hors else etiquettes)(a, tout, ref, refs, noms, a.debut, a.fin) - pmax = max((m["peak"] for ms in tout.values() for m in ms if m["peak"] is not None), default=None) - print(f"Référence calme : {a.calme or 'tout le dossier'}, par heure UTC du jour (r = référence)") - resume(par, ref, noms, refs, pmax) - if a.commun: - commun(par, ref, noms, refs, a.pas) - if a.table: - table(par, ref, noms, a.table, a.pas, a.seuil) - - -def essai(): - """Contrôle du rapport à la référence : même heure, repli sur toutes les heures, fenêtre calme respectée.""" - from datetime import datetime, timezone - t = lambda j, h: datetime(2026, 10, j, h, tzinfo=timezone.utc) # noqa: E731 - vide = dict.fromkeys(METRIQUES) - par = {"A": [dict(vide, t=t(1, 3), flux=10.0), dict(vide, t=t(2, 3), flux=30.0), dict(vide, t=t(2, 5), flux=100.0), - dict(vide, t=t(9, 3), flux=1000.0)]} - ref = references(par, [(t(1, 0), t(3, 0))]) - assert ref["A"]["flux"][3] == 20.0 and ref["A"]["flux"][None] == 30.0, ref - assert rapport(ref, "A", "flux", dict(vide, t=t(9, 3), flux=10.0)) == 0.5 - assert rapport(ref, "A", "flux", dict(vide, t=t(9, 7), flux=60.0)) == 2.0 # heure sans calme : toutes les heures - assert rapport(ref, "A", "snr", dict(vide, t=t(9, 3), snr=5.0)) is None - assert touche(0.4, "flux", 0.5) and touche(2.5, "dominance", 0.5) and not touche(2.5, "flux", 0.5) - print("essai : ok") - - -if __name__ == "__main__": - essai() if sys.argv[1:] == ["--essai"] else main() diff --git a/agent-tools/resume.py b/agent-tools/resume.py deleted file mode 100644 index 1376487..0000000 --- a/agent-tools/resume.py +++ /dev/null @@ -1,124 +0,0 @@ -"""Résumé chiffré compact des séries d'un export « advanced », pour l'agent de diagnostic. - -Usage : python3 agent-tools/resume.py data/PS_DES_COUDRES/ [--colonne error_value] - [--stat median|min|max] [--pas 1h] [--niveau periode|fenetre] [--capteurs CAPTEUR_A,CAPTEUR_B] [--debut 2026-01-01T00:00Z] [--fin ...] - [--instants T1,T2] [--marque] - -1. Niveau habituel de chaque capteur : médiane, MAD (écart absolu médian), min, max, sur toute la période - (défaut) ou, avec --niveau fenetre, sur la fenêtre --debut/--fin seulement (un changement de niveau - dans la fenêtre ne se compare pas à des semaines d'autres mesures). - Colonnes : error_value, corr_x, corr_y, relative_x, relative_y, x, y, sigma0, reproj_err, et les six métriques de qualité d'image (peak à snr, valeurs brutes ; vides sur les - caméras anciennes ; face à une référence calme : qualite.py). -2. Tableau : une ligne par pas de temps (début du pas, UTC), une colonne par capteur, la statistique - choisie sur les mesures du pas. « rej » : toutes les mesures du pas sont rejetées ; « vide » : des mesures, - mais la colonne est vide (ex. reproj_err d'une cible) ; « - » : aucune mesure. L'en-tête des capteurs se répète - toutes les 24 lignes. Avec --instants T1,T2 : seulement les pas qui contiennent ces instants. Avec --marque : « * » - après la valeur quand une mesure du pas est rejetée (x, y, error_value d'une mesure rejetée restent remplis), - « o » quand une mesure du pas a inlier = 0 (référence écartée par la compensation). -Rend des valeurs, pas de verdict. -""" -import argparse -import re -import statistics -import sys -from datetime import timedelta - -from donnees import charger, est_reference, filtrer, instant, iso, rejetee - -COLONNES = ("error_value", "corr_x", "corr_y", "relative_x", "relative_y", "x", "y", "sigma0", "reproj_err") -QUALITE = ("peak", "flux", "sharpness", "fwhm", "dominance", "snr") # qualité de l'image : caméras récentes ; lue par qualite.py -STATS = {"median": statistics.median, "min": min, "max": max} - - -def duree(texte): - """'15min', '1h', '6h', '1d' -> timedelta.""" - m = re.fullmatch(r"(\d+)(min|h|d)", texte) - if not m: - raise argparse.ArgumentTypeError(f"pas invalide : {texte!r} (ex. 15min, 1h, 1d)") - n, unite = int(m.group(1)), m.group(2) - return {"min": timedelta(minutes=n), "h": timedelta(hours=n), "d": timedelta(days=n)}[unite] - - -ARRONDI = 1e-9 # en deçà, un écart entre deux mesures est l'arrondi du calcul de la station, pas un bruit - - -def bruit_propre(vs): - """Médiane des écarts absolus entre deux valeurs consécutives ; 0 quand elle est sous ARRONDI (valeurs constantes - à l'arrondi près : le corr des références quand la compensation passe exactement par elles, deux références - retenues), pour qu'un écart ne s'écrive pas en milliards de bruits ; 0 aussi avec moins de deux valeurs.""" - d = [abs(b - a) for a, b in zip(vs, vs[1:])] - b = statistics.median(d) if d else 0 - return b if b >= ARRONDI else 0 - - -def valeurs(ms, col): - return [m[col] for m in ms if m[col] is not None] - - -def main(): - a = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) - a.add_argument("dossier") - a.add_argument("--colonne", default="error_value", choices=COLONNES + QUALITE) - a.add_argument("--stat", default="median", choices=STATS) - a.add_argument("--pas", default="1h", type=duree) - a.add_argument("--niveau", default="periode", choices=("periode", "fenetre"), - help="période sur laquelle médiane et MAD sont calculées (défaut : toutes les mesures)") - a.add_argument("--capteurs", help="liste séparée par des virgules (défaut : tous)") - a.add_argument("--instants", help="T1,T2 : seulement les pas qui contiennent ces instants") - a.add_argument("--marque", action="store_true", help="* : une mesure du pas rejetée ; o : une mesure du pas avec inlier = 0") - a.add_argument("--debut", type=instant) - a.add_argument("--fin", type=instant) - o = a.parse_args() - - par = charger(o.dossier) - if not par: - sys.exit(f"Aucun export « advanced » dans {o.dossier} (voir inventaire.py).") - noms = o.capteurs.split(",") if o.capteurs else sorted(par, key=lambda s: (not est_reference(par[s]), s)) - inconnus = [s for s in noms if s not in par] - if inconnus: - sys.exit(f"Capteurs absents : {', '.join(inconnus)}. Présents : {', '.join(sorted(par))}.") - - t0 = min(m["t"] for s in noms for m in par[s]).replace(hour=0, minute=0, second=0, microsecond=0) - cases = {} - for s in noms: - for m in filtrer(par[s], o.debut, o.fin): - debut_du_pas = t0 + ((m["t"] - t0) // o.pas) * o.pas - cases.setdefault(debut_du_pas, {}).setdefault(s, []).append(m) - if not cases: - sys.exit("Aucune mesure dans la fenêtre demandée.") - - sur = "la fenêtre --debut/--fin" if o.niveau == "fenetre" else "toute la période" - print(f"Colonne : {o.colonne}. Niveau habituel sur {sur} (mesures non vides) :") - print(f"{'capteur':10} {'n':>5} {'médiane':>10} {'MAD':>10} {'min':>10} {'max':>10}") - for s in noms: - v = valeurs(filtrer(par[s], o.debut, o.fin) if o.niveau == "fenetre" else par[s], o.colonne) - if not v: - print(f"{s:10} {0:5} (aucune valeur)") - continue - med = statistics.median(v) - mad = statistics.median(abs(x - med) for x in v) - print(f"{s:10} {len(v):5} {med:10.5g} {mad:10.5g} {min(v):10.5g} {max(v):10.5g}") - - print(f"\n{o.stat} de {o.colonne} par pas de {o.pas} (début du pas, UTC) :") - print("rej : mesures du pas toutes rejetées ; vide : colonne vide ; - : aucune mesure") - if o.marque: - print("* : une mesure du pas au moins est rejetée ; o : une mesure du pas au moins a inlier = 0") - entete = f"{'début':17} " + " ".join(f"{s:>9}" for s in noms) - voulus = {t0 + ((instant(x) - t0) // o.pas) * o.pas for x in o.instants.split(",")} if o.instants else None - for i, k in enumerate(k for k in sorted(cases) if voulus is None or k in voulus): - if i % 24 == 0: - print(entete) - cellules = [] - for s in noms: - ms = cases[k].get(s, []) - v = valeurs(ms, o.colonne) - if v: - marque = ("*" if any(map(rejetee, ms)) else "") + ("o" if any(m["inlier"] == 0 for m in ms) else "") if o.marque else "" - cellules.append(f"{STATS[o.stat](v):.5g}{marque}".rjust(9)) - else: - cellules.append(f"{'-' if not ms else 'rej' if all(map(rejetee, ms)) else 'vide':>9}") - print(f"{iso(k):17} " + " ".join(cellules)) - - -if __name__ == "__main__": - main() diff --git a/agent-tools/stations.py b/agent-tools/stations.py deleted file mode 100644 index 0f41cb6..0000000 --- a/agent-tools/stations.py +++ /dev/null @@ -1,194 +0,0 @@ -"""Plusieurs stations sur une même ligne de temps : température du boîtier, pose de la caméra, corr des cibles, rejets, trous. - -Usage : .venv/bin/python agent-tools/stations.py data/BREITHORN data/MICHIGAN data/NEBRASKA - [--colonnes temperature,cam_tilt,cam_rotation,cam_scale,cib_corr_x,cib_corr_y] [--pas 1h] [--stat median|min|max] - [--table T1/T2|non] [--debut ...] [--fin ...] [--sortie DOSSIER] - -Pour chaque station (un dossier de station chacune), sur la fenêtre --debut/--fin : -- colonnes possibles : temperature (médiane des composants sensor_*_deg_c, comme metriques.py), cam_pan, cam_tilt, - cam_rotation, cam_scale, cam_sigma0 (pose brute de la caméra), cib_corr_x, cib_corr_y (médiane sur les cibles de - corr moins le niveau propre de chaque cible, mesures acceptées, comme metriques.py), rej_cibles, rej_refs (nombre de - cibles, de références rejetées : le plus grand des instants de mesure du pas) ; -- imprime, par station, la période des mesures, la cadence (pas médian) et le nombre d'instants ; puis les **trous** : - les suites de pas de --pas sans mesure ou sans température, avec les stations où elles manquent (un trou commun à - plusieurs stations y est sur une seule ligne) ; puis la table, une ligne par pas (début du pas, UTC ; --stat des - valeurs du pas ; « - » : aucune valeur), une colonne par station et par colonne, séparées par des tabulations - (--table T1/T2 : seulement entre T1 et T2, « non » : pas du tout ; le reste porte sur toute la fenêtre) ; puis, pour - chaque colonne et chaque paire de stations, la corrélation r des valeurs et celle des pas (différence d'une valeur à - la suivante, sur les pas où les deux stations ont une valeur : un mouvement commun se voit sur les pas, une tendance - commune sur les valeurs), avec le nombre de pas ; -- un PNG « stations » : un panneau par colonne, un trait par station (température brute ; les autres colonnes moins - leur médiane sur la fenêtre, pour se superposer), coupé sur un trou ; trous de mesure grisés sous l'axe, une bande - par station. -Jamais d'identifiant de metrics/ (SIM_CCID, ip*) : seules les températures y sont lues. Rend des valeurs, pas de verdict. -""" -import argparse -import os -import statistics -import sys - -import matplotlib - -matplotlib.use("Agg") -import matplotlib.dates as mdates # noqa: E402 -import matplotlib.pyplot as plt # noqa: E402 - -from donnees import POSE, charger, charger_camera, charger_temperature, est_reference, filtrer, instant, iso, rejetee # noqa: E402 -from graphique import RACINE, borne # noqa: E402 -from metriques import cibles, coupe, suites # noqa: E402 -from resume import STATS, duree # noqa: E402 - -COLONNES = ("temperature",) + tuple("cam_" + c for c in POSE) + ("cib_corr_x", "cib_corr_y", "rej_cibles", "rej_refs") - - -def lire(dossier, debut, fin): - """Dossier de station -> ({colonne: [{'t', 'v'}]}, [instants de mesure]).""" - par = charger(dossier) - series = {"temperature": filtrer([{"t": t, "v": v} for t, v in charger_temperature(dossier)], debut, fin)} - for p in filtrer(charger_camera(dossier), debut, fin): - for c in POSE: - if p[c] is not None: - series.setdefault("cam_" + c, []).append({"t": p["t"], "v": p[c]}) - for c in ("corr_x", "corr_y"): - series["cib_" + c] = cibles(par, c, debut, fin) - rej = {} # t -> [cibles rejetées, références rejetées] - for s, ms in par.items(): - ref = est_reference(ms) - for m in filtrer(ms, debut, fin): - n = rej.setdefault(m["t"], [0, 0]) - n[ref] += rejetee(m) - series["rej_cibles"] = [{"t": t, "v": float(n[0])} for t, n in sorted(rej.items())] - series["rej_refs"] = [{"t": t, "v": float(n[1])} for t, n in sorted(rej.items())] - return series, sorted(rej) - - -def correlation(a, b): - try: - return f"{statistics.correlation(a, b):+.2f}" - except (statistics.StatisticsError, ValueError): - return "-" - - -def main(): - a = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) - a.add_argument("dossiers", nargs="+", help="dossiers de station, au moins deux") - a.add_argument("--colonnes", default="temperature,cam_tilt,cam_rotation,cam_scale,cib_corr_x,cib_corr_y") - a.add_argument("--pas", default="1h", type=duree) - a.add_argument("--stat", default="median", choices=STATS) - a.add_argument("--table", default="", metavar="T1/T2|non", help="table imprimée seulement entre T1 et T2 (« non » : pas du tout)") - a.add_argument("--debut", type=instant) - a.add_argument("--fin", type=instant) - a.add_argument("--sortie", default=os.path.join(RACINE, "out", "diagnostic"), help="dossier du PNG") - o = a.parse_args() - colonnes = o.colonnes.split(",") - if absents := [c for c in colonnes if c not in COLONNES]: - sys.exit(f"Colonnes inconnues : {', '.join(absents)}. Connues : {', '.join(COLONNES)}.") - if o.table in ("", "non"): - dans_table = lambda t: o.table == "" # noqa: E731 - else: - bornes = [instant(x) for x in o.table.split("/")] - if len(bornes) != 2: - sys.exit("--table attend T1/T2 ou non.") - dans_table = lambda t: bornes[0] <= t <= bornes[1] # noqa: E731 - - noms = [os.path.basename(os.path.normpath(d)) for d in o.dossiers] - donnees, mesures = {}, {} - for n, d in zip(noms, o.dossiers): - donnees[n], mesures[n] = lire(d, o.debut, o.fin) - tous = [p["t"] for s in donnees.values() for c in s.values() for p in c] - if not tous: - sys.exit("Aucune valeur dans la fenêtre demandée.") - t0 = (o.debut or min(tous)).replace(minute=0, second=0, microsecond=0) - t1 = o.fin or max(tous) - grille = [t0 + i * o.pas for i in range(int((t1 - t0) / o.pas) + 1)] - case = lambda t: t0 + ((t - t0) // o.pas) * o.pas # noqa: E731 - - print("Stations :") - for n in noms: - ts = mesures[n] - if not ts: - print(f" {n} : aucune mesure dans la fenêtre") - continue - cad = statistics.median(b - a_ for a_, b in zip(ts, ts[1:])) if len(ts) > 1 else None - print(f" {n} : mesures {iso(ts[0])} → {iso(ts[-1])}, {len(ts)} instants, cadence {round(cad.total_seconds() / 60) if cad else '-'} min ; " - + ", ".join(f"{c} {len(donnees[n].get(c, []))}" for c in colonnes)) - - # trous : pas sans mesure, sans température, et les stations concernées - avec = {n: {case(t) for t in mesures[n]} for n in noms} - avec_t = {n: {case(p["t"]) for p in donnees[n]["temperature"]} for n in noms} - print(f"\nTrous (pas de {int(o.pas.total_seconds() // 60)} min sans mesure ou sans température), avec les stations où ils manquent :") - cles = {} - for k in grille: - m = tuple(n for n in noms if k not in avec[n]) - t = tuple(n for n in noms if k not in avec_t[n]) - if m or t: - cles.setdefault((m, t), []).append(k) - lignes = [] - for (m, t), ks in cles.items(): - for d, f, nb in suites(ks, o.pas): - lignes.append((d, f, nb, m, t)) - for d, f, nb, m, t in sorted(lignes): - print(f" {iso(d)} → {iso(f)} ({nb} pas) : sans mesure {','.join(m) or '-'} ; sans température {','.join(t) or '-'}") - if not lignes: - print(" (aucun)") - - stat = STATS[o.stat] - table = {} # (station, colonne) -> {pas: valeur} - for n in noms: - for c in colonnes: - cases = {} - for p in donnees[n].get(c, []): - cases.setdefault(case(p["t"]), []).append(p["v"]) - table[n, c] = {k: stat(v) for k, v in cases.items()} - entete = [f"{n}:{c}" for n in noms for c in colonnes] - print(f"\n{o.stat} par pas de {int(o.pas.total_seconds() // 60)} min (début du pas, UTC) ; « - » : aucune valeur" - + (f" (table : {o.table})" if o.table else "") + " :") - if o.table != "non": - print("\t".join(["heure"] + entete)) - for k in grille: - if dans_table(k): - v = [table[n, c].get(k) for n in noms for c in colonnes] - if any(x is not None for x in v): - print("\t".join([iso(k)] + ["-" if x is None else f"{x:.6g}" for x in v])) - - print("\nCorrélation entre stations, r des valeurs, puis r des pas d'une valeur à la suivante (n : pas où les deux ont une valeur) :") - for c in colonnes: - for i, s1 in enumerate(noms): - for s2 in noms[i + 1:]: - ks = sorted(set(table[s1, c]) & set(table[s2, c])) - v1, v2 = [table[s1, c][k] for k in ks], [table[s2, c][k] for k in ks] - d1, d2 = [b - a_ for a_, b in zip(v1, v1[1:])], [b - a_ for a_, b in zip(v2, v2[1:])] - print(f" {c:12} {s1}-{s2} : r valeurs {correlation(v1, v2)}, r pas {correlation(d1, d2)} (n = {len(ks)})") - - fig, axes = plt.subplots(len(colonnes) + 1, 1, sharex=True, figsize=(14, 2.4 * (len(colonnes) + 1)), squeeze=False, - layout="constrained", gridspec_kw={"height_ratios": [3] * len(colonnes) + [0.3 * len(noms)]}) - for ax, c in zip(axes[:-1, 0], colonnes): - for i, n in enumerate(noms): - s = donnees[n].get(c, []) - if not s: - continue - med = 0 if c == "temperature" else statistics.median(p["v"] for p in s) - ts, vs = coupe([{"t": p["t"], "v": p["v"] - med} for p in s]) - ax.plot(ts, vs, ".-", ms=2, lw=0.8, color=f"C{i % 10}", label=n) - ax.set_ylabel(c if c == "temperature" else f"{c}\nmoins sa médiane", fontsize=8) - ax.grid(alpha=0.3) - ax.legend(loc="upper left", bbox_to_anchor=(1.0, 1.0), fontsize=8) - ax = axes[-1, 0] - for i, n in enumerate(noms): - for k in grille: - if k not in avec[n]: - ax.axvspan(k, k + o.pas, ymin=i / len(noms), ymax=(i + 1) / len(noms), color=f"C{i % 10}", lw=0) - ax.set_yticks([(i + 0.5) / len(noms) for i in range(len(noms))], noms, fontsize=7) - ax.set_ylim(0, 1) - ax.set_ylabel("sans mesure", fontsize=8) - ax.set_xlim(grille[0], grille[-1] + o.pas) - ax.xaxis.set_major_formatter(mdates.DateFormatter("%d/%m\n%H:%MZ")) - fig.suptitle(f"{', '.join(noms)} : même ligne de temps (heures UTC)") - os.makedirs(o.sortie, exist_ok=True) - chemin = os.path.join(o.sortie, f"{'-'.join(noms)}_stations_{borne(o.debut, 'debut')}_{borne(o.fin, 'fin')}.png") - fig.savefig(chemin, dpi=100, bbox_inches="tight") - print(f"\n{chemin}") - - -if __name__ == "__main__": - main() diff --git a/agent-tools/vignettes.py b/agent-tools/vignettes.py deleted file mode 100644 index 35173e6..0000000 --- a/agent-tools/vignettes.py +++ /dev/null @@ -1,172 +0,0 @@ -"""Vignettes des images de la caméra autour de capteurs, à pleine résolution, pour l'agent de diagnostic. - -Usage : .venv/bin/python agent-tools/vignettes.py data/PS_DES_COUDRES/ - --capteurs REF_G,REF_D --heures 2026-10-13T22:00Z,2026-10-14T02:00Z [--rayon 100] [--contraste [MIN,MAX]] [--sortie DOSSIER] -Une ligne par capteur, une colonne par heure. Quand il n'y a pas d'image à l'heure demandée, la plus proche est -prise : l'écart est imprimé et l'heure réelle de l'image est dans le titre de la vignette. Chaque vignette est centrée sur la position brute (x, y) du capteur -dans l'export « advanced », lue à la mesure la plus proche de l'image ; les pixels ne sont pas retouchés, l'éclat -se compare donc d'une vignette à l'autre. Imprime les positions utilisées, le fond (médiane des pixels de la -vignette), le 99e centile et le pic (maximum) du niveau de gris de chaque vignette (0 à 255), puis le chemin du PNG. ---contraste : toutes les vignettes en niveaux de gris, avec le même étirement pour toute la planche, pour qu'une -tache faible se voie et se compare d'une vignette à l'autre. Sans valeur, l'étirement va du 1er centile au maximum -de la planche (un pixel saturé quelque part l'écrase : redonner alors --contraste MIN,MAX, en s'aidant du fond et du -pic imprimés pour chaque vignette). Un --rayon plus petit (30 à 50) grossit. Les bornes sont imprimées. -Le centre du cadre (px) est écrit sous chaque vignette : quand les x, y de l'export sautent, le cadre se déplace -d'autant. --fixe garde, sur chaque ligne, le cadre centré sur la position de la première heure demandée, et marque -d'une croix rouge les x, y de l'export à chaque heure : une tache qui entre dans le cadre ou en sort ne s'y confond -pas avec une tache qui apparaît. Un cadre que le bord de l'image coupe est signalé (taille de l'image) : sur certains -exports, x, y ne sont pas des pixels (valeurs proches de 0), et le cadre tombe dans le coin de l'image. ---zone X,Y,L,H : la même zone de l'image (pixels de l'image d'origine : coin haut gauche, largeur, hauteur, comme -gif.py) à chaque heure, côte à côte (jusqu'à 4 par ligne, moins quand la zone est large), même étirement avec --contraste ; --capteurs devient facultatif : -ceux qui sont donnés sont marqués d'une croix rouge et de leur nom à leurs x, y de chaque heure. Pour la scène autour -des cibles (premier plan, objet, éclairage), qu'un grand --rayon rendrait trop petite. -Chaque vignette est rendue à sa taille en pixels (un pixel de l'image pour un pixel du PNG) de 260 à 1000 px de côté ; -Read réduit un PNG trop large : avec un grand --rayon ou une grande --zone, peu d'heures par planche. -""" -import argparse -import os -import sys - -import matplotlib - -matplotlib.use("Agg") -import matplotlib.pyplot as plt # noqa: E402 - -from donnees import charger, heure_image, instant, iso, trouver # noqa: E402 - - - -def centile(gris, p): - """Centile p (0 à 100) des pixels d'une vignette, sans interpolation.""" - v = sorted(gris.ravel().tolist()) - return v[min(int(p / 100 * len(v)), len(v) - 1)] - - -RACINE = os.path.normpath(os.path.join(os.path.dirname(os.path.abspath(__file__)), "..")) - - -def main(): - a = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) - a.add_argument("dossier") - a.add_argument("--capteurs", default="", help="liste séparée par des virgules (facultative avec --zone)") - a.add_argument("--heures", required=True, help="heures des images, séparées par des virgules (UTC)") - a.add_argument("--rayon", type=int, default=100, help="demi-côté de la vignette en pixels (défaut 100)") - a.add_argument("--contraste", nargs="?", const="auto", metavar="MIN,MAX", help="niveaux de gris, même étirement pour toute la planche : MIN,MAX (0 à 255) ou, sans valeur, du 1er centile au maximum de la planche") - a.add_argument("--fixe", action="store_true", help="un cadre fixe par capteur (position à la première heure), x, y de chaque heure marqués d'une croix") - a.add_argument("--zone", metavar="X,Y,L,H", help="la même zone de l'image à chaque heure (pixels de l'image d'origine : coin haut gauche, largeur, hauteur)") - a.add_argument("--sortie", default=os.path.join(RACINE, "out", "diagnostic"), help="dossier du PNG") - o = a.parse_args() - - par = charger(o.dossier) - images = {heure_image(p): p for p in trouver(o.dossier)["images"]} - noms, heures = [s for s in o.capteurs.split(",") if s], [instant(h) for h in o.heures.split(",")] - zone = tuple(map(int, o.zone.split(","))) if o.zone else None - if not noms and not zone: - sys.exit("Donne --capteurs, ou --zone X,Y,L,H.") - absents = [s for s in noms if s not in par] - if absents: - sys.exit(f"Capteurs inconnus : {', '.join(absents)}. Connus : {', '.join(sorted(par))}.") - connues = sorted(h for h in images if h) - if not connues: - sys.exit(f"Aucune image dans {o.dossier}.") - proche = {h: min(connues, key=lambda i: abs(i - h)) for h in heures} # image à l'heure demandée, sinon la plus proche - for h in heures: - if proche[h] != h: - print(f"Pas d'image à {iso(h)} : la plus proche est celle de {iso(proche[h])} (écart {abs(proche[h] - h)}).") - - def niveaux(c): - gris = c[..., :3].mean(axis=-1) if c.ndim == 3 else c - return gris * 255 if gris.max() <= 1 and c.dtype.kind == "f" else gris - - def mesure(s, t): - return min((m for m in par[s] if m["x"] is not None), key=lambda m: abs(m["t"] - t)) - - r = o.rayon - coupes, centres, croix = {}, {}, {} - for j, h in enumerate(heures): - img = plt.imread(images[proche[h]]) - haut, larg = img.shape[:2] - if zone: - X, Y, L, H = zone - c = img[max(Y, 0):Y + H, max(X, 0):X + L] - if c.size == 0: - sys.exit(f"--zone {o.zone} hors de l'image ({larg} × {haut} px).") - gris = niveaux(c) - coupes[0, j] = (c, gris) - croix[0, j] = [(s, m["x"] - max(X, 0), m["y"] - max(Y, 0)) for s in noms for m in [mesure(s, proche[h])]] - print(f"zone {o.zone} {iso(h)} : {os.path.basename(images[proche[h]])}, fond {centile(gris, 50):.0f}, " - f"p99 {centile(gris, 99):.0f}, pic {gris.max():.0f}" - + ("" if c.shape[:2] == (H, L) else f", coupée par le bord de l'image ({larg} × {haut} px)") - + "".join(f" ; {s} x={x + max(X, 0):.1f} y={y + max(Y, 0):.1f}" for s, x, y in croix[0, j])) - continue - for i, s in enumerate(noms): - m = mesure(s, proche[h]) - x, y = centres[i] if o.fixe and j else (round(m["x"]), round(m["y"])) - if j == 0: - centres[i] = (x, y) - c = img[max(y - r, 0):y + r, max(x - r, 0):x + r] - if c.size == 0: - sys.exit(f"{s} {iso(h)} : x={m['x']:.1f} y={m['y']:.1f} hors de l'image ({larg} × {haut} px) ; " - "--zone X,Y,L,H regarde une zone fixe.") - croix[i, j] = (m["x"] - max(x - r, 0), m["y"] - max(y - r, 0), x, y) - gris = niveaux(c) - coupes[i, j] = (c, gris) - coupe = x - r < 0 or y - r < 0 or x + r > larg or y + r > haut - print(f"{s} {iso(h)} : x={m['x']:.1f} y={m['y']:.1f} (mesure de {iso(m['t'])}), {os.path.basename(images[proche[h]])}, " - f"fond {centile(gris, 50):.0f}, p99 {centile(gris, 99):.0f}, pic {gris.max():.0f}" - + (f", cadre coupé par le bord de l'image ({larg} × {haut} px)" if coupe else "")) - bornes = {} - if o.contraste: - if o.contraste == "auto": - bornes = dict(vmin=min(centile(g, 1) for _, g in coupes.values()), vmax=max(g.max() for _, g in coupes.values())) - else: - bornes = dict(zip(("vmin", "vmax"), map(float, o.contraste.split(",")))) - print(f"Étirement commun : {bornes['vmin']:.0f} à {bornes['vmax']:.0f} (niveaux de gris, 0 à 255)") - # Une vignette à sa taille en pixels (à 100 dpi) dès qu'elle dépasse 2,6 pouces : un grand --rayon n'est plus réduit. - cote = max(c.shape[1] for c, _ in coupes.values()) / 100, max(c.shape[0] for c, _ in coupes.values()) / 100 - cote = tuple(v * min(1, 10 / max(cote)) for v in cote) # au plus 1000 px de côté par vignette - if zone: - nc = max(1, min(4, len(heures), int(20 // max(2.6, cote[0])))) # planche d'au plus ~2000 px de large : Read la réduit au-delà - nl = -(-len(heures) // nc) - fig, axes = plt.subplots(nl, nc, figsize=(max(2.6, cote[0]) * nc, (max(2.6, cote[1]) + 0.4) * nl), squeeze=False) - for ax in axes.ravel()[len(heures):]: - ax.axis("off") - else: - fig, axes = plt.subplots(len(noms), len(heures), figsize=(max(2.6, cote[0]) * len(heures), (max(2.6, cote[1]) + 0.2) * len(noms)), squeeze=False) - for (i, j), (c, gris) in coupes.items(): - ax = axes[j // nc, j % nc] if zone else axes[i, j] - if o.contraste: - ax.imshow(gris, cmap="gray", interpolation="nearest", **bornes) - else: - ax.imshow(c, interpolation="nearest") - ax.set_title(f"{'zone' if zone else noms[i]} {proche[heures[j]].strftime('%d/%m %H:%MZ')}" + ("" if proche[heures[j]] == heures[j] else " (demandée " + heures[j].strftime('%H:%MZ') + ")"), fontsize=9) - if zone: - for s, cx, cy in croix[i, j]: - ax.plot(cx, cy, "+", color="r", ms=10, mew=1) - ax.annotate(s, (cx, cy), xytext=(4, 4), textcoords="offset points", color="r", fontsize=7) - ax.set_xlim(-0.5, c.shape[1] - 0.5) - ax.set_ylim(c.shape[0] - 0.5, -0.5) - ax.set_xlabel(f"zone {o.zone}", fontsize=7) - ax.set_xticks([]) - ax.set_yticks([]) - continue - cx, cy, x, y = croix[i, j] - if o.fixe: - ax.plot(cx, cy, "+", color="r", ms=10, mew=1) - ax.set_xlabel(f"centre du cadre {x}, {y}" + (f"\nx, y {cx + max(x - r, 0):.1f}, {cy + max(y - r, 0):.1f}" if o.fixe else ""), fontsize=7) - ax.set_xticks([]) - ax.set_yticks([]) - station = os.path.basename(os.path.normpath(o.dossier)) - fig.suptitle(f"{station} : zone {o.zone} (x, y, largeur, hauteur en px ; heures UTC)" if zone else - f"{station} : vignettes de {2 * r} px autour de chaque capteur (heures UTC)", fontsize=10) - - os.makedirs(o.sortie, exist_ok=True) - quoi = f"zone{o.zone.replace(',', '-')}" + ("_" + "-".join(noms) if noms else "") if zone else "-".join(noms) - sortie = os.path.join(o.sortie, f"{station}_vignettes_{quoi}_" - f"{'-'.join(h.strftime('%d%H%M') for h in heures)}{'_contraste' if o.contraste else ''}{'_fixe' if o.fixe else ''}.png") - fig.savefig(sortie, dpi=100, bbox_inches="tight") - print(sortie) - - -if __name__ == "__main__": - main() diff --git a/app/README.md b/app/README.md index 47e6d66..613107e 100644 --- a/app/README.md +++ b/app/README.md @@ -18,10 +18,10 @@ L'adresse garde la station et la plage (UTC, `au` exclu) : `#/data?station=NIEDE ## L'onglet Analysis -- **Analyser la plage** : une plage sélectionnée, des indices facultatifs, puis `serveur/analyse.py` lance l'analyste par `claude -p` (non interactif). Il écrit dans `labeling/auto/analyses/__/` ses étiquettes et un rapport de diagnostic (`rapport.md` et ses figures ; son travail et le journal de claude dans `travail/`, hors de git). La page suit son avancement, puis montre le rapport ; le serveur verse ses étiquettes dans `labeling/auto/.jsonl` (champ `analyse`). « Voir le rapport » sur une telle étiquette le rouvre. +- **Analyser la plage** : une plage sélectionnée, des indices facultatifs, puis `serveur/analyse.py` lance l'analyste du dépôt agents par `claude -p` (non interactif), avec ses consignes (`consignes/analyste.md`) et sans les détecteurs (`DETECTEURS : non`). Il écrit dans `labeling/auto/analyses/__/` ses étiquettes et un rapport de diagnostic (`rapport.md` et ses figures ; son travail et le journal de claude dans `travail/`, hors de git). La page suit son avancement, puis montre le rapport ; le serveur verse ses étiquettes dans `labeling/auto/.jsonl` (champ `analyse`). « Voir le rapport » sur une telle étiquette le rouvre. - **La barre latérale** range les analyses de `labeling/auto/analyses/` en dossiers, un par station (ouvert d'office s'il en a une en cours), et dedans une analyse par plage, la plus récente en tête, avec son état ; un clic ouvre Data sur elle. - **Les messages** : après le rapport, l'utilisateur écrit à l'analyste, la même session reprend (`--resume`). Une analyse s'arrête avec le serveur (« interrompue ») ; « continue » dans le champ de message la reprend. -- **Optimiser les détecteurs**, sur une analyse finie : `/detectors:wf-improve` sur la plage de l'analyse (`--plugin-dir detectors`), puis le `tool-builder` ; les détecteurs commités dans `detectors/`, les outils de lecture ici, sur `main`. La page suit le fil de la séance (`travail/optimisation.jsonl`), puis montre son bilan sous le rapport (`/detectors//summary.md`, puis `/outils.md`). Une optimisation à la fois ; pendant, ni analyse ni message à l'analyste ; une optimisation coupée par l'arrêt du serveur se relance par le bouton. Les événements des détecteurs sont gardés en mémoire jusqu'à la fin d'une optimisation : après un `/detectors:wf-improve` lancé hors de l'app, relancer le serveur. +- **Optimiser les détecteurs**, sur une analyse finie : `/improve` dans Optimizer (`optimizer/`, avec le plugin `agents/`) sur la plage de l'analyse, puis le `tool-builder` du dépôt agents ; les détecteurs commités dans `detectors/`, les outils de lecture dans `tools/`, chacun sur sa branche courante. La page suit le fil de la séance (`travail/optimisation.jsonl`), puis montre son bilan sous le rapport (`optimizer/seances/_/summary.md`, puis `/outils.md`). Une optimisation à la fois ; pendant, ni analyse ni message à l'analyste ; une optimisation coupée par l'arrêt du serveur se relance par le bouton. Les événements des détecteurs sont gardés en mémoire jusqu'à la fin d'une optimisation : après un `/improve` lancé hors de l'app, relancer le serveur. ## Lancer @@ -37,8 +37,8 @@ La page s'ouvre sur `http://127.0.0.1:8770`. Réglages par variables : `AIMSIGHT ## Les dossiers - `serveur/serveur.py` : FastAPI ; sert la page construite et l'API sous `/api` (stations, images, courbes, détecteurs, étiquettes, analyses) ; ne répond qu'aux pages du poste (Host local, JSON déclaré). -- `serveur/station.py` : les données de la page Data ; lecture seule sur `data/` (par `agent-tools/donnees.py`), écrit seulement dans `labeling/{auto,manual}/`. -- `serveur/analyse.py` : l'onglet Analysis ; lance `claude` avec l'agent `analyste` (Read, Write, Bash autorisés sans demande) ; et l'optimisation, `/detectors:wf-improve` (Read, Write, Edit, Bash, Agent) puis l'agent `tool-builder` (Read, Write, Edit, Bash). +- `serveur/station.py` : les données de la page Data ; lecture seule sur `data/` (par `tools/donnees.py`), écrit seulement dans `labeling/{auto,manual}/`. +- `serveur/analyse.py` : l'onglet Analysis ; lance `claude` avec l'agent `agents:analyste` (Read, Write, Bash autorisés sans demande) ; et l'optimisation, `/improve` dans Optimizer (Read, Write, Edit, Bash, Agent) puis l'agent `agents:tool-builder` (Read, Write, Edit, Bash). - `serveur/check.py` : vérifications, sans appel à claude : `.venv/bin/python app/serveur/check.py`. - `web/` : React (Vite) et Mantine ; `src/App.jsx` (en-tête, barre latérale, adresse), `src/pages/Data.jsx` (la page), `src/pages/Images.jsx` (les images, dans Data), `src/commun.jsx` (requêtes, cartes, sélecteur), `src/main.jsx` (thème). Plotly, habillé aux couleurs de Mantine, ne se charge qu'avec Data. `dist/` et `node_modules/` hors de git. diff --git a/app/serveur/analyse.py b/app/serveur/analyse.py index ccd6347..7a26640 100644 --- a/app/serveur/analyse.py +++ b/app/serveur/analyse.py @@ -1,14 +1,14 @@ -"""L'onglet Analysis de la page Data : l'analyste (.claude/agents/analyste.md) lancé par `claude -p`, non interactif, sur une -plage choisie dans la page, avec les indices facultatifs de l'utilisateur. Il écrit dans +"""L'onglet Analysis de la page Data : l'analyste du dépôt agents (agents/, un plugin : --agent agents:analyste), lancé par +`claude -p`, non interactif, sur une plage choisie dans la page, avec les indices facultatifs de l'utilisateur, ses consignes +(consignes/analyste.md) et sans les détecteurs (DETECTEURS : non : ses étiquettes serviront à les améliorer). Il écrit dans labeling/auto/analyses/__/ ses étiquettes (etiquettes.jsonl) et un rapport de diagnostic (rapport.md, ses figures à côté) ; à la fin, le serveur verse ses étiquettes dans labeling/auto/.jsonl, marquées de leur analyse (champ `analyse`). Puis l'utilisateur peut lui écrire : la même session reprend (`claude -p --resume`), et ses étiquettes, si elles changent, remplacent celles qu'il avait versées. -Sur une analyse finie, « Optimiser » lance `/detectors:wf-improve` (le plugin du dépôt detectors, monté en detectors/) sur -la plage de l'analyse, ses étiquettes pour vérité, qui améliore les détecteurs, puis le tool-builder (.claude/agents/tool-builder.md), qui fait entrer -les scripts de l'analyste dans les outils de lecture ; une optimisation à la fois, ni analyse ni message pendant ; le bilan de -la séance (/detectors//summary.md) et celui des outils (/outils.md) s'affichent sous -le rapport. +Sur une analyse finie, « Optimiser » lance `/improve` dans Optimizer (optimizer/, le skill qui améliore les détecteurs sur la +plage de l'analyse, ses étiquettes pour vérité), puis le tool-builder du dépôt agents, qui fait entrer les scripts de +l'analyste dans les outils de lecture (tools/) ; une optimisation à la fois, ni analyse ni message pendant ; le bilan de la +séance (optimizer/seances/_/summary.md) et celui des outils (/outils.md) s'affichent sous le rapport. """ import html import json @@ -23,14 +23,16 @@ import station DOSSIER = station.ETIQUETTES / "auto" / "analyses" DETECTEURS = station.RACINE / "detectors" -# la requête de /detectors:wf-improve (detectors/README.md) : tout ce qu'il lit et écrit est donné ici, avec ses règles git -AMELIORER = """/detectors:wf-improve DETECTORS: detectors/. STATION: {donnees}/{station}. FROM: {du}. TO: {au}. \ -LABELS: {etiquettes}/auto/{station}.jsonl. REFERENCE: --labels {etiquettes}/auto --data {donnees}. \ -FAMILIES: {etiquettes}/familles.md. CONTEXT: {analyse}/rapport.md. OUT: {sortie}/. Caller's context: Diagnostic-app, \ -detectors/ is a link to the detectors repository, shared with Optimizer; read-only on {donnees}/ and {etiquettes}/; commit only in detectors/, on its current branch; \ -OUT is in the labeling repository (labeling/ is a link to it): do not commit it.""" +AGENTS = station.RACINE / "agents" # le plugin des agents génériques (~/agents) +OPTIMIZER = station.RACINE / "optimizer" # le dépôt Optimizer (~/Optimizer), où tourne /improve +SEANCES = OPTIMIZER / "seances" +# la requête de /improve (optimizer/README.md), chemins relatifs à la racine d'Optimizer (ses liens data, labeling, detectors) +AMELIORER = """/improve DETECTORS: detectors/. STATION: data/{station}. FROM: {du}. TO: {au}. \ +LABELS: labeling/auto/{station}.jsonl. REFERENCE: --labels labeling/auto --data data. FAMILIES: labeling/familles.md. \ +CONTEXT: labeling/auto/analyses/{nom}/rapport.md. OUT: seances/{nom}_{heure}/. Caller's context: Diagnostic-app, through \ +Optimizer; read-only on data/ and labeling/; commit only in detectors/, on its current branch; do not commit OUT.""" DEMANDE = """Station : data/{station}/. Plage : {debut} → {fin} (UTC). Indices de l'utilisateur : {indices}. \ -Dossier de sortie : {sortie}/.""" +Dossier de sortie : {sortie}/. DETECTEURS : non. CONSIGNES : consignes/analyste.md.""" # nom -> {"etat": "en cours" | "fini" | "erreur", "lignes": [...], "versees": n} ; une analyse à la fois par plage analyses, verrou = {}, threading.Lock() @@ -72,7 +74,8 @@ def travailler(nom, sortie, prompt, reprise=None): """Un tour de l'analyste : la demande, ou un message de l'utilisateur dans la même session (reprise : son id).""" a = analyses[nom] try: - p = subprocess.Popen(["claude", "-p", prompt, "--agent", "analyste", "--output-format", "stream-json", "--verbose", + p = subprocess.Popen(["claude", "-p", prompt, "--plugin-dir", str(AGENTS), "--agent", "agents:analyste", + "--output-format", "stream-json", "--verbose", "--allowedTools", "Read,Write,Bash", "--permission-mode", "acceptEdits", *station.liens()] + (["--resume", reprise] if reprise else []), cwd=station.RACINE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True) @@ -218,11 +221,12 @@ def rapport(nom, sombre): return _page(fichier(nom, "rapport.md").read_text(encoding="utf-8"), nom, sombre) -# --- « Optimiser » : /detectors:wf-improve sur l'analyse, puis le tool-builder, par claude -p +# --- « Optimiser » : /improve dans Optimizer sur l'analyse, puis le tool-builder, par claude -p def _bilan(nom): - """Le bilan de la dernière séance de cette analyse, ou None.""" - bilans = sorted((DOSSIER / nom / "detectors").glob("*/summary.md")) # / : l'ordre du nom est celui du temps + """Le bilan de la dernière séance de cette analyse, ou None. Le motif de l'heure écarte les séances d'une autre analyse + de la même plage (__).""" + bilans = sorted(SEANCES.glob(f"{nom}_????????T????Z/summary.md")) # l'ordre du nom est celui du temps return bilans[-1] if bilans else None @@ -245,8 +249,9 @@ def optimiser(nom): """Le bouton « Optimiser » sur une analyse finie : la séance dans un fil ; refusée si une optimisation ou une analyse tourne.""" if etat(nom)["etat"] != "fini": raise station.Refus("seule une analyse finie s'optimise") - if not (DETECTEURS / ".claude-plugin" / "plugin.json").exists(): - raise station.Refus("pas de dépôt detectors en detectors/ (le lien : ln -s ~/detectors detectors)") + if not ((OPTIMIZER / ".claude" / "skills" / "improve" / "SKILL.md").exists() + and (AGENTS / ".claude-plugin" / "plugin.json").exists()): + raise station.Refus("pas d'Optimizer en optimizer/ ou pas d'agents en agents/ (les liens : README.md)") with verrou: if _optimise(): raise station.Refus(OCCUPE) @@ -258,8 +263,8 @@ def optimiser(nom): def optimiser_fil(nom): - """Les deux tours de l'optimisation, l'un après l'autre : les détecteurs (le plugin detectors), puis les outils de lecture - (le tool-builder, même si les détecteurs n'ont pas changé).""" + """Les deux tours de l'optimisation, l'un après l'autre : les détecteurs (/improve, dans Optimizer), puis les outils de + lecture (le tool-builder, même si les détecteurs n'ont pas changé).""" o, sortie = optimisations[nom], DOSSIER / nom rel = os.path.relpath(sortie, station.RACINE) (sortie / "travail").mkdir(exist_ok=True) @@ -268,15 +273,17 @@ def optimiser_fil(nom): d = json.loads((sortie / "demande.json").read_text(encoding="utf-8")) requete = AMELIORER.format( # TO exclu : le jour après la fin de la plage, comme la page station=d["station"], du=d["debut"][:10], au=date.fromisoformat(d["fin"][:10]) + timedelta(days=1), - donnees=os.path.relpath(station.DONNEES, station.RACINE), etiquettes=os.path.relpath(station.ETIQUETTES, station.RACINE), - analyse=rel, sortie=f"{rel}/detectors/{datetime.now(timezone.utc):%Y%m%dT%H%MZ}") - tours = [[requete, "--plugin-dir", "detectors", "--add-dir", str(DETECTEURS.resolve()), # la cible du lien, où la séance écrit - "--allowedTools", "Read,Write,Edit,Bash,Agent"], - [f"Analyse : {rel}/. Écris {rel}/outils.md.", "--agent", "tool-builder", "--allowedTools", "Read,Write,Edit,Bash"]] - for prompt, *options in tours: + nom=nom, heure=f"{datetime.now(timezone.utc):%Y%m%dT%H%MZ}") + # ponytail: Optimizer lit data/ et labeling/ par ses propres liens ; AIMSIGHT_DATA / AIMSIGHT_LABELS ne le suivent pas + tours = [(OPTIMIZER.resolve(), [requete, "--plugin-dir", str(AGENTS.resolve()), + "--add-dir", str(DETECTEURS.resolve()), # la cible du lien, où la séance écrit + "--allowedTools", "Read,Write,Edit,Bash,Agent"]), + (station.RACINE, [f"Analyse : {rel}/. Outils : tools/. Écris {rel}/outils.md.", "--plugin-dir", str(AGENTS), + "--agent", "agents:tool-builder", "--allowedTools", "Read,Write,Edit,Bash"])] + for dossier, (prompt, *options) in tours: p = subprocess.Popen(["claude", "-p", prompt, "--output-format", "stream-json", "--verbose", "--permission-mode", "acceptEdits", *station.liens(), *options], - cwd=station.RACINE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True) + cwd=dossier, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True) for ligne in p.stdout: flux.write(ligne) o["lignes"] += resume(ligne) diff --git a/app/serveur/check.py b/app/serveur/check.py index 7a5fbe1..5dc936d 100644 --- a/app/serveur/check.py +++ b/app/serveur/check.py @@ -112,13 +112,15 @@ def check_optimisation(): stdout = iter(lambda: fin.wait() and "", "") # rien, jusqu'au signal def __init__(self, args, *a, **k): - lances.append(args) + lances.append((args, k)) def wait(self): return 0 - avant = analyse.DOSSIER, analyse.subprocess.Popen - analyse.DOSSIER = seance_temporaire() + avant = analyse.DOSSIER, analyse.subprocess.Popen, analyse.OPTIMIZER, analyse.SEANCES, analyse.AGENTS + racine = seance_temporaire() + analyse.DOSSIER, analyse.OPTIMIZER, analyse.AGENTS = racine / "analyses", racine / "optimizer", racine / "agents" + analyse.SEANCES = analyse.OPTIMIZER / "seances" analyse.subprocess.Popen = FauxProcessus try: for nom in ("NORDEND_a", "NORDEND_b"): @@ -127,6 +129,13 @@ def check_optimisation(): {"station": "NORDEND", "debut": "2026-11-04T21:12Z", "fin": "2026-11-07T14:12Z", "indices": ""})) (analyse.DOSSIER / nom / "rapport.md").write_text("# rapport") assert analyse.etat("NORDEND_a")["optimisation"] is None + # sans Optimizer, puis sans agents : un refus clair, pas une trace d'erreur + assert "optimizer/" in leve(analyse.optimiser, "NORDEND_a") + (analyse.OPTIMIZER / ".claude" / "skills" / "improve").mkdir(parents=True) + (analyse.OPTIMIZER / ".claude" / "skills" / "improve" / "SKILL.md").write_text("improve") + assert "agents/" in leve(analyse.optimiser, "NORDEND_a") + (analyse.AGENTS / ".claude-plugin").mkdir(parents=True) + (analyse.AGENTS / ".claude-plugin" / "plugin.json").write_text("{}") assert analyse.optimiser("NORDEND_a") == {} assert analyse.etat("NORDEND_a")["optimisation"]["etat"] == "en cours" leve(analyse.optimiser, "NORDEND_a") @@ -137,9 +146,13 @@ def check_optimisation(): while analyse.etat("NORDEND_a")["optimisation"]["etat"] == "en cours": time.sleep(0.05) assert analyse.etat("NORDEND_a")["optimisation"]["etat"] == "fini" - requete = lances[0][2] # la plage de l'analyse, TO exclu - assert requete.startswith("/detectors:wf-improve ") and "/NORDEND. FROM: 2026-11-04. TO: 2026-11-08. LABELS: " \ - in requete and "/NORDEND_a/detectors/" in requete, requete + args, k = lances[0] # /improve dans Optimizer, sur la plage de l'analyse, TO exclu + requete = args[2] + assert requete.startswith("/improve ") and "STATION: data/NORDEND. FROM: 2026-11-04. TO: 2026-11-08." in requete \ + and "OUT: seances/NORDEND_a_" in requete, requete + assert k["cwd"] == analyse.OPTIMIZER.resolve() and "--plugin-dir" in args, (args, k) + args, k = lances[1] # puis le tool-builder du dépôt agents, sur le dépôt tools + assert args[args.index("--agent") + 1] == "agents:tool-builder" and "Outils : tools/" in args[2], args analyse.analyses["NORDEND_b"]["etat"] = "en cours" # une analyse qui tourne bloque l'optimisation leve(analyse.optimiser, "NORDEND_a") # après un redémarrage : le flux finit par {"type": "fin"} -> fini ; sans cette ligne -> interrompue ; le bilan des @@ -152,8 +165,12 @@ def check_optimisation(): flux.write_text('{"type": "assistant", "message": {"content": []}}\n') analyse.optimisations.clear() assert analyse.etat("NORDEND_a")["optimisation"]["etat"] == "interrompue" - (analyse.DOSSIER / "NORDEND_a" / "detectors" / "20261113T1000Z").mkdir(parents=True) - (analyse.DOSSIER / "NORDEND_a" / "detectors" / "20261113T1000Z" / "summary.md").write_text("# wf-improve\n\n**Result**: none") + (analyse.SEANCES / "NORDEND_a_20261113T1000Z").mkdir(parents=True) + (analyse.SEANCES / "NORDEND_a_20261113T1000Z" / "summary.md").write_text("# improve\n\n**Result**: none") + # une nouvelle analyse de la même plage (NORDEND_a_143000) : sa séance n'est pas le bilan de NORDEND_a + (analyse.SEANCES / "NORDEND_a_143000_20261113T1100Z").mkdir(parents=True) + (analyse.SEANCES / "NORDEND_a_143000_20261113T1100Z" / "summary.md").write_text("# autre analyse") + assert analyse._bilan("NORDEND_a").parent.name == "NORDEND_a_20261113T1000Z", analyse._bilan("NORDEND_a") (analyse.DOSSIER / "NORDEND_a" / "outils.md").write_text("# Outils\n\n**Outils modifiés** : aucun") assert analyse.etat("NORDEND_a")["optimisation"]["bilan"] page = analyse.bilan("NORDEND_a", False) @@ -161,13 +178,55 @@ def check_optimisation(): assert analyse.etat("NORDEND_b")["optimisation"] is None finally: fin.set() - shutil.rmtree(analyse.DOSSIER) - analyse.DOSSIER, analyse.subprocess.Popen = avant + shutil.rmtree(racine) + analyse.DOSSIER, analyse.subprocess.Popen, analyse.OPTIMIZER, analyse.SEANCES, analyse.AGENTS = avant analyse.analyses.clear() analyse.optimisations.clear() -CHECKS = [check_serveur, check_station, check_optimisation] +def check_analyse(): + # « Analyser la plage » puis un message (analyse.lancer, analyse.message), sans claude : l'analyste du dépôt agents, ses + # paramètres, et la reprise de sa session avec le même agent + import analyse + lances = [] + + class FauxProcessus: + returncode = 0 + + def __init__(self, args, *a, **k): + lances.append(args) + self.stdout = iter([]) + + def wait(self): + return 0 + + (station.RACINE / "out").mkdir(exist_ok=True) # sous la racine : la demande cite le dossier de sortie par rapport à elle + avant = analyse.DOSSIER, analyse.subprocess.Popen, analyse.verser + analyse.DOSSIER = Path(tempfile.mkdtemp(dir=station.RACINE / "out")) + analyse.subprocess.Popen = FauxProcessus + analyse.verser = lambda *a: 0 # sinon le test réécrit le vrai labeling/auto/NORDEND.jsonl + try: + nom = analyse.lancer({"station": "NORDEND", "debut": "2026-11-05T06:00Z", "fin": "2026-11-05T12:00Z"})["nom"] + while analyse.analyses[nom]["etat"] == "en cours": + time.sleep(0.05) + assert analyse.analyses[nom]["etat"] == "fini", analyse.analyses[nom] + args = lances[0] + assert args[args.index("--agent") + 1] == "agents:analyste" and "--plugin-dir" in args, args + assert "DETECTEURS : non" in args[2] and "CONSIGNES : consignes/analyste.md" in args[2], args[2] + (analyse.DOSSIER / nom / "travail" / "session").write_text("s-1") + analyse.message(nom, {"texte": "continue"}) + while analyse.analyses[nom]["etat"] == "en cours": + time.sleep(0.05) + args = lances[1] + assert args[args.index("--resume") + 1] == "s-1" and args[args.index("--agent") + 1] == "agents:analyste" \ + and "--plugin-dir" in args, args + finally: + shutil.rmtree(analyse.DOSSIER) + analyse.DOSSIER, analyse.subprocess.Popen, analyse.verser = avant + analyse.analyses.clear() + + +CHECKS = [check_serveur, check_station, check_optimisation, check_analyse] if __name__ == "__main__": nom = sys.argv[1] if len(sys.argv) > 1 else None diff --git a/app/serveur/station.py b/app/serveur/station.py index 169530b..16cc3af 100644 --- a/app/serveur/station.py +++ b/app/serveur/station.py @@ -1,6 +1,6 @@ """Les données de la page Data : les images d'une station, ses courbes, ses étiquettes. -La lecture des données est celle des agents, agent-tools/donnees.py ; les événements des détecteurs, ceux de +La lecture des données est celle des agents, tools/donnees.py (le dépôt tools, par le lien tools/) ; les événements des détecteurs, ceux de detectors/scripts/categories.py (events). Lecture seule sur data/ ; écrit seulement dans labeling/{auto,manual}/. """ import bisect @@ -16,18 +16,19 @@ from datetime import datetime, timedelta from pathlib import Path RACINE = Path(__file__).resolve().parents[2] -sys.path[:0] = [str(RACINE / "agent-tools"), str(RACINE / "detectors" / "scripts")] +sys.path[:0] = [str(RACINE / "tools"), str(RACINE / "detectors" / "scripts")] import donnees # noqa: E402 from categories import events # noqa: E402 # data/ et labeling/ sont des liens vers ~/aimsight-data/data et ~/labeling : pas de resolve(), les agents voient data/ et labeling/ DONNEES = Path(os.environ.get("AIMSIGHT_DATA", RACINE / "data")).absolute() ETIQUETTES = Path(os.environ.get("AIMSIGHT_LABELS", RACINE / "labeling")).absolute() +TOOLS = RACINE / "tools" # le harnais de lecture (~/tools), que lit l'analyste et où écrit le tool-builder def liens(): - """--add-dir pour claude -p : la cible réelle des liens data/ et labeling/, hors du dépôt.""" - return [a for d in (DONNEES, ETIQUETTES) for a in ("--add-dir", str(d.resolve()))] + """--add-dir pour claude -p : la cible réelle des liens data/, labeling/ et tools/, hors du dépôt.""" + return [a for d in (DONNEES, ETIQUETTES, TOOLS) for a in ("--add-dir", str(d.resolve()))] DOSSIERS = ("auto", "manual") # celles des agents et de la page (D-105), celles de l'expert (D-102) @@ -186,7 +187,7 @@ def courbes(station, du, au): HISTORIQUE = timedelta(days=3) # jours d'avant donnés aux détecteurs, comme categories.py (règle du 2026-10-24) -# ponytail: gardés jusqu'au redémarrage du serveur (une minute ou plus par plage) ; relancer après un /detectors:wf-improve lancé hors de l'app +# ponytail: gardés jusqu'au redémarrage du serveur (une minute ou plus par plage) ; relancer après un /improve lancé hors de l'app @functools.lru_cache(maxsize=32) def detecteurs(station, du, au, cibles=""): """-> les événements des détecteurs sur la plage, au format des étiquettes (debut, fin, categorie, description) ; diff --git a/app/web/src/pages/Data.jsx b/app/web/src/pages/Data.jsx index 665a9cf..626c7b7 100644 --- a/app/web/src/pages/Data.jsx +++ b/app/web/src/pages/Data.jsx @@ -488,7 +488,7 @@ const COULEUR_ETAT = { "en cours": "blue", fini: "teal", erreur: "red", interrom // Une analyse de l'onglet Analysis : son fil (relu toutes les 3 s tant qu'elle travaille), son rapport, et un message à // l'analyste, qui reprend sa session ; à la fin de chaque tour, les étiquettes se relisent. Une analyse finie s'optimise -// (/detectors:wf-improve sur la plage de l'analyse, puis le tool-builder) : le fil de la séance, puis ses bilans sous le rapport +// (/improve d'Optimizer sur la plage de l'analyse, puis le tool-builder) : le fil de la séance, puis ses bilans sous le rapport function Analyse({ nom, sombre, fini, fermer }) { const [a, setA] = useState(null), [tour, setTour] = useState(0), [texte, setTexte] = useState(""); const boite = useRef(), charge = !!a; @@ -524,7 +524,7 @@ function Analyse({ nom, sombre, fini, fermer }) { {occupe && } - {a.etat === "fini" && + {a.etat === "fini" && } @@ -552,7 +552,7 @@ function Analyse({ nom, sombre, fini, fermer }) { {o.etat === "interrompue" && Arrêtée avec le serveur ; la relancer par le bouton.} {o.bilan && } - {o.bilan && python3 detectors/skills/wf-improve/scripts/score.py data/{d.station} --labels labeling/auto/{d.station}.jsonl --from {d.debut.slice(0, 10)} --to {au}} + {o.bilan && python3 detectors/bench/score.py data/{d.station} --labels labeling/auto/{d.station}.jsonl --from {d.debut.slice(0, 10)} --to {au}} )} labeling/auto/analyses/{nom}/ diff --git a/consignes/analyste.md b/consignes/analyste.md new file mode 100644 index 0000000..0ef9120 --- /dev/null +++ b/consignes/analyste.md @@ -0,0 +1,27 @@ +# Consignes de Diagnostic-App à l'analyste + +Ce que l'app demande à l'analyste (dépôt agents, `agents:analyste`), en plus de son métier. Lancé par l'onglet Analysis de la page Data (`app/serveur/analyse.py`), avec `DETECTEURS : non`. + +## Pourquoi cette plage + +L'utilisateur a sélectionné une plage dans la page Data et cliqué « Analyser la plage » : il y a vu une anomalie que les détecteurs captent mal, ou il veut une analyse plus poussée. Ses indices sont dans la requête (ou « aucun »). Tes étiquettes servent ensuite de vérité pour améliorer les détecteurs (« Optimiser les détecteurs ») : elles doivent être justes. + +## Ton dossier de sortie + +`labeling/auto/analyses/__/`, donné par la requête ; ton travail et le journal de claude dans `travail/`, hors de git. + +- Tes étiquettes vont dans `etiquettes.jsonl` ; c'est le serveur qui les verse dans `labeling/auto/.jsonl`. **Tu n'écris jamais dans `labeling/auto/.jsonl`.** +- Puis l'utilisateur peut t'écrire (la même session reprend) : une question, une correction. Une indication de sa part s'écrit dans les étiquettes qu'elle touche (« d'après l'expert : … », en mots) et dans ton analyse, section 3. Si tu changes tes étiquettes, réécris `etiquettes.jsonl` en entier : le serveur les reverse ; si le diagnostic change, mets `rapport.md` à jour. + +## Le rapport + +En plus de tes étiquettes et de ton analyse : `rapport.md`, le diagnostic que l'utilisateur lira dans la page, en français : + +- `# : `, puis la question (sa sélection, ses indices) en une ou deux phrases ; +- « Ce que montrent les données » : chaque événement daté (UTC), les capteurs touchés et ceux qui ne bougent pas, la cause et son niveau de preuve (confirmed / strongly supported / consistent with / possible / insufficient evidence / not observed), la commande qui fonde chaque fait ; +- les figures qui prouvent, chacune insérée par `![légende](chemin relatif au dossier de sortie)` et suivie d'une ligne qui dit ce qu'on y voit : courbes (`graphique.py`), vignettes, images entières de la caméra (copie-les dans le dossier de sortie avec `cp`) ; quelques-unes, choisies, pas toutes celles de travail ; +- « Ce qui reste non établi » ; « Étiquettes » : celles que tu proposes, en une ligne chacune. + +## Ta réponse + +En 2 lignes : le nombre d'étiquettes, le chemin du rapport.