Guide de détection des points de repère manuels pour Python

La tâche MediaPipe Hand Markerer vous permet de détecter les points de repère des mains dans une image. Ces instructions vous expliquent comment utiliser Hand Markerer avec Python. La l'exemple de code décrit dans ces instructions est disponible sur GitHub

Pour en savoir plus sur les fonctionnalités, les modèles et les options de configuration de cette tâche, consultez la section Présentation.

Exemple de code

L'exemple de code pour Hand Markerer fournit une implémentation complète de cette dans Python à titre de référence. Ce code vous aide à tester cette tâche et à obtenir vous avez commencé à créer votre propre détecteur de points de repère à main. Vous pouvez afficher, exécuter modifiez le Exemple de code pour Hand Markerer en utilisant uniquement votre navigateur Web.

Configuration

Cette section décrit les étapes clés à suivre pour configurer votre environnement de développement de code spécifiquement pour utiliser Hand Markerer. Pour obtenir des informations générales sur configurer votre environnement de développement pour utiliser les tâches MediaPipe, y compris versions de la plate-forme requises, consultez la Guide de configuration pour Python

Colis

La tâche MediaPipe Hand Markerer nécessite le package Mediapipe PyPI. Vous pouvez installer et importer ces dépendances à l'aide des éléments suivants:

$ python -m pip install mediapipe

Importations

Importez les classes suivantes pour accéder aux fonctions de tâche Hand Markerer:

import mediapipe as mp
from mediapipe.tasks import python
from mediapipe.tasks.python import vision

Modèle

La tâche MediaPipe Hand Markerer nécessite un modèle entraîné et compatible avec cette tâche. Pour en savoir plus sur les modèles entraînés disponibles pour Hand Markerer, 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'

Utilisez le paramètre model_asset_path de l'objet BaseOptions pour spécifier le chemin d'accès. du modèle à utiliser. Pour obtenir un exemple de code, consultez la section suivante.

Créer la tâche

La tâche MediaPipe Hand Markerer utilise la fonction create_from_options pour : configurer la tâche. La fonction create_from_options accepte les valeurs pour les options de configuration à gérer. Pour en savoir plus sur la configuration consultez la section Options de configuration.

Le code suivant montre comment compiler et configurer cette tâche.

Ces exemples montrent également les variantes de la construction de la tâche pour les images, des fichiers vidéo et des diffusions en direct.

import mediapipe as mp

BaseOptions = mp.tasks.BaseOptions
HandLandmarker = mp.tasks.vision.HandLandmarker
HandLandmarkerOptions = mp.tasks.vision.HandLandmarkerOptions
VisionRunningMode = mp.tasks.vision.RunningMode

# Create a hand landmarker instance with the image mode:
options = HandLandmarkerOptions(
    base_options=BaseOptions(model_asset_path='/path/to/model.task'),
    running_mode=VisionRunningMode.IMAGE)
with HandLandmarker.create_from_options(options) as landmarker:
  # The landmarker is initialized. Use it here.
  # ...
    

import mediapipe as mp

BaseOptions = mp.tasks.BaseOptions
HandLandmarker = mp.tasks.vision.HandLandmarker
HandLandmarkerOptions = mp.tasks.vision.HandLandmarkerOptions
VisionRunningMode = mp.tasks.vision.RunningMode

# Create a hand landmarker instance with the video mode:
options = HandLandmarkerOptions(
    base_options=BaseOptions(model_asset_path='/path/to/model.task'),
    running_mode=VisionRunningMode.VIDEO)
with HandLandmarker.create_from_options(options) as landmarker:
  # The landmarker is initialized. Use it here.
  # ...
    

import mediapipe as mp

BaseOptions = mp.tasks.BaseOptions
HandLandmarker = mp.tasks.vision.HandLandmarker
HandLandmarkerOptions = mp.tasks.vision.HandLandmarkerOptions
HandLandmarkerResult = mp.tasks.vision.HandLandmarkerResult
VisionRunningMode = mp.tasks.vision.RunningMode

# Create a hand landmarker instance with the live stream mode:
def print_result(result: HandLandmarkerResult, output_image: mp.Image, timestamp_ms: int):
    print('hand landmarker result: {}'.format(result))

options = HandLandmarkerOptions(
    base_options=BaseOptions(model_asset_path='/path/to/model.task'),
    running_mode=VisionRunningMode.LIVE_STREAM,
    result_callback=print_result)
with HandLandmarker.create_from_options(options) as landmarker:
  # The landmarker is initialized. Use it here.
  # ...
    

Pour obtenir un exemple complet de création d'un repère de main à utiliser avec une image, consultez la exemple de code.

Options de configuration

Cette tâche comporte les options de configuration suivantes pour les applications Python:

Préparer les données

Préparez votre entrée sous forme de fichier image ou de tableau Numpy. puis le convertir en objet mediapipe.Image. Si votre entrée est un fichier vidéo ou une diffusion en direct depuis une webcam, vous pouvez utiliser une bibliothèque externe telle que OpenCV pour charger vos frames d'entrée au format Numpy ; tableaux.

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)
    

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)
    

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

Hand Markerer utilise les fonctions "Detect", "Detect_for_video" et "Detect_async". pour déclencher des inférences. Pour la détection des points de repère de la main, cela implique prétraiter les données d'entrée, détecter les mains dans l'image et détecter les mains de points de repère.

Le code suivant montre comment exécuter le traitement avec le modèle de tâche.

# Perform hand landmarks detection on the provided single image.
# The hand landmarker must be created with the image mode.
hand_landmarker_result = landmarker.detect(mp_image)
    

# Perform hand landmarks detection on the provided single image.
# The hand landmarker must be created with the video mode.
hand_landmarker_result = landmarker.detect_for_video(mp_image, frame_timestamp_ms)
    

# Send live image data to perform hand landmarks detection.
# The results are accessible via the `result_callback` provided in
# the `HandLandmarkerOptions` object.
# The hand landmarker must be created with the live stream mode.
landmarker.detect_async(mp_image, frame_timestamp_ms)
    

Veuillez noter les points suivants :

• Lorsque vous êtes en mode vidéo ou flux en direct, vous devez également fournir à la tâche Hand Markerer le code temporel de la trame d'entrée.
• Lors de l'exécution du modèle d'image ou de vidéo, la tâche Hand Markerer bloquer le thread actuel jusqu'à ce qu'il ait fini de traiter l'image d'entrée ou cadre.
• En mode diffusion en direct, la tâche Hand Markerer ne bloque pas le thread actuel, mais renvoie immédiatement. Elle appellera son résultat avec le résultat de la détection chaque fois que le traitement est terminé une trame d'entrée. Si la fonction de détection est appelée lorsque la fonction Hand Markerer est occupée à traiter une autre trame, elle ignore la nouvelle trame d'entrée.

Pour obtenir un exemple complet de mise en œuvre d'un repère de main sur une image, consultez la exemple de code.

Gérer et afficher les résultats

Pour chaque détection, Hand Markerer génère un objet permettant de marquer une main. exécuter. L'objet résultant contient des points de repère "main" dans les coordonnées de l'image, "main" points de repère en coordonnées mondiales et main dominante(main gauche/droite) du mains libres.

Voici un exemple de données de sortie de cette tâche:

La sortie HandLandmarkerResult contient trois composants. Chaque composant est un tableau, où chaque élément contient les résultats suivants pour une seule main détectée:

• Main dominante

  La dominance indique si les mains détectées sont des mains gauches ou droites.

• Points de repère

  Il y a 21 points de repère de main, chacun composé de coordonnées x, y et z. La Les coordonnées x et y sont normalisées à [0,0, 1,0] par la largeur de l'image et de hauteur, respectivement. La coordonnée z représente la profondeur du point de repère, avec la profondeur au poignet étant l'origine. Plus la valeur est faible, plus la à l'objectif de l'appareil photo. L'amplitude de z utilise à peu près la même échelle que x

• Sites remarquables et monuments du monde

  Les 21 points de repère sont également représentés par des coordonnées mondiales. Chaque point de repère est composé de x, y et z, qui représentent des coordonnées 3D réelles dans mètres avec l'origine au centre géométrique de la main.

HandLandmarkerResult:
  Handedness:
    Categories #0:
      index        : 0
      score        : 0.98396
      categoryName : Left
  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)

L'image suivante montre une visualisation du résultat de la tâche:

L'exemple de code Hand Markerer montre comment afficher le renvoyés par la tâche, consultez la exemple de code pour en savoir plus.