class Image – אובייקט תמונה¶

Image הוא טיפוס הנתונים המרכזי של מודול image – חוצץ פיקסלים בזיכרון שכל שגרת ציור, כל מסנן, כל טרנספורמציה גאומטרית וכל שגרת חילוץ מאפיינים פועלים עליו. כל פריים שיוצא מ-csi.CSI.snapshot() הוא Image; וכך גם כל פריים שנטען מהדיסק, מפוענח מ-JPEG או PNG, מוקצה מ-ndarray בסגנון numpy, או נבנה כמשטח ציור ריק.

Image מתואר על ידי שלושה מספרים – width, height ו-pixformat – בתוספת חוצץ פיקסלים רציף. פורמט הפיקסל קובע גם את פריסת הזיכרון וגם אילו פעולות זמינות:

BINARY (1 bpp) – ביט אחד לפיקסל; משמש למורפולוגיה והגדרת סף.
GRAYSCALE (8 bpp) – בית אחד לפיקסל; הפורמט המקובל לרוב פעולות הראייה הממוחשבת (AprilTag, קצוות, ORB, זרימה אופטית).
RGB565 (16 bpp) – שני בתים לפיקסל (5R/6G/5B); פורמט הצבע ברירת המחדל.
BAYER (8 bpp) – נתוני פסיפס Bayer גולמיים ישירות מהחיישן. רוב שיטות הראייה הממוחשבת אינן זמינות על תמונות Bayer; בצעו debayer ל-GRAYSCALE / RGB565 תחילה.
YUV422 (16 bpp) – צבע בדגימת כרומה משנית 4:2:2, שני בתים לפיקסל. רק חלק מהשיטות עובדות ישירות על YUV422.
JPEG / PNG – חוצצים דחוסים. פעולות ברמת הפיקסל דורשות to_grayscale() או to_rgb565() תחילה.

מהיכן מגיעים אובייקטי Image¶

ישנן ארבע דרכים להשיג Image:

מחוצץ הפריימים של המצלמה – csi.CSI().snapshot() מחזיר את הפריים הבא שנקלט. האובייקט המוחזר הוא עטיפה דקה סביב זיכרון חוצץ הפריימים של המצלמה, ולכן כל פעולת ציור / סינון עליו משנה את מה שנשלח לתצוגה המקדימה ב-IDE ולמסך.
מקובץ – העבירו מחרוזת נתיב לבנאי של Image. קבצי BMP, PGM, PPM, JPEG ו-PNG מפוענחים ישירות ל-RAM (או לחוצץ הפריימים של המצלמה אם copy_to_fb=True).
מ-ndarray – העבירו מערך float32 בצורת (h, w) או (h, w, 3). הפיקסלים מותאמים בקנה מידה מ-0.0 -- 255.0 ל-GRAYSCALE או RGB565 בהתאמה.
ריק – העבירו (width, height, pixformat) כדי להקצות משטח ציור מאופס. עבור פורמטי פיקסל דחוסים (JPEG / PNG) נדרש ארגומנט buffer= המכיל את זרם הבתים הדחוס.

לולאת קליטה-עיבוד-תצוגה טיפוסית¶

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.

אינדוקס, אורך, איטרציה וגישה דמוית-בתים¶

אינדוקס – img[i] קורא את פיקסל i (באופן ליניארי, לפי שורות). img[i] = value כותב אותו. פיקסלים מסוג Grayscale / Bayer הם מספרים שלמים של 8 ביט, פיקסלים מסוג RGB565 / YUV422 הם מספרים שלמים ארוזים של 16 ביט, פיקסלים בינאריים הם 0 / 1. עבור תמונות JPEG / PNG מרחב האינדוקס הוא זרם הבתים הדחוס, ולא פיקסלים.
אורך – len(img) מחזיר את מספר הפיקסלים עבור פורמטים לא דחוסים או את מספר הבתים עבור פורמטים דחוסים.
איטרציה – for px in img: ... עובר על מערך הפיקסלים באותו סדר של אינדוקס [].
דמוי-בתים – Image חושף את פרוטוקול חוצץ הקריאה, כך שניתן להעביר אותו ישירות לכל דבר שמקבל bytes / bytearray (למשל uart.write(img), socket.send(img), hashlib.sha256(img)). השתמשו ב-bytearray() במקום זאת כדי לקבל תצוגת קריאה/כתיבה.

דגלי רמז¶

שיטות Image רבות מקבלות ארגומנט hint שהוא OR לוגי של הדגלים הבאים:

image.AREA: השתמש בקנה מידה לפי שטח בעת הקטנה, במקום ברירת המחדל של השכן הקרוב ביותר.

image.BILINEAR: השתמש בקנה מידה דו-ליניארי במקום ברירת המחדל של קנה מידה לפי השכן הקרוב ביותר.

image.BICUBIC: השתמש בקנה מידה דו-קוּבי במקום ברירת המחדל של קנה מידה לפי השכן הקרוב ביותר.

image.CENTER: מרכז את התמונה המצוירת על המסך. מוחל לאחר קנה המידה.

image.HMIRROR: שקף את התמונה אופקית.

image.VFLIP: הפוך את התמונה אנכית.

image.TRANSPOSE: שחלף את התמונה (החלפת x/y).

image.EXTRACT_RGB_CHANNEL_FIRST: בצע חילוץ rgb_channel לפני קנה המידה.

image.APPLY_COLOR_PALETTE_FIRST: החל פלטת צבעים לפני קנה המידה.

image.SCALE_ASPECT_KEEP: התאם את התמונה המצוירת בקנה מידה כך שתיכנס לתוך המסך.

image.SCALE_ASPECT_EXPAND: התאם את התמונה המצוירת בקנה מידה כך שתמלא את המסך (גורם לחיתוך)

image.SCALE_ASPECT_IGNORE: התאם את התמונה המצוירת בקנה מידה כך שתמלא את המסך (גורם למתיחה).

image.ROTATE_90: סובב את התמונה ב-90 מעלות (זהו פשוט VFLIP | TRANSPOSE).

image.ROTATE_180: סובב את התמונה ב-180 מעלות (זהו פשוט HMIRROR | VFLIP).

image.ROTATE_270: סובב את התמונה ב-270 מעלות (זהו פשוט HMIRROR | TRANSPOSE).

image.BLACK_BACKGROUND: הנח שתמונת הרקע שעליה מציירים שחורה, מה שמאיץ את המיזוג. נתמך רק על ידי Image.draw_image() ו-Image.get_similarity().

אם arg הוא מחרוזת, פעולה זו יוצרת אובייקט תמונה חדש מקובץ בנתיב arg. תומך בטעינת קבצי תמונה bmp/pgm/ppm/jpg/jpeg/png מהדיסק. אם copy_to_fb הוא true התמונה מועתקת לחוצץ הפריימים במקום להיות מוקצית בערמה.

אם arg הוא ndarray, פעולה זו יוצרת אובייקט תמונה חדש מה-ndarray. אובייקטי ndarray בצורה של (w, h) נחשבים לתמונות בגווני אפור, (w, h, 3) נחשבים לתמונות RGB565. רק ndarrays מסוג float32 נתמכים בשלב זה. בעת יצירת תמונה בדרך זו, אם תעבירו ארגומנט buffer הוא ישמש לאחסון נתוני התמונה במקום הקצאת מקום בערמה. אם copy_to_fb הוא true התמונה מועתקת לחוצץ הפריימים במקום להיות מוקצית בערמה או באמצעות ה-buffer.

אם arg הוא int הוא נחשב לרוחב של תמונה חדשה, ועליו לבוא בעקבותיו ערך height וערך format כדי ליצור אובייקט תמונה ריק חדש. format יכול להיות כל ערך pixformat של תמונה כמו image.GRAYSCALE. התמונה תאותחל לכולה אפסים. שימו לב שערך buffer נדרש עבור פורמטי תמונה דחוסים. buffer נחשב למקור נתוני התמונה ביצירת תמונות בדרך זו. אם משתמשים בו עם copy_to_fb הנתונים מ-buffer מועתקים לחוצץ הפריימים. אם תרצו ליצור תמונת JPEG מאובייקט bytes() או bytearray() של JPEG, תוכלו להעביר את width, height, image.JPEG עבור ה-JPEG ולהגדיר את buffer לזרם הבתים של ה-JPEG כדי ליצור תמונת JPEG.

תמונות תומכות בסימון ”[]“. בצעו image[index] = 8/16-bit value כדי להקצות פיקסל בתמונה או image[index] כדי לקבל פיקסל בתמונה שיהיה ערך 8 ביט עבור תמונות grayscale/bayer או ערך 16 ביט עבור תמונות RGB565/YUV. תמונות בינאריות מחזירות ערך של ביט אחד.

עבור תמונות JPEG, הסימון ”[]“ מאפשר לכם לגשת לכתם תמונת ה-JPEG הדחוסה כמערך בתים. עם זאת, קריאה וכתיבה למערך הנתונים אטומות מכיוון שתמונות JPEG הן זרמי בתים דחוסים.

תמונות תומכות גם בפעולות חוצץ קריאה. תוכלו להעביר תמונות לכל מיני פונקציות של MicroPython כאילו התמונה הייתה אובייקט מערך בתים. בפרט, אם תרצו לשדר תמונה תוכלו פשוט להעביר אותה לפונקציות הכתיבה של UART/SPI/I2C כדי לשדרה אוטומטית.

שיטות בסיסיות¶

width() → int¶: מחזיר את רוחב התמונה בפיקסלים.

height() → int¶: מחזיר את גובה התמונה בפיקסלים.

format() → int¶: מחזיר image.GRAYSCALE עבור תמונות בגווני אפור, image.RGB565 עבור תמונות RGB565, image.BAYER עבור תמונות בתבנית bayer, ו-image.JPEG עבור תמונות JPEG.

size() → int¶: מחזיר את גודל התמונה בבתים.

