kinemotion 0.47.4__py3-none-any.whl → 0.49.0__py3-none-any.whl

kinemotion/api.py

@@ -7,6 +7,9 @@ The actual implementations have been moved to their respective submodules:
 """
 
 # CMJ API
+from .cmj.api import (
+    AnalysisOverrides as CMJAnalysisOverrides,
+)
 from .cmj.api import (
     CMJVideoConfig,
     CMJVideoResult,
@@ -17,6 +20,7 @@ from .cmj.kinematics import CMJMetrics
 
 # Drop jump API
 from .dropjump.api import (
+    AnalysisOverrides,
     DropJumpVideoConfig,
     DropJumpVideoResult,
     process_dropjump_video,
@@ -25,11 +29,13 @@ from .dropjump.api import (
 
 __all__ = [
     # Drop jump
+    "AnalysisOverrides",
     "DropJumpVideoConfig",
     "DropJumpVideoResult",
     "process_dropjump_video",
     "process_dropjump_videos_bulk",
     # CMJ
+    "CMJAnalysisOverrides",
     "CMJMetrics",
     "CMJVideoConfig",
     "CMJVideoResult",

kinemotion/cmj/api.py

@@ -48,6 +48,20 @@ from .kinematics import CMJMetrics, calculate_cmj_metrics
 from .metrics_validator import CMJMetricsValidator
 
 
+@dataclass
+class AnalysisOverrides:
+    """Optional overrides for analysis parameters.
+
+    Allows fine-tuning of specific analysis parameters beyond quality presets.
+    If None, values will be determined by the quality preset.
+    """
+
+    smoothing_window: int | None = None
+    velocity_threshold: float | None = None
+    min_contact_frames: int | None = None
+    visibility_threshold: float | None = None
+
+
 def _generate_debug_video(
     output_video: str,
     frames: list[NDArray[np.uint8]],
@@ -109,9 +123,9 @@ def _print_timing_summary(start_time: float, timer: Timer, metrics: CMJMetrics)
     for stage, duration in stage_times.items():
         percentage = (duration / total_time) * 100
         dur_ms = duration * 1000
-        print(f"{stage:. <40} {dur_ms:>6.0f}ms ({percentage:>5.1f}%)")
+        print(f"{stage:.<40} {dur_ms:>6.0f}ms ({percentage:>5.1f}%)")
     total_ms = total_time * 1000
-    print(f"{('Total'):.>40} {total_ms:>6.0f}ms (100.0%)")
+    print(f"{'Total':.<40} {total_ms:>6.0f}ms (100.0%)")
     print()
 
     print(f"\nJump height: {metrics.jump_height:.3f}m")
@@ -212,10 +226,7 @@ class CMJVideoConfig:
     quality: str = "balanced"
     output_video: str | None = None
     json_output: str | None = None
-    smoothing_window: int | None = None
-    velocity_threshold: float | None = None
-    min_contact_frames: int | None = None
-    visibility_threshold: float | None = None
+    overrides: AnalysisOverrides | None = None
     detection_confidence: float | None = None
     tracking_confidence: float | None = None
 
@@ -236,10 +247,7 @@ def process_cmj_video(
     quality: str = "balanced",
     output_video: str | None = None,
     json_output: str | None = None,
-    smoothing_window: int | None = None,
-    velocity_threshold: float | None = None,
-    min_contact_frames: int | None = None,
-    visibility_threshold: float | None = None,
+    overrides: AnalysisOverrides | None = None,
     detection_confidence: float | None = None,
     tracking_confidence: float | None = None,
     verbose: bool = False,
@@ -258,10 +266,7 @@ def process_cmj_video(
         quality: Analysis quality preset ("fast", "balanced", or "accurate")
         output_video: Optional path for debug video output
         json_output: Optional path for JSON metrics output
-        smoothing_window: Optional override for smoothing window
-        velocity_threshold: Optional override for velocity threshold
-        min_contact_frames: Optional override for minimum contact frames
-        visibility_threshold: Optional override for visibility threshold
+        overrides: Optional AnalysisOverrides with parameter fine-tuning
         detection_confidence: Optional override for pose detection confidence
         tracking_confidence: Optional override for pose tracking confidence
         verbose: Print processing details
@@ -315,10 +320,10 @@ def process_cmj_video(
                 params = auto_tune_parameters(characteristics, quality_preset)
                 params = apply_expert_overrides(
                     params,
-                    smoothing_window,
-                    velocity_threshold,
-                    min_contact_frames,
-                    visibility_threshold,
+                    overrides.smoothing_window if overrides else None,
+                    overrides.velocity_threshold if overrides else None,
+                    overrides.min_contact_frames if overrides else None,
+                    overrides.visibility_threshold if overrides else None,
                 )
 
                 if verbose:
@@ -463,10 +468,7 @@ def _process_cmj_video_wrapper(config: CMJVideoConfig) -> CMJVideoResult:
             quality=config.quality,
             output_video=config.output_video,
             json_output=config.json_output,
-            smoothing_window=config.smoothing_window,
-            velocity_threshold=config.velocity_threshold,
-            min_contact_frames=config.min_contact_frames,
-            visibility_threshold=config.visibility_threshold,
+            overrides=config.overrides,
             detection_confidence=config.detection_confidence,
             tracking_confidence=config.tracking_confidence,
             verbose=False,

kinemotion/cmj/cli.py

@@ -12,7 +12,7 @@ from ..core.cli_utils import (
     common_output_options,
     generate_batch_output_paths,
 )
-from .api import process_cmj_video
+from .api import AnalysisOverrides, process_cmj_video
 from .kinematics import CMJMetrics
 
 
@@ -260,16 +260,21 @@ def _process_single(
 ) -> None:
     """Process a single CMJ video by calling the API."""
     try:
+        # Create overrides from expert parameters
+        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,
+        )
+
         # Call the API function (handles all processing logic)
         metrics = process_cmj_video(
             video_path=video_path,
             quality=quality_preset.value,
             output_video=output,
             json_output=json_output,
-            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=overrides,
             detection_confidence=expert_params.detection_confidence,
             tracking_confidence=expert_params.tracking_confidence,
             verbose=verbose,

kinemotion/dropjump/api.py

@@ -13,6 +13,7 @@ if TYPE_CHECKING:
 from ..core.auto_tuning import (
     AnalysisParameters,
     QualityPreset,
+    VideoCharacteristics,
     analyze_video_sample,
     auto_tune_parameters,
 )
@@ -52,6 +53,20 @@ from .kinematics import DropJumpMetrics, calculate_drop_jump_metrics
 from .metrics_validator import DropJumpMetricsValidator
 
 
+@dataclass
+class AnalysisOverrides:
+    """Optional overrides for analysis parameters.
+
+    Allows fine-tuning of specific analysis parameters beyond quality presets.
+    If None, values will be determined by the quality preset.
+    """
+
+    smoothing_window: int | None = None
+    velocity_threshold: float | None = None
+    min_contact_frames: int | None = None
+    visibility_threshold: float | None = None
+
+
 @dataclass
 class DropJumpVideoResult:
     """Result of processing a single drop jump video."""
@@ -72,10 +87,7 @@ class DropJumpVideoConfig:
     output_video: str | None = None
     json_output: str | None = None
     drop_start_frame: int | None = None
-    smoothing_window: int | None = None
-    velocity_threshold: float | None = None
-    min_contact_frames: int | None = None
-    visibility_threshold: float | None = None
+    overrides: AnalysisOverrides | None = None
     detection_confidence: float | None = None
     tracking_confidence: float | None = None
 
@@ -219,6 +231,195 @@ def _print_dropjump_summary(
     print("Analysis complete!")
 
 
+def _setup_pose_tracker(
+    quality_preset: QualityPreset,
+    detection_confidence: float | None,
+    tracking_confidence: float | None,
+    pose_tracker: "PoseTracker | None",
+    timer: Timer,
+) -> tuple["PoseTracker", bool]:
+    """Set up pose tracker and determine if it should be closed."""
+    detection_conf, tracking_conf = determine_confidence_levels(
+        quality_preset, detection_confidence, tracking_confidence
+    )
+
+    tracker = pose_tracker
+    should_close_tracker = False
+
+    if tracker is None:
+        tracker = PoseTracker(
+            min_detection_confidence=detection_conf,
+            min_tracking_confidence=tracking_conf,
+            timer=timer,
+        )
+        should_close_tracker = True
+
+    return tracker, should_close_tracker
+
+
+def _process_frames_and_landmarks(
+    video: "VideoProcessor",
+    tracker: "PoseTracker",
+    should_close_tracker: bool,
+    verbose: bool,
+    timer: Timer,
+) -> tuple[list, list, list[int]]:
+    """Process all video frames and extract landmarks."""
+    if verbose:
+        print("Processing all frames with MediaPipe pose tracking...")
+
+    frames, landmarks_sequence, frame_indices = process_all_frames(
+        video, tracker, verbose, timer, close_tracker=should_close_tracker
+    )
+
+    return frames, landmarks_sequence, frame_indices
+
+
+def _tune_and_smooth(
+    landmarks_sequence: list,
+    video_fps: float,
+    frame_count: int,
+    quality_preset: QualityPreset,
+    overrides: AnalysisOverrides | None,
+    timer: Timer,
+    verbose: bool,
+) -> tuple[list, AnalysisParameters, VideoCharacteristics]:
+    """Tune parameters and apply smoothing to landmarks.
+
+    Args:
+        landmarks_sequence: Sequence of pose landmarks
+        video_fps: Video frame rate
+        frame_count: Total number of frames
+        quality_preset: Quality preset for analysis
+        overrides: Optional parameter overrides
+        timer: Performance timer
+        verbose: Verbose output flag
+
+    Returns:
+        Tuple of (smoothed_landmarks, params, characteristics)
+    """
+    with timer.measure("parameter_auto_tuning"):
+        characteristics = analyze_video_sample(
+            landmarks_sequence, video_fps, frame_count
+        )
+        params = auto_tune_parameters(characteristics, quality_preset)
+
+        # Apply overrides if provided
+        if overrides:
+            params = apply_expert_overrides(
+                params,
+                overrides.smoothing_window,
+                overrides.velocity_threshold,
+                overrides.min_contact_frames,
+                overrides.visibility_threshold,
+            )
+        else:
+            params = apply_expert_overrides(
+                params,
+                None,
+                None,
+                None,
+                None,
+            )
+
+    smoothed_landmarks = apply_smoothing(landmarks_sequence, params, verbose, timer)
+
+    return smoothed_landmarks, params, characteristics
+
+
+def _extract_positions_and_detect_contact(
+    smoothed_landmarks: list,
+    params: AnalysisParameters,
+    timer: Timer,
+    verbose: bool,
+) -> tuple["NDArray", "NDArray", list]:
+    """Extract vertical positions and detect ground contact."""
+    if verbose:
+        print("Extracting foot positions...")
+    with timer.measure("vertical_position_extraction"):
+        vertical_positions, visibilities = extract_vertical_positions(
+            smoothed_landmarks
+        )
+
+    if verbose:
+        print("Detecting ground contact...")
+    with timer.measure("ground_contact_detection"):
+        contact_states = detect_ground_contact(
+            vertical_positions,
+            velocity_threshold=params.velocity_threshold,
+            min_contact_frames=params.min_contact_frames,
+            visibility_threshold=params.visibility_threshold,
+            visibilities=visibilities,
+            window_length=params.smoothing_window,
+            polyorder=params.polyorder,
+            timer=timer,
+        )
+
+    return vertical_positions, visibilities, contact_states
+
+
+def _calculate_metrics_and_assess_quality(
+    contact_states: list,
+    vertical_positions: "NDArray",
+    visibilities: "NDArray",
+    video_fps: float,
+    drop_start_frame: int | None,
+    params: AnalysisParameters,
+    timer: Timer,
+    verbose: bool,
+) -> tuple[DropJumpMetrics, QualityAssessment]:
+    """Calculate metrics and assess quality."""
+    if verbose:
+        print("Calculating metrics...")
+    with timer.measure("metrics_calculation"):
+        metrics = calculate_drop_jump_metrics(
+            contact_states,
+            vertical_positions,
+            video_fps,
+            drop_start_frame=drop_start_frame,
+            velocity_threshold=params.velocity_threshold,
+            smoothing_window=params.smoothing_window,
+            polyorder=params.polyorder,
+            use_curvature=params.use_curvature,
+            timer=timer,
+        )
+
+    if verbose:
+        print("Assessing tracking quality...")
+    with timer.measure("quality_assessment"):
+        quality_result, _, _, _ = _assess_dropjump_quality(
+            vertical_positions, visibilities, contact_states, video_fps
+        )
+
+    return metrics, quality_result
+
+
+def _print_quality_warnings(quality_result: QualityAssessment, verbose: bool) -> None:
+    """Print quality warnings if present."""
+    if verbose and quality_result.warnings:
+        print("\n⚠️  Quality Warnings:")
+        for warning in quality_result.warnings:
+            print(f"  - {warning}")
+        print()
+
+
+def _validate_metrics_and_print_results(
+    metrics: DropJumpMetrics,
+    timer: Timer,
+    verbose: bool,
+) -> None:
+    """Validate metrics and print validation results if verbose."""
+    with timer.measure("metrics_validation"):
+        validator = DropJumpMetricsValidator()
+        validation_result = validator.validate(metrics.to_dict())  # type: ignore[arg-type]
+        metrics.validation_result = validation_result
+
+    if verbose and validation_result.issues:
+        print("\n⚠️  Validation Results:")
+        for issue in validation_result.issues:
+            print(f"  [{issue.severity.value}] {issue.metric}: {issue.message}")
+
+
 def _generate_debug_video(
     output_video: str,
     frames: list,
@@ -285,10 +486,7 @@ def process_dropjump_video(
     output_video: str | None = None,
     json_output: str | None = None,
     drop_start_frame: int | None = None,
-    smoothing_window: int | None = None,
-    velocity_threshold: float | None = None,
-    min_contact_frames: int | None = None,
-    visibility_threshold: float | None = None,
+    overrides: AnalysisOverrides | None = None,
     detection_confidence: float | None = None,
     tracking_confidence: float | None = None,
     verbose: bool = False,
@@ -306,10 +504,7 @@ def process_dropjump_video(
         output_video: Optional path for debug video output
         json_output: Optional path for JSON metrics output
         drop_start_frame: Optional manual drop start frame
-        smoothing_window: Optional override for smoothing window
-        velocity_threshold: Optional override for velocity threshold
-        min_contact_frames: Optional override for minimum contact frames
-        visibility_threshold: Optional override for visibility threshold
+        overrides: Optional AnalysisOverrides for fine-tuning parameters
         detection_confidence: Optional override for pose detection confidence
         tracking_confidence: Optional override for pose tracking confidence
         verbose: Print processing details
@@ -331,106 +526,54 @@ def process_dropjump_video(
     set_deterministic_mode(seed=42)
 
     start_time = time.time()
-    if timer is None:
-        timer = PerformanceTimer()
-
+    timer = timer or PerformanceTimer()
     quality_preset = parse_quality_preset(quality)
 
     with timer.measure("video_initialization"):
         with VideoProcessor(video_path, timer=timer) as video:
-            detection_conf, tracking_conf = determine_confidence_levels(
-                quality_preset, detection_confidence, tracking_confidence
+            tracker, should_close_tracker = _setup_pose_tracker(
+                quality_preset,
+                detection_confidence,
+                tracking_confidence,
+                pose_tracker,
+                timer,
             )
 
-            if verbose:
-                print("Processing all frames with MediaPipe pose tracking...")
-
-            tracker = pose_tracker
-            should_close_tracker = False
-
-            if tracker is None:
-                tracker = PoseTracker(
-                    min_detection_confidence=detection_conf,
-                    min_tracking_confidence=tracking_conf,
-                    timer=timer,
-                )
-                should_close_tracker = True
-
-            frames, landmarks_sequence, frame_indices = process_all_frames(
-                video, tracker, verbose, timer, close_tracker=should_close_tracker
+            frames, landmarks_sequence, frame_indices = _process_frames_and_landmarks(
+                video, tracker, should_close_tracker, verbose, timer
             )
 
-            with timer.measure("parameter_auto_tuning"):
-                characteristics = analyze_video_sample(
-                    landmarks_sequence, video.fps, video.frame_count
-                )
-                params = auto_tune_parameters(characteristics, quality_preset)
-
-                params = apply_expert_overrides(
-                    params,
-                    smoothing_window,
-                    velocity_threshold,
-                    min_contact_frames,
-                    visibility_threshold,
-                )
-
-                if verbose:
-                    print_verbose_parameters(
-                        video, characteristics, quality_preset, params
-                    )
-
-            smoothed_landmarks = apply_smoothing(
-                landmarks_sequence, params, verbose, timer
+            smoothed_landmarks, params, characteristics = _tune_and_smooth(
+                landmarks_sequence,
+                video.fps,
+                video.frame_count,
+                quality_preset,
+                overrides,
+                timer,
+                verbose,
             )
 
             if verbose:
-                print("Extracting foot positions...")
-            with timer.measure("vertical_position_extraction"):
-                vertical_positions, visibilities = extract_vertical_positions(
-                    smoothed_landmarks
-                )
+                print_verbose_parameters(video, characteristics, quality_preset, params)
 
-            if verbose:
-                print("Detecting ground contact...")
-            with timer.measure("ground_contact_detection"):
-                contact_states = detect_ground_contact(
-                    vertical_positions,
-                    velocity_threshold=params.velocity_threshold,
-                    min_contact_frames=params.min_contact_frames,
-                    visibility_threshold=params.visibility_threshold,
-                    visibilities=visibilities,
-                    window_length=params.smoothing_window,
-                    polyorder=params.polyorder,
-                    timer=timer,
-                )
-
-            if verbose:
-                print("Calculating metrics...")
-            with timer.measure("metrics_calculation"):
-                metrics = calculate_drop_jump_metrics(
-                    contact_states,
-                    vertical_positions,
-                    video.fps,
-                    drop_start_frame=drop_start_frame,
-                    velocity_threshold=params.velocity_threshold,
-                    smoothing_window=params.smoothing_window,
-                    polyorder=params.polyorder,
-                    use_curvature=params.use_curvature,
-                    timer=timer,
+            vertical_positions, visibilities, contact_states = (
+                _extract_positions_and_detect_contact(
+                    smoothed_landmarks, params, timer, verbose
                 )
+            )
 
-            if verbose:
-                print("Assessing tracking quality...")
-            with timer.measure("quality_assessment"):
-                quality_result, _, _, _ = _assess_dropjump_quality(
-                    vertical_positions, visibilities, contact_states, video.fps
-                )
+            metrics, quality_result = _calculate_metrics_and_assess_quality(
+                contact_states,
+                vertical_positions,
+                visibilities,
+                video.fps,
+                drop_start_frame,
+                params,
+                timer,
+                verbose,
+            )
 
-            if verbose and quality_result.warnings:
-                print("\n⚠️  Quality Warnings:")
-                for warning in quality_result.warnings:
-                    print(f"  - {warning}")
-                print()
+            _print_quality_warnings(quality_result, verbose)
 
             if output_video:
                 _generate_debug_video(
@@ -445,15 +588,7 @@ def process_dropjump_video(
                     verbose,
                 )
 
-            with timer.measure("metrics_validation"):
-                validator = DropJumpMetricsValidator()
-                validation_result = validator.validate(metrics.to_dict())  # type: ignore[arg-type]
-                metrics.validation_result = validation_result
-
-            if verbose and validation_result.issues:
-                print("\n⚠️  Validation Results:")
-                for issue in validation_result.issues:
-                    print(f"  [{issue.severity.value}] {issue.metric}: {issue.message}")
+            _validate_metrics_and_print_results(metrics, timer, verbose)
 
             processing_time = time.time() - start_time
             result_metadata = _build_dropjump_metadata(
@@ -512,10 +647,7 @@ def _process_dropjump_video_wrapper(config: DropJumpVideoConfig) -> DropJumpVide
             output_video=config.output_video,
             json_output=config.json_output,
             drop_start_frame=config.drop_start_frame,
-            smoothing_window=config.smoothing_window,
-            velocity_threshold=config.velocity_threshold,
-            min_contact_frames=config.min_contact_frames,
-            visibility_threshold=config.visibility_threshold,
+            overrides=config.overrides,
             detection_confidence=config.detection_confidence,
             tracking_confidence=config.tracking_confidence,
             verbose=False,

kinemotion/dropjump/cli.py

@@ -237,6 +237,25 @@ def _process_single(
     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,
+            )
+
         # Call the API function (handles all processing logic)
         metrics = process_dropjump_video(
             video_path=video_path,
@@ -244,10 +263,7 @@ def _process_single(
             output_video=output,
             json_output=json_output,
             drop_start_frame=expert_params.drop_start_frame,
-            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=overrides,
             detection_confidence=expert_params.detection_confidence,
             tracking_confidence=expert_params.tracking_confidence,
             verbose=verbose,
@@ -312,16 +328,32 @@ 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,
+            )
+
         config = DropJumpVideoConfig(
             video_path=video_file,
             quality=quality,
             output_video=debug_video,
             json_output=json_file,
             drop_start_frame=expert_params.drop_start_frame,
-            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=overrides,
             detection_confidence=expert_params.detection_confidence,
             tracking_confidence=expert_params.tracking_confidence,
         )

{kinemotion-0.47.4.dist-info → kinemotion-0.49.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kinemotion
-Version: 0.47.4
+Version: 0.49.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

{kinemotion-0.47.4.dist-info → kinemotion-0.49.0.dist-info}/RECORD

@@ -1,10 +1,10 @@
 kinemotion/__init__.py,sha256=wPItmyGJUOFM6GPRVhAEvRz0-ErI7e2qiUREYJ9EfPQ,943
-kinemotion/api.py,sha256=uj3py8jXuG3mYnmsZQnzuCQtWrO4O6gvZzGAMfZne4o,891
+kinemotion/api.py,sha256=q33-C6xlZKzXthjii1FKnschFU_WT60EHabRgczy3ic,1039
 kinemotion/cli.py,sha256=cqYV_7URH0JUDy1VQ_EDLv63FmNO4Ns20m6s1XAjiP4,464
 kinemotion/cmj/__init__.py,sha256=SkAw9ka8Yd1Qfv9hcvk22m3EfucROzYrSNGNF5kDzho,113
 kinemotion/cmj/analysis.py,sha256=3l0vYQB9tN4HtEO2MPFHVtrdzSmXgwpCm03qzYLCF0c,22196
-kinemotion/cmj/api.py,sha256=MLyc4pkzK8wdSI5-pZ5ekfcI9MDwySknAqOUWxWCT9s,16895
-kinemotion/cmj/cli.py,sha256=S4-3YmaCjtGutDwjG475h8nIiw5utiLg5L6hCGfLOHY,9926
+kinemotion/cmj/api.py,sha256=TYWja-Ellfyq_R2ixfvQyCWnPON7CG7IZk8odlLVM8E,16784
+kinemotion/cmj/cli.py,sha256=r3k5LDRXob12PV_6f6XnXOzKXoGn5WfeCMXkxiJ_CYE,10078
 kinemotion/cmj/debug_overlay.py,sha256=fXmWoHhqMLGo4vTtB6Ezs3yLUDOLw63zLIgU2gFlJQU,15892
 kinemotion/cmj/joint_angles.py,sha256=HmheIEiKcQz39cRezk4h-htorOhGNPsqKIR9RsAEKts,9960
 kinemotion/cmj/kinematics.py,sha256=Q-L8M7wG-MJ6EJTq6GO17c8sD5cb0Jg6Hc5vUZr14bA,13673
@@ -28,15 +28,15 @@ kinemotion/core/validation.py,sha256=LmKfSl4Ayw3DgwKD9IrhsPdzp5ia4drLsHA2UuU1SCM
 kinemotion/core/video_io.py,sha256=vCwpWnlW2y29l48dFXokdehQn42w_IQvayxbVTjpXqQ,7863
 kinemotion/dropjump/__init__.py,sha256=tC3H3BrCg8Oj-db-Vrtx4PH_llR1Ppkd5jwaOjhQcLg,862
 kinemotion/dropjump/analysis.py,sha256=p7nnCe7V6vnhQKZVYk--_nhsTvVa_WY-A3zXmyplsew,28211
-kinemotion/dropjump/api.py,sha256=9tetwjoFdY7Z8PqXpNfaS96L9YVqEkJl7jejGnewhbE,17517
-kinemotion/dropjump/cli.py,sha256=pPQkjpuPUUefGcsRuMvRTtjsxpPSqSgQ9K49rsN_X_o,15823
+kinemotion/dropjump/api.py,sha256=O8DSTLankRibFH8pf1A9idK0x9-khKpG1h2X5nlg5Ms,20688
+kinemotion/dropjump/cli.py,sha256=Ho80fSOgH8zo2e8dGQA90VXL-mZPVvnpc1ZKtl51vB0,16917
 kinemotion/dropjump/debug_overlay.py,sha256=8XVuDyZ3nuNoCYkxcUWC7wyEoHyBxx77Sb--B1KiYWw,5974
 kinemotion/dropjump/kinematics.py,sha256=PATlGaClutGKJslL-LRIXHmTsvb-xEB8PUIMScU_K4c,19849
 kinemotion/dropjump/metrics_validator.py,sha256=CrTlGup8q2kyPXtA6HNwm7_yq0AsBaDllG7RVZdXmYA,9342
 kinemotion/dropjump/validation_bounds.py,sha256=fyl04ZV7nfvHkL5eob6oEpV9Hxce6aiOWQ9pclLp7AQ,5077
 kinemotion/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kinemotion-0.47.4.dist-info/METADATA,sha256=-N2sOXvyGeykCej_Uq07hmu51025vrRF8EUFEiO5kVI,26020
-kinemotion-0.47.4.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-kinemotion-0.47.4.dist-info/entry_points.txt,sha256=zaqnAnjLvcdrk1Qvj5nvXZCZ2gp0prS7it1zTJygcIY,50
-kinemotion-0.47.4.dist-info/licenses/LICENSE,sha256=KZajvqsHw0NoOHOi2q0FZ4NBe9HdV6oey-IPYAtHXfg,1088
-kinemotion-0.47.4.dist-info/RECORD,,
+kinemotion-0.49.0.dist-info/METADATA,sha256=5lngG5Rjd7iFSYSnSdUDHlafk41F4XFScXq_QgWOS60,26020
+kinemotion-0.49.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+kinemotion-0.49.0.dist-info/entry_points.txt,sha256=zaqnAnjLvcdrk1Qvj5nvXZCZ2gp0prS7it1zTJygcIY,50
+kinemotion-0.49.0.dist-info/licenses/LICENSE,sha256=KZajvqsHw0NoOHOi2q0FZ4NBe9HdV6oey-IPYAtHXfg,1088
+kinemotion-0.49.0.dist-info/RECORD,,