class Image – Objeto de imagem¶

Image é o tipo de dado central do módulo image – um buffer de pixels em memória sobre o qual operam todas as rotinas de desenho, todos os filtros, todas as transformações geométricas e todas as rotinas de extração de características. Todo quadro que sai de csi.CSI.snapshot() é uma Image; assim como todo quadro carregado do disco, decodificado de JPEG ou PNG, alocado a partir de um ndarray no estilo numpy ou construído como uma tela de desenho vazia.

Uma Image é descrita por três números – width, height e pixformat – mais um buffer de pixels contíguo. O formato de pixel determina tanto o layout em memória quanto quais operações estão disponíveis:

BINARY (1 bpp) – 1 bit por pixel; usado por morfologia e limiarização.
GRAYSCALE (8 bpp) – 1 byte por pixel; o formato canônico para a maioria das tarefas de visão computacional (AprilTag, bordas, ORB, fluxo óptico).
RGB565 (16 bpp) – 2 bytes por pixel (5R/6G/5B); o formato de cor padrão.
BAYER (8 bpp) – dados brutos do mosaico Bayer direto do sensor. A maioria dos métodos de visão computacional não está disponível em imagens Bayer; converta para GRAYSCALE / RGB565 com debayer primeiro.
YUV422 (16 bpp) – cor com subamostragem de croma 4:2:2, dois bytes por pixel. Apenas alguns métodos funcionam diretamente sobre YUV422.
JPEG / PNG – buffers comprimidos. Operações em nível de pixel exigem to_grayscale() ou to_rgb565() primeiro.

De onde vêm os objetos Image¶

Há quatro formas de obter uma Image:

A partir do frame buffer da câmera – csi.CSI().snapshot() retorna o próximo quadro capturado. O objeto retornado é um invólucro fino sobre a memória do frame buffer da câmera, de modo que qualquer operação de desenho / filtro sobre ele altera o que é enviado para a pré-visualização do IDE e para o display.
A partir de um arquivo – passe uma string de caminho para o construtor Image. BMP, PGM, PPM, JPEG e PNG são decodificados diretamente para a RAM (ou para o frame buffer da câmera se copy_to_fb=True).
A partir de um ndarray – passe um array float32 de formato (h, w) ou (h, w, 3). Os pixels são escalados de 0.0 -- 255.0 para GRAYSCALE ou RGB565, respectivamente.
Vazia – passe (width, height, pixformat) para alocar uma superfície de desenho preenchida com zeros. Para formatos de pixel comprimidos (JPEG / PNG), um argumento buffer= é obrigatório e contém o fluxo de bytes comprimido.

Laço típico de captura-processamento-exibição¶

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.

Indexação, comprimento, iteração e acesso semelhante a bytes¶

Indexação – img[i] lê o pixel i (linearmente, em ordem de linha). img[i] = value o escreve. Pixels de imagens grayscale / Bayer são inteiros de 8 bits, pixels RGB565 / YUV422 são inteiros empacotados de 16 bits, pixels binários são 0 / 1. Para imagens JPEG / PNG o espaço de índice é o fluxo de bytes comprimido, não os pixels.
Comprimento – len(img) retorna o número de pixels para formatos não comprimidos ou a contagem de bytes para formatos comprimidos.
Iteração – for px in img: ... percorre o array de pixels na mesma ordem da indexação [].
Semelhante a bytes – Image expõe o protocolo de buffer de leitura, então você pode passá-la diretamente para qualquer coisa que aceite um bytes / bytearray (por exemplo, uart.write(img), socket.send(img), hashlib.sha256(img)). Use bytearray() em vez disso para obter uma visão de leitura/escrita.

Flags de dica (hint)¶

Muitos métodos de Image aceitam um argumento hint que é um OR lógico das seguintes flags:

image.AREA: Usa escalonamento por área ao reduzir, em vez do padrão de vizinho mais próximo.

image.BILINEAR: Usa escalonamento bilinear em vez do escalonamento padrão por vizinho mais próximo.

image.BICUBIC: Usa escalonamento bicúbico em vez do escalonamento padrão por vizinho mais próximo.

image.CENTER: Centraliza a imagem que está sendo desenhada no display. Isso é aplicado após o escalonamento.

image.HMIRROR: Espelha a imagem horizontalmente.

image.VFLIP: Inverte a imagem verticalmente.

image.TRANSPOSE: Transpõe a imagem (troca x/y).

image.EXTRACT_RGB_CHANNEL_FIRST: Faz a extração de rgb_channel antes do escalonamento.

image.APPLY_COLOR_PALETTE_FIRST: Aplica a paleta de cores antes do escalonamento.

image.SCALE_ASPECT_KEEP: Escala a imagem que está sendo desenhada para caber dentro do display.

image.SCALE_ASPECT_EXPAND: Escala a imagem que está sendo desenhada para preencher o display (resulta em recorte).

image.SCALE_ASPECT_IGNORE: Escala a imagem que está sendo desenhada para preencher o display (resulta em esticamento).

image.ROTATE_90: Rotaciona a imagem em 90 graus (isso é apenas VFLIP | TRANSPOSE).

image.ROTATE_180: Rotaciona a imagem em 180 graus (isso é apenas HMIRROR | VFLIP).

image.ROTATE_270: Rotaciona a imagem em 270 graus (isso é apenas HMIRROR | TRANSPOSE).

image.BLACK_BACKGROUND: Assume que a imagem de fundo sobre a qual se desenha é preta, acelerando a mesclagem. Suportado apenas por Image.draw_image() e Image.get_similarity().

Se arg for uma string, isso cria um novo objeto de imagem a partir de um arquivo no caminho arg. Suporta o carregamento de arquivos de imagem bmp/pgm/ppm/jpg/jpeg/png do disco. Se copy_to_fb for verdadeiro, a imagem é copiada para o frame buffer em vez de ser alocada no heap.

Se arg for um ndarray, isso cria um novo objeto de imagem a partir do ndarray. Objetos ndarray com formato (w, h) são tratados como imagens em escala de cinza, (w, h, 3) são tratados como imagens RGB565. Apenas ndarrays de ponto flutuante float32 são suportados no momento. Ao criar uma imagem desta forma, se você passar um argumento buffer, ele será usado para armazenar os dados da imagem em vez de alocar espaço no heap. Se copy_to_fb for verdadeiro, a imagem é copiada para o frame buffer em vez de ser alocada no heap ou usando o buffer.

Se arg for um int, ele é então considerado a largura de uma nova imagem, e um valor height e um valor format devem seguir para criar um novo objeto de imagem em branco. format pode ser qualquer valor de pixformat de imagem, como image.GRAYSCALE. A imagem será inicializada com tudo zerado. Observe que um valor buffer é esperado para formatos de imagem comprimidos. buffer é considerado a fonte dos dados da imagem ao criar imagens desta forma. Se usado com copy_to_fb, os dados de buffer são copiados para o frame buffer. Se você quiser criar uma imagem JPEG a partir de um objeto JPEG bytes() ou bytearray(), você pode passar width, height, image.JPEG para o JPEG, além de definir buffer como o fluxo de bytes JPEG para criar uma imagem JPEG.

Imagens suportam a notação “[]”. Faça image[index] = 8/16-bit value para atribuir um pixel da imagem ou image[index] para obter um pixel da imagem, que será um valor de 8 bits para imagens grayscale/bayer ou um valor de 16 bits para imagens RGB565/YUV. Imagens binárias retornam um valor de 1 bit.

Para imagens JPEG, o “[]” permite acessar o blob da imagem JPEG comprimida como um array de bytes. A leitura e a escrita no array de dados são opacas, no entanto, já que imagens JPEG são fluxos de bytes comprimidos.

Imagens também suportam operações de buffer de leitura. Você pode passar imagens para todo tipo de função do MicroPython como se a imagem fosse um objeto array de bytes. Em particular, se você quiser transmitir uma imagem, pode simplesmente passá-la para as funções de escrita UART/SPI/I2C para que seja transmitida automaticamente.

Métodos básicos¶

width() → int¶: Retorna a largura da imagem em pixels.

height() → int¶: Retorna a altura da imagem em pixels.

format() → int¶: Retorna image.GRAYSCALE para imagens em escala de cinza, image.RGB565 para imagens RGB565, image.BAYER para imagens com padrão bayer e image.JPEG para imagens JPEG.

size() → int¶: Retorna o tamanho da imagem em bytes.

bytearray() → bytearray¶: Retorna um objeto bytearray que aponta para os dados da imagem para acesso de leitura/escrita em nível de byte.

Nota

Objetos de imagem são automaticamente convertidos em objetos bytes quando passados a um driver do MicroPython que requer um objeto semelhante a bytes. Esse é um acesso somente leitura. Chame bytearray() para obter acesso de leitura/escrita.

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

Para imagens em escala de cinza: Retorna o valor do pixel em escala de cinza na localização (x, y). Para imagens RGB565: Retorna a tupla de pixel RGB888 (r, g, b) na localização (x, y). Para imagens com padrão bayer: Retorna o valor do pixel na localização (x, y).

