kinemotion 0.73.0__py3-none-any.whl → 0.75.0__py3-none-any.whl

kinemotion/core/video_io.py

@@ -50,9 +50,27 @@ class VideoProcessor:
         self._current_timestamp_ms: int = 0  # Timestamp for the current frame
 
         # Read first frame to get actual dimensions
-        # This is critical for preserving aspect ratio, especially with mobile videos
-        # that have rotation metadata. OpenCV properties (CAP_PROP_FRAME_WIDTH/HEIGHT)
-        # may return incorrect dimensions, so we read the actual frame data.
+        self._extract_dimensions_from_frame()
+
+        # Initialize metadata placeholders
+        self.rotation = 0  # Will be set by _extract_video_metadata()
+        self.codec: str | None = None  # Will be set by _extract_video_metadata()
+
+        # Initialize display dimensions (may be adjusted by SAR metadata)
+        self.display_width = self.width
+        self.display_height = self.height
+        self._extract_video_metadata()
+
+        # Apply rotation to dimensions if needed
+        self._apply_rotation_to_dimensions()
+
+    def _extract_dimensions_from_frame(self) -> None:
+        """Extract video dimensions by reading the first frame.
+
+        This is critical for preserving aspect ratio, especially with mobile videos
+        that have rotation metadata. OpenCV properties (CAP_PROP_FRAME_WIDTH/HEIGHT)
+        may return incorrect dimensions, so we read the actual frame data.
+        """
         ret, first_frame = self.cap.read()
         if ret:
             # frame.shape is (height, width, channels) - extract actual dimensions
