[PYTHON] Versuchen Sie die Gesichtserkennung in Echtzeit mit einer Webkamera

Einführung

Ich habe eine Software namens motion auf Raspberry PI installiert und sie als Überwachungskamera verwendet, um zu identifizieren, wer die Person auf dem Bild ist, aber sie ist etwas unbefriedigend, da sie nur anhand des gespeicherten Standbilds identifiziert wird. Um diese Zeit.

Da es eine große Sache war, fragte ich mich, ob ich etwas tun könnte, indem ich das Video in Echtzeit verarbeite und Informationen sammle. Da es jedoch einen Artikel gab, der verwandt zu sein scheint, habe ich ein Skript erstellt, um das Gesicht in Echtzeit zu erkennen, während ich darauf Bezug nahm.

Versuchen Sie, Webkamera- / Videokamera-Videos in Echtzeit mit OpenCV zu konvertieren

OpenCV-Installation

Dies ist Miso. Informationen zur Installation finden Sie im folgenden Artikel.

Verfahren zum schnellen Erstellen einer Deep-Learning-Umgebung auf einem Mac mit TensorFlow und OpenCV

Kopieren Sie außerdem den für die Gesichtserkennung verwendeten Klassifizierer mit dem folgenden Befehl in den Arbeitsordner.

$ cp /usr/local/share/OpenCV/haarcascades/haarcascade_frontalface_alt2.xml ./

Ein Skript erstellen

Das auf der Referenzseite veröffentlichte Skript wurde wie folgt geändert.

sebcam.py

import cv2

if __name__ == '__main__':
    #Konstante Definition
    ESC_KEY = 27     #Esc-Taste
    INTERVAL= 33     #Wartezeit
    FRAME_RATE = 30  # fps

    ORG_WINDOW_NAME = "org"
    GAUSSIAN_WINDOW_NAME = "gaussian"

    DEVICE_ID = 0

    #Bezeichnung des Klassifikators
    cascade_file = "haarcascade_frontalface_alt2.xml"
    cascade = cv2.CascadeClassifier(cascade_file)
    
    #Kamerabilderfassung
    cap = cv2.VideoCapture(DEVICE_ID)

    #Laden des ersten Frames
    end_flag, c_frame = cap.read()
    height, width, channels = c_frame.shape

    #Fenstervorbereitung
    cv2.namedWindow(ORG_WINDOW_NAME)
    cv2.namedWindow(GAUSSIAN_WINDOW_NAME)

    #Konvertierungsverarbeitungsschleife
    while end_flag == True:

        #Bildaufnahme und Gesichtserkennung
        img = c_frame
        img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
        face_list = cascade.detectMultiScale(img_gray, minSize=(100, 100))
        
        #Markieren Sie das erkannte Gesicht
        for (x, y, w, h) in face_list:
            color = (0, 0, 225)
            pen_w = 3
            cv2.rectangle(img_gray, (x, y), (x+w, y+h), color, thickness = pen_w)
        
        #Rahmenanzeige
        cv2.imshow(ORG_WINDOW_NAME, c_frame)
        cv2.imshow(GAUSSIAN_WINDOW_NAME, img_gray)

        #Beenden Sie mit der Esc-Taste
        key = cv2.waitKey(INTERVAL)
        if key == ESC_KEY:
            break

        #Lesen Sie den nächsten Frame
        end_flag, c_frame = cap.read()

    #Verarbeitung beenden
    cv2.destroyAllWindows()
    cap.release()

Funktionsprüfung

Wenn Sie den folgenden Befehl ausführen, werden zwei Fenster angezeigt, und Sie sollten das Originalbild und die Graustufen mit einem auf dem Gesicht gezeichneten Quadrat sehen.

python

$ python sebcam.py

Es wurde gemacht (^ - ^) /

Bonus (optischer Fluss)

Es gab auch ein Beispiel, das ein in Echtzeit erkanntes Objekt verfolgt, also habe ich es versucht.

Zeichnen Sie den optischen Fluss in Echtzeit mit OpenCV (Shi-Tomasi-Methode, Lucas-Kanade-Methode)

Da die Video-Lesequelle des Referenzziels eine Videodatei war, habe ich diese in eine Webkamera geändert. Und wenn die erkannten Merkmalspunkte verschwinden, wird sie geändert, um erneut erkannt zu werden.

LucasKande.py

import numpy as np
import cv2

DEVICE_ID = 0
cap = cv2.VideoCapture(DEVICE_ID)

# Shi-Tomasi-Eckenerkennungsparameter
feature_params = dict( maxCorners = 100,
                       qualityLevel = 0.3,
                       minDistance = 7,
                       blockSize = 7 )

# Lucas-Parameter der Kanade-Methode
lk_params = dict( winSize  = (15,15),
                  maxLevel = 2,
                  criteria = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 0.03))

#Generieren Sie 100 Farben nach dem Zufallsprinzip (generieren Sie ein zufälliges ndarray mit 100 Zeilen und 3 Spalten im Bereich von 0 bis 255).
color = np.random.randint(0, 255, (100, 3))

#Verarbeitung des ersten Frames
end_flag, frame = cap.read()
gray_prev = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
feature_prev = cv2.goodFeaturesToTrack(gray_prev, mask = None, **feature_params)
mask = np.zeros_like(frame)

while(end_flag):
    #In Graustufen konvertieren
    gray_next = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

    #Optische Durchflusserkennung
    feature_next, status, err = cv2.calcOpticalFlowPyrLK(gray_prev, gray_next, feature_prev, None, **lk_params)

    if len(feature_next[status == 1]) == 0:
        feature_prev = cv2.goodFeaturesToTrack(gray_prev, mask = None, **feature_params)
        mask = np.zeros_like(frame)
        feature_next, status, err = cv2.calcOpticalFlowPyrLK(gray_prev, gray_next, feature_prev, None, **lk_params)

    #Wählen Sie Merkmalspunkte aus, für die ein optischer Fluss erkannt wurde (0: nicht erkannt, 1: erkannt).
    good_prev = feature_prev[status == 1]
    good_next = feature_next[status == 1]
    
    #Optischen Fluss zeichnen
    for i, (next_point, prev_point) in enumerate(zip(good_next, good_prev)):
        prev_x, prev_y = prev_point.ravel()
        next_x, next_y = next_point.ravel()
        mask = cv2.line(mask, (next_x, next_y), (prev_x, prev_y), color[i].tolist(), 2)
        frame = cv2.circle(frame, (next_x, next_y), 25, color[i].tolist(), -1)
    img = cv2.add(frame, mask)

    #Im Fenster anzeigen
    cv2.imshow('window', img)

    #Drücken Sie die ESC-Taste, um den Vorgang abzuschließen
    if cv2.waitKey(30) & 0xff == 27:
        break

    #Vorbereitung des nächsten Rahmens und Punktes
    gray_prev = gray_next.copy()
    feature_prev = good_next.reshape(-1, 1, 2)
    end_flag, frame = cap.read()

#Verarbeitung beenden
cv2.destroyAllWindows()
cap.release()

erledigt!