Mendeteksi pose dengan ML Kit di Android

ML Kit menyediakan dua SDK yang dioptimalkan untuk deteksi pose.

Nama SDKdeteksi posepose-detection-akurat
PenerapanKode dan aset ditautkan secara statis ke aplikasi Anda pada waktu build.Kode dan aset ditautkan secara statis ke aplikasi Anda pada waktu build.
Dampak ukuran aplikasi (termasuk kode dan aset)~10,1 MB~13,3 MB
PerformaPixel 3XL: ~30FPSPixel 3XL: ~23FPS dengan CPU, ~30FPS dengan GPU

Cobalah

Sebelum memulai

  1. Di file build.gradle level project, pastikan Anda memasukkan repositori Maven Google di bagian buildscript dan allprojects.
  2. Tambahkan dependensi untuk library Android ML Kit ke file gradle level aplikasi modul Anda, biasanya 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. Membuat instance PoseDetector

Opsi PoseDetector

Untuk mendeteksi pose dalam gambar, pertama-tama buat instance PoseDetector dan tentukan setelan detektor secara opsional.

Mode deteksi

PoseDetector beroperasi dalam dua mode deteksi. Pastikan Anda memilih yang sesuai dengan kasus penggunaan Anda.

STREAM_MODE (default)
Detektor pose akan terlebih dahulu mendeteksi orang yang paling terlihat dalam gambar, lalu menjalankan deteksi pose. Dalam frame berikutnya, langkah deteksi orang tidak akan dilakukan kecuali orang tersebut tersamarkan atau tidak lagi terdeteksi dengan keyakinan tinggi. Detektor pose akan mencoba melacak orang yang paling terlihat dan mengembalikan posenya di setiap inferensi. Tindakan ini akan mengurangi latensi dan menghaluskan deteksi. Gunakan mode ini saat Anda ingin mendeteksi pose dalam streaming video.
SINGLE_IMAGE_MODE
Detektor pose akan mendeteksi seseorang, lalu menjalankan deteksi pose. Langkah deteksi orang akan berjalan untuk setiap gambar, sehingga latensi akan lebih tinggi, dan tidak ada pelacakan orang. Gunakan mode ini saat menggunakan deteksi pose pada gambar statis atau saat pelacakan tidak diinginkan.

Konfigurasi hardware

PoseDetector mendukung beberapa konfigurasi hardware untuk mengoptimalkan performa:

  • CPU: menjalankan detektor menggunakan CPU saja
  • CPU_GPU: menjalankan detektor menggunakan CPU dan GPU

Saat membuat opsi detektor, Anda dapat menggunakan API setPreferredHardwareConfigs untuk mengontrol pemilihan hardware. Secara default, semua konfigurasi hardware ditetapkan sesuai keinginan.

ML Kit akan mempertimbangkan ketersediaan, stabilitas, ketepatan, dan latensi setiap konfigurasi dan memilih yang terbaik dari konfigurasi pilihan. Jika tidak ada konfigurasi pilihan yang berlaku, konfigurasi CPU akan otomatis digunakan sebagai penggantian. ML Kit akan melakukan pemeriksaan ini dan persiapan terkait dengan cara yang tidak memblokir sebelum mengaktifkan akselerasi apa pun. Jadi, kemungkinan besar saat pengguna menjalankan detektor untuk pertama kalinya, CPU akan digunakan. Setelah semua persiapan selesai, konfigurasi terbaik akan digunakan dalam operasi berikut.

Contoh penggunaan setPreferredHardwareConfigs:

  • Agar ML Kit dapat memilih konfigurasi terbaik, jangan panggil API ini.
  • Jika Anda tidak ingin mengaktifkan akselerasi, teruskan CPU saja.
  • Jika Anda ingin menggunakan GPU untuk memindahkan CPU meskipun GPU mungkin lebih lambat, teruskan CPU_GPU saja.

Tentukan opsi detektor pose:

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

Terakhir, buat instance PoseDetector. Teruskan opsi yang Anda tentukan:

Kotlin

val poseDetector = PoseDetection.getClient(options)

Java

PoseDetector poseDetector = PoseDetection.getClient(options);

2. Siapkan gambar input

Untuk mendeteksi pose dalam gambar, buat objek InputImage dari Bitmap, media.Image, ByteBuffer, array byte, atau file di perangkat. Lalu, teruskan objek InputImage ke PoseDetector.

Untuk deteksi pose, Anda harus menggunakan gambar dengan dimensi yang berukuran minimal 480x360 piksel. Jika Anda mendeteksi pose secara real time, pengambilan frame pada resolusi minimum ini dapat membantu mengurangi latensi.

Anda dapat membuat objek InputImage dari berbagai sumber, masing-masing dijelaskan di bawah.

Menggunakan media.Image

Untuk membuat objek InputImage dari objek media.Image, seperti saat mengambil gambar dari kamera perangkat, teruskan objek media.Image dan rotasi gambar ke InputImage.fromMediaImage().

Jika Anda menggunakan library CameraX, class OnImageCapturedListener dan ImageAnalysis.Analyzer menghitung nilai rotasi untuk Anda.

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