Retorna None se x ou y estiver fora da imagem.

x e y podem ser passados independentemente ou como uma tupla.

rgbtuple se True faz com que este método retorne uma tupla RGB888. Caso contrário, este método retorna o valor inteiro do pixel subjacente. Ou seja, para imagens RGB565 este método retorna um valor RGB565. O padrão é True para imagens RGB565 e False caso contrário.

Não suportado em imagens comprimidas.

Nota

Image.get_pixel() e Image.set_pixel() são os únicos métodos que permitem manipular imagens com padrão bayer. Imagens com padrão bayer são imagens literais nas quais os pixels são R/G/R/G/etc. para linhas pares e G/B/G/B/etc. para linhas ímpares. Cada pixel tem 8 bits. Se você chamar este método com rgbtuple definido, então Image.get_pixel() fará o debayer da imagem de origem naquela localização de pixel e retornará uma tupla RGB888 válida para a localização do pixel.

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

Para imagens em escala de cinza: Define o pixel na localização (x, y) como o valor em escala de cinza pixel. Para imagens RGB565: Define o pixel na localização (x, y) como a tupla RGB888 (r, g, b) pixel. Para imagens com padrão bayer: Define o valor do pixel na localização (x, y) como o valor pixel.

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

x e y podem ser passados independentemente ou como uma tupla.

pixel pode ser uma tupla RGB888 (r, g, b) ou o valor de pixel subjacente (ou seja, um valor RGB565 para imagens RGB565 ou um valor de 8 bits para imagens em escala de cinza).

Não suportado em imagens comprimidas.

Nota

Image.get_pixel() e Image.set_pixel() são os únicos métodos que permitem manipular imagens com padrão bayer. Imagens com padrão bayer são imagens literais nas quais os pixels são R/G/R/G/etc. para linhas pares e G/B/G/B/etc. para linhas ímpares. Cada pixel tem 8 bits. Se você chamar este método com uma tupla RGB888, o valor em escala de cinza dessa tupla RGB888 é extraído e definido na localização do pixel.

Métodos de conversão¶

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

Retorna um objeto ndarray criado a partir da imagem. Isso atualmente só funciona para imagens GRAYSCALE ou RGB565.

dtype pode ser b, B ou f para criar um ndarray de 8 bits com sinal, 8 bits sem sinal ou ponto flutuante de 32 bits. Imagens GRAYSCALE são diretamente convertidas em objetos ndarray de 8 bits sem sinal. Para objetos ndarray de 8 bits com sinal, os valores (0:255) são mapeados para (-127:128). Para objetos ndarray float de 32 bits, os valores são mapeados para (0.0:255.0). Imagens RGB565 são convertidas em objetos ndarray de 3 canais e o mesmo processo descrito acima para imagens GRAYSCALE é aplicado a cada canal, dependendo de dtype. Observe que dtype também aceita os valores inteiros (por exemplo, ord()) de b, B e f, respectivamente.

buffer se não for None é um objeto bytearray a ser usado como buffer para o ndarray. Se None, um novo buffer é alocado no heap para armazenar os dados da imagem ndarray. Você pode usar o argumento buffer para alocar diretamente o ndarray em um buffer pré-alocado, economizando uma alocação no heap e uma operação de cópia.

O ndarray retornado tem o formato (height, width) para imagens GRAYSCALE e (height, width, 3) para imagens 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¶

Converte uma imagem em uma imagem de bitmap (1 bit por pixel).

x_scale controla o quanto a imagem exibida é escalada na direção x (float). Se este valor for negativo, a imagem será invertida horizontalmente. Observe que se y_scale não for especificado, ele corresponderá a x_scale para manter a proporção.

y_scale controla o quanto a imagem exibida é escalada na direção y (float). Se este valor for negativo, a imagem será invertida verticalmente. Observe que se x_scale não for especificado, ele corresponderá a x_scale para manter a proporção.

roi é a tupla de retângulo de região de interesse (x, y, w, h) da imagem de origem a ser desenhada. Isso permite extrair apenas os pixels na ROI para escalar e desenhar na imagem de destino.

rgb_channel é o canal RGB (0=R, G=1, B=2) a ser extraído de uma imagem RGB565 (se passada) e renderizado na imagem de destino. Por exemplo, se você passar rgb_channel=1, isso extrairá o canal verde da imagem RGB565 de origem e o desenhará em escala de cinza na imagem de destino.

alpha controla o quanto da imagem de origem é mesclado na imagem de destino. Um valor de 255 desenha uma imagem de origem opaca, enquanto um valor menor que 255 produz uma mesclagem entre a imagem de origem e a de destino. 0 resulta em nenhuma modificação na imagem de destino.

color_palette se não for None pode ser um enum de paleta de cores ou uma imagem RGB565 de 256 pixels no total a ser usada como tabela de consulta de cores sobre o valor em escala de cinza de qualquer que seja a imagem de origem. Isso é aplicado após a extração de rgb_channel, se usada.

alpha_palette se não for None pode ser uma imagem GRAYSCALE de 256 pixels no total a ser usada como paleta alfa, que modula o valor alpha da imagem de origem sendo desenhada em nível de pixel, permitindo controlar com precisão o valor alfa dos pixels com base em seu valor em escala de cinza. Um valor de pixel de 255 na tabela de consulta alfa é opaco, enquanto qualquer coisa menor que 255 se torna mais transparente até 0. Isso é aplicado após a extração de rgb_channel, se usada.

hint é um OR lógico das flags listadas em Flags de dica (excluindo image.BLACK_BACKGROUND, que não é suportada aqui).

transform é um ndarray 3x3 usado para realizar uma transformação de perspectiva na imagem. Atualmente suportado apenas na OpenMV Cam N6, pois ela tem uma GPU que pode fazer isso em hardware.

copy se True cria uma cópia profunda no heap da imagem que foi convertida, em vez de converter a imagem original no local.

copy_to_fb se True a imagem é carregada diretamente no frame buffer. copy_to_fb tem prioridade sobre copy. Isso não tem efeito especial se a imagem já estiver no frame buffer.

Nota

Imagens de bitmap são como imagens em escala de cinza com apenas dois valores de pixel - 0 e 1. Além disso, imagens de bitmap são empacotadas de forma que armazenam apenas 1 bit por pixel, tornando-as muito pequenas. A biblioteca de imagens da OpenMV permite que imagens de bitmap sejam usadas em todos os lugares onde imagens sensor.GRAYSCALE e sensor.RGB565 podem ser usadas. No entanto, muitas operações, quando aplicadas a imagens de bitmap, não fazem sentido, porque imagens de bitmap têm apenas 2 valores. A OpenMV recomenda usar imagens de bitmap como valores de mask em operações e similares, pois elas cabem no heap do MicroPython com bastante facilidade. Por fim, os valores de pixel 0 e 1 de imagens de bitmap são interpretados como preto e branco quando aplicados a imagens sensor.GRAYSCALE ou sensor.RGB565. A biblioteca lida com a conversão automaticamente.

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

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¶

Converte uma imagem em uma imagem em escala de cinza (8 bits por pixel).

roi é a tupla de retângulo de região de interesse (x, y, w, h) da imagem de origem a ser desenhada. Isso permite extrair apenas os pixels na ROI para escalar e desenhar na imagem de destino.

hint é um OR lógico das flags listadas em Flags de dica (excluindo image.BLACK_BACKGROUND, que não é suportada aqui).

transform é um ndarray 3x3 usado para realizar uma transformação de perspectiva na imagem. Atualmente suportado apenas na OpenMV Cam N6, pois ela tem uma GPU que pode fazer isso em hardware.

copy se True cria uma cópia profunda no heap da imagem que foi convertida, em vez de converter a imagem original no local.

copy_to_fb se True a imagem é carregada diretamente no frame buffer. copy_to_fb tem prioridade sobre copy. Isso não tem efeito especial se a imagem já estiver no frame buffer.

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

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¶

Converte uma imagem em uma imagem RGB565 (16 bits por pixel).

roi é a tupla de retângulo de região de interesse (x, y, w, h) da imagem de origem a ser desenhada. Isso permite extrair apenas os pixels na ROI para escalar e desenhar na imagem de destino.

hint é um OR lógico das flags listadas em Flags de dica (excluindo image.BLACK_BACKGROUND, que não é suportada aqui).

transform é um ndarray 3x3 usado para realizar uma transformação de perspectiva na imagem. Atualmente suportado apenas na OpenMV Cam N6, pois ela tem uma GPU que pode fazer isso em hardware.

copy se True cria uma cópia profunda no heap da imagem que foi convertida, em vez de converter a imagem original no local.

copy_to_fb se True a imagem é carregada diretamente no frame buffer. copy_to_fb tem prioridade sobre copy. Isso não tem efeito especial se a imagem já estiver no frame buffer.

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

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¶

Converte uma imagem em uma imagem RGB565 rainbow (16 bits por pixel).

