kinemotion 0.11.1__py3-none-any.whl → 0.11.3__py3-none-any.whl

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/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/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(

kinemotion/cmj/debug_overlay.py

@@ -98,6 +98,76 @@ class CMJDebugOverlayRenderer:
         }
         return colors.get(phase, (128, 128, 128))
 
+    def _get_skeleton_segments(
+        self, side_prefix: str
+    ) -> list[tuple[str, str, tuple[int, int, int], int]]:
+        """Get skeleton segments for one side of the body."""
+        return [
+            (f"{side_prefix}heel", f"{side_prefix}ankle", (0, 255, 255), 3),  # Foot
+            (
+                f"{side_prefix}heel",
+                f"{side_prefix}foot_index",
+                (0, 255, 255),
+                2,
+            ),  # Alt foot
+            (f"{side_prefix}ankle", f"{side_prefix}knee", (255, 100, 100), 4),  # Shin
+            (f"{side_prefix}knee", f"{side_prefix}hip", (100, 255, 100), 4),  # Femur
+            (
+                f"{side_prefix}hip",
+                f"{side_prefix}shoulder",
+                (100, 100, 255),
+                4,
+            ),  # Trunk
+            (f"{side_prefix}shoulder", "nose", (150, 150, 255), 2),  # Neck
+        ]
+
+    def _draw_segment(
+        self,
+        frame: np.ndarray,
+        landmarks: dict[str, tuple[float, float, float]],
+        start_key: str,
+        end_key: str,
+        color: tuple[int, int, int],
+        thickness: int,
+    ) -> None:
+        """Draw a single skeleton segment if both endpoints are visible."""
+        if start_key not in landmarks or end_key not in landmarks:
+            return
+
+        start_vis = landmarks[start_key][2]
+        end_vis = landmarks[end_key][2]
+
+        # Very low threshold to show as much as possible
+        if start_vis > 0.2 and end_vis > 0.2:
+            start_x = int(landmarks[start_key][0] * self.width)
+            start_y = int(landmarks[start_key][1] * self.height)
+            end_x = int(landmarks[end_key][0] * self.width)
+            end_y = int(landmarks[end_key][1] * self.height)
+
+            cv2.line(frame, (start_x, start_y), (end_x, end_y), color, thickness)
+
+    def _draw_joints(
+        self,
+        frame: np.ndarray,
+        landmarks: dict[str, tuple[float, float, float]],
+        side_prefix: str,
+    ) -> None:
+        """Draw joint circles for one side of the body."""
+        joint_keys = [
+            f"{side_prefix}heel",
+            f"{side_prefix}foot_index",
+            f"{side_prefix}ankle",
+            f"{side_prefix}knee",
+            f"{side_prefix}hip",
+            f"{side_prefix}shoulder",
+        ]
+        for key in joint_keys:
+            if key in landmarks and landmarks[key][2] > 0.2:
+                jx = int(landmarks[key][0] * self.width)
+                jy = int(landmarks[key][1] * self.height)
+                cv2.circle(frame, (jx, jy), 6, (255, 255, 255), -1)
+                cv2.circle(frame, (jx, jy), 8, (0, 0, 0), 2)
+
     def _draw_skeleton(
         self, frame: np.ndarray, landmarks: dict[str, tuple[float, float, float]]
     ) -> None:
@@ -112,68 +182,16 @@ class CMJDebugOverlayRenderer:
         """
         # Try both sides and draw all visible segments
         for side_prefix in ["right_", "left_"]:
-            segments = [
-                (f"{side_prefix}heel", f"{side_prefix}ankle", (0, 255, 255), 3),  # Foot
-                (
-                    f"{side_prefix}heel",
-                    f"{side_prefix}foot_index",
-                    (0, 255, 255),
-                    2,
-                ),  # Alt foot
-                (
-                    f"{side_prefix}ankle",
-                    f"{side_prefix}knee",
-                    (255, 100, 100),
-                    4,
-                ),  # Shin
-                (
-                    f"{side_prefix}knee",
-                    f"{side_prefix}hip",
-                    (100, 255, 100),
-                    4,
-                ),  # Femur
-                (
-                    f"{side_prefix}hip",
-                    f"{side_prefix}shoulder",
-                    (100, 100, 255),
-                    4,
-                ),  # Trunk
-                # Additional segments for better visualization
-                (f"{side_prefix}shoulder", "nose", (150, 150, 255), 2),  # Neck
-            ]
+            segments = self._get_skeleton_segments(side_prefix)
 
             # Draw ALL visible segments (not just one side)
             for start_key, end_key, color, thickness in segments:
-                if start_key in landmarks and end_key in landmarks:
-                    start_vis = landmarks[start_key][2]
-                    end_vis = landmarks[end_key][2]
-
-                    # Very low threshold to show as much as possible
-                    if start_vis > 0.2 and end_vis > 0.2:
-                        start_x = int(landmarks[start_key][0] * self.width)
-                        start_y = int(landmarks[start_key][1] * self.height)
-                        end_x = int(landmarks[end_key][0] * self.width)
-                        end_y = int(landmarks[end_key][1] * self.height)
-
-                        cv2.line(
-                            frame, (start_x, start_y), (end_x, end_y), color, thickness
-                        )
+                self._draw_segment(
+                    frame, landmarks, start_key, end_key, color, thickness
+                )
 
             # Draw joints as circles for this side
-            joint_keys = [
-                f"{side_prefix}heel",
-                f"{side_prefix}foot_index",
-                f"{side_prefix}ankle",
-                f"{side_prefix}knee",
-                f"{side_prefix}hip",
-                f"{side_prefix}shoulder",
-            ]
-            for key in joint_keys:
-                if key in landmarks and landmarks[key][2] > 0.2:
-                    jx = int(landmarks[key][0] * self.width)
-                    jy = int(landmarks[key][1] * self.height)
-                    cv2.circle(frame, (jx, jy), 6, (255, 255, 255), -1)
-                    cv2.circle(frame, (jx, jy), 8, (0, 0, 0), 2)
+            self._draw_joints(frame, landmarks, side_prefix)
 
         # Always draw nose (head position) if visible
         if "nose" in landmarks and landmarks["nose"][2] > 0.2:
@@ -316,6 +334,126 @@ class CMJDebugOverlayRenderer:
         # Draw arc (simplified as a circle for now)
         cv2.circle(frame, (jx, jy), radius, arc_color, 2)
 
+    def _draw_foot_landmarks(
+        self,
+        frame: np.ndarray,
+        landmarks: dict[str, tuple[float, float, float]],
+        phase_color: tuple[int, int, int],
+    ) -> None:
+        """Draw foot landmarks and average position."""
+        foot_keys = ["left_ankle", "right_ankle", "left_heel", "right_heel"]
+        foot_positions = []
+
+        for key in foot_keys:
+            if key in landmarks:
+                x, y, vis = landmarks[key]
+                if vis > 0.5:
+                    lx = int(x * self.width)
+                    ly = int(y * self.height)
+                    foot_positions.append((lx, ly))
+                    cv2.circle(frame, (lx, ly), 5, (255, 255, 0), -1)
+
+        # Draw average foot position with phase color
+        if foot_positions:
+            avg_x = int(np.mean([p[0] for p in foot_positions]))
+            avg_y = int(np.mean([p[1] for p in foot_positions]))
+            cv2.circle(frame, (avg_x, avg_y), 12, phase_color, -1)
+            cv2.circle(frame, (avg_x, avg_y), 14, (255, 255, 255), 2)
+
+    def _draw_phase_banner(
+        self, frame: np.ndarray, phase: str | None, phase_color: tuple[int, int, int]
+    ) -> None:
+        """Draw phase indicator banner."""
+        if not phase:
+            return
+
+        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
+        )
+
+    def _draw_key_frame_markers(
+        self, frame: np.ndarray, frame_idx: int, metrics: CMJMetrics
+    ) -> None:
+        """Draw markers for key frames (standing start, lowest, takeoff, landing)."""
+        y_offset = 120
+        markers = []
+
+        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):
+            markers.append("LOWEST POINT")
+
+        if frame_idx == int(metrics.takeoff_frame):
+            markers.append("TAKEOFF")
+
+        if frame_idx == int(metrics.landing_frame):
+            markers.append("LANDING")
+
+        for marker in markers:
+            cv2.putText(
+                frame,
+                marker,
+                (10, y_offset),
+                cv2.FONT_HERSHEY_SIMPLEX,
+                0.7,
+                (255, 255, 0),
+                2,
+            )
+            y_offset += 35
+
+    def _draw_metrics_summary(
+        self, frame: np.ndarray, frame_idx: int, metrics: CMJMetrics
+    ) -> None:
+        """Draw metrics summary in bottom right (last 30 frames)."""
+        total_frames = int(metrics.landing_frame) + 30
+        if frame_idx < total_frames - 30:
+            return
+
+        metrics_text = [
+            f"Jump Height: {metrics.jump_height:.3f}m",
+            f"Flight Time: {metrics.flight_time*1000:.0f}ms",
+            f"CM Depth: {metrics.countermovement_depth:.3f}m",
+            f"Ecc Duration: {metrics.eccentric_duration*1000:.0f}ms",
+            f"Con Duration: {metrics.concentric_duration*1000:.0f}ms",
+        ]
+
+        # Draw background
+        box_height = len(metrics_text) * 30 + 20
+        cv2.rectangle(
+            frame,
+            (self.width - 320, self.height - box_height - 10),
+            (self.width - 10, self.height - 10),
+            (0, 0, 0),
+            -1,
+        )
+        cv2.rectangle(
+            frame,
+            (self.width - 320, self.height - box_height - 10),
+            (self.width - 10, self.height - 10),
+            (0, 255, 0),
+            2,
+        )
+
+        # Draw metrics text
+        text_y = self.height - box_height + 10
+        for text in metrics_text:
+            cv2.putText(
+                frame,
+                text,
+                (self.width - 310, text_y),
+                cv2.FONT_HERSHEY_SIMPLEX,
+                0.6,
+                (255, 255, 255),
+                1,
+            )
+            text_y += 30
+
     def render_frame(
         self,
         frame: np.ndarray,
@@ -346,47 +484,12 @@ class CMJDebugOverlayRenderer:
 
         # Draw skeleton and triple extension if landmarks available
         if landmarks:
-            # Draw skeleton segments for triple extension
             self._draw_skeleton(annotated, landmarks)
-
-            # Draw joint angles
             self._draw_joint_angles(annotated, landmarks, phase_color)
-
-            # Draw foot landmarks
-            foot_keys = ["left_ankle", "right_ankle", "left_heel", "right_heel"]
-            foot_positions = []
-
-            for key in foot_keys:
-                if key in landmarks:
-                    x, y, vis = landmarks[key]
-                    if vis > 0.5:
-                        lx = int(x * self.width)
-                        ly = int(y * self.height)
-                        foot_positions.append((lx, ly))
-                        cv2.circle(annotated, (lx, ly), 5, (255, 255, 0), -1)
-
-            # Draw average foot position with phase color
-            if foot_positions:
-                avg_x = int(np.mean([p[0] for p in foot_positions]))
-                avg_y = int(np.mean([p[1] for p in foot_positions]))
-                cv2.circle(annotated, (avg_x, avg_y), 12, phase_color, -1)
-                cv2.circle(annotated, (avg_x, avg_y), 14, (255, 255, 255), 2)
+            self._draw_foot_landmarks(annotated, landmarks, phase_color)
 
         # Draw phase indicator banner
-        if phase:
-            # Phase name with background
-            phase_text = f"Phase: {phase.upper()}"
-            text_size = cv2.getTextSize(phase_text, cv2.FONT_HERSHEY_SIMPLEX, 1, 2)[0]
-            cv2.rectangle(annotated, (5, 5), (text_size[0] + 15, 45), phase_color, -1)
-            cv2.putText(
-                annotated,
-                phase_text,
-                (10, 35),
-                cv2.FONT_HERSHEY_SIMPLEX,
-                1,
-                (0, 0, 0),
-                2,
-            )
+        self._draw_phase_banner(annotated, phase, phase_color)
 
         # Draw frame number
         cv2.putText(
@@ -399,78 +502,10 @@ class CMJDebugOverlayRenderer:
             2,
         )
 
-        # Draw key frame markers
+        # Draw key frame markers and metrics summary
         if metrics:
-            y_offset = 120
-            markers = []
-
-            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):
-                markers.append("LOWEST POINT")
-
-            if frame_idx == int(metrics.takeoff_frame):
-                markers.append("TAKEOFF")
-
-            if frame_idx == int(metrics.landing_frame):
-                markers.append("LANDING")
-
-            for marker in markers:
-                cv2.putText(
-                    annotated,
-                    marker,
-                    (10, y_offset),
-                    cv2.FONT_HERSHEY_SIMPLEX,
-                    0.7,
-                    (255, 255, 0),
-                    2,
-                )
-                y_offset += 35
-
-            # Draw metrics summary in bottom right (last 30 frames)
-            total_frames = int(metrics.landing_frame) + 30
-            if frame_idx >= total_frames - 30:
-                metrics_text = [
-                    f"Jump Height: {metrics.jump_height:.3f}m",
-                    f"Flight Time: {metrics.flight_time*1000:.0f}ms",
-                    f"CM Depth: {metrics.countermovement_depth:.3f}m",
-                    f"Ecc Duration: {metrics.eccentric_duration*1000:.0f}ms",
-                    f"Con Duration: {metrics.concentric_duration*1000:.0f}ms",
-                ]
-
-                # Draw background
-                box_height = len(metrics_text) * 30 + 20
-                cv2.rectangle(
-                    annotated,
-                    (self.width - 320, self.height - box_height - 10),
-                    (self.width - 10, self.height - 10),
-                    (0, 0, 0),
-                    -1,
-                )
-                cv2.rectangle(
-                    annotated,
-                    (self.width - 320, self.height - box_height - 10),
-                    (self.width - 10, self.height - 10),
-                    (0, 255, 0),
-                    2,
-                )
-
-                # Draw metrics text
-                text_y = self.height - box_height + 10
-                for text in metrics_text:
-                    cv2.putText(
-                        annotated,
-                        text,
-                        (self.width - 310, text_y),
-                        cv2.FONT_HERSHEY_SIMPLEX,
-                        0.6,
-                        (255, 255, 255),
-                        1,
-                    )
-                    text_y += 30
+            self._draw_key_frame_markers(annotated, frame_idx, metrics)
+            self._draw_metrics_summary(annotated, frame_idx, metrics)
 
         return annotated
 

kinemotion/core/cli_utils.py

@@ -0,0 +1,113 @@
+"""Shared CLI utilities for drop jump and CMJ analysis."""
+
+from typing import Any, Protocol
+
+import click
+
+from .auto_tuning import AutoTunedParams, QualityPreset
+from .pose import PoseTracker
+from .smoothing import smooth_landmarks, smooth_landmarks_advanced
+from .video_io import VideoProcessor
+
+
+class ExpertParameters(Protocol):
+    """Protocol for expert parameter overrides."""
+
+    detection_confidence: float | None
+    tracking_confidence: float | None
+
+
+def determine_initial_confidence(
+    quality_preset: QualityPreset,
+    expert_params: ExpertParameters,
+) -> tuple[float, float]:
+    """Determine initial detection and tracking confidence levels.
+
+    Args:
+        quality_preset: Quality preset enum
+        expert_params: Expert parameter overrides
+
+    Returns:
+        Tuple of (detection_confidence, tracking_confidence)
+    """
+    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.
+
+    Args:
+        video: Video processor
+        tracker: Pose tracker
+
+    Returns:
+        Tuple of (frames, landmarks_sequence)
+    """
+    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 smooth_landmark_sequence(landmarks_sequence: list, params: AutoTunedParams) -> list:
+    """Apply smoothing to landmark sequence.
+
+    Args:
+        landmarks_sequence: Raw landmark sequence
+        params: Auto-tuned parameters
+
+    Returns:
+        Smoothed 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,
+        )

kinemotion/dropjump/cli.py

@@ -21,8 +21,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 (
     ContactState,
@@ -256,69 +260,6 @@ def dropjump_analyze(  # NOSONAR(S107) - Click CLI requires individual parameter
         )
 
 
-def _determine_initial_confidence(
-    quality_preset: QualityPreset,
-    expert_params: AnalysisParameters,
-) -> tuple[float, float]:
-    """Determine initial detection and tracking confidence levels.
-
-    Args:
-        quality_preset: Quality preset enum
-        expert_params: Expert parameter overrides
-
-    Returns:
-        Tuple of (detection_confidence, tracking_confidence)
-    """
-    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.
-
-    Args:
-        video: Video processor
-        tracker: Pose tracker
-
-    Returns:
-        Tuple of (frames, landmarks_sequence)
-    """
-    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:
@@ -380,42 +321,6 @@ 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.
-
-    Args:
-        landmarks_sequence: Raw landmark sequence
-        params: Auto-tuned parameters
-
-    Returns:
-        Smoothed landmarks
-    """
-    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 _extract_positions_and_visibilities(
     smoothed_landmarks: list,
 ) -> tuple[np.ndarray, np.ndarray]:
@@ -533,7 +438,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
             )
 
@@ -542,7 +447,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)
@@ -560,7 +465,7 @@ def _process_single(
                 _print_auto_tuned_params(video, characteristics, quality_preset, params)
 
             # Apply smoothing
-            smoothed_landmarks = _smooth_landmark_sequence(landmarks_sequence, params)
+            smoothed_landmarks = smooth_landmark_sequence(landmarks_sequence, params)
 
             # Extract positions
             vertical_positions, visibilities = _extract_positions_and_visibilities(

{kinemotion-0.11.1.dist-info → kinemotion-0.11.3.dist-info}/METADATA

@@ -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.dist-info → kinemotion-0.11.3.dist-info}/RECORD

@@ -1,26 +1,27 @@
 kinemotion/__init__.py,sha256=REBC9wrwYC_grvCS00qEOyign65Zc1sc-5buLpyqQxA,654
-kinemotion/api.py,sha256=mbI57PFvRK7iNU3p4PNdweuHCCU0HP9nLeUk9fx-b2g,31390
+kinemotion/api.py,sha256=10Rj_dqAa6KCcmCjlGEtQFZLoNyqeMzFLo7vGZcttWY,31586
 kinemotion/cli.py,sha256=cqYV_7URH0JUDy1VQ_EDLv63FmNO4Ns20m6s1XAjiP4,464
 kinemotion/cmj/__init__.py,sha256=Ynv0-Oco4I3Y1Ubj25m3h9h2XFqeNwpAewXmAYOmwfU,127
-kinemotion/cmj/analysis.py,sha256=ciH5f5SC1IJjG0j8nkyZRu7QYR-Al6bWCBIfOW4Q1xQ,18466
-kinemotion/cmj/cli.py,sha256=HUXat4xecCZ7JOiyo4zfcOk5xJLFpUn5ZaTDVAJL6qo,20565
-kinemotion/cmj/debug_overlay.py,sha256=TVDrZ16TJClftM_zhkrCzBLMs87SfYDa8H-eqfzQJ4c,17976
+kinemotion/cmj/analysis.py,sha256=4HYGn4VDIB6oExAees-VcPfpNgWOltpgwjyNTU7YAb4,18263
+kinemotion/cmj/cli.py,sha256=lVVlh8teFHXbDzaFdDfq3xSwRf4kVwyYyd6FU8ta_Ec,19044
+kinemotion/cmj/debug_overlay.py,sha256=ELrSYQ9LmLV81bJS5w9i2c4VwRS0EYAUnMehMHU7VGc,18724
 kinemotion/cmj/joint_angles.py,sha256=8ucpDGPvbt4iX3tx9eVxJEUv0laTm2Y58_--VzJCogE,9113
 kinemotion/cmj/kinematics.py,sha256=Xl_PlC2OqMoA-zOc3SRB_GqI0AgLlJol5FTPe5J_qLc,7573
 kinemotion/core/__init__.py,sha256=3yzDhb5PekDNjydqrs8aWGneUGJBt-lB0SoB_Y2FXqU,1010
 kinemotion/core/auto_tuning.py,sha256=cvmxUI-CbahpOJQtR2r5jOx4Q6yKPe3DO1o15hOQIdw,10508
+kinemotion/core/cli_utils.py,sha256=hNf2-_LIbi-ntXAkovjqcuWifYLazikqJBzeTN9YmZc,3492
 kinemotion/core/filtering.py,sha256=f-m-aA59e4WqE6u-9MA51wssu7rI-Y_7n1cG8IWdeRQ,11241
 kinemotion/core/pose.py,sha256=Wfd1RR-2ZznYpWeQUbySwcV3mvReqn8n3XO6S7pGq4M,8390
 kinemotion/core/smoothing.py,sha256=FON4qKtsSp1-03GnJrDkEUAePaACn4QPMJF0eTIYqR0,12925
 kinemotion/core/video_io.py,sha256=z8Z0qbNaKbcdB40KnbNOBMzab3BbgnhBxp-mUBYeXgM,6577
 kinemotion/dropjump/__init__.py,sha256=yc1XiZ9vfo5h_n7PKVSiX2TTgaIfGL7Y7SkQtiDZj_E,838
 kinemotion/dropjump/analysis.py,sha256=HfJt2t9IsMBiBUz7apIzdxbRH9QqzlFnDVVWcKhU3ow,23291
-kinemotion/dropjump/cli.py,sha256=zo23qoYSpC_2BcScy-JOilcGcWGM0j3Xv0lpO0_n0wk,27975
+kinemotion/dropjump/cli.py,sha256=eXO-9H9z0g-EJUD1uIT37KIMgfyje4fPAO2FgZiEZzk,24985
 kinemotion/dropjump/debug_overlay.py,sha256=GMo-jCl5OPIv82uPxDbBVI7CsAMwATTvxZMeWfs8k8M,8701
 kinemotion/dropjump/kinematics.py,sha256=RM_O8Kdc6aEiPIu_99N4cu-4EhYSQxtBGASJF_dmQaU,19081
 kinemotion/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kinemotion-0.11.1.dist-info/METADATA,sha256=XRgrT5bV--WLFpW-pDbZAQpo0N5RekTUvtFMntKcQoA,18990
-kinemotion-0.11.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-kinemotion-0.11.1.dist-info/entry_points.txt,sha256=zaqnAnjLvcdrk1Qvj5nvXZCZ2gp0prS7it1zTJygcIY,50
-kinemotion-0.11.1.dist-info/licenses/LICENSE,sha256=KZajvqsHw0NoOHOi2q0FZ4NBe9HdV6oey-IPYAtHXfg,1088
-kinemotion-0.11.1.dist-info/RECORD,,
+kinemotion-0.11.3.dist-info/METADATA,sha256=Yu4EP1FzusXr0Y0KRNIfywzuw0nNYeACUojxFhzrDuE,18990
+kinemotion-0.11.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+kinemotion-0.11.3.dist-info/entry_points.txt,sha256=zaqnAnjLvcdrk1Qvj5nvXZCZ2gp0prS7it1zTJygcIY,50
+kinemotion-0.11.3.dist-info/licenses/LICENSE,sha256=KZajvqsHw0NoOHOi2q0FZ4NBe9HdV6oey-IPYAtHXfg,1088
+kinemotion-0.11.3.dist-info/RECORD,,