Sejas atpazīšana reāllaikā: pilns projekts: 8 soļi (ar attēliem)

2024 Autors: John Day | [email protected]. Pēdējoreiz modificēts: 2024-01-30 10:57

Pēdējā apmācībā, kurā es pētīju OpenCV, mēs uzzinājām AUTOMĀTISKĀS VISIJAS OBJEKTA IZSEKOŠANU. Tagad mēs izmantosim savu PiCam, lai atpazītu sejas reāllaikā, kā redzams zemāk:

Šis projekts tika veikts ar šo fantastisko "atvērtā pirmkoda datora redzes bibliotēku", OpenCV. Šajā apmācībā mēs koncentrēsimies uz Raspberry Pi (tātad, Raspbian kā OS) un Python, bet es arī pārbaudīju kodu vietnē My Mac, un tas arī darbojas labi. OpenCV tika izstrādāts, lai nodrošinātu skaitļošanas efektivitāti un koncentrētos uz reāllaika lietojumprogrammām. Tātad, tas ir lieliski piemērots reāllaika sejas atpazīšanai, izmantojot kameru.

Lai izveidotu pilnīgu sejas atpazīšanas projektu, mums jāstrādā pie 3 ļoti atšķirīgiem posmiem:

1. Sejas noteikšana un datu vākšana
2. Apmāciet atpazīšanas ierīci
3. Sejas atpazīšana

Zemāk esošā blokshēma atsāk šīs fāzes:

1. solis: BoM - materiālu saraksts

Galvenās daļas:

1. Raspberry Pi V3 - 32,00 ASV dolāri
2. 5 megapikseļu 1080p sensors OV5647 mini kameras video modulis - 13,00 ASV dolāri

2. darbība: OpenCV 3 pakotnes instalēšana

Es izmantoju Raspberry Pi V3, kas atjaunināta uz pēdējo Raspbian (Stretch) versiju, tāpēc labākais veids, kā instalēt OpenCV, ir sekot Adrian Rosebrock izstrādātajai lieliskajai apmācībai: Raspbian Stretch: instalējiet OpenCV 3 + Python savā Raspberry Pi.

Es izmēģināju vairākus dažādus ceļvežus, lai instalētu OpenCV savā Pi. Adriana apmācība ir labākā. Es iesaku jums rīkoties tāpat, soli pa solim ievērojot viņa norādījumus.

Kad esat pabeidzis Adriana apmācību, jums jābūt gatavai OpenCV virtuālajai videi, lai veiktu mūsu eksperimentus ar jūsu Pi.

Dodamies uz mūsu virtuālo vidi un apstiprinām, ka OpenCV 3 ir pareizi instalēts.

Adrians iesaka palaist komandu “avots” katru reizi, atverot jaunu termināli, lai pārliecinātos, ka sistēmas mainīgie ir pareizi iestatīti.

avots ~/.profils

Pēc tam ievadīsim mūsu virtuālo vidi:

workon cv

Ja pirms uzvednes redzat tekstu (cv), tad atrodaties cv virtuālajā vidē:

(cv) pi@aveņu: ~ $Adrians pievērš uzmanību tam, ka cv Python virtuālā vide ir pilnīgi neatkarīga un atdalīta no noklusējuma Python versijas, kas iekļauta Raspbian Stretch lejupielādē. Tātad, visas Python paketes globālajā vietņu pakotņu direktorijā nebūs pieejamas cv virtuālajai videi. Līdzīgi visas Python pakotnes, kas instalētas cv vietnes pakotnēs, nebūs pieejamas Python globālajai instalācijai

Tagad ievadiet savu Python tulku:

pitons

un apstipriniet, ka izmantojat versiju 3.5 (vai jaunāku)

Tulka iekšpusē (parādīsies ">>>") importējiet OpenCV bibliotēku:

importēt cv2

Ja netiek parādīts neviens kļūdas ziņojums, OpenCV ir pareizi instalēts JŪSU PYTHON VIRTUAL VIDĒ.

Varat arī pārbaudīt instalēto OpenCV versiju:

cv2._ versija_

Parādīsies 3.3.0 (vai augstāka versija, kuru var izlaist nākotnē). Iepriekš redzamais termināļa drukas ekrāns parāda iepriekšējās darbības.

3. darbība: kameras pārbaude

