Vous pouvez utiliser ML Kit pour détecter les visages dans des images et des vidéos semblables à celles d'un selfie.
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
Dans le fichier
build.gradle
au niveau du projet, veillez à inclure le dépôt Maven de Google dans les sections buildscript et allprojects.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
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.
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:
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'utilisationBOUNDING_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 }
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)
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() }
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 ) // 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 objet 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 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(); } }