Gesichter mit ML Kit für Android erkennen

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

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

Feature	Nicht gebündelt	Gebündelt
Implementierung	Das Modell wird dynamisch über die Google Play-Dienste heruntergeladen.	Das Modell ist zum Build-Zeitpunkt statisch mit Ihrer App verknüpft.
App-Größe	Die Größe wurde um etwa 800 KB erhöht.	Die Größe wird um etwa 6,9 MB erhöht.
Initialisierungszeit	Vor der ersten Verwendung kann es möglicherweise etwas dauern, bis das Modell heruntergeladen wurde.	Modell ist sofort verfügbar

Ausprobieren

• Probieren Sie die Beispiel-App aus, um sich ein Anwendungsbeispiel für diese API anzusehen.
• Mit dem Codelab können Sie den Code selbst ausprobieren.

Hinweis

Für diese API ist Android API-Level 21 oder höher erforderlich. Achten Sie darauf, dass die Build-Datei Ihrer Anwendung einen minSdkVersion-Wert von 21 oder höher verwendet.

1. In der Datei build.gradle auf Projektebene muss das Maven-Repository von Google in den Abschnitten buildscript und allprojects enthalten sein.

2. Fügen Sie die Abhängigkeiten für die ML Kit-Android-Bibliotheken in die Gradle-Datei auf App-Ebene Ihres Moduls ein, die normalerweise app/build.gradle ist. Wählen Sie je nach Ihren Anforderungen eine der folgenden Abhängigkeiten aus:

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

   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 Ihre App so konfigurieren, dass das Modell nach der Installation der App aus dem Play Store automatisch auf das Gerät heruntergeladen wird. Füge dazu der Datei AndroidManifest.xml deiner 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 prüfen und einen Download über die ModuleInstallClient API der Google Play-Dienste anfordern.

   Wenn Sie weder Modelldownloads bei der Installation aktivieren noch einen expliziten Download anfordern, wird das Modell bei der ersten Ausführung des Detektors heruntergeladen. Anfragen, die Sie vor Abschluss des Downloads stellen, führen zu keinen Ergebnissen.

Richtlinien für Eingabebilder

Für die Gesichtserkennung sollten Sie ein Bild mit mindestens 480 x 360 Pixeln verwenden. Damit ML Kit Gesichter genau erkennen kann, müssen die 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, erfordert ML Kit eine höhere Auflösung: Jede Fläche sollte mindestens 200 × 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. Um die Latenz zu verringern, sollten Sie Bilder mit niedrigerer Auflösung erfassen. Beachten Sie jedoch die oben genannten Anforderungen an die Genauigkeit und achten Sie darauf, dass das Gesicht der Person so viel wie möglich einnimmt. Weitere Informationen finden Sie unter Tipps zur Verbesserung der Echtzeitleistung.

Ein schlechter Bildfokus kann auch die Genauigkeit beeinträchtigen. Wenn Sie keine akzeptablen Ergebnisse erhalten, bitten Sie den Nutzer, das Bild noch einmal zu kopieren.

Die Ausrichtung eines Gesichts relativ zur Kamera kann sich auch darauf auswirken, welche Gesichtsmerkmale ML Kit erkennt. Weitere Informationen finden Sie unter Konzepte der Gesichtserkennung.

1. Gesichtserkennung konfigurieren

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

Einstellungen
setPerformanceMode	PERFORMANCE_MODE_FAST (Standard) | PERFORMANCE_MODE_ACCURATE Bevorzugen Sie bei der Gesichtswiedererkennung Geschwindigkeit oder Genauigkeit.
setLandmarkMode	LANDMARK_MODE_NONE (Standard) | LANDMARK_MODE_ALL Gibt an, ob Gesichtsmerkmale erkannt werden sollen: Augen, Ohren, Nase, Wangen, Mund usw.
setContourMode	CONTOUR_MODE_NONE (Standard) | CONTOUR_MODE_ALL Gibt an, ob die Konturen von Gesichtszügen erkannt werden sollen. Konturen werden nur für das auffälligste Gesicht im 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 (Standardeinstellung: 0.1f) Legt die kleinste gewünschte Gesichtsgröße fest, ausgedrückt als Verhältnis der Breite des Kopfes zur Breite des Bilds.
enableTracking	false (Standardeinstellung) | true Gibt an, ob Gesichtern eine ID zugewiesen werden soll, mit der Gesichter in verschiedenen Bildern nachverfolgt werden können. Hinweis: Wenn die Konturerkennung aktiviert ist, wird nur ein Gesicht erkannt. Die Gesichtserkennung liefert daher keine hilfreichen Ergebnisse. Aktiviere daher die Konturerkennung und die Gesichtserkennung nicht gleichzeitig, um die Geschwindigkeit der Erkennung zu erhöhen.

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

Wenn Sie Gesichter in einem Bild erkennen möchten, erstellen Sie ein InputImage-Objekt aus einem Bitmap-, media.Image-, ByteBuffer-, Byte-Array oder einer Datei auf dem Gerät. Übergib dann das InputImage-Objekt an die Methode process von FaceDetector.

