Gesichtserkennung mit OpenCV

Die Komplexität von Maschinen hat im Laufe der Jahre zugenommen und Computer sind keine Ausnahme. Computer haben der Menschheit geholfen, viele Probleme zu lösen und viele schwierige Aufgaben zu erledigen. Vorbei sind die Zeiten, in denen Computer nur einfache Rechenoperationen machten, Computer bestimmen heute die Welt.

Computer sind so komplex geworden, dass ihnen beigebracht wird, wie Menschen zu denken.
Ja!

Wir werden in diesem Artikel so etwas tun. Als Menschen ist es eine einfache Aufgabe, die Gesichter anderer Menschen zu erkennen, und trotz der Fähigkeiten der heutigen Computer ist es für den Computer nicht so einfach, also müssen wir ihn trainieren, dasselbe zu tun.

Viele Artikel, die Sie da draußen sehen würden, bleiben bei der einfachen Gesichtserkennung stehen, aber in diesem Artikel würde nicht nur die Gesichtserkennung, sondern auch die Gesichtserkennung behandelt.

Das heißt, wenn dem Computer zwei Bilder von mir präsentiert werden, würde er nicht nur erkennen, welcher Teil des Bildes mein Gesicht ist, sondern auch, dass ich diejenige auf beiden Bildern bin.

Zunächst müssen wir opencv auf unseren Maschinen installieren, was nur möglich ist, wenn Sie Python installiert haben. Die Installation von Python ist nicht das Ziel dieses Artikels. Wenn Sie es also noch nicht auf Ihrem Computer haben, können Sie Python von der Python-Website installieren.

Um Open CV zu installieren, können wir das mit dem pip-Befehl tun.

pip install opencv-python

Wir werden in diesem Artikel auch das numpy-Paket verwenden, das zusammen mit OpenCV mit dem obigen Befehl installiert werden sollte.

Wenn numpy nicht installiert wurde, können Sie dies einfach mit dem folgenden Befehl tun:

pip install numpy

Um zu bestätigen, dass Ihr OpenCV installiert ist, versuchen Sie beim Aktivieren der interaktiven Umgebung von Python, es zu importieren, indem Sie:

CV2 importieren import

Wenn keine Fehlermeldung angezeigt wird, können Sie fortfahren.

Um die Gesichtserkennung durchzuführen, würden wir drei Skripte schreiben. Einer zum Erstellen eines Datensatzes von Bildern, ein anderer zum Trainieren dieser Bilder und der letzte zum Erkennen der Gesichter basierend auf den Ergebnissen des Trainings, das der Computer durchläuft.

Wir bräuchten die Haarkaskade von Open CV. Diese Datei kann aus dem opencv-Verzeichnis abgerufen werden, das cv2/data/haarcascade_frontalface_default ist.xml auf meinem Rechner sollte es auch auf Ihrem Rechner sein. Kopieren Sie die Datei in den Ordner, in dem Sie die Gesichtserkennung durchführen möchten.

Kommen wir nun zur Sache.
Wir würden versuchen, unsere Webcam zu bekommen, um die Bilder zu bekommen, die für den Datensatz benötigt werden.

CV2 importieren import
vid_cam = cv2.Videoaufnahme(0)
face_detector = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
face_id = 1
zählen = 0
while(vid_cam.ist geöffnet()):
ret, image_frame = vid_cam.lesen()
grau = cv2.cvtColor(image_frame, cv2.COLOR_BGR2GRAY)
Gesichter = face_detector.DetectMultiScale(grau, 1.3, 5)
für (x,y,w,h) in Flächen:
cv2.Rechteck(Bildrahmen, (x,y), (x+w,y+h), (255,0,0), 2)
zählen += 1
cv2.imwrite("Datensatz/Benutzer." + str(face_id) + '.' + str(Anzahl) + ".jpg", grau[y:y+h,x:x+w])
cv2.imshow('frame', image_frame)
wenn cv2.waitKey(100) & 0xFF == ord('q'):
Unterbrechung
Elfenzahl>100:
Unterbrechung
vid_cam.Veröffentlichung()
cv2.zerstörenAllWindows()

