euler-loading 2.20.0__tar.gz → 2.21.0__tar.gz

{euler_loading-2.20.0 → euler_loading-2.21.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: euler-loading
-Version: 2.20.0
+Version: 2.21.0
 Summary: Multi-modal PyTorch dataloader using ds-crawler indices
 Requires-Python: >=3.9
 Requires-Dist: ds-crawler>=2.3.0

{euler_loading-2.20.0 → euler_loading-2.21.0}/euler_loading/loaders/cpu/real_drive_sim.py

@@ -243,6 +243,95 @@ def read_intrinsics(path: Union[str, BinaryIO], meta: dict[str, Any] | None = No
     return intrinsics[sensor]
 
 
+DEFAULT_CAMERA_SENSOR = "CS_FRONT"
+DEFAULT_LIDAR_SENSOR = "HDL_64E"
+
+_SENSOR_ALIASES = {
+    "camera": DEFAULT_CAMERA_SENSOR,
+    "cam": DEFAULT_CAMERA_SENSOR,
+    "rgb": DEFAULT_CAMERA_SENSOR,
+    "front": DEFAULT_CAMERA_SENSOR,
+    "lidar": DEFAULT_LIDAR_SENSOR,
+    "hdl64": DEFAULT_LIDAR_SENSOR,
+    "hdl_64": DEFAULT_LIDAR_SENSOR,
+    "hdl32": "HDL_32E",
+    "hdl_32": "HDL_32E",
+}
+
+
+def _select_sensor(
+    meta: dict[str, Any] | None,
+    attributes: dict[str, Any] | None,
+    keys: tuple[str, ...],
+    default: str,
+) -> str:
+    """Resolve a sensor name from ``attributes`` (highest priority) or ``meta``."""
+    for source in (attributes, meta):
+        if not isinstance(source, dict):
+            continue
+        for key in keys:
+            value = source.get(key)
+            if isinstance(value, str) and value:
+                return _SENSOR_ALIASES.get(value.lower(), value)
+    return default
+
+
+@modality_meta(
+    modality_type="camera_extrinsics",
+    dtype="float32",
+    hierarchical=True,
+    shape="4x4",
+    file_formats=[".json"],
+    meta={
+        "dataset": "RealDriveSim",
+        "default_source_frame": DEFAULT_LIDAR_SENSOR,
+        "default_target_frame": DEFAULT_CAMERA_SENSOR,
+        "transform_direction": "source_frame_to_target_frame",
+    },
+)
+def read_extrinsics(path: Union[str, BinaryIO], meta: dict[str, Any] | None = None, *, attributes: dict[str, Any] | None = None) -> np.ndarray:
+    """Load a directed ``source -> target`` sensor transform.
+
+    Real Drive Sim stores one pose per sensor, each mapping that sensor's
+    coordinates into the shared vehicle frame. There is therefore no stored
+    sensor-to-sensor matrix; it is composed here::
+
+        X_target = inv(T_target) @ T_source @ X_source
+
+    The default is ``HDL_64E -> CS_FRONT``, suitable for projecting Real Drive
+    Sim lidar/sparse-depth points into the front camera. Override it with
+    ``meta`` or per-file ``attributes`` using ``source_frame`` /
+    ``source_sensor`` and ``target_frame`` / ``target_sensor``.
+
+    Returns a ``(4, 4)`` float32 homogeneous matrix, row-major.
+    """
+    sensors = calibration(path)
+
+    source = _select_sensor(
+        meta,
+        attributes,
+        ("source_frame", "source_sensor", "from_frame", "from_sensor", "source"),
+        DEFAULT_LIDAR_SENSOR,
+    )
+    target = _select_sensor(
+        meta,
+        attributes,
+        ("target_frame", "target_sensor", "to_frame", "to_sensor", "target", "camera"),
+        DEFAULT_CAMERA_SENSOR,
+    )
+
+    for role, sensor in (("source", source), ("target", target)):
+        if sensor not in sensors:
+            raise KeyError(
+                f"Real Drive Sim calibration has no {role} sensor {sensor!r}. "
+                f"Available sensors: {sorted(sensors)}"
+            )
+
+    T_source = np.asarray(sensors[source]["T"], dtype=np.float64)
+    T_target = np.asarray(sensors[target]["T"], dtype=np.float64)
+    return (np.linalg.inv(T_target) @ T_source).astype(np.float32)
+
+
 # ---------------------------------------------------------------------------
 # Writers
 # ---------------------------------------------------------------------------

{euler_loading-2.20.0 → euler_loading-2.21.0}/euler_loading/loaders/generate/loaders.json

@@ -20,6 +20,23 @@
                         "shape": "CHW"
                     }
                 },
