Njohja e fytyrës në kohë reale: një projekt nga skaji në skaj: 8 hapa (me fotografi)

2024 Autor: John Day | [email protected]. E modifikuara e fundit: 2024-01-30 12:27

Në mësimin tim të fundit që eksploroj OpenCV, mësuam ZONIMIN E OBJEKTIT TIS VIZIONIT AUTOMATIK. Tani ne do të përdorim PiCam-in tonë për të njohur fytyrat në kohë reale, siç mund ta shihni më poshtë:

Ky projekt u bë me këtë "Biblioteka e Vizionit Kompjuterik me Burim të Hapur", OpenCV. Në këtë tutorial, ne do të përqendrohemi në Raspberry Pi (pra, Raspbian si OS) dhe Python, por unë gjithashtu testova kodin në My Mac dhe gjithashtu funksionon mirë. OpenCV është krijuar për efikasitet llogaritës dhe me një fokus të fortë në aplikimet në kohë reale. Pra, është e përkryer për njohjen e fytyrës në kohë reale duke përdorur një aparat fotografik.

Për të krijuar një projekt të plotë mbi Njohjen e Fytyrës, ne duhet të punojmë në 3 faza shumë të dallueshme:

1. Zbulimi i Fytyrës dhe Grumbullimi i të Dhënave
2. Trajnoni Njohësin
3. Njohja e Fytyrës

Blloqagrami i mëposhtëm rifillon ato faza:

Hapi 1: BM - Fatura e Materialit

Pjesët kryesore:

1. Raspberry Pi V3 - 32,00 dollarë amerikanë
2. 5 Megapixels 1080p Sensor OV5647 Mini Kamera Modul Video - 13,00 US $

Hapi 2: Instalimi i Pakos OpenCV 3

Unë jam duke përdorur një Raspberry Pi V3 të azhurnuar në versionin e fundit të Raspbian (Stretch), kështu që mënyra më e mirë për të instaluar OpenCV është të ndiqni tutorialin e shkëlqyer të zhvilluar nga Adrian Rosebrock: Raspbian Stretch: Instaloni OpenCV 3 + Python në Raspberry Pi tuaj Me

Unë provova disa udhëzues të ndryshëm për të instaluar OpenCV në Pi tim. Mësimi i Adrianit është më i miri. Unë ju këshilloj të bëni të njëjtën gjë, duke ndjekur udhëzimin e tij hap pas hapi.

Pasi të keni mbaruar mësimin e Adrianit, duhet të keni një mjedis virtual OpenCV gati për të ekzekutuar eksperimentet tona në Pi tuaj.

Le të shkojmë në mjedisin tonë virtual dhe të konfirmojmë që OpenCV 3 është instaluar saktë.

Adrian rekomandon të ekzekutoni komandën "burim" sa herë që hapni një terminal të ri për të siguruar që variablat e sistemit tuaj janë konfiguruar në mënyrë korrekte.

burimi ~/.profili

Tjetra, le të hyjmë në mjedisin tonë virtual:

workon cv

Nëse shihni tekstin (cv) që paraprin kërkesën tuaj, atëherë jeni në mjedisin virtual të cv:

(cv) pi@mjedër: ~ $Adrian tërheq vëmendjen se mjedisi virtual cv Python është krejtësisht i pavarur dhe i sekuestruar nga versioni i paracaktuar Python i përfshirë në shkarkimin e Raspbian Stretch. Pra, çdo paketë Python në drejtorinë globale të paketave të faqeve nuk do të jetë e disponueshme për mjedisin virtual cv. Në mënyrë të ngjashme, çdo paketë Python e instaluar në paketat e faqeve të cv nuk do të jetë e disponueshme për instalimin global të Python

Tani, futni përkthyesin tuaj Python:

piton

dhe konfirmoni që po përdorni versionin 3.5 (ose më lart)

Brenda përkthyesit (">>>" do të shfaqet), importoni bibliotekën OpenCV:

