kinemotion 0.46.0__py3-none-any.whl → 0.47.0__py3-none-any.whl

kinemotion/api.py

@@ -39,7 +39,7 @@ from .core.pipeline_utils import (
 )
 from .core.pose import PoseTracker
 from .core.quality import assess_jump_quality
-from .core.timing import PerformanceTimer
+from .core.timing import NULL_TIMER, PerformanceTimer, Timer
 from .core.video_io import VideoProcessor
 from .dropjump.analysis import (
     detect_ground_contact,
@@ -86,7 +86,7 @@ def _generate_debug_video(
     smoothed_landmarks: list,
     contact_states: list,
     metrics: DropJumpMetrics,
-    timer: PerformanceTimer | None,
+    timer: Timer | None,
     verbose: bool,
 ) -> None:
     """Generate debug video with overlay."""
@@ -96,6 +96,7 @@ def _generate_debug_video(
     if not frames:
         return
 
+    timer = timer or NULL_TIMER
     debug_h, debug_w = frames[0].shape[:2]
 
     if video_fps > 30:
@@ -129,11 +130,7 @@ def _generate_debug_video(
         timer=timer,
     )
 
-    if timer:
-        with timer.measure("debug_video_generation"):
-            with renderer_context as renderer:
-                _render_frames(renderer)
-    else:
+    with timer.measure("debug_video_generation"):
         with renderer_context as renderer:
             _render_frames(renderer)
 
@@ -154,7 +151,7 @@ def process_dropjump_video(
     detection_confidence: float | None = None,
     tracking_confidence: float | None = None,
     verbose: bool = False,
-    timer: PerformanceTimer | None = None,
+    timer: Timer | None = None,
     pose_tracker: "PoseTracker | None" = None,
 ) -> DropJumpMetrics:
     """
@@ -175,7 +172,7 @@ def process_dropjump_video(
         detection_confidence: Optional override for pose detection confidence
         tracking_confidence: Optional override for pose tracking confidence
         verbose: Print processing details
-        timer: Optional PerformanceTimer for measuring operations
+        timer: Optional Timer for measuring operations
         pose_tracker: Optional pre-initialized PoseTracker instance (reused if provided)
 
     Returns:
@@ -263,6 +260,7 @@ def process_dropjump_video(
                     visibilities=visibilities,
                     window_length=params.smoothing_window,
                     polyorder=params.polyorder,
+                    timer=timer,
                 )
 
             if verbose:
@@ -277,6 +275,7 @@ def process_dropjump_video(
                     smoothing_window=params.smoothing_window,
                     polyorder=params.polyorder,
                     use_curvature=params.use_curvature,
+                    timer=timer,
                 )
 
             if verbose:
@@ -391,13 +390,7 @@ def process_dropjump_video(
             metrics.result_metadata = result_metadata
 
             if json_output:
-                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:
+                with timer.measure("json_serialization"):
                     output_path = Path(json_output)
                     metrics_dict = metrics.to_dict()
                     json_str = json.dumps(metrics_dict, indent=2)
@@ -528,7 +521,7 @@ def process_cmj_video(
     detection_confidence: float | None = None,
     tracking_confidence: float | None = None,
     verbose: bool = False,
-    timer: PerformanceTimer | None = None,
+    timer: Timer | None = None,
     pose_tracker: "PoseTracker | None" = None,
 ) -> CMJMetrics:
     """
@@ -550,7 +543,7 @@ def process_cmj_video(
         detection_confidence: Optional override for pose detection confidence
         tracking_confidence: Optional override for pose tracking confidence
         verbose: Print processing details
-        timer: Optional PerformanceTimer for measuring operations
+        timer: Optional Timer for measuring operations
         pose_tracker: Optional pre-initialized PoseTracker instance (reused if provided)
 
     Returns:
@@ -644,6 +637,7 @@ def process_cmj_video(
                     window_length=params.smoothing_window,
                     polyorder=params.polyorder,
                     landing_positions=foot_positions,
+                    timer=timer,
                 )
 
             if phases is None:
@@ -738,23 +732,7 @@ def process_cmj_video(
                 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,
-                            debug_w,
-                            debug_h,
-                            debug_w,
-                            debug_h,
-                            debug_fps,
-                            timer=timer,
-                        ) as renderer:
-                            for frame, idx in zip(frames, frame_indices, strict=True):
-                                annotated = renderer.render_frame(
-                                    frame, smoothed_landmarks[idx], idx, metrics
-                                )
-                                renderer.write_frame(annotated)
-                else:
+                with timer.measure("debug_video_generation"):
                     with CMJDebugOverlayRenderer(
                         output_video,
                         debug_w,
@@ -799,13 +777,7 @@ def process_cmj_video(
             metrics.result_metadata = result_metadata
 
             if json_output:
-                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:
+                with timer.measure("json_serialization"):
                     output_path = Path(json_output)
                     metrics_dict = metrics.to_dict()
                     json_str = json.dumps(metrics_dict, indent=2)

kinemotion/cmj/analysis.py

@@ -7,6 +7,7 @@ from scipy.signal import savgol_filter
 
 from ..core.experimental import unused
 from ..core.smoothing import compute_acceleration_from_derivative
+from ..core.timing import NULL_TIMER, Timer
 
 
 def compute_signed_velocity(
@@ -545,6 +546,7 @@ def detect_cmj_phases(
     window_length: int = 5,
     polyorder: int = 2,
     landing_positions: np.ndarray | None = None,
+    timer: Timer | None = None,
 ) -> tuple[float | None, float, float, float] | None:
     """
     Detect all phases of a counter movement jump using a simplified, robust approach.
@@ -562,18 +564,22 @@ def detect_cmj_phases(
         polyorder: Polynomial order for Savitzky-Golay filter
         landing_positions: Optional array of positions for landing detection
             (e.g., Feet). If None, uses `positions` (Hips) for landing too.
+        timer: Optional Timer for measuring operations
 
     Returns:
         Tuple of (standing_end_frame, lowest_point_frame, takeoff_frame, landing_frame)
         with fractional precision, or None if phases cannot be detected.
     """
+    timer = timer or NULL_TIMER
+
     # Compute SIGNED velocities and accelerations for primary signal (Hips)
-    velocities = compute_signed_velocity(
-        positions, window_length=window_length, polyorder=polyorder
-    )
-    accelerations = compute_acceleration_from_derivative(
-        positions, window_length=window_length, polyorder=polyorder
-    )
+    with timer.measure("cmj_compute_derivatives"):
+        velocities = compute_signed_velocity(
+            positions, window_length=window_length, polyorder=polyorder
+        )
+        accelerations = compute_acceleration_from_derivative(
+            positions, window_length=window_length, polyorder=polyorder
+        )
 
     # Step 1: Find peak height (global minimum y = highest point in frame)
     peak_height_frame = int(np.argmin(positions))
@@ -581,34 +587,42 @@ def detect_cmj_phases(
         return None  # Peak too early, invalid
 
     # Step 2-4: Find all phases using helper functions
-    takeoff_frame = find_takeoff_frame(velocities, peak_height_frame, fps)
-    lowest_point = find_lowest_frame(velocities, positions, takeoff_frame, fps)
+    with timer.measure("cmj_find_takeoff"):
+        takeoff_frame = find_takeoff_frame(velocities, peak_height_frame, fps)
+
+    with timer.measure("cmj_find_lowest_point"):
+        lowest_point = find_lowest_frame(velocities, positions, takeoff_frame, fps)
 
     # Determine landing frame
-    if landing_positions is not None:
-        # Use specific landing signal (Feet) for landing detection
-        landing_velocities = compute_signed_velocity(
-            landing_positions, window_length=window_length, polyorder=polyorder
-        )
-        landing_accelerations = compute_acceleration_from_derivative(
-            landing_positions, window_length=window_length, polyorder=polyorder
-        )
-        # We still reference peak_height_frame from Hips, as Feet peak
-        # might be different/noisy but generally they align in time.
-        landing_frame = find_landing_frame(
-            landing_accelerations,
-            landing_velocities,
-            peak_height_frame,
-            fps,
-        )
-    else:
-        # Use primary signal (Hips)
-        landing_frame = find_landing_frame(
-            accelerations,
-            velocities,
-            peak_height_frame,
-            fps,
+    with timer.measure("cmj_find_landing"):
+        if landing_positions is not None:
+            # Use specific landing signal (Feet) for landing detection
+            landing_velocities = compute_signed_velocity(
+                landing_positions, window_length=window_length, polyorder=polyorder
+            )
+            landing_accelerations = compute_acceleration_from_derivative(
+                landing_positions, window_length=window_length, polyorder=polyorder
+            )
+            # We still reference peak_height_frame from Hips, as Feet peak
+            # might be different/noisy but generally they align in time.
+            landing_frame = find_landing_frame(
+                landing_accelerations,
+                landing_velocities,
+                peak_height_frame,
+                fps,
+            )
+        else:
+            # Use primary signal (Hips)
+            landing_frame = find_landing_frame(
+                accelerations,
+                velocities,
+                peak_height_frame,
+                fps,
+            )
+
+    with timer.measure("cmj_find_standing_end"):
+        standing_end = find_standing_end(
+            velocities, lowest_point, positions, accelerations
         )
 
-    standing_end = find_standing_end(velocities, lowest_point, positions, accelerations)
     return (standing_end, lowest_point, takeoff_frame, landing_frame)

kinemotion/core/__init__.py

@@ -22,7 +22,14 @@ from .smoothing import (
     smooth_landmarks,
     smooth_landmarks_advanced,
 )
-from .timing import NULL_TIMER, NullTimer, PerformanceTimer, Timer
+from .timing import (
+    NULL_TIMER,
+    CompositeTimer,
+    NullTimer,
+    OpenTelemetryTimer,
+    PerformanceTimer,
+    Timer,
+)
 from .video_io import VideoProcessor
 
 __all__ = [
@@ -52,6 +59,8 @@ __all__ = [
     "Timer",
     "NullTimer",
     "NULL_TIMER",
+    "CompositeTimer",
+    "OpenTelemetryTimer",
     # Video I/O
     "VideoProcessor",
 ]

kinemotion/core/debug_overlay_utils.py

@@ -10,7 +10,7 @@ from typing import Self
 import cv2
 import numpy as np
 
-from .timing import PerformanceTimer
+from .timing import NULL_TIMER, Timer
 
 
 def create_video_writer(
@@ -107,7 +107,7 @@ class BaseDebugOverlayRenderer:
         display_width: int,
         display_height: int,
         fps: float,
-        timer: PerformanceTimer | None = None,
+        timer: Timer | None = None,
     ):
         """
         Initialize overlay renderer.
@@ -119,12 +119,12 @@ class BaseDebugOverlayRenderer:
             display_width: Display width (considering SAR)
             display_height: Display height (considering SAR)
             fps: Frames per second
-            timer: Optional PerformanceTimer for measuring operations
+            timer: Optional Timer for measuring operations
         """
         self.output_path = output_path
         self.width = width
         self.height = height
-        self.timer = timer
+        self.timer = timer or NULL_TIMER
 
         # Optimize debug video resolution: Cap max dimension to 720p
         # Reduces software encoding time on single-core Cloud Run instances.
@@ -166,26 +166,14 @@ class BaseDebugOverlayRenderer:
 
         # Resize to display dimensions if needed (to handle SAR)
         if self.needs_resize:
-            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:
+            with self.timer.measure("debug_video_resize"):
                 frame = cv2.resize(
                     frame,
                     (self.display_width, self.display_height),
                     interpolation=cv2.INTER_LINEAR,
                 )
 
-        if self.timer:
-            with self.timer.measure("debug_video_write"):
-                write_overlay_frame(
-                    self.writer, frame, self.display_width, self.display_height
-                )
-        else:
+        with self.timer.measure("debug_video_write"):
             write_overlay_frame(
                 self.writer, frame, self.display_width, self.display_height
             )

kinemotion/core/pipeline_utils.py

@@ -12,7 +12,7 @@ from ..dropjump.analysis import compute_average_foot_position
 from .auto_tuning import AnalysisParameters, QualityPreset, VideoCharacteristics
 from .pose import PoseTracker
 from .smoothing import smooth_landmarks, smooth_landmarks_advanced
-from .timing import PerformanceTimer
+from .timing import NULL_TIMER, Timer
 from .video_io import VideoProcessor
 
 TResult = TypeVar("TResult")
@@ -182,7 +182,7 @@ def process_all_frames(
     video: VideoProcessor,
     tracker: PoseTracker,
     verbose: bool,
-    timer: PerformanceTimer | None = None,
+    timer: Timer | None = None,
     close_tracker: bool = True,
     target_debug_fps: float = 30.0,
     max_debug_dim: int = 720,
@@ -193,7 +193,7 @@ def process_all_frames(
         video: Video processor to read frames from
         tracker: Pose tracker for landmark detection
         verbose: Print progress messages
-        timer: Optional PerformanceTimer for measuring operations
+        timer: Optional Timer 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)
@@ -207,6 +207,7 @@ def process_all_frames(
     if verbose:
         print("Tracking pose landmarks...")
 
+    timer = timer or NULL_TIMER
     step = max(1, int(video.fps / target_debug_fps))
 
     w, h = video.display_width, video.display_height
@@ -218,12 +219,7 @@ def process_all_frames(
     debug_h = int(h * scale) // 2 * 2
     should_resize = (debug_w != video.width) or (debug_h != video.height)
 
-    if timer:
-        with timer.measure("pose_tracking"):
-            debug_frames, landmarks_sequence, frame_indices = _process_frames_loop(
-                video, tracker, step, should_resize, debug_w, debug_h
-            )
-    else:
+    with timer.measure("pose_tracking"):
         debug_frames, landmarks_sequence, frame_indices = _process_frames_loop(
             video, tracker, step, should_resize, debug_w, debug_h
         )
@@ -241,7 +237,7 @@ def apply_smoothing(
     landmarks_sequence: list,
     params: AnalysisParameters,
     verbose: bool,
-    timer: PerformanceTimer | None = None,
+    timer: Timer | None = None,
 ) -> list:
     """Apply smoothing to landmark sequence with auto-tuned parameters.
 
@@ -249,11 +245,12 @@ def apply_smoothing(
         landmarks_sequence: Sequence of landmarks from all frames
         params: Auto-tuned parameters containing smoothing settings
         verbose: Print progress messages
-        timer: Optional PerformanceTimer for measuring operations
+        timer: Optional Timer for measuring operations
 
     Returns:
         Smoothed landmarks sequence
     """
+    timer = timer or NULL_TIMER
     use_advanced = params.outlier_rejection or params.bilateral_filter
 
     if verbose:
@@ -273,6 +270,7 @@ def apply_smoothing(
                 polyorder=params.polyorder,
                 use_outlier_rejection=params.outlier_rejection,
                 use_bilateral=params.bilateral_filter,
+                timer=timer,
             )
         else:
             return smooth_landmarks(
@@ -281,10 +279,8 @@ def apply_smoothing(
                 polyorder=params.polyorder,
             )
 
-    if timer:
-        with timer.measure("smoothing"):
-            return _run_smoothing()
-    return _run_smoothing()
+    with timer.measure("smoothing"):
+        return _run_smoothing()
 
 
 def calculate_foot_visibility(frame_landmarks: dict) -> float:
@@ -341,7 +337,7 @@ def convert_timer_to_stage_names(
     """Convert timer metric names to human-readable stage names.
 
     Args:
-        timer_metrics: Dictionary from PerformanceTimer.get_metrics()
+        timer_metrics: Dictionary from Timer.get_metrics()
 
     Returns:
         Dictionary with human-readable stage names as keys
@@ -366,6 +362,24 @@ def convert_timer_to_stage_names(
         "debug_video_copy": "Debug video frame copy",
         "debug_video_draw": "Debug video drawing",
         "debug_video_write": "Debug video encoding",
+        # Granular metrics
+        "frame_conversion": "Frame BGR-RGB conversion",
+        "mediapipe_inference": "MediaPipe inference",
+        "landmark_extraction": "Landmark extraction",
+        "smoothing_outlier_rejection": "Smoothing (outlier rejection)",
+        "smoothing_bilateral": "Smoothing (bilateral)",
+        "smoothing_savgol": "Smoothing (Savitzky-Golay)",
+        "cmj_compute_derivatives": "CMJ derivatives computation",
+        "cmj_find_takeoff": "CMJ takeoff detection",
+        "cmj_find_lowest_point": "CMJ lowest point detection",
+        "cmj_find_landing": "CMJ landing detection",
+        "cmj_find_standing_end": "CMJ standing end detection",
+        "dj_compute_velocity": "DJ velocity computation",
+        "dj_find_contact_frames": "DJ contact frame search",
+        "dj_detect_drop_start": "DJ drop start detection",
+        "dj_find_phases": "DJ phase finding",
+        "dj_identify_contact": "DJ contact identification",
+        "dj_analyze_flight": "DJ flight analysis",
     }
     return {mapping.get(k, k): v for k, v in timer_metrics.items()}
 

kinemotion/core/pose.py

@@ -4,7 +4,7 @@ import cv2
 import mediapipe as mp
 import numpy as np
 
-from .timing import PerformanceTimer
+from .timing import NULL_TIMER, Timer
 
 
 class PoseTracker:
@@ -14,7 +14,7 @@ class PoseTracker:
         self,
         min_detection_confidence: float = 0.5,
         min_tracking_confidence: float = 0.5,
-        timer: PerformanceTimer | None = None,
+        timer: Timer | None = None,
     ) -> None:
         """
         Initialize the pose tracker.
@@ -22,9 +22,9 @@ class PoseTracker:
         Args:
             min_detection_confidence: Minimum confidence for pose detection
             min_tracking_confidence: Minimum confidence for pose tracking
-            timer: Optional PerformanceTimer for measuring operations
+            timer: Optional Timer for measuring operations
         """
-        self.timer = timer
+        self.timer = timer or NULL_TIMER
         self.mp_pose = mp.solutions.pose
         self.pose = self.mp_pose.Pose(
             static_image_mode=False,  # Use tracking mode for better performance
@@ -47,42 +47,41 @@ class PoseTracker:
             or None if no pose detected. Coordinates are normalized (0-1).
         """
         # Convert BGR to RGB
-        rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        with self.timer.measure("frame_conversion"):
+            rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
 
         # Process the frame
-        if self.timer:
-            with self.timer.measure("mediapipe_inference"):
-                results = self.pose.process(rgb_frame)
-        else:
+        with self.timer.measure("mediapipe_inference"):
             results = self.pose.process(rgb_frame)
 
         if not results.pose_landmarks:
             return None
 
         # Extract key landmarks for feet tracking and CoM estimation
-        landmarks = {}
-        landmark_names = {
-            # Feet landmarks
-            self.mp_pose.PoseLandmark.LEFT_ANKLE: "left_ankle",
-            self.mp_pose.PoseLandmark.RIGHT_ANKLE: "right_ankle",
-            self.mp_pose.PoseLandmark.LEFT_HEEL: "left_heel",
-            self.mp_pose.PoseLandmark.RIGHT_HEEL: "right_heel",
-            self.mp_pose.PoseLandmark.LEFT_FOOT_INDEX: "left_foot_index",
-            self.mp_pose.PoseLandmark.RIGHT_FOOT_INDEX: "right_foot_index",
-            # Torso landmarks for CoM estimation
-            self.mp_pose.PoseLandmark.LEFT_HIP: "left_hip",
-            self.mp_pose.PoseLandmark.RIGHT_HIP: "right_hip",
-            self.mp_pose.PoseLandmark.LEFT_SHOULDER: "left_shoulder",
-            self.mp_pose.PoseLandmark.RIGHT_SHOULDER: "right_shoulder",
-            # Additional landmarks for better CoM estimation
-            self.mp_pose.PoseLandmark.NOSE: "nose",
-            self.mp_pose.PoseLandmark.LEFT_KNEE: "left_knee",
-            self.mp_pose.PoseLandmark.RIGHT_KNEE: "right_knee",
-        }
-
-        for landmark_id, name in landmark_names.items():
-            lm = results.pose_landmarks.landmark[landmark_id]
-            landmarks[name] = (lm.x, lm.y, lm.visibility)
+        with self.timer.measure("landmark_extraction"):
+            landmarks = {}
+            landmark_names = {
+                # Feet landmarks
+                self.mp_pose.PoseLandmark.LEFT_ANKLE: "left_ankle",
+                self.mp_pose.PoseLandmark.RIGHT_ANKLE: "right_ankle",
+                self.mp_pose.PoseLandmark.LEFT_HEEL: "left_heel",
+                self.mp_pose.PoseLandmark.RIGHT_HEEL: "right_heel",
+                self.mp_pose.PoseLandmark.LEFT_FOOT_INDEX: "left_foot_index",
+                self.mp_pose.PoseLandmark.RIGHT_FOOT_INDEX: "right_foot_index",
+                # Torso landmarks for CoM estimation
+                self.mp_pose.PoseLandmark.LEFT_HIP: "left_hip",
+                self.mp_pose.PoseLandmark.RIGHT_HIP: "right_hip",
+                self.mp_pose.PoseLandmark.LEFT_SHOULDER: "left_shoulder",
+                self.mp_pose.PoseLandmark.RIGHT_SHOULDER: "right_shoulder",
+                # Additional landmarks for better CoM estimation
+                self.mp_pose.PoseLandmark.NOSE: "nose",
+                self.mp_pose.PoseLandmark.LEFT_KNEE: "left_knee",
+                self.mp_pose.PoseLandmark.RIGHT_KNEE: "right_knee",
+            }
+
+            for landmark_id, name in landmark_names.items():
+                lm = results.pose_landmarks.landmark[landmark_id]
+                landmarks[name] = (lm.x, lm.y, lm.visibility)
 
         return landmarks
 

kinemotion/core/smoothing.py

@@ -9,6 +9,7 @@ from .filtering import (
     bilateral_temporal_filter,
     reject_outliers,
 )
+from .timing import NULL_TIMER, Timer
 
 # Type aliases for landmark data structures
 LandmarkCoord: TypeAlias = tuple[float, float, float]  # (x, y, visibility)
@@ -347,6 +348,7 @@ def smooth_landmarks_advanced(
     ransac_threshold: float = 0.02,
     bilateral_sigma_spatial: float = 3.0,
     bilateral_sigma_intensity: float = 0.02,
+    timer: Timer | None = None,
 ) -> LandmarkSequence:
     """
     Advanced landmark smoothing with outlier rejection and bilateral filtering.
@@ -365,10 +367,12 @@ def smooth_landmarks_advanced(
         ransac_threshold: Threshold for RANSAC outlier detection
         bilateral_sigma_spatial: Spatial sigma for bilateral filter
         bilateral_sigma_intensity: Intensity sigma for bilateral filter
+        timer: Optional Timer for measuring operations
 
     Returns:
         Smoothed landmark sequence with same structure as input
     """
+    timer = timer or NULL_TIMER
     if len(landmark_sequence) < window_length:
         return landmark_sequence
 
@@ -382,37 +386,40 @@ def smooth_landmarks_advanced(
 
         # Step 1: Outlier rejection
         if use_outlier_rejection:
-            x_array, _ = reject_outliers(
-                x_array,
-                use_ransac=True,
-                use_median=True,
-                ransac_threshold=ransac_threshold,
-            )
-            y_array, _ = reject_outliers(
-                y_array,
-                use_ransac=True,
-                use_median=True,
-                ransac_threshold=ransac_threshold,
-            )
+            with timer.measure("smoothing_outlier_rejection"):
+                x_array, _ = reject_outliers(
+                    x_array,
+                    use_ransac=True,
+                    use_median=True,
+                    ransac_threshold=ransac_threshold,
+                )
+                y_array, _ = reject_outliers(
+                    y_array,
+                    use_ransac=True,
+                    use_median=True,
+                    ransac_threshold=ransac_threshold,
+                )
 
         # Step 2: Smoothing (bilateral or Savitzky-Golay)
         if use_bilateral:
-            x_smooth = bilateral_temporal_filter(
-                x_array,
-                window_size=window_length,
-                sigma_spatial=bilateral_sigma_spatial,
-                sigma_intensity=bilateral_sigma_intensity,
-            )
-            y_smooth = bilateral_temporal_filter(
-                y_array,
-                window_size=window_length,
-                sigma_spatial=bilateral_sigma_spatial,
-                sigma_intensity=bilateral_sigma_intensity,
-            )
+            with timer.measure("smoothing_bilateral"):
+                x_smooth = bilateral_temporal_filter(
+                    x_array,
+                    window_size=window_length,
+                    sigma_spatial=bilateral_sigma_spatial,
+                    sigma_intensity=bilateral_sigma_intensity,
+                )
+                y_smooth = bilateral_temporal_filter(
+                    y_array,
+                    window_size=window_length,
+                    sigma_spatial=bilateral_sigma_spatial,
+                    sigma_intensity=bilateral_sigma_intensity,
+                )
         else:
             # Standard Savitzky-Golay
-            x_smooth = savgol_filter(x_array, window_length, polyorder)
-            y_smooth = savgol_filter(y_array, window_length, polyorder)
+            with timer.measure("smoothing_savgol"):
+                x_smooth = savgol_filter(x_array, window_length, polyorder)
+                y_smooth = savgol_filter(y_array, window_length, polyorder)
 
         return x_smooth, y_smooth
 

kinemotion/core/timing.py

@@ -26,9 +26,43 @@ Example:
 """
 
 import time
-from contextlib import AbstractContextManager
+from contextlib import AbstractContextManager, ExitStack, contextmanager
 from typing import Protocol, runtime_checkable
 
+# OpenTelemetry related imports, guarded by try-except for optional dependency
+_trace_module = None  # This will hold the actual 'trace' module if imported
+_otel_tracer_class = None  # This will hold the actual 'Tracer' class if imported
+
+try:
+    import opentelemetry.trace as _trace_module_import  # Import the module directly
+
+    _otel_tracer_class = (
+        _trace_module_import.Tracer
+    )  # Get the Tracer class from the module
+    _trace_module = (
+        _trace_module_import  # Expose the trace module globally after successful import
+    )
+except ImportError:
+    pass  # No OTel, so these remain None
+
+# Now define the global/module-level variables used elsewhere
+# Conditionally expose 'trace' and 'Tracer' aliases
+trace = _trace_module  # This will be the actual module or None
+
+
+class Tracer:  # Dummy for type hints if actual Tracer is not available
+    pass
+
+
+if _otel_tracer_class:
+    Tracer = _otel_tracer_class  # Override dummy if actual Tracer is available
+
+# This _OPENTELEMETRY_AVAILABLE variable is assigned only once,
+# after the try-except block
+_OPENTELEMETRY_AVAILABLE = bool(
+    _otel_tracer_class
+)  # True if Tracer class was successfully loaded
+
 
 @runtime_checkable
 class Timer(Protocol):
@@ -59,6 +93,87 @@ class Timer(Protocol):
         ...
 
 
+class _NullContext(AbstractContextManager[None]):
+    """Singleton null context manager with zero overhead.
+
+    Implements the context manager protocol but performs no operations.
+    Optimized away by the Python interpreter for minimal overhead.
+    """
+
+    __slots__ = ()
+
+    def __enter__(self) -> None:
+        """No-op entry - returns immediately."""
+        return None
+
+    def __exit__(self, exc_type: object, exc_val: object, exc_tb: object) -> bool:
+        """No-op exit - returns immediately.
+
+        Args:
+            exc_type: Exception type (ignored)
+            exc_val: Exception value (ignored)
+            exc_tb: Exception traceback (ignored)
+
+        Returns:
+            False (does not suppress exceptions)
+        """
+        return False
+
+
+class NullTimer:
+    """No-op timer implementing the Null Object Pattern.
+
+    Provides zero-overhead instrumentation when profiling is disabled.
+    All methods are no-ops that optimize away at runtime.
+
+    Performance: ~20-30 nanoseconds overhead per measure() call.
+    This is negligible compared to any actual work being measured.
+
+    Use Cases:
+        - Production deployments (profiling disabled)
+        - Performance-critical paths
+        - Testing without timing dependencies
+
+    Example:
+        # Use global singleton for zero allocation overhead
+        tracker = PoseTracker(timer=NULL_TIMER)
+
+        # No overhead - measure() call optimizes to nothing
+        with tracker.timer.measure("operation"):
+            do_work()
+    """
+
+    __slots__ = ()
+
+    def measure(self, name: str) -> AbstractContextManager[None]:
+        """Return a no-op context manager.
+
+        This method does nothing and is optimized away by the Python interpreter.
+        The context manager protocol (__enter__/__exit__) has minimal overhead.
+
+        Args:
+            name: Ignored - kept for protocol compatibility
+
+        Returns:
+            Singleton null context manager
+        """
+        return _NULL_CONTEXT
+
+    def get_metrics(self) -> dict[str, float]:
+        """Return empty metrics dictionary.
+
+        Returns:
+            Empty dictionary (no metrics collected)
+        """
+        return {}
+
+
+# Singleton instances for global reuse
+# Use these instead of creating new instances to avoid allocation overhead
+_NULL_CONTEXT = _NullContext()
+NULL_TIMER: Timer = NullTimer()
+
+
 class _MeasureContext(AbstractContextManager[None]):
     """Optimized context manager for active timing.
 
@@ -165,82 +280,103 @@ class PerformanceTimer:
         return self.metrics.copy()
 
 
-class _NullContext(AbstractContextManager[None]):
-    """Singleton null context manager with zero overhead.
+@contextmanager
+def _composite_context_manager(contexts: list[AbstractContextManager[None]]):
+    """Helper to combine multiple context managers into one.
 
-    Implements the context manager protocol but performs no operations.
-    Optimized away by the Python interpreter for minimal overhead.
+    Uses ExitStack to manage entering and exiting multiple contexts transparently.
     """
+    with ExitStack() as stack:
+        for ctx in contexts:
+            stack.enter_context(ctx)
+        yield
 
-    __slots__ = ()
 
-    def __enter__(self) -> None:
-        """No-op entry - returns immediately."""
-        return None
+class CompositeTimer:
+    """Timer that delegates measurements to multiple underlying timers.
 
-    def __exit__(self, exc_type: object, exc_val: object, exc_tb: object) -> bool:
-        """No-op exit - returns immediately.
+    Useful for enabling both local performance timing (for JSON output)
+    and distributed tracing (OpenTelemetry) simultaneously.
+    """
+
+    __slots__ = ("timers",)
+
+    def __init__(self, timers: list[Timer]) -> None:
+        """Initialize composite timer.
 
         Args:
-            exc_type: Exception type (ignored)
-            exc_val: Exception value (ignored)
-            exc_tb: Exception traceback (ignored)
+            timers: List of timer instances to delegate to
+        """
+        self.timers = timers
+
+    def measure(self, name: str) -> AbstractContextManager[None]:
+        """Measure using all underlying timers.
+
+        Args:
+            name: Name of the operation
 
         Returns:
-            False (does not suppress exceptions)
+            Context manager that manages all underlying timers
         """
-        return False
+        contexts = [timer.measure(name) for timer in self.timers]
+        return _composite_context_manager(contexts)
 
+    def get_metrics(self) -> dict[str, float]:
+        """Get combined metrics from all timers.
 
-class NullTimer:
-    """No-op timer implementing the Null Object Pattern.
+        Returns:
+            Merged dictionary of metrics
+        """
+        metrics = {}
+        for timer in self.timers:
+            metrics.update(timer.get_metrics())
+        return metrics
 
-    Provides zero-overhead instrumentation when profiling is disabled.
-    All methods are no-ops that optimize away at runtime.
 
-    Performance: ~20-30 nanoseconds overhead per measure() call.
-    This is negligible compared to any actual work being measured.
+class OpenTelemetryTimer:
+    """Timer implementation that creates OpenTelemetry spans.
 
-    Use Cases:
-        - Production deployments (profiling disabled)
-        - Performance-critical paths
-        - Testing without timing dependencies
+    Maps 'measure' calls to OTel spans. Requires opentelemetry-api installed.
+    """
 
-    Example:
-        # Use global singleton for zero allocation overhead
-        tracker = PoseTracker(timer=NULL_TIMER)
+    __slots__ = ("tracer",)
 
-        # No overhead - measure() call optimizes to nothing
-        with tracker.timer.measure("operation"):
-            do_work()
-    """
+    def __init__(self, tracer: Tracer | None = None) -> None:
+        """Initialize OTel timer.
 
-    __slots__ = ()
+        Args:
+            tracer: Optional OTel tracer. If None, gets tracer for module name.
+        """
+        if not _OPENTELEMETRY_AVAILABLE:
+            self.tracer = None  # Always initialize self.tracer for __slots__
+            return
+
+        if trace is not None:
+            self.tracer = tracer or trace.get_tracer(__name__)
+        else:
+            # This branch should ideally not be reached if _OPENTELEMETRY_AVAILABLE
+            # is True but trace is None (meaning import succeeded but trace was not what
+            # expected). Defensive programming: ensure self.tracer is set.
+            self.tracer = None
 
     def measure(self, name: str) -> AbstractContextManager[None]:
-        """Return a no-op context manager.
-
-        This method does nothing and is optimized away by the Python interpreter.
-        The context manager protocol (__enter__/__exit__) has minimal overhead.
+        """Start an OpenTelemetry span.
 
         Args:
-            name: Ignored - kept for protocol compatibility
+            name: Name of the span
 
         Returns:
-            Singleton null context manager
+            Span context manager (compatible with AbstractContextManager)
         """
-        return _NULL_CONTEXT
+        if not _OPENTELEMETRY_AVAILABLE or self.tracer is None:
+            return _NULL_CONTEXT  # Return the no-op context
+
+        return self.tracer.start_as_current_span(name)
 
     def get_metrics(self) -> dict[str, float]:
-        """Return empty metrics dictionary.
+        """Return empty metrics (OTel handles export asynchronously).
 
         Returns:
-            Empty dictionary (no metrics collected)
+            Empty dictionary
         """
         return {}
-
-
-# Singleton instances for global reuse
-# Use these instead of creating new instances to avoid allocation overhead
-_NULL_CONTEXT = _NullContext()
-NULL_TIMER: Timer = NullTimer()

kinemotion/core/video_io.py

@@ -7,7 +7,7 @@ import warnings
 import cv2
 import numpy as np
 
-from .timing import PerformanceTimer
+from .timing import NULL_TIMER, Timer
 
 
 class VideoProcessor:
@@ -18,16 +18,16 @@ class VideoProcessor:
     No dimensions are hardcoded - all dimensions are extracted from actual frame data.
     """
 
-    def __init__(self, video_path: str, timer: PerformanceTimer | None = None) -> None:
+    def __init__(self, video_path: str, timer: Timer | None = None) -> None:
         """
         Initialize video processor.
 
         Args:
             video_path: Path to input video file
-            timer: Optional PerformanceTimer for measuring operations
+            timer: Optional Timer for measuring operations
         """
         self.video_path = video_path
-        self.timer = timer
+        self.timer = timer or NULL_TIMER
         self.cap = cv2.VideoCapture(video_path)
 
         if not self.cap.isOpened():
@@ -179,28 +179,14 @@ class VideoProcessor:
         OpenCV ignores rotation metadata, so we manually apply rotation
         based on the display matrix metadata extracted from the video.
         """
-        if self.timer:
-            with self.timer.measure("frame_read"):
-                ret, frame = self.cap.read()
-        else:
+        with self.timer.measure("frame_read"):
             ret, frame = self.cap.read()
 
         if not ret:
             return None
 
         # Apply rotation if video has rotation metadata
-        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:
+        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)

kinemotion/dropjump/analysis.py

@@ -10,6 +10,7 @@ from ..core.smoothing import (
     compute_velocity_from_derivative,
     interpolate_threshold_crossing,
 )
+from ..core.timing import NULL_TIMER, Timer
 
 
 class ContactState(Enum):
@@ -345,6 +346,7 @@ def detect_ground_contact(
     visibilities: np.ndarray | None = None,
     window_length: int = 5,
     polyorder: int = 2,
+    timer: Timer | None = None,
 ) -> list[ContactState]:
     """
     Detect when feet are in contact with ground based on vertical motion.
@@ -361,19 +363,22 @@ def detect_ground_contact(
         visibilities: Array of visibility scores for each frame
         window_length: Window size for velocity derivative calculation (must be odd)
         polyorder: Polynomial order for Savitzky-Golay filter (default: 2)
+        timer: Optional Timer for measuring operations
 
     Returns:
         List of ContactState for each frame
     """
+    timer = timer or NULL_TIMER
     n_frames = len(foot_positions)
 
     if n_frames < 2:
         return [ContactState.UNKNOWN] * n_frames
 
     # Compute vertical velocity using derivative-based method
-    velocities = compute_velocity_from_derivative(
-        foot_positions, window_length=window_length, polyorder=polyorder
-    )
+    with timer.measure("dj_compute_velocity"):
+        velocities = compute_velocity_from_derivative(
+            foot_positions, window_length=window_length, polyorder=polyorder
+        )
 
     # Detect stationary frames based on velocity threshold
     is_stationary = np.abs(velocities) < velocity_threshold
@@ -384,7 +389,8 @@ def detect_ground_contact(
     )
 
     # Find frames with sustained contact
-    contact_frames = _find_contact_frames(is_stationary, min_contact_frames)
+    with timer.measure("dj_find_contact_frames"):
+        contact_frames = _find_contact_frames(is_stationary, min_contact_frames)
 
     # Assign states
     return _assign_contact_states(

kinemotion/dropjump/debug_overlay.py

@@ -138,10 +138,7 @@ class DebugOverlayRenderer(BaseDebugOverlayRenderer):
         Returns:
             Frame with debug overlay
         """
-        if self.timer:
-            with self.timer.measure("debug_video_copy"):
-                annotated = frame.copy()
-        else:
+        with self.timer.measure("debug_video_copy"):
             annotated = frame.copy()
 
         def _draw_overlays() -> None:
@@ -181,10 +178,7 @@ class DebugOverlayRenderer(BaseDebugOverlayRenderer):
             if metrics:
                 self._draw_phase_labels(annotated, frame_idx, metrics)
 
-        if self.timer:
-            with self.timer.measure("debug_video_draw"):
-                _draw_overlays()
-        else:
+        with self.timer.measure("debug_video_draw"):
             _draw_overlays()
 
         return annotated

kinemotion/dropjump/kinematics.py

@@ -7,6 +7,7 @@ from numpy.typing import NDArray
 
 from ..core.formatting import format_float_metric, format_int_metric
 from ..core.smoothing import compute_acceleration_from_derivative
+from ..core.timing import NULL_TIMER, Timer
 from .analysis import (
     ContactState,
     detect_drop_start,
@@ -433,6 +434,7 @@ def calculate_drop_jump_metrics(
     smoothing_window: int = 5,
     polyorder: int = 2,
     use_curvature: bool = True,
+    timer: Timer | None = None,
 ) -> DropJumpMetrics:
     """
     Calculate drop-jump metrics from contact states and positions.
@@ -450,16 +452,19 @@ def calculate_drop_jump_metrics(
             (must be odd)
         polyorder: Polynomial order for Savitzky-Golay filter (default: 2)
         use_curvature: Whether to use curvature analysis for refining transitions
+        timer: Optional Timer for measuring operations
 
     Returns:
         DropJumpMetrics object with calculated values
     """
+    timer = timer or NULL_TIMER
     metrics = DropJumpMetrics()
 
     # Determine drop start frame
-    drop_start_frame_value = _determine_drop_start_frame(
-        drop_start_frame, foot_y_positions, fps, smoothing_window
-    )
+    with timer.measure("dj_detect_drop_start"):
+        drop_start_frame_value = _determine_drop_start_frame(
+            drop_start_frame, foot_y_positions, fps, smoothing_window
+        )
 
     # Store drop start frame in metrics
     metrics.drop_start_frame = (
@@ -467,15 +472,16 @@ def calculate_drop_jump_metrics(
     )
 
     # Find contact phases
-    phases = find_contact_phases(contact_states)
-    interpolated_phases = find_interpolated_phase_transitions_with_curvature(
-        foot_y_positions,
-        contact_states,
-        velocity_threshold,
-        smoothing_window,
-        polyorder,
-        use_curvature,
-    )
+    with timer.measure("dj_find_phases"):
+        phases = find_contact_phases(contact_states)
+        interpolated_phases = find_interpolated_phase_transitions_with_curvature(
+            foot_y_positions,
+            contact_states,
+            velocity_threshold,
+            smoothing_window,
+            polyorder,
+            use_curvature,
+        )
 
     if not phases:
         return metrics
@@ -504,9 +510,10 @@ def calculate_drop_jump_metrics(
         return metrics
 
     # Identify main contact phase
-    contact_start, contact_end, _ = _identify_main_contact_phase(
-        phases, ground_phases, air_phases_indexed, foot_y_positions
-    )
+    with timer.measure("dj_identify_contact"):
+        contact_start, contact_end, _ = _identify_main_contact_phase(
+            phases, ground_phases, air_phases_indexed, foot_y_positions
+        )
 
     # Store integer frame indices
     metrics.contact_start_frame = contact_start
@@ -524,15 +531,16 @@ def calculate_drop_jump_metrics(
     metrics.contact_end_frame_precise = contact_end_frac
 
     # Analyze flight phase and calculate jump height
-    _analyze_flight_phase(
-        metrics,
-        phases,
-        interpolated_phases,
-        contact_end,
-        foot_y_positions,
-        fps,
-        smoothing_window,
-        polyorder,
-    )
+    with timer.measure("dj_analyze_flight"):
+        _analyze_flight_phase(
+            metrics,
+            phases,
+            interpolated_phases,
+            contact_end,
+            foot_y_positions,
+            fps,
+            smoothing_window,
+            polyorder,
+        )
 
     return metrics

{kinemotion-0.46.0.dist-info → kinemotion-0.47.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kinemotion
-Version: 0.46.0
+Version: 0.47.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.46.0.dist-info → kinemotion-0.47.0.dist-info}/RECORD

@@ -1,40 +1,40 @@
 kinemotion/__init__.py,sha256=wPItmyGJUOFM6GPRVhAEvRz0-ErI7e2qiUREYJ9EfPQ,943
-kinemotion/api.py,sha256=AWURqiz0SI1BGh6mTlywTOWKFGrXyoZJbmo_t6sRkjQ,32538
+kinemotion/api.py,sha256=K3E5kEQQyPZrEWYaIczJNxxWREWfclIvQYjXcX--9-k,31185
 kinemotion/cli.py,sha256=cqYV_7URH0JUDy1VQ_EDLv63FmNO4Ns20m6s1XAjiP4,464
 kinemotion/cmj/__init__.py,sha256=Ynv0-Oco4I3Y1Ubj25m3h9h2XFqeNwpAewXmAYOmwfU,127
-kinemotion/cmj/analysis.py,sha256=qtULzp9uYzm5M0_Qu5YGJpuwjg9fz1VKAg6xg4NJxvM,21639
+kinemotion/cmj/analysis.py,sha256=YDj7HpSCzrsw6mPtE3phDfYuAWQV0w-CCiLiQjkh3Mg,22196
 kinemotion/cmj/cli.py,sha256=HpZgLWoLjcgsfOZu6EQ_26tg6QwTgFjR-Ly8WCBg24c,9904
 kinemotion/cmj/debug_overlay.py,sha256=fXmWoHhqMLGo4vTtB6Ezs3yLUDOLw63zLIgU2gFlJQU,15892
 kinemotion/cmj/joint_angles.py,sha256=HmheIEiKcQz39cRezk4h-htorOhGNPsqKIR9RsAEKts,9960
 kinemotion/cmj/kinematics.py,sha256=Lq9m9MNQxnXv31VhKmXVrlM7rRkhi8PxW50N_CC8_8Y,11860
 kinemotion/cmj/metrics_validator.py,sha256=V_fmlczYH06SBtwqESv-IfGi3wDsIy3RQbd7VwOyNo0,31359
 kinemotion/cmj/validation_bounds.py,sha256=9ZTo68fl3ooyWjXXyTMRLpK9tFANa_rQf3oHhq7iQGE,11995
-kinemotion/core/__init__.py,sha256=mIsuXS9L7jk-3TCSlEdQ5nlgEAMXl7v5xfRFycwDn80,1430
+kinemotion/core/__init__.py,sha256=rBIEx9sW6E-nyVdWmoVGJYhfPikLukoDp7lxKri7RTQ,1543
 kinemotion/core/auto_tuning.py,sha256=wtCUMOhBChVJNXfEeku3GCMW4qED6MF-O_mv2sPTiVQ,11324
 kinemotion/core/cli_utils.py,sha256=sQPbT6XWWau-sm9yuN5c3eS5xNzoQGGXwSz6hQXtRvM,1859
-kinemotion/core/debug_overlay_utils.py,sha256=Eu4GXm8VeaDhU7voDjPJ4JvR-7ypT1mYmCz0d-M39N4,9027
+kinemotion/core/debug_overlay_utils.py,sha256=-goE3w4gBij99y1U4ckU5iaQPS0SupcHplT04DDWzUo,8579
 kinemotion/core/determinism.py,sha256=NwVrHqJiVxxFHTBPVy8aDBJH2SLIcYIpdGFp7glblB8,2515
 kinemotion/core/experimental.py,sha256=IK05AF4aZS15ke85hF3TWCqRIXU1AlD_XKzFz735Ua8,3640
 kinemotion/core/filtering.py,sha256=GsC9BB71V07LJJHgS2lsaxUAtJsupcUiwtZFDgODh8c,11417
 kinemotion/core/formatting.py,sha256=G_3eqgOtym9RFOZVEwCxye4A2cyrmgvtQ214vIshowU,2480
 kinemotion/core/metadata.py,sha256=bJAVa4nym__zx1hNowSZduMGKBSGOPxTbBQkjm6N0D0,7207
-kinemotion/core/pipeline_utils.py,sha256=n6ee90xOYfBGkDCM1_F2rpYVsC3wWyKSTtWpAFz0Fh0,14161
-kinemotion/core/pose.py,sha256=Tq4VS0YmMzrprVUsELm6FQczyLhP8UKurM9ccYn1LLU,8959
+kinemotion/core/pipeline_utils.py,sha256=0u7o-UFZX6cOu3NaWpFmEy5ejS0WUKggZ1HSdeZXhoA,14964
+kinemotion/core/pose.py,sha256=z1OGuwnc-NdK6Aoc9UYCyPBzomw4eInexOWonZbsEoA,9057
 kinemotion/core/quality.py,sha256=dPGQp08y8DdEUbUdjTThnUOUsALgF0D2sdz50cm6wLI,13098
-kinemotion/core/smoothing.py,sha256=GAfC-jxu1eqNyDjsUXqUBicKx9um5hrk49wz1FxfRNM,15219
-kinemotion/core/timing.py,sha256=Zjhue9LBM1kOcYhqYx3K-OIulnMN8yJer_m3V9i_vqo,7730
+kinemotion/core/smoothing.py,sha256=FZmv3rumn0mYKU2y3JPKz46EvD8TVmQ6_GsN_Vp3BdU,15650
+kinemotion/core/timing.py,sha256=mXwFTEYcB2cfAqQZAlucPN8cqPbVs7as2qjVMPToBdw,12024
 kinemotion/core/validation.py,sha256=LmKfSl4Ayw3DgwKD9IrhsPdzp5ia4drLsHA2UuU1SCM,6310
-kinemotion/core/video_io.py,sha256=HyLwn22fKe37j18853YYYrQi0JQWAwxpepPLNkuZKnQ,8586
+kinemotion/core/video_io.py,sha256=vCwpWnlW2y29l48dFXokdehQn42w_IQvayxbVTjpXqQ,7863
 kinemotion/dropjump/__init__.py,sha256=tC3H3BrCg8Oj-db-Vrtx4PH_llR1Ppkd5jwaOjhQcLg,862
-kinemotion/dropjump/analysis.py,sha256=MjxO-vps0nz_hXlnGk7cgq3jFenJYzsM0VVpHwnHXsM,27935
+kinemotion/dropjump/analysis.py,sha256=p7nnCe7V6vnhQKZVYk--_nhsTvVa_WY-A3zXmyplsew,28211
 kinemotion/dropjump/cli.py,sha256=eLIA0rnx60vqD__PinB1-5nQ8_xQUhCGplwsB0u9MgU,15824
-kinemotion/dropjump/debug_overlay.py,sha256=9nlnDYB_ZJO4dC1uMhDa4UOYGMBsDpyPQD3WbJjbwpM,6130
-kinemotion/dropjump/kinematics.py,sha256=kH-XM66wlOCYMpjvyb6_Qh5ZebyOfFZ47rmhgE1Tww4,19404
+kinemotion/dropjump/debug_overlay.py,sha256=8XVuDyZ3nuNoCYkxcUWC7wyEoHyBxx77Sb--B1KiYWw,5974
+kinemotion/dropjump/kinematics.py,sha256=PATlGaClutGKJslL-LRIXHmTsvb-xEB8PUIMScU_K4c,19849
 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.46.0.dist-info/METADATA,sha256=IRNoNMIpHqtIEc1LZzTvL6k4_8SzAaPLlY6SqI1RzsM,26020
-kinemotion-0.46.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-kinemotion-0.46.0.dist-info/entry_points.txt,sha256=zaqnAnjLvcdrk1Qvj5nvXZCZ2gp0prS7it1zTJygcIY,50
-kinemotion-0.46.0.dist-info/licenses/LICENSE,sha256=KZajvqsHw0NoOHOi2q0FZ4NBe9HdV6oey-IPYAtHXfg,1088
-kinemotion-0.46.0.dist-info/RECORD,,
+kinemotion-0.47.0.dist-info/METADATA,sha256=Kz7ptLupptK9uFRaatqfcVBvsaN_N6vqf0zKFitX1-o,26020
+kinemotion-0.47.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+kinemotion-0.47.0.dist-info/entry_points.txt,sha256=zaqnAnjLvcdrk1Qvj5nvXZCZ2gp0prS7it1zTJygcIY,50
+kinemotion-0.47.0.dist-info/licenses/LICENSE,sha256=KZajvqsHw0NoOHOi2q0FZ4NBe9HdV6oey-IPYAtHXfg,1088
+kinemotion-0.47.0.dist-info/RECORD,,