x4d-devkit 0.6.0__tar.gz → 0.7.0__tar.gz

{x4d_devkit-0.6.0 → x4d_devkit-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: x4d-devkit
-Version: 0.6.0
+Version: 0.7.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.6.0 → x4d_devkit-0.7.0}/pyproject.toml

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

@@ -38,11 +38,14 @@ def _make_synthetic_clip(tmp_path: Path) -> Path:
         "sensors": {
             "LIDAR_TOP": {
                 "modality": "lidar",
-                "point_format": {"fields": ["x", "y", "z", "intensity"]}
+                "point_format": {
+                    "fields": ["x", "y", "z", "intensity"],
+                    "types": ["float32"] * 4,
+                    "bytes_per_point": 16,
+                },
             },
             "CAM_FRONT": {
                 "modality": "camera",
-                "point_format": None
             }
         }
     }))

{x4d_devkit-0.6.0 → x4d_devkit-0.7.0}/tests/test_models.py

@@ -9,6 +9,8 @@ from x4d_devkit.core.models import (
     SampleData,
     Annotation,
     Instance,
+    PointFormat,
+    SensorInfo,
 )
 
 
@@ -16,17 +18,21 @@ class TestClipMeta:
     def test_construction(self):
         meta = ClipMeta(
             clip_id="20180724_n015_scene-0061_000",
-            schema_version="0.1",
+            schema_version="0.5",
             session_id="n015-2018-07-24-11-22-45+0800",
             vehicle_id="n015",
             capture_time_utc="2018-07-24T00:00:00Z",
             duration_s=19.5,
             num_keyframes=39,
             num_sweeps=305,
-            sensors={"CAM_FRONT": {"modality": "camera", "resolution": [1600, 900]}},
+            sensors={
+                "CAM_FRONT": SensorInfo(modality="camera", resolution=(1600, 900)),
+            },
         )
         assert meta.clip_id == "20180724_n015_scene-0061_000"
         assert meta.num_keyframes == 39
+        assert meta.sensors["CAM_FRONT"].modality == "camera"
+        assert meta.sensors["CAM_FRONT"].resolution == (1600, 900)
 
     def test_frozen(self):
         meta = ClipMeta(
@@ -153,3 +159,74 @@ class TestInstance:
             first_annotation_token="a1", last_annotation_token="a5",
         )
         assert inst.num_annotations == 5
+
+
+class TestPointFormat:
+    def test_construction_normalises_to_tuples(self):
+        pf = PointFormat(
+            fields=["x", "y", "z", "intensity", "time"],
+            types=["float32"] * 5,
+            bytes_per_point=20,
+        )
+        assert isinstance(pf.fields, tuple)
+        assert isinstance(pf.types, tuple)
+        assert pf.num_fields == 5
+
+    def test_mismatched_lengths_rejected(self):
+        with pytest.raises(ValueError, match="must have equal length"):
+            PointFormat(fields=["x", "y", "z"], types=["float32", "float32"], bytes_per_point=12)
+
+    def test_round_trip_via_dict(self):
+        d = {
+            "fields": ["x", "y", "z", "intensity", "time"],
+            "types": ["float32"] * 5,
+            "bytes_per_point": 20,
+        }
+        pf = PointFormat.from_dict(d)
+        assert pf.to_dict() == d
+
+
+class TestSensorInfo:
+    def test_lidar_with_point_format(self):
+        d = {
+            "modality": "lidar",
+            "point_format": {
+                "fields": ["x", "y", "z", "intensity", "time"],
+                "types": ["float32"] * 5,
+                "bytes_per_point": 20,
+            },
+        }
+        si = SensorInfo.from_dict(d)
+        assert si.modality == "lidar"
+        assert si.point_format is not None
+        assert si.point_format.num_fields == 5
+        assert si.resolution is None
+        assert si.to_dict() == d
+
+    def test_camera_with_resolution(self):
+        d = {"modality": "camera", "resolution": [1600, 900]}
+        si = SensorInfo.from_dict(d)
+        assert si.modality == "camera"
+        assert si.point_format is None
+        assert si.resolution == (1600, 900)
+        assert si.to_dict() == d
+
+    def test_extras_round_trip(self):
+        """Unknown keys (e.g. producer-specific extras) survive a round-trip."""
+        d = {
+            "modality": "lidar",
+            "point_format": {
+                "fields": ["x", "y", "z"],
+                "types": ["float32", "float32", "float32"],
+                "bytes_per_point": 12,
+            },
+            "fused_from": ["lidar_top", "lidar_left"],
+        }
+        si = SensorInfo.from_dict(d)
+        assert si.extras == {"fused_from": ["lidar_top", "lidar_left"]}
+        out = si.to_dict()
+        assert out["fused_from"] == ["lidar_top", "lidar_left"]
+
+    def test_camera_no_point_format_in_dict(self):
+        si = SensorInfo.from_dict({"modality": "camera"})
+        assert si.point_format is None

