kinemotion 0.70.1__py3-none-any.whl → 0.71.1__py3-none-any.whl

kinemotion/core/pose.py

@@ -18,6 +18,8 @@ Configuration strategies for matching Solution API behavior:
 
 from __future__ import annotations
 
+from typing import Any
+
 import cv2
 import mediapipe as mp
 import numpy as np
@@ -159,474 +161,42 @@ class MediaPipePoseTracker:
 
 
 class PoseTrackerFactory:
-    """Factory for creating pose trackers with automatic backend selection.
+    """Factory for creating pose trackers.
 
-    Supports multiple backends with auto-detection:
-    - RTMPose CUDA: NVIDIA GPU acceleration (fastest, 133 FPS)
-    - RTMPose CoreML: Apple Silicon acceleration (42 FPS)
-    - RTMPose CPU: Optimized CPU implementation (40-68 FPS)
-    - MediaPipe: Fallback baseline (48 FPS)
+    Currently supports MediaPipe as the only backend.
 
     Usage:
-        # Auto-detect best backend
         tracker = PoseTrackerFactory.create()
-
-        # Force specific backend
-        tracker = PoseTrackerFactory.create(backend='rtmpose-cuda')
-
-        # Check available backends
-        available = PoseTrackerFactory.get_available_backends()
     """
 
-    # Backend class mappings
-    _BACKENDS: dict[str, type] = {}
-
     @classmethod
     def create(
         cls,
-        backend: str = "auto",
-        mode: str = "lightweight",
-        **kwargs: object,
-    ) -> object:
-        """Create a pose tracker with the specified backend.
-
-        Args:
-            backend: Backend selection:
-                - 'auto': Auto-detect best available backend
-                - 'mediapipe': MediaPipe Tasks API (baseline)
-                - 'rtmpose-cpu': RTMPose optimized CPU
-                - 'rtmpose-cuda': RTMPose with CUDA (NVIDIA GPU)
-                - 'rtmpose-coreml': RTMPose with CoreML (Apple Silicon)
-            mode: RTMPose performance mode ('lightweight', 'balanced', 'performance')
-                Only used for RTMPose backends
-            **kwargs: Additional arguments passed to tracker constructor
-
-        Returns:
-            Configured pose tracker instance
-
-        Raises:
-            ValueError: If backend is not available or recognized
-        """
-        # Auto-detect backend
-        if backend == "auto":
-            backend = cls._detect_best_backend()
-            backend = cls._check_backend_available(backend)
-
-        # Check environment variable override
-        import os
-
-        env_backend = os.environ.get("POSE_TRACKER_BACKEND")
-        if env_backend:
-            backend = cls._normalize_backend_name(env_backend)
-
-        # Verify backend is available
-        backend = cls._check_backend_available(backend)
-
-        # Get tracker class
-        tracker_class = cls._get_tracker_class(backend)
-
-        # Create tracker with appropriate arguments
-        return cls._create_tracker(tracker_class, backend, mode, kwargs)
-
-    @classmethod
-    def _detect_best_backend(cls) -> str:
-        """Detect the best available backend.
-
-        Priority order:
-        1. CUDA (NVIDIA GPU) - fastest
-        2. CoreML (Apple Silicon) - good performance
-        3. RTMPose CPU - optimized CPU
-        4. MediaPipe - baseline fallback
-
-        Returns:
-            Backend name string
-        """
-        # Check for CUDA (NVIDIA GPU)
-        try:
-            import torch
-
-            if torch.cuda.is_available():
-                return "rtmpose-cuda"
-        except ImportError:
-            pass
-
-        # Check for CoreML (Apple Silicon)
-        import sys
-
-        if sys.platform == "darwin":
-            return "rtmpose-coreml"
-
-        # Check for RTMPose CPU
-        try:
-            from kinemotion.core.rtmpose_cpu import (
-                OptimizedCPUTracker as _RTMPoseCPU,  # type: ignore
-            )
-
-            _ = _RTMPoseCPU  # Mark as intentionally used for availability check
-
-            return "rtmpose-cpu"
-        except ImportError:
-            pass
-
-        # Fallback to MediaPipe
-        return "mediapipe"
-
-    @classmethod
-    def _check_backend_available(cls, backend: str) -> str:
-        """Check if a backend is available and return a fallback if not.
+        backend: str = "mediapipe",
+        **kwargs: Any,
+    ) -> MediaPipePoseTracker:
+        """Create a MediaPipe pose tracker.
 
         Args:
-            backend: Requested backend name
+            backend: Backend selection (only 'mediapipe' supported)
+            **kwargs: Arguments passed to MediaPipePoseTracker
 
         Returns:
-            Available backend name (may be different from requested)
+            Configured MediaPipePoseTracker instance
 
         Raises:
-            ValueError: If no backend is available
-        """
-        normalized = cls._normalize_backend_name(backend)
-
-        # Check if specific backend can be imported
-        if normalized == "rtmpose-cuda":
-            try:
-                import torch  # noqa: F401
-
-                if not torch.cuda.is_available():
-                    # CUDA not available, fall back to CPU
-                    return cls._check_backend_available("rtmpose-cpu")
-                # CUDA is available, use rtmpose-cuda
-                return normalized
-            except ImportError:
-                return cls._check_backend_available("rtmpose-cpu")
-
-        if normalized == "rtmpose-coreml":
-            import sys
-
-            if sys.platform != "darwin":
-                # Not macOS, fall back to CPU
-                return cls._check_backend_available("rtmpose-cpu")
-
-            # On macOS, verify CoreML wrapper is available
-            try:
-                from kinemotion.core.rtmpose_wrapper import RTMPoseWrapper
-
-                _ = RTMPoseWrapper  # Mark as intentionally used
-                return normalized
-            except ImportError:
-                # CoreML wrapper not available, fall back to CPU
-                return cls._check_backend_available("rtmpose-cpu")
-
-        if normalized == "rtmpose-cpu":
-            try:
-                from kinemotion.core.rtmpose_cpu import (
-                    OptimizedCPUTracker as _RTMPoseCPU,
-                )  # type: ignore
-
-                _ = _RTMPoseCPU  # Mark as intentionally used for availability check
-
-                return normalized
-            except ImportError:
-                # RTMPose not available, fall back to MediaPipe
-                return "mediapipe"
-
-        if normalized == "mediapipe":
-            try:
-                import mediapipe as _mp  # noqa: F401
-
-                _ = _mp  # Mark as intentionally used for availability check
-                return normalized
-            except ImportError as err:
-                raise ValueError(
-                    "No pose tracking backend available. Please install mediapipe or rtmlib."
-                ) from err
-
-        raise ValueError(f"Unknown backend: {backend}")
-
-    @classmethod
-    def _normalize_backend_name(cls, backend: str) -> str:
-        """Normalize backend name to canonical form.
-
-        Args:
-            backend: User-provided backend name
-
-        Returns:
-            Canonical backend name
-        """
-        # Normalize various aliases to canonical names
-        aliases = {
-            "mp": "mediapipe",
-            "mediapipe": "mediapipe",
-            "rtmpose": "rtmpose-cpu",
-            "rtmpose-cpu": "rtmpose-cpu",
-            "rtmpose_cpu": "rtmpose-cpu",
-            "cpu": "rtmpose-cpu",
-            "cuda": "rtmpose-cuda",
-            "rtmpose-cuda": "rtmpose-cuda",
-            "rtmpose_cuda": "rtmpose-cuda",
-            "gpu": "rtmpose-cuda",
-            "mps": "rtmpose-coreml",
-            "coreml": "rtmpose-coreml",
-            "rtmpose-coreml": "rtmpose-coreml",
-            "rtmpose_coreml": "rtmpose-coreml",
-        }
-        return aliases.get(backend.lower(), backend)
-
-    @classmethod
-    def _get_tracker_class(cls, backend: str):
-        """Get the tracker class for a backend.
-
-        Args:
-            backend: Canonical backend name
-
-        Returns:
-            Tracker class
-
-        Raises:
-            ValueError: If backend is not recognized
-        """
-        if backend == "mediapipe":
-            return MediaPipePoseTracker
-
-        if backend == "rtmpose-cpu":
-            try:
-                from kinemotion.core.rtmpose_cpu import OptimizedCPUTracker
-
-                return OptimizedCPUTracker
-            except ImportError as e:
-                raise ValueError(f"RTMPose CPU backend requested but not available: {e}") from e
-
-        if backend in ("rtmpose-cuda", "rtmpose-coreml"):
-            try:
-                from kinemotion.core.rtmpose_wrapper import RTMPoseWrapper
-
-                return RTMPoseWrapper
-            except ImportError as e:
-                raise ValueError(
-                    f"RTMPose wrapper backend requested but not available: {e}"
-                ) from e
-
-        raise ValueError(f"Unknown backend: {backend}")
-
-    @classmethod
-    def _create_tracker(
-        cls,
-        tracker_class: type,
-        backend: str,
-        mode: str,
-        kwargs: dict[str, object],
-    ) -> object:
-        """Create a tracker instance with appropriate arguments.
-
-        Args:
-            tracker_class: Tracker class to instantiate
-            backend: Backend name (for parameter mapping)
-            mode: RTMPose mode (only used for RTMPose backends)
-            kwargs: Additional arguments from user
-
-        Returns:
-            Tracker instance
-        """
-        # MediaPipe-specific arguments
-        if backend == "mediapipe":
-            # Remove RTMPose-specific arguments
-            rttmpose_keys = {"mode", "backend", "device", "pose_input_size"}
-            filtered_kwargs = {k: v for k, v in kwargs.items() if k not in rttmpose_keys}
-            return tracker_class(**filtered_kwargs)
-
-        # OptimizedCPUTracker (CPU-only, doesn't accept device parameter)
-        if backend == "rtmpose-cpu":
-            # Remove RTMPoseWrapper-specific and MediaPipe-specific arguments
-            unsupported_keys = {
-                "backend",
-                "device",
-                "min_detection_confidence",
-                "min_tracking_confidence",
-            }
-            filtered_kwargs = {k: v for k, v in kwargs.items() if k not in unsupported_keys}
-            filtered_kwargs.setdefault("mode", mode)
-            return tracker_class(**filtered_kwargs)
-
-        # RTMPoseWrapper (CUDA/CoreML, requires device parameter)
-        # Remove MediaPipe-specific arguments
-        mediapipe_keys = {"min_detection_confidence", "min_tracking_confidence"}
-        filtered_kwargs = {k: v for k, v in kwargs.items() if k not in mediapipe_keys}
-
-        device = backend.split("-")[-1]  # Extract 'cuda', 'cpu', 'coreml'
-        if device == "coreml":
-            device = "mps"  # RTMLib uses 'mps' for Apple Silicon
-
-        filtered_kwargs.setdefault("device", device)
-        filtered_kwargs.setdefault("mode", mode)
-
-        return tracker_class(**filtered_kwargs)
-
-    @classmethod
-    def get_available_backends(cls) -> list[str]:
-        """Get list of available backends on current system.
-
-        Returns:
-            List of available backend names
+            ValueError: If backend is not 'mediapipe'
         """
