kinemotion 0.70.0__py3-none-any.whl → 0.71.0__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,358 +161,51 @@ 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.
-
-        Args:
-            backend: Requested backend name
-
-        Returns:
-            Available backend name (may be different from requested)
-
-        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")
-
-        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.
+        backend: str = "mediapipe",
+        **kwargs: Any,
+    ) -> MediaPipePoseTracker:
+        """Create a MediaPipe pose tracker.
 
         Args:
-            backend: Canonical backend name
+            backend: Backend selection (only 'mediapipe' supported)
+            **kwargs: Arguments passed to MediaPipePoseTracker
 
         Returns:
-            Tracker class
+            Configured MediaPipePoseTracker instance
 
         Raises:
-            ValueError: If backend is not recognized
+            ValueError: If backend is not 'mediapipe'
         """
-        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
+        # Normalize and validate backend
+        normalized = backend.lower()
+        if normalized not in ("mediapipe", "mp", "auto"):
+            raise ValueError(f"Unknown backend: {backend}. Only 'mediapipe' is supported.")
 
-        if backend in ("rtmpose-cuda", "rtmpose-coreml"):
-            try:
-                from kinemotion.core.rtmpose_wrapper import RTMPoseWrapper
+        # 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}
 
-                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)
+        return MediaPipePoseTracker(**filtered_kwargs)
 
     @classmethod
     def get_available_backends(cls) -> list[str]:
-        """Get list of available backends on current system.
+        """Get list of available backends.
 
         Returns:
-            List of available backend names
+            List containing '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
-
-            available.append("rtmpose-cpu")
-        except ImportError:
-            pass
-
-        # 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
+        return ["mediapipe"]
 
     @classmethod
     def get_backend_info(cls, backend: str) -> dict[str, str]:
@@ -522,39 +217,15 @@ class PoseTrackerFactory:
         Returns:
             Dictionary with backend information
         """
-        info = {
-            "mediapipe": {
+        if backend.lower() in ("mediapipe", "mp"):
+            return {
                 "name": "MediaPipe",
-                "description": "Baseline pose tracking using MediaPipe Tasks API",
+                "description": "Pose tracking using MediaPipe Tasks API",
                 "performance": "~48 FPS",
-                "accuracy": "Baseline (reference)",
+                "accuracy": "Reference (validated for jumps)",
                 "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, {})
+            }
+        return {}
 
 
 def get_tracker_info(tracker: object) -> str:
@@ -571,50 +242,8 @@ def get_tracker_info(tracker: object) -> str:
 
     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
 

kinemotion/dropjump/api.py

@@ -90,7 +90,6 @@ class DropJumpVideoConfig:
     overrides: AnalysisOverrides | None = None
     detection_confidence: float | None = None
     tracking_confidence: float | None = None
-    pose_backend: str | None = None
 
 
 def _assess_dropjump_quality(
@@ -237,7 +236,6 @@ def _setup_pose_tracker(
     detection_confidence: float | None,
     tracking_confidence: float | None,
     pose_tracker: "MediaPipePoseTracker | None",
-    pose_backend: str | None,
     timer: Timer,
     verbose: bool = False,
 ) -> tuple["MediaPipePoseTracker", bool]:
@@ -250,29 +248,13 @@ def _setup_pose_tracker(
     should_close_tracker = False
 
     if tracker is None:
-        if pose_backend is not None:
-            import time
-
-            from ..core import get_tracker_info
-            from ..core.pose import PoseTrackerFactory
-
-            init_start = time.perf_counter()
-            tracker = PoseTrackerFactory.create(
-                backend=pose_backend,
-                timer=timer,
-            )
-            init_time = time.perf_counter() - init_start
-
-            if verbose:
-                print(f"Using pose backend: {pose_backend}")
-                print(f"  → {get_tracker_info(tracker)}")
-                print(f"  → Initialized in {init_time * 1000:.1f} ms")
-        else:
-            tracker = MediaPipePoseTracker(
-                min_detection_confidence=detection_conf,
-                min_tracking_confidence=tracking_conf,
-                timer=timer,
-            )
+        if verbose:
+            print("Processing all frames with MediaPipe pose tracking...")
+        tracker = MediaPipePoseTracker(
+            min_detection_confidence=detection_conf,
+            min_tracking_confidence=tracking_conf,
+            timer=timer,
+        )
         should_close_tracker = True
 
     return tracker, should_close_tracker
@@ -509,7 +491,6 @@ def process_dropjump_video(
     verbose: bool = False,
     timer: Timer | None = None,
     pose_tracker: "MediaPipePoseTracker | None" = None,
-    pose_backend: str | None = None,
 ) -> DropJumpMetrics:
     """
     Process a single drop jump video and return metrics.
