kinemotion 0.42.0__tar.gz → 0.44.0__tar.gz

{kinemotion-0.42.0 → kinemotion-0.44.0}/CHANGELOG.md

@@ -7,6 +7,32 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 <!-- version list -->
 
+## v0.44.0 (2025-12-11)
+
+### Features
+
+- Optimize debug video generation and fix logging warning
+  ([`619ccd5`](https://github.com/feniix/kinemotion/commit/619ccd53a4013457033749481cf6792f44529d93))
+
+
+## v0.43.0 (2025-12-11)
+
+### Continuous Integration
+
+- Remove b ad workflow
+  ([`7584229`](https://github.com/feniix/kinemotion/commit/7584229682eb94ddf13a6becac7ad31b96d62f0f))
+
+### Features
+
+- Optimize debug video generation and improve code quality
+  ([`81ce698`](https://github.com/feniix/kinemotion/commit/81ce698d5a0fa8dff6c20c6870a7bee52080cef0))
+
+### Testing
+
+- Optimize test suite execution speed
+  ([`26ea210`](https://github.com/feniix/kinemotion/commit/26ea21072745ef606405b5f6f5277dd422636baf))
+
+
 ## v0.42.0 (2025-12-10)
 
 ### Documentation

{kinemotion-0.42.0 → kinemotion-0.44.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kinemotion
-Version: 0.42.0
+Version: 0.44.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.42.0 → kinemotion-0.44.0}/backend/src/kinemotion_backend/logging_config.py

@@ -64,7 +64,6 @@ def setup_logging(*, json_logs: bool = False, log_level: str = "INFO") -> None:
         structlog.configure(
             processors=shared_processors
             + [
-                structlog.processors.ExceptionRenderer(),
                 structlog.dev.ConsoleRenderer(colors=True),
             ],
             wrapper_class=structlog.stdlib.BoundLogger,

{kinemotion-0.42.0 → kinemotion-0.44.0}/justfile

@@ -1,3 +1,14 @@
+# Check python sanity
+python-check:
+    @echo "Running pyright..."
+    uv run pyright
+    (cd backend && uv run pyright)
+    @echo "Running ruff check and format..."
+    uv run ruff check --fix
+    uv run ruff format
+    (cd backend && uv run ruff check --fix)
+    (cd backend && uv run ruff format)
+
 # Clean generated and temporary files (preserves .claude/, .cursor/, .mcp.json)
 clean:
     @echo "Cleaning generated files..."

{kinemotion-0.42.0 → kinemotion-0.44.0}/pyproject.toml

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

{kinemotion-0.42.0 → kinemotion-0.44.0}/src/kinemotion/api.py

@@ -1,4 +1,4 @@
-"""Public API for programmatic use of kinemotion analysis."""
+"Public API for programmatic use of kinemotion analysis."
 
 import time
 from collections.abc import Callable
@@ -6,6 +6,7 @@ from concurrent.futures import ProcessPoolExecutor, as_completed
 from dataclasses import dataclass
 from pathlib import Path
 
+import cv2
 import numpy as np
 
 from .cmj.analysis import compute_average_hip_position, detect_cmj_phases
@@ -37,7 +38,6 @@ from .core.smoothing import smooth_landmarks, smooth_landmarks_advanced
 from .core.timing import PerformanceTimer
 from .core.video_io import VideoProcessor
 from .dropjump.analysis import (
-    ContactState,
     compute_average_foot_position,
     detect_ground_contact,
     find_contact_phases,
@@ -179,18 +179,26 @@ def _process_all_frames(
     verbose: bool,
     timer: PerformanceTimer | None = None,
     close_tracker: bool = True,
-) -> tuple[list, list]:
+    target_debug_fps: float = 30.0,
+    max_debug_dim: int = 720,
+) -> tuple[list, list, list]:
     """Process all frames from video and extract pose landmarks.
 
+    Optimizes memory and speed by:
+    1. Decimating frames stored for debug video (to target_debug_fps)
+    2. Pre-resizing stored frames (to max_debug_dim)
+
     Args:
         video: Video processor to read frames from
         tracker: Pose tracker for landmark detection
         verbose: Print progress messages
         timer: Optional PerformanceTimer for measuring operations
         close_tracker: Whether to close the tracker after processing (default: True)
+        target_debug_fps: Target FPS for debug video (default: 30.0)
+        max_debug_dim: Max dimension for debug video frames (default: 720)
 
     Returns:
-        Tuple of (frames, landmarks_sequence)
+        Tuple of (debug_frames, landmarks_sequence, frame_indices)
 
     Raises:
         ValueError: If no frames could be processed
@@ -199,7 +207,24 @@ def _process_all_frames(
         print("Tracking pose landmarks...")
 
     landmarks_sequence = []
-    frames = []
+    debug_frames = []
+    frame_indices = []
+
+    # Calculate decimation and resize parameters
+    step = max(1, int(video.fps / target_debug_fps))
+
+    # Calculate resize dimensions maintaining aspect ratio
+    # Logic mirrors BaseDebugOverlayRenderer to ensure consistency
+    w, h = video.display_width, video.display_height
+    scale = 1.0
+    if max(w, h) > max_debug_dim:
+        scale = max_debug_dim / max(w, h)
+
+    debug_w = int(w * scale) // 2 * 2
+    debug_h = int(h * scale) // 2 * 2
+    should_resize = (debug_w != video.width) or (debug_h != video.height)
+
+    frame_idx = 0
 
     if timer:
         with timer.measure("pose_tracking"):
@@ -208,26 +233,54 @@ def _process_all_frames(
                 if frame is None:
                     break
 
-                frames.append(frame)
+                # 1. Track on FULL resolution frame (preserves accuracy)
                 landmarks = tracker.process_frame(frame)
                 landmarks_sequence.append(landmarks)
+
+                # 2. Store frame for debug video ONLY if matches step
+                if frame_idx % step == 0:
+                    # Pre-resize to save memory and later encoding time
+                    if should_resize:
+                        # Use simple linear interpolation for speed (debug only)
+                        processed_frame = cv2.resize(
+                            frame, (debug_w, debug_h), interpolation=cv2.INTER_LINEAR
+                        )
+                    else:
+                        processed_frame = frame
+
+                    debug_frames.append(processed_frame)
+                    frame_indices.append(frame_idx)
+
+                frame_idx += 1
     else:
         while True:
             frame = video.read_frame()
             if frame is None:
                 break
 
-            frames.append(frame)
             landmarks = tracker.process_frame(frame)
             landmarks_sequence.append(landmarks)
 
+            if frame_idx % step == 0:
+                if should_resize:
+                    processed_frame = cv2.resize(
+                        frame, (debug_w, debug_h), interpolation=cv2.INTER_LINEAR
+                    )
+                else:
+                    processed_frame = frame
+
+                debug_frames.append(processed_frame)
+                frame_indices.append(frame_idx)
+
+            frame_idx += 1
+
     if close_tracker:
         tracker.close()
 
     if not landmarks_sequence:
         raise ValueError("No frames could be processed from video")
 
-    return frames, landmarks_sequence
+    return debug_frames, landmarks_sequence, frame_indices
 
 
 def _apply_smoothing(
@@ -370,105 +423,15 @@ def _convert_timer_to_stage_names(
         "json_serialization": "JSON serialization",
         "debug_video_generation": "Debug video generation",
         "debug_video_reencode": "Debug video re-encoding",
+        "frame_rotation": "Frame rotation",
+        "debug_video_resize": "Debug video resizing",
+        "debug_video_copy": "Debug video frame copy",
+        "debug_video_draw": "Debug video drawing",
+        "debug_video_write": "Debug video encoding",
     }
     return {mapping.get(k, k): v for k, v in timer_metrics.items()}
 
 
-def _generate_dropjump_outputs(
-    metrics: DropJumpMetrics,
-    json_output: str | None,
-    output_video: str | None,
-    frames: list,
-    smoothed_landmarks: list,
-    contact_states: list[ContactState],
-    video: VideoProcessor,
-    verbose: bool,
-    timer: PerformanceTimer | None = None,
-) -> None:
-    """Generate JSON and debug video outputs if requested.
-
-    Args:
-        metrics: Calculated drop jump metrics
-        json_output: Optional path for JSON output
-        output_video: Optional path for debug video
-        frames: List of video frames
-        smoothed_landmarks: Smoothed landmark sequence
-        contact_states: Ground contact state for each frame
-        video: Video processor with dimensions and fps
-        verbose: Print progress messages
-        timer: Optional PerformanceTimer for measuring operations
-    """
-    # Save JSON if requested
-    if json_output:
-        import json
-
-        if timer:
-            with timer.measure("json_serialization"):
-                output_path = Path(json_output)
-                metrics_dict = metrics.to_dict()
-                json_str = json.dumps(metrics_dict, indent=2)
-                output_path.write_text(json_str)
-        else:
-            output_path = Path(json_output)
-            metrics_dict = metrics.to_dict()
-            json_str = json.dumps(metrics_dict, indent=2)
-            output_path.write_text(json_str)
-
-        if verbose:
-            print(f"Metrics written to: {json_output}")
-
-    # Generate debug video if requested
-    if output_video:
-        if verbose:
-            print(f"Generating debug video: {output_video}")
-
-        if timer:
-            with timer.measure("debug_video_generation"):
-                with DebugOverlayRenderer(
-                    output_video,
-                    video.width,
-                    video.height,
-                    video.display_width,
-                    video.display_height,
-                    video.fps,
-                ) as renderer:
-                    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)
-            # Capture re-encoding duration separately
-            with timer.measure("debug_video_reencode"):
-                pass  # Re-encoding happens in context manager __exit__
-        else:
-            with DebugOverlayRenderer(
-                output_video,
-                video.width,
-                video.height,
-                video.display_width,
-                video.display_height,
-                video.fps,
-            ) as renderer:
-                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)
-
-        if verbose:
-            print(f"Debug video saved: {output_video}")
-
-
 @dataclass
 class DropJumpVideoResult:
     """Result of processing a single drop jump video."""
@@ -583,11 +546,11 @@ def process_dropjump_video(
                 )
                 should_close_tracker = True
 
-            frames, landmarks_sequence = _process_all_frames(
+            frames, landmarks_sequence, frame_indices = _process_all_frames(
                 video, tracker, verbose, timer, close_tracker=should_close_tracker
             )
 
-            # Analyze video characteristics and auto-tune parameters
+            # Auto-tune parameters
             with timer.measure("parameter_auto_tuning"):
                 characteristics = analyze_video_sample(
                     landmarks_sequence, video.fps, video.frame_count
@@ -731,22 +694,35 @@ def process_dropjump_video(
                 if verbose:
                     print(f"Generating debug video: {output_video}")
 
+                # Determine debug video properties from the pre-processed frames
+                debug_h, debug_w = frames[0].shape[:2]
+                if video.fps > 30:
+                    debug_fps = video.fps / (video.fps / 30.0)
+                else:
+                    debug_fps = video.fps
+                # Use approximate 30fps if decimated, or actual if not
+                if len(frames) < len(landmarks_sequence):
+                    # Re-calculate step to get precise FPS
+                    step = max(1, int(video.fps / 30.0))
+                    debug_fps = video.fps / step
+
                 if timer:
                     with timer.measure("debug_video_generation"):
                         with DebugOverlayRenderer(
                             output_video,
-                            video.width,
-                            video.height,
-                            video.display_width,
-                            video.display_height,
-                            video.fps,
+                            debug_w,  # Encoded width = pre-resized width
+                            debug_h,  # Encoded height
+                            debug_w,  # Display width (already corrected)
+                            debug_h,  # Display height
+                            debug_fps,
+                            timer=timer,
                         ) as renderer:
-                            for i, frame in enumerate(frames):
+                            for frame, idx in zip(frames, frame_indices, strict=True):
                                 annotated = renderer.render_frame(
                                     frame,
-                                    smoothed_landmarks[i],
-                                    contact_states[i],
-                                    i,
+                                    smoothed_landmarks[idx],
+                                    contact_states[idx],
+                                    idx,
                                     metrics,
                                     use_com=False,
                                 )
@@ -757,18 +733,19 @@ def process_dropjump_video(
                 else:
                     with DebugOverlayRenderer(
                         output_video,
-                        video.width,
-                        video.height,
-                        video.display_width,
-                        video.display_height,
-                        video.fps,
+                        debug_w,
+                        debug_h,
+                        debug_w,
+                        debug_h,
+                        debug_fps,
+                        timer=timer,
                     ) as renderer:
-                        for i, frame in enumerate(frames):
+                        for frame, idx in zip(frames, frame_indices, strict=True):
                             annotated = renderer.render_frame(
                                 frame,
-                                smoothed_landmarks[i],
-                                contact_states[i],
-                                i,
+                                smoothed_landmarks[idx],
+                                contact_states[idx],
+                                idx,
                                 metrics,
                                 use_com=False,
                             )
@@ -843,7 +820,7 @@ def process_dropjump_video(
                     dur_ms = duration * 1000
                     print(f"{stage:.<40} {dur_ms:>6.0f}ms ({percentage:>5.1f}%)")
                 total_ms = total_time * 1000
-                print(f"{'Total':.>40} {total_ms:>6.0f}ms (100.0%)")
+                print(f"{('Total'):.>40} {total_ms:>6.0f}ms (100.0%)")
                 print()
                 print("Analysis complete!")
 
@@ -994,95 +971,6 @@ class CMJVideoResult:
     processing_time: float = 0.0
 
 
-def _generate_cmj_outputs(
-    output_video: str | None,
-    json_output: str | None,
-    metrics: CMJMetrics,
-    frames: list,
-    smoothed_landmarks: list,
-    video_width: int,
-    video_height: int,
-    video_display_width: int,
-    video_display_height: int,
-    video_fps: float,
-    verbose: bool,
-    timer: PerformanceTimer | None = None,
-) -> None:
-    """Generate JSON and debug video outputs for CMJ analysis.
-
-    Args:
-        output_video: Optional path for debug video output
-        json_output: Optional path for JSON output
-        metrics: Calculated CMJ metrics
-        frames: List of video frames
-        smoothed_landmarks: Smoothed landmark sequence
-        video_width: Video width in pixels
-        video_height: Video height in pixels
-        video_display_width: Display width considering aspect ratio
-        video_display_height: Display height considering aspect ratio
-        video_fps: Video frames per second
-        verbose: Print progress messages
-        timer: Optional PerformanceTimer for measuring operations
-    """
-    if json_output:
-        import json
-
-        if timer:
-            with timer.measure("json_serialization"):
-                output_path = Path(json_output)
-                metrics_dict = metrics.to_dict()
-                json_str = json.dumps(metrics_dict, indent=2)
-                output_path.write_text(json_str)
-        else:
-            output_path = Path(json_output)
-            metrics_dict = metrics.to_dict()
-            json_str = json.dumps(metrics_dict, indent=2)
-            output_path.write_text(json_str)
-
-        if verbose:
-            print(f"Metrics written to: {json_output}")
-
-    if output_video:
-        if verbose:
-            print(f"Generating debug video: {output_video}")
-
-        if timer:
-            with timer.measure("debug_video_generation"):
-                with CMJDebugOverlayRenderer(
-                    output_video,
-                    video_width,
-                    video_height,
-                    video_display_width,
-                    video_display_height,
-                    video_fps,
-                ) as renderer:
-                    for i, frame in enumerate(frames):
-                        annotated = renderer.render_frame(
-                            frame, smoothed_landmarks[i], i, metrics
-                        )
-                        renderer.write_frame(annotated)
-            # Capture re-encoding duration separately
-            with timer.measure("debug_video_reencode"):
-                pass  # Re-encoding happens in context manager __exit__
-        else:
-            with CMJDebugOverlayRenderer(
-                output_video,
-                video_width,
-                video_height,
-                video_display_width,
-                video_display_height,
-                video_fps,
-            ) as renderer:
-                for i, frame in enumerate(frames):
-                    annotated = renderer.render_frame(
-                        frame, smoothed_landmarks[i], i, metrics
-                    )
-                    renderer.write_frame(annotated)
-
-        if verbose:
-            print(f"Debug video saved: {output_video}")
-
-
 def process_cmj_video(
     video_path: str,
     quality: str = "balanced",
@@ -1177,7 +1065,7 @@ def process_cmj_video(
                 )
                 should_close_tracker = True
 
-            frames, landmarks_sequence = _process_all_frames(
+            frames, landmarks_sequence, frame_indices = _process_all_frames(
                 video, tracker, verbose, timer, close_tracker=should_close_tracker
             )
 
@@ -1331,19 +1219,25 @@ def process_cmj_video(
                 if verbose:
                     print(f"Generating debug video: {output_video}")
 
+                # Determine debug video properties from the pre-processed frames
+                debug_h, debug_w = frames[0].shape[:2]
+                step = max(1, int(video.fps / 30.0))
+                debug_fps = video.fps / step
+
                 if timer:
                     with timer.measure("debug_video_generation"):
                         with CMJDebugOverlayRenderer(
                             output_video,
-                            video.width,
-                            video.height,
-                            video.display_width,
-                            video.display_height,
-                            video.fps,
+                            debug_w,
+                            debug_h,
+                            debug_w,
+                            debug_h,
+                            debug_fps,
+                            timer=timer,  # Passing timer here too
                         ) as renderer:
-                            for i, frame in enumerate(frames):
+                            for frame, idx in zip(frames, frame_indices, strict=True):
                                 annotated = renderer.render_frame(
-                                    frame, smoothed_landmarks[i], i, metrics
+                                    frame, smoothed_landmarks[idx], idx, metrics
                                 )
                                 renderer.write_frame(annotated)
                     # Capture re-encoding duration separately
@@ -1352,15 +1246,16 @@ def process_cmj_video(
                 else:
                     with CMJDebugOverlayRenderer(
                         output_video,
-                        video.width,
-                        video.height,
-                        video.display_width,
-                        video.display_height,
-                        video.fps,
+                        debug_w,
+                        debug_h,
+                        debug_w,
+                        debug_h,
+                        debug_fps,
+                        timer=timer,  # Passing timer here too
                     ) as renderer:
-                        for i, frame in enumerate(frames):
+                        for frame, idx in zip(frames, frame_indices, strict=True):
                             annotated = renderer.render_frame(
-                                frame, smoothed_landmarks[i], i, metrics
+                                frame, smoothed_landmarks[idx], idx, metrics
                             )
                             renderer.write_frame(annotated)
 
@@ -1433,7 +1328,7 @@ def process_cmj_video(
                     dur_ms = duration * 1000
                     print(f"{stage:.<40} {dur_ms:>6.0f}ms ({percentage:>5.1f}%)")
                 total_ms = total_time * 1000
-                print(f"{'Total':.>40} {total_ms:>6.0f}ms (100.0%)")
+                print(f"{('Total'):.>40} {total_ms:>6.0f}ms (100.0%)")
                 print()
 
                 print(f"\nJump height: {metrics.jump_height:.3f}m")

{kinemotion-0.42.0 → kinemotion-0.44.0}/src/kinemotion/core/debug_overlay_utils.py

@@ -9,6 +9,8 @@ from pathlib import Path
 import cv2
 import numpy as np
 
+from .timing import PerformanceTimer
+
 
 def create_video_writer(
     output_path: str,
@@ -104,6 +106,7 @@ class BaseDebugOverlayRenderer:
         display_width: int,
         display_height: int,
         fps: float,
+        timer: PerformanceTimer | None = None,
     ):
         """
         Initialize overlay renderer.
@@ -115,16 +118,30 @@ class BaseDebugOverlayRenderer:
             display_width: Display width (considering SAR)
             display_height: Display height (considering SAR)
             fps: Frames per second
+            timer: Optional PerformanceTimer for measuring operations
         """
         self.output_path = output_path
         self.width = width
         self.height = height
-        self.display_width = display_width
-        self.display_height = display_height
+        self.timer = timer
+
+        # Optimize debug video resolution: Cap max dimension to 720p
+        # Reduces software encoding time on single-core Cloud Run instances.
+        # while keeping sufficient quality for visual debugging.
+        max_dimension = 720
+        if max(display_width, display_height) > max_dimension:
+            scale = max_dimension / max(display_width, display_height)
+            # Ensure dimensions are even for codec compatibility
+            self.display_width = int(display_width * scale) // 2 * 2
+            self.display_height = int(display_height * scale) // 2 * 2
+        else:
+            self.display_width = display_width
+            self.display_height = display_height
+
         # Duration of ffmpeg re-encoding (0.0 if not needed)
         self.reencode_duration_s = 0.0
         self.writer, self.needs_resize, self.used_codec = create_video_writer(
-            output_path, width, height, display_width, display_height, fps
+            output_path, width, height, self.display_width, self.display_height, fps
         )
 
     def write_frame(self, frame: np.ndarray) -> None:
@@ -148,13 +165,29 @@ class BaseDebugOverlayRenderer:
 
         # Resize to display dimensions if needed (to handle SAR)
         if self.needs_resize:
-            frame = cv2.resize(
-                frame,
-                (self.display_width, self.display_height),
-                interpolation=cv2.INTER_LANCZOS4,
-            )
+            if self.timer:
+                with self.timer.measure("debug_video_resize"):
+                    frame = cv2.resize(
+                        frame,
+                        (self.display_width, self.display_height),
+                        interpolation=cv2.INTER_LINEAR,
+                    )
+            else:
+                frame = cv2.resize(
+                    frame,
+                    (self.display_width, self.display_height),
+                    interpolation=cv2.INTER_LINEAR,
+                )
 
-        write_overlay_frame(self.writer, frame, self.display_width, self.display_height)
+        if self.timer:
+            with self.timer.measure("debug_video_write"):
+                write_overlay_frame(
+                    self.writer, frame, self.display_width, self.display_height
+                )
+        else:
+            write_overlay_frame(
+                self.writer, frame, self.display_width, self.display_height
+            )
 
     def close(self) -> None:
         """Release video writer and re-encode if possible."""