roi é a tupla de retângulo de região de interesse (x, y, w, h) da imagem de origem a ser desenhada. Isso permite extrair apenas os pixels na ROI para escalar e desenhar na imagem de destino.

hint é um OR lógico das flags listadas em Flags de dica (excluindo image.BLACK_BACKGROUND, que não é suportada aqui).

transform é um ndarray 3x3 usado para realizar uma transformação de perspectiva na imagem. Atualmente suportado apenas na OpenMV Cam N6, pois ela tem uma GPU que pode fazer isso em hardware.

copy se True cria uma cópia profunda no heap da imagem que foi convertida, em vez de converter a imagem original no local.

copy_to_fb se True a imagem é carregada diretamente no frame buffer. copy_to_fb tem prioridade sobre copy. Isso não tem efeito especial se a imagem já estiver no frame buffer.

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

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¶

Converte uma imagem em uma imagem RGB565 ironbow (16 bits por pixel).

roi é a tupla de retângulo de região de interesse (x, y, w, h) da imagem de origem a ser desenhada. Isso permite extrair apenas os pixels na ROI para escalar e desenhar na imagem de destino.

hint é um OR lógico das flags listadas em Flags de dica (excluindo image.BLACK_BACKGROUND, que não é suportada aqui).

transform é um ndarray 3x3 usado para realizar uma transformação de perspectiva na imagem. Atualmente suportado apenas na OpenMV Cam N6, pois ela tem uma GPU que pode fazer isso em hardware.

copy se True cria uma cópia profunda no heap da imagem que foi convertida, em vez de converter a imagem original no local.

copy_to_fb se True a imagem é carregada diretamente no frame buffer. copy_to_fb tem prioridade sobre copy. Isso não tem efeito especial se a imagem já estiver no frame buffer.

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

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¶

Converte uma imagem em uma Imagem de Profundidade RGB565 (16 bits por pixel).

roi é a tupla de retângulo de região de interesse (x, y, w, h) da imagem de origem a ser desenhada. Isso permite extrair apenas os pixels na ROI para escalar e desenhar na imagem de destino.

color_palette se não for None pode ser image.PALETTE_DEPTH ou uma imagem RGB565 de 256 pixels no total a ser usada como tabela de consulta de cores sobre o valor em escala de cinza de qualquer que seja a imagem de origem. Isso é aplicado após a extração de rgb_channel, se usada.

hint é um OR lógico das flags listadas em Flags de dica (excluindo image.BLACK_BACKGROUND, que não é suportada aqui).

transform é um ndarray 3x3 usado para realizar uma transformação de perspectiva na imagem. Atualmente suportado apenas na OpenMV Cam N6, pois ela tem uma GPU que pode fazer isso em hardware.

copy se True cria uma cópia profunda no heap da imagem que foi convertida, em vez de converter a imagem original no local.

copy_to_fb se True a imagem é carregada diretamente no frame buffer. copy_to_fb tem prioridade sobre copy. Isso não tem efeito especial se a imagem já estiver no frame buffer.

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

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¶

Converte uma imagem em uma Imagem de Evento Escuro RGB565 (16 bits por pixel).

roi é a tupla de retângulo de região de interesse (x, y, w, h) da imagem de origem a ser desenhada. Isso permite extrair apenas os pixels na ROI para escalar e desenhar na imagem de destino.

hint é um OR lógico das flags listadas em Flags de dica (excluindo image.BLACK_BACKGROUND, que não é suportada aqui).

transform é um ndarray 3x3 usado para realizar uma transformação de perspectiva na imagem. Atualmente suportado apenas na OpenMV Cam N6, pois ela tem uma GPU que pode fazer isso em hardware.

copy se True cria uma cópia profunda no heap da imagem que foi convertida, em vez de converter a imagem original no local.

copy_to_fb se True a imagem é carregada diretamente no frame buffer. copy_to_fb tem prioridade sobre copy. Isso não tem efeito especial se a imagem já estiver no frame buffer.

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

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¶

Converte uma imagem em uma Imagem de Evento Claro RGB565 (16 bits por pixel).

roi é a tupla de retângulo de região de interesse (x, y, w, h) da imagem de origem a ser desenhada. Isso permite extrair apenas os pixels na ROI para escalar e desenhar na imagem de destino.

hint é um OR lógico das flags listadas em Flags de dica (excluindo image.BLACK_BACKGROUND, que não é suportada aqui).

transform é um ndarray 3x3 usado para realizar uma transformação de perspectiva na imagem. Atualmente suportado apenas na OpenMV Cam N6, pois ela tem uma GPU que pode fazer isso em hardware.

copy se True cria uma cópia profunda no heap da imagem que foi convertida, em vez de converter a imagem original no local.

copy_to_fb se True a imagem é carregada diretamente no frame buffer. copy_to_fb tem prioridade sobre copy. Isso não tem efeito especial se a imagem já estiver no frame buffer.

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

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¶

Converte uma imagem em uma imagem JPEG.

roi é a tupla de retângulo de região de interesse (x, y, w, h) da imagem de origem a ser desenhada. Isso permite extrair apenas os pixels na ROI para escalar e desenhar na imagem de destino.

hint é um OR lógico das flags listadas em Flags de dica (excluindo image.BLACK_BACKGROUND, que não é suportada aqui).

transform é um ndarray 3x3 usado para realizar uma transformação de perspectiva na imagem. Atualmente suportado apenas na OpenMV Cam N6, pois ela tem uma GPU que pode fazer isso em hardware.

copy se True cria uma cópia profunda no heap da imagem que foi convertida, em vez de converter a imagem original no local.

copy_to_fb se True a imagem é carregada diretamente no frame buffer. copy_to_fb tem prioridade sobre copy. Isso não tem efeito especial se a imagem já estiver no frame buffer.

quality controla a qualidade de compressão da imagem jpeg. O valor pode estar entre 0 e 100.

subsampling pode ser:

image.JPEG_SUBSAMPLING_AUTO: Usa a melhor subamostragem para a imagem com base na qualidade.

image.JPEG_SUBSAMPLING_444: Usa subamostragem 4:4:4.

image.JPEG_SUBSAMPLING_422: Usa subamostragem 4:2:2.

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

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

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¶

Converte uma imagem em uma imagem PNG.

roi é a tupla de retângulo de região de interesse (x, y, w, h) da imagem de origem a ser desenhada. Isso permite extrair apenas os pixels na ROI para escalar e desenhar na imagem de destino.

hint é um OR lógico das flags listadas em Flags de dica (excluindo image.BLACK_BACKGROUND, que não é suportada aqui).

transform é um ndarray 3x3 usado para realizar uma transformação de perspectiva na imagem. Atualmente suportado apenas na OpenMV Cam N6, pois ela tem uma GPU que pode fazer isso em hardware.

copy se True cria uma cópia profunda no heap da imagem que foi convertida, em vez de converter a imagem original no local.

copy_to_fb se True a imagem é carregada diretamente no frame buffer. copy_to_fb tem prioridade sobre copy. Isso não tem efeito especial se a imagem já estiver no frame buffer.

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

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¶

Converte uma imagem em uma imagem JPEG.

roi é a tupla de retângulo de região de interesse (x, y, w, h) da imagem de origem a ser desenhada. Isso permite extrair apenas os pixels na ROI para escalar e desenhar na imagem de destino.

hint é um OR lógico das flags listadas em Flags de dica (excluindo image.BLACK_BACKGROUND, que não é suportada aqui).

transform é um ndarray 3x3 usado para realizar uma transformação de perspectiva na imagem. Atualmente suportado apenas na OpenMV Cam N6, pois ela tem uma GPU que pode fazer isso em hardware.

copy se True cria uma cópia profunda no heap da imagem que foi convertida, em vez de converter a imagem original no local.

copy_to_fb se True a imagem é carregada diretamente no frame buffer. copy_to_fb tem prioridade sobre copy. Isso não tem efeito especial se a imagem já estiver no frame buffer.

quality controla a qualidade de compressão da imagem jpeg. O valor pode estar entre 0 e 100.

subsampling pode ser:

image.JPEG_SUBSAMPLING_AUTO: Usa a melhor subamostragem para a imagem com base na qualidade.

image.JPEG_SUBSAMPLING_444: Usa subamostragem 4:4:4.

image.JPEG_SUBSAMPLING_422: Usa subamostragem 4:2:2.

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

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

Nota

Image.compress é um alias para 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¶

Cria uma cópia profunda do objeto de imagem.

roi é a tupla de retângulo de região de interesse (x, y, w, h) da imagem de origem a ser desenhada. Isso permite extrair apenas os pixels na ROI para escalar e desenhar na imagem de destino.

hint é um OR lógico das flags listadas em Flags de dica (excluindo image.BLACK_BACKGROUND, que não é suportada aqui).

transform é um ndarray 3x3 usado para realizar uma transformação de perspectiva na imagem. Atualmente suportado apenas na OpenMV Cam N6, pois ela tem uma GPU que pode fazer isso em hardware.

