Gesichtserkennung mit OpenCV

Die Komplexität von Maschinen hat im Laufe der Jahre zugenommen und Computer sind keine Ausnahme. Computer haben die Menschheit geholfen, viele Probleme zu lösen und viele schwierige Aufgaben zu erledigen. Vorbei sind die Zeiten, in denen alle Computer einfache arithmetische Operationen waren. Computer fahren jetzt die Welt.

Computer sind so komplex geworden, dass sie geschult werden, um wie Menschen zu denken.
Ja!

Wir werden in diesem Artikel etwas von dieser Art tun. Als Menschen ist das Erkennen der Gesichter anderer Menschen eine einfache Aufgabe. Trotz der Fähigkeiten der heutigen Computer ist es für den Computer nicht so einfach.

Viele Artikel, die Sie da draußen sehen würden, können bei einfacher Gesichtserkennung aufhören, aber in diesem Artikel würde nicht nur die Gesichtserkennung, sondern auch die Gesichtserkennung abdecken.

Dies bedeutet, wenn der Computer mit zwei Bildern von mir präsentiert wird, würde er nicht nur erkennen, welcher Teil des Bildes mein Gesicht ist, es würde auch erkennen, dass ich auch derjenige in beiden Bildern bin.

Zunächst müssten wir zuerst OpenCV auf unseren Maschinen installieren, was nur dann erfolgen kann, wenn Sie Python installiert haben. Die Installation von Python ist nicht das Ziel dieses Artikels. Wenn Sie ihn also noch nicht auf Ihrem Computer haben, können Sie Python von der Python -Website installieren.

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

PIP Installieren Sie OpenCV-Python

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

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

PIP Installieren Sie Numpy

Um zu bestätigen, dass Ihr OpenCV installiert ist, versuchen Sie, sie mit der interaktiven Umgebung von Python zu aktivieren. Versuchen Sie, sie mit:

CV2 importieren

Wenn Sie keinen Fehler erhalten, können Sie fortfahren.

Um die Gesichtserkennung durchzuführen, schreiben wir drei Skripte. Eine, um einen Datensatz mit Bildern zu erstellen, ein anderer, um diese Bilder zu trainieren und dann die letzte, die die Gesichter basierend auf den Ergebnissen des Trainings erkennen, den der Computer durchläuft.

Wir würden die von Open CV bereitgestellte Haar -Kaskade benötigen. Diese Datei kann aus dem OpenCV -Verzeichnis erhalten werden, das CV2/Data/haarcascade_frontalface_default ist.XML auf meiner Maschine sollte es auch auf Ihrer Maschine gleich sein. Kopieren Sie die Datei in den Ordner, in dem Sie die Gesichtserkennung durchführen möchten.

Jetzt gehen wir mitten in die Dinge ein.
Wir würden versuchen, unsere Webcam dazu zu bringen, die Bilder zu erhalten, die für den Datensatz benötigt werden.

CV2 importieren
VID_CAM = CV2.Videokapiture (0)
face_detektor = cv2.CascadeClassifier ('haarcascade_frontalface_default.xml ')
face_id = 1
count = 0
while (vid_cam.ist geöffnet()):
ret, image_frame = vid_cam.lesen()
grau = cv2.cvtcolor (Image_frame, CV2.Color_bgr2gray)
faces = face_detector.DECTECTMULTISCALE (GRAU, 1.3, 5)
für (x, y, w, h) in Gesichtern:
CV2.Rechteck (Image_Frame, (x, y), (x+w, y+h), (255,0,0), 2)
zählen += 1
CV2.Imwrite ("Datensatz/Benutzer." + str (face_id) + '.' + str (count) + ".JPG ", Grau [y: y+h, x: x+w])
CV2.IMshow ('Frame', Image_frame)
Wenn CV2.WaitKey (100) & 0xff == ord ('q'):
brechen
Elif Count> 100:
brechen
VID_CAM.freigeben()
CV2.zerstörerndenwindows ()

Um zu erklären, was jede Codezeile tut:

CV2 importieren

Hier ist der Befehl, der Python aufweist.

VID_CAM = CV2.Videokapiture (0)

Dieser Code fordert die importierte Open CV -Bibliothek auf, um mit der Erfassung zu beginnen, und die Webcam wird an dieser Stelle initiiert. Wenn der offene Lebenslauf Ihre Webcam nicht unterstützt, fällt hier der Code fehl.

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