import cv2

Nëse nuk shfaqen mesazhe gabimi, OpenCV është instaluar saktë N ON MJEDISIN TUAJ PYTHON VIRTUAL.

Ju gjithashtu mund të kontrolloni versionin e instaluar të OpenCV:

cv2._ version_

3.3.0 duhet të shfaqet (ose një version superior që mund të lëshohet në të ardhmen). Ekrani i printimit të Terminalit të mësipërm tregon hapat e mëparshëm.

Hapi 3: Testimi i kamerës suaj

Pasi të keni instaluar OpenCV në RPi tuaj, le të testojmë për të konfirmuar që kamera juaj po funksionon siç duhet.

Unë po supozoj se ju keni një PiCam të instaluar tashmë në Raspberry Pi tuaj.

Shkruani kodin e mëposhtëm Python në IDE tuaj:

importoni numpy si np

import 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. rrokullisje (kornizë, -1) # Kthejeni kamerën vertikalisht gri = cv2.cvtColor (kornizë, cv2. COLOR_BGR2GRAY) cv2.imshow ('kornizë', kornizë) cv2.imshow ('gri', gri) k = cv2.waitKey (30) & 0xff nëse k == 27: # shtypni 'ESC' për të lënë pushimin e kapakut.release () cv2.destroyAllWindows ()

Kodi i mësipërm do të kapë transmetimin e videos që do të krijohet nga PiCam juaj, duke i shfaqur të dyja, në ngjyrën BGR dhe atë Gri.

Vini re se kam rrotulluar kamerën time vertikalisht për shkak të mënyrës së montimit të saj. Nëse nuk është rasti juaj, komentoni ose fshini rreshtin e komandës "rrokullisje".

Përndryshe, mund të shkarkoni kodin nga GitHub im: simpleCamTest.py

Për të ekzekutuar, futni komandën:

python simpleCamTest.py

Për të përfunduar programin, duhet të shtypni butonin [ESC] në tastierën tuaj.

Klikoni miun në dritaren e videos, para se të shtypni [ESC]

Fotografia e mësipërme tregon rezultatin.

Disa krijues gjetën probleme kur përpiqeshin të hapnin kamerën (mesazhet e gabimit "Pohimi dështoi"). Kjo mund të ndodhë nëse kamera nuk ishte e aktivizuar gjatë instalimit të OpenCv dhe kështu, drejtuesit e kamerës nuk ishin instaluar si duhet. Për të korrigjuar, përdorni komandën:

sudo modprobe bcm2835-v4l2

Ju gjithashtu mund të shtoni bcm2835-v4l2 në rreshtin e fundit të skedarit /etc /modules në mënyrë që shoferi të ngarkohet në boot.

Për të ditur më shumë rreth OpenCV, mund të ndiqni tutorialin: loading -video-python-opencv-tutorial

Hapi 4: Zbulimi i fytyrës

Detyra më themelore në Njohjen e Fytyrës është natyrisht, "Zbulimi i fytyrës". Para çdo gjëje, ju duhet të "kapni" një fytyrë (Faza 1) në mënyrë që ta njihni atë, në krahasim me një fytyrë të re të kapur në të ardhmen (Faza 3).

Mënyra më e zakonshme për të zbuluar një fytyrë (ose ndonjë objekt), është përdorimi i "klasifikuesit të Kaskadës Haar"

Zbulimi i objekteve duke përdorur klasifikuesit kaskadë të bazuar në veçori Haar është një metodë efektive e zbulimit të objekteve të propozuar nga Paul Viola dhe Michael Jones në punimin e tyre, "Zbulimi i shpejtë i objekteve duke përdorur një kaskadë të shtuar të veçorive të thjeshta" në 2001. approachshtë një qasje e bazuar në mësimin e makinerisë ku funksioni i kaskadës është trajnuar nga shumë imazhe pozitive dhe negative. Pastaj përdoret për të zbuluar objekte në imazhe të tjera.

