kinemotion 0.8.3__py3-none-any.whl → 0.10.0__py3-none-any.whl

kinemotion/__init__.py

@@ -1,3 +1,14 @@
 """Kinemotion: Video-based kinematic analysis for athletic performance."""
 
+from .api import VideoConfig, VideoResult, process_video, process_videos_bulk
+from .dropjump.kinematics import DropJumpMetrics
+
 __version__ = "0.1.0"
+
+__all__ = [
+    "process_video",
+    "process_videos_bulk",
+    "VideoConfig",
+    "VideoResult",
+    "DropJumpMetrics",
+]

kinemotion/api.py

@@ -0,0 +1,428 @@
+"""Public API for programmatic use of kinemotion analysis."""
+
+import time
+from collections.abc import Callable
+from concurrent.futures import ProcessPoolExecutor, as_completed
+from dataclasses import dataclass
+from pathlib import Path
+
+import numpy as np
+
+from .core.auto_tuning import (
+    QualityPreset,
+    analyze_video_sample,
+    auto_tune_parameters,
+)
+from .core.pose import PoseTracker
+from .core.smoothing import smooth_landmarks, smooth_landmarks_advanced
+from .core.video_io import VideoProcessor
+from .dropjump.analysis import compute_average_foot_position, detect_ground_contact
+from .dropjump.debug_overlay import DebugOverlayRenderer
+from .dropjump.kinematics import DropJumpMetrics, calculate_drop_jump_metrics
+
+
+@dataclass
+class VideoResult:
+    """Result of processing a single video."""
+
+    video_path: str
+    success: bool
+    metrics: DropJumpMetrics | None = None
+    error: str | None = None
+    processing_time: float = 0.0
+
+
+@dataclass
+class VideoConfig:
+    """Configuration for processing a single video."""
+
+    video_path: str
+    drop_height: float
+    quality: str = "balanced"
+    output_video: str | None = None
+    json_output: str | None = None
+    drop_start_frame: int | None = None
+    smoothing_window: int | None = None
+    velocity_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
+
+
+def process_video(
+    video_path: str,
+    drop_height: float,
+    quality: str = "balanced",
+    output_video: str | None = None,
+    json_output: str | None = None,
+    drop_start_frame: int | None = None,
+    smoothing_window: int | None = None,
+    velocity_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,
+    verbose: bool = False,
+) -> DropJumpMetrics:
+    """
+    Process a single drop jump video and return metrics.
+
+    Args:
+        video_path: Path to the input video file
+        drop_height: Height of drop box/platform in meters (e.g., 0.40 for 40cm)
+        quality: Analysis quality preset ("fast", "balanced", or "accurate")
+        output_video: Optional path for debug video output
+        json_output: Optional path for JSON metrics output
+        drop_start_frame: Optional manual drop start frame
+        smoothing_window: Optional override for smoothing window
+        velocity_threshold: Optional override for velocity threshold
+        min_contact_frames: Optional override for minimum contact frames
+        visibility_threshold: Optional override for visibility threshold
+        detection_confidence: Optional override for pose detection confidence
+        tracking_confidence: Optional override for pose tracking confidence
+        verbose: Print processing details
+
+    Returns:
+        DropJumpMetrics object containing analysis results
+
+    Raises:
+        ValueError: If video cannot be processed or parameters are invalid
+        FileNotFoundError: If video file does not exist
+    """
+    if not Path(video_path).exists():
+        raise FileNotFoundError(f"Video file not found: {video_path}")
+
+    # Convert quality string to enum
+    try:
+        quality_preset = QualityPreset(quality.lower())
+    except ValueError as e:
+        raise ValueError(
+            f"Invalid quality preset: {quality}. Must be 'fast', 'balanced', or 'accurate'"
+        ) from e
+
+    # Initialize video processor
+    with VideoProcessor(video_path) as video:
+        if verbose:
+            print(
+                f"Video: {video.width}x{video.height} @ {video.fps:.2f} fps, "
+                f"{video.frame_count} frames"
+            )
+
+        # Determine initial detection/tracking confidence from quality preset
+        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 detection_confidence is not None:
+            initial_detection_conf = detection_confidence
+        if tracking_confidence is not None:
+            initial_tracking_conf = tracking_confidence
+
+        # Initialize pose tracker
+        tracker = PoseTracker(
+            min_detection_confidence=initial_detection_conf,
+            min_tracking_confidence=initial_tracking_conf,
+        )
+
+        # Process all frames
+        if verbose:
+            print("Tracking pose landmarks...")
+
+        landmarks_sequence = []
+        frames = []
+
+        while True:
+            frame = video.read_frame()
+            if frame is None:
+                break
+
+            frames.append(frame)
+            landmarks = tracker.process_frame(frame)
+            landmarks_sequence.append(landmarks)
+
+        tracker.close()
+
+        if not landmarks_sequence:
+            raise ValueError("No frames could be processed from video")
+
+        # Analyze video characteristics and auto-tune parameters
+        characteristics = analyze_video_sample(
+            landmarks_sequence, video.fps, video.frame_count
+        )
+
+        params = auto_tune_parameters(characteristics, quality_preset)
+
+        # Apply expert overrides if provided
+        if smoothing_window is not None:
+            params.smoothing_window = smoothing_window
+        if velocity_threshold is not None:
+            params.velocity_threshold = velocity_threshold
+        if min_contact_frames is not None:
+            params.min_contact_frames = min_contact_frames
+        if visibility_threshold is not None:
+            params.visibility_threshold = visibility_threshold
+
+        # Show selected parameters if verbose
+        if verbose:
+            print("\n" + "=" * 60)
+            print("AUTO-TUNED PARAMETERS")
+            print("=" * 60)
+            print(f"Video FPS: {video.fps:.2f}")
+            print(
+                f"Tracking quality: {characteristics.tracking_quality} "
+                f"(avg visibility: {characteristics.avg_visibility:.2f})"
+            )
+            print(f"Quality preset: {quality_preset.value}")
+            print("\nSelected parameters:")
+            print(f"  smoothing_window: {params.smoothing_window}")
+            print(f"  polyorder: {params.polyorder}")
+            print(f"  velocity_threshold: {params.velocity_threshold:.4f}")
+            print(f"  min_contact_frames: {params.min_contact_frames}")
+            print(f"  visibility_threshold: {params.visibility_threshold}")
+            print(f"  detection_confidence: {params.detection_confidence}")
+            print(f"  tracking_confidence: {params.tracking_confidence}")
+            print(f"  outlier_rejection: {params.outlier_rejection}")
+            print(f"  bilateral_filter: {params.bilateral_filter}")
+            print(f"  use_curvature: {params.use_curvature}")
+            print("=" * 60 + "\n")
+
+        # Apply smoothing with auto-tuned parameters
+        if params.outlier_rejection or params.bilateral_filter:
+            if verbose:
+                if params.outlier_rejection:
+                    print("Smoothing landmarks with outlier rejection...")
+                if params.bilateral_filter:
+                    print("Using bilateral temporal filter...")
+            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:
+            if verbose:
+                print("Smoothing landmarks...")
+            smoothed_landmarks = smooth_landmarks(
+                landmarks_sequence,
+                window_length=params.smoothing_window,
+                polyorder=params.polyorder,
+            )
+
+        # Extract vertical positions from feet
+        if verbose:
+            print("Extracting foot positions...")
+
+        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)
+
+        vertical_positions: np.ndarray = np.array(position_list)
+        visibilities: np.ndarray = np.array(visibilities_list)
+
+        # Detect ground contact
+        contact_states = detect_ground_contact(
+            vertical_positions,
+            velocity_threshold=params.velocity_threshold,
+            min_contact_frames=params.min_contact_frames,
+            visibility_threshold=params.visibility_threshold,
+            visibilities=visibilities,
+            window_length=params.smoothing_window,
+            polyorder=params.polyorder,
+        )
+
+        # Calculate metrics
+        if verbose:
+            print("Calculating metrics...")
+            print(
+                f"Using drop height calibration: {drop_height}m ({drop_height*100:.0f}cm)"
+            )
+
+        metrics = calculate_drop_jump_metrics(
+            contact_states,
+            vertical_positions,
+            video.fps,
+            drop_height_m=drop_height,
+            drop_start_frame=drop_start_frame,
+            velocity_threshold=params.velocity_threshold,
+            smoothing_window=params.smoothing_window,
+            polyorder=params.polyorder,
+            use_curvature=params.use_curvature,
+            kinematic_correction_factor=1.0,
+        )
+
+        # Save JSON 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}")
+
+        # Generate debug video if requested
+        if output_video:
+            if verbose:
+                print(f"Generating debug video: {output_video}")
+
+            with DebugOverlayRenderer(
+                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],
+                        contact_states[i],
+                        i,
+                        metrics,
+                        use_com=False,
+                    )
+                    renderer.write_frame(annotated)
+
+            if verbose:
+                print(f"Debug video saved: {output_video}")
+
+        if verbose:
+            print("Analysis complete!")
+
+        return metrics
+
+
+def process_videos_bulk(
+    configs: list[VideoConfig],
+    max_workers: int = 4,
+    progress_callback: Callable[[VideoResult], None] | None = None,
+) -> list[VideoResult]:
+    """
+    Process multiple videos in parallel using ProcessPoolExecutor.
+
+    Args:
+        configs: List of VideoConfig objects specifying video paths and parameters
+        max_workers: Maximum number of parallel workers (default: 4)
+        progress_callback: Optional callback function called after each video completes.
+                         Receives VideoResult object.
+
+    Returns:
+        List of VideoResult objects, one per input video, in completion order
+
+    Example:
+        >>> configs = [
+        ...     VideoConfig("video1.mp4", drop_height=0.40),
+        ...     VideoConfig("video2.mp4", drop_height=0.30, quality="accurate"),
+        ...     VideoConfig("video3.mp4", drop_height=0.50, output_video="debug3.mp4"),
+        ... ]
+        >>> results = process_videos_bulk(configs, max_workers=4)
+        >>> for result in results:
+        ...     if result.success:
+        ...         print(f"{result.video_path}: {result.metrics.jump_height_m:.3f}m")
+        ...     else:
+        ...         print(f"{result.video_path}: FAILED - {result.error}")
+    """
+    results: list[VideoResult] = []
+
+    # Use ProcessPoolExecutor for CPU-bound video processing
+    with ProcessPoolExecutor(max_workers=max_workers) as executor:
+        # Submit all jobs
+        future_to_config = {
+            executor.submit(_process_video_wrapper, config): config
+            for config in configs
+        }
+
+        # Process results as they complete
+        for future in as_completed(future_to_config):
+            config = future_to_config[future]
+            result: VideoResult
+
+            try:
+                result = future.result()
+            except Exception as exc:
+                # Handle unexpected errors
+                result = VideoResult(
+                    video_path=config.video_path,
+                    success=False,
+                    error=f"Unexpected error: {str(exc)}",
+                )
+
+            results.append(result)
+
+            # Call progress callback if provided
+            if progress_callback:
+                progress_callback(result)
+
+    return results
+
+
+def _process_video_wrapper(config: VideoConfig) -> VideoResult:
+    """
+    Wrapper function for parallel processing. Must be picklable (top-level function).
+
+    Args:
+        config: VideoConfig object with processing parameters
+
+    Returns:
+        VideoResult object with metrics or error information
+    """
+    start_time = time.time()
+
+    try:
+        metrics = process_video(
+            video_path=config.video_path,
+            drop_height=config.drop_height,
+            quality=config.quality,
+            output_video=config.output_video,
+            json_output=config.json_output,
+            drop_start_frame=config.drop_start_frame,
+            smoothing_window=config.smoothing_window,
+            velocity_threshold=config.velocity_threshold,
+            min_contact_frames=config.min_contact_frames,
+            visibility_threshold=config.visibility_threshold,
+            detection_confidence=config.detection_confidence,
+            tracking_confidence=config.tracking_confidence,
+            verbose=False,  # Disable verbose in parallel mode
+        )
+
+        processing_time = time.time() - start_time
+
+        return VideoResult(
+            video_path=config.video_path,
+            success=True,
+            metrics=metrics,
+            processing_time=processing_time,
+        )
+
+    except Exception as e:
+        processing_time = time.time() - start_time
+
+        return VideoResult(
+            video_path=config.video_path,
+            success=False,
+            error=str(e),
+            processing_time=processing_time,
+        )

