classe Image – Objeto Image¶

Image é o tipo de dados 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. Cada fotograma proveniente de csi.CSI.snapshot() é um Image; também o são todos os fotogramas carregados do disco, descodificados de JPEG ou PNG, alocados a partir de um ndarray no estilo numpy, ou construídos como uma tela de desenho vazia.

Um Image é descrito por três números – width, height e pixformat – mais um buffer de pixels contíguo. O formato de pixel determina tanto a disposição em memória como as operações disponíveis:

BINARY (1 bpp) – 1 bit por pixel; utilizado para morfologia e limiarização.
GRAYSCALE (8 bpp) – 1 byte por pixel; o formato canónico para a maioria das técnicas de CV (AprilTag, arestas, ORB, fluxo ótico).
RGB565 (16 bpp) – 2 bytes por pixel (5R/6G/5B); o formato de cor predefinido.
BAYER (8 bpp) – dados brutos de mosaico Bayer diretamente do sensor. A maioria dos métodos de CV não está disponível em imagens Bayer; converta primeiro para GRAYSCALE / RGB565.
YUV422 (16 bpp) – cor com subamostragem de crominância 4:2:2, dois bytes por pixel. Apenas alguns métodos funcionam diretamente em YUV422.
JPEG / PNG – buffers comprimidos. As operações ao nível do pixel requerem primeiro to_grayscale() ou to_rgb565().

Origem dos objetos Image¶

Existem quatro formas de obter um Image:

A partir do buffer de fotograma da câmara – csi.CSI().snapshot() devolve o fotograma capturado seguinte. O objeto devolvido é um invólucro fino em torno da memória do buffer de fotograma da câmara, pelo que qualquer operação de desenho/filtragem sobre ele altera o que é enviado para a pré-visualização do IDE e para o ecrã.
A partir de um ficheiro – passe uma string de caminho ao construtor de Image. BMP, PGM, PPM, JPEG e PNG são descodificados diretamente para RAM (ou para o buffer de fotograma da câmara se copy_to_fb=True).
A partir de um ndarray – passe um array float32 (h, w) ou (h, w, 3). Os pixels são escalados de 0.0 -- 255.0 para GRAYSCALE ou RGB565, respetivamente.
Vazio – passe (width, height, pixformat) para alocar uma superfície de desenho inicializada a zero. Para formatos de pixel comprimidos (JPEG / PNG) é necessário um argumento buffer= que contém o fluxo de bytes comprimido.

Ciclo 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, linha-a-linha). img[i] = value escreve-o. Os pixels em Grayscale / Bayer são inteiros de 8 bits, os pixels RGB565 / YUV422 são inteiros de 16 bits compactados, e os 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) devolve 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 que a indexação com [].
Semelhante a bytes – Image expõe o protocolo de buffer de leitura, pelo que pode ser passado diretamente a qualquer elemento que aceite bytes / bytearray (por exemplo, uart.write(img), socket.send(img), hashlib.sha256(img)). Use bytearray() para obter uma vista de leitura/escrita.

Flags de sugestão¶

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

image.AREA: Utiliza escalonamento por área ao reduzir a escala, em vez do método predefinido de vizinho mais próximo.

image.BILINEAR: Utiliza escalonamento bilinear em vez do método predefinido de escalonamento pelo vizinho mais próximo.

image.BICUBIC: Utiliza escalonamento bicúbico em vez do método predefinido de escalonamento pelo vizinho mais próximo.

image.CENTER: Centra a imagem a ser desenhada no ecrã. Isto é 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: Efetua a extração do canal rgb antes do escalonamento.

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

image.SCALE_ASPECT_KEEP: Escala a imagem a ser desenhada para caber dentro do ecrã.

image.SCALE_ASPECT_EXPAND: Escala a imagem a ser desenhada para preencher o ecrã (resulta em corte).

image.SCALE_ASPECT_IGNORE: Escala a imagem a ser desenhada para preencher o ecrã (resulta em distorção).

image.ROTATE_90: Roda a imagem 90 graus (equivale a VFLIP | TRANSPOSE).

image.ROTATE_180: Roda a imagem 180 graus (equivale a HMIRROR | VFLIP).

image.ROTATE_270: Roda a imagem 270 graus (equivale a HMIRROR | TRANSPOSE).

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

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

Se arg for um ndarray, cria um novo objeto Image a partir do ndarray. Objetos ndarray com a forma (w, h) são tratados como imagens em escala de cinzentos, (w, h, 3) são tratados como imagens RGB565. Apenas ndarrays do tipo float32 são suportados de momento. Ao criar uma imagem desta forma, se passar um argumento buffer, este será utilizado para armazenar os dados da imagem em vez de alocar espaço na heap. Se copy_to_fb for verdadeiro, a imagem é copiada para o buffer de fotograma em vez de ser alocada na heap ou de utilizar o buffer.

Se arg for um int, é considerado como a largura de uma nova imagem e devem seguir-se um valor height e um valor format para criar um novo objeto de imagem em branco. format pode ser qualquer valor de formato de pixel da imagem, como image.GRAYSCALE. A imagem será inicializada a zeros. Note que um valor buffer é esperado para formatos de imagem comprimidos. O buffer é considerado como a fonte de dados da imagem para criar imagens desta forma. Se utilizado com copy_to_fb, os dados do buffer são copiados para o buffer de fotograma. Se pretender criar uma imagem JPEG a partir de um objeto bytes() ou bytearray() JPEG, pode passar width, height, image.JPEG para o JPEG juntamente com a definição de buffer para o fluxo de bytes JPEG para criar uma imagem JPEG.