Këtu do të punojmë me zbulimin e fytyrës. Fillimisht, algoritmi ka nevojë për shumë imazhe pozitive (imazhe të fytyrave) dhe imazhe negative (imazhe pa fytyra) për të trajnuar klasifikuesin. Atëherë duhet të nxjerrim veçori prej tij. Lajmi i mirë është se OpenCV vjen me një trajner, si dhe një detektor. Nëse dëshironi të stërvitni klasifikuesin tuaj për çdo objekt si makina, aeroplanë etj., Mund të përdorni OpenCV për të krijuar një të tillë. Detajet e tij të plota jepen këtu: Trajnimi i Klasifikuesit të Kaskadës.

Nëse nuk doni të krijoni klasifikuesin tuaj, OpenCV tashmë përmban shumë klasifikues të stërvitur paraprakisht për fytyrën, sytë, buzëqeshjen, etj. Ato skedarë XML mund të shkarkohen nga drejtoria haarcascades.

Mjaft teori, le të krijojmë një detektor fytyre me OpenCV!

Shkarkoni skedarin: faceDetection.py nga GitHub im.

importoni numpy si np

import cv2 faceCascade = cv2. CascadeClassifier ('Cascades/haarcascade_frontalface_default.xml') cap = cv2. VideoCapture (0) cap.set (3, 640) # set Width cap.set (4, 480) # vendosur Lartësia ndërsa E vërtetë: ret, img = cap.read () img = cv2.flip (img, -1) gri = cv2.cvtColor (img, cv2. COLOR_BGR2GRAY) fytyra = faceCascade.detectMultiScale (gri, shkallaFaktor = 1.2, minFqinjët = 5, minSize = (20, 20)) për (x, y, w, h) në fytyra: cv2. Drejtkëndësh (img, (x, y), (x+w, y+h), (255, 0, 0), 2) roi_gray = gri [y: y+h, x: x+w] roi_color = img [y: y+h, x: x+w] cv2.imshow ('video', img) k = cv2.waitKy (30) & 0xff nëse k == 27: # shtypni 'ESC' për të lënë pushimin cap.release () cv2.destroyAllWindows ()

Besoni apo jo, linjat e mësipërme të kodit janë gjithçka që ju nevojitet për të zbuluar një fytyrë, duke përdorur Python dhe OpenCV.

Kur krahasoheni me kodin e fundit të përdorur për të testuar kamerën, do të kuptoni se pak pjesë i janë shtuar. Vini re rreshtin më poshtë:

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

Kjo është linja që ngarkon "klasifikuesin" (që duhet të jetë në një drejtori të quajtur "Cascades/", nën drejtorinë e projektit tuaj).

Pastaj, ne do të vendosim kamerën tonë dhe brenda lakut, do të ngarkojmë videon tonë hyrëse në modalitetin gri (e njëjta që pamë më parë).

Tani ne duhet të thërrasim funksionin tonë të klasifikuesit, duke i kaluar atij disa parametra shumë të rëndësishëm, si faktori i shkallës, numri i fqinjëve dhe madhësia minimale e fytyrës së zbuluar.

fytyrat = faceCascade.detectMultiScale (gri, shkallaFaktor = 1.2, minFqinjët = 5, minMadhësia = (20, 20))

Ku,

• gri është imazhi hyrës i shkallës gri.
• scaleFactor është parametri që specifikon sa zvogëlohet madhësia e figurës në secilën shkallë të imazhit. Përdoret për të krijuar piramidën e shkallës.
• minNeighbors është një parametër që përcakton se sa fqinjë duhet të ketë çdo drejtkëndësh kandidat, për ta mbajtur atë. Një numër më i lartë jep më pak pozitivë të rremë.
• minSize është madhësia minimale e drejtkëndëshit që duhet konsideruar si fytyrë.

Funksioni do të zbulojë fytyrat në imazh. Tjetra, ne duhet të "shënojmë" fytyrat në imazh, duke përdorur, për shembull, një drejtkëndësh blu. Kjo bëhet me këtë pjesë të kodit:

për (x, y, w, h) në fytyra:

cv2.rekëndësh (img, (x, y), (x+w, y+h), (255, 0, 0), 2) roi_gray = gri [y: y+h, x: x+w] roi_color = img [y: y+h, x: x+w]

Nëse gjenden fytyra, ai kthen pozicionet e fytyrave të zbuluara si një drejtkëndësh me këndin e majtë lart (x, y) dhe duke pasur "w" si gjerësinë e tij dhe "h" si lartësinë e tij ==> (x, y, w, h) Ju lutemi shikoni foton e mësipërme.

Pasi të marrim këto vende, ne mund të krijojmë një "ROI" (drejtkëndësh të vizatuar) për fytyrën dhe të paraqesim rezultatin me funksionin imshow ().

Drejtoni Script -un e mësipërm python në mjedisin tuaj python, duke përdorur Terminalin Rpi:

python faceDetection.py

Rezultati:

Ju gjithashtu mund të përfshini klasifikues për "zbulimin e syve" apo edhe "zbulimin e buzëqeshjes". Në ato raste, ju do të përfshini funksionin e klasifikuesit dhe vizatimin e drejtkëndëshit brenda lakut të fytyrës, sepse nuk do të kishte kuptim të zbuloni një sy ose një buzëqeshje jashtë fytyrës.

Vini re se në Pi, të kesh disa klasifikues në të njëjtin kod do të ngadalësojë përpunimin, pasi kjo metodë e zbulimit (HaarCascades) përdor një sasi të madhe të fuqisë llogaritëse. Në një desktop, është më e lehtë për ta ekzekutuar atë.

Në GitHub tim do të gjeni shembuj të tjerë:

faceEyeDetection.py

faceSmileDetection.py

faceSmileEyeDetection.py

Dhe në foton e mësipërme, ju mund të shihni rezultatin.

Ju gjithashtu mund të ndiqni tutorialin e mëposhtëm për të kuptuar më mirë Zbulimin e Fytyrës:

Tutoriali i fytyrës dhe syve të zbulimit të objekteve Haar Cascade Python

Hapi 5: Mbledhja e të dhënave

Para së gjithash, duhet të falënderoj Ramiz Raja për punën e tij të shkëlqyeshme në Njohjen e Fytyrës në foto:

NJOHJA E FYRJES PINGRDORIMI I OPENCV DHE PYTHON: UDHZUES P BER FILLIMIN

dhe gjithashtu Anirban Kar, që zhvilloi një mësim shumë të plotë duke përdorur video:

NJOHJA E FYRJES - 3 pjesë

Unë me të vërtetë ju rekomandoj që të hidhni një sy në të dyja mësimet.

Duke thënë këtë, le të fillojmë fazën e parë të projektit tonë. Ajo që ne do të bëjmë këtu, është duke filluar nga hapi i fundit (Zbulimi i Fytyrës), ne thjesht do të krijojmë një grup të dhënash, ku do të ruajmë për secilin ID, një grup fotografish në ngjyrë gri me pjesën që është përdorur për zbulimin e fytyrës.

Së pari, krijoni një drejtori ku zhvilloni projektin tuaj, për shembull, FacialRecognitionProject:

mkdirProjekti i Njohjes së fytyrës

Në këtë drejtori, përveç 3 shkrimeve python që do të krijojmë për projektin tonë, duhet të kemi ruajtur në të Klasifikuesin e Fytyrës. Mund ta shkarkoni nga GitHub im: haarcascade_frontalface_default.xml

Tjetra, krijoni një nëndrejtori ku do të ruajmë mostrat tona të fytyrës dhe do ta emërojmë atë "databazë":

të dhëna mkdir

Dhe shkarkoni kodin nga GitHub im: 01_face_dataset.py

import cv2

