Guide de détection de visages pour Android

La tâche "Détecteur de visages MediaPipe" vous permet de détecter des visages dans une image ou une vidéo. Vous pouvez utiliser cette tâche pour localiser des visages et des traits du visage dans un cadre. Cette tâche utilise un modèle de machine learning (ML) qui fonctionne avec des images uniques ou un pipeline d'images. Les résultats de la tâche indiquent les emplacements des visages, ainsi que les éléments suivants : points clés du visage: œil gauche, œil droit, extrémité du nez, bouche, tragion oculaire gauche et le tragion de l'œil droit.

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 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'un détecteur de visages pour Android. L'exemple utilise l'appareil photo d'un appareil Android physique pour détecter les visages dans un flux vidéo en continu L'application peut également détecter des visages dans les images et les vidéos de la galerie de l'appareil.

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 visages 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 Détecteur de visages:

   cd mediapipe
   git sparse-checkout init --cone
   git sparse-checkout set examples/face_detector/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 cet exemple de détection de visages application:

• FaceDetectorHelper.kt : Initialise le détecteur de visages, et gère le modèle et la délégation de votre choix.
• CameraFragment.kt : Gère l'appareil photo de l'appareil, et traite les données d'entrée des images et des vidéos.
• GalleryFragment.kt : Il interagit avec OverlayView pour afficher l'image ou la vidéo de sortie.
• OverlayView.kt : Met en œuvre l'affichage avec des cadres de délimitation pour les visages détectés.

Configuration

Cette section décrit les étapes clés à suivre pour configurer votre environnement de développement des projets de codage spécifiquement pour utiliser Face Detector. 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 "Détecteur de visages" 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 détection de visages MediaPipe nécessite un bundle de modèles entraînés et compatibles avec cette tâche. Pour en savoir plus sur les modèles entraînés disponibles pour le détecteur de visages, consultez 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 FaceDetectorHelper.kt :

val modelName = "face_detection_short_range.tflite"
baseOptionsBuilder.setModelAssetPath(modelName)

Créer la tâche

La tâche de détection de visages MediaPipe utilise la fonction createFromOptions() pour configurer le tâche. La fonction createFromOptions() accepte les valeurs pour la configuration options. Pour en savoir plus sur les options de configuration, consultez Options de configuration.

Le détecteur de visages prend en charge les types de données d'entrée suivants: images fixes, fichiers vidéo et des flux vidéo en direct. Vous devez spécifier le mode d'exécution correspondant 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(modelName)
val baseOptions = baseOptionBuilder.build()

val optionsBuilder =
    FaceDetector.FaceDetectorOptions.builder()
        .setBaseOptions(baseOptionsBuilder.build())
        .setMinDetectionConfidence(threshold)
        .setRunningMode(RunningMode.IMAGE)

val options = optionsBuilder.build()

FaceDetector =
    FaceDetector.createFromOptions(context, options)
    

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

val optionsBuilder =
    FaceDetector.FaceDetectorOptions.builder()
        .setBaseOptions(baseOptionsBuilder.build())
        .setMinDetectionConfidence(threshold)
        .setRunningMode(RunningMode.VIDEO)

val options = optionsBuilder.build()

FaceDetector =
    FaceDetector.createFromOptions(context, options)
    

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

val optionsBuilder =
    FaceDetector.FaceDetectorOptions.builder()
        .setBaseOptions(baseOptionsBuilder.build())
        .setMinDetectionConfidence(threshold)
        .setResultListener(this::returnLivestreamResult)
        .setErrorListener(this::returnLivestreamError)
        .setRunningMode(RunningMode.LIVE_STREAM)

val options = optionsBuilder.build()

FaceDetector =
    FaceDetector.createFromOptions(context, options)
    

L'exemple d'implémentation de code du détecteur de visages permet à l'utilisateur de passer 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 setupFaceDetector() dans FaceDetectorHelper.kt .

Options de configuration

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

Préparer les données

Le détecteur de visages fonctionne avec les images, les fichiers vidéo et les flux vidéo 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 le détecteur de visages, la préparation des données est gérée dans les FaceDetectorHelper.kt .

Exécuter la tâche

Selon le type de données avec lesquelles vous travaillez, utilisez le Méthode faceDetector.detect...() spécifique à ce type de données. Utilisez detect() pour les images individuelles detectForVideo() pour les images dans les fichiers vidéo ; et detectAsync() pour les flux vidéo Lorsque vous effectuez des détections flux vidéo, veillez à exécuter les détections sur un thread distinct pour éviter bloquant le thread de l'interface utilisateur.

Les exemples de code suivants illustrent des exemples simples d'exécution du détecteur de visages. dans ces différents modes de données:

val result = faceDetector.detect(mpImage)
    

val timestampMs = i * inferenceIntervalMs

faceDetector.detectForVideo(mpImage, timestampMs)
    .let { detectionResult ->
        resultList.add(detectionResult)
    }
    

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

faceDetector.detectAsync(mpImage, frameTime)
    

Veuillez noter les points suivants :

• En mode vidéo ou flux en direct, vous devez : fournir le code temporel de la trame d'entrée à la tâche de détection de visages.
• En mode Image ou Vidéo, la tâche "Détecteur de visage" bloque 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.
• En mode diffusion en direct, la tâche "Détecteur de visage" renvoie immédiatement et ne bloque pas le thread actuel. Elle appellera le résultat avec le résultat de la détection chaque fois que le traitement d'une trame d'entrée. Si la fonction de détection est appelée lorsque la tâche de détection de visages est occupé à traiter une autre trame, la tâche ignore la nouvelle trame d'entrée.

Dans exemple de code du détecteur de visages, les champs detect, detectForVideo et Les fonctions detectAsync sont définies dans FaceDetectorHelper.kt .

Gérer et afficher les résultats

Le détecteur de visages renvoie un objet FaceDetectorResult pour chaque détection exécuter. L'objet de résultat contient des cadres de délimitation pour les visages détectés et une pour chaque visage détecté.

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

FaceDetectionResult:
  Detections:
    Detection #0:
      BoundingBox:
        origin_x: 126
        origin_y: 100
        width: 463
        height: 463
      Categories:
        Category #0:
          index: 0
          score: 0.9729152917861938
      NormalizedKeypoints:
        NormalizedKeypoint #0:
          x: 0.18298381567001343
          y: 0.2961040139198303
        NormalizedKeypoint #1:
          x: 0.3302789330482483
          y: 0.29289937019348145
        ... (6 keypoints for each face)
    Detection #1:
      BoundingBox:
        origin_x: 616
        origin_y: 193
        width: 430
        height: 430
      Categories:
        Category #0:
          index: 0
          score: 0.9251380562782288
      NormalizedKeypoints:
        NormalizedKeypoint #0:
          x: 0.6151331663131714
          y: 0.3713381886482239
        NormalizedKeypoint #1:
          x: 0.7460576295852661
          y: 0.38825345039367676
        ... (6 keypoints for each face)

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

Pour voir l'image sans cadre de délimitation, reportez-vous à l'image d'origine.

L'exemple de code du détecteur de visages montre comment afficher le renvoyés par la tâche, consultez la OverlayView pour en savoir plus.