As imagens suportam a notação «[]». Utilize image[index] = 8/16-bit value para atribuir um pixel a uma imagem ou image[index] para obter um pixel da imagem, que será um valor de 8 bits para imagens em escala de cinzentos/bayer ou um valor de 16 bits para imagens RGB565/YUV. As imagens binárias devolvem um valor de 1 bit.

Para imagens JPEG, o «[]» permite aceder ao blob de imagem JPEG comprimida como um array de bytes. No entanto, a leitura e escrita no array de dados é opaca, uma vez que as imagens JPEG são fluxos de bytes comprimidos.

As imagens também suportam operações de leitura em buffer. Pode passar imagens a todo o tipo de funções MicroPython como se a imagem fosse um objeto byte-array. Em particular, se pretender transmitir uma imagem, pode simplesmente passá-la às funções de escrita UART/SPI/I2C para ser transmitida automaticamente.

Métodos Básicos¶

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

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

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

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

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

Nota

Os objetos Image são automaticamente convertidos em objetos bytes quando passados a um driver MicroPython que requer um objeto semelhante a bytes. Este é um acesso de leitura apenas. 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 cinzentos: Devolve o valor do pixel em escala de cinzentos na localização (x, y). Para imagens RGB565: Devolve o tuplo de pixel RGB888 (r, g, b) na localização (x, y). Para imagens com padrão bayer: Devolve o valor do pixel na localização (x, y).

Devolve None se x ou y estiver fora dos limites da imagem.

x e y podem ser passados de forma independente ou como um tuplo.

rgbtuple se True faz com que este método devolva um tuplo RGB888. Caso contrário, este método devolve o valor inteiro do pixel subjacente. Por exemplo, para imagens RGB565 este método devolve um valor RGB565. O valor predefinido é True para imagens RGB565 e False nos restantes casos.

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. As imagens com padrão bayer são imagens literais onde os pixels são R/G/R/G/etc. nas linhas pares e G/B/G/B/etc. nas linhas ímpares. Cada pixel tem 8 bits. Se chamar este método com rgbtuple definido, Image.get_pixel() irá descodificar o padrão bayer da imagem de origem nessa localização de pixel e devolver um tuplo RGB888 válido para essa localização.

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

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

Devolve o objeto Image para que possa chamar outro método utilizando a notação ..

x e y podem ser passados de forma independente ou como um tuplo.

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

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. As imagens com padrão bayer são imagens literais onde os pixels são R/G/R/G/etc. nas linhas pares e G/B/G/B/etc. nas linhas ímpares. Cada pixel tem 8 bits. Se chamar este método com um tuplo RGB888, o valor de escala de cinzentos desse tuplo 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¶

Devolve um objeto ndarray criado a partir da imagem. Funciona apenas com imagens GRAYSCALE ou RGB565 de momento.

dtype pode ser b, B ou f para criar um ndarray de inteiros de 8 bits com sinal, inteiros de 8 bits sem sinal ou de ponto flutuante de 32 bits, respetivamente. As imagens GRAYSCALE são diretamente convertidas para 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). As imagens RGB565 são convertidas para objetos ndarray de 3 canais e o mesmo processo descrito acima para imagens GRAYSCALE é aplicado a cada canal dependendo de dtype. Note que dtype também aceita os valores inteiros (por exemplo, ord()) de b, B e f, respetivamente.

buffer se não for None é um objeto bytearray a utilizar como buffer para o ndarray. Se for None, um novo buffer é alocado na heap para armazenar os dados de imagem do ndarray. Pode usar o argumento buffer para alocar diretamente o ndarray num buffer pré-alocado, poupando uma alocação na heap e uma operação de cópia.