import os cam = cv2. VideoCapture (0) cam.set (3, 640) # vendosni gjerësinë e videos cam.set (4, 480) # vendosni lartësinë e videos face_detector = cv2. CascadeClassifier ('haarcascade_frontalface_default.xml') # Për secilin person, futni një ID numerike të fytyrës face_id = input ('\ n futni id -në e përdoruesit shtypni ==>') print ("\ n [INFO] Inicimi i kapjes së fytyrës. Shikoni kamerën dhe prisni …") # Filloni numërimin individual të numërimit të fytyrave të kampionimit = 0 ndërsa (E vërtetë): ret, img = cam.read () img = cv2.flip (img, -1) # ktheni imazhin e videos vertikalisht gri = cv2.cvtColor (img, cv2. COLOR_BGR2GRAY) fytyrat = face_detector.detectMultiScale (gri, 1.3, 5) për (x, y, w, h) në fytyra: cv2. drejtkëndësh (img, (x, y), (x+w, y+h), (255, 0, 0), 2) count + = 1 # Ruaj imazhin e kapur në dosjen e të dhënave cv2.imwrite ("dataset/User." + str (face_id) + '.' + str (count) + ".jpg", gri [y: y + h, x: x+w]) cv2.imshow ('image', img) k = cv2.waitKey (100) & 0xff # Shtypni 'ESC' për daljen nga videoja nëse k == 27: pushoni numrin elif> = 30: # Merrni 30 mostra të fytyrës dhe ndaloni pushimin e videos # Bëni ab ajo e printimit të pastrimit ("\ n [INFO] Programi i daljes dhe gjërat e pastrimit") cam.release () cv2.destroyAllWindows ()

Kodi është shumë i ngjashëm me kodin që pamë për zbulimin e fytyrës. Ajo që shtuam ishte një "komandë hyrëse" për të kapur një ID përdoruesi, që duhet të jetë një numër i plotë (1, 2, 3, etj.)

face_id = input ('\ n futni id -në e përdoruesit shtypni ==>')

Dhe për secilën prej kornizave të kapura, ne duhet ta ruajmë atë si një skedar në një drejtori "të dhënash":

cv2.imwrite ("database/User." + str (face_id) + '.' + str (numërimi) + ".jpg", gri [y: y + h, x: x + w])

Vini re se për ruajtjen e skedarit të mësipërm, duhet të keni importuar bibliotekën "os". Emri i secilit skedar do të ndjekë strukturën:

User.face_id.count.jpg

Për shembull, për një përdorues me një face_id = 1, skedari i katërt i mostrës në grupin e të dhënave/ drejtorisë do të jetë diçka si:

Përdoruesi.1.4.jpg

siç tregohet në foton e mësipërme nga Pi im. Në kodin tim, unë jam duke kapur 30 mostra nga secili ID. Mund ta ndryshoni në "elif" -in e fundit. Numri i mostrave përdoret për të thyer lakin ku kapen mostrat e fytyrës.

Drejtoni skriptin Python dhe kapni disa ID. Duhet të ekzekutoni skriptin çdo herë që dëshironi të grumbulloni një përdorues të ri (ose të ndryshoni fotot për atë që tashmë ekziston).

Hapi 6: Trajner

Në këtë fazë të dytë, ne duhet të marrim të gjitha të dhënat e përdoruesit nga grupi ynë i të dhënave dhe të "trajnojmë" Njohjen OpenCV. Kjo bëhet drejtpërdrejt nga një funksion specifik OpenCV. Rezultati do të jetë një skedar.yml që do të ruhet në një direktori "trainer/".

Pra, le të fillojmë të krijojmë një nëndrejtori ku do të ruajmë të dhënat e stërvitura:

trajner mkdir

Shkarkoni nga GitHub im skriptin e dytë python: 02_face_training.py

import cv2

