זיהוי פנים בזמן אמת: פרויקט מקצה לקצה: 8 שלבים (עם תמונות)

2024 מְחַבֵּר: John Day | [email protected]. שונה לאחרונה: 2024-01-30 09:16

בהדרכה האחרונה שלי בחקר OpenCV למדנו מעקב אחר אובייקטים אוטומטיים של חזון אוטומטי. כעת נשתמש ב- PiCam שלנו כדי לזהות פנים בזמן אמת, כפי שניתן לראות להלן:

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

כדי ליצור פרויקט שלם בנושא זיהוי פנים, עלינו לעבוד על 3 שלבים מובחנים מאוד:

1. זיהוי פנים ואיסוף נתונים
2. לאמן את המכיר
3. זיהוי פנים

תרשים הבלוק שלהלן חוזר לשלבים אלה:

שלב 1: BoM - שטר החומר

חלקים עיקריים:

1. Raspberry Pi V3 - 32.00 דולר ארה"ב
2. 5 מגה פיקסל חיישן 1080p OV5647 מודול וידאו מצלמה מיני - 13.00 $

שלב 2: התקנת חבילת OpenCV 3

אני משתמש ב- Raspberry Pi V3 המעודכן לגרסה האחרונה של Raspbian (Stretch), ולכן הדרך הטובה ביותר להתקין OpenCV היא לעקוב אחר ההדרכה המעולה שפיתחה אדריאן רוזברק: Raspbian Stretch: התקן OpenCV 3 + Python ב- Raspberry Pi שלך.

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

לאחר שתסיים את ההדרכה של אדריאן, אמורה להיות לך סביבה וירטואלית OpenCV מוכנה להריץ את הניסויים שלנו ב- Pi שלך.

בואו נלך לסביבה הווירטואלית שלנו ונוודא ש- OpenCV 3 מותקן כראוי.

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

מקור ~/.profile

לאחר מכן, בואו להיכנס לסביבה הווירטואלית שלנו:

workon cv

אם אתה רואה את הטקסט (cv) שלפני ההנחיה שלך, אתה נמצא בסביבה הווירטואלית של cv:

(cv) pi@פטל: ~ $אדריאן מפנה את תשומת הלב לכך שהסביבה הווירטואלית cyth Python היא עצמאית לחלוטין ומופרשת מגרסת ברירת המחדל של פייתון הכלולה בהורדה של Raspbian Stretch. אז כל חבילות Python בספריית חבילות האתרים העולמית לא יהיו זמינות לסביבה הווירטואלית של cv. באופן דומה, כל חבילות Python המותקנות בחבילות אתר של cv לא יהיו זמינות להתקנה העולמית של Python

כעת, הזן את מתורגמן ה- Python שלך:

פִּיתוֹן

וודא שאתה מפעיל את גרסת 3.5 (או מעל)

בתוך המתורגמן (">>>" יופיע), ייבא את ספריית OpenCV:

יבוא cv2

אם לא מופיעות הודעות שגיאה, ה- OpenCV מותקן כראוי ב- PYTHON VIRTUAL ENVIRONMENT שלך.

תוכל גם לבדוק את גירסת OpenCV המותקנת:

cv2._ גרסה_

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

שלב 3: בדיקת המצלמה שלך

לאחר שהתקנת את OpenCV ב- RPi שלך נבדוק כדי לאשר שהמצלמה שלך פועלת כראוי.

אני מניח שיש לך כבר PiCam מותקן ב- Raspberry Pi שלך.

הזן את קוד ה- Python למטה ב- IDE שלך:

ייבא numpy כמו np

ייבוא cv2 cap = cv2. VideoCapture (0) cap.set (3, 640) # set Width cap.set (4, 480) # set Height while (True): ret, frame = cap.read () frame = cv2. flip (מסגרת, -1) # הפוך מצלמה אפורה אנכית = cv2.cvtColor (frame, cv2. COLOR_BGR2GRAY) cv2.imshow ('frame', frame) cv2.imshow ('אפור', אפור) k = cv2.waitKey (30) & 0xff אם k == 27: # הקש על 'ESC' כדי להפסיק את ההפסקה של cap.release () cv2.destroyAllWindows ()

הקוד לעיל יתעד את זרם הווידאו שייווצר על ידי ה- PiCam שלך, ויציג את שניהם, בצבע BGR ובמצב אפור.

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

תוכל לחלופין להוריד את הקוד מ- GitHub שלי: simpleCamTest.py

לביצוע, הזן את הפקודה:

python simpleCamTest.py

לסיום התוכנית, עליך ללחוץ על המקש [ESC] במקלדת.

לחץ על העכבר על חלון הווידאו לפני שתלחץ על [ESC]

התמונה למעלה מציגה את התוצאה.

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

sudo modprobe bcm2835-v4l2

תוכל גם להוסיף bcm2835-v4l2 לשורה האחרונה של קובץ /etc /modules כך שהנהג נטען בעת האתחול.

למידע נוסף על OpenCV, תוכל לעקוב אחר ההדרכה: loading -video-python-opencv-tutorial

שלב 4: זיהוי פנים

המשימה הבסיסית ביותר בנושא זיהוי פנים היא כמובן "זיהוי פנים". לפני כל דבר, עליך "ללכוד" פנים (שלב 1) על מנת לזהות אותו, בהשוואה לפנים חדשות שנתפסו בעתיד (שלב 3).

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

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

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

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

מספיק תיאוריה, בואו ניצור גלאי פנים עם OpenCV!

הורד את הקובץ: faceDetection.py מה- GitHub שלי.

ייבא numpy כמו np

יבוא cv2 faceCascade = cv2. CascadeClassifier ('Cascades/haarcascade_frontalface_default.xml') cap = cv2. VideoCapture (0) cap.set (3, 640) # set Width cap.set (4, 480) # set Height while true: ret, img = cap.read () img = cv2.flip (img, -1) אפור = cv2.cvtColor (img, cv2. COLOR_BGR2GRAY) פנים = faceCascade.detectMultiScale (אפור, scaleFactor = 1.2, minNeighbors = 5, minSize = (20, 20)) עבור (x, y, w, h) בפנים: cv2.lectangle (img, (x, y), (x+w, y+h), (255, 0, 0), 2) roi_gray = אפור [y: y+h, x: x+w] roi_color = img [y: y+h, x: x+w] cv2.imshow ('וידאו', img) k = cv2.waitKey (30) & 0xff אם k == 27: # הקש על 'ESC' כדי לסיים את הפסקה cap.release () cv2.destroyAllWindows ()

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

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

faceCascade = cv2. CascadeClassifier ('Cascades/haarcascade_frontalface_default.xml')

זו השורה שמטעינה את "המסווג" (חייב להיות בספרייה בשם "Cascades/", מתחת לספריית הפרויקטים שלך).

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

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

פנים = faceCascade.detectMultiScale (אפור, קנה מידה = 1.2, minNighbors = 5, minSize = (20, 20))

איפה,

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

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

עבור (x, y, w, h) בפנים:

cv2. מלבן (img, (x, y), (x+w, y+h), (255, 0, 0), 2) roi_gray = אפור [y: y+h, x: x+w] roi_color = img [y: y+h, x: x+w]

אם נמצאו פרצופים, הוא מחזיר את המיקומים של הפנים המזוהות כמלבן עם הפינה השמאלית למעלה (x, y) ובעל "w" כרוחבו ו- "h" כגובהו ==> (x, y, w, ח). אנא ראה את התמונה למעלה.

לאחר שנקבל את המיקומים האלה, נוכל ליצור "ROI" (מלבן מצויר) לפנים ולהציג את התוצאה עם הפונקציה imshow ().

הפעל את סקריפט הפיתון לעיל בסביבת הפייתון שלך, באמצעות מסוף ה- Rpi:

python faceDetection.py

התוצאה:

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

שים לב שבפי, מספר מסווגים באותו קוד יאט את העיבוד, ברגע ששיטת זיהוי זו (HaarCascades) תשתמש בכוח חישובי רב. בשולחן העבודה, קל יותר להריץ אותו.

ב- GitHub שלי תמצא דוגמאות נוספות:

faceEyeDetection.py

faceSmileDetection.py

faceSmileEyeDetection.py

ובתמונה למעלה אתה יכול לראות את התוצאה.

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

הדרכת זיהוי אובייקטים של האשד בפנים ובעין OpenCV Python הדרכה

שלב 5: איסוף נתונים

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

הכרת פנים באמצעות OPENCV ופייתון: מדריך למתחילים

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

הכרת פנים - 3 חלקים

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

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

ראשית, צור ספרייה שבה אתה מפתח את הפרויקט שלך, למשל, FacialRecognitionProject:

mkdir FacialRecognitionProject

בספרייה זו, מלבד 3 סקריפטים של פייתון שניצור עבור הפרויקט שלנו, בטח שמרנו עליו את מסווג הפנים. אתה יכול להוריד אותו מה- GitHub שלי: haarcascade_frontalface_default.xml

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

מערך נתונים mkdir

