מניפולציות תמונה ב- opencv (חלק

בהדרכות הקודמות למדנו על OpenCV ועשינו קצת עיבוד תמונה בסיסי ואז בהדרכה הבאה עשינו קצת מניפולציות בתמונות ב- OpenCV כמו חיתוך, סיבוב, תמונת תמונה וכו '. אז בהמשך ללימוד הקודם של מניפולציה של תמונות, כאן נלמד כמה טכניקות נוספות למניפולציה של תמונות כמו ובסיום ההדרכה נבנה תוכנית פייתון-פתוחcv להכנת סקיצה חיה מהעדכון החי של מצלמת הרשת. יישום זה ישתמש רבות בפונקציות עיבוד תמונה שלמדנו עד כה או שנלמד במדריך זה, כך שזו תהיה דוגמה מעשית טובה לכיסוי כל הפונקציות.

כפי שנאמר במדריך הקודם, OpenCV היא Open Source Commuter Vision Library אשר כוללת ממשקי C ++, Python ו- Java ותומכת ב- Windows, Linux, Mac OS, iOS ו- Android. כך שניתן להתקין אותו בקלות ב- Raspberry Pi עם פייתון וסביבת לינוקס. ו- Raspberry Pi עם OpenCV ומצלמה מחוברת יכולים לשמש ליצירת יישומי עיבוד תמונה רבים בזמן אמת כמו זיהוי פנים, נעילת פנים, מעקב אחר אובייקטים, זיהוי לוחית מספר רכב, מערכת אבטחה לבית וכו '

במדריך זה אנו הולכים לראות עוד כמה מניפולציות של תמונות באמצעות Python OpenCV. כאן נלמד להחיל את הפונקציה הבאה על תמונה באמצעות פייתון OpenCV:

• פעולות ומיסוך סיביות
• קונבולוציה וטשטוש
• השחזה - היפוך התמונה מיטשטש
• סף (בינאריזציה)
• התרחבות, שחיקה, פתיחה / סגירה
• זיהוי קצה ושיפועי תמונה
• פרספקטיבה והפיכת זיקה
• יישום סקיצה חיה

1. פעולות ומיסוך סיביות

פעולות סיביות מסייעות לך במסוך תמונות ועוזרות לך ליצור כמה תמונות פשוטות.

הכנת ריבוע

ייבא cv2 ייבא מטומטם כ- np # אנו משתמשים בשני ממדים בלבד מכיוון שזו תמונה בגווני אפור, אם היינו משתמשים בתמונה # צבעונית, השתמשנו במלבן = np.zeros ((300,300,3), np.uint8) # הכנת ריבוע מרובע = np.zeros ((300,300), np.uint8) cv2. מלבן (ריבוע, (50,50), (250,250), 255, -1) cv2.imshow ("ריבוע", ריבוע) cv2. waitKey (0)

ביצוע אליפסה

אליפסה = np.zeros ((300,300), np.uint8) cv2. אליפסה (אליפסה, (150,150), (150,150), 30,0,180,255, -1) cv2.imshow ("אליפסה", אליפסה) cv2.waitKey (0)

התנסות בפעולות סיביות

#AND_ מציג רק היכן השניים מצטלבים

BitwiseAND = cv2.bitwise_and (ריבוע, אליפסה) cv2.imshow ("AND", BitwiseAND) cv2.waitKey (0)

#OR_ מציג רק היכן שהוא מרובע או אליפסה

BitwiseOR = cv2.bitwise_or (ריבוע, אליפסה) cv2.imshow ("או", BitwiseOR) cv2.waitKey (0)

#XOR_ מציג רק היכן שקיים אחד מהם בפני עצמו

BitwiseXOR = cv2.bitwise_xor (מרובע, אליפסה) cv2.imshow ("XOR", BitwiseXOR) cv2.waitKey (0)

#NOT_ מציג את כל מה שאינו חלק מהאליפסה ו- NOT ניתן להחיל רק על דמות אחת

BitwiseNOT_elp = cv2.bitwise_not (אליפסה) cv2.imshow ("NOT_ellipse", BitwiseNOT_elp) cv2.waitKey (0) cv2.destroyAllWindows ()

2. קונבולציה וטשטוש

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

תמונת פלט = תמונה פונקציה _{גודל ליבה}

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

טשטוש הוא פעולה בה אנו ממוצעים בפיקסלים באזור (ליבה)

OpenCV מטשטש תמונה על ידי החלת גרעינים, גרעין אומר לך כיצד לשנות את הערך של כל פיקסל נתון על ידי שילובו עם כמות שונה של פיקסלים שכנים שהגרעין מוחל על כל פיקסל בתמונה בזה אחר זה כדי לייצר את התמונה הסופית.

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

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

האמור לעיל הוא גרעין 3X3.

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

בוא נבדוק filter2D בשיטת טשטוש opencv, הניתן על ידי הפונקציה cv2.filter2D (תמונה, -1, ליבת)

ייבא cv2 ייבא מטומטם כתמונת np = cv2.imread ('elephant.jpg') cv2.imshow ('original', image) cv2.waitKey (0)

# יצירת מטריצת ליבות 3x3

kernel_3x3 = np.ones ((3,3), np.float32) / 9

# אנו משתמשים ב- cv2.filter2D כדי לכרוך את הגרעין עם תמונה

מטושטש = cv2.filter2D (תמונה, -1, kernel_3x3) cv2.imshow ('3x3_blurring', מטושטש) cv2.waitKey (0)

# יצירת מטריצת ליבות 7x7

kernel_7x7 = np.ones ((7,7), np.float32) / 49

# אנו משתמשים ב- cv2.filter2D כדי לכרוך את הגרעין עם תמונה

מטושטש = cv2.filter2D (תמונה, -1, kernel_7x7) cv2.imshow ('7x7_blurring', מטושטש) cv2.waitKey (0) cv2.destroyAllWindows ()

ישנם סוגים אחרים של שיטות טשטוש:

cv2.blur - ממוצע של ערך על חלון שצוין.

cv2.GaussianBlur - דומה אך משתמש בחלון גאוסי (דגש רב יותר על נקודות סביב המרכז).

cv2.medianBlur– משתמש בחציון של כל האלמנטים בחלון.

cv2.bilateralFilter– מטשטש את הקצוות ופרטי הקו תוך שמירה על חדות הקצוות.

נראה אחד אחד למטה, ראשית נציג את התמונה המקורית באמצעות הקוד שלמטה:

ייבא cv2 ייבא מטומטם כתמונת np = cv2.imread ('elephant.jpg') cv2.imshow ('original', image) cv2.waitKey (0)

cv2.blur:

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

# cv2.blur blur = cv2.blur (image, (3,3)) cv2.imshow ('Averaging', blur) cv2.waitKey (0)

cv2.GaussianBlur:

# cv2.GaussianBlur # במקום מסנן התיבה, בואו ננסה את הגרעין הגאוסי Gaussian = cv2.GaussianBlur (תמונה, (7,7), 0) cv2.imshow ('Gaussian blurring', Gaussian) cv2.waitKey (0)

cv2.medianBlur:

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

# cv2.medianBlur # לוקח חציון של כל הפיקסלים מתחת לאזור הליבה והאלמנט המרכזי # מוחלף לערך חציוני זה. חציון = cv2.medianBlur (תמונה, 5) cv2.imshow ('החציוני טשטוש', חציון) cv2.waitKey (0)

cv2.bilateralFilter:

דו צדדי יעיל מאוד בהסרת רעשים תוך שמירה על קצוות חדים

# cv2.bilateralFilter # דו צדדי יעיל מאוד בהסרת רעש תוך שמירה על הקצוות חד דו צדדיים = cv2.bilateralFilter (תמונה, 9,75,75) cv2.imshow ('טשטוש דו-צדדי', דו צדדי) cv2.waitKey (0) cv2. destroyAllWindows ()

תמונה דה-רעש-לא מקומי פירושו הרס

ייבא cv2 ייבא טשטוש כתמונת np = cv2.imread ('elephant.jpg') cv2.imshow ('original', image) cv2.waitKey (0)

#parameter after None הוא חוזק המסנן 'h' (5-10 הוא טווח טוב) # next is h עבור רכיבי צבע, מוגדר באותו ערך כמו h שוב

dst = cv2.fastNlMeansDenoisingColored (תמונה, ללא, 6,6,7,21) cv2.imshow ('מהיר פירושו מכחול', dst) cv2.waitKey (0) cv2.destroyAllWindows ()

ישנן 4 וריאציות של אמצעי הכחשה לא מקומי

cv2.fastNlMeansDenoising () - לתמונה בקנה מידה אפור יחיד

cv2.fastNlMeansDenoisingColored () - תמונה בצבע יחיד

cv2.fastNlmeansDenoisingMulti () - לסדר אפור ברצף התמונה

cv2.fastNlmeansDenoisingcoloredMulti () - לצבע רצף תמונות

3. השחזה - היפוך התמונה מטשטש

השחזה היא ההפך מטשטוש, היא מחזקת או מדגישה בקצוות בתמונה.

Kernel =,,

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

ייבוא cv2 יבוא numpy כפי NP תמונה = cv2.imread ('elephant.jpg') cv2.imshow ('מקורי', תמונה) cv2.waitKey (0)

kernel_sharpening = np.array (,

])