import numpy si np nga PIL import Imazh import os # Rruga për imazhin e fytyrës shtegu i bazës së të dhënave = 'dataset' = = cv2.face. LBPHFaceRecognizer_create () detektor = cv2. CascadeClassifier ("haarcascade_frontalface_default.xml"); # funksion për të marrë imazhet dhe të dhënat e etiketës def getImagesAndLabels (path): imagePaths = [os.path.join (path, f) for f in os.listdir (path)] faceSamples = ids = për imagePath në imagePaths: PIL_img = Image.open (imagePath).convert ('L') # konvertojeni në gri img_numpy = np.array (PIL_img, 'uint8') id = int (os.path.split (imagePath) [-1]. ndarje (".") [1]) fytyra = detektor.detectMultiScale (img_numpy) për (x, y, w, h) në fytyrat: faceSamples.append (img_numpy [y: y+h, x: x+w]) ids.append (id) return faceSembles, ids print ("\ n [INFO] Fytyrat e trajnimit. Do të duhen disa sekonda. Prisni …") fytyra, ids = getImagesAndLabels (path) njohës.treni (fytyrat, np.array (ids)) # Ruani modelin në trainer/trainer.yml njohës.shkruani ('trainer/trainer.yml') # njohës.save () punuar në Mac, por jo në Pi # Shtypni numrin e fytyrave të trajnuar dhe përfundoni printimin e programit ("\ n [INFO] {0} fytyrat e stërvitura. Programi i daljes".format (len (np.unique (ids))))

Konfirmoni nëse keni bibliotekën PIL të instaluar në Rpi tuaj. Nëse jo, ekzekutoni komandën e mëposhtme në Terminal:

jastëk për instalimin e pipit

Ne do të përdorim si një njohës, LBPH (HISTOGRAMET E LET LR BINAREVE T MOTIT) Njohësi i Fytyrës, i përfshirë në paketën OpenCV. Ne e bëjmë këtë në rreshtin e mëposhtëm:

njohës = cv2.face. LBPHFaceRecognizer_create ()

Funksioni "getImagesAndLabels (shteg)", do të marrë të gjitha fotot në drejtori: "dataset/", duke kthyer 2 vargje: "ID" dhe "fytyra". Me ato vargje si hyrje, ne do të "trajnojmë njohësin tonë":

njohës.tren (fytyra, ID)

Si rezultat, një skedar i quajtur "trainer.yml" do të ruhet në drejtorinë e trainerit që është krijuar më parë nga ne.

Kjo eshte! Kam përfshirë deklaratën e fundit të printimit ku shfaqa për konfirmim, numrin e fytyrave të Përdoruesit që kemi trajnuar.

Sa herë që kryeni Fazën 1, Faza 2 gjithashtu duhet të ekzekutohet

Hapi 7: Njohësi

Tani, arritëm në fazën përfundimtare të projektit tonë. Këtu, ne do të kapim një fytyrë të freskët në kamerën tonë dhe nëse ky person do ta kishte kapur dhe stërvitur fytyrën e tij më parë, njohësi ynë do të bëjë një "parashikim" duke kthyer id -in e tij dhe një indeks, i treguar se sa i sigurt është njohësi me këtë ndeshje.

Le të shkarkojmë shkrimin python të fazës së tretë nga GitHub im: 03_face_recognition.py.

import cv2

