kinemotion 0.76.0__py3-none-any.whl → 0.76.1__py3-none-any.whl

kinemotion/countermovement_jump/metrics_validator.py

@@ -124,8 +124,8 @@ class CMJMetricsValidator(MetricsValidator):
         self._check_flight_time(data, result, profile)
         self._check_jump_height(data, result, profile)
         self._check_countermovement_depth(data, result, profile)
-        self._check_concentric_duration(data, result, profile)
-        self._check_eccentric_duration(data, result, profile)
+        self._check_concentric_duration(data, result)
+        self._check_eccentric_duration(data, result)
         self._check_peak_velocities(data, result, profile)
 
         # CROSS-VALIDATION CHECKS
@@ -220,7 +220,7 @@ class CMJMetricsValidator(MetricsValidator):
         )
 
     def _check_concentric_duration(
-        self, metrics: MetricsDict, result: CMJValidationResult, profile: AthleteProfile
+        self, metrics: MetricsDict, result: CMJValidationResult
     ) -> None:
         """Validate concentric duration (contact time)."""
         duration_raw = self._get_metric_value(
@@ -256,9 +256,7 @@ class CMJMetricsValidator(MetricsValidator):
                 value=duration,
             )
 
-    def _check_eccentric_duration(
-        self, metrics: MetricsDict, result: CMJValidationResult, profile: AthleteProfile
-    ) -> None:
+    def _check_eccentric_duration(self, metrics: MetricsDict, result: CMJValidationResult) -> None:
         """Validate eccentric duration."""
         duration_raw = self._get_metric_value(
             metrics, "eccentric_duration_ms", "eccentric_duration"

kinemotion/squat_jump/analysis.py

@@ -21,7 +21,6 @@ class SJPhase(Enum):
 def detect_sj_phases(
     positions: FloatArray,
     fps: float,
-    squat_hold_threshold: float = 0.02,
     velocity_threshold: float = 0.1,
     window_length: int = 5,
     polyorder: int = 2,
@@ -38,7 +37,6 @@ def detect_sj_phases(
     Args:
         positions: 1D array of vertical positions (normalized coordinates)
         fps: Video frames per second
-        squat_hold_threshold: Threshold for detecting squat hold phase (m)
         velocity_threshold: Threshold for detecting flight phase (m/s)
         window_length: Window size for velocity smoothing
         polyorder: Polynomial order for smoothing
@@ -183,6 +181,26 @@ def detect_squat_start(
     return None
 
 
+def _find_takeoff_threshold_crossing(
+    velocities: FloatArray,
+    search_start: int,
+    search_end: int,
+    velocity_threshold: float,
+    min_duration_frames: int,
+) -> int | None:
+    """Find first frame where velocity exceeds threshold for minimum duration."""
+    above_threshold = velocities[search_start:search_end] <= -velocity_threshold
+    if not np.any(above_threshold):
+        return None
+
+    threshold_indices = np.nonzero(above_threshold)[0]
+    for idx in threshold_indices:
+        if idx + min_duration_frames < len(above_threshold):
+            if np.all(above_threshold[idx : idx + min_duration_frames]):
+                return search_start + idx
+    return None
+
+
 def detect_takeoff(
     positions: FloatArray,
     velocities: FloatArray,
@@ -234,19 +252,43 @@ def detect_takeoff(
     # Verify velocity exceeds threshold
     if velocities[takeoff_frame] > -velocity_threshold:
         # Velocity not high enough - actual takeoff may be later
-        # Look for frames where velocity exceeds threshold
-        above_threshold = velocities[search_start:search_end] <= -velocity_threshold
-        if np.any(above_threshold):
-            # Find first frame above threshold with sufficient duration
-            threshold_indices = np.where(above_threshold)[0]
-            for idx in threshold_indices:
-                if idx + min_duration_frames < len(above_threshold):
-                    if np.all(above_threshold[idx : idx + min_duration_frames]):
-                        return search_start + idx
+        # Look for frames where velocity exceeds threshold with duration filter
+        return _find_takeoff_threshold_crossing(
+            velocities, search_start, search_end, velocity_threshold, min_duration_frames
+        )
 
     return takeoff_frame if velocities[takeoff_frame] <= -velocity_threshold else None
 
 
+def _detect_impact_landing(
+    accelerations: FloatArray,
+    search_start: int,
+    search_end: int,
+) -> int | None:
+    """Detect landing by finding the maximum acceleration spike."""
+    landing_accelerations = accelerations[search_start:search_end]
+    if len(landing_accelerations) == 0:
+        return None
+
+    # Find maximum acceleration spike (impact)
+    landing_idx = int(np.argmax(landing_accelerations))
+    return search_start + landing_idx
+
+
+def _refine_landing_by_velocity(
+    velocities: FloatArray,
+    landing_frame: int,
+) -> int:
+    """Refine landing frame by looking for positive (downward) velocity."""
+    if landing_frame < len(velocities) and velocities[landing_frame] < 0:
+        # Velocity still upward - landing might not be detected yet
+        # Look ahead for where velocity becomes positive
+        for i in range(landing_frame, min(landing_frame + 10, len(velocities))):
+            if velocities[i] >= 0:
+                return i
+    return landing_frame
+
+
 def detect_landing(
     positions: FloatArray,
     velocities: FloatArray,
@@ -270,6 +312,8 @@ def detect_landing(
         velocity_threshold: Maximum velocity threshold for landing detection
         min_flight_frames: Minimum frames in flight before landing
         landing_search_window_s: Time window to search for landing after peak (seconds)
+        window_length: Window size for velocity smoothing
+        polyorder: Polynomial order for smoothing
 
     Returns:
         Frame index where landing occurs, or None if not detected
@@ -294,8 +338,7 @@ def detect_landing(
 
     # Find peak height (minimum position value in normalized coords = highest point)
     flight_positions = positions[search_start:search_end]
-    peak_idx = int(np.argmin(flight_positions))
-    peak_frame = search_start + peak_idx
+    peak_frame = search_start + int(np.argmin(flight_positions))
 
     # After peak, look for landing using impact detection
     landing_search_start = peak_frame + min_flight_frames
@@ -312,8 +355,12 @@ def detect_landing(
         landing_window = window_length
         if landing_window % 2 == 0:
             landing_window += 1
+        # Use polyorder for smoothing (must be at least 2 for deriv=2)
+        eff_polyorder = max(2, polyorder)
         accelerations = np.abs(
-            savgol_filter(positions, landing_window, 2, deriv=2, delta=1.0, mode="interp")
+            savgol_filter(
+                positions, landing_window, eff_polyorder, deriv=2, delta=1.0, mode="interp"
+            )
         )
     else:
         # Fallback for short sequences
@@ -321,22 +368,10 @@ def detect_landing(
         accelerations = np.abs(np.diff(velocities_abs, prepend=velocities_abs[0]))
 
     # Find impact: maximum positive acceleration (deceleration spike)
-    landing_accelerations = accelerations[landing_search_start:landing_search_end]
+    landing_frame = _detect_impact_landing(accelerations, landing_search_start, landing_search_end)
 
-    if len(landing_accelerations) == 0:
+    if landing_frame is None:
         return None
 
-    # Find maximum acceleration spike (impact)
-    landing_idx = int(np.argmax(landing_accelerations))
-    landing_frame = landing_search_start + landing_idx
-
     # Additional verification: velocity should be positive (downward) at landing
-    if landing_frame < len(velocities) and velocities[landing_frame] < 0:
-        # Velocity still upward - landing might not be detected yet
-        # Look ahead for where velocity becomes positive
-        for i in range(landing_frame, min(landing_frame + 10, len(velocities))):
-            if velocities[i] >= 0:
-                landing_frame = i
-                break
-
-    return landing_frame
+    return _refine_landing_by_velocity(velocities, landing_frame)

kinemotion/squat_jump/debug_overlay.py

@@ -1,83 +1,43 @@
 """Debug overlay visualization for Squat Jump analysis."""
 
-from typing import Any
-
 import cv2
 import numpy as np
 
-
-class SquatJumpDebugOverlayRenderer:
+from ..core.debug_overlay_utils import BaseDebugOverlayRenderer
+from ..core.overlay_constants import (
+    CYAN,
+    GREEN,
+    PHASE_LABEL_LINE_HEIGHT,
+    PHASE_LABEL_START_Y,
+    RED,
+    WHITE,
+    Color,
+    LandmarkDict,
+)
+from .analysis import SJPhase
+from .kinematics import SJMetrics
+
+
+class SquatJumpDebugOverlayRenderer(BaseDebugOverlayRenderer):
     """Debug overlay renderer for Squat Jump analysis results."""
 
-    def __init__(
-        self,
-        output_path: str,
-        input_width: int,
-        input_height: int,
-        output_width: int,
-        output_height: int,
-        fps: float,
-        timer: Any = None,
-    ):
-        """Initialize debug overlay renderer.
-
-        Args:
-            output_path: Path to output video file
-            input_width: Width of input frames
-            input_height: Height of input frames
-            output_width: Width of output video
-            output_height: Height of output video
-            fps: Frames per second for output video
-            timer: Optional timer for performance profiling
-        """
-        self.output_path = output_path
-        self.input_width = input_width
-        self.input_height = input_height
-        self.output_width = output_width
-        self.output_height = output_height
-        self.fps = fps
-        self.timer = timer
-
-        self.writer = None
-        self.frame_count = 0
-
-    def __enter__(self):
-        """Enter context manager and initialize video writer."""
-        fourcc = cv2.VideoWriter_fourcc(*"mp4v")  # type: ignore[attr-defined]
-        self.writer = cv2.VideoWriter(
-            self.output_path,
-            fourcc,
-            self.fps,
-            (self.output_width, self.output_height),
-        )
-        return self
-
-    def __exit__(
-        self,
-        exc_type: type[BaseException] | None,
-        exc_val: BaseException | None,
-        exc_tb: Any,
-    ) -> None:
-        """Exit context manager and release video writer."""
-        if self.writer:
-            self.writer.release()
-
-    def write_frame(self, frame: np.ndarray) -> None:
-        """Write a frame to the output video.
-
-        Args:
-            frame: Annotated frame to write
-        """
-        if self.writer:
-            self.writer.write(frame)
-        self.frame_count += 1
+    def _get_phase_color(self, phase: SJPhase) -> Color:
+        """Get color based on jump phase."""
+        phase_colors = {
+            SJPhase.SQUAT_HOLD: (255, 255, 0),  # Yellow
+            SJPhase.CONCENTRIC: (0, 165, 255),  # Orange
+            SJPhase.FLIGHT: RED,
+            SJPhase.LANDING: GREEN,
+            SJPhase.UNKNOWN: WHITE,
+        }
+        return phase_colors.get(phase, WHITE)
 
     def render_frame(
         self,
         frame: np.ndarray,
-        landmarks: list | None,
+        landmarks: LandmarkDict | None,
         frame_index: int,
-        metrics: Any = None,
+        metrics: SJMetrics | None = None,
     ) -> np.ndarray:
         """Render debug overlay on a single frame.
 
@@ -93,36 +53,53 @@ class SquatJumpDebugOverlayRenderer:
         # Create a copy to avoid modifying the original
         annotated_frame = frame.copy()
 
-        # Resize if needed
-        if self.input_width != self.output_width or self.input_height != self.output_height:
-            annotated_frame = cv2.resize(
-                annotated_frame,
-                (self.output_width, self.output_height),
-                interpolation=cv2.INTER_LINEAR,
-            )
-
-        # TODO: Implement by Computer Vision Engineer
-        # This is a placeholder function that needs to be implemented
-
-        # Placeholder: Just draw basic info
-        self._draw_frame_info(annotated_frame, frame_index)
-
-        # Placeholder: Draw landmarks if available
+        # Determine current phase
+        current_phase = SJPhase.UNKNOWN
+        if metrics:
+            if (
+                metrics.squat_hold_start_frame is not None
+                and metrics.concentric_start_frame is not None
+                and metrics.squat_hold_start_frame <= frame_index < metrics.concentric_start_frame
+            ):
+                current_phase = SJPhase.SQUAT_HOLD
+            elif (
+                metrics.concentric_start_frame is not None
+                and metrics.takeoff_frame is not None
+                and metrics.concentric_start_frame <= frame_index < metrics.takeoff_frame
+            ):
+                current_phase = SJPhase.CONCENTRIC
+            elif (
+                metrics.takeoff_frame is not None
+                and metrics.landing_frame is not None
+                and metrics.takeoff_frame <= frame_index < metrics.landing_frame
+            ):
+                current_phase = SJPhase.FLIGHT
+            elif (
+                metrics.landing_frame is not None
+                and metrics.landing_frame <= frame_index < metrics.landing_frame + 15
+            ):
+                current_phase = SJPhase.LANDING
+
+        # Draw skeleton and landmarks
         if landmarks:
-            self._draw_landmarks(annotated_frame, landmarks)
+            self._draw_skeleton(annotated_frame, landmarks)
 
-        # Placeholder: Draw metrics if available
+        # Draw frame information
+        self._draw_frame_info(annotated_frame, frame_index, current_phase)
+
+        # Draw metrics if available
         if metrics:
-            self._draw_metrics(annotated_frame, metrics)
+            self._draw_metrics(annotated_frame, metrics, frame_index)
 
         return annotated_frame
 
-    def _draw_frame_info(self, frame: np.ndarray, frame_index: int) -> None:
+    def _draw_frame_info(self, frame: np.ndarray, frame_index: int, phase: SJPhase) -> None:
         """Draw frame information overlay.
 
         Args:
             frame: Frame to draw on
             frame_index: Current frame index
+            phase: Current jump phase
         """
         # Draw frame counter
         cv2.putText(
@@ -131,85 +108,56 @@ class SquatJumpDebugOverlayRenderer:
             (10, 30),
             cv2.FONT_HERSHEY_SIMPLEX,
             0.7,
-            (0, 255, 0),
+            WHITE,
             2,
             cv2.LINE_AA,
         )
 
-    def _draw_landmarks(self, frame: np.ndarray, landmarks: list) -> None:
-        """Draw pose landmarks on frame.
-
-        Args:
-            frame: Frame to draw on
-            landmarks: Pose landmarks data
-        """
-        # TODO: Implement by Computer Vision Engineer
-        # This should draw key joints and connections based on landmarks
-        pass
+        # Draw phase label
+        phase_color = self._get_phase_color(phase)
+        cv2.putText(
+            frame,
+            f"Phase: {phase.value.replace('_', ' ').upper()}",
+            (10, 70),
+            cv2.FONT_HERSHEY_SIMPLEX,
+            0.8,
+            phase_color,
+            2,
+            cv2.LINE_AA,
+        )
 
-    def _draw_metrics(self, frame: np.ndarray, metrics: Any) -> None:
+    def _draw_metrics(self, frame: np.ndarray, metrics: SJMetrics, frame_index: int) -> None:
         """Draw metrics information on frame.
 
         Args:
             frame: Frame to draw on
             metrics: Metrics object with analysis results
+            frame_index: Current frame index
         """
-        # TODO: Implement by Computer Vision Engineer
-        # This should display current phase, key metrics, and highlights
-        y_offset = 60
-
-        # Placeholder: Display some basic info
-        if hasattr(metrics, "jump_height"):
-            text = f"Jump Height: {metrics.jump_height:.3f} m"
-            cv2.putText(
-                frame,
-                text,
-                (10, y_offset),
-                cv2.FONT_HERSHEY_SIMPLEX,
-                0.6,
-                (255, 255, 255),
-                2,
-                cv2.LINE_AA,
-            )
-            y_offset += 30
-
-        if hasattr(metrics, "flight_time"):
-            text = f"Flight Time: {metrics.flight_time * 1000:.1f} ms"
-            cv2.putText(
-                frame,
-                text,
-                (10, y_offset),
-                cv2.FONT_HERSHEY_SIMPLEX,
-                0.6,
-                (255, 255, 255),
-                2,
-                cv2.LINE_AA,
-            )
-            y_offset += 30
-
-        if hasattr(metrics, "squat_hold_duration"):
-            text = f"Squat Hold: {metrics.squat_hold_duration * 1000:.1f} ms"
-            cv2.putText(
-                frame,
-                text,
-                (10, y_offset),
-                cv2.FONT_HERSHEY_SIMPLEX,
-                0.6,
-                (255, 255, 255),
-                2,
-                cv2.LINE_AA,
-            )
-            y_offset += 30
-
-        if hasattr(metrics, "concentric_duration"):
-            text = f"Concentric: {metrics.concentric_duration * 1000:.1f} ms"
+        # Only show summary metrics after takeoff or at the end
+        if metrics.takeoff_frame is None or frame_index < metrics.takeoff_frame:
+            return
+
+        y_offset = PHASE_LABEL_START_Y + 100
+
+        # Display key metrics
+        metric_items: list[tuple[str, Color]] = [
+            (f"Jump Height: {metrics.jump_height:.3f} m", WHITE),
+            (f"Flight Time: {metrics.flight_time * 1000:.1f} ms", RED),
+            (f"Concentric: {metrics.concentric_duration * 1000:.1f} ms", CYAN),
+        ]
+        if metrics.peak_power is not None:
+            metric_items.append((f"Peak Power: {metrics.peak_power:.0f} W", GREEN))
+
+        for text, color in metric_items:
             cv2.putText(
                 frame,
                 text,
                 (10, y_offset),
                 cv2.FONT_HERSHEY_SIMPLEX,
                 0.6,
-                (255, 255, 255),
+                color,
                 2,
                 cv2.LINE_AA,
             )
+            y_offset += PHASE_LABEL_LINE_HEIGHT

kinemotion/squat_jump/kinematics.py

@@ -165,13 +165,11 @@ def calculate_sj_metrics(
         peak_concentric_velocity = 0.0
 
     # Calculate power and force if mass is provided
-    peak_power = calculate_peak_power(
+    peak_power = _calculate_peak_power(velocities, concentric_start, takeoff_frame, mass_kg)
+    mean_power = _calculate_mean_power(
         positions, velocities, concentric_start, takeoff_frame, fps, mass_kg
     )
-    mean_power = calculate_mean_power(
-        positions, velocities, concentric_start, takeoff_frame, fps, mass_kg
-    )
-    peak_force = calculate_peak_force(
+    peak_force = _calculate_peak_force(
         positions, velocities, concentric_start, takeoff_frame, fps, mass_kg
     )
 
@@ -193,12 +191,10 @@ def calculate_sj_metrics(
     )
 
 
-def calculate_peak_power(
-    positions: FloatArray,
+def _calculate_peak_power(
     velocities: FloatArray,
     concentric_start: int,
     takeoff_frame: int,
-    fps: float,
     mass_kg: float | None,
 ) -> float | None:
     """Calculate peak power using Sayers et al. (1999) regression equation.
@@ -212,11 +208,9 @@ def calculate_peak_power(
     - Superior to Lewis formula (73% error) and Harman equation
 
     Args:
-        positions: 1D array of vertical positions (not used in regression)
         velocities: 1D array of vertical velocities
         concentric_start: Frame index where concentric phase begins
         takeoff_frame: Frame index where takeoff occurs
-        fps: Video frames per second
         mass_kg: Athlete mass in kilograms
 
     Returns:
@@ -246,7 +240,7 @@ def calculate_peak_power(
     return float(peak_power)
 
 
-def calculate_mean_power(
+def _calculate_mean_power(
     positions: FloatArray,
     velocities: FloatArray,
     concentric_start: int,
@@ -297,7 +291,7 @@ def calculate_mean_power(
     return float(mean_power)
 
 
-def calculate_peak_force(
+def _calculate_peak_force(
     positions: FloatArray,
     velocities: FloatArray,
     concentric_start: int,

kinemotion/squat_jump/metrics_validator.py

@@ -114,11 +114,11 @@ class SJMetricsValidator(MetricsValidator):
         # PRIMARY BOUNDS CHECKS
         self._check_flight_time(data, result, profile)
         self._check_jump_height(data, result, profile)
-        self._check_squat_hold_duration(data, result, profile)
-        self._check_concentric_duration(data, result, profile)
+        self._check_squat_hold_duration(data, result)
+        self._check_concentric_duration(data, result)
         self._check_peak_concentric_velocity(data, result, profile)
-        self._check_power_metrics(data, result, profile)
-        self._check_force_metrics(data, result, profile)
+        self._check_power_metrics(data, result)
+        self._check_force_metrics(data, result)
 
         # CROSS-VALIDATION CHECKS
         self._check_flight_time_height_consistency(data, result)
@@ -183,9 +183,7 @@ class SJMetricsValidator(MetricsValidator):
             format_str="{value:.3f}m",
         )
 
-    def _check_squat_hold_duration(
-        self, metrics: MetricsDict, result: SJValidationResult, profile: AthleteProfile
-    ) -> None:
+    def _check_squat_hold_duration(self, metrics: MetricsDict, result: SJValidationResult) -> None:
         """Validate squat hold duration."""
         duration_raw = self._get_metric_value(
             metrics, "squat_hold_duration_ms", "squat_hold_duration"
@@ -210,9 +208,7 @@ class SJMetricsValidator(MetricsValidator):
                 value=duration,
             )
 
-    def _check_concentric_duration(
-        self, metrics: MetricsDict, result: SJValidationResult, profile: AthleteProfile
-    ) -> None:
+    def _check_concentric_duration(self, metrics: MetricsDict, result: SJValidationResult) -> None:
         """Validate concentric duration."""
         duration_raw = self._get_metric_value(
             metrics, "concentric_duration_ms", "concentric_duration"
@@ -268,9 +264,7 @@ class SJMetricsValidator(MetricsValidator):
             format_str="{value:.3f} m/s",
         )
 
-    def _check_power_metrics(
-        self, metrics: MetricsDict, result: SJValidationResult, profile: AthleteProfile
-    ) -> None:
+    def _check_power_metrics(self, metrics: MetricsDict, result: SJValidationResult) -> None:
         """Validate power metrics (peak and mean)."""
         power_checks = [
             ("peak_power", "peak_power_w", SJBounds.PEAK_POWER, ""),
@@ -305,9 +299,7 @@ class SJMetricsValidator(MetricsValidator):
                     value=power,
                 )
 
-    def _check_force_metrics(
-        self, metrics: MetricsDict, result: SJValidationResult, profile: AthleteProfile
-    ) -> None:
+    def _check_force_metrics(self, metrics: MetricsDict, result: SJValidationResult) -> None:
         """Validate force metrics."""
         peak_force = self._get_metric_value(metrics, "peak_force_n", "peak_force")
         if peak_force is None:

{kinemotion-0.76.0.dist-info → kinemotion-0.76.1.dist-info}/METADATA

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

{kinemotion-0.76.0.dist-info → kinemotion-0.76.1.dist-info}/RECORD

@@ -29,7 +29,7 @@ kinemotion/countermovement_jump/cli.py,sha256=m727IOg5BuixgNraCXc2sjW5jGrxrg7RKv
 kinemotion/countermovement_jump/debug_overlay.py,sha256=vF5Apiz8zDRpgrVzf52manLW99m1kHQAPSdUkar5rPs,11474
 kinemotion/countermovement_jump/joint_angles.py,sha256=by5M4LDtUfd2_Z9DmcgUl0nsvarsBYjgsE8KWWYcn08,11255
 kinemotion/countermovement_jump/kinematics.py,sha256=KwA8uSj3g1SeNf0NXMSHsp3gIw6Gfa-6QWIwdYdRXYw,13362
-kinemotion/countermovement_jump/metrics_validator.py,sha256=Gozn88jBpe77GhLIMYZfcAlfAmu4_k9R73bCfcwUsTI,24691
+kinemotion/countermovement_jump/metrics_validator.py,sha256=ma1XSLT-RIDrcjYmgfixf244TwbiosRzN7oFr4yWCXg,24609
 kinemotion/countermovement_jump/validation_bounds.py,sha256=-0iXDhH-RntiGZi_Co22V6qtA5D-hLzkrPkVcfoNd2U,11343
 kinemotion/drop_jump/__init__.py,sha256=yBbEbPdY6sqozWtTvfbvuUZnrVWSSjBp61xK34M29F4,878
 kinemotion/drop_jump/analysis.py,sha256=5jlRAjS1kN091FfxNcrkh2gh3PnDqAbnJHFXZrm3hro,34870
@@ -44,16 +44,16 @@ kinemotion/models/pose_landmarker_lite.task,sha256=WZKeHR7pUodzXd2DOxnPSsRtKbx6_
 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/squat_jump/__init__.py,sha256=h6ubO3BUANxqjKMdN-KtlN6m77HARAP25PLzHw9k-Lk,99
-kinemotion/squat_jump/analysis.py,sha256=lr8C4UDVRI1fHmzMhtcsPXWlt7bNjAKS6EytIgayzTE,12497
+kinemotion/squat_jump/analysis.py,sha256=Iwmss8EHVylN6Hace53fmGTDSxpUiEBh4AiO5YYIWc8,13500
 kinemotion/squat_jump/api.py,sha256=YMbq2BQzB_SnZ_Z-2KnR_OO2xuua-Zg0hP29Ghbk_d4,20111
 kinemotion/squat_jump/cli.py,sha256=09Q9O4_sHxw6QWDyPiynDQZSMixTO32NrJ5PTXTJNIk,9806
-kinemotion/squat_jump/debug_overlay.py,sha256=tCIeE9BqCfK-RCURCOM2oqF5qgYGMWD27QWdREpeuSc,6429
-kinemotion/squat_jump/kinematics.py,sha256=deJV1qDEn6-CLA3SxAOuuI-YDWIbEe9N8lWeZvswmgA,12231
-kinemotion/squat_jump/metrics_validator.py,sha256=F0jycY7waDxf6RqUwBulcaKD3frD7EobykgQB-Ayluk,16106
+kinemotion/squat_jump/debug_overlay.py,sha256=IZij8XQvWnmxfDhOZZiLIQ-0xuICx6lDYqcdS7TA3Kw,5280
+kinemotion/squat_jump/kinematics.py,sha256=RU5JobjkSV6Bxs3ope-4fvbeLBITFb_dv9uvHQY3fAE,12052
+kinemotion/squat_jump/metrics_validator.py,sha256=euqd3dYrDCqdifVhs0RPc-UUprkyR-PzTg-D_rIfmI4,15914
 kinemotion/squat_jump/validation_bounds.py,sha256=q01eQ8Eg01Y5UV3KlvZS1S9iY628OVPUwLoukHZvQOs,7276
 kinemotion/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kinemotion-0.76.0.dist-info/METADATA,sha256=S4_rnobPn-X8PmMBwe7jOoj-voa_dk0xBJsuhw15au4,27690
-kinemotion-0.76.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-kinemotion-0.76.0.dist-info/entry_points.txt,sha256=zaqnAnjLvcdrk1Qvj5nvXZCZ2gp0prS7it1zTJygcIY,50
-kinemotion-0.76.0.dist-info/licenses/LICENSE,sha256=KZajvqsHw0NoOHOi2q0FZ4NBe9HdV6oey-IPYAtHXfg,1088
-kinemotion-0.76.0.dist-info/RECORD,,
+kinemotion-0.76.1.dist-info/METADATA,sha256=ddJE2glHyWt9apLoYSBLt7Lpq9PZIDEjgjVVzxc5XBY,27690
+kinemotion-0.76.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+kinemotion-0.76.1.dist-info/entry_points.txt,sha256=zaqnAnjLvcdrk1Qvj5nvXZCZ2gp0prS7it1zTJygcIY,50
+kinemotion-0.76.1.dist-info/licenses/LICENSE,sha256=KZajvqsHw0NoOHOi2q0FZ4NBe9HdV6oey-IPYAtHXfg,1088
+kinemotion-0.76.1.dist-info/RECORD,,