class Image – Image-objekt¶

Image är den centrala datatypen i modulen image – en pixelbuffert i minnet som varje ritrutin, varje filter, varje geometrisk transform och varje rutin för särdragsextraktion arbetar på. Varje bildruta som kommer ut ur csi.CSI.snapshot() är en Image; likaså varje bildruta som läses in från disk, avkodas från JPEG eller PNG, allokeras från en numpy-liknande ndarray eller skapas som en tom rityta.

En Image beskrivs av tre tal – width, height och pixformat – plus en sammanhängande pixelbuffert. Pixelformatet bestämmer både layouten i minnet och vilka operationer som är tillgängliga:

BINARY (1 bpp) – 1 bit per pixel; används av morfologi och tröskling.
GRAYSCALE (8 bpp) – 1 byte per pixel; det kanoniska formatet för det mesta inom CV (AprilTag, kanter, ORB, optiskt flöde).
RGB565 (16 bpp) – 2 byte per pixel (5R/6G/5B); standardfärgformatet.
BAYER (8 bpp) – rådata i Bayer-mosaik direkt från sensorn. De flesta CV-metoder är inte tillgängliga på Bayer-bilder; debayera till GRAYSCALE / RGB565 först.
YUV422 (16 bpp) – 4:2:2 kroma-subsamplad färg, två byte per pixel. Bara vissa metoder fungerar direkt på YUV422.
JPEG / PNG – komprimerade buffertar. Pixelnivåoperationer kräver to_grayscale() eller to_rgb565() först.

Var Image-objekt kommer ifrån¶

Det finns fyra sätt att få tag i en Image:

Från kamerans bildbuffert – csi.CSI().snapshot() returnerar nästa infångade bildruta. Det returnerade objektet är ett tunt omslag kring kamerans bildbuffertminne, så varje rit-/filteroperation på det ändrar vad som skickas till IDE-förhandsvisningen och displayen.
Från en fil – skicka en sökvägssträng till Image-konstruktorn. BMP, PGM, PPM, JPEG och PNG avkodas direkt till RAM (eller till kamerans bildbuffert om copy_to_fb=True).
Från en ndarray – skicka en (h, w)- eller (h, w, 3)-array av float32. Pixlarna skalas från 0.0 -- 255.0 till GRAYSCALE respektive RGB565.
Tom – skicka (width, height, pixformat) för att allokera en nollfylld rityta. För komprimerade pixelformat (JPEG / PNG) krävs ett buffer=-argument som innehåller den komprimerade byteströmmen.

Typisk infångnings-, bearbetnings- och visningsloop¶

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.

Indexering, längd, iteration och byte-liknande åtkomst¶

Indexering – img[i] läser pixel i (linjärt, radvis). img[i] = value skriver den. Pixlar i gråskala / Bayer är 8-bitars heltal, RGB565 / YUV422-pixlar är 16-bitars packade heltal, binära pixlar är 0 / 1. För JPEG / PNG-bilder är indexutrymmet den komprimerade byteströmmen, inte pixlar.
Längd – len(img) returnerar antalet pixlar för okomprimerade format eller byteantalet för komprimerade format.
Iteration – for px in img: ... går igenom pixelarrayen i samma ordning som indexering med [].
Byte-liknande – Image exponerar läsbuffertprotokollet, så du kan skicka den direkt till allt som tar en bytes / bytearray (t.ex. uart.write(img), socket.send(img), hashlib.sha256(img)). Använd bytearray() i stället för att få en läs/skriv-vy.

Hint-flaggor¶

Många Image-metoder accepterar ett hint-argument som är en logisk OR av följande flaggor:

image.AREA: Använd ytskalning vid nedskalning i stället för standardvärdet närmaste granne.

image.BILINEAR: Använd bilinjär skalning i stället för standardvärdet skalning med närmaste granne.

image.BICUBIC: Använd bikubisk skalning i stället för standardvärdet skalning med närmaste granne.

image.CENTER: Centrera bilden som ritas på displayen. Detta tillämpas efter skalning.

image.HMIRROR: Spegla bilden horisontellt.

image.VFLIP: Vänd bilden vertikalt.

image.TRANSPOSE: Transponera bilden (byt x/y).

image.EXTRACT_RGB_CHANNEL_FIRST: Utför rgb_channel-extraktion före skalning.

image.APPLY_COLOR_PALETTE_FIRST: Tillämpa färgpalett före skalning.

image.SCALE_ASPECT_KEEP: Skala bilden som ritas så att den får plats inuti displayen.

image.SCALE_ASPECT_EXPAND: Skala bilden som ritas så att den fyller displayen (resulterar i beskärning)

image.SCALE_ASPECT_IGNORE: Skala bilden som ritas så att den fyller displayen (resulterar i utsträckning).

image.ROTATE_90: Rotera bilden 90 grader (detta är bara VFLIP | TRANSPOSE).

image.ROTATE_180: Rotera bilden 180 grader (detta är bara HMIRROR | VFLIP).

image.ROTATE_270: Rotera bilden 270 grader (detta är bara HMIRROR | TRANSPOSE).

image.BLACK_BACKGROUND: Anta att bakgrundsbilden som ritas på är svart för att snabba upp blandningen. Stöds endast av Image.draw_image() och Image.get_similarity().

Om arg är en sträng skapar detta ett nytt bildobjekt från en fil på sökvägen arg. Stöder inläsning av bmp/pgm/ppm/jpg/jpeg/png-bildfiler från disk. Om copy_to_fb är sant kopieras bilden till bildbufferten i stället för att allokeras på heapen.

Om arg är en ndarray skapar detta ett nytt bildobjekt från ndarray. ndarray-objekt med formen (w, h) behandlas som gråskalebilder, (w, h, 3) behandlas som RGB565-bilder. Endast ndarrays av typen float32 stöds för närvarande. När du skapar en bild på detta sätt och skickar ett buffer-argument används det för att lagra bilddatan i stället för att allokera utrymme på heapen. Om copy_to_fb är sant kopieras bilden till bildbufferten i stället för att allokeras på heapen eller använda buffer.

Om arg är ett int betraktas det som bredden på en ny bild, och ett height-värde och ett format-värde måste följa för att skapa ett nytt tomt bildobjekt. format kan vara vilket bildpixformat-värde som helst, som image.GRAYSCALE. Bilden initieras till enbart nollor. Observera att ett buffer-värde förväntas för komprimerade bildformat. buffer betraktas som källan till bilddata när bilder skapas på detta sätt. Om det används med copy_to_fb kopieras datan från buffer till bildbufferten. Om du vill skapa en JPEG-bild från ett bytes()- eller bytearray()-objekt med JPEG kan du skicka width, height och image.JPEG för JPEG-bilden tillsammans med att sätta buffer till JPEG-byteströmmen för att skapa en JPEG-bild.

Bilder stöder ”[]”-notation. Gör image[index] = 8/16-bit value för att tilldela en bildpixel eller image[index] för att hämta en bildpixel, vilket blir antingen ett 8-bitars värde för gråskale-/bayerbilder eller ett 16-bitars värde för RGB565/YUV-bilder. Binära bilder returnerar ett 1-bitars värde.

För JPEG-bilder låter ”[]” dig komma åt den komprimerade JPEG-bildbloben som en byte-array. Att läsa och skriva till dataarrayen är dock ogenomskinligt eftersom JPEG-bilder är komprimerade byteströmmar.

Bilder stöder även läsbuffertoperationer. Du kan skicka bilder till alla möjliga MicroPython-funktioner som om bilden vore ett byte-array-objekt. I synnerhet kan du, om du vill överföra en bild, bara skicka den till skrivfunktionerna för UART/SPI/I2C för att den ska överföras automatiskt.

Grundläggande metoder¶

width() → int¶: Returnerar bildbredden i pixlar.

height() → int¶: Returnerar bildhöjden i pixlar.

format() → int¶: Returnerar image.GRAYSCALE för gråskalebilder, image.RGB565 för RGB565-bilder, image.BAYER för bilder med bayer-mönster och image.JPEG för JPEG-bilder.

size() → int¶: Returnerar bildstorleken i byte.

bytearray() → bytearray¶: Returnerar ett bytearray-objekt som pekar på bilddatan för läs/skriv-åtkomst på bytenivå.

Anteckning

Image-objekt typomvandlas automatiskt till bytes-objekt när de skickas till en MicroPython-drivrutin som kräver ett bytes-liknande objekt. Detta är skrivskyddad åtkomst. Anropa bytearray() för att få läs/skriv-åtkomst.

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

För gråskalebilder: Returnerar gråskalepixelvärdet på platsen (x, y). För RGB565-bilder: Returnerar RGB888-pixeltupeln (r, g, b) på platsen (x, y). För bilder med bayer-mönster: Returnerar pixelvärdet på platsen (x, y).

Returnerar None om x eller y ligger utanför bilden.

x och y kan antingen skickas var för sig eller som en tupel.

rgbtuple om True gör att denna metod returnerar en RGB888-tupel. Annars returnerar denna metod heltalsvärdet för den underliggande pixeln. D.v.s. för RGB565-bilder returnerar denna metod ett RGB565-värde. Standardvärdet är True för RGB565-bilder och False annars.

Stöds inte på komprimerade bilder.

Anteckning

Image.get_pixel() och Image.set_pixel() är de enda metoderna som låter dig manipulera bilder med bayer-mönster. Bilder med bayer-mönster är bokstavliga bilder där pixlarna i bilden är R/G/R/G/osv. för jämna rader och G/B/G/B/osv. för udda rader. Varje pixel är 8 bitar. Om du anropar denna metod med rgbtuple satt kommer Image.get_pixel() att debayera källbilden på den pixelplatsen och returnera en giltig RGB888-tupel för pixelplatsen.

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

För gråskalebilder: Sätter pixeln på platsen (x, y) till gråskalevärdet pixel. För RGB565-bilder: Sätter pixeln på platsen (x, y) till RGB888-tupeln (r, g, b) pixel. För bilder med bayer-mönster: Sätter pixelvärdet på platsen (x, y) till värdet pixel.

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

x och y kan antingen skickas var för sig eller som en tupel.

pixel kan antingen vara en RGB888-tupel (r, g, b) eller det underliggande pixelvärdet (d.v.s. ett RGB565-värde för RGB565-bilder eller ett 8-bitars värde för gråskalebilder).

Stöds inte på komprimerade bilder.

Anteckning

Image.get_pixel() och Image.set_pixel() är de enda metoderna som låter dig manipulera bilder med bayer-mönster. Bilder med bayer-mönster är bokstavliga bilder där pixlarna i bilden är R/G/R/G/osv. för jämna rader och G/B/G/B/osv. för udda rader. Varje pixel är 8 bitar. Om du anropar denna metod med en RGB888-tupel extraheras gråskalevärdet för den RGB888-tupeln och sätts på pixelplatsen.

Konverteringsmetoder¶

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

Returnerar ett ndarray-objekt skapat från bilden. Detta fungerar för närvarande endast för GRAYSCALE- eller RGB565-bilder.

dtype kan vara b, B eller f för att skapa en ndarray med teckenförsedd 8-bitars, teckenlös 8-bitars eller 32-bitars flyttal. GRAYSCALE-bilder konverteras direkt till teckenlösa 8-bitars ndarray-objekt. För teckenförsedda 8-bitars ndarray-objekt mappas värdena (0:255) till (-127:128). För 32-bitars flyttals-ndarray-objekt mappas värdena till (0.0:255.0). RGB565-bilder konverteras till 3-kanaliga ndarray-objekt, och samma process som beskrivs ovan för GRAYSCALE-bilder tillämpas på varje kanal beroende på dtype. Observera att dtype även accepterar heltalsvärdena (t.ex. ord()) för b, B respektive f.

buffer om inte None är ett bytearray-objekt som ska användas som buffert för ndarray. Om None allokeras en ny buffert på heapen för att lagra ndarray-bilddatan. Du kan använda buffer-argumentet för att direkt allokera ndarray i en förallokerad buffert och därmed spara en heapallokering och en kopieringsoperation.

Den returnerade ndarray har formen (height, width) för GRAYSCALE-bilder och (height, width, 3) för RGB565-bilder.

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¶

Konverterar en bild till en bitmappsbild (1 bit per pixel).

x_scale styr hur mycket den visade bilden skalas i x-riktningen (float). Om detta värde är negativt vänds bilden horisontellt. Observera att om y_scale inte anges kommer det att matcha x_scale för att behålla bildförhållandet.

y_scale styr hur mycket den visade bilden skalas i y-riktningen (float). Om detta värde är negativt vänds bilden vertikalt. Observera att om x_scale inte anges kommer det att matcha x_scale för att behålla bildförhållandet.

roi är intresseområdets rektangeltupel (x, y, w, h) i källbilden som ska ritas. Detta låter dig extrahera bara pixlarna i ROI för att skala och rita på destinationsbilden.

rgb_channel är RGB-kanalen (0=R, G=1, B=2) som ska extraheras från en RGB565-bild (om den skickas) och renderas på destinationsbilden. Om du till exempel skickar rgb_channel=1 extraheras den gröna kanalen i RGB565-källbilden och ritas i gråskala på destinationsbilden.

alpha styr hur mycket av källbilden som blandas in i destinationsbilden. Värdet 255 ritar en ogenomskinlig källbild medan ett värde lägre än 255 ger en blandning mellan käll- och destinationsbilden. 0 resulterar i ingen ändring av destinationsbilden.

color_palette om inte None kan vara en enum för färgpalett eller en RGB565-bild på totalt 256 pixlar att använda som en färguppslagstabell på gråskalevärdet för vad källbilden än är. Detta tillämpas efter rgb_channel-extraktion om sådan används.

alpha_palette om inte None kan vara en GRAYSCALE-bild på totalt 256 pixlar att använda som en alfapalett som modulerar alpha-värdet för källbilden som ritas på pixelnivå, vilket låter dig exakt styra alfavärdet för pixlar baserat på deras gråskalevärde. Ett pixelvärde på 255 i alfauppslagstabellen är ogenomskinligt, medan allt lägre än 255 blir mer genomskinligt ner till 0. Detta tillämpas efter rgb_channel-extraktion om sådan används.

hint är en logisk OR av flaggorna som listas i Hint-flaggor (exklusive image.BLACK_BACKGROUND som inte stöds här).

transform är en 3x3 ndarray som används för att utföra en perspektivtransformation på bilden. Stöds för närvarande endast på OpenMV Cam N6 eftersom den har en GPU som kan göra detta i hårdvara.

copy om True skapas en djupkopia på heapen av bilden som har konverterats i stället för att konvertera originalbilden på plats.

copy_to_fb om True läses bilden in direkt i bildbufferten. copy_to_fb har företräde framför copy. Detta har ingen särskild effekt om bilden redan finns i bildbufferten.

Anteckning

Bitmappsbilder är som gråskalebilder med bara två pixelvärden - 0 och 1. Dessutom är bitmappsbilder packade så att de bara lagrar 1 bit per pixel, vilket gör dem mycket små. OpenMV-bildbiblioteket tillåter att bitmappsbilder används på alla ställen där sensor.GRAYSCALE- och sensor.RGB565-bilder kan användas. Många operationer är dock meningslösa när de tillämpas på bitmappsbilder eftersom bitmappsbilder bara har 2 värden. OpenMV rekommenderar att använda bitmappsbilder som mask-värden i operationer och liknande eftersom de får plats på MicroPython-heapen ganska enkelt. Slutligen tolkas bitmappsbildens pixelvärden 0 och 1 som svart och vitt när de tillämpas på sensor.GRAYSCALE- eller sensor.RGB565-bilder. Biblioteket hanterar konverteringen automatiskt.

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

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

Konverterar en bild till en gråskalebild (8 bitar per pixel).

roi är intresseområdets rektangeltupel (x, y, w, h) i källbilden som ska ritas. Detta låter dig extrahera bara pixlarna i ROI för att skala och rita på destinationsbilden.

hint är en logisk OR av flaggorna som listas i Hint-flaggor (exklusive image.BLACK_BACKGROUND som inte stöds här).

copy om True skapas en djupkopia på heapen av bilden som har konverterats i stället för att konvertera originalbilden på plats.

copy_to_fb om True läses bilden in direkt i bildbufferten. copy_to_fb har företräde framför copy. Detta har ingen särskild effekt om bilden redan finns i bildbufferten.

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

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

Konverterar en bild till en RGB565-bild (16 bitar per pixel).

roi är intresseområdets rektangeltupel (x, y, w, h) i källbilden som ska ritas. Detta låter dig extrahera bara pixlarna i ROI för att skala och rita på destinationsbilden.

hint är en logisk OR av flaggorna som listas i Hint-flaggor (exklusive image.BLACK_BACKGROUND som inte stöds här).

copy om True skapas en djupkopia på heapen av bilden som har konverterats i stället för att konvertera originalbilden på plats.

copy_to_fb om True läses bilden in direkt i bildbufferten. copy_to_fb har företräde framför copy. Detta har ingen särskild effekt om bilden redan finns i bildbufferten.

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

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

Konverterar en bild till en RGB565-regnbågsbild (16 bitar per pixel).

roi är intresseområdets rektangeltupel (x, y, w, h) i källbilden som ska ritas. Detta låter dig extrahera bara pixlarna i ROI för att skala och rita på destinationsbilden.

hint är en logisk OR av flaggorna som listas i Hint-flaggor (exklusive image.BLACK_BACKGROUND som inte stöds här).

copy om True skapas en djupkopia på heapen av bilden som har konverterats i stället för att konvertera originalbilden på plats.

copy_to_fb om True läses bilden in direkt i bildbufferten. copy_to_fb har företräde framför copy. Detta har ingen särskild effekt om bilden redan finns i bildbufferten.

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

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

Konverterar en bild till en RGB565-ironbow-bild (16 bitar per pixel).

roi är intresseområdets rektangeltupel (x, y, w, h) i källbilden som ska ritas. Detta låter dig extrahera bara pixlarna i ROI för att skala och rita på destinationsbilden.

hint är en logisk OR av flaggorna som listas i Hint-flaggor (exklusive image.BLACK_BACKGROUND som inte stöds här).

copy om True skapas en djupkopia på heapen av bilden som har konverterats i stället för att konvertera originalbilden på plats.

copy_to_fb om True läses bilden in direkt i bildbufferten. copy_to_fb har företräde framför copy. Detta har ingen särskild effekt om bilden redan finns i bildbufferten.

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

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

Konverterar en bild till en RGB565-djupbild (16 bitar per pixel).

roi är intresseområdets rektangeltupel (x, y, w, h) i källbilden som ska ritas. Detta låter dig extrahera bara pixlarna i ROI för att skala och rita på destinationsbilden.

color_palette om inte None kan vara image.PALETTE_DEPTH eller en RGB565-bild på totalt 256 pixlar att använda som en färguppslagstabell på gråskalevärdet för vad källbilden än är. Detta tillämpas efter rgb_channel-extraktion om sådan används.

hint är en logisk OR av flaggorna som listas i Hint-flaggor (exklusive image.BLACK_BACKGROUND som inte stöds här).

copy om True skapas en djupkopia på heapen av bilden som har konverterats i stället för att konvertera originalbilden på plats.

copy_to_fb om True läses bilden in direkt i bildbufferten. copy_to_fb har företräde framför copy. Detta har ingen särskild effekt om bilden redan finns i bildbufferten.

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

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

Konverterar en bild till en RGB565 Dark Event Image (16 bitar per pixel).

roi är intresseområdets rektangeltupel (x, y, w, h) i källbilden som ska ritas. Detta låter dig extrahera bara pixlarna i ROI för att skala och rita på destinationsbilden.

hint är en logisk OR av flaggorna som listas i Hint-flaggor (exklusive image.BLACK_BACKGROUND som inte stöds här).

copy om True skapas en djupkopia på heapen av bilden som har konverterats i stället för att konvertera originalbilden på plats.

copy_to_fb om True läses bilden in direkt i bildbufferten. copy_to_fb har företräde framför copy. Detta har ingen särskild effekt om bilden redan finns i bildbufferten.

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

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

Konverterar en bild till en RGB565 Light Event Image (16 bitar per pixel).

roi är intresseområdets rektangeltupel (x, y, w, h) i källbilden som ska ritas. Detta låter dig extrahera bara pixlarna i ROI för att skala och rita på destinationsbilden.

hint är en logisk OR av flaggorna som listas i Hint-flaggor (exklusive image.BLACK_BACKGROUND som inte stöds här).

copy om True skapas en djupkopia på heapen av bilden som har konverterats i stället för att konvertera originalbilden på plats.

copy_to_fb om True läses bilden in direkt i bildbufferten. copy_to_fb har företräde framför copy. Detta har ingen särskild effekt om bilden redan finns i bildbufferten.

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

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

Konverterar en bild till en JPEG-bild.

roi är intresseområdets rektangeltupel (x, y, w, h) i källbilden som ska ritas. Detta låter dig extrahera bara pixlarna i ROI för att skala och rita på destinationsbilden.

hint är en logisk OR av flaggorna som listas i Hint-flaggor (exklusive image.BLACK_BACKGROUND som inte stöds här).

copy om True skapas en djupkopia på heapen av bilden som har konverterats i stället för att konvertera originalbilden på plats.

copy_to_fb om True läses bilden in direkt i bildbufferten. copy_to_fb har företräde framför copy. Detta har ingen särskild effekt om bilden redan finns i bildbufferten.

quality styr komprimeringskvaliteten för jpeg-bilden. Värdet kan vara mellan 0 och 100.

subsampling kan vara:

image.JPEG_SUBSAMPLING_AUTO: Använd den bästa subsamplingen för bilden baserat på kvaliteten.

image.JPEG_SUBSAMPLING_444: Använd 4:4:4-subsampling.

image.JPEG_SUBSAMPLING_422: Använd 4:2:2-subsampling.

image.JPEG_SUBSAMPLING_420: Använd 4:2:0-subsampling.

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

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

Konverterar en bild till en PNG-bild.

roi är intresseområdets rektangeltupel (x, y, w, h) i källbilden som ska ritas. Detta låter dig extrahera bara pixlarna i ROI för att skala och rita på destinationsbilden.

hint är en logisk OR av flaggorna som listas i Hint-flaggor (exklusive image.BLACK_BACKGROUND som inte stöds här).

copy om True skapas en djupkopia på heapen av bilden som har konverterats i stället för att konvertera originalbilden på plats.

copy_to_fb om True läses bilden in direkt i bildbufferten. copy_to_fb har företräde framför copy. Detta har ingen särskild effekt om bilden redan finns i bildbufferten.

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

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

Konverterar en bild till en JPEG-bild.

roi är intresseområdets rektangeltupel (x, y, w, h) i källbilden som ska ritas. Detta låter dig extrahera bara pixlarna i ROI för att skala och rita på destinationsbilden.

hint är en logisk OR av flaggorna som listas i Hint-flaggor (exklusive image.BLACK_BACKGROUND som inte stöds här).

copy om True skapas en djupkopia på heapen av bilden som har konverterats i stället för att konvertera originalbilden på plats.

copy_to_fb om True läses bilden in direkt i bildbufferten. copy_to_fb har företräde framför copy. Detta har ingen särskild effekt om bilden redan finns i bildbufferten.

quality styr komprimeringskvaliteten för jpeg-bilden. Värdet kan vara mellan 0 och 100.

subsampling kan vara:

image.JPEG_SUBSAMPLING_AUTO: Använd den bästa subsamplingen för bilden baserat på kvaliteten.

image.JPEG_SUBSAMPLING_444: Använd 4:4:4-subsampling.

image.JPEG_SUBSAMPLING_422: Använd 4:2:2-subsampling.

image.JPEG_SUBSAMPLING_420: Använd 4:2:0-subsampling.

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

Anteckning

Image.compress är ett alias för 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¶

Skapar en djupkopia av bildobjektet.

roi är intresseområdets rektangeltupel (x, y, w, h) i källbilden som ska ritas. Detta låter dig extrahera bara pixlarna i ROI för att skala och rita på destinationsbilden.

hint är en logisk OR av flaggorna som listas i Hint-flaggor (exklusive image.BLACK_BACKGROUND som inte stöds här).

copy_to_fb om True läses bilden in direkt i bildbufferten. Detta har ingen särskild effekt om bilden redan finns i bildbufferten.

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

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

Modifierar en bild på plats utan att ändra den underliggande bildtypen.

roi är intresseområdets rektangeltupel (x, y, w, h) i källbilden som ska ritas. Detta låter dig extrahera bara pixlarna i ROI för att skala och rita på destinationsbilden.

hint är en logisk OR av flaggorna som listas i Hint-flaggor (exklusive image.BLACK_BACKGROUND som inte stöds här).

copy om True skapas en djupkopia på heapen av bilden som har konverterats i stället för att konvertera originalbilden på plats.

copy_to_fb om True läses bilden in direkt i bildbufferten. copy_to_fb har företräde framför copy. Detta har ingen särskild effekt om bilden redan finns i bildbufferten.

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

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

Modifierar en bild på plats utan att ändra den underliggande bildtypen.

roi är intresseområdets rektangeltupel (x, y, w, h) i källbilden som ska ritas. Detta låter dig extrahera bara pixlarna i ROI för att skala och rita på destinationsbilden.

hint är en logisk OR av flaggorna som listas i Hint-flaggor (exklusive image.BLACK_BACKGROUND som inte stöds här).

copy om True skapas en djupkopia på heapen av bilden som har konverterats i stället för att konvertera originalbilden på plats.

copy_to_fb om True läses bilden in direkt i bildbufferten. copy_to_fb har företräde framför copy. Detta har ingen särskild effekt om bilden redan finns i bildbufferten.

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

Anteckning

Image.scale är ett alias för Image.crop.

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

Sparar en kopia av bilden i filsystemet på path.

Stöder bmp/pgm/ppm/jpg/jpeg-bildfiler. Observera att du inte kan spara jpeg-komprimerade bilder i ett okomprimerat format.

roi är intresseområdets rektangel (x, y, w, h) att spara från. Om den inte anges är den lika med bildrektangeln, vilket kopierar hela bilden. Detta argument är inte tillämpligt för JPEG-bilder.

quality är jpeg-komprimeringskvaliteten som ska användas för att spara bilden i jpeg-format om bilden inte redan är komprimerad (0-100) (int).

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

flush() → None¶: Uppdaterar bildbufferten i IDE:n med bilden i bildbufferten på kameran.

Ritmetoder¶

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

Sätter alla pixlar i bilden till noll (mycket snabbt).

mask är en annan bild som ska användas som en mask på pixelnivå för operationen. Masken bör vara en bild med bara svarta eller vita pixlar och bör ha samma storlek som bilden som operationen utförs på. Endast pixlar som är satta i masken modifieras.

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

Stöds inte på komprimerade bilder.

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

Ritar en linje från (x0, y0) till (x1, y1) på bilden. Du kan antingen skicka x0, y0, x1, y1 var för sig eller som en tupel (x0, y0, x1, y1).

color är en RGB888-tupel för gråskale- eller RGB565-bilder. Standardvärdet är vitt. Du kan dock även skicka det underliggande pixelvärdet (0-255) för gråskalebilder eller ett RGB565-värde för RGB565-bilder.

thickness styr hur tjock linjen är i pixlar.

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

Stöds inte på komprimerade bilder eller bayerbilder.

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¶

Ritar en rektangel på bilden. Du kan antingen skicka x, y, w, h var för sig eller som en tupel (x, y, w, h).

thickness styr hur tjocka linjerna är i pixlar.

Skicka fill satt till True för att fylla rektangeln.

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

Stöds inte på komprimerade bilder eller bayerbilder.

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

Ritar en cirkel på bilden. Du kan antingen skicka x, y, radius var för sig eller som en tupel (x, y, radius).

thickness styr hur tjocka kanterna är i pixlar.

Skicka fill satt till True för att fylla cirkeln.

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

Stöds inte på komprimerade bilder eller bayerbilder.

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¶

Ritar en ellips på bilden. Du kan antingen skicka cx, cy, rx, ry och rotationen (i grader) var för sig eller som en tupel (cx, yc, rx, ry, rotation).

thickness styr hur tjocka kanterna är i pixlar.

Skicka fill satt till True för att fylla ellipsen.

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

Stöds inte på komprimerade bilder eller bayerbilder.

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¶

Ritar 8x10-text med start på platsen (x, y) i bilden. Du kan antingen skicka x, y var för sig eller som en tupel (x, y).

text är en sträng som ska skrivas till bilden. Radslut med \n, \r och \r\n flyttar markören till nästa rad.

scale kan ökas för att öka/minska storleken på texten på bilden. Du kan skicka heltals- eller flyttalsvärden större än 0.

x_spacing låter dig lägga till (om positivt) eller dra ifrån (om negativt) x-pixlar mellan tecken.

y_spacing låter dig lägga till (om positivt) eller dra ifrån (om negativt) y-pixlar mellan tecken (för flerradig text).

mono_space är som standard True vilket tvingar texten att vara fast åtskild. För stora textskalor ser detta hemskt ut. Sätt till False för att få teckenavstånd med icke-fast bredd, vilket ser MYCKET bättre ut.

char_rotation kan vara 0, 90, 180, 270 för att rotera varje tecken i strängen med detta belopp.

char_hmirror om True speglas alla tecken i strängen horisontellt.

char_vflip om True vänds alla tecken i strängen vertikalt.

string_rotation kan vara 0, 90, 180, 270 för att rotera strängen med detta belopp.

string_hmirror om True speglas strängen horisontellt.

string_vflip om True vänds strängen vertikalt.

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

Stöds inte på komprimerade bilder eller bayerbilder.

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

Ritar ett kors på platsen x, y. Du kan antingen skicka x, y var för sig eller som en tupel (x, y).

size styr hur långt korsets linjer sträcker sig.

thickness styr hur tjocka kanterna är i pixlar.

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

Stöds inte på komprimerade bilder eller bayerbilder.

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

Ritar en pil från (x0, y0) till (x1, y1) på bilden. Du kan antingen skicka x0, y0, x1, y1 var för sig eller som en tupel (x0, y0, x1, y1).

thickness styr hur tjock linjen är i pixlar.

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

Stöds inte på komprimerade bilder eller bayerbilder.

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¶

Ritar ett detekteringsresultat på bilden. detection är en 6-tupel (rx, ry, rw, rh, cx, cy) som beskriver en begränsande rektangel och ett tyngdpunktscentrum (returneras vanligtvis av NN- eller färgspårningskod).

color1 är rektangelfärgen och color2 är färgen på tyngdpunktskorset. size är storleken på tyngdpunktskorset, thickness styr konturbredden och fill fyller rektangeln.

label om den anges ritas nära rektangeln, förskjuten med label_offset (x, y).

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

Stöds inte på komprimerade bilder eller bayerbilder.

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¶

Ritar linjekanter mellan en hörnlista som returneras av metoder som blob.corners. Corners är en tupel med fyra värden av tvåvärdiga x/y-tupler. T.ex. [(x1,y1),(x2,y2),(x3,y3),(x4,y4)].

size om större än 0 gör att hörnen ritas som cirklar med radien size.

thickness styr hur tjock linjen är i pixlar.

Skicka fill satt till True för att fylla hörncirklarna om de ritas.

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

Stöds inte på komprimerade bilder eller bayerbilder.

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¶

Ritar en image vars övre vänstra hörn börjar på platsen x, y. Du kan antingen skicka x, y var för sig eller som en tupel (x, y). Denna metod hanterar automatiskt rendering av den skickade bilden till rätt pixelformat för destinationsbilden samtidigt som den hanterar beskärning sömlöst.

Du kan även skicka en sökväg i stället för ett bildobjekt till denna metod för att automatiskt läsa in bilden från disk och använda den i ett steg. T.ex. draw_image("test.jpg").

roi är intresseområdets rektangeltupel (x, y, w, h) i källbilden som ska ritas. Detta låter dig extrahera bara pixlarna i ROI för att skala och rita på destinationsbilden.

hint är en logisk OR av flaggorna som listas i Hint-flaggor (inklusive image.BLACK_BACKGROUND som stöds här).

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

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

Ritar nyckelpunkterna i ett keypoints-objekt på bilden. Du kan även skicka en lista med trevärdiga tupler som innehåller (x, y, rotation_angle_in_degrees) för att återanvända denna metod för att rita nyckelpunktsglyfer, vilka är en cirkel med en linje som pekar i en viss riktning.

size styr hur stora nyckelpunkterna är.

thickness styr hur tjock linjen är i pixlar.

Skicka fill satt till True för att fylla nyckelpunkterna.

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

Stöds inte på komprimerade bilder eller bayerbilder.

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¶

Flödesfyller en region i bilden med start från platsen x, y. Du kan antingen skicka x, y var för sig eller som en tupel (x, y).

seed_threshold styr hur olik någon pixel i fyllningsområdet får vara från den ursprungliga startpixeln.

floating_threshold styr hur olik någon pixel i fyllningsområdet får vara från någon grannpixel.

Skicka invert som True för att färga om allt utanför det flödesfyllda sammanhängande området.

Skicka clear_background som True för att nollställa resten av pixlarna som flödesfyllningen inte färgade om.

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

Stöds inte på komprimerade bilder eller bayerbilder.

Denna metod är inte tillgänglig på OpenMV Cam M4.

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

Rastrerar en händelse-ndarray (som fylld av csi.IOCTL_GENX320_READ_EVENTS) på en Image för visualisering. Bildbufferten måste vara en 320x320 GRAYSCALE-bild.

För varje csi.PIX_ON_EVENT-rad får händelsens pixel +contrast adderat; för varje csi.PIX_OFF_EVENT-rad får pixeln -contrast. Triggerhändelser ignoreras. Pixelvärden klampas till 0-255.

clear om True återställs bildbufferten till brightness före ritning — varje bildruta blir en ny rendering med enbart händelser. Sätt till False för att ackumulera händelser över flera anrop (användbart för rörelsespår med lång exponering).

brightness styr den mellangrå baslinjen som bufferten återställs till när clear är True. Standardvärdet 128 placerar ON-händelser i den ljusa änden och OFF-händelser i den mörka änden med lika stort spelrum.

