kinemotion 0.10.1__tar.gz → 0.10.3__tar.gz

{kinemotion-0.10.1 → kinemotion-0.10.3}/CHANGELOG.md

@@ -7,6 +7,22 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 <!-- version list -->
 
+## v0.10.3 (2025-11-03)
+
+### Bug Fixes
+
+- Reduce function parameter count using dataclass
+  ([`0b8abfd`](https://github.com/feniix/kinemotion/commit/0b8abfd6ee53835ba3d787924747ab5e46066395))
+
+
+## v0.10.2 (2025-11-03)
+
+### Bug Fixes
+
+- Replace legacy numpy random functions with Generator API
+  ([`5cfa31b`](https://github.com/feniix/kinemotion/commit/5cfa31bce040eadfc53d52654c2e75087ef087a5))
+
+
 ## v0.10.1 (2025-11-03)
 
 ### Bug Fixes

{kinemotion-0.10.1 → kinemotion-0.10.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kinemotion
-Version: 0.10.1
+Version: 0.10.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.10.1 → kinemotion-0.10.3}/pyproject.toml

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

{kinemotion-0.10.1 → kinemotion-0.10.3}/src/kinemotion/dropjump/cli.py

@@ -4,6 +4,7 @@ import csv
 import glob
 import json
 import sys
+from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
 
@@ -27,6 +28,19 @@ from .debug_overlay import DebugOverlayRenderer
 from .kinematics import calculate_drop_jump_metrics
 
 
+@dataclass
+class AnalysisParameters:
+    """Expert parameters for analysis customization."""
+
+    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
+
+
 @click.command(name="dropjump-analyze")
 @click.argument("video_path", nargs=-1, type=click.Path(exists=False), required=True)
 @click.option(
@@ -202,6 +216,17 @@ def dropjump_analyze(
     # Determine if batch mode should be used
     use_batch = batch or len(video_files) > 1
 
+    # Group expert parameters
+    params = AnalysisParameters(
+        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,
+    )
+
     if use_batch:
         _process_batch(
             video_files,
@@ -211,13 +236,7 @@ def dropjump_analyze(
             output_dir,
             json_output_dir,
             csv_summary,
-            drop_start_frame,
-            smoothing_window,
-            velocity_threshold,
-            min_contact_frames,
-            visibility_threshold,
-            detection_confidence,
-            tracking_confidence,
+            params,
         )
     else:
         # Single video mode (original behavior)
@@ -228,13 +247,7 @@ def dropjump_analyze(
             drop_height,
             quality,
             verbose,
-            drop_start_frame,
-            smoothing_window,
-            velocity_threshold,
-            min_contact_frames,
-            visibility_threshold,
-            detection_confidence,
-            tracking_confidence,
+            params,
         )
 
 
@@ -245,13 +258,7 @@ def _process_single(
     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,
+    expert_params: AnalysisParameters,
 ) -> None:
     """Process a single video (original CLI behavior)."""
     click.echo(f"Analyzing video: {video_path}", err=True)
@@ -285,10 +292,10 @@ def _process_single(
                 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
+            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
 
             # Initialize pose tracker
             tracker = PoseTracker(
@@ -334,14 +341,14 @@ def _process_single(
             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
+            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
 
             # Show selected parameters if verbose
             if verbose:
@@ -463,7 +470,7 @@ def _process_single(
                 vertical_positions,
                 video.fps,
                 drop_height_m=drop_height,
-                drop_start_frame=drop_start_frame,
+                drop_start_frame=expert_params.drop_start_frame,
                 velocity_threshold=params.velocity_threshold,
                 smoothing_window=params.smoothing_window,
                 polyorder=params.polyorder,
@@ -545,13 +552,7 @@ def _process_batch(
     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,
+    expert_params: AnalysisParameters,
 ) -> None:
     """Process multiple videos in batch mode using parallel processing."""
     click.echo(
@@ -588,13 +589,13 @@ def _process_batch(
             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,
+            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,
+            detection_confidence=expert_params.detection_confidence,
+            tracking_confidence=expert_params.tracking_confidence,
         )
         configs.append(config)
 

{kinemotion-0.10.1 → kinemotion-0.10.3}/tests/test_adaptive_threshold.py

@@ -14,8 +14,8 @@ def test_adaptive_threshold_basic() -> None:
     baseline_frames = int(3 * fps)  # 90 frames
 
     # Baseline: small random noise around position 0.5
-    np.random.seed(42)
-    baseline_positions = 0.5 + np.random.normal(0, 0.005, baseline_frames)
+    rng = np.random.default_rng(42)
+    baseline_positions = 0.5 + rng.normal(0, 0.005, baseline_frames)
 
     # Movement: larger position changes
     movement_positions = np.linspace(0.5, 0.7, 60)
@@ -36,8 +36,8 @@ def test_adaptive_threshold_high_noise() -> None:
     baseline_frames = int(3 * fps)
 
     # High noise baseline
-    np.random.seed(42)
-    baseline_positions = 0.5 + np.random.normal(0, 0.015, baseline_frames)
+    rng = np.random.default_rng(42)
+    baseline_positions = 0.5 + rng.normal(0, 0.015, baseline_frames)
     movement_positions = np.linspace(0.5, 0.8, 60)
     positions = np.concatenate([baseline_positions, movement_positions])
 
@@ -56,8 +56,8 @@ def test_adaptive_threshold_low_noise() -> None:
     baseline_frames = int(3 * fps)
 
     # Very low noise baseline
-    np.random.seed(42)
-    baseline_positions = 0.5 + np.random.normal(0, 0.002, baseline_frames)
+    rng = np.random.default_rng(42)
+    baseline_positions = 0.5 + rng.normal(0, 0.002, baseline_frames)
     movement_positions = np.linspace(0.5, 0.7, 60)
     positions = np.concatenate([baseline_positions, movement_positions])
 
@@ -90,8 +90,8 @@ def test_adaptive_threshold_maximum_bound() -> None:
     baseline_frames = int(3 * fps)
 
     # Extreme noise baseline
-    np.random.seed(42)
-    baseline_positions = 0.5 + np.random.normal(0, 0.05, baseline_frames)
+    rng = np.random.default_rng(42)
+    baseline_positions = 0.5 + rng.normal(0, 0.05, baseline_frames)
     movement_positions = np.linspace(0.5, 0.8, 60)
     positions = np.concatenate([baseline_positions, movement_positions])
 
@@ -106,7 +106,8 @@ def test_adaptive_threshold_short_video() -> None:
     fps = 30.0
 
     # Only 60 frames (2 seconds) - less than 3 second baseline
-    positions = 0.5 + np.random.normal(0, 0.01, 60)
+    rng = np.random.default_rng(42)
+    positions = 0.5 + rng.normal(0, 0.01, 60)
 
     threshold = calculate_adaptive_threshold(positions, fps, baseline_duration=3.0)
 
@@ -137,8 +138,8 @@ def test_adaptive_threshold_different_fps() -> None:
     fps = 60.0
     baseline_frames = int(3 * fps)  # 180 frames
 
-    np.random.seed(42)
-    baseline_positions = 0.5 + np.random.normal(0, 0.008, baseline_frames)
+    rng = np.random.default_rng(42)
+    baseline_positions = 0.5 + rng.normal(0, 0.008, baseline_frames)
     movement_positions = np.linspace(0.5, 0.7, 120)
     positions = np.concatenate([baseline_positions, movement_positions])
 
@@ -153,8 +154,8 @@ def test_adaptive_threshold_custom_multiplier() -> None:
     fps = 30.0
     baseline_frames = int(3 * fps)
 
-    np.random.seed(42)
-    baseline_positions = 0.5 + np.random.normal(0, 0.005, baseline_frames)
+    rng = np.random.default_rng(42)
+    baseline_positions = 0.5 + rng.normal(0, 0.008, baseline_frames)
     movement_positions = np.linspace(0.5, 0.7, 60)
     positions = np.concatenate([baseline_positions, movement_positions])
 
@@ -181,9 +182,9 @@ def test_adaptive_threshold_baseline_duration() -> None:
     fps = 30.0
 
     # Long video with different noise in different sections
-    np.random.seed(42)
-    first_3s = 0.5 + np.random.normal(0, 0.005, int(3 * fps))  # Low noise
-    next_2s = 0.5 + np.random.normal(0, 0.015, int(2 * fps))  # High noise
+    rng = np.random.default_rng(42)
+    first_3s = 0.5 + rng.normal(0, 0.005, int(3 * fps))  # Low noise
+    next_2s = 0.5 + rng.normal(0, 0.015, int(2 * fps))  # High noise
     movement = np.linspace(0.5, 0.7, 60)
 
     positions = np.concatenate([first_3s, next_2s, movement])

{kinemotion-0.10.1 → kinemotion-0.10.3}/tests/test_aspect_ratio.py

@@ -21,9 +21,10 @@ def create_test_video(
     fourcc = cv2.VideoWriter_fourcc(*"mp4v")
     writer = cv2.VideoWriter(temp_path, fourcc, fps, (width, height))
 
+    rng = np.random.default_rng(42)
     for _ in range(num_frames):
         # Create a random frame
-        frame = np.random.randint(0, 255, (height, width, 3), dtype=np.uint8)
+        frame = rng.integers(0, 255, (height, width, 3), dtype=np.uint8)
         writer.write(frame)
 
     writer.release()

{kinemotion-0.10.1 → kinemotion-0.10.3}/tests/test_filtering.py

@@ -35,8 +35,9 @@ def test_detect_outliers_ransac_finds_glitches() -> None:
 def test_detect_outliers_ransac_handles_clean_data() -> None:
     """Test that RANSAC does not flag valid points as outliers."""
     # Create smooth motion with small noise
+    rng = np.random.default_rng(42)
     positions = np.array([0.5 + 0.001 * i**2 for i in range(30)])
-    positions += np.random.normal(0, 0.001, 30)  # Small noise
+    positions += rng.normal(0, 0.001, 30)  # Small noise
 
     outliers = detect_outliers_ransac(
         positions, window_size=15, threshold=0.02, min_inliers=0.7
@@ -220,8 +221,9 @@ def test_bilateral_temporal_filter_preserves_edges() -> None:
 def test_bilateral_temporal_filter_smooths_noise() -> None:
     """Test that bilateral filter smooths noise within smooth regions."""
     # Noisy flat region
+    rng = np.random.default_rng(42)
     positions = np.array([0.5] * 30)
-    positions += np.random.normal(0, 0.01, 30)
+    positions += rng.normal(0, 0.01, 30)
 
     filtered = bilateral_temporal_filter(
         positions, window_size=9, sigma_spatial=3.0, sigma_intensity=0.02
@@ -233,7 +235,8 @@ def test_bilateral_temporal_filter_smooths_noise() -> None:
 
 def test_bilateral_temporal_filter_window_size() -> None:
     """Test that bilateral filter handles even window sizes."""
-    positions = np.random.rand(50)
+    rng = np.random.default_rng(42)
+    positions = rng.random(50)
 
     # Even window size should be adjusted to odd
     filtered_even = bilateral_temporal_filter(
@@ -284,10 +287,11 @@ def test_smooth_landmarks_advanced_with_bilateral() -> None:
     # Create landmark sequence with sharp transition (landing)
     n_frames = 40
     landmark_sequence = []
+    rng = np.random.default_rng(42)
 
     for i in range(n_frames):
         y = 0.8 if i < 20 else 0.5  # Sharp drop at frame 20
-        y += np.random.normal(0, 0.005)  # Add noise
+        y += rng.normal(0, 0.005)  # Add noise
 
         landmark_sequence.append(
             {
@@ -322,10 +326,11 @@ def test_smooth_landmarks_advanced_combined() -> None:
     n_frames = 50
     landmark_sequence = []
 
+    rng = np.random.default_rng(42)
     for i in range(n_frames):
         # Parabolic motion
         y = 0.5 + 0.001 * (i - 25) ** 2
-        y += np.random.normal(0, 0.005)  # Noise
+        y += rng.normal(0, 0.005)  # Noise
 
         # Add tracking glitch
         if i == 25:

{kinemotion-0.10.1 → kinemotion-0.10.3}/tests/test_polyorder.py

@@ -15,10 +15,11 @@ def test_smooth_landmarks_polyorder2_vs_polyorder3() -> None:
     n_frames = 30
     landmark_sequence = []
 
+    rng = np.random.default_rng(42)
     for i in range(n_frames):
         # Smooth parabolic motion with noise
         base_y = 0.5 + 0.01 * (i - 15) ** 2 / 225  # Parabola
-        noisy_y = base_y + np.random.normal(0, 0.01)
+        noisy_y = base_y + rng.normal(0, 0.01)
 
         landmark_sequence.append(
             {
@@ -49,9 +50,10 @@ def test_smooth_landmarks_polyorder2_vs_polyorder3() -> None:
 def test_velocity_from_derivative_polyorder() -> None:
     """Test velocity computation with different polynomial orders."""
     # Create synthetic position data with quadratic motion
+    rng = np.random.default_rng(42)
     t = np.linspace(0, 2, 60)
     positions = 0.5 + 0.1 * t**2  # Parabolic trajectory
-    positions += np.random.normal(0, 0.005, len(positions))  # Add noise
+    positions += rng.normal(0, 0.005, len(positions))  # Add noise
 
     # Compute velocity with different polynomial orders
     velocity_2 = compute_velocity_from_derivative(
@@ -79,9 +81,10 @@ def test_velocity_from_derivative_polyorder() -> None:
 def test_acceleration_from_derivative_polyorder() -> None:
     """Test acceleration computation with different polynomial orders."""
     # Create synthetic position data with cubic motion (non-zero third derivative)
+    rng = np.random.default_rng(42)
     t = np.linspace(0, 2, 60)
     positions = 0.5 + 0.05 * t**3  # Cubic trajectory
-    positions += np.random.normal(0, 0.003, len(positions))  # Add noise
+    positions += rng.normal(0, 0.003, len(positions))  # Add noise
 
     # Compute acceleration with different polynomial orders
     accel_2 = compute_acceleration_from_derivative(
@@ -111,7 +114,8 @@ def test_acceleration_from_derivative_polyorder() -> None:
 
 def test_polyorder_validation() -> None:
     """Test that polyorder must be less than window_length."""
-    positions = np.random.rand(50)
+    rng = np.random.default_rng(42)
+    positions = rng.random(50)
 
     # polyorder=2 with window=5 should work (2 < 5)
     velocity_valid = compute_velocity_from_derivative(

{kinemotion-0.10.1 → kinemotion-0.10.3}/uv.lock

@@ -603,7 +603,7 @@ wheels = [
 
 [[package]]
 name = "kinemotion"
-version = "0.10.0"
+version = "0.10.2"
 source = { editable = "." }
 dependencies = [
     { name = "click" },

{kinemotion-0.10.1 → kinemotion-0.10.3}/Dockerfile

@@ -53,10 +53,10 @@ LABEL org.opencontainers.image.title="kinemotion" \
 # - ffmpeg: Video codec support for OpenCV
 # hadolint ignore=DL3008
 RUN apt-get update && apt-get install -y --no-install-recommends \
+    ffmpeg \
     libgl1 \
     libglib2.0-0 \
     libgomp1 \
-    ffmpeg \
     && apt-get clean \
     && rm -rf /var/lib/apt/lists/*