kinemotion/dropjump/cli.py

@@ -1,5 +1,7 @@
 """Command-line interface for drop jump analysis."""
 
+import csv
+import glob
 import json
 import sys
 from pathlib import Path
@@ -8,6 +10,7 @@ from typing import Any
 import click
 import numpy as np
 
+from ..api import VideoConfig, VideoResult, process_videos_bulk
 from ..core.auto_tuning import (
     QualityPreset,
     analyze_video_sample,
@@ -25,7 +28,7 @@ from .kinematics import calculate_drop_jump_metrics
 
 
 @click.command(name="dropjump-analyze")
-@click.argument("video_path", type=click.Path(exists=True))
+@click.argument("video_path", nargs=-1, type=click.Path(exists=False), required=True)
 @click.option(
     "--output",
     "-o",
@@ -65,6 +68,34 @@ from .kinematics import calculate_drop_jump_metrics
     is_flag=True,
     help="Show auto-selected parameters and analysis details",
 )
+# Batch processing options
+@click.option(
+    "--batch",
+    is_flag=True,
+    help="Enable batch processing mode for multiple videos",
+)
+@click.option(
+    "--workers",
+    type=int,
+    default=4,
+    help="Number of parallel workers for batch processing (default: 4)",
+    show_default=True,
+)
+@click.option(
+    "--output-dir",
+    type=click.Path(),
+    help="Directory for debug video outputs (batch mode only)",
+)
+@click.option(
+    "--json-output-dir",
+    type=click.Path(),
+    help="Directory for JSON metrics outputs (batch mode only)",
+)
+@click.option(
+    "--csv-summary",
+    type=click.Path(),
+    help="Path for CSV summary export (batch mode only)",
+)
 # Expert parameters (hidden in help, but always available for advanced users)
 @click.option(
     "--drop-start-frame",
@@ -109,12 +140,17 @@ from .kinematics import calculate_drop_jump_metrics
     help="[EXPERT] Override pose tracking confidence",
 )
 def dropjump_analyze(
-    video_path: str,
+    video_path: tuple[str, ...],
     output: str | None,
     json_output: str | None,
     drop_height: float,
     quality: str,
     verbose: bool,
+    batch: bool,
+    workers: int,
+    output_dir: str | None,
+    json_output_dir: str | None,
+    csv_summary: str | None,
     drop_start_frame: int | None,
     smoothing_window: int | None,
     velocity_threshold: float | None,
@@ -124,13 +160,101 @@ def dropjump_analyze(
     tracking_confidence: float | None,
 ) -> None:
     """
-    Analyze drop-jump video to estimate ground contact time, flight time, and jump height.
+    Analyze drop-jump video(s) to estimate ground contact time, flight time, and jump height.
 
     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 to the input video file
+    VIDEO_PATH: Path(s) to video file(s). Supports glob patterns in batch mode
+    (e.g., "videos/*.mp4").
+
+    Examples:
+
+    \b
+    # Single video
+    kinemotion dropjump-analyze video.mp4 --drop-height 0.40
+
+    \b
+    # Batch mode with glob pattern
+    kinemotion dropjump-analyze videos/*.mp4 --batch --drop-height 0.40 --workers 4
+
+    \b
+    # Batch with output directories
+    kinemotion dropjump-analyze videos/*.mp4 --batch --drop-height 0.40 \\
+        --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():
+            # Direct path (not a glob pattern)
+            video_files.append(pattern)
+        else:
+            click.echo(f"Warning: No files found for pattern: {pattern}", err=True)
+
+    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
+
+    if use_batch:
+        _process_batch(
+            video_files,
+            drop_height,
+            quality,
+            workers,
+            output_dir,
+            json_output_dir,
+            csv_summary,
+            drop_start_frame,
+            smoothing_window,
+            velocity_threshold,
+            min_contact_frames,
+            visibility_threshold,
+            detection_confidence,
+            tracking_confidence,
+            verbose,
+        )
+    else:
+        # Single video mode (original behavior)
+        _process_single(
+            video_files[0],
+            output,
+            json_output,
+            drop_height,
+            quality,
+            verbose,
+            drop_start_frame,
+            smoothing_window,
+            velocity_threshold,
+            min_contact_frames,
+            visibility_threshold,
+            detection_confidence,
+            tracking_confidence,
+        )
+
+
+def _process_single(
+    video_path: str,
+    output: str | None,
+    json_output: str | None,
+    drop_height: float,
+    quality: str,
+    verbose: bool,
+    drop_start_frame: int | None,
+    smoothing_window: int | None,
+    velocity_threshold: float | None,
+    min_contact_frames: int | None,
+    visibility_threshold: float | None,
+    detection_confidence: float | None,
+    tracking_confidence: float | None,
+) -> None:
+    """Process a single video (original CLI behavior)."""
     click.echo(f"Analyzing video: {video_path}", err=True)
 
     # Convert quality string to enum
@@ -414,3 +538,194 @@ def dropjump_analyze(
     except Exception as e:
         click.echo(f"Error: {str(e)}", err=True)
         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,
+    drop_start_frame: int | None,
+    smoothing_window: int | None,
+    velocity_threshold: float | None,
+    min_contact_frames: int | None,
+    visibility_threshold: float | None,
+    detection_confidence: float | None,
+    tracking_confidence: float | None,
+    verbose: bool,
+) -> 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 if specified
+    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)
+
+    if json_output_dir:
+        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
+    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")
+
+        json_file = None
+        if json_output_dir:
+            json_file = str(Path(json_output_dir) / f"{video_name}.json")
+
+        config = VideoConfig(
+            video_path=video_file,
+            drop_height=drop_height,
+            quality=quality,
+            output_video=debug_video,
+            json_output=json_file,
+            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,
+        )
+        configs.append(config)
+
+    # 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
+    )
+
+    # Generate summary
+    click.echo("\n" + "=" * 70, err=True)
+    click.echo("BATCH PROCESSING SUMMARY", err=True)
+    click.echo("=" * 70, err=True)
+
+    successful = [r for r in results if r.success]
+    failed = [r for r in results if not r.success]
+
+    click.echo(f"Total videos: {len(results)}", err=True)
+    click.echo(f"Successful: {len(successful)}", err=True)
+    click.echo(f"Failed: {len(failed)}", err=True)
+
+    if successful:
+        # Calculate average metrics
+        with_gct = [
+            r
+            for r in successful
+            if r.metrics and r.metrics.ground_contact_time is not None
+        ]
+        with_flight = [
+            r for r in successful if r.metrics and r.metrics.flight_time is not None
+        ]
+        with_jump = [
+            r for r in successful if r.metrics and r.metrics.jump_height is not None
+        ]
+
+        if with_gct:
+            avg_gct = sum(r.metrics.ground_contact_time * 1000 for r in with_gct) / len(
+                with_gct
+            )
+            click.echo(f"\nAverage ground contact time: {avg_gct:.1f} ms", err=True)
+
+        if with_flight:
+            avg_flight = sum(r.metrics.flight_time * 1000 for r in with_flight) / len(
+                with_flight
+            )
+            click.echo(f"Average flight time: {avg_flight:.1f} ms", err=True)
+
+        if with_jump:
+            avg_jump = sum(r.metrics.jump_height for r in with_jump) / len(with_jump)
+            click.echo(
+                f"Average jump height: {avg_jump:.3f} m ({avg_jump * 100:.1f} cm)",
+                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)
+
+    click.echo("\nBatch processing complete!", err=True)

{kinemotion-0.8.3.dist-info → kinemotion-0.10.0.dist-info}/METADATA

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

@@ -1,4 +1,5 @@
-kinemotion/__init__.py,sha256=JhS0ZTgcTdcMH5WcIyWxEqZJPOoBUSKX8tT8hsG-xWk,98
+kinemotion/__init__.py,sha256=Z85xg29NA-r4IjrSbAkJpMFigyxACFGUb-37AiMp6YY,350
+kinemotion/api.py,sha256=3Hswx5lfyWc-EanS6iV-4MPUa_uB5t8BpGe4EB4gIIQ,15453
 kinemotion/cli.py,sha256=2IFA2_TE9a5zBtmGVzv5SnX39w7yPuBlw42dL7ca25U,402
 kinemotion/core/__init__.py,sha256=3yzDhb5PekDNjydqrs8aWGneUGJBt-lB0SoB_Y2FXqU,1010
 kinemotion/core/auto_tuning.py,sha256=cvmxUI-CbahpOJQtR2r5jOx4Q6yKPe3DO1o15hOQIdw,10508
@@ -8,11 +9,12 @@ kinemotion/core/smoothing.py,sha256=VVv95auiuah_GPG3jxiQPyiYXF5i3B4fF9UGI5FLX-Q,
 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=nhcqYClTx9R0XeTduJCNspltNgeaK4W8ZUT1ACB8GFI,15601
+kinemotion/dropjump/cli.py,sha256=Wc0Z3w8RBaozEQ-Oc8_zTIUrfsgRwhD97kH4P8ZozzQ,25759
 kinemotion/dropjump/debug_overlay.py,sha256=hmEtadqYP8K-kGr_Q03KDQyl1152-YSPeRJzEXMyuhs,8687
 kinemotion/dropjump/kinematics.py,sha256=RceIH2HndpHQpcOQd56MmEdXQNEst-CWXfBKPJk2g3Y,17659
-kinemotion-0.8.3.dist-info/METADATA,sha256=BM4Um2TVjiQKdQjPY4gdIRi1x2B7DuRuZlyFNpzNpvo,16318
-kinemotion-0.8.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-kinemotion-0.8.3.dist-info/entry_points.txt,sha256=zaqnAnjLvcdrk1Qvj5nvXZCZ2gp0prS7it1zTJygcIY,50
-kinemotion-0.8.3.dist-info/licenses/LICENSE,sha256=KZajvqsHw0NoOHOi2q0FZ4NBe9HdV6oey-IPYAtHXfg,1088
-kinemotion-0.8.3.dist-info/RECORD,,
+kinemotion/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kinemotion-0.10.0.dist-info/METADATA,sha256=mwCvLjVVaKjlIptGUxPKeQD5BH6IAs5luVm7OIUd1SU,16319
+kinemotion-0.10.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+kinemotion-0.10.0.dist-info/entry_points.txt,sha256=zaqnAnjLvcdrk1Qvj5nvXZCZ2gp0prS7it1zTJygcIY,50
+kinemotion-0.10.0.dist-info/licenses/LICENSE,sha256=KZajvqsHw0NoOHOi2q0FZ4NBe9HdV6oey-IPYAtHXfg,1088
+kinemotion-0.10.0.dist-info/RECORD,,