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

kinemotion/dropjump/cli.py

@@ -5,6 +5,7 @@ import json
 import sys
 from dataclasses import dataclass
 from pathlib import Path
+from typing import TYPE_CHECKING
 
 import click
 
@@ -19,6 +20,9 @@ from .api import (
     process_dropjump_videos_bulk,
 )
 
+if TYPE_CHECKING:
+    from .api import AnalysisOverrides
+
 
 @dataclass
 class AnalysisParameters:
@@ -31,7 +35,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 +69,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 +147,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 +216,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,10 +226,37 @@ def dropjump_analyze(  # NOSONAR(S107) - Click CLI requires individual
             quality,
             verbose,
             expert_params,
-            pose_backend,
         )
 
 
+def _create_overrides_if_needed(params: AnalysisParameters) -> "AnalysisOverrides | None":
+    """Create AnalysisOverrides if any override parameters are set.
+
+    Args:
+        params: Expert parameters from CLI
+
+    Returns:
+        AnalysisOverrides if any relevant parameters are non-None, else None
+    """
+    from .api import AnalysisOverrides
+
+    if any(
+        [
+            params.smoothing_window is not None,
+            params.velocity_threshold is not None,
+            params.min_contact_frames is not None,
+            params.visibility_threshold is not None,
+        ]
+    ):
+        return AnalysisOverrides(
+            smoothing_window=params.smoothing_window,
+            velocity_threshold=params.velocity_threshold,
+            min_contact_frames=params.min_contact_frames,
+            visibility_threshold=params.visibility_threshold,
+        )
+    return None
+
+
 def _process_single(
     video_path: str,
     output: str | None,
@@ -253,30 +264,12 @@ 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)
 
     try:
-        # Create AnalysisOverrides if any expert parameters are set
-        from .api import AnalysisOverrides
-
-        overrides = None
-        if any(
-            [
-                expert_params.smoothing_window is not None,
-                expert_params.velocity_threshold is not None,
-                expert_params.min_contact_frames is not None,
-                expert_params.visibility_threshold is not None,
-            ]
-        ):
-            overrides = AnalysisOverrides(
-                smoothing_window=expert_params.smoothing_window,
-                velocity_threshold=expert_params.velocity_threshold,
-                min_contact_frames=expert_params.min_contact_frames,
-                visibility_threshold=expert_params.visibility_threshold,
-            )
+        overrides = _create_overrides_if_needed(expert_params)
 
         # Call the API function (handles all processing logic)
         metrics = process_dropjump_video(
@@ -288,7 +281,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 +324,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.
 
@@ -352,24 +343,7 @@ def _create_video_configs(
             video_file, output_dir, json_output_dir
         )
 
-        # Create AnalysisOverrides if any expert parameters are set
-        from .api import AnalysisOverrides
-
-        overrides = None
-        if any(
-            [
-                expert_params.smoothing_window is not None,
-                expert_params.velocity_threshold is not None,
-                expert_params.min_contact_frames is not None,
-                expert_params.visibility_threshold is not None,
-            ]
-        ):
-            overrides = AnalysisOverrides(
-                smoothing_window=expert_params.smoothing_window,
-                velocity_threshold=expert_params.velocity_threshold,
-                min_contact_frames=expert_params.min_contact_frames,
-                visibility_threshold=expert_params.visibility_threshold,
-            )
+        overrides = _create_overrides_if_needed(expert_params)
 
         config = DropJumpVideoConfig(
             video_path=video_file,
@@ -380,7 +354,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)
 
@@ -405,35 +378,33 @@ def _compute_batch_statistics(results: list[DropJumpVideoResult]) -> None:
     click.echo(f"Failed: {len(failed)}", err=True)
 
     if successful:
-        # Calculate average metrics
-        with_gct = [
-            r for r in successful if r.metrics and r.metrics.ground_contact_time is not None
+        # Calculate average metrics from results with non-None values
+        gct_values = [
+            r.metrics.ground_contact_time * 1000
+            for r in successful
+            if r.metrics and r.metrics.ground_contact_time is not None
         ]
-        with_flight = [r for r in successful if r.metrics and r.metrics.flight_time is not None]
-        with_jump = [r for r in successful if r.metrics and r.metrics.jump_height is not None]
-
-        if with_gct:
-            avg_gct = sum(
-                r.metrics.ground_contact_time * 1000
-                for r in with_gct
-                if r.metrics and r.metrics.ground_contact_time is not None
-            ) / len(with_gct)
+        flight_values = [
+            r.metrics.flight_time * 1000
+            for r in successful
+            if r.metrics and r.metrics.flight_time is not None
+        ]
+        jump_values = [
+            r.metrics.jump_height
+            for r in successful
+            if r.metrics and r.metrics.jump_height is not None
+        ]
+
+        if gct_values:
+            avg_gct = sum(gct_values) / len(gct_values)
             click.echo(f"\nAverage ground contact time: {avg_gct:.1f} ms", err=True)
 
-        if with_flight:
-            avg_flight = sum(
-                r.metrics.flight_time * 1000
-                for r in with_flight
-                if r.metrics and r.metrics.flight_time is not None
-            ) / len(with_flight)
+        if flight_values:
+            avg_flight = sum(flight_values) / len(flight_values)
             click.echo(f"Average flight time: {avg_flight:.1f} ms", err=True)
 
-        if with_jump:
-            avg_jump = sum(
-                r.metrics.jump_height
-                for r in with_jump
-                if r.metrics and r.metrics.jump_height is not None
-            ) / len(with_jump)
+        if jump_values:
+            avg_jump = sum(jump_values) / len(jump_values)
             click.echo(
                 f"Average jump height: {avg_jump:.3f} m ({avg_jump * 100:.1f} cm)",
                 err=True,
@@ -478,38 +449,27 @@ def _create_csv_row_from_result(result: DropJumpVideoResult) -> list[str]:
     processing_time = f"{result.processing_time:.2f}"
 
     if result.success and result.metrics:
-        return [
-            video_name,
+        metrics_data = [
             _format_time_metric(result.metrics.ground_contact_time),
             _format_time_metric(result.metrics.flight_time),
             _format_distance_metric(result.metrics.jump_height),
-            processing_time,
-            "Success",
-        ]
-    else:
-        return [
-            video_name,
-            "N/A",
-            "N/A",
-            "N/A",
-            processing_time,
-            f"Failed: {result.error}",
         ]
+        return [video_name, *metrics_data, processing_time, "Success"]
+
+    return [video_name, "N/A", "N/A", "N/A", processing_time, f"Failed: {result.error}"]
 
 
 def _write_csv_summary(
     csv_summary: str | None,
     results: list[DropJumpVideoResult],
-    successful: list[DropJumpVideoResult],
 ) -> None:
     """Write CSV summary of batch processing results.
 
     Args:
         csv_summary: Path to CSV output file
         results: All processing results
-        successful: Successful processing results
     """
-    if not csv_summary or not successful:
+    if not csv_summary:
         return
 
     click.echo(f"\nExporting CSV summary to: {csv_summary}", err=True)
@@ -545,7 +505,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 +515,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
@@ -584,7 +543,6 @@ def _process_batch(
     _compute_batch_statistics(results)
 
     # Export CSV summary if requested
-    successful = [r for r in results if r.success]
-    _write_csv_summary(csv_summary, results, successful)
+    _write_csv_summary(csv_summary, results)
 
     click.echo("\nBatch processing complete!", err=True)

kinemotion/dropjump/debug_overlay.py

@@ -4,61 +4,80 @@ import cv2
 import numpy as np
 
 from ..core.debug_overlay_utils import BaseDebugOverlayRenderer
+from ..core.overlay_constants import (
+    BLACK,
+    COM_CIRCLE_RADIUS,
+    COM_OUTLINE_RADIUS,
+    CYAN,
+    FOOT_CIRCLE_RADIUS,
+    FOOT_LANDMARK_RADIUS,
+    FOOT_VISIBILITY_THRESHOLD,
+    GREEN,
+    HIP_MARKER_RADIUS,
+    METRICS_BOX_WIDTH,
+    ORANGE,
+    PHASE_LABEL_LINE_HEIGHT,
+    PHASE_LABEL_START_Y,
+    RED,
+    WHITE,
+    Color,
+    LandmarkDict,
+)
 from ..core.pose import compute_center_of_mass
 from .analysis import ContactState, compute_average_foot_position
 from .kinematics import DropJumpMetrics
 
 
-class DebugOverlayRenderer(BaseDebugOverlayRenderer):
+class DropJumpDebugOverlayRenderer(BaseDebugOverlayRenderer):
     """Renders debug information on video frames."""
 
+    def _get_contact_state_color(self, contact_state: ContactState) -> Color:
+        """Get color based on ground contact state."""
+        return GREEN if contact_state == ContactState.ON_GROUND else RED
+
     def _draw_com_visualization(
         self,
         frame: np.ndarray,
-        landmarks: dict[str, tuple[float, float, float]],
+        landmarks: LandmarkDict,
         contact_state: ContactState,
     ) -> None:
         """Draw center of mass visualization on frame."""
         com_x, com_y, _ = compute_center_of_mass(landmarks)
-        px = int(com_x * self.width)
-        py = int(com_y * self.height)
+        px, py = self._normalize_to_pixels(com_x, com_y)
 
-        color = (0, 255, 0) if contact_state == ContactState.ON_GROUND else (0, 0, 255)
-        cv2.circle(frame, (px, py), 15, color, -1)
-        cv2.circle(frame, (px, py), 17, (255, 255, 255), 2)
+        color = self._get_contact_state_color(contact_state)
+        cv2.circle(frame, (px, py), COM_CIRCLE_RADIUS, color, -1)
+        cv2.circle(frame, (px, py), COM_OUTLINE_RADIUS, WHITE, 2)
 
         # Draw hip midpoint reference
         if "left_hip" in landmarks and "right_hip" in landmarks:
             lh_x, lh_y, _ = landmarks["left_hip"]
             rh_x, rh_y, _ = landmarks["right_hip"]
-            hip_x = int((lh_x + rh_x) / 2 * self.width)
-            hip_y = int((lh_y + rh_y) / 2 * self.height)
-            cv2.circle(frame, (hip_x, hip_y), 8, (255, 165, 0), -1)
-            cv2.line(frame, (hip_x, hip_y), (px, py), (255, 165, 0), 2)
+            hip_x, hip_y = self._normalize_to_pixels((lh_x + rh_x) / 2, (lh_y + rh_y) / 2)
+            cv2.circle(frame, (hip_x, hip_y), HIP_MARKER_RADIUS, ORANGE, -1)
+            cv2.line(frame, (hip_x, hip_y), (px, py), ORANGE, 2)
 
     def _draw_foot_visualization(
         self,
         frame: np.ndarray,
-        landmarks: dict[str, tuple[float, float, float]],
+        landmarks: LandmarkDict,
         contact_state: ContactState,
     ) -> None:
         """Draw foot position visualization on frame."""
         foot_x, foot_y = compute_average_foot_position(landmarks)
-        px = int(foot_x * self.width)
-        py = int(foot_y * self.height)
+        px, py = self._normalize_to_pixels(foot_x, foot_y)
 
-        color = (0, 255, 0) if contact_state == ContactState.ON_GROUND else (0, 0, 255)
-        cv2.circle(frame, (px, py), 10, color, -1)
+        color = self._get_contact_state_color(contact_state)
+        cv2.circle(frame, (px, py), FOOT_CIRCLE_RADIUS, color, -1)
 
         # Draw individual foot landmarks
         foot_keys = ["left_ankle", "right_ankle", "left_heel", "right_heel"]
         for key in foot_keys:
             if key in landmarks:
                 x, y, vis = landmarks[key]
-                if vis > 0.5:
-                    lx = int(x * self.width)
-                    ly = int(y * self.height)
-                    cv2.circle(frame, (lx, ly), 5, (255, 255, 0), -1)
+                if vis > FOOT_VISIBILITY_THRESHOLD:
+                    lx, ly = self._normalize_to_pixels(x, y)
+                    cv2.circle(frame, (lx, ly), FOOT_LANDMARK_RADIUS, CYAN, -1)
 
     def _draw_phase_labels(
         self,
@@ -67,58 +86,99 @@ class DebugOverlayRenderer(BaseDebugOverlayRenderer):
         metrics: DropJumpMetrics,
     ) -> None:
         """Draw phase labels (ground contact, flight, peak) on frame."""
-        y_offset = 110
-
-        # Ground contact phase
-        if (
-            metrics.contact_start_frame
-            and metrics.contact_end_frame
-            and metrics.contact_start_frame <= frame_idx <= metrics.contact_end_frame
-        ):
+        # Phase configurations: (start_frame, end_frame, label, color)
+        # For range-based phases (ground contact, flight)
+        range_phase_configs = [
+            (metrics.contact_start_frame, metrics.contact_end_frame, "GROUND CONTACT", GREEN),
+            (metrics.flight_start_frame, metrics.flight_end_frame, "FLIGHT PHASE", RED),
+        ]
+
+        y_offset = PHASE_LABEL_START_Y
+        for start_frame, end_frame, label, color in range_phase_configs:
+            if start_frame and end_frame and start_frame <= frame_idx <= end_frame:
+                cv2.putText(
+                    frame,
+                    label,
+                    (10, y_offset),
+                    cv2.FONT_HERSHEY_SIMPLEX,
+                    0.7,
+                    color,
+                    2,
+                )
+                y_offset += PHASE_LABEL_LINE_HEIGHT
+
+        # Single-frame indicator (peak height)
+        if metrics.peak_height_frame == frame_idx:
             cv2.putText(
                 frame,
-                "GROUND CONTACT",
+                "PEAK HEIGHT",
                 (10, y_offset),
                 cv2.FONT_HERSHEY_SIMPLEX,
                 0.7,
-                (0, 255, 0),
+                (255, 0, 255),  # Magenta
                 2,
             )
-            y_offset += 40
 
-        # Flight phase
+    def _draw_info_box(
+        self,
+        frame: np.ndarray,
+        top_left: tuple[int, int],
+        bottom_right: tuple[int, int],
+        border_color: Color,
+    ) -> None:
+        """Draw a filled box with border for displaying information."""
+        cv2.rectangle(frame, top_left, bottom_right, BLACK, -1)
+        cv2.rectangle(frame, top_left, bottom_right, border_color, 2)
+
+    def _draw_metrics_summary(
+        self, frame: np.ndarray, frame_idx: int, metrics: DropJumpMetrics
+    ) -> None:
+        """Draw metrics summary in bottom right after flight phase ends."""
+        if metrics.flight_end_frame is None or frame_idx < metrics.flight_end_frame:
+            return
+
+        # Build metrics text list
+        metrics_text: list[str] = []
+
+        if metrics.ground_contact_time is not None:
+            metrics_text.append(f"Contact Time: {metrics.ground_contact_time * 1000:.0f}ms")
+
+        if metrics.flight_time is not None:
+            metrics_text.append(f"Flight Time: {metrics.flight_time * 1000:.0f}ms")
+
+        if metrics.jump_height is not None:
+            metrics_text.append(f"Jump Height: {metrics.jump_height:.3f}m")
+
+        # Calculate RSI (Reactive Strength Index)
         if (
-            metrics.flight_start_frame
-            and metrics.flight_end_frame
-            and metrics.flight_start_frame <= frame_idx <= metrics.flight_end_frame
+            metrics.jump_height is not None
+            and metrics.ground_contact_time is not None
+            and metrics.ground_contact_time > 0
         ):
-            cv2.putText(
-                frame,
-                "FLIGHT PHASE",
-                (10, y_offset),
-                cv2.FONT_HERSHEY_SIMPLEX,
-                0.7,
-                (0, 0, 255),
-                2,
-            )
-            y_offset += 40
+            rsi = metrics.jump_height / metrics.ground_contact_time
+            metrics_text.append(f"RSI: {rsi:.2f}")
 
-        # Peak height
-        if metrics.peak_height_frame == frame_idx:
-            cv2.putText(
-                frame,
-                "PEAK HEIGHT",
-                (10, y_offset),
-                cv2.FONT_HERSHEY_SIMPLEX,
-                0.7,
-                (255, 0, 255),
-                2,
-            )
+        if not metrics_text:
+            return
+
+        # Calculate box dimensions
+        box_height = len(metrics_text) * 30 + 20
+        top_left = (self.width - METRICS_BOX_WIDTH, self.height - box_height - 10)
+        bottom_right = (self.width - 10, self.height - 10)
+
+        self._draw_info_box(frame, top_left, bottom_right, GREEN)
+
+        # Draw metrics text
+        text_x = self.width - METRICS_BOX_WIDTH + 10
+        text_y = self.height - box_height + 10
+        for text in metrics_text:
+            cv2.putText(frame, text, (text_x, text_y), cv2.FONT_HERSHEY_SIMPLEX, 0.6, WHITE, 1)
+            text_y += 30
 
     def render_frame(
         self,
         frame: np.ndarray,
-        landmarks: dict[str, tuple[float, float, float]] | None,
+        landmarks: LandmarkDict | None,
         contact_state: ContactState,
         frame_idx: int,
         metrics: DropJumpMetrics | None = None,
@@ -141,16 +201,17 @@ class DebugOverlayRenderer(BaseDebugOverlayRenderer):
         with self.timer.measure("debug_video_copy"):
             annotated = frame.copy()
 
-        def _draw_overlays() -> None:
-            # Draw landmarks
+        with self.timer.measure("debug_video_draw"):
+            # Draw skeleton and landmarks
             if landmarks:
+                self._draw_skeleton(annotated, landmarks)
                 if use_com:
                     self._draw_com_visualization(annotated, landmarks, contact_state)
                 else:
                     self._draw_foot_visualization(annotated, landmarks, contact_state)
 
             # Draw contact state
-            state_color = (0, 255, 0) if contact_state == ContactState.ON_GROUND else (0, 0, 255)
+            state_color = self._get_contact_state_color(contact_state)
             cv2.putText(
                 annotated,
                 f"State: {contact_state.value}",
@@ -168,15 +229,13 @@ class DebugOverlayRenderer(BaseDebugOverlayRenderer):
                 (10, 70),
                 cv2.FONT_HERSHEY_SIMPLEX,
                 0.7,
-                (255, 255, 255),
+                WHITE,
                 2,
             )
 
-            # Draw phase labels
+            # Draw phase labels and metrics summary
             if metrics:
                 self._draw_phase_labels(annotated, frame_idx, metrics)
-
-        with self.timer.measure("debug_video_draw"):
-            _draw_overlays()
+                self._draw_metrics_summary(annotated, frame_idx, metrics)
 
         return annotated

kinemotion/dropjump/validation_bounds.py

@@ -124,7 +124,7 @@ def _classify_combined_score(combined_score: float) -> AthleteProfile:
     return AthleteProfile.ELITE
 
 
-def estimate_athlete_profile(metrics: MetricsDict, gender: str | None = None) -> AthleteProfile:
+def estimate_athlete_profile(metrics: MetricsDict, _gender: str | None = None) -> AthleteProfile:
     """Estimate athlete profile from drop jump metrics.
 
     Uses jump_height and contact_time to classify athlete level.

{kinemotion-0.70.1.dist-info → kinemotion-0.71.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kinemotion
-Version: 0.70.1
+Version: 0.71.1
 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,13 +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; sys_platform == 'linux' and platform_machine == 'x86_64'
-Requires-Dist: onnxruntime>=1.23.2; sys_platform != 'linux' or platform_machine != 'x86_64'
 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

kinemotion-0.71.1.dist-info/RECORD

@@ -0,0 +1,50 @@
+kinemotion/__init__.py,sha256=HkD8habCcfxGobxZcACOStla-L1nYHMIZp0th00Q3E8,1061
+kinemotion/api.py,sha256=uG1e4bTnj2c-6cbZJEZ_LjMwFdaG32ba2KcK_XjE_NI,1040
+kinemotion/cli.py,sha256=_Us9krSce4GUKtlLIPrFUhKmPWURzeJ1-ydR_YU2VGw,626
+kinemotion/cmj/__init__.py,sha256=SkAw9ka8Yd1Qfv9hcvk22m3EfucROzYrSNGNF5kDzho,113
+kinemotion/cmj/analysis.py,sha256=EQydClIbNkIj-FmCZGaPQe-COVW8fbO3139i9z1vomA,23643
+kinemotion/cmj/api.py,sha256=P_lbqEqAKPO5n1Xn4IQZKNj9nLaO3ljkN2PgqvExGXU,18435
+kinemotion/cmj/cli.py,sha256=P2b77IIw6kqTSIkncxlShzhmjIwqMFBNd-pZxYP-TsI,9918
+kinemotion/cmj/debug_overlay.py,sha256=vF5Apiz8zDRpgrVzf52manLW99m1kHQAPSdUkar5rPs,11474
+kinemotion/cmj/joint_angles.py,sha256=by5M4LDtUfd2_Z9DmcgUl0nsvarsBYjgsE8KWWYcn08,11255
+kinemotion/cmj/kinematics.py,sha256=KwA8uSj3g1SeNf0NXMSHsp3gIw6Gfa-6QWIwdYdRXYw,13362
+kinemotion/cmj/metrics_validator.py,sha256=IQofafpwLCXER3ucZXNfiJKFFKPOVxXnC4BNLHOMnNY,30013
+kinemotion/cmj/validation_bounds.py,sha256=-0iXDhH-RntiGZi_Co22V6qtA5D-hLzkrPkVcfoNd2U,11343
+kinemotion/core/__init__.py,sha256=8hMvfNK7v_eqswuk_J5s5FRGvPtp2-R4kasVMGchFkM,1766
+kinemotion/core/auto_tuning.py,sha256=dF2opupuphbTd6sZIDyXX8hwedLaNlMiH-hT7PGqnfU,10251
+kinemotion/core/cli_utils.py,sha256=sQPbT6XWWau-sm9yuN5c3eS5xNzoQGGXwSz6hQXtRvM,1859
+kinemotion/core/debug_overlay_utils.py,sha256=QaVkHuFZpXUrdiMlm8ylQn6baJOj8jcZeiV4kDqODt0,17441
+kinemotion/core/determinism.py,sha256=Frw-KAOvAxTL_XtxoWpXCjMbQPUKEAusK6JctlkeuRo,2509
+kinemotion/core/experimental.py,sha256=G1EpkmWQ8d-rPaN1n0P7mF6XUzrbW0Br3nVkIzJ1D9M,3694
+kinemotion/core/filtering.py,sha256=7KUeclXqZpNQA8WKNocDwhCxZpwwtizI3wvAEyq9SBo,11603
+kinemotion/core/formatting.py,sha256=G_3eqgOtym9RFOZVEwCxye4A2cyrmgvtQ214vIshowU,2480
+kinemotion/core/metadata.py,sha256=bJAVa4nym__zx1hNowSZduMGKBSGOPxTbBQkjm6N0D0,7207
+kinemotion/core/model_downloader.py,sha256=mqhJBHGaNe0aN9qbcBqvcTk9FDd7xaHqEcwD-fyP89c,5205
+kinemotion/core/overlay_constants.py,sha256=zZreHHWe00p2XuCJsbRFqN6g-AAUAnx53LwKqHm1Bl8,1438
+kinemotion/core/pipeline_utils.py,sha256=B5jMXoiLaTh02uGA2MIe1uZLVSRGZ5nxbARuvdrjDrQ,15161
+kinemotion/core/pose.py,sha256=Z795p0EnaTUeWHO8FuApFcMGTLwZ47JOjs5f5TzRvdk,14224
+kinemotion/core/pose_landmarks.py,sha256=LcEbL5K5xKia6dCzWf6Ft18UIE1CLMMqCZ3KUjwUDzM,1558
+kinemotion/core/quality.py,sha256=VUkRL2N6B7lfIZ2pE9han_U68JwarmZz1U0ygHkgkhE,13022
+kinemotion/core/smoothing.py,sha256=F1DCsnvPBi62XJLygOJ5MkNlRa7BCLg_E9ORtCWcoKk,16562
+kinemotion/core/timing.py,sha256=ITX77q4hbtajRuWfgwYhws8nCvOeKFlEdKjCu8lD9_w,7938
+kinemotion/core/types.py,sha256=m141buSkEsqflt5VFaTHtRq_IcimjI3_T_EfaNpIVxY,1652
+kinemotion/core/validation.py,sha256=rrhpI24Iq8WGtNaMg0beTWMbEGccdKF-f-pk-FCKJzI,6749
+kinemotion/core/video_io.py,sha256=84IxC1n3HvYK28MSa5fqumdzlPDhP8k9IPB3OCvWku0,9198
+kinemotion/dropjump/__init__.py,sha256=yBbEbPdY6sqozWtTvfbvuUZnrVWSSjBp61xK34M29F4,878
+kinemotion/dropjump/analysis.py,sha256=Tc41jVctG4zJZOyYqM1SiM95mnF2xz4vcieGJ6vYi2M,29099
+kinemotion/dropjump/api.py,sha256=5qBj05e6Zo-H4-UjBOIt_CYyDqLVcPhwyyLG04eJYMU,20639
+kinemotion/dropjump/cli.py,sha256=FaBX637x7VcLcB8HupaZCkVS7sp8C0YuaKM0h-DBNIA,15906
+kinemotion/dropjump/debug_overlay.py,sha256=X4mvCi5Qi1gnvSZZAsUs-0ZRUx9mVBbEUznOFO21HO8,8470
+kinemotion/dropjump/kinematics.py,sha256=dx4PuXKfKMKcsc_HX6sXj8rHXf9ksiZIOAIkJ4vBlY4,19637
+kinemotion/dropjump/metrics_validator.py,sha256=lSfo4Lm5FHccl8ijUP6SA-kcSh50LS9hF8UIyWxcnW8,9243
+kinemotion/dropjump/validation_bounds.py,sha256=k31qy-kCXTiCTx0RPo2t8yZ-faLxqGO-AeF05QfBFb0,5125
+kinemotion/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kinemotion/models/pose_landmarker_lite.task,sha256=WZKeHR7pUodzXd2DOxnPSsRtKbx6_du_Z1PEWWkNV0o,5777746
+kinemotion/models/rtmpose-s_simcc-body7_pt-body7-halpe26_700e-256x192-7f134165_20230605.onnx,sha256=dfZTq8kbhv8RxWiXS0HUIJNCUpxYTBN45dFIorPflEs,133
+kinemotion/models/yolox_tiny_8xb8-300e_humanart-6f3252f9.onnx,sha256=UsutHVQ6GP3X5pCcp52EN8q7o2J3d-TnxZqlF48kY6I,133
+kinemotion/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kinemotion-0.71.1.dist-info/METADATA,sha256=D2ZS9pNSi3NAaSkYKoQ09PZaJ-B3qWDHPLChu3oxdbY,26125
+kinemotion-0.71.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+kinemotion-0.71.1.dist-info/entry_points.txt,sha256=zaqnAnjLvcdrk1Qvj5nvXZCZ2gp0prS7it1zTJygcIY,50
+kinemotion-0.71.1.dist-info/licenses/LICENSE,sha256=KZajvqsHw0NoOHOi2q0FZ4NBe9HdV6oey-IPYAtHXfg,1088
+kinemotion-0.71.1.dist-info/RECORD,,