OpenCV-Gesichtserkennung mit dem Haar Cascade Classifier

In dieser Demonstration lernen wir die Grundlagen der Gesichtserkennung mit Hilfe von haarfunktionsbasierten Cascade-Klassifikatoren kennen und lernen, wie Gesichter aus einem Bild und Video in OpenCV erkannt werden.

Erstellen Sie ein Gesichtserkennungsprojekt mit dem Haar Cascade Classifier in OpenCV

Die Objekterkennung unter Verwendung der merkmalsbasierten Kaskadenklassifikatoren von Haar ist eine effektive Objekterkennungsmethode, die von Paul Viola und Michael Jones in ihrem Team vorgeschlagen wurde. Der funktionsbasierte Kaskaden-Klassifikator von Haar ist ein auf maschinellem Lernen basierender Ansatz, bei dem eine Kaskadenfunktion für viele positive und negative Bilder trainiert wird.

Was sind also diese positiven und negativen Bilder? Ein Klassifikator wird mit einigen hundert Beispielansichten eines bestimmten Objekts trainiert, das ein Gesicht oder ein Auto oder irgendein anderes Objekt sein kann, das als Positiv bezeichnet wird.

Wenn Sie beispielsweise ein Gesicht erkennen möchten, müssen Sie Ihren Klassifikator mit der Anzahl der Bilder trainieren, die Gesichter enthalten. Dann nennt man es die positiven Bilder.

In einem anderen Fall, wenn Sie das Gesicht erkennen möchten und das Bild das Gesicht nicht enthält, wird es als Negativbild bezeichnet.

Nachdem ein Klassifikator trainiert wurde, kann er auf einen interessierenden Bereich in einem Eingabebild angewendet werden. Die Ausgabe des Klassifizierers ist eine 1, wenn der Bereich wahrscheinlich das Objekt zeigt; andernfalls ist es 0.

Mal sehen, wie wir die Haar Cascade-Erkennung in OpenCV verwenden können.

OpenCV wird mit einem Trainer sowie einem Detektor geliefert. Wenn Sie Ihren Klassifikator für ein beliebiges Objekt wie eine Uhr, ein Auto oder irgendetwas trainieren möchten, können Sie diesen Klassifikator verwenden.

Wir finden einige trainierte Klassifikator-XML-Dateien auf der OpenCV-GitHub-Seite. In diesem Repository sind viele trainierte Klassifikatoren verfügbar.

Sie müssen nur diese hervorgehobene Datei öffnen und sie dann herunterladen, indem Sie auf die RAW-Symbolschaltfläche klicken. Wenn es geöffnet wird, können Sie mit der rechten Maustaste darauf klicken und es auf Ihrem Computer speichern.

Lassen Sie uns den Code-Editor öffnen und unsere Klassifikatoren definieren.

Es gibt eine Methode namens CascadeClassifier(), wo wir unseren Classifier-Pfad angeben können. Nachdem wir den Klassifikator definiert haben, lesen wir das Bild.

F_C = cv2.CascadeClassifier("haarcascade_frontalface_default.xml")

Da dieser Klassifikator mit den Graustufenbildern arbeitet, müssen wir unser Bild in ein Graustufenbild umwandeln. Es wird wirklich einfach sein, die Bildkonvertierung zu implementieren.

IMG = cv2.imread("inp.png")
G_scale = cv2.cvtColor(IMG, cv2.COLOR_BGR2GRAY)

Der nächste Schritt besteht darin, die Gesichter in diesem Bild zu erkennen; Dazu deklarieren wir eine Variable namens Faces. Wir rufen die Methode detectMultiScale() auf, die drei Parameter benötigt.

Das erste ist das Graustufenbild, und das zweite Argument, das wir verwenden werden, ist der Skalierungsfaktor, der verwendet wird, um anzugeben, wie stark die Bildgröße bei jeder Bildskalierung reduziert wird. Der nächste ist der Parameter min Neighbours, der angibt, wie viele Nachbarn bei jedem Kandidatenrechteck es behalten müssen.

Faces = F_C.detectMultiScale(G_scale, 1.1, 4)

Der letzte Schritt besteht darin, alle erkannten Gesichter zu durchlaufen und dann ein Rechteck zu zeichnen. Diese Gesichter-Variable ist der Vektor des Rechtecks, wobei jedes Rechteck ein erkanntes Objekt enthält, und in unserem Fall ist es das erkannte Gesicht.

Wir erhalten den Parameter (x,y,w,h) aus dem Faces-Objekt. Dies sind Werte des Rechtecks ​​des Objekts.

Während wir die Koordinaten erhalten, zeichnen wir das Rechteck mit der Methode rectangle().

Es braucht ein paar Parameter. Der erste ist ein Bild, der zweite sind die Punkte (x,y), die wir mit dem Faces-Vektor erhalten haben, und der nächste Parameter ist der zweite Punkt des Rechtecks.

Die nächsten beiden Parameter sind die Farbe und die Dicke.

import cv2

F_C = cv2.CascadeClassifier("haarcascade_frontalface_default.xml")

IMG = cv2.imread("inp.png")
G_scale = cv2.cvtColor(IMG, cv2.COLOR_BGR2GRAY)
Faces = F_C.detectMultiScale(G_scale, 1.1, 4)

for (x, y, w, h) in Faces:
    cv2.rectangle(IMG, (x, y), (x + w, y + h), (255, 0, 0), 3)

cv2.imshow("IMG", IMG)

cv2.waitKey()

Jetzt können wir sehen, dass das Gesicht in einem Bild erkannt wird.

Lassen Sie uns versuchen, das Gesicht in einem Video zu erkennen, damit dies kein anderer Ansatz ist. Wir müssen diesen Ansatz nur auf jeden Frame anwenden, also verwenden wir anstelle des Lesebilds die Methode VideoCapture(), um das Video aufzunehmen.

Um die Frames aufzunehmen, müssen wir eine Video-Variable definieren und sie gleich VideoCapture() machen und eine mp4-Datei bereitstellen. Wenn Sie die Kamera haben, können Sie sie 0 bereitstellen.

Jetzt schließen wir den gesamten obigen Code in eine while-Schleife ein, und für die while-Schleife definieren wir die Methode isOpened(). Wenn diese Methode einen wahren Wert zurückgibt, fährt das Programm mit dem Lesen des Rahmens fort; wir sollen Video.read() aufrufen, was bedeutet, dass wir jeden Frame lesen.

Wir definieren eine Bedingung, wenn jemand die Taste q drückt, dann bricht das Programm aus der while-Schleife aus. Endlich, außerhalb unserer while-Schleife, werden wir unser Video veröffentlichen.

import cv2

F_C = cv2.CascadeClassifier("haarcascade_frontalface_default.xml")

Video = cv2.VideoCapture("inp.mp4")

while Video.isOpened():
    _, IMG = Video.read()

    G_scale = cv2.cvtColor(IMG, cv2.COLOR_BGR2GRAY)
    Faces = F_C.detectMultiScale(G_scale, 1.1, 4)

    for (x, y, w, h) in Faces:
        cv2.rectangle(IMG, (x, y), (x + w, y + h), (255, 0, 0), 3)

    cv2.imshow("Window", IMG)
    K = cv2.waitKey(1)
    if K & 0xFF == ord("q"):
        break

Video.release()

In diesem Video können wir die erkannten Gesichter in Echtzeit sehen.