"""Journal du matin : le détecteur de la famille Displacement (labeling/familles.md) : les sauts brutaux de corr_x / corr_y (px) de chaque cible, à la cadence native de l'export « advanced », et la dérive lente (en fin de fichier). Une cible qui bascule (« Target flipping ») est de la famille Target issue : episodes() la rend, detect() la laisse à target_issue.py. 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) ; les BASE premières mesures, faute de niveau d'avant, face au niveau d'après (médiane des BASE suivantes), un écart y est un saut revenu aussitôt (point 12 du plan, 2026-10-24). 2. Revenu (une heure de mesures de suite à moins de la moitié du saut : BASE à 15 min, une seule à 4 h, boucle /detector-learner MICHIGAN, modification 1) 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é ; sa cause n'est pas établie ici (categories.py lui donne celle de la catégorie qui le chevauche, sinon : à vérifier sur les images). 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. 6. Pic commun (lot 01 de la boucle NORDEND, 2026-10-26) : au même instant, au moins PIC_MIN cibles s'écartent d'au moins K_PIC bruits de leurs deux mesures voisines, du même côté (toute l'image secouée un pas) : un saut revenu pour chacune, même sous K. Il entre dans les épisodes du point 4 (près d'un saut durable, il ne grise rien). 7. Boucle CLARIDEN, lot 01 (2026-10-26) : un saut jamais revenu ne clôt plus la lecture de la série, son nouveau niveau devient le niveau d'avant ; un épisode qui n'est pas grisé finit à son dernier saut, pas aux retours (ils ne sont plus à griser) ; une cible qui bascule (REPET sauts revenus ou plus, chacun à moins d'un jour du précédent) fait un épisode « back to normal » à elle seule, de la première à la dernière bascule, hors des épisodes communs. Résultats (2026-10-23, K = 20) : - E-001 PS des Coudres : rien (vérité : rien côté sauts). - E-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). - E-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. - E-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. - E-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 vu depuis le 2026-10-24 (2 cibles, première mesure de l'export) ; feuilles, pluie : rien (error_value, pas des sauts). Les trains sont de toute façon attrapés par visibilite (« Passing obstacle ») et le classement y absorbe leurs sauts : ne pas baisser K pour eux (point 12 du plan). - 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é. Pic commun (K_PIC = 6, PIC_MIN = 3, 2026-10-26) : NORDEND, lot du 01 au 04/09 : secousses du 03/09 13:30 (3 cibles) et 16:45 (4) grisées, aussi 01/09 15:45 → 16:00 et 02/09 09:45, mêmes secousses d'un pas pendant la bascule de la caméra ; NORDEND octobre : un pic de 3 cibles le 13/10 12:30, et PR17 (08/10 02:30) groupé avec le pic de 02:15, « 3 targets, 1 stayed shifted », toujours non grisé ; E-002, E-005 : pics absorbés par la toile et les trains ; E-004 : les pics du mouvement (19/09 06:30, 06:50) restent dans le « Lasting shift » ; E-001, E-003 : rien. Point 7 (REPET = 5, 2026-10-26) : CLARIDEN, lot du 18 au 22/09 : PR_BG grisé 19/09 06:40 → 21/09 23:20 (28 bascules de 12 px ; les autres cibles en font 3 au plus) ; le saut seul de D-303-A le 18/09 15:40 vu ; le « Lasting shift » du matin garde 05:40 → 10:30 ; E-001 à E-003, E-005 à E-008 : inchangés. Catégories du terrain (D-074, 2026-10-27) : la cible qui bascule pendant BASCULE au moins, avec SEULES cibles au plus en même temps, devient « Target flipping » (Target issue, plus un saut bref) ; un saut durable d'au moins GROS des cibles, « Large shift » (gros saut : tout a bougé), toujours à vérifier. /detector-learner Target issue, modification 1, S2 : BASCULE de 6 h à 36 h ; une cible qui bascule un jour, pendant une gêne de toute la scène (pluie, brouillard, nuit de mauvaise visibilité), n'est pas une cible à problème (familles.md : des rejets propres presque chaque jour) ; ses sauts revenus vont à la gêne qui les chevauche, sinon restent Displacement. 8. Saut sous K qui reste (boucle NIEDERHORN, lot 01, 2026-10-27 ; K_DURABLE = 7, PALIER = 8) : un saut d'au moins K_DURABLE bruits compte s'il est durable au point 3 et que la médiane du jour d'après s'écarte de celle du jour d'avant, du côté du saut, d'au moins PALIER fois la variation ordinaire du niveau d'un jour UTC au suivant (médiane des écarts entre niveaux journaliers) ; sinon il est ignoré (ni revenu ni trop récent : seuls les sauts de K bruits ou plus le sont). NIEDERHORN : e09, corr_y −0,19 px le 02/10 20:00 (8 bruits, 13 variations ordinaires), « Lasting shift », avec e10 au même instant (corr_x +0,22 px, resté) ; E-001 : rien (cibles saines à 6 variations ordinaires au plus) ; E-004 : le mouvement du 19/09 couvre deux fois plus de mesures à vérifier ; les autres events inchangés. """ import statistics import sys from datetime import timedelta from pathlib import Path sys.path.insert(0, str(Path(__file__).resolve().parent)) # donnees.py, à côté import donnees # noqa: E402 K = 20 # provisoire, réglé sur E-001 : à 15, deux cibles saines y sont grisées (17 et 18 bruits) ; les trains de # E-005 (17 et 19 bruits) sont attrapés par visibilite : ne pas baisser K K_DURABLE = 7 # provisoire : sous K, un saut qui reste compte dès K_DURABLE bruits (boucle NIEDERHORN, lot 01 : e09, # corr_y −0,18 px d'un coup, 8 bruits, resté 5 jours) PALIER = 8 # provisoire : ... s'il reste : médiane du jour d'après, du côté du saut, à PALIER fois la variation # ordinaire du niveau d'un jour au suivant de celle du jour d'avant (e09 : 13 ; E-001, cibles saines : 6 au plus) K_PIC = 6 # provisoire : pic d'un pas commun à plusieurs cibles (secousses de NORDEND, 6 à 11 bruits, lot 01 de la boucle) PIC_MIN = 3 # provisoire : cibles qui piquent au même pas pour un pic commun (une ou deux : bruit ordinaire) 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 (E-002 : paliers jusqu'à 11 h 30) BASCULE = timedelta(hours=36) # provisoire : une cible à problème bascule plusieurs jours (PR_BG : 2,5 jours) ; en moins, # c'est un matin agité (E-009 : C8 et C13, 5 bascules en 1 h 20 pendant le mouvement) ou une nuit de gêne # (NORDEND, JUNGFRAU : 12 à 28 h dans une perte de visibilité), un saut revenu, absorbé par son hôte SEULES = 2 # provisoire : cibles qui basculent en même temps, au plus (FLORIDA : les deux collées ; E-002, toile sur les # références : 15 à la fois) GROS = 0.5 # provisoire : part des cibles d'un saut durable pour un gros saut (E-004 : presque toutes) REPET = 5 # provisoire : sauts revenus d'une même cible, à moins d'un jour l'un de l'autre, qui en font une cible qui # bascule (PR_BG de CLARIDEN, boucle lot 01 : une trentaine en 2,5 jours) 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:])) pas = statistics.median(b - a for a, b in zip(t, t[1:])) # cadence de la série retour = max(1, min(BASE, round(timedelta(hours=1) / pas))) # mesures d'une heure (BASE à 15 min, une à 4 h) # 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) lv = {} # niveau de chaque jour UTC ; sa variation ordinaire d'un jour au suivant juge un saut sous K for x, u in zip(v, t): lv.setdefault(u.date(), []).append(x) lv = [statistics.median(x) for _, x in sorted(lv.items())] ordinaire = statistics.median(abs(b - a) for a, b in zip(lv, lv[1:])) if len(lv) > 2 else 0 # les BASE premières mesures, faute de niveau d'avant, face au niveau d'après : un écart y est revenu aussitôt out = [(k, k, "back") for k in range(min(BASE, len(v) - BASE)) if noise and abs(v[k] - statistics.median(v[k + 1:k + 1 + BASE])) >= K * noise] i = BASE while noise and i < len(v): base = statistics.median(v[i - BASE:i]) if abs(v[i] - base) < K_DURABLE * noise: i += 1 continue tol = abs(v[i] - base) / 2 # revenu : une heure de 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 + retour])), 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 if abs(v[i] - base) < K * noise and (state != "lasting" or (after - before) * (v[i] - base) < 0 or not ordinaire or abs(after - before) < PALIER * ordinaire): i += 1 # sous K, seul compte un saut qui reste : le jour d'après loin du jour d'avant, de son côté continue out.append((i, j - 1, state)) # niveau d'avant refait après le retour ; jamais revenu : le nouveau niveau devient celui d'avant, la suite # reste lue (PR_BG de CLARIDEN, lot 01 : ses bascules après le saut de 10:30 étaient invisibles) i = (j if j < len(v) else i) + BASE return out def _pics(t, v): """Instants où la mesure s'écarte d'au moins K_PIC bruits de ses deux voisines, du même côté (pic d'un pas).""" noise = statistics.median(abs(y - x) for x, y in zip(v, v[1:])) return [t[i] for i in range(1, len(v) - 1) if noise and (v[i] - v[i - 1]) * (v[i] - v[i + 1]) > 0 and min(abs(v[i] - v[i - 1]), abs(v[i] - v[i + 1])) >= K_PIC * noise] def episodes(mesures): """{capteur: [mesure]} (donnees.charger) -> épisodes des sauts, triés par début : Displacement, et Target issue pour une cible qui bascule.""" found = [] # (début, fin, état, capteur) pics = {} # instant -> cibles qui y font un pic d'un pas 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)] for u in _pics(t, v): pics.setdefault(u, set()).add(name) found += [(u, u, "back", s) for u, cs in pics.items() if len(cs) >= PIC_MIN for s in cs] # pic commun : revenu seuls = _bascules(found) # une cible qui saute et revient sans cesse : un épisode à elle seule, hors des communs found = [f for f in found if f[2] != "back" or not any(f[3] in g["sensors"] and g["start"] <= f[0] <= g["end"] for g in seuls)] 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, "last": s, "sensors": {}} groups.append(g) g["end"], g["until"], g["last"] = max(g["end"], e), max(g["until"], e if state == "back" else s), s g["sensors"].setdefault(name, set()).add(state) longues = [g for g in seuls if g["flip"]] # bascules de nombreuses cibles en même temps : la compensation, pas une for g in longues: # cible à problème if sum(h["start"] <= g["end"] and h["end"] >= g["start"] for h in longues) > SEULES: g["flip"] = 0 total = sum(not donnees.est_reference(ms) for ms in mesures.values()) return sorted((_episode(g, total) for g in groups + seuls), key=lambda ep: ep["start"]) def _bascules(found): """Sauts revenus d'une même cible, chacun à moins de BACK_H du précédent : REPET ou plus -> un groupe, de la première à la dernière bascule.""" day, seuls = timedelta(hours=BACK_H), [] for name in {f[3] for f in found}: chain = [] # (début, fin) ; corr_x et corr_y en double : comptés par instant for s, e in sorted({(s, e) for s, e, state, n in found if n == name and state == "back"}) + [(None, None)]: if chain and s is not None and s <= max(c[1] for c in chain) + day: chain.append((s, e)) continue if len({c[0] for c in chain}) >= REPET: seuls.append({"start": chain[0][0], "end": max(c[1] for c in chain), "sensors": {name: {"back"}}, "flip": len({c[0] for c in chain}) if max(c[1] for c in chain) - chain[0][0] >= BASCULE else 0}) chain = [(s, e)] return seuls def _episode(g, total): """Un groupe -> épisode du journal ; un seul saut durable (ou trop récent) suffit à ne pas griser ; une cible qui bascule : « Target flipping » (Target issue, D-074) ; un saut durable de GROS cibles ou plus : « Large shift » (le gros saut, sous-groupe de « À vérifier »).""" 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 g.get("flip"): name = next(iter(g["sensors"])) return {"start": donnees.iso(g["start"]), "end": donnees.iso(g["end"]), "kind": "Target issue", "label": "Target flipping", "text": f"{name} jumped and came back {g['flip']} times: its tracking is not reliable, look at the images " "of the target.", "ignore": True, "sensors": [name], "lasting": []} if lasting and n >= GROS * total: label = "Large shift" text = f"{n} targets jumped together and {lasting} of them stayed shifted: everything moved, please check it." elif 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: the cause is not established, look at the images." end = g["last"] if lasting or recent else g["end"] # pas grisé : le dernier saut, pas les retours return {"start": donnees.iso(g["start"]), "end": donnees.iso(end), "kind": "Displacement", "label": label, "text": text, "ignore": not lasting and not recent, "sensors": sorted(g["sensors"]), "lasting": sorted(s for s, st in g["sensors"].items() if "lasting" in st)} # restées décalées (phrase du journal) def detect(mesures): return sorted([e for e in episodes(mesures) if e["kind"] == "Displacement"] + derive(mesures), key=lambda ep: ep["start"]) # --- Dérive lente --------------------------------------------------------------------------------------------------- # Dérive lente : une cible qui bouge peu à peu, jour après jour. # # Reprend la tendance de l'onglet Displacements (D-055, explore.find_trend) sur l'export « advanced » (corr_x, corr_y, px), # pour que la boucle puisse l'entraîner comme les autres détecteurs. Méthode, par cible (hors références globales) et par # axe (seuils provisoires, ceux de D-055) : # 1. Niveau du jour : médiane des mesures de chaque jour UTC d'au moins HEURES heures mesurées sur 24, en part des heures # que la station mesure (boucle /detector-learner MICHIGAN, modification 1 : à une mesure toutes les 4 h, 5 des 6 # heures ; avant, aucun jour ne comptait) ; au moins JOURS jours. # 2. Pente de Theil-Sen et tau de Kendall des niveaux journaliers ; amplitude du jour : écart entre ses déciles 9 et 1. # 3. Dérive : |pente| × durée ≥ TAILLE fois l'amplitude médiane du jour, |tau| ≥ REGULIER, et aucun pas d'un jour au # suivant de plus de la moitié de la dérive (un saut qui dure n'est pas une dérive : le détecteur sauts le prend). # 4. Un épisode par cible (un axe suffit), de la première mesure du premier jour à la dernière du dernier ; pas grisé. # 4 bis. Par morceaux (/detector-learner Displacement, modification 1, S1) : une cible sans dérive sur toute la fenêtre # peut dériver quelques jours, puis se poser ou repartir en arrière. Sur chaque suite d'au moins JOURS jours retenus, # dérive = niveau du dernier jour moins celui du premier, au moins MORCEAU amplitudes du jour (médiane de la série), # |tau| ≥ REGULIER du même signe, aucun pas d'un jour retenu au suivant de plus de la moitié de la dérive ; les # morceaux pris de la plus grande dérive à la plus petite, sans se chevaucher (ils peuvent partager le jour où le # niveau tourne) : chacun va d'un extrême du niveau à l'autre, un épisode par morceau et par axe. À MORCEAU = 1, les # cycles thermiques de quelques jours et le bruit des niveaux passent (JUNGFRAU, NORDEND) : 3,5 garde les rangées de # CLARIDEN (3,8 à 8,3 amplitudes), écarte JUNGFRAU (3,1 au plus). Les morceaux ne remplacent pas l'étape 3 : à leur # place, la fin des dérives de MICHIGAN et ce que couvraient les tendances de WILDSTRUBEL étaient perdus. # Un morceau ne franchit pas un trou : deux jours retenus qui se suivent sont à TROU jours au plus l'un de l'autre # (modification 2, remarque 1 du contrôle : l'écart d'un niveau à travers trois jours sans mesure est un pas, pas une # pente ; il faisait des morceaux de toute la fenêtre, CLARIDEN 09-28 → 11-01). Un jour manquant ne coupe pas. # 5. Dérive de la caméra (même modification) : au moins GROS des cibles dérivent du même côté sur corr_x ou corr_y, et au # moins GROS des capteurs, références comprises, sur leurs positions brutes x ou y : seuls les morceaux du point 4 bis # sont signalés, pas la tendance de toute la fenêtre (/detector-learner Displacement, modification 1, S2 : la caméra # mal compensée qui dérive, NEBRASKA, est un Displacement pour les étiquettes ; avant, rien n'était signalé). Les # cibles d'un pont qui suivent la saison (JUNGFRAU, étiquetées Thermal displacement jour après jour) passent l'étape 3 # mais pas MORCEAU ; NEBRASKA les deux. BREITHORN (5 capteurs sur 16 en x comme en y) et MICHIGAN ne sont pas # concernées. HEURES = 20 # un jour compte s'il a au moins 20 heures mesurées sur 24 (comme D-055), en part des heures mesurées JOURS = 5 # jours au minimum pour une tendance (TREND_DAYS de D-055) TAILLE = 1.0 # dérive ≥ TAILLE amplitudes journalières (TREND_SIZE de D-055) REGULIER = 0.6 # |tau de Kendall| des niveaux journaliers (TREND_STEADY de D-055) MORCEAU = 3.5 # dérive par morceaux ≥ MORCEAU amplitudes journalières (point 4 bis) TROU = 2 # un morceau ne passe pas d'un jour retenu au suivant à plus de TROU jours (point 4 bis) def _decile(vs, q): vs = sorted(vs) return vs[min(len(vs) - 1, int(q * len(vs)))] def _jours(ms, col): """-> {jour UTC: ses mesures}, les jours retenus (point 1).""" jours = {} for m in ms: if m[col] is not None: jours.setdefault(m["t"].date(), []).append(m) creneaux = len({m["t"].hour for js in jours.values() for m in js}) # heures que la station mesure (6 à 4 h de pas) return {d: js for d, js in jours.items() if len({m["t"].hour for m in js}) >= HEURES / 24 * creneaux} def _derive(ms, col): """-> (dérive en px, jours, premier instant, dernier) ou None.""" jours = _jours(ms, col) if len(jours) < JOURS: return None niv = sorted((d.toordinal(), statistics.median(m[col] for m in js)) for d, js in jours.items()) paires = [(a, b) for k, a in enumerate(niv) for b in niv[k + 1:]] pente = statistics.median((b[1] - a[1]) / (b[0] - a[0]) for a, b in paires) tau = sum((b[1] > a[1]) - (b[1] < a[1]) for a, b in paires) / len(paires) derive = pente * (niv[-1][0] - niv[0][0]) ampl = statistics.median(_decile([m[col] for m in js], 0.9) - _decile([m[col] for m in js], 0.1) for js in jours.values()) pas = max(abs(b[1] - a[1]) for a, b in zip(niv, niv[1:])) if abs(derive) < TAILLE * ampl or abs(tau) < REGULIER or pas > abs(derive) / 2: return None d0, d1 = min(jours), max(jours) return derive, len(jours), min(m["t"] for m in jours[d0]), max(m["t"] for m in jours[d1]) def _morceaux(ms, col): """-> [(dérive en px, jours, premier instant, dernier)] : les morceaux de dérive (point 4 bis).""" jours = _jours(ms, col) if len(jours) < JOURS: return [] ds = sorted(jours) niv = [statistics.median(m[col] for m in jours[d]) for d in ds] ampl = statistics.median(_decile([m[col] for m in js], 0.9) - _decile([m[col] for m in js], 0.1) for js in jours.values()) morceaux = [] # (dérive, i, j) for i in range(len(ds)): signes = pas = 0 for j in range(i + 1, len(ds)): if (ds[j] - ds[j - 1]).days > TROU: break # un écart à travers un trou est un pas (le détecteur des sauts le prend), pas une pente signes += sum((niv[j] > niv[k]) - (niv[j] < niv[k]) for k in range(i, j)) # tau de Kendall, pas à pas pas = max(pas, abs(niv[j] - niv[j - 1])) n, d = j - i + 1, niv[j] - niv[i] if n >= JOURS and d and abs(d) >= MORCEAU * ampl and pas <= abs(d) / 2 \ and signes * (1 if d > 0 else -1) >= REGULIER * n * (n - 1) / 2: morceaux.append((d, i, j)) pris = [] for d, i, j in sorted(morceaux, key=lambda x: (-abs(x[0]), x[2] - x[1])): if all(j <= a or i >= b for _, a, b in pris): pris.append((d, i, j)) return [(d, j - i + 1, min(m["t"] for m in jours[ds[i]]), max(m["t"] for m in jours[ds[j]])) for d, i, j in pris] def _commune(mesures, cols): """Au moins GROS des capteurs dérivent du même côté sur un même axe de cols.""" for col in cols: signes = [x[0] > 0 for ms in mesures.values() if (x := _derive(ms, col))] if max(signes.count(True), signes.count(False)) >= GROS * len(mesures): return True return False def derive(mesures): cibles = {s: ms for s, ms in mesures.items() if not donnees.est_reference(ms)} camera = _commune(cibles, ("corr_x", "corr_y")) and _commune(mesures, ("x", "y")) # point 5 : morceaux seuls out = [] for s, ms in sorted(mesures.items()): if donnees.est_reference(ms): continue r = [] if camera else [x for col in ("corr_x", "corr_y") if (x := _derive(ms, col))] r = [max(r, key=lambda x: abs(x[0]))] if r else [x for col in ("corr_x", "corr_y") for x in _morceaux(ms, col)] out += [{"start": donnees.iso(a), "end": donnees.iso(b), "kind": "Displacement", "label": "Slow drift", "text": f"{s} drifts slowly and steadily: {derive:+.2f} px in {n} days. Keep watching it.", "ignore": False, "sensors": [s]} for derive, n, a, b in r] return out 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"])