Gesichtserkennung in Echtzeit: ein End-to-End-Projekt – wikiHow

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:21

In meinem letzten Tutorial zum Erkunden von OpenCV haben wir AUTOMATIC VISION OBJECT TRACKING gelernt. Jetzt werden wir unsere PiCam verwenden, um Gesichter in Echtzeit zu erkennen, wie Sie unten sehen können:

Dieses Projekt wurde mit dieser fantastischen "Open Source Computer Vision Library", dem OpenCV, durchgeführt. In diesem Tutorial konzentrieren wir uns auf Raspberry Pi (also Raspbian als OS) und Python, aber ich habe den Code auch auf meinem Mac getestet und er funktioniert auch einwandfrei. OpenCV wurde für Recheneffizienz und mit einem starken Fokus auf Echtzeitanwendungen entwickelt. Es ist also perfekt für die Echtzeit-Gesichtserkennung mit einer Kamera.

Um ein vollständiges Projekt zur Gesichtserkennung zu erstellen, müssen wir an 3 sehr unterschiedlichen Phasen arbeiten:

1. Gesichtserkennung und Datenerfassung
2. Den Erkenner trainieren
3. Gesichtserkennung

Das folgende Blockdiagramm fasst diese Phasen zusammen:

Schritt 1: Stückliste - Stückliste

Hauptteile:

1. Raspberry Pi V3 - US$ 32,00
2. 5 Megapixel 1080p Sensor OV5647 Mini Kamera Videomodul - US$ 13.00

Schritt 2: OpenCV 3-Paket installieren

Ich verwende einen Raspberry Pi V3, der auf die neueste Version von Raspbian (Stretch) aktualisiert wurde. Der beste Weg, OpenCV zu installieren, besteht darin, dem hervorragenden Tutorial von Adrian Rosebrock zu folgen: Raspbian Stretch: Install OpenCV 3 + Python on your Raspberry Pi.

Ich habe verschiedene Anleitungen ausprobiert, um OpenCV auf meinem Pi zu installieren. Adrians Tutorial ist das Beste. Ich rate Ihnen, dasselbe zu tun, indem Sie Schritt für Schritt seiner Anleitung folgen.

Sobald Sie Adrians Tutorial beendet haben, sollten Sie eine virtuelle OpenCV-Umgebung haben, die bereit ist, unsere Experimente auf Ihrem Pi auszuführen.

Gehen wir zu unserer virtuellen Umgebung und bestätigen Sie, dass OpenCV 3 korrekt installiert ist.

Adrian empfiehlt, den Befehl "source" jedes Mal auszuführen, wenn Sie ein neues Terminal öffnen, um sicherzustellen, dass Ihre Systemvariablen korrekt eingerichtet wurden.

Quelle ~/.profile

Als nächstes betreten wir unsere virtuelle Umgebung:

Arbeitslebenslauf

Wenn Sie den Text (cv) vor Ihrer Eingabeaufforderung sehen, befinden Sie sich in der virtuellen Umgebung von cv:

(cv) pi@raspberry:~$Adrian weist darauf hin, dass die virtuelle Umgebung von cv Python völlig unabhängig und von der im Download von Raspbian Stretch enthaltenen Python-Standardversion getrennt ist. Daher sind alle Python-Pakete im globalen Verzeichnis site-packages für die virtuelle Umgebung von cv nicht verfügbar. Ebenso sind alle Python-Pakete, die in Site-Paketen von cv installiert sind, für die globale Installation von Python nicht verfügbar

Geben Sie nun Ihren Python-Interpreter ein:

Python

und bestätigen Sie, dass Sie die Version 3.5 (oder höher) verwenden

Importieren Sie im Interpreter (das ">>>" wird angezeigt) die OpenCV-Bibliothek:

CV2 importieren

Wenn keine Fehlermeldungen erscheinen, ist OpenCV auf IHRER VIRTUELLEN PYTHON-UMGEBUNG korrekt installiert.

Sie können auch die installierte OpenCV-Version überprüfen:

cv2._version_

Die 3.3.0 sollte erscheinen (oder eine höherwertige Version, die in Zukunft veröffentlicht werden kann). Der obige Terminaldruckbildschirm zeigt die vorherigen Schritte.

Schritt 3: Testen Sie Ihre Kamera

Sobald Sie OpenCV in Ihrem RPi installiert haben, testen wir, ob Ihre Kamera ordnungsgemäß funktioniert.