Um zu erklären, was jede Codezeile tut:

CV2 importieren import

Hier ist der Befehl, der Python anweist, eine externe Bibliothek einzuschließen, die in diesem Code verwendet werden soll, in diesem Fall ist es Open CV.

vid_cam = cv2.Videoaufnahme(0)

Dieser Code ruft die importierte Open CV-Bibliothek auf, um mit der Aufnahme zu beginnen, und die Webcam wird an dieser Stelle gestartet. Wenn der Open CV Ihre Webcam nicht unterstützt, schlägt der Code hier fehl.

face_detector = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')

Damit wir die Bilderkennung durchführen können, wird dieser Code benötigt. Open CV verwendet die 'haarcascade_frontalface_default.xml' für die Kaskadenklassifizierung. Das resultierende Objekt wird dann in der face_detector-Variable gespeichert.

face_id = 1

Hier ist ein Fall, in dem die ID-Nummer des Gesichts festgelegt wird, sodass das erste Gesicht eine ID von 1 erhält.

zählen = 0

Wir werden ein paar Bilder aufnehmen, da Open CV Bilder trainieren muss, um Gesichter erkennen zu können. Die Zählvariable dient als Bildzählung.

while(vid_cam.ist geöffnet()):

Dadurch können die folgenden Vorgänge ausgeführt werden, sofern die Videokamera geöffnet ist. Die Methode isOpened() gibt True oder False zurück.

ret, image_frame = vid_cam.lesen()

Hier die vid_cam.read() schaut in die Videoaufnahme und erfasst dann den Frame, der in der Variablen image_frame gespeichert ist. Wenn die Operation erfolgreich ist, wird der boolesche Wert True zurückgegeben und in der Variablen ret gespeichert

grau = cv2.cvtColor(image_frame, cv2.COLOR_BGR2GRAY)

Die Methode cvtColor() wird verwendet, um den Bildrahmen in den gewünschten Farbtyp zu konvertieren. In diesem Fall haben wir es in Graustufen umgewandelt.

Gesichter = face_detector.DetectMultiScale(grau, 1.3, 5)

Dies prüft auf Rahmen unterschiedlicher Größe und versucht, sie maßstabsgetreu einzustellen. Dies wird auf die Variable angewendet, auf die die Haarkaskade angewendet wurde.

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

Hier durchlaufen wir die Flächen und ihre Dimensionen, wobei x und y für die Koordinaten und w und h für Breite bzw. Höhe stehen.

cv2.Rechteck(Bildrahmen, (x,y), (x+w,y+h), (255,0,0), 2)

Denken Sie daran, dass wir immer noch mit der Videokamera arbeiten, die Videokamera schneidet dann den benötigten Teil des Bildes gemäß den obigen Abmessungen zu.

zählen += 1

Sofort wird die Zählvariable, die als Zähler steht, inkrementiert.

cv2.imwrite("Datensatz/Benutzer." + str(face_id) + '.' + str(Anzahl) + ".jpg", grau[y:y+h,x:x+w])

Das zugeschnittene Bild wird mit dem Namen User(face_id) gespeichert.(Anzahl).jpg und in einen Ordner namens dataset.

cv2.imshow('frame', image_frame)

Nach dem Speichern stellt dieser Code sicher, dass das Bild als Videoframe mit einem Rechteck auf dem Gesicht der Person angezeigt wird, nachdem die Gesichtserkennung durchgeführt wurde.

wenn cv2.waitKey(100) & 0xFF == ord('q'):
Unterbrechung

Nach jedem Bild kann der Benutzer das Programm daran hindern, weitere Bilder aufzunehmen, was durch Drücken von 'q' auf der Tastatur für mindestens 100 ms erfolgen kann.

Elfenzahl>100:
Unterbrechung