Kad jūsu RPi ir instalēts OpenCV, pārbaudīsim, vai jūsu kamera darbojas pareizi.

Es pieņemu, ka jūsu Raspberry Pi jau ir instalēts PiCam.

Ievadiet tālāk norādīto Python kodu savā IDE:

importēt numpy kā np

importēt 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 (kadrs, -1) # Flip kamera vertikāli pelēka = cv2.cvtColor (kadrs, cv2. COLOR_BGR2GRAY) cv2.imshow ('rāmis', rāmis) cv2.imshow ('pelēks', pelēks) k = cv2.waitKey (30) & 0xff, ja k == 27: # nospiediet 'ESC', lai aizvērtu pārtraukuma vāciņu. Release () cv2.destroyAllWindows ()

Iepriekš minētais kods uzņems video straumi, ko ģenerēs jūsu PiCam, parādot gan BGR krāsu, gan pelēkā režīmā.

Ņemiet vērā, ka es pagriezu kameru vertikāli, jo tā ir salikta. Ja tas nav jūsu gadījums, komentējiet vai izdzēsiet komandrindu "flip".

Varat arī lejupielādēt kodu no mana GitHub: simpleCamTest.py

Lai izpildītu, ievadiet komandu:

python simpleCamTest.py

Lai pabeigtu programmu, jums jānospiež tastatūras taustiņš [ESC].

Noklikšķiniet uz peles uz video loga, pirms nospiežat [ESC]

Iepriekš redzamais attēls parāda rezultātu.

Daži ražotāji atklāja problēmas, mēģinot atvērt kameru (kļūdas ziņojumi “Apstiprinājums neizdevās”). Tas varētu notikt, ja kamera nebūtu iespējota OpenCv instalēšanas laikā un tāpēc kameras draiveri netiktu instalēti pareizi. Lai labotu, izmantojiet komandu:

sudo modprobe bcm2835-v4l2

Jūs varat arī pievienot bcm2835-v4l2 faila /etc /modules pēdējā rindā, lai draiveris tiktu ielādēts sāknēšanas laikā.

Lai uzzinātu vairāk par OpenCV, varat sekot apmācībai: ielādēt -video-python-opencv-tutorial

4. darbība. Sejas noteikšana

Svarīgākais sejas atpazīšanas uzdevums, protams, ir "Seju noteikšana". Vispirms jums ir "jāuzņem" seja (1. fāze), lai to atpazītu, salīdzinot ar jaunu seju, kas uzņemta nākotnē (3. fāze).

Visizplatītākais veids, kā noteikt seju (vai citus objektus), ir "Haar Cascade" klasifikators

Objektu noteikšana, izmantojot uz Haar īpašībām balstītus kaskādes klasifikatorus, ir efektīva objektu noteikšanas metode, ko 2001. gadā ierosināja Pols Viola un Maikls Džounss savā darbā "Ātrā objektu noteikšana, izmantojot vienkāršu funkciju pastiprinātu kaskādi". Tā ir uz mašīnmācīšanos balstīta pieeja, kurā kaskādes funkcija tiek apmācīta no daudziem pozitīviem un negatīviem attēliem. Pēc tam to izmanto, lai noteiktu objektus citos attēlos.

Šeit mēs strādāsim ar sejas noteikšanu. Sākotnēji algoritmam ir nepieciešams daudz pozitīvu attēlu (seju attēlu) un negatīvu attēlu (attēli bez sejām), lai apmācītu klasifikatoru. Tad mums ir jāizņem no tā iezīmes. Labā ziņa ir tā, ka OpenCV komplektā ir trenažieris, kā arī detektors. Ja vēlaties apmācīt savu klasifikatoru jebkuram objektam, piemēram, automašīnai, lidmašīnai utt., Varat izmantot OpenCV, lai to izveidotu. Visa tā informācija ir sniegta šeit: Cascade Classifier Training.

Ja nevēlaties izveidot savu klasifikatoru, OpenCV jau satur daudzus iepriekš apmācītus sejas, acu, smaida uc klasifikatorus. Šos XML failus var lejupielādēt no kataloga haarcascades.

Pietiek teorijas, izveidosim sejas detektoru ar OpenCV!

Lejupielādējiet failu: faceDetection.py no mana GitHub.

importēt numpy kā np

