Pose Detection: apa itu, model dan prinsip kerja

Apa itu Pose Detection: dasar dan metrik

Pose Detection (juga dikenal sebagai Pose Estimation) mengacu pada tugas menentukan titik-titik kunci semantik tubuh manusia dari gambar atau video. Pendekatan Top-down pertama mendeteksi orang (Object Detection), kemudian menentukan posturnya. Pendekatan Bottom-up menemukan semua landmark dalam gambar, kemudian mengelompokkannya per orang (OpenPose). Untuk perangkat seluler digunakan bottom-up — lebih cepat jika ada beberapa orang dalam bingkai. ML Kit dan BlazePose menggunakan pendekatan single-stage — deteksi + postur dalam satu langkah.

COCO Keypoints — set standar 17 titik: hidung, mata (2), telinga (2), bahu (2), siku (2), pergelangan tangan (2), pinggul (2), lutut (2), pergelangan kaki (2). MediaPipe BlazePose menggunakan 33 titik, menambahkan: jari kaki, tumit, pusat batang tubuh, titik wajah. Semakin banyak titik, semakin akurat analisis postur, tetapi semakin tinggi beban komputasi. Untuk aplikasi kebugaran, 17–20 titik sudah cukup. Untuk analisis lengkap (yoga, tari) — 33 titik. Untuk filter AR — 33 titik + 468 titik wajah (MediaPipe Face Mesh).

PCK (Percentage of Correct Keypoints) — metrik akurasi Pose Detection. Dihitung sebagai proporsi titik yang diprediksi dalam batas jarak dari ground truth (biasanya 0.05–0.15 dari ukuran bounding box orang). ML Kit Pose Detection: 94% PCK@0.1. BlazePose Full: 96% PCK@0.1. MoveNet Lightning: 91% PCK@0.1. OKS (Object Keypoint Similarity) — metrik yang digunakan dalam COCO, mempertimbangkan skala orang dan tingkat kesulitan titik. mAP@OKS — metrik standar untuk benchmark.

Keypoint Visibility: setiap landmark memiliki skor (0..1) yang menunjukkan seberapa yakin model terhadap titik tersebut dan apakah titik tersebut terlihat. Titik dengan skor < 0.5 dianggap tidak terlihat (tertutup, di luar bingkai). Untuk analisis postur, gunakan hanya titik yang terlihat. Untuk mengevaluasi keselarasan — hitung confidence-weighted distances, di mana titik dengan skor rendah memiliki bobot lebih kecil dalam metrik.

ML Kit Pose Detection di Android dan iOS

ML Kit Pose Detection — pustaka dari Google untuk menentukan postur pada perangkat. Mendukung 33 landmarks, termasuk titik wajah, jari kaki, dan tumit. Mode: Accurate Mode (model 14 MB, 15–30 ms, akurasi tinggi) dan Streaming Mode (5 MB, 5–10 ms, untuk real-time). Streaming Mode menggunakan model ringan dengan pelacakan — setelah bingkai pertama, melacak gerakan tanpa mendeteksi ulang posisi tepat, memberikan hingga 60 FPS.

API ML Kit Pose Detection: PoseDetector (opsi: setDetectorMode, setPerformanceMode) → InputImage → Pose (List<PoseLandmark>). Setiap PoseLandmark memiliki: landmarkType (38 tipe), position (PointF3D), inFrameLikelihood (0..1). Pose juga menyediakan: boundingBox orang, daftar landmarks, metode getLandmark(type). Untuk klasifikasi postur, gunakan sudut antar tulang: shoulderAngle, elbowAngle, hipAngle — dihitung melalui Vector3D antar landmark yang berdekatan.

val options = PoseDetectorOptions.Builder()
    .setDetectorMode(PoseDetectorOptions.STREAM_MODE)
    .setPerformanceMode(PoseDetectorOptions.PERFORMANCE_MODE_FAST)
    .build()

val detector = PoseDetection.getClient(options)

detector.process(inputImage)
    .addOnSuccessListener { pose ->
        val leftElbow = pose.getLandmark(PoseLandmark.LEFT_ELBOW)
        val leftShoulder = pose.getLandmark(PoseLandmark.LEFT_SHOULDER)
        val leftWrist = pose.getLandmark(PoseLandmark.LEFT_WRIST)
        val elbowAngle = calculateAngle(
            leftShoulder.position, leftElbow.position, leftWrist.position
        )
    }

ML Kit di iOS: Pose Detection tersedia melalui ML Kit CocoaPods. API identik dengan Android: PoseDetector → UIImage → Pose → PoseLandmark. Di iOS, ML Kit menggunakan Core ML dan ANE (A12+), memberikan latensi 10–20 ms di Accurate Mode pada iPhone 15 Pro. Streaming Mode — 3–8 ms, hingga 120 FPS. Di iOS, ML Kit Pose Detection bekerja lebih cepat dari MediaPipe BlazePose (percepatan Core ML), tetapi kalah dari BlazePose dalam hal jumlah FPS pada perangkat lama (iPhone X–11).