Dieser Code verhindert, dass das Video in dem Moment funktioniert, in dem 100 Bilder aufgenommen wurden, unabhängig davon, ob der Benutzer mehr aufnehmen möchte oder nicht.

vid_cam.Veröffentlichung()

Hier wird die Webcam geschlossen und nicht nur vom Fotografieren abgehalten.

cv2.zerstörenAllWindows()

Dann sind alle Fenster, die OpenCV geöffnet hat, zerstört und der Code läuft zu Ende.

Nachdem wir damit fertig sind, können wir den Bilddatensatz trainieren:

cv2, os importieren
numpy als np importieren
aus PIL-Import Bild
Erkenner = cv2.Gesicht.createLBPHFaceRecognizer()
Detektor = cv2.CascadeClassifier("haarcascade_frontalface_default.xml");
def getImagesAndLabels(Pfad):
imagePaths = [os.Pfad.join(path,f) für f in os.listdir(Pfad)]
faceSamples=[]
ID = []
für imagePath in imagePaths:
PIL_img = Bild.open(imagePath).konvertieren('L')
img_numpy = np.Array(PIL_img,'uint8')
id = int(os.Pfad.split(imagePath)[-1].Teilt(".")[1])
Gesichter = Detektor.DetectMultiScale(img_numpy)
für (x,y,w,h) in Flächen:
faceSamples.anhängen(img_numpy[y:y+h,x:x+w])
ids.anhängen(id)
zurück faceSamples,ids
faces,ids = getImagesAndLabels('dataset')
Erkenner.train(Gesichter, np.Array (IDs))
Erkenner.speichern('trainer/trainer.yml')

Lassen Sie uns auch diesen Code erklären:

cv2, os importieren

Genau wie der andere Code importieren wir hier OpenCV und OS, die wir für den Dateipfad benötigen würden.

numpy als np importieren

Wir importieren auch die numpy-Bibliothek, die für die Matrixberechnung verwendet wird (eine Matrix ist nur eine Anordnung von Arrays).

aus PIL-Import Bild

Wir importieren die Python-Bildbibliothek und erhalten dann auch die Bildbibliothek aus diesem Paket.

Erkenner = cv2.Gesicht.createLBPHFaceRecognizer()

Dies bewirkt, dass die Methode createLBPHFaceRecognizer() auf cv2 angewendet wird.Gesichtsobjekt, würde dies die Erkennung von Gesichtern erleichtern, da wir keine eigenen Algorithmen entwickeln müssen.

Detektor = cv2.CascadeClassifier("haarcascade_frontalface_default.xml");

Wenn Sie das Tutorial verfolgt haben, wären Sie schon einmal darauf gestoßen. Es hilft bei der Gesichtserkennung mit dem "haarcascade_frontalface_default".xml“ für die Kaskadenklassifizierung.

def getImagesAndLabels(Pfad):

Jetzt beginnen wir mit dem eigentlichen Bildtraining, also erstellen wir eine Funktion.

imagePaths = [os.Pfad.join(path,f) für f in os.listdir(Pfad)]

Dieser Code checkt das aktuelle Verzeichnis der Datei ein und sucht nach den Bilddateien und fügt sie dann dieser Liste hinzu.

faceSamples=[]

Dadurch wird eine Liste von Beispielen initialisiert, die zu diesem Zeitpunkt leer ist, aber Gesichter würden hinzugefügt, während der Code ausgeführt wird.

ID = []

Initialisieren Sie eine Liste von IDs, die zunächst leer ist.

für imagePath in imagePaths:

Merken Sie sich den Code, der nach den Bilddateien im Verzeichnis gesucht hat? Ja? Jetzt werden wir jede dieser Dateien durchgehen und Operationen an ihnen ausführen.

PIL_img = Bild.open(imagePath).konvertieren('L')

Das erste, was wir mit dem Bild machen, ist es in Graustufen umzuwandeln, und dieser Code macht das.

img_numpy = np.Array(PIL_img,'uint8')

