Essayez la reconnaissance faciale avec Python

Lorsque je lisais le document en diagonale tout en étudiant le traitement d'image avec Python + OpenCV, il y avait Tutoriel sur la reconnaissance faciale. C'est une technologie qui semble m'aider à me souvenir des visages des gens de nos jours.

Reconnaissance faciale avec Haar Cascades

Je ne connais pas grand-chose à l'apprentissage automatique ici, mais pour le dire simplement, je m'entraîne pour être capable de distinguer les visages des fonctionnalités Haar en utilisant des images sans visage et des images de visage. En conséquence, des données d'identification sont produites, mais comme méthode pour utiliser efficacement les données d'identification pour l'identification, un classificateur Cascade a été conçu et semble être inclus dans la distribution OpenCV.

Pour Mac Anaconda, il se trouve dans "anaconda3 / share / OpenCV / haarcascades", et pour la version Windows Anaconda, il se trouve dans "Anaconda3 \ Library \ etc \ haarcascades".

--haarcascade_eye.xml ... Reconnaissance oculaire --haarcascade_frontalface_default.xml ... Reconnaissance faciale --haarcascade_smile.xml ... Reconnaissance de sourire

Pour le moment, j'en ai fait une copie. Alors, rendez-le utilisable comme classificateur.

face_cascade = cv2.CascadeClassifier(‘haarcascades/haarcascade_frontalface_default.xml’)

Ensuite, lisez le fichier image. cv2.imread () lit en mode échelle de gris lorsque 0 est spécifié dans le deuxième argument, mais sans utiliser cette fonction, après avoir lu en couleur comme img, utilisez cv2.cvtColor () Faites convertir une copie en échelle de gris. En effet, la reconnaissance faciale est effectuée à l'aide d'une image en échelle de gris et une image en couleur est affichée.

img = cv2.imread(file)
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

Trouvez le visage dans l'image et renvoyez les coordonnées de la position du visage. Une seule ligne, car vous n'utilisez que le classificateur basé sur les données d'identification déjà entraînées.

faces = face_cascade.detectMultiScale(gray, 1.3, 5)

Le visage est recherché dans l'image en échelle de gris (gris), mais un rectangle entourant le visage est dessiné dans l'image couleur d'origine (img) en fonction de la position des coordonnées du visage.

for (x, y, w, h) in faces:
    cv2.rectangle(img, (x,y), (x+w, y+h), (255,0,0), 2)

x et y indiquent respectivement les coordonnées x et y du coin supérieur gauche du rectangle et w et h indiquent respectivement la largeur et la hauteur, mais lors du dessin d'un rectangle dans l'image (img) avec OpenCV, le coin supérieur gauche Puisque les coordonnées x, y et les coordonnées x, y de l'angle inférieur droit sont respectivement requises, elles sont spécifiées comme (x, y), (x + w, y + h).

plt.imshow( cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
plt.show()

L'image avec le rectangle écrit à la fin est affichée, mais pour une raison quelconque, l'image couleur lue par imread () d'OpenCV contient les données dans l'ordre de BGR, mais cette fois, dans le pyplot de matplotlib utilisé pour l'affichage de l'image Comme il est supposé que les données sont conservées dans l'ordre RVB, lors de la transmission des données à plt.imshow (), elles sont converties par cv2.cvtColor (img, cv2.COLOR_BGR2RGB).

Au fait, il est normal d'avoir plusieurs visages, donc je le reçois comme pour (x, y, w, h) dans les visages:, mais les droits d'auteur et de portrait sont parfaits. Je n'ai pas quelque chose comme ça, donc je ne peux pas l'essayer.

import os
import cv2
import numpy as np
from matplotlib import pyplot as plt
%matplotlib inline

def facedetect(file):
    face_cascade = cv2.CascadeClassifier('haarcascades/haarcascade_frontalface_default.xml')
    img = cv2.imread(file)
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    faces = face_cascade.detectMultiScale(gray, 1.3, 5)
    for (x, y, w, h) in faces:
        cv2.rectangle(img, (x,y), (x+w, y+h), (255,0,0), 2)
    plt.imshow( cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
    plt.show()
    
if __name__ == '__main__':
    lenna = "4.2.04.tiff"
    if os.path.exists(lenna):
        facedetect(lenna)

Peut également reconnaître les yeux

Tutoriel contient également un exemple de reconnaissance oculaire après reconnaissance faciale. S'il y a un visage, il y a un œil, et il n'y a pas d'œil ailleurs que le visage, il est donc conçu pour exécuter la reconnaissance oculaire dans le rectangle qui a reconnu le visage.

faces = face_cascade.detectMultiScale(gray, 1.3, 5)
    for (x,y,w,h) in faces:
        cv2.rectangle(img,(x,y),(x+w,y+h),(255,0,0),2)
        roi_gray = gray[y:y+h, x:x+w]
        roi_color = img[y:y+h, x:x+w]
        eyes = eye_cascade.detectMultiScale(roi_gray)
        for (ex,ey,ew,eh) in eyes:
            cv2.rectangle(roi_color,(ex,ey),(ex+ew,ey+eh),(0,255,0),2)

Le problème est que je ne connais rien des "classificateurs Cascade basés sur les fonctionnalités de Haar" et je ne comprends pas du tout l'explication des arguments de la méthode detectMultiScale (). Cela dit, c'est facile et génial.

Maintenant, si vous voulez également identifier quelque chose à partir de l'image, vous devez créer correctement ce classificateur Cascade, mais c'est une autre histoire.

Ce code

• https://github.com/fukuit/Python_SelfLearning/blob/master/face_detect.py