classe Image – Objet image¶

Image est le type de données central du module image – un tampon de pixels en mémoire sur lequel opèrent chaque routine de dessin, chaque filtre, chaque transformation géométrique et chaque routine d’extraction de caractéristiques. Chaque trame issue de csi.CSI.snapshot() est une Image ; il en va de même pour chaque trame chargée depuis le disque, décodée depuis un JPEG ou un PNG, allouée à partir d’un ndarray de type numpy, ou construite comme une toile de dessin vide.

Une Image est décrite par trois nombres – width, height et pixformat – plus un tampon de pixels contigu. Le format de pixel détermine à la fois la disposition en mémoire et les opérations disponibles :

BINARY (1 bpp) – 1 bit par pixel ; utilisé par la morphologie et le seuillage.
GRAYSCALE (8 bpp) – 1 octet par pixel ; le format canonique pour la plupart des traitements de vision (AprilTag, contours, ORB, flux optique).
RGB565 (16 bpp) – 2 octets par pixel (5R/6G/5B) ; le format couleur par défaut.
BAYER (8 bpp) – données brutes en mosaïque de Bayer directement issues du capteur. La plupart des méthodes de vision ne sont pas disponibles sur les images Bayer ; effectuez d’abord un débayerisation vers GRAYSCALE / RGB565.
YUV422 (16 bpp) – couleur avec sous-échantillonnage chromatique 4:2:2, deux octets par pixel. Seules certaines méthodes fonctionnent directement sur YUV422.
JPEG / PNG – tampons compressés. Les opérations au niveau du pixel nécessitent d’abord to_grayscale() ou to_rgb565().

D’où proviennent les objets Image¶

Il existe quatre façons d’obtenir une Image :

Depuis le tampon d’image de la caméra – csi.CSI().snapshot() renvoie la trame capturée suivante. L’objet renvoyé est une enveloppe légère autour de la mémoire du tampon d’image de la caméra, de sorte que toute opération de dessin / filtrage qui lui est appliquée modifie ce qui est envoyé à l’aperçu de l’IDE et à l’écran.
Depuis un fichier – passez une chaîne de chemin au constructeur Image. Les formats BMP, PGM, PPM, JPEG et PNG sont décodés directement en RAM (ou dans le tampon d’image de la caméra si copy_to_fb=True).
Depuis un ndarray – passez un tableau float32 de forme (h, w) ou (h, w, 3). Les pixels sont mis à l’échelle de 0.0 -- 255.0 respectivement vers GRAYSCALE ou RGB565.
Vide – passez (width, height, pixformat) pour allouer une surface de dessin remplie de zéros. Pour les formats de pixel compressés (JPEG / PNG), un argument buffer= est requis et contient le flux d’octets compressé.

Boucle typique de capture-traitement-affichage¶

import csi
import image

sensor = csi.CSI()
sensor.reset()
sensor.pixformat(csi.RGB565)
sensor.framesize(csi.QVGA)

while True:
    img = sensor.snapshot()                    # capture
    for blob in img.find_blobs([(30, 100, 15, 127, 15, 127)]):  # process
        img.draw_rectangle(blob.rect)          # annotate
    # img is shown automatically in the IDE preview and on any
    # attached display.

Indexation, longueur, itération et accès de type bytes¶

Indexation – img[i] lit le pixel i (linéairement, par ligne d’abord). img[i] = value l’écrit. Les pixels en niveaux de gris / Bayer sont des entiers 8 bits, les pixels RGB565 / YUV422 sont des entiers compactés 16 bits, et les pixels binaires valent 0 / 1. Pour les images JPEG / PNG, l’espace d’index correspond au flux d’octets compressé, et non aux pixels.
Longueur – len(img) renvoie le nombre de pixels pour les formats non compressés ou le nombre d’octets pour les formats compressés.
Itération – for px in img: ... parcourt le tableau de pixels dans le même ordre que l’indexation [].
Type bytes – Image expose le protocole de tampon en lecture, vous pouvez donc la passer directement à tout élément acceptant un objet bytes / bytearray (par ex. uart.write(img), socket.send(img), hashlib.sha256(img)). Utilisez plutôt bytearray() pour obtenir une vue en lecture/écriture.

Indicateurs d’aide¶

De nombreuses méthodes de Image acceptent un argument hint qui est un OU logique des indicateurs suivants :

image.AREA : Utilise une mise à l’échelle par aire lors d’une réduction, au lieu de la méthode par défaut du plus proche voisin.

image.BILINEAR : Utilise une mise à l’échelle bilinéaire au lieu de la mise à l’échelle par défaut du plus proche voisin.

image.BICUBIC : Utilise une mise à l’échelle bicubique au lieu de la mise à l’échelle par défaut du plus proche voisin.

image.CENTER : Centre l’image dessinée sur l’écran. Ceci est appliqué après la mise à l’échelle.

image.HMIRROR : Met l’image en miroir horizontal.

image.VFLIP : Retourne l’image verticalement.

image.TRANSPOSE : Transpose l’image (échange x/y).

image.EXTRACT_RGB_CHANNEL_FIRST : Effectue l’extraction rgb_channel avant la mise à l’échelle.

image.APPLY_COLOR_PALETTE_FIRST : Applique la palette de couleurs avant la mise à l’échelle.

image.SCALE_ASPECT_KEEP : Met l’image dessinée à l’échelle pour qu’elle tienne à l’intérieur de l’écran.

image.SCALE_ASPECT_EXPAND : Met l’image dessinée à l’échelle pour qu’elle remplisse l’écran (entraîne un recadrage).

image.SCALE_ASPECT_IGNORE : Met l’image dessinée à l’échelle pour qu’elle remplisse l’écran (entraîne un étirement).

image.ROTATE_90 : Fait pivoter l’image de 90 degrés (équivaut simplement à VFLIP | TRANSPOSE).

image.ROTATE_180 : Fait pivoter l’image de 180 degrés (équivaut simplement à HMIRROR | VFLIP).

image.ROTATE_270 : Fait pivoter l’image de 270 degrés (équivaut simplement à HMIRROR | TRANSPOSE).

image.BLACK_BACKGROUND : Suppose que l’image d’arrière-plan sur laquelle on dessine est noire, ce qui accélère le mélange. Pris en charge uniquement par Image.draw_image() et Image.get_similarity().

Si arg est une chaîne, alors un nouvel objet image est créé à partir d’un fichier situé au chemin arg. Prend en charge le chargement de fichiers image bmp/pgm/ppm/jpg/jpeg/png depuis le disque. Si copy_to_fb est vrai, l’image est copiée dans le tampon d’image au lieu d’être allouée sur le tas.

Si arg est un ndarray, alors un nouvel objet image est créé à partir du ndarray. Les objets ndarray ayant une forme de (w, h) sont traités comme des images en niveaux de gris, et ceux de forme (w, h, 3) comme des images RGB565. Seuls les ndarrays en virgule flottante float32 sont pris en charge pour l’instant. Lors de la création d’une image de cette manière, si vous passez un argument buffer, il sera utilisé pour stocker les données de l’image au lieu d’allouer de l’espace sur le tas. Si copy_to_fb est vrai, l’image est copiée dans le tampon d’image au lieu d’être allouée sur le tas ou d’utiliser le buffer.

Si arg est un int, il est alors considéré comme la largeur d’une nouvelle image, et une valeur height ainsi qu’une valeur format doivent suivre pour créer un nouvel objet image vierge. format peut être n’importe quelle valeur de format de pixel d’image comme image.GRAYSCALE. L’image sera initialisée à zéro. Notez qu’une valeur buffer est attendue pour les formats d’image compressés. buffer est considéré comme la source des données d’image pour créer les images de cette manière. S’il est utilisé avec copy_to_fb, les données de buffer sont copiées dans le tampon d’image. Si vous souhaitez créer une image JPEG à partir d’un objet bytes() ou bytearray() JPEG, vous pouvez passer width, height, image.JPEG pour le JPEG en définissant buffer sur le flux d’octets JPEG afin de créer une image JPEG.

Les images prennent en charge la notation « [] ». Faites image[index] = 8/16-bit value pour affecter un pixel d’image ou image[index] pour obtenir un pixel d’image, qui sera soit une valeur 8 bits pour les images en niveaux de gris/bayer, soit une valeur 16 bits pour les images RGB565/YUV. Les images binaires renvoient une valeur 1 bit.

Pour les images JPEG, la notation « [] » vous permet d’accéder au blob d’image JPEG compressé sous forme de tableau d’octets. La lecture et l’écriture dans le tableau de données restent opaques cependant, car les images JPEG sont des flux d’octets compressés.

Les images prennent également en charge les opérations de tampon en lecture. Vous pouvez passer des images à toutes sortes de fonctions MicroPython comme si l’image était un objet de type tableau d’octets. En particulier, si vous souhaitez transmettre une image, vous pouvez simplement la passer aux fonctions d’écriture UART/SPI/I2C pour qu’elle soit transmise automatiquement.

Méthodes de base¶

width() → int¶: Renvoie la largeur de l’image en pixels.

height() → int¶: Renvoie la hauteur de l’image en pixels.

format() → int¶: Renvoie image.GRAYSCALE pour les images en niveaux de gris, image.RGB565 pour les images RGB565, image.BAYER pour les images en motif de Bayer, et image.JPEG pour les images JPEG.

size() → int¶: Renvoie la taille de l’image en octets.

bytearray() → bytearray¶: Renvoie un objet bytearray qui pointe vers les données de l’image pour un accès en lecture/écriture au niveau de l’octet.

Note

Les objets image sont automatiquement convertis en objets bytes lorsqu’ils sont passés à un pilote MicroPython qui requiert un objet de type bytes. Il s’agit d’un accès en lecture seule. Appelez bytearray() pour obtenir un accès en lecture/écriture.

get_pixel(x: int, y: int, rgbtuple: bool | None = None) → int | Tuple[int, int, int]¶

Pour les images en niveaux de gris : renvoie la valeur du pixel en niveaux de gris à l’emplacement (x, y). Pour les images RGB565 : renvoie le tuple de pixel RGB888 (r, g, b) à l’emplacement (x, y). Pour les images en motif de Bayer : renvoie la valeur du pixel à l’emplacement (x, y).

Renvoie None si x ou y est en dehors de l’image.

x et y peuvent être passés indépendamment ou sous forme de tuple.

rgbtuple si vrai, fait que cette méthode renvoie un tuple RGB888. Sinon, cette méthode renvoie la valeur entière du pixel sous-jacent. C.-à-d. que pour les images RGB565, cette méthode renvoie une valeur RGB565. La valeur par défaut est True pour les images RGB565 et False sinon.