copy_to_fb se True a imagem é carregada diretamente no frame buffer. Isso não tem efeito especial se a imagem já estiver no frame buffer.

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

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 uma imagem no local sem alterar o tipo subjacente da imagem.

roi é a tupla de retângulo de região de interesse (x, y, w, h) da imagem de origem a ser desenhada. Isso permite extrair apenas os pixels na ROI para escalar e desenhar na imagem de destino.

hint é um OR lógico das flags listadas em Flags de dica (excluindo image.BLACK_BACKGROUND, que não é suportada aqui).

transform é um ndarray 3x3 usado para realizar uma transformação de perspectiva na imagem. Atualmente suportado apenas na OpenMV Cam N6, pois ela tem uma GPU que pode fazer isso em hardware.

copy se True cria uma cópia profunda no heap da imagem que foi convertida, em vez de converter a imagem original no local.

copy_to_fb se True a imagem é carregada diretamente no frame buffer. copy_to_fb tem prioridade sobre copy. Isso não tem efeito especial se a imagem já estiver no frame buffer.

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

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 uma imagem no local sem alterar o tipo subjacente da imagem.

roi é a tupla de retângulo de região de interesse (x, y, w, h) da imagem de origem a ser desenhada. Isso permite extrair apenas os pixels na ROI para escalar e desenhar na imagem de destino.

hint é um OR lógico das flags listadas em Flags de dica (excluindo image.BLACK_BACKGROUND, que não é suportada aqui).

transform é um ndarray 3x3 usado para realizar uma transformação de perspectiva na imagem. Atualmente suportado apenas na OpenMV Cam N6, pois ela tem uma GPU que pode fazer isso em hardware.

copy se True cria uma cópia profunda no heap da imagem que foi convertida, em vez de converter a imagem original no local.

copy_to_fb se True a imagem é carregada diretamente no frame buffer. copy_to_fb tem prioridade sobre copy. Isso não tem efeito especial se a imagem já estiver no frame buffer.

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

Nota

Image.scale é um alias para Image.crop.

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

Salva uma cópia da imagem no sistema de arquivos no caminho path.

Suporta arquivos de imagem bmp/pgm/ppm/jpg/jpeg. Observe que você não pode salvar imagens comprimidas em jpeg em um formato não comprimido.

roi é o retângulo de região de interesse (x, y, w, h) a partir do qual salvar. Se não especificado, é igual ao retângulo da imagem, o que copia a imagem inteira. Este argumento não é aplicável a imagens JPEG.

quality é a qualidade de compressão jpeg a ser usada para salvar a imagem no formato jpeg se a imagem ainda não estiver comprimida (0-100) (int).

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

flush() → None¶: Atualiza o frame buffer no IDE com a imagem no frame buffer da câmera.

Métodos de desenho¶

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

Define todos os pixels da imagem como zero (muito rápido).

mask é outra imagem a ser usada como máscara em nível de pixel para a operação. A máscara deve ser uma imagem com apenas pixels pretos ou brancos e deve ter o mesmo tamanho da imagem sendo operada. Apenas os pixels definidos na máscara são modificados.

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

Não suportado em imagens comprimidas.

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

Desenha uma linha de (x0, y0) a (x1, y1) na imagem. Você pode passar x0, y0, x1, y1 separadamente ou como uma tupla (x0, y0, x1, y1).

color é uma tupla RGB888 para imagens em escala de cinza ou RGB565. O padrão é branco. No entanto, você também pode passar o valor de pixel subjacente (0-255) para imagens em escala de cinza ou um valor RGB565 para imagens RGB565.

thickness controla a espessura da linha em pixels.

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

Não suportado em imagens comprimidas ou imagens 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¶

Desenha um retângulo na imagem. Você pode passar x, y, w, h separadamente ou como uma tupla (x, y, w, h).

thickness controla a espessura das linhas em pixels.

Passe fill como True para preencher o retângulo.

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

Não suportado em imagens comprimidas ou imagens bayer.

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

Desenha um círculo na imagem. Você pode passar x, y, radius separadamente ou como uma tupla (x, y, radius).

thickness controla a espessura das bordas em pixels.

Passe fill como True para preencher o círculo.

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

Não suportado em imagens comprimidas ou imagens 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¶

Desenha uma elipse na imagem. Você pode passar cx, cy, rx, ry e a rotação (em graus) separadamente ou como uma tupla (cx, yc, rx, ry, rotation).

thickness controla a espessura das bordas em pixels.

Passe fill como True para preencher a elipse.

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

Não suportado em imagens comprimidas ou imagens 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¶

Desenha texto 8x10 começando na localização (x, y) na imagem. Você pode passar x, y separadamente ou como uma tupla (x, y).

text é uma string a ser escrita na imagem. Os finais de linha \n, \r e \r\n movem o cursor para a próxima linha.

scale pode ser aumentado para aumentar/diminuir o tamanho do texto na imagem. Você pode passar valores inteiros ou de ponto flutuante maiores que 0.

x_spacing permite adicionar (se positivo) ou subtrair (se negativo) x pixels entre os caracteres.

y_spacing permite adicionar (se positivo) ou subtrair (se negativo) y pixels entre os caracteres (para texto de várias linhas).

mono_space por padrão é True, o que força o texto a ter espaçamento fixo. Para escalas grandes de texto isso fica terrível. Defina como False para obter espaçamento de caracteres de largura não fixa, que fica MUITO melhor.

char_rotation pode ser 0, 90, 180, 270 para rotacionar cada caractere da string nessa quantidade.

char_hmirror se True espelha horizontalmente todos os caracteres da string.

char_vflip se True inverte verticalmente todos os caracteres da string.

string_rotation pode ser 0, 90, 180, 270 para rotacionar a string nessa quantidade.

string_hmirror se True espelha horizontalmente a string.

string_vflip se True inverte verticalmente a string.

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

Não suportado em imagens comprimidas ou imagens bayer.

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

Desenha uma cruz na localização x, y. Você pode passar x, y separadamente ou como uma tupla (x, y).

size controla o comprimento das linhas da cruz.

thickness controla a espessura das bordas em pixels.

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

Não suportado em imagens comprimidas ou imagens bayer.

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

Desenha uma seta de (x0, y0) a (x1, y1) na imagem. Você pode passar x0, y0, x1, y1 separadamente ou como uma tupla (x0, y0, x1, y1).

thickness controla a espessura da linha em pixels.

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

Não suportado em imagens comprimidas ou imagens 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¶

Desenha um resultado de detecção na imagem. detection é uma tupla de 6 valores (rx, ry, rw, rh, cx, cy) que descreve um retângulo delimitador e um centroide (normalmente retornada por código de rede neural ou de rastreamento de cores).

color1 é a cor do retângulo e color2 é a cor da cruz do centroide. size é o tamanho da cruz do centroide, thickness controla a largura do contorno e fill preenche o retângulo.

label se fornecido é desenhado próximo ao retângulo, deslocado por label_offset (x, y).

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

Não suportado em imagens comprimidas ou imagens 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¶

Desenha as bordas das linhas entre uma lista de cantos retornada por métodos como blob.corners. Corners é uma tupla de quatro valores formada por tuplas x/y de dois valores. Por exemplo, [(x1,y1),(x2,y2),(x3,y3),(x4,y4)].

size se for maior que 0 faz com que os cantos sejam desenhados como círculos de raio size.

thickness controla a espessura da linha em pixels.

Passe fill como True para preencher os círculos dos cantos, se desenhados.

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

Não suportado em imagens comprimidas ou imagens 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¶

Desenha uma image cujo canto superior esquerdo começa na localização x, y. Você pode passar x, y separadamente ou como uma tupla (x, y). Este método lida automaticamente com a renderização da imagem passada no formato de pixel correto para a imagem de destino, ao mesmo tempo que trata o recorte de forma transparente.

Você também pode passar um caminho em vez de um objeto de imagem para que este método carregue automaticamente a imagem do disco e a use em uma única etapa. Por exemplo, draw_image("test.jpg").

roi é a tupla de retângulo de região de interesse (x, y, w, h) da imagem de origem a ser desenhada. Isso permite extrair apenas os pixels na ROI para escalar e desenhar na imagem de destino.

hint é um OR lógico das flags listadas em Flags de dica (incluindo image.BLACK_BACKGROUND, que é suportada aqui).

transform é um ndarray 3x3 usado para realizar uma transformação de perspectiva na imagem. Atualmente suportado apenas na OpenMV Cam N6, pois ela tem uma GPU que pode fazer isso em hardware.

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

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¶

Desenha os pontos-chave de um objeto de pontos-chave na imagem. Você também pode passar uma lista de tuplas de três valores contendo (x, y, ângulo_de_rotação_em_graus) para reutilizar este método para desenhar glifos de ponto-chave, que são um círculo com uma linha apontando em uma direção específica.

size controla o tamanho dos pontos-chave.

thickness controla a espessura da linha em pixels.