contrast styr hur mycket varje händelse förskjuter sin pixel — högre värden gör att händelser sticker ut, på bekostnad av att snabbt mättas när många händelser landar på samma pixel.

Maskeringsmetoder¶

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

Nollställer en rektangulär del av bilden. Om inga argument anges nollställer denna metod bildens centrum.

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

Stöds inte på komprimerade bilder eller bayerbilder.

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

Nollställer en cirkulär del av bilden. Om inga argument anges nollställer denna metod bildens centrum.

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

Stöds inte på komprimerade bilder eller bayerbilder.

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

Nollställer en ellipsformad del av bilden. Om inga argument anges nollställer denna metod bildens centrum.

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

Stöds inte på komprimerade bilder eller bayerbilder.

Binära metoder¶

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

Sätter alla pixlar i bilden till svart eller vitt beroende på om varje pixel ligger inom en av tröskelvärdestuplerna i thresholds.

thresholds är en lista med (lo, hi)-tupler för gråskalebilder, eller (l_lo, l_hi, a_lo, a_hi, b_lo, b_hi)-tupler för RGB565-bilder. Omkastade min/max-värden korrigeras automatiskt; saknade komponenter får som standard maximalt intervall.

invert inverterar tröskelmatchningen.

zero om True nollställs trösklade pixlar och övriga lämnas orörda.

mask är en binär bild som används som en mask på pixelnivå; endast pixlar som är satta i masken modifieras.

to_bitmap om True konverteras bilddatan till en bitmapp med 1 bit per pixel. För mycket små bilder kan detta kräva copy=True.

copy om True returneras en ny bild på heapen i stället för att modifiera källbilden.

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

Stöds inte på komprimerade bilder eller bayerbilder.

invert() → Image¶

Inverterar alla pixelvärden i bilden (varje pixel blir 255 - pixel för 8-bitarskanaler).

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

Stöds inte på komprimerade bilder eller bayer-/yuv-bilder.

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

Utför logisk AND mellan denna bild och en annan bild.

image kan vara ett bildobjekt, en sökväg till en okomprimerad bildfil (bmp/pgm/ppm) eller ett skalärt värde (RGB888-tupel eller underliggande pixelvärde).

mask är en binär bild som används som en mask på pixelnivå; endast pixlar som är satta i masken modifieras.

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

Stöds inte på komprimerade bilder eller bayerbilder.

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

Utför logisk NAND mellan denna bild och en annan bild.

image kan vara ett bildobjekt, en sökväg till en okomprimerad bildfil (bmp/pgm/ppm) eller ett skalärt värde (RGB888-tupel eller underliggande pixelvärde).

mask är en binär bild som används som en mask på pixelnivå; endast pixlar som är satta i masken modifieras.

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

Stöds inte på komprimerade bilder eller bayerbilder.

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

Utför logisk OR mellan denna bild och en annan bild.

image kan vara ett bildobjekt, en sökväg till en okomprimerad bildfil (bmp/pgm/ppm) eller ett skalärt värde (RGB888-tupel eller underliggande pixelvärde).

mask är en binär bild som används som en mask på pixelnivå; endast pixlar som är satta i masken modifieras.

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

Stöds inte på komprimerade bilder eller bayerbilder.

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

Utför logisk NOR mellan denna bild och en annan bild.

image kan vara ett bildobjekt, en sökväg till en okomprimerad bildfil (bmp/pgm/ppm) eller ett skalärt värde (RGB888-tupel eller underliggande pixelvärde).

mask är en binär bild som används som en mask på pixelnivå; endast pixlar som är satta i masken modifieras.

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

Stöds inte på komprimerade bilder eller bayerbilder.

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

Utför logisk XOR mellan denna bild och en annan bild.

image kan vara ett bildobjekt, en sökväg till en okomprimerad bildfil (bmp/pgm/ppm) eller ett skalärt värde (RGB888-tupel eller underliggande pixelvärde).

mask är en binär bild som används som en mask på pixelnivå; endast pixlar som är satta i masken modifieras.

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

Stöds inte på komprimerade bilder eller bayerbilder.

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

Utför logisk XNOR mellan denna bild och en annan bild.

image kan vara ett bildobjekt, en sökväg till en okomprimerad bildfil (bmp/pgm/ppm) eller ett skalärt värde (RGB888-tupel eller underliggande pixelvärde).

mask är en binär bild som används som en mask på pixelnivå; endast pixlar som är satta i masken modifieras.

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

Stöds inte på komprimerade bilder eller bayerbilder.

ISP-metoder¶

awb(max: bool = False) → Image¶

Utför automatisk vitbalans på bilden med grå-världen-algoritmen. Arbetar på RAW Bayer- eller RGB565-bilder. Har ingen effekt på binära/gråskalebilder.

max om True används vit-fläck-algoritmen i stället.

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

Stöds inte på komprimerade eller yuv-bilder.

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

Multiplicerar den skickade flyttals-färgkorrigeringsmatrisen med bilden. Matriser kan vara 3x3 eller 3x4 (med offsetkolumn), i nästlad listform eller platt listform:

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

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

Stöds inte på komprimerade bilder eller bayer-/yuv-bilder.

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

Justerar bildens gamma, kontrast och ljusstyrka.

gamma tillämpar pow(pixel, 1/gamma) efter normalisering. Värden större än 1.0 gör ljusare; mindre än 1.0 gör mörkare.

contrast tillämpar pixel * contrast efter normalisering.

brightness tillämpar pixel + brightness efter normalisering.

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

Stöds inte på komprimerade eller bayer-/yuv-bilder.

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

Matematiska metoder¶

negate() → Image¶: Alias för Image.invert.

replace(image: Image | None = None, **kwargs) → Image¶: Alias för Image.draw_image(). Ersätter denna bild med image (eller transformerar denna bild på plats om image utelämnas) med standardnyckelordsargumenten för draw_image. Argumentet transform är en 3x3 ndarray som beskriver en perspektivtransformation (stöds endast på OpenMV-kameror med ULAB aktiverat).

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

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

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

Adderar en bild pixelvis till denna.

image kan vara ett bildobjekt, en sökväg till en okomprimerad bildfil (bmp/pgm/ppm) eller ett skalärt värde (RGB888-tupel eller underliggande pixelvärde).

mask är en binär bild som används som en mask på pixelnivå; endast pixlar som är satta i masken modifieras.

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

Stöds inte på komprimerade bilder eller bayerbilder.

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

Subtraherar image pixelvis från denna bild (self - image).

image kan antingen vara ett bildobjekt, en sökväg till en okomprimerad bildfil (bmp/pgm/ppm) eller ett skalärt värde (RGB888-tupel eller underliggande pixelvärde).

mask är en binär bild som används som en mask på pixelnivå; endast pixlar som är satta i masken modifieras.

Denna metod accepterar även hela uppsättningen av nyckelordsargument för Image.draw_image() (x, y, x_scale, y_scale, roi, rgb_channel, alpha, color_palette, alpha_palette, hint, transform).

Stöds inte på komprimerade bilder eller bayerbilder.

rsub(image: Image, mask: Image | None = None) → Image¶: Omvänd subtraktion: ersätter denna bild med image - self pixelvis. I övrigt identisk med Image.sub().

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

Returnerar den minsta bilden av två bilder pixelvis.

image kan vara ett bildobjekt, en sökväg till en okomprimerad bildfil (bmp/pgm/ppm) eller ett skalärt värde (RGB888-tupel eller underliggande pixelvärde).

mask är en binär bild som används som en mask på pixelnivå; endast pixlar som är satta i masken modifieras.

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

Stöds inte på komprimerade bilder eller bayerbilder.

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

Returnerar den största bilden av två bilder pixelvis.

image kan vara ett bildobjekt, en sökväg till en okomprimerad bildfil (bmp/pgm/ppm) eller ett skalärt värde (RGB888-tupel eller underliggande pixelvärde).

mask är en binär bild som används som en mask på pixelnivå; endast pixlar som är satta i masken modifieras.

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

Stöds inte på komprimerade bilder eller bayerbilder.

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

Returnerar bilden med den absoluta differensen mellan två bilder (t.ex. ||a-b||).

image kan vara ett bildobjekt, en sökväg till en okomprimerad bildfil (bmp/pgm/ppm) eller ett skalärt värde (RGB888-tupel eller underliggande pixelvärde).

mask är en binär bild som används som en mask på pixelnivå; endast pixlar som är satta i masken modifieras.

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

Stöds inte på komprimerade bilder eller bayerbilder.

