Clever Geek Handbook

Comme le voit l'ordinateur





Vous êtes-vous déjà demandé comment l'ordinateur trouve les objets nécessaires au traitement à partir du flux vidéo? À première vue, cela ressemble à une tâche de programmation "élevée" utilisant un grand nombre de formules d'analyse mathématique, de mathématiques discrètes, etc., nécessite une énorme quantité de connaissances pour écrire au moins un petit programme comme "Hello, world" dans le monde de la reconnaissance images sur la vidéo. Et si on vous disait qu'en fait maintenant il est beaucoup plus facile d'entrer dans le monde de la vision par ordinateur, et après avoir lu cet article, vous pouvez écrire votre propre programme qui apprendra à votre ordinateur à voir et à détecter les visages? Vous trouverez également à la fin de l'article un bonus qui peut augmenter la sécurité de votre PC en utilisant la vision par ordinateur.



Pour que votre ordinateur commence Ă  comprendre que vous lui montrez quelque chose qui ressemble Ă  un visage, nous avons besoin de:



  1. Ordinateur;
  2. Webcam;
  3. Python 3;
  4. Votre éditeur de code préféré (PyCharm, Jupyter, etc.).


Ainsi, après avoir rassemblé tout ce dont vous avez besoin dans la liste ci-dessus, nous pouvons procéder à la rédaction directe de notre programme de reconnaissance faciale.



Tout d'abord, téléchargez les bibliothèques Python nécessaires à l'aide de la commande de la ligne de commande: 



pip install opencv-python; numpy






En bref, pourquoi nous en avons besoin:



OpenCV. Cette bibliothèque est l'épine dorsale de presque tous les projets de vision par ordinateur modernes. Il abrite des centaines d'algorithmes de vision par ordinateur et de traitement d'image. Il a été initialement écrit en C / C ++, mais plus tard, il a également été réécrit en Python en raison de sa forte demande dans ce langage.



Numpy. Aidera aux calculs internes de la bibliothèque OpenCV.



Après avoir terminé l'installation des bibliothèques dont nous avons besoin, ouvrez notre éditeur de code préféré et commencez à écrire notre programme:



Joindre la bibliothèque de vision par ordinateur OpenCV 



import cv2 as cv


2. Nous capturons un flux vidéo à partir d'une caméra Web en utilisant la méthode VideoCapture (index), où index est le numéro de série de notre caméra Web dans le système. S'il n'y a qu'une seule caméra, le paramètre sera égal à 0. 



capture = cv.VideoCapture(0)


3. Pour obtenir la vidéo, nous utiliserons la méthode read (), qui nous renvoie le drapeau rtrn - montre le succès de la capture d'une image à partir du flux vidéo et de l'image - l'image de notre flux vidéo (tableau numpy). Nous lirons les données du flux vidéo en continu jusqu'à ce que la touche Échap soit enfoncée. 



while True:
    rtrn, image = capture.read()
    cv.imshow("Capture from Web-camera", image) #      
    if cv.waitKey(1) == 27:  #      Esc
        break
capture.release()
cv.destroyAllWindows()


Nous sauvegardons notre fichier, l'exécutons à partir de la ligne de commande en utilisant python our_file_name.py. Maintenant, notre programme peut recevoir un flux vidéo d'une caméra Web! Cela signifie que nous sommes déjà à mi-chemin du fait que l'ordinateur peut reconnaître les visages.



4. Faisons en sorte que notre ordinateur puisse également écrire une vidéo dans un fichier:



spécifiez le codec pour enregistrer la vidéo, spécifiez le nom du fichier enregistré, les fps et les tailles. Pour notre tâche, nous prenons le codec XVID. 



import cv2 as cv
capture = cv.VideoCapture(0)
codec = cv.VideoWriter_fourcc(*'XVID')


5. Nous sortons séquentiellement les images dans la fenêtre vidéo, puis enregistrons le résultat dans la variable de sortie. Ensuite, les données de la sortie, après la fin du flux vidéo, seront transférées dans le fichier "saved_from_camera.avi": 



output = cv.VideoWriter('saved_from_camera.avi ', codec, 25.0, (640, 480))
while capture.isOpened():
    rtrn, image = capture.read()
    if cv.waitKey(1) == 27 or rtrn == False:
        break
    cv.imshow('video for save', image)
    output.write(image)
output.release()
capture.release()
cv.destroyAllWindows()


Après avoir appris à prendre une vidéo à partir d'une caméra Web et à l'enregistrer dans un fichier, nous pouvons passer à la chose la plus intéressante: la reconnaissance faciale dans un flux vidéo. Pour trouver le visage dans les cadres, nous utiliserons les fonctionnalités dites Haar. Leur essence est que si nous prenons des zones rectangulaires dans l'image, alors par la différence d'intensité entre les pixels des rectangles adjacents, nous pouvons distinguer les caractéristiques inhérentes aux visages.



