class Image – Image objektum¶

Image az image modul központi adattípusa – egy memóriabeli képpont-puffer, amelyen minden rajzolási rutin, minden szűrő, minden geometriai transzformáció és minden jellemzőkinyerő rutin működik. Minden képkocka, amely a csi.CSI.snapshot() hívásból érkezik, egy Image; ugyanígy minden képkocka, amelyet lemezről töltünk be, JPEG-ből vagy PNG-ből dekódolunk, numpy-stílusú ndarray-ből foglalunk, vagy üres rajzvászonként hozunk létre.

Egy Image objektumot három szám ír le – width, height és pixformat –, valamint egy folytonos képpont-puffer. A képpontformátum határozza meg mind a memóriabeli elrendezést, mind azt, hogy mely műveletek érhetők el:

BINARY (1 bpp) – 1 bit képpontonként; a morfológia és a küszöbölés használja.
GRAYSCALE (8 bpp) – 1 bájt képpontonként; a legtöbb CV-művelet (AprilTag, élek, ORB, optikai áramlás) kanonikus formátuma.
RGB565 (16 bpp) – 2 bájt képpontonként (5R/6G/5B); az alapértelmezett színformátum.
BAYER (8 bpp) – nyers Bayer-mozaik adat közvetlenül az érzékelőről. A legtöbb CV-művelet nem érhető el Bayer képeken; előbb debayer-ezz GRAYSCALE / RGB565 formátumra.
YUV422 (16 bpp) – 4:2:2 króma-alulmintavételezett szín, két bájt képpontonként. Csak néhány művelet működik közvetlenül YUV422-n.
JPEG / PNG – tömörített pufferek. A képpontszintű műveletekhez előbb to_grayscale() vagy to_rgb565() szükséges.

Honnan származnak az Image objektumok¶

Négy módon szerezhetsz Image objektumot:

A kamera képkocka-pufferéből – a csi.CSI().snapshot() a következő rögzített képkockát adja vissza. A visszaadott objektum egy vékony burkoló a kamera képkocka-puffer memóriája köré, így bármely rajz- / szűrőművelet rajta megváltoztatja azt, ami az IDE előnézetbe és a kijelzőre kerül.
Fájlból – adj át egy elérési út karakterláncot az Image konstruktornak. A BMP, PGM, PPM, JPEG és PNG közvetlenül a RAM-ba (vagy a kamera képkocka-pufferébe, ha copy_to_fb=True) kerülnek dekódolásra.
ndarray-ből – adj át egy (h, w) vagy (h, w, 3) float32 tömböt. A képpontok 0.0 -- 255.0 tartományból GRAYSCALE, illetve RGB565 formátumra skálázódnak.
Üres – adj át (width, height, pixformat) értékeket egy nullákkal feltöltött rajzfelület foglalásához. Tömörített képpontformátumoknál (JPEG / PNG) szükséges egy buffer= argumentum, amely a tömörített bájtfolyamot tartalmazza.

Tipikus rögzítés-feldolgozás-megjelenítés ciklus¶

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.

Indexelés, hossz, iteráció és bájtszerű hozzáférés¶

Indexelés – az img[i] az i képpontot olvassa (lineárisan, sorfolytonosan). Az img[i] = value írja azt. A szürkeárnyalatos / Bayer képpontok 8 bites egész számok, az RGB565 / YUV422 képpontok 16 bites csomagolt egészek, a bináris képpontok 0 / 1. JPEG / PNG képeknél az indextér a tömörített bájtfolyam, nem a képpontok.
Hossz – a len(img) a képpontok számát adja vissza tömörítetlen formátumoknál, vagy a bájtok számát tömörített formátumoknál.
Iteráció – a for px in img: ... ugyanabban a sorrendben járja be a képpont-tömböt, mint a [] indexelés.
Bájtszerű – az Image megvalósítja az olvasópuffer-protokollt, így közvetlenül átadhatod bárminek, ami bytes / bytearray típust vár (pl. uart.write(img), socket.send(img), hashlib.sha256(img)). Olvasható/írható nézet eléréséhez használd helyette a bytearray() metódust.

Hint jelzők¶

Sok Image metódus elfogad egy hint argumentumot, amely a következő jelzők logikai VAGY-a:

image.AREA: Területi skálázás használata kicsinyítéskor az alapértelmezett legközelebbi szomszéd helyett.

image.BILINEAR: Bilineáris skálázás használata az alapértelmezett legközelebbi szomszéd skálázás helyett.

image.BICUBIC: Bikubikus skálázás használata az alapértelmezett legközelebbi szomszéd skálázás helyett.

image.CENTER: A rajzolt kép középre igazítása a kijelzőn. Ez a skálázás után kerül alkalmazásra.

image.HMIRROR: A kép vízszintes tükrözése.

image.VFLIP: A kép függőleges átfordítása.

image.TRANSPOSE: A kép transzponálása (x/y felcserélése).

image.EXTRACT_RGB_CHANNEL_FIRST: Az rgb_channel kinyerése a skálázás előtt.

image.APPLY_COLOR_PALETTE_FIRST: A színpaletta alkalmazása a skálázás előtt.

image.SCALE_ASPECT_KEEP: A rajzolt kép skálázása úgy, hogy beleférjen a kijelzőbe.

image.SCALE_ASPECT_EXPAND: A rajzolt kép skálázása úgy, hogy kitöltse a kijelzőt (levágást eredményez)

image.SCALE_ASPECT_IGNORE: A rajzolt kép skálázása úgy, hogy kitöltse a kijelzőt (nyújtást eredményez).

image.ROTATE_90: A kép elforgatása 90 fokkal (ez csak VFLIP | TRANSPOSE).

image.ROTATE_180: A kép elforgatása 180 fokkal (ez csak HMIRROR | VFLIP).

image.ROTATE_270: A kép elforgatása 270 fokkal (ez csak HMIRROR | TRANSPOSE).

image.BLACK_BACKGROUND: Feltételezi, hogy a háttérkép, amelyre rajzol, fekete, ezzel felgyorsítva a keverést. Csak az Image.draw_image() és az Image.get_similarity() támogatja.

Ha az arg egy karakterlánc, akkor ez egy új képobjektumot hoz létre egy fájlból az arg elérési úton. Támogatja a bmp/pgm/ppm/jpg/jpeg/png képfájlok betöltését lemezről. Ha a copy_to_fb igaz, a kép a képkocka-pufferbe másolódik ahelyett, hogy a kupacon (heap) foglalná.

Ha az arg egy ndarray, akkor ez egy új képobjektumot hoz létre az ndarray-ből. A (w, h) alakú ndarray objektumok szürkeárnyalatos képként, a (w, h, 3) alakúak RGB565 képként kezelődnek. Jelenleg csak float32 lebegőpontos ndarrays támogatottak. Ha így hozol létre képet és átadsz egy buffer argumentumot, az a képadatok tárolására lesz használva ahelyett, hogy helyet foglalna a kupacon. Ha a copy_to_fb igaz, a kép a képkocka-pufferbe másolódik ahelyett, hogy a kupacon foglalná vagy a buffer-t használná.

Ha az arg egy int, akkor azt egy új kép szélességének tekinti, és egy height értéknek, valamint egy format értéknek kell követnie egy új üres képobjektum létrehozásához. A format bármilyen képpontformátum-érték lehet, mint például image.GRAYSCALE. A kép csupa nullára inicializálódik. Megjegyzendő, hogy tömörített képformátumoknál egy buffer érték várt. A buffer az így létrehozott képek képadatainak forrásaként tekintendő. Ha a copy_to_fb-vel együtt használod, a buffer adatai a képkocka-pufferbe másolódnak. Ha JPEG képet szeretnél létrehozni egy JPEG bytes() vagy bytearray() objektumból, átadhatod a width, height, image.JPEG értékeket a JPEG-hez, és a buffer-t a JPEG bájtfolyamra állítva létrehozhatsz egy JPEG képet.

A képek támogatják a „[]” jelölést. Használd az image[index] = 8/16-bit value kifejezést egy képpont beállítására, vagy az image[index] kifejezést egy képpont lekérdezésére, amely szürkeárnyalatos/Bayer képeknél 8 bites érték, RGB565/YUV képeknél 16 bites érték lesz. A bináris képek 1 bites értéket adnak vissza.

JPEG képeknél a „[]” lehetővé teszi a tömörített JPEG kép-blob bájttömbként való elérését. Az adattömb olvasása és írása azonban átláthatatlan, mivel a JPEG képek tömörített bájtfolyamok.

A képek olvasópuffer-műveleteket is támogatnak. Átadhatod a képeket mindenféle MicroPython függvénynek úgy, mintha a kép egy bájttömb objektum volna. Különösen, ha egy képet szeretnél továbbítani, egyszerűen átadhatod az UART/SPI/I2C write függvényeknek, hogy automatikusan továbbítódjon.

Alapvető metódusok¶

width() → int¶: Visszaadja a kép szélességét képpontban.

height() → int¶: Visszaadja a kép magasságát képpontban.

format() → int¶: Visszaadja image.GRAYSCALE szürkeárnyalatos képeknél, image.RGB565 RGB565 képeknél, image.BAYER Bayer-mintázatú képeknél, és image.JPEG JPEG képeknél.

size() → int¶: Visszaadja a kép méretét bájtban.

