class Image – Objeto de imagen¶

Image es el tipo de dato central del módulo image: un búfer de píxeles en memoria sobre el que operan todas las rutinas de dibujo, todos los filtros, todas las transformaciones geométricas y todas las rutinas de extracción de características. Cada fotograma que sale de csi.CSI.snapshot() es una Image; también lo es cada fotograma cargado desde disco, decodificado desde JPEG o PNG, asignado desde un ndarray al estilo de numpy, o construido como un lienzo de dibujo vacío.

Una Image se describe mediante tres números (width, height y pixformat) más un búfer de píxeles contiguo. El formato de píxel determina tanto la disposición en memoria como qué operaciones están disponibles:

BINARY (1 bpp) – 1 bit por píxel; usado por la morfología y la umbralización.
GRAYSCALE (8 bpp) – 1 byte por píxel; el formato canónico para la mayoría de la visión artificial (AprilTag, bordes, ORB, flujo óptico).
RGB565 (16 bpp) – 2 bytes por píxel (5R/6G/5B); el formato de color predeterminado.
BAYER (8 bpp) – datos de mosaico Bayer en bruto directamente del sensor. La mayoría de los métodos de visión artificial no están disponibles en imágenes Bayer; conviértalas primero a GRAYSCALE / RGB565 mediante debayer.
YUV422 (16 bpp) – color con submuestreo de croma 4:2:2, dos bytes por píxel. Solo algunos métodos funcionan directamente sobre YUV422.
JPEG / PNG – búferes comprimidos. Las operaciones a nivel de píxel requieren primero to_grayscale() o to_rgb565().

De dónde provienen los objetos Image¶

Hay cuatro formas de obtener una Image:

Desde el búfer de fotogramas (frame buffer) de la cámara – csi.CSI().snapshot() devuelve el siguiente fotograma capturado. El objeto devuelto es un envoltorio ligero alrededor de la memoria del búfer de fotogramas de la cámara, por lo que cualquier operación de dibujo o filtrado sobre él cambia lo que se envía a la vista previa del IDE y a la pantalla.
Desde un archivo – pase una cadena de ruta al constructor de Image. Los formatos BMP, PGM, PPM, JPEG y PNG se decodifican directamente en RAM (o en el búfer de fotogramas de la cámara si copy_to_fb=True).
Desde un ndarray – pase un arreglo float32 de forma (h, w) o (h, w, 3). Los píxeles se escalan desde 0.0 -- 255.0 a GRAYSCALE o RGB565 respectivamente.
Vacío – pase (width, height, pixformat) para asignar una superficie de dibujo rellena de ceros. Para los formatos de píxel comprimidos (JPEG / PNG) se requiere un argumento buffer= que contiene el flujo de bytes comprimido.

Bucle típico de captura, procesamiento y visualización¶

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.

Indexación, longitud, iteración y acceso tipo bytes¶

Indexación – img[i] lee el píxel i (linealmente, en orden de filas). img[i] = value lo escribe. Los píxeles en escala de grises / Bayer son enteros de 8 bits, los píxeles RGB565 / YUV422 son enteros empaquetados de 16 bits, y los píxeles binarios son 0 / 1. Para imágenes JPEG / PNG el espacio de índices es el flujo de bytes comprimido, no los píxeles.
Longitud – len(img) devuelve el número de píxeles para formatos sin comprimir o el recuento de bytes para formatos comprimidos.
Iteración – for px in img: ... recorre el arreglo de píxeles en el mismo orden que la indexación [].
Tipo bytes – Image expone el protocolo de búfer de lectura, por lo que puede pasarla directamente a cualquier cosa que acepte un bytes / bytearray (p. ej. uart.write(img), socket.send(img), hashlib.sha256(img)). Use bytearray() en su lugar para obtener una vista de lectura/escritura.

Indicadores de sugerencia (hint)¶

Muchos métodos de Image aceptan un argumento hint que es un OR lógico de los siguientes indicadores:

image.AREA: Usa el escalado por área al reducir, en lugar del predeterminado de vecino más cercano.

image.BILINEAR: Usa el escalado bilineal en lugar del escalado predeterminado de vecino más cercano.

image.BICUBIC: Usa el escalado bicúbico en lugar del escalado predeterminado de vecino más cercano.

image.CENTER: Centra la imagen que se dibuja en la pantalla. Esto se aplica después del escalado.

image.HMIRROR: Refleja horizontalmente la imagen.

image.VFLIP: Voltea verticalmente la imagen.

image.TRANSPOSE: Transpone la imagen (intercambia x/y).

image.EXTRACT_RGB_CHANNEL_FIRST: Realiza la extracción de rgb_channel antes del escalado.

image.APPLY_COLOR_PALETTE_FIRST: Aplica la paleta de colores antes del escalado.

image.SCALE_ASPECT_KEEP: Escala la imagen que se dibuja para que quepa dentro de la pantalla.

image.SCALE_ASPECT_EXPAND: Escala la imagen que se dibuja para que llene la pantalla (produce recorte).

image.SCALE_ASPECT_IGNORE: Escala la imagen que se dibuja para que llene la pantalla (produce estiramiento).

image.ROTATE_90: Rota la imagen 90 grados (esto es simplemente VFLIP | TRANSPOSE).

image.ROTATE_180: Rota la imagen 180 grados (esto es simplemente HMIRROR | VFLIP).

image.ROTATE_270: Rota la imagen 270 grados (esto es simplemente HMIRROR | TRANSPOSE).

image.BLACK_BACKGROUND: Asume que la imagen de fondo sobre la que se dibuja es negra, acelerando la mezcla. Solo lo admiten Image.draw_image() y Image.get_similarity().

Si arg es una cadena, esto crea un nuevo objeto de imagen a partir de un archivo en la ruta arg. Admite la carga de archivos de imagen bmp/pgm/ppm/jpg/jpeg/png desde disco. Si copy_to_fb es verdadero, la imagen se copia al búfer de fotogramas en lugar de asignarse en el heap.

Si arg es un ndarray, esto crea un nuevo objeto de imagen a partir del ndarray. Los objetos ndarray con una forma de (w, h) se tratan como imágenes en escala de grises, y los de (w, h, 3) se tratan como imágenes RGB565. Por ahora solo se admiten ndarrays de punto flotante float32. Al crear una imagen de esta manera, si pasa un argumento buffer se usará para almacenar los datos de la imagen en lugar de asignar espacio en el heap. Si copy_to_fb es verdadero, la imagen se copia al búfer de fotogramas en lugar de asignarse en el heap o usar el buffer.

Si arg es un int, entonces se considera el ancho de una nueva imagen y deben seguir un valor height y un valor format para crear un nuevo objeto de imagen en blanco. format puede ser cualquier valor de pixformat de imagen como image.GRAYSCALE. La imagen se inicializará con todos ceros. Tenga en cuenta que se espera un valor buffer para los formatos de imagen comprimidos. buffer se considera la fuente de datos de imagen para crear imágenes de esta manera. Si se usa con copy_to_fb, los datos de buffer se copian al búfer de fotogramas. Si desea crear una imagen JPEG a partir de un objeto JPEG bytes() o bytearray(), puede pasar width, height, image.JPEG para el JPEG junto con establecer buffer en el flujo de bytes JPEG para crear una imagen JPEG.

Las imágenes admiten la notación «[]». Haga image[index] = 8/16-bit value para asignar un píxel de imagen o image[index] para obtener un píxel de imagen, que será un valor de 8 bits para imágenes en escala de grises/bayer o un valor de 16 bits para imágenes RGB565/YUV. Las imágenes binarias devuelven un valor de 1 bit.

Para imágenes JPEG, los «[]» le permiten acceder al blob de imagen JPEG comprimida como un arreglo de bytes. Sin embargo, la lectura y escritura en el arreglo de datos es opaca, ya que las imágenes JPEG son flujos de bytes comprimidos.

Las imágenes también admiten operaciones de búfer de lectura. Puede pasar imágenes a todo tipo de funciones de MicroPython como si la imagen fuera un objeto de arreglo de bytes. En particular, si desea transmitir una imagen, simplemente puede pasarla a las funciones de escritura UART/SPI/I2C para que se transmita automáticamente.

Métodos básicos¶

width() → int¶: Devuelve el ancho de la imagen en píxeles.

height() → int¶: Devuelve la altura de la imagen en píxeles.