Par exemple, dans les images avec des visages, la zone autour des yeux est plus sombre que autour des joues. Par conséquent, l'un des signes de Haar pour les visages peut être appelé 2 rectangles adjacents au niveau des joues et des yeux.



Il existe de nombreuses autres méthodes, plus rapides et plus précises, pour détecter les objets dans l'image, mais pour comprendre les principes généraux, nous n'aurons besoin que de connaître les signes de Haar pour l'instant.



Les développeurs d'OpenCV ont déjà travaillé sur la définition des signes Haar et ont fourni à chacun des résultats sur les capacités de traitement du flux vidéo.



Commençons par écrire un détecteur de visage à partir de notre webcam:



6. Tout d'abord, récupérez nos fonctionnalités Haar et définissez les paramètres pour capturer un flux vidéo. Le fichier Traits se trouve dans le chemin où les bibliothèques Python sont installées. Par défaut, ils se trouvent dans le dossier 



C:/Python3X/Lib/sitepackages/cv2/data/haarcascade_frontalface_default.xml


oĂą X est votre subversion Python 3. 



import cv2 as cv
cascade_of_face = cv.CascadeClassifier('C:/Python3.X/Lib/site-packages/cv2/data/haarcascade_frontalface_default.xml ')
capture = cv.VideoCapture(0)
capture.set(cv.CAP_PROP_FPS, 25) #   25


7. Ensuite, en boucle, nous lirons à tour de rôle les cadres de la webcam et les transmettrons à notre détecteur de visage: 



while True:
    rtrn, image = capture.read()
    gr = cv.cvtColor(image, cv.COLOR_BGR2GRAY)
    faces_detect = cascade_of_face.detectMultiScale(
        image=gr,
        minSize=(15, 15),
        minNeighbors=10,
        scaleFactor=1.2
    )
    for (x_face, y_face, w_face, h_face) in faces_detect:
        cv.rectangle(image, (x_face, y_face), (x_face + w_face, y_face + h_face), (0, 0, 255), 2)
    cv.imshow("Image", image)
    if cv.waitKey(1) == 27:  # Esc key
        break
capture.release()
cv.destroyAllWindows()


8. Maintenant, combinons tout en un tout et obtenons un programme qui capture la vidéo d'une caméra Web, reconnaît les visages et enregistre le résultat dans un fichier: 



import cv2 as cv
faceCascade = cv.CascadeClassifier('C:/Users/Zet/Desktop/Python/test_opencv/Lib/site-packages/cv2/data/haarcascade_frontalface_default.xml')
capture = cv.VideoCapture(0)
capture.set(cv.CAP_PROP_FPS, 25)
codec = cv.VideoWriter_fourcc(*'XVID')
output = cv.VideoWriter('saved_from_camera.avi', codec, 25.0, (640, 480))
while True:
    rtrn, image = capture.read()
    gr = cv.cvtColor(image, cv.COLOR_BGR2GRAY)
    faces_detect = faceCascade.detectMultiScale(
        image=gr,
        minSize=(15, 15),
        minNeighbors=10,
        scaleFactor=1.2
    )
    for (x_face, y_face, w_face, h_face) in faces_detect:
        cv.rectangle(image, (x_face, y_face), (x_face + w_face, y_face + h_face), (255, 0, 0), 2)
    cv.imshow("Image", image)
    output.write(image)
    if cv.waitKey(1) == 27:  # Esc key
        break
output.release()
capture.release()
cv.destroyAllWindows()


Tout! Vous avez écrit un programme qui est la première étape pour comprendre comment un ordinateur voit. De plus, vous pouvez améliorer la reconnaissance faciale, par exemple, afin que l'ordinateur reconnaisse certaines personnes dans la vidéo en entraînant les réseaux de neurones. Il est également possible d'écrire un détecteur configuré pour reconnaître des objets plus complexes (par exemple, suivre le trafic) avec la possibilité de les analyser. Et aussi pour résoudre d'autres tâches non moins intéressantes de la vision par ordinateur.



BONUS



Appliquons le programme en pratique - nous suivrons les connexions sous le compte.



  1. Allons au planificateur de tâches (peut être trouvé via la recherche Windows standard);
  2. Créons une tâche simple, donnez-lui un titre et une courte description;






3. Cliquez sur Suivant et accédez à l'élément Déclencheur. Ici, nous sélectionnons l'événement au cours duquel le lancement de notre tâche aura lieu. Nous sélectionnons "Lors de la saisie de Windows";



4. Ensuite, en action, nous indiquons "Exécuter le programme";



5. Dans Action, spécifiez le chemin vers python.exe, et dans les Paramètres - le chemin vers notre programme:







Terminé! En conséquence, lors de la connexion, la personne connectée sous le compte sera enregistrée et la vidéo sera enregistrée. Ainsi, vous pouvez suivre qui a travaillé à l'ordinateur en votre absence, tout en conservant un registre des preuves.


More articles:


All Articles