Posen mit ML Kit für Android erkennen

ML Kit bietet zwei optimierte SDKs für die Posenerkennung.

SDK-Namepose-detectionpose-detection-accurate
ImplementierungCode und Assets werden beim Erstellen statisch mit Ihrer App verknüpft.Code und Assets werden beim Erstellen statisch mit Ihrer App verknüpft.
Auswirkungen auf die App-Größe (einschließlich Code und Assets)~10,1 MB~13,3 MB
LeistungPixel 3 XL: ~30 fpsPixel 3XL: ~23 fps mit CPU, ~30 fps mit GPU

Jetzt ausprobieren

  • In der Beispiel-App finden Sie ein Beispiel für die Verwendung dieser API.

Hinweis

  1. Fügen Sie in der build.gradle-Datei auf Projektebene das Maven-Repository von Google in die Abschnitte buildscript und allprojects ein.

  2. Fügen Sie der Gradle-Datei Ihres Moduls auf App-Ebene, die normalerweise app/build.gradle heißt, die Abhängigkeiten für die ML Kit-Android-Bibliotheken hinzu:

    dependencies {
  // If you want to use the base sdk
  implementation 'com.google.mlkit:pose-detection:18.0.0-beta5'
  // If you want to use the accurate sdk
  implementation 'com.google.mlkit:pose-detection-accurate:18.0.0-beta5'
}

1. Instanz von PoseDetector erstellen

Optionen für PoseDetector

Wenn Sie eine Pose in einem Bild erkennen möchten, erstellen Sie zuerst eine Instanz von PoseDetector und geben Sie optional die Detektoreinstellungen an.

Erkennungsmodus

Die PoseDetector funktioniert in zwei Erkennungsmodi. Wählen Sie die Option aus, die Ihrem Anwendungsfall entspricht.

STREAM_MODE (Standard)
Der Detektor für die Posenerkennung erkennt zuerst die am deutlichsten sichtbare Person im Bild und führt dann die Posenerkennung aus. In nachfolgenden Frames wird der Schritt zur Personenerkennung nicht durchgeführt, es sei denn, die Person wird verdeckt oder nicht mehr mit hoher Konfidenz erkannt. Der Pose Detector versucht, die am deutlichsten sichtbare Person zu verfolgen und ihre Pose bei jeder Inferenz zurückzugeben. Dadurch wird die Latenz verringert und die Erkennung verbessert. Verwenden Sie diesen Modus, wenn Sie die Pose in einem Videostream erkennen möchten.
SINGLE_IMAGE_MODE
Der Haltungsdetektor erkennt eine Person und führt dann die Haltungserkennung aus. Der Schritt zur Personenentdeckung wird für jedes Bild ausgeführt, sodass die Latenz höher ist und keine Personenverfolgung stattfindet. Verwenden Sie diesen Modus, wenn Sie die Posenerkennung für statische Bilder verwenden oder kein Tracking gewünscht ist.

Hardwarekonfiguration

Die PoseDetector unterstützt mehrere Hardwarekonfigurationen zur Leistungsoptimierung:

  • CPU: Detektor nur mit CPU ausführen
  • CPU_GPU: Detektor sowohl mit CPU als auch mit GPU ausführen

Beim Erstellen der Detektoroptionen können Sie die API setPreferredHardwareConfigs verwenden, um die Hardwareauswahl zu steuern. Standardmäßig sind alle Hardwarekonfigurationen als bevorzugt festgelegt.

ML Kit berücksichtigt die Verfügbarkeit, Stabilität, Korrektheit und Latenz jeder Konfiguration und wählt die beste aus den bevorzugten Konfigurationen aus. Wenn keine der bevorzugten Konfigurationen anwendbar ist, wird die CPU-Konfiguration automatisch als Fallback verwendet. Das ML Kit führt diese Prüfungen und die zugehörige Vorbereitung auf nicht blockierende Weise durch, bevor eine Beschleunigung aktiviert wird. Daher wird beim ersten Ausführen des Detektors durch den Nutzer wahrscheinlich CPU verwendet. Nach Abschluss der Vorbereitung wird die beste Konfiguration in den folgenden Ausführungen verwendet.

Beispiele für die Verwendung von setPreferredHardwareConfigs:

  • Wenn Sie möchten, dass ML Kit die beste Konfiguration auswählt, rufen Sie diese API nicht auf.
  • Wenn Sie keine Beschleunigung aktivieren möchten, übergeben Sie nur CPU.
  • Wenn Sie die GPU verwenden möchten, um die CPU zu entlasten, auch wenn die GPU langsamer sein könnte, übergeben Sie nur CPU_GPU.

Geben Sie die Optionen für die Posenerkennung an:

Kotlin

