Posen mit ML Kit für Android erkennen

Diese API wird in der Betaphase angeboten und unterliegt keinem SLA und keiner Richtlinie zur Einstellung von Produkten und Diensten. Mögliche Änderungen die die Abwärtskompatibilität beeinträchtigen.

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

Diese API verwendet eine gebündelte Bibliothek, die Ihre App-Größe erhöht. Weitere Informationen finden Sie unter in diesem Leitfaden.

SDK-Name	Posenerkennung	pose-detection-accurate
Implementierung	Code und Assets werden bei der Build-Phase statisch mit Ihrer App verknüpft.	Der Code und die Assets werden zum Zeitpunkt der Erstellung statisch mit Ihrer App verknüpft.
Auswirkungen auf die App-Größe (einschließlich Code und Assets)	~10,1 MB	~13,3 MB
Leistung	Google Pixel 3 XL: ca. 30 fps	Pixel 3 XL: ~23 fps mit CPU, ~30 fps mit GPU

Jetzt ausprobieren

• Probieren Sie die Beispiel-App aus, um sehen Sie sich ein Anwendungsbeispiel für diese API an.

Vorbereitung

Für diese API ist Android API-Level 21 oder höher erforderlich. Achten Sie darauf, dass in der Build-Datei Ihrer App ein minSdkVersion-Wert von 21 oder höher verwendet wird.

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

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:

   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 Einstellungen für den Detector an.

Erkennungsmodus

Der PoseDetector kann in zwei Erkennungsmodi betrieben werden. Wählen Sie die Option aus, die Ihrem Anwendungsfall entspricht.

STREAM_MODE (Standard)

Die Positionserkennung erkennt zuerst die am stärksten hervorgehobene Person im Bild und führt dann die Positionserkennung durch. In den nachfolgenden Frames wird der Schritt der Personenentdeckung erst durchgeführt, wenn die Person oder nicht mehr mit hoher Zuverlässigkeit erkannt werden. Die Pose-Erkennung Sie versuchen, die auffälligste Person zu verfolgen und jeweils ihre Position zurückzugeben Inferenz. Dadurch wird die Latenz verringert und die Erkennung optimiert. Verwenden Sie diesen Modus, wenn Sie die Körperhaltung in einem Videostream erkennen möchten.

SINGLE_IMAGE_MODE

Die Positionserkennung erkennt eine Person und läuft die Pose -Erkennung. Der Schritt zur Personenerkennung wird für jedes Bild ausgeführt. Daher ist die Latenz höher und es erfolgt kein Personen-Tracking. Verwenden Sie diesen Modus, wenn Sie die Körperhaltungserkennung auf statischen Bildern verwenden oder wenn kein Tracking gewünscht ist.

Hardwarekonfiguration

Der PoseDetector unterstützt mehrere Hardwarekonfigurationen zur Leistungsoptimierung:

• CPU: Den Detektor nur mit der CPU ausführen
• CPU_GPU: den Detector sowohl mit der CPU als auch mit der GPU ausführen

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

ML Kit berücksichtigt Verfügbarkeit, Stabilität, Korrektheit und Latenz der einzelnen Konfigurationen und wählt die beste aus den bevorzugten Konfigurationen aus. Wenn keine der bevorzugten Konfigurationen zutrifft, wird die CPU-Konfiguration automatisch als Fallback verwendet. ML Kit führt diese Prüfungen und die zugehörige Vorbereitung nicht blockierend durch, bevor die Beschleunigung aktiviert wird. Daher wird beim ersten Ausführen des Detectors höchstwahrscheinlich CPU verwendet. Nach all den Vorbereitung abgeschlossen ist, wird in den folgenden Ausführungen die beste Konfiguration verwendet.

Verwendungsbeispiele für setPreferredHardwareConfigs:

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

Legen Sie die Optionen für die Positionserkennung fest:

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 von Ihnen angegebenen Optionen:

Kotlin

val poseDetector = PoseDetection.getClient(options)

Java

PoseDetector poseDetector = PoseDetection.getClient(options);

2. Eingabebild vorbereiten

Erstellen Sie ein InputImage-Objekt, um Posen in einem Bild zu erkennen aus einem Bitmap-, media.Image-, ByteBuffer-, Byte-Array oder einer Datei in auf dem Gerät. Übergeben Sie dann das InputImage-Objekt an die PoseDetector.

Für die Posenerkennung solltest du ein Bild mit mindestens den Abmessungen verwenden 480 x 360 Pixel. Wenn Sie Posen in Echtzeit erkennen, kann die Aufnahme von Frames mit dieser Mindestauflösung die Latenz verringern.

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 CameraX-Bibliothek verwenden, wird der Drehwert von den Klassen OnImageCapturedListener und ImageAnalysis.Analyzer für Sie berechnet.

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 Drehungsgrad des Bildes anzeigt, lässt sich anhand des Drehungsgrads des Geräts und der Ausrichtung der Kamera berechnen. Sensor im Gerät:

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 Rotationsgrad auf InputImage.fromMediaImage():