{x4d_devkit-0.6.0 → x4d_devkit-0.7.0}/x4d_devkit/__init__.py

@@ -15,9 +15,11 @@ from x4d_devkit.core import (
     ClipMeta,
     EgoPose,
     Instance,
+    PointFormat,
     Sample,
     SampleData,
     SchemaVersionMismatch,
+    SensorInfo,
     Transform,
     TransformChain,
     generate_token,
@@ -47,9 +49,11 @@ __all__ = [
     "DetectionResult",
     "EgoPose",
     "Instance",
+    "PointFormat",
     "Sample",
     "SampleData",
     "SchemaVersionMismatch",
+    "SensorInfo",
     "Transform",
     "TransformChain",
     "ValidationReport",

{x4d_devkit-0.6.0 → x4d_devkit-0.7.0}/x4d_devkit/core/__init__.py

@@ -7,8 +7,10 @@ from x4d_devkit.core.models import (
     ClipMeta,
     EgoPose,
     Instance,
+    PointFormat,
     Sample,
     SampleData,
+    SensorInfo,
 )
 from x4d_devkit.core.token import generate_token
 from x4d_devkit.core.transform import Transform, TransformChain
@@ -20,9 +22,11 @@ __all__ = [
     "ClipMeta",
     "EgoPose",
     "Instance",
+    "PointFormat",
     "Sample",
     "SampleData",
     "SchemaVersionMismatch",
+    "SensorInfo",
     "Transform",
     "TransformChain",
     "generate_token",

{x4d_devkit-0.6.0 → x4d_devkit-0.7.0}/x4d_devkit/core/loader.py

@@ -17,6 +17,7 @@ from x4d_devkit.core.models import (
     SampleData,
     Annotation,
     Instance,
+    SensorInfo,
 )
 from x4d_devkit.core.transform import Transform, TransformChain, rotation_matrix_to_quat
 
@@ -122,6 +123,10 @@ class ClipLoader:
 
     def _load_meta(self) -> ClipMeta:
         d = self._read_json("meta.json")
+        sensors = {
+            channel: SensorInfo.from_dict(raw)
+            for channel, raw in (d.get("sensors") or {}).items()
+        }
         return ClipMeta(
             clip_id=d["clip_id"],
             schema_version=d["schema_version"],
@@ -131,7 +136,7 @@ class ClipLoader:
             duration_s=d["duration_s"],
             num_keyframes=d["keyframe_count"],
             num_sweeps=d["sweep_count"],
-            sensors=d["sensors"],
+            sensors=sensors,
         )
 
     def _load_calibrated_sensors(self) -> list[CalibratedSensor]:
@@ -400,8 +405,12 @@ class ClipLoader:
             raise ValueError(f"Invalid frame '{frame}', must be one of {_VALID_FRAMES}")
 
         sensor_info = self._meta.sensors[sd.channel]
-        pf = sensor_info["point_format"]
-        num_fields = len(pf["fields"])
+        if sensor_info.point_format is None:
+            raise ValueError(
+                f"channel '{sd.channel}' has no point_format in meta.json — "
+                f"cannot load as a point cloud (modality={sensor_info.modality})"
+            )
+        num_fields = sensor_info.point_format.num_fields
 
         path = self._clip_dir / sd.file_path
         raw = np.fromfile(str(path), dtype=np.float32)

{x4d_devkit-0.6.0 → x4d_devkit-0.7.0}/x4d_devkit/core/models.py

@@ -12,28 +12,119 @@ Coordinate conventions:
 
 from __future__ import annotations
 
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Any
 
 import numpy as np
 
 
+@dataclass(frozen=True)
+class PointFormat:
+    """Binary layout of a LiDAR point cloud .bin file.
+
+    Each point is laid out as ``len(fields)`` consecutive scalars of the
+    matching numpy dtype (``types[i]`` for ``fields[i]``). ``bytes_per_point``
+    is the on-disk stride in bytes.
+
+    Attributes:
+        fields: Per-component field names, e.g. ``["x", "y", "z", "intensity", "time"]``.
+        types: Per-component numpy dtype names, e.g. ``["float32", ...]``.
+        bytes_per_point: Total bytes per point on disk (== sum of dtype sizes).
+    """
+
+    fields: tuple[str, ...]
+    types: tuple[str, ...]
+    bytes_per_point: int
+
+    def __post_init__(self) -> None:
+        # Normalise sequences → immutable tuples for free hashability.
+        object.__setattr__(self, "fields", tuple(self.fields))
+        object.__setattr__(self, "types", tuple(self.types))
+        if len(self.fields) != len(self.types):
+            raise ValueError(
+                f"PointFormat: fields ({len(self.fields)}) and types "
+                f"({len(self.types)}) must have equal length"
+            )
+
+    @classmethod
+    def from_dict(cls, d: dict[str, Any]) -> PointFormat:
+        return cls(
+            fields=tuple(d["fields"]),
+            types=tuple(d["types"]),
+            bytes_per_point=int(d["bytes_per_point"]),
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "fields": list(self.fields),
+            "types": list(self.types),
+            "bytes_per_point": self.bytes_per_point,
+        }
+
+    @property
+    def num_fields(self) -> int:
+        return len(self.fields)
+
+
+@dataclass(frozen=True)
+class SensorInfo:
+    """Per-channel sensor metadata embedded in ``meta.json``.
+
+    Attributes:
+        modality: ``"lidar"`` or ``"camera"``.
+        point_format: Binary point layout (LiDAR only; ``None`` for cameras).
+        resolution: ``(width, height)`` in pixels (cameras only; ``None`` for LiDAR).
+        extras: Any additional fields the producer wrote into the sensor dict.
+            Preserved verbatim so ``to_dict()`` round-trips unknown keys.
+    """
+
+    modality: str
+    point_format: PointFormat | None = None
+    resolution: tuple[int, int] | None = None
+    extras: dict[str, Any] = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, d: dict[str, Any]) -> SensorInfo:
+        modality = d["modality"]
+        pf_raw = d.get("point_format")
+        point_format = PointFormat.from_dict(pf_raw) if pf_raw is not None else None
+        res_raw = d.get("resolution")
+        resolution = (int(res_raw[0]), int(res_raw[1])) if res_raw is not None else None
+        known = {"modality", "point_format", "resolution"}
+        extras = {k: v for k, v in d.items() if k not in known}
+        return cls(
+            modality=modality,
+            point_format=point_format,
+            resolution=resolution,
+            extras=extras,
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        out: dict[str, Any] = {"modality": self.modality}
+        if self.point_format is not None:
+            out["point_format"] = self.point_format.to_dict()
+        if self.resolution is not None:
+            out["resolution"] = list(self.resolution)
+        out.update(self.extras)
+        return out
+
+
 @dataclass(frozen=True)
 class ClipMeta:
     """Metadata for an X4D clip (from meta.json).
 
     Attributes:
         clip_id: Unique clip identifier (e.g. "20180724_n015_scene-0061_000").
-        schema_version: X4D format version (e.g. "0.2").
+        schema_version: X4D format version (e.g. "0.5").
         session_id: Recording session identifier.
         vehicle_id: Vehicle identifier.
         capture_time_utc: Capture timestamp in ISO 8601 format.
         duration_s: Clip duration in seconds.
         num_keyframes: Number of keyframes (annotated frames).
         num_sweeps: Number of sweep frames (non-annotated intermediate frames).
-        sensors: Sensor metadata dict, keyed by channel name. Each value
-            contains ``modality`` ("lidar"/"camera") and ``point_format``
-            (for LiDAR channels, describes binary file field layout).
+        sensors: Per-channel sensor metadata, keyed by channel name. Each
+            value is a ``SensorInfo`` carrying modality + (for LiDAR) the
+            binary ``PointFormat`` describing the .bin file layout.
     """
 
     clip_id: str
@@ -44,7 +135,7 @@ class ClipMeta:
     duration_s: float
     num_keyframes: int
     num_sweeps: int
-    sensors: dict[str, dict[str, Any]]
+    sensors: dict[str, SensorInfo]
 
 
 @dataclass(frozen=True)

{x4d_devkit-0.6.0 → x4d_devkit-0.7.0}/x4d_devkit.egg-info/PKG-INFO

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