171 lines
11 KiB
Python
171 lines
11 KiB
Python
"""Vignettes des images de la caméra autour de capteurs, à pleine résolution, pour l'agent de diagnostic.
|
||||
|
|
|
|||
|
|
Usage : .venv/bin/python tools/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()
|