Segmentation des selfies avec ML Kit sur Android

ML Kit fournit un SDK optimisé pour la segmentation des selfies.

Les composants du segmentateur de selfies sont liés de manière statique à votre application au moment de la compilation. Cela augmente la taille de téléchargement de votre application d'environ 4,5 Mo.La latence de l'API peut varier de 25 ms à 65 ms en fonction de la taille de l'image d'entrée, comme mesuré sur un Pixel 4.

Essayer

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

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 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 :

dependencies {
  implementation 'com.google.mlkit:segmentation-selfie:16.0.0-beta6'
}

1. Créer une instance de Segmenter

Options de Segmenter

Pour effectuer une segmentation sur une image, créez d'abord une instance de Segmenter en spécifiant les options suivantes.

Mode détecteur

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

STREAM_MODE (default)

Ce mode est conçu pour diffuser des frames à partir d'une vidéo ou d'une caméra. Dans ce mode, le segmentateur exploite les résultats des frames précédentes 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 segmentateur traite chaque image indépendamment, sans lissage sur les frames.

Activer le masque de taille brute

Demande au segmentateur de renvoyer le masque de taille brute qui correspond à la taille de sortie du modèle.

La taille brute du masque (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.

Sans spécifier cette option, le segmentateur redimensionne le masque brut pour qu'il corresponde à la taille de l'image d'entrée. Envisagez d'utiliser cette option si vous souhaitez appliquer une logique de redimensionnement personnalisée ou si le redimensionnement n'est pas nécessaire pour votre cas d'utilisation.

Spécifiez les options du segmentateur :

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

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 :

val segmenter = Segmentation.getClient(options)

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 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.

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
            // ...
        }
    }
}

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 :

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

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 la valeur du degré de rotation à InputImage.fromMediaImage() :

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

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 de galerie.

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

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. Ensuite, créez 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 :

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

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 :

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

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. Traiter l'image

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

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

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 :

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()
  }
}

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 le exemple de démarrage rapide de ML Kit.

Conseils pour améliorer les performances

La qualité de vos 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 avoir un impact sur la précision. Si vous n'obtenez pas de résultats acceptables, 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 inférieure. Toutefois, gardez également à l'esprit les exigences de cette API concernant les dimensions des images.
• Envisagez d'activer l'option de masque de taille brute et de combiner toute la logique de redimensionnement. Par exemple, au lieu de laisser l'API redimensionner d'abord 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, demandez simplement le masque de taille brute et combinez ces deux étapes en une seule.
• Si vous utilisez l'API Camera ou camera2, limitez les appels au détecteur. Si une nouvelle frame vidéo devient disponible pendant l'exécution du détecteur, supprimez la frame. Pour obtenir un exemple, consultez la classe VisionProcessorBase dans 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 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 sera 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 affichez l'image et la superposition en une seule étape. Cela n'affiche la surface d'affichage qu'une seule fois pour chaque frame 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.