@@ -63,22 +81,13 @@ class VideoProcessor:
             self.width = int(self.cap.get(cv2.CAP_PROP_FRAME_WIDTH))
             self.height = int(self.cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
 
-        # Extract rotation metadata from video (iPhones store rotation in
-        # side_data_list). OpenCV ignores rotation metadata, so we need to
-        # extract and apply it manually
-        self.rotation = 0  # Will be set by _extract_video_metadata()
-
-        # Extract codec information from video metadata
-        self.codec: str | None = None  # Will be set by _extract_video_metadata()
-
-        # Calculate display dimensions considering SAR (Sample Aspect Ratio)
-        # Mobile videos often have non-square pixels encoded in SAR metadata
-        # OpenCV doesn't directly expose SAR, but we need to handle display correctly
-        self.display_width = self.width
-        self.display_height = self.height
-        self._extract_video_metadata()
+    def _apply_rotation_to_dimensions(self) -> None:
+        """Swap width/height for 90/-90 degree rotations.
 
-        # Apply rotation to dimensions if needed
+        Extract rotation metadata from video (iPhones store rotation in
+        side_data_list). OpenCV ignores rotation metadata, so we need to
+        extract and apply it manually.
+        """
         if self.rotation in [90, -90, 270]:
             # Swap dimensions for 90/-90 degree rotations
             self.width, self.height = self.height, self.width

kinemotion/countermovement_jump/analysis.py

@@ -55,103 +55,6 @@ class CMJPhase(Enum):
     UNKNOWN = "unknown"
 
 
-@unused(
-    reason="Alternative implementation not called by pipeline",
-    since="0.34.0",
-)
-def find_standing_phase(
-    positions: FloatArray,
-    velocities: FloatArray,
-    fps: float,
-    min_standing_duration: float = 0.5,
-    velocity_threshold: float = 0.01,
-) -> int | None:
-    """
-    Find the end of standing phase (start of countermovement).
-
-    Looks for a period of low velocity (standing) followed by consistent
-    downward motion.
-
-    Args:
-        positions: Array of vertical positions (normalized 0-1)
-        velocities: Array of vertical velocities
-        fps: Video frame rate
-        min_standing_duration: Minimum standing duration in seconds (default: 0.5s)
-        velocity_threshold: Velocity threshold for standing detection
-
-    Returns:
-        Frame index where countermovement begins, or None if not detected.
-    """
-    min_standing_frames = int(fps * min_standing_duration)
-
-    if len(positions) < min_standing_frames:
-        return None
-
-    # Find periods of low velocity (standing)
-    is_standing = np.abs(velocities) < velocity_threshold
-
-    # Look for first sustained standing period
-    standing_count = 0
-    standing_end = None
-
-    for i in range(len(is_standing)):
-        if is_standing[i]:
-            standing_count += 1
-            if standing_count >= min_standing_frames:
-                standing_end = i
-        else:
-            if standing_end is not None:
-                # Found end of standing phase
-                return standing_end
-            standing_count = 0
-
-    return None
-
-
-@unused(
-    reason="Alternative implementation not called by pipeline",
-    since="0.34.0",
-)
-def find_countermovement_start(
-    velocities: FloatArray,
-    countermovement_threshold: float = 0.015,
-    min_eccentric_frames: int = 3,
-    standing_start: int | None = None,
-) -> int | None:
-    """
-    Find the start of countermovement (eccentric phase).
-
-    Detects when velocity becomes consistently positive (downward motion in
-    normalized coords).
-
-    Args:
-        velocities: Array of SIGNED vertical velocities
-        countermovement_threshold: Velocity threshold for detecting downward
-            motion (POSITIVE)
-        min_eccentric_frames: Minimum consecutive frames of downward motion
-        standing_start: Optional frame where standing phase ended
-
-    Returns:
-        Frame index where countermovement begins, or None if not detected.
-    """
-    start_frame = standing_start if standing_start is not None else 0
-
-    # Look for sustained downward velocity (POSITIVE in normalized coords)
-    is_downward = velocities[start_frame:] > countermovement_threshold
-    consecutive_count = 0
-
-    for i in range(len(is_downward)):
-        if is_downward[i]:
-            consecutive_count += 1
-            if consecutive_count >= min_eccentric_frames:
-                # Found start of eccentric phase
-                return start_frame + i - consecutive_count + 1
-        else:
-            consecutive_count = 0
-
-    return None
-
-
 def find_lowest_point(
     positions: FloatArray,
     velocities: FloatArray,

kinemotion/countermovement_jump/api.py

@@ -393,6 +393,24 @@ class CMJVideoConfig:
     overrides: AnalysisOverrides | None = None
     detection_confidence: float | None = None
     tracking_confidence: float | None = None
+    verbose: bool = False
+    timer: Timer | None = None
+    pose_tracker: "MediaPipePoseTracker | None" = None
+
+    def to_kwargs(self) -> dict:
+        """Convert config to kwargs dict for process_cmj_video."""
+        return {
+            "video_path": self.video_path,
+            "quality": self.quality,
+            "output_video": self.output_video,
+            "json_output": self.json_output,
+            "overrides": self.overrides,
+            "detection_confidence": self.detection_confidence,
+            "tracking_confidence": self.tracking_confidence,
+            "verbose": self.verbose,
+            "timer": self.timer,
+            "pose_tracker": self.pose_tracker,
+        }
 
 
 @dataclass
@@ -511,6 +529,23 @@ def process_cmj_video(
             return metrics
 
 
+def process_cmj_video_from_config(
+    config: CMJVideoConfig,
+) -> CMJMetrics:
+    """Process a CMJ video using a configuration object.
+
+    This is a convenience wrapper around process_cmj_video that
+    accepts a CMJVideoConfig instead of individual parameters.
+
+    Args:
+        config: Configuration object containing all analysis parameters
+
+    Returns:
+        CMJMetrics object containing analysis results
+    """
+    return process_cmj_video(**config.to_kwargs())
+
+
 def process_cmj_videos_bulk(
     configs: list[CMJVideoConfig],
     max_workers: int = 4,
@@ -537,17 +572,8 @@ def _process_cmj_video_wrapper(config: CMJVideoConfig) -> CMJVideoResult:
     start_time = time.perf_counter()
 
     try:
-        metrics = process_cmj_video(
-            video_path=config.video_path,
-            quality=config.quality,
-            output_video=config.output_video,
-            json_output=config.json_output,
-            overrides=config.overrides,
-            detection_confidence=config.detection_confidence,
-            tracking_confidence=config.tracking_confidence,
-            verbose=False,
-        )
-
+        # Use convenience wrapper to avoid parameter unpacking
+        metrics = process_cmj_video_from_config(config)
         processing_time = time.perf_counter() - start_time
 
         return CMJVideoResult(

kinemotion/countermovement_jump/cli.py

@@ -8,9 +8,12 @@ import click
 
 from ..core.auto_tuning import QualityPreset
 from ..core.cli_utils import (
+    batch_processing_options,
     collect_video_files,
     common_output_options,
     generate_batch_output_paths,
+    quality_option,
+    verbose_option,
 )
 from .api import AnalysisOverrides, process_cmj_video
 from .kinematics import CMJMetrics
@@ -59,52 +62,9 @@ def _process_batch_videos(
 @click.command(name="cmj-analyze")
 @click.argument("video_path", nargs=-1, type=click.Path(exists=False), required=True)
 @common_output_options
-@click.option(
-    "--quality",
-    type=click.Choice(["fast", "balanced", "accurate"], case_sensitive=False),
-    default="balanced",
-    help=(
-        "Analysis quality preset: "
-        "fast (quick, less precise), "
-        "balanced (default, good for most cases), "
-        "accurate (research-grade, slower)"
-    ),
-    show_default=True,
-)
-@click.option(
-    "--verbose",
-    "-v",
-    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)",
-)
+@quality_option
+@verbose_option
+@batch_processing_options
 # Expert parameters (hidden in help, but always available for advanced users)
 @click.option(
     "--smoothing-window",