Damit wir die Bilderkennung durchführen können, ist dieser Code erforderlich. Öffnen Sie den Lebenslauf für die 'haarcascade_frontalface_default.XML 'für die Kaskadenklassifizierung. Das resultierende Objekt wird dann in der Variablen face_detektor 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.

count = 0

Wir werden ein paar Bilder aufnehmen, da offener Lebenslauf Bilder trainieren muss, um Gesichter zu erkennen. Die Zählvariable dient als Bildanzahl.

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

Auf diese Weise können die folgenden Vorgänge fortgesetzt werden, sofern die Videokamera geöffnet ist. Die iopened () -Methode gibt wahr oder falsch zurück.

ret, image_frame = vid_cam.lesen()

Hier die vid_cam.Read () untersucht die Videoaufnahme und erfasst dann den Rahmen, der in der Variablen image_frame gespeichert ist. Wenn der Operation erfolgreich ist, wird der boolesche True -True in der Ret -Variablen zurückgegeben und gespeichert

grau = cv2.cvtcolor (Image_frame, CV2.Color_bgr2gray)

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

faces = face_detector.DECTECTMULTISCALE (GRAU, 1.3, 5)

Dies prüft nach Rahmen verschiedener Größen und versucht, sie auf Skalierung einzustellen. Dies wird auf der Variablen angewendet, auf die die Haar -Kaskade angewendet wurde.

für (x, y, w, h) in Gesichtern:

Hier schauen wir uns durch die Gesichter und ihre Dimensionen, wobei x und y für die Koordinaten stehen und W und H für Breite und Höhe stehen.

CV2.Rechteck (Image_Frame, (x, y), (x+w, y+h), (255,0,0), 2)

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

zählen += 1

Sofort erfolgt die Zählvariable, die als Zähler steht und dann in Erhöhungen steigt.

CV2.Imwrite ("Datensatz/Benutzer." + str (face_id) + '.' + str (count) + ".JPG ", Grau [y: y+h, x: x+w])

Das verkaufte Bild ist das mit dem Namen des Namens Benutzer gespeicherte (face_id).(zählen).JPG und in einen Ordner namens Dataset einfügen.

CV2.IMshow ('Frame', Image_frame)

Nach dem Speichern stellt dieser Code sicher.

Wenn CV2.WaitKey (100) & 0xff == ord ('q'):
brechen

Nach jedem Bild darf der Benutzer das Programm daran hindern.

Elif Count> 100:
brechen

Dieser Code verhindern, dass das Video davon abhält, dass 100 Bilder aufgenommen wurden, unabhängig davon, ob der Benutzer mehr aufnehmen möchte oder nicht.

VID_CAM.freigeben()

Hier ist die Web -Cam geschlossen und nicht nur daran gehindert, Fotos zu machen.

CV2.zerstörerndenwindows ()

Dann wurden alle Windows OpenCV geöffnet, und der Code wird zu Schlussfolgerung ausgeführt.

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

CV2 importieren, Betriebssystem
Numph als NP importieren
vom PIL -Importbild
Erkennung = CV2.Gesicht.createlbPhfaCerecognizer ()
Detektor = CV2.CascadeClassifier ("haarcascade_frontalface_default.xml ");
Def getImagesandlabels (Pfad):
ImagePaths = [OS.Weg.Führen Sie (Pfad, f) für F in OS.ListDir (Pfad)]
facesAmples = []
ids = []
Für ImagePath in ImagePaths:
Pil_img = Bild.offen (ImagePath).konvertieren ('l')
img_numpy = np.Array (pil_img, 'uint8')
id = int (os.Weg.Split (ImagePath) [-1].Teilt(".") [1])
Gesichter = Detektor.DECTECTMULTISCALE (IMG_NUMPY)
für (x, y, w, h) in Gesichtern:
Faces -Samples.append (img_numpy [y: y+h, x: x+w])
IDS.anhängen (ID)
FaceSampules, IDS zurückkehren
Gesichter, ids = getImagesandlabels ('Dataset')
Erkenntnis.Zug (Gesichter, NP.Array (IDS))
Erkenntnis.Speichern ('Trainer/Trainer.yml ')

Lassen Sie uns diesen Code auch erklären:

CV2 importieren, Betriebssystem

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

Numph als NP importieren

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

vom PIL -Importbild

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

