Apprenez à identifier et à suivre les mains avec OpenCV et Python
Le suivi des mains est le processus d’utilisation de la vision par ordinateur pour détecter et suivre les mouvements de la main d’une personne en temps réel. L’application la plus dominante du suivi des mains se trouve dans les casques de réalité virtuelle. Les casques vous permettent d’utiliser vos mains comme entrée à la place des contrôleurs tactiles. Cela rend l’expérience plus immersive.
Découvrez comment suivre les mains d’une personne à l’aide de Python, OpenCV pour la vision par ordinateur et MediaPipe.
Comment le framework MediaPipe suit-il les mains ?
Google a développé le framework MediaPipe, qui contient de nombreuses solutions d’apprentissage automatique. L’une des solutions est la solution de suivi des mains et des doigts appelée MediaPipe Hands . Pour suivre les mains, MediaPipe Hands exécute deux processus : la détection de la paume et la détection des points de repère.
Détection de la paume de la main
MediaPipe commence par identifier où se trouvent les paumes dans l’image d’entrée. Étant donné que l’estimation des boîtes englobantes pour les objets rigides est plus simple que l’identification des mains avec des doigts articulés.
Détection des repères de la main
Après la détection de la paume, MediaPipe effectue la détection des repères de la main. Le modèle de point de repère de la main peut prédire 21 coordonnées précises de l’emplacement de chaque point de repère de la main.
Les nombres représentent un identifiant unique pour chaque point de repère.
Configuration de votre environnement
Pour suivre ce projet, vous devez être familiarisé avec les bases de Python. Installez les bibliothèques suivantes dans votre environnement :
- OpenCV : vous utiliserez cette bibliothèque pour la vision par ordinateur et pour effectuer des techniques de traitement d’image sur l’image d’entrée.
- MediaPipe : vous utiliserez cette bibliothèque pour effectuer la détection et le suivi des mains sur l’image d’entrée.
- imutils : vous utiliserez cette bibliothèque pour redimensionner l’image vidéo de l’entrée.
Exécutez la commande suivante sur votre terminal pour installer les bibliothèques OpenCV, MediaPipe et imutils. Installez pip, le gestionnaire de packages Python, si vous en avez besoin. Assurez-vous de transmettre les bibliothèques sous forme de liste délimitée par des espaces.
pip install OpenCV-Python MediaPipe imutils
Lorsque la mise à jour est terminée, l’environnement est prêt pour que vous commenciez à coder.
Importation des bibliothèques requises
Vous devrez importer les bibliothèques que vous avez installées pour pouvoir les utiliser. Ouvrez n’importe quel IDE Python, créez un fichier Python et ajoutez les importations suivantes :
import cv2
import mediapipe as mp
import imutils
Assurez-vous d’importer OpenCV en tant que cv2 et MediaPipe en minuscules. Ne pas le faire générera une erreur.
Création des objets MediaPipe que vous utiliserez pendant le suivi
Vous utiliserez mpHands pour appeler la solution mains MediaPipe, et l’objet mains pour détecter et suivre l’entrée de la main. Vous utiliserez l’objet mpDraw pour dessiner les connexions entre les repères des mains identifiées.
mpHands = mp.solutions.hands
hands = mpHands.Hands()
mpDraw = mp.solutions.drawing_utils
Vous pouvez affiner le modèle de mains MediaPipe en passant divers paramètres au constructeur Hands(). Les valeurs par défaut sont suffisantes pour ce projet, mais vous pouvez les tester pour voir comment elles affectent le modèle :
Vous devez laisser static_image_mode sur False pour vous assurer que le modèle détecte les mains une fois avant de commencer à les suivre. Il ne répète le processus de suivi que si la confiance de détection tombe en dessous du paramètre déclaré, ce qui accélère le traitement global des entrées.
Effectuer le suivi des mains
Vous avez besoin de trois fonctions pour effectuer le suivi de la main : une pour traiter l’entrée, une pour dessiner les connexions de repère de la main et une fonction principale pour contrôler le déroulement du programme.
Fonction de traitement des entrées
Cette fonction prend l’entrée, la convertit en niveaux de gris et la transmet au modèle de mains MediaPipe pour détecter et suivre les mains dans l’entrée.
# Processing the input image
def process_image(img):
# Converting the input to grayscale
gray_image = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
results = hands.process(gray_image)
# Returning the detected hands to calling function
return results
La fonction renvoie les résultats indiquant s’il y avait des mains détectées sur l’entrée.
La fonction de dessin des connexions des points de repère de la main
Cette fonction vérifie si la fonction de traitement d’entrée a détecté des mains. S’il y a des mains détectées, il boucle sur chaque point de repère et dessine un cercle autour de celui-ci, en gardant une trace du point de repère à l’aide de la fonction d’énumération de Python. Il dessine ensuite les connexions entre les points de repère sur l’entrée vidéo d’origine.
# Drawing landmark connections
def draw_hand_connections(img, results):
if results.multi_hand_landmarks:
for handLms in results.multi_hand_landmarks:
for id, lm in enumerate(handLms.landmark):
h, w, c = img.shape
# Finding the coordinates of each landmark
cx, cy = int(lm.x * w), int(lm.y * h)
# Printing each landmark ID and coordinates
# on the terminal
print(id, cx, cy)
# Creating a circle around each landmark
cv2.circle(img, (cx, cy), 10, (0, 255, 0),
cv2.FILLED)
# Drawing the landmark connections
mpDraw.draw_landmarks(img, handLms,
mpHands.HAND_CONNECTIONS)
return img
La fonction commence par encercler chaque point de repère :
Il dessine ensuite les liaisons manuelles :
Il renvoie enfin sa sortie à la fonction appelante.
La fonction principale
Créez une fonction principale qui contrôlera le flux de votre programme. Il prendra l’entrée et redimensionnera l’image vidéo pour assurer la cohérence de la sortie. Transmettez l’entrée à la fonction de traitement qui détectera et suivra ensuite les aiguilles. Prenez les résultats renvoyés dans la fonction de dessin de connexion des points de repère de la main qui dessinera la connexion sur l’entrée vidéo d’origine. Il affichera enfin la sortie à l’utilisateur.
def main():
# Replace 0 with the video path to use a
# pre-recorded video
cap = cv2.VideoCapture(0)
while True:
# Taking the input
success, image = cap.read()
image = imutils.resize(image, width=500, height=500)
results = process_image(image)
draw_hand_connections(image, results)
# Displaying the output
cv2.imshow("Hand tracker", image)
# Program terminates when q key is pressed
if cv2.waitKey(1) == ord('q'):
cap.release()
cv2.destroyAllWindows()
La dernière étape consiste à exécuter votre programme. Le code ci-dessous garantit que lorsque vous exécutez le programme, la fonction principale s’exécute en premier.
if __name__ == "__main__":
main()
Lorsque le programme s’exécute, il produit une sortie comme celle-ci :
Le programme suit les mains en temps réel.
Suivi manuel pour la réalité virtuelle immersive
Le suivi manuel en réalité virtuelle rend la technologie plus attrayante. Les casques de réalité virtuelle ont commencé à introduire le suivi des mains, apportant un sentiment de réalité accrue au monde virtuel. Les casques permettent à l’utilisateur de saisir des commandes à l’aide d’une main virtuelle.
Le suivi des mains dans les casques virtuels n’est qu’une application de cette technologie. Vous pouvez intégrer le suivi manuel dans n’importe quel domaine applicable de votre choix.
Laisser un commentaire