euler-loading 2.8.0__tar.gz → 2.9.0__tar.gz

{euler_loading-2.8.0 → euler_loading-2.9.0}/PKG-INFO

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

{euler_loading-2.8.0 → euler_loading-2.9.0}/README.md

@@ -309,7 +309,7 @@ When `Modality.loader` is `None`, euler-loading resolves the loader from the ds-
 }
 ```
 
-`loader` is the module name (`vkitti2`, `real_drive_sim`, or `generic_dense_depth`) and `function` is the function within that module. The GPU variant is used by default.
+`loader` is the module name (`vkitti2`, `real_drive_sim`, `muses`, or `generic_dense_depth`) and `function` is the function within that module. The GPU variant is used by default.
 
 Writer resolution uses the same module and function metadata:
 
@@ -439,6 +439,18 @@ All built-in loaders accept both filesystem paths (`str`) and in-memory buffers
 | `sky_mask` | Binary mask where class ID == 29 (sky) |
 | `calibration` | Per-sensor calibration from JSON: returns `dict[sensor_name, {"K": (3,3), "T": (4,4), "distortion": (8,)}]` (use with `hierarchical_modalities`) |
 
+### MUSES (`euler_loading.loaders.muses`)
+
+| Function | Description |
+|----------|-------------|
+| `rgb` | Frame-camera RGB image as float32, normalised to [0, 1] |
+| `reference_rgb` | Clear-weather reference RGB image as float32, normalised to [0, 1] |
+| `semantic_segmentation` | Single-channel Cityscapes `labelIds` or `labelTrainIds` PNG as class IDs |
+| `semantic_segmentation_color` | Cityscapes `labelColor` PNG as RGB uint8 labels |
+| `panoptic_segmentation` | COCO-style RGB panoptic PNG decoded to integer segment IDs |
+| `lidar_point_cloud` / `point_cloud` | Lidar `.bin` file as `(N, 6)` float64: `x, y, z, intensity, ring, timestamp` |
+| `sparse_depth` | Alias for MUSES lidar points for sparse-depth style workflows |
+
 ### Generic Dense Depth (`euler_loading.loaders.gpu.generic_dense_depth`)
 
 A format-agnostic loader that infers the loading strategy from the file extension. Useful for datasets that don't have a dedicated loader module.
@@ -450,7 +462,7 @@ A format-agnostic loader that infers the loading strategy from the file extensio
 | `sky_mask` | Binary mask by comparing pixels against `meta["sky_mask"]` (`[R, G, B]`). Requires `meta` |
 | `read_intrinsics` | Returns `meta["intrinsics"]` as a `(3, 3)` tensor. Ignores path; requires `meta` |
 
-CPU variants of all loaders live under `euler_loading.loaders.cpu.{vkitti2,real_drive_sim,generic_dense_depth}`.
+CPU variants of all loaders live under `euler_loading.loaders.cpu.{vkitti2,real_drive_sim,muses,generic_dense_depth}`.
 
 ### Flattening hierarchical modalities
 

{euler_loading-2.8.0 → euler_loading-2.9.0}/euler_loading/_resolution.py

@@ -23,6 +23,7 @@ _LOADER_MODULES: dict[str, str] = {
     "real_drive_sim": "euler_loading.loaders.gpu.real_drive_sim",
     "generic_dense_depth": "euler_loading.loaders.gpu.generic_dense_depth",
     "generic": "euler_loading.loaders.gpu.generic",
+    "muses": "euler_loading.loaders.gpu.muses",
 }
 
 

{euler_loading-2.8.0 → euler_loading-2.9.0}/euler_loading/loaders/__init__.py

@@ -23,4 +23,8 @@ Available submodules:
 
 - :mod:`euler_loading.loaders.gpu.vkitti2` — Virtual KITTI 2 (torch)
 - :mod:`euler_loading.loaders.cpu.vkitti2` — Virtual KITTI 2 (numpy)
+- :mod:`euler_loading.loaders.gpu.real_drive_sim` — Real Drive Sim (torch)
+- :mod:`euler_loading.loaders.cpu.real_drive_sim` — Real Drive Sim (numpy)
+- :mod:`euler_loading.loaders.gpu.muses` — MUSES (torch)
+- :mod:`euler_loading.loaders.cpu.muses` — MUSES (numpy)
 """

{euler_loading-2.8.0 → euler_loading-2.9.0}/euler_loading/loaders/cpu/__init__.py

@@ -8,4 +8,6 @@ requiring torch.
 Available submodules:
 
 - :mod:`euler_loading.loaders.cpu.vkitti2` — Virtual KITTI 2
+- :mod:`euler_loading.loaders.cpu.real_drive_sim` — Real Drive Sim
+- :mod:`euler_loading.loaders.cpu.muses` — MUSES
 """

euler_loading-2.9.0/euler_loading/loaders/cpu/muses.py

@@ -0,0 +1,180 @@
+"""CPU-oriented loader functions for the MUSES dataset.
+
+MUSES stores RGB camera frames, reference frames, semantic labels, panoptic
+labels, and lidar point clouds in separate modality folders.  These loaders
+return NumPy arrays for CPU-based processing.
+
+Return types
+------------
+- **rgb** / **reference_rgb** -- ``np.ndarray`` of shape ``(H, W, 3)``
+  float32 in ``[0, 1]``.
+- **semantic_segmentation** -- ``np.ndarray`` of shape ``(H, W)`` int64
+  containing raw Cityscapes ``labelIds`` or ``labelTrainIds``.
+- **semantic_segmentation_color** -- ``np.ndarray`` of shape ``(H, W, 3)``
+  uint8 containing Cityscapes RGB colours.
+- **panoptic_segmentation** -- ``np.ndarray`` of shape ``(H, W)`` int64
+  containing COCO-style panoptic segment IDs decoded from RGB.
+- **lidar_point_cloud** / **sparse_depth** -- ``np.ndarray`` of shape
+  ``(N, 6)`` float64 with columns ``x, y, z, intensity, ring, timestamp``.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Any, BinaryIO, Union
+
+import numpy as np
+from PIL import Image
+
+from euler_loading.loaders._annotations import modality_meta
+
+_LIDAR_COLUMNS = ["x", "y", "z", "intensity", "ring", "timestamp"]
+
+
+def _load_image_rgb(path: Union[str, BinaryIO]) -> np.ndarray:
+    """Load an image file as ``(H, W, 3)`` float32 in ``[0, 1]``."""
+    with Image.open(path) as image:
+        return np.array(image.convert("RGB"), dtype=np.float32) / 255.0
+
+
+def _load_single_channel_labels(path: Union[str, BinaryIO]) -> np.ndarray:
+    """Load a single-channel semantic label image as int64."""
+    with Image.open(path) as image:
+        arr = np.array(image, dtype=np.int64)
+    if arr.ndim != 2:
+        raise ValueError(
+            "MUSES semantic_segmentation expects a single-channel labelIds "
+            "or labelTrainIds PNG. Use semantic_segmentation_color for "
+            "labelColor PNG files."
+        )
+    return arr
+
+
+def _load_rgb_uint8(path: Union[str, BinaryIO]) -> np.ndarray:
+    """Load an RGB image without normalisation."""
+    with Image.open(path) as image:
+        return np.array(image.convert("RGB"), dtype=np.uint8)
+
+
+def _decode_panoptic_rgb(rgb: np.ndarray) -> np.ndarray:
+    """Decode COCO-style RGB panoptic IDs as ``R + 256*G + 256^2*B``."""
+    values = rgb.astype(np.int64)
+    return values[:, :, 0] + 256 * values[:, :, 1] + 65536 * values[:, :, 2]
+
+
+def _load_lidar_array(path: Union[str, BinaryIO]) -> np.ndarray:
+    """Load a MUSES lidar ``.bin`` file as an ``(N, 6)`` float64 array."""
+    if isinstance(path, (str, os.PathLike)):
+        arr = np.fromfile(path, dtype=np.float64)
+    else:
+        arr = np.frombuffer(path.read(), dtype=np.float64).copy()
+
+    if arr.size % 6 != 0:
+        name = getattr(path, "name", path)
+        raise ValueError(
+            f"MUSES lidar file {name!r} contains {arr.size} float64 values, "
+            "which is not divisible by 6."
+        )
+    return arr.reshape((-1, 6))
+
+
+@modality_meta(
+    modality_type="rgb",
+    dtype="float32",
+    shape="HWC",
+    file_formats=[".png"],
+    output_range=[0.0, 1.0],
+)
+def rgb(path: Union[str, BinaryIO], meta: dict[str, Any] | None = None, *, attributes: dict[str, Any] | None = None) -> np.ndarray:
+    """Load a MUSES frame-camera RGB image as float32 in ``[0, 1]``."""
+    return _load_image_rgb(path)
+
+
+@modality_meta(
+    modality_type="rgb",
+    dtype="float32",
+    shape="HWC",
+    file_formats=[".png"],
+    output_range=[0.0, 1.0],
+    meta={"source": "reference_frames"},
+)
+def reference_rgb(path: Union[str, BinaryIO], meta: dict[str, Any] | None = None, *, attributes: dict[str, Any] | None = None) -> np.ndarray:
+    """Load a MUSES clear-weather reference RGB image as float32 in ``[0, 1]``."""
+    return _load_image_rgb(path)
+
+
+@modality_meta(
+    modality_type="semantic_segmentation",
+    dtype="int64",
+    shape="HW",
+    file_formats=[".png"],
+    meta={
+        "encoding": "single_channel",
+        "supported_suffixes": ["labelIds", "labelTrainIds"],
+    },
+)
+def semantic_segmentation(path: Union[str, BinaryIO], meta: dict[str, Any] | None = None, *, attributes: dict[str, Any] | None = None) -> np.ndarray:
+    """Load MUSES ``labelIds`` or ``labelTrainIds`` semantic labels."""
+    return _load_single_channel_labels(path)
+
+
+@modality_meta(
+    modality_type="semantic_segmentation_color",
+    dtype="uint8",
+    shape="HWC",
+    file_formats=[".png"],
+    meta={"encoding": "rgb", "supported_suffixes": ["labelColor"]},
+)
+def semantic_segmentation_color(path: Union[str, BinaryIO], meta: dict[str, Any] | None = None, *, attributes: dict[str, Any] | None = None) -> np.ndarray:
+    """Load MUSES ``labelColor`` semantic labels as RGB uint8 values."""
+    return _load_rgb_uint8(path)
+
+
+@modality_meta(
+    modality_type="panoptic_segmentation",
+    dtype="int64",
+    shape="HW",
+    file_formats=[".png"],
+    meta={"encoding": "coco_rgb_id"},
+)
+def panoptic_segmentation(path: Union[str, BinaryIO], meta: dict[str, Any] | None = None, *, attributes: dict[str, Any] | None = None) -> np.ndarray:
+    """Load a MUSES panoptic PNG as an integer segment-ID map."""
+    return _decode_panoptic_rgb(_load_rgb_uint8(path))
+
+
+@modality_meta(
+    modality_type="point_cloud",
+    dtype="float64",
+    shape="NC",
+    file_formats=[".bin"],
+    meta={
+        "columns": _LIDAR_COLUMNS,
+        "coordinate_unit": "meters",
+        "timestamp_unit": "seconds",
+    },
+)
+def lidar_point_cloud(path: Union[str, BinaryIO], meta: dict[str, Any] | None = None, *, attributes: dict[str, Any] | None = None) -> np.ndarray:
+    """Load a MUSES lidar point cloud as ``(N, 6)`` float64."""
+    return _load_lidar_array(path)
+
+
+def point_cloud(path: Union[str, BinaryIO], meta: dict[str, Any] | None = None, *, attributes: dict[str, Any] | None = None) -> np.ndarray:
+    """Alias for :func:`lidar_point_cloud`."""
+    return _load_lidar_array(path)
+
+
+@modality_meta(
+    modality_type="sparse_depth",
+    dtype="float64",
+    shape="NC",
+    file_formats=[".bin"],
+    meta={
+        "representation": "point_cloud",
+        "columns": _LIDAR_COLUMNS,
+        "coordinate_unit": "meters",
+        "timestamp_unit": "seconds",
+    },
+)
+def sparse_depth(path: Union[str, BinaryIO], meta: dict[str, Any] | None = None, *, attributes: dict[str, Any] | None = None) -> np.ndarray:
+    """Load MUSES lidar points for sparse-depth style workflows."""
+    return _load_lidar_array(path)

{euler_loading-2.8.0 → euler_loading-2.9.0}/euler_loading/loaders/generate/loaders.json

@@ -219,6 +219,175 @@
                 }
             ]
         },
+        {
+            "name": "muses",
+            "modalities": [
+                {
+                    "type": "point_cloud",
+                    "function": "lidar_point_cloud",
+                    "hierarchical": false,
+                    "dtype": "float64",
+                    "access": "key",
+                    "file_formats": [
+                        ".bin"
+                    ],
+                    "meta": {
+                        "columns": [
+                            "x",
+                            "y",
+                            "z",
+                            "intensity",
+                            "ring",
+                            "timestamp"
+                        ],
+                        "coordinate_unit": "meters",
+                        "timestamp_unit": "seconds"
+                    },
+                    "cpu": {
+                        "shape": "NC"
+                    },
+                    "gpu": {
+                        "shape": "NC"
+                    }
+                },
+                {
+                    "type": "panoptic_segmentation",
+                    "function": "panoptic_segmentation",
+                    "hierarchical": false,
+                    "dtype": "int64",
+                    "access": "key",
+                    "file_formats": [
+                        ".png"
+                    ],
+                    "meta": {
+                        "encoding": "coco_rgb_id"
+                    },
+                    "cpu": {
+                        "shape": "HW"
+                    },
+                    "gpu": {
+                        "shape": "1HW"
+                    }
+                },
+                {
+                    "type": "rgb",
+                    "function": "reference_rgb",
+                    "hierarchical": false,
+                    "dtype": "float32",
+                    "access": "key",
+                    "output_range": [
+                        0.0,
+                        1.0
+                    ],
+                    "file_formats": [
+                        ".png"
+                    ],
+                    "meta": {
+                        "source": "reference_frames"
+                    },
+                    "cpu": {
+                        "shape": "HWC"
+                    },
+                    "gpu": {
+                        "shape": "CHW"
+                    }
+                },
+                {
+                    "type": "rgb",
+                    "function": "rgb",
+                    "hierarchical": false,
+                    "dtype": "float32",
+                    "access": "key",
+                    "output_range": [
+                        0.0,
+                        1.0
+                    ],
+                    "file_formats": [
+                        ".png"
+                    ],
+                    "cpu": {
+                        "shape": "HWC"
+                    },
+                    "gpu": {
+                        "shape": "CHW"
+                    }
+                },
+                {
+                    "type": "semantic_segmentation",
+                    "function": "semantic_segmentation",
+                    "hierarchical": false,
+                    "dtype": "int64",
+                    "access": "key",
+                    "file_formats": [
+                        ".png"
+                    ],
+                    "meta": {
+                        "encoding": "single_channel",
+                        "supported_suffixes": [
+                            "labelIds",
+                            "labelTrainIds"
+                        ]
+                    },
+                    "cpu": {
+                        "shape": "HW"
+                    },
+                    "gpu": {
+                        "shape": "1HW"
+                    }
+                },
+                {
+                    "type": "semantic_segmentation_color",
+                    "function": "semantic_segmentation_color",
+                    "hierarchical": false,
+                    "dtype": "uint8",
+                    "access": "key",
+                    "file_formats": [
+                        ".png"
+                    ],
+                    "meta": {
+                        "encoding": "rgb",
+                        "supported_suffixes": [
+                            "labelColor"
+                        ]
+                    },
+                    "cpu": {
+                        "shape": "HWC"
+                    },
+                    "gpu": {
+                        "shape": "CHW"
+                    }
+                },
+                {
+                    "type": "sparse_depth",
+                    "function": "sparse_depth",
+                    "hierarchical": false,
+                    "dtype": "float64",
+                    "access": "key",
+                    "file_formats": [
+                        ".bin"
+                    ],
+                    "meta": {
+                        "representation": "point_cloud",
+                        "columns": [
+                            "x",
+                            "y",
+                            "z",
+                            "intensity",
+                            "ring",
+                            "timestamp"
+                        ],
+                        "coordinate_unit": "meters",
+                        "timestamp_unit": "seconds"
+                    },
+                    "cpu": {
+                        "shape": "NC"
+                    },
+                    "gpu": {
+                        "shape": "NC"
+                    }
+                }
+            ]
+        },
         {
             "name": "real_drive_sim",
             "modalities": [

{euler_loading-2.8.0 → euler_loading-2.9.0}/euler_loading/loaders/gpu/__init__.py

@@ -7,4 +7,6 @@ All loaders return **torch tensors** suitable for direct GPU-based training.
 Available submodules:
 
 - :mod:`euler_loading.loaders.gpu.vkitti2` — Virtual KITTI 2
+- :mod:`euler_loading.loaders.gpu.real_drive_sim` — Real Drive Sim
+- :mod:`euler_loading.loaders.gpu.muses` — MUSES
 """

euler_loading-2.9.0/euler_loading/loaders/gpu/muses.py

@@ -0,0 +1,186 @@
+"""GPU-oriented loader functions for the MUSES dataset.
+
+MUSES stores RGB camera frames, reference frames, semantic labels, panoptic
+labels, and lidar point clouds in separate modality folders.  These loaders
+return PyTorch tensors for GPU-oriented training pipelines.
+
+Return types
+------------
+- **rgb** / **reference_rgb** -- ``torch.FloatTensor`` of shape
+  ``(3, H, W)`` in ``[0, 1]``.
+- **semantic_segmentation** -- ``torch.LongTensor`` of shape ``(1, H, W)``
+  containing raw Cityscapes ``labelIds`` or ``labelTrainIds``.
+- **semantic_segmentation_color** -- ``torch.ByteTensor`` of shape
+  ``(3, H, W)`` containing Cityscapes RGB colours.
+- **panoptic_segmentation** -- ``torch.LongTensor`` of shape ``(1, H, W)``
+  containing COCO-style panoptic segment IDs decoded from RGB.
+- **lidar_point_cloud** / **sparse_depth** -- ``torch.DoubleTensor`` of shape
+  ``(N, 6)`` with columns ``x, y, z, intensity, ring, timestamp``.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Any, BinaryIO, Union
+
+import numpy as np
+import torch
+from PIL import Image
+
+from euler_loading.loaders._annotations import modality_meta
+
+_LIDAR_COLUMNS = ["x", "y", "z", "intensity", "ring", "timestamp"]
+
+
+def _load_image_rgb(path: Union[str, BinaryIO]) -> np.ndarray:
+    """Load an image file as ``(H, W, 3)`` float32 in ``[0, 1]``."""
+    with Image.open(path) as image:
+        return np.array(image.convert("RGB"), dtype=np.float32) / 255.0
+
+
+def _load_single_channel_labels(path: Union[str, BinaryIO]) -> np.ndarray:
+    """Load a single-channel semantic label image as int64."""
+    with Image.open(path) as image:
+        arr = np.array(image, dtype=np.int64)
+    if arr.ndim != 2:
+        raise ValueError(
+            "MUSES semantic_segmentation expects a single-channel labelIds "
+            "or labelTrainIds PNG. Use semantic_segmentation_color for "
+            "labelColor PNG files."
+        )
+    return arr
+
+
+def _load_rgb_uint8(path: Union[str, BinaryIO]) -> np.ndarray:
+    """Load an RGB image without normalisation."""
+    with Image.open(path) as image:
+        return np.array(image.convert("RGB"), dtype=np.uint8)
+
+
+def _decode_panoptic_rgb(rgb: np.ndarray) -> np.ndarray:
+    """Decode COCO-style RGB panoptic IDs as ``R + 256*G + 256^2*B``."""
+    values = rgb.astype(np.int64)
+    return values[:, :, 0] + 256 * values[:, :, 1] + 65536 * values[:, :, 2]
+
+
+def _load_lidar_array(path: Union[str, BinaryIO]) -> np.ndarray:
+    """Load a MUSES lidar ``.bin`` file as an ``(N, 6)`` float64 array."""
+    if isinstance(path, (str, os.PathLike)):
+        arr = np.fromfile(path, dtype=np.float64)
+    else:
+        arr = np.frombuffer(path.read(), dtype=np.float64).copy()
+
+    if arr.size % 6 != 0:
+        name = getattr(path, "name", path)
+        raise ValueError(
+            f"MUSES lidar file {name!r} contains {arr.size} float64 values, "
+            "which is not divisible by 6."
+        )
+    return arr.reshape((-1, 6))
+
+
+@modality_meta(
+    modality_type="rgb",
+    dtype="float32",
+    shape="CHW",
+    file_formats=[".png"],
+    output_range=[0.0, 1.0],
+)
+def rgb(path: Union[str, BinaryIO], meta: dict[str, Any] | None = None, *, attributes: dict[str, Any] | None = None) -> torch.Tensor:
+    """Load a MUSES frame-camera RGB image as a float32 tensor in ``[0, 1]``."""
+    arr = _load_image_rgb(path)
+    return torch.from_numpy(arr).permute(2, 0, 1).contiguous()
+
+
+@modality_meta(
+    modality_type="rgb",
+    dtype="float32",
+    shape="CHW",
+    file_formats=[".png"],
+    output_range=[0.0, 1.0],
+    meta={"source": "reference_frames"},
+)
+def reference_rgb(path: Union[str, BinaryIO], meta: dict[str, Any] | None = None, *, attributes: dict[str, Any] | None = None) -> torch.Tensor:
+    """Load a MUSES clear-weather reference RGB image as float32 in ``[0, 1]``."""
+    arr = _load_image_rgb(path)
+    return torch.from_numpy(arr).permute(2, 0, 1).contiguous()
+
+
+@modality_meta(
+    modality_type="semantic_segmentation",
+    dtype="int64",
+    shape="1HW",
+    file_formats=[".png"],
+    meta={
+        "encoding": "single_channel",
+        "supported_suffixes": ["labelIds", "labelTrainIds"],
+    },
+)
+def semantic_segmentation(path: Union[str, BinaryIO], meta: dict[str, Any] | None = None, *, attributes: dict[str, Any] | None = None) -> torch.Tensor:
+    """Load MUSES ``labelIds`` or ``labelTrainIds`` semantic labels."""
+    arr = _load_single_channel_labels(path)
+    return torch.from_numpy(arr).unsqueeze(0).contiguous()
+
+
+@modality_meta(
+    modality_type="semantic_segmentation_color",
+    dtype="uint8",
+    shape="CHW",
+    file_formats=[".png"],
+    meta={"encoding": "rgb", "supported_suffixes": ["labelColor"]},
+)
+def semantic_segmentation_color(path: Union[str, BinaryIO], meta: dict[str, Any] | None = None, *, attributes: dict[str, Any] | None = None) -> torch.Tensor:
+    """Load MUSES ``labelColor`` semantic labels as RGB uint8 values."""
+    arr = _load_rgb_uint8(path)
+    return torch.from_numpy(arr).permute(2, 0, 1).contiguous()
+
+
+@modality_meta(
+    modality_type="panoptic_segmentation",
+    dtype="int64",
+    shape="1HW",
+    file_formats=[".png"],
+    meta={"encoding": "coco_rgb_id"},
+)
+def panoptic_segmentation(path: Union[str, BinaryIO], meta: dict[str, Any] | None = None, *, attributes: dict[str, Any] | None = None) -> torch.Tensor:
+    """Load a MUSES panoptic PNG as an integer segment-ID map."""
+    arr = _decode_panoptic_rgb(_load_rgb_uint8(path))
+    return torch.from_numpy(arr).unsqueeze(0).contiguous()
+
+
+@modality_meta(
+    modality_type="point_cloud",
+    dtype="float64",
+    shape="NC",
+    file_formats=[".bin"],
+    meta={
+        "columns": _LIDAR_COLUMNS,
+        "coordinate_unit": "meters",
+        "timestamp_unit": "seconds",
+    },
+)
+def lidar_point_cloud(path: Union[str, BinaryIO], meta: dict[str, Any] | None = None, *, attributes: dict[str, Any] | None = None) -> torch.Tensor:
+    """Load a MUSES lidar point cloud as ``(N, 6)`` float64."""
+    return torch.from_numpy(_load_lidar_array(path)).contiguous()
+
+
+def point_cloud(path: Union[str, BinaryIO], meta: dict[str, Any] | None = None, *, attributes: dict[str, Any] | None = None) -> torch.Tensor:
+    """Alias for :func:`lidar_point_cloud`."""
+    return torch.from_numpy(_load_lidar_array(path)).contiguous()
+
+
+@modality_meta(
+    modality_type="sparse_depth",
+    dtype="float64",
+    shape="NC",
+    file_formats=[".bin"],
+    meta={
+        "representation": "point_cloud",
+        "columns": _LIDAR_COLUMNS,
+        "coordinate_unit": "meters",
+        "timestamp_unit": "seconds",
+    },
+)
+def sparse_depth(path: Union[str, BinaryIO], meta: dict[str, Any] | None = None, *, attributes: dict[str, Any] | None = None) -> torch.Tensor:
+    """Load MUSES lidar points for sparse-depth style workflows."""
+    return torch.from_numpy(_load_lidar_array(path)).contiguous()

euler_loading-2.9.0/euler_loading/loaders/muses.py

@@ -0,0 +1,12 @@
+"""Loader functions for the MUSES dataset.
+
+This module re-exports the GPU-oriented loaders from
+:mod:`euler_loading.loaders.gpu.muses` for convenience.  For explicit
+control, import from :mod:`~euler_loading.loaders.gpu` or
+:mod:`~euler_loading.loaders.cpu` directly::
+
+    from euler_loading.loaders.gpu import muses   # torch tensors (CHW)
+    from euler_loading.loaders.cpu import muses   # numpy arrays  (HWC)
+"""
+
+from euler_loading.loaders.gpu.muses import *  # noqa: F401,F403

{euler_loading-2.8.0 → euler_loading-2.9.0}/package-lock.json

@@ -1,5 +1,5 @@
 {
-  "name": "euler-lo",
+  "name": "euler-load-muses",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {}

{euler_loading-2.8.0 → euler_loading-2.9.0}/pyproject.toml

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

{euler_loading-2.8.0 → euler_loading-2.9.0}/tests/test_loaders.py

@@ -2,22 +2,27 @@
 
 from __future__ import annotations
 
+import io
 from pathlib import Path
 
 import numpy as np
 import pytest
 import torch
+from PIL import Image
 
 from euler_loading.loaders import vkitti2
 from euler_loading.loaders import generic as generic_top
+from euler_loading.loaders import muses as muses_top
 from euler_loading.loaders.gpu import vkitti2 as gpu_vkitti2
 from euler_loading.loaders.gpu import real_drive_sim as gpu_rds
 from euler_loading.loaders.gpu import generic as gpu_generic
 from euler_loading.loaders.gpu import generic_dense_depth as gpu_generic_dense_depth
+from euler_loading.loaders.gpu import muses as gpu_muses
 from euler_loading.loaders.cpu import vkitti2 as cpu_vkitti2
 from euler_loading.loaders.cpu import real_drive_sim as cpu_rds
 from euler_loading.loaders.cpu import generic as cpu_generic
 from euler_loading.loaders.cpu import generic_dense_depth as cpu_generic_dense_depth
+from euler_loading.loaders.cpu import muses as cpu_muses
 
 # ---------------------------------------------------------------------------
 # Shared fixtures
@@ -143,6 +148,230 @@ class TestGenericDenseDepthAttributes:
         np.testing.assert_allclose(result, expected)
 
 
+# ---------------------------------------------------------------------------
+# MUSES loader smoke tests
+# ---------------------------------------------------------------------------
+
+MUSES_LOADER_NAMES = [
+    "rgb",
+    "reference_rgb",
+    "semantic_segmentation",
+    "semantic_segmentation_color",
+    "panoptic_segmentation",
+    "lidar_point_cloud",
+    "point_cloud",
+    "sparse_depth",
+]
+
+
+@pytest.fixture()
+def muses_rgb_path(tmp_path):
+    arr = np.array(
+        [
+            [[0, 64, 128], [255, 128, 0]],
+            [[32, 16, 8], [4, 2, 1]],
+        ],
+        dtype=np.uint8,
+    )
+    path = tmp_path / "REC0001_frame_000001_frame_camera.png"
+    Image.fromarray(arr, mode="RGB").save(path)
+    return str(path), arr
+
+
+@pytest.fixture()
+def muses_semantic_path(tmp_path):
+    arr = np.array([[0, 7], [24, 255]], dtype=np.uint8)
+    path = tmp_path / "REC0001_frame_000001_gt_labelTrainIds.png"
+    Image.fromarray(arr, mode="L").save(path)
+    return str(path), arr
+
+
+@pytest.fixture()
+def muses_semantic_color_path(tmp_path):
+    arr = np.array(
+        [
+            [[128, 64, 128], [70, 70, 70]],
+            [[220, 20, 60], [0, 0, 142]],
+        ],
+        dtype=np.uint8,
+    )
+    path = tmp_path / "REC0001_frame_000001_gt_labelColor.png"
+    Image.fromarray(arr, mode="RGB").save(path)
+    return str(path), arr
+
+
+@pytest.fixture()
+def muses_panoptic_path(tmp_path):
+    arr = np.array(
+        [
+            [[1, 0, 0], [2, 1, 0]],
+            [[3, 2, 1], [255, 255, 255]],
+        ],
+        dtype=np.uint8,
+    )
+    path = tmp_path / "REC0001_frame_000001_gt_panoptic.png"
+    Image.fromarray(arr, mode="RGB").save(path)
+    expected = (
+        arr[:, :, 0].astype(np.int64)
+        + 256 * arr[:, :, 1].astype(np.int64)
+        + 65536 * arr[:, :, 2].astype(np.int64)
+    )
+    return str(path), expected
+
+
+@pytest.fixture()
+def muses_lidar_path(tmp_path):
+    arr = np.array(
+        [
+            [1.0, 2.0, 3.0, 19.0, 1.0, 1671182560.125],
+            [4.0, 5.0, 6.0, 27.0, 5.0, 1671182560.250],
+        ],
+        dtype=np.float64,
+    )
+    path = tmp_path / "REC0001_frame_000001_lidar.bin"
+    arr.tofile(path)
+    return str(path), arr
+
+
+class TestMUSESModuleContents:
+    """The muses module exposes the expected loader functions."""
+
+    @pytest.mark.parametrize("name", MUSES_LOADER_NAMES)
+    def test_top_level_has_callable(self, name):
+        assert callable(getattr(muses_top, name))
+
+    @pytest.mark.parametrize("name", MUSES_LOADER_NAMES)
+    def test_gpu_has_callable(self, name):
+        assert callable(getattr(gpu_muses, name))
+
+    @pytest.mark.parametrize("name", MUSES_LOADER_NAMES)
+    def test_cpu_has_callable(self, name):
+        assert callable(getattr(cpu_muses, name))
+
+    def test_reference_rgb_is_marked_as_rgb_modality(self):
+        assert gpu_muses.reference_rgb._modality_meta["type"] == "rgb"
+        assert cpu_muses.reference_rgb._modality_meta["type"] == "rgb"
+
+
+class TestMUSESGPULoaders:
+    """GPU MUSES loaders produce torch tensors from minimal on-disk data."""
+
+    def test_rgb_shape_dtype_and_range(self, muses_rgb_path):
+        path, _ = muses_rgb_path
+        result = gpu_muses.rgb(path)
+        assert isinstance(result, torch.Tensor)
+        assert result.dtype == torch.float32
+        assert result.shape == (3, 2, 2)
+        assert result.min() >= 0.0
+        assert result.max() <= 1.0
+
+    def test_reference_rgb_matches_rgb_loader(self, muses_rgb_path):
+        path, _ = muses_rgb_path
+        assert torch.equal(gpu_muses.reference_rgb(path), gpu_muses.rgb(path))
+
+    def test_semantic_segmentation_is_single_channel_long(self, muses_semantic_path):
+        path, expected = muses_semantic_path
+        result = gpu_muses.semantic_segmentation(path)
+        assert result.dtype == torch.int64
+        assert result.shape == (1, 2, 2)
+        assert torch.equal(result, torch.from_numpy(expected.astype(np.int64)).unsqueeze(0))
+
+    def test_semantic_color_is_chw_uint8(self, muses_semantic_color_path):
+        path, expected = muses_semantic_color_path
+        result = gpu_muses.semantic_segmentation_color(path)
+        assert result.dtype == torch.uint8
+        assert result.shape == (3, 2, 2)
+        assert torch.equal(result, torch.from_numpy(expected).permute(2, 0, 1))
+
+    def test_panoptic_segmentation_decodes_rgb_ids(self, muses_panoptic_path):
+        path, expected = muses_panoptic_path
+        result = gpu_muses.panoptic_segmentation(path)
+        assert result.dtype == torch.int64
+        assert result.shape == (1, 2, 2)
+        assert torch.equal(result, torch.from_numpy(expected).unsqueeze(0))
+
+    def test_lidar_point_cloud_preserves_float64_columns(self, muses_lidar_path):
+        path, expected = muses_lidar_path
+        result = gpu_muses.lidar_point_cloud(path)
+        assert result.dtype == torch.float64
+        assert result.shape == (2, 6)
+        assert torch.equal(result, torch.from_numpy(expected))
+
+    def test_point_cloud_alias_matches_lidar_point_cloud(self, muses_lidar_path):
+        path, _ = muses_lidar_path
+        assert torch.equal(gpu_muses.point_cloud(path), gpu_muses.lidar_point_cloud(path))
+
+    def test_sparse_depth_matches_lidar_point_cloud(self, muses_lidar_path):
+        path, _ = muses_lidar_path
+        assert torch.equal(gpu_muses.sparse_depth(path), gpu_muses.lidar_point_cloud(path))
+
+
+class TestMUSESCPULoaders:
+    """CPU MUSES loaders produce numpy arrays from minimal on-disk data."""
+
+    def test_rgb_shape_dtype_and_range(self, muses_rgb_path):
+        path, _ = muses_rgb_path
+        result = cpu_muses.rgb(path)
+        assert isinstance(result, np.ndarray)
+        assert result.dtype == np.float32
+        assert result.shape == (2, 2, 3)
+        assert result.min() >= 0.0
+        assert result.max() <= 1.0
+
+    def test_semantic_segmentation_is_hw_int64(self, muses_semantic_path):
+        path, expected = muses_semantic_path
+        result = cpu_muses.semantic_segmentation(path)
+        assert result.dtype == np.int64
+        assert result.shape == (2, 2)
+        assert np.array_equal(result, expected.astype(np.int64))
+
+    def test_semantic_color_is_hwc_uint8(self, muses_semantic_color_path):
+        path, expected = muses_semantic_color_path
+        result = cpu_muses.semantic_segmentation_color(path)
+        assert result.dtype == np.uint8
+        assert result.shape == (2, 2, 3)
+        assert np.array_equal(result, expected)
+
+    def test_panoptic_segmentation_decodes_rgb_ids(self, muses_panoptic_path):
+        path, expected = muses_panoptic_path
+        result = cpu_muses.panoptic_segmentation(path)
+        assert result.dtype == np.int64
+        assert result.shape == (2, 2)
+        assert np.array_equal(result, expected)
+
+    def test_lidar_point_cloud_preserves_float64_columns(self, muses_lidar_path):
+        path, expected = muses_lidar_path
+        result = cpu_muses.lidar_point_cloud(path)
+        assert result.dtype == np.float64
+        assert result.shape == (2, 6)
+        assert np.array_equal(result, expected)
+
+    def test_point_cloud_alias_matches_lidar_point_cloud(self, muses_lidar_path):
+        path, _ = muses_lidar_path
+        assert np.array_equal(cpu_muses.point_cloud(path), cpu_muses.lidar_point_cloud(path))
+
+    def test_lidar_point_cloud_supports_binary_streams(self, muses_lidar_path):
+        _, expected = muses_lidar_path
+        stream = io.BytesIO(expected.tobytes())
+        result = cpu_muses.lidar_point_cloud(stream)
+        assert np.array_equal(result, expected)
+
+
+class TestMUSESBackwardCompat:
+    """``from euler_loading.loaders import muses`` returns GPU loaders."""
+
+    def test_top_level_rgb_matches_gpu(self, muses_rgb_path):
+        path, _ = muses_rgb_path
+        assert torch.equal(muses_top.rgb(path), gpu_muses.rgb(path))
+
+    def test_top_level_panoptic_matches_gpu(self, muses_panoptic_path):
+        path, _ = muses_panoptic_path
+        assert torch.equal(
+            muses_top.panoptic_segmentation(path),
+            gpu_muses.panoptic_segmentation(path),
+        )
+
+
 # ---------------------------------------------------------------------------
 # GPU loader smoke tests
 # ---------------------------------------------------------------------------