Posen mit ML Kit für Android erkennen

ML Kit bietet zwei optimierte SDKs für die Erkennung von Posen.

SDK-Name	pose-detection	pose-detection-accurate
Implementierung	Code und Assets werden zur Build-Zeit statisch mit Ihrer App verknüpft.	Code und Assets werden zur Build-Zeit statisch mit Ihrer App verknüpft.
Auswirkungen auf die App-Größe (einschließlich Code und Assets)	~10,1 MB	~13,3 MB
Leistung	Pixel 3XL: ~30FPS	Pixel 3 XL: ~23 FPS mit CPU, ~30 FPS mit GPU

Jetzt ausprobieren

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

Hinweis

Für diese API ist Android API-Level 23 oder höher erforderlich. Die Build -Datei Ihrer App muss einen Wert von 23 oder höher für minSdkVersion verwenden.

In die Datei build.gradle auf Projektebene muss das Maven-Repository von Google in die Abschnitte buildscript und allprojects aufgenommen werden.

Fügen Sie die Abhängigkeiten für die ML Kit Android-Bibliotheken der Gradle-Datei auf App-Ebene Ihres Moduls hinzu, 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 die Erkennung an.

Erkennungsmodus

Der PoseDetector funktioniert in zwei Erkennungsmodi. Wählen Sie den Modus aus, der Ihrem Anwendungsfall entspricht.

STREAM_MODE (Standard): Der Pose-Detector erkennt zuerst die auffälligste Person im Bild und führt dann die Erkennung der Pose aus. In nachfolgenden Frames wird der Schritt zur Personenerkennung nur ausgeführt, wenn die Person verdeckt ist oder nicht mehr mit hoher Zuverlässigkeit erkannt wird. Der Pose-Detector versucht, die auffälligste Person zu verfolgen und ihre Pose bei jeder Inferenz zurückzugeben. Dadurch wird die Latenz verringert und die Erkennung reibungsloser. Verwenden Sie diesen Modus, wenn Sie Posen in einem Videostream erkennen möchten.
SINGLE_IMAGE_MODE: Der Pose-Detector erkennt eine Person und führt dann die Erkennung der Pose aus. Der Schritt zur Personenerkennung wird für jedes Bild ausgeführt. Daher ist die Latenz höher und es gibt keine Personenverfolgung. Verwenden Sie diesen Modus, wenn Sie die Erkennung von Posen auf statischen Bildern verwenden oder keine Verfolgung gewünscht ist.

Hardwarekonfiguration

Der PoseDetector unterstützt mehrere Hardwarekonfigurationen zur Optimierung der Leistung:

CPU: Führen Sie den Detector nur mit der CPU aus.
CPU_GPU: Führen Sie den Detector mit CPU und GPU aus.

Beim Erstellen der Detector-Optionen 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 automatisch die CPU-Konfiguration als Fallback verwendet. ML Kit führt diese Prüfungen und die zugehörige Vorbereitung nicht blockierend aus, bevor eine Beschleunigung aktiviert wird. Daher wird der Detector höchstwahrscheinlich beim ersten Ausführen durch den Nutzer die CPU verwenden. Nach Abschluss aller Vorbereitungen wird bei den folgenden Ausführungen die beste Konfiguration verwendet.

Beispiele für die Verwendung von 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 an.
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 an.

Geben Sie die Optionen für den Pose-Detector 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 schließlich 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

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 den PoseDetector.

Für die Erkennung von Posen sollten Sie ein Bild mit einer Auflösung von mindestens 480 × 360 Pixeln verwenden. Wenn Sie Posen in Echtzeit erkennen, kann das Erfassen von Frames mit dieser Mindestauflösung die Latenz verringern.

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

`media.Image` verwenden

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 Drehungswert 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 Drehwinkel des Bildes liefert, können Sie ihn aus dem Drehwinkel 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 Drehwinkelwert 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 einer Datei-URI erstellen möchten, übergeben Sie den App-Kontext und die Datei-URI an InputImage.fromFilePath(). Dies 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 einem ByteArray erstellen möchten, berechnen Sie zuerst den Drehwinkel des Bildes wie zuvor für die Eingabe von media.Image beschrieben. Erstellen Sie dann das InputImage Objekt mit dem Puffer oder Array zusammen mit der Höhe, Breite, Farbcodierung 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
)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

`Bitmap` verwenden

Wenn Sie ein InputImage -Objekt aus einem Bitmap-Objekt erstellen möchten, verwenden Sie die folgende Deklaration:

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 zusammen mit Drehwinkeln dargestellt.