# החלת גרעין השחזה לתמונת קלט

מחודד = cv2.filter2D (תמונה, -1, kernel_sharpening) cv2.imshow ('תמונה מחודדת', מושחז) cv2.waitKey (0) cv2.destroyAllWindows ()

4. רזולוציה (בינריזציה)

סף הוא פעולה של המרת תמונה לצורה בינארית. ב- opencv יש פונקציה נפרדת לסף המוגדרת כ-

סף Cv2 (תמונה, ערך סף, ערך מקסימלי, סוג סף)

ישנם סוגי סף הבאים:

• cv2.THRESH_BINARY - הנפוץ ביותר
• cv2. THRESH_BINARY_INV - הנפוץ ביותר
• cv2.THRESH_TRUNC
• cv2.THRESH_TOZERO
• cv2. THRESH_TOZERO_INV

הערה: יש צורך להמיר תמונה לגווני אפור לפני הסף

ייבוא cv2 יבוא numpy כפי NP תמונה #load כמו בגווני אפור תמונה = cv2.imread ('gradient.jpg', 0) cv2.imshow ('מקורי', תמונה) cv2.waitKey (0)

ערך # מתחת 127 עברו ל 0 (שחור), ומעל 127 עוברים ל 255 (לבן)

_, thresh1 = cv2.threshold (תמונה, 127,255, cv2.THRESH_BINARY) cv2.imshow ('סף 1', thresh1) cv2.waitKey (0)

