Détection du visage et du mouvement à l'aide de la vision de l'ordinateur

OpenCV (Open Source Computer Vision Library) est un module Python utilisé pour la vision de l'ordinateur. C'est un immense module avec des capacités exceptionnelles. Nous pouvons faire beaucoup de choses avec la vision par ordinateur, et certains des plus grands sont la reconnaissance du visage et la détection de mouvement.

Dans ce tutoriel, vous apprendrez à écrire du code pour détecter les visages dans les images, les vidéos et le mouvement.

Pour éviter toutes sortes d'erreurs et de problèmes, nous téléchargerons le fichier OpenCV à partir de github sur https: // github.com / opencv / opencv. Nous utiliserons certains des fichiers à l'intérieur pour terminer le code.

Détection du visage à l'aide d'images

Dans le fichier github opencvv, il y a un sous-répertoire (opencv-master \ samples \ data) appelées données où des exemples de photos et de vidéos avec lesquels travailler sont disponibles. Nous utiliserons des photos et des vidéos trouvées dans ce répertoire. En particulier, j'utiliserai la Lena.fichier jpg. Je vais le copier et le coller dans mon répertoire de travail PyCharm (dans mon cas, c'est C: \ Users \ Never \ PyCharMProjects \ PythonProject). Maintenant, commençons la détection du visage sur cette image.

Tout d'abord, chargeons les modules dont nous avons besoin:

Importer Numpy comme NP
Importer CV2

Le fichier que nous utiliserons est situé à OpenCV-Master \ Data \ HaarCascades \ HaarCascade_Frontalface_Default.XML du fichier téléchargé à partir de github. Nous devons mettre un lien vers le fichier haarcascade comme suit:

FACE_CASCADE = CV2.CascadeClassifier ('C: \\ Users \\ Never \\ Téléchargements \\ opencv-master \\ data \\ haarcascades \\ haarcascade_frontalface_default.xml ')

Chargez la photo pour effectuer la détection du visage à l'aide du CV2.Méthode ImRead ().

image = cv2.Imread ('Lena.jpg ')

Notre prochain objectif est de transformer la photo en niveaux de gris. Ce dernier est fait en utilisant le CV2.Méthode cvtColor (). Cette méthode prend deux arguments. Le premier argument est le nom du fichier à convertir, et le deuxième argument est le format de conversion. Dans ce cas, nous utiliserons CV2.Color_bgr2gray pour le convertir en format de gris.

gris = cv2.cvtcolor (image, cv2.Color_bgr2gray)

Nous utilisons ensuite la fonction DetectMultiScale () pour détecter les objets ou, dans ce cas, les visages. Ici, nous dirons à Python face_cascade.DetectMultiScale (), qui détectera les visages car c'est ce que dans le paramètre FACE_CASCADE. La fonction DetectMultiScale () prend quelques arguments, l'image, un facteur de mise à l'échelle, le nombre minimum de voisins, de drapeaux, de taille minimale et de taille maximale.

faces = face_cascade.détectMultiscale (gris, 1.5, 5)

Pour placer une boîte rectangulaire autour du visage, nous devons utiliser le CV2.Méthode rectangle (). En utilisant cette méthode, nous devons lui donner quelques arguments. Le premier argument est l'image sur laquelle vous voulez, le deuxième argument est le point de départ du rectangle, le troisième argument est le point final du rectangle, le quatrième argument est la couleur du rectangle, et le cinquième argument est l'épaisseur de la ligne. Dans ce cas, W est pour la largeur, H est pour la hauteur, et X et Y sont le point de départ.

pour (x, y, w, h) dans les visages:
cv2.Rectangle (image, (x, y), (x + w, y + h), (0,255,0), 3)

Enfin, nous montrons l'image en utilisant le CV2.Méthode imshow (). Nous utilisons également le CV2.WaitKey (0) pour définir un temps d'attente infini et utiliser le CV2.Méthode de destrielwindows () pour fermer la fenêtre.

cv2.imshow ('image', image)
cv2.WaitKey (0)
cv2.Destroyallwindows ()