Passe fill como True para preencher os pontos-chave.

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

Não suportado em imagens comprimidas ou imagens 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¶

Preenche por inundação (flood fill) uma região da imagem a partir da localização x, y. Você pode passar x, y separadamente ou como uma tupla (x, y).

seed_threshold controla o quanto qualquer pixel na área de preenchimento pode diferir do pixel inicial original.

floating_threshold controla o quanto qualquer pixel na área de preenchimento pode diferir de qualquer pixel vizinho.

Passe invert como True para recolorir tudo fora da área conectada do flood-fill.

Passe clear_background como True para zerar o restante dos pixels que o flood-fill não recoloriu.

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

Não suportado em imagens comprimidas ou imagens bayer.

Este método não está disponível na OpenMV Cam M4.

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

Rasteriza um ndarray de eventos (conforme preenchido por csi.IOCTL_GENX320_READ_EVENTS) em uma Image para visualização. O buffer da imagem deve ser uma imagem GRAYSCALE de 320x320.

Para cada linha csi.PIX_ON_EVENT, o pixel do evento recebe +contrast adicionado; para cada linha csi.PIX_OFF_EVENT, o pixel recebe -contrast. Eventos de gatilho são ignorados. Os valores de pixel são limitados a 0-255.

clear se True redefine o buffer da imagem para brightness antes de desenhar — cada quadro se torna uma renderização nova apenas de eventos. Defina como False para acumular eventos ao longo de várias chamadas (útil para rastros de movimento de longa exposição).

brightness controla a linha de base cinza-médio para a qual o buffer é redefinido quando clear é True. O padrão 128 coloca os eventos ON na extremidade clara e os eventos OFF na extremidade escura com margem igual.

contrast controla o quanto cada evento desloca seu pixel — valores mais altos fazem os eventos se destacarem, ao custo de saturar rapidamente quando muitos eventos caem no mesmo pixel.

Métodos de mascaramento¶

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

Zera uma parte retangular da imagem. Se nenhum argumento for fornecido, este método zera o centro da imagem.

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

Não suportado em imagens comprimidas ou imagens bayer.

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

Zera uma parte circular da imagem. Se nenhum argumento for fornecido, este método zera o centro da imagem.

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

Não suportado em imagens comprimidas ou imagens bayer.

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

Zera uma parte em forma de elipse da imagem. Se nenhum argumento for fornecido, este método zera o centro da imagem.

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

Não suportado em imagens comprimidas ou imagens bayer.

Métodos binários¶

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

Define todos os pixels da imagem como preto ou branco dependendo de cada pixel estar dentro de uma das tuplas de limiar em thresholds.

thresholds é uma lista de tuplas (lo, hi) para imagens em escala de cinza, ou tuplas (l_lo, l_hi, a_lo, a_hi, b_lo, b_hi) para imagens RGB565. Valores min/max trocados são corrigidos automaticamente; componentes ausentes assumem o padrão de faixa máxima.

invert inverte a correspondência do limiar.

zero se True, zera os pixels limiarizados e deixa os demais intactos.

mask é uma imagem binária usada como máscara em nível de pixel; apenas os pixels definidos na máscara são modificados.

to_bitmap se True, converte os dados da imagem em um bitmap de 1 bit por pixel. Para imagens muito pequenas isso pode exigir copy=True.

copy se True, retorna uma nova imagem no heap em vez de modificar a imagem de origem.

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

Não suportado em imagens comprimidas ou imagens bayer.

invert() → Image¶

Inverte todos os valores de pixel da imagem (cada pixel se torna 255 - pixel para canais de 8 bits).

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

Não suportado em imagens comprimidas ou imagens bayer/yuv.

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

Faz o AND lógico desta imagem com outra imagem.

image pode ser um objeto de imagem, um caminho para um arquivo de imagem não comprimido (bmp/pgm/ppm) ou um valor escalar (tupla RGB888 ou valor de pixel subjacente).

mask é uma imagem binária usada como máscara em nível de pixel; apenas os pixels definidos na máscara são modificados.

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

Não suportado em imagens comprimidas ou imagens bayer.

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

Faz o NAND lógico desta imagem com outra imagem.

image pode ser um objeto de imagem, um caminho para um arquivo de imagem não comprimido (bmp/pgm/ppm) ou um valor escalar (tupla RGB888 ou valor de pixel subjacente).

mask é uma imagem binária usada como máscara em nível de pixel; apenas os pixels definidos na máscara são modificados.

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

Não suportado em imagens comprimidas ou imagens bayer.

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

Faz o OR lógico desta imagem com outra imagem.

image pode ser um objeto de imagem, um caminho para um arquivo de imagem não comprimido (bmp/pgm/ppm) ou um valor escalar (tupla RGB888 ou valor de pixel subjacente).

mask é uma imagem binária usada como máscara em nível de pixel; apenas os pixels definidos na máscara são modificados.

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

Não suportado em imagens comprimidas ou imagens bayer.

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

Faz o NOR lógico desta imagem com outra imagem.

image pode ser um objeto de imagem, um caminho para um arquivo de imagem não comprimido (bmp/pgm/ppm) ou um valor escalar (tupla RGB888 ou valor de pixel subjacente).

mask é uma imagem binária usada como máscara em nível de pixel; apenas os pixels definidos na máscara são modificados.

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

Não suportado em imagens comprimidas ou imagens bayer.

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

Faz o XOR lógico desta imagem com outra imagem.

image pode ser um objeto de imagem, um caminho para um arquivo de imagem não comprimido (bmp/pgm/ppm) ou um valor escalar (tupla RGB888 ou valor de pixel subjacente).

mask é uma imagem binária usada como máscara em nível de pixel; apenas os pixels definidos na máscara são modificados.

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

Não suportado em imagens comprimidas ou imagens bayer.

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

Faz o XNOR lógico desta imagem com outra imagem.

image pode ser um objeto de imagem, um caminho para um arquivo de imagem não comprimido (bmp/pgm/ppm) ou um valor escalar (tupla RGB888 ou valor de pixel subjacente).

mask é uma imagem binária usada como máscara em nível de pixel; apenas os pixels definidos na máscara são modificados.

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

Não suportado em imagens comprimidas ou imagens bayer.

Métodos de ISP¶

awb(max: bool = False) → Image¶

Realiza o balanço de branco automático na imagem usando o algoritmo gray-world. Opera em imagens RAW Bayer ou RGB565. Não tem efeito em imagens binárias/em escala de cinza.

max se True, usa o algoritmo white-patch em vez disso.

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

Não suportado em imagens comprimidas ou yuv.

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

Multiplica a matriz de correção de cor de ponto flutuante passada com a imagem. As matrizes podem ser 3x3 ou 3x4 (com coluna de deslocamento), em forma de lista aninhada ou de 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]

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

Não suportado em imagens comprimidas ou imagens bayer/yuv.

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

Ajusta o gama, o contraste e o brilho da imagem.

gamma aplica pow(pixel, 1/gamma) após a normalização. Valores maiores que 1.0 clareiam; menores que 1.0 escurecem.

contrast aplica pixel * contrast após a normalização.

brightness aplica pixel + brightness após a normalização.

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

Não suportado em imagens comprimidas ou bayer/yuv.

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

Métodos matemáticos¶

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

replace(image: Image | None = None, **kwargs) → Image¶: Alias para Image.draw_image(). Substitui esta imagem por image (ou transforma esta imagem no local se image for omitido) usando os argumentos nomeados padrão de draw_image. O argumento transform é um ndarray 3x3 que descreve uma transformação de perspectiva (suportado apenas em câmeras OpenMV com ULAB habilitado).

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

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

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

Adiciona uma imagem a esta, pixel por pixel.

image pode ser um objeto de imagem, um caminho para um arquivo de imagem não comprimido (bmp/pgm/ppm) ou um valor escalar (tupla RGB888 ou valor de pixel subjacente).

mask é uma imagem binária usada como máscara em nível de pixel; apenas os pixels definidos na máscara são modificados.

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

Não suportado em imagens comprimidas ou imagens bayer.

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

Subtrai image desta imagem, pixel por pixel (self - image).

image pode ser um objeto de imagem, um caminho para um arquivo de imagem não comprimido (bmp/pgm/ppm) ou um valor escalar (tupla RGB888 ou valor de pixel subjacente).

mask é uma imagem binária usada como máscara em nível de pixel; apenas os pixels definidos na máscara são modificados.

Este método também aceita o conjunto completo de argumentos nomeados de Image.draw_image() (x, y, x_scale, y_scale, roi, rgb_channel, alpha, color_palette, alpha_palette, hint, transform).

Não suportado em imagens comprimidas ou imagens bayer.

rsub(image: Image, mask: Image | None = None) → Image¶: Subtração reversa: substitui esta imagem por image - self, pixel por pixel. Caso contrário, idêntico a Image.sub().

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

Retorna a imagem mínima de duas imagens, pixel por pixel.