#value מתחת 127 עובר ל 255 וערכים מעל 127 עולים ל- 0 (הפוך מלמעלה)

_, thresh2 = cv2.threshold (תמונה, 127,255, cv2.THRESH_BINARY_INV) cv2.imshow ('2 סף', thresh2) cv2.waitKey (0)

ערך # מעל 127 חתוך (מוחזק) בגיל 127, הארגומנט 255 אינו בשימוש.

_, thresh3 = cv2.threshold (תמונה, 127,255, cv2.THRESH_TRUNC) cv2.imshow ('3 tresh trunc', thresh3) cv2.waitKey (0)

# הערכים מתחת 127 עוברים ל 0, מעל 127 הם ​​ללא שינוי

_, thresh4 = cv2.threshold (תמונה, 127,255, cv2.THRESH_TOZERO) cv2.imshow ('4 סף', thresh4) cv2.waitKey (0)

#Revesrse שלמעלה, מתחת 127 אינו משתנה, מעל 127 הולך לאפס

_, thresh5 = cv2.threshold (תמונה, 127,255, cv2.THRESH_TOZERO_INV) cv2.imshow ('5 סף', thresh5) cv2.waitKey (0) cv2.destroyAllWindows ()

5. התרחבות, שחיקה, פתיחה / סגירה

אלה הפעולות בתחום המורפולוגיה המתמטית

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

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

פתיחה - שחיקה ואחריה התרחבות.

סגירה - התרחבות ואחריה שחיקה.

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

בלבול עם התרחבות ושחיקה

לעיתים קיים בלבול בין התרחבות לשחיקה בדרך כלל בתמונות עם רקע לבן, מכיוון ש- opencv מחשיב את הרקע הלבן כתמונה להיות מורחבת או נשחקת במקום תמונה מקורית, כך שבמקרה זה שחיקה פועלת כהרחבה ולהיפך, כפי שמוצג בדוגמת תמונה. מוצג להלן.

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

ייבא cv2 ייבוא ​​מטומטם כתמונת np = cv2.imread ('imagecv.png', 0) cv2.imshow ('original', image) cv2.waitKey (0)

#Erosion

# בואו נגדיר את גודל הליבה שלנו

גרעין = np.ones ((5,5), np.uint8)

# עכשיו אנו שוחקים את התמונה, כאן איטרציה אינה פעמים שאתה רוצה לכרסם בתמונה

סחף = cv2.erode (תמונה, גרעין, חזרות = 1) cv2.imshow ('שחיקה', סחף) cv2.waitKey (0)

#הַרחָבָה

הרחבה = cv2. הרחבה (תמונה, גרעין, חזרות = 1) cv2.imshow ('הרחבה', הרחבה) cv2.waitKey (0)

# פתיחה, טוב להסרת הרעש

פתיחה = cv2.morphologyEx (תמונה, cv2.MORPH_OPEN, ליבת) cv2.imshow ('פתיחה', פתיחה) cv2.waitKey (0)

# סגירה, טוב להסרת רעש

סוגרים = cv2.morphologyEx (תמונה, cv2.MORPH_CLOSE, ליבת) cv2.imshow ('סוגרים', סוגרים) cv2.waitKey (0) cv2.destroyAllWindows ()

6. זיהוי קצה ושיפועי תמונה

זיהוי קצה הוא תחום חשוב מאוד בראיית המחשב, במיוחד כאשר מתמודדים עם קווי מתאר.

ניתן להגדיר קצוות כגבולות של תמונה, למעשה הם קצוות המגדירים אובייקט בתמונות הם שומרים על מידע רב על התמונה.

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

התמונה לעיל מראה כיצד ראיית המחשב מזהה ומזהה את התמונה.

אלגוריתמים לזיהוי קצה: - ישנם שלושה סוגים עיקריים של אלגוריתמים לזיהוי קצה

• סובל - להדגשת תמונות אנכיות או אופקיות.
• Laplacian - אופטימלי עקב שיעור שגיאות נמוך, קצוות מוגדרים היטב וזיהוי מדויק.
• אלגוריתם זיהוי Canny Edge (הוחלף על ידי john F. Canny בשנת 1986)

1. מחיל טשטוש גאוסי

2. מוצא את שיפוע העוצמה של התמונה

3. מחיל דיכוי שאינו מקסימלי (כלומר מסיר פיקסלים שאינם קצוות).

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

ייבא cv2 ייבא מטומטם כתמונת np = cv2.imread ('input.jpg', 0) גובה, רוחב = image.shape

# סובל

# חילוץ קצוות מרים

sobel_x = cv2.Sobel (תמונה, cv2.CV_64F, 0,1, ksize = 5) sobel_y = cv2.Sobel (תמונה, cv2.CV_64F, 1,0, ksize = 5) cv2.imshow ('מקורי', תמונה) cv2.waitKey (0) cv2.imshow ('sobelx', sobel_x) cv2.waitKey (0)

# בובלי

cv2.imshow ('sobely', sobel_y) cv2.waitKey (0)

sobel_OR = cv2.bitwise_or (sobel_x, sobel_y) cv2.imshow ('sobelOR', sobel_OR) cv2.waitKey (0)

#laplaian

laplacian = cv2.Laplacian (תמונה, cv2.CV_64F) cv2.imshow ('Laplacian', laplacian) cv2.waitKey (0)

# אלגוריתם של זיהוי קצה קנדי ​​משתמש בערכי שיפוע

