Détecter des visages avec ML Kit sur Android

Vous pouvez utiliser ML Kit pour détecter des visages dans des images et des vidéos.

Cette API est disponible à l'aide d'une bibliothèque non groupée qui doit être téléchargée avant utilisation ou d'une bibliothèque groupée qui augmente la taille de votre application. Pour en savoir plus sur les différences entre les deux options d'installation, consultez ce guide.

Fonctionnalité	Non groupée	Groupée
Implémentation	Le modèle est téléchargé de manière dynamique via les services Google Play.	Le modèle est lié de manière statique à votre application au moment de la compilation.
Taille de l'application	Augmentation de la taille d'environ 800 Ko.	Augmentation de la taille d'environ 6,9 Mo.
Délai d'initialisation	Vous devrez peut-être attendre le téléchargement du modèle avant de l'utiliser pour la première fois.	Le modèle est disponible immédiatement.

Essayer

• Essayez l'exemple d'application pour voir un exemple d'utilisation de cette API.
• Essayez le code vous-même avec l' atelier de programmation.

Avant de commencer

Cette API nécessite le niveau d'API Android 23 ou supérieur. Assurez-vous que le fichier de compilation de votre application utilise une valeur minSdkVersion de 23 ou plus.

1. Dans le fichier build.gradle au niveau du projet, veillez à inclure le dépôt Maven de Google à la fois dans les sections buildscript et allprojects.

2. Ajoutez les dépendances des bibliothèques Android ML Kit au fichier Gradle au niveau de l'application de votre module, qui est généralement app/build.gradle. Choisissez l'une des dépendances suivantes en fonction de vos besoins :

   Pour regrouper le modèle avec votre application :

   dependencies {
     // ...
     // Use this dependency to bundle the model with your app
     implementation 'com.google.mlkit:face-detection:16.1.7'
   }
   

   Pour utiliser le modèle dans les services Google Play :

   dependencies {
     // ...
     // Use this dependency to use the dynamically downloaded model in Google Play Services
     implementation 'com.google.android.gms:play-services-mlkit-face-detection:17.1.0'
   }
   

3. Si vous choisissez d'utiliser le modèle dans les services Google Play, vous pouvez configurer votre application pour qu'elle télécharge automatiquement le modèle sur l'appareil une fois qu'elle est installée depuis le Play Store. Pour ce faire, ajoutez la déclaration suivante au fichier AndroidManifest.xml de votre application :

   <application ...>
         ...
         <meta-data
             android:name="com.google.mlkit.vision.DEPENDENCIES"
             android:value="face" >
         <!-- To use multiple models: android:value="face,model2,model3" -->
   </application>
   

   Vous pouvez également vérifier explicitement la disponibilité du modèle et demander son téléchargement via l'API ModuleInstallClient des services Google Play.

   Si vous n'activez pas les téléchargements de modèles au moment de l'installation ou ne demandez pas de téléchargement explicite, le modèle est téléchargé la première fois que vous exécutez le détecteur. Les requêtes que vous effectuez avant la fin du téléchargement ne produisent aucun résultat.

Consignes concernant les images d'entrée

Pour la reconnaissance faciale, vous devez utiliser une image d'au moins 480 x 360 pixels. Pour que ML Kit détecte les visages avec précision, les images d'entrée doivent contenir des visages représentés par suffisamment de données de pixels. En général, chaque visage que vous souhaitez détecter dans une image doit être d'au moins 100 x 100 pixels. Si vous souhaitez détecter les contours des visages, ML Kit nécessite une entrée de résolution plus élevée : chaque visage doit être d'au moins 200 x 200 pixels.

Si vous détectez des visages dans une application en temps réel, vous pouvez également tenir compte des dimensions globales des images d'entrée. Les images plus petites peuvent être traitées plus rapidement. Par conséquent, pour réduire la latence, capturez des images à des résolutions inférieures, mais gardez à l'esprit les exigences de précision ci-dessus et assurez-vous que le visage du sujet occupe la plus grande partie possible de l'image. Consultez également les conseils pour améliorer les performances en temps réel.

Une mauvaise mise au point de l'image peut également avoir un impact sur la précision. Si vous n'obtenez pas de résultats acceptables, demandez à l'utilisateur de reprendre l'image.

L'orientation d'un visage par rapport à la caméra peut également affecter les caractéristiques faciales détectées par ML Kit. Consultez la section Concepts de la détection des visages.

1. Configurer le détecteur de visages

Avant d'appliquer la détection des visages à une image, si vous souhaitez modifier l'un des paramètres par défaut du détecteur de visages, spécifiez-les avec un FaceDetectorOptions objet. Vous pouvez modifier les paramètres suivants :

Paramètres
setPerformanceMode	PERFORMANCE_MODE_FAST (par défaut) | PERFORMANCE_MODE_ACCURATE Privilégiez la vitesse ou la précision lors de la détection des visages.
setLandmarkMode	LANDMARK_MODE_NONE (par défaut) | LANDMARK_MODE_ALL Indique si vous devez tenter d'identifier les "points de repère" faciaux : yeux, oreilles, nez, joues, bouche, etc.
setContourMode	CONTOUR_MODE_NONE (par défaut) | CONTOUR_MODE_ALL Indique si vous devez détecter les contours des caractéristiques faciales. Les contours ne sont détectés que pour le visage le plus visible d'une image.
setClassificationMode	CLASSIFICATION_MODE_NONE (par défaut) | CLASSIFICATION_MODE_ALL Indique si vous devez classer les visages dans des catégories telles que "sourire", et "yeux ouverts".
setMinFaceSize	float (par défaut : 0.1f) Définit la plus petite taille de visage souhaitée, exprimée sous forme de rapport entre la largeur de la tête et la largeur de l'image.
enableTracking	false (par défaut) | true Indique si vous devez attribuer un ID aux visages, qui peut être utilisé pour suivre les visages sur plusieurs images. Notez que lorsque la détection des contours est activée, un seul visage est détecté. Par conséquent, le suivi des visages ne produit pas de résultats utiles. Pour cette raison et pour améliorer la vitesse de détection, n'activez pas à la fois la détection des contours et le suivi des visages.

Exemple :

Kotlin

// High-accuracy landmark detection and face classification
val highAccuracyOpts = FaceDetectorOptions.Builder()
        .setPerformanceMode(FaceDetectorOptions.PERFORMANCE_MODE_ACCURATE)
        .setLandmarkMode(FaceDetectorOptions.LANDMARK_MODE_ALL)
        .setClassificationMode(FaceDetectorOptions.CLASSIFICATION_MODE_ALL)
        .build()

// Real-time contour detection
val realTimeOpts = FaceDetectorOptions.Builder()
        .setContourMode(FaceDetectorOptions.CONTOUR_MODE_ALL)
        .build()
FaceDetectionActivity.kt

Java

// High-accuracy landmark detection and face classification
FaceDetectorOptions highAccuracyOpts =
        new FaceDetectorOptions.Builder()
                .setPerformanceMode(FaceDetectorOptions.PERFORMANCE_MODE_ACCURATE)
                .setLandmarkMode(FaceDetectorOptions.LANDMARK_MODE_ALL)
                .setClassificationMode(FaceDetectorOptions.CLASSIFICATION_MODE_ALL)
                .build();

// Real-time contour detection
FaceDetectorOptions realTimeOpts =
        new FaceDetectorOptions.Builder()
                .setContourMode(FaceDetectorOptions.CONTOUR_MODE_ALL)
                .build();
FaceDetectionActivity.java

2. Préparer l'image d'entrée

Pour détecter des visages dans une image, créez un objet InputImage à partir d'un Bitmap, d'un media.Image, d'un ByteBuffer, d'un tableau d'octets ou d'un fichier sur l'appareil. Transmettez ensuite l'objet InputImage à la méthode process du FaceDetector.

Pour la détection des visages, vous devez utiliser une image d'au moins 480 x 360 pixels. Si vous détectez des visages en temps réel, la capture d'images à cette résolution minimale peut aider à réduire la latence.

Vous pouvez créer un InputImage objet à partir de différentes sources, chacune étant expliquée ci-dessous.

Utiliser un media.Image

Pour créer un objet InputImage à partir d'un objet media.Image, par exemple lorsque vous capturez une image à partir de l'appareil photo d'un appareil, transmettez l'objet media.Image et la rotation de l'image à InputImage.fromMediaImage().

Si vous utilisez la bibliothèque CameraX, les classes OnImageCapturedListener et ImageAnalysis.Analyzer calculent la valeur de rotation pour vous.

Kotlin

private class YourImageAnalyzer : ImageAnalysis.Analyzer {

    override fun analyze(imageProxy: ImageProxy) {
        val mediaImage = imageProxy.image
        if (mediaImage != null) {
            val image = InputImage.fromMediaImage(mediaImage, imageProxy.imageInfo.rotationDegrees)
            // Pass image to an ML Kit Vision API
            // ...
        }
    }
}

