Files
aimsight-tools/scripts/vignettes.py
T

172 lines
11 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""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()