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

<ph type="x-smartling-placeholder">

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

<ph type="x-smartling-placeholder">
API de détection des maillages de visages
Nom du SDKface-mesh-detection
ImplémentationLe 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
PerformancesEn temps réel sur la plupart des appareils.

Essayer

Avant de commencer

<ph type="x-smartling-placeholder">
  1. Dans le fichier build.gradle au niveau du projet, veillez à inclure l'adresse e-mail de Google dans les sections "buildscript" et "allprojects".

  2. Ajoutez la dépendance de la bibliothèque de détection des grilles faciales de ML Kit à votre fichier Gradle au niveau de l'application du 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 photos doivent être prises dans un rayon d'environ deux mètres de l'appareil photo. que les visages sont suffisamment grands pour une reconnaissance optimale des grilles faciales. Dans plus le visage est grand, plus la reconnaissance des mailles du visage est pertinente.

  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 entraîner une chute précision.

Pour détecter les visages dans une application en temps réel, vous devez également tenir compte des dimensions globales de l'image d'entrée. Les images plus petites peuvent être traités plus rapidement. La capture d'images à des résolutions inférieures réduit donc la latence. Gardez toutefois à l'esprit les exigences de précision ci-dessus et assurez-vous le visage du sujet occupe le plus d'espace possible dans l'image.

Configurer le détecteur de grilles faciale

Si vous souhaitez modifier les paramètres par défaut du détecteur de grilles faciale, indiquez ces paramètres avec une 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 avec une portée limitée doit 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 une face supplémentaire. Informations sur le réseau maillé (468 points 3D et informations sur les triangles) Par rapport aux BOUNDING_BOX_ONLY : la latence augmente d'environ 15%, comme mesuré sur 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 sur une image, créez un objet InputImage à partir d'un Bitmap, media.Image, ByteBuffer, tableau d'octets ou 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, à cette résolution minimale peut aider à réduire la latence.

Vous pouvez créer un InputImage de différentes sources. Chacune d'elles est expliquée ci-dessous.

Utiliser un media.Image

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

Si vous utilisez les <ph type="x-smartling-placeholder"></ph> la bibliothèque CameraX, les OnImageCapturedListener et Les classes 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'appareils photo qui indique le degré de rotation de l'image, le calcul à partir du degré de rotation de l'appareil et de l'orientation de la caméra capteur 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
}

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;
}

Ensuite, transmettez l'objet media.Image et valeur du degré de rotation sur InputImage.fromMediaImage():

Kotlin

val image = InputImage.fromMediaImage(mediaImage, rotation)

Java

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

Utiliser un URI de fichier

Pour créer un 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 Utiliser un intent ACTION_GET_CONTENT pour inviter l'utilisateur à sélectionner une image de son application Galerie.

Kotlin

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

Java

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

Utiliser un ByteBuffer ou un ByteArray

Pour créer un InputImage d'un objet ByteBuffer ou ByteArray, calculez d'abord l'image degré de rotation 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 l'objet image la hauteur, la largeur, le format d'encodage des couleurs et le degré de rotation:

Kotlin

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

Java

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

Utiliser un Bitmap

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

Kotlin

val image = InputImage.fromBitmap(bitmap, 0)

Java

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

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 le l'image. Pour chaque maillage de visages, vous pouvez obtenir ses coordonnées de délimitation dans l'entrée ainsi que toute autre information permettant de configurer le maillage à 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();
    }
}