bytearray() → bytearray¶: Visszaad egy bytearray objektumot, amely a képadatokra mutat bájtszintű olvasási/írási hozzáféréshez.

Megjegyzés

A képobjektumok automatikusan bytes objektumokká konvertálódnak, amikor egy bytes-szerű objektumot igénylő MicroPython illesztőprogramnak adják át őket. Ez csak olvasási hozzáférés. Olvasási/írási hozzáféréshez hívd meg a bytearray()-t.

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

Szürkeárnyalatos képeknél: Visszaadja a szürkeárnyalatos képpontértéket az (x, y) helyen. RGB565 képeknél: Visszaadja az RGB888 képpont-tuple-t (r, g, b) az (x, y) helyen. Bayer-mintázatú képeknél: Visszaadja a képpontértéket az (x, y) helyen.

None értéket ad vissza, ha az x vagy y a képen kívül esik.

Az x és y átadható egymástól függetlenül vagy tuple-ként is.

Ha az rgbtuple True, ez a metódus egy RGB888 tuple-t ad vissza. Egyébként a metódus az alapul szolgáló képpont egész értékét adja vissza. Azaz RGB565 képeknél ez a metódus egy RGB565 értéket ad vissza. Alapértelmezett értéke True RGB565 képeknél, egyébként False.

Tömörített képeken nem támogatott.

Megjegyzés

Az Image.get_pixel() és az Image.set_pixel() az egyetlen metódusok, amelyek lehetővé teszik a Bayer-mintázatú képek manipulálását. A Bayer-mintázatú képek olyan tényleges képek, ahol a képpontok R/G/R/G/stb. a páros sorokban és G/B/G/B/stb. a páratlan sorokban. Minden képpont 8 bites. Ha ezt a metódust beállított rgbtuple-lel hívod meg, akkor az Image.get_pixel() debayer-ezi a forrásképet az adott képpont helyén, és érvényes RGB888 tuple-t ad vissza az adott képpont helyére.

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

Szürkeárnyalatos képeknél: Beállítja az (x, y) helyen lévő képpontot a pixel szürkeárnyalatos értékre. RGB565 képeknél: Beállítja az (x, y) helyen lévő képpontot a pixel RGB888 tuple-re (r, g, b). Bayer-mintázatú képeknél: Beállítja az (x, y) helyen lévő képpontértéket a pixel értékre.

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

Az x és y átadható egymástól függetlenül vagy tuple-ként is.

A pixel lehet egy RGB888 tuple (r, g, b) vagy az alapul szolgáló képpontérték (azaz egy RGB565 érték RGB565 képeknél vagy egy 8 bites érték szürkeárnyalatos képeknél).

Tömörített képeken nem támogatott.

Megjegyzés

Az Image.get_pixel() és az Image.set_pixel() az egyetlen metódusok, amelyek lehetővé teszik a Bayer-mintázatú képek manipulálását. A Bayer-mintázatú képek olyan tényleges képek, ahol a képpontok R/G/R/G/stb. a páros sorokban és G/B/G/B/stb. a páratlan sorokban. Minden képpont 8 bites. Ha ezt a metódust egy RGB888 tuple-lel hívod meg, az adott RGB888 tuple szürkeárnyalatos értéke kinyerésre és a képpont helyére beállításra kerül.

Konverziós metódusok¶

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

Visszaad egy a képből létrehozott ndarray objektumot. Ez jelenleg csak GRAYSCALE vagy RGB565 képeknél működik.

A dtype lehet b, B vagy f egy előjeles 8 bites, előjel nélküli 8 bites, illetve 32 bites lebegőpontos ndarray létrehozásához. A GRAYSCALE képek közvetlenül előjel nélküli 8 bites ndarray objektumokká konvertálódnak. Előjeles 8 bites ndarray objektumoknál a (0:255) értékek (-127:128) tartományra képződnek le. Float 32 bites ndarray objektumoknál az értékek (0.0:255.0) tartományra képződnek le. Az RGB565 képek 3 csatornás ndarray objektumokká konvertálódnak, és a fent a GRAYSCALE képeknél leírt folyamat alkalmazódik minden csatornára a dtype-tól függően. Megjegyzendő, hogy a dtype elfogadja a b, B és f egész értékeit is (pl. ord()).

A buffer, ha nem None, egy bytearray objektum, amelyet az ndarray pufferéként kell használni. Ha None, új puffer foglalódik a kupacon az ndarray képadatainak tárolására. A buffer argumentummal közvetlenül egy előre lefoglalt pufferben foglalhatod az ndarray-t, megtakarítva egy kupacfoglalást és egy másolási műveletet.

A visszaadott ndarray alakja (height, width) GRAYSCALE képeknél és (height, width, 3) RGB565 képeknél.

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¶

Egy képet bitmap képpé konvertál (1 bit képpontonként).

Az x_scale szabályozza, hogy a megjelenített kép mennyivel skálázódik x irányban (float). Ha ez az érték negatív, a kép vízszintesen tükröződik. Megjegyzendő, hogy ha az y_scale nincs megadva, akkor megegyezik az x_scale-lel a képarány megtartásához.

Az y_scale szabályozza, hogy a megjelenített kép mennyivel skálázódik y irányban (float). Ha ez az érték negatív, a kép függőlegesen tükröződik. Megjegyzendő, hogy ha az x_scale nincs megadva, akkor megegyezik az x_scale-lel a képarány megtartásához.

A roi a forráskép rajzolandó érdeklődési terület téglalap-tuple-je (x, y, w, h). Ez lehetővé teszi, hogy csak a ROI képpontjait nyerd ki a célképre való skálázáshoz és rajzoláshoz.

Az rgb_channel az RGB csatorna (0=R, G=1, B=2), amelyet egy RGB565 képből (ha át van adva) kinyersz és a célképre renderelsz. Például, ha rgb_channel=1 értéket adsz át, ez kinyeri a forrás RGB565 kép zöld csatornáját, és azt szürkeárnyalatosan rajzolja a célképre.

Az alpha szabályozza, hogy a forráskép mennyire keveredjen a célképbe. A 255-ös érték átlátszatlan forrásképet rajzol, míg a 255-nél kisebb érték keverést hoz létre a forrás- és célkép között. A 0 nem módosítja a célképet.

A color_palette, ha nem None, lehet egy színpaletta enum vagy egy összesen 256 képpontos RGB565 kép, amelyet színkereső táblaként használ a forráskép szürkeárnyalatos értékén. Ez az rgb_channel kinyerés után kerül alkalmazásra, ha az használatban van.

Az alpha_palette, ha nem None, lehet egy összesen 256 képpontos GRAYSCALE kép, amelyet alfa-palettaként használ, amely a rajzolt forráskép alpha értékét modulálja képpontonkénti szinten, lehetővé téve a képpontok alfa értékének pontos szabályozását a szürkeárnyalatos értékük alapján. Az alfa-keresőtáblában a 255-ös képpontérték átlátszatlan, míg bármi 255-nél kevesebb egyre átlátszóbbá válik, egészen 0-ig. Ez az rgb_channel kinyerés után kerül alkalmazásra, ha az használatban van.

A hint a Hint jelzők között felsorolt jelzők logikai VAGY-a (kivéve az image.BLACK_BACKGROUND-ot, amely itt nem támogatott).

A transform egy 3x3-as ndarray, amely perspektivikus transzformáció végrehajtására szolgál a képen. Jelenleg csak az OpenMV Cam N6-on támogatott, mivel annak van GPU-ja, amely ezt hardveresen képes elvégezni.

A copy, ha True, mély másolatot hoz létre a kupacon a konvertált képről, ahelyett, hogy az eredeti képet helyben konvertálná.

A copy_to_fb, ha True, a kép közvetlenül a képkocka-pufferbe töltődik. A copy_to_fb elsőbbséget élvez a copy-val szemben. Ennek nincs különleges hatása, ha a kép már a képkocka-pufferben van.

Megjegyzés

A bitmap képek olyanok, mint a szürkeárnyalatos képek, csak két képpontértékkel - 0 és 1. Ezenkívül a bitmap képek úgy vannak csomagolva, hogy csak 1 bitet tárolnak képpontonként, így nagyon kicsik. Az OpenMV képkönyvtár lehetővé teszi a bitmap képek használatát minden olyan helyen, ahol sensor.GRAYSCALE és sensor.RGB565 képek használhatók. Azonban sok művelet bitmap képekre alkalmazva értelmetlen, mivel a bitmap képeknek csak 2 értékük van. Az OpenMV a bitmap képek használatát mask értékként javasolja műveletekben és hasonlókban, mivel azok elég könnyen elférnek a MicroPython kupacon. Végül a bitmap kép 0 és 1 képpontértékei feketeként és fehérként értelmeződnek, amikor sensor.GRAYSCALE vagy sensor.RGB565 képekre alkalmazzák őket. A könyvtár automatikusan kezeli a konverziót.

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

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¶

Egy képet szürkeárnyalatos képpé konvertál (8 bit képpontonként).

A hint a Hint jelzők között felsorolt jelzők logikai VAGY-a (kivéve az image.BLACK_BACKGROUND-ot, amely itt nem támogatott).

A copy, ha True, mély másolatot hoz létre a kupacon a konvertált képről, ahelyett, hogy az eredeti képet helyben konvertálná.

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

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¶

Egy képet RGB565 képpé konvertál (16 bit képpontonként).

