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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: euler-loading
-Version: 2.19.1
+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.19.1 → euler_loading-2.21.0}/euler_loading/loaders/cpu/princeton_dense.py

@@ -24,6 +24,13 @@ import numpy as np
 from PIL import Image
 
 from euler_loading.loaders._annotations import modality_meta
+from euler_loading.loaders._writer_utils import (
+    ensure_parent,
+    mark_stream_supported,
+    save_image,
+    to_hwc_rgb,
+    to_uint8,
+)
 from euler_loading.loaders._princeton_dense import DEFAULT_CAMERA_FRAME
 from euler_loading.loaders._princeton_dense import DEFAULT_LIDAR_FRAME
 from euler_loading.loaders._princeton_dense import LIDAR_COLUMNS
@@ -73,6 +80,18 @@ def rgb(
     return np.array(Image.open(path).convert("RGB"), dtype=np.float32) / 255.0
 
 
+@mark_stream_supported
+def write_rgb(
+    path: Union[str, BinaryIO],
+    value: Any,
+    meta: dict[str, Any] | None = None,
+) -> None:
+    """Write an RGB array/tensor as an 8-bit PNG."""
+    ensure_parent(path)
+    arr = to_uint8(to_hwc_rgb(value, name="rgb"), scale_unit_range=True)
+    save_image(path, Image.fromarray(arr, mode="RGB"), format="PNG")
+
+
 @modality_meta(
     modality_type="sparse_depth",
     dtype="float32",

{euler_loading-2.19.1 → 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.19.1 → 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.19.1 → euler_loading-2.21.0}/euler_loading/loaders/gpu/princeton_dense.py

@@ -25,6 +25,13 @@ from PIL import Image
 import torch
 
 from euler_loading.loaders._annotations import modality_meta
+from euler_loading.loaders._writer_utils import (
+    ensure_parent,
+    mark_stream_supported,
+    save_image,
+    to_hwc_rgb,
+    to_uint8,
+)
 from euler_loading.loaders._princeton_dense import DEFAULT_CAMERA_FRAME
 from euler_loading.loaders._princeton_dense import DEFAULT_LIDAR_FRAME
 from euler_loading.loaders._princeton_dense import LIDAR_COLUMNS
@@ -76,6 +83,18 @@ def rgb(
     return torch.from_numpy(arr).permute(2, 0, 1).contiguous()
 
 
+@mark_stream_supported
+def write_rgb(
+    path: Union[str, BinaryIO],
+    value: Any,
+    meta: dict[str, Any] | None = None,
+) -> None:
+    """Write an RGB tensor/array as an 8-bit PNG."""
+    ensure_parent(path)
+    arr = to_uint8(to_hwc_rgb(value, name="rgb"), scale_unit_range=True)
+    save_image(path, Image.fromarray(arr, mode="RGB"), format="PNG")
+
+
 @modality_meta(
     modality_type="sparse_depth",
     dtype="float32",

{euler_loading-2.19.1 → 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.19.1 → euler_loading-2.21.0}/pyproject.toml

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

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

@@ -165,6 +165,8 @@ PRINCETON_DENSE_LOADER_NAMES = [
     "read_extrinsics",
 ]
 
+PRINCETON_DENSE_WRITER_NAMES = ["write_rgb"]
+
 
 @pytest.fixture()
 def princeton_dense_rgb_path(tmp_path):
@@ -261,6 +263,18 @@ class TestPrincetonDenseModuleContents:
     def test_cpu_has_callable(self, name):
         assert callable(getattr(cpu_princeton_dense, name))
 
+    @pytest.mark.parametrize("name", PRINCETON_DENSE_WRITER_NAMES)
+    def test_top_level_has_writer(self, name):
+        assert callable(getattr(princeton_dense_top, name))
+
+    @pytest.mark.parametrize("name", PRINCETON_DENSE_WRITER_NAMES)
+    def test_gpu_has_writer(self, name):
+        assert callable(getattr(gpu_princeton_dense, name))
+
+    @pytest.mark.parametrize("name", PRINCETON_DENSE_WRITER_NAMES)
+    def test_cpu_has_writer(self, name):
+        assert callable(getattr(cpu_princeton_dense, name))
+
     def test_auto_resolution_uses_gpu_module(self):
         module = resolve_loader_module("princeton_dense")
         assert module.__name__ == "euler_loading.loaders.gpu.princeton_dense"
@@ -1097,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
 # ---------------------------------------------------------------------------

{euler_loading-2.19.1 → euler_loading-2.21.0}/tests/test_writing.py

@@ -14,6 +14,7 @@ from PIL import Image
 
 from euler_loading import Modality, MultiModalDataset, resolve_writer_module
 from euler_loading.loaders.gpu import vkitti2 as gpu_vkitti2
+from euler_loading.loaders.gpu import princeton_dense as gpu_princeton_dense
 
 from .conftest import dummy_loader
 
@@ -92,6 +93,55 @@ class TestWriterResolution:
 
         assert ds.get_writer("intrinsics") is gpu_vkitti2.write_intrinsics
 
+    def test_auto_resolves_princeton_dense_rgb_writer(self):
+        index = _flat_index(
+            "png",
+            ["f001"],
+            euler_loading={"loader": "princeton_dense", "function": "rgb"},
+        )
+        with patch(
+            "euler_loading.dataset.index_dataset_from_path",
+            return_value=index,
+        ):
+            ds = MultiModalDataset(modalities={"rgb": Modality("/data/rgb")})
+
+        assert ds.get_writer("rgb") is gpu_princeton_dense.write_rgb
+
+    @pytest.mark.parametrize(
+        "writer,chw",
+        [
+            (gpu_princeton_dense.write_rgb, True),
+            pytest.param(None, False, id="cpu"),
+        ],
+    )
+    def test_princeton_dense_rgb_writer_round_trip(self, tmp_path, writer, chw):
+        if writer is None:
+            from euler_loading.loaders.cpu import princeton_dense as cpu_princeton_dense
+
+            writer = cpu_princeton_dense.write_rgb
+        expected = np.array(
+            [[[0.0, 0.5, 1.0], [1.0, 0.25, 0.0]]],
+            dtype=np.float32,
+        )
+        value = np.transpose(expected, (2, 0, 1)) if chw else expected
+        path = tmp_path / ("gpu.png" if chw else "cpu.png")
+
+        writer(path, value)
+
+        actual = np.asarray(Image.open(path).convert("RGB"), dtype=np.float32) / 255.0
+        np.testing.assert_allclose(actual, expected, atol=1.0 / 255.0)
+
+    def test_princeton_dense_rgb_writer_supports_binary_stream(self):
+        stream = io.BytesIO()
+        gpu_princeton_dense.write_rgb(
+            stream,
+            np.ones((3, 2, 2), dtype=np.float32),
+        )
+        stream.seek(0)
+        image = Image.open(stream)
+        assert image.format == "PNG"
+        assert image.size == (2, 2)
+
 
 class TestWriteSample:
     def test_write_sample_preserves_relative_path(self, tmp_path):