// Base pose detector with streaming frames, when depending on the pose-detection sdk
val options = PoseDetectorOptions.Builder()
    .setDetectorMode(PoseDetectorOptions.STREAM_MODE)
    .build()

// Accurate pose detector on static images, when depending on the pose-detection-accurate sdk
val options = AccuratePoseDetectorOptions.Builder()
    .setDetectorMode(AccuratePoseDetectorOptions.SINGLE_IMAGE_MODE)
    .build()

Java

// Base pose detector with streaming frames, when depending on the pose-detection sdk
PoseDetectorOptions options =
   new PoseDetectorOptions.Builder()
       .setDetectorMode(PoseDetectorOptions.STREAM_MODE)
       .build();

// Accurate pose detector on static images, when depending on the pose-detection-accurate sdk
AccuratePoseDetectorOptions options =
   new AccuratePoseDetectorOptions.Builder()
       .setDetectorMode(AccuratePoseDetectorOptions.SINGLE_IMAGE_MODE)
       .build();

Erstellen Sie abschließend eine Instanz von PoseDetector. Übergeben Sie die angegebenen Optionen:

Kotlin

val poseDetector = PoseDetection.getClient(options)

Java

PoseDetector poseDetector = PoseDetection.getClient(options);

2. Eingabebild vorbereiten

Wenn Sie Posen 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. Übergeben Sie dann das InputImage-Objekt an PoseDetector.

Für die Posenerkennung sollten Sie ein Bild mit einer Größe von mindestens 480 × 360 Pixeln verwenden. Wenn Sie Posen in Echtzeit erkennen, können Sie die Latenz reduzieren, indem Sie Frames mit dieser Mindestauflösung erfassen.

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

Mit einem media.Image

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

Wenn Sie die CameraX-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 den Rotationsgrad des Bildes angibt, können Sie ihn anhand des Rotationsgrads 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;
}

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

Kotlin

val image = InputImage.fromMediaImage(mediaImage, rotation)

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 App-Kontext und den Datei-URI an InputImage.fromFilePath(). Das ist nützlich, wenn Sie einen ACTION_GET_CONTENT-Intent 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();
}

ByteBuffer oder ByteArray verwenden

Wenn Sie ein InputImage-Objekt aus einem ByteBuffer oder einem ByteArray erstellen möchten, berechnen Sie zuerst den Drehwinkel des Bildes, wie zuvor für die media.Image-Eingabe beschrieben. Erstellen Sie dann das InputImage-Objekt mit dem Zwischenspeicher oder Array sowie der Höhe, Breite, dem Farbcodierungsformat und dem Drehwinkel 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

Wenn Sie ein InputImage-Objekt aus einem Bitmap-Objekt erstellen möchten, deklarieren Sie Folgendes:

Kotlin

val image = InputImage.fromBitmap(bitmap, 0)

Java

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

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

3. Bild verarbeiten

Übergeben Sie das vorbereitete InputImage-Objekt an die Methode process von PoseDetector.

Kotlin

Task<Pose> result = poseDetector.process(image)
       .addOnSuccessListener { results ->
           // Task completed successfully
           // ...
       }
       .addOnFailureListener { e ->
           // Task failed with an exception
           // ...
       }

Java

Task<Pose> result =
        poseDetector.process(image)
                .addOnSuccessListener(
                        new OnSuccessListener<Pose>() {
                            @Override
                            public void onSuccess(Pose pose) {
                                // Task completed successfully
                                // ...
                            }
                        })
                .addOnFailureListener(
                        new OnFailureListener() {
                            @Override
                            public void onFailure(@NonNull Exception e) {
                                // Task failed with an exception
                                // ...
                            }
                        });

4. Informationen zur erkannten Pose abrufen

Wenn eine Person im Bild erkannt wird, gibt die API zur Haltungserkennung ein Pose-Objekt mit 33 PoseLandmarks zurück.

Wenn die Person nicht vollständig im Bild zu sehen war, weist das Modell den fehlenden Landmarken Koordinaten außerhalb des Bildes zu und gibt ihnen niedrige InFrameConfidence-Werte.

Wenn im Frame keine Person erkannt wurde, enthält das Objekt Pose keine PoseLandmarks.

Kotlin

// Get all PoseLandmarks. If no person was detected, the list will be empty
val allPoseLandmarks = pose.getAllPoseLandmarks()

