kinemotion 0.12.2__py3-none-any.whl → 0.12.3__py3-none-any.whl

kinemotion/core/auto_tuning.py

@@ -216,6 +216,59 @@ def auto_tune_parameters(
     )
 
 
+def _collect_foot_visibility_and_positions(
+    frame_landmarks: dict[str, tuple[float, float, float]],
+) -> tuple[list[float], list[float]]:
+    """
+    Collect visibility scores and Y positions from foot landmarks.
+
+    Args:
+        frame_landmarks: Landmarks for a single frame
+
+    Returns:
+        Tuple of (visibility_scores, y_positions)
+    """
+    foot_keys = [
+        "left_ankle",
+        "right_ankle",
+        "left_heel",
+        "right_heel",
+        "left_foot_index",
+        "right_foot_index",
+    ]
+
+    frame_vis = []
+    frame_y_positions = []
+
+    for key in foot_keys:
+        if key in frame_landmarks:
+            _, y, vis = frame_landmarks[key]  # x not needed for analysis
+            frame_vis.append(vis)
+            frame_y_positions.append(y)
+
+    return frame_vis, frame_y_positions
+
+
+def _check_stable_period(positions: list[float]) -> bool:
+    """
+    Check if video has a stable period at the start.
+
+    A stable period (low variance in first 30 frames) indicates
+    the subject is standing on an elevated platform before jumping.
+
+    Args:
+        positions: List of average Y positions per frame
+
+    Returns:
+        True if stable period detected, False otherwise
+    """
+    if len(positions) < 30:
+        return False
+
+    first_30_std = float(np.std(positions[:30]))
+    return first_30_std < 0.01  # Very stable = on platform
+
+
 def analyze_video_sample(
     landmarks_sequence: list[dict[str, tuple[float, float, float]] | None],
     fps: float,
@@ -235,35 +288,22 @@ def analyze_video_sample(
     Returns:
         VideoCharacteristics with analyzed properties
     """
-    # Calculate average landmark visibility
     visibilities = []
     positions = []
 
+    # Collect visibility and position data from all frames
     for frame_landmarks in landmarks_sequence:
-        if frame_landmarks:
-            # Collect visibility scores from foot landmarks
-            foot_keys = [
-                "left_ankle",
-                "right_ankle",
-                "left_heel",
-                "right_heel",
-                "left_foot_index",
-                "right_foot_index",
-            ]
-
-            frame_vis = []
-            frame_y_positions = []
-
-            for key in foot_keys:
-                if key in frame_landmarks:
-                    _, y, vis = frame_landmarks[key]  # x not needed for analysis
-                    frame_vis.append(vis)
-                    frame_y_positions.append(y)
-
-            if frame_vis:
-                visibilities.append(float(np.mean(frame_vis)))
-            if frame_y_positions:
-                positions.append(float(np.mean(frame_y_positions)))
+        if not frame_landmarks:
+            continue
+
+        frame_vis, frame_y_positions = _collect_foot_visibility_and_positions(
+            frame_landmarks
+        )
+
+        if frame_vis:
+            visibilities.append(float(np.mean(frame_vis)))
+        if frame_y_positions:
+            positions.append(float(np.mean(frame_y_positions)))
 
     # Compute metrics
     avg_visibility = float(np.mean(visibilities)) if visibilities else 0.5
@@ -273,11 +313,7 @@ def analyze_video_sample(
     tracking_quality = analyze_tracking_quality(avg_visibility)
 
     # Check for stable period (indicates drop jump from elevated platform)
-    # Simple check: do first 30 frames have low variance?
-    has_stable_period = False
-    if len(positions) >= 30:
-        first_30_std = float(np.std(positions[:30]))
-        has_stable_period = first_30_std < 0.01  # Very stable = on platform
+    has_stable_period = _check_stable_period(positions)
 
     return VideoCharacteristics(
         fps=fps,

kinemotion/core/video_io.py

@@ -65,6 +65,43 @@ class VideoProcessor:
                 self.display_width,
             )
 
+    def _parse_sample_aspect_ratio(self, sar_str: str) -> None:
+        """
+        Parse SAR string and update display dimensions.
+
+        Args:
+            sar_str: SAR string in format "width:height" (e.g., "270:473")
+        """
+        if not sar_str or ":" not in sar_str:
+            return
+
+        sar_parts = sar_str.split(":")
+        sar_width = int(sar_parts[0])
+        sar_height = int(sar_parts[1])
+
+        # Calculate display dimensions if pixels are non-square
+        # DAR = (width * SAR_width) / (height * SAR_height)
+        if sar_width != sar_height:
+            self.display_width = int(self.width * sar_width / sar_height)
+            self.display_height = self.height
+
+    def _extract_rotation_from_stream(self, stream: dict) -> int:  # type: ignore[type-arg]
+        """
+        Extract rotation metadata from video stream.
+
+        Args:
+            stream: ffprobe stream dictionary
+
+        Returns:
+            Rotation angle in degrees (0, 90, -90, 180)
+        """
+        side_data_list = stream.get("side_data_list", [])
+        for side_data in side_data_list:
+            if side_data.get("side_data_type") == "Display Matrix":
+                rotation = side_data.get("rotation", 0)
+                return int(rotation)
+        return 0
+
     def _extract_video_metadata(self) -> None:
         """
         Extract video metadata including SAR and rotation using ffprobe.
@@ -94,35 +131,22 @@ class VideoProcessor:
                 timeout=5,
             )
 
-            if result.returncode == 0:
-                data = json.loads(result.stdout)
-                if "streams" in data and len(data["streams"]) > 0:
-                    stream = data["streams"][0]
-
-                    # Extract SAR (Sample Aspect Ratio)
-                    sar_str = stream.get("sample_aspect_ratio", "1:1")
-
-                    # Parse SAR (e.g., "270:473")
-                    if sar_str and ":" in sar_str:
-                        sar_parts = sar_str.split(":")
-                        sar_width = int(sar_parts[0])
-                        sar_height = int(sar_parts[1])
-
-                        # Calculate display dimensions
-                        # DAR = (width * SAR_width) / (height * SAR_height)
-                        if sar_width != sar_height:
-                            self.display_width = int(
-                                self.width * sar_width / sar_height
-                            )
-                            self.display_height = self.height
-
-                    # Extract rotation from side_data_list (common for iPhone videos)
-                    side_data_list = stream.get("side_data_list", [])
-                    for side_data in side_data_list:
-                        if side_data.get("side_data_type") == "Display Matrix":
-                            rotation = side_data.get("rotation", 0)
-                            # Convert to int and normalize to 0, 90, -90, 180
-                            self.rotation = int(rotation)
+            if result.returncode != 0:
+                return
+
+            data = json.loads(result.stdout)
+            if "streams" not in data or len(data["streams"]) == 0:
+                return
+
+            stream = data["streams"][0]
+
+            # Extract and parse SAR (Sample Aspect Ratio)
+            sar_str = stream.get("sample_aspect_ratio", "1:1")
+            self._parse_sample_aspect_ratio(sar_str)
+
+            # Extract rotation from side_data_list (common for iPhone videos)
+            self.rotation = self._extract_rotation_from_stream(stream)
+
         except (subprocess.TimeoutExpired, FileNotFoundError, json.JSONDecodeError):
             # If ffprobe fails, keep original dimensions (square pixels)
             pass

kinemotion/dropjump/analysis.py

@@ -752,3 +752,39 @@ def compute_average_foot_position(
         return (0.5, 0.5)  # Default to center if no visible feet
 
     return (float(np.mean(x_positions)), float(np.mean(y_positions)))
+
+
+def extract_foot_positions_and_visibilities(
+    smoothed_landmarks: list[dict[str, tuple[float, float, float]] | None],
+) -> tuple[np.ndarray, np.ndarray]:
+    """
+    Extract vertical positions and average visibilities from smoothed landmarks.
+
+    This utility function eliminates code duplication between CLI and programmatic usage.
+
+    Args:
+        smoothed_landmarks: Smoothed landmark sequence from tracking
+
+    Returns:
+        Tuple of (vertical_positions, visibilities) as numpy arrays
+    """
+    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:
+            # Fill missing frames with last known position or default
+            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)

kinemotion/dropjump/cli.py

@@ -28,8 +28,8 @@ from ..core.pose import PoseTracker
 from ..core.video_io import VideoProcessor
 from .analysis import (
     ContactState,
-    compute_average_foot_position,
     detect_ground_contact,
+    extract_foot_positions_and_visibilities,
 )
 from .debug_overlay import DebugOverlayRenderer
 from .kinematics import DropJumpMetrics, calculate_drop_jump_metrics
@@ -258,26 +258,7 @@ def _extract_positions_and_visibilities(
         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)
+    return extract_foot_positions_and_visibilities(smoothed_landmarks)
 
 
 def _create_debug_video(
@@ -567,6 +548,63 @@ 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: VideoResult) -> 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]
 ) -> None:
@@ -600,40 +638,7 @@ 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)
 

{kinemotion-0.12.2.dist-info → kinemotion-0.12.3.dist-info}/METADATA

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

@@ -8,21 +8,21 @@ kinemotion/cmj/debug_overlay.py,sha256=D-y2FQKI01KY0WXFKTKg6p9Qj3AkXCE7xjau3Ais0
 kinemotion/cmj/joint_angles.py,sha256=8ucpDGPvbt4iX3tx9eVxJEUv0laTm2Y58_--VzJCogE,9113
 kinemotion/cmj/kinematics.py,sha256=Xl_PlC2OqMoA-zOc3SRB_GqI0AgLlJol5FTPe5J_qLc,7573
 kinemotion/core/__init__.py,sha256=3yzDhb5PekDNjydqrs8aWGneUGJBt-lB0SoB_Y2FXqU,1010
-kinemotion/core/auto_tuning.py,sha256=cvmxUI-CbahpOJQtR2r5jOx4Q6yKPe3DO1o15hOQIdw,10508
+kinemotion/core/auto_tuning.py,sha256=j6cul_qC6k0XyryCG93C1AWH2MKPj3UBMzuX02xaqfI,11235
 kinemotion/core/cli_utils.py,sha256=Pq1JF7yvK1YbH0tOUWKjplthCbWsJQt4Lv7esPYH4FM,7254
 kinemotion/core/debug_overlay_utils.py,sha256=TyUb5okv5qw8oeaX3jsUO_kpwf1NnaHEAOTm-8LwTno,4587
 kinemotion/core/filtering.py,sha256=f-m-aA59e4WqE6u-9MA51wssu7rI-Y_7n1cG8IWdeRQ,11241
 kinemotion/core/pose.py,sha256=ztemdZ_ysVVK3gbXabm8qS_dr1VfJX9KZjmcO-Z-iNE,8532
 kinemotion/core/smoothing.py,sha256=C9GK3PAN16RpqJw2UWeVslSTJZEvALeVADjtnJnSF88,14240