Non pris en charge sur les images compressées.

Note

Image.get_pixel() et Image.set_pixel() sont les seules méthodes qui vous permettent de manipuler les images en motif de Bayer. Les images en motif de Bayer sont des images littérales où les pixels de l’image sont R/G/R/G/etc. pour les lignes paires et G/B/G/B/etc. pour les lignes impaires. Chaque pixel fait 8 bits. Si vous appelez cette méthode avec rgbtuple défini, alors Image.get_pixel() débayerisera l’image source à cet emplacement de pixel et renverra un tuple RGB888 valide pour cet emplacement de pixel.

set_pixel(x: int, y: int, pixel: int | Tuple[int, int, int]) → Image¶

Pour les images en niveaux de gris : définit le pixel à l’emplacement (x, y) sur la valeur en niveaux de gris pixel. Pour les images RGB565 : définit le pixel à l’emplacement (x, y) sur le tuple RGB888 (r, g, b) pixel. Pour les images en motif de Bayer : définit la valeur du pixel à l’emplacement (x, y) sur la valeur pixel.

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

x et y peuvent être passés indépendamment ou sous forme de tuple.

pixel peut être soit un tuple RGB888 (r, g, b), soit la valeur du pixel sous-jacent (c.-à-d. une valeur RGB565 pour les images RGB565 ou une valeur 8 bits pour les images en niveaux de gris).

Non pris en charge sur les images compressées.

Note

Image.get_pixel() et Image.set_pixel() sont les seules méthodes qui vous permettent de manipuler les images en motif de Bayer. Les images en motif de Bayer sont des images littérales où les pixels de l’image sont R/G/R/G/etc. pour les lignes paires et G/B/G/B/etc. pour les lignes impaires. Chaque pixel fait 8 bits. Si vous appelez cette méthode avec un tuple RGB888, la valeur en niveaux de gris de ce tuple RGB888 est extraite et affectée à l’emplacement du pixel.

Méthodes de conversion¶

to_ndarray(dtype: str, buffer: bytes | bytearray | memoryview | None = None) → ndarray¶

Renvoie un objet ndarray créé à partir de l’image. Cela ne fonctionne actuellement que pour les images GRAYSCALE ou RGB565.

dtype peut être b, B ou f pour créer un ndarray 8 bits signé, 8 bits non signé ou en virgule flottante 32 bits. Les images GRAYSCALE sont directement converties en objets ndarray 8 bits non signés. Pour les objets ndarray 8 bits signés, les valeurs (0:255) sont mappées sur (-127:128). Pour les objets ndarray en virgule flottante 32 bits, les valeurs sont mappées sur (0.0:255.0). Les images RGB565 sont converties en objets ndarray à 3 canaux et le même processus décrit ci-dessus pour les images GRAYSCALE est appliqué à chaque canal selon dtype. Notez que dtype accepte aussi les valeurs entières (par ex. ord()) de b, B et f respectivement.

buffer, s’il n’est pas None, est un objet bytearray à utiliser comme tampon pour le ndarray. Si None, un nouveau tampon est alloué sur le tas pour stocker les données d’image du ndarray. Vous pouvez utiliser l’argument buffer pour allouer directement le ndarray dans un tampon pré-alloué, économisant ainsi une allocation sur le tas et une opération de copie.

Le ndarray renvoyé a la forme (height, width) pour les images GRAYSCALE et (height, width, 3) pour les images RGB565.

to_bitmap(x_scale: float = 1.0, y_scale: float = 1.0, roi: Tuple[int, int, int, int] | None = None, rgb_channel: int = -1, alpha: int = 255, color_palette: int | Image | None = None, alpha_palette: Image | None = None, hint: int = 0, transform: ndarray | None = None, copy: bool = False, copy_to_fb: bool = False) → Image¶

Convertit une image en image bitmap (1 bit par pixel).

x_scale contrôle de combien l’image affichée est mise à l’échelle dans la direction x (float). Si cette valeur est négative, l’image sera retournée horizontalement. Notez que si y_scale n’est pas spécifié, il correspondra à x_scale afin de conserver le rapport d’aspect.

y_scale contrôle de combien l’image affichée est mise à l’échelle dans la direction y (float). Si cette valeur est négative, l’image sera retournée verticalement. Notez que si x_scale n’est pas spécifié, il correspondra à x_scale afin de conserver le rapport d’aspect.

roi est le tuple rectangle de la région d’intérêt (x, y, w, h) de l’image source à dessiner. Cela vous permet d’extraire uniquement les pixels de la ROI pour les mettre à l’échelle et les dessiner sur l’image de destination.

rgb_channel est le canal RGB (0=R, G=1, B=2) à extraire d’une image RGB565 (si elle est passée) et à rendre sur l’image de destination. Par exemple, si vous passez rgb_channel=1, cela extraira le canal vert de l’image source RGB565 et le dessinera en niveaux de gris sur l’image de destination.

alpha contrôle la quantité d’image source à mélanger dans l’image de destination. Une valeur de 255 dessine une image source opaque tandis qu’une valeur inférieure à 255 produit un mélange entre l’image source et l’image de destination. 0 n’entraîne aucune modification de l’image de destination.

color_palette, s’il n’est pas None, peut être une énumération de palette de couleurs ou une image RGB565 de 256 pixels au total à utiliser comme table de correspondance de couleurs sur la valeur en niveaux de gris de l’image source, quelle qu’elle soit. Ceci est appliqué après l’extraction rgb_channel si elle est utilisée.

alpha_palette, s’il n’est pas None, peut être une image GRAYSCALE de 256 pixels au total à utiliser comme palette alpha qui module la valeur alpha de l’image source dessinée au niveau de chaque pixel, vous permettant de contrôler précisément la valeur alpha des pixels en fonction de leur valeur en niveaux de gris. Une valeur de pixel de 255 dans la table de correspondance alpha est opaque, tandis que toute valeur inférieure à 255 devient de plus en plus transparente jusqu’à 0. Ceci est appliqué après l’extraction rgb_channel si elle est utilisée.

hint est un OU logique des indicateurs listés dans Indicateurs d’aide (à l’exception de image.BLACK_BACKGROUND qui n’est pas pris en charge ici).

transform est un ndarray 3x3 utilisé pour effectuer une transformation perspective sur l’image. Pris en charge uniquement sur l’OpenMV Cam N6 actuellement, car elle dispose d’un GPU capable de réaliser cela en matériel.

copy si vrai, crée une copie profonde sur le tas de l’image convertie au lieu de convertir l’image d’origine sur place.

copy_to_fb si vrai, l’image est chargée directement dans le tampon d’image. copy_to_fb est prioritaire sur copy. Cela n’a aucun effet particulier si l’image se trouve déjà dans le tampon d’image.

Note

Les images bitmap sont comme des images en niveaux de gris avec seulement deux valeurs de pixel - 0 et 1. De plus, les images bitmap sont compactées de sorte qu’elles ne stockent qu’1 bit par pixel, ce qui les rend très petites. La bibliothèque d’images OpenMV permet d’utiliser les images bitmap partout où les images sensor.GRAYSCALE et sensor.RGB565 peuvent être utilisées. Cependant, de nombreuses opérations appliquées aux images bitmap n’ont aucun sens car les images bitmap n’ont que 2 valeurs. OpenMV recommande d’utiliser les images bitmap pour les valeurs mask dans les opérations, etc., car elles tiennent assez facilement dans le tas MicroPython. Enfin, les valeurs de pixel 0 et 1 des images bitmap sont interprétées comme noir et blanc lorsqu’elles sont appliquées aux images sensor.GRAYSCALE ou sensor.RGB565. La bibliothèque gère automatiquement la conversion.

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

to_grayscale(x_scale: float = 1.0, y_scale: float = 1.0, roi: Tuple[int, int, int, int] | None = None, rgb_channel: int = -1, alpha: int = 255, color_palette: int | Image | None = None, alpha_palette: Image | None = None, hint: int = 0, transform: ndarray | None = None, copy: bool = False, copy_to_fb: bool = False) → Image¶

Convertit une image en image en niveaux de gris (8 bits par pixel).

hint est un OU logique des indicateurs listés dans Indicateurs d’aide (à l’exception de image.BLACK_BACKGROUND qui n’est pas pris en charge ici).

copy si vrai, crée une copie profonde sur le tas de l’image convertie au lieu de convertir l’image d’origine sur place.

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

to_rgb565(x_scale: float = 1.0, y_scale: float = 1.0, roi: Tuple[int, int, int, int] | None = None, rgb_channel: int = -1, alpha: int = 255, color_palette: int | Image | None = None, alpha_palette: Image | None = None, hint: int = 0, transform: ndarray | None = None, copy: bool = False, copy_to_fb: bool = False) → Image¶

Convertit une image en image RGB565 (16 bits par pixel).

hint est un OU logique des indicateurs listés dans Indicateurs d’aide (à l’exception de image.BLACK_BACKGROUND qui n’est pas pris en charge ici).

copy si vrai, crée une copie profonde sur le tas de l’image convertie au lieu de convertir l’image d’origine sur place.

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

to_rainbow(x_scale: float = 1.0, y_scale: float = 1.0, roi: Tuple[int, int, int, int] | None = None, rgb_channel: int = -1, alpha: int = 255, color_palette: int | Image = PALETTE_RAINBOW, alpha_palette: Image | None = None, hint: int = 0, transform: ndarray | None = None, copy: bool = False, copy_to_fb: bool = False) → Image¶

Convertit une image en image RGB565 arc-en-ciel (16 bits par pixel).

hint est un OU logique des indicateurs listés dans Indicateurs d’aide (à l’exception de image.BLACK_BACKGROUND qui n’est pas pris en charge ici).

copy si vrai, crée une copie profonde sur le tas de l’image convertie au lieu de convertir l’image d’origine sur place.

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

to_ironbow(x_scale: float = 1.0, y_scale: float = 1.0, roi: Tuple[int, int, int, int] | None = None, rgb_channel: int = -1, alpha: int = 255, color_palette: int | Image = PALETTE_IRONBOW, alpha_palette: Image | None = None, hint: int = 0, transform: ndarray | None = None, copy: bool = False, copy_to_fb: bool = False) → Image¶

Convertit une image en image RGB565 ironbow (16 bits par pixel).

hint est un OU logique des indicateurs listés dans Indicateurs d’aide (à l’exception de image.BLACK_BACKGROUND qui n’est pas pris en charge ici).

copy si vrai, crée une copie profonde sur le tas de l’image convertie au lieu de convertir l’image d’origine sur place.

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

