Echtzeit-Gesichtserkennung:Ein End-to-End-Projekt

Wir werden Schritt für Schritt lernen, wie man eine PiCam verwendet, um Gesichter in Echtzeit zu erkennen. In meinem letzten Tutorial zum Erkunden von OpenCV haben wir das AUTOMATISCHE 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 gut. 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.

3 Phasen

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

• Gesichtserkennung und Datenerfassung

• Trainiere den Erkenner

• Gesichtserkennung

Das folgende Blockdiagramm fasst diese Phasen wieder:

Schritt 1:Stückliste – Stückliste

Hauptteile:

• Raspberry Pi V3 – US$ 32,00

• 5 Megapixel 1080p Sensor OV5647 Mini-Kamera-Videomodul – 13,00 €

Schritt 2:OpenCV 3-Paket installieren

Ich verwende einen Raspberry Pi V3, der auf die neueste Version von Raspbian (Stretch) aktualisiert wurde. OpenCV lässt sich daher am besten installieren, indem Sie dem hervorragenden Tutorial von Adrian Rosebrock folgen: Raspbian Stretch:Install OpenCV 3 + Python auf Ihrem Raspberry Pi.

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

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

Gehen wir in unsere virtuelle 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 (Lebenslauf) vor Ihrer Eingabeaufforderung sehen, befinden Sie sich im virtuellen Lebenslauf Umgebung:

(cv) pi@raspberry:~$

Adrian weist darauf hin, dass die vv Python virtuelle Umgebung ist völlig unabhängig und getrennt von der Standard-Python-Version, die im Download von Raspbian Stretch enthalten 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.

Im Interpreter (das „>>>“ erscheint) importieren Sie die OpenCV-Bibliothek:

CV2 importieren

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

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

cv2.__version__

Die 3.3.0 sollte erscheinen (oder eine höhere Version, die in Zukunft veröffentlicht werden kann).

Der obige Terminal-Druckbildschirm zeigt die vorherigen Schritte.

Schritt 3:Testen Sie Ihre Kamera

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

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

Sie müssen die Kamera aktiviert haben, wenn Sie Adrians Tutorial durchlaufen haben, sonst werden die Treiber nicht korrekt installiert.

Falls Sie einen Fehler erhalten wie: OpenCV-Fehler:Assertion fehlgeschlagen , können Sie versuchen, das Problem mit dem folgenden Befehl zu lösen:

sudo modprobe bcm2835-v4l2

Sobald Sie alle Treiber korrekt installiert haben, geben Sie den folgenden Python-Code in Ihre IDE ein:

import numpy as 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.flip(frame, -1) # Kamera vertikal spiegeln
gray =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
break
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 „Flip“-Befehlszeile.

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

Geben Sie zum Ausführen folgenden 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 stellten beim Versuch, die Kamera zu öffnen, Probleme fest (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.

Weitere Informationen zu OpenCV finden Sie in der folgenden Anleitung: loading -video-python-opencv-tutorial

Schritt 4:Gesichtserkennung

Die grundlegendste Aufgabe der Gesichtserkennung ist natürlich die „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 Classifier“

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 ist ein auf maschinellem Lernen basierender Ansatz, bei dem eine Kaskadenfunktion aus vielen positiven und negativen Bildern trainiert wird. Es wird dann verwendet, um Objekte in anderen Bildern zu erkennen.

Hier werden wir mit der Gesichtserkennung arbeiten. 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 sowohl mit einem Trainer als auch mit 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, lass uns einen Gesichtsdetektor mit OpenCV erstellen!

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

import numpy as 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) # set Height
während True:
ret, img =cap.read()
img =cv2.flip(img, –1 )
gray =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 ' zum 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 Skalierungsfaktor, Anzahl der Nachbarn und minimale Größe des erkannten Gesichts.

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

Wo,

• 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 Skalenpyramide zu erstellen.

