kinemotion 0.6.4__py3-none-any.whl → 0.7.0__py3-none-any.whl

kinemotion/core/auto_tuning.py

@@ -0,0 +1,289 @@
+"""Automatic parameter tuning based on video characteristics."""
+
+from dataclasses import dataclass
+from enum import Enum
+
+import numpy as np
+
+
+class QualityPreset(str, Enum):
+    """Quality presets for analysis."""
+
+    FAST = "fast"  # Quick analysis, lower precision
+    BALANCED = "balanced"  # Default: good balance of speed and accuracy
+    ACCURATE = "accurate"  # Research-grade analysis, slower
+
+
+@dataclass
+class VideoCharacteristics:
+    """Characteristics extracted from video analysis."""
+
+    fps: float
+    frame_count: int
+    avg_visibility: float  # Average landmark visibility (0-1)
+    position_variance: float  # Variance in foot positions
+    has_stable_period: bool  # Whether video has initial stationary period
+    tracking_quality: str  # "low", "medium", "high"
+
+
+@dataclass
+class AnalysisParameters:
+    """Auto-tuned parameters for drop jump analysis."""
+
+    smoothing_window: int
+    polyorder: int
+    velocity_threshold: float
+    min_contact_frames: int
+    visibility_threshold: float
+    detection_confidence: float
+    tracking_confidence: float
+    outlier_rejection: bool
+    bilateral_filter: bool
+    use_curvature: bool
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary."""
+        return {
+            "smoothing_window": self.smoothing_window,
+            "polyorder": self.polyorder,
+            "velocity_threshold": self.velocity_threshold,
+            "min_contact_frames": self.min_contact_frames,
+            "visibility_threshold": self.visibility_threshold,
+            "detection_confidence": self.detection_confidence,
+            "tracking_confidence": self.tracking_confidence,
+            "outlier_rejection": self.outlier_rejection,
+            "bilateral_filter": self.bilateral_filter,
+            "use_curvature": self.use_curvature,
+        }
+
+
+def analyze_tracking_quality(avg_visibility: float) -> str:
+    """
+    Classify tracking quality based on average landmark visibility.
+
+    Args:
+        avg_visibility: Average visibility score across all tracked landmarks
+
+    Returns:
+        Quality classification: "low", "medium", or "high"
+    """
+    if avg_visibility < 0.4:
+        return "low"
+    elif avg_visibility < 0.7:
+        return "medium"
+    else:
+        return "high"
+
+
+def auto_tune_parameters(
+    characteristics: VideoCharacteristics,
+    quality_preset: QualityPreset = QualityPreset.BALANCED,
+) -> AnalysisParameters:
+    """
+    Automatically tune analysis parameters based on video characteristics.
+
+    This function implements heuristics to select optimal parameters without
+    requiring user expertise in video analysis or kinematic tracking.
+
+    Key principles:
+    1. FPS-based scaling: Higher fps needs lower velocity thresholds
+    2. Quality-based smoothing: Noisy video needs more smoothing
+    3. Always enable proven features: outlier rejection, curvature analysis
+    4. Preset modifiers: fast/balanced/accurate adjust base parameters
+
+    Args:
+        characteristics: Analyzed video characteristics
+        quality_preset: Quality vs speed tradeoff
+
+    Returns:
+        AnalysisParameters with auto-tuned values
+    """
+    fps = characteristics.fps
+    quality = characteristics.tracking_quality
+
+    # =================================================================
+    # STEP 1: FPS-based baseline parameters
+    # These scale automatically with frame rate to maintain consistent
+    # temporal resolution and sensitivity
+    # =================================================================
+
+    # Velocity threshold: Scale inversely with fps
+    # At 30fps, feet move ~2% of frame per frame when "stationary"
+    # At 60fps, feet move ~1% of frame per frame when "stationary"
+    # Formula: threshold = 0.02 * (30 / fps)
+    base_velocity_threshold = 0.02 * (30.0 / fps)
+
+    # Min contact frames: Scale with fps to maintain same time duration
+    # Goal: ~100ms minimum contact (3 frames @ 30fps, 6 frames @ 60fps)
+    # Formula: frames = round(3 * (fps / 30))
+    base_min_contact_frames = max(2, round(3.0 * (fps / 30.0)))
+
+    # Smoothing window: Decrease with higher fps for better temporal resolution
+    # Lower fps (30fps): 5-frame window = 167ms
+    # Higher fps (60fps): 3-frame window = 50ms (same temporal resolution)
+    if fps <= 30:
+        base_smoothing_window = 5
+    elif fps <= 60:
+        base_smoothing_window = 3
+    else:
+        base_smoothing_window = 3  # Even at 120fps, 3 is minimum for Savitzky-Golay
+
+    # =================================================================
+    # STEP 2: Quality-based adjustments
+    # Adapt smoothing and filtering based on tracking quality
+    # =================================================================
+
+    smoothing_adjustment = 0
+    enable_bilateral = False
+
+    if quality == "low":
+        # Poor tracking quality: aggressive smoothing and filtering
+        smoothing_adjustment = +2
+        enable_bilateral = True
+    elif quality == "medium":
+        # Moderate quality: slight smoothing increase
+        smoothing_adjustment = +1
+        enable_bilateral = True
+    else:  # high quality
+        # Good tracking: preserve detail, minimal smoothing
+        smoothing_adjustment = 0
+        enable_bilateral = False
+
+    # =================================================================
+    # STEP 3: Apply quality preset modifiers
+    # User can choose speed vs accuracy tradeoff
+    # =================================================================
+
+    if quality_preset == QualityPreset.FAST:
+        # Fast: Trade accuracy for speed
+        velocity_threshold = base_velocity_threshold * 1.5  # Less sensitive
+        min_contact_frames = max(2, int(base_min_contact_frames * 0.67))
+        smoothing_window = max(3, base_smoothing_window - 2 + smoothing_adjustment)
+        bilateral_filter = False  # Skip expensive filtering
+        detection_confidence = 0.3
+        tracking_confidence = 0.3
+
+    elif quality_preset == QualityPreset.ACCURATE:
+        # Accurate: Maximize accuracy, accept slower processing
+        velocity_threshold = base_velocity_threshold * 0.5  # More sensitive
+        min_contact_frames = (
+            base_min_contact_frames  # Don't increase (would miss brief)
+        )
+        smoothing_window = min(11, base_smoothing_window + 2 + smoothing_adjustment)
+        bilateral_filter = True  # Always use for best accuracy
+        detection_confidence = 0.6
+        tracking_confidence = 0.6
+
+    else:  # QualityPreset.BALANCED (default)
+        # Balanced: Good accuracy, reasonable speed
+        velocity_threshold = base_velocity_threshold
+        min_contact_frames = base_min_contact_frames
+        smoothing_window = max(3, base_smoothing_window + smoothing_adjustment)
+        bilateral_filter = enable_bilateral
+        detection_confidence = 0.5
+        tracking_confidence = 0.5
+
+    # Ensure smoothing window is odd (required for Savitzky-Golay)
+    if smoothing_window % 2 == 0:
+        smoothing_window += 1
+
+    # =================================================================
+    # STEP 4: Set fixed optimal values
+    # These are always the same regardless of video characteristics
+    # =================================================================
+
+    # Polyorder: Always 2 (quadratic) - optimal for jump physics (parabolic motion)
+    polyorder = 2
+
+    # Visibility threshold: Standard MediaPipe threshold
+    visibility_threshold = 0.5
+
+    # Always enable proven accuracy features
+    outlier_rejection = True  # Removes tracking glitches (minimal cost)
+    use_curvature = True  # Trajectory curvature analysis (minimal cost)
+
+    return AnalysisParameters(
+        smoothing_window=smoothing_window,
+        polyorder=polyorder,
+        velocity_threshold=velocity_threshold,
+        min_contact_frames=min_contact_frames,
+        visibility_threshold=visibility_threshold,
+        detection_confidence=detection_confidence,
+        tracking_confidence=tracking_confidence,
+        outlier_rejection=outlier_rejection,
+        bilateral_filter=bilateral_filter,
+        use_curvature=use_curvature,
+    )
+
+
+def analyze_video_sample(
+    landmarks_sequence: list[dict[str, tuple[float, float, float]] | None],
+    fps: float,
+    frame_count: int,
+) -> VideoCharacteristics:
+    """
+    Analyze video characteristics from a sample of frames.
+
+    This function should be called after tracking the first 30-60 frames
+    to understand video quality and characteristics.
+
+    Args:
+        landmarks_sequence: Tracked landmarks from sample frames
+        fps: Video frame rate
+        frame_count: Total number of frames in video
+
+    Returns:
+        VideoCharacteristics with analyzed properties
+    """
+    # Calculate average landmark visibility
+    visibilities = []
+    positions = []
+
+    for frame_landmarks in landmarks_sequence:
+        if frame_landmarks:
+            # Collect visibility scores from foot landmarks
+            foot_keys = [
+                "left_ankle",
+                "right_ankle",
+                "left_heel",
+                "right_heel",
+                "left_foot_index",
+                "right_foot_index",
+            ]
+
+            frame_vis = []
+            frame_y_positions = []
+
+            for key in foot_keys:
+                if key in frame_landmarks:
+                    _, y, vis = frame_landmarks[key]  # x not needed for analysis
+                    frame_vis.append(vis)
+                    frame_y_positions.append(y)
+
+            if frame_vis:
+                visibilities.append(float(np.mean(frame_vis)))
+            if frame_y_positions:
+                positions.append(float(np.mean(frame_y_positions)))
+
+    # Compute metrics
+    avg_visibility = float(np.mean(visibilities)) if visibilities else 0.5
+    position_variance = float(np.var(positions)) if len(positions) > 1 else 0.0
+
+    # Determine tracking quality
+    tracking_quality = analyze_tracking_quality(avg_visibility)
+
+    # Check for stable period (indicates drop jump from elevated platform)
+    # Simple check: do first 30 frames have low variance?
+    has_stable_period = False
+    if len(positions) >= 30:
+        first_30_std = float(np.std(positions[:30]))
+        has_stable_period = first_30_std < 0.01  # Very stable = on platform
+
+    return VideoCharacteristics(
+        fps=fps,
+        frame_count=frame_count,
+        avg_visibility=avg_visibility,
+        position_variance=position_variance,
+        has_stable_period=has_stable_period,
+        tracking_quality=tracking_quality,
+    )

kinemotion/core/filtering.py

@@ -104,7 +104,7 @@ def detect_outliers_median(
     # Mark as outlier if deviation exceeds threshold
     is_outlier = deviations > threshold
 
-    return is_outlier  # type: ignore[no-any-return]
+    return is_outlier
 
 
 def remove_outliers(

kinemotion/core/smoothing.py

@@ -1,6 +1,5 @@
 """Landmark smoothing utilities to reduce jitter in pose tracking."""
 
-
 import numpy as np
 from scipy.signal import savgol_filter
 
@@ -79,12 +78,12 @@ def smooth_landmarks(
                 smoothed_sequence[frame_idx] = {}
 
             if (
-                landmark_name not in smoothed_sequence[frame_idx]  # type: ignore[operator]
+                landmark_name not in smoothed_sequence[frame_idx]
                 and landmark_sequence[frame_idx] is not None
             ):
                 # Keep original visibility
-                orig_vis = landmark_sequence[frame_idx][landmark_name][2]  # type: ignore[index]
-                smoothed_sequence[frame_idx][landmark_name] = (  # type: ignore[index]
+                orig_vis = landmark_sequence[frame_idx][landmark_name][2]
+                smoothed_sequence[frame_idx][landmark_name] = (
                     float(x_smooth[idx]),
                     float(y_smooth[idx]),
                     orig_vis,
@@ -125,7 +124,7 @@ def compute_velocity(
         for dim in range(velocity.shape[1]):
             velocity[:, dim] = savgol_filter(velocity[:, dim], smooth_window, 1)
 
-    return velocity  # type: ignore[no-any-return]
+    return velocity
 
 
 def compute_velocity_from_derivative(
@@ -154,7 +153,7 @@ def compute_velocity_from_derivative(
     """
     if len(positions) < window_length:
         # Fallback to simple differences for short sequences
-        return np.abs(np.diff(positions, prepend=positions[0]))  # type: ignore[no-any-return]
+        return np.abs(np.diff(positions, prepend=positions[0]))
 
     # Ensure window_length is odd
     if window_length % 2 == 0:
@@ -174,7 +173,7 @@ def compute_velocity_from_derivative(
     )
 
     # Return absolute velocity (magnitude only)
-    return np.abs(velocity)  # type: ignore[no-any-return]
+    return np.abs(velocity)
 
 
 def compute_acceleration_from_derivative(
@@ -225,7 +224,7 @@ def compute_acceleration_from_derivative(
         mode="interp",
     )
 
-    return acceleration  # type: ignore[no-any-return]
+    return acceleration
 
 
 def smooth_landmarks_advanced(
@@ -345,12 +344,12 @@ def smooth_landmarks_advanced(
                 smoothed_sequence[frame_idx] = {}
 
             if (
-                landmark_name not in smoothed_sequence[frame_idx]  # type: ignore[operator]
+                landmark_name not in smoothed_sequence[frame_idx]
                 and landmark_sequence[frame_idx] is not None
             ):
                 # Keep original visibility
-                orig_vis = landmark_sequence[frame_idx][landmark_name][2]  # type: ignore[index]
-                smoothed_sequence[frame_idx][landmark_name] = (  # type: ignore[index]
+                orig_vis = landmark_sequence[frame_idx][landmark_name][2]
+                smoothed_sequence[frame_idx][landmark_name] = (
                     float(x_smooth[idx]),
                     float(y_smooth[idx]),
                     orig_vis,

kinemotion/core/video_io.py

@@ -45,20 +45,35 @@ class VideoProcessor:
             self.width = int(self.cap.get(cv2.CAP_PROP_FRAME_WIDTH))
             self.height = int(self.cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
 
+        # Extract rotation metadata from video (iPhones store rotation in side_data_list)
+        # OpenCV ignores rotation metadata, so we need to extract and apply it manually
+        self.rotation = 0  # Will be set by _extract_video_metadata()
+
         # Calculate display dimensions considering SAR (Sample Aspect Ratio)
         # Mobile videos often have non-square pixels encoded in SAR metadata
         # OpenCV doesn't directly expose SAR, but we need to handle display correctly
         self.display_width = self.width
         self.display_height = self.height
-        self._calculate_display_dimensions()
+        self._extract_video_metadata()
+
+        # Apply rotation to dimensions if needed
+        if self.rotation in [90, -90, 270]:
+            # Swap dimensions for 90/-90 degree rotations
+            self.width, self.height = self.height, self.width
+            self.display_width, self.display_height = (
+                self.display_height,
+                self.display_width,
+            )
 
-    def _calculate_display_dimensions(self) -> None:
+    def _extract_video_metadata(self) -> None:
         """
-        Calculate display dimensions by reading SAR metadata from video file.
+        Extract video metadata including SAR and rotation using ffprobe.
 
-        Many mobile videos use non-square pixels (SAR != 1:1), which means
-        the encoded dimensions differ from how the video should be displayed.
-        We use ffprobe to extract this metadata.
+        Many mobile videos (especially from iPhones) have:
+        - Non-square pixels (SAR != 1:1) affecting display dimensions
+        - Rotation metadata in side_data_list that OpenCV ignores
+
+        We extract both to ensure proper display and pose detection.
         """
         try:
             # Use ffprobe to get SAR metadata
@@ -83,6 +98,8 @@ class VideoProcessor:
                 data = json.loads(result.stdout)
                 if "streams" in data and len(data["streams"]) > 0:
                     stream = data["streams"][0]
+
+                    # Extract SAR (Sample Aspect Ratio)
                     sar_str = stream.get("sample_aspect_ratio", "1:1")
 
                     # Parse SAR (e.g., "270:473")
@@ -98,14 +115,41 @@ class VideoProcessor:
                                 self.width * sar_width / sar_height
                             )
                             self.display_height = self.height
+
+                    # Extract rotation from side_data_list (common for iPhone videos)
+                    side_data_list = stream.get("side_data_list", [])
+                    for side_data in side_data_list:
+                        if side_data.get("side_data_type") == "Display Matrix":
+                            rotation = side_data.get("rotation", 0)
+                            # Convert to int and normalize to 0, 90, -90, 180
+                            self.rotation = int(rotation)
         except (subprocess.TimeoutExpired, FileNotFoundError, json.JSONDecodeError):
             # If ffprobe fails, keep original dimensions (square pixels)
             pass
 
     def read_frame(self) -> np.ndarray | None:
-        """Read next frame from video."""
+        """
+        Read next frame from video and apply rotation if needed.
+
+        OpenCV ignores rotation metadata, so we manually apply rotation
+        based on the display matrix metadata extracted from the video.
+        """
         ret, frame = self.cap.read()
-        return frame if ret else None
+        if not ret:
+            return None
+
+        # Apply rotation if video has rotation metadata
+        if self.rotation == -90 or self.rotation == 270:
+            # -90 degrees = rotate 90 degrees clockwise
+            frame = cv2.rotate(frame, cv2.ROTATE_90_CLOCKWISE)
+        elif self.rotation == 90 or self.rotation == -270:
+            # 90 degrees = rotate 90 degrees counter-clockwise
+            frame = cv2.rotate(frame, cv2.ROTATE_90_COUNTERCLOCKWISE)
+        elif self.rotation == 180 or self.rotation == -180:
+            # 180 degrees rotation
+            frame = cv2.rotate(frame, cv2.ROTATE_180)
+
+        return frame
 
     def reset(self) -> None:
         """Reset video to beginning."""

kinemotion/dropjump/analysis.py

@@ -89,6 +89,123 @@ def calculate_adaptive_threshold(
     return adaptive_threshold
 
 
+def detect_drop_start(
+    positions: np.ndarray,
+    fps: float,
+    min_stationary_duration: float = 1.0,
+    position_change_threshold: float = 0.02,
+    smoothing_window: int = 5,
+    debug: bool = False,
+) -> int:
+    """
+    Detect when the drop jump actually starts by finding stable period then detecting drop.
+
+    Strategy:
+    1. Scan forward to find first STABLE period (low variance over N frames)
+    2. Use that stable period as baseline
+    3. Detect when position starts changing significantly from baseline
+
+    This handles videos where athlete steps onto box at start (unstable beginning).
+
+    Args:
+        positions: Array of vertical positions (0-1 normalized, y increases downward)
+        fps: Video frame rate
+        min_stationary_duration: Minimum duration (seconds) of stable period (default: 1.0s)
+        position_change_threshold: Position change indicating start of drop
+            (default: 0.02 = 2% of frame)
+        smoothing_window: Window for computing position variance
+        debug: Print debug information (default: False)
+
+    Returns:
+        Frame index where drop starts (or 0 if no clear stable period found)
+
+    Example:
+        - Frames 0-14: Stepping onto box (noisy, unstable)
+        - Frames 15-119: Standing on box (stable, low variance)
+        - Frame 119: Drop begins (position changes significantly)
+        - Returns: 119
+    """
+    min_stable_frames = int(fps * min_stationary_duration)
+    if len(positions) < min_stable_frames + 30:  # Need some frames after stable period
+        if debug:
+            min_frames_needed = min_stable_frames + 30
+            print(
+                f"[detect_drop_start] Video too short: {len(positions)} < {min_frames_needed}"
+            )
+        return 0
+
+    # STEP 1: Find first stable period by scanning forward
+    # Look for window with low variance (< 1% of frame height)
+    stability_threshold = 0.01  # 1% of frame height
+    stable_window = min_stable_frames
+
+    baseline_start = -1
+    baseline_position = 0.0
+
+    # Scan from start, looking for stable window
+    for start_idx in range(0, len(positions) - stable_window, 5):  # Step by 5 frames
+        window = positions[start_idx : start_idx + stable_window]
+        window_std = float(np.std(window))
+
+        if window_std < stability_threshold:
+            # Found stable period!
+            baseline_start = start_idx
+            baseline_position = float(np.median(window))
+
+            if debug:
+                end_frame = baseline_start + stable_window - 1
+                print("[detect_drop_start] Found stable period:")
+                print(f"  frames {baseline_start}-{end_frame}")
+                print(f"  baseline_position: {baseline_position:.4f}")
+                print(f"  baseline_std: {window_std:.4f} < {stability_threshold:.4f}")
+            break
+
+    if baseline_start < 0:
+        if debug:
+            msg = (
+                f"No stable period found (variance always > {stability_threshold:.4f})"
+            )
+            print(f"[detect_drop_start] {msg}")
+        return 0
+
+    # STEP 2: Find when position changes significantly from baseline
+    # Start searching after stable period ends
+    search_start = baseline_start + stable_window
+    window_size = max(3, smoothing_window)
+
+    for i in range(search_start, len(positions) - window_size):
+        # Average position over small window to reduce noise
+        window_positions = positions[i : i + window_size]
+        avg_position = float(np.mean(window_positions))
+
+        # Check if position has increased (dropped) significantly
+        position_change = avg_position - baseline_position
+
+        if position_change > position_change_threshold:
+            # Found start of drop - back up slightly to catch beginning
+            drop_frame_candidate = i - window_size
+            if drop_frame_candidate < baseline_start:
+                drop_frame = baseline_start
+            else:
+                drop_frame = drop_frame_candidate
+
+            if debug:
+                print(f"[detect_drop_start] Drop detected at frame {drop_frame}")
+                print(
+                    f"  position_change: {position_change:.4f} > {position_change_threshold:.4f}"
+                )
+                print(
+                    f"  avg_position: {avg_position:.4f} vs baseline: {baseline_position:.4f}"
+                )
+
+            return drop_frame
+
+    # No significant position change detected
+    if debug:
+        print("[detect_drop_start] No drop detected after stable period")
+    return 0
+
+
 def detect_ground_contact(
     foot_positions: np.ndarray,
     velocity_threshold: float = 0.02,
@@ -273,7 +390,9 @@ def find_interpolated_phase_transitions(
 
         # Interpolate start boundary (transition INTO this phase)
         if start_idx > 0 and start_idx < len(velocities):
-            vel_before = velocities[start_idx - 1] if start_idx > 0 else velocities[start_idx]
+            vel_before = (
+                velocities[start_idx - 1] if start_idx > 0 else velocities[start_idx]
+            )
             vel_at = velocities[start_idx]
 
             # Check if we're crossing the threshold at this boundary
@@ -392,9 +511,7 @@ def refine_transition_with_curvature(
     # Blend with original estimate (don't stray too far)
     # 70% curvature-based, 30% velocity-based
     blend_factor = 0.7
-    refined_frame = (
-        blend_factor * refined_frame + (1 - blend_factor) * estimated_frame
-    )
+    refined_frame = blend_factor * refined_frame + (1 - blend_factor) * estimated_frame
 
     return refined_frame
 

kinemotion/dropjump/cli.py

@@ -3,10 +3,16 @@
 import json
 import sys
 from pathlib import Path
+from typing import Any
 
 import click
 import numpy as np
 
+from ..core.auto_tuning import (
+    QualityPreset,
+    analyze_video_sample,
+    auto_tune_parameters,
+)
 from ..core.pose import PoseTracker
 from ..core.smoothing import smooth_landmarks, smooth_landmarks_advanced
 from ..core.video_io import VideoProcessor
@@ -33,140 +39,102 @@ from .kinematics import calculate_drop_jump_metrics
     help="Path for JSON metrics output (default: stdout)",
 )
 @click.option(
-    "--smoothing-window",
-    type=int,
-    default=5,
-    help="Smoothing window size (must be odd, >= 3)",
-    show_default=True,
+    "--drop-height",
+    type=float,
+    required=True,
+    help=(
+        "Height of drop box/platform in meters (e.g., 0.40 for 40cm box) - "
+        "REQUIRED for accurate calibration"
+    ),
 )
 @click.option(
-    "--polyorder",
-    type=int,
-    default=2,
+    "--quality",
+    type=click.Choice(["fast", "balanced", "accurate"], case_sensitive=False),
+    default="balanced",
     help=(
-        "Polynomial order for Savitzky-Golay smoothing "
-        "(2=quadratic, 3=cubic, must be < smoothing-window)"
+        "Analysis quality preset: "
+        "fast (quick, less precise), "
+        "balanced (default, good for most cases), "
+        "accurate (research-grade, slower)"
     ),
     show_default=True,
 )
 @click.option(
-    "--outlier-rejection/--no-outlier-rejection",
-    default=True,
-    help=(
-        "Apply RANSAC and median-based outlier rejection to remove tracking glitches "
-        "(default: enabled, +1-2%% accuracy)"
-    ),
+    "--verbose",
+    "-v",
+    is_flag=True,
+    help="Show auto-selected parameters and analysis details",
 )
+# Expert parameters (hidden in help, but always available for advanced users)
 @click.option(
-    "--bilateral-filter/--no-bilateral-filter",
-    default=False,
-    help=(
-        "Use bilateral temporal filter for edge-preserving smoothing "
-        "(default: disabled, experimental)"
-    ),
+    "--drop-start-frame",
+    type=int,
+    default=None,
+    help="[EXPERT] Manually specify frame where drop begins (overrides auto-detection)",
+)
+@click.option(
+    "--smoothing-window",
+    type=int,
+    default=None,
+    help="[EXPERT] Override auto-tuned smoothing window size",
 )
 @click.option(
     "--velocity-threshold",
     type=float,
-    default=0.02,
-    help="Velocity threshold for contact detection (normalized units)",
-    show_default=True,
+    default=None,
+    help="[EXPERT] Override auto-tuned velocity threshold",
 )
 @click.option(
     "--min-contact-frames",
     type=int,
-    default=3,
-    help="Minimum frames for valid ground contact",
-    show_default=True,
+    default=None,
+    help="[EXPERT] Override auto-tuned minimum contact frames",
 )
 @click.option(
     "--visibility-threshold",
     type=float,
-    default=0.5,
-    help="Minimum landmark visibility score (0-1)",
-    show_default=True,
+    default=None,
+    help="[EXPERT] Override visibility threshold",
 )
 @click.option(
     "--detection-confidence",
     type=float,
-    default=0.5,
-    help="Pose detection confidence threshold (0-1)",
-    show_default=True,
+    default=None,
+    help="[EXPERT] Override pose detection confidence",
 )
 @click.option(
     "--tracking-confidence",
     type=float,
-    default=0.5,
-    help="Pose tracking confidence threshold (0-1)",
-    show_default=True,
-)
-@click.option(
-    "--drop-height",
-    type=float,
     default=None,
-    help="Height of drop box/platform in meters (e.g., 0.40 for 40cm) - used for calibration",
-)
-@click.option(
-    "--use-curvature/--no-curvature",
-    default=True,
-    help="Use trajectory curvature analysis for refining transitions (default: enabled)",
-)
-@click.option(
-    "--kinematic-correction-factor",
-    type=float,
-    default=1.0,
-    help=(
-        "Correction factor for kinematic jump height (default: 1.0 = no correction). "
-        "Historical testing suggested 1.35, but this is UNVALIDATED. "
-        "Use --drop-height for validated measurements."
-    ),
-    show_default=True,
+    help="[EXPERT] Override pose tracking confidence",
 )
 def dropjump_analyze(
     video_path: str,
     output: str | None,
     json_output: str | None,
-    smoothing_window: int,
-    polyorder: int,
-    outlier_rejection: bool,
-    bilateral_filter: bool,
-    velocity_threshold: float,
-    min_contact_frames: int,
-    visibility_threshold: float,
-    detection_confidence: float,
-    tracking_confidence: float,
-    drop_height: float | None,
-    use_curvature: bool,
-    kinematic_correction_factor: float,
+    drop_height: float,
+    quality: str,
+    verbose: bool,
+    drop_start_frame: int | None,
+    smoothing_window: int | None,
+    velocity_threshold: float | None,
+    min_contact_frames: int | None,
+    visibility_threshold: float | None,
+    detection_confidence: float | None,
+    tracking_confidence: float | None,
 ) -> None:
     """
     Analyze drop-jump video to estimate ground contact time, flight time, and jump height.
 
+    Uses intelligent auto-tuning to select optimal parameters based on video characteristics.
+    Parameters are automatically adjusted for frame rate, tracking quality, and analysis preset.
+
     VIDEO_PATH: Path to the input video file
     """
     click.echo(f"Analyzing video: {video_path}", err=True)
 
-    # Validate parameters
-    if smoothing_window < 3:
-        click.echo("Error: smoothing-window must be >= 3", err=True)
-        sys.exit(1)
-
-    if smoothing_window % 2 == 0:
-        smoothing_window += 1
-        click.echo(
-            f"Adjusting smoothing-window to {smoothing_window} (must be odd)", err=True
-        )
-
-    if polyorder < 1:
-        click.echo("Error: polyorder must be >= 1", err=True)
-        sys.exit(1)
-
-    if polyorder >= smoothing_window:
-        click.echo(
-            f"Error: polyorder ({polyorder}) must be < smoothing-window ({smoothing_window})",
-            err=True,
-        )
-        sys.exit(1)
+    # Convert quality string to enum
+    quality_preset = QualityPreset(quality.lower())
 
     try:
         # Initialize video processor
@@ -177,10 +145,32 @@ def dropjump_analyze(
                 err=True,
             )
 
+            # ================================================================
+            # STEP 1: Auto-tune parameters based on video characteristics
+            # ================================================================
+
+            # Analyze video characteristics from a sample to determine optimal parameters
+            # We'll use detection/tracking confidence from quality preset for initial tracking
+            initial_detection_conf = 0.5
+            initial_tracking_conf = 0.5
+
+            if quality_preset == QualityPreset.FAST:
+                initial_detection_conf = 0.3
+                initial_tracking_conf = 0.3
+            elif quality_preset == QualityPreset.ACCURATE:
+                initial_detection_conf = 0.6
+                initial_tracking_conf = 0.6
+
+            # Override with expert values if provided
+            if detection_confidence is not None:
+                initial_detection_conf = detection_confidence
+            if tracking_confidence is not None:
+                initial_tracking_conf = tracking_confidence
+
             # Initialize pose tracker
             tracker = PoseTracker(
-                min_detection_confidence=detection_confidence,
-                min_tracking_confidence=tracking_confidence,
+                min_detection_confidence=initial_detection_conf,
+                min_tracking_confidence=initial_tracking_conf,
             )
 
             # Process all frames
@@ -189,6 +179,7 @@ def dropjump_analyze(
             frames = []
 
             frame_idx = 0
+            bar: Any
             with click.progressbar(
                 length=video.frame_count, label="Processing frames"
             ) as bar:
@@ -210,28 +201,90 @@ def dropjump_analyze(
                 click.echo("Error: No frames processed", err=True)
                 sys.exit(1)
 
-            # Smooth landmarks
-            if outlier_rejection or bilateral_filter:
-                if outlier_rejection:
+            # ================================================================
+            # STEP 2: Analyze video characteristics and auto-tune parameters
+            # ================================================================
+
+            characteristics = analyze_video_sample(
+                landmarks_sequence, video.fps, video.frame_count
+            )
+
+            # Auto-tune parameters based on video characteristics
+            params = auto_tune_parameters(characteristics, quality_preset)
+
+            # Apply expert overrides if provided
+            if smoothing_window is not None:
+                params.smoothing_window = smoothing_window
+            if velocity_threshold is not None:
+                params.velocity_threshold = velocity_threshold
+            if min_contact_frames is not None:
+                params.min_contact_frames = min_contact_frames
+            if visibility_threshold is not None:
+                params.visibility_threshold = visibility_threshold
+
+            # Show selected parameters if verbose
+            if verbose:
+                click.echo("\n" + "=" * 60, err=True)
+                click.echo("AUTO-TUNED PARAMETERS", err=True)
+                click.echo("=" * 60, err=True)
+                click.echo(f"Video FPS: {video.fps:.2f}", err=True)
+                click.echo(
+                    f"Tracking quality: {characteristics.tracking_quality} "
+                    f"(avg visibility: {characteristics.avg_visibility:.2f})",
+                    err=True,
+                )
+                click.echo(f"Quality preset: {quality_preset.value}", err=True)
+                click.echo("\nSelected parameters:", err=True)
+                click.echo(f"  smoothing_window: {params.smoothing_window}", err=True)
+                click.echo(f"  polyorder: {params.polyorder}", err=True)
+                click.echo(
+                    f"  velocity_threshold: {params.velocity_threshold:.4f}", err=True
+                )
+                click.echo(
+                    f"  min_contact_frames: {params.min_contact_frames}", err=True
+                )
+                click.echo(
+                    f"  visibility_threshold: {params.visibility_threshold}", err=True
+                )
+                click.echo(
+                    f"  detection_confidence: {params.detection_confidence}", err=True
+                )
+                click.echo(
+                    f"  tracking_confidence: {params.tracking_confidence}", err=True
+                )
+                click.echo(f"  outlier_rejection: {params.outlier_rejection}", err=True)
+                click.echo(f"  bilateral_filter: {params.bilateral_filter}", err=True)
+                click.echo(f"  use_curvature: {params.use_curvature}", err=True)
+                click.echo("=" * 60 + "\n", err=True)
+
+            # ================================================================
+            # STEP 3: Apply smoothing with auto-tuned parameters
+            # ================================================================
+
+            # Smooth landmarks using auto-tuned parameters
+            if params.outlier_rejection or params.bilateral_filter:
+                if params.outlier_rejection:
                     click.echo(
                         "Smoothing landmarks with outlier rejection...", err=True
                     )
-                if bilateral_filter:
+                if params.bilateral_filter:
                     click.echo(
                         "Using bilateral temporal filter for edge-preserving smoothing...",
                         err=True,
                     )
                 smoothed_landmarks = smooth_landmarks_advanced(
                     landmarks_sequence,
-                    window_length=smoothing_window,
-                    polyorder=polyorder,
-                    use_outlier_rejection=outlier_rejection,
-                    use_bilateral=bilateral_filter,
+                    window_length=params.smoothing_window,
+                    polyorder=params.polyorder,
+                    use_outlier_rejection=params.outlier_rejection,
+                    use_bilateral=params.bilateral_filter,
                 )
             else:
                 click.echo("Smoothing landmarks...", err=True)
                 smoothed_landmarks = smooth_landmarks(
-                    landmarks_sequence, window_length=smoothing_window, polyorder=polyorder
+                    landmarks_sequence,
+                    window_length=params.smoothing_window,
+                    polyorder=params.polyorder,
                 )
 
             # Extract vertical positions from feet
@@ -261,42 +314,40 @@ def dropjump_analyze(
                     )
                 else:
                     # Use previous position if available, otherwise default
-                    position_list.append(
-                        position_list[-1] if position_list else 0.5
-                    )
+                    position_list.append(position_list[-1] if position_list else 0.5)
                     visibilities_list.append(0.0)
 
             vertical_positions: np.ndarray = np.array(position_list)
             visibilities: np.ndarray = np.array(visibilities_list)
 
-            # Detect ground contact
+            # Detect ground contact using auto-tuned parameters
             contact_states = detect_ground_contact(
                 vertical_positions,
-                velocity_threshold=velocity_threshold,
-                min_contact_frames=min_contact_frames,
-                visibility_threshold=visibility_threshold,
+                velocity_threshold=params.velocity_threshold,
+                min_contact_frames=params.min_contact_frames,
+                visibility_threshold=params.visibility_threshold,
                 visibilities=visibilities,
-                window_length=smoothing_window,
-                polyorder=polyorder,
+                window_length=params.smoothing_window,
+                polyorder=params.polyorder,
             )
 
             # Calculate metrics
             click.echo("Calculating metrics...", err=True)
-            if drop_height:
-                click.echo(
-                    f"Using drop height calibration: {drop_height}m ({drop_height*100:.0f}cm)",
-                    err=True,
-                )
+            click.echo(
+                f"Using drop height calibration: {drop_height}m ({drop_height*100:.0f}cm)",
+                err=True,
+            )
             metrics = calculate_drop_jump_metrics(
                 contact_states,
                 vertical_positions,
                 video.fps,
                 drop_height_m=drop_height,
-                velocity_threshold=velocity_threshold,
-                smoothing_window=smoothing_window,
-                polyorder=polyorder,
-                use_curvature=use_curvature,
-                kinematic_correction_factor=kinematic_correction_factor,
+                drop_start_frame=drop_start_frame,
+                velocity_threshold=params.velocity_threshold,
+                smoothing_window=params.smoothing_window,
+                polyorder=params.polyorder,
+                use_curvature=params.use_curvature,
+                kinematic_correction_factor=1.0,  # Always 1.0 now (no experimental correction)
             )
 
             # Output metrics as JSON
@@ -313,7 +364,10 @@ def dropjump_analyze(
             # Generate debug video if requested
             if output:
                 click.echo(f"Generating debug video: {output}", err=True)
-                if video.display_width != video.width or video.display_height != video.height:
+                if (
+                    video.display_width != video.width
+                    or video.display_height != video.height
+                ):
                     click.echo(
                         f"Source video encoded: {video.width}x{video.height}",
                         err=True,
@@ -337,9 +391,10 @@ def dropjump_analyze(
                     video.display_height,
                     video.fps,
                 ) as renderer:
+                    render_bar: Any
                     with click.progressbar(
                         length=len(frames), label="Rendering frames"
-                    ) as bar:
+                    ) as render_bar:
                         for i, frame in enumerate(frames):
                             annotated = renderer.render_frame(
                                 frame,
@@ -350,7 +405,7 @@ def dropjump_analyze(
                                 use_com=False,
                             )
                             renderer.write_frame(annotated)
-                            bar.update(1)
+                            render_bar.update(1)
 
                 click.echo(f"Debug video saved: {output}", err=True)
 

kinemotion/dropjump/debug_overlay.py

@@ -38,7 +38,7 @@ class DebugOverlayRenderer:
         self.needs_resize = (display_width != width) or (display_height != height)
 
         # Try H.264 codec first (better quality/compatibility), fallback to mp4v
-        fourcc = cv2.VideoWriter_fourcc(*"avc1")  # type: ignore[attr-defined]
+        fourcc = cv2.VideoWriter_fourcc(*"avc1")
         # IMPORTANT: cv2.VideoWriter expects (width, height) tuple - NOT (height, width)
         # Write at display dimensions so video displays correctly without SAR metadata
         self.writer = cv2.VideoWriter(
@@ -47,7 +47,7 @@ class DebugOverlayRenderer:
 
         # Check if writer opened successfully, fallback to mp4v if not
         if not self.writer.isOpened():
-            fourcc = cv2.VideoWriter_fourcc(*"mp4v")  # type: ignore[attr-defined]
+            fourcc = cv2.VideoWriter_fourcc(*"mp4v")
             self.writer = cv2.VideoWriter(
                 output_path, fourcc, fps, (display_width, display_height)
             )
@@ -93,7 +93,9 @@ class DebugOverlayRenderer:
 
                 # Draw CoM with larger circle
                 color = (
-                    (0, 255, 0) if contact_state == ContactState.ON_GROUND else (0, 0, 255)
+                    (0, 255, 0)
+                    if contact_state == ContactState.ON_GROUND
+                    else (0, 0, 255)
                 )
                 cv2.circle(annotated, (px, py), 15, color, -1)
                 cv2.circle(annotated, (px, py), 17, (255, 255, 255), 2)  # White border
@@ -105,7 +107,9 @@ class DebugOverlayRenderer:
                     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(annotated, (hip_x, hip_y), 8, (255, 165, 0), -1)  # Orange
+                    cv2.circle(
+                        annotated, (hip_x, hip_y), 8, (255, 165, 0), -1
+                    )  # Orange
                     # Draw line from hip to CoM
                     cv2.line(annotated, (hip_x, hip_y), (px, py), (255, 165, 0), 2)
             else:
@@ -116,7 +120,9 @@ class DebugOverlayRenderer:
 
                 # Draw foot position circle
                 color = (
-                    (0, 255, 0) if contact_state == ContactState.ON_GROUND else (0, 0, 255)
+                    (0, 255, 0)
+                    if contact_state == ContactState.ON_GROUND
+                    else (0, 0, 255)
                 )
                 cv2.circle(annotated, (px, py), 10, color, -1)
 

kinemotion/dropjump/kinematics.py

@@ -1,10 +1,10 @@
 """Kinematic calculations for drop-jump metrics."""
 
-
 import numpy as np
 
 from .analysis import (
     ContactState,
+    detect_drop_start,
     find_contact_phases,
     find_interpolated_phase_transitions_with_curvature,
 )
@@ -109,6 +109,7 @@ def calculate_drop_jump_metrics(
     foot_y_positions: np.ndarray,
     fps: float,
     drop_height_m: float | None = None,
+    drop_start_frame: int | None = None,
     velocity_threshold: float = 0.02,
     smoothing_window: int = 5,
     polyorder: int = 2,
@@ -135,6 +136,20 @@ def calculate_drop_jump_metrics(
         DropJumpMetrics object with calculated values
     """
     metrics = DropJumpMetrics()
+
+    # Detect or use manually specified drop jump start frame
+    if drop_start_frame is None:
+        # Auto-detect where drop jump actually starts (skip initial stationary period)
+        drop_start_frame = detect_drop_start(
+            foot_y_positions,
+            fps,
+            min_stationary_duration=0.5,  # 0.5s stable period (~30 frames @ 60fps)
+            position_change_threshold=0.005,  # 0.5% of frame height - sensitive to drop start
+            smoothing_window=smoothing_window,
+        )
+    # If manually specified or auto-detected, use it
+    drop_start_frame_value = drop_start_frame if drop_start_frame is not None else 0
+
     phases = find_contact_phases(contact_states)
 
     # Get interpolated phases with curvature-based refinement
@@ -148,6 +163,23 @@ def calculate_drop_jump_metrics(
         use_curvature,
     )
 
+    if not phases:
+        return metrics
+
+    # Filter phases to only include those after drop start
+    # This removes the initial stationary period where athlete is standing on box
+    if drop_start_frame_value > 0:
+        phases = [
+            (start, end, state)
+            for start, end, state in phases
+            if end >= drop_start_frame_value
+        ]
+        interpolated_phases = [
+            (start, end, state)
+            for start, end, state in interpolated_phases
+            if end >= drop_start_frame_value
+        ]
+
     if not phases:
         return metrics
 
@@ -177,7 +209,9 @@ def calculate_drop_jump_metrics(
 
         # 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
+            (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:
@@ -241,7 +275,9 @@ def calculate_drop_jump_metrics(
             # Look back a few frames to get stable position on box
             lookback_start = max(0, first_air_start - 5)
             if lookback_start < first_air_start:
-                initial_position = float(np.mean(foot_y_positions[lookback_start:first_air_start]))
+                initial_position = float(
+                    np.mean(foot_y_positions[lookback_start:first_air_start])
+                )
             else:
                 initial_position = float(foot_y_positions[first_air_start])
 
@@ -337,13 +373,17 @@ def calculate_drop_jump_metrics(
                 # For validated measurements, use:
                 # - Calibrated measurement with --drop-height parameter
                 # - Or compare against validated measurement systems
-                metrics.jump_height = jump_height_kinematic * kinematic_correction_factor
+                metrics.jump_height = (
+                    jump_height_kinematic * kinematic_correction_factor
+                )
                 metrics.jump_height_kinematic = jump_height_kinematic
         else:
             # Fallback to kinematic if no position data
             if drop_height_m is None:
                 # Apply kinematic correction factor (see detailed comment above)
-                metrics.jump_height = jump_height_kinematic * kinematic_correction_factor
+                metrics.jump_height = (
+                    jump_height_kinematic * kinematic_correction_factor
+                )
             else:
                 metrics.jump_height = jump_height_kinematic
             metrics.jump_height_kinematic = jump_height_kinematic

{kinemotion-0.6.4.dist-info → kinemotion-0.7.0.dist-info}/METADATA

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

@@ -0,0 +1,18 @@
+kinemotion/__init__.py,sha256=JhS0ZTgcTdcMH5WcIyWxEqZJPOoBUSKX8tT8hsG-xWk,98
+kinemotion/cli.py,sha256=2IFA2_TE9a5zBtmGVzv5SnX39w7yPuBlw42dL7ca25U,402
+kinemotion/core/__init__.py,sha256=3yzDhb5PekDNjydqrs8aWGneUGJBt-lB0SoB_Y2FXqU,1010
+kinemotion/core/auto_tuning.py,sha256=cvmxUI-CbahpOJQtR2r5jOx4Q6yKPe3DO1o15hOQIdw,10508
+kinemotion/core/filtering.py,sha256=5opOq0Fbot_AvsT8cT2kS9uyD_uqLW-jR6SXZbg672c,11235
+kinemotion/core/pose.py,sha256=5Dhw3LqX3STR-eLb5JAQkxhS-dd0PqGytBWnaQ66nWc,8391
+kinemotion/core/smoothing.py,sha256=VVv95auiuah_GPG3jxiQPyiYXF5i3B4fF9UGI5FLX-Q,12897
+kinemotion/core/video_io.py,sha256=z8Z0qbNaKbcdB40KnbNOBMzab3BbgnhBxp-mUBYeXgM,6577
+kinemotion/dropjump/__init__.py,sha256=yc1XiZ9vfo5h_n7PKVSiX2TTgaIfGL7Y7SkQtiDZj_E,838
+kinemotion/dropjump/analysis.py,sha256=HfJt2t9IsMBiBUz7apIzdxbRH9QqzlFnDVVWcKhU3ow,23291
+kinemotion/dropjump/cli.py,sha256=nhcqYClTx9R0XeTduJCNspltNgeaK4W8ZUT1ACB8GFI,15601
+kinemotion/dropjump/debug_overlay.py,sha256=hmEtadqYP8K-kGr_Q03KDQyl1152-YSPeRJzEXMyuhs,8687
+kinemotion/dropjump/kinematics.py,sha256=RceIH2HndpHQpcOQd56MmEdXQNEst-CWXfBKPJk2g3Y,17659
+kinemotion-0.7.0.dist-info/METADATA,sha256=D9N1JQN9MQpSDch4TdC-cz_SaBYXaaaj8kiEuLsacAk,19321
+kinemotion-0.7.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+kinemotion-0.7.0.dist-info/entry_points.txt,sha256=zaqnAnjLvcdrk1Qvj5nvXZCZ2gp0prS7it1zTJygcIY,50
+kinemotion-0.7.0.dist-info/licenses/LICENSE,sha256=KZajvqsHw0NoOHOi2q0FZ4NBe9HdV6oey-IPYAtHXfg,1088
+kinemotion-0.7.0.dist-info/RECORD,,

kinemotion-0.6.4.dist-info/RECORD

@@ -1,17 +0,0 @@
-kinemotion/__init__.py,sha256=JhS0ZTgcTdcMH5WcIyWxEqZJPOoBUSKX8tT8hsG-xWk,98
-kinemotion/cli.py,sha256=2IFA2_TE9a5zBtmGVzv5SnX39w7yPuBlw42dL7ca25U,402
-kinemotion/core/__init__.py,sha256=3yzDhb5PekDNjydqrs8aWGneUGJBt-lB0SoB_Y2FXqU,1010
-kinemotion/core/filtering.py,sha256=QtZRz8KlcLtR4dLRFH9sGqRQsUo_Dqcr1ZJIyWwPlcM,11266
-kinemotion/core/pose.py,sha256=5Dhw3LqX3STR-eLb5JAQkxhS-dd0PqGytBWnaQ66nWc,8391
-kinemotion/core/smoothing.py,sha256=z2qnpEGohDm6ZUrzqRXGLp189-NJL0ngKqYwXkU-iW0,13166
-kinemotion/core/video_io.py,sha256=LD7qmHIqUYomGxS1kxz6khugIbFo2y4tDSY7XqJQCOM,4581
-kinemotion/dropjump/__init__.py,sha256=yc1XiZ9vfo5h_n7PKVSiX2TTgaIfGL7Y7SkQtiDZj_E,838
-kinemotion/dropjump/analysis.py,sha256=5lyTJFiItqmSHw96m8HmFrl7N6nCVQZnERWU2prjn9Y,18719
-kinemotion/dropjump/cli.py,sha256=URQguQ6tmDofWagGydXzvc4NPXOCfOGX-yyFgvLV6lM,11954
-kinemotion/dropjump/debug_overlay.py,sha256=s7hwYLA2JenRYOPD2GNmx3kATFseeZT3pW8jxiVgys8,8621
-kinemotion/dropjump/kinematics.py,sha256=wcXaGUrb1kjSTus0KEwgdDzdkJRMy-umAzfStGq0_t4,16258
-kinemotion-0.6.4.dist-info/METADATA,sha256=3GyfOFp8WbHPjauu1gJ42dMNySoHfGUw5sFksrimOnY,19321
-kinemotion-0.6.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-kinemotion-0.6.4.dist-info/entry_points.txt,sha256=zaqnAnjLvcdrk1Qvj5nvXZCZ2gp0prS7it1zTJygcIY,50
-kinemotion-0.6.4.dist-info/licenses/LICENSE,sha256=KZajvqsHw0NoOHOi2q0FZ4NBe9HdV6oey-IPYAtHXfg,1088
-kinemotion-0.6.4.dist-info/RECORD,,