MediaPipe BlazePose: arsitektur dan 3D

MediaPipe BlazePose — model berkinerja tinggi untuk Pose Detection dari Google Research. Menggunakan arsitektur hybrid detector-decoder pipeline berbasis MobileNetV2 + Feature Pyramid Network. BlazePose Full: 33 landmarks + koordinat 3D (kedalaman z). BlazePose Lite: 33 landmarks (2D) tanpa kedalaman. Kedua model tersedia di MediaPipe Tasks Vision pada Android, iOS, Python, dan Web. BlazePose Full memproses 30–60 FPS pada GPU, Lite — 60+ FPS.

3D Pose Estimation dengan BlazePose: model memprediksi koordinat z untuk setiap landmark, memungkinkan penilaian kedalaman (pendekatan/penjauhan anggota tubuh) tanpa kamera stereo. Koordinat z dihitung dalam ruang metrik (meter) relatif terhadap kamera. Akurasi BlazePose 3D: 37 mm MPJPE (Mean Per Joint Position Error) pada benchmark publik — cukup untuk kebugaran dan AR, tidak cukup untuk diagnosis medis. Untuk ARKit/ARFoundation, BlazePose 3D memberikan kedalaman alami.

// MediaPipe Pose Detection Tasks Vision
val options = PoseLandmarkerOptions.Builder()
    .setBaseOptions(BaseOptions.builder()
        .setModelAssetPath("pose_landmarker_full.task")
        .build())
    .setDelegate(Delegate.GPU)
    .build()

val landmaker = PoseLandmarker.createFromOptions(context, options)

val result = landmaker.detect(MPImage.fromBitmap(bitmap))
result.landmarks.forEach { pose ->
    pose.forEach { landmark ->
        drawLandmark(landmark.x, landmark.y, landmark.z)
    }
}

BlazePose vs ML Kit Pose Detection: BlazePose lebih cepat (60+ FPS vs 30 FPS), mendukung koordinat 3D, bekerja lintas platform melalui MediaPipe. ML Kit lebih sederhana untuk diintegrasi (tidak memerlukan MediaPipe SDK), mencakup model terlatih dengan akurasi tinggi. Untuk proyek native iOS — ML Kit Pose Detection (optimasi lebih baik untuk ANE). Untuk proyek lintas platform (Flutter, React Native) — MediaPipe BlazePose (model tunggal untuk semua platform). Untuk akurasi dalam skenario yang menantang — kedua model sebanding.

MoveNet: Lightning dan Thunder dari TensorFlow

MoveNet — keluarga model Pose Detection dari TensorFlow, dioptimalkan untuk TFLite. Lightning (8 MB, INT8 — 4 MB): 17 COCO keypoints, 91% PCK, latensi 8–15 ms, 30+ FPS. Thunder (13 MB, INT8 — 6 MB): 17 keypoints, 95% PCK, latensi 25–40 ms, 20+ FPS. MoveNet menggunakan arsitektur CenterNet + interpolasi bilinear untuk heatmap resolusi tinggi. MoveNet mendukung deteksi multi-pose (hingga 6 orang). Model tersedia di TensorFlow Hub.

MoveNet Lightning vs Thunder: Lightning — untuk aplikasi real-time dengan FPS tinggi (kebugaran, filter AR). Thunder — untuk analisis postur akurat (rehabilitasi, analitik olahraga) pada perangkat dengan GPU. Kedua model dikonversi ke Core ML melalui tf-coreml untuk iOS. MoveNet juga tersedia melalui TFLite Task Vision PoseLandmarker API. Rekomendasi: mulai dengan Lightning, jika akurasi tidak mencukupi — beralih ke Thunder (hanya +15 ms overhead latensi).

// MoveNet Inference with TFLite
Interpreter interpreter = new Interpreter(loadModel(context));
TensorImage image = TensorImage.fromBitmap(bitmap);
image.load(Bitmap.createScaledBitmap(bitmap, 192, 192, true));

float[][] output = new float[1][51];
interpreter.run(image.getTensorBuffer(), output);

float[] keypoints = output[0];
for (int i = 0; i < 17; i++) {
    float y = keypoints[i * 3];
    float x = keypoints[i * 3 + 1];
    float score = keypoints[i * 3 + 2];
    drawKeypoint(x, y, score);
}

MoveNet Multi-Pose: deteksi hingga 6 orang dalam bingkai. Alih-alih pendekatan heatmap standar, MoveNet menggunakan person detection + pose refinement: pertama mendeteksi orang (centroid-based), kemudian menilai postur masing-masing. Mode multi-pose 2–3x lebih lambat dari single-pose: Lightning — 25–50 ms (6 orang). Untuk aplikasi kebugaran dengan satu pengguna, gunakan single-pose. Untuk aktivitas kelompok (yoga, crossfit) — multi-pose dengan batasan bingkai untuk menghemat baterai.

Klasifikasi postur: dari titik ke tindakan

