kinemotion 0.1.0__tar.gz → 0.4.0__tar.gz

{kinemotion-0.1.0 → kinemotion-0.4.0}/.gitignore

@@ -60,3 +60,5 @@ Thumbs.db
 *.mp4
 *.jpeg
 *.jpg
+
+.claude/settings.local.json*

{kinemotion-0.1.0 → kinemotion-0.4.0}/CLAUDE.md

@@ -4,19 +4,21 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 ## Repository Purpose
 
-Kinemetry: Video-based kinematic analysis tool for athletic performance. Analyzes drop-jump videos to estimate ground contact time, flight time, and jump height by tracking athlete's feet using MediaPipe pose tracking and advanced kinematics.
+Kinemotion: Video-based kinematic analysis tool for athletic performance. Analyzes drop-jump videos to estimate ground contact time, flight time, and jump height by tracking athlete's movement using MediaPipe pose tracking and advanced kinematics. Supports both foot-based tracking (traditional) and center of mass (CoM) tracking for improved accuracy.
 
 ## Project Setup
 
 ### Dependencies
 
 Managed with `uv` and `asdf`:
+
 - Python version: 3.12.7 (specified in `.tool-versions`)
   - **Important**: MediaPipe requires Python 3.12 or earlier (no 3.13 support yet)
 - Install dependencies: `uv sync`
-- Run CLI: `kinemetry dropjump-analyze <video.mp4>`
+- Run CLI: `kinemotion dropjump-analyze <video.mp4>`
 
 **Production dependencies:**
+
 - click: CLI framework
 - opencv-python: Video processing
 - mediapipe: Pose detection and tracking
@@ -24,6 +26,7 @@ Managed with `uv` and `asdf`:
 - scipy: Signal processing (Savitzky-Golay filter)
 
 **Development dependencies:**
+
 - pytest: Testing framework
 - black: Code formatting
 - ruff: Fast Python linter
@@ -31,64 +34,103 @@ Managed with `uv` and `asdf`:
 
 ### Development Commands
 
-- **Run tool**: `uv run kinemetry dropjump-analyze <video_path>`
+- **Run tool**: `uv run kinemotion dropjump-analyze <video_path>`
 - **Install/sync deps**: `uv sync`
 - **Run tests**: `uv run pytest`
 - **Run specific test**: `uv run pytest tests/test_aspect_ratio.py -v`
 - **Format code**: `uv run black src/`
 - **Lint code**: `uv run ruff check`
 - **Auto-fix lint issues**: `uv run ruff check --fix`
-- **Type check**: `uv run mypy src/dropjump`
-- **Run all checks**: `uv run ruff check && uv run mypy src/dropjump && uv run pytest`
+- **Type check**: `uv run mypy src/kinemotion`
+- **Run all checks**: `uv run ruff check && uv run mypy src/kinemotion && uv run pytest`
 
 ## Architecture
 
 ### Module Structure
 
-```
-src/dropjump/
-├── cli.py              # Click-based CLI entry point
-├── pose_tracker.py     # MediaPipe Pose integration
-├── smoothing.py        # Savitzky-Golay landmark smoothing
-├── contact_detection.py # Ground contact state detection
-├── kinematics.py       # Metric calculations (contact time, flight time, jump height)
-└── video_io.py         # Video processing and debug overlay rendering
+```text
+src/kinemotion/
+├── __init__.py
+├── cli.py                      # Main CLI entry point (registers subcommands)
+├── core/                       # Shared functionality across all jump types
+│   ├── __init__.py
+│   ├── pose.py                 # MediaPipe Pose integration + CoM
+│   ├── smoothing.py            # Savitzky-Golay landmark smoothing
+│   ├── filtering.py            # Outlier rejection + bilateral filtering
+│   └── video_io.py             # Video processing (VideoProcessor class)
+└── dropjump/                   # Drop jump specific analysis
+    ├── __init__.py
+    ├── cli.py                  # Drop jump CLI command (dropjump-analyze)
+    ├── analysis.py             # Ground contact state detection
+    ├── kinematics.py           # Drop jump metrics calculations
+    └── debug_overlay.py        # Debug video overlay rendering
 
 tests/
+├── test_adaptive_threshold.py  # Adaptive threshold tests
+├── test_aspect_ratio.py        # Aspect ratio preservation tests
+├── test_com_estimation.py      # Center of mass estimation tests
 ├── test_contact_detection.py  # Contact detection unit tests
+├── test_filtering.py           # Advanced filtering tests
 ├── test_kinematics.py          # Metrics calculation tests
