Segmentation des selfies avec ML Kit sur Android

ML Kit fournit un SDK optimisé pour la segmentation par selfie.

Les composants du segment de selfie sont associés de manière statique à votre application au moment de la compilation. Cela augmentera la taille de téléchargement de votre application d'environ 4,5 Mo et la latence de l'API pourra varie de 25 ms à 65 ms selon la taille de l'image d'entrée, mesurée sur un Pixel 4.

Essayer

Avant de commencer

  1. Dans le fichier build.gradle au niveau du projet, veillez à inclure le dépôt Maven de Google à la fois dans vos 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:
dependencies {
  implementation 'com.google.mlkit:segmentation-selfie:16.0.0-beta5'
}

1. Créer une instance de Segmenter

Options du segmenteur

Pour segmenter une image, commencez par créer une instance de Segmenter en spécifiant les options suivantes.

Mode détecteur

Segmenter fonctionne dans deux modes. Veillez à choisir celle qui correspond à votre cas d'utilisation.

STREAM_MODE (default)

Ce mode est conçu pour diffuser les images de la vidéo ou de la caméra. Dans ce mode, le segmenteur exploite les résultats des frames précédents pour renvoyer des résultats de segmentation plus fluides.

SINGLE_IMAGE_MODE

Ce mode est conçu pour les images uniques qui ne sont pas liées. Dans ce mode, le segmenteur traite chaque image indépendamment, sans lissage sur les images.

Activer le masque de taille brute

Il demande au segmenteur de renvoyer le masque de taille brute qui correspond à la taille de sortie du modèle.

La taille du masque brut (par exemple, 256 x 256) est généralement inférieure à la taille de l'image d'entrée. Veuillez appeler SegmentationMask#getWidth() et SegmentationMask#getHeight() pour obtenir la taille du masque lorsque vous activez cette option.

Si vous ne spécifiez pas cette option, le segmenteur redimensionne le masque brut pour qu'il corresponde à la taille de l'image d'entrée. Utilisez cette option si vous souhaitez appliquer une logique de rescaling personnalisée ou si le redimensionnement n'est pas nécessaire pour votre cas d'utilisation.

Spécifiez les options du segmenteur:

Kotlin

val options =
        SelfieSegmenterOptions.Builder()
            .setDetectorMode(SelfieSegmenterOptions.STREAM_MODE)
            .enableRawSizeMask()
            .build()

Java

SelfieSegmenterOptions options =
        new SelfieSegmenterOptions.Builder()
            .setDetectorMode(SelfieSegmenterOptions.STREAM_MODE)
            .enableRawSizeMask()
            .build();

Créez une instance de Segmenter. Transmettez les options que vous avez spécifiées:

Kotlin

val segmenter = Segmentation.getClient(options)

Java

Segmenter segmenter = Segmentation.getClient(options);

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

Pour effectuer une segmentation sur 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.

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

Ensuite, transmettez l'objet media.Image et valeur du degré de rotation sur 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 à 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()
}
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 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
)
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 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.

3. Traiter l'image

Transmettez l'objet InputImage préparé à la méthode process de Segmenter.

Kotlin

Task<SegmentationMask> result = segmenter.process(image)
       .addOnSuccessListener { results ->
           // Task completed successfully
           // ...
       }
       .addOnFailureListener { e ->
           // Task failed with an exception
           // ...
       }

Java

Task<SegmentationMask> result =
        segmenter.process(image)
                .addOnSuccessListener(
                        new OnSuccessListener<SegmentationMask>() {
                            @Override
                            public void onSuccess(SegmentationMask mask) {
                                // Task completed successfully
                                // ...
                            }
                        })
                .addOnFailureListener(
                        new OnFailureListener() {
                            @Override
                            public void onFailure(@NonNull Exception e) {
                                // Task failed with an exception
                                // ...
                            }
                        });

4. Obtenir le résultat de la segmentation

Vous pouvez obtenir le résultat de la segmentation comme suit:

Kotlin

val mask = segmentationMask.getBuffer()
val maskWidth = segmentationMask.getWidth()
val maskHeight = segmentationMask.getHeight()

for (val y = 0; y < maskHeight; y++) {
  for (val x = 0; x < maskWidth; x++) {
    // Gets the confidence of the (x,y) pixel in the mask being in the foreground.
    val foregroundConfidence = mask.getFloat()
  }
}

Java

ByteBuffer mask = segmentationMask.getBuffer();
int maskWidth = segmentationMask.getWidth();
int maskHeight = segmentationMask.getHeight();

for (int y = 0; y < maskHeight; y++) {
  for (int x = 0; x < maskWidth; x++) {
    // Gets the confidence of the (x,y) pixel in the mask being in the foreground.
    float foregroundConfidence = mask.getFloat();
  }
}

Pour obtenir un exemple complet d'utilisation des résultats de segmentation, consultez la Exemple de démarrage rapide avec ML Kit

Conseils pour améliorer les performances

La qualité des résultats dépend de la qualité de l'image d'entrée:

  • Pour que ML Kit obtienne un résultat de segmentation précis, l'image doit faire au moins 256 x 256 pixels.
  • Une mauvaise mise au point de l'image peut également nuire à sa précision. Si les résultats ne sont pas satisfaisants, demandez à l'utilisateur de reprendre l'image.

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

  • Utilisez STREAM_MODE.
  • Envisagez de capturer des images à une résolution plus faible. Cependant, gardez également à l'esprit les exigences de cette API concernant les dimensions de l'image.
  • Envisagez d'activer l'option de masque de taille brute et de combiner toute la logique de rescaling. Par exemple, au lieu de laisser l'API redimensionner le masque pour qu'il corresponde à la taille de votre image d'entrée, puis de le redimensionner à nouveau pour qu'il corresponde à la taille de la vue à afficher, il vous suffit de demander le masque de taille brute et de combiner ces deux étapes en une seule.
  • Si vous utilisez les Camera ou API camera2 limiter les appels au détecteur. Si une nouvelle vidéo devient disponible pendant l'exécution du détecteur, supprimez la trame. Consultez le VisionProcessorBase de l'application exemple 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 à la fois sera envoyée pour analyse. Si davantage d'images sont générées lorsque l'analyseur est occupé, elles sont automatiquement abandonnées et ne sont pas mises en file d'attente la livraison. Une fois que l'image en cours d'analyse est fermée en appelant ImageProxy.close(), l'image suivante la plus récente sera diffusée.
  • Si vous utilisez la sortie du détecteur pour superposer des graphiques sur l'image d'entrée, récupérez d'abord le résultat à partir de ML Kit, puis effectuez le rendu de l'image. et les superposer en une seule étape. Le rendu à la surface d'affichage une seule fois pour chaque trame d'entrée. Consultez le CameraSourcePreview et GraphicOverlay de l'application exemple de démarrage rapide.
  • Si vous utilisez l'API Camera2, capturez des images Format ImageFormat.YUV_420_888. Si vous utilisez l'ancienne API Camera, capturez les images Format ImageFormat.NV21.