format() → int¶: Devuelve image.GRAYSCALE para imágenes en escala de grises, image.RGB565 para imágenes RGB565, image.BAYER para imágenes de patrón bayer e image.JPEG para imágenes JPEG.

size() → int¶: Devuelve el tamaño de la imagen en bytes.

bytearray() → bytearray¶: Devuelve un objeto bytearray que apunta a los datos de la imagen para acceso de lectura/escritura a nivel de byte.

Nota

Los objetos de imagen se convierten automáticamente en objetos bytes cuando se pasan a un controlador de MicroPython que requiere un objeto tipo bytes. Este es un acceso de solo lectura. Llame a bytearray() para obtener acceso de lectura/escritura.

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

Para imágenes en escala de grises: Devuelve el valor del píxel en escala de grises en la ubicación (x, y). Para imágenes RGB565: Devuelve la tupla de píxel RGB888 (r, g, b) en la ubicación (x, y). Para imágenes de patrón bayer: Devuelve el valor del píxel en la ubicación (x, y).

Devuelve None si x o y está fuera de la imagen.

x e y pueden pasarse de forma independiente o como una tupla.

rgbtuple si es True hace que este método devuelva una tupla RGB888. De lo contrario, este método devuelve el valor entero del píxel subyacente. Es decir, para imágenes RGB565 este método devuelve un valor RGB565. El valor predeterminado es True para imágenes RGB565 y False en los demás casos.

No compatible con imágenes comprimidas.

Nota

Image.get_pixel() e Image.set_pixel() son los únicos métodos que le permiten manipular imágenes de patrón bayer. Las imágenes de patrón bayer son imágenes literales en las que los píxeles de la imagen son R/G/R/G/etc. para las filas pares y G/B/G/B/etc. para las filas impares. Cada píxel es de 8 bits. Si llama a este método con rgbtuple activado, entonces Image.get_pixel() aplicará debayer a la imagen de origen en esa ubicación de píxel y devolverá una tupla RGB888 válida para esa ubicación de píxel.

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

Para imágenes en escala de grises: Establece el píxel en la ubicación (x, y) al valor en escala de grises pixel. Para imágenes RGB565: Establece el píxel en la ubicación (x, y) a la tupla RGB888 (r, g, b) pixel. Para imágenes de patrón bayer: Establece el valor del píxel en la ubicación (x, y) al valor pixel.

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

x e y pueden pasarse de forma independiente o como una tupla.

pixel puede ser una tupla RGB888 (r, g, b) o el valor del píxel subyacente (es decir, un valor RGB565 para imágenes RGB565 o un valor de 8 bits para imágenes en escala de grises).

No compatible con imágenes comprimidas.

Nota

Image.get_pixel() e Image.set_pixel() son los únicos métodos que le permiten manipular imágenes de patrón bayer. Las imágenes de patrón bayer son imágenes literales en las que los píxeles de la imagen son R/G/R/G/etc. para las filas pares y G/B/G/B/etc. para las filas impares. Cada píxel es de 8 bits. Si llama a este método con una tupla RGB888, se extrae el valor en escala de grises de esa tupla RGB888 y se establece en la ubicación del píxel.

Métodos de conversión¶

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

Devuelve un objeto ndarray creado a partir de la imagen. Actualmente esto solo funciona para imágenes GRAYSCALE o RGB565.

dtype puede ser b, B o f para crear un ndarray de 8 bits con signo, de 8 bits sin signo o de punto flotante de 32 bits. Las imágenes GRAYSCALE se convierten directamente en objetos ndarray de 8 bits sin signo. Para objetos ndarray de 8 bits con signo, los valores (0:255) se mapean a (-127:128). Para objetos ndarray de punto flotante de 32 bits, los valores se mapean a (0.0:255.0). Las imágenes RGB565 se convierten en objetos ndarray de 3 canales y se aplica a cada canal el mismo proceso descrito anteriormente para las imágenes GRAYSCALE según dtype. Tenga en cuenta que dtype también acepta los valores enteros (p. ej. ord()) de b, B y f respectivamente.

buffer si no es None es un objeto bytearray para usar como búfer del ndarray. Si es None se asigna un nuevo búfer en el heap para almacenar los datos de imagen del ndarray. Puede usar el argumento buffer para asignar directamente el ndarray en un búfer preasignado, ahorrando una asignación de heap y una operación de copia.

El ndarray devuelto tiene la forma (height, width) para imágenes GRAYSCALE y (height, width, 3) para imágenes 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¶

Convierte una imagen en una imagen de mapa de bits (1 bit por píxel).

x_scale controla cuánto se escala la imagen mostrada en la dirección x (float). Si este valor es negativo, la imagen se voltea horizontalmente. Tenga en cuenta que si no se especifica y_scale, este coincidirá con x_scale para mantener la relación de aspecto.

y_scale controla cuánto se escala la imagen mostrada en la dirección y (float). Si este valor es negativo, la imagen se voltea verticalmente. Tenga en cuenta que si no se especifica x_scale, este coincidirá con x_scale para mantener la relación de aspecto.

roi es la tupla del rectángulo de la región de interés (x, y, w, h) de la imagen de origen a dibujar. Esto le permite extraer solo los píxeles de la ROI para escalarlos y dibujarlos en la imagen de destino.

rgb_channel es el canal RGB (0=R, G=1, B=2) a extraer de una imagen RGB565 (si se pasa) y a renderizar en la imagen de destino. Por ejemplo, si pasa rgb_channel=1, esto extraerá el canal verde de la imagen RGB565 de origen y lo dibujará en escala de grises en la imagen de destino.

alpha controla cuánto de la imagen de origen se mezcla con la imagen de destino. Un valor de 255 dibuja una imagen de origen opaca, mientras que un valor inferior a 255 produce una mezcla entre la imagen de origen y la de destino. 0 no produce ninguna modificación en la imagen de destino.

color_palette si no es None puede ser un enum de paleta de colores o una imagen RGB565 de 256 píxeles en total para usar como tabla de búsqueda de color sobre el valor en escala de grises de cualquiera que sea la imagen de origen. Esto se aplica después de la extracción de rgb_channel si se usa.

alpha_palette si no es None puede ser una imagen GRAYSCALE de 256 píxeles en total para usar como paleta alfa que modula el valor alpha de la imagen de origen que se dibuja a nivel de píxel, permitiéndole controlar con precisión el valor alfa de los píxeles según su valor en escala de grises. Un valor de píxel de 255 en la tabla de búsqueda alfa es opaco, mientras que cualquier valor inferior a 255 se vuelve más transparente hasta llegar a 0. Esto se aplica después de la extracción de rgb_channel si se usa.

hint es un OR lógico de los indicadores enumerados en Indicadores de sugerencia (excluyendo image.BLACK_BACKGROUND, que no se admite aquí).

transform es un ndarray 3x3 que se usa para realizar una transformación de perspectiva en la imagen. Actualmente solo se admite en la OpenMV Cam N6, ya que tiene una GPU que puede hacer esto por hardware.

copy si es True crea una copia profunda en el heap de la imagen que se ha convertido, en lugar de convertir la imagen original in situ.

copy_to_fb si es True la imagen se carga directamente en el búfer de fotogramas. copy_to_fb tiene prioridad sobre copy. Esto no tiene ningún efecto especial si la imagen ya está en el búfer de fotogramas.

Nota

Las imágenes de mapa de bits son como imágenes en escala de grises con solo dos valores de píxel: 0 y 1. Además, las imágenes de mapa de bits están empaquetadas de modo que solo almacenan 1 bit por píxel, lo que las hace muy pequeñas. La biblioteca de imágenes de OpenMV permite usar imágenes de mapa de bits en todos los lugares donde se pueden usar imágenes sensor.GRAYSCALE y sensor.RGB565. Sin embargo, muchas operaciones, cuando se aplican a imágenes de mapa de bits, no tienen ningún sentido porque las imágenes de mapa de bits solo tienen 2 valores. OpenMV recomienda usar imágenes de mapa de bits para los valores mask en operaciones y similares, ya que caben en el heap de MicroPython con bastante facilidad. Por último, los valores de píxel 0 y 1 de las imágenes de mapa de bits se interpretan como negro y blanco cuando se aplican a imágenes sensor.GRAYSCALE o sensor.RGB565. La biblioteca maneja la conversión automáticamente.

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

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¶

Convierte una imagen en una imagen en escala de grises (8 bits por píxel).

hint es un OR lógico de los indicadores enumerados en Indicadores de sugerencia (excluyendo image.BLACK_BACKGROUND, que no se admite aquí).

copy si es True crea una copia profunda en el heap de la imagen que se ha convertido, en lugar de convertir la imagen original in situ.

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

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¶

Convierte una imagen en una imagen RGB565 (16 bits por píxel).

hint es un OR lógico de los indicadores enumerados en Indicadores de sugerencia (excluyendo image.BLACK_BACKGROUND, que no se admite aquí).

copy si es True crea una copia profunda en el heap de la imagen que se ha convertido, en lugar de convertir la imagen original in situ.

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

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¶

Convierte una imagen en una imagen arcoíris RGB565 (16 bits por píxel).

hint es un OR lógico de los indicadores enumerados en Indicadores de sugerencia (excluyendo image.BLACK_BACKGROUND, que no se admite aquí).

copy si es True crea una copia profunda en el heap de la imagen que se ha convertido, en lugar de convertir la imagen original in situ.

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

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¶

Convierte una imagen en una imagen ironbow RGB565 (16 bits por píxel).

hint es un OR lógico de los indicadores enumerados en Indicadores de sugerencia (excluyendo image.BLACK_BACKGROUND, que no se admite aquí).

copy si es True crea una copia profunda en el heap de la imagen que se ha convertido, en lugar de convertir la imagen original in situ.

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

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¶

Convierte una imagen en una imagen de profundidad RGB565 (16 bits por píxel).

color_palette si no es None puede ser image.PALETTE_DEPTH o una imagen RGB565 de 256 píxeles en total para usar como tabla de búsqueda de color sobre el valor en escala de grises de cualquiera que sea la imagen de origen. Esto se aplica después de la extracción de rgb_channel si se usa.

hint es un OR lógico de los indicadores enumerados en Indicadores de sugerencia (excluyendo image.BLACK_BACKGROUND, que no se admite aquí).

copy si es True crea una copia profunda en el heap de la imagen que se ha convertido, en lugar de convertir la imagen original in situ.

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

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¶

Convierte una imagen en una imagen RGB565 de eventos oscuros (16 bits por píxel).

hint es un OR lógico de los indicadores enumerados en Indicadores de sugerencia (excluyendo image.BLACK_BACKGROUND, que no se admite aquí).

copy si es True crea una copia profunda en el heap de la imagen que se ha convertido, en lugar de convertir la imagen original in situ.

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

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¶

Convierte una imagen en una imagen RGB565 de eventos luminosos (16 bits por píxel).

hint es un OR lógico de los indicadores enumerados en Indicadores de sugerencia (excluyendo image.BLACK_BACKGROUND, que no se admite aquí).

copy si es True crea una copia profunda en el heap de la imagen que se ha convertido, en lugar de convertir la imagen original in situ.

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

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¶

Convierte una imagen en una imagen JPEG.

hint es un OR lógico de los indicadores enumerados en Indicadores de sugerencia (excluyendo image.BLACK_BACKGROUND, que no se admite aquí).

copy si es True crea una copia profunda en el heap de la imagen que se ha convertido, en lugar de convertir la imagen original in situ.

quality controla la calidad de compresión de la imagen jpeg. El valor puede estar entre 0 y 100.

subsampling puede ser:

image.JPEG_SUBSAMPLING_AUTO: Usa el mejor submuestreo para la imagen según la calidad.

image.JPEG_SUBSAMPLING_444: Usa submuestreo 4:4:4.

image.JPEG_SUBSAMPLING_422: Usa submuestreo 4:2:2.

image.JPEG_SUBSAMPLING_420: Usa submuestreo 4:2:0.

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

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¶

Convierte una imagen en una imagen PNG.

hint es un OR lógico de los indicadores enumerados en Indicadores de sugerencia (excluyendo image.BLACK_BACKGROUND, que no se admite aquí).

copy si es True crea una copia profunda en el heap de la imagen que se ha convertido, en lugar de convertir la imagen original in situ.

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

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¶

Convierte una imagen en una imagen JPEG.

hint es un OR lógico de los indicadores enumerados en Indicadores de sugerencia (excluyendo image.BLACK_BACKGROUND, que no se admite aquí).

copy si es True crea una copia profunda en el heap de la imagen que se ha convertido, en lugar de convertir la imagen original in situ.

quality controla la calidad de compresión de la imagen jpeg. El valor puede estar entre 0 y 100.

subsampling puede ser:

image.JPEG_SUBSAMPLING_AUTO: Usa el mejor submuestreo para la imagen según la calidad.

image.JPEG_SUBSAMPLING_444: Usa submuestreo 4:4:4.

image.JPEG_SUBSAMPLING_422: Usa submuestreo 4:2:2.

image.JPEG_SUBSAMPLING_420: Usa submuestreo 4:2:0.

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

Nota

Image.compress es 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¶

Crea una copia profunda del objeto de imagen.

hint es un OR lógico de los indicadores enumerados en Indicadores de sugerencia (excluyendo image.BLACK_BACKGROUND, que no se admite aquí).

copy_to_fb si es True la imagen se carga directamente en el búfer de fotogramas. Esto no tiene ningún efecto especial si la imagen ya está en el búfer de fotogramas.

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

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¶

Modifica una imagen in situ sin cambiar el tipo de imagen subyacente.

hint es un OR lógico de los indicadores enumerados en Indicadores de sugerencia (excluyendo image.BLACK_BACKGROUND, que no se admite aquí).

copy si es True crea una copia profunda en el heap de la imagen que se ha convertido, en lugar de convertir la imagen original in situ.

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

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¶

Modifica una imagen in situ sin cambiar el tipo de imagen subyacente.

hint es un OR lógico de los indicadores enumerados en Indicadores de sugerencia (excluyendo image.BLACK_BACKGROUND, que no se admite aquí).

copy si es True crea una copia profunda en el heap de la imagen que se ha convertido, en lugar de convertir la imagen original in situ.

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

Nota

Image.scale es un alias de Image.crop.

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

Guarda una copia de la imagen en el sistema de archivos en path.

Admite archivos de imagen bmp/pgm/ppm/jpg/jpeg. Tenga en cuenta que no puede guardar imágenes comprimidas en jpeg en un formato sin comprimir.

roi es el rectángulo de la región de interés (x, y, w, h) desde el que guardar. Si no se especifica, es igual al rectángulo de la imagen, lo que copia toda la imagen. Este argumento no es aplicable a las imágenes JPEG.

quality es la calidad de compresión jpeg a usar para guardar la imagen en formato jpeg si la imagen no está ya comprimida (0-100) (int).

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

flush() → None¶: Actualiza el búfer de fotogramas en el IDE con la imagen del búfer de fotogramas de la cámara.

Métodos de dibujo¶

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

Establece todos los píxeles de la imagen en cero (muy rápido).

mask es otra imagen para usar como máscara a nivel de píxel para la operación. La máscara debe ser una imagen con solo píxeles negros o blancos y debe tener el mismo tamaño que la imagen sobre la que se opera. Solo se modifican los píxeles establecidos en la máscara.

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

No compatible con imágenes comprimidas.

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

Dibuja una línea desde (x0, y0) hasta (x1, y1) en la imagen. Puede pasar x0, y0, x1, y1 por separado o como una tupla (x0, y0, x1, y1).

color es una tupla RGB888 para imágenes en escala de grises o RGB565. El valor predeterminado es blanco. Sin embargo, también puede pasar el valor del píxel subyacente (0-255) para imágenes en escala de grises o un valor RGB565 para imágenes RGB565.

thickness controla el grosor de la línea en píxeles.

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

No compatible con imágenes comprimidas o imágenes 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¶

Dibuja un rectángulo en la imagen. Puede pasar x, y, w, h por separado o como una tupla (x, y, w, h).

thickness controla el grosor de las líneas en píxeles.

Pase fill con valor True para rellenar el rectángulo.

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

No compatible con imágenes comprimidas o imágenes bayer.

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

Dibuja un círculo en la imagen. Puede pasar x, y, radius por separado o como una tupla (x, y, radius).

thickness controla el grosor de los bordes en píxeles.

Pase fill con valor True para rellenar el círculo.

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

No compatible con imágenes comprimidas o imágenes 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¶

Dibuja una elipse en la imagen. Puede pasar cx, cy, rx, ry y la rotación (en grados) por separado o como una tupla (cx, yc, rx, ry, rotation).

