x4d-devkit 0.9.0__tar.gz → 0.12.0__tar.gz

{x4d_devkit-0.9.0/x4d_devkit.egg-info → x4d_devkit-0.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: x4d-devkit
-Version: 0.9.0
+Version: 0.12.0
 Summary: X-4D dataset format SDK — load, validate, evaluate, and convert autonomous driving datasets
 Author: windzu
 License-Expression: Apache-2.0
@@ -65,22 +65,31 @@ for sample in loader.samples:
 
 ### Coordinate frame transforms
 
-Point clouds and annotations can be loaded in different coordinate frames:
+Frames are real frame_id strings: any node in the calibration tree (e.g.
+`"LIDAR_TOP"`, `"base_link"`, `"cam_front"`) plus the constant
+`"clip_world"` (the SLAM-anchored clip-local world). The legacy aliases
+`"sensor"`, `"ego"`, `"world"` are not accepted.
 
 ```python
+from x4d_devkit import ClipLoader
+from x4d_devkit.core.loader import CLIP_WORLD_FRAME_ID
+
 loader = ClipLoader("/path/to/clip")
 sd = loader.sample_data_for_channel("LIDAR_TOP")[0]
 
 # Load point cloud in different frames
-pts_sensor = loader.load_point_cloud(sd, frame="sensor")  # raw (default)
-pts_ego = loader.load_point_cloud(sd, frame="ego")        # sensor → ego
-pts_world = loader.load_point_cloud(sd, frame="world")    # sensor → world
+pts_sensor = loader.load_point_cloud(sd)                                 # raw sensor (default)
+pts_ego    = loader.load_point_cloud(sd, frame=loader.ego_pose_frame_id) # sensor → ego
+pts_world  = loader.load_point_cloud(sd, frame=CLIP_WORLD_FRAME_ID)      # sensor → clip_world
+
+# Get annotations transformed to clip-local world
+anns_world = loader.annotations_for_sample(sample.token, frame=CLIP_WORLD_FRAME_ID)
 
-# Get annotations in ego frame (for training)
-anns_ego = loader.annotations_for_sample(sample.token, frame="ego")
+# Or to a specific sensor's frame
+anns_lidar = loader.annotations_for_sample(sample.token, frame="LIDAR_TOP")
 
-# Get the transform matrix directly
-T = loader.get_transform(sd, from_frame="sensor", to_frame="world")
+# Get the transform matrix directly (sd is required when clip_world is involved)
+T = loader.get_transform(loader.sensor_frame_id(sd), CLIP_WORLD_FRAME_ID, sd=sd)
 pts_world = T.apply(pts_sensor[:, :3])  # or use T.as_matrix for 4x4
 ```
 

{x4d_devkit-0.9.0 → x4d_devkit-0.12.0}/README.md

@@ -35,22 +35,31 @@ for sample in loader.samples:
 
 ### Coordinate frame transforms
 
-Point clouds and annotations can be loaded in different coordinate frames:
+Frames are real frame_id strings: any node in the calibration tree (e.g.
+`"LIDAR_TOP"`, `"base_link"`, `"cam_front"`) plus the constant
+`"clip_world"` (the SLAM-anchored clip-local world). The legacy aliases
+`"sensor"`, `"ego"`, `"world"` are not accepted.
 
 ```python
+from x4d_devkit import ClipLoader
+from x4d_devkit.core.loader import CLIP_WORLD_FRAME_ID
+
 loader = ClipLoader("/path/to/clip")
 sd = loader.sample_data_for_channel("LIDAR_TOP")[0]
 
 # Load point cloud in different frames
-pts_sensor = loader.load_point_cloud(sd, frame="sensor")  # raw (default)
-pts_ego = loader.load_point_cloud(sd, frame="ego")        # sensor → ego
-pts_world = loader.load_point_cloud(sd, frame="world")    # sensor → world
+pts_sensor = loader.load_point_cloud(sd)                                 # raw sensor (default)
+pts_ego    = loader.load_point_cloud(sd, frame=loader.ego_pose_frame_id) # sensor → ego
+pts_world  = loader.load_point_cloud(sd, frame=CLIP_WORLD_FRAME_ID)      # sensor → clip_world
+
+# Get annotations transformed to clip-local world
+anns_world = loader.annotations_for_sample(sample.token, frame=CLIP_WORLD_FRAME_ID)
 
-# Get annotations in ego frame (for training)
-anns_ego = loader.annotations_for_sample(sample.token, frame="ego")
+# Or to a specific sensor's frame
+anns_lidar = loader.annotations_for_sample(sample.token, frame="LIDAR_TOP")
 
-# Get the transform matrix directly
-T = loader.get_transform(sd, from_frame="sensor", to_frame="world")
+# Get the transform matrix directly (sd is required when clip_world is involved)
+T = loader.get_transform(loader.sensor_frame_id(sd), CLIP_WORLD_FRAME_ID, sd=sd)
 pts_world = T.apply(pts_sensor[:, :3])  # or use T.as_matrix for 4x4
 ```
 

{x4d_devkit-0.9.0 → x4d_devkit-0.12.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "x4d-devkit"
-version = "0.9.0"
+version = "0.12.0"
 description = "X-4D dataset format SDK — load, validate, evaluate, and convert autonomous driving datasets"
 readme = "README.md"
 license = "Apache-2.0"

{x4d_devkit-0.9.0 → x4d_devkit-0.12.0}/tests/test_coordinate_frames.py

@@ -1,7 +1,12 @@
-"""Tests for ClipLoader coordinate frame support.
+"""Tests for ClipLoader coordinate frame support — frame-graph (post-magic-string) API.
 
-Unit tests use synthetic data (no nuScenes dependency).
-Integration tests require nuScenes mini data.
+The new contract: every frame is a real frame_id string (a node in the
+calibration tree) plus the constant ``"clip_world"`` for the SLAM-anchored
+clip-local world. The legacy magic strings ``"sensor"``, ``"ego"``, ``"world"``
+are rejected to remove the "did you mean my-actual-frame_id-string?" foot-gun.
+
+Unit tests use synthetic data (no nuScenes dependency). Integration tests
+require nuScenes mini data.
 """
 
 import json
@@ -12,8 +17,9 @@ import numpy as np
 import pytest
 
 from x4d_devkit.core.loader import ClipLoader
-from x4d_devkit.core.models import Annotation, SampleData
-from x4d_devkit.core.transform import Transform, rotation_matrix_to_quat
+
+
+CLIP_WORLD = "clip_world"
 
 
 # ---------------------------------------------------------------------------
@@ -157,7 +163,7 @@ def _make_synthetic_clip(tmp_path: Path) -> Path:
     pts.tofile(str(lidar_dir / "frame0.bin"))
     pts.tofile(str(lidar_dir / "frame1.bin"))
 
-    # -- annotation.json (v0.5: per-sample ego frame) --
+    # -- annotation.json (v0.5: per-sample ego frame; here ann_frame == base_link) --
     # s-0 ego at origin; s-1 ego at (10, 0, 0). Same world pos (5,3,0) and (10,3,0)
     # for the two frames maps to ego (5,3,0) and (0,3,0) respectively.
     (clip_dir / "annotation.json").write_text(json.dumps([
@@ -224,186 +230,220 @@ def loader(synthetic_clip):
 
 
 # ---------------------------------------------------------------------------
-# Unit tests: load_point_cloud with frame parameter
+# Frame-id helpers (the user-facing way to discover frame names)
+# ---------------------------------------------------------------------------
+
+class TestFrameIdHelpers:
+    def test_ego_pose_frame_id_exposes_ego_frame(self, loader):
+        # v0.2 fallback chain: meta.ego_pose_frame_id None → annotation_frame_id None → "base_link".
+        assert loader.ego_pose_frame_id == "base_link"
+
+    def test_annotation_frame_id_exposed(self, loader):
+        assert loader.annotation_frame_id == "base_link"
+
+    def test_sensor_frame_id_returns_channel_frame(self, loader):
+        sd = loader.sample_data_for_channel("LIDAR_TOP")[0]
+        # v0.2 has no per-sensor frame_id, falls back to channel name.
+        assert loader.sensor_frame_id(sd) == "LIDAR_TOP"
+
+    def test_clip_world_constant_is_string_literal(self):
+        # The spec pins this name. Any consumer can pass it as a regular frame.
+        from x4d_devkit.core.loader import CLIP_WORLD_FRAME_ID
+        assert CLIP_WORLD_FRAME_ID == "clip_world"
+
+
+# ---------------------------------------------------------------------------
+# load_point_cloud — explicit frame_id, no magic strings
 # ---------------------------------------------------------------------------
 
 class TestLoadPointCloudFrames:
-    def test_sensor_frame_default(self, loader):
-        """Default frame should return raw sensor coordinates."""
+    def test_no_frame_returns_raw_sensor(self, loader):
+        """Default (no frame=) returns the raw sensor data unchanged."""
         sd = loader.sample_data_for_channel("LIDAR_TOP")[0]
         pts = loader.load_point_cloud(sd)
         assert pts.shape == (4, 4)
         np.testing.assert_allclose(pts[0, :3], [1.0, 0.0, 0.0], atol=1e-6)
 
-    def test_sensor_frame_explicit(self, loader):
-        """Explicit frame='sensor' should match default."""
+    def test_frame_equal_to_sensor_frame_is_noop(self, loader):
+        """Passing the sensor's own frame_id matches the no-frame default."""
         sd = loader.sample_data_for_channel("LIDAR_TOP")[0]
         pts_default = loader.load_point_cloud(sd)
-        pts_sensor = loader.load_point_cloud(sd, frame="sensor")
-        np.testing.assert_array_equal(pts_default, pts_sensor)
+        pts_explicit = loader.load_point_cloud(sd, frame=loader.sensor_frame_id(sd))
+        np.testing.assert_array_equal(pts_default, pts_explicit)
 
-    def test_ego_frame(self, loader):
-        """frame='ego' applies sensor-to-ego transform (z+1 for LIDAR_TOP)."""
+    def test_frame_equal_to_ego_applies_calibration(self, loader):
+        """frame=ego_pose_frame_id applies sensor-to-ego (z+1 for LIDAR_TOP)."""
         sd = loader.sample_data_for_channel("LIDAR_TOP")[0]
-        pts = loader.load_point_cloud(sd, frame="ego")
-        # LiDAR is at z=1 in ego frame, so sensor point (1,0,0) -> ego (1,0,1)
+        pts = loader.load_point_cloud(sd, frame=loader.ego_pose_frame_id)
         np.testing.assert_allclose(pts[0, :3], [1.0, 0.0, 1.0], atol=1e-5)
-        # sensor (0,0,1) -> ego (0,0,2)
         np.testing.assert_allclose(pts[2, :3], [0.0, 0.0, 2.0], atol=1e-5)
 
-    def test_world_frame_first_ego(self, loader):
-        """frame='world' for first frame (ego at origin): same as ego frame."""
+    def test_frame_clip_world_first_ego(self, loader):
+        """frame='clip_world' for the first ego pose (at origin) ≡ ego frame."""
         sd = loader.sample_data_for_channel("LIDAR_TOP")[0]  # ep-0 at origin
-        pts_ego = loader.load_point_cloud(sd, frame="ego")
-        pts_world = loader.load_point_cloud(sd, frame="world")
+        pts_ego = loader.load_point_cloud(sd, frame=loader.ego_pose_frame_id)
+        pts_world = loader.load_point_cloud(sd, frame=CLIP_WORLD)
         np.testing.assert_allclose(pts_world[:, :3], pts_ego[:, :3], atol=1e-5)
 
-    def test_world_frame_second_ego(self, loader):
-        """frame='world' for second frame (ego at x=10): adds ego offset."""
+    def test_frame_clip_world_second_ego(self, loader):
+        """frame='clip_world' for the second ego pose adds the ego offset."""
         sd = loader.sample_data_for_channel("LIDAR_TOP")[1]  # ep-1 at x=10
-        pts = loader.load_point_cloud(sd, frame="world")
-        # sensor (1,0,0) -> ego (1,0,1) -> world (11,0,1)
+        pts = loader.load_point_cloud(sd, frame=CLIP_WORLD)
         np.testing.assert_allclose(pts[0, :3], [11.0, 0.0, 1.0], atol=1e-5)
 
     def test_intensity_preserved(self, loader):
-        """Non-xyz columns should not be modified."""
+        """Non-xyz columns are passed through unchanged."""
         sd = loader.sample_data_for_channel("LIDAR_TOP")[0]
-        pts = loader.load_point_cloud(sd, frame="world")
+        pts = loader.load_point_cloud(sd, frame=CLIP_WORLD)
         np.testing.assert_allclose(pts[:, 3], 0.5, atol=1e-6)
 
-    def test_invalid_frame_raises(self, loader):
+    def test_magic_string_world_rejected(self, loader):
+        """The legacy magic string 'world' must be rejected with a hint."""
         sd = loader.sample_data_for_channel("LIDAR_TOP")[0]
-        with pytest.raises(ValueError, match="Invalid frame"):
-            loader.load_point_cloud(sd, frame="invalid")
+        with pytest.raises(ValueError, match=r"clip_world"):
+            loader.load_point_cloud(sd, frame="world")
+
+    def test_magic_string_ego_rejected(self, loader):
+        sd = loader.sample_data_for_channel("LIDAR_TOP")[0]
+        with pytest.raises(ValueError, match=r"ego_pose_frame_id"):
+            loader.load_point_cloud(sd, frame="ego")
+
+    def test_magic_string_sensor_rejected(self, loader):
+        sd = loader.sample_data_for_channel("LIDAR_TOP")[0]
+        with pytest.raises(ValueError, match=r"sensor_frame_id"):
+            loader.load_point_cloud(sd, frame="sensor")
+
+    def test_unknown_frame_id_raises_keyerror(self, loader):
+        sd = loader.sample_data_for_channel("LIDAR_TOP")[0]
+        with pytest.raises(KeyError, match=r"not_a_real_frame"):
+            loader.load_point_cloud(sd, frame="not_a_real_frame")
 
 
 # ---------------------------------------------------------------------------
-# Unit tests: annotations_for_sample with frame parameter
+# annotations_for_sample — explicit frame_id, no magic strings
 # ---------------------------------------------------------------------------
 
 class TestAnnotationsForSampleFrames:
-    def test_ego_frame_default(self, loader):
-        """Default frame should return annotations in per-sample ego coordinates (v0.5 native)."""
+    def test_no_frame_returns_native(self, loader):
+        """Default (no frame=) returns annotations in the stored frame, unchanged."""
         anns = loader.annotations_for_sample("s-0")
         assert len(anns) == 1
         np.testing.assert_allclose(anns[0].translation, [5.0, 3.0, 0.0])
 
-    def test_ego_frame_explicit(self, loader):
-        """Explicit frame='ego' should match default."""
+    def test_frame_equal_to_annotation_frame_is_noop(self, loader):
+        """Passing annotation_frame_id matches the no-frame default."""
         anns_default = loader.annotations_for_sample("s-0")
-        anns_ego = loader.annotations_for_sample("s-0", frame="ego")
-        assert len(anns_default) == len(anns_ego)
-        np.testing.assert_allclose(anns_default[0].translation, anns_ego[0].translation)
-
-    def test_world_frame_first_sample(self, loader):
-        """frame='world' for first sample (ego at origin): same as ego."""
-        anns = loader.annotations_for_sample("s-0", frame="world")
-        # ego at origin -> ego-to-world is identity
+        anns_explicit = loader.annotations_for_sample("s-0", frame=loader.annotation_frame_id)
+        np.testing.assert_allclose(anns_default[0].translation, anns_explicit[0].translation)
+
+    def test_frame_clip_world_first_sample(self, loader):
+        """frame='clip_world' on the first sample (ego at origin) ≡ stored ego."""
+        anns = loader.annotations_for_sample("s-0", frame=CLIP_WORLD)
         np.testing.assert_allclose(anns[0].translation, [5.0, 3.0, 0.0], atol=1e-5)
 
-    def test_world_frame_second_sample(self, loader):
-        """frame='world' for second sample (ego at x=10): adds ego offset."""
-        anns = loader.annotations_for_sample("s-1", frame="world")
-        # ego frame (0,3,0), ego at (10,0,0) -> world (10,3,0)
+    def test_frame_clip_world_second_sample(self, loader):
+        """frame='clip_world' on the second sample (ego at x=10) shifts by ego offset."""
+        anns = loader.annotations_for_sample("s-1", frame=CLIP_WORLD)
         np.testing.assert_allclose(anns[0].translation, [10.0, 3.0, 0.0], atol=1e-5)
 
-    def test_ego_frame_velocity_unchanged(self, loader):
-        """Native (ego) frame: velocity returned as stored."""
-        anns = loader.annotations_for_sample("s-0", frame="ego")
+    def test_native_velocity_unchanged(self, loader):
+        anns = loader.annotations_for_sample("s-0")
         np.testing.assert_allclose(anns[0].velocity, [5.0, 0.0, 0.0], atol=1e-5)
 
-    def test_world_frame_preserves_other_fields(self, loader):
-        """Non-pose fields should be preserved across frame transforms."""
-        anns_ego = loader.annotations_for_sample("s-0", frame="ego")
-        anns_world = loader.annotations_for_sample("s-0", frame="world")
-        assert anns_ego[0].token == anns_world[0].token
-        assert anns_ego[0].category == anns_world[0].category
-        np.testing.assert_allclose(anns_ego[0].size, anns_world[0].size)
-        assert anns_ego[0].num_lidar_pts == anns_world[0].num_lidar_pts
-
-    def test_world_frame_returns_new_objects(self, loader):
-        """Transformed annotations should be new objects, not mutated originals."""
-        anns_ego = loader.annotations_for_sample("s-1", frame="ego")
-        anns_world = loader.annotations_for_sample("s-1", frame="world")
-        # Originals (ego, native) should be unmodified
-        np.testing.assert_allclose(anns_ego[0].translation, [0.0, 3.0, 0.0])
-        # World should be different
-        assert not np.allclose(anns_world[0].translation, anns_ego[0].translation, atol=0.1)
-
-    def test_sensor_frame_raises(self, loader):
-        with pytest.raises(ValueError, match="ambiguous"):
+    def test_clip_world_preserves_other_fields(self, loader):
+        anns_native = loader.annotations_for_sample("s-0")
+        anns_world = loader.annotations_for_sample("s-0", frame=CLIP_WORLD)
+        assert anns_native[0].token == anns_world[0].token
+        assert anns_native[0].category == anns_world[0].category
+        np.testing.assert_allclose(anns_native[0].size, anns_world[0].size)
+        assert anns_native[0].num_lidar_pts == anns_world[0].num_lidar_pts
+
+    def test_returns_new_objects(self, loader):
+        """Transformed annotations are new objects; originals untouched."""
+        anns_native = loader.annotations_for_sample("s-1")
+        anns_world = loader.annotations_for_sample("s-1", frame=CLIP_WORLD)
+        np.testing.assert_allclose(anns_native[0].translation, [0.0, 3.0, 0.0])
+        assert not np.allclose(anns_world[0].translation, anns_native[0].translation, atol=0.1)
+
+    def test_frame_sensor_id_transforms_to_that_sensor(self, loader):
+        """Passing a sensor's frame_id transforms annotations into that sensor's frame."""
+        # LIDAR_TOP is at (0,0,1) in ego frame. Annotation at ego (5,3,0) →
+        # LIDAR_TOP frame: subtract z=1 → (5,3,-1).
+        anns = loader.annotations_for_sample("s-0", frame="LIDAR_TOP")
+        np.testing.assert_allclose(anns[0].translation, [5.0, 3.0, -1.0], atol=1e-5)
+
+    def test_magic_string_sensor_rejected(self, loader):
+        with pytest.raises(ValueError, match=r"sensor_frame_id"):
             loader.annotations_for_sample("s-0", frame="sensor")
 
-    def test_invalid_frame_raises(self, loader):
-        with pytest.raises(ValueError, match="Invalid frame"):
-            loader.annotations_for_sample("s-0", frame="invalid")
+    def test_magic_string_ego_rejected(self, loader):
+        with pytest.raises(ValueError, match=r"ego_pose_frame_id"):
+            loader.annotations_for_sample("s-0", frame="ego")
+
+    def test_magic_string_world_rejected(self, loader):
+        with pytest.raises(ValueError, match=r"clip_world"):
+            loader.annotations_for_sample("s-0", frame="world")
+
+    def test_unknown_frame_id_raises(self, loader):
+        with pytest.raises((KeyError, ValueError), match=r"not_a_real_frame"):
+            loader.annotations_for_sample("s-0", frame="not_a_real_frame")
 
     def test_empty_sample_returns_empty(self, loader):
-        """Non-existent sample returns empty list regardless of frame."""
-        assert loader.annotations_for_sample("nonexistent", frame="ego") == []
+        assert loader.annotations_for_sample("nonexistent") == []
+        assert loader.annotations_for_sample("nonexistent", frame=CLIP_WORLD) == []
 
 
 # ---------------------------------------------------------------------------
-# Unit tests: get_transform
+# get_transform — frame_id × frame_id, sd carries dynamic context
 # ---------------------------------------------------------------------------
 
 class TestGetTransform:
     def test_identity_same_frame(self, loader):
-        sd = loader.sample_data_for_channel("LIDAR_TOP")[0]
-        T = loader.get_transform(sd, from_frame="sensor", to_frame="sensor")
+        T = loader.get_transform("LIDAR_TOP", "LIDAR_TOP")
         np.testing.assert_allclose(T.as_matrix, np.eye(4), atol=1e-10)
 
-    def test_sensor_to_ego(self, loader):
-        sd = loader.sample_data_for_channel("LIDAR_TOP")[0]
-        T = loader.get_transform(sd, from_frame="sensor", to_frame="ego")
-        # LiDAR at z=1
+    def test_static_sensor_to_ego(self, loader):
+        # Static-only: no sd needed.
+        T = loader.get_transform("LIDAR_TOP", loader.ego_pose_frame_id)
         np.testing.assert_allclose(T.translation, [0.0, 0.0, 1.0], atol=1e-10)
 
-    def test_sensor_to_world(self, loader):
+    def test_static_sensor_to_sensor(self, loader):
+        # LIDAR_TOP at (0,0,1) and CAM_FRONT at (0.5,0,0.8) in ego frame.
+        # T_CAM_from_LIDAR = T_CAM_from_ego @ T_ego_from_LIDAR
+        #   = (-0.5, 0, -0.8) ∘ (0, 0, +1) = (-0.5, 0, +0.2)
+        T = loader.get_transform("LIDAR_TOP", "CAM_FRONT")
+        np.testing.assert_allclose(T.translation, [-0.5, 0.0, 0.2], atol=1e-10)
+
+    def test_dynamic_sensor_to_clip_world_requires_sd(self, loader):
         sd = loader.sample_data_for_channel("LIDAR_TOP")[1]  # ego at x=10
-        T = loader.get_transform(sd, from_frame="sensor", to_frame="world")
-        # sensor to ego (z+1) then ego to world (x+10)
+        T = loader.get_transform("LIDAR_TOP", CLIP_WORLD, sd=sd)
+        # sensor → ego (z+1) → world (x+10)  →  (10, 0, 1)
         np.testing.assert_allclose(T.translation, [10.0, 0.0, 1.0], atol=1e-10)
 
-    def test_ego_to_world(self, loader):
-        sd = loader.sample_data_for_channel("LIDAR_TOP")[1]
-        T = loader.get_transform(sd, from_frame="ego", to_frame="world")
-        np.testing.assert_allclose(T.translation, [10.0, 0.0, 0.0], atol=1e-10)
+    def test_clip_world_without_sd_raises(self, loader):
+        with pytest.raises(ValueError, match=r"clip_world"):
+            loader.get_transform("LIDAR_TOP", CLIP_WORLD)
 
-    def test_round_trip(self, loader):
-        """sensor→world→sensor should be identity."""
+    def test_round_trip_through_clip_world(self, loader):
         sd = loader.sample_data_for_channel("LIDAR_TOP")[1]
-        T_fwd = loader.get_transform(sd, from_frame="sensor", to_frame="world")
-        T_rev = loader.get_transform(sd, from_frame="world", to_frame="sensor")
-        T_round = T_fwd @ T_rev
-        np.testing.assert_allclose(T_round.as_matrix, np.eye(4), atol=1e-10)
+        T_fwd = loader.get_transform("LIDAR_TOP", CLIP_WORLD, sd=sd)
+        T_rev = loader.get_transform(CLIP_WORLD, "LIDAR_TOP", sd=sd)
+        np.testing.assert_allclose((T_fwd @ T_rev).as_matrix, np.eye(4), atol=1e-10)
 
-    def test_all_six_combinations(self, loader):
-        """All from/to combinations should work without error."""
+    def test_magic_string_rejected(self, loader):
         sd = loader.sample_data_for_channel("LIDAR_TOP")[0]
-        frames = ["sensor", "ego", "world"]
-        for f in frames:
-            for t in frames:
-                T = loader.get_transform(sd, from_frame=f, to_frame=t)
-                assert T.as_matrix.shape == (4, 4)
+        with pytest.raises(ValueError, match=r"clip_world"):
+            loader.get_transform("sensor", "world", sd=sd)
 
-    def test_invalid_from_frame_raises(self, loader):
-        sd = loader.sample_data_for_channel("LIDAR_TOP")[0]
-        with pytest.raises(ValueError, match="Invalid from_frame"):
-            loader.get_transform(sd, from_frame="bad", to_frame="ego")
-
-    def test_invalid_to_frame_raises(self, loader):
-        sd = loader.sample_data_for_channel("LIDAR_TOP")[0]
-        with pytest.raises(ValueError, match="Invalid to_frame"):
-            loader.get_transform(sd, from_frame="sensor", to_frame="bad")
+    def test_unknown_frame_id_raises_keyerror(self, loader):
+        with pytest.raises(KeyError, match=r"not_a_real_frame"):
+            loader.get_transform("LIDAR_TOP", "not_a_real_frame")
 
     def test_consistency_with_load_point_cloud(self, loader):
-        """get_transform result should match load_point_cloud frame output."""
         sd = loader.sample_data_for_channel("LIDAR_TOP")[1]
-        pts_sensor = loader.load_point_cloud(sd, frame="sensor")
-        pts_world = loader.load_point_cloud(sd, frame="world")
-
-        T = loader.get_transform(sd, from_frame="sensor", to_frame="world")
+        pts_sensor = loader.load_point_cloud(sd)
+        pts_world = loader.load_point_cloud(sd, frame=CLIP_WORLD)
+        T = loader.get_transform("LIDAR_TOP", CLIP_WORLD, sd=sd)
         pts_manual = T.apply(pts_sensor[:, :3].astype(np.float64)).astype(np.float32)
         np.testing.assert_allclose(pts_world[:, :3], pts_manual, atol=1e-5)
 
@@ -434,25 +474,28 @@ def nuscenes_loader(tmp_path_factory):
 @pytest.mark.skipif(not NUSCENES_AVAILABLE, reason="nuScenes data not found")
 class TestCoordinateFramesIntegration:
     def test_point_cloud_round_trip(self, nuscenes_loader):
-        """sensor→world→sensor should recover original points."""
+        """sensor → clip_world → sensor recovers original points."""
         sd = next(
             s for s in nuscenes_loader.sample_data_for_channel("LIDAR_TOP") if s.is_keyframe
         )
-        pts_sensor = nuscenes_loader.load_point_cloud(sd, frame="sensor")
-        T = nuscenes_loader.get_transform(sd, from_frame="world", to_frame="sensor")
-        pts_world = nuscenes_loader.load_point_cloud(sd, frame="world")
-        recovered = T.apply(pts_world[:, :3].astype(np.float64)).astype(np.float32)
+        pts_sensor = nuscenes_loader.load_point_cloud(sd)
+        pts_world = nuscenes_loader.load_point_cloud(sd, frame=CLIP_WORLD)
+        T_back = nuscenes_loader.get_transform(CLIP_WORLD, "LIDAR_TOP", sd=sd)
+        recovered = T_back.apply(pts_world[:, :3].astype(np.float64)).astype(np.float32)
         np.testing.assert_allclose(recovered, pts_sensor[:, :3], atol=1e-4)
 
     def test_ego_annotations_near_ego(self, nuscenes_loader):
-        """Ego-frame annotations should be centered around the ego vehicle."""
         sample = nuscenes_loader.samples[0]
-        anns_world = nuscenes_loader.annotations_for_sample(sample.token, frame="world")
-        anns_ego = nuscenes_loader.annotations_for_sample(sample.token, frame="ego")
-        if not anns_world:
+        anns_native = nuscenes_loader.annotations_for_sample(sample.token)
+        anns_world = nuscenes_loader.annotations_for_sample(sample.token, frame=CLIP_WORLD)
+        if not anns_native:
             pytest.skip("No annotations in first sample")
-
-        # In ego frame, nearby objects should be within reasonable range
-        for ann in anns_ego:
-            dist = np.linalg.norm(ann.translation[:2])  # xy distance from ego
-            assert dist < 200, f"Annotation too far in ego frame: {dist}m"
+        for ann in anns_native:
+            dist = np.linalg.norm(ann.translation[:2])
+            assert dist < 200, f"Annotation too far in native frame: {dist}m"
+        # World frame should differ for at least one annotation (ego usually not at origin).
+        diffs = [
+            np.linalg.norm(an.translation - aw.translation)
+            for an, aw in zip(anns_native, anns_world)
+        ]
+        assert max(diffs) > 0  # at minimum, different positions

{x4d_devkit-0.9.0 → x4d_devkit-0.12.0}/tests/test_v06_schema.py

@@ -274,7 +274,7 @@ def test_annotations_for_sample_unknown_frame_id_raises(tmp_path):
         }],
     )
     loader = ClipLoader(tmp_path)
-    with pytest.raises(ValueError, match="Invalid frame"):
+    with pytest.raises(KeyError, match="never_exists_frame"):
         loader.annotations_for_sample("s-0", frame="never_exists_frame")