euler-eval 2.10.0__tar.gz → 2.12.0__tar.gz

{euler_eval-2.10.0 → euler_eval-2.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: euler-eval
-Version: 2.10.0
+Version: 2.12.0
 Summary: Depth map evaluation toolkit with comprehensive metrics
 Author: Depth Eval Contributors
 License: MIT
@@ -241,7 +241,7 @@ Defines GT modalities, prediction datasets to evaluate, and optional euler_train
 
 Each modality entry can optionally include a `split` field to select a specific split from the dataset (e.g. `{ "path": "/data/gt/depth", "split": "test" }`). euler-loading inline selectors are also accepted in `path`, such as `/data/muses.zip:test` or `/data/muses.zip:test#scope=rgb`.
 
-For sparse pointcloud depth evaluation, use `gt.sparse_depth` instead of `gt.depth`. The prediction still uses `datasets[].depth` because the model output is a dense depth map. The evaluator projects the sparse GT point cloud into the prediction image plane using `gt.intrinsics` and `gt.camera_extrinsics`, then computes pointwise depth metrics only at projected valid pixels.
+For sparse pointcloud depth evaluation, use `gt.sparse_depth` instead of `gt.depth`. The prediction uses a dense depth-like map under `datasets[].depth`, `datasets[].relative_depth`, or `datasets[].affine_depth`. The evaluator projects the sparse GT point cloud into the prediction image plane using `gt.intrinsics` and `gt.camera_extrinsics`, then computes pointwise depth metrics only at projected valid pixels.
 
 #### GT section
 
@@ -261,17 +261,21 @@ For sparse pointcloud depth evaluation, use `gt.sparse_depth` instead of `gt.dep
 
 #### Prediction datasets
 
-Each entry in `datasets` can include `rgb`, `depth`, `rays`, or any combination:
+Each entry in `datasets` can include `rgb`, one dense depth-like prediction (`depth`, `relative_depth`, or `affine_depth`), `rays`, or any combination:
 
 | Field | Required | Description |
 |---|---|---|
 | `name` | yes | Display name for this prediction dataset |
 | `rgb.path` | no\* | Path to predicted RGB dataset |
-| `depth.path` | no\* | Path to predicted dense depth dataset; also used when evaluating against sparse pointcloud GT |
+| `depth.path` | no\* | Path to predicted dense metric depth dataset; also used when evaluating against sparse pointcloud GT |
+| `relative_depth.path` | no\* | Path to predicted dense relative depth dataset; evaluated through the same depth pipeline with scale/shift alignment support |
+| `affine_depth.path` | no\* | Path to predicted dense affine-depth dataset; evaluated through the same depth pipeline with scale/shift alignment support |
 | `rays.path` | no\* | Path to predicted ray direction map dataset |
 | `output_file` | no | Custom output path for results JSON (default: `eval.json` inside the first available modality path) |
 
-\* At least one of `rgb.path`, `depth.path`, or `rays.path` is required.
+\* At least one of `rgb.path`, `depth.path`, `relative_depth.path`, `affine_depth.path`, or `rays.path` is required. Use only one dense depth-like entry per prediction dataset.
+
+When `relative_depth` or `affine_depth` is used, `--depth-alignment auto_affine` treats the entry as declared non-metric depth and runs scale/shift alignment even if the raw value range is not normalized. `--depth-alignment none` still disables calibration.
 
 #### `euler_train` section (optional)
 

{euler_eval-2.10.0 → euler_eval-2.12.0}/README.md

@@ -203,7 +203,7 @@ Defines GT modalities, prediction datasets to evaluate, and optional euler_train
 
 Each modality entry can optionally include a `split` field to select a specific split from the dataset (e.g. `{ "path": "/data/gt/depth", "split": "test" }`). euler-loading inline selectors are also accepted in `path`, such as `/data/muses.zip:test` or `/data/muses.zip:test#scope=rgb`.
 
-For sparse pointcloud depth evaluation, use `gt.sparse_depth` instead of `gt.depth`. The prediction still uses `datasets[].depth` because the model output is a dense depth map. The evaluator projects the sparse GT point cloud into the prediction image plane using `gt.intrinsics` and `gt.camera_extrinsics`, then computes pointwise depth metrics only at projected valid pixels.
+For sparse pointcloud depth evaluation, use `gt.sparse_depth` instead of `gt.depth`. The prediction uses a dense depth-like map under `datasets[].depth`, `datasets[].relative_depth`, or `datasets[].affine_depth`. The evaluator projects the sparse GT point cloud into the prediction image plane using `gt.intrinsics` and `gt.camera_extrinsics`, then computes pointwise depth metrics only at projected valid pixels.
 
 #### GT section
 
@@ -223,17 +223,21 @@ For sparse pointcloud depth evaluation, use `gt.sparse_depth` instead of `gt.dep
 
 #### Prediction datasets
 
-Each entry in `datasets` can include `rgb`, `depth`, `rays`, or any combination:
+Each entry in `datasets` can include `rgb`, one dense depth-like prediction (`depth`, `relative_depth`, or `affine_depth`), `rays`, or any combination:
 
 | Field | Required | Description |
 |---|---|---|
 | `name` | yes | Display name for this prediction dataset |
 | `rgb.path` | no\* | Path to predicted RGB dataset |
-| `depth.path` | no\* | Path to predicted dense depth dataset; also used when evaluating against sparse pointcloud GT |
+| `depth.path` | no\* | Path to predicted dense metric depth dataset; also used when evaluating against sparse pointcloud GT |
+| `relative_depth.path` | no\* | Path to predicted dense relative depth dataset; evaluated through the same depth pipeline with scale/shift alignment support |
+| `affine_depth.path` | no\* | Path to predicted dense affine-depth dataset; evaluated through the same depth pipeline with scale/shift alignment support |
 | `rays.path` | no\* | Path to predicted ray direction map dataset |
 | `output_file` | no | Custom output path for results JSON (default: `eval.json` inside the first available modality path) |
 
-\* At least one of `rgb.path`, `depth.path`, or `rays.path` is required.
+\* At least one of `rgb.path`, `depth.path`, `relative_depth.path`, `affine_depth.path`, or `rays.path` is required. Use only one dense depth-like entry per prediction dataset.
+
+When `relative_depth` or `affine_depth` is used, `--depth-alignment auto_affine` treats the entry as declared non-metric depth and runs scale/shift alignment even if the raw value range is not normalized. `--depth-alignment none` still disables calibration.
 
 #### `euler_train` section (optional)
 

{euler_eval-2.10.0 → euler_eval-2.12.0}/euler_eval/cli.py

@@ -13,8 +13,8 @@ import zipfile
 from pathlib import Path
 
 import torch
-from euler_loading import Modality
 
+from .config_paths import normalize_modality_path
 from .data import (
     build_depth_eval_dataset,
     build_rays_eval_dataset,
@@ -41,22 +41,6 @@ except ImportError:
 from euler_metric_naming import AxisDeclaration, MetricDescription, MetricNamespace
 
 
-def _normalize_modality_path(
-    path: str | Path,
-    *,
-    modality_key: str,
-    split: str | None = None,
-) -> Path:
-    """Return the filesystem/archive root for an euler-loading modality path."""
-    modality = Modality(
-        str(path),
-        modality_type=modality_key,
-        metadata_scope=modality_key,
-        split=split,
-    )
-    return Path(modality.path)
-
-
 # ── Eval namespace ──────────────────────────────────────────────────────────
 # MetricNamespace subclass for eval context with custom axis declarations,
 # following the Normed Metric Namespacing convention (§3.6, §4, §5.2).
@@ -167,6 +151,8 @@ def _rgb_eval_axes(*, benchmark: bool = False) -> dict[str, AxisDeclaration]:
 
 _RAYS_EVAL_AXES: dict[str, AxisDeclaration] = {}
 
+_PRED_DEPTH_KEYS = ("depth", "relative_depth", "affine_depth")
+
 # Downstream eval consumers validate metricSet.metricNamespace with a stricter
 # first-segment rule than euler_metric_naming's modality validator. Keep the
 # public Python sparse_depth result keys, but use a wire-compatible metric root
@@ -578,6 +564,34 @@ def print_device_info(requested_device: str, resolved_device: str) -> None:
             pass
 
 
+def _prediction_depth_entry(
+    entry: dict, *, label: str = "Prediction dataset"
+) -> tuple[str | None, dict | None]:
+    """Return the configured dense-depth prediction entry, if any."""
+    matches = [
+        key
+        for key in _PRED_DEPTH_KEYS
+        if key in entry and "path" in entry.get(key, {})
+    ]
+    if not matches:
+        return None, None
+    if len(matches) > 1:
+        raise ValueError(
+            f"{label} contains multiple dense depth entries "
+            f"{matches}. Use only one of {list(_PRED_DEPTH_KEYS)}."
+        )
+    key = matches[0]
+    return key, entry[key]
+
+
+def _prediction_depth_space_hint(key: str | None) -> str | None:
+    if key == "relative_depth":
+        return "relative"
+    if key == "affine_depth":
+        return "affine"
+    return None
+
+
 def validate_gt_config(gt: dict) -> None:
     """Validate the ``gt`` section of the configuration.
 
@@ -616,9 +630,8 @@ def validate_gt_config(gt: dict) -> None:
         "camera_extrinsics",
     ):
         if modality in gt and "path" in gt[modality]:
-            p = _normalize_modality_path(
+            p = normalize_modality_path(
                 gt[modality]["path"],
-                modality_key=modality,
                 split=gt[modality].get("split"),
             )
             if not p.exists():
@@ -636,18 +649,19 @@ def validate_dataset_entry(entry: dict, index: int) -> None:
         raise ValueError(f"{label} must have a 'name' field")
 
     has_rgb = "rgb" in entry and "path" in entry.get("rgb", {})
-    has_depth = "depth" in entry and "path" in entry.get("depth", {})
+    depth_key, _ = _prediction_depth_entry(entry, label=label)
+    has_depth = depth_key is not None
     has_rays = "rays" in entry and "path" in entry.get("rays", {})
     if not has_rgb and not has_depth and not has_rays:
         raise ValueError(
-            f"{label} must have at least 'rgb.path', 'depth.path', or 'rays.path'"
+            f"{label} must have at least 'rgb.path', 'depth.path', "
+            "'relative_depth.path', 'affine_depth.path', or 'rays.path'"
         )
 
-    for modality in ("rgb", "depth", "rays"):
+    for modality in ("rgb", *_PRED_DEPTH_KEYS, "rays"):
         if modality in entry and "path" in entry[modality]:
-            p = _normalize_modality_path(
+            p = normalize_modality_path(
                 entry[modality]["path"],
-                modality_key=modality,
                 split=entry[modality].get("split"),
             )
             if not p.exists():
@@ -769,27 +783,28 @@ def save_results(
     """
     output_file = dataset_config.get("output_file")
     if output_file is None:
+        selected_modality = modality
+        if selected_modality == "depth" and "depth" not in dataset_config:
+            selected_modality, _ = _prediction_depth_entry(dataset_config)
         if (
-            modality is not None
-            and modality in dataset_config
-            and "path" in dataset_config[modality]
+            selected_modality is not None
+            and selected_modality in dataset_config
+            and "path" in dataset_config[selected_modality]
         ):
             output_file = (
-                _normalize_modality_path(
-                    dataset_config[modality]["path"],
-                    modality_key=modality,
-                    split=dataset_config[modality].get("split"),
+                normalize_modality_path(
+                    dataset_config[selected_modality]["path"],
+                    split=dataset_config[selected_modality].get("split"),
                 )
                 / "eval.json"
             )
         else:
             # Default: save alongside first available modality path
-            for mod in ("depth", "rgb", "rays"):
+            for mod in (*_PRED_DEPTH_KEYS, "rgb", "rays"):
                 if mod in dataset_config and "path" in dataset_config[mod]:
                     output_file = (
-                        _normalize_modality_path(
+                        normalize_modality_path(
                             dataset_config[mod]["path"],
-                            modality_key=mod,
                             split=dataset_config[mod].get("split"),
                         )
                         / "eval.json"
@@ -1008,7 +1023,8 @@ def main():
     # Evaluate each prediction dataset
     for dataset_config in config["datasets"]:
         ds_name = dataset_config["name"]
-        has_depth = "depth" in dataset_config and "path" in dataset_config["depth"]
+        pred_depth_key, pred_depth_config = _prediction_depth_entry(dataset_config)
+        has_depth = pred_depth_config is not None
         has_rgb = "rgb" in dataset_config and "path" in dataset_config["rgb"]
         has_rays = "rays" in dataset_config and "path" in dataset_config["rays"]
 
@@ -1031,17 +1047,22 @@ def main():
             and not gt_sparse_depth_path
             and not args.skip_depth
         ):
-            pred_depth_path = dataset_config["depth"]["path"]
-            pred_depth_split = dataset_config["depth"].get("split")
+            pred_depth_path = pred_depth_config["path"]
+            pred_depth_split = pred_depth_config.get("split")
             print(f"\n[DEPTH] Evaluating: '{ds_name}'")
             print(f"  GT:   {gt_depth_path}")
             print(f"  Pred: {pred_depth_path}")
+            if pred_depth_key != "depth":
+                print(f"  Pred depth entry: {pred_depth_key}")
 
             depth_dataset = build_depth_eval_dataset(
                 gt_depth_path=gt_depth_path,
                 pred_depth_path=pred_depth_path,
                 calibration_path=calibration_path,
                 segmentation_path=segmentation_path,
+                pred_depth_metadata_scope=(
+                    pred_depth_key if pred_depth_key != "depth" else None
+                ),
                 gt_depth_split=gt_depth_split,
                 pred_depth_split=pred_depth_split,
                 calibration_split=calibration_split,
@@ -1070,6 +1091,7 @@ def main():
                     if args.benchmark_depth_range
                     else None
                 ),
+                input_space_hint=_prediction_depth_space_hint(pred_depth_key),
             )
 
             if sanity_checker is not None:
@@ -1121,6 +1143,7 @@ def main():
                     "pred": {
                         "path": pred_depth_path,
                         "split": pred_depth_split,
+                        "entry": pred_depth_key,
                         "dimensions": depth_spatial.get("pred_dimensions"),
                     },
                     "spatial_alignment": {
@@ -1210,11 +1233,13 @@ def main():
         # -- Sparse pointcloud depth evaluation --
         sparse_depth_dataset = None
         if has_depth and gt_sparse_depth_path and not args.skip_depth:
-            pred_depth_path = dataset_config["depth"]["path"]
-            pred_depth_split = dataset_config["depth"].get("split")
+            pred_depth_path = pred_depth_config["path"]
+            pred_depth_split = pred_depth_config.get("split")
             print(f"\n[SPARSE_DEPTH] Evaluating: '{ds_name}'")
             print(f"  GT sparse pointcloud: {gt_sparse_depth_path}")
             print(f"  Pred dense depth:     {pred_depth_path}")
+            if pred_depth_key != "depth":
+                print(f"  Pred depth entry:     {pred_depth_key}")
             print(f"  Intrinsics:           {intrinsics_path}")
             print(f"  Camera extrinsics:    {camera_extrinsics_path}")
 
@@ -1224,6 +1249,9 @@ def main():
                 intrinsics_path=intrinsics_path,
                 camera_extrinsics_path=camera_extrinsics_path,
                 segmentation_path=segmentation_path,
+                pred_depth_metadata_scope=(
+                    pred_depth_key if pred_depth_key != "depth" else None
+                ),
                 gt_sparse_depth_split=gt_sparse_depth_split,
                 pred_depth_split=pred_depth_split,
                 intrinsics_split=intrinsics_split,
@@ -1251,6 +1279,7 @@ def main():
                     if args.benchmark_depth_range
                     else None
                 ),
+                input_space_hint=_prediction_depth_space_hint(pred_depth_key),
             )
 
             if sanity_checker is not None:
@@ -1297,6 +1326,7 @@ def main():
                     "pred": {
                         "path": pred_depth_path,
                         "split": pred_depth_split,
+                        "entry": pred_depth_key,
                         "dimensions": sparse_depth_spatial.get("pred_dimensions"),
                     },
                     "calibration": {
@@ -1652,7 +1682,11 @@ def main():
 
         # Save per-modality results to respective dataset paths
         if depth_save:
-            depth_out = save_results(depth_save, dataset_config, modality="depth")
+            depth_out = save_results(
+                depth_save,
+                dataset_config,
+                modality=pred_depth_key or "depth",
+            )
             depth_label = (
                 "Sparse depth"
                 if _SPARSE_DEPTH_METRIC_ROOT in depth_save

euler_eval-2.12.0/euler_eval/config_paths.py

@@ -0,0 +1,127 @@
+"""Helpers for euler-loading modality path selectors in config files."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from urllib.parse import parse_qsl
+
+from ds_crawler import validate_metadata_scope
+from ds_crawler.zip_utils import validate_split_name
+from euler_loading import Modality
+
+
+@dataclass(frozen=True)
+class ModalityPath:
+    path: str
+    split: str | None = None
+    metadata_scope: str | None = None
+
+
+def _parse_inline_scope(path: str) -> tuple[str, str | None]:
+    candidate_path, sep, fragment = path.rpartition("#")
+    if not sep:
+        return path, None
+
+    params = parse_qsl(fragment, keep_blank_values=True)
+    scope_values = [value for key, value in params if key == "scope"]
+    if not scope_values:
+        return path, None
+
+    unsupported = [key for key, _ in params if key != "scope"]
+    if unsupported:
+        raise ValueError(
+            "Unsupported modality path fragment parameter(s): "
+            f"{', '.join(sorted(set(unsupported)))}. "
+            "Only '#scope=<metadata_scope>' is supported."
+        )
+    if len(scope_values) > 1:
+        raise ValueError("Modality path may contain at most one '#scope=' selector.")
+
+    return candidate_path, validate_metadata_scope(scope_values[0])
+
+
+def _parse_inline_split(path: str) -> tuple[str, str | None]:
+    colon_pos = path.rfind(":")
+    if colon_pos <= 1:
+        return path, None
+
+    candidate_split = path[colon_pos + 1 :]
+    candidate_path = path[:colon_pos]
+
+    try:
+        split = validate_split_name(candidate_split)
+    except ValueError:
+        return path, None
+
+    return candidate_path, split
+
+
+def parse_modality_path(
+    path: str | Path,
+    *,
+    split: str | None = None,
+    metadata_scope: str | None = None,
+) -> ModalityPath:
+    """Parse euler-loading inline split/scope selectors from a config path."""
+    raw_path = str(path)
+    parsed_path, inline_scope = _parse_inline_scope(raw_path)
+    parsed_path, inline_split = _parse_inline_split(parsed_path)
+
+    if inline_split is not None and split is not None:
+        raise ValueError(
+            f"Modality path {raw_path!r} contains an inline split "
+            f"({inline_split!r}) but an explicit split={split!r} was also "
+            "provided. Use one or the other, not both."
+        )
+
+    normalized_scope = (
+        validate_metadata_scope(metadata_scope)
+        if metadata_scope is not None
+        else None
+    )
+    if inline_scope is not None:
+        if normalized_scope is not None and normalized_scope != inline_scope:
+            raise ValueError(
+                f"Modality path {raw_path!r} contains an inline metadata scope "
+                f"({inline_scope!r}) but an explicit "
+                f"metadata_scope={metadata_scope!r} was also provided. Use one "
+                "metadata scope selector."
+            )
+        normalized_scope = inline_scope
+
+    return ModalityPath(
+        path=parsed_path,
+        split=split if split is not None else inline_split,
+        metadata_scope=normalized_scope,
+    )
+
+
+def normalize_modality_path(path: str | Path, *, split: str | None = None) -> Path:
+    """Return the filesystem/archive root for a config modality path."""
+    return Path(parse_modality_path(path, split=split).path)
+
+
+def build_modality(
+    *,
+    path: str | Path,
+    modality_key: str,
+    split: str | None = None,
+    metadata_scope: str | None = None,
+    loader=None,
+    used_as: str | None = None,
+) -> Modality:
+    """Create a Modality after parsing inline config selectors locally."""
+    parsed = parse_modality_path(
+        path,
+        split=split,
+        metadata_scope=metadata_scope,
+    )
+    return Modality(
+        path=parsed.path,
+        loader=loader,
+        used_as=used_as,
+        modality_type=modality_key,
+        metadata_scope=parsed.metadata_scope or modality_key,
+        split=parsed.split,
+    )

{euler_eval-2.10.0 → euler_eval-2.12.0}/euler_eval/data.py

@@ -13,6 +13,7 @@ import torch
 from ds_crawler import get_dataset_contract, index_dataset_from_path
 from euler_loading import Modality, MultiModalDataset, resolve_loader_module
 
+from .config_paths import build_modality
 from .metrics.utils import convert_planar_to_radial
 
 # ---------------------------------------------------------------------------
@@ -570,16 +571,17 @@ def _modality(
     path: str,
     modality_key: str,
     split: Optional[str] = None,
+    metadata_scope: Optional[str] = None,
     loader: Optional[Callable[..., Any]] = None,
     used_as: Optional[str] = None,
 ) -> Modality:
     """Create an euler-loading modality with an explicit metadata selector."""
-    return Modality(
+    return build_modality(
         path=path,
         loader=loader,
         used_as=used_as,
-        modality_type=modality_key,
-        metadata_scope=modality_key,
+        modality_key=modality_key,
+        metadata_scope=metadata_scope,
         split=split,
     )
 
@@ -593,6 +595,7 @@ def build_depth_eval_dataset(
     pred_depth_split: Optional[str] = None,
     calibration_split: Optional[str] = None,
     segmentation_split: Optional[str] = None,
+    pred_depth_metadata_scope: Optional[str] = None,
 ) -> MultiModalDataset:
     """Build a MultiModalDataset for depth evaluation.
 
@@ -611,6 +614,9 @@ def build_depth_eval_dataset(
         pred_depth_split: Optional split name for the prediction depth modality.
         calibration_split: Optional split name for the calibration modality.
         segmentation_split: Optional split name for the segmentation modality.
+        pred_depth_metadata_scope: Optional metadata scope for the prediction
+            depth modality, useful when loading depth-like outputs such as
+            ``relative_depth`` or ``affine_depth`` through the depth loader.
 
     Returns:
         A MultiModalDataset instance.
@@ -624,6 +630,7 @@ def build_depth_eval_dataset(
         "pred": _modality(
             path=pred_depth_path,
             modality_key="depth",
+            metadata_scope=pred_depth_metadata_scope,
             used_as="output",
             split=pred_depth_split,
         ),
@@ -662,12 +669,16 @@ def build_sparse_depth_eval_dataset(
     intrinsics_split: Optional[str] = None,
     camera_extrinsics_split: Optional[str] = None,
     segmentation_split: Optional[str] = None,
+    pred_depth_metadata_scope: Optional[str] = None,
 ) -> MultiModalDataset:
     """Build a MultiModalDataset for sparse pointcloud depth evaluation.
 
     The returned dataset yields dense predicted depth under ``"pred"``,
     sparse GT point clouds under ``"gt"``, and hierarchical camera
     calibration under ``"intrinsics"`` and ``"camera_extrinsics"``.
+    ``pred_depth_metadata_scope`` can select a depth-like prediction scope
+    such as ``relative_depth`` or ``affine_depth`` while still loading it
+    as a dense depth map.
     """
     modalities = {
         "gt": _modality(
@@ -678,6 +689,7 @@ def build_sparse_depth_eval_dataset(
         "pred": _modality(
             path=pred_depth_path,
             modality_key="depth",
+            metadata_scope=pred_depth_metadata_scope,
             used_as="output",
             split=pred_depth_split,
         ),

{euler_eval-2.10.0 → euler_eval-2.12.0}/euler_eval/evaluate.py

@@ -552,6 +552,7 @@ def evaluate_depth_samples(
     sky_mask_enabled: bool = False,
     alignment_mode: str = "auto_affine",
     benchmark_depth_range: Optional[tuple[float, float]] = None,
+    input_space_hint: Optional[str] = None,
 ) -> dict:
     """Evaluate all depth metrics from a MultiModalDataset.
 
@@ -574,6 +575,9 @@ def evaluate_depth_samples(
         benchmark_depth_range: Optional ``(min_meters, max_meters)`` tuple.
             When set, also computes depth metrics for pixels within this
             range, subdivided into square-root-scaled near/mid/far bins.
+        input_space_hint: Optional declaration from the prediction config.
+            ``relative`` or ``affine`` makes ``auto_affine`` run alignment
+            even when values are outside the normalized range.
 
     Returns:
         Dictionary containing depth aggregate/per-file metrics with:
@@ -587,6 +591,12 @@ def evaluate_depth_samples(
             f"Invalid alignment_mode '{alignment_mode}'. "
             f"Expected one of {sorted(valid_alignment_modes)}."
         )
+    valid_input_space_hints = {None, "relative", "affine"}
+    if input_space_hint not in valid_input_space_hints:
+        raise ValueError(
+            f"Invalid input_space_hint '{input_space_hint}'. "
+            "Expected None, 'relative', or 'affine'."
+        )
 
     num_samples = len(dataset)
     if num_samples == 0:
@@ -1007,7 +1017,14 @@ def evaluate_depth_samples(
                 if i == 0:
                     pred_min = float(np.nanmin(depth_pred))
                     pred_max = float(np.nanmax(depth_pred))
-                    if pred_max <= 1.0 + 1e-3 and pred_min >= -1.0 - 1e-3:
+                    if input_space_hint in {"relative", "affine"}:
+                        normalized_predictions = True
+                        input_space_detected = input_space_hint
+                        print(
+                            f"  Detected native depth space: {input_space_hint} "
+                            f"(declared; range [{pred_min:.3f}, {pred_max:.3f}])"
+                        )
+                    elif pred_max <= 1.0 + 1e-3 and pred_min >= -1.0 - 1e-3:
                         normalized_predictions = True
                         input_space_detected = "normalized"
                         print(
@@ -1496,6 +1513,7 @@ def evaluate_sparse_depth_samples(
     sky_mask_enabled: bool = False,
     alignment_mode: str = "auto_affine",
     benchmark_depth_range: Optional[tuple[float, float]] = None,
+    input_space_hint: Optional[str] = None,
 ) -> dict:
     """Evaluate dense depth predictions against sparse pointcloud GT.
 
@@ -1510,6 +1528,12 @@ def evaluate_sparse_depth_samples(
             f"Invalid alignment_mode '{alignment_mode}'. "
             f"Expected one of {sorted(valid_alignment_modes)}."
         )
+    valid_input_space_hints = {None, "relative", "affine"}
+    if input_space_hint not in valid_input_space_hints:
+        raise ValueError(
+            f"Invalid input_space_hint '{input_space_hint}'. "
+            "Expected None, 'relative', or 'affine'."
+        )
 
     num_samples = len(dataset)
     if num_samples == 0:
@@ -1700,7 +1724,14 @@ def evaluate_sparse_depth_samples(
                 if i == 0:
                     pred_native_dims = depth_pred.shape[:2]
                     finite_pred = depth_pred[np.isfinite(depth_pred)]
-                    if finite_pred.size and finite_pred.max() <= 1.0 + 1e-3 and finite_pred.min() >= -1.0 - 1e-3:
+                    if input_space_hint in {"relative", "affine"} and finite_pred.size:
+                        normalized_predictions = True
+                        input_space_detected = input_space_hint
+                        print(
+                            f"  Detected native depth space: {input_space_hint} "
+                            f"(declared; range [{float(finite_pred.min()):.3f}, {float(finite_pred.max()):.3f}])"
+                        )
+                    elif finite_pred.size and finite_pred.max() <= 1.0 + 1e-3 and finite_pred.min() >= -1.0 - 1e-3:
                         normalized_predictions = True
                         input_space_detected = "normalized"
                         print(

{euler_eval-2.10.0 → euler_eval-2.12.0}/euler_eval.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: euler-eval
-Version: 2.10.0
+Version: 2.12.0
 Summary: Depth map evaluation toolkit with comprehensive metrics
 Author: Depth Eval Contributors
 License: MIT
@@ -241,7 +241,7 @@ Defines GT modalities, prediction datasets to evaluate, and optional euler_train
 
 Each modality entry can optionally include a `split` field to select a specific split from the dataset (e.g. `{ "path": "/data/gt/depth", "split": "test" }`). euler-loading inline selectors are also accepted in `path`, such as `/data/muses.zip:test` or `/data/muses.zip:test#scope=rgb`.
 
-For sparse pointcloud depth evaluation, use `gt.sparse_depth` instead of `gt.depth`. The prediction still uses `datasets[].depth` because the model output is a dense depth map. The evaluator projects the sparse GT point cloud into the prediction image plane using `gt.intrinsics` and `gt.camera_extrinsics`, then computes pointwise depth metrics only at projected valid pixels.
+For sparse pointcloud depth evaluation, use `gt.sparse_depth` instead of `gt.depth`. The prediction uses a dense depth-like map under `datasets[].depth`, `datasets[].relative_depth`, or `datasets[].affine_depth`. The evaluator projects the sparse GT point cloud into the prediction image plane using `gt.intrinsics` and `gt.camera_extrinsics`, then computes pointwise depth metrics only at projected valid pixels.
 
 #### GT section
 
@@ -261,17 +261,21 @@ For sparse pointcloud depth evaluation, use `gt.sparse_depth` instead of `gt.dep
 
 #### Prediction datasets
 
-Each entry in `datasets` can include `rgb`, `depth`, `rays`, or any combination:
+Each entry in `datasets` can include `rgb`, one dense depth-like prediction (`depth`, `relative_depth`, or `affine_depth`), `rays`, or any combination:
 
 | Field | Required | Description |
 |---|---|---|
 | `name` | yes | Display name for this prediction dataset |
 | `rgb.path` | no\* | Path to predicted RGB dataset |
-| `depth.path` | no\* | Path to predicted dense depth dataset; also used when evaluating against sparse pointcloud GT |
+| `depth.path` | no\* | Path to predicted dense metric depth dataset; also used when evaluating against sparse pointcloud GT |
+| `relative_depth.path` | no\* | Path to predicted dense relative depth dataset; evaluated through the same depth pipeline with scale/shift alignment support |
+| `affine_depth.path` | no\* | Path to predicted dense affine-depth dataset; evaluated through the same depth pipeline with scale/shift alignment support |
 | `rays.path` | no\* | Path to predicted ray direction map dataset |
 | `output_file` | no | Custom output path for results JSON (default: `eval.json` inside the first available modality path) |
 
-\* At least one of `rgb.path`, `depth.path`, or `rays.path` is required.
+\* At least one of `rgb.path`, `depth.path`, `relative_depth.path`, `affine_depth.path`, or `rays.path` is required. Use only one dense depth-like entry per prediction dataset.
+
+When `relative_depth` or `affine_depth` is used, `--depth-alignment auto_affine` treats the entry as declared non-metric depth and runs scale/shift alignment even if the raw value range is not normalized. `--depth-alignment none` still disables calibration.
 
 #### `euler_train` section (optional)
 

{euler_eval-2.10.0 → euler_eval-2.12.0}/euler_eval.egg-info/SOURCES.txt

@@ -3,6 +3,7 @@ init_cache.py
 pyproject.toml
 euler_eval/__init__.py
 euler_eval/cli.py
+euler_eval/config_paths.py
 euler_eval/data.py
 euler_eval/evaluate.py
 euler_eval/sanity_checker.py

{euler_eval-2.10.0 → euler_eval-2.12.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "euler-eval"
-version = "2.10.0"
+version = "2.12.0"
 description = "Depth map evaluation toolkit with comprehensive metrics"
 readme = "README.md"
 requires-python = ">=3.9"

{euler_eval-2.10.0 → euler_eval-2.12.0}/tests/test_config.py

@@ -65,6 +65,25 @@ class TestValidateGtConfig:
         gt = {"rgb": {"path": f"{rgb_path}#scope=rgb"}}
         validate_gt_config(gt)
 
+    def test_inline_scope_intrinsics_gt_path_is_valid(self, tmp_path):
+        depth_path = tmp_path / "depth"
+        depth_path.mkdir()
+        intrinsics_path = tmp_path / "frame_camera_trainvaltest.zip"
+        with zipfile.ZipFile(intrinsics_path, "w") as zf:
+            zf.writestr("dummy.txt", "x")
+        gt = {
+            "depth": {"path": str(depth_path)},
+            "intrinsics": {"path": f"{intrinsics_path}#scope=intrinsics"},
+        }
+        validate_gt_config(gt)
+
+    def test_inline_split_and_scope_gt_path_is_valid(self, tmp_path):
+        rgb_path = tmp_path / "reference.zip"
+        with zipfile.ZipFile(rgb_path, "w") as zf:
+            zf.writestr("dummy.txt", "x")
+        gt = {"rgb": {"path": f"{rgb_path}:fog_day#scope=rgb"}}
+        validate_gt_config(gt)
+
     def test_sparse_depth_requires_projection_modalities(self, tmp_path):
         sparse_path = tmp_path / "sparse_depth"
         sparse_path.mkdir()
@@ -108,6 +127,35 @@ class TestValidateDatasetEntry:
         }
         validate_dataset_entry(entry, 0)
 
+    def test_valid_relative_depth_only(self, tmp_path):
+        depth_path = tmp_path / "relative_depth"
+        depth_path.mkdir()
+        entry = {
+            "name": "model_a",
+            "relative_depth": {"path": str(depth_path)},
+        }
+        validate_dataset_entry(entry, 0)
+
+    def test_valid_affine_depth_only(self, tmp_path):
+        depth_path = tmp_path / "affine_depth"
+        depth_path.mkdir()
+        entry = {
+            "name": "model_a",
+            "affine_depth": {"path": str(depth_path)},
+        }
+        validate_dataset_entry(entry, 0)
+
+    def test_multiple_depth_prediction_entries_are_rejected(self, tmp_path):
+        for name in ("depth", "relative_depth"):
+            (tmp_path / name).mkdir()
+        entry = {
+            "name": "model_a",
+            "depth": {"path": str(tmp_path / "depth")},
+            "relative_depth": {"path": str(tmp_path / "relative_depth")},
+        }
+        with pytest.raises(ValueError, match="multiple dense depth entries"):
+            validate_dataset_entry(entry, 0)
+
     def test_valid_rgb_only(self, tmp_path):
         rgb_path = tmp_path / "rgb"
         rgb_path.mkdir()

{euler_eval-2.10.0 → euler_eval-2.12.0}/tests/test_data_builders.py

@@ -15,8 +15,10 @@ def _install_captured_dataset(monkeypatch):
     monkeypatch.setattr(data, "MultiModalDataset", _CapturedDataset)
 
 
-def _assert_modality(modality, *, key, split=None, used_as=None, loader=None):
-    assert modality.metadata_scope == key
+def _assert_modality(
+    modality, *, key, split=None, used_as=None, loader=None, scope=None
+):
+    assert modality.metadata_scope == (scope or key)
     assert modality.modality_type == key
     assert modality.split == split
     assert modality.used_as == used_as
@@ -100,6 +102,25 @@ def test_sparse_depth_builder_sets_projection_modality_scopes(monkeypatch):
     )
 
 
+def test_sparse_depth_builder_can_load_relative_depth_prediction_scope(monkeypatch):
+    _install_captured_dataset(monkeypatch)
+
+    dataset = data.build_sparse_depth_eval_dataset(
+        gt_sparse_depth_path="/datasets/shared",
+        pred_depth_path="/predictions/shared",
+        intrinsics_path="/datasets/shared",
+        camera_extrinsics_path="/datasets/shared",
+        pred_depth_metadata_scope="relative_depth",
+    )
+
+    _assert_modality(
+        dataset.modalities["pred"],
+        key="depth",
+        scope="relative_depth",
+        used_as="output",
+    )
+
+
 def test_rgb_builder_sets_rgb_and_auxiliary_modality_scopes(monkeypatch):
     _install_captured_dataset(monkeypatch)
 
@@ -192,3 +213,14 @@ def test_sky_mask_loader_resolution_strips_inline_split(monkeypatch):
     assert calls == [
         ("/datasets/shared.zip", {"metadata_scope": "segmentation"}),
     ]
+
+
+def test_modality_parses_inline_split_and_scope():
+    modality = data._modality(
+        path="/datasets/frame_camera_trainvaltest.zip:fog_day#scope=intrinsics",
+        modality_key="intrinsics",
+    )
+
+    assert modality.path == "/datasets/frame_camera_trainvaltest.zip"
+    assert modality.split == "fog_day"
+    assert modality.metadata_scope == "intrinsics"

{euler_eval-2.10.0 → euler_eval-2.12.0}/tests/test_save_results.py

@@ -126,6 +126,18 @@ class TestSaveResultsDirectory:
         assert out.exists()
         assert json.loads(out.read_text()) == results
 
+    def test_saves_to_relative_depth_path(self, tmp_path):
+        depth_dir = tmp_path / "pred_relative_depth"
+        depth_dir.mkdir()
+
+        results = {"depth": {"rmse": 0.5}}
+        config = {"name": "model", "relative_depth": {"path": str(depth_dir)}}
+        out = save_results(results, config, modality="depth")
+
+        assert out == depth_dir / "eval.json"
+        assert out.exists()
+        assert json.loads(out.read_text()) == results
+
     def test_saves_to_rgb_path_when_no_depth(self, tmp_path):
         rgb_dir = tmp_path / "pred_rgb"
         rgb_dir.mkdir()
@@ -229,6 +241,21 @@ class TestSaveResultsZip:
             stored = json.loads(zf.read("eval.json"))
             assert stored == results
 
+    def test_inline_zip_scope_writes_eval_json_into_zip(self, tmp_path):
+        zp = tmp_path / "dataset.zip"
+        with zipfile.ZipFile(zp, "w") as zf:
+            zf.writestr("image_001.png", b"\x89PNG")
+
+        results = {"rgb": {"psnr": 30.0}}
+        config = {"name": "model", "rgb": {"path": f"{zp}#scope=rgb"}}
+        out = save_results(results, config, modality="rgb")
+
+        assert out == zp / "eval.json"
+        with zipfile.ZipFile(zp, "r") as zf:
+            assert "eval.json" in zf.namelist()
+            stored = json.loads(zf.read("eval.json"))
+            assert stored == results
+
     def test_preserves_existing_zip_contents(self, tmp_path):
         zp = tmp_path / "dataset.zip"
         with zipfile.ZipFile(zp, "w") as zf:

{euler_eval-2.10.0 → euler_eval-2.12.0}/tests/test_sparse_depth.py

@@ -99,6 +99,22 @@ class _ZeroValidSparseDataset(_OneSampleSparseDataset):
         self.pred = np.zeros((3, 3), dtype=np.float32)
 
 
+class _RelativeSparseDataset(_OneSampleSparseDataset):
+    def __init__(self):
+        super().__init__()
+        self.pred = np.zeros((3, 3), dtype=np.float32)
+        self.pred[1, 1] = (np.sqrt(12.0) - 3.0) / 2.0
+        self.pred[1, 2] = (np.sqrt(24.0) - 3.0) / 2.0
+
+
+class _AffineSparseDataset(_OneSampleSparseDataset):
+    def __init__(self):
+        super().__init__()
+        self.pred = np.zeros((3, 3), dtype=np.float32)
+        self.pred[1, 1] = np.sqrt(12.0) * 10.0 + 7.0
+        self.pred[1, 2] = np.sqrt(24.0) * 10.0 + 7.0
+
+
 def test_sparse_depth_eval_reports_only_pointwise_depth_metrics():
     dataset = _OneSampleSparseDataset()
 
@@ -119,6 +135,50 @@ def test_sparse_depth_eval_reports_only_pointwise_depth_metrics():
     np.testing.assert_allclose(metrics["depth_metrics"]["rmse"]["median"], 0.0)
 
 
+def test_sparse_depth_eval_auto_affine_aligns_relative_depth():
+    result = evaluate_sparse_depth_samples(
+        _RelativeSparseDataset(),
+        pred_is_radial=True,
+        num_workers=0,
+        alignment_mode="auto_affine",
+    )
+
+    assert result["space_info"]["input_space_detected"] == "normalized"
+    assert result["space_info"]["calibration_applied"] is True
+    assert result["space_info"]["emitted_spaces"] == ["native", "metric"]
+
+    native_rmse = result["sparse_depth_native"]["depth_metrics"]["rmse"]["median"]
+    metric_rmse = result["sparse_depth_metric"]["depth_metrics"]["rmse"]["median"]
+    assert metric_rmse < native_rmse
+    np.testing.assert_allclose(metric_rmse, 0.0, atol=1e-6)
+
+    per_file = result["per_file_metrics"]["files"][0]["metrics"]
+    assert "sparse_depth_native" in per_file
+    assert "sparse_depth_metric" in per_file
+    assert (
+        per_file["sparse_depth_metric"]["depth_metrics"]["rmse"]
+        < per_file["sparse_depth_native"]["depth_metrics"]["rmse"]
+    )
+
+
+def test_sparse_depth_eval_auto_affine_uses_declared_affine_depth_hint():
+    result = evaluate_sparse_depth_samples(
+        _AffineSparseDataset(),
+        pred_is_radial=True,
+        num_workers=0,
+        alignment_mode="auto_affine",
+        input_space_hint="affine",
+    )
+
+    assert result["space_info"]["input_space_detected"] == "affine"
+    assert result["space_info"]["calibration_applied"] is True
+
+    native_rmse = result["sparse_depth_native"]["depth_metrics"]["rmse"]["median"]
+    metric_rmse = result["sparse_depth_metric"]["depth_metrics"]["rmse"]["median"]
+    assert metric_rmse < native_rmse
+    np.testing.assert_allclose(metric_rmse, 0.0, atol=1e-5)
+
+
 def test_sparse_depth_per_file_reports_zero_valid_support():
     result = evaluate_sparse_depth_samples(
         _ZeroValidSparseDataset(),