image pode ser um objeto de imagem, um caminho para um arquivo de imagem não comprimido (bmp/pgm/ppm) ou um valor escalar (tupla RGB888 ou valor de pixel subjacente).

mask é uma imagem binária usada como máscara em nível de pixel; apenas os pixels definidos na máscara são modificados.

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

Não suportado em imagens comprimidas ou imagens bayer.

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

Retorna a imagem máxima de duas imagens, pixel por pixel.

image pode ser um objeto de imagem, um caminho para um arquivo de imagem não comprimido (bmp/pgm/ppm) ou um valor escalar (tupla RGB888 ou valor de pixel subjacente).

mask é uma imagem binária usada como máscara em nível de pixel; apenas os pixels definidos na máscara são modificados.

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

Não suportado em imagens comprimidas ou imagens bayer.

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

Retorna a imagem da diferença absoluta entre duas imagens (por exemplo, ||a-b||).

image pode ser um objeto de imagem, um caminho para um arquivo de imagem não comprimido (bmp/pgm/ppm) ou um valor escalar (tupla RGB888 ou valor de pixel subjacente).

mask é uma imagem binária usada como máscara em nível de pixel; apenas os pixels definidos na máscara são modificados.

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

Não suportado em imagens comprimidas ou imagens bayer.

blend(image: Image, x: int = 0, y: int = 0, alpha: int = 128, mask: Image | None = None, **kwargs) → Image¶: Alias para Image.draw_image(). Faz a mesclagem alfa de image nesta imagem. alpha é um inteiro de 0 a 256; valores mais próximos de 256 favorecem a imagem de origem. Aceita todos os argumentos nomeados de Image.draw_image().

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

Executa a equalização de histograma na imagem para normalizar o contraste e o brilho.

adaptive se True, executa a equalização de histograma adaptativa (mais lenta, mas geralmente melhor).

clip_limit limita o contraste na variante adaptativa (um valor pequeno como 10 produz bons resultados de CLAHE).

mask é uma imagem binária usada como máscara em nível de pixel; apenas os pixels definidos na máscara são modificados.

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

Não suportado em imagens comprimidas ou imagens bayer.

Métodos de filtragem¶

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

Remove pixels das bordas de áreas segmentadas. Convoluciona um kernel ((size*2)+1)x((size*2)+1) pela imagem, limpando o pixel central se mais de threshold vizinhos estiverem limpos (atua como erosão padrão se threshold for None).

mask é uma imagem binária usada como máscara em nível de pixel; apenas os pixels definidos na máscara são modificados.

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

Não suportado em imagens comprimidas ou imagens bayer/yuv.

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

Adiciona pixels às bordas de áreas segmentadas. Convoluciona um kernel ((size*2)+1)x((size*2)+1) pela imagem, definindo o pixel central se mais de threshold vizinhos estiverem definidos (atua como dilatação padrão se threshold for None).

mask é uma imagem binária usada como máscara em nível de pixel; apenas os pixels definidos na máscara são modificados.

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

Não suportado em imagens comprimidas ou imagens bayer/yuv.

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

Realiza erosão e depois dilatação. Veja Image.erode() e Image.dilate().

mask é uma imagem binária usada como máscara em nível de pixel; apenas os pixels definidos na máscara são modificados.

Não suportado em imagens comprimidas ou imagens bayer/yuv.

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

Realiza dilatação e depois erosão. Veja Image.dilate() e Image.erode().

mask é uma imagem binária usada como máscara em nível de pixel; apenas os pixels definidos na máscara são modificados.

Não suportado em imagens comprimidas ou imagens bayer/yuv.

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

Retorna a diferença de imagem entre a imagem e a imagem processada com Image.open().

mask é uma imagem binária usada como máscara em nível de pixel; apenas os pixels definidos na máscara são modificados.

Não suportado em imagens comprimidas ou imagens bayer/yuv.

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

Retorna a diferença de imagem entre a imagem e a imagem processada com Image.close().

mask é uma imagem binária usada como máscara em nível de pixel; apenas os pixels definidos na máscara são modificados.

Não suportado em imagens comprimidas ou imagens bayer/yuv.

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

Filtro padrão de desfoque por média usando um filtro de caixa.

size é o tamanho do kernel. Use 1 (kernel 3x3), 2 (kernel 5x5), etc.

threshold se True, limiariza adaptativamente a saída do filtro em uma imagem binária. offset desloca a binarização (negativo torna mais pixels brancos, positivo torna menos). invert inverte a saída binária.

mask é uma imagem binária usada como máscara em nível de pixel; apenas os pixels definidos na máscara são modificados.

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

Não suportado em imagens comprimidas ou imagens bayer/yuv.

Executa um filtro de percentil na imagem (mediana por padrão).

size é o tamanho do kernel. Use 1 (kernel 3x3), 2 (kernel 5x5), etc.

percentile é o percentil a selecionar de cada kernel (0 = mín, 0.5 = mediana, 1.0 = máx). O padrão é 0.5.

mask é uma imagem binária usada como máscara em nível de pixel; apenas os pixels definidos na máscara são modificados.

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

Não suportado em imagens comprimidas ou imagens bayer/yuv.

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

Substitui cada pixel pela moda de seus vizinhos. Pode produzir artefatos nas bordas de imagens RGB devido à operação não linear.

size é o tamanho do kernel. Use 1 (kernel 3x3), 2 (kernel 5x5), etc.

mask é uma imagem binária usada como máscara em nível de pixel; apenas os pixels definidos na máscara são modificados.

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

Não suportado em imagens comprimidas ou imagens bayer/yuv.

Executa o filtro de ponto médio na imagem. Este filtro encontra o ponto médio ((max-min)/2) de cada vizinhança de pixels na imagem.

size é o tamanho do kernel. Use 1 (kernel 3x3), 2 (kernel 5x5), etc.

bias controla a mistura mín/máx. 0 para filtragem apenas por mínimo, 1.0 para filtragem apenas por máximo. Usando o bias você pode filtrar a imagem por mín/máx.

mask é uma imagem binária usada como máscara em nível de pixel; apenas os pixels definidos na máscara são modificados.

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

Não suportado em imagens comprimidas ou imagens bayer/yuv.

Convoluciona a imagem com um kernel de filtro arbitrário.

size controla o tamanho do kernel, que deve ter ((size*2)+1)x((size*2)+1) elementos.

kernel é o kernel com o qual convolucionar, como uma lista/tupla 1D plana de ((size*2)+1)*((size*2)+1) elementos, ou como uma lista/tupla 2D com ((size*2)+1) linhas de ((size*2)+1) elementos.

mul é uma escala de contraste multiplicativa (padrão 1.0).

add é um deslocamento de brilho aditivo (padrão 0.0).

mask é uma imagem binária usada como máscara em nível de pixel; apenas os pixels definidos na máscara são modificados.

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

Não suportado em imagens comprimidas ou imagens bayer/yuv.

Convoluciona a imagem com um kernel gaussiano de suavização.

size é o tamanho do kernel. Use 1 (kernel 3x3), 2 (kernel 5x5), etc.

unsharp se True, realiza uma operação de máscara de nitidez (sharpens edges) em vez de uma gaussiana simples.

mul é uma escala de contraste multiplicativa (padrão 1.0).

add é um deslocamento de brilho aditivo (padrão 0.0).

mask é uma imagem binária usada como máscara em nível de pixel; apenas os pixels definidos na máscara são modificados.

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

Não suportado em imagens comprimidas ou imagens 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 a imagem com um kernel laplaciano de detecção de bordas.

size é o tamanho do kernel. Use 1 (kernel 3x3), 2 (kernel 5x5), etc.

sharpen se True, aumenta a nitidez da imagem em vez de gerar a resposta bruta de bordas não limiarizada.

mul é uma escala de contraste multiplicativa (padrão 1.0).

add é um deslocamento de brilho aditivo (padrão 0.0).

threshold se True, limiariza adaptativamente a saída do filtro em uma imagem binária. offset desloca a binarização (negativo torna mais pixels brancos, positivo torna menos). invert inverte a saída binária.

mask é uma imagem binária usada como máscara em nível de pixel; apenas os pixels definidos na máscara são modificados.

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

Não suportado em imagens comprimidas ou imagens bayer/yuv.

Convoluciona a imagem com um filtro bilateral (suavização preservadora de bordas).

size é o tamanho do kernel. Use 1 (kernel 3x3), 2 (kernel 5x5), etc.

color_sigma controla a tolerância de correspondência de cor; valores maiores produzem mais desfoque de cor.

space_sigma controla o desfoque espacial; valores maiores produzem mais desfoque de pixels.

mask é uma imagem binária usada como máscara em nível de pixel; apenas os pixels definidos na máscara são modificados.

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

Não suportado em imagens comprimidas ou imagens bayer/yuv.

Métodos geométricos¶

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

Reprojeta uma imagem de coordenadas cartesianas para coordenadas polares lineares.

Defina reverse=True para reprojetar na direção oposta.

