Guide de reconnaissance des gestes pour Android

La tâche de reconnaissance des gestes MediaPipe vous permet de reconnaître les gestes de la main en temps réel et fournit les résultats de la reconnaissance des gestes de la main et les repères de la main des mains détectées. Ces instructions vous expliquent comment utiliser le détecteur 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, regardez 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 section Présentation.

Exemple de code

L'exemple de code MediaPipe Tasks est une implémentation simple d'une application de reconnaissance gestuelle pour Android. L'exemple utilise l'appareil photo d'un appareil Android physique pour détecter en continu les gestes des mains. Il peut également utiliser des images et des vidéos de la galerie de l'appareil pour détecter de manière statique les gestes.

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 du détecteur 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:

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 également configurer votre instance git pour utiliser un "checkout" clairsemé afin de n'avoir que les fichiers de l'application exemple du détecteur 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 essentiel de cet exemple d'application de reconnaissance des gestes manuels:

• GestureRecognizerHelper.kt : initialise le détecteur de gestes et gère le modèle et la sélection du délégué.
• MainActivity.kt : implémente l'application, y compris l'appel de GestureRecognizerHelper et de GestureRecognizerResultsAdapter.
• GestureRecognizerResultsAdapter.kt : gère et met en forme les résultats.

Configuration

Cette section décrit les étapes clés à suivre pour configurer votre environnement de développement et vos projets de code spécifiquement pour utiliser le détecteur de gestes. Pour obtenir des informations générales sur la configuration de votre environnement de développement pour utiliser les tâches MediaPipe, y compris les exigences concernant les versions de la plate-forme, consultez le guide de configuration pour Android.

Dépendances

La tâche de l'outil de reconnaissance des 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 de reconnaissance des gestes MediaPipe nécessite un bundle de modèle entraîné compatible avec cette tâche. Pour en savoir plus sur les modèles entraînés disponibles pour le détecteur de gestes, consultez la section Modèles de la présentation de la tâche.

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 au 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 des 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.

Le détecteur de gestes est compatible avec 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 lorsque vous créez la tâche. Sélectionnez l'onglet correspondant à votre type de données d'entrée pour découvrir 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'implémentation de l'exemple de code du détecteur de gestes permet à l'utilisateur de basculer entre les modes de traitement. Cette approche rend le code de création de tâche plus complexe et n'est peut-être pas 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 propose les options de configuration suivantes pour les applications Android:

Préparer les données

Le détecteur de gestes fonctionne avec les images, les fichiers vidéo et les vidéos en direct. La tâche gère le prétraitement de l'entrée des données, y compris le redimensionnement, la rotation et la normalisation des valeurs.

Le code suivant montre comment transmettre des données pour traitement. Ces exemples incluent des informations sur la gestion des données issues d'images, de fichiers vidéo et de 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 du détecteur de gestes, la préparation des données est gérée dans le fichier GestureRecognizerHelper.kt.

Exécuter la tâche

Le détecteur de gestes utilise les fonctions recognize, recognizeForVideo et recognizeAsync pour déclencher des inférences. Pour la reconnaissance des gestes, cela implique de prétraiter les données d'entrée, de détecter les mains dans l'image, de détecter les points de repère des mains et de reconnaître les gestes des mains à partir des points de repère.

Le code suivant montre comment exécuter le traitement avec le modèle de tâche. Ces exemples incluent des informations sur la gestion des données issues d'images, de fichiers vidéo et de 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 diffusion en direct, vous devez également fournir le code temporel du frame d'entrée à la tâche de reconnaissance des gestes.
• Lorsqu'elle s'exécute en mode image ou vidéo, la tâche du détecteur de gestes bloque le thread actuel jusqu'à ce qu'elle ait terminé de traiter l'image ou le frame d'entrée. Pour éviter de bloquer l'interface utilisateur, exécutez le traitement dans un thread en arrière-plan.
• Lorsqu'elle s'exécute en mode diffusion en direct, la tâche du détecteur de gestes ne bloque pas le thread en cours, mais renvoie immédiatement. Il appelle son écouteur de résultats avec le résultat de la reconnaissance chaque fois qu'il a terminé le traitement d'un frame d'entrée. Si la fonction de reconnaissance est appelée lorsque la tâche du détecteur de gestes est occupée à traiter un autre frame, la tâche ignore le nouveau frame d'entrée.

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

Gérer et afficher les résultats

Le détecteur de gestes génère un objet de résultat de détection de gestes pour chaque exécution de la reconnaissance. L'objet résultat contient des repères de main en coordonnées d'image, des repères de main en coordonnées mondiales, une latéralité(main gauche/droite) et des catégories de gestes de la main des mains détectées.

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

Le GestureRecognizerResult généré 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 maniabilité indique si les mains détectées sont des mains gauches ou droites.

• Gestes

  Catégories de gestes reconnues pour les mains détectées.

• Points de repère

  Il existe 21 repères de la main, chacun composé de coordonnées x, y et z. Les coordonnées x et y sont normalisées à [0,0, 1,0] par la largeur et la hauteur de l'image, respectivement. La coordonnée z représente la profondeur du repère, la profondeur au poignet étant l'origine. Plus la valeur est faible, plus le repère est proche de la caméra. L'ampleur de z utilise à peu près la même échelle que x.

• Monuments du monde

  Les 21 repères de la main sont également présentés en coordonnées mondiales. Chaque repère est composé de x, y et z, qui représentent des coordonnées 3D réelles en mètres, avec l'origine 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 présentent une visualisation de la sortie de la tâche:

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