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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: euler-eval
-Version: 2.11.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.11.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.11.0 → euler_eval-2.12.0}/euler_eval/cli.py

@@ -151,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
@@ -562,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.
 
@@ -619,14 +649,16 @@ 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(
                 entry[modality]["path"],
@@ -751,21 +783,24 @@ 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"],
-                    split=dataset_config[modality].get("split"),
+                    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(
@@ -988,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"]
 
@@ -1011,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,
@@ -1050,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:
@@ -1101,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": {
@@ -1190,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}")
 
@@ -1204,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,
@@ -1231,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:
@@ -1277,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": {
@@ -1632,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.11.0 → euler_eval-2.12.0}/euler_eval/config_paths.py

@@ -107,6 +107,7 @@ 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:
@@ -114,6 +115,7 @@ def build_modality(
     parsed = parse_modality_path(
         path,
         split=split,
+        metadata_scope=metadata_scope,
     )
     return Modality(
         path=parsed.path,

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

@@ -571,6 +571,7 @@ 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:
@@ -580,6 +581,7 @@ def _modality(
         loader=loader,
         used_as=used_as,
         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.11.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.11.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.11.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.11.0 → euler_eval-2.12.0}/pyproject.toml

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

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

@@ -127,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.11.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)
 

{euler_eval-2.11.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()

{euler_eval-2.11.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(),