O ndarray devolvido tem a forma (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 para imagem bitmap (1 bit por pixel).

x_scale controla o fator de escala da imagem exibida na direção x (float). Se este valor for negativo, a imagem será espelhada horizontalmente. Note que se y_scale não for especificado, corresponderá a x_scale para manter a proporção.

y_scale controla o fator de escala da imagem exibida na direção y (float). Se este valor for negativo, a imagem será invertida verticalmente. Note que se x_scale não for especificado, corresponderá a x_scale para manter a proporção.

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

rgb_channel é o canal RGB (0=R, G=1, B=2) a extrair de uma imagem RGB565 (se passada) e a renderizar na imagem de destino. Por exemplo, se passar rgb_channel=1, isto irá extrair o canal verde da imagem RGB565 de origem e desenhá-lo em escala de cinzentos na imagem de destino.

alpha controla a quantidade da imagem de origem a misturar na imagem de destino. Um valor de 255 desenha uma imagem de origem opaca, enquanto um valor inferior a 255 produz uma mistura entre a imagem de origem e a de destino. 0 não produz 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 com 256 pixels no total para usar como tabela de pesquisa de cores sobre o valor de escala de cinzentos da imagem de origem. Isto é aplicado após a extração de rgb_channel, se utilizada.

alpha_palette se não for None pode ser uma imagem GRAYSCALE com 256 pixels no total para usar como paleta alfa, que modula o valor alpha da imagem de origem sendo desenhada ao nível do pixel, permitindo controlar com precisão o valor alfa dos pixels com base no seu valor de escala de cinzentos. Um valor de pixel de 255 na tabela de pesquisa alfa é opaco, sendo que qualquer valor inferior a 255 se torna mais transparente até 0. Isto é aplicado após a extração de rgb_channel, se utilizada.

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

transform é um ndarray 3x3 utilizado para efetuar uma transformação de perspetiva na imagem. Atualmente apenas suportado na OpenMV Cam N6, pois esta possui uma GPU que o pode fazer por hardware.

copy se True cria uma cópia profunda na heap da imagem convertida em vez de converter a imagem original no lugar.

copy_to_fb se True a imagem é carregada diretamente para o buffer de fotograma. copy_to_fb tem prioridade sobre copy. Não tem efeito especial se a imagem já estiver no buffer de fotograma.

Nota

As imagens bitmap são como imagens em escala de cinzentos com apenas dois valores de pixel - 0 e 1. Além disso, as imagens bitmap são compactadas de forma a armazenar apenas 1 bit por pixel, tornando-as muito pequenas. A biblioteca de imagens OpenMV permite que as imagens bitmap sejam utilizadas em todos os locais onde as imagens sensor.GRAYSCALE e sensor.RGB565 podem ser usadas. No entanto, muitas operações aplicadas em imagens bitmap não fazem sentido porque as imagens bitmap têm apenas 2 valores. A OpenMV recomenda o uso de imagens bitmap para valores mask em operações, pois cabem facilmente na heap do MicroPython. Por fim, os valores de pixel 0 e 1 em imagens bitmap são interpretados como preto e branco quando aplicados a imagens sensor.GRAYSCALE ou sensor.RGB565. A biblioteca trata automaticamente da conversão.

Devolve o objeto Image para que possa chamar outro método utilizando 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 para imagem em escala de cinzentos (8 bits por pixel).

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

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

copy se True cria uma cópia profunda na heap da imagem convertida em vez de converter a imagem original no lugar.

copy_to_fb se True a imagem é carregada diretamente para o buffer de fotograma. copy_to_fb tem prioridade sobre copy. Não tem efeito especial se a imagem já estiver no buffer de fotograma.

Devolve o objeto Image para que possa chamar outro método utilizando 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 para imagem RGB565 (16 bits por pixel).

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

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

copy se True cria uma cópia profunda na heap da imagem convertida em vez de converter a imagem original no lugar.

copy_to_fb se True a imagem é carregada diretamente para o buffer de fotograma. copy_to_fb tem prioridade sobre copy. Não tem efeito especial se a imagem já estiver no buffer de fotograma.

Devolve o objeto Image para que possa chamar outro método utilizando 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 para imagem rainbow RGB565 (16 bits por pixel).

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

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

copy se True cria uma cópia profunda na heap da imagem convertida em vez de converter a imagem original no lugar.

copy_to_fb se True a imagem é carregada diretamente para o buffer de fotograma. copy_to_fb tem prioridade sobre copy. Não tem efeito especial se a imagem já estiver no buffer de fotograma.

Devolve o objeto Image para que possa chamar outro método utilizando 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 para imagem ironbow RGB565 (16 bits por pixel).

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

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

copy se True cria uma cópia profunda na heap da imagem convertida em vez de converter a imagem original no lugar.

copy_to_fb se True a imagem é carregada diretamente para o buffer de fotograma. copy_to_fb tem prioridade sobre copy. Não tem efeito especial se a imagem já estiver no buffer de fotograma.

Devolve o objeto Image para que possa chamar outro método utilizando 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 para uma Imagem de Profundidade RGB565 (16 bits por pixel).

roi é o retângulo de região de interesse (x, y, w, h) da imagem de origem a desenhar. Permite extrair apenas os pixels do 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 com 256 pixels no total para usar como tabela de pesquisa de cores sobre o valor de escala de cinzentos da imagem de origem. Isto é aplicado após a extração de rgb_channel, se utilizada.

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

copy se True cria uma cópia profunda na heap da imagem convertida em vez de converter a imagem original no lugar.

copy_to_fb se True a imagem é carregada diretamente para o buffer de fotograma. copy_to_fb tem prioridade sobre copy. Não tem efeito especial se a imagem já estiver no buffer de fotograma.

Devolve o objeto Image para que possa chamar outro método utilizando 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 para uma Imagem de Evento Escuro RGB565 (16 bits por pixel).

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

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

copy se True cria uma cópia profunda na heap da imagem convertida em vez de converter a imagem original no lugar.

copy_to_fb se True a imagem é carregada diretamente para o buffer de fotograma. copy_to_fb tem prioridade sobre copy. Não tem efeito especial se a imagem já estiver no buffer de fotograma.

Devolve o objeto Image para que possa chamar outro método utilizando 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 para uma Imagem de Evento Luminoso RGB565 (16 bits por pixel).

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

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

copy se True cria uma cópia profunda na heap da imagem convertida em vez de converter a imagem original no lugar.

copy_to_fb se True a imagem é carregada diretamente para o buffer de fotograma. copy_to_fb tem prioridade sobre copy. Não tem efeito especial se a imagem já estiver no buffer de fotograma.

Devolve o objeto Image para que possa chamar outro método utilizando 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 para imagem JPEG.

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

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

copy se True cria uma cópia profunda na heap da imagem convertida em vez de converter a imagem original no lugar.

copy_to_fb se True a imagem é carregada diretamente para o buffer de fotograma. copy_to_fb tem prioridade sobre copy. Não tem efeito especial se a imagem já estiver no buffer de fotograma.

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

subsampling pode ser:

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

image.JPEG_SUBSAMPLING_444: Utiliza subamostragem 4:4:4.

image.JPEG_SUBSAMPLING_422: Utiliza subamostragem 4:2:2.

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

Devolve o objeto Image para que possa chamar outro método utilizando 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 para imagem PNG.

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

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

copy se True cria uma cópia profunda na heap da imagem convertida em vez de converter a imagem original no lugar.

copy_to_fb se True a imagem é carregada diretamente para o buffer de fotograma. copy_to_fb tem prioridade sobre copy. Não tem efeito especial se a imagem já estiver no buffer de fotograma.

Devolve o objeto Image para que possa chamar outro método utilizando 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 para imagem JPEG.

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

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

copy se True cria uma cópia profunda na heap da imagem convertida em vez de converter a imagem original no lugar.

copy_to_fb se True a imagem é carregada diretamente para o buffer de fotograma. copy_to_fb tem prioridade sobre copy. Não tem efeito especial se a imagem já estiver no buffer de fotograma.

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

subsampling pode ser:

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

image.JPEG_SUBSAMPLING_444: Utiliza subamostragem 4:4:4.

image.JPEG_SUBSAMPLING_422: Utiliza subamostragem 4:2:2.

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

Devolve o objeto Image para que possa chamar outro método utilizando 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 Image.

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

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

copy_to_fb se True a imagem é carregada diretamente para o buffer de fotograma. Não tem efeito especial se a imagem já estiver no buffer de fotograma.

Devolve o objeto Image para que possa chamar outro método utilizando 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 lugar sem alterar o tipo de imagem subjacente.

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

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

copy se True cria uma cópia profunda na heap da imagem convertida em vez de converter a imagem original no lugar.

copy_to_fb se True a imagem é carregada diretamente para o buffer de fotograma. copy_to_fb tem prioridade sobre copy. Não tem efeito especial se a imagem já estiver no buffer de fotograma.

Devolve o objeto Image para que possa chamar outro método utilizando 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 lugar sem alterar o tipo de imagem subjacente.

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

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

copy se True cria uma cópia profunda na heap da imagem convertida em vez de converter a imagem original no lugar.

copy_to_fb se True a imagem é carregada diretamente para o buffer de fotograma. copy_to_fb tem prioridade sobre copy. Não tem efeito especial se a imagem já estiver no buffer de fotograma.

Devolve o objeto Image para que possa chamar outro método utilizando 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¶

Guarda uma cópia da imagem no sistema de ficheiros em path.

Suporta ficheiros de imagem bmp/pgm/ppm/jpg/jpeg. Note que não é possível guardar imagens comprimidas em jpeg num formato não comprimido.

roi é o retângulo de região de interesse (x, y, w, h) a guardar. Se não for 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 utilizar para guardar a imagem em formato jpeg, se a imagem ainda não estiver comprimida (0-100) (int).

Devolve o objeto Image para que possa chamar outro método utilizando a notação ..

flush() → None¶: Atualiza o buffer de fotograma no IDE com a imagem presente no buffer de fotograma da câmara.

Métodos de Desenho¶

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

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

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

Devolve o objeto Image para que possa chamar outro método utilizando 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. Pode passar x0, y0, x1, y1 de forma independente ou como um tuplo (x0, y0, x1, y1).

color é um tuplo RGB888 para imagens em Grayscale ou RGB565. O valor predefinido é branco. No entanto, também pode passar o valor do pixel subjacente (0-255) para imagens em escala de cinzentos ou um valor RGB565 para imagens RGB565.

thickness controla a espessura da linha em pixels.

Devolve o objeto Image para que possa chamar outro método utilizando 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. Pode passar x, y, w, h de forma independente ou como um tuplo (x, y, w, h).

thickness controla a espessura das linhas em pixels.

Passe fill como True para preencher o retângulo.

Devolve o objeto Image para que possa chamar outro método utilizando 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. Pode passar x, y, radius de forma independente ou como um tuplo (x, y, radius).

thickness controla a espessura das arestas em pixels.

Passe fill como True para preencher o círculo.

Devolve o objeto Image para que possa chamar outro método utilizando 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. Pode passar cx, cy, rx, ry e a rotação (em graus) de forma independente ou como um tuplo (cx, yc, rx, ry, rotation).

thickness controla a espessura das arestas em pixels.

Passe fill como True para preencher a elipse.

Devolve o objeto Image para que possa chamar outro método utilizando 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) da imagem. Pode passar x, y de forma independente ou como um tuplo (x, y).