// Or get specific PoseLandmarks individually. These will all be null if no person
// was detected
val leftShoulder = pose.getPoseLandmark(PoseLandmark.LEFT_SHOULDER)
val rightShoulder = pose.getPoseLandmark(PoseLandmark.RIGHT_SHOULDER)
val leftElbow = pose.getPoseLandmark(PoseLandmark.LEFT_ELBOW)
val rightElbow = pose.getPoseLandmark(PoseLandmark.RIGHT_ELBOW)
val leftWrist = pose.getPoseLandmark(PoseLandmark.LEFT_WRIST)
val rightWrist = pose.getPoseLandmark(PoseLandmark.RIGHT_WRIST)
val leftHip = pose.getPoseLandmark(PoseLandmark.LEFT_HIP)
val rightHip = pose.getPoseLandmark(PoseLandmark.RIGHT_HIP)
val leftKnee = pose.getPoseLandmark(PoseLandmark.LEFT_KNEE)
val rightKnee = pose.getPoseLandmark(PoseLandmark.RIGHT_KNEE)
val leftAnkle = pose.getPoseLandmark(PoseLandmark.LEFT_ANKLE)
val rightAnkle = pose.getPoseLandmark(PoseLandmark.RIGHT_ANKLE)
val leftPinky = pose.getPoseLandmark(PoseLandmark.LEFT_PINKY)
val rightPinky = pose.getPoseLandmark(PoseLandmark.RIGHT_PINKY)
val leftIndex = pose.getPoseLandmark(PoseLandmark.LEFT_INDEX)
val rightIndex = pose.getPoseLandmark(PoseLandmark.RIGHT_INDEX)
val leftThumb = pose.getPoseLandmark(PoseLandmark.LEFT_THUMB)
val rightThumb = pose.getPoseLandmark(PoseLandmark.RIGHT_THUMB)
val leftHeel = pose.getPoseLandmark(PoseLandmark.LEFT_HEEL)
val rightHeel = pose.getPoseLandmark(PoseLandmark.RIGHT_HEEL)
val leftFootIndex = pose.getPoseLandmark(PoseLandmark.LEFT_FOOT_INDEX)
val rightFootIndex = pose.getPoseLandmark(PoseLandmark.RIGHT_FOOT_INDEX)
val nose = pose.getPoseLandmark(PoseLandmark.NOSE)
val leftEyeInner = pose.getPoseLandmark(PoseLandmark.LEFT_EYE_INNER)
val leftEye = pose.getPoseLandmark(PoseLandmark.LEFT_EYE)
val leftEyeOuter = pose.getPoseLandmark(PoseLandmark.LEFT_EYE_OUTER)
val rightEyeInner = pose.getPoseLandmark(PoseLandmark.RIGHT_EYE_INNER)
val rightEye = pose.getPoseLandmark(PoseLandmark.RIGHT_EYE)
val rightEyeOuter = pose.getPoseLandmark(PoseLandmark.RIGHT_EYE_OUTER)
val leftEar = pose.getPoseLandmark(PoseLandmark.LEFT_EAR)
val rightEar = pose.getPoseLandmark(PoseLandmark.RIGHT_EAR)
val leftMouth = pose.getPoseLandmark(PoseLandmark.LEFT_MOUTH)
val rightMouth = pose.getPoseLandmark(PoseLandmark.RIGHT_MOUTH)

Java

// Get all PoseLandmarks. If no person was detected, the list will be empty
List<PoseLandmark> allPoseLandmarks = pose.getAllPoseLandmarks();

// Or get specific PoseLandmarks individually. These will all be null if no person
// was detected
PoseLandmark leftShoulder = pose.getPoseLandmark(PoseLandmark.LEFT_SHOULDER);
PoseLandmark rightShoulder = pose.getPoseLandmark(PoseLandmark.RIGHT_SHOULDER);
PoseLandmark leftElbow = pose.getPoseLandmark(PoseLandmark.LEFT_ELBOW);
PoseLandmark rightElbow = pose.getPoseLandmark(PoseLandmark.RIGHT_ELBOW);
PoseLandmark leftWrist = pose.getPoseLandmark(PoseLandmark.LEFT_WRIST);
PoseLandmark rightWrist = pose.getPoseLandmark(PoseLandmark.RIGHT_WRIST);
PoseLandmark leftHip = pose.getPoseLandmark(PoseLandmark.LEFT_HIP);
PoseLandmark rightHip = pose.getPoseLandmark(PoseLandmark.RIGHT_HIP);
PoseLandmark leftKnee = pose.getPoseLandmark(PoseLandmark.LEFT_KNEE);
PoseLandmark rightKnee = pose.getPoseLandmark(PoseLandmark.RIGHT_KNEE);
PoseLandmark leftAnkle = pose.getPoseLandmark(PoseLandmark.LEFT_ANKLE);
PoseLandmark rightAnkle = pose.getPoseLandmark(PoseLandmark.RIGHT_ANKLE);
PoseLandmark leftPinky = pose.getPoseLandmark(PoseLandmark.LEFT_PINKY);
PoseLandmark rightPinky = pose.getPoseLandmark(PoseLandmark.RIGHT_PINKY);
PoseLandmark leftIndex = pose.getPoseLandmark(PoseLandmark.LEFT_INDEX);
PoseLandmark rightIndex = pose.getPoseLandmark(PoseLandmark.RIGHT_INDEX);
PoseLandmark leftThumb = pose.getPoseLandmark(PoseLandmark.LEFT_THUMB);
PoseLandmark rightThumb = pose.getPoseLandmark(PoseLandmark.RIGHT_THUMB);
PoseLandmark leftHeel = pose.getPoseLandmark(PoseLandmark.LEFT_HEEL);
PoseLandmark rightHeel = pose.getPoseLandmark(PoseLandmark.RIGHT_HEEL);
PoseLandmark leftFootIndex = pose.getPoseLandmark(PoseLandmark.LEFT_FOOT_INDEX);
PoseLandmark rightFootIndex = pose.getPoseLandmark(PoseLandmark.RIGHT_FOOT_INDEX);
PoseLandmark nose = pose.getPoseLandmark(PoseLandmark.NOSE);
PoseLandmark leftEyeInner = pose.getPoseLandmark(PoseLandmark.LEFT_EYE_INNER);
PoseLandmark leftEye = pose.getPoseLandmark(PoseLandmark.LEFT_EYE);
PoseLandmark leftEyeOuter = pose.getPoseLandmark(PoseLandmark.LEFT_EYE_OUTER);
PoseLandmark rightEyeInner = pose.getPoseLandmark(PoseLandmark.RIGHT_EYE_INNER);
PoseLandmark rightEye = pose.getPoseLandmark(PoseLandmark.RIGHT_EYE);
PoseLandmark rightEyeOuter = pose.getPoseLandmark(PoseLandmark.RIGHT_EYE_OUTER);
PoseLandmark leftEar = pose.getPoseLandmark(PoseLandmark.LEFT_EAR);
PoseLandmark rightEar = pose.getPoseLandmark(PoseLandmark.RIGHT_EAR);
PoseLandmark leftMouth = pose.getPoseLandmark(PoseLandmark.LEFT_MOUTH);
PoseLandmark rightMouth = pose.getPoseLandmark(PoseLandmark.RIGHT_MOUTH);

Tipps zur Leistungsverbesserung

Die Qualität der Ergebnisse hängt von der Qualität des Eingabebildes ab:

  • Damit das ML Kit die Pose genau erkennen kann, sollte die Person im Bild durch ausreichend Pixeldaten dargestellt werden. Für eine optimale Leistung sollte das Motiv mindestens 256 × 256 Pixel groß sein.
  • Wenn Sie die Pose 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 aufnehmen. Beachten Sie jedoch die oben genannten Auflösungsanforderungen und achten Sie darauf, dass das Motiv so viel wie möglich vom Bild einnimmt.
  • Auch ein unscharfes Bild kann die Genauigkeit beeinträchtigen. Wenn Sie keine akzeptablen Ergebnisse erhalten, bitten Sie den Nutzer, das Bild noch einmal aufzunehmen.

Wenn Sie die Posenerkennung in einer Echtzeitanwendung verwenden möchten, beachten Sie die folgenden Richtlinien, um die besten Framerates zu erzielen:

  • Verwenden Sie das Basis-SDK für die Posenerkennung und STREAM_MODE.
  • Versuchen Sie, Bilder mit einer niedrigeren Auflösung aufzunehmen. Beachten Sie jedoch auch die Anforderungen dieser API an die Bildabmessungen.
  • Wenn Sie die API Camera oder camera2 verwenden, drosseln Sie die Aufrufe an den Detektor. Wenn ein neuer Videoframe verfügbar wird, während der Detektor ausgeführt wird, wird der Frame verworfen. Ein Beispiel finden Sie in der Klasse VisionProcessorBase in der Beispiel-App der Kurzanleitung.
  • Wenn Sie die CameraX API verwenden, muss die Backpressure-Strategie auf den Standardwert ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST festgelegt sein. So wird sichergestellt, dass jeweils nur ein Bild zur Analyse bereitgestellt wird. Wenn mehr Bilder erzeugt werden, während der Analyzer ausgelastet ist, werden sie automatisch verworfen und nicht für die Übermittlung in die Warteschlange gestellt. Sobald das zu analysierende Bild durch Aufrufen von ImageProxy.close() geschlossen wird, wird das nächste aktuelle Bild geliefert.
  • Wenn Sie die Ausgabe des Detektors verwenden, um Grafiken über das Eingabebild zu legen, 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 Klassen CameraSourcePreview und GraphicOverlay in der Beispiel-App der Kurzanleitung.
  • Wenn Sie die Camera2 API verwenden, nehmen Sie Bilder im ImageFormat.YUV_420_888-Format auf. Wenn Sie die ältere Camera API verwenden, nehmen Sie Bilder im ImageFormat.NV21-Format auf.

Nächste Schritte