+                {
+                    "type": "instance_segmentation",
+                    "function": "instance_segmentation",
+                    "hierarchical": false,
+                    "dtype": "uint16",
+                    "access": "key",
+                    "file_formats": [
+                        ".npy",
+                        ".npz"
+                    ],
+                    "cpu": {
+                        "shape": "HW"
+                    },
+                    "gpu": {
+                        "shape": "HW"
+                    }
+                },
                 {
                     "type": "intrinsics",
                     "function": "intrinsics",
@@ -105,6 +122,23 @@
                         "shape": "HW"
                     }
                 },
+                {
+                    "type": "semantic_segmentation",
+                    "function": "semantic_segmentation",
+                    "hierarchical": false,
+                    "dtype": "uint8",
+                    "access": "key",
+                    "file_formats": [
+                        ".npy",
+                        ".npz"
+                    ],
+                    "cpu": {
+                        "shape": "HW"
+                    },
+                    "gpu": {
+                        "shape": "HW"
+                    }
+                },
                 {
                     "type": "sh_coeffs",
                     "function": "sh_coeffs",
@@ -680,6 +714,28 @@
                         "shape": "1HW"
                     }
                 },
+                {
+                    "type": "camera_extrinsics",
+                    "function": "read_extrinsics",
+                    "hierarchical": true,
+                    "dtype": "float32",
+                    "access": "key",
+                    "file_formats": [
+                        ".json"
+                    ],
+                    "meta": {
+                        "dataset": "RealDriveSim",
+                        "default_source_frame": "HDL_64E",
+                        "default_target_frame": "CS_FRONT",
+                        "transform_direction": "source_frame_to_target_frame"
+                    },
+                    "cpu": {
+                        "shape": "4x4"
+                    },
+                    "gpu": {
+                        "shape": "4x4"
+                    }
+                },
                 {
                     "type": "intrinsics",
                     "function": "read_intrinsics",

{euler_loading-2.20.0 → euler_loading-2.21.0}/euler_loading/loaders/gpu/real_drive_sim.py

@@ -230,8 +230,103 @@ def all_intrinsics(path: Union[str, BinaryIO], meta: dict[str, Any] | None = Non
 )
 def read_intrinsics(path: Union[str, BinaryIO], meta: dict[str, Any] | None = None, *, attributes: dict[str, Any] | None = None) -> torch.Tensor:
     """Load the intrinsics for a specific sensor from a Real Drive Sim calibration JSON."""
+    sensor = (attributes or {}).get("sensor") or (meta or {}).get("sensor") or "CS_FRONT"
     all_intrinsics_data = all_intrinsics(path)
-    return all_intrinsics_data["CS_FRONT"]
+    if sensor not in all_intrinsics_data:
+        raise KeyError(
+            f"Real Drive Sim calibration has no intrinsics for sensor {sensor!r}. "
+            f"Available sensors: {sorted(all_intrinsics_data)}"
+        )
+    return all_intrinsics_data[sensor]
+
+
+DEFAULT_CAMERA_SENSOR = "CS_FRONT"
+DEFAULT_LIDAR_SENSOR = "HDL_64E"
+
+_SENSOR_ALIASES = {
+    "camera": DEFAULT_CAMERA_SENSOR,
+    "cam": DEFAULT_CAMERA_SENSOR,
+    "rgb": DEFAULT_CAMERA_SENSOR,
+    "front": DEFAULT_CAMERA_SENSOR,
+    "lidar": DEFAULT_LIDAR_SENSOR,
+    "hdl64": DEFAULT_LIDAR_SENSOR,
+    "hdl_64": DEFAULT_LIDAR_SENSOR,
+    "hdl32": "HDL_32E",
+    "hdl_32": "HDL_32E",
+}
+
+
+def _select_sensor(
+    meta: dict[str, Any] | None,
+    attributes: dict[str, Any] | None,
+    keys: tuple[str, ...],
+    default: str,
+) -> str:
+    """Resolve a sensor name from ``attributes`` (highest priority) or ``meta``."""
+    for source in (attributes, meta):
+        if not isinstance(source, dict):
+            continue
+        for key in keys:
+            value = source.get(key)
+            if isinstance(value, str) and value:
+                return _SENSOR_ALIASES.get(value.lower(), value)
+    return default
+
+
+@modality_meta(
+    modality_type="camera_extrinsics",
+    dtype="float32",
+    hierarchical=True,
+    shape="4x4",
+    file_formats=[".json"],
+    meta={
+        "dataset": "RealDriveSim",
+        "default_source_frame": DEFAULT_LIDAR_SENSOR,
+        "default_target_frame": DEFAULT_CAMERA_SENSOR,
+        "transform_direction": "source_frame_to_target_frame",
+    },
+)
+def read_extrinsics(path: Union[str, BinaryIO], meta: dict[str, Any] | None = None, *, attributes: dict[str, Any] | None = None) -> torch.Tensor:
+    """Load a directed ``source -> target`` sensor transform.
+
+    Real Drive Sim stores one pose per sensor, each mapping that sensor's
+    coordinates into the shared vehicle frame. There is therefore no stored
+    sensor-to-sensor matrix; it is composed here::
+
+        X_target = inv(T_target) @ T_source @ X_source
+
+    The default is ``HDL_64E -> CS_FRONT``, suitable for projecting Real Drive
+    Sim lidar/sparse-depth points into the front camera. Override it with
+    ``meta`` or per-file ``attributes`` using ``source_frame`` /
+    ``source_sensor`` and ``target_frame`` / ``target_sensor``.
+
+    Returns a ``(4, 4)`` float32 homogeneous tensor, row-major.
+    """
+    sensors = calibration(path)
+
+    source = _select_sensor(
+        meta,
+        attributes,
+        ("source_frame", "source_sensor", "from_frame", "from_sensor", "source"),
+        DEFAULT_LIDAR_SENSOR,
+    )
+    target = _select_sensor(
+        meta,
+        attributes,
+        ("target_frame", "target_sensor", "to_frame", "to_sensor", "target", "camera"),
+        DEFAULT_CAMERA_SENSOR,
+    )
+
+    for role, sensor in (("source", source), ("target", target)):
+        if sensor not in sensors:
+            raise KeyError(
+                f"Real Drive Sim calibration has no {role} sensor {sensor!r}. "
+                f"Available sensors: {sorted(sensors)}"
+            )
+
+    T_source = sensors[source]["T"].to(torch.float64)
+    T_target = sensors[target]["T"].to(torch.float64)
+    return (torch.linalg.inv(T_target) @ T_source).to(torch.float32).contiguous()
 
 
 # ---------------------------------------------------------------------------

{euler_loading-2.20.0 → euler_loading-2.21.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "euler-loading"
-version = "2.20.0"
+version = "2.21.0"
 description = "Multi-modal PyTorch dataloader using ds-crawler indices"
 requires-python = ">=3.9"
 dependencies = [

{euler_loading-2.20.0 → euler_loading-2.21.0}/tests/test_loaders.py

@@ -1111,6 +1111,89 @@ class TestRDSCPUCalibration:
         assert K[0, 0] == 0.0
 
 
+class TestRDSReadExtrinsics:
+    """Real Drive Sim composes sensor-to-sensor transforms from per-sensor poses.
+
+    The dataset stores one pose per sensor in a shared vehicle frame, so the
+    directed transform is derived: ``X_target = inv(T_target) @ T_source @ X_source``.
+    """
+
+    def test_defaults_to_lidar_to_front_camera(self):
+        T = cpu_rds.read_extrinsics(_RDS_CALIB_PATH)
+        assert T.shape == (4, 4)
+        assert T.dtype == np.float32
+        assert np.array_equal(T[3], np.array([0.0, 0.0, 0.0, 1.0], dtype=np.float32))
+
+    def test_matches_explicit_composition(self):
+        sensors = cpu_rds.calibration(_RDS_CALIB_PATH)
+        expected = np.linalg.inv(
+            sensors["CS_FRONT"]["T"].astype(np.float64)
+        ) @ sensors["HDL_64E"]["T"].astype(np.float64)
+        result = cpu_rds.read_extrinsics(_RDS_CALIB_PATH)
+        assert np.allclose(result, expected, atol=1e-6)
+
+    def test_same_source_and_target_is_identity(self):
+        T = cpu_rds.read_extrinsics(
+            _RDS_CALIB_PATH,
+            {"source_frame": "CS_FRONT", "target_frame": "CS_FRONT"},
+        )
+        assert np.allclose(T, np.eye(4), atol=1e-6)
+
+    def test_reversed_direction_is_the_inverse(self):
+        forward = cpu_rds.read_extrinsics(
+            _RDS_CALIB_PATH,
+            {"source_frame": "HDL_64E", "target_frame": "CS_FRONT"},
+        )
+        backward = cpu_rds.read_extrinsics(
+            _RDS_CALIB_PATH,
+            {"source_frame": "CS_FRONT", "target_frame": "HDL_64E"},
+        )
+        assert np.allclose(forward @ backward, np.eye(4), atol=1e-6)
+
+    def test_rotation_block_stays_orthonormal(self):
+        R = cpu_rds.read_extrinsics(_RDS_CALIB_PATH)[:3, :3]
+        assert np.allclose(R @ R.T, np.eye(3), atol=1e-6)
+        assert np.isclose(np.linalg.det(R), 1.0, atol=1e-6)
+
+    def test_sensor_aliases_resolve_to_canonical_names(self):
+        aliased = cpu_rds.read_extrinsics(
+            _RDS_CALIB_PATH, {"source_frame": "lidar", "target_frame": "camera"}
+        )
+        canonical = cpu_rds.read_extrinsics(
+            _RDS_CALIB_PATH,
+            {"source_frame": "HDL_64E", "target_frame": "CS_FRONT"},
+        )
+        assert np.array_equal(aliased, canonical)
+
+    def test_attributes_take_priority_over_meta(self):
+        result = cpu_rds.read_extrinsics(
+            _RDS_CALIB_PATH,
+            {"source_frame": "HDL_64E"},
+            attributes={"source_frame": "HDL_32E"},
+        )
+        expected = cpu_rds.read_extrinsics(_RDS_CALIB_PATH, {"source_frame": "HDL_32E"})
+        assert np.array_equal(result, expected)
+
+    def test_unknown_sensor_names_the_available_ones(self):
+        with pytest.raises(KeyError) as excinfo:
+            cpu_rds.read_extrinsics(_RDS_CALIB_PATH, {"target_frame": "NOT_A_SENSOR"})
+        message = str(excinfo.value)
+        assert "NOT_A_SENSOR" in message
+        assert "CS_FRONT" in message
+
+    def test_gpu_matches_cpu(self):
+        for kwargs in (
+            None,
+            {"source_frame": "HDL_32E"},
+            {"source_frame": "CS_FRONT", "target_frame": "HDL_64E"},
+        ):
+            cpu_result = cpu_rds.read_extrinsics(_RDS_CALIB_PATH, kwargs)
+            gpu_result = gpu_rds.read_extrinsics(_RDS_CALIB_PATH, kwargs)
+            assert gpu_result.shape == (4, 4)
+            assert gpu_result.dtype == torch.float32
+            assert np.allclose(cpu_result, gpu_result.numpy(), atol=1e-6)
+
+
 # ---------------------------------------------------------------------------
 # Writer round-trip tests
 # ---------------------------------------------------------------------------