euler-loading 2.14.0__tar.gz → 2.18.0__tar.gz

{euler_loading-2.14.0 → euler_loading-2.18.0}/PKG-INFO

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

{euler_loading-2.14.0 → euler_loading-2.18.0}/README.md

@@ -381,7 +381,7 @@ When `Modality.loader` is `None`, euler-loading resolves the loader from the ds-
 }
 ```
 
-`loader` is the module name (`vkitti2`, `real_drive_sim`, `muses`, `princeton_dense`, 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`, `princeton_dense`, `generic`, 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:
 
@@ -550,7 +550,15 @@ 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,muses,princeton_dense,generic_dense_depth}`.
+### Generic NumPy Modalities (`euler_loading.loaders.gpu.generic`)
+
+Generic loaders for `.npy` and `.npz` modalities without dataset-specific decoding.
+
+| Function | Description |
+|----------|-------------|
+| `points_3d` | Dense 3D point map from NumPy files stored as `(3, H, W)` float32 |
+
+CPU variants of all loaders live under `euler_loading.loaders.cpu.{vkitti2,real_drive_sim,muses,princeton_dense,generic,generic_dense_depth}`.
 
 ### Flattening hierarchical modalities
 

{euler_loading-2.14.0 → euler_loading-2.18.0}/euler_loading/_resolution.py

@@ -58,9 +58,7 @@ def resolve_loader_module(name: str) -> ModuleType:
     module_path = _LOADER_MODULES.get(name)
     if module_path is None:
         available = ", ".join(sorted(_LOADER_MODULES))
-        raise ValueError(
-            f"Unknown loader {name!r}. Available loaders: {available}"
-        )
+        raise ValueError(f"Unknown loader {name!r}. Available loaders: {available}")
     return importlib.import_module(module_path)
 
 
@@ -132,7 +130,8 @@ def _resolve_loader(
     func = getattr(module, func_name, None)
     if func is None or not callable(func):
         available = [
-            attr for attr in dir(module)
+            attr
+            for attr in dir(module)
             if not attr.startswith("_") and callable(getattr(module, attr))
         ]
         raise ValueError(
@@ -150,7 +149,7 @@ def _writer_name_candidates(read_function_name: str, explicit: Any) -> list[str]
         names.append(explicit_name)
 
     if read_function_name.startswith("read_"):
-        names.append(f"write_{read_function_name[len('read_'):]}")
+        names.append(f"write_{read_function_name[len('read_') :]}")
     names.append(f"write_{read_function_name}")
 
     deduped: list[str] = []

{euler_loading-2.14.0 → euler_loading-2.18.0}/euler_loading/loaders/cpu/generic.py

@@ -12,6 +12,7 @@ Return types
 ------------
 - **map_2d** / **scattering_coefficient** -- ``np.ndarray`` of shape ``(H, W)`` float32.
 - **map_3d** / **atmospheric_light** -- ``np.ndarray`` of shape ``(H, W, C)`` float32.
+- **points_3d** -- ``np.ndarray`` of shape ``(3, H, W)`` float32.
 - **spherical_map** -- ``np.ndarray`` of shape ``(H, W, C)`` float32.
 - **intrinsics** -- ``np.ndarray`` of shape ``(3, 3)`` float32.
 - **sh_coeffs** -- ``np.ndarray`` of shape ``(N, 3)`` float32.
@@ -23,6 +24,7 @@ Usage::
 
     Modality("/data/my_dataset/scattering_coefficient", loader=generic.scattering_coefficient)
     Modality("/data/my_dataset/atmospheric_light",      loader=generic.atmospheric_light)
+    Modality("/data/my_dataset/points_3d",              loader=generic.points_3d)
     Modality("/data/my_dataset/spherical_map",          loader=generic.spherical_map)
     Modality("/data/my_dataset/intrinsics",             loader=generic.intrinsics)
     Modality("/data/my_dataset/sh_coeffs",              loader=generic.sh_coeffs)
@@ -85,6 +87,14 @@ def _write_numpy(path: Union[str, BinaryIO], value: Any) -> None:
     raise ValueError(f"Unsupported output extension: {ext}")
 
 
+def _as_3d_points(value: Any) -> np.ndarray:
+    """Return a float32 ``(3, H, W)`` array for dense 3D point maps."""
+    arr = to_numpy(value).astype(np.float32)
+    if arr.ndim != 3 or arr.shape[0] != 3:
+        raise ValueError(f"points_3d must have shape (3, H, W), got {arr.shape}")
+    return arr
+
+
 # ---------------------------------------------------------------------------
 # Public loaders
 # ---------------------------------------------------------------------------
@@ -124,6 +134,23 @@ def map_3d(path: Union[str, BinaryIO], meta: dict[str, Any] | None = None, *, at
     return np.transpose(arr, (1, 2, 0))
 
 
+@modality_meta(
+    modality_type="points_3d",
+    dtype="float32",
+    shape="3HW",
+    file_formats=[".npy", ".npz"],
+)
+def points_3d(path: Union[str, BinaryIO], meta: dict[str, Any] | None = None, *, attributes: dict[str, Any] | None = None) -> np.ndarray:
+    """Load dense 3D points as a ``(3, H, W)`` float32 array.
+
+    Files are expected to store the per-pixel 3D point coordinates directly in
+    ``(3, H, W)`` layout.  Unlike :func:`map_3d`, this loader preserves the
+    channel-first representation on CPU because it is a coordinate point map,
+    not a generic HWC image-style map.
+    """
+    return _as_3d_points(_load_numpy(path))
+
+
 @modality_meta(
     modality_type="scattering_coefficient",
     dtype="float32",
@@ -239,6 +266,12 @@ def write_map_3d(path: Union[str, BinaryIO], value: Any, meta: dict[str, Any] |
     raise ValueError(f"Unsupported map_3d output extension: {ext}")
 
 
+@mark_stream_supported
+def write_points_3d(path: Union[str, BinaryIO], value: Any, meta: dict[str, Any] | None = None) -> None:
+    """Write dense 3D points to NumPy formats in ``(3, H, W)`` layout."""
+    _write_numpy(path, _as_3d_points(value))
+
+
 @mark_stream_supported
 def write_scattering_coefficient(path: Union[str, BinaryIO], value: Any, meta: dict[str, Any] | None = None) -> None:
     """Write a scattering-coefficient map (delegates to :func:`write_map_2d`)."""

{euler_loading-2.14.0 → euler_loading-2.18.0}/euler_loading/loaders/cpu/princeton_dense.py

@@ -5,6 +5,7 @@ images and Velodyne lidar point clouds as binary ``float32`` records.
 
 Return types
 ------------
+- **rccb** -- ``np.ndarray`` of shape ``(H, W, 3)`` float32 in ``[0, 1]``.
 - **rgb** -- ``np.ndarray`` of shape ``(H, W, 3)`` float32 in ``[0, 1]``.
 - **sparse_depth** -- ``np.ndarray`` of shape ``(N, 5)`` float32 with columns
   ``x, y, z, intensity, ring``.
@@ -20,6 +21,7 @@ from __future__ import annotations
 from typing import Any, BinaryIO, Union
 
 import numpy as np
+from PIL import Image
 
 from euler_loading.loaders._annotations import modality_meta
 from euler_loading.loaders._princeton_dense import DEFAULT_CAMERA_FRAME
@@ -32,7 +34,7 @@ from euler_loading.loaders._princeton_dense import load_sparse_depth_array
 
 
 @modality_meta(
-    modality_type="rgb",
+    modality_type="rccb",
     dtype="float32",
     shape="HWC",
     file_formats=[".tif", ".tiff"],
@@ -44,16 +46,33 @@ from euler_loading.loaders._princeton_dense import load_sparse_depth_array
         "raw_max_value": 4095.0,
     },
 )
-def rgb(
+def rccb(
     path: Union[str, BinaryIO],
     meta: dict[str, Any] | None = None,
     *,
     attributes: dict[str, Any] | None = None,
 ) -> np.ndarray:
-    """Load a SeeingThroughFog 12-bit Bayer TIFF as RGB float32 in ``[0, 1]``."""
+    """Load a SeeingThroughFog 12-bit Bayer TIFF as RCCB float32 in ``[0, 1]``."""
     return load_rgb_array(path, meta, attributes)
 
 
+@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 SeeingThroughFog plain 8-bit PNG as RGB float32 in ``[0, 1]``."""
+    return np.array(Image.open(path).convert("RGB"), dtype=np.float32) / 255.0
+
+
 @modality_meta(
     modality_type="sparse_depth",
     dtype="float32",

{euler_loading-2.14.0 → euler_loading-2.18.0}/euler_loading/loaders/generate/loaders.json

@@ -71,6 +71,23 @@
                         "shape": "CHW"
                     }
                 },
+                {
+                    "type": "points_3d",
+                    "function": "points_3d",
+                    "hierarchical": false,
+                    "dtype": "float32",
+                    "access": "key",
+                    "file_formats": [
+                        ".npy",
+                        ".npz"
+                    ],
+                    "cpu": {
+                        "shape": "3HW"
+                    },
+                    "gpu": {
+                        "shape": "3HW"
+                    }
+                },
                 {
                     "type": "scattering_coefficient",
                     "function": "scattering_coefficient",
@@ -456,6 +473,33 @@
         {
             "name": "princeton_dense",
             "modalities": [
+                {
+                    "type": "rccb",
+                    "function": "rccb",
+                    "hierarchical": false,
+                    "dtype": "float32",
+                    "access": "key",
+                    "output_range": [
+                        0.0,
+                        1.0
+                    ],
+                    "file_formats": [
+                        ".tif",
+                        ".tiff"
+                    ],
+                    "meta": {
+                        "dataset": "SeeingThroughFog",
+                        "raw_bit_depth": 12,
+                        "bayer_pattern": "GBRG",
+                        "raw_max_value": 4095.0
+                    },
+                    "cpu": {
+                        "shape": "HWC"
+                    },
+                    "gpu": {
+                        "shape": "CHW"
+                    }
+                },
                 {
                     "type": "camera_extrinsics",
                     "function": "read_extrinsics",
@@ -510,15 +554,8 @@
                         1.0
                     ],
                     "file_formats": [
-                        ".tif",
-                        ".tiff"
+                        ".png"
                     ],
-                    "meta": {
-                        "dataset": "SeeingThroughFog",
-                        "raw_bit_depth": 12,
-                        "bayer_pattern": "GBRG",
-                        "raw_max_value": 4095.0
-                    },
                     "cpu": {
                         "shape": "HWC"
                     },

{euler_loading-2.14.0 → euler_loading-2.18.0}/euler_loading/loaders/gpu/generic.py

@@ -12,6 +12,7 @@ Return types
 ------------
 - **map_2d** / **scattering_coefficient** -- ``torch.FloatTensor`` of shape ``(H, W)``.
 - **map_3d** / **atmospheric_light** -- ``torch.FloatTensor`` of shape ``(C, H, W)``.
+- **points_3d** -- ``torch.FloatTensor`` of shape ``(3, H, W)``.
 - **spherical_map** -- ``torch.FloatTensor`` of shape ``(C, H, W)``.
 - **intrinsics** -- ``torch.FloatTensor`` of shape ``(3, 3)``.
 - **sh_coeffs** -- ``torch.FloatTensor`` of shape ``(N, 3)``.
@@ -23,6 +24,7 @@ Usage::
 
     Modality("/data/my_dataset/scattering_coefficient", loader=generic.scattering_coefficient)
     Modality("/data/my_dataset/atmospheric_light",      loader=generic.atmospheric_light)
+    Modality("/data/my_dataset/points_3d",              loader=generic.points_3d)
     Modality("/data/my_dataset/spherical_map",          loader=generic.spherical_map)
     Modality("/data/my_dataset/intrinsics",             loader=generic.intrinsics)
     Modality("/data/my_dataset/sh_coeffs",              loader=generic.sh_coeffs)
@@ -86,6 +88,14 @@ def _write_numpy(path: Union[str, BinaryIO], value: Any) -> None:
     raise ValueError(f"Unsupported output extension: {ext}")
 
 
+def _as_3d_points(value: Any) -> np.ndarray:
+    """Return a float32 ``(3, H, W)`` array for dense 3D point maps."""
+    arr = to_numpy(value).astype(np.float32)
+    if arr.ndim != 3 or arr.shape[0] != 3:
+        raise ValueError(f"points_3d must have shape (3, H, W), got {arr.shape}")
+    return arr
+
+
 # ---------------------------------------------------------------------------
 # Public loaders
 # ---------------------------------------------------------------------------
@@ -125,6 +135,21 @@ def map_3d(path: Union[str, BinaryIO], meta: dict[str, Any] | None = None, *, at
     return torch.from_numpy(arr).contiguous()
 
 
+@modality_meta(
+    modality_type="points_3d",
+    dtype="float32",
+    shape="3HW",
+    file_formats=[".npy", ".npz"],
+)
+def points_3d(path: Union[str, BinaryIO], meta: dict[str, Any] | None = None, *, attributes: dict[str, Any] | None = None) -> torch.Tensor:
+    """Load dense 3D points as a ``(3, H, W)`` float32 tensor.
+
+    Files are expected to store the per-pixel 3D point coordinates directly in
+    ``(3, H, W)`` layout.
+    """
+    return torch.from_numpy(_as_3d_points(_load_numpy(path))).contiguous()
+
+
 @modality_meta(
     modality_type="scattering_coefficient",
     dtype="float32",
@@ -229,6 +254,12 @@ def write_map_3d(path: Union[str, BinaryIO], value: Any, meta: dict[str, Any] |
     _write_numpy(path, value)
 
 
+@mark_stream_supported
+def write_points_3d(path: Union[str, BinaryIO], value: Any, meta: dict[str, Any] | None = None) -> None:
+    """Write dense 3D points to NumPy formats in ``(3, H, W)`` layout."""
+    _write_numpy(path, _as_3d_points(value))
+
+
 @mark_stream_supported
 def write_scattering_coefficient(path: Union[str, BinaryIO], value: Any, meta: dict[str, Any] | None = None) -> None:
     """Write a scattering-coefficient map (delegates to :func:`write_map_2d`)."""

{euler_loading-2.14.0 → euler_loading-2.18.0}/euler_loading/loaders/gpu/princeton_dense.py

@@ -5,6 +5,7 @@ images and Velodyne lidar point clouds as binary ``float32`` records.
 
 Return types
 ------------
+- **rccb** -- ``torch.FloatTensor`` of shape ``(3, H, W)`` in ``[0, 1]``.
 - **rgb** -- ``torch.FloatTensor`` of shape ``(3, H, W)`` in ``[0, 1]``.
 - **sparse_depth** -- ``torch.FloatTensor`` of shape ``(N, 5)`` with columns
   ``x, y, z, intensity, ring``.
@@ -19,6 +20,8 @@ from __future__ import annotations
 
 from typing import Any, BinaryIO, Union
 
+import numpy as np
+from PIL import Image
 import torch
 
 from euler_loading.loaders._annotations import modality_meta
@@ -32,7 +35,7 @@ from euler_loading.loaders._princeton_dense import load_sparse_depth_array
 
 
 @modality_meta(
-    modality_type="rgb",
+    modality_type="rccb",
     dtype="float32",
     shape="CHW",
     file_formats=[".tif", ".tiff"],
@@ -44,17 +47,35 @@ from euler_loading.loaders._princeton_dense import load_sparse_depth_array
         "raw_max_value": 4095.0,
     },
 )
-def rgb(
+def rccb(
     path: Union[str, BinaryIO],
     meta: dict[str, Any] | None = None,
     *,
     attributes: dict[str, Any] | None = None,
 ) -> torch.Tensor:
-    """Load a SeeingThroughFog 12-bit Bayer TIFF as an RGB tensor."""
+    """Load a SeeingThroughFog 12-bit Bayer TIFF as an RCCB tensor."""
     arr = load_rgb_array(path, meta, attributes)
     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],
+)
+def rgb(
+    path: Union[str, BinaryIO],
+    meta: dict[str, Any] | None = None,
+    *,
+    attributes: dict[str, Any] | None = None,
+) -> torch.Tensor:
+    """Load a SeeingThroughFog plain 8-bit PNG as an RGB tensor."""
+    arr = np.array(Image.open(path).convert("RGB"), dtype=np.float32) / 255.0
+    return torch.from_numpy(arr).permute(2, 0, 1).contiguous()
+
+
 @modality_meta(
     modality_type="sparse_depth",
     dtype="float32",

euler_loading-2.18.0/gen_loaders.sh

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+cd "$SCRIPT_DIR"
+
+"${PYTHON:-python}" -m euler_loading.loaders.generate

{euler_loading-2.14.0 → euler_loading-2.18.0}/package-lock.json

@@ -1,5 +1,5 @@
 {
-  "name": "loading-dense",
+  "name": "euler-loading-3d",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {}

{euler_loading-2.14.0 → euler_loading-2.18.0}/pyproject.toml

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

{euler_loading-2.14.0 → euler_loading-2.18.0}/tests/test_loaders.py

@@ -159,6 +159,7 @@ class TestGenericDenseDepthAttributes:
 
 PRINCETON_DENSE_LOADER_NAMES = [
     "rgb",
+    "rccb",
     "sparse_depth",
     "read_intrinsics",
     "read_extrinsics",
@@ -167,6 +168,14 @@ PRINCETON_DENSE_LOADER_NAMES = [
 
 @pytest.fixture()
 def princeton_dense_rgb_path(tmp_path):
+    arr = np.full((4, 4, 3), 128, dtype=np.uint8)
+    path = tmp_path / "2018-02-05_12-09-01_00000.png"
+    Image.fromarray(arr).save(path)
+    return str(path)
+
+
+@pytest.fixture()
+def princeton_dense_rccb_path(tmp_path):
     arr = np.full((4, 4), 2048, dtype=np.uint16)
     path = tmp_path / "2018-02-05_12-09-01_00000.tiff"
     Image.fromarray(arr).save(path)
@@ -264,6 +273,14 @@ class TestPrincetonDenseModuleContents:
 class TestPrincetonDenseGPULoaders:
     """GPU Princeton DENSE loaders produce torch tensors."""
 
+    def test_rccb_shape_dtype_and_range(self, princeton_dense_rccb_path):
+        result = gpu_princeton_dense.rccb(princeton_dense_rccb_path)
+        assert isinstance(result, torch.Tensor)
+        assert result.dtype == torch.float32
+        assert result.shape == (3, 4, 4)
+        assert result.min() >= 0.0
+        assert result.max() <= 1.0
+
     def test_rgb_shape_dtype_and_range(self, princeton_dense_rgb_path):
         result = gpu_princeton_dense.rgb(princeton_dense_rgb_path)
         assert isinstance(result, torch.Tensor)
@@ -297,6 +314,14 @@ class TestPrincetonDenseGPULoaders:
 class TestPrincetonDenseCPULoaders:
     """CPU Princeton DENSE loaders produce numpy arrays."""
 
+    def test_rccb_shape_dtype_and_range(self, princeton_dense_rccb_path):
+        result = cpu_princeton_dense.rccb(princeton_dense_rccb_path)
+        assert isinstance(result, np.ndarray)
+        assert result.dtype == np.float32
+        assert result.shape == (4, 4, 3)
+        assert result.min() >= 0.0
+        assert result.max() <= 1.0
+
     def test_rgb_shape_dtype_and_range(self, princeton_dense_rgb_path):
         result = cpu_princeton_dense.rgb(princeton_dense_rgb_path)
         assert isinstance(result, np.ndarray)
@@ -347,6 +372,12 @@ class TestPrincetonDenseCPULoaders:
 class TestPrincetonDenseBackwardCompat:
     """``from euler_loading.loaders import princeton_dense`` returns GPU loaders."""
 
+    def test_top_level_rccb_matches_gpu(self, princeton_dense_rccb_path):
+        assert torch.equal(
+            princeton_dense_top.rccb(princeton_dense_rccb_path),
+            gpu_princeton_dense.rccb(princeton_dense_rccb_path),
+        )
+
     def test_top_level_rgb_matches_gpu(self, princeton_dense_rgb_path):
         assert torch.equal(
             princeton_dense_top.rgb(princeton_dense_rgb_path),
@@ -1148,6 +1179,7 @@ class TestRDSWriters:
 GENERIC_LOADER_NAMES = [
     "map_2d",
     "map_3d",
+    "points_3d",
     "scattering_coefficient",
     "atmospheric_light",
     "spherical_map",
@@ -1155,6 +1187,7 @@ GENERIC_LOADER_NAMES = [
 GENERIC_WRITER_NAMES = [
     "write_map_2d",
     "write_map_3d",
+    "write_points_3d",
     "write_scattering_coefficient",
     "write_atmospheric_light",
     "write_spherical_map",
@@ -1353,6 +1386,24 @@ def map_3d_npz_path(tmp_path):
     return str(p), arr
 
 
+@pytest.fixture()
+def points_3d_npy_path(tmp_path):
+    """Write a small (3, 4, 5) float32 .npy file in 3HW layout."""
+    arr = np.random.default_rng(4).random((3, 4, 5), dtype=np.float32)
+    p = tmp_path / "points_3d.npy"
+    np.save(str(p), arr)
+    return str(p), arr
+
+
+@pytest.fixture()
+def points_3d_npz_path(tmp_path):
+    """Write a small (3, 4, 5) float32 .npz file in 3HW layout."""
+    arr = np.random.default_rng(5).random((3, 4, 5), dtype=np.float32)
+    p = tmp_path / "points_3d.npz"
+    np.savez_compressed(str(p), data=arr)
+    return str(p), arr
+
+
 class TestGPUMap2DLoader:
     """GPU ``map_2d`` loads a 2D map as an ``(H, W)`` float32 tensor."""
 
@@ -1434,6 +1485,52 @@ class TestCPUMap3DLoader:
         assert np.allclose(result, np.transpose(expected, (1, 2, 0)))
 
 
+class TestGPUPoints3DLoader:
+    """GPU ``points_3d`` loads dense 3D points as a ``(3, H, W)`` tensor."""
+
+    def test_npy_dtype_and_shape(self, points_3d_npy_path):
+        path, _ = points_3d_npy_path
+        result = gpu_generic.points_3d(path)
+        assert isinstance(result, torch.Tensor)
+        assert result.dtype == torch.float32
+        assert result.shape == (3, 4, 5)
+
+    def test_npy_values_match(self, points_3d_npy_path):
+        path, expected = points_3d_npy_path
+        result = gpu_generic.points_3d(path)
+        assert torch.allclose(result, torch.from_numpy(expected))
+
+    def test_npz_dtype_and_shape(self, points_3d_npz_path):
+        path, _ = points_3d_npz_path
+        result = gpu_generic.points_3d(path)
+        assert result.dtype == torch.float32
+        assert result.shape == (3, 4, 5)
+
+
+class TestCPUPoints3DLoader:
+    """CPU ``points_3d`` preserves the ``(3, H, W)`` dense point layout."""
+
+    def test_npy_dtype_and_shape(self, points_3d_npy_path):
+        path, _ = points_3d_npy_path
+        result = cpu_generic.points_3d(path)
+        assert isinstance(result, np.ndarray)
+        assert result.dtype == np.float32
+        assert result.shape == (3, 4, 5)
+
+    def test_npy_values_match(self, points_3d_npy_path):
+        path, expected = points_3d_npy_path
+        result = cpu_generic.points_3d(path)
+        assert np.allclose(result, expected)
+
+    def test_rejects_hwc_input(self, tmp_path):
+        arr = np.random.default_rng(6).random((4, 5, 3), dtype=np.float32)
+        path = tmp_path / "points_3d.npy"
+        np.save(str(path), arr)
+
+        with pytest.raises(ValueError, match=r"points_3d must have shape"):
+            cpu_generic.points_3d(str(path))
+
+
 class TestMapWriters:
     """Writer round-trip tests for ``map_2d`` / ``map_3d``."""
 
@@ -1473,6 +1570,13 @@ class TestMapWriters:
         loaded = gpu_generic.map_3d(str(path))
         assert torch.allclose(loaded, data)
 
+    def test_gpu_write_points_3d_npy_roundtrip(self, tmp_path):
+        data = torch.rand(3, 4, 5, dtype=torch.float32)
+        path = tmp_path / "points.npy"
+        gpu_generic.write_points_3d(str(path), data)
+        loaded = gpu_generic.points_3d(str(path))
+        assert torch.allclose(loaded, data)
+
     def test_cpu_write_map_3d_npy_roundtrip(self, tmp_path):
         data = np.random.default_rng(0).random((4, 5, 2)).astype(np.float32)
         path = tmp_path / "m.npy"
@@ -1480,6 +1584,13 @@ class TestMapWriters:
         loaded = cpu_generic.map_3d(str(path))
         assert np.allclose(loaded, data)
 
+    def test_cpu_write_points_3d_npz_roundtrip(self, tmp_path):
+        data = np.random.default_rng(0).random((3, 4, 5)).astype(np.float32)
+        path = tmp_path / "points.npz"
+        cpu_generic.write_points_3d(str(path), data)
+        loaded = cpu_generic.points_3d(str(path))
+        assert np.allclose(loaded, data)
+
     def test_cpu_write_map_3d_npz_roundtrip(self, tmp_path):
         data = np.random.default_rng(0).random((4, 5, 2)).astype(np.float32)
         path = tmp_path / "m.npz"
@@ -1529,6 +1640,8 @@ class TestSpecificMapAliases:
 
     def test_modality_meta_distinct_types(self):
         """Each alias carries its own modality_type even though logic is shared."""
+        assert gpu_generic.points_3d._modality_meta["type"] == "points_3d"
+        assert cpu_generic.points_3d._modality_meta["type"] == "points_3d"
         assert (
             gpu_generic.scattering_coefficient._modality_meta["type"]
             == "scattering_coefficient"