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

kinemotion/countermovement_jump/analysis.py

@@ -55,50 +55,7 @@ class CMJPhase(Enum):
     UNKNOWN = "unknown"
 
 
-def find_lowest_point(
-    positions: FloatArray,
-    velocities: FloatArray,
-    min_search_frame: int = 80,
-) -> int:
-    """
-    Find the lowest point of countermovement (transition from eccentric to concentric).
-
-    The lowest point occurs BEFORE the peak height (the jump apex). It's where
-    velocity crosses from positive (downward/squatting) to negative (upward/jumping).
-
-    Args:
-        positions: Array of vertical positions (higher value = lower in video)
-        velocities: Array of SIGNED vertical velocities (positive=down, negative=up)
-        min_search_frame: Minimum frame to start searching (default: frame 80)
-
-    Returns:
-        Frame index of lowest point.
-    """
-    # First, find the peak height (minimum y value = highest jump point)
-    peak_height_frame = int(np.argmin(positions))
-
-    # Lowest point MUST be before peak height
-    # Search from min_search_frame to peak_height_frame
-    start_frame = min_search_frame
-    end_frame = peak_height_frame
-
-    if end_frame <= start_frame:
-        start_frame = int(len(positions) * 0.3)
-        end_frame = int(len(positions) * 0.7)
-
-    search_positions = positions[start_frame:end_frame]
-
-    if len(search_positions) == 0:
-        return start_frame
-
-    # Find maximum position value in this range (lowest point in video)
-    lowest_idx = int(np.argmax(search_positions))
-    lowest_frame = start_frame + lowest_idx
-
-    return lowest_frame
-
-
-def find_cmj_takeoff_from_velocity_peak(
+def _find_cmj_takeoff_from_velocity_peak(
     positions: FloatArray,
     velocities: FloatArray,
     lowest_point_frame: int,
@@ -135,7 +92,7 @@ def find_cmj_takeoff_from_velocity_peak(
     return float(takeoff_frame)
 
 
-def find_cmj_landing_from_position_peak(
+def _find_cmj_landing_from_position_peak(
     positions: FloatArray,
     velocities: FloatArray,
     accelerations: FloatArray,
@@ -193,7 +150,7 @@ def find_cmj_landing_from_position_peak(
     reason="Experimental alternative superseded by backward search algorithm",
     since="0.34.0",
 )
-def find_interpolated_takeoff_landing(
+def _find_interpolated_takeoff_landing(
     positions: FloatArray,
     velocities: FloatArray,
     lowest_point_frame: int,
@@ -226,19 +183,19 @@ def find_interpolated_takeoff_landing(
     )
 
     # Find takeoff using peak velocity method (CMJ-specific)
-    takeoff_frame = find_cmj_takeoff_from_velocity_peak(
+    takeoff_frame = _find_cmj_takeoff_from_velocity_peak(
         positions, velocities, lowest_point_frame, fps
     )
 
     # Find landing using position peak and impact detection
-    landing_frame = find_cmj_landing_from_position_peak(
+    landing_frame = _find_cmj_landing_from_position_peak(
         positions, velocities, accelerations, int(takeoff_frame), fps
     )
 
     return (takeoff_frame, landing_frame)
 
 
-def find_takeoff_frame(
+def _find_takeoff_frame(
     velocities: FloatArray,
     peak_height_frame: int,
     fps: float,
@@ -301,7 +258,7 @@ def find_takeoff_frame(
     return float(peak_vel_frame)
 
 
-def find_lowest_frame(
+def _find_lowest_frame(
     velocities: FloatArray, positions: FloatArray, takeoff_frame: float, fps: float
 ) -> float:
     """Find lowest point frame before takeoff."""
@@ -370,7 +327,7 @@ def _find_landing_impact(
     return float(landing_frame)
 
 
-def find_landing_frame(
+def _find_landing_frame(
     accelerations: FloatArray,
     velocities: FloatArray,
     peak_height_frame: int,
@@ -422,7 +379,7 @@ def compute_average_hip_position(
     return (float(np.mean(x_positions)), float(np.mean(y_positions)))
 
 
-def find_standing_end(
+def _find_standing_end(
     velocities: FloatArray,
     lowest_point: float,
     _positions: FloatArray | None = None,
@@ -533,12 +490,12 @@ def detect_cmj_phases(
 
     # Step 2-4: Find all phases using helper functions
     with timer.measure("cmj_find_takeoff"):
-        takeoff_frame = find_takeoff_frame(
+        takeoff_frame = _find_takeoff_frame(
             velocities, peak_height_frame, fps, accelerations=accelerations
         )
 
     with timer.measure("cmj_find_lowest_point"):
-        lowest_point = find_lowest_frame(velocities, positions, takeoff_frame, fps)
+        lowest_point = _find_lowest_frame(velocities, positions, takeoff_frame, fps)
 
     # Determine landing frame
     with timer.measure("cmj_find_landing"):
@@ -552,7 +509,7 @@ def detect_cmj_phases(
             )
             # We still reference peak_height_frame from Hips, as Feet peak
             # might be different/noisy but generally they align in time.
-            landing_frame = find_landing_frame(
+            landing_frame = _find_landing_frame(
                 landing_accelerations,
                 landing_velocities,
                 peak_height_frame,
@@ -560,7 +517,7 @@ def detect_cmj_phases(
             )
         else:
             # Use primary signal (Hips)
-            landing_frame = find_landing_frame(
+            landing_frame = _find_landing_frame(
                 accelerations,
                 velocities,
                 peak_height_frame,
@@ -568,6 +525,6 @@ def detect_cmj_phases(
             )
 
     with timer.measure("cmj_find_standing_end"):
-        standing_end = find_standing_end(velocities, lowest_point, positions, accelerations)
+        standing_end = _find_standing_end(velocities, lowest_point, positions, accelerations)
 
     return (standing_end, lowest_point, takeoff_frame, landing_frame)

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/drop_jump/__init__.py

@@ -3,11 +3,8 @@
 from ..core.smoothing import interpolate_threshold_crossing
 from .analysis import (
     ContactState,
-    calculate_adaptive_threshold,
     compute_average_foot_position,
     detect_ground_contact,
-    find_interpolated_phase_transitions_with_curvature,
-    refine_transition_with_curvature,
 )
 from .debug_overlay import DropJumpDebugOverlayRenderer
 from .kinematics import DropJumpMetrics, calculate_drop_jump_metrics
@@ -17,10 +14,7 @@ __all__ = [
     "ContactState",
     "detect_ground_contact",
     "compute_average_foot_position",
-    "calculate_adaptive_threshold",
     "interpolate_threshold_crossing",
-    "refine_transition_with_curvature",
-    "find_interpolated_phase_transitions_with_curvature",
     # Metrics
     "DropJumpMetrics",
     "calculate_drop_jump_metrics",

kinemotion/drop_jump/analysis.py

@@ -27,7 +27,7 @@ class ContactState(Enum):
     remove_in="1.0.0",
     since="0.34.0",
 )
-def calculate_adaptive_threshold(
+def _calculate_adaptive_threshold(
     positions: FloatArray,
     fps: float,
     baseline_duration: float = 3.0,
@@ -188,7 +188,7 @@ def _find_drop_from_baseline(
     return 0
 
 
-def detect_drop_start(
+def _detect_drop_start(
     positions: FloatArray,
     fps: float,
     min_stationary_duration: float = 1.0,
@@ -580,7 +580,7 @@ def _interpolate_phase_end(
     )
 
 
-def find_interpolated_phase_transitions(
+def _find_interpolated_phase_transitions(
     foot_positions: FloatArray,
     contact_states: list[ContactState],
     velocity_threshold: float,
@@ -622,7 +622,7 @@ def find_interpolated_phase_transitions(
     return interpolated_phases
 
 
-def refine_transition_with_curvature(
+def _refine_transition_with_curvature(
     foot_positions: FloatArray,
     estimated_frame: float,
     transition_type: str,
@@ -720,7 +720,7 @@ def _refine_phase_boundaries(
     Returns:
         Tuple of (refined_start, refined_end) fractional frame indices
     """
-    refined_start = refine_transition_with_curvature(
+    refined_start = _refine_transition_with_curvature(
         foot_positions,
         start_frac,
         start_type,
@@ -728,7 +728,7 @@ def _refine_phase_boundaries(
         smoothing_window=smoothing_window,
         polyorder=polyorder,
     )
-    refined_end = refine_transition_with_curvature(
+    refined_end = _refine_transition_with_curvature(
         foot_positions,
         end_frac,
         end_type,
@@ -739,7 +739,7 @@ def _refine_phase_boundaries(
     return refined_start, refined_end
 
 
-def find_interpolated_phase_transitions_with_curvature(
+def _find_interpolated_phase_transitions_with_curvature(
     foot_positions: FloatArray,
     contact_states: list[ContactState],
     velocity_threshold: float,
@@ -767,7 +767,7 @@ def find_interpolated_phase_transitions_with_curvature(
         List of (start_frame, end_frame, state) tuples with fractional frame indices
     """
     # Get interpolated phases using velocity
-    interpolated_phases = find_interpolated_phase_transitions(
+    interpolated_phases = _find_interpolated_phase_transitions(
         foot_positions, contact_states, velocity_threshold, smoothing_window
     )
 
@@ -808,7 +808,7 @@ def find_interpolated_phase_transitions_with_curvature(
     return refined_phases
 
 
-def find_landing_from_acceleration(
+def _find_landing_from_acceleration(
     positions: FloatArray,
     accelerations: FloatArray,
     takeoff_frame: int,
@@ -954,7 +954,7 @@ def _calculate_average_visibility(
     reason="Alternative implementation not called by pipeline",
     since="0.34.0",
 )
-def extract_foot_positions_and_visibilities(
+def _extract_foot_positions_and_visibilities(
     smoothed_landmarks: list[dict[str, tuple[float, float, float]] | None],
 ) -> tuple[np.ndarray, np.ndarray]:
     """

kinemotion/drop_jump/kinematics.py

@@ -10,10 +10,10 @@ from ..core.smoothing import compute_acceleration_from_derivative
 from ..core.timing import NULL_TIMER, Timer
 from .analysis import (
     ContactState,
-    detect_drop_start,
+    _detect_drop_start,  # pyright: ignore[reportPrivateUsage]
+    _find_interpolated_phase_transitions_with_curvature,  # pyright: ignore[reportPrivateUsage]
+    _find_landing_from_acceleration,  # pyright: ignore[reportPrivateUsage]
     find_contact_phases,
-    find_interpolated_phase_transitions_with_curvature,
-    find_landing_from_acceleration,
 )
 
 if TYPE_CHECKING:
@@ -159,7 +159,7 @@ def _determine_drop_start_frame(
     """
     if drop_start_frame is None:
         # Auto-detect where drop jump actually starts (skip initial stationary period)
-        return detect_drop_start(
+        return _detect_drop_start(
             foot_y_positions,
             fps,
             min_stationary_duration=0.5,
@@ -445,7 +445,7 @@ def _analyze_flight_phase(
         accelerations = compute_acceleration_from_derivative(
             foot_y_positions, window_length=smoothing_window, polyorder=polyorder
         )
-        flight_end = find_landing_from_acceleration(
+        flight_end = _find_landing_from_acceleration(
             foot_y_positions, accelerations, flight_start, fps
         )
 
@@ -559,7 +559,7 @@ def calculate_drop_jump_metrics(
     # Find contact phases
     with timer.measure("dj_find_phases"):
         phases = find_contact_phases(contact_states)
-        interpolated_phases = find_interpolated_phase_transitions_with_curvature(
+        interpolated_phases = _find_interpolated_phase_transitions_with_curvature(
             foot_y_positions,
             contact_states,
             velocity_threshold,

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
@@ -55,7 +53,7 @@ def detect_sj_phases(
         window_length += 1
 
     # Step 1: Detect squat hold start
-    squat_hold_start = detect_squat_start(
+    squat_hold_start = _detect_squat_start(
         positions,
         fps,
         velocity_threshold=velocity_threshold,
@@ -77,7 +75,7 @@ def detect_sj_phases(
         )
 
     # Step 3: Detect takeoff (this marks the start of concentric phase)
-    takeoff_frame = detect_takeoff(
+    takeoff_frame = _detect_takeoff(
         positions, velocities, fps, velocity_threshold=velocity_threshold
     )
 
@@ -94,7 +92,7 @@ def detect_sj_phases(
             break
 
     # Step 4: Detect landing
-    landing_frame = detect_landing(
+    landing_frame = _detect_landing(
         positions,
         velocities,
         fps,
@@ -128,7 +126,7 @@ def detect_sj_phases(
     return (squat_hold_start, concentric_start, takeoff_frame, landing_frame)
 
 
-def detect_squat_start(
+def _detect_squat_start(
     positions: FloatArray,
     fps: float,
     velocity_threshold: float = 0.1,
@@ -183,7 +181,27 @@ def detect_squat_start(
     return None
 
 
-def detect_takeoff(
+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,
     fps: float,
@@ -212,7 +230,7 @@ def detect_takeoff(
         return None
 
     # Find squat start to determine where to begin search
-    squat_start = detect_squat_start(positions, fps)
+    squat_start = _detect_squat_start(positions, fps)
     if squat_start is None:
         # If no squat start detected, start from reasonable middle point
         squat_start = len(positions) // 3
@@ -234,20 +252,44 @@ 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_landing(
+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,
     fps: float,
@@ -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
@@ -278,7 +322,7 @@ def detect_landing(
         return None
 
     # Find takeoff first (needed to determine where to start peak search)
-    takeoff_frame = detect_takeoff(
+    takeoff_frame = _detect_takeoff(
         positions, velocities, fps, velocity_threshold, 5, landing_search_window_s
     )
     if takeoff_frame is None:
@@ -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.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kinemotion
-Version: 0.76.0
+Version: 0.76.2
 Summary: Video-based kinematic analysis for athletic performance
 Project-URL: Homepage, https://github.com/feniix/kinemotion
 Project-URL: Repository, https://github.com/feniix/kinemotion
@@ -625,9 +625,9 @@ The debug video includes:
 **Solutions**:
 
 1. **Check video quality**: Ensure the athlete is clearly visible in profile view
-1. **Increase smoothing**: Use `--smoothing-window 7` or higher
-1. **Adjust detection confidence**: Try `--detection-confidence 0.6` or `--tracking-confidence 0.6`
-1. **Generate debug video**: Use `--output` to visualize what's being tracked
+2. **Increase smoothing**: Use `--smoothing-window 7` or higher
+3. **Adjust detection confidence**: Try `--detection-confidence 0.6` or `--tracking-confidence 0.6`
+4. **Generate debug video**: Use `--output` to visualize what's being tracked
 
 ### No Pose Detected
 
@@ -636,9 +636,9 @@ The debug video includes:
 **Solutions**:
 
 1. **Verify video format**: OpenCV must be able to read the video
-1. **Check framing**: Ensure full body is visible in side view
-1. **Lower confidence thresholds**: Try `--detection-confidence 0.3 --tracking-confidence 0.3`
-1. **Test video playback**: Verify video opens correctly with standard video players
+2. **Check framing**: Ensure full body is visible in side view
+3. **Lower confidence thresholds**: Try `--detection-confidence 0.3 --tracking-confidence 0.3`
+4. **Test video playback**: Verify video opens correctly with standard video players
 
 ### Incorrect Contact Detection
 
@@ -647,11 +647,11 @@ The debug video includes:
 **Solutions**:
 
 1. **Generate debug video**: Visualize contact states to diagnose the issue
-1. **Adjust velocity threshold**:
+2. **Adjust velocity threshold**:
    - If missing contacts: decrease to `--velocity-threshold 0.01`
    - If false contacts: increase to `--velocity-threshold 0.03`
-1. **Adjust minimum frames**: `--min-contact-frames 5` for longer required contact
-1. **Check visibility**: Lower `--visibility-threshold 0.3` if feet are partially obscured
+3. **Adjust minimum frames**: `--min-contact-frames 5` for longer required contact
+4. **Check visibility**: Lower `--visibility-threshold 0.3` if feet are partially obscured
 
 ### Jump Height Seems Wrong
 
@@ -660,9 +660,9 @@ The debug video includes:
 **Solutions**:
 
 1. **Check video quality**: Ensure video frame rate is adequate (30fps or higher recommended)
-1. **Verify flight time detection**: Check `flight_start_frame` and `flight_end_frame` in JSON
-1. **Compare measurements**: JSON output includes both `jump_height_m` (primary) and `jump_height_kinematic_m` (kinematic-only)
-1. **Check for drop jump detection**: If doing a drop jump, ensure first phase is elevated enough (>5% of frame height)
+2. **Verify flight time detection**: Check `flight_start_frame` and `flight_end_frame` in JSON
+3. **Compare measurements**: JSON output includes both `jump_height_m` (primary) and `jump_height_kinematic_m` (kinematic-only)
+4. **Check for drop jump detection**: If doing a drop jump, ensure first phase is elevated enough (>5% of frame height)
 
 ### Video Codec Issues
 
@@ -671,30 +671,30 @@ The debug video includes:
 **Solutions**:
 
 1. **Install additional codecs**: Ensure OpenCV has proper video codec support
-1. **Try different output format**: Use `.avi` extension instead of `.mp4`
-1. **Check output path**: Ensure write permissions for output directory
+2. **Try different output format**: Use `.avi` extension instead of `.mp4`
+3. **Check output path**: Ensure write permissions for output directory
 
 ## How It Works
 
 1. **Pose Tracking**: MediaPipe extracts 2D pose landmarks (foot points: ankles, heels, foot indices) from each frame
-1. **Position Calculation**: Averages ankle, heel, and foot index positions to determine foot location
-1. **Smoothing**: Savitzky-Golay filter reduces tracking jitter while preserving motion dynamics
-1. **Contact Detection**: Analyzes vertical position velocity to identify ground contact vs. flight phases
-1. **Phase Identification**: Finds continuous ground contact and flight periods
+2. **Position Calculation**: Averages ankle, heel, and foot index positions to determine foot location
+3. **Smoothing**: Savitzky-Golay filter reduces tracking jitter while preserving motion dynamics
+4. **Contact Detection**: Analyzes vertical position velocity to identify ground contact vs. flight phases
+5. **Phase Identification**: Finds continuous ground contact and flight periods
    - Automatically detects drop jumps vs regular jumps
    - For drop jumps: identifies box → drop → ground contact → jump sequence
-1. **Sub-Frame Interpolation**: Estimates exact transition times between frames
+6. **Sub-Frame Interpolation**: Estimates exact transition times between frames
    - Uses Savitzky-Golay derivative for smooth velocity calculation
    - Linear interpolation of velocity to find threshold crossings
    - Achieves sub-millisecond timing precision (at 30fps: ±10ms vs ±33ms)
    - Reduces timing error by 60-70% for contact and flight measurements
    - Smoother velocity curves eliminate false threshold crossings
-1. **Trajectory Curvature Analysis**: Refines transitions using acceleration patterns
+7. **Trajectory Curvature Analysis**: Refines transitions using acceleration patterns
    - Computes second derivative (acceleration) from position trajectory
    - Detects landing impact by acceleration spike
    - Identifies takeoff by acceleration change patterns
    - Provides independent validation and refinement of velocity-based detection
-1. **Metric Calculation**:
+8. **Metric Calculation**:
    - Ground contact time = contact phase duration (using fractional frames)
    - Flight time = flight phase duration (using fractional frames)
    - Jump height = kinematic estimate from flight time: (g × t²) / 8
@@ -744,9 +744,9 @@ uv run ruff check && uv run pyright && uv run pytest
 Before committing code, ensure all checks pass:
 
 1. Format with Black
-1. Fix linting issues with ruff
-1. Ensure type safety with pyright
-1. Run all tests with pytest
+2. Fix linting issues with ruff
+3. Ensure type safety with pyright
+4. Run all tests with pytest
 
 See [CONTRIBUTING.md](CONTRIBUTING.md) for contribution guidelines and requirements, or [CLAUDE.md](CLAUDE.md) for detailed development guidelines.
 

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

@@ -23,20 +23,20 @@ kinemotion/core/validation.py,sha256=-8Wwe56PO37F0OAEMpWr1AB_7QmFtDY5bVmux3oiLYM
 kinemotion/core/video_analysis_base.py,sha256=U8j-6-dv6uiGUiIHl53AIVFUiVHotgTmMNvCArSXx0E,4045
 kinemotion/core/video_io.py,sha256=tLAHm63_sap-CXQpLzmgUXpWZ5_TtBI9LHP8Tk2L-z4,9355
 kinemotion/countermovement_jump/__init__.py,sha256=SkAw9ka8Yd1Qfv9hcvk22m3EfucROzYrSNGNF5kDzho,113
-kinemotion/countermovement_jump/analysis.py,sha256=0ocj1ZbaV4rPeor-y6jvDIKsGalZoozwo7kxwFhQQ1w,20637
+kinemotion/countermovement_jump/analysis.py,sha256=XJd7o7p7l0WvjJuIzTBCnIyrhoUj7kryKZB9BltQIZY,19219
 kinemotion/countermovement_jump/api.py,sha256=uNo2JLuFDeBdpi3Y2qf-DyG-1KIRwmSF7HjXMu9Cwj0,19320
 kinemotion/countermovement_jump/cli.py,sha256=m727IOg5BuixgNraCXc2sjW5jGrxrg7RKvFS4qyrBK8,8902
 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
+kinemotion/drop_jump/__init__.py,sha256=p1lqit5OQruIcCizCJwG0OuUab6ktK_9HCp9eaHS2Io,616
+kinemotion/drop_jump/analysis.py,sha256=i38uOZEpmH0T-_8-m9Ne4I24dQO2B5tgYVIgwG0kJ4o,34880
 kinemotion/drop_jump/api.py,sha256=xcA7CkBjLQZhIs6UHr2mo5jT1p-D6e3cgRAFLSwZCmE,21927
 kinemotion/drop_jump/cli.py,sha256=WTUJWCjBl9SgR3Z-2cml1EQhVF8HaXIXQ27fS4tnR7U,14693
 kinemotion/drop_jump/debug_overlay.py,sha256=X4mvCi5Qi1gnvSZZAsUs-0ZRUx9mVBbEUznOFO21HO8,8470
-kinemotion/drop_jump/kinematics.py,sha256=59Q035bXAGGEAdrfLA2mALkWfJUifs35Tvk89xfU8pc,23657
+kinemotion/drop_jump/kinematics.py,sha256=wQSXvchqZgc-KBnLRWJw_EuhXwo764xQltRL38toou4,23780
 kinemotion/drop_jump/metrics_validator.py,sha256=yY0wzFzUUDLn6pZcOnwErMlIt_aTWq-RyAkqIemBG5M,7885
 kinemotion/drop_jump/validation_bounds.py,sha256=k31qy-kCXTiCTx0RPo2t8yZ-faLxqGO-AeF05QfBFb0,5125
 kinemotion/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -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=Y6pRtQDaSd2fl_WYwkGKWQ9_uOjATwGkrWRd1TOcOL8,13508
 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.2.dist-info/METADATA,sha256=Tro_HX69rBHnPkSVhhC2MPmI9qx5fWyTP4338wBjClA,27690
+kinemotion-0.76.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+kinemotion-0.76.2.dist-info/entry_points.txt,sha256=zaqnAnjLvcdrk1Qvj5nvXZCZ2gp0prS7it1zTJygcIY,50
+kinemotion-0.76.2.dist-info/licenses/LICENSE,sha256=KZajvqsHw0NoOHOi2q0FZ4NBe9HdV6oey-IPYAtHXfg,1088
+kinemotion-0.76.2.dist-info/RECORD,,