A hint a Hint jelzők között felsorolt jelzők logikai VAGY-a (kivéve az image.BLACK_BACKGROUND-ot, amely itt nem támogatott).

A copy, ha True, mély másolatot hoz létre a kupacon a konvertált képről, ahelyett, hogy az eredeti képet helyben konvertálná.

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

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¶

Egy képet RGB565 szivárvány képpé konvertál (16 bit képpontonként).

A hint a Hint jelzők között felsorolt jelzők logikai VAGY-a (kivéve az image.BLACK_BACKGROUND-ot, amely itt nem támogatott).

A copy, ha True, mély másolatot hoz létre a kupacon a konvertált képről, ahelyett, hogy az eredeti képet helyben konvertálná.

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

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¶

Egy képet RGB565 ironbow képpé konvertál (16 bit képpontonként).

A hint a Hint jelzők között felsorolt jelzők logikai VAGY-a (kivéve az image.BLACK_BACKGROUND-ot, amely itt nem támogatott).

A copy, ha True, mély másolatot hoz létre a kupacon a konvertált képről, ahelyett, hogy az eredeti képet helyben konvertálná.

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

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¶

Egy képet RGB565 mélységi képpé konvertál (16 bit képpontonként).

A color_palette, ha nem None, lehet image.PALETTE_DEPTH vagy egy összesen 256 képpontos RGB565 kép, amelyet színkereső táblaként használ a forráskép szürkeárnyalatos értékén. Ez az rgb_channel kinyerés után kerül alkalmazásra, ha az használatban van.

A hint a Hint jelzők között felsorolt jelzők logikai VAGY-a (kivéve az image.BLACK_BACKGROUND-ot, amely itt nem támogatott).

A copy, ha True, mély másolatot hoz létre a kupacon a konvertált képről, ahelyett, hogy az eredeti képet helyben konvertálná.

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

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¶

Egy képet RGB565 sötét esemény képpé konvertál (16 bit képpontonként).

A hint a Hint jelzők között felsorolt jelzők logikai VAGY-a (kivéve az image.BLACK_BACKGROUND-ot, amely itt nem támogatott).

A copy, ha True, mély másolatot hoz létre a kupacon a konvertált képről, ahelyett, hogy az eredeti képet helyben konvertálná.

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

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¶

Egy képet RGB565 világos esemény képpé konvertál (16 bit képpontonként).

A hint a Hint jelzők között felsorolt jelzők logikai VAGY-a (kivéve az image.BLACK_BACKGROUND-ot, amely itt nem támogatott).

A copy, ha True, mély másolatot hoz létre a kupacon a konvertált képről, ahelyett, hogy az eredeti képet helyben konvertálná.

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

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¶

Egy képet JPEG képpé konvertál.

A hint a Hint jelzők között felsorolt jelzők logikai VAGY-a (kivéve az image.BLACK_BACKGROUND-ot, amely itt nem támogatott).

A copy, ha True, mély másolatot hoz létre a kupacon a konvertált képről, ahelyett, hogy az eredeti képet helyben konvertálná.

A quality szabályozza a jpeg kép tömörítési minőségét. Az érték 0 és 100 között lehet.

A subsampling lehet:

image.JPEG_SUBSAMPLING_AUTO: A képhez a minőség alapján legjobb alulmintavételezés használata.

image.JPEG_SUBSAMPLING_444: 4:4:4 alulmintavételezés használata.

image.JPEG_SUBSAMPLING_422: 4:2:2 alulmintavételezés használata.

image.JPEG_SUBSAMPLING_420: 4:2:0 alulmintavételezés használata.

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

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¶

Egy képet PNG képpé konvertál.

A hint a Hint jelzők között felsorolt jelzők logikai VAGY-a (kivéve az image.BLACK_BACKGROUND-ot, amely itt nem támogatott).

A copy, ha True, mély másolatot hoz létre a kupacon a konvertált képről, ahelyett, hogy az eredeti képet helyben konvertálná.

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

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¶

Egy képet JPEG képpé konvertál.

A hint a Hint jelzők között felsorolt jelzők logikai VAGY-a (kivéve az image.BLACK_BACKGROUND-ot, amely itt nem támogatott).

A copy, ha True, mély másolatot hoz létre a kupacon a konvertált képről, ahelyett, hogy az eredeti képet helyben konvertálná.

A quality szabályozza a jpeg kép tömörítési minőségét. Az érték 0 és 100 között lehet.

A subsampling lehet:

image.JPEG_SUBSAMPLING_AUTO: A képhez a minőség alapján legjobb alulmintavételezés használata.

image.JPEG_SUBSAMPLING_444: 4:4:4 alulmintavételezés használata.

image.JPEG_SUBSAMPLING_422: 4:2:2 alulmintavételezés használata.

image.JPEG_SUBSAMPLING_420: 4:2:0 alulmintavételezés használata.

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

Megjegyzés

Az Image.compress az Image.to_jpeg álneve.

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¶

Mély másolatot készít a képobjektumról.

A hint a Hint jelzők között felsorolt jelzők logikai VAGY-a (kivéve az image.BLACK_BACKGROUND-ot, amely itt nem támogatott).

A copy_to_fb, ha True, a kép közvetlenül a képkocka-pufferbe töltődik. Ennek nincs különleges hatása, ha a kép már a képkocka-pufferben van.

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

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¶

Egy képet helyben módosít az alapul szolgáló képtípus megváltoztatása nélkül.

A hint a Hint jelzők között felsorolt jelzők logikai VAGY-a (kivéve az image.BLACK_BACKGROUND-ot, amely itt nem támogatott).

A copy, ha True, mély másolatot hoz létre a kupacon a konvertált képről, ahelyett, hogy az eredeti képet helyben konvertálná.

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

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¶

Egy képet helyben módosít az alapul szolgáló képtípus megváltoztatása nélkül.

A hint a Hint jelzők között felsorolt jelzők logikai VAGY-a (kivéve az image.BLACK_BACKGROUND-ot, amely itt nem támogatott).

A copy, ha True, mély másolatot hoz létre a kupacon a konvertált képről, ahelyett, hogy az eredeti képet helyben konvertálná.

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

Megjegyzés

Az Image.scale az Image.crop álneve.

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

A kép egy másolatát menti a fájlrendszerbe a path helyre.

Támogatja a bmp/pgm/ppm/jpg/jpeg képfájlokat. Megjegyzendő, hogy jpeg-tömörített képeket nem menthetsz tömörítetlen formátumba.

A roi a mentendő érdeklődési terület téglalap (x, y, w, h). Ha nincs megadva, megegyezik a kép téglalapjával, amely a teljes képet másolja. Ez az argumentum nem alkalmazható JPEG képekre.

A quality a kép jpeg formátumba mentéséhez használt jpeg tömörítési minőség, ha a kép még nincs tömörítve (0-100) (int).

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

flush() → None¶: Frissíti az IDE-ben a képkocka-puffert a kamera képkocka-pufferében lévő képpel.

Rajzolási metódusok¶

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

A kép összes képpontját nullára állítja (nagyon gyors).

A mask egy másik kép, amelyet képpontszintű maszkként használ a művelethez. A maszk csak fekete vagy fehér képpontokat tartalmazó kép legyen, és azonos méretű legyen a feldolgozott képpel. Csak a maszkban beállított képpontok módosulnak.

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

Tömörített képeken nem támogatott.

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

Vonalat rajzol az (x0, y0) ponttól az (x1, y1) pontig a képen. Az x0, y0, x1, y1 értékeket átadhatod külön-külön vagy tuple-ként (x0, y0, x1, y1) is.

A color egy RGB888 tuple szürkeárnyalatos vagy RGB565 képeknél. Alapértelmezetten fehér. Azonban átadhatod az alapul szolgáló képpontértéket (0-255) is szürkeárnyalatos képeknél, vagy egy RGB565 értéket RGB565 képeknél.

A thickness szabályozza, hogy a vonal milyen vastag képpontban.

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

Tömörített képeken vagy Bayer képeken nem támogatott.

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¶

Téglalapot rajzol a képre. Az x, y, w, h értékeket átadhatod külön-külön vagy tuple-ként (x, y, w, h) is.

A thickness szabályozza, hogy a vonalak milyen vastagok képpontban.

Add át a fill értéket True-ra állítva a téglalap kitöltéséhez.

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

Tömörített képeken vagy Bayer képeken nem támogatott.

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

Kört rajzol a képre. Az x, y, radius értékeket átadhatod külön-külön vagy tuple-ként (x, y, radius) is.

A thickness szabályozza, hogy az élek milyen vastagok képpontban.

Add át a fill értéket True-ra állítva a kör kitöltéséhez.

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

Tömörített képeken vagy Bayer képeken nem támogatott.

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¶

Ellipszist rajzol a képre. A cx, cy, rx, ry értékeket és az elforgatást (fokban) átadhatod külön-külön vagy tuple-ként (cx, yc, rx, ry, rotation) is.

A thickness szabályozza, hogy az élek milyen vastagok képpontban.

Add át a fill értéket True-ra állítva az ellipszis kitöltéséhez.

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

Tömörített képeken vagy Bayer képeken nem támogatott.

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¶

8x10-es szöveget rajzol az (x, y) helytől kezdve a képen. Az x, y értékeket átadhatod külön-külön vagy tuple-ként (x, y) is.

A text egy a képre írandó karakterlánc. A \n, \r és \r\n sorvégek a kurzort a következő sorra mozgatják.

A scale növelhető a szöveg méretének növeléséhez/csökkentéséhez a képen. 0-nál nagyobb egész vagy lebegőpontos értékeket adhatsz át.

Az x_spacing lehetővé teszi x képpontok hozzáadását (ha pozitív) vagy kivonását (ha negatív) a karakterek között.

Az y_spacing lehetővé teszi y képpontok hozzáadását (ha pozitív) vagy kivonását (ha negatív) a karakterek között (többsoros szövegnél).

A mono_space alapértelmezetten True, amely fix szélességűre kényszeríti a szöveget. Nagy szövegskáláknál ez borzalmasan néz ki. Állítsd False-ra a nem fix szélességű karakterköz eléréséhez, amely SOKKAL jobban néz ki.

A char_rotation lehet 0, 90, 180, 270 a karakterlánc minden karakterének ennyivel való elforgatásához.

A char_hmirror, ha True, vízszintesen tükrözi a karakterlánc összes karakterét.

A char_vflip, ha True, függőlegesen átfordítja a karakterlánc összes karakterét.

A string_rotation lehet 0, 90, 180, 270 a karakterlánc ennyivel való elforgatásához.

A string_hmirror, ha True, vízszintesen tükrözi a karakterláncot.

A string_vflip, ha True, függőlegesen átfordítja a karakterláncot.

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

Tömörített képeken vagy Bayer képeken nem támogatott.

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

Keresztet rajzol az x, y helyen. Az x, y értékeket átadhatod külön-külön vagy tuple-ként (x, y) is.

A size szabályozza, hogy a kereszt vonalai milyen hosszan nyúljanak ki.

A thickness szabályozza, hogy az élek milyen vastagok képpontban.

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

Tömörített képeken vagy Bayer képeken nem támogatott.

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

Nyilat rajzol az (x0, y0) ponttól az (x1, y1) pontig a képen. Az x0, y0, x1, y1 értékeket átadhatod külön-külön vagy tuple-ként (x0, y0, x1, y1) is.

A thickness szabályozza, hogy a vonal milyen vastag képpontban.

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

Tömörített képeken vagy Bayer képeken nem támogatott.

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¶

Egy észlelési eredményt rajzol a képre. A detection egy 6 elemű tuple (rx, ry, rw, rh, cx, cy), amely egy határoló téglalapot és egy súlypontot ír le (jellemzően NN vagy színkövető kód adja vissza).

A color1 a téglalap színe, a color2 a súlypont-kereszt színe. A size a súlypont-kereszt mérete, a thickness szabályozza a körvonal szélességét, a fill pedig kitölti a téglalapot.

A label, ha meg van adva, a téglalap közelében kerül kirajzolásra, a label_offset (x, y) értékkel eltolva.

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

Tömörített képeken vagy Bayer képeken nem támogatott.

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¶

Vonalas éleket rajzol egy olyan metódus által visszaadott saroklista között, mint a blob.corners. A Corners egy négyelemű tuple, amely kétértékű x/y tuple-öket tartalmaz. Pl. [(x1,y1),(x2,y2),(x3,y3),(x4,y4)].

A size, ha 0-nál nagyobb, a sarkok size sugarú körökként való kirajzolását okozza.

A thickness szabályozza, hogy a vonal milyen vastag képpontban.

Add át a fill értéket True-ra állítva a sarokkörök kitöltéséhez, ha azok kirajzolásra kerülnek.

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

Tömörített képeken vagy Bayer képeken nem támogatott.

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¶

Egy image képet rajzol, amelynek bal felső sarka az x, y helyen kezdődik. Az x, y értékeket átadhatod külön-külön vagy tuple-ként (x, y) is. Ez a metódus automatikusan kezeli az átadott kép helyes képpontformátumra renderelését a célképhez, miközben a levágást is zökkenőmentesen kezeli.

Egy képobjektum helyett egy elérési utat is átadhatsz ennek a metódusnak, hogy automatikusan betöltse a képet lemezről, és egy lépésben felhasználja. Pl. draw_image("test.jpg").

A hint a Hint jelzők között felsorolt jelzők logikai VAGY-a (beleértve az image.BLACK_BACKGROUND-ot, amely itt támogatott).

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

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¶

Egy kulcspont-objektum kulcspontjait rajzolja a képre. Átadhatsz egy háromértékű tuple-öket tartalmazó listát is, amely tartalmazza az (x, y, rotation_angle_in_degrees) értékeket, hogy újrafelhasználd ezt a metódust kulcspont-glifek rajzolásához, amelyek egy kör egy adott irányba mutató vonallal.

A size szabályozza, hogy a kulcspontok milyen nagyok.

A thickness szabályozza, hogy a vonal milyen vastag képpontban.

Add át a fill értéket True-ra állítva a kulcspontok kitöltéséhez.

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

Tömörített képeken vagy Bayer képeken nem támogatott.

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¶

Egy képterületet elárasztással feltölt az x, y helytől kezdve. Az x, y értékeket átadhatod külön-külön vagy tuple-ként (x, y) is.

A seed_threshold szabályozza, hogy a feltöltési terület bármely képpontja mennyire különbözhet az eredeti kiindulási képponttól.

A floating_threshold szabályozza, hogy a feltöltési terület bármely képpontja mennyire különbözhet bármely szomszédos képponttól.

Add át az invert értéket True-ra az elárasztásos feltöltéssel összefüggő területen kívül minden átszínezéséhez.

Add át a clear_background értéket True-ra a többi képpont nullázásához, amelyet az elárasztásos feltöltés nem színezett át.

A mask egy másik kép, amelyet képpontszintű maszkként használ a művelethez. A maszk csak fekete vagy fehér képpontokat tartalmazó kép legyen, és azonos méretű legyen a feldolgozott képpel. Elárasztásos feltöltéskor csak a maszkban beállított képpontok kerülnek kiértékelésre.

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

Tömörített képeken vagy Bayer képeken nem támogatott.

Ez a metódus nem érhető el az OpenMV Cam M4-en.

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

Egy esemény-ndarray-t (amelyet a csi.IOCTL_GENX320_READ_EVENTS tölt fel) raszterizál egy Image-re vizualizáció céljából. A kép pufferének egy 320x320-as GRAYSCALE képnek kell lennie.

Minden csi.PIX_ON_EVENT sornál az esemény képpontja +contrast értéket kap; minden csi.PIX_OFF_EVENT sornál a képpont -contrast értéket kap. A trigger események figyelmen kívül maradnak. A képpontértékek 0-255 közé vágódnak.

A clear, ha True, a kép pufferét brightness értékre állítja vissza rajzolás előtt — minden képkocka friss, csak eseményeket tartalmazó renderré válik. Állítsd False-ra az események több hívás közötti felhalmozásához (hosszú expozíciós mozgásnyomokhoz hasznos).

A brightness szabályozza a közép-szürke alapvonalat, amelyre a puffer visszaáll, amikor a clear True. Az alapértelmezett 128 az ON eseményeket a világos végre, az OFF eseményeket a sötét végre helyezi azonos mozgástérrel.

A contrast szabályozza, hogy minden esemény mennyivel tolja el a képpontját — a magasabb értékek kiemelik az eseményeket, azon az áron, hogy gyorsan telítődnek, amikor sok esemény ér ugyanarra a képpontra.

Maszkolási metódusok¶

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

A kép egy téglalap alakú részét nullázza. Ha nem adsz meg argumentumokat, ez a metódus a kép közepét nullázza.

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

Tömörített képeken vagy Bayer képeken nem támogatott.

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

A kép egy kör alakú részét nullázza. Ha nem adsz meg argumentumokat, ez a metódus a kép közepét nullázza.

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

Tömörített képeken vagy Bayer képeken nem támogatott.

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

A kép egy ellipszis alakú részét nullázza. Ha nem adsz meg argumentumokat, ez a metódus a kép közepét nullázza.

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

Tömörített képeken vagy Bayer képeken nem támogatott.

Bináris metódusok¶

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

Az összes képpontot feketére vagy fehérre állítja attól függően, hogy minden egyes képpont a thresholds küszöb-tuple-jeinek egyikén belül van-e.

A thresholds egy (lo, hi) tuple-öket tartalmazó lista szürkeárnyalatos képeknél, vagy (l_lo, l_hi, a_lo, a_hi, b_lo, b_hi) tuple-öket RGB565 képeknél. A felcserélt min/max értékek automatikusan javítódnak; a hiányzó komponensek alapértelmezetten a maximális tartományt veszik fel.

Az invert invertálja a küszöbölési egyezést.

A zero, ha True, nullázza a küszöbölt képpontokat, a többit pedig érintetlenül hagyja.

A mask egy bináris kép, amelyet képpontszintű maszkként használ; csak a maszkban beállított képpontok módosulnak.

A to_bitmap, ha True, a képadatokat 1 bit/képpont bitmappé konvertálja. Nagyon kis képeknél ehhez copy=True szükséges lehet.

A copy, ha True, a forráskép módosítása helyett egy új képet ad vissza a kupacon.

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

Tömörített képeken vagy Bayer képeken nem támogatott.

invert() → Image¶

Invertálja a kép összes képpontértékét (minden képpont 255 - pixel lesz a 8 bites csatornáknál).

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

Tömörített képeken vagy Bayer/yuv képeken nem támogatott.

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

Logikai ÉS-t végez ezen a képen egy másik képpel.

Az image lehet egy képobjektum, egy tömörítetlen képfájl (bmp/pgm/ppm) elérési útja, vagy egy skalárérték (RGB888 tuple vagy alapul szolgáló képpontérték).

A mask egy bináris kép, amelyet képpontszintű maszkként használ; csak a maszkban beállított képpontok módosulnak.

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

Tömörített képeken vagy Bayer képeken nem támogatott.

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

Logikai NÉS-t végez ezen a képen egy másik képpel.

Az image lehet egy képobjektum, egy tömörítetlen képfájl (bmp/pgm/ppm) elérési útja, vagy egy skalárérték (RGB888 tuple vagy alapul szolgáló képpontérték).

A mask egy bináris kép, amelyet képpontszintű maszkként használ; csak a maszkban beállított képpontok módosulnak.

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

Tömörített képeken vagy Bayer képeken nem támogatott.

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

Logikai VAGY-ot végez ezen a képen egy másik képpel.

Az image lehet egy képobjektum, egy tömörítetlen képfájl (bmp/pgm/ppm) elérési útja, vagy egy skalárérték (RGB888 tuple vagy alapul szolgáló képpontérték).

A mask egy bináris kép, amelyet képpontszintű maszkként használ; csak a maszkban beállított képpontok módosulnak.

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

Tömörített képeken vagy Bayer képeken nem támogatott.

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

Logikai NVAGY-ot végez ezen a képen egy másik képpel.

Az image lehet egy képobjektum, egy tömörítetlen képfájl (bmp/pgm/ppm) elérési útja, vagy egy skalárérték (RGB888 tuple vagy alapul szolgáló képpontérték).

A mask egy bináris kép, amelyet képpontszintű maszkként használ; csak a maszkban beállított képpontok módosulnak.

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

Tömörített képeken vagy Bayer képeken nem támogatott.

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

Logikai KIZÁRÓ VAGY-ot végez ezen a képen egy másik képpel.

Az image lehet egy képobjektum, egy tömörítetlen képfájl (bmp/pgm/ppm) elérési útja, vagy egy skalárérték (RGB888 tuple vagy alapul szolgáló képpontérték).

A mask egy bináris kép, amelyet képpontszintű maszkként használ; csak a maszkban beállított képpontok módosulnak.

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

Tömörített képeken vagy Bayer képeken nem támogatott.

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

Logikai NEM-KIZÁRÓ VAGY-ot végez ezen a képen egy másik képpel.

Az image lehet egy képobjektum, egy tömörítetlen képfájl (bmp/pgm/ppm) elérési útja, vagy egy skalárérték (RGB888 tuple vagy alapul szolgáló képpontérték).

A mask egy bináris kép, amelyet képpontszintű maszkként használ; csak a maszkban beállított képpontok módosulnak.

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

Tömörített képeken vagy Bayer képeken nem támogatott.

ISP metódusok¶

awb(max: bool = False) → Image¶

Automatikus fehéregyensúlyt hajt végre a képen a gray-world algoritmus használatával. Nyers Bayer vagy RGB565 képeken működik. Bináris/szürkeárnyalatos képekre nincs hatása.

A max, ha True, helyette a white-patch algoritmust használja.

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

Tömörített vagy yuv képeken nem támogatott.

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

Megszorozza az átadott lebegőpontos színkorrekciós mátrixot a képpel. A mátrixok lehetnek 3x3-asak vagy 3x4-esek (eltolás oszloppal), beágyazott lista vagy lapos lista formában:

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

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

Tömörített képeken vagy Bayer/yuv képeken nem támogatott.

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

Beállítja a kép gammáját, kontrasztját és fényerejét.

A gamma a normalizálás után pow(pixel, 1/gamma)-t alkalmaz. Az 1.0-nál nagyobb értékek világosítanak; az 1.0-nál kisebbek sötétítenek.

A contrast a normalizálás után pixel * contrast-ot alkalmaz.

A brightness a normalizálás után pixel + brightness-t alkalmaz.

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

Tömörített vagy Bayer/yuv képeken nem támogatott.

gamma_corr(gamma: float = 1.0, contrast: float = 1.0, brightness: float = 0.0) → Image¶: Az Image.gamma álneve.

Matematikai metódusok¶

negate() → Image¶: Az Image.invert álneve.

replace(image: Image | None = None, **kwargs) → Image¶: Az Image.draw_image() álneve. Lecseréli ezt a képet az image-re (vagy helyben transzformálja ezt a képet, ha az image el van hagyva) a standard draw_image kulcsszavas argumentumok használatával. A transform argumentum egy 3x3-as ndarray, amely egy perspektivikus transzformációt ír le (csak az ULAB engedélyezésével rendelkező OpenMV kamerákon támogatott).

assign(image: Image | None = None, **kwargs) → Image¶: Az Image.replace() álneve.

set(image: Image | None = None, **kwargs) → Image¶: Az Image.replace() álneve.

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

Képpontonként hozzáad egy képet ehhez.

Az image lehet egy képobjektum, egy tömörítetlen képfájl (bmp/pgm/ppm) elérési útja, vagy egy skalárérték (RGB888 tuple vagy alapul szolgáló képpontérték).

A mask egy bináris kép, amelyet képpontszintű maszkként használ; csak a maszkban beállított képpontok módosulnak.

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

Tömörített képeken vagy Bayer képeken nem támogatott.

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

Képpontonként kivonja az image-t ebből a képből (self - image).

Az image lehet egy képobjektum, egy tömörítetlen képfájl (bmp/pgm/ppm) elérési útja, vagy egy skalárérték (RGB888 tuple vagy alapul szolgáló képpontérték).

A mask egy bináris kép, amelyet képpontszintű maszkként használ; csak a maszkban beállított képpontok módosulnak.

Ez a metódus elfogadja az Image.draw_image() kulcsszavas argumentumainak teljes készletét is (x, y, x_scale, y_scale, roi, rgb_channel, alpha, color_palette, alpha_palette, hint, transform).

Tömörített képeken vagy Bayer képeken nem támogatott.

rsub(image: Image, mask: Image | None = None) → Image¶: Fordított kivonás: lecseréli ezt a képet az image - self képpontonkénti különbségére. Egyébként megegyezik az Image.sub()-bal.

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

Visszaadja két kép képpontonkénti minimum képét.

Az image lehet egy képobjektum, egy tömörítetlen képfájl (bmp/pgm/ppm) elérési útja, vagy egy skalárérték (RGB888 tuple vagy alapul szolgáló képpontérték).

A mask egy bináris kép, amelyet képpontszintű maszkként használ; csak a maszkban beállított képpontok módosulnak.

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

Tömörített képeken vagy Bayer képeken nem támogatott.

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

Visszaadja két kép képpontonkénti maximum képét.

Az image lehet egy képobjektum, egy tömörítetlen képfájl (bmp/pgm/ppm) elérési útja, vagy egy skalárérték (RGB888 tuple vagy alapul szolgáló képpontérték).

A mask egy bináris kép, amelyet képpontszintű maszkként használ; csak a maszkban beállított képpontok módosulnak.

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

Tömörített képeken vagy Bayer képeken nem támogatott.

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

Visszaadja két kép közötti abszolút különbség képet (pl. ||a-b||).

Az image lehet egy képobjektum, egy tömörítetlen képfájl (bmp/pgm/ppm) elérési útja, vagy egy skalárérték (RGB888 tuple vagy alapul szolgáló képpontérték).

A mask egy bináris kép, amelyet képpontszintű maszkként használ; csak a maszkban beállított képpontok módosulnak.

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

Tömörített képeken vagy Bayer képeken nem támogatott.

blend(image: Image, x: int = 0, y: int = 0, alpha: int = 128, mask: Image | None = None, **kwargs) → Image¶: Az Image.draw_image() álneve. Alfa-keveri az image-t ebbe a képbe. Az alpha egy 0-256 közötti egész szám; a 256-hoz közelebbi értékek a forrásképet részesítik előnyben. Elfogadja az összes Image.draw_image() kulcsszavas argumentumot.

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

Hisztogram-kiegyenlítést futtat a képen a kontraszt és a fényerő normalizálásához.

Az adaptive, ha True, adaptív hisztogram-kiegyenlítést futtat (lassabb, de általában jobb).

A clip_limit korlátozza a kontrasztot az adaptív változatban (egy kis érték, mint a 10, jó CLAHE eredményeket ad).

A mask egy bináris kép, amelyet képpontszintű maszkként használ; csak a maszkban beállított képpontok módosulnak.

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

Tömörített képeken vagy Bayer képeken nem támogatott.

Szűrési metódusok¶

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

Eltávolítja a képpontokat a szegmentált területek éleiről. Egy ((size*2)+1)x((size*2)+1) kernelt konvolvál végig a képen, törölve a középső képpontot, ha több mint threshold szomszéd törölt (standard erodálásként működik, ha a threshold None).

A mask egy bináris kép, amelyet képpontszintű maszkként használ; csak a maszkban beállított képpontok módosulnak.

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

Tömörített képeken vagy Bayer/yuv képeken nem támogatott.

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

