euler-eval 2.2.0__tar.gz → 2.4.0__tar.gz

{euler_eval-2.2.0 → euler_eval-2.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: euler-eval
-Version: 2.2.0
+Version: 2.4.0
 Summary: Depth map evaluation toolkit with comprehensive metrics
 Author: Depth Eval Contributors
 License: MIT
@@ -139,7 +139,7 @@ This pre-downloads:
 | `--mask-sky` | flag | off | Mask sky regions from metrics using GT segmentation |
 | `--no-sanity-check` | flag | off | Disable sanity checking of metric configurations |
 | `--metrics-config` | `str` | auto-detect | Path to `metrics_config.json` for sanity checking |
-| `--depth-alignment` | `{none,auto_affine,affine}` | `auto_affine` | Depth alignment mode (`depth` output uses aligned branch) |
+| `--depth-alignment` | `{none,auto_affine,affine}` | `auto_affine` | Depth calibration mode; outputs are emitted in semantic `native`/`metric` spaces and `depth` aliases the canonical branch |
 | `--rgb-fid-backend` | `{builtin,clean-fid}` | `builtin` | RGB FID backend; `clean-fid` requires optional dependency |
 | `--benchmark-depth-range` | `float float` | none | Depth range `[MIN, MAX]` in meters for benchmark evaluation; computes depth and RGB metrics for pixels within this range, subdivided into log-scaled near/mid/far bins (additive to regular metrics) |
 
@@ -341,10 +341,10 @@ When `--rgb-fid-backend clean-fid` is used, `euler-eval` will honor `CLEANFID_CA
 
 ```json
 {
-  "depth_raw": { "...": "metrics without alignment" },
-  "depth_aligned": { "...": "metrics with selected alignment mode" },
+  "depth_native": { "...": "native model depth space, if diagnostically meaningful" },
+  "depth_metric": { "...": "metric depth space, if available" },
   "depth": {
-    "...": "backward-compatible alias of depth_aligned"
+    "...": "canonical alias of depth_metric when present, else depth_native"
   },
   "rgb": {
     "...": "..."
@@ -358,9 +358,9 @@ When `--rgb-fid-backend clean-fid` is used, `euler-eval` will honor `CLEANFID_CA
               {
                 "id": "frame_0001",
                 "metrics": {
-                  "depth": { "...": "aligned (alias)" },
-                  "depth_raw": { "...": "raw" },
-                  "depth_aligned": { "...": "aligned" },
+                  "depth": { "...": "canonical alias" },
+                  "depth_native": { "...": "native, when emitted" },
+                  "depth_metric": { "...": "metric, when emitted" },
                   "rgb": { "...": "..." }
                 }
               }
@@ -374,9 +374,9 @@ When `--rgb-fid-backend clean-fid` is used, `euler-eval` will honor `CLEANFID_CA
 ```
 
 For depth outputs:
-- `depth_raw`: metric-space depth without any post-hoc alignment.
-- `depth_aligned`: metric-space depth after configured alignment mode.
-- `depth`: backward-compatible alias of `depth_aligned`.
+- `depth_native`: the model's native depth space after spatial/radial preprocessing, emitted only when it is diagnostically distinct.
+- `depth_metric`: the comparable metric-depth branch. This is either the native prediction itself or the calibrated scale-shift result.
+- `depth`: canonical alias of `depth_metric` when available, otherwise `depth_native`.
 - `standard`: explicit monocular-depth metrics with three reducers:
   `image_mean`, `image_median`, and `pixel_pool`.
 

{euler_eval-2.2.0 → euler_eval-2.4.0}/README.md

@@ -101,7 +101,7 @@ This pre-downloads:
 | `--mask-sky` | flag | off | Mask sky regions from metrics using GT segmentation |
 | `--no-sanity-check` | flag | off | Disable sanity checking of metric configurations |
 | `--metrics-config` | `str` | auto-detect | Path to `metrics_config.json` for sanity checking |
-| `--depth-alignment` | `{none,auto_affine,affine}` | `auto_affine` | Depth alignment mode (`depth` output uses aligned branch) |
+| `--depth-alignment` | `{none,auto_affine,affine}` | `auto_affine` | Depth calibration mode; outputs are emitted in semantic `native`/`metric` spaces and `depth` aliases the canonical branch |
 | `--rgb-fid-backend` | `{builtin,clean-fid}` | `builtin` | RGB FID backend; `clean-fid` requires optional dependency |
 | `--benchmark-depth-range` | `float float` | none | Depth range `[MIN, MAX]` in meters for benchmark evaluation; computes depth and RGB metrics for pixels within this range, subdivided into log-scaled near/mid/far bins (additive to regular metrics) |
 
@@ -303,10 +303,10 @@ When `--rgb-fid-backend clean-fid` is used, `euler-eval` will honor `CLEANFID_CA
 
 ```json
 {
-  "depth_raw": { "...": "metrics without alignment" },
-  "depth_aligned": { "...": "metrics with selected alignment mode" },
+  "depth_native": { "...": "native model depth space, if diagnostically meaningful" },
+  "depth_metric": { "...": "metric depth space, if available" },
   "depth": {
-    "...": "backward-compatible alias of depth_aligned"
+    "...": "canonical alias of depth_metric when present, else depth_native"
   },
   "rgb": {
     "...": "..."
@@ -320,9 +320,9 @@ When `--rgb-fid-backend clean-fid` is used, `euler-eval` will honor `CLEANFID_CA
               {
                 "id": "frame_0001",
                 "metrics": {
-                  "depth": { "...": "aligned (alias)" },
-                  "depth_raw": { "...": "raw" },
-                  "depth_aligned": { "...": "aligned" },
+                  "depth": { "...": "canonical alias" },
+                  "depth_native": { "...": "native, when emitted" },
+                  "depth_metric": { "...": "metric, when emitted" },
                   "rgb": { "...": "..." }
                 }
               }
@@ -336,9 +336,9 @@ When `--rgb-fid-backend clean-fid` is used, `euler-eval` will honor `CLEANFID_CA
 ```
 
 For depth outputs:
-- `depth_raw`: metric-space depth without any post-hoc alignment.
-- `depth_aligned`: metric-space depth after configured alignment mode.
-- `depth`: backward-compatible alias of `depth_aligned`.
+- `depth_native`: the model's native depth space after spatial/radial preprocessing, emitted only when it is diagnostically distinct.
+- `depth_metric`: the comparable metric-depth branch. This is either the native prediction itself or the calibrated scale-shift result.
+- `depth`: canonical alias of `depth_metric` when available, otherwise `depth_native`.
 - `standard`: explicit monocular-depth metrics with three reducers:
   `image_mean`, `image_median`, and `pixel_pool`.
 

{euler_eval-2.2.0 → euler_eval-2.4.0}/euler_eval/cli.py

@@ -56,11 +56,11 @@ class _EvalNamespace(MetricNamespace):
 
 # ── Axis declarations ───────────────────────────────────────────────────────
 
-_DEPTH_ALIGNMENT_AXIS = AxisDeclaration(
+_DEPTH_SPACE_AXIS = AxisDeclaration(
     position=0,
-    values=("raw", "aligned"),
+    values=("native", "metric"),
     optional=False,
-    description="Depth alignment mode",
+    description="Depth space semantics",
 )
 
 _DEPTH_CATEGORY_AXIS = AxisDeclaration(
@@ -107,7 +107,7 @@ _RGB_BENCHMARK_BIN_AXIS = AxisDeclaration(
 
 def _depth_eval_axes(*, benchmark: bool = False) -> dict[str, AxisDeclaration]:
     axes = {
-        "alignment": _DEPTH_ALIGNMENT_AXIS,
+        "space": _DEPTH_SPACE_AXIS,
         "category": _DEPTH_CATEGORY_AXIS,
         "reduction": _DEPTH_REDUCTION_AXIS,
     }
@@ -691,7 +691,10 @@ def main():
         type=str,
         default="auto_affine",
         choices=["none", "auto_affine", "affine"],
-        help="Depth alignment mode: none, auto_affine (default), or affine",
+        help=(
+            "Depth calibration mode: none, auto_affine (default), or affine. "
+            "Output is emitted in semantic native/metric spaces."
+        ),
     )
     parser.add_argument(
         "--rgb-fid-backend",
@@ -853,9 +856,9 @@ def main():
 
             # Build per-modality results for saving.
             # All metric names must be fully-qualified under the declared
-            # metricNamespace.  We nest raw/aligned under depth → eval so
+            # metricNamespace. We nest semantic spaces under depth → eval so
             # every flattened path starts with "depth.eval.".
-            alignment_info = depth_results.get("alignment", {})
+            space_info = depth_results.get("space_info", {})
             depth_dataset_info = depth_results.get("dataset_info", {})
 
             depth_spatial = depth_results.get("spatial_info", {})
@@ -870,8 +873,18 @@ def main():
                 "metricSet": depth_ns.metric_set_envelope(
                     "depth",
                     metadata={
-                        "alignment_mode": alignment_info.get("mode", "unknown"),
-                        "alignment_applied": alignment_info.get("applied", False),
+                        "input_space_detected": space_info.get(
+                            "input_space_detected", "unknown"
+                        ),
+                        "metric_space_source": space_info.get("metric_space_source"),
+                        "calibration_mode": space_info.get(
+                            "calibration_mode", "unknown"
+                        ),
+                        "calibration_applied": space_info.get(
+                            "calibration_applied", False
+                        ),
+                        "emitted_spaces": space_info.get("emitted_spaces", []),
+                        "canonical_space": space_info.get("canonical_space", "metric"),
                     },
                 ),
                 "dataset_info": depth_dataset_info,
@@ -908,40 +921,46 @@ def main():
                         ),
                     },
                 }),
-                "depth": {
-                    "eval": {
-                        "raw": _clean_metric_tree(depth_results["depth_raw"]),
-                        "aligned": _clean_metric_tree(
-                            depth_results["depth_aligned"]
-                        ),
-                    },
-                },
+                "depth": {"eval": {}},
             }
+            for space_name, result_key in (
+                ("native", "depth_native"),
+                ("metric", "depth_metric"),
+            ):
+                branch = depth_results.get(result_key)
+                if branch is not None:
+                    depth_save["depth"]["eval"][space_name] = _clean_metric_tree(branch)
 
             # Inject benchmark bin metrics under the existing category
             # keys so that the bin axis decomposes correctly:
-            #   depth.eval.aligned.standard.image_mean.{bin}.absrel
-            #   depth.eval.aligned.depth_metrics.{bin}.absrel.median
-            #   depth.eval.aligned.geometric_metrics.{bin}.normal_consistency.mean_angle
+            #   depth.eval.metric.standard.image_mean.{bin}.absrel
+            #   depth.eval.metric.depth_metrics.{bin}.absrel.median
+            #   depth.eval.metric.geometric_metrics.{bin}.normal_consistency.mean_angle
             depth_benchmark = depth_results.get("depth_benchmark")
             if depth_benchmark is not None:
-                aligned = depth_save["depth"]["eval"]["aligned"]
-                for bn in ("all", "near", "mid", "far"):
-                    bin_summary = depth_benchmark.get(bn, {})
-                    for category, metrics in bin_summary.items():
-                        cleaned = _clean_metric_tree(metrics)
-                        if cleaned:
-                            if category == "standard":
-                                bucket = aligned.setdefault(category, {})
-                                for reduction, reduction_metrics in cleaned.items():
-                                    bucket.setdefault(reduction, {})[bn] = reduction_metrics
-                            else:
-                                aligned.setdefault(category, {})[bn] = cleaned
+                for space_name in ("native", "metric"):
+                    if space_name not in depth_save["depth"]["eval"]:
+                        continue
+                    space_benchmark = depth_benchmark.get(space_name)
+                    if space_benchmark is None:
+                        continue
+                    target = depth_save["depth"]["eval"][space_name]
+                    for bn in ("all", "near", "mid", "far"):
+                        bin_summary = space_benchmark.get(bn, {})
+                        for category, metrics in bin_summary.items():
+                            cleaned = _clean_metric_tree(metrics)
+                            if cleaned:
+                                if category == "standard":
+                                    bucket = target.setdefault(category, {})
+                                    for reduction, reduction_metrics in cleaned.items():
+                                        bucket.setdefault(reduction, {})[bn] = reduction_metrics
+                                else:
+                                    target.setdefault(category, {})[bn] = cleaned
                 depth_save["metricSet"]["metadata"]["benchmark"] = {
                     "depth_range": depth_benchmark["boundaries"]["range"],
                     "boundaries": depth_benchmark["boundaries"],
                 }
-            for depth_key in ("depth", "depth_raw", "depth_aligned", "depth_benchmark"):
+            for depth_key in ("depth", "depth_native", "depth_metric", "depth_benchmark"):
                 if depth_key in depth_results and depth_results[depth_key] is not None:
                     all_results[depth_key] = depth_results[depth_key]
             depth_pfm = depth_results.get("per_file_metrics", {})
@@ -949,14 +968,17 @@ def main():
                 depth_save["per_file_metrics"] = _clean_metric_tree(
                     _wrap_pfm_metrics(
                         depth_pfm,
-                        lambda m: {
-                            "depth": {
-                                "eval": {
-                                    "raw": m.get("depth_raw", {}),
-                                    "aligned": m.get("depth_aligned", {}),
+                        lambda m: (
+                            {
+                                "depth": {
+                                    "eval": {
+                                        space: m[f"depth_{space}"]
+                                        for space in ("native", "metric")
+                                        if f"depth_{space}" in m
+                                    },
                                 },
-                            },
-                        },
+                            }
+                        ),
                     )
                 )
             all_results.setdefault("per_file_metrics", {}).update(depth_pfm)

{euler_eval-2.2.0 → euler_eval-2.4.0}/euler_eval/evaluate.py

@@ -103,12 +103,13 @@ def _init_benchmark_bin_store(temp_dir: Path, prefix: str) -> dict:
 
 def _close_benchmark_stores(stores: dict) -> None:
     """Close all streaming stores in a benchmark store dict."""
-    for bin_name in _BENCHMARK_BIN_NAMES:
-        s = stores[bin_name]
-        s["absrel_store"].close()
-        s["rmse_store"].close()
-        s["silog_store"].close()
-        s["normal_store"].close()
+    for space_stores in stores.values():
+        for bin_name in _BENCHMARK_BIN_NAMES:
+            s = space_stores[bin_name]
+            s["absrel_store"].close()
+            s["rmse_store"].close()
+            s["silog_store"].close()
+            s["normal_store"].close()
 
 
 def _safe_mean_values(values: list) -> Optional[float]:
@@ -322,6 +323,13 @@ def _ensure_file_system_sharing() -> None:
     runs accumulate FDs and eventually trip ``EMFILE`` ("Too many open
     files") mid-iteration. ``file_system`` uses ``/dev/shm`` file-backed
     storage instead, sidestepping the FD cap. Idempotent.
+
+    Caveat: activation is lazy — the strategy only flips the first time
+    a worker-spawning prefetch call runs. Any ``DataLoader`` / torch IPC
+    that fires *before* :func:`_prefetched_iter` reaches its workers
+    branch keeps the default strategy. In the current CLI flow, the
+    depth/RGB prefetch loop starts before any internal DataLoader (FID,
+    etc.), so those inherit the safe strategy by the time they run.
     """
     global _sharing_strategy_set
     if _sharing_strategy_set:
@@ -549,9 +557,9 @@ def evaluate_depth_samples(
 
     Returns:
         Dictionary containing depth aggregate/per-file metrics with:
-        ``depth_raw``, ``depth_aligned``, backward-compatible ``depth``,
-        explicit ``standard`` reducers within each depth branch, and
-        optionally ``depth_benchmark``.
+        optional ``depth_native`` and/or ``depth_metric`` semantic branches,
+        backward-compatible canonical ``depth``, and optionally
+        per-space ``depth_benchmark`` summaries.
     """
     valid_alignment_modes = {"none", "auto_affine", "affine"}
     if alignment_mode not in valid_alignment_modes:
@@ -882,12 +890,13 @@ def evaluate_depth_samples(
     logged_alignment = False
     normalized_predictions = False
     alignment_applied = False
+    input_space_detected = "unknown"
     gt_native_dims: Optional[tuple[int, int]] = None
     pred_native_dims: Optional[tuple[int, int]] = None
     spatial_method = "none"
 
     if alignment_mode == "none":
-        print("Depth alignment mode: none (raw predictions only)")
+        print("Depth alignment mode: none")
     elif alignment_mode == "auto_affine":
         print("Depth alignment mode: auto_affine (normalized-depth detection)")
     else:
@@ -925,8 +934,14 @@ def evaluate_depth_samples(
                 f"(log-scaled near/mid/far bins)"
             )
             benchmark_stores = {
-                bn: _init_benchmark_bin_store(temp_dir, f"bench_{bn}")
-                for bn in _BENCHMARK_BIN_NAMES
+                "native": {
+                    bn: _init_benchmark_bin_store(temp_dir, f"bench_native_{bn}")
+                    for bn in _BENCHMARK_BIN_NAMES
+                },
+                "metric": {
+                    bn: _init_benchmark_bin_store(temp_dir, f"bench_metric_{bn}")
+                    for bn in _BENCHMARK_BIN_NAMES
+                },
             }
 
         try:
@@ -969,21 +984,24 @@ def evaluate_depth_samples(
                     ):
                         sky_valid = align_to_prediction(sky_valid, depth_pred)
 
-                if alignment_mode == "auto_affine" and i == 0:
+                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:
                         normalized_predictions = True
+                        input_space_detected = "normalized"
                         print(
-                            f"  Scale-and-shift: detected normalized predictions "
+                            f"  Detected native depth space: normalized "
                             f"(range [{pred_min:.3f}, {pred_max:.3f}])"
                         )
                     else:
+                        input_space_detected = "metric"
                         print(
-                            f"  Scale-and-shift: predictions appear metric "
-                            f"(range [{pred_min:.1f}, {pred_max:.1f}]), "
-                            f"skipping alignment"
+                            f"  Detected native depth space: metric "
+                            f"(range [{pred_min:.1f}, {pred_max:.1f}])"
                         )
+                        if alignment_mode == "auto_affine":
+                            print("  Scale-and-shift: skipping calibration")
 
                 depth_gt = process_depth(depth_gt, 1.0, is_radial, intrinsics_K)
                 depth_pred_raw = process_depth(depth_pred, 1.0, is_radial, intrinsics_K)
@@ -1059,22 +1077,28 @@ def evaluate_depth_samples(
                     _append_metrics(stores["aligned"], aligned_metrics, aligned_pred_path)
 
                 raw_value = _build_per_file_depth_value(raw_metrics)
-                aligned_value = (
+                metric_value = (
                     raw_value
                     if aligned_metrics is raw_metrics
                     else _build_per_file_depth_value(aligned_metrics)
                 )
+                emit_native = alignment_applied or normalized_predictions
+                emit_metric = alignment_applied or not normalized_predictions
+                canonical_value = metric_value if emit_metric else raw_value
+                file_metrics = {
+                    "depth": canonical_value,
+                }
+                if emit_native:
+                    file_metrics["depth_native"] = raw_value
+                if emit_metric:
+                    file_metrics["depth_metric"] = metric_value
                 set_value(
                     per_file_metrics,
                     hierarchy,
                     entry_id,
                     {
                         "id": entry_id,
-                        "metrics": {
-                            "depth": aligned_value,
-                            "depth_raw": raw_value,
-                            "depth_aligned": aligned_value,
-                        },
+                        "metrics": file_metrics,
                     },
                 )
 
@@ -1102,7 +1126,7 @@ def evaluate_depth_samples(
                         v,
                         _store=stores["aligned"],
                         _slot=aligned_lpips_slot,
-                        _per_file=aligned_value,
+                        _per_file=metric_value,
                     ):
                         val = float(v) if np.isfinite(v) else float("nan")
                         _store["lpips_values"][_slot] = val
@@ -1116,8 +1140,8 @@ def evaluate_depth_samples(
 
                 # -- Enqueue batched GPU depth metrics; callbacks patch the
                 # placeholders that _compute_branch_metrics(defer_to_batcher=True)
-                # left behind and run the deferred sanity checks on the aligned
-                # branch.
+                # left behind and run the deferred sanity checks on the
+                # canonical emitted branch.
                 if defer_depth:
                     raw_depth_slot = len(stores["raw"]["psnr_values"]) - 1
                     # When aligned == raw, there is only one enqueue; run the
@@ -1159,7 +1183,7 @@ def evaluate_depth_samples(
                             _metrics=aligned_metrics,
                             _store=stores["aligned"],
                             _slot=aligned_depth_slot,
-                            _pf=aligned_value,
+                            _pf=metric_value,
                             _sanity=sanity_checker,
                             _entry_id=entry_id,
                         ):
@@ -1178,7 +1202,7 @@ def evaluate_depth_samples(
                             _aligned_depth_cb,
                         )
 
-                # -- Benchmark depth-range metrics (aligned only) --
+                # -- Benchmark depth-range metrics per emitted semantic space --
                 if benchmark_stores is not None:
                     bm_bins = get_benchmark_depth_bins(
                         depth_gt, benchmark_depth_range[0], benchmark_depth_range[1]
@@ -1187,72 +1211,136 @@ def evaluate_depth_samples(
                         benchmark_boundaries = bm_bins["boundaries"]
 
                     for bn in _BENCHMARK_BIN_NAMES:
-                        bin_mask = bm_bins[bn].copy()
-                        bin_mask &= (depth_pred_aligned > 0) & np.isfinite(
-                            depth_pred_aligned
+                        native_bin_mask = bm_bins[bn].copy()
+                        native_bin_mask &= (depth_pred_raw > 0) & np.isfinite(
+                            depth_pred_raw
                         )
                         if sky_valid is not None:
-                            bin_mask &= sky_valid
-                        if not bin_mask.any():
-                            continue
-
-                        bm_store = benchmark_stores[bn]
-
-                        bm_absrel = compute_absrel(
-                            depth_pred_aligned, depth_gt, valid_mask=bin_mask
-                        )
-                        bm_rmse = compute_rmse_per_pixel(
-                            depth_pred_aligned, depth_gt, valid_mask=bin_mask
-                        )
-                        bm_silog_arr = compute_silog_per_pixel(
-                            depth_pred_aligned, depth_gt, valid_mask=bin_mask
-                        )
-                        bm_silog_val = compute_scale_invariant_log_error(
-                            depth_pred_aligned, depth_gt, valid_mask=bin_mask
-                        )
-                        bm_standard, bm_standard_pool = compute_standard_depth_metrics(
-                            depth_pred_aligned, depth_gt, valid_mask=bin_mask
-                        )
-                        bm_normals = compute_normal_angles(
-                            depth_pred_aligned, depth_gt, valid_mask=bin_mask
-                        )
-
-                        bm_store["absrel_store"].append(bm_absrel)
-                        bm_store["rmse_store"].append(np.sqrt(bm_rmse))
-                        bm_store["silog_store"].append(bm_silog_arr)
-                        bm_store["silog_full_values"].append(bm_silog_val)
-                        append_standard_depth_metrics(
-                            bm_store["standard_store"],
-                            bm_standard,
-                            bm_standard_pool,
-                        )
-                        bm_store["normal_store"].append(bm_normals)
-                        if len(bm_normals) > 0:
-                            bm_store["normal_below_11_25"] += int(
-                                np.sum(bm_normals < 11.25)
+                            native_bin_mask &= sky_valid
+                        if native_bin_mask.any():
+                            bm_store = benchmark_stores["native"][bn]
+                            bm_absrel = compute_absrel(
+                                depth_pred_raw, depth_gt, valid_mask=native_bin_mask
+                            )
+                            bm_rmse = compute_rmse_per_pixel(
+                                depth_pred_raw, depth_gt, valid_mask=native_bin_mask
+                            )
+                            bm_silog_arr = compute_silog_per_pixel(
+                                depth_pred_raw, depth_gt, valid_mask=native_bin_mask
+                            )
+                            bm_silog_val = compute_scale_invariant_log_error(
+                                depth_pred_raw, depth_gt, valid_mask=native_bin_mask
+                            )
+                            bm_standard, bm_standard_pool = compute_standard_depth_metrics(
+                                depth_pred_raw, depth_gt, valid_mask=native_bin_mask
                             )
-                            bm_store["normal_below_22_5"] += int(
-                                np.sum(bm_normals < 22.5)
+                            bm_normals = compute_normal_angles(
+                                depth_pred_raw, depth_gt, valid_mask=native_bin_mask
                             )
-                            bm_store["normal_below_30"] += int(
-                                np.sum(bm_normals < 30.0)
+
+                            bm_store["absrel_store"].append(bm_absrel)
+                            bm_store["rmse_store"].append(np.sqrt(bm_rmse))
+                            bm_store["silog_store"].append(bm_silog_arr)
+                            bm_store["silog_full_values"].append(bm_silog_val)
+                            append_standard_depth_metrics(
+                                bm_store["standard_store"],
+                                bm_standard,
+                                bm_standard_pool,
+                            )
+                            bm_store["normal_store"].append(bm_normals)
+                            if len(bm_normals) > 0:
+                                bm_store["normal_below_11_25"] += int(
+                                    np.sum(bm_normals < 11.25)
+                                )
+                                bm_store["normal_below_22_5"] += int(
+                                    np.sum(bm_normals < 22.5)
+                                )
+                                bm_store["normal_below_30"] += int(
+                                    np.sum(bm_normals < 30.0)
+                                )
+
+                        if aligned_metrics is not raw_metrics:
+                            metric_bin_mask = bm_bins[bn].copy()
+                            metric_bin_mask &= (depth_pred_aligned > 0) & np.isfinite(
+                                depth_pred_aligned
                             )
+                            if sky_valid is not None:
+                                metric_bin_mask &= sky_valid
+                            if metric_bin_mask.any():
+                                bm_store = benchmark_stores["metric"][bn]
+                                bm_absrel = compute_absrel(
+                                    depth_pred_aligned,
+                                    depth_gt,
+                                    valid_mask=metric_bin_mask,
+                                )
+                                bm_rmse = compute_rmse_per_pixel(
+                                    depth_pred_aligned,
+                                    depth_gt,
+                                    valid_mask=metric_bin_mask,
+                                )
+                                bm_silog_arr = compute_silog_per_pixel(
+                                    depth_pred_aligned,
+                                    depth_gt,
+                                    valid_mask=metric_bin_mask,
+                                )
+                                bm_silog_val = compute_scale_invariant_log_error(
+                                    depth_pred_aligned,
+                                    depth_gt,
+                                    valid_mask=metric_bin_mask,
+                                )
+                                bm_standard, bm_standard_pool = compute_standard_depth_metrics(
+                                    depth_pred_aligned,
+                                    depth_gt,
+                                    valid_mask=metric_bin_mask,
+                                )
+                                bm_normals = compute_normal_angles(
+                                    depth_pred_aligned,
+                                    depth_gt,
+                                    valid_mask=metric_bin_mask,
+                                )
+
+                                bm_store["absrel_store"].append(bm_absrel)
+                                bm_store["rmse_store"].append(np.sqrt(bm_rmse))
+                                bm_store["silog_store"].append(bm_silog_arr)
+                                bm_store["silog_full_values"].append(bm_silog_val)
+                                append_standard_depth_metrics(
+                                    bm_store["standard_store"],
+                                    bm_standard,
+                                    bm_standard_pool,
+                                )
+                                bm_store["normal_store"].append(bm_normals)
+                                if len(bm_normals) > 0:
+                                    bm_store["normal_below_11_25"] += int(
+                                        np.sum(bm_normals < 11.25)
+                                    )
+                                    bm_store["normal_below_22_5"] += int(
+                                        np.sum(bm_normals < 22.5)
+                                    )
+                                    bm_store["normal_below_30"] += int(
+                                        np.sum(bm_normals < 30.0)
+                                    )
 
                 if sanity_checker is not None:
+                    canonical_pred = depth_pred_aligned if (
+                        alignment_applied or not normalized_predictions
+                    ) else depth_pred_raw
+                    canonical_metrics = aligned_metrics if (
+                        alignment_applied or not normalized_predictions
+                    ) else raw_metrics
                     sanity_checker.validate_depth_input(
-                        depth_gt, depth_pred_aligned, entry_id
+                        depth_gt, canonical_pred, entry_id
                     )
                     if not defer_depth:
                         # When deferred, the batcher callback runs these.
                         _run_deferred_depth_sanity(
-                            sanity_checker, aligned_metrics, entry_id
+                            sanity_checker, canonical_metrics, entry_id
                         )
-                    nm = aligned_metrics["normal_meta"]
+                    nm = canonical_metrics["normal_meta"]
                     if nm["mean_angle"] is not None:
                         sanity_checker.validate_normal_consistency(
                             nm["mean_angle"], nm["valid_pixels_after_erosion"], entry_id
                         )
-                    ef = aligned_metrics["edge_f1"]
+                    ef = canonical_metrics["edge_f1"]
                     sanity_checker.validate_depth_edge_f1(
                         ef["pred_edge_pixels"],
                         ef["gt_edge_pixels"],
@@ -1271,28 +1359,61 @@ def evaluate_depth_samples(
             print("Computing FID/KID (this may take a while)...")
             print("Aggregating depth results...")
 
-            depth_raw = _build_depth_summary(stores["raw"], gt_depth_paths)
-            if alignment_applied:
-                depth_aligned = _build_depth_summary(stores["aligned"], gt_depth_paths)
-            else:
-                depth_aligned = copy.deepcopy(depth_raw)
+            emit_native = alignment_applied or normalized_predictions
+            emit_metric = alignment_applied or not normalized_predictions
+
+            native_summary = (
+                _build_depth_summary(stores["raw"], gt_depth_paths)
+                if emit_native or (emit_metric and not alignment_applied)
+                else None
+            )
+            metric_summary = None
+            if emit_metric:
+                if alignment_applied:
+                    metric_summary = _build_depth_summary(
+                        stores["aligned"], gt_depth_paths
+                    )
+                else:
+                    metric_summary = copy.deepcopy(native_summary)
+            depth_summary = metric_summary if emit_metric else native_summary
 
             # -- Benchmark aggregation --
             depth_benchmark = None
             if benchmark_stores is not None:
                 print("Aggregating benchmark depth results...")
-                depth_benchmark = {
-                    "boundaries": benchmark_boundaries,
-                }
-                for bn in _BENCHMARK_BIN_NAMES:
-                    depth_benchmark[bn] = _build_benchmark_bin_summary(
-                        benchmark_stores[bn]
-                    )
+                depth_benchmark = {"boundaries": benchmark_boundaries}
+                if emit_native or (emit_metric and not alignment_applied):
+                    native_benchmark = {
+                        bn: _build_benchmark_bin_summary(
+                            benchmark_stores["native"][bn]
+                        )
+                        for bn in _BENCHMARK_BIN_NAMES
+                    }
+                else:
+                    native_benchmark = None
+                if emit_native:
+                    depth_benchmark["native"] = native_benchmark
+                if emit_metric:
+                    if alignment_applied:
+                        depth_benchmark["metric"] = {
+                            bn: _build_benchmark_bin_summary(
+                                benchmark_stores["metric"][bn]
+                            )
+                            for bn in _BENCHMARK_BIN_NAMES
+                        }
+                    else:
+                        depth_benchmark["metric"] = copy.deepcopy(native_benchmark)
+
+            emitted_spaces = []
+            if emit_native:
+                emitted_spaces.append("native")
+            if emit_metric:
+                emitted_spaces.append("metric")
 
             result = {
-                "depth_raw": depth_raw,
-                "depth_aligned": depth_aligned,
-                "depth": depth_aligned,
+                "depth_native": native_summary if emit_native else None,
+                "depth_metric": metric_summary if emit_metric else None,
+                "depth": depth_summary,
                 "depth_benchmark": depth_benchmark,
                 "per_file_metrics": per_file_metrics,
                 "dataset_info": {
@@ -1300,9 +1421,17 @@ def evaluate_depth_samples(
                     "gt_name": gt_name,
                     "pred_name": pred_name,
                 },
-                "alignment": {
-                    "mode": alignment_mode,
-                    "applied": alignment_applied,
+                "space_info": {
+                    "input_space_detected": input_space_detected,
+                    "metric_space_source": (
+                        "scale_shift"
+                        if alignment_applied
+                        else ("native" if emit_metric else None)
+                    ),
+                    "calibration_mode": alignment_mode,
+                    "calibration_applied": alignment_applied,
+                    "emitted_spaces": emitted_spaces,
+                    "canonical_space": "metric" if emit_metric else "native",
                 },
                 "spatial_info": {
                     "gt_dimensions": {"height": gt_native_dims[0], "width": gt_native_dims[1]}

{euler_eval-2.2.0 → euler_eval-2.4.0}/euler_eval/metrics/gpu_image_batch.py

@@ -23,8 +23,8 @@ import numpy as np
 import torch
 
 try:
-    from torchmetrics.functional import peak_signal_noise_ratio as _tm_psnr
     from torchmetrics.functional.image import (
+        peak_signal_noise_ratio as _tm_psnr,
         structural_similarity_index_measure as _tm_ssim,
     )
 

{euler_eval-2.2.0 → euler_eval-2.4.0}/euler_eval.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: euler-eval
-Version: 2.2.0
+Version: 2.4.0
 Summary: Depth map evaluation toolkit with comprehensive metrics
 Author: Depth Eval Contributors
 License: MIT
@@ -139,7 +139,7 @@ This pre-downloads:
 | `--mask-sky` | flag | off | Mask sky regions from metrics using GT segmentation |
 | `--no-sanity-check` | flag | off | Disable sanity checking of metric configurations |
 | `--metrics-config` | `str` | auto-detect | Path to `metrics_config.json` for sanity checking |
-| `--depth-alignment` | `{none,auto_affine,affine}` | `auto_affine` | Depth alignment mode (`depth` output uses aligned branch) |
+| `--depth-alignment` | `{none,auto_affine,affine}` | `auto_affine` | Depth calibration mode; outputs are emitted in semantic `native`/`metric` spaces and `depth` aliases the canonical branch |
 | `--rgb-fid-backend` | `{builtin,clean-fid}` | `builtin` | RGB FID backend; `clean-fid` requires optional dependency |
 | `--benchmark-depth-range` | `float float` | none | Depth range `[MIN, MAX]` in meters for benchmark evaluation; computes depth and RGB metrics for pixels within this range, subdivided into log-scaled near/mid/far bins (additive to regular metrics) |
 
@@ -341,10 +341,10 @@ When `--rgb-fid-backend clean-fid` is used, `euler-eval` will honor `CLEANFID_CA
 
 ```json
 {
-  "depth_raw": { "...": "metrics without alignment" },
-  "depth_aligned": { "...": "metrics with selected alignment mode" },
+  "depth_native": { "...": "native model depth space, if diagnostically meaningful" },
+  "depth_metric": { "...": "metric depth space, if available" },
   "depth": {
-    "...": "backward-compatible alias of depth_aligned"
+    "...": "canonical alias of depth_metric when present, else depth_native"
   },
   "rgb": {
     "...": "..."
@@ -358,9 +358,9 @@ When `--rgb-fid-backend clean-fid` is used, `euler-eval` will honor `CLEANFID_CA
               {
                 "id": "frame_0001",
                 "metrics": {
-                  "depth": { "...": "aligned (alias)" },
-                  "depth_raw": { "...": "raw" },
-                  "depth_aligned": { "...": "aligned" },
+                  "depth": { "...": "canonical alias" },
+                  "depth_native": { "...": "native, when emitted" },
+                  "depth_metric": { "...": "metric, when emitted" },
                   "rgb": { "...": "..." }
                 }
               }
@@ -374,9 +374,9 @@ When `--rgb-fid-backend clean-fid` is used, `euler-eval` will honor `CLEANFID_CA
 ```
 
 For depth outputs:
-- `depth_raw`: metric-space depth without any post-hoc alignment.
-- `depth_aligned`: metric-space depth after configured alignment mode.
-- `depth`: backward-compatible alias of `depth_aligned`.
+- `depth_native`: the model's native depth space after spatial/radial preprocessing, emitted only when it is diagnostically distinct.
+- `depth_metric`: the comparable metric-depth branch. This is either the native prediction itself or the calibrated scale-shift result.
+- `depth`: canonical alias of `depth_metric` when available, otherwise `depth_native`.
 - `standard`: explicit monocular-depth metrics with three reducers:
   `image_mean`, `image_median`, and `pixel_pool`.
 

{euler_eval-2.2.0 → euler_eval-2.4.0}/pyproject.toml

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

{euler_eval-2.2.0 → euler_eval-2.4.0}/tests/test_depth_alignment_output.py

@@ -1,4 +1,4 @@
-"""Tests for depth raw/aligned output structure and alignment behavior."""
+"""Tests for semantic depth-space output and calibration behavior."""
 
 from pathlib import Path
 
@@ -222,7 +222,29 @@ def _make_dataset_with_segmentation():
     return _DummyDepthDataset(samples)
 
 
-def test_depth_output_contains_raw_and_aligned(monkeypatch):
+def _make_metric_dataset():
+    gt_a = np.array([[10.0, 20.0], [30.0, 40.0]], dtype=np.float32)
+    gt_b = np.array([[6.0, 12.0], [18.0, 24.0]], dtype=np.float32)
+    pred_a = (gt_a * 1.02).astype(np.float32)
+    pred_b = (gt_b * 0.98).astype(np.float32)
+    samples = [
+        {
+            "id": "00001",
+            "full_id": "/Scene01/clone/00001",
+            "gt": gt_a,
+            "pred": pred_a,
+        },
+        {
+            "id": "00002",
+            "full_id": "/Scene01/clone/00002",
+            "gt": gt_b,
+            "pred": pred_b,
+        },
+    ]
+    return _DummyDepthDataset(samples)
+
+
+def test_depth_output_contains_native_and_metric_for_calibrated_normalized_input(monkeypatch):
     _patch_depth_metrics(monkeypatch)
 
     results = eval_mod.evaluate_depth_samples(
@@ -232,36 +254,38 @@ def test_depth_output_contains_raw_and_aligned(monkeypatch):
         alignment_mode="auto_affine",
     )
 
-    assert "depth_raw" in results
-    assert "depth_aligned" in results
+    assert "depth_native" in results
+    assert "depth_metric" in results
     assert "depth" in results
 
-    raw_absrel = results["depth_raw"]["depth_metrics"]["absrel"]["median"]
-    aligned_absrel = results["depth_aligned"]["depth_metrics"]["absrel"]["median"]
-    raw_standard_absrel = results["depth_raw"]["standard"]["image_mean"]["absrel"]
-    aligned_standard_absrel = results["depth_aligned"]["standard"]["image_mean"]["absrel"]
-    assert aligned_absrel < raw_absrel
-    assert aligned_standard_absrel < raw_standard_absrel
-    assert results["alignment"]["applied"] is True
+    native_absrel = results["depth_native"]["depth_metrics"]["absrel"]["median"]
+    metric_absrel = results["depth_metric"]["depth_metrics"]["absrel"]["median"]
+    native_standard_absrel = results["depth_native"]["standard"]["image_mean"]["absrel"]
+    metric_standard_absrel = results["depth_metric"]["standard"]["image_mean"]["absrel"]
+    assert metric_absrel < native_absrel
+    assert metric_standard_absrel < native_standard_absrel
+    assert results["space_info"]["calibration_applied"] is True
+    assert results["space_info"]["emitted_spaces"] == ["native", "metric"]
+    assert results["space_info"]["canonical_space"] == "metric"
 
     files = results["per_file_metrics"]["children"]["Scene01"]["children"]["clone"][
         "files"
     ]
     per_file = next(item["metrics"] for item in files if item["id"] == "00001")
     assert "depth" in per_file
-    assert "depth_raw" in per_file
-    assert "depth_aligned" in per_file
+    assert "depth_native" in per_file
+    assert "depth_metric" in per_file
     assert (
-        per_file["depth_aligned"]["depth_metrics"]["absrel"]
-        < per_file["depth_raw"]["depth_metrics"]["absrel"]
+        per_file["depth_metric"]["depth_metrics"]["absrel"]
+        < per_file["depth_native"]["depth_metrics"]["absrel"]
     )
     assert (
-        per_file["depth_aligned"]["standard"]["absrel"]
-        < per_file["depth_raw"]["standard"]["absrel"]
+        per_file["depth_metric"]["standard"]["absrel"]
+        < per_file["depth_native"]["standard"]["absrel"]
     )
 
 
-def test_depth_alignment_none_keeps_raw_and_aligned_equal(monkeypatch):
+def test_depth_alignment_none_emits_only_native_for_normalized_input(monkeypatch):
     _patch_depth_metrics(monkeypatch)
 
     results = eval_mod.evaluate_depth_samples(
@@ -271,13 +295,34 @@ def test_depth_alignment_none_keeps_raw_and_aligned_equal(monkeypatch):
         alignment_mode="none",
     )
 
-    raw = results["depth_raw"]["depth_metrics"]["absrel"]["median"]
-    aligned = results["depth_aligned"]["depth_metrics"]["absrel"]["median"]
-    raw_standard = results["depth_raw"]["standard"]["pixel_pool"]["absrel"]
-    aligned_standard = results["depth_aligned"]["standard"]["pixel_pool"]["absrel"]
-    assert raw == aligned
-    assert raw_standard == aligned_standard
-    assert results["alignment"]["applied"] is False
+    assert "depth_native" in results and results["depth_native"] is not None
+    assert results.get("depth_metric") is None
+    assert results["depth"] == results["depth_native"]
+    assert results["space_info"]["calibration_applied"] is False
+    assert results["space_info"]["emitted_spaces"] == ["native"]
+    assert results["space_info"]["canonical_space"] == "native"
+
+
+def test_metric_input_emits_only_metric_when_no_calibration_is_needed(monkeypatch):
+    _patch_depth_metrics(monkeypatch)
+
+    results = eval_mod.evaluate_depth_samples(
+        dataset=_make_metric_dataset(),
+        is_radial=True,
+        device="cpu",
+        alignment_mode="auto_affine",
+    )
+
+    assert results.get("depth_native") is None
+    assert "depth_metric" in results and results["depth_metric"] is not None
+    assert results["depth"] == results["depth_metric"]
+    assert results["space_info"]["input_space_detected"] == "metric"
+    assert results["space_info"]["metric_space_source"] == "native"
+    assert results["space_info"]["emitted_spaces"] == ["metric"]
+    files = results["per_file_metrics"]["children"]["Scene01"]["children"]["clone"]["files"]
+    per_file = next(item["metrics"] for item in files if item["id"] == "00001")
+    assert "depth_metric" in per_file
+    assert "depth_native" not in per_file
 
 
 def test_depth_output_contains_spatial_info(monkeypatch):

{euler_eval-2.2.0 → euler_eval-2.4.0}/tests/test_meta_output.py

@@ -89,7 +89,7 @@ class TestMetaBlockStructure:
                 "pred": {"dimensions": {"height": 50, "width": 100}},
                 "spatial_alignment": {"method": "resize"},
             },
-            "depth": {"eval": {"raw": {}, "aligned": {}}},
+            "depth": {"eval": {"native": {}, "metric": {}}},
         }
         cleaned = _clean_metric_tree(save_dict)
         assert "meta" in cleaned
@@ -126,16 +126,16 @@ class TestAxisDeclarations:
     """Verify axis declarations follow the metric-namespacing convention."""
 
     def test_depth_axes_structure(self):
-        """depth.eval declares alignment, category, and reduction axes."""
-        assert "alignment" in _DEPTH_EVAL_AXES
+        """depth.eval declares space, category, and reduction axes."""
+        assert "space" in _DEPTH_EVAL_AXES
         assert "category" in _DEPTH_EVAL_AXES
         assert "reduction" in _DEPTH_EVAL_AXES
 
-        alignment = _DEPTH_EVAL_AXES["alignment"]
-        assert alignment.position == 0
-        assert alignment.optional is False
-        assert "raw" in alignment.values
-        assert "aligned" in alignment.values
+        space = _DEPTH_EVAL_AXES["space"]
+        assert space.position == 0
+        assert space.optional is False
+        assert "native" in space.values
+        assert "metric" in space.values
 
         category = _DEPTH_EVAL_AXES["category"]
         assert category.position == 1
@@ -264,6 +264,6 @@ class TestMetricDescriptions:
         envelope = ns.metric_set_envelope("depth", metadata={})
         assert "axes" in envelope
         assert "metricDescriptions" in envelope
-        assert envelope["axes"]["alignment"]["position"] == 0
+        assert envelope["axes"]["space"]["position"] == 0
         assert envelope["axes"]["reduction"]["position"] == 2
         assert "psnr" in envelope["metricDescriptions"]