Le suivi des mains consiste à utiliser 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 courante du suivi des mains est celle des casques de réalité virtuelle. Ces casques vous permettent d’utiliser vos mains à la place des contrôleurs tactiles. Cela rend l’expérience plus immersive.
Découvrez comment suivre les mains d’une personne en utilisant Python, OpenCV pour la vision par ordinateur et MediaPipe.
Comment le cadre MediaPipe suit-il les mains ?
Google a développé le cadre MediaPipe, qui contient de nombreuses solutions d’apprentissage automatique. L’une de ces 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 des paumes 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. Puisque 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 points de repère des mains
Après la détection de la paume, MediaPipe effectue la détection des points de repère de la main. Le modèle de repère de la main peut prédire 21 coordonnées précises de l’emplacement de chaque repère de la main.
Les chiffres représentent un identifiant unique pour chaque point de repère.
Configuration de votre environnement
Pour suivre ce projet, vous devez être familier 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 dans votre terminal pour installer les bibliothèques OpenCV, MediaPipe et imutils. Installez pip – le gestionnaire de paquets Python – si nécessaire. Assurez-vous que vous passez 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 puissiez commencer à coder.
Le code source complet de ce projet est disponible dans son dépôt GitHub.
Importation des bibliothèques requises
Vous devez importer les bibliothèques que vous avez installées pour pouvoir les utiliser. Ouvrez un IDE Python, créez un fichier Python et ajoutez les imports suivants :
import cv2
import mediapipe as mp
import imutils
Assurez-vous que vous importez OpenCV en tant que cv2 et MediaPipe en minuscules. Si vous ne le faites pas, vous obtiendrez une erreur.
Création des objets MediaPipe que vous utiliserez pendant le tracking
Vous utiliserez mpHands pour appeler la solution MediaPipe hands, et l’objet hands pour détecter et suivre l’entrée de la main. Vous utiliserez l’objet mpDraw pour dessiner les connexions entre les points de repère des mains identifiées.
mpHands = mp.solutions.hands
hands = mpHands.Hands()
mpDraw = mp.solutions.drawing_utils
Vous pouvez affiner le modèle de mains de MediaPipe en passant divers paramètres au constructeur Hands(). Les valeurs par défaut sont suffisantes pour ce projet, mais vous pouvez les modifier pour voir comment elles affectent le modèle :
Vous devez laisser l’option static_image_mode comme False pour garantir 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 en la détection est inférieure au paramètre déclaré, ce qui accélère le traitement global de l’entrée.
Exécution du 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 du repère de la main, et une fonction principale pour contrôler le flux 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 si des mains ont été détectées sur l’entrée.
Fonction de dessin de connexions de points de repère de la main
Cette fonction vérifie si la fonction de traitement des entrées a détecté des mains. S’il y a des mains détectées, elle boucle sur chaque point de repère et dessine un cercle autour de lui, en gardant la trace du point de repère en utilisant la fonction enumerate de Python. Elle dessine ensuite les connexions entre les points de repère sur l’entrée vidéo originale.
# 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 connexions des mains :
Il renvoie finalement sa sortie à la fonction appelante.
La fonction principale
Créez une fonction principale qui contrôlera le flux de votre programme. Elle prendra l’entrée et redimensionnera l’image vidéo pour assurer la cohérence de la sortie. Passez l’entrée à la fonction de traitement qui détectera et suivra les mains. Il transmet les résultats obtenus à la fonction de dessin de la connexion des points de repère des mains, qui dessine la connexion sur l’entrée vidéo originale. Enfin, la sortie est affichée à 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 des mains pour la réalité virtuelle immersive
Le suivi des mains dans la réalité virtuelle rend cette technologie plus attrayante. Les casques de réalité virtuelle ont commencé à introduire le suivi de la main, apportant un sentiment de réalité accrue au monde virtuel. Ces casques permettent à l’utilisateur de saisir des commandes à l’aide d’une main virtuelle.
Le suivi de la main dans les casques virtuels n’est qu’une application de cette technologie. Vous pouvez incorporer le suivi de la main dans n’importe quel domaine applicable de votre choix.