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

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/{dropjump → dj}/validation_bounds.py

@@ -124,7 +124,7 @@ def _classify_combined_score(combined_score: float) -> AthleteProfile:
     return AthleteProfile.ELITE
 
 
-def estimate_athlete_profile(metrics: MetricsDict, gender: str | None = None) -> AthleteProfile:
+def estimate_athlete_profile(metrics: MetricsDict, _gender: str | None = None) -> AthleteProfile:
     """Estimate athlete profile from drop jump metrics.
 
     Uses jump_height and contact_time to classify athlete level.

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kinemotion
-Version: 0.71.0
+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.72.0.dist-info/RECORD

@@ -0,0 +1,50 @@
+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
+kinemotion/cmj/cli.py,sha256=P2b77IIw6kqTSIkncxlShzhmjIwqMFBNd-pZxYP-TsI,9918
+kinemotion/cmj/debug_overlay.py,sha256=vF5Apiz8zDRpgrVzf52manLW99m1kHQAPSdUkar5rPs,11474
+kinemotion/cmj/joint_angles.py,sha256=by5M4LDtUfd2_Z9DmcgUl0nsvarsBYjgsE8KWWYcn08,11255
+kinemotion/cmj/kinematics.py,sha256=KwA8uSj3g1SeNf0NXMSHsp3gIw6Gfa-6QWIwdYdRXYw,13362
+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=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
+kinemotion/core/experimental.py,sha256=G1EpkmWQ8d-rPaN1n0P7mF6XUzrbW0Br3nVkIzJ1D9M,3694
+kinemotion/core/filtering.py,sha256=7KUeclXqZpNQA8WKNocDwhCxZpwwtizI3wvAEyq9SBo,11603
+kinemotion/core/formatting.py,sha256=G_3eqgOtym9RFOZVEwCxye4A2cyrmgvtQ214vIshowU,2480
+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=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
+kinemotion/core/smoothing.py,sha256=F1DCsnvPBi62XJLygOJ5MkNlRa7BCLg_E9ORtCWcoKk,16562
+kinemotion/core/timing.py,sha256=ITX77q4hbtajRuWfgwYhws8nCvOeKFlEdKjCu8lD9_w,7938
+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/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.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,,

kinemotion/dropjump/debug_overlay.py

@@ -1,182 +0,0 @@
-"""Debug overlay rendering for drop jump analysis."""
-
-import cv2
-import numpy as np
-
-from ..core.debug_overlay_utils import BaseDebugOverlayRenderer
-from ..core.pose import compute_center_of_mass
-from .analysis import ContactState, compute_average_foot_position
-from .kinematics import DropJumpMetrics
-
-
-class DebugOverlayRenderer(BaseDebugOverlayRenderer):
-    """Renders debug information on video frames."""
-
-    def _draw_com_visualization(
-        self,
-        frame: np.ndarray,
-        landmarks: dict[str, tuple[float, float, float]],
-        contact_state: ContactState,
-    ) -> None:
-        """Draw center of mass visualization on frame."""
-        com_x, com_y, _ = compute_center_of_mass(landmarks)
-        px = int(com_x * self.width)
-        py = int(com_y * self.height)
-
-        color = (0, 255, 0) if contact_state == ContactState.ON_GROUND else (0, 0, 255)
-        cv2.circle(frame, (px, py), 15, color, -1)
-        cv2.circle(frame, (px, py), 17, (255, 255, 255), 2)
-
-        # Draw hip midpoint reference
-        if "left_hip" in landmarks and "right_hip" in landmarks:
-            lh_x, lh_y, _ = landmarks["left_hip"]
-            rh_x, rh_y, _ = landmarks["right_hip"]
-            hip_x = int((lh_x + rh_x) / 2 * self.width)
-            hip_y = int((lh_y + rh_y) / 2 * self.height)
-            cv2.circle(frame, (hip_x, hip_y), 8, (255, 165, 0), -1)
-            cv2.line(frame, (hip_x, hip_y), (px, py), (255, 165, 0), 2)
-
-    def _draw_foot_visualization(
-        self,
-        frame: np.ndarray,
-        landmarks: dict[str, tuple[float, float, float]],
-        contact_state: ContactState,
-    ) -> None:
-        """Draw foot position visualization on frame."""
-        foot_x, foot_y = compute_average_foot_position(landmarks)
-        px = int(foot_x * self.width)
-        py = int(foot_y * self.height)
-
-        color = (0, 255, 0) if contact_state == ContactState.ON_GROUND else (0, 0, 255)
-        cv2.circle(frame, (px, py), 10, color, -1)
-
-        # Draw individual foot landmarks
-        foot_keys = ["left_ankle", "right_ankle", "left_heel", "right_heel"]
-        for key in foot_keys:
-            if key in landmarks:
-                x, y, vis = landmarks[key]
-                if vis > 0.5:
-                    lx = int(x * self.width)
-                    ly = int(y * self.height)
-                    cv2.circle(frame, (lx, ly), 5, (255, 255, 0), -1)
-
-    def _draw_phase_labels(
-        self,
-        frame: np.ndarray,
-        frame_idx: int,
-        metrics: DropJumpMetrics,
-    ) -> None:
-        """Draw phase labels (ground contact, flight, peak) on frame."""
-        y_offset = 110
-
-        # Ground contact phase
-        if (
-            metrics.contact_start_frame
-            and metrics.contact_end_frame
-            and metrics.contact_start_frame <= frame_idx <= metrics.contact_end_frame
-        ):
-            cv2.putText(
-                frame,
-                "GROUND CONTACT",
-                (10, y_offset),
-                cv2.FONT_HERSHEY_SIMPLEX,
-                0.7,
-                (0, 255, 0),
-                2,
-            )
-            y_offset += 40
-
-        # Flight phase
-        if (
-            metrics.flight_start_frame
-            and metrics.flight_end_frame
-            and metrics.flight_start_frame <= frame_idx <= metrics.flight_end_frame
-        ):
-            cv2.putText(
-                frame,
-                "FLIGHT PHASE",
-                (10, y_offset),
-                cv2.FONT_HERSHEY_SIMPLEX,
-                0.7,
-                (0, 0, 255),
-                2,
-            )
-            y_offset += 40
-
-        # Peak height
-        if metrics.peak_height_frame == frame_idx:
-            cv2.putText(
-                frame,
-                "PEAK HEIGHT",
-                (10, y_offset),
-                cv2.FONT_HERSHEY_SIMPLEX,
-                0.7,
-                (255, 0, 255),
-                2,
-            )
-
-    def render_frame(
-        self,
-        frame: np.ndarray,
-        landmarks: dict[str, tuple[float, float, float]] | None,
-        contact_state: ContactState,
-        frame_idx: int,
-        metrics: DropJumpMetrics | None = None,
-        use_com: bool = False,
-    ) -> np.ndarray:
-        """
-        Render debug overlay on frame.
-
-        Args:
-            frame: Original video frame
-            landmarks: Pose landmarks for this frame
-            contact_state: Ground contact state
-            frame_idx: Current frame index
-            metrics: Drop-jump metrics (optional)
-            use_com: Whether to visualize CoM instead of feet (optional)
-
-        Returns:
-            Frame with debug overlay
-        """
-        with self.timer.measure("debug_video_copy"):
-            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)
-
-        with self.timer.measure("debug_video_draw"):
-            _draw_overlays()
-
-        return annotated

kinemotion-0.71.0.dist-info/RECORD

@@ -1,49 +0,0 @@
-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/cmj/__init__.py,sha256=SkAw9ka8Yd1Qfv9hcvk22m3EfucROzYrSNGNF5kDzho,113
-kinemotion/cmj/analysis.py,sha256=WcFNJVd9zpwvDrbe41VshXqP9MFfptlgYD4Nph5mHLA,23675
-kinemotion/cmj/api.py,sha256=5PDV_vX3k63Ko4OEttyUkV4fWyklyy-CG_UyNKgNoyY,18476
-kinemotion/cmj/cli.py,sha256=P2b77IIw6kqTSIkncxlShzhmjIwqMFBNd-pZxYP-TsI,9918
-kinemotion/cmj/debug_overlay.py,sha256=bX9aPLhXiLCCMZW9v8Y4OiOAaZO0i-UGr-Pl8HCsmbI,15810
-kinemotion/cmj/joint_angles.py,sha256=HmheIEiKcQz39cRezk4h-htorOhGNPsqKIR9RsAEKts,9960
-kinemotion/cmj/kinematics.py,sha256=KwA8uSj3g1SeNf0NXMSHsp3gIw6Gfa-6QWIwdYdRXYw,13362
-kinemotion/cmj/metrics_validator.py,sha256=JWuWFfDXyZMTHXFWVdI0MhaQjMR3cjd01tTrDy_if2U,30290
-kinemotion/cmj/validation_bounds.py,sha256=Ry915JdInPXbqjaVGNY_urnDO1PAkCSJqHwNKRq-VkU,12048
-kinemotion/core/__init__.py,sha256=8WB7tAJPKOxgNzbhIEOnGnkRr0CcdNeTnz91Jsiyafo,1812
-kinemotion/core/auto_tuning.py,sha256=lhAqPc-eLjMYx9BCvKdECE7TD2Dweb9KcifV6JHaXOE,11278
-kinemotion/core/cli_utils.py,sha256=sQPbT6XWWau-sm9yuN5c3eS5xNzoQGGXwSz6hQXtRvM,1859
-kinemotion/core/debug_overlay_utils.py,sha256=D4aT8xstThPcV2i5D4KJZJEttW6E_4GE5QiERqe1MwI,13049
-kinemotion/core/determinism.py,sha256=Frw-KAOvAxTL_XtxoWpXCjMbQPUKEAusK6JctlkeuRo,2509
-kinemotion/core/experimental.py,sha256=IK05AF4aZS15ke85hF3TWCqRIXU1AlD_XKzFz735Ua8,3640
-kinemotion/core/filtering.py,sha256=Oc__pV6iHEGyyovbqa5SUi-6v8QyvaRVwA0LRayM884,11355
-kinemotion/core/formatting.py,sha256=G_3eqgOtym9RFOZVEwCxye4A2cyrmgvtQ214vIshowU,2480
-kinemotion/core/metadata.py,sha256=bJAVa4nym__zx1hNowSZduMGKBSGOPxTbBQkjm6N0D0,7207
-kinemotion/core/model_downloader.py,sha256=mqhJBHGaNe0aN9qbcBqvcTk9FDd7xaHqEcwD-fyP89c,5205
-kinemotion/core/pipeline_utils.py,sha256=B5jMXoiLaTh02uGA2MIe1uZLVSRGZ5nxbARuvdrjDrQ,15161
-kinemotion/core/pose.py,sha256=_qC4cbFD0Mp2JAGftZcY5AEDLgD2yRnTyRKD9bkqLI8,15306
-kinemotion/core/pose_landmarks.py,sha256=LcEbL5K5xKia6dCzWf6Ft18UIE1CLMMqCZ3KUjwUDzM,1558
-kinemotion/core/quality.py,sha256=VUkRL2N6B7lfIZ2pE9han_U68JwarmZz1U0ygHkgkhE,13022
-kinemotion/core/smoothing.py,sha256=ELMHL7pzSqYffjnLDBUMBJIgt1AwOssDInE8IiXBbig,15942
-kinemotion/core/timing.py,sha256=ITX77q4hbtajRuWfgwYhws8nCvOeKFlEdKjCu8lD9_w,7938
-kinemotion/core/types.py,sha256=A_HclzKpf3By5DiJ0wY9B-dQJrIVAAhUfGab7qTSIL8,1279
-kinemotion/core/validation.py,sha256=0xVv-ftWveV60fJ97kmZMuy2Qqqb5aZLR50dDIrjnhg,6773
-kinemotion/core/video_io.py,sha256=TxdLUEpekGytesL3X3k78WWgZTOd5fuge30hU4Uy48Y,9198
-kinemotion/dropjump/__init__.py,sha256=tC3H3BrCg8Oj-db-Vrtx4PH_llR1Ppkd5jwaOjhQcLg,862
-kinemotion/dropjump/analysis.py,sha256=YomuoJF_peyrBSpeT89Q5_sBgY0kEDyq7TFrtEnRLjs,28049
-kinemotion/dropjump/api.py,sha256=QlZxCrjOg78PXXip6Krb91RSYqH37x1AbBUy6U8uFt8,20833
-kinemotion/dropjump/cli.py,sha256=gUef9nmyR5952h1WnfBGyCdFXQvzVTlCKYAjJGcO4sE,16819
-kinemotion/dropjump/debug_overlay.py,sha256=9RQYXPRf0q2wdy6y2Ak2R4tpRceDwC8aJrXZzkmh3Wo,5942
-kinemotion/dropjump/kinematics.py,sha256=dx4PuXKfKMKcsc_HX6sXj8rHXf9ksiZIOAIkJ4vBlY4,19637
-kinemotion/dropjump/metrics_validator.py,sha256=lSfo4Lm5FHccl8ijUP6SA-kcSh50LS9hF8UIyWxcnW8,9243
-kinemotion/dropjump/validation_bounds.py,sha256=x4yjcFxyvdMp5e7MkcoUosGLeGsxBh1Lft6h__AQ2G8,5124
-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.0.dist-info/METADATA,sha256=sKhmkomkzrmp1YnX0SC9dzsRvDNlrVtVQ5npxSPWVeI,26125
-kinemotion-0.71.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-kinemotion-0.71.0.dist-info/entry_points.txt,sha256=zaqnAnjLvcdrk1Qvj5nvXZCZ2gp0prS7it1zTJygcIY,50
-kinemotion-0.71.0.dist-info/licenses/LICENSE,sha256=KZajvqsHw0NoOHOi2q0FZ4NBe9HdV6oey-IPYAtHXfg,1088
-kinemotion-0.71.0.dist-info/RECORD,,