Ich gehe davon aus, dass auf Ihrem Raspberry Pi bereits eine PiCam installiert ist.

Geben Sie den folgenden Python-Code in Ihre IDE ein:

numpy als np importieren

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. flip(frame, -1) # Kamera vertikal spiegeln grau = cv2.cvtColor(frame, cv2. COLOR_BGR2GRAY) cv2.imshow('frame', frame) cv2.imshow('gray', grey) k = cv2.waitKey(30) & 0xff if k == 27: # 'ESC' drücken um zu beenden cap.release() cv2.destroyAllWindows()

Der obige Code erfasst den Videostream, der von Ihrer PiCam generiert wird, und zeigt sowohl in BGR-Farbe als auch im Graumodus an.

Beachten Sie, dass ich meine Kamera aufgrund der Art und Weise, wie sie zusammengebaut ist, vertikal gedreht habe. Wenn dies nicht der Fall ist, kommentieren oder löschen Sie die Befehlszeile "flip".

Alternativ können Sie den Code von meinem GitHub herunterladen: simpleCamTest.py

Geben Sie zum Ausführen den Befehl ein:

python simpleCamTest.py

Um das Programm zu beenden, müssen Sie die Taste [ESC] auf Ihrer Tastatur drücken.

Klicken Sie mit der Maus auf das Videofenster, bevor Sie [ESC] drücken.

Das obige Bild zeigt das Ergebnis.

Einige Hersteller fanden Probleme beim Versuch, die Kamera zu öffnen (Fehlermeldungen "Assertion failed"). Dies kann passieren, wenn die Kamera während der OpenCv-Installation nicht aktiviert wurde und die Kameratreiber nicht korrekt installiert wurden. Verwenden Sie zur Korrektur den Befehl:

sudo modprobe bcm2835-v4l2

Sie können auch bcm2835-v4l2 in die letzte Zeile der Datei /etc/modules einfügen, damit der Treiber beim Booten geladen wird.

Um mehr über OpenCV zu erfahren, können Sie dem Tutorial folgen: loading -video-python-opencv-tutorial

Schritt 4: Gesichtserkennung

Die grundlegendste Aufgabe der Gesichtserkennung ist natürlich "Gesichtserkennung". Zuallererst müssen Sie ein Gesicht "einfangen" (Phase 1), um es im Vergleich zu einem neuen Gesicht zu erkennen, das in der Zukunft aufgenommen wurde (Phase 3).

Die gebräuchlichste Methode zur Erkennung eines Gesichts (oder anderer Objekte) ist die Verwendung des "Haar Cascade-Klassifikators".

Die Objekterkennung mit merkmalsbasierten Kaskadenklassifikatoren von Haar ist eine effektive Objekterkennungsmethode, die von Paul Viola und Michael Jones in ihrem Artikel "Rapid Object Detection using a Boosted Cascade of Simple Features" aus dem Jahr 2001 vorgeschlagen wurde. Es handelt sich um einen auf maschinellem Lernen basierenden Ansatz, bei dem a Kaskadenfunktion wird aus vielen positiven und negativen Bildern trainiert. Es wird dann verwendet, um Objekte in anderen Bildern zu erkennen.

Hier arbeiten wir mit der Gesichtserkennung. Der Algorithmus benötigt zunächst viele positive Bilder (Bilder von Gesichtern) und negative Bilder (Bilder ohne Gesichter), um den Klassifikator zu trainieren. Dann müssen wir Features daraus extrahieren. Die gute Nachricht ist, dass OpenCV mit einem Trainer sowie einem Detektor geliefert wird. Wenn Sie Ihren eigenen Klassifikator für ein beliebiges Objekt wie Autos, Flugzeuge usw. trainieren möchten, können Sie OpenCV verwenden, um einen zu erstellen. Die vollständigen Details finden Sie hier: Cascade Classifier Training.

Wenn Sie keinen eigenen Klassifikator erstellen möchten, enthält OpenCV bereits viele vortrainierte Klassifikatoren für Gesicht, Augen, Lächeln usw. Diese XML-Dateien können aus dem haarcascades-Verzeichnis heruntergeladen werden.

Genug der Theorie, erstellen wir einen Gesichtsdetektor mit OpenCV!

Laden Sie die Datei faceDetection.py von meinem GitHub herunter.

numpy als np importieren

