kinemotion 0.10.0__py3-none-any.whl → 0.10.1__py3-none-any.whl

kinemotion/core/filtering.py

@@ -130,13 +130,13 @@ def remove_outliers(
     if not np.any(outlier_mask):
         return positions_clean
 
-    outlier_indices = np.where(outlier_mask)[0]
+    outlier_indices = np.nonzero(outlier_mask)[0]
 
     for idx in outlier_indices:
         if method == "interpolate":
             # Find nearest valid points before and after
-            valid_before = np.where(~outlier_mask[:idx])[0]
-            valid_after = np.where(~outlier_mask[idx + 1 :])[0]
+            valid_before = np.nonzero(~outlier_mask[:idx])[0]
+            valid_after = np.nonzero(~outlier_mask[idx + 1 :])[0]
 
             if len(valid_before) > 0 and len(valid_after) > 0:
                 # Linear interpolation between nearest valid points

kinemotion/core/pose.py

@@ -1,6 +1,5 @@
 """Pose tracking using MediaPipe Pose."""
 
-
 import cv2
 import mediapipe as mp
 import numpy as np

kinemotion/core/smoothing.py

@@ -54,7 +54,7 @@ def smooth_landmarks(
 
         for i, frame_landmarks in enumerate(landmark_sequence):
             if frame_landmarks is not None and landmark_name in frame_landmarks:
-                x, y, vis = frame_landmarks[landmark_name]
+                x, y, _ = frame_landmarks[landmark_name]  # vis not used
                 x_coords.append(x)
                 y_coords.append(y)
                 valid_frames.append(i)
@@ -287,7 +287,7 @@ def smooth_landmarks_advanced(
 
         for i, frame_landmarks in enumerate(landmark_sequence):
             if frame_landmarks is not None and landmark_name in frame_landmarks:
-                x, y, vis = frame_landmarks[landmark_name]
+                x, y, _ = frame_landmarks[landmark_name]  # vis not used
                 x_coords.append(x)
                 y_coords.append(y)
                 valid_frames.append(i)

kinemotion/dropjump/cli.py

@@ -218,7 +218,6 @@ def dropjump_analyze(
             visibility_threshold,
             detection_confidence,
             tracking_confidence,
-            verbose,
         )
     else:
         # Single video mode (original behavior)
@@ -302,7 +301,6 @@ def _process_single(
             landmarks_sequence = []
             frames = []
 
-            frame_idx = 0
             bar: Any
             with click.progressbar(
                 length=video.frame_count, label="Processing frames"
@@ -316,7 +314,6 @@ def _process_single(
                     landmarks = tracker.process_frame(frame)
                     landmarks_sequence.append(landmarks)
 
-                    frame_idx += 1
                     bar.update(1)
 
             tracker.close()
@@ -555,7 +552,6 @@ def _process_batch(
     visibility_threshold: float | None,
     detection_confidence: float | None,
     tracking_confidence: float | None,
-    verbose: bool,
 ) -> None:
     """Process multiple videos in batch mode using parallel processing."""
     click.echo(
@@ -651,19 +647,30 @@ def _process_batch(
         ]
 
         if with_gct:
-            avg_gct = sum(r.metrics.ground_contact_time * 1000 for r in with_gct) / len(
-                with_gct
-            )
+            # Type assertion: filtering ensures metrics and ground_contact_time are not None
+            avg_gct = sum(
+                r.metrics.ground_contact_time * 1000
+                for r in with_gct
+                if r.metrics and r.metrics.ground_contact_time is not None
+            ) / len(with_gct)
             click.echo(f"\nAverage ground contact time: {avg_gct:.1f} ms", err=True)
 
         if with_flight:
-            avg_flight = sum(r.metrics.flight_time * 1000 for r in with_flight) / len(
-                with_flight
-            )
+            # Type assertion: filtering ensures metrics and flight_time are not None
+            avg_flight = sum(
+                r.metrics.flight_time * 1000
+                for r in with_flight
+                if r.metrics and r.metrics.flight_time is not None
+            ) / len(with_flight)
             click.echo(f"Average flight time: {avg_flight:.1f} ms", err=True)
 
         if with_jump:
-            avg_jump = sum(r.metrics.jump_height for r in with_jump) / len(with_jump)
+            # Type assertion: filtering ensures metrics and jump_height are not None
+            avg_jump = sum(
+                r.metrics.jump_height
+                for r in with_jump
+                if r.metrics and r.metrics.jump_height is not None
+            ) / len(with_jump)
             click.echo(
                 f"Average jump height: {avg_jump:.3f} m ({avg_jump * 100:.1f} cm)",
                 err=True,

kinemotion/dropjump/debug_overlay.py

@@ -87,7 +87,7 @@ class DebugOverlayRenderer:
         if landmarks:
             if use_com:
                 # Draw center of mass position
-                com_x, com_y, com_vis = compute_center_of_mass(landmarks)
+                com_x, com_y, _ = compute_center_of_mass(landmarks)  # com_vis not used
                 px = int(com_x * self.width)
                 py = int(com_y * self.height)
 

kinemotion/dropjump/kinematics.py

@@ -147,8 +147,12 @@ def calculate_drop_jump_metrics(
             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
+    # If manually specified or auto-detected, use it; otherwise start from frame 0
+    drop_start_frame_value: int
+    if drop_start_frame is None:  # pyright: ignore[reportUnnecessaryComparison]
+        drop_start_frame_value = 0
+    else:
+        drop_start_frame_value = drop_start_frame
 
     phases = find_contact_phases(contact_states)
 
@@ -200,6 +204,10 @@ def calculate_drop_jump_metrics(
     if not ground_phases:
         return metrics
 
+    # Initialize contact variables with first ground phase as fallback
+    # (will be overridden by drop jump or regular jump detection logic)
+    contact_start, contact_end = ground_phases[0][0], ground_phases[0][1]
+
     # Detect if this is a drop jump or regular jump
     # Drop jump: first ground phase is elevated (lower y), followed by drop, then landing (higher y)
     is_drop_jump = False
@@ -393,7 +401,6 @@ def calculate_drop_jump_metrics(
 
 def estimate_jump_height_from_trajectory(
     foot_y_positions: np.ndarray,
-    contact_start: int,
     flight_start: int,
     flight_end: int,
     pixel_to_meter_ratio: float | None = None,
@@ -403,7 +410,6 @@ def estimate_jump_height_from_trajectory(
 
     Args:
         foot_y_positions: Vertical positions of feet (normalized or pixels)
-        contact_start: Frame where ground contact starts
         flight_start: Frame where flight begins
         flight_end: Frame where flight ends
         pixel_to_meter_ratio: Conversion factor from pixels to meters

{kinemotion-0.10.0.dist-info → kinemotion-0.10.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kinemotion
-Version: 0.10.0
+Version: 0.10.1
 Summary: Video-based kinematic analysis for athletic performance
 Project-URL: Homepage, https://github.com/feniix/kinemotion
 Project-URL: Repository, https://github.com/feniix/kinemotion
@@ -52,6 +52,9 @@ A video-based kinematic analysis tool for athletic performance. Analyzes side-vi
 - **Calibrated measurements** - use known drop height for theoretically improved accuracy (⚠️ accuracy claims unvalidated)
 - **JSON output** for easy integration with other tools
 - **Optional debug video** with visual overlays showing contact states and landmarks
+- **Batch processing** - CLI and Python API for parallel processing of multiple videos
+- **Python library API** - use kinemotion programmatically in your own code
+- **CSV export** - aggregated results for research and analysis
 - **Configurable parameters** for smoothing, thresholds, and detection
 
 **Note**: Drop jump analysis uses foot-based tracking with fixed velocity thresholds. Center of mass (CoM) tracking and adaptive thresholding (available in `core/` modules) require longer videos (~5+ seconds) with a 3-second standing baseline, making them unsuitable for typical drop jump videos (~3 seconds). These features may be available in future jump types like CMJ (countermovement jump).
@@ -172,18 +175,148 @@ kinemotion dropjump-analyze video.mp4 \
   --velocity-threshold 0.015
 ```
 
+### Batch Processing
+
+Process multiple videos in parallel from the command line:
+
+```bash
+# Process multiple videos with glob pattern
+kinemotion dropjump-analyze videos/*.mp4 --batch --drop-height 0.40 --workers 4
+
+# Save all results to directories
+kinemotion dropjump-analyze videos/*.mp4 --batch --drop-height 0.40 \
+  --json-output-dir results/ \
+  --output-dir debug_videos/ \
+  --csv-summary summary.csv
+
+# Multiple explicit paths (batch mode auto-enabled)
+kinemotion dropjump-analyze video1.mp4 video2.mp4 video3.mp4 --drop-height 0.40
+```
+
+**Batch options:**
+
+- `--batch`: Explicitly enable batch mode
+- `--workers <int>`: Number of parallel workers (default: 4)
+- `--output-dir <path>`: Directory for debug videos (auto-named per video)
+- `--json-output-dir <path>`: Directory for JSON metrics (auto-named per video)
+- `--csv-summary <path>`: Export aggregated results to CSV
+
+**Output example:**
+
+```text
+Batch processing 10 videos with 4 workers
+======================================================================
+
+Processing videos...
+[1/10] ✓ athlete1.mp4 (2.3s)
+[2/10] ✓ athlete2.mp4 (2.1s)
+[3/10] ✗ athlete3.mp4 (0.5s)
+    Error: No frames could be processed
+
+======================================================================
+BATCH PROCESSING SUMMARY
+======================================================================
+Total videos: 10
+Successful: 9
+Failed: 1
+
+Average ground contact time: 245.3 ms
+Average flight time: 523.7 ms
+Average jump height: 0.352 m (35.2 cm)
+```
+
+## Python API
+
+Use kinemotion as a library in your Python code for automated pipelines and custom analysis:
+
+### Single Video Processing
+
+```python
+from kinemotion import process_video
+
+# Process a single video
+metrics = process_video(
+    video_path="athlete_jump.mp4",
+    drop_height=0.40,  # 40cm drop box
+    quality="balanced",
+    verbose=True
+)
+
+# Access results
+print(f"Jump height: {metrics.jump_height:.3f} m")
+print(f"Ground contact time: {metrics.ground_contact_time * 1000:.1f} ms")
+print(f"Flight time: {metrics.flight_time * 1000:.1f} ms")
+```
+
+### Bulk Video Processing
+
+```python
+from kinemotion import VideoConfig, process_videos_bulk
+
+# Configure multiple videos
+configs = [
+    VideoConfig("video1.mp4", drop_height=0.40),
+    VideoConfig("video2.mp4", drop_height=0.30, quality="accurate"),
+    VideoConfig("video3.mp4", drop_height=0.50, output_video="debug3.mp4"),
+]
+
+# Process in parallel with 4 workers
+results = process_videos_bulk(configs, max_workers=4)
+
+# Check results
+for result in results:
+    if result.success:
+        print(f"✓ {result.video_path}: {result.metrics.jump_height:.3f} m")
+    else:
+        print(f"✗ {result.video_path}: {result.error}")
+```
+
+### Export Results to CSV
+
+```python
+import csv
+from pathlib import Path
+from kinemotion import VideoConfig, process_videos_bulk
+
+# Process directory of videos
+video_dir = Path("athlete_videos")
+configs = [
+    VideoConfig(str(v), drop_height=0.40, quality="balanced")
+    for v in video_dir.glob("*.mp4")
+]
+
+results = process_videos_bulk(configs, max_workers=4)
+
+# Export to CSV
+with open("results.csv", "w", newline="") as f:
+    writer = csv.writer(f)
+    writer.writerow(["Video", "GCT (ms)", "Flight (ms)", "Jump (m)"])
+
+    for r in results:
+        if r.success and r.metrics:
+            writer.writerow([
+                Path(r.video_path).name,
+                f"{r.metrics.ground_contact_time * 1000:.1f}" if r.metrics.ground_contact_time else "N/A",
+                f"{r.metrics.flight_time * 1000:.1f}" if r.metrics.flight_time else "N/A",
+                f"{r.metrics.jump_height:.3f}" if r.metrics.jump_height else "N/A",
+            ])
+```
+
+**See [examples/bulk/README.md](examples/bulk/README.md) for comprehensive API documentation and more examples.**
+
 ## Configuration Options
 
 ### Intelligent Auto-Tuning
 
 Kinemotion automatically optimizes parameters based on your video:
+
 - **FPS-based scaling**: 30fps, 60fps, 120fps videos use different thresholds automatically
 - **Quality-based adjustments**: Adapts smoothing based on MediaPipe tracking confidence
 - **Always enabled**: Outlier rejection, curvature analysis, drop start detection
 
 ### Required Parameters
 
-- `--drop-height <float>` **[REQUIRED]**
+- `--drop-height <float>` **\[REQUIRED\]**
   - Height of drop box/platform in meters (e.g., 0.40 for 40cm)
   - Used for accurate calibration of jump height measurements
   - Measure your box height accurately for best results
@@ -191,18 +324,22 @@ Kinemotion automatically optimizes parameters based on your video:
 ### Optional Parameters
 
 - `--quality [fast|balanced|accurate]` (default: balanced)
+
   - **fast**: Quick analysis, less precise (~50% faster)
   - **balanced**: Good accuracy/speed tradeoff (recommended)
   - **accurate**: Research-grade analysis, slower (maximum precision)
 
 - `--verbose` / `-v`
+
   - Show auto-selected parameters and analysis details
   - Useful for understanding what the tool is doing
 
 - `--output <path>` / `-o`
+
   - Generate annotated debug video with pose tracking visualization
 
 - `--json-output <path>` / `-j`
+
   - Save metrics to JSON file instead of stdout
 
 ### Expert Overrides (Rarely Needed)
@@ -271,9 +408,9 @@ The debug video includes:
 **Solutions**:
 
 1. **Check video quality**: Ensure the athlete is clearly visible in profile view
-2. **Increase smoothing**: Use `--smoothing-window 7` or higher
-3. **Adjust detection confidence**: Try `--detection-confidence 0.6` or `--tracking-confidence 0.6`
-4. **Generate debug video**: Use `--output` to visualize what's being tracked
+1. **Increase smoothing**: Use `--smoothing-window 7` or higher
+1. **Adjust detection confidence**: Try `--detection-confidence 0.6` or `--tracking-confidence 0.6`
+1. **Generate debug video**: Use `--output` to visualize what's being tracked
 
 ### No Pose Detected
 
@@ -282,9 +419,9 @@ The debug video includes:
 **Solutions**:
 
 1. **Verify video format**: OpenCV must be able to read the video
-2. **Check framing**: Ensure full body is visible in side view
-3. **Lower confidence thresholds**: Try `--detection-confidence 0.3 --tracking-confidence 0.3`
-4. **Test video playback**: Verify video opens correctly with standard video players
+1. **Check framing**: Ensure full body is visible in side view
+1. **Lower confidence thresholds**: Try `--detection-confidence 0.3 --tracking-confidence 0.3`
+1. **Test video playback**: Verify video opens correctly with standard video players
 
 ### Incorrect Contact Detection
 
@@ -293,11 +430,11 @@ The debug video includes:
 **Solutions**:
 
 1. **Generate debug video**: Visualize contact states to diagnose the issue
-2. **Adjust velocity threshold**:
+1. **Adjust velocity threshold**:
    - If missing contacts: decrease to `--velocity-threshold 0.01`
    - If false contacts: increase to `--velocity-threshold 0.03`
-3. **Adjust minimum frames**: `--min-contact-frames 5` for longer required contact
-4. **Check visibility**: Lower `--visibility-threshold 0.3` if feet are partially obscured
+1. **Adjust minimum frames**: `--min-contact-frames 5` for longer required contact
+1. **Check visibility**: Lower `--visibility-threshold 0.3` if feet are partially obscured
 
 ### Jump Height Seems Wrong
 
@@ -307,9 +444,9 @@ The debug video includes:
 
 1. **Use calibration**: For drop jumps, add `--drop-height` parameter with box height in meters (e.g., `--drop-height 0.40`)
    - Theoretically improves accuracy (⚠️ unvalidated)
-2. **Verify flight time detection**: Check `flight_start_frame` and `flight_end_frame` in JSON
-3. **Compare measurements**: JSON output includes both `jump_height_m` (primary) and `jump_height_kinematic_m` (kinematic-only)
-4. **Check for drop jump detection**: If doing a drop jump, ensure first phase is elevated enough (>5% of frame height)
+1. **Verify flight time detection**: Check `flight_start_frame` and `flight_end_frame` in JSON
+1. **Compare measurements**: JSON output includes both `jump_height_m` (primary) and `jump_height_kinematic_m` (kinematic-only)
+1. **Check for drop jump detection**: If doing a drop jump, ensure first phase is elevated enough (>5% of frame height)
 
 ### Video Codec Issues
 
@@ -318,30 +455,30 @@ The debug video includes:
 **Solutions**:
 
 1. **Install additional codecs**: Ensure OpenCV has proper video codec support
-2. **Try different output format**: Use `.avi` extension instead of `.mp4`
-3. **Check output path**: Ensure write permissions for output directory
+1. **Try different output format**: Use `.avi` extension instead of `.mp4`
+1. **Check output path**: Ensure write permissions for output directory
 
 ## How It Works
 
 1. **Pose Tracking**: MediaPipe extracts 2D pose landmarks (foot points: ankles, heels, foot indices) from each frame
-2. **Position Calculation**: Averages ankle, heel, and foot index positions to determine foot location
-3. **Smoothing**: Savitzky-Golay filter reduces tracking jitter while preserving motion dynamics
-4. **Contact Detection**: Analyzes vertical position velocity to identify ground contact vs. flight phases
-5. **Phase Identification**: Finds continuous ground contact and flight periods
+1. **Position Calculation**: Averages ankle, heel, and foot index positions to determine foot location
+1. **Smoothing**: Savitzky-Golay filter reduces tracking jitter while preserving motion dynamics
+1. **Contact Detection**: Analyzes vertical position velocity to identify ground contact vs. flight phases
+1. **Phase Identification**: Finds continuous ground contact and flight periods
    - Automatically detects drop jumps vs regular jumps
    - For drop jumps: identifies box → drop → ground contact → jump sequence
-6. **Sub-Frame Interpolation**: Estimates exact transition times between frames
+1. **Sub-Frame Interpolation**: Estimates exact transition times between frames
    - Uses Savitzky-Golay derivative for smooth velocity calculation
    - Linear interpolation of velocity to find threshold crossings
    - Achieves sub-millisecond timing precision (at 30fps: ±10ms vs ±33ms)
    - Reduces timing error by 60-70% for contact and flight measurements
    - Smoother velocity curves eliminate false threshold crossings
-7. **Trajectory Curvature Analysis**: Refines transitions using acceleration patterns
+1. **Trajectory Curvature Analysis**: Refines transitions using acceleration patterns
    - Computes second derivative (acceleration) from position trajectory
    - Detects landing impact by acceleration spike
    - Identifies takeoff by acceleration change patterns
    - Provides independent validation and refinement of velocity-based detection
-8. **Metric Calculation**:
+1. **Metric Calculation**:
    - Ground contact time = contact phase duration (using fractional frames)
    - Flight time = flight phase duration (using fractional frames)
    - Jump height = calibrated position-based measurement (if --drop-height provided)
@@ -356,7 +493,8 @@ This project enforces strict code quality standards:
 - **Type safety**: Full mypy strict mode compliance with complete type annotations
 - **Linting**: Comprehensive ruff checks (pycodestyle, pyflakes, isort, pep8-naming, etc.)
 - **Formatting**: Black code style
-- **Testing**: pytest with 25 unit tests
+- **Testing**: pytest with 61 unit tests
+- **PEP 561 compliant**: Includes py.typed marker for type checking support
 
 ### Development Commands
 
@@ -391,9 +529,9 @@ uv run ruff check && uv run mypy src/dropjump && uv run pytest
 Before committing code, ensure all checks pass:
 
 1. Format with Black
-2. Fix linting issues with ruff
-3. Ensure type safety with mypy
-4. Run all tests with pytest
+1. Fix linting issues with ruff
+1. Ensure type safety with mypy
+1. Run all tests with pytest
 
 See [CLAUDE.md](CLAUDE.md) for detailed development guidelines.
 
@@ -414,9 +552,7 @@ See [CLAUDE.md](CLAUDE.md) for detailed development guidelines.
 - Advanced camera calibration (intrinsic parameters, lens distortion)
 - Multi-angle analysis support
 - Automatic camera orientation detection
-- Batch processing for multiple videos
 - Real-time analysis from webcam
-- Export to CSV/Excel formats
 - Comparison with reference values
 - Force plate integration for validation
 

kinemotion-0.10.1.dist-info/RECORD

@@ -0,0 +1,20 @@
+kinemotion/__init__.py,sha256=Z85xg29NA-r4IjrSbAkJpMFigyxACFGUb-37AiMp6YY,350
+kinemotion/api.py,sha256=3Hswx5lfyWc-EanS6iV-4MPUa_uB5t8BpGe4EB4gIIQ,15453
+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=f-m-aA59e4WqE6u-9MA51wssu7rI-Y_7n1cG8IWdeRQ,11241
+kinemotion/core/pose.py,sha256=Wfd1RR-2ZznYpWeQUbySwcV3mvReqn8n3XO6S7pGq4M,8390
+kinemotion/core/smoothing.py,sha256=FON4qKtsSp1-03GnJrDkEUAePaACn4QPMJF0eTIYqR0,12925
+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=GuVOc3cWeZ3FjNrf-28DdA-xkLuxwyNVquX3AbiLtE0,26208
+kinemotion/dropjump/debug_overlay.py,sha256=GMo-jCl5OPIv82uPxDbBVI7CsAMwATTvxZMeWfs8k8M,8701
+kinemotion/dropjump/kinematics.py,sha256=4G_7_KWnXiT09G9BduQNIgFtxvwjo2RyH1sP9SU3hSE,17949
+kinemotion/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kinemotion-0.10.1.dist-info/METADATA,sha256=6PtvHfOyoKCqyAH6UO4YAjmZhq4xk-WlK_XaU49PCB8,20333
+kinemotion-0.10.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+kinemotion-0.10.1.dist-info/entry_points.txt,sha256=zaqnAnjLvcdrk1Qvj5nvXZCZ2gp0prS7it1zTJygcIY,50
+kinemotion-0.10.1.dist-info/licenses/LICENSE,sha256=KZajvqsHw0NoOHOi2q0FZ4NBe9HdV6oey-IPYAtHXfg,1088
+kinemotion-0.10.1.dist-info/RECORD,,

kinemotion-0.10.0.dist-info/RECORD

@@ -1,20 +0,0 @@
-kinemotion/__init__.py,sha256=Z85xg29NA-r4IjrSbAkJpMFigyxACFGUb-37AiMp6YY,350
-kinemotion/api.py,sha256=3Hswx5lfyWc-EanS6iV-4MPUa_uB5t8BpGe4EB4gIIQ,15453
-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=Wc0Z3w8RBaozEQ-Oc8_zTIUrfsgRwhD97kH4P8ZozzQ,25759
-kinemotion/dropjump/debug_overlay.py,sha256=hmEtadqYP8K-kGr_Q03KDQyl1152-YSPeRJzEXMyuhs,8687
-kinemotion/dropjump/kinematics.py,sha256=RceIH2HndpHQpcOQd56MmEdXQNEst-CWXfBKPJk2g3Y,17659
-kinemotion/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kinemotion-0.10.0.dist-info/METADATA,sha256=mwCvLjVVaKjlIptGUxPKeQD5BH6IAs5luVm7OIUd1SU,16319
-kinemotion-0.10.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-kinemotion-0.10.0.dist-info/entry_points.txt,sha256=zaqnAnjLvcdrk1Qvj5nvXZCZ2gp0prS7it1zTJygcIY,50
-kinemotion-0.10.0.dist-info/licenses/LICENSE,sha256=KZajvqsHw0NoOHOi2q0FZ4NBe9HdV6oey-IPYAtHXfg,1088
-kinemotion-0.10.0.dist-info/RECORD,,