bytearray() → bytearray¶: מחזיר אובייקט bytearray המצביע על נתוני התמונה לגישת קריאה/כתיבה ברמת הבית.

הערה

אובייקטי Image מומרים אוטומטית לאובייקטי bytes כשהם מועברים לדרייבר MicroPython שדורש אובייקט דמוי bytes. זוהי גישת קריאה בלבד. קראו ל-bytearray() כדי לקבל גישת קריאה/כתיבה.

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

עבור תמונות בגווני אפור: מחזיר את ערך הפיקסל בגווני אפור במיקום (x, y). עבור תמונות RGB565: מחזיר את צמד הפיקסל RGB888 (r, g, b) במיקום (x, y). עבור תמונות בתבנית bayer: מחזיר את ערך הפיקסל במיקום (x, y).

מחזיר None אם x או y נמצאים מחוץ לתמונה.

x ו-y יכולים להיות מועברים בנפרד או כצמד.

rgbtuple אם True גורם לשיטה זו להחזיר צמד RGB888. אחרת, שיטה זו מחזירה את הערך השלם של הפיקסל הבסיסי. כלומר, עבור תמונות RGB565 שיטה זו מחזירה ערך RGB565. ברירת המחדל היא True עבור תמונות RGB565 ו-False אחרת.

לא נתמך על תמונות דחוסות.

הערה

Image.get_pixel() ו-Image.set_pixel() הן השיטות היחידות המאפשרות לכם לטפל בתמונות בתבנית bayer. תמונות בתבנית bayer הן תמונות מילוליות שבהן הפיקסלים בתמונה הם R/G/R/G/וכו« עבור שורות זוגיות ו-G/B/G/B/וכו« עבור שורות אי-זוגיות. כל פיקסל הוא 8 ביט. אם תקראו לשיטה זו עם rgbtuple מוגדר, אז Image.get_pixel() יבצע debayer לתמונת המקור באותו מיקום פיקסל ויחזיר צמד RGB888 תקף עבור מיקום הפיקסל.

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

עבור תמונות בגווני אפור: מגדיר את הפיקסל במיקום (x, y) לערך גווני האפור pixel. עבור תמונות RGB565: מגדיר את הפיקסל במיקום (x, y) לצמד RGB888 (r, g, b) pixel. עבור תמונות בתבנית bayer: מגדיר את ערך הפיקסל במיקום (x, y) לערך pixel.

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

x ו-y יכולים להיות מועברים בנפרד או כצמד.