כספים # אם אנו יכולים לספק שני ערכים: סף 1 וסף 2.

# כל שיפוע גדול מסף 2 נחשב לקצה.

# כל שיפוע גדול מסף 1 נחשב לא לקצה.

#values בין הסף 1 ו סף 2 הם או כמו קצה או אי-קצה

#on איך בעוצמות שלהם מחוברים, זה מקרה כל ערך מתחת 60 הם נחשבים

#non קצוות wheareas ערך כלשהו מעל 120 נחשבים הקצוות.

canny = cv2.Canny (תמונה, 60,120) cv2.imshow ('canny', canny ) cv2.waitKey (0) cv2.destroyAllWindows ()

14. פרספקטיבה ושינוי זיקה

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

לצורך שינוי פרספקטיבה זה אנו זקוקים לארבע הקואורדינטות של התמונה המקורית ואז לארבע הנקודות של תמונת הפלט, הן מסומנות על ידי נקודות_ A ונקודות_B. ראשית בעזרת נקודות אלה אנו מחשבים מטריצת טרנספורמציה, M בעזרת פונקציית getPerspectiveTransform.

ואז המטריצה ​​הזו ניתנת לפונקציה warpPerspective כדי לייצר את הפלט הסופי.

בואו ננסה תחילה את טרנספורמציית הפרספקטיבה.

ייבא cv2 ייבא numpy כמו np ייבא matplotlib.pyplot כתמונת plt = cv2.imread ('paper.jpg') cv2.imshow ('original', image) cv2.waitKey (0)

# תיאום של 4 פינות תמונה מקורית

נקודות_א = np.float32 (,,,])

# קואורדינטות של 4 פינות של הפלט הרצוי # אנו

משתמשים ביחס של נייר A4 1: 1.41

points_B = np.float32 (,,,])

# השתמש בשתי הסטים של שתי הנקודות כדי לחשב את מטריצת הטרנספורמציה המשוערת , M

M = cv2.getPerspectiveTransform (points_A, points_B) מעוות = cv2.warpPerspective (תמונה, M, (420,594)) cv2.imshow ('warpprespective', מעוות) cv2.waitKey (0) cv2.destroyAllWindows ()

טרנספורמציה של זיקה קלה יותר מהטרנספורמציה שאינה זיקה מכיוון שאנו זקוקים לשלוש נקודות בלבד כדי לקבל את השינוי. התהליך כולו משתנה, אך במקום טרנספורמציה פרספקטיבית יש לנו כעת טרנספורמציה affine וגם אנו מגדירים cols ושורות ב- warpAffine מפונקציית הצורה במקום להזין אותה ידנית.

ייבא cv2 ייבא numpy כמו np ייבא matplotlib.pyplot כתמונת plt = cv2.imread ('box.jpg') שורות, cols = image.shape cv2.imshow ('מקורי', תמונה) cv2.waitKey (0)

# תיאום של 3 פינות של התמונה המקורית

נקודות_א = np.float32 (,,])

# קואורדינטות של 3 פינות של הפלט הרצוי # אנו

משתמשים ביחס של נייר A4 1: 1.41

points_B = np.float32 (,,])

# השתמש בשתי הסטים של שתי הנקודות כדי לחשב את מטריצת הטרנספורמציה # Affine

, M

M = cv2.getAffineTransform (points_A, points_B) מעוות = cv2.warpAffine (תמונה, M, (cols, שורות)) cv2.imshow ('warpaffine', מעוות) cv2.waitKey (0) cv2.destroyAllWindows ()

8. יישום סקיצה חיה

ראשית כל, ברכו את עצמכם שהשלמתם על פרויקט המיני הזה לאחר שקראתם את כל פונקציות המניפולציה בתמונות לעיל. אז בפרויקט המיני הזה של פייתון OpenCV אנו הולכים ללמוד כמה מושגים חדשים של לולאות ופונקציות. אם אתם מכירים את התכנות, עליכם לקבל מושג רחב יותר על מה הפונקציה והלולאות. עם זאת, בפיתון הרעיון הבסיסי של לולאות ופונקציות נותר זהה אך השיטה להגדרתם משתנה מעט.

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