Für die Gesichtserkennung sollten Sie ein Bild mit mindestens 480 × 360 Pixeln verwenden. Wenn Sie Gesichter in Echtzeit erkennen, kann die Aufnahme von Frames in dieser Mindestauflösung die Latenz reduzieren.

Sie können ein InputImage-Objekt aus verschiedenen Quellen erstellen, die unten erläutert werden.

Mit einem media.Image

Wenn du ein InputImage-Objekt aus einem media.Image-Objekt erstellen möchtest, z. B. wenn du ein Bild mit der Kamera eines Geräts aufnimmst, übergib das media.Image-Objekt und die Drehung des Bildes an InputImage.fromMediaImage().

Wenn Sie die Bibliothek CameraX 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 du keine Kamerabibliothek verwendest, die dir den Drehungsgrad des Bildes liefert, kannst du ihn aus dem Drehungsgrad des Geräts 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 Wert für den Rotationsgrad an InputImage.fromMediaImage():

Kotlin

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

Java

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

Datei-URI verwenden

Wenn Sie ein InputImage-Objekt aus einem Datei-URI erstellen möchten, übergeben Sie den Anwendungskontext und den Datei-URI an InputImage.fromFilePath(). Das ist nützlich, 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();
}

ByteBuffer oder ByteArray verwenden

Um ein InputImage-Objekt aus ByteBuffer oder ByteArray zu erstellen, berechnen Sie zuerst den Bilddrehungsgrad, wie zuvor für die media.Image-Eingabe beschrieben. Erstellen Sie dann das InputImage-Objekt mit dem Zwischenspeicher oder Array, zusammen mit Höhe, Breite, Farbcodierungsformat und Drehungsgrad:

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

Um ein InputImage-Objekt aus einem Bitmap-Objekt zu erstellen, deklariere Folgendes:

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 in Verbindung mit Drehungsgrad dargestellt.

3. FaceDetector-Instanz 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 die ImageProxy schließen, wenn Sie sie nicht mehr benötigen. Fügen Sie dazu beispielsweise dem Task-Objekt, das von der Methode process zurückgegeben wird, ein OnCompleteListener hinzu. Ein Beispiel finden Sie in der Kurzanleitung VisionProcessorBase in der Beispielanwendung.

5. Informationen zu erkannten Gesichtern erhalten

Wenn die Gesichtserkennung erfolgreich ist, wird eine Liste von Face-Objekten an den Erfolgs-Listener übergeben. Jedes Face-Objekt repräsentiert ein Gesicht, das im Bild erkannt wurde. Für jedes Gesicht können Sie die Begrenzungskoordinaten im Eingabebild sowie alle anderen Informationen abrufen, die Sie mithilfe des Gesichtserkennungs mithilfe der Konfiguration gefunden 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, wird für jedes erkannte Gesichtselement eine Liste mit Punkten angezeigt. Diese Punkte stellen die Form des Elements 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, beachten Sie die folgenden Richtlinien, um die besten Framerates zu erzielen:

• Konfigurieren Sie die Gesichtserkennung so, dass sie entweder die Gesichtskonturenerkennung oder die Klassifizierung und die Erkennung von Sehenswürdigkeiten verwendet, aber nicht beides:

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

• FAST-Modus aktivieren (standardmäßig aktiviert).

• Nehmen Sie Bilder mit einer niedrigeren Auflösung auf. Beachten Sie jedoch auch die Anforderungen dieser API an die Bildabmessungen.

Wenn Sie die Camera oder camera2 API verwenden, drosseln Sie Aufrufe an den Detektor. Wenn ein neuer Videoframe verfügbar wird, während der Detektor ausgeführt wird, lassen Sie den Frame fallen. Ein Beispiel finden Sie in der VisionProcessorBase-Klasse in der Beispielanwendung im Schnellstart.

Wenn Sie die CameraX API verwenden, muss die Rückstaustrategie auf den Standardwert ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST gesetzt sein. Dadurch wird garantiert, dass jeweils nur ein Bild zur Analyse geliefert wird. Wenn mehr Bilder erzeugt werden, während das Analysegerät ausgelastet ist, werden diese automatisch verworfen und nicht in die Warteschlange für die Übermittlung eingereiht. Sobald das analysierte Bild durch Aufrufen von ImageProxy.close() geschlossen wurde, wird das nächste aktuelle Bild geliefert.

Wenn Sie die Ausgabe des Detektors verwenden, um Grafiken über das Eingabebild einzublenden, rufen Sie zuerst das Ergebnis aus ML Kit ab und rendern Sie dann das Bild und das Overlay in einem Schritt. Dadurch wird die Anzeigeoberfläche für jeden Eingabeframe nur einmal gerendert. Ein Beispiel finden Sie in der Kurzanleitung unter den Klassen CameraSourcePreview und GraphicOverlay.

Wenn du die Camera2 API verwendest, nimm Bilder im ImageFormat.YUV_420_888-Format auf. Wenn du die ältere Camera API verwendest, nimm Bilder im ImageFormat.NV21-Format auf.