kinemotion 0.10.5__py3-none-any.whl → 0.10.7__py3-none-any.whl

kinemotion/dropjump/cli.py

@@ -12,8 +12,12 @@ import click
 import numpy as np
 
 from ..api import VideoConfig, VideoResult, process_videos_bulk
+from ..core.auto_tuning import (
+    AnalysisParameters as AutoTunedParams,
+)
 from ..core.auto_tuning import (
     QualityPreset,
+    VideoCharacteristics,
     analyze_video_sample,
     auto_tune_parameters,
 )
@@ -21,11 +25,12 @@ from ..core.pose import PoseTracker
 from ..core.smoothing import smooth_landmarks, smooth_landmarks_advanced
 from ..core.video_io import VideoProcessor
 from .analysis import (
+    ContactState,
     compute_average_foot_position,
     detect_ground_contact,
 )
 from .debug_overlay import DebugOverlayRenderer
-from .kinematics import calculate_drop_jump_metrics
+from .kinematics import DropJumpMetrics, calculate_drop_jump_metrics
 
 
 @dataclass
@@ -41,6 +46,25 @@ class AnalysisParameters:
     tracking_confidence: float | None = None
 
 
+@dataclass
+class BatchOptions:
+    """Batch processing configuration."""
+
+    batch: bool
+    workers: int
+    output_dir: str | None
+    json_output_dir: str | None
+    csv_summary: str | None
+
+
+@dataclass
+class OutputOptions:
+    """Output configuration for single video processing."""
+
+    output: str | None
+    json_output: str | None
+
+
 @click.command(name="dropjump-analyze")
 @click.argument("video_path", nargs=-1, type=click.Path(exists=False), required=True)
 @click.option(
@@ -197,6 +221,62 @@ def dropjump_analyze(
     kinemotion dropjump-analyze videos/*.mp4 --batch --drop-height 0.40 \\
         --json-output-dir results/ --csv-summary summary.csv
     """
+    # Group parameters into dataclasses
+    batch_opts = BatchOptions(
+        batch=batch,
+        workers=workers,
+        output_dir=output_dir,
+        json_output_dir=json_output_dir,
+        csv_summary=csv_summary,
+    )
+
+    output_opts = OutputOptions(
+        output=output,
+        json_output=json_output,
+    )
+
+    expert_params = AnalysisParameters(
+        drop_start_frame=drop_start_frame,
+        smoothing_window=smoothing_window,
+        velocity_threshold=velocity_threshold,
+        min_contact_frames=min_contact_frames,
+        visibility_threshold=visibility_threshold,
+        detection_confidence=detection_confidence,
+        tracking_confidence=tracking_confidence,
+    )
+
+    # Execute analysis with grouped parameters
+    _execute_analysis(
+        video_path,
+        drop_height,
+        quality,
+        verbose,
+        batch_opts,
+        output_opts,
+        expert_params,
+    )
+
+
+def _execute_analysis(
+    video_path: tuple[str, ...],
+    drop_height: float,
+    quality: str,
+    verbose: bool,
+    batch_opts: BatchOptions,
+    output_opts: OutputOptions,
+    expert_params: AnalysisParameters,
+) -> None:
+    """Execute drop jump analysis with grouped parameters.
+
+    Args:
+        video_path: Tuple of video path patterns
+        drop_height: Drop height in meters
+        quality: Quality preset string
+        verbose: Verbose output flag
+        batch_opts: Batch processing options
+        output_opts: Output file options
+        expert_params: Expert parameter overrides
+    """
     # Expand glob patterns and collect all video files
     video_files: list[str] = []
     for pattern in video_path:
@@ -214,43 +294,286 @@ def dropjump_analyze(
         sys.exit(1)
 
     # Determine if batch mode should be used
-    use_batch = batch or len(video_files) > 1
-
-    # Group expert parameters
-    params = AnalysisParameters(
-        drop_start_frame=drop_start_frame,
-        smoothing_window=smoothing_window,
-        velocity_threshold=velocity_threshold,
-        min_contact_frames=min_contact_frames,
-        visibility_threshold=visibility_threshold,
-        detection_confidence=detection_confidence,
-        tracking_confidence=tracking_confidence,
-    )
+    use_batch = batch_opts.batch or len(video_files) > 1
 
     if use_batch:
         _process_batch(
             video_files,
             drop_height,
             quality,
-            workers,
-            output_dir,
-            json_output_dir,
-            csv_summary,
-            params,
+            batch_opts.workers,
+            batch_opts.output_dir,
+            batch_opts.json_output_dir,
+            batch_opts.csv_summary,
+            expert_params,
         )
     else:
         # Single video mode (original behavior)
         _process_single(
             video_files[0],
-            output,
-            json_output,
+            output_opts.output,
+            output_opts.json_output,
             drop_height,
             quality,
             verbose,
-            params,
+            expert_params,
         )
 
 
+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:
+    """Apply expert parameter overrides to auto-tuned parameters.
+
+    Args:
+        params: Auto-tuned parameters
+        expert_params: Expert overrides
+
+    Returns:
+        Modified params object (mutated in place)
+    """
+    if expert_params.smoothing_window is not None:
+        params.smoothing_window = expert_params.smoothing_window
+    if expert_params.velocity_threshold is not None:
+        params.velocity_threshold = expert_params.velocity_threshold
+    if expert_params.min_contact_frames is not None:
+        params.min_contact_frames = expert_params.min_contact_frames
+    if expert_params.visibility_threshold is not None:
+        params.visibility_threshold = expert_params.visibility_threshold
+    return params
+
+
+def _print_auto_tuned_params(
+    video: VideoProcessor,
+    characteristics: VideoCharacteristics,
+    quality_preset: QualityPreset,
+    params: AutoTunedParams,
+) -> None:
+    """Print auto-tuned parameters in verbose mode.
+
+    Args:
+        video: Video processor
+        characteristics: Video characteristics
+        quality_preset: Quality preset
+        params: Auto-tuned parameters
+    """
+    click.echo("\n" + "=" * 60, err=True)
+    click.echo("AUTO-TUNED PARAMETERS", err=True)
+    click.echo("=" * 60, err=True)
+    click.echo(f"Video FPS: {video.fps:.2f}", err=True)
+    click.echo(
+        f"Tracking quality: {characteristics.tracking_quality} "
+        f"(avg visibility: {characteristics.avg_visibility:.2f})",
+        err=True,
+    )
+    click.echo(f"Quality preset: {quality_preset.value}", err=True)
+    click.echo("\nSelected parameters:", err=True)
+    click.echo(f"  smoothing_window: {params.smoothing_window}", err=True)
+    click.echo(f"  polyorder: {params.polyorder}", err=True)
+    click.echo(f"  velocity_threshold: {params.velocity_threshold:.4f}", err=True)
+    click.echo(f"  min_contact_frames: {params.min_contact_frames}", err=True)
+    click.echo(f"  visibility_threshold: {params.visibility_threshold}", err=True)
+    click.echo(f"  detection_confidence: {params.detection_confidence}", err=True)
+    click.echo(f"  tracking_confidence: {params.tracking_confidence}", err=True)
+    click.echo(f"  outlier_rejection: {params.outlier_rejection}", err=True)
+    click.echo(f"  bilateral_filter: {params.bilateral_filter}", err=True)
+    click.echo(f"  use_curvature: {params.use_curvature}", err=True)
+    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]:
+    """Extract vertical positions and visibilities from landmarks.
+
+    Args:
+        smoothed_landmarks: Smoothed landmark sequence
+
+    Returns:
+        Tuple of (vertical_positions, visibilities)
+    """
+    click.echo("Extracting foot positions...", err=True)
+
+    position_list: list[float] = []
+    visibilities_list: list[float] = []
+
+    for frame_landmarks in smoothed_landmarks:
+        if frame_landmarks:
+            _, foot_y = compute_average_foot_position(frame_landmarks)
+            position_list.append(foot_y)
+
+            # Average visibility of foot landmarks
+            foot_vis = []
+            for key in ["left_ankle", "right_ankle", "left_heel", "right_heel"]:
+                if key in frame_landmarks:
+                    foot_vis.append(frame_landmarks[key][2])
+            visibilities_list.append(float(np.mean(foot_vis)) if foot_vis else 0.0)
+        else:
+            position_list.append(position_list[-1] if position_list else 0.5)
+            visibilities_list.append(0.0)
+
+    return np.array(position_list), np.array(visibilities_list)
+
+
+def _create_debug_video(
+    output: str,
+    video: VideoProcessor,
+    frames: list,
+    smoothed_landmarks: list,
+    contact_states: list[ContactState],
+    metrics: DropJumpMetrics,
+) -> None:
+    """Generate debug video with overlays.
+
+    Args:
+        output: Output video path
+        video: Video processor
+        frames: Video frames
+        smoothed_landmarks: Smoothed landmarks
+        contact_states: Contact states
+        metrics: Calculated metrics
+    """
+    click.echo(f"Generating debug video: {output}", err=True)
+    if video.display_width != video.width or video.display_height != video.height:
+        click.echo(f"Source video encoded: {video.width}x{video.height}", err=True)
+        click.echo(
+            f"Output dimensions: {video.display_width}x{video.display_height} "
+            f"(respecting display aspect ratio)",
+            err=True,
+        )
+    else:
+        click.echo(
+            f"Output dimensions: {video.width}x{video.height} "
+            f"(matching source video aspect ratio)",
+            err=True,
+        )
+
+    with DebugOverlayRenderer(
+        output,
+        video.width,
+        video.height,
+        video.display_width,
+        video.display_height,
+        video.fps,
+    ) as renderer:
+        render_bar: Any
+        with click.progressbar(
+            length=len(frames), label="Rendering frames"
+        ) as render_bar:
+            for i, frame in enumerate(frames):
+                annotated = renderer.render_frame(
+                    frame,
+                    smoothed_landmarks[i],
+                    contact_states[i],
+                    i,
+                    metrics,
+                    use_com=False,
+                )
+                renderer.write_frame(annotated)
+                render_bar.update(1)
+
+    click.echo(f"Debug video saved: {output}", err=True)
+
+
 def _process_single(
     video_path: str,
     output: str | None,
@@ -263,11 +586,9 @@ def _process_single(
     """Process a single video (original CLI behavior)."""
     click.echo(f"Analyzing video: {video_path}", err=True)
 
-    # Convert quality string to enum
     quality_preset = QualityPreset(quality.lower())
 
     try:
-        # Initialize video processor
         with VideoProcessor(video_path) as video:
             click.echo(
                 f"Video: {video.width}x{video.height} @ {video.fps:.2f} fps, "
@@ -275,180 +596,42 @@ def _process_single(
                 err=True,
             )
 
-            # ================================================================
-            # STEP 1: Auto-tune parameters based on video characteristics
-            # ================================================================
-
-            # Analyze video characteristics from a sample to determine optimal parameters
-            # We'll use detection/tracking confidence from quality preset for initial tracking
-            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
-
-            # Initialize pose tracker
-            tracker = PoseTracker(
-                min_detection_confidence=initial_detection_conf,
-                min_tracking_confidence=initial_tracking_conf,
+            # Determine confidence levels
+            detection_conf, tracking_conf = _determine_initial_confidence(
+                quality_preset, expert_params
             )
 
-            # Process all 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()
+            # Track all frames
+            tracker = PoseTracker(
+                min_detection_confidence=detection_conf,
+                min_tracking_confidence=tracking_conf,
+            )
+            frames, landmarks_sequence = _track_all_frames(video, tracker)
 
             if not landmarks_sequence:
                 click.echo("Error: No frames processed", err=True)
                 sys.exit(1)
 
-            # ================================================================
-            # STEP 2: Analyze video characteristics and auto-tune parameters
-            # ================================================================
-
+            # Auto-tune parameters
             characteristics = analyze_video_sample(
                 landmarks_sequence, video.fps, video.frame_count
             )
-
-            # Auto-tune parameters based on video characteristics
             params = auto_tune_parameters(characteristics, quality_preset)
+            params = _apply_expert_param_overrides(params, expert_params)
 
-            # Apply expert overrides if provided
-            if expert_params.smoothing_window is not None:
-                params.smoothing_window = expert_params.smoothing_window
-            if expert_params.velocity_threshold is not None:
-                params.velocity_threshold = expert_params.velocity_threshold
-            if expert_params.min_contact_frames is not None:
-                params.min_contact_frames = expert_params.min_contact_frames
-            if expert_params.visibility_threshold is not None:
-                params.visibility_threshold = expert_params.visibility_threshold
-
-            # Show selected parameters if verbose
+            # Show parameters if verbose
             if verbose:
-                click.echo("\n" + "=" * 60, err=True)
-                click.echo("AUTO-TUNED PARAMETERS", err=True)
-                click.echo("=" * 60, err=True)
-                click.echo(f"Video FPS: {video.fps:.2f}", err=True)
-                click.echo(
-                    f"Tracking quality: {characteristics.tracking_quality} "
-                    f"(avg visibility: {characteristics.avg_visibility:.2f})",
-                    err=True,
-                )
-                click.echo(f"Quality preset: {quality_preset.value}", err=True)
-                click.echo("\nSelected parameters:", err=True)
-                click.echo(f"  smoothing_window: {params.smoothing_window}", err=True)
-                click.echo(f"  polyorder: {params.polyorder}", err=True)
-                click.echo(
-                    f"  velocity_threshold: {params.velocity_threshold:.4f}", err=True
-                )
-                click.echo(
-                    f"  min_contact_frames: {params.min_contact_frames}", err=True
-                )
-                click.echo(
-                    f"  visibility_threshold: {params.visibility_threshold}", err=True
-                )
-                click.echo(
-                    f"  detection_confidence: {params.detection_confidence}", err=True
-                )
-                click.echo(
-                    f"  tracking_confidence: {params.tracking_confidence}", err=True
-                )
-                click.echo(f"  outlier_rejection: {params.outlier_rejection}", err=True)
-                click.echo(f"  bilateral_filter: {params.bilateral_filter}", err=True)
-                click.echo(f"  use_curvature: {params.use_curvature}", err=True)
-                click.echo("=" * 60 + "\n", err=True)
-
-            # ================================================================
-            # STEP 3: Apply smoothing with auto-tuned parameters
-            # ================================================================
-
-            # Smooth landmarks using auto-tuned parameters
-            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,
-                    )
-                smoothed_landmarks = 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)
-                smoothed_landmarks = smooth_landmarks(
-                    landmarks_sequence,
-                    window_length=params.smoothing_window,
-                    polyorder=params.polyorder,
-                )
+                _print_auto_tuned_params(video, characteristics, quality_preset, params)
+
+            # Apply smoothing
+            smoothed_landmarks = _smooth_landmark_sequence(landmarks_sequence, params)
+
+            # Extract positions
+            vertical_positions, visibilities = _extract_positions_and_visibilities(
+                smoothed_landmarks
+            )
 
-            # Extract vertical positions from feet
-            click.echo("Extracting foot positions...", err=True)
-
-            position_list: list[float] = []
-            visibilities_list: list[float] = []
-
-            for frame_landmarks in smoothed_landmarks:
-                if frame_landmarks:
-                    # Use average foot position
-                    _, foot_y = compute_average_foot_position(frame_landmarks)
-                    position_list.append(foot_y)
-
-                    # Average visibility of foot landmarks
-                    foot_vis = []
-                    for key in [
-                        "left_ankle",
-                        "right_ankle",
-                        "left_heel",
-                        "right_heel",
-                    ]:
-                        if key in frame_landmarks:
-                            foot_vis.append(frame_landmarks[key][2])
-                    visibilities_list.append(
-                        float(np.mean(foot_vis)) if foot_vis else 0.0
-                    )
-                else:
-                    # Use previous position if available, otherwise default
-                    position_list.append(position_list[-1] if position_list else 0.5)
-                    visibilities_list.append(0.0)
-
-            vertical_positions: np.ndarray = np.array(position_list)
-            visibilities: np.ndarray = np.array(visibilities_list)
-
-            # Detect ground contact using auto-tuned parameters
+            # Detect ground contact
             contact_states = detect_ground_contact(
                 vertical_positions,
                 velocity_threshold=params.velocity_threshold,
@@ -475,67 +658,22 @@ def _process_single(
                 smoothing_window=params.smoothing_window,
                 polyorder=params.polyorder,
                 use_curvature=params.use_curvature,
-                kinematic_correction_factor=1.0,  # Always 1.0 now (no experimental correction)
+                kinematic_correction_factor=1.0,
             )
 
-            # Output metrics as JSON
-            metrics_dict = metrics.to_dict()
-            metrics_json = json.dumps(metrics_dict, indent=2)
-
+            # Output metrics
+            metrics_json = json.dumps(metrics.to_dict(), indent=2)
             if json_output:
-                output_path = Path(json_output)
-                output_path.write_text(metrics_json)
+                Path(json_output).write_text(metrics_json)
                 click.echo(f"Metrics written to: {json_output}", err=True)
             else:
                 click.echo(metrics_json)
 
             # Generate debug video if requested
             if output:
-                click.echo(f"Generating debug video: {output}", err=True)
-                if (
-                    video.display_width != video.width
-                    or video.display_height != video.height
-                ):
-                    click.echo(
-                        f"Source video encoded: {video.width}x{video.height}",
-                        err=True,
-                    )
-                    click.echo(
-                        f"Output dimensions: {video.display_width}x{video.display_height} "
-                        f"(respecting display aspect ratio)",
-                        err=True,
-                    )
-                else:
-                    click.echo(
-                        f"Output dimensions: {video.width}x{video.height} "
-                        f"(matching source video aspect ratio)",
-                        err=True,
-                    )
-                with DebugOverlayRenderer(
-                    output,
-                    video.width,
-                    video.height,
-                    video.display_width,
-                    video.display_height,
-                    video.fps,
-                ) as renderer:
-                    render_bar: Any
-                    with click.progressbar(
-                        length=len(frames), label="Rendering frames"
-                    ) as render_bar:
-                        for i, frame in enumerate(frames):
-                            annotated = renderer.render_frame(
-                                frame,
-                                smoothed_landmarks[i],
-                                contact_states[i],
-                                i,
-                                metrics,
-                                use_com=False,
-                            )
-                            renderer.write_frame(annotated)
-                            render_bar.update(1)
-
-                click.echo(f"Debug video saved: {output}", err=True)
+                _create_debug_video(
+                    output, video, frames, smoothed_landmarks, contact_states, metrics
+                )
 
             click.echo("Analysis complete!", err=True)
 
@@ -544,23 +682,15 @@ def _process_single(
         sys.exit(1)
 
 
-def _process_batch(
-    video_files: list[str],
-    drop_height: float,
-    quality: str,
-    workers: int,
-    output_dir: str | None,
-    json_output_dir: str | None,
-    csv_summary: str | None,
-    expert_params: AnalysisParameters,
+def _setup_batch_output_dirs(
+    output_dir: str | None, json_output_dir: str | None
 ) -> None:
-    """Process multiple videos in batch mode using parallel processing."""
-    click.echo(
-        f"\nBatch processing {len(video_files)} videos with {workers} workers", err=True
-    )
-    click.echo("=" * 70, err=True)
+    """Create output directories for batch processing.
 
-    # Create output directories if specified
+    Args:
+        output_dir: Debug video output directory
+        json_output_dir: JSON metrics output directory
+    """
     if output_dir:
         Path(output_dir).mkdir(parents=True, exist_ok=True)
         click.echo(f"Debug videos will be saved to: {output_dir}", err=True)
@@ -569,12 +699,32 @@ def _process_batch(
         Path(json_output_dir).mkdir(parents=True, exist_ok=True)
         click.echo(f"JSON metrics will be saved to: {json_output_dir}", err=True)
 
-    # Build configurations for each video
+
+def _create_video_configs(
+    video_files: list[str],
+    drop_height: float,
+    quality: str,
+    output_dir: str | None,
+    json_output_dir: str | None,
+    expert_params: AnalysisParameters,
+) -> list[VideoConfig]:
+    """Build configuration objects for each video.
+
+    Args:
+        video_files: List of video file paths
+        drop_height: Drop height in meters
+        quality: Quality preset
+        output_dir: Debug video output directory
+        json_output_dir: JSON metrics output directory
+        expert_params: Expert parameter overrides
+
+    Returns:
+        List of VideoConfig objects
+    """
     configs: list[VideoConfig] = []
     for video_file in video_files:
         video_name = Path(video_file).stem
 
-        # Determine output paths
         debug_video = None
         if output_dir:
             debug_video = str(Path(output_dir) / f"{video_name}_debug.mp4")
@@ -599,29 +749,15 @@ def _process_batch(
         )
         configs.append(config)
 
-    # Progress callback
-    completed = 0
+    return configs
 
-    def show_progress(result: VideoResult) -> None:
-        nonlocal completed
-        completed += 1
-        status = "✓" if result.success else "✗"
-        video_name = Path(result.video_path).name
-        click.echo(
-            f"[{completed}/{len(configs)}] {status} {video_name} "
-            f"({result.processing_time:.1f}s)",
-            err=True,
-        )
-        if not result.success:
-            click.echo(f"    Error: {result.error}", err=True)
 
-    # Process all videos
-    click.echo("\nProcessing videos...", err=True)
-    results = process_videos_bulk(
-        configs, max_workers=workers, progress_callback=show_progress
-    )
+def _compute_batch_statistics(results: list[VideoResult]) -> None:
+    """Compute and display batch processing statistics.
 
-    # Generate summary
+    Args:
+        results: List of video processing results
+    """
     click.echo("\n" + "=" * 70, err=True)
     click.echo("BATCH PROCESSING SUMMARY", err=True)
     click.echo("=" * 70, err=True)
@@ -648,7 +784,6 @@ def _process_batch(
         ]
 
         if with_gct:
-            # Type assertion: filtering ensures metrics and ground_contact_time are not None
             avg_gct = sum(
                 r.metrics.ground_contact_time * 1000
                 for r in with_gct
@@ -657,7 +792,6 @@ def _process_batch(
             click.echo(f"\nAverage ground contact time: {avg_gct:.1f} ms", err=True)
 
         if with_flight:
-            # Type assertion: filtering ensures metrics and flight_time are not None
             avg_flight = sum(
                 r.metrics.flight_time * 1000
                 for r in with_flight
@@ -666,7 +800,6 @@ def _process_batch(
             click.echo(f"Average flight time: {avg_flight:.1f} ms", err=True)
 
         if with_jump:
-            # Type assertion: filtering ensures metrics and jump_height are not None
             avg_jump = sum(
                 r.metrics.jump_height
                 for r in with_jump
@@ -677,63 +810,129 @@ def _process_batch(
                 err=True,
             )
 
-    # Export CSV summary if requested
-    if csv_summary and successful:
-        click.echo(f"\nExporting CSV summary to: {csv_summary}", err=True)
-        Path(csv_summary).parent.mkdir(parents=True, exist_ok=True)
-
-        with open(csv_summary, "w", newline="") as f:
-            writer = csv.writer(f)
-
-            # Header
-            writer.writerow(
-                [
-                    "Video",
-                    "Ground Contact Time (ms)",
-                    "Flight Time (ms)",
-                    "Jump Height (m)",
-                    "Processing Time (s)",
-                    "Status",
-                ]
-            )
 
-            # Data rows
-            for result in results:
-                if result.success and result.metrics:
-                    writer.writerow(
-                        [
-                            Path(result.video_path).name,
-                            (
-                                f"{result.metrics.ground_contact_time * 1000:.1f}"
-                                if result.metrics.ground_contact_time
-                                else "N/A"
-                            ),
-                            (
-                                f"{result.metrics.flight_time * 1000:.1f}"
-                                if result.metrics.flight_time
-                                else "N/A"
-                            ),
-                            (
-                                f"{result.metrics.jump_height:.3f}"
-                                if result.metrics.jump_height
-                                else "N/A"
-                            ),
-                            f"{result.processing_time:.2f}",
-                            "Success",
-                        ]
-                    )
-                else:
-                    writer.writerow(
-                        [
-                            Path(result.video_path).name,
-                            "N/A",
-                            "N/A",
-                            "N/A",
-                            f"{result.processing_time:.2f}",
-                            f"Failed: {result.error}",
-                        ]
-                    )
-
-        click.echo("CSV summary written successfully", err=True)
+def _write_csv_summary(
+    csv_summary: str | None, results: list[VideoResult], successful: list[VideoResult]
+) -> None:
+    """Write CSV summary of batch processing results.
+
+    Args:
+        csv_summary: Path to CSV output file
+        results: All processing results
+        successful: Successful processing results
+    """
+    if not csv_summary or not successful:
+        return
+
+    click.echo(f"\nExporting CSV summary to: {csv_summary}", err=True)
+    Path(csv_summary).parent.mkdir(parents=True, exist_ok=True)
+
+    with open(csv_summary, "w", newline="") as f:
+        writer = csv.writer(f)
+
+        # Header
+        writer.writerow(
+            [
+                "Video",
+                "Ground Contact Time (ms)",
+                "Flight Time (ms)",
+                "Jump Height (m)",
+                "Processing Time (s)",
+                "Status",
+            ]
+        )
+
+        # Data rows
+        for result in results:
+            if result.success and result.metrics:
+                writer.writerow(
+                    [
+                        Path(result.video_path).name,
+                        (
+                            f"{result.metrics.ground_contact_time * 1000:.1f}"
+                            if result.metrics.ground_contact_time
+                            else "N/A"
+                        ),
+                        (
+                            f"{result.metrics.flight_time * 1000:.1f}"
+                            if result.metrics.flight_time
+                            else "N/A"
+                        ),
+                        (
+                            f"{result.metrics.jump_height:.3f}"
+                            if result.metrics.jump_height
+                            else "N/A"
+                        ),
+                        f"{result.processing_time:.2f}",
+                        "Success",
+                    ]
+                )
+            else:
+                writer.writerow(
+                    [
+                        Path(result.video_path).name,
+                        "N/A",
+                        "N/A",
+                        "N/A",
+                        f"{result.processing_time:.2f}",
+                        f"Failed: {result.error}",
+                    ]
+                )
+
+    click.echo("CSV summary written successfully", err=True)
+
+
+def _process_batch(
+    video_files: list[str],
+    drop_height: float,
+    quality: str,
+    workers: int,
+    output_dir: str | None,
+    json_output_dir: str | None,
+    csv_summary: str | None,
+    expert_params: AnalysisParameters,
+) -> None:
+    """Process multiple videos in batch mode using parallel processing."""
+    click.echo(
+        f"\nBatch processing {len(video_files)} videos with {workers} workers", err=True
+    )
+    click.echo("=" * 70, err=True)
+
+    # Setup output directories
+    _setup_batch_output_dirs(output_dir, json_output_dir)
+
+    # Create video configurations
+    configs = _create_video_configs(
+        video_files, drop_height, quality, output_dir, json_output_dir, expert_params
+    )
+
+    # Progress callback
+    completed = 0
+
+    def show_progress(result: VideoResult) -> None:
+        nonlocal completed
+        completed += 1
+        status = "✓" if result.success else "✗"
+        video_name = Path(result.video_path).name
+        click.echo(
+            f"[{completed}/{len(configs)}] {status} {video_name} "
+            f"({result.processing_time:.1f}s)",
+            err=True,
+        )
+        if not result.success:
+            click.echo(f"    Error: {result.error}", err=True)
+
+    # Process all videos
+    click.echo("\nProcessing videos...", err=True)
+    results = process_videos_bulk(
+        configs, max_workers=workers, progress_callback=show_progress
+    )
+
+    # Display statistics
+    _compute_batch_statistics(results)
+
+    # Export CSV summary if requested
+    successful = [r for r in results if r.success]
+    _write_csv_summary(csv_summary, results, successful)
 
     click.echo("\nBatch processing complete!", err=True)

{kinemotion-0.10.5.dist-info → kinemotion-0.10.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kinemotion
-Version: 0.10.5
+Version: 0.10.7
 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.10.5.dist-info → kinemotion-0.10.7.dist-info}/RECORD

@@ -9,12 +9,12 @@ kinemotion/core/smoothing.py,sha256=FON4qKtsSp1-03GnJrDkEUAePaACn4QPMJF0eTIYqR0,
 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=C6v6E3g1W-KNFc0xUzSjg4wKve1WsPxKvUBJV7LiMNI,26468
+kinemotion/dropjump/cli.py,sha256=THFJqVLFdFIXgrKSHw2MVc5DuOsqHKJQVT_x_C7l_18,29443
 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.10.5.dist-info/METADATA,sha256=I5dXmUcnNNtKS43uCbC_zbMLBMZAg_QpOMhwpnFSYcw,20333
-kinemotion-0.10.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-kinemotion-0.10.5.dist-info/entry_points.txt,sha256=zaqnAnjLvcdrk1Qvj5nvXZCZ2gp0prS7it1zTJygcIY,50
-kinemotion-0.10.5.dist-info/licenses/LICENSE,sha256=KZajvqsHw0NoOHOi2q0FZ4NBe9HdV6oey-IPYAtHXfg,1088
-kinemotion-0.10.5.dist-info/RECORD,,
+kinemotion-0.10.7.dist-info/METADATA,sha256=HDg72JCd-k5WKdgm8o7YfXj2Pdtu-DW_cs-KvGHm_xc,20333
+kinemotion-0.10.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+kinemotion-0.10.7.dist-info/entry_points.txt,sha256=zaqnAnjLvcdrk1Qvj5nvXZCZ2gp0prS7it1zTJygcIY,50
+kinemotion-0.10.7.dist-info/licenses/LICENSE,sha256=KZajvqsHw0NoOHOi2q0FZ4NBe9HdV6oey-IPYAtHXfg,1088
+kinemotion-0.10.7.dist-info/RECORD,,