Képpontokat ad a szegmentált területek éleihez. Egy ((size*2)+1)x((size*2)+1) kernelt konvolvál végig a képen, beállítva a középső képpontot, ha több mint threshold szomszéd beállított (standard dilatálásként működik, ha a threshold None).

A mask egy bináris kép, amelyet képpontszintű maszkként használ; csak a maszkban beállított képpontok módosulnak.

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

Tömörített képeken vagy Bayer/yuv képeken nem támogatott.

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

Erodálást, majd dilatálást hajt végre. Lásd Image.erode() és Image.dilate().

A mask egy bináris kép, amelyet képpontszintű maszkként használ; csak a maszkban beállított képpontok módosulnak.

Tömörített képeken vagy Bayer/yuv képeken nem támogatott.

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

Dilatálást, majd erodálást hajt végre. Lásd Image.dilate() és Image.erode().

A mask egy bináris kép, amelyet képpontszintű maszkként használ; csak a maszkban beállított képpontok módosulnak.

Tömörített képeken vagy Bayer/yuv képeken nem támogatott.

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

Visszaadja a kép és az Image.open()-elt kép képkülönbségét.

A mask egy bináris kép, amelyet képpontszintű maszkként használ; csak a maszkban beállított képpontok módosulnak.

Tömörített képeken vagy Bayer/yuv képeken nem támogatott.

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

Visszaadja a kép és az Image.close()-olt kép képkülönbségét.

A mask egy bináris kép, amelyet képpontszintű maszkként használ; csak a maszkban beállított képpontok módosulnak.

Tömörített képeken vagy Bayer/yuv képeken nem támogatott.

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

Standard átlagoló elmosó szűrő box szűrő használatával.

A size a kernelméret. Használj 1-et (3x3-as kernel), 2-t (5x5-ös kernel) stb.

A threshold, ha True, adaptívan küszöböli a szűrőkimenetet bináris képpé. Az offset eltolja a binarizálást (a negatív több képpontot tesz fehérré, a pozitív kevesebbet). Az invert invertálja a bináris kimenetet.

A mask egy bináris kép, amelyet képpontszintű maszkként használ; csak a maszkban beállított képpontok módosulnak.

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

Tömörített képeken vagy Bayer/yuv képeken nem támogatott.

Percentilis szűrőt futtat a képen (alapértelmezetten medián).

A size a kernelméret. Használj 1-et (3x3-as kernel), 2-t (5x5-ös kernel) stb.

A percentile az egyes kernelekből kiválasztandó percentilis (0 = min, 0.5 = medián, 1.0 = max). Alapértelmezett értéke 0.5.

A mask egy bináris kép, amelyet képpontszintű maszkként használ; csak a maszkban beállított képpontok módosulnak.

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

Tömörített képeken vagy Bayer/yuv képeken nem támogatott.

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

Minden képpontot a szomszédjainak móduszával helyettesít. RGB képek élein műtermékeket produkálhat a nemlineáris művelet miatt.

A size a kernelméret. Használj 1-et (3x3-as kernel), 2-t (5x5-ös kernel) stb.

A mask egy bináris kép, amelyet képpontszintű maszkként használ; csak a maszkban beállított képpontok módosulnak.

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

Tömörített képeken vagy Bayer/yuv képeken nem támogatott.

A középérték-szűrőt futtatja a képen. Ez a szűrő megtalálja a kép minden képpontkörnyezetének középértékét ((max-min)/2).

A size a kernelméret. Használj 1-et (3x3-as kernel), 2-t (5x5-ös kernel) stb.

A bias szabályozza a min/max keverést. 0 csak min szűréshez, 1.0 csak max szűréshez. A bias használatával min/max szűrheted a képet.

A mask egy bináris kép, amelyet képpontszintű maszkként használ; csak a maszkban beállított képpontok módosulnak.

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

Tömörített képeken vagy Bayer/yuv képeken nem támogatott.

A képet egy tetszőleges szűrőkernellel konvolválja.

A size szabályozza a kernelméretet, amelynek ((size*2)+1)x((size*2)+1) elemnek kell lennie.

A kernel a konvolválandó kernel, egy ((size*2)+1)*((size*2)+1) elemből álló lapos 1D lista/tuple-ként, vagy egy 2D lista/tuple-ként ((size*2)+1) sorral, amelyek ((size*2)+1) elemet tartalmaznak.

A mul egy multiplikatív kontraszt-skála (alapértelmezett 1.0).

Az add egy additív fényerő-eltolás (alapértelmezett 0.0).

A mask egy bináris kép, amelyet képpontszintű maszkként használ; csak a maszkban beállított képpontok módosulnak.

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

Tömörített képeken vagy Bayer/yuv képeken nem támogatott.

A képet egy simító gauss-kernellel konvolválja.

A size a kernelméret. Használj 1-et (3x3-as kernel), 2-t (5x5-ös kernel) stb.

Az unsharp, ha True, egy unsharp mask műveletet hajt végre (élek élesítése) egy egyszerű gauss helyett.

A mul egy multiplikatív kontraszt-skála (alapértelmezett 1.0).

Az add egy additív fényerő-eltolás (alapértelmezett 0.0).

A mask egy bináris kép, amelyet képpontszintű maszkként használ; csak a maszkban beállított képpontok módosulnak.

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

Tömörített képeken vagy Bayer/yuv képeken nem támogatott.

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¶: A képet egy éldetektáló laplace-kernellel konvolválja.

A size a kernelméret. Használj 1-et (3x3-as kernel), 2-t (5x5-ös kernel) stb.

A sharpen, ha True, élesíti a képet ahelyett, hogy a nyers, küszöböletlen élválaszt adná ki.

A mul egy multiplikatív kontraszt-skála (alapértelmezett 1.0).

Az add egy additív fényerő-eltolás (alapértelmezett 0.0).

A threshold, ha True, adaptívan küszöböli a szűrőkimenetet bináris képpé. Az offset eltolja a binarizálást (a negatív több képpontot tesz fehérré, a pozitív kevesebbet). Az invert invertálja a bináris kimenetet.

A mask egy bináris kép, amelyet képpontszintű maszkként használ; csak a maszkban beállított képpontok módosulnak.

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

Tömörített képeken vagy Bayer/yuv képeken nem támogatott.

A képet egy bilaterális szűrővel konvolválja (élmegőrző simítás).

A size a kernelméret. Használj 1-et (3x3-as kernel), 2-t (5x5-ös kernel) stb.

A color_sigma szabályozza a színillesztési toleranciát; a nagyobb értékek több színelmosást produkálnak.

A space_sigma szabályozza a térbeli elmosást; a nagyobb értékek több képpontelmosást produkálnak.

A mask egy bináris kép, amelyet képpontszintű maszkként használ; csak a maszkban beállított képpontok módosulnak.

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

Tömörített képeken vagy Bayer/yuv képeken nem támogatott.

Geometriai metódusok¶

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

Egy képet derékszögű koordinátákból lineáris poláris koordinátákba vetít újra.

Állítsd be a reverse=True-t az ellenkező irányú újravetítéshez.

Az x és y adja meg a transzformáció középpontjának koordinátáját képpontban. Ha az x None (az alapértelmezett), a kép szélességének felére áll be; hasonlóan az y alapértelmezetten a kép magasságának fele.

A lineáris poláris újravetítés a kép elforgatását x-irányú eltolássá alakítja.

Tömörített képeken vagy Bayer képeken nem támogatott.

Ez a metódus nem érhető el az OpenMV Cam M4-en.

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

Egy képet derékszögű koordinátákból logaritmikus poláris koordinátákba vetít újra.

Állítsd be a reverse=True-t az ellenkező irányú újravetítéshez.

A logaritmikus poláris újravetítés a kép elforgatását x-irányú eltolássá, a skálázást/nagyítást pedig y-irányú eltolássá alakítja.

Tömörített képeken vagy Bayer képeken nem támogatott.

Ez a metódus nem érhető el az OpenMV Cam M4-en.

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

Lencsekorrekciót hajt végre a kép halszem-torzulásának kiküszöbölésére a lencsetorzulás miatt.

A strength egy float, amely meghatározza, hogy mennyire kell kiküszöbölni a kép halszem-torzulását. Próbáld ki alapértelmezetten az 1.8-at, majd innen növeld vagy csökkentsd, amíg a kép jól nem néz ki.

A zoom a képre való ráközelítés mértéke. Alapértelmezetten 1.0.

Az x_corr lebegőpontos képpont-eltolás a középponttól. Lehet negatív vagy pozitív.

Az y_corr lebegőpontos képpont-eltolás a középponttól. Lehet negatív vagy pozitív.

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

Tömörített képeken vagy Bayer képeken nem támogatott.

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¶

Kijavítja a kép perspektivikus problémáit a képkocka-puffer 3D-s elforgatásával.

Az x_rotation a kép képkocka-pufferben az x tengely körüli elforgatásának foka (azaz ez fel-le forgatja a képet).

Az y_rotation a kép képkocka-pufferben az y tengely körüli elforgatásának foka (azaz ez balra-jobbra forgatja a képet).

A z_rotation a kép képkocka-pufferben a z tengely körüli elforgatásának foka (azaz ez helyben forgatja a képet).

Az x_translation a kép balra vagy jobbra mozgatásának egységeinek száma az elforgatás után. Mivel ez az eltolás 3D térben kerül alkalmazásra, az egységek nem képpontok…

Az y_translation a kép felfelé vagy lefelé mozgatásának egységeinek száma az elforgatás után. Mivel ez az eltolás 3D térben kerül alkalmazásra, az egységek nem képpontok…

A zoom a képre való ráközelítés mértéke. Alapértelmezetten 1.0.

A fov a belső 2D->3D vetítéshez használt látómező. Ahogy a fov közelít a 0-hoz, a kép a végtelenbe kerül; ahogy közelít a 180-hoz, a kép a nézőablakon belülre kerül.

A corners négy (x, y) tuple listája, amely egy 4 pontos homográfia felépítésére szolgál, leképezve a sarkokat (0, 0), (image_width-1, 0), (image_width-1, image_height-1) és (0, image_height-1) pontokra a 3D-s elforgatás alkalmazása előtt. Madártávlati nézet transzformációkhoz hasznos.

Visszaadja a képobjektumot, így egy másik metódust hívhatsz a . jelöléssel.

Tömörített képeken vagy Bayer képeken nem támogatott.

Ez a metódus nem érhető el az OpenMV Cam M4-en.

Lekérdező metódusok¶

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¶

Kiszámítja a két kép közötti hasonlóságot a Structural Similarity Index (SSIM) használatával. Az SSIM -1 (ellentétes) és 1 (azonos) között mozog. Egy image.similarity objektumot ad vissza.

Az image az összehasonlítandó kép (egy képobjektum vagy egy elérési út karakterlánc, pl. "test.jpg").

Az x, y, x_scale, y_scale, roi, rgb_channel, alpha, color_palette, alpha_palette, hint és transform ugyanazokat az értékeket fogadja el, mint az Image.draw_image().

A dssim, ha True, helyette a Structural Dissimilarity Index (DSSIM) értéket adja vissza, ahol a 0 azonosat, az 1 pedig teljesen különbözőt jelent.

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¶

Kiszámítja a normalizált hisztogramot az összes színcsatornán egy roi-ra, és egy image.histogram objektumot ad vissza. Elérhető Image.get_hist() vagy Image.histogram() néven is.

A thresholds egy (lo, hi) tuple-öket tartalmazó lista szürkeárnyalatos képeknél, vagy (l_lo, l_hi, a_lo, a_hi, b_lo, b_hi) tuple-öket RGB565 képeknél. Ha át van adva, a hisztogram csak a küszöbökön belüli képpontokra kerül kiszámításra.

Az invert invertálja a küszöbölési egyezést.

A roi az érdeklődési terület téglalap-tuple (x, y, w, h). Alapértelmezetten a kép téglalapja.

A bins (szürkeárnyalatos) vagy az l_bins/a_bins/b_bins (RGB565) állítja be a hisztogram-rekeszek számát csatornánként. 2-nél nagyobbnak kell lennie. Alapértelmezetten a maximális rekeszszám csatornánként.

A difference beállítható egy képobjektumra, hogy az aktuális kép és az adott kép közötti különbségen működjön további puffer nélkül.

Tömörített képeken vagy Bayer képeken nem támogatott.

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¶

Kiszámítja az átlagot, mediánt, móduszt, szórást, minimumot, maximumot, alsó kvartilist és felső kvartilist az összes színcsatornára egy roi-ra, és egy image.statistics objektumot ad vissza. Elérhető Image.get_stats() vagy Image.statistics() néven is.

A thresholds egy (lo, hi) tuple-öket tartalmazó lista szürkeárnyalatos képeknél, vagy (l_lo, l_hi, a_lo, a_hi, b_lo, b_hi) tuple-öket RGB565 képeknél. Ha át van adva, a statisztikák csak a küszöbökön belüli képpontokra kerülnek kiszámításra.

Az invert invertálja a küszöbölési egyezést.

A roi az érdeklődési terület téglalap-tuple (x, y, w, h). Alapértelmezetten a kép téglalapja.

A difference beállítható egy képobjektumra, hogy az aktuális kép és az adott kép közötti különbségen működjön további puffer nélkül.

Tömörített képeken vagy Bayer képeken nem támogatott.

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¶

Lineáris regressziót (Theil-Sen) számít a kép összes küszöbölt képpontján. Egy image.line objektumot ad vissza, vagy None-t, ha nem talált vonalat.

A thresholds egy (lo, hi) tuple-öket tartalmazó lista szürkeárnyalatos képeknél, vagy (l_lo, l_hi, a_lo, a_hi, b_lo, b_hi) tuple-öket RGB565 képeknél.

Az invert invertálja a küszöbölési egyezést.

A roi az érdeklődési terület téglalap-tuple (x, y, w, h). Alapértelmezetten a kép téglalapja.

Az x_stride és y_stride szabályozza, hogy a kép kiértékelése során hány képpont kerül átugrásra.

Az area_threshold minimális határoló doboz terület; a kisebb eredmények None-t adnak vissza.

A pixels_threshold minimális küszöbölt képpontszám; a kisebb eredmények None-t adnak vissza.

A target_size egy (w, h) tuple. A ROI területileg lekicsinyítődik, hogy beleférjen ebbe a méretbe az O(N^2) algoritmus futtatása előtt. Alapértelmezett értéke (80, 60).

Tömörített képeken vagy Bayer képeken nem támogatott.

Észlelési metódusok¶

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

Megtalálja a kép összes foltját (összefüggő képpontterületek, amelyek átmennek egy küszöbteszten), és egy image.blob objektumokat tartalmazó listát ad vissza.

A thresholds egy (lo, hi) tuple-öket tartalmazó lista szürkeárnyalatos képeknél, vagy (l_lo, l_hi, a_lo, a_hi, b_lo, b_hi) tuple-öket RGB565 képeknél (LAB csatornák). Legfeljebb 32 tuple adható át. A felcserélt min/max értékek automatikusan javítódnak; a hiányzó komponensek alapértelmezetten a maximális tartományt veszik fel.

Az invert invertálja a küszöbölési egyezést.

A roi az érdeklődési terület téglalap-tuple (x, y, w, h). Alapértelmezetten a kép téglalapja.

Az x_stride és y_stride szabályozza, hogy folt keresése közben hány képpont kerül átugrásra. Növeld, ha ismert, hogy a foltok nagyok.

Az area_threshold minimális határoló doboz terület; a kisebb foltok kiszűrődnek.

A pixels_threshold minimális küszöbölt képpontszám; a kisebb foltok kiszűrődnek.

A merge, ha True, egyesíti azokat a foltokat, amelyek határoló téglalapjai metszik egymást. A margin növeli/csökkenti a metszéshez használt határoló téglalapokat. Az egyesített foltok logikai VAGY-olják a code bitvektoraikat (egy bit küszöbönként).

A threshold_cb minden foltra meghívódik a küszöbölés után; True visszaadásával megtartja, False visszaadásával kiszűri.

A merge_cb minden egyesítendő foltpárra meghívódik; True visszaadásával engedélyezi az egyesítést, False visszaadásával megakadályozza azt.

Az x_hist_bins_max, ha nem nulla, minden foltot feltölt egy x_histogram projekcióval ennyi rekeszt használva.

Az y_hist_bins_max, ha nem nulla, minden foltot feltölt egy y_histogram projekcióval ennyi rekeszt használva.

Tömörített képeken vagy Bayer képeken nem támogatott.

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

Megtalálja a kép összes végtelen vonalát a Hough-transzformáció használatával. Egy image.line objektumokat tartalmazó listát ad vissza.

A roi az érdeklődési terület téglalap-tuple (x, y, w, h). Alapértelmezetten a kép téglalapja.

Az x_stride és y_stride szabályozza, hogy a Hough-transzformáció során hány képpont kerül átugrásra.

A threshold minimális vonalnagyság (a sobel-magnitúdók összege a vonal mentén); az ez alatti vonalak kiszűrődnek.

A theta_margin és rho_margin szabályozza az egyesítést: az ezeken a küszöbökön belüli vonalak egyesülnek.

Tömörített képeken vagy Bayer képeken nem támogatott.

Ez a metódus nem érhető el az OpenMV Cam M4-en.

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

Vonalszakaszokat talál a képen. Egy image.line objektumokat tartalmazó listát ad vissza.

A roi az érdeklődési terület téglalap-tuple (x, y, w, h). Alapértelmezetten a kép téglalapja.

A merge_distance a két szakasz közötti maximális képpont-elválasztás az egyesítéshez.

A max_theta_difference a szakaszok közötti maximális théta-különbség fokban az egyesítéshez.

Ez a metódus nem érhető el az OpenMV Cam M4-en.

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

Köröket talál a képen a Hough-transzformáció használatával. Egy image.circle objektumokat tartalmazó listát ad vissza.

A roi az érdeklődési terület téglalap-tuple (x, y, w, h). Alapértelmezetten a kép téglalapja.

Az x_stride és y_stride szabályozza, hogy a Hough-transzformáció során hány képpont kerül átugrásra.

A threshold minimális körnagyság (a sobel-magnitúdók összege a kör mentén); az ez alatti körök kiszűrődnek.

Az x_margin, y_margin és r_margin szabályozza az egyesítést: az ezeken a küszöbökön belüli körök egyesülnek.

Az r_min minimális körsugár. Alapértelmezett értéke 2.

Az r_max maximális körsugár. Alapértelmezett értéke min(roi.w/2, roi.h/2).

Az r_step sugárléptetés mérete. Alapértelmezett értéke 2.

