euler-eval 2.26.0__tar.gz → 2.28.0__tar.gz

{euler_eval-2.26.0 → euler_eval-2.28.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: euler-eval
-Version: 2.26.0
+Version: 2.28.0
 Summary: Evaluation toolkit for depth, RGB, ray and 3D point-map predictions
 Author-email: Daniel Rothenpieler <rothenpielerdaniel@gmail.com>
 License: MIT
@@ -158,10 +158,10 @@ straight out of the archive. Full schema: [Configuration](docs/configuration.md)
 | Modality | Config key | Scored against | Headline metrics |
 |---|---|---|---|
 | **Depth** | `depth`, `relative_depth`, `affine_depth` | dense GT depth | `absrel`…`delta3`, PSNR/SSIM/LPIPS/FID/KID, surface-normal consistency, depth-edge F1 |
-| **Sparse depth** | `depth` + `gt.sparse_depth` | a LiDAR-style point cloud, projected into the prediction plane | pointwise depth metrics at projected points, plus directed 3D completeness |
+| **Sparse depth** | `depth` + `gt.sparse_depth` | a LiDAR-style point cloud, projected into the prediction plane | pointwise depth metrics at projected points |
 | **RGB** | `rgb` | GT RGB | PSNR, SSIM, LPIPS, FID, SCE, edge F1, tail errors, HF energy ratio, depth-binned photometric error; optional NIQE/FADE dehazing metrics |
 | **Rays** | `rays` | GT ray direction map | ρ_A (angular-accuracy AUC), angular error, threshold percentages |
-| **Points-3D** | `points_3d` | GT point map, or GT depth unprojected on the fly | 3D EPE/RMSE/δ, radial-vs-lateral decomposition, true-3D normals and edge F1, Chamfer / F-score |
+| **Points-3D** | `points_3d` | GT point map, GT depth unprojected on the fly, or a sparse point cloud | 3D EPE/RMSE/δ, radial-vs-lateral decomposition, true-3D normals and edge F1, Chamfer / F-score |
 
 A run evaluates whichever modalities are configured on both sides; a depth-only
 prediction is a perfectly ordinary run. The full inventory, with the key each

{euler_eval-2.26.0 → euler_eval-2.28.0}/README.md

@@ -109,10 +109,10 @@ straight out of the archive. Full schema: [Configuration](docs/configuration.md)
 | Modality | Config key | Scored against | Headline metrics |
 |---|---|---|---|
 | **Depth** | `depth`, `relative_depth`, `affine_depth` | dense GT depth | `absrel`…`delta3`, PSNR/SSIM/LPIPS/FID/KID, surface-normal consistency, depth-edge F1 |
-| **Sparse depth** | `depth` + `gt.sparse_depth` | a LiDAR-style point cloud, projected into the prediction plane | pointwise depth metrics at projected points, plus directed 3D completeness |
+| **Sparse depth** | `depth` + `gt.sparse_depth` | a LiDAR-style point cloud, projected into the prediction plane | pointwise depth metrics at projected points |
 | **RGB** | `rgb` | GT RGB | PSNR, SSIM, LPIPS, FID, SCE, edge F1, tail errors, HF energy ratio, depth-binned photometric error; optional NIQE/FADE dehazing metrics |
 | **Rays** | `rays` | GT ray direction map | ρ_A (angular-accuracy AUC), angular error, threshold percentages |
-| **Points-3D** | `points_3d` | GT point map, or GT depth unprojected on the fly | 3D EPE/RMSE/δ, radial-vs-lateral decomposition, true-3D normals and edge F1, Chamfer / F-score |
+| **Points-3D** | `points_3d` | GT point map, GT depth unprojected on the fly, or a sparse point cloud | 3D EPE/RMSE/δ, radial-vs-lateral decomposition, true-3D normals and edge F1, Chamfer / F-score |
 
 A run evaluates whichever modalities are configured on both sides; a depth-only
 prediction is a perfectly ordinary run. The full inventory, with the key each

{euler_eval-2.26.0 → euler_eval-2.28.0}/euler_eval/cli.py

@@ -30,6 +30,7 @@ from .data import (
     get_rays_metadata,
     get_rgb_metadata,
     get_sparse_depth_metadata,
+    validate_sky_depth,
 )
 from .evaluate import (
     evaluate_depth_samples,
@@ -906,7 +907,16 @@ def validate_dataset_entry(entry: dict, index: int) -> None:
             "or 'points_3d.path'"
         )
 
-    for modality in ("rgb", *_PRED_DEPTH_KEYS, "rays", "points_3d"):
+    if "sky_mask" in entry:
+        if not isinstance(entry["sky_mask"], dict) or not entry["sky_mask"].get("path"):
+            raise ValueError(f"{label}.sky_mask must have a 'path' field")
+        if not has_depth:
+            raise ValueError(
+                f"{label}.sky_mask requires a dense depth prediction "
+                "('depth', 'relative_depth', or 'affine_depth')"
+            )
+
+    for modality in ("rgb", *_PRED_DEPTH_KEYS, "rays", "points_3d", "sky_mask"):
         if modality in entry and "path" in entry[modality]:
             p = normalize_modality_path(
                 entry[modality]["path"],
@@ -1166,6 +1176,17 @@ def main():
         action="store_true",
         help="Mask sky regions from metrics using GT segmentation",
     )
+    parser.add_argument(
+        "--sky-depth",
+        type=float,
+        default=None,
+        metavar="METERS",
+        help=(
+            "Cap GT and predicted depths at this finite positive value after "
+            "conversion/alignment; fill predicted sky_mask pixels with it "
+            "(default: disabled)"
+        ),
+    )
     parser.add_argument(
         "--no-sanity-check",
         action="store_true",
@@ -1219,6 +1240,10 @@ def main():
     )
 
     args = parser.parse_args()
+    try:
+        validate_sky_depth(args.sky_depth)
+    except ValueError as e:
+        parser.error(f"--sky-depth: {e}")
 
     selected_metric_sets = resolve_metric_sets(args.domains)
 
@@ -1237,6 +1262,8 @@ def main():
     configure_torch_runtime(args.device)
     print_device_info(requested_device, args.device)
     print(f"Depth alignment: {args.depth_alignment}")
+    if args.sky_depth is not None:
+        print(f"Sky depth: {args.sky_depth} meters (depth cap and predicted sky fill)")
     print(f"RGB FID backend: {args.rgb_fid_backend}")
     print(
         "Metric sets: "
@@ -1320,6 +1347,11 @@ def main():
         ds_name = dataset_config["name"]
         pred_depth_key, pred_depth_config = _prediction_depth_entry(dataset_config)
         has_depth = pred_depth_config is not None
+        pred_sky_mask_config = (
+            dataset_config.get("sky_mask", {}) if args.sky_depth is not None else {}
+        )
+        pred_sky_mask_path = pred_sky_mask_config.get("path")
+        pred_sky_mask_split = pred_sky_mask_config.get("split")
         has_rgb = "rgb" in dataset_config and "path" in dataset_config["rgb"]
         has_rays = "rays" in dataset_config and "path" in dataset_config["rays"]
         has_points_3d = (
@@ -1364,6 +1396,8 @@ def main():
             depth_dataset = build_depth_eval_dataset(
                 gt_depth_path=gt_depth_path,
                 pred_depth_path=pred_depth_path,
+                pred_sky_mask_path=pred_sky_mask_path,
+                pred_sky_mask_split=pred_sky_mask_split,
                 calibration_path=calibration_path,
                 segmentation_path=segmentation_path,
                 pred_depth_metadata_scope=(
@@ -1392,6 +1426,7 @@ def main():
                 verbose=args.verbose,
                 sanity_checker=sanity_checker,
                 sky_mask_enabled=args.mask_sky,
+                sky_depth=args.sky_depth,
                 alignment_mode=args.depth_alignment,
                 benchmark_depth_range=(
                     tuple(args.benchmark_depth_range)
@@ -1452,6 +1487,7 @@ def main():
                         "split": pred_depth_split,
                         "entry": pred_depth_key,
                         "dimensions": depth_spatial.get("pred_dimensions"),
+                        "sky_mask": pred_sky_mask_config or None,
                     },
                     "spatial_alignment": {
                         "method": depth_spatial.get("method", "none"),
@@ -1463,6 +1499,7 @@ def main():
                     "eval_params": {
                         "sky_masking": args.mask_sky,
                         "depth_alignment_mode": args.depth_alignment,
+                        "sky_depth": args.sky_depth,
                         "batch_size": args.batch_size,
                         "num_workers": args.num_workers,
                         "benchmark_depth_range": (
@@ -1555,6 +1592,8 @@ def main():
             sparse_depth_dataset = build_sparse_depth_eval_dataset(
                 gt_sparse_depth_path=gt_sparse_depth_path,
                 pred_depth_path=pred_depth_path,
+                pred_sky_mask_path=pred_sky_mask_path,
+                pred_sky_mask_split=pred_sky_mask_split,
                 intrinsics_path=intrinsics_path,
                 camera_extrinsics_path=camera_extrinsics_path,
                 lidar_extrinsics_path=lidar_extrinsics_path,
@@ -1585,6 +1624,7 @@ def main():
                 verbose=args.verbose,
                 sanity_checker=sanity_checker,
                 sky_mask_enabled=args.mask_sky,
+                sky_depth=args.sky_depth,
                 alignment_mode=args.depth_alignment,
                 benchmark_depth_range=(
                     tuple(args.benchmark_depth_range)
@@ -1640,6 +1680,7 @@ def main():
                         "split": pred_depth_split,
                         "entry": pred_depth_key,
                         "dimensions": sparse_depth_spatial.get("pred_dimensions"),
+                        "sky_mask": pred_sky_mask_config or None,
                     },
                     "calibration": {
                         "intrinsics_path": intrinsics_path,
@@ -1661,6 +1702,7 @@ def main():
                     "eval_params": {
                         "sky_masking": args.mask_sky,
                         "depth_alignment_mode": args.depth_alignment,
+                        "sky_depth": args.sky_depth,
                         "num_workers": args.num_workers,
                         "benchmark_depth_range": (
                             list(args.benchmark_depth_range)
@@ -2198,80 +2240,42 @@ def main():
         # -- Points-3D against sparse pointcloud GT --
         # When the GT is a sparse LiDAR cloud (gt.sparse_depth), evaluate the
         # *3D* metrics (Chamfer/F-score completeness + per-correspondence 3D
-        # error) against the sparse GT cloud. Two prediction sources are
-        # supported, with the native point map preferred when both are present:
-        #   - a predicted points_3d map, scored directly (3D similarity gauge);
-        #   - a dense depth map, unprojected with the GT intrinsics (affine
-        #     gauge). Independent of the sparse-depth pointwise branch; gated by
-        #     --skip-points-3d.
+        # error) against the sparse GT cloud. This is an atomic points_3d
+        # evaluation and therefore requires an explicit predicted points_3d map;
+        # a depth prediction is handled only by the sparse-depth branch above.
         if (
             gt_sparse_depth_path
-            and (has_points_3d or has_depth)
+            and has_points_3d
             and not args.skip_points_3d
         ):
-            p3s_pred_is_depth = not has_points_3d
             print(f"\n[POINTS_3D · SPARSE] Evaluating: '{ds_name}'")
             print(f"  GT sparse pointcloud: {gt_sparse_depth_path}")
-            if p3s_pred_is_depth:
-                p3s_pred_path = pred_depth_config["path"]
-                p3s_pred_split = pred_depth_config.get("split")
-                p3s_pred_entry = pred_depth_key
-                print(f"  Pred dense depth:     {p3s_pred_path}")
-                if pred_depth_key != "depth":
-                    print(f"  Pred depth entry:     {pred_depth_key}")
-                points_3d_sparse_dataset = build_sparse_depth_eval_dataset(
-                    gt_sparse_depth_path=gt_sparse_depth_path,
-                    pred_depth_path=p3s_pred_path,
-                    intrinsics_path=intrinsics_path,
-                    camera_extrinsics_path=camera_extrinsics_path,
-                    lidar_extrinsics_path=lidar_extrinsics_path,
-                    segmentation_path=segmentation_path,
-                    pred_depth_metadata_scope=(
-                        pred_depth_key if pred_depth_key != "depth" else None
-                    ),
-                    segmentation_modality_key=segmentation_key or "segmentation",
-                    gt_sparse_depth_split=gt_sparse_depth_split,
-                    pred_depth_split=p3s_pred_split,
-                    intrinsics_split=intrinsics_split,
-                    camera_extrinsics_split=camera_extrinsics_split,
-                    lidar_extrinsics_split=lidar_extrinsics_split,
-                    segmentation_split=segmentation_split,
-                )
-                p3ds_meta = get_sparse_depth_metadata(points_3d_sparse_dataset)
-                p3s_pred_is_radial = p3ds_meta["pred_radial_depth"]
-                p3s_alignment_mode = args.depth_alignment
-                p3s_input_hint = _prediction_depth_space_hint(pred_depth_key)
-                print(f"  pred_radial_depth: {p3s_pred_is_radial}")
-            else:
-                p3s_pred_path = dataset_config["points_3d"]["path"]
-                p3s_pred_split = dataset_config["points_3d"].get("split")
-                p3s_pred_entry = "points_3d"
-                print(f"  Pred point map:       {p3s_pred_path}")
-                points_3d_sparse_dataset = build_points_3d_sparse_eval_dataset(
-                    gt_sparse_depth_path=gt_sparse_depth_path,
-                    pred_points_3d_path=p3s_pred_path,
-                    intrinsics_path=intrinsics_path,
-                    camera_extrinsics_path=camera_extrinsics_path,
-                    lidar_extrinsics_path=lidar_extrinsics_path,
-                    segmentation_path=segmentation_path,
-                    segmentation_modality_key=segmentation_key or "segmentation",
-                    gt_sparse_depth_split=gt_sparse_depth_split,
-                    pred_points_3d_split=p3s_pred_split,
-                    intrinsics_split=intrinsics_split,
-                    camera_extrinsics_split=camera_extrinsics_split,
-                    lidar_extrinsics_split=lidar_extrinsics_split,
-                    segmentation_split=segmentation_split,
-                )
-                p3ds_meta = get_points_3d_metadata(points_3d_sparse_dataset)
-                p3s_pred_is_radial = True
-                p3s_alignment_mode = args.points_3d_alignment
-                p3s_input_hint = None
+            p3s_pred_path = dataset_config["points_3d"]["path"]
+            p3s_pred_split = dataset_config["points_3d"].get("split")
+            print(f"  Pred point map:       {p3s_pred_path}")
+            points_3d_sparse_dataset = build_points_3d_sparse_eval_dataset(
+                gt_sparse_depth_path=gt_sparse_depth_path,
+                pred_points_3d_path=p3s_pred_path,
+                intrinsics_path=intrinsics_path,
+                camera_extrinsics_path=camera_extrinsics_path,
+                lidar_extrinsics_path=lidar_extrinsics_path,
+                segmentation_path=segmentation_path,
+                segmentation_modality_key=segmentation_key or "segmentation",
+                gt_sparse_depth_split=gt_sparse_depth_split,
+                pred_points_3d_split=p3s_pred_split,
+                intrinsics_split=intrinsics_split,
+                camera_extrinsics_split=camera_extrinsics_split,
+                lidar_extrinsics_split=lidar_extrinsics_split,
+                segmentation_split=segmentation_split,
+            )
+            p3ds_meta = get_points_3d_metadata(points_3d_sparse_dataset)
+            p3s_alignment_mode = args.points_3d_alignment
             et_eval_datasets["points_3d_sparse"] = points_3d_sparse_dataset
             print(f"  Matched pairs: {len(points_3d_sparse_dataset)}")
 
             points_3d_sparse_results = evaluate_points_3d_sparse_samples(
                 dataset=points_3d_sparse_dataset,
-                pred_is_radial=p3s_pred_is_radial,
+                pred_is_radial=True,
                 gt_name=gt.get("name", "GT"),
                 pred_name=ds_name,
                 num_workers=args.num_workers,
@@ -2279,8 +2283,8 @@ def main():
                 sanity_checker=sanity_checker,
                 sky_mask_enabled=args.mask_sky,
                 alignment_mode=p3s_alignment_mode,
-                input_space_hint=p3s_input_hint,
-                pred_is_depth=p3s_pred_is_depth,
+                input_space_hint=None,
+                pred_is_depth=False,
             )
 
             if sanity_checker is not None:
@@ -2335,8 +2339,8 @@ def main():
                     "pred": {
                         "path": p3s_pred_path,
                         "split": p3s_pred_split,
-                        "entry": p3s_pred_entry,
-                        "representation": "depth" if p3s_pred_is_depth else "points_3d",
+                        "entry": "points_3d",
+                        "representation": "points_3d",
                         "dimensions": p3s_spatial.get("pred_dimensions"),
                     },
                     "calibration": {

{euler_eval-2.26.0 → euler_eval-2.28.0}/euler_eval/data.py

@@ -614,6 +614,12 @@ def align_to_prediction(gt: np.ndarray, pred: np.ndarray) -> np.ndarray:
     return result.astype(bool) if is_bool else result
 
 
+def validate_sky_depth(sky_depth: Optional[float]) -> None:
+    """Require a finite positive depth cap when sky-depth processing is enabled."""
+    if sky_depth is not None and (not np.isfinite(sky_depth) or sky_depth <= 0):
+        raise ValueError("sky_depth must be a finite positive value")
+
+
 def compute_scale_and_shift(
     pred: np.ndarray,
     gt: np.ndarray,
@@ -760,11 +766,14 @@ def build_depth_eval_dataset(
     segmentation_split: Optional[str] = None,
     pred_depth_metadata_scope: Optional[str] = None,
     segmentation_modality_key: str = "segmentation",
+    pred_sky_mask_path: Optional[str] = None,
+    pred_sky_mask_split: Optional[str] = None,
 ) -> MultiModalDataset:
     """Build a MultiModalDataset for depth evaluation.
 
     The returned dataset yields samples with keys ``"gt"``, ``"pred"``,
-    and optionally ``"calibration"`` and ``"segmentation"``.
+    and optionally ``"calibration"``, ``"segmentation"`` (GT), and
+    ``"pred_sky_mask"`` (prediction, True = sky).
 
     Loaders are resolved automatically from each dataset directory's
     ds-crawler index metadata.
@@ -781,6 +790,9 @@ def build_depth_eval_dataset(
         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.
+        pred_sky_mask_path: Optional predicted ``sky_mask`` dataset, paired
+            with depth by sample ID using its own loader metadata.
+        pred_sky_mask_split: Optional split for the predicted sky mask.
 
     Returns:
         A MultiModalDataset instance.
@@ -799,6 +811,13 @@ def build_depth_eval_dataset(
             split=pred_depth_split,
         ),
     }
+    if pred_sky_mask_path is not None:
+        modalities["pred_sky_mask"] = _modality(
+            path=pred_sky_mask_path,
+            modality_key="sky_mask",
+            used_as="output",
+            split=pred_sky_mask_split,
+        )
 
     hierarchical = {}
     if calibration_path is not None:
@@ -840,6 +859,8 @@ def build_sparse_depth_eval_dataset(
     segmentation_split: Optional[str] = None,
     pred_depth_metadata_scope: Optional[str] = None,
     segmentation_modality_key: str = "segmentation",
+    pred_sky_mask_path: Optional[str] = None,
+    pred_sky_mask_split: Optional[str] = None,
 ) -> MultiModalDataset:
     """Build a MultiModalDataset for sparse pointcloud depth evaluation.
 
@@ -855,6 +876,8 @@ def build_sparse_depth_eval_dataset(
     such as ``relative_depth`` or ``affine_depth`` while still loading it
     as a dense depth map. Segmentation remains optional for sparse depth and is
     only loaded by callers that request sky masking.
+    ``pred_sky_mask_path`` optionally adds an ID-paired ``"pred_sky_mask"``
+    prediction (True = sky), with its own ``pred_sky_mask_split`` selector.
     """
     modalities = {
         "gt": _modality(
@@ -870,6 +893,13 @@ def build_sparse_depth_eval_dataset(
             split=pred_depth_split,
         ),
     }
+    if pred_sky_mask_path is not None:
+        modalities["pred_sky_mask"] = _modality(
+            path=pred_sky_mask_path,
+            modality_key="sky_mask",
+            used_as="output",
+            split=pred_sky_mask_split,
+        )
 
     hierarchical = _sparse_projection_hierarchical(
         intrinsics_path=intrinsics_path,

{euler_eval-2.26.0 → euler_eval-2.28.0}/euler_eval/evaluate.py

@@ -38,6 +38,7 @@ from .data import (
     to_numpy_points_3d,
     to_numpy_rgb,
     unproject_depth_to_points,
+    validate_sky_depth,
 )
 from .metric_sets import resolve_metric_sets
 from .metrics import (
@@ -504,6 +505,48 @@ def _get_sky_mask(sample: dict) -> Optional[np.ndarray]:
     return ~sky  # invert: True = non-sky = valid
 
 
+def _get_prediction_sky_mask(
+    sample: dict, depth_pred: np.ndarray
+) -> Optional[np.ndarray]:
+    """Return the predicted sky mask on the depth grid (True = sky)."""
+    mask_data = sample.get("pred_sky_mask")
+    if mask_data is None:
+        return None
+    return align_to_prediction(to_numpy_mask(mask_data), depth_pred)
+
+
+def _apply_sky_depth(
+    depth_gt: np.ndarray,
+    depth_pred_raw: np.ndarray,
+    depth_pred_aligned: np.ndarray,
+    sky_depth: Optional[float],
+    pred_sky_mask: Optional[np.ndarray],
+) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """Cap evaluation depths and fill predicted sky after conversion/alignment.
+
+    Preserve the shared prediction object when no alignment was needed, since
+    evaluators use its identity to avoid computing the same metrics twice.
+    NaNs and nonpositive values remain invalid unless filled by the sky mask;
+    positive infinity is truncated to the cap like any other larger depth.
+    """
+    if sky_depth is None:
+        return depth_gt, depth_pred_raw, depth_pred_aligned
+
+    def _cap_prediction(depth):
+        capped = np.minimum(depth, sky_depth)
+        if pred_sky_mask is not None:
+            capped[pred_sky_mask] = sky_depth
+        return capped
+
+    aligned_is_raw = depth_pred_aligned is depth_pred_raw
+    depth_gt = np.minimum(depth_gt, sky_depth)
+    depth_pred_raw = _cap_prediction(depth_pred_raw)
+    depth_pred_aligned = (
+        depth_pred_raw if aligned_is_raw else _cap_prediction(depth_pred_aligned)
+    )
+    return depth_gt, depth_pred_raw, depth_pred_aligned
+
+
 # Calibration extraction lives in euler_eval.calibration (imported above with
 # private aliases that tests import from euler_eval.evaluate).
 
@@ -582,6 +625,7 @@ def evaluate_depth_samples(
     alignment_mode: str = "auto_affine",
     benchmark_depth_range: Optional[tuple[float, float]] = None,
     input_space_hint: Optional[str] = None,
+    sky_depth: Optional[float] = None,
 ) -> dict:
     """Evaluate all depth metrics from a MultiModalDataset.
 
@@ -607,6 +651,11 @@ def evaluate_depth_samples(
         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.
+        sky_depth: Optional finite positive maximum evaluation depth in meters.
+            After conversion/alignment, cap GT and both prediction branches and
+            fill ``sample["pred_sky_mask"]`` pixels (True = sky) with this value.
+            Predicted sky is excluded from affine fitting, but remains scored
+            unless excluded by GT validity or ``sky_mask_enabled``.
 
     Returns:
         Dictionary containing depth aggregate/per-file metrics with:
@@ -614,6 +663,7 @@ def evaluate_depth_samples(
         backward-compatible canonical ``depth``, and optionally
         per-space ``depth_benchmark`` summaries.
     """
+    validate_sky_depth(sky_depth)
     valid_alignment_modes = {"none", "auto_affine", "affine"}
     if alignment_mode not in valid_alignment_modes:
         raise ValueError(
@@ -1095,6 +1145,11 @@ def evaluate_depth_samples(
 
                 depth_gt = process_depth(depth_gt, is_radial, intrinsics_K)
                 depth_pred_raw = process_depth(depth_pred, is_radial, intrinsics_K)
+                pred_sky_mask = (
+                    _get_prediction_sky_mask(sample, depth_pred)
+                    if sky_depth is not None
+                    else None
+                )
 
                 if alignment_mode == "none":
                     depth_pred_aligned = depth_pred_raw
@@ -1114,6 +1169,8 @@ def evaluate_depth_samples(
                         )
                         if sky_valid is not None:
                             fit_mask = fit_mask & sky_valid
+                        if pred_sky_mask is not None:
+                            fit_mask &= ~pred_sky_mask
                         depth_pred_aligned, s, t = compute_scale_and_shift(
                             fit_source,
                             depth_gt,
@@ -1130,6 +1187,11 @@ def evaluate_depth_samples(
                     else:
                         depth_pred_aligned = depth_pred_raw
 
+                depth_gt, depth_pred_raw, depth_pred_aligned = _apply_sky_depth(
+                    depth_gt, depth_pred_raw, depth_pred_aligned,
+                    sky_depth, pred_sky_mask,
+                )
+
                 if verbose and not logged_stats:
                     _log_sample_stats(depth_gt, depth_pred_aligned, "DEPTH")
                     logged_stats = True
@@ -1577,6 +1639,7 @@ def evaluate_sparse_depth_samples(
     alignment_mode: str = "auto_affine",
     benchmark_depth_range: Optional[tuple[float, float]] = None,
     input_space_hint: Optional[str] = None,
+    sky_depth: Optional[float] = None,
 ) -> dict:
     """Evaluate dense depth predictions against sparse pointcloud GT.
 
@@ -1584,7 +1647,10 @@ def evaluate_sparse_depth_samples(
     dense prediction image plane, and metrics are computed only at projected
     valid pixels. The emitted metric categories intentionally exclude dense
     image/geometric metrics such as SSIM, LPIPS, FID, normals, and edge F1.
+    ``sky_depth`` caps projected GT and predictions and fills optional
+    ``sample["pred_sky_mask"]`` pixels, as in :func:`evaluate_depth_samples`.
     """
+    validate_sky_depth(sky_depth)
     valid_alignment_modes = {"none", "auto_affine", "affine"}
     if alignment_mode not in valid_alignment_modes:
         raise ValueError(
@@ -1838,6 +1904,11 @@ def evaluate_sparse_depth_samples(
                 depth_pred_raw = process_depth(
                     depth_pred, pred_is_radial, intrinsics_K
                 )
+                pred_sky_mask = (
+                    _get_prediction_sky_mask(sample, depth_pred)
+                    if sky_depth is not None
+                    else None
+                )
 
                 if alignment_mode == "none":
                     depth_pred_aligned = depth_pred_raw
@@ -1853,6 +1924,8 @@ def evaluate_sparse_depth_samples(
                         )
                         if sky_valid is not None:
                             fit_mask &= sky_valid
+                        if pred_sky_mask is not None:
+                            fit_mask &= ~pred_sky_mask
                         depth_pred_aligned, s, t = compute_scale_and_shift(
                             fit_source,
                             sparse_depth_gt,
@@ -1869,6 +1942,11 @@ def evaluate_sparse_depth_samples(
                     else:
                         depth_pred_aligned = depth_pred_raw
 
+                sparse_depth_gt, depth_pred_raw, depth_pred_aligned = _apply_sky_depth(
+                    sparse_depth_gt, depth_pred_raw, depth_pred_aligned,
+                    sky_depth, pred_sky_mask,
+                )
+
                 if verbose and not logged_stats:
                     _log_sample_stats(sparse_depth_gt, depth_pred_aligned, "SPARSE DEPTH")
                     logged_stats = True
@@ -3498,6 +3576,7 @@ def evaluate_points_3d_sparse_samples(
     input_space_hint: Optional[str] = None,
     max_cloud_points: int = POINTS3D_DEFAULT_MAX_POINTS,
     pred_is_depth: bool = True,
+    sky_depth: Optional[float] = None,
 ) -> dict:
     """Evaluate a depth **or** ``points_3d`` prediction against sparse GT.
 
@@ -3555,6 +3634,9 @@ def evaluate_points_3d_sparse_samples(
         max_cloud_points: Per-cloud subsample cap for the cloud-distance query.
         pred_is_depth: Whether the prediction is a dense depth map (unprojected)
             or a native ``points_3d`` map (scored directly).
+        sky_depth: Optional depth cap and predicted-sky fill value, supported
+            for depth predictions. GT points are capped radially, preserving
+            their directions, to match the sparse-depth evaluation range.
 
     Returns:
         Dict shaped like :func:`evaluate_points_3d_samples`:
@@ -3562,6 +3644,9 @@ def evaluate_points_3d_sparse_samples(
         ``per_file_metrics``, ``dataset_info``, ``space_info`` and
         ``spatial_info``.
     """
+    validate_sky_depth(sky_depth)
+    if sky_depth is not None and not pred_is_depth:
+        raise ValueError("sky_depth is only supported for depth predictions")
     if pred_is_depth:
         valid_alignment_modes = {"none", "auto_affine", "affine"}
         valid_input_space_hints = {None, "relative", "affine"}
@@ -3614,6 +3699,8 @@ def evaluate_points_3d_sparse_samples(
                     dataset_max_depth,
                     float(np.max(finite_depths)),
                 )
+    if sky_depth is not None:
+        dataset_max_depth = min(dataset_max_depth, sky_depth)
     f_a_max_threshold = dataset_max_depth / 20.0
 
     resolved_domain: Optional[str] = fov_domain
@@ -3884,6 +3971,11 @@ def evaluate_points_3d_sparse_samples(
                     depth_pred_raw = process_depth(
                         depth_pred, pred_is_radial, intrinsics_K
                     )
+                    pred_sky_mask = (
+                        _get_prediction_sky_mask(sample, depth_pred)
+                        if sky_depth is not None
+                        else None
+                    )
                     if alignment_mode == "none":
                         depth_pred_aligned = depth_pred_raw
                     else:
@@ -3904,6 +3996,8 @@ def evaluate_points_3d_sparse_samples(
                             )
                             if sky_valid is not None:
                                 fit_mask &= sky_valid
+                            if pred_sky_mask is not None:
+                                fit_mask &= ~pred_sky_mask
                             depth_pred_aligned, s_fit, t_fit = compute_scale_and_shift(
                                 fit_source,
                                 gt_radial,
@@ -3920,6 +4014,19 @@ def evaluate_points_3d_sparse_samples(
                         else:
                             depth_pred_aligned = depth_pred_raw
 
+                    if sky_depth is not None:
+                        # Keep actual GT ray directions, including subpixel
+                        # offsets, while limiting each point's radial depth.
+                        gt_scale = np.ones_like(gt_radial)
+                        beyond_cap = gt_radial > sky_depth
+                        gt_scale[beyond_cap] = sky_depth / gt_radial[beyond_cap]
+                        gt_point_map = gt_point_map * gt_scale[..., None]
+                        gt_cloud = gt_point_map[gt_valid]
+                    gt_radial, depth_pred_raw, depth_pred_aligned = _apply_sky_depth(
+                        gt_radial, depth_pred_raw, depth_pred_aligned,
+                        sky_depth, pred_sky_mask,
+                    )
+
                     if verbose and not logged_stats:
                         _log_sample_stats(gt_radial, depth_pred_raw, "SPARSE POINTS_3D")
                         logged_stats = True

{euler_eval-2.26.0 → euler_eval-2.28.0}/euler_eval.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: euler-eval
-Version: 2.26.0
+Version: 2.28.0
 Summary: Evaluation toolkit for depth, RGB, ray and 3D point-map predictions
 Author-email: Daniel Rothenpieler <rothenpielerdaniel@gmail.com>
 License: MIT
@@ -158,10 +158,10 @@ straight out of the archive. Full schema: [Configuration](docs/configuration.md)
 | Modality | Config key | Scored against | Headline metrics |
 |---|---|---|---|
 | **Depth** | `depth`, `relative_depth`, `affine_depth` | dense GT depth | `absrel`…`delta3`, PSNR/SSIM/LPIPS/FID/KID, surface-normal consistency, depth-edge F1 |
-| **Sparse depth** | `depth` + `gt.sparse_depth` | a LiDAR-style point cloud, projected into the prediction plane | pointwise depth metrics at projected points, plus directed 3D completeness |
+| **Sparse depth** | `depth` + `gt.sparse_depth` | a LiDAR-style point cloud, projected into the prediction plane | pointwise depth metrics at projected points |
 | **RGB** | `rgb` | GT RGB | PSNR, SSIM, LPIPS, FID, SCE, edge F1, tail errors, HF energy ratio, depth-binned photometric error; optional NIQE/FADE dehazing metrics |
 | **Rays** | `rays` | GT ray direction map | ρ_A (angular-accuracy AUC), angular error, threshold percentages |
-| **Points-3D** | `points_3d` | GT point map, or GT depth unprojected on the fly | 3D EPE/RMSE/δ, radial-vs-lateral decomposition, true-3D normals and edge F1, Chamfer / F-score |
+| **Points-3D** | `points_3d` | GT point map, GT depth unprojected on the fly, or a sparse point cloud | 3D EPE/RMSE/δ, radial-vs-lateral decomposition, true-3D normals and edge F1, Chamfer / F-score |
 
 A run evaluates whichever modalities are configured on both sides; a depth-only
 prediction is a perfectly ordinary run. The full inventory, with the key each

{euler_eval-2.26.0 → euler_eval-2.28.0}/euler_eval.egg-info/SOURCES.txt

@@ -50,6 +50,7 @@ euler_eval/metrics/utils.py
 euler_eval/utils/hierarchy_parser.py
 tests/test_alignment.py
 tests/test_cli_device.py
+tests/test_cli_sparse_outputs.py
 tests/test_config.py
 tests/test_data.py
 tests/test_data_builders.py