Détecter les informations de réseau maillé faciale avec ML Kit sur Android

Cette API est proposée en version bêta. Elle n'est sujette à aucun contrat de niveau de service ni aucun règlement relatif aux abandons. Des modifications susceptibles d'affecter la rétrocompatibilité peuvent être apportées à cette API.

Vous pouvez utiliser ML Kit pour détecter les visages dans des images et des vidéos semblables à celles d'un selfie.

Cette API utilise une bibliothèque intégrée qui augmente la taille de votre application. Pour en savoir plus, consultez ce guide.

API de détection des maillages de visages
Nom du SDK	face-mesh-detection
Implémentation	Le code et les éléments sont associés de manière statique à votre application au moment de la compilation.
Impact sur la taille de l'application	~6,4 Mo
Performances	En temps réel sur la plupart des appareils.

Essayer

• Jouez avec l'application exemple pour voir un exemple d'utilisation de cette API.

Avant de commencer

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

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

2. Ajoutez la dépendance de la bibliothèque de détection de maillages de visages ML Kit au fichier Gradle au niveau de l'application de votre module, qui est généralement app/build.gradle:

   dependencies {
    // ...
   
    implementation 'com.google.mlkit:face-mesh-detection:16.0.0-beta1'
   }
   

Consignes pour les images d'entrée

1. Les images doivent être prises dans un rayon d'environ deux mètres de la caméra de l'appareil, afin que les visages soient suffisamment grands pour une reconnaissance optimale du maillage. En général, plus le visage est grand, meilleure est la reconnaissance des mailles du visage.

2. Le visage doit être face à la caméra, et au moins la moitié de votre visage doit être visible. Tout gros objet situé entre le visage et l'appareil photo peut réduire la précision.

Si vous souhaitez détecter des visages dans une application en temps réel, vous devez également prendre en compte les dimensions globales de l'image d'entrée. Les images de petite taille peuvent être traitées plus rapidement. Par conséquent, la capture d'images à des résolutions inférieures réduit la latence. Toutefois, tenez compte des exigences de précision ci-dessus et assurez-vous que le visage du sujet occupe une grande partie de l'image possible.

Configurer le détecteur de grilles faciale

Si vous souhaitez modifier les paramètres par défaut du détecteur de maillage de visages, spécifiez-les avec un objet FaceMeshDetectorOptions. Vous pouvez modifier les paramètres suivants:

1. setUseCase

   • BOUNDING_BOX_ONLY: ne fournit un cadre de délimitation qu'à un maillage de visages détecté. Il s'agit du détecteur de visages le plus rapide, mais sa portée est limitée(les visages doivent se trouver dans un rayon d'environ 2 mètres de la caméra).

   • FACE_MESH (option par défaut): fournit un cadre de délimitation et des informations supplémentaires sur le maillage de visages (468 points 3D et informations sur les triangles). Par rapport au cas d'utilisation BOUNDING_BOX_ONLY, la latence augmente d'environ 15%, comme mesuré sur le Pixel 3.

Exemple :

Kotlin

val defaultDetector = FaceMeshDetection.getClient(
  FaceMeshDetectorOptions.DEFAULT_OPTIONS)

val boundingBoxDetector = FaceMeshDetection.getClient(
  FaceMeshDetectorOptions.Builder()
    .setUseCase(UseCase.BOUNDING_BOX_ONLY)
    .build()
)

Java

FaceMeshDetector defaultDetector =
        FaceMeshDetection.getClient(
                FaceMeshDetectorOptions.DEFAULT_OPTIONS);

FaceMeshDetector boundingBoxDetector = FaceMeshDetection.getClient(
        new FaceMeshDetectorOptions.Builder()
                .setUseCase(UseCase.BOUNDING_BOX_ONLY)
                .build()
        );

Préparer l'image d'entrée

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

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

Vous pouvez créer un objet InputImage à partir de différentes sources, qui sont expliquées 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 Camera 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 indique 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 de 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 objet InputImage à 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 de 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 élément ByteBuffer ou 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 associé à des degrés de rotation.

Traiter l'image

Transmettez l'image à la méthode process:

Kotlin

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

Java

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

Obtenir des informations sur la grille faciale détectée

Si un visage est détecté dans l'image, une liste d'objets FaceMesh est transmise à l'écouteur de réussite. Chaque FaceMesh représente un visage détecté dans l'image. Pour chaque maillage de visages, vous pouvez obtenir ses coordonnées de délimitation dans l'image d'entrée, ainsi que toutes les autres informations que vous avez configuré le détecteur de maillage de visages à trouver.

Kotlin

for (faceMesh in faceMeshs) {
    val bounds: Rect = faceMesh.boundingBox()

    // Gets all points
    val faceMeshpoints = faceMesh.allPoints
    for (faceMeshpoint in faceMeshpoints) {
      val index: Int = faceMeshpoints.index()
      val position = faceMeshpoint.position
    }

    // Gets triangle info
    val triangles: List<Triangle<FaceMeshPoint>> = faceMesh.allTriangles
    for (triangle in triangles) {
      // 3 Points connecting to each other and representing a triangle area.
      val connectedPoints = triangle.allPoints()
    }
}

Java

for (FaceMesh faceMesh : faceMeshs) {
    Rect bounds = faceMesh.getBoundingBox();

    // Gets all points
    List<FaceMeshPoint> faceMeshpoints = faceMesh.getAllPoints();
    for (FaceMeshPoint faceMeshpoint : faceMeshpoints) {
        int index = faceMeshpoints.getIndex();
        PointF3D position = faceMeshpoint.getPosition();
    }

    // Gets triangle info
    List<Triangle<FaceMeshPoint>> triangles = faceMesh.getAllTriangles();
    for (Triangle<FaceMeshPoint> triangle : triangles) {
        // 3 Points connecting to each other and representing a triangle area.
        List<FaceMeshPoint> connectedPoints = triangle.getAllPoints();
    }
}