Gesichter mit ML Kit auf Android-Geräten erkennen

Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

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

Es gibt zwei Möglichkeiten, die Gesichtserkennung zu integrieren: ein gebündeltes Modell, das Teil Ihrer App ist, und ein nicht gebündeltes Modell, das von den Google Play-Diensten abhängt. Die beiden Modelle sind identisch. Wenn Sie das nicht gebündelte Modell auswählen, ist Ihre App kleiner.

FunktionNicht gebündeltGebündelt
ImplementierungDas Modell wird über die Google Play-Dienste dynamisch heruntergeladen.Das Modell ist bei der Build-Erstellung statisch mit Ihrer App verknüpft.
App-GrößeDie Größe wurde um ca. 800 KB erhöht.Ca. 6,9 MB
InitialisierungszeitMüssen möglicherweise warten, bis das Modell heruntergeladen ist, bevor es verwendet werden kann.Modell ist sofort verfügbar
  • Probieren Sie die Beispiel-App aus, um ein Beispiel für die Verwendung dieser API zu sehen.
  • Probieren Sie den Code selbst mit dem Codelab aus.

Hinweis

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

  2. Fügen Sie die Abhängigkeiten für die ML Kit-Android-Bibliotheken der Gradle-Datei auf App-Ebene hinzu, 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.5'
    }
    

    Für die 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, können Sie die App so konfigurieren, dass das Modell automatisch auf das Gerät heruntergeladen wird, nachdem es aus dem Play Store installiert wurde. 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 prüfen und einen Download über die ModuleInstallClient API der Google Play-Dienste anfordern.

    Wenn Sie das Herunterladen von Modellen 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 Sie vor Abschluss des Downloads senden, führen zu keinem Ergebnis.

Richtlinien für Eingabebilder

Für die Gesichtserkennung sollte ein Bild mit einer Größe von mindestens 480 x 360 Pixeln verwendet werden. Damit das ML Kit Gesichter richtig erkennen kann, müssen Eingabebilder Gesichter enthalten, die durch genügend Pixeldaten dargestellt werden. Grundsätzlich sollte jedes Gesicht, das Sie in einem Bild erkennen möchten, mindestens 100 × 100 Pixel groß sein. Wenn Sie die Konturen von Gesichtern erfassen möchten, ist für ML Kit eine Eingabe mit höherer Auflösung erforderlich: 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. Um die Latenz zu verringern, sollten Sie Bilder mit geringeren Auflösungen aufnehmen. Beachten Sie jedoch die oben genannten Anforderungen an die Genauigkeit und achten Sie darauf, dass das Gesicht des Nutzers so viel vom Bild wie möglich einnimmt. Weitere Informationen finden Sie in den Tipps zur Verbesserung der Echtzeitleistung.

Ein schlechter Bildfokus kann sich auch auf die Genauigkeit auswirken. Wenn du keine akzeptablen Ergebnisse erhältst, bitte den Nutzer, das Bild neu aufzunehmen.

Die Ausrichtung eines Gesichts relativ zur Kamera kann sich auch darauf auswirken, welche Gesichtsmerkmale das ML Kit erkennt. Siehe Konzepte der Gesichtserkennung.

1. Gesichtserkennung konfigurieren

Wenn Sie die Standardeinstellungen des Gesichtserkennungsmodus für ein Bild ändern 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 bevorzugen.

setLandmarkMode LANDMARK_MODE_NONE (Standard) | LANDMARK_MODE_ALL

Informationen zur Erkennung von Gesichts- und Gesichtsmerkmalen: Augen, Ohren, Nase, Wangen, Mund usw.

setContourMode CONTOUR_MODE_NONE (Standard) | CONTOUR_MODE_ALL

Gibt an, ob die Konturen von Gesichtszügen erkannt werden. 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“ einzuordnen sind.

setMinFaceSize float (Standard: 0.1f)

Legt die kleinstmögliche Gesichtergröße fest, ausgedrückt als das Verhältnis der Breite des Kopfs zur Breite des Bildes.

enableTracking false (Standard) | true

Ob Gesichtern eine ID zugewiesen wird, mit der Gesichter auf Bildern erfasst werden können.

Hinweis: Wenn die Konturerkennung aktiviert ist, wird nur ein Gesicht erkannt. Die Funktion „Gesichtserkennung“ liefert daher keine nützlichen Ergebnisse. Aus diesem Grund und zur Verbesserung der Erkennungsgeschwindigkeit sollten Sie die Konturerkennung und das Gesichtserkennung nicht aktivieren.

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

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. Eingabebild vorbereiten

