kinemotion 0.11.1__tar.gz → 0.11.3__tar.gz

{kinemotion-0.11.1 → kinemotion-0.11.3}/CHANGELOG.md

@@ -7,6 +7,34 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 <!-- version list -->
 
+## v0.11.3 (2025-11-06)
+
+### Bug Fixes
+
+- Deduplicate CLI utilities across CMJ and drop jump modules
+  ([`c314083`](https://github.com/feniix/kinemotion/commit/c314083dd6601071f75ded38864f7ba9a9daab3d))
+
+- **cmj**: Remove unused countermovement_threshold parameter from process_cmj_video
+  ([`a8d9425`](https://github.com/feniix/kinemotion/commit/a8d9425a509b44ccf5c9e983e2d8552e9b5f8839))
+
+
+## v0.11.2 (2025-11-06)
+
+### Bug Fixes
+
+- **cmj**: Reduce cognitive complexity in _extract_positions_from_landmarks
+  ([`9772df6`](https://github.com/feniix/kinemotion/commit/9772df69ca8fb2a46726614dd0adda3795cf0ad1))
+
+- **cmj**: Reduce cognitive complexity in cmj_analyze CLI function
+  ([`e9c7200`](https://github.com/feniix/kinemotion/commit/e9c720081df171d2b18150a5b370c4471fdf9b19))
+
+- **cmj**: Reduce cognitive complexity in debug overlay rendering
+  ([`11f35c4`](https://github.com/feniix/kinemotion/commit/11f35c4cf675301bccfef376e12c0ed06470e259))
+
+- **cmj**: Remove unused variable and parameters in api and analysis
+  ([`e8ef607`](https://github.com/feniix/kinemotion/commit/e8ef60735711f4c715d53049477362284efca433))
+
+
 ## v0.11.1 (2025-11-06)
 
 ### Bug Fixes

{kinemotion-0.11.1 → kinemotion-0.11.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kinemotion
-Version: 0.11.1
+Version: 0.11.3
 Summary: Video-based kinematic analysis for athletic performance
 Project-URL: Homepage, https://github.com/feniix/kinemotion
 Project-URL: Repository, https://github.com/feniix/kinemotion

{kinemotion-0.11.1 → kinemotion-0.11.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kinemotion"
-version = "0.11.1"
+version = "0.11.3"
 description = "Video-based kinematic analysis for athletic performance"
 readme = "README.md"
 requires-python = ">=3.10,<3.13"

{kinemotion-0.11.1 → kinemotion-0.11.3}/src/kinemotion/api.py

@@ -638,6 +638,50 @@ class CMJVideoResult:
     processing_time: float = 0.0
 
 
+def _generate_cmj_outputs(
+    output_video: str | None,
+    json_output: str | None,
+    metrics: CMJMetrics,
+    frames: list,
+    smoothed_landmarks: list,
+    video_width: int,
+    video_height: int,
+    video_display_width: int,
+    video_display_height: int,
+    video_fps: float,
+    verbose: bool,
+) -> None:
+    """Generate JSON and debug video outputs for CMJ analysis."""
+    if json_output:
+        import json
+
+        output_path = Path(json_output)
+        output_path.write_text(json.dumps(metrics.to_dict(), indent=2))
+        if verbose:
+            print(f"Metrics written to: {json_output}")
+
+    if output_video:
+        if verbose:
+            print(f"Generating debug video: {output_video}")
+
+        with CMJDebugOverlayRenderer(
+            output_video,
+            video_width,
+            video_height,
+            video_display_width,
+            video_display_height,
+            video_fps,
+        ) as renderer:
+            for i, frame in enumerate(frames):
+                annotated = renderer.render_frame(
+                    frame, smoothed_landmarks[i], i, metrics
+                )
+                renderer.write_frame(annotated)
+
+        if verbose:
+            print(f"Debug video saved: {output_video}")
+
+
 def process_cmj_video(
     video_path: str,
     quality: str = "balanced",
@@ -645,7 +689,6 @@ def process_cmj_video(
     json_output: str | None = None,
     smoothing_window: int | None = None,
     velocity_threshold: float | None = None,
-    countermovement_threshold: float | None = None,
     min_contact_frames: int | None = None,
     visibility_threshold: float | None = None,
     detection_confidence: float | None = None,
@@ -666,7 +709,6 @@ def process_cmj_video(
         json_output: Optional path for JSON metrics output
         smoothing_window: Optional override for smoothing window
         velocity_threshold: Optional override for velocity threshold
-        countermovement_threshold: Optional override for countermovement threshold
         min_contact_frames: Optional override for minimum contact frames
         visibility_threshold: Optional override for visibility threshold
         detection_confidence: Optional override for pose detection confidence
@@ -741,12 +783,6 @@ def process_cmj_video(
         vertical_positions, _ = _extract_vertical_positions(smoothed_landmarks)
         tracking_method = "foot"
 
-        # Calculate countermovement threshold (FPS-adjusted)
-        # POSITIVE threshold for downward motion (squatting) in normalized coordinates
-        cm_threshold = countermovement_threshold
-        if cm_threshold is None:
-            cm_threshold = 0.015 * (30.0 / video.fps)
-
         # Detect CMJ phases
         if verbose:
             print("Detecting CMJ phases...")
@@ -788,34 +824,19 @@ def process_cmj_video(
         )
 
         # Generate outputs if requested
-        if json_output:
-            import json
-
-            output_path = Path(json_output)
-            output_path.write_text(json.dumps(metrics.to_dict(), indent=2))
-            if verbose:
-                print(f"Metrics written to: {json_output}")
-
-        if output_video:
-            if verbose:
-                print(f"Generating debug video: {output_video}")
-
-            with CMJDebugOverlayRenderer(
-                output_video,
-                video.width,
-                video.height,
-                video.display_width,
-                video.display_height,
-                video.fps,
-            ) as renderer:
-                for i, frame in enumerate(frames):
-                    annotated = renderer.render_frame(
-                        frame, smoothed_landmarks[i], i, metrics
-                    )
-                    renderer.write_frame(annotated)
-
-            if verbose:
-                print(f"Debug video saved: {output_video}")
+        _generate_cmj_outputs(
+            output_video,
+            json_output,
+            metrics,
+            frames,
+            smoothed_landmarks,
+            video.width,
+            video.height,
+            video.display_width,
+            video.display_height,
+            video.fps,
+            verbose,
+        )
 
         if verbose:
             print(f"\nJump height: {metrics.jump_height:.3f}m")

{kinemotion-0.11.1 → kinemotion-0.11.3}/src/kinemotion/cmj/analysis.py

@@ -279,8 +279,6 @@ def find_cmj_takeoff_from_velocity_peak(
     velocities: np.ndarray,
     lowest_point_frame: int,
     fps: float,
-    window_length: int = 5,
-    polyorder: int = 2,
 ) -> float:
     """
     Find CMJ takeoff frame as peak upward velocity during concentric phase.
@@ -293,8 +291,6 @@ def find_cmj_takeoff_from_velocity_peak(
         velocities: Array of SIGNED vertical velocities (negative = upward)
         lowest_point_frame: Frame at lowest point
         fps: Video frame rate
-        window_length: Window size for derivative calculations
-        polyorder: Polynomial order for Savitzky-Golay filter
 
     Returns:
         Takeoff frame with fractional precision.
@@ -407,7 +403,7 @@ def find_interpolated_takeoff_landing(
 
     # Find takeoff using peak velocity method (CMJ-specific)
     takeoff_frame = find_cmj_takeoff_from_velocity_peak(
-        positions, velocities, lowest_point_frame, fps, window_length, polyorder
+        positions, velocities, lowest_point_frame, fps
     )
 
     # Find landing using position peak and impact detection

{kinemotion-0.11.1 → kinemotion-0.11.3}/src/kinemotion/cmj/cli.py

@@ -18,8 +18,12 @@ from ..core.auto_tuning import (
     analyze_video_sample,
     auto_tune_parameters,
 )
+from ..core.cli_utils import (
+    determine_initial_confidence,
+    smooth_landmark_sequence,
+    track_all_frames,
+)
 from ..core.pose import PoseTracker
-from ..core.smoothing import smooth_landmarks, smooth_landmarks_advanced
 from ..core.video_io import VideoProcessor
 from .analysis import detect_cmj_phases
 from .debug_overlay import CMJDebugOverlayRenderer
@@ -39,6 +43,64 @@ class AnalysisParameters:
     tracking_confidence: float | None = None
 
 
+def _collect_video_files(video_path: tuple[str, ...]) -> list[str]:
+    """Expand glob patterns and collect all video files."""
+    video_files: list[str] = []
+    for pattern in video_path:
+        expanded = glob.glob(pattern)
+        if expanded:
+            video_files.extend(expanded)
+        elif Path(pattern).exists():
+            video_files.append(pattern)
+        else:
+            click.echo(f"Warning: No files found for pattern: {pattern}", err=True)
+    return video_files
+
+
+def _generate_output_paths(
+    video: str, output_dir: str | None, json_output_dir: str | None
+) -> tuple[str | None, str | None]:
+    """Generate output paths for debug video and JSON."""
+    out_path = None
+    json_path = None
+    if output_dir:
+        out_path = str(Path(output_dir) / f"{Path(video).stem}_debug.mp4")
+    if json_output_dir:
+        json_path = str(Path(json_output_dir) / f"{Path(video).stem}.json")
+    return out_path, json_path
+
+
+def _process_batch_videos(
+    video_files: list[str],
+    output_dir: str | None,
+    json_output_dir: str | None,
+    quality_preset: QualityPreset,
+    verbose: bool,
+    expert_params: AnalysisParameters,
+    workers: int,
+) -> None:
+    """Process multiple videos in batch mode."""
+    click.echo(
+        f"Batch mode: Processing {len(video_files)} video(s) with {workers} workers",
+        err=True,
+    )
+    click.echo("Note: Batch processing not yet fully implemented", err=True)
+    click.echo("Processing videos sequentially...", err=True)
+
+    for video in video_files:
+        try:
+            click.echo(f"\nProcessing: {video}", err=True)
+            out_path, json_path = _generate_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
+
+
 @click.command(name="cmj-analyze")
 @click.argument("video_path", nargs=-1, type=click.Path(exists=False), required=True)
 @click.option(
@@ -189,15 +251,7 @@ def cmj_analyze(  # NOSONAR(S107) - Click CLI requires individual parameters for
         --json-output-dir results/ --csv-summary summary.csv
     """
     # Expand glob patterns and collect all video files
-    video_files: list[str] = []
-    for pattern in video_path:
-        expanded = glob.glob(pattern)
-        if expanded:
-            video_files.extend(expanded)
-        elif Path(pattern).exists():
-            video_files.append(pattern)
-        else:
-            click.echo(f"Warning: No files found for pattern: {pattern}", err=True)
+    video_files = _collect_video_files(video_path)
 
     if not video_files:
         click.echo("Error: No video files found", err=True)
@@ -220,27 +274,15 @@ def cmj_analyze(  # NOSONAR(S107) - Click CLI requires individual parameters for
     )
 
     if use_batch:
-        click.echo(
-            f"Batch mode: Processing {len(video_files)} video(s) with {workers} workers",
-            err=True,
+        _process_batch_videos(
+            video_files,
+            output_dir,
+            json_output_dir,
+            quality_preset,
+            verbose,
+            expert_params,
+            workers,
         )
-        click.echo("Note: Batch processing not yet fully implemented", err=True)
-        click.echo("Processing videos sequentially...", err=True)
-        for video in video_files:
-            try:
-                click.echo(f"\nProcessing: {video}", err=True)
-                out_path = None
-                json_path = None
-                if output_dir:
-                    out_path = str(Path(output_dir) / f"{Path(video).stem}_debug.mp4")
-                if json_output_dir:
-                    json_path = str(Path(json_output_dir) / f"{Path(video).stem}.json")
-                _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
     else:
         # Single video mode
         try:
@@ -257,53 +299,6 @@ def cmj_analyze(  # NOSONAR(S107) - Click CLI requires individual parameters for
             sys.exit(1)
 
 
-def _determine_initial_confidence(
-    quality_preset: QualityPreset,
-    expert_params: AnalysisParameters,
-) -> tuple[float, float]:
-    """Determine initial detection and tracking confidence levels."""
-    initial_detection_conf = 0.5
-    initial_tracking_conf = 0.5
-
-    if quality_preset == QualityPreset.FAST:
-        initial_detection_conf = 0.3
-        initial_tracking_conf = 0.3
-    elif quality_preset == QualityPreset.ACCURATE:
-        initial_detection_conf = 0.6
-        initial_tracking_conf = 0.6
-
-    # Override with expert values if provided
-    if expert_params.detection_confidence is not None:
-        initial_detection_conf = expert_params.detection_confidence
-    if expert_params.tracking_confidence is not None:
-        initial_tracking_conf = expert_params.tracking_confidence
-
-    return initial_detection_conf, initial_tracking_conf
-
-
-def _track_all_frames(video: VideoProcessor, tracker: PoseTracker) -> tuple[list, list]:
-    """Track pose landmarks in all video frames."""
-    click.echo("Tracking pose landmarks...", err=True)
-    landmarks_sequence = []
-    frames = []
-
-    bar: Any
-    with click.progressbar(length=video.frame_count, label="Processing frames") as bar:
-        while True:
-            frame = video.read_frame()
-            if frame is None:
-                break
-
-            frames.append(frame)
-            landmarks = tracker.process_frame(frame)
-            landmarks_sequence.append(landmarks)
-
-            bar.update(1)
-
-    tracker.close()
-    return frames, landmarks_sequence
-
-
 def _apply_expert_param_overrides(
     params: AutoTunedParams, expert_params: AnalysisParameters
 ) -> AutoTunedParams:
@@ -348,32 +343,20 @@ def _print_auto_tuned_params(
     click.echo("=" * 60 + "\n", err=True)
 
 
-def _smooth_landmark_sequence(
-    landmarks_sequence: list, params: AutoTunedParams
-) -> list:
-    """Apply smoothing to landmark sequence."""
-    if params.outlier_rejection or params.bilateral_filter:
-        if params.outlier_rejection:
-            click.echo("Smoothing landmarks with outlier rejection...", err=True)
-        if params.bilateral_filter:
-            click.echo(
-                "Using bilateral temporal filter for edge-preserving smoothing...",
-                err=True,
-            )
-        return smooth_landmarks_advanced(
-            landmarks_sequence,
-            window_length=params.smoothing_window,
-            polyorder=params.polyorder,
-            use_outlier_rejection=params.outlier_rejection,
-            use_bilateral=params.bilateral_filter,
-        )
-    else:
-        click.echo("Smoothing landmarks...", err=True)
-        return smooth_landmarks(
-            landmarks_sequence,
-            window_length=params.smoothing_window,
-            polyorder=params.polyorder,
-        )
+def _get_foot_position(frame_landmarks: dict | None, last_position: float) -> float:
+    """Extract average foot position from frame landmarks."""
+    if not frame_landmarks:
+        return last_position
+
+    # Average foot position (ankles and heels)
+    foot_y_values = []
+    for key in ["left_ankle", "right_ankle", "left_heel", "right_heel"]:
+        if key in frame_landmarks:
+            foot_y_values.append(frame_landmarks[key][1])
+
+    if foot_y_values:
+        return float(np.mean(foot_y_values))
+    return last_position
 
 
 def _extract_positions_from_landmarks(
@@ -391,20 +374,9 @@ def _extract_positions_from_landmarks(
     position_list: list[float] = []
 
     for frame_landmarks in smoothed_landmarks:
-        if frame_landmarks:
-            # Average foot position (ankles and heels)
-            foot_y_values = []
-            for key in ["left_ankle", "right_ankle", "left_heel", "right_heel"]:
-                if key in frame_landmarks:
-                    foot_y_values.append(frame_landmarks[key][1])
-
-            if foot_y_values:
-                avg_y = float(np.mean(foot_y_values))
-                position_list.append(avg_y)
-            else:
-                position_list.append(position_list[-1] if position_list else 0.5)
-        else:
-            position_list.append(position_list[-1] if position_list else 0.5)
+        last_pos = position_list[-1] if position_list else 0.5
+        position = _get_foot_position(frame_landmarks, last_pos)
+        position_list.append(position)
 
     return np.array(position_list), "foot"
 
@@ -427,7 +399,7 @@ def _process_single(
             )
 
             # Determine confidence levels
-            detection_conf, tracking_conf = _determine_initial_confidence(
+            detection_conf, tracking_conf = determine_initial_confidence(
                 quality_preset, expert_params
             )
 
@@ -436,7 +408,7 @@ def _process_single(
                 min_detection_confidence=detection_conf,
                 min_tracking_confidence=tracking_conf,
             )
-            frames, landmarks_sequence = _track_all_frames(video, tracker)
+            frames, landmarks_sequence = track_all_frames(video, tracker)
 
             if not landmarks_sequence:
                 click.echo("Error: No frames processed", err=True)
@@ -462,7 +434,7 @@ def _process_single(
                 )
 
             # Apply smoothing
-            smoothed_landmarks = _smooth_landmark_sequence(landmarks_sequence, params)
+            smoothed_landmarks = smooth_landmark_sequence(landmarks_sequence, params)
 
             # Extract foot positions
             vertical_positions, tracking_method = _extract_positions_from_landmarks(