import 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) grey = cv2.cvtColor(img, cv2. COLOR_BGR2GRAY) faces = faceCascade.detectMultiScale(gray, scaleFactor=1.2, minNeighbors=5, minSize=(20, 20)) für (x, y, w, h) in Flächen: cv2.rectangle(img, (x, y), (x+w, y+h), (255, 0, 0), 2) roi_gray = grau[y:y+h, x:x+w] roi_color = img[y:y+h, x:x+w] cv2.imshow('video', img) k = cv2.waitKey(30) & 0xff if k == 27: # 'ESC' drücken um zu beenden break cap.release() cv2.destroyAllWindows()

Ob Sie es glauben oder nicht, die obigen paar Codezeilen sind alles, was Sie brauchen, um ein Gesicht mit Python und OpenCV zu erkennen.

Wenn Sie mit dem letzten Code vergleichen, der zum Testen der Kamera verwendet wurde, werden Sie feststellen, dass nur wenige Teile hinzugefügt wurden. Beachten Sie die folgende Zeile:

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

Dies ist die Zeile, die den "Klassifizierer" lädt (der sich in einem Verzeichnis namens "Cascades/" unter Ihrem Projektverzeichnis befinden muss).

Dann stellen wir unsere Kamera ein und laden in der Schleife unser Eingabevideo im Graustufenmodus (wie wir zuvor gesehen haben).

Jetzt müssen wir unsere Klassifikatorfunktion aufrufen und ihr einige sehr wichtige Parameter übergeben, wie den Skalierungsfaktor, die Anzahl der Nachbarn und die minimale Größe des erkannten Gesichts.

Gesichter = faceCascade.detectMultiScale(grau, scaleFactor=1,2, minNeighbors=5, minSize=(20, 20))

Woher,

• grau ist das eingegebene Graustufenbild.
• scaleFactor ist der Parameter, der angibt, um wie viel die Bildgröße bei jedem Bildmaßstab reduziert wird. Es wird verwendet, um die Maßstabspyramide zu erstellen.
• minNeighbors ist ein Parameter, der angibt, wie viele Nachbarn jedes Kandidatenrechteck haben soll, um es beizubehalten. Eine höhere Zahl führt zu niedrigeren Fehlalarmen.
• minSize ist die minimale Rechteckgröße, die als Gesicht betrachtet wird.

Die Funktion erkennt Gesichter auf dem Bild. Als nächstes müssen wir die Gesichter im Bild "markieren", indem wir beispielsweise ein blaues Rechteck verwenden. Dies geschieht mit diesem Teil des Codes:

für (x, y, w, h) in Flächen:

cv2.rectangle(img, (x, y), (x+w, y+h), (255, 0, 0), 2) roi_gray = grau[y:y+h, x:x+w] roi_color = img[y:y+h, x:x+w]

Wenn Gesichter gefunden werden, gibt es die Positionen der erkannten Gesichter als Rechteck mit der linken oberen Ecke (x, y) und mit "w" als Breite und "h" als Höhe zurück ==> (x, y, w, h). Bitte sehen Sie das obige Bild.

Sobald wir diese Positionen erhalten haben, können wir ein "ROI" (gezeichnetes Rechteck) für das Gesicht erstellen und das Ergebnis mit der Funktion imshow() präsentieren.

Führen Sie das obige Python-Skript in Ihrer Python-Umgebung mit dem Rpi-Terminal aus:

python faceDetection.py

Das Ergebnis:

Sie können auch Klassifikatoren für "Augenerkennung" oder sogar "Lächelnerkennung" hinzufügen. In diesen Fällen werden Sie die Klassifikatorfunktion und das Rechteckzeichnen in die Gesichtsschleife einbeziehen, da es keinen Sinn macht, ein Auge oder ein Lächeln außerhalb eines Gesichts zu erkennen.

Beachten Sie, dass auf einem Pi mehrere Klassifikatoren im selben Code die Verarbeitung verlangsamen, sobald diese Erkennungsmethode (HaarCascades) eine große Menge an Rechenleistung verbraucht. Auf einem Desktop ist es einfacher, es auszuführen.

Auf meinem GitHub finden Sie weitere Beispiele:

faceEyeDetection.py

faceSmileDetection.py

faceSmileEyeDetection.py

Und im obigen Bild sehen Sie das Ergebnis.

Sie können auch dem folgenden Tutorial folgen, um die Gesichtserkennung besser zu verstehen:

Haarkaskade Objekterkennung Gesicht & Auge OpenCV Python Tutorial

