kinemotion 0.72.1__py3-none-any.whl → 0.74.0__py3-none-any.whl

kinemotion/{dj → drop_jump}/analysis.py

@@ -677,6 +677,48 @@ def refine_transition_with_curvature(
     return refined_frame
 
 
+def _refine_phase_boundaries(
+    foot_positions: FloatArray,
+    start_frac: float,
+    end_frac: float,
+    start_type: str,
+    end_type: str,
+    smoothing_window: int,
+    polyorder: int,
+) -> tuple[float, float]:
+    """Refine phase boundary frames using curvature analysis.
+
+    Args:
+        foot_positions: Array of foot y-positions (normalized, 0-1)
+        start_frac: Start frame (fractional)
+        end_frac: End frame (fractional)
+        start_type: Transition type for start ("landing" or "takeoff")
+        end_type: Transition type for end ("landing" or "takeoff")
+        smoothing_window: Window size for acceleration computation
+        polyorder: Polynomial order for Savitzky-Golay filter
+
+    Returns:
+        Tuple of (refined_start, refined_end) fractional frame indices
+    """
+    refined_start = refine_transition_with_curvature(
+        foot_positions,
+        start_frac,
+        start_type,
+        search_window=3,
+        smoothing_window=smoothing_window,
+        polyorder=polyorder,
+    )
+    refined_end = refine_transition_with_curvature(
+        foot_positions,
+        end_frac,
+        end_type,
+        search_window=3,
+        smoothing_window=smoothing_window,
+        polyorder=polyorder,
+    )
+    return refined_start, refined_end
+
+
 def find_interpolated_phase_transitions_with_curvature(
     foot_positions: FloatArray,
     contact_states: list[ContactState],
@@ -716,47 +758,30 @@ def find_interpolated_phase_transitions_with_curvature(
     refined_phases: list[tuple[float, float, ContactState]] = []
 
     for start_frac, end_frac, state in interpolated_phases:
-        refined_start = start_frac
-        refined_end = end_frac
-
         if state == ContactState.ON_GROUND:
-            # Refine landing (start of ground contact)
-            refined_start = refine_transition_with_curvature(
+            # ON_GROUND: landing at start, takeoff at end
+            refined_start, refined_end = _refine_phase_boundaries(
                 foot_positions,
                 start_frac,
-                "landing",
-                search_window=3,
-                smoothing_window=smoothing_window,
-                polyorder=polyorder,
-            )
-            # Refine takeoff (end of ground contact)
-            refined_end = refine_transition_with_curvature(
-                foot_positions,
                 end_frac,
+                "landing",
                 "takeoff",
-                search_window=3,
-                smoothing_window=smoothing_window,
-                polyorder=polyorder,
+                smoothing_window,
+                polyorder,
             )
-
         elif state == ContactState.IN_AIR:
-            # For flight phases, takeoff is at start, landing is at end
-            refined_start = refine_transition_with_curvature(
+            # IN_AIR: takeoff at start, landing at end
+            refined_start, refined_end = _refine_phase_boundaries(
                 foot_positions,
                 start_frac,
-                "takeoff",
-                search_window=3,
-                smoothing_window=smoothing_window,
-                polyorder=polyorder,
-            )
-            refined_end = refine_transition_with_curvature(
-                foot_positions,
                 end_frac,
+                "takeoff",
                 "landing",
-                search_window=3,
-                smoothing_window=smoothing_window,
-                polyorder=polyorder,
+                smoothing_window,
+                polyorder,
             )
+        else:
+            refined_start, refined_end = start_frac, end_frac
 
         refined_phases.append((refined_start, refined_end, state))
 

kinemotion/{dj → drop_jump}/api.py

@@ -8,8 +8,11 @@ from pathlib import Path
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
+    import numpy as np
     from numpy.typing import NDArray
 
+    from .analysis import ContactState
+
 from ..core.auto_tuning import (
     AnalysisParameters,
     QualityPreset,
@@ -57,6 +60,7 @@ __all__ = [
     "DropJumpVideoConfig",
     "DropJumpVideoResult",
     "process_dropjump_video",
+    "process_dropjump_video_from_config",
     "process_dropjump_videos_bulk",
 ]
 
@@ -98,14 +102,33 @@ class DropJumpVideoConfig:
     overrides: AnalysisOverrides | None = None
     detection_confidence: float | None = None
     tracking_confidence: float | None = None
+    verbose: bool = False
+    timer: Timer | None = None
+    pose_tracker: "MediaPipePoseTracker | None" = None
+
+    def to_kwargs(self) -> dict:
+        """Convert config to kwargs dict for process_dropjump_video."""
+        return {
+            "video_path": self.video_path,
+            "quality": self.quality,
+            "output_video": self.output_video,
+            "json_output": self.json_output,
+            "drop_start_frame": self.drop_start_frame,
+            "overrides": self.overrides,
+            "detection_confidence": self.detection_confidence,
+            "tracking_confidence": self.tracking_confidence,
+            "verbose": self.verbose,
+            "timer": self.timer,
+            "pose_tracker": self.pose_tracker,
+        }
 
 
 def _assess_dropjump_quality(
-    vertical_positions: "NDArray",
-    visibilities: "NDArray",
-    contact_states: list,
+    vertical_positions: "NDArray[np.float64]",
+    visibilities: "NDArray[np.float64]",
+    contact_states: list["ContactState"],
     fps: float,
-) -> tuple:
+) -> tuple[QualityAssessment, "NDArray[np.bool_]", bool, int]:
     """Assess tracking quality and detect phases.
 
     Returns:
@@ -607,6 +630,23 @@ def process_dropjump_video(
             return metrics
 
 
+def process_dropjump_video_from_config(
+    config: DropJumpVideoConfig,
+) -> DropJumpMetrics:
+    """Process a drop jump video using a configuration object.
+
+    This is a convenience wrapper around process_dropjump_video that
+    accepts a DropJumpVideoConfig instead of individual parameters.
+
+    Args:
+        config: Configuration object containing all analysis parameters
+
+    Returns:
+        DropJumpMetrics object containing analysis results
+    """
+    return process_dropjump_video(**config.to_kwargs())
+
+
 def process_dropjump_videos_bulk(
     configs: list[DropJumpVideoConfig],
     max_workers: int = 4,
@@ -633,18 +673,8 @@ def _process_dropjump_video_wrapper(config: DropJumpVideoConfig) -> DropJumpVide
     start_time = time.perf_counter()
 
     try:
-        metrics = process_dropjump_video(
-            video_path=config.video_path,
-            quality=config.quality,
-            output_video=config.output_video,
-            json_output=config.json_output,
-            drop_start_frame=config.drop_start_frame,
-            overrides=config.overrides,
-            detection_confidence=config.detection_confidence,
-            tracking_confidence=config.tracking_confidence,
-            verbose=False,
-        )
-
+        # Use convenience wrapper to avoid parameter unpacking
+        metrics = process_dropjump_video_from_config(config)
         processing_time = time.perf_counter() - start_time
 
         return DropJumpVideoResult(

kinemotion/{dj → drop_jump}/cli.py

@@ -10,8 +10,12 @@ from typing import TYPE_CHECKING
 import click
 
 from ..core.cli_utils import (
+    batch_processing_options,
     collect_video_files,
+    common_output_options,
     generate_batch_output_paths,
+    quality_option,
+    verbose_option,
 )
 from .api import (
     DropJumpVideoConfig,
@@ -39,64 +43,10 @@ class AnalysisParameters:
 
 @click.command(name="dropjump-analyze")
 @click.argument("video_path", nargs=-1, type=click.Path(exists=False), required=True)
-@click.option(
-    "--output",
-    "-o",
-    type=click.Path(),
-    help="Path for debug video output (optional)",
-)
-@click.option(
-    "--json-output",
-    "-j",
-    type=click.Path(),
-    help="Path for JSON metrics output (default: stdout)",
-)
-@click.option(
-    "--quality",
-    type=click.Choice(["fast", "balanced", "accurate"], case_sensitive=False),
-    default="balanced",
-    help=(
-        "Analysis quality preset: "
-        "fast (quick, less precise), "
-        "balanced (default, good for most cases), "
-        "accurate (research-grade, slower)"
-    ),
-    show_default=True,
-)
-@click.option(
-    "--verbose",
-    "-v",
-    is_flag=True,
-    help="Show auto-selected parameters and analysis details",
-)
-# Batch processing options
-@click.option(
-    "--batch",
-    is_flag=True,
-    help="Enable batch processing mode for multiple videos",
-)
-@click.option(
-    "--workers",
-    type=int,
-    default=4,
-    help="Number of parallel workers for batch processing (default: 4)",
-    show_default=True,
-)
-@click.option(
-    "--output-dir",
-    type=click.Path(),
-    help="Directory for debug video outputs (batch mode only)",
-)
-@click.option(
-    "--json-output-dir",
-    type=click.Path(),
-    help="Directory for JSON metrics outputs (batch mode only)",
-)
-@click.option(
-    "--csv-summary",
-    type=click.Path(),
-    help="Path for CSV summary export (batch mode only)",
-)
+@common_output_options
+@quality_option
+@verbose_option
+@batch_processing_options
 # Expert parameters (hidden in help, but always available for advanced users)
 @click.option(
     "--drop-start-frame",

kinemotion/{dj → drop_jump}/kinematics.py

@@ -226,8 +226,90 @@ def _compute_robust_phase_position(
     return float(np.median(window_positions))
 
 
+def _detect_drop_jump_air_first_pattern(
+    air_phases_indexed: list[tuple[int, int, int]],
+    ground_phases: list[tuple[int, int, int]],
+) -> tuple[int, int] | None:
+    """Detect drop jump using air-first pattern (box + drop classified as IN_AIR).
+
+    Pattern: IN_AIR(box+drop) → ON_GROUND(contact) → IN_AIR(flight) → ON_GROUND(land)
+
+    Args:
+        air_phases_indexed: Air phases with indices
+        ground_phases: Ground phases with indices
+
+    Returns:
+        (contact_start, contact_end) if drop jump detected, None otherwise
+    """
+    if not air_phases_indexed or len(ground_phases) < 2:
+        return None
+
+    _, _, first_air_idx = air_phases_indexed[0]
+    first_ground_start, first_ground_end, first_ground_idx = ground_phases[0]
+
+    # Drop jump: first phase is IN_AIR (index 0), second phase is ground (index 1)
+    if first_air_idx != 0 or first_ground_idx != 1:
+        return None
+
+    # Check for flight phase after contact
+    air_after_contact = [i for _, _, i in air_phases_indexed if i > first_ground_idx]
+    if not air_after_contact:
+        return None
+
+    return first_ground_start, first_ground_end
+
+
+def _detect_drop_jump_height_pattern(
+    air_phases_indexed: list[tuple[int, int, int]],
+    ground_phases: list[tuple[int, int, int]],
+    foot_y_positions: NDArray[np.float64],
+) -> tuple[int, int] | None:
+    """Detect drop jump using height comparison (box detected as ground).
+
+    Legacy detection: first ground is on elevated box (lower y value).
+
+    Args:
+        air_phases_indexed: Air phases with indices
+        ground_phases: Ground phases with indices
+        foot_y_positions: Vertical position array
+
+    Returns:
+        (contact_start, contact_end) if drop jump detected, None otherwise
+    """
+    if not air_phases_indexed or len(ground_phases) < 2:
+        return None
+
+    _, _, first_air_idx = air_phases_indexed[0]
+    first_ground_start, first_ground_end, first_ground_idx = ground_phases[0]
+
+    # This pattern: first ground is before first air (athlete on box)
+    if first_ground_idx >= first_air_idx:
+        return None
+
+    ground_after_air = [
+        (start, end, idx) for start, end, idx in ground_phases if idx > first_air_idx
+    ]
+    if not ground_after_air:
+        return None
+
+    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 second ground is significantly lower (>7% of frame), it's a drop jump
+    height_diff = second_ground_y - first_ground_y
+    if height_diff <= 0.07:
+        return None
+
+    return second_ground_start, second_ground_end
+
+
 def _identify_main_contact_phase(
-    phases: list[tuple[int, int, ContactState]],
+    phases: list[tuple[int, int, ContactState]],  # noqa: ARG001  # Used in caller for context
     ground_phases: list[tuple[int, int, int]],
     air_phases_indexed: list[tuple[int, int, int]],
     foot_y_positions: NDArray[np.float64],
@@ -253,55 +335,21 @@ def _identify_main_contact_phase(
     Returns:
         Tuple of (contact_start, contact_end, is_drop_jump)
     """
-    # Initialize with first ground phase as fallback
-    contact_start, contact_end = ground_phases[0][0], ground_phases[0][1]
-    is_drop_jump = False
-
-    # 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]
-
-        # 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 = 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
-        contact_start, contact_end = max(
-            [(s, e) for s, e, _ in ground_phases], key=lambda p: p[1] - p[0]
-        )
-
-    return contact_start, contact_end, is_drop_jump
+    # Try air-first detection pattern (most common for clean videos)
+    result = _detect_drop_jump_air_first_pattern(air_phases_indexed, ground_phases)
+    if result is not None:
+        return result[0], result[1], True
+
+    # Try height-based detection (fallback for box-as-ground videos)
+    result = _detect_drop_jump_height_pattern(air_phases_indexed, ground_phases, foot_y_positions)
+    if result is not None:
+        return result[0], result[1], True
+
+    # Regular jump: use longest ground contact phase
+    contact_start, contact_end = max(
+        [(s, e) for s, e, _ in ground_phases], key=lambda p: p[1] - p[0]
+    )
+    return contact_start, contact_end, False
 
 
 def _find_precise_phase_timing(

kinemotion/{dj → drop_jump}/metrics_validator.py

@@ -14,7 +14,7 @@ from kinemotion.core.validation import (
     MetricsValidator,
     ValidationResult,
 )
-from kinemotion.dj.validation_bounds import (
+from kinemotion.drop_jump.validation_bounds import (
     DropJumpBounds,
     estimate_athlete_profile,
 )
@@ -114,63 +114,37 @@ class DropJumpMetricsValidator(MetricsValidator):
     ) -> None:
         """Validate contact time."""
         contact_time_s = contact_time_ms / 1000.0
-        bounds = DropJumpBounds.CONTACT_TIME
-
-        if not bounds.is_physically_possible(contact_time_s):
-            result.add_error(
-                "contact_time",
-                f"Contact time {contact_time_s:.3f}s physically impossible",
-                value=contact_time_s,
-                bounds=(bounds.absolute_min, bounds.absolute_max),
-            )
-        elif result.athlete_profile and not bounds.contains(
-            contact_time_s, result.athlete_profile
-        ):
-            profile_name = result.athlete_profile.value
-            result.add_warning(
-                "contact_time",
-                f"Contact time {contact_time_s:.3f}s unusual for {profile_name} athlete",
-                value=contact_time_s,
-            )
+        self._validate_metric_with_bounds(
+            name="contact_time",
+            value=contact_time_s,
+            bounds=DropJumpBounds.CONTACT_TIME,
+            profile=result.athlete_profile,
+            result=result,
+            format_str="{value:.3f}s",
+        )
 
     def _check_flight_time(self, flight_time_ms: float, result: DropJumpValidationResult) -> None:
         """Validate flight time."""
         flight_time_s = flight_time_ms / 1000.0
-        bounds = DropJumpBounds.FLIGHT_TIME
-
-        if not bounds.is_physically_possible(flight_time_s):
-            result.add_error(
-                "flight_time",
-                f"Flight time {flight_time_s:.3f}s physically impossible",
-                value=flight_time_s,
-                bounds=(bounds.absolute_min, bounds.absolute_max),
-            )
-        elif result.athlete_profile and not bounds.contains(flight_time_s, result.athlete_profile):
-            profile_name = result.athlete_profile.value
-            result.add_warning(
-                "flight_time",
-                f"Flight time {flight_time_s:.3f}s unusual for {profile_name} athlete",
-                value=flight_time_s,
-            )
+        self._validate_metric_with_bounds(
+            name="flight_time",
+            value=flight_time_s,
+            bounds=DropJumpBounds.FLIGHT_TIME,
+            profile=result.athlete_profile,
+            result=result,
+            format_str="{value:.3f}s",
+        )
 
     def _check_jump_height(self, jump_height_m: float, result: DropJumpValidationResult) -> None:
         """Validate jump height."""
-        bounds = DropJumpBounds.JUMP_HEIGHT
-
-        if not bounds.is_physically_possible(jump_height_m):
-            result.add_error(
-                "jump_height",
-                f"Jump height {jump_height_m:.3f}m physically impossible",
-                value=jump_height_m,
-                bounds=(bounds.absolute_min, bounds.absolute_max),
-            )
-        elif result.athlete_profile and not bounds.contains(jump_height_m, result.athlete_profile):
-            profile_name = result.athlete_profile.value
-            result.add_warning(
-                "jump_height",
-                f"Jump height {jump_height_m:.3f}m unusual for {profile_name} athlete",
-                value=jump_height_m,
-            )
+        self._validate_metric_with_bounds(
+            name="jump_height",
+            value=jump_height_m,
+            bounds=DropJumpBounds.JUMP_HEIGHT,
+            profile=result.athlete_profile,
+            result=result,
+            format_str="{value:.3f}m",
+        )
 
     def _check_rsi(
         self,

{kinemotion-0.72.1.dist-info → kinemotion-0.74.0.dist-info}/METADATA

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

@@ -0,0 +1,51 @@
+kinemotion/__init__.py,sha256=GovgX2mxUmfTH2HsMqlOCfU28niiTdu0c7iTIACcly4,1079
+kinemotion/api.py,sha256=x7rHYgh-bpc6a1kMp9fnnFkU7y96qYelDbzcqN3oUKY,1110
+kinemotion/cli.py,sha256=H3--5whfauDuOyW31lrK1MF-2U-61V11ft5RIndZuUU,644
+kinemotion/core/__init__.py,sha256=E7HDsetuKTJ7EBb8ftNifJoKS8uhS4snRO7HgISyBoM,2035
+kinemotion/core/auto_tuning.py,sha256=ZDmHJJw69wzlRkEJ8OtLPE6KV5wLHcMha1RePVRICkI,11836
+kinemotion/core/cli_utils.py,sha256=6VA8HSnVvKaWMm7d9ahrqwFPXuRPp53s0dib1yCE7yQ,4179
+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=i0x9HM2wzQDvvD9Y54VPIU20Nu-k-IYy6AY9fHPAetY,15179
+kinemotion/core/pose.py,sha256=Z795p0EnaTUeWHO8FuApFcMGTLwZ47JOjs5f5TzRvdk,14224
+kinemotion/core/pose_landmarks.py,sha256=LcEbL5K5xKia6dCzWf6Ft18UIE1CLMMqCZ3KUjwUDzM,1558
+kinemotion/core/quality.py,sha256=JxuM6jwO9i07S6Don3Fki9eFDyITQ6OYJr8YhPSTL7s,13010
+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=-8Wwe56PO37F0OAEMpWr1AB_7QmFtDY5bVmux3oiLYM,9585
+kinemotion/core/video_analysis_base.py,sha256=U8j-6-dv6uiGUiIHl53AIVFUiVHotgTmMNvCArSXx0E,4045
+kinemotion/core/video_io.py,sha256=tLAHm63_sap-CXQpLzmgUXpWZ5_TtBI9LHP8Tk2L-z4,9355
+kinemotion/countermovement_jump/__init__.py,sha256=SkAw9ka8Yd1Qfv9hcvk22m3EfucROzYrSNGNF5kDzho,113
+kinemotion/countermovement_jump/analysis.py,sha256=0ocj1ZbaV4rPeor-y6jvDIKsGalZoozwo7kxwFhQQ1w,20637
+kinemotion/countermovement_jump/api.py,sha256=uNo2JLuFDeBdpi3Y2qf-DyG-1KIRwmSF7HjXMu9Cwj0,19320
+kinemotion/countermovement_jump/cli.py,sha256=m727IOg5BuixgNraCXc2sjW5jGrxrg7RKvFS4qyrBK8,8902
+kinemotion/countermovement_jump/debug_overlay.py,sha256=vF5Apiz8zDRpgrVzf52manLW99m1kHQAPSdUkar5rPs,11474
+kinemotion/countermovement_jump/joint_angles.py,sha256=by5M4LDtUfd2_Z9DmcgUl0nsvarsBYjgsE8KWWYcn08,11255
+kinemotion/countermovement_jump/kinematics.py,sha256=KwA8uSj3g1SeNf0NXMSHsp3gIw6Gfa-6QWIwdYdRXYw,13362
+kinemotion/countermovement_jump/metrics_validator.py,sha256=Gozn88jBpe77GhLIMYZfcAlfAmu4_k9R73bCfcwUsTI,24691
+kinemotion/countermovement_jump/validation_bounds.py,sha256=-0iXDhH-RntiGZi_Co22V6qtA5D-hLzkrPkVcfoNd2U,11343
+kinemotion/drop_jump/__init__.py,sha256=yBbEbPdY6sqozWtTvfbvuUZnrVWSSjBp61xK34M29F4,878
+kinemotion/drop_jump/analysis.py,sha256=ppbhB6Z9GTPzFlIOXso7tq0ldCpf1EZbYk2v31ClLV8,33998
+kinemotion/drop_jump/api.py,sha256=xcA7CkBjLQZhIs6UHr2mo5jT1p-D6e3cgRAFLSwZCmE,21927
+kinemotion/drop_jump/cli.py,sha256=WTUJWCjBl9SgR3Z-2cml1EQhVF8HaXIXQ27fS4tnR7U,14693
+kinemotion/drop_jump/debug_overlay.py,sha256=X4mvCi5Qi1gnvSZZAsUs-0ZRUx9mVBbEUznOFO21HO8,8470
+kinemotion/drop_jump/kinematics.py,sha256=59Q035bXAGGEAdrfLA2mALkWfJUifs35Tvk89xfU8pc,23657
+kinemotion/drop_jump/metrics_validator.py,sha256=yY0wzFzUUDLn6pZcOnwErMlIt_aTWq-RyAkqIemBG5M,7885
+kinemotion/drop_jump/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.74.0.dist-info/METADATA,sha256=lg3dJnKHLKkm-_hs373v_JfjXrJniQp5ngwe9jKMVaU,26125
+kinemotion-0.74.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+kinemotion-0.74.0.dist-info/entry_points.txt,sha256=zaqnAnjLvcdrk1Qvj5nvXZCZ2gp0prS7it1zTJygcIY,50
+kinemotion-0.74.0.dist-info/licenses/LICENSE,sha256=KZajvqsHw0NoOHOi2q0FZ4NBe9HdV6oey-IPYAtHXfg,1088
+kinemotion-0.74.0.dist-info/RECORD,,

kinemotion-0.72.1.dist-info/RECORD

@@ -1,50 +0,0 @@
-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.1.dist-info/METADATA,sha256=yZfreLGtqNencpusq6HrXv4mrVCTZ4tQwAAYWCdWu6U,26125
-kinemotion-0.72.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-kinemotion-0.72.1.dist-info/entry_points.txt,sha256=zaqnAnjLvcdrk1Qvj5nvXZCZ2gp0prS7it1zTJygcIY,50
-kinemotion-0.72.1.dist-info/licenses/LICENSE,sha256=KZajvqsHw0NoOHOi2q0FZ4NBe9HdV6oey-IPYAtHXfg,1088
-kinemotion-0.72.1.dist-info/RECORD,,