Um Gesichter in einem Bild zu erkennen, erstellst du ein InputImage-Objekt aus einem Bitmap-, media.Image-, ByteBuffer-, Byte-Array oder einer Datei auf dem Gerät. Übergeben Sie dann das Objekt InputImage an die Methode process von FaceDetector.

Für die Gesichtserkennung sollte ein Bild mit einer Größe von mindestens 480 x 360 Pixeln verwendet werden. Wenn Sie Gesichter in Echtzeit erkennen, können Sie die Latenz verringern, indem Sie Frames mit dieser Mindestauflösung aufnehmen.

Sie können ein InputImage-Objekt aus verschiedenen Quellen erstellen. Dies wird unten erläutert.

Mit einem media.Image

Wenn Sie ein InputImage-Objekt aus einem media.Image-Objekt erstellen möchten, z. B. wenn Sie ein Bild von der Kamera eines Geräts aufnehmen, übergeben Sie das Objekt media.Image und die Bilddrehung 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 du keine Kamerabibliothek verwendest, die dir den Grad der Drehung des Bildes liefert, kannst du ihn aus dem Rotationsgrad 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
}

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

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

Kotlin

val image = InputImage.fromMediaImage(mediaImage, rotation)

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

Java

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

Mit ByteBuffer oder ByteArray

Um ein InputImage-Objekt aus einem ByteBuffer oder einem ByteArray zu erstellen, musst du zuerst den Grad der Bilddrehung berechnen, wie zuvor für die media.Image-Eingabe beschrieben. Erstellen Sie dann das InputImage-Objekt mit dem Zwischenspeicher oder Array sowie 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
)
// 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
);

Mit einem Bitmap

So erstellen Sie ein InputImage-Objekt aus einem Bitmap-Objekt:

Kotlin

val image = InputImage.fromBitmap(bitmap, 0)

Java

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

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

Java

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

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

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. Informationen zu erkannten Gesichtern abrufen

Wenn die Gesichtserkennung erfolgreich ist, wird eine Liste der Face-Objekte 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 Begrenzungskoordinaten im Eingabebild sowie alle anderen Informationen abrufen, die Sie zum Erkennen des Gesichtsdetektors 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
    }
}

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

Beispiel für Gesichtskonturen

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

Die folgende Abbildung zeigt, wie diese Punkte einem Gesicht zugeordnet werden. Klicken Sie auf das Bild, um es zu vergrößern:

Beispiel für ein erkanntes Gesichtskontur Mesh

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 entweder die Gesichtserkennung oder die Klassifizierung und die Erkennung von Sehenswürdigkeiten verwendet werden, aber nicht beides:

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

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

  • Sie sollten Bilder mit einer geringeren Auflösung aufnehmen. Beachten Sie jedoch die Anforderungen an die Bildabmessung dieser API.

  • Wenn Sie die API Camera oder camera2 verwenden, drosseln Sie Aufrufe an den Detektor. Wenn während der Ausführung des Detektors ein neuer Videoframe verfügbar wird, lassen Sie den Frame los. Ein Beispiel findest du in der Kurzanleitungs-Beispielanwendung in der Klasse VisionProcessorBase.
  • Wenn Sie die CameraX API verwenden, achten Sie darauf, dass die Gegendruckstrategie auf den Standardwert ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST festgelegt ist. So wird sichergestellt, dass jeweils nur ein Bild zur Analyse übermittelt wird. Wenn bei der Ausarbeitung des Analysetools mehr Bilder erstellt werden, werden diese automatisch gelöscht und nicht in die Warteschlange gestellt. Sobald das analysierte Bild durch Aufrufen von ImageProxy.close() geschlossen wird, wird das nächste neueste Bild bereitgestellt.
  • Wenn Sie die Ausgabe des Detektors verwenden, um Grafiken auf dem Eingabebild einzublenden, rufen Sie zuerst das Ergebnis aus ML Kit ab 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 finden Sie in den Beispielkursen CameraSourcePreview und GraphicOverlay.
  • Wenn Sie die Camera2 API verwenden, nehmen Sie Bilder im Format ImageFormat.YUV_420_888 auf. Wenn du die ältere Camera API verwendest, solltest du Bilder im Format ImageFormat.NV21 aufnehmen.