kinemotion 0.26.0__tar.gz → 0.27.0__tar.gz

{kinemotion-0.26.0 → kinemotion-0.27.0}/CHANGELOG.md

@@ -7,6 +7,22 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 <!-- version list -->
 
+## v0.27.0 (2025-11-14)
+
+### Features
+
+- Extract video codec from metadata
+  ([`52c7ff2`](https://github.com/feniix/kinemotion/commit/52c7ff2ee3f6620a5271f670ab60e6bca8bc38fb))
+
+
+## v0.26.1 (2025-11-14)
+
+### Bug Fixes
+
+- Reduce cognitive complexity in ground contact detection and API
+  ([`57f0424`](https://github.com/feniix/kinemotion/commit/57f0424043e4f15540851157220133e7361213a1))
+
+
 ## v0.26.0 (2025-11-14)
 
 ### Features

{kinemotion-0.26.0 → kinemotion-0.27.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kinemotion
-Version: 0.26.0
+Version: 0.27.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.26.0 → kinemotion-0.27.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kinemotion"
-version = "0.26.0"
+version = "0.27.0"
 description = "Video-based kinematic analysis for athletic performance"
 readme = "README.md"
 requires-python = ">=3.10,<3.13"

{kinemotion-0.26.0 → kinemotion-0.27.0}/src/kinemotion/api.py

@@ -244,6 +244,20 @@ def _apply_smoothing(
         )
 
 
+def _calculate_foot_visibility(frame_landmarks: dict) -> float:
+    """Calculate average visibility of foot landmarks.
+
+    Args:
+        frame_landmarks: Dictionary of landmarks for a frame
+
+    Returns:
+        Average visibility value (0-1)
+    """
+    foot_keys = ["left_ankle", "right_ankle", "left_heel", "right_heel"]
+    foot_vis = [frame_landmarks[key][2] for key in foot_keys if key in frame_landmarks]
+    return float(np.mean(foot_vis)) if foot_vis else 0.0
+
+
 def _extract_vertical_positions(
     smoothed_landmarks: list,
 ) -> tuple[np.ndarray, np.ndarray]:
@@ -262,13 +276,7 @@ def _extract_vertical_positions(
         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)
+            visibilities_list.append(_calculate_foot_visibility(frame_landmarks))
         else:
             position_list.append(position_list[-1] if position_list else 0.5)
             visibilities_list.append(0.0)
@@ -524,7 +532,7 @@ def process_dropjump_video(
             height=video.height,
             duration_s=video.frame_count / video.fps,
             frame_count=video.frame_count,
-            codec=None,
+            codec=video.codec,
         )
 
         processing_info = ProcessingInfo(
@@ -965,7 +973,7 @@ def process_cmj_video(
             height=video.height,
             duration_s=video.frame_count / video.fps,
             frame_count=video.frame_count,
-            codec=None,  # TODO: Extract from video metadata if available
+            codec=video.codec,
         )
 
         processing_info = ProcessingInfo(

{kinemotion-0.26.0 → kinemotion-0.27.0}/src/kinemotion/core/video_io.py

@@ -50,6 +50,9 @@ class VideoProcessor:
         # 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
@@ -141,6 +144,9 @@ class VideoProcessor:
 
             stream = data["streams"][0]
 
+            # Extract codec name (e.g., "h264", "hevc", "vp9")
+            self.codec = stream.get("codec_name")
+
             # Extract and parse SAR (Sample Aspect Ratio)
             sar_str = stream.get("sample_aspect_ratio", "1:1")
             self._parse_sample_aspect_ratio(sar_str)

{kinemotion-0.26.0 → kinemotion-0.27.0}/src/kinemotion/dropjump/analysis.py

@@ -235,6 +235,86 @@ def detect_drop_start(
     )
 
 
+def _filter_stationary_with_visibility(
+    is_stationary: np.ndarray,
+    visibilities: np.ndarray | None,
+    visibility_threshold: float,
+) -> np.ndarray:
+    """Apply visibility filter to stationary flags.
+
+    Args:
+        is_stationary: Boolean array indicating stationary frames
+        visibilities: Optional visibility scores for each frame
+        visibility_threshold: Minimum visibility to trust landmark
+
+    Returns:
+        Filtered is_stationary array
+    """
+    if visibilities is not None:
+        is_visible = visibilities > visibility_threshold
+        return is_stationary & is_visible
+    return is_stationary
+
+
+def _find_contact_frames(
+    is_stationary: np.ndarray,
+    min_contact_frames: int,
+) -> set[int]:
+    """Find frames with sustained contact using minimum duration filter.
+
+    Args:
+        is_stationary: Boolean array indicating stationary frames
+        min_contact_frames: Minimum consecutive frames to confirm contact
+
+    Returns:
+        Set of frame indices that meet minimum contact duration
+    """
+    contact_frames: set[int] = set()
+    current_run = []
+
+    for i, stationary in enumerate(is_stationary):
+        if stationary:
+            current_run.append(i)
+        else:
+            if len(current_run) >= min_contact_frames:
+                contact_frames.update(current_run)
+            current_run = []
+
+    # Handle last run
+    if len(current_run) >= min_contact_frames:
+        contact_frames.update(current_run)
+
+    return contact_frames
+
+
+def _assign_contact_states(
+    n_frames: int,
+    contact_frames: set[int],
+    visibilities: np.ndarray | None,
+    visibility_threshold: float,
+) -> list[ContactState]:
+    """Assign contact states based on contact frames and visibility.
+
+    Args:
+        n_frames: Total number of frames
+        contact_frames: Set of frames with confirmed contact
+        visibilities: Optional visibility scores for each frame
+        visibility_threshold: Minimum visibility to trust landmark
+
+    Returns:
+        List of ContactState for each frame
+    """
+    states = []
+    for i in range(n_frames):
+        if visibilities is not None and visibilities[i] < visibility_threshold:
+            states.append(ContactState.UNKNOWN)
+        elif i in contact_frames:
+            states.append(ContactState.ON_GROUND)
+        else:
+            states.append(ContactState.IN_AIR)
+    return states
+
+
 def detect_ground_contact(
     foot_positions: np.ndarray,
     velocity_threshold: float = 0.02,
@@ -247,7 +327,7 @@ def detect_ground_contact(
     """
     Detect when feet are in contact with ground based on vertical motion.
 
-    Uses derivative-based velocity calculation via Savitzky-Golay filter for smooth,
+    Uses derivative-based velocity calculation via Savitzky-Goyal filter for smooth,
     accurate velocity estimates. This is consistent with the velocity calculation used
     throughout the pipeline for sub-frame interpolation and curvature analysis.
 
@@ -264,52 +344,30 @@ def detect_ground_contact(
         List of ContactState for each frame
     """
     n_frames = len(foot_positions)
-    states = [ContactState.UNKNOWN] * n_frames
 
     if n_frames < 2:
-        return states
+        return [ContactState.UNKNOWN] * n_frames
 
     # Compute vertical velocity using derivative-based method
-    # This provides smoother, more accurate velocity estimates than frame-to-frame differences
-    # and is consistent with the velocity calculation used for sub-frame interpolation
     velocities = compute_velocity_from_derivative(
         foot_positions, window_length=window_length, polyorder=polyorder
     )
 
-    # Detect potential contact frames based on low velocity
+    # Detect stationary frames based on velocity threshold
     is_stationary = np.abs(velocities) < velocity_threshold
 
     # Apply visibility filter
-    if visibilities is not None:
-        is_visible = visibilities > visibility_threshold
-        is_stationary = is_stationary & is_visible
-
-    # Apply minimum contact duration filter
-    contact_frames = []
-    current_run = []
-
-    for i, stationary in enumerate(is_stationary):
-        if stationary:
-            current_run.append(i)
-        else:
-            if len(current_run) >= min_contact_frames:
-                contact_frames.extend(current_run)
-            current_run = []
-
-    # Don't forget the last run
-    if len(current_run) >= min_contact_frames:
-        contact_frames.extend(current_run)
+    is_stationary = _filter_stationary_with_visibility(
+        is_stationary, visibilities, visibility_threshold
+    )
 
-    # Set states
-    for i in range(n_frames):
-        if visibilities is not None and visibilities[i] < visibility_threshold:
-            states[i] = ContactState.UNKNOWN
-        elif i in contact_frames:
-            states[i] = ContactState.ON_GROUND
-        else:
-            states[i] = ContactState.IN_AIR
+    # Find frames with sustained contact
+    contact_frames = _find_contact_frames(is_stationary, min_contact_frames)
 
-    return states
+    # Assign states
+    return _assign_contact_states(
+        n_frames, contact_frames, visibilities, visibility_threshold
+    )
 
 
 def find_contact_phases(

kinemotion-0.27.0/tests/test_video_io.py

@@ -0,0 +1,114 @@
+"""Tests for video I/O functionality including codec extraction."""
+
+import tempfile
+from unittest.mock import patch
+
+import cv2
+import numpy as np
+import pytest
+
+from kinemotion.core.video_io import VideoProcessor
+
+
+@pytest.fixture
+def test_video_path() -> str:
+    """Create a test video file with codec metadata."""
+    temp_file = tempfile.NamedTemporaryFile(suffix=".mp4", delete=False)
+    temp_path = temp_file.name
+    temp_file.close()
+
+    # Create a simple test video with mp4v codec
+    fourcc = cv2.VideoWriter_fourcc(*"mp4v")
+    writer = cv2.VideoWriter(temp_path, fourcc, 30.0, (640, 480))
+
+    # Write 10 frames
+    for _ in range(10):
+        frame = np.zeros((480, 640, 3), dtype=np.uint8)
+        cv2.circle(frame, (320, 240), 50, (255, 255, 255), -1)
+        writer.write(frame)
+
+    writer.release()
+    return temp_path
+
+
+def test_codec_extraction_from_video(test_video_path: str) -> None:
+    """Test that codec is extracted from video metadata."""
+    video = VideoProcessor(test_video_path)
+    try:
+        # Codec should be extracted (or None if ffprobe unavailable)
+        # We just verify it's either a string or None
+        assert video.codec is None or isinstance(video.codec, str)
+    finally:
+        video.close()
+
+
+def test_codec_extraction_with_ffprobe_available(test_video_path: str) -> None:
+    """Test codec extraction when ffprobe is available."""
+    video = VideoProcessor(test_video_path)
+    try:
+        # If ffprobe is available, codec should be a string like "h264", "hevc", "mpeg4", etc.
+        # If ffprobe is not available, it will be None
+        if video.codec is not None:
+            assert isinstance(video.codec, str)
+            # Common codec names
+            assert (
+                video.codec
+                in [
+                    "h264",
+                    "hevc",
+                    "mpeg4",
+                    "vp8",
+                    "vp9",
+                    "av1",
+                    "mpeg2video",
+                    "rawvideo",
+                    "mpeg1video",
+                ]
+                or len(video.codec) > 0
+            )
+    finally:
+        video.close()
+
+
+def test_codec_none_on_ffprobe_failure(test_video_path: str) -> None:
+    """Test that codec remains None if ffprobe fails or is unavailable."""
+    with patch("kinemotion.core.video_io.subprocess.run") as mock_run:
+        # Simulate ffprobe not being available (FileNotFoundError)
+        mock_run.side_effect = FileNotFoundError("ffprobe not found")
+
+        video = VideoProcessor(test_video_path)
+        try:
+            # Codec should remain None when ffprobe is unavailable
+            assert video.codec is None
+        finally:
+            video.close()
+
+
+def test_video_processor_basic_properties(test_video_path: str) -> None:
+    """Test that VideoProcessor initializes all properties including codec."""
+    video = VideoProcessor(test_video_path)
+    try:
+        # Verify all properties are set
+        assert video.fps > 0
+        assert video.frame_count > 0
+        assert video.width > 0
+        assert video.height > 0
+        assert video.rotation in [0, 90, -90, 180, -180]
+        # codec can be None or str
+        assert video.codec is None or isinstance(video.codec, str)
+    finally:
+        video.close()
+
+
+def test_codec_persists_across_frame_reading(test_video_path: str) -> None:
+    """Test that codec property persists after reading frames."""
+    video = VideoProcessor(test_video_path)
+    try:
+        codec_before = video.codec
+        # Read a frame
+        frame = video.read_frame()
+        assert frame is not None
+        # Codec should remain unchanged
+        assert video.codec == codec_before
+    finally:
+        video.close()

{kinemotion-0.26.0 → kinemotion-0.27.0}/uv.lock

@@ -700,7 +700,7 @@ wheels = [
 
 [[package]]
 name = "kinemotion"
-version = "0.26.0"
+version = "0.27.0"
 source = { editable = "." }
 dependencies = [
     { name = "click" },