Guide de reconnaissance des gestes pour Android

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 les points de repère de la main des mains détectées. Ces instructions vous expliquent comment utiliser la reconnaissance de gestes avec les applications Android. L'exemple de code décrit dans ces instructions est disponible sur GitHub.

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 MediaPipe Tasks est une implémentation simple d'une application de reconnaissance de gestes pour Android. L'exemple utilise la caméra d'un appareil Android physique pour détecter en permanence les gestes de la main, et peut également utiliser des images et des vidéos de la galerie de l'appareil pour détecter les gestes de manière statique.

Vous pouvez utiliser l'application comme point de départ pour votre propre application Android ou vous y référer lorsque vous modifiez une application existante. L'exemple de code de la reconnaissance de gestes est hébergé sur GitHub.

Télécharger le code

Les instructions suivantes vous expliquent comment créer une copie locale de l'exemple de code à l'aide de l'outil de ligne de commande git.

Pour télécharger l'exemple de code, procédez comme suit:

1. Clonez le dépôt git à l'aide de la commande suivante :

   git clone https://github.com/google-ai-edge/mediapipe-samples
   

2. Vous pouvez éventuellement configurer votre instance Git pour utiliser le paiement creux afin de n'avoir que les fichiers de l'application exemple de reconnaissance de gestes :

   cd mediapipe
   git sparse-checkout init --cone
   git sparse-checkout set examples/gesture_recognizer/android
   

Après avoir créé une version locale de l'exemple de code, vous pouvez importer le projet dans Android Studio et exécuter l'application. Pour obtenir des instructions, consultez le guide de configuration pour Android.

Composants clés

Les fichiers suivants contiennent le code crucial pour cet exemple d'application de reconnaissance de gestes de la main:

• GestureRecognizerHelper.kt : initialise l'outil de reconnaissance de gestes, et gère le modèle et la sélection du délégué.
• MainActivity.kt : met en œuvre l'application, y compris en appelant GestureRecognizerHelper et GestureRecognizerResultsAdapter.
• GestureRecognizerResultsAdapter.kt : gère et met en forme les résultats.

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 de version de la plate-forme, consultez le guide de configuration pour Android.

Dépendances

La tâche de reconnaissance de gestes utilise la bibliothèque com.google.mediapipe:tasks-vision. Ajoutez cette dépendance au fichier build.gradle de votre application Android:

dependencies {
    implementation 'com.google.mediapipe:tasks-vision:latest.release'
}

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 le répertoire de votre projet:

<dev-project-root>/src/main/assets

Spécifiez le chemin d'accès du modèle dans le paramètre ModelAssetPath. Dans l'exemple de code, le modèle est défini dans le fichier GestureRecognizerHelper.kt:

baseOptionBuilder.setModelAssetPath(MP_RECOGNIZER_TASK)

Créer la tâche

La tâche de reconnaissance de gestes MediaPipe utilise la fonction createFromOptions() pour configurer la tâche. La fonction createFromOptions() accepte des valeurs pour les options de configuration. Pour en savoir plus sur les options de configuration, consultez la section Options de configuration.

L'outil de reconnaissance de gestes accepte trois types de données d'entrée: les images fixes, les fichiers vidéo et les flux vidéo en direct. Vous devez spécifier le mode d'exécution correspondant à votre type de données d'entrée lors de la création de la tâche. Choisissez l'onglet correspondant à votre type de données d'entrée pour voir comment créer la tâche et exécuter l'inférence.

val baseOptionsBuilder = BaseOptions.builder().setModelAssetPath(MP_RECOGNIZER_TASK)
val baseOptions = baseOptionBuilder.build()

val optionsBuilder =
    GestureRecognizer.GestureRecognizerOptions.builder()
        .setBaseOptions(baseOptions)
        .setMinHandDetectionConfidence(minHandDetectionConfidence)
        .setMinTrackingConfidence(minHandTrackingConfidence)
        .setMinHandPresenceConfidence(minHandPresenceConfidence)
        .setRunningMode(RunningMode.IMAGE)

val options = optionsBuilder.build()
gestureRecognizer =
    GestureRecognizer.createFromOptions(context, options)
    

val baseOptionsBuilder = BaseOptions.builder().setModelAssetPath(MP_RECOGNIZER_TASK)
val baseOptions = baseOptionBuilder.build()

val optionsBuilder =
    GestureRecognizer.GestureRecognizerOptions.builder()
        .setBaseOptions(baseOptions)
        .setMinHandDetectionConfidence(minHandDetectionConfidence)
        .setMinTrackingConfidence(minHandTrackingConfidence)
        .setMinHandPresenceConfidence(minHandPresenceConfidence)
        .setRunningMode(RunningMode.VIDEO)