Java

private class YourAnalyzer implements ImageAnalysis.Analyzer {

    @Override
    public void analyze(ImageProxy imageProxy) {
        Image mediaImage = imageProxy.getImage();
        if (mediaImage != null) {
          InputImage image =
                InputImage.fromMediaImage(mediaImage, imageProxy.getImageInfo().getRotationDegrees());
          // Pass image to an ML Kit Vision API
          // ...
        }
    }
}

Si vous n'utilisez pas de bibliothèque d'appareil photo qui vous donne le degré de rotation de l'image, vous pouvez le calculer à partir du degré de rotation de l'appareil et de l'orientation du capteur de l'appareil photo dans l'appareil :

Kotlin

private val ORIENTATIONS = SparseIntArray()

init {
    ORIENTATIONS.append(Surface.ROTATION_0, 0)
    ORIENTATIONS.append(Surface.ROTATION_90, 90)
    ORIENTATIONS.append(Surface.ROTATION_180, 180)
    ORIENTATIONS.append(Surface.ROTATION_270, 270)
}

/**
 * Get the angle by which an image must be rotated given the device's current
 * orientation.
 */
@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
@Throws(CameraAccessException::class)
private fun getRotationCompensation(cameraId: String, activity: Activity, isFrontFacing: Boolean): Int {
    // Get the device's current rotation relative to its "native" orientation.
    // Then, from the ORIENTATIONS table, look up the angle the image must be
    // rotated to compensate for the device's rotation.
    val deviceRotation = activity.windowManager.defaultDisplay.rotation
    var rotationCompensation = ORIENTATIONS.get(deviceRotation)

    // Get the device's sensor orientation.
    val cameraManager = activity.getSystemService(CAMERA_SERVICE) as CameraManager
    val sensorOrientation = cameraManager
            .getCameraCharacteristics(cameraId)
            .get(CameraCharacteristics.SENSOR_ORIENTATION)!!

    if (isFrontFacing) {
        rotationCompensation = (sensorOrientation + rotationCompensation) % 360
    } else { // back-facing
        rotationCompensation = (sensorOrientation - rotationCompensation + 360) % 360
    }
    return rotationCompensation
}
MLKitVisionImage.kt

Java

private static final SparseIntArray ORIENTATIONS = new SparseIntArray();
static {
    ORIENTATIONS.append(Surface.ROTATION_0, 0);
    ORIENTATIONS.append(Surface.ROTATION_90, 90);
    ORIENTATIONS.append(Surface.ROTATION_180, 180);
    ORIENTATIONS.append(Surface.ROTATION_270, 270);
}

/**
 * Get the angle by which an image must be rotated given the device's current
 * orientation.
 */
@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
private int getRotationCompensation(String cameraId, Activity activity, boolean isFrontFacing)
        throws CameraAccessException {
    // Get the device's current rotation relative to its "native" orientation.
    // Then, from the ORIENTATIONS table, look up the angle the image must be
    // rotated to compensate for the device's rotation.
    int deviceRotation = activity.getWindowManager().getDefaultDisplay().getRotation();
    int rotationCompensation = ORIENTATIONS.get(deviceRotation);

    // Get the device's sensor orientation.
    CameraManager cameraManager = (CameraManager) activity.getSystemService(CAMERA_SERVICE);
    int sensorOrientation = cameraManager
            .getCameraCharacteristics(cameraId)
            .get(CameraCharacteristics.SENSOR_ORIENTATION);

    if (isFrontFacing) {
        rotationCompensation = (sensorOrientation + rotationCompensation) % 360;
    } else { // back-facing
        rotationCompensation = (sensorOrientation - rotationCompensation + 360) % 360;
    }
    return rotationCompensation;
}

Transmettez ensuite l'objet media.Image et la valeur du degré de rotation à InputImage.fromMediaImage() :

Kotlin

val image = InputImage.fromMediaImage(mediaImage, rotation)
MLKitVisionImage.kt

Java

InputImage image = InputImage.fromMediaImage(mediaImage, rotation);

Utiliser un URI de fichier

Pour créer un InputImage objet à partir d'un URI de fichier, transmettez le contexte de l'application et l'URI du fichier à InputImage.fromFilePath(). Cela est utile lorsque vous utilisez un intent ACTION_GET_CONTENT pour inviter l'utilisateur à sélectionner une image dans son application Galerie.