to_depth(x_scale: float = 1.0, y_scale: float = 1.0, roi: Tuple[int, int, int, int] | None = None, rgb_channel: int = -1, alpha: int = 255, color_palette: int | Image = PALETTE_IRONBOW, alpha_palette: Image | None = None, hint: int = 0, transform: ndarray | None = None, copy: bool = False, copy_to_fb: bool = False) → Image¶

Convertit une image en image de profondeur RGB565 (16 bits par pixel).

color_palette, s’il n’est pas None, peut être image.PALETTE_DEPTH ou une image RGB565 de 256 pixels au total à utiliser comme table de correspondance de couleurs sur la valeur en niveaux de gris de l’image source, quelle qu’elle soit. Ceci est appliqué après l’extraction rgb_channel si elle est utilisée.

hint est un OU logique des indicateurs listés dans Indicateurs d’aide (à l’exception de image.BLACK_BACKGROUND qui n’est pas pris en charge ici).

copy si vrai, crée une copie profonde sur le tas de l’image convertie au lieu de convertir l’image d’origine sur place.

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

to_evt_dark(x_scale: float = 1.0, y_scale: float = 1.0, roi: Tuple[int, int, int, int] | None = None, rgb_channel: int = -1, alpha: int = 255, color_palette: int | Image = PALETTE_IRONBOW, alpha_palette: Image | None = None, hint: int = 0, transform: ndarray | None = None, copy: bool = False, copy_to_fb: bool = False) → Image¶

Convertit une image en image RGB565 d’événements sombres (16 bits par pixel).

hint est un OU logique des indicateurs listés dans Indicateurs d’aide (à l’exception de image.BLACK_BACKGROUND qui n’est pas pris en charge ici).

copy si vrai, crée une copie profonde sur le tas de l’image convertie au lieu de convertir l’image d’origine sur place.

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

to_evt_light(x_scale: float = 1.0, y_scale: float = 1.0, roi: Tuple[int, int, int, int] | None = None, rgb_channel: int = -1, alpha: int = 255, color_palette: int | Image = PALETTE_IRONBOW, alpha_palette: Image | None = None, hint: int = 0, transform: ndarray | None = None, copy: bool = False, copy_to_fb: bool = False) → Image¶

Convertit une image en image RGB565 d’événements clairs (16 bits par pixel).

hint est un OU logique des indicateurs listés dans Indicateurs d’aide (à l’exception de image.BLACK_BACKGROUND qui n’est pas pris en charge ici).

copy si vrai, crée une copie profonde sur le tas de l’image convertie au lieu de convertir l’image d’origine sur place.

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

to_jpeg(x_scale: float = 1.0, y_scale: float = 1.0, roi: Tuple[int, int, int, int] | None = None, rgb_channel: int = -1, alpha: int = 255, color_palette: int | Image | None = None, alpha_palette: Image | None = None, hint: int = 0, transform: ndarray | None = None, copy: bool = False, copy_to_fb: bool = False, quality: int = 90, subsampling: int = 0) → Image¶

Convertit une image en image JPEG.

hint est un OU logique des indicateurs listés dans Indicateurs d’aide (à l’exception de image.BLACK_BACKGROUND qui n’est pas pris en charge ici).

copy si vrai, crée une copie profonde sur le tas de l’image convertie au lieu de convertir l’image d’origine sur place.

quality contrôle la qualité de compression de l’image jpeg. La valeur peut être comprise entre 0 et 100.

subsampling peut être :

image.JPEG_SUBSAMPLING_AUTO : Utilise le meilleur sous-échantillonnage pour l’image en fonction de la qualité.

image.JPEG_SUBSAMPLING_444 : Utilise un sous-échantillonnage 4:4:4.

image.JPEG_SUBSAMPLING_422 : Utilise un sous-échantillonnage 4:2:2.

image.JPEG_SUBSAMPLING_420 : Utilise un sous-échantillonnage 4:2:0.

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

to_png(x_scale: float = 1.0, y_scale: float = 1.0, roi: Tuple[int, int, int, int] | None = None, rgb_channel: int = -1, alpha: int = 255, color_palette: int | Image | None = None, alpha_palette: Image | None = None, hint: int = 0, transform: ndarray | None = None, copy: bool = False, copy_to_fb: bool = False) → Image¶

Convertit une image en image PNG.

hint est un OU logique des indicateurs listés dans Indicateurs d’aide (à l’exception de image.BLACK_BACKGROUND qui n’est pas pris en charge ici).

copy si vrai, crée une copie profonde sur le tas de l’image convertie au lieu de convertir l’image d’origine sur place.

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

compress(x_scale: float = 1.0, y_scale: float = 1.0, roi: Tuple[int, int, int, int] | None = None, rgb_channel: int = -1, alpha: int = 255, color_palette: int | Image | None = None, alpha_palette: Image | None = None, hint: int = 0, transform: ndarray | None = None, copy: bool = False, copy_to_fb: bool = False, quality: int = 90, subsampling: int = 0) → Image¶

Convertit une image en image JPEG.

hint est un OU logique des indicateurs listés dans Indicateurs d’aide (à l’exception de image.BLACK_BACKGROUND qui n’est pas pris en charge ici).

copy si vrai, crée une copie profonde sur le tas de l’image convertie au lieu de convertir l’image d’origine sur place.

quality contrôle la qualité de compression de l’image jpeg. La valeur peut être comprise entre 0 et 100.

subsampling peut être :

image.JPEG_SUBSAMPLING_AUTO : Utilise le meilleur sous-échantillonnage pour l’image en fonction de la qualité.

image.JPEG_SUBSAMPLING_444 : Utilise un sous-échantillonnage 4:4:4.

image.JPEG_SUBSAMPLING_422 : Utilise un sous-échantillonnage 4:2:2.

image.JPEG_SUBSAMPLING_420 : Utilise un sous-échantillonnage 4:2:0.

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

Note

Image.compress est un alias de Image.to_jpeg.

copy(x_scale: float = 1.0, y_scale: float = 1.0, roi: Tuple[int, int, int, int] | None = None, rgb_channel: int = -1, alpha: int = 255, color_palette: int | Image | None = None, alpha_palette: Image | None = None, hint: int = 0, transform: ndarray | None = None, copy_to_fb: bool = False) → Image¶

Crée une copie profonde de l’objet image.

hint est un OU logique des indicateurs listés dans Indicateurs d’aide (à l’exception de image.BLACK_BACKGROUND qui n’est pas pris en charge ici).

copy_to_fb si vrai, l’image est chargée directement dans le tampon d’image. Cela n’a aucun effet particulier si l’image se trouve déjà dans le tampon d’image.

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

crop(x_scale: float = 1.0, y_scale: float = 1.0, roi: Tuple[int, int, int, int] | None = None, rgb_channel: int = -1, alpha: int = 255, color_palette: int | Image | None = None, alpha_palette: Image | None = None, hint: int = 0, transform: ndarray | None = None, copy: bool = False, copy_to_fb: bool = False) → Image¶

Modifie une image sur place sans changer le type d’image sous-jacent.

hint est un OU logique des indicateurs listés dans Indicateurs d’aide (à l’exception de image.BLACK_BACKGROUND qui n’est pas pris en charge ici).

copy si vrai, crée une copie profonde sur le tas de l’image convertie au lieu de convertir l’image d’origine sur place.

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

scale(x_scale: float = 1.0, y_scale: float = 1.0, roi: Tuple[int, int, int, int] | None = None, rgb_channel: int = -1, alpha: int = 255, color_palette: int | Image | None = None, alpha_palette: Image | None = None, hint: int = 0, transform: ndarray | None = None, copy: bool = False, copy_to_fb: bool = False) → Image¶

Modifie une image sur place sans changer le type d’image sous-jacent.

hint est un OU logique des indicateurs listés dans Indicateurs d’aide (à l’exception de image.BLACK_BACKGROUND qui n’est pas pris en charge ici).

copy si vrai, crée une copie profonde sur le tas de l’image convertie au lieu de convertir l’image d’origine sur place.

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

Note

Image.scale est un alias de Image.crop.

save(path: str, roi: Tuple[int, int, int, int] | None = None, quality: int = 50) → Image¶

Enregistre une copie de l’image dans le système de fichiers au chemin path.

Prend en charge les fichiers image bmp/pgm/ppm/jpg/jpeg. Notez que vous ne pouvez pas enregistrer des images compressées jpeg dans un format non compressé.

roi est le rectangle de la région d’intérêt (x, y, w, h) à enregistrer. S’il n’est pas spécifié, il est égal au rectangle de l’image, ce qui copie l’image entière. Cet argument n’est pas applicable aux images JPEG.

quality est la qualité de compression jpeg à utiliser pour enregistrer l’image au format jpeg si l’image n’est pas déjà compressée (0-100) (int).

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

flush() → None¶: Met à jour le tampon d’image dans l’IDE avec l’image présente dans le tampon d’image de la caméra.

Méthodes de dessin¶

clear(mask: Image | None = None) → Image¶

Met tous les pixels de l’image à zéro (très rapide).

mask est une autre image à utiliser comme masque au niveau du pixel pour l’opération. Le masque doit être une image comportant uniquement des pixels noirs ou blancs et doit avoir la même taille que l’image sur laquelle on opère. Seuls les pixels définis dans le masque sont modifiés.

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

Non pris en charge sur les images compressées.

draw_line(x0: int, y0: int, x1: int, y1: int, color: int | Tuple[int, int, int] | None = None, thickness: int = 1) → Image¶

Dessine une ligne de (x0, y0) à (x1, y1) sur l’image. Vous pouvez passer x0, y0, x1, y1 séparément ou sous forme de tuple (x0, y0, x1, y1).

color est un tuple RGB888 pour les images en niveaux de gris ou RGB565. La valeur par défaut est le blanc. Cependant, vous pouvez aussi passer la valeur du pixel sous-jacent (0-255) pour les images en niveaux de gris ou une valeur RGB565 pour les images RGB565.

thickness contrôle l’épaisseur de la ligne en pixels.

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

Non pris en charge sur les images compressées ou les images bayer.

draw_rectangle(x: int, y: int, w: int, h: int, color: int | Tuple[int, int, int] | None = None, thickness: int = 1, fill: bool = False) → Image¶

Dessine un rectangle sur l’image. Vous pouvez passer x, y, w, h séparément ou sous forme de tuple (x, y, w, h).

thickness contrôle l’épaisseur des lignes en pixels.

Passez fill à True pour remplir le rectangle.

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

Non pris en charge sur les images compressées ou les images bayer.

draw_circle(x: int, y: int, radius: int, color: int | Tuple[int, int, int] | None = None, thickness: int = 1, fill: bool = False) → Image¶

Dessine un cercle sur l’image. Vous pouvez passer x, y, radius séparément ou sous forme de tuple (x, y, radius).

thickness contrôle l’épaisseur des bords en pixels.

Passez fill à True pour remplir le cercle.

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

Non pris en charge sur les images compressées ou les images bayer.

draw_ellipse(cx: int, cy: int, rx: int, ry: int, rotation: int, color: int | Tuple[int, int, int] | None = None, thickness: int = 1, fill: bool = False) → Image¶

Dessine une ellipse sur l’image. Vous pouvez passer cx, cy, rx, ry et la rotation (en degrés) séparément ou sous forme de tuple (cx, yc, rx, ry, rotation).

thickness contrôle l’épaisseur des bords en pixels.

Passez fill à True pour remplir l’ellipse.

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

Non pris en charge sur les images compressées ou les images bayer.

draw_string(x: int, y: int, text: str, color: int | Tuple[int, int, int] | None = None, scale: float = 1, x_spacing: int = 0, y_spacing: int = 0, mono_space: bool = True, char_rotation: int = 0, char_hmirror: bool = False, char_vflip: bool = False, string_rotation: int = 0, string_hmirror: bool = False, string_vflip: bool = False) → Image¶

Dessine du texte 8x10 à partir de l’emplacement (x, y) dans l’image. Vous pouvez passer x, y séparément ou sous forme de tuple (x, y).

text est une chaîne à écrire dans l’image. Les fins de ligne \n, \r et \r\n déplacent le curseur à la ligne suivante.

scale peut être augmenté pour augmenter/diminuer la taille du texte sur l’image. Vous pouvez passer des valeurs entières ou en virgule flottante supérieures à 0.

x_spacing vous permet d’ajouter (si positif) ou de soustraire (si négatif) des pixels x entre les caractères.

y_spacing vous permet d’ajouter (si positif) ou de soustraire (si négatif) des pixels y entre les caractères (pour le texte multi-lignes).

mono_space vaut True par défaut, ce qui force l’espacement fixe du texte. Pour les grandes échelles de texte, cela rend très mal. Définissez-le à False pour obtenir un espacement de caractères à largeur non fixe, ce qui rend BEAUCOUP mieux.

char_rotation peut valoir 0, 90, 180, 270 pour faire pivoter chaque caractère de la chaîne de cette valeur.

char_hmirror si True, met en miroir horizontal tous les caractères de la chaîne.

char_vflip si True, retourne verticalement tous les caractères de la chaîne.

string_rotation peut valoir 0, 90, 180, 270 pour faire pivoter la chaîne de cette valeur.

string_hmirror si True, met la chaîne en miroir horizontal.

string_vflip si True, retourne la chaîne verticalement.

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

Non pris en charge sur les images compressées ou les images bayer.

draw_cross(x: int, y: int, color: int | Tuple[int, int, int] | None = None, size: int = 5, thickness: int = 1) → Image¶

Dessine une croix à l’emplacement x, y. Vous pouvez passer x, y séparément ou sous forme de tuple (x, y).

size contrôle la longueur des lignes de la croix.

thickness contrôle l’épaisseur des bords en pixels.

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

Non pris en charge sur les images compressées ou les images bayer.

draw_arrow(x0: int, y0: int, x1: int, y1: int, color: int | Tuple[int, int, int] | None = None, thickness: int = 1) → Image¶

Dessine une flèche de (x0, y0) à (x1, y1) sur l’image. Vous pouvez passer x0, y0, x1, y1 séparément ou sous forme de tuple (x0, y0, x1, y1).

thickness contrôle l’épaisseur de la ligne en pixels.

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

Non pris en charge sur les images compressées ou les images bayer.

draw_detection(detection: Tuple[int, int, int, int, int, int], color1: int | Tuple[int, int, int] | None = None, color2: int | Tuple[int, int, int] | None = None, size: int = 5, thickness: int = 1, fill: bool = False, label: str | None = None, label_offset: Tuple[int, int] | None = None) → Image¶

Dessine un résultat de détection sur l’image. detection est un 6-tuple (rx, ry, rw, rh, cx, cy) décrivant un rectangle englobant et un barycentre (généralement renvoyé par du code de réseau de neurones ou de suivi de couleur).

color1 est la couleur du rectangle et color2 est la couleur de la croix du barycentre. size est la taille de la croix du barycentre, thickness contrôle l’épaisseur du contour, et fill remplit le rectangle.

label, s’il est fourni, est dessiné près du rectangle, décalé de label_offset (x, y).

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

Non pris en charge sur les images compressées ou les images bayer.

draw_edges(corners: List[Tuple[int, int]], color: int | Tuple[int, int, int] | None = None, size: int = 0, thickness: int = 1, fill: bool = False) → Image¶

Dessine les contours des lignes entre une liste de coins renvoyée par des méthodes comme blob.corners. Corners est un tuple à quatre valeurs de tuples x/y à deux valeurs. Par ex. [(x1,y1),(x2,y2),(x3,y3),(x4,y4)].

size, s’il est supérieur à 0, fait dessiner les coins sous forme de cercles de rayon size.

thickness contrôle l’épaisseur de la ligne en pixels.

Passez fill à True pour remplir les cercles des coins s’ils sont dessinés.

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

Non pris en charge sur les images compressées ou les images bayer.

draw_image(image: Image, x: int = 0, y: int = 0, x_scale: float = 1.0, y_scale: float = 1.0, roi: Tuple[int, int, int, int] | None = None, rgb_channel: int = -1, alpha: int = 255, color_palette: int | Image | None = None, alpha_palette: Image | None = None, hint: int = 0, transform: ndarray | None = None, mask: Image | None = None) → Image¶

Dessine une image dont le coin supérieur gauche commence à l’emplacement x, y. Vous pouvez passer x, y séparément ou sous forme de tuple (x, y). Cette méthode gère automatiquement le rendu de l’image passée dans le format de pixel correct pour l’image de destination tout en gérant aussi le découpage de manière transparente.

Vous pouvez aussi passer un chemin au lieu d’un objet image à cette méthode pour charger automatiquement l’image depuis le disque et l’utiliser en une seule étape. Par ex. draw_image("test.jpg").

hint est un OU logique des indicateurs listés dans Indicateurs d’aide (y compris image.BLACK_BACKGROUND qui est pris en charge ici).

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

draw_keypoints(keypoints: kp_desc | List[Tuple[int, int, int]], color: int | Tuple[int, int, int] | None = None, size: int = 10, thickness: int = 1, fill: bool = False) → Image¶

Dessine les points clés d’un objet de points clés sur l’image. Vous pouvez aussi passer une liste de tuples à trois valeurs contenant le (x, y, angle_de_rotation_en_degres) pour réutiliser cette méthode afin de dessiner des glyphes de points clés qui sont un cercle avec une ligne pointant dans une direction particulière.

size contrôle la taille des points clés.

thickness contrôle l’épaisseur de la ligne en pixels.

Passez fill à True pour remplir les points clés.

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

Non pris en charge sur les images compressées ou les images bayer.

flood_fill(x: int, y: int, seed_threshold: float = 0.05, floating_threshold: float = 0.05, color: int | Tuple[int, int, int] | None = None, invert: bool = False, clear_background: bool = False, mask: Image | None = None) → Image¶

Remplit par diffusion une région de l’image à partir de l’emplacement x, y. Vous pouvez passer x, y séparément ou sous forme de tuple (x, y).

seed_threshold contrôle à quel point un pixel de la zone de remplissage peut différer du pixel de départ d’origine.

floating_threshold contrôle à quel point un pixel de la zone de remplissage peut différer de ses pixels voisins.

Passez invert à True pour recolorer tout ce qui se trouve en dehors de la zone connexe de remplissage par diffusion.

Passez clear_background à True pour mettre à zéro le reste des pixels que le remplissage par diffusion n’a pas recolorés.

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

Non pris en charge sur les images compressées ou les images bayer.

Cette méthode n’est pas disponible sur l’OpenMV Cam M4.

draw_event_histogram(array: ndarray, clear: bool = True, brightness: int = 128, contrast: int = 16) → Image¶

Rastérise un ndarray d’événements (tel que rempli par csi.IOCTL_GENX320_READ_EVENTS) sur une Image pour la visualisation. Le tampon d’image doit être une image GRAYSCALE de 320x320.

Pour chaque ligne csi.PIX_ON_EVENT, le pixel de l’événement se voit ajouter +contrast ; pour chaque ligne csi.PIX_OFF_EVENT, le pixel se voit ajouter -contrast. Les événements de déclenchement sont ignorés. Les valeurs de pixel sont écrêtées entre 0 et 255.

clear si True, réinitialise le tampon d’image à brightness avant le dessin — chaque trame devient un rendu frais ne contenant que les événements. Définissez-le à False pour accumuler les événements sur plusieurs appels (utile pour les traînées de mouvement à longue exposition).

brightness contrôle la valeur de référence gris moyen à laquelle le tampon est réinitialisé lorsque clear est True. La valeur par défaut 128 place les événements ON à l’extrémité claire et les événements OFF à l’extrémité sombre avec une marge égale.

contrast contrôle de combien chaque événement décale son pixel — des valeurs plus élevées font ressortir les événements, au prix d’une saturation rapide lorsque de nombreux événements atterrissent sur le même pixel.

Méthodes de masquage¶

mask_rectangle(x: int, y: int, w: int, h: int) → Image¶

Met à zéro une partie rectangulaire de l’image. Si aucun argument n’est fourni, cette méthode met à zéro le centre de l’image.

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

Non pris en charge sur les images compressées ou les images bayer.

mask_circle(x: int, y: int, radius: int) → Image¶

Met à zéro une partie circulaire de l’image. Si aucun argument n’est fourni, cette méthode met à zéro le centre de l’image.

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

Non pris en charge sur les images compressées ou les images bayer.

mask_ellipse(x: int, y: int, radius_x: int, radius_y: int, rotation_angle_in_degrees: int) → Image¶

Met à zéro une partie en forme d’ellipse de l’image. Si aucun argument n’est fourni, cette méthode met à zéro le centre de l’image.

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

Non pris en charge sur les images compressées ou les images bayer.

Méthodes binaires¶

binary(thresholds: List[Tuple[int, int]], invert: bool = False, zero: bool = False, mask: Image | None = None, to_bitmap: bool = False, copy: bool = False) → Image¶