3. Bild verarbeiten

Übergeben Sie das vorbereitete InputImage-Objekt an die Methode process des 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 Sie die CameraX API verwenden, schließen Sie den ImageProxy, wenn Sie ihn nicht mehr benötigen, z.B. indem Sie der Task einen OnCompleteListener hinzufügen, der von der process Methode zurückgegeben wird. Ein Beispiel finden Sie in der Klasse VisionProcessorBase in der Beispiel-App für die Kurzanleitung.

4. Informationen zur erkannten Pose abrufen

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

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

Wenn im Frame keine Person erkannt wurde, enthält das Pose -Objekt keine PoseLandmark-Objekte.

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 Ihrer Ergebnisse hängt von der Qualität des Eingabebildes ab:

Damit 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 Posen 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, erfassen Sie Bilder mit niedrigeren Auflösungen. Beachten Sie jedoch die oben genannten Anforderungen an die Auflösung und sorgen Sie dafür, dass das Motiv so viel wie möglich vom Bild einnimmt.
Eine schlechte Bildschärfe kann sich auch auf die Genauigkeit auswirken. Wenn Sie keine akzeptablen Ergebnisse erhalten, bitten Sie den Nutzer, das Bild noch einmal aufzunehmen.

Wenn Sie die Erkennung von Posen in einer Echtzeitanwendung verwenden möchten, folgen Sie diesen Richtlinien, um die besten Frameraten zu erzielen:

Verwenden Sie das Basis-SDK für die Erkennung von Posen und STREAM_MODE.
Erfassen Sie Bilder mit einer niedrigeren Auflösung. Beachten Sie jedoch auch die Anforderungen an die Bildabmessungen dieser API.
Wenn Sie die Camera oder camera2 API verwenden, drosseln Sie die Aufrufe an den Detector. Wenn ein neuer Video Frame verfügbar wird, während der Detector ausgeführt wird, verwerfen Sie den Frame. Ein Beispiel finden Sie in der VisionProcessorBase Klasse in der Beispiel-App für die Kurzanleitung.
Wenn Sie die CameraX-API verwenden, muss die Backpressure-Strategie auf den Standardwert ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST festgelegt sein. Dadurch wird sichergestellt, dass jeweils nur ein Bild zur Analyse bereitgestellt wird. Wenn mehr Bilder erstellt werden, während der Analyzer beschäftigt ist, werden sie automatisch verworfen und nicht zur Bereitstellung in die Warteschlange gestellt. Sobald das analysierte Bild durch Aufrufen von ImageProxy.close() geschlossen wird, wird das nächste aktuelle Bild bereitgestellt.
Wenn Sie die Ausgabe des Detectors verwenden, um Grafiken auf das Eingabebild zu legen, rufen Sie zuerst das Ergebnis von ML Kit ab und rendern Sie dann das Bild und die Überlagerung in einem Schritt. Dadurch wird die Anzeigeoberfläche nur einmal für jeden Eingabeframe gerendert. Ein Beispiel finden Sie in den CameraSourcePreview und GraphicOverlay Klassen in der Beispiel-App für die Kurzanleitung.
Wenn Sie die Camera2 API verwenden, erfassen Sie Bilder in ImageFormat.YUV_420_888 Format. Wenn Sie die ältere Camera API verwenden, erfassen Sie Bilder im ImageFormat.NV21 Format.

Nächste Schritte

Informationen zur Verwendung von Pose-Landmarken zum Klassifizieren von Posen finden Sie unter Tipps zur Klassifizierung von Posen.

Posen mit ML Kit für Android erkennen Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Jetzt ausprobieren

Hinweis

1. Instanz von PoseDetector erstellen

Optionen für PoseDetector

Erkennungsmodus

Hardwarekonfiguration

Kotlin

Java

Kotlin

Java

2. Eingabebild vorbereiten

media.Image verwenden

Kotlin

Java

Kotlin

Java

Kotlin

Java

Datei-URI verwenden

Kotlin

Java

ByteBuffer oder ByteArray verwenden

Kotlin

Java

Bitmap verwenden

Kotlin

Java

3. Bild verarbeiten

Kotlin

Java

4. Informationen zur erkannten Pose abrufen

Kotlin

Java

Tipps zur Leistungsverbesserung

Nächste Schritte

Posen mit ML Kit für Android erkennen

1. Instanz von `PoseDetector` erstellen

Optionen für `PoseDetector`

`media.Image` verwenden

`ByteBuffer` oder `ByteArray` verwenden

`Bitmap` verwenden