text é uma string a escrever na imagem. Os terminadores de linha \n, \r e \r\n movem o cursor para a linha seguinte.

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

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

y_spacing permite adicionar (se positivo) ou subtrair (se negativo) pixels y entre 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 de texto grandes, isto parece terrível. Defina como False para obter espaçamento de caracteres de largura não fixa, o que fica MUITO melhor.

char_rotation pode ser 0, 90, 180, 270 para rodar cada caractere da string por este valor.

char_hmirror se True espelha horizontalmente todos os caracteres na string.

char_vflip se True inverte verticalmente todos os caracteres na string.

string_rotation pode ser 0, 90, 180, 270 para rodar a string por este valor.

string_hmirror se True espelha horizontalmente a string.

string_vflip se True inverte verticalmente a string.

Devolve o objeto Image para que possa chamar outro método utilizando 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. Pode passar x, y de forma independente ou como um tuplo (x, y).

size controla o comprimento das linhas da cruz.

thickness controla a espessura das arestas em pixels.

Devolve o objeto Image para que possa chamar outro método utilizando 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. Pode passar x0, y0, x1, y1 de forma independente ou como um tuplo (x0, y0, x1, y1).

thickness controla a espessura da linha em pixels.

Devolve o objeto Image para que possa chamar outro método utilizando 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 deteção na imagem. detection é um tuplo de 6 elementos (rx, ry, rw, rh, cx, cy) descrevendo um retângulo delimitador e um centróide (normalmente devolvido por código NN ou de rastreamento de cor).

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

