kinemotion 0.10.6__py3-none-any.whl → 0.67.0__py3-none-any.whl

kinemotion/dropjump/cli.py

@@ -1,36 +1,23 @@
 """Command-line interface for drop jump analysis."""
 
 import csv
-import glob
 import json
 import sys
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any
 
 import click
-import numpy as np
 
-from ..api import VideoConfig, VideoResult, process_videos_bulk
-from ..core.auto_tuning import (
-    AnalysisParameters as AutoTunedParams,
+from ..core.cli_utils import (
+    collect_video_files,
+    generate_batch_output_paths,
 )
-from ..core.auto_tuning import (
-    QualityPreset,
-    VideoCharacteristics,
-    analyze_video_sample,
-    auto_tune_parameters,
+from .api import (
+    DropJumpVideoConfig,
+    DropJumpVideoResult,
+    process_dropjump_video,
+    process_dropjump_videos_bulk,
 )
-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 DropJumpMetrics, calculate_drop_jump_metrics
 
 
 @dataclass
@@ -60,15 +47,6 @@ class AnalysisParameters:
     type=click.Path(),
     help="Path for JSON metrics output (default: stdout)",
 )
-@click.option(
-    "--drop-height",
-    type=float,
-    required=True,
-    help=(
-        "Height of drop box/platform in meters (e.g., 0.40 for 40cm box) - "
-        "REQUIRED for accurate calibration"
-    ),
-)
 @click.option(
     "--quality",
     type=click.Choice(["fast", "balanced", "accurate"], case_sensitive=False),
@@ -158,11 +136,11 @@ class AnalysisParameters:
     default=None,
     help="[EXPERT] Override pose tracking confidence",
 )
-def dropjump_analyze(
+def dropjump_analyze(  # NOSONAR(S107) - Click CLI requires individual
+    # parameters for each option
     video_path: tuple[str, ...],
     output: str | None,
     json_output: str | None,
-    drop_height: float,
     quality: str,
     verbose: bool,
     batch: bool,
@@ -179,10 +157,12 @@ def dropjump_analyze(
     tracking_confidence: float | None,
 ) -> None:
     """
-    Analyze drop-jump video(s) 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.
+    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
     (e.g., "videos/*.mp4").
@@ -191,28 +171,19 @@ def dropjump_analyze(
 
     \b
     # Single video
-    kinemotion dropjump-analyze video.mp4 --drop-height 0.40
+    kinemotion dropjump-analyze video.mp4
 
     \b
     # Batch mode with glob pattern
-    kinemotion dropjump-analyze videos/*.mp4 --batch --drop-height 0.40 --workers 4
+    kinemotion dropjump-analyze videos/*.mp4 --batch --workers 4
 
     \b
     # Batch with output directories
-    kinemotion dropjump-analyze videos/*.mp4 --batch --drop-height 0.40 \\
+    kinemotion dropjump-analyze videos/*.mp4 --batch \
         --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)
+    video_files = collect_video_files(video_path)
 
     if not video_files:
         click.echo("Error: No video files found", err=True)
@@ -222,7 +193,7 @@ def dropjump_analyze(
     use_batch = batch or len(video_files) > 1
 
     # Group expert parameters
-    params = AnalysisParameters(
+    expert_params = AnalysisParameters(
         drop_start_frame=drop_start_frame,
         smoothing_window=smoothing_window,
         velocity_threshold=velocity_threshold,
@@ -235,13 +206,12 @@ def dropjump_analyze(
     if use_batch:
         _process_batch(
             video_files,
-            drop_height,
             quality,
             workers,
             output_dir,
             json_output_dir,
             csv_summary,
-            params,
+            expert_params,
         )
     else:
         # Single video mode (original behavior)
@@ -249,377 +219,74 @@ def dropjump_analyze(
             video_files[0],
             output,
             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,
     json_output: str | None,
-    drop_height: float,
     quality: str,
     verbose: bool,
     expert_params: AnalysisParameters,
 ) -> None:
-    """Process a single video (original CLI behavior)."""
+    """Process a single video by calling the API."""
     click.echo(f"Analyzing video: {video_path}", err=True)
 
-    quality_preset = QualityPreset(quality.lower())
-
     try:
-        with VideoProcessor(video_path) as video:
-            click.echo(
-                f"Video: {video.width}x{video.height} @ {video.fps:.2f} fps, "
-                f"{video.frame_count} frames",
-                err=True,
-            )
-
-            # Determine confidence levels
-            detection_conf, tracking_conf = _determine_initial_confidence(
-                quality_preset, expert_params
-            )
-
-            # 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)
-
-            # Auto-tune parameters
-            characteristics = analyze_video_sample(
-                landmarks_sequence, video.fps, video.frame_count
-            )
-            params = auto_tune_parameters(characteristics, quality_preset)
-            params = _apply_expert_param_overrides(params, expert_params)
-
-            # Show parameters if verbose
-            if verbose:
-                _print_auto_tuned_params(video, characteristics, quality_preset, params)
-
-            # Apply smoothing
-            smoothed_landmarks = _smooth_landmark_sequence(landmarks_sequence, params)
+        # Create AnalysisOverrides if any expert parameters are set
+        from .api import AnalysisOverrides
 
-            # Extract positions
-            vertical_positions, visibilities = _extract_positions_and_visibilities(
-                smoothed_landmarks
-            )
-
-            # 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
-            click.echo("Calculating metrics...", err=True)
-            click.echo(
-                f"Using drop height calibration: {drop_height}m ({drop_height*100:.0f}cm)",
-                err=True,
-            )
-            metrics = calculate_drop_jump_metrics(
-                contact_states,
-                vertical_positions,
-                video.fps,
-                drop_height_m=drop_height,
-                drop_start_frame=expert_params.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,
+        overrides = None
+        if any(
+            [
+                expert_params.smoothing_window is not None,
+                expert_params.velocity_threshold is not None,
+                expert_params.min_contact_frames is not None,
+                expert_params.visibility_threshold is not None,
+            ]
+        ):
+            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,
             )
 
-            # Output metrics
-            metrics_json = json.dumps(metrics.to_dict(), indent=2)
-            if json_output:
-                Path(json_output).write_text(metrics_json)
-                click.echo(f"Metrics written to: {json_output}", err=True)
-            else:
-                click.echo(metrics_json)
+        # Call the API function (handles all processing logic)
+        metrics = process_dropjump_video(
+            video_path=video_path,
+            quality=quality,
+            output_video=output,
+            json_output=json_output,
+            drop_start_frame=expert_params.drop_start_frame,
+            overrides=overrides,
+            detection_confidence=expert_params.detection_confidence,
+            tracking_confidence=expert_params.tracking_confidence,
+            verbose=verbose,
+        )
 
-            # Generate debug video if requested
-            if output:
-                _create_debug_video(
-                    output, video, frames, smoothed_landmarks, contact_states, metrics
-                )
+        # Print formatted summary to stdout if no JSON output specified
+        if not json_output:
+            click.echo(json.dumps(metrics.to_dict(), indent=2))
 
-            click.echo("Analysis complete!", err=True)
+        click.echo("Analysis complete!", err=True)
 
     except Exception as e:
         click.echo(f"Error: {str(e)}", err=True)
+        if verbose:
+            import traceback
+
+            traceback.print_exc()
         sys.exit(1)
 
 
 def _setup_batch_output_dirs(
-    output_dir: str | None, json_output_dir: str | None
+    output_dir: str | None,
+    json_output_dir: str | None,
 ) -> None:
     """Create output directories for batch processing.
 
@@ -638,48 +305,55 @@ def _setup_batch_output_dirs(
 
 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]:
+) -> list[DropJumpVideoConfig]:
     """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
+        List of DropJumpVideoConfig objects
     """
-    configs: list[VideoConfig] = []
+    configs: list[DropJumpVideoConfig] = []
     for video_file in video_files:
-        video_name = Path(video_file).stem
+        debug_video, json_file = generate_batch_output_paths(
+            video_file, output_dir, json_output_dir
+        )
 
-        debug_video = None
-        if output_dir:
-            debug_video = str(Path(output_dir) / f"{video_name}_debug.mp4")
+        # Create AnalysisOverrides if any expert parameters are set
+        from .api import AnalysisOverrides
 
-        json_file = None
-        if json_output_dir:
-            json_file = str(Path(json_output_dir) / f"{video_name}.json")
+        overrides = None
+        if any(
+            [
+                expert_params.smoothing_window is not None,
+                expert_params.velocity_threshold is not None,
+                expert_params.min_contact_frames is not None,
+                expert_params.visibility_threshold is not None,
+            ]
+        ):
+            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,
+            )
 
-        config = VideoConfig(
+        config = DropJumpVideoConfig(
             video_path=video_file,
-            drop_height=drop_height,
             quality=quality,
             output_video=debug_video,
             json_output=json_file,
             drop_start_frame=expert_params.drop_start_frame,
-            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,
+            overrides=overrides,
             detection_confidence=expert_params.detection_confidence,
             tracking_confidence=expert_params.tracking_confidence,
         )
@@ -688,7 +362,7 @@ def _create_video_configs(
     return configs
 
 
-def _compute_batch_statistics(results: list[VideoResult]) -> None:
+def _compute_batch_statistics(results: list[DropJumpVideoResult]) -> None:
     """Compute and display batch processing statistics.
 
     Args:
@@ -708,16 +382,10 @@ def _compute_batch_statistics(results: list[VideoResult]) -> None:
     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
+            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(
@@ -747,8 +415,67 @@ def _compute_batch_statistics(results: list[VideoResult]) -> None:
             )
 
 
+def _format_time_metric(value: float | None, multiplier: float = 1000.0) -> str:
+    """Format time metric for CSV output.
+
+    Args:
+        value: Time value in seconds
+        multiplier: Multiplier to convert to milliseconds (default: 1000.0)
+
+    Returns:
+        Formatted string or "N/A" if value is None
+    """
+    return f"{value * multiplier:.1f}" if value is not None else "N/A"
+
+
+def _format_distance_metric(value: float | None) -> str:
+    """Format distance metric for CSV output.
+
+    Args:
+        value: Distance value in meters
+
+    Returns:
+        Formatted string or "N/A" if value is None
+    """
+    return f"{value:.3f}" if value is not None else "N/A"
+
+
+def _create_csv_row_from_result(result: DropJumpVideoResult) -> list[str]:
+    """Create CSV row from video processing result.
+
+    Args:
+        result: Video processing result
+
+    Returns:
+        List of formatted values for CSV row
+    """
+    video_name = Path(result.video_path).name
+    processing_time = f"{result.processing_time:.2f}"
+
+    if result.success and result.metrics:
+        return [
+            video_name,
+            _format_time_metric(result.metrics.ground_contact_time),
+            _format_time_metric(result.metrics.flight_time),
+            _format_distance_metric(result.metrics.jump_height),
+            processing_time,
+            "Success",
+        ]
+    else:
+        return [
+            video_name,
+            "N/A",
+            "N/A",
+            "N/A",
+            processing_time,
+            f"Failed: {result.error}",
+        ]
+
+
 def _write_csv_summary(
-    csv_summary: str | None, results: list[VideoResult], successful: list[VideoResult]
+    csv_summary: str | None,
+    results: list[DropJumpVideoResult],
+    successful: list[DropJumpVideoResult],
 ) -> None:
     """Write CSV summary of batch processing results.
 
@@ -780,47 +507,13 @@ def _write_csv_summary(
 
         # 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}",
-                    ]
-                )
+            writer.writerow(_create_csv_row_from_result(result))
 
     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,
@@ -829,9 +522,7 @@ def _process_batch(
     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(f"\nBatch processing {len(video_files)} videos with {workers} workers", err=True)
     click.echo("=" * 70, err=True)
 
     # Setup output directories
@@ -839,20 +530,19 @@ def _process_batch(
 
     # Create video configurations
     configs = _create_video_configs(
-        video_files, drop_height, quality, output_dir, json_output_dir, expert_params
+        video_files, quality, output_dir, json_output_dir, expert_params
     )
 
     # Progress callback
     completed = 0
 
-    def show_progress(result: VideoResult) -> None:
+    def show_progress(result: DropJumpVideoResult) -> 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)",
+            f"[{completed}/{len(configs)}] {status} {video_name} ({result.processing_time:.1f}s)",
             err=True,
         )
         if not result.success:
@@ -860,7 +550,7 @@ def _process_batch(
 
     # Process all videos
     click.echo("\nProcessing videos...", err=True)
-    results = process_videos_bulk(
+    results = process_dropjump_videos_bulk(
         configs, max_workers=workers, progress_callback=show_progress
     )