Schritt 5: Datenerfassung

Zunächst muss ich Ramiz Raja für seine großartige Arbeit zur Gesichtserkennung auf Fotos danken:

GESICHTSERKENNUNG MIT OPENCV UND PYTHON: EIN LEITFADEN FÜR EINSTEIGER

und auch Anirban Kar, das ein sehr umfassendes Tutorial mit Video entwickelt hat:

GESICHTSERKENNUNG - 3 Teile

Ich empfehle dringend, sich beide Tutorials anzuschauen.

Damit beginnen wir die erste Phase unseres Projekts. Was wir hier tun werden, ist ab dem letzten Schritt (Gesichtserkennung) einfach einen Datensatz zu erstellen, in dem wir für jede ID eine Gruppe von Fotos in Grau mit dem Teil speichern, der für die Gesichtserkennung verwendet wurde.

Erstellen Sie zunächst ein Verzeichnis, in dem Sie Ihr Projekt entwickeln, zum Beispiel FacialRecognitionProject:

mkdir FacialRecognitionProject

In diesem Verzeichnis müssen wir neben den 3 Python-Skripten, die wir für unser Projekt erstellen werden, den Facial Classifier gespeichert haben. Sie können es von meinem GitHub herunterladen: haarcascade_frontalface_default.xml

Als nächstes erstellen Sie ein Unterverzeichnis, in dem wir unsere Gesichtsproben speichern und nennen es "Datensatz":

mkdir-Datensatz

Und lade den Code von meinem GitHub herunter: 01_face_dataset.py

CV2 importieren

import os cam = cv2. VideoCapture(0) cam.set(3, 640) # Videobreite einstellen cam.set(4, 480) # Videohöhe einstellen face_detector = cv2. CascadeClassifier('haarcascade_frontalface_default.xml') # Für jede Person, geben Sie eine numerische Gesichts-ID ein face_id = input('\n Eingabe der Benutzer-ID end press ==> ') print("\n [INFO] Initialisieren der Gesichtserfassung. Schauen Sie in die Kamera und warten Sie …") # Initialisieren Sie die Zählung der individuellen Stichprobengesichtszählung = 0 while(True): ret, img = cam.read() img = cv2.flip(img, -1) # Videobild vertikal spiegeln grau = cv2.cvtColor(img, cv2. COLOR_BGR2GRAY) Gesichter = face_detector.detectMultiScale(grau, 1.3, 5) für (x, y, w, h) in Flächen: cv2.rectangle(img, (x, y), (x+w, y+h), (255, 0, 0), 2) count += 1 # Speichern Sie das aufgenommene Bild im Datensatzordner cv2.imwrite("dataset/User." + str(face_id) + '.' + str(count) + ".jpg", grey[y:y+ h, x:x+w]) cv2.imshow('image', img) k = cv2.waitKey(100) & 0xff # Drücken Sie 'ESC', um das Video zu beenden, wenn k == 27: Elif-Zählung >= 30: # Nehmen Sie 30 Gesichtsproben und stoppen Sie die Videopause # Machen Sie ab it of cleanup print("\n [INFO] Beenden des Programms und cleanup stuff") cam.release() cv2.destroyAllWindows()

Der Code ist dem Code, den wir für die Gesichtserkennung gesehen haben, sehr ähnlich. Was wir hinzugefügt haben, war ein "Eingabebefehl", um eine Benutzer-ID zu erfassen, die eine ganze Zahl sein sollte (1, 2, 3 usw.).

face_id = input('\n Geben Sie die Benutzer-ID ein und drücken Sie ==> ')

Und für jeden der aufgenommenen Frames sollten wir ihn als Datei in einem "Dataset"-Verzeichnis speichern:

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

Beachten Sie, dass Sie zum Speichern der obigen Datei die Bibliothek "os" importiert haben müssen. Der Name jeder Datei folgt der Struktur:

User.face_id.count.jpg

Für einen Benutzer mit einer face_id = 1 sieht die vierte Beispieldatei im Datensatz/Verzeichnis beispielsweise so aus:

Benutzer.1.4.jpg

wie auf dem obigen Foto von meinem Pi gezeigt. In meinem Code erfasse ich 30 Beispiele von jeder ID. Sie können es auf dem letzten "elif" ändern. Die Anzahl der Proben wird verwendet, um die Schleife zu unterbrechen, in der die Gesichtsproben erfasst werden.