-└── test_aspect_ratio.py        # Aspect ratio preservation tests
+└── test_polyorder.py           # Polynomial order tests
 
 docs/
-└── PARAMETERS.md       # Comprehensive guide to all CLI parameters
+├── PARAMETERS.md               # Comprehensive guide to all CLI parameters
+└── IMPLEMENTATION_PLAN.md      # Implementation plan and fix guide
 ```
 
+**Design Rationale:**
+
+- `core/` contains shared code reusable across different jump types (CMJ, squat jumps, etc.)
+- `dropjump/` contains drop jump specific logic, metrics, and CLI command
+- Each jump type module contains its own CLI command definition
+- Main `cli.py` is just an entry point that registers subcommands from each module
+- Future jump types (CMJ, squat) will be sibling modules to `dropjump/` with their own cli.py
+- Single CLI group with subcommands for different analysis types
+
+**CLI Architecture:**
+
+- `src/kinemotion/cli.py` (20 lines): Main CLI group + command registration
+- `src/kinemotion/dropjump/cli.py` (358 lines): Complete dropjump-analyze command
+- Commands registered using Click's `cli.add_command()` pattern
+- Modular design allows easy addition of new jump type analysis commands
+
 ### Analysis Pipeline
 
-1. **Pose Tracking** (pose_tracker.py): MediaPipe extracts foot landmarks (ankles, heels, foot indices) from each frame
-2. **Smoothing** (smoothing.py): Savitzky-Golay filter reduces jitter while preserving dynamics
-3. **Contact Detection** (contact_detection.py): Analyzes vertical foot velocity to classify ground contact vs. flight
-4. **Phase Identification**: Finds continuous ground contact and flight periods
+1. **Pose Tracking** (core/pose.py): MediaPipe extracts body landmarks from each frame
+   - Foot landmarks: ankles, heels, foot indices (for traditional foot-based tracking)
+   - Body landmarks: nose, shoulders, hips, knees (for CoM-based tracking)
+   - Total 13 landmarks tracked per frame
+2. **Center of Mass Estimation** (core/pose.py): Optional biomechanical CoM calculation
+   - Uses Dempster's body segment parameters for accurate weight distribution:
+     - Head: 8%, Trunk: 50%, Thighs: 20%, Legs: 10%, Feet: 3%
+   - Weighted average of segment positions for physics-based tracking
+   - More accurate than foot tracking as it tracks true body movement
+   - Reduces error from foot dorsiflexion/plantarflexion during flight
+3. **Smoothing** (core/smoothing.py): Savitzky-Golay filter reduces jitter while preserving dynamics
+4. **Contact Detection** (dropjump/analysis.py): Analyzes vertical position velocity to classify ground contact vs. flight
+   - Works with either foot positions or CoM positions
+5. **Phase Identification**: Finds continuous ground contact and flight periods
    - Automatically detects drop jumps vs regular jumps
    - For drop jumps: identifies standing on box → drop → ground contact → jump
-5. **Sub-Frame Interpolation** (contact_detection.py): Estimates exact transition times
-   - Computes velocity from Savitzky-Golay derivative (smoothing.py)
+6. **Sub-Frame Interpolation** (dropjump/analysis.py): Estimates exact transition times
+   - Computes velocity from Savitzky-Golay derivative (core/smoothing.py)
    - Linear interpolation of smooth velocity to find threshold crossings
    - Returns fractional frame indices (e.g., 48.78 instead of 49)
    - Reduces timing error from ±33ms to ±10ms at 30fps (60-70% improvement)
    - Eliminates false threshold crossings from velocity noise
-6. **Trajectory Curvature Analysis** (contact_detection.py): Refines transitions
+7. **Trajectory Curvature Analysis** (dropjump/analysis.py): Refines transitions
    - Computes acceleration (second derivative) using Savitzky-Golay filter
    - Detects landing events by acceleration spikes (impact deceleration)
    - Identifies takeoff events by acceleration changes
    - Blends curvature-based refinement with velocity-based estimates (70/30)
    - Provides independent validation based on physical motion patterns
-7. **Metrics Calculation** (kinematics.py):
+8. **Metrics Calculation** (dropjump/kinematics.py):
    - Ground contact time from phase duration (using fractional frames)
    - Flight time from phase duration (using fractional frames)
    - Jump height from position tracking with optional calibration
    - Fallback: kinematic estimate from flight time: h = (g × t²) / 8
-7. **Output**: JSON metrics + optional debug video overlay
+9. **Output**: JSON metrics + optional debug video overlay with visualizations
 
 ### Key Design Decisions
 
@@ -97,7 +139,7 @@ docs/
 - **Configurable thresholds**: CLI flags allow tuning for different video qualities and athletes
 - **Calibrated jump height**: Position-based measurement with drop height calibration for accuracy
   - Optional `--drop-height` parameter uses known drop box height to calibrate measurements
-  - Achieves ~88% accuracy (vs 71% with kinematic-only method)
+  - **⚠️ Accuracy claim unvalidated** - theoretical benefit estimated, not empirically tested
   - Fallback to empirically-corrected kinematic formula when no calibration provided
 - **Aspect ratio preservation**: Output video ALWAYS matches source video dimensions
   - Handles SAR (Sample Aspect Ratio) metadata from mobile videos
@@ -116,7 +158,7 @@ The codebase enforces strict code quality standards using multiple tools:
   - `disallow_incomplete_defs`: Partial type hints not allowed
   - `warn_return_any`: Warns on Any return types
   - Third-party stubs: Ignores missing imports for cv2, mediapipe, scipy
-- Run with: `uv run mypy src/dropjump`
+- Run with: `uv run mypy src/kinemotion`
 
 ### Linting with ruff
 
@@ -136,6 +178,7 @@ The codebase enforces strict code quality standards using multiple tools:
 ### When Contributing Code
 
 Always run before committing:
+
 ```bash
 # Format code
 uv run black src/
@@ -144,24 +187,25 @@ uv run black src/
 uv run ruff check --fix
 
 # Type check
-uv run mypy src/dropjump
+uv run mypy src/kinemotion
 
 # Run tests
 uv run pytest
 ```
 
 Or run all checks at once:
+
 ```bash
-uv run ruff check && uv run mypy src/dropjump && uv run pytest
+uv run ruff check && uv run mypy src/kinemotion && uv run pytest
 ```
 
 ## Critical Implementation Details
 
-### Aspect Ratio Preservation & SAR Handling (video_io.py)
+### Aspect Ratio Preservation & SAR Handling (core/video_io.py)
 
 **IMPORTANT**: The tool preserves the exact aspect ratio of the source video, including SAR (Sample Aspect Ratio) metadata. No dimensions are hardcoded.
 
-#### VideoProcessor (`video_io.py:15-110`)
+#### VideoProcessor (`core/video_io.py:15-110`)
 
 - Reads the **first actual frame** to get true encoded dimensions (not OpenCV properties)
 - Critical for mobile videos with rotation metadata
@@ -180,13 +224,14 @@ if ret:
 ```
 
 **Never do this:**
+
 ```python
 # Wrong - may return incorrect dimensions with rotated videos
 self.width = int(self.cap.get(cv2.CAP_PROP_FRAME_WIDTH))
 self.height = int(self.cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
 ```
 
-#### DebugOverlayRenderer (`video_io.py:130-330`)
+#### DebugOverlayRenderer (`dropjump/debug_overlay.py`)
 
 - Creates output video with **display dimensions** (respecting SAR)
 - Resizes frames from encoded dimensions to display dimensions if needed (INTER_LANCZOS4)
