Gesichter mit ML Kit für Android erkennen

Mit dem ML Kit können Sie Gesichter in Bildern und Videos erkennen.

Diese API ist entweder in einer nicht gebündelten Bibliothek, die vor der Verwendung heruntergeladen werden muss, oder einer gebündelten Bibliothek verfügbar, die die App-Größe erhöht. Weitere Informationen zu den Unterschieden zwischen den beiden Installationsoptionen finden Sie in dieser Anleitung.

Funktion	Nicht gebündelt	Gebündelt
Implementierung	Das Modell wird dynamisch über die Google Play-Dienste heruntergeladen.	Das Modell ist bei der Build-Erstellung statisch mit Ihrer App verknüpft.
App-Größe	Über 800 KB Dateigröße.	Etwa 6,9 MB.
Initialisierungszeit	Sie müssen möglicherweise auf den Download warten, bevor das Modell verwendet werden kann.	Modell ist sofort verfügbar

Ausprobieren

• Probieren Sie die Beispiel-App aus, um sich ein Beispiel für die Verwendung dieser API anzusehen.
• Probieren Sie den Code selbst mit dem Codelab aus.

Hinweis

Für diese API ist das Android-API-Level 19 oder höher erforderlich. Achten Sie darauf, dass die Build-Datei Ihrer App den minSdkVersion-Wert 19 oder höher hat.

1. Achten Sie darauf, dass Sie in der Datei build.gradle auf Projektebene das Maven-Repository von Google in die Abschnitte buildscript und allprojects aufnehmen.

2. Fügen Sie der Gradle-Datei auf Modulebene (in der Regel app/build.gradle) die Abhängigkeiten für die Android-Bibliotheken des ML Kits hinzu. Wählen Sie je nach Ihren Anforderungen eine der folgenden Abhängigkeiten aus:

   Wenn Sie das Modell mit Ihrer App kombinieren:

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

   Zur Verwendung des Modells in 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, können Sie die App so konfigurieren, dass das Modell nach der Installation aus dem Play Store automatisch auf das Gerät heruntergeladen wird. Fügen Sie dazu der Datei AndroidManifest.xml Ihrer App die folgende Deklaration hinzu:

   <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 überprüfen und einen Download über die ModuleInstallClient API der Google Play-Dienste anfordern.

   Wenn Sie das Herunterladen des Modells während der Installation nicht aktivieren oder einen expliziten Download anfordern, wird das Modell heruntergeladen, wenn Sie den Detektor das erste Mal ausführen. Anfragen, die vor Abschluss des Downloads gesendet werden, führen zu keinem Ergebnis.

Richtlinien für Eingabebilder

Für die Gesichtserkennung solltest du Bilder mit einer Größe von mindestens 480 x 360 Pixeln verwenden. Damit das ML Kit Gesichter richtig erkennen kann, müssen Eingabebilder Gesichter enthalten, die durch genügend Pixeldaten dargestellt werden. Im Allgemeinen sollte jedes Gesicht, das Sie in einem Bild erkennen möchten, mindestens 100 × 100 Pixel groß sein. Wenn Sie die Konturen von Gesichtern erkennen möchten, muss für das ML Kit eine höhere Auflösung eingegeben werden: Jedes Gesicht sollte mindestens 200 x 200 Pixel groß sein.

Wenn Sie Gesichter in einer Echtzeitanwendung erkennen, sollten Sie auch die Gesamtabmessungen der Eingabebilder berücksichtigen. Kleinere Bilder können schneller verarbeitet werden. Erfassen Sie daher Bilder mit geringerer Auflösung, um die Latenz zu verringern. Beachten Sie dabei jedoch die oben genannten Anforderungen an die Genauigkeit und achten Sie darauf, dass das Gesicht des Motivs so viel vom Bild wie möglich einnimmt. Hier finden Sie weitere Tipps zur Verbesserung der Leistung in Echtzeit.

Ein schlechter Bildfokus kann sich auch auf die Genauigkeit auswirken. Wenn Sie keine akzeptablen Ergebnisse erhalten, bitten Sie den Nutzer, das Bild neu aufzunehmen.

Die Ausrichtung eines Gesichts im Verhältnis zur Kamera kann sich auch darauf auswirken, welche Gesichtsmerkmale mit dem ML Kit erkannt werden. Siehe Konzepte der Gesichtserkennung.

1) Gesichtserkennung konfigurieren

Wenn Sie die Standardeinstellungen eines Gesichtserkennungsgeräts auf ein Bild anwenden möchten, geben Sie diese Einstellungen mit einem FaceDetectorOptions-Objekt an. Sie können die folgenden Einstellungen ändern:

Einstellungen
setPerformanceMode	PERFORMANCE_MODE_FAST (Standard) | PERFORMANCE_MODE_ACCURATE Geschwindigkeit oder Genauigkeit bei der Gesichtserkennung verbessern.
setLandmarkMode	LANDMARK_MODE_NONE (Standard) | LANDMARK_MODE_ALL Gibt an, ob es sich um Aufnahmen von Gesichtsmerkmalen handelt: Augen, Ohren, Nase, Wangen, Mund usw.
setContourMode	CONTOUR_MODE_NONE (Standard) | CONTOUR_MODE_ALL Gibt an, ob die Konturen von Gesichtsmerkmalen erkannt werden sollen. Konturen werden nur für das auffälligste Gesicht in einem Bild erkannt.
setClassificationMode	CLASSIFICATION_MODE_NONE (Standard) | CLASSIFICATION_MODE_ALL Gibt an, ob Gesichter in Kategorien wie „Lächeln“ und „Augen geöffnet“ klassifiziert werden sollen.
setMinFaceSize	float (Standard: 0.1f) Legt die kleinstmögliche Gesichtsgröße fest, ausgedrückt als Verhältnis der Breite des Kopfes zur Breite des Bildes.
enableTracking	false (Standard) | true Gibt an, ob Gesichtern eine ID zugewiesen werden soll, um Bilder in mehreren Bildern zu erfassen. Wenn die Konturerkennung aktiviert ist, wird nur ein Gesicht erkannt. Die Funktion „Gesichtserkennung“ liefert daher keine nützlichen Ergebnisse. Daher sollten Sie die Konturerkennung und das Gesichts-Tracking nicht aktivieren, um die Erkennungsgeschwindigkeit zu verbessern.

Beispiel:

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

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

2. Eingabebild vorbereiten

Damit Gesichter in einem Bild erkannt werden, erstellen Sie ein InputImage-Objekt aus einem Bitmap-, media.Image-, ByteBuffer-, Bytearray oder einer Datei auf dem Gerät. Übergeben Sie dann das Objekt InputImage an die Methode process von FaceDetector.

Für die Gesichtserkennung solltest du ein Bild mit einer Größe von mindestens 480 x 360 Pixeln verwenden. Wenn Sie Gesichter in Echtzeit erkennen, kann die Aufnahme von Frames mit dieser Mindestauflösung die Latenz reduzieren.

Sie können ein InputImage-Objekt aus verschiedenen Quellen erstellen. Dies wird im Folgenden beschrieben.

Mit einem media.Image

Um ein InputImage-Objekt aus einem media.Image-Objekt zu erstellen, z. B. wenn ein Bild von der Kamera eines Geräts aufgenommen wird, übergeben Sie das media.Image-Objekt und die Rotation des Bildes an InputImage.fromMediaImage().

Wenn Sie die KameraX-Bibliothek verwenden, berechnen die Klassen OnImageCapturedListener und ImageAnalysis.Analyzer den Rotationswert für Sie.

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

Wenn Sie keine Kamerabibliothek verwenden, die Ihnen den Grad der Drehung des Bildes liefert, können Sie ihn anhand des Grades der Drehung und der Ausrichtung des Kamerasensors im Gerät berechnen:

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

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

Übergeben Sie dann das media.Image-Objekt und den Rotationsgradwert an InputImage.fromMediaImage():

Kotlin

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

Java

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

Datei-URI verwenden

Übergeben Sie den Anwendungskontext und den Datei-URI an InputImage.fromFilePath(), um ein InputImage-Objekt aus einem Datei-URI zu erstellen. Dies ist hilfreich, wenn Sie den Intent ACTION_GET_CONTENT verwenden, um den Nutzer aufzufordern, ein Bild aus seiner Galerie-App auszuwählen.

Kotlin

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

Java

InputImage image;
try {
    image = InputImage.fromFilePath(context, uri);
} catch (IOException e) {
    e.printStackTrace();
}

Mit ByteBuffer oder ByteArray

Um ein InputImage-Objekt aus einer ByteBuffer oder ByteArray zu erstellen, berechnen Sie zuerst den Grad der Bilddrehung, wie zuvor für die media.Image-Eingabe beschrieben. Dann erstellen Sie das InputImage-Objekt mit dem Puffer oder Array. Erstellen Sie dabei Höhe, Breite, Farbcodierungsformat und Rotationsgrad des Bildes:

Kotlin

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

Java

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 ein InputImage-Objekt aus einem Bitmap-Objekt:

Kotlin

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

Java

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

Das Bild wird durch ein Bitmap-Objekt mit Rotationsgrad dargestellt.

3. Instanz von FaceDetector abrufen

Kotlin

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

Java

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

4. Bild verarbeiten

Übergeben Sie das Bild an die Methode process:

Kotlin

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

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

Hinweis: Wenn Sie die CameraX API verwenden, müssen Sie ImageProxy schließen, wenn Sie die Verwendung nicht beendet haben. Fügen Sie beispielsweise OnCompleteListener der Task-Methode hinzu, die von der process-Methode zurückgegeben wird. Ein Beispiel dafür finden Sie in der Beispiel-App VisionProcessorBase.

5. Informationen zu erkannten Gesichtern abrufen

Wenn die Gesichtserkennung erfolgreich ist, wird eine Liste von Face-Objekten an den Erfolgs-Listener übergeben. Jedes Face-Objekt stellt ein Gesicht dar, das im Bild erkannt wurde. Für jedes Gesicht können Sie die Begrenzungsrahmenkoordinaten im Eingabebild sowie alle anderen Informationen abrufen, die Sie für die Suche nach Gesichtern konfiguriert haben. Beispiel:

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

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

Beispiel für Gesichtskonturen

Wenn die Gesichtskonturerkennung aktiviert ist, erhalten Sie eine Liste der Punkte für jedes erkannte Gesichtsmerkmal. Diese Punkte stellen die Form des Merkmals dar. Weitere Informationen zur Darstellung von Konturen finden Sie unter Konzepte der Gesichtserkennung.

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

Gesichtserkennung in Echtzeit

Wenn Sie die Gesichtserkennung in einer Echtzeitanwendung verwenden möchten, folgen Sie diesen Richtlinien, um die besten Framerates zu erreichen:

• Konfigurieren Sie den Gesichtserkennung so, dass entweder die Gesichtskonturerkennung oder die Klassifizierung und die Erkennung von Sehenswürdigkeiten verwendet werden, aber nicht beide:

  Konturerkennung
  Erkennung von Sehenswürdigkeiten
  Klassifizierung
  Erkennung von Sehenswürdigkeiten und Klassifizierung
  Erkennung von Konturen und Sehenswürdigkeiten
  Konturerkennung und -klassifizierung
  Konturerkennung, Erkennung von Sehenswürdigkeiten und Klassifizierung
  

• Aktivieren Sie den FAST-Modus (standardmäßig aktiviert).

• Du kannst Bilder mit einer geringeren Auflösung aufnehmen. Beachten Sie jedoch die Anforderungen an die Bildabmessungen dieser API.

Wenn Sie die Camera oder camera2 API verwenden, drosseln Sie Aufrufe an den Detektor. Wenn während der Ausführung des Detektors ein neuer Videoframe verfügbar ist, lassen Sie den Frame los. Ein Beispiel dafür finden Sie in der Beispiel-App VisionProcessorBase.

Wenn du die CameraX API verwendest, muss die Rückdruckstrategie auf den Standardwert ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST festgelegt sein. So ist sichergestellt, dass immer nur ein Bild zur Analyse bereitgestellt wird. Wenn das Analysesystem ausgelastet ist, werden weitere Bilder automatisch gelöscht und nicht in die Auslieferung aufgenommen. Sobald das zu analysierende Bild durch Aufrufen von „ImageProxy.close()“ geschlossen wird, wird das nächste aktuelle Bild gesendet.

Wenn Sie die Ausgabe des Detektors verwenden, um Grafiken auf dem Eingabebild einzublenden, erhalten Sie zuerst das Ergebnis aus ML Kit und rendern Sie dann das Bild und das Overlay in einem einzigen Schritt. Dies wird für jeden Eingabeframe nur einmal auf der Anzeigeoberfläche gerendert. Ein Beispiel dafür finden Sie in den Beispielklassen CameraSourcePreview und GraphicOverlay in der Kurzanleitung.

Wenn Sie die Camera2 API verwenden, erfassen Sie Bilder im ImageFormat.YUV_420_888-Format. Wenn Sie die ältere Camera API verwenden, sollten Sie Bilder im Format ImageFormat.NV21 aufnehmen.