val options = optionsBuilder.build()
gestureRecognizer =
    GestureRecognizer.createFromOptions(context, options)
    

val baseOptionsBuilder = BaseOptions.builder().setModelAssetPath(MP_RECOGNIZER_TASK)
val baseOptions = baseOptionBuilder.build()

val optionsBuilder =
    GestureRecognizer.GestureRecognizerOptions.builder()
        .setBaseOptions(baseOptions)
        .setMinHandDetectionConfidence(minHandDetectionConfidence)
        .setMinTrackingConfidence(minHandTrackingConfidence)
        .setMinHandPresenceConfidence(minHandPresenceConfidence)
        .setResultListener(this::returnLivestreamResult)
        .setErrorListener(this::returnLivestreamError)
        .setRunningMode(RunningMode.LIVE_STREAM)

val options = optionsBuilder.build()
gestureRecognizer =
    GestureRecognizer.createFromOptions(context, options)
    

L'exemple de code de la reconnaissance de gestes permet à l'utilisateur de basculer entre les modes de traitement. Cette approche complique le code de création de la tâche et peut ne pas être adaptée à votre cas d'utilisation. Vous pouvez voir ce code dans la fonction setupGestureRecognizer() du fichier GestureRecognizerHelper.kt.

Options de configuration

Cette tâche dispose des options de configuration suivantes pour les applications Android:

Préparation des données

La reconnaissance de gestes fonctionne avec des images, des fichiers vidéo et des flux vidéo en direct. Cette tâche gère le prétraitement des entrées de données, y compris le redimensionnement, la rotation et la normalisation de la valeur.

Le code suivant montre comment transférer des données pour traitement. Ces exemples fournissent des détails sur la façon de gérer les données provenant des images, des fichiers vidéo et des flux vidéo en direct.

import com.google.mediapipe.framework.image.BitmapImageBuilder
import com.google.mediapipe.framework.image.MPImage

// Convert the input Bitmap object to an MPImage object to run inference
val mpImage = BitmapImageBuilder(image).build()
    

import com.google.mediapipe.framework.image.BitmapImageBuilder
import com.google.mediapipe.framework.image.MPImage

val argb8888Frame =
    if (frame.config == Bitmap.Config.ARGB_8888) frame
    else frame.copy(Bitmap.Config.ARGB_8888, false)

// Convert the input Bitmap object to an MPImage object to run inference
val mpImage = BitmapImageBuilder(argb8888Frame).build()
    

import com.google.mediapipe.framework.image.BitmapImageBuilder
import com.google.mediapipe.framework.image.MPImage

// Convert the input Bitmap object to an MPImage object to run inference
val mpImage = BitmapImageBuilder(rotatedBitmap).build()
    

Dans l'exemple de code de la reconnaissance de gestes, la préparation des données est gérée dans le fichier GestureRecognizerHelper.kt.

Exécuter la tâche

L'outil de reconnaissance de gestes utilise les fonctions recognize, recognizeForVideo et recognizeAsync 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. Ces exemples incluent des détails sur la façon de gérer les données des images, des fichiers vidéo et des flux vidéo en direct.

val result = gestureRecognizer?.recognize(mpImage)
    

val timestampMs = i * inferenceIntervalMs

gestureRecognizer?.recognizeForVideo(mpImage, timestampMs)
    ?.let { recognizerResult ->
        resultList.add(recognizerResult)
    }
    

val mpImage = BitmapImageBuilder(rotatedBitmap).build()
val frameTime = SystemClock.uptimeMillis()

gestureRecognizer?.recognizeAsync(mpImage, frameTime)
    

Veuillez noter les points suivants :

• Lorsque vous exécutez le mode vidéo ou le mode de diffusion en direct, vous devez également fournir l'horodatage du frame d'entrée à la tâche de reconnaissance de gestes.
• Lors de l'exécution en mode image ou 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. Pour éviter de bloquer l'interface utilisateur, exécutez le traitement dans un thread d'arrière-plan.
• 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 un autre frame, la tâche ignore le nouveau frame d'entrée.

Dans l'exemple de code de la reconnaissance de gestes, les fonctions recognize, recognizeForVideo et recognizeAsync sont définies dans le fichier GestureRecognizerHelper.kt.

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 et z. Les coordonnées x et y sont normalisées à [0,0, 1,0] en fonction de la largeur et de la hauteur de l'image, respectivement. La coordonnée z 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 de z utilise à peu près la même échelle que x.

• 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 et z, 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:

Dans l'exemple de code de la reconnaissance de gestes, la classe GestureRecognizerResultsAdapter du fichier GestureRecognizerResultsAdapter.kt gère les résultats.