Reconnaissance du visage avec OpenCV

La complexité des machines a augmenté au fil des ans et les ordinateurs ne font pas exception. Les ordinateurs ont aidé l'humanité à résoudre beaucoup de problèmes et à effectuer de nombreuses tâches difficiles. Il est révolu le temps où tous les ordinateurs étaient de simples opérations arithmétiques, les ordinateurs stimulent désormais le monde.

Les ordinateurs sont devenus si complexes qu'ils sont formés pour penser comme les humains.
Oui!

Nous allons faire quelque chose de cette nature dans cet article. En tant qu'êtres humains, reconnaître les visages des autres est une tâche simple et malgré les capacités des ordinateurs d'aujourd'hui, il n'est pas aussi facile pour l'ordinateur, nous devons donc le former pour pouvoir faire la même chose.

De nombreux articles que vous verriez là-bas pourraient s'arrêter à une simple détection de visage, mais dans cet article, couvrirait non seulement la détection du visage mais aussi la reconnaissance du visage.

Cela signifie que si l'ordinateur est présenté avec deux photos de moi, il ne reconnaîtrait pas seulement quelle partie de l'image est mon visage, elle reconnaîtrait également que je suis également moi.

Pour commencer, nous devions d'abord installer OpenCV sur nos machines, ce qui ne peut être fait que si vous avez installé Python. L'installation de Python n'est pas l'objectif de cet article, donc si vous ne l'avez pas déjà sur votre machine, vous pouvez obtenir Python à partir du site Web de Python.

Pour installer Open CV, nous pouvons le faire en utilisant la commande PIP.

pip install opencv-python

Nous utiliserons également le package Numpy dans cet article, qui devrait être installé aux côtés d'OpenCV en utilisant la commande ci-dessus.

Si Numpy n'a pas été installé, vous pouvez facilement le faire en utilisant la commande ci-dessous:

pip installer Numpy

Pour confirmer que votre OpenCV est installé, lorsque vous activez l'environnement interactif de Python, essayez de l'importer en utilisant:

Importer CV2

Si vous n'obtenez pas d'erreur, alors vous pouvez continuer.

Pour effectuer une reconnaissance faciale, nous écrivions trois scripts. Un pour créer un ensemble de données d'images, un autre pour former ces images, puis la dernière à reconnaître les visages en fonction des résultats de la formation de l'ordinateur.

Nous aurions besoin de la cascade Haar fournie par Open CV. Ce fichier peut être obtenu du répertoire OpenCV qui est CV2 / DATA / HAARCASCAD_FRONTALFACE_DEFAULT.XML sur ma machine, il devrait aussi être le même sur votre machine. Copiez le fichier dans le dossier où vous souhaitez faire la reconnaissance faciale.

Maintenant, passons dans l'épaisseur des choses.
Nous essayions d'obtenir notre webcam pour obtenir les photos, nécessaires pour l'ensemble de données.

Importer CV2
vid_cam = cv2.Videocapture (0)
face_detector = cv2.Cascadeclassifier ('haarcascade_frontalface_default.xml ')
face_id = 1
comte = 0
Pendant (vid_cam.est ouvert()):
ret, image_frame = vid_cam.lire()
gris = cv2.cvtColor (image_frame, cv2.Color_bgr2gray)
faces = face_detector.détectMultiscale (gris, 1.3, 5)
pour (x, y, w, h) dans les visages:
cv2.rectangle (image_frame, (x, y), (x + w, y + h), (255,0,0), 2)
compter + = 1
cv2.IMWRITE ("DataSet / utilisateur."+ str (face_id) + '.'+ str (count) + ".jpg ", gris [y: y + h, x: x + w])
cv2.imshow ('frame', image_frame)
Si CV2.waitKey (100) & 0xff == ord ('q'):
casser
Elif Count> 100:
casser
vid_cam.libérer()
cv2.Destroyallwindows ()

Donc pour expliquer ce que fait chaque ligne de code:

Importer CV2

Voici la commande qui dit à Python d'inclure une bibliothèque externe à utiliser dans ce code, dans ce cas, il est ouvert CV.

vid_cam = cv2.Videocapture (0)

Ce code appelle la bibliothèque CV ouverte importée pour commencer à capturer et la webcam est lancée à ce stade. Si le CV ouvert ne prend pas en charge votre webcam, le code échouera ici.

face_detector = cv2.Cascadeclassifier ('haarcascade_frontalface_default.xml ')

Pour que nous puissions effectuer une détection d'image, ce code est nécessaire. Open CV utilise le 'haarcascade_frontalface_default.XML 'pour la classification en cascade. L'objet résultant est ensuite stocké dans la variable FACE_DETETER.

face_id = 1

Voici un cas de définition du numéro d'identification du visage, donc le premier visage obtient un ID de 1.

comte = 0

Nous allons prendre quelques images car le CV ouvert doit former des images pour pouvoir reconnaître les visages, la variable de nombre sert de nombre d'images.

Pendant (vid_cam.est ouvert()):

Cela permet aux opérations suivantes de procéder à condition que la caméra vidéo soit ouverte. La méthode isopecée () renvoie vrai ou faux.

ret, image_frame = vid_cam.lire()

Ici, le vid_cam.read () regarde la capture vidéo puis capture le cadre qui est stocké dans la variable Image_Frame, si l'opération est réussie, le booléen vrai est renvoyé et stocké dans la variable RET

gris = cv2.cvtColor (image_frame, cv2.Color_bgr2gray)

La méthode cvtColor () est utilisée pour convertir le cadre d'image en type de couleur souhaité. Dans ce cas, nous l'avons converti en niveaux de gris.

faces = face_detector.détectMultiscale (gris, 1.3, 5)

Cela vérifie les cadres de différentes tailles et essaie de les mettre à l'échelle, ceci est appliqué sur la variable à laquelle la cascade Haar a été appliquée.

pour (x, y, w, h) dans les visages:

Ici, nous parcourons les visages et ses dimensions, où X et Y représentent les coordonnées et W et H représentent respectivement la largeur et la hauteur.

cv2.rectangle (image_frame, (x, y), (x + w, y + h), (255,0,0), 2)

N'oubliez pas que nous travaillons toujours avec la caméra vidéo, la caméra vidéo récolte ensuite la partie nécessaire de l'image en fonction des dimensions ci-dessus.

compter + = 1

Immédiatement cela est fait, la variable de comptage qui est un compteur puis incréments.

cv2.IMWRITE ("DataSet / utilisateur."+ str (face_id) + '.'+ str (count) + ".jpg ", gris [y: y + h, x: x + w])

L'image recadrée est la sauvegarde avec l'utilisateur de nom (face_id).(compter).JPG et mis dans un dossier appelé ensemble de données.

cv2.imshow ('frame', image_frame)

Après la sauvegarde, ce code garantit que l'image est une image vidéo s'affiche avec un rectangle sur le visage de l'individu après que la détection du visage a été effectuée.

Si CV2.waitKey (100) & 0xff == ord ('q'):
casser

Après l'image, l'utilisateur est autorisé à empêcher le programme de prendre plus de photos qui peuvent être effectuées en appuyant sur le «Q» sur le clavier pour au moins 100 ms.

Elif Count> 100:
casser

Ce que fait ce code, c'est empêcher la vidéo de fonctionner au moment où 100 photos ont été prises, peu importe si l'utilisateur veut prendre plus ou non.

vid_cam.libérer()

Ici, la webcam est fermée et pas seulement empêchée de prendre des photos.

cv2.Destroyallwindows ()

Ensuite, tous les OpenCV de Windows ont été détruits et le code s'exécute vers la conclusion.

Maintenant que nous en avons fini avec cela, nous pouvons ensuite trouver le jeu de données d'image:

Importer CV2, OS
Importer Numpy comme NP
à partir de l'image d'importation PIL
Reconnaître = CV2.affronter.createlbphfaceRecognizer ()
détecteur = CV2.Cascadeclassifier ("haarcascade_frontalface_default.xml ");
Def GetImagesAndLabels (chemin):
ImagePaths = [OS.chemin.rejoindre (chemin, f) pour f dans le système d'exploitation.listDir (path)]
Faces échantillons = []
ids = []
pour ImagePath dans ImagePaths:
Pil_img = image.ouvert (ImagePath).convertir ('l')
img_numpy = np.Array (pil_img, 'uint8')
id = int (os.chemin.Split (ImagePath) [- 1].diviser(".")[1])
visages = détecteur.DetectMultiScale (IMG_Numpy)
pour (x, y, w, h) dans les visages:
Faces échantillons.Ajouter (img_numpy [y: y + h, x: x + w])
identifiant.ajouter (id)
RETOUR FACES SEMPLE, IDS
faces, ids = getImagesAndLabels ('DataSet')
reconnaissance.train (visages, np.Array (IDS))
reconnaissance.Save ('Trainer / entraîneur.yml ')

Allons-y et expliquons également ce code:

Importer CV2, OS

Tout comme l'autre code, nous importons ici OpenCV et le système d'exploitation dont nous aurions besoin pour le chemin du fichier.

Importer Numpy comme NP

Nous importons également la bibliothèque Numpy qui serait utilisée pour le calcul de la matrice (une matrice est juste une disposition des tableaux).

à partir de l'image d'importation PIL

Nous importons la bibliothèque d'images Python, puis à partir de celui-ci, nous obtenons également la bibliothèque d'images de ce package.

Reconnaître = CV2.affronter.createlbphfaceRecognizer ()

Ce que cela fait, c'est d'appliquer la méthode CreatelBPHFaceCognizer () au CV2.Face Object, cela aiderait à faciliter la reconnaissance des visages car nous n'avons pas à trouver notre propre ensemble d'algorithmes.

détecteur = CV2.Cascadeclassifier ("haarcascade_frontalface_default.xml ");

Si vous avez suivi le tutoriel, vous auriez rencontré cela avant. Il aide à la détection du visage en utilisant le «haarcascade_frontalface_default.XML ”pour la classification en cascade.

Def GetImagesAndLabels (chemin):

Maintenant, nous sommes sur le point de commencer la formation d'image proprement dite, nous créons donc une fonction.

ImagePaths = [OS.chemin.rejoindre (chemin, f) pour f dans le système d'exploitation.listDir (path)]

Ce code vérifie le répertoire actuel du fichier et vérifie les fichiers image puis les ajoute à cette liste.

Faces échantillons = []

Cela initialise une liste d'échantillons, il est vide à ce stade, mais les visages seraient ajoutés au fil du code.

ids = []

Initialiser une liste d'ID, qui est initialement vide.

pour ImagePath dans ImagePaths:

N'oubliez pas le code qui a vérifié les fichiers d'image dans le répertoire? Oui? Maintenant, nous allons traverser chacun de ces fichiers et effectuer des opérations sur eux.

Pil_img = image.ouvert (ImagePath).convertir ('l')

Maintenant, la première chose que nous faisons à l'image est de la convertir en niveaux de gris, et ce code fait cela.

img_numpy = np.Array (pil_img, 'uint8')

L'image à échelle gris n'est qu'une série de nombres en un seul endroit, nous en créons donc un tableau nuchy.

id = int (os.chemin.Split (ImagePath) [- 1].diviser(".")[1])

Si vous vous souvenez du fichier qui obtient les images, vous vous rappelez que nous avons nommé l'utilisateur de fichiers (face_id).compter.jpg. Alors ici, nous partageons les noms avec le «."Et puis nous extrassons le FACE_ID et assignons à une variable ici. Nous aurions besoin de la carte d'identité pour la reconnaissance.

visages = détecteur.DetectMultiScale (IMG_Numpy)

Depuis le tableau Numpy, la méthode DetectMultiScale () va essayer de détecter les visages du modèle qu'il trouve dans le tableau Numpy. Ensuite, il attribue les valeurs dans la variable FACES.

pour (x, y, w, h) dans les visages:

Ici, nous traversons les valeurs attribuées à la variable. Les valeurs ici sont les coordonnées X et Y que nous pourrions prendre comme origine, puis W et H pour la largeur et la hauteur respectivement.

Faces échantillons.Ajouter (img_numpy [y: y + h, x: x + w])

Plus tôt, nous avons créé une liste d'échantillons de visage, mais c'était vide. Ici, nous pouvons ajouter des visages à cette liste, et nous ajoutons le y à H afin d'obtenir les deux valeurs des coordonnées Y et la même est faite à x.

identifiant.ajouter (id)

Nous avons maintenant une liste d'échantillons Face in the Face, nous obtenons donc son identifiant et l'ajoutons également sur la liste des IDS.

RETOUR FACES SEMPLE, IDS

Ensuite, après tout, nous retournons la liste des échantillons de visage et la liste des ID.

faces, ids = getImagesAndLabels ('DataSet')

N'oubliez pas que getImagesAndLabels () n'est qu'une fonction. Nous pouvons donc appeler la fonction ici, et les valeurs de retour sont enregistrées dans les variables des visages et des IDS.

reconnaissance.train (visages, np.Array (IDS))

Voici où se produit la véritable formation. Nous avons appliqué la méthode CreatelBPhfaceRecognizer () un peu plus tôt et affecté à une variable de reconnaissance. C'est le temps de formation!

reconnaissance.Save ('Trainer / entraîneur.yml ')

Après la formation, nous pouvons sauver les résultats de la formation.
Après avoir exécuté le code, il crée un fichier appelé entraîneur.YML qui serait ensuite utilisé par le code de reconnaissance faciale.

Voici le code de reconnaissance faciale:

Importer CV2
Importer Numpy comme NP
Reconnaître = CV2.affronter.createlbphfaceRecognizer ()
reconnaissance.Charge ('entraîneur / entraîneur.yml ')
cascadepath = "haarcascade_frontalface_default.xml "
FACECASCADE = CV2.Cascadeclassifier (Cascadepath)
FONT = CV2.FONT_HERSHEY_SIMPLEX
cam = cv2.Videocapture (0)
Bien que vrai:
ret, im = cam.lire()
gris = cv2.cvtColor (IM, cv2.Color_bgr2gray)
Visages = FACECASCADE.détectMultiscale (gris, 1.2,5)
pour (x, y, w, h) dans les visages:
cv2.Rectangle (IM, (X-20, Y-20), (X + W + 20, Y + H + 20), (0,255,0), 4)
Id = reconnaissance.prédire (gris [y: y + h, x: x + w]))
if (id == 1):
Id = "nazmi"
autre:
Id = "inconnu"
cv2.Rectangle (IM, (X-22, Y-90), (X + W + 22, Y-22), (0,255,0), -1)
cv2.putText (im, str (id), (x, y-40), police, 2, (255 255 255), 3)
cv2.imshow ('im', im)
Si CV2.WaitKey (10) & 0xff == ord ('q'):
casser
came.libérer()
cv2.Destroyallwindows ()

Si vous avez suivi l'article depuis le début, nous l'avons déjà fait. Si vous n'avez pas gentiment fait.

reconnaissance.Charge ('entraîneur / entraîneur.yml ')

N'oubliez pas que nous avons formé le reconnaissance et enregistré un fichier? Oui? Nous chargeons ce fichier maintenant.

cascadepath = "haarcascade_frontalface_default.xml "

Nous travaillerions avec le fichier haarcascade, et ici nous avons attribué le nom de fichier à une variable.

# Créer un classificateur à partir du modèle préconçu
FACECASCADE = CV2.Cascadeclassifier (Cascadepath)

Ici, nous pouvons effectuer une classification en cascade sur le fichier haarcascade.

FONT = CV2.FONT_HERSHEY_SIMPLEX

Nous définissons le type de police qui serait utilisé lorsque le code reconnaît le visage dans une image et affiche le nom.

cam = cv2.Videocapture (0)

Nous avons déjà été ici, mais cette fois, il est temps de reconnaître les visages. Si vous ne savez pas ce que fait ce code, il lance la webcam.

Bien que vrai:
ret, im = cam.lire()
gris = cv2.cvtColor (IM, cv2.Color_bgr2gray)
Visages = FACECASCADE.détectMultiscale (gris, 1.2,5)
pour (x, y, w, h) dans les visages:

Tout cela a déjà été fait, veuillez vérifier le code qui a été utilisé pour enregistrer des images si vous ne savez pas ce que fait le code.

cv2.Rectangle (IM, (X-20, Y-20), (X + W + 20, Y + H + 20), (0,255,0), 4)

Cela aide donc la webcam à détecter où se trouvent les visages et place un rectangle pour indiquer un visage.

Id = reconnaissance.prédire (gris [y: y + h, x: x + w]))

