kinemotion 0.26.1__tar.gz → 0.28.0__tar.gz

{kinemotion-0.26.1 → kinemotion-0.28.0}/CHANGELOG.md

@@ -7,6 +7,22 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 <!-- version list -->
 
+## v0.28.0 (2025-11-15)
+
+### Features
+
+- Standardize numeric precision across jump types
+  ([`def84b0`](https://github.com/feniix/kinemotion/commit/def84b00ba4aef35f398ac615e328ba15e50133d))
+
+
+## v0.27.0 (2025-11-14)
+
+### Features
+
+- Extract video codec from metadata
+  ([`52c7ff2`](https://github.com/feniix/kinemotion/commit/52c7ff2ee3f6620a5271f670ab60e6bca8bc38fb))
+
+
 ## v0.26.1 (2025-11-14)
 
 ### Bug Fixes

{kinemotion-0.26.1 → kinemotion-0.28.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kinemotion
-Version: 0.26.1
+Version: 0.28.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.26.1 → kinemotion-0.28.0}/docs/reference/json-output-format.md

@@ -37,14 +37,14 @@ ______________________________________________________________________
 {
   "data": {
     "jump_height_m": 0.506,
-    "flight_time_s": 0.642,
+    "flight_time_ms": 642.0,
     "countermovement_depth_m": 0.045,
-    "eccentric_duration_s": 0.412,
-    "concentric_duration_s": 0.305,
-    "total_movement_time_s": 0.717,
+    "eccentric_duration_ms": 412.0,
+    "concentric_duration_ms": 305.0,
+    "total_movement_time_ms": 717.0,
     "peak_eccentric_velocity_m_s": -1.234,
     "peak_concentric_velocity_m_s": 2.634,
-    "transition_time_s": 0.135,
+    "transition_time_ms": 135.0,
     "standing_start_frame": 145.0,
     "lowest_point_frame": 146.0,
     "takeoff_frame": 154.3,
@@ -200,14 +200,14 @@ ______________________________________________________________________
 **CMJ-specific fields:**
 
 - `jump_height_m` (float): Maximum vertical displacement
-- `flight_time_s` (float): Time in the air
+- `flight_time_ms` (float): Time in the air in milliseconds
 - `countermovement_depth_m` (float): Depth of eccentric phase
-- `eccentric_duration_s` (float): Time from start to lowest point
-- `concentric_duration_s` (float): Time from lowest point to takeoff
-- `total_movement_time_s` (float): Total time from start to takeoff
+- `eccentric_duration_ms` (float): Time from start to lowest point in milliseconds
+- `concentric_duration_ms` (float): Time from lowest point to takeoff in milliseconds
+- `total_movement_time_ms` (float): Total time from start to takeoff in milliseconds
 - `peak_eccentric_velocity_m_s` (float): Max downward velocity (negative)
 - `peak_concentric_velocity_m_s` (float): Max upward velocity (negative in coords)
-- `transition_time_s` (float | null): Amortization phase duration
+- `transition_time_ms` (float | null): Amortization phase duration in milliseconds
 - `standing_start_frame` (float | null): Frame where movement begins
 - `lowest_point_frame` (float): Frame at deepest countermovement
 - `takeoff_frame` (float): Frame where feet leave ground
@@ -414,7 +414,7 @@ ______________________________________________________________________
 {
   "data": {
     "jump_height_m": 0.352,
-    "flight_time_s": 0.534
+    "flight_time_ms": 534.0
   },
   "metadata": {
     "quality": {

{kinemotion-0.26.1 → kinemotion-0.28.0}/docs/reference/json-structure-comparison.md

@@ -11,7 +11,7 @@ ______________________________________________________________________
 ```json
 {
   "jump_height_m": 0.352,
-  "flight_time_s": 0.534,
+  "flight_time_ms": 534.0,
   "takeoff_frame": 154.3,
   "landing_frame": 172.8,
   "confidence": "high",
@@ -121,7 +121,7 @@ ______________________________________________________________________
 ```json
 {
   "jump_height_m": 0.352,
-  "flight_time_s": 0.534,
+  "flight_time_ms": 534.0,
   "takeoff_frame": 154.3,
   "landing_frame": 172.8,
   "quality": {
@@ -185,7 +185,7 @@ ______________________________________________________________________
 class JumpData:
     """Physical measurements."""
     jump_height_m: float
-    flight_time_s: float
+    flight_time_ms: float
     ...
 
 @dataclass

{kinemotion-0.26.1 → kinemotion-0.28.0}/pyproject.toml

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

{kinemotion-0.26.1 → kinemotion-0.28.0}/src/kinemotion/api.py

@@ -532,7 +532,7 @@ def process_dropjump_video(
             height=video.height,
             duration_s=video.frame_count / video.fps,
             frame_count=video.frame_count,
-            codec=None,
+            codec=video.codec,
         )
 
         processing_info = ProcessingInfo(
@@ -973,7 +973,7 @@ def process_cmj_video(
             height=video.height,
             duration_s=video.frame_count / video.fps,
             frame_count=video.frame_count,
-            codec=None,  # TODO: Extract from video metadata if available
+            codec=video.codec,
         )
 
         processing_info = ProcessingInfo(

{kinemotion-0.26.1 → kinemotion-0.28.0}/src/kinemotion/cmj/kinematics.py

@@ -6,6 +6,8 @@ from typing import TYPE_CHECKING, TypedDict
 import numpy as np
 from numpy.typing import NDArray
 
+from ..core.formatting import format_float_metric
+
 if TYPE_CHECKING:
     from ..core.metadata import ResultMetadata
     from ..core.quality import QualityAssessment
@@ -15,14 +17,14 @@ class CMJDataDict(TypedDict, total=False):
     """Type-safe dictionary for CMJ measurement data."""
 
     jump_height_m: float
-    flight_time_s: float
+    flight_time_ms: float
     countermovement_depth_m: float
-    eccentric_duration_s: float
-    concentric_duration_s: float
-    total_movement_time_s: float
+    eccentric_duration_ms: float
+    concentric_duration_ms: float
+    total_movement_time_ms: float
     peak_eccentric_velocity_m_s: float
     peak_concentric_velocity_m_s: float
-    transition_time_s: float | None
+    transition_time_ms: float | None
     standing_start_frame: float | None
     lowest_point_frame: float
     takeoff_frame: float
@@ -43,14 +45,14 @@ class CMJMetrics:
 
     Attributes:
         jump_height: Maximum jump height in meters
-        flight_time: Time spent in the air in seconds
+        flight_time: Time spent in the air in milliseconds
         countermovement_depth: Vertical distance traveled during eccentric phase in meters
-        eccentric_duration: Time from countermovement start to lowest point in seconds
-        concentric_duration: Time from lowest point to takeoff in seconds
-        total_movement_time: Total time from countermovement start to takeoff in seconds
+        eccentric_duration: Time from countermovement start to lowest point in milliseconds
+        concentric_duration: Time from lowest point to takeoff in milliseconds
+        total_movement_time: Total time from countermovement start to takeoff in milliseconds
         peak_eccentric_velocity: Maximum downward velocity during countermovement in m/s
         peak_concentric_velocity: Maximum upward velocity during propulsion in m/s
-        transition_time: Duration at lowest point (amortization phase) in seconds
+        transition_time: Duration at lowest point (amortization phase) in milliseconds
         standing_start_frame: Frame where standing phase ends (countermovement begins)
         lowest_point_frame: Frame at lowest point of countermovement
         takeoff_frame: Frame where athlete leaves ground
@@ -85,19 +87,27 @@ class CMJMetrics:
             Dictionary with nested data and metadata structure.
         """
         data: CMJDataDict = {
-            "jump_height_m": float(self.jump_height),
-            "flight_time_s": float(self.flight_time),
-            "countermovement_depth_m": float(self.countermovement_depth),
-            "eccentric_duration_s": float(self.eccentric_duration),
-            "concentric_duration_s": float(self.concentric_duration),
-            "total_movement_time_s": float(self.total_movement_time),
-            "peak_eccentric_velocity_m_s": float(self.peak_eccentric_velocity),
-            "peak_concentric_velocity_m_s": float(self.peak_concentric_velocity),
-            "transition_time_s": (
-                float(self.transition_time)
-                if self.transition_time is not None
-                else None
-            ),
+            "jump_height_m": format_float_metric(self.jump_height, 1, 3),  # type: ignore[typeddict-item]
+            "flight_time_ms": format_float_metric(self.flight_time, 1000, 2),  # type: ignore[typeddict-item]
+            "countermovement_depth_m": format_float_metric(
+                self.countermovement_depth, 1, 3
+            ),  # type: ignore[typeddict-item]
+            "eccentric_duration_ms": format_float_metric(
+                self.eccentric_duration, 1000, 2
+            ),  # type: ignore[typeddict-item]
+            "concentric_duration_ms": format_float_metric(
+                self.concentric_duration, 1000, 2
+            ),  # type: ignore[typeddict-item]
+            "total_movement_time_ms": format_float_metric(
+                self.total_movement_time, 1000, 2
+            ),  # type: ignore[typeddict-item]
+            "peak_eccentric_velocity_m_s": format_float_metric(
+                self.peak_eccentric_velocity, 1, 4
+            ),  # type: ignore[typeddict-item]
+            "peak_concentric_velocity_m_s": format_float_metric(
+                self.peak_concentric_velocity, 1, 4
+            ),  # type: ignore[typeddict-item]
+            "transition_time_ms": format_float_metric(self.transition_time, 1000, 2),
             "standing_start_frame": (
                 float(self.standing_start_frame)
                 if self.standing_start_frame is not None

kinemotion-0.28.0/src/kinemotion/core/formatting.py

@@ -0,0 +1,75 @@
+"""Formatting utilities for consistent numeric output across jump analysis types.
+
+This module provides shared helpers for formatting numeric values with appropriate
+precision based on measurement type and capabilities of video-based analysis.
+"""
+
+# Standard precision values for different measurement types
+# These values are chosen based on:
+# - Video analysis capabilities (30-240 fps)
+# - Typical measurement uncertainty in video-based biomechanics
+# - Balance between accuracy and readability
+
+PRECISION_TIME_MS = 2  # Time in milliseconds: ±0.01ms (e.g., 534.12)
+PRECISION_DISTANCE_M = 3  # Distance in meters: ±1mm (e.g., 0.352)
+PRECISION_VELOCITY_M_S = 4  # Velocity in m/s: ±0.0001 m/s (e.g., 2.6340)
+PRECISION_FRAME = 3  # Sub-frame interpolation precision (e.g., 154.342)
+PRECISION_NORMALIZED = 4  # Normalized values 0-1 ratios (e.g., 0.0582)
+
+
+def format_float_metric(
+    value: float | None,
+    multiplier: float = 1.0,
+    decimals: int = 2,
+) -> float | None:
+    """Format a float metric value with optional scaling and rounding.
+
+    This helper ensures consistent precision across all jump analysis outputs,
+    preventing false precision in measurements while maintaining appropriate
+    accuracy for the measurement type.
+
+    Args:
+        value: The value to format, or None
+        multiplier: Factor to multiply value by (e.g., 1000 for seconds→milliseconds)
+        decimals: Number of decimal places to round to
+
+    Returns:
+        Formatted value rounded to specified decimals, or None if input is None
+
+    Examples:
+        >>> format_float_metric(0.534123, 1000, 2)  # seconds to ms
+        534.12
+        >>> format_float_metric(0.3521234, 1, 3)  # meters
+        0.352
+        >>> format_float_metric(None, 1, 2)
+        None
+        >>> format_float_metric(-1.23456, 1, 4)  # negative values preserved
+        -1.2346
+    """
+    if value is None:
+        return None
+    return round(value * multiplier, decimals)
+
+
+def format_int_metric(value: float | int | None) -> int | None:
+    """Format a value as an integer.
+
+    Used for frame numbers and other integer-valued metrics.
+
+    Args:
+        value: The value to format, or None
+
+    Returns:
+        Value converted to int, or None if input is None
+
+    Examples:
+        >>> format_int_metric(42.7)
+        42
+        >>> format_int_metric(None)
+        None
+        >>> format_int_metric(154)
+        154
+    """
+    if value is None:
+        return None
+    return int(value)

{kinemotion-0.26.1 → kinemotion-0.28.0}/src/kinemotion/core/video_io.py

@@ -50,6 +50,9 @@ class VideoProcessor:
         # OpenCV ignores rotation metadata, so we need to extract and apply it manually
         self.rotation = 0  # Will be set by _extract_video_metadata()
 
+        # Extract codec information from video metadata
+        self.codec: str | None = None  # Will be set by _extract_video_metadata()
+
         # Calculate display dimensions considering SAR (Sample Aspect Ratio)
         # Mobile videos often have non-square pixels encoded in SAR metadata
         # OpenCV doesn't directly expose SAR, but we need to handle display correctly
@@ -141,6 +144,9 @@ class VideoProcessor:
 
             stream = data["streams"][0]
 
+            # Extract codec name (e.g., "h264", "hevc", "vp9")
+            self.codec = stream.get("codec_name")
+
             # Extract and parse SAR (Sample Aspect Ratio)
             sar_str = stream.get("sample_aspect_ratio", "1:1")
             self._parse_sample_aspect_ratio(sar_str)

{kinemotion-0.26.1 → kinemotion-0.28.0}/src/kinemotion/dropjump/kinematics.py

@@ -5,6 +5,7 @@ from typing import TYPE_CHECKING, TypedDict
 import numpy as np
 from numpy.typing import NDArray
 
+from ..core.formatting import format_float_metric, format_int_metric
 from ..core.smoothing import compute_acceleration_from_derivative
 from .analysis import (
     ContactState,
@@ -19,38 +20,6 @@ if TYPE_CHECKING:
     from ..core.quality import QualityAssessment
 
 
-def _format_float_metric(
-    value: float | None, multiplier: float = 1, decimals: int = 2
-) -> float | None:
-    """Format a float metric value with optional scaling and rounding.
-
-    Args:
-        value: The value to format, or None
-        multiplier: Factor to multiply value by (default: 1)
-        decimals: Number of decimal places to round to (default: 2)
-
-    Returns:
-        Formatted value rounded to specified decimals, or None if input is None
-    """
-    if value is None:
-        return None
-    return round(value * multiplier, decimals)
-
-
-def _format_int_metric(value: float | int | None) -> int | None:
-    """Format a value as an integer.
-
-    Args:
-        value: The value to format, or None
-
-    Returns:
-        Value converted to int, or None if input is None
-    """
-    if value is None:
-        return None
-    return int(value)
-
-
 class DropJumpDataDict(TypedDict, total=False):
     """Type-safe dictionary for drop jump measurement data."""
 
@@ -108,32 +77,32 @@ class DropJumpMetrics:
             Dictionary containing formatted metric values.
         """
         return {
-            "ground_contact_time_ms": _format_float_metric(
+            "ground_contact_time_ms": format_float_metric(
                 self.ground_contact_time, 1000, 2
             ),
-            "flight_time_ms": _format_float_metric(self.flight_time, 1000, 2),
-            "jump_height_m": _format_float_metric(self.jump_height, 1, 3),
-            "jump_height_kinematic_m": _format_float_metric(
+            "flight_time_ms": format_float_metric(self.flight_time, 1000, 2),
+            "jump_height_m": format_float_metric(self.jump_height, 1, 3),
+            "jump_height_kinematic_m": format_float_metric(
                 self.jump_height_kinematic, 1, 3
             ),
-            "jump_height_trajectory_normalized": _format_float_metric(
+            "jump_height_trajectory_normalized": format_float_metric(
                 self.jump_height_trajectory, 1, 4
             ),
-            "contact_start_frame": _format_int_metric(self.contact_start_frame),
-            "contact_end_frame": _format_int_metric(self.contact_end_frame),
-            "flight_start_frame": _format_int_metric(self.flight_start_frame),
-            "flight_end_frame": _format_int_metric(self.flight_end_frame),
-            "peak_height_frame": _format_int_metric(self.peak_height_frame),
-            "contact_start_frame_precise": _format_float_metric(
+            "contact_start_frame": format_int_metric(self.contact_start_frame),
+            "contact_end_frame": format_int_metric(self.contact_end_frame),
+            "flight_start_frame": format_int_metric(self.flight_start_frame),
+            "flight_end_frame": format_int_metric(self.flight_end_frame),
+            "peak_height_frame": format_int_metric(self.peak_height_frame),
+            "contact_start_frame_precise": format_float_metric(
                 self.contact_start_frame_precise, 1, 3
             ),
-            "contact_end_frame_precise": _format_float_metric(
+            "contact_end_frame_precise": format_float_metric(
                 self.contact_end_frame_precise, 1, 3
             ),
-            "flight_start_frame_precise": _format_float_metric(
+            "flight_start_frame_precise": format_float_metric(
                 self.flight_start_frame_precise, 1, 3
             ),
-            "flight_end_frame_precise": _format_float_metric(
+            "flight_end_frame_precise": format_float_metric(
                 self.flight_end_frame_precise, 1, 3
             ),
         }

{kinemotion-0.26.1 → kinemotion-0.28.0}/tests/test_cli_cmj.py

@@ -118,7 +118,7 @@ class TestCMJCLIFileOperations:
             # Test keys exist, not their values (which may be None)
             assert isinstance(data, dict)
             assert "jump_height_m" in data
-            assert "flight_time_s" in data
+            assert "flight_time_ms" in data
 
     def test_debug_video_output_created(self, cli_runner, minimal_video, tmp_path):
         """Test debug video file is created when analysis succeeds."""

{kinemotion-0.26.1 → kinemotion-0.28.0}/tests/test_cmj_kinematics.py

@@ -97,14 +97,14 @@ def test_cmj_metrics_to_dict() -> None:
     # Verify all expected keys are present in data
     expected_keys = [
         "jump_height_m",
-        "flight_time_s",
+        "flight_time_ms",
         "countermovement_depth_m",
-        "eccentric_duration_s",
-        "concentric_duration_s",
-        "total_movement_time_s",
+        "eccentric_duration_ms",
+        "concentric_duration_ms",
+        "total_movement_time_ms",
         "peak_eccentric_velocity_m_s",
         "peak_concentric_velocity_m_s",
-        "transition_time_s",
+        "transition_time_ms",
         "standing_start_frame",
         "lowest_point_frame",
         "takeoff_frame",
@@ -117,7 +117,7 @@ def test_cmj_metrics_to_dict() -> None:
 
     # Verify all numeric values are Python types (not NumPy)
     assert isinstance(result_dict["data"]["jump_height_m"], float)
-    assert isinstance(result_dict["data"]["flight_time_s"], float)
+    assert isinstance(result_dict["data"]["flight_time_ms"], float)
     assert isinstance(result_dict["data"]["tracking_method"], str)
 
 

kinemotion-0.28.0/tests/test_formatting.py

@@ -0,0 +1,179 @@
+"""Tests for numeric formatting utilities."""
+
+from kinemotion.core.formatting import (
+    PRECISION_DISTANCE_M,
+    PRECISION_FRAME,
+    PRECISION_NORMALIZED,
+    PRECISION_TIME_MS,
+    PRECISION_VELOCITY_M_S,
+    format_float_metric,
+    format_int_metric,
+)
+
+
+class TestFormatFloatMetric:
+    """Test float metric formatting."""
+
+    def test_basic_rounding(self) -> None:
+        """Test basic rounding without scaling."""
+        assert format_float_metric(1.23456, 1, 2) == 1.23
+        assert format_float_metric(1.23456, 1, 3) == 1.235
+        assert format_float_metric(1.23456, 1, 4) == 1.2346
+
+    def test_scaling_with_rounding(self) -> None:
+        """Test scaling (e.g., seconds to milliseconds) with rounding."""
+        # Seconds to milliseconds
+        assert format_float_metric(0.534123, 1000, 2) == 534.12
+        assert format_float_metric(0.001, 1000, 2) == 1.0
+        assert format_float_metric(1.999999, 1000, 2) == 2000.0
+
+    def test_none_handling(self) -> None:
+        """Test that None values pass through."""
+        assert format_float_metric(None, 1, 2) is None
+        assert format_float_metric(None, 1000, 3) is None
+
+    def test_negative_values(self) -> None:
+        """Test that negative values are preserved."""
+        assert format_float_metric(-1.23456, 1, 2) == -1.23
+        assert format_float_metric(-0.534, 1000, 2) == -534.0
+
+    def test_zero_values(self) -> None:
+        """Test zero handling."""
+        assert format_float_metric(0.0, 1, 2) == 0.0
+        assert format_float_metric(0.0, 1000, 2) == 0.0
+
+    def test_precision_constants(self) -> None:
+        """Test that precision constants are defined correctly."""
+        assert PRECISION_TIME_MS == 2
+        assert PRECISION_DISTANCE_M == 3
+        assert PRECISION_VELOCITY_M_S == 4
+        assert PRECISION_FRAME == 3
+        assert PRECISION_NORMALIZED == 4
+
+
+class TestFormatIntMetric:
+    """Test integer metric formatting."""
+
+    def test_float_to_int(self) -> None:
+        """Test float to integer conversion."""
+        assert format_int_metric(42.7) == 42
+        assert format_int_metric(42.2) == 42
+        assert format_int_metric(42.9) == 42
+
+    def test_int_passthrough(self) -> None:
+        """Test that integers pass through."""
+        assert format_int_metric(42) == 42
+        assert format_int_metric(0) == 0
+
+    def test_none_handling(self) -> None:
+        """Test that None values pass through."""
+        assert format_int_metric(None) is None
+
+    def test_negative_values(self) -> None:
+        """Test negative value handling."""
+        assert format_int_metric(-42.7) == -42
+
+
+class TestPrecisionConsistency:
+    """Test precision consistency across measurement types."""
+
+    def test_time_precision(self) -> None:
+        """Test time measurements use 2 decimal places."""
+        # Time in milliseconds
+        time_ms = format_float_metric(534.123456, 1, PRECISION_TIME_MS)
+        assert time_ms == 534.12
+
+        # Seconds to milliseconds
+        time_s_to_ms = format_float_metric(0.534123456, 1000, PRECISION_TIME_MS)
+        assert time_s_to_ms == 534.12
+
+    def test_distance_precision(self) -> None:
+        """Test distance measurements use 3 decimal places."""
+        # Jump height in meters
+        height = format_float_metric(0.35212345, 1, PRECISION_DISTANCE_M)
+        assert height == 0.352
+
+        # Countermovement depth
+        depth = format_float_metric(0.04512345, 1, PRECISION_DISTANCE_M)
+        assert depth == 0.045
+
+    def test_velocity_precision(self) -> None:
+        """Test velocity measurements use 4 decimal places."""
+        # Velocity in m/s
+        velocity = format_float_metric(2.63401234, 1, PRECISION_VELOCITY_M_S)
+        assert velocity == 2.634
+
+        # Negative velocity (downward)
+        neg_velocity = format_float_metric(-1.23459999, 1, PRECISION_VELOCITY_M_S)
+        assert neg_velocity == -1.2346
+
+    def test_frame_precision(self) -> None:
+        """Test frame numbers use 3 decimal places for sub-frame precision."""
+        frame = format_float_metric(154.342567, 1, PRECISION_FRAME)
+        assert frame == 154.343
+
+    def test_normalized_precision(self) -> None:
+        """Test normalized values use 4 decimal places."""
+        normalized = format_float_metric(0.058234567, 1, PRECISION_NORMALIZED)
+        assert normalized == 0.0582
+
+
+class TestRealWorldExamples:
+    """Test with real-world measurement examples."""
+
+    def test_cmj_measurements(self) -> None:
+        """Test CMJ measurement formatting."""
+        # Jump height: 0.40502274976565683 → 0.405
+        assert format_float_metric(0.40502274976565683, 1, 3) == 0.405
+
+        # Flight time: 0.57471 seconds → 574.71 ms
+        assert format_float_metric(0.57471, 1000, 2) == 574.71
+
+        # Countermovement depth: 0.0024646043777466486 → 0.002
+        assert format_float_metric(0.0024646043777466486, 1, 3) == 0.002
+
+        # Peak velocity: 0.0028023441632588253 → 0.0028
+        assert format_float_metric(0.0028023441632588253, 1, 4) == 0.0028
+
+    def test_dropjump_measurements(self) -> None:
+        """Test drop jump measurement formatting."""
+        # Ground contact time: 0.35709 seconds → 357.09 ms
+        assert format_float_metric(0.35709, 1000, 2) == 357.09
+
+        # Jump height: 0.259123 → 0.259
+        assert format_float_metric(0.259123, 1, 3) == 0.259
+
+        # Trajectory normalized: 0.058234 → 0.0582
+        assert format_float_metric(0.058234, 1, 4) == 0.0582
+
+        # Precise frame: 32.034567 → 32.035
+        assert format_float_metric(32.034567, 1, 3) == 32.035
+
+
+class TestEdgeCases:
+    """Test edge cases and boundary conditions."""
+
+    def test_very_small_values(self) -> None:
+        """Test very small values near zero."""
+        # Should not use scientific notation
+        assert format_float_metric(0.0001, 1, 4) == 0.0001
+        assert format_float_metric(0.00001, 1, 5) == 0.00001
+
+    def test_very_large_values(self) -> None:
+        """Test very large values."""
+        assert format_float_metric(999999.123, 1, 2) == 999999.12
+        assert format_float_metric(1000000.5, 1, 1) == 1000000.5
+
+    def test_exact_values(self) -> None:
+        """Test values that are exact after rounding."""
+        assert format_float_metric(1.5, 1, 2) == 1.5
+        assert format_float_metric(1.50, 1, 2) == 1.5
+        assert format_float_metric(0.0, 1, 3) == 0.0
+
+    def test_rounding_at_boundary(self) -> None:
+        """Test rounding at .5 boundary (Python uses banker's rounding)."""
+        # Banker's rounding: round to nearest even
+        assert format_float_metric(2.5, 1, 0) == 2.0  # rounds to even (2)
+        assert format_float_metric(3.5, 1, 0) == 4.0  # rounds to even (4)
+        assert format_float_metric(1.25, 1, 1) == 1.2  # rounds to even (1.2)
+        assert format_float_metric(1.35, 1, 1) == 1.4  # rounds to even (1.4)