thickness controla el grosor de los bordes en píxeles.

Pase fill con valor True para rellenar la elipse.

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

No compatible con imágenes comprimidas o imágenes 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¶

Dibuja texto de 8x10 comenzando en la ubicación (x, y) de la imagen. Puede pasar x, y por separado o como una tupla (x, y).

text es una cadena para escribir en la imagen. Los finales de línea \n, \r y \r\n mueven el cursor a la siguiente línea.

scale puede aumentarse para incrementar/disminuir el tamaño del texto en la imagen. Puede pasar valores enteros o de punto flotante mayores que 0.

x_spacing le permite sumar (si es positivo) o restar (si es negativo) x píxeles entre caracteres.

y_spacing le permite sumar (si es positivo) o restar (si es negativo) y píxeles entre caracteres (para texto de varias líneas).

mono_space tiene como valor predeterminado True, lo que fuerza un espaciado fijo del texto. Para escalas de texto grandes esto se ve terrible. Establézcalo en False para obtener un espaciado de caracteres de ancho no fijo que se ve MUCHO mejor.

char_rotation puede ser 0, 90, 180, 270 para rotar cada carácter de la cadena en esta cantidad.

char_hmirror si es True refleja horizontalmente todos los caracteres de la cadena.

char_vflip si es True voltea verticalmente todos los caracteres de la cadena.

string_rotation puede ser 0, 90, 180, 270 para rotar la cadena en esta cantidad.

string_hmirror si es True refleja horizontalmente la cadena.

string_vflip si es True voltea verticalmente la cadena.

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

No compatible con imágenes comprimidas o imágenes bayer.

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

Dibuja una cruz en la ubicación x, y. Puede pasar x, y por separado o como una tupla (x, y).

size controla la longitud de las líneas de la cruz.

thickness controla el grosor de los bordes en píxeles.

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

No compatible con imágenes comprimidas o imágenes bayer.

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

Dibuja una flecha desde (x0, y0) hasta (x1, y1) en la imagen. Puede pasar x0, y0, x1, y1 por separado o como una tupla (x0, y0, x1, y1).

thickness controla el grosor de la línea en píxeles.

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

No compatible con imágenes comprimidas o imágenes 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¶

Dibuja un resultado de detección en la imagen. detection es una 6-tupla (rx, ry, rw, rh, cx, cy) que describe un rectángulo delimitador y un centroide (normalmente devuelto por código de red neuronal o de seguimiento de color).

color1 es el color del rectángulo y color2 es el color de la cruz del centroide. size es el tamaño de la cruz del centroide, thickness controla el ancho del contorno y fill rellena el rectángulo.

label si se proporciona se dibuja cerca del rectángulo, desplazado por label_offset (x, y).

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

No compatible con imágenes comprimidas o imágenes 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¶

Dibuja los bordes de las líneas entre una lista de esquinas devuelta por métodos como blob.corners. Corners es una tupla de cuatro valores de tuplas x/y de dos valores. P. ej. [(x1,y1),(x2,y2),(x3,y3),(x4,y4)].

size si es mayor que 0 hace que las esquinas se dibujen como círculos de radio size.

thickness controla el grosor de la línea en píxeles.

Pase fill con valor True para rellenar los círculos de las esquinas si se dibujan.

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

No compatible con imágenes comprimidas o imágenes 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¶

Dibuja una image cuya esquina superior izquierda comienza en la ubicación x, y. Puede pasar x, y por separado o como una tupla (x, y). Este método maneja automáticamente la renderización de la imagen pasada en el formato de píxel correcto para la imagen de destino, manejando también el recorte de forma transparente.

También puede pasar una ruta en lugar de un objeto de imagen para que este método cargue automáticamente la imagen desde disco y la use en un solo paso. P. ej. draw_image("test.jpg").

hint es un OR lógico de los indicadores enumerados en Indicadores de sugerencia (incluyendo image.BLACK_BACKGROUND, que sí se admite aquí).

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

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¶

Dibuja los puntos clave de un objeto de puntos clave en la imagen. También puede pasar una lista de tuplas de tres valores que contengan (x, y, ángulo_de_rotación_en_grados) para reutilizar este método para dibujar glifos de punto clave, que son un círculo con una línea que apunta en una dirección particular.

size controla el tamaño de los puntos clave.

thickness controla el grosor de la línea en píxeles.

Pase fill con valor True para rellenar los puntos clave.

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

No compatible con imágenes comprimidas o imágenes 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¶

Realiza un relleno por inundación de una región de la imagen comenzando desde la ubicación x, y. Puede pasar x, y por separado o como una tupla (x, y).

seed_threshold controla cuánto puede diferir cualquier píxel del área de relleno respecto al píxel inicial original.

floating_threshold controla cuánto puede diferir cualquier píxel del área de relleno respecto a cualquier píxel vecino.

Pase invert con valor True para recolorear todo lo que esté fuera del área conectada del relleno por inundación.

Pase clear_background con valor True para poner a cero el resto de los píxeles que el relleno por inundación no recoloreó.

mask es otra imagen para usar como máscara a nivel de píxel para la operación. La máscara debe ser una imagen con solo píxeles negros o blancos y debe tener el mismo tamaño que la imagen sobre la que se opera. Solo se evalúan los píxeles establecidos en la máscara durante el relleno por inundación.

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

No compatible con imágenes comprimidas o imágenes bayer.

Este método no está disponible en la OpenMV Cam M4.

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

Rasteriza un ndarray de eventos (tal como lo rellena csi.IOCTL_GENX320_READ_EVENTS) sobre una Image para su visualización. El búfer de imagen debe ser una imagen GRAYSCALE de 320x320.

Por cada fila csi.PIX_ON_EVENT se le suma +contrast al píxel del evento; por cada fila csi.PIX_OFF_EVENT se le resta -contrast al píxel. Los eventos de disparo se ignoran. Los valores de píxel se acotan a 0-255.

clear si es True restablece el búfer de imagen a brightness antes de dibujar; cada fotograma se convierte en una renderización nueva basada solo en eventos. Establézcalo en False para acumular eventos a lo largo de múltiples llamadas (útil para estelas de movimiento de larga exposición).

brightness controla la línea base de gris medio a la que se restablece el búfer cuando clear es True. El valor predeterminado de 128 coloca los eventos ON en el extremo brillante y los eventos OFF en el extremo oscuro con igual margen.

contrast controla cuánto desplaza cada evento su píxel; valores más altos hacen que los eventos resalten, a costa de saturarse rápidamente cuando muchos eventos caen en el mismo píxel.

Métodos de enmascaramiento¶

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

Pone a cero una parte rectangular de la imagen. Si no se proporcionan argumentos, este método pone a cero el centro de la imagen.

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

No compatible con imágenes comprimidas o imágenes bayer.

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

Pone a cero una parte circular de la imagen. Si no se proporcionan argumentos, este método pone a cero el centro de la imagen.

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

No compatible con imágenes comprimidas o imágenes bayer.

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

Pone a cero una parte con forma de elipse de la imagen. Si no se proporcionan argumentos, este método pone a cero el centro de la imagen.

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

No compatible con imágenes comprimidas o imágenes bayer.

Métodos binarios¶

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

Establece todos los píxeles de la imagen en negro o blanco según si cada píxel está dentro de una de las tuplas de umbral en thresholds.

thresholds es una lista de tuplas (lo, hi) para imágenes en escala de grises, o tuplas (l_lo, l_hi, a_lo, a_hi, b_lo, b_hi) para imágenes RGB565. Los valores mín/máx intercambiados se corrigen automáticamente; los componentes faltantes adoptan por defecto el rango máximo.

invert invierte la coincidencia de umbral.

zero si es True, pone a cero los píxeles umbralizados y deja los demás intactos.

mask es una imagen binaria usada como máscara a nivel de píxel; solo se modifican los píxeles establecidos en la máscara.

to_bitmap si es True, convierte los datos de la imagen a un mapa de bits de 1 bit por píxel. Para imágenes muy pequeñas esto puede requerir copy=True.

copy si es True, devuelve una nueva imagen en el heap en lugar de modificar la imagen de origen.

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

No compatible con imágenes comprimidas o imágenes bayer.

invert() → Image¶

Invierte todos los valores de píxel de la imagen (cada píxel se convierte en 255 - pixel para canales de 8 bits).

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