label se fornecido é desenhado perto do retângulo, deslocado por label_offset (x, y).

Devolve o objeto Image para que possa chamar outro método utilizando 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 arestas de linha entre uma lista de cantos devolvida por métodos como blob.corners. Os cantos são um tuplo de quatro valores com tuplos x/y de dois valores. Por exemplo, [(x1,y1),(x2,y2),(x3,y3),(x4,y4)].

size se 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.

Devolve o objeto Image para que possa chamar outro método utilizando 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. Pode passar x, y de forma independente ou como um tuplo (x, y). Este método trata automaticamente da renderização da imagem passada no formato de pixel correto para a imagem de destino, bem como do recorte de forma transparente.

Também pode passar um caminho em vez de um objeto de imagem para este método carregar automaticamente a imagem do disco e utilizá-la num só passo. Por exemplo, draw_image("test.jpg").

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

hint é um OR lógico das flags listadas em Flags de sugestão (incluindo image.BLACK_BACKGROUND que é suportado aqui).

Devolve o objeto Image para que possa chamar outro método utilizando 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 keypoints na imagem. Também pode passar uma lista de tuplos de três valores contendo (x, y, rotation_angle_in_degrees) para reutilizar este método para desenhar glifos de ponto-chave, que são um círculo com uma linha apontando numa 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.

Devolve o objeto Image para que possa chamar outro método utilizando 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 uma região da imagem a partir da localização x, y. Pode passar x, y de forma independente ou como um tuplo (x, y).

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

floating_threshold controla o quanto qualquer pixel na área de preenchimento pode diferir dos seus pixels vizinhos.

Passe invert como True para recolorir tudo fora da área de preenchimento por inundação conectada.

Passe clear_background como True para zerar o resto dos pixels que o preenchimento por inundação não recoloriu.

Devolve o objeto Image para que possa chamar outro método utilizando 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 (tal como preenchido por csi.IOCTL_GENX320_READ_EVENTS) sobre uma Image para visualização. O buffer de 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. Os eventos de disparo são ignorados. Os valores dos pixels são limitados a 0-255.

clear se True repõe o buffer de imagem para brightness antes de desenhar — cada fotograma torna-se uma renderização apenas de eventos. Defina como False para acumular eventos em várias chamadas (útil para trilhos de movimento de longa exposição).

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

contrast controla o quanto cada evento desloca o seu pixel — valores mais elevados tornam os eventos mais visíveis, ao custo de saturar rapidamente quando muitos eventos incidem 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 não forem fornecidos argumentos, este método zera o centro da imagem.

Devolve o objeto Image para que possa chamar outro método utilizando 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 não forem fornecidos argumentos, este método zera o centro da imagem.

Devolve o objeto Image para que possa chamar outro método utilizando 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 não forem fornecidos argumentos, este método zera o centro da imagem.

Devolve o objeto Image para que possa chamar outro método utilizando 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 a preto ou branco dependendo se cada pixel está dentro de um dos tuplos de limiar em thresholds.

thresholds é uma lista de tuplos (lo, hi) para imagens em escala de cinzentos, ou (l_lo, l_hi, a_lo, a_hi, b_lo, b_hi) para imagens RGB565. Os valores mín/máx trocados são corrigidos automaticamente; os componentes em falta assumem o intervalo máximo.

invert inverte a correspondência de limiares.

zero se True, zera os pixels limiarizados e deixa os restantes intocados.

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

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

copy se True, devolve uma nova imagem na heap em vez de modificar a imagem de origem.

Devolve o objeto Image para que possa chamar outro método utilizando a notação ..

Não suportado em imagens comprimidas ou imagens bayer.

invert() → Image¶

Inverte todos os valores de pixel na imagem (cada pixel passa a 255 - pixel para canais de 8 bits).

Devolve o objeto Image para que possa chamar outro método utilizando a notação ..

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

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

Efetua um AND lógico desta imagem com outra imagem.

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

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

Devolve o objeto Image para que possa chamar outro método utilizando a notação ..

Não suportado em imagens comprimidas ou imagens bayer.

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

Efetua um NAND lógico desta imagem com outra imagem.

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

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

Devolve o objeto Image para que possa chamar outro método utilizando a notação ..

Não suportado em imagens comprimidas ou imagens bayer.

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

Efetua um OR lógico desta imagem com outra imagem.

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

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

Devolve o objeto Image para que possa chamar outro método utilizando a notação ..

Não suportado em imagens comprimidas ou imagens bayer.

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

