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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: euler-loading
-Version: 2.12.0
+Version: 2.17.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.17.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`, `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:
 
@@ -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,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,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.12.0 → euler_loading-2.17.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.17.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.17.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.17.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.12.0 → euler_loading-2.17.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.17.0/euler_loading/loaders/cpu/princeton_dense.py

@@ -0,0 +1,160 @@
+"""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
+------------
+- **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``.
+- **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 PIL import Image
+
+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="rccb",
+    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 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 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",
+    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)