blend(image: Image, x: int = 0, y: int = 0, alpha: int = 128, mask: Image | None = None, **kwargs) → Image¶: Alias för Image.draw_image(). Alfablandar image in i denna bild. alpha är ett heltal 0-256; värden närmare 256 gynnar källbilden. Accepterar alla nyckelordsargument för Image.draw_image().

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

Kör histogramutjämning på bilden för att normalisera kontrast och ljusstyrka.

adaptive om True körs adaptiv histogramutjämning (långsammare men generellt bättre).

clip_limit begränsar kontrasten i den adaptiva varianten (ett litet värde som 10 ger bra CLAHE-resultat).

mask är en binär bild som används som en mask på pixelnivå; endast pixlar som är satta i masken modifieras.

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

Stöds inte på komprimerade bilder eller bayerbilder.

Filtreringsmetoder¶

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

Tar bort pixlar från kanterna på segmenterade områden. Konvolverar en ((size*2)+1)x((size*2)+1)-kärna över bilden och rensar mittpixeln om fler än threshold grannar är rensade (fungerar som standard-erodering om threshold är None).

mask är en binär bild som används som en mask på pixelnivå; endast pixlar som är satta i masken modifieras.

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

Stöds inte på komprimerade bilder eller bayer-/yuv-bilder.

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

Lägger till pixlar på kanterna av segmenterade områden. Konvolverar en ((size*2)+1)x((size*2)+1)-kärna över bilden och sätter mittpixeln om fler än threshold grannar är satta (fungerar som standard-dilatering om threshold är None).

mask är en binär bild som används som en mask på pixelnivå; endast pixlar som är satta i masken modifieras.

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

Stöds inte på komprimerade bilder eller bayer-/yuv-bilder.

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

Utför erodering och sedan dilatering. Se Image.erode() och Image.dilate().

mask är en binär bild som används som en mask på pixelnivå; endast pixlar som är satta i masken modifieras.

Stöds inte på komprimerade bilder eller bayer-/yuv-bilder.

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

Utför dilatering och sedan erodering. Se Image.dilate() och Image.erode().

mask är en binär bild som används som en mask på pixelnivå; endast pixlar som är satta i masken modifieras.

Stöds inte på komprimerade bilder eller bayer-/yuv-bilder.

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

Returnerar bilddifferensen mellan bilden och den Image.open()-ade bilden.

mask är en binär bild som används som en mask på pixelnivå; endast pixlar som är satta i masken modifieras.

Stöds inte på komprimerade bilder eller bayer-/yuv-bilder.

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

Returnerar bilddifferensen mellan bilden och den Image.close()-ade bilden.

mask är en binär bild som används som en mask på pixelnivå; endast pixlar som är satta i masken modifieras.

Stöds inte på komprimerade bilder eller bayer-/yuv-bilder.

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

Standardfilter för medelvärdesoskärpa med ett boxfilter.

size är kärnstorleken. Använd 1 (3x3-kärna), 2 (5x5-kärna) o.s.v.

threshold om True trösklas filterutdatan adaptivt till en binär bild. offset förskjuter binariseringen (negativt gör fler pixlar vita, positivt gör färre). invert inverterar den binära utdatan.

mask är en binär bild som används som en mask på pixelnivå; endast pixlar som är satta i masken modifieras.

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

Stöds inte på komprimerade bilder eller bayer-/yuv-bilder.

Kör ett percentilfilter på bilden (median som standard).

size är kärnstorleken. Använd 1 (3x3-kärna), 2 (5x5-kärna) o.s.v.

percentile är percentilen som ska väljas från varje kärna (0 = min, 0.5 = median, 1.0 = max). Standardvärdet är 0.5.

mask är en binär bild som används som en mask på pixelnivå; endast pixlar som är satta i masken modifieras.

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

Stöds inte på komprimerade bilder eller bayer-/yuv-bilder.

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

Ersätter varje pixel med typvärdet (mode) för dess grannar. Kan ge artefakter på kanterna i RGB-bilder på grund av den icke-linjära operationen.

size är kärnstorleken. Använd 1 (3x3-kärna), 2 (5x5-kärna) o.s.v.

mask är en binär bild som används som en mask på pixelnivå; endast pixlar som är satta i masken modifieras.

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

Stöds inte på komprimerade bilder eller bayer-/yuv-bilder.

Kör mittpunktsfiltret på bilden. Detta filter hittar mittpunkten ((max-min)/2) i varje pixels grannskap i bilden.

size är kärnstorleken. Använd 1 (3x3-kärna), 2 (5x5-kärna) o.s.v.

bias styr min/max-blandningen. 0 för enbart min-filtrering, 1.0 för enbart max-filtrering. Genom att använda bias kan du min/max-filtrera bilden.

mask är en binär bild som används som en mask på pixelnivå; endast pixlar som är satta i masken modifieras.

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

Stöds inte på komprimerade bilder eller bayer-/yuv-bilder.

Konvolverar bilden med en godtycklig filterkärna.

size styr kärnstorleken, som måste vara ((size*2)+1)x((size*2)+1) element.

kernel är kärnan att konvolvera med, som en platt 1D-lista/tupel med ((size*2)+1)*((size*2)+1) element, eller som en 2D-lista/tupel med ((size*2)+1) rader om ((size*2)+1) element.

mul är en multiplikativ kontrastskala (standard 1.0).

add är en additiv ljusstyrkeoffset (standard 0.0).

mask är en binär bild som används som en mask på pixelnivå; endast pixlar som är satta i masken modifieras.

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

Stöds inte på komprimerade bilder eller bayer-/yuv-bilder.

Konvolverar bilden med en utjämnande gauss-kärna.

size är kärnstorleken. Använd 1 (3x3-kärna), 2 (5x5-kärna) o.s.v.

unsharp om True utförs en oskarp maskering (skärper kanter) i stället för en vanlig gauss.

mul är en multiplikativ kontrastskala (standard 1.0).

add är en additiv ljusstyrkeoffset (standard 0.0).

mask är en binär bild som används som en mask på pixelnivå; endast pixlar som är satta i masken modifieras.

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

Stöds inte på komprimerade bilder eller bayer-/yuv-bilder.

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¶: Konvolverar bilden med en kantdetekterande laplace-kärna.

size är kärnstorleken. Använd 1 (3x3-kärna), 2 (5x5-kärna) o.s.v.

sharpen om True skärps bilden i stället för att mata ut det råa otrösklade kantgensvaret.

mul är en multiplikativ kontrastskala (standard 1.0).

add är en additiv ljusstyrkeoffset (standard 0.0).

threshold om True trösklas filterutdatan adaptivt till en binär bild. offset förskjuter binariseringen (negativt gör fler pixlar vita, positivt gör färre). invert inverterar den binära utdatan.

mask är en binär bild som används som en mask på pixelnivå; endast pixlar som är satta i masken modifieras.

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

Stöds inte på komprimerade bilder eller bayer-/yuv-bilder.

Konvolverar bilden med ett bilateralt filter (kantbevarande utjämning).

size är kärnstorleken. Använd 1 (3x3-kärna), 2 (5x5-kärna) o.s.v.

color_sigma styr toleransen för färgmatchning; större värden ger mer färgoskärpa.

space_sigma styr rumslig oskärpa; större värden ger mer pixeloskärpa.

mask är en binär bild som används som en mask på pixelnivå; endast pixlar som är satta i masken modifieras.

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

Stöds inte på komprimerade bilder eller bayer-/yuv-bilder.

Geometriska metoder¶

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

Omprojicerar en bild från kartesiska koordinater till linjära polära koordinater.

Sätt reverse=True för att omprojicera i motsatt riktning.

x och y anger transformens centrumkoordinat i bildpixlar. Om x är None (standard) sätts den till halva bildbredden; på samma sätt får y som standard halva bildhöjden.

Linjär polär omprojektion förvandlar rotation av en bild till x-förflyttning.

Stöds inte på komprimerade bilder eller bayerbilder.

Denna metod är inte tillgänglig på OpenMV Cam M4.

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

Omprojicerar en bild från kartesiska koordinater till logaritmiska polära koordinater.

Sätt reverse=True för att omprojicera i motsatt riktning.

x och y anger transformens centrumkoordinat i bildpixlar. Om x är None (standard) sätts den till halva bildbredden; på samma sätt får y som standard halva bildhöjden.

Logaritmisk polär omprojektion förvandlar rotation av en bild till x-förflyttning och skalning/zoomning till y-förflyttning.

Stöds inte på komprimerade bilder eller bayerbilder.

Denna metod är inte tillgänglig på OpenMV Cam M4.

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

Utför linskorrigering för att av-fiskögea bilden på grund av linsförvrängningen.

