kinemotion 0.11.7__py3-none-any.whl → 0.12.0__py3-none-any.whl

kinemotion/api.py

@@ -337,7 +337,6 @@ class VideoConfig:
     """Configuration for processing a single video."""
 
     video_path: str
-    drop_height: float
     quality: str = "balanced"
     output_video: str | None = None
     json_output: str | None = None
@@ -352,7 +351,6 @@ class VideoConfig:
 
 def process_video(
     video_path: str,
-    drop_height: float,
     quality: str = "balanced",
     output_video: str | None = None,
     json_output: str | None = None,
@@ -368,9 +366,10 @@ def process_video(
     """
     Process a single drop jump video and return metrics.
 
+    Jump height is calculated from flight time using kinematic formula (h = g*t²/8).
+
     Args:
         video_path: Path to the input video file
-        drop_height: Height of drop box/platform in meters (e.g., 0.40 for 40cm)
         quality: Analysis quality preset ("fast", "balanced", or "accurate")
         output_video: Optional path for debug video output
         json_output: Optional path for JSON metrics output
@@ -459,15 +458,12 @@ def process_video(
         # Calculate metrics
         if verbose:
             print("Calculating metrics...")
-            print(
-                f"Using drop height calibration: {drop_height}m ({drop_height*100:.0f}cm)"
-            )
 
         metrics = calculate_drop_jump_metrics(
             contact_states,
             vertical_positions,
             video.fps,
-            drop_height_m=drop_height,
+            drop_height_m=None,
             drop_start_frame=drop_start_frame,
             velocity_threshold=params.velocity_threshold,
             smoothing_window=params.smoothing_window,
@@ -513,9 +509,9 @@ def process_videos_bulk(
 
     Example:
         >>> configs = [
-        ...     VideoConfig("video1.mp4", drop_height=0.40),
-        ...     VideoConfig("video2.mp4", drop_height=0.30, quality="accurate"),
-        ...     VideoConfig("video3.mp4", drop_height=0.50, output_video="debug3.mp4"),
+        ...     VideoConfig("video1.mp4"),
+        ...     VideoConfig("video2.mp4", quality="accurate"),
+        ...     VideoConfig("video3.mp4", output_video="debug3.mp4"),
         ... ]
         >>> results = process_videos_bulk(configs, max_workers=4)
         >>> for result in results:
@@ -573,7 +569,6 @@ def _process_video_wrapper(config: VideoConfig) -> VideoResult:
     try:
         metrics = process_video(
             video_path=config.video_path,
-            drop_height=config.drop_height,
             quality=config.quality,
             output_video=config.output_video,
             json_output=config.json_output,

kinemotion/cmj/debug_overlay.py

@@ -242,18 +242,15 @@ class CMJDebugOverlayRenderer(BaseDebugOverlayRenderer):
             y_offset += 30
 
         # Draw angle arcs at joints for visual feedback (only if angle is available)
-        if angles.get("ankle_angle") is not None:
-            self._draw_angle_arc(
-                frame, landmarks, f"{side_used}_ankle", angles["ankle_angle"]
-            )
-        if angles.get("knee_angle") is not None:
-            self._draw_angle_arc(
-                frame, landmarks, f"{side_used}_knee", angles["knee_angle"]
-            )
-        if angles.get("hip_angle") is not None:
-            self._draw_angle_arc(
-                frame, landmarks, f"{side_used}_hip", angles["hip_angle"]
-            )
+        ankle_angle = angles.get("ankle_angle")
+        if ankle_angle is not None:
+            self._draw_angle_arc(frame, landmarks, f"{side_used}_ankle", ankle_angle)
+        knee_angle = angles.get("knee_angle")
+        if knee_angle is not None:
+            self._draw_angle_arc(frame, landmarks, f"{side_used}_knee", knee_angle)
+        hip_angle = angles.get("hip_angle")
+        if hip_angle is not None:
+            self._draw_angle_arc(frame, landmarks, f"{side_used}_hip", hip_angle)
 
     def _draw_angle_arc(
         self,

kinemotion/core/cli_utils.py

@@ -5,7 +5,7 @@ from typing import Any, Protocol
 
 import click
 
-from .auto_tuning import AutoTunedParams, QualityPreset, VideoCharacteristics
+from .auto_tuning import AnalysisParameters, QualityPreset, VideoCharacteristics
 from .pose import PoseTracker
 from .smoothing import smooth_landmarks, smooth_landmarks_advanced
 from .video_io import VideoProcessor
@@ -85,8 +85,8 @@ def track_all_frames(video: VideoProcessor, tracker: PoseTracker) -> tuple[list,
 
 
 def apply_expert_param_overrides(
-    params: AutoTunedParams, expert_params: ExpertParameters
-) -> AutoTunedParams:
+    params: AnalysisParameters, expert_params: ExpertParameters
+) -> AnalysisParameters:
     """Apply expert parameter overrides to auto-tuned parameters.
 
     Args:
@@ -110,7 +110,7 @@ def apply_expert_param_overrides(
 def print_auto_tuned_params(
     video: VideoProcessor,
     quality_preset: QualityPreset,
-    params: AutoTunedParams,
+    params: AnalysisParameters,
     characteristics: VideoCharacteristics | None = None,
     extra_params: dict[str, Any] | None = None,
 ) -> None:
@@ -159,7 +159,9 @@ def print_auto_tuned_params(
     click.echo("=" * 60 + "\n", err=True)
 
 
-def smooth_landmark_sequence(landmarks_sequence: list, params: AutoTunedParams) -> list:
+def smooth_landmark_sequence(
+    landmarks_sequence: list, params: AnalysisParameters
+) -> list:
     """Apply smoothing to landmark sequence.
 
     Args:
@@ -209,98 +211,4 @@ def common_output_options(func: Callable) -> Callable:  # type: ignore[type-arg]
     )(func)
     return func
 
-
-def common_quality_options(func: Callable) -> Callable:  # type: ignore[type-arg]
-    """Add quality and verbose options to CLI command."""
-    func = click.option(
-        "--quality",
-        type=click.Choice(["fast", "balanced", "accurate"], case_sensitive=False),
-        default="balanced",
-        help=(
-            "Analysis quality preset: "
-            "fast (quick, less precise), "
-            "balanced (default, good for most cases), "
-            "accurate (research-grade, slower)"
-        ),
-        show_default=True,
-    )(func)
-    func = click.option(
-        "--verbose",
-        "-v",
-        is_flag=True,
-        help="Show auto-selected parameters and analysis details",
-    )(func)
-    return func
-
-
-def common_batch_options(func: Callable) -> Callable:  # type: ignore[type-arg]
-    """Add batch processing options to CLI command."""
-    func = click.option(
-        "--batch",
-        is_flag=True,
-        help="Enable batch processing mode for multiple videos",
-    )(func)
-    func = click.option(
-        "--workers",
-        type=int,
-        default=4,
-        help="Number of parallel workers for batch processing (default: 4)",
-        show_default=True,
-    )(func)
-    func = click.option(
-        "--output-dir",
-        type=click.Path(),
-        help="Directory for debug video outputs (batch mode only)",
-    )(func)
-    func = click.option(
-        "--json-output-dir",
-        type=click.Path(),
-        help="Directory for JSON metrics outputs (batch mode only)",
-    )(func)
-    func = click.option(
-        "--csv-summary",
-        type=click.Path(),
-        help="Path for CSV summary export (batch mode only)",
-    )(func)
-    return func
-
-
-def common_expert_options(func: Callable) -> Callable:  # type: ignore[type-arg]
-    """Add expert parameter options to CLI command."""
-    func = click.option(
-        "--smoothing-window",
-        type=int,
-        default=None,
-        help="[EXPERT] Override auto-tuned smoothing window size",
-    )(func)
-    func = click.option(
-        "--velocity-threshold",
-        type=float,
-        default=None,
-        help="[EXPERT] Override auto-tuned velocity threshold",
-    )(func)
-    func = click.option(
-        "--min-contact-frames",
-        type=int,
-        default=None,
-        help="[EXPERT] Override auto-tuned minimum contact frames",
-    )(func)
-    func = click.option(
-        "--visibility-threshold",
-        type=float,
-        default=None,
-        help="[EXPERT] Override visibility threshold for landmarks",
-    )(func)
-    func = click.option(
-        "--detection-confidence",
-        type=float,
-        default=None,
-        help="[EXPERT] Override MediaPipe detection confidence (0.0-1.0)",
-    )(func)
-    func = click.option(
-        "--tracking-confidence",
-        type=float,
-        default=None,
-        help="[EXPERT] Override MediaPipe tracking confidence (0.0-1.0)",
-    )(func)
     return func

kinemotion/core/debug_overlay_utils.py

@@ -48,29 +48,6 @@ def create_video_writer(
     return writer, needs_resize
 
 
-def prepare_frame_for_overlay(
-    frame: np.ndarray, needs_resize: bool, display_width: int, display_height: int
-) -> np.ndarray:
-    """
-    Prepare frame for overlay rendering by resizing if needed.
-
-    Args:
-        frame: Original video frame
-        needs_resize: Whether frame needs resizing
-        display_width: Target display width
-        display_height: Target display height
-
-    Returns:
-        Prepared frame ready for overlay
-    """
-    # Apply SAR correction if needed
-    if needs_resize:
-        frame = cv2.resize(
-            frame, (display_width, display_height), interpolation=cv2.INTER_LINEAR
-        )
-    return frame
-
-
 def write_overlay_frame(
     writer: cv2.VideoWriter, frame: np.ndarray, width: int, height: int
 ) -> None:
@@ -162,5 +139,5 @@ class BaseDebugOverlayRenderer:
     def __enter__(self) -> "BaseDebugOverlayRenderer":
         return self
 
-    def __exit__(self, exc_type, exc_val, exc_tb) -> None:  # type: ignore[no-untyped-def]
+    def __exit__(self, _exc_type, _exc_val, _exc_tb) -> None:  # type: ignore[no-untyped-def]
         self.close()

kinemotion/core/video_io.py

@@ -151,10 +151,6 @@ class VideoProcessor:
 
         return frame
 
-    def reset(self) -> None:
-        """Reset video to beginning."""
-        self.cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
-
     def close(self) -> None:
         """Release video capture."""
         self.cap.release()
@@ -162,5 +158,5 @@ class VideoProcessor:
     def __enter__(self) -> "VideoProcessor":
         return self
 
-    def __exit__(self, exc_type, exc_val, exc_tb) -> None:  # type: ignore[no-untyped-def]
+    def __exit__(self, _exc_type, _exc_val, _exc_tb) -> None:  # type: ignore[no-untyped-def]
         self.close()

kinemotion/dropjump/analysis.py

@@ -602,6 +602,75 @@ def find_interpolated_phase_transitions_with_curvature(
     return refined_phases
 
 
+def find_landing_from_acceleration(
+    positions: np.ndarray,
+    accelerations: np.ndarray,
+    takeoff_frame: int,
+    fps: float,
+    search_duration: float = 0.7,
+) -> int:
+    """
+    Find landing frame by detecting impact acceleration after takeoff.
+
+    Similar to CMJ landing detection, looks for maximum positive acceleration
+    (deceleration on ground impact) after the jump peak.
+
+    Args:
+        positions: Array of vertical positions (normalized 0-1)
+        accelerations: Array of accelerations (second derivative)
+        takeoff_frame: Frame at takeoff (end of ground contact)
+        fps: Video frame rate
+        search_duration: Duration in seconds to search for landing (default: 0.7s)
+
+    Returns:
+        Landing frame index (integer)
+    """
+    # Find peak height (minimum y value = highest point)
+    search_start = takeoff_frame
+    search_end = min(len(positions), takeoff_frame + int(fps * search_duration))
+
+    if search_end <= search_start:
+        return min(len(positions) - 1, takeoff_frame + int(fps * 0.3))
+
+    flight_positions = positions[search_start:search_end]
+    peak_idx = int(np.argmin(flight_positions))
+    peak_frame = search_start + peak_idx
+
+    # After peak, look for landing (impact with ground)
+    # Landing is detected by maximum positive acceleration (deceleration on impact)
+    landing_search_start = peak_frame + 2
+    landing_search_end = min(len(accelerations), landing_search_start + int(fps * 0.6))
+
+    if landing_search_end <= landing_search_start:
+        return min(len(positions) - 1, peak_frame + int(fps * 0.2))
+
+    # Find impact: maximum positive acceleration after peak
+    landing_accelerations = accelerations[landing_search_start:landing_search_end]
+    impact_idx = int(np.argmax(landing_accelerations))
+    impact_frame = landing_search_start + impact_idx
+
+    # After acceleration peak, look for position stabilization (full ground contact)
+    # Check where vertical position stops decreasing (athlete stops compressing)
+    stabilization_search_start = impact_frame
+    stabilization_search_end = min(len(positions), impact_frame + int(fps * 0.2))
+
+    landing_frame = impact_frame
+    if stabilization_search_end > stabilization_search_start + 3:
+        # Find where position reaches maximum (lowest point) and starts stabilizing
+        search_positions = positions[
+            stabilization_search_start:stabilization_search_end
+        ]
+
+        # Look for the frame where position reaches its maximum (deepest landing)
+        max_pos_idx = int(np.argmax(search_positions))
+
+        # Landing is just after max position (athlete at deepest landing compression)
+        landing_frame = stabilization_search_start + max_pos_idx
+        landing_frame = min(len(positions) - 1, landing_frame)
+
+    return landing_frame
+
+
 def compute_average_foot_position(
     landmarks: dict[str, tuple[float, float, float]],
 ) -> tuple[float, float]:

kinemotion/dropjump/cli.py

@@ -62,15 +62,6 @@ class AnalysisParameters:
     type=click.Path(),
     help="Path for JSON metrics output (default: stdout)",
 )
-@click.option(
-    "--drop-height",
-    type=float,
-    required=True,
-    help=(
-        "Height of drop box/platform in meters (e.g., 0.40 for 40cm box) - "
-        "REQUIRED for accurate calibration"
-    ),
-)
 @click.option(
     "--quality",
     type=click.Choice(["fast", "balanced", "accurate"], case_sensitive=False),
@@ -164,7 +155,6 @@ def dropjump_analyze(  # NOSONAR(S107) - Click CLI requires individual parameter
     video_path: tuple[str, ...],
     output: str | None,
     json_output: str | None,
-    drop_height: float,
     quality: str,
     verbose: bool,
     batch: bool,
@@ -193,15 +183,15 @@ def dropjump_analyze(  # NOSONAR(S107) - Click CLI requires individual parameter
 
     \b
     # Single video
-    kinemotion dropjump-analyze video.mp4 --drop-height 0.40
+    kinemotion dropjump-analyze video.mp4
 
     \b
     # Batch mode with glob pattern
-    kinemotion dropjump-analyze videos/*.mp4 --batch --drop-height 0.40 --workers 4
+    kinemotion dropjump-analyze videos/*.mp4 --batch --workers 4
 
     \b
     # Batch with output directories
-    kinemotion dropjump-analyze videos/*.mp4 --batch --drop-height 0.40 \\
+    kinemotion dropjump-analyze videos/*.mp4 --batch \\
         --json-output-dir results/ --csv-summary summary.csv
     """
     # Expand glob patterns and collect all video files
@@ -237,7 +227,6 @@ def dropjump_analyze(  # NOSONAR(S107) - Click CLI requires individual parameter
     if use_batch:
         _process_batch(
             video_files,
-            drop_height,
             quality,
             workers,
             output_dir,
@@ -251,7 +240,6 @@ def dropjump_analyze(  # NOSONAR(S107) - Click CLI requires individual parameter
             video_files[0],
             output,
             json_output,
-            drop_height,
             quality,
             verbose,
             expert_params,
@@ -356,7 +344,6 @@ def _process_single(
     video_path: str,
     output: str | None,
     json_output: str | None,
-    drop_height: float,
     quality: str,
     verbose: bool,
     expert_params: AnalysisParameters,
@@ -422,15 +409,11 @@ def _process_single(
 
             # Calculate metrics
             click.echo("Calculating metrics...", err=True)
-            click.echo(
-                f"Using drop height calibration: {drop_height}m ({drop_height*100:.0f}cm)",
-                err=True,
-            )
             metrics = calculate_drop_jump_metrics(
                 contact_states,
                 vertical_positions,
                 video.fps,
-                drop_height_m=drop_height,
+                drop_height_m=None,
                 drop_start_frame=expert_params.drop_start_frame,
                 velocity_threshold=params.velocity_threshold,
                 smoothing_window=params.smoothing_window,
@@ -480,7 +463,6 @@ def _setup_batch_output_dirs(
 
 def _create_video_configs(
     video_files: list[str],
-    drop_height: float,
     quality: str,
     output_dir: str | None,
     json_output_dir: str | None,
@@ -490,7 +472,6 @@ def _create_video_configs(
 
     Args:
         video_files: List of video file paths
-        drop_height: Drop height in meters
         quality: Quality preset
         output_dir: Debug video output directory
         json_output_dir: JSON metrics output directory
@@ -513,7 +494,6 @@ def _create_video_configs(
 
         config = VideoConfig(
             video_path=video_file,
-            drop_height=drop_height,
             quality=quality,
             output_video=debug_video,
             json_output=json_file,
@@ -662,7 +642,6 @@ def _write_csv_summary(
 
 def _process_batch(
     video_files: list[str],
-    drop_height: float,
     quality: str,
     workers: int,
     output_dir: str | None,
@@ -681,7 +660,7 @@ def _process_batch(
 
     # Create video configurations
     configs = _create_video_configs(
-        video_files, drop_height, quality, output_dir, json_output_dir, expert_params
+        video_files, quality, output_dir, json_output_dir, expert_params
     )
 
     # Progress callback

kinemotion/dropjump/kinematics.py

@@ -2,11 +2,13 @@
 
 import numpy as np
 
+from ..core.smoothing import compute_acceleration_from_derivative
 from .analysis import (
     ContactState,
     detect_drop_start,
     find_contact_phases,
     find_interpolated_phase_transitions_with_curvature,
+    find_landing_from_acceleration,
 )
 
 
@@ -123,14 +125,13 @@ def _determine_drop_start_frame(
     """
     if drop_start_frame is None:
         # Auto-detect where drop jump actually starts (skip initial stationary period)
-        detected_frame = detect_drop_start(
+        return detect_drop_start(
             foot_y_positions,
             fps,
             min_stationary_duration=0.5,
             position_change_threshold=0.005,
             smoothing_window=smoothing_window,
         )
-        return detected_frame if detected_frame is not None else 0
     return drop_start_frame
 
 
@@ -313,9 +314,14 @@ def _analyze_flight_phase(
     drop_height_m: float | None,
     scale_factor: float,
     kinematic_correction_factor: float,
+    smoothing_window: int,
+    polyorder: int,
 ) -> None:
     """Analyze flight phase and calculate jump height metrics.
 
+    Uses acceleration-based landing detection (like CMJ) for accurate flight time,
+    then calculates jump height using kinematic formula h = g*t²/8.
+
     Args:
         metrics: DropJumpMetrics object to populate
         phases: All phase tuples
@@ -323,38 +329,41 @@ def _analyze_flight_phase(
         contact_end: End of contact phase
         foot_y_positions: Vertical position array
         fps: Video frame rate
-        drop_height_m: Known drop height (optional)
+        drop_height_m: Known drop height (optional, for RSI calculation)
         scale_factor: Calibration scale factor
         kinematic_correction_factor: Correction for kinematic method
+        smoothing_window: Window size for acceleration computation
+        polyorder: Polynomial order for Savitzky-Golay filter
     """
-    # Find flight phase after ground contact
-    flight_phases = [
-        (start, end)
-        for start, end, state in phases
-        if state == ContactState.IN_AIR and start > contact_end
-    ]
+    # Find takeoff frame (end of ground contact)
+    flight_start = contact_end
 
-    if not flight_phases:
-        return
+    # Compute accelerations for landing detection
+    accelerations = compute_acceleration_from_derivative(
+        foot_y_positions, window_length=smoothing_window, polyorder=polyorder
+    )
 
-    flight_start, flight_end = flight_phases[0]
+    # Use acceleration-based landing detection (like CMJ)
+    # This finds the actual ground impact, not just when velocity drops
+    flight_end = find_landing_from_acceleration(
+        foot_y_positions, accelerations, flight_start, fps, search_duration=0.7
+    )
 
     # Store integer frame indices
     metrics.flight_start_frame = flight_start
     metrics.flight_end_frame = flight_end
 
-    # Find precise timing
+    # Find precise sub-frame timing for takeoff
     flight_start_frac = float(flight_start)
     flight_end_frac = float(flight_end)
 
     for start_frac, end_frac, state in interpolated_phases:
         if (
-            state == ContactState.IN_AIR
+            state == ContactState.ON_GROUND
             and int(start_frac) <= flight_start <= int(end_frac) + 1
-            and int(start_frac) <= flight_end <= int(end_frac) + 1
         ):
-            flight_start_frac = start_frac
-            flight_end_frac = end_frac
+            # Use end of ground contact as precise takeoff
+            flight_start_frac = end_frac
             break
 
     # Calculate flight time
@@ -363,11 +372,16 @@ def _analyze_flight_phase(
     metrics.flight_start_frame_precise = flight_start_frac
     metrics.flight_end_frame_precise = flight_end_frac
 
-    # Calculate jump height using kinematic method
+    # Calculate jump height using kinematic method (like CMJ)
+    # h = g * t² / 8
     g = 9.81  # m/s^2
     jump_height_kinematic = (g * metrics.flight_time**2) / 8
 
-    # Calculate jump height from trajectory
+    # Always use kinematic method for jump height (like CMJ)
+    metrics.jump_height = jump_height_kinematic
+    metrics.jump_height_kinematic = jump_height_kinematic
+
+    # Calculate trajectory-based height for reference
     takeoff_position = foot_y_positions[flight_start]
     flight_positions = foot_y_positions[flight_start : flight_end + 1]
 
@@ -379,21 +393,6 @@ def _analyze_flight_phase(
         height_normalized = float(takeoff_position - peak_position)
         metrics.jump_height_trajectory = height_normalized
 
-        # Choose measurement method based on calibration availability
-        if drop_height_m is not None and scale_factor > 1.0:
-            metrics.jump_height = height_normalized * scale_factor
-            metrics.jump_height_kinematic = jump_height_kinematic
-        else:
-            metrics.jump_height = jump_height_kinematic * kinematic_correction_factor
-            metrics.jump_height_kinematic = jump_height_kinematic
-    else:
-        # Fallback to kinematic if no position data
-        if drop_height_m is None:
-            metrics.jump_height = jump_height_kinematic * kinematic_correction_factor
-        else:
-            metrics.jump_height = jump_height_kinematic
-        metrics.jump_height_kinematic = jump_height_kinematic
-
 
 def calculate_drop_jump_metrics(
     contact_states: list[ContactState],
@@ -506,46 +505,8 @@ def calculate_drop_jump_metrics(
         drop_height_m,
         scale_factor,
         kinematic_correction_factor,
+        smoothing_window,
+        polyorder,
     )
 
     return metrics
-
-
-def estimate_jump_height_from_trajectory(
-    foot_y_positions: np.ndarray,
-    flight_start: int,
-    flight_end: int,
-    pixel_to_meter_ratio: float | None = None,
-) -> float:
-    """
-    Estimate jump height from position trajectory.
-
-    Args:
-        foot_y_positions: Vertical positions of feet (normalized or pixels)
-        flight_start: Frame where flight begins
-        flight_end: Frame where flight ends
-        pixel_to_meter_ratio: Conversion factor from pixels to meters
-
-    Returns:
-        Estimated jump height in meters (or normalized units if no calibration)
-    """
-    if flight_end < flight_start:
-        return 0.0
-
-    # Get position at takeoff (end of contact) and peak (minimum y during flight)
-    takeoff_position = foot_y_positions[flight_start]
-    flight_positions = foot_y_positions[flight_start : flight_end + 1]
-
-    if len(flight_positions) == 0:
-        return 0.0
-
-    peak_position = np.min(flight_positions)
-
-    # Height difference (in normalized coordinates, y increases downward)
-    height_diff = takeoff_position - peak_position
-
-    # Convert to meters if calibration available
-    if pixel_to_meter_ratio is not None:
-        return float(height_diff * pixel_to_meter_ratio)
-
-    return float(height_diff)

{kinemotion-0.11.7.dist-info → kinemotion-0.12.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kinemotion
-Version: 0.11.7
+Version: 0.12.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.11.7.dist-info → kinemotion-0.12.0.dist-info}/RECORD

@@ -1,28 +1,28 @@
 kinemotion/__init__.py,sha256=REBC9wrwYC_grvCS00qEOyign65Zc1sc-5buLpyqQxA,654
-kinemotion/api.py,sha256=M6KqzdspOvtJ9Wl555HGe3ITzvRFhPK4xeqcX7IA98s,31463
+kinemotion/api.py,sha256=-m4KnlpXWswNyHc_keuNtKZKy8EONSUqrSTNtvoq_OA,31193
 kinemotion/cli.py,sha256=cqYV_7URH0JUDy1VQ_EDLv63FmNO4Ns20m6s1XAjiP4,464
 kinemotion/cmj/__init__.py,sha256=Ynv0-Oco4I3Y1Ubj25m3h9h2XFqeNwpAewXmAYOmwfU,127
 kinemotion/cmj/analysis.py,sha256=4HYGn4VDIB6oExAees-VcPfpNgWOltpgwjyNTU7YAb4,18263
 kinemotion/cmj/cli.py,sha256=bmDvNvL7cu65-R8YkRIZYKD0nuTA0IJnWLcLlH_kFm0,16843
-kinemotion/cmj/debug_overlay.py,sha256=5Uwtyx9FP-tKhQyUvFW2t_ULVBV7oMCvzcLzf4hFcUg,15910
+kinemotion/cmj/debug_overlay.py,sha256=D-y2FQKI01KY0WXFKTKg6p9Qj3AkXCE7xjau3Ais080,15886
 kinemotion/cmj/joint_angles.py,sha256=8ucpDGPvbt4iX3tx9eVxJEUv0laTm2Y58_--VzJCogE,9113
 kinemotion/cmj/kinematics.py,sha256=Xl_PlC2OqMoA-zOc3SRB_GqI0AgLlJol5FTPe5J_qLc,7573
 kinemotion/core/__init__.py,sha256=3yzDhb5PekDNjydqrs8aWGneUGJBt-lB0SoB_Y2FXqU,1010
 kinemotion/core/auto_tuning.py,sha256=cvmxUI-CbahpOJQtR2r5jOx4Q6yKPe3DO1o15hOQIdw,10508
-kinemotion/core/cli_utils.py,sha256=Pmg8z0nGhkYJm0o-y3jyvzeRy9yvol14ddaHrp6f7cw,10161
-kinemotion/core/debug_overlay_utils.py,sha256=E3krJ0SeIhSl6AM5WYiGuaONKsLNKL93P3aHqMgStY8,5235
+kinemotion/core/cli_utils.py,sha256=uCGOsXRpxhRpu8VW9b3tAsHBySyaVl_YMMVCrEZqB-Y,7271
+kinemotion/core/debug_overlay_utils.py,sha256=TyUb5okv5qw8oeaX3jsUO_kpwf1NnaHEAOTm-8LwTno,4587
 kinemotion/core/filtering.py,sha256=f-m-aA59e4WqE6u-9MA51wssu7rI-Y_7n1cG8IWdeRQ,11241
 kinemotion/core/pose.py,sha256=Wfd1RR-2ZznYpWeQUbySwcV3mvReqn8n3XO6S7pGq4M,8390
 kinemotion/core/smoothing.py,sha256=Zdhqw4NyCrZaEb-Jo3sASzP-QlEL5sVTgHoXU8zT_xU,14136
-kinemotion/core/video_io.py,sha256=z8Z0qbNaKbcdB40KnbNOBMzab3BbgnhBxp-mUBYeXgM,6577
+kinemotion/core/video_io.py,sha256=UtmUndw22uFnZBK_BmeE912yRYH1YnU_P8LjuN33DPc,6461
 kinemotion/dropjump/__init__.py,sha256=yc1XiZ9vfo5h_n7PKVSiX2TTgaIfGL7Y7SkQtiDZj_E,838
-kinemotion/dropjump/analysis.py,sha256=HfJt2t9IsMBiBUz7apIzdxbRH9QqzlFnDVVWcKhU3ow,23291
-kinemotion/dropjump/cli.py,sha256=-iBgHNwW_dijHe6_JIEGSBUzvFb6tZV0aopbPd-9jC8,22402
+kinemotion/dropjump/analysis.py,sha256=crO0SUq8TiMHdK5hPuHHuOFrEGhGdPoeb5rXQUvqCog,26103
+kinemotion/dropjump/cli.py,sha256=emnMlg2Td4iS7go9ckTFnolPEytX9MKoPRhfjBwyArU,21731
 kinemotion/dropjump/debug_overlay.py,sha256=2L4VAZwWFnaOQ7LAF3ALXCjEaVNzkfpLT5-h0qKL_6g,5707
-kinemotion/dropjump/kinematics.py,sha256=RM_O8Kdc6aEiPIu_99N4cu-4EhYSQxtBGASJF_dmQaU,19081
+kinemotion/dropjump/kinematics.py,sha256=bHQFeBHGNDKyusHKN_hHmeNHLEK2xMIHBMvL2tScm88,17935
 kinemotion/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kinemotion-0.11.7.dist-info/METADATA,sha256=7z0ZpUWjjZXDq-fe3006Pgy7CCZTucZ_cCRh9lbLjkU,18990
-kinemotion-0.11.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-kinemotion-0.11.7.dist-info/entry_points.txt,sha256=zaqnAnjLvcdrk1Qvj5nvXZCZ2gp0prS7it1zTJygcIY,50
-kinemotion-0.11.7.dist-info/licenses/LICENSE,sha256=KZajvqsHw0NoOHOi2q0FZ4NBe9HdV6oey-IPYAtHXfg,1088
-kinemotion-0.11.7.dist-info/RECORD,,
+kinemotion-0.12.0.dist-info/METADATA,sha256=bwCv7u1ErLWVmzFcFYK_Lx7_XRAOajSp6YFTYWtXhRg,18990
+kinemotion-0.12.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+kinemotion-0.12.0.dist-info/entry_points.txt,sha256=zaqnAnjLvcdrk1Qvj5nvXZCZ2gp0prS7it1zTJygcIY,50
+kinemotion-0.12.0.dist-info/licenses/LICENSE,sha256=KZajvqsHw0NoOHOi2q0FZ4NBe9HdV6oey-IPYAtHXfg,1088
+kinemotion-0.12.0.dist-info/RECORD,,