diff --git a/.claude/skills/lire-les-donnees/SKILL.md b/.claude/skills/lire-les-donnees/SKILL.md index 7458db3..4581d20 100644 --- a/.claude/skills/lire-les-donnees/SKILL.md +++ b/.claude/skills/lire-les-donnees/SKILL.md @@ -22,7 +22,8 @@ Lance-les depuis la racine du dépôt. Ils rendent des valeurs, jamais des verdi | `python3 agents/diagnostic/outils/resume.py [--colonne C] [--stat median\|min\|max] [--pas 1h] [--niveau periode\|fenetre] [--capteurs A,B] [--debut T] [--fin T]` | 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` | | `.venv/bin/python agents/diagnostic/outils/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. **Regarde-le avec Read** : tu lis mieux un graphique qu'un tableau | | `.venv/bin/python agents/diagnostic/outils/ensemble.py [--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]] [--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. 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, par capteur, min, max et valeur au dernier instant de `dx`, `dy`. 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 graduations du PNG « commun » sont toutes les 1 à 12 h selon la fenêtre. 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 agents/diagnostic/outils/plages.py [--colonnes error_value,corr_x,corr_y] [--k 5] [--fusion 1h] [--hors T1/T2] [--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. 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 | +| `python3 agents/diagnostic/outils/plages.py [--colonnes error_value,corr_x,corr_y] [--k 5] [--fusion 1h] [--min-mesures 1] [--hors T1/T2] [--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. 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 | +| `.venv/bin/python agents/diagnostic/outils/jours.py [--colonnes corr_x,corr_y,error_value] [--nuit 20-3] [--k 5] [--jours 2] [--pas 15min] [--capteurs A,B] [--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. 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 agents/diagnostic/outils/vignettes.py --capteurs A,B --heures T1,T2 [--rayon 100] [--contraste [MIN,MAX]] [--fixe] [--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 | | `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) | @@ -38,10 +39,10 @@ Lance-les depuis la racine du dépôt. Ils rendent des valeurs, jamais des verdi ## La méthode 1. **Inventaire** : ce qui est disponible, ce qui manque (fichiers, images, poses de la caméra, période, cadence, capteurs). 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 ; **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). 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). +2. **Large d'abord** : `ensemble.py` sur le lot, d'abord ; **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. 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 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), et les tables de `x`, `y` sur les fenêtres où ils s'agitent. +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), et les tables de `x`, `y` sur les fenêtres où ils s'agitent. 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 diff --git a/agents/diagnostic/outils/jours.py b/agents/diagnostic/outils/jours.py new file mode 100644 index 0000000..5b42a70 --- /dev/null +++ b/agents/diagnostic/outils/jours.py @@ -0,0 +1,194 @@ +"""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 agents/diagnostic/outils/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] [--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. +Rend des valeurs, pas de verdict. +""" +import argparse +import math +import os +import statistics +import sys +from datetime import timedelta + +import matplotlib + +matplotlib.use("Agg") +import matplotlib.pyplot as plt # noqa: E402 + +from donnees import charger, est_reference, filtrer, instant, iso, rejetee # noqa: E402 +from graphique import COLONNES, RACINE, borne # noqa: E402 +from resume import 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("--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] = statistics.median(abs(b[1] - a_[1]) for a_, b in zip(ms, ms[1:])) + 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 __name__ == "__main__": + main() diff --git a/agents/diagnostic/outils/plages.py b/agents/diagnostic/outils/plages.py index f80908b..b390bec 100644 --- a/agents/diagnostic/outils/plages.py +++ b/agents/diagnostic/outils/plages.py @@ -1,7 +1,7 @@ """Plages datées par capteur et par colonne, au pas natif des mesures, pour l'agent de diagnostic. Usage : python3 agents/diagnostic/outils/plages.py data/PS_DES_COUDRES/ [--colonnes error_value,corr_x,corr_y] - [--k 5] [--fusion 1h] [--hors T1/T2] [--capteurs A,B] [--debut ...] [--fin ...] + [--k 5] [--fusion 1h] [--min-mesures 1] [--hors T1/T2] [--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 @@ -16,6 +16,7 @@ long fausse la médiane) et à son bruit propre (médiane des écarts entre deux 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). Chaque colonne est lue aux mesures, jamais moyennée par pas. Rend des valeurs, pas de verdict. """ import argparse @@ -32,6 +33,7 @@ def main(): 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("--capteurs", help="liste séparée par des virgules (défaut : tous)") a.add_argument("--debut", type=instant) @@ -87,7 +89,10 @@ def main(): groupe.append((t, v)) elif t is None and groupe: plages.append((s, groupe, niv, bruit, rej)) - print(f"\n{col} : plages à plus de {o.k:g} bruits du niveau{' (niveau hors ' + o.hors + ')' if hors else ''} (fusion {int(o.fusion.total_seconds() // 60)} min)") + 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{' (niveau hors ' + o.hors + ')' if hors 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, niv, bruit, rej in plages: t, v = max(g, key=lambda x: abs(x[1] - niv)) diff --git a/vues-deplacements/aiguiser/2026-10-27T0843Z_WILDSTRUBEL/lot-01/modification-2.md b/vues-deplacements/aiguiser/2026-10-27T0843Z_WILDSTRUBEL/lot-01/modification-2.md new file mode 100644 index 0000000..745b18f --- /dev/null +++ b/vues-deplacements/aiguiser/2026-10-27T0843Z_WILDSTRUBEL/lot-01/modification-2.md @@ -0,0 +1,54 @@ +# Modification 2 : lot 01, WILDSTRUBEL + +## Défaut traité +D1 (rien ne superpose les jours par heure du jour : un écart court qui revient chaque matin se noie) et D2 (un capteur à plusieurs niveaux n'a pas de niveau par nuit ; les paliers longs se noient parmi les plages d'un pas). + +## Ce qui a changé +- `agents/diagnostic/outils/jours.py` (nouveau, docstring en tête) : sur les mesures acceptées seulement, deux choses par colonne (défaut `corr_x,corr_y,error_value`). + 1. Pour D2, le **niveau de chaque nuit** (`--nuit H1-H2` en UTC, défaut `20-3`, à cheval sur minuit) de chaque capteur : médiane, MAD, nombre de mesures et bruit propre. D'une nuit à la suivante, il donne la marche (en unités et en bruits) et sa place, « entre A et B ». La place est la coupure de la suite des mesures de nuit qui minimise la somme des écarts absolus aux deux niveaux. Si B tombe en début de nuit, la coupure est de jour. + 2. Pour D1, les **jours superposés**. Le PNG `parheure-` a un petit graphique par capteur, l'heure du jour en abscisse et une courbe par jour. Chaque mesure y est diminuée du niveau de la dernière nuit commencée, ce qui garde juste un capteur à plusieurs niveaux. Le cadre va du 1er au 99e centile, et le titre dit combien de mesures en sortent. La table donne, par créneau de `--pas` de l'heure du jour, les capteurs à plus de `--k` bruits du même côté au moins `--jours` jours, avec « n jours / jours mesurés » et la médiane de ces écarts. L'outil ne pose ni seuil propre ni catégorie : `--k` et `--jours` sont des réglages du lecteur, comme `--k` et `--min` d'`ensemble.py`. +- `agents/diagnostic/outils/plages.py` : nouvelle option `--min-mesures N` (défaut 1, la sortie par défaut ne change pas). Elle n'imprime que les plages d'au moins N mesures et dit combien il y en a sur le total (D2 : « les plages longues avant les plages d'un pas », demandé aussi par la lecture). Docstring à jour. +- `.claude/skills/lire-les-donnees/SKILL.md` : + - Le tableau a une ligne pour `jours.py` et décrit `--min-mesures`. + - Méthode, étape 2 : sur un lot de plus de deux jours, lancer `jours.py` avant de lire les pas isolés. Ce qui revient à la même heure fait un moment par heure du jour. Le tableau des niveaux de nuit se lit pour tout capteur qui a fait un palier ou qui a plusieurs niveaux : marches datées par « entre A et B », marches d'`error_value` et de `corr` au même instant reliées, dérive d'une nuit à l'autre. + - Étape 5 : `plages.py` d'abord avec `--min-mesures 6`. + +## Essai +`.venv/bin/python agents/diagnostic/outils/jours.py data/WILDSTRUBEL --debut 2026-09-24T00:00Z --fin 2026-09-28T00:00Z --sortie lot-01/modification-2/` + +**D2, niveaux de nuit** +- PB2_2 `corr_x` : −0,049 (23/09), −0,322, −0,118, −0,107, −0,156 (27/09). Les marches sont datées : + - −0,273 (−17 bruits) entre 24/09 02:30 et 02:45 ; + - +0,204 entre 25/09 02:30 et 02:45 ; + - **−0,049 (−3,1 bruits) entre 27/09 02:15 et 02:30** : c'est le pas manqué. +- PB2_2 `error_value` : 0,104, 0,124, **0,160**, 0,161, 0,158. Les marches sont +0,019 entre 24/09 02:30 et 02:45, puis **+0,036 entre 25/09 02:30 et 02:45**, au même pas que le retour de `corr_x` : c'était 15:30 dans la lecture. +- PB1_2 `corr_y` : −0,174, −0,165, −0,195, −0,207, −0,208. PB4 `corr_y` : +0,064 → +0,042. Ce sont les dérives faibles. +- Avec `--colonnes x,y`, la dérive commune se lit nuit par nuit : `y` de R1 934,72 → 934,32 ; `y` de PB2_2 1181,15 → 1180,70. + +**D1, table par créneau de `corr_x`** +- 04:30 : PA1_2 3/4 +0,148 (+12 bruits), PA2_2 2/3 +0,139, PA3_2 2/3 +0,098, PB3_2 2/3 +0,072, R1 2/4 −0,074 (−7,9). +- 04:45, 05:00 et 05:15 : les mêmes. + +Ce sont les résidus du lever du soleil, regroupés sur une ligne par créneau. PB1_2 n'y est pas, parce que ses écarts de 04:30 sont de sens opposés selon les jours. Il se voit sur le PNG. + +**D1, table par créneau de `corr_y`** +05:30–08:00 : PB1_2 2 à 3/4 +0,09 à +0,12, PB2_2 et PB3_2. C'est la bosse du matin. + +**Figures de `lot-01/modification-2/`, toutes regardées** +- `parheure-corr_x` : le pic de PA1_2, PA2_2 et PA_9 à 04:30–05:00 chaque jour, et le creux de R1 au même moment. Pour PB2_2, quatre jours à quatre niveaux différents (le palier, le retour, et 27/09 à −0,05). Les pics à 30 px (PB2_2, PB_5) sont hors cadre et comptés dans le titre. +- `parheure-corr_y` : la bosse du matin de PB1_2 et PB2_2. +- `parheure-error_value` : le cycle du jour, identique d'un jour à l'autre. Pour PB2_2, le 25/09 reste à +0,035 après 15 h, parce que son niveau a changé à 02:45. +- `parheure-x`, `parheure-y` : vues (essai `--colonnes x,y`). + +**`plages.py`** +`plages.py … --colonnes corr_x --min-mesures 6` : « 4 d'au moins 6 mesures sur 90 ». Il reste le palier de PB2_2 (24/09 06:00 → 25/09 02:30, 83 mesures), ses deux bords, et PB1_2 le 27/09 (19 mesures). + +## Commandes des fiches relancées +6 (`plages.py`), aucun échec. Aucune fiche n'emploie `jours.py`. + +## Pas fait +- La table par créneau d'`error_value` est longue sur ce lot (49 lignes, de 10 à 13 capteurs par créneau de jour), parce que le cycle du jour dépasse tous les seuils. Le skill ne dit pas de la sauter. Le lecteur peut passer `--colonnes corr_x,corr_y` ou monter `--k`. +- Le défaut `--nuit 20-3` est un choix d'heures UTC sombres toute l'année en Suisse. Le skill demande de le choisir là où le cycle du jour est retombé. L'outil ne le déduit pas des données. + +## Difficultés +- `vues-deplacements/CLAUDE.md` a été injecté dans mon contexte après la lecture d'un PNG, alors que la consigne exclut `CLAUDE.md`. Je ne m'en suis pas servi. diff --git a/vues-deplacements/aiguiser/2026-10-27T0843Z_WILDSTRUBEL/lot-01/modification-2/WILDSTRUBEL_parheure-corr_x_20260924T0000Z_20260928T0000Z.png b/vues-deplacements/aiguiser/2026-10-27T0843Z_WILDSTRUBEL/lot-01/modification-2/WILDSTRUBEL_parheure-corr_x_20260924T0000Z_20260928T0000Z.png new file mode 100644 index 0000000..425f383 Binary files /dev/null and b/vues-deplacements/aiguiser/2026-10-27T0843Z_WILDSTRUBEL/lot-01/modification-2/WILDSTRUBEL_parheure-corr_x_20260924T0000Z_20260928T0000Z.png differ diff --git a/vues-deplacements/aiguiser/2026-10-27T0843Z_WILDSTRUBEL/lot-01/modification-2/WILDSTRUBEL_parheure-corr_y_20260924T0000Z_20260928T0000Z.png b/vues-deplacements/aiguiser/2026-10-27T0843Z_WILDSTRUBEL/lot-01/modification-2/WILDSTRUBEL_parheure-corr_y_20260924T0000Z_20260928T0000Z.png new file mode 100644 index 0000000..ff25b89 Binary files /dev/null and b/vues-deplacements/aiguiser/2026-10-27T0843Z_WILDSTRUBEL/lot-01/modification-2/WILDSTRUBEL_parheure-corr_y_20260924T0000Z_20260928T0000Z.png differ diff --git a/vues-deplacements/aiguiser/2026-10-27T0843Z_WILDSTRUBEL/lot-01/modification-2/WILDSTRUBEL_parheure-error_value_20260924T0000Z_20260928T0000Z.png b/vues-deplacements/aiguiser/2026-10-27T0843Z_WILDSTRUBEL/lot-01/modification-2/WILDSTRUBEL_parheure-error_value_20260924T0000Z_20260928T0000Z.png new file mode 100644 index 0000000..ceeab89 Binary files /dev/null and b/vues-deplacements/aiguiser/2026-10-27T0843Z_WILDSTRUBEL/lot-01/modification-2/WILDSTRUBEL_parheure-error_value_20260924T0000Z_20260928T0000Z.png differ diff --git a/vues-deplacements/aiguiser/2026-10-27T0843Z_WILDSTRUBEL/lot-01/modification-2/WILDSTRUBEL_parheure-x_20260924T0000Z_20260928T0000Z.png b/vues-deplacements/aiguiser/2026-10-27T0843Z_WILDSTRUBEL/lot-01/modification-2/WILDSTRUBEL_parheure-x_20260924T0000Z_20260928T0000Z.png new file mode 100644 index 0000000..5a25ba0 Binary files /dev/null and b/vues-deplacements/aiguiser/2026-10-27T0843Z_WILDSTRUBEL/lot-01/modification-2/WILDSTRUBEL_parheure-x_20260924T0000Z_20260928T0000Z.png differ diff --git a/vues-deplacements/aiguiser/2026-10-27T0843Z_WILDSTRUBEL/lot-01/modification-2/WILDSTRUBEL_parheure-y_20260924T0000Z_20260928T0000Z.png b/vues-deplacements/aiguiser/2026-10-27T0843Z_WILDSTRUBEL/lot-01/modification-2/WILDSTRUBEL_parheure-y_20260924T0000Z_20260928T0000Z.png new file mode 100644 index 0000000..b19b984 Binary files /dev/null and b/vues-deplacements/aiguiser/2026-10-27T0843Z_WILDSTRUBEL/lot-01/modification-2/WILDSTRUBEL_parheure-y_20260924T0000Z_20260928T0000Z.png differ