Pose Classification — tahap setelah deteksi: mengubah landmarks menjadi tindakan semantik (berdiri, duduk, mengangkat tangan, melakukan squat). Pendekatan: Rule-based (aturan manual — sudut antar tulang), ML-based (regresi logistik atau Random Forest pada vektor landmarks), DL-based (pengklasifikasi LSTM dari urutan postur per bingkai). Rule-based — akurasi 50–80%, sederhana dan cepat. ML-based — akurasi 85–95% dengan 200+ contoh berlabel. LSTM — akurasi 90–98% pada deret waktu (video).

Sudut antar tulang: untuk setiap titik, sudut dengan titik tetangga dihitung. Contoh: right elbow angle (shoulder → elbow → wrist), right knee angle (hip → knee → ankle), torso angle (titik tengah bahu → titik tengah pinggul). Sudut tidak tergantung pada skala dan posisi orang di layar. Normalisasi sudut ke rentang [0, 1] memungkinkan klasifikasi postur dengan aturan ambang sederhana: jika elbowAngle < 30° — lengan ditekuk, jika > 150° — diluruskan.

// Pengklasifikasi squat berbasis aturan
fun classifySquat(pose: Pose): SquatPhase {
    val kneeAngle = angle(
        pose.getLandmark(PoseLandmark.LEFT_HIP),
        pose.getLandmark(PoseLandmark.LEFT_KNEE),
        pose.getLandmark(PoseLandmark.LEFT_ANKLE)
    )
    return when {
        kneeAngle > 140f -> SquatPhase.STANDING
        kneeAngle < 90f  -> SquatPhase.SQUAT
        else           -> SquatPhase.TRANSITION
    }
}

MediaPipe Pose Classification — pengklasifikasi terlatih dalam MediaPipe Tasks: squat, push-up, plank, angkat kaki. Pengklasifikasi menerima daftar landmarks dan mengembalikan tindakan + kepercayaan diri. Termasuk pemulusan temporal (temporal filter): HED (Holt Exponential Double Smoothing) untuk transisi mulus antar postur. Untuk tindakan kustom — latih pengklasifikasi pada 100–500 contoh melalui MediaPipe Model Maker (TensorFlow Lite + metadata).

Penerapan Pose Detection dalam kebugaran dan rehabilitasi

Pelacak kebugaran dengan koreksi teknik — aplikasi menganalisis postur pengguna selama latihan dan memberikan petunjuk suara: “tu runkan panggul lebih rendah”, “jangan memiringkan tubuh”. ML Kit Pose Detection + pengklasifikasi rule-based menghitung pengulangan dan menilai kualitas. Squat: knee angle < 90° — squat benar, back angle < 45° — kemiringan tubuh berbahaya. Push-up: elbow angle < 90° di titik terbawah — push-up penuh. Pull-up: dagu di atas level palang.

Rehabilitasi dan fisioterapi — Pose Detection digunakan untuk kontrol jarak jauh latihan fisioterapi. Dokter menetapkan postur referensi (misalnya, abduksi bahu 45°), aplikasi mengukur sudut saat ini dan penyimpangan. BlazePose 3D memberikan akurasi sudut ±3° — cukup untuk penilaian klinis. Frekuensi: 1 bingkai per 3–5 detik (menghemat baterai). On-device — privasi data medis pasien. Rehabilitasi pasca stroke: pelacakan hand-to-shoulder, elbow-extension, hip-flexion.

Filter AR dan efek — Pose Detection mendasari filter AR media sosial (TikTok, Instagram, Snapchat). Landmarks kepala, bahu, dan tangan digunakan untuk menimpa masker, animasi, dan elemen dekoratif. MediaPipe BlazePose Full + Face Mesh (468 titik) memberikan 120+ FPS pada perangkat unggulan. ARKit/ARCore Face Tracking + Pose Detection — kombinasi untuk full-body AR. Persyaratan: FPS > 30, latensi motion-to-photon < 20 ms.

// Filter AR dengan landmark postur
let request = VNDetectHumanBodyPoseRequest { req, _ in
    guard let observation = req.results?.first as? VNHumanBodyPoseObservation else { return }
    let keypoints = try observation.recognizedPoints(.all)
    let rightShoulder = keypoints[VNHumanBodyPoseObservation.JointName.rightShoulder]
    DispatchQueue.main.async {
        arView.placeFilter(at: rightShoulder?.location ?? .zero)
    }
}

Analitik olahraga — penilaian teknik profesional: analisis biomekanik lari (cadence, stride length, arm swing symmetry), renang (body roll, elbow angle saat menarik), tenis (shoulder rotation, wrist snap). MoveNet Thunder dengan pasca-pemrosesan memberikan akurasi yang cukup untuk analitik non-profesional. Untuk olahraga profesional diperlukan 3D Motion Capture (Vicon, OptiTrack), tetapi Pose Detection di ponsel adalah alternatif yang terjangkau untuk pasar massal. Sinkronisasi sudut antar bingkai — komponen kunci.