"""Vignettes des images de la caméra autour de capteurs, à pleine résolution, pour l'agent de diagnostic. Usage : .venv/bin/python tools/scripts/vignettes.py data/PS_DES_COUDRES/ --capteurs REF_G,REF_D --heures 2026-10-13T22:00Z,2026-10-14T02:00Z [--rayon 100] [--contraste [MIN,MAX]] [--sortie DOSSIER] Une ligne par capteur, une colonne par heure. Quand il n'y a pas d'image à l'heure demandée, la plus proche est prise : l'écart est imprimé et l'heure réelle de l'image est dans le titre de la vignette. Chaque vignette est centrée sur la position brute (x, y) du capteur dans l'export « advanced », lue à la mesure la plus proche de l'image ; les pixels ne sont pas retouchés, l'éclat se compare donc d'une vignette à l'autre. Imprime les positions utilisées, le fond (médiane des pixels de la vignette), le 99e centile et le pic (maximum) du niveau de gris de chaque vignette (0 à 255), puis le chemin du PNG. --contraste : toutes les vignettes en niveaux de gris, avec le même étirement pour toute la planche, pour qu'une tache faible se voie et se compare d'une vignette à l'autre. Sans valeur, l'étirement va du 1er centile au maximum de la planche (un pixel saturé quelque part l'écrase : redonner alors --contraste MIN,MAX, en s'aidant du fond et du pic imprimés pour chaque vignette). Un --rayon plus petit (30 à 50) grossit. Les bornes sont imprimées. 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. 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 import sys import matplotlib matplotlib.use("Agg") import matplotlib.pyplot as plt # noqa: E402 from donnees import charger, heure_image, instant, iso, trouver # noqa: E402 def centile(gris, p): """Centile p (0 à 100) des pixels d'une vignette, sans interpolation.""" v = sorted(gris.ravel().tolist()) return v[min(int(p / 100 * len(v)), len(v) - 1)] def main(): a = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) a.add_argument("dossier") 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("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 = [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))}.") connues = sorted(h for h in images if h) if not connues: sys.exit(f"Aucune image dans {o.dossier}.") proche = {h: min(connues, key=lambda i: abs(i - h)) for h in heures} # image à l'heure demandée, sinon la plus proche for h in heures: 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 = 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 = 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", cadre coupé par le bord de l'image ({larg} × {haut} px)" if coupe else "")) bornes = {} if o.contraste: if o.contraste == "auto": bornes = dict(vmin=min(centile(g, 1) for _, g in coupes.values()), vmax=max(g.max() for _, g in coupes.values())) 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)") # 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[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"{'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) ax.set_xlabel(f"centre du cadre {x}, {y}" + (f"\nx, y {cx + max(x - r, 0):.1f}, {cy + max(y - r, 0):.1f}" if o.fixe else ""), fontsize=7) ax.set_xticks([]) ax.set_yticks([]) station = os.path.basename(os.path.normpath(o.dossier)) 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) 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) if __name__ == "__main__": main()