importēt 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) pelēks = cv2.cvtColor (img, cv2. COLOR_BGR2GRAY) sejas = faceCascade.detectMultiScale (pelēks, scaleFactor = 1,2, minKaimiņi = 5, minSize = (20, 20)) (x, y, w, h) sejās: cv2. taisnstūris (img, (x, y), (x+w, y+h), (255, 0, 0), 2) roi_gray = pelēks [y: y+h, x: x+w] roi_color = img [y: y+h, x: x+w] cv2.imshow ('video', img) k = cv2.waitKey (30) & 0xff, ja k == 27: # nospiediet 'ESC', lai aizvērtu pārtraukuma vāciņu. Release () cv2.destroyAllWindows ()

Ticiet vai nē, dažas iepriekš minētās koda rindas ir viss, kas jums nepieciešams, lai noteiktu seju, izmantojot Python un OpenCV.

Salīdzinot ar pēdējo kodu, ko izmantoja kameras pārbaudei, jūs sapratīsit, ka tai tika pievienotas dažas daļas. Ievērojiet zemāk esošo rindiņu:

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

Šī ir rinda, kurā tiek ielādēts "klasifikators" (tam jāatrodas direktorijā ar nosaukumu "Kaskādes/", kas atrodas jūsu projekta direktorijā).

Pēc tam mēs iestatīsim kameru un cilpas iekšpusē ielādēsim ievades video pelēktoņu režīmā (tas pats, ko redzējām iepriekš).

Tagad mums ir jāizsauc mūsu klasifikatora funkcija, nododot tai dažus ļoti svarīgus parametrus, piemēram, mēroga koeficientu, kaimiņu skaitu un konstatētās sejas minimālo izmēru.

sejas = faceCascade.detectMultiScale (pelēks, skala Faktors = 1,2, min Kaimiņi = 5, minSize = (20, 20))

Kur,

• pelēks ir ievades pelēktoņu attēls.
• scaleFactor ir parametrs, kas nosaka, cik lielā mērā katrā attēla mērogā tiek samazināts attēla izmērs. To izmanto, lai izveidotu mēroga piramīdu.
• minNeighbors ir parametrs, kas nosaka, cik kaimiņu jābūt katram taisnstūra kandidātam, lai to saglabātu. Lielāks skaitlis dod mazāk viltus pozitīvu rezultātu.
• minSize ir minimālais taisnstūra izmērs, kas uzskatāms par seju.

Funkcija atpazīs sejas attēlā. Tālāk mums ir "jāatzīmē" sejas attēlā, izmantojot, piemēram, zilu taisnstūri. Tas tiek darīts ar šo koda daļu:

(x, y, w, h) sejās:

cv2. taisnstūris (img, (x, y), (x+w, y+h), (255, 0, 0), 2) roi_gray = pelēks [y: y+h, x: x+w] roi_color = img [y: y+h, x: x+w]

Ja tiek atrastas sejas, tas atgriež atklāto seju pozīcijas kā taisnstūri ar kreiso augšējo stūri (x, y) un ar platumu “w” un augstumu “h” ==> (x, y, w, h). Lūdzu, skatiet iepriekš redzamo attēlu.

Kad esam ieguvuši šīs atrašanās vietas, mēs varam izveidot sejai “ROI” (uzzīmētu taisnstūri) un parādīt rezultātu ar imshow () funkciju.

Palaidiet iepriekš minēto python skriptu savā python vidē, izmantojot Rpi termināli:

python faceDetection.py

Rezultāts:

Varat arī iekļaut klasifikatorus "acu noteikšanai" vai pat "smaida noteikšanai". Šādos gadījumos jūs iekļausit klasifikācijas funkciju un taisnstūra zīmējumu sejas cilpā, jo nebūtu jēgas atklāt aci vai smaidu ārpus sejas.

Ņemiet vērā, ka Pi gadījumā, ja vienā klasē ir vairāki klasifikatori, tas palēninās apstrādi, tiklīdz šī noteikšanas metode (HaarCascades) izmanto lielu skaitļošanas jaudu. Galddatorā to ir vieglāk palaist.

Manā GitHub atradīsit citus piemērus:

faceEyeDetection.py

faceSmileDetection.py

faceSmileEyeDetection.py

Un iepriekš redzamajā attēlā jūs varat redzēt rezultātu.

Varat arī sekot tālāk sniegtajai apmācībai, lai labāk izprastu sejas noteikšanu:

