kinemotion 0.60.0__py3-none-any.whl → 0.61.0__py3-none-any.whl

kinemotion/cmj/analysis.py

@@ -216,9 +216,7 @@ def find_cmj_takeoff_from_velocity_peak(
         Takeoff frame with fractional precision.
     """
     concentric_start = int(lowest_point_frame)
-    search_duration = int(
-        fps * 0.3
-    )  # Search next 0.3 seconds (concentric to takeoff is brief)
+    search_duration = int(fps * 0.3)  # Search next 0.3 seconds (concentric to takeoff is brief)
     search_end = min(len(velocities), concentric_start + search_duration)
 
     if search_end <= concentric_start:
@@ -227,9 +225,7 @@ def find_cmj_takeoff_from_velocity_peak(
     # Find peak upward velocity (most NEGATIVE velocity)
     # In normalized coords: negative velocity = y decreasing = jumping up
     concentric_velocities = velocities[concentric_start:search_end]
-    takeoff_idx = int(
-        np.argmin(concentric_velocities)
-    )  # Most negative = fastest upward = takeoff
+    takeoff_idx = int(np.argmin(concentric_velocities))  # Most negative = fastest upward = takeoff
     takeoff_frame = concentric_start + takeoff_idx
 
     return float(takeoff_frame)
@@ -338,9 +334,7 @@ def find_interpolated_takeoff_landing(
     return (takeoff_frame, landing_frame)
 
 
-def find_takeoff_frame(
-    velocities: np.ndarray, peak_height_frame: int, fps: float
-) -> float:
+def find_takeoff_frame(velocities: np.ndarray, peak_height_frame: int, fps: float) -> float:
     """Find takeoff frame as peak upward velocity before peak height.
 
     Robust detection: When velocities are nearly identical (flat), detects
@@ -621,8 +615,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/cmj/api.py

@@ -91,9 +91,7 @@ def _generate_debug_video(
             timer=timer,
         ) as renderer:
             for frame, idx in zip(frames, frame_indices, strict=True):
-                annotated = renderer.render_frame(
-                    frame, smoothed_landmarks[idx], idx, metrics
-                )
+                annotated = renderer.render_frame(frame, smoothed_landmarks[idx], idx, metrics)
                 renderer.write_frame(annotated)
 
     if verbose:
@@ -142,9 +140,7 @@ def _print_quality_warnings(quality_result: QualityAssessment, verbose: bool) ->
         print()
 
 
-def _print_validation_results(
-    validation_result: ValidationResult, verbose: bool
-) -> None:
+def _print_validation_results(validation_result: ValidationResult, verbose: bool) -> None:
     """Print validation issues if present."""
     if verbose and validation_result.issues:
         print("\n⚠️  Validation Results:")
@@ -327,13 +323,9 @@ def process_cmj_video(
                 )
 
                 if verbose:
-                    print_verbose_parameters(
-                        video, characteristics, quality_preset, params
-                    )
+                    print_verbose_parameters(video, characteristics, quality_preset, params)
 
-            smoothed_landmarks = apply_smoothing(
-                landmarks_sequence, params, verbose, timer
-            )
+            smoothed_landmarks = apply_smoothing(landmarks_sequence, params, verbose, timer)
 
             if verbose:
                 print("Extracting vertical positions (Hip and Foot)...")
@@ -341,9 +333,7 @@ def process_cmj_video(
                 vertical_positions, visibilities = extract_vertical_positions(
                     smoothed_landmarks, target="hip"
                 )
-                foot_positions, _ = extract_vertical_positions(
-                    smoothed_landmarks, target="foot"
-                )
+                foot_positions, _ = extract_vertical_positions(smoothed_landmarks, target="foot")
 
             if verbose:
                 print("Detecting CMJ phases...")

kinemotion/cmj/cli.py

@@ -49,12 +49,8 @@ def _process_batch_videos(
     for video in video_files:
         try:
             click.echo(f"\nProcessing: {video}", err=True)
-            out_path, json_path = generate_batch_output_paths(
-                video, output_dir, json_output_dir
-            )
-            _process_single(
-                video, out_path, json_path, quality_preset, verbose, expert_params
-            )
+            out_path, json_path = generate_batch_output_paths(video, output_dir, json_output_dir)
+            _process_single(video, out_path, json_path, quality_preset, verbose, expert_params)
         except Exception as e:
             click.echo(f"Error processing {video}: {e}", err=True)
             continue
@@ -311,30 +307,18 @@ def _output_results(metrics: CMJMetrics, json_output: str | None) -> None:
     click.echo("=" * 60, err=True)
     click.echo(f"Jump height: {metrics.jump_height:.3f} m", err=True)
     click.echo(f"Flight time: {metrics.flight_time * 1000:.1f} ms", err=True)
+    click.echo(f"Countermovement depth: {metrics.countermovement_depth:.3f} m", err=True)
+    click.echo(f"Eccentric duration: {metrics.eccentric_duration * 1000:.1f} ms", err=True)
+    click.echo(f"Concentric duration: {metrics.concentric_duration * 1000:.1f} ms", err=True)
+    click.echo(f"Total movement time: {metrics.total_movement_time * 1000:.1f} ms", err=True)
     click.echo(
-        f"Countermovement depth: {metrics.countermovement_depth:.3f} m", err=True
-    )
-    click.echo(
-        f"Eccentric duration: {metrics.eccentric_duration * 1000:.1f} ms", err=True
-    )
-    click.echo(
-        f"Concentric duration: {metrics.concentric_duration * 1000:.1f} ms", err=True
-    )
-    click.echo(
-        f"Total movement time: {metrics.total_movement_time * 1000:.1f} ms", err=True
-    )
-    click.echo(
-        f"Peak eccentric velocity: {abs(metrics.peak_eccentric_velocity):.3f} "
-        "m/s (downward)",
+        f"Peak eccentric velocity: {abs(metrics.peak_eccentric_velocity):.3f} m/s (downward)",
         err=True,
     )
     click.echo(
-        f"Peak concentric velocity: {metrics.peak_concentric_velocity:.3f} "
-        "m/s (upward)",
+        f"Peak concentric velocity: {metrics.peak_concentric_velocity:.3f} m/s (upward)",
         err=True,
     )
     if metrics.transition_time is not None:
-        click.echo(
-            f"Transition time: {metrics.transition_time * 1000:.1f} ms", err=True
-        )
+        click.echo(f"Transition time: {metrics.transition_time * 1000:.1f} ms", err=True)
     click.echo("=" * 60, err=True)

kinemotion/cmj/debug_overlay.py

@@ -142,9 +142,7 @@ class CMJDebugOverlayRenderer(BaseDebugOverlayRenderer):
 
             # Draw ALL visible segments (not just one side)
             for start_key, end_key, color, thickness in segments:
-                self._draw_segment(
-                    frame, landmarks, start_key, end_key, color, thickness
-                )
+                self._draw_segment(frame, landmarks, start_key, end_key, color, thickness)
 
             # Draw joints as circles for this side
             self._draw_joints(frame, landmarks, side_prefix)
@@ -323,9 +321,7 @@ class CMJDebugOverlayRenderer(BaseDebugOverlayRenderer):
         phase_text = f"Phase: {phase.upper()}"
         text_size = cv2.getTextSize(phase_text, cv2.FONT_HERSHEY_SIMPLEX, 1, 2)[0]
         cv2.rectangle(frame, (5, 5), (text_size[0] + 15, 45), phase_color, -1)
-        cv2.putText(
-            frame, phase_text, (10, 35), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 0), 2
-        )
+        cv2.putText(frame, phase_text, (10, 35), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 0), 2)
 
     def _draw_key_frame_markers(
         self, frame: np.ndarray, frame_idx: int, metrics: CMJMetrics
@@ -334,9 +330,7 @@ class CMJDebugOverlayRenderer(BaseDebugOverlayRenderer):
         y_offset = 120
         markers = []
 
-        if metrics.standing_start_frame and frame_idx == int(
-            metrics.standing_start_frame
-        ):
+        if metrics.standing_start_frame and frame_idx == int(metrics.standing_start_frame):
             markers.append("COUNTERMOVEMENT START")
 
         if frame_idx == int(metrics.lowest_point_frame):

kinemotion/cmj/kinematics.py

@@ -98,29 +98,17 @@ class CMJMetrics:
         data: CMJDataDict = {
             "jump_height_m": format_float_metric(self.jump_height, 1, 3),  # type: ignore[typeddict-item]
             "flight_time_ms": format_float_metric(self.flight_time, 1000, 2),  # type: ignore[typeddict-item]
-            "countermovement_depth_m": format_float_metric(
-                self.countermovement_depth, 1, 3
-            ),  # type: ignore[typeddict-item]
-            "eccentric_duration_ms": format_float_metric(
-                self.eccentric_duration, 1000, 2
-            ),  # type: ignore[typeddict-item]
-            "concentric_duration_ms": format_float_metric(
-                self.concentric_duration, 1000, 2
-            ),  # type: ignore[typeddict-item]
-            "total_movement_time_ms": format_float_metric(
-                self.total_movement_time, 1000, 2
-            ),  # type: ignore[typeddict-item]
-            "peak_eccentric_velocity_m_s": format_float_metric(
-                self.peak_eccentric_velocity, 1, 4
-            ),  # type: ignore[typeddict-item]
+            "countermovement_depth_m": format_float_metric(self.countermovement_depth, 1, 3),  # type: ignore[typeddict-item]
+            "eccentric_duration_ms": format_float_metric(self.eccentric_duration, 1000, 2),  # type: ignore[typeddict-item]
+            "concentric_duration_ms": format_float_metric(self.concentric_duration, 1000, 2),  # type: ignore[typeddict-item]
+            "total_movement_time_ms": format_float_metric(self.total_movement_time, 1000, 2),  # type: ignore[typeddict-item]
+            "peak_eccentric_velocity_m_s": format_float_metric(self.peak_eccentric_velocity, 1, 4),  # type: ignore[typeddict-item]
             "peak_concentric_velocity_m_s": format_float_metric(
                 self.peak_concentric_velocity, 1, 4
             ),  # type: ignore[typeddict-item]
             "transition_time_ms": format_float_metric(self.transition_time, 1000, 2),
             "standing_start_frame": (
-                float(self.standing_start_frame)
-                if self.standing_start_frame is not None
-                else None
+                float(self.standing_start_frame) if self.standing_start_frame is not None else None
             ),
             "lowest_point_frame": float(self.lowest_point_frame),
             "takeoff_frame": float(self.takeoff_frame),
@@ -198,9 +186,7 @@ def _calculate_countermovement_depth(
         Countermovement depth in meters
     """
     standing_position = (
-        positions[int(standing_start_frame)]
-        if standing_start_frame is not None
-        else positions[0]
+        positions[int(standing_start_frame)] if standing_start_frame is not None else positions[0]
     )
     lowest_position = positions[int(lowest_point_frame)]
     depth_normalized = abs(standing_position - lowest_position)
@@ -269,9 +255,7 @@ def _calculate_peak_velocities(
 
     peak_concentric_velocity = 0.0
     if len(concentric_velocities) > 0:
-        peak_concentric_velocity = (
-            abs(float(np.min(concentric_velocities))) * velocity_scale
-        )
+        peak_concentric_velocity = abs(float(np.min(concentric_velocities))) * velocity_scale
 
     return peak_eccentric_velocity, peak_concentric_velocity
 
@@ -337,17 +321,13 @@ def calculate_cmj_metrics(
     jump_height = (g * flight_time**2) / 8
 
     # Calculate scaling factor and derived metrics
-    scale_factor = _calculate_scale_factor(
-        positions, takeoff_frame, landing_frame, jump_height
-    )
+    scale_factor = _calculate_scale_factor(positions, takeoff_frame, landing_frame, jump_height)
     countermovement_depth = _calculate_countermovement_depth(
         positions, standing_start_frame, lowest_point_frame, scale_factor
     )
 
-    eccentric_duration, concentric_duration, total_movement_time = (
-        _calculate_phase_durations(
-            standing_start_frame, lowest_point_frame, takeoff_frame, fps
-        )
+    eccentric_duration, concentric_duration, total_movement_time = _calculate_phase_durations(
+        standing_start_frame, lowest_point_frame, takeoff_frame, fps
     )
 
     velocity_scale = scale_factor * fps

kinemotion/cmj/metrics_validator.py

@@ -52,13 +52,9 @@ class CMJValidationResult(ValidationResult):
                 }
                 for issue in self.issues
             ],
-            "athlete_profile": (
-                self.athlete_profile.value if self.athlete_profile else None
-            ),
+            "athlete_profile": (self.athlete_profile.value if self.athlete_profile else None),
             "rsi": self.rsi,
-            "height_flight_time_consistency_percent": (
-                self.height_flight_time_consistency
-            ),
+            "height_flight_time_consistency_percent": (self.height_flight_time_consistency),
             "velocity_height_consistency_percent": self.velocity_height_consistency,
             "depth_height_ratio": self.depth_height_ratio,
             "contact_depth_ratio": self.contact_depth_ratio,
@@ -135,9 +131,7 @@ class CMJMetricsValidator(MetricsValidator):
         self, metrics: dict, result: CMJValidationResult, profile: AthleteProfile
     ) -> None:
         """Validate flight time."""
-        flight_time_raw = self._get_metric_value(
-            metrics, "flight_time_ms", "flight_time"
-        )
+        flight_time_raw = self._get_metric_value(metrics, "flight_time_ms", "flight_time")
         if flight_time_raw is None:
             return
 
@@ -167,8 +161,7 @@ class CMJMetricsValidator(MetricsValidator):
         elif bounds.contains(flight_time, profile):
             result.add_info(
                 "flight_time",
-                f"Flight time {flight_time:.3f}s within expected range for "
-                f"{profile.value}",
+                f"Flight time {flight_time:.3f}s within expected range for {profile.value}",
                 value=flight_time,
             )
         else:
@@ -210,8 +203,7 @@ class CMJMetricsValidator(MetricsValidator):
         elif bounds.contains(jump_height, profile):
             result.add_info(
                 "jump_height",
-                f"Jump height {jump_height:.3f}m within expected range for "
-                f"{profile.value}",
+                f"Jump height {jump_height:.3f}m within expected range for {profile.value}",
                 value=jump_height,
             )
         else:
@@ -228,9 +220,7 @@ class CMJMetricsValidator(MetricsValidator):
         self, metrics: dict, result: CMJValidationResult, profile: AthleteProfile
     ) -> None:
         """Validate countermovement depth."""
-        depth = self._get_metric_value(
-            metrics, "countermovement_depth_m", "countermovement_depth"
-        )
+        depth = self._get_metric_value(metrics, "countermovement_depth_m", "countermovement_depth")
         if depth is None:
             return
 
@@ -254,8 +244,7 @@ class CMJMetricsValidator(MetricsValidator):
         elif bounds.contains(depth, profile):
             result.add_info(
                 "countermovement_depth",
-                f"Countermovement depth {depth:.3f}m within expected range for "
-                f"{profile.value}",
+                f"Countermovement depth {depth:.3f}m within expected range for {profile.value}",
                 value=depth,
             )
         else:
@@ -298,16 +287,14 @@ class CMJMetricsValidator(MetricsValidator):
             else:
                 result.add_error(
                     "concentric_duration",
-                    f"Concentric duration {duration:.3f}s likely includes "
-                    "standing phase",
+                    f"Concentric duration {duration:.3f}s likely includes standing phase",
                     value=duration,
                     bounds=(bounds.absolute_min, bounds.absolute_max),
                 )
         elif bounds.contains(duration, profile):
             result.add_info(
                 "concentric_duration",
-                f"Concentric duration {duration:.3f}s within expected range for "
-                f"{profile.value}",
+                f"Concentric duration {duration:.3f}s within expected range for {profile.value}",
                 value=duration,
             )
         else:
@@ -348,8 +335,7 @@ class CMJMetricsValidator(MetricsValidator):
         elif bounds.contains(duration, profile):
             result.add_info(
                 "eccentric_duration",
-                f"Eccentric duration {duration:.3f}s within expected range for "
-                f"{profile.value}",
+                f"Eccentric duration {duration:.3f}s within expected range for {profile.value}",
                 value=duration,
             )
         else:
@@ -382,8 +368,7 @@ class CMJMetricsValidator(MetricsValidator):
             elif bounds.contains(ecc_vel, profile):
                 result.add_info(
                     "peak_eccentric_velocity",
-                    f"Peak eccentric velocity {ecc_vel:.2f} m/s within range "
-                    f"for {profile.value}",
+                    f"Peak eccentric velocity {ecc_vel:.2f} m/s within range for {profile.value}",
                     value=ecc_vel,
                 )
             else:
@@ -406,24 +391,21 @@ class CMJMetricsValidator(MetricsValidator):
                 if con_vel < bounds.absolute_min:
                     result.add_error(
                         "peak_concentric_velocity",
-                        f"Peak concentric velocity {con_vel:.2f} m/s "
-                        "insufficient to leave ground",
+                        f"Peak concentric velocity {con_vel:.2f} m/s insufficient to leave ground",
                         value=con_vel,
                         bounds=(bounds.absolute_min, bounds.absolute_max),
                     )
                 else:
                     result.add_error(
                         "peak_concentric_velocity",
-                        f"Peak concentric velocity {con_vel:.2f} m/s exceeds "
-                        "elite capability",
+                        f"Peak concentric velocity {con_vel:.2f} m/s exceeds elite capability",
                         value=con_vel,
                         bounds=(bounds.absolute_min, bounds.absolute_max),
                     )
             elif bounds.contains(con_vel, profile):
                 result.add_info(
                     "peak_concentric_velocity",
-                    f"Peak concentric velocity {con_vel:.2f} m/s within range "
-                    f"for {profile.value}",
+                    f"Peak concentric velocity {con_vel:.2f} m/s within range for {profile.value}",
                     value=con_vel,
                 )
             else:
@@ -468,8 +450,7 @@ class CMJMetricsValidator(MetricsValidator):
         else:
             result.add_info(
                 "height_flight_time_consistency",
-                f"Jump height and flight time consistent "
-                f"(error {error_pct * 100:.1f}%)",
+                f"Jump height and flight time consistent (error {error_pct * 100:.1f}%)",
                 value=error_pct,
             )
 
@@ -505,8 +486,7 @@ class CMJMetricsValidator(MetricsValidator):
         else:
             result.add_info(
                 "velocity_height_consistency",
-                f"Peak velocity and jump height consistent "
-                f"(error {error_pct * 100:.1f}%)",
+                f"Peak velocity and jump height consistent (error {error_pct * 100:.1f}%)",
                 value=error_pct,
             )
 
@@ -514,9 +494,7 @@ class CMJMetricsValidator(MetricsValidator):
         self, metrics: dict, result: CMJValidationResult, profile: AthleteProfile
     ) -> None:
         """Validate Reactive Strength Index."""
-        flight_time_raw = self._get_metric_value(
-            metrics, "flight_time_ms", "flight_time"
-        )
+        flight_time_raw = self._get_metric_value(metrics, "flight_time_ms", "flight_time")
         concentric_duration_raw = self._get_metric_value(
             metrics, "concentric_duration_ms", "concentric_duration"
         )
@@ -577,16 +555,12 @@ class CMJMetricsValidator(MetricsValidator):
                     bounds=(expected_min, expected_max),
                 )
 
-    def _check_depth_height_ratio(
-        self, metrics: dict, result: CMJValidationResult
-    ) -> None:
+    def _check_depth_height_ratio(self, metrics: dict, result: CMJValidationResult) -> None:
         """Check countermovement depth to jump height ratio."""
         depth = metrics.get("countermovement_depth_m")
         jump_height = metrics.get("jump_height_m")
 
-        if (
-            depth is None or jump_height is None or depth < 0.05
-        ):  # Skip if depth minimal
+        if depth is None or jump_height is None or depth < 0.05:  # Skip if depth minimal
             return
 
         ratio = jump_height / depth
@@ -621,9 +595,7 @@ class CMJMetricsValidator(MetricsValidator):
                 value=ratio,
             )
 
-    def _check_contact_depth_ratio(
-        self, metrics: dict, result: CMJValidationResult
-    ) -> None:
+    def _check_contact_depth_ratio(self, metrics: dict, result: CMJValidationResult) -> None:
         """Check contact time to countermovement depth ratio."""
         contact_ms = metrics.get("concentric_duration_ms")
         depth = metrics.get("countermovement_depth_m")
@@ -639,8 +611,7 @@ class CMJMetricsValidator(MetricsValidator):
         if ratio < MetricConsistency.CONTACT_DEPTH_RATIO_MIN:
             result.add_warning(
                 "contact_depth_ratio",
-                f"Contact time {ratio:.2f}s/m to depth ratio: Very fast for "
-                "depth traversed",
+                f"Contact time {ratio:.2f}s/m to depth ratio: Very fast for depth traversed",
                 value=ratio,
                 bounds=(
                     MetricConsistency.CONTACT_DEPTH_RATIO_MIN,
@@ -692,8 +663,7 @@ class CMJMetricsValidator(MetricsValidator):
             if not TripleExtensionBounds.knee_angle_valid(knee, profile):
                 result.add_warning(
                     "knee_angle",
-                    f"Knee angle {knee:.1f}° outside expected range for "
-                    f"{profile.value}",
+                    f"Knee angle {knee:.1f}° outside expected range for {profile.value}",
                     value=knee,
                 )
             else:
@@ -708,15 +678,13 @@ class CMJMetricsValidator(MetricsValidator):
             if not TripleExtensionBounds.ankle_angle_valid(ankle, profile):
                 result.add_warning(
                     "ankle_angle",
-                    f"Ankle angle {ankle:.1f}° outside expected range for "
-                    f"{profile.value}",
+                    f"Ankle angle {ankle:.1f}° outside expected range for {profile.value}",
                     value=ankle,
                 )
             else:
                 result.add_info(
                     "ankle_angle",
-                    f"Ankle angle {ankle:.1f}° within expected range for "
-                    f"{profile.value}",
+                    f"Ankle angle {ankle:.1f}° within expected range for {profile.value}",
                     value=ankle,
                 )
 
@@ -763,15 +731,9 @@ class CMJMetricsValidator(MetricsValidator):
 
         if hip <= hip_min + boundary_threshold or hip >= hip_max - boundary_threshold:
             joints_at_boundary += 1
-        if (
-            knee <= knee_min + boundary_threshold
-            or knee >= knee_max - boundary_threshold
-        ):
+        if knee <= knee_min + boundary_threshold or knee >= knee_max - boundary_threshold:
             joints_at_boundary += 1
-        if (
-            ankle <= ankle_min + boundary_threshold
-            or ankle >= ankle_max - boundary_threshold
-        ):
+        if ankle <= ankle_min + boundary_threshold or ankle >= ankle_max - boundary_threshold:
             joints_at_boundary += 1
 
         # If 2+ joints at boundaries, likely compensation pattern
@@ -785,9 +747,7 @@ class CMJMetricsValidator(MetricsValidator):
             )
 
     @staticmethod
-    def _get_profile_range(
-        profile: AthleteProfile, bounds: MetricBounds
-    ) -> tuple[float, float]:
+    def _get_profile_range(profile: AthleteProfile, bounds: MetricBounds) -> tuple[float, float]:
         """Get min/max bounds for specific profile."""
         if profile == AthleteProfile.ELDERLY:
             return (bounds.practical_min, bounds.recreational_max)

kinemotion/cmj/validation_bounds.py

@@ -299,9 +299,7 @@ ATHLETE_PROFILES = {
 }
 
 
-def estimate_athlete_profile(
-    metrics_dict: dict, gender: str | None = None
-) -> AthleteProfile:
+def estimate_athlete_profile(metrics_dict: dict, gender: str | None = None) -> AthleteProfile:
     """Estimate athlete profile from metrics.
 
     Uses jump height as primary classifier:

kinemotion/core/auto_tuning.py

@@ -168,9 +168,7 @@ def auto_tune_parameters(
     elif quality_preset == QualityPreset.ACCURATE:
         # Accurate: Maximize accuracy, accept slower processing
         velocity_threshold = base_velocity_threshold * 0.5  # More sensitive
-        min_contact_frames = (
-            base_min_contact_frames  # Don't increase (would miss brief)
-        )
+        min_contact_frames = base_min_contact_frames  # Don't increase (would miss brief)
         smoothing_window = min(11, base_smoothing_window + 2 + smoothing_adjustment)
         bilateral_filter = True  # Always use for best accuracy
         detection_confidence = 0.6
@@ -298,9 +296,7 @@ def analyze_video_sample(
         if not frame_landmarks:
             continue
 
-        frame_vis, frame_y_positions = _collect_foot_visibility_and_positions(
-            frame_landmarks
-        )
+        frame_vis, frame_y_positions = _collect_foot_visibility_and_positions(frame_landmarks)
 
         if frame_vis:
             visibilities.append(float(np.mean(frame_vis)))

kinemotion/core/debug_overlay_utils.py

@@ -49,16 +49,11 @@ def create_video_writer(
     for codec in codecs_to_try:
         try:
             fourcc = cv2.VideoWriter_fourcc(*codec)
-            writer = cv2.VideoWriter(
-                output_path, fourcc, fps, (display_width, display_height)
-            )
+            writer = cv2.VideoWriter(output_path, fourcc, fps, (display_width, display_height))
             if writer.isOpened():
                 used_codec = codec
                 if codec == "mp4v":
-                    print(
-                        f"Warning: Fallback to {codec} codec. "
-                        "Video may not play in browsers."
-                    )
+                    print(f"Warning: Fallback to {codec} codec. Video may not play in browsers.")
                 break
         except Exception:
             continue
@@ -174,9 +169,7 @@ class BaseDebugOverlayRenderer:
                 )
 
         with self.timer.measure("debug_video_write"):
-            write_overlay_frame(
-                self.writer, frame, self.display_width, self.display_height
-            )
+            write_overlay_frame(self.writer, frame, self.display_width, self.display_height)
 
     def close(self) -> None:
         """Release video writer and re-encode if possible."""
@@ -187,9 +180,7 @@ class BaseDebugOverlayRenderer:
             temp_path = None
             try:
                 temp_path = str(
-                    Path(self.output_path).with_suffix(
-                        ".temp" + Path(self.output_path).suffix
-                    )
+                    Path(self.output_path).with_suffix(".temp" + Path(self.output_path).suffix)
                 )
 
                 # Convert to H.264 with yuv420p pixel format for browser compatibility

kinemotion/core/determinism.py

@@ -32,9 +32,7 @@ def get_video_hash_seed(video_path: str) -> int:
     return int(hash_value[:8], 16)
 
 
-def set_deterministic_mode(
-    seed: int | None = None, video_path: str | None = None
-) -> None:
+def set_deterministic_mode(seed: int | None = None, video_path: str | None = None) -> None:
     """Set random seeds for reproducible analysis.
 
     Sets seeds for:

kinemotion/core/filtering.py

@@ -147,9 +147,7 @@ def remove_outliers(
 
                 # Interpolate
                 t = (idx - idx_before) / (idx_after - idx_before)
-                positions_clean[idx] = (
-                    positions[idx_before] * (1 - t) + positions[idx_after] * t
-                )
+                positions_clean[idx] = positions[idx_before] * (1 - t) + positions[idx_after] * t
             elif len(valid_before) > 0:
                 # Use last valid value
                 positions_clean[idx] = positions[valid_before[-1]]
@@ -219,9 +217,7 @@ def reject_outliers(
 
     # Remove/replace outliers
     if interpolate:
-        cleaned_positions = remove_outliers(
-            positions, outlier_mask, method="interpolate"
-        )
+        cleaned_positions = remove_outliers(positions, outlier_mask, method="interpolate")
     else:
         cleaned_positions = positions.copy()
 

kinemotion/core/pipeline_utils.py

@@ -35,8 +35,7 @@ def parse_quality_preset(quality: str) -> QualityPreset:
         return QualityPreset(quality.lower())
     except ValueError as e:
         raise ValueError(
-            f"Invalid quality preset: {quality}. "
-            "Must be 'fast', 'balanced', or 'accurate'"
+            f"Invalid quality preset: {quality}. Must be 'fast', 'balanced', or 'accurate'"
         ) from e
 
 
@@ -408,9 +407,7 @@ def process_videos_bulk_generic(
     results: list[TResult] = []
 
     with ProcessPoolExecutor(max_workers=max_workers) as executor:
-        future_to_config = {
-            executor.submit(processor_func, config): config for config in configs
-        }
+        future_to_config = {executor.submit(processor_func, config): config for config in configs}
 
         for future in as_completed(future_to_config):
             config = future_to_config[future]

kinemotion/core/pose.py

@@ -33,9 +33,7 @@ class PoseTracker:
             model_complexity=1,
         )
 
-    def process_frame(
-        self, frame: np.ndarray
-    ) -> dict[str, tuple[float, float, float]] | None:
+    def process_frame(self, frame: np.ndarray) -> dict[str, tuple[float, float, float]] | None:
         """
         Process a single frame and extract pose landmarks.
 
@@ -241,9 +239,7 @@ def compute_center_of_mass(
             0.05,
             visibility_threshold,
         )
-        _add_foot_segment(
-            segments, weights, visibilities, landmarks, side, visibility_threshold
-        )
+        _add_foot_segment(segments, weights, visibilities, landmarks, side, visibility_threshold)
 
     # Fallback if no segments found
     if not segments:
@@ -257,12 +253,8 @@ def compute_center_of_mass(
     total_weight = sum(weights)
     normalized_weights = [w / total_weight for w in weights]
 
-    com_x = float(
-        sum(p[0] * w for p, w in zip(segments, normalized_weights, strict=True))
-    )
-    com_y = float(
-        sum(p[1] * w for p, w in zip(segments, normalized_weights, strict=True))
-    )
+    com_x = float(sum(p[0] * w for p, w in zip(segments, normalized_weights, strict=True)))
+    com_y = float(sum(p[1] * w for p, w in zip(segments, normalized_weights, strict=True)))
     com_visibility = float(np.mean(visibilities)) if visibilities else 0.0
 
     return (com_x, com_y, com_visibility)

kinemotion/core/quality.py

@@ -59,12 +59,8 @@ class QualityAssessment:
                 "tracking_stable": self.quality_indicators.tracking_stable,
                 "phase_detection_clear": self.quality_indicators.phase_detection_clear,
                 "outliers_detected": self.quality_indicators.outliers_detected,
-                "outlier_percentage": round(
-                    self.quality_indicators.outlier_percentage, 1
-                ),
-                "position_variance": round(
-                    self.quality_indicators.position_variance, 6
-                ),
+                "outlier_percentage": round(self.quality_indicators.outlier_percentage, 1),
+                "position_variance": round(self.quality_indicators.position_variance, 6),
                 "fps": round(self.quality_indicators.fps, 1),
             },
             "warnings": self.warnings,

kinemotion/core/smoothing.py

@@ -207,14 +207,10 @@ def smooth_landmarks(
         y_smooth = savgol_filter(y_coords, window_length, polyorder)
         return x_smooth, y_smooth
 
-    return _smooth_landmarks_core(
-        landmark_sequence, window_length, polyorder, savgol_smoother
-    )
+    return _smooth_landmarks_core(landmark_sequence, window_length, polyorder, savgol_smoother)
 
 
-def compute_velocity(
-    positions: np.ndarray, fps: float, smooth_window: int = 3
-) -> np.ndarray:
+def compute_velocity(positions: np.ndarray, fps: float, smooth_window: int = 3) -> np.ndarray:
     """
     Compute velocity from position data.
 
@@ -423,9 +419,7 @@ def smooth_landmarks_advanced(
 
         return x_smooth, y_smooth
 
-    return _smooth_landmarks_core(
-        landmark_sequence, window_length, polyorder, advanced_smoother
-    )
+    return _smooth_landmarks_core(landmark_sequence, window_length, polyorder, advanced_smoother)
 
 
 def interpolate_threshold_crossing(

kinemotion/core/validation.py

@@ -160,12 +160,8 @@ class ValidationResult:
 
     def finalize_status(self) -> None:
         """Determine final pass/fail status based on issues."""
-        has_errors = any(
-            issue.severity == ValidationSeverity.ERROR for issue in self.issues
-        )
-        has_warnings = any(
-            issue.severity == ValidationSeverity.WARNING for issue in self.issues
-        )
+        has_errors = any(issue.severity == ValidationSeverity.ERROR for issue in self.issues)
+        has_warnings = any(issue.severity == ValidationSeverity.WARNING for issue in self.issues)
 
         if has_errors:
             self.status = "FAIL"

kinemotion/dropjump/analysis.py

@@ -176,13 +176,9 @@ def _find_drop_from_baseline(
             if debug:
                 print(f"[detect_drop_start] Drop detected at frame {drop_frame}")
                 print(
-                    f"  position_change: {position_change:.4f} > "
-                    f"{position_change_threshold:.4f}"
-                )
-                print(
-                    f"  avg_position: {avg_position:.4f} vs baseline: "
-                    f"{baseline_position:.4f}"
+                    f"  position_change: {position_change:.4f} > {position_change_threshold:.4f}"
                 )
+                print(f"  avg_position: {avg_position:.4f} vs baseline: {baseline_position:.4f}")
 
             return drop_frame
 
@@ -233,8 +229,7 @@ def detect_drop_start(
     if len(positions) < min_stable_frames + 30:
         if debug:
             print(
-                f"[detect_drop_start] Video too short: {len(positions)} < "
-                f"{min_stable_frames + 30}"
+                f"[detect_drop_start] Video too short: {len(positions)} < {min_stable_frames + 30}"
             )
         return 0
 
@@ -393,9 +388,7 @@ def detect_ground_contact(
         contact_frames = _find_contact_frames(is_stationary, min_contact_frames)
 
     # Assign states
-    return _assign_contact_states(
-        n_frames, contact_frames, visibilities, visibility_threshold
-    )
+    return _assign_contact_states(n_frames, contact_frames, visibilities, visibility_threshold)
 
 
 def find_contact_phases(
@@ -448,12 +441,8 @@ def _interpolate_phase_start(
     vel_at = velocities[start_idx]
 
     # Check threshold crossing based on state
-    is_landing = (
-        state == ContactState.ON_GROUND and vel_before > velocity_threshold > vel_at
-    )
-    is_takeoff = (
-        state == ContactState.IN_AIR and vel_before < velocity_threshold < vel_at
-    )
+    is_landing = state == ContactState.ON_GROUND and vel_before > velocity_threshold > vel_at
+    is_takeoff = state == ContactState.IN_AIR and vel_before < velocity_threshold < vel_at
 
     if is_landing or is_takeoff:
         offset = interpolate_threshold_crossing(vel_before, vel_at, velocity_threshold)
@@ -481,12 +470,8 @@ def _interpolate_phase_end(
     vel_after = velocities[end_idx + 1]
 
     # Check threshold crossing based on state
-    is_takeoff = (
-        state == ContactState.ON_GROUND and vel_at < velocity_threshold < vel_after
-    )
-    is_landing = (
-        state == ContactState.IN_AIR and vel_at > velocity_threshold > vel_after
-    )
+    is_takeoff = state == ContactState.ON_GROUND and vel_at < velocity_threshold < vel_after
+    is_landing = state == ContactState.IN_AIR and vel_at > velocity_threshold > vel_after
 
     if is_takeoff or is_landing:
         offset = interpolate_threshold_crossing(vel_at, vel_after, velocity_threshold)
@@ -528,9 +513,7 @@ def find_interpolated_phase_transitions(
     interpolated_phases: list[tuple[float, float, ContactState]] = []
 
     for start_idx, end_idx, state in phases:
-        start_frac = _interpolate_phase_start(
-            start_idx, state, velocities, velocity_threshold
-        )
+        start_frac = _interpolate_phase_start(start_idx, state, velocities, velocity_threshold)
         end_frac = _interpolate_phase_end(
             end_idx, state, velocities, velocity_threshold, len(foot_positions)
         )

kinemotion/dropjump/api.py

@@ -299,9 +299,7 @@ def _tune_and_smooth(
         Tuple of (smoothed_landmarks, params, characteristics)
     """
     with timer.measure("parameter_auto_tuning"):
-        characteristics = analyze_video_sample(
-            landmarks_sequence, video_fps, frame_count
-        )
+        characteristics = analyze_video_sample(landmarks_sequence, video_fps, frame_count)
         params = auto_tune_parameters(characteristics, quality_preset)
 
         # Apply overrides if provided
@@ -337,9 +335,7 @@ def _extract_positions_and_detect_contact(
     if verbose:
         print("Extracting foot positions...")
     with timer.measure("vertical_position_extraction"):
-        vertical_positions, visibilities = extract_vertical_positions(
-            smoothed_landmarks
-        )
+        vertical_positions, visibilities = extract_vertical_positions(smoothed_landmarks)
 
     if verbose:
         print("Detecting ground contact...")
@@ -557,9 +553,7 @@ def process_dropjump_video(
                 print_verbose_parameters(video, characteristics, quality_preset, params)
 
             vertical_positions, visibilities, contact_states = (
-                _extract_positions_and_detect_contact(
-                    smoothed_landmarks, params, timer, verbose
-                )
+                _extract_positions_and_detect_contact(smoothed_landmarks, params, timer, verbose)
             )
 
             metrics, quality_result = _calculate_metrics_and_assess_quality(
@@ -623,9 +617,7 @@ def process_dropjump_videos_bulk(
     """
 
     def error_factory(video_path: str, error_msg: str) -> DropJumpVideoResult:
-        return DropJumpVideoResult(
-            video_path=video_path, success=False, error=error_msg
-        )
+        return DropJumpVideoResult(video_path=video_path, success=False, error=error_msg)
 
     return process_videos_bulk_generic(
         configs,

kinemotion/dropjump/cli.py

@@ -382,16 +382,10 @@ def _compute_batch_statistics(results: list[DropJumpVideoResult]) -> None:
     if successful:
         # Calculate average metrics
         with_gct = [
-            r
-            for r in successful
-            if r.metrics and r.metrics.ground_contact_time is not None
-        ]
-        with_flight = [
-            r for r in successful if r.metrics and r.metrics.flight_time is not None
-        ]
-        with_jump = [
-            r for r in successful if r.metrics and r.metrics.jump_height is not None
+            r for r in successful if r.metrics and r.metrics.ground_contact_time is not None
         ]
+        with_flight = [r for r in successful if r.metrics and r.metrics.flight_time is not None]
+        with_jump = [r for r in successful if r.metrics and r.metrics.jump_height is not None]
 
         if with_gct:
             avg_gct = sum(
@@ -528,9 +522,7 @@ def _process_batch(
     expert_params: AnalysisParameters,
 ) -> None:
     """Process multiple videos in batch mode using parallel processing."""
-    click.echo(
-        f"\nBatch processing {len(video_files)} videos with {workers} workers", err=True
-    )
+    click.echo(f"\nBatch processing {len(video_files)} videos with {workers} workers", err=True)
     click.echo("=" * 70, err=True)
 
     # Setup output directories
@@ -550,8 +542,7 @@ def _process_batch(
         status = "✓" if result.success else "✗"
         video_name = Path(result.video_path).name
         click.echo(
-            f"[{completed}/{len(configs)}] {status} {video_name} "
-            f"({result.processing_time:.1f}s)",
+            f"[{completed}/{len(configs)}] {status} {video_name} ({result.processing_time:.1f}s)",
             err=True,
         )
         if not result.success:

kinemotion/dropjump/debug_overlay.py

@@ -150,9 +150,7 @@ class DebugOverlayRenderer(BaseDebugOverlayRenderer):
                     self._draw_foot_visualization(annotated, landmarks, contact_state)
 
             # Draw contact state
-            state_color = (
-                (0, 255, 0) if contact_state == ContactState.ON_GROUND else (0, 0, 255)
-            )
+            state_color = (0, 255, 0) if contact_state == ContactState.ON_GROUND else (0, 0, 255)
             cv2.putText(
                 annotated,
                 f"State: {contact_state.value}",

kinemotion/dropjump/kinematics.py

@@ -87,17 +87,11 @@ class DropJumpMetrics:
             Dictionary containing formatted metric values.
         """
         return {
-            "ground_contact_time_ms": format_float_metric(
-                self.ground_contact_time, 1000, 2
-            ),
+            "ground_contact_time_ms": format_float_metric(self.ground_contact_time, 1000, 2),
             "flight_time_ms": format_float_metric(self.flight_time, 1000, 2),
             "jump_height_m": format_float_metric(self.jump_height, 1, 3),
-            "jump_height_kinematic_m": format_float_metric(
-                self.jump_height_kinematic, 1, 3
-            ),
-            "jump_height_trajectory_m": format_float_metric(
-                self.jump_height_trajectory_m, 1, 3
-            ),
+            "jump_height_kinematic_m": format_float_metric(self.jump_height_kinematic, 1, 3),
+            "jump_height_trajectory_m": format_float_metric(self.jump_height_trajectory_m, 1, 3),
             "jump_height_trajectory_normalized": format_float_metric(
                 self.jump_height_trajectory, 1, 4
             ),
@@ -109,15 +103,11 @@ class DropJumpMetrics:
             "contact_start_frame_precise": format_float_metric(
                 self.contact_start_frame_precise, 1, 3
             ),
-            "contact_end_frame_precise": format_float_metric(
-                self.contact_end_frame_precise, 1, 3
-            ),
+            "contact_end_frame_precise": format_float_metric(self.contact_end_frame_precise, 1, 3),
             "flight_start_frame_precise": format_float_metric(
                 self.flight_start_frame_precise, 1, 3
             ),
-            "flight_end_frame_precise": format_float_metric(
-                self.flight_end_frame_precise, 1, 3
-            ),
+            "flight_end_frame_precise": format_float_metric(self.flight_end_frame_precise, 1, 3),
         }
 
     def _build_metadata_dict(self) -> dict:
@@ -183,9 +173,7 @@ def _filter_phases_after_drop(
     phases: list[tuple[int, int, ContactState]],
     interpolated_phases: list[tuple[float, float, ContactState]],
     drop_start_frame: int,
-) -> tuple[
-    list[tuple[int, int, ContactState]], list[tuple[float, float, ContactState]]
-]:
+) -> tuple[list[tuple[int, int, ContactState]], list[tuple[float, float, ContactState]]]:
     """Filter phases to only include those after drop start.
 
     Args:
@@ -203,9 +191,7 @@ def _filter_phases_after_drop(
         (start, end, state) for start, end, state in phases if end >= drop_start_frame
     ]
     filtered_interpolated = [
-        (start, end, state)
-        for start, end, state in interpolated_phases
-        if end >= drop_start_frame
+        (start, end, state) for start, end, state in interpolated_phases if end >= drop_start_frame
     ]
     return filtered_phases, filtered_interpolated
 
@@ -268,9 +254,7 @@ def _identify_main_contact_phase(
 
         # Find ground phase after first air phase
         ground_after_air = [
-            (start, end, idx)
-            for start, end, idx in ground_phases
-            if idx > first_air_idx
+            (start, end, idx) for start, end, idx in ground_phases if idx > first_air_idx
         ]
 
         if ground_after_air and first_ground_idx < first_air_idx:
@@ -467,9 +451,7 @@ def calculate_drop_jump_metrics(
         )
 
     # Store drop start frame in metrics
-    metrics.drop_start_frame = (
-        drop_start_frame_value if drop_start_frame_value > 0 else None
-    )
+    metrics.drop_start_frame = drop_start_frame_value if drop_start_frame_value > 0 else None
 
     # Find contact phases
     with timer.measure("dj_find_phases"):

kinemotion/dropjump/metrics_validator.py

@@ -45,9 +45,7 @@ class DropJumpValidationResult(ValidationResult):
                 }
                 for issue in self.issues
             ],
-            "athlete_profile": (
-                self.athlete_profile.value if self.athlete_profile else None
-            ),
+            "athlete_profile": (self.athlete_profile.value if self.athlete_profile else None),
             "rsi": self.rsi,
             "contact_flight_ratio": self.contact_flight_ratio,
             "height_kinematic_trajectory_consistency_percent": (
@@ -130,14 +128,11 @@ class DropJumpMetricsValidator(MetricsValidator):
             profile_name = result.athlete_profile.value
             result.add_warning(
                 "contact_time",
-                f"Contact time {contact_time_s:.3f}s unusual for "
-                f"{profile_name} athlete",
+                f"Contact time {contact_time_s:.3f}s unusual for {profile_name} athlete",
                 value=contact_time_s,
             )
 
-    def _check_flight_time(
-        self, flight_time_ms: float, result: DropJumpValidationResult
-    ) -> None:
+    def _check_flight_time(self, flight_time_ms: float, result: DropJumpValidationResult) -> None:
         """Validate flight time."""
         flight_time_s = flight_time_ms / 1000.0
         bounds = DropJumpBounds.FLIGHT_TIME
@@ -149,9 +144,7 @@ class DropJumpMetricsValidator(MetricsValidator):
                 value=flight_time_s,
                 bounds=(bounds.absolute_min, bounds.absolute_max),
             )
-        elif result.athlete_profile and not bounds.contains(
-            flight_time_s, result.athlete_profile
-        ):
+        elif result.athlete_profile and not bounds.contains(flight_time_s, result.athlete_profile):
             profile_name = result.athlete_profile.value
             result.add_warning(
                 "flight_time",
@@ -159,9 +152,7 @@ class DropJumpMetricsValidator(MetricsValidator):
                 value=flight_time_s,
             )
 
-    def _check_jump_height(
-        self, jump_height_m: float, result: DropJumpValidationResult
-    ) -> None:
+    def _check_jump_height(self, jump_height_m: float, result: DropJumpValidationResult) -> None:
         """Validate jump height."""
         bounds = DropJumpBounds.JUMP_HEIGHT
 
@@ -172,9 +163,7 @@ class DropJumpMetricsValidator(MetricsValidator):
                 value=jump_height_m,
                 bounds=(bounds.absolute_min, bounds.absolute_max),
             )
-        elif result.athlete_profile and not bounds.contains(
-            jump_height_m, result.athlete_profile
-        ):
+        elif result.athlete_profile and not bounds.contains(jump_height_m, result.athlete_profile):
             profile_name = result.athlete_profile.value
             result.add_warning(
                 "jump_height",
@@ -206,9 +195,7 @@ class DropJumpMetricsValidator(MetricsValidator):
                     value=rsi,
                     bounds=(bounds.absolute_min, bounds.absolute_max),
                 )
-            elif result.athlete_profile and not bounds.contains(
-                rsi, result.athlete_profile
-            ):
+            elif result.athlete_profile and not bounds.contains(rsi, result.athlete_profile):
                 result.add_warning(
                     "rsi",
                     f"RSI {rsi:.2f} unusual for {result.athlete_profile.value} athlete",

kinemotion/dropjump/validation_bounds.py

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

{kinemotion-0.60.0.dist-info → kinemotion-0.61.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kinemotion
-Version: 0.60.0
+Version: 0.61.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.61.0.dist-info/RECORD

@@ -0,0 +1,42 @@
+kinemotion/__init__.py,sha256=Ho_BUtsM0PBxBW1ye9RlUg0ZqBlgGudRI9bZTF7QKUI,966
+kinemotion/api.py,sha256=uG1e4bTnj2c-6cbZJEZ_LjMwFdaG32ba2KcK_XjE_NI,1040
+kinemotion/cli.py,sha256=cqYV_7URH0JUDy1VQ_EDLv63FmNO4Ns20m6s1XAjiP4,464
+kinemotion/cmj/__init__.py,sha256=SkAw9ka8Yd1Qfv9hcvk22m3EfucROzYrSNGNF5kDzho,113
+kinemotion/cmj/analysis.py,sha256=ZtKVfDj1-qoegXPklMO1GX8_OtD8pYbTyTCW4FCeaS8,22140
+kinemotion/cmj/api.py,sha256=Xu6PepQKQFzRWZMESaWvHyPV-dueCH1TQQeQdil1KiQ,16626
+kinemotion/cmj/cli.py,sha256=P2b77IIw6kqTSIkncxlShzhmjIwqMFBNd-pZxYP-TsI,9918
+kinemotion/cmj/debug_overlay.py,sha256=bX9aPLhXiLCCMZW9v8Y4OiOAaZO0i-UGr-Pl8HCsmbI,15810
+kinemotion/cmj/joint_angles.py,sha256=HmheIEiKcQz39cRezk4h-htorOhGNPsqKIR9RsAEKts,9960
+kinemotion/cmj/kinematics.py,sha256=5xAqBP_lwDGP4fcnMXozELj0XRzBcWYGmI0tsVMYbnw,13413
+kinemotion/cmj/metrics_validator.py,sha256=10Dx7-o5-ziQ9YXnzs98v_ZqJxi3ax3COwNY8M_KqqM,30835
+kinemotion/cmj/validation_bounds.py,sha256=1QXaX3uclU2ceZya90u5qVT1tWU4kGkUW0CQbvh317I,11989
+kinemotion/core/__init__.py,sha256=U2fnLUGXQ0jbwpXhdksYKDXbeQndEHjn9gwTAEJ9Av0,1451
+kinemotion/core/auto_tuning.py,sha256=lhAqPc-eLjMYx9BCvKdECE7TD2Dweb9KcifV6JHaXOE,11278
+kinemotion/core/cli_utils.py,sha256=sQPbT6XWWau-sm9yuN5c3eS5xNzoQGGXwSz6hQXtRvM,1859
+kinemotion/core/debug_overlay_utils.py,sha256=YlDmKns6x37H4yvulGGEUJ_D8G0bDZFTSbV8ig2hfFQ,8400
+kinemotion/core/determinism.py,sha256=Frw-KAOvAxTL_XtxoWpXCjMbQPUKEAusK6JctlkeuRo,2509
+kinemotion/core/experimental.py,sha256=IK05AF4aZS15ke85hF3TWCqRIXU1AlD_XKzFz735Ua8,3640
+kinemotion/core/filtering.py,sha256=Oc__pV6iHEGyyovbqa5SUi-6v8QyvaRVwA0LRayM884,11355
+kinemotion/core/formatting.py,sha256=G_3eqgOtym9RFOZVEwCxye4A2cyrmgvtQ214vIshowU,2480
+kinemotion/core/metadata.py,sha256=bJAVa4nym__zx1hNowSZduMGKBSGOPxTbBQkjm6N0D0,7207
+kinemotion/core/pipeline_utils.py,sha256=q32c1AJ8KI4Ht-K3ZiI7ectQKtg8k_FLdLy6WPBPWkU,14927
+kinemotion/core/pose.py,sha256=b7RQF4prb40hb4Yr5ATBFsj3dvEX0ohkG4h65lqHf8E,8993
+kinemotion/core/quality.py,sha256=VUkRL2N6B7lfIZ2pE9han_U68JwarmZz1U0ygHkgkhE,13022
+kinemotion/core/smoothing.py,sha256=-RPZzNjgtBQ-Ri0o-inkwIfx30IKo7ZTSnxXJ3Itn9w,15616
+kinemotion/core/timing.py,sha256=d1rjZc07Nbi5Jrio9AC-zeS0dNAlbPyNIydLz7X75Pk,7804
+kinemotion/core/validation.py,sha256=0xVv-ftWveV60fJ97kmZMuy2Qqqb5aZLR50dDIrjnhg,6773
+kinemotion/core/video_io.py,sha256=vCwpWnlW2y29l48dFXokdehQn42w_IQvayxbVTjpXqQ,7863
+kinemotion/dropjump/__init__.py,sha256=tC3H3BrCg8Oj-db-Vrtx4PH_llR1Ppkd5jwaOjhQcLg,862
+kinemotion/dropjump/analysis.py,sha256=WQ2ol5fWAXA2y-0UDGXgF587qsOsKNgkWPQLXaNZMdU,28005
+kinemotion/dropjump/api.py,sha256=uidio49CXisyWKd287CnCrM51GusG9DWAIUKGH85fpM,20584
+kinemotion/dropjump/cli.py,sha256=gUef9nmyR5952h1WnfBGyCdFXQvzVTlCKYAjJGcO4sE,16819
+kinemotion/dropjump/debug_overlay.py,sha256=9RQYXPRf0q2wdy6y2Ak2R4tpRceDwC8aJrXZzkmh3Wo,5942
+kinemotion/dropjump/kinematics.py,sha256=dx4PuXKfKMKcsc_HX6sXj8rHXf9ksiZIOAIkJ4vBlY4,19637
+kinemotion/dropjump/metrics_validator.py,sha256=367-TFal2bVDU3zwoCDpYY_lnYjSdXOrvNIIxVnIWiE,9190
+kinemotion/dropjump/validation_bounds.py,sha256=MUMJhGV62peFuIHdPR1uulMS4bI-i_JerGh5T9HF8Wk,5071
+kinemotion/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kinemotion-0.61.0.dist-info/METADATA,sha256=XKDUV9jvvAFNsZPfEfw-qn_tgr_ZLzDu2vmRUkUwZdg,26020
+kinemotion-0.61.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+kinemotion-0.61.0.dist-info/entry_points.txt,sha256=zaqnAnjLvcdrk1Qvj5nvXZCZ2gp0prS7it1zTJygcIY,50
+kinemotion-0.61.0.dist-info/licenses/LICENSE,sha256=KZajvqsHw0NoOHOi2q0FZ4NBe9HdV6oey-IPYAtHXfg,1088
+kinemotion-0.61.0.dist-info/RECORD,,

kinemotion-0.60.0.dist-info/RECORD

@@ -1,42 +0,0 @@
-kinemotion/__init__.py,sha256=Ho_BUtsM0PBxBW1ye9RlUg0ZqBlgGudRI9bZTF7QKUI,966
-kinemotion/api.py,sha256=uG1e4bTnj2c-6cbZJEZ_LjMwFdaG32ba2KcK_XjE_NI,1040
-kinemotion/cli.py,sha256=cqYV_7URH0JUDy1VQ_EDLv63FmNO4Ns20m6s1XAjiP4,464
-kinemotion/cmj/__init__.py,sha256=SkAw9ka8Yd1Qfv9hcvk22m3EfucROzYrSNGNF5kDzho,113
-kinemotion/cmj/analysis.py,sha256=3l0vYQB9tN4HtEO2MPFHVtrdzSmXgwpCm03qzYLCF0c,22196
-kinemotion/cmj/api.py,sha256=TYWja-Ellfyq_R2ixfvQyCWnPON7CG7IZk8odlLVM8E,16784
-kinemotion/cmj/cli.py,sha256=r3k5LDRXob12PV_6f6XnXOzKXoGn5WfeCMXkxiJ_CYE,10078
-kinemotion/cmj/debug_overlay.py,sha256=fXmWoHhqMLGo4vTtB6Ezs3yLUDOLw63zLIgU2gFlJQU,15892
-kinemotion/cmj/joint_angles.py,sha256=HmheIEiKcQz39cRezk4h-htorOhGNPsqKIR9RsAEKts,9960
-kinemotion/cmj/kinematics.py,sha256=Q-L8M7wG-MJ6EJTq6GO17c8sD5cb0Jg6Hc5vUZr14bA,13673
-kinemotion/cmj/metrics_validator.py,sha256=JAakR4RgNvUc7GM9Aj2TQrtatYpCCCGSzkBMXOldKjw,31455
-kinemotion/cmj/validation_bounds.py,sha256=9ZTo68fl3ooyWjXXyTMRLpK9tFANa_rQf3oHhq7iQGE,11995
-kinemotion/core/__init__.py,sha256=U2fnLUGXQ0jbwpXhdksYKDXbeQndEHjn9gwTAEJ9Av0,1451
-kinemotion/core/auto_tuning.py,sha256=wtCUMOhBChVJNXfEeku3GCMW4qED6MF-O_mv2sPTiVQ,11324
-kinemotion/core/cli_utils.py,sha256=sQPbT6XWWau-sm9yuN5c3eS5xNzoQGGXwSz6hQXtRvM,1859
-kinemotion/core/debug_overlay_utils.py,sha256=-goE3w4gBij99y1U4ckU5iaQPS0SupcHplT04DDWzUo,8579
-kinemotion/core/determinism.py,sha256=NwVrHqJiVxxFHTBPVy8aDBJH2SLIcYIpdGFp7glblB8,2515
-kinemotion/core/experimental.py,sha256=IK05AF4aZS15ke85hF3TWCqRIXU1AlD_XKzFz735Ua8,3640
-kinemotion/core/filtering.py,sha256=GsC9BB71V07LJJHgS2lsaxUAtJsupcUiwtZFDgODh8c,11417
-kinemotion/core/formatting.py,sha256=G_3eqgOtym9RFOZVEwCxye4A2cyrmgvtQ214vIshowU,2480
-kinemotion/core/metadata.py,sha256=bJAVa4nym__zx1hNowSZduMGKBSGOPxTbBQkjm6N0D0,7207
-kinemotion/core/pipeline_utils.py,sha256=0u7o-UFZX6cOu3NaWpFmEy5ejS0WUKggZ1HSdeZXhoA,14964
-kinemotion/core/pose.py,sha256=z1OGuwnc-NdK6Aoc9UYCyPBzomw4eInexOWonZbsEoA,9057
-kinemotion/core/quality.py,sha256=dPGQp08y8DdEUbUdjTThnUOUsALgF0D2sdz50cm6wLI,13098
-kinemotion/core/smoothing.py,sha256=FZmv3rumn0mYKU2y3JPKz46EvD8TVmQ6_GsN_Vp3BdU,15650
-kinemotion/core/timing.py,sha256=d1rjZc07Nbi5Jrio9AC-zeS0dNAlbPyNIydLz7X75Pk,7804
-kinemotion/core/validation.py,sha256=UOdB0v-xZjYvUogwlSdX4luDHy1E0VCJvmu4VvrVPyc,6817
-kinemotion/core/video_io.py,sha256=vCwpWnlW2y29l48dFXokdehQn42w_IQvayxbVTjpXqQ,7863
-kinemotion/dropjump/__init__.py,sha256=tC3H3BrCg8Oj-db-Vrtx4PH_llR1Ppkd5jwaOjhQcLg,862
-kinemotion/dropjump/analysis.py,sha256=p7nnCe7V6vnhQKZVYk--_nhsTvVa_WY-A3zXmyplsew,28211
-kinemotion/dropjump/api.py,sha256=O8DSTLankRibFH8pf1A9idK0x9-khKpG1h2X5nlg5Ms,20688
-kinemotion/dropjump/cli.py,sha256=Ho80fSOgH8zo2e8dGQA90VXL-mZPVvnpc1ZKtl51vB0,16917
-kinemotion/dropjump/debug_overlay.py,sha256=8XVuDyZ3nuNoCYkxcUWC7wyEoHyBxx77Sb--B1KiYWw,5974
-kinemotion/dropjump/kinematics.py,sha256=PATlGaClutGKJslL-LRIXHmTsvb-xEB8PUIMScU_K4c,19849
-kinemotion/dropjump/metrics_validator.py,sha256=CrTlGup8q2kyPXtA6HNwm7_yq0AsBaDllG7RVZdXmYA,9342
-kinemotion/dropjump/validation_bounds.py,sha256=fyl04ZV7nfvHkL5eob6oEpV9Hxce6aiOWQ9pclLp7AQ,5077
-kinemotion/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kinemotion-0.60.0.dist-info/METADATA,sha256=vqgWB9ipABFSv5FYyL8bB-qiYovxwcRJlU2-BLVj8xI,26020
-kinemotion-0.60.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-kinemotion-0.60.0.dist-info/entry_points.txt,sha256=zaqnAnjLvcdrk1Qvj5nvXZCZ2gp0prS7it1zTJygcIY,50
-kinemotion-0.60.0.dist-info/licenses/LICENSE,sha256=KZajvqsHw0NoOHOi2q0FZ4NBe9HdV6oey-IPYAtHXfg,1088
-kinemotion-0.60.0.dist-info/RECORD,,