Pose Detection: vad är det, modeller och funktionsprincip

Vad är Pose Detection: grunder och mätvärden

Pose Detection (även känt som Pose Estimation) avser uppgiften att bestämma semantiska nyckelpunkter på människokroppen från en bild eller video. Top-down-metoden detekterar först personen (Object Detection), därefter bestämmer dess hållning. Bottom-up-metoden hittar alla landmarks i bilden, grupperar dem sedan per person (OpenPose). För mobila enheter används bottom-up — snabbare när flera personer är i bild. ML Kit och BlazePose använder en single-stage-metod — detektering + hållning i en enda genomgång.

COCO Keypoints — standarduppsättning av 17 punkter: näsa, ögon (2), öron (2), axlar (2), armbågar (2), handleder (2), höfter (2), knän (2), anklar (2). MediaPipe BlazePose använder 33 punkter och lägger till: tår, hälar, mittpunkt av bälen, ansiktspunkter. Ju fler punkter, desto mer exakt positionsanalys, men desto högre beräkningsbelastning. För fitness-appar räcker 17–20 punkter. För fullständig analys (yoga, dans) — 33 punkter. För AR-filter — 33 punkter + 468 ansiktspunkter (MediaPipe Face Mesh).

PCK (Percentage of Correct Keypoints) — noggrannhetsmått för Pose Detection. Beräknas som andelen punkter som förutsägs inom ett avstånd från ground truth (vanligtvis 0.05–0.15 av personens bounding box-storlek). ML Kit Pose Detection: 94% PCK@0.1. BlazePose Full: 96% PCK@0.1. MoveNet Lightning: 91% PCK@0.1. OKS (Object Keypoint Similarity) — mått som används i COCO, med hänsyn till personens skala och punktens svårighetsgrad. mAP@OKS — standardmått för benchmarks.

Keypoint Visibility: varje landmark har ett poäng (0..1) som anger hur säker modellen är på punkten och om den är synlig. Punkter med poäng < 0.5 anses osynliga (täckta, utanför bildrutan). För positionsanalys, använd endast synliga punkter. För utvärdering av inriktning — beräkna confidence-weighted distances, där punkter med lågt poäng har mindre vikt i måttet.

ML Kit Pose Detection på Android och iOS

ML Kit Pose Detection — bibliotek från Google för att bestämma hållning på enheten. Stödjer 33 landmarks, inklusive ansiktspunkter, tår och hälar. Lägen: Accurate Mode (14 MB modell, 15–30 ms, hög noggrannhet) och Streaming Mode (5 MB, 5–10 ms, för realtid). Streaming Mode använder en lätt modell med spårning — efter den första bildrutan spårar den rörelse utan att detektera exakta positioner igen, vilket ger upp till 60 FPS.

ML Kit Pose Detection API: PoseDetector (alternativ: setDetectorMode, setPerformanceMode) → InputImage → Pose (List<PoseLandmark>). Varje PoseLandmark har: landmarkType (38 typer), position (PointF3D), inFrameLikelihood (0..1). Pose tillhandahåller också: personens boundingBox, lista över landmarks, metod getLandmark(type). För positionsklassificering, använd vinklar mellan ben: shoulderAngle, elbowAngle, hipAngle — beräknade via Vector3D mellan angränsande landmarks.

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 på iOS: Pose Detection är tillgängligt via ML Kit CocoaPods. API är identiskt med Android: PoseDetector → UIImage → Pose → PoseLandmark. På iOS använder ML Kit Core ML och ANE (A12+), vilket ger 10–20 ms latens i Accurate Mode på iPhone 15 Pro. Streaming Mode — 3–8 ms, upp till 120 FPS. På iOS fungerar ML Kit Pose Detection snabbare än MediaPipe BlazePose (Core ML-acceleration), men är sämre än BlazePose i FPS på äldre enheter (iPhone X–11).

MediaPipe BlazePose: arkitektur och 3D

MediaPipe BlazePose — högpresterande modell för Pose Detection från Google Research. Använder en hybrid arkitektur detector-decoder pipeline baserad på MobileNetV2 + Feature Pyramid Network. BlazePose Full: 33 landmarks + 3D-koordinater (djup z). BlazePose Lite: 33 landmarks (2D) utan djup. Båda modellerna är tillgängliga i MediaPipe Tasks Vision på Android, iOS, Python och Web. BlazePose Full bearbetar 30–60 FPS på GPU, Lite — 60+ FPS.

3D Pose Estimation med BlazePose: modellen förutsäger z-koordinat för varje landmark, vilket möjliggör djupbedömning (närmande/avlägsnande av lemmar) utan stereokamera. Z-koordinaten beräknas i metriskt rum (meter) relativt kameran. BlazePose 3D-noggrannhet: 37 mm MPJPE (Mean Per Joint Position Error) på offentliga benchmarks — tillräckligt för fitness och AR, otillräckligt för medicinsk diagnostik. För ARKit/ARFoundation ger BlazePose 3D naturligt djup.

// 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 är snabbare (60+ FPS vs 30 FPS), stödjer 3D-koordinater, fungerar cross-platform via MediaPipe. ML Kit är enklare att integrera (kräver inte MediaPipe SDK), innehåller förtränade modeller med hög noggrannhet. För native iOS-projekt — ML Kit Pose Detection (bättre optimering för ANE). För cross-platform-projekt (Flutter, React Native) — MediaPipe BlazePose (enda modell för alla plattformar). För noggrannhet i krävande scener — båda modellerna är jämförbara.

MoveNet: Lightning och Thunder från TensorFlow

MoveNet — familj av Pose Detection-modeller från TensorFlow, optimerade för TFLite. Lightning (8 MB, INT8 — 4 MB): 17 COCO keypoints, 91% PCK, 8–15 ms latens, 30+ FPS. Thunder (13 MB, INT8 — 6 MB): 17 keypoints, 95% PCK, 25–40 ms latens, 20+ FPS. MoveNet använder CenterNet-arkitektur + bilinjär interpolation för högupplöst heatmap. MoveNet stödjer multi-pose-detektering (upp till 6 personer). Modellerna finns i TensorFlow Hub.

MoveNet Lightning vs Thunder: Lightning — för realtidsappar med hög FPS (fitness, AR-filter). Thunder — för exakt positionsanalys (rehabilitering, sportanalys) på enheter med GPU. Båda modellerna konverteras till Core ML via tf-coreml för iOS. MoveNet är också tillgängligt via TFLite Task Vision PoseLandmarker API. Rekommendation: börja med Lightning, om noggrannheten är otillräcklig — byt till Thunder (endast +15 ms latensökning).

// 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: detekterar upp till 6 personer i bilden. Istället för standard heatmap-metoden använder MoveNet person detection + pose refinement: först detekterar personer (centroid-based), sedan bedömer varje persons hållning. Multi-pose-läget är 2–3x långsammare än single-pose: Lightning — 25–50 ms (6 personer). För fitness-appar med en enskild användare, använd single-pose. För gruppaktiviteter (yoga, crossfit) — multi-pose med bildrutebegränsning för att spara batteri.

Positionsklassificering: från punkter till handlingar

Pose Classification — steg efter detektering: omvandling av landmarks till semantiska handlingar (står, sitter, har lyft handen, gör knäböj). Metoder: Rule-based (manuella regler — vinklar mellan ben), ML-based (logistisk regression eller Random Forest på landmark-vektor), DL-based (LSTM-klassificerare av positionssekvens över bildrutor). Rule-based — 50–80% noggrannhet, enkel och snabb. ML-based — 85–95% noggrannhet med 200+ märkta exempel. LSTM — 90–98% noggrannhet på tidsserier (video).

Vinklar mellan ben: för varje punkt beräknas vinklar med angränsande punkter. Exempel: right elbow angle (shoulder → elbow → wrist), right knee angle (hip → knee → ankle), torso angle (mittpunkt av axlar → mittpunkt av höfter). Vinklar är oberoende av skala och personens position på skärmen. Normalisering av vinklar till intervallet [0, 1] möjliggör klassificering av hållning med en enkel tröskelregel: om elbowAngle < 30° — armen böjd, om > 150° — utsträckt.

// Regelbaserad knäböjs klassificerare
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 — förtränade klassificerare i MediaPipe Tasks: knäböj, armhävningar, planka, benlyft. Klassificeraren tar emot en lista av landmarks och returnerar handlingen + konfidens. Inkluderar temporal utjämning (temporal filter): HED (Holt Exponential Double Smoothing) för mjuka övergångar mellan positioner. För anpassade handlingar — träna en klassificerare på 100–500 exempel via MediaPipe Model Maker (TensorFlow Lite + metadata).

Tillämpning av Pose Detection inom fitness och rehabilitering

Fitness-trackers med teknikkorrigering — appen analyserar användarens hållning under träning och ger röstinstruktioner: ”sänk bäckenet”, “luda inte bölen”. ML Kit Pose Detection + rule-baserad klassificerare räknar repetitioner och bedömer kvalitet. Squat: knee angle < 90° — korrekt knäböj, back angle < 45° — farlig bölning. Push-up: elbow angle < 90° i nedre läget — full armhävning. Pull-up: hakan över stångnivå.

Rehabilitering och sjukgymnastik — Pose Detection används för fjärrkontroll av sjukgymnastikövningar. Läkaren ställer in en referensposition (t.ex. axelabduktion på 45°), appen mäter aktuell vinkel och avvikelser. BlazePose 3D ger vinkelnoggrannhet på ±3° — tillräckligt för klinisk bedömning. Frekvens: 1 bildruta per 3–5 sekunder (batteribesparing). On-device — integritet för patientens medicinska data. Rehabilitering efter stroke: spårning av hand-to-shoulder, elbow-extension, hip-flexion.

AR-filter och effekter — Pose Detection ligger till grund för AR-filter i sociala medier (TikTok, Instagram, Snapchat). Landmarks av huvud, axlar och händer används för att överlagra masker, animationer och dekorativa element. MediaPipe BlazePose Full + Face Mesh (468 punkter) ger 120+ FPS på flaggskeppsenheter. ARKit/ARCore Face Tracking + Pose Detection — kombination för full-body AR. Krav: FPS > 30, motion-to-photon latens < 20 ms.

// AR-filter med positions-landmarks
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)
    }
}

Sportanalys — professionell teknikbedömning: biomekanisk analys av löpning (cadence, stride length, arm swing symmetry), simning (body roll, elbow angle vid tag), tennis (shoulder rotation, wrist snap). MoveNet Thunder med efterbehandling ger tillräcklig noggrannhet för icke-professionell analys. För professionell sport krävs 3D Motion Capture (Vicon, OptiTrack), men Pose Detection på telefonen är ett tillgängligt alternativ för massmarknaden. Synkronisering av vinklar mellan bildrutor — nyckelkomponent.