No compatible con imágenes comprimidas o imágenes bayer/yuv.

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

Aplica un AND lógico entre esta imagen y otra imagen.

image puede ser un objeto de imagen, una ruta a un archivo de imagen sin comprimir (bmp/pgm/ppm) o un valor escalar (tupla RGB888 o valor de píxel subyacente).

mask es una imagen binaria usada como máscara a nivel de píxel; solo se modifican los píxeles establecidos en la máscara.

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

No compatible con imágenes comprimidas o imágenes bayer.

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

Aplica un NAND lógico entre esta imagen y otra imagen.

image puede ser un objeto de imagen, una ruta a un archivo de imagen sin comprimir (bmp/pgm/ppm) o un valor escalar (tupla RGB888 o valor de píxel subyacente).

mask es una imagen binaria usada como máscara a nivel de píxel; solo se modifican los píxeles establecidos en la máscara.

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

No compatible con imágenes comprimidas o imágenes bayer.

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

Aplica un OR lógico entre esta imagen y otra imagen.

image puede ser un objeto de imagen, una ruta a un archivo de imagen sin comprimir (bmp/pgm/ppm) o un valor escalar (tupla RGB888 o valor de píxel subyacente).

mask es una imagen binaria usada como máscara a nivel de píxel; solo se modifican los píxeles establecidos en la máscara.

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

No compatible con imágenes comprimidas o imágenes bayer.

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

Aplica un NOR lógico entre esta imagen y otra imagen.

image puede ser un objeto de imagen, una ruta a un archivo de imagen sin comprimir (bmp/pgm/ppm) o un valor escalar (tupla RGB888 o valor de píxel subyacente).

mask es una imagen binaria usada como máscara a nivel de píxel; solo se modifican los píxeles establecidos en la máscara.

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

No compatible con imágenes comprimidas o imágenes bayer.

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

Aplica un XOR lógico entre esta imagen y otra imagen.

image puede ser un objeto de imagen, una ruta a un archivo de imagen sin comprimir (bmp/pgm/ppm) o un valor escalar (tupla RGB888 o valor de píxel subyacente).

mask es una imagen binaria usada como máscara a nivel de píxel; solo se modifican los píxeles establecidos en la máscara.

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

No compatible con imágenes comprimidas o imágenes bayer.

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

Aplica un XNOR lógico entre esta imagen y otra imagen.

image puede ser un objeto de imagen, una ruta a un archivo de imagen sin comprimir (bmp/pgm/ppm) o un valor escalar (tupla RGB888 o valor de píxel subyacente).

mask es una imagen binaria usada como máscara a nivel de píxel; solo se modifican los píxeles establecidos en la máscara.

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

No compatible con imágenes comprimidas o imágenes bayer.

Métodos de ISP¶

awb(max: bool = False) → Image¶

Realiza un balance de blancos automático en la imagen usando el algoritmo gray-world. Opera sobre imágenes Bayer en bruto o RGB565. No tiene efecto en imágenes binarias/en escala de grises.

max si es True, usa el algoritmo white-patch en su lugar.

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

No compatible con imágenes comprimidas o yuv.

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

Multiplica la matriz de corrección de color de punto flotante pasada con la imagen. Las matrices pueden ser 3x3 o 3x4 (con columna de desplazamiento), en forma de lista anidada o lista plana:

[[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]

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

No compatible con imágenes comprimidas o imágenes bayer/yuv.

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

Ajusta la gamma, el contraste y el brillo de la imagen.

gamma aplica pow(pixel, 1/gamma) después de la normalización. Los valores mayores que 1.0 aclaran; los menores que 1.0 oscurecen.

contrast aplica pixel * contrast después de la normalización.

brightness aplica pixel + brightness después de la normalización.

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

No compatible con imágenes comprimidas o imágenes bayer/yuv.

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

Métodos matemáticos¶

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

replace(image: Image | None = None, **kwargs) → Image¶: Alias de Image.draw_image(). Reemplaza esta imagen con image (o transforma esta imagen in situ si se omite image) usando los argumentos de palabra clave estándar de draw_image. El argumento transform es un ndarray 3x3 que describe una transformación de perspectiva (solo se admite en cámaras OpenMV con ULAB habilitado).

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¶

Suma una imagen píxel a píxel a esta.

image puede ser un objeto de imagen, una ruta a un archivo de imagen sin comprimir (bmp/pgm/ppm) o un valor escalar (tupla RGB888 o valor de píxel subyacente).

mask es una imagen binaria usada como máscara a nivel de píxel; solo se modifican los píxeles establecidos en la máscara.

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

No compatible con imágenes comprimidas o imágenes bayer.

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

Resta image píxel a píxel de esta imagen (self - image).

image puede ser un objeto de imagen, una ruta a un archivo de imagen sin comprimir (bmp/pgm/ppm) o un valor escalar (tupla RGB888 o valor de píxel subyacente).

mask es una imagen binaria usada como máscara a nivel de píxel; solo se modifican los píxeles establecidos en la máscara.

Este método también acepta el conjunto completo de argumentos de palabra clave de Image.draw_image() (x, y, x_scale, y_scale, roi, rgb_channel, alpha, color_palette, alpha_palette, hint, transform).

No compatible con imágenes comprimidas o imágenes bayer.

rsub(image: Image, mask: Image | None = None) → Image¶: Resta inversa: reemplaza esta imagen con image - self píxel a píxel. Por lo demás, idéntico a Image.sub().

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

Devuelve la imagen mínima de dos imágenes píxel a píxel.

image puede ser un objeto de imagen, una ruta a un archivo de imagen sin comprimir (bmp/pgm/ppm) o un valor escalar (tupla RGB888 o valor de píxel subyacente).

mask es una imagen binaria usada como máscara a nivel de píxel; solo se modifican los píxeles establecidos en la máscara.

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

No compatible con imágenes comprimidas o imágenes bayer.

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

Devuelve la imagen máxima de dos imágenes píxel a píxel.

image puede ser un objeto de imagen, una ruta a un archivo de imagen sin comprimir (bmp/pgm/ppm) o un valor escalar (tupla RGB888 o valor de píxel subyacente).

mask es una imagen binaria usada como máscara a nivel de píxel; solo se modifican los píxeles establecidos en la máscara.

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

No compatible con imágenes comprimidas o imágenes bayer.

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

Devuelve la imagen de diferencia absoluta entre dos imágenes (p. ej. ||a-b||).

image puede ser un objeto de imagen, una ruta a un archivo de imagen sin comprimir (bmp/pgm/ppm) o un valor escalar (tupla RGB888 o valor de píxel subyacente).

mask es una imagen binaria usada como máscara a nivel de píxel; solo se modifican los píxeles establecidos en la máscara.

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

No compatible con imágenes comprimidas o imágenes bayer.

blend(image: Image, x: int = 0, y: int = 0, alpha: int = 128, mask: Image | None = None, **kwargs) → Image¶: Alias de Image.draw_image(). Mezcla con alfa image en esta imagen. alpha es un entero 0-256; los valores más cercanos a 256 favorecen la imagen de origen. Acepta todos los argumentos de palabra clave de Image.draw_image().

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

Ejecuta la ecualización de histograma en la imagen para normalizar el contraste y el brillo.

adaptive si es True, ejecuta la ecualización de histograma adaptativa (más lenta pero generalmente mejor).

clip_limit limita el contraste en la variante adaptativa (un valor pequeño como 10 produce buenos resultados de CLAHE).

mask es una imagen binaria usada como máscara a nivel de píxel; solo se modifican los píxeles establecidos en la máscara.

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

No compatible con imágenes comprimidas o imágenes bayer.

Métodos de filtrado¶

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

Elimina píxeles de los bordes de las áreas segmentadas. Convoluciona un kernel ((size*2)+1)x((size*2)+1) a través de la imagen, limpiando el píxel central si más de threshold vecinos están limpios (actúa como una erosión estándar si threshold es None).

mask es una imagen binaria usada como máscara a nivel de píxel; solo se modifican los píxeles establecidos en la máscara.

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

No compatible con imágenes comprimidas o imágenes bayer/yuv.

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

Añade píxeles a los bordes de las áreas segmentadas. Convoluciona un kernel ((size*2)+1)x((size*2)+1) a través de la imagen, estableciendo el píxel central si más de threshold vecinos están establecidos (actúa como una dilatación estándar si threshold es None).

mask es una imagen binaria usada como máscara a nivel de píxel; solo se modifican los píxeles establecidos en la máscara.

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

No compatible con imágenes comprimidas o imágenes bayer/yuv.

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

Realiza una erosión seguida de una dilatación. Consulte Image.erode() e Image.dilate().

mask es una imagen binaria usada como máscara a nivel de píxel; solo se modifican los píxeles establecidos en la máscara.

No compatible con imágenes comprimidas o imágenes bayer/yuv.

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

Realiza una dilatación seguida de una erosión. Consulte Image.dilate() e Image.erode().

mask es una imagen binaria usada como máscara a nivel de píxel; solo se modifican los píxeles establecidos en la máscara.

No compatible con imágenes comprimidas o imágenes bayer/yuv.

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

Devuelve la diferencia de imagen entre la imagen y la imagen tras aplicar Image.open().

mask es una imagen binaria usada como máscara a nivel de píxel; solo se modifican los píxeles establecidos en la máscara.

No compatible con imágenes comprimidas o imágenes bayer/yuv.

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

Devuelve la diferencia de imagen entre la imagen y la imagen tras aplicar Image.close().

mask es una imagen binaria usada como máscara a nivel de píxel; solo se modifican los píxeles establecidos en la máscara.

No compatible con imágenes comprimidas o imágenes bayer/yuv.

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

Filtro estándar de desenfoque por media usando un filtro de caja.

size es el tamaño del kernel. Use 1 (kernel 3x3), 2 (kernel 5x5), etc.

threshold si es True, umbraliza adaptativamente la salida del filtro a una imagen binaria. offset desplaza la binarización (negativo hace que más píxeles sean blancos, positivo hace que sean menos). invert invierte la salida binaria.

mask es una imagen binaria usada como máscara a nivel de píxel; solo se modifican los píxeles establecidos en la máscara.

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

No compatible con imágenes comprimidas o imágenes bayer/yuv.

Ejecuta un filtro de percentil en la imagen (mediana por defecto).

size es el tamaño del kernel. Use 1 (kernel 3x3), 2 (kernel 5x5), etc.

percentile es el percentil a seleccionar de cada kernel (0 = mín, 0.5 = mediana, 1.0 = máx). El valor predeterminado es 0.5.

mask es una imagen binaria usada como máscara a nivel de píxel; solo se modifican los píxeles establecidos en la máscara.

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

No compatible con imágenes comprimidas o imágenes bayer/yuv.

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

Reemplaza cada píxel con la moda de sus vecinos. Puede producir artefactos en los bordes de imágenes RGB debido a la operación no lineal.

size es el tamaño del kernel. Use 1 (kernel 3x3), 2 (kernel 5x5), etc.

mask es una imagen binaria usada como máscara a nivel de píxel; solo se modifican los píxeles establecidos en la máscara.

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

No compatible con imágenes comprimidas o imágenes bayer/yuv.

Ejecuta el filtro de punto medio en la imagen. Este filtro encuentra el punto medio ((max-min)/2) de cada vecindario de píxeles de la imagen.

size es el tamaño del kernel. Use 1 (kernel 3x3), 2 (kernel 5x5), etc.

bias controla la mezcla mín/máx. 0 para filtrado solo mínimo, 1.0 para filtrado solo máximo. Usando bias puede aplicar un filtrado mín/máx a la imagen.

mask es una imagen binaria usada como máscara a nivel de píxel; solo se modifican los píxeles establecidos en la máscara.

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

No compatible con imágenes comprimidas o imágenes bayer/yuv.

Convoluciona la imagen con un kernel de filtro arbitrario.

size controla el tamaño del kernel, que debe tener ((size*2)+1)x((size*2)+1) elementos.

kernel es el kernel con el que convolucionar, como una lista/tupla 1D plana de ((size*2)+1)*((size*2)+1) elementos, o como una lista/tupla 2D con ((size*2)+1) filas de ((size*2)+1) elementos.

mul es una escala de contraste multiplicativa (valor predeterminado 1.0).

add es un desplazamiento de brillo aditivo (valor predeterminado 0.0).

mask es una imagen binaria usada como máscara a nivel de píxel; solo se modifican los píxeles establecidos en la máscara.

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

No compatible con imágenes comprimidas o imágenes bayer/yuv.

Convoluciona la imagen con un kernel gaussiano de suavizado.

size es el tamaño del kernel. Use 1 (kernel 3x3), 2 (kernel 5x5), etc.

unsharp si es True, realiza una operación de máscara de enfoque (afila los bordes) en lugar de un gaussiano simple.

mul es una escala de contraste multiplicativa (valor predeterminado 1.0).

add es un desplazamiento de brillo aditivo (valor predeterminado 0.0).

mask es una imagen binaria usada como máscara a nivel de píxel; solo se modifican los píxeles establecidos en la máscara.

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

No compatible con imágenes comprimidas o imágenes 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¶: Convoluciona la imagen con un kernel laplaciano de detección de bordes.

size es el tamaño del kernel. Use 1 (kernel 3x3), 2 (kernel 5x5), etc.

sharpen si es True, afila la imagen en lugar de emitir la respuesta de borde sin umbralizar en bruto.

mul es una escala de contraste multiplicativa (valor predeterminado 1.0).

add es un desplazamiento de brillo aditivo (valor predeterminado 0.0).

threshold si es True, umbraliza adaptativamente la salida del filtro a una imagen binaria. offset desplaza la binarización (negativo hace que más píxeles sean blancos, positivo hace que sean menos). invert invierte la salida binaria.

mask es una imagen binaria usada como máscara a nivel de píxel; solo se modifican los píxeles establecidos en la máscara.

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

No compatible con imágenes comprimidas o imágenes bayer/yuv.

Convoluciona la imagen con un filtro bilateral (suavizado que preserva los bordes).

size es el tamaño del kernel. Use 1 (kernel 3x3), 2 (kernel 5x5), etc.

color_sigma controla la tolerancia de coincidencia de color; valores más grandes producen más desenfoque de color.

space_sigma controla el desenfoque espacial; valores más grandes producen más desenfoque de píxeles.

mask es una imagen binaria usada como máscara a nivel de píxel; solo se modifican los píxeles establecidos en la máscara.

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

No compatible con imágenes comprimidas o imágenes bayer/yuv.

Métodos geométricos¶

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

Reproyecta una imagen de coordenadas cartesianas a coordenadas polares lineales.

Establezca reverse=True para reproyectar en la dirección opuesta.

x e y especifican la coordenada central de la transformación en píxeles de la imagen. Si x es None (el valor predeterminado) se establece en la mitad del ancho de la imagen; del mismo modo, y adopta por defecto la mitad de la altura de la imagen.

La reproyección polar lineal convierte la rotación de una imagen en traslación en x.

No compatible con imágenes comprimidas o imágenes bayer.

Este método no está disponible en la OpenMV Cam M4.

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

Reproyecta una imagen de coordenadas cartesianas a coordenadas polares logarítmicas.

Establezca reverse=True para reproyectar en la dirección opuesta.

La reproyección polar logarítmica convierte la rotación de una imagen en traslación en x y el escalado/zoom en traslación en y.

No compatible con imágenes comprimidas o imágenes bayer.

Este método no está disponible en la OpenMV Cam M4.

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

Realiza la corrección de lente para deshacer el efecto ojo de pez de la imagen debido a la distorsión de la lente.

strength es un float que define cuánto deshacer el efecto ojo de pez de la imagen. Pruebe 1.8 por defecto y luego aumente o disminuya desde ahí hasta que la imagen se vea bien.

zoom es la cantidad de acercamiento a aplicar a la imagen. 1.0 por defecto.

x_corr desplazamiento de píxeles de punto flotante desde el centro. Puede ser negativo o positivo.

y_corr desplazamiento de píxeles de punto flotante desde el centro. Puede ser negativo o positivo.

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

No compatible con imágenes comprimidas o imágenes 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 problemas de perspectiva en la imagen realizando una rotación 3D del búfer de fotogramas.

x_rotation es el número de grados para rotar la imagen del búfer de fotogramas alrededor del eje x (es decir, esto gira la imagen hacia arriba y hacia abajo).

y_rotation es el número de grados para rotar la imagen del búfer de fotogramas alrededor del eje y (es decir, esto gira la imagen hacia la izquierda y la derecha).

z_rotation es el número de grados para rotar la imagen del búfer de fotogramas alrededor del eje z (es decir, esto gira la imagen sobre sí misma).

x_translation es el número de unidades para mover la imagen a la izquierda o a la derecha después de la rotación. Como esta traslación se aplica en el espacio 3D, las unidades no son píxeles…

y_translation es el número de unidades para mover la imagen hacia arriba o hacia abajo después de la rotación. Como esta traslación se aplica en el espacio 3D, las unidades no son píxeles…

zoom es la cantidad de acercamiento a aplicar a la imagen. 1.0 por defecto.

fov es el campo de visión usado para la proyección interna 2D->3D. A medida que fov se acerca a 0, la imagen se coloca en el infinito; a medida que se acerca a 180, la imagen se coloca dentro del viewport.

corners es una lista de cuatro tuplas (x, y) usadas para construir una homografía de 4 puntos que mapea las esquinas a (0, 0), (image_width-1, 0), (image_width-1, image_height-1) y (0, image_height-1) antes de aplicar la rotación 3D. Útil para transformaciones de vista de pájaro.

Devuelve el objeto de imagen para que pueda llamar a otro método usando la notación ..

No compatible con imágenes comprimidas o imágenes bayer.

Este método no está disponible en la OpenMV Cam M4.

Métodos de obtención¶

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¶

Calcula la similitud entre dos imágenes usando el Índice de Similitud Estructural (SSIM). El SSIM varía de -1 (opuesto) a 1 (idéntico). Devuelve un objeto image.similarity.

image es la imagen con la que comparar (un objeto de imagen o una cadena de ruta, p. ej. "test.jpg").

x, y, x_scale, y_scale, roi, rgb_channel, alpha, color_palette, alpha_palette, hint y transform aceptan los mismos valores que Image.draw_image().

dssim si es True, devuelve en su lugar el Índice de Disimilitud Estructural (DSSIM), donde 0 significa idéntico y 1 significa completamente diferente.

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¶

Calcula el histograma normalizado en todos los canales de color para una roi y devuelve un objeto image.histogram. También está disponible como Image.get_hist() o Image.histogram().

thresholds es una lista de tuplas (lo, hi) para imágenes en escala de grises, o tuplas (l_lo, l_hi, a_lo, a_hi, b_lo, b_hi) para imágenes RGB565. Si se pasa, el histograma se calcula solo sobre los píxeles dentro de los umbrales.

invert invierte la coincidencia de umbral.

roi es la tupla del rectángulo de la región de interés (x, y, w, h). Por defecto es el rectángulo de la imagen.

bins (escala de grises) o l_bins/a_bins/b_bins (RGB565) establecen el número de contenedores del histograma por canal. Debe ser mayor que 2. Por defecto es el máximo de contenedores por canal.

difference puede establecerse en un objeto de imagen para operar sobre la diferencia entre la imagen actual y esa imagen sin un búfer adicional.

No compatible con imágenes comprimidas o imágenes 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¶

Calcula la media, la mediana, la moda, la desviación estándar, el mín, el máx, el cuartil inferior y el cuartil superior para todos los canales de color de una roi y devuelve un objeto image.statistics. También está disponible como Image.get_stats() o Image.statistics().

thresholds es una lista de tuplas (lo, hi) para imágenes en escala de grises, o tuplas (l_lo, l_hi, a_lo, a_hi, b_lo, b_hi) para imágenes RGB565. Si se pasa, las estadísticas se calculan solo sobre los píxeles dentro de los umbrales.

invert invierte la coincidencia de umbral.

roi es la tupla del rectángulo de la región de interés (x, y, w, h). Por defecto es el rectángulo de la imagen.

difference puede establecerse en un objeto de imagen para operar sobre la diferencia entre la imagen actual y esa imagen sin un búfer adicional.

No compatible con imágenes comprimidas o imágenes 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¶

Calcula una regresión lineal (Theil-Sen) sobre todos los píxeles umbralizados de la imagen. Devuelve un objeto image.line, o None si no se encontró ninguna línea.

thresholds es una lista de tuplas (lo, hi) para imágenes en escala de grises, o tuplas (l_lo, l_hi, a_lo, a_hi, b_lo, b_hi) para imágenes RGB565.

invert invierte la coincidencia de umbral.

roi es la tupla del rectángulo de la región de interés (x, y, w, h). Por defecto es el rectángulo de la imagen.

x_stride e y_stride controlan cuántos píxeles se omiten al evaluar la imagen.

area_threshold área mínima del cuadro delimitador; los resultados más pequeños devuelven None.

pixels_threshold recuento mínimo de píxeles umbralizados; los resultados más pequeños devuelven None.

target_size es una tupla (w, h). La ROI se reduce por área para que quepa dentro de este tamaño antes de ejecutar el algoritmo O(N^2). Por defecto es (80, 60).

No compatible con imágenes comprimidas o imágenes bayer.

Métodos de detección¶

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]¶

