2026-10-14 16:00:40 +02:00
"""Vignettes des images de la caméra autour de capteurs, à pleine résolution, pour l'agent de diagnostic.
2026-10-28 16:36:45 +01:00
Usage : .venv/bin/python agent-tools/vignettes.py data/PS_DES_COUDRES/
2026-10-26 14:47:00 +01:00
--capteurs REF_G,REF_D --heures 2026-10-13T22:00Z,2026-10-14T02:00Z [--rayon 100] [--contraste [MIN,MAX]] [--sortie DOSSIER]
2026-10-26 14:55:46 +01:00
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
2026-10-14 16:00:40 +02:00
dans l'export « advanced », lue à la mesure la plus proche de l'image ; les pixels ne sont pas retouchés, l'éclat
2026-10-26 14:47:00 +01:00
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.
2026-10-26 19:07:50 +01:00
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
2026-11-03 16:56:59 +01:00
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.
2026-10-14 16:00:40 +02:00
"""
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
2026-10-26 14:47:00 +01:00
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 )]
2026-10-28 16:36:45 +01:00
RACINE = os . path . normpath ( os . path . join ( os . path . dirname ( os . path . abspath ( __file__ )), ".." ))
2026-10-14 16:00:40 +02:00
def main ():
a = argparse . ArgumentParser ( description = __doc__ , formatter_class = argparse . RawDescriptionHelpFormatter )
a . add_argument ( "dossier" )
2026-11-03 16:56:59 +01:00
a . add_argument ( "--capteurs" , default = "" , help = "liste séparée par des virgules (facultative avec --zone)" )
2026-10-14 16:00:40 +02:00
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)" )
2026-10-26 14:47:00 +01:00
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" )
2026-10-26 19:07:50 +01:00
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" )
2026-11-03 16:56:59 +01:00
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)" )
2026-10-14 16:00:40 +02:00
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" ]}
2026-11-03 16:56:59 +01:00
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." )
2026-10-14 16:00:40 +02:00
absents = [ s for s in noms if s not in par ]
if absents :
sys . exit ( f "Capteurs inconnus : { ', ' . join ( absents ) } . Connus : { ', ' . join ( sorted ( par )) } ." )
2026-10-26 14:55:46 +01:00
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 ) } )." )
2026-10-14 16:00:40 +02:00
2026-11-03 16:56:59 +01:00
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 ))
2026-10-14 16:00:40 +02:00
r = o . rayon
2026-10-26 19:07:50 +01:00
coupes , centres , croix = {}, {}, {}
2026-10-14 16:00:40 +02:00
for j , h in enumerate ( heures ):
2026-10-26 14:55:46 +01:00
img = plt . imread ( images [ proche [ h ]])
2026-11-03 16:56:59 +01:00
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
2026-10-14 16:00:40 +02:00
for i , s in enumerate ( noms ):
2026-11-03 16:56:59 +01:00
m = mesure ( s , proche [ h ])
2026-10-26 19:07:50 +01:00
x , y = centres [ i ] if o . fixe and j else ( round ( m [ "x" ]), round ( m [ "y" ]))
if j == 0 :
centres [ i ] = ( x , y )
2026-10-26 14:47:00 +01:00
c = img [ max ( y - r , 0 ): y + r , max ( x - r , 0 ): x + r ]
2026-11-03 16:56:59 +01:00
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." )
2026-10-26 19:07:50 +01:00
croix [ i , j ] = ( m [ "x" ] - max ( x - r , 0 ), m [ "y" ] - max ( y - r , 0 ), x , y )
2026-11-03 16:56:59 +01:00
gris = niveaux ( c )
2026-10-26 14:47:00 +01:00
coupes [ i , j ] = ( c , gris )
2026-11-03 16:56:59 +01:00
coupe = x - r < 0 or y - r < 0 or x + r > larg or y + r > haut
2026-10-26 14:55:46 +01:00
print ( f " { s } { iso ( h ) } : x= { m [ 'x' ] : .1f } y= { m [ 'y' ] : .1f } (mesure de { iso ( m [ 't' ]) } ), { os . path . basename ( images [ proche [ h ]]) } , "
2026-11-03 16:56:59 +01:00
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 "" ))
2026-10-26 14:47:00 +01:00
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)" )
2026-11-03 16:56:59 +01:00
# 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 )
2026-10-26 14:47:00 +01:00
for ( i , j ), ( c , gris ) in coupes . items ():
2026-11-03 16:56:59 +01:00
ax = axes [ j // nc , j % nc ] if zone else axes [ i , j ]
2026-10-26 14:47:00 +01:00
if o . contraste :
ax . imshow ( gris , cmap = "gray" , interpolation = "nearest" , ** bornes )
else :
ax . imshow ( c , interpolation = "nearest" )
2026-11-03 16:56:59 +01:00
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
2026-10-26 19:07:50 +01:00
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 " \n x, y { cx + max ( x - r , 0 ) : .1f } , { cy + max ( y - r , 0 ) : .1f } " if o . fixe else "" ), fontsize = 7 )
2026-10-26 14:47:00 +01:00
ax . set_xticks ([])
ax . set_yticks ([])
2026-10-14 16:00:40 +02:00
station = os . path . basename ( os . path . normpath ( o . dossier ))
2026-11-03 16:56:59 +01:00
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 )
2026-10-14 16:00:40 +02:00
os . makedirs ( o . sortie , exist_ok = True )
2026-11-03 16:56:59 +01:00
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 } _"
2026-10-26 19:07:50 +01:00
f " { '-' . join ( h . strftime ( ' %d %H%M' ) for h in heures ) }{ '_contraste' if o . contraste else '' }{ '_fixe' if o . fixe else '' } .png" )
2026-10-14 16:00:40 +02:00
fig . savefig ( sortie , dpi = 100 , bbox_inches = "tight" )
print ( sortie )
if __name__ == "__main__" :
main ()