Gesichter mit ML Kit für Android erkennen

Sie können ML Kit verwenden, um Gesichter in Bildern und Videos zu erkennen.

Jetzt ausprobieren

• Probieren Sie die Beispiel-App aus, um sehen Sie sich ein Anwendungsbeispiel für diese API an.
• Testen Sie den Code mit dem Codelab erhalten.

Hinweis

1. In der Datei build.gradle auf Projektebene müssen Sie die Parameter von Google Maven-Repository in den Abschnitten buildscript und allprojects.

2. Fügen Sie die Abhängigkeiten für die ML Kit-Android-Bibliotheken Ihres Moduls Gradle-Datei auf App-Ebene, in der Regel app/build.gradle. Wählen Sie eine der folgenden Optionen aus: die folgenden Abhängigkeiten verwenden:

   So bündeln Sie das Modell mit Ihrer App:

   dependencies {
     // ...
     // Use this dependency to bundle the model with your app
     implementation 'com.google.mlkit:face-detection:16.1.7'
   }
   

   Verwendung des Modells in den Google Play-Diensten:

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

3. Wenn Sie das Modell in den Google Play-Diensten verwenden möchten, können Sie wird das Modell automatisch auf das Gerät heruntergeladen, aus dem Play Store installiert haben. Fügen Sie dazu die folgende Deklaration der Datei AndroidManifest.xml Ihrer App:

   <application ...>
         ...
         <meta-data
             android:name="com.google.mlkit.vision.DEPENDENCIES"
             android:value="face" >
         <!-- To use multiple models: android:value="face,model2,model3" -->
   </application>
   

   Sie können die Modellverfügbarkeit auch explizit prüfen und den Download über Die Google Play-Dienste ModuleInstallClient API.

   Wenn Sie das Herunterladen von Modellen bei der Installation nicht aktivieren oder einen expliziten Download anfordern, wird das Modell heruntergeladen, wenn Sie den Detektor zum ersten Mal ausführen. Von Ihnen gestellte Anfragen bevor der Download abgeschlossen ist, keine Ergebnisse liefern.

Richtlinien für Eingabebilder

Für die Gesichtserkennung sollten Sie ein Bild mit mindestens 480 x 360 Pixeln verwenden. Damit ML Kit Gesichter richtig erkennen kann, müssen die eingegebenen Bilder Gesichter enthalten die durch ausreichende Pixeldaten dargestellt werden. Jedes Gesicht, das Sie sehen möchten, die in einem Bild erkannt werden sollen, mindestens 100 × 100 Pixel groß sein. Wenn Sie herausfinden möchten, Konturen von Flächen erfordert ML Kit eine Eingabe mit höherer Auflösung: jede Fläche sollte mindestens 200 x 200 Pixel groß sein.

Wenn Sie Gesichter in einer Echtzeitanwendung erkennen, um die Gesamtabmessungen der eingegebenen Bilder zu berücksichtigen. Kleinere Bilder können werden schneller verarbeitet. Um die Latenz zu verringern, nehmen Sie Bilder mit geringerer Auflösung auf, behalten Sie berücksichtigen Sie die oben genannten Anforderungen an die Genauigkeit und stellen Sie sicher, dass das Gesicht der Person so weit wie möglich einnimmt. Siehe auch Tipps zur Optimierung der Leistung in Echtzeit

Ein schlechter Bildfokus kann auch die Genauigkeit beeinträchtigen. Wenn Sie keine akzeptablen erhalten, bitten Sie den Nutzer, das Bild erneut aufzunehmen.

Auch die Ausrichtung eines Gesichts relativ zur Kamera kann sich darauf auswirken, welche Gesichtszüge Funktionen, die ML Kit erkennt. Weitere Informationen finden Sie unter Konzepte der Gesichtserkennung.

1. Gesichtserkennung konfigurieren

Beispiel:

// 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()
FaceDetectionActivity.kt

// 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();
FaceDetectionActivity.java