Détection du visage à l'aide de vidéos / webcam

Dans ce cas, nous allons détecter les visages en temps réel à l'aide d'une webcam ou d'une vidéo. Encore une fois, nous commençons par importer les modules requis.

Importer Numpy comme NP
Importer CV2

Ensuite, nous devons spécifier l'emplacement des fichiers haarcascade. Nous le faisons comme suit (exactement comme pour l'image):

FACE_CASCADE = CV2.CascadeClassifier ('C: \\ Users \\ Never \\ Téléchargements \\ opencv-master \\ data \\ haarcascades \\ haarcascade_frontalface_default.xml ')

Maintenant, nous devons spécifier la vidéo que nous souhaitons faire face à l'utilisation du CV2.Méthode VideoCapture (). Dans mon cas, j'ai choisi de gérer une vidéo que j'avais et j'ai saisi le nom de la vidéo. Si vous souhaitez traiter avec des webcams, vous metteriez un 0 au lieu du nom du fichier vidéo.

vidéo = cv2.VideoCapture ("Vidéo.MP4 ")

Nous commençons alors une boucle de temps. En tout cas, nous demandons au programme de détecter les visages jusqu'à ce que nous y mettez un arrêt. Dans le premier cas, nous lisons le fichier vidéo à l'aide de la fonction read ().

Bien que vrai:
ret, image = vidéo.lire()

Tout comme dans la section précédente, nous devons transformer les images ou les cadres en niveaux de gris pour faciliter la détection. Nous utilisons le CV2.Méthode cvtColor () pour changer les cadres en gris.

gris = cv2.cvtcolor (image, cv2.Color_bgr2gray)

Pour détecter les visages, nous utilisons la fonction détectMultiScale (). Encore une fois, il faut les mêmes paramètres que dans la section précédente.

faces = face_cascade.détectMultiscale (gris, 1.1, 4)

Afin de placer des rectangles autour des faces, nous utilisons le CV2.Méthode rectangle (). Ceci est similaire à la section précédente.

pour (x, y, w, h) dans les visages:
cv2.rectangle (image, (x, y), (x + w, y + h), (255, 0, 0), 2)

Nous montrons ensuite les cadres en utilisant le cv2.Méthode imshow (). Cette méthode prend deux arguments, le premier est le nom du cadre, et le second est le cadre à afficher.

cv2.imshow ('image', image)

Nous mettons ensuite une clause, si l'utilisateur appuie sur la touche ESC (ou 27), le code va sortir de la boucle.

Si CV2.WaitKey (0) & 0xff == 27:
casser

Enfin, nous publions la vidéo en utilisant la fonction version ().

vidéo.libérer()

Détection de mouvement

La détection de mouvement est excellente! Ce que cela signifie, c'est qu'avec Python et une bonne webcam, nous pouvons créer notre propre caméra de sécurité! Alors, commençons.

Importer Numpy comme NP
Importer CV2

Je choisirai une vidéo dans les échantillons (opencv-master \ samples \ data) du fichier github.

vidéo = cv2.VideoCapture ("VTest.Avi ")

Afin de détecter le mouvement, ce sur quoi nous comptons essentiellement, c'est la différence dans les valeurs de pixel de deux images, une image de référence et une deuxième image ou cadre. Donc, nous créons deux images, Frame1 et Frame2.

ret, frame1 = vidéo.lire()
ret, frame2 = vidéo.lire()

Pendant que la vidéo est ouverte ou en utilisant la fonction isopecée (), nous commençons une boucle.

pendant la vidéo.est ouvert():

Nous calculons d'abord la différence absolue entre Frame1 et Frame2 en utilisant le CV2.Méthode absdiff (). De toute évidence, il faut deux arguments, les premier et deuxième images.

Différence = CV2.Absdiff (Frame1, Frame2)

Comme les choses sont plus faciles en noir et blanc, nous transformerons la différence en niveaux de gris en utilisant le CV2.Méthode cvtColor (). Le CV2.La méthode cvtColor () prend deux arguments, le premier est le cadre ou l'image, et le second est la transformation. Dans ce cas, nous utiliserons CV2.Color_bgr2gray.