Ez a metódus nem érhető el az OpenMV Cam M4-en.

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

Téglalapokat talál a képen az apriltag négyszög-észlelési algoritmus használatával. Egy image.rect objektumokat tartalmazó listát ad vissza.

A roi az érdeklődési terület téglalap-tuple (x, y, w, h). Alapértelmezetten a kép téglalapja.

A threshold minimális élnagyság (a sobel-magnitúdók összege a téglalap élei mentén); az ez alatti téglalapok kiszűrődnek.

Ez a metódus nem érhető el az OpenMV Cam M4-en.

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

Megtalálja az összes qrcode-ot a roi-n belül, és egy image.qrcode objektumokat tartalmazó listát ad vissza.

A roi az érdeklődési terület téglalap-tuple (x, y, w, h). Alapértelmezetten a kép téglalapja.

Ez a metódus nem érhető el az OpenMV Cam M4-en.

Megtalálja az összes apriltaget a roi-n belül, és egy image.apriltag objektumokat tartalmazó listát ad vissza.

A roi az érdeklődési terület téglalap-tuple (x, y, w, h). Alapértelmezetten a kép téglalapja.

A families a dekódolandó tag-családok bitmaszkja. A következők logikai VAGY-a:

image.TAG16H5

image.TAG25H9

image.TAG36H10

image.TAG36H11

image.TAGCIRCLE21H7

image.TAGCIRCLE49H12

image.TAGCUSTOM48H12

image.TAGSTANDARD41H12

image.TAGSTANDARD52H13

Alapértelmezett értéke image.TAG36H11. Az észlelési idő az engedélyezett családok számával arányos.

Az fx és fy a kamera X és Y fókusztávolsága képpontban.

A cx és cy a kép középpontja, jellemzően image.width()/2 és image.height()/2.

Tömörített képeken nem támogatott.

Ez a metódus nem érhető el az OpenMV Cam M4-en.

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

Megtalálja az összes datamatrixot a roi-n belül, és egy image.datamatrix objektumokat tartalmazó listát ad vissza.

A roi az érdeklődési terület téglalap-tuple (x, y, w, h). Alapértelmezetten a kép téglalapja.

Az effort szabályozza, hogy mennyi időt töltsön a data matrix egyezések keresésével. A magasabb értékek javítják az észlelést a képkockasebesség rovására. A ~160 alatti értékek nem észlelnek; a ~240 feletti értékek csökkenő hozadékot adnak. Alapértelmezett értéke 200.

Ez a metódus nem érhető el az OpenMV Cam M4-en.

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

Megtalálja az összes 1D vonalkódot a roi-n belül, és egy image.barcode objektumokat tartalmazó listát ad vissza. Vízszintesen és függőlegesen egyaránt szkennel.

Támogatott vonalkódtípusok: 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.

A roi az érdeklődési terület téglalap-tuple (x, y, w, h). Alapértelmezetten a kép téglalapja.

Ez a metódus nem érhető el az OpenMV Cam M4-en.

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¶

Megtalálja ennek a képnek az eltolódását a template-hez képest fáziskorreláció használatával. Egy image.displacement objektumot ad vissza.

A roi az érdeklődési terület téglalap (x, y, w, h). Alapértelmezetten a kép téglalapja.

A template_roi a sablon érdeklődési területe. Alapértelmezetten a sablonkép téglalapja. A roi és a template_roi szélességének és magasságának azonosnak kell lennie.

A logpolar, ha True, x/y eltolás helyett az elforgatás/skála változását adja vissza.

A fix_rotation_scale, ha True, az eltolódást az elforgatás és skála igazítása után számítja ki (csak akkor van értelme, ha logpolar=False).

Megjegyzés

Ezt a metódust 2 hatványú képméreteken használd (pl. sensor.B64X64).

Tömörített képeken vagy Bayer képeken nem támogatott. Az OpenMV Cam M4-en nem érhető el.

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¶

Megpróbálja megtalálni a kép első helyét, ahol a template egyezik a Normalized Cross Correlation használatával. Egy határoló doboz tuple-t (x, y, w, h) ad vissza, vagy None-t.

A template egy szürkeárnyalatos kép, amelyhez ezt a képet illeszteni kell.

A threshold egy érték (0.0-1.0). A magasabb értékek csökkentik a hamis pozitívokat és az észleléseket; az alacsonyabb értékek ennek ellenkezőjét teszik.

A roi az érdeklődési terület téglalap-tuple (x, y, w, h). Alapértelmezetten a kép téglalapja.

A step a keresés közben átugrandó képpontok száma (csak image.SEARCH_EX módban használatos).

A search lehet image.SEARCH_DS (gyorsabb gyémántkeresés) vagy image.SEARCH_EX (kimerítő keresés).

Csak szürkeárnyalatos képeken működik.

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

Az átadott Haar kaszkádhoz illeszkedő területeket keres a képen, és egy határoló doboz tuple-öket (x, y, w, h) tartalmazó listát ad vissza. Üres listát ad vissza, ha nem talál jellemzőket.

A cascade egy Haar Cascade objektum (lásd image.HaarCascade()).

A threshold (0.0-1.0). Az alacsonyabb értékek növelik az észlelési arányt és a hamis pozitívok arányát.

A scale 1.0-nál nagyobbnak kell lennie. A magasabb értékek gyorsabban futnak, de gyengébb egyezéseket produkálnak.

A roi az érdeklődési terület téglalap-tuple (x, y, w, h). Alapértelmezetten a kép téglalapja.

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

A pupillát keresi egy szem körüli érdeklődési terület (x, y, w, h) tuple-ben. Visszaadja a pupilla (x, y) helyét, vagy (0, 0)-t, ha nem talál.

A roi az érdeklődési terület téglalap-tuple (x, y, w, h).

Csak szürkeárnyalatos képeken működik.

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

LBP (local-binary-patterns) kulcspontokat nyer ki az érdeklődési területből. Használd az image.match_descriptor()-t két leíró összehasonlításához.

A roi az érdeklődési terület téglalap-tuple (x, y, w, h).

Csak szürkeárnyalatos képeken működik.

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¶

ORB kulcspontokat nyer ki az érdeklődési területből. Használd az image.match_descriptor()-t két leíró összehasonlításához. None-t ad vissza, ha nem talált kulcspontokat.

A roi az érdeklődési terület téglalap-tuple (x, y, w, h). Alapértelmezetten a kép téglalapja.

A threshold (0-255) szabályozza a kinyert sarkok számát. Az alacsonyabb küszöbök több sarkot produkálnak. Használj ~20-at AGAST-hoz, ~60-80-at FAST-hoz.

A normalized, ha True, letiltja a többfelbontású kulcspont-kinyerést.

A scale_factor 1.0-nál nagyobbnak kell lennie. A magasabb értékek gyorsabban futnak, de gyengébb egyezéseket produkálnak.

A max_keypoints a megtartandó kulcspontok maximális száma.

A corner_detector lehet image.CORNER_FAST vagy image.CORNER_AGAST.

Csak szürkeárnyalatos képeken működik.

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

Fekete-fehérré alakítja a képet, csak az éleket hagyva meg fehér képpontokként.

image.EDGE_SIMPLE - Egyszerű küszöbölt felüláteresztő szűrő algoritmus.

image.EDGE_CANNY - Canny éldetektálási algoritmus.

A threshold egy kétértékű tuple, amely egy alsó küszöböt és egy felső küszöböt tartalmaz. Ezen értékek beállításával szabályozhatod az élek minőségét. Alapértelmezett értéke (100, 200).

Csak szürkeárnyalatos képeken működik.

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

A ROI képpontjait HOG (histogram of orientated graidients) vonalakkal helyettesíti.

A roi az érdeklődési terület téglalap-tuple (x, y, w, h). Ha nincs megadva, megegyezik a kép téglalapjával. Csak a roi-n belüli képpontokon működik.

Csak szürkeárnyalatos képeken működik.

Ez a metódus nem érhető el az OpenMV Cam M4-en.

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

Egy kétszeres szélességű szürkeárnyalatos képet vesz, amely két egymás melletti kameraérzékelő kimenetét tartalmazza, és az egyik felét a sztereó diszparitás képpel helyettesíti (minden képpont a mélységet ábrázolja). Pl. két 320x240-es kameránál adj át egy 640x240-es képet.

A reversed alapértelmezetten a bal képet hasonlítja a jobbhoz, és a jobb képet cseréli le. Állítsd True-ra a jobb->bal összehasonlításhoz és a bal kép lecseréléséhez.

A max_disparity a maximális távolság (1-255), ameddig egy illeszkedő képpontblokkot keres az abszolút különbségek összege módszerrel. A nagyobb értékek exponenciálisan tovább tartanak, de magasabb minőségű kimenetet produkálnak.

A threshold, ha két blokk abszolút különbségeinek összege kisebb vagy egyenlő ennél a küszöbnél, illeszkedőnek tekintendők.

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

Szelektív keresést futtat a képen, és objektumjavaslatok határoló doboz tuple-jeit (x, y, w, h) tartalmazó listát ad vissza.

A threshold a szegmentálási küszöbérték; a magasabb értékek kevesebb/nagyobb területet produkálnak.

A size a minimális területméret az egyesítés után.

Az a1, a2, a3 a területek egyesítésekor használt szín/textúra/méret hasonlósági súlyok.