kinemotion 0.76.3__py3-none-any.whl → 1.0.0__py3-none-any.whl

kinemotion/squat_jump/cli.py

@@ -1,309 +0,0 @@
-"""Command-line interface for squat jump (SJ) analysis."""
-
-import json
-import sys
-from dataclasses import dataclass
-
-import click
-
-from ..core.auto_tuning import QualityPreset
-from ..core.cli_utils import (
-    batch_processing_options,
-    collect_video_files,
-    common_output_options,
-    generate_batch_output_paths,
-    quality_option,
-    verbose_option,
-)
-from .api import AnalysisOverrides, process_sj_video
-from .kinematics import SJMetrics
-
-
-@dataclass
-class AnalysisParameters:
-    """Expert parameters for SJ analysis customization."""
-
-    smoothing_window: int | None = None
-    velocity_threshold: float | None = None
-    squat_hold_threshold: float | None = None
-    min_contact_frames: int | None = None
-    visibility_threshold: float | None = None
-    detection_confidence: float | None = None
-    tracking_confidence: float | None = None
-    mass_kg: float | None = None  # For power calculations
-
-
-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_batch_output_paths(video, output_dir, json_output_dir)
-            _process_single(video, out_path, json_path, quality_preset, verbose, expert_params)
-        except Exception as e:
-            click.echo(f"Error processing {video}: {e}", err=True)
-            continue
-
-
-@click.command(name="sj-analyze")
-@click.argument("video_path", nargs=-1, type=click.Path(exists=False), required=True)
-@common_output_options
-@quality_option
-@verbose_option
-@batch_processing_options
-@click.option(
-    "--mass",
-    type=float,
-    required=True,
-    help="Athlete mass in kilograms (required for power calculations)",
-)
-# Expert parameters (hidden in help, but always available for advanced users)
-@click.option(
-    "--smoothing-window",
-    type=int,
-    default=None,
-    help="[EXPERT] Override auto-tuned smoothing window size",
-)
-@click.option(
-    "--velocity-threshold",
-    type=float,
-    default=None,
-    help="[EXPERT] Override auto-tuned velocity threshold for flight detection",
-)
-@click.option(
-    "--squat-hold-threshold",
-    type=float,
-    default=None,
-    help="[EXPERT] Override auto-tuned squat hold threshold",
-)
-@click.option(
-    "--min-contact-frames",
-    type=int,
-    default=None,
-    help="[EXPERT] Override auto-tuned minimum contact frames",
-)
-@click.option(
-    "--visibility-threshold",
-    type=float,
-    default=None,
-    help="[EXPERT] Override visibility threshold",
-)
-@click.option(
-    "--detection-confidence",
-    type=float,
-    default=None,
-    help="[EXPERT] Override pose detection confidence",
-)
-@click.option(
-    "--tracking-confidence",
-    type=float,
-    default=None,
-    help="[EXPERT] Override pose tracking confidence",
-)
-def sj_analyze(  # NOSONAR(S107) - Click CLI requires individual parameters
-    # for each option
-    video_path: tuple[str, ...],
-    output: str | None,
-    json_output: str | None,
-    quality: str,
-    verbose: bool,
-    batch: bool,
-    workers: int,
-    output_dir: str | None,
-    json_output_dir: str | None,
-    csv_summary: str | None,
-    mass: float,
-    smoothing_window: int | None,
-    velocity_threshold: float | None,
-    squat_hold_threshold: float | None,
-    min_contact_frames: int | None,
-    visibility_threshold: float | None,
-    detection_confidence: float | None,
-    tracking_confidence: float | None,
-) -> None:
-    """
-    Analyze squat jump (SJ) video(s) to estimate jump performance metrics.
-
-    ⚠️ EXPERIMENTAL: Squat Jump analysis is new and awaiting validation studies.
-    Power/force calculations use validated Sayers regression but SJ-specific
-    phase detection may need refinement based on real-world data.
-
-    Squat Jump starts from a static squat position and focuses on explosive
-    upward movement without countermovement. Power calculations require
-    athlete mass for force and power metrics.
-
-    Uses intelligent auto-tuning to select optimal parameters based on video
-    characteristics. Parameters are automatically adjusted for frame rate,
-    tracking quality, and analysis preset.
-
-    VIDEO_PATH: Path(s) to video file(s). Supports glob patterns in batch mode.
-
-    Examples:
-
-    \b
-    # Basic analysis
-    kinemotion sj-analyze video.mp4 --mass 75.0
-
-    \b
-    # With debug video output
-    kinemotion sj-analyze video.mp4 --mass 75.0 --output debug.mp4
-
-    \b
-    # Batch mode with glob pattern
-    kinemotion sj-analyze videos/*.mp4 --batch --workers 4 --mass 75.0
-
-    \b
-    # Batch with output directories
-    kinemotion sj-analyze videos/*.mp4 --batch --mass 75.0 \\
-        --json-output-dir results/ --csv-summary summary.csv
-    """
-    # Warn user that SJ is experimental
-    click.echo(
-        "⚠️  WARNING: Squat Jump analysis is experimental (since v0.74.0)",
-        err=True,
-    )
-    click.echo(
-        "   Power/force calculations use validated Sayers regression, but",
-        err=True,
-    )
-    click.echo(
-        "   SJ-specific phase detection may need refinement based on real-world data.",
-        err=True,
-    )
-    click.echo(err=True)
-    # Expand glob patterns and collect all video files
-    video_files = collect_video_files(video_path)
-
-    if not video_files:
-        click.echo("Error: No video files found", err=True)
-        sys.exit(1)
-
-    # Determine if batch mode should be used
-    use_batch = batch or len(video_files) > 1
-
-    quality_preset = QualityPreset(quality.lower())
-
-    # Group expert parameters
-    expert_params = AnalysisParameters(
-        smoothing_window=smoothing_window,
-        velocity_threshold=velocity_threshold,
-        squat_hold_threshold=squat_hold_threshold,
-        min_contact_frames=min_contact_frames,
-        visibility_threshold=visibility_threshold,
-        detection_confidence=detection_confidence,
-        tracking_confidence=tracking_confidence,
-        mass_kg=mass,
-    )
-
-    if use_batch:
-        _process_batch_videos(
-            video_files,
-            output_dir,
-            json_output_dir,
-            quality_preset,
-            verbose,
-            expert_params,
-            workers,
-        )
-    else:
-        # Single video mode
-        try:
-            _process_single(
-                video_files[0],
-                output,
-                json_output,
-                quality_preset,
-                verbose,
-                expert_params,
-            )
-        except Exception as e:
-            click.echo(f"Error: {e}", err=True)
-            sys.exit(1)
-
-
-def _process_single(
-    video_path: str,
-    output: str | None,
-    json_output: str | None,
-    quality_preset: QualityPreset,
-    verbose: bool,
-    expert_params: AnalysisParameters,
-) -> None:
-    """Process a single SJ video by calling the API."""
-    try:
-        # Create overrides from expert parameters
-        overrides = AnalysisOverrides(
-            smoothing_window=expert_params.smoothing_window,
-            velocity_threshold=expert_params.velocity_threshold,
-            min_contact_frames=expert_params.min_contact_frames,
-            visibility_threshold=expert_params.visibility_threshold,
-        )
-
-        # Call the API function (handles all processing logic)
-        metrics = process_sj_video(
-            video_path=video_path,
-            quality=quality_preset.value,
-            output_video=output,
-            json_output=json_output,
-            overrides=overrides,
-            detection_confidence=expert_params.detection_confidence,
-            tracking_confidence=expert_params.tracking_confidence,
-            mass_kg=expert_params.mass_kg,
-            verbose=verbose,
-        )
-
-        # Print formatted summary to stdout
-        _output_results(metrics, json_output=None)  # Don't write JSON (API already did)
-
-    except Exception as e:
-        click.echo(f"Error processing video: {e}", err=True)
-        if verbose:
-            import traceback
-
-            traceback.print_exc()
-        sys.exit(1)
-
-
-def _output_results(metrics: SJMetrics, json_output: str | None) -> None:
-    """Output analysis results."""
-    results = metrics.to_dict()
-
-    # Output JSON
-    if json_output:
-        with open(json_output, "w") as f:
-            json.dump(results, f, indent=2)
-        click.echo(f"Metrics saved to: {json_output}", err=True)
-    else:
-        # Output to stdout
-        print(json.dumps(results, indent=2))
-
-    # Print summary
-    click.echo("\n" + "=" * 60, err=True)
-    click.echo("SJ ANALYSIS RESULTS", err=True)
-    click.echo("=" * 60, err=True)
-    click.echo(f"Jump height: {metrics.jump_height:.3f} m", err=True)
-    click.echo(f"Flight time: {metrics.flight_time * 1000:.1f} ms", err=True)
-    click.echo(f"Squat hold duration: {metrics.squat_hold_duration * 1000:.1f} ms", err=True)
-    click.echo(f"Concentric duration: {metrics.concentric_duration * 1000:.1f} ms", err=True)
-    click.echo(f"Peak concentric velocity: {metrics.peak_concentric_velocity:.3f} m/s", err=True)
-    if metrics.peak_power is not None:
-        click.echo(f"Peak power: {metrics.peak_power:.0f} W", err=True)
-        click.echo(f"Mean power: {metrics.mean_power:.0f} W", err=True)
-    if metrics.peak_force is not None:
-        click.echo(f"Peak force: {metrics.peak_force:.0f} N", err=True)
-    click.echo("=" * 60, err=True)