Nous avons Alrerady a chargé le fichier de train dans le reconnaissance, il est donc capable de reconnaître le visage maintenant.

if (id == 1):
Id = "moi-même"
autre:
Id = "inconnu"

Après avoir essayé de reconnaître de quel visage il s'agit, il vérifie l'ID et voit s'il existe. Ici, la valeur de l'identifiant serait le nom de celui qui était propriétaire du fait face à un tel identifiant lorsque l'ensemble de données d'image a été créé.

cv2.Rectangle (IM, (X-22, Y-90), (X + W + 22, Y-22), (0,255,0), -1)
cv2.putText (im, str (id), (x, y-40), police, 2, (255 255 255), 3)

Le code après avoir trouvé le propriétaire de l'ID, tire un rectangle autour du visage et place le nom du propriétaire du visage. Visage reconnu!

cv2.imshow ('im', im)

Ici, le cadre vidéo s'affiche avec le rectangle borné.

Si CV2.WaitKey (10) & 0xff == ord ('q'):
casser
came.libérer()
cv2.Destroyallwindows ()

Donc, une fois terminé, vous pouvez arrêter le programme en appuyant sur la touche «Q», et il arrête la webcam et la ferme.

Là, vous l'avez, votre webcam peut désormais reconnaître les visages et vous pouvez l'utiliser quand vous le souhaitez. Aussi à utiliser la webcam, vous pouvez également charger une image, mais cela nécessite d'autres étapes que celles prises dans cet article.