Jika Anda tidak menggunakan library kamera yang memberi derajat rotasi gambar, Anda dapat menghitungnya dari derajat rotasi perangkat dan orientasi sensor kamera pada perangkat:

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

Kemudian, teruskan objek media.Image dan nilai derajat rotasi ke InputImage.fromMediaImage():

Kotlin

val image = InputImage.fromMediaImage(mediaImage, rotation)

Java

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

Menggunakan URI file

Untuk membuat objek InputImage dari URI file, teruskan konteks aplikasi dan URI file ke InputImage.fromFilePath(). Hal ini berguna saat Anda menggunakan intent ACTION_GET_CONTENT untuk meminta pengguna memilih gambar dari aplikasi galeri mereka.

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

Menggunakan ByteBuffer atau ByteArray

Untuk membuat objek InputImage dari ByteBuffer atau ByteArray, pertama-tama hitung derajat rotasi gambar seperti yang dijelaskan sebelumnya untuk input media.Image. Kemudian, buat objek InputImage dengan buffer atau array, beserta tinggi, lebar, format encoding warna, dan derajat rotasi gambar:

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

Menggunakan Bitmap

Untuk membuat objek InputImage dari objek Bitmap, buat deklarasi berikut:

Kotlin

val image = InputImage.fromBitmap(bitmap, 0)

Java

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

Gambar direpresentasikan oleh objek Bitmap bersama dengan derajat rotasi.

3. Memproses gambar

Teruskan objek InputImage yang sudah disiapkan ke metode process 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. Mendapatkan informasi tentang pose yang terdeteksi

Jika seseorang terdeteksi dalam gambar, API deteksi pose akan menampilkan objek Pose dengan 33 PoseLandmark.

Jika orang tersebut tidak benar-benar berada di dalam gambar, model akan menetapkan koordinat tempat terkenal yang hilang di luar bingkai dan memberinya nilai InFrameConfidence yang rendah.

Jika tidak ada orang yang terdeteksi dalam frame, objek Pose tidak berisi PoseLandmark.

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

Tips untuk meningkatkan performa

Kualitas hasil bergantung pada kualitas gambar input:

  • Agar ML Kit dapat mendeteksi pose secara akurat, orang dalam gambar harus diwakili oleh data piksel yang memadai; untuk performa terbaik, subjek harus berukuran minimal 256x256 piksel.
  • Jika Anda mendeteksi pose dalam aplikasi real-time, sebaiknya pertimbangkan dimensi keseluruhan gambar input. Gambar yang lebih kecil dapat diproses lebih cepat, jadi untuk mengurangi latensi, ambil gambar dengan resolusi lebih rendah, tetapi perhatikan persyaratan resolusi di atas dan pastikan subjek menempati gambar sebanyak mungkin.
  • Fokus gambar yang buruk juga dapat memengaruhi akurasi. Jika Anda tidak mendapatkan hasil yang dapat diterima, minta pengguna untuk mengambil ulang gambar.

Jika Anda ingin menggunakan deteksi pose dalam aplikasi real-time, ikuti panduan ini untuk mencapai frekuensi gambar terbaik:

  • Gunakan SDK deteksi pose dasar dan STREAM_MODE.
  • Pertimbangkan untuk mengambil gambar dengan resolusi lebih rendah. Namun, perhatikan juga persyaratan dimensi gambar API ini.
  • Jika Anda menggunakan Camera atau camera2 API, throttle panggilan ke detektor. Jika frame video baru tersedia saat detektor sedang berjalan, hapus frame tersebut. Lihat class VisionProcessorBase di aplikasi contoh panduan memulai untuk mengetahui contohnya.
  • Jika Anda menggunakan CameraX API, pastikan strategi backpressure ditetapkan ke nilai defaultnya ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST. Tindakan ini menjamin hanya satu gambar yang akan dikirim untuk dianalisis pada satu waktu. Jika lebih banyak gambar dihasilkan saat analyzer sibuk, gambar tersebut akan otomatis dihapus dan tidak diantrekan untuk pengiriman. Setelah gambar yang dianalisis ditutup dengan memanggil ImageProxy.close(), gambar terbaru berikutnya akan dikirim.
  • Jika Anda menggunakan output detektor untuk menempatkan grafis pada gambar input, pertama-tama dapatkan hasilnya dari ML Kit, lalu render gambar dan tempatkan grafis dalam satu langkah. Tindakan ini hanya merender ke permukaan tampilan sekali untuk setiap frame input. Lihat class CameraSourcePreview dan GraphicOverlay dalam aplikasi contoh panduan memulai untuk mengetahui contohnya.
  • Jika Anda menggunakan Camera2 API, ambil gambar dalam format ImageFormat.YUV_420_888. Jika Anda menggunakan Camera API versi lama, ambil gambar dalam format ImageFormat.NV21.

Langkah berikutnya

  • Untuk mempelajari cara menggunakan tempat terkenal pose untuk mengklasifikasikan pose, lihat Tips Klasifikasi Pose.