והורד את הקוד מה- GitHub שלי: 01_face_dataset.py

יבוא cv2

יבוא os cam = cv2. VideoCapture (0) cam.set (3, 640) # set video width cam.set (4, 480) # set video height face_detector = cv2. CascadeClassifier ('haarcascade_frontalface_default.xml') # לכל אדם, הזן מזהה פנים מספרי אחד face_id = input ('\ n הזן מזהה משתמש הקש ==>') הדפסה ("\ n [INFO] אתחול לכידת פנים. הסתכל במצלמה והמתן …") # אתחל ספירת ספגי פנים בודדים של דגימה בודדת. = 0 בעוד (נכון): ret, img = cam.read () img = cv2.flip (img, -1) # הפוך תמונת וידאו אפורה אנכית = cv2.cvtColor (img, cv2. COLOR_BGR2GRAY) פנים = face_detector.detectMultiScale (אפור, 1.3, 5) עבור (x, y, w, h) בפנים: cv2.lectangle (img, (x, y), (x+w, y+h), (255, 0, 0), 2) count + = 1 # שמור את התמונה שצולמה בתיקיית מערכי הנתונים cv2.imwrite ("dataset/User." + str (face_id) + '.' + str (count) + ".jpg", אפור [y: y + h, x: x+w]) cv2.imshow ('image', img) k = cv2.waitKey (100) & 0xff # לחץ על 'ESC' ליציאה מהסרטון אם k == 27: שבירת ספירת האליפים> = 30: # קח 30 מדגם פנים והפסק את הפסקת הווידאו # עשה ab זה של הדפסת ניקוי ("\ n [INFO] יציאה מתוכנית וניקוי דברים") cam.release () cv2.destroyAllWindows ()