x e y especificam a coordenada central da transformação em pixels da imagem. Se x for None (o padrão), ele é definido como metade da largura da imagem; da mesma forma, y por padrão é metade da altura da imagem.

A reprojeção polar linear transforma a rotação de uma imagem em translação x.

Não suportado em imagens comprimidas ou imagens bayer.

Este método não está disponível na OpenMV Cam M4.

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

Reprojeta uma imagem de coordenadas cartesianas para coordenadas log-polares.

Defina reverse=True para reprojetar na direção oposta.

A reprojeção log-polar transforma a rotação de uma imagem em translação x e a escala/zoom em translação y.

Não suportado em imagens comprimidas ou imagens bayer.

Este método não está disponível na 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 a correção de lente para remover o efeito olho-de-peixe da imagem devido à distorção da lente.

strength é um float que define o quanto remover o efeito olho-de-peixe da imagem. Experimente 1.8 por padrão e depois aumente ou diminua a partir daí até a imagem ficar boa.

zoom é a quantidade de zoom a aplicar na imagem. 1.0 por padrão.

x_corr deslocamento de pixel de ponto flutuante a partir do centro. Pode ser negativo ou positivo.

y_corr deslocamento de pixel de ponto flutuante a partir do centro. Pode ser negativo ou positivo.

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

Não suportado em imagens comprimidas ou imagens 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 na imagem fazendo uma rotação 3D do frame buffer.

x_rotation é o número de graus para rotacionar a imagem no frame buffer em torno do eixo x (ou seja, isso gira a imagem para cima e para baixo).

y_rotation é o número de graus para rotacionar a imagem no frame buffer em torno do eixo y (ou seja, isso gira a imagem para a esquerda e para a direita).

z_rotation é o número de graus para rotacionar a imagem no frame buffer em torno do eixo z (ou seja, isso gira a imagem no lugar).

x_translation é o número de unidades para mover a imagem para a esquerda ou direita após a rotação. Como esta translação é aplicada no espaço 3D, as unidades não são pixels…

y_translation é o número de unidades para mover a imagem para cima ou para baixo após a rotação. Como esta translação é aplicada no espaço 3D, as unidades não são pixels…

zoom é a quantidade de zoom a aplicar na imagem. 1.0 por padrão.

fov é o campo de visão usado para a projeção interna 2D->3D. À medida que fov se aproxima de 0, a imagem é colocada no infinito; à medida que se aproxima de 180, a imagem é colocada dentro da viewport.

corners é uma lista de quatro tuplas (x, y) usada para construir uma homografia de 4 pontos que mapeia os cantos para (0, 0), (image_width-1, 0), (image_width-1, image_height-1) e (0, image_height-1) antes de aplicar a rotação 3D. Útil para transformações de vista aérea (birds-eye-view).

Retorna o objeto de imagem para que você possa chamar outro método usando a notação ..

Não suportado em imagens comprimidas ou imagens bayer.

Este método não está disponível na OpenMV Cam M4.

Métodos de obtenção (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¶

Calcula a similaridade entre duas imagens usando o Índice de Similaridade Estrutural (SSIM). O SSIM varia de -1 (oposto) a 1 (idêntico). Retorna um objeto image.similarity.

image é a imagem a comparar (um objeto de imagem ou uma string de caminho, por exemplo, "test.jpg").

x, y, x_scale, y_scale, roi, rgb_channel, alpha, color_palette, alpha_palette, hint e transform aceitam os mesmos valores que Image.draw_image().

dssim se True, retorna o Índice de Dissimilaridade Estrutural (DSSIM) em vez disso, onde 0 significa idêntico e 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 o histograma normalizado em todos os canais de cor para uma roi e retorna um objeto image.histogram. Também disponível como Image.get_hist() ou Image.histogram().

thresholds é uma lista de tuplas (lo, hi) para imagens em escala de cinza, ou tuplas (l_lo, l_hi, a_lo, a_hi, b_lo, b_hi) para imagens RGB565. Se passado, o histograma é calculado apenas sobre os pixels dentro dos limiares.

invert inverte a correspondência do limiar.

roi é a tupla de retângulo de região de interesse (x, y, w, h). O padrão é o retângulo da imagem.

bins (escala de cinza) ou l_bins/a_bins/b_bins (RGB565) definem o número de bins do histograma por canal. Deve ser maior que 2. O padrão é o número máximo de bins por canal.

difference pode ser definido como um objeto de imagem para operar sobre a diferença entre a imagem atual e essa imagem sem um buffer extra.

Não suportado em imagens comprimidas ou imagens 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 a média, a mediana, a moda, o desvio padrão, o mínimo, o máximo, o quartil inferior e o quartil superior para todos os canais de cor de uma roi e retorna um objeto image.statistics. Também disponível como Image.get_stats() ou Image.statistics().

thresholds é uma lista de tuplas (lo, hi) para imagens em escala de cinza, ou tuplas (l_lo, l_hi, a_lo, a_hi, b_lo, b_hi) para imagens RGB565. Se passado, as estatísticas são calculadas apenas sobre os pixels dentro dos limiares.

invert inverte a correspondência do limiar.

roi é a tupla de retângulo de região de interesse (x, y, w, h). O padrão é o retângulo da imagem.

bins (escala de cinza) ou l_bins/a_bins/b_bins (RGB565) definem o número de bins do histograma por canal. Deve ser maior que 2. O padrão é o número máximo de bins por canal.

difference pode ser definido como um objeto de imagem para operar sobre a diferença entre a imagem atual e essa imagem sem um buffer extra.

Não suportado em imagens comprimidas ou imagens 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 uma regressão linear (Theil-Sen) sobre todos os pixels limiarizados na imagem. Retorna um objeto image.line, ou None se nenhuma linha for encontrada.

thresholds é uma lista de tuplas (lo, hi) para imagens em escala de cinza, ou tuplas (l_lo, l_hi, a_lo, a_hi, b_lo, b_hi) para imagens RGB565.

invert inverte a correspondência do limiar.

roi é a tupla de retângulo de região de interesse (x, y, w, h). O padrão é o retângulo da imagem.

x_stride e y_stride controlam quantos pixels são pulados durante a avaliação da imagem.

area_threshold área mínima da caixa delimitadora; resultados menores retornam None.

pixels_threshold contagem mínima de pixels limiarizados; resultados menores retornam None.

target_size é uma tupla (w, h). A ROI é reduzida por escalonamento por área para caber dentro deste tamanho antes de executar o algoritmo O(N^2). O padrão é (80, 60).

Não suportado em imagens comprimidas ou imagens bayer.

Métodos de detecção¶

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

Encontra todos os blobs (regiões de pixels conectados que passam por um teste de limiar) na imagem e retorna uma lista de objetos image.blob.

thresholds é uma lista de tuplas (lo, hi) para imagens em escala de cinza, ou tuplas (l_lo, l_hi, a_lo, a_hi, b_lo, b_hi) para imagens RGB565 (canais LAB). Até 32 tuplas podem ser passadas. Valores min/max trocados são corrigidos automaticamente; componentes ausentes assumem o padrão de faixa máxima.

invert inverte a correspondência do limiar.

roi é a tupla de retângulo de região de interesse (x, y, w, h). O padrão é o retângulo da imagem.

x_stride e y_stride controlam quantos pixels são pulados durante a busca por um blob. Aumente se for sabido que os blobs são grandes.

area_threshold área mínima da caixa delimitadora; blobs menores são filtrados.

pixels_threshold contagem mínima de pixels limiarizados; blobs menores são filtrados.

merge se True mescla blobs cujos retângulos delimitadores se intersectam. margin aumenta/reduz os retângulos delimitadores usados na intersecção. Blobs mesclados fazem o OR de seus vetores de bits code (um bit por limiar).

threshold_cb é chamado por blob após a limiarização; retorne True para manter, False para filtrar.

merge_cb é chamado por par de blobs prestes a serem mesclados; retorne True para permitir a mesclagem, False para impedi-la.

x_hist_bins_max se diferente de zero, preenche cada blob com uma projeção x_histogram usando este número de bins.

y_hist_bins_max se diferente de zero, preenche cada blob com uma projeção y_histogram usando este número de bins.

Não suportado em imagens comprimidas ou imagens 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]¶

Encontra todas as linhas infinitas na imagem usando a transformada de Hough. Retorna uma lista de objetos image.line.

roi é a tupla de retângulo de região de interesse (x, y, w, h). O padrão é o retângulo da imagem.

x_stride e y_stride controlam quantos pixels são pulados durante a transformada de Hough.

threshold magnitude mínima da linha (soma das magnitudes de sobel ao longo da linha); linhas abaixo deste valor são filtradas.

theta_margin e rho_margin controlam a mesclagem: linhas dentro destes limiares são mescladas.

Não suportado em imagens comprimidas ou imagens bayer.

Este método não está disponível na 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]¶

Encontra segmentos de linha na imagem. Retorna uma lista de objetos image.line.

roi é a tupla de retângulo de região de interesse (x, y, w, h). O padrão é o retângulo da imagem.