Erkennung = CV2.Gesicht.createlbPhfaCerecognizer ()

Dies ist, die Methode createLbPhfaCerecognizer () auf die CV2 anzuwenden.Das Gesichtsobjekt würde dazu beitragen, die Anerkennung von Gesichtern zu erleichtern, da wir uns nicht mit unseren eigenen Algorithmen einfallen lassen müssen.

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

Wenn Sie das Tutorial verfolgt hätten, wären Sie schon einmal darauf gestoßen. Es hilft bei der Gesichtserkennung mit der „haarcascade_frontalface_default.XML ”für die Kaskadenklassifizierung.

Def getImagesandlabels (Pfad):

Jetzt stehen wir kurz vor dem richtigen Bildtraining, also erstellen wir eine Funktion.

ImagePaths = [OS.Weg.Führen Sie (Pfad, f) für F in OS.ListDir (Pfad)]

Dieser Code überprüft in das aktuelle Verzeichnis der Datei und überprüft die Bilddateien, und fügt sie dieser Liste hinzu.

facesAmples = []

Dies initialisiert eine Liste von Beispielen, sie ist an diesem Punkt leer, aber Gesichter würden hinzugefügt, wenn der Code ausgeführt wird.

ids = []

Initialisieren Sie eine Liste von IDs, die ursprünglich leer sind.

Für ImagePath in ImagePaths:

Denken Sie an den Code, der auf die Bilddateien im Verzeichnis geprüft wurde? Ja? Jetzt werden wir jede dieser Dateien durchlaufen und Operationen auf sie ausführen.

Pil_img = Bild.offen (ImagePath).konvertieren ('l')

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

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

Das grauSkalierte Bild ist nur eine Reihe von Zahlen an einem Ort, daher erstellen wir ein numpy Array aus ihnen und weisen es einer Variablen zu.

id = int (os.Weg.Split (ImagePath) [-1].Teilt(".") [1])

Wenn Sie sich an die Datei erinnern, die die Bilder erhält, erinnern Sie sich daran, dass wir den Dateienbenutzer benannt haben (face_id).zählen.JPG. Hier teilen wir die Namen mit dem “.Und dann extrahieren wir das face_id und weisen hier eine Variable zu. Wir würden die ID für die Anerkennung brauchen.

Gesichter = Detektor.DECTECTMULTISCALE (IMG_NUMPY)

Aus dem Numpy -Array wird die Methode von DetectMultiscale () versuchen, die Gesichter aus dem Muster zu erkennen, das sie im Numpy -Array findet. Dann weist es die Werte in der Variablen der Gesichter zu.

für (x, y, w, h) in Gesichtern:

Hier durchlaufen wir die Werte, die der Variablen zugeordnet sind. Die Werte hier sind die X- und Y -Koordinaten, die wir als Ursprung einnehmen könnten, und dann w und h stehen für Breite und Höhe.

Faces -Samples.append (img_numpy [y: y+h, x: x+w])

Früher haben wir eine Liste von Gesichtsmuster erstellt, aber sie war leer. Hier können wir dieser Liste Gesichter hinzufügen, und wir fügen das y zu h hinzu, um die beiden Werte der Y -Koordinaten zu erhalten, und gleich wird X erfolgt.

IDS.anhängen (ID)

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

FaceSampules, IDS zurückkehren

Nach allem geben wir die Liste der Gesichtsmuster und die Liste der IDs zurück.

Gesichter, ids = getImagesandlabels ('Dataset')

Denken Sie daran, dass GetImagesandLabels () nur eine Funktion ist. Deshalb können wir die Funktion hier aufrufen, und die Rückgabeteile werden in den Variablen von Gesichtern und IDs gespeichert.

Erkenntnis.Zug (Gesichter, NP.Array (IDS))

Hier geschieht das eigentliche Training. Wir haben die Methode createLbPhfaCerecognizer () irgendwann früher angewendet und einer Erkennungsvariablen zugeordnet. Es ist Trainingszeit!

Erkenntnis.Speichern ('Trainer/Trainer.yml ')

Nach dem Training können wir die Ergebnisse vor dem Training speichern.
Nach dem Ausführen des Codes erstellt er eine Datei namens Trainer.YML, das dann vom Gesichtserkennungscode verwendet wird.

Hier ist der Gesichtserkennungscode:

CV2 importieren
Numph als NP importieren
Erkennung = CV2.Gesicht.createlbPhfaCerecognizer ()
Erkenntnis.Laden ('Trainer/Trainer.yml ')
Cascadepath = "HAARCASCADE_FRONTALFACE_DEFAULT.XML "
FACECASCADE = CV2.Cascadeklassifier (Cascadepath)
Schrift = CV2.FONT_HERSHEY_Simplex
cam = cv2.Videokapiture (0)
während wahr:
ret, im = cam.lesen()
grau = cv2.CVTColor (IM, CV2.Color_bgr2gray)
Gesichter = FaceCascade.DECTECTMULTISCALE (GRAU, 1.2,5)
für (x, y, w, h) in Gesichtern:
CV2.Rechteck (IM, (x-20, y-20), (x+w+20, y+h+20), (0,255,0), 4), 4)
ID = Erkenner.Predict (grau [y: y+h, x: x+w])
if (id == 1):
Id = "nazmi"
anders:
Id = "unbekannt"
CV2.Rechteck (IM, (x-22, y-90), (x+w+22, y-22), (0,255,0), -1), -1)
CV2.PutText (IM, Str (ID), (X, Y-40), Schriftart, 2, (255.255.255), 3), 3)
CV2.IMshow ('IM', im)
Wenn CV2.WaitKey (10) & 0xff == ord ('q'):
brechen
Nocken.freigeben()
CV2.zerstörerndenwindows ()

Wenn Sie den Artikel von Anfang an verfolgt haben, haben wir dies schon einmal getan. Wenn Sie nicht freundlicherweise tun.

Erkenntnis.Laden ('Trainer/Trainer.yml ')

Denken Sie daran, wir haben den Erkenner trainiert und eine Datei gespeichert? Ja? Wir laden diese Datei jetzt.

Cascadepath = "HAARCASCADE_FRONTALFACE_DEFAULT.XML "

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

# Klassifizierer aus dem vorgebauten Modell erstellen
FACECASCADE = CV2.Cascadeklassifier (Cascadepath)

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

Schrift = CV2.FONT_HERSHEY_Simplex

Wir setzen den Schriftart, der verwendet wird, wenn der Code das Gesicht in einem Bild erkennt, und zeigt den Namen an.

cam = cv2.Videokapiture (0)

Wir waren schon einmal hier, aber diesmal ist es Zeit, die Gesichter zu erkennen. Wenn Sie nicht wissen, was dieser Code tut, wird die Webcam gestartet.

während wahr:
ret, im = cam.lesen()
grau = cv2.CVTColor (IM, CV2.Color_bgr2gray)
Gesichter = FaceCascade.DECTECTMULTISCALE (GRAU, 1.2,5)
für (x, y, w, h) in Gesichtern:

All dies wurde bereits getan. Überprüfen Sie bitte den Code, mit dem Sie Bilder speichern, 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), 4)

Dies hilft der Webcam, zu erkennen, wo sich die Gesichter befinden.

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

Wir haben Allerady die Zugdatei in den Erkenner geladen, sodass es jetzt das Gesicht erkennen kann.

if (id == 1):
Id = "ich" "
anders:
Id = "unbekannt"

Nachdem er versucht hat zu erkennen, was es ist, überprüft es die ID und sieht, ob es existiert. Hier würde der Wert der ID der Name desjenigen sein, der das Besitz der ID im Besitz hat, wenn der Bilddatensatz erstellt wurde.

CV2.Rechteck (IM, (x-22, y-90), (x+w+22, y-22), (0,255,0), -1), -1)
CV2.PutText (IM, Str (ID), (X, Y-40), Schriftart, 2, (255.255.255), 3), 3)

Der Code, nachdem er den Eigentümer der ID gefunden hat, zeichnet ein Rechteck um das Gesicht und legt den Namen des Besitzers des Gesichts auf. Gesicht erkannt!

CV2.IMshow ('IM', im)

Hier wird der Videobrahmen mit dem begrenzten Rechteck angezeigt.

Wenn CV2.WaitKey (10) & 0xff == ord ('q'):
brechen
Nocken.freigeben()
CV2.zerstörerndenwindows ()

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

Dort haben Sie es, Ihre Webcam kann jetzt Gesichter erkennen und Sie können ihn verwenden, wann immer Sie möchten. Mit der Webcam können Sie auch ein Bild laden. Dies erfordert jedoch einige andere Schritte als die in diesem Artikel durchgeführten.