kinemotion 0.71.1__py3-none-any.whl → 0.72.0__py3-none-any.whl

kinemotion/__init__.py

@@ -14,7 +14,7 @@ from .api import (
     process_dropjump_videos_bulk,
 )
 from .cmj.kinematics import CMJMetrics
-from .dropjump.kinematics import DropJumpMetrics
+from .dj.kinematics import DropJumpMetrics
 
 # Get version from package metadata (set in pyproject.toml)
 try:

kinemotion/api.py

@@ -2,7 +2,7 @@
 
 This module provides a unified interface for both drop jump and CMJ video analysis.
 The actual implementations have been moved to their respective submodules:
-- Drop jump: kinemotion.dropjump.api
+- Drop jump: kinemotion.dj.api
 - CMJ: kinemotion.cmj.api
 
 """
@@ -20,7 +20,7 @@ from .cmj.api import (
 from .cmj.kinematics import CMJMetrics
 
 # Drop jump API
-from .dropjump.api import (
+from .dj.api import (
     AnalysisOverrides,
     DropJumpVideoConfig,
     DropJumpVideoResult,

kinemotion/cli.py

@@ -3,7 +3,7 @@
 import click
 
 from .cmj.cli import cmj_analyze
-from .dropjump.cli import dropjump_analyze
+from .dj.cli import dropjump_analyze
 
 
 @click.group()

kinemotion/core/auto_tuning.py

@@ -170,7 +170,10 @@ def auto_tune_parameters(
     quality_adj = _QUALITY_ADJUSTMENTS[quality]
 
     # Compute FPS-based baseline parameters
-    base_velocity_threshold = 0.004 * (30.0 / fps)
+    # Base velocity threshold: 0.012 at 30fps, scaled inversely by fps
+    # Must exceed typical MediaPipe landmark jitter (0.5-2% per frame)
+    # Previous value of 0.004 was below noise floor, causing false IN_AIR detections
+    base_velocity_threshold = 0.012 * (30.0 / fps)
     base_min_contact_frames = max(2, round(3.0 * (fps / 30.0)))
 
     # Smoothing window: Decrease with higher fps for better temporal resolution

kinemotion/core/pipeline_utils.py

@@ -9,7 +9,7 @@ import cv2
 import numpy as np
 
 from ..cmj.analysis import compute_average_hip_position
-from ..dropjump.analysis import compute_average_foot_position
+from ..dj.analysis import compute_average_foot_position
 from .auto_tuning import AnalysisParameters, QualityPreset, VideoCharacteristics
 from .pose import MediaPipePoseTracker
 from .smoothing import smooth_landmarks, smooth_landmarks_advanced

kinemotion/{dropjump → dj}/analysis.py

@@ -334,6 +334,48 @@ def _assign_contact_states(
     return states
 
 
+def _compute_near_ground_mask(
+    foot_positions: FloatArray,
+    height_tolerance: float = 0.35,
+) -> BoolArray:
+    """Compute mask for frames where feet are near ground level.
+
+    Uses position-based filtering to identify frames near ground baseline.
+    In normalized coordinates: y=1 is bottom (ground), y=0 is top.
+
+    The ground baseline is established as the 90th percentile of positions,
+    which represents the typical ground level while handling outliers.
+
+    The tolerance is set at 35% of the position range by default, which is
+    generous enough to capture the full reactive contact phase (where athletes
+    maintain an athletic stance) while still filtering out the jump apex
+    (where y is much lower than ground level).
+
+    Args:
+        foot_positions: Array of foot y-positions (normalized, 0-1)
+        height_tolerance: Fraction of position range allowed above ground (default 35%)
+
+    Returns:
+        Boolean array where True indicates frame is near ground level
+    """
+    # Ground baseline: 90th percentile (where feet are typically on ground)
+    # Using 90th instead of 95th to be less sensitive to final landing positions
+    ground_baseline = float(np.percentile(foot_positions, 90))
+
+    # Compute position range for tolerance calculation
+    position_range = float(np.max(foot_positions) - np.min(foot_positions))
+
+    # Minimum absolute tolerance to handle small movements
+    min_tolerance = 0.03  # 3% of normalized range
+
+    # Height tolerance: percentage of position range or minimum
+    tolerance = max(position_range * height_tolerance, min_tolerance)
+
+    # Frames are near ground if y >= ground_baseline - tolerance
+    # (Remember: higher y = closer to ground in normalized coords)
+    return foot_positions >= (ground_baseline - tolerance)
+
+
 def detect_ground_contact(
     foot_positions: FloatArray,
     velocity_threshold: float = 0.02,
@@ -343,13 +385,14 @@ def detect_ground_contact(
     window_length: int = 5,
     polyorder: int = 2,
     timer: Timer | None = None,
+    height_tolerance: float = 0.35,
 ) -> list[ContactState]:
     """
-    Detect when feet are in contact with ground based on vertical motion.
+    Detect when feet are in contact with ground based on vertical motion AND position.
 
-    Uses derivative-based velocity calculation via Savitzky-Goyal filter for smooth,
-    accurate velocity estimates. This is consistent with the velocity calculation used
-    throughout the pipeline for sub-frame interpolation and curvature analysis.
+    Uses derivative-based velocity calculation via Savitzky-Golay filter for smooth,
+    accurate velocity estimates. Additionally uses position-based filtering to prevent
+    false ON_GROUND classification at jump apex where velocity approaches zero.
 
     Args:
         foot_positions: Array of foot y-positions (normalized, 0-1, where 1 is bottom)
@@ -360,6 +403,7 @@ def detect_ground_contact(
         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
+        height_tolerance: Fraction of position range to allow above ground baseline (default 35%)
 
     Returns:
         List of ContactState for each frame
@@ -379,6 +423,14 @@ def detect_ground_contact(
     # Detect stationary frames based on velocity threshold
     is_stationary = np.abs(velocities) < velocity_threshold
 
+    # Position-based filtering to prevent false ON_GROUND at jump apex
+    # In normalized coords: y=1 is bottom (ground), y=0 is top
+    # Ground baseline is the 95th percentile (handles outliers)
+    is_near_ground = _compute_near_ground_mask(foot_positions, height_tolerance)
+
+    # Both conditions must be true: low velocity AND near ground
+    is_stationary = is_stationary & is_near_ground
+
     # Apply visibility filter
     is_stationary = _filter_stationary_with_visibility(
         is_stationary, visibilities, visibility_threshold
@@ -716,25 +768,28 @@ def find_landing_from_acceleration(
     accelerations: FloatArray,
     takeoff_frame: int,
     fps: float,
-    search_duration: float = 0.7,
+    search_duration: float = 1.5,
 ) -> int:
     """
-    Find landing frame by detecting impact acceleration after takeoff.
+    Find landing frame using position-based detection with acceleration refinement.
+
+    Primary method: Find when feet return to near-takeoff level after peak.
+    Secondary: Refine with acceleration spike if present.
 
-    Detects the moment of initial ground contact, characterized by a sharp
-    deceleration (positive acceleration spike) as downward velocity is arrested.
+    For drop jumps, landing is defined as the first ground contact after the
+    reactive jump, when feet return to approximately the same level as takeoff.
 
     Args:
-        positions: Array of vertical positions (normalized 0-1)
+        positions: Array of vertical positions (normalized 0-1, where higher = closer to ground)
         accelerations: Array of accelerations (second derivative)
         takeoff_frame: Frame at takeoff (end of ground contact)
         fps: Video frame rate
-        search_duration: Duration in seconds to search for landing (default: 0.7s)
+        search_duration: Duration in seconds to search for landing (default: 1.5s)
 
     Returns:
         Landing frame index (integer)
     """
-    # Find peak height (minimum y value = highest point)
+    # Extended search window to capture full flight
     search_start = takeoff_frame
     search_end = min(len(positions), takeoff_frame + int(fps * search_duration))
 
@@ -742,52 +797,91 @@ def find_landing_from_acceleration(
         return min(len(positions) - 1, takeoff_frame + int(fps * 0.3))
 
     flight_positions = positions[search_start:search_end]
+
+    # Find peak height (minimum y value = highest point)
     peak_idx = int(np.argmin(flight_positions))
     peak_frame = search_start + peak_idx
 
-    # After peak, look for landing (impact with ground)
-    # Landing is detected by maximum positive acceleration (deceleration on impact)
-    landing_search_start = peak_frame + 2
-    landing_search_end = min(len(accelerations), landing_search_start + int(fps * 0.6))
+    # Get takeoff position as reference for landing detection
+    takeoff_position = positions[takeoff_frame]
+
+    # Position-based landing: find first frame after peak where position
+    # returns to within 5% of takeoff level (or 95% of the way back)
+    landing_threshold = takeoff_position - 0.05 * (takeoff_position - positions[peak_frame])
 
-    if landing_search_end <= landing_search_start:
-        return min(len(positions) - 1, peak_frame + int(fps * 0.2))
+    # Search for landing after peak
+    landing_frame = None
+    for i in range(peak_frame + 2, min(len(positions), search_end)):
+        if positions[i] >= landing_threshold:
+            landing_frame = i
+            break
 
-    # Find impact: maximum negative acceleration after peak (deceleration on impact)
-    # The impact creates a large upward force (negative acceleration in Y-down)
-    landing_accelerations = accelerations[landing_search_start:landing_search_end]
-    impact_idx = int(np.argmin(landing_accelerations))
-    landing_frame = landing_search_start + impact_idx
+    # If position-based detection fails, use end of search window
+    if landing_frame is None:
+        landing_frame = min(len(positions) - 1, search_end - 1)
+
+    # Refine with acceleration if there's a clear impact spike
+    # Look for significant acceleration in a small window around the position-based landing
+    refine_start = max(peak_frame + 2, landing_frame - int(fps * 0.1))
+    refine_end = min(len(accelerations), landing_frame + int(fps * 0.1))
+
+    if refine_end > refine_start:
+        window_accelerations = accelerations[refine_start:refine_end]
+        # Check if there's a significant acceleration spike (> 3x median)
+        median_acc = float(np.median(np.abs(window_accelerations)))
+        max_acc_idx = int(np.argmax(np.abs(window_accelerations)))
+        max_acc = float(np.abs(window_accelerations[max_acc_idx]))
+
+        if median_acc > 0 and max_acc > 3 * median_acc:
+            # Use acceleration-refined landing frame
+            landing_frame = refine_start + max_acc_idx
 
     return landing_frame
 
 
 def compute_average_foot_position(
     landmarks: dict[str, tuple[float, float, float]],
+    visibility_threshold: float = 0.5,
 ) -> tuple[float, float]:
     """
     Compute average foot position from ankle and foot landmarks.
 
+    Uses tiered visibility approach to avoid returning center (0.5, 0.5)
+    which can cause false phase transitions in contact detection.
+
     Args:
         landmarks: Dictionary of landmark positions
+        visibility_threshold: Minimum visibility to include landmark (default: 0.5)
 
     Returns:
         (x, y) average foot position in normalized coordinates
     """
-    x_positions = []
-    y_positions = []
-
+    # Collect all foot landmarks with their visibility
+    foot_data: list[tuple[float, float, float]] = []
     for key in FOOT_KEYS:
         if key in landmarks:
             x, y, visibility = landmarks[key]
-            if visibility > 0.5:  # Only use visible landmarks
-                x_positions.append(x)
-                y_positions.append(y)
-
-    if not x_positions:
-        return (0.5, 0.5)  # Default to center if no visible feet
-
-    return (float(np.mean(x_positions)), float(np.mean(y_positions)))
+            foot_data.append((x, y, visibility))
+
+    if not foot_data:
+        # No foot landmarks at all - return center as last resort
+        return (0.5, 0.5)
+
+    # Tier 1: Use landmarks above visibility threshold
+    high_vis = [(x, y) for x, y, v in foot_data if v > visibility_threshold]
+    if high_vis:
+        xs, ys = zip(*high_vis, strict=False)
+        return (float(np.mean(xs)), float(np.mean(ys)))
+
+    # Tier 2: Use landmarks with any reasonable visibility (> 0.1)
+    low_vis = [(x, y) for x, y, v in foot_data if v > 0.1]
+    if low_vis:
+        xs, ys = zip(*low_vis, strict=False)
+        return (float(np.mean(xs)), float(np.mean(ys)))
+
+    # Tier 3: Use highest visibility landmark regardless of threshold
+    best = max(foot_data, key=lambda t: t[2])
+    return (best[0], best[1])
 
 
 def _calculate_average_visibility(

kinemotion/{dropjump → dj}/api.py

@@ -52,6 +52,14 @@ from .debug_overlay import DropJumpDebugOverlayRenderer
 from .kinematics import DropJumpMetrics, calculate_drop_jump_metrics
 from .metrics_validator import DropJumpMetricsValidator
 
+__all__ = [
+    "AnalysisOverrides",
+    "DropJumpVideoConfig",
+    "DropJumpVideoResult",
+    "process_dropjump_video",
+    "process_dropjump_videos_bulk",
+]
+
 
 @dataclass
 class AnalysisOverrides:

kinemotion/{dropjump → dj}/kinematics.py

@@ -234,6 +234,16 @@ def _identify_main_contact_phase(
 ) -> tuple[int, int, bool]:
     """Identify the main contact phase and determine if it's a drop jump.
 
+    Drop jump detection strategy:
+    1. With position-based filtering, box period is classified as IN_AIR
+    2. Pattern: IN_AIR(box+drop) → ON_GROUND(contact) → IN_AIR(flight) → ON_GROUND(land)
+    3. The FIRST ground phase is the contact phase (before the flight)
+    4. The LAST ground phase is the landing (after the flight)
+
+    The key differentiator from regular jump:
+    - Drop jump: starts with IN_AIR, has 2+ ground phases with air between them
+    - Regular jump: starts with ON_GROUND, may have multiple phases
+
     Args:
         phases: All phase tuples
         ground_phases: Ground phases with indices
@@ -247,34 +257,43 @@ def _identify_main_contact_phase(
     contact_start, contact_end = ground_phases[0][0], ground_phases[0][1]
     is_drop_jump = False
 
-    # Detect if this is a drop jump or regular jump
+    # Check if this looks like a drop jump pattern:
+    # Pattern: starts with IN_AIR → ON_GROUND → IN_AIR → ON_GROUND
     if air_phases_indexed and len(ground_phases) >= 2:
+        _, _, first_air_idx = air_phases_indexed[0]
         first_ground_start, first_ground_end, first_ground_idx = ground_phases[0]
-        first_air_idx = air_phases_indexed[0][2]
-
-        # Find ground phase after first air phase
-        ground_after_air = [
-            (start, end, idx) for start, end, idx in ground_phases if idx > first_air_idx
-        ]
-
-        if ground_after_air and first_ground_idx < first_air_idx:
-            # Check if first ground is at higher elevation (lower y) than
-            # ground after air using robust temporal averaging
-            first_ground_y = _compute_robust_phase_position(
-                foot_y_positions, first_ground_start, first_ground_end
-            )
-            second_ground_start, second_ground_end, _ = ground_after_air[0]
-            second_ground_y = _compute_robust_phase_position(
-                foot_y_positions, second_ground_start, second_ground_end
-            )
-
-            # If first ground is significantly higher (>7% of frame), it's a drop jump
-            # Increased from 0.05 to 0.07 with 11-frame temporal averaging
-            # for reproducibility (balances detection sensitivity with noise robustness)
-            # Note: MediaPipe has inherent non-determinism (Google issue #3945)
-            if second_ground_y - first_ground_y > 0.07:
+
+        # Drop jump pattern: first phase is IN_AIR (athlete on box/dropping)
+        # followed by ground contact, then flight, then landing
+        if first_air_idx == 0 and first_ground_idx == 1:
+            # First phase is air (box + drop), second phase is ground (contact)
+            # Check if there's a flight phase after contact
+            air_after_contact = [
+                (s, e, i) for s, e, i in air_phases_indexed if i > first_ground_idx
+            ]
+            if air_after_contact:
+                # This is a drop jump: first ground = contact, last ground = landing
                 is_drop_jump = True
-                contact_start, contact_end = second_ground_start, second_ground_end
+                contact_start, contact_end = first_ground_start, first_ground_end
+
+        # Legacy detection: first ground is on elevated box (lower y)
+        # This handles cases where box level IS detected as ground
+        if not is_drop_jump and first_ground_idx < first_air_idx:
+            ground_after_air = [
+                (start, end, idx) for start, end, idx in ground_phases if idx > first_air_idx
+            ]
+            if ground_after_air:
+                first_ground_y = _compute_robust_phase_position(
+                    foot_y_positions, first_ground_start, first_ground_end
+                )
+                second_ground_start, second_ground_end, _ = ground_after_air[0]
+                second_ground_y = _compute_robust_phase_position(
+                    foot_y_positions, second_ground_start, second_ground_end
+                )
+                # If first ground is significantly higher (>7% of frame), it's a drop jump
+                if second_ground_y - first_ground_y > 0.07:
+                    is_drop_jump = True
+                    contact_start, contact_end = second_ground_start, second_ground_end
 
     if not is_drop_jump:
         # Regular jump: use longest ground contact phase
@@ -317,6 +336,30 @@ def _find_precise_phase_timing(
     return contact_start_frac, contact_end_frac
 
 
+def _find_landing_from_phases(
+    phases: list[tuple[int, int, ContactState]],
+    flight_start: int,
+) -> int | None:
+    """Find landing frame from phase detection.
+
+    Looks for the first ON_GROUND phase that starts after the flight_start frame.
+    This represents the first ground contact after the reactive jump.
+
+    Args:
+        phases: List of (start, end, state) phase tuples
+        flight_start: Frame where flight begins (takeoff)
+
+    Returns:
+        Landing frame (start of landing phase), or None if not found
+    """
+    for start, _, state in phases:
+        if state == ContactState.ON_GROUND and start > flight_start:
+            # Found the landing phase - return its start frame
+            return start
+
+    return None
+
+
 def _analyze_flight_phase(
     metrics: DropJumpMetrics,
     phases: list[tuple[int, int, ContactState]],
@@ -345,22 +388,20 @@ def _analyze_flight_phase(
     # Find takeoff frame (end of ground contact)
     flight_start = contact_end
 
-    # Compute accelerations for landing detection
-    accelerations = compute_acceleration_from_derivative(
-        foot_y_positions, window_length=smoothing_window, polyorder=polyorder
-    )
+    # Use phase detection for landing (more accurate than position-based)
+    # Find the next ON_GROUND phase after the flight phase
+    flight_end = _find_landing_from_phases(phases, flight_start)
 
-    # Use acceleration-based landing detection (like CMJ)
-    # This finds the actual ground impact, not just when velocity drops
-    flight_end = find_landing_from_acceleration(
-        foot_y_positions, accelerations, flight_start, fps, search_duration=0.7
-    )
-
-    # Store integer frame indices
-    metrics.flight_start_frame = flight_start
-    metrics.flight_end_frame = flight_end
+    # If phase detection fails, fall back to position-based detection
+    if flight_end is None:
+        accelerations = compute_acceleration_from_derivative(
+            foot_y_positions, window_length=smoothing_window, polyorder=polyorder
+        )
+        flight_end = find_landing_from_acceleration(
+            foot_y_positions, accelerations, flight_start, fps
+        )
 
-    # Find precise sub-frame timing for takeoff
+    # Find precise sub-frame timing for takeoff and landing
     flight_start_frac = float(flight_start)
     flight_end_frac = float(flight_end)
 
@@ -373,6 +414,20 @@ def _analyze_flight_phase(
             flight_start_frac = end_frac
             break
 
+    # Find interpolated landing (start of landing ON_GROUND phase)
+    for start_frac, _, state in interpolated_phases:
+        if state == ContactState.ON_GROUND and int(start_frac) >= flight_end - 2:
+            flight_end_frac = start_frac
+            break
+
+    # Refine landing frame using floor of interpolated value
+    # This compensates for velocity-based detection being ~1-2 frames late
+    refined_flight_end = int(np.floor(flight_end_frac))
+
+    # Store integer frame indices (refined using interpolated values)
+    metrics.flight_start_frame = flight_start
+    metrics.flight_end_frame = refined_flight_end
+
     # Calculate flight time
     flight_frames_precise = flight_end_frac - flight_start_frac
     metrics.flight_time = flight_frames_precise / fps
@@ -497,15 +552,22 @@ def calculate_drop_jump_metrics(
             phases, ground_phases, air_phases_indexed, foot_y_positions
         )
 
-    # Store integer frame indices
-    metrics.contact_start_frame = contact_start
-    metrics.contact_end_frame = contact_end
-
-    # Find precise timing for contact phase
+    # Find precise timing for contact phase (uses curvature refinement)
     contact_start_frac, contact_end_frac = _find_precise_phase_timing(
         contact_start, contact_end, interpolated_phases
     )
 
+    # Refine contact_start using floor of interpolated value
+    # This compensates for velocity-based detection being ~1-2 frames late
+    # because velocity settles AFTER initial impact. Using floor() biases
+    # toward earlier detection, matching the moment of first ground contact.
+    refined_contact_start = int(np.floor(contact_start_frac))
+
+    # Store integer frame indices (refined start, raw end)
+    # Contact end (takeoff) uses raw value as velocity-based detection is accurate
+    metrics.contact_start_frame = refined_contact_start
+    metrics.contact_end_frame = contact_end
+
     # Calculate ground contact time
     contact_frames_precise = contact_end_frac - contact_start_frac
     metrics.ground_contact_time = contact_frames_precise / fps

kinemotion/{dropjump → dj}/metrics_validator.py

@@ -14,7 +14,7 @@ from kinemotion.core.validation import (
     MetricsValidator,
     ValidationResult,
 )
-from kinemotion.dropjump.validation_bounds import (
+from kinemotion.dj.validation_bounds import (
     DropJumpBounds,
     estimate_athlete_profile,
 )

{kinemotion-0.71.1.dist-info → kinemotion-0.72.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kinemotion
-Version: 0.71.1
+Version: 0.72.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.71.1.dist-info → kinemotion-0.72.0.dist-info}/RECORD

@@ -1,6 +1,6 @@
-kinemotion/__init__.py,sha256=HkD8habCcfxGobxZcACOStla-L1nYHMIZp0th00Q3E8,1061
-kinemotion/api.py,sha256=uG1e4bTnj2c-6cbZJEZ_LjMwFdaG32ba2KcK_XjE_NI,1040
-kinemotion/cli.py,sha256=_Us9krSce4GUKtlLIPrFUhKmPWURzeJ1-ydR_YU2VGw,626
+kinemotion/__init__.py,sha256=jlhHJlxZJbp7CPfRWMlxwfDISBCdHadjigmXvcahXxU,1055
+kinemotion/api.py,sha256=1GMi_7SbU3EyDdDRtnF55roB8iMR0t91qGOkqa4E6sI,1028
+kinemotion/cli.py,sha256=ugrc1Dpx7abYGEyIDcslzNu8KR0VoOoGGUGUm87E_kQ,620
 kinemotion/cmj/__init__.py,sha256=SkAw9ka8Yd1Qfv9hcvk22m3EfucROzYrSNGNF5kDzho,113
 kinemotion/cmj/analysis.py,sha256=EQydClIbNkIj-FmCZGaPQe-COVW8fbO3139i9z1vomA,23643
 kinemotion/cmj/api.py,sha256=P_lbqEqAKPO5n1Xn4IQZKNj9nLaO3ljkN2PgqvExGXU,18435
@@ -11,7 +11,7 @@ kinemotion/cmj/kinematics.py,sha256=KwA8uSj3g1SeNf0NXMSHsp3gIw6Gfa-6QWIwdYdRXYw,
 kinemotion/cmj/metrics_validator.py,sha256=IQofafpwLCXER3ucZXNfiJKFFKPOVxXnC4BNLHOMnNY,30013
 kinemotion/cmj/validation_bounds.py,sha256=-0iXDhH-RntiGZi_Co22V6qtA5D-hLzkrPkVcfoNd2U,11343
 kinemotion/core/__init__.py,sha256=8hMvfNK7v_eqswuk_J5s5FRGvPtp2-R4kasVMGchFkM,1766
-kinemotion/core/auto_tuning.py,sha256=dF2opupuphbTd6sZIDyXX8hwedLaNlMiH-hT7PGqnfU,10251
+kinemotion/core/auto_tuning.py,sha256=rliPTLueMbOjYRb4hjb0af7DVMtxLT92wpnVve75GvA,10478
 kinemotion/core/cli_utils.py,sha256=sQPbT6XWWau-sm9yuN5c3eS5xNzoQGGXwSz6hQXtRvM,1859
 kinemotion/core/debug_overlay_utils.py,sha256=QaVkHuFZpXUrdiMlm8ylQn6baJOj8jcZeiV4kDqODt0,17441
 kinemotion/core/determinism.py,sha256=Frw-KAOvAxTL_XtxoWpXCjMbQPUKEAusK6JctlkeuRo,2509
@@ -21,7 +21,7 @@ kinemotion/core/formatting.py,sha256=G_3eqgOtym9RFOZVEwCxye4A2cyrmgvtQ214vIshowU
 kinemotion/core/metadata.py,sha256=bJAVa4nym__zx1hNowSZduMGKBSGOPxTbBQkjm6N0D0,7207
 kinemotion/core/model_downloader.py,sha256=mqhJBHGaNe0aN9qbcBqvcTk9FDd7xaHqEcwD-fyP89c,5205
 kinemotion/core/overlay_constants.py,sha256=zZreHHWe00p2XuCJsbRFqN6g-AAUAnx53LwKqHm1Bl8,1438
-kinemotion/core/pipeline_utils.py,sha256=B5jMXoiLaTh02uGA2MIe1uZLVSRGZ5nxbARuvdrjDrQ,15161
+kinemotion/core/pipeline_utils.py,sha256=FzfdKNhM0eK9Y5wbNP9Jab_nmrZxcJfL3cstpO4yfxc,15155
 kinemotion/core/pose.py,sha256=Z795p0EnaTUeWHO8FuApFcMGTLwZ47JOjs5f5TzRvdk,14224
 kinemotion/core/pose_landmarks.py,sha256=LcEbL5K5xKia6dCzWf6Ft18UIE1CLMMqCZ3KUjwUDzM,1558
 kinemotion/core/quality.py,sha256=VUkRL2N6B7lfIZ2pE9han_U68JwarmZz1U0ygHkgkhE,13022
@@ -30,21 +30,21 @@ kinemotion/core/timing.py,sha256=ITX77q4hbtajRuWfgwYhws8nCvOeKFlEdKjCu8lD9_w,793
 kinemotion/core/types.py,sha256=m141buSkEsqflt5VFaTHtRq_IcimjI3_T_EfaNpIVxY,1652
 kinemotion/core/validation.py,sha256=rrhpI24Iq8WGtNaMg0beTWMbEGccdKF-f-pk-FCKJzI,6749
 kinemotion/core/video_io.py,sha256=84IxC1n3HvYK28MSa5fqumdzlPDhP8k9IPB3OCvWku0,9198
-kinemotion/dropjump/__init__.py,sha256=yBbEbPdY6sqozWtTvfbvuUZnrVWSSjBp61xK34M29F4,878
-kinemotion/dropjump/analysis.py,sha256=Tc41jVctG4zJZOyYqM1SiM95mnF2xz4vcieGJ6vYi2M,29099
-kinemotion/dropjump/api.py,sha256=5qBj05e6Zo-H4-UjBOIt_CYyDqLVcPhwyyLG04eJYMU,20639
-kinemotion/dropjump/cli.py,sha256=FaBX637x7VcLcB8HupaZCkVS7sp8C0YuaKM0h-DBNIA,15906
-kinemotion/dropjump/debug_overlay.py,sha256=X4mvCi5Qi1gnvSZZAsUs-0ZRUx9mVBbEUznOFO21HO8,8470
-kinemotion/dropjump/kinematics.py,sha256=dx4PuXKfKMKcsc_HX6sXj8rHXf9ksiZIOAIkJ4vBlY4,19637
-kinemotion/dropjump/metrics_validator.py,sha256=lSfo4Lm5FHccl8ijUP6SA-kcSh50LS9hF8UIyWxcnW8,9243
-kinemotion/dropjump/validation_bounds.py,sha256=k31qy-kCXTiCTx0RPo2t8yZ-faLxqGO-AeF05QfBFb0,5125
+kinemotion/dj/__init__.py,sha256=yBbEbPdY6sqozWtTvfbvuUZnrVWSSjBp61xK34M29F4,878
+kinemotion/dj/analysis.py,sha256=dR5Dqxo_ub9EAOR95oPI4oJKtIofSH0EodopuoywsO8,33339
+kinemotion/dj/api.py,sha256=v-T-VurOoOIAWVyfR5IUCnUc4bHjBuxB2pP8qJG7TLs,20799
+kinemotion/dj/cli.py,sha256=FaBX637x7VcLcB8HupaZCkVS7sp8C0YuaKM0h-DBNIA,15906
+kinemotion/dj/debug_overlay.py,sha256=X4mvCi5Qi1gnvSZZAsUs-0ZRUx9mVBbEUznOFO21HO8,8470
+kinemotion/dj/kinematics.py,sha256=1K291z-PeJTqJbJDeIKWat90mVbxxh4B4hjz-nTFk88,22618
+kinemotion/dj/metrics_validator.py,sha256=BZbqareRaIfCcehTUvNPO3xzkq4X27xDD867e_w7Fmo,9237
+kinemotion/dj/validation_bounds.py,sha256=k31qy-kCXTiCTx0RPo2t8yZ-faLxqGO-AeF05QfBFb0,5125
 kinemotion/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 kinemotion/models/pose_landmarker_lite.task,sha256=WZKeHR7pUodzXd2DOxnPSsRtKbx6_du_Z1PEWWkNV0o,5777746
 kinemotion/models/rtmpose-s_simcc-body7_pt-body7-halpe26_700e-256x192-7f134165_20230605.onnx,sha256=dfZTq8kbhv8RxWiXS0HUIJNCUpxYTBN45dFIorPflEs,133
 kinemotion/models/yolox_tiny_8xb8-300e_humanart-6f3252f9.onnx,sha256=UsutHVQ6GP3X5pCcp52EN8q7o2J3d-TnxZqlF48kY6I,133
 kinemotion/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kinemotion-0.71.1.dist-info/METADATA,sha256=D2ZS9pNSi3NAaSkYKoQ09PZaJ-B3qWDHPLChu3oxdbY,26125
-kinemotion-0.71.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-kinemotion-0.71.1.dist-info/entry_points.txt,sha256=zaqnAnjLvcdrk1Qvj5nvXZCZ2gp0prS7it1zTJygcIY,50
-kinemotion-0.71.1.dist-info/licenses/LICENSE,sha256=KZajvqsHw0NoOHOi2q0FZ4NBe9HdV6oey-IPYAtHXfg,1088
-kinemotion-0.71.1.dist-info/RECORD,,
+kinemotion-0.72.0.dist-info/METADATA,sha256=_OdCWsVJMVu8s2tebWVeW5XnFTi_aMZYVTw01XWN_p0,26125
+kinemotion-0.72.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+kinemotion-0.72.0.dist-info/entry_points.txt,sha256=zaqnAnjLvcdrk1Qvj5nvXZCZ2gp0prS7it1zTJygcIY,50
+kinemotion-0.72.0.dist-info/licenses/LICENSE,sha256=KZajvqsHw0NoOHOi2q0FZ4NBe9HdV6oey-IPYAtHXfg,1088
+kinemotion-0.72.0.dist-info/RECORD,,