pixel יכול להיות צמד RGB888 (r, g, b) או ערך הפיקסל הבסיסי (כלומר ערך RGB565 עבור תמונות RGB565 או ערך 8 ביט עבור תמונות בגווני אפור.

לא נתמך על תמונות דחוסות.

הערה

Image.get_pixel() ו-Image.set_pixel() הן השיטות היחידות המאפשרות לכם לטפל בתמונות בתבנית bayer. תמונות בתבנית bayer הן תמונות מילוליות שבהן הפיקסלים בתמונה הם R/G/R/G/וכו« עבור שורות זוגיות ו-G/B/G/B/וכו« עבור שורות אי-זוגיות. כל פיקסל הוא 8 ביט. אם תקראו לשיטה זו עם צמד RGB888, ערך גווני האפור של אותו צמד RGB888 מחולץ ומוגדר למיקום הפיקסל.

שיטות המרה¶

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

מחזיר אובייקט ndarray שנוצר מהתמונה. זה עובד כרגע רק עבור תמונות GRAYSCALE או RGB565.

dtype יכול להיות b, B או f ליצירת ndarray מסוג 8 ביט עם סימן, 8 ביט ללא סימן, או נקודה צפה 32 ביט. תמונות GRAYSCALE מומרות ישירות לאובייקטי ndarray של 8 ביט ללא סימן. עבור אובייקטי ndarray של 8 ביט עם סימן הערכים (0:255) ממופים ל-(-127:128). עבור אובייקטי ndarray של נקודה צפה 32 ביט הערכים ממופים ל-(0.0:255.0). תמונות RGB565 מומרות לאובייקטי ndarray בעלי 3 ערוצים, ואותו תהליך המתואר לעיל עבור תמונות GRAYSCALE מוחל על כל ערוץ בהתאם ל-dtype. שימו לב ש-dtype מקבל גם את הערכים השלמים (למשל ord()) של b, B ו-f בהתאמה.

buffer אם אינו None הוא אובייקט bytearray שישמש כחוצץ עבור ה-ndarray. אם None מוקצה חוצץ חדש בערמה לאחסון נתוני התמונה של ה-ndarray. תוכלו להשתמש בארגומנט buffer כדי להקצות ישירות את ה-ndarray בחוצץ שהוקצה מראש, מה שחוסך הקצאת ערמה ופעולת העתקה.

ל-ndarray המוחזר יש את הצורה (height, width) עבור תמונות GRAYSCALE ו-(height, width, 3) עבור תמונות RGB565.

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

ממיר תמונה לתמונת מפת ביטים (ביט אחד לפיקסל).

x_scale שולט בכמה התמונה המוצגת מותאמת בקנה מידה בכיוון x (float). אם ערך זה שלילי התמונה תהפך אופקית. שימו לב שאם y_scale אינו מצוין הוא יתאים ל-x_scale כדי לשמור על יחס הממדים.

y_scale שולט בכמה התמונה המוצגת מותאמת בקנה מידה בכיוון y (float). אם ערך זה שלילי התמונה תהפך אנכית. שימו לב שאם x_scale אינו מצוין הוא יתאים ל-x_scale כדי לשמור על יחס הממדים.

roi הוא צמד מלבן אזור העניין (x, y, w, h) של תמונת המקור לציור. זה מאפשר לכם לחלץ רק את הפיקסלים שב-ROI כדי להתאים אותם בקנה מידה ולצייר על תמונת היעד.

rgb_channel הוא ערוץ ה-RGB (0=R, G=1, B=2) לחילוץ מתמונת RGB565 (אם הועברה) ולעיבוד על תמונת היעד. לדוגמה, אם תעבירו rgb_channel=1 זה יחלץ את הערוץ הירוק של תמונת המקור RGB565 ויצייר אותו בגווני אפור על תמונת היעד.

alpha שולט בכמה מתמונת המקור למזג לתוך תמונת היעד. ערך של 255 מצייר תמונת מקור אטומה בעוד ערך נמוך מ-255 מייצר מיזוג בין תמונת המקור והיעד. 0 גורם לאי-שינוי תמונת היעד.

color_palette אם אינו None יכול להיות enum של פלטת צבעים או תמונת RGB565 בת 256 פיקסלים בסך הכל שתשמש כטבלת חיפוש צבעים על ערך גווני האפור של תמונת המקור כלשהי. זה מוחל לאחר חילוץ rgb_channel אם נעשה בו שימוש.

alpha_palette אם אינו None יכול להיות תמונת GRAYSCALE בת 256 פיקסלים בסך הכל שתשמש כפלטת אלפא המווסתת את ערך ה-alpha של תמונת המקור המצוירת ברמת הפיקסל, מה שמאפשר לכם לשלוט במדויק בערך האלפא של פיקסלים בהתבסס על ערך גווני האפור שלהם. ערך פיקסל של 255 בטבלת חיפוש האלפא הוא אטום, וכל ערך נמוך מ-255 הופך שקוף יותר עד 0. זה מוחל לאחר חילוץ rgb_channel אם נעשה בו שימוש.

hint הוא OR לוגי של הדגלים המפורטים ב-Hint flags (למעט image.BLACK_BACKGROUND שאינו נתמך כאן).

transform הוא ndarray של 3x3 המשמש לביצוע טרנספורמציה פרספקטיבית על התמונה. נתמך כרגע רק על OpenMV Cam N6 מכיוון שיש לו GPU שיכול לעשות זאת בחומרה.

copy אם True יוצר עותק עמוק בערמה של התמונה שהומרה במקום להמיר את התמונה המקורית במקום.

copy_to_fb אם True התמונה נטענת ישירות לחוצץ הפריימים. ל-copy_to_fb יש עדיפות על copy. אין לכך השפעה מיוחדת אם התמונה כבר בחוצץ הפריימים.

הערה

תמונות מפת ביטים דומות לתמונות בגווני אפור עם שני ערכי פיקסל בלבד - 0 ו-1. בנוסף, תמונות מפת ביטים ארוזות כך שהן מאחסנות רק ביט אחד לפיקסל, מה שהופך אותן לקטנות מאוד. ספריית התמונות של OpenMV מאפשרת להשתמש בתמונות מפת ביטים בכל המקומות שבהם ניתן להשתמש בתמונות sensor.GRAYSCALE ו-sensor.RGB565. עם זאת, פעולות רבות כשהן מוחלות על תמונות מפת ביטים אינן הגיוניות מכיוון שלתמונות מפת ביטים יש רק 2 ערכים. OpenMV ממליצה להשתמש בתמונות מפת ביטים עבור ערכי mask בפעולות וכדומה, מכיוון שהן נכנסות בקלות רבה בערמת MicroPython. לבסוף, ערכי הפיקסל 0 ו-1 של תמונת מפת ביטים מתפרשים כשחור ולבן כשהם מוחלים על תמונות sensor.GRAYSCALE או sensor.RGB565. הספרייה מטפלת בהמרה אוטומטית.

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

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¶

ממיר תמונה לתמונה בגווני אפור (8 ביט לפיקסל).

hint הוא OR לוגי של הדגלים המפורטים ב-Hint flags (למעט image.BLACK_BACKGROUND שאינו נתמך כאן).

copy אם True יוצר עותק עמוק בערמה של התמונה שהומרה במקום להמיר את התמונה המקורית במקום.

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

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¶

ממיר תמונה לתמונת RGB565 (16 ביט לפיקסל).

hint הוא OR לוגי של הדגלים המפורטים ב-Hint flags (למעט image.BLACK_BACKGROUND שאינו נתמך כאן).

copy אם True יוצר עותק עמוק בערמה של התמונה שהומרה במקום להמיר את התמונה המקורית במקום.

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

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¶

ממיר תמונה לתמונת קשת RGB565 (16 ביט לפיקסל).

hint הוא OR לוגי של הדגלים המפורטים ב-Hint flags (למעט image.BLACK_BACKGROUND שאינו נתמך כאן).

copy אם True יוצר עותק עמוק בערמה של התמונה שהומרה במקום להמיר את התמונה המקורית במקום.

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

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¶

ממיר תמונה לתמונת ironbow RGB565 (16 ביט לפיקסל).

hint הוא OR לוגי של הדגלים המפורטים ב-Hint flags (למעט image.BLACK_BACKGROUND שאינו נתמך כאן).

copy אם True יוצר עותק עמוק בערמה של התמונה שהומרה במקום להמיר את התמונה המקורית במקום.

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

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¶

ממיר תמונה לתמונת עומק RGB565 (16 ביט לפיקסל).

color_palette אם אינו None יכול להיות image.PALETTE_DEPTH או תמונת RGB565 בת 256 פיקסלים בסך הכל שתשמש כטבלת חיפוש צבעים על ערך גווני האפור של תמונת המקור כלשהי. זה מוחל לאחר חילוץ rgb_channel אם נעשה בו שימוש.

hint הוא OR לוגי של הדגלים המפורטים ב-Hint flags (למעט image.BLACK_BACKGROUND שאינו נתמך כאן).

copy אם True יוצר עותק עמוק בערמה של התמונה שהומרה במקום להמיר את התמונה המקורית במקום.

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

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¶

ממיר תמונה לתמונת אירוע כהה RGB565 (16 ביט לפיקסל).

hint הוא OR לוגי של הדגלים המפורטים ב-Hint flags (למעט image.BLACK_BACKGROUND שאינו נתמך כאן).

copy אם True יוצר עותק עמוק בערמה של התמונה שהומרה במקום להמיר את התמונה המקורית במקום.

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

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¶

ממיר תמונה לתמונת אירוע בהיר RGB565 (16 ביט לפיקסל).

hint הוא OR לוגי של הדגלים המפורטים ב-Hint flags (למעט image.BLACK_BACKGROUND שאינו נתמך כאן).

copy אם True יוצר עותק עמוק בערמה של התמונה שהומרה במקום להמיר את התמונה המקורית במקום.

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

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¶

ממיר תמונה לתמונת JPEG.

hint הוא OR לוגי של הדגלים המפורטים ב-Hint flags (למעט image.BLACK_BACKGROUND שאינו נתמך כאן).

copy אם True יוצר עותק עמוק בערמה של התמונה שהומרה במקום להמיר את התמונה המקורית במקום.

quality שולט באיכות דחיסת תמונת ה-jpeg. הערך יכול להיות בין 0 ל-100.

subsampling יכול להיות:

image.JPEG_SUBSAMPLING_AUTO: השתמש בדגימה המשנית הטובה ביותר עבור התמונה בהתבסס על האיכות.

image.JPEG_SUBSAMPLING_444: השתמש בדגימה משנית 4:4:4.

image.JPEG_SUBSAMPLING_422: השתמש בדגימה משנית 4:2:2.

image.JPEG_SUBSAMPLING_420: השתמש בדגימה משנית 4:2:0.

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

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¶

ממיר תמונה לתמונת PNG.

hint הוא OR לוגי של הדגלים המפורטים ב-Hint flags (למעט image.BLACK_BACKGROUND שאינו נתמך כאן).

copy אם True יוצר עותק עמוק בערמה של התמונה שהומרה במקום להמיר את התמונה המקורית במקום.

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

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¶

ממיר תמונה לתמונת JPEG.

hint הוא OR לוגי של הדגלים המפורטים ב-Hint flags (למעט image.BLACK_BACKGROUND שאינו נתמך כאן).

copy אם True יוצר עותק עמוק בערמה של התמונה שהומרה במקום להמיר את התמונה המקורית במקום.

quality שולט באיכות דחיסת תמונת ה-jpeg. הערך יכול להיות בין 0 ל-100.

subsampling יכול להיות:

image.JPEG_SUBSAMPLING_AUTO: השתמש בדגימה המשנית הטובה ביותר עבור התמונה בהתבסס על האיכות.

image.JPEG_SUBSAMPLING_444: השתמש בדגימה משנית 4:4:4.

image.JPEG_SUBSAMPLING_422: השתמש בדגימה משנית 4:2:2.

image.JPEG_SUBSAMPLING_420: השתמש בדגימה משנית 4:2:0.

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

הערה

Image.compress הוא כינוי ל-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¶

יוצר עותק עמוק של אובייקט התמונה.

hint הוא OR לוגי של הדגלים המפורטים ב-Hint flags (למעט image.BLACK_BACKGROUND שאינו נתמך כאן).

copy_to_fb אם True התמונה נטענת ישירות לחוצץ הפריימים. אין לכך השפעה מיוחדת אם התמונה כבר בחוצץ הפריימים.

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

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¶

משנה תמונה במקום מבלי לשנות את טיפוס התמונה הבסיסי.

hint הוא OR לוגי של הדגלים המפורטים ב-Hint flags (למעט image.BLACK_BACKGROUND שאינו נתמך כאן).

copy אם True יוצר עותק עמוק בערמה של התמונה שהומרה במקום להמיר את התמונה המקורית במקום.

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

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¶

משנה תמונה במקום מבלי לשנות את טיפוס התמונה הבסיסי.

hint הוא OR לוגי של הדגלים המפורטים ב-Hint flags (למעט image.BLACK_BACKGROUND שאינו נתמך כאן).

copy אם True יוצר עותק עמוק בערמה של התמונה שהומרה במקום להמיר את התמונה המקורית במקום.

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

הערה

Image.scale הוא כינוי ל-Image.crop.

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

שומר עותק של התמונה במערכת הקבצים בנתיב path.

תומך בקבצי תמונה bmp/pgm/ppm/jpg/jpeg. שימו לב שלא ניתן לשמור תמונות דחוסות jpeg לפורמט לא דחוס.

roi הוא מלבן אזור העניין (x, y, w, h) שממנו לשמור. אם אינו מצוין, הוא שווה למלבן התמונה המעתיק את כל התמונה. ארגומנט זה אינו ישים עבור תמונות JPEG.

quality הוא איכות דחיסת ה-jpeg לשימוש לשמירת התמונה בפורמט jpeg אם התמונה אינה דחוסה כבר (0-100) (int).

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

flush() → None¶: מעדכן את חוצץ הפריימים ב-IDE עם התמונה בחוצץ הפריימים שעל המצלמה.

שיטות ציור¶

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

מגדיר את כל הפיקסלים בתמונה לאפס (מהיר מאוד).

mask היא תמונה אחרת המשמשת כמסכה ברמת הפיקסל עבור הפעולה. המסכה צריכה להיות תמונה עם פיקסלים שחורים או לבנים בלבד וצריכה להיות באותו גודל של התמונה שעליה פועלים. רק פיקסלים מוגדרים במסכה משתנים.

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

לא נתמך על תמונות דחוסות.

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

מצייר קו מ-(x0, y0) ל-(x1, y1) על התמונה. תוכלו להעביר את x0, y0, x1, y1 בנפרד או כצמד (x0, y0, x1, y1).

color הוא צמד RGB888 עבור תמונות Grayscale או RGB565. ברירת המחדל היא לבן. עם זאת, תוכלו גם להעביר את ערך הפיקסל הבסיסי (0-255) עבור תמונות בגווני אפור או ערך RGB565 עבור תמונות RGB565.

thickness שולט בעובי הקו בפיקסלים.

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

לא נתמך על תמונות דחוסות או תמונות bayer.

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

מצייר מלבן על התמונה. תוכלו להעביר את x, y, w, h בנפרד או כצמד (x, y, w, h).

thickness שולט בעובי הקווים בפיקסלים.

העבירו fill מוגדר ל-True כדי למלא את המלבן.

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

לא נתמך על תמונות דחוסות או תמונות bayer.

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

מצייר עיגול על התמונה. תוכלו להעביר את x, y, radius בנפרד או כצמד (x, y, radius).

thickness שולט בעובי הקצוות בפיקסלים.

העבירו fill מוגדר ל-True כדי למלא את העיגול.

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

לא נתמך על תמונות דחוסות או תמונות bayer.

draw_ellipse(cx: int, cy: int, rx: int, ry: int, rotation: int, color: int | Tuple[int, int, int] | None = None, thickness: int = 1, fill: bool = False) → Image¶

מצייר אליפסה על התמונה. תוכלו להעביר את cx, cy, rx, ry ואת הסיבוב (במעלות) בנפרד או כצמד (cx, yc, rx, ry, rotation).

thickness שולט בעובי הקצוות בפיקסלים.

העבירו fill מוגדר ל-True כדי למלא את האליפסה.

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

לא נתמך על תמונות דחוסות או תמונות bayer.

draw_string(x: int, y: int, text: str, color: int | Tuple[int, int, int] | None = None, scale: float = 1, x_spacing: int = 0, y_spacing: int = 0, mono_space: bool = True, char_rotation: int = 0, char_hmirror: bool = False, char_vflip: bool = False, string_rotation: int = 0, string_hmirror: bool = False, string_vflip: bool = False) → Image¶

מצייר טקסט בגודל 8x10 החל ממיקום (x, y) בתמונה. תוכלו להעביר את x, y בנפרד או כצמד (x, y).

text היא מחרוזת לכתיבה לתמונה. סיומי שורה \n, \r ו-\r\n מעבירים את הסמן לשורה הבאה.

scale ניתן להגדלה כדי להגדיל/להקטין את גודל הטקסט על התמונה. תוכלו להעביר ערכים שלמים גדולים מ-0 או ערכי נקודה צפה.

x_spacing מאפשר לכם להוסיף (אם חיובי) או להחסיר (אם שלילי) פיקסלים בכיוון x בין תווים.

y_spacing מאפשר לכם להוסיף (אם חיובי) או להחסיר (אם שלילי) פיקסלים בכיוון y בין תווים (עבור טקסט רב-שורתי).

mono_space ברירת המחדל היא True שכופה ריווח קבוע על הטקסט. עבור קני מידה גדולים של טקסט זה נראה נורא. הגדירו ל-False כדי לקבל ריווח תווים ברוחב לא קבוע שנראה הרבה יותר טוב.

char_rotation יכול להיות 0, 90, 180, 270 כדי לסובב כל תו במחרוזת בכמות זו.

char_hmirror אם True משקף אופקית את כל התווים במחרוזת.

char_vflip אם True הופך אנכית את כל התווים במחרוזת.

string_rotation יכול להיות 0, 90, 180, 270 כדי לסובב את המחרוזת בכמות זו.

string_hmirror אם True משקף אופקית את המחרוזת.

string_vflip אם True הופך אנכית את המחרוזת.

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

לא נתמך על תמונות דחוסות או תמונות bayer.

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

מצייר צלב במיקום x, y. תוכלו להעביר את x, y בנפרד או כצמד (x, y).

size שולט באורך שאליו משתרעים קווי הצלב.

thickness שולט בעובי הקצוות בפיקסלים.

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

לא נתמך על תמונות דחוסות או תמונות bayer.

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

מצייר חץ מ-(x0, y0) ל-(x1, y1) על התמונה. תוכלו להעביר את x0, y0, x1, y1 בנפרד או כצמד (x0, y0, x1, y1).

thickness שולט בעובי הקו בפיקסלים.

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

לא נתמך על תמונות דחוסות או תמונות bayer.

draw_detection(detection: Tuple[int, int, int, int, int, int], color1: int | Tuple[int, int, int] | None = None, color2: int | Tuple[int, int, int] | None = None, size: int = 5, thickness: int = 1, fill: bool = False, label: str | None = None, label_offset: Tuple[int, int] | None = None) → Image¶

מצייר תוצאת זיהוי על התמונה. detection הוא צמד בן 6 ערכים (rx, ry, rw, rh, cx, cy) המתאר מלבן תוחם ומרכז מסה (מוחזר בדרך כלל על ידי קוד NN או מעקב צבע).

color1 הוא צבע המלבן ו-color2 הוא צבע צלב מרכז המסה. size הוא גודל צלב מרכז המסה, thickness שולט ברוחב המתאר, ו-fill ממלא את המלבן.

label אם סופק מצויר ליד המלבן, בהיסט של label_offset (x, y).

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

לא נתמך על תמונות דחוסות או תמונות bayer.

draw_edges(corners: List[Tuple[int, int]], color: int | Tuple[int, int, int] | None = None, size: int = 0, thickness: int = 1, fill: bool = False) → Image¶

מצייר קצוות קו בין רשימת פינות המוחזרת על ידי שיטות כמו blob.corners. Corners הוא צמד בן ארבעה ערכים של צמדי x/y בני שני ערכים. למשל [(x1,y1),(x2,y2),(x3,y3),(x4,y4)].

size אם גדול מ-0 גורם לפינות להיות מצוירות כעיגולים ברדיוס size.

thickness שולט בעובי הקו בפיקסלים.

העבירו fill מוגדר ל-True כדי למלא את עיגולי הפינות אם מצוירים.

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

לא נתמך על תמונות דחוסות או תמונות bayer.

draw_image(image: Image, x: int = 0, y: int = 0, x_scale: float = 1.0, y_scale: float = 1.0, roi: Tuple[int, int, int, int] | None = None, rgb_channel: int = -1, alpha: int = 255, color_palette: int | Image | None = None, alpha_palette: Image | None = None, hint: int = 0, transform: ndarray | None = None, mask: Image | None = None) → Image¶

מצייר image שהפינה השמאלית-עליונה שלה מתחילה במיקום x, y. תוכלו להעביר את x, y בנפרד או כצמד (x, y). שיטה זו מטפלת אוטומטית בעיבוד התמונה המועברת לפורמט הפיקסל הנכון עבור תמונת היעד, תוך טיפול בחיתוך בצורה חלקה.

תוכלו גם להעביר נתיב במקום אובייקט תמונה עבור שיטה זו כדי לטעון אוטומטית את התמונה מהדיסק ולהשתמש בה בשלב אחד. למשל draw_image("test.jpg").

hint הוא OR לוגי של הדגלים המפורטים ב-Hint flags (כולל image.BLACK_BACKGROUND שנתמך כאן).

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

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¶

מצייר את נקודות המפתח של אובייקט keypoints על התמונה. תוכלו גם להעביר רשימה של צמדים בני שלושה ערכים המכילים את (x, y, rotation_angle_in_degrees) כדי להשתמש מחדש בשיטה זו לציור גליפים של נקודות מפתח שהם עיגול עם קו המצביע לכיוון מסוים.

size שולט בגודל נקודות המפתח.

thickness שולט בעובי הקו בפיקסלים.

העבירו fill מוגדר ל-True כדי למלא את נקודות המפתח.

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

לא נתמך על תמונות דחוסות או תמונות bayer.

flood_fill(x: int, y: int, seed_threshold: float = 0.05, floating_threshold: float = 0.05, color: int | Tuple[int, int, int] | None = None, invert: bool = False, clear_background: bool = False, mask: Image | None = None) → Image¶

ממלא בהצפה אזור של התמונה החל ממיקום x, y. תוכלו להעביר את x, y בנפרד או כצמד (x, y).

seed_threshold שולט בכמה כל פיקסל באזור המילוי יכול להיות שונה מפיקסל ההתחלה המקורי.

floating_threshold שולט בכמה כל פיקסל באזור המילוי יכול להיות שונה מכל פיקסל שכן.

העבירו invert כ-True כדי לצבוע מחדש את כל מה שמחוץ לאזור המחובר של מילוי ההצפה.

העבירו clear_background כ-True כדי לאפס את שאר הפיקסלים שמילוי ההצפה לא צבע מחדש.

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

לא נתמך על תמונות דחוסות או תמונות bayer.

שיטה זו אינה זמינה על OpenMV Cam M4.

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

מבצע רסטריזציה של ndarray אירועים (כפי שמולא על ידי csi.IOCTL_GENX320_READ_EVENTS) על Image להמחשה. חוצץ התמונה חייב להיות תמונת GRAYSCALE בגודל 320x320.

עבור כל שורת csi.PIX_ON_EVENT הפיקסל של האירוע מקבל +contrast נוסף; עבור כל שורת csi.PIX_OFF_EVENT הפיקסל מקבל -contrast. אירועי טריגר מתעלמים מהם. ערכי פיקסל מוגבלים ל-0-255.

clear אם True מאפס את חוצץ התמונה ל-brightness לפני הציור — כל פריים הופך לעיבוד אירועים-בלבד טרי. הגדירו ל-False כדי לצבור אירועים על פני קריאות מרובות (שימושי לשובלי תנועה בחשיפה ארוכה).

brightness שולט בקו הבסיס של אפור-בינוני שאליו מאופס החוצץ כש-clear הוא True. ברירת המחדל 128 מציבה אירועי ON בקצה הבהיר ואירועי OFF בקצה הכהה עם מרווח שווה.

contrast שולט בכמה כל אירוע מזיז את הפיקסל שלו — ערכים גבוהים יותר גורמים לאירועים לבלוט, במחיר רוויה מהירה כשאירועים רבים נוחתים על אותו פיקסל.

שיטות מיסוך¶

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

מאפס חלק מלבני של התמונה. אם לא סופקו ארגומנטים שיטה זו מאפסת את מרכז התמונה.

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

לא נתמך על תמונות דחוסות או תמונות bayer.

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

מאפס חלק עגול של התמונה. אם לא סופקו ארגומנטים שיטה זו מאפסת את מרכז התמונה.

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

לא נתמך על תמונות דחוסות או תמונות bayer.

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

מאפס חלק בצורת אליפסה של התמונה. אם לא סופקו ארגומנטים שיטה זו מאפסת את מרכז התמונה.

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

לא נתמך על תמונות דחוסות או תמונות bayer.

שיטות בינאריות¶

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

מגדיר את כל הפיקסלים בתמונה לשחור או לבן בהתאם לשאלה האם כל פיקסל נמצא בתוך אחד מצמדי הסף ב-thresholds.

thresholds היא רשימה של צמדי (lo, hi) עבור תמונות בגווני אפור, או צמדי (l_lo, l_hi, a_lo, a_hi, b_lo, b_hi) עבור תמונות RGB565. ערכי min/max מוחלפים מתוקנים אוטומטית; רכיבים חסרים מקבלים כברירת מחדל את הטווח המרבי.

invert הופך את התאמת הסף.

zero אם True, מאפס פיקסלים שעברו סף ומשאיר אחרים ללא שינוי.

mask היא תמונה בינארית המשמשת כמסכה ברמת הפיקסל; רק פיקסלים מוגדרים במסכה משתנים.

to_bitmap אם True, ממיר את נתוני התמונה למפת ביטים של ביט אחד לפיקסל. עבור תמונות קטנות מאוד זה עשוי לדרוש copy=True.

copy אם True, מחזיר תמונה חדשה בערמה במקום לשנות את תמונת המקור.

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

לא נתמך על תמונות דחוסות או תמונות bayer.

invert() → Image¶

הופך את כל ערכי הפיקסל בתמונה (כל פיקסל הופך ל-255 - pixel עבור ערוצים של 8 ביט).

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

לא נתמך על תמונות דחוסות או תמונות bayer/yuv.

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

מבצע AND לוגי בין תמונה זו לתמונה אחרת.

image יכול להיות אובייקט תמונה, נתיב לקובץ תמונה לא דחוס (bmp/pgm/ppm), או ערך סקלרי (צמד RGB888 או ערך פיקסל בסיסי).

mask היא תמונה בינארית המשמשת כמסכה ברמת הפיקסל; רק פיקסלים מוגדרים במסכה משתנים.

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

לא נתמך על תמונות דחוסות או תמונות bayer.

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

מבצע NAND לוגי בין תמונה זו לתמונה אחרת.

image יכול להיות אובייקט תמונה, נתיב לקובץ תמונה לא דחוס (bmp/pgm/ppm), או ערך סקלרי (צמד RGB888 או ערך פיקסל בסיסי).

mask היא תמונה בינארית המשמשת כמסכה ברמת הפיקסל; רק פיקסלים מוגדרים במסכה משתנים.

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

לא נתמך על תמונות דחוסות או תמונות bayer.

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

מבצע OR לוגי בין תמונה זו לתמונה אחרת.

image יכול להיות אובייקט תמונה, נתיב לקובץ תמונה לא דחוס (bmp/pgm/ppm), או ערך סקלרי (צמד RGB888 או ערך פיקסל בסיסי).

mask היא תמונה בינארית המשמשת כמסכה ברמת הפיקסל; רק פיקסלים מוגדרים במסכה משתנים.

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

לא נתמך על תמונות דחוסות או תמונות bayer.

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

מבצע NOR לוגי בין תמונה זו לתמונה אחרת.

image יכול להיות אובייקט תמונה, נתיב לקובץ תמונה לא דחוס (bmp/pgm/ppm), או ערך סקלרי (צמד RGB888 או ערך פיקסל בסיסי).

mask היא תמונה בינארית המשמשת כמסכה ברמת הפיקסל; רק פיקסלים מוגדרים במסכה משתנים.

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

לא נתמך על תמונות דחוסות או תמונות bayer.

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

מבצע XOR לוגי בין תמונה זו לתמונה אחרת.

image יכול להיות אובייקט תמונה, נתיב לקובץ תמונה לא דחוס (bmp/pgm/ppm), או ערך סקלרי (צמד RGB888 או ערך פיקסל בסיסי).

mask היא תמונה בינארית המשמשת כמסכה ברמת הפיקסל; רק פיקסלים מוגדרים במסכה משתנים.

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

לא נתמך על תמונות דחוסות או תמונות bayer.

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

מבצע XNOR לוגי בין תמונה זו לתמונה אחרת.

image יכול להיות אובייקט תמונה, נתיב לקובץ תמונה לא דחוס (bmp/pgm/ppm), או ערך סקלרי (צמד RGB888 או ערך פיקסל בסיסי).

mask היא תמונה בינארית המשמשת כמסכה ברמת הפיקסל; רק פיקסלים מוגדרים במסכה משתנים.

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

לא נתמך על תמונות דחוסות או תמונות bayer.

שיטות ISP¶

awb(max: bool = False) → Image¶

מבצע איזון לבן אוטומטי על התמונה באמצעות אלגוריתם gray-world. פועל על תמונות RAW Bayer או RGB565. אין לו השפעה על תמונות בינאריות/גווני אפור.

max אם True, משתמש באלגוריתם white-patch במקום.

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

לא נתמך על תמונות דחוסות או yuv.

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

מכפיל את מטריצת תיקון הצבע של נקודה צפה המועברת עם התמונה. מטריצות יכולות להיות 3x3 או 3x4 (עם עמודת היסט), בצורת רשימה מקוננת או רשימה שטוחה:

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

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

לא נתמך על תמונות דחוסות או תמונות bayer/yuv.

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

מתאים את הגמא, הניגודיות והבהירות של התמונה.

gamma מחיל pow(pixel, 1/gamma) לאחר נרמול. ערכים גדולים מ-1.0 מבהירים; קטנים מ-1.0 מכהים.

contrast מחיל pixel * contrast לאחר נרמול.

brightness מחיל pixel + brightness לאחר נרמול.

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

לא נתמך על תמונות דחוסות או תמונות bayer/yuv.

gamma_corr(gamma: float = 1.0, contrast: float = 1.0, brightness: float = 0.0) → Image¶: כינוי ל-Image.gamma.

שיטות מתמטיות¶

negate() → Image¶: כינוי ל-Image.invert.

replace(image: Image | None = None, **kwargs) → Image¶: כינוי ל-Image.draw_image(). מחליף תמונה זו ב-image (או מבצע טרנספורמציה של תמונה זו במקום אם image מושמט) באמצעות ארגומנטי מילות המפתח הסטנדרטיים של draw_image. הארגומנט transform הוא ndarray של 3x3 המתאר טרנספורמציה פרספקטיבית (נתמך רק על מצלמות OpenMV עם ULAB מאופשר).

assign(image: Image | None = None, **kwargs) → Image¶: כינוי ל-Image.replace().

set(image: Image | None = None, **kwargs) → Image¶: כינוי ל-Image.replace().

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

מוסיף תמונה לזו, פיקסל אחר פיקסל.

image יכול להיות אובייקט תמונה, נתיב לקובץ תמונה לא דחוס (bmp/pgm/ppm), או ערך סקלרי (צמד RGB888 או ערך פיקסל בסיסי).

mask היא תמונה בינארית המשמשת כמסכה ברמת הפיקסל; רק פיקסלים מוגדרים במסכה משתנים.

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

לא נתמך על תמונות דחוסות או תמונות bayer.

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

מחסיר image מתמונה זו, פיקסל אחר פיקסל (self - image).

image יכול להיות אובייקט תמונה, נתיב לקובץ תמונה לא דחוס (bmp/pgm/ppm), או ערך סקלרי (צמד RGB888 או ערך פיקסל בסיסי).

mask היא תמונה בינארית המשמשת כמסכה ברמת הפיקסל; רק פיקסלים מוגדרים במסכה משתנים.

שיטה זו מקבלת גם את הסט המלא של ארגומנטי מילות המפתח של Image.draw_image() (x, y, x_scale, y_scale, roi, rgb_channel, alpha, color_palette, alpha_palette, hint, transform).

לא נתמך על תמונות דחוסות או תמונות bayer.

rsub(image: Image, mask: Image | None = None) → Image¶: חיסור הפוך: מחליף תמונה זו ב-image - self פיקסל אחר פיקסל. אחרת זהה ל-Image.sub().

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

מחזיר את תמונת המינימום של שתי תמונות, פיקסל אחר פיקסל.

image יכול להיות אובייקט תמונה, נתיב לקובץ תמונה לא דחוס (bmp/pgm/ppm), או ערך סקלרי (צמד RGB888 או ערך פיקסל בסיסי).

mask היא תמונה בינארית המשמשת כמסכה ברמת הפיקסל; רק פיקסלים מוגדרים במסכה משתנים.

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

לא נתמך על תמונות דחוסות או תמונות bayer.

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

מחזיר את תמונת המקסימום של שתי תמונות, פיקסל אחר פיקסל.

image יכול להיות אובייקט תמונה, נתיב לקובץ תמונה לא דחוס (bmp/pgm/ppm), או ערך סקלרי (צמד RGB888 או ערך פיקסל בסיסי).

mask היא תמונה בינארית המשמשת כמסכה ברמת הפיקסל; רק פיקסלים מוגדרים במסכה משתנים.

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

לא נתמך על תמונות דחוסות או תמונות bayer.

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

מחזיר את תמונת ההפרש המוחלט בין שתי תמונות (למשל ||a-b||).

image יכול להיות אובייקט תמונה, נתיב לקובץ תמונה לא דחוס (bmp/pgm/ppm), או ערך סקלרי (צמד RGB888 או ערך פיקסל בסיסי).

mask היא תמונה בינארית המשמשת כמסכה ברמת הפיקסל; רק פיקסלים מוגדרים במסכה משתנים.

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

לא נתמך על תמונות דחוסות או תמונות bayer.

blend(image: Image, x: int = 0, y: int = 0, alpha: int = 128, mask: Image | None = None, **kwargs) → Image¶: כינוי ל-Image.draw_image(). ממזג ב-alpha את image לתוך תמונה זו. alpha הוא מספר שלם 0-256; ערכים קרובים יותר ל-256 מעדיפים את תמונת המקור. מקבל את כל ארגומנטי מילות המפתח של Image.draw_image().

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

מריץ השוואת היסטוגרמה על התמונה כדי לנרמל ניגודיות ובהירות.

adaptive אם True, מריץ השוואת היסטוגרמה אדפטיבית (איטי יותר אך בדרך כלל טוב יותר).

clip_limit מגביל את הניגודיות בגרסה האדפטיבית (ערך קטן כמו 10 מפיק תוצאות CLAHE טובות).

mask היא תמונה בינארית המשמשת כמסכה ברמת הפיקסל; רק פיקסלים מוגדרים במסכה משתנים.

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

לא נתמך על תמונות דחוסות או תמונות bayer.

שיטות סינון¶

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

מסיר פיקסלים מקצוות אזורים מפולחים. מבצע קונבולוציה של גרעין ((size*2)+1)x((size*2)+1) על פני התמונה, מנקה את הפיקסל המרכזי אם יותר מ-threshold שכנים נקיים (פועל כ-erode סטנדרטי אם threshold הוא None).

mask היא תמונה בינארית המשמשת כמסכה ברמת הפיקסל; רק פיקסלים מוגדרים במסכה משתנים.

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

לא נתמך על תמונות דחוסות או תמונות bayer/yuv.

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

מוסיף פיקסלים לקצוות אזורים מפולחים. מבצע קונבולוציה של גרעין ((size*2)+1)x((size*2)+1) על פני התמונה, מגדיר את הפיקסל המרכזי אם יותר מ-threshold שכנים מוגדרים (פועל כ-dilate סטנדרטי אם threshold הוא None).

mask היא תמונה בינארית המשמשת כמסכה ברמת הפיקסל; רק פיקסלים מוגדרים במסכה משתנים.

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

לא נתמך על תמונות דחוסות או תמונות bayer/yuv.

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

מבצע erosion ואז dilation. ראו Image.erode() ו-Image.dilate().

mask היא תמונה בינארית המשמשת כמסכה ברמת הפיקסל; רק פיקסלים מוגדרים במסכה משתנים.

לא נתמך על תמונות דחוסות או תמונות bayer/yuv.

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

מבצע dilation ואז erosion. ראו Image.dilate() ו-Image.erode().

mask היא תמונה בינארית המשמשת כמסכה ברמת הפיקסל; רק פיקסלים מוגדרים במסכה משתנים.

לא נתמך על תמונות דחוסות או תמונות bayer/yuv.

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

מחזיר את הפרש התמונה בין התמונה לבין התמונה לאחר Image.open().

mask היא תמונה בינארית המשמשת כמסכה ברמת הפיקסל; רק פיקסלים מוגדרים במסכה משתנים.

לא נתמך על תמונות דחוסות או תמונות bayer/yuv.

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

מחזיר את הפרש התמונה בין התמונה לבין התמונה לאחר Image.close().

mask היא תמונה בינארית המשמשת כמסכה ברמת הפיקסל; רק פיקסלים מוגדרים במסכה משתנים.

לא נתמך על תמונות דחוסות או תמונות bayer/yuv.

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

מסנן טשטוש ממוצע סטנדרטי באמצעות מסנן תיבה.

size הוא גודל הגרעין. השתמשו ב-1 (גרעין 3x3), 2 (גרעין 5x5), וכו«.

threshold אם True, מגדיר באופן אדפטיבי סף על פלט המסנן לתמונה בינארית. offset מזיז את הבינריזציה (שלילי הופך יותר פיקסלים ללבנים, חיובי הופך פחות). invert הופך את הפלט הבינארי.

mask היא תמונה בינארית המשמשת כמסכה ברמת הפיקסל; רק פיקסלים מוגדרים במסכה משתנים.

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

לא נתמך על תמונות דחוסות או תמונות bayer/yuv.

מריץ מסנן אחוזון על התמונה (חציון כברירת מחדל).

size הוא גודל הגרעין. השתמשו ב-1 (גרעין 3x3), 2 (גרעין 5x5), וכו«.

percentile הוא האחוזון לבחירה מכל גרעין (0 = מינימום, 0.5 = חציון, 1.0 = מקסימום). ברירת המחדל היא 0.5.

mask היא תמונה בינארית המשמשת כמסכה ברמת הפיקסל; רק פיקסלים מוגדרים במסכה משתנים.

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

לא נתמך על תמונות דחוסות או תמונות bayer/yuv.

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

מחליף כל פיקסל בשכיח של שכניו. עשוי להפיק עיוותים על קצוות תמונות RGB עקב הפעולה הלא-ליניארית.

size הוא גודל הגרעין. השתמשו ב-1 (גרעין 3x3), 2 (גרעין 5x5), וכו«.

mask היא תמונה בינארית המשמשת כמסכה ברמת הפיקסל; רק פיקסלים מוגדרים במסכה משתנים.

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

לא נתמך על תמונות דחוסות או תמונות bayer/yuv.

מריץ את מסנן נקודת האמצע על התמונה. מסנן זה מוצא את נקודת האמצע ((max-min)/2) של כל סביבת פיקסל בתמונה.

size הוא גודל הגרעין. השתמשו ב-1 (גרעין 3x3), 2 (גרעין 5x5), וכו«.

bias שולט בערבוב min/max. 0 לסינון min בלבד, 1.0 לסינון max בלבד. באמצעות bias תוכלו לסנן את התמונה ב-min/max.

mask היא תמונה בינארית המשמשת כמסכה ברמת הפיקסל; רק פיקסלים מוגדרים במסכה משתנים.

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

לא נתמך על תמונות דחוסות או תמונות bayer/yuv.

מבצע קונבולוציה של התמונה עם גרעין מסנן שרירותי.

size שולט בגודל הגרעין, שחייב להיות ((size*2)+1)x((size*2)+1) אלמנטים.

kernel הוא הגרעין לקונבולוציה, כרשימה/צמד חד-ממדי שטוח של ((size*2)+1)*((size*2)+1) אלמנטים, או כרשימה/צמד דו-ממדי עם ((size*2)+1) שורות של ((size*2)+1) אלמנטים.

mul הוא קנה מידה כפלי של ניגודיות (ברירת מחדל 1.0).

add הוא היסט חיבורי של בהירות (ברירת מחדל 0.0).

mask היא תמונה בינארית המשמשת כמסכה ברמת הפיקסל; רק פיקסלים מוגדרים במסכה משתנים.

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

לא נתמך על תמונות דחוסות או תמונות bayer/yuv.

מבצע קונבולוציה של התמונה עם גרעין גאוסיאני מחליק.

size הוא גודל הגרעין. השתמשו ב-1 (גרעין 3x3), 2 (גרעין 5x5), וכו«.

unsharp אם True, מבצע פעולת unsharp mask (מחדד קצוות) במקום גאוסיאן רגיל.

mul הוא קנה מידה כפלי של ניגודיות (ברירת מחדל 1.0).

add הוא היסט חיבורי של בהירות (ברירת מחדל 0.0).

mask היא תמונה בינארית המשמשת כמסכה ברמת הפיקסל; רק פיקסלים מוגדרים במסכה משתנים.

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

לא נתמך על תמונות דחוסות או תמונות bayer/yuv.

laplacian(size: int, sharpen: bool | None = False, mul: float | None = 1.0, add: float | None = 0.0, threshold: bool | None = False, offset: int | None = 0, invert: bool | None = False, mask: Image | None = None) → Image¶: מבצע קונבולוציה של התמונה עם גרעין לפלסיאני לזיהוי קצוות.

size הוא גודל הגרעין. השתמשו ב-1 (גרעין 3x3), 2 (גרעין 5x5), וכו«.

sharpen אם True, מחדד את התמונה במקום להוציא את תגובת הקצה הגולמית ללא סף.

mul הוא קנה מידה כפלי של ניגודיות (ברירת מחדל 1.0).

add הוא היסט חיבורי של בהירות (ברירת מחדל 0.0).

threshold אם True, מגדיר באופן אדפטיבי סף על פלט המסנן לתמונה בינארית. offset מזיז את הבינריזציה (שלילי הופך יותר פיקסלים ללבנים, חיובי הופך פחות). invert הופך את הפלט הבינארי.

mask היא תמונה בינארית המשמשת כמסכה ברמת הפיקסל; רק פיקסלים מוגדרים במסכה משתנים.

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

לא נתמך על תמונות דחוסות או תמונות bayer/yuv.

מבצע קונבולוציה של התמונה עם מסנן דו-צדדי (החלקה משמרת קצוות).

size הוא גודל הגרעין. השתמשו ב-1 (גרעין 3x3), 2 (גרעין 5x5), וכו«.

color_sigma שולט בסבילות התאמת הצבע; ערכים גדולים יותר מפיקים יותר טשטוש צבע.

space_sigma שולט בטשטוש המרחבי; ערכים גדולים יותר מפיקים יותר טשטוש פיקסלים.

mask היא תמונה בינארית המשמשת כמסכה ברמת הפיקסל; רק פיקסלים מוגדרים במסכה משתנים.

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

לא נתמך על תמונות דחוסות או תמונות bayer/yuv.

שיטות גאומטריות¶

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

מקרין מחדש תמונה מקואורדינטות קרטזיות לקואורדינטות פולריות ליניאריות.

הגדירו reverse=True כדי להקרין מחדש בכיוון ההפוך.

x ו-y מציינים את קואורדינטת מרכז הטרנספורמציה בפיקסלים של התמונה. אם x הוא None (ברירת המחדל) הוא מוגדר לחצי רוחב התמונה; באופן דומה y מקבל כברירת מחדל חצי גובה התמונה.

הקרנה מחדש פולרית ליניארית הופכת סיבוב של תמונה להזזה בכיוון x.

לא נתמך על תמונות דחוסות או תמונות bayer.

שיטה זו אינה זמינה על OpenMV Cam M4.

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

מקרין מחדש תמונה מקואורדינטות קרטזיות לקואורדינטות פולריות לוגריתמיות.

הגדירו reverse=True כדי להקרין מחדש בכיוון ההפוך.

הקרנה מחדש פולרית לוגריתמית הופכת סיבוב של תמונה להזזה בכיוון x וקנה מידה/זום להזזה בכיוון y.

לא נתמך על תמונות דחוסות או תמונות bayer.

שיטה זו אינה זמינה על OpenMV Cam M4.

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

מבצע תיקון עדשה לביטול אפקט עין-הדג בתמונה עקב עיוות העדשה.

strength הוא float המגדיר כמה לבטל את אפקט עין-הדג בתמונה. נסו 1.8 כברירת מחדל ואז הגדילו או הקטינו משם עד שהתמונה נראית טוב.

zoom הוא הכמות לזום פנימה בתמונה. 1.0 כברירת מחדל.

x_corr היסט פיקסל של נקודה צפה ממרכז. יכול להיות שלילי או חיובי.

y_corr היסט פיקסל של נקודה צפה ממרכז. יכול להיות שלילי או חיובי.

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

לא נתמך על תמונות דחוסות או תמונות bayer.

rotation_corr(x_rotation: float = 0.0, y_rotation: float = 0.0, z_rotation: float = 0.0, x_translation: float = 0.0, y_translation: float = 0.0, zoom: float = 1.0, fov: float = 60.0, corners: List[Tuple[int, int]] | None = None) → Image¶

מתקן בעיות פרספקטיבה בתמונה על ידי ביצוע סיבוב תלת-ממדי של חוצץ הפריימים.

x_rotation הוא מספר המעלות לסיבוב התמונה בחוצץ הפריימים סביב ציר x (כלומר זה מסובב את התמונה למעלה ולמטה).

y_rotation הוא מספר המעלות לסיבוב התמונה בחוצץ הפריימים סביב ציר y (כלומר זה מסובב את התמונה שמאלה וימינה).

z_rotation הוא מספר המעלות לסיבוב התמונה בחוצץ הפריימים סביב ציר z (כלומר זה מסובב את התמונה במקומה).

x_translation הוא מספר היחידות להזיז את התמונה שמאלה או ימינה לאחר הסיבוב. מכיוון שהזזה זו מוחלת במרחב תלת-ממדי היחידות אינן פיקסלים…

y_translation הוא מספר היחידות להזיז את התמונה למעלה או למטה לאחר הסיבוב. מכיוון שהזזה זו מוחלת במרחב תלת-ממדי היחידות אינן פיקסלים…

zoom הוא הכמות לזום פנימה בתמונה. 1.0 כברירת מחדל.

fov הוא שדה הראייה המשמש להקרנה הפנימית 2D->3D. ככל ש-fov מתקרב ל-0 התמונה מוצבת באינסוף; ככל שהוא מתקרב ל-180 התמונה מוצבת בתוך אזור התצוגה.

corners היא רשימה של ארבעה צמדי (x, y) המשמשים לבניית הומוגרפיה בת 4 נקודות הממפה את הפינות ל-(0, 0), (image_width-1, 0), (image_width-1, image_height-1), ו-(0, image_height-1) לפני החלת הסיבוב התלת-ממדי. שימושי לטרנספורמציות מבט-על.

מחזיר את אובייקט התמונה כך שתוכלו לקרוא לשיטה אחרת באמצעות סימון ..

לא נתמך על תמונות דחוסות או תמונות bayer.

שיטה זו אינה זמינה על OpenMV Cam M4.

שיטות קבלה¶

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¶

מחשב את הדמיון בין שתי תמונות באמצעות מדד הדמיון המבני (SSIM). SSIM נע מ-1- (הפוך) עד 1 (זהה). מחזיר אובייקט image.similarity.

image היא התמונה להשוואה (אובייקט תמונה או מחרוזת נתיב, למשל "test.jpg").

x, y, x_scale, y_scale, roi, rgb_channel, alpha, color_palette, alpha_palette, hint ו-transform מקבלים את אותם ערכים כמו Image.draw_image().

dssim אם True, מחזיר במקום זאת את מדד אי-הדמיון המבני (DSSIM), שבו 0 פירושו זהה ו-1 פירושו שונה לחלוטין.

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¶

מחשב את ההיסטוגרמה המנורמלת על כל ערוצי הצבע עבור roi ומחזיר אובייקט image.histogram. זמין גם כ-Image.get_hist() או Image.histogram().

thresholds היא רשימה של צמדי (lo, hi) עבור תמונות בגווני אפור, או צמדי (l_lo, l_hi, a_lo, a_hi, b_lo, b_hi) עבור תמונות RGB565. אם הועבר, ההיסטוגרמה מחושבת רק על פני פיקסלים בתוך הספים.

invert הופך את התאמת הסף.

roi הוא צמד מלבן אזור העניין (x, y, w, h). ברירת המחדל היא מלבן התמונה.

bins (גווני אפור) או l_bins/a_bins/b_bins (RGB565) קובעים את מספר תאי ההיסטוגרמה לכל ערוץ. חייב להיות גדול מ-2. ברירת המחדל היא מספר התאים המרבי לכל ערוץ.

difference ניתן להגדרה לאובייקט תמונה כדי לפעול על ההפרש בין התמונה הנוכחית לאותה תמונה ללא חוצץ נוסף.

לא נתמך על תמונות דחוסות או תמונות bayer.

get_statistics(thresholds: List[Tuple[int, int]] | None = None, invert: bool = False, roi: Tuple[int, int, int, int] | None = None, bins: int = -1, l_bins: int = -1, a_bins: int = -1, b_bins: int = -1, difference: Image | None = None) → statistics¶

מחשב את הממוצע, החציון, השכיח, סטיית התקן, המינימום, המקסימום, הרבעון התחתון והרבעון העליון עבור כל ערוצי הצבע עבור roi ומחזיר אובייקט image.statistics. זמין גם כ-Image.get_stats() או Image.statistics().

thresholds היא רשימה של צמדי (lo, hi) עבור תמונות בגווני אפור, או צמדי (l_lo, l_hi, a_lo, a_hi, b_lo, b_hi) עבור תמונות RGB565. אם הועבר, הסטטיסטיקה מחושבת רק על פני פיקסלים בתוך הספים.

invert הופך את התאמת הסף.

roi הוא צמד מלבן אזור העניין (x, y, w, h). ברירת המחדל היא מלבן התמונה.

difference ניתן להגדרה לאובייקט תמונה כדי לפעול על ההפרש בין התמונה הנוכחית לאותה תמונה ללא חוצץ נוסף.

לא נתמך על תמונות דחוסות או תמונות bayer.

get_regression(thresholds: List[Tuple[int, int]], invert: bool = False, roi: Tuple[int, int, int, int] | None = None, x_stride: int = 2, y_stride: int = 1, area_threshold: int = 10, pixels_threshold: int = 10, target_size: Tuple[int, int] = (80, 60)) → line¶

מחשב רגרסיה ליניארית (Theil-Sen) על כל הפיקסלים שעברו סף בתמונה. מחזיר אובייקט image.line, או None אם לא נמצא קו.

thresholds היא רשימה של צמדי (lo, hi) עבור תמונות בגווני אפור, או צמדי (l_lo, l_hi, a_lo, a_hi, b_lo, b_hi) עבור תמונות RGB565.

invert הופך את התאמת הסף.

roi הוא צמד מלבן אזור העניין (x, y, w, h). ברירת המחדל היא מלבן התמונה.

x_stride ו-y_stride שולטים בכמה פיקסלים מדלגים תוך כדי הערכת התמונה.

area_threshold שטח תיבה תוחמת מינימלי; תוצאות קטנות יותר מחזירות None.

pixels_threshold ספירת פיקסלים מינימלית שעברה סף; תוצאות קטנות יותר מחזירות None.

target_size הוא צמד (w, h). ה-ROI מוקטן בקנה מידה לפי שטח כדי להיכנס לתוך גודל זה לפני הרצת האלגוריתם O(N^2). ברירת המחדל היא (80, 60).

לא נתמך על תמונות דחוסות או תמונות bayer.

שיטות זיהוי¶

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

מוצא את כל הרכיבים (אזורי פיקסלים מחוברים שעוברים בדיקת סף) בתמונה ומחזיר רשימה של אובייקטי image.blob.

thresholds היא רשימה של צמדי (lo, hi) עבור תמונות בגווני אפור, או צמדי (l_lo, l_hi, a_lo, a_hi, b_lo, b_hi) עבור תמונות RGB565 (ערוצי LAB). ניתן להעביר עד 32 צמדים. ערכי min/max מוחלפים מתוקנים אוטומטית; רכיבים חסרים מקבלים כברירת מחדל את הטווח המרבי.

invert הופך את התאמת הסף.

roi הוא צמד מלבן אזור העניין (x, y, w, h). ברירת המחדל היא מלבן התמונה.

x_stride ו-y_stride שולטים בכמה פיקסלים מדלגים תוך כדי חיפוש רכיב. הגדילו אם ידוע שהרכיבים גדולים.

area_threshold שטח תיבה תוחמת מינימלי; רכיבים קטנים יותר מסוננים.

pixels_threshold ספירת פיקסלים מינימלית שעברה סף; רכיבים קטנים יותר מסוננים.

merge אם True ממזג רכיבים שמלבני התיחום שלהם מצטלבים. margin מגדיל/מקטין את מלבני התיחום המשמשים לחיתוך. רכיבים ממוזגים מבצעים OR בין וקטורי הביט code שלהם (ביט אחד לכל סף).

threshold_cb נקרא עבור כל רכיב לאחר הגדרת הסף; החזירו True לשמירה, False לסינון.

merge_cb נקרא עבור כל זוג רכיבים שעומדים להתמזג; החזירו True כדי לאפשר את המיזוג, False כדי למנוע אותו.

x_hist_bins_max אם שונה מאפס, ממלא כל רכיב בהיטל x_histogram עם מספר תאים זה.

y_hist_bins_max אם שונה מאפס, ממלא כל רכיב בהיטל y_histogram עם מספר תאים זה.

לא נתמך על תמונות דחוסות או תמונות bayer.

find_lines(roi: Tuple[int, int, int, int] | None = None, x_stride: int = 2, y_stride: int = 1, threshold: int = 1000, theta_margin: int = 25, rho_margin: int = 25) → List[line]¶

מוצא את כל הקווים האינסופיים בתמונה באמצעות טרנספורם הוף. מחזיר רשימה של אובייקטי image.line.

roi הוא צמד מלבן אזור העניין (x, y, w, h). ברירת המחדל היא מלבן התמונה.

x_stride ו-y_stride שולטים בכמה פיקסלים מדלגים במהלך טרנספורם הוף.

threshold עוצמת קו מינימלית (סכום עוצמות סובל לאורך הקו); קווים מתחת לזה מסוננים החוצה.

theta_margin ו-rho_margin שולטים במיזוג: קווים בתוך ספים אלה ממוזגים.

לא נתמך על תמונות דחוסות או תמונות bayer.

שיטה זו אינה זמינה על 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]¶