strength är ett flyttal som definierar hur mycket bilden ska av-fiskögeas. Prova 1.8 som standard och öka eller minska därifrån tills bilden ser bra ut.

zoom är hur mycket som ska zoomas in på bilden. 1.0 som standard.

x_corr flyttals-pixeloffset från centrum. Kan vara negativ eller positiv.

y_corr flyttals-pixeloffset från centrum. Kan vara negativ eller positiv.

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

Stöds inte på komprimerade bilder eller bayerbilder.

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¶

Korrigerar perspektivproblem i bilden genom att göra en 3D-rotation av bildbufferten.

x_rotation är antalet grader att rotera bilden i bildbufferten kring x-axeln (d.v.s. detta snurrar bilden upp och ner).

y_rotation är antalet grader att rotera bilden i bildbufferten kring y-axeln (d.v.s. detta snurrar bilden åt vänster och höger).

z_rotation är antalet grader att rotera bilden i bildbufferten kring z-axeln (d.v.s. detta snurrar bilden på plats).

x_translation är antalet enheter att flytta bilden åt vänster eller höger efter rotation. Eftersom denna förflyttning tillämpas i 3D-rymden är enheterna inte pixlar…

y_translation är antalet enheter att flytta bilden uppåt eller nedåt efter rotation. Eftersom denna förflyttning tillämpas i 3D-rymden är enheterna inte pixlar…

zoom är hur mycket som ska zoomas in på bilden. 1.0 som standard.

fov är synfältet som används för den interna 2D->3D-projektionen. När fov närmar sig 0 placeras bilden i oändligheten; när det närmar sig 180 placeras bilden inuti vyporten.

corners är en lista med fyra (x, y)-tupler som används för att bygga en 4-punkts homografi som mappar hörnen till (0, 0), (image_width-1, 0), (image_width-1, image_height-1) och (0, image_height-1) innan 3D-rotationen tillämpas. Användbart för fågelperspektivtransformer.

Returnerar bildobjektet så att du kan anropa en annan metod med .-notation.

Stöds inte på komprimerade bilder eller bayerbilder.

Denna metod är inte tillgänglig på OpenMV Cam M4.

Get-metoder¶

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¶

Beräknar likheten mellan två bilder med hjälp av Structural Similarity Index (SSIM). SSIM sträcker sig från -1 (motsatt) till 1 (identisk). Returnerar ett image.similarity-objekt.

image är bilden att jämföra med (ett bildobjekt eller en sökvägssträng, t.ex. "test.jpg").

x, y, x_scale, y_scale, roi, rgb_channel, alpha, color_palette, alpha_palette, hint och transform accepterar samma värden som Image.draw_image().

dssim om True returneras Structural Dissimilarity Index (DSSIM) i stället, där 0 betyder identisk och 1 betyder helt olika.

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¶

Beräknar det normaliserade histogrammet på alla färgkanaler för en roi och returnerar ett image.histogram-objekt. Finns även tillgänglig som Image.get_hist() eller Image.histogram().

thresholds är en lista med (lo, hi)-tupler för gråskalebilder, eller (l_lo, l_hi, a_lo, a_hi, b_lo, b_hi)-tupler för RGB565-bilder. Om den skickas beräknas histogrammet endast över pixlar inom tröskelvärdena.

invert inverterar tröskelmatchningen.

roi är intresseområdets rektangeltupel (x, y, w, h). Standardvärdet är bildrektangeln.

bins (gråskala) eller l_bins/a_bins/b_bins (RGB565) anger antalet histogramfack per kanal. Måste vara större än 2. Standardvärdet är det maximala antalet fack per kanal.

difference kan sättas till ett bildobjekt för att arbeta på differensen mellan den aktuella bilden och den bilden utan en extra buffert.

Stöds inte på komprimerade bilder eller bayerbilder.

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¶

Beräknar medelvärde, median, typvärde, standardavvikelse, min, max, nedre kvartil och övre kvartil för alla färgkanaler för en roi och returnerar ett image.statistics-objekt. Finns även tillgänglig som Image.get_stats() eller Image.statistics().

thresholds är en lista med (lo, hi)-tupler för gråskalebilder, eller (l_lo, l_hi, a_lo, a_hi, b_lo, b_hi)-tupler för RGB565-bilder. Om den skickas beräknas statistiken endast över pixlar inom tröskelvärdena.

invert inverterar tröskelmatchningen.

roi är intresseområdets rektangeltupel (x, y, w, h). Standardvärdet är bildrektangeln.

bins (gråskala) eller l_bins/a_bins/b_bins (RGB565) anger antalet histogramfack per kanal. Måste vara större än 2. Standardvärdet är det maximala antalet fack per kanal.

difference kan sättas till ett bildobjekt för att arbeta på differensen mellan den aktuella bilden och den bilden utan en extra buffert.

Stöds inte på komprimerade bilder eller bayerbilder.

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¶

Beräknar en linjär regression (Theil-Sen) på alla trösklade pixlar i bilden. Returnerar ett image.line-objekt, eller None om ingen linje hittades.

thresholds är en lista med (lo, hi)-tupler för gråskalebilder, eller (l_lo, l_hi, a_lo, a_hi, b_lo, b_hi)-tupler för RGB565-bilder.

invert inverterar tröskelmatchningen.

roi är intresseområdets rektangeltupel (x, y, w, h). Standardvärdet är bildrektangeln.

x_stride och y_stride styr hur många pixlar som hoppas över under utvärderingen av bilden.

area_threshold minsta begränsningsrutearea; mindre resultat returnerar None.

pixels_threshold minsta antal trösklade pixlar; mindre resultat returnerar None.

target_size är en (w, h)-tupel. ROI:n ytskalas ned för att få plats inom denna storlek innan O(N^2)-algoritmen körs. Standardvärdet är (80, 60).

Stöds inte på komprimerade bilder eller bayerbilder.

Detekteringsmetoder¶

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

Hittar alla blobbar (sammanhängande pixelregioner som klarar ett tröskeltest) i bilden och returnerar en lista med image.blob-objekt.

thresholds är en lista med (lo, hi)-tupler för gråskalebilder, eller (l_lo, l_hi, a_lo, a_hi, b_lo, b_hi)-tupler för RGB565-bilder (LAB-kanaler). Upp till 32 tupler kan skickas. Omkastade min/max-värden korrigeras automatiskt; saknade komponenter får som standard maximalt intervall.

invert inverterar tröskelmatchningen.

roi är intresseområdets rektangeltupel (x, y, w, h). Standardvärdet är bildrektangeln.

x_stride och y_stride styr hur många pixlar som hoppas över vid sökning efter en blob. Öka om blobbarna är kända för att vara stora.

area_threshold minsta begränsningsrutearea; mindre blobbar filtreras bort.

pixels_threshold minsta antal trösklade pixlar; mindre blobbar filtreras bort.

merge om True slås blobbar vars begränsningsrektanglar överlappar samman. margin förstorar/förminskar begränsningsrektanglarna som används för överlappning. Sammanslagna blobbar utför OR mellan sina code-bitvektorer (en bit per tröskelvärde).

threshold_cb anropas per blob efter tröskling; returnera True för att behålla, False för att filtrera bort.

merge_cb anropas per par av blobbar som ska slås samman; returnera True för att tillåta sammanslagningen, False för att förhindra den.

x_hist_bins_max om skild från noll fylls varje blob med en x_histogram-projektion med så här många fack.

y_hist_bins_max om skild från noll fylls varje blob med en y_histogram-projektion med så här många fack.

Stöds inte på komprimerade bilder eller bayerbilder.

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

Hittar alla oändliga linjer i bilden med hjälp av hough-transformen. Returnerar en lista med image.line-objekt.

roi är intresseområdets rektangeltupel (x, y, w, h). Standardvärdet är bildrektangeln.

x_stride och y_stride styr hur många pixlar som hoppas över under hough-transformen.

threshold minsta linjemagnitud (summan av sobel-magnituder längs linjen); linjer under detta filtreras bort.

theta_margin och rho_margin styr sammanslagningen: linjer inom dessa tröskelvärden slås samman.

Stöds inte på komprimerade bilder eller bayerbilder.

Denna metod är inte tillgänglig på 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]¶

Hittar linjesegment i bilden. Returnerar en lista med image.line-objekt.

roi är intresseområdets rektangeltupel (x, y, w, h). Standardvärdet är bildrektangeln.

merge_distance är det maximala pixelavståndet mellan två segment för att de ska slås samman.

max_theta_difference är den maximala theta-skillnaden i grader mellan segment för att de ska slås samman.

Denna metod är inte tillgänglig på 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]¶

Hittar cirklar i bilden med hjälp av hough-transformen. Returnerar en lista med image.circle-objekt.

