euler-eval 2.16.0__tar.gz → 2.19.0__tar.gz

{euler_eval-2.16.0 → euler_eval-2.19.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: euler-eval
-Version: 2.16.0
+Version: 2.19.0
 Summary: Depth map evaluation toolkit with comprehensive metrics
 Author: Depth Eval Contributors
 License: MIT
@@ -221,6 +221,77 @@ The interval bounds are `near=[MIN, near_max)`, `mid=[near_max, mid_max)`, and
 | `mid` | `[9.290856529, 35.954189863)` |
 | `far` | `[35.954189863, 80.0]` |
 
+## Programmatic use (in-training validation)
+
+Besides the file-based CLI, `euler_eval.validation` exposes the same depth
+metric semantics for **in-memory predictions** — e.g. scoring a training
+run's validation pass against dense *or sparse* GT without writing
+predictions to disk:
+
+```python
+from euler_eval import (
+    DepthValidationAggregator,
+    build_validation_gt_dataset,
+    evaluate_dense_depth_sample,
+    evaluate_sparse_depth_sample,
+    get_sample_intrinsics,
+    get_sample_pointcloud_to_camera_extrinsics,
+    summarize_reduced_state,
+)
+
+# GT-only dataset from euler-loading compatible paths (.ds_crawler indices,
+# inline :split#scope= selectors supported).
+dataset = build_validation_gt_dataset(
+    sparse_depth_path="/data/muses.zip:val#scope=lidar",
+    rgb_path="/data/muses.zip:val#scope=rgb",
+    intrinsics_path="/data/muses.zip:val#scope=intrinsics",
+    camera_extrinsics_path="/data/muses.zip:val#scope=extrinsics",
+)
+
+aggregator = DepthValidationAggregator()
+for i in range(len(dataset)):
+    sample = dataset[i]
+    depth_pred = my_model(sample["rgb"])          # (H, W) metres, planar z
+    K = get_sample_intrinsics(sample)
+    lidar2cam, _ = get_sample_pointcloud_to_camera_extrinsics(sample)
+    aggregator.update(
+        evaluate_sparse_depth_sample(
+            depth_pred,
+            sample["sparse_depth"],               # (N, C>=3) lidar points
+            K,
+            lidar2cam,
+            alignment="none",                     # "affine" for relative depth
+        )
+    )
+
+summary = aggregator.summary()
+print(summary["standard"]["image_mean"]["absrel"])
+```
+
+Key pieces:
+
+- `evaluate_dense_depth_sample(pred, gt, valid_mask=None, alignment=...,
+  min_depth=..., max_depth=...)` — one dense prediction vs a dense GT map.
+  GT at another resolution is aligned to the prediction plane; returns the
+  standard metric set (`absrel`, `sqrel`, `mae`, `rmse`, `rmse_log`, `log10`,
+  `silog`, `delta1-3`) plus pooled pixel statistics, or `None` when too few
+  valid pixels remain.
+- `evaluate_sparse_depth_sample(pred, point_cloud, intrinsics,
+  camera_extrinsics, lidar_extrinsics=None, pred_is_radial=False, ...)` —
+  projects the sparse GT cloud into the prediction plane (radial depth,
+  nearest-z occlusion handling), converts a planar prediction to radial with
+  the same intrinsics, and scores only the projected pixels — matching the
+  CLI's `gt.sparse_depth` pipeline. Pass the intrinsics of the *actual
+  prediction plane* (i.e. adjusted for any crop/resize of the model input).
+- `alignment="none"` scores metric predictions as-is; `"affine"` fits
+  least-squares scale+shift first (relative/affine depth models).
+- `DepthValidationAggregator` accumulates per-sample results into the CLI's
+  `image_mean` / `image_median` / `pixel_pool` reducers. For multi-process
+  validation, sum `aggregator.reduced_state()` vectors across ranks (fixed
+  key order via `DepthValidationAggregator.state_keys()`) and rebuild
+  mean-based summaries with `summarize_reduced_state(...)`.
+- Inputs accept torch tensors or numpy arrays; all math runs on CPU numpy.
+
 ## Configuration
 
 ### `config.json`
@@ -268,7 +339,7 @@ When the GT is a sparse pointcloud, the evaluator also produces **3D (`points_3d
 - a **predicted point map** (`datasets[].points_3d`, an `(H,W,3)` map) — evaluated *directly* against the sparse GT cloud, with the 3D **similarity** gauge selected by `--points-3d-alignment`; or
 - a **dense depth map** (`datasets[].depth`/`relative_depth`/`affine_depth`) — unprojected with `gt.intrinsics` into a point map, with the depth **affine** gauge selected by `--depth-alignment`.
 
-If a dataset entry provides both, the predicted `points_3d` map is preferred (the depth is still scored by the pointwise sparse-depth metrics). Either way the sparse GT cloud is projected into the prediction plane, and the 3D results are written to a separate `points3d_eval.json` (or `<output_file>_points3d.json`) so they never clobber the sparse-depth `eval.json`.
+If a dataset entry provides both, the predicted `points_3d` map is preferred (the depth is still scored by the pointwise sparse-depth metrics). Either way the sparse GT cloud is projected into the prediction plane, and the 3D results are written as `eval.json` in the selected prediction modality path (or to the configured `output_file`). Give simultaneous evaluations distinct prediction paths: one `output_file` applies to the whole dataset entry.
 
 Sparse depth does not require segmentation GT. `gt.segmentation` and
 `gt.semantic_segmentation` are optional aliases for the same sky-mask source.
@@ -536,7 +607,7 @@ For sparse depth outputs, the internal Python result dict still uses `sparse_dep
 
 For points_3d outputs, the internal Python result dict uses `points_3d_native`, `points_3d_metric`, and `points_3d` (canonical alias), but serialized `eval.json` metric paths are rooted at `points3d.eval` (no underscore) to satisfy the namespace first-segment rule, mirroring `sparsedepth`. The `metric` space is emitted only when a gauge alignment is applied; otherwise only `native` is present and aliased.
 
-When the points_3d metrics come from a sparse pointcloud GT (`gt.sparse_depth` + a predicted `points_3d` map or a dense depth prediction), they use the same `points3d.eval` namespace but are written to a distinct file — `points3d_eval.json` beside the prediction, or `<output_file>_points3d.json` when `output_file` is set — so they do not overwrite the sparse-depth `eval.json`. Only the `point_error`, `error_decomposition`, and (directed) `cloud_distance` categories are present; the `metric` space is emitted only when the gauge (`--points-3d-alignment` for a point-map prediction, `--depth-alignment` for a depth prediction) calibrates the prediction.
+When the points_3d metrics come from a sparse pointcloud GT (`gt.sparse_depth` + a predicted `points_3d` map or a dense depth prediction), they use the same `points3d.eval` namespace and are written as `eval.json` beside the selected prediction modality (or to the configured `output_file`). Only the `point_error`, `error_decomposition`, and (directed) `cloud_distance` categories are present; the `metric` space is emitted only when the gauge (`--points-3d-alignment` for a point-map prediction, `--depth-alignment` for a depth prediction) calibrates the prediction.
 
 Previous single-depth structure (kept under `depth`) is:
 

{euler_eval-2.16.0 → euler_eval-2.19.0}/README.md

@@ -183,6 +183,77 @@ The interval bounds are `near=[MIN, near_max)`, `mid=[near_max, mid_max)`, and
 | `mid` | `[9.290856529, 35.954189863)` |
 | `far` | `[35.954189863, 80.0]` |
 
+## Programmatic use (in-training validation)
+
+Besides the file-based CLI, `euler_eval.validation` exposes the same depth
+metric semantics for **in-memory predictions** — e.g. scoring a training
+run's validation pass against dense *or sparse* GT without writing
+predictions to disk:
+
+```python
+from euler_eval import (
+    DepthValidationAggregator,
+    build_validation_gt_dataset,
+    evaluate_dense_depth_sample,
+    evaluate_sparse_depth_sample,
+    get_sample_intrinsics,
+    get_sample_pointcloud_to_camera_extrinsics,
+    summarize_reduced_state,
+)
+
+# GT-only dataset from euler-loading compatible paths (.ds_crawler indices,
+# inline :split#scope= selectors supported).
+dataset = build_validation_gt_dataset(
+    sparse_depth_path="/data/muses.zip:val#scope=lidar",
+    rgb_path="/data/muses.zip:val#scope=rgb",
+    intrinsics_path="/data/muses.zip:val#scope=intrinsics",
+    camera_extrinsics_path="/data/muses.zip:val#scope=extrinsics",
+)
+
+aggregator = DepthValidationAggregator()
+for i in range(len(dataset)):
+    sample = dataset[i]
+    depth_pred = my_model(sample["rgb"])          # (H, W) metres, planar z
+    K = get_sample_intrinsics(sample)
+    lidar2cam, _ = get_sample_pointcloud_to_camera_extrinsics(sample)
+    aggregator.update(
+        evaluate_sparse_depth_sample(
+            depth_pred,
+            sample["sparse_depth"],               # (N, C>=3) lidar points
+            K,
+            lidar2cam,
+            alignment="none",                     # "affine" for relative depth
+        )
+    )
+
+summary = aggregator.summary()
+print(summary["standard"]["image_mean"]["absrel"])
+```
+
+Key pieces:
+
+- `evaluate_dense_depth_sample(pred, gt, valid_mask=None, alignment=...,
+  min_depth=..., max_depth=...)` — one dense prediction vs a dense GT map.
+  GT at another resolution is aligned to the prediction plane; returns the
+  standard metric set (`absrel`, `sqrel`, `mae`, `rmse`, `rmse_log`, `log10`,
+  `silog`, `delta1-3`) plus pooled pixel statistics, or `None` when too few
+  valid pixels remain.
+- `evaluate_sparse_depth_sample(pred, point_cloud, intrinsics,
+  camera_extrinsics, lidar_extrinsics=None, pred_is_radial=False, ...)` —
+  projects the sparse GT cloud into the prediction plane (radial depth,
+  nearest-z occlusion handling), converts a planar prediction to radial with
+  the same intrinsics, and scores only the projected pixels — matching the
+  CLI's `gt.sparse_depth` pipeline. Pass the intrinsics of the *actual
+  prediction plane* (i.e. adjusted for any crop/resize of the model input).
+- `alignment="none"` scores metric predictions as-is; `"affine"` fits
+  least-squares scale+shift first (relative/affine depth models).
+- `DepthValidationAggregator` accumulates per-sample results into the CLI's
+  `image_mean` / `image_median` / `pixel_pool` reducers. For multi-process
+  validation, sum `aggregator.reduced_state()` vectors across ranks (fixed
+  key order via `DepthValidationAggregator.state_keys()`) and rebuild
+  mean-based summaries with `summarize_reduced_state(...)`.
+- Inputs accept torch tensors or numpy arrays; all math runs on CPU numpy.
+
 ## Configuration
 
 ### `config.json`
@@ -230,7 +301,7 @@ When the GT is a sparse pointcloud, the evaluator also produces **3D (`points_3d
 - a **predicted point map** (`datasets[].points_3d`, an `(H,W,3)` map) — evaluated *directly* against the sparse GT cloud, with the 3D **similarity** gauge selected by `--points-3d-alignment`; or
 - a **dense depth map** (`datasets[].depth`/`relative_depth`/`affine_depth`) — unprojected with `gt.intrinsics` into a point map, with the depth **affine** gauge selected by `--depth-alignment`.
 
-If a dataset entry provides both, the predicted `points_3d` map is preferred (the depth is still scored by the pointwise sparse-depth metrics). Either way the sparse GT cloud is projected into the prediction plane, and the 3D results are written to a separate `points3d_eval.json` (or `<output_file>_points3d.json`) so they never clobber the sparse-depth `eval.json`.
+If a dataset entry provides both, the predicted `points_3d` map is preferred (the depth is still scored by the pointwise sparse-depth metrics). Either way the sparse GT cloud is projected into the prediction plane, and the 3D results are written as `eval.json` in the selected prediction modality path (or to the configured `output_file`). Give simultaneous evaluations distinct prediction paths: one `output_file` applies to the whole dataset entry.
 
 Sparse depth does not require segmentation GT. `gt.segmentation` and
 `gt.semantic_segmentation` are optional aliases for the same sky-mask source.
@@ -498,7 +569,7 @@ For sparse depth outputs, the internal Python result dict still uses `sparse_dep
 
 For points_3d outputs, the internal Python result dict uses `points_3d_native`, `points_3d_metric`, and `points_3d` (canonical alias), but serialized `eval.json` metric paths are rooted at `points3d.eval` (no underscore) to satisfy the namespace first-segment rule, mirroring `sparsedepth`. The `metric` space is emitted only when a gauge alignment is applied; otherwise only `native` is present and aliased.
 
-When the points_3d metrics come from a sparse pointcloud GT (`gt.sparse_depth` + a predicted `points_3d` map or a dense depth prediction), they use the same `points3d.eval` namespace but are written to a distinct file — `points3d_eval.json` beside the prediction, or `<output_file>_points3d.json` when `output_file` is set — so they do not overwrite the sparse-depth `eval.json`. Only the `point_error`, `error_decomposition`, and (directed) `cloud_distance` categories are present; the `metric` space is emitted only when the gauge (`--points-3d-alignment` for a point-map prediction, `--depth-alignment` for a depth prediction) calibrates the prediction.
+When the points_3d metrics come from a sparse pointcloud GT (`gt.sparse_depth` + a predicted `points_3d` map or a dense depth prediction), they use the same `points3d.eval` namespace and are written as `eval.json` beside the selected prediction modality (or to the configured `output_file`). Only the `point_error`, `error_decomposition`, and (directed) `cloud_distance` categories are present; the `metric` space is emitted only when the gauge (`--points-3d-alignment` for a point-map prediction, `--depth-alignment` for a depth prediction) calibrates the prediction.
 
 Previous single-depth structure (kept under `depth`) is:
 

euler_eval-2.19.0/euler_eval/__init__.py

@@ -0,0 +1,65 @@
+"""Depth evaluation package.
+
+Public programmatic API (lazily imported so that ``import euler_eval`` stays
+cheap; heavy metric backends only load on first use):
+
+* :mod:`euler_eval.validation` — in-training/programmatic depth validation
+  (``evaluate_dense_depth_sample``, ``evaluate_sparse_depth_sample``,
+  ``DepthValidationAggregator``, ``build_validation_gt_dataset``).
+* :mod:`euler_eval.calibration` — calibration extraction from euler-loading
+  samples.
+* :mod:`euler_eval.metrics` — pure-array metric functions.
+* :mod:`euler_eval.data` — dataset builders, converters, projection, and
+  alignment helpers.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+_VALIDATION_EXPORTS = (
+    "DepthSampleEvaluation",
+    "DepthValidationAggregator",
+    "VALIDATION_ALIGNMENT_MODES",
+    "build_validation_gt_dataset",
+    "evaluate_dense_depth_sample",
+    "evaluate_sparse_depth_sample",
+    "summarize_reduced_state",
+)
+_CALIBRATION_EXPORTS = (
+    "get_sample_intrinsics",
+    "get_sample_pointcloud_to_camera_extrinsics",
+)
+
+__all__ = [*_VALIDATION_EXPORTS, *_CALIBRATION_EXPORTS]
+
+if TYPE_CHECKING:  # pragma: no cover - static import surface for type checkers
+    from .calibration import (  # noqa: F401
+        get_sample_intrinsics,
+        get_sample_pointcloud_to_camera_extrinsics,
+    )
+    from .validation import (  # noqa: F401
+        VALIDATION_ALIGNMENT_MODES,
+        DepthSampleEvaluation,
+        DepthValidationAggregator,
+        build_validation_gt_dataset,
+        evaluate_dense_depth_sample,
+        evaluate_sparse_depth_sample,
+        summarize_reduced_state,
+    )
+
+
+def __getattr__(name: str):
+    if name in _VALIDATION_EXPORTS:
+        from . import validation
+
+        return getattr(validation, name)
+    if name in _CALIBRATION_EXPORTS:
+        from . import calibration
+
+        return getattr(calibration, name)
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+def __dir__() -> list[str]:
+    return sorted(set(globals()) | set(__all__))

euler_eval-2.19.0/euler_eval/calibration.py

@@ -0,0 +1,258 @@
+"""Camera-calibration extraction from euler-loading samples.
+
+MultiModalDataset samples carry calibration either directly (a ``(3, 3)`` /
+``(4, 4)`` tensor per sample) or wrapped in hierarchical-modality dicts and
+nested calibration payloads (e.g. a MUSES ``calib.json`` with named
+``lidar2rgb`` transforms).  This module owns the tolerant extraction logic
+shared by the CLI evaluators (:mod:`euler_eval.evaluate`) and the
+programmatic validation interface (:mod:`euler_eval.validation`).
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Optional
+
+import numpy as np
+
+from .data import (
+    compose_sensor_to_camera_extrinsics,
+    to_numpy_extrinsics,
+    to_numpy_intrinsics,
+)
+
+__all__ = [
+    "get_first_hierarchical_value",
+    "iter_hierarchical_values",
+    "get_sample_intrinsics",
+    "get_sample_pointcloud_to_camera_extrinsics",
+    "extract_wrapped_extrinsics",
+    "extract_named_extrinsics",
+    "extract_direct_source_to_camera",
+    "DIRECT_SOURCE_TO_CAMERA_KEYS",
+    "SOURCE_SENSOR_POSE_KEYS",
+    "CAMERA_SENSOR_POSE_KEYS",
+    "MATRIX_WRAPPER_KEYS",
+]
+
+
+def get_first_hierarchical_value(sample: dict, key: str):
+    """Return ``sample[key]``, unwrapping hierarchical ``{file_id: value}`` dicts."""
+    data = sample.get(key)
+    if data is None:
+        return None
+    if isinstance(data, dict):
+        if not data:
+            return None
+        return next(iter(data.values()))
+    return data
+
+
+def iter_hierarchical_values(sample: dict, key: str) -> list:
+    """Return candidate values for ``sample[key]`` (dict itself plus entries)."""
+    data = sample.get(key)
+    if data is None:
+        return []
+    if isinstance(data, dict):
+        return [data, *data.values()]
+    return [data]
+
+
+def get_sample_intrinsics(sample: dict) -> Optional[np.ndarray]:
+    """Extract a ``(3, 3)`` intrinsics matrix from sample calibration data."""
+    K_data = get_first_hierarchical_value(sample, "intrinsics")
+    if K_data is None:
+        K_data = get_first_hierarchical_value(sample, "calibration")
+    if K_data is None:
+        return None
+    return to_numpy_intrinsics(K_data)
+
+
+DIRECT_SOURCE_TO_CAMERA_KEYS = (
+    "lidar2rgb",
+    "lidar2camera",
+    "lidar2cam",
+    "lidar_to_rgb",
+    "lidar_to_camera",
+    "lidar_to_cam",
+    "source2rgb",
+    "source2camera",
+    "source_to_rgb",
+    "source_to_camera",
+    "sensor2rgb",
+    "sensor2camera",
+    "sensor_to_rgb",
+    "sensor_to_camera",
+)
+SOURCE_SENSOR_POSE_KEYS = (
+    "lidar",
+    "lidar_pose",
+    "lidar_extrinsics",
+    "source",
+    "source_sensor",
+    "source_extrinsics",
+    "sensor",
+    "sensor_extrinsics",
+    "lidar2gnss",
+    "lidar2ego",
+    "lidar2vehicle",
+    "lidar2world",
+    "lidar_to_gnss",
+    "lidar_to_ego",
+    "lidar_to_vehicle",
+    "lidar_to_world",
+)
+CAMERA_SENSOR_POSE_KEYS = (
+    "rgb",
+    "camera",
+    "cam",
+    "frame_camera",
+    "rgb_pose",
+    "camera_pose",
+    "camera_extrinsics",
+    "target",
+    "target_sensor",
+    "target_extrinsics",
+    "rgb2gnss",
+    "camera2gnss",
+    "cam2gnss",
+    "frame_camera2gnss",
+    "rgb2ego",
+    "camera2ego",
+    "cam2ego",
+    "frame_camera2ego",
+    "rgb2vehicle",
+    "camera2vehicle",
+    "cam2vehicle",
+    "frame_camera2vehicle",
+    "rgb2world",
+    "camera2world",
+    "cam2world",
+    "frame_camera2world",
+)
+MATRIX_WRAPPER_KEYS = ("T", "transform", "matrix", "extrinsics", "pose")
+
+
+def _as_extrinsics_or_none(data) -> Optional[np.ndarray]:
+    try:
+        return to_numpy_extrinsics(data)
+    except (TypeError, ValueError):
+        return None
+
+
+def extract_wrapped_extrinsics(data) -> Optional[np.ndarray]:
+    """Extract a ``(4, 4)`` transform from a value or common wrapper mappings."""
+    matrix = _as_extrinsics_or_none(data)
+    if matrix is not None:
+        return matrix
+
+    if not isinstance(data, Mapping):
+        return None
+
+    for key in MATRIX_WRAPPER_KEYS:
+        if key in data:
+            matrix = extract_wrapped_extrinsics(data[key])
+            if matrix is not None:
+                return matrix
+
+    if len(data) == 1:
+        return extract_wrapped_extrinsics(next(iter(data.values())))
+
+    return None
+
+
+def extract_named_extrinsics(data, names: tuple[str, ...]) -> Optional[np.ndarray]:
+    """Extract a transform stored under one of ``names`` in a calibration payload."""
+    if not isinstance(data, Mapping):
+        return extract_wrapped_extrinsics(data)
+
+    for name in names:
+        if name in data:
+            matrix = extract_wrapped_extrinsics(data[name])
+            if matrix is not None:
+                return matrix
+
+    for key in ("extrinsics", "sensors", "calibration", "poses"):
+        if key in data and isinstance(data[key], Mapping):
+            matrix = extract_named_extrinsics(data[key], names)
+            if matrix is not None:
+                return matrix
+
+    if len(data) == 1:
+        return extract_named_extrinsics(next(iter(data.values())), names)
+
+    return None
+
+
+def extract_direct_source_to_camera(data) -> Optional[np.ndarray]:
+    """Extract a direct source→camera transform (e.g. MUSES ``lidar2rgb``)."""
+    matrix = _as_extrinsics_or_none(data)
+    if matrix is not None:
+        return matrix
+
+    if not isinstance(data, Mapping):
+        return None
+
+    for key in DIRECT_SOURCE_TO_CAMERA_KEYS:
+        if key in data:
+            matrix = extract_wrapped_extrinsics(data[key])
+            if matrix is not None:
+                return matrix
+
+    for key in ("extrinsics", "calibration"):
+        if key in data and isinstance(data[key], Mapping):
+            matrix = extract_direct_source_to_camera(data[key])
+            if matrix is not None:
+                return matrix
+
+    if len(data) == 1:
+        return extract_direct_source_to_camera(next(iter(data.values())))
+
+    return None
+
+
+def get_sample_pointcloud_to_camera_extrinsics(
+    sample: dict,
+) -> tuple[Optional[np.ndarray], Optional[str]]:
+    """Extract or compose the transform used for sparse point projection.
+
+    The common MUSES path supplies a direct ``lidar2rgb`` transform via
+    ``camera_extrinsics``.  Some datasets instead expose separate lidar and
+    camera sensor poses in a shared frame; in that case we compose them to the
+    same source-to-camera transform expected by the projector.
+    """
+    lidar_pose = None
+    for value in iter_hierarchical_values(sample, "lidar_extrinsics"):
+        lidar_pose = extract_named_extrinsics(value, SOURCE_SENSOR_POSE_KEYS)
+        if lidar_pose is not None:
+            break
+
+    camera_values = iter_hierarchical_values(sample, "camera_extrinsics")
+    if not camera_values:
+        camera_values = iter_hierarchical_values(sample, "extrinsics")
+
+    if lidar_pose is not None:
+        for value in camera_values:
+            camera_pose = extract_named_extrinsics(value, CAMERA_SENSOR_POSE_KEYS)
+            if camera_pose is not None:
+                return (
+                    compose_sensor_to_camera_extrinsics(lidar_pose, camera_pose),
+                    "composed_lidar_and_camera_sensor_poses",
+                )
+        return None, None
+
+    for value in camera_values:
+        direct = extract_direct_source_to_camera(value)
+        if direct is not None:
+            return direct, "direct_source_to_camera"
+
+    for value in camera_values:
+        lidar_pose = extract_named_extrinsics(value, SOURCE_SENSOR_POSE_KEYS)
+        camera_pose = extract_named_extrinsics(value, CAMERA_SENSOR_POSE_KEYS)
+        if lidar_pose is not None and camera_pose is not None:
+            return (
+                compose_sensor_to_camera_extrinsics(lidar_pose, camera_pose),
+                "composed_lidar_and_camera_sensor_poses",
+            )
+
+    return None, None

{euler_eval-2.16.0 → euler_eval-2.19.0}/euler_eval/cli.py

@@ -978,9 +978,6 @@ def save_results(
     results: dict,
     dataset_config: dict,
     modality: str | None = None,
-    *,
-    default_basename: str = "eval.json",
-    output_file_suffix: str | None = None,
 ) -> Path:
     """Save results to output file.
 
@@ -994,14 +991,6 @@ def save_results(
         modality: When set, save to this specific modality's path
             (e.g. ``"depth"`` or ``"rgb"``).  Falls back to the first
             available modality path when *None*.
-        default_basename: File name used when no explicit ``output_file`` is
-            configured (default ``"eval.json"``).  Lets a second modality that
-            shares a prediction path (e.g. sparse ``points_3d`` alongside sparse
-            ``depth``) write to a distinct file instead of clobbering it.
-        output_file_suffix: When an explicit ``output_file`` is configured, this
-            suffix is inserted before its extension (e.g. ``"_points3d"`` turns
-            ``model_a.json`` into ``model_a_points3d.json``) so multiple
-            modalities can honour a single configured path without collision.
 
     Returns:
         Path where results were saved.
@@ -1021,7 +1010,7 @@ def save_results(
                     dataset_config[selected_modality]["path"],
                     split=dataset_config[selected_modality].get("split"),
                 )
-                / default_basename
+                / "eval.json"
             )
         else:
             # Default: save alongside first available modality path
@@ -1032,17 +1021,13 @@ def save_results(
                             dataset_config[mod]["path"],
                             split=dataset_config[mod].get("split"),
                         )
-                        / default_basename
+                        / "eval.json"
                     )
                     break
         if output_file is None:
-            output_file = Path(default_basename)
+            output_file = Path("eval.json")
     else:
         output_file = Path(output_file)
-        if output_file_suffix:
-            output_file = output_file.with_name(
-                f"{output_file.stem}{output_file_suffix}{output_file.suffix}"
-            )
 
     zip_path, internal_name = _find_zip_ancestor(output_file)
     if zip_path is not None and internal_name:
@@ -2360,14 +2345,10 @@ def main():
             )
             print(f"\n  Points-3D results saved to: {points_3d_out}")
         if points_3d_sparse_save:
-            # Distinct file so it never clobbers the sparse-depth eval.json that
-            # shares the same dense-depth prediction path / output_file.
             points_3d_sparse_out = save_results(
                 points_3d_sparse_save,
                 dataset_config,
                 modality="points_3d",
-                default_basename="points3d_eval.json",
-                output_file_suffix="_points3d",
             )
             print(
                 f"\n  Points-3D (sparse GT) results saved to: {points_3d_sparse_out}"