kinemotion 0.42.0__py3-none-any.whl → 0.43.0__py3-none-any.whl

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
@@ -37,7 +37,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,
@@ -370,105 +369,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."""
@@ -740,6 +649,7 @@ def process_dropjump_video(
                             video.display_width,
                             video.display_height,
                             video.fps,
+                            timer=timer,
                         ) as renderer:
                             for i, frame in enumerate(frames):
                                 annotated = renderer.render_frame(
@@ -762,6 +672,7 @@ def process_dropjump_video(
                         video.display_width,
                         video.display_height,
                         video.fps,
+                        timer=timer,
                     ) as renderer:
                         for i, frame in enumerate(frames):
                             annotated = renderer.render_frame(
@@ -843,7 +754,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 +905,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",
@@ -1340,6 +1162,7 @@ def process_cmj_video(
                             video.display_width,
                             video.display_height,
                             video.fps,
+                            timer=timer,  # Passing timer here too
                         ) as renderer:
                             for i, frame in enumerate(frames):
                                 annotated = renderer.render_frame(
@@ -1357,6 +1180,7 @@ def process_cmj_video(
                         video.display_width,
                         video.display_height,
                         video.fps,
+                        timer=timer,  # Passing timer here too
                     ) as renderer:
                         for i, frame in enumerate(frames):
                             annotated = renderer.render_frame(
@@ -1433,7 +1257,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/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."""

kinemotion/core/video_io.py

@@ -189,15 +189,27 @@ class VideoProcessor:
             return None
 
         # Apply rotation if video has rotation metadata
-        if self.rotation == -90 or self.rotation == 270:
-            # -90 degrees = rotate 90 degrees clockwise
-            frame = cv2.rotate(frame, cv2.ROTATE_90_CLOCKWISE)
-        elif self.rotation == 90 or self.rotation == -270:
-            # 90 degrees = rotate 90 degrees counter-clockwise
-            frame = cv2.rotate(frame, cv2.ROTATE_90_COUNTERCLOCKWISE)
-        elif self.rotation == 180 or self.rotation == -180:
-            # 180 degrees rotation
-            frame = cv2.rotate(frame, cv2.ROTATE_180)
+        if self.timer:
+            with self.timer.measure("frame_rotation"):
+                if self.rotation == -90 or self.rotation == 270:
+                    # -90 degrees = rotate 90 degrees clockwise
+                    frame = cv2.rotate(frame, cv2.ROTATE_90_CLOCKWISE)
+                elif self.rotation == 90 or self.rotation == -270:
+                    # 90 degrees = rotate 90 degrees counter-clockwise
+                    frame = cv2.rotate(frame, cv2.ROTATE_90_COUNTERCLOCKWISE)
+                elif self.rotation == 180 or self.rotation == -180:
+                    # 180 degrees rotation
+                    frame = cv2.rotate(frame, cv2.ROTATE_180)
+        else:
+            if self.rotation == -90 or self.rotation == 270:
+                # -90 degrees = rotate 90 degrees clockwise
+                frame = cv2.rotate(frame, cv2.ROTATE_90_CLOCKWISE)
+            elif self.rotation == 90 or self.rotation == -270:
+                # 90 degrees = rotate 90 degrees counter-clockwise
+                frame = cv2.rotate(frame, cv2.ROTATE_90_COUNTERCLOCKWISE)
+            elif self.rotation == 180 or self.rotation == -180:
+                # 180 degrees rotation
+                frame = cv2.rotate(frame, cv2.ROTATE_180)
 
         return frame
 

kinemotion/dropjump/debug_overlay.py