Met tous les pixels de l’image à noir ou blanc selon que chaque pixel se trouve à l’intérieur de l’un des tuples de seuil de thresholds.

thresholds est une liste de tuples (lo, hi) pour les images en niveaux de gris, ou de tuples (l_lo, l_hi, a_lo, a_hi, b_lo, b_hi) pour les images RGB565. Les valeurs min/max inversées sont corrigées automatiquement ; les composantes manquantes prennent par défaut la plage maximale.

invert inverse la correspondance de seuil.

zero si True, met à zéro les pixels seuillés et laisse les autres intacts.

mask est une image binaire utilisée comme masque au niveau du pixel ; seuls les pixels définis dans le masque sont modifiés.

to_bitmap si True, convertit les données de l’image en bitmap d’1 bit par pixel. Pour de très petites images, cela peut nécessiter copy=True.

copy si True, renvoie une nouvelle image sur le tas au lieu de modifier l’image source.

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

Non pris en charge sur les images compressées ou les images bayer.

invert() → Image¶

Inverse toutes les valeurs de pixel de l’image (chaque pixel devient 255 - pixel pour les canaux 8 bits).

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

Non pris en charge sur les images compressées ou les images bayer/yuv.

b_and(image: Image, mask: Image | None = None) → Image¶

Effectue un ET logique entre cette image et une autre image.

image peut être un objet image, un chemin vers un fichier image non compressé (bmp/pgm/ppm), ou une valeur scalaire (tuple RGB888 ou valeur de pixel sous-jacente).

mask est une image binaire utilisée comme masque au niveau du pixel ; seuls les pixels définis dans le masque sont modifiés.

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

Non pris en charge sur les images compressées ou les images bayer.

b_nand(image: Image, mask: Image | None = None) → Image¶

Effectue un NON-ET (NAND) logique entre cette image et une autre image.

image peut être un objet image, un chemin vers un fichier image non compressé (bmp/pgm/ppm), ou une valeur scalaire (tuple RGB888 ou valeur de pixel sous-jacente).

mask est une image binaire utilisée comme masque au niveau du pixel ; seuls les pixels définis dans le masque sont modifiés.

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

Non pris en charge sur les images compressées ou les images bayer.

b_or(image: Image, mask: Image | None = None) → Image¶

Effectue un OU logique entre cette image et une autre image.

image peut être un objet image, un chemin vers un fichier image non compressé (bmp/pgm/ppm), ou une valeur scalaire (tuple RGB888 ou valeur de pixel sous-jacente).

mask est une image binaire utilisée comme masque au niveau du pixel ; seuls les pixels définis dans le masque sont modifiés.

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

Non pris en charge sur les images compressées ou les images bayer.

b_nor(image: Image, mask: Image | None = None) → Image¶

Effectue un NON-OU (NOR) logique entre cette image et une autre image.

image peut être un objet image, un chemin vers un fichier image non compressé (bmp/pgm/ppm), ou une valeur scalaire (tuple RGB888 ou valeur de pixel sous-jacente).

mask est une image binaire utilisée comme masque au niveau du pixel ; seuls les pixels définis dans le masque sont modifiés.

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

Non pris en charge sur les images compressées ou les images bayer.

b_xor(image: Image, mask: Image | None = None) → Image¶

Effectue un OU exclusif (XOR) logique entre cette image et une autre image.

image peut être un objet image, un chemin vers un fichier image non compressé (bmp/pgm/ppm), ou une valeur scalaire (tuple RGB888 ou valeur de pixel sous-jacente).

mask est une image binaire utilisée comme masque au niveau du pixel ; seuls les pixels définis dans le masque sont modifiés.

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

Non pris en charge sur les images compressées ou les images bayer.

b_xnor(image: Image, mask: Image | None = None) → Image¶

Effectue un NON-OU exclusif (XNOR) logique entre cette image et une autre image.

image peut être un objet image, un chemin vers un fichier image non compressé (bmp/pgm/ppm), ou une valeur scalaire (tuple RGB888 ou valeur de pixel sous-jacente).

mask est une image binaire utilisée comme masque au niveau du pixel ; seuls les pixels définis dans le masque sont modifiés.

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

Non pris en charge sur les images compressées ou les images bayer.

Méthodes ISP¶

awb(max: bool = False) → Image¶

Effectue une balance des blancs automatique sur l’image à l’aide de l’algorithme gray-world. Opère sur les images Bayer brutes (RAW) ou RGB565. N’a aucun effet sur les images binaires/en niveaux de gris.

max si True, utilise plutôt l’algorithme white-patch.

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

Non pris en charge sur les images compressées ou yuv.

ccm(matrix: List[List[float]]) → Image¶

Multiplie la matrice de correction des couleurs en virgule flottante passée avec l’image. Les matrices peuvent être 3x3 ou 3x4 (avec colonne de décalage), sous forme de liste imbriquée ou de liste plate

[[rr, rg, rb], [gr, gg, gb], [br, bg, bb]]
[[rr, rg, rb, ro], [gr, gg, gb, go], [br, bg, bb, bo]]
[rr, rg, rb, ro, gr, gg, gb, go, br, bg, bb, bo]

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

Non pris en charge sur les images compressées ou les images bayer/yuv.

gamma(gamma: float = 1.0, contrast: float = 1.0, brightness: float = 0.0) → Image¶

Ajuste le gamma, le contraste et la luminosité de l’image.

gamma applique pow(pixel, 1/gamma) après normalisation. Les valeurs supérieures à 1.0 éclaircissent ; inférieures à 1.0 assombrissent.

contrast applique pixel * contrast après normalisation.

brightness applique pixel + brightness après normalisation.

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

Non pris en charge sur les images compressées ou les images bayer/yuv.

gamma_corr(gamma: float = 1.0, contrast: float = 1.0, brightness: float = 0.0) → Image¶: Alias de Image.gamma.

Méthodes mathématiques¶

negate() → Image¶: Alias de Image.invert.

replace(image: Image | None = None, **kwargs) → Image¶: Alias de Image.draw_image(). Remplace cette image par image (ou transforme cette image sur place si image est omis) en utilisant les arguments nommés standard de draw_image. L’argument transform est un ndarray 3x3 décrivant une transformation perspective (pris en charge uniquement sur les caméras OpenMV avec ULAB activé).

assign(image: Image | None = None, **kwargs) → Image¶: Alias de Image.replace().

set(image: Image | None = None, **kwargs) → Image¶: Alias de Image.replace().

add(image: Image, mask: Image | None = None) → Image¶

Ajoute une image à celle-ci pixel par pixel.

image peut être un objet image, un chemin vers un fichier image non compressé (bmp/pgm/ppm), ou une valeur scalaire (tuple RGB888 ou valeur de pixel sous-jacente).

mask est une image binaire utilisée comme masque au niveau du pixel ; seuls les pixels définis dans le masque sont modifiés.

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

Non pris en charge sur les images compressées ou les images bayer.

sub(image: Image, mask: Image | None = None) → Image¶

Soustrait image de cette image pixel par pixel (self - image).

image peut être soit un objet image, soit un chemin vers un fichier image non compressé (bmp/pgm/ppm), soit une valeur scalaire (tuple RGB888 ou valeur de pixel sous-jacente).

mask est une image binaire utilisée comme masque au niveau du pixel ; seuls les pixels définis dans le masque sont modifiés.

Cette méthode accepte aussi l’ensemble complet des arguments nommés de Image.draw_image() (x, y, x_scale, y_scale, roi, rgb_channel, alpha, color_palette, alpha_palette, hint, transform).

Non pris en charge sur les images compressées ou les images bayer.

rsub(image: Image, mask: Image | None = None) → Image¶: Soustraction inversée : remplace cette image par image - self pixel par pixel. Par ailleurs identique à Image.sub().

min(image: Image, mask: Image | None = None) → Image¶

Renvoie l’image minimale de deux images pixel par pixel.

image peut être un objet image, un chemin vers un fichier image non compressé (bmp/pgm/ppm), ou une valeur scalaire (tuple RGB888 ou valeur de pixel sous-jacente).

mask est une image binaire utilisée comme masque au niveau du pixel ; seuls les pixels définis dans le masque sont modifiés.

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

Non pris en charge sur les images compressées ou les images bayer.

max(image: Image, mask: Image | None = None) → Image¶

Renvoie l’image maximale de deux images pixel par pixel.

image peut être un objet image, un chemin vers un fichier image non compressé (bmp/pgm/ppm), ou une valeur scalaire (tuple RGB888 ou valeur de pixel sous-jacente).

mask est une image binaire utilisée comme masque au niveau du pixel ; seuls les pixels définis dans le masque sont modifiés.

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

Non pris en charge sur les images compressées ou les images bayer.

difference(image: Image, mask: Image | None = None) → Image¶

Renvoie l’image de différence absolue entre deux images (par ex. ||a-b||).

image peut être un objet image, un chemin vers un fichier image non compressé (bmp/pgm/ppm), ou une valeur scalaire (tuple RGB888 ou valeur de pixel sous-jacente).

mask est une image binaire utilisée comme masque au niveau du pixel ; seuls les pixels définis dans le masque sont modifiés.

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

Non pris en charge sur les images compressées ou les images bayer.

blend(image: Image, x: int = 0, y: int = 0, alpha: int = 128, mask: Image | None = None, **kwargs) → Image¶: Alias de Image.draw_image(). Mélange image dans cette image par fondu alpha. alpha est un entier 0-256 ; les valeurs plus proches de 256 favorisent l’image source. Accepte tous les arguments nommés de Image.draw_image().

histeq(adaptive: bool = False, clip_limit: float = -1, mask: Image | None = None) → Image¶

Exécute une égalisation d’histogramme sur l’image pour normaliser le contraste et la luminosité.

adaptive si True, exécute une égalisation d’histogramme adaptative (plus lente mais généralement meilleure).

clip_limit limite le contraste dans la variante adaptative (une petite valeur comme 10 produit de bons résultats CLAHE).

mask est une image binaire utilisée comme masque au niveau du pixel ; seuls les pixels définis dans le masque sont modifiés.

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

Non pris en charge sur les images compressées ou les images bayer.

Méthodes de filtrage¶

erode(size: int, threshold: int | None = None, mask: Image | None = None) → Image¶

Retire des pixels des bords des zones segmentées. Convolue un noyau ((size*2)+1)x((size*2)+1) sur l’image, effaçant le pixel central si plus de threshold voisins sont effacés (agit comme une érosion standard si threshold est None).

mask est une image binaire utilisée comme masque au niveau du pixel ; seuls les pixels définis dans le masque sont modifiés.

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

Non pris en charge sur les images compressées ou les images bayer/yuv.

dilate(size: int, threshold: int | None = None, mask: Image | None = None) → Image¶

Ajoute des pixels aux bords des zones segmentées. Convolue un noyau ((size*2)+1)x((size*2)+1) sur l’image, définissant le pixel central si plus de threshold voisins sont définis (agit comme une dilatation standard si threshold est None).

mask est une image binaire utilisée comme masque au niveau du pixel ; seuls les pixels définis dans le masque sont modifiés.

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

Non pris en charge sur les images compressées ou les images bayer/yuv.

open(size: int, threshold: int | None = None, mask: Image | None = None) → Image¶

Effectue une érosion puis une dilatation. Voir Image.erode() et Image.dilate().

mask est une image binaire utilisée comme masque au niveau du pixel ; seuls les pixels définis dans le masque sont modifiés.

Non pris en charge sur les images compressées ou les images bayer/yuv.

close(size: int, threshold: int | None = None, mask: Image | None = None) → Image¶

Effectue une dilatation puis une érosion. Voir Image.dilate() et Image.erode().

mask est une image binaire utilisée comme masque au niveau du pixel ; seuls les pixels définis dans le masque sont modifiés.

Non pris en charge sur les images compressées ou les images bayer/yuv.

top_hat(size: int, threshold: int | None = None, mask: Image | None = None) → Image¶

Renvoie la différence d’image entre l’image et l’image traitée par Image.open().

mask est une image binaire utilisée comme masque au niveau du pixel ; seuls les pixels définis dans le masque sont modifiés.

Non pris en charge sur les images compressées ou les images bayer/yuv.

black_hat(size: int, threshold: int | None = None, mask: Image | None = None) → Image¶

Renvoie la différence d’image entre l’image et l’image traitée par Image.close().

mask est une image binaire utilisée comme masque au niveau du pixel ; seuls les pixels définis dans le masque sont modifiés.

Non pris en charge sur les images compressées ou les images bayer/yuv.

mean(size: int, threshold: bool | None = False, offset: int | None = 0, invert: bool | None = False, mask: Image | None = None) → Image¶

Filtre de flou moyen standard utilisant un filtre par boîte.

size est la taille du noyau. Utilisez 1 (noyau 3x3), 2 (noyau 5x5), etc.

threshold si True, seuille de manière adaptative la sortie du filtre en une image binaire. offset décale la binarisation (négatif rend plus de pixels blancs, positif en rend moins). invert inverse la sortie binaire.

mask est une image binaire utilisée comme masque au niveau du pixel ; seuls les pixels définis dans le masque sont modifiés.

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

Non pris en charge sur les images compressées ou les images bayer/yuv.

Exécute un filtre par percentile sur l’image (médiane par défaut).

size est la taille du noyau. Utilisez 1 (noyau 3x3), 2 (noyau 5x5), etc.

percentile est le percentile à sélectionner dans chaque noyau (0 = min, 0.5 = médiane, 1.0 = max). La valeur par défaut est 0.5.

mask est une image binaire utilisée comme masque au niveau du pixel ; seuls les pixels définis dans le masque sont modifiés.

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

Non pris en charge sur les images compressées ou les images bayer/yuv.

mode(size: int, threshold: bool | None = False, offset: int | None = 0, invert: bool | None = False, mask: Image | None = None) → Image¶

Remplace chaque pixel par le mode de ses voisins. Peut produire des artéfacts sur les bords des images RGB en raison de l’opération non linéaire.

size est la taille du noyau. Utilisez 1 (noyau 3x3), 2 (noyau 5x5), etc.

mask est une image binaire utilisée comme masque au niveau du pixel ; seuls les pixels définis dans le masque sont modifiés.

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

Non pris en charge sur les images compressées ou les images bayer/yuv.

Exécute le filtre du point milieu sur l’image. Ce filtre trouve le point milieu ((max-min)/2) de chaque voisinage de pixel dans l’image.

size est la taille du noyau. Utilisez 1 (noyau 3x3), 2 (noyau 5x5), etc.

bias contrôle le mélange min/max. 0 pour un filtrage min uniquement, 1.0 pour un filtrage max uniquement. En utilisant bias, vous pouvez appliquer un filtrage min/max à l’image.

mask est une image binaire utilisée comme masque au niveau du pixel ; seuls les pixels définis dans le masque sont modifiés.

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

Non pris en charge sur les images compressées ou les images bayer/yuv.

Convolue l’image avec un noyau de filtre arbitraire.

size contrôle la taille du noyau, qui doit comporter ((size*2)+1)x((size*2)+1) éléments.

kernel est le noyau de convolution, sous forme de liste/tuple 1D plate de ((size*2)+1)*((size*2)+1) éléments, ou de liste/tuple 2D avec ((size*2)+1) lignes de ((size*2)+1) éléments.

mul est une échelle de contraste multiplicative (par défaut 1.0).

add est un décalage de luminosité additif (par défaut 0.0).

mask est une image binaire utilisée comme masque au niveau du pixel ; seuls les pixels définis dans le masque sont modifiés.

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

Non pris en charge sur les images compressées ou les images bayer/yuv.

Convolue l’image avec un noyau gaussien de lissage.

size est la taille du noyau. Utilisez 1 (noyau 3x3), 2 (noyau 5x5), etc.

unsharp si True, effectue une opération de masque flou (accentue les contours) au lieu d’un simple flou gaussien.

mul est une échelle de contraste multiplicative (par défaut 1.0).

add est un décalage de luminosité additif (par défaut 0.0).

mask est une image binaire utilisée comme masque au niveau du pixel ; seuls les pixels définis dans le masque sont modifiés.

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

Non pris en charge sur les images compressées ou les images bayer/yuv.

laplacian(size: int, sharpen: bool | None = False, mul: float | None = 1.0, add: float | None = 0.0, threshold: bool | None = False, offset: int | None = 0, invert: bool | None = False, mask: Image | None = None) → Image¶: Convolue l’image avec un noyau laplacien de détection de contours.

size est la taille du noyau. Utilisez 1 (noyau 3x3), 2 (noyau 5x5), etc.

sharpen si True, accentue l’image au lieu de produire la réponse de contour brute non seuillée.

mul est une échelle de contraste multiplicative (par défaut 1.0).

add est un décalage de luminosité additif (par défaut 0.0).

threshold si True, seuille de manière adaptative la sortie du filtre en une image binaire. offset décale la binarisation (négatif rend plus de pixels blancs, positif en rend moins). invert inverse la sortie binaire.

mask est une image binaire utilisée comme masque au niveau du pixel ; seuls les pixels définis dans le masque sont modifiés.

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

Non pris en charge sur les images compressées ou les images bayer/yuv.

Convolue l’image avec un filtre bilatéral (lissage préservant les contours).

size est la taille du noyau. Utilisez 1 (noyau 3x3), 2 (noyau 5x5), etc.

color_sigma contrôle la tolérance de correspondance des couleurs ; des valeurs plus grandes produisent plus de flou de couleur.

space_sigma contrôle le flou spatial ; des valeurs plus grandes produisent plus de flou de pixel.

mask est une image binaire utilisée comme masque au niveau du pixel ; seuls les pixels définis dans le masque sont modifiés.

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

Non pris en charge sur les images compressées ou les images bayer/yuv.

Méthodes géométriques¶

linpolar(reverse: bool = False, *, x: int | None = None, y: int | None = None) → Image¶

Reprojette une image des coordonnées cartésiennes vers les coordonnées polaires linéaires.

Définissez reverse=True pour reprojeter dans la direction opposée.

x et y spécifient la coordonnée centrale de la transformation en pixels d’image. Si x est None (la valeur par défaut), il est défini à la moitié de la largeur de l’image ; de même, y vaut par défaut la moitié de la hauteur de l’image.

La reprojection polaire linéaire transforme la rotation d’une image en translation x.

Non pris en charge sur les images compressées ou les images bayer.

Cette méthode n’est pas disponible sur l’OpenMV Cam M4.

logpolar(reverse: bool = False, *, x: int | None = None, y: int | None = None) → Image¶

Reprojette une image des coordonnées cartésiennes vers les coordonnées polaires logarithmiques.

Définissez reverse=True pour reprojeter dans la direction opposée.

La reprojection polaire logarithmique transforme la rotation d’une image en translation x, et la mise à l’échelle/le zoom en translation y.

Non pris en charge sur les images compressées ou les images bayer.

Cette méthode n’est pas disponible sur l’OpenMV Cam M4.

lens_corr(strength: float = 1.8, zoom: float = 1.0, x_corr: float = 0.0, y_corr: float = 0.0) → Image¶

Effectue une correction d’objectif pour défisheyer l’image due à la distorsion de l’objectif.

strength est un float définissant à quel point défisheyer l’image. Essayez 1.8 par défaut puis augmentez ou diminuez à partir de là jusqu’à ce que l’image semble correcte.

zoom est le facteur de zoom à appliquer à l’image. 1.0 par défaut.

x_corr décalage de pixel en virgule flottante par rapport au centre. Peut être négatif ou positif.

y_corr décalage de pixel en virgule flottante par rapport au centre. Peut être négatif ou positif.

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

Non pris en charge sur les images compressées ou les images bayer.

rotation_corr(x_rotation: float = 0.0, y_rotation: float = 0.0, z_rotation: float = 0.0, x_translation: float = 0.0, y_translation: float = 0.0, zoom: float = 1.0, fov: float = 60.0, corners: List[Tuple[int, int]] | None = None) → Image¶

Corrige les problèmes de perspective dans l’image en effectuant une rotation 3D du tampon d’image.

x_rotation est le nombre de degrés de rotation de l’image dans le tampon d’image autour de l’axe x (c.-à-d. que cela fait tourner l’image de haut en bas).

y_rotation est le nombre de degrés de rotation de l’image dans le tampon d’image autour de l’axe y (c.-à-d. que cela fait tourner l’image de gauche à droite).

z_rotation est le nombre de degrés de rotation de l’image dans le tampon d’image autour de l’axe z (c.-à-d. que cela fait tourner l’image sur place).

x_translation est le nombre d’unités de déplacement de l’image vers la gauche ou la droite après rotation. Comme cette translation est appliquée dans l’espace 3D, les unités ne sont pas des pixels…

y_translation est le nombre d’unités de déplacement de l’image vers le haut ou le bas après rotation. Comme cette translation est appliquée dans l’espace 3D, les unités ne sont pas des pixels…

zoom est le facteur de zoom à appliquer à l’image. 1.0 par défaut.