merge_distance é a separação máxima em pixels entre dois segmentos para que sejam mesclados.

max_theta_difference é a diferença máxima de theta em graus entre os segmentos para que sejam mesclados.

Este método não está disponível na 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]¶

Encontra círculos na imagem usando a transformada de Hough. Retorna uma lista de objetos image.circle.

roi é a tupla de retângulo de região de interesse (x, y, w, h). O padrão é o retângulo da imagem.

x_stride e y_stride controlam quantos pixels são pulados durante a transformada de Hough.

threshold magnitude mínima do círculo (soma das magnitudes de sobel ao longo do círculo); círculos abaixo deste valor são filtrados.

x_margin, y_margin e r_margin controlam a mesclagem: círculos dentro destes limiares são mesclados.

r_min raio mínimo do círculo. O padrão é 2.

r_max raio máximo do círculo. O padrão é min(roi.w/2, roi.h/2).

r_step tamanho do passo do raio. O padrão é 2.

Este método não está disponível na OpenMV Cam M4.

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

Encontra retângulos na imagem usando o algoritmo de detecção de quadriláteros do apriltag. Retorna uma lista de objetos image.rect.

roi é a tupla de retângulo de região de interesse (x, y, w, h). O padrão é o retângulo da imagem.

threshold magnitude mínima de borda (soma das magnitudes de sobel ao longo das bordas do retângulo); retângulos abaixo deste valor são filtrados.

Este método não está disponível na OpenMV Cam M4.

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

Encontra todos os qrcodes dentro da roi e retorna uma lista de objetos image.qrcode.

roi é a tupla de retângulo de região de interesse (x, y, w, h). O padrão é o retângulo da imagem.

Este método não está disponível na OpenMV Cam M4.

Encontra todos os apriltags dentro da roi e retorna uma lista de objetos image.apriltag.

roi é a tupla de retângulo de região de interesse (x, y, w, h). O padrão é o retângulo da imagem.

families é uma máscara de bits de famílias de tags a decodificar. É o OR lógico de:

image.TAG16H5

image.TAG25H9

image.TAG36H10

image.TAG36H11

image.TAGCIRCLE21H7

image.TAGCIRCLE49H12

image.TAGCUSTOM48H12

image.TAGSTANDARD41H12

image.TAGSTANDARD52H13

O padrão é image.TAG36H11. O tempo de detecção escala com o número de famílias habilitadas.

fx e fy são as distâncias focais X e Y da câmera em pixels.

cx e cy são o centro da imagem, normalmente image.width()/2 e image.height()/2.

Não suportado em imagens comprimidas.

Este método não está disponível na OpenMV Cam M4.

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

Encontra todas as datamatrices dentro da roi e retorna uma lista de objetos image.datamatrix.

roi é a tupla de retângulo de região de interesse (x, y, w, h). O padrão é o retângulo da imagem.

effort controla quanto tempo gastar tentando encontrar correspondências de data matrix. Valores mais altos melhoram a detecção ao custo da taxa de quadros. Valores abaixo de ~160 falham na detecção; valores acima de ~240 trazem retornos decrescentes. O padrão é 200.

Este método não está disponível na OpenMV Cam M4.

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

Encontra todos os códigos de barras 1D dentro da roi e retorna uma lista de objetos image.barcode. Faz a varredura tanto horizontalmente quanto verticalmente.

Tipos de código de barras suportados: 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 é a tupla de retângulo de região de interesse (x, y, w, h). O padrão é o retângulo da imagem.

Este método não está disponível na 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¶

Encontra o deslocamento de translação desta imagem em relação a template usando correlação de fase. Retorna um objeto image.displacement.

roi é o retângulo de região de interesse (x, y, w, h). O padrão é o retângulo da imagem.

template_roi é a região de interesse do template. O padrão é o retângulo da imagem do template. roi e template_roi devem ter a mesma largura e altura.

logpolar se True retorna a mudança de rotação/escala em vez da translação x/y.

fix_rotation_scale se True, calcula o deslocamento após alinhar a rotação e a escala (só faz sentido quando logpolar=False).

Nota

Use este método em tamanhos de imagem que sejam potências de 2 (por exemplo, sensor.B64X64).

Não suportado em imagens comprimidas ou imagens bayer. Não disponível na 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¶

Tenta encontrar a primeira localização na imagem onde template corresponde usando Correlação Cruzada Normalizada. Retorna uma tupla de caixa delimitadora (x, y, w, h), ou None.

template é uma imagem em escala de cinza a ser comparada com esta imagem.

threshold é um valor (0.0-1.0). Valores mais altos reduzem os falsos positivos e as detecções; valores mais baixos fazem o oposto.

roi é a tupla de retângulo de região de interesse (x, y, w, h). O padrão é o retângulo da imagem.

step é o número de pixels a pular durante a busca (usado apenas no modo image.SEARCH_EX).

search é image.SEARCH_DS (busca em diamante, mais rápida) ou image.SEARCH_EX (busca exaustiva).

Funciona apenas em imagens em escala de cinza.

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 na imagem áreas que correspondam à cascata de Haar passada e retorna uma lista de tuplas de caixa delimitadora (x, y, w, h). Retorna uma lista vazia se nenhuma característica for encontrada.

cascade é um objeto Haar Cascade (veja image.HaarCascade()).

threshold (0.0-1.0). Valores mais baixos elevam a taxa de detecção e a taxa de falsos positivos.

scale deve ser maior que 1.0. Valores mais altos rodam mais rápido, mas produzem correspondências piores.

roi é a tupla de retângulo de região de interesse (x, y, w, h). O padrão é o retângulo da imagem.

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

Busca pela pupila em uma tupla de região de interesse (x, y, w, h) em torno de um olho. Retorna a localização (x, y) da pupila, ou (0, 0) se nenhuma for encontrada.

roi é a tupla de retângulo de região de interesse (x, y, w, h).

Funciona apenas em imagens em escala de cinza.

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

Extrai pontos-chave LBP (local-binary-patterns) da região de interesse. Use image.match_descriptor() para comparar dois descritores.

roi é a tupla de retângulo de região de interesse (x, y, w, h).

Funciona apenas em imagens em escala de cinza.

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¶

Extrai pontos-chave ORB da região de interesse. Use image.match_descriptor() para comparar dois descritores. Retorna None se nenhum ponto-chave for encontrado.

roi é a tupla de retângulo de região de interesse (x, y, w, h). O padrão é o retângulo da imagem.

threshold (0-255) controla o número de cantos extraídos. Limiares mais baixos produzem mais cantos. Use ~20 para AGAST, ~60-80 para FAST.

normalized se True, desabilita a extração de pontos-chave em múltiplas resoluções.

scale_factor deve ser maior que 1.0. Valores mais altos rodam mais rápido, mas produzem correspondências piores.

max_keypoints é o número máximo de pontos-chave a reter.

corner_detector é image.CORNER_FAST ou image.CORNER_AGAST.

Funciona apenas em imagens em escala de cinza.

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

Transforma a imagem em preto e branco, deixando apenas as bordas como pixels brancos.

image.EDGE_SIMPLE - Algoritmo simples de filtro passa-alta limiarizado.

image.EDGE_CANNY - Algoritmo de detecção de bordas Canny.

threshold é uma tupla de dois valores contendo um limiar baixo e um limiar alto. Você pode controlar a qualidade das bordas ajustando estes valores. O padrão é (100, 200).

Funciona apenas em imagens em escala de cinza.

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

Substitui os pixels na ROI por linhas HOG (histogram of orientated gradients).

roi é a tupla de retângulo de região de interesse (x, y, w, h). Se não especificado, é igual ao retângulo da imagem. Apenas os pixels dentro da roi são operados.

Funciona apenas em imagens em escala de cinza.

Este método não está disponível na OpenMV Cam M4.

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

Recebe uma imagem em escala de cinza com o dobro da largura contendo a saída de dois sensores de câmera lado a lado e substitui uma metade pela imagem de disparidade estéreo (cada pixel representa profundidade). Por exemplo, para duas câmeras de 320x240, passe uma imagem de 640x240.

reversed Por padrão, a imagem da esquerda é comparada com a da direita e a imagem da direita é substituída. Defina como True para comparar direita->esquerda e substituir a imagem da esquerda.

max_disparity é a distância máxima (1-255) a buscar por um bloco de pixels correspondente usando a soma das diferenças absolutas. Valores maiores levam exponencialmente mais tempo, mas produzem saída de maior qualidade.

threshold se a soma das diferenças absolutas entre dois blocos for menor ou igual a este limiar, eles são considerados correspondentes.

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

Executa a busca seletiva na imagem e retorna uma lista de tuplas de caixa delimitadora (x, y, w, h) de propostas de objetos.

threshold é o limiar de segmentação; valores mais altos produzem menos regiões/regiões maiores.

size é o tamanho mínimo de região após a mesclagem.

a1, a2, a3 são os pesos de similaridade de cor/textura/tamanho usados ao mesclar regiões.