kinemotion 0.11.0__tar.gz → 0.11.2__tar.gz

{kinemotion-0.11.0 → kinemotion-0.11.2}/CHANGELOG.md

@@ -7,6 +7,31 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 <!-- version list -->
 
+## 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
+
+- **cmj**: Remove unused parameters and fix code quality issues
+  ([`72a1e43`](https://github.com/feniix/kinemotion/commit/72a1e43ec107e5b1c132efb10a08a09ea2864ae4))
+
+
 ## v0.11.0 (2025-11-06)
 
 ### Documentation

{kinemotion-0.11.0 → kinemotion-0.11.2}/PKG-INFO

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

{kinemotion-0.11.0 → kinemotion-0.11.2}/pyproject.toml

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

{kinemotion-0.11.0 → kinemotion-0.11.2}/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",
@@ -741,12 +785,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...")
@@ -754,11 +792,6 @@ def process_cmj_video(
         phases = detect_cmj_phases(
             vertical_positions,
             video.fps,
-            velocity_threshold=params.velocity_threshold,
-            countermovement_threshold=cm_threshold,
-            min_contact_frames=params.min_contact_frames,
-            min_eccentric_frames=params.min_contact_frames,
-            use_curvature=params.use_curvature,
             window_length=params.smoothing_window,
             polyorder=params.polyorder,
         )
@@ -793,34 +826,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.0 → kinemotion-0.11.2}/src/kinemotion/cmj/analysis.py

@@ -102,7 +102,6 @@ def find_standing_phase(
 
 def find_countermovement_start(
     velocities: np.ndarray,
-    fps: float,
     countermovement_threshold: float = 0.015,
     min_eccentric_frames: int = 3,
     standing_start: int | None = None,
@@ -114,7 +113,6 @@ def find_countermovement_start(
 
     Args:
         velocities: Array of SIGNED vertical velocities
-        fps: Video frame rate
         countermovement_threshold: Velocity threshold for detecting downward motion (POSITIVE)
         min_eccentric_frames: Minimum consecutive frames of downward motion
         standing_start: Optional frame where standing phase ended
@@ -143,7 +141,6 @@ def find_countermovement_start(
 def find_lowest_point(
     positions: np.ndarray,
     velocities: np.ndarray,
-    eccentric_start: int | None = None,
     min_search_frame: int = 80,
 ) -> int:
     """
@@ -155,7 +152,6 @@ def find_lowest_point(
     Args:
         positions: Array of vertical positions (higher value = lower in video)
         velocities: Array of SIGNED vertical velocities (positive=down, negative=up)
-        eccentric_start: Optional frame where eccentric phase started
         min_search_frame: Minimum frame to start searching (default: frame 80)
 
     Returns:
@@ -283,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.
@@ -297,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.
@@ -381,9 +373,6 @@ def find_interpolated_takeoff_landing(
     positions: np.ndarray,
     velocities: np.ndarray,
     lowest_point_frame: int,
-    velocity_threshold: float = 0.02,
-    min_flight_frames: int = 3,
-    use_curvature: bool = True,
     window_length: int = 5,
     polyorder: int = 2,
 ) -> tuple[float, float] | None:
@@ -397,9 +386,6 @@ def find_interpolated_takeoff_landing(
         positions: Array of vertical positions
         velocities: Array of vertical velocities
         lowest_point_frame: Frame at lowest point
-        velocity_threshold: Velocity threshold (unused for CMJ, kept for API compatibility)
-        min_flight_frames: Minimum consecutive frames for valid flight phase
-        use_curvature: Whether to use trajectory curvature refinement
         window_length: Window size for derivative calculations
         polyorder: Polynomial order for Savitzky-Golay filter
 
@@ -417,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
@@ -428,14 +414,76 @@ def find_interpolated_takeoff_landing(
     return (takeoff_frame, landing_frame)
 
 
+def _find_takeoff_frame(
+    velocities: np.ndarray, peak_height_frame: int, fps: float
+) -> float:
+    """Find takeoff frame as peak upward velocity before peak height."""
+    takeoff_search_start = max(0, peak_height_frame - int(fps * 0.35))
+    takeoff_search_end = peak_height_frame - 2
+
+    takeoff_velocities = velocities[takeoff_search_start:takeoff_search_end]
+
+    if len(takeoff_velocities) > 0:
+        peak_vel_idx = int(np.argmin(takeoff_velocities))
+        return float(takeoff_search_start + peak_vel_idx)
+    else:
+        return float(peak_height_frame - int(fps * 0.3))
+
+
+def _find_lowest_frame(
+    velocities: np.ndarray, positions: np.ndarray, takeoff_frame: float, fps: float
+) -> float:
+    """Find lowest point frame before takeoff."""
+    lowest_search_start = max(0, int(takeoff_frame) - int(fps * 0.4))
+    lowest_search_end = int(takeoff_frame)
+
+    # Find where velocity crosses from positive to negative
+    for i in range(lowest_search_end - 1, lowest_search_start, -1):
+        if i > 0 and velocities[i] < 0 and velocities[i - 1] >= 0:
+            return float(i)
+
+    # Fallback: use maximum position
+    lowest_positions = positions[lowest_search_start:lowest_search_end]
+    if len(lowest_positions) > 0:
+        lowest_idx = int(np.argmax(lowest_positions))
+        return float(lowest_search_start + lowest_idx)
+    else:
+        return float(int(takeoff_frame) - int(fps * 0.2))
+
+
+def _find_landing_frame(
+    accelerations: np.ndarray, peak_height_frame: int, fps: float
+) -> float:
+    """Find landing frame after peak height."""
+    landing_search_start = peak_height_frame
+    landing_search_end = min(len(accelerations), peak_height_frame + int(fps * 0.5))
+    landing_accelerations = accelerations[landing_search_start:landing_search_end]
+
+    if len(landing_accelerations) > 0:
+        landing_idx = int(np.argmin(landing_accelerations))
+        return float(landing_search_start + landing_idx)
+    else:
+        return float(peak_height_frame + int(fps * 0.3))
+
+
+def _find_standing_end(velocities: np.ndarray, lowest_point: float) -> float | None:
+    """Find end of standing phase before lowest point."""
+    if lowest_point <= 20:
+        return None
+
+    standing_search = velocities[: int(lowest_point)]
+    low_vel = np.abs(standing_search) < 0.005
+    if np.any(low_vel):
+        standing_frames = np.nonzero(low_vel)[0]
+        if len(standing_frames) > 10:
+            return float(standing_frames[-1])
+
+    return None
+
+
 def detect_cmj_phases(
     positions: np.ndarray,
     fps: float,
-    velocity_threshold: float = 0.02,
-    countermovement_threshold: float = -0.015,
-    min_contact_frames: int = 3,
-    min_eccentric_frames: int = 3,
-    use_curvature: bool = True,
     window_length: int = 5,
     polyorder: int = 2,
 ) -> tuple[float | None, float, float, float] | None:
@@ -451,11 +499,6 @@ def detect_cmj_phases(
     Args:
         positions: Array of vertical positions (normalized 0-1)
         fps: Video frame rate
-        velocity_threshold: Velocity threshold (not used)
-        countermovement_threshold: Velocity threshold (not used)
-        min_contact_frames: Minimum frames for ground contact
-        min_eccentric_frames: Minimum frames for eccentric phase
-        use_curvature: Whether to use trajectory curvature refinement
         window_length: Window size for derivative calculations
         polyorder: Polynomial order for Savitzky-Golay filter
 
@@ -473,76 +516,13 @@ def detect_cmj_phases(
 
     # Step 1: Find peak height (global minimum y = highest point in frame)
     peak_height_frame = int(np.argmin(positions))
-
     if peak_height_frame < 10:
         return None  # Peak too early, invalid
 
-    # Step 2: Find takeoff as peak upward velocity
-    # Takeoff occurs at maximum upward velocity (most negative) before peak height
-    # Typical: 0.3 seconds before peak (9 frames at 30fps)
-    takeoff_search_start = max(0, peak_height_frame - int(fps * 0.35))
-    takeoff_search_end = peak_height_frame - 2  # Must be at least 2 frames before peak
-
-    takeoff_velocities = velocities[takeoff_search_start:takeoff_search_end]
-
-    if len(takeoff_velocities) > 0:
-        # Takeoff = peak upward velocity (most negative)
-        peak_vel_idx = int(np.argmin(takeoff_velocities))
-        takeoff_frame = float(takeoff_search_start + peak_vel_idx)
-    else:
-        # Fallback
-        takeoff_frame = float(peak_height_frame - int(fps * 0.3))
-
-    # Step 3: Find lowest point (countermovement bottom) before takeoff
-    # This is where velocity crosses from positive (squatting) to negative (jumping)
-    # Search backward from takeoff for where velocity was last positive/zero
-    lowest_search_start = max(0, int(takeoff_frame) - int(fps * 0.4))
-    lowest_search_end = int(takeoff_frame)
-
-    # Find where velocity crosses from positive to negative (transition point)
-    lowest_frame_found = None
-    for i in range(lowest_search_end - 1, lowest_search_start, -1):
-        if i > 0:
-            # Look for velocity crossing from positive/zero to negative
-            if velocities[i] < 0 and velocities[i - 1] >= 0:
-                lowest_frame_found = float(i)
-                break
-
-    # Fallback: use maximum position (lowest point in frame) if no velocity crossing
-    if lowest_frame_found is None:
-        lowest_positions = positions[lowest_search_start:lowest_search_end]
-        if len(lowest_positions) > 0:
-            lowest_idx = int(np.argmax(lowest_positions))
-            lowest_point = float(lowest_search_start + lowest_idx)
-        else:
-            lowest_point = float(int(takeoff_frame) - int(fps * 0.2))
-    else:
-        lowest_point = lowest_frame_found
-
-    # Step 4: Find landing (impact after peak height)
-    # Landing shows as large negative acceleration spike (impact deceleration)
-    landing_search_start = peak_height_frame
-    landing_search_end = min(len(accelerations), peak_height_frame + int(fps * 0.5))
-    landing_accelerations = accelerations[landing_search_start:landing_search_end]
-
-    if len(landing_accelerations) > 0:
-        # Find most negative acceleration (maximum impact deceleration)
-        # Landing acceleration should be around -0.008 to -0.010
-        landing_idx = int(np.argmin(landing_accelerations))  # Most negative = impact
-        landing_frame = float(landing_search_start + landing_idx)
-    else:
-        landing_frame = float(peak_height_frame + int(fps * 0.3))
-
-    # Optional: Find standing phase (not critical)
-    standing_end = None
-    if lowest_point > 20:
-        # Look for low-velocity period before lowest point
-        standing_search = velocities[: int(lowest_point)]
-        low_vel = np.abs(standing_search) < 0.005
-        if np.any(low_vel):
-            # Find last low-velocity frame before countermovement
-            standing_frames = np.where(low_vel)[0]
-            if len(standing_frames) > 10:
-                standing_end = float(standing_frames[-1])
+    # Step 2-4: Find all phases using helper functions
+    takeoff_frame = _find_takeoff_frame(velocities, peak_height_frame, fps)
+    lowest_point = _find_lowest_frame(velocities, positions, takeoff_frame, fps)
+    landing_frame = _find_landing_frame(accelerations, peak_height_frame, fps)
+    standing_end = _find_standing_end(velocities, lowest_point)
 
     return (standing_end, lowest_point, takeoff_frame, landing_frame)

{kinemotion-0.11.0 → kinemotion-0.11.2}/src/kinemotion/cmj/cli.py

@@ -39,6 +39,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 +247,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 +270,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:
@@ -376,6 +414,22 @@ def _smooth_landmark_sequence(
         )
 
 
+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(
     smoothed_landmarks: list,
 ) -> tuple[np.ndarray, str]:
@@ -391,20 +445,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"
 
@@ -474,11 +517,6 @@ def _process_single(
             phases = detect_cmj_phases(
                 vertical_positions,
                 video.fps,
-                velocity_threshold=params.velocity_threshold,
-                countermovement_threshold=countermovement_threshold,
-                min_contact_frames=params.min_contact_frames,
-                min_eccentric_frames=params.min_contact_frames,
-                use_curvature=params.use_curvature,
                 window_length=params.smoothing_window,
                 polyorder=params.polyorder,
             )