x4d-devkit 0.3.0__tar.gz → 0.4.0__tar.gz

{x4d_devkit-0.3.0/x4d_devkit.egg-info → x4d_devkit-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: x4d-devkit
-Version: 0.3.0
+Version: 0.4.0
 Summary: X-4D dataset format SDK — load, validate, evaluate, and convert autonomous driving datasets
 Author: windzu
 License-Expression: Apache-2.0

{x4d_devkit-0.3.0 → x4d_devkit-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "x4d-devkit"
-version = "0.3.0"
+version = "0.4.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.3.0 → x4d_devkit-0.4.0}/tests/test_coordinate_frames.py

@@ -56,14 +56,18 @@ def _make_synthetic_clip(tmp_path: Path) -> Path:
             "channel": "LIDAR_TOP",
             "translation": {"x": 0.0, "y": 0.0, "z": 1.0},
             "rotation": {"qx": 0.0, "qy": 0.0, "qz": 0.0, "qw": 1.0},
-            "camera_intrinsic": None,
+            "intrinsics": None,
+            "distortion": None,
         },
         {
             "calibrated_sensor_token": "cs-cam",
             "channel": "CAM_FRONT",
             "translation": {"x": 0.5, "y": 0.0, "z": 0.8},
             "rotation": {"qx": 0.0, "qy": 0.0, "qz": 0.0, "qw": 1.0},
-            "camera_intrinsic": {"fx": 1000, "fy": 1000, "cx": 320, "cy": 240},
+            "intrinsics": {"camera_model": "pinhole",
+                           "fx": 1000, "fy": 1000, "cx": 320, "cy": 240,
+                           "image_width": 640, "image_height": 480},
+            "distortion": None,
         },
     ]))
 

{x4d_devkit-0.3.0 → x4d_devkit-0.4.0}/tests/test_models.py

@@ -82,13 +82,17 @@ class TestSampleData:
 class TestCalibratedSensor:
     def test_construction(self):
         cs = CalibratedSensor(
-            token="cs1", channel="CAM_FRONT", modality="camera",
+            token="cs1", channel="cam_front", modality="camera",
             translation=np.zeros(3), rotation=np.array([0, 0, 0, 1.0]),
-            camera_intrinsic={"fx": 1266.4, "fy": 1266.4, "cx": 816.3, "cy": 491.5,
-                              "k1": 0.0, "k2": 0.0, "k3": 0.0, "p1": 0.0, "p2": 0.0},
+            intrinsics={"camera_model": "pinhole",
+                        "fx": 1266.4, "fy": 1266.4, "cx": 816.3, "cy": 491.5,
+                        "image_width": 1600, "image_height": 900},
+            distortion={"model": "plumb_bob",
+                        "k1": 0.0, "k2": 0.0, "k3": 0.0, "p1": 0.0, "p2": 0.0},
         )
         assert cs.modality == "camera"
-        assert cs.camera_intrinsic["fx"] == 1266.4
+        assert cs.intrinsics["fx"] == 1266.4
+        assert cs.distortion["model"] == "plumb_bob"
 
 
 class TestAnnotation:

{x4d_devkit-0.3.0 → x4d_devkit-0.4.0}/tests/test_nuscenes_converter.py

@@ -108,11 +108,10 @@ class TestIntrinsicConversion:
         assert result["fy"] == pytest.approx(1266.4)
         assert result["cx"] == pytest.approx(816.3)
         assert result["cy"] == pytest.approx(491.5)
-        assert result["k1"] == 0.0
-        assert result["k2"] == 0.0
-        assert result["k3"] == 0.0
-        assert result["p1"] == 0.0
-        assert result["p2"] == 0.0
+        assert result["camera_model"] == "pinhole"
+        # Image dimensions default to nuScenes standard 1600x900 when not given.
+        assert result["image_width"] == 1600
+        assert result["image_height"] == 900
 
     def test_empty_intrinsic(self):
         """nuScenes uses empty list for non-camera sensors."""
@@ -185,8 +184,10 @@ class TestNuScenesConverterExtraction:
         # Check named fields
         assert "x" in cam_front["translation"]
         assert "qx" in cam_front["rotation"]
-        assert cam_front["camera_intrinsic"] is not None
-        assert "fx" in cam_front["camera_intrinsic"]
+        assert cam_front["intrinsics"] is not None
+        assert "fx" in cam_front["intrinsics"]
+        assert cam_front["intrinsics"]["camera_model"] == "pinhole"
+        assert "child_frame" not in cam_front  # dropped in v0.4
 
     def test_ego_poses_local_coordinates(self, converter):
         scene = converter.nusc.scene[0]

{x4d_devkit-0.3.0 → x4d_devkit-0.4.0}/tests/test_validation.py

@@ -55,12 +55,12 @@ def valid_clip(tmp_path):
             [
                 {
                     "calibrated_sensor_token": "cs_lidar",
-                    "channel": "LIDAR_TOP",
+                    "channel": "lidar_top",
                     "parent_frame": "base_link",
-                    "child_frame": "lidar_top",
                     "translation": {"x": 0, "y": 0, "z": 1.8},
                     "rotation": {"qx": 0, "qy": 0, "qz": 0, "qw": 1},
-                    "camera_intrinsic": None,
+                    "intrinsics": None,
+                    "distortion": None,
                 }
             ]
         )

