La tâche de reconnaissance de gestes MediaPipe vous permet de reconnaître des gestes de la main en temps réel et fournit les résultats et points de repère des gestes détectés. Ces instructions vous expliquent comment utiliser l'outil de reconnaissance de gestes avec des applications Python.
Pour voir cette tâche en action, consultez la démonstration Web. Pour en savoir plus sur les fonctionnalités, les modèles et les options de configuration de cette tâche, consultez la présentation.
Exemple de code
L'exemple de code de la reconnaissance de gestes fournit une implémentation complète de cette tâche en Python à titre de référence. Ce code vous aide à tester cette tâche et à créer votre propre outil de reconnaissance de gestes de la main. Vous pouvez afficher, exécuter et modifier l'exemple de code de la reconnaissance de gestes à l'aide de votre navigateur Web.
Si vous implémentez la reconnaissance de gestes pour Raspberry Pi, reportez-vous à l'application exemple pour Raspberry Pi.
Préparation
Cette section décrit les étapes clés de la configuration de votre environnement de développement et de vos projets de code spécifiquement pour l'utilisation de la reconnaissance de gestes. Pour obtenir des informations générales sur la configuration de votre environnement de développement pour l'utilisation des tâches MediaPipe, y compris sur les exigences concernant les versions de la plate-forme, consultez le guide de configuration de Python.
Colis
La tâche de reconnaissance de gestes MediaPipe nécessite le package PyPI Mediapipe. Vous pouvez installer et importer ces dépendances avec les éléments suivants:
$ python -m pip install mediapipe
Importations
Importez les classes suivantes pour accéder aux fonctions des tâches de la reconnaissance de gestes:
import mediapipe as mp
from mediapipe.tasks import python
from mediapipe.tasks.python import vision
Modèle
La tâche MediaPipe de reconnaissance de gestes nécessite un groupe de modèles entraînés compatibles avec cette tâche. Pour en savoir plus sur les modèles entraînés disponibles pour la reconnaissance de gestes, consultez la section Modèles de la présentation des tâches.
Sélectionnez et téléchargez le modèle, puis stockez-le dans un répertoire local:
model_path = '/absolute/path/to/gesture_recognizer.task'
Spécifiez le chemin d'accès du modèle dans le paramètre "Nom du modèle", comme indiqué ci-dessous:
base_options = BaseOptions(model_asset_path=model_path)
Créer la tâche
La tâche de reconnaissance de gestes MediaPipe utilise la fonction create_from_options
pour configurer la tâche. La fonction create_from_options
accepte les valeurs à gérer pour les options de configuration. Pour en savoir plus sur les options de configuration, consultez la section Options de configuration.
Le code suivant montre comment créer et configurer cette tâche.
Ces exemples montrent également les variantes de construction des tâches pour les images, les fichiers vidéo et les flux vidéo en direct.
Images
import mediapipe as mp BaseOptions = mp.tasks.BaseOptions GestureRecognizer = mp.tasks.vision.GestureRecognizer GestureRecognizerOptions = mp.tasks.vision.GestureRecognizerOptions VisionRunningMode = mp.tasks.vision.RunningMode # Create a gesture recognizer instance with the image mode: options = GestureRecognizerOptions( base_options=BaseOptions(model_asset_path='/path/to/model.task'), running_mode=VisionRunningMode.IMAGE) with GestureRecognizer.create_from_options(options) as recognizer: # The detector is initialized. Use it here. # ...
Vidéo
import mediapipe as mp BaseOptions = mp.tasks.BaseOptions GestureRecognizer = mp.tasks.vision.GestureRecognizer GestureRecognizerOptions = mp.tasks.vision.GestureRecognizerOptions VisionRunningMode = mp.tasks.vision.RunningMode # Create a gesture recognizer instance with the video mode: options = GestureRecognizerOptions( base_options=BaseOptions(model_asset_path='/path/to/model.task'), running_mode=VisionRunningMode.VIDEO) with GestureRecognizer.create_from_options(options) as recognizer: # The detector is initialized. Use it here. # ...
Diffusion en direct
import mediapipe as mp BaseOptions = mp.tasks.BaseOptions GestureRecognizer = mp.tasks.vision.GestureRecognizer GestureRecognizerOptions = mp.tasks.vision.GestureRecognizerOptions GestureRecognizerResult = mp.tasks.vision.GestureRecognizerResult VisionRunningMode = mp.tasks.vision.RunningMode # Create a gesture recognizer instance with the live stream mode: def print_result(result: GestureRecognizerResult, output_image: mp.Image, timestamp_ms: int): print('gesture recognition result: {}'.format(result)) options = GestureRecognizerOptions( base_options=BaseOptions(model_asset_path='/path/to/model.task'), running_mode=VisionRunningMode.LIVE_STREAM, result_callback=print_result) with GestureRecognizer.create_from_options(options) as recognizer: # The detector is initialized. Use it here. # ...
Options de configuration
Cette tâche dispose des options de configuration suivantes pour les applications Python:
Nom de l'option | Description | Plage de valeurs | Valeur par défaut | |
---|---|---|---|---|
running_mode |
Définit le mode d'exécution de la tâche. Il existe trois modes: IMAGE: mode pour les entrées d'une seule image. VIDEO: mode pour les images décodées d'une vidéo. LIVE_STREAM: mode de diffusion en direct de données d'entrée, issues par exemple d'une caméra. Dans ce mode, resultListener doit être appelé pour configurer un écouteur afin de recevoir les résultats de manière asynchrone. |
{IMAGE, VIDEO, LIVE_STREAM } |
IMAGE |
|
num_hands |
Le GestureRecognizer peut détecter le nombre maximal d'aiguilles.
|
Any integer > 0 |
1 |
|
min_hand_detection_confidence |
Score de confiance minimal pour que la détection de la main soit considérée comme réussie dans le modèle de détection de la paume de la main. | 0.0 - 1.0 |
0.5 |
|
min_hand_presence_confidence |
Score de confiance minimal du score de présence de la main dans le modèle de détection de points de repère de la main. En mode vidéo et en mode diffusion en direct de la reconnaissance de gestes, si le score de confiance de présence de la main du modèle de point de repère de la main est inférieur à ce seuil, le modèle de détection de la paume de la main est déclenché. Sinon, un algorithme léger de suivi de la main est utilisé pour déterminer la position des mains pour la détection ultérieure des points de repère. | 0.0 - 1.0 |
0.5 |
|
min_tracking_confidence |
Score de confiance minimal pour que le suivi manuel soit considéré comme réussi. Il s'agit du seuil IoU du cadre de délimitation entre les aiguilles de la trame actuelle et de la dernière image. En mode Vidéo et en mode Flux de la reconnaissance de gestes, en cas d'échec du suivi, l'outil de reconnaissance de gestes déclenche la détection des mains. Sinon, la détection de la main est ignorée. | 0.0 - 1.0 |
0.5 |
|
canned_gestures_classifier_options |
Options de configuration du comportement du classificateur de gestes prédéfinis. Les gestes prédéfinis sont les suivants : ["None", "Closed_Fist", "Open_Palm", "Pointing_Up", "Thumb_Down", "Thumb_Up", "Victory", "ILoveYou"] |
|
|
|
custom_gestures_classifier_options |
Options de configuration du comportement du classificateur de gestes personnalisés. |
|
|
|
result_callback |
Définit l'écouteur de résultat pour recevoir les résultats de la classification de manière asynchrone lorsque le programme de reconnaissance de gestes est en mode flux en direct.
Ne peut être utilisé que lorsque le mode En cours d'exécution est défini sur LIVE_STREAM |
ResultListener |
N/A | N/A |
Préparation des données
Préparez votre entrée en tant que fichier image ou tableau Numpy, puis convertissez-la en objet mediapipe.Image
. Si votre entrée est un fichier vidéo ou un flux en direct à partir d'une webcam, vous pouvez utiliser une bibliothèque externe telle que OpenCV pour charger vos images d'entrée sous forme de tableaux Numpy.
Images
import mediapipe as mp # Load the input image from an image file. mp_image = mp.Image.create_from_file('/path/to/image') # Load the input image from a numpy array. mp_image = mp.Image(image_format=mp.ImageFormat.SRGB, data=numpy_image)
Vidéo
import mediapipe as mp # Use OpenCV’s VideoCapture to load the input video. # Load the frame rate of the video using OpenCV’s CV_CAP_PROP_FPS # You’ll need it to calculate the timestamp for each frame. # Loop through each frame in the video using VideoCapture#read() # Convert the frame received from OpenCV to a MediaPipe’s Image object. mp_image = mp.Image(image_format=mp.ImageFormat.SRGB, data=numpy_frame_from_opencv)
Diffusion en direct
import mediapipe as mp # Use OpenCV’s VideoCapture to start capturing from the webcam. # Create a loop to read the latest frame from the camera using VideoCapture#read() # Convert the frame received from OpenCV to a MediaPipe’s Image object. mp_image = mp.Image(image_format=mp.ImageFormat.SRGB, data=numpy_frame_from_opencv)
Exécuter la tâche
L'outil de reconnaissance de gestes utilise les fonctions de reconnaissance, de reconnaissance pour la vidéo et de reconnaissance asynchrone pour déclencher des inférences. Pour la reconnaissance des gestes, cela implique le prétraitement des données d'entrée, la détection des mains dans l'image, la détection des points de repère de la main et la reconnaissance des gestes de la main à partir de ces points.
Le code suivant montre comment exécuter le traitement avec le modèle de tâche.
Images
# Perform gesture recognition on the provided single image. # The gesture recognizer must be created with the image mode. gesture_recognition_result = recognizer.recognize(mp_image)
Vidéo
# Perform gesture recognition on the provided single image. # The gesture recognizer must be created with the video mode. gesture_recognition_result = recognizer.recognize_for_video(mp_image, frame_timestamp_ms)
Diffusion en direct
# Send live image data to perform gesture recognition. # The results are accessible via the `result_callback` provided in # the `GestureRecognizerOptions` object. # The gesture recognizer must be created with the live stream mode. recognizer.recognize_async(mp_image, frame_timestamp_ms)
Veuillez noter les points suivants :
- Lorsque vous exécutez en mode vidéo ou en mode de diffusion en direct, vous devez également fournir à la tâche de reconnaissance de gestes l'horodatage de l'image d'entrée.
- Lors de l'exécution dans le modèle d'image ou de vidéo, la tâche de reconnaissance de gestes bloque le thread actuel jusqu'à ce qu'il ait fini de traiter l'image ou le cadre d'entrée.
- Lors de l'exécution en mode diffusion en direct, la tâche de reconnaissance de gestes ne bloque pas le thread actuel, mais est renvoyée immédiatement. Il appelle son écouteur de résultat avec le résultat de la reconnaissance chaque fois qu'il a fini de traiter une trame d'entrée. Si la fonction de reconnaissance est appelée lorsque la tâche de reconnaissance de gestes est occupée à traiter une autre image, la tâche ignore la nouvelle image d'entrée.
Pour obtenir un exemple complet d'exécution de la reconnaissance de gestes sur une image, consultez l'exemple de code pour en savoir plus.
Gérer et afficher les résultats
L'outil de reconnaissance de gestes génère un objet de résultat de détection de gestes pour chaque exécution de reconnaissance. L'objet de résultat contient des points de repère de la main en coordonnées d'image, des points de repère de la main en coordonnées mondiales, des catégories de main dominante(main gauche/droite) et de gestes de la main des mains détectées.
Voici un exemple des données de sortie de cette tâche:
Le GestureRecognizerResult
obtenu contient quatre composants, chacun étant un tableau, où chaque élément contient le résultat détecté d'une seule main détectée.
Main dominante
La main dominante indique si les mains détectées sont des mains gauches ou droites.
Gestes
Catégories de gestes reconnus pour les mains détectées.
Points de repère
Il y a 21 points de repère pour les mains, chacun composé des coordonnées
x
,y
etz
. Les coordonnéesx
ety
sont normalisées à [0,0, 1,0] en fonction de la largeur et de la hauteur de l'image, respectivement. La coordonnéez
représente la profondeur du point de repère, la profondeur au niveau du poignet correspondant à l'origine. Plus la valeur est faible, plus le point de repère est proche de la caméra. La magnitude dez
utilise à peu près la même échelle quex
.Monuments internationaux
Les points de repère des 21 mains sont également indiqués en coordonnées mondiales. Chaque point de repère est composé de
x
,y
etz
, représentant des coordonnées 3D réelles en mètres avec le point de départ au centre géométrique de la main.
GestureRecognizerResult:
Handedness:
Categories #0:
index : 0
score : 0.98396
categoryName : Left
Gestures:
Categories #0:
score : 0.76893
categoryName : Thumb_Up
Landmarks:
Landmark #0:
x : 0.638852
y : 0.671197
z : -3.41E-7
Landmark #1:
x : 0.634599
y : 0.536441
z : -0.06984
... (21 landmarks for a hand)
WorldLandmarks:
Landmark #0:
x : 0.067485
y : 0.031084
z : 0.055223
Landmark #1:
x : 0.063209
y : -0.00382
z : 0.020920
... (21 world landmarks for a hand)
Les images suivantes montrent une visualisation du résultat de la tâche:
L'exemple de code de la reconnaissance de gestes montre comment afficher les résultats de reconnaissance renvoyés par la tâche. Pour en savoir plus, consultez cet exemple de code.