kinemotion 0.11.6__tar.gz → 0.12.0__tar.gz

{kinemotion-0.11.6 → kinemotion-0.12.0}/.pre-commit-config.yaml

@@ -39,7 +39,7 @@ repos:
         additional_dependencies:
           - mdformat-gfm>=0.3.5  # GitHub Flavored Markdown
           - mdformat-tables  # Table formatting
-        exclude: ^CLAUDE\.md$
+        exclude: (^CLAUDE\.md$|^CHANGELOG\.md$)
 
   - repo: https://github.com/compilerla/conventional-pre-commit
     rev: v4.3.0

{kinemotion-0.11.6 → kinemotion-0.12.0}/CHANGELOG.md

@@ -7,6 +7,48 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 <!-- version list -->
 
+## v0.12.0 (2025-11-06)
+
+### Documentation
+
+- Update claude.md
+  ([`b4d93d9`](https://github.com/feniix/kinemotion/commit/b4d93d94259fbfe86101c256910fcfc07c8dfcc2))
+
+### Features
+
+- **dropjump**: Calculate jump height from flight time like CMJ
+  ([`f7d96a2`](https://github.com/feniix/kinemotion/commit/f7d96a253b287d58215fd64bd1e598784cb098f4))
+
+- **dropjump**: Improve landing detection with position stabilization
+  ([`6d19938`](https://github.com/feniix/kinemotion/commit/6d199382485a80a975911c51444b2c18aa32c428))
+
+### Refactoring
+
+- **core**: Remove unused code and fix vulture warnings
+  ([`16328e2`](https://github.com/feniix/kinemotion/commit/16328e299a0e15f7f0f0e87d133e1f662dc59d0b))
+
+- **core**: Rename AutoTunedParams to AnalysisParameters for consistency
+  ([`2b6e59b`](https://github.com/feniix/kinemotion/commit/2b6e59b832769224b600e23bf4141af5d6159169))
+
+### Testing
+
+- Update tests for kinematic-based height calculation
+  ([`308469e`](https://github.com/feniix/kinemotion/commit/308469e978c53a971a4a20352cfffd72a3c9e6cd))
+
+
+## v0.11.7 (2025-11-06)
+
+### Bug Fixes
+
+- Reduce code duplication to 2.73% with shared CLI decorators
+  ([`4edbb50`](https://github.com/feniix/kinemotion/commit/4edbb50cec1e9e730a958e88aded53129f772649))
+
+### Documentation
+
+- Add code duplication guidelines to CLAUDE.md
+  ([`5294842`](https://github.com/feniix/kinemotion/commit/529484241b236ad60d7dba693afd25e8f89b6a09))
+
+
 ## v0.11.6 (2025-11-06)
 
 ### Bug Fixes

{kinemotion-0.11.6 → kinemotion-0.12.0}/CLAUDE.md

@@ -147,6 +147,31 @@ uv run pytest             # All 70 tests
 - Pyright strict mode (all functions typed)
 - Ruff (100 char lines)
 - Conventional Commits (see below)
+- **Code duplication target: < 3%**
+
+### Avoiding Code Duplication
+
+When writing new code, follow these principles to maintain low duplication:
+
+1. **Extract Common Logic**: If you find yourself copying code between modules, extract it to a shared utility
+   - Example: `core/smoothing.py` uses `_smooth_landmarks_core()` shared by both standard and advanced smoothing
+   - Example: `core/debug_overlay_utils.py` provides `BaseDebugOverlayRenderer` base class
+
+2. **Use Inheritance for Shared Behavior**: When classes share common initialization or methods
+   - Example: `DebugOverlayRenderer` and `CMJDebugOverlayRenderer` inherit from `BaseDebugOverlayRenderer`
+   - Avoids duplicating `__init__()`, `write_frame()`, `close()`, and context manager methods
+
+3. **Create Helper Functions**: Break down complex functions into smaller, reusable pieces
+   - Example: `_extract_landmark_coordinates()`, `_get_landmark_names()`, `_fill_missing_frames()`
+   - Makes code more testable and reusable
+
+4. **Use Function Composition**: Pass functions as parameters to share control flow logic
+   - Example: `_smooth_landmarks_core()` accepts a `smoother_fn` parameter
+   - Allows different smoothing strategies without duplicating iteration logic
+
+5. **Check Duplication**: Run `npx jscpd src/kinemotion` to verify duplication stays below 3%
+   - Current: 2.96% (206 duplicated lines out of 6952)
+   - Acceptable duplicates: CLI option definitions, small wrapper functions for type safety
 
 ## Quick Reference
 
@@ -229,6 +254,8 @@ chore(release): 0.11.0 [skip ci]
 feat!: change API signature for process_video
 ```
 
+**Important**: Commit messages must never reference Claude or AI assistance. Keep messages professional and focused on the technical changes.
+
 ## MCP Servers
 
 Configured in `.mcp.json`: web-search, sequential-thinking, context7, etc.

{kinemotion-0.11.6 → kinemotion-0.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kinemotion
-Version: 0.11.6
+Version: 0.12.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.11.6 → kinemotion-0.12.0}/docs/CAMERA_SETUP.md

@@ -12,7 +12,7 @@ Proper camera positioning is critical for accurate drop jump analysis. The curre
 
 ### Required Camera Position
 
-**Camera must be positioned at a side view angle, perpendicular to the sagittal plane (90°)**
+Camera must be positioned at a side view angle, perpendicular to the sagittal plane (90°).
 
 #### Camera Positioning Diagram
 

{kinemotion-0.11.6 → kinemotion-0.12.0}/docs/CAMERA_SETUP_ES.md

@@ -12,7 +12,7 @@ El posicionamiento adecuado de la cámara es crítico para un análisis preciso
 
 ### Posición Requerida de la Cámara
 
-**La cámara debe posicionarse en ángulo de vista lateral, perpendicular al plano sagital (90°)**
+La cámara debe posicionarse en ángulo de vista lateral, perpendicular al plano sagital (90°).
 
 #### Diagrama de Posicionamiento de Cámara
 

{kinemotion-0.11.6 → kinemotion-0.12.0}/docs/CMJ_GUIDE.md

@@ -61,7 +61,7 @@ print(f"Eccentric duration: {metrics.eccentric_duration*1000:.0f}ms")
 
 ### Movement Characteristics
 
-3. **Countermovement Depth** (m) - Vertical distance during eccentric phase
+1. **Countermovement Depth** (m) - Vertical distance during eccentric phase
 
    - Represents how deep the athlete squats
    - Typical range: 0.20-0.40m
@@ -90,7 +90,7 @@ print(f"Eccentric duration: {metrics.eccentric_duration*1000:.0f}ms")
 
 ### Velocity Profile
 
-8. **Peak Eccentric Velocity** (m/s) - Maximum downward speed
+1. **Peak Eccentric Velocity** (m/s) - Maximum downward speed
 
    - Indicates countermovement speed
    - Typical range: 0.5-1.5 m/s
@@ -102,10 +102,10 @@ print(f"Eccentric duration: {metrics.eccentric_duration*1000:.0f}ms")
 
 ### Triple Extension (in debug video)
 
-10. **Ankle Angle** - Dorsiflexion/plantarflexion
-01. **Knee Angle** - Flexion/extension
-01. **Hip Angle** - Flexion/extension
-01. **Trunk Tilt** - Forward/backward lean
+1. **Ankle Angle** - Dorsiflexion/plantarflexion
+1. **Knee Angle** - Flexion/extension
+1. **Hip Angle** - Flexion/extension
+1. **Trunk Tilt** - Forward/backward lean
 
 **Note**: Ankle/knee angles have limited visibility in lateral view videos (~20-30% of frames). Trunk angle is available throughout. See docs/TRIPLE_EXTENSION.md for details.
 

{kinemotion-0.11.6 → kinemotion-0.12.0}/docs/REAL_TIME_ANALYSIS.md

@@ -244,7 +244,7 @@ ______________________________________________________________________
 
 **Test video**: 236 frames @ 29.58fps
 
-```
+```text
 Processing time breakdown:
 - MediaPipe tracking: ~5-6 seconds
 - Smoothing: ~0.1 seconds
@@ -681,7 +681,7 @@ ______________________________________________________________________
 
 ## Recommendation Matrix
 
-### Choose Offline (Current) If:
+### Choose Offline (Current) If
 
 - ✅ Maximum accuracy required (research, validation)
 - ✅ Processing pre-recorded videos
@@ -689,7 +689,7 @@ ______________________________________________________________________
 - ✅ Want triple extension with full coverage
 - ✅ Publication-quality data needed
 
-### Choose Near Real-Time If:
+### Choose Near Real-Time If
 
 - ✅ Need quick results (1-2 sec acceptable)
 - ✅ Coaching/training applications
@@ -697,7 +697,7 @@ ______________________________________________________________________
 - ✅ Want to maintain accuracy
 - ✅ Building mobile/web app
 
-### Choose True Real-Time If:
+### Choose True Real-Time If
 
 - ⚠️ Instant feedback critical (\<100ms)
 - ⚠️ Interactive applications (games, VR)

{kinemotion-0.11.6 → kinemotion-0.12.0}/docs/TRIPLE_EXTENSION.md

@@ -49,7 +49,7 @@ The CMJ debug video now includes **triple extension tracking** - real-time visua
 
 **At Lowest Point (Countermovement Bottom):**
 
-```
+```text
 Ankle:  70-90°  (neutral to slight dorsiflexion)
 Knee:   90-110° (moderate squat)
 Hip:    90-110° (hip flexion)
@@ -58,7 +58,7 @@ Trunk:  0-20°   (slight forward lean)
 
 **At Takeoff (Leaving Ground):**
 
-```
+```text
 Ankle:  110-130° (strong plantarflexion)
 Knee:   160-180° (near full extension)
 Hip:    170-180° (full extension)
@@ -67,7 +67,7 @@ Trunk:  0-10°    (nearly vertical)
 
 **During Flight:**
 
-```
+```text
 All joints: ~180° (full extension)
 ```
 
@@ -139,23 +139,23 @@ All joints: ~180° (full extension)
 
 ### Poor Extension Patterns
 
-**Problem 1: Incomplete knee extension**
+#### Problem 1: Incomplete knee extension
 
-```
+```text
 Takeoff: Ankle 120°, Knee 150°, Hip 175°
 → Power leak: Not fully utilizing leg strength
 ```
 
-**Problem 2: Sequential extension (not simultaneous)**
+#### Problem 2: Sequential extension (not simultaneous)
 
-```
+```text
 Early concentric: Hip 170°, Knee 120°, Ankle 80°
 → Poor coordination: Extending in sequence instead of together
 ```
 
-**Problem 3: Excessive trunk lean**
+#### Problem 3: Excessive trunk lean
 
-```
+```text
 Takeoff: Trunk 30° forward
 → Sub-optimal: Reduces vertical force component
 ```
@@ -272,7 +272,7 @@ The triple extension feature has been tested with:
 
 **Debug video shows:**
 
-```
+```text
 Frame 140-155 (Concentric phase):
   ┌─────────────────────┐
   │ TRIPLE EXTENSION    │

{kinemotion-0.11.6 → kinemotion-0.12.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kinemotion"
-version = "0.11.6"
+version = "0.12.0"
 description = "Video-based kinematic analysis for athletic performance"
 readme = "README.md"
 requires-python = ">=3.10,<3.13"

{kinemotion-0.11.6 → kinemotion-0.12.0}/src/kinemotion/api.py

@@ -337,7 +337,6 @@ class VideoConfig:
     """Configuration for processing a single video."""
 
     video_path: str
-    drop_height: float
     quality: str = "balanced"
     output_video: str | None = None
     json_output: str | None = None
@@ -352,7 +351,6 @@ class VideoConfig:
 
 def process_video(
     video_path: str,
-    drop_height: float,
     quality: str = "balanced",
     output_video: str | None = None,
     json_output: str | None = None,
@@ -368,9 +366,10 @@ def process_video(
     """
     Process a single drop jump video and return metrics.
 
+    Jump height is calculated from flight time using kinematic formula (h = g*t²/8).
+
     Args:
         video_path: Path to the input video file
-        drop_height: Height of drop box/platform in meters (e.g., 0.40 for 40cm)
         quality: Analysis quality preset ("fast", "balanced", or "accurate")
         output_video: Optional path for debug video output
         json_output: Optional path for JSON metrics output
@@ -459,15 +458,12 @@ def process_video(
         # Calculate metrics
         if verbose:
             print("Calculating metrics...")
-            print(
-                f"Using drop height calibration: {drop_height}m ({drop_height*100:.0f}cm)"
-            )
 
         metrics = calculate_drop_jump_metrics(
             contact_states,
             vertical_positions,
             video.fps,
-            drop_height_m=drop_height,
+            drop_height_m=None,
             drop_start_frame=drop_start_frame,
             velocity_threshold=params.velocity_threshold,
             smoothing_window=params.smoothing_window,
@@ -513,9 +509,9 @@ def process_videos_bulk(
 
     Example:
         >>> 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"),
+        ...     VideoConfig("video1.mp4"),
+        ...     VideoConfig("video2.mp4", quality="accurate"),
+        ...     VideoConfig("video3.mp4", output_video="debug3.mp4"),
         ... ]
         >>> results = process_videos_bulk(configs, max_workers=4)
         >>> for result in results:
@@ -573,7 +569,6 @@ def _process_video_wrapper(config: VideoConfig) -> VideoResult:
     try:
         metrics = process_video(
             video_path=config.video_path,
-            drop_height=config.drop_height,
             quality=config.quality,
             output_video=config.output_video,
             json_output=config.json_output,

{kinemotion-0.11.6 → kinemotion-0.12.0}/src/kinemotion/cmj/cli.py

@@ -17,6 +17,7 @@ from ..core.auto_tuning import (
 )
 from ..core.cli_utils import (
     apply_expert_param_overrides,
+    common_output_options,
     determine_initial_confidence,
     print_auto_tuned_params,
     smooth_landmark_sequence,
@@ -102,18 +103,7 @@ def _process_batch_videos(
 
 @click.command(name="cmj-analyze")
 @click.argument("video_path", nargs=-1, type=click.Path(exists=False), required=True)
-@click.option(
-    "--output",
-    "-o",
-    type=click.Path(),
-    help="Path for debug video output (optional)",
-)
-@click.option(
-    "--json-output",
-    "-j",
-    type=click.Path(),
-    help="Path for JSON metrics output (default: stdout)",
-)
+@common_output_options
 @click.option(
     "--quality",
     type=click.Choice(["fast", "balanced", "accurate"], case_sensitive=False),

{kinemotion-0.11.6 → kinemotion-0.12.0}/src/kinemotion/cmj/debug_overlay.py

@@ -242,18 +242,15 @@ class CMJDebugOverlayRenderer(BaseDebugOverlayRenderer):
             y_offset += 30
 
         # Draw angle arcs at joints for visual feedback (only if angle is available)
-        if angles.get("ankle_angle") is not None:
-            self._draw_angle_arc(
-                frame, landmarks, f"{side_used}_ankle", angles["ankle_angle"]
-            )
-        if angles.get("knee_angle") is not None:
-            self._draw_angle_arc(
-                frame, landmarks, f"{side_used}_knee", angles["knee_angle"]
-            )
-        if angles.get("hip_angle") is not None:
-            self._draw_angle_arc(
-                frame, landmarks, f"{side_used}_hip", angles["hip_angle"]
-            )
+        ankle_angle = angles.get("ankle_angle")
+        if ankle_angle is not None:
+            self._draw_angle_arc(frame, landmarks, f"{side_used}_ankle", ankle_angle)
+        knee_angle = angles.get("knee_angle")
+        if knee_angle is not None:
+            self._draw_angle_arc(frame, landmarks, f"{side_used}_knee", knee_angle)
+        hip_angle = angles.get("hip_angle")
+        if hip_angle is not None:
+            self._draw_angle_arc(frame, landmarks, f"{side_used}_hip", hip_angle)
 
     def _draw_angle_arc(
         self,

{kinemotion-0.11.6 → kinemotion-0.12.0}/src/kinemotion/core/cli_utils.py

@@ -1,10 +1,11 @@
 """Shared CLI utilities for drop jump and CMJ analysis."""
 
+from collections.abc import Callable
 from typing import Any, Protocol
 
 import click
 
-from .auto_tuning import AutoTunedParams, QualityPreset, VideoCharacteristics
+from .auto_tuning import AnalysisParameters, QualityPreset, VideoCharacteristics
 from .pose import PoseTracker
 from .smoothing import smooth_landmarks, smooth_landmarks_advanced
 from .video_io import VideoProcessor
@@ -84,8 +85,8 @@ def track_all_frames(video: VideoProcessor, tracker: PoseTracker) -> tuple[list,
 
 
 def apply_expert_param_overrides(
-    params: AutoTunedParams, expert_params: ExpertParameters
-) -> AutoTunedParams:
+    params: AnalysisParameters, expert_params: ExpertParameters
+) -> AnalysisParameters:
     """Apply expert parameter overrides to auto-tuned parameters.
 
     Args:
@@ -109,7 +110,7 @@ def apply_expert_param_overrides(
 def print_auto_tuned_params(
     video: VideoProcessor,
     quality_preset: QualityPreset,
-    params: AutoTunedParams,
+    params: AnalysisParameters,
     characteristics: VideoCharacteristics | None = None,
     extra_params: dict[str, Any] | None = None,
 ) -> None:
@@ -158,7 +159,9 @@ def print_auto_tuned_params(
     click.echo("=" * 60 + "\n", err=True)
 
 
-def smooth_landmark_sequence(landmarks_sequence: list, params: AutoTunedParams) -> list:
+def smooth_landmark_sequence(
+    landmarks_sequence: list, params: AnalysisParameters
+) -> list:
     """Apply smoothing to landmark sequence.
 
     Args:
@@ -190,3 +193,22 @@ def smooth_landmark_sequence(landmarks_sequence: list, params: AutoTunedParams)
             window_length=params.smoothing_window,
             polyorder=params.polyorder,
         )
+
+
+def common_output_options(func: Callable) -> Callable:  # type: ignore[type-arg]
+    """Add common output options to CLI command."""
+    func = click.option(
+        "--output",
+        "-o",
+        type=click.Path(),
+        help="Path for debug video output (optional)",
+    )(func)
+    func = click.option(
+        "--json-output",
+        "-j",
+        type=click.Path(),
+        help="Path for JSON metrics output (default: stdout)",
+    )(func)
+    return func
+
+    return func

{kinemotion-0.11.6 → kinemotion-0.12.0}/src/kinemotion/core/debug_overlay_utils.py

@@ -48,29 +48,6 @@ def create_video_writer(
     return writer, needs_resize
 
 
-def prepare_frame_for_overlay(
-    frame: np.ndarray, needs_resize: bool, display_width: int, display_height: int
-) -> np.ndarray:
-    """
-    Prepare frame for overlay rendering by resizing if needed.
-
-    Args:
-        frame: Original video frame
-        needs_resize: Whether frame needs resizing
-        display_width: Target display width
-        display_height: Target display height
-
-    Returns:
-        Prepared frame ready for overlay
-    """
-    # Apply SAR correction if needed
-    if needs_resize:
-        frame = cv2.resize(
-            frame, (display_width, display_height), interpolation=cv2.INTER_LINEAR
-        )
-    return frame
-
-
 def write_overlay_frame(
     writer: cv2.VideoWriter, frame: np.ndarray, width: int, height: int
 ) -> None:
@@ -162,5 +139,5 @@ class BaseDebugOverlayRenderer:
     def __enter__(self) -> "BaseDebugOverlayRenderer":
         return self
 
-    def __exit__(self, exc_type, exc_val, exc_tb) -> None:  # type: ignore[no-untyped-def]
+    def __exit__(self, _exc_type, _exc_val, _exc_tb) -> None:  # type: ignore[no-untyped-def]
         self.close()

{kinemotion-0.11.6 → kinemotion-0.12.0}/src/kinemotion/core/video_io.py

@@ -151,10 +151,6 @@ class VideoProcessor:
 
         return frame
 
-    def reset(self) -> None:
-        """Reset video to beginning."""
-        self.cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
-
     def close(self) -> None:
         """Release video capture."""
         self.cap.release()
@@ -162,5 +158,5 @@ class VideoProcessor:
     def __enter__(self) -> "VideoProcessor":
         return self
 
-    def __exit__(self, exc_type, exc_val, exc_tb) -> None:  # type: ignore[no-untyped-def]
+    def __exit__(self, _exc_type, _exc_val, _exc_tb) -> None:  # type: ignore[no-untyped-def]
         self.close()

{kinemotion-0.11.6 → kinemotion-0.12.0}/src/kinemotion/dropjump/analysis.py

@@ -602,6 +602,75 @@ def find_interpolated_phase_transitions_with_curvature(
     return refined_phases
 
 
+def find_landing_from_acceleration(
+    positions: np.ndarray,
+    accelerations: np.ndarray,
+    takeoff_frame: int,
+    fps: float,
+    search_duration: float = 0.7,
+) -> int:
+    """
+    Find landing frame by detecting impact acceleration after takeoff.
+
+    Similar to CMJ landing detection, looks for maximum positive acceleration
+    (deceleration on ground impact) after the jump peak.
+
+    Args:
+        positions: Array of vertical positions (normalized 0-1)
+        accelerations: Array of accelerations (second derivative)
+        takeoff_frame: Frame at takeoff (end of ground contact)
+        fps: Video frame rate
+        search_duration: Duration in seconds to search for landing (default: 0.7s)
+
+    Returns:
+        Landing frame index (integer)
+    """
+    # Find peak height (minimum y value = highest point)
+    search_start = takeoff_frame
+    search_end = min(len(positions), takeoff_frame + int(fps * search_duration))
+
+    if search_end <= search_start:
+        return min(len(positions) - 1, takeoff_frame + int(fps * 0.3))
+
+    flight_positions = positions[search_start:search_end]
+    peak_idx = int(np.argmin(flight_positions))
+    peak_frame = search_start + peak_idx
+
+    # After peak, look for landing (impact with ground)
+    # Landing is detected by maximum positive acceleration (deceleration on impact)
+    landing_search_start = peak_frame + 2
+    landing_search_end = min(len(accelerations), landing_search_start + int(fps * 0.6))
+
+    if landing_search_end <= landing_search_start:
+        return min(len(positions) - 1, peak_frame + int(fps * 0.2))
+
+    # Find impact: maximum positive acceleration after peak
+    landing_accelerations = accelerations[landing_search_start:landing_search_end]
+    impact_idx = int(np.argmax(landing_accelerations))
+    impact_frame = landing_search_start + impact_idx
+
+    # After acceleration peak, look for position stabilization (full ground contact)
+    # Check where vertical position stops decreasing (athlete stops compressing)
+    stabilization_search_start = impact_frame
+    stabilization_search_end = min(len(positions), impact_frame + int(fps * 0.2))
+
+    landing_frame = impact_frame
+    if stabilization_search_end > stabilization_search_start + 3:
+        # Find where position reaches maximum (lowest point) and starts stabilizing
+        search_positions = positions[
+            stabilization_search_start:stabilization_search_end
+        ]
+
+        # Look for the frame where position reaches its maximum (deepest landing)
+        max_pos_idx = int(np.argmax(search_positions))
+
+        # Landing is just after max position (athlete at deepest landing compression)
+        landing_frame = stabilization_search_start + max_pos_idx
+        landing_frame = min(len(positions) - 1, landing_frame)
+
+    return landing_frame
+
+
 def compute_average_foot_position(
     landmarks: dict[str, tuple[float, float, float]],
 ) -> tuple[float, float]:

{kinemotion-0.11.6 → kinemotion-0.12.0}/src/kinemotion/dropjump/cli.py

@@ -62,15 +62,6 @@ class AnalysisParameters:
     type=click.Path(),
     help="Path for JSON metrics output (default: stdout)",
 )
-@click.option(
-    "--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(
     "--quality",
     type=click.Choice(["fast", "balanced", "accurate"], case_sensitive=False),
@@ -164,7 +155,6 @@ def dropjump_analyze(  # NOSONAR(S107) - Click CLI requires individual parameter
     video_path: tuple[str, ...],
     output: str | None,
     json_output: str | None,
-    drop_height: float,
     quality: str,
     verbose: bool,
     batch: bool,
@@ -193,15 +183,15 @@ def dropjump_analyze(  # NOSONAR(S107) - Click CLI requires individual parameter
 
     \b
     # Single video
-    kinemotion dropjump-analyze video.mp4 --drop-height 0.40
+    kinemotion dropjump-analyze video.mp4
 
     \b
     # Batch mode with glob pattern
-    kinemotion dropjump-analyze videos/*.mp4 --batch --drop-height 0.40 --workers 4
+    kinemotion dropjump-analyze videos/*.mp4 --batch --workers 4
 
     \b
     # Batch with output directories
-    kinemotion dropjump-analyze videos/*.mp4 --batch --drop-height 0.40 \\
+    kinemotion dropjump-analyze videos/*.mp4 --batch \\
         --json-output-dir results/ --csv-summary summary.csv
     """
     # Expand glob patterns and collect all video files
@@ -237,7 +227,6 @@ def dropjump_analyze(  # NOSONAR(S107) - Click CLI requires individual parameter
     if use_batch:
         _process_batch(
             video_files,
-            drop_height,
             quality,
             workers,
             output_dir,
@@ -251,7 +240,6 @@ def dropjump_analyze(  # NOSONAR(S107) - Click CLI requires individual parameter
             video_files[0],
             output,
             json_output,
-            drop_height,
             quality,
             verbose,
             expert_params,
@@ -356,7 +344,6 @@ def _process_single(
     video_path: str,
     output: str | None,
     json_output: str | None,
-    drop_height: float,
     quality: str,
     verbose: bool,
     expert_params: AnalysisParameters,
@@ -422,15 +409,11 @@ def _process_single(
 
             # Calculate metrics
             click.echo("Calculating metrics...", 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,
+                drop_height_m=None,
                 drop_start_frame=expert_params.drop_start_frame,
                 velocity_threshold=params.velocity_threshold,
                 smoothing_window=params.smoothing_window,
@@ -480,7 +463,6 @@ def _setup_batch_output_dirs(
 
 def _create_video_configs(
     video_files: list[str],
-    drop_height: float,
     quality: str,
     output_dir: str | None,
     json_output_dir: str | None,
@@ -490,7 +472,6 @@ def _create_video_configs(
 
     Args:
         video_files: List of video file paths
-        drop_height: Drop height in meters
         quality: Quality preset
         output_dir: Debug video output directory
         json_output_dir: JSON metrics output directory
@@ -513,7 +494,6 @@ def _create_video_configs(
 
         config = VideoConfig(
             video_path=video_file,
-            drop_height=drop_height,
             quality=quality,
             output_video=debug_video,
             json_output=json_file,
@@ -662,7 +642,6 @@ def _write_csv_summary(
 
 def _process_batch(
     video_files: list[str],
-    drop_height: float,
     quality: str,
     workers: int,
     output_dir: str | None,
@@ -681,7 +660,7 @@ def _process_batch(
 
     # Create video configurations
     configs = _create_video_configs(
-        video_files, drop_height, quality, output_dir, json_output_dir, expert_params
+        video_files, quality, output_dir, json_output_dir, expert_params
     )
 
     # Progress callback

{kinemotion-0.11.6 → kinemotion-0.12.0}/src/kinemotion/dropjump/kinematics.py

@@ -2,11 +2,13 @@
 
 import numpy as np
 
+from ..core.smoothing import compute_acceleration_from_derivative
 from .analysis import (
     ContactState,
     detect_drop_start,
     find_contact_phases,
     find_interpolated_phase_transitions_with_curvature,
+    find_landing_from_acceleration,
 )
 
 
@@ -123,14 +125,13 @@ def _determine_drop_start_frame(
     """
     if drop_start_frame is None:
         # Auto-detect where drop jump actually starts (skip initial stationary period)
-        detected_frame = detect_drop_start(
+        return detect_drop_start(
             foot_y_positions,
             fps,
             min_stationary_duration=0.5,
             position_change_threshold=0.005,
             smoothing_window=smoothing_window,
         )
-        return detected_frame if detected_frame is not None else 0
     return drop_start_frame
 
 
@@ -313,9 +314,14 @@ def _analyze_flight_phase(
     drop_height_m: float | None,
     scale_factor: float,
     kinematic_correction_factor: float,
+    smoothing_window: int,
+    polyorder: int,
 ) -> None:
     """Analyze flight phase and calculate jump height metrics.
 
+    Uses acceleration-based landing detection (like CMJ) for accurate flight time,
+    then calculates jump height using kinematic formula h = g*t²/8.
+
     Args:
         metrics: DropJumpMetrics object to populate
         phases: All phase tuples
@@ -323,38 +329,41 @@ def _analyze_flight_phase(
         contact_end: End of contact phase
         foot_y_positions: Vertical position array
         fps: Video frame rate
-        drop_height_m: Known drop height (optional)
+        drop_height_m: Known drop height (optional, for RSI calculation)
         scale_factor: Calibration scale factor
         kinematic_correction_factor: Correction for kinematic method
+        smoothing_window: Window size for acceleration computation
+        polyorder: Polynomial order for Savitzky-Golay filter
     """
-    # Find flight phase after ground contact
-    flight_phases = [
-        (start, end)
-        for start, end, state in phases
-        if state == ContactState.IN_AIR and start > contact_end
-    ]
+    # Find takeoff frame (end of ground contact)
+    flight_start = contact_end
 
-    if not flight_phases:
-        return
+    # Compute accelerations for landing detection
+    accelerations = compute_acceleration_from_derivative(
+        foot_y_positions, window_length=smoothing_window, polyorder=polyorder
+    )
 
-    flight_start, flight_end = flight_phases[0]
+    # Use acceleration-based landing detection (like CMJ)
+    # This finds the actual ground impact, not just when velocity drops
+    flight_end = find_landing_from_acceleration(
+        foot_y_positions, accelerations, flight_start, fps, search_duration=0.7
+    )
 
     # Store integer frame indices
     metrics.flight_start_frame = flight_start
     metrics.flight_end_frame = flight_end
 
-    # Find precise timing
+    # Find precise sub-frame timing for takeoff
     flight_start_frac = float(flight_start)
     flight_end_frac = float(flight_end)
 
     for start_frac, end_frac, state in interpolated_phases:
         if (
-            state == ContactState.IN_AIR
+            state == ContactState.ON_GROUND
             and int(start_frac) <= flight_start <= int(end_frac) + 1
-            and int(start_frac) <= flight_end <= int(end_frac) + 1
         ):
-            flight_start_frac = start_frac
-            flight_end_frac = end_frac
+            # Use end of ground contact as precise takeoff
+            flight_start_frac = end_frac
             break
 
     # Calculate flight time
@@ -363,11 +372,16 @@ def _analyze_flight_phase(
     metrics.flight_start_frame_precise = flight_start_frac
     metrics.flight_end_frame_precise = flight_end_frac
 
-    # Calculate jump height using kinematic method
+    # Calculate jump height using kinematic method (like CMJ)
+    # h = g * t² / 8
     g = 9.81  # m/s^2
     jump_height_kinematic = (g * metrics.flight_time**2) / 8
 
-    # Calculate jump height from trajectory
+    # Always use kinematic method for jump height (like CMJ)
+    metrics.jump_height = jump_height_kinematic
+    metrics.jump_height_kinematic = jump_height_kinematic
+
+    # Calculate trajectory-based height for reference
     takeoff_position = foot_y_positions[flight_start]
     flight_positions = foot_y_positions[flight_start : flight_end + 1]
 
@@ -379,21 +393,6 @@ def _analyze_flight_phase(
         height_normalized = float(takeoff_position - peak_position)
         metrics.jump_height_trajectory = height_normalized
 
-        # Choose measurement method based on calibration availability
-        if drop_height_m is not None and scale_factor > 1.0:
-            metrics.jump_height = height_normalized * scale_factor
-            metrics.jump_height_kinematic = jump_height_kinematic
-        else:
-            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:
-            metrics.jump_height = jump_height_kinematic * kinematic_correction_factor
-        else:
-            metrics.jump_height = jump_height_kinematic
-        metrics.jump_height_kinematic = jump_height_kinematic
-
 
 def calculate_drop_jump_metrics(
     contact_states: list[ContactState],
@@ -506,46 +505,8 @@ def calculate_drop_jump_metrics(
         drop_height_m,
         scale_factor,
         kinematic_correction_factor,
+        smoothing_window,
+        polyorder,
     )
 
     return metrics
-
-
-def estimate_jump_height_from_trajectory(
-    foot_y_positions: np.ndarray,
-    flight_start: int,
-    flight_end: int,
-    pixel_to_meter_ratio: float | None = None,
-) -> float:
-    """
-    Estimate jump height from position trajectory.
-
-    Args:
-        foot_y_positions: Vertical positions of feet (normalized or pixels)
-        flight_start: Frame where flight begins
-        flight_end: Frame where flight ends
-        pixel_to_meter_ratio: Conversion factor from pixels to meters
-
-    Returns:
-        Estimated jump height in meters (or normalized units if no calibration)
-    """
-    if flight_end < flight_start:
-        return 0.0
-
-    # Get position at takeoff (end of contact) and peak (minimum y during flight)
-    takeoff_position = foot_y_positions[flight_start]
-    flight_positions = foot_y_positions[flight_start : flight_end + 1]
-
-    if len(flight_positions) == 0:
-        return 0.0
-
-    peak_position = np.min(flight_positions)
-
-    # Height difference (in normalized coordinates, y increases downward)
-    height_diff = takeoff_position - peak_position
-
-    # Convert to meters if calibration available
-    if pixel_to_meter_ratio is not None:
-        return float(height_diff * pixel_to_meter_ratio)
-
-    return float(height_diff)

{kinemotion-0.11.6 → kinemotion-0.12.0}/tests/test_api.py

@@ -19,7 +19,6 @@ def test_process_video_returns_metrics(sample_video_path: str) -> None:
     """Test that process_video returns DropJumpMetrics object."""
     metrics = process_video(
         video_path=sample_video_path,
-        drop_height=0.40,
         quality="fast",  # Use fast for quicker tests
         verbose=False,
     )
@@ -37,7 +36,6 @@ def test_process_video_with_json_output(sample_video_path: str) -> None:
 
         process_video(
             video_path=sample_video_path,
-            drop_height=0.40,
             json_output=str(json_path),
             quality="fast",
         )
@@ -64,7 +62,6 @@ def test_process_video_with_debug_output(sample_video_path: str) -> None:
 
         metrics = process_video(
             video_path=sample_video_path,
-            drop_height=0.40,
             output_video=str(output_path),
             quality="fast",
         )
@@ -86,7 +83,6 @@ def test_process_video_invalid_quality(tmp_path: Path) -> None:
     with pytest.raises(ValueError, match="Invalid quality preset"):
         process_video(
             video_path=str(dummy_video),
-            drop_height=0.40,
             quality="invalid",
         )
 
@@ -96,7 +92,6 @@ def test_process_video_file_not_found() -> None:
     with pytest.raises(FileNotFoundError, match="Video file not found"):
         process_video(
             video_path="nonexistent_video.mp4",
-            drop_height=0.40,
         )
 
 
@@ -107,7 +102,6 @@ def test_process_video_quality_presets(sample_video_path: str) -> None:
     for quality in qualities:
         metrics = process_video(
             video_path=sample_video_path,
-            drop_height=0.40,
             quality=quality,
             verbose=False,
         )
@@ -121,7 +115,6 @@ def test_process_video_with_expert_overrides(sample_video_path: str) -> None:
     """Test that expert parameter overrides work."""
     metrics = process_video(
         video_path=sample_video_path,
-        drop_height=0.40,
         smoothing_window=7,
         velocity_threshold=0.025,
         min_contact_frames=5,
@@ -136,12 +129,10 @@ def test_video_config_creation() -> None:
     """Test VideoConfig dataclass creation."""
     config = VideoConfig(
         video_path="test.mp4",
-        drop_height=0.40,
         quality="balanced",
     )
 
     assert config.video_path == "test.mp4"
-    assert config.drop_height == pytest.approx(0.40)
     assert config.quality == "balanced"
     assert config.output_video is None
     assert config.json_output is None
@@ -171,8 +162,8 @@ def test_video_result_creation() -> None:
 def test_process_videos_bulk_success(sample_video_path: str) -> None:
     """Test bulk processing of multiple videos."""
     configs = [
-        VideoConfig(video_path=sample_video_path, drop_height=0.40, quality="fast"),
-        VideoConfig(video_path=sample_video_path, drop_height=0.30, quality="fast"),
+        VideoConfig(video_path=sample_video_path, quality="fast"),
+        VideoConfig(video_path=sample_video_path, quality="fast"),
     ]
 
     results = process_videos_bulk(configs, max_workers=2)
@@ -191,8 +182,12 @@ def test_process_videos_bulk_success(sample_video_path: str) -> None:
 def test_process_videos_bulk_with_failure() -> None:
     """Test bulk processing handles failures gracefully."""
     configs = [
-        VideoConfig(video_path="nonexistent1.mp4", drop_height=0.40),
-        VideoConfig(video_path="nonexistent2.mp4", drop_height=0.40),
+        VideoConfig(
+            video_path="nonexistent1.mp4",
+        ),
+        VideoConfig(
+            video_path="nonexistent2.mp4",
+        ),
     ]
 
     results = process_videos_bulk(configs, max_workers=2)
@@ -210,9 +205,11 @@ def test_process_videos_bulk_with_failure() -> None:
 def test_process_videos_bulk_mixed_results(sample_video_path: str) -> None:
     """Test bulk processing with mix of successful and failed videos."""
     configs = [
-        VideoConfig(video_path=sample_video_path, drop_height=0.40, quality="fast"),
-        VideoConfig(video_path="nonexistent.mp4", drop_height=0.40),
-        VideoConfig(video_path=sample_video_path, drop_height=0.30, quality="fast"),
+        VideoConfig(video_path=sample_video_path, quality="fast"),
+        VideoConfig(
+            video_path="nonexistent.mp4",
+        ),
+        VideoConfig(video_path=sample_video_path, quality="fast"),
     ]
 
     results = process_videos_bulk(configs, max_workers=2)
@@ -238,8 +235,8 @@ def test_process_videos_bulk_mixed_results(sample_video_path: str) -> None:
 def test_process_videos_bulk_progress_callback(sample_video_path: str) -> None:
     """Test that progress callback is called for each video."""
     configs = [
-        VideoConfig(video_path=sample_video_path, drop_height=0.40, quality="fast"),
-        VideoConfig(video_path=sample_video_path, drop_height=0.30, quality="fast"),
+        VideoConfig(video_path=sample_video_path, quality="fast"),
+        VideoConfig(video_path=sample_video_path, quality="fast"),
     ]
 
     callback_results = []
@@ -266,18 +263,15 @@ def test_process_videos_bulk_different_parameters(sample_video_path: str) -> Non
         configs = [
             VideoConfig(
                 video_path=sample_video_path,
-                drop_height=0.40,
                 quality="fast",
             ),
             VideoConfig(
                 video_path=sample_video_path,
-                drop_height=0.40,
                 quality="balanced",
                 json_output=str(Path(tmpdir) / "video2.json"),
             ),
             VideoConfig(
                 video_path=sample_video_path,
-                drop_height=0.40,
                 quality="fast",
                 smoothing_window=7,
             ),

{kinemotion-0.11.6 → kinemotion-0.12.0}/tests/test_kinematics.py

@@ -32,9 +32,10 @@ def test_calculate_metrics_basic():
     assert metrics.ground_contact_time is not None
     assert 0.25 < metrics.ground_contact_time < 0.40  # Approximately 8-12 frames
 
-    # Flight time should be approximately 20 frames / 30 fps = 0.667 seconds
+    # Flight time: acceleration-based landing detection finds impact earlier
+    # than simple phase boundary, typically 13-17 frames instead of 20
     assert metrics.flight_time is not None
-    assert 0.60 < metrics.flight_time < 0.75  # Approximately 18-22 frames
+    assert 0.35 < metrics.flight_time < 0.65  # Approximately 10-20 frames
 
     # Jump height should be calculated from flight time
     assert metrics.jump_height is not None
@@ -46,9 +47,10 @@ def test_calculate_metrics_basic():
     assert metrics.flight_start_frame_precise is not None
     assert metrics.flight_end_frame_precise is not None
 
-    # Fractional frames should be close to integer frames
-    assert abs(metrics.contact_start_frame_precise - metrics.contact_start_frame) < 1.0
-    assert abs(metrics.flight_start_frame_precise - metrics.flight_start_frame) < 1.0
+    # Fractional frames should be reasonably close to integer frames
+    # (within 2 frames due to sub-frame interpolation and phase detection)
+    assert abs(metrics.contact_start_frame_precise - metrics.contact_start_frame) < 2.0
+    assert abs(metrics.flight_start_frame_precise - metrics.flight_start_frame) < 2.0
 
 
 def test_metrics_to_dict():

{kinemotion-0.11.6 → kinemotion-0.12.0}/uv.lock

@@ -603,7 +603,7 @@ wheels = [
 
 [[package]]
 name = "kinemotion"
-version = "0.11.6"
+version = "0.12.0"
 source = { editable = "." }
 dependencies = [
     { name = "click" },