Encuentra todas las manchas (blobs) (regiones de píxeles conectadas que pasan una prueba de umbral) en la imagen y devuelve una lista de objetos image.blob.

thresholds es una lista de tuplas (lo, hi) para imágenes en escala de grises, o tuplas (l_lo, l_hi, a_lo, a_hi, b_lo, b_hi) para imágenes RGB565 (canales LAB). Se pueden pasar hasta 32 tuplas. Los valores mín/máx intercambiados se corrigen automáticamente; los componentes faltantes adoptan por defecto el rango máximo.

invert invierte la coincidencia de umbral.

roi es la tupla del rectángulo de la región de interés (x, y, w, h). Por defecto es el rectángulo de la imagen.

x_stride e y_stride controlan cuántos píxeles se omiten al buscar una mancha. Auméntelos si se sabe que las manchas son grandes.

area_threshold área mínima del cuadro delimitador; las manchas más pequeñas se filtran.

pixels_threshold recuento mínimo de píxeles umbralizados; las manchas más pequeñas se filtran.

merge si es True fusiona las manchas cuyos rectángulos delimitadores se intersecan. margin agranda/reduce los rectángulos delimitadores usados para la intersección. Las manchas fusionadas aplican un OR entre sus vectores de bits code (un bit por umbral).

threshold_cb se llama por cada mancha tras la umbralización; devuelva True para conservarla, False para filtrarla.

merge_cb se llama por cada par de manchas a punto de fusionarse; devuelva True para permitir la fusión, False para impedirla.

x_hist_bins_max si es distinto de cero, rellena cada mancha con una proyección x_histogram usando esta cantidad de contenedores.

y_hist_bins_max si es distinto de cero, rellena cada mancha con una proyección y_histogram usando esta cantidad de contenedores.

No compatible con imágenes comprimidas o imágenes 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]¶

Encuentra todas las líneas infinitas en la imagen usando la transformada de Hough. Devuelve una lista de objetos image.line.

roi es la tupla del rectángulo de la región de interés (x, y, w, h). Por defecto es el rectángulo de la imagen.

x_stride e y_stride controlan cuántos píxeles se omiten durante la transformada de Hough.

threshold magnitud mínima de línea (suma de magnitudes sobel a lo largo de la línea); las líneas por debajo de esto se filtran.

theta_margin y rho_margin controlan la fusión: las líneas dentro de estos umbrales se fusionan.

No compatible con imágenes comprimidas o imágenes bayer.

Este método no está disponible en la 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]¶

Encuentra segmentos de línea en la imagen. Devuelve una lista de objetos image.line.

roi es la tupla del rectángulo de la región de interés (x, y, w, h). Por defecto es el rectángulo de la imagen.

merge_distance es la separación máxima en píxeles entre dos segmentos para que se fusionen.

max_theta_difference es la diferencia máxima de theta en grados entre segmentos para que se fusionen.

Este método no está disponible en la 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]¶

Encuentra círculos en la imagen usando la transformada de Hough. Devuelve una lista de objetos image.circle.

roi es la tupla del rectángulo de la región de interés (x, y, w, h). Por defecto es el rectángulo de la imagen.

x_stride e y_stride controlan cuántos píxeles se omiten durante la transformada de Hough.

threshold magnitud mínima de círculo (suma de magnitudes sobel a lo largo del círculo); los círculos por debajo de esto se filtran.

x_margin, y_margin y r_margin controlan la fusión: los círculos dentro de estos umbrales se fusionan.

r_min radio mínimo del círculo. Por defecto es 2.

r_max radio máximo del círculo. Por defecto es min(roi.w/2, roi.h/2).

r_step tamaño del paso de radio. Por defecto es 2.

Este método no está disponible en la OpenMV Cam M4.

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

Encuentra rectángulos en la imagen usando el algoritmo de detección de cuadriláteros de apriltag. Devuelve una lista de objetos image.rect.

roi es la tupla del rectángulo de la región de interés (x, y, w, h). Por defecto es el rectángulo de la imagen.

threshold magnitud mínima de borde (suma de magnitudes sobel a lo largo de los bordes del rectángulo); los rectángulos por debajo de esto se filtran.

Este método no está disponible en la OpenMV Cam M4.

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

Encuentra todos los códigos qr dentro de la roi y devuelve una lista de objetos image.qrcode.

roi es la tupla del rectángulo de la región de interés (x, y, w, h). Por defecto es el rectángulo de la imagen.

Este método no está disponible en la OpenMV Cam M4.

Encuentra todos los apriltags dentro de la roi y devuelve una lista de objetos image.apriltag.

roi es la tupla del rectángulo de la región de interés (x, y, w, h). Por defecto es el rectángulo de la imagen.

families es una máscara de bits de familias de etiquetas a decodificar. Es el OR lógico de:

image.TAG16H5

image.TAG25H9

image.TAG36H10

image.TAG36H11

image.TAGCIRCLE21H7

image.TAGCIRCLE49H12

image.TAGCUSTOM48H12

image.TAGSTANDARD41H12

image.TAGSTANDARD52H13

Por defecto es image.TAG36H11. El tiempo de detección escala con el número de familias habilitadas.

fx y fy son las distancias focales X e Y de la cámara en píxeles.

cx y cy son el centro de la imagen, típicamente image.width()/2 e image.height()/2.

No compatible con imágenes comprimidas.

Este método no está disponible en la OpenMV Cam M4.

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

Encuentra todas las datamatrices dentro de la roi y devuelve una lista de objetos image.datamatrix.

roi es la tupla del rectángulo de la región de interés (x, y, w, h). Por defecto es el rectángulo de la imagen.

effort controla cuánto tiempo dedicar a intentar encontrar coincidencias de data matrix. Los valores más altos mejoran la detección a costa de la tasa de fotogramas. Los valores por debajo de ~160 no logran detectar; los valores por encima de ~240 producen rendimientos decrecientes. Por defecto es 200.

Este método no está disponible en la OpenMV Cam M4.

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

Encuentra todos los códigos de barras 1D dentro de la roi y devuelve una lista de objetos image.barcode. Escanea tanto horizontal como verticalmente.

Tipos de código de barras admitidos: 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 es la tupla del rectángulo de la región de interés (x, y, w, h). Por defecto es el rectángulo de la imagen.

Este método no está disponible en la 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¶

Encuentra el desplazamiento de traslación de esta imagen respecto a template usando correlación de fase. Devuelve un objeto image.displacement.

roi es el rectángulo de la región de interés (x, y, w, h). Por defecto es el rectángulo de la imagen.

template_roi es la región de interés de la plantilla. Por defecto es el rectángulo de la imagen de plantilla. roi y template_roi deben tener el mismo ancho y altura.

logpolar si es True devuelve el cambio de rotación/escala en lugar de la traslación x/y.

fix_rotation_scale si es True, calcula el desplazamiento después de alinear la rotación y la escala (solo tiene sentido cuando logpolar=False).

Nota

Use este método con tamaños de imagen potencia de 2 (p. ej. sensor.B64X64).

No compatible con imágenes comprimidas o imágenes bayer. No disponible en la 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¶

Intenta encontrar la primera ubicación de la imagen donde coincide template usando Correlación Cruzada Normalizada. Devuelve una tupla de cuadro delimitador (x, y, w, h), o None.

template es una imagen en escala de grises para coincidir con esta imagen.

threshold es un valor (0.0-1.0). Los valores más altos reducen los falsos positivos y las detecciones; los valores más bajos hacen lo contrario.

roi es la tupla del rectángulo de la región de interés (x, y, w, h). Por defecto es el rectángulo de la imagen.

step es el número de píxeles a omitir durante la búsqueda (solo se usa en el modo image.SEARCH_EX).

search es image.SEARCH_DS (búsqueda en diamante más rápida) o image.SEARCH_EX (búsqueda exhaustiva).

Solo funciona en imágenes en escala de grises.

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]]¶

Busca en la imagen áreas que coincidan con la cascada Haar pasada y devuelve una lista de tuplas de cuadro delimitador (x, y, w, h). Devuelve una lista vacía si no se encuentran características.

cascade es un objeto de cascada Haar (consulte image.HaarCascade()).

threshold (0.0-1.0). Los valores más bajos aumentan la tasa de detección y la tasa de falsos positivos.

scale debe ser mayor que 1.0. Los valores más altos se ejecutan más rápido pero producen peores coincidencias.

roi es la tupla del rectángulo de la región de interés (x, y, w, h). Por defecto es el rectángulo de la imagen.

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

Busca la pupila en una tupla de región de interés (x, y, w, h) alrededor de un ojo. Devuelve la ubicación (x, y) de la pupila, o (0, 0) si no se encuentra ninguna.

roi es la tupla del rectángulo de la región de interés (x, y, w, h).

Solo funciona en imágenes en escala de grises.

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

Extrae puntos clave LBP (patrones binarios locales) de la región de interés. Use image.match_descriptor() para comparar dos descriptores.

roi es la tupla del rectángulo de la región de interés (x, y, w, h).

Solo funciona en imágenes en escala de grises.

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¶

Extrae puntos clave ORB de la región de interés. Use image.match_descriptor() para comparar dos descriptores. Devuelve None si no se encontraron puntos clave.

roi es la tupla del rectángulo de la región de interés (x, y, w, h). Por defecto es el rectángulo de la imagen.

threshold (0-255) controla el número de esquinas extraídas. Los umbrales más bajos producen más esquinas. Use ~20 para AGAST, ~60-80 para FAST.

normalized si es True, desactiva la extracción de puntos clave multirresolución.

scale_factor debe ser mayor que 1.0. Los valores más altos se ejecutan más rápido pero producen peores coincidencias.

max_keypoints es el número máximo de puntos clave a retener.

corner_detector es image.CORNER_FAST o image.CORNER_AGAST.

Solo funciona en imágenes en escala de grises.

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

Convierte la imagen en blanco y negro dejando solo los bordes como píxeles blancos.

image.EDGE_SIMPLE - Algoritmo simple de filtro paso alto umbralizado.

image.EDGE_CANNY - Algoritmo de detección de bordes Canny.

threshold es una tupla de dos valores que contiene un umbral bajo y un umbral alto. Puede controlar la calidad de los bordes ajustando estos valores. Por defecto es (100, 200).

Solo funciona en imágenes en escala de grises.

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

Reemplaza los píxeles de la ROI con líneas HOG (histograma de gradientes orientados).

roi es la tupla del rectángulo de la región de interés (x, y, w, h). Si no se especifica, es igual al rectángulo de la imagen. Solo se opera sobre los píxeles dentro de la roi.

Solo funciona en imágenes en escala de grises.

Este método no está disponible en la OpenMV Cam M4.

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

Toma una imagen en escala de grises de doble ancho que contiene la salida de dos sensores de cámara contiguos y reemplaza una mitad con la imagen de disparidad estéreo (cada píxel representa la profundidad). P. ej. para dos cámaras de 320x240 pase una imagen de 640x240.

reversed Por defecto la imagen izquierda se compara con la derecha y la imagen derecha se reemplaza. Establézcalo en True para comparar derecha->izquierda y reemplazar la imagen izquierda.

max_disparity es la distancia máxima (1-255) a buscar para un bloque de píxeles coincidente usando la suma de diferencias absolutas. Los valores más grandes tardan exponencialmente más pero producen una salida de mayor calidad.

threshold si la suma de diferencias absolutas entre dos bloques es menor o igual a este umbral, se consideran coincidentes.

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]]¶

Ejecuta la búsqueda selectiva en la imagen y devuelve una lista de tuplas de cuadro delimitador (x, y, w, h) de propuestas de objetos.

threshold es el umbral de segmentación; los valores más altos producen menos regiones / regiones más grandes.

size es el tamaño mínimo de región tras la fusión.

a1, a2, a3 son los pesos de similitud de color/textura/tamaño usados al fusionar regiones.