Führen Sie das Python-Skript aus und erfassen Sie einige IDs. Sie müssen das Skript jedes Mal ausführen, wenn Sie einen neuen Benutzer aggregieren (oder die Fotos durch einen bereits vorhandenen ersetzen möchten).

Schritt 6: Trainer

In dieser zweiten Phase müssen wir alle Benutzerdaten aus unserem Datensatz nehmen und den OpenCV-Erkenner "trainieren". Dies geschieht direkt durch eine spezielle OpenCV-Funktion. Das Ergebnis ist eine.yml-Datei, die im Verzeichnis "trainer/" gespeichert wird.

Beginnen wir also mit der Erstellung eines Unterverzeichnisses, in dem wir die trainierten Daten speichern:

mkdir-Trainer

Laden Sie von meinem GitHub das zweite Python-Skript herunter: 02_face_training.py

CV2 importieren

import numpy as np from PIL import Image import os # Pfad für Gesichtsbilddatenbank path = 'dataset'cognizer = cv2.face. LBPHFaceRecognizer_create() Detector = cv2. CascadeClassifier("haarcascade_frontalface_default.xml"); # Funktion zum Abrufen der Bilder und Labeldaten def getImagesAndLabels(path): imagePaths = [os.path.join(path, f) for f in os.listdir(path)] faceSamples= ids = for imagePath in imagePaths: PIL_img = Image.open(imagePath).convert('L') # in Graustufen konvertieren img_numpy = np.array(PIL_img, 'uint8') id = int(os.path.split(imagePath)[-1]. split(".")[1]) faces = Detector.detectMultiScale(img_numpy) für (x, y, w, h) in Gesichtern: faceSamples.append(img_numpy[y:y+h, x:x+w]) ids.append(id) return faceSamples, ids print ("\n [INFO] Gesichter trainieren. Es dauert ein paar Sekunden. Warte …") Gesichter, ids = getImagesAndLabels(path)cognizer.train(faces, np.array(ids)) # Speichern Sie das Modell in trainer/trainer.ymlcognizer.write('trainer/trainer.yml') #cognizer.save() funktionierte auf Mac, aber nicht auf Pi # Drucken Sie die Anzahl der trainierten Gesichter und beenden Sie den Programmdruck ("\n [INFO] {0} Gesichter trainiert. Programm wird beendet".format(len(np.unique(ids))))

Bestätigen Sie, ob Sie die PIL-Bibliothek auf Ihrem Rpi installiert haben. Wenn nicht, führen Sie den folgenden Befehl im Terminal aus:

Pip installieren Kissen

Wir verwenden als Erkennungsmerkmal den LBPH-Gesichtserkenner (LOCAL BINARY PATTERNS HISTOGRAMS), der im OpenCV-Paket enthalten ist. Das machen wir in der folgenden Zeile:

Recognizer = cv2.face. LBPHFaceRecognizer_create()

Die Funktion "getImagesAndLabels (path)" nimmt alle Fotos im Verzeichnis: "dataset/" und gibt 2 Arrays zurück: "Ids" und "faces". Mit diesen Arrays als Eingabe werden wir "unseren Erkenner trainieren":

Erkennung. Zug(Gesichter, IDs)

Als Ergebnis wird eine Datei mit dem Namen "trainer.yml" im zuvor von uns erstellten Trainerverzeichnis gespeichert.

Das ist es! Ich habe die letzte Druckaussage hinzugefügt, in der ich zur Bestätigung die Anzahl der von uns trainierten Benutzergesichter angezeigt habe.

Jedes Mal, wenn Sie Phase 1 ausführen, muss auch Phase 2 ausgeführt werden

Schritt 7: Erkenner

Jetzt haben wir die letzte Phase unseres Projekts erreicht. Hier werden wir ein neues Gesicht mit unserer Kamera aufnehmen und wenn diese Person sein Gesicht zuvor aufgenommen und trainiert hat, macht unser Erkenner eine "Vorhersage", die seine ID und einen Index zurückgibt, der zeigt, wie sicher der Erkenner mit dieser Übereinstimmung ist.

Laden wir das Python-Skript der 3. Phase von meinem GitHub herunter: 03_face_recognition.py.

CV2 importieren