Haar kaskādes objektu noteikšanas sejas un acu OpenCV Python apmācība

5. darbība. Datu vākšana

Pirmkārt, man jāpateicas Ramizam Radžam par lielisko darbu pie sejas atpazīšanas fotoattēlos:

Sejas atpazīšana, izmantojot OPENCV un PYTHON: iesācēja rokasgrāmata

un arī Anirban Kar, kas izstrādāja ļoti visaptverošu apmācību, izmantojot video:

SEJAS ATZĪŠANA - 3 daļas

Es tiešām iesaku jums apskatīt abas apmācības.

To sakot, sāksim mūsu projekta pirmo posmu. Šeit mēs darīsim visu, sākot ar pēdējo darbību (sejas noteikšana), mēs vienkārši izveidosim datu kopu, kurā katram ID saglabāsim pelēku fotoattēlu grupu ar daļu, kas tika izmantota sejas noteikšanai.

Vispirms izveidojiet direktoriju, kurā izstrādājat savu projektu, piemēram, FacialRecognitionProject:

mkdir FacialRecognitionProject

Šajā direktorijā papildus 3 python skriptiem, kurus mēs izveidosim savam projektam, mums tajā ir jāsaglabā sejas klasifikators. To var lejupielādēt no mana GitHub: haarcascade_frontalface_default.xml

Pēc tam izveidojiet apakšdirektoriju, kurā mēs glabāsim mūsu sejas paraugus un nosauksim to par "datu kopu":

mkdir datu kopa

Un lejupielādējiet kodu no mana GitHub: 01_face_dataset.py

importēt cv2

importēt os cam = cv2. VideoCapture (0) cam.set (3, 640) # iestatīt video platumu cam.set (4, 480) # iestatīt video augstumu face_detector = cv2. CascadeClassifier ('haarcascade_frontalface_default.xml') # Katrai personai, ievadiet vienu ciparu sejas ID face_id = ievade ('\ n ievadiet lietotāja ID beigas nospiediet ==>') print ("\ n [INFO] Notiek sejas uztveršanas inicializēšana. Paskatieties kamerā un pagaidiet …") # Inicializējiet individuālo paraugu ņemšanas seju skaitu = 0, kamēr (True): ret, img = cam.read () img = cv2.flip (img, -1) # apvērst video attēlu vertikāli pelēks = cv2.cvtColor (img, cv2. COLOR_BGR2GRAY) sejas = face_detector.detectMultiScale (pelēks, 1.3, 5) (x, y, w, h) sejās: cv2. taisnstūris (img, (x, y), (x+w, y+h), (255, 0, 0), 2)) count + = 1 # Saglabājiet uzņemto attēlu datu kopu mapē cv2.imwrite ("dataset/User." + str (face_id) + '.' + str (count) + ".jpg", pelēks [y: y + h, x: x+w]) cv2.imshow ('attēls', img) k = cv2.waitKey (100) & 0xff # Nospiediet 'ESC', lai izietu no video, ja k == 27: pārtraukuma elifu skaits> = 30: # Paņemiet 30 sejas paraugu un pārtrauciet video pārtraukumu # Vai ab it of cleanup print ("\ n [INFO] Iziešana no programmas un tīrīšanas materiāli") cam.release () cv2.destroyAllWindows ()

Kods ir ļoti līdzīgs kodam, ko mēs redzējām sejas noteikšanai. Mēs pievienojām “ievades komandu”, lai iegūtu lietotāja ID, kam vajadzētu būt veselam skaitlim (1, 2, 3 utt.)

face_id = ievade ('\ n ievadiet lietotāja ID beigu nospiediet ==>')

Un katram no uzņemtajiem kadriem mums tas jāsaglabā kā fails "datu kopas" direktorijā:

cv2.imwrite ("datu kopa/lietotājs." + str (face_id) + '.' + str (skaits) + ".jpg", pelēks [y: y + h, x: x + w])

Ņemiet vērā: lai saglabātu iepriekš minēto failu, jums ir jābūt importētam bibliotēkai "os". Katra faila nosaukums atbilst struktūrai:

User.face_id.count.jpg

Piemēram, lietotājam ar face_id = 1 ceturtais parauga fails datu kopā/ direktorijā būs šāds:

Lietotājs.1.4.jpg

kā parādīts iepriekšējā fotoattēlā no mana Pi. Savā kodā es tveru 30 paraugus no katra ID. Jūs varat to mainīt pēdējā "elifā". Paraugu skaits tiek izmantots, lai pārtrauktu cilpu, kur tiek uztverti sejas paraugi.

Palaidiet Python skriptu un uzņemiet dažus ID. Skripts jāizpilda katru reizi, kad vēlaties apkopot jaunu lietotāju (vai mainīt fotoattēlus pret jau esošu).

6. solis: treneris

Šajā otrajā posmā mums ir jāņem visi lietotāju dati no mūsu datu kopas un "jāapmāca" OpenCV Recognizer. To dara tieši, izmantojot īpašu OpenCV funkciju. Rezultāts būs.yml fails, kas tiks saglabāts direktorijā "trainer/".

Tātad, sāksim izveidot apakšdirektoriju, kurā mēs saglabāsim apmācītos datus:

mkdir treneris

Lejupielādējiet no mana GitHub otro python skriptu: 02_face_training.py

importēt cv2

importēt numpy kā np no PIL importa attēla importēšanas os # Ceļš sejas attēlu datu bāzes ceļam = 'datu kopa' atpazīšanas ierīce = cv2.face. LBPHFaceRecognizer_create () detektors = cv2. CascadeClassifier ("haarcascade_frontalface_default.xml"); # funkcija, lai iegūtu attēlus un etiķetes datus def getImagesAndLabels (ceļš): imagePaths = [os.path.join (path, f) for f in os.listdir (path)] faceSamples = ids = imagePath in imagePaths: PIL_img = Image.open (imagePath).convert ('L') # pārvērst to pelēktoņos img_numpy = np.array (PIL_img, 'uint8') id = int (os.path.split (imagePath) [-1]. sadalīt (".") [1]) sejas = detektors.detectMultiScale (img_numpy) (x, y, w, h) sejās: faceSamples.append (img_numpy [y: y+h, x: x+w]) ids.append (id) atgriezt seju ids)) # Saglabājiet modeli trenera/trenažiera.yml atpazīšanas ierīcē.write ('trainer/trainer.yml') # tunnizētājs.save () strādāja operētājsistēmā Mac, bet ne uz Pi # Izdrukājiet apmācīto seju skaitu un beidziet programmas drukāšanu ("\ n [INFO] {0} sejas ir apmācītas. Iziet no programmas".format (len (np.unique (ids))))

Pārbaudiet, vai jūsu RPI ir instalēta PIL bibliotēka. Ja nē, palaidiet šādu komandu terminālī:

pip uzstādīt spilvenu

Kā atpazīšanas ierīci mēs izmantosim LBPH (LOCAL BINARY PATTERNS HISTOGRAMS) sejas atpazīšanas ierīci, kas iekļauta OpenCV iepakojumā. Mēs to darām šādā rindā:

atpazīšanas ierīce = cv2.face. LBPHFaceRecognizer_create ()

Funkcija "getImagesAndLabels (ceļš)" uzņems visus fotoattēlus direktorijā: "dataset/", atgriežot 2 masīvus: "ID" un "sejas". Izmantojot šos masīvus, mēs "apmācīsim atpazīstamību":

tunnistajs.treniņš (sejas, ID)

Tā rezultātā fails ar nosaukumu "trainer.yml" tiks saglabāts trenera direktorijā, kuru mēs iepriekš izveidojām.

Tieši tā! Es iekļāvu pēdējo drukas paziņojumu, kurā es parādīju apstiprināšanai, lietotāju apmācīto seju skaitu.

Katru reizi, kad veicat 1. fāzi, ir jāsāk arī 2. fāze

7. darbība: atpazīšanas ierīce

Tagad mēs esam sasnieguši mūsu projekta pēdējo posmu. Šeit mēs savā kamerā iemūžināsim svaigu seju, un, ja šai personai seja tika iemūžināta un apmācīta iepriekš, mūsu atpazīšanas ierīce veiks “prognozi”, atgriežot savu ID un rādītāju, parādot, cik pārliecināts atpazīstamība ir ar šo spēli.

Lejupielādēsim trešās fāzes python skriptu no mana GitHub: 03_face_recognition.py.

importēt cv2