@@ -554,7 +535,6 @@ def process_dropjump_video(
                 detection_confidence,
                 tracking_confidence,
                 pose_tracker,
-                pose_backend,
                 timer,
                 verbose,
             )

kinemotion/dropjump/cli.py

@@ -31,7 +31,6 @@ class AnalysisParameters:
     visibility_threshold: float | None = None
     detection_confidence: float | None = None
     tracking_confidence: float | None = None
-    pose_backend: str | None = None
 
 
 @click.command(name="dropjump-analyze")
@@ -66,23 +65,6 @@ class AnalysisParameters:
     is_flag=True,
     help="Show auto-selected parameters and analysis details",
 )
-@click.option(
-    "--pose-backend",
-    type=click.Choice(
-        ["auto", "mediapipe", "rtmpose-cpu", "rtmpose-cuda", "rtmpose-coreml"],
-        case_sensitive=False,
-    ),
-    default="auto",
-    help=(
-        "Pose tracking backend: "
-        "auto (detect best), "
-        "mediapipe (baseline), "
-        "rtmpose-cpu (optimized CPU), "
-        "rtmpose-cuda (NVIDIA GPU), "
-        "rtmpose-coreml (Apple Silicon)"
-    ),
-    show_default=True,
-)
 # Batch processing options
 @click.option(
     "--batch",
@@ -161,7 +143,6 @@ def dropjump_analyze(  # NOSONAR(S107) - Click CLI requires individual
     json_output: str | None,
     quality: str,
     verbose: bool,
-    pose_backend: str,
     batch: bool,
     workers: int,
     output_dir: str | None,
@@ -231,7 +212,6 @@ def dropjump_analyze(  # NOSONAR(S107) - Click CLI requires individual
             json_output_dir,
             csv_summary,
             expert_params,
-            pose_backend,
         )
     else:
         # Single video mode (original behavior)
@@ -242,7 +222,6 @@ def dropjump_analyze(  # NOSONAR(S107) - Click CLI requires individual
             quality,
             verbose,
             expert_params,
-            pose_backend,
         )
 
 
@@ -253,7 +232,6 @@ def _process_single(
     quality: str,
     verbose: bool,
     expert_params: AnalysisParameters,
-    pose_backend: str,
 ) -> None:
     """Process a single video by calling the API."""
     click.echo(f"Analyzing video: {video_path}", err=True)
@@ -288,7 +266,6 @@ def _process_single(
             overrides=overrides,
             detection_confidence=expert_params.detection_confidence,
             tracking_confidence=expert_params.tracking_confidence,
-            pose_backend=pose_backend,
             verbose=verbose,
         )
 
@@ -332,7 +309,6 @@ def _create_video_configs(
     output_dir: str | None,
     json_output_dir: str | None,
     expert_params: AnalysisParameters,
-    pose_backend: str,
 ) -> list[DropJumpVideoConfig]:
     """Build configuration objects for each video.
 
@@ -380,7 +356,6 @@ def _create_video_configs(
             overrides=overrides,
             detection_confidence=expert_params.detection_confidence,
             tracking_confidence=expert_params.tracking_confidence,
-            pose_backend=expert_params.pose_backend,
         )
         configs.append(config)
 
@@ -545,7 +520,6 @@ def _process_batch(
     json_output_dir: str | None,
     csv_summary: str | None,
     expert_params: AnalysisParameters,
-    pose_backend: str,
 ) -> None:
     """Process multiple videos in batch mode using parallel processing."""
     click.echo(f"\nBatch processing {len(video_files)} videos with {workers} workers", err=True)
@@ -556,7 +530,7 @@ def _process_batch(
 
     # Create video configurations
     configs = _create_video_configs(
-        video_files, quality, output_dir, json_output_dir, expert_params, pose_backend
+        video_files, quality, output_dir, json_output_dir, expert_params
     )
 
     # Progress callback

{kinemotion-0.70.0.dist-info → kinemotion-0.71.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kinemotion
-Version: 0.70.0
+Version: 0.71.0
 Summary: Video-based kinematic analysis for athletic performance
 Project-URL: Homepage, https://github.com/feniix/kinemotion
 Project-URL: Repository, https://github.com/feniix/kinemotion
@@ -23,12 +23,9 @@ Requires-Python: <3.13,>=3.10
 Requires-Dist: click>=8.1.7
 Requires-Dist: mediapipe>=0.10.30
 Requires-Dist: numpy>=1.26.0
-Requires-Dist: onnxruntime-gpu>=1.23.2
 Requires-Dist: opencv-python>=4.9.0
 Requires-Dist: platformdirs>=4.0.0
-Requires-Dist: rtmlib>=0.0.13
 Requires-Dist: scipy>=1.11.0
-Requires-Dist: torch>=2.0.0
 Requires-Dist: tqdm>=4.67.1
 Requires-Dist: typing-extensions>=4.15.0
 Description-Content-Type: text/markdown