import numpy si np import os njohës = cv2.face. LBPHFaceRecognizer_create () njohës.lex ('trainer/trainer.yml') cascadePath = "haarcascade_frontalface_default.xml" faceCascade = cv2. CascadeClassifier (cascadePath); font = cv2. FONT_HERSHEY_SIMPLEX #iniciate id counter id = 0 # emrat që lidhen me ids: shembull ==> Marcelo: id = 1, etj emrat = ['Asnjë', 'Marcelo', 'Paula', 'Ilza', 'Z ',' W '] # Filloni dhe filloni regjistrimin e videove në kohë reale kamera = cv2. VideoCapture (0) cam.set (3, 640) # vendosni video të gjera cam.set (4, 480) # vendosni lartësinë e videos # Përcaktoni min madhësinë e dritares të njihet si fytyrë minW = 0.1*cam.get (3) minH = 0.1*cam.get (4) ndërsa True: ret, img = cam.read () img = cv2.flip (img, -1) # Rrokullisje gri vertikalisht = cv2.cvtColor (img, cv2. COLOR_BGR2GRAY) fytyra = faceCascade.detectMultiScale (gri, shkallëFaktori = 1.2, minFqinjët = 5, minSize = (int (minW), int (minH)),) për (x, y, w, h) në fytyra: cv2.rekëndësh (img, (x, y), (x+w, y+h), (0, 255, 0), 2) id, besim = njohës. parashiko (gri [y: y+h, x: x+w]) # Kontrolloni nëse besimi është më i vogël se ata 100 ==> "0" përputhet perfekt nëse (besimi <100): id = emrat [id] besimi = "{0}% ".format (raundi (100 - besimi)) tjetër: id =" i panjohur "besimi =" {0}%". format (raundi (100 - konf idence)) cv2.putText (img, str (id), (x+5, y-5), font, 1, (255, 255, 255), 2) cv2.putText (img, str (besim), (x+5, y+h-5), font, 1, (255, 255, 0), 1) cv2.imshow ('kamera', img) k = cv2.waitKey (10) & 0xff # Shtyp 'ESC' për daljen nga videoja nëse k == 27: pushim # Bëni pak printim pastrimi ("\ n [INFO] Dalja nga programi dhe gjëra pastrimi") cam.release () cv2.destroyAllWindows ()

Ne po përfshijmë këtu një grup të ri, kështu që ne do të shfaqim "emra", në vend të ID -ve të numëruara:

emrat = ['Asnjë', 'Marcelo', 'Paula', 'Ilza', 'Z', 'W']

Kështu, për shembull: Marcelo do të përdoruesit me id = 1; Paula: id = 2, etj.

Tjetra, ne do të zbulojmë një fytyrë, të njëjtën gjë që kemi bërë më parë me klasifikuesin haasCascade. Duke pasur një fytyrë të zbuluar, ne mund të thërrasim funksionin më të rëndësishëm në kodin e mësipërm:

id, besim = njohës. parashikoj (pjesa gri e fytyrës)

Identifikuesi.parashikimi (), do të marrë si parametër një pjesë të kapur të fytyrës që do të analizohet dhe do të kthejë pronarin e tij të mundshëm, duke treguar id -në e tij dhe sa besim ka njohësi në lidhje me këtë ndeshje.

Vini re se indeksi i besimit do të kthehet "zero" nëse do të konsiderohet një ndeshje e përsosur

Dhe së fundi, nëse njohësi mund të parashikojë një fytyrë, ne vendosim një tekst mbi imazhin me id -në e mundshme dhe sa është "probabiliteti" në % që përputhja të jetë e saktë ("probabiliteti" = 100 - indeksi i besimit). Nëse jo, një etiketë "e panjohur" vendoset në fytyrë.

Më poshtë një-g.webp

Në foton e mësipërme, unë tregoj disa teste të bëra me këtë projekt, ku gjithashtu kam përdorur fotografi për të verifikuar nëse funksionon njohësi.

Hapi 8: Përfundimi

Si gjithmonë, shpresoj se ky projekt mund të ndihmojë të tjerët të gjejnë rrugën e tyre në botën emocionuese të elektronikës!

Për detaje dhe kodin përfundimtar, ju lutemi vizitoni depozitimin tim GitHub: OpenCV-Face-Recognition

Për më shumë projekte, ju lutemi vizitoni blogun tim: MJRoBot.org

Më poshtë një paraqitje e shkurtër e një tutoriali të ardhshëm, ku ne do të eksplorojmë "gjurmimin automatik të fytyrës dhe metoda të tjera për zbulimin e fytyrës":

Saludos nga jugu i botës!

Shihemi në udhëzimin tim të ardhshëm!

Faleminderit, Marcelo