@@ -138,42 +138,53 @@ class DebugOverlayRenderer(BaseDebugOverlayRenderer):
         Returns:
             Frame with debug overlay
         """
-        annotated = frame.copy()
-
-        # Draw landmarks
-        if landmarks:
-            if use_com:
-                self._draw_com_visualization(annotated, landmarks, contact_state)
-            else:
-                self._draw_foot_visualization(annotated, landmarks, contact_state)
-
-        # Draw contact state
-        state_color = (
-            (0, 255, 0) if contact_state == ContactState.ON_GROUND else (0, 0, 255)
-        )
-        cv2.putText(
-            annotated,
-            f"State: {contact_state.value}",
-            (10, 30),
-            cv2.FONT_HERSHEY_SIMPLEX,
-            1,
-            state_color,
-            2,
-        )
-
-        # Draw frame number
-        cv2.putText(
-            annotated,
-            f"Frame: {frame_idx}",
-            (10, 70),
-            cv2.FONT_HERSHEY_SIMPLEX,
-            0.7,
-            (255, 255, 255),
-            2,
-        )
-
-        # Draw phase labels
-        if metrics:
-            self._draw_phase_labels(annotated, frame_idx, metrics)
+        if self.timer:
+            with self.timer.measure("debug_video_copy"):
+                annotated = frame.copy()
+        else:
+            annotated = frame.copy()
+
+        def _draw_overlays() -> None:
+            # Draw landmarks
+            if landmarks:
+                if use_com:
+                    self._draw_com_visualization(annotated, landmarks, contact_state)
+                else:
+                    self._draw_foot_visualization(annotated, landmarks, contact_state)
+
+            # Draw contact state
+            state_color = (
+                (0, 255, 0) if contact_state == ContactState.ON_GROUND else (0, 0, 255)
+            )
+            cv2.putText(
+                annotated,
+                f"State: {contact_state.value}",
+                (10, 30),
+                cv2.FONT_HERSHEY_SIMPLEX,
+                1,
+                state_color,
+                2,
+            )
+
+            # Draw frame number
+            cv2.putText(
+                annotated,
+                f"Frame: {frame_idx}",
+                (10, 70),
+                cv2.FONT_HERSHEY_SIMPLEX,
+                0.7,
+                (255, 255, 255),
+                2,
+            )
+
+            # Draw phase labels
+            if metrics:
+                self._draw_phase_labels(annotated, frame_idx, metrics)
+
+        if self.timer:
+            with self.timer.measure("debug_video_draw"):
+                _draw_overlays()
+        else:
+            _draw_overlays()
 
         return annotated

{kinemotion-0.42.0.dist-info → kinemotion-0.43.0.dist-info}/METADATA

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

@@ -1,5 +1,5 @@
 kinemotion/__init__.py,sha256=wPItmyGJUOFM6GPRVhAEvRz0-ErI7e2qiUREYJ9EfPQ,943
-kinemotion/api.py,sha256=plEUM5kuSvPJNgIg-iDFzwHCLU2w9YjUpDpBE7BHNWA,58273
+kinemotion/api.py,sha256=oSCc3GNJcIBhjHyCoHbWRur8q3IzMP5y43ngwjyLwkg,52174
 kinemotion/cli.py,sha256=cqYV_7URH0JUDy1VQ_EDLv63FmNO4Ns20m6s1XAjiP4,464
 kinemotion/cmj/__init__.py,sha256=Ynv0-Oco4I3Y1Ubj25m3h9h2XFqeNwpAewXmAYOmwfU,127
 kinemotion/cmj/analysis.py,sha256=qtULzp9uYzm5M0_Qu5YGJpuwjg9fz1VKAg6xg4NJxvM,21639
@@ -12,7 +12,7 @@ kinemotion/cmj/validation_bounds.py,sha256=9ZTo68fl3ooyWjXXyTMRLpK9tFANa_rQf3oHh
 kinemotion/core/__init__.py,sha256=GTLnE_gGIk7HC51epWUXVuNxcvS5lf7UL6qeWRlgMV0,1352
 kinemotion/core/auto_tuning.py,sha256=wtCUMOhBChVJNXfEeku3GCMW4qED6MF-O_mv2sPTiVQ,11324
 kinemotion/core/cli_utils.py,sha256=zbnifPhD-OYofJioeYfJtshuWcl8OAEWtqCGVF4ctAI,7966
-kinemotion/core/debug_overlay_utils.py,sha256=sUx_A14iZkJJjmUVeqvD_g2zAO9PwlzF3xrP4FLuiTc,7625
+kinemotion/core/debug_overlay_utils.py,sha256=vOoWv3vlNdNgPI2R-UwAZKtSpugUUsiokR_kvaz1UWg,9025
 kinemotion/core/determinism.py,sha256=NwVrHqJiVxxFHTBPVy8aDBJH2SLIcYIpdGFp7glblB8,2515
 kinemotion/core/experimental.py,sha256=IK05AF4aZS15ke85hF3TWCqRIXU1AlD_XKzFz735Ua8,3640
 kinemotion/core/filtering.py,sha256=GsC9BB71V07LJJHgS2lsaxUAtJsupcUiwtZFDgODh8c,11417
@@ -23,17 +23,17 @@ kinemotion/core/quality.py,sha256=dPGQp08y8DdEUbUdjTThnUOUsALgF0D2sdz50cm6wLI,13
 kinemotion/core/smoothing.py,sha256=GAfC-jxu1eqNyDjsUXqUBicKx9um5hrk49wz1FxfRNM,15219
 kinemotion/core/timing.py,sha256=bdRg1g7J0-eWB3oj7tEF5Ucp_tiad1IxsM14edAZQu4,1484
 kinemotion/core/validation.py,sha256=LmKfSl4Ayw3DgwKD9IrhsPdzp5ia4drLsHA2UuU1SCM,6310
-kinemotion/core/video_io.py,sha256=Nn5xIt4iZCQxaP9g0cpWFeNsz5AgUlWbZ_B8ZCfd4lw,7869
+kinemotion/core/video_io.py,sha256=HyLwn22fKe37j18853YYYrQi0JQWAwxpepPLNkuZKnQ,8586
 kinemotion/dropjump/__init__.py,sha256=tC3H3BrCg8Oj-db-Vrtx4PH_llR1Ppkd5jwaOjhQcLg,862
 kinemotion/dropjump/analysis.py,sha256=MjxO-vps0nz_hXlnGk7cgq3jFenJYzsM0VVpHwnHXsM,27935
 kinemotion/dropjump/cli.py,sha256=n_Wfv3AC6YIgRPYhO3F2nTSai0NR7fh95nAoWjryQeY,16250
-kinemotion/dropjump/debug_overlay.py,sha256=LkPw6ucb7beoYWS4L-Lvjs1KLCm5wAWDAfiznUeV2IQ,5668
+kinemotion/dropjump/debug_overlay.py,sha256=9nlnDYB_ZJO4dC1uMhDa4UOYGMBsDpyPQD3WbJjbwpM,6130
 kinemotion/dropjump/kinematics.py,sha256=kH-XM66wlOCYMpjvyb6_Qh5ZebyOfFZ47rmhgE1Tww4,19404
 kinemotion/dropjump/metrics_validator.py,sha256=CrTlGup8q2kyPXtA6HNwm7_yq0AsBaDllG7RVZdXmYA,9342
 kinemotion/dropjump/validation_bounds.py,sha256=5b4I3CKPybuvrbn-nP5yCcGF_sH4Vtyw3a5AWWvWnBk,4645
 kinemotion/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kinemotion-0.42.0.dist-info/METADATA,sha256=tPUkpNnzytbN0vxVda5Dcx8Q7M1edBJfStsU_MJGM7E,26020
-kinemotion-0.42.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-kinemotion-0.42.0.dist-info/entry_points.txt,sha256=zaqnAnjLvcdrk1Qvj5nvXZCZ2gp0prS7it1zTJygcIY,50
-kinemotion-0.42.0.dist-info/licenses/LICENSE,sha256=KZajvqsHw0NoOHOi2q0FZ4NBe9HdV6oey-IPYAtHXfg,1088
-kinemotion-0.42.0.dist-info/RECORD,,
+kinemotion-0.43.0.dist-info/METADATA,sha256=BTxQ2TBeVYsVzux_OTmoE-tOu8gbEBv2oxe7j-3nyDM,26020
+kinemotion-0.43.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+kinemotion-0.43.0.dist-info/entry_points.txt,sha256=zaqnAnjLvcdrk1Qvj5nvXZCZ2gp0prS7it1zTJygcIY,50
+kinemotion-0.43.0.dist-info/licenses/LICENSE,sha256=KZajvqsHw0NoOHOi2q0FZ4NBe9HdV6oey-IPYAtHXfg,1088
+kinemotion-0.43.0.dist-info/RECORD,,