Das Graustufenbild ist nur eine Reihe von Zahlen an einer Stelle, also erstellen wir daraus ein numpy Array und weisen es einer Variablen zu.

id = int(os.Pfad.split(imagePath)[-1].Teilt(".")[1])

Wenn Sie sich an die Datei erinnern, die die Bilder abruft, erinnern Sie sich daran, dass wir die Dateien User(face_id) genannt haben.Anzahl.jpg. Hier teilen wir also die Namen mit dem „.” und dann extrahieren wir die face_id und weisen sie hier einer Variablen zu. Wir bräuchten den Ausweis zur Anerkennung.

Gesichter = Detektor.DetectMultiScale(img_numpy)

Aus dem numpy-Array versucht die Methode detectMultiScale(), die Gesichter anhand des Musters zu erkennen, das sie im numpy-Array findet. Dann weist es die Werte in der Gesichtsvariablen zu.

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

Hier durchlaufen wir die der Variablen zugewiesenen Werte. Die Werte hier sind die x- und y-Koordinaten, die wir als Ursprung nehmen könnten, und dann w und h für Breite bzw. Höhe.

faceSamples.anhängen(img_numpy[y:y+h,x:x+w])

Vorhin haben wir eine Liste mit Gesichtsproben erstellt, aber sie war leer. Hier können wir dieser Liste Gesichter hinzufügen, und wir fügen y zu h hinzu, um die beiden Werte der y-Koordinaten zu erhalten, und dasselbe wird mit x . gemacht.

ids.anhängen(id)

Wir haben jetzt ein Gesicht in der Gesichtsprobenliste, also erhalten wir seine ID und fügen es auch an die IDs-Liste an.

zurück faceSamples,ids

Dann geben wir nach all dem die Liste der Gesichtsproben und die Liste der IDs zurück.

faces,ids = getImagesAndLabels('dataset')

Denken Sie daran, dass getImagesAndLabels() nur eine Funktion ist. Also rufen wir hier die Funktion auf und die Rückgabewerte werden in den Faces- und IDs-Variablen gespeichert saved.

Erkenner.train(Gesichter, np.Array (IDs))

Hier findet das eigentliche Training statt. Wir haben die Methode createLBPHFaceRecognizer() vor einiger Zeit angewendet und einer Erkennungsvariablen zugewiesen. Es ist Trainingszeit!

Erkenner.speichern('trainer/trainer.yml')

Nach dem Training können wir die Ergebnisse aus dem Training speichern.
Nach dem Ausführen des Codes wird eine Datei namens trainer erstellt.yml, die dann vom Gesichtserkennungscode verwendet wird.

Hier ist der Gesichtserkennungscode:

CV2 importieren import
numpy als np importieren
Erkenner = cv2.Gesicht.createLBPHFaceRecognizer()
Erkenner.Belastung('Trainer/Trainer.yml')
cascadePath = "haarcascade_frontalface_default.xml"
faceCascade = cv2.CascadeClassifier(cascadePath)
Schriftart = cv2.FONT_HERSHEY_SIMPLEX
Nocke = CV2.Videoaufnahme(0)
während Wahr:
ret, im =cam.lesen()
grau = cv2.cvtColor(im,cv2.COLOR_BGR2GRAY)
Gesichter = faceCascade.DetectMultiScale(grau, 1.2,5)
for(x,y,w,h) in Gesichtern:
cv2.Rechteck(im, (x-20,y-20), (x+w+20,y+h+20), (0,255,0), 4)
ID = Erkenner.vorhersagen(grau[y:y+h,x:x+w])
if(Id == 1):
Id = "Nazmi"
sonst:
ID = "Unbekannt"
cv2.Rechteck(im, (x-22,y-90), (x+w+22, y-22), (0,255,0), -1)
cv2.putText(im, str(Id), (x,y-40), Schriftart, 2, (255,255,255), 3)
cv2.imshow('im',im)
wenn cv2.waitKey(10) & 0xFF == ord('q'):
Unterbrechung
Nocken.Veröffentlichung()
cv2.zerstörenAllWindows()

Wenn Sie den Artikel von Anfang an verfolgt haben, haben wir dies bereits getan. Wenn Sie es nicht freundlicherweise getan haben.

Erkenner.Belastung('Trainer/Trainer.yml')

Denken Sie daran, dass wir die Erkennung trainiert und eine Datei gespeichert haben? Ja? Wir laden diese Datei jetzt.

cascadePath = "haarcascade_frontalface_default.xml"

Wir würden mit der haarcascade-Datei arbeiten, und hier haben wir den Dateinamen einer Variablen zugewiesen.

# Klassifikator aus vorgefertigtem Modell erstellen
faceCascade = cv2.CascadeClassifier(cascadePath)

Hier können wir die Kaskadenklassifizierung in der Haarkaskade-Datei durchführen.

Schriftart = cv2.FONT_HERSHEY_SIMPLEX

Wir legen die Schriftart fest, die verwendet wird, wenn der Code das Gesicht in einem Bild erkennt und den Namen anzeigt.

Nocke = CV2.Videoaufnahme(0)

Wir waren schon einmal hier, aber dieses Mal ist es an der Zeit, die Gesichter zu erkennen. Wenn Sie nicht wissen, was dieser Code bewirkt, wird die Webcam gestartet.

während Wahr:
ret, im =cam.lesen()
grau = cv2.cvtColor(im,cv2.COLOR_BGR2GRAY)
Gesichter = faceCascade.DetectMultiScale(grau, 1.2,5)
for(x,y,w,h) in Gesichtern:

All dies wurde schon einmal gemacht, bitte überprüfen Sie den Code, der zum Speichern von Bildern verwendet wurde, wenn Sie nicht wissen, was der Code tut.

cv2.Rechteck(im, (x-20,y-20), (x+w+20,y+h+20), (0,255,0), 4)

Dies hilft der Webcam, zu erkennen, wo sich die Gesichter befinden, und platziert ein Rechteck, um ein Gesicht anzuzeigen.

ID = Erkenner.vorhersagen(grau[y:y+h,x:x+w])

Wir haben die Zugdatei bereits in den Recognizer geladen, damit er das Gesicht jetzt erkennen kann.

if(Id == 1):
Id = "Ich selbst"
sonst:
ID = "Unbekannt"

Nachdem versucht wurde, das Gesicht zu erkennen, überprüft es die ID und sieht, ob sie existiert. Hier wäre der Wert der ID der Name desjenigen, der beim Erstellen des Bilddatensatzes mit einer solchen ID konfrontiert war.

cv2.Rechteck(im, (x-22,y-90), (x+w+22, y-22), (0,255,0), -1)
cv2.putText(im, str(Id), (x,y-40), Schriftart, 2, (255,255,255), 3)

Der Code zeichnet nach dem Finden des Besitzers der ID ein Rechteck um das Gesicht und platziert den Namen des Besitzers des Gesichts. Gesicht erkannt!

cv2.imshow('im',im)

Hier wird der Videorahmen mit dem begrenzten Rechteck angezeigt.

wenn cv2.waitKey(10) & 0xFF == ord('q'):
Unterbrechung
Nocken.Veröffentlichung()
cv2.zerstörenAllWindows()

Wenn Sie fertig sind, können Sie das Programm stoppen, indem Sie die Taste 'q' drücken, und es stoppt die Webcam und schließt sie.

Da haben Sie es, Ihre Webcam kann jetzt Gesichter erkennen und Sie können sie verwenden, wann immer Sie möchten. Neben der Verwendung der Webcam können Sie auch ein Bild laden, was jedoch einige andere Schritte als die in diesem Artikel beschriebenen erfordert.

Sie finden den verwendeten Quellcode in seinem Github-Repository. Twittern Sie uns auch, wenn Sie Kommentare haben oder über @linuxhint diskutieren möchten