roi är intresseområdets rektangeltupel (x, y, w, h). Standardvärdet är bildrektangeln.

x_stride och y_stride styr hur många pixlar som hoppas över under hough-transformen.

threshold minsta cirkelmagnitud (summan av sobel-magnituder längs cirkeln); cirklar under detta filtreras bort.

x_margin, y_margin och r_margin styr sammanslagningen: cirklar inom dessa tröskelvärden slås samman.

r_min minsta cirkelradie. Standardvärdet är 2.

r_max största cirkelradie. Standardvärdet är min(roi.w/2, roi.h/2).

r_step radiesteglängd. Standardvärdet är 2.

Denna metod är inte tillgänglig på OpenMV Cam M4.

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

Hittar rektanglar i bilden med hjälp av apriltag-kvaddetekteringsalgoritmen. Returnerar en lista med image.rect-objekt.

roi är intresseområdets rektangeltupel (x, y, w, h). Standardvärdet är bildrektangeln.

threshold minsta kantmagnitud (summan av sobel-magnituder längs rektangelkanterna); rektanglar under detta filtreras bort.

Denna metod är inte tillgänglig på OpenMV Cam M4.

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

Hittar alla qrcodes inom roi och returnerar en lista med image.qrcode-objekt.

roi är intresseområdets rektangeltupel (x, y, w, h). Standardvärdet är bildrektangeln.

Denna metod är inte tillgänglig på OpenMV Cam M4.

Hittar alla apriltags inom roi och returnerar en lista med image.apriltag-objekt.

roi är intresseområdets rektangeltupel (x, y, w, h). Standardvärdet är bildrektangeln.

families är en bitmask av taggfamiljer att avkoda. Den är den logiska OR av:

image.TAG16H5

image.TAG25H9

image.TAG36H10

image.TAG36H11

image.TAGCIRCLE21H7

image.TAGCIRCLE49H12

image.TAGCUSTOM48H12

image.TAGSTANDARD41H12

image.TAGSTANDARD52H13

Standardvärdet är image.TAG36H11. Detekteringstiden skalar med antalet aktiverade familjer.

fx och fy är kamerans X- och Y-fokallängder i pixlar.

cx och cy är bildens centrum, vanligtvis image.width()/2 och image.height()/2.

Stöds inte på komprimerade bilder.

Denna metod är inte tillgänglig på OpenMV Cam M4.

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

Hittar alla datamatriser inom roi och returnerar en lista med image.datamatrix-objekt.

roi är intresseområdets rektangeltupel (x, y, w, h). Standardvärdet är bildrektangeln.

effort styr hur mycket tid som läggs på att försöka hitta datamatris-matchningar. Högre värden förbättrar detekteringen på bekostnad av bildrutehastigheten. Värden under ~160 misslyckas med att detektera; värden över ~240 ger avtagande avkastning. Standardvärdet är 200.

Denna metod är inte tillgänglig på OpenMV Cam M4.

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

Hittar alla 1D-streckkoder inom roi och returnerar en lista med image.barcode-objekt. Skannar både horisontellt och vertikalt.

Streckkodstyper som stöds: 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 är intresseområdets rektangeltupel (x, y, w, h). Standardvärdet är bildrektangeln.

Denna metod är inte tillgänglig på 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¶

Hittar förflyttningsoffseten för denna bild från template med hjälp av faskorrelation. Returnerar ett image.displacement-objekt.

roi är intresseområdets rektangel (x, y, w, h). Standardvärdet är bildrektangeln.

template_roi är mallens intresseområde. Standardvärdet är mallbildens rektangel. roi och template_roi måste ha samma bredd och höjd.

logpolar om True returneras rotations-/skaländring i stället för x/y-förflyttning.

fix_rotation_scale om True beräknas förflyttningen efter att rotation och skala har justerats (endast meningsfullt när logpolar=False).

Anteckning

Använd denna metod på bildstorlekar som är potenser av 2 (t.ex. sensor.B64X64).

Stöds inte på komprimerade bilder eller bayerbilder. Inte tillgänglig på 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¶

Försöker hitta den första platsen i bilden där template matchar med hjälp av normaliserad korskorrelation. Returnerar en begränsningsrutetupel (x, y, w, h), eller None.

template är en gråskalebild att matcha mot denna bild.

threshold är ett värde (0.0-1.0). Högre värden minskar falska positiva och detekteringar; lägre värden gör motsatsen.

roi är intresseområdets rektangeltupel (x, y, w, h). Standardvärdet är bildrektangeln.

step är antalet pixlar att hoppa över under sökningen (används endast i läget image.SEARCH_EX).

search är image.SEARCH_DS (snabbare diamantsökning) eller image.SEARCH_EX (uttömmande sökning).

Fungerar endast på gråskalebilder.

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

Söker i bilden efter områden som matchar den skickade Haar-kaskaden och returnerar en lista med begränsningsrutetupler (x, y, w, h). Returnerar en tom lista om inga särdrag hittas.

cascade är ett Haar Cascade-objekt (se image.HaarCascade()).

threshold (0.0-1.0). Lägre värden höjer detekteringsfrekvensen och frekvensen av falska positiva.

scale måste vara större än 1.0. Högre värden körs snabbare men ger sämre matchningar.

roi är intresseområdets rektangeltupel (x, y, w, h). Standardvärdet är bildrektangeln.

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

Söker efter pupillen i en intresseområdestupel (x, y, w, h) kring ett öga. Returnerar (x, y)-platsen för pupillen, eller (0, 0) om ingen hittas.

roi är intresseområdets rektangeltupel (x, y, w, h).

Fungerar endast på gråskalebilder.

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

Extraherar LBP-nyckelpunkter (local-binary-patterns) från intresseområdet. Använd image.match_descriptor() för att jämföra två deskriptorer.

roi är intresseområdets rektangeltupel (x, y, w, h).

Fungerar endast på gråskalebilder.

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¶

Extraherar ORB-nyckelpunkter från intresseområdet. Använd image.match_descriptor() för att jämföra två deskriptorer. Returnerar None om inga nyckelpunkter hittades.

roi är intresseområdets rektangeltupel (x, y, w, h). Standardvärdet är bildrektangeln.

threshold (0-255) styr antalet extraherade hörn. Lägre tröskelvärden ger fler hörn. Använd ~20 för AGAST, ~60-80 för FAST.

normalized om True inaktiveras nyckelpunktsextraktion med flera upplösningar.

scale_factor måste vara större än 1.0. Högre värden körs snabbare men ger sämre matchningar.

max_keypoints är det maximala antalet nyckelpunkter att behålla.

corner_detector är image.CORNER_FAST eller image.CORNER_AGAST.

Fungerar endast på gråskalebilder.

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

Gör bilden svartvit och lämnar bara kanterna som vita pixlar.

image.EDGE_SIMPLE - Enkel trösklad högpassfilteralgoritm.

image.EDGE_CANNY - Canny-kantdetekteringsalgoritm.

threshold är en tvåvärdig tupel som innehåller ett lågt tröskelvärde och ett högt tröskelvärde. Du kan styra kantkvaliteten genom att justera dessa värden. Standardvärdet är (100, 200).

Fungerar endast på gråskalebilder.

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

Ersätter pixlarna i ROI:n med HOG-linjer (histogram of oriented gradients).

roi är intresseområdets rektangeltupel (x, y, w, h). Om den inte anges är den lika med bildrektangeln. Endast pixlar inom roi opereras på.

Fungerar endast på gråskalebilder.

Denna metod är inte tillgänglig på OpenMV Cam M4.

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

Tar en dubbelbred gråskalebild som innehåller utdatan från två sensorer placerade sida vid sida och ersätter ena halvan med stereodisparitetsbilden (varje pixel representerar djup). T.ex. för två 320x240-kameror skicka en 640x240-bild.

reversed Som standard jämförs den vänstra bilden med den högra och den högra bilden ersätts. Sätt till True för att jämföra höger->vänster och ersätta den vänstra bilden.

max_disparity är det maximala avståndet (1-255) att söka efter ett matchande pixelblock med hjälp av summan av absoluta differenser. Större värden tar exponentiellt längre tid men ger utdata av högre kvalitet.

threshold om summan av absoluta differenser mellan två block är mindre än eller lika med detta tröskelvärde betraktas de som matchande.

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

Kör selektiv sökning på bilden och returnerar en lista med begränsningsrutetupler (x, y, w, h) av objektförslag.

threshold är segmenteringströskelvärdet; högre värden ger färre/större regioner.

size är den minsta regionstorleken efter sammanslagning.

a1, a2, a3 är likhetsvikterna för färg/textur/storlek som används vid sammanslagning av regioner.