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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: euler-eval
-Version: 2.14.0
+Version: 2.16.0
 Summary: Depth map evaluation toolkit with comprehensive metrics
 Author: Depth Eval Contributors
 License: MIT
@@ -45,7 +45,7 @@ A comprehensive evaluation toolkit for comparing predicted depth maps, RGB image
 - **Depth metrics**: PSNR, SSIM, LPIPS, FID, KID, AbsRel, RMSE, Scale-Invariant Log Error, Normal Consistency, Depth Edge F1
 - **RGB metrics**: PSNR, SSIM, LPIPS, FID, SCE (Structural Chromatic Error), Edge F1, Tail Errors (p95/p99), High-Frequency Energy Ratio, Depth-Binned Photometric Error
 - **Rays metrics**: ρ_A (AUC of angular accuracy curve), Angular Error statistics and threshold percentages
-- **Points-3D metrics**: for models that predict a per-pixel 3D point map *and their own camera*: Euclidean 3D error (EPE/RMSE/3D δ-accuracy), radial-vs-lateral error decomposition (depth vs camera-model attribution) with ρ_A, true-3D surface normals, 3D edge F1, and correspondence-free Chamfer / F-score. Native + similarity-gauge-aligned (Umeyama) metric spaces.
+- **Points-3D metrics**: for models that predict a per-pixel 3D point map *and their own camera*: Euclidean 3D error (EPE/RMSE/3D δ-accuracy), radial-vs-lateral error decomposition (depth vs camera-model attribution) with ρ_A, true-3D surface normals, 3D edge F1, and correspondence-free Chamfer / F-score. Native + similarity-gauge-aligned (Umeyama) metric spaces. Also evaluates a **dense depth prediction against sparse pointcloud GT** (`gt.sparse_depth`): the depth is unprojected with the GT intrinsics and scored in 3D via directed Chamfer completeness / recall plus per-correspondence 3D error.
 - **Benchmark binning**: Optional depth-range benchmark that subdivides metrics into square-root-scaled near/mid/far bins
 - **Sanity checking**: Automatic validation of metric results against configurable thresholds, with detailed warning reports
 - **Sky masking**: Optional exclusion of sky regions from metrics using GT segmentation
@@ -174,8 +174,19 @@ depth-eval config.json --rgb-fid-backend clean-fid
 depth-eval config.json --benchmark-depth-range 0.01 80.0
 
 # Evaluate dense depth predictions against sparse pointcloud GT
+# (emits pointwise sparse-depth metrics AND 3D points_3d metrics)
 depth-eval example_sparse_depth_config.json --skip-rgb --skip-rays
 
+# Sparse pointcloud GT, but only the 3D (points_3d) metrics
+depth-eval example_sparse_depth_config.json --skip-depth --skip-rgb --skip-rays
+
+# Sparse pointcloud GT, but only the pointwise depth metrics
+depth-eval example_sparse_depth_config.json --skip-points-3d --skip-rgb --skip-rays
+
+# Evaluate a predicted points_3d map directly against sparse pointcloud GT
+# (config uses datasets[].points_3d; align relative point maps with a similarity gauge)
+depth-eval config.json --skip-depth --skip-rgb --skip-rays --points-3d-alignment similarity
+
 # Skip rays evaluation
 depth-eval config.json --skip-rays
 
@@ -252,6 +263,13 @@ Each modality entry can optionally include a `split` field to select a specific
 
 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. For MUSES through `euler_loading.loaders.muses`, `gt.camera_extrinsics` normally resolves to the direct `lidar2rgb` transform and no extra lidar pose is needed. If a dataset exposes separate lidar and camera poses in a shared frame instead, provide optional `gt.lidar_extrinsics`; the evaluator composes `inv(camera_pose) @ lidar_pose` before projection.
 
+When the GT is a sparse pointcloud, the evaluator also produces **3D (`points_3d`) metrics** unless `--skip-points-3d` is set (see [Sparse Points-3D Metrics](#sparse-points-3d-metrics)). The prediction scored in 3D can be either:
+
+- a **predicted point map** (`datasets[].points_3d`, an `(H,W,3)` map) — evaluated *directly* against the sparse GT cloud, with the 3D **similarity** gauge selected by `--points-3d-alignment`; or
+- a **dense depth map** (`datasets[].depth`/`relative_depth`/`affine_depth`) — unprojected with `gt.intrinsics` into a point map, with the depth **affine** gauge selected by `--depth-alignment`.
+
+If a dataset entry provides both, the predicted `points_3d` map is preferred (the depth is still scored by the pointwise sparse-depth metrics). Either way the sparse GT cloud is projected into the prediction plane, and the 3D results are written to a separate `points3d_eval.json` (or `<output_file>_points3d.json`) so they never clobber the sparse-depth `eval.json`.
+
 Sparse depth does not require segmentation GT. `gt.segmentation` and
 `gt.semantic_segmentation` are optional aliases for the same sky-mask source.
 They are loaded only when `--mask-sky` is set; in sparse depth evaluation that
@@ -423,6 +441,31 @@ The angular `error_decomposition` ray metrics and `rho_a` are computed on the
 **native** point-map directions (the camera-faithful frame); the radial/lateral and
 Euclidean metrics are reported per space.
 
+### Sparse Points-3D Metrics
+
+When the ground truth is a sparse pointcloud (`gt.sparse_depth`), the evaluator
+additionally scores the prediction as a 3D point map (unless `--skip-points-3d`
+is set). The sparse GT cloud is projected into the prediction plane, giving both
+the visible GT cloud and per-pixel correspondences. The predicted point map is
+either taken **directly** from `datasets[].points_3d` (gauge = 3D similarity via
+`--points-3d-alignment`) or **unprojected** from a dense `datasets[].depth`
+prediction with `gt.intrinsics` (gauge = depth affine via `--depth-alignment`).
+Results serialize under `points3d.eval.{native,metric}` in a separate output
+file.
+
+Only the categories that stay meaningful with a sparse GT are emitted —
+dense-neighbourhood `geometric` metrics (normals, edge F1) are skipped, and the
+`cloud_distance` block reports only the **directed `gt→pred`** side (a correct
+dense prediction has many legitimate points far from any sparse GT return, so
+`accuracy`/`precision` would be misleading and are omitted):
+
+| Metric | Key (per space) | Description |
+|---|---|---|
+| Cloud completeness | `cloud_distance.chamfer.completeness`, `.median` | Mean / median distance from each GT return to its nearest predicted point (metres, lower is better) |
+| Cloud recall | `cloud_distance.fscore.tau_<τ>.recall` | Fraction of GT returns within τ m of a predicted point, `τ ∈ {0.05, 0.1, 0.25, 0.5}` (higher is better) |
+| 3D point error | `point_error.{image_mean,image_median,pixel_pool}.*` | 3D EPE `mae3d`/`rmse3d`, percentiles, relative error, and δ-accuracy at the projected correspondences |
+| Error decomposition | `error_decomposition.{radial_*,lateral_*,lateral_fraction,angular_error.*,rho_a.*}` | Radial (≈ depth) vs lateral (≈ camera-model) split at correspondences, with ray angular error and ρ_A |
+
 ## Output
 
 Results are saved as JSON per modality per prediction dataset (one file for depth or sparse depth, one for RGB, one for rays). Default path: `eval.json` inside each modality's dataset path, unless overridden by `output_file` in the config.
@@ -493,6 +536,8 @@ For sparse depth outputs, the internal Python result dict still uses `sparse_dep
 
 For points_3d outputs, the internal Python result dict uses `points_3d_native`, `points_3d_metric`, and `points_3d` (canonical alias), but serialized `eval.json` metric paths are rooted at `points3d.eval` (no underscore) to satisfy the namespace first-segment rule, mirroring `sparsedepth`. The `metric` space is emitted only when a gauge alignment is applied; otherwise only `native` is present and aliased.
 
+When the points_3d metrics come from a sparse pointcloud GT (`gt.sparse_depth` + a predicted `points_3d` map or a dense depth prediction), they use the same `points3d.eval` namespace but are written to a distinct file — `points3d_eval.json` beside the prediction, or `<output_file>_points3d.json` when `output_file` is set — so they do not overwrite the sparse-depth `eval.json`. Only the `point_error`, `error_decomposition`, and (directed) `cloud_distance` categories are present; the `metric` space is emitted only when the gauge (`--points-3d-alignment` for a point-map prediction, `--depth-alignment` for a depth prediction) calibrates the prediction.
+
 Previous single-depth structure (kept under `depth`) is:
 
 ```json

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

@@ -7,7 +7,7 @@ A comprehensive evaluation toolkit for comparing predicted depth maps, RGB image
 - **Depth metrics**: PSNR, SSIM, LPIPS, FID, KID, AbsRel, RMSE, Scale-Invariant Log Error, Normal Consistency, Depth Edge F1
 - **RGB metrics**: PSNR, SSIM, LPIPS, FID, SCE (Structural Chromatic Error), Edge F1, Tail Errors (p95/p99), High-Frequency Energy Ratio, Depth-Binned Photometric Error
 - **Rays metrics**: ρ_A (AUC of angular accuracy curve), Angular Error statistics and threshold percentages
-- **Points-3D metrics**: for models that predict a per-pixel 3D point map *and their own camera*: Euclidean 3D error (EPE/RMSE/3D δ-accuracy), radial-vs-lateral error decomposition (depth vs camera-model attribution) with ρ_A, true-3D surface normals, 3D edge F1, and correspondence-free Chamfer / F-score. Native + similarity-gauge-aligned (Umeyama) metric spaces.
+- **Points-3D metrics**: for models that predict a per-pixel 3D point map *and their own camera*: Euclidean 3D error (EPE/RMSE/3D δ-accuracy), radial-vs-lateral error decomposition (depth vs camera-model attribution) with ρ_A, true-3D surface normals, 3D edge F1, and correspondence-free Chamfer / F-score. Native + similarity-gauge-aligned (Umeyama) metric spaces. Also evaluates a **dense depth prediction against sparse pointcloud GT** (`gt.sparse_depth`): the depth is unprojected with the GT intrinsics and scored in 3D via directed Chamfer completeness / recall plus per-correspondence 3D error.
 - **Benchmark binning**: Optional depth-range benchmark that subdivides metrics into square-root-scaled near/mid/far bins
 - **Sanity checking**: Automatic validation of metric results against configurable thresholds, with detailed warning reports
 - **Sky masking**: Optional exclusion of sky regions from metrics using GT segmentation
@@ -136,8 +136,19 @@ depth-eval config.json --rgb-fid-backend clean-fid
 depth-eval config.json --benchmark-depth-range 0.01 80.0
 
 # Evaluate dense depth predictions against sparse pointcloud GT
+# (emits pointwise sparse-depth metrics AND 3D points_3d metrics)
 depth-eval example_sparse_depth_config.json --skip-rgb --skip-rays
 
+# Sparse pointcloud GT, but only the 3D (points_3d) metrics
+depth-eval example_sparse_depth_config.json --skip-depth --skip-rgb --skip-rays
+
+# Sparse pointcloud GT, but only the pointwise depth metrics
+depth-eval example_sparse_depth_config.json --skip-points-3d --skip-rgb --skip-rays
+
+# Evaluate a predicted points_3d map directly against sparse pointcloud GT
+# (config uses datasets[].points_3d; align relative point maps with a similarity gauge)
+depth-eval config.json --skip-depth --skip-rgb --skip-rays --points-3d-alignment similarity
+
 # Skip rays evaluation
 depth-eval config.json --skip-rays
 
@@ -214,6 +225,13 @@ Each modality entry can optionally include a `split` field to select a specific
 
 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. For MUSES through `euler_loading.loaders.muses`, `gt.camera_extrinsics` normally resolves to the direct `lidar2rgb` transform and no extra lidar pose is needed. If a dataset exposes separate lidar and camera poses in a shared frame instead, provide optional `gt.lidar_extrinsics`; the evaluator composes `inv(camera_pose) @ lidar_pose` before projection.
 
+When the GT is a sparse pointcloud, the evaluator also produces **3D (`points_3d`) metrics** unless `--skip-points-3d` is set (see [Sparse Points-3D Metrics](#sparse-points-3d-metrics)). The prediction scored in 3D can be either:
+
+- a **predicted point map** (`datasets[].points_3d`, an `(H,W,3)` map) — evaluated *directly* against the sparse GT cloud, with the 3D **similarity** gauge selected by `--points-3d-alignment`; or
+- a **dense depth map** (`datasets[].depth`/`relative_depth`/`affine_depth`) — unprojected with `gt.intrinsics` into a point map, with the depth **affine** gauge selected by `--depth-alignment`.
+
+If a dataset entry provides both, the predicted `points_3d` map is preferred (the depth is still scored by the pointwise sparse-depth metrics). Either way the sparse GT cloud is projected into the prediction plane, and the 3D results are written to a separate `points3d_eval.json` (or `<output_file>_points3d.json`) so they never clobber the sparse-depth `eval.json`.
+
 Sparse depth does not require segmentation GT. `gt.segmentation` and
 `gt.semantic_segmentation` are optional aliases for the same sky-mask source.
 They are loaded only when `--mask-sky` is set; in sparse depth evaluation that
@@ -385,6 +403,31 @@ The angular `error_decomposition` ray metrics and `rho_a` are computed on the
 **native** point-map directions (the camera-faithful frame); the radial/lateral and
 Euclidean metrics are reported per space.
 
+### Sparse Points-3D Metrics
+
+When the ground truth is a sparse pointcloud (`gt.sparse_depth`), the evaluator
+additionally scores the prediction as a 3D point map (unless `--skip-points-3d`
+is set). The sparse GT cloud is projected into the prediction plane, giving both
+the visible GT cloud and per-pixel correspondences. The predicted point map is
+either taken **directly** from `datasets[].points_3d` (gauge = 3D similarity via
+`--points-3d-alignment`) or **unprojected** from a dense `datasets[].depth`
+prediction with `gt.intrinsics` (gauge = depth affine via `--depth-alignment`).
+Results serialize under `points3d.eval.{native,metric}` in a separate output
+file.
+
+Only the categories that stay meaningful with a sparse GT are emitted —
+dense-neighbourhood `geometric` metrics (normals, edge F1) are skipped, and the
+`cloud_distance` block reports only the **directed `gt→pred`** side (a correct
+dense prediction has many legitimate points far from any sparse GT return, so
+`accuracy`/`precision` would be misleading and are omitted):
+
+| Metric | Key (per space) | Description |
+|---|---|---|
+| Cloud completeness | `cloud_distance.chamfer.completeness`, `.median` | Mean / median distance from each GT return to its nearest predicted point (metres, lower is better) |
+| Cloud recall | `cloud_distance.fscore.tau_<τ>.recall` | Fraction of GT returns within τ m of a predicted point, `τ ∈ {0.05, 0.1, 0.25, 0.5}` (higher is better) |
+| 3D point error | `point_error.{image_mean,image_median,pixel_pool}.*` | 3D EPE `mae3d`/`rmse3d`, percentiles, relative error, and δ-accuracy at the projected correspondences |
+| Error decomposition | `error_decomposition.{radial_*,lateral_*,lateral_fraction,angular_error.*,rho_a.*}` | Radial (≈ depth) vs lateral (≈ camera-model) split at correspondences, with ray angular error and ρ_A |
+
 ## Output
 
 Results are saved as JSON per modality per prediction dataset (one file for depth or sparse depth, one for RGB, one for rays). Default path: `eval.json` inside each modality's dataset path, unless overridden by `output_file` in the config.
@@ -455,6 +498,8 @@ For sparse depth outputs, the internal Python result dict still uses `sparse_dep
 
 For points_3d outputs, the internal Python result dict uses `points_3d_native`, `points_3d_metric`, and `points_3d` (canonical alias), but serialized `eval.json` metric paths are rooted at `points3d.eval` (no underscore) to satisfy the namespace first-segment rule, mirroring `sparsedepth`. The `metric` space is emitted only when a gauge alignment is applied; otherwise only `native` is present and aliased.
 
+When the points_3d metrics come from a sparse pointcloud GT (`gt.sparse_depth` + a predicted `points_3d` map or a dense depth prediction), they use the same `points3d.eval` namespace but are written to a distinct file — `points3d_eval.json` beside the prediction, or `<output_file>_points3d.json` when `output_file` is set — so they do not overwrite the sparse-depth `eval.json`. Only the `point_error`, `error_decomposition`, and (directed) `cloud_distance` categories are present; the `metric` space is emitted only when the gauge (`--points-3d-alignment` for a point-map prediction, `--depth-alignment` for a depth prediction) calibrates the prediction.
+
 Previous single-depth structure (kept under `depth`) is:
 
 ```json

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

@@ -18,6 +18,7 @@ from .config_paths import normalize_modality_path
 from .data import (
     build_depth_eval_dataset,
     build_points_3d_eval_dataset,
+    build_points_3d_sparse_eval_dataset,
     build_rays_eval_dataset,
     build_rgb_eval_dataset,
     build_sparse_depth_eval_dataset,
@@ -30,6 +31,7 @@ from .data import (
 from .evaluate import (
     evaluate_depth_samples,
     evaluate_points_3d_samples,
+    evaluate_points_3d_sparse_samples,
     evaluate_rays_samples,
     evaluate_rgb_samples,
     evaluate_sparse_depth_samples,
@@ -973,7 +975,12 @@ def _save_json_to_zip(zip_path: Path, internal_name: str, data: dict) -> None:
 
 
 def save_results(
-    results: dict, dataset_config: dict, modality: str | None = None
+    results: dict,
+    dataset_config: dict,
+    modality: str | None = None,
+    *,
+    default_basename: str = "eval.json",
+    output_file_suffix: str | None = None,
 ) -> Path:
     """Save results to output file.
 
@@ -987,6 +994,14 @@ def save_results(
         modality: When set, save to this specific modality's path
             (e.g. ``"depth"`` or ``"rgb"``).  Falls back to the first
             available modality path when *None*.
+        default_basename: File name used when no explicit ``output_file`` is
+            configured (default ``"eval.json"``).  Lets a second modality that
+            shares a prediction path (e.g. sparse ``points_3d`` alongside sparse
+            ``depth``) write to a distinct file instead of clobbering it.
+        output_file_suffix: When an explicit ``output_file`` is configured, this
+            suffix is inserted before its extension (e.g. ``"_points3d"`` turns
+            ``model_a.json`` into ``model_a_points3d.json``) so multiple
+            modalities can honour a single configured path without collision.
 
     Returns:
         Path where results were saved.
@@ -1006,7 +1021,7 @@ def save_results(
                     dataset_config[selected_modality]["path"],
                     split=dataset_config[selected_modality].get("split"),
                 )
-                / "eval.json"
+                / default_basename
             )
         else:
             # Default: save alongside first available modality path
@@ -1017,13 +1032,17 @@ def save_results(
                             dataset_config[mod]["path"],
                             split=dataset_config[mod].get("split"),
                         )
-                        / "eval.json"
+                        / default_basename
                     )
                     break
         if output_file is None:
-            output_file = Path("eval.json")
+            output_file = Path(default_basename)
     else:
         output_file = Path(output_file)
+        if output_file_suffix:
+            output_file = output_file.with_name(
+                f"{output_file.stem}{output_file_suffix}{output_file.suffix}"
+            )
 
     zip_path, internal_name = _find_zip_ancestor(output_file)
     if zip_path is not None and internal_name:
@@ -1273,6 +1292,7 @@ def main():
         rgb_save = {}
         rays_save = {}
         points_3d_save = {}
+        points_3d_sparse_save = {}
         et_eval_datasets = {}
         has_benchmark = args.benchmark_depth_range is not None
 
@@ -2103,13 +2123,218 @@ def main():
                 f"POINTS_3D: {ds_name}",
             )
 
-        elif has_points_3d and not args.skip_points_3d:
+        elif (
+            has_points_3d
+            and not args.skip_points_3d
+            and not gt_sparse_depth_path
+        ):
+            # (When gt.sparse_depth is present the sparse points_3d branch below
+            # evaluates the predicted point map against the LiDAR cloud instead.)
             print(
                 f"\n[POINTS_3D] Skipping '{ds_name}': no usable GT. Provide "
                 "gt.points_3d, or gt.depth with gt.intrinsics/gt.calibration to "
                 "synthesize the GT point map."
             )
 
+        # -- 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.
+        if (
+            gt_sparse_depth_path
+            and (has_points_3d or has_depth)
+            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
+            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,
+                gt_name=gt.get("name", "GT"),
+                pred_name=ds_name,
+                num_workers=args.num_workers,
+                verbose=args.verbose,
+                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,
+            )
+
+            if sanity_checker is not None:
+                sanity_checker.print_pair_report(ds_name, modality="points_3d")
+
+            p3s_space_info = points_3d_sparse_results.get("space_info", {})
+            p3s_dataset_info = points_3d_sparse_results.get("dataset_info", {})
+            p3s_spatial = points_3d_sparse_results.get("spatial_info", {})
+
+            points_3d_sparse_ns = _EvalNamespace(
+                producer="euler-eval",
+                producer_version=_get_version(),
+                modalities=("points_3d",),
+                axes=_points_3d_eval_axes(),
+                descriptions=_POINTS_3D_EVAL_DESCRIPTIONS,
+            )
+            points_3d_sparse_save = {
+                "metricSet": _points_3d_metric_set_envelope(
+                    points_3d_sparse_ns,
+                    metadata={
+                        "input_space_detected": p3s_space_info.get(
+                            "input_space_detected", "unknown"
+                        ),
+                        "metric_space_source": p3s_space_info.get(
+                            "metric_space_source"
+                        ),
+                        "calibration_mode": p3s_space_info.get(
+                            "calibration_mode", "unknown"
+                        ),
+                        "calibration_applied": p3s_space_info.get(
+                            "calibration_applied", False
+                        ),
+                        "emitted_spaces": p3s_space_info.get("emitted_spaces", []),
+                        "canonical_space": p3s_space_info.get(
+                            "canonical_space", "native"
+                        ),
+                        "gt_representation": "point_cloud",
+                        "fov_domain": p3s_dataset_info.get("fov_domain"),
+                        "threshold_deg": p3s_dataset_info.get("threshold_deg"),
+                    },
+                ),
+                "dataset_info": p3s_dataset_info,
+                "meta": _clean_metric_tree({
+                    "version": _get_version(),
+                    "modality": "points_3d",
+                    "device": args.device,
+                    "gt": {
+                        "path": gt_sparse_depth_path,
+                        "split": gt_sparse_depth_split,
+                        "representation": "point_cloud",
+                    },
+                    "pred": {
+                        "path": p3s_pred_path,
+                        "split": p3s_pred_split,
+                        "entry": p3s_pred_entry,
+                        "representation": "depth" if p3s_pred_is_depth else "points_3d",
+                        "dimensions": p3s_spatial.get("pred_dimensions"),
+                    },
+                    "calibration": {
+                        "intrinsics_path": intrinsics_path,
+                        "intrinsics_split": intrinsics_split,
+                        "camera_extrinsics_path": camera_extrinsics_path,
+                        "camera_extrinsics_split": camera_extrinsics_split,
+                        "lidar_extrinsics_path": lidar_extrinsics_path,
+                        "lidar_extrinsics_split": lidar_extrinsics_split,
+                    },
+                    "spatial_alignment": {
+                        "method": p3s_spatial.get("method", "pointcloud_projection"),
+                        "evaluated_dimensions": p3s_spatial.get(
+                            "evaluated_dimensions"
+                        ),
+                    },
+                    "modality_params": p3ds_meta,
+                    "eval_params": {
+                        "sky_masking": args.mask_sky,
+                        "alignment_mode": p3s_alignment_mode,
+                        "num_workers": args.num_workers,
+                    },
+                }),
+                "points3d": {"eval": {}},
+            }
+            for space_name, result_key in (
+                ("native", "points_3d_native"),
+                ("metric", "points_3d_metric"),
+            ):
+                branch = points_3d_sparse_results.get(result_key)
+                if branch is not None:
+                    points_3d_sparse_save["points3d"]["eval"][space_name] = (
+                        _clean_metric_tree(branch)
+                    )
+            p3s_pfm = points_3d_sparse_results.get("per_file_metrics", {})
+            if p3s_pfm:
+                canonical_space = p3s_space_info.get("canonical_space", "native")
+                points_3d_sparse_save["per_file_metrics"] = _clean_per_file_metrics(
+                    _wrap_pfm_metrics(
+                        p3s_pfm,
+                        lambda m: _wrap_depth_space_pfm_metrics(
+                            m,
+                            metric_root="points3d",
+                            canonical_key="points_3d",
+                            canonical_space=canonical_space,
+                        ),
+                    ),
+                    label="points_3d sparse per_file_metrics",
+                )
+            all_results.setdefault("per_file_metrics", {}).update(p3s_pfm)
+
+            print_results(
+                {k: v for k, v in points_3d_sparse_results.items()
+                 if k not in ("per_file_metrics", "spatial_info")},
+                f"POINTS_3D · SPARSE: {ds_name}",
+            )
+
         # Save per-modality results to respective dataset paths
         if depth_save:
             depth_out = save_results(
@@ -2134,6 +2359,19 @@ def main():
                 points_3d_save, dataset_config, modality="points_3d"
             )
             print(f"\n  Points-3D results saved to: {points_3d_out}")
+        if points_3d_sparse_save:
+            # Distinct file so it never clobbers the sparse-depth eval.json that
+            # shares the same dense-depth prediction path / output_file.
+            points_3d_sparse_out = save_results(
+                points_3d_sparse_save,
+                dataset_config,
+                modality="points_3d",
+                default_basename="points3d_eval.json",
+                output_file_suffix="_points3d",
+            )
+            print(
+                f"\n  Points-3D (sparse GT) results saved to: {points_3d_sparse_out}"
+            )
 
         # Log to euler_train
         if et_run is not None and et_eval_datasets: