kinemotion 0.47.1__py3-none-any.whl → 0.47.2__py3-none-any.whl

kinemotion/api.py

@@ -5,12 +5,18 @@ import time
 from collections.abc import Callable
 from dataclasses import dataclass
 from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from numpy.typing import NDArray
 
 from .cmj.analysis import detect_cmj_phases
 from .cmj.debug_overlay import CMJDebugOverlayRenderer
 from .cmj.kinematics import CMJMetrics, calculate_cmj_metrics
 from .cmj.metrics_validator import CMJMetricsValidator
 from .core.auto_tuning import (
+    AnalysisParameters,
+    QualityPreset,
     analyze_video_sample,
     auto_tune_parameters,
 )
@@ -38,7 +44,7 @@ from .core.pipeline_utils import (
     process_videos_bulk_generic,
 )
 from .core.pose import PoseTracker
-from .core.quality import assess_jump_quality
+from .core.quality import QualityAssessment, assess_jump_quality
 from .core.timing import NULL_TIMER, PerformanceTimer, Timer
 from .core.video_io import VideoProcessor
 from .dropjump.analysis import (
@@ -78,6 +84,146 @@ class DropJumpVideoConfig:
     tracking_confidence: float | None = None
 
 
+def _assess_dropjump_quality(
+    vertical_positions: "NDArray",
+    visibilities: "NDArray",
+    contact_states: list,
+    fps: float,
+    timer: Timer,
+) -> tuple:
+    """Assess tracking quality and detect phases.
+
+    Returns:
+        Tuple of (quality_result, outlier_mask, phases_detected, phase_count)
+    """
+    _, outlier_mask = reject_outliers(
+        vertical_positions,
+        use_ransac=True,
+        use_median=True,
+        interpolate=False,
+    )
+
+    phases = find_contact_phases(contact_states)
+    phases_detected = len(phases) > 0
+    phase_count = len(phases)
+
+    quality_result = assess_jump_quality(
+        visibilities=visibilities,
+        positions=vertical_positions,
+        outlier_mask=outlier_mask,
+        fps=fps,
+        phases_detected=phases_detected,
+        phase_count=phase_count,
+    )
+
+    return quality_result, outlier_mask, phases_detected, phase_count
+
+
+def _build_dropjump_metadata(
+    video_path: str,
+    video: "VideoProcessor",
+    params: "AnalysisParameters",
+    quality_result: QualityAssessment,
+    drop_start_frame: int | None,
+    metrics: DropJumpMetrics,
+    processing_time: float,
+    quality_preset: "QualityPreset",
+    timer: Timer,
+) -> ResultMetadata:
+    """Build complete result metadata."""
+    drop_frame = None
+    if drop_start_frame is None and metrics.drop_start_frame is not None:
+        drop_frame = metrics.drop_start_frame
+    elif drop_start_frame is not None:
+        drop_frame = drop_start_frame
+
+    algorithm_config = AlgorithmConfig(
+        detection_method="forward_search",
+        tracking_method="mediapipe_pose",
+        model_complexity=1,
+        smoothing=SmoothingConfig(
+            window_size=params.smoothing_window,
+            polynomial_order=params.polyorder,
+            use_bilateral_filter=params.bilateral_filter,
+            use_outlier_rejection=params.outlier_rejection,
+        ),
+        detection=DetectionConfig(
+            velocity_threshold=params.velocity_threshold,
+            min_contact_frames=params.min_contact_frames,
+            visibility_threshold=params.visibility_threshold,
+            use_curvature_refinement=params.use_curvature,
+        ),
+        drop_detection=DropDetectionConfig(
+            auto_detect_drop_start=(drop_start_frame is None),
+            detected_drop_frame=drop_frame,
+            min_stationary_duration_s=0.5,
+        ),
+    )
+
+    video_info = VideoInfo(
+        source_path=video_path,
+        fps=video.fps,
+        width=video.width,
+        height=video.height,
+        duration_s=video.frame_count / video.fps,
+        frame_count=video.frame_count,
+        codec=video.codec,
+    )
+
+    stage_times = convert_timer_to_stage_names(timer.get_metrics())
+
+    processing_info = ProcessingInfo(
+        version=get_kinemotion_version(),
+        timestamp=create_timestamp(),
+        quality_preset=quality_preset.value,
+        processing_time_s=processing_time,
+        timing_breakdown=stage_times,
+    )
+
+    return ResultMetadata(
+        quality=quality_result,
+        video=video_info,
+        processing=processing_info,
+        algorithm=algorithm_config,
+    )
+
+
+def _save_dropjump_json(
+    json_output: str,
+    metrics: DropJumpMetrics,
+    timer: Timer,
+    verbose: bool,
+) -> None:
+    """Save metrics to JSON file."""
+    with timer.measure("json_serialization"):
+        output_path = Path(json_output)
+        metrics_dict = metrics.to_dict()
+        json_str = json.dumps(metrics_dict, indent=2)
+        output_path.write_text(json_str)
+
+    if verbose:
+        print(f"Metrics written to: {json_output}")
+
+
+def _print_dropjump_summary(
+    start_time: float,
+    timer: Timer,
+) -> None:
+    """Print verbose timing summary."""
+    total_time = time.time() - start_time
+    stage_times = convert_timer_to_stage_names(timer.get_metrics())
+
+    print("\n=== Timing Summary ===")
+    for stage, duration in stage_times.items():
+        percentage = (duration / total_time) * 100
+        dur_ms = duration * 1000
+        print(f"{stage:.<40} {dur_ms:>6.0f}ms ({percentage:>5.1f}%)")
+    total_ms = total_time * 1000
+    print(f"{('Total'):.>40} {total_ms:>6.0f}ms (100.0%)")
+    print()
+    print("Analysis complete!")
+
+
 def _generate_debug_video(
     output_video: str,
     frames: list,
@@ -281,65 +427,10 @@ def process_dropjump_video(
             if verbose:
                 print("Assessing tracking quality...")
             with timer.measure("quality_assessment"):
-                _, outlier_mask = reject_outliers(
-                    vertical_positions,
-                    use_ransac=True,
-                    use_median=True,
-                    interpolate=False,
-                )
-
-                phases = find_contact_phases(contact_states)
-                phases_detected = len(phases) > 0
-                phase_count = len(phases)
-
-                quality_result = assess_jump_quality(
-                    visibilities=visibilities,
-                    positions=vertical_positions,
-                    outlier_mask=outlier_mask,
-                    fps=video.fps,
-                    phases_detected=phases_detected,
-                    phase_count=phase_count,
+                quality_result, _, _, _ = _assess_dropjump_quality(
+                    vertical_positions, visibilities, contact_states, video.fps, timer
                 )
 
-            drop_frame = None
-            if drop_start_frame is None and metrics.drop_start_frame is not None:
-                drop_frame = metrics.drop_start_frame
-            elif drop_start_frame is not None:
-                drop_frame = drop_start_frame
-
-            algorithm_config = AlgorithmConfig(
-                detection_method="forward_search",
-                tracking_method="mediapipe_pose",
-                model_complexity=1,
-                smoothing=SmoothingConfig(
-                    window_size=params.smoothing_window,
-                    polynomial_order=params.polyorder,
-                    use_bilateral_filter=params.bilateral_filter,
-                    use_outlier_rejection=params.outlier_rejection,
-                ),
-                detection=DetectionConfig(
-                    velocity_threshold=params.velocity_threshold,
-                    min_contact_frames=params.min_contact_frames,
-                    visibility_threshold=params.visibility_threshold,
-                    use_curvature_refinement=params.use_curvature,
-                ),
-                drop_detection=DropDetectionConfig(
-                    auto_detect_drop_start=(drop_start_frame is None),
-                    detected_drop_frame=drop_frame,
-                    min_stationary_duration_s=0.5,
-                ),
-            )
-
-            video_info = VideoInfo(
-                source_path=video_path,
-                fps=video.fps,
-                width=video.width,
-                height=video.height,
-                duration_s=video.frame_count / video.fps,
-                frame_count=video.frame_count,
-                codec=video.codec,
-            )
-
             if verbose and quality_result.warnings:
                 print("\n⚠️  Quality Warnings:")
                 for warning in quality_result.warnings:
@@ -370,48 +461,24 @@ def process_dropjump_video(
                     print(f"  [{issue.severity.value}] {issue.metric}: {issue.message}")
 
             processing_time = time.time() - start_time
-            stage_times = convert_timer_to_stage_names(timer.get_metrics())
-
-            processing_info = ProcessingInfo(
-                version=get_kinemotion_version(),
-                timestamp=create_timestamp(),
-                quality_preset=quality_preset.value,
-                processing_time_s=processing_time,
-                timing_breakdown=stage_times,
-            )
-
-            result_metadata = ResultMetadata(
-                quality=quality_result,
-                video=video_info,
-                processing=processing_info,
-                algorithm=algorithm_config,
+            result_metadata = _build_dropjump_metadata(
+                video_path,
+                video,
+                params,
+                quality_result,
+                drop_start_frame,
+                metrics,
+                processing_time,
+                quality_preset,
+                timer,
             )
-
             metrics.result_metadata = result_metadata
 
             if json_output:
-                with timer.measure("json_serialization"):
-                    output_path = Path(json_output)
-                    metrics_dict = metrics.to_dict()
-                    json_str = json.dumps(metrics_dict, indent=2)
-                    output_path.write_text(json_str)
-
-                if verbose:
-                    print(f"Metrics written to: {json_output}")
+                _save_dropjump_json(json_output, metrics, timer, verbose)
 
             if verbose:
-                total_time = time.time() - start_time
-                stage_times_verbose = convert_timer_to_stage_names(timer.get_metrics())
-
-                print("\n=== Timing Summary ===")
-                for stage, duration in stage_times_verbose.items():
-                    percentage = (duration / total_time) * 100
-                    dur_ms = duration * 1000
-                    print(f"{stage:.<40} {dur_ms:>6.0f}ms ({percentage:>5.1f}%)")
-                total_ms = total_time * 1000
-                print(f"{('Total'):.>40} {total_ms:>6.0f}ms (100.0%)")
-                print()
-                print("Analysis complete!")
+                _print_dropjump_summary(start_time, timer)
 
             return metrics
 

kinemotion/cmj/analysis.py

@@ -480,7 +480,7 @@ def compute_average_hip_position(
 def find_standing_end(
     velocities: np.ndarray,
     lowest_point: float,
-    positions: np.ndarray | None = None,
+    _positions: np.ndarray | None = None,
     accelerations: np.ndarray | None = None,
 ) -> float | None:
     """
@@ -493,7 +493,7 @@ def find_standing_end(
     Args:
         velocities: Signed velocity array (for backward compatibility)
         lowest_point: Frame index of lowest point
-        positions: Position array (unused, kept for backward compatibility)
+        _positions: Intentionally unused - kept for backward compatibility
         accelerations: Acceleration array (if provided, uses
             acceleration-based detection)
 

kinemotion/cmj/kinematics.py

@@ -147,133 +147,219 @@ class CMJMetrics:
         return result
 
 
-def calculate_cmj_metrics(
+def _calculate_scale_factor(
     positions: NDArray[np.float64],
-    velocities: NDArray[np.float64],
-    standing_start_frame: float | None,
-    lowest_point_frame: float,
     takeoff_frame: float,
     landing_frame: float,
-    fps: float,
-    tracking_method: str = "foot",
-) -> CMJMetrics:
-    """Calculate all CMJ metrics from detected phases.
+    jump_height: float,
+) -> float:
+    """Calculate meters per normalized unit scaling factor from flight phase.
 
     Args:
-        positions: Array of vertical positions (normalized coordinates)
-        velocities: Array of vertical velocities
-        standing_start_frame: Frame where countermovement begins (fractional)
-        lowest_point_frame: Frame at lowest point (fractional)
-        takeoff_frame: Frame at takeoff (fractional)
-        landing_frame: Frame at landing (fractional)
-        fps: Video frames per second
-        tracking_method: Tracking method used ("foot" or "com")
+        positions: Array of vertical positions
+        takeoff_frame: Takeoff frame index
+        landing_frame: Landing frame index
+        jump_height: Calculated jump height in meters
 
     Returns:
-        CMJMetrics object with all calculated metrics.
+        Scale factor (meters per normalized unit)
     """
-    # Calculate flight time from takeoff to landing
-    flight_time = (landing_frame - takeoff_frame) / fps
-
-    # Calculate jump height from flight time using kinematic formula
-    # h = g * t^2 / 8 (where t is total flight time)
-    g = 9.81  # gravity in m/s^2
-    jump_height = (g * flight_time**2) / 8
-
-    # Determine scaling factor (meters per normalized unit)
-    # We use the flight phase displacement in normalized units compared to
-    # kinematic jump height
     flight_start_idx = int(takeoff_frame)
     flight_end_idx = int(landing_frame)
     flight_positions = positions[flight_start_idx:flight_end_idx]
 
-    scale_factor = 0.0
-    if len(flight_positions) > 0:
-        # Peak height is minimum y value (highest point in frame)
-        peak_flight_pos = np.min(flight_positions)
-        takeoff_pos = positions[flight_start_idx]
-        # Displacement is upward (takeoff_pos - peak_pos) because y decreases upward
-        flight_displacement = takeoff_pos - peak_flight_pos
+    if len(flight_positions) == 0:
+        return 0.0
 
-        if flight_displacement > 0.001:  # Avoid division by zero or noise
-            scale_factor = jump_height / flight_displacement
+    peak_flight_pos = np.min(flight_positions)
+    takeoff_pos = positions[flight_start_idx]
+    flight_displacement = takeoff_pos - peak_flight_pos
+
+    if flight_displacement > 0.001:
+        return jump_height / flight_displacement
+    return 0.0
 
-    # Calculate countermovement depth
-    if standing_start_frame is not None:
-        standing_position = positions[int(standing_start_frame)]
-    else:
-        # Use position at start of recording if standing not detected
-        standing_position = positions[0]
 
+def _calculate_countermovement_depth(
+    positions: NDArray[np.float64],
+    standing_start_frame: float | None,
+    lowest_point_frame: float,
+    scale_factor: float,
+) -> float:
+    """Calculate countermovement depth in meters.
+
+    Args:
+        positions: Array of vertical positions
+        standing_start_frame: Standing phase end frame (or None)
+        lowest_point_frame: Lowest point frame index
+        scale_factor: Meters per normalized unit
+
+    Returns:
+        Countermovement depth in meters
+    """
+    standing_position = (
+        positions[int(standing_start_frame)]
+        if standing_start_frame is not None
+        else positions[0]
+    )
     lowest_position = positions[int(lowest_point_frame)]
-    # Depth in normalized units
     depth_normalized = abs(standing_position - lowest_position)
-    # Convert to meters
-    countermovement_depth = depth_normalized * scale_factor
+    return depth_normalized * scale_factor
+
+
+def _calculate_phase_durations(
+    standing_start_frame: float | None,
+    lowest_point_frame: float,
+    takeoff_frame: float,
+    fps: float,
+) -> tuple[float, float, float]:
+    """Calculate phase durations in seconds.
+
+    Args:
+        standing_start_frame: Standing phase end frame (or None)
+        lowest_point_frame: Lowest point frame index
+        takeoff_frame: Takeoff frame index
+        fps: Frames per second
 
-    # Calculate phase durations
+    Returns:
+        Tuple of (eccentric_duration, concentric_duration, total_movement_time)
+    """
     if standing_start_frame is not None:
         eccentric_duration = (lowest_point_frame - standing_start_frame) / fps
         total_movement_time = (takeoff_frame - standing_start_frame) / fps
     else:
-        # If no standing phase detected, measure from start
         eccentric_duration = lowest_point_frame / fps
         total_movement_time = takeoff_frame / fps
 
     concentric_duration = (takeoff_frame - lowest_point_frame) / fps
+    return eccentric_duration, concentric_duration, total_movement_time
 
-    # Velocity scaling factor: units/frame -> meters/second
-    # v_m_s = v_units_frame * fps * scale_factor
-    velocity_scale = scale_factor * fps
 
-    # Calculate peak velocities
-    # Eccentric phase: Downward motion = Positive velocity in image coords
-    if standing_start_frame is not None:
-        eccentric_start_idx = int(standing_start_frame)
-    else:
-        eccentric_start_idx = 0
+def _calculate_peak_velocities(
+    velocities: NDArray[np.float64],
+    standing_start_frame: float | None,
+    lowest_point_frame: float,
+    takeoff_frame: float,
+    velocity_scale: float,
+) -> tuple[float, float]:
+    """Calculate peak eccentric and concentric velocities.
 
+    Args:
+        velocities: Array of velocities
+        standing_start_frame: Standing phase end frame (or None)
+        lowest_point_frame: Lowest point frame index
+        takeoff_frame: Takeoff frame index
+        velocity_scale: Velocity scaling factor
+
+    Returns:
+        Tuple of (peak_eccentric_velocity, peak_concentric_velocity)
+    """
+    eccentric_start_idx = int(standing_start_frame) if standing_start_frame else 0
     eccentric_end_idx = int(lowest_point_frame)
     eccentric_velocities = velocities[eccentric_start_idx:eccentric_end_idx]
 
+    peak_eccentric_velocity = 0.0
     if len(eccentric_velocities) > 0:
-        # Peak eccentric velocity is maximum positive value (fastest downward)
-        # We take max and ensure it's positive (it should be)
-        peak_eccentric_velocity = float(np.max(eccentric_velocities)) * velocity_scale
-        # If max is negative (weird), it means no downward motion detected
-        if peak_eccentric_velocity < 0:
-            peak_eccentric_velocity = 0.0
-    else:
-        peak_eccentric_velocity = 0.0
+        peak = float(np.max(eccentric_velocities)) * velocity_scale
+        peak_eccentric_velocity = max(0.0, peak)
 
-    # Concentric phase: Upward motion = Negative velocity in image coords
     concentric_start_idx = int(lowest_point_frame)
     concentric_end_idx = int(takeoff_frame)
     concentric_velocities = velocities[concentric_start_idx:concentric_end_idx]
 
+    peak_concentric_velocity = 0.0
     if len(concentric_velocities) > 0:
-        # Peak concentric velocity is minimum value (most negative = fastest upward)
-        # We take abs to report magnitude
         peak_concentric_velocity = (
             abs(float(np.min(concentric_velocities))) * velocity_scale
         )
-    else:
-        peak_concentric_velocity = 0.0
 
-    # Estimate transition time (amortization phase)
-    # Look for period around lowest point where velocity is near zero
-    transition_threshold = 0.005  # Very low velocity threshold
-    search_window = int(fps * 0.1)  # Search within ±100ms
+    return peak_eccentric_velocity, peak_concentric_velocity
+
+
+def _calculate_transition_time(
+    velocities: NDArray[np.float64],
+    lowest_point_frame: float,
+    fps: float,
+) -> float | None:
+    """Calculate transition/amortization time around lowest point.
+
+    Args:
+        velocities: Array of velocities
+        lowest_point_frame: Lowest point frame index
+        fps: Frames per second
+
+    Returns:
+        Transition time in seconds, or None if no transition detected
+    """
+    transition_threshold = 0.005
+    search_window = int(fps * 0.1)
 
     transition_start_idx = max(0, int(lowest_point_frame) - search_window)
     transition_end_idx = min(len(velocities), int(lowest_point_frame) + search_window)
 
-    transition_frames = 0
-    for i in range(transition_start_idx, transition_end_idx):
-        if abs(velocities[i]) < transition_threshold:
-            transition_frames += 1
+    transition_frames = sum(
+        1
+        for i in range(transition_start_idx, transition_end_idx)
+        if abs(velocities[i]) < transition_threshold
+    )
+
+    return transition_frames / fps if transition_frames > 0 else None
+
+
+def calculate_cmj_metrics(
+    positions: NDArray[np.float64],
+    velocities: NDArray[np.float64],
+    standing_start_frame: float | None,
+    lowest_point_frame: float,
+    takeoff_frame: float,
+    landing_frame: float,
+    fps: float,
+    tracking_method: str = "foot",
+) -> CMJMetrics:
+    """Calculate all CMJ metrics from detected phases.
+
+    Args:
+        positions: Array of vertical positions (normalized coordinates)
+        velocities: Array of vertical velocities
+        standing_start_frame: Frame where countermovement begins (fractional)
+        lowest_point_frame: Frame at lowest point (fractional)
+        takeoff_frame: Frame at takeoff (fractional)
+        landing_frame: Frame at landing (fractional)
+        fps: Video frames per second
+        tracking_method: Tracking method used ("foot" or "com")
+
+    Returns:
+        CMJMetrics object with all calculated metrics.
+    """
+    # Calculate jump height from flight time using kinematic formula: h = g*t²/8
+    g = 9.81
+    flight_time = (landing_frame - takeoff_frame) / fps
+    jump_height = (g * flight_time**2) / 8
+
+    # Calculate scaling factor and derived metrics
+    scale_factor = _calculate_scale_factor(
+        positions, takeoff_frame, landing_frame, jump_height
+    )
+    countermovement_depth = _calculate_countermovement_depth(
+        positions, standing_start_frame, lowest_point_frame, scale_factor
+    )
+
+    eccentric_duration, concentric_duration, total_movement_time = (
+        _calculate_phase_durations(
+            standing_start_frame, lowest_point_frame, takeoff_frame, fps
+        )
+    )
+
+    velocity_scale = scale_factor * fps
+    peak_eccentric_velocity, peak_concentric_velocity = _calculate_peak_velocities(
+        velocities,
+        standing_start_frame,
+        lowest_point_frame,
+        takeoff_frame,
+        velocity_scale,
+    )
 
-    transition_time = transition_frames / fps if transition_frames > 0 else None
+    transition_time = _calculate_transition_time(velocities, lowest_point_frame, fps)
 
     return CMJMetrics(
         jump_height=jump_height,

kinemotion/cmj/metrics_validator.py

@@ -449,7 +449,7 @@ class CMJMetricsValidator(MetricsValidator):
         # Convert ms to seconds
         flight_time = flight_time_ms / 1000.0
 
-        # h = g * t^2 / 8
+        # Calculate expected height using kinematic formula: h = g*t²/8
         g = 9.81
         expected_height = (g * flight_time**2) / 8
         error_pct = abs(jump_height - expected_height) / expected_height
@@ -483,7 +483,7 @@ class CMJMetricsValidator(MetricsValidator):
         if velocity is None or jump_height is None:
             return
 
-        # h = v^2 / (2*g)
+        # Calculate expected velocity using kinematic formula: v² = 2*g*h
         g = 9.81
         expected_velocity = (2 * g * jump_height) ** 0.5
         error_pct = abs(velocity - expected_velocity) / expected_velocity

kinemotion/core/timing.py

@@ -152,11 +152,12 @@ class NullTimer:
         The context manager protocol (__enter__/__exit__) has minimal overhead.
 
         Args:
-            name: Ignored - kept for protocol compatibility
+            name: Operation name (unused in no-op implementation)
 
         Returns:
             Singleton null context manager
         """
+        del name  # Intentionally unused - satisfies Timer protocol
         return _NULL_CONTEXT
 
     def get_metrics(self) -> dict[str, float]:

kinemotion/dropjump/validation_bounds.py

@@ -70,6 +70,59 @@ class DropJumpBounds:
     )
 
 
+def _score_jump_height(jump_height: float) -> float:
+    """Convert jump height to athlete profile score (0-4).
+
+    Args:
+        jump_height: Jump height in meters
+
+    Returns:
+        Score from 0 (elderly) to 4 (elite)
+    """
+    thresholds = [(0.25, 0), (0.35, 1), (0.50, 2), (0.70, 3)]
+    for threshold, score in thresholds:
+        if jump_height < threshold:
+            return float(score)
+    return 4.0  # Elite
+
+
+def _score_contact_time(contact_time_s: float) -> float:
+    """Convert contact time to athlete profile score (0-4).
+
+    Args:
+        contact_time_s: Ground contact time in seconds
+
+    Returns:
+        Score from 0 (elderly) to 4 (elite)
+    """
+    thresholds = [(0.60, 0), (0.50, 1), (0.45, 2), (0.40, 3)]
+    for threshold, score in thresholds:
+        if contact_time_s > threshold:
+            return float(score)
+    return 4.0  # Elite
+
+
+def _classify_combined_score(combined_score: float) -> AthleteProfile:
+    """Classify combined score into athlete profile.
+
+    Args:
+        combined_score: Weighted score from height and contact time
+
+    Returns:
+        Athlete profile classification
+    """
+    thresholds = [
+        (1.0, AthleteProfile.ELDERLY),
+        (1.7, AthleteProfile.UNTRAINED),
+        (2.7, AthleteProfile.RECREATIONAL),
+        (3.7, AthleteProfile.TRAINED),
+    ]
+    for threshold, profile in thresholds:
+        if combined_score < threshold:
+            return profile
+    return AthleteProfile.ELITE
+
+
 def estimate_athlete_profile(
     metrics: dict, gender: str | None = None
 ) -> AthleteProfile:
@@ -92,48 +145,14 @@ def estimate_athlete_profile(
     contact_time = metrics.get("data", {}).get("ground_contact_time_ms")
 
     if jump_height is None or contact_time is None:
-        return AthleteProfile.RECREATIONAL  # Default
+        return AthleteProfile.RECREATIONAL
 
-    # Convert contact_time from ms to seconds
     contact_time_s = contact_time / 1000.0
 
-    # Decision logic: Use weighted combination to avoid over-weighting single metrics
-    # Calculate profile scores based on each metric
-    height_score = 0.0
-    if jump_height < 0.25:
-        height_score = 0  # Elderly
-    elif jump_height < 0.35:
-        height_score = 1  # Untrained
-    elif jump_height < 0.50:
-        height_score = 2  # Recreational
-    elif jump_height < 0.70:
-        height_score = 3  # Trained
-    else:
-        height_score = 4  # Elite
-
-    contact_score = 0.0
-    if contact_time_s > 0.60:
-        contact_score = 0  # Elderly
-    elif contact_time_s > 0.50:
-        contact_score = 1  # Untrained
-    elif contact_time_s > 0.45:
-        contact_score = 2  # Recreational
-    elif contact_time_s > 0.40:
-        contact_score = 3  # Trained
-    else:
-        contact_score = 4  # Elite
-
-    # Weight height more heavily (70%) than contact time (30%)
+    # Calculate weighted combination: height (70%) + contact time (30%)
     # Height is more reliable indicator across populations
+    height_score = _score_jump_height(jump_height)
+    contact_score = _score_contact_time(contact_time_s)
     combined_score = (height_score * 0.70) + (contact_score * 0.30)
 
-    if combined_score < 1.0:
-        return AthleteProfile.ELDERLY
-    elif combined_score < 1.7:
-        return AthleteProfile.UNTRAINED
-    elif combined_score < 2.7:
-        return AthleteProfile.RECREATIONAL
-    elif combined_score < 3.7:
-        return AthleteProfile.TRAINED
-    else:
-        return AthleteProfile.ELITE
+    return _classify_combined_score(combined_score)

{kinemotion-0.47.1.dist-info → kinemotion-0.47.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kinemotion
-Version: 0.47.1
+Version: 0.47.2
 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.47.1.dist-info → kinemotion-0.47.2.dist-info}/RECORD

@@ -1,13 +1,13 @@
 kinemotion/__init__.py,sha256=wPItmyGJUOFM6GPRVhAEvRz0-ErI7e2qiUREYJ9EfPQ,943
-kinemotion/api.py,sha256=K3E5kEQQyPZrEWYaIczJNxxWREWfclIvQYjXcX--9-k,31185
+kinemotion/api.py,sha256=vqr3IZPQhvAMgNI0WbU295ufXRJ8-tu638KojF_upaI,32153
 kinemotion/cli.py,sha256=cqYV_7URH0JUDy1VQ_EDLv63FmNO4Ns20m6s1XAjiP4,464
 kinemotion/cmj/__init__.py,sha256=Ynv0-Oco4I3Y1Ubj25m3h9h2XFqeNwpAewXmAYOmwfU,127
-kinemotion/cmj/analysis.py,sha256=YDj7HpSCzrsw6mPtE3phDfYuAWQV0w-CCiLiQjkh3Mg,22196
+kinemotion/cmj/analysis.py,sha256=3l0vYQB9tN4HtEO2MPFHVtrdzSmXgwpCm03qzYLCF0c,22196
 kinemotion/cmj/cli.py,sha256=HpZgLWoLjcgsfOZu6EQ_26tg6QwTgFjR-Ly8WCBg24c,9904
 kinemotion/cmj/debug_overlay.py,sha256=fXmWoHhqMLGo4vTtB6Ezs3yLUDOLw63zLIgU2gFlJQU,15892
 kinemotion/cmj/joint_angles.py,sha256=HmheIEiKcQz39cRezk4h-htorOhGNPsqKIR9RsAEKts,9960
-kinemotion/cmj/kinematics.py,sha256=Lq9m9MNQxnXv31VhKmXVrlM7rRkhi8PxW50N_CC8_8Y,11860
-kinemotion/cmj/metrics_validator.py,sha256=V_fmlczYH06SBtwqESv-IfGi3wDsIy3RQbd7VwOyNo0,31359
+kinemotion/cmj/kinematics.py,sha256=Q-L8M7wG-MJ6EJTq6GO17c8sD5cb0Jg6Hc5vUZr14bA,13673
+kinemotion/cmj/metrics_validator.py,sha256=JAakR4RgNvUc7GM9Aj2TQrtatYpCCCGSzkBMXOldKjw,31455
 kinemotion/cmj/validation_bounds.py,sha256=9ZTo68fl3ooyWjXXyTMRLpK9tFANa_rQf3oHhq7iQGE,11995
 kinemotion/core/__init__.py,sha256=rBIEx9sW6E-nyVdWmoVGJYhfPikLukoDp7lxKri7RTQ,1543
 kinemotion/core/auto_tuning.py,sha256=wtCUMOhBChVJNXfEeku3GCMW4qED6MF-O_mv2sPTiVQ,11324
@@ -22,7 +22,7 @@ kinemotion/core/pipeline_utils.py,sha256=0u7o-UFZX6cOu3NaWpFmEy5ejS0WUKggZ1HSdeZ
 kinemotion/core/pose.py,sha256=z1OGuwnc-NdK6Aoc9UYCyPBzomw4eInexOWonZbsEoA,9057
 kinemotion/core/quality.py,sha256=dPGQp08y8DdEUbUdjTThnUOUsALgF0D2sdz50cm6wLI,13098
 kinemotion/core/smoothing.py,sha256=FZmv3rumn0mYKU2y3JPKz46EvD8TVmQ6_GsN_Vp3BdU,15650
-kinemotion/core/timing.py,sha256=Shu9KnoX-2K7gzTQr6apIcrqFaxiONR2go6g3xE9xb8,12039
+kinemotion/core/timing.py,sha256=8DJLtyQIGA0BKT07A2b32OHi1cdGQAoX5ahjGt17vlI,12113
 kinemotion/core/validation.py,sha256=LmKfSl4Ayw3DgwKD9IrhsPdzp5ia4drLsHA2UuU1SCM,6310
 kinemotion/core/video_io.py,sha256=vCwpWnlW2y29l48dFXokdehQn42w_IQvayxbVTjpXqQ,7863
 kinemotion/dropjump/__init__.py,sha256=tC3H3BrCg8Oj-db-Vrtx4PH_llR1Ppkd5jwaOjhQcLg,862
@@ -31,10 +31,10 @@ kinemotion/dropjump/cli.py,sha256=eLIA0rnx60vqD__PinB1-5nQ8_xQUhCGplwsB0u9MgU,15
 kinemotion/dropjump/debug_overlay.py,sha256=8XVuDyZ3nuNoCYkxcUWC7wyEoHyBxx77Sb--B1KiYWw,5974
 kinemotion/dropjump/kinematics.py,sha256=PATlGaClutGKJslL-LRIXHmTsvb-xEB8PUIMScU_K4c,19849
 kinemotion/dropjump/metrics_validator.py,sha256=CrTlGup8q2kyPXtA6HNwm7_yq0AsBaDllG7RVZdXmYA,9342
-kinemotion/dropjump/validation_bounds.py,sha256=5b4I3CKPybuvrbn-nP5yCcGF_sH4Vtyw3a5AWWvWnBk,4645
+kinemotion/dropjump/validation_bounds.py,sha256=fyl04ZV7nfvHkL5eob6oEpV9Hxce6aiOWQ9pclLp7AQ,5077
 kinemotion/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kinemotion-0.47.1.dist-info/METADATA,sha256=XPL4ms0o_O4Xk9M-NC59nVWEe5UC7qPbYnUG7KBjSvU,26020
-kinemotion-0.47.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-kinemotion-0.47.1.dist-info/entry_points.txt,sha256=zaqnAnjLvcdrk1Qvj5nvXZCZ2gp0prS7it1zTJygcIY,50
-kinemotion-0.47.1.dist-info/licenses/LICENSE,sha256=KZajvqsHw0NoOHOi2q0FZ4NBe9HdV6oey-IPYAtHXfg,1088
-kinemotion-0.47.1.dist-info/RECORD,,
+kinemotion-0.47.2.dist-info/METADATA,sha256=j1rpZaKZM8ANWsND2jaj7JrDSvDfdHUiFJnn6EfqpoY,26020
+kinemotion-0.47.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+kinemotion-0.47.2.dist-info/entry_points.txt,sha256=zaqnAnjLvcdrk1Qvj5nvXZCZ2gp0prS7it1zTJygcIY,50
+kinemotion-0.47.2.dist-info/licenses/LICENSE,sha256=KZajvqsHw0NoOHOi2q0FZ4NBe9HdV6oey-IPYAtHXfg,1088
+kinemotion-0.47.2.dist-info/RECORD,,