import numpy as np import oscognizer = cv2.face. LBPHFaceRecognizer_create()cognizer.read('trainer/trainer.yml') cascadePath = "haarcascade_frontalface_default.xml" faceCascade = cv2. CascadeClassifier(cascadePath); font = cv2. FONT_HERSHEY_SIMPLEX #iniciate id counter id = 0 # Namen im Zusammenhang mit IDs: Beispiel ==> Marcelo: id=1, etc. names = ['Keine', 'Marcelo', 'Paula', 'Ilza', 'Z ', 'W'] # Echtzeit-Videoaufnahme initialisieren und starten cam = cv2. VideoCapture(0) cam.set(3, 640) # Videobreite einstellen cam.set(4, 480) # Videohöhe einstellen # Minimale Fenstergröße definieren als Gesicht erkannt werden minW = 0.1*cam.get(3) minH = 0.1*cam.get(4) while True: ret, img =cam.read() img = cv2.flip(img, -1) # Vertikal spiegeln grau = cv2.cvtColor(img, cv2. COLOR_BGR2GRAY) Gesichter = faceCascade.detectMultiScale(gray, scaleFactor = 1.2, minNeighbors = 5, minSize = (int(minW), int(minH)),) for(x, y, w, h) in Gesichtern: cv2.rectangle(img, (x, y), (x+w, y+h), (0, 255, 0), 2) id, Confidence =cognizer.predict(gray[y:y+h, x:x+w]) # Prüfen, ob Konfidenz kleiner als 100 ==> "0" ist perfekt, wenn (Konfidenz < 100): id = Namen[id] Konfidenz = " {0}% ".format(round(100 - Konfidenz)) else: id = "unbekannt" Konfidenz = " {0}%".format(round(100 - Konf idence)) cv2.putText(img, str(id), (x+5, y-5), font, 1, (255, 255, 255), 2) cv2.putText(img, str(confidence), (x+5, y+h-5), Schriftart, 1, (255, 255, 0), 1) cv2.imshow('camera', img) k = cv2.waitKey(10) & 0xff # Drücken Sie 'ESC' zum Beenden des Videos if k == 27: break # Mach ein bisschen Aufräumen print("\n [INFO] Programm beenden und Sachen aufräumen") cam.release() cv2.destroyAllWindows()

Wir fügen hier ein neues Array ein, sodass wir "Namen" anstelle von nummerierten IDs anzeigen:

Namen = ['Keine', 'Marcelo', 'Paula', 'Ilza', 'Z', 'W']

Also zum Beispiel: Marcelo wird der Benutzer mit der ID = 1; Paula: id=2 usw.

Als nächstes werden wir ein Gesicht erkennen, genau wie zuvor mit dem haasCascade-Klassifikator. Mit einem erkannten Gesicht können wir die wichtigste Funktion im obigen Code aufrufen:

ID, Vertrauen = Recognizer.predict (grauer Teil des Gesichts)

Der Recognizer.predict() nimmt als Parameter einen erfassten Teil des zu analysierenden Gesichts und gibt seinen wahrscheinlichen Besitzer zurück, der seine ID angibt und wie viel Vertrauen der Recognizer in Bezug auf diese Übereinstimmung hat.

Beachten Sie, dass der Konfidenzindex "Null" zurückgibt, wenn er als perfekte Übereinstimmung angesehen wird

Und schließlich, wenn der Erkenner ein Gesicht vorhersagen könnte, legen wir einen Text über das Bild mit der wahrscheinlichen ID und wie hoch ist die "Wahrscheinlichkeit" in %, dass die Übereinstimmung richtig ist ("Wahrscheinlichkeit" = 100 - Konfidenzindex). Wenn nicht, wird das Gesicht mit einem "Unbekannt"-Etikett versehen.

Unten ein-g.webp

Auf dem obigen Bild zeige ich einige Tests, die mit diesem Projekt durchgeführt wurden, bei denen ich auch Fotos verwendet habe, um zu überprüfen, ob der Erkenner funktioniert.

Schritt 8: Fazit

Wie immer hoffe ich, dass dieses Projekt anderen helfen kann, ihren Weg in die spannende Welt der Elektronik zu finden!

Für Details und den endgültigen Code besuchen Sie bitte mein GitHub-Depot: OpenCV-Face-Recognition

Für weitere Projekte besuchen Sie bitte meinen Blog: MJRoBot.org

Unten ein Blick auf ein zukünftiges Tutorial, in dem wir "automatische Gesichtsverfolgung und andere Methoden zur Gesichtserkennung" untersuchen:

Saludos aus dem Süden der Welt!

Wir sehen uns in meinem nächsten instructable!

Dankeschön, Marcelo