kinemotion/squat_jump/debug_overlay.py

@@ -1,163 +0,0 @@
-"""Debug overlay visualization for Squat Jump analysis."""
-
-import cv2
-import numpy as np
-
-from ..core.debug_overlay_utils import BaseDebugOverlayRenderer
-from ..core.overlay_constants import (
-    CYAN,
-    GREEN,
-    PHASE_LABEL_LINE_HEIGHT,
-    PHASE_LABEL_START_Y,
-    RED,
-    WHITE,
-    Color,
-    LandmarkDict,
-)
-from .analysis import SJPhase
-from .kinematics import SJMetrics
-
-
-class SquatJumpDebugOverlayRenderer(BaseDebugOverlayRenderer):
-    """Debug overlay renderer for Squat Jump analysis results."""
-
-    def _get_phase_color(self, phase: SJPhase) -> Color:
-        """Get color based on jump phase."""
-        phase_colors = {
-            SJPhase.SQUAT_HOLD: (255, 255, 0),  # Yellow
-            SJPhase.CONCENTRIC: (0, 165, 255),  # Orange
-            SJPhase.FLIGHT: RED,
-            SJPhase.LANDING: GREEN,
-            SJPhase.UNKNOWN: WHITE,
-        }
-        return phase_colors.get(phase, WHITE)
-
-    def render_frame(
-        self,
-        frame: np.ndarray,
-        landmarks: LandmarkDict | None,
-        frame_index: int,
-        metrics: SJMetrics | None = None,
-    ) -> np.ndarray:
-        """Render debug overlay on a single frame.
-
-        Args:
-            frame: Input frame (BGR format)
-            landmarks: Pose landmarks for the frame
-            frame_index: Frame index for timeline display
-            metrics: Analysis metrics for data display
-
-        Returns:
-            Annotated frame with debug overlay
-        """
-        # Create a copy to avoid modifying the original
-        annotated_frame = frame.copy()
-
-        # Determine current phase
-        current_phase = SJPhase.UNKNOWN
-        if metrics:
-            if (
-                metrics.squat_hold_start_frame is not None
-                and metrics.concentric_start_frame is not None
-                and metrics.squat_hold_start_frame <= frame_index < metrics.concentric_start_frame
-            ):
-                current_phase = SJPhase.SQUAT_HOLD
-            elif (
-                metrics.concentric_start_frame is not None
-                and metrics.takeoff_frame is not None
-                and metrics.concentric_start_frame <= frame_index < metrics.takeoff_frame
-            ):
-                current_phase = SJPhase.CONCENTRIC
-            elif (
-                metrics.takeoff_frame is not None
-                and metrics.landing_frame is not None
-                and metrics.takeoff_frame <= frame_index < metrics.landing_frame
-            ):
-                current_phase = SJPhase.FLIGHT
-            elif (
-                metrics.landing_frame is not None
-                and metrics.landing_frame <= frame_index < metrics.landing_frame + 15
-            ):
-                current_phase = SJPhase.LANDING
-
-        # Draw skeleton and landmarks
-        if landmarks:
-            self._draw_skeleton(annotated_frame, landmarks)
-
-        # Draw frame information
-        self._draw_frame_info(annotated_frame, frame_index, current_phase)
-
-        # Draw metrics if available
-        if metrics:
-            self._draw_metrics(annotated_frame, metrics, frame_index)
-
-        return annotated_frame
-
-    def _draw_frame_info(self, frame: np.ndarray, frame_index: int, phase: SJPhase) -> None:
-        """Draw frame information overlay.
-
-        Args:
-            frame: Frame to draw on
-            frame_index: Current frame index
-            phase: Current jump phase
-        """
-        # Draw frame counter
-        cv2.putText(
-            frame,
-            f"Frame: {frame_index}",
-            (10, 30),
-            cv2.FONT_HERSHEY_SIMPLEX,
-            0.7,
-            WHITE,
-            2,
-            cv2.LINE_AA,
-        )
-
-        # Draw phase label
-        phase_color = self._get_phase_color(phase)
-        cv2.putText(
-            frame,
-            f"Phase: {phase.value.replace('_', ' ').upper()}",
-            (10, 70),
-            cv2.FONT_HERSHEY_SIMPLEX,
-            0.8,
-            phase_color,
-            2,
-            cv2.LINE_AA,
-        )
-
-    def _draw_metrics(self, frame: np.ndarray, metrics: SJMetrics, frame_index: int) -> None:
-        """Draw metrics information on frame.
-
-        Args:
-            frame: Frame to draw on
-            metrics: Metrics object with analysis results
-            frame_index: Current frame index
-        """
-        # Only show summary metrics after takeoff or at the end
-        if metrics.takeoff_frame is None or frame_index < metrics.takeoff_frame:
-            return
-
-        y_offset = PHASE_LABEL_START_Y + 100
-
-        # Display key metrics
-        metric_items: list[tuple[str, Color]] = [
-            (f"Jump Height: {metrics.jump_height:.3f} m", WHITE),
-            (f"Flight Time: {metrics.flight_time * 1000:.1f} ms", RED),
-            (f"Concentric: {metrics.concentric_duration * 1000:.1f} ms", CYAN),
-        ]
-        if metrics.peak_power is not None:
-            metric_items.append((f"Peak Power: {metrics.peak_power:.0f} W", GREEN))
-
-        for text, color in metric_items:
-            cv2.putText(
-                frame,
-                text,
-                (10, y_offset),
-                cv2.FONT_HERSHEY_SIMPLEX,
-                0.6,
-                color,
-                2,
-                cv2.LINE_AA,
-            )
-            y_offset += PHASE_LABEL_LINE_HEIGHT