classe ImageIO – objet ImageIO

La classe ImageIO enregistre et restitue des flux de trames Image dans le format natif sur disque d’OpenMV. Un même flux peut contenir des trames hétérogènes (formats de pixels / tailles différents) et enregistre l’intervalle entre trames de chacune afin que la restitution reproduise la cadence d’images d’origine.

Il existe deux supports de stockage :

• Flux fichier – les trames sont lues depuis / ajoutées à un fichier du système de fichiers. Le fichier commence par un en-tête magique de 16 octets OMV IMG STR Vx.y suivi de blocs par trame. L’écrivain actuel émet V2.0 ; les anciens fichiers V1.0 et V1.1 restent lisibles.

• Flux mémoire – les trames sont lues depuis / écrites dans un tampon RAM de taille fixe alloué au moment de la construction. Utile pour faire transiter des trames à travers des filtres qui nécessitent un enregistrement sans toucher au système de fichiers.

class image.ImageIO(path: str | Tuple[int, int, int], mode: str | int)

Crée un flux ImageIO.

Si path est une chaîne, un flux fichier est ouvert à ce chemin. mode doit être l’une des valeurs suivantes :

• 'r' – ouvre un fichier existant en lecture. L’en-tête magique est validé et la version (V1.0 / V1.1 / V2.0) est enregistrée pour être utilisée par version().

• 'w' – tronque / crée le fichier et écrit un nouvel en-tête magique V2.0. Les trames sont ajoutées à chaque write().

Si path est un triplet (w, h, pixformat), un flux mémoire est alloué. mode est alors l’entier nombre d’emplacements de trame à préallouer. Le tampon est dimensionné pour count trames de (w, h, pixformat) et ne peut pas grandir après sa création. pixformat est l’une des valeurs image.BINARY, image.GRAYSCALE, image.RGB565, image.BAYER, image.YUV422, image.JPEG ou image.PNG. Pour les formats compressés (image.JPEG, image.PNG) la taille par emplacement est estimée à 2 bpp ; les trames plus grandes que l’estimation lèvent ValueError au moment du write().

Inspection

type() → int

Renvoie le support de stockage du flux : FILE_STREAM pour un flux fichier, MEMORY_STREAM pour un flux mémoire.

is_closed() → bool

Renvoie True si close() a été appelée sur cet objet. Une fois fermé, le flux lève OSError("Stream closed") à toute lecture/écriture/recherche ultérieure.

count() → int

Renvoie le nombre de trames actuellement stockées dans le flux. Pour les flux fichier, ce nombre augmente à mesure que write() ajoute des trames ; pour les flux mémoire, il est fixé au moment de la construction.

offset() → int

Renvoie l’index de trame courant. Incrémenté par read() et write(), réinitialisé par seek().

version() → int | None

Renvoie la version du format sur disque pour les flux fichier (10 pour V1.0, 11 pour V1.1, 20 pour V2.0). Renvoie None pour les flux mémoire.

buffer_size() → int | None

Renvoie la taille du tampon de pixels par emplacement, en octets, pour les flux mémoire (la taille de l’emplacement moins l’en-tête de gestion interne Image). Renvoie None pour les flux fichier. Utilisez ceci avec count() pour vérifier si une taille de trame particulière tiendra.

size() → int

Renvoie le nombre total d’octets consommés par le flux – la taille du fichier sur disque pour les flux fichier, ou la taille complète du tampon RAM (count * per_slot_size y compris l’en-tête par emplacement) pour les flux mémoire.

E/S

write(img: Image) → ImageIO

Ajoute (flux fichier) ou stocke à un décalage donné (flux mémoire) img et avance offset() d’une unité.

Pour les flux fichier, le fichier grandit à mesure que les trames sont ajoutées. Écrire à un décalage qui n’est pas la fin tronque le reste du fichier, de sorte que le nombre de trames peut diminuer.

Pour les flux mémoire, la trame est écrite dans l’emplacement courant ; écrire au-delà du dernier emplacement lève EOFError("End of stream") et écrire une trame plus grande que buffer_size() lève ValueError("Invalid frame size").

Renvoie self afin que les appels puissent être chaînés.

read(copy_to_fb: bool = True, *, loop: bool = True, pause: bool = True) → Image | None

Lit la trame au offset() courant, avance le décalage et renvoie la nouvelle Image. Reflète la moitié restitution de write().

copy_to_fb – lorsque True (par défaut), la trame décodée est placée dans le tampon d’image de la caméra (le même endroit où atterrit un csi.CSI.snapshot()), de sorte que l”Image renvoyée est dessinable via l’aperçu de l’IDE. Lorsque False, la trame est allouée sur le tas MicroPython à la place.

loop (flux fichier uniquement) – lorsque True (par défaut), lire au-delà de la dernière trame revient à la première trame et continue. Lorsque False, l’appel renvoie None une fois la fin du fichier atteinte.

pause – lorsque True (par défaut), l’appel se bloque jusqu’à ce que l’intervalle entre trames enregistré à l’origine se soit écoulé, de sorte que la restitution s’exécute à la cadence d’images native de l’enregistrement. Mettez à False pour une restitution aussi rapide que possible.

seek(offset: int) → ImageIO

Déplace offset() vers la trame offset. offset doit être non négatif ; les décalages de flux mémoire doivent en plus être inférieurs à count().

Les recherches sur flux fichier parcourent le fichier trame par trame depuis le début, car les blocs de trame sont de taille variable – attendez-vous à un temps en O(offset) pour les grands sauts.

Renvoie self afin que les appels puissent être chaînés.

sync() → ImageIO

Vide les écritures en attente sur le disque pour les flux fichier (appelle le sync sous-jacent du système de fichiers). Sans effet pour les flux mémoire.

Renvoie self afin que les appels puissent être chaînés.

close() → None

Ferme le flux. Libère le tampon mémoire (flux mémoire) ou ferme le fichier (flux fichier). Après close(), l’objet ImageIO ne peut plus être réutilisé ; les opérations ultérieures lèvent OSError("Stream closed"). Appeler close() deux fois est sans effet.

Un ImageIO est aussi fermé automatiquement lorsqu’il est récupéré par le ramasse-miettes (il enregistre un finaliseur lors de la construction).

Constantes

FILE_STREAM: int

Valeur renvoyée par type() pour les flux adossés à un fichier.

MEMORY_STREAM: int

Valeur renvoyée par type() pour les flux en mémoire.