gris = cv2.cvtcolor (différence, cv2.Color_bgr2gray)

Une fois l'image en niveaux de gris, nous avons ensuite besoin de brouiller l'image pour supprimer le bruit à l'aide du CV2.Méthode GaussianBlur (). Le CV2.La méthode GaussianBlur () prend quelques arguments - l'image source à brouiller, l'image de sortie, la taille du noyau gaussien, l'écart type du noyau le long de l'axe x, l'écart type du noyau le long de l'axe y et le type de bordure.

Blur = cv2.GaussianBlur (Gray, (5,5), 0)

Ensuite, nous plaçons une valeur de seuil en utilisant le CV2.Méthode threshold (). Cette technique isolera le mouvement en segmentant l'arrière-plan et le premier plan (ou le mouvement). Le CV2.La méthode threshold () prend quatre arguments: l'image, la valeur de seuil, la valeur maximale à utiliser avec thresh_binary et thresh_binary_inv, et le type de seuil.

_, seuil = cv2.Seuil (Blur, 20, 255, CV2.Thresh_binary)

Ensuite, nous dilaterons en utilisant le CV2.Méthode dilate () qui prend 6 arguments au maximum: l'image, le noyau, l'ancre, les itérations, le type de bordure et la valeur de la bordure.

dilater = cv2.dilater (seuil, aucun, itérations = 3)

Le CV2.La méthode findContours () fait exactement ce qu'elle signifie, elle trouve des contours. Il faut trois arguments: l'image source, le mode de récupération et la méthode d'approximation de contour.

contour, _ = cv2.FindContours (dilater, cv2.Retr_tree, v2.Chaîne_approx_simple)

Le CV2.La méthode DrawContours () est utilisée pour dessiner les contours. Il faut quelques arguments: l'image, les contours, le contouridx (cette valeur est négative si tous les contours sont dessinés), la couleur, l'épaisseur, le type de ligne, la hiérarchie, le niveau maximum et le décalage.

cv2.DrawContours (trame1, contour, -1, (0, 0, 255), 2)

Enfin, nous montrons l'image en utilisant le CV2.Méthode imshow ().

cv2.imshow ("image", frame1)

Maintenant, nous définissons le cadre initial 2 comme première image et lisons la vidéo pour un nouveau cadre que nous plaçons dans le paramètre Frame2.

trame1 = trame2
ret, frame2 = vidéo.lire()

Si la touche «Q» est enfoncée, sortez de la boucle:

Si CV2.waitKey (40) == ord ('q'):
casser
vidéo.libérer()

Le code dans son ensemble pour la détection de mouvement ressemblerait à quelque chose comme ceci:

Importer Numpy comme NP
Importer CV2
vidéo = cv2.VideoCapture ("VTest.Avi ")
ret, frame1 = vidéo.lire()
ret, frame2 = vidéo.lire()
pendant la vidéo.est ouvert():
Différence = CV2.Absdiff (Frame1, Frame2)
gris = cv2.cvtcolor (différence, cv2.Color_bgr2gray)
Blur = cv2.GaussianBlur (Gray, (5,5), 0)
_, seuil = cv2.Seuil (Blur, 20, 255, CV2.Thresh_binary)
dilater = cv2.dilater (seuil, aucun, itérations = 3)
contour, _ = cv2.FindContours (dilater, cv2.Retr_tree, Cv2.Chaîne_approx_simple)
cv2.DrawContours (trame1, contour, -1, (0, 0, 255), 2)
cv2.imshow ("image", frame1)
trame1 = trame2
ret, frame2 = vidéo.lire()
Si CV2.waitKey (40) == ord ('q'):
casser
vidéo.libérer()

C'est juste aussi simple! Quelques lignes de code, et nous pouvons faire nos propres programmes de reconnaissance faciale et de détection de mouvement. Quelques lignes supplémentaires, et nous pouvons même les faire parler (disons en utilisant PTTSX3) et créer nos propres caméras de sécurité!

Codage heureux!