-        available = []
-
-        # Always have MediaPipe as fallback
-        try:
-            import mediapipe as _mp  # noqa: F401
-
-            _ = _mp  # Mark as intentionally used for availability check
-            available.append("mediapipe")
-        except ImportError:
-            pass
-
-        # Check RTMPose CPU
-        try:
-            from kinemotion.core.rtmpose_cpu import (
-                OptimizedCPUTracker as _RTMPoseCPU,
-            )  # type: ignore
-
-            _ = _RTMPoseCPU  # Mark as intentionally used for availability check
+        # Normalize and validate backend
+        normalized = backend.lower()
+        if normalized not in ("mediapipe", "mp", "auto"):
+            raise ValueError(f"Unknown backend: {backend}. Only 'mediapipe' is supported.")
 
-            available.append("rtmpose-cpu")
-        except ImportError:
-            pass
+        # Filter out any legacy kwargs that don't apply to MediaPipe
+        legacy_keys = {"mode", "backend", "device", "pose_input_size"}
+        filtered_kwargs = {k: v for k, v in kwargs.items() if k not in legacy_keys}
 
-        # Check CUDA
-        try:
-            import torch
-
-            if torch.cuda.is_available():
-                from kinemotion.core.rtmpose_wrapper import (
-                    RTMPoseWrapper as _RTMPoseWrapper,
-                )  # type: ignore
-
-                _ = _RTMPoseWrapper  # Mark as intentionally used for availability check
-
-                available.append("rtmpose-cuda")
-        except ImportError:
-            pass
-
-        # Check CoreML (Apple Silicon)
-        import sys
-
-        if sys.platform == "darwin":
-            try:
-                from kinemotion.core.rtmpose_wrapper import (
-                    RTMPoseWrapper as _RTMPoseWrapperMPS,
-                )  # type: ignore
-
-                _ = _RTMPoseWrapperMPS  # Mark as intentionally used for availability check
-
-                available.append("rtmpose-coreml")
-            except ImportError:
-                pass
-
-        return available
-
-    @classmethod
-    def get_backend_info(cls, backend: str) -> dict[str, str]:
-        """Get information about a backend.
-
-        Args:
-            backend: Backend name
-
-        Returns:
-            Dictionary with backend information
-        """
-        info = {
-            "mediapipe": {
-                "name": "MediaPipe",
-                "description": "Baseline pose tracking using MediaPipe Tasks API",
-                "performance": "~48 FPS",
-                "accuracy": "Baseline (reference)",
-                "requirements": "mediapipe package",
-            },
-            "rtmpose-cpu": {
-                "name": "RTMPose CPU",
-                "description": "Optimized CPU implementation with ONNX Runtime",
-                "performance": "~40-68 FPS (134% of MediaPipe)",
-                "accuracy": "9-12px mean difference (1-5% metric accuracy)",
-                "requirements": "rtmlib package",
-            },
-            "rtmpose-cuda": {
-                "name": "RTMPose CUDA",
-                "description": "NVIDIA GPU acceleration with CUDA",
-                "performance": "~133 FPS (271% of MediaPipe)",
-                "accuracy": "9-12px mean difference (1-5% metric accuracy)",
-                "requirements": "rtmlib + CUDA-capable GPU",
-            },
-            "rtmpose-coreml": {
-                "name": "RTMPose CoreML",
-                "description": "Apple Silicon acceleration with CoreML",
-                "performance": "~42 FPS (94% of MediaPipe)",
-                "accuracy": "9-12px mean difference (1-5% metric accuracy)",
-                "requirements": "rtmlib + Apple Silicon",
-            },
-        }
-
-        normalized = cls._normalize_backend_name(backend)
-        return info.get(normalized, {})
-
-
-def get_tracker_info(tracker: object) -> str:
-    """Get detailed information about a pose tracker instance.
-
-    Args:
-        tracker: Pose tracker instance
-
-    Returns:
-        Formatted string with tracker details
-    """
-    tracker_class = type(tracker).__name__
-    module = type(tracker).__module__
-
-    info = f"{tracker_class} (from {module})"
-
-    # Add backend-specific details
-    if tracker_class == "MediaPipePoseTracker":
-        info += " [MediaPipe Tasks API]"
-    elif tracker_class == "OptimizedCPUTracker":
-        # Check if ONNX Runtime has CUDA
-        try:
-            import onnxruntime as ort
-
-            providers = ort.get_available_providers()
-            if "CUDAExecutionProvider" in providers:
-                # Check what providers the session is actually using
-                det_session = getattr(tracker, "det_session", None)
-                if det_session is not None:
-                    active_providers = det_session.get_providers()
-                    if "CUDAExecutionProvider" in active_providers:
-                        info += " [ONNX Runtime: CUDA]"
-                    else:
-                        info += " [ONNX Runtime: CPU]"
-                else:
-                    info += " [ONNX Runtime]"
-            else:
-                info += " [ONNX Runtime: CPU]"
-        except ImportError:
-            info += " [ONNX Runtime]"
-    elif tracker_class == "RTMPoseWrapper":
-        device = getattr(tracker, "device", None)
-        if device:
-            if device == "cuda":
-                try:
-                    import torch
-
-                    if torch.cuda.is_available():
-                        device_name = torch.cuda.get_device_name(0)
-                        info += f" [PyTorch CUDA: {device_name}]"
-                    else:
-                        info += " [PyTorch: CPU fallback]"
-                except ImportError:
-                    info += " [PyTorch CUDA]"
-            elif device == "mps":
-                info += " [PyTorch: Apple Silicon GPU]"
-            else:
-                info += f" [PyTorch: {device}]"
-        else:
-            info += " [PyTorch]"
-
-    return info
+        return MediaPipePoseTracker(**filtered_kwargs)
 
 
 def _extract_landmarks_from_results(
@@ -654,28 +224,6 @@ def _extract_landmarks_from_results(
     return landmarks
 
 
-# Legacy compatibility aliases for Solution API enum values
-class _LegacyPoseLandmark:
-    """Compatibility shim for Solution API enum values."""
-
-    LEFT_ANKLE = 27
-    RIGHT_ANKLE = 28
-    LEFT_HEEL = 29
-    RIGHT_HEEL = 30
-    LEFT_FOOT_INDEX = 31
-    RIGHT_FOOT_INDEX = 32
-    LEFT_HIP = 23
-    RIGHT_HIP = 24
-    LEFT_SHOULDER = 11
-    RIGHT_SHOULDER = 12
-    NOSE = 0
-    LEFT_KNEE = 25
-    RIGHT_KNEE = 26
-
-
-PoseLandmark = _LegacyPoseLandmark
-
-
 def compute_center_of_mass(
     landmarks: dict[str, tuple[float, float, float]],
     visibility_threshold: float = 0.5,
@@ -754,6 +302,37 @@ def compute_center_of_mass(
     return (com_x, com_y, com_visibility)
 
 
+def _compute_mean_landmark_position(
+    landmark_keys: list[str],
+    landmarks: dict[str, tuple[float, float, float]],
+    vis_threshold: float,
+) -> tuple[float, float, float] | None:
+    """Compute mean position and visibility from multiple landmarks.
+
+    Args:
+        landmark_keys: List of landmark key names to average
+        landmarks: Dictionary of landmark positions
+        vis_threshold: Minimum visibility threshold
+
+    Returns:
+        (x, y, visibility) tuple if any landmarks are visible, else None
+    """
+    positions = [
+        (x, y, vis)
+        for key in landmark_keys
+        if key in landmarks
+        for x, y, vis in [landmarks[key]]
+        if vis > vis_threshold
+    ]
+    if not positions:
+        return None
+
+    x = float(np.mean([p[0] for p in positions]))
+    y = float(np.mean([p[1] for p in positions]))
+    vis = float(np.mean([p[2] for p in positions]))
+    return (x, y, vis)
+
+
 def _add_head_segment(
     segments: list,
     weights: list,
@@ -779,20 +358,17 @@ def _add_trunk_segment(
 ) -> None:
     """Add trunk segment (50% body mass) if visible."""
     trunk_keys = ["left_shoulder", "right_shoulder", "left_hip", "right_hip"]
-    trunk_pos = [
-        (x, y, vis)
-        for key in trunk_keys
-        if key in landmarks
-        for x, y, vis in [landmarks[key]]
-        if vis > vis_threshold
-    ]
-    if len(trunk_pos) >= 2:
-        trunk_x = float(np.mean([p[0] for p in trunk_pos]))
-        trunk_y = float(np.mean([p[1] for p in trunk_pos]))
-        trunk_vis = float(np.mean([p[2] for p in trunk_pos]))
-        segments.append((trunk_x, trunk_y))
-        weights.append(0.50)
-        visibilities.append(trunk_vis)
+    trunk_pos = _compute_mean_landmark_position(trunk_keys, landmarks, vis_threshold)
+
+    if trunk_pos is not None:
+        # Require at least 2 visible landmarks for valid trunk
+        visible_count = sum(
+            1 for key in trunk_keys if key in landmarks and landmarks[key][2] > vis_threshold
+        )
+        if visible_count >= 2:
+            segments.append((trunk_pos[0], trunk_pos[1]))
+            weights.append(0.50)
+            visibilities.append(trunk_pos[2])
 
 
 def _add_limb_segment(
@@ -832,17 +408,9 @@ def _add_foot_segment(
 ) -> None:
     """Add foot segment (1.5% body mass per foot) if visible."""
     foot_keys = [f"{side}_ankle", f"{side}_heel", f"{side}_foot_index"]
-    foot_pos = [
-        (x, y, vis)
-        for key in foot_keys
-        if key in landmarks
-        for x, y, vis in [landmarks[key]]
-        if vis > vis_threshold
-    ]
-    if foot_pos:
-        foot_x = float(np.mean([p[0] for p in foot_pos]))
-        foot_y = float(np.mean([p[1] for p in foot_pos]))
-        foot_vis = float(np.mean([p[2] for p in foot_pos]))
-        segments.append((foot_x, foot_y))
+    foot_pos = _compute_mean_landmark_position(foot_keys, landmarks, vis_threshold)
+
+    if foot_pos is not None:
+        segments.append((foot_pos[0], foot_pos[1]))
         weights.append(0.015)
-        visibilities.append(foot_vis)
+        visibilities.append(foot_pos[2])