euler-eval 2.30.0__tar.gz → 2.32.0__tar.gz

{euler_eval-2.30.0/euler_eval.egg-info → euler_eval-2.32.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: euler-eval
-Version: 2.30.0
+Version: 2.32.0
 Summary: Evaluation toolkit for depth, RGB, ray and 3D point-map predictions
 Author-email: Daniel Rothenpieler <rothenpielerdaniel@gmail.com>
 License: MIT
@@ -33,7 +33,7 @@ Requires-Dist: opencv-python-headless>=4.5.0
 Requires-Dist: lpips>=0.1.4
 Requires-Dist: torchmetrics>=1.0
 Requires-Dist: tqdm>=4.62.0
-Requires-Dist: euler-loading>=2.15
+Requires-Dist: euler-loading>=2.29
 Requires-Dist: ds-crawler>=2.10
 Requires-Dist: euler-metric-naming>=0.2
 Provides-Extra: logging
@@ -133,8 +133,10 @@ euler-eval config.json --batch-size 32
 
 Ground truth and prediction files are matched by ID rather than by directory
 order, so an incomplete prediction set scores the frames it does have instead of
-silently comparing the wrong pairs. Results are written next to each prediction
-modality:
+silently comparing the wrong pairs. Results are written into each prediction
+dataset, under `.eval/` beside its `.ds_crawler/` metadata — e.g.
+`/data/model_a/depth/.eval/eval.json`, or `.eval/<scope>/eval.json` for a scoped
+dataset ([details](docs/output.md#where-results-land)):
 
 ```json
 {
@@ -176,7 +178,8 @@ metric is written under, is in [Metrics](docs/metrics.md).
 | **Metadata-driven decoding** | Radial vs planar depth, value ranges, point-cloud column layout and loader choice all come from the dataset index — no per-dataset flags. |
 | **Honest spaces** | Relative models are scored `native` *and* `metric` (after scale/shift or a similarity gauge), so a scale failure never reads as a geometry failure. |
 | **Benchmark depth bins** | `--benchmark-depth-range MIN MAX` adds near/mid/far bins in square-root depth space, additive to the regular metrics. |
-| **Sky masking** | `--mask-sky` drops sky pixels using GT segmentation — from the metrics *and* from the alignment fit. |
+| **Sky masking** | `--mask-sky` drops sky pixels using GT segmentation — from the metrics *and* from the alignment fit. `--mask-sky-prediction` does the same with each prediction's own `sky_mask`. |
+| **Sky IoU** | `--sky-iou` scores predicted sky — a `sky_mask`, or depth reaching a fixed cap — against GT segmentation, without changing any depth metric. |
 | **Per-file + aggregate** | Dataset-level numbers plus per-image metrics in dataset-hierarchy order, in the same file. |
 | **Sanity checks** | Results are validated against configurable thresholds; implausible ranges, degenerate inputs and scale mismatches are reported instead of quietly scored. |
 | **Structured metric names** | Each result carries a `metricSet` envelope declaring its namespace, axes, units and metric directions. |

{euler_eval-2.30.0 → euler_eval-2.32.0}/README.md

@@ -83,8 +83,10 @@ euler-eval config.json --batch-size 32
 
 Ground truth and prediction files are matched by ID rather than by directory
 order, so an incomplete prediction set scores the frames it does have instead of
-silently comparing the wrong pairs. Results are written next to each prediction
-modality:
+silently comparing the wrong pairs. Results are written into each prediction
+dataset, under `.eval/` beside its `.ds_crawler/` metadata — e.g.
+`/data/model_a/depth/.eval/eval.json`, or `.eval/<scope>/eval.json` for a scoped
+dataset ([details](docs/output.md#where-results-land)):
 
 ```json
 {
@@ -126,7 +128,8 @@ metric is written under, is in [Metrics](docs/metrics.md).
 | **Metadata-driven decoding** | Radial vs planar depth, value ranges, point-cloud column layout and loader choice all come from the dataset index — no per-dataset flags. |
 | **Honest spaces** | Relative models are scored `native` *and* `metric` (after scale/shift or a similarity gauge), so a scale failure never reads as a geometry failure. |
 | **Benchmark depth bins** | `--benchmark-depth-range MIN MAX` adds near/mid/far bins in square-root depth space, additive to the regular metrics. |
-| **Sky masking** | `--mask-sky` drops sky pixels using GT segmentation — from the metrics *and* from the alignment fit. |
+| **Sky masking** | `--mask-sky` drops sky pixels using GT segmentation — from the metrics *and* from the alignment fit. `--mask-sky-prediction` does the same with each prediction's own `sky_mask`. |
+| **Sky IoU** | `--sky-iou` scores predicted sky — a `sky_mask`, or depth reaching a fixed cap — against GT segmentation, without changing any depth metric. |
 | **Per-file + aggregate** | Dataset-level numbers plus per-image metrics in dataset-hierarchy order, in the same file. |
 | **Sanity checks** | Results are validated against configurable thresholds; implausible ranges, degenerate inputs and scale mismatches are reported instead of quietly scored. |
 | **Structured metric names** | Each result carries a `metricSet` envelope declaring its namespace, axes, units and metric directions. |

{euler_eval-2.30.0 → euler_eval-2.32.0}/docs/README.md

@@ -7,7 +7,7 @@
 | [Spaces & alignment](alignment.md) | Why `native` and `metric` exist, depth affine fitting, points-3d gauge alignment, benchmark depth bins |
 | [Metrics](metrics.md) | The full metric inventory per modality, with the key each one is written under |
 | [Error distributions](distributions.md) | Optional per-sample and pooled RMSE histograms, bin settings, axes and JSON layout |
-| [Results & output](output.md) | Where files land, the anatomy of `eval.json`, per-file metrics, the sanity-check report |
+| [Results & output](output.md) | Where files land, the anatomy of `eval.json`, comparing evaluations, per-file metrics, the sanity-check report |
 | [In-training validation](validation.md) | The programmatic API for scoring in-memory predictions during training |
 
 ## Proposed features

{euler_eval-2.30.0 → euler_eval-2.32.0}/docs/alignment.md

@@ -32,7 +32,8 @@ map `d_aligned = s · d_pred + t` by least squares over valid pixels.
 
 The fit uses pixels where GT and prediction are finite and GT > 0. With
 `--mask-sky`, sky pixels are excluded and the fit is trimmed to `gt ≤ P95(gt)`
-so residual sky outliers do not dominate.
+so residual sky outliers do not dominate. Pixels in a prediction's `sky_mask`
+are excluded from the fit with `--sky-depth` or `--mask-sky-prediction`.
 
 Declaring the prediction with the `relative_depth` or `affine_depth` config key
 (instead of `depth`) tells the evaluator the model is not metric, so

{euler_eval-2.30.0 → euler_eval-2.32.0}/docs/cli.md

@@ -23,7 +23,9 @@ validation exits with status `1` before any dataset is opened.
 | `--skip-rays` | flag | off | Skip rays (spherical direction map) evaluation |
 | `--skip-points-3d` | flag | off | Skip points_3d (per-pixel 3D point map) evaluation |
 | `--mask-sky` | flag | off | Mask sky regions from metrics using GT segmentation |
+| `--mask-sky-prediction` | flag | off | Exclude pixels in a prediction's `datasets[].sky_mask` from dense and sparse depth metrics and the alignment fit; predictions without a `sky_mask` are scored in full ([details](configuration.md#masking-predicted-sky)) |
 | `--sky-depth` | `float` | none | Cap GT and predicted depths in meters and fill predicted `sky_mask` pixels with this value; must be finite and positive |
+| `--sky-iou` | flag | off | Score predicted sky against GT segmentation sky: IoU, precision and recall for the `explicit` (`datasets[].sky_mask`) and `implicit` (`depth >= --sky-depth`, metric predictions only) variants. Requires `gt.segmentation`; depth metrics are unchanged ([details](metrics.md#sky-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 calibration mode ([details](alignment.md#depth-alignment)) |
@@ -35,6 +37,7 @@ validation exits with status `1` before any dataset is opened.
 | `--distribution-bins` | `int` | `50` | Total histogram bins, including tails; minimum 3 |
 | `--distribution-scale` | `{log,linear}` | `log` | Spacing of finite histogram bins |
 | `--distribution-range` | `float float` | `0.001 100` | Finite error range `[MIN, MAX)` in evaluated space units; zero/small-error and overflow bins retain the tails |
+| `--eval-name` | `str` | `eval` | Name this evaluation: results are written as `<name>.json` in each prediction dataset's `.eval/` folder, so differently named runs sit side by side; a dataset's `output_file` still wins ([details](output.md#where-results-land)) |
 
 Histogram settings can also be specified in the config's `distributions`
 section. A bin, scale or range flag enables histograms and overrides that
@@ -54,12 +57,22 @@ euler-eval config.json --batch-size 32
 # Sky masking (requires gt.segmentation)
 euler-eval config.json --mask-sky -v
 
+# Exclude each prediction's own sky (datasets[].sky_mask) from depth metrics
+euler-eval config.json --mask-sky-prediction
+
 # Cap depth at 100 m and fill predicted sky at 100 m (optional datasets[].sky_mask)
 euler-eval config.json --sky-depth 100
 
+# Sky IoU: explicit from datasets[].sky_mask, implicit at depth >= 100 m
+# (requires gt.segmentation; the threshold is also the depth cap)
+euler-eval config.json --sky-iou --sky-depth 100
+
 # Only depth evaluation
 euler-eval config.json --skip-rgb --skip-rays --skip-points-3d
 
+# Keep a sky-masked run beside the default results: .eval/[<scope>/]no_sky.json
+euler-eval config.json --mask-sky --eval-name no_sky
+
 # Force affine scale+shift alignment on all depth predictions
 euler-eval config.json --depth-alignment affine
 
@@ -109,6 +122,13 @@ per prediction dataset and modality with the GT and prediction paths, the
 resolved modality metadata (such as `radial_depth`), and the number of matched
 pairs.
 
+With `--sky-iou`, each depth block ends with one line holding the pooled
+(`pixel_pool`) sky IoU, precision and recall of every computed variant, for
+example `Sky IoU, pixel_pool, 'model': explicit 0.9120 (precision 0.9500,
+recall 0.9580); implicit (depth >= 100 m) 0.4410 (precision 0.9800, recall
+0.4450)`. Skipped variants, GT segmentation without sky and an empty implicit
+sky are reported as warnings above it.
+
 A matched-pair count that is much lower than expected is the first sign that GT
 and predictions are not indexed consistently — see
 [Loader resolution & dataset metadata](configuration.md#loader-resolution--dataset-metadata).

{euler_eval-2.30.0 → euler_eval-2.32.0}/docs/configuration.md

@@ -71,7 +71,8 @@ required.
 | `gt.sparse_depth.path` | no\* | Sparse pointcloud GT, `(N,C)` points whose first columns are `x,y,z` in metres |
 | `gt.rays.path` | no\* | GT ray direction map dataset |
 | `gt.points_3d.path` | no\* | GT per-pixel 3D point map `(H,W,3)` in camera-frame metres |
-| `gt.segmentation.path` | no | GT segmentation (needed for `--mask-sky`) |
+| `gt.segmentation.path` | no | GT segmentation (needed for `--mask-sky` and `--sky-iou`); see [GT segmentation](#gt-segmentation) |
+| `gt.semantic_segmentation.path` | no | Alias of `gt.segmentation`; configure only one of the two |
 | `gt.calibration.path` | no | Calibration data (camera intrinsics); enables true camera-frame [surface normals](metrics.md#surface-normals-and-calibration) |
 | `gt.intrinsics.path` | with `gt.sparse_depth` | Camera intrinsics for pointcloud projection |
 | `gt.camera_extrinsics.path` | with `gt.sparse_depth` | Source-to-camera extrinsics (e.g. MUSES `lidar2rgb`) |
@@ -80,6 +81,35 @@ required.
 
 \* At least one of the five modality entries must be present.
 
+### GT segmentation
+
+`gt.segmentation` is the canonical key. `gt.semantic_segmentation` is accepted
+as an alias, for archives whose segmentation scope carries that name (MUSES,
+for example); configuring both keys is an error. The segmentation is read only
+when `--mask-sky` or `--sky-iou` needs it. `--mask-sky` without it warns and
+disables itself, while `--sky-iou` without it exits with an error.
+
+The dataset head's loader module must expose a `sky_mask` function, and the
+head must declare the sky label as `skyclass` (euler-loading 2.29 or later).
+euler-eval contains no label IDs.
+
+Segmentation is per frame, so it is paired with the evaluated frames by
+hierarchy path and file ID, like depth: its index must use the same folder
+structure and IDs as the frames it masks. A frame without its own segmentation
+file is not evaluated, and the run prints how many pairs the segmentation
+dropped. When segmentation is read only for `--sky-iou`, it must not change
+the evaluated pairs, so a segmentation that lacks frames is not loaded; the run
+warns and the sky IoU is skipped. A segmentation whose IDs match no frame
+stops the run with euler-loading's "No common IDs" error and per-modality file
+counts.
+
+The config key is also the default metadata scope. If the path has no
+`#scope=` selector, no root-level metadata, and no scope of that name, the
+scope is chosen among the archive's scopes: the one whose name or
+`dataset-head.json` modality key is `segmentation` or `semantic_segmentation`
+(both names are candidates under either key), or the only scope. If several
+scopes match, or none among several, the run stops and asks for `#scope=`.
+
 ## `datasets` section
 
 Each entry needs a `name` and at least one prediction modality. Use only **one**
@@ -94,10 +124,10 @@ would be ambiguous.
 | `depth.path` | no\* | Predicted dense metric depth; also used against sparse pointcloud GT |
 | `relative_depth.path` | no\* | Predicted dense relative depth (scale/shift alignment supported) |
 | `affine_depth.path` | no\* | Predicted dense affine depth (scale/shift alignment supported) |
-| `sky_mask.path` | no | Auxiliary predicted sky mask for a dense depth entry; used with `--sky-depth` |
+| `sky_mask.path` | no | Auxiliary predicted sky mask for a dense depth entry; used with `--sky-depth`, `--mask-sky-prediction` and `--sky-iou` |
 | `rays.path` | no\* | Predicted ray direction map dataset |
 | `points_3d.path` | no\* | Predicted per-pixel 3D point map `(H,W,3)` |
-| `output_file` | no | Custom results path (default: `eval.json` in the first modality path) |
+| `output_file` | no | Custom results path for every modality of this entry, replacing the `.eval/` layout and `--eval-name` (default: `.eval/[<scope>/][split_<split>/]eval.json` in each prediction modality's dataset root; see [where results land](output.md#where-results-land)) |
 
 \* At least one prediction modality must be present.
 
@@ -123,8 +153,8 @@ The sky mask is paired with GT and predicted depth by sample ID and hierarchy.
 It supports the same archive, split, and `#scope=` selectors as depth, defaulting
 to the `sky_mask` metadata scope. Its loader must return a boolean mask with
 **True meaning sky**. For example, `generic_dense_depth.sky_mask` uses the RGB
-sky color in the mask dataset's `meta.sky_mask` (`[R, G, B]`) and returns a
-`(1, H, W)` tensor. Masks at another resolution follow the depth grid's crop
+sky color in the mask dataset's `meta.skyclass` (`[R, G, B]`; the older
+`meta.sky_mask` key is deprecated) and returns a `(1, H, W)` tensor. Masks at another resolution follow the depth grid's crop
 rule or use nearest-neighbor resizing.
 
 `--sky-depth` applies to dense and sparse depth evaluation. GT and both native
@@ -139,9 +169,37 @@ contributes only at projected points. Predicted sky stays in the scores where
 GT is valid; `--mask-sky` separately excludes pixels using GT segmentation and
 can be combined with `--sky-depth`.
 
-Without `--sky-depth`, the predicted mask is not loaded and depth evaluation
-uses the usual uncapped values. The effective cap and mask source are recorded
-in `eval.json` under `meta.eval_params.sky_depth` and `meta.pred.sky_mask`.
+Without `--sky-depth`, `--mask-sky-prediction` or `--sky-iou`, the predicted
+mask is not loaded and depth evaluation uses the usual uncapped values.
+`--sky-iou` loads the mask
+even without `--sky-depth`, but only to score it against GT sky
+([Sky segmentation](metrics.md#sky-segmentation)); the depth fill and the
+affine-fit exclusion stay tied to `--sky-depth` (and `--mask-sky-prediction`),
+so depth values do not change.
+Because the mask is paired by sample ID, a mask that lacks some depth frames
+also drops them from the depth metrics; the run prints how many. When the mask
+is loaded only for `--sky-iou`, such a mask is not loaded at all: the run
+warns, keeps every depth pair and skips the explicit variant. The effective cap and mask
+source are recorded in `eval.json` under `meta.eval_params.sky_depth` and
+`meta.pred.sky_mask`.
+
+### Masking predicted sky
+
+`--mask-sky-prediction` excludes the pixels of a prediction's `sky_mask` from
+dense and sparse depth evaluation, as `--mask-sky` does for GT sky: from every
+metric, benchmark bin and histogram, and from the scale/shift fit. For sparse
+depth, lidar points that project into predicted sky are not scored. A dataset
+without a `sky_mask` is scored in full and the run warns. The flag loads the
+mask without `--sky-depth`, combines with `--mask-sky` (the union of both skies
+is excluded) and with `--sky-depth` (the cap still applies to the remaining
+pixels). It does not change `--sky-iou`, which scores the masks themselves.
+
+The excluded pixels come from the evaluated model, so two models are scored on
+different pixel sets, and a model can lower its error by calling hard pixels
+sky. Each result records how much it excluded under `meta.pred_sky_masking`
+([Results & output](output.md#predicted-sky-masking)); compare models with
+this flag only alongside that fraction, or prefer `--mask-sky`, whose GT sky is
+the same for every model.
 
 ## Sparse depth (pointcloud GT)
 
@@ -156,14 +214,16 @@ and evaluated as `points_3d`.
 
 An explicit `datasets[].points_3d` prediction can be evaluated separately
 against the same sparse cloud. That evaluation uses the points-3D similarity
-gauge, writes an atomic `points3d.eval` metric set beside the point-map
-prediction, and is controlled by `--skip-points-3d`. If a dataset provides both
-depth and `points_3d`, each prediction modality gets its own `eval.json` at its
-own path.
+gauge, writes an atomic `points3d.eval` metric set to the point-map
+prediction's results file, and is controlled by `--skip-points-3d`. If a dataset
+provides both depth and `points_3d`, each prediction modality gets its own
+results file, also when both live in one archive under separate scopes (see
+[where results land](output.md#where-results-land)).
 
 Sparse depth does not require segmentation GT. `gt.segmentation` is loaded only
-when `--mask-sky` is set, and then excludes sky pixels from projected-point
-metrics and from scale/shift fitting.
+when `--mask-sky` or `--sky-iou` is set. `--mask-sky` excludes sky pixels from
+projected-point metrics and from scale/shift fitting; `--sky-iou` scores the
+dense prediction's sky against it without changing any depth metric.
 
 ```json
 {
@@ -239,11 +299,15 @@ The scope defaults to the configuration key name, so the common case is compact:
 
 Use `#scope=<scope>` when an artifact scope is not named exactly like the config
 key, e.g. `"sparse_depth": { "path": "/data/capture.zip:test#scope=lidar" }`.
-
-Regular modalities (`rgb`, `depth`, `rays`, `points_3d`, `sparse_depth`)
-participate in file-ID intersection; calibration and pose data (`intrinsics`,
-`calibration`, `camera_extrinsics`, `lidar_extrinsics`, segmentation) are loaded
-hierarchically and do not.
+GT segmentation is the exception: under either of its keys it also finds a
+scope named after the other key, as described in [GT segmentation](#gt-segmentation).
+
+Regular modalities (`rgb`, `depth`, `rays`, `points_3d`, `sparse_depth`, GT
+segmentation and a predicted `sky_mask`) participate in file-ID intersection;
+calibration and pose data (`intrinsics`, `calibration`, `camera_extrinsics`,
+`lidar_extrinsics`) are loaded hierarchically and do not. A hierarchical file
+applies to every frame at or below its folder, which suits one calibration per
+scene but not per-frame data.
 
 ## `metrics_config.json`
 

{euler_eval-2.30.0 → euler_eval-2.32.0}/docs/metrics.md

@@ -76,6 +76,87 @@ the 45° sanity threshold.
 > plane read as nearly fronto-parallel and the focal length was unused. Values
 > are not comparable with earlier releases.
 
+### Sky segmentation
+
+`--sky-iou` scores how well each prediction's sky matches the GT segmentation
+sky. It is opt-in and read-only: no depth value, mask or alignment fit changes,
+so every other key keeps its value. It requires `gt.segmentation` (or its alias
+`gt.semantic_segmentation`); the sky label comes from that dataset head's
+`skyclass`, as for `--mask-sky`.
+
+There are two variants. They answer different questions, so they are reported
+under separate keys and never merged:
+
+| Variant | Predicted sky `P` | Computed when |
+|---|---|---|
+| `explicit` | The prediction's `datasets[].sky_mask` (True = sky) | The prediction has a `sky_mask` |
+| `implicit` | `depth >= --sky-depth` | `--sky-depth` is set and the prediction is metric |
+
+The implicit test reads the prediction after planar-to-radial conversion and
+before calibration and capping. `+inf` counts as sky; NaN and values `<= 0` do
+not. It is not computed for `relative_depth`, `affine_depth` or predictions
+detected as normalized, since their values are not in meters. When both sources
+exist, both variants are reported side by side; neither replaces the other. A
+dataset with neither prints a warning and writes no sky keys.
+
+| Metric | Key |
+|---|---|
+| Sky IoU / precision / recall | `depth.eval.sky_segmentation.{explicit,implicit}.{pixel_pool,image_mean,image_median}.{iou,precision,recall}` |
+| Sparse-depth runs | `sparsedepth.eval.sky_segmentation.{explicit,implicit}.{pixel_pool,image_mean,image_median}.{iou,precision,recall}` |
+| Per file | `{depth,sparsedepth}.eval.sky_segmentation.{explicit,implicit}.{iou,precision,recall}` |
+
+`sky_segmentation` sits beside `native` and `metric`, not under them, because
+the IoU does not depend on the evaluated depth space. Sparse-depth runs score
+the dense prediction grid against the GT segmentation exactly like dense runs;
+the sparse GT depth plays no part. Provenance, including the threshold and the
+GT and predicted sky fractions, is recorded under
+[`meta.sky_segmentation`](output.md#sky-segmentation-provenance).
+
+If the GT segmentation lacks frames and `--mask-sky` is off, it is not loaded
+and no sky IoU is computed, so that the depth pairs stay the same; see
+[GT segmentation](configuration.md#gt-segmentation).
+
+**Definitions.** GT sky `G` is the segmentation of the sample's own frame,
+resized to the prediction grid with the same rule as GT depth (crop for the
+VAE multiple-of-8 pattern, nearest neighbour otherwise). An explicit mask is
+resized the same way. The domain `D` is the full prediction grid. Per sample:
+
+```text
+I = |P ∩ G ∩ D|   U = |(P ∪ G) ∩ D|   T_p = |P ∩ D|   T_g = |G ∩ D|
+iou = I / U       precision = I / T_p   recall = I / T_g
+```
+
+Each value is undefined when its denominator is 0. `image_mean` and
+`image_median` reduce the defined per-image values. `pixel_pool` is
+`ΣI / ΣU`, `ΣI / ΣT_p` and `ΣI / ΣT_g` over all samples, so a sample with an
+undefined IoU (no sky in `P` or `G`) is left out of the image reducers but
+still adds its zero counts to the pooled sums. Undefined dataset values are
+omitted from `eval.json`.
+
+**Interpreting the numbers.**
+
+- **Explicit IoU** measures agreement between a dedicated sky prediction and GT
+  sky. It does not depend on depth quality.
+- **Implicit IoU** measures whether the depth output reaches `--sky-depth` on
+  GT sky pixels. It does not measure whether the regressor recognizes sky. A
+  regressor that outputs about 95 m over the sky, as UniDepth V2 does in fog,
+  never reaches a 250 m cap; its implicit IoU is close to zero by construction,
+  even if it places the sky correctly relative to everything else. The same
+  model at `--sky-depth 80` can score high. Implicit IoU therefore depends on
+  both the model's saturation behaviour and the cap.
+
+Consequences:
+
+- Never present implicit and explicit IoU as the same quantity, and always
+  state the threshold with an implicit value (`meta.sky_segmentation.threshold_m`).
+- Do not choose `--sky-depth` on the benchmark to maximize implicit IoU. That
+  is the same leakage as choosing the fill constant on the test set. Fix the
+  threshold beforehand, or report several runs at fixed thresholds.
+- Pooled IoU weights images by their sky area, so a few large-sky images can
+  dominate it. `image_median` shows typical behaviour.
+- Precision and recall separate the two failure modes. Low recall with high
+  precision usually means the regressor does not saturate at the cap.
+
 ## Sparse depth
 
 With a sparse pointcloud GT, only metrics that stay meaningful at isolated
@@ -86,6 +167,7 @@ skipped. Results serialize under the `sparsedepth.eval` root:
 |---|---|
 | Standard | `sparsedepth.eval.{native,metric}.standard.{image_mean,image_median,pixel_pool}.*` |
 | AbsRel / RMSE / SILog | `sparsedepth.eval.{native,metric}.depth_metrics.*` |
+| Sky segmentation (`--sky-iou`) | `sparsedepth.eval.sky_segmentation.*` ([details](#sky-segmentation)) |
 
 ## RGB