2026-11-03 14:57:52 +01:00
|
|
|
|
"""Journal du matin : le détecteur de la famille Thermal displacement (labeling/familles.md) : la vague quotidienne des
|
|
|
|
|
|
déplacements corrigés (dilatation le jour, contraction le soir : l'utilisateur, 2026-10-24 ; point 41 du plan).
|
2026-10-23 21:52:08 +02:00
|
|
|
|
|
|
|
|
|
|
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
|
2026-11-05 13:18:24 +01:00
|
|
|
|
entre le jour et le profil des autres jours. Axe concerné si répétabilité ≥ 0,6. Un jour incomplet (au moins
|
|
|
|
|
|
PARTIEL heures, moins de 20) n'entre pas dans le profil, mais sa ressemblance se mesure sur les heures qu'il a : un
|
|
|
|
|
|
trou d'une demi-journée ne lui ôte plus son épisode (/detector-learner Thermal displacement, modification 1, S4 ;
|
|
|
|
|
|
à HEURES_MIN = 12 ou 16, les jours incomplets faussaient le profil, NIEDERHORN reculait).
|
2026-10-24 12:22:06 +02:00
|
|
|
|
3. Cycle de la station si au moins la moitié des cibles ont un axe concerné, **et** (seconde méthode, demandée par
|
|
|
|
|
|
l'utilisateur) si une sinusoïde de 24 h, a + b·sin(2πt/24 h) + c·cos(2πt/24 h) par moindres carrés, explique au
|
|
|
|
|
|
moins R2_MIN de la courbe d'un axe pour au moins la moitié des cibles.
|
2026-10-23 21:52:08 +02:00
|
|
|
|
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.
|
2026-10-24 12:22:06 +02:00
|
|
|
|
5. Deux épisodes par jour complet qui ressemble aux autres (corrélation médiane ≥ 0,5 sur les axes concernés) :
|
2026-11-05 12:37:29 +01:00
|
|
|
|
« Thermal expansion » du départ à l'heure du plus grand écart au niveau de nuit (le pic), puis « Thermal
|
|
|
|
|
|
contraction » jusqu'au retour. Les heures chaudes disent qu'il y a un cycle ; ses bornes se lisent plus bas, à BORD
|
|
|
|
|
|
fois l'amplitude : le départ, en remontant du pic tant que l'écart reste ≥ BORD (au plus jusqu'à l'heure la plus
|
|
|
|
|
|
calme du profil) ; le retour, en descendant du pic jusqu'à ce qu'il repasse sous BORD, après minuit s'il le faut, au
|
|
|
|
|
|
plus jusqu'au départ du lendemain : un retour lent la nuit enchaîne les cycles (/detector-learner Thermal
|
|
|
|
|
|
displacement, modification 1, S1 : avant, la vague s'arrêtait à la dernière heure chaude, le soir et la nuit
|
|
|
|
|
|
manquaient). Le sens (une courbe qui monte ou qui descend) dépend de la direction de la cible : on ne le regarde
|
|
|
|
|
|
pas, seulement l'écart au niveau de nuit.
|
2026-10-24 12:22:06 +02:00
|
|
|
|
Sinusoïde (2026-10-24), axes des courbes corrigées où elle explique ≥ 30 % : PS des Coudres 14/22, NORDEND d'octobre
|
|
|
|
|
|
0/38, juillet 1/38, WILDSTRUBEL 1/14, CLARIDEN 0/48, NIEDERHORN 14/40 (3 jours, deux nuits de pluie aux mêmes heures,
|
|
|
|
|
|
écarté par la première méthode) ; PS des Coudres seule a son effet périodique, 5 jours, dilatation puis contraction.
|
2026-10-23 21:52:08 +02:00
|
|
|
|
|
|
|
|
|
|
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 |
|
2026-10-29 07:25:29 +01:00
|
|
|
|
| NORDEND (juillet, E-002) | 2/18, rien | 18/19, 1,8 px, 06-18 h |
|
|
|
|
|
|
| WILDSTRUBEL (E-003) | 3/7, rien | 6/7, 3,2 px, 04-08 h |
|
|
|
|
|
|
| CLARIDEN (E-004) | 1/24, rien | 1/24, aucun cycle |
|
|
|
|
|
|
| NIEDERHORN (E-005, horaire) | 3/11, rien | 19/30, 4,6 px, ~12 h |
|
2026-10-23 21:52:08 +02:00
|
|
|
|
| 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.
|
2026-10-27 09:28:29 +01:00
|
|
|
|
Effet thermique (D-074, 2026-10-27) : sans cycle dans corr, la même méthode sur les positions brutes x, y donne
|
|
|
|
|
|
« Camera thermal expansion » et « Camera thermal contraction » : la caméra bouge avec la chaleur de son support, la
|
|
|
|
|
|
compensation l'enlève ; mêmes catégories du journal, phrase propre.
|
2026-10-27 09:49:47 +01:00
|
|
|
|
Caméra sans sinusoïde (boucle WILDSTRUBEL, lot 01) : sur les positions brutes, la seconde méthode n'est plus demandée ;
|
|
|
|
|
|
la caméra y montait d'un bloc de 3 px au lever, tenait 3 h et retombait en un pas vers 09:30, six jours de suite, que
|
|
|
|
|
|
la sinusoïde n'explique pas (une cible sur sept, les pointés faux de 30 px écrasent l'ajustement) ; la répétition
|
|
|
|
|
|
d'un jour à l'autre (méthode 1, 6 cibles sur 7) suffit. En échange, une seule heure chaude n'est pas un cycle
|
2026-10-29 07:25:29 +01:00
|
|
|
|
(CHAUDES_MIN) : NIEDERHORN (E-005, horaire) avait sinon son heure de midi (trains, trous) en contraction de la caméra.
|
2026-10-27 09:49:47 +01:00
|
|
|
|
L'épisode de la caméra porte sur tous les capteurs, références comprises : toute l'image bouge.
|
2026-11-03 15:32:27 +01:00
|
|
|
|
Glissade commune, sans cycle (boucle /detector-learner MICHIGAN, modification 1) : faute de cycle dans les courbes
|
|
|
|
|
|
corrigées comme dans les positions brutes, un instant est une glissade de la caméra si les positions brutes (x ou y) d'au
|
|
|
|
|
|
moins PART des capteurs, références comprises, **et** les courbes corrigées (corr_x ou corr_y) d'au moins PART des cibles
|
|
|
|
|
|
s'écartent du même côté d'au moins ECART bruits (médiane des pas de la série) de leur médiane du jour d'avant ; les
|
|
|
|
|
|
glissades à moins d'un jour l'une de l'autre font un épisode, « Camera thermal movement », sur tous les capteurs, hôte
|
|
|
|
|
|
des sauts revenus (categories.HOTES). La caméra bouge avec la température sans revenir chaque jour à la même heure (une
|
|
|
|
|
|
mesure toutes les 4 h, refroidissements brefs), et la compensation ne l'enlève pas toute. La condition sur les positions
|
|
|
|
|
|
brutes laisse aux sauts une bascule de la seule pose calculée (positions brutes immobiles). MICHIGAN : 9 épisodes du 09
|
|
|
|
|
|
au 30.10, tous dans la dérive thermique étiquetée ; NEBRASKA : 13 instants, tous justes ; BREITHORN, JUNGFRAU, NORDEND,
|
|
|
|
|
|
WILDSTRUBEL inchangés (cycle trouvé, ou rien) ; ECART = 2 prenait 2 instants Displacement de BREITHORN.
|
2026-11-05 13:04:28 +01:00
|
|
|
|
La caméra bouge avec le froid (/detector-learner Thermal displacement, modification 1, S3) : faute de cycle, aussi un
|
|
|
|
|
|
« Camera thermal movement » là où la pose de la caméra (tilt, rotation ou échelle) s'écarte de sa médiane du jour d'avant
|
|
|
|
|
|
d'au moins FROID bruits, pendant que la température de la station (detect la déclare, D-124) tombe sous la sienne d'au
|
|
|
|
|
|
moins FROID bruits la même heure ; bruit : la médiane des variations sur une heure (sur un pas, à une mesure toutes les
|
|
|
|
|
|
4 h), pour que le seuil ne dépende pas de la cadence. Les cibles peuvent s'écarter en sens opposés ou rester presque
|
|
|
|
|
|
immobiles (la compensation absorbe le mouvement) : la règle des glissades ne le voit pas. Les instants qui se suivent dans
|
|
|
|
|
|
la pose font un épisode. Sans pose ou sans température, rien. FROID = 3 prenait plus d'instants Displacement de NEBRASKA
|
|
|
|
|
|
et de MICHIGAN ; la chaleur n'est pas prise : par beau temps, c'est le cycle du jour.
|
2026-10-23 21:52:08 +02:00
|
|
|
|
"""
|
2026-10-24 12:22:06 +02:00
|
|
|
|
import math
|
2026-10-23 21:52:08 +02:00
|
|
|
|
import os
|
|
|
|
|
|
import statistics
|
|
|
|
|
|
import sys
|
|
|
|
|
|
from datetime import datetime, timedelta, timezone
|
|
|
|
|
|
|
2026-10-28 17:19:51 +01:00
|
|
|
|
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "agent-tools"))
|
2026-10-23 21:52:08 +02:00
|
|
|
|
from donnees import charger, iso # noqa: E402
|
|
|
|
|
|
|
2026-11-05 13:18:24 +01:00
|
|
|
|
HEURES_MIN = 20 # provisoire : un jour UTC compte dans le profil s'il a au moins 20 heures mesurées
|
|
|
|
|
|
PARTIEL = 12 # provisoire : un jour incomplet d'au moins 12 heures reçoit son épisode s'il ressemble au profil
|
2026-10-23 21:52:08 +02:00
|
|
|
|
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
|
2026-10-24 12:22:06 +02:00
|
|
|
|
R2_MIN = 0.3 # provisoire, ébauche du 2026-10-24 : PS des Coudres 14 axes sur 22 au-dessus, CLARIDEN 0 sur 48
|
2026-10-29 07:25:29 +01:00
|
|
|
|
CHAUDES_MIN = 2 # provisoire : boucle WILDSTRUBEL, lot 01 ; NIEDERHORN (E-005) n'a qu'une heure chaude (midi)
|
2026-11-05 12:37:29 +01:00
|
|
|
|
BORD = 0.1 # provisoire : bornes de la vague (départ, retour), en part de l'amplitude ; CHAUD dit s'il y a un cycle
|
2026-11-03 15:32:27 +01:00
|
|
|
|
ECART = 3 # provisoire : glissade commune, en bruits (médiane des pas) d'écart à la médiane du jour d'avant
|
2026-11-05 13:04:28 +01:00
|
|
|
|
FROID = 4 # provisoire : la caméra bouge avec le froid, en bruits d'une heure d'écart au jour d'avant (pose, température)
|
2026-10-24 12:22:06 +02:00
|
|
|
|
W = 2 * math.pi / 86400 # pulsation d'un cycle de 24 h, en rad/s
|
2026-10-23 21:52:08 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
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])
|
2026-11-05 13:18:24 +01:00
|
|
|
|
J, tous = {}, {}
|
2026-10-23 21:52:08 +02:00
|
|
|
|
for d, hs in jours.items():
|
2026-11-05 13:18:24 +01:00
|
|
|
|
if len(hs) >= PARTIEL:
|
2026-10-23 21:52:08 +02:00
|
|
|
|
med = statistics.median(v for l in hs.values() for v in l)
|
2026-11-05 13:18:24 +01:00
|
|
|
|
tous[d] = {h: statistics.mean(l) - med for h, l in hs.items()}
|
|
|
|
|
|
if len(hs) >= HEURES_MIN:
|
|
|
|
|
|
J[d] = tous[d]
|
2026-10-23 21:52:08 +02:00
|
|
|
|
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 = {}
|
2026-11-05 13:18:24 +01:00
|
|
|
|
for d, p in tous.items():
|
2026-10-23 21:52:08 +02:00
|
|
|
|
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)]
|
2026-11-05 13:18:24 +01:00
|
|
|
|
if len(hs) >= 3:
|
|
|
|
|
|
ressemblance[d] = _corr([p[h] for h in hs], [statistics.median(q[h] for q in autres) for h in hs])
|
2026-10-23 21:52:08 +02:00
|
|
|
|
return profil, ressemblance
|
|
|
|
|
|
|
|
|
|
|
|
|
2026-10-24 12:22:06 +02:00
|
|
|
|
def sinus_r2(ms, col):
|
|
|
|
|
|
"""Part de la courbe expliquée par une sinusoïde de 24 h (moindres carrés, 3 inconnues), ou None si trop court."""
|
|
|
|
|
|
pts = [(m["t"].timestamp(), m[col]) for m in ms if m[col] is not None]
|
|
|
|
|
|
if len(pts) <= 48:
|
|
|
|
|
|
return None
|
|
|
|
|
|
rows = [(1.0, math.sin(W * t), math.cos(W * t)) for t, _ in pts]
|
|
|
|
|
|
A = [[sum(r[i] * r[j] for r in rows) for j in range(3)] for i in range(3)]
|
|
|
|
|
|
B = [sum(r[i] * y for r, (_, y) in zip(rows, pts)) for i in range(3)]
|
|
|
|
|
|
for i in range(3): # élimination de Gauss
|
|
|
|
|
|
for k in range(i + 1, 3):
|
|
|
|
|
|
f = A[k][i] / A[i][i]
|
|
|
|
|
|
A[k] = [x - f * y for x, y in zip(A[k], A[i])]
|
|
|
|
|
|
B[k] -= f * B[i]
|
|
|
|
|
|
x = [0.0] * 3
|
|
|
|
|
|
for i in (2, 1, 0):
|
|
|
|
|
|
x[i] = (B[i] - sum(A[i][j] * x[j] for j in range(i + 1, 3))) / A[i][i]
|
|
|
|
|
|
m = statistics.mean(y for _, y in pts)
|
|
|
|
|
|
sst = sum((y - m) ** 2 for _, y in pts)
|
|
|
|
|
|
sse = sum((y - sum(c * v for c, v in zip(x, r))) ** 2 for r, (_, y) in zip(rows, pts))
|
|
|
|
|
|
return 1 - sse / sst if sst else None
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def sinus(mesures, cols=("corr_x", "corr_y")):
|
|
|
|
|
|
"""-> (cibles dont un axe suit une sinusoïde de 24 h, cibles évaluées)."""
|
|
|
|
|
|
oui, evaluees = set(), set()
|
|
|
|
|
|
for s, ms in mesures.items():
|
|
|
|
|
|
if ms[0]["pattern_type"] == "global_ref":
|
|
|
|
|
|
continue
|
|
|
|
|
|
for col in cols:
|
|
|
|
|
|
r2 = sinus_r2(ms, col)
|
|
|
|
|
|
if r2 is not None:
|
|
|
|
|
|
evaluees.add(s)
|
|
|
|
|
|
if r2 >= R2_MIN:
|
|
|
|
|
|
oui.add(s)
|
|
|
|
|
|
return oui, evaluees
|
|
|
|
|
|
|
|
|
|
|
|
|
2026-10-23 21:52:08 +02:00
|
|
|
|
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)
|
|
|
|
|
|
|
|
|
|
|
|
|
2026-10-24 12:22:06 +02:00
|
|
|
|
def ecarts(concernes):
|
|
|
|
|
|
"""Écart médian (sur les axes concernés) au niveau de nuit, heure par heure, en part de l'amplitude du profil."""
|
2026-10-23 21:52:08 +02:00
|
|
|
|
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))
|
2026-10-24 12:22:06 +02:00
|
|
|
|
return [statistics.median(score(c[2], h) for c in concernes) for h in range(24)]
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def heures_chaudes(concernes):
|
|
|
|
|
|
return [h for h, e in enumerate(ecarts(concernes)) if e >= CHAUD]
|
2026-10-23 21:52:08 +02:00
|
|
|
|
|
|
|
|
|
|
|
2026-11-05 13:04:28 +01:00
|
|
|
|
def detect(mesures, temperature=(), camera=()):
|
2026-10-27 09:28:29 +01:00
|
|
|
|
"""Cycle des courbes corrigées (l'ouvrage) ; sinon, celui des positions brutes (la caméra qui bouge par dilatation
|
2026-11-05 13:04:28 +01:00
|
|
|
|
de son support, compensée : D-074, 2026-10-27) ; sinon, les glissades de la caméra (avec le froid)."""
|
2026-10-27 09:49:47 +01:00
|
|
|
|
return (_episodes(mesures, ("corr_x", "corr_y"), "Thermal", False) or
|
2026-11-05 13:04:28 +01:00
|
|
|
|
_episodes(mesures, ("x", "y"), "Camera thermal", True) or glissades(mesures, temperature, camera))
|
2026-11-03 15:32:27 +01:00
|
|
|
|
|
|
|
|
|
|
|
2026-11-05 13:04:28 +01:00
|
|
|
|
def _signes(ms, col, heure=False, seuil=None):
|
|
|
|
|
|
"""{instant: +1 ou -1} où la mesure s'écarte d'au moins ECART bruits de la médiane du jour d'avant ; bruit : la
|
|
|
|
|
|
médiane des pas d'une mesure à la suivante, ou, heure, des variations sur une heure (un pas si la cadence est lente)."""
|
2026-11-03 15:32:27 +01:00
|
|
|
|
k = [(m["t"], m[col]) for m in ms if m[col] is not None]
|
|
|
|
|
|
if len(k) < 3:
|
|
|
|
|
|
return {}
|
2026-11-05 13:04:28 +01:00
|
|
|
|
pas = statistics.median((b - a).total_seconds() for (a, _), (b, _) in zip(k, k[1:])) if heure else 0
|
|
|
|
|
|
n = max(1, round(3600 / pas)) if pas else 1
|
|
|
|
|
|
bruit = statistics.median(abs(k[i + n][1] - k[i][1]) for i in range(len(k) - n)) if len(k) > n else 0
|
2026-11-03 15:32:27 +01:00
|
|
|
|
out, j = {}, 0
|
|
|
|
|
|
for i, (t, v) in enumerate(k):
|
|
|
|
|
|
while k[j][0] < t - timedelta(days=1):
|
|
|
|
|
|
j += 1
|
|
|
|
|
|
avant = [w for _, w in k[j:i]]
|
2026-11-05 13:04:28 +01:00
|
|
|
|
if bruit and len(avant) >= 3 and abs(v - statistics.median(avant)) >= (seuil or ECART) * bruit:
|
2026-11-03 15:32:27 +01:00
|
|
|
|
out[t] = 1 if v > statistics.median(avant) else -1
|
|
|
|
|
|
return out
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def _communs(series):
|
|
|
|
|
|
"""[{instant: signe}] d'un groupe de capteurs -> instants où au moins PART d'entre eux s'écartent du même côté."""
|
|
|
|
|
|
n, compte = len(series), {}
|
|
|
|
|
|
for sg in series:
|
|
|
|
|
|
for t, x in sg.items():
|
|
|
|
|
|
compte.setdefault((t, x), 0)
|
|
|
|
|
|
compte[(t, x)] += 1
|
|
|
|
|
|
return {t for (t, x), c in compte.items() if n and c >= PART * n}
|
|
|
|
|
|
|
|
|
|
|
|
|
2026-11-05 13:04:28 +01:00
|
|
|
|
def _froid(mesures, temperature, camera):
|
|
|
|
|
|
"""[(début, fin)] des suites d'instants où la pose de la caméra (tilt, rotation ou échelle) s'écarte de son jour
|
|
|
|
|
|
d'avant pendant que la température tombe sous le sien, d'au moins FROID bruits d'une heure ; vide sans l'une d'elles."""
|
|
|
|
|
|
ts = [m["t"] for ms in mesures.values() for m in ms]
|
|
|
|
|
|
heure = lambda t: t.replace(minute=0, second=0, microsecond=0) # noqa: E731
|
|
|
|
|
|
froid = {heure(t) for t, x in _signes([{"t": t, "T": v} for t, v in temperature], "T", True, FROID).items() if x < 0}
|
|
|
|
|
|
pose = [p for p in camera if min(ts) <= p["t"] <= max(ts)] if ts else []
|
|
|
|
|
|
vus = {t for c in ("tilt", "rotation", "scale") for t in _signes(pose, c, True, FROID) if heure(t) in froid}
|
|
|
|
|
|
episodes = [] # les instants qui se suivent dans la pose font un épisode
|
|
|
|
|
|
for i, p in enumerate(pose):
|
|
|
|
|
|
if p["t"] in vus:
|
|
|
|
|
|
if episodes and episodes[-1][2] == i - 1:
|
|
|
|
|
|
episodes[-1][1:] = [p["t"], i]
|
|
|
|
|
|
else:
|
|
|
|
|
|
episodes.append([p["t"], p["t"], i])
|
|
|
|
|
|
return [(a, b) for a, b, _ in episodes]
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def glissades(mesures, temperature=(), camera=()):
|
2026-11-03 15:32:27 +01:00
|
|
|
|
"""Glissade commune de la caméra, sans cycle de 24 h : les positions brutes de la plupart des capteurs, références
|
2026-11-05 13:04:28 +01:00
|
|
|
|
comprises, et les courbes corrigées de la plupart des cibles s'écartent ensemble, du même côté, de leur jour d'avant ;
|
|
|
|
|
|
ou la pose de la caméra s'en écarte avec le froid (_froid)."""
|
2026-11-03 15:32:27 +01:00
|
|
|
|
cibles = [ms for ms in mesures.values() if ms[0]["pattern_type"] != "global_ref"]
|
|
|
|
|
|
brut = set().union(*(_communs([_signes(ms, c) for ms in mesures.values()]) for c in ("x", "y")))
|
|
|
|
|
|
corr = set().union(*(_communs([_signes(ms, c) for ms in cibles]) for c in ("corr_x", "corr_y")))
|
|
|
|
|
|
episodes = []
|
|
|
|
|
|
for t in sorted(brut & corr):
|
|
|
|
|
|
if episodes and t - episodes[-1][1] <= timedelta(days=1): # moins d'un jour entre deux : la même glissade
|
|
|
|
|
|
episodes[-1][1] = t
|
|
|
|
|
|
else:
|
|
|
|
|
|
episodes.append([t, t])
|
|
|
|
|
|
return [{"start": iso(a), "end": iso(b), "kind": "Thermal displacement", "label": "Camera thermal movement",
|
|
|
|
|
|
"text": "The camera moved with a change of temperature and all the curves moved with it; this is not a "
|
|
|
|
|
|
"movement of the structure, nothing to do.", "ignore": False, "sensors": sorted(mesures)}
|
2026-11-05 13:04:28 +01:00
|
|
|
|
for a, b in episodes + _froid(mesures, temperature, camera)]
|
2026-10-27 09:28:29 +01:00
|
|
|
|
|
|
|
|
|
|
|
2026-10-27 09:49:47 +01:00
|
|
|
|
def _episodes(mesures, cols, nom, camera):
|
2026-10-27 09:28:29 +01:00
|
|
|
|
concernes, n = cycle(mesures, cols)
|
2026-10-23 21:52:08 +02:00
|
|
|
|
capteurs = sorted({c[0] for c in concernes})
|
|
|
|
|
|
if not n or len(capteurs) < PART * n:
|
|
|
|
|
|
return []
|
2026-10-27 09:49:47 +01:00
|
|
|
|
if not camera: # seconde méthode, pour l'ouvrage seul : la sinusoïde doit le voir aussi
|
|
|
|
|
|
oui, evaluees = sinus(mesures, cols)
|
|
|
|
|
|
if not evaluees or len(oui) < PART * len(evaluees):
|
|
|
|
|
|
return []
|
2026-10-23 21:52:08 +02:00
|
|
|
|
chaudes = heures_chaudes(concernes)
|
2026-10-27 09:49:47 +01:00
|
|
|
|
if len(chaudes) < CHAUDES_MIN:
|
2026-10-23 21:52:08 +02:00
|
|
|
|
return []
|
2026-10-24 12:22:06 +02:00
|
|
|
|
e = ecarts(concernes)
|
|
|
|
|
|
pic = max(chaudes, key=lambda h: e[h]) # le plus grand écart au niveau de nuit : fin de la dilatation
|
2026-11-05 12:37:29 +01:00
|
|
|
|
repos = min(range(24), key=lambda h: e[h])
|
|
|
|
|
|
a = pic # départ : on remonte du pic tant que le profil reste au-dessus de BORD, jusqu'à l'heure la plus calme
|
|
|
|
|
|
while (a - 1) % 24 != repos and e[(a - 1) % 24] >= BORD:
|
|
|
|
|
|
a -= 1
|
|
|
|
|
|
b = pic + 1 # retour : jusqu'à ce que le profil repasse sous BORD, au plus jusqu'au départ suivant
|
|
|
|
|
|
while b < a + 24 and e[b % 24] >= BORD:
|
|
|
|
|
|
b += 1
|
|
|
|
|
|
derniere = max(m["t"] for ms in mesures.values() for m in ms)
|
2026-10-23 21:52:08 +02:00
|
|
|
|
jours = sorted({d for c in concernes for d in c[3]})
|
2026-10-27 09:49:47 +01:00
|
|
|
|
if camera: # toute l'image bouge, références comprises
|
|
|
|
|
|
capteurs = sorted(mesures)
|
2026-10-23 21:52:08 +02:00
|
|
|
|
episodes = []
|
2026-11-05 13:18:24 +01:00
|
|
|
|
for d in jours: # ponytail: jours d'au moins PARTIEL heures, les bouts d'export (22:00 → minuit) n'ont pas d'épisode
|
2026-10-23 21:52:08 +02:00
|
|
|
|
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)
|
2026-11-05 12:37:29 +01:00
|
|
|
|
for label, u, v in ((f"{nom} expansion", a, pic), (f"{nom} contraction", pic, b)):
|
|
|
|
|
|
debut, fin = minuit + timedelta(hours=u), min(minuit + timedelta(hours=v), derniere)
|
|
|
|
|
|
if fin > debut:
|
|
|
|
|
|
episodes.append({"start": iso(debut), "end": iso(fin),
|
2026-11-03 14:57:52 +01:00
|
|
|
|
"kind": "Thermal displacement", "label": label, "text": "", "ignore": False, "sensors": capteurs})
|
2026-10-23 21:52:08 +02:00
|
|
|
|
return episodes
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if __name__ == "__main__":
|
|
|
|
|
|
mesures = charger(sys.argv[1])
|
|
|
|
|
|
for e in detect(mesures):
|
2026-10-24 12:22:06 +02:00
|
|
|
|
print(e["start"], "→", e["end"], e["label"], len(e["sensors"]), "cibles")
|
2026-10-23 21:52:08 +02:00
|
|
|
|
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
|
2026-10-24 12:22:06 +02:00
|
|
|
|
oui, evaluees = sinus(mesures, cols)
|
|
|
|
|
|
print(f"{cols[0][:-2] or 'brut'} : cibles {k}/{n}, amplitude médiane {amp:.3f} px, heures chaudes (UTC) "
|
|
|
|
|
|
f"{heures_chaudes(concernes) if concernes else '-'} ; sinusoïde : cibles {len(oui)}/{len(evaluees)}")
|