Diese Seite wurde von der Cloud Translation API übersetzt.

Posen mit ML Kit für Android erkennen

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

SDK-Name	Posenerkennung	Posenerkennung-genau
Implementierung	Code und Assets sind beim Build statisch mit Ihrer App verknüpft.	Code und Assets sind beim Build 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 3 XL: ~30 fps	Pixel 3 XL: ~23 fps mit CPU, ~30 fps mit GPU

Ausprobieren

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

Hinweis

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

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

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

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

1. Instanz von `PoseDetector` erstellen

`PoseDetector` Optionen

Erstellen Sie zuerst eine Instanz von PoseDetector und geben Sie optional die Detektoreinstellungen an, um eine Pose in einem Bild zu erkennen.

Erkennungsmodus

Das PoseDetector funktioniert in zwei Erkennungsmodi. Wählen Sie unbedingt die Option aus, die zu Ihrem Anwendungsfall passt.

STREAM_MODE (Standard): Der Posendetektor erkennt zuerst die bekannteste Person auf dem Bild und führt dann die Posenerkennung durch. In nachfolgenden Frames wird die Personenerkennung nur dann ausgeführt, wenn die Person verdeckt wird oder nicht mehr mit hoher Zuverlässigkeit erkannt wird. Der Posendetektor versucht, die bekannteste Person zu verfolgen und ihre Pose in jeder Ableitung zurückzugeben. Dies reduziert die Latenz und sorgt für eine reibungslose Erkennung. Verwenden Sie diesen Modus, wenn Sie eine Pose in einem Videostream erkennen möchten.
SINGLE_IMAGE_MODE: Der Posendetektor erkennt eine Person und führt dann die Posenerkennung durch. Die Personenerkennung wird für jedes Bild ausgeführt, sodass die Latenz höher ist und es keine Personennachverfolgung gibt. Verwenden Sie diesen Modus, wenn Sie die Posenerkennung auf statischen Bildern verwenden oder wenn eine Nachverfolgung nicht erwünscht ist.

Hardwarekonfiguration

Der PoseDetector unterstützt mehrere Hardwarekonfigurationen zur Leistungsoptimierung:

CPU: Detektor ausschließlich über die CPU ausführen
CPU_GPU: Führe den Detektor sowohl mit CPU als auch mit GPU aus

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

ML Kit berücksichtigt Verfügbarkeit, Stabilität, Richtigkeit und Latenz jeder Konfiguration und wählt die beste aus der bevorzugten Konfiguration aus. Wenn keine der bevorzugten Konfigurationen zutrifft, wird die Konfiguration CPU automatisch als Fallback verwendet. ML Kit führt diese Prüfungen und die zugehörige Vorbereitung auf nicht blockierende Weise durch, bevor die Beschleunigung aktiviert wird. Wenn Ihr Nutzer den Detektor zum ersten Mal ausführt, wird er also höchstwahrscheinlich CPU verwendet. Nachdem die Vorbereitung abgeschlossen ist, wird in den folgenden Ausführungen die beste Konfiguration verwendet.

Beispiele für die Verwendung von setPreferredHardwareConfigs:

Rufen Sie diese API nicht auf, damit ML Kit die beste Konfiguration auswählen kann.
Wenn Sie keine Beschleunigung aktivieren möchten, übergeben Sie nur CPU.
Wenn Sie die CPU mithilfe von GPU entlasten möchten, auch wenn die GPU langsamer sein könnte, übergeben Sie nur CPU_GPU.

Geben Sie die Optionen für die Positionserkennung 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

Erstellen Sie zum Erkennen von Posen in einem Bild 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 die PoseDetector.

Zur Erkennung von Posen sollten Sie ein Bild mit einer Größe von mindestens 480 × 360 Pixeln verwenden. Wenn du Posen in Echtzeit erkennen möchtest, kann das Erfassen von Frames mit dieser Mindestauflösung die Latenz reduzieren.

Sie können ein InputImage-Objekt aus verschiedenen Quellen erstellen. Diese werden unten jeweils 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 mit der Kamera eines Geräts aufnehmen, übergeben Sie das media.Image-Objekt und die Bilddrehung an InputImage.fromMediaImage().

Wenn Sie die CameraX-Bibliothek verwenden, wird der Rotationswert von den Klassen OnImageCapturedListener und ImageAnalysis.Analyzer 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 den Drehgrad des Bildes angibt, können Sie ihn anhand des Gerätedrehungsgrads 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

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

