kinemotion 0.11.0__py3-none-any.whl → 0.11.2__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",
@@ -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/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/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,
             )

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-0.11.0.dist-info → kinemotion-0.11.2.dist-info}/METADATA

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

@@ -1,10 +1,10 @@
 kinemotion/__init__.py,sha256=REBC9wrwYC_grvCS00qEOyign65Zc1sc-5buLpyqQxA,654
-kinemotion/api.py,sha256=HYd8OnCZ9eJq7wn38dFVta5llTjqB9P0wKEwXPAXu6M,31666
+kinemotion/api.py,sha256=Cm3DXuNcInecJ2BoRMYBLRUk1ImDSn3ZP82H31TU4Gw,31721
 kinemotion/cli.py,sha256=cqYV_7URH0JUDy1VQ_EDLv63FmNO4Ns20m6s1XAjiP4,464
 kinemotion/cmj/__init__.py,sha256=Ynv0-Oco4I3Y1Ubj25m3h9h2XFqeNwpAewXmAYOmwfU,127
-kinemotion/cmj/analysis.py,sha256=uzUouxeCE3H5dad_AQ8PhtpgVC8DfPE32AMDqihD82o,19887
-kinemotion/cmj/cli.py,sha256=kyPJpxvLZGfzdqv4FGzQVNmR2uUSOg3a6_I0d1VszVw,20874
-kinemotion/cmj/debug_overlay.py,sha256=TVDrZ16TJClftM_zhkrCzBLMs87SfYDa8H-eqfzQJ4c,17976
+kinemotion/cmj/analysis.py,sha256=4HYGn4VDIB6oExAees-VcPfpNgWOltpgwjyNTU7YAb4,18263
+kinemotion/cmj/cli.py,sha256=XcLlBPVyBWffI_UTQZN7wxlnm971LL9-ynkBoL3T37I,21567
+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
@@ -19,8 +19,8 @@ kinemotion/dropjump/cli.py,sha256=zo23qoYSpC_2BcScy-JOilcGcWGM0j3Xv0lpO0_n0wk,27
 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.0.dist-info/METADATA,sha256=JaV-num_wEFgMB_tl3sxOJmUGl0FddtS5bkfQmGH3Gc,18990
-kinemotion-0.11.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-kinemotion-0.11.0.dist-info/entry_points.txt,sha256=zaqnAnjLvcdrk1Qvj5nvXZCZ2gp0prS7it1zTJygcIY,50
-kinemotion-0.11.0.dist-info/licenses/LICENSE,sha256=KZajvqsHw0NoOHOi2q0FZ4NBe9HdV6oey-IPYAtHXfg,1088
-kinemotion-0.11.0.dist-info/RECORD,,
+kinemotion-0.11.2.dist-info/METADATA,sha256=DrLLms6trTMJYlfaibiR0y49jDd7D-zuYQTblJTq44Q,18990
+kinemotion-0.11.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+kinemotion-0.11.2.dist-info/entry_points.txt,sha256=zaqnAnjLvcdrk1Qvj5nvXZCZ2gp0prS7it1zTJygcIY,50
+kinemotion-0.11.2.dist-info/licenses/LICENSE,sha256=KZajvqsHw0NoOHOi2q0FZ4NBe9HdV6oey-IPYAtHXfg,1088
+kinemotion-0.11.2.dist-info/RECORD,,