• minNachbarn ist ein Parameter, der angibt, wie viele Nachbarn jedes Kandidatenrechteck haben sollte, um es beizubehalten. Eine höhere Zahl führt zu weniger falsch positiven Ergebnissen.

• minSize ist die minimale Rechteckgröße, die als Gesicht angesehen werden kann.

Die Funktion erkennt Gesichter auf dem Bild. Als nächstes müssen wir die Gesichter im Bild „markieren“, beispielsweise mit einem blauen Rechteck. 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 sich das Bild an.

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

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 die "Augenerkennung" oder sogar "Lächelnerkennung" hinzufügen. In diesen Fällen werden Sie die Klassifikatorfunktion und das Zeichnen von Rechtecken 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) viel Rechenleistung benötigt. Auf einem Desktop ist es einfacher, es auszuführen.

Beispiele

Auf meinem GitHub findest du weitere Beispiele:

• faceEyeDetection.py

• faceSmileDetection.py

• faceSmileEyeDetection.py

Und auf dem Bild seht ihr das Ergebnis.

Sie können auch der folgenden Anleitung folgen, um die Gesichtserkennung besser zu verstehen:

Haar Cascade Object Detection Face &Eye OpenCV Python Tutorial

Schritt 5:Datenerfassung

Zuallererst 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, die ein sehr umfassendes Tutorial mit Video entwickelt haben:

GESICHTSERKENNUNG – 3 Teile

Ich empfehle dir wirklich, dir beide Tutorials anzuschauen.

In diesem Sinne beginnen wir die erste Phase unseres Projekts. Was wir hier tun werden, beginnend mit dem letzten Schritt (Gesichtserkennung), erstellen wir einfach einen Datensatz, 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

Erstellen Sie als Nächstes ein Unterverzeichnis, in dem wir unsere Gesichtsproben speichern und nennen Sie es "Datensatz":

mkdir-Datensatz

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

import cv2
import os
cam =cv2.VideoCapture(0)
cam.set(3, 640) # setze video width
cam.set(4, 480) # set video height
face_detector =cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
# Geben Sie für jede Person eine numerische Gesichts-ID ein
face_id =input('\n Geben Sie die Benutzer-ID ein Ende drücken Sie ==> ')
print(“\n [INFO] Initialisieren der Gesichtserfassung. Schauen Sie in die Kamera und warten Sie …“)
# Initialisieren Sie die individuelle Stichprobengesichtszählung
count =0
while(True):
ret, img =cam.read()
img =cv2.flip(img, -1) # Videobild vertikal spiegeln
gray =cv2.cvtColor(img , cv2.COLOR_BGR2GRAY)
faces =face_detector.detectMultiScale(gray, 1.3, 5)
für (x,y,w,h) in Gesichtern:
cv2.rectangle(img, (x ,y), (x+w,y+h), (255,0,0), 2)
count +=1
# Speichern Sie das aufgenommene Bild im Datasets-Ordner
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) &0x ff # Drücken Sie 'ESC', um das Video zu beenden
if k ==27:
Pause
elif count>=30:# Nehmen Sie 30 Gesichtsproben und stoppen Sie das Video
Pause
# Mach ein bisschen Aufräumarbeiten
print(“\n [INFO] Programm beenden und Sachen aufräumen“)
cam.release()
cv2.destroyAllWindows()

Der Code ist dem Code, den wir zur 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 Ende 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

Beispielsweise für einen Benutzer mit einer face_id =1 sieht die vierte Beispieldatei im dataset/-Verzeichnis so aus:

User.1.4.jpg

wie auf dem 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 Recognizer „trainieren“. Dies geschieht direkt durch eine spezielle OpenCV-Funktion. Das Ergebnis ist eine .yml-Datei, die im Verzeichnis „trainer/“ gespeichert wird.

Lesen Sie mehr Details :Gesichtserkennung in Echtzeit:Ein End-to-End-Projekt