Mithilfe von `ByteBuffer` oder `ByteArray`

Zum Erstellen eines InputImage-Objekts aus einem ByteBuffer- oder ByteArray-Objekt müssen Sie 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 der 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
)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`

Mit der folgenden Deklaration kannst du ein InputImage-Objekt aus einem Bitmap-Objekt erstellen:

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 Grad der Drehung dargestellt.

3. Bild verarbeiten

Übergeben Sie das vorbereitete InputImage-Objekt an die process-Methode der 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 ImageProxy nach der Verwendung schließen. Dazu fügst du dem Task-Objekt, das von der Methode process zurückgegeben wird, ein OnCompleteListener hinzu. Ein Beispiel hierfür finden Sie in der Beispiel-App der Kurzanleitung in der Klasse VisionProcessorBase.

4. Informationen zur erkannten Pose abrufen

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

Wenn sich die Person nicht vollständig im Bild befand, weist das Modell die fehlenden Markierungskoordinaten außerhalb des Frames zu und weist ihr niedrige InFrameConfidence-Werte zu.

Wenn im Frame keine Person erkannt wurde, enthält das Pose-Objekt 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 Eingabebilds ab:

Damit das ML Kit die Pose genau erkennen kann, sollte die Person auf dem Bild durch genügend Pixeldaten repräsentiert sein. Für eine optimale Leistung sollte die Person 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, sollten Sie Bilder mit geringerer Auflösung erfassen. Beachten Sie dabei jedoch die oben genannten Auflösungsanforderungen und achten Sie darauf, dass das Motiv so viel wie möglich auf dem Bild einnimmt.
Ein schlechter Bildfokus kann sich auch auf die Genauigkeit auswirken. Wenn Sie keine akzeptablen Ergebnisse erhalten, bitten Sie den Nutzer, das Bild neu aufzunehmen.

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

Verwende das Basis-SDK für Posenerkennung und STREAM_MODE.
Nehmen Sie Bilder mit einer niedrigeren Auflösung auf. Beachten Sie jedoch auch die Anforderungen dieser API an die Bildabmessung.
Wenn Sie die Camera oder camera2 API verwenden, drosseln Sie Aufrufe an den Detektor. Wenn ein neuer Videoframe verfügbar ist, während der Detektor ausgeführt wird, löschen Sie den Frame. Ein Beispiel hierfür finden Sie in der Beispiel-App der Kurzanleitung in der Klasse VisionProcessorBase.
Wenn Sie die CameraX API verwenden, muss die Rückdruckstrategie auf den Standardwert ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST festgelegt sein. Dadurch wird sichergestellt, dass jeweils nur ein Bild zur Analyse geliefert wird. Werden weitere Bilder erstellt, während das Analysetool ausgelastet ist, werden diese automatisch gelöscht und nicht in die Warteschlange gestellt. Nachdem das zu analysierende Bild durch Aufrufen von ImageProxy.close() geschlossen wurde, wird das jeweils neueste Bild bereitgestellt.
Wenn Sie die Ausgabe des Detektors verwenden, um Grafiken über das Eingabebild einzublenden, rufen Sie zuerst das Ergebnis aus dem 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 entsprechendes Beispiel finden Sie in der Beispiel-App der Kurzanleitung in 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.

Nächste Schritte

Weitere Informationen zur Verwendung von Orientierungspunkten in Posen zum Klassifizieren von Posen finden Sie unter Tipps zur Körperklassifizierung.

Posen mit ML Kit für Android erkennen

Ausprobieren

Hinweis

1. Instanz von PoseDetector erstellen

PoseDetector Optionen

Erkennungsmodus

Hardwarekonfiguration

Kotlin

Java

Kotlin

Java

2. Eingabebild vorbereiten

Mit einem media.Image

Kotlin

Java

Kotlin

Java

Kotlin

Java

Datei-URI verwenden

Kotlin

Java

Mithilfe von ByteBuffer oder ByteArray

Kotlin

Java

Mit einem Bitmap

Kotlin

Java

3. Bild verarbeiten

Kotlin

Java

4. Informationen zur erkannten Pose abrufen

Kotlin

Java

Tipps zur Leistungsverbesserung

Nächste Schritte

1. Instanz von `PoseDetector` erstellen

`PoseDetector` Optionen

Mit einem `media.Image`

Mithilfe von `ByteBuffer` oder `ByteArray`

Mit einem `Bitmap`