@@ -204,12 +249,14 @@ self.height = int(self.cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
 Instead of simple frame-to-frame differences, velocity is computed as the derivative of the smoothed position trajectory using Savitzky-Golay filter:
 
 **Advantages:**
+
 - **Smoother velocity curves**: Eliminates noise from frame-to-frame jitter
 - **More accurate threshold crossings**: Clean transitions without false positives
 - **Better interpolation**: Smoother velocity gradient for sub-frame precision
 - **Consistent with smoothing**: Uses same polynomial fit as position smoothing
 
 **Implementation:**
+
 ```python
 # OLD: Simple differences (noisy)
 velocities = np.abs(np.diff(foot_positions, prepend=foot_positions[0]))
@@ -219,6 +266,7 @@ velocities = savgol_filter(positions, window_length=5, polyorder=2, deriv=1, del
 ```
 
 **Key Function:**
+
 - `compute_velocity_from_derivative()`: Computes first derivative using Savitzky-Golay filter
 
 #### Sub-Frame Interpolation Algorithm
@@ -226,9 +274,11 @@ velocities = savgol_filter(positions, window_length=5, polyorder=2, deriv=1, del
 At 30fps, each frame represents 33.3ms. Contact events (landing, takeoff) rarely occur exactly at frame boundaries. Sub-frame interpolation estimates the exact moment between frames when velocity crosses the threshold.
 
 **Algorithm:**
+
 1. Calculate smooth velocity using derivative: `v = derivative(smooth_position)`
 2. Find frames where velocity crosses threshold (e.g., from 0.025 to 0.015, threshold 0.020)
 3. Use linear interpolation to find exact crossing point:
+
    ```python
    # If v[10] = 0.025 and v[11] = 0.015, threshold = 0.020
    t = (0.020 - 0.025) / (0.015 - 0.025) = 0.5
@@ -236,11 +286,13 @@ At 30fps, each frame represents 33.3ms. Contact events (landing, takeoff) rarely
    ```
 
 **Key Functions:**
+
 - `interpolate_threshold_crossing()`: Linear interpolation of velocity crossing
 - `find_interpolated_phase_transitions()`: Returns fractional frame indices for all phases
 
 **Accuracy Improvement:**
-```
+
+```text
 30fps without interpolation: ±33ms (1 frame on each boundary)
 30fps with interpolation:    ±10ms (sub-frame precision)
 60fps without interpolation: ±17ms
@@ -248,6 +300,7 @@ At 30fps, each frame represents 33.3ms. Contact events (landing, takeoff) rarely
 ```
 
 **Velocity Comparison:**
+
 ```python
 # Frame-to-frame differences: noisy, discontinuous jumps
 v_simple = [0.01, 0.03, 0.02, 0.04, 0.02, 0.01]  # Jittery
@@ -257,6 +310,7 @@ v_deriv = [0.015, 0.022, 0.025, 0.024, 0.018, 0.012]  # Smooth
 ```
 
 **Example:**
+
 ```python
 # Integer frames: contact from frame 49 to 53 (5 frames = 168ms at 30fps)
 # With derivative velocity: contact from 49.0 to 53.0 (4 frames = 135ms)
@@ -272,12 +326,14 @@ v_deriv = [0.015, 0.022, 0.025, 0.024, 0.018, 0.012]  # Smooth
 Acceleration (second derivative) reveals characteristic patterns at contact events:
 
 **Physical Patterns:**
+
 - **Landing impact**: Large acceleration spike as feet decelerate on impact
 - **Takeoff**: Acceleration change as body transitions from static to upward motion
 - **In flight**: Constant acceleration (gravity ≈ -9.81 m/s²)
 - **On ground**: Near-zero acceleration (stationary position)
 
 **Implementation:**
+
 ```python
 # Compute acceleration using Savitzky-Golay second derivative
 acceleration = savgol_filter(positions, window=5, polyorder=2, deriv=2, delta=1.0)
@@ -291,6 +347,7 @@ takeoff_frame = np.argmax(accel_change[search_window])
 ```
 
 **Key Functions:**
+
 - `compute_acceleration_from_derivative()`: Computes second derivative using Savitzky-Golay
 - `refine_transition_with_curvature()`: Searches for acceleration patterns near transitions
 - `find_interpolated_phase_transitions_with_curvature()`: Combines velocity + curvature
@@ -304,11 +361,13 @@ Curvature analysis refines velocity-based estimates through blending:
 3. **Blending**: 70% curvature-based + 30% velocity-based
 
 **Why Blending?**
+
 - Velocity is reliable for coarse timing
 - Curvature provides fine detail but can be noisy at boundaries
 - Blending prevents large deviations while incorporating physical insights
 
 **Algorithm:**
+
 ```python
 # 1. Get velocity-based estimate
 velocity_estimate = 49.0  # from interpolation
@@ -323,6 +382,7 @@ blend = 0.7 * 47.2 + 0.3 * 49.0  # = 47.74
 ```
 
 **Accuracy Improvement:**
+
 ```python
 # Example: Landing detection
 # Velocity only: frame 49.0 (when velocity drops below threshold)
@@ -331,6 +391,7 @@ blend = 0.7 * 47.2 + 0.3 * 49.0  # = 47.74
 ```
 
 **Optional Feature:**
+
 - Enabled by default (`--use-curvature`, default: True)
 - Can be disabled with `--no-curvature` flag for pure velocity-based detection
 - Negligible performance impact (reuses smoothed trajectory)
@@ -348,12 +409,13 @@ Always convert to Python `int()` in `to_dict()` method:
 ```
 
 **Never do this:**
+
 ```python
 # Wrong - will fail with "Object of type int64 is not JSON serializable"
 "contact_start_frame": self.contact_start_frame
 ```
 
-### Video Codec Handling (video_io.py:78-94)
+### Video Codec Handling (dropjump/debug_overlay.py)
 
 - Primary codec: H.264 (avc1) - better quality, smaller file size
 - Fallback codec: MPEG-4 (mp4v) - broader compatibility
@@ -367,6 +429,7 @@ OpenCV and NumPy use different dimension ordering:
 - **OpenCV VideoWriter size**: `(width, height)` tuple
 
 Example:
+
 ```python
 frame.shape           # (1080, 1920, 3)  - height first
 cv2.VideoWriter(..., (1920, 1080))      # width first
@@ -378,39 +441,46 @@ Always be careful with dimension ordering to avoid squashed/stretched videos.
 
 ### Adding New Metrics
 
-1. Update `DropJumpMetrics` class in `kinematics.py:10-19`
+1. Update `DropJumpMetrics` class in `dropjump/kinematics.py:10-19`
 2. Add calculation logic in `calculate_drop_jump_metrics()` function
 3. Update `to_dict()` method for JSON serialization (remember to convert NumPy types to Python types)
-4. Optionally add visualization in `DebugOverlayRenderer.render_frame()` in `video_io.py:96`
+4. Optionally add visualization in `DebugOverlayRenderer.render_frame()` in `dropjump/debug_overlay.py`
 5. Add tests in `tests/test_kinematics.py`
 
 ### Modifying Contact Detection Logic
 
-Edit `detect_ground_contact()` in `contact_detection.py:14`. Key parameters:
+Edit `detect_ground_contact()` in `dropjump/analysis.py:14`. Key parameters:
+
 - `velocity_threshold`: Tune for different surface/athlete combinations (default: 0.02)
 - `min_contact_frames`: Adjust for frame rate and contact duration expectations (default: 3)
 - `visibility_threshold`: Minimum landmark visibility score (default: 0.5)
 
 ### Adjusting Smoothing
 
-Modify `smooth_landmarks()` in `smoothing.py:9`:
+Modify `smooth_landmarks()` in `core/smoothing.py:9`:
+
 - `window_length`: Controls smoothing strength (must be odd, default: 5)
 - `polyorder`: Polynomial order for Savitzky-Golay filter (default: 2)
 
 ### Parameter Tuning
 
-**IMPORTANT**: See `docs/PARAMETERS.md` for comprehensive guide on all 7 CLI parameters.
+**IMPORTANT**: See `docs/PARAMETERS.md` for comprehensive guide on all CLI parameters.
+
+Quick reference for `dropjump-analyze`:
 
-Quick reference:
 - **smoothing-window**: Trajectory smoothness (↑ for noisy video)
 - **velocity-threshold**: Contact sensitivity (↓ to detect brief contacts)
 - **min-contact-frames**: Temporal filter (↑ to remove false contacts)
-- **visibility-threshold**: Landmark confidence (↓ for occluded feet)
+- **visibility-threshold**: Landmark confidence (↓ for occluded landmarks)
 - **detection-confidence**: Pose detection strictness (MediaPipe)
 - **tracking-confidence**: Tracking persistence (MediaPipe)
 - **drop-height**: Drop box height in meters for calibration (e.g., 0.40 for 40cm)
+- **use-curvature**: Enable trajectory curvature analysis (default: enabled)
+
+**Note**: Drop jump analysis always uses foot-based tracking with fixed velocity thresholds because typical drop jump videos are ~3 seconds long without a stationary baseline period. The `--use-com` and `--adaptive-threshold` options (available in `core/` modules) require longer videos (~5+ seconds) with 3 seconds of standing baseline, making them suitable for future jump types like CMJ (countermovement jump) but not drop jumps.
 
 The detailed guide includes:
+
 - How each parameter works internally
 - Frame rate considerations
 - Scenario-based recommended settings
@@ -420,6 +490,7 @@ The detailed guide includes:
 ### Working with Different Video Formats
 
 The tool handles various video formats and aspect ratios:
+
 - 16:9 landscape (1920x1080)
 - 4:3 standard (640x480)
 - 9:16 portrait (1080x1920)
@@ -448,14 +519,17 @@ uv run pytest -v
 
 - **Aspect ratio preservation**: 4 tests covering 16:9, 4:3, 9:16, and validation
 - **Contact detection**: 3 tests for ground contact detection and phase identification
+- **Center of mass estimation**: 6 tests for CoM calculation, biomechanical weights, and fallback behavior
+- **Adaptive thresholding**: 10 tests for auto-calibration, noise adaptation, bounds checking, and edge cases
 - **Kinematics**: 2 tests for metrics calculation and JSON serialization
 
 ### Code Quality
 
 All code passes:
+
 - ✅ **Type checking**: Full mypy strict mode compliance
 - ✅ **Linting**: ruff checks with comprehensive rule sets
-- ✅ **Tests**: 9/9 tests passing
+- ✅ **Tests**: 25/25 tests passing
 - ✅ **Formatting**: Black code style
 
 ## Troubleshooting
@@ -468,6 +542,7 @@ All code passes:
 ### Video Dimension Issues
 
 If output video has wrong aspect ratio:
+
 1. Check `VideoProcessor` is reading first frame correctly
 2. Verify `DebugOverlayRenderer` receives correct width/height from `VideoProcessor`
 3. Check that `write_frame()` validation is enabled (should raise error if dimensions mismatch)
@@ -476,6 +551,7 @@ If output video has wrong aspect ratio:
 ### JSON Serialization Errors
 
 If you see "Object of type X is not JSON serializable":
+
 1. Check `kinematics.py` `to_dict()` method
 2. Ensure all NumPy types are converted to Python types with `int()` or `float()`
 3. Run `tests/test_kinematics.py::test_metrics_to_dict` to verify
@@ -483,6 +559,7 @@ If you see "Object of type X is not JSON serializable":
 ### Video Codec Issues
 
 If output video won't play:
+
 1. Try different output format: `.avi` instead of `.mp4`
 2. Check OpenCV codec support: `cv2.getBuildInformation()`
 3. DebugOverlayRenderer will fallback from H.264 to MPEG-4 automatically
@@ -490,48 +567,49 @@ If output video won't play:
 ### Type Checking Issues
 
 If mypy reports errors:
+
 1. Ensure all function signatures have complete type annotations (parameters and return types)
 2. For numpy types, use explicit casts: `int()`, `float()` when converting to Python types
 3. For third-party libraries without stubs (cv2, mediapipe, scipy), use `# type: ignore` comments sparingly
 4. Check `pyproject.toml` under `[tool.mypy]` for configuration
-5. Run `uv run mypy src/dropjump` to verify fixes
+5. Run `uv run mypy src/kinemotion` to verify fixes
 
 ## CLI Usage Examples
 
 ```bash
 # Show main command help
-uv run kinemetry --help
+uv run kinemotion --help
 
 # Show subcommand help
-uv run kinemetry dropjump-analyze --help
+uv run kinemotion dropjump-analyze --help
 
 # Basic analysis (JSON to stdout)
-uv run kinemetry dropjump-analyze video.mp4
+uv run kinemotion dropjump-analyze video.mp4
 
 # Save metrics to file
-uv run kinemetry dropjump-analyze video.mp4 --json-output results.json
+uv run kinemotion dropjump-analyze video.mp4 --json-output results.json
 
 # Generate debug video
-uv run kinemetry dropjump-analyze video.mp4 --output debug.mp4
+uv run kinemotion dropjump-analyze video.mp4 --output debug.mp4
 
 # Drop jump with calibration (40cm box)
-uv run kinemetry dropjump-analyze video.mp4 --drop-height 0.40
+uv run kinemotion dropjump-analyze video.mp4 --drop-height 0.40
 
 # Custom parameters for noisy video
-uv run kinemetry dropjump-analyze video.mp4 \
+uv run kinemotion dropjump-analyze video.mp4 \
   --smoothing-window 7 \
   --velocity-threshold 0.01 \
   --min-contact-frames 5
 
 # Full analysis with calibration and all outputs
-uv run kinemetry dropjump-analyze video.mp4 \
+uv run kinemotion dropjump-analyze video.mp4 \
   --output debug.mp4 \
   --json-output metrics.json \
   --drop-height 0.40 \
   --smoothing-window 7
 
 # Regular jump (no calibration, uses corrected kinematic method)
-uv run kinemetry dropjump-analyze jump.mp4 \
+uv run kinemotion dropjump-analyze jump.mp4 \
   --output debug.mp4 \
   --json-output metrics.json
 ```
@@ -539,6 +617,7 @@ uv run kinemetry dropjump-analyze jump.mp4 \
 ## MCP Server Configuration
 
 The repository includes MCP server configuration in `.mcp.json`:
+
 - **web-search**: DuckDuckGo search via @dannyboy2042/freebird-mcp
 - **sequential**: Sequential thinking via @smithery-ai/server-sequential-thinking
 - **context7**: Library documentation via @upstash/context7-mcp