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. fournit les résultats de gestes de la main reconnus et les points de repère de la main de détection des mains. 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 concrètement en quoi consiste cette tâche, consultez le 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'un outil de reconnaissance de gestes pour Android. L'exemple utilise l'appareil photo d'un appareil Android physique pour détecte en permanence les mouvements de la main, et peut également utiliser des images et des vidéos 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 à 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 éventuellement configurer votre instance Git pour utiliser le paiement creuse. Vous n'avez donc 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 les Guide de configuration pour Android

Composants clés

Les fichiers suivants contiennent le code essentiel pour ce geste de la main exemple d'application de reconnaissance:

• GestureRecognizerHelper.kt Initialise le programme de reconnaissance de gestes, et gère le modèle et la délégation de votre choix.
• MainActivity.kt : Elle implémente l'application, y compris en appelant GestureRecognizerHelper et GestureRecognizerResultsAdapter
• GestureRecognizerResultsAdapter.kt : Il 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 projets de code spécifiques pour utiliser la reconnaissance de gestes. 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 Android

Dépendances

La tâche de reconnaissance de gestes utilise l'com.google.mediapipe:tasks-vision bibliothèque. 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 de gestes MediaPipe nécessite un bundle de modèles entraînés compatible 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 exemple de code, le modèle est défini dans la 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 définir la tâche. La fonction createFromOptions() accepte les valeurs 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: images fixes, fichiers vidéo et des 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 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'exemple d'implémentation de code de la reconnaissance de gestes permet à l'utilisateur de basculer entre différents modes de traitement. L'approche rend le code de création de la tâche plus compliqué et peuvent ne pas être adaptés à votre cas d'utilisation. Ce code figure dans la fonction setupGestureRecognizer() dans GestureRecognizerHelper.kt .

Options de configuration

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

Préparer les données

La reconnaissance de gestes fonctionne avec les images, les fichiers vidéo et les diffusions 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 valeur. normalisation.

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

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 exemple de code pour la reconnaissance de gestes, la préparation des données est gérée dans GestureRecognizerHelper.kt .

Exécuter la tâche

L'outil de reconnaissance de gestes utilise recognize, recognizeForVideo et recognizeAsync. pour déclencher des inférences. Pour la reconnaissance des gestes, cela implique prétraiter les données d'entrée, détecter les mains dans l'image, détecter les mains points de repère et reconnaître le geste de la main à 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 détails sur la façon de traiter les données des images, des fichiers vidéo, et les 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 êtes en mode vidéo ou flux en direct, vous devez également fournir le code temporel de la trame 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 bloquer le thread actuel jusqu'à ce qu'il ait fini de traiter l'image d'entrée ou cadre. Pour éviter de bloquer l'interface utilisateur, exécutez le traitement dans un thread d'arrière-plan.
• Lorsqu'elle est exécutée en mode diffusion en direct, la tâche de reconnaissance de gestes ne bloque pas le thread actuel, mais renvoie immédiatement. Elle appellera son résultat avec le résultat de la reconnaissance chaque fois que le traitement est terminé une trame d'entrée. Si la fonction de reconnaissance est appelée lorsque l'outil de reconnaissance de gestes est occupée à traiter une autre trame, elle ignore la nouvelle trame d'entrée.

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

Gérer et afficher les résultats

L'outil de reconnaissance de gestes génère un objet de résultat de la détection de gestes pour chaque de reconnaissance vocale. L'objet de résultat contient des points de repère de main dans les coordonnées de l'image, points de repère de la main en coordonnées mondiales, main gauche(main gauche/droite) et main dominante catégories de gestes des mains détectées.

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

Le résultat GestureRecognizerResult contient quatre composants, chacun sous la forme d'un tableau, où chaque élément contient le résultat détecté par 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 par les mains détectées.

• Points de repère

  Il y a 21 points de repère de main, chacun composé des 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 et leur hauteur. 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.

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 illustrent le résultat de la tâche:

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