Phenquestions
Raspberry Pi est un mini-ordinateur à faible coût qui a rendu l'informatique et la programmation beaucoup plus faciles pour la plupart des gens, y compris les étudiants et les amateurs. Ce mini-ordinateur peut faire tout ce qu'un ordinateur de bureau peut faire, de la navigation sur Internet à la création de projets et de programmes passionnants. Et l'un de ces projets étonnants consiste à créer une reconnaissance faciale Raspberry Pi. Bien que ce projet puisse être très intéressant, il n'est pas très facile à réaliser. Donc, je vous recommande de suivre l'article étape par étape.
Reconnaissance faciale Raspberry Pi
Faire un programme de reconnaissance faciale aurait pu être une chose très difficile et avancée une fois. Mais avec Raspberry Pi, rien n'est trop dur! Dans cet article, j'ai utilisé la bibliothèque Open Source Computer Vision (OpenCV) pour réaliser le projet.
Ce référentiel a été conçu pour fonctionner avec une efficacité de calcul et des applications en temps réel. Par conséquent, il est idéal pour notre programme de reconnaissance faciale en temps réel. Cet article vous guidera pas à pas tout au long du projet. Alors, restez à la fin pour avoir votre propre reconnaissance faciale Raspberry Pi!
Conditions
Vous aurez besoin des éléments suivants pour créer un système de reconnaissance faciale Raspberry Pi :
- Framboise Pi V4
- Appareil photo noir
- OpenCV
Connexions Raspberry Pi
Assurez-vous de créer les connexions suivantes avant de commencer à coder :
- Établissez des connexions entre le Raspberry Pi et le câble ruban de l'écran
- Attachez le SDA à la broche SDA de votre Pi
- Mettez le SCL de l'affichage à la broche SCL
- Attachez le câble plat de la caméra au Raspberry Pi
- Mettez le GND de l'écran dans le Pi GND
- Connectez le Raspberry Pi 5V et le 5V de l'écran
Étape 1 : Installez OpenCV sur Raspberry Pi
La première étape consiste à installer OpenCV sur votre appareil Pi. Pour ce faire, démarrez votre Raspberry Pi et ouvrez une connexion SSH. Pour inclure tout l'espace disponible sur la carte micro-SD, développez votre système de fichiers.
$ sudo raspi-config
Sélectionnez ensuite les « Options avancées » dans le menu et « Développer le système de fichiers » par la suite :
Après cela, appuyez sur le "
$ sudo redémarrer
Étape 2 : Confirmez l'installation d'OpenCV
Une fois que vous avez terminé de redémarrer, il devrait y avoir un environnement virtuel OpenCV prêt sur votre Pi. Maintenant, vous devez confirmer si OpenCV est correctement installé dans votre Pi. Exécutez la commande « source » à chaque fois que vous ouvrez un nouveau terminal afin que les variables système soient correctement configurées.
source ~/.profil
Maintenant, entrez dans votre environnement virtuel :
travailler sur cv
Le texte (cv) signifie que vous êtes dans l'environnement virtuel cv.
(cv) pi@framboise:~$
Pour entrer dans votre interprète Python :
python
Vous verrez un ">>>" apparaître dans l'interpréteur. Pour importer la bibliothèque OpenCV :
importer cv2
S'il n'y a pas de messages d'erreur, vous pouvez être sûr que l'OpenCV est correctement installé.
Étape 3 : Téléchargez OpenCV
Maintenant, téléchargez votre OpenCV installé. Vous devrez télécharger à la fois OpenCV et OpenCV contrib. La contrib est livrée avec des modules et des fonctions dont vous aurez besoin dans cette expérience.
$ cd ~ $ wget -O opencv.zip https://github.fr/opencv/opencv/archive/4.0.0.zip $ wget -O opencv_contrib.zip https://github.com/opencv/opencv_contrib/archive/4.0.0.Zip *: français
Maintenant, décompressez les archives :
$ décompressez opencv.zip $ décompresser opencv_contrib.Zip *: français
Étape 4 : Installer les dépendances
Maintenant, installez les dépendances OpenCV nécessaires sur votre Raspberry Pi pour le faire fonctionner correctement :
$ sudo apt-get update && sudo apt-get upgrade $ sudo apt-get install build-essential cmake pkg-config $ sudo apt-get install libjpeg-dev libtiff5-dev libjasper-dev libpng-dev $ sudo apt-get install libavcodec -dev libavformat-dev libswscale-dev libv4l-dev $ sudo apt-get install libxvidcore-dev libx264-dev $ sudo apt-get install libgtk2.0-dev libgtk-3-dev $ sudo apt-get install libfontconfig1-dev libcairo2-dev $ sudo apt-get install libgdk-pixbuf2.0-dev libpango1.0-dev $ sudo apt-get install libhdf5-dev libhdf5-serial-dev libhdf5-103 $ sudo apt-get install libqtgui4 libqtwebkit4 libqt4-test python3-pyqt5 $ sudo apt-get install libatlas-base-dev g-aptran $ sudo obtenir installer python2.7-dev python3-dev $ sudo apt-get install python3-pil.imagetk
Étape 5 : Installer pip
Dans cette étape, vous devrez installer un gestionnaire de paquets pour python appelé « pip ».
$ wget https://bootstrap.papy.io/get-pip.py $ sudo python3 get-pip.py
Étape 6 : installez Numpy
Après cela, installez une bibliothèque python appelée "Numpy".
$ pip3 install numpy
Étape 7 : Testez la caméra
Maintenant que vous avez installé toutes les choses nécessaires, y compris OpenCV, il est temps de vérifier si votre appareil photo fonctionne correctement. Vous devriez déjà avoir un Picam installé sur votre Raspberry Pi. Saisissez le code suivant sur votre IDE Python :
import numpy as np import cv2 cap = cv2.Capacité de capture vidéo(0).set(3,640) # set Capuchon de largeur.set(4,480) # set Height while(True): ret, frame = cap.read() frame = cv2.flip(frame, -1) # Retourner la caméra verticalement gris = cv2.cvtCouleur(cadre, cv2.COULEUR_BGR2GRAY) cv2.imshow('cadre', cadre) cv2.imshow('gris', gris) k = cv2.waitKey(30) & 0xff if k == 27 : # appuyez sur 'ESC' pour quitter la cassure.release() cv2.détruireToutesFenêtres() Ce code fonctionne en capturant le flux vidéo généré par votre PiCam qui affiche à la fois le mode gris et le mode couleur BGR. Exécutez ensuite le code avec la commande suivante :
python simpleCamTest.py
Maintenant, appuyez sur la touche [ESC] pour terminer le programme. Assurez-vous de cliquer sur la fenêtre vidéo avant de la terminer. Vous devriez maintenant voir votre appareil photo fonctionner correctement et afficher les résultats. Si votre caméra affiche des messages d'erreur « Échec de l'assertion », utilisez la commande suivante pour résoudre ce problème :
sudo modprobe bcm2835-v4l2
Étape 8 : Détection de visage
Vous devez savoir que la première étape pour mener à bien notre projet de reconnaissance faciale est de faire en sorte que la PiCam capture un visage. Sûrement, il doit d'abord détecter un visage afin de le reconnaître à l'avenir.
L'algorithme de détection de visage nécessite des images avec le visage ainsi que sans visage pour entraîner le classificateur et enregistrer les structures à partir de celles-ci. Heureusement, l'OpenCV que vous avez téléchargé au préalable est livré avec un détecteur et un entraîneur. En outre, il possède déjà des classificateurs pré-entraînés comme le visage, les yeux, les mains, etc. Pour créer un détecteur de visage avec OpenCV, utilisez les codes suivants :
importer numpy en tant que np importer cv2 faceCascade = cv2.CascadeClassifier('Cascades/haarcascade_frontalface_default.xml') casquette = cv2.Capacité de capture vidéo(0).set(3,640) # set Capuchon de largeur.set(4,480) # set Height while True: ret, img = cap.lire () img = cv2.flip(img, -1) gris = cv2.cvtCouleur(img, cv2.COLOR_BGR2GRAY) faces = faceCascade.detectMultiScale( gray, scaleFactor=1.2, minNeighbors=5, minSize=(20, 20) ) pour (x,y,w,h) dans les 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] cv2.imshow('vidéo',img) k = cv2.waitKey(30) & 0xff if k == 27: # appuyez sur 'ESC' pour quitter la cassure.release() cv2.détruireToutesFenêtres() Maintenant, vous devrez appeler la fonction classificateur avec des facteurs d'échelle, des paramètres et une taille minimale du visage qu'elle détectera.
faces = faceCascade.detectMultiScale( gray, scaleFactor=1.2, minNeighbors=5, minSize=(20, 20) )
Ce code fonctionne en détectant les visages sur une image. Maintenant, vous voudrez peut-être marquer les visages en utilisant une forme comme un rectangle. Utilisez le code suivant pour le faire :
pour (x,y,w,h) dans les 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]
Alors, voici comment cela fonctionne :
Si le classificateur trouve des visages dans l'image, il affiche les positions du visage sous la forme d'un rectangle comme indiqué où il utilise "h" comme hauteur et "w" comme largeur et les coins supérieurs gauches (x,y). Cela résume assez bien notre rectangle (x,y,w,h).
Maintenant que vous avez terminé avec les emplacements, créez un « ROI » pour le visage et affichez le résultat avec la fonction imshow (). Exécutez-le sur l'environnement python à l'aide du terminal Raspberry Pi :
détection de visage python.py
Et le résultat :
Étape 9 : Sauvegarde des données
Dans cette partie, vous devez créer un ensemble de données où votre programme va enregistrer les données recueillies sur les identifiants du visage qu'il a détecté. Pour ce faire, créez un répertoire (j'utilise FacialRecognition):
mkdir Reconnaissance faciale
Maintenant, créez un sous-répertoire avec le nom "dataset".
jeu de données mkdir
Ensuite, utilisez le code suivant :
importer cv2 importer os cam = cv2.Caméra de capture vidéo(0).set (3, 640) # définir la largeur de la caméra vidéo.set(4, 480) # définir la hauteur de la vidéo face_detector = cv2.CascadeClassifier('haarcascade_frontalface_default.xml') # Pour chaque personne, entrez un identifiant de visage numérique face_id = input('\n entrez l'identifiant de l'utilisateur et appuyez sur ==> ') print("\n [INFO] Initialisation de la capture de visage. Regardez la caméra et attendez… ") # Initialiser le nombre de visages d'échantillonnage individuel = 0 while(True): ret, img = cam.lire () img = cv2.flip(img, -1) # retourne l'image vidéo verticalement gray = cv2.cvtCouleur(img, cv2.COLOR_BGR2GRAY) faces = face_detector.detectMultiScale(gris, 1.3, 5) pour (x,y,w,h) dans les faces : cv2.rectangle(img, (x,y), (x+w,y+h), (255,0,0), 2) count += 1 # Enregistrer l'image capturée dans le dossier datasets cv2.imwrite("ensemble de données/utilisateur." + str(face_id) + '.' + str(nombre) + ".jpg", gris[y:y+h,x:x+w]) cv2.imshow('image', img) k = cv2.waitKey(100) & 0xff # Appuyez sur 'ESC' pour quitter la vidéo si k == 27: break elif count >= 10: # Prenez 10 échantillons de visage et arrêtez la pause vidéo # Faites un peu de nettoyage print ("\n [INFO] Quitter le programme et nettoyer les trucs") cam.release() cv2.détruireToutesFenêtres() Notez que nous allons enregistrer chacune des images capturées sous forme de fichier dans le sous-répertoire « dataset » :
cv2.imwrite("ensemble de données/utilisateur." + str(face_id) + '.' + str(nombre) + ".jpg", gris[y:y+h,x:x+w]) Après cela, vous devez importer la bibliothèque "os" pour enregistrer le fichier ci-dessus. Le nom des fichiers suivra une structure comme celle-ci :
Utilisateur.face_id.compter.jpg,/pré>
Le code mentionné ci-dessus ne capturera que 10 images pour chaque identifiant. Tu peux surement changer ça si tu veux.
Maintenant, essayez d'exécuter le programme et capturez quelques identifiants. Assurez-vous d'exécuter le code à chaque fois que vous modifiez l'utilisateur ou la photo existante.
Étape 10 : Formateur
Dans cette étape, vous devrez utiliser une fonction OpenCV pour entraîner l'outil de reconnaissance OpenCV avec les données de votre ensemble de données. Commencez par créer un sous-répertoire pour stocker les données entraînées.
entraîneur mkdir
Exécutez ensuite le code suivant :
import cv2 import numpy as np de PIL import Image import os # Chemin de la base de données d'images de visage chemin = 'dataset' reconnaisseur = cv2.visage.Détecteur LBPHFaceRecognizer_create() = cv2.CascadeClassifier("haarcascade_frontalface_default.xml"); # fonction pour obtenir les images et les données d'étiquette def getImagesAndLabels(path): imagePaths = [os.chemin.join(chemin,f) pour f dans os.listdir(path)] faceSamples=[] ids = [] pour imagePath dans imagePaths : PIL_img = Image.open(imagePath).convert('L') # le convertit en niveaux de gris img_numpy = np.tableau(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 : faceSamples.append(img_numpy[y:y+h,x:x+w]) ids.append(id) return faceSamples,ids print ("\n [INFO] Faces d'entraînement. Cela prendra quelques secondes. Attendez… ") faces,ids = getImagesAndLabels(path) reconnaisseur.train(visages, np.array(ids)) # Enregistrez le modèle dans trainer/trainer.reconnaissance yml.écrire('formateur/formateur.yml') # reconnaissance.save() a fonctionné sur Mac, mais pas sur Pi # Imprime le nombre de visages entraînés et termine le programme print("\n [INFO] 0 visages entraînés. Quitter le programme".format(len(np.unique(ids)))) Assurez-vous d'avoir installé la bibliothèque PIL sur votre Raspberry Pi. Si vous ne l'avez pas, exécutez la commande suivante :
pip installer oreiller
Ici, j'utilise le reconnaisseur de visage LBPH fourni avec le package OpenCV. Maintenant, suivez cette ligne :
reconnaissance = cv2.visage.LBPHFaceRecognizer_create()
Toutes vos photos seront transférées dans le répertoire « dataset » par la fonction « getImagesAndLabels ». Il renverra 2 tableaux nommés "Ids" et "faces". Maintenant, il est temps de former l'outil de reconnaissance.
reconnaissance.former (visages, identifiants)
Maintenant, vous verrez le "formateur.yml" fichier nommé enregistré dans le répertoire du formateur.
Étape 11 : Reconnaissance faciale
C'est l'heure de l'action finale. Après cette étape, votre outil de reconnaissance peut deviner un identifiant de retour si le visage a été capturé auparavant. Alors, écrivons notre code final :
importer cv2 importer numpy en tant que np importer os reconnaître = cv2.visage.Reconnaisseur LBPHFaceRecognizer_create().read('formateur/formateur.yml') cascadePath = "haarcascade_frontalface_default.xml" faceCascade = cv2.CascadeClassifier(cascadePath); police = cv2.FONT_HERSHEY_SIMPLEX #iniciate id counter id = 0 # noms liés aux identifiants : exemple ==> Marcelo : id=1, etc names = ['None', 'Markian', 'Bell', 'Grace', 'A', 'Z '] # Initialiser et démarrer la caméra de capture vidéo en temps réel = cv2.Caméra de capture vidéo(0).set (3, 640) # définir la largeur de la caméra vidéo.set(4, 480) # set video height # Définit la taille minimale de la fenêtre à reconnaître comme un visage minW = 0.1 * caméra.obtenir(3) minH = 0.1 * caméra.get(4) avec True : ret, img =cam.lire () img = cv2.flip(img, -1) # Retourner verticalement gris = cv2.cvtCouleur(img,cv2.COLOR_BGR2GRAY) faces = faceCascade.detectMultiScale( gray, scaleFactor = 1.2, minNeighbors = 5, minSize = (int(minW), int(minH)), ) for(x,y,w,h) dans les faces : cv2.rectangle(img, (x,y), (x+w,y+h), (0,255,0), 2) id, confidence = reconnaisseur.predict(gray[y:y+h,x:x+w]) # Vérifiez si la confiance est inférieure à 100 ==> "0" correspond parfaitement si (confiance < 100): id = names[id] confidence = " 0%".format(round(100 - confidence)) else: id = "unknown" confidence = " 0%".format(round(100 - confidence)) cv2.putText(img, str(id), (x+5,y-5), font, 1, (255,255,255), 2) cv2.putText(img, str(confidence), (x+5,y+h-5), font, 1, (255,255,0), 1) cv2.imshow('camera',img) k = cv2.waitKey(10) & 0xff # Press 'ESC' for exiting video if k == 27: break # Do a bit of cleanup print("\n [INFO] Exiting Program and cleanup stuff") cam.release() cv2.destroyAllWindows() Le programme fonctionne comme un outil de reconnaissance. La fonction prédire () prend différentes parties du visage capturé en tant que paramètres différents et revient au propriétaire enregistré tout en affichant l'identifiant.
S'il ne reconnaît pas le visage, il affichera « inconnu » sur la photo.
Donc, Voila!
Enfin, des aperçus
Alors, voici comment vous faites une reconnaissance faciale Raspberry Pi. Assurez-vous de suivre cet article étape par étape pour obtenir le meilleur résultat! Désormais, en plus de ce classificateur de reconnaissance faciale, vous pouvez également effectuer une reconnaissance oculaire ou une reconnaissance de sourire à l'aide de différents classificateurs et fonctions. J'ai fait des recherches sur tous les articles connexes sur Internet et j'ai trouvé celui-ci. Donc, j'espère vraiment que ce guide vous a aidé avec les projets. Et j'espère que c'est réussi pour toi. N'oubliez pas de mentionner vos pensées dans la section des commentaires!