importēt numpy kā np importēt os atpazīšanas ierīci = cv2.face. LBPHFaceRecognizer_create () atpazīšanas rīks ('trainer/trainer.yml') cascadePath = "haarcascade_frontalface_default.xml" faceCascade = cv2. CascadeClassifier (cascadePath); font = cv2. FONT_HERSHEY_SIMPLEX #iniciate id counter id = 0 # vārdi, kas saistīti ar ID: example ==> Marcelo: id = 1, etc names = ['Nav', 'Marcelo', 'Paula', 'Ilza', 'Z ',' W '] # Inicializējiet un sāciet reāllaika video uzņemšanu cam = cv2. VideoCapture (0) cam.set (3, 640) # set video widht cam.set (4, 480) # set video height # Definēt minimālo loga izmēru jāatzīst par seju minW = 0,1*cam.get (3) minH = 0,1*cam.get (4), kamēr True: ret, img = cam.read () img = cv2.flip (img, -1) # Apvērst vertikāli pelēku = cv2.cvtColor (img, cv2. COLOR_BGR2GRAY) sejas = faceCascade.detectMultiScale (pelēks, scaleFactor = 1,2, minNeighbors = 5, minSize = (int (minW), int (minH)),) (x, y, w, h) sejās: cv2. taisnstūris (img, (x, y), (x+w, y+h), (0, 255, 0), 2) id, uzticamība = atpazītājs.prognozēt (pelēks [y: y+h, x: x+w]) # Pārbaudiet, vai pašpārliecinātība ir mazāka. ".format (apaļa (100 - ticamība)) else: id =" unknown "trust =" {0}%". format (round (100 - conf idence)) cv2.putText (img, str (id), (x+5, y-5), fonts, 1, (255, 255, 255), 2) cv2.putText (img, str (uzticība), (x+5, y+h-5), fonts, 1, (255, 255, 0), 1) cv2.imshow ('kamera', img) k = cv2.waitKey (10) & 0xff # Nospiediet 'ESC' iziešanai no video, ja k == 27: break # Veiciet nelielu tīrīšanu ("\ n [INFO] Iziešana no programmas un tīrīšanas materiāli") cam.release () cv2.destroyAllWindows ()

Mēs šeit iekļaujam jaunu masīvu, tāpēc numurētu ID vietā parādīsim vārdus:

vārdi = ['Nav', 'Marcelo', 'Paula', 'Ilza', 'Z', 'W']

Tā, piemēram: Marcelo būs lietotājs ar id = 1; Paula: id = 2 utt.

Tālāk mēs atklāsim seju, tāpat kā iepriekš ar haasCascade klasifikatoru. Ja ir konstatēta seja, mēs varam izsaukt vissvarīgāko funkciju iepriekš minētajā kodā:

id, uzticība = atpazītājs.prognozēt (pelēka sejas daļa)

Atpazinējs.predict () par parametru ņems analizējamo sejas daļu un atgriezīs iespējamo īpašnieku, norādot tā ID un uzticības pakāpi attiecībā uz šo atbilstību.

Ņemiet vērā, ka ticamības indekss atgriezīs “nulli”, ja tas tiks atzīts par perfektu atbilstību

Visbeidzot, ja atpazīšanas ierīce varēja paredzēt seju, mēs virs attēla ievietojām tekstu ar iespējamo ID un cik liela ir "varbūtība" %, ka atbilstība ir pareiza ("varbūtība" = 100 - ticamības indekss). Ja nē, uz sejas tiek uzlikta etiķete "nepazīstama".

Zemāk-g.webp

Iepriekš redzamajā attēlā es parādīju dažus testus, kas veikti ar šo projektu, kur arī esmu izmantojis fotoattēlus, lai pārbaudītu, vai atpazīšanas ierīce darbojas.

8. solis. Secinājums

Kā vienmēr, es ceru, ka šis projekts var palīdzēt citiem atrast ceļu aizraujošajā elektronikas pasaulē!

Lai iegūtu sīkāku informāciju un galīgo kodu, lūdzu, apmeklējiet manu GitHub depozitāriju: OpenCV-Face-Recognition

Lai iegūtu vairāk projektu, lūdzu, apmeklējiet manu emuāru: MJRoBot.org

Zemāk ieskats turpmākajā apmācībā, kurā mēs izpētīsim “automātisko sejas izsekošanu un citas sejas noteikšanas metodes”:

Sveicieni no pasaules dienvidiem!

Uz tikšanos manā nākamajā pamācībā!

Paldies, Marselo