-kinemotion/core/video_io.py,sha256=UtmUndw22uFnZBK_BmeE912yRYH1YnU_P8LjuN33DPc,6461
+kinemotion/core/video_io.py,sha256=kH5FYPx3y3lFZ3ybdgxaZfKPdHJ37eqxSeAaZjyQnJk,6817
 kinemotion/dropjump/__init__.py,sha256=yc1XiZ9vfo5h_n7PKVSiX2TTgaIfGL7Y7SkQtiDZj_E,838
-kinemotion/dropjump/analysis.py,sha256=PoBzlqciBFB_O7ejdjBhpnk19a_VoD31tDjXuN1-ovo,25764
-kinemotion/dropjump/cli.py,sha256=90GddzgMLwEKKwcG0VW94HeXFwEK5zSJm6w6UkPbaRk,21646
+kinemotion/dropjump/analysis.py,sha256=xx5NWy6s0eb9BEyO_FByY1Ahunaoh3TyaTAxjlPrvxg,27153
+kinemotion/dropjump/cli.py,sha256=Oni7gntysA6Zwb_ehsAnk6Ytd2ofUhN0yXVCsCsiris,21196
 kinemotion/dropjump/debug_overlay.py,sha256=LkPw6ucb7beoYWS4L-Lvjs1KLCm5wAWDAfiznUeV2IQ,5668
 kinemotion/dropjump/kinematics.py,sha256=txDxpDti3VJVctWGbe3aIrlIx83UY8-ynzlX01TOvTA,15577
 kinemotion/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kinemotion-0.12.2.dist-info/METADATA,sha256=FE1-EfYL73UDQE9xBj-qRCQ51PN6F1SylDmVJrt974s,18990
-kinemotion-0.12.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-kinemotion-0.12.2.dist-info/entry_points.txt,sha256=zaqnAnjLvcdrk1Qvj5nvXZCZ2gp0prS7it1zTJygcIY,50
-kinemotion-0.12.2.dist-info/licenses/LICENSE,sha256=KZajvqsHw0NoOHOi2q0FZ4NBe9HdV6oey-IPYAtHXfg,1088
-kinemotion-0.12.2.dist-info/RECORD,,
+kinemotion-0.12.3.dist-info/METADATA,sha256=rbD5mEdFYxRAlAbmaobBcrnMaFh0mFd2L3GyHipRlGY,18990
+kinemotion-0.12.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+kinemotion-0.12.3.dist-info/entry_points.txt,sha256=zaqnAnjLvcdrk1Qvj5nvXZCZ2gp0prS7it1zTJygcIY,50
+kinemotion-0.12.3.dist-info/licenses/LICENSE,sha256=KZajvqsHw0NoOHOi2q0FZ4NBe9HdV6oey-IPYAtHXfg,1088
+kinemotion-0.12.3.dist-info/RECORD,,