מוצא קטעי קו בתמונה. מחזיר רשימה של אובייקטי image.line.

roi הוא צמד מלבן אזור העניין (x, y, w, h). ברירת המחדל היא מלבן התמונה.

merge_distance הוא ההפרדה המרבית בפיקסלים בין שני קטעים כדי שימוזגו.

max_theta_difference הוא הפרש התטא המרבי במעלות בין קטעים כדי שימוזגו.

שיטה זו אינה זמינה על 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]¶

מוצא עיגולים בתמונה באמצעות טרנספורם הוף. מחזיר רשימה של אובייקטי image.circle.

roi הוא צמד מלבן אזור העניין (x, y, w, h). ברירת המחדל היא מלבן התמונה.

x_stride ו-y_stride שולטים בכמה פיקסלים מדלגים במהלך טרנספורם הוף.

threshold עוצמת עיגול מינימלית (סכום עוצמות סובל לאורך העיגול); עיגולים מתחת לזה מסוננים החוצה.

x_margin, y_margin ו-r_margin שולטים במיזוג: עיגולים בתוך ספים אלה ממוזגים.

r_min רדיוס עיגול מינימלי. ברירת המחדל היא 2.

r_max רדיוס עיגול מרבי. ברירת המחדל היא min(roi.w/2, roi.h/2).

r_step גודל צעד הרדיוס. ברירת המחדל היא 2.

שיטה זו אינה זמינה על OpenMV Cam M4.

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

מוצא מלבנים בתמונה באמצעות אלגוריתם זיהוי הריבועים של apriltag. מחזיר רשימה של אובייקטי image.rect.

roi הוא צמד מלבן אזור העניין (x, y, w, h). ברירת המחדל היא מלבן התמונה.

threshold עוצמת קצה מינימלית (סכום עוצמות סובל לאורך קצוות המלבן); מלבנים מתחת לזה מסוננים החוצה.

שיטה זו אינה זמינה על OpenMV Cam M4.

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

מוצא את כל ה-qrcodes בתוך ה-roi ומחזיר רשימה של אובייקטי image.qrcode.

roi הוא צמד מלבן אזור העניין (x, y, w, h). ברירת המחדל היא מלבן התמונה.

שיטה זו אינה זמינה על OpenMV Cam M4.

מוצא את כל ה-apriltags בתוך ה-roi ומחזיר רשימה של אובייקטי image.apriltag.

roi הוא צמד מלבן אזור העניין (x, y, w, h). ברירת המחדל היא מלבן התמונה.

families היא מסכת ביטים של משפחות תגים לפענוח. זהו ה-OR הלוגי של:

image.TAG16H5

image.TAG25H9

image.TAG36H10

image.TAG36H11

image.TAGCIRCLE21H7

image.TAGCIRCLE49H12

image.TAGCUSTOM48H12

image.TAGSTANDARD41H12

image.TAGSTANDARD52H13

ברירת המחדל היא image.TAG36H11. זמן הזיהוי גדל עם מספר המשפחות המאופשרות.

fx ו-fy הם אורכי המוקד של המצלמה בצירי X ו-Y בפיקסלים.

cx ו-cy הם מרכז התמונה, בדרך כלל image.width()/2 ו-image.height()/2.

לא נתמך על תמונות דחוסות.

שיטה זו אינה זמינה על OpenMV Cam M4.

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

מוצא את כל ה-datamatrices בתוך ה-roi ומחזיר רשימה של אובייקטי image.datamatrix.

roi הוא צמד מלבן אזור העניין (x, y, w, h). ברירת המחדל היא מלבן התמונה.

effort שולט בכמה זמן להשקיע בניסיון למצוא התאמות data matrix. ערכים גבוהים יותר משפרים את הזיהוי במחיר קצב הפריימים. ערכים מתחת ל-~160 נכשלים בזיהוי; ערכים מעל ~240 מניבים תשואה פוחתת. ברירת המחדל היא 200.

שיטה זו אינה זמינה על OpenMV Cam M4.

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

מוצא את כל הברקודים החד-ממדיים בתוך ה-roi ומחזיר רשימה של אובייקטי image.barcode. סורק גם אופקית וגם אנכית.

סוגי ברקוד נתמכים: 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 הוא צמד מלבן אזור העניין (x, y, w, h). ברירת המחדל היא מלבן התמונה.

שיטה זו אינה זמינה על 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¶

מוצא את היסט ההזזה של תמונה זו מ-template באמצעות מתאם פאזה. מחזיר אובייקט image.displacement.

roi הוא מלבן אזור העניין (x, y, w, h). ברירת המחדל היא מלבן התמונה.

template_roi הוא אזור העניין של התבנית. ברירת המחדל היא מלבן תמונת התבנית. roi ו-template_roi חייבים להיות בעלי אותו רוחב וגובה.

logpolar אם True מחזיר שינוי סיבוב/קנה מידה במקום הזזת x/y.

fix_rotation_scale אם True, מחשב הזזה לאחר יישור הסיבוב וקנה המידה (משמעותי רק כש-logpolar=False).

הערה

השתמשו בשיטה זו על גדלי תמונה שהם חזקה של 2 (למשל sensor.B64X64).

לא נתמך על תמונות דחוסות או תמונות bayer. לא זמין על 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¶