fov est le champ de vision utilisé pour la projection interne 2D->3D. À mesure que fov approche de 0, l’image est placée à l’infini ; à mesure qu’il approche de 180, l’image est placée à l’intérieur de la fenêtre d’affichage.

corners est une liste de quatre tuples (x, y) utilisés pour construire une homographie à 4 points mappant les coins sur (0, 0), (image_width-1, 0), (image_width-1, image_height-1) et (0, image_height-1) avant d’appliquer la rotation 3D. Utile pour les transformations en vue aérienne.

Renvoie l’objet image afin que vous puissiez appeler une autre méthode en utilisant la notation ..

Non pris en charge sur les images compressées ou les images bayer.

Cette méthode n’est pas disponible sur l’OpenMV Cam M4.

Méthodes d’obtention (Get)¶

get_similarity(image: Image, x: int = 0, y: int = 0, x_scale: float = 1.0, y_scale: float = 1.0, roi: Tuple[int, int, int, int] | None = None, rgb_channel: int = -1, alpha: int = 255, color_palette: int | Image | None = None, alpha_palette: Image | None = None, hint: int = 0, transform: ndarray | None = None, dssim: bool = False) → Similarity¶

Calcule la similarité entre deux images à l’aide de l’indice de similarité structurelle (SSIM). Le SSIM varie de -1 (opposé) à 1 (identique). Renvoie un objet image.similarity.

image est l’image à comparer (un objet image ou une chaîne de chemin, par ex. "test.jpg").

x, y, x_scale, y_scale, roi, rgb_channel, alpha, color_palette, alpha_palette, hint et transform acceptent les mêmes valeurs que Image.draw_image().

dssim si True, renvoie plutôt l’indice de dissimilarité structurelle (DSSIM), où 0 signifie identique et 1 signifie complètement différent.

get_histogram(thresholds: List[Tuple[int, int]] | None = None, invert: bool = False, roi: Tuple[int, int, int, int] | None = None, bins: int = -1, l_bins: int = -1, a_bins: int = -1, b_bins: int = -1, difference: Image | None = None) → histogram¶

Calcule l’histogramme normalisé sur tous les canaux de couleur pour une roi et renvoie un objet image.histogram. Également disponible sous Image.get_hist() ou Image.histogram().

thresholds est une liste de tuples (lo, hi) pour les images en niveaux de gris, ou de tuples (l_lo, l_hi, a_lo, a_hi, b_lo, b_hi) pour les images RGB565. S’il est passé, l’histogramme n’est calculé que sur les pixels situés dans les seuils.

invert inverse la correspondance de seuil.

roi est le tuple rectangle de la région d’intérêt (x, y, w, h). Par défaut, le rectangle de l’image.

bins (niveaux de gris) ou l_bins/a_bins/b_bins (RGB565) définissent le nombre de classes (bins) d’histogramme par canal. Doit être supérieur à 2. Par défaut, le nombre maximal de classes par canal.

difference peut être défini sur un objet image pour opérer sur la différence entre l’image courante et cette image sans tampon supplémentaire.

Non pris en charge sur les images compressées ou les images bayer.

get_statistics(thresholds: List[Tuple[int, int]] | None = None, invert: bool = False, roi: Tuple[int, int, int, int] | None = None, bins: int = -1, l_bins: int = -1, a_bins: int = -1, b_bins: int = -1, difference: Image | None = None) → statistics¶

Calcule la moyenne, la médiane, le mode, l’écart type, le min, le max, le quartile inférieur et le quartile supérieur pour tous les canaux de couleur d’une roi et renvoie un objet image.statistics. Également disponible sous Image.get_stats() ou Image.statistics().

thresholds est une liste de tuples (lo, hi) pour les images en niveaux de gris, ou de tuples (l_lo, l_hi, a_lo, a_hi, b_lo, b_hi) pour les images RGB565. S’il est passé, les statistiques ne sont calculées que sur les pixels situés dans les seuils.

invert inverse la correspondance de seuil.

roi est le tuple rectangle de la région d’intérêt (x, y, w, h). Par défaut, le rectangle de l’image.

difference peut être défini sur un objet image pour opérer sur la différence entre l’image courante et cette image sans tampon supplémentaire.

Non pris en charge sur les images compressées ou les images bayer.

get_regression(thresholds: List[Tuple[int, int]], invert: bool = False, roi: Tuple[int, int, int, int] | None = None, x_stride: int = 2, y_stride: int = 1, area_threshold: int = 10, pixels_threshold: int = 10, target_size: Tuple[int, int] = (80, 60)) → line¶

Calcule une régression linéaire (Theil-Sen) sur tous les pixels seuillés de l’image. Renvoie un objet image.line, ou None si aucune ligne n’a été trouvée.

thresholds est une liste de tuples (lo, hi) pour les images en niveaux de gris, ou de tuples (l_lo, l_hi, a_lo, a_hi, b_lo, b_hi) pour les images RGB565.

invert inverse la correspondance de seuil.

roi est le tuple rectangle de la région d’intérêt (x, y, w, h). Par défaut, le rectangle de l’image.

x_stride et y_stride contrôlent combien de pixels sont sautés lors de l’évaluation de l’image.

area_threshold aire minimale de la boîte englobante ; les résultats plus petits renvoient None.

pixels_threshold nombre minimal de pixels seuillés ; les résultats plus petits renvoient None.

target_size est un tuple (w, h). La ROI est réduite par mise à l’échelle d’aire pour tenir dans cette taille avant d’exécuter l’algorithme en O(N^2). La valeur par défaut est (80, 60).

Non pris en charge sur les images compressées ou les images bayer.

Méthodes de détection¶

find_blobs(thresholds: List[Tuple[int, int]], invert: bool = False, roi: Tuple[int, int, int, int] | None = None, x_stride: int = 2, y_stride: int = 1, area_threshold: int = 10, pixels_threshold: int = 10, merge: bool = False, margin: int = 0, threshold_cb: Callable | None = None, merge_cb: Callable | None = None, x_hist_bins_max: int = 0, y_hist_bins_max: int = 0) → List[blob]¶

Trouve tous les blobs (régions de pixels connexes passant un test de seuil) dans l’image et renvoie une liste d’objets image.blob.

thresholds est une liste de tuples (lo, hi) pour les images en niveaux de gris, ou de tuples (l_lo, l_hi, a_lo, a_hi, b_lo, b_hi) pour les images RGB565 (canaux LAB). Jusqu’à 32 tuples peuvent être passés. Les valeurs min/max inversées sont corrigées automatiquement ; les composantes manquantes prennent par défaut la plage maximale.

invert inverse la correspondance de seuil.

roi est le tuple rectangle de la région d’intérêt (x, y, w, h). Par défaut, le rectangle de l’image.

x_stride et y_stride contrôlent combien de pixels sont sautés lors de la recherche d’un blob. Augmentez-les si les blobs sont connus pour être grands.

area_threshold aire minimale de la boîte englobante ; les blobs plus petits sont filtrés.

pixels_threshold nombre minimal de pixels seuillés ; les blobs plus petits sont filtrés.

merge si True, fusionne les blobs dont les rectangles englobants se croisent. margin agrandit/réduit les rectangles englobants utilisés pour l’intersection. Les blobs fusionnés effectuent un OU entre leurs vecteurs de bits code (un bit par seuil).

threshold_cb est appelée par blob après le seuillage ; renvoyez True pour conserver, False pour filtrer.

merge_cb est appelée pour chaque paire de blobs sur le point d’être fusionnés ; renvoyez True pour autoriser la fusion, False pour l’empêcher.

x_hist_bins_max, s’il est non nul, remplit chaque blob avec une projection x_histogram utilisant ce nombre de classes.

y_hist_bins_max, s’il est non nul, remplit chaque blob avec une projection y_histogram utilisant ce nombre de classes.

Non pris en charge sur les images compressées ou les images bayer.

find_lines(roi: Tuple[int, int, int, int] | None = None, x_stride: int = 2, y_stride: int = 1, threshold: int = 1000, theta_margin: int = 25, rho_margin: int = 25) → List[line]¶

Trouve toutes les lignes infinies de l’image à l’aide de la transformée de Hough. Renvoie une liste d’objets image.line.

roi est le tuple rectangle de la région d’intérêt (x, y, w, h). Par défaut, le rectangle de l’image.

x_stride et y_stride contrôlent combien de pixels sont sautés pendant la transformée de Hough.

threshold magnitude minimale de ligne (somme des magnitudes de Sobel le long de la ligne) ; les lignes en dessous sont filtrées.

theta_margin et rho_margin contrôlent la fusion : les lignes situées dans ces seuils sont fusionnées.

Non pris en charge sur les images compressées ou les images bayer.

Cette méthode n’est pas disponible sur l’OpenMV Cam M4.

find_line_segments(roi: Tuple[int, int, int, int] | None = None, merge_distance: int = 0, max_theta_difference: int = 15) → List[line]¶

Trouve des segments de ligne dans l’image. Renvoie une liste d’objets image.line.

roi est le tuple rectangle de la région d’intérêt (x, y, w, h). Par défaut, le rectangle de l’image.

merge_distance est la séparation maximale en pixels entre deux segments pour qu’ils soient fusionnés.

max_theta_difference est la différence maximale de theta en degrés entre les segments pour qu’ils soient fusionnés.

Cette méthode n’est pas disponible sur l’OpenMV Cam M4.

find_circles(roi: Tuple[int, int, int, int] | None = None, x_stride: int = 2, y_stride: int = 1, threshold: int = 2000, x_margin: int = 10, y_margin: int = 10, r_margin: int = 10, r_min: int = 2, r_max: int | None = None, r_step: int = 2) → List[circle]¶

Trouve des cercles dans l’image à l’aide de la transformée de Hough. Renvoie une liste d’objets image.circle.

roi est le tuple rectangle de la région d’intérêt (x, y, w, h). Par défaut, le rectangle de l’image.

x_stride et y_stride contrôlent combien de pixels sont sautés pendant la transformée de Hough.

threshold magnitude minimale de cercle (somme des magnitudes de Sobel le long du cercle) ; les cercles en dessous sont filtrés.

x_margin, y_margin et r_margin contrôlent la fusion : les cercles situés dans ces seuils sont fusionnés.

r_min rayon minimal du cercle. La valeur par défaut est 2.

r_max rayon maximal du cercle. La valeur par défaut est min(roi.w/2, roi.h/2).

r_step pas du rayon. La valeur par défaut est 2.

Cette méthode n’est pas disponible sur l’OpenMV Cam M4.

find_rects(roi: Tuple[int, int, int, int] | None = None, threshold: int = 1000) → List[rect]¶

