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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: euler-eval
-Version: 2.30.0
+Version: 2.31.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
@@ -176,7 +176,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.31.0}/README.md

@@ -126,7 +126,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.31.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.31.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)) |
@@ -54,9 +56,16 @@ 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
 
@@ -109,6 +118,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.31.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,7 +124,7 @@ 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) |
@@ -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)
 
@@ -162,8 +220,9 @@ depth and `points_3d`, each prediction modality gets its own `eval.json` at its
 own path.
 
 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 +298,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.31.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
 

{euler_eval-2.30.0 → euler_eval-2.31.0}/docs/output.md

@@ -78,6 +78,65 @@ GT/prediction resolution mismatch was resolved — `none` when they already matc
 `vae_crop` for the multiple-of-8 crop that latent models produce, `resize`
 otherwise, and `pointcloud_projection` when GT was a sparse cloud.
 
+### Sky segmentation provenance
+
+With `--sky-iou`, dense and sparse depth results record
+`meta.eval_params.sky_iou: true` and a `meta.sky_segmentation` block. Without
+the flag, neither field exists. Values below are illustrative:
+
+```json
+"sky_segmentation": {
+  "explicit": {
+    "available": true, "source": "pred.sky_mask", "samples": 500,
+    "samples_undefined_iou": 3, "pred_sky_fraction": 0.19
+  },
+  "implicit": { "available": false, "reason": "prediction is not metric (relative)" },
+  "gt_source": "gt.segmentation",
+  "domain": "prediction_grid",
+  "samples": 500,
+  "samples_without_gt": 0,
+  "gt_sky_fraction": 0.21
+}
+```
+
+| Field | Meaning |
+|---|---|
+| `explicit`, `implicit` | Whether each variant was computed. A computed variant gives its `source`, how many `samples` it scored, how many had an undefined IoU (no sky in prediction or GT), and its pooled predicted sky fraction; the implicit one adds `rule: "depth >= threshold_m"`. A skipped variant gives the `reason` instead |
+| `gt_source` | The config key the GT segmentation came from |
+| `threshold_m` | The `--sky-depth` threshold of the implicit variant; present only when that variant was computed |
+| `domain` | Pixels scored: `prediction_grid`, the full prediction grid |
+| `samples` | Depth pairs evaluated |
+| `samples_without_gt` | Pairs left out because no GT segmentation of their own frame was found |
+| `gt_sky_fraction` | Pooled GT sky fraction over the scored samples |
+
+### Predicted-sky masking
+
+With `--mask-sky-prediction`, dense and sparse depth results record
+`meta.eval_params.mask_sky_prediction: true` and how much the prediction's own
+sky removed, since that differs from model to model:
+
+```json
+"pred_sky_masking": {
+  "source": "pred.sky_mask",
+  "samples": 500,
+  "samples_with_sky_mask": 500,
+  "gt_valid_pixels": 1048576000,
+  "excluded_gt_pixels": 220200960,
+  "excluded_gt_fraction": 0.21
+}
+```
+
+`gt_valid_pixels` counts the GT pixels (projected lidar points for sparse
+depth) that would be scored without the flag, after `--mask-sky` if set;
+`excluded_gt_pixels` is how many of them fell in predicted sky.
+
+When sky keys are written, the metric-set axes also declare them:
+`sky_segmentation` joins the `category` values, an optional `variant` axis
+(`explicit`, `implicit`) follows `category`, and `space` becomes optional
+because these keys have no depth space. `metricDescriptions` gains `iou`,
+`precision` and `recall` (higher is better, bounds `[0, 1]`). Every other key
+decomposes exactly as before.
+
 ## Spaces and canonical aliases
 
 Depth-like and points-3d results are nested by space: