nouvelle planification

This commit is contained in:
maxime committed 2026-10-23 21:52:08 +02:00
1 parent 8d9b927600
commit 23f01d7c23
23 files changed
+1897 -11

No files matched your search

+2
View File
@@ -18,6 +18,8 @@ Le code et les maquettes du chantier vivent dans `maquette/` (D-053, D-054) : `e
Détection mécanique des anomalies (D-055) : faire ressortir les courbes qui comptent, sans toucher aux données : les sauts (décalage soudain qui dure) et les tendances (hausse ou baisse lente), ce que regarde le client ; onglet `Displacements` de la maquette ; idée, méthode, résultats et pistes dans `contexte/detection-d-anomalies.md`, savoir métier dans `docs/displacement/domaine/ce-que-regarde-le-client.md`.
Journal du matin du client (D-056), le cap actuel : onglet `Journal` de la maquette ; un détecteur élémentaire par fichier dans `journal/` (`detect(mesures)` -> épisodes `start`, `end`, `kind`, `label`, `text`, `ignore`, `sensors`), chargés seuls par `explore.py` ; brainstorming et pistes dans `contexte/journal-du-matin.md`, lissage dans `contexte/lissage.md`, données en masse et boucle Claude dans `contexte/donnees-et-boucle.md`.
## Règles
- Les données restent seules dans `<STATION>/` : les outils de l'agent lisent tout le dossier qu'on leur donne, et une capture PNG y passerait pour une image de la caméra. Le verdict de l'utilisateur, dans `parcours.md`, reste hors de la vue de l'agent.
@@ -0,0 +1,58 @@
# Données en masse et boucle Claude : ce qui existe et ce qu'on recommande
Étude du 2026-10-23, en lecture seule dans `~/monitoring-dashboard-displacement` (branche `displacement`, doc dans `CLAUDE.md` et `docs/diagnostics/`). Rien lancé, aucun secret lu ; les variables d'environnement ne sont citées que par leur nom.
## Recommandation
**Option A, avec un seul script** (`extraction/pomper.py`, brouillon, jamais lancé) : il réutilise les lectures de l'appli, ouvre un moteur PostgreSQL **en lecture seule** (comme `scripts/domain_diagnostics.py`, déjà lancé avec succès dans le container le 2026-10-21) et écrit `data/<STATION>/displacement/…_advanced_….csv` et `data/<STATION>/images/…jpg`, les formats que `agents/diagnostic/outils/donnees.py` (`trouver`, `heure_image`) lit déjà. B n'est pas une autre solution : c'est ce même script lancé depuis WSL, si la base y est joignable (non vérifié). C (une route d'export) vient seulement si la boucle prouve sa valeur.
## Ce que j'ai trouvé
**D'où viennent les données**
- Une base PostgreSQL/TimescaleDB, partagée avec la production, pour les mesures ; les images sont dans un stockage S3 (Garage), rangées par `measurement_uuid` (`docs/architecture.md:14,25`, `docs/database/read_paths.md:17`). SQLite (`configs/database.db`) ne porte que l'appli : appareils, sorties, utilisateurs.
- Déplacements natifs : `AcquisitionUnit.get_datapoints` (`app/aimsight_database.py:1096`) fusionné aux états à 1 min par `build_advanced_frame` (`app/datapoints.py:285`). Ses colonnes (`app/datapoints.py:35`) sont celles de l'export « advanced » reçu à la main : c'est la même fonction (endpoint parquet, `app/api/v1/datapoints.py:47`). Volume : ~0,3 Mo par jour et par station (NORDEND : 8 339 lignes pour 5 jours).
- Horaire (« 1hour ») : `fetch_and_process_shifts` (`Dashboard/Dash_fun.py:1069`), qui exige les sorties configurées de l'appareil, donc SQLite et le contexte Flask. Le script ne le fait pas : l'horaire se recalcule depuis l'advanced.
- Images : `Measurement` de type `OPTICAL_SHIFT-IRON` (JPEG), via `acq_unit.measurements` (`app/aimsight_database.py:901`) puis `get_measurement_payload(uuid)` (`:2346`, S3). L'id de mesure est celui que contiennent déjà nos noms `20261013T1200Z_<id>.jpg`. Poids vus dans `data/` : 0,1 à 1,2 Mo l'image selon la station.
- **Images différentielles : elles existent**, type `OPTICAL_SHIFT-DIFF` (`app/mqtt/receiver.py:916`, `app/api/v1/images.py:307`, `Dashboard/PatternCreation.py:46`), en PNG (`app/base/routes.py:465`). Mais seules les stations réglées en mode « Differential » en ont ; je n'ai pas pu vérifier lesquelles, ni leur cadence. Le script les prend avec `--diff`, rangées à part dans `images_diff/`.
**Lectures déjà prêtes à réutiliser, et leur piège**
- `Dashboard/displacement_data.py` (`hourly`, `advanced`, `images`, lignes 22 à 64) fait exactement notre besoin, mais passe par `Device.query` (SQLite, Flask-SQLAlchemy) et `AIMsightDB_get_session()`.
- `AIMsightDB_get_session()` (`app/extensions.py:94`) construit `DatabaseEngine`, dont l'`__init__` lance `create_all_tables` (DDL) et un écouteur NOTIFY, sur une connexion **en écriture** sans délai (`app/aimsight_database.py:1636,1644`). Le `CLAUDE.md` de l'appli l'interdit pour lire. Le script contourne : un petit `ReadOnlyDB` emprunte à `DatabaseEngine` ses trois méthodes de lecture (`get_sensor_state_aggregate`, `get_common_state_aggregate`, `get_measurement_payload`) sans l'instancier.
- Il lit par numéro de série du **système** (`System.serial_number`, comme `domain_diagnostics.py`), pas par nom d'appareil (les noms de fichiers reçus portent le nom d'appareil, ex. « Carrière TROYDO (B) »). Les dossiers de `data/` suivent déjà le numéro de série.
**Authentification**
- L'appli a deux modes selon `AUTH_MODE` (`app/base/auth/__init__.py:10-16`) : formulaire login/mot de passe (Flask, session) ou Auth0. Elle ne protège que les **routes HTTP**. La base et S3 sont atteintes avec un compte de service lu dans les variables `AIMSIGHT_DATABASE_*` et `AIMSIGHT_S3_*` : pas d'authentification par utilisateur côté base. « La même authentification que l'appli » veut donc dire soit ce compte de service (le script), soit passer par HTTP.
- HTTP : `requires_auth` (`app/base/auth/common.py:32`) n'accepte qu'un cookie de session, ce que demande aussi la route parquet. Seul `can_explore_device` passe par `is_authenticated()`, qui en mode Auth0 accepte un jeton Bearer (`auth_auth0.py:47-51,309`) ; une portée `reads:explore` y donne les droits de lecture admin (`:54-62`). Qui délivre un tel jeton, je ne le sais pas : question au collègue.
- Les routes d'images de l'API `/api/v1` répondent 500 aujourd'hui (note dans `Dashboard/displacement_data.py:76-79`, décorateur de `common.py:53`) ; l'export CSV (`app/api/v1/measurements.py:273`) lance une tâche Celery, donc exige un worker local.
## Options
| | Effort | Blocage | Verdict |
|---|---|---|---|
| **A** script dans le container | brouillon écrit, ~1 h d'essai | le container ne monte sans doute que le dépôt de l'appli (compose non lisible, non vérifié) : copier le dossier dedans, puis les fichiers dehors (2 `cp`) ; charge sur la base de production | à faire |
| **B** depuis WSL | A + `pip install` (sqlalchemy, psycopg2, boto3, pandas) + les identifiants de l'appli copiés sur WSL | la base est-elle joignable hors container ? Les docs disent que tout passe par le container (`docs/diagnostics/index.md:102`) ; en HTTP, il faudrait un cookie de session ou un jeton, à fournir ; secrets sur une seconde machine | seulement si le test réseau passe |
| **C** route d'export | quelques jours de l'autre côté : auth par jeton sur `requires_auth`, correctif du décorateur, route d'images par plage (le zip en masse, `measurements.py:162`, n'existe que par jeton Redis posé par le Dash) | dépend d'un tiers et de la règle « ajouter, ne pas modifier » de la branche | après A, si la boucle sert |
Taille : l'advanced se compte en Mo. Les images dominent : à l'heure, ~1 Go pour 40 jours d'une station à 1 Mo l'image, six fois plus à 10 min. Quelques centaines de Go suffisent donc largement ; la limite sera le temps de lecture de la base, pas le disque.
**Précautions de l'appli à respecter** (`CLAUDE.md` de l'appli) : requêtes bornées en temps (le script lit un jour à la fois, 60 s de délai, pause entre les jours), lecture seule, rien qui écrive ; l'utilisateur lance, Claude ne se connecte jamais. Premier essai : une station, 2 jours, on note le temps par jour ; les vieux chunks compressés de `datapoint` coûtent plus cher à lire, et la base est partagée avec l'ingestion : lancer hors des heures chargées.
## La boucle, étape par étape
Hors ligne, dans Support-Agent, à la main de l'utilisateur (pas de LLM à chaque chargement de page, `journal-du-matin.md`).
1. **Liste** : l'utilisateur donne les stations et la plage totale (par exemple 3 stations, 60 jours) ; un fichier `extraction/plan.md` les range en tranches de 3 à 5 jours. Coût : zéro.
2. **Pompe** (utilisateur, dans le container) : `pomper.py` par lots ; copie dans `data/<STATION>/`. Pas de coût Claude ; reprenable.
3. **Tri sans image** : les détecteurs de `vues-deplacements/journal/` tournent sur la tranche et sortent une table d'épisodes (début, fin, étiquette, capteurs). Coût : ordinateur seul, et c'est ce qui décide la suite.
4. **Regard de Claude, choisi** : Claude ne regarde que les tranches où les détecteurs voient quelque chose ou **ne voient rien malgré un signal fort** (saut ou tendance de `detection-d-anomalies.md`), et seulement les courbes et 4 à 8 vignettes par épisode, pas toutes les images. C'est l'étape chère : un plafond de tranches regardées par séance, fixé à l'avance.
5. **Critique** : par épisode, Claude dit s'il est d'accord (étiquette juste), en retard ou en trop (faux positif), ou s'il manque un épisode ; il écrit son verdict dans un fichier de revue de la tranche, hors de la vue de l'agent (règle de `vues-deplacements/CLAUDE.md`).
6. **Proposition** : au plus deux sorties, soit un réglage chiffré d'un détecteur (seuil, durée) avec les épisodes qui changent, soit un cas candidat. Les cas n'entrent dans la base que sur demande de l'utilisateur (`/nouveau-cas`) ; Claude propose, ne crée pas.
7. **Rejeu** : le détecteur modifié est relancé sur **toutes** les tranches déjà vues (gratuit, étape 3) pour vérifier qu'il ne casse rien ; seulement alors on passe à la tranche suivante.
8. **Arrêt** : à la fin du plafond de la séance, ou quand deux tranches de suite ne donnent plus rien à corriger. Les données déjà regardées ne sont pas relues ; le fichier de revue sert de mémoire.
## Ce qui reste à vérifier avant de s'y fier
- Le script n'a jamais tourné : écrit d'après le code, relu, syntaxe vérifiée. Premier lancement par l'utilisateur, une station, 2 jours ; ce qu'il faut comparer : le CSV obtenu contre un export « advanced » déjà reçu pour la même plage (colonnes, fuseau UTC, nombre de lignes).
- Le numéro de série du système sert d'entrée ; si l'unité d'acquisition n'est pas unique (`acquisition_unit()` du script reprend la règle MER* / ME2S* de `app/base/models.py:268`), le dire.
- Combien de stations ont des images `DIFF`, et à quelle cadence.
- Joignabilité de la base depuis WSL (un test `nc -z` fait par l'utilisateur, hôte lu dans `.env` sans l'afficher).
@@ -0,0 +1,70 @@
# Journal du matin du client : brainstorming du 2026-10-23
Notes de la conversation vocale du 2026-10-23 (utilisateur, après échange avec son supérieur), tenues par l'orchestrateur. Les idées sont gardées toutes, même celles qu'on ne fait pas tout de suite ; ce qui est lancé est marqué **[en cours]**. Décision : D-056.
## Le constat
- Le projet s'est éparpillé : beaucoup d'analyses fines (sauts, tendances, compensation, agent de diagnostic) ; important, mais on s'y perd.
- Revenir à du simple, terre à terre, côté **support** : des analyses élémentaires, qui **discréditent** certaines zones plutôt qu'elles ne mesurent des variations.
- Changement de regard sur l'anomalie : ce n'est pas d'abord un vrai déplacement de l'ouvrage, ce sont surtout des « trucs nuls » : un train qui passe, de la neige ou une toile d'araignée sur une cible, la pluie, la buée, le soleil, la turbulence, plus assez de références (alors tout bouge un peu). **Une anomalie = un moment où il ne faut pas prendre les données en compte.**
## L'idée : le journal du matin
- Le client se lève, ouvre le monitoring comme on lit le journal : le récapitulatif de ce qui s'est passé depuis sa dernière visite.
- Une plage de quelques jours par défaut (celle qu'il regarde : s'il vient tous les 2-3 jours, 2-3 jours).
- Les courbes de déplacement, **toutes les données gardées** ; dessous, des **barres étiquetées** (une bande colorée : « mauvaise météo », « mauvaise visibilité », « effet thermique », la catégorie trouvée) ; les zones à ignorer **grisées** sur les courbes, sans retirer les points.
- Deux familles de ce qui peut se passer : des conditions qui gâtent la mesure (météo, visibilité, turbulence, cycle thermique) et, plus rarement, un vrai mouvement.
- Courbes en **pixels** (suggestion du supérieur) plutôt qu'en mm : on y voit les mêmes choses ; premier essai en px (`corr_x`, `corr_y` de l'export « advanced », à la cadence native).
- Une visualisation **très simple**, « bateau », comme les cas de la base (pluie, toile d'araignée, train…).
- Garder les **images** et la technique des petits **GIF** (vignettes animées) : on voit tout de suite qu'on a perdu les cibles. Pas dans la v0.
- Objectif de contrôle : si on donnait les mêmes données à Claude, il devrait voir de lui-même les mêmes catégories ; notre solution doit dire ce que Claude dirait.
## Les pistes, une par agent [en cours]
Un orchestrateur (la conversation principale) et un agent par piste, qui rapporte à l'orchestrateur ; l'orchestrateur en discute avec l'utilisateur. Contrat commun des détecteurs : un fichier par détecteur dans `vues-deplacements/journal/`, `detect(mesures)` rend des épisodes (`start`, `end`, `label`, `text`, `ignore`, `sensors`).
| Piste | Ce que l'utilisateur en dit | Où |
|---|---|---|
| Gros sauts brutaux | perte de visibilité, gros déplacements, puis retour à la normale juste après : un événement ; variation brutale sur une petite plage | `journal/sauts.py` |
| Taux d'erreur | entre 2 h et 3 h, d'un coup beaucoup de perturbations : un flag « grand taux d'erreur des cibles », moyenne sur les cibles | `journal/visibilite.py` |
| Cycle thermique | chaque jour de grosses vagues : tout chauffe, bouge un peu, puis refroidit à la tombée de la nuit, très prévisible ; vu seul ça paraît bizarre, vu chaque jour c'est normal | `journal/thermique.py` |
| Turbulence atmosphérique | des petites vagues, du bruit, à expliquer au client | `journal/turbulence.py` |
| Cartographie des cas | il n'y a pas 36 000 options : un diagramme (Mermaid) de tous les cas rencontrés, branchés (mauvais temps, train, obstruction…), à partir des catégories déjà dans le projet | `docs/displacement/domaine/carte-des-evenements.md` |
| Page | une page dans Explore : les courbes, les barres dessous, les zones grisées | onglet `Journal` de `vues-deplacements/maquette/` |
| Volet 2 : lissage | le premier volet ne touche pas aux données et les interprète ; un second les lisse ; peur que ce soit trop complexe : un agent dit ce qui existe et ce qui est possible | `vues-deplacements/contexte/lissage.md` |
| Données et boucle | récupérer les données pour travailler hors de l'application, puis boucler Claude dessus | `vues-deplacements/contexte/donnees-et-boucle.md` |
## Les données et la boucle d'amélioration
- Aujourd'hui, Claude ne voit pas l'application : elle tourne dans le dev container, que l'utilisateur doit relancer, et Claude ne peut pas y entrer.
- Pistes d'accès, aucune fermée :
- **A**, préférée pour l'instant : un dossier de scripts **dédié, séparé de tout le reste**, que l'utilisateur lance dans le dev container pour pomper les données de nombreuses stations sur de grandes plages (déplacements, images, images différentielles), par lots ; quelques centaines de Go acceptables ;
- **B** : un petit client qui interroge directement la base avec le même protocole d'authentification que l'application (identifiants de l'utilisateur), et un site HTML / JS local qui fait le même travail ; avantage : ne récupérer que le nécessaire ;
- **C** : demander au collègue l'infrastructure qui manque.
- La boucle, idée « super puissante » à faire intelligemment (elle consomme) : Claude prend une plage, lance les scripts de diagnostic, regarde lui-même les données et les images, critique les scripts, les améliore, crée un cas si besoin, passe à la plage suivante, et épluche ainsi toutes les données.
- Calcul à la volée : aujourd'hui, le site calcule les analyses quand le client charge la page ; faire tourner un LLM à ce moment-là n'est pas raisonnable. Claude sert donc à **régler** les scripts hors ligne, pas à répondre en direct.
## Où l'on travaille
- **Dans Support-Agent**, pas dans le dev container (précision de l'utilisateur en fin de message) : on y voit tout et on itère vite ; quand c'est convaincant, on le porte dans le vrai conteneur, comme pour les statuts des métriques système (Energy, Storage, Cellular, Temperature), où l'on savait déjà ce qu'on voulait.
## Façon de travailler
- Prototypes : ni tests, ni revues, ni qualité de code ; on développe, l'utilisateur essaie, il fait un retour, on itère.
- Consigne aux agents : pas d'imagination débordante, pas l'optimal ni le stylé ; quelque chose qui marche au départ, minimaliste au besoin, puis on améliore.
## Idées gardées pour plus tard
- Vignettes et GIF des images d'un épisode, dans le journal.
- Images différentielles (si la plateforme les a), pour voir ce qui a changé.
- D'autres métriques existent sur certains projets : un agent pourrait les passer en revue quand les données seront récupérées en masse.
- Effet périodique étiqueté comme tel (« periodic effect »), jugé encore poussé.
- Un cas de la base pour chaque catégorie de la carte, quand l'utilisateur les apporte.
## Retour de l'utilisateur sur la v0 (2026-10-23, le soir)
- « Pas trop mal », mais il veut **encore plus simple**, et surtout un diagnostic **catégorique et complet**, comme celui des cas étudiés par l'agent de diagnostic (`agents/diagnostic/cas/`) : pas de « most likely a measurement artefact » ni de « probably rain ».
- Exemple : sur NORDEND, le 14/10 vers 05:15, un immense saut monte puis redescend en quelques heures. Ce comportement se voit tout le temps ; il a plusieurs causes possibles, mais on veut clairement **invalider la zone**. Ici il n'y a pas d'ambiguïté : les cibles étaient perdues (intempéries, plein jour, aube…), et les images le montrent.
- **Cas par cas, isoler les scénarios** : un gros saut → trouver sa **catégorie** (celle de la carte des événements, d'où la demande d'un agent cartographe) → **exécuter le processus de la catégorie**. Pour la perte de visibilité, le processus est de **montrer les images** : le client voit le gros saut, lit la catégorie, voit qu'on ne distingue pas les cibles, comprend que ce n'est qu'une perte de visibilité et passe à la suite sans s'alarmer.
- Sous les courbes, le label dit **ce qui s'est passé** (la catégorie), pas le nom du détecteur.
- La suite : pas forcément de modification tout de suite, mais **un plan** très détaillé, numéroté et non linéaire, qui reprend tout le travail de la conversation et qu'il pourra exécuter point par point dans de nouvelles conversations : `docs/superpowers/plans/2026-10-23-journal-du-matin.md`.
+61
View File
@@ -0,0 +1,61 @@
# Lisser ou corriger les courbes de déplacement : ce qui existe, ce qui est possible
- **Date** : 2026-10-23. **Statut** : exploration, rien de construit. Second volet du « journal du matin » : le premier n'altère rien (barres étiquetées, zones grisées « à ignorer »), celui-ci ajoute une courbe lissée ou corrigée, **la brute toujours gardée**.
- Les chiffres ci-dessous viennent des exports horaires (mm) de WILDSTRUBEL, NIEDERHORN et CLARIDEN, 3 jours chacun : des ordres de grandeur, pas une validation.
## 1. Ce qui existe déjà
- **La station** moyenne 20 à 40 images par mesure et rejette toute mesure dont l'`error_value` dépasse le seuil du capteur (`corr_x` / `corr_y` vides, rien d'interpolé). La plateforme propose déjà de surligner, masquer, interpoler ou passer une médiane glissante (Data Exploration, cadrage §2).
- **L'export horaire** est la moyenne des mesures de l'heure (1 à 6 selon la station), avec `_min` et `_max`. Une moyenne n'est pas robuste : un train d'une mesure déplace l'heure entière.
- **Le cadrage D-044** (`docs/displacement/cadrage.md`) fixe déjà le cadre : brute jamais remplacée, chaque point corrigé porte son statut et sa raison (§3, §4.2), calcul causal, poids continus, correction seulement si la cause externe est `strongly supported`. Chaîne : qualifier, détecter, corriger ; outil du socle : le masque, puis une médiane glissante causale (§4.1) ; lisser sans détecter est écarté (§8).
- **L'annexe du cadrage** note Hampel, Kalman et le poids continu, à revoir « si le besoin apparaît ». Le contexte support interdit de fusionner en silence données d'origine et retraitées (§27).
- **Aucun code** : rien dans `src/`. Le volet 1 du journal fournira les zones « ignore », donc une partie de l'étape « détecter » du cadrage.
## 2. Les options, de la plus simple à la plus riche
**A. Masquer les zones « ignore » du journal.**
- Principe : la courbe nettoyée est la brute sans les points des zones grisées, laissés en **trou** (pas d'interpolation, sinon on cache une marche). Aucun calcul nouveau.
- Enlève : tout ce que le volet 1 grise (train, mauvaise visibilité, turbulence, pluie), avec sa raison déjà étiquetée.
- Risque : une zone mal posée masque un vrai mouvement (CLARIDEN, mouvement réel qui débute la nuit : un volet 1 qui le rangerait en « mauvaise visibilité » le masquerait). La marche reste visible entre les deux bords du trou.
- Coût : nul, bibliothèque standard, embarquable. La fiabilité est celle du volet 1.
**B. Médiane glissante causale (ou filtre de Hampel : un point à plus de k MAD de la médiane locale est remplacé par elle).**
- Enlève : les pics courts. NIEDERHORN, train du 01/10 12:00 UTC : une heure à 14,83 mm sur un niveau de 9,9 ; médiane de 3 h : 9,95. Ne gomme pas un épisode plus long que la moitié de la fenêtre (pluie, turbulence de l'après-midi).
- Risque : une marche réelle est **gardée en entier mais en retard** de (fenêtre − 1) / 2 heures. CLARIDEN, −4,9 mm en deux paliers : retard de 1 h (3 h) ou 2 h (5 h), amplitude intacte ; une moyenne de 5 h étale la marche sur 6 h. Un vrai choc d'une heure disparaît.
- Sur WILDSTRUBEL, aucun gain : le bruit d'heure en heure est déjà de 0,03 à 0,12 mm pour un cycle de 0,3 à 0,75 mm, et la médiane de 5 h ne le change pas. La turbulence se voit à la mesure, pas à l'heure.
- Coût : une dizaine de lignes, bibliothèque standard, embarquable, causale. Fenêtre à sourcer (cadrage §6, étape 3). `_min` / `_max` ne voient pas le train de NIEDERHORN : inutilisables pour le détecter.
**C. Moyenne pondérée par `error_value`.**
- Principe : chaque mesure pèse selon son erreur, au lieu de tout ou rien (roadmap §5.2, `image_quality_weight`, qui ne donne pas de formule).
- Enlève : le bruit des mesures sous le seuil de rejet (eau, turbulence légère).
- Risque : à CLARIDEN, l'`error` de la cible qui saute triple (0,02 puis 0,06) **à la marche réelle** : la pondération rend la marche moins crédible au moment où elle naît. La fonction de poids n'a pas de source.
- Coût : demande l'export « advanced » à cadence native (l'horaire ne donne que l'erreur moyenne), plus une fonction de poids à justifier.
**D. Retrait du profil journalier (vague thermique).**
- Principe : soustraire le profil moyen heure par heure des jours précédents.
- Enlève : le cycle du jour, donc ce qui ressemble à un mouvement et n'en est pas un pour le client.
- Risque : trop court, il aggrave. WILDSTRUBEL, profil des jours 1-2 retiré du jour 3 : crête à crête 0,46 puis 0,67 mm (PA3_2), le profil variant de 0,13 à 0,21 mm d'un jour à l'autre pour un cycle de 0,3 à 0,75 mm. La dilatation thermique est aussi un mouvement réel (cadrage Q8), et une dérive apprise dans le profil s'efface.
- Coût : simple à coder, mais il faut des semaines d'historique ; inutilisable sur une station neuve.
**E. Filtre de Kalman ou lissage centré a posteriori, avec bande d'incertitude.**
- Principe : modèle d'état de la position, bande autour de la courbe ; ou fenêtre centrée sur le journal de la veille, sans retard.
- Enlève : bruit, pics et trous, avec une incertitude affichée. Aucun chiffre ici, aucun cas de test à ce jour.
- Risque : réglage (bruit du modèle) sans source, difficile à expliquer au client ; un modèle trop souple absorbe une marche.
- Coût : le plus lourd ; l'annexe du cadrage le réserve au jour où l'incertitude par cible existe (roadmap §5.5).
## 3. Recommandation : la première marche
**Option A seule.** Rien à régler, rien d'inventé, chaque trou porte l'étiquette du volet 1, aucun risque d'effacer un mouvement tant que les zones sont justes. Si le client veut ensuite une courbe plus lisse, **B avec une fenêtre de 3 h** (étape 3 du cadrage), qu'on mesure sur NIEDERHORN et CLARIDEN avant de la montrer. C, D et E attendent un besoin visible.
**Affichage** (chaque graphique de cible) :
- la **brute** en gris fin, toujours dessous et visible ;
- la **nettoyée** en couleur par-dessus, en trait **interrompu aux trous** ;
- les zones grisées du volet 1 derrière, avec leur étiquette au survol ;
- un sélecteur « Brute / Nettoyée / Les deux », « Les deux » par défaut, et une ligne de légende : « zones à ignorer retirées, rien d'autre modifié » ;
- avec B ensuite : une troisième courbe nommée « Lissée (médiane 3 h) », jamais confondue avec la nettoyée.
## 4. Questions pour l'utilisateur
1. Le client voit-il la nettoyée par défaut avec la brute en option, ou l'inverse ? Elle ne remplace jamais la brute à l'écran (cadrage Q4).
2. Le journal paraît une fois le matin : un lissage **centré** (côté serveur, sans retard) vous convient-il, ou garde-t-on le calcul **causal** des analyses, avec 1 à 2 h de retard (cadrage Q5) ?
3. Le cycle thermique du jour reste-t-il tel quel (choix par défaut, cadrage Q8), ou faut-il une vue « sans le cycle » ? Seule cette réponse justifie l'option D.
+117
View File
@@ -0,0 +1,117 @@
"""Sauts brutaux du journal du matin : corr_x / corr_y (px) de chaque cible, cadence native de l'export « advanced ».
1. Bruit de la série = médiane des écarts d'une mesure à la suivante ; saut = mesure à K bruits ou plus du niveau
d'avant (médiane des BASE mesures précédentes).
2. Revenu (BASE mesures de suite à moins de la moitié du saut) en moins d'un jour, ou un jour après de retour à sa place
habituelle (premier jour de l'export) ou du jour d'avant : « Sudden jump, back to normal », grisé (artefact).
3. Sinon « Lasting shift », jamais grisé (peut-être un vrai mouvement) ; moins d'un jour de recul :
« Jump, not back yet », pas grisé non plus.
4. Les sauts qui se suivent à moins d'une heure, toutes cibles confondues, font un seul épisode (mode commun) ;
une seule cible durable (ou trop récente) suffit à ne pas griser l'épisode.
5. Références globales exclues ; mesures rejetées (corr vides) sautées.
Résultats (2026-10-23, K = 20) :
- C-001 PS des Coudres : rien (vérité : rien côté sauts).
- C-002 NORDEND juillet : grisés 28/07 21:00 → 29/07 10:45 (18 cibles) et 30/07 13:30 → 31/07 01:15 (18) ; toile revenue
31/07 20:30 : « not back yet » (13 cibles, 1 h avant la fin des données).
- C-003 WILDSTRUBEL : un saut d'un pas grisé, 04/09 06:45 (le C2 de la fiche) ; les autres sont sur des références
ou rejetés.
- C-004 CLARIDEN : « Lasting shift » 19/09 06:10, 18 cibles, non grisé ; faux positif probable : une cible agitée seule,
18/09 15:40, non grisé ; la dérive de nuit de corr_x (lente) n'est pas un saut.
- C-005 NIEDERHORN : train du 01/10 12:00 grisé (1 cible sur 3 : les deux autres à 17 et 19 bruits) ; train du
30/09 22:00 manqué (première mesure) ; feuilles, pluie : rien (error_value, pas des sauts).
- NORDEND octobre : PR17 seule en « Lasting shift » le 08/10 02:30 ; cinq épisodes communs grisés (07/10 19:45,
08/10 07:15, 09/10 08:45 et 21:15, 14/10 05:15 : 4 à 15 cibles, aller-retour en moins de 5 h) ; PR15 08/10 04:45,
un instant grisé.
"""
import statistics
import sys
from datetime import timedelta
from pathlib import Path
sys.path.insert(0, str(Path(__file__).resolve().parents[2] / "agents" / "diagnostic" / "outils"))
import donnees # noqa: E402
K = 20 # provisoire, réglé sur C-001 : à 15, deux cibles saines y sont grisées (17 et 18 bruits)
BASE = 4 # mesures qui font le niveau d'avant (1 h à 15 min)
GAP = timedelta(hours=1) # deux sauts à moins d'une heure, toutes cibles confondues : un seul épisode
BACK_H = 24 # provisoire : retour en moins d'un jour = artefact (C-002 : paliers jusqu'à 11 h 30)
def _sauts(t, v):
"""Une série (instants, valeurs) -> [(i début, i fin, état)], état 'back', 'lasting' ou 'recent'."""
day = timedelta(hours=BACK_H)
noise = statistics.median(abs(y - x) for x, y in zip(v, v[1:]))
# ponytail: place habituelle = premier jour de l'export, faux s'il commence dans un artefact
ref = statistics.median(x for x, u in zip(v, t) if u < t[0] + day)
out, i = [], BASE # ponytail: les BASE premières mesures ne sont pas testées (train du 30/09 22:00 manqué)
while noise and i < len(v):
base = statistics.median(v[i - BASE:i])
if abs(v[i] - base) < K * noise:
i += 1
continue
tol = abs(v[i] - base) / 2 # revenu : BASE mesures de suite à moins de la moitié du saut du niveau d'avant
j = next((k for k in range(i + 1, len(v)) if all(abs(x - base) < tol for x in v[k:k + BASE])), len(v))
before = statistics.median([x for x, u in zip(v, t) if t[i] - day <= u < t[i]] or [base])
after = statistics.median(x for x, u in zip(v, t) if t[i] <= u < t[i] + day)
if j < len(v) and t[j] - t[i] <= day:
state = "back"
elif abs(after - ref) < tol or abs(after - before) < tol: # le jour d'après, la cible est à sa place
state, j = "back", i + 1 # habituelle, ou là où elle était le jour d'avant : le saut finissait un creux
else:
state = "lasting" if t[-1] - t[i] >= day else "recent" # moins d'un jour de recul : on ne sait pas encore
out.append((i, j - 1, state))
i = j + BASE # niveau d'avant refait après le retour
return out
def detect(mesures):
"""{capteur: [mesure]} (donnees.charger) -> épisodes du journal, triés par début."""
found = [] # (début, fin, état, capteur)
for name, ms in mesures.items():
if donnees.est_reference(ms):
continue
for axe in ("corr_x", "corr_y"):
kept = [m for m in ms if m[axe] is not None]
if len(kept) <= BASE:
continue
t, v = [m["t"] for m in kept], [m[axe] for m in kept]
# un saut qui n'est pas revenu finit avec lui-même, pas avec les données (sa barre cachait les autres)
found += [(t[a], t[b] if state == "back" else t[a], state, name) for a, b, state in _sauts(t, v)]
groups = [] # un saut qui n'est pas revenu ne compte que par son instant : sa fin est souvent celle des données
for s, e, state, name in sorted(found):
if groups and s <= groups[-1]["until"] + GAP:
g = groups[-1]
else:
g = {"start": s, "end": e, "until": s, "sensors": {}}
groups.append(g)
g["end"], g["until"] = max(g["end"], e), max(g["until"], e if state == "back" else s)
g["sensors"].setdefault(name, set()).add(state)
return [_episode(g) for g in groups]
def _episode(g):
"""Un groupe -> épisode du journal ; un seul saut durable (ou trop récent) suffit à ne pas griser."""
n = len(g["sensors"])
lasting = sum("lasting" in st for st in g["sensors"].values())
recent = any("recent" in st for st in g["sensors"].values())
who = "One target" if n == 1 else f"{n} targets together (a single event)"
if lasting:
label = "Lasting shift"
some = "" if lasting == n else f", {lasting} of them stayed shifted for more than a day"
text = (f"{who} jumped{some}" if some else f"{who} jumped and stayed shifted for more than a day") + \
": this may be a real movement, please check it."
elif recent:
label = "Jump, not back yet"
text = f"{who} jumped less than a day before the last measurement and has not come back yet: check again later."
else:
label = "Sudden jump, back to normal"
text = f"{who} jumped and came back within a day: most likely a measurement artefact, not a movement."
return {"start": donnees.iso(g["start"]), "end": donnees.iso(g["end"]), "kind": "sauts", "label": label,
"text": text, "ignore": not lasting and not recent, "sensors": sorted(g["sensors"])}
if __name__ == "__main__":
for ep in detect(donnees.charger(sys.argv[1])):
print(ep["start"], ep["end"], "ignore" if ep["ignore"] else "KEEP ", ep["label"], "|", len(ep["sensors"]),
",".join(ep["sensors"][:6]), "|", ep["text"])
+128
View File
@@ -0,0 +1,128 @@
"""Journal du matin : cycle thermique jour / nuit (la vague quotidienne des déplacements corrigés).
Méthode, par cible (hors références globales) et par axe (corr_x, corr_y) :
1. Chaque jour UTC d'au moins 20 h : moyenne de chaque heure moins la médiane du jour (enlève sauts et dérive).
2. Profil = médiane, heure par heure, sur les jours ; « répétabilité » = médiane, sur les jours, de la corrélation
entre le jour et le profil des autres jours. Axe concerné si répétabilité ≥ 0,6.
3. Cycle de la station si au moins la moitié des cibles ont un axe concerné.
4. Heures chaudes : niveau de nuit = médiane des 8 heures consécutives les plus plates du profil ; une heure est
chaude si, en médiane sur les axes concernés, le profil s'en écarte d'au moins 0,3 fois son amplitude.
5. Un épisode par jour complet, de la première à la dernière heure chaude, si ce jour ressemble aux autres
(corrélation médiane ≥ 0,5 sur les axes concernés).
Résultats (2026-10-23 ; « cibles » = part des cibles concernées, amplitude = médiane max − min du profil, en px) :
| Jeu | corr (ce que voit le client) | x, y bruts |
|---|---|---|
| PS_DES_COUDRES | 11/11 cibles, 0,17 px, 08-17 h, 5 épisodes | 12/12, 0,55 px, 08-16 h |
| NORDEND (juillet, C-002) | 2/18, rien | 18/19, 1,8 px, 06-18 h |
| WILDSTRUBEL (C-003) | 3/7, rien | 6/7, 3,2 px, 04-08 h |
| CLARIDEN (C-004) | 1/24, rien | 1/24, aucun cycle |
| NIEDERHORN (C-005, horaire) | 3/11, rien | 19/30, 4,6 px, ~12 h |
| cas 2026-10_NORDEND (11 j) | 9/19, 0,02 px, 08-17 h, sous le seuil (PART = 0,4 : 8 épisodes, sans 08 ni 09/10) | 17/19, 0,78 px, 09-17 h |
Lecture : le cycle est presque partout dans les positions brutes (mode commun) et la compensation l'enlève,
sauf à PS des Coudres où il reste dans corr, de même forme que dans les positions brutes.
"""
import os
import statistics
import sys
from datetime import datetime, timedelta, timezone
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..", "agents", "diagnostic", "outils"))
from donnees import charger, iso # noqa: E402
HEURES_MIN = 20 # provisoire : un jour UTC compte s'il a au moins 20 heures mesurées
REPRO = 0.6 # provisoire : un axe a un cycle si chaque jour ressemble aux autres (bruit pur ≈ 0)
PART = 0.5 # provisoire : part des cibles concernées ; 2026-10_NORDEND est juste dessous (9/19)
CHAUD = 0.3 # provisoire : écart au niveau de nuit, en part de l'amplitude du profil
JOUR = 0.5 # provisoire : ressemblance d'un jour aux autres pour lui donner son épisode
NUIT = 8 # heures consécutives du profil les plus plates = niveau de nuit
def _corr(a, b):
ma, mb = statistics.mean(a), statistics.mean(b)
num = sum((x - ma) * (y - mb) for x, y in zip(a, b))
den = (sum((x - ma) ** 2 for x in a) * sum((y - mb) ** 2 for y in b)) ** 0.5
return num / den if den else 0.0
def _axe(ms, col):
"""-> (profil sur 24 h, {jour: corrélation au profil des autres jours}) ou None."""
jours = {}
for m in ms:
if m[col] is not None:
jours.setdefault(m["t"].date(), {}).setdefault(m["t"].hour, []).append(m[col])
J = {}
for d, hs in jours.items():
if len(hs) >= HEURES_MIN:
med = statistics.median(v for l in hs.values() for v in l)
J[d] = {h: statistics.mean(l) - med for h, l in hs.items()}
if len(J) < 2:
return None
profil = [statistics.median(q[h] for q in J.values() if h in q) for h in range(24) if any(h in q for q in J.values())]
if len(profil) < 24:
return None
ressemblance = {}
for d, p in J.items():
autres = [q for e, q in J.items() if e != d]
hs = [h for h in p if all(h in q for q in autres)]
ressemblance[d] = _corr([p[h] for h in hs], [statistics.median(q[h] for q in autres) for h in hs])
return profil, ressemblance
def cycle(mesures, cols=("corr_x", "corr_y")):
"""-> (axes concernés [(capteur, col, profil, ressemblance)], nombre de cibles évaluées)."""
concernes, cibles = [], set()
for s, ms in mesures.items():
if ms[0]["pattern_type"] == "global_ref":
continue
for col in cols:
r = _axe(ms, col)
if r is None:
continue
cibles.add(s)
if statistics.median(r[1].values()) >= REPRO:
concernes.append((s, col) + r)
return concernes, len(cibles)
def heures_chaudes(concernes):
def score(p, h):
debut = min(range(24), key=lambda i: max(p[(i + k) % 24] for k in range(NUIT)) - min(p[(i + k) % 24] for k in range(NUIT)))
nuit = statistics.median(p[(debut + k) % 24] for k in range(NUIT))
return abs(p[h] - nuit) / (max(p) - min(p))
return [h for h in range(24) if statistics.median(score(c[2], h) for c in concernes) >= CHAUD]
def detect(mesures):
concernes, n = cycle(mesures)
capteurs = sorted({c[0] for c in concernes})
if not n or len(capteurs) < PART * n:
return []
chaudes = heures_chaudes(concernes)
if not chaudes:
return []
jours = sorted({d for c in concernes for d in c[3]})
episodes = []
for d in jours: # ponytail: jours complets seulement, les bouts d'export (22:00 → minuit) n'ont pas d'épisode
if statistics.median(c[3][d] for c in concernes if d in c[3]) < JOUR:
continue
minuit = datetime(d.year, d.month, d.day, tzinfo=timezone.utc)
episodes.append({
"start": iso(minuit + timedelta(hours=chaudes[0])), "end": iso(minuit + timedelta(hours=chaudes[-1] + 1)),
"kind": "thermique", "label": "Daily thermal cycle",
"text": "The structure, the mast and the camera warm up during the day and move very slightly, "
"then cool down in the evening: this wave comes back every day and is normal.",
"ignore": False, "sensors": capteurs,
})
return episodes
if __name__ == "__main__":
mesures = charger(sys.argv[1])
for e in detect(mesures):
print(e["start"], "→", e["end"], e["label"], len(e["sensors"]), "cibles |", e["text"])
for cols in (("corr_x", "corr_y"), ("x", "y")):
concernes, n = cycle(mesures, cols)
k = len({c[0] for c in concernes})
amp = statistics.median(max(c[2]) - min(c[2]) for c in concernes) if concernes else 0
print(f"{cols[0][:-2] or 'brut'} : cibles {k}/{n}, amplitude médiane {amp:.3f} px, heures chaudes (UTC) {heures_chaudes(concernes) if concernes else '-'}")
+37
View File
@@ -0,0 +1,37 @@
"""Journal du matin : moments sans mesure (cadence de l'export « advanced » rompue).
Cadence : écart médian entre deux instants de mesure, tous capteurs confondus. Un trou : plus de 2 pas manquants entre
deux mesures (écart > 3 cadences) ; l'épisode va de la dernière mesure à la suivante. Pas de mesure dans l'export ne
veut pas dire station arrêtée (CLAUDE.md) : le texte dit seulement que l'export n'a rien.
Usage : python3 vues-deplacements/journal/trous.py <dossier de station> (affiche les épisodes)
"""
import os
import statistics
import sys
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..", "agents", "diagnostic", "outils"))
from donnees import charger, iso # noqa: E402
MISSING = 2 # au-delà de 2 pas manquants, c'est un trou (consigne de l'utilisateur, 2026-10-23)
def duration(s):
h, m = divmod(round(s / 60), 60)
return f"{h} h {m:02d} min" if h else f"{m} min"
def detect(mesures):
ts = sorted({m["t"].replace(second=0, microsecond=0) for ms in mesures.values() for m in ms})
if len(ts) < 3:
return []
gaps = [(b - a).total_seconds() for a, b in zip(ts, ts[1:])]
step = statistics.median(gaps)
return [{"start": iso(a), "end": iso(b), "kind": "trous", "label": "No data",
"text": f"No measurement in the export for {duration(g)} (usually one every {duration(step)}).",
"ignore": False, "sensors": []}
for a, b, g in zip(ts, ts[1:], gaps) if g > (MISSING + 1) * step]
if __name__ == "__main__":
for e in detect(charger(sys.argv[1])):
print(e)
+106
View File
@@ -0,0 +1,106 @@
"""Journal du matin : turbulence atmosphérique (bruit rapide sur les déplacements corrigés).
Méthode :
1. Par capteur et par heure H, sur les mesures de [H − 1 h, H + 2 h) : agitation = médiane de |Δcorr_x| + |Δcorr_y|
entre mesures successives (robuste aux sauts d'un seul pas), et médiane de l'error_value.
2. Chacune est rapportée au calme du capteur : le quartile bas de ses valeurs horaires sur l'export (souvent la nuit).
3. Heure turbulente : au moins la moitié des capteurs à ≥ 1,5 fois leur agitation calme, et error_value médiane
des capteurs à ≥ 1,5 fois la calme (l'air chaud brouille les taches : C-003, critère 1).
4. Heures voisines fusionnées (trou d'une heure toléré), épisode d'au moins 3 h, écarté si plus de 15 % des mesures
sont rejetées (c'est alors de la mauvaise visibilité, autre détecteur). Grisé si l'agitation médiane ≥ 2×.
Résultats (2026-10-23, seuils ci-dessous) :
- WILDSTRUBEL (C-003, vérité : chaque jour ~03:30 → 16:00) : 3 épisodes, 02.09 04:00-15:00, 03.09 05:00-15:00,
04.09 04:00-15:00, les 13 capteurs, ×2,3 à ×2,6, tous grisés.
- PS_DES_COUDRES (sain, buée une nuit), NORDEND juillet (toile d'araignée), CLARIDEN (mouvement réel),
NIEDERHORN (trains, pluie), NORDEND octobre (11 jours) : aucun épisode. Écartés en route : midis agités sans
error_value en hausse (PS des Coudres, NORDEND octobre), toile et pluie par les rejets (18 à 43 %), le matin du
mouvement de CLARIDEN (06:00-08:00) par la durée.
"""
import os
import statistics
import sys
from datetime import timedelta
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..", "agents", "diagnostic", "outils"))
from donnees import charger, iso # noqa: E402
RATIO = 1.5 # provisoire, réglé sur C-003 (WILDSTRUBEL : de jour, corr ×1,7 à ×3 la nuit)
PART = 0.5 # provisoire : part des capteurs agités en même temps
RATIO_ERR = 1.5 # provisoire, réglé sur C-003 (error_value ×1,7 à ×3,2 la nuit ; ≈ ×1 à midi ailleurs)
REJET_MAX = 0.15 # provisoire : C-003 ≤ 7 % ; toile d'araignée (C-002) et pluie (C-005) ≥ 18 %
FORT = 2.0 # provisoire : C-003 (×2,3 à ×2,6) est fort ; un épisode entre ×1,5 et ×2 reste visible
DUREE_MIN = timedelta(hours=3) # provisoire : C-003 dure 10-11 h ; écarte le matin du mouvement réel de C-004 (2 h)
HEURE = timedelta(hours=1)
def _heure(t):
return t.replace(minute=0, second=0, microsecond=0)
def _rapports(points):
"""[(t, valeur)] -> {heure H: médiane sur [H − 1 h, H + 2 h) / quartile bas de ces médianes}."""
par = {}
for t, v in points:
for k in (-1, 0, 1):
par.setdefault(_heure(t) + k * HEURE, []).append(v)
med = {h: statistics.median(v) for h, v in par.items() if len(v) >= 3}
if len(med) < 8:
return {}
calme = statistics.quantiles(med.values(), n=4)[0]
return {h: v / calme for h, v in med.items()} if calme > 0 else {}
def heures(mesures):
"""-> {heure: {capteur: (agitation / calme, error_value / calme)}}."""
out = {}
for s, ms in mesures.items():
ag = _rapports([(b["t"], abs(b["corr_x"] - a["corr_x"]) + abs(b["corr_y"] - a["corr_y"]))
for a, b in zip(ms, ms[1:]) if a["corr_x"] is not None and b["corr_x"] is not None])
er = _rapports([(m["t"], m["error_value"]) for m in ms if m["error_value"] is not None])
for h, r in ag.items():
if h in er:
out.setdefault(h, {})[s] = (r, er[h])
return out
def _turbulente(r):
return (sum(a >= RATIO for a, _ in r.values()) >= PART * len(r)
and statistics.median(e for _, e in r.values()) >= RATIO_ERR)
def detect(mesures):
H = heures(mesures)
blocs = []
for h in sorted(h for h, r in H.items() if _turbulente(r)):
if blocs and h - blocs[-1][-1] <= 2 * HEURE:
blocs[-1].append(h)
else:
blocs.append([h])
episodes = []
for b in blocs:
debut, fin = b[0], b[-1] + HEURE
dedans = [m for ms in mesures.values() for m in ms if debut <= m["t"] < fin]
if fin - debut < DUREE_MIN or sum(m["corr_x"] is None for m in dedans) > REJET_MAX * len(dedans):
continue
par_capteur = {}
for h in b:
for s, (a, _) in H[h].items():
par_capteur.setdefault(s, []).append(a)
agit = {s: statistics.median(v) for s, v in par_capteur.items()}
fort = statistics.median(agit.values())
episodes.append({
"start": iso(debut), "end": iso(fin), "kind": "turbulence",
"label": "Heat shimmer",
"text": f"Readings were about {fort:.1f}× noisier than in calm hours because of heat shimmer "
"(warm air trembling in the line of sight); the small fast wiggles are not movement.",
"ignore": fort >= FORT,
"sensors": sorted(s for s, v in agit.items() if v >= RATIO),
})
return episodes
if __name__ == "__main__":
for e in detect(charger(sys.argv[1])):
print(e["start"], "→", e["end"], e["label"], "(grisé)" if e["ignore"] else "",
f"{len(e['sensors'])} capteurs |", e["text"])
+158
View File
@@ -0,0 +1,158 @@
"""Journal du matin : visibilité / taux d'erreur de reconnaissance (error_value), un épisode grisé par moment douteux.
Méthode (seuils provisoires ci-dessous) :
1. Mesure « haute » : error_value > médiane + 10 MAD et > 2 × médiane du capteur sur l'export (relatif au capteur, pas au seuil).
2. Brief obstruction : un instant où au moins 3 capteurs sont hauts, 3 fois plus qu'aux instants voisins (train, véhicule).
3. Poor visibility : suites d'au moins 3 mesures hautes par capteur, réunies entre capteurs (au moins 2), réduites aux instants
où au moins 15 % du pic de l'épisode est haut ; le texte dit si des références (global_ref) sont touchées.
4. Target obscured : une cible (pas une global_ref) rejetée (> error_threshold) et à plus de 5 MAD, au moins 3 fois à moins de 6 h
d'écart, la plupart hors des épisodes 2 et 3 (feuilles, neige, reflet sur une cible). Tous les épisodes : ignore = True.
Résultats (2026-10-23 ; vérité : agents/diagnostic/cas/INDEX.md) :
- PS_DES_COUDRES (C-001, buée 13.10 23:45 → 14.10 05:15, 2 références sur 3) : Poor visibility 13.10 23:45 → 14.10 04:45, REF_G et
REF_D ; aussi la nuit d'avant, 13.10 01:15 → 03:30, mêmes références (hors vérité, pas d'image : sans doute la même buée).
- NORDEND juillet (C-002, toile 28.07 20:45 → 31.07 03:00, reprise 31.07 20:30) : Poor visibility 28.07 20:45 → 31.07 02:45 (20 capteurs)
et 31.07 20:30 → fin (18), références comprises.
- WILDSTRUBEL (C-003, turbulence de jour) : pas de Poor visibility (error_value ×1,5 à ×3 seulement : laissé au détecteur turbulence) ;
3 Brief obstruction de jour (02.09 12:00, 03.09 08:15, 04.09 14:00 : un véhicule sur la route à 14:00, image) ; PA_9 en
Target obscured chaque matin dès 04:30, jusqu'à 06:45, 08:15 ou 12:00 (soleil sur la cible, probable).
- CLARIDEN (C-004, mouvement réel) : rien sur le groupe à error_value durablement haute (bon) ; Brief obstruction 18.09 13:40
et 20.09 06:20 (tunnel : taches assombries, non établi) ; Target obscured PR-284 19.09 18:30 → 18:50.
- NIEDERHORN (C-005) : trains 30.09 22:00, 01.10 12:00 et 21:00, 02.10 21:00 (celui du 03.10 10:00, 2 cibles, manqué) ;
pluie 01.10 06:00 → 11:00 et 02.10 03:00 → 11:00 (vérité 05:00 et 03:00 → 11:00), références intactes ; feuilles 02.10 10:00 → 22:00.
- NORDEND octobre (cas/2026-10_NORDEND) : Poor visibility 07.10 17:15 → 08.10 12:15 (buée du 08.10 02:30), 09.10 07:45 → 14:00
(parois ruisselantes), 09.10 20:45 → 23:45 (17 rejets à 23:00, retour à 00:00), 13.10 09:45 → 10:30, 14.10 05:15 → 06:30
(taches pâles à l'aube) ; Brief obstruction 09.10 18:45 et 12.10 14:15 ; Target obscured surtout CTR01, PR04, PR09
(souvent rejetées) : à vérifier.
"""
import os
import statistics
import sys
from datetime import timedelta
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..", "agents", "diagnostic", "outils"))
from donnees import charger, iso # noqa: E402
K_MAD = 10 # provisoire, réglé sur C-001 (buée : 11 à 57 MAD) et C-005 (pluie, trains : 10 à 70 MAD)
FACTEUR = 2 # provisoire : écarte les capteurs à MAD quasi nulle (C-004 : PWD_REF10 ×1,6 à 14 MAD, C-005)
SUITE_MIN = 3 # provisoire : mesures hautes d'affilée pour une mauvaise visibilité (C-001, C-005 pluie)
BREF_MIN = 3 # provisoire, réglé sur C-005 (trains : 5 à 17 capteurs ; celui de 2 cibles est manqué)
K_CIBLE = 5 # provisoire, réglé sur C-005 (feuilles : 6 à 25 MAD, rejetées)
CIBLE_MIN = 3 # provisoire : rejets répétés d'une cible
FRAC = 0.15 # provisoire : coupe les queues de PR09 + CTR01 (NORDEND octobre) sans couper la toile (C-002)
ECART = 2.5 # provisoire : pas tolérés entre deux mesures hautes d'une même suite (un pas manquant, horloge à la seconde près)
COUPURE = timedelta(hours=2) # provisoire : accalmie qui sépare deux épisodes (NORDEND octobre, nuit du 13 au 14.10)
SAILLIE = 3 # provisoire : un train ressort d'au moins 3 fois les instants voisins (C-005 : 5 à 17 contre 0 à 2 ;
# la toile de C-002 varie de 2 à 9 d'un pas à l'autre)
CIBLE_ECART = timedelta(hours=6) # provisoire, réglé sur C-005 (feuilles : 7 rejets en 12 h, jusqu'à 5 h d'écart)
def _pas(mesures):
ts = sorted({m["t"] for v in mesures.values() for m in v})
return statistics.median(b - a for a, b in zip(ts, ts[1:]))
def _grouper(points, ecart):
"""[(t, capteur)] triés par t -> groupes [(début, fin, {capteurs}, [t])] dont les points sont à ≤ ecart les uns des autres."""
groupes = []
for t, s in points:
if groupes and t - groupes[-1][1] <= ecart:
g = groupes[-1]
groupes[-1] = (g[0], t, g[2] | {s}, g[3] + [t])
else:
groupes.append((t, t, {s}, [t]))
return groupes
def _episode(debut, fin, label, text, capteurs):
return {"start": iso(debut), "end": iso(fin), "kind": "visibilite", "label": label, "text": text,
"ignore": True, "sensors": sorted(capteurs)}
def detect(mesures):
ecart = ECART * _pas(mesures)
refs = {s for s, v in mesures.items() if v[0]["pattern_type"] == "global_ref"}
instants = sorted({m["t"] for v in mesures.values() for m in v})
hautes, rejets = {}, {} # capteur -> [t]
for s, v in mesures.items():
e = [m["error_value"] for m in v if m["error_value"] is not None]
if len(e) < 10:
continue
med = statistics.median(e)
mad = statistics.median(abs(x - med) for x in e) or 1e-9
for m in v:
x = m["error_value"]
if x is None:
continue
if x > med + K_MAD * mad and x > FACTEUR * med:
hautes.setdefault(s, []).append(m["t"])
if s not in refs and m["error_threshold"] and x > m["error_threshold"] and x > med + K_CIBLE * mad:
rejets.setdefault(s, []).append(m["t"])
par_t = {} # t -> {capteurs hauts}
for s, ts in hautes.items():
for t in ts:
par_t.setdefault(t, set()).add(s)
n = lambda t: len(par_t.get(t, ())) # noqa: E731
out = []
# 2. Brief obstruction : un instant où beaucoup de capteurs sont hauts, au moins SAILLIE fois plus qu'aux instants voisins.
brefs = set()
for i, t in enumerate(instants):
voisins = [n(instants[j]) for j in (i - 1, i + 1) if 0 <= j < len(instants)]
if n(t) >= BREF_MIN and n(t) >= SAILLIE * max(voisins):
brefs.add(t)
out.append(_episode(t, t, "Brief obstruction", f"{n(t)} points were poorly seen for a single measurement, then came "
"back: probably a train, a vehicle or an animal passing; ignore this point on the curves.", par_t[t]))
# 3. Poor visibility : suites longues par capteur (sans les instants brefs), réunies entre capteurs,
# puis réduites aux instants où au moins FRAC du pic de l'épisode est haut (coupe les queues d'un ou deux capteurs
# et les longues accalmies, plus de COUPURE).
suites = []
for s, ts in hautes.items():
pts = [(t, s) for t in ts if t not in brefs]
suites += [(a, b, s) for a, b, _, l in _grouper(pts, ecart) if len(l) >= SUITE_MIN]
zones = [z for z in _grouper_intervalles(sorted(suites), ecart) if len(z[2]) >= 2]
gardees = []
for a, b, _ in zones:
dans = [t for t in instants if a <= t <= b and t not in brefs]
pic = max(n(t) for t in dans)
pts = [(t, s) for t in dans if n(t) >= max(1, FRAC * pic) for s in par_t[t]]
gardees += [(d, f, cs) for d, f, cs, l in _grouper(pts, max(ecart, COUPURE)) if len(cs) >= 2 and len(set(l)) >= SUITE_MIN]
for a, b, cs in gardees:
r = cs & refs
if r:
text = (f"{len(cs)} points, including {len(r)} of the {len(refs)} reference points, were poorly seen: probably rain, "
"fog, condensation or something in front of the camera; all displacements in this period are unreliable.")
else:
text = (f"{len(cs)} targets were poorly seen, the reference points stayed clear: probably rain, fog or condensation; "
"the displacements of these targets in this period are unreliable.")
out.append(_episode(a, b, "Poor visibility", text, cs))
dedans = lambda t: t in brefs or any(a <= t <= b for a, b, _ in gardees) # noqa: E731
# 4. Target obscured : une cible rejetée à répétition, surtout hors des épisodes ci-dessus.
cibles = []
for s, ts in rejets.items():
for a, b, _, l in _grouper([(t, s) for t in ts], CIBLE_ECART):
if len(l) >= CIBLE_MIN and sum(map(dedans, l)) * 2 < len(l):
cibles.append((a, b, s))
for a, b, cs in _grouper_intervalles(sorted(cibles), timedelta(0)):
qui, it, its = ("One target was", "it", "its") if len(cs) == 1 else (f"{len(cs)} targets were", "them", "their")
out.append(_episode(a, b, "Target obscured", f"{qui} repeatedly lost while the targets around stayed clear: probably "
f"something in front of {it} (leaves, snow) or glare; {its} displacements in this period are unreliable.", cs))
return sorted(out, key=lambda e: e["start"])
def _grouper_intervalles(intervalles, ecart):
"""[(début, fin, capteur)] triés -> [(début, fin, {capteurs})] des intervalles qui se chevauchent (à ecart près)."""
out = []
for a, b, s in intervalles:
if out and a - out[-1][1] <= ecart:
out[-1] = (out[-1][0], max(out[-1][1], b), out[-1][2] | {s})
else:
out.append((a, b, {s}))
return out
if __name__ == "__main__":
for e in detect(charger(sys.argv[1])):
print(e["start"], "→", e["end"], e["label"], f"| {len(e['sensors'])} :", ",".join(e["sensors"][:8]), "|", e["text"])
+20 -3
View File
@@ -1,4 +1,4 @@
"""Maquette de la page Explore, onglets View et Diagnosis (D-053, D-054) et Displacements (sauts et tendances, D-055) ;
"""Maquette de la page Explore, onglets View et Diagnosis (D-053, D-054), Displacements (sauts et tendances, D-055) et Journal ;
spec : vues-deplacements/maquette/spec.md.
Lit l'export « advanced » d'un dossier de station avec l'outil donnees.py de l'agent (positions, error_value) et son
@@ -8,6 +8,7 @@ Usage : python3 vues-deplacements/maquette/explore.py [dossier de station] (d
"""
import csv
import html
import importlib.util
import json
import os
import statistics
@@ -26,7 +27,7 @@ sys.path.insert(0, str(ROOT / "agents" / "diagnostic" / "outils"))
from common.page import AUTOSCALE_Y_JS, open_html # noqa: E402 (bascule seule sur .venv si plotly manque)
import donnees # noqa: E402 (lecture des exports, bibliothèque standard)
COLUMNS = ("error_value",) # grandeurs de l'export « advanced » gardées pour la page, en plus de x, y
COLUMNS = ("error_value", "corr_x", "corr_y") # grandeurs de l'export « advanced » gardées pour la page, en plus de x, y
KINDS = ("global_ref", "ref", "target") # ordre des lignes : références de la compensation, local reference, cibles
MARGIN_PX = 150 # marge autour des capteurs, zoom de départ de l'image (spec §1)
HOURLY_TZ = ZoneInfo("Europe/Zurich") # horodatage de l'export horaire : heure suisse, sans fuseau (docs/domaine/colonnes-des-deplacements.md)
@@ -168,6 +169,22 @@ def regime_changes(hr):
return events, sorted(trends, key=lambda f: abs(f["drift"]) / f["swing"], reverse=True)
def journal(mesures):
"""Épisodes de tous les détecteurs de vues-deplacements/journal/*.py (onglet Journal), triés par début ; un détecteur
qui plante est sauté avec un message."""
episodes = []
for path in sorted((HERE.parent / "journal").glob("*.py")):
try:
spec = importlib.util.spec_from_file_location(f"journal_{path.stem}", path)
mod = importlib.util.module_from_spec(spec)
spec.loader.exec_module(mod)
if hasattr(mod, "detect"):
episodes += mod.detect(mesures)
except Exception as e: # noqa: BLE001 (prototype : un détecteur cassé ne bloque pas la page)
print(f"Journal : {path.name} sauté ({type(e).__name__}: {e})", file=sys.stderr)
return sorted(episodes, key=lambda e: e["start"])
def url(path):
"""Chemin -> URL relative depuis out/, où la page est écrite."""
return quote(Path(os.path.relpath(path, OUT)).as_posix())
@@ -209,7 +226,7 @@ def build(folder):
return {"platform": Path(files["advanced"][0]).name.split("_advanced_")[0], "times": [donnees.iso(t) for t in instants],
"sensors": sensors, "images": images, "view": view, "captures": captures,
"folder": Path(os.path.relpath(Path(folder).resolve(), ROOT)).as_posix(), # pour la demande à l'agent
"hourly": hr, "regime": regime, "trends": trends,
"hourly": hr, "regime": regime, "trends": trends, "journal": journal(mesures),
"rules": {"abrupt": ABRUPT, "size": SIZE, "trend_size": TREND_SIZE, "trend_days": TREND_DAYS}}
@@ -121,6 +121,12 @@
#r-trends { margin: 0 0 12px; }
#r-events details { margin: 0 0 12px; color: var(--text); }
#r-events summary { font-size: 15px; cursor: pointer; padding: 4px 0; }
/* Onglet Journal (spec « L'onglet Journal ») : courbes, frise des épisodes, journal en texte de la plage visible. */
#journal .hint { color: var(--muted); font-size: 12px; margin: 2px 0 10px; }
.jentry { padding: 6px 4px; border-bottom: 1px solid var(--line); color: var(--text); cursor: pointer; }
.jentry:hover { background: #e8f0fb; }
.jentry i { display: inline-block; width: 10px; height: 10px; border-radius: 2px; margin-right: 6px; }
.rtable { border-collapse: collapse; width: 100%; margin-top: 4px; color: var(--text); }
.rtable th, .rtable td { padding: 5px 6px; border-bottom: 1px solid var(--line); text-align: left; white-space: nowrap; }
.rtable th { color: var(--muted); font-weight: normal; white-space: normal; vertical-align: bottom; }
@@ -168,6 +174,7 @@
<button type="button" data-pane="view" class="active">View</button>
<button type="button" data-pane="diagnosis">Diagnosis</button>
<button type="button" data-pane="displacements">Displacements</button>
<button type="button" data-pane="journal">Journal</button>
</nav>
<div class="pane" id="time_series"></div>
<div class="pane" id="advanced"></div>
@@ -244,6 +251,12 @@
<div id="r-curves"></div>
</div>
</div>
<div class="pane" id="journal">
<div id="j-curves"></div>
<p class="hint">Grey zones: do not trust the data there (they are kept, not removed). Hover a bar for details; zoom the curves
with the wheel or by dragging, double-click for the whole period.</p>
<div id="j-list"></div>
</div>
</section>
</main>
@@ -897,6 +910,70 @@ function drawRegime() { // toutes les cibles en gris fin, celles qui ont sauté
}
drawRegime();
// Onglet Journal (spec « L'onglet Journal ») : le journal du matin du client. Courbes corr_x et corr_y des cibles, zones à
// ignorer grisées, une frise des épisodes (une ligne par détecteur), puis le journal en texte de la plage visible.
const J = D.journal;
const J_NAMES = { visibilite: "Visibility", sauts: "Jumps", turbulence: "Turbulence", thermique: "Thermal", trous: "Missing data" };
const J_KINDS = [...new Set([...Object.keys(J_NAMES), ...J.map(e => e.kind)])].filter(k => J.some(e => e.kind === k));
// une couleur fixe par détecteur, d'une station à l'autre ; vert pour ce qui est normal (le cycle thermique)
const J_COLORS = { visibilite: "#1f77b4", sauts: "#d62728", turbulence: "#ff7f0e", thermique: "#2ca02c", trous: "#7f7f7f" };
const jName = k => J_NAMES[k] || k, jColor = k => J_COLORS[k] || PALETTE[J_KINDS.indexOf(k) % PALETTE.length];
const MON = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
const jWhen = t => `${MON[+t.slice(5, 7) - 1]} ${+t.slice(8, 10)}, ${t.slice(11, 16)}`;
const plotT = ms => new Date(ms).toISOString().slice(0, 19).replace("T", " "); // instant en ms -> date Plotly (UTC)
const jEnd = e => Math.max(Date.parse(e.end), Date.parse(e.start) + 3600e3); // dessin : 1 h au moins, sinon invisible
function drawJournal() {
const targets = S.filter(s => s.kind === "target" || s.kind === "ref");
const traces = targets.flatMap((s, n) => [["corr_x", "Horizontal"], ["corr_y", "Vertical"]].map(([c, label], r) => ({
type: "scatter", mode: "lines", x: D.times, y: s.values[c], yaxis: `y${r ? 2 : ""}`, name: s.name, showlegend: false,
line: { color: PALETTE[n % PALETTE.length], width: 1 },
hovertemplate: `${s.name} · %{x|%d %b %H:%M} UTC<br>${label} %{y:.2f} px<extra></extra>` })));
for (const k of J_KINDS) { // frise : une barre par épisode, de son début à sa fin
const eps = J.filter(e => e.kind === k);
traces.push({ type: "bar", orientation: "h", yaxis: "y3", name: jName(k), showlegend: false,
y: eps.map(() => jName(k)), base: eps.map(e => e.start), x: eps.map(e => jEnd(e) - Date.parse(e.start)),
marker: { color: jColor(k) }, text: eps.map(e => e.label), textposition: "inside", insidetextanchor: "middle",
insidetextfont: { color: "#fff" }, hovertext: eps.map(e => `<b>${e.label}</b><br>${e.text}<br>Sensors: ${
e.sensors.length ? e.sensors.join(", ") : "all"}`), hovertemplate: "%{hovertext}<extra></extra>" });
}
const C = 220, G = 24, F = 30 * Math.max(J_KINDS.length, 1), A = 2 * C + 2 * G + F; // hauteurs en px, A : zone tracée
const grey = J.filter(e => e.ignore).flatMap(e => ["y domain", "y2 domain"].map(yref => ({ type: "rect", xref: "x", yref,
x0: e.start, x1: plotT(jEnd(e)), y0: 0, y1: 1, fillcolor: "#888", opacity: 0.25, line: { width: 0 }, layer: "below" })));
const end = Date.parse(D.times[D.times.length - 1]);
Plotly.newPlot("j-curves", traces, {
height: A + 70, margin: { l: 110, r: 10, t: 20, b: 50 }, barmode: "overlay", bargap: 0.25, uniformtext: { mode: "hide", minsize: 10 },
xaxis: { type: "date", anchor: "y3", range: [ASKED.get("from") || plotT(end - 3 * 864e5), plotT(end)] }, // départ : les 3 derniers jours (#from=AAAA-MM-JJ : captures)
yaxis: { domain: [1 - C / A, 1], fixedrange: true, title: { text: "Horizontal (px)" } },
yaxis2: { domain: [1 - (2 * C + G) / A, 1 - (C + G) / A], fixedrange: true, title: { text: "Vertical (px)" } },
yaxis3: { domain: [0, F / A], fixedrange: true, type: "category", categoryorder: "array",
categoryarray: J_KINDS.map(jName).reverse(), showgrid: false }, // inversé : le premier détecteur en haut
shapes: grey,
}, CONFIG).then(() => {
autoscale("j-curves"); // les barres de la frise (ordonnées en texte) n'entrent pas dans le recalage
const gd = document.getElementById("j-curves");
gd.on("plotly_relayout", () => listJournal(gd.layout.xaxis.range.map(v => Date.parse(minute(v)))));
Plotly.relayout(gd, { "xaxis.range": gd.layout.xaxis.range.slice() }); // ordonnées et journal dès l'ouverture
});
}
function listJournal([a, b]) { // les épisodes de la plage visible, dans l'ordre du temps ; clic : zoom sur l'épisode
const eps = J.filter(e => Date.parse(e.end) >= a && Date.parse(e.start) <= b);
document.getElementById("j-list").innerHTML = eps.length ? eps.map(e => `<div class="jentry" data-n="${J.indexOf(e)}">
<i style="background:${jColor(e.kind)}"></i>${jWhen(e.start)}${e.end === e.start ? "" : ` – ${
e.end.slice(0, 10) === e.start.slice(0, 10) ? e.end.slice(11, 16) : jWhen(e.end)}`} UTC · <b>${e.label}</b> · ${e.text}${
e.sensors.length ? ` <span class="meta">(${e.sensors.join(", ")})</span>` : ""}</div>`).join("")
: '<p class="empty">Nothing to report on this period.</p>';
}
document.getElementById("j-list").addEventListener("click", ev => {
const el = ev.target.closest("[data-n]");
if (!el) return;
const e = J[+el.dataset.n], a = Date.parse(e.start), b = Date.parse(e.end), m = Math.max((b - a) / 2, 2 * 3600e3); // marge
Plotly.relayout("j-curves", { "xaxis.range": [plotT(a - m), plotT(b + m)] });
});
drawJournal();
</script>
</body>
</html>
+17 -2
View File
@@ -1,4 +1,4 @@
# Maquette Explore : onglets View, Diagnosis et Displacements
# Maquette Explore : onglets View, Diagnosis, Displacements et Journal
Spec construite en conversation le 2026-10-16 (D-053, puis D-054). Cas de départ : `cas/2026-10_NORDEND/` (Carrière TROYDO (B), PR17).
@@ -15,7 +15,7 @@ Au départ (D-053), la version 0 était un cadre : image à T et grille capteurs
Maquette de la page Explore de la plateforme, texte en anglais (D-023).
- Habillage repris de `maquettes/user/summary_template.html` : barre latérale « AIMsight monitoring », en-tête `<nom plateforme> · Explore`, sélecteur de dates affiché seulement (inerte). Le nom plateforme est le préfixe du nom de l'export « advanced » (`Carrière TROYDO (B)_advanced_…` → `Carrière TROYDO (B)`).
- Cinq onglets : `Time Series`, `Advanced`, `View` (ouvert au chargement, ajouté le 2026-10-16 à la demande de l'utilisateur), `Diagnosis`, `Displacements` (D-055). L'adresse peut choisir l'onglet de départ : `#tab=diagnosis`, `#tab=displacements`.
- Six onglets : `Time Series`, `Advanced`, `View` (ouvert au chargement, ajouté le 2026-10-16 à la demande de l'utilisateur), `Diagnosis`, `Displacements` (D-055), `Journal` (2026-10-23). L'adresse peut choisir l'onglet de départ : `#tab=diagnosis`, `#tab=displacements`, `#tab=journal`.
- `Time Series` et `Advanced` sont un décor : les captures de `cas/<cas>/plateforme/` affichées telles quelles, `01` à `03` dans `Time Series`, `04` et `05` dans `Advanced`. Elles couvrent le 1/10 au 16/10, les données le 5/10 au 16/10 : écart admis.
## L'onglet View
@@ -108,6 +108,21 @@ Ajouté le 2026-10-16 à la demande de l'utilisateur : faire ressortir seules le
- **Clic sur une ligne** : l'onglet Diagnosis, sur cette cible à cette heure (fin du saut, ou dernière mesure pour une tendance).
- Vérifié par captures le 2026-10-16 : NORDEND, deux événements PR17 (08/10 et retour du 12/10) et une tendance (PR06 en horizontal, +0,7 mm) ; PS des Coudres, rien ; CLARIDEN, un événement de 21 cibles. Vérifié en onglet (`#tab=displacements`) le même jour. Pas encore essayés : le clic vers Diagnosis, le zoom des courbes. Survol vérifié par captures le 2026-10-19 (`#focus=…`) : NORDEND, les deux sauts de PR17 et la tendance de PR06 ; CLARIDEN, l'événement de 21 cibles ; pas encore essayé à la souris.
## L'onglet Journal (2026-10-23)
Le « journal du matin » du client (utilisateur, 2026-10-23) : il ouvre Explore, voit ses courbes sur quelques jours et, dessous, des barres étiquetées qui disent ce qui s'est passé. Un épisode n'est pas un vrai déplacement : c'est un moment où il ne faut pas se fier aux données. On garde toutes les données ; les zones à ignorer sont grisées. Prototype, au plus simple, en attente des retours de l'utilisateur.
- **Détecteurs** : un fichier par détecteur dans `vues-deplacements/journal/<nom>.py`, qui expose `detect(mesures)` (`mesures = donnees.charger(dossier)`) et rend des épisodes `{start, end, kind, label, text, ignore, sensors}` (heures `donnees.iso`, UTC ; `kind` = nom du fichier ; `ignore` vrai = zone grisée ; `sensors` vide = tous). `explore.py` (`journal`) charge tous les fichiers qui ont `detect`, appelle chacun sur les mesures déjà lues et trie les épisodes par début ; un détecteur qui plante est sauté avec un message, la page se fait quand même.
- **`trous.py`** : les moments sans mesure, cadence de l'export rompue (plus de 2 pas manquants, cadence = écart médian), de la dernière mesure à la suivante ; label `No data`, pas grisé. Les autres (`visibilite`, `sauts`, `turbulence`, `thermique`) sont écrits à part.
- **Courbes** : `Horizontal (px)` = `corr_x`, `Vertical (px)` = `corr_y` de l'export « advanced », cibles seules (`target` et `ref`, pas les `global_ref`), lignes fines, axe du temps partagé ; vue de départ : les 3 derniers jours (`#from=AAAA-MM-JJ` dans l'adresse la fait partir d'un autre jour, pour les captures) ; zoom à la molette ou au cadre sur toute la plage, double-clic pour tout voir ; ordonnées recalées sur la plage visible (D-013).
- **Zones grisées** : un rectangle gris sur les deux courbes par épisode `ignore`.
- **Frise** sous les courbes, même axe du temps : une ligne par détecteur (Visibility, Jumps, Turbulence, Thermal, Missing data, puis les autres), seulement ceux qui ont des épisodes ; une barre colorée par épisode, son label dedans s'il tient ; survol : label, texte et capteurs. Un épisode plus court qu'une heure est dessiné sur 1 h, sinon il serait invisible.
- **Journal en texte** : les épisodes de la plage visible, dans l'ordre du temps (`Oct 14, 23:45 – 05:15 UTC · Poor visibility · <text> (capteurs)`), mis à jour à chaque zoom ; `Nothing to report on this period.` sinon ; clic sur une entrée : les courbes zooment sur l'épisode, avec une marge (la moitié de sa durée, 2 h au moins).
- **Vérifié** par captures Chrome headless le 2026-10-23 (`#tab=journal`, `#tab=journal&from=2026-10-07`) : NORDEND (cas d'octobre) et NIEDERHORN (`data/NIEDERHORN/`), avec `trous`, `visibilite` et `sauts` ; courbes, zones grisées, frise, libellés, journal de la plage visible ; le trou de NORDEND (15/10 22:30 → 16/10 01:15) en barre `No data`.
- **Pas encore vérifié** : le clic sur une entrée (zoom), le survol des barres, le zoom à la souris ; `turbulence` et `thermique` n'ont rien rendu sur ces deux cas.
- **Corrigé le jour même** : un `Lasting shift` durait jusqu'à la fin des données et sa barre cachait les autres sauts (il finit maintenant avec le saut) ; les couleurs de la frise sont fixes par détecteur (`J_COLORS` : bleu visibilité, rouge sauts, orange turbulence, vert cycle thermique, gris trous). Vérifié ensuite par captures sur les six jeux, avec les cinq détecteurs.
- **Retour de l'utilisateur (2026-10-23)** : encore plus simple, diagnostic catégorique (une catégorie par événement, son processus, les images pour une perte de visibilité) : `docs/superpowers/plans/2026-10-23-journal-du-matin.md`, partie II.
## Fichiers et flux
- `vues-deplacements/maquette/explore.py [dossier de station]` (défaut `vues-deplacements/cas/2026-10_NORDEND/NORDEND/`) :