[PYTHON] Essayez la détection des visages en temps réel à l'aide d'une webcam

introduction

J'ai installé un logiciel appelé motion sur Raspberry PI et je l'ai utilisé comme caméra de surveillance pour identifier qui est la personne sur la photo, mais c'est un peu insatisfaisant car il ne s'identifie qu'en utilisant l'image fixe enregistrée. Vers cette heure-ci.

Comme c'était un gros problème, je me demandais si je pouvais faire quelque chose en traitant la vidéo en temps réel et en collectant des informations, mais comme il y avait un article qui semble lié, j'ai fait un script pour détecter le visage en temps réel tout en y faisant référence.

Essayez de convertir des vidéos de caméra Web / caméra vidéo en temps réel avec OpenCV

Installation d'OpenCV

Ceci est Miso, mais veuillez vous référer à l'article suivant pour la procédure d'installation.

Procédure pour créer rapidement un environnement d'apprentissage en profondeur sur Mac avec TensorFlow et OpenCV

Copiez également le classificateur utilisé pour la détection des visages dans le dossier de travail avec la commande suivante.

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

Créer un script

Le script publié sur le site de référence a été modifié comme suit.

sebcam.py

import cv2

if __name__ == '__main__':
    #Définition constante
    ESC_KEY = 27     #Touche Echap
    INTERVAL= 33     #Temps d'attente
    FRAME_RATE = 30  # fps

    ORG_WINDOW_NAME = "org"
    GAUSSIAN_WINDOW_NAME = "gaussian"

    DEVICE_ID = 0

    #Désignation du classificateur
    cascade_file = "haarcascade_frontalface_alt2.xml"
    cascade = cv2.CascadeClassifier(cascade_file)
    
    #Acquisition d'image de la caméra
    cap = cv2.VideoCapture(DEVICE_ID)

    #Chargement du cadre initial
    end_flag, c_frame = cap.read()
    height, width, channels = c_frame.shape

    #Préparation de la fenêtre
    cv2.namedWindow(ORG_WINDOW_NAME)
    cv2.namedWindow(GAUSSIAN_WINDOW_NAME)

    #Boucle de traitement de conversion
    while end_flag == True:

        #Acquisition d'image et détection de visage
        img = c_frame
        img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
        face_list = cascade.detectMultiScale(img_gray, minSize=(100, 100))
        
        #Marquer le visage détecté
        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)
        
        #Affichage du cadre
        cv2.imshow(ORG_WINDOW_NAME, c_frame)
        cv2.imshow(GAUSSIAN_WINDOW_NAME, img_gray)

        #Quitter avec la touche Echap
        key = cv2.waitKey(INTERVAL)
        if key == ESC_KEY:
            break

        #Lire l'image suivante
        end_flag, c_frame = cap.read()

    #Terminer le traitement
    cv2.destroyAllWindows()
    cap.release()

Contrôle de fonctionnement

Lorsque vous exécutez la commande suivante, deux fenêtres s'afficheront et vous devriez voir l'image d'origine et l'échelle de gris avec un carré dessiné sur le visage.

python

$ python sebcam.py

C'était fait (^ - ^) /

Bonus (flux optique)

Il y avait aussi un échantillon qui suit un objet détecté en temps réel, alors je l'ai essayé.

Dessinez un flux optique en temps réel avec OpenCV (méthode Shi-Tomasi, méthode Lucas-Kanade)

Étant donné que la source de lecture vidéo de la destination de référence était un fichier vidéo, je l'ai changé en une caméra Web. Et lorsque les points caractéristiques détectés disparaissent, ils sont modifiés pour être à nouveau détectés.

LucasKande.py

import numpy as np
import cv2

DEVICE_ID = 0
cap = cv2.VideoCapture(DEVICE_ID)

# Shi-Paramètres de détection de coin Tomasi
feature_params = dict( maxCorners = 100,
                       qualityLevel = 0.3,
                       minDistance = 7,
                       blockSize = 7 )

# Lucas-Paramètres de la méthode Kanade
lk_params = dict( winSize  = (15,15),
                  maxLevel = 2,
                  criteria = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 0.03))

#Générer 100 couleurs au hasard (générer un ndarray aléatoire avec 100 lignes et 3 colonnes dans la plage de 0 à 255)
color = np.random.randint(0, 255, (100, 3))

#Traitement de la première image
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):
    #Convertir en échelle de gris
    gray_next = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

    #Détection de flux optique
    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)

    #Sélectionnez les points caractéristiques pour lesquels un flux optique a été détecté (0: non détecté, 1: détecté)
    good_prev = feature_prev[status == 1]
    good_next = feature_next[status == 1]
    
    #Dessiner un flux optique
    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)

    #Afficher dans la fenêtre
    cv2.imshow('window', img)

    #Appuyez sur la touche ESC pour terminer
    if cv2.waitKey(30) & 0xff == 27:
        break

    #Préparation de l'image et du point suivant
    gray_prev = gray_next.copy()
    feature_prev = good_next.reshape(-1, 1, 2)
    end_flag, frame = cap.read()

#Terminer le traitement
cv2.destroyAllWindows()
cap.release()

l'a fait!