Les outils dans scripts/ ; guide, README et CLAUDE.md suivent
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
f1448bc5cb
commit
67c88625c5
15 files changed
+31
-31
No files matched your search
@@ -0,0 +1,491 @@
|
||||
"""Vue d'ensemble de tous les capteurs d'un export « advanced » : ce que font les capteurs ensemble.
|
||||
|
||||
Usage : .venv/bin/python tools/scripts/ensemble.py data/PS_DES_COUDRES/
|
||||
[--colonnes x,y,sigma0] [--colonne error_value] [--pas 15min] [--k 5] [--min 5]
|
||||
[--residus corr_x,corr_y,error_value] [--hors T1/T2] [--autres] [--rigide BASE [--sans A,B] [--suivre A,B]] [--table T1/T2|non] [--capteurs A,B] [--debut ...] [--fin ...] [--sortie DOSSIER]
|
||||
|
||||
Chaque capteur est comparé à son propre niveau sur la fenêtre --debut/--fin (médiane et MAD de la fenêtre).
|
||||
Deux PNG, dont les chemins sont imprimés :
|
||||
1. « commun » : d'abord, si le dossier a des mouvements de la caméra (camera/), un panneau par grandeur de la pose
|
||||
(pan, tilt, rotation [deg], scale, sigma0 du recalage), valeurs brutes, un point par recalage ; puis un panneau par colonne de --colonnes (défaut x,y,sigma0 : position brute et sigma0 de la
|
||||
caméra) : médiane, sur les capteurs, de l'écart de chaque capteur à sa médiane ; bande grise = 10e à 90e
|
||||
centile entre capteurs (la dispersion) ; sur chaque panneau sauf sigma0, en plus, chaque référence globale à part
|
||||
(son écart à sa médiane, un trait par référence) et la médiane des cibles seules (trait noir) : on voit si les
|
||||
références bougent dans l'image avec les cibles ou sans elles ; dernier panneau : nombre de capteurs dont --colonne
|
||||
(défaut error_value) dépasse sa médiane de plus de --k MAD à chaque pas.
|
||||
2. « multiples » : un petit graphique par capteur (références d'abord) de --colonne, médiane par pas de --pas,
|
||||
trait pointillé = médiane de la fenêtre ; chaque graphique a son échelle, un palier se voit.
|
||||
3. « residus-<colonne> » (un PNG par colonne de --residus, défaut corr_x,corr_y,error_value) : un petit graphique par
|
||||
capteur de la colonne moins le niveau propre du capteur (sa médiane sur la fenêtre, ou hors de --hors T1/T2 si
|
||||
donné : le niveau est alors celui du reste de la fenêtre, pas celui du moment lu), une échelle par capteur, zéro en
|
||||
pointillé ; un écart de quelques centièmes sur une colonne `corr` que les bandes parallèles de `graphique.py` cachent
|
||||
s'y voit. Imprime, par capteur, le niveau, le bruit propre (médiane des écarts entre deux mesures consécutives) et
|
||||
l'écart minimum et maximum de la médiane par pas de --pas, avec leur instant, en unités de la colonne et en bruits
|
||||
(bruit 0 et « - » en bruits : valeurs constantes à l'arrondi près, 1e-9 ; --residus non : aucun PNG de résidus).
|
||||
Avec --autres, chaque capteur est de plus ramené à l'écart à la médiane des AUTRES capteurs au même instant (on
|
||||
retranche, à chaque mesure, la médiane des autres capteurs de la même colonne moins leur niveau propre) : ce qui est
|
||||
partagé par tous (le reste de la compensation d'un mouvement commun) s'annule, ce qui est propre au capteur reste.
|
||||
PNG « residus-<colonne>-autres » ; la table imprime en plus, par capteur, la pente de ce résidu sur chaque
|
||||
colonne de --colonnes (médiane commune, ex. y) et la corrélation r : un résidu proportionnel au mouvement commun
|
||||
(même s'il n'est pas partagé par tous) a une pente non nulle et un r élevé.
|
||||
4. « rigide » (avec --rigide BASE) : à chaque mesure, le mouvement d'ensemble des cibles depuis l'instant BASE
|
||||
(similitude : translation, rotation, échelle, estimée par médianes sur les cibles, hors --sans) ; pour chaque
|
||||
capteur, le résidu dx, dy = position brute moins sa position à BASE transportée par ce mouvement [px]. Panneaux :
|
||||
dx et dy de chaque référence globale (un trait chacune) face à la médiane et au 10e-90e centile des cibles ;
|
||||
médiane et 90e centile de |résidu| des cibles ; rotation et échelle ajustées ; reproj_err des références. Imprime
|
||||
la table par pas de --pas (rot_deg, echelle, tx, ty, cib_med, cib_max, puis dx, dy de chaque référence et de chaque
|
||||
capteur de --suivre A,B), puis par capteur le min et le max de dx, dy avec leur instant et la valeur au dernier
|
||||
instant. Les mesures rejetées n'entrent ni dans l'ajustement, ni dans la bande et la médiane des cibles, cib_med,
|
||||
cib_max, ni dans les colonnes de la table ; sur le PNG, celles des références sont des croix, qui ne fixent pas l'échelle ; dans le résumé par
|
||||
capteur, elles viennent à part (nombre, min et max).
|
||||
Imprime aussi la table de la médiane commune (une ligne par pas de --pas : heure, écart à la médiane de la fenêtre
|
||||
pour chaque colonne de --colonnes, puis <colonne>_cibles, la médiane des cibles seules, puis la pose brute de la caméra, vide sans recalage) puis le minimum et le maximum de chaque colonne avec leur instant, et ceux de chaque référence globale ; pour dater
|
||||
un début ou une fin, la table est au pas de --pas (défaut 15min, la cadence des mesures ; un pas plus large,
|
||||
1h par ex., aplatit un pic d'un à quatre pas et date à l'heure).
|
||||
Imprime aussi, pour chaque instant où au moins --min capteurs dépassent leur médiane de plus de --k MAD,
|
||||
le nombre et les capteurs (--min 1 : aussi les instants où un seul capteur sort de son niveau), et les instants de
|
||||
mesure sans pose de la caméra (pas de recalage).
|
||||
Les tables par pas (médiane commune, --rigide) répètent leur en-tête toutes les 24 lignes. Avec --table T1/T2, elles ne
|
||||
s'impriment qu'entre T1 et T2 (« non » : pas du tout) ; niveaux, minimum et maximum, PNG et le reste portent toujours sur
|
||||
toute la fenêtre --debut/--fin : sur un mois, on lit tout le reste, puis la table d'un jour aux mêmes niveaux.
|
||||
Rend des valeurs, pas de verdict.
|
||||
"""
|
||||
import argparse
|
||||
import math
|
||||
import os
|
||||
import statistics
|
||||
import sys
|
||||
|
||||
import matplotlib
|
||||
|
||||
matplotlib.use("Agg")
|
||||
import matplotlib.dates as mdates # noqa: E402
|
||||
import matplotlib.pyplot as plt # noqa: E402
|
||||
|
||||
from donnees import POSE, charger, charger_camera, est_reference, filtrer, instant, iso, rejetee # noqa: E402
|
||||
from graphique import COLONNES, borne # noqa: E402
|
||||
from resume import bruit_propre, duree # noqa: E402
|
||||
|
||||
|
||||
def niveau(ms, col):
|
||||
"""(médiane, MAD) des valeurs non vides ; None si aucune."""
|
||||
v = [m[col] for m in ms if m[col] is not None]
|
||||
if not v:
|
||||
return None
|
||||
med = statistics.median(v)
|
||||
return med, statistics.median(abs(x - med) for x in v)
|
||||
|
||||
|
||||
def similitude(p, q):
|
||||
"""Similitude (a, b, tx, ty) qui envoie les points p sur q : q ≈ (a·x − b·y + tx, b·x + a·y + ty).
|
||||
|
||||
Estimation par médianes (une cible qui saute seule ne tire pas l'ajustement) : rotation et échelle, médiane sur
|
||||
toutes les paires de cibles du rapport complexe (qi − qj) / (pi − pj) ; translation, médiane de q − (rotation, échelle)·p.
|
||||
"""
|
||||
p, q = [complex(*u) for u in p], [complex(*u) for u in q]
|
||||
z = [(q[i] - q[j]) / (p[i] - p[j]) for i in range(len(p)) for j in range(i) if p[i] != p[j]]
|
||||
r = complex(statistics.median(v.real for v in z), statistics.median(v.imag for v in z))
|
||||
d = [w - r * u for u, w in zip(p, q)]
|
||||
return r.real, r.imag, statistics.median(v.real for v in d), statistics.median(v.imag for v in d)
|
||||
|
||||
|
||||
def rigide(o, noms, series, temps, base, station):
|
||||
"""4. Chaque capteur face au mouvement d'ensemble des cibles depuis l'instant --rigide : PNG « rigide » et table."""
|
||||
t_b = min(temps, key=lambda t: abs(t - o.rigide))
|
||||
pos = {s: {m["t"]: (m["x"], m["y"]) for m in series[s] if m["x"] is not None and m["y"] is not None} for s in noms}
|
||||
sans = set(o.sans.split(",")) - {""}
|
||||
acc = {s: {m["t"] for m in series[s] if not rejetee(m)} for s in noms} # mesures acceptées : seules à entrer dans l'ajustement et les statistiques des cibles
|
||||
refs = [s for s in noms if series[s] and est_reference(series[s])]
|
||||
cib = [s for s in noms if s not in refs and t_b in pos[s]]
|
||||
ajust = [s for s in cib if s not in sans and t_b in acc[s]]
|
||||
suivis = [s for s in o.suivre.split(",") if s and s not in refs]
|
||||
res, fit = {s: {} for s in noms}, {} # res : {capteur: {t: (dx, dy)}} ; fit : {t: (rotation deg, échelle, tx, ty, |r| médiane, max des cibles)}
|
||||
for t in temps:
|
||||
ok = [s for s in ajust if t in pos[s] and t in acc[s]]
|
||||
if len(ok) < 2:
|
||||
continue
|
||||
a, b, tx, ty = similitude([pos[s][t_b] for s in ok], [pos[s][t] for s in ok])
|
||||
for s in noms:
|
||||
if t in pos[s] and t_b in pos[s]:
|
||||
(x0, y0), (x, y) = pos[s][t_b], pos[s][t]
|
||||
res[s][t] = (x - (a * x0 - b * y0 + tx), y - (b * x0 + a * y0 + ty))
|
||||
r = [math.hypot(*res[s][t]) for s in cib if t in res[s] and t in acc[s]]
|
||||
fit[t] = (math.degrees(math.atan2(b, a)), math.hypot(a, b), tx, ty, statistics.median(r), max(r))
|
||||
if not fit:
|
||||
print(f"\n--rigide : moins de deux cibles avec x, y à {iso(t_b)} et ensuite.")
|
||||
return
|
||||
tf = sorted(fit)
|
||||
reproj = {s: {m["t"]: m["reproj_err"] for m in series[s] if m["reproj_err"] is not None} for s in refs}
|
||||
panneaux = [("dx", 0), ("dy", 1)]
|
||||
fig, axes = plt.subplots(6, 1, sharex=True, figsize=(14, 18), squeeze=False)
|
||||
for ax, (nom, k) in zip(axes[:2, 0], panneaux):
|
||||
band = [sorted(res[s][t][k] for s in cib if t in res[s] and t in acc[s]) for t in tf]
|
||||
q = [statistics.quantiles(v, n=10, method="inclusive") if len(v) >= 2 else [v[0]] * 9 for v in band]
|
||||
ax.fill_between(tf, [x[0] for x in q], [x[-1] for x in q], color="0.85", label="cibles : 10e-90e centile")
|
||||
ax.plot(tf, [statistics.median(v) for v in band], "-", lw=1.2, color="k", label="cibles : médiane")
|
||||
for i, s in enumerate(refs):
|
||||
ta = [t for t in res[s] if t in acc[s]]
|
||||
ax.plot(ta, [res[s][t][k] for t in ta], "-", lw=0.9, color=f"C{(i + 1) % 10}", label=f"{s} (réf.)")
|
||||
cadre = ax.get_ylim() # l'échelle des mesures acceptées : une référence rejetée loin est hors cadre
|
||||
for i, s in enumerate(refs):
|
||||
tr = [t for t in res[s] if t not in acc[s]]
|
||||
if tr: # mesures rejetées : à part, une croix chacune, hors du trait
|
||||
ax.plot(tr, [res[s][t][k] for t in tr], "x", ms=3, color=f"C{(i + 1) % 10}", label=f"{s} rejetée")
|
||||
ax.set_ylim(cadre)
|
||||
ax.set_ylabel(f"{nom} [px]\nposition brute moins\nle mouvement des cibles")
|
||||
ax.legend(loc="upper left", fontsize=8, ncol=1 + len(refs) // 4)
|
||||
axes[2, 0].plot(tf, [fit[t][4] for t in tf], "-", lw=1, color="k", label="cibles : médiane de |résidu|")
|
||||
p90 = {t: statistics.quantiles([math.hypot(*res[s][t]) for s in cib if t in res[s] and t in acc[s]], n=10, method="inclusive")[-1] for t in tf}
|
||||
axes[2, 0].plot(tf, [p90[t] for t in tf], "-", lw=0.8, color="C3", label="cibles : 90e centile de |résidu| (le max est dans la table)")
|
||||
axes[2, 0].set_ylabel("|résidu| des cibles [px]")
|
||||
axes[2, 0].legend(loc="upper left", fontsize=8)
|
||||
axes[3, 0].plot(tf, [fit[t][0] for t in tf], "-", lw=1, color="C2")
|
||||
axes[3, 0].set_ylabel("rotation ajustée [deg]")
|
||||
axes[4, 0].plot(tf, [fit[t][1] for t in tf], "-", lw=1, color="C2")
|
||||
axes[4, 0].set_ylabel("échelle ajustée")
|
||||
for i, s in enumerate(refs):
|
||||
axes[5, 0].plot(list(reproj[s]), list(reproj[s].values()), "-", lw=0.9, color=f"C{(i + 1) % 10}", label=f"{s} (réf.)")
|
||||
axes[5, 0].set_ylabel("reproj_err\ndes références")
|
||||
if refs:
|
||||
axes[5, 0].legend(loc="upper left", fontsize=8, ncol=1 + len(refs) // 4)
|
||||
for ax in axes[:, 0]:
|
||||
ax.grid(alpha=0.4)
|
||||
ax.axvline(t_b, color="C3", ls=":", lw=0.8)
|
||||
axes[-1, 0].set_xlim(tf[0], tf[-1])
|
||||
axes[-1, 0].xaxis.set_major_formatter(mdates.DateFormatter("%d/%m\n%H:%MZ"))
|
||||
fig.suptitle(f"{station} : mouvement d'ensemble (translation, rotation, échelle) ajusté sur {len(ajust)} cibles depuis {iso(t_b)} (pointillé), "
|
||||
"résidu de chaque capteur, mesures acceptées (croix : référence rejetée) (heures UTC)")
|
||||
fig.tight_layout(rect=(0, 0, 1, 1 - 0.4 / fig.get_figheight()))
|
||||
chemin = base.format("rigide")
|
||||
fig.savefig(chemin, dpi=100, bbox_inches="tight")
|
||||
plt.close(fig)
|
||||
print(chemin)
|
||||
|
||||
print(f"\nMouvement d'ensemble ajusté sur les cibles depuis {iso(t_b)} : {', '.join(ajust)}"
|
||||
+ (f" (hors ajustement : {', '.join(sorted(sans & set(cib)))})" if sans & set(cib) else "")
|
||||
+ f".\nRésidu = position brute moins la position de {iso(t_b)} transportée par ce mouvement [px] ; mesures rejetées hors de l'ajustement, "
|
||||
f"de cib_med, cib_max et des colonnes des capteurs (à part dans le résumé par capteur) ; médiane par pas de {int(o.pas.total_seconds() // 60)} min{' (table : ' + o.table + ')' if o.table else ''} :")
|
||||
cols = ["rot_deg", "echelle", "tx", "ty", "cib_med", "cib_max"] + [f"{s}_{c}" for s in refs + suivis for c in ("dx", "dy")]
|
||||
minuit = tf[0].replace(hour=0, minute=0, second=0, microsecond=0)
|
||||
t0 = minuit + ((tf[0] - minuit) // o.pas) * o.pas
|
||||
par_pas = {}
|
||||
for t in tf:
|
||||
ligne = par_pas.setdefault(t0 + ((t - t0) // o.pas) * o.pas, {})
|
||||
for c, v in zip(cols, fit[t]):
|
||||
ligne.setdefault(c, []).append(v)
|
||||
for s in refs + suivis:
|
||||
if t in res[s] and t in acc[s]:
|
||||
ligne.setdefault(f"{s}_dx", []).append(res[s][t][0]), ligne.setdefault(f"{s}_dy", []).append(res[s][t][1])
|
||||
w = max(10, max(len(c) for c in cols) + 1)
|
||||
entete = f"{'instant':17}" + "".join(f"{c:>{w}}" for c in cols)
|
||||
for i, t in enumerate(t for t in sorted(par_pas) if o.dans_table(t)):
|
||||
if i % 24 == 0:
|
||||
print(entete)
|
||||
print(f"{iso(t):17}" + "".join(f"{statistics.median(par_pas[t][c]):{w}.{7 if c == 'echelle' else 3}g}" if c in par_pas[t] else " " * w for c in cols))
|
||||
print("\nPar capteur, mesures acceptées : min et max de dx, dy, valeur au dernier instant ; puis les rejetées à part :")
|
||||
for s in noms:
|
||||
bons = {t: v for t, v in res[s].items() if t in acc[s]}
|
||||
rej = {t: v for t, v in res[s].items() if t not in acc[s]}
|
||||
for k, c in ((0, "dx"), (1, "dy")):
|
||||
ligne = f"{s:9}{' (réf.)' if s in refs else ' '} {c}"
|
||||
if bons:
|
||||
lo, hi = min(bons.items(), key=lambda x: x[1][k]), max(bons.items(), key=lambda x: x[1][k])
|
||||
der = res[s].get(tf[-1])
|
||||
ligne += (f" min {lo[1][k]:+.3g} à {iso(lo[0])}, max {hi[1][k]:+.3g} à {iso(hi[0])}, au dernier instant "
|
||||
f"{der[k] if der else math.nan:+.3g}{' (rejetée)' if der and tf[-1] not in acc[s] else ''}")
|
||||
else:
|
||||
ligne += " aucune mesure acceptée"
|
||||
if rej:
|
||||
lo, hi = min(rej.items(), key=lambda x: x[1][k]), max(rej.items(), key=lambda x: x[1][k])
|
||||
ligne += f" ; {len(rej)} rejetées : min {lo[1][k]:+.3g} à {iso(lo[0])}, max {hi[1][k]:+.3g} à {iso(hi[0])}"
|
||||
if bons or rej:
|
||||
print(ligne)
|
||||
|
||||
|
||||
def main():
|
||||
a = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
|
||||
a.add_argument("dossier")
|
||||
a.add_argument("--colonnes", default="x,y,sigma0")
|
||||
a.add_argument("--colonne", default="error_value", choices=COLONNES)
|
||||
a.add_argument("--pas", default="15min", type=duree, help="pas des tables et des courbes en bleu (défaut 15min, la cadence des mesures : un pas plus large aplatit et décale les événements courts)")
|
||||
a.add_argument("--k", type=float, default=5, help="écart compté, en MAD de la fenêtre")
|
||||
a.add_argument("--min", type=int, default=5, help="nombre de capteurs à partir duquel un instant est imprimé")
|
||||
a.add_argument("--residus", default="corr_x,corr_y,error_value", help="colonnes tracées moins le niveau propre de chaque capteur (« non » ou '' : aucune)")
|
||||
a.add_argument("--hors", help="T1/T2 : le niveau propre des résidus se calcule hors de ce moment")
|
||||
a.add_argument("--autres", action="store_true", help="résidus de plus ramenés à la médiane des autres capteurs au même instant, avec pente et corrélation sur le mouvement commun")
|
||||
a.add_argument("--rigide", type=instant, metavar="BASE", help="résidus face au mouvement d'ensemble des cibles (translation, rotation, échelle) depuis l'instant BASE")
|
||||
a.add_argument("--sans", default="", help="A,B : cibles laissées hors de l'ajustement de --rigide (leur résidu reste tracé)")
|
||||
a.add_argument("--suivre", default="", help="A,B : avec --rigide, dx, dy de ces capteurs ajoutés à la table au pas (les références y sont déjà)")
|
||||
a.add_argument("--table", default="", metavar="T1/T2|non",
|
||||
help="tables par pas imprimées seulement entre T1 et T2 (« non » : pas du tout) ; le reste sur toute la fenêtre")
|
||||
a.add_argument("--capteurs", help="liste séparée par des virgules (défaut : tous)")
|
||||
a.add_argument("--debut", type=instant)
|
||||
a.add_argument("--fin", type=instant)
|
||||
a.add_argument("--sortie", default=os.path.join("out", "diagnostic"), help="dossier des PNG")
|
||||
o = a.parse_args()
|
||||
|
||||
par = charger(o.dossier)
|
||||
if not par:
|
||||
sys.exit(f"Aucun export « advanced » dans {o.dossier} (voir inventaire.py).")
|
||||
noms = o.capteurs.split(",") if o.capteurs else sorted(par, key=lambda s: (not est_reference(par[s]), s))
|
||||
colonnes = o.colonnes.split(",")
|
||||
residus = [c for c in o.residus.split(",") if c and c != "non"] # '' ou « non » : aucune, comme --table
|
||||
hors = tuple(instant(x) for x in o.hors.split("/")) if o.hors else None
|
||||
if hors and len(hors) != 2:
|
||||
sys.exit("--hors attend T1/T2.")
|
||||
if o.table in ("", "non"):
|
||||
o.dans_table = lambda t: o.table == ""
|
||||
else:
|
||||
bornes = [instant(x) for x in o.table.split("/")]
|
||||
if len(bornes) != 2:
|
||||
sys.exit("--table attend T1/T2 ou non.")
|
||||
o.dans_table = lambda t: bornes[0] <= t <= bornes[1]
|
||||
for demandes, connus, quoi in ((noms, par, "Capteurs"), ([s for s in o.suivre.split(",") if s], noms, "Capteurs de --suivre (pris parmi --capteurs)"), (colonnes + residus + [o.colonne], COLONNES, "Colonnes")):
|
||||
absents = [x for x in demandes if x not in connus]
|
||||
if absents:
|
||||
sys.exit(f"{quoi} inconnus : {', '.join(absents)}. Connus : {', '.join(sorted(connus))}.")
|
||||
series = {s: filtrer(par[s], o.debut, o.fin) for s in noms}
|
||||
if not any(series.values()):
|
||||
sys.exit("Aucune mesure dans la fenêtre demandée.")
|
||||
temps = sorted({m["t"] for s in noms for m in series[s]})
|
||||
poses = filtrer(charger_camera(o.dossier), temps[0].replace(second=0, microsecond=0), temps[-1]) # poses à la minute, mesures à la seconde
|
||||
pose_cols = POSE if poses else ()
|
||||
station = os.path.basename(os.path.normpath(o.dossier))
|
||||
os.makedirs(o.sortie, exist_ok=True)
|
||||
base = os.path.join(o.sortie, f"{station}_{{}}_{borne(o.debut, 'debut')}_{borne(o.fin, 'fin')}.png")
|
||||
|
||||
def ecarts(col):
|
||||
"""{capteur: {t: valeur - médiane de la fenêtre}}, et les MAD."""
|
||||
e, mad = {}, {}
|
||||
for s in noms:
|
||||
n = niveau(series[s], col)
|
||||
if n:
|
||||
e[s] = {m["t"]: m[col] - n[0] for m in series[s] if m[col] is not None}
|
||||
mad[s] = n[1]
|
||||
return e, mad
|
||||
|
||||
# 1. commun
|
||||
n_ax = len(pose_cols) + len(colonnes) + 1
|
||||
fig, axes = plt.subplots(n_ax, 1, sharex=True, figsize=(14, 3 * n_ax), squeeze=False)
|
||||
for ax, col in zip(axes[:, 0], pose_cols):
|
||||
pose_t = {p["t"].replace(second=0, microsecond=0): p[col] for p in poses if p[col] is not None}
|
||||
cam_t = sorted(set(pose_t) | {t.replace(second=0, microsecond=0) for t in temps})
|
||||
# trait coupé aux instants de mesure sans recalage : il ne relie pas deux poses par-dessus un trou
|
||||
ax.plot(cam_t, [pose_t.get(t, math.nan) for t in cam_t], ".-", ms=3, lw=0.5, color="C2", label="pose de la caméra (un point par recalage)")
|
||||
ax.set_ylabel(f"caméra : {col}" + (" [deg]" if col in ("pan", "tilt", "rotation") else ""))
|
||||
ax.legend(loc="upper left", fontsize=8)
|
||||
communes, refs_par_col, ref_ecarts = {}, {}, {}
|
||||
for ax, col in zip(axes[len(pose_cols):, 0], colonnes):
|
||||
e, _ = ecarts(col)
|
||||
med, bas, haut, tt = [], [], [], []
|
||||
for t in temps:
|
||||
v = sorted(e[s][t] for s in e if t in e[s])
|
||||
if len(v) >= 2:
|
||||
q = statistics.quantiles(v, n=10, method="inclusive")
|
||||
tt.append(t), med.append(statistics.median(v)), bas.append(q[0]), haut.append(q[-1])
|
||||
communes[col] = dict(zip(tt, med))
|
||||
ax.fill_between(tt, bas, haut, color="0.85", label="10e-90e centile entre capteurs")
|
||||
ax.plot(tt, med, ".-", ms=2, lw=0.8, label="médiane des capteurs")
|
||||
refs = [s for s in e if est_reference(series[s])]
|
||||
if refs and col != "sigma0": # sigma0 est le même pour tous : rien à séparer
|
||||
# références globales une à une, et médiane des seules cibles : qui bouge dans l'image, les références ou tout
|
||||
cib = {}
|
||||
for t in temps:
|
||||
v = [e[s][t] for s in e if s not in refs and t in e[s]]
|
||||
if v:
|
||||
cib[t] = statistics.median(v)
|
||||
communes[col + "_cibles"] = cib
|
||||
ax.plot(list(cib), list(cib.values()), "-", lw=1.2, color="k", label="médiane des cibles seules")
|
||||
for i, s in enumerate(refs):
|
||||
ax.plot(list(e[s]), list(e[s].values()), "-", lw=0.9, color=f"C{(i + 1) % 10}", label=f"{s} (réf.)")
|
||||
refs_par_col[col] = refs
|
||||
ref_ecarts[col] = {s: e[s] for s in refs}
|
||||
ax.set_ylabel(f"{col}\nécart à sa médiane")
|
||||
ax.grid(alpha=0.3)
|
||||
ax.legend(loc="upper left", fontsize=8, ncol=1 + len(refs_par_col.get(col, [])) // 4)
|
||||
e, mad = ecarts(o.colonne)
|
||||
compte, qui = [], {}
|
||||
for t in temps:
|
||||
hauts = [s for s in e if t in e[s] and mad[s] > 0 and e[s][t] > o.k * mad[s]]
|
||||
compte.append(len(hauts))
|
||||
if len(hauts) >= o.min:
|
||||
qui[t] = hauts
|
||||
axes[-1, 0].step(temps, compte, where="mid", lw=0.8)
|
||||
axes[-1, 0].set_ylabel(f"capteurs au-dessus\nde médiane + {o.k:g} MAD\n({o.colonne})")
|
||||
axes[-1, 0].grid(alpha=0.3)
|
||||
h = next((h for h in (1, 2, 3, 6, 12) if (temps[-1] - temps[0]).total_seconds() / 3600 / h <= 20), 24)
|
||||
jours = (temps[-1] - temps[0]).total_seconds() / 86400
|
||||
# au-delà de 20 jours, une graduation par jour se chevauche : tous les n jours, au plus 20 graduations
|
||||
axes[-1, 0].xaxis.set_major_locator(mdates.HourLocator(byhour=range(0, 24, h)) if h < 24 else mdates.DayLocator(interval=math.ceil(jours / 20)))
|
||||
axes[-1, 0].set_xlim(temps[0], temps[-1])
|
||||
axes[-1, 0].xaxis.set_major_formatter(mdates.DateFormatter("%d/%m\n%H:%MZ"))
|
||||
for ax in axes[:, 0]:
|
||||
ax.grid(alpha=0.5, which="major")
|
||||
fig.suptitle(f"{station} : {len(e)} capteurs ensemble, chacun face à son niveau sur la fenêtre (heures UTC)")
|
||||
fig.tight_layout(rect=(0, 0, 1, 1 - 0.4 / fig.get_figheight())) # place du titre
|
||||
commun = base.format("commun")
|
||||
fig.savefig(commun, dpi=100, bbox_inches="tight")
|
||||
plt.close(fig)
|
||||
print(commun)
|
||||
|
||||
# table de la médiane commune, par pas
|
||||
minuit = temps[0].replace(hour=0, minute=0, second=0, microsecond=0)
|
||||
t0 = minuit + ((temps[0] - minuit) // o.pas) * o.pas # pas calés sur l'horloge (hh:00, hh:15…), pas sur la 1re mesure
|
||||
lignes_t = {}
|
||||
for col in colonnes:
|
||||
for t, v in communes[col].items():
|
||||
lignes_t.setdefault(t0 + ((t - t0) // o.pas) * o.pas, {}).setdefault(col, []).append(v)
|
||||
for col in pose_cols:
|
||||
communes["cam_" + col] = {p["t"]: p[col] for p in poses if p[col] is not None}
|
||||
for t, v in communes["cam_" + col].items():
|
||||
lignes_t.setdefault(t0 + ((t - t0) // o.pas) * o.pas, {}).setdefault("cam_" + col, []).append(v)
|
||||
for col in refs_par_col:
|
||||
for t, v in communes[col + "_cibles"].items():
|
||||
lignes_t.setdefault(t0 + ((t - t0) // o.pas) * o.pas, {}).setdefault(col + "_cibles", []).append(v)
|
||||
cols_t = colonnes + [c + "_cibles" for c in refs_par_col] + ["cam_" + c for c in pose_cols]
|
||||
print(f"\nMédiane commune (écart à la médiane de la fenêtre){' et pose brute de la caméra (cam_, vide sans recalage)' if pose_cols else ''}, "
|
||||
f"médiane par pas de {int(o.pas.total_seconds() // 60)} min{' (table : ' + o.table + ')' if o.table else ''} :")
|
||||
entete = f"{'instant':17}" + "".join(f"{c:>13}" for c in cols_t)
|
||||
for i, t in enumerate(t for t in sorted(lignes_t) if o.dans_table(t)):
|
||||
if i % 24 == 0:
|
||||
print(entete)
|
||||
print(f"{iso(t):17}" + "".join(f"{statistics.median(lignes_t[t][c]):13.{6 if c.startswith('cam_') else 4}g}" if c in lignes_t[t] else " " * 13 for c in cols_t))
|
||||
for col in cols_t:
|
||||
if communes[col]:
|
||||
lo, hi = min(communes[col].items(), key=lambda x: x[1]), max(communes[col].items(), key=lambda x: x[1])
|
||||
g = 6 if col.startswith("cam_") else 4
|
||||
print(f"{col} (mesures) : min {lo[1]:.{g}g} à {iso(lo[0])}, max {hi[1]:.{g}g} à {iso(hi[0])}")
|
||||
|
||||
for col, refs in refs_par_col.items():
|
||||
print(f"\n{col} brut des références globales, écart à leur médiane de la fenêtre (mesures) ; {col}_cibles : médiane des cibles seules :")
|
||||
for s in refs:
|
||||
d = ref_ecarts[col][s]
|
||||
lo, hi = min(d.items(), key=lambda x: x[1]), max(d.items(), key=lambda x: x[1])
|
||||
rej = {m["t"] for m in series[s] if rejetee(m)}
|
||||
r = lambda t: " (rejetée)" if t in rej else ""
|
||||
print(f"{s:9} min {lo[1]:+.3g} à {iso(lo[0])}{r(lo[0])}, max {hi[1]:+.3g} à {iso(hi[0])}{r(hi[0])}"
|
||||
+ (f" ; {len(rej)} mesures rejetées dans la fenêtre" if rej else ""))
|
||||
if not pose_cols:
|
||||
print("Pose de la caméra : aucune dans la fenêtre (pas de camera/ dans le dossier, ou pas de recalage).")
|
||||
else:
|
||||
avec = {p["t"].replace(second=0, microsecond=0) for p in poses}
|
||||
suites = [] # suites d'instants de mesure consécutifs sans pose : [début, fin, nombre]
|
||||
for i, t in enumerate(temps):
|
||||
if t.replace(second=0, microsecond=0) in avec:
|
||||
continue
|
||||
if suites and suites[-1][3] == i - 1:
|
||||
suites[-1][1], suites[-1][2], suites[-1][3] = t, suites[-1][2] + 1, i
|
||||
else:
|
||||
suites.append([t, t, 1, i])
|
||||
print(f"Instants de mesure sans pose de la caméra (pas de recalage) : {sum(x[2] for x in suites)} sur {len(temps)}"
|
||||
+ (" : " + "; ".join(iso(a) if n == 1 else f"{iso(a)} → {iso(b)} ({n})" for a, b, n, _ in suites) if suites else ""))
|
||||
|
||||
# 2. petits multiples
|
||||
col = o.colonne
|
||||
n = len(noms)
|
||||
lignes = math.ceil(n / 5)
|
||||
fig, axes = plt.subplots(lignes, 5, sharex=True, figsize=(18, 2.5 * lignes), squeeze=False)
|
||||
for ax, s in zip(axes.flat, noms):
|
||||
ms = [m for m in series[s] if m[col] is not None]
|
||||
ax.plot([m["t"] for m in ms], [m[col] for m in ms], "-", lw=0.4, color="0.7")
|
||||
pas = {}
|
||||
for m in ms:
|
||||
pas.setdefault(t0 + ((m["t"] - t0) // o.pas) * o.pas, []).append(m[col])
|
||||
ax.plot(list(pas), [statistics.median(v) for v in pas.values()], "-", lw=1.1, color="C0")
|
||||
lv = niveau(series[s], col)
|
||||
if lv:
|
||||
ax.axhline(lv[0], color="C3", ls=":", lw=0.8)
|
||||
ax.set_title(s + (" (réf.)" if series[s] and est_reference(series[s]) else ""), fontsize=9)
|
||||
ax.grid(alpha=0.3)
|
||||
ax.tick_params(labelsize=7)
|
||||
ax.xaxis.set_major_locator(mdates.AutoDateLocator(minticks=2, maxticks=5))
|
||||
ax.xaxis.set_major_formatter(mdates.DateFormatter("%d/%m\n%Hh"))
|
||||
for ax in list(axes.flat)[n:]:
|
||||
ax.axis("off")
|
||||
fig.suptitle(f"{station} : {col}, médiane par pas de {int(o.pas.total_seconds() // 60)} min (bleu), mesures (gris), "
|
||||
f"médiane de la fenêtre (pointillé) ; une échelle par capteur (heures UTC)")
|
||||
fig.tight_layout()
|
||||
multiples = base.format(f"multiples-{col}")
|
||||
fig.savefig(multiples, dpi=100, bbox_inches="tight")
|
||||
print(multiples)
|
||||
|
||||
# 3. résidus : chaque capteur moins son propre niveau
|
||||
for col, autres in [(c, False) for c in residus] + [(c, True) for c in residus if o.autres]:
|
||||
fig, axes = plt.subplots(lignes, 5, sharex=True, figsize=(18, 2.5 * lignes), squeeze=False)
|
||||
dev = {}
|
||||
if autres: # {capteur: {t: valeur - niveau propre}} pour la médiane des autres
|
||||
for q in noms:
|
||||
mq = [m for m in series[q] if m[col] is not None]
|
||||
rq = [m for m in mq if not hors or not hors[0] <= m["t"] <= hors[1]] or mq
|
||||
nq = niveau(rq, col)
|
||||
if nq:
|
||||
dev[q] = {m["t"]: m[col] - nq[0] for m in mq}
|
||||
print(f"\n{col} moins le niveau propre{' et moins la médiane des autres capteurs au même instant' if autres else ''} ({'hors ' + o.hors if hors else 'médiane de la fenêtre'}), médiane par pas de "
|
||||
f"{int(o.pas.total_seconds() // 60)} min :")
|
||||
pentes = []
|
||||
print(f"{'capteur':9}{'niveau':>10}{'bruit':>10}{'écart min':>11} {'à':<17}{'(bruits)':>9}{'écart max':>11} {'à':<17}{'(bruits)':>9}")
|
||||
for ax, s in zip(axes.flat, noms):
|
||||
ms = [m for m in series[s] if m[col] is not None]
|
||||
ref = [m for m in ms if not hors or not hors[0] <= m["t"] <= hors[1]] or ms
|
||||
lv = niveau(ref, col)
|
||||
if not lv:
|
||||
ax.axis("off")
|
||||
continue
|
||||
bruit = bruit_propre([m[col] for m in ms])
|
||||
if autres:
|
||||
res = {}
|
||||
for m in ms:
|
||||
v = [dev[q][m["t"]] for q in dev if q != s and m["t"] in dev[q]]
|
||||
if len(v) >= 2:
|
||||
res[m["t"]] = m[col] - lv[0] - statistics.median(v)
|
||||
if len(res) < 2:
|
||||
ax.axis("off")
|
||||
continue
|
||||
else:
|
||||
res = {m["t"]: m[col] - lv[0] for m in ms}
|
||||
pas = {}
|
||||
for t, v in res.items():
|
||||
pas.setdefault(t0 + ((t - t0) // o.pas) * o.pas, []).append(v)
|
||||
pm = {t: statistics.median(v) for t, v in pas.items()}
|
||||
ax.plot(list(res), list(res.values()), "-", lw=0.4, color="0.7")
|
||||
ax.plot(list(pm), list(pm.values()), "-", lw=1.1, color="C0")
|
||||
ax.axhline(0, color="C3", ls=":", lw=0.8)
|
||||
ax.set_title(s + (" (réf.)" if est_reference(ms) else "") + f" bruit {bruit:.2g}", fontsize=9)
|
||||
ax.grid(alpha=0.3)
|
||||
ax.tick_params(labelsize=7)
|
||||
ax.xaxis.set_major_locator(mdates.AutoDateLocator(minticks=2, maxticks=5))
|
||||
ax.xaxis.set_major_formatter(mdates.DateFormatter("%d/%m\n%Hh"))
|
||||
lo, hi = min(pm.items(), key=lambda x: x[1]), max(pm.items(), key=lambda x: x[1])
|
||||
f = lambda v: f"{v / bruit:9.1f}" if bruit else f"{'-':>9}"
|
||||
print(f"{s:9}{lv[0]:10.4g}{bruit:10.3g}{lo[1]:11.3g} {iso(lo[0]):<17}{f(lo[1])}{hi[1]:11.3g} {iso(hi[0]):<17}{f(hi[1])}")
|
||||
if autres:
|
||||
for c in colonnes:
|
||||
tt = [t for t in res if t in communes[c]]
|
||||
if len(tt) > 2 and len({communes[c][t] for t in tt}) > 1:
|
||||
xs, ys = [communes[c][t] for t in tt], [res[t] for t in tt]
|
||||
pente = statistics.linear_regression(xs, ys).slope
|
||||
pentes.append(f"{s:9}pente sur {c} commun {pente:+.4g} par unité, r = {statistics.correlation(xs, ys):+.2f}")
|
||||
for ax in list(axes.flat)[n:]:
|
||||
ax.axis("off")
|
||||
if pentes:
|
||||
print("\n".join(pentes))
|
||||
fig.suptitle(f"{station} : {col} moins le niveau propre{' et la médiane des autres' if autres else ''} de chaque capteur, médiane par pas de "
|
||||
f"{int(o.pas.total_seconds() // 60)} min (bleu), mesures (gris) ; une échelle par capteur (heures UTC)")
|
||||
fig.tight_layout()
|
||||
chemin = base.format(f"residus-{col}" + ("-autres" if autres else ""))
|
||||
fig.savefig(chemin, dpi=100, bbox_inches="tight")
|
||||
plt.close(fig)
|
||||
print(chemin)
|
||||
|
||||
if o.rigide:
|
||||
rigide(o, noms, series, temps, base, station)
|
||||
|
||||
print(f"\nInstants où au moins {o.min} capteurs ont {o.colonne} > médiane de la fenêtre + {o.k:g} MAD :")
|
||||
for t, hauts in qui.items():
|
||||
print(f"{iso(t)} {len(hauts):3} {','.join(hauts)}")
|
||||
if not qui:
|
||||
print("(aucun)")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
Reference in new issue
Block a user