מנסה למצוא את המיקום הראשון בתמונה שבו template מתאים באמצעות מתאם צולב מנורמל. מחזיר צמד תיבה תוחמת (x, y, w, h), או None.

template היא תמונה בגווני אפור להתאמה מול תמונה זו.

threshold הוא ערך (0.0-1.0). ערכים גבוהים יותר מפחיתים תוצאות חיוביות שגויות וזיהויים; ערכים נמוכים יותר עושים את ההפך.

roi הוא צמד מלבן אזור העניין (x, y, w, h). ברירת המחדל היא מלבן התמונה.

step הוא מספר הפיקסלים לדלג עליהם תוך כדי חיפוש (משמש רק במצב image.SEARCH_EX).

search הוא image.SEARCH_DS (חיפוש יהלום מהיר יותר) או image.SEARCH_EX (חיפוש ממצה).

עובד רק על תמונות בגווני אפור.

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

מחפש בתמונה אזורים התואמים את ה-Haar cascade המועבר ומחזיר רשימה של צמדי תיבה תוחמת (x, y, w, h). מחזיר רשימה ריקה אם לא נמצאו מאפיינים.

cascade הוא אובייקט Haar Cascade (ראו image.HaarCascade()).

threshold (0.0-1.0). ערכים נמוכים יותר מעלים את שיעור הזיהוי ואת שיעור החיוביות השגויות.

scale חייב להיות גדול מ-1.0. ערכים גבוהים יותר רצים מהר יותר אך מפיקים התאמות גרועות יותר.

roi הוא צמד מלבן אזור העניין (x, y, w, h). ברירת המחדל היא מלבן התמונה.

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

מחפש את האישון בצמד אזור עניין (x, y, w, h) סביב עין. מחזיר את מיקום (x, y) של האישון, או (0, 0) אם לא נמצא.

roi הוא צמד מלבן אזור העניין (x, y, w, h).

עובד רק על תמונות בגווני אפור.

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

מחלץ נקודות מפתח LBP (local-binary-patterns) מאזור העניין. השתמשו ב-image.match_descriptor() כדי להשוות שני מתארים.

roi הוא צמד מלבן אזור העניין (x, y, w, h).

עובד רק על תמונות בגווני אפור.

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 מאזור העניין. השתמשו ב-image.match_descriptor() כדי להשוות שני מתארים. מחזיר None אם לא נמצאו נקודות מפתח.

roi הוא צמד מלבן אזור העניין (x, y, w, h). ברירת המחדל היא מלבן התמונה.

threshold (0-255) שולט במספר הפינות המחולצות. ספים נמוכים יותר מפיקים יותר פינות. השתמשו ב-~20 עבור AGAST, ~60-80 עבור FAST.

normalized אם True, משבית חילוץ נקודות מפתח רב-רזולוציוני.

scale_factor חייב להיות גדול מ-1.0. ערכים גבוהים יותר רצים מהר יותר אך מפיקים התאמות גרועות יותר.

max_keypoints הוא המספר המרבי של נקודות מפתח לשמירה.

corner_detector הוא image.CORNER_FAST או image.CORNER_AGAST.

עובד רק על תמונות בגווני אפור.

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

הופך את התמונה לשחור-לבן, ומשאיר רק את הקצוות כפיקסלים לבנים.

image.EDGE_SIMPLE - אלגוריתם מסנן מעבר-גבוה פשוט עם סף.

image.EDGE_CANNY - אלגוריתם זיהוי קצוות Canny.

threshold הוא צמד בן שני ערכים המכיל סף נמוך וסף גבוה. תוכלו לשלוט באיכות הקצוות על ידי התאמת ערכים אלה. ברירת המחדל היא (100, 200).

עובד רק על תמונות בגווני אפור.

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

מחליף את הפיקסלים ב-ROI בקווי HOG (histogram of orientated gradients).

roi הוא צמד מלבן אזור העניין (x, y, w, h). אם אינו מצוין, הוא שווה למלבן התמונה. רק פיקסלים בתוך ה-roi מעובדים.

עובד רק על תמונות בגווני אפור.

שיטה זו אינה זמינה על OpenMV Cam M4.

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

מקבל תמונה בגווני אפור ברוחב כפול המכילה את הפלט של שני חיישני מצלמה זה לצד זה ומחליף את אחד החצאים בתמונת הפרש הסטריאו (כל פיקסל מייצג עומק). למשל, עבור שתי מצלמות 320x240 העבירו תמונת 640x240.

reversed כברירת מחדל התמונה השמאלית מושווית לימנית והתמונה הימנית מוחלפת. הגדירו True כדי להשוות ימין->שמאל ולהחליף את התמונה השמאלית.

max_disparity הוא המרחק המרבי (1-255) לחיפוש בלוק פיקסלים תואם באמצעות סכום ההפרשים המוחלטים. ערכים גדולים יותר לוקחים זמן ארוך באופן אקספוננציאלי אך מפיקים פלט באיכות גבוהה יותר.

threshold אם סכום ההפרשים המוחלטים בין שני בלוקים קטן או שווה לסף זה הם נחשבים תואמים.

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

מריץ חיפוש סלקטיבי על התמונה ומחזיר רשימה של צמדי תיבה תוחמת (x, y, w, h) של הצעות אובייקט.

threshold הוא סף הפילוח; ערכים גבוהים יותר מפיקים פחות/גדולים יותר אזורים.

size הוא גודל האזור המינימלי לאחר מיזוג.

a1, a2, a3 הם משקלי הדמיון של צבע/מרקם/גודל המשמשים בעת מיזוג אזורים.