הקוד דומה מאוד לקוד שראינו לזיהוי פנים. מה שהוספנו היה "פקודת קלט" ללכידת מזהה משתמש, שאמור להיות מספר שלם (1, 2, 3 וכו ')

face_id = input ('\ n הזן סיום משתמש לחץ ==>')

ולכל אחת מהמסגרות שצולמו, עלינו לשמור אותה כקובץ במדריך "מערך נתונים":

cv2.imwrite ("dataset/User." + str (face_id) + '.' + str (count) + ".jpg", אפור [y: y + h, x: x + w])

שים לב שכדי לשמור את הקובץ לעיל, עליך לייבא את "מערכת ההפעלה" של הספרייה. שם כל קובץ יעקוב אחר המבנה:

User.face_id.count.jpg

לדוגמה, עבור משתמש עם face_id = 1, קובץ המדגם הרביעי במערך הנתונים/ בספרייה יהיה בערך כמו:

משתמש.1.4.jpg

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

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

שלב 6: מאמן

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

אז בואו נתחיל ליצור ספריית משנה שבה נשמור את הנתונים המאומנים:

מאמן mkdir

הורד מ- GitHub שלי את סקריפט הפיתון השני: 02_face_training.py

יבוא cv2

יבוא numpy כמו np מ- PIL יבוא תמונה יבוא מערכת os # נתיב עבור מסד נתונים של תמונת פנים = 'dataset' מזהה = cv2.face. LBPHFaceRecognizer_create () גלאי = cv2. CascadeClassifier ("haarcascade_frontalface_default.xml"); פונקציה # כדי לקבל את התמונות ולתייג נתוני def getImagesAndLabels (נתיב): imagePaths = [os.path.join (נתיב, f) עבור f ב- os.listdir (נתיב)] faceSamples = ids = עבור imagePath ב- imagePaths: PIL_img = Image.open (imagePath).convert ('L') # המר אותו לגווני אפור img_numpy = np.array (PIL_img, 'uint8') id = int (os.path.split (imagePath) [-1]. פיצול (".") [1]) פנים = detector.detectMultiScale (img_numpy) עבור (x, y, w, h) בפנים: faceSamples.append (img_numpy [y: y+h, x: x+w]) ids.append (id) return faceSamples, ids print ("\ n [INFO] פרצופי אימון. ייקח כמה שניות. המתן …") פנים, ids = getImagesAndLabels (נתיב) מזהה.טראן (פנים, np.array (ids)) # שמור את הדגם ב- trainer/trainer.yml מזהה.כתב ('trainer/trainer.yml') # מזהה.שמור () עבד ב- Mac, אך לא ב- Pi # הדפס את מספר הפנים המאומנות וסיים את הדפסת התוכנית ("\ n [INFO] {0} פנים מאומנות. פורמט תוכנית". פורמט (len (np.unique (ids))))

אשר אם יש לך את ספריית ה- PIL המותקנת ב- Rpi שלך. אם לא, הפעל את הפקודה הבאה במסוף:

פיפ להתקין כרית

נשתמש כמזהה, LBPH (LOCAL BINARY PATTERNS HISTOGRAMS) מזהה פנים, הכלול בחבילת OpenCV. אנו עושים זאת בשורה הבאה:

מזהה = cv2.face. LBPHFaceRecognizer_create ()

הפונקציה "getImagesAndLabels (נתיב)", תצלם את כל התמונות בספרייה: "dataset/", ותחזיר 2 מערכים: "מזהים" ו"פנים ". עם מערכים אלה כקלט, "נאמן את המזהה שלנו":

מזהה.טראן (פנים, מזהים)

כתוצאה מכך, קובץ בשם "trainer.yml" יישמר בספריית המאמן שנוצרה בעבר על ידינו.

זהו זה! כללתי את הצהרת ההדפסה האחרונה שבה הצגתי לאישור, את מספר פני המשתמש שהכשירנו.

בכל פעם שאתה מבצע שלב 1, שלב 2 חייב להיות מופעל גם כן

שלב 7: מזהה

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

בואו להוריד את סקריפט הפיתון שלב שלישי מה- GitHub שלי: 03_face_recognition.py.

יבוא cv2

יבוא numpy כמו np יבוא os מזהה = cv2.face. LBPHFaceRecognizer_create () מזהה.רד ('trainer/trainer.yml') cascadePath = "haarcascade_frontalface_default.xml" faceCascade = cv2. CascadeClassifier (cascadePath); font = cv2. FONT_HERSHEY_SIMPLEX # התחילו מזהה מונה מזהה = 0 # שמות הקשורים לזהות: דוגמה ==> מרסלו: id = 1 וכו 'שמות = [' אין ',' מרסלו ',' פאולה ',' אילזה ',' ז ', W להיות מוכר כפנים minW = 0.1*cam.get (3) minH = 0.1*cam.get (4) בעוד True: ret, img = cam.read () img = cv2.flip (img, -1) # הפוך אנכית אפורה = cv2.cvtColor (img, cv2. COLOR_BGR2GRAY) פנים = faceCascade.detectMultiScale (אפור, scaleFactor = 1.2, minNeighbours = 5, minSize = (int (minW), int (minH)),) עבור (x, y, w, h) בפרצופים: cv2.lectangle (img, (x, y), (x+w, y+h), (0, 255, 0), 2) id, confidence = מזהה.חיזוי (אפור [y: y+h, x: x+w]) # בדוק אם הביטחון קטן מהם 100 ==> "0" מתאים באופן מושלם אם (ביטחון <100): id = names [id] confidence = "{0}% ".format (עגול (100 - ביטחון)) else: id =" לא ידוע "ביטחון =" {0}%". פורמט (עגול (100 - conf idence)) cv2.putText (img, str (id), (x+5, y-5), font, 1, (255, 255, 255), 2) cv2.putText (img, str (ביטחון), (x+5, y+h-5), פונט, 1, (255, 255, 0), 1) cv2.imshow ('מצלמה', img) k = cv2.waitKey (10) & 0xff # הקש 'ESC' ליציאה מסרטון אם k == 27: הפסקה # עשה קצת ניקוי הדפסה ("\ n [INFO] יציאה מתוכנית וניקוי דברים") cam.release () cv2.destroyAllWindows ()

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

names = ['None', 'Marcelo', 'Paula', 'Ilza', 'Z', 'W']

כך, למשל: מרסלו יהיה המשתמש עם id = 1; פאולה: id = 2 וכו '.

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

מזהה, ביטחון = מזהה.חיזוי (חלק אפור של הפנים)

המזהה מזהה (.

שים לב שמדד הביטחון יחזיר "אפס" אם הוא ייחשב כהתאמה מושלמת

ולבסוף, אם המזהה יכול לחזות פנים, שמנו טקסט מעל התמונה עם המזהה הסביר וכמה עולה "ההסתברות" באחוזים שההתאמה נכונה ("הסתברות" = 100 - מדד ביטחון). אם לא, תווית "לא יודעת" מונחת על הפנים.

מתחת ל--g.webp

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

שלב 8: סיכום

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

לפרטים וקוד סופי, בקר במאגר GitHub שלי: OpenCV- זיהוי פנים

לפרויקטים נוספים, בקר בבלוג שלי: MJRoBot.org

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

כל הכבוד מדרום העולם!

נתראה במדריך הבא שלי!

תודה, מרסלו