Kotlin

val image: InputImage
try {
    image = InputImage.fromFilePath(context, uri)
} catch (e: IOException) {
    e.printStackTrace()
}
MLKitVisionImage.kt

Java

InputImage image;
try {
    image = InputImage.fromFilePath(context, uri);
} catch (IOException e) {
    e.printStackTrace();
}

Utiliser un ByteBuffer ou un ByteArray

Pour créer un objet InputImage à partir d'un ByteBuffer ou d'un ByteArray, calculez d'abord le degré de rotation de l'image comme décrit précédemment pour l'entrée media.Image. Créez ensuite l'objet InputImage avec le tampon ou le tableau, ainsi que la hauteur, la largeur, le format d'encodage des couleurs et le degré de rotation de l'image :

Kotlin

val image = InputImage.fromByteBuffer(
        byteBuffer,
        /* image width */ 480,
        /* image height */ 360,
        rotationDegrees,
        InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12
)
MLKitVisionImage.kt
// Or:
val image = InputImage.fromByteArray(
        byteArray,
        /* image width */ 480,
        /* image height */ 360,
        rotationDegrees,
        InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12
)
MLKitVisionImage.kt

Java

InputImage image = InputImage.fromByteBuffer(byteBuffer,
        /* image width */ 480,
        /* image height */ 360,
        rotationDegrees,
        InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12
);
MLKitVisionImage.java
// Or:
InputImage image = InputImage.fromByteArray(
        byteArray,
        /* image width */480,
        /* image height */360,
        rotation,
        InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12
);
MLKitVisionImage.java

Utiliser un Bitmap

Pour créer un objet InputImage à partir d'un objet Bitmap, effectuez la déclaration suivante :

Kotlin

val image = InputImage.fromBitmap(bitmap, 0)
MLKitVisionImage.kt

Java

InputImage image = InputImage.fromBitmap(bitmap, rotationDegree);
MLKitVisionImage.java

L'image est représentée par un objet Bitmap ainsi que par des degrés de rotation.

3. Obtenir une instance de FaceDetector

Kotlin

val detector = FaceDetection.getClient(options)
// Or, to use the default option:
// val detector = FaceDetection.getClient();
FaceDetectionActivity.kt

Java

FaceDetector detector = FaceDetection.getClient(options);
// Or use the default options:
// FaceDetector detector = FaceDetection.getClient();
FaceDetectionActivity.java

4. Traiter l'image

Transmettez l'image à la méthode process :

Kotlin

val result = detector.process(image)
        .addOnSuccessListener { faces ->
            // Task completed successfully
            // ...
        }
        .addOnFailureListener { e ->
            // Task failed with an exception
            // ...
        }
FaceDetectionActivity.kt

Java

Task<List<Face>> result =
        detector.process(image)
                .addOnSuccessListener(
                        new OnSuccessListener<List<Face>>() {
                            @Override
                            public void onSuccess(List<Face> faces) {
                                // Task completed successfully
                                // ...
                            }
                        })
                .addOnFailureListener(
                        new OnFailureListener() {
                            @Override
                            public void onFailure(@NonNull Exception e) {
                                // Task failed with an exception
                                // ...
                            }
                        });
FaceDetectionActivity.java

Remarque : Si vous utilisez l'API CameraX, veillez à fermer l'ImageProxy lorsque vous avez terminé de l'utiliser, par exemple en ajoutant un OnCompleteListener à la Task renvoyée par la méthode process. Pour obtenir un exemple, consultez la classe VisionProcessorBase dans l'exemple d'application de démarrage rapide.

5. Obtenir des informations sur les visages détectés

Si l'opération de détection des visages réussit, une liste d' Face objets est transmise à l'écouteur de réussite. Chaque objet Face représente un visage détecté dans l'image. Pour chaque visage, vous pouvez obtenir ses coordonnées de délimitation dans l'image d'entrée, ainsi que toute autre information que vous avez configurée pour que le détecteur de visages trouve. Exemple :

Kotlin

for (face in faces) {
    val bounds = face.boundingBox
    val rotY = face.headEulerAngleY // Head is rotated to the right rotY degrees
    val rotZ = face.headEulerAngleZ // Head is tilted sideways rotZ degrees

    // If landmark detection was enabled (mouth, ears, eyes, cheeks, and
    // nose available):
    val leftEar = face.getLandmark(FaceLandmark.LEFT_EAR)
    leftEar?.let {
        val leftEarPos = leftEar.position
    }

    // If contour detection was enabled:
    val leftEyeContour = face.getContour(FaceContour.LEFT_EYE)?.points
    val upperLipBottomContour = face.getContour(FaceContour.UPPER_LIP_BOTTOM)?.points

    // If classification was enabled:
    if (face.smilingProbability != null) {
        val smileProb = face.smilingProbability
    }
    if (face.rightEyeOpenProbability != null) {
        val rightEyeOpenProb = face.rightEyeOpenProbability
    }

    // If face tracking was enabled:
    if (face.trackingId != null) {
        val id = face.trackingId
    }
}
FaceDetectionActivity.kt

Java

for (Face face : faces) {
    Rect bounds = face.getBoundingBox();
    float rotY = face.getHeadEulerAngleY();  // Head is rotated to the right rotY degrees
    float rotZ = face.getHeadEulerAngleZ();  // Head is tilted sideways rotZ degrees

    // If landmark detection was enabled (mouth, ears, eyes, cheeks, and
    // nose available):
    FaceLandmark leftEar = face.getLandmark(FaceLandmark.LEFT_EAR);
    if (leftEar != null) {
        PointF leftEarPos = leftEar.getPosition();
    }

    // If contour detection was enabled:
    List<PointF> leftEyeContour =
            face.getContour(FaceContour.LEFT_EYE).getPoints();
    List<PointF> upperLipBottomContour =
            face.getContour(FaceContour.UPPER_LIP_BOTTOM).getPoints();

    // If classification was enabled:
    if (face.getSmilingProbability() != null) {
        float smileProb = face.getSmilingProbability();
    }
    if (face.getRightEyeOpenProbability() != null) {
        float rightEyeOpenProb = face.getRightEyeOpenProbability();
    }

    // If face tracking was enabled:
    if (face.getTrackingId() != null) {
        int id = face.getTrackingId();
    }
}
FaceDetectionActivity.java

Exemple de contours de visage

Lorsque la détection des contours du visage est activée, vous obtenez une liste de points pour chaque caractéristique faciale détectée. Ces points représentent la forme de la caractéristique. Pour en savoir plus sur la représentation des contours, consultez la section Face Detection Concepts.

L'image suivante illustre la façon dont ces points sont mappés sur un visage. Cliquez sur l' image pour l'agrandir :

Détection des visages en temps réel

Si vous souhaitez utiliser la détection des visages dans une application en temps réel, suivez ces consignes pour obtenir les meilleures fréquences d'images :

• Configurez le détecteur de visages pour qu'il utilise la détection des contours du visage ou la classification et la détection des points de repère, mais pas les deux :

  Détection des contours
  Détection des points de repère
  Classification
  Détection des points de repère et classification
  Détection des contours et des points de repère
  Détection des contours et classification
  Détection des contours, des points de repère et classification
  

• Activez le mode FAST (activé par défaut).

• Envisagez de capturer des images à une résolution inférieure. Toutefois, gardez également à l'esprit les exigences de dimension d'image de cette API.

Si vous utilisez l'API Camera ou camera2, limitez les appels au détecteur. Si une nouvelle image vidéo devient disponible pendant l'exécution du détecteur, supprimez l'image. Pour obtenir un exemple, consultez la classe VisionProcessorBase dans l'exemple d'application de démarrage rapide.

Si vous utilisez l'API CameraX, assurez-vous que la stratégie de contre-pression est définie sur sa valeur par défaut ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST. Cela garantit qu'une seule image sera fournie pour l'analyse à la fois. Si d'autres images sont produites lorsque l'analyseur est occupé, elles seront automatiquement supprimées et ne seront pas mises en file d'attente pour la livraison. Une fois que l'image analysée est fermée en appelant ImageProxy.close(), la dernière image la plus récente est fournie.

Si vous utilisez la sortie du détecteur pour superposer des graphiques sur l'image d'entrée, obtenez d'abord le résultat de ML Kit, puis effectuez le rendu de l'image et de la superposition en une seule étape. Le rendu n'est effectué qu'une seule fois sur la surface d'affichage pour chaque image d'entrée. Pour obtenir un exemple, consultez les classes CameraSourcePreview et GraphicOverlay dans l'application exemple de démarrage rapide.

Si vous utilisez l'API Camera2, capturez des images au format ImageFormat.YUV_420_888 Si vous utilisez l'ancienne API Camera, capturez des images au ImageFormat.NV21 format.