2. Eingabebild vorbereiten

Für die Gesichtserkennung sollten Sie ein Bild mit mindestens den Abmessungen 480 x 360 Pixel. Wenn Sie Gesichter in Echtzeit erkennen, bei dieser Mindestauflösung kann die Latenz verringert werden.

Sie können eine InputImage erstellen aus verschiedenen Quellen stammen. Diese werden im Folgenden erläutert.

Mit einem media.Image

So erstellen Sie eine InputImage: media.Image-Objekts erstellen, beispielsweise wenn Sie ein Bild von einem des Geräts an, übergeben Sie das media.Image-Objekt und die Drehung auf InputImage.fromMediaImage().

Wenn Sie die Methode <ph type="x-smartling-placeholder"></ph> CameraX-Bibliothek, den OnImageCapturedListener und ImageAnalysis.Analyzer-Klassen berechnen den Rotationswert für Sie.

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

Wenn Sie keine Kamerabibliothek verwenden, die Ihnen den Drehungsgrad des Bildes anzeigt, lässt sich anhand des Drehungsgrads des Geräts und der Ausrichtung der Kamera berechnen. Sensor im Gerät:

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

Übergeben Sie dann das media.Image-Objekt und den Wert für Rotationsgrad auf InputImage.fromMediaImage():

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

InputImage image = InputImage.fromMediaImage(mediaImage, rotation);

Datei-URI verwenden

So erstellen Sie eine InputImage: aus einem Datei-URI entfernen möchten, übergeben Sie den App-Kontext und den Datei-URI an InputImage.fromFilePath(). Dies ist nützlich, wenn Sie Verwenden Sie den Intent ACTION_GET_CONTENT, um den Nutzer zur Auswahl aufzufordern ein Bild aus ihrer Galerie-App.

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

ByteBuffer oder ByteArray verwenden

So erstellen Sie eine InputImage: aus einem ByteBuffer- oder ByteArray-Objekt zu erstellen, berechnen Sie Drehung wie zuvor für die media.Image-Eingabe beschrieben. Erstellen Sie dann das InputImage-Objekt mit dem Zwischenspeicher oder Array Höhe, Breite, Farbcodierungsformat und Drehungsgrad:

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

Mit einem Bitmap

So erstellen Sie eine InputImage: Bitmap-Objekt zu erstellen, nehmen Sie folgende Deklaration vor:

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

InputImage image = InputImage.fromBitmap(bitmap, rotationDegree);
MLKitVisionImage.java

Das Bild wird durch ein Bitmap-Objekt in Verbindung mit Drehungsgrad dargestellt.

3. FaceDetector-Instanz abrufen

val detector = FaceDetection.getClient(options)
// Or, to use the default option:
// val detector = FaceDetection.getClient();
FaceDetectionActivity.kt

FaceDetector detector = FaceDetection.getClient(options);
// Or use the default options:
// FaceDetector detector = FaceDetection.getClient();
FaceDetectionActivity.java

4. Bild verarbeiten

val result = detector.process(image)
        .addOnSuccessListener { faces ->
            // Task completed successfully
            // ...
        }
        .addOnFailureListener { e ->
            // Task failed with an exception
            // ...
        }
FaceDetectionActivity.kt

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
                                // ...
                            }
                        });
FaceDetectionActivity.java

5. Informationen zu erkannten Gesichtern erhalten

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
    }
}
FaceDetectionActivity.kt

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();
    }
}
FaceDetectionActivity.java

Beispiel für Gesichtskonturen

Wenn Sie die Gesichtskonturerkennung aktiviert haben, wird eine Liste mit Punkten jedes erkannte Gesichtsmerkmal. Diese Punkte stellen die Form des . Gesichtserkennung Erkennungskonzepte mit weiteren Informationen zu Konturen repräsentiert werden.

In der folgenden Abbildung sehen Sie, wie diese Punkte einem Gesicht zugeordnet sind. Klicken Sie auf das Bild vergrößern: