Reading tools: what the etiqueteur had to script itself (metrics, daily bounds, local level, zone, references)

- metriques.py: new, reads metrics/ (temperatures, voltage) against targets and camera pose
- jours.py --bornes: per-day first/last excursion, extreme, from the previous night
- plages.py --glissant, --instants: deviations from a local level, per-instant view
- ensemble.py --table, resume.py --marque/--instants: shorter outputs, repeated headers
- inventaire.py: image gaps as runs, references on reproj_err when inlier is empty
- vignettes.py --zone: same scene area across hours
- donnees.py: references recognised when pattern_type is empty (benchmark unchanged)
- lire-les-donnees: new options documented, gif.py row added

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
maximeandClaude Opus 5.5 committed 2026-11-03 16:56:59 +01:00
1 parent 6fbd7510b7
commit efbc5f15d7
9 files changed
+670 -80

No files matched your search

+70 -12
View File
@@ -14,7 +14,14 @@ pic imprimés pour chaque vignette). Un --rayon plus petit (30 à 50) grossit. L
Le centre du cadre (px) est écrit sous chaque vignette : quand les x, y de l'export sautent, le cadre se déplace
d'autant. --fixe garde, sur chaque ligne, le cadre centré sur la position de la première heure demandée, et marque
d'une croix rouge les x, y de l'export à chaque heure : une tache qui entre dans le cadre ou en sort ne s'y confond
pas avec une tache qui apparaît.
pas avec une tache qui apparaît. Un cadre que le bord de l'image coupe est signalé (taille de l'image) : sur certains
exports, x, y ne sont pas des pixels (valeurs proches de 0), et le cadre tombe dans le coin de l'image.
--zone X,Y,L,H : la même zone de l'image (pixels de l'image d'origine : coin haut gauche, largeur, hauteur, comme
gif.py) à chaque heure, côte à côte (jusqu'à 4 par ligne, moins quand la zone est large), même étirement avec --contraste ; --capteurs devient facultatif :
ceux qui sont donnés sont marqués d'une croix rouge et de leur nom à leurs x, y de chaque heure. Pour la scène autour
des cibles (premier plan, objet, éclairage), qu'un grand --rayon rendrait trop petite.
Chaque vignette est rendue à sa taille en pixels (un pixel de l'image pour un pixel du PNG) de 260 à 1000 px de côté ;
Read réduit un PNG trop large : avec un grand --rayon ou une grande --zone, peu d'heures par planche.
"""
import argparse
import os
@@ -41,17 +48,21 @@ RACINE = os.path.normpath(os.path.join(os.path.dirname(os.path.abspath(__file__)
def main():
a = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
a.add_argument("dossier")
a.add_argument("--capteurs", required=True, help="liste séparée par des virgules")
a.add_argument("--capteurs", default="", help="liste séparée par des virgules (facultative avec --zone)")
a.add_argument("--heures", required=True, help="heures des images, séparées par des virgules (UTC)")
a.add_argument("--rayon", type=int, default=100, help="demi-côté de la vignette en pixels (défaut 100)")
a.add_argument("--contraste", nargs="?", const="auto", metavar="MIN,MAX", help="niveaux de gris, même étirement pour toute la planche : MIN,MAX (0 à 255) ou, sans valeur, du 1er centile au maximum de la planche")
a.add_argument("--fixe", action="store_true", help="un cadre fixe par capteur (position à la première heure), x, y de chaque heure marqués d'une croix")
a.add_argument("--zone", metavar="X,Y,L,H", help="la même zone de l'image à chaque heure (pixels de l'image d'origine : coin haut gauche, largeur, hauteur)")
a.add_argument("--sortie", default=os.path.join(RACINE, "out", "diagnostic"), help="dossier du PNG")
o = a.parse_args()
par = charger(o.dossier)
images = {heure_image(p): p for p in trouver(o.dossier)["images"]}
noms, heures = o.capteurs.split(","), [instant(h) for h in o.heures.split(",")]
noms, heures = [s for s in o.capteurs.split(",") if s], [instant(h) for h in o.heures.split(",")]
zone = tuple(map(int, o.zone.split(","))) if o.zone else None
if not noms and not zone:
sys.exit("Donne --capteurs, ou --zone X,Y,L,H.")
absents = [s for s in noms if s not in par]
if absents:
sys.exit(f"Capteurs inconnus : {', '.join(absents)}. Connus : {', '.join(sorted(par))}.")
@@ -63,22 +74,47 @@ def main():
if proche[h] != h:
print(f"Pas d'image à {iso(h)} : la plus proche est celle de {iso(proche[h])} (écart {abs(proche[h] - h)}).")
def niveaux(c):
gris = c[..., :3].mean(axis=-1) if c.ndim == 3 else c
return gris * 255 if gris.max() <= 1 and c.dtype.kind == "f" else gris
def mesure(s, t):
return min((m for m in par[s] if m["x"] is not None), key=lambda m: abs(m["t"] - t))
r = o.rayon
coupes, centres, croix = {}, {}, {}
for j, h in enumerate(heures):
img = plt.imread(images[proche[h]])
haut, larg = img.shape[:2]
if zone:
X, Y, L, H = zone
c = img[max(Y, 0):Y + H, max(X, 0):X + L]
if c.size == 0:
sys.exit(f"--zone {o.zone} hors de l'image ({larg} × {haut} px).")
gris = niveaux(c)
coupes[0, j] = (c, gris)
croix[0, j] = [(s, m["x"] - max(X, 0), m["y"] - max(Y, 0)) for s in noms for m in [mesure(s, proche[h])]]
print(f"zone {o.zone} {iso(h)} : {os.path.basename(images[proche[h]])}, fond {centile(gris, 50):.0f}, "
f"p99 {centile(gris, 99):.0f}, pic {gris.max():.0f}"
+ ("" if c.shape[:2] == (H, L) else f", coupée par le bord de l'image ({larg} × {haut} px)")
+ "".join(f" ; {s} x={x + max(X, 0):.1f} y={y + max(Y, 0):.1f}" for s, x, y in croix[0, j]))
continue
for i, s in enumerate(noms):
m = min((m for m in par[s] if m["x"] is not None), key=lambda m: abs(m["t"] - proche[h]))
m = mesure(s, proche[h])
x, y = centres[i] if o.fixe and j else (round(m["x"]), round(m["y"]))
if j == 0:
centres[i] = (x, y)
c = img[max(y - r, 0):y + r, max(x - r, 0):x + r]
if c.size == 0:
sys.exit(f"{s} {iso(h)} : x={m['x']:.1f} y={m['y']:.1f} hors de l'image ({larg} × {haut} px) ; "
"--zone X,Y,L,H regarde une zone fixe.")
croix[i, j] = (m["x"] - max(x - r, 0), m["y"] - max(y - r, 0), x, y)
gris = c[..., :3].mean(axis=-1) if c.ndim == 3 else c
gris = gris * 255 if gris.max() <= 1 and c.dtype.kind == "f" else gris
gris = niveaux(c)
coupes[i, j] = (c, gris)
coupe = x - r < 0 or y - r < 0 or x + r > larg or y + r > haut
print(f"{s} {iso(h)} : x={m['x']:.1f} y={m['y']:.1f} (mesure de {iso(m['t'])}), {os.path.basename(images[proche[h]])}, "
f"fond {centile(gris, 50):.0f}, p99 {centile(gris, 99):.0f}, pic {gris.max():.0f}")
f"fond {centile(gris, 50):.0f}, p99 {centile(gris, 99):.0f}, pic {gris.max():.0f}"
+ (f", cadre coupé par le bord de l'image ({larg} × {haut} px)" if coupe else ""))
bornes = {}
if o.contraste:
if o.contraste == "auto":
@@ -86,14 +122,34 @@ def main():
else:
bornes = dict(zip(("vmin", "vmax"), map(float, o.contraste.split(","))))
print(f"Étirement commun : {bornes['vmin']:.0f} à {bornes['vmax']:.0f} (niveaux de gris, 0 à 255)")
fig, axes = plt.subplots(len(noms), len(heures), figsize=(2.6 * len(heures), 2.8 * len(noms)), squeeze=False)
# Une vignette à sa taille en pixels (à 100 dpi) dès qu'elle dépasse 2,6 pouces : un grand --rayon n'est plus réduit.
cote = max(c.shape[1] for c, _ in coupes.values()) / 100, max(c.shape[0] for c, _ in coupes.values()) / 100
cote = tuple(v * min(1, 10 / max(cote)) for v in cote) # au plus 1000 px de côté par vignette
if zone:
nc = max(1, min(4, len(heures), int(20 // max(2.6, cote[0])))) # planche d'au plus ~2000 px de large : Read la réduit au-delà
nl = -(-len(heures) // nc)
fig, axes = plt.subplots(nl, nc, figsize=(max(2.6, cote[0]) * nc, (max(2.6, cote[1]) + 0.4) * nl), squeeze=False)
for ax in axes.ravel()[len(heures):]:
ax.axis("off")
else:
fig, axes = plt.subplots(len(noms), len(heures), figsize=(max(2.6, cote[0]) * len(heures), (max(2.6, cote[1]) + 0.2) * len(noms)), squeeze=False)
for (i, j), (c, gris) in coupes.items():
ax = axes[i, j]
ax = axes[j // nc, j % nc] if zone else axes[i, j]
if o.contraste:
ax.imshow(gris, cmap="gray", interpolation="nearest", **bornes)
else:
ax.imshow(c, interpolation="nearest")
ax.set_title(f"{noms[i]} {proche[heures[j]].strftime('%d/%m %H:%MZ')}" + ("" if proche[heures[j]] == heures[j] else " (demandée " + heures[j].strftime('%H:%MZ') + ")"), fontsize=9)
ax.set_title(f"{'zone' if zone else noms[i]} {proche[heures[j]].strftime('%d/%m %H:%MZ')}" + ("" if proche[heures[j]] == heures[j] else " (demandée " + heures[j].strftime('%H:%MZ') + ")"), fontsize=9)
if zone:
for s, cx, cy in croix[i, j]:
ax.plot(cx, cy, "+", color="r", ms=10, mew=1)
ax.annotate(s, (cx, cy), xytext=(4, 4), textcoords="offset points", color="r", fontsize=7)
ax.set_xlim(-0.5, c.shape[1] - 0.5)
ax.set_ylim(c.shape[0] - 0.5, -0.5)
ax.set_xlabel(f"zone {o.zone}", fontsize=7)
ax.set_xticks([])
ax.set_yticks([])
continue
cx, cy, x, y = croix[i, j]
if o.fixe:
ax.plot(cx, cy, "+", color="r", ms=10, mew=1)
@@ -101,10 +157,12 @@ def main():
ax.set_xticks([])
ax.set_yticks([])
station = os.path.basename(os.path.normpath(o.dossier))
fig.suptitle(f"{station} : vignettes de {2 * r} px autour de chaque capteur (heures UTC)", fontsize=10)
fig.suptitle(f"{station} : zone {o.zone} (x, y, largeur, hauteur en px ; heures UTC)" if zone else
f"{station} : vignettes de {2 * r} px autour de chaque capteur (heures UTC)", fontsize=10)
os.makedirs(o.sortie, exist_ok=True)
sortie = os.path.join(o.sortie, f"{station}_vignettes_{'-'.join(noms)}_"
quoi = f"zone{o.zone.replace(',', '-')}" + ("_" + "-".join(noms) if noms else "") if zone else "-".join(noms)
sortie = os.path.join(o.sortie, f"{station}_vignettes_{quoi}_"
f"{'-'.join(h.strftime('%d%H%M') for h in heures)}{'_contraste' if o.contraste else ''}{'_fixe' if o.fixe else ''}.png")
fig.savefig(sortie, dpi=100, bbox_inches="tight")
print(sortie)