Vous pouvez utiliser ML Kit pour détecter des visages dans des images et des vidéos.
Fonctionnalité | Sans catégorie | Groupée |
---|---|---|
Implémentation | Le modèle est téléchargé de manière dynamique via les services Google Play. | Le modèle est associé de manière statique à votre application au moment de la compilation. |
Taille de l'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 l'utiliser pour la première fois. | Le modèle est disponible immédiatement |
Essayer
- Testez l'application exemple pour : consultez un exemple d'utilisation de cette API.
- Essayez vous-même le code avec le atelier de programmation.
Avant de commencer
Dans le fichier
build.gradle
au niveau du projet, veillez à inclure l'adresse e-mail de Google Dépôt Maven dans les sectionsbuildscript
etallprojects
.Ajoutez les dépendances des bibliothèques Android ML Kit au fichier fichier Gradle au niveau de l'application, généralement
app/build.gradle
. Choisissez l'une des options les dépendances suivantes en fonction de vos besoins:Pour regrouper le modèle avec votre application:
dependencies { // ... // Use this dependency to bundle the model with your app implementation 'com.google.mlkit:face-detection:16.1.7' }
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 télécharger automatiquement le modèle sur l'appareil une fois l'application installé depuis le Play Store. Pour ce faire, ajoutez la déclaration suivante au fichier le 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 aussi vérifier explicitement la disponibilité du modèle et demander un téléchargement via API ModuleInstallClient des services Google Play.
Si vous n'activez pas le téléchargement du modèle au moment de l'installation ou le modèle est téléchargé la première fois que vous exécutez le détecteur. Demandes que vous effectuez avant la fin du téléchargement ne produit 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 détecte les visages avec précision, les images d'entrée doivent contenir des visages représentées par suffisamment de données de pixels. En général, chaque visage que vous souhaitez à détecter dans une image doivent être d'au moins 100 x 100 pixels. Si vous souhaitez détecter les contours des visages, ML Kit nécessite une résolution plus élevée: chaque visage elle doit faire au moins 200 x 200 pixels.
Si vous détectez des visages dans une application en temps réel, vous pouvez également pour prendre en compte les dimensions globales des images d'entrée. Les images plus petites peuvent être sont traitées plus rapidement, ce qui permet de réduire la latence, de capturer des images à des résolutions inférieures, gardez à l'esprit les exigences de précision ci-dessus et assurez-vous que le visage du sujet occupe le plus d'espace possible dans l'image. Voir aussi conseils pour améliorer les performances en temps réel.
Une mauvaise mise au point de l'image peut également nuire à sa précision. Si vous n'obtenez pas dans les résultats, demandez à l'utilisateur de capturer à nouveau l'image.
L'orientation d'un visage par rapport à l'appareil photo peut aussi avoir une incidence sur le comportement détecte les caractéristiques détectées par ML Kit. Voir Concepts de détection de visages.
1. Configurer le détecteur de visages
Avant d'appliquer la détection des visages à une image, vous pouvez modifier les paramètres paramètres par défaut du détecteur de visages, spécifiez ces paramètres à l'aide d'une 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
Tentative d'identification des "points de repère" du visage : yeux, oreilles, nez, les joues, la bouche, etc. |
setContourMode
|
CONTOUR_MODE_NONE (par défaut)
|
CONTOUR_MODE_ALL
Permet de détecter ou non les contours des traits du visage. Les contours sont détecté uniquement pour le visage le plus proéminent d'une image. |
setClassificationMode
|
CLASSIFICATION_MODE_NONE (par défaut)
|
CLASSIFICATION_MODE_ALL
classer les visages en 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 en tant que ratio des la largeur de la tête par rapport à celle de l'image. |
enableTracking
|
false (par défaut) | true
Permet d'attribuer ou non aux visages un ID qui peut être utilisé pour suivre visages sur les images. Notez que lorsque la détection des contours est activée, un seul visage est détecté, le suivi des visages ne produit donc pas de résultats utiles. Pour cette et pour améliorer la vitesse de détection, n'activez pas les deux 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 sur une image, créez un objetInputImage
à partir d'un Bitmap
, d'un media.Image
, d'un ByteBuffer
, d'un tableau d'octets ou d'un fichier sur
l'appareil. Ensuite, transmettez l'objet InputImage
à la
La méthode process
de FaceDetector
.
Pour la détection de visages, utilisez 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
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
.
Ensuite, créez 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.
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 réussit, une liste de Les objetsFace
sont transmis à la table
l'écouteur. Chaque objet Face
représente un visage détecté.
dans l'image. Pour chaque face, vous pouvez obtenir ses coordonnées de délimitation dans l'entrée
ainsi que toute autre information que vous avez configurée
trouver. 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 d'un visage
Lorsque la détection des contours du visage est activée, vous obtenez une liste de points pour chaque caractéristique faciale détectée. Ces points représentent la forme . Voir Visage Concepts de détection pour en savoir plus sur la façon dont les contours représentées.
L'image suivante montre comment ces points sont mappés à une face. Cliquez sur l'icône 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 pour obtenir des fréquences d'images optimales:
Configurez le détecteur de visages pour utiliser la détection ou la classification du contour du visage et la détection de points de repère, mais pas les deux:
Détection de contours
Détection de points de repère
Classification
Détection et classification des points de repère
Détection de contours et de points de repère
Détection et classification de contours
Détection de contours, détection de points de repère et classificationActivez le mode
FAST
(activé par défaut).Envisagez de capturer des images à une résolution plus faible. Cependant, gardez aussi à l'esprit aux exigences de cette API concernant les dimensions de l'image.
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.
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 envoyée.
CameraSourcePreview
et
GraphicOverlay
de l'application exemple de démarrage rapide.
ImageFormat.YUV_420_888
. Si vous utilisez l'ancienne API Camera, capturez les images
Format ImageFormat.NV21
.