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

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

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

{euler_loading-2.12.0 → euler_loading-2.14.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`, 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`, 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:
 
@@ -530,6 +530,15 @@ All built-in loaders accept both filesystem paths (`str`) and in-memory buffers
 | `read_intrinsics` | RGB camera intrinsics from MUSES `calib.json` as a `(3, 3)` matrix; defaults to `sensor="rgb"` |
 | `read_extrinsics` | Camera extrinsics from MUSES `calib.json` as a `(4, 4)` matrix; defaults to `transform="lidar2rgb"` for sparse-depth reprojection into RGB pixels |
 
+### Princeton DENSE / SeeingThroughFog (`euler_loading.loaders.princeton_dense`)
+
+| Function | Description |
+|----------|-------------|
+| `rgb` | Left/right stereo 12-bit Bayer TIFF as RGB float32, normalised to [0, 1] |
+| `sparse_depth` | Lidar `.bin` point cloud as `(N, 5)` float32: `x, y, z, intensity, ring` |
+| `read_intrinsics` | Left stereo camera intrinsics `K` from `calib_cam_stereo_left.json` as a `(3, 3)` matrix |
+| `read_extrinsics` | Transform from HDL64 lidar frame `lidar_hdl64_s3_roof` to left camera optical frame `cam_stereo_left_optical` from `calib_tf_tree_full.json` as a `(4, 4)` matrix |
+
 ### 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.
@@ -541,7 +550,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,muses,generic_dense_depth}`.
+CPU variants of all loaders live under `euler_loading.loaders.cpu.{vkitti2,real_drive_sim,muses,princeton_dense,generic_dense_depth}`.
 
 ### Flattening hierarchical modalities
 

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

@@ -24,6 +24,8 @@ _LOADER_MODULES: dict[str, str] = {
     "generic_dense_depth": "euler_loading.loaders.gpu.generic_dense_depth",
     "generic": "euler_loading.loaders.gpu.generic",
     "muses": "euler_loading.loaders.gpu.muses",
+    "princeton_dense": "euler_loading.loaders.gpu.princeton_dense",
+    "seeing_through_fog": "euler_loading.loaders.gpu.princeton_dense",
 }
 
 

{euler_loading-2.12.0 → euler_loading-2.14.0}/euler_loading/loaders/__init__.py

@@ -27,4 +27,8 @@ Available submodules:
 - :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)
+- :mod:`euler_loading.loaders.gpu.princeton_dense` — Princeton DENSE /
+  SeeingThroughFog (torch)
+- :mod:`euler_loading.loaders.cpu.princeton_dense` — Princeton DENSE /
+  SeeingThroughFog (numpy)
 """

euler_loading-2.14.0/euler_loading/loaders/_princeton_dense.py

@@ -0,0 +1,314 @@
+"""Shared helpers for Princeton DENSE / SeeingThroughFog loaders."""
+
+from __future__ import annotations
+
+import json
+import os
+from collections import deque
+from collections.abc import Mapping
+from typing import Any, BinaryIO, Union
+
+import numpy as np
+from PIL import Image
+
+_DEFAULT_BAYER_PATTERN = "GBRG"
+_DEFAULT_RAW_MAX_VALUE = 4095.0
+DEFAULT_CAMERA_FRAME = "cam_stereo_left_optical"
+DEFAULT_LIDAR_FRAME = "lidar_hdl64_s3_roof"
+LIDAR_COLUMNS = ["x", "y", "z", "intensity", "ring"]
+
+
+def _value_from_context(
+    meta: Mapping[str, Any] | None,
+    attributes: Mapping[str, Any] | None,
+    keys: tuple[str, ...],
+) -> Any:
+    for source in (attributes, meta):
+        if not isinstance(source, Mapping):
+            continue
+        for key in keys:
+            if key in source:
+                return source[key]
+    return None
+
+
+def _rgb_scale(
+    raw: np.ndarray,
+    meta: Mapping[str, Any] | None,
+    attributes: Mapping[str, Any] | None,
+) -> float:
+    value = _value_from_context(
+        meta,
+        attributes,
+        ("rgb_max_value", "raw_max_value", "white_level"),
+    )
+    if value is not None:
+        return float(value)
+
+    if np.issubdtype(raw.dtype, np.integer):
+        if raw.dtype == np.uint8:
+            return 255.0
+        if raw.size and float(raw.max()) <= _DEFAULT_RAW_MAX_VALUE:
+            return _DEFAULT_RAW_MAX_VALUE
+        return float(np.iinfo(raw.dtype).max)
+
+    return 1.0
+
+
+def _bayer_pattern(
+    meta: Mapping[str, Any] | None,
+    attributes: Mapping[str, Any] | None,
+) -> str:
+    value = _value_from_context(meta, attributes, ("bayer_pattern", "cfa_pattern"))
+    if value is None:
+        return _DEFAULT_BAYER_PATTERN
+    pattern = str(value).upper()
+    if len(pattern) != 4 or any(channel not in "RGB" for channel in pattern):
+        raise ValueError("bayer_pattern must be a 4-character pattern using R, G, and B")
+    return pattern
+
+
+def _interpolate_channel(values: np.ndarray, mask: np.ndarray) -> np.ndarray:
+    values_pad = np.pad(values, 1, mode="edge")
+    mask_pad = np.pad(mask.astype(np.float32), 1, mode="edge")
+
+    sums = np.zeros_like(values, dtype=np.float32)
+    counts = np.zeros_like(values, dtype=np.float32)
+    for y_offset in range(3):
+        for x_offset in range(3):
+            y = slice(y_offset, y_offset + values.shape[0])
+            x = slice(x_offset, x_offset + values.shape[1])
+            sums += values_pad[y, x]
+            counts += mask_pad[y, x]
+
+    interpolated = np.divide(
+        sums,
+        counts,
+        out=np.zeros_like(sums, dtype=np.float32),
+        where=counts > 0,
+    )
+    return np.where(mask, values, interpolated)
+
+
+def _demosaic_bayer(raw: np.ndarray, pattern: str) -> np.ndarray:
+    raw_f32 = raw.astype(np.float32, copy=False)
+    channel_values = {
+        "R": np.zeros(raw.shape, dtype=np.float32),
+        "G": np.zeros(raw.shape, dtype=np.float32),
+        "B": np.zeros(raw.shape, dtype=np.float32),
+    }
+    channel_masks = {
+        "R": np.zeros(raw.shape, dtype=bool),
+        "G": np.zeros(raw.shape, dtype=bool),
+        "B": np.zeros(raw.shape, dtype=bool),
+    }
+
+    positions = (
+        (slice(0, None, 2), slice(0, None, 2), pattern[0]),
+        (slice(0, None, 2), slice(1, None, 2), pattern[1]),
+        (slice(1, None, 2), slice(0, None, 2), pattern[2]),
+        (slice(1, None, 2), slice(1, None, 2), pattern[3]),
+    )
+    for row_slice, col_slice, channel in positions:
+        channel_values[channel][row_slice, col_slice] = raw_f32[row_slice, col_slice]
+        channel_masks[channel][row_slice, col_slice] = True
+
+    channels = [
+        _interpolate_channel(channel_values[channel], channel_masks[channel])
+        for channel in ("R", "G", "B")
+    ]
+    return np.stack(channels, axis=-1)
+
+
+def load_rgb_array(
+    path: Union[str, BinaryIO],
+    meta: Mapping[str, Any] | None = None,
+    attributes: Mapping[str, Any] | None = None,
+) -> np.ndarray:
+    """Load a SeeingThroughFog RGB TIFF as an ``(H, W, 3)`` float32 array."""
+    with Image.open(path) as image:
+        raw = np.array(image)
+
+    if raw.ndim == 2:
+        rgb = _demosaic_bayer(raw, _bayer_pattern(meta, attributes))
+        scale = _rgb_scale(raw, meta, attributes)
+    elif raw.ndim == 3 and raw.shape[-1] >= 3:
+        rgb = raw[..., :3].astype(np.float32, copy=False)
+        scale = _rgb_scale(raw, meta, attributes)
+    else:
+        name = getattr(path, "name", path)
+        raise ValueError(f"Unsupported Princeton RGB image shape for {name!r}: {raw.shape}")
+
+    if scale <= 0:
+        raise ValueError(f"RGB scale must be positive, got {scale!r}")
+    return np.clip(rgb / scale, 0.0, 1.0).astype(np.float32, copy=False)
+
+
+def load_sparse_depth_array(path: Union[str, BinaryIO]) -> np.ndarray:
+    """Load a SeeingThroughFog lidar ``.bin`` file as ``(N, 5)`` float32."""
+    if isinstance(path, (str, os.PathLike)):
+        values = np.fromfile(path, dtype=np.float32)
+    else:
+        values = np.frombuffer(path.read(), dtype=np.float32).copy()
+
+    if values.size % 5 != 0:
+        name = getattr(path, "name", path)
+        raise ValueError(
+            f"Princeton sparse-depth file {name!r} contains {values.size} "
+            "float32 values, which is not divisible by 5."
+        )
+    return values.reshape((-1, 5))
+
+
+def _load_json(path: Union[str, BinaryIO]) -> Any:
+    if isinstance(path, (str, os.PathLike)):
+        with open(path) as f:
+            return json.load(f)
+    return json.load(path)
+
+
+def load_intrinsics_array(path: Union[str, BinaryIO]) -> np.ndarray:
+    """Load the left stereo camera intrinsics matrix from ROS camera-info JSON."""
+    data = _load_json(path)
+    if not isinstance(data, Mapping) or "K" not in data:
+        name = getattr(path, "name", path)
+        raise ValueError(f"Princeton camera calibration {name!r} must contain a K array.")
+
+    K = np.asarray(data["K"], dtype=np.float32)
+    if K.shape == (9,):
+        K = K.reshape(3, 3)
+    if K.shape != (3, 3):
+        raise ValueError(f"Princeton camera K must have shape (3, 3), got {K.shape}.")
+    return K
+
+
+def _select_frame(
+    meta: Mapping[str, Any] | None,
+    attributes: Mapping[str, Any] | None,
+    keys: tuple[str, ...],
+    default: str,
+) -> str:
+    value = _value_from_context(meta, attributes, keys)
+    if value is None:
+        return default
+    frame = str(value)
+    aliases = {
+        "camera": DEFAULT_CAMERA_FRAME,
+        "cam_stereo_left": DEFAULT_CAMERA_FRAME,
+        "left": DEFAULT_CAMERA_FRAME,
+        "rgb": DEFAULT_CAMERA_FRAME,
+        "lidar": DEFAULT_LIDAR_FRAME,
+        "hdl64": DEFAULT_LIDAR_FRAME,
+        "hdl64_s3": DEFAULT_LIDAR_FRAME,
+        "lidar_hdl64": DEFAULT_LIDAR_FRAME,
+    }
+    return aliases.get(frame, frame)
+
+
+def _matrix_from_transform(transform: Mapping[str, Any]) -> np.ndarray:
+    translation = transform.get("translation")
+    rotation = transform.get("rotation")
+    if not isinstance(translation, Mapping) or not isinstance(rotation, Mapping):
+        raise ValueError("TF transform entries must contain translation and rotation objects.")
+
+    x = float(rotation.get("x", 0.0))
+    y = float(rotation.get("y", 0.0))
+    z = float(rotation.get("z", 0.0))
+    w = float(rotation.get("w", 1.0))
+    norm = float(np.sqrt(x * x + y * y + z * z + w * w))
+    if norm <= 0.0:
+        raise ValueError("TF quaternion must have non-zero norm.")
+    x /= norm
+    y /= norm
+    z /= norm
+    w /= norm
+
+    matrix = np.eye(4, dtype=np.float64)
+    matrix[:3, :3] = np.array(
+        [
+            [1 - 2 * (y * y + z * z), 2 * (x * y - z * w), 2 * (x * z + y * w)],
+            [2 * (x * y + z * w), 1 - 2 * (x * x + z * z), 2 * (y * z - x * w)],
+            [2 * (x * z - y * w), 2 * (y * z + x * w), 1 - 2 * (x * x + y * y)],
+        ],
+        dtype=np.float64,
+    )
+    matrix[:3, 3] = [
+        float(translation.get("x", 0.0)),
+        float(translation.get("y", 0.0)),
+        float(translation.get("z", 0.0)),
+    ]
+    return matrix
+
+
+def _tf_edges(data: Any) -> dict[str, list[tuple[str, np.ndarray]]]:
+    if not isinstance(data, list):
+        raise ValueError("Princeton TF calibration must be a JSON list of transforms.")
+
+    edges: dict[str, list[tuple[str, np.ndarray]]] = {}
+    for entry in data:
+        if not isinstance(entry, Mapping):
+            continue
+        header = entry.get("header")
+        child = entry.get("child_frame_id")
+        transform = entry.get("transform")
+        if not isinstance(header, Mapping) or not isinstance(child, str):
+            continue
+        parent = header.get("frame_id")
+        if not isinstance(parent, str) or not isinstance(transform, Mapping):
+            continue
+
+        # ROS TransformStamped stores the child pose in the parent frame.
+        # This matrix maps coordinates from child frame to parent frame.
+        parent_from_child = _matrix_from_transform(transform)
+        child_from_parent = np.linalg.inv(parent_from_child)
+        edges.setdefault(child, []).append((parent, parent_from_child))
+        edges.setdefault(parent, []).append((child, child_from_parent))
+    return edges
+
+
+def _compose_tf(
+    edges: Mapping[str, list[tuple[str, np.ndarray]]],
+    source_frame: str,
+    target_frame: str,
+) -> np.ndarray:
+    queue: deque[tuple[str, np.ndarray]] = deque(
+        [(source_frame, np.eye(4, dtype=np.float64))]
+    )
+    seen = {source_frame}
+
+    while queue:
+        frame, frame_from_source = queue.popleft()
+        if frame == target_frame:
+            return frame_from_source.astype(np.float32)
+        for next_frame, next_from_frame in edges.get(frame, []):
+            if next_frame in seen:
+                continue
+            seen.add(next_frame)
+            queue.append((next_frame, next_from_frame @ frame_from_source))
+
+    available = ", ".join(sorted(edges.keys()))
+    raise KeyError(
+        f"No TF path from {source_frame!r} to {target_frame!r}. "
+        f"Available frames: {available}"
+    )
+
+
+def load_extrinsics_array(
+    path: Union[str, BinaryIO],
+    meta: Mapping[str, Any] | None = None,
+    attributes: Mapping[str, Any] | None = None,
+) -> np.ndarray:
+    """Load a 4x4 transform mapping HDL64 lidar points into the camera frame."""
+    source_frame = _select_frame(
+        meta,
+        attributes,
+        ("source_frame", "source_sensor", "from_frame", "from_sensor", "source"),
+        DEFAULT_LIDAR_FRAME,
+    )
+    target_frame = _select_frame(
+        meta,
+        attributes,
+        ("target_frame", "target_sensor", "to_frame", "to_sensor", "target", "camera"),
+        DEFAULT_CAMERA_FRAME,
+    )
+    return _compose_tf(_tf_edges(_load_json(path)), source_frame, target_frame)

{euler_loading-2.12.0 → euler_loading-2.14.0}/euler_loading/loaders/cpu/__init__.py

@@ -10,4 +10,6 @@ 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
+- :mod:`euler_loading.loaders.cpu.princeton_dense` — Princeton DENSE /
+  SeeingThroughFog
 """

euler_loading-2.14.0/euler_loading/loaders/cpu/princeton_dense.py

@@ -0,0 +1,141 @@
+"""CPU-oriented loaders for the Princeton DENSE / SeeingThroughFog dataset.
+
+The SeeingThroughFog release stores stereo-camera frames as 12-bit Bayer TIFF
+images and Velodyne lidar point clouds as binary ``float32`` records.
+
+Return types
+------------
+- **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``.
+- **read_intrinsics** -- ``np.ndarray`` of shape ``(3, 3)`` float32 from
+  ``calib_cam_stereo_left.json``.
+- **read_extrinsics** -- ``np.ndarray`` of shape ``(4, 4)`` float32 from
+  ``calib_tf_tree_full.json``, mapping HDL64 lidar points into the left camera
+  optical frame by default.
+"""
+
+from __future__ import annotations
+
+from typing import Any, BinaryIO, Union
+
+import numpy as np
+
+from euler_loading.loaders._annotations import modality_meta
+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
+from euler_loading.loaders._princeton_dense import load_extrinsics_array
+from euler_loading.loaders._princeton_dense import load_intrinsics_array
+from euler_loading.loaders._princeton_dense import load_rgb_array
+from euler_loading.loaders._princeton_dense import load_sparse_depth_array
+
+
+@modality_meta(
+    modality_type="rgb",
+    dtype="float32",
+    shape="HWC",
+    file_formats=[".tif", ".tiff"],
+    output_range=[0.0, 1.0],
+    meta={
+        "dataset": "SeeingThroughFog",
+        "raw_bit_depth": 12,
+        "bayer_pattern": "GBRG",
+        "raw_max_value": 4095.0,
+    },
+)
+def rgb(
+    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]``."""
+    return load_rgb_array(path, meta, attributes)
+
+
+@modality_meta(
+    modality_type="sparse_depth",
+    dtype="float32",
+    shape="NC",
+    file_formats=[".bin"],
+    meta={
+        "dataset": "SeeingThroughFog",
+        "representation": "point_cloud",
+        "columns": LIDAR_COLUMNS,
+        "coordinate_unit": "meters",
+    },
+)
+def sparse_depth(
+    path: Union[str, BinaryIO],
+    meta: dict[str, Any] | None = None,
+    *,
+    attributes: dict[str, Any] | None = None,
+) -> np.ndarray:
+    """Load a SeeingThroughFog lidar point cloud as ``(N, 5)`` float32."""
+    return load_sparse_depth_array(path)
+
+
+def lidar_point_cloud(
+    path: Union[str, BinaryIO],
+    meta: dict[str, Any] | None = None,
+    *,
+    attributes: dict[str, Any] | None = None,
+) -> np.ndarray:
+    """Alias for :func:`sparse_depth`."""
+    return load_sparse_depth_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:`sparse_depth`."""
+    return load_sparse_depth_array(path)
+
+
+@modality_meta(
+    modality_type="intrinsics",
+    dtype="float32",
+    hierarchical=True,
+    shape="3x3",
+    file_formats=[".json"],
+    meta={
+        "dataset": "SeeingThroughFog",
+        "camera_frame": DEFAULT_CAMERA_FRAME,
+        "source": "calib_cam_stereo_left",
+    },
+)
+def read_intrinsics(
+    path: Union[str, BinaryIO],
+    meta: dict[str, Any] | None = None,
+    *,
+    attributes: dict[str, Any] | None = None,
+) -> np.ndarray:
+    """Load the left stereo camera intrinsics matrix ``K``."""
+    return load_intrinsics_array(path)
+
+
+@modality_meta(
+    modality_type="camera_extrinsics",
+    dtype="float32",
+    hierarchical=True,
+    shape="4x4",
+    file_formats=[".json"],
+    meta={
+        "dataset": "SeeingThroughFog",
+        "default_source_frame": DEFAULT_LIDAR_FRAME,
+        "default_target_frame": DEFAULT_CAMERA_FRAME,
+        "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 the default ``lidar_hdl64_s3_roof`` to left-camera transform."""
+    return load_extrinsics_array(path, meta, attributes)

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

@@ -453,6 +453,109 @@
                 }
             ]
         },
+        {
+            "name": "princeton_dense",
+            "modalities": [
+                {
+                    "type": "camera_extrinsics",
+                    "function": "read_extrinsics",
+                    "hierarchical": true,
+                    "dtype": "float32",
+                    "access": "key",
+                    "file_formats": [
+                        ".json"
+                    ],
+                    "meta": {
+                        "dataset": "SeeingThroughFog",
+                        "default_source_frame": "lidar_hdl64_s3_roof",
+                        "default_target_frame": "cam_stereo_left_optical",
+                        "transform_direction": "source_frame_to_target_frame"
+                    },
+                    "cpu": {
+                        "shape": "4x4"
+                    },
+                    "gpu": {
+                        "shape": "4x4"
+                    }
+                },
+                {
+                    "type": "intrinsics",
+                    "function": "read_intrinsics",
+                    "hierarchical": true,
+                    "dtype": "float32",
+                    "access": "key",
+                    "file_formats": [
+                        ".json"
+                    ],
+                    "meta": {
+                        "dataset": "SeeingThroughFog",
+                        "camera_frame": "cam_stereo_left_optical",
+                        "source": "calib_cam_stereo_left"
+                    },
+                    "cpu": {
+                        "shape": "3x3"
+                    },
+                    "gpu": {
+                        "shape": "3x3"
+                    }
+                },
+                {
+                    "type": "rgb",
+                    "function": "rgb",
+                    "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": "sparse_depth",
+                    "function": "sparse_depth",
+                    "hierarchical": false,
+                    "dtype": "float32",
+                    "access": "key",
+                    "file_formats": [
+                        ".bin"
+                    ],
+                    "meta": {
+                        "dataset": "SeeingThroughFog",
+                        "representation": "point_cloud",
+                        "columns": [
+                            "x",
+                            "y",
+                            "z",
+                            "intensity",
+                            "ring"
+                        ],
+                        "coordinate_unit": "meters"
+                    },
+                    "cpu": {
+                        "shape": "NC"
+                    },
+                    "gpu": {
+                        "shape": "NC"
+                    }
+                }
+            ]
+        },
         {
             "name": "real_drive_sim",
             "modalities": [
@@ -465,6 +568,9 @@
                     "file_formats": [
                         ".json"
                     ],
+                    "cpu": {
+                        "shape": "dict"
+                    },
                     "gpu": {
                         "shape": "dict"
                     }
@@ -490,6 +596,9 @@
                             "distortion"
                         ]
                     },
+                    "cpu": {
+                        "shape": "dict"
+                    },
                     "gpu": {
                         "shape": "dict"
                     }
@@ -546,6 +655,9 @@
                     "meta": {
                         "sensor": "CS_FRONT"
                     },
+                    "cpu": {
+                        "shape": "3x3"
+                    },
                     "gpu": {
                         "shape": "3x3"
                     }

{euler_loading-2.12.0 → euler_loading-2.14.0}/euler_loading/loaders/gpu/__init__.py

@@ -9,4 +9,6 @@ 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
+- :mod:`euler_loading.loaders.gpu.princeton_dense` — Princeton DENSE /
+  SeeingThroughFog
 """

euler_loading-2.14.0/euler_loading/loaders/gpu/princeton_dense.py

@@ -0,0 +1,142 @@
+"""GPU-oriented loaders for the Princeton DENSE / SeeingThroughFog dataset.
+
+The SeeingThroughFog release stores stereo-camera frames as 12-bit Bayer TIFF
+images and Velodyne lidar point clouds as binary ``float32`` records.
+
+Return types
+------------
+- **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``.
+- **read_intrinsics** -- ``torch.FloatTensor`` of shape ``(3, 3)`` from
+  ``calib_cam_stereo_left.json``.
+- **read_extrinsics** -- ``torch.FloatTensor`` of shape ``(4, 4)`` from
+  ``calib_tf_tree_full.json``, mapping HDL64 lidar points into the left camera
+  optical frame by default.
+"""
+
+from __future__ import annotations
+
+from typing import Any, BinaryIO, Union
+
+import torch
+
+from euler_loading.loaders._annotations import modality_meta
+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
+from euler_loading.loaders._princeton_dense import load_extrinsics_array
+from euler_loading.loaders._princeton_dense import load_intrinsics_array
+from euler_loading.loaders._princeton_dense import load_rgb_array
+from euler_loading.loaders._princeton_dense import load_sparse_depth_array
+
+
+@modality_meta(
+    modality_type="rgb",
+    dtype="float32",
+    shape="CHW",
+    file_formats=[".tif", ".tiff"],
+    output_range=[0.0, 1.0],
+    meta={
+        "dataset": "SeeingThroughFog",
+        "raw_bit_depth": 12,
+        "bayer_pattern": "GBRG",
+        "raw_max_value": 4095.0,
+    },
+)
+def rgb(
+    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."""
+    arr = load_rgb_array(path, meta, attributes)
+    return torch.from_numpy(arr).permute(2, 0, 1).contiguous()
+
+
+@modality_meta(
+    modality_type="sparse_depth",
+    dtype="float32",
+    shape="NC",
+    file_formats=[".bin"],
+    meta={
+        "dataset": "SeeingThroughFog",
+        "representation": "point_cloud",
+        "columns": LIDAR_COLUMNS,
+        "coordinate_unit": "meters",
+    },
+)
+def sparse_depth(
+    path: Union[str, BinaryIO],
+    meta: dict[str, Any] | None = None,
+    *,
+    attributes: dict[str, Any] | None = None,
+) -> torch.Tensor:
+    """Load a SeeingThroughFog lidar point cloud as ``(N, 5)`` float32."""
+    return torch.from_numpy(load_sparse_depth_array(path)).contiguous()
+
+
+def lidar_point_cloud(
+    path: Union[str, BinaryIO],
+    meta: dict[str, Any] | None = None,
+    *,
+    attributes: dict[str, Any] | None = None,
+) -> torch.Tensor:
+    """Alias for :func:`sparse_depth`."""
+    return torch.from_numpy(load_sparse_depth_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:`sparse_depth`."""
+    return torch.from_numpy(load_sparse_depth_array(path)).contiguous()
+
+
+@modality_meta(
+    modality_type="intrinsics",
+    dtype="float32",
+    hierarchical=True,
+    shape="3x3",
+    file_formats=[".json"],
+    meta={
+        "dataset": "SeeingThroughFog",
+        "camera_frame": DEFAULT_CAMERA_FRAME,
+        "source": "calib_cam_stereo_left",
+    },
+)
+def read_intrinsics(
+    path: Union[str, BinaryIO],
+    meta: dict[str, Any] | None = None,
+    *,
+    attributes: dict[str, Any] | None = None,
+) -> torch.Tensor:
+    """Load the left stereo camera intrinsics matrix ``K``."""
+    return torch.from_numpy(load_intrinsics_array(path)).contiguous()
+
+
+@modality_meta(
+    modality_type="camera_extrinsics",
+    dtype="float32",
+    hierarchical=True,
+    shape="4x4",
+    file_formats=[".json"],
+    meta={
+        "dataset": "SeeingThroughFog",
+        "default_source_frame": DEFAULT_LIDAR_FRAME,
+        "default_target_frame": DEFAULT_CAMERA_FRAME,
+        "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 the default ``lidar_hdl64_s3_roof`` to left-camera transform."""
+    return torch.from_numpy(load_extrinsics_array(path, meta, attributes)).contiguous()

euler_loading-2.14.0/euler_loading/loaders/princeton_dense.py

@@ -0,0 +1,12 @@
+"""Loader functions for the Princeton DENSE / SeeingThroughFog dataset.
+
+This module re-exports the GPU-oriented loaders from
+:mod:`euler_loading.loaders.gpu.princeton_dense` 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 princeton_dense   # torch tensors
+    from euler_loading.loaders.cpu import princeton_dense   # numpy arrays
+"""
+
+from euler_loading.loaders.gpu.princeton_dense import *  # noqa: F401,F403

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

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

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

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

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

@@ -11,19 +11,23 @@ import pytest
 import torch
 from PIL import Image
 
+from euler_loading import resolve_loader_module
 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 import princeton_dense as princeton_dense_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.gpu import princeton_dense as gpu_princeton_dense
 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
+from euler_loading.loaders.cpu import princeton_dense as cpu_princeton_dense
 
 # ---------------------------------------------------------------------------
 # Shared fixtures
@@ -149,6 +153,214 @@ class TestGenericDenseDepthAttributes:
         np.testing.assert_allclose(result, expected)
 
 
+# ---------------------------------------------------------------------------
+# Princeton DENSE / SeeingThroughFog loader smoke tests
+# ---------------------------------------------------------------------------
+
+PRINCETON_DENSE_LOADER_NAMES = [
+    "rgb",
+    "sparse_depth",
+    "read_intrinsics",
+    "read_extrinsics",
+]
+
+
+@pytest.fixture()
+def princeton_dense_rgb_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)
+    return str(path)
+
+
+@pytest.fixture()
+def princeton_dense_sparse_depth_path(tmp_path):
+    arr = np.array(
+        [
+            [1.0, 2.0, 3.0, 128.0, 12.0],
+            [4.0, 5.0, 6.0, 255.0, 63.0],
+        ],
+        dtype=np.float32,
+    )
+    path = tmp_path / "2018-02-06_15-48-12_00200.bin"
+    arr.tofile(path)
+    return str(path), arr
+
+
+@pytest.fixture()
+def princeton_dense_intrinsics_path(tmp_path):
+    data = {
+        "K": [2612.86, 0.0, 966.525, 0.0, 2612.86, 508.297, 0.0, 0.0, 1.0],
+        "D": [-0.567575, 0.0, 0.0, 0.0, 0.0],
+        "R": [1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0],
+        "P": [2355.722801, 0.0, 988.138054, 0.0, 0.0, 2355.722801, 508.051838, 0.0, 0.0, 0.0, 1.0, 0.0],
+        "width": 1920,
+        "height": 1024,
+        "header": {"frame_id": "cam_stereo_left_optical"},
+    }
+    path = tmp_path / "calib_cam_stereo_left.json"
+    path.write_text(json.dumps(data))
+    return str(path), np.asarray(data["K"], dtype=np.float32).reshape(3, 3)
+
+
+@pytest.fixture()
+def princeton_dense_tf_tree_path(tmp_path):
+    data = [
+        {
+            "header": {"frame_id": "body"},
+            "child_frame_id": "lidar_hdl64_s3_roof",
+            "transform": {
+                "translation": {"x": 1.0, "y": 0.0, "z": 0.0},
+                "rotation": {"x": 0.0, "y": 0.0, "z": 0.0, "w": 1.0},
+            },
+        },
+        {
+            "header": {"frame_id": "body"},
+            "child_frame_id": "cam_stereo_left_optical",
+            "transform": {
+                "translation": {"x": 0.0, "y": 2.0, "z": 0.0},
+                "rotation": {"x": 0.0, "y": 0.0, "z": 0.0, "w": 1.0},
+            },
+        },
+    ]
+    path = tmp_path / "calib_tf_tree_full.json"
+    path.write_text(json.dumps(data))
+    expected = np.asarray(
+        [
+            [1.0, 0.0, 0.0, 1.0],
+            [0.0, 1.0, 0.0, -2.0],
+            [0.0, 0.0, 1.0, 0.0],
+            [0.0, 0.0, 0.0, 1.0],
+        ],
+        dtype=np.float32,
+    )
+    return str(path), expected
+
+
+class TestPrincetonDenseModuleContents:
+    """The Princeton DENSE module exposes the expected loader functions."""
+
+    @pytest.mark.parametrize("name", PRINCETON_DENSE_LOADER_NAMES)
+    def test_top_level_has_callable(self, name):
+        assert callable(getattr(princeton_dense_top, name))
+
+    @pytest.mark.parametrize("name", PRINCETON_DENSE_LOADER_NAMES)
+    def test_gpu_has_callable(self, name):
+        assert callable(getattr(gpu_princeton_dense, name))
+
+    @pytest.mark.parametrize("name", PRINCETON_DENSE_LOADER_NAMES)
+    def test_cpu_has_callable(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"
+
+    def test_auto_resolution_supports_dataset_alias(self):
+        module = resolve_loader_module("seeing_through_fog")
+        assert module.__name__ == "euler_loading.loaders.gpu.princeton_dense"
+
+
+class TestPrincetonDenseGPULoaders:
+    """GPU Princeton DENSE loaders produce torch tensors."""
+
+    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)
+        assert result.dtype == torch.float32
+        assert result.shape == (3, 4, 4)
+        assert result.min() >= 0.0
+        assert result.max() <= 1.0
+
+    def test_sparse_depth_preserves_float32_columns(self, princeton_dense_sparse_depth_path):
+        path, expected = princeton_dense_sparse_depth_path
+        result = gpu_princeton_dense.sparse_depth(path)
+        assert result.dtype == torch.float32
+        assert result.shape == (2, 5)
+        assert torch.equal(result, torch.from_numpy(expected))
+
+    def test_read_intrinsics_returns_camera_k(self, princeton_dense_intrinsics_path):
+        path, expected = princeton_dense_intrinsics_path
+        result = gpu_princeton_dense.read_intrinsics(path)
+        assert result.dtype == torch.float32
+        assert result.shape == (3, 3)
+        assert torch.equal(result, torch.from_numpy(expected))
+
+    def test_read_extrinsics_maps_hdl64_lidar_to_camera(self, princeton_dense_tf_tree_path):
+        path, expected = princeton_dense_tf_tree_path
+        result = gpu_princeton_dense.read_extrinsics(path)
+        assert result.dtype == torch.float32
+        assert result.shape == (4, 4)
+        assert torch.equal(result, torch.from_numpy(expected))
+
+
+class TestPrincetonDenseCPULoaders:
+    """CPU Princeton DENSE loaders produce numpy arrays."""
+
+    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)
+        assert result.dtype == np.float32
+        assert result.shape == (4, 4, 3)
+        assert result.min() >= 0.0
+        assert result.max() <= 1.0
+
+    def test_sparse_depth_preserves_float32_columns(self, princeton_dense_sparse_depth_path):
+        path, expected = princeton_dense_sparse_depth_path
+        result = cpu_princeton_dense.sparse_depth(path)
+        assert result.dtype == np.float32
+        assert result.shape == (2, 5)
+        assert np.array_equal(result, expected)
+
+    def test_sparse_depth_supports_binary_streams(self, princeton_dense_sparse_depth_path):
+        _, expected = princeton_dense_sparse_depth_path
+        stream = io.BytesIO(expected.tobytes())
+        result = cpu_princeton_dense.sparse_depth(stream)
+        assert np.array_equal(result, expected)
+
+    def test_read_intrinsics_returns_camera_k(self, princeton_dense_intrinsics_path):
+        path, expected = princeton_dense_intrinsics_path
+        result = cpu_princeton_dense.read_intrinsics(path)
+        assert result.dtype == np.float32
+        assert result.shape == (3, 3)
+        assert np.array_equal(result, expected)
+
+    def test_read_extrinsics_maps_hdl64_lidar_to_camera(self, princeton_dense_tf_tree_path):
+        path, expected = princeton_dense_tf_tree_path
+        result = cpu_princeton_dense.read_extrinsics(path)
+        assert result.dtype == np.float32
+        assert result.shape == (4, 4)
+        assert np.array_equal(result, expected)
+
+    def test_read_extrinsics_supports_frame_overrides(self, princeton_dense_tf_tree_path):
+        path, expected_lidar_to_camera = princeton_dense_tf_tree_path
+        result = cpu_princeton_dense.read_extrinsics(
+            path,
+            attributes={
+                "source_frame": "cam_stereo_left_optical",
+                "target_frame": "lidar_hdl64_s3_roof",
+            },
+        )
+        assert np.allclose(result, np.linalg.inv(expected_lidar_to_camera))
+
+
+class TestPrincetonDenseBackwardCompat:
+    """``from euler_loading.loaders import princeton_dense`` returns GPU loaders."""
+
+    def test_top_level_rgb_matches_gpu(self, princeton_dense_rgb_path):
+        assert torch.equal(
+            princeton_dense_top.rgb(princeton_dense_rgb_path),
+            gpu_princeton_dense.rgb(princeton_dense_rgb_path),
+        )
+
+    def test_top_level_sparse_depth_matches_gpu(self, princeton_dense_sparse_depth_path):
+        path, _ = princeton_dense_sparse_depth_path
+        assert torch.equal(
+            princeton_dense_top.sparse_depth(path),
+            gpu_princeton_dense.sparse_depth(path),
+        )
+
+
 # ---------------------------------------------------------------------------
 # MUSES loader smoke tests
 # ---------------------------------------------------------------------------