Vous pouvez utiliser ML Kit pour détecter les visages dans des images et des vidéos.
Caractéristique | Sans groupe | Groupée |
---|---|---|
Implémentation | Le modèle est téléchargé dynamiquement via les services Google Play. | Le modèle est associé de manière statique à votre application au moment de la compilation. |
Taille d'application | Augmentation de la taille d'environ 800 Ko. | Augmentation de la taille d'environ 6,9 Mo. |
Délai d'initialisation | Vous devrez peut-être attendre que le modèle soit téléchargé avant de la première utilisation. | Le modèle est disponible immédiatement |
Essayer
- Testez l'application exemple pour voir un exemple d'utilisation de cette API.
- Essayez de coder vous-même dans cet atelier de programmation.
Avant de commencer
Dans le fichier
build.gradle
au niveau du projet, veillez à inclure le dépôt Maven de Google dans les sectionsbuildscript
etallprojects
.Ajoutez les dépendances des bibliothèques Android de ML Kit au fichier Gradle au niveau de l'application de votre module (généralement
app/build.gradle
). Choisissez l'une des dépendances suivantes en fonction de vos besoins:Pour regrouper le modèle dans votre application:
dependencies { // ... // Use this dependency to bundle the model with your app implementation 'com.google.mlkit:face-detection:16.1.5' }
Pour utiliser le modèle dans les services Google Play:
dependencies { // ... // Use this dependency to use the dynamically downloaded model in Google Play Services implementation 'com.google.android.gms:play-services-mlkit-face-detection:17.1.0' }
Si vous choisissez d'utiliser le modèle dans les services Google Play, vous pouvez configurer votre application pour qu'elle télécharge automatiquement le modèle sur l'appareil une fois votre application installée depuis le Play Store. Pour ce faire, ajoutez la déclaration suivante au fichier
AndroidManifest.xml
de votre application:<application ...> ... <meta-data android:name="com.google.mlkit.vision.DEPENDENCIES" android:value="face" > <!-- To use multiple models: android:value="face,model2,model3" --> </application>
Vous pouvez également vérifier explicitement la disponibilité du modèle et demander son téléchargement via l'API ModuleInstallClient des services Google Play.
Si vous n'activez pas les téléchargements de modèles au moment de l'installation ou ne demandez pas de téléchargement explicite, le modèle est téléchargé la première fois que vous exécutez le détecteur. Les requêtes que vous effectuez avant la fin du téléchargement ne produisent aucun résultat.
Consignes pour les images d'entrée
Pour la reconnaissance faciale, vous devez utiliser une image d'au moins 480 x 360 pixels. Pour que ML Kit puisse détecter avec précision les visages, les images d'entrée doivent contenir des visages représentés par un volume de données de pixels suffisant. En règle générale, la taille de chaque visage à détecter dans une image doit être d'au moins 100 x 100 pixels. Si vous souhaitez détecter les contours de visages, ML Kit nécessite une entrée de résolution plus élevée: chaque face doit faire au moins 200 x 200 pixels.
Si vous détectez des visages dans une application en temps réel, vous pouvez également prendre en compte les dimensions globales des images d'entrée. Les images de petite taille peuvent être traitées plus rapidement. Pour réduire la latence, capturez des images à des résolutions inférieures, mais gardez à l'esprit les exigences de précision ci-dessus et assurez-vous que le visage du sujet occupe autant de place que possible dans l'image. Consultez également nos conseils pour améliorer les performances en temps réel.
Une mise au point médiocre 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.
L'orientation d'un visage par rapport à la caméra peut également avoir une incidence sur les caractéristiques faciales détectées par ML Kit. Consultez la page Concepts de détection de visages.
1. Configurer la détection de visages
Avant d'appliquer la détection des visages à une image, si vous souhaitez modifier l'un des paramètres par défaut du détecteur de visages, spécifiez-le avec un objetFaceDetectorOptions
.
Vous pouvez modifier les paramètres suivants:
Paramètres | |
---|---|
setPerformanceMode
|
PERFORMANCE_MODE_FAST (par défaut) |
PERFORMANCE_MODE_ACCURATE
Privilégiez la vitesse ou la précision lors de la détection des visages. |
setLandmarkMode
|
LANDMARK_MODE_NONE (par défaut) |
LANDMARK_MODE_ALL
Indique s'il faut tenter d'identifier les points de repère sur les visages : yeux, oreilles, nez, joues, bouche, etc. |
setContourMode
|
CONTOUR_MODE_NONE (par défaut) |
CONTOUR_MODE_ALL
Détecter ou non les contours des traits du visage Les contours ne sont détectés que pour le visage le plus proéminent dans une image. |
setClassificationMode
|
CLASSIFICATION_MODE_NONE (par défaut) |
CLASSIFICATION_MODE_ALL
Indique si les visages doivent être classés dans des catégories telles que "souriant" et "yeux ouverts". |
setMinFaceSize
|
float (par défaut: 0.1f )
Définit la plus petite taille de visage souhaitée, exprimée sous la forme du rapport entre la largeur de la tête et la largeur de l'image. |
enableTracking
|
false (par défaut) | true
Indique si les visages doivent être attribués ou non à un ID, qui peut être utilisé pour suivre les visages sur l'ensemble des images. Notez que lorsque la détection du contour est activée, un seul visage est détecté. Le suivi des visages ne génère donc pas de résultats utiles. C'est pourquoi, et afin d'améliorer la vitesse de détection, n'activez pas à la fois la détection du contour et le suivi des visages. |
Exemple :
Kotlin
// High-accuracy landmark detection and face classification val highAccuracyOpts = FaceDetectorOptions.Builder() .setPerformanceMode(FaceDetectorOptions.PERFORMANCE_MODE_ACCURATE) .setLandmarkMode(FaceDetectorOptions.LANDMARK_MODE_ALL) .setClassificationMode(FaceDetectorOptions.CLASSIFICATION_MODE_ALL) .build() // Real-time contour detection val realTimeOpts = FaceDetectorOptions.Builder() .setContourMode(FaceDetectorOptions.CONTOUR_MODE_ALL) .build()
Java
// High-accuracy landmark detection and face classification FaceDetectorOptions highAccuracyOpts = new FaceDetectorOptions.Builder() .setPerformanceMode(FaceDetectorOptions.PERFORMANCE_MODE_ACCURATE) .setLandmarkMode(FaceDetectorOptions.LANDMARK_MODE_ALL) .setClassificationMode(FaceDetectorOptions.CLASSIFICATION_MODE_ALL) .build(); // Real-time contour detection FaceDetectorOptions realTimeOpts = new FaceDetectorOptions.Builder() .setContourMode(FaceDetectorOptions.CONTOUR_MODE_ALL) .build();
2. Préparer l'image d'entrée
Pour détecter les visages dans une image, créez un objetInputImage
à partir d'un Bitmap
, media.Image
, 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 de visages, vous devez utiliser une image d'au moins 480 x 360 pixels. Si vous détectez des visages en temps réel, la capture d'images à cette résolution minimale peut contribuer à réduire la latence.
Vous pouvez créer un objet InputImage
à partir de différentes sources, chacune 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 avec 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.
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 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 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 ByteBuffer
ou d'un ByteArray
, commencez par calculer 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
accompagné de degrés de rotation.
3. Obtenir une instance de FaceDetector
Kotlin
val detector = FaceDetection.getClient(options) // Or, to use the default option: // val detector = FaceDetection.getClient();
Java
FaceDetector detector = FaceDetection.getClient(options); // Or use the default options: // FaceDetector detector = FaceDetection.getClient();
4. Traiter l'image
Transmettez l'image à la méthodeprocess
:
Kotlin
val result = detector.process(image) .addOnSuccessListener { faces -> // Task completed successfully // ... } .addOnFailureListener { e -> // Task failed with an exception // ... }
Java
Task<List<Face>> result = detector.process(image) .addOnSuccessListener( new OnSuccessListener<List<Face>>() { @Override public void onSuccess(List<Face> faces) { // Task completed successfully // ... } }) .addOnFailureListener( new OnFailureListener() { @Override public void onFailure(@NonNull Exception e) { // Task failed with an exception // ... } });
5. Obtenir des informations sur les visages détectés
Si l'opération de détection de visages aboutit, une liste d'objetsFace
est transmise à l'écouteur de réussite. Chaque objet Face
représente un visage détecté dans l'image. Pour chaque visage, 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ées pour le détecteur de visages. Exemple :
Kotlin
for (face in faces) { val bounds = face.boundingBox val rotY = face.headEulerAngleY // Head is rotated to the right rotY degrees val rotZ = face.headEulerAngleZ // Head is tilted sideways rotZ degrees // If landmark detection was enabled (mouth, ears, eyes, cheeks, and // nose available): val leftEar = face.getLandmark(FaceLandmark.LEFT_EAR) leftEar?.let { val leftEarPos = leftEar.position } // If contour detection was enabled: val leftEyeContour = face.getContour(FaceContour.LEFT_EYE)?.points val upperLipBottomContour = face.getContour(FaceContour.UPPER_LIP_BOTTOM)?.points // If classification was enabled: if (face.smilingProbability != null) { val smileProb = face.smilingProbability } if (face.rightEyeOpenProbability != null) { val rightEyeOpenProb = face.rightEyeOpenProbability } // If face tracking was enabled: if (face.trackingId != null) { val id = face.trackingId } }
Java
for (Face face : faces) { Rect bounds = face.getBoundingBox(); float rotY = face.getHeadEulerAngleY(); // Head is rotated to the right rotY degrees float rotZ = face.getHeadEulerAngleZ(); // Head is tilted sideways rotZ degrees // If landmark detection was enabled (mouth, ears, eyes, cheeks, and // nose available): FaceLandmark leftEar = face.getLandmark(FaceLandmark.LEFT_EAR); if (leftEar != null) { PointF leftEarPos = leftEar.getPosition(); } // If contour detection was enabled: List<PointF> leftEyeContour = face.getContour(FaceContour.LEFT_EYE).getPoints(); List<PointF> upperLipBottomContour = face.getContour(FaceContour.UPPER_LIP_BOTTOM).getPoints(); // If classification was enabled: if (face.getSmilingProbability() != null) { float smileProb = face.getSmilingProbability(); } if (face.getRightEyeOpenProbability() != null) { float rightEyeOpenProb = face.getRightEyeOpenProbability(); } // If face tracking was enabled: if (face.getTrackingId() != null) { int id = face.getTrackingId(); } }
Exemple de contours du visage
Lorsque la détection du contour du visage est activée, vous obtenez une liste de points pour chaque caractéristique du visage détectée. Ces points représentent la forme de l'élément géographique. Pour en savoir plus sur la représentation des contours, consultez la page Concepts de détection de visages.
L'image suivante montre comment ces points correspondent à un visage. Cliquez sur l'image pour l'agrandir:
Détection des visages en temps réel
Si vous souhaitez utiliser la détection de visages dans une application en temps réel, suivez ces consignes pour obtenir les meilleures fréquences d'images:
Configurez le détecteur de visages pour qu'il utilise soit la détection du contour du visage, soit la classification et la détection des points de repère, mais pas les deux:
Détection de contours
Détection de points de repère
Classification
Détection et classification de points de repère
Détection de contours et détection de points de repère
Détection et classification de contours
Détection et classification de contoursActivez le mode
FAST
(activé par défaut).Envisagez de capturer des images à une résolution inférieure. Toutefois, gardez également à l'esprit les exigences de cette API concernant les dimensions d'image.
Camera
ou camera2
, limitez les appels au détecteur. Si une nouvelle image vidéo devient disponible pendant que le détecteur est en cours d'exécution, déposez l'image. Consultez la classe
VisionProcessorBase
dans l'exemple d'application de démarrage rapide pour un exemple.
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 d'autres images sont produites lorsque l'analyseur est occupé, elles sont automatiquement supprimées et ne sont pas mises en file d'attente pour la diffusion. Une fois l'image en cours d'analyse fermée en appelant ImageProxy.close(), la dernière image suivante est diffusée.
CameraSourcePreview
et
GraphicOverlay
dans l'exemple d'application de démarrage rapide pour voir un exemple.
ImageFormat.YUV_420_888
. Si vous utilisez l'ancienne API Camera, capturez des images au format ImageFormat.NV21
.