Reading tools: what the etiqueteur had to script itself (metrics, daily bounds, local level, zone, references)
- metriques.py: new, reads metrics/ (temperatures, voltage) against targets and camera pose - jours.py --bornes: per-day first/last excursion, extreme, from the previous night - plages.py --glissant, --instants: deviations from a local level, per-instant view - ensemble.py --table, resume.py --marque/--instants: shorter outputs, repeated headers - inventaire.py: image gaps as runs, references on reproj_err when inlier is empty - vignettes.py --zone: same scene area across hours - donnees.py: references recognised when pattern_type is empty (benchmark unchanged) - lire-les-donnees: new options documented, gif.py row added Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
6fbd7510b7
commit
efbc5f15d7
9 files changed
+670
-80
No files matched your search
@@ -18,13 +18,15 @@ Lance-les depuis la racine du dépôt. Ils rendent des valeurs, jamais des verdi
|
||||
|
||||
| Commande | Ce qu'elle rend |
|
||||
|---|---|
|
||||
| `python3 agent-tools/inventaire.py <dossier> [--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 (heures couvertes), 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** |
|
||||
| `python3 agent-tools/resume.py <dossier> [--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` |
|
||||
| `python3 agent-tools/inventaire.py <dossier> [--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. 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 <dossier> [--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`. 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 <dossier> [--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 agent-tools/ensemble.py <dossier> [--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 agent-tools/plages.py <dossier> [--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 agent-tools/jours.py <dossier> [--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-<colonne>**, 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 agent-tools/vignettes.py <dossier> --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 |
|
||||
| `.venv/bin/python agent-tools/ensemble.py <dossier> [--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]] [--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. 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 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 <dossier> [--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. 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 <dossier> [--colonnes corr_x,corr_y,error_value] [--nuit 20-3] [--k 5] [--jours 2] [--pas 15min] [--capteurs A,B] [--bornes] [--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-<colonne>**, 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. 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 <dossier> [--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 `<contre>_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/vignettes.py <dossier> --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 <dossier> --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 <dossier>/images/ \| grep <AAAAMMJJ>T<HHMM>Z`, 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 <dossier>` : là où celui qui t'appelle range tes figures ; il te le donne.
|
||||
@@ -33,16 +35,17 @@ Lance-les depuis la racine du dépôt. Ils rendent des valeurs, jamais des verdi
|
||||
|
||||
- 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 <racine> && <commande>` compte pour une commande. N'écris aucun autre script. Celui qui t'appelle peut ajouter des commandes à cette liste.
|
||||
- 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é.
|
||||
- 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). 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 (par exemple les six colonnes de qualité d'image, `peak` à `snr`, sur certaines stations) ou une source qu'aucun outil ne lit (`metrics/`, `images_diff/`) reste une donnée : sache qu'elle existe. 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). 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).
|
||||
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 (par exemple les six colonnes de qualité d'image, `peak` à `snr`, sur certaines stations) ou une source qu'aucun outil ne lit (`images_diff/`) reste une donnée : sache qu'elle existe. `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. Une ligne « 1 mesures » est un pic, pas un cycle. Quand la pose ou les `corr` des cibles dLine truncated
|
||||
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), 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 ; 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.
|
||||
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
|
||||
|
||||
@@ -97,8 +97,13 @@ def charger_camera(dossier):
|
||||
|
||||
|
||||
def est_reference(mesures):
|
||||
"""Référence du réseau de compensation (pattern_type global_ref), sinon cible."""
|
||||
return mesures[0]["pattern_type"] == "global_ref"
|
||||
"""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 : docs/domaine/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):
|
||||
|
||||
+28
-9
@@ -2,7 +2,7 @@
|
||||
|
||||
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]] [--capteurs A,B] [--debut ...] [--fin ...] [--sortie DOSSIER]
|
||||
[--residus corr_x,corr_y,error_value] [--hors T1/T2] [--autres] [--rigide BASE [--sans 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 :
|
||||
@@ -40,7 +40,11 @@ un début ou une fin, la table est au pas de --pas (défaut 15min, la cadence de
|
||||
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). Rend des valeurs, pas de verdict.
|
||||
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
|
||||
@@ -146,7 +150,7 @@ def rigide(o, noms, series, temps, base, station):
|
||||
|
||||
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] ; médiane par pas de {int(o.pas.total_seconds() // 60)} min :")
|
||||
+ f".\nRésidu = position brute moins la position de {iso(t_b)} transportée par ce mouvement [px] ; 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 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
|
||||
@@ -159,8 +163,10 @@ def rigide(o, noms, series, temps, base, station):
|
||||
if t in res[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)
|
||||
print(f"{'instant':17}" + "".join(f"{c:>{w}}" for c in cols))
|
||||
for t in sorted(par_pas):
|
||||
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))
|
||||
for s in noms:
|
||||
if res[s]:
|
||||
@@ -183,6 +189,8 @@ def main():
|
||||
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("--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)
|
||||
@@ -198,6 +206,13 @@ def main():
|
||||
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"), (colonnes + residus + [o.colonne], COLONNES, "Colonnes")):
|
||||
absents = [x for x in demandes if x not in connus]
|
||||
if absents:
|
||||
@@ -272,7 +287,9 @@ def main():
|
||||
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)
|
||||
axes[-1, 0].xaxis.set_major_locator(mdates.HourLocator(byhour=range(0, 24, h)))
|
||||
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]:
|
||||
@@ -300,9 +317,11 @@ def main():
|
||||
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 :")
|
||||
print(f"{'instant':17}" + "".join(f"{c:>13}" for c in cols_t))
|
||||
for t in sorted(lignes_t):
|
||||
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]:
|
||||
|
||||
+88
-29
@@ -4,11 +4,16 @@ Usage : python3 agent-tools/inventaire.py data/PS_DES_COUDRES/ [--debut T] [--fi
|
||||
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) à chaque instant et, datées, les suites d'instants où des
|
||||
références ne le sont pas (lesquelles, et pourquoi : rejetée, inlier 0, inlier vide). Mouvements de la caméra (camera/) : nombre de poses, période, et les instants de mesure
|
||||
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, les noms
|
||||
des métriques système de metrics/, les images et les images différentielles. Rend des valeurs, pas de verdict.
|
||||
(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
|
||||
@@ -24,6 +29,36 @@ from donnees import charger, charger_camera, est_reference, filtrer, heure_image
|
||||
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:
|
||||
@@ -38,6 +73,7 @@ def liste(chemins, tout):
|
||||
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 docs/domaine/colonnes-des-deplacements.md)")
|
||||
liste(f["horaire"], tout)
|
||||
@@ -48,8 +84,9 @@ def fichiers(f, tout=False):
|
||||
|
||||
|
||||
def remplies(chemins, debut, fin):
|
||||
"""CSV d'une source -> (lignes de la fenêtre, {colonne: lignes avec une valeur}), colonnes dans l'ordre des en-têtes."""
|
||||
lignes, compte = 0, {}
|
||||
"""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)
|
||||
@@ -63,7 +100,9 @@ def remplies(chemins, debut, fin):
|
||||
for c in compte:
|
||||
if (row.get(c) or "").strip():
|
||||
compte[c] += 1
|
||||
return lignes, compte
|
||||
if row.get("sensor_name"):
|
||||
qui[c].add(row["sensor_name"].strip())
|
||||
return lignes, compte, qui
|
||||
|
||||
|
||||
def contenu(dossier, f, debut=None, fin=None):
|
||||
@@ -77,8 +116,11 @@ def contenu(dossier, f, debut=None, fin=None):
|
||||
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 = remplies(chemins, debut, fin)
|
||||
print(f" {titre} : {n} lignes ; " + ", ".join(f"{c} {k}" if k else f"{c} vide" for c, k in compte.items()))
|
||||
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()))
|
||||
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))
|
||||
@@ -89,7 +131,7 @@ def contenu(dossier, f, debut=None, fin=None):
|
||||
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 ; aucun outil ne les lit) : {len(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", "*")))):
|
||||
@@ -100,20 +142,28 @@ def contenu(dossier, f, debut=None, fin=None):
|
||||
print(" Autres : " + ", ".join(f"{k} ({len(v)})" for k, v in sorted(autres.items())))
|
||||
|
||||
|
||||
def images(chemins):
|
||||
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)}")
|
||||
if heures:
|
||||
manquantes = []
|
||||
for a, b in zip(heures, heures[1:]):
|
||||
h = a + timedelta(hours=1)
|
||||
while h < b:
|
||||
manquantes.append(iso(h))
|
||||
h += timedelta(hours=1)
|
||||
print(f" heures pleines sans image entre la première et la dernière : {', '.join(manquantes) or 'aucune'}")
|
||||
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):
|
||||
@@ -132,6 +182,10 @@ def mesures(par):
|
||||
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, docs/domaine/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]
|
||||
@@ -161,7 +215,7 @@ def camera(dossier, par, debut=None, fin=None):
|
||||
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" {iso(a)}" + ("" if n == 1 else f" → {iso(b)} ({n})"))
|
||||
print(f" {suite(a, b, n)}")
|
||||
|
||||
|
||||
def fenetre(par, debut, fin):
|
||||
@@ -196,22 +250,27 @@ def fenetre(par, debut, fin):
|
||||
else:
|
||||
suites.append([t, t, 1])
|
||||
if rej:
|
||||
print(f" {s} ({len(rej)}) : " + "; ".join(iso(a) if a == b else f"{iso(a)} → {iso(b)} ({n})" for a, b, n in suites))
|
||||
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])]
|
||||
if not any(m["inlier"] is not None for s in refs for m in series[s].values()):
|
||||
print("Références retenues par la compensation : colonne inlier absente ou vide.")
|
||||
# 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 "0" if m["inlier"] == 0 else "vide"
|
||||
hors = [(t, tuple((s, marque(s, t)) for s in refs if t not in series[s] or series[s][t]["inlier"] != 1)) for t in dans]
|
||||
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)
|
||||
print(f"Références retenues par la compensation (inlier = 1) sur {len(refs)}, nombre d'instants : "
|
||||
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 ; "
|
||||
"r = rejetée, 0 = inlier 0, vide = inlier vide) :")
|
||||
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:
|
||||
@@ -219,7 +278,7 @@ def fenetre(par, debut, fin):
|
||||
elif h:
|
||||
suites.append([t, t, 1, h, i])
|
||||
for a, b, n, h, _ in suites:
|
||||
print(f" {iso(a) if n == 1 else f'{iso(a)} → {iso(b)} ({n})'} : {len(refs) - len(h)} retenues ; hors : "
|
||||
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)")
|
||||
@@ -230,7 +289,7 @@ def main(dossier, debut=None, fin=None, tout=False):
|
||||
f = trouver(dossier)
|
||||
fichiers(f, tout)
|
||||
contenu(dossier, f, debut, fin)
|
||||
images(f["images"])
|
||||
images(f["images"], debut, fin)
|
||||
par = charger(dossier)
|
||||
mesures(par)
|
||||
if par:
|
||||
|
||||
+123
-3
@@ -1,7 +1,7 @@
|
||||
"""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] [--debut ...] [--fin ...] [--sortie DOSSIER]
|
||||
[--nuit 20-3] [--k 5] [--jours 2] [--pas 15min] [--capteurs A,B] [--bornes] [--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 ;
|
||||
@@ -20,6 +20,20 @@ la nuit en cours au début de la fenêtre compte aussi (ses heures après minuit
|
||||
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. 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
|
||||
@@ -27,14 +41,14 @@ import math
|
||||
import os
|
||||
import statistics
|
||||
import sys
|
||||
from datetime import timedelta
|
||||
from datetime import datetime, timedelta, timezone
|
||||
|
||||
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 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 duree # noqa: E402
|
||||
|
||||
@@ -74,6 +88,7 @@ def main():
|
||||
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("--debut", type=instant)
|
||||
a.add_argument("--fin", type=instant)
|
||||
a.add_argument("--sortie", default=os.path.join(RACINE, "out", "diagnostic"), help="dossier des PNG")
|
||||
@@ -189,6 +204,111 @@ def main():
|
||||
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]}",
|
||||
{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}", {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}"
|
||||
print(f"\n== Bornes de chaque jour : écart au niveau de la nuit qui le précède ({h1} h → {h2} h UTC), seuil {o.k:g} bruits ==")
|
||||
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, 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
|
||||
print(f"\n{nom} : bruit {bruit:.3g}")
|
||||
enb = lambda e: f"{e:+.4g} ({e / bruit:+.1f})" if bruit else f"{e:+.4g}"
|
||||
for jour, d, ref, p, suiv in ecarts:
|
||||
if not p:
|
||||
print(f"{jour:%d/%m} aucune mesure" + ("" if nuits else " de nuit"))
|
||||
continue
|
||||
ligne = f"{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])} | "
|
||||
hors = [i for i, (_, e) in enumerate(p) if bruit and abs(e) > o.k * bruit]
|
||||
if hors:
|
||||
i, j = hors[0], hors[-1]
|
||||
ligne += (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 > {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 bruit and signe * p[x][1] > o.k * bruit:
|
||||
i = j = x
|
||||
while i > 0 and signe * p[i - 1][1] > o.k * bruit:
|
||||
i -= 1
|
||||
while j + 1 < len(p) and signe * p[j + 1][1] > o.k * bruit:
|
||||
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)
|
||||
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:
|
||||
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 de {o.k:g} bruits, foncé : la suite autour de l'extrême ; points : max et min du jour")
|
||||
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()
|
||||
@@ -0,0 +1,264 @@
|
||||
"""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 <contre>_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()
|
||||
+62
-12
@@ -1,7 +1,8 @@
|
||||
"""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] [--capteurs A,B] [--debut ...] [--fin ...]
|
||||
[--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
|
||||
@@ -17,15 +18,38 @@ long fausse la médiane) et à son bruit propre (médiane des écarts entre deux
|
||||
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, 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)
|
||||
@@ -35,6 +59,9 @@ def main():
|
||||
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)
|
||||
@@ -55,6 +82,8 @@ def main():
|
||||
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 ==")
|
||||
@@ -80,27 +109,48 @@ def main():
|
||||
+ (f" (rejetée : {', '.join(marque)})" if marque else ""))
|
||||
if not bruit:
|
||||
continue
|
||||
groupe = []
|
||||
for t, v in ms + [(None, 0)]:
|
||||
if t is not None and abs(v - niv) > o.k * bruit:
|
||||
if groupe and (t - groupe[-1][0] > o.fusion or (v > niv) != (groupe[-1][1] > niv)): # même sens seul
|
||||
plages.append((s, groupe, niv, bruit, rej))
|
||||
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))
|
||||
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, niv, bruit, rej))
|
||||
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{' (niveau hors ' + o.hors + ')' if hors else ''} (fusion {int(o.fusion.total_seconds() // 60)} min)"
|
||||
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, niv, bruit, rej in plages:
|
||||
t, v = max(g, key=lambda x: abs(x[1] - niv))
|
||||
print(f"{s:9}{iso(g[0][0]):<18}{iso(g[-1][0]):<18}{len(g):8}{v - niv:+10.4g}{(v - niv) / bruit:9.1f} {iso(t):<17}"
|
||||
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()
|
||||
+16
-4
@@ -2,13 +2,17 @@
|
||||
|
||||
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).
|
||||
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.
|
||||
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
|
||||
@@ -45,6 +49,8 @@ def main():
|
||||
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()
|
||||
@@ -80,14 +86,20 @@ def main():
|
||||
|
||||
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")
|
||||
print(f"{'début':17} " + " ".join(f"{s:>9}" for s in noms))
|
||||
for k in sorted(cases):
|
||||
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:
|
||||
cellules.append(f"{STATS[o.stat](v):9.5g}")
|
||||
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))
|
||||
|
||||
+70
-12
@@ -14,7 +14,14 @@ pic imprimés pour chaque vignette). Un --rayon plus petit (30 à 50) grossit. L
|
||||
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.
|
||||
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
|
||||
@@ -41,17 +48,21 @@ 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", required=True, help="liste séparée par des virgules")
|
||||
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 = o.capteurs.split(","), [instant(h) for h in o.heures.split(",")]
|
||||
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))}.")
|
||||
@@ -63,22 +74,47 @@ def main():
|
||||
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 = min((m for m in par[s] if m["x"] is not None), key=lambda m: abs(m["t"] - proche[h]))
|
||||
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 = c[..., :3].mean(axis=-1) if c.ndim == 3 else c
|
||||
gris = gris * 255 if gris.max() <= 1 and c.dtype.kind == "f" else gris
|
||||
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"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":
|
||||
@@ -86,14 +122,34 @@ def main():
|
||||
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)")
|
||||
fig, axes = plt.subplots(len(noms), len(heures), figsize=(2.6 * len(heures), 2.8 * len(noms)), squeeze=False)
|
||||
# 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[i, j]
|
||||
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"{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)
|
||||
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)
|
||||
@@ -101,10 +157,12 @@ def main():
|
||||
ax.set_xticks([])
|
||||
ax.set_yticks([])
|
||||
station = os.path.basename(os.path.normpath(o.dossier))
|
||||
fig.suptitle(f"{station} : vignettes de {2 * r} px autour de chaque capteur (heures UTC)", fontsize=10)
|
||||
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)
|
||||
sortie = os.path.join(o.sortie, f"{station}_vignettes_{'-'.join(noms)}_"
|
||||
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)
|
||||
|
||||
Reference in new issue
Block a user