Kotlin

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

Java

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

Datei-URI verwenden

Wenn du ein InputImage-Objekt aus einem Datei-URI erstellen möchtest, übergebe den App-Kontext und den Datei-URI an InputImage.fromFilePath(). Das ist nützlich, wenn Sie mit einer ACTION_GET_CONTENT-Intent den Nutzer auffordern, 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

Wenn Sie ein InputImage-Objekt aus einem ByteBuffer oder ByteArray erstellen möchten, berechnen Sie zuerst den Drehwinkel des Bildes, wie oben für die media.Image-Eingabe beschrieben. Erstellen Sie dann das InputImage-Objekt mit dem Puffer oder Array sowie der Höhe, Breite, dem Farbcodierungsformat und dem Drehgrad des Bilds:

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 eine InputImage: Bitmap-Objekt zu erstellen, nehmen Sie folgende Deklaration vor:

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. Bild verarbeiten

Übergeben Sie das vorbereitete InputImage-Objekt an die process-Methode 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
                                // ...
                            }
                        });

Hinweis: Wenn du die CameraX API verwendest, musst du die ImageProxy schließen, wenn du sie nicht mehr benötigst. Du kannst dazu beispielsweise der Task, die von der process-Methode zurückgegeben wird, ein OnCompleteListener hinzufügen. Ein Beispiel finden Sie in der Klasse VisionProcessorBase in der Beispiel-App für den Schnellstart.

4. Informationen zur erkannten Pose abrufen

Wenn eine Person auf dem Bild erkannt wird, gibt die POS Detection API eine Pose zurück. Objekt mit 33 PoseLandmarken.

Wenn die Person nicht vollständig im Bild ist, weist das Modell den fehlenden Markierungen Koordinaten außerhalb des Bildes zu und gibt ihnen niedrige Werte für die Konfidenz im Bild.

Wenn keine Person im Bild erkannt wurde: Pose Objekt enthält 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 Verbesserung der Leistung

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

• Damit ML Kit die Pose genau erkennen kann, sollte die Person auf dem Bild ausreichende Pixeldaten dargestellt werden. um eine optimale Leistung zu erzielen, mindestens 256 x 256 Pixel groß sein.
• Wenn Sie in einer Echtzeitanwendung Posen erkennen, sollten Sie die Gesamtabmessungen der Eingabebilder. Kleinere Bilder können verarbeitet werden Um die Latenz zu verringern, nehmen Sie Bilder mit geringerer Auflösung auf, die oben genannten Anforderungen an die Auflösung berücksichtigen und sicherstellen, dass die Person möglichst viel vom Bild zu sehen.
• Ein schlechter Bildfokus kann auch die Genauigkeit beeinträchtigen. Wenn Sie keine akzeptablen Ergebnisse erhalten, den Nutzer bitten, das Bild erneut aufzunehmen.

Wenn Sie die Körperhaltungserkennung in einer Echtzeitanwendung verwenden möchten, beachten Sie die folgenden Richtlinien, um die beste Framerate zu erzielen:

• Verwenden Sie das Base Pose Detection SDK und STREAM_MODE.
• 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, begrenzen Sie die Aufrufe an den Detektor. Wenn während der Laufzeit des Detektors ein neuer Videoframe verfügbar wird, legen Sie ihn ab. Weitere Informationen finden Sie in der VisionProcessorBase in der Beispielanwendung „Kurzanleitung“ finden Sie ein Beispiel.
• Wenn Sie die CameraX API verwenden, muss die Backpressure-Strategie auf den Standardwert ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST festgelegt sein. Dadurch wird garantiert, dass jeweils nur ein Bild zur Analyse geliefert wird. Wenn mehr Bilder erstellt werden, während der Analyser beschäftigt ist, werden sie automatisch gelöscht und nicht für die Übermittlung in die Warteschlange gestellt. Sobald das analysierte Bild durch Aufrufen von ImageProxy.close() geschlossen wurde, wird das nächste aktuelle Bild gesendet.
• Wenn Sie die Ausgabe des Detektors verwenden, um Grafiken Eingabebild, rufen Sie zuerst das Ergebnis aus ML Kit ab und rendern Sie das Bild in einem Schritt übereinanderlegen. Dieser wird nur einmal pro Eingabeframe auf der Anzeigeoberfläche gerendert. Eines dieser Beispiele sind die Klassen CameraSourcePreview und GraphicOverlay in der Beispiel-App für die Schnellstartanleitung.
• Wenn Sie die Camera2 API verwenden, nehmen Sie Bilder in ImageFormat.YUV_420_888-Format. Wenn Sie die ältere Camera API verwenden, nehmen Sie Bilder in ImageFormat.NV21-Format.

Nächste Schritte

• Informationen zum Klassifizieren von Posen mithilfe von Orientierungspunkten finden Sie unter Tipps zur Posesklassifizierung.