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!

Recommended Posts

Essayez la détection des visages en temps réel à l'aide d'une webcam
Détection de visage à l'aide d'un classificateur en cascade
Essayez de convertir des vidéos en temps réel avec OpenCV
Résumé de la détection de visage en Python
Essayez de créer un réseau de neurones en Python sans utiliser de bibliothèque
Essayez d'exécuter une fonction écrite en Python à l'aide de Fn Project
Essayez d'utiliser Spyder inclus dans Anaconda
Créer un outil de reconnaissance de visage à l'aide de TensorFlow
Essayez d'utiliser LevelDB avec Python (plyvel)
Essayez d'utiliser LeapMotion avec Python
Utiliser une webcam avec Raspberry Pi
Essayez d'utiliser FireBase Cloud Firestore avec Python pour le moment
Comment faire un modèle pour la détection d'objets avec YOLO en 3 heures
J'ai essayé de classer les accords de guitare en temps réel en utilisant l'apprentissage automatique
[Python] [Word] [python-docx] Essayez de créer un modèle de phrase de mot en Python en utilisant python-docx
Une note utile lors de l'utilisation de Python après une longue période
Essayez d'utiliser l'API Kraken avec Python
Essayez d'utiliser la bande HL dans l'ordre
Essayez d'envoyer un paquet SYN en Python
Essayez de dessiner une animation simple en Python
Essayez rapidement l'API Face de Microsoft en Python
Essayez d'utiliser un langage de programmation probabiliste (Pyro)
Dessinez une structure arborescente en Python 3 à l'aide de graphviz
Essayez un tube de programmation fonctionnel en Python
Essayez d'utiliser Platypus, une bibliothèque d'optimisation polyvalente
Créez un environnement LAMP en très peu de temps
Créer un fichier GIF en utilisant Pillow en Python
Calculons en fait le problème statistique avec Python
Apprentissage par renforcement 10 Essayez d'utiliser un réseau neuronal formé.
Essayez d'utiliser Blueprint avec Flask pour séparer les contrôleurs
Essayez d'utiliser le code QR avec Raspberry Pi
Essayez d'utiliser l'API BitFlyer Ligntning en Python
Essayez d'utiliser Sourcetrail, un outil de visualisation de code source
Une manière intelligente de chronométrer le traitement avec Python
Lire la sortie du sous-processus, ouvrir en temps réel
Afficher les avis sur les médicaments à l'aide de listes en Python
Essayez d'utiliser LINE Notify pour le moment
Essayez de dessiner un diagramme de contour en utilisant matplotlib avec OpenFOAM
Essayons la détection d'objets en temps réel en utilisant Faster R-CNN
Mettre en œuvre une recherche de visage similaire en une demi-journée
Conseils pour utiliser Elastic Search de manière efficace
Créez un fichier MIDI en Python en utilisant pretty_midi
J'ai écrit un analyseur japonais en japonais en utilisant pyparsing.
Enregistrer des vues YouTube sur une feuille de calcul à l'aide de Lambda
Essayez d'utiliser une classe orientée objet dans R (méthode R6)
Essayez d'utiliser l'API ChatWork et l'API Qiita en Python
Essayez d'utiliser l'API DropBox Core avec Python
Chaque fois que j'essaye de lire un fichier csv en utilisant des pandas, j'obtiens une erreur numpy.
Comment tester unitaire une fonction contenant l'heure actuelle à l'aide de Freezegun en Python
Enregistrez votre fréquence cardiaque sur des feuilles de calcul en temps réel (?) En utilisant Python x fitbit API!
Un script qui transfère les tweets contenant des mots-clés spécifiques sur Twitter vers Slack en temps réel.
Prédire à partir de diverses données en Python à l'aide de l'outil de prédiction de séries chronologiques Facebook Prophet