אז סקיצה זו היא פונקציה, בפונקציה של פיתון מוגדרת על ידי "def" ומסתיימת בסימן ":". גם ההצהרות הנדרשות להיות בתוך הפונקציה או שאתה יכול לומר שנדרשות כדי שהפונקציה תפעל כראוי, מיושרות אוטומטית על ידי הפונקציה. אז כדי לצאת מהפונקציות, הצהרות היו צריכות להיות מיושרות לגמרי. לקבלת הפניות הנוספות תוכלו להתייחס אל google כיצד להגדיר את הפונקציות בפייתון.

אז בפונקציית סקיצה זו הצגנו כמה שכבות של עיבוד תמונה המשתלבות יחד כדי לתת פלט. ראשית, התמונה מומרת לגווני אפור כך שה- opencv יכול לעבד אותה בקלות ואז מוחל טשטוש גאוסי על התמונה בקנה מידה אפור כדי להפחית את הרעש. ואז שולפים את הקצוות בעזרת אלגוריתם זיהוי הקצוות של הקני, ואז מוחל הפוך בינארי על התמונה המוגדרת בקצה, כאן ניתן לבצע את ההפך הבינארי גם על ידי bitwise_NOT אבל בחרנו בכוונה את הסף ההפוך הבינארי הזה מכיוון שהוא נותן חופש לקבוע את הפרמטרים שלו עד שנקבל תמונה ברורה.

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

ואז הרעיון השני הוא הפעלת מצלמת רשת ב- opencv שנעשית על ידי פונקציית cv2.VideoCapture (0) , השומרת את התמונה בכובע אובייקט שניתן לקרוא את הכובע עם הפונקציה cap.read () , גם כאן כדי לציין את הכובע הזה . read () נמצא בתוך הלולאה האינסופית שכן הוא נאלץ לצלם את התמונות ברציפות, כדי לתת לו תחושה של סרטון חי, כאשר קצב הפריימים של הווידאו יהיה קצב הפריימים של מצלמת הרשת שלך, שהיא בעיקר בין 24 ל 60 fps.

cap.read () מחזירה ret ו- frame, כאשר ה- ret הוא הבוליאני המציין שהפונקציה הופעלה בהצלחה או לא והמסגרת מכילה את התמונה שצולמה במצלמת הרשת.

להלן קוד ה- Python OpenCV השלם להפעלת ה- Sketch Live

ייבוא cv2 יבוא numpy כפי NP תפקיד מניע #sketch def סקיצה (תמונה): תמונה #convert לגווני אפור img_gray = cv2.cvtColor (תמונה, cv2.COLOR_BGR2GRAY) #cleaning את התמונה באמצעות Gaussian Blur img_gray_blur = cv2.GaussianBlur (img_gray, (5,5), 0) # קצוות תמצית canny_edges = cv2.Canny (img_gray_blur, 10,70) # בצע הפוך בינארי את התמונה ret, mask = cv2. סף (canny_edges, 70,255, cv2. THRESH_BINARY_INV) מסיכת החזרה # לאתחל, הכובע הוא האובייקט שמספק לכידת וידאו # זה מכיל בוליאני המציין אם הוא הצליח (ret) #it ​​מכיל גם את התמונות שנאספו ממצלמת האינטרנט (frame) cap = cv2.VideoCapture (0) בעוד True: ret, frame = cap.read () cv2.imshow ('livesketcher', sketch (frame)) if cv2.waitKey (1) == 13: # 13 הוא הפסקה של מפתח המפתח # שחרר מצלמה וסגור חלון, זכור לשחרר את מצלמת הרשת בעזרת cap.release () cap.release () cv2.destroyAllWindows ()

אז זה הסוף של חלק 2 של מניפולציות תמונה בפייתון-OpenCV. כדי להמעיט בערך ראיית המחשב וה- OpenCV, עברו על מאמרים קודמים (תחילת העבודה עם Python OpenCV ו- Manipulations Image ב- Python OpenCV (חלק 1) ותוכלו להפוך משהו מגניב עם Vision Vision.