Efetua um NOR lógico desta imagem com outra imagem.

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

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

Devolve o objeto Image para que possa chamar outro método utilizando a notação ..

Não suportado em imagens comprimidas ou imagens bayer.

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

Efetua um XOR lógico desta imagem com outra imagem.

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

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

Devolve o objeto Image para que possa chamar outro método utilizando a notação ..

Não suportado em imagens comprimidas ou imagens bayer.

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

Efetua um XNOR lógico desta imagem com outra imagem.

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

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

Devolve o objeto Image para que possa chamar outro método utilizando a notação ..

Não suportado em imagens comprimidas ou imagens bayer.

Métodos ISP¶

awb(max: bool = False) → Image¶

Efetua o balanço de brancos automático na imagem utilizando o algoritmo do mundo cinzento. Opera em imagens RAW Bayer ou RGB565. Não tem efeito em imagens binárias/escala de cinzentos.

max se True, utiliza o algoritmo de patch branco em vez disso.

Devolve o objeto Image para que possa chamar outro método utilizando 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 fornecida pela imagem. As matrizes podem ser 3x3 ou 3x4 (com coluna de offset), em forma de lista aninhada ou 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]

Devolve o objeto Image para que possa chamar outro método utilizando 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, contraste e brilho da imagem.

gamma aplica pow(pixel, 1/gamma) após normalização. Valores superiores a 1.0 tornam a imagem mais clara; inferiores a 1.0 tornam-na mais escura.

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

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

Devolve o objeto Image para que possa chamar outro método utilizando 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 lugar se image for omitido) utilizando os argumentos de palavra-chave padrão de draw_image. O argumento transform é um ndarray 3x3 que descreve uma transformação de perspetiva (apenas suportado em câmaras OpenMV com ULAB ativado).

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 pixel a pixel a esta.

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

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

Devolve o objeto Image para que possa chamar outro método utilizando a notação ..

Não suportado em imagens comprimidas ou imagens bayer.

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

Subtrai image pixel a pixel desta imagem (self - image).

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

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

Este método também aceita o conjunto completo de argumentos de palavra-chave 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 inversa: substitui esta imagem por image - self pixel a pixel. De resto, idêntico a Image.sub().

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

Devolve a imagem mínima de duas imagens pixel a pixel.

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

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

Devolve o objeto Image para que possa chamar outro método utilizando a notação ..

Não suportado em imagens comprimidas ou imagens bayer.

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

Devolve a imagem máxima de duas imagens pixel a pixel.

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

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

Devolve o objeto Image para que possa chamar outro método utilizando a notação ..

Não suportado em imagens comprimidas ou imagens bayer.

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

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

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

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

Devolve o objeto Image para que possa chamar outro método utilizando 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 mistura alfa de image nesta imagem. alpha é um inteiro de 0-256; valores mais próximos de 256 favorecem a imagem de origem. Aceita todos os argumentos de palavra-chave 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 contraste e 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 CLAHE).

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

Devolve o objeto Image para que possa chamar outro método utilizando 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 arestas das áreas segmentadas. Convola um kernel ((size*2)+1)x((size*2)+1) sobre a imagem, limpando o pixel central se mais de threshold vizinhos estiverem limpos (funciona como erosão padrão se threshold for None).

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

Devolve o objeto Image para que possa chamar outro método utilizando 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 arestas das áreas segmentadas. Convola um kernel ((size*2)+1)x((size*2)+1) sobre a imagem, definindo o pixel central se mais de threshold vizinhos estiverem definidos (funciona como dilatação padrão se threshold for None).

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

Devolve o objeto Image para que possa chamar outro método utilizando 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¶

Executa erosão seguida de dilatação. Consulte Image.erode() e Image.dilate().

mask é uma imagem binária utilizada como máscara ao nível do 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¶

Executa dilatação seguida de erosão. Consulte Image.dilate() e Image.erode().

mask é uma imagem binária utilizada como máscara ao nível do 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¶

Devolve a diferença entre a imagem e a imagem sujeita a Image.open().

mask é uma imagem binária utilizada como máscara ao nível do 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¶

Devolve a diferença entre a imagem e a imagem sujeita a Image.close().

mask é uma imagem binária utilizada como máscara ao nível do 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 de desfoque médio padrão utilizando um filtro de caixa.

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

threshold se True, limiariza adaptativamente a saída do filtro para uma imagem binária. offset desloca a binarização (valores negativos tornam mais pixels brancos, valores positivos tornam menos). invert inverte a saída binária.

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

Devolve o objeto Image para que possa chamar outro método utilizando 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. Utilize 1 (kernel 3x3), 2 (kernel 5x5), etc.

percentile é o percentil a selecionar de cada kernel (0 = mínimo, 0.5 = mediana, 1.0 = máximo). O valor predefinido é 0.5.

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

Devolve o objeto Image para que possa chamar outro método utilizando 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 dos seus vizinhos. Pode produzir artefactos nas arestas de imagens RGB devido à operação não linear.

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

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

Devolve o objeto Image para que possa chamar outro método utilizando 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 pixel na imagem.

size é o tamanho do kernel. Utilize 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 pode filtrar a imagem por mín/máx.

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

Devolve o objeto Image para que possa chamar outro método utilizando a notação ..

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

Convola a imagem com um kernel de filtragem 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 efetuar a convolução, como uma lista/tuplo plano 1D de ((size*2)+1)*((size*2)+1) elementos, ou como uma lista/tuplo 2D com ((size*2)+1) linhas de ((size*2)+1) elementos.