Trouve des rectangles dans l’image à l’aide de l’algorithme de détection de quadrilatères apriltag. Renvoie une liste d’objets image.rect.

roi est le tuple rectangle de la région d’intérêt (x, y, w, h). Par défaut, le rectangle de l’image.

threshold magnitude minimale de contour (somme des magnitudes de Sobel le long des bords du rectangle) ; les rectangles en dessous sont filtrés.

Cette méthode n’est pas disponible sur l’OpenMV Cam M4.

find_qrcodes(roi: Tuple[int, int, int, int] | None = None) → List[qrcode]¶

Trouve tous les qrcodes dans la roi et renvoie une liste d’objets image.qrcode.

roi est le tuple rectangle de la région d’intérêt (x, y, w, h). Par défaut, le rectangle de l’image.

Cette méthode n’est pas disponible sur l’OpenMV Cam M4.

Trouve tous les apriltags dans la roi et renvoie une liste d’objets image.apriltag.

roi est le tuple rectangle de la région d’intérêt (x, y, w, h). Par défaut, le rectangle de l’image.

families est un masque de bits de familles de tags à décoder. C’est le OU logique de :

image.TAG16H5

image.TAG25H9

image.TAG36H10

image.TAG36H11

image.TAGCIRCLE21H7

image.TAGCIRCLE49H12

image.TAGCUSTOM48H12

image.TAGSTANDARD41H12

image.TAGSTANDARD52H13

La valeur par défaut est image.TAG36H11. Le temps de détection augmente avec le nombre de familles activées.

fx et fy sont les longueurs focales X et Y de la caméra en pixels.

cx et cy sont le centre de l’image, généralement image.width()/2 et image.height()/2.

Non pris en charge sur les images compressées.

Cette méthode n’est pas disponible sur l’OpenMV Cam M4.

find_datamatrices(roi: Tuple[int, int, int, int] | None = None, effort: int = 200) → List[datamatrix]¶

Trouve toutes les datamatrices dans la roi et renvoie une liste d’objets image.datamatrix.

roi est le tuple rectangle de la région d’intérêt (x, y, w, h). Par défaut, le rectangle de l’image.

effort contrôle le temps à consacrer à la recherche de correspondances de data matrix. Des valeurs plus élevées améliorent la détection au prix de la cadence d’images. Les valeurs en dessous de ~160 échouent à détecter ; les valeurs au-dessus de ~240 donnent des rendements décroissants. La valeur par défaut est 200.

Cette méthode n’est pas disponible sur l’OpenMV Cam M4.

find_barcodes(roi: Tuple[int, int, int, int] | None = None) → List[barcode]¶

Trouve tous les codes-barres 1D dans la roi et renvoie une liste d’objets image.barcode. Effectue un balayage à la fois horizontal et vertical.

Types de codes-barres pris en charge : image.EAN2, image.EAN5, image.EAN8, image.UPCE, image.ISBN10, image.UPCA, image.EAN13, image.ISBN13, image.I25, image.DATABAR (RSS-14), image.DATABAR_EXP (RSS-Expanded), image.CODABAR, image.CODE39, image.PDF417, image.CODE93, image.CODE128.

roi est le tuple rectangle de la région d’intérêt (x, y, w, h). Par défaut, le rectangle de l’image.

Cette méthode n’est pas disponible sur l’OpenMV Cam M4.

find_displacement(template: Image, roi: Tuple[int, int, int, int] | None = None, template_roi: Tuple[int, int, int, int] | None = None, logpolar: bool = False, fix_rotation_scale: bool = False) → displacement¶

Trouve le décalage de translation de cette image par rapport à template à l’aide de la corrélation de phase. Renvoie un objet image.displacement.

roi est le rectangle de la région d’intérêt (x, y, w, h). Par défaut, le rectangle de l’image.

template_roi est la région d’intérêt du modèle. Par défaut, le rectangle de l’image modèle. roi et template_roi doivent avoir la même largeur et la même hauteur.

logpolar si True, renvoie le changement de rotation/échelle au lieu de la translation x/y.

fix_rotation_scale si True, calcule le déplacement après alignement de la rotation et de l’échelle (n’a de sens que lorsque logpolar=False).

Note

Utilisez cette méthode sur des tailles d’image en puissance de 2 (par ex. sensor.B64X64).

Non pris en charge sur les images compressées ou les images bayer. Non disponible sur l’OpenMV Cam M4.

find_template(template: Image, threshold: float, roi: Tuple[int, int, int, int] | None = None, step: int = 2, search: int = SEARCH_EX) → Tuple[int, int, int, int] | None¶

Tente de trouver le premier emplacement dans l’image où template correspond à l’aide de la corrélation croisée normalisée. Renvoie un tuple de boîte englobante (x, y, w, h), ou None.

template est une image en niveaux de gris à comparer à cette image.

threshold est une valeur (0.0-1.0). Des valeurs plus élevées réduisent les faux positifs et les détections ; des valeurs plus basses font l’inverse.

roi est le tuple rectangle de la région d’intérêt (x, y, w, h). Par défaut, le rectangle de l’image.

step est le nombre de pixels à sauter pendant la recherche (utilisé uniquement en mode image.SEARCH_EX).

search est image.SEARCH_DS (recherche en diamant plus rapide) ou image.SEARCH_EX (recherche exhaustive).

Ne fonctionne que sur les images en niveaux de gris.

find_features(cascade: Cascade, threshold: float = 0.5, scale: float = 1.5, roi: Tuple[int, int, int, int] | None = None) → List[Tuple[int, int, int, int]]¶

Recherche dans l’image les zones correspondant au Haar Cascade passé et renvoie une liste de tuples de boîte englobante (x, y, w, h). Renvoie une liste vide si aucune caractéristique n’est trouvée.

cascade est un objet Haar Cascade (voir image.HaarCascade()).

threshold (0.0-1.0). Des valeurs plus basses augmentent le taux de détection et le taux de faux positifs.

scale doit être supérieur à 1.0. Des valeurs plus élevées s’exécutent plus rapidement mais produisent de moins bonnes correspondances.

roi est le tuple rectangle de la région d’intérêt (x, y, w, h). Par défaut, le rectangle de l’image.

find_eye(roi: Tuple[int, int, int, int]) → Tuple[int, int]¶

Recherche la pupille dans un tuple de région d’intérêt (x, y, w, h) autour d’un œil. Renvoie l’emplacement (x, y) de la pupille, ou (0, 0) si aucune n’est trouvée.

roi est le tuple rectangle de la région d’intérêt (x, y, w, h).

Ne fonctionne que sur les images en niveaux de gris.

find_lbp(roi: Tuple[int, int, int, int]) → lbp_descriptor¶

Extrait les points clés LBP (local-binary-patterns) de la région d’intérêt. Utilisez image.match_descriptor() pour comparer deux descripteurs.

roi est le tuple rectangle de la région d’intérêt (x, y, w, h).

Ne fonctionne que sur les images en niveaux de gris.

find_keypoints(roi: Tuple[int, int, int, int] | None = None, threshold: int = 20, normalized: bool = False, scale_factor: float = 1.5, max_keypoints: int = 100, corner_detector: int = CORNER_AGAST) → kp_descriptor | None¶

Extrait les points clés ORB de la région d’intérêt. Utilisez image.match_descriptor() pour comparer deux descripteurs. Renvoie None si aucun point clé n’a été trouvé.

roi est le tuple rectangle de la région d’intérêt (x, y, w, h). Par défaut, le rectangle de l’image.

threshold (0-255) contrôle le nombre de coins extraits. Des seuils plus bas produisent plus de coins. Utilisez ~20 pour AGAST, ~60-80 pour FAST.

normalized si True, désactive l’extraction de points clés multi-résolution.

scale_factor doit être supérieur à 1.0. Des valeurs plus élevées s’exécutent plus rapidement mais produisent de moins bonnes correspondances.

max_keypoints est le nombre maximal de points clés à conserver.

corner_detector est image.CORNER_FAST ou image.CORNER_AGAST.

Ne fonctionne que sur les images en niveaux de gris.

find_edges(edge_type: int, threshold: Tuple[int, int] = (100, 200)) → Image¶

Transforme l’image en noir et blanc en ne laissant que les contours sous forme de pixels blancs.

image.EDGE_SIMPLE - Algorithme simple de filtre passe-haut seuillé.

image.EDGE_CANNY - Algorithme de détection de contours de Canny.

threshold est un tuple à deux valeurs contenant un seuil bas et un seuil haut. Vous pouvez contrôler la qualité des contours en ajustant ces valeurs. La valeur par défaut est (100, 200).

Ne fonctionne que sur les images en niveaux de gris.

find_hog(roi: Tuple[int, int, int, int] | None = None, size: int = 8) → Image¶

Remplace les pixels de la ROI par des lignes HOG (histogram of oriented gradients).

roi est le tuple rectangle de la région d’intérêt (x, y, w, h). S’il n’est pas spécifié, il est égal au rectangle de l’image. Seuls les pixels situés dans la roi sont traités.

Ne fonctionne que sur les images en niveaux de gris.

Cette méthode n’est pas disponible sur l’OpenMV Cam M4.

stereo_disparity(reversed: bool = False, max_disparity: int = 64, threshold: int = 64) → Image¶

Prend une image en niveaux de gris à double largeur contenant la sortie de deux capteurs de caméra côte à côte et remplace une moitié par l’image de disparité stéréo (chaque pixel représente une profondeur). Par ex. pour deux caméras 320x240, passez une image 640x240.

reversed Par défaut, l’image de gauche est comparée à celle de droite et l’image de droite est remplacée. Définissez à True pour comparer droite->gauche et remplacer l’image de gauche.

max_disparity est la distance maximale (1-255) de recherche d’un bloc de pixels correspondant à l’aide de la somme des différences absolues. Des valeurs plus grandes prennent un temps exponentiellement plus long mais produisent une sortie de meilleure qualité.

threshold si la somme des différences absolues entre deux blocs est inférieure ou égale à ce seuil, ils sont considérés comme correspondants.

selective_search(threshold: int = 500, size: int = 20, a1: float = 1.0, a2: float = 1.0, a3: float = 1.0) → List[Tuple[int, int, int, int]]¶

Exécute une recherche sélective sur l’image et renvoie une liste de tuples de boîte englobante (x, y, w, h) de propositions d’objets.

threshold est le seuil de segmentation ; des valeurs plus élevées produisent moins de régions, plus grandes.

size est la taille minimale de région après fusion.

a1, a2, a3 sont les poids de similarité couleur/texture/taille utilisés lors de la fusion des régions.