{x4d_devkit-0.3.0 → x4d_devkit-0.4.0}/x4d_devkit/converters/nuscenes.py

@@ -32,20 +32,26 @@ def size_wlh_to_named(size: list[float]) -> dict[str, float]:
     return {"length": size[1], "width": size[0], "height": size[2]}
 
 
-def intrinsic_matrix_to_named(matrix: list[list[float]]) -> dict[str, float] | None:
-    """Convert 3x3 intrinsic matrix to X4D named fields. Returns None for empty."""
+def intrinsic_matrix_to_named(
+    matrix: list[list[float]],
+    image_width: int | None = None,
+    image_height: int | None = None,
+) -> dict[str, float] | None:
+    """Convert 3x3 intrinsic matrix to X4D v0.4 intrinsics dict. Returns None for empty.
+
+    nuScenes does not record image dimensions per-sensor; they default to the
+    standard 1600x900 used by the dataset when not provided.
+    """
     if not matrix:
         return None
     return {
+        "camera_model": "pinhole",
         "fx": matrix[0][0],
         "fy": matrix[1][1],
         "cx": matrix[0][2],
         "cy": matrix[1][2],
-        "k1": 0.0,
-        "k2": 0.0,
-        "k3": 0.0,
-        "p1": 0.0,
-        "p2": 0.0,
+        "image_width": int(image_width) if image_width is not None else 1600,
+        "image_height": int(image_height) if image_height is not None else 900,
     }
 
 
@@ -238,21 +244,22 @@ class NuScenesConverter:
             sensor = self._sensor_by_token[cs["sensor_token"]]
 
             parent_frame = "base_link"
-            child_frame = channel.lower()
+
+            intrinsics = (
+                intrinsic_matrix_to_named(cs["camera_intrinsic"])
+                if sensor["modality"] == "camera"
+                else None
+            )
 
             records.append(
                 {
                     "calibrated_sensor_token": generate_token(clip_id, f"cs:{channel}"),
                     "channel": channel,
                     "parent_frame": parent_frame,
-                    "child_frame": child_frame,
                     "translation": translation_to_named(cs["translation"]),
                     "rotation": quat_wxyz_to_named(cs["rotation"]),
-                    "camera_intrinsic": intrinsic_matrix_to_named(
-                        cs["camera_intrinsic"]
-                    )
-                    if sensor["modality"] == "camera"
-                    else None,
+                    "intrinsics": intrinsics,
+                    "distortion": None,
                 }
             )
         return records

{x4d_devkit-0.3.0 → x4d_devkit-0.4.0}/x4d_devkit/core/loader.py

@@ -115,13 +115,15 @@ class ClipLoader:
         for r in records:
             t = r["translation"]
             q = r["rotation"]
+            intr = r.get("intrinsics")
             result.append(CalibratedSensor(
                 token=r["calibrated_sensor_token"],
                 channel=r["channel"],
-                modality="lidar" if r["camera_intrinsic"] is None else "camera",
+                modality="camera" if intr is not None else "lidar",
                 translation=[t["x"], t["y"], t["z"]],
                 rotation=[q["qx"], q["qy"], q["qz"], q["qw"]],
-                camera_intrinsic=r["camera_intrinsic"],
+                intrinsics=intr,
+                distortion=r.get("distortion"),
             ))
         return result
 

{x4d_devkit-0.3.0 → x4d_devkit-0.4.0}/x4d_devkit/core/models.py

@@ -53,11 +53,14 @@ class CalibratedSensor:
 
     Attributes:
         token: Unique token for this calibrated sensor record.
-        channel: Sensor channel name (e.g. "LIDAR_TOP", "CAM_FRONT").
+        channel: Sensor channel name — equals the ROS frame_id of the sensor
+            (e.g. "lidar_top", "cam_front_left").
         modality: "lidar" or "camera".
         translation: (3,) float64 array — sensor position in ego frame [x, y, z] meters.
         rotation: (4,) float64 array — sensor orientation as quaternion [qx, qy, qz, qw].
-        camera_intrinsic: Camera intrinsic parameters (fx, fy, cx, cy), or None for LiDAR.
+        intrinsics: Full camera intrinsics dict (camera_model, fx, fy, cx, cy,
+            image_width, image_height) or None for LiDAR.
+        distortion: Distortion model dict (model + coefficients) or None.
     """
 
     token: str
@@ -65,7 +68,8 @@ class CalibratedSensor:
     modality: str
     translation: np.ndarray
     rotation: np.ndarray
-    camera_intrinsic: dict[str, float] | None
+    intrinsics: dict | None
+    distortion: dict | None
 
     def __post_init__(self) -> None:
         object.__setattr__(self, "translation", np.asarray(self.translation, dtype=np.float64))

{x4d_devkit-0.3.0 → x4d_devkit-0.4.0/x4d_devkit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: x4d-devkit
-Version: 0.3.0
+Version: 0.4.0
 Summary: X-4D dataset format SDK — load, validate, evaluate, and convert autonomous driving datasets
 Author: windzu
 License-Expression: Apache-2.0