mul é um fator de escala de contraste multiplicativo (padrão 1.0).

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

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

Devolve o objeto Image para que possa chamar outro método utilizando a notação ..

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

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

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

unsharp se True, executa uma operação de máscara de nitidez (aguça as arestas) em vez de um gaussiano simples.

mul é um fator de escala de contraste multiplicativo (padrão 1.0).

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

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

Devolve o objeto Image para que possa chamar outro método utilizando 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¶: Convola a imagem com um kernel laplaciano de deteção de arestas.

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

sharpen se True, aguça a imagem em vez de produzir a resposta de aresta não limiarizada.

mul é um fator de escala de contraste multiplicativo (padrão 1.0).

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

threshold se True, limiariza adaptativamente a saída do filtro para uma imagem binária. offset desloca a binarização (valores negativos tornam mais pixels brancos, valores positivos tornam menos). invert inverte a saída binária.

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

Devolve o objeto Image para que possa chamar outro método utilizando a notação ..

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

Convola a imagem com um filtro bilateral (suavização com preservação de arestas).

size é o tamanho do kernel. Utilize 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 pixel.

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

Devolve o objeto Image para que possa chamar outro método utilizando 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¶

Reprojecta uma imagem de coordenadas cartesianas para coordenadas polares lineares.

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

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

A reprojeção polar linear transforma a rotação de uma imagem em translação em 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¶

Reprojecta uma imagem de coordenadas cartesianas para coordenadas polares logarítmicas.

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

A reprojeção polar logarítmica transforma a rotação de uma imagem em translação em x e o escalonamento/zoom em translação em 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¶

Efetua 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 até a imagem parecer 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.

Devolve o objeto Image para que possa chamar outro método utilizando 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 perspetiva na imagem efetuando uma rotação 3D do buffer de fotograma.

x_rotation é o número de graus para rodar a imagem no buffer de fotograma em torno do eixo x (ou seja, isto roda a imagem para cima e para baixo).

y_rotation é o número de graus para rodar a imagem no buffer de fotograma em torno do eixo y (ou seja, isto roda a imagem para a esquerda e para a direita).

z_rotation é o número de graus para rodar a imagem no buffer de fotograma em torno do eixo z (ou seja, isto roda 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 utilizado 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 do viewport.

corners é uma lista de quatro tuplos (x, y) utilizados para construir uma homografia de 4 pontos mapeando 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 de pássaro.

Devolve o objeto Image para que possa chamar outro método utilizando 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_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 semelhança entre duas imagens utilizando o Índice de Semelhança Estrutural (SSIM). O SSIM varia de -1 (oposto) a 1 (idêntico). Devolve um objeto image.similarity.

image é a imagem com a qual 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, devolve o Índice de Dissemelhança 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 um roi e devolve um objeto image.histogram. Também disponível como Image.get_hist() ou Image.histogram().

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

invert inverte a correspondência de limiares.

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

bins (escala de cinzentos) ou l_bins/a_bins/b_bins (RGB565) definem o número de compartimentos do histograma por canal. Deve ser maior que 2. O valor predefinido é o número máximo de compartimentos 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 adicional.

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

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

invert inverte a correspondência de limiares.

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

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 adicional.

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) em todos os pixels limiarizados da imagem. Devolve um objeto image.line, ou None se não for encontrada nenhuma linha.

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

invert inverte a correspondência de limiares.

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

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

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

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

target_size é um tuplo (w, h). O ROI é reduzido por área para caber neste tamanho antes de executar o algoritmo O(N^2). O valor predefinido é (80, 60).

Não suportado em imagens comprimidas ou imagens bayer.

Métodos de Deteçã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 todas as manchas (regiões de pixels conectadas que passam num teste de limiar) na imagem e devolve uma lista de objetos image.blob.

thresholds é uma lista de tuplos (lo, hi) para imagens em escala de cinzentos, ou (l_lo, l_hi, a_lo, a_hi, b_lo, b_hi) para imagens RGB565 (canais LAB). Podem ser passados até 32 tuplos. Os valores mín/máx trocados são corrigidos automaticamente; os componentes em falta assumem o intervalo máximo.

invert inverte a correspondência de limiares.

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

x_stride e y_stride controlam quantos pixels são ignorados ao procurar uma mancha. Aumente se as manchas forem conhecidamente grandes.

area_threshold área mínima da caixa delimitadora; manchas menores são filtradas.

pixels_threshold contagem mínima de pixels limiarizados; manchas menores são filtradas.

merge se True funde manchas cujos retângulos delimitadores se intersectam. margin aumenta/reduz os retângulos delimitadores utilizados para a interseção. As manchas fundidas fazem OR nos seus vetores de bits code (um bit por limiar).

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

merge_cb é chamado por par de manchas prestes a ser fundidas; devolve True para permitir a fusão, False para a impedir.

x_hist_bins_max se diferente de zero, preenche cada mancha com uma projeção x_histogram utilizando este número de compartimentos.

y_hist_bins_max se diferente de zero, preenche cada mancha com uma projeção y_histogram utilizando este número de compartimentos.

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 utilizando a transformada de Hough. Devolve uma lista de objetos image.line.

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

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

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

theta_margin e rho_margin controlam a fusão: linhas dentro destes limiares são fundidas.

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. Devolve uma lista de objetos image.line.

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

merge_distance é a separação máxima em pixels entre dois segmentos para serem fundidos.

max_theta_difference é a diferença máxima de theta em graus entre segmentos para serem fundidos.

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 utilizando a transformada de Hough. Devolve uma lista de objetos image.circle.

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

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

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

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

r_min raio mínimo do círculo. O valor predefinido é 2.

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

r_step incremento do raio. O valor predefinido é 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 utilizando o algoritmo de deteção de quádruplos apriltag. Devolve uma lista de objetos image.rect.

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

threshold magnitude mínima da aresta (soma das magnitudes sobel ao longo das arestas do retângulo); os 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 códigos QR dentro do roi e devolve uma lista de objetos image.qrcode.

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

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

Encontra todos os apriltags dentro do roi e devolve uma lista de objetos image.apriltag.

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

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

image.TAG16H5

image.TAG25H9

image.TAG36H10

image.TAG36H11

image.TAGCIRCLE21H7

image.TAGCIRCLE49H12

image.TAGCUSTOM48H12

image.TAGSTANDARD41H12

image.TAGSTANDARD52H13

O valor predefinido é image.TAG36H11. O tempo de deteção escala com o número de famílias ativas.

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

cx e cy são o centro da imagem, tipicamente 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 datamatrizes dentro do roi e devolve uma lista de objetos image.datamatrix.

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

effort controla quanto tempo despender a tentar encontrar correspondências de matriz de dados. Valores mais elevados melhoram a deteção ao custo da taxa de fotogramas. Valores abaixo de ~160 falham na deteção; valores acima de ~240 têm retornos decrescentes. O valor predefinido é 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 do roi e devolve uma lista de objetos image.barcode. Faz a pesquisa horizontal e 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 é o tuplo de retângulo de região de interesse (x, y, w, h). O valor predefinido é 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. Devolve um objeto image.displacement.

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

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

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

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

Nota

Utilize este método em tamanhos de imagem que são 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 utilizando Correlação Cruzada Normalizada. Devolve um tuplo de caixa delimitadora (x, y, w, h), ou None.

template é uma imagem em escala de cinzentos para comparar com esta imagem.

threshold é um valor (0.0-1.0). Valores mais elevados reduzem os falsos positivos e as deteções; valores mais baixos têm o efeito oposto.

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

step é o número de pixels a ignorar durante a pesquisa (apenas utilizado no modo image.SEARCH_EX).

search é image.SEARCH_DS (pesquisa diamante mais rápida) ou image.SEARCH_EX (pesquisa exaustiva).

Funciona apenas em imagens em escala de cinzentos.

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

Pesquisa na imagem áreas correspondentes à cascata Haar passada e devolve uma lista de tuplos de caixa delimitadora (x, y, w, h). Devolve uma lista vazia se não forem encontradas características.

cascade é um objeto Cascata Haar (consulte image.HaarCascade()).

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

scale deve ser maior que 1.0. Valores mais elevados são mais rápidos mas produzem correspondências de menor qualidade.

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

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

Procura a pupila numa região de interesse (x, y, w, h) em torno de um olho. Devolve a localização (x, y) da pupila, ou (0, 0) se nenhuma for encontrada.

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

Funciona apenas em imagens em escala de cinzentos.

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

Extrai pontos-chave LBP (padrões binários locais) da região de interesse. Utilize image.match_descriptor() para comparar dois descritores.

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

Funciona apenas em imagens em escala de cinzentos.

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. Utilize image.match_descriptor() para comparar dois descritores. Devolve None se não forem encontrados pontos-chave.

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

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

normalized se True, desativa a extração de pontos-chave multi-resolução.

scale_factor deve ser maior que 1.0. Valores mais elevados são mais rápidos mas produzem correspondências de menor qualidade.

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 cinzentos.

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

Converte a imagem para preto e branco deixando apenas as arestas como pixels brancos.

image.EDGE_SIMPLE - Algoritmo simples de filtro passa-alto com limiarização.

image.EDGE_CANNY - Algoritmo de deteção de arestas Canny.

threshold é um tuplo de dois valores contendo um limiar baixo e um limiar alto. Pode controlar a qualidade das arestas ajustando estes valores. O valor predefinido é (100, 200).

Funciona apenas em imagens em escala de cinzentos.

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

Substitui os pixels no ROI com linhas HOG (histograma de gradientes orientados).

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

Funciona apenas em imagens em escala de cinzentos.

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 cinzentos de dupla largura contendo a saída de dois sensores de câmara lado a lado e substitui uma metade pela imagem de disparidade estéreo (cada pixel representa profundidade). Por exemplo, para duas câmaras 320x240, passe uma imagem 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) para procurar um bloco de pixels correspondente usando soma de diferenças absolutas. Valores maiores demoram exponencialmente mais mas produzem saída de maior qualidade.

threshold se a soma das diferenças absolutas entre dois blocos for inferior ou igual a este limiar, 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 pesquisa seletiva na imagem e devolve uma lista de tuplos de caixa delimitadora (x, y, w, h) de propostas de objetos.

threshold é o limiar de segmentação; valores mais elevados produzem regiões menos numerosas e maiores.

size é o tamanho mínimo da região após a fusão.

a1, a2, a3 são os pesos de semelhança de cor/textura/tamanho utilizados na fusão de regiões.