Initial release: metadata, code, adapters (v1.0; scenes/ in next commit)

CHANGELOG.md

@@ -0,0 +1,31 @@
+# Changelog
+
+All notable changes to CM-EVS are documented here. The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [v1.0.0] — 2026-05-02 (initial release)
+
+### Added
+
+- **Blender indoor data drop**: 374 scene instances (`sence_indoor_0001 … sence_indoor_0374`), 13,631 ERP RGB frames + 12,634 range-depth NumPy arrays + 13,631 pose JSON files. Resolution 2048×1024. CC-BY 4.0.
+- **Blender indoor metadata**: `source_manifest.json`, `splits.json` (scene-level 70/15/15 via `sha256(scene_id) % 100`), `frame_manifest.csv` (14 columns matching the Croissant RecordSet schema), `scene_id_mapping.csv` and `frame_id_mapping.csv` (back-references to original H100 round1+2 / round2 sampling).
+- **Per-archive integrity**: `blender_indoor/SHA256SUMS` (39,896 lines covering panorama + depth + pose).
+- **Adapter packages** for the four license-restricted sources: HM3D (401 rooms), ScanNet++ (500 scans), OB3D (24 instances, outdoor), TartanGround (762 parts, outdoor). Each package contains README, config, pipeline / re-encoding script, and `metadata/source_manifest.json` listing the upstream scene IDs needed to reproduce the curator's selection.
+- **Curator source code** (`code/`): MIT-licensed core modules (`core/`), scripts (`scripts/`), helper tools (`tools/`), metadata schemas (`metadata_examples/`), tiny example (`examples/tiny_blender_scene/`), `environment.yml`, `requirements.txt`.
+- **Croissant v1.0 metadata** (`croissant.json`): conforms to <http://mlcommons.org/croissant/1.0>; passes `mlcroissant 1.1.0` validator. 12 distribution entries (Blender archive + 4 FileSets + 4 adapter packages + code + docs + frame-manifest), 1 RecordSet (`erp-frame-records`) with 14 fields, 9 RAI extension fields.
+- **Datasheet** (in `README.md`) following Gebru et al. 2021.
+- **License matrix** (`LICENSE.md`).
+- **Top-level integrity manifest** (`SHA256SUMS`) covering all non-data files.
+- **Pre-push checklist** (`TODO.md`).
+
+### Notes
+
+- The paper's headline numbers `326 scenes / 11,583 frames` describe the **curator-selected subset**, not the full data drop. v1.0 stages the underlying 374 / 13,631; the curator-selected subset will be derived after the §5 evaluation experiments finalize and posted as v1.1.
+- **HM3D / ScanNet++ / TartanGround / OB3D**: zero RGB-D frames are redistributed under any license. The adapter packages reproduce matching frames on the user's machine after upstream access is granted.
+- Frame numbers within each Blender scene are renumbered consecutively (`panorama_0000 … panorama_NNNN`); `frame_id_mapping.csv` records the back-reference to the original H100 file path for traceability.
+
+### Known gaps (tracked in `TODO.md`)
+
+- §5 evaluation result CSVs are still placeholders (coverage / oracle / lambda sweep / cross-source / 50-frame audit).
+- `frame_quality.csv` (per-frame invalid-depth + exposure stats) requires running `code/scripts/audit_quality.py` over the 13,631 frames.
+- Curator-only fields in `frame_manifest.csv` (`viewpoint_score`, `coverage_gain`, `conflict_ratio`, `candidate_id`) are intentionally empty in v1.0 because the curator has not yet run on the merged 374-scene set.
+- Real `sha256` and `contentUrl` for each `cr:FileObject` in `croissant.json` will be filled when the actual distributable archives are packaged.

LICENSE.md

@@ -0,0 +1,39 @@
+# CM-EVS License Matrix
+
+CM-EVS combines redistributable synthetic frames, license-aware adapter scripts, and metadata derived from upstream datasets that have their own access terms. **This release is mixed-license.** Please consult the per-component table below before redistribution or commercial use.
+
+| Component | Source license | CM-EVS release license | Notes |
+| --- | --- | --- | --- |
+| Blender indoor frames (`blender_indoor/scenes/`) | CC0 / CC-BY 4.0 source assets | **CC-BY 4.0** | Redistributable. Includes RGB, range-depth, pose, and metadata for 374 scene instances / 13,631 frames. |
+| HM3D adapter (`adapters/hm3d/`) | code: original; metadata: Matterport / HM3D EULA | **MIT** (code) + upstream EULA (scene ids and any HM3D-derived metadata) | No derived RGB-D frames are redistributed. Users must independently accept HM3D's EULA before running the adapter. |
+| ScanNet++ adapter (`adapters/scannetpp/`) | code: original; metadata: ScanNet++ ToS | **MIT** (code) + upstream ToS (scan ids and any ScanNet++-derived metadata) | No derived RGB-D frames are redistributed. Users must accept the ScanNet++ ToS. |
+| OB3D adapter (`adapters/ob3d/`) | code: original; metadata: per upstream OB3D | **MIT** (code) + upstream license (any OB3D-derived metadata) | Outdoor re-encoding adapter. No data redistributed. |
+| TartanGround adapter (`adapters/tartanground/`) | code: original; metadata: per upstream TartanGround / TartanAir | **MIT** (code) + upstream license (any TartanGround-derived metadata) | Outdoor re-encoding adapter. No data redistributed. |
+| Curator source code (`code/`) | original | **MIT** | Includes core modules, scripts, tools, metadata schemas, tiny example. |
+| Documentation (`README.md`, `LICENSE.md`, `CHANGELOG.md`, `TODO.md`, `*/README.md`) | original | **CC-BY 4.0** | Datasheet, Croissant metadata, and per-source READMEs. |
+| Croissant metadata (`croissant.json`) | original | **CC-BY 4.0** | MLCommons Croissant v1.0; passes mlcroissant 1.1 validator. |
+
+## Important constraints
+
+- **Blender indoor**: CC-BY 4.0 — attribution required if redistributed or used commercially. Cite the dataset paper (see `README.md`).
+- **HM3D / ScanNet++ / TartanGround / OB3D**: regenerated frames produced by running the adapters here remain bound by the **upstream license** of each source. The MIT license on the adapter code does **not** override upstream terms for those frames.
+- **Synthetic-real gap**: this dataset includes synthetic Blender renders. Synthetic-only results should not be used as evidence for real-scan performance without further validation; see paper §6 limitations.
+
+## Attribution
+
+If you use the Blender indoor data or curator code, please cite:
+
+```bibtex
+@inproceedings{cmevs2026,
+  title={{CM-EVS}: A Coverage-Curated Panoramic {RGB-D} Dataset for Indoor Scene Understanding},
+  author={Anonymous Author(s)},
+  booktitle={NeurIPS 2026 Datasets and Benchmarks Track (under review)},
+  year={2026}
+}
+```
+
+For full text of the licenses referenced above, see:
+- CC-BY 4.0: <https://creativecommons.org/licenses/by/4.0/legalcode>
+- MIT: <https://opensource.org/licenses/MIT>
+- HM3D EULA: <https://aihabitat.org/datasets/hm3d/>
+- ScanNet++ ToS: <https://kaldir.vc.in.tum.de/scannetpp/>

README.md

@@ -0,0 +1,156 @@
+---
+license: other
+license_name: cm-evs-mixed
+language:
+- en
+size_categories:
+- 10K<n<100K
+task_categories:
+- depth-estimation
+- image-to-image
+tags:
+- panoramic
+- equirectangular
+- erp
+- rgb-d
+- viewpoint-selection
+- view-planning
+- data-curation
+- 3d-scene
+- indoor-scene-understanding
+- world-model
+- novel-view-synthesis
+pretty_name: CM-EVS — Coverage-Curated Panoramic RGB-D Dataset
+---
+
+# CM-EVS: A Coverage-Curated Panoramic RGB-D Dataset for Indoor Scene Understanding
+
+CM-EVS is a curated panoramic RGB-D dataset built under a single principle: **maximize the geometric coverage of a 3D scene with the fewest equirectangular (ERP) frames possible**. The release is structured as one redistributable Blender indoor data archive plus four license-aware adapter packages that regenerate matched frames locally from upstream sources whose terms forbid redistribution.
+
+> **v1.0 status**: this version stages the **full Blender indoor data drop** (374 scene instances, 13,631 ERP RGB-depth-pose frames; 201 from the round1+2 sampling and 173 from round2). The paper's headline `326 scenes / 11,583 frames` is the curator-selected subset that will be derived from this drop after the §5 evaluation experiments finalize. See `TODO.md` for items still in flight.
+
+## Dataset summary
+
+| Source | License | Released here | Scenes / frames |
+| --- | --- | --- | --- |
+| **Blender indoor** | CC-BY 4.0 | **Full data** (`blender_indoor/`) | 374 / 13,631 |
+| HM3D | upstream EULA | Adapter only (`adapters/hm3d/`) | 401 rooms / regen-only |
+| ScanNet++ | upstream ToS | Adapter only (`adapters/scannetpp/`) | 500 scans / regen-only |
+| OB3D (outdoor) | upstream license | Adapter only (`adapters/ob3d/`) | 24 / regen-only |
+| TartanGround (outdoor) | upstream license | Adapter only (`adapters/tartanground/`) | 762 parts / regen-only |
+
+The Blender indoor frames are the only redistributable RGB-D data. For the four restricted sources, this dataset ships the per-source adapter (config + pipeline script + scene-id metadata); users obtain upstream data themselves and run the adapter locally to reproduce matching ERP frames under the unified schema.
+
+## Output schema
+
+Every released ERP frame follows a single coordinate convention:
+
+- World frame: right-handed, `+X` right, `+Y` up, `+Z` forward
+- Camera frame: OpenCV (`+x` image right, `+y` image down, `+z` camera forward)
+- Pose: scalar-first quaternion `q_wc = [w, x, y, z]` plus position `C_w − C_{w,0}` relative to the scene's first selected frame (the absolute first-frame center is recorded once per scene in `meta.json` when present)
+- ERP pixel coords: longitude `(u/W − 0.5) · 2π`, latitude `(0.5 − v/H) · π`
+- Range depth: each pixel stores radial distance from camera center to surface (not perspective `z`-depth). NaN or 0 marks invalid pixels.
+
+| File | Format | Description |
+| --- | --- | --- |
+| `panorama_{NNNN}.png` | PNG, 2048×1024 | ERP RGB image |
+| `panorama_{NNNN}_depth.npy` | float32 array | ERP range depth (m); NaN or 0 if invalid; absent for some frames where depth was not produced |
+| `pose_{NNNN}.json` | JSON | `q_wc`, position, `camera_type` |
+
+Per-scene `meta.json`, `metadata/selected_viewpoints.json`, `metadata/candidates.jsonl`, `metadata/per_step_log.jsonl` (curator-only) will land here once the curator runs on the merged 374-scene set; see `TODO.md`.
+
+## Directory layout
+
+```
+cmevs_hf_release/
+├── README.md            (this file — HF dataset card)
+├── LICENSE.md           (mixed-license matrix)
+├── CHANGELOG.md
+├── croissant.json       (MLCommons Croissant v1.0; passes mlcroissant 1.1 validator)
+├── SHA256SUMS           (top-level checksums, excluding blender_indoor/scenes/)
+├── TODO.md              (pre-push checklist)
+├── blender_indoor/
+│   ├── README.md
+│   ├── scenes/sence_indoor_{0001..0374}/{panorama,pose}_{NNNN}.{png,npy,json}
+│   ├── SHA256SUMS       (39,896 lines for 13,631 frames × ~3 files)
+│   └── metadata/{source_manifest.json, splits.json, frame_manifest.csv,
+│                  scene_id_mapping.csv, frame_id_mapping.csv}
+├── adapters/{hm3d, scannetpp, ob3d, tartanground}/
+│   ├── README.md
+│   ├── config.yaml
+│   ├── pipeline.py / reencoding_script.md
+│   └── metadata/source_manifest.json
+├── code/                (curator core modules + scripts; reviewer reference)
+└── results/             (paper §5 result CSVs; placeholders to be filled)
+```
+
+## Datasheet
+
+Following Gebru et al. 2021. (Source: `main.tex` Appendix A — content here is a faithful markdown rendering; cross-check against the paper PDF.)
+
+### Motivation
+
+**Purpose.** Evaluates fixed-budget panoramic viewpoint curation policies on existing 3D assets, and provides reproducible ERP RGB-D-pose samples for panoramic perception experiments.
+
+**Creators / funding.** Anonymized during double-blind review; finalized in camera-ready.
+
+### Composition
+
+**Instances.** Each instance is an ERP frame triple (RGB image + range-depth array + camera pose), plus per-scene `meta.json` and curator-only provenance metadata.
+
+**Counts.** v1.0 stages 13,631 ERP frames across 374 Blender indoor scene instances (CC-BY 4.0). The four restricted sources (HM3D / ScanNet++ / OB3D / TartanGround) ship adapters only; users regenerate matching frames locally.
+
+**Sampling.** Indoor (Blender) frames are produced offline by Cycles ERP rendering. The 374 scene instances comprise 201 from round1+2 (Blender_indoor_FOU_threshold-0.2, rounds 1+2 merge) and 173 from round2 (independent extraction). 48 original `sence_indoor_XXXX` ids appear in both rounds with different sampling outcomes; both versions are kept and renumbered (see `blender_indoor/metadata/scene_id_mapping.csv` for traceability). Outdoor source trajectories (TartanGround, OB3D) are re-encoded into the unified schema by the `adapters/{tartanground,ob3d}/` pipelines; the curator does not run on outdoor sources in v1.0.
+
+**Fields.** RGB PNG (2048×1024 for Blender indoor; native source resolution otherwise), float32 range depth (`.npy`), pose JSON with scalar-first `q_wc`, `meta.json`, candidate / viewpoint / per-step-log metadata (curator-produced frames only), source / scene / split ids.
+
+**Missing values.** Invalid depth pixels are NaN or 0 by source convention; per-frame invalid-depth ratio statistics will land in `results/frame_quality.csv` (see TODO).
+
+**Splits.** Default scene-level 70 / 15 / 15 split via `sha256(new_scene_id) % 100`. See `blender_indoor/metadata/splits.json`. The downstream panoramic-depth experiment (paper §4.10) uses a separate 94-scene Blender-indoor subset under its own scene-level split (84 / 10 / 10 = 3,400 / 362 / 423 frames).
+
+### Collection
+
+Indoor data is produced by the CM-EVS pipeline (asset loading, coordinate normalization, candidate generation, 26-direction geometric-validity filtering, conflict-aware greedy selection, 2048×1024 high-resolution Cycles ERP rendering, export under the unified schema). Outdoor data (TartanGround, OB3D) is re-encoded into the unified schema; the curator does **not** run on outdoor sources in v1.0. HM3D and ScanNet++ frames are not redistributed: the release ships adapter regeneration scripts that produce matched frames locally after the user accepts upstream license terms. No new human-subject data is collected.
+
+### Preprocessing
+
+Coordinate normalization to right-handed `+X`-right `+Y`-up `+Z`-forward world frame with the OpenCV-style camera frame; pose stored as scalar-first `q_wc = [w, x, y, z]` plus position relative to the scene's first selected frame. AABB computation; source-specific candidate generation; 26-direction geometric-validity filter. Cubemap-to-ERP re-encoding at native resolution for outdoor sources; optional exposure adjustment for Blender; output schema conversion. Raw upstream 3D assets are not redistributed unless upstream licenses allow.
+
+### Uses
+
+**Recommended:** panoramic depth estimation, ERP novel-view synthesis, data-centric viewpoint policy comparison, view-planning research, panoramic Gaussian-splatting reconstruction, panoramic world-model pretraining.
+
+**Avoid:** identity-sensitive inference, safety-critical deployment, claims about private indoor spaces, treating synthetic-only results as real-world evidence without further validation.
+
+### Distribution
+
+Blender indoor frames (CC-BY 4.0), curator code (MIT), documentation (CC-BY 4.0), Datasheet, and Croissant metadata are released here. The four restricted sources ship metadata + regeneration scripts only.
+
+### Maintenance
+
+Versioned releases on a 6-month cadence. Errata are tracked via the project repository; checksum manifests are refreshed at every release; regeneration scripts are updated when upstream APIs, file layouts, or access terms change.
+
+## Citation
+
+```bibtex
+@inproceedings{cmevs2026,
+  title={{CM-EVS}: A Coverage-Curated Panoramic {RGB-D} Dataset for Indoor Scene Understanding},
+  author={Anonymous Author(s)},
+  booktitle={NeurIPS 2026 Datasets and Benchmarks Track (under review)},
+  year={2026}
+}
+```
+
+## Verifying integrity
+
+```bash
+# top-level files + adapter packages + code + metadata
+shasum -a 256 -c SHA256SUMS
+
+# Blender indoor frames (39,896 entries: 13,631 panorama + 12,634 depth + 13,631 pose)
+cd blender_indoor && shasum -a 256 -c SHA256SUMS
+```
+
+## License
+
+See `LICENSE.md` for the per-component license matrix.

SHA256SUMS

@@ -0,0 +1,88 @@
+335453649489fd3fa08a4296e38ba8a86dabb8455501ad9f78ef2b08a4092bd6  CHANGELOG.md
+6c00f7c8cd699b2e706058cf03f8a12866fb588abebf80a29ba21ff4b4407ac5  LICENSE.md
+a04a8e6d4ce3bf5c9dab3aa27c7e050e08247106dce5b5e7637e5d23ede533c4  README.md
+296be8845dcbe9d09f01762726d5618c62e2adebd530bd1286b9eb342d91ecb3  TODO.md
+2c66395c6714c6664039a03344cb795c9216258b957d16990f020623883ebe48  adapters/README.md
+979bb0b0eba729b79f2f1b1fa51095d8a58ca6d363abc6dc7e678c8517d90c61  adapters/hm3d/README.md
+93ddb9458d7caaa9898df553a1a9f756b5fca0cdc6514edff226b13176c0577e  adapters/hm3d/config.yaml
+65eba96c4175d2f8cef275b306169463ad138f2d329c7aed70c447d89062764d  adapters/hm3d/metadata/source_manifest.json
+1008e53f357b0cb3126139b682ceede7d329b6e3dfa2f178b4cf62d7eda591f9  adapters/hm3d/pipeline.py
+0dbec1b25b605ea7a92771ee50da7274aef1214430f0176eec2d4c05ccadb37b  adapters/ob3d/README.md
+fa1c89831631f09015ac87bd0d409dac8a1c38d88425defbdc33b106f7dbffc1  adapters/ob3d/config.yaml
+777d9f30d901755dc4176cf1477e4d3bd5f39f835db38c7798915f6907036dac  adapters/ob3d/metadata/source_manifest.json
+f4645cb6e5448e51b88f7b7f4d3795f2c2c1356e906d64e99725dad922bd0970  adapters/ob3d/reencoding_script.md
+137f008232551fb16503fe1785c97e774c5a566db74b07bc8811423714437986  adapters/scannetpp/README.md
+00cd245e4e590b8f7f649cfa87170099d758c0f166970755270b2f752a478666  adapters/scannetpp/config.yaml
+2097e0ab11ce36b97dc7f52deba9e1a8ee26ac3556f804934905559a0000b692  adapters/scannetpp/metadata/source_manifest.json
+8c03c3f667f9ee1466d1c183359bf9a4d182473675d07515f8dfcbecfca39928  adapters/scannetpp/pipeline.py
+f7d2598f886e92d8d197d54fbc5daffa6851cfa00b09a7746be07ca3b1ae7e5f  adapters/tartanground/README.md
+4685882bc25d76b6cf1d1edbc142687f1d3165864a50267cfc245340bac8c948  adapters/tartanground/config.yaml
+7d7f2208aac42acfeee05dc6e0683b1a9f81aabbc66c58c7f1cb6ad0547b1aa5  adapters/tartanground/metadata/source_manifest.json
+8dc66b506fdd7f5a2f093e32ed90c9c203b5884c301f9be2afe83831e2862f8a  adapters/tartanground/reencoding_script.md
+cce8650483e0e6b80ff5872ce954d1e4db639a6a6bdfb0dacfe9fa003818aafc  blender_indoor/README.md
+8a61d8ea13c49e66394810776f982ae5918e43ecd9c5482796801a1355a551bb  blender_indoor/metadata/frame_id_mapping.csv
+6d851b67947c8e9d2992b4fbb935db4b6cebab7ce917b0e03242d8f6e3e94c4d  blender_indoor/metadata/frame_manifest.csv
+58f2ee4949e5def251babc54f39bf9ee170d482a116d0a337993726f7b565c92  blender_indoor/metadata/scene_id_mapping.csv
+c44fabb3932d6067704825d9af59ccf633c5129bffad9fd8a30ed4720a726ae1  blender_indoor/metadata/source_manifest.json
+072493c9e533554c0faafb1d3ba766365152f6c5084e2837d29f4d5279c76ab6  blender_indoor/metadata/splits.json
+2c14d7ac4ef207357073eabef1bc7f65853ab248237550a5542a59ba677f8ade  code/LICENSE
+b8bba6d5adc75decd73c4da0723b60c2678bb94985ba07085b08dc391faa0e35  code/README.md
+efb670c7a9eef10060a1d50f36be3670402e20716f1c01d7ed70964ae1879e14  code/README_REPRODUCE.md
+a195a9cdf86c7c2d23d5259fa0cb3cc75dd327411be3b3f5d78f227f36ad4a8c  code/configs/base_erpt.yaml
+0086890995745e230a23ef766795af44e5cd633f792d9e9386594d6b1a339586  code/configs/blender_indoor.yaml
+3147f7c85a712e6f02f17330640ecb8c6bda0ff5b9994f22e90f95a53633adfb  code/configs/blender_outdoor.yaml
+4e03f04feaee0a3d0d355e6a260c93d0d0ecd44e3b58b7ee6c23a710fcefcfd9  code/configs/default.yaml
+93ddb9458d7caaa9898df553a1a9f756b5fca0cdc6514edff226b13176c0577e  code/configs/hm3d.yaml
+00cd245e4e590b8f7f649cfa87170099d758c0f166970755270b2f752a478666  code/configs/scannetpp.yaml
+f41e12d62f7dc5f0fa6259d8d35dfc8ea20f2fdd94e1bed3dcbbe07ae856dd48  code/configs/tiny.yaml
+9b3d00ec613ce18b4eeadbc9af0053251e074c61e8937062d79442fe9282b48f  code/core/__init__.py
+3fad91fe28ebd11a98178179622a2cee9ad2dfb0f057ae62eae5f3821f0e985e  code/core/coordinate.py
+06b214daacd64b0de9747abc2d50d0318ac7ce122f315d48c5e05d891a78d221  code/core/depth_estimation.py
+31fbacffa8b2b0aa40eddfea6d7ba53c28137d9ee6ad91298771f66c98e8cf73  code/core/depth_fusion.py
+ee596d36829271f164a4e1d6a297aaa42ef8eaaa0339d3b4b14f3b9089b084c7  code/core/erp_projection.py
+f714d3d887b142cb63f0c1fc23dde0949b1e179330964edb6216bc06d5d318ab  code/core/erp_warp.py
+a8a1ba38ffde69fd0c07f653fc388dc9fc53eb5aa2b95a3ed58d54848714e03e  code/core/tangent_extraction.py
+21e7c6c68fd31d5c63f6cb9f949e38adf78a5660f83650481afccc418b9390ab  code/data/README.md
+e5261ad1221380fad1174aeb931355679f419f8bfa8266f3bff06d9b2b917f75  code/dataset_metadata/croissant.json
+c9e7127fc7c6de554516ee219e8aeaa2fca1b00951099d973c7e8af8db32ea95  code/environment.yml
+4b6766691ae074a066ed06919cc372a2849b435e372e6a24849154d0b09c1195  code/examples/metadata/candidates.jsonl
+71c290335857fd7b4a53e507bc94fa6e6c20d1fbdc768fed0e9de20e11229e65  code/examples/tiny_blender_scene/README.md
+ae204fa937a7a427e8bc06fe204ecc16e26eba191a0187b98e6ed20e0a9d7ace  code/metadata_examples/candidates.schema.json
+6839cf7fd0bf08de9006ae76b007843fd6ceb997a83a7e632b0b051f903ce789  code/metadata_examples/per_step_log.schema.json
+23832a8e7d3b0b7e52d0beb7d71f45c210b558d336f7e48bf6b81fbb3a1d8388  code/metadata_examples/selected_viewpoints.schema.json
+bddf800be3a0e5046fdf8a5435733d19199e16d63df25a2ba62de9c1c50f46ba  code/pipelines/get_blend_bounds.py
+4de927c2825256599466766e323d3530eb10b55ea9b618953660bbff9b8ee4d1  code/pipelines/render_erp_blender.py
+7313dc7cd2fb4a03b9fdfe19503511ac7551a2c231a2e83f66b02fcbdcd55798  code/pipelines/run_blend_pipeline.py
+eff64bfb9b1a5d8fa4add9fa7e006b750c3c029220c9ea3cb2e39f735c92a9a6  code/pipelines/run_full_pipeline.py
+1008e53f357b0cb3126139b682ceede7d329b6e3dfa2f178b4cf62d7eda591f9  code/pipelines/run_hm3d_pipeline.py
+0e72c1081ff0f541a552731d7e86eda3380f652e8866f6bb612f64ba8c57cd5b  code/pipelines/run_pipeline.py
+8c03c3f667f9ee1466d1c183359bf9a4d182473675d07515f8dfcbecfca39928  code/pipelines/run_ply_pipeline.py
+b853a2be65e05a38435cadda54c29926a5c8d6c9a96b68752478a24bda42ca76  code/requirements.txt
+72dbcd63d46db055eaf12d5afc7a5bdd402833ef03c886db570d47fde476efdf  code/results/README.md
+dd7ed0dc4e17143b0cb2be9269035cc67a6f0d2292992426d4362091143c14f3  code/scripts/_common.py
+3c41a31d1723ce8bcba2a619ee79ee986ddb51e368664c073b97359feda45b48  code/scripts/audit_quality.py
+d6fbe64e1cf56d7e3d487e108207e47797cbc1e17b2063786b965674e4d831fa  code/scripts/build_candidates.py
+9c7cff2bbfaaf0bb52d8ed9b604f3a7167885d1e514a3ab6469f3909f5d1a7e5  code/scripts/check_anonymity.sh
+d52befd9b56357de17dbe33ef840a352d6152695319a9446dc5c71bfca6d70f6  code/scripts/evaluate_coverage.py
+bd2c6c8fb8869ca34608254c2719b9484a9817628e82e3802b0d4efd13d5c568  code/scripts/evaluate_oracle_gap.py
+21adb3f4cde65b77387873555f16df4a8b260bc0901bc555a2eab9b7db85930c  code/scripts/render_selected.py
+e9392972fb7937bc42c493cb18b96bba4f5bf2cad207e07bf30750083e9bd710  code/scripts/run_blender_indoor.sh
+54f6a5af30881ac32f867a8d22437c999f390871cb162319d79e77e2d96b1e4f  code/scripts/run_tiny.sh
+00c330c04a8ca40e30251efccda7e716ae3a8876056a5688d34279c0fb02029f  code/scripts/select_views.py
+90a20ddfd55c434dd9df4496dd757f00ccfd18f76c24affd6b3fe67e466df1a3  code/scripts/selection_metrics.py
+8ce9e1d8d99ab19b899eae3abfcd345cfb2405ede6541db97884526a3e8173c6  code/scripts/summarize_blender_indoor_run.py
+a03153d20d38fb6805aaa980b659c1964d312f209605fbdbd692ef3b3db44232  code/scripts/summarize_quality_audit.py
+e4cfbffc9ce620f47f977aa6a4cc78f546125ac33189948f5da8a41ac3bf5690  code/third_party/README.md
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  code/tools/__init__.py
+043e8fc09641621a207543857f621195b9365e2da9ce9d8f6cfd6517cdcd99d9  code/tools/make_sha256sums.sh
+1f28cb01c320379ce4138842f848fdcae2db224b805942d0e17c20d132c74609  code/tools/navmesh_utils.py
+08dc49bc2f8bf272274625235f7a9eeec99f94bb3e011778731cc87f28157552  code/tools/semantic_utils.py
+80b87f28df042b2789fd650aec2bbf97a29b6d3a20bb2b13b7dba3c64ec8e06a  code/tools/update_croissant_with_real_hashes.py
+e5261ad1221380fad1174aeb931355679f419f8bfa8266f3bff06d9b2b917f75  croissant.json
+776469105fec88931d5d91239f98b31284e7e090beaf8a8bd7f4aa2e03728594  results/README.md
+df494f4c0a6fc76d9180310286f839e6c4631c009b0244ea192eb552b186c50f  results/audit_50_frames.csv
+04d0f1d19756fb279564a4d5ba0e571f2cab8518a50cce4860d292065bfa64c2  results/coverage_main.csv
+3815d5acdfb0b7a9aa5566d09820878580c5f93ac3aedfc689efff67c8f6d760  results/cross_source.csv
+37ada0e9beb0ca623452a745caf6032eb03d71507e900579b13d420d14bcd702  results/frame_quality.csv
+40a4f28a3208e8db3e85e38821bb171c6e9d6e073746dde85176a8576760196b  results/lambda_sweep.csv
+ae7fcb6f12fd22cc527242749809781929f10836bf4951cb9be16d0f5a5f0048  results/oracle_validation.csv

TODO.md

@@ -0,0 +1,83 @@
+# TODO — before pushing this directory to Hugging Face
+
+This is the list of items still in flight. Some require running the §5 evaluation experiments; others require human review (50-frame audit) or upstream license confirmation. The directory is **internally consistent and self-verifying** today; what's missing is filled-in experiment results and the actual Hugging Face push.
+
+Estimated time-to-push: **~1–2 weeks** assuming §5 experiments are running in parallel.
+
+---
+
+## Blocking — must be done before push
+
+- [ ] **Reconcile paper numbers vs. data drop.** Paper §4.3 Table 4 says `Blender indoor: 326 scenes / 11,583 frames`. v1.0 here stages **374 / 13,631** (round1+2 + round2 union, no de-dup). Three options:
+  - (a) Update paper to `374 / 13,631` and label this version "raw, pre-curator". → simplest.
+  - (b) Run the curator on the 374-scene set so the final selection lands at exactly 11,583 over 326 (matches paper). → requires §5 to converge first.
+  - (c) Keep paper as is and ship v1.0 alongside the curator-selected v1.1; explicitly document the relationship.
+- [ ] **`croissant.json`: align numbers and fill real hashes.**
+  - Update `description` field: `11,583 ERP RGB-depth-pose frames over 326 Blender indoor scenes` → match whichever count is on the paper.
+  - Replace every `"sha256": "TODO_SHA256"` with the actual SHA-256 of the packaged tar (or per-file equivalent if uploading individual files via HF LFS).
+  - Replace every `https://anonymous.4open.science/r/cmevs-XXXX/...` `contentUrl` with the real Hugging Face dataset URL (resolved to LFS, e.g. `https://huggingface.co/datasets/<user>/cmevs-erp-eval/resolve/main/...`).
+  - Re-validate with `mlcroissant`: `python -c "from mlcroissant import Dataset; Dataset(jsonld='croissant.json')"`.
+- [ ] **§5 experiment result CSVs.** Drop into `results/`:
+  - `coverage_main.csv` (§5.1 Random / Uniform / FPS / coverage-only / conflict-aware × K=8/16/32)
+  - `oracle_validation.csv` (§5.2 30-unit pre-render-all vs. warping oracle: gain corr, top-1 agreement, ε̄, GPU-h, speedup)
+  - `lambda_sweep.csv` (§5.3 λ ∈ {0, 0.05, 0.1, 0.2, 0.35, 0.5, 0.75, 1.0})
+  - `cross_source.csv` (§5.4 Blender / HM3D / ScanNet++ at K=30; ≥5 units per source for std/SE)
+  - `audit_50_frames.csv` (Appendix F.2 50-frame manual + vision-model-assisted audit)
+- [ ] **`results/frame_quality.csv` (§4.8).** Run `code/scripts/audit_quality.py` on `blender_indoor/scenes/`; output one row per frame with `{frame_id, source, scene_id, invalid_depth_ratio, under_exposed_ratio, over_exposed_ratio, finite_depth_min, finite_depth_max, finite_depth_p50}`. Append per-source aggregates at the bottom (median invalid-depth ratio target ≈ 1.4% per the paper).
+
+---
+
+## Curator output (depends on §5 running)
+
+- [ ] **Per-scene `meta.json`** under `blender_indoor/scenes/sence_indoor_NNNN/meta.json`. Re-states the world / camera coordinate convention and records the absolute first-frame center for each scene.
+- [ ] **Per-scene `metadata/selected_viewpoints.json`** (curator-selected viewpoints + scores).
+- [ ] **Per-scene `metadata/candidates.jsonl`** (full feasible candidate set + 26-direction validity flags).
+- [ ] **Per-scene `metadata/per_step_log.jsonl`** (per-step `G_t`, `L_t`, `s_t`, runtime).
+- [ ] **`blender_indoor/metadata/frame_manifest.csv`** — fill the curator-only columns: `viewpoint_score`, `coverage_gain`, `conflict_ratio`, `candidate_id`. Currently blank for v1.0.
+
+---
+
+## Adapters — config completion + license confirmation
+
+- [ ] **`adapters/ob3d/config.yaml`** is a placeholder; populate from the real OB3D adapter parameters (cubemap face size, trajectory sampling interval, axis-conversion matrix). Source: paper §3.4 outdoor adapter description.
+- [ ] **`adapters/tartanground/config.yaml`** same as above.
+- [ ] **HM3D / ScanNet++ / TartanGround / OB3D upstream license check.** Default note in `LICENSE.md` is "per upstream"; before pushing, confirm in writing whether **scene-id metadata** (not frames) can be redistributed at all. If any source forbids redistributing scene ids, strip them from `adapters/<source>/metadata/source_manifest.json` and replace with a placeholder + recipe.
+
+---
+
+## Hugging Face push mechanics
+
+- [ ] **Decide repository name** (suggested: `cmevs-erp-eval`) and **visibility** (public vs gated). Anonymous submission requires public read.
+- [ ] **`.gitattributes`** with LFS rules:
+  ```
+  *.png filter=lfs diff=lfs merge=lfs -text
+  *.npy filter=lfs diff=lfs merge=lfs -text
+  *.tar filter=lfs diff=lfs merge=lfs -text
+  *.zip filter=lfs diff=lfs merge=lfs -text
+  ```
+- [ ] **HF repo creation**: `huggingface-cli repo create datasets/<user>/cmevs-erp-eval --type dataset`.
+- [ ] **First push**: `git lfs install && git clone … && rsync -av --exclude=.git /data/.../cmevs_hf_release/ <repo>/ && git add . && git commit && git push`.
+- [ ] **Anonymous review**: ensure HF profile name is anonymized for the double-blind review window.
+- [ ] **Smoke test the URL** in a private browser (no login) — confirm README renders, Croissant button appears, sample data downloads.
+
+---
+
+## Anonymity scan (before push)
+
+- [ ] No absolute filesystem paths from a developer machine appear in any release file (run a recursive search for `/Users/`, `/home/<username>`, `/Volumes/`).
+- [ ] No personal email addresses appear in any release file (recursive search for `@yahoo`, `@gmail`, `@anthropic`, `@<your-domain>`).
+- [ ] No `.DS_Store`, `*.pyc`, `__pycache__/`, or `._*` AppleDouble artifacts remain (run `find ... -name '.DS_Store' -o -name '*.pyc' -o -name '._*'` → 0 results).
+- [ ] All `pose_*.json` strip any author / system metadata accidentally embedded by Cycles.
+- [ ] All `panorama_*.png` EXIF stripped (`exiftool -all= panorama_*.png` if needed).
+- [ ] Any local file paths inside metadata JSON (e.g. `original_frame_path`) are rebased to anonymized labels (round identifiers like `round1+2` / `round2` are fine; full developer-machine absolute paths are not).
+
+---
+
+## Post-push synchronization
+
+- [ ] OpenReview submission form:
+  - `Dataset URL`: HF repo URL
+  - `Croissant File`: upload the `croissant.json` independently (also kept here)
+  - `Code URL`: anonymous mirror of `code/` (separate Anonymous GitHub repo)
+- [ ] `main.tex` §4.7 Table — replace `TODO:ANON_SAMPLE_URL` and `TODO:SHA256_MANIFEST` with the real HF URLs.
+- [ ] `cmevs_anonymous_code_release/dataset_metadata/manifests_h100/README.md` — append a note: "stale post-renaming; superseded by `cmevs_hf_release/blender_indoor/SHA256SUMS`".

adapters/README.md

@@ -0,0 +1,64 @@
+# Adapter packages — license-aware regeneration for restricted sources
+
+The four sources here (HM3D, ScanNet++, OB3D, TartanGround) cannot be redistributed as ERP RGB-D frames under their upstream licenses. Instead, each adapter package contains:
+
+1. A `config.yaml` with all curator / re-encoding parameters used in the paper (resolution, grid spacing, fixed-budget K, thresholds, …).
+2. A `pipeline.py` (curator adapters) or `reencoding_script.md` (outdoor re-encoders) describing exactly which command to run and which input layout it expects.
+3. A `metadata/source_manifest.json` listing the upstream scene / scan / part IDs that the paper's `K=30` evaluation runs over.
+
+Users that want to reproduce the per-source ERP frames acquire the upstream data themselves (after accepting upstream license terms) and run the adapter locally.
+
+## Per-source quick reference
+
+| Source | License gate | Adapter type | Scene count |
+| --- | --- | --- | --- |
+| **HM3D** | Matterport / HM3D EULA | curator (NavMesh-based room proposal → CM-EVS greedy) | 401 rooms |
+| **ScanNet++** | ScanNet++ ToS | curator (mesh / point-cloud modes) | 500 scans |
+| **OB3D** | per upstream | re-encoding (cubemap → ERP, pose unification) | 24 instances (12 scenes × 2 viewpoints) |
+| **TartanGround** | per upstream (typically CC-BY-NC-SA) | re-encoding (cubemap → ERP, pose unification) | 762 parts (~11 environments) |
+
+## Curator adapters (HM3D, ScanNet++)
+
+These plug into the standard CM-EVS pipeline:
+
+```
+scene asset → adapter (load + normalize + propose candidates) → curator greedy selection →
+high-res Cycles ERP render → unified output schema
+```
+
+The adapter handles three things specific to that source:
+
+- **Asset loading** (HM3D: `.glb`; ScanNet++: `.ply` point cloud or mesh).
+- **Candidate proposal** (HM3D: NavMesh / cluster / label-based; ScanNet++: mesh / point-cloud sampling).
+- **Source-specific failure modes** (e.g. ScanNet++ point-cloud mode degrades surface tests to `AABB + splat Z-buffer`).
+
+To run an adapter:
+
+```bash
+cd ../code
+python pipelines/run_hm3d_pipeline.py     --config ../adapters/hm3d/config.yaml
+# or
+python pipelines/run_ply_pipeline.py      --config ../adapters/scannetpp/config.yaml
+```
+
+Both adapters write to `outputs/<source>/<scene_id>/{rgb,depth,pose,metadata}/...` under the same schema as `blender_indoor/scenes/`.
+
+## Re-encoding adapters (OB3D, TartanGround)
+
+These do **not** run the curator. Their job is to take dense RGB-D-pose trajectories already shipped by the upstream source and re-express them in CM-EVS's unified ERP + world-to-camera pose convention:
+
+- Cubemap → ERP at the source's native resolution.
+- Pose re-expressed in right-handed `+Y`-up world frame with scalar-first `q_wc`.
+- The full re-encoded trajectory is released — outdoor frames are **not** curator-selected subsets and therefore do not carry per-step provenance logs (`per_step_log.jsonl`).
+
+The `reencoding_script.md` inside each package documents the exact command, expected upstream layout, and output schema.
+
+## Source-id metadata
+
+`metadata/source_manifest.json` in each adapter package lists the upstream IDs that the paper's reported numbers are computed over. If you need to reproduce the **exact** numbers in §5.4 (cross-source) or §4.10 (downstream), use only these IDs.
+
+> **Caveat**: depending on each upstream license, simply listing scene IDs may itself be restricted. Before redistributing or quoting these manifests verbatim, check the upstream's terms. See `../LICENSE.md`.
+
+## Anonymous review note
+
+For NeurIPS double-blind review, no upstream credentials are required to inspect this directory: the adapters list IDs and parameters, but no upstream data ships here. To **execute** an adapter, the reviewer must independently obtain the upstream dataset.

adapters/hm3d/README.md

@@ -0,0 +1,43 @@
+# HM3D adapter — CM-EVS
+
+This package regenerates the HM3D portion of CM-EVS (401 rooms; paper reports 14,475 frames after local regeneration). **No HM3D-derived RGB-D frames are redistributed here**; users must independently accept the [HM3D EULA](https://aihabitat.org/datasets/hm3d/) and obtain the source data.
+
+## Files
+
+- `config.yaml` — curator parameters (input source, output root, resolution, grid spacing, K, conflict weight λ, early-stop thresholds, etc.). Same values as used in the paper.
+- `pipeline.py` — adapter entry point (CM-EVS curator + HM3D-specific NavMesh / cluster / label-based room proposal).
+- `metadata/source_manifest.json` — list of 401 HM3D scene IDs the paper's evaluation runs over.
+
+## Reproducing the paper's HM3D frames
+
+1. Obtain HM3D from <https://aihabitat.org/datasets/hm3d/> after accepting the EULA.
+2. Place HM3D `.glb` files under `data/hm3d/<scene_id>/<scene_id>.glb` (matching `config.yaml`'s `pipeline.input_dir`).
+3. Install the curator code from `../../code/`:
+   ```bash
+   conda env create -f ../../code/environment.yml
+   conda activate cmevs
+   ```
+4. Run the pipeline:
+   ```bash
+   cd ../../code
+   python pipelines/run_hm3d_pipeline.py --config ../adapters/hm3d/config.yaml
+   ```
+5. Outputs land in `outputs/hm3d/<scene_id>/{rgb, depth, pose, metadata}/...` under the unified CM-EVS schema (see `../../blender_indoor/README.md` for the schema).
+
+The 401-room evaluation set is determined by `metadata/source_manifest.json`; the paper's reported HM3D numbers (§4.3 Table 4 and §5.4) are reproduced by running this exact set with the shipped config.
+
+## What the adapter does
+
+HM3D scenes contain multiple rooms in a single mesh, which would unfairly weight the curator toward whichever room dominates the AABB. This adapter solves it by:
+
+1. **Space-unit proposal** (before the standard Phase 1): NavMesh / cluster / room-label segmentation of the HM3D scene into per-room "space units"; each unit is curated independently.
+2. **Per-room Gini reporting** for transparency on frame allocation across rooms.
+3. **Standard Phase 1–2** (candidate grid + 26-direction filter + conflict-aware greedy) is then applied per space unit.
+
+See paper §3.4 (Table 2 row "HM3D") and `pipeline.py` for details.
+
+## License
+
+- This adapter code: **MIT** (see top-level `LICENSE.md`).
+- HM3D-derived metadata (scene IDs, candidate metadata): bound by the **HM3D EULA**.
+- Frames you produce by running this adapter on HM3D source data: bound by the HM3D EULA. The MIT license on the adapter does **not** override upstream terms for those frames.

adapters/hm3d/config.yaml

@@ -0,0 +1,17 @@
+experiment:
+  source: hm3d
+  input_kind: glb
+
+pipeline:
+  blender: /path/to/blender
+  input_dir: data/hm3d
+  output_root: outputs/hm3d
+  num_frames: 30
+  resolution: "2048,1024"
+  grid_spacing: 0.5
+  camera_height: null
+  min_frames: 5
+  stop_gain: 0.08
+  stop_score: -0.3
+  stop_delta: 0.08
+

adapters/hm3d/metadata/source_manifest.json

@@ -0,0 +1,412 @@
+{
+  "source": "hm3d",
+  "label": "HM3D",
+  "description": "401 HM3D rooms used by the CM-EVS curator. Each entry maps to a NavMesh / cluster / label-derived space-unit.",
+  "license": "MIT (code) + Matterport / HM3D EULA (metadata)",
+  "release_policy": "no derived RGB-D frames redistributed; users regenerate locally",
+  "id_field": "room_id",
+  "id_count": 401,
+  "ids": [
+    "00000-kfPV7w3FaU5+space_01",
+    "00000-kfPV7w3FaU5+space_04",
+    "00000-kfPV7w3FaU5+space_05",
+    "00000-kfPV7w3FaU5+space_10",
+    "00000-kfPV7w3FaU5+space_12",
+    "00001-UVdNNRcVyV1+space_12",
+    "00001-UVdNNRcVyV1+space_17",
+    "00001-UVdNNRcVyV1+space_19",
+    "00001-UVdNNRcVyV1+space_24",
+    "00001-UVdNNRcVyV1+space_28",
+    "00001-UVdNNRcVyV1+space_36",
+    "00001-UVdNNRcVyV1+space_38",
+    "00003-NtVbfPCkBFy+space_01",
+    "00003-NtVbfPCkBFy+space_02",
+    "00003-NtVbfPCkBFy+space_18",
+    "00003-NtVbfPCkBFy+space_29",
+    "00003-NtVbfPCkBFy+space_35",
+    "00003-NtVbfPCkBFy+space_41",
+    "00003-NtVbfPCkBFy+space_42",
+    "00003-NtVbfPCkBFy+space_53",
+    "00003-NtVbfPCkBFy+space_58",
+    "00003-NtVbfPCkBFy+space_59",
+    "00004-VqCaAuuoeWk+space_00",
+    "00004-VqCaAuuoeWk+space_01",
+    "00004-VqCaAuuoeWk+space_12",
+    "00004-VqCaAuuoeWk+space_15",
+    "00006-HkseAnWCgqk+space_03",
+    "00006-HkseAnWCgqk+space_06",
+    "00006-HkseAnWCgqk+space_07",
+    "00006-HkseAnWCgqk+space_12",
+    "00006-HkseAnWCgqk+space_13",
+    "00006-HkseAnWCgqk+space_18",
+    "00007-UQuchpekHRJ+space_05",
+    "00007-UQuchpekHRJ+space_08",
+    "00007-UQuchpekHRJ+space_09",
+    "00007-UQuchpekHRJ+space_11",
+    "00008-VYnUX657cVo+space_00",
+    "00008-VYnUX657cVo+space_02",
+    "00008-VYnUX657cVo+space_05",
+    "00008-VYnUX657cVo+space_08",
+    "00008-VYnUX657cVo+space_09",
+    "00008-VYnUX657cVo+space_12",
+    "00008-VYnUX657cVo+space_28",
+    "00008-VYnUX657cVo+space_31",
+    "00008-VYnUX657cVo+space_32",
+    "00008-VYnUX657cVo+space_34",
+    "00008-VYnUX657cVo+space_39",
+    "00008-VYnUX657cVo+space_40",
+    "00008-VYnUX657cVo+space_41",
+    "00008-VYnUX657cVo+space_42",
+    "00009-vLpv2VX547B+space_08",
+    "00009-vLpv2VX547B+space_10",
+    "00009-vLpv2VX547B+space_11",
+    "00009-vLpv2VX547B+space_14",
+    "00009-vLpv2VX547B+space_18",
+    "00009-vLpv2VX547B+space_21",
+    "00009-vLpv2VX547B+space_26",
+    "00009-vLpv2VX547B+space_28",
+    "00010-DBjEcHFg4oq+space_00",
+    "00011-1W61QJVDBqe+space_03",
+    "00011-1W61QJVDBqe+space_05",
+    "00011-1W61QJVDBqe+space_06",
+    "00011-1W61QJVDBqe+space_07",
+    "00011-1W61QJVDBqe+space_11",
+    "00011-1W61QJVDBqe+space_12",
+    "00011-1W61QJVDBqe+space_13",
+    "00011-1W61QJVDBqe+space_26",
+    "00011-1W61QJVDBqe+space_27",
+    "00011-1W61QJVDBqe+space_29",
+    "00011-1W61QJVDBqe+space_30",
+    "00011-1W61QJVDBqe+space_31",
+    "00011-1W61QJVDBqe+space_32",
+    "00011-1W61QJVDBqe+space_33",
+    "00011-1W61QJVDBqe+space_34",
+    "00011-1W61QJVDBqe+space_36",
+    "00011-1W61QJVDBqe+space_37",
+    "00011-1W61QJVDBqe+space_38",
+    "00011-1W61QJVDBqe+space_42",
+    "00011-1W61QJVDBqe+space_43",
+    "00011-1W61QJVDBqe+space_44",
+    "00011-1W61QJVDBqe+space_45",
+    "00011-1W61QJVDBqe+space_46",
+    "00012-kDgLKdMd5X8+space_03",
+    "00012-kDgLKdMd5X8+space_09",
+    "00012-kDgLKdMd5X8+space_25",
+    "00012-kDgLKdMd5X8+space_28",
+    "00013-sfbj7jspYWj+space_05",
+    "00013-sfbj7jspYWj+space_06",
+    "00013-sfbj7jspYWj+space_13",
+    "00013-sfbj7jspYWj+space_14",
+    "00013-sfbj7jspYWj+space_15",
+    "00013-sfbj7jspYWj+space_16",
+    "00013-sfbj7jspYWj+space_17",
+    "00014-nYYcLpSzihC+space_03",
+    "00014-nYYcLpSzihC+space_09",
+    "00014-nYYcLpSzihC+space_10",
+    "00014-nYYcLpSzihC+space_11",
+    "00014-nYYcLpSzihC+space_29",
+    "00014-nYYcLpSzihC+space_30",
+    "00014-nYYcLpSzihC+space_31",
+    "00014-nYYcLpSzihC+space_32",
+    "00014-nYYcLpSzihC+space_33",
+    "00014-nYYcLpSzihC+space_34",
+    "00014-nYYcLpSzihC+space_35",
+    "00014-nYYcLpSzihC+space_36",
+    "00014-nYYcLpSzihC+space_37",
+    "00014-nYYcLpSzihC+space_40",
+    "00014-nYYcLpSzihC+space_41",
+    "00014-nYYcLpSzihC+space_70",
+    "00014-nYYcLpSzihC+space_71",
+    "00014-nYYcLpSzihC+space_72",
+    "00014-nYYcLpSzihC+space_73",
+    "00015-LPwS1aEGXBb+space_00",
+    "00015-LPwS1aEGXBb+space_01",
+    "00015-LPwS1aEGXBb+space_05",
+    "00015-LPwS1aEGXBb+space_16",
+    "00015-LPwS1aEGXBb+space_17",
+    "00015-LPwS1aEGXBb+space_27",
+    "00015-LPwS1aEGXBb+space_30",
+    "00015-LPwS1aEGXBb+space_31",
+    "00015-LPwS1aEGXBb+space_32",
+    "00015-LPwS1aEGXBb+space_33",
+    "00015-LPwS1aEGXBb+space_34",
+    "00015-LPwS1aEGXBb+space_36",
+    "00015-LPwS1aEGXBb+space_37",
+    "00015-LPwS1aEGXBb+space_38",
+    "00015-LPwS1aEGXBb+space_39",
+    "00015-LPwS1aEGXBb+space_43",
+    "00016-qk9eeNeR4vw+space_09",
+    "00016-qk9eeNeR4vw+space_23",
+    "00016-qk9eeNeR4vw+space_25",
+    "00017-oEPjPNSPmzL+space_03",
+    "00017-oEPjPNSPmzL+space_07",
+    "00018-as8Y8AYx6yW+space_00",
+    "00018-as8Y8AYx6yW+space_10",
+    "00018-as8Y8AYx6yW+space_11",
+    "00018-as8Y8AYx6yW+space_12",
+    "00018-as8Y8AYx6yW+space_13",
+    "00018-as8Y8AYx6yW+space_14",
+    "00018-as8Y8AYx6yW+space_17",
+    "00018-as8Y8AYx6yW+space_18",
+    "00018-as8Y8AYx6yW+space_20",
+    "00018-as8Y8AYx6yW+space_21",
+    "00018-as8Y8AYx6yW+space_23",
+    "00018-as8Y8AYx6yW+space_24",
+    "00018-as8Y8AYx6yW+space_25",
+    "00018-as8Y8AYx6yW+space_26",
+    "00018-as8Y8AYx6yW+space_27",
+    "00018-as8Y8AYx6yW+space_28",
+    "00018-as8Y8AYx6yW+space_29",
+    "00018-as8Y8AYx6yW+space_34",
+    "00018-as8Y8AYx6yW+space_35",
+    "00018-as8Y8AYx6yW+space_36",
+    "00018-as8Y8AYx6yW+space_38",
+    "00018-as8Y8AYx6yW+space_46",
+    "00018-as8Y8AYx6yW+space_48",
+    "00018-as8Y8AYx6yW+space_51",
+    "00018-as8Y8AYx6yW+space_53",
+    "00018-as8Y8AYx6yW+space_55",
+    "00018-as8Y8AYx6yW+space_56",
+    "00018-as8Y8AYx6yW+space_57",
+    "00018-as8Y8AYx6yW+space_58",
+    "00019-AfKhsVmG8L4+space_02",
+    "00019-AfKhsVmG8L4+space_03",
+    "00019-AfKhsVmG8L4+space_05",
+    "00019-AfKhsVmG8L4+space_11",
+    "00019-AfKhsVmG8L4+space_12",
+    "00019-AfKhsVmG8L4+space_14",
+    "00020-XYyR54sxe6b+space_00",
+    "00020-XYyR54sxe6b+space_02",
+    "00020-XYyR54sxe6b+space_03",
+    "00021-yQESfVcg18k+space_01",
+    "00021-yQESfVcg18k+space_02",
+    "00021-yQESfVcg18k+space_07",
+    "00021-yQESfVcg18k+space_09",
+    "00021-yQESfVcg18k+space_10",
+    "00021-yQESfVcg18k+space_21",
+    "00021-yQESfVcg18k+space_25",
+    "00021-yQESfVcg18k+space_26",
+    "00021-yQESfVcg18k+space_27",
+    "00021-yQESfVcg18k+space_30",
+    "00021-yQESfVcg18k+space_31",
+    "00021-yQESfVcg18k+space_32",
+    "00021-yQESfVcg18k+space_36",
+    "00021-yQESfVcg18k+space_38",
+    "00021-yQESfVcg18k+space_39",
+    "00021-yQESfVcg18k+space_43",
+    "00021-yQESfVcg18k+space_44",
+    "00021-yQESfVcg18k+space_50",
+    "00021-yQESfVcg18k+space_53",
+    "00021-yQESfVcg18k+space_55",
+    "00022-gmuS7Wgsbrx+space_02",
+    "00022-gmuS7Wgsbrx+space_06",
+    "00022-gmuS7Wgsbrx+space_07",
+    "00022-gmuS7Wgsbrx+space_08",
+    "00022-gmuS7Wgsbrx+space_23",
+    "00022-gmuS7Wgsbrx+space_24",
+    "00022-gmuS7Wgsbrx+space_25",
+    "00022-gmuS7Wgsbrx+space_26",
+    "00022-gmuS7Wgsbrx+space_27",
+    "00022-gmuS7Wgsbrx+space_29",
+    "00022-gmuS7Wgsbrx+space_30",
+    "00022-gmuS7Wgsbrx+space_37",
+    "00022-gmuS7Wgsbrx+space_64",
+    "00022-gmuS7Wgsbrx+space_65",
+    "00024-XNoaAZwsWKk+space_09",
+    "00024-XNoaAZwsWKk+space_11",
+    "00024-XNoaAZwsWKk+space_12",
+    "00024-XNoaAZwsWKk+space_15",
+    "00025-ixTj1aTMup2+space_03",
+    "00025-ixTj1aTMup2+space_05",
+    "00025-ixTj1aTMup2+space_09",
+    "00025-ixTj1aTMup2+space_10",
+    "00025-ixTj1aTMup2+space_12",
+    "00025-ixTj1aTMup2+space_13",
+    "00025-ixTj1aTMup2+space_24",
+    "00025-ixTj1aTMup2+space_27",
+    "00025-ixTj1aTMup2+space_28",
+    "00025-ixTj1aTMup2+space_31",
+    "00026-tzaZQQmUVXZ+space_14",
+    "00027-cVppJowrUqs+space_00",
+    "00027-cVppJowrUqs+space_06",
+    "00027-cVppJowrUqs+space_07",
+    "00027-cVppJowrUqs+space_14",
+    "00028-xGnehmjiCSA+space_08",
+    "00028-xGnehmjiCSA+space_10",
+    "00028-xGnehmjiCSA+space_19",
+    "00029-4wCTuaUNWEd+space_06",
+    "00029-4wCTuaUNWEd+space_07",
+    "00029-4wCTuaUNWEd+space_18",
+    "00029-4wCTuaUNWEd+space_20",
+    "00029-4wCTuaUNWEd+space_25",
+    "00031-Wo6kuutE9i7+space_00",
+    "00031-Wo6kuutE9i7+space_01",
+    "00032-jTTGECZYKRA+space_09",
+    "00032-jTTGECZYKRA+space_11",
+    "00032-jTTGECZYKRA+space_15",
+    "00032-jTTGECZYKRA+space_17",
+    "00032-jTTGECZYKRA+space_19",
+    "00032-jTTGECZYKRA+space_20",
+    "00032-jTTGECZYKRA+space_21",
+    "00032-jTTGECZYKRA+space_22",
+    "00032-jTTGECZYKRA+space_23",
+    "00032-jTTGECZYKRA+space_24",
+    "00032-jTTGECZYKRA+space_26",
+    "00032-jTTGECZYKRA+space_27",
+    "00032-jTTGECZYKRA+space_36",
+    "00032-jTTGECZYKRA+space_37",
+    "00033-oPj9qMxrDEa+space_05",
+    "00033-oPj9qMxrDEa+space_06",
+    "00033-oPj9qMxrDEa+space_11",
+    "00033-oPj9qMxrDEa+space_12",
+    "00033-oPj9qMxrDEa+space_13",
+    "00034-6imZUJGRUq4+space_01",
+    "00034-6imZUJGRUq4+space_03",
+    "00034-6imZUJGRUq4+space_04",
+    "00034-6imZUJGRUq4+space_05",
+    "00034-6imZUJGRUq4+space_06",
+    "00034-6imZUJGRUq4+space_08",
+    "00034-6imZUJGRUq4+space_10",
+    "00034-6imZUJGRUq4+space_23",
+    "00034-6imZUJGRUq4+space_24",
+    "00034-6imZUJGRUq4+space_25",
+    "00034-6imZUJGRUq4+space_26",
+    "00034-6imZUJGRUq4+space_30",
+    "00034-6imZUJGRUq4+space_31",
+    "00034-6imZUJGRUq4+space_41",
+    "00035-3XYAD64HpDr+space_00",
+    "00035-3XYAD64HpDr+space_01",
+    "00035-3XYAD64HpDr+space_02",
+    "00035-3XYAD64HpDr+space_05",
+    "00035-3XYAD64HpDr+space_07",
+    "00035-3XYAD64HpDr+space_08",
+    "00035-3XYAD64HpDr+space_10",
+    "00035-3XYAD64HpDr+space_11",
+    "00036-41FNXLAZZgC+space_01",
+    "00036-41FNXLAZZgC+space_06",
+    "00036-41FNXLAZZgC+space_09",
+    "00037-oKFJo8jpzRW+space_02",
+    "00037-oKFJo8jpzRW+space_03",
+    "00037-oKFJo8jpzRW+space_20",
+    "00037-oKFJo8jpzRW+space_21",
+    "00038-aJg466zMSNt+space_01",
+    "00038-aJg466zMSNt+space_02",
+    "00038-aJg466zMSNt+space_05",
+    "00038-aJg466zMSNt+space_08",
+    "00038-aJg466zMSNt+space_11",
+    "00038-aJg466zMSNt+space_12",
+    "00038-aJg466zMSNt+space_21",
+    "00038-aJg466zMSNt+space_22",
+    "00039-ANmWrL7Kz7h+space_00",
+    "00039-ANmWrL7Kz7h+space_01",
+    "00039-ANmWrL7Kz7h+space_02",
+    "00039-ANmWrL7Kz7h+space_03",
+    "00039-ANmWrL7Kz7h+space_04",
+    "00039-ANmWrL7Kz7h+space_06",
+    "00039-ANmWrL7Kz7h+space_07",
+    "00039-ANmWrL7Kz7h+space_10",
+    "00039-ANmWrL7Kz7h+space_13",
+    "00039-ANmWrL7Kz7h+space_14",
+    "00039-ANmWrL7Kz7h+space_17",
+    "00039-ANmWrL7Kz7h+space_19",
+    "00039-ANmWrL7Kz7h+space_21",
+    "00039-ANmWrL7Kz7h+space_23",
+    "00039-ANmWrL7Kz7h+space_33",
+    "00039-ANmWrL7Kz7h+space_35",
+    "00039-ANmWrL7Kz7h+space_36",
+    "00040-ZB8o8rMmPdB+space_03",
+    "00040-ZB8o8rMmPdB+space_04",
+    "00040-ZB8o8rMmPdB+space_07",
+    "00040-ZB8o8rMmPdB+space_10",
+    "00040-ZB8o8rMmPdB+space_12",
+    "00040-ZB8o8rMmPdB+space_15",
+    "00040-ZB8o8rMmPdB+space_16",
+    "00040-ZB8o8rMmPdB+space_19",
+    "00040-ZB8o8rMmPdB+space_20",
+    "00040-ZB8o8rMmPdB+space_37",
+    "00040-ZB8o8rMmPdB+space_38",
+    "00040-ZB8o8rMmPdB+space_39",
+    "00040-ZB8o8rMmPdB+space_48",
+    "00041-QKfBMSSy7Hy+space_01",
+    "00041-QKfBMSSy7Hy+space_02",
+    "00041-QKfBMSSy7Hy+space_11",
+    "00041-QKfBMSSy7Hy+space_16",
+    "00041-QKfBMSSy7Hy+space_24",
+    "00041-QKfBMSSy7Hy+space_26",
+    "00041-QKfBMSSy7Hy+space_27",
+    "00041-QKfBMSSy7Hy+space_29",
+    "00042-qDjhFcNqFPi+space_00",
+    "00042-qDjhFcNqFPi+space_16",
+    "00043-Jfyvj3xn2aJ+space_04",
+    "00043-Jfyvj3xn2aJ+space_06",
+    "00046-UQ5EhY5wve1+space_23",
+    "00047-u9LiqMn6kA6+space_01",
+    "00047-u9LiqMn6kA6+space_28",
+    "00053-kAMF2R7PCqX+space_08",
+    "00053-kAMF2R7PCqX+space_13",
+    "00054-6BReaxZUoMg+space_10",
+    "00057-1UnKg1rAb8A+space_02",
+    "00057-1UnKg1rAb8A+space_08",
+    "00060-TgWKHxhJAng+space_07",
+    "00060-TgWKHxhJAng+space_11",
+    "00060-TgWKHxhJAng+space_14",
+    "00060-TgWKHxhJAng+space_45",
+    "00061-duthTPisf28+space_06",
+    "00061-duthTPisf28+space_21",
+    "00061-duthTPisf28+space_25",
+    "00063-KsD3yx9nZCv+space_06",
+    "00063-KsD3yx9nZCv+space_61",
+    "00064-gQgtJ9Stk5s+space_15",
+    "00064-gQgtJ9Stk5s+space_17",
+    "00065-kZhZfAhdnNN+space_00",
+    "00065-kZhZfAhdnNN+space_04",
+    "00065-kZhZfAhdnNN+space_09",
+    "00065-kZhZfAhdnNN+space_13",
+    "00066-nHHVbEyHX3t+space_03",
+    "00066-nHHVbEyHX3t+space_05",
+    "00067-osQy15y8EVT+space_03",
+    "00067-osQy15y8EVT+space_04",
+    "00067-osQy15y8EVT+space_07",
+    "00067-osQy15y8EVT+space_14",
+    "00067-osQy15y8EVT+space_15",
+    "00067-osQy15y8EVT+space_16",
+    "00068-812QqCky3T7+space_20",
+    "00069-Y8Y6ukxGMvn+space_08",
+    "00070-w7QyjJ3H9Bp+space_00",
+    "00070-w7QyjJ3H9Bp+space_07",
+    "00071-GCEb4nmNi7j+space_02",
+    "00071-GCEb4nmNi7j+space_04",
+    "00072-t8wCA6Qe8uT+space_06",
+    "00073-bCFcvb4zc3N+space_17",
+    "00073-bCFcvb4zc3N+space_33",
+    "00073-bCFcvb4zc3N+space_36",
+    "00074-kHvNo8x6Qoe+space_00",
+    "00074-kHvNo8x6Qoe+space_01",
+    "00074-kHvNo8x6Qoe+space_02",
+    "00074-kHvNo8x6Qoe+space_04",
+    "00074-kHvNo8x6Qoe+space_09",
+    "00074-kHvNo8x6Qoe+space_12",
+    "00074-kHvNo8x6Qoe+space_20",
+    "00074-kHvNo8x6Qoe+space_21",
+    "00074-kHvNo8x6Qoe+space_22",
+    "00074-kHvNo8x6Qoe+space_23",
+    "00074-kHvNo8x6Qoe+space_27",
+    "00075-u3zrj4Nojev+space_09",
+    "00075-u3zrj4Nojev+space_25",
+    "00075-u3zrj4Nojev+space_26",
+    "00076-fJ1GEE6PdHD+space_01",
+    "00076-fJ1GEE6PdHD+space_19",
+    "00077-z9VLaZqCsW5+space_07",
+    "00078-nJTPfwbAj4S+space_05",
+    "00078-nJTPfwbAj4S+space_06",
+    "00078-nJTPfwbAj4S+space_39",
+    "00079-2ihrkjrbHVf+space_06",
+    "00079-2ihrkjrbHVf+space_17",
+    "00081-5biL7VEkByM+space_02",
+    "00081-5biL7VEkByM+space_51",
+    "00082-y4YiUQwvWGH+space_17",
+    "00083-16tymPtM7uS+space_09",
+    "00088-z9w4aD7JsiQ+space_00",
+    "00090-C8VQQtzUoqV+space_00"
+  ]
+}

adapters/ob3d/README.md

@@ -0,0 +1,35 @@
+# OB3D adapter — CM-EVS (re-encoding only)
+
+OB3D is an outdoor source. Unlike HM3D / ScanNet++ (which run the full CM-EVS curator), OB3D ships dense pre-rendered cubemap trajectories upstream; this adapter's job is only to **re-encode** those trajectories into CM-EVS's unified ERP + world-to-camera pose schema.
+
+The curator does **not** run on OB3D in v1.0; outdoor frames in the release are full re-encoded source trajectories, not curator-selected subsets, and they do not carry per-step provenance logs.
+
+## Files
+
+- `config.yaml` — re-encoding parameters (input layout, output schema, axis-conversion matrix). Some fields are **placeholders** to be finalized; see `../../TODO.md`.
+- `reencoding_script.md` — exact command + expected upstream layout + output schema.
+- `metadata/source_manifest.json` — list of 24 instances (12 scenes × 2 viewpoints — Egocentric / Non-Egocentric) the paper's evaluation runs over.
+
+## Reproducing the paper's OB3D frames
+
+1. Obtain OB3D source data per its upstream license.
+2. Place under `data/ob3d/<scene_name>-{Egocentric,Non-Egocentric}/...` matching the layout in `reencoding_script.md`.
+3. Run the re-encoder:
+   ```bash
+   cd ../../code
+   python scripts/reencode_outdoor.py --source ob3d --config ../adapters/ob3d/config.yaml
+   ```
+4. Outputs land in `outputs/ob3d/<scene_name>-<viewpoint>/{rgb, depth, pose}/...` under the unified schema (without the `metadata/per_step_log.jsonl` since the curator does not run here).
+
+## What the re-encoding does
+
+- **Cubemap → ERP** at the source's native resolution (1600×800 per paper §4.3 Table 4).
+- **Pose unification**: rewrite original axis convention into the right-handed `+X`-right `+Y`-up `+Z`-forward world frame; pose stored as scalar-first `q_wc = [w, x, y, z]` plus position relative to scene first frame.
+- **Egocentric vs Non-Egocentric** are kept as separate instances since their pose conventions differ; both are emitted under the same scene root.
+
+See paper §3.4 (Table 2 row "OB3D") and §4.3 (Table 4 — outdoor / OB3D row).
+
+## License
+
+- This adapter code: **MIT**.
+- Frames you produce by re-encoding upstream OB3D data are bound by the **upstream OB3D license**. The MIT license on the adapter does **not** override upstream terms.

adapters/ob3d/config.yaml

@@ -0,0 +1,41 @@
+# OB3D outdoor re-encoding adapter — CM-EVS
+#
+# This is a placeholder reflecting paper §3.4 (Table 2 row "OB3D"). Concrete
+# parameters (cubemap face size, axis-conversion matrix) are tracked in TODO.md
+# and will be finalized before HF push.
+
+experiment:
+  source: ob3d
+  input_kind: cubemap_dense_trajectory   # OB3D upstream ships dense cubemap RGB-D-pose
+
+reencoding:
+  # Where upstream OB3D files live (per scene_name × viewpoint).
+  # Layout is documented in reencoding_script.md.
+  input_dir: data/ob3d
+  output_root: outputs/ob3d
+
+  # Source cubemap face size — TODO: confirm against actual OB3D download.
+  cubemap_face_size: TODO          # e.g. 800 (px per face)
+
+  # Final ERP resolution — paper §4.3 Table 4 lists OB3D at 1600×800.
+  erp_resolution: "1600,800"
+
+  # Pose handling.
+  pose_format: world_to_camera_quaternion   # output convention
+  source_axis_convention: TODO              # e.g. "y-down z-forward" — confirm from upstream
+  target_axis_convention: y-up_z-forward    # CM-EVS world frame
+
+  # Depth handling.
+  depth_format: range                       # ERP range depth (radial), not perspective z
+  depth_unit: meters
+  invalid_marker: nan                       # NaN preferred; 0 also accepted
+
+  # Trajectory slicing (none for OB3D — full trajectory released per upstream).
+  trajectory_partition: false
+
+  # Per-scene metadata.
+  emit_meta_json: true                      # per-scene meta.json with coordinate convention
+  emit_per_step_log: false                  # curator does not run on outdoor in v1.0
+
+# Source manifest (which scenes / viewpoints to re-encode):
+# see metadata/source_manifest.json (24 instances = 12 scenes × 2 viewpoints)

adapters/ob3d/metadata/source_manifest.json

@@ -0,0 +1,35 @@
+{
+  "source": "ob3d",
+  "label": "OB3D",
+  "description": "12 outdoor scenes × 2 viewpoints (Egocentric / Non-Egocentric) = 24 instances. Re-encoding adapter only — no curator selection.",
+  "license": "MIT (code) + per upstream OB3D license (metadata + frames)",
+  "release_policy": "frames produced by re-encoding remain under upstream OB3D license",
+  "id_field": "instance_id",
+  "id_count": 24,
+  "ids": [
+    "archiviz-flat-Egocentric",
+    "archiviz-flat-Non-Egocentric",
+    "barbershop-Egocentric",
+    "barbershop-Non-Egocentric",
+    "bistro-Egocentric",
+    "bistro-Non-Egocentric",
+    "classroom-Egocentric",
+    "classroom-Non-Egocentric",
+    "emerald-square-Egocentric",
+    "emerald-square-Non-Egocentric",
+    "fisher-hut-Egocentric",
+    "fisher-hut-Non-Egocentric",
+    "lone-monk-Egocentric",
+    "lone-monk-Non-Egocentric",
+    "pavillion-Egocentric",
+    "pavillion-Non-Egocentric",
+    "restroom-Egocentric",
+    "restroom-Non-Egocentric",
+    "san-miguel-Egocentric",
+    "san-miguel-Non-Egocentric",
+    "sponza-Egocentric",
+    "sponza-Non-Egocentric",
+    "sun-temple-Egocentric",
+    "sun-temple-Non-Egocentric"
+  ]
+}

adapters/ob3d/reencoding_script.md

@@ -0,0 +1,68 @@
+# OB3D Re-encoding — exact procedure
+
+## Upstream layout (input)
+
+OB3D ships dense cubemap RGB-D-pose trajectories. Place the upstream data under `data/ob3d/` matching this layout:
+
+```
+data/ob3d/
+├── <scene_name>-Egocentric/
+│   ├── cubemap/
+│   │   ├── px/{frame_NNNN.png, frame_NNNN_depth.npy}      # +X face
+│   │   ├── nx/                                            # -X face
+│   │   ├── py/, ny/, pz/, nz/                             # remaining faces
+│   ├── pose/
+│   │   └── pose_NNNN.json                                  # source pose convention
+│   └── …
+└── <scene_name>-Non-Egocentric/
+    └── (same structure)
+```
+
+The exact upstream filenames depend on which OB3D distribution you use; the `pipeline.py` reads the layout from `config.yaml` so adjust `input_layout` there if needed.
+
+## Output schema (CM-EVS unified)
+
+```
+outputs/ob3d/<scene_name>-<viewpoint>/
+├── meta.json                                    # coordinate convention, first-frame center
+├── panorama_0000.png                            # ERP RGB, 1600×800
+├── panorama_0000_depth.npy                      # ERP range depth (m), float32
+├── pose_0000.json                               # { qwc: [w,x,y,z], position: [x,y,z], camera_type: "cubemap_reencoded" }
+├── panorama_0001.png
+├── panorama_0001_depth.npy
+├── pose_0001.json
+└── …
+```
+
+## Run
+
+```bash
+cd ../../code
+python scripts/reencode_outdoor.py \
+    --source ob3d \
+    --config ../adapters/ob3d/config.yaml
+```
+
+The script:
+
+1. Loads `config.yaml` → resolves cubemap face size, axis conversion, ERP target resolution.
+2. For each scene/viewpoint listed in `metadata/source_manifest.json`:
+    - Reads the 6 cubemap faces per frame, concatenates into ERP via standard cubemap → equirectangular projection.
+    - Re-projects depth: cubemap perspective `z` → ERP **range** depth (radial).
+    - Reads source pose, converts axis convention to CM-EVS world frame, expresses as `q_wc` + position.
+    - Writes the triple `panorama_NNNN.{png, _depth.npy}` and `pose_NNNN.json`.
+3. Emits per-scene `meta.json` re-stating the coordinate convention.
+
+## Verifying against paper
+
+After running, compare with paper §4.3 Table 4:
+
+- 12 scenes × 2 viewpoints = 24 instances ✓
+- 200 frames each = 2,400 frames ✓
+- Resolution 1600×800 ✓
+- Median depth 3.88 m ✓ (sanity-check via your favorite stats script)
+
+## Caveats
+
+- **No curator selection**. Paper §4.2 Table 3 row "Outdoor / OB3D" notes that all v1.0 outdoor frames are full re-encoded source trajectories, not curator-selected subsets. Therefore no `metadata/per_step_log.jsonl` is emitted.
+- **License**: frames produced by this adapter remain under upstream OB3D license. Do not redistribute without checking upstream terms.

adapters/scannetpp/README.md

@@ -0,0 +1,38 @@
+# ScanNet++ adapter — CM-EVS
+
+This package regenerates the ScanNet++ portion of CM-EVS (500 scans; paper reports 8,267 frames after local regeneration). **No ScanNet++-derived RGB-D frames are redistributed here**; users must independently accept the [ScanNet++ Terms of Service](https://kaldir.vc.in.tum.de/scannetpp/) and obtain the source data.
+
+## Files
+
+- `config.yaml` — curator parameters (input source, output root, resolution, grid spacing, K, conflict weight λ, early-stop thresholds, point-size for splat mode, etc.).
+- `pipeline.py` — adapter entry point (CM-EVS curator + ScanNet++-specific mesh / point-cloud proposal).
+- `metadata/source_manifest.json` — list of 500 ScanNet++ scan IDs the paper's evaluation runs over.
+
+## Reproducing the paper's ScanNet++ frames
+
+1. Obtain ScanNet++ from <https://kaldir.vc.in.tum.de/scannetpp/> after accepting the ToS.
+2. Place per-scan files under `data/scannetpp/<scan_id>/<scan_id>.ply` (matching `config.yaml`'s `pipeline.input_dir`).
+3. Install the curator code:
+   ```bash
+   conda env create -f ../../code/environment.yml
+   conda activate cmevs
+   ```
+4. Run the pipeline:
+   ```bash
+   cd ../../code
+   python pipelines/run_ply_pipeline.py --config ../adapters/scannetpp/config.yaml
+   ```
+5. Outputs land in `outputs/scannetpp/<scan_id>/{rgb, depth, pose, metadata}/...` under the unified CM-EVS schema.
+
+## What the adapter does
+
+ScanNet++ scans come as either textured **mesh** (preferred) or pure **point cloud**. This adapter handles both:
+
+- **Mesh mode**: standard CM-EVS pipeline (raycast-based candidate generation, conflict-aware warping oracle).
+- **Point-cloud mode**: degrades surface tests to `AABB + splat Z-buffer` because point clouds lack continuous surfaces. `point_size` in `config.yaml` controls the splat radius. This is a documented robustness limitation — see paper §3.4 Table 2 row "ScanNet++".
+
+## License
+
+- This adapter code: **MIT**.
+- ScanNet++-derived metadata (scan IDs): bound by the **ScanNet++ ToS**.
+- Frames you produce: bound by the ScanNet++ ToS.

adapters/scannetpp/config.yaml

@@ -0,0 +1,17 @@
+experiment:
+  source: scannetpp
+  input_kind: ply
+
+pipeline:
+  input_dir: data/scannetpp
+  output_root: outputs/scannetpp
+  num_frames: 30
+  resolution: "2048,1024"
+  grid_spacing: 0.5
+  point_size: 2.0
+  z_up: true
+  min_frames: 5
+  stop_gain: 0.08
+  stop_score: -0.3
+  stop_delta: 0.08
+

adapters/scannetpp/metadata/source_manifest.json

@@ -0,0 +1,511 @@
+{
+  "source": "scannetpp",
+  "label": "ScanNet++",
+  "description": "500 ScanNet++ scans (mesh / point-cloud) used by the CM-EVS curator.",
+  "license": "MIT (code) + ScanNet++ ToS (metadata)",
+  "release_policy": "no derived RGB-D frames redistributed; users regenerate locally",
+  "id_field": "scan_id",
+  "id_count": 500,
+  "ids": [
+    "scene021",
+    "scene022",
+    "scene023",
+    "scene025",
+    "scene026",
+    "scene027",
+    "scene031",
+    "scene032",
+    "scene035",
+    "scene036",
+    "scene037",
+    "scene038",
+    "scene039",
+    "scene041",
+    "scene042",
+    "scene043",
+    "scene045",
+    "scene046",
+    "scene048",
+    "scene049",
+    "scene050",
+    "scene051",
+    "scene054",
+    "scene058",
+    "scene061",
+    "scene065",
+    "scene066",
+    "scene071",
+    "scene072",
+    "scene073",
+    "scene076",
+    "scene077",
+    "scene078",
+    "scene079",
+    "scene081",
+    "scene082",
+    "scene083",
+    "scene084",
+    "scene085",
+    "scene087",
+    "scene093",
+    "scene094",
+    "scene097",
+    "scene098",
+    "scene099",
+    "scene100",
+    "scene102",
+    "scene103",
+    "scene104",
+    "scene105",
+    "scene108",
+    "scene109",
+    "scene112",
+    "scene113",
+    "scene116",
+    "scene117",
+    "scene118",
+    "scene119",
+    "scene120",
+    "scene121",
+    "scene123",
+    "scene124",
+    "scene125",
+    "scene126",
+    "scene128",
+    "scene129",
+    "scene131",
+    "scene133",
+    "scene134",
+    "scene135",
+    "scene137",
+    "scene138",
+    "scene140",
+    "scene141",
+    "scene142",
+    "scene143",
+    "scene145",
+    "scene149",
+    "scene150",
+    "scene151",
+    "scene153",
+    "scene155",
+    "scene158",
+    "scene159",
+    "scene160",
+    "scene163",
+    "scene168",
+    "scene169",
+    "scene171",
+    "scene173",
+    "scene174",
+    "scene175",
+    "scene177",
+    "scene180",
+    "scene183",
+    "scene184",
+    "scene185",
+    "scene186",
+    "scene187",
+    "scene189",
+    "scene190",
+    "scene191",
+    "scene192",
+    "scene194",
+    "scene195",
+    "scene196",
+    "scene199",
+    "scene201",
+    "scene202",
+    "scene203",
+    "scene205",
+    "scene211",
+    "scene212",
+    "scene213",
+    "scene214",
+    "scene217",
+    "scene220",
+    "scene221",
+    "scene222",
+    "scene224",
+    "scene226",
+    "scene228",
+    "scene230",
+    "scene232",
+    "scene235",
+    "scene237",
+    "scene238",
+    "scene239",
+    "scene240",
+    "scene241",
+    "scene242",
+    "scene243",
+    "scene245",
+    "scene246",
+    "scene251",
+    "scene252",
+    "scene253",
+    "scene254",
+    "scene255",
+    "scene258",
+    "scene260",
+    "scene264",
+    "scene265",
+    "scene266",
+    "scene267",
+    "scene270",
+    "scene271",
+    "scene272",
+    "scene273",
+    "scene277",
+    "scene278",
+    "scene279",
+    "scene281",
+    "scene286",
+    "scene287",
+    "scene289",
+    "scene291",
+    "scene292",
+    "scene293",
+    "scene297",
+    "scene302",
+    "scene305",
+    "scene306",
+    "scene308",
+    "scene312",
+    "scene313",
+    "scene315",
+    "scene317",
+    "scene321",
+    "scene323",
+    "scene324",
+    "scene326",
+    "scene327",
+    "scene331",
+    "scene332",
+    "scene334",
+    "scene336",
+    "scene337",
+    "scene339",
+    "scene340",
+    "scene341",
+    "scene342",
+    "scene343",
+    "scene344",
+    "scene346",
+    "scene354",
+    "scene355",
+    "scene357",
+    "scene358",
+    "scene359",
+    "scene360",
+    "scene361",
+    "scene362",
+    "scene363",
+    "scene365",
+    "scene366",
+    "scene367",
+    "scene369",
+    "scene371",
+    "scene372",
+    "scene374",
+    "scene375",
+    "scene376",
+    "scene377",
+    "scene378",
+    "scene379",
+    "scene380",
+    "scene381",
+    "scene382",
+    "scene386",
+    "scene388",
+    "scene390",
+    "scene392",
+    "scene393",
+    "scene394",
+    "scene395",
+    "scene396",
+    "scene397",
+    "scene399",
+    "scene400",
+    "scene401",
+    "scene403",
+    "scene404",
+    "scene405",
+    "scene407",
+    "scene408",
+    "scene410",
+    "scene411",
+    "scene412",
+    "scene413",
+    "scene415",
+    "scene418",
+    "scene419",
+    "scene421",
+    "scene422",
+    "scene424",
+    "scene425",
+    "scene427",
+    "scene428",
+    "scene430",
+    "scene431",
+    "scene434",
+    "scene435",
+    "scene437",
+    "scene439",
+    "scene440",
+    "scene441",
+    "scene442",
+    "scene443",
+    "scene444",
+    "scene445",
+    "scene446",
+    "scene447",
+    "scene448",
+    "scene449",
+    "scene450",
+    "scene452",
+    "scene453",
+    "scene454",
+    "scene456",
+    "scene457",
+    "scene459",
+    "scene460",
+    "scene462",
+    "scene463",
+    "scene464",
+    "scene465",
+    "scene466",
+    "scene467",
+    "scene468",
+    "scene471",
+    "scene472",
+    "scene473",
+    "scene474",
+    "scene475",
+    "scene477",
+    "scene478",
+    "scene479",
+    "scene480",
+    "scene481",
+    "scene482",
+    "scene484",
+    "scene485",
+    "scene488",
+    "scene489",
+    "scene490",
+    "scene491",
+    "scene494",
+    "scene495",
+    "scene496",
+    "scene500",
+    "scene503",
+    "scene504",
+    "scene505",
+    "scene506",
+    "scene507",
+    "scene508",
+    "scene509",
+    "scene510",
+    "scene515",
+    "scene517",
+    "scene518",
+    "scene519",
+    "scene520",
+    "scene521",
+    "scene524",
+    "scene525",
+    "scene526",
+    "scene527",
+    "scene528",
+    "scene531",
+    "scene532",
+    "scene533",
+    "scene534",
+    "scene536",
+    "scene537",
+    "scene539",
+    "scene540",
+    "scene541",
+    "scene542",
+    "scene543",
+    "scene544",
+    "scene545",
+    "scene546",
+    "scene547",
+    "scene548",
+    "scene549",
+    "scene550",
+    "scene552",
+    "scene554",
+    "scene556",
+    "scene559",
+    "scene561",
+    "scene562",
+    "scene563",
+    "scene564",
+    "scene565",
+    "scene566",
+    "scene569",
+    "scene570",
+    "scene571",
+    "scene572",
+    "scene573",
+    "scene574",
+    "scene575",
+    "scene576",
+    "scene578",
+    "scene580",
+    "scene581",
+    "scene582",
+    "scene585",
+    "scene586",
+    "scene587",
+    "scene588",
+    "scene591",
+    "scene592",
+    "scene593",
+    "scene594",
+    "scene595",
+    "scene596",
+    "scene597",
+    "scene598",
+    "scene599",
+    "scene600",
+    "scene601",
+    "scene603",
+    "scene604",
+    "scene605",
+    "scene607",
+    "scene608",
+    "scene609",
+    "scene610",
+    "scene611",
+    "scene612",
+    "scene613",
+    "scene614",
+    "scene615",
+    "scene616",
+    "scene617",
+    "scene618",
+    "scene620",
+    "scene621",
+    "scene622",
+    "scene623",
+    "scene626",
+    "scene628",
+    "scene629",
+    "scene630",
+    "scene631",
+    "scene634",
+    "scene637",
+    "scene638",
+    "scene639",
+    "scene640",
+    "scene641",
+    "scene642",
+    "scene643",
+    "scene644",
+    "scene646",
+    "scene647",
+    "scene652",
+    "scene657",
+    "scene661",
+    "scene662",
+    "scene663",
+    "scene665",
+    "scene666",
+    "scene669",
+    "scene674",
+    "scene675",
+    "scene676",
+    "scene677",
+    "scene682",
+    "scene688",
+    "scene690",
+    "scene697",
+    "scene699",
+    "scene702",
+    "scene704",
+    "scene706",
+    "scene709",
+    "scene710",
+    "scene712",
+    "scene715",
+    "scene719",
+    "scene720",
+    "scene721",
+    "scene729",
+    "scene741",
+    "scene745",
+    "scene747",
+    "scene749",
+    "scene757",
+    "scene758",
+    "scene759",
+    "scene760",
+    "scene766",
+    "scene767",
+    "scene769",
+    "scene770",
+    "scene771",
+    "scene777",
+    "scene778",
+    "scene786",
+    "scene787",
+    "scene794",
+    "scene796",
+    "scene798",
+    "scene799",
+    "scene800",
+    "scene802",
+    "scene803",
+    "scene807",
+    "scene812",
+    "scene813",
+    "scene814",
+    "scene815",
+    "scene818",
+    "scene820",
+    "scene822",
+    "scene828",
+    "scene829",
+    "scene838",
+    "scene839",
+    "scene840",
+    "scene846",
+    "scene848",
+    "scene857",
+    "scene860",
+    "scene862",
+    "scene863",
+    "scene866",
+    "scene869",
+    "scene874",
+    "scene877",
+    "scene878",
+    "scene880",
+    "scene882",
+    "scene883",
+    "scene885",
+    "scene890",
+    "scene891",
+    "scene901",
+    "scene908",
+    "scene910",
+    "scene912",
+    "scene915",
+    "scene916",
+    "scene919",
+    "scene923",
+    "scene926",
+    "scene928",
+    "scene932",
+    "scene933",
+    "scene935",
+    "scene939",
+    "scene946",
+    "scene947",
+    "scene948",
+    "scene956"
+  ]
+}

adapters/scannetpp/pipeline.py

@@ -0,0 +1,1967 @@
+#!/usr/bin/env python3
+"""
+PLY 全流程 Pipeline（纯 Python，无需 Blender）
+
+从 .ply 点云/网格文件出发，完成：
+  Phase 0: 加载场景 + 获取 AABB 边界
+  Phase 1: 多高度层撒点 + 7 层过滤（trimesh ray_cast 替代 bpy）
+  Phase 2: 边渲边选（Open3D ERP 点云渲染 + 深度图）
+
+输出格式与 run_blend_pipeline.py 完全一致:
+  panorama_XXXX.png   + panorama_XXXX_depth.npy  + pose_XXXX.json
+
+坐标系: ERPT_native 右手系 [X右, Y上, Z前]
+  PLY 坐标系通常为 Z-up，渲染前统一转换为 Y-up。
+
+运行:
+    python run_ply_pipeline.py \\
+        --ply /path/to/scene.ply \\
+        --output-dir /path/to/output \\
+        --num-frames 30 \\
+        --resolution 2048,1024
+
+依赖:
+    pip install open3d trimesh numpy opencv-python pillow
+"""
+
+import argparse
+import json
+import math
+import os
+import random as _random
+import sys
+import time
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+from typing import Optional
+
+import numpy as np
+import trimesh
+import open3d as o3d
+import cv2
+
+# ── GPU 支持检测 ──────────────────────────────────────────────────────────────
+try:
+    import torch
+    import torch.nn.functional as _F
+    _CUDA_AVAILABLE = torch.cuda.is_available()
+    _TORCH_DEVICE = torch.device("cuda") if _CUDA_AVAILABLE else torch.device("cpu")
+    if _CUDA_AVAILABLE:
+        print(f"[GPU] CUDA 可用: {torch.cuda.get_device_name(0)}")
+    else:
+        print("[GPU] CUDA 不可用，使用 CPU 渲染")
+except ImportError:
+    torch = None
+    _CUDA_AVAILABLE = False
+    _TORCH_DEVICE = None
+    print("[GPU] torch 未安装，使用 CPU 渲染")
+
+
+WARP_H = 128
+WARP_W = 256
+MARGIN = 0.2          # 距边界最小安全距离（PLY 场景通常比 blend 精度低，稍微宽松）
+
+DEFAULT_STOP_GAIN = 0.08
+DEFAULT_OVERLAP_PENALTY = 0.5
+DEFAULT_MIN_DIST = 0.6
+DEFAULT_MIN_FRAMES = 5
+
+ROTATION_TYPES = {
+    "none":         [0.0, 0.0, 0.0],
+    "rotate_x_90":  [math.pi / 2, 0.0, 0.0],
+    "rotate_x_180": [math.pi, 0.0, 0.0],
+    "rotate_z_90":  [0.0, 0.0, math.pi / 2],
+}
+
+
+def get_camera_rot(rotation_type: str, frame_id: int):
+    if rotation_type == "random_yaw":
+        yaw = 0.0 if frame_id == 0 else _random.uniform(0, 2 * math.pi)
+        return [math.pi / 2, 0.0, yaw]
+    return list(ROTATION_TYPES[rotation_type])
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="PLY Pipeline（边渲边选）")
+    parser.add_argument("--ply", type=str, required=True,
+                        help=".ply 文件路径")
+    parser.add_argument("--output-dir", type=str, required=True,
+                        help="输出目录")
+    parser.add_argument("--num-frames", type=int, default=30)
+    parser.add_argument("--resolution", type=str, default="2048,1024",
+                        help="渲染分辨率 width,height")
+    parser.add_argument("--grid-spacing", type=float, default=0.5,
+                        help="候选点网格间距（米）")
+    parser.add_argument("--camera-height", type=float, default=None,
+                        help="固定相机高度（米），None=自动多层")
+    parser.add_argument("--stop-gain", type=float, default=DEFAULT_STOP_GAIN)
+    parser.add_argument("--stop-score", type=float, default=-0.3)
+    parser.add_argument("--stop-delta", type=float, default=0.08)
+    parser.add_argument("--min-frames", type=int, default=DEFAULT_MIN_FRAMES)
+    parser.add_argument("--rotation-type", type=str, default="random_yaw",
+                        choices=["none", "rotate_x_90", "rotate_x_180",
+                                 "rotate_z_90", "random_yaw"])
+    parser.add_argument("--point-size", type=float, default=2.0,
+                        help="点云渲染点径（像素）")
+    parser.add_argument("--z-up", action="store_true", default=True,
+                        help="PLY 坐标系为 Z-up（默认 True，转为 Y-up）")
+    parser.add_argument("--no-z-up", dest="z_up", action="store_false")
+    return parser.parse_args()
+
+
+def load_ply_scene(ply_path: str, z_up: bool = True):
+    """加载 PLY，可选将 Z-up 转为 Y-up（ERPT_native）
+
+    PLY 常见坐标系:
+      Z-up:  X右, Y前, Z上  → 转换: X'=X, Y'=Z, Z'=Y（ERPT_native）
+      Y-up:  X右, Y上, Z前  → 直接使用
+
+    Returns:
+        mesh_or_pc: trimesh 对象（Mesh 或 PointCloud）
+        pts_world:  np.ndarray (N,3) Y-up 世界点坐标
+        bmin, bmax: AABB (3,) float
+        is_mesh:    bool, True=Trimesh Mesh（支持 ray_cast）
+        faces:      np.ndarray (F,3) int 或 None（纯点云时为 None）
+    """
+    print(f"\n[Phase 0] 加载场景: {ply_path}")
+    scene_or_mesh = trimesh.load(ply_path, process=False, force=None)
+
+    # trimesh 可能返回 Scene（多个 mesh 合并）
+    if isinstance(scene_or_mesh, trimesh.Scene):
+        mesh = trimesh.util.concatenate(
+            [g for g in scene_or_mesh.geometry.values()
+             if isinstance(g, trimesh.Trimesh)]
+        )
+        is_mesh = True
+    elif isinstance(scene_or_mesh, trimesh.Trimesh):
+        mesh = scene_or_mesh
+        is_mesh = True
+    elif isinstance(scene_or_mesh, trimesh.PointCloud):
+        mesh = scene_or_mesh
+        is_mesh = False
+    else:
+        # 尝试强制为 PointCloud
+        mesh = trimesh.load(ply_path, process=False, force='mesh')
+        is_mesh = isinstance(mesh, trimesh.Trimesh)
+
+    # 获取顶点坐标和面数据
+    pts_raw = np.array(mesh.vertices, dtype=np.float64)
+    faces = np.array(mesh.faces, dtype=np.int32) if is_mesh else None
+
+    print(f"  点数: {len(pts_raw)}, 面数: {len(faces) if faces is not None else 0}, is_mesh={is_mesh}")
+
+    # 坐标系转换 Z-up → Y-up（ERPT_native）
+    if z_up:
+        pts_world = pts_raw[:, [0, 2, 1]].copy()
+    else:
+        pts_world = pts_raw.copy()
+
+    bmin = pts_world.min(axis=0)
+    bmax = pts_world.max(axis=0)
+
+    print(f"  AABB (Y-up): min=[{bmin[0]:.2f}, {bmin[1]:.2f}, {bmin[2]:.2f}]  "
+          f"max=[{bmax[0]:.2f}, {bmax[1]:.2f}, {bmax[2]:.2f}]")
+
+    return mesh, pts_world, bmin, bmax, is_mesh, faces
+
+
+class RayCaster:
+    """封装 trimesh RayMeshIntersector，提供与 Blender ray_cast 相同的接口。
+
+    对于纯点云（非 mesh）场景，降级为"无碰撞"模式（所有射线无 hit），
+    只能依靠 AABB 做粗略过滤。
+    """
+
+    def __init__(self, mesh, pts_world: np.ndarray, bmin, bmax,
+                 is_mesh: bool, z_up: bool = True):
+        self.is_mesh = is_mesh
+        self.pts_world = pts_world
+        self.bmin = np.array(bmin)
+        self.bmax = np.array(bmax)
+        self.z_up = z_up
+        self._intersector = None
+
+        if is_mesh and isinstance(mesh, trimesh.Trimesh):
+            if z_up:
+                # 需要把 mesh 顶点也转为 Y-up
+                verts = np.array(mesh.vertices, dtype=np.float64)
+                verts_yup = verts[:, [0, 2, 1]]
+                import copy
+                m2 = copy.deepcopy(mesh)
+                m2.vertices = verts_yup
+                self._intersector = trimesh.ray.ray_pyembree.RayMeshIntersector(m2) \
+                    if hasattr(trimesh.ray, 'ray_pyembree') \
+                    else trimesh.ray.ray_triangle.RayMeshIntersector(m2)
+            else:
+                self._intersector = trimesh.ray.ray_pyembree.RayMeshIntersector(mesh) \
+                    if hasattr(trimesh.ray, 'ray_pyembree') \
+                    else trimesh.ray.ray_triangle.RayMeshIntersector(mesh)
+            print("  [RayCaster] 使用 trimesh RayMeshIntersector")
+        else:
+            print("  [RayCaster] 非 Mesh 场景，使用 AABB 降级模式")
+
+    def cast_ray(self, origin: np.ndarray, direction: np.ndarray):
+        """单条射线，返回 (hit: bool, dist: float)
+
+        hit=True 时 dist 为交点距离（米）。
+        hit=False 时 dist=inf。
+        """
+        if self._intersector is None:
+            return False, float('inf')
+
+        o = np.array(origin, dtype=np.float64)[np.newaxis]  # (1,3)
+        d = np.array(direction, dtype=np.float64)[np.newaxis]
+        d = d / (np.linalg.norm(d) + 1e-12)
+
+        try:
+            locs, idx_ray, idx_tri = self._intersector.intersects_location(
+                o, d, multiple_hits=True)
+        except Exception:
+            return False, float('inf')
+
+        if len(locs) == 0:
+            return False, float('inf')
+
+        dists = np.linalg.norm(locs - origin, axis=1)
+        # 过滤极近距离（防止自交）
+        valid = dists > 1e-4
+        if not np.any(valid):
+            return False, float('inf')
+
+        min_dist = float(dists[valid].min())
+        return True, min_dist
+
+    def cast_rays_batch(self, origin: np.ndarray,
+                        directions: np.ndarray) -> np.ndarray:
+        """批量射线，返回 dist 数组 (N,)，无 hit 为 inf。"""
+        if self._intersector is None:
+            return np.full(len(directions), float('inf'))
+
+        origins = np.tile(origin[np.newaxis], (len(directions), 1))
+        dirs = directions / (np.linalg.norm(directions, axis=1, keepdims=True) + 1e-12)
+
+        try:
+            locs, idx_ray, idx_tri = self._intersector.intersects_location(
+                origins, dirs, multiple_hits=True)
+        except Exception:
+            return np.full(len(directions), float('inf'))
+
+        dists_out = np.full(len(directions), float('inf'))
+        if len(locs) == 0:
+            return dists_out
+
+        # 每条射线取最近交点
+        for i, (loc, ir) in enumerate(zip(locs, idx_ray)):
+            d = float(np.linalg.norm(loc - origin))
+            if d > 1e-4 and d < dists_out[ir]:
+                dists_out[ir] = d
+
+        return dists_out
+
+
+def compute_camera_heights(floor_y: float, ceiling_y: float,
+                           manual_height=None):
+    """计算相机高度层（Y-up 坐标系，Y=高度）"""
+    CEIL_CLEARANCE = 0.3
+    FIXED_HEIGHTS = [0.5, 0.8, 1.2, 1.7, 2.1]
+
+    if manual_height is not None:
+        return [manual_height]
+
+    room_h = ceiling_y - floor_y
+    if room_h <= 0:
+        return [floor_y + 1.5]
+
+    heights = []
+    for eye_h in FIXED_HEIGHTS:
+        z = floor_y + eye_h
+        if z < ceiling_y - CEIL_CLEARANCE:
+            heights.append(z)
+
+    if room_h > 3.0:
+        cur_h = FIXED_HEIGHTS[-1]
+        step = 1.0
+        while True:
+            cur_h += step
+            z = floor_y + cur_h
+            if z >= ceiling_y - CEIL_CLEARANCE:
+                break
+            heights.append(z)
+            step = min(step + 0.5, 3.0)
+
+    top_y = ceiling_y - CEIL_CLEARANCE
+    if heights and top_y > max(heights) + 0.5:
+        heights.append(top_y)
+    elif not heights and top_y > floor_y + 0.5:
+        heights.append(top_y)
+
+    return sorted(set(round(h, 2) for h in heights)) if heights else [floor_y + 1.5]
+
+
+def generate_candidate_grid(bmin, bmax, x_spacing, z_spacing, heights):
+    """生成候选点网格（Y-up 坐标系：X=右, Y=高, Z=前）
+
+    heights 是 Y 方向的高度值列表。
+    """
+    cx = (bmin[0] + bmax[0]) / 2
+    cz = (bmin[2] + bmax[2]) / 2
+
+    x_half = int((bmax[0] - cx - MARGIN) / x_spacing)
+    z_half = int((bmax[2] - cz - MARGIN) / z_spacing)
+
+    xz_offsets = []
+    for ix in range(-x_half, x_half + 1):
+        for iz in range(-z_half, z_half + 1):
+            x = cx + ix * x_spacing
+            z = cz + iz * z_spacing
+            if (bmin[0] + MARGIN <= x <= bmax[0] - MARGIN and
+                    bmin[2] + MARGIN <= z <= bmax[2] - MARGIN):
+                xz_offsets.append((ix * ix + iz * iz, x, z))
+    xz_offsets.sort(key=lambda t: t[0])
+
+    candidates = []
+    for y in heights:
+        for _, x, z in xz_offsets:
+            candidates.append([float(x), float(y), float(z)])
+
+    n_xz = len(xz_offsets)
+    print(f"  网格: {n_xz}点/层 x {len(heights)}层 = {len(candidates)} 个候选")
+    return candidates
+
+
+def _build_26_directions_yup():
+    """26 方向球面采样（Y-up 坐标系：水平面=XZ，竖直=Y）"""
+    dirs = []
+    # 水平 16 方向（XZ 平面）
+    for i in range(16):
+        a = i * (2 * math.pi / 16)
+        dirs.append(np.array([math.cos(a), 0.0, math.sin(a)]))
+    # 上方 5 方向
+    elev = math.pi / 4
+    for i in range(5):
+        a = i * (2 * math.pi / 5)
+        dirs.append(np.array([
+            math.cos(a) * math.cos(elev),
+            math.sin(elev),
+            math.sin(a) * math.cos(elev),
+        ]))
+    # 下方 5 方向
+    for i in range(5):
+        a = i * (2 * math.pi / 5)
+        dirs.append(np.array([
+            math.cos(a) * math.cos(elev),
+            -math.sin(elev),
+            math.sin(a) * math.cos(elev),
+        ]))
+    return dirs
+
+
+def raycast_filter(candidates, raycaster: RayCaster, room_height: float,
+                   min_wall_dist: float = 1.0):
+    """7 层候选点过滤（Y-up 坐标系）
+
+    第 1 层: 室内检测（朝+Y/-Y 各一条射线，距离合理）
+    第 2 层: 穿模检测（≥2 方向 < 0.2m）
+    第 3 层: 角落检测（>50% 水平方向 < 1.0m）
+    第 4 层: 包裹检测（hit_rate≥90% + CV<0.30 + max<8m）
+    第 5 层: 贴墙检测（水平 16 方向最近 < 0.3m）
+    第 6 层: 视野质量（有效命中比例 < 35%）
+    第 7 层: 窄缝检测（对向水平距离之和 < 1.5m）
+
+    非 Mesh 场景（降级模式）：跳过射线过滤，仅做 AABB 内判断。
+    """
+    if raycaster._intersector is None:
+        print("  [过滤] 非 Mesh 场景，跳过射线过滤，返回所有 AABB 内候选")
+        bmin, bmax = raycaster.bmin, raycaster.bmax
+        passed = [c for c in candidates
+                  if all(bmin[i] + MARGIN <= c[i] <= bmax[i] - MARGIN
+                         for i in [0, 2])]
+        print(f"  过滤统计: 总计={len(candidates)}, 通过={len(passed)}")
+        return passed
+
+    DIRS_26 = _build_26_directions_yup()
+    n26 = len(DIRS_26)
+
+    dir_up = np.array([0.0, 1.0, 0.0])
+    dir_down = np.array([0.0, -1.0, 0.0])
+    max_up = max(5.0, room_height)
+    max_down = max(3.0, room_height)
+
+    MIN_WALL_CLEARANCE = 0.3
+    VIEW_GOOD_MIN = 0.5
+    VIEW_GOOD_MAX = 20.0
+    VIEW_GOOD_RATIO = 0.35
+    MIN_SLIT_WIDTH = 1.5
+
+    N = len(candidates)
+    passed = []
+    stats = {"无天花板": 0, "无地板": 0, "穿模": 0, "角落": 0,
+             "包裹": 0, "贴墙": 0, "视野差": 0, "窄缝": 0}
+
+    t0 = time.time()
+    log_interval = max(1, N // 10)
+
+    for idx, pos in enumerate(candidates):
+        if idx % log_interval == 0 and idx > 0:
+            print(f"    过滤进度: {idx}/{N} ({idx*100//N}%)", flush=True)
+
+        origin = np.array(pos, dtype=np.float64)
+
+        # 第 1 层: 室内检测（Y-up：朝上=+Y，朝下=-Y）
+        hit_up, d_up = raycaster.cast_ray(origin, dir_up)
+        if not hit_up or d_up > max_up:
+            stats["无天花板"] += 1
+            continue
+
+        hit_dn, d_dn = raycaster.cast_ray(origin, dir_down)
+        if not hit_dn or d_dn > max_down:
+            stats["无地板"] += 1
+            continue
+
+        # 第 2~7 层: 26 方向采样
+        dists = raycaster.cast_rays_batch(origin, np.array(DIRS_26))
+
+        # 第 2 层: 穿模
+        n_close = int(np.sum(dists < 0.2))
+        if n_close >= 2:
+            stats["穿模"] += 1
+            continue
+
+        # 第 3 层: 角落（水平 16 方向）
+        n_wall = int(np.sum(dists[:16] < min_wall_dist))
+        if n_wall > 8:
+            stats["角落"] += 1
+            continue
+
+        # 第 4 层: 包裹
+        finite = dists[np.isfinite(dists)]
+        hit_rate = len(finite) / n26
+        if hit_rate >= 0.90 and len(finite) >= 2:
+            mean_d = float(finite.mean())
+            max_d = float(finite.max())
+            if mean_d > 0:
+                cv = float(finite.std()) / mean_d
+                if cv < 0.30 and max_d < 8.0:
+                    stats["包裹"] += 1
+                    continue
+
+        # 第 5 层: 贴墙
+        horiz_finite = dists[:16][np.isfinite(dists[:16])]
+        if len(horiz_finite) > 0 and float(horiz_finite.min()) < MIN_WALL_CLEARANCE:
+            stats["贴墙"] += 1
+            continue
+
+        # 第 6 层: 视野质量
+        n_good = int(np.sum((dists >= VIEW_GOOD_MIN) & (dists <= VIEW_GOOD_MAX)))
+        if n_good / n26 < VIEW_GOOD_RATIO:
+            stats["视野差"] += 1
+            continue
+
+        # 第 7 层: 窄缝
+        in_slit = False
+        for i in range(8):
+            d_fwd = dists[i] if np.isfinite(dists[i]) else 999
+            d_bwd = dists[i + 8] if np.isfinite(dists[i + 8]) else 999
+            if d_fwd + d_bwd < MIN_SLIT_WIDTH:
+                in_slit = True
+                break
+        if in_slit:
+            stats["窄缝"] += 1
+            continue
+
+        passed.append(pos)
+
+    dt = time.time() - t0
+    print(f"  过滤统计 ({dt:.1f}s): 总计={N}, 通过={len(passed)}")
+    for k, v in stats.items():
+        if v > 0:
+            print(f"    ❌ {k}: {v} ({v * 100 // max(N, 1)}%)")
+
+    return passed
+
+
+def _euler_to_rotation_matrix(rx: float, ry: float, rz: float) -> np.ndarray:
+    """XYZ 欧拉角 → 旋转矩阵（用于 ERP 相机朝向，Y-up 坐标系）"""
+    cx, sx = math.cos(rx), math.sin(rx)
+    cy, sy = math.cos(ry), math.sin(ry)
+    cz, sz = math.cos(rz), math.sin(rz)
+
+    Rx = np.array([[1, 0, 0], [0, cx, -sx], [0, sx, cx]])
+    Ry = np.array([[cy, 0, sy], [0, 1, 0], [-sy, 0, cy]])
+    Rz = np.array([[cz, -sz, 0], [sz, cz, 0], [0, 0, 1]])
+    return Rz @ Ry @ Rx
+
+
+def render_erp_pointcloud(pts_world: np.ndarray,
+                          cam_pos: np.ndarray,
+                          cam_rot_euler: list,
+                          width: int,
+                          height: int,
+                          point_size: float = 2.0):
+    """将点云渲染为 ERP 全景图（等距圆柱投影）
+
+    算法:
+      1. 将所有世界点变换到相机坐标系
+      2. 计算每个点的方位角 (lon) 和仰角 (lat)（Y-up 右手系）
+      3. 投影到 ERP 像素坐标
+      4. 用 Z-buffer 填充 RGB + depth 图，splat_radius=point_size
+
+    坐标系 (ERPT_native, Y-up):
+      相机前向 = +Z_cam, 上方 = +Y_cam, 右方 = +X_cam
+      lon = atan2(x_cam, z_cam)  （正前方=0，右=+）
+      lat = atan2(y_cam, sqrt(x^2+z^2))（上=+π/2）
+
+    Returns:
+        rgb   : np.ndarray (H, W, 3) uint8
+        depth : np.ndarray (H, W) float32，range depth（米），0=无效
+    """
+    o3d = o3d
+
+    cam_pos = np.array(cam_pos, dtype=np.float64)
+    # 旋转矩阵：world → camera
+    # 相机默认朝向 +Z，根据欧拉角旋转
+    R_cw = _euler_to_rotation_matrix(*cam_rot_euler)  # cam_to_world
+    R_wc = R_cw.T  # world_to_cam
+
+    # 变换点云到相机坐标系
+    vecs = pts_world - cam_pos  # (N, 3)
+    pts_cam = (R_wc @ vecs.T).T  # (N, 3)
+
+    x_c = pts_cam[:, 0]
+    y_c = pts_cam[:, 1]
+    z_c = pts_cam[:, 2]
+
+    # 计算经纬度（ERPT_native 约定）
+    lon = np.arctan2(x_c, z_c)                          # [-π, π]
+    r_xz = np.sqrt(x_c ** 2 + z_c ** 2)
+    lat = np.arctan2(y_c, r_xz)                         # [-π/2, π/2]
+
+    # 转为像素坐标
+    u = ((lon / (2 * math.pi) + 0.5) * width).astype(np.float32)
+    v = ((0.5 - lat / math.pi) * height).astype(np.float32)
+    u = np.clip(u, 0, width - 1).astype(np.int32)
+    v = np.clip(v, 0, height - 1).astype(np.int32)
+
+    # range depth = 射线距离（米）
+    dist = np.sqrt(x_c ** 2 + y_c ** 2 + z_c ** 2).astype(np.float32)
+
+    # 尝试获取点云颜色
+    has_colors = hasattr(pts_world, '_colors')
+    colors_rgb = None
+
+    # 初始化图像缓冲区
+    rgb_buf = np.zeros((height, width, 3), dtype=np.uint8)
+    depth_buf = np.full((height, width), np.inf, dtype=np.float32)
+
+    # Z-buffer 渲染（每点 splat_radius 像素）
+    radius = max(1, int(round(point_size / 2)))
+
+    # 为效率起见，用 numpy 向量化做单像素填充，然后 dilate
+    # 先做精确 Z-buffer（单像素）
+    for i in np.argsort(dist)[::-1]:    # 从远到近，近的覆盖远的
+        ui, vi = u[i], v[i]
+        di = dist[i]
+        if di <= 0 or not np.isfinite(di):
+            continue
+        if di < depth_buf[vi, ui]:
+            depth_buf[vi, ui] = di
+            if colors_rgb is not None:
+                rgb_buf[vi, ui] = colors_rgb[i]
+            else:
+                # 无颜色时用伪彩色（深度着色）
+                c = int(np.clip(255 * (1.0 - di / 20.0), 0, 255))
+                rgb_buf[vi, ui] = [c, c, c]
+
+    # 如果有 Open3D 点云颜色，补充颜色
+    # （此处暂用灰度，完整颜色在下方 _render_with_colors 中处理）
+    depth_out = np.where(np.isfinite(depth_buf), depth_buf, 0.0).astype(np.float32)
+    return rgb_buf, depth_out
+
+
+def _gpu_align_u(u_ref, u_other, W: int):
+    """把 u_other 对齐到与 u_ref 最近的 ERP 循环副本（GPU tensor）"""
+    half_w = float(W) / 2.0
+    diff = u_other - u_ref
+    u_other = torch.where(diff >  half_w, u_other - W, u_other)
+    u_other = torch.where(diff < -half_w, u_other + W, u_other)
+    return u_other
+
+
+def _gpu_raster_batch(u0, v0, u1, v1, u2, v2,
+                      c0, c1, c2, d0b, d1b, d2b,
+                      rgb_flat, depth_flat, H: int, W: int):
+    """完全向量化批量光栅化（无 Python for 循环）。
+
+    将所有三角面的包围盒像素展开成一个大 tensor，一次性完成
+    重心坐标计算和 scatter_reduce Z-buffer 写入。
+
+    Args:
+        u0/v0, u1/v1, u2/v2: (B,) float32，三顶点 ERP 像素坐标
+        c0/c1/c2:            (B,3) float32，三顶点颜色 [0,255]
+        d0b/d1b/d2b:         (B,) float32，三顶点距离
+        rgb_flat:   (H*W, 3) 输出颜色缓冲（就地修改）
+        depth_flat: (H*W,)   输出深度缓冲（就地修改）
+    """
+    dev = u0.device
+
+    # ── 包围盒 ──────────────────────────────────────────────────────────────
+    u_lo = torch.clamp(torch.floor(torch.minimum(torch.minimum(u0, u1), u2)).long(), 0, W - 1)
+    u_hi = torch.clamp(torch.ceil (torch.maximum(torch.maximum(u0, u1), u2)).long(), 0, W - 1)
+    v_lo = torch.clamp(torch.floor(torch.minimum(torch.minimum(v0, v1), v2)).long(), 0, H - 1)
+    v_hi = torch.clamp(torch.ceil (torch.maximum(torch.maximum(v0, v1), v2)).long(), 0, H - 1)
+
+    du = u_hi - u_lo + 1
+    dv = v_hi - v_lo + 1
+    bbox_px = du * dv
+
+    # 过滤退化面 & 超大面
+    valid = (u_hi >= u_lo) & (v_hi >= v_lo) & (bbox_px <= 128 * 128)
+    if not valid.any():
+        return
+
+    idx = valid.nonzero(as_tuple=False).squeeze(1)
+    u0v = u0[idx]; v0v = v0[idx]
+    u1v = u1[idx]; v1v = v1[idx]
+    u2v = u2[idx]; v2v = v2[idx]
+    c0v = c0[idx]; c1v = c1[idx]; c2v = c2[idx]
+    d0v = d0b[idx]; d1v = d1b[idx]; d2v = d2b[idx]
+    u_lv = u_lo[idx]; u_hv = u_hi[idx]
+    v_lv = v_lo[idx]; v_hv = v_hi[idx]
+    duv = u_hv - u_lv + 1
+    dvv = v_hv - v_lv + 1
+    npx = duv * dvv
+
+    Bp = int(npx.sum().item())
+    if Bp == 0:
+        return
+
+    # ── 展开：repeat_interleave 把面 id 重复 npx[i] 次 ──────────────────────
+    face_id = torch.repeat_interleave(
+        torch.arange(len(idx), device=dev, dtype=torch.long), npx)
+
+    cumsum = torch.zeros(len(idx) + 1, dtype=torch.long, device=dev)
+    cumsum[1:] = torch.cumsum(npx, 0)
+    local_flat = torch.arange(Bp, device=dev, dtype=torch.long) - cumsum[face_id]
+
+    local_u = local_flat % duv[face_id]
+    local_v = local_flat // duv[face_id]
+
+    uu = (u_lv[face_id] + local_u).float()
+    vv = (v_lv[face_id] + local_v).float()
+
+    # ── 重心坐标（完全向量化） ───────────────────────────────────────────────
+    ax = u0v[face_id]; ay = v0v[face_id]
+    bx = u1v[face_id]; by = v1v[face_id]
+    cx = u2v[face_id]; cy = v2v[face_id]
+
+    denom = (by - cy) * (ax - cx) + (cx - bx) * (ay - cy)
+    safe  = denom.abs() > 1e-8
+    inv_d = torch.where(safe, 1.0 / denom, torch.zeros_like(denom))
+    w0 = ((by - cy) * (uu - cx) + (cx - bx) * (vv - cy)) * inv_d
+    w1 = ((cy - ay) * (uu - cx) + (ax - cx) * (vv - cy)) * inv_d
+    w2 = 1.0 - w0 - w1
+
+    inside = safe & (w0 >= -0.01) & (w1 >= -0.01) & (w2 >= -0.01)
+    if not inside.any():
+        return
+
+    fi  = face_id[inside]
+    uui = uu[inside].long()
+    vvi = vv[inside].long()
+    w0i = w0[inside]; w1i = w1[inside]; w2i = w2[inside]
+
+    # ── Z-buffer scatter_reduce(amin) ───────────────────────────────────────
+    di  = w0i * d0v[fi] + w1i * d1v[fi] + w2i * d2v[fi]
+    lin = vvi * W + uui
+    depth_flat.scatter_reduce_(0, lin, di, reduce='amin', include_self=True)
+
+    # ── 颜色写入（near-wins） ────────────────────────────────────────────────
+    cur_d  = depth_flat[lin]
+    winner = (di - cur_d).abs() < 1e-4
+    w0e = w0i[winner].unsqueeze(1)
+    w1e = w1i[winner].unsqueeze(1)
+    w2e = w2i[winner].unsqueeze(1)
+    fie = fi[winner]
+    col_i = torch.clamp(w0e * c0v[fie] + w1e * c1v[fie] + w2e * c2v[fie], 0, 255)
+    rgb_flat.scatter_(0, lin[winner].unsqueeze(1).expand(-1, 3), col_i)
+
+
+def _gpu_raster_mesh(u_f, v_f, dist, col_t, f_t,
+                     rgb_flat, depth_flat, H: int, W: int,
+                     batch_size: int = 65536):
+    """ERP 网格光栅化主流程（含接缝三副本 + OOM 自动降级）。
+
+    操作 rgb_flat / depth_flat 缓冲（就地修改）。
+    """
+    d0t = dist[f_t[:, 0]]; d1t = dist[f_t[:, 1]]; d2t = dist[f_t[:, 2]]
+    avg_d = (d0t + d1t + d2t) / 3.0
+    order = torch.argsort(avg_d, descending=True)
+    f_ord = f_t[order]
+    d0t, d1t, d2t = dist[f_ord[:, 0]], dist[f_ord[:, 1]], dist[f_ord[:, 2]]
+    c0t = col_t[f_ord[:, 0]]; c1t = col_t[f_ord[:, 1]]; c2t = col_t[f_ord[:, 2]]
+    u0r = u_f[f_ord[:, 0]]; u1r = u_f[f_ord[:, 1]]; u2r = u_f[f_ord[:, 2]]
+    v0r = v_f[f_ord[:, 0]]; v1r = v_f[f_ord[:, 1]]; v2r = v_f[f_ord[:, 2]]
+
+    valid_f = (d0t > 1e-4) & (d1t > 1e-4) & (d2t > 1e-4)
+    f_idx = valid_f.nonzero(as_tuple=False).squeeze(1)
+
+    def _process_batch(bi):
+        u0b = u0r[bi]; v0b = v0r[bi]
+        u1b = _gpu_align_u(u0b, u1r[bi], W)
+        u2b = _gpu_align_u(u0b, u2r[bi], W)
+        v1b = v1r[bi]; v2b = v2r[bi]
+        c0b = c0t[bi]; c1b = c1t[bi]; c2b = c2t[bi]
+        d0b_ = d0t[bi]; d1b_ = d1t[bi]; d2b_ = d2t[bi]
+        # 三副本 concat：主 + 左(u-W) + 右(u+W)，一次送入减少 kernel launch
+        _gpu_raster_batch(
+            torch.cat([u0b, u0b - W, u0b + W]),
+            torch.cat([v0b, v0b,     v0b    ]),
+            torch.cat([u1b, u1b - W, u1b + W]),
+            torch.cat([v1b, v1b,     v1b    ]),
+            torch.cat([u2b, u2b - W, u2b + W]),
+            torch.cat([v2b, v2b,     v2b    ]),
+            torch.cat([c0b, c0b, c0b]),
+            torch.cat([c1b, c1b, c1b]),
+            torch.cat([c2b, c2b, c2b]),
+            torch.cat([d0b_, d0b_, d0b_]),
+            torch.cat([d1b_, d1b_, d1b_]),
+            torch.cat([d2b_, d2b_, d2b_]),
+            rgb_flat, depth_flat, H, W,
+        )
+
+    try:
+        _process_batch(f_idx)
+    except torch.cuda.OutOfMemoryError:
+        torch.cuda.empty_cache()
+        print(f"  [WARN] OOM（{len(f_idx)} 面），自动降级分批 batch={batch_size}")
+        for start in range(0, len(f_idx), batch_size):
+            _process_batch(f_idx[start: start + batch_size])
+
+
+def _gpu_splat_pointcloud(u_f, v_f, dist, col_t,
+                          rgb_flat, depth_flat, H: int, W: int,
+                          point_size: float = 2.0):
+    """点云 scatter Z-buffer splatting（就地修改 rgb_flat / depth_flat）"""
+    valid  = dist > 1e-4
+    u_i    = torch.clamp(u_f[valid].long(), 0, W - 1)
+    v_i    = torch.clamp(v_f[valid].long(), 0, H - 1)
+    dist_v = dist[valid]
+    col_v  = col_t[valid]
+    lin    = v_i * W + u_i
+    radius = max(0, int(round(point_size / 2)) - 1)
+
+    if radius == 0:
+        depth_flat.scatter_reduce_(0, lin, dist_v, reduce='amin', include_self=True)
+        sort_idx = torch.argsort(dist_v)
+        rgb_flat.scatter_(0, lin[sort_idx].unsqueeze(1).expand(-1, 3), col_v[sort_idx])
+    else:
+        for dr in range(-radius, radius + 1):
+            for dc in range(-radius, radius + 1):
+                v_nb = torch.clamp(v_i + dr, 0, H - 1)
+                u_nb = torch.clamp(u_i + dc, 0, W - 1)
+                depth_flat.scatter_reduce_(0, v_nb * W + u_nb, dist_v,
+                                           reduce='amin', include_self=True)
+        sort_idx = torch.argsort(dist_v, descending=True)
+        for dr in range(-radius, radius + 1):
+            for dc in range(-radius, radius + 1):
+                v_nb = torch.clamp(v_i[sort_idx] + dr, 0, H - 1)
+                u_nb = torch.clamp(u_i[sort_idx] + dc, 0, W - 1)
+                rgb_flat.scatter_(0, (v_nb * W + u_nb).unsqueeze(1).expand(-1, 3),
+                                  col_v[sort_idx])
+
+
+def _gpu_fill_holes(rgb_2d, depth_out):
+    """GPU 空洞填充：大核 max_pool2d + 残余小孔迭代收尾。
+
+    Args:
+        rgb_2d:    (H,W,3) float32 GPU tensor
+        depth_out: (H,W)   float32 GPU tensor（0=空洞）
+
+    Returns:
+        rgb_2d: (H,W,3) float32，填充后
+    """
+    hole = (depth_out == 0)
+    if not hole.any():
+        return rgb_2d
+
+    fill_radius = 32
+    k = fill_radius * 2 + 1   # 65
+
+    rgb_f   = rgb_2d.permute(2, 0, 1).unsqueeze(0).float()       # (1,3,H,W)
+    valid_m = (~hole).float().unsqueeze(0).unsqueeze(0)           # (1,1,H,W)
+
+    rgb_masked = rgb_f * valid_m
+    expanded   = _F.max_pool2d(rgb_masked, kernel_size=k, stride=1, padding=fill_radius)
+    valid_exp  = _F.max_pool2d(valid_m,    kernel_size=k, stride=1, padding=fill_radius) > 0
+
+    fill_mask = hole.unsqueeze(0).unsqueeze(0) & valid_exp
+    rgb_f = torch.where(fill_mask.expand_as(rgb_f), expanded, rgb_f)
+
+    # 残余大孔洞：最多 8 轮 3×3 迭代收尾
+    hole2 = hole & ~fill_mask.squeeze(0).squeeze(0)
+    if hole2.any():
+        valid_f2 = (~hole2).float().unsqueeze(0).unsqueeze(0)
+        rgb_f2   = rgb_f
+        for _ in range(8):
+            if not hole2.any():
+                break
+            r2m  = rgb_f2 * valid_f2
+            exp2 = _F.max_pool2d(r2m,     kernel_size=3, stride=1, padding=1)
+            vd2  = _F.max_pool2d(valid_f2, kernel_size=3, stride=1, padding=1) > 0
+            nw2  = hole2.unsqueeze(0).unsqueeze(0) & vd2
+            if not nw2.any():
+                break
+            rgb_f2   = torch.where(nw2.expand_as(rgb_f2), exp2, rgb_f2)
+            valid_f2 = torch.where(nw2, torch.ones_like(valid_f2), valid_f2)
+            hole2    = hole2 & ~nw2.squeeze(0).squeeze(0)
+        rgb_f = rgb_f2
+
+    return rgb_f.squeeze(0).permute(1, 2, 0)   # (H,W,3)
+
+
+def _render_erp_gpu(pts_world: np.ndarray,
+                    colors_world,
+                    cam_pos,
+                    R_wc: np.ndarray,
+                    width: int,
+                    height: int,
+                    faces: np.ndarray = None,
+                    point_size: float = 2.0,
+                    batch_size: int = 65536) -> tuple:
+    """GPU（CUDA）加速的 ERP 全景渲染。
+
+    所有计算在 GPU tensor 上完成：
+      1. 顶点变换 + ERP 投影（全量向量化）
+      2. 网格/点云光栅化（委托给共享辅助函数）
+      3. 空洞填充：max_pool2d 大核膨胀（纯 GPU，无 cv2）
+
+    Returns:
+        rgb   (H, W, 3) uint8 numpy
+        depth (H, W)    float32 numpy
+    """
+    dev = _TORCH_DEVICE
+
+    # ── 1. 顶点变换到相机坐标系 ──────────────────────────────────────────────
+    pts = torch.from_numpy(pts_world.astype(np.float32)).to(dev)
+    cp  = torch.from_numpy(cam_pos.astype(np.float32)).to(dev)
+    R   = torch.from_numpy(R_wc.astype(np.float32)).to(dev)
+
+    pts_cam = (R @ (pts - cp).T).T
+    x_c, y_c, z_c = pts_cam[:, 0], pts_cam[:, 1], pts_cam[:, 2]
+
+    # ── 2. ERP 投影 ──────────────────────────────────────────────────────────
+    lon  = torch.atan2(x_c, z_c)
+    r_xz = torch.sqrt(x_c ** 2 + z_c ** 2)
+    lat  = torch.atan2(y_c, r_xz)
+    u_f  = (lon  / (2 * math.pi) + 0.5) * width
+    v_f  = (0.5  - lat / math.pi) * height
+    dist = torch.sqrt(x_c ** 2 + y_c ** 2 + z_c ** 2)
+
+    # ── 3. 顶点颜色 ──────────────────────────────────────────────────────────
+    if colors_world is not None:
+        col_np = colors_world if colors_world.dtype == np.uint8 \
+            else (np.clip(colors_world, 0, 1) * 255).astype(np.uint8)
+        col_t = torch.from_numpy(col_np.astype(np.float32)).to(dev)
+    else:
+        d_norm = torch.clamp(dist / max(float(dist.max()), 1.0), 0, 1)
+        g = torch.clamp((1.0 - d_norm) * 200 + 30, 0, 255)
+        col_t = g.unsqueeze(1).expand(-1, 3)
+
+    H, W = height, width
+    INF  = 1e9
+    rgb_flat   = torch.zeros(H * W, 3, dtype=torch.float32, device=dev)
+    depth_flat = torch.full((H * W,), INF, dtype=torch.float32, device=dev)
+
+    # ── 4. 光栅化 ────────────────────────────────────────────────────────────
+    if faces is not None and len(faces) > 0:
+        f_t = torch.from_numpy(faces.astype(np.int64)).to(dev)
+        _gpu_raster_mesh(u_f, v_f, dist, col_t, f_t,
+                         rgb_flat, depth_flat, H, W, batch_size)
+    else:
+        _gpu_splat_pointcloud(u_f, v_f, dist, col_t,
+                              rgb_flat, depth_flat, H, W, point_size)
+
+    # ── 5. reshape ───────────────────────────────────────────────────────────
+    depth_2d  = depth_flat.reshape(H, W)
+    rgb_2d    = rgb_flat.reshape(H, W, 3)
+    depth_out = torch.where(depth_2d < INF / 2, depth_2d, torch.zeros_like(depth_2d))
+
+    # ── 6. 空洞填充 ──────────────────────────────────────────────────────────
+    if faces is not None and len(faces) > 0:
+        rgb_2d = _gpu_fill_holes(rgb_2d, depth_out)
+
+    # ── 7. 回传 numpy ──────────��─────────────────────────────────────────────
+    rgb_np   = rgb_2d.clamp(0, 255).byte().cpu().numpy()
+    depth_np = depth_out.cpu().numpy().astype(np.float32)
+    return rgb_np, depth_np
+
+
+def render_erp_batch_gpu(pts_world: np.ndarray,
+                         colors_world,
+                         cam_poses: list,
+                         cam_rots: list,
+                         width: int,
+                         height: int,
+                         faces: np.ndarray = None,
+                         point_size: float = 2.0) -> list:
+    """并行批量渲染多个相机视角（共用同一场景，减少重复数据传输）。
+
+    将场景数据（pts_world, colors_world, faces）只上传一次到 GPU，
+    然后依次渲染 len(cam_poses) 个视角，显著减少 PCIe 传输开销。
+
+    Args:
+        cam_poses: list of [x, y, z]，各帧相机位置
+        cam_rots:  list of [rx, ry, rz]，各帧相机欧拉角
+
+    Returns:
+        list of (rgb_np, depth_np) 与输入顺序对应
+    """
+    if not (_CUDA_AVAILABLE and torch is not None):
+        return [
+            render_erp_from_ply(pts_world, colors_world, pos, rot,
+                                 width, height, point_size, faces)
+            for pos, rot in zip(cam_poses, cam_rots)
+        ]
+
+    dev = _TORCH_DEVICE
+
+    # ── 场景数据上传（只做一次）──────────────────────────────────────────────
+    pts_t = torch.from_numpy(pts_world.astype(np.float32)).to(dev)
+
+    if colors_world is not None:
+        col_np = colors_world if colors_world.dtype == np.uint8 \
+            else (np.clip(colors_world, 0, 1) * 255).astype(np.uint8)
+        col_t_scene = torch.from_numpy(col_np.astype(np.float32)).to(dev)
+    else:
+        col_t_scene = None
+
+    f_t = None
+    if faces is not None and len(faces) > 0:
+        f_t = torch.from_numpy(faces.astype(np.int64)).to(dev)
+
+    # ── 逐帧渲染（场景数据复用）──────────────────────────────────────────────
+    results = []
+    for cam_pos, cam_rot in zip(cam_poses, cam_rots):
+        cam_pos_np = np.array(cam_pos, dtype=np.float64)
+        R_wc = _euler_to_rotation_matrix(*cam_rot).T
+
+        cp = torch.from_numpy(cam_pos_np.astype(np.float32)).to(dev)
+        R  = torch.from_numpy(R_wc.astype(np.float32)).to(dev)
+
+        pts_cam = (R @ (pts_t - cp).T).T
+        x_c, y_c, z_c = pts_cam[:, 0], pts_cam[:, 1], pts_cam[:, 2]
+        lon  = torch.atan2(x_c, z_c)
+        r_xz = torch.sqrt(x_c ** 2 + z_c ** 2)
+        lat  = torch.atan2(y_c, r_xz)
+        u_f  = (lon  / (2 * math.pi) + 0.5) * width
+        v_f  = (0.5  - lat / math.pi) * height
+        dist = torch.sqrt(x_c ** 2 + y_c ** 2 + z_c ** 2)
+
+        if col_t_scene is None:
+            d_norm = torch.clamp(dist / max(float(dist.max()), 1.0), 0, 1)
+            g = torch.clamp((1.0 - d_norm) * 200 + 30, 0, 255)
+            col_frame = g.unsqueeze(1).expand(-1, 3)
+        else:
+            col_frame = col_t_scene
+
+        try:
+            rgb_np, depth_np = _render_erp_gpu_from_projected(
+                u_f, v_f, dist, col_frame, f_t, width, height, point_size)
+        except Exception as e:
+            print(f"  [WARN] batch GPU 渲染帧失败，回退单帧: {e}")
+            rgb_np, depth_np = _render_erp_gpu(
+                pts_world, colors_world, cam_pos_np, R_wc,
+                width, height, faces=faces, point_size=point_size)
+        results.append((rgb_np, depth_np))
+
+    return results
+
+
+def _render_erp_gpu_from_projected(
+        u_f, v_f, dist, col_t, f_t,
+        width: int, height: int, point_size: float = 2.0) -> tuple:
+    """内部函数：从已投影的 GPU tensor 直接光栅化，省去重复的顶点变换。
+
+    Args:
+        u_f, v_f:  (N,) float32 GPU tensor，ERP 像素浮点坐标
+        dist:      (N,) float32 GPU tensor，各顶点到相机距离
+        col_t:     (N,3) float32 GPU tensor，顶点颜色 [0,255]
+        f_t:       (F,3) int64  GPU tensor 或 None
+        width, height: 输出分辨率
+    """
+    dev = u_f.device
+    H, W = height, width
+    INF  = 1e9
+
+    rgb_flat   = torch.zeros(H * W, 3, dtype=torch.float32, device=dev)
+    depth_flat = torch.full((H * W,), INF, dtype=torch.float32, device=dev)
+
+    if f_t is not None and len(f_t) > 0:
+        _gpu_raster_mesh(u_f, v_f, dist, col_t, f_t,
+                         rgb_flat, depth_flat, H, W)
+    else:
+        _gpu_splat_pointcloud(u_f, v_f, dist, col_t,
+                              rgb_flat, depth_flat, H, W, point_size)
+
+    depth_2d  = depth_flat.reshape(H, W)
+    rgb_2d    = rgb_flat.reshape(H, W, 3)
+    depth_out = torch.where(depth_2d < INF / 2, depth_2d, torch.zeros_like(depth_2d))
+
+    if f_t is not None and len(f_t) > 0:
+        rgb_2d = _gpu_fill_holes(rgb_2d, depth_out)
+
+    rgb_np   = rgb_2d.clamp(0, 255).byte().cpu().numpy()
+    depth_np = depth_out.cpu().numpy().astype(np.float32)
+    return rgb_np, depth_np
+
+
+def render_erp_from_ply(pts_world: np.ndarray,
+                        colors_world,
+                        cam_pos: list,
+                        cam_rot_euler: list,
+                        width: int,
+                        height: int,
+                        point_size: float = 2.0,
+                        faces: np.ndarray = None):
+    """带颜色的 ERP 全景图渲染（自动 dispatch 到 GPU/CPU）
+
+    Args:
+        pts_world:     (N,3) float64，Y-up 世界坐标
+        colors_world:  (N,3) uint8 或 float32，RGB 颜色，None=伪彩
+        cam_pos:       [x, y, z] 相机位置（Y-up）
+        cam_rot_euler: [rx, ry, rz] 相机欧拉角（弧度）
+        width, height: 输出分辨率
+        point_size:    splat 直径（像素），仅纯点云模式有效
+        faces:         (F,3) int，三角面顶点索引；有面时走面光栅化
+
+    Returns:
+        rgb:   (H, W, 3) uint8
+        depth: (H, W) float32，range depth（米），0=无效
+    """
+    cam_pos = np.array(cam_pos, dtype=np.float64)
+    R_cw = _euler_to_rotation_matrix(*cam_rot_euler)
+    R_wc = R_cw.T
+
+    # ── GPU dispatch ──────────────────────────────────────────────────────
+    if _CUDA_AVAILABLE and torch is not None:
+        try:
+            return _render_erp_gpu(pts_world, colors_world,
+                                   cam_pos, R_wc,
+                                   width, height,
+                                   faces=faces, point_size=point_size)
+        except Exception as _gpu_err:
+            print(f"  [WARN] GPU 渲染失败，回退 CPU: {_gpu_err}")
+
+    # ── CPU 路径 ──────────────────────────────────────────────────────────
+    # 所有顶点变换到相机坐标系
+    vecs = pts_world - cam_pos
+    pts_cam = (R_wc @ vecs.T).T  # (N, 3)
+
+    x_c = pts_cam[:, 0].astype(np.float32)
+    y_c = pts_cam[:, 1].astype(np.float32)
+    z_c = pts_cam[:, 2].astype(np.float32)
+
+    # ERP 投影：每顶点 → (u_f, v_f, dist)
+    lon = np.arctan2(x_c, z_c)
+    r_xz = np.sqrt(x_c ** 2 + z_c ** 2)
+    lat = np.arctan2(y_c, r_xz)
+    u_f = (lon / (2 * math.pi) + 0.5) * width    # float 像素坐标
+    v_f = (0.5 - lat / math.pi) * height
+    dist = np.sqrt(x_c ** 2 + y_c ** 2 + z_c ** 2)
+
+    # 顶点颜色
+    if colors_world is not None:
+        col_all = colors_world
+        if col_all.dtype != np.uint8:
+            col_all = (np.clip(col_all, 0, 1) * 255).astype(np.uint8)
+    else:
+        d_norm = np.clip(dist / max(float(dist.max()), 1.0), 0, 1)
+        g = np.clip((1.0 - d_norm) * 200 + 30, 0, 255).astype(np.uint8)
+        col_all = np.stack([g, g, g], axis=1)
+
+    rgb_buf = np.zeros((height, width, 3), dtype=np.uint8)
+    depth_buf = np.full((height, width), np.inf, dtype=np.float32)
+
+    if faces is not None and len(faces) > 0:
+        # ── 网格模式：三角面光栅化 ──────────────────────────────────────
+        f = faces.astype(np.int32)
+        d0, d1, d2 = dist[f[:, 0]], dist[f[:, 1]], dist[f[:, 2]]
+        face_dist = (d0 + d1 + d2) / 3.0
+        valid_face = (d0 > 1e-4) & (d1 > 1e-4) & (d2 > 1e-4)
+        f = f[valid_face]
+        face_dist = face_dist[valid_face]
+
+        # 从远到近排序，近面覆盖远面
+        order = np.argsort(face_dist)[::-1]
+        f = f[order]
+        face_dist = face_dist[order]
+
+        c0s = col_all[f[:, 0]].astype(np.float32)
+        c1s = col_all[f[:, 1]].astype(np.float32)
+        c2s = col_all[f[:, 2]].astype(np.float32)
+        d0s = dist[f[:, 0]]
+        d1s = dist[f[:, 1]]
+        d2s = dist[f[:, 2]]
+
+        # 三顶点的 ERP 浮点坐标
+        u0s_raw = u_f[f[:, 0]]
+        u1s_raw = u_f[f[:, 1]]
+        u2s_raw = u_f[f[:, 2]]
+        v0s = v_f[f[:, 0]]
+        v1s = v_f[f[:, 1]]
+        v2s = v_f[f[:, 2]]
+
+        def _raster_triangle(u0v, v0v, u1v, v1v, u2v, v2v,
+                             c0, c1, c2, dep0, dep1, dep2):
+            """将单个三角面光栅化写入 rgb_buf / depth_buf（闭包）"""
+            v_min = max(0, int(math.floor(min(v0v, v1v, v2v))))
+            v_max = min(height - 1, int(math.ceil(max(v0v, v1v, v2v))))
+            u_min = max(0, int(math.floor(min(u0v, u1v, u2v))))
+            u_max = min(width - 1, int(math.ceil(max(u0v, u1v, u2v))))
+            if v_max < v_min or u_max < u_min:
+                return
+            vs_arr = np.arange(v_min, v_max + 1)
+            us_arr = np.arange(u_min, u_max + 1)
+            uu, vv = np.meshgrid(us_arr, vs_arr)
+            uu = uu.flatten().astype(np.float32)
+            vv = vv.flatten().astype(np.float32)
+            denom = ((v1v - v2v) * (u0v - u2v) + (u2v - u1v) * (v0v - v2v))
+            if abs(denom) < 1e-8:
+                return
+            inv_d = 1.0 / denom
+            w0 = ((v1v - v2v) * (uu - u2v) + (u2v - u1v) * (vv - v2v)) * inv_d
+            w1 = ((v2v - v0v) * (uu - u2v) + (u0v - u2v) * (vv - v2v)) * inv_d
+            w2 = 1.0 - w0 - w1
+            inside = (w0 >= -0.01) & (w1 >= -0.01) & (w2 >= -0.01)
+            if not inside.any():
+                return
+            uu_in = uu[inside].astype(np.int32)
+            vv_in = vv[inside].astype(np.int32)
+            w0_in = w0[inside][:, None]
+            w1_in = w1[inside][:, None]
+            w2_in = w2[inside][:, None]
+            di = w0_in[:, 0] * dep0 + w1_in[:, 0] * dep1 + w2_in[:, 0] * dep2
+            ci_rgb = np.clip(w0_in * c0 + w1_in * c1 + w2_in * c2, 0, 255).astype(np.uint8)
+            closer = di < depth_buf[vv_in, uu_in]
+            if closer.any():
+                depth_buf[vv_in[closer], uu_in[closer]] = di[closer]
+                rgb_buf[vv_in[closer], uu_in[closer]] = ci_rgb[closer]
+
+        half_w = width / 2.0
+
+        for i in range(len(f)):
+            u0v, v0v = float(u0s_raw[i]), float(v0s[i])
+            u1v, v1v = float(u1s_raw[i]), float(v1s[i])
+            u2v, v2v = float(u2s_raw[i]), float(v2s[i])
+            c0, c1, c2 = c0s[i], c1s[i], c2s[i]
+            dep0, dep1, dep2 = float(d0s[i]), float(d1s[i]), float(d2s[i])
+
+            # 检测是否跨越 ERP 左右边界（u 坐标差 > width/2）
+            us_tri = np.array([u0v, u1v, u2v])
+            u_span = float(us_tri.max() - us_tri.min())
+
+            if u_span > half_w:
+                # 跨边界：以 u0 为基准，把 u1/u2 对齐到与 u0 最近的循环副本
+                def _align(u_ref, u_other):
+                    diff = u_other - u_ref
+                    if diff > half_w:
+                        return u_other - width
+                    elif diff < -half_w:
+                        return u_other + width
+                    return u_other
+
+                u1_a = _align(u0v, u1v)
+                u2_a = _align(u0v, u2v)
+
+                # 主渲染（对齐后坐标，_raster_triangle 内部 clip 到 [0, width-1]）
+                _raster_triangle(u0v, v0v, u1_a, v1v, u2_a, v2v, c0, c1, c2, dep0, dep1, dep2)
+                # 循环副本（偏移 ±width 处理左右两侧黑边）
+                _raster_triangle(u0v - width, v0v, u1_a - width, v1v, u2_a - width, v2v,
+                                 c0, c1, c2, dep0, dep1, dep2)
+                _raster_triangle(u0v + width, v0v, u1_a + width, v1v, u2_a + width, v2v,
+                                 c0, c1, c2, dep0, dep1, dep2)
+            else:
+                _raster_triangle(u0v, v0v, u1v, v1v, u2v, v2v, c0, c1, c2, dep0, dep1, dep2)
+
+    else:
+        # ── 纯点云模式：Z-buffer Splatting ────────────────────────────
+        valid_mask = dist > 1e-4
+        u_i = np.clip(u_f.astype(np.int32), 0, width - 1)[valid_mask]
+        v_i = np.clip(v_f.astype(np.int32), 0, height - 1)[valid_mask]
+        dist_v = dist[valid_mask]
+        col_v = col_all[valid_mask]
+
+        order = np.argsort(dist_v)[::-1]
+        radius = max(0, int(round(point_size / 2)) - 1)
+
+        if radius == 0:
+            near_order = np.argsort(dist_v)
+            for idx in near_order:
+                vi, ui, di = v_i[idx], u_i[idx], dist_v[idx]
+                if di < depth_buf[vi, ui]:
+                    depth_buf[vi, ui] = di
+                    rgb_buf[vi, ui] = col_v[idx]
+        else:
+            for idx in order:
+                vi, ui, di = int(v_i[idx]), int(u_i[idx]), float(dist_v[idx])
+                if not np.isfinite(di):
+                    continue
+                v0 = max(0, vi - radius)
+                v1 = min(height, vi + radius + 1)
+                u0 = max(0, ui - radius)
+                u1 = min(width, ui + radius + 1)
+                region = depth_buf[v0:v1, u0:u1]
+                mask = di < region
+                region[mask] = di
+                depth_buf[v0:v1, u0:u1] = region
+                rgb_region = rgb_buf[v0:v1, u0:u1]
+                rgb_region[mask] = col_v[idx]
+                rgb_buf[v0:v1, u0:u1] = rgb_region
+
+    depth_out = np.where(np.isfinite(depth_buf), depth_buf, 0.0).astype(np.float32)
+
+    # ── 空洞填充：迭代最近邻复制，每轮向外扩 1 像素，不修改已有有效像素 ──────
+    if faces is not None and len(faces) > 0:
+        hole_mask = (depth_out == 0)  # True=空洞
+        if hole_mask.any():
+            kernel = np.ones((3, 3), np.uint8)
+            valid_u8 = (~hole_mask).astype(np.uint8)
+            for _ in range(32):
+                if not hole_mask.any():
+                    break
+                dilated_valid = cv2.dilate(valid_u8, kernel)
+                newly = hole_mask & (dilated_valid > 0)
+                if not newly.any():
+                    break
+                for c in range(3):
+                    src = rgb_buf[:, :, c]
+                    # dilate 在 valid 区域的颜色，传播到邻近空洞（取邻域最大值近似最近邻）
+                    expanded = cv2.dilate(src * valid_u8, kernel)
+                    rgb_buf[:, :, c] = np.where(newly, expanded, src)
+                hole_mask[newly] = False
+                valid_u8[newly] = 1
+
+    return rgb_buf, depth_out
+
+
+def _extract_ply_colors(mesh_or_pc) -> Optional[np.ndarray]:
+    """尝试从 trimesh 对象中提取顶点颜色 (N,3) uint8"""
+    try:
+        if isinstance(mesh_or_pc, trimesh.Trimesh):
+            if mesh_or_pc.visual is not None:
+                if hasattr(mesh_or_pc.visual, 'vertex_colors'):
+                    vc = mesh_or_pc.visual.vertex_colors
+                    if vc is not None and len(vc) > 0:
+                        return np.array(vc[:, :3], dtype=np.uint8)
+        elif isinstance(mesh_or_pc, trimesh.PointCloud):
+            if mesh_or_pc.colors is not None and len(mesh_or_pc.colors) > 0:
+                return np.array(mesh_or_pc.colors[:, :3], dtype=np.uint8)
+    except Exception as e:
+        print(f"  [WARN] 提取颜色失败: {e}")
+    return None
+
+
+def save_pose(cam_pos_yup: list, cam_rot_euler: list,
+              output_path: str, frame_id: int):
+    """保存位姿 JSON（ERPT 格式，Y-up 坐标系，cam_to_world）
+
+    cam_pos_yup: [x, y, z]，Y-up 世界坐标（已是 ERPT_native）
+    cam_rot_euler: [rx, ry, rz] 弧度，XYZ 顺序
+    """
+    R_cw = _euler_to_rotation_matrix(*cam_rot_euler)
+
+    # 旋转矩阵 → 四元数（XYZW 顺序，转为 WXYZ）
+    # Shepperd 方法
+    m = R_cw
+    t = m[0, 0] + m[1, 1] + m[2, 2]
+    if t > 0:
+        s = 0.5 / math.sqrt(t + 1.0)
+        w = 0.25 / s
+        x = (m[2, 1] - m[1, 2]) * s
+        y = (m[0, 2] - m[2, 0]) * s
+        z = (m[1, 0] - m[0, 1]) * s
+    elif m[0, 0] > m[1, 1] and m[0, 0] > m[2, 2]:
+        s = 2.0 * math.sqrt(1.0 + m[0, 0] - m[1, 1] - m[2, 2])
+        w = (m[2, 1] - m[1, 2]) / s
+        x = 0.25 * s
+        y = (m[0, 1] + m[1, 0]) / s
+        z = (m[0, 2] + m[2, 0]) / s
+    elif m[1, 1] > m[2, 2]:
+        s = 2.0 * math.sqrt(1.0 + m[1, 1] - m[0, 0] - m[2, 2])
+        w = (m[0, 2] - m[2, 0]) / s
+        x = (m[0, 1] + m[1, 0]) / s
+        y = 0.25 * s
+        z = (m[1, 2] + m[2, 1]) / s
+    else:
+        s = 2.0 * math.sqrt(1.0 + m[2, 2] - m[0, 0] - m[1, 1])
+        w = (m[1, 0] - m[0, 1]) / s
+        x = (m[0, 2] + m[2, 0]) / s
+        y = (m[1, 2] + m[2, 1]) / s
+        z = 0.25 * s
+
+    pose_data = {
+        "frame_id": frame_id,
+        "position": [float(v) for v in cam_pos_yup],
+        "rotation_quaternion": [float(w), float(x), float(y), float(z)],
+        "camera_type": "erp_ray",
+        "coordinate_system": "right-handed, Y-up, Z-forward (cam_to_world)",
+        "render_method": "ply_erp",
+    }
+    with open(output_path, 'w') as f:
+        json.dump(pose_data, f, indent=2)
+
+
+def build_ray_directions(H=WARP_H, W=WARP_W):
+    """ERP 射线方向（Y-up 坐标系）"""
+    i = np.arange(H, dtype=np.float64)
+    j = np.arange(W, dtype=np.float64)
+    lat = np.pi / 2 - np.pi * (i + 0.5) / H   # [-π/2, π/2]
+    lon = 2 * np.pi * (j + 0.5) / W             # [0, 2π]
+    lat, lon = np.meshgrid(lat, lon, indexing='ij')
+    r_xz = np.cos(lat)
+    return np.stack([
+        r_xz * np.sin(lon),   # X
+        np.sin(lat),           # Y (up)
+        r_xz * np.cos(lon),   # Z (front)
+    ], axis=-1)
+
+
+_ray_dirs_cache = {}
+
+
+def get_ray_dirs(H=WARP_H, W=WARP_W):
+    if (H, W) not in _ray_dirs_cache:
+        _ray_dirs_cache[(H, W)] = build_ray_directions(H, W)
+    return _ray_dirs_cache[(H, W)]
+
+
+def depth_to_3d_points(position, depth, ray_dirs, max_depth=None):
+    valid = depth > 0
+    if max_depth is not None:
+        valid &= (depth <= max_depth)
+    if not np.any(valid):
+        return np.empty((0, 3), dtype=np.float64)
+    pos = np.array(position, dtype=np.float64)
+    return (pos + ray_dirs * depth[..., np.newaxis])[valid]
+
+
+def project_points_to_coverage(pts, tgt_pos, H=WARP_H, W=WARP_W):
+    if len(pts) == 0:
+        return np.zeros((H, W), dtype=bool)
+    tgt = np.array(tgt_pos, dtype=np.float64)
+    vecs = pts - tgt
+    x, y, z = vecs[:, 0], vecs[:, 1], vecs[:, 2]
+    r_xz = np.sqrt(x ** 2 + z ** 2)
+    lat = np.arctan2(y, r_xz)
+    lon = np.arctan2(x, z) % (2 * np.pi)
+    vi = np.clip(((np.pi / 2 - lat) / np.pi * H).astype(np.int32), 0, H - 1)
+    uj = np.clip((lon / (2 * np.pi) * W).astype(np.int32), 0, W - 1)
+    cov = np.zeros((H, W), dtype=bool)
+    cov[vi, uj] = True
+    pad = cov.copy()
+    pad[1:, :] |= cov[:-1, :]
+    pad[:-1, :] |= cov[1:, :]
+    pad[:, 1:] |= cov[:, :-1]
+    pad[:, :-1] |= cov[:, 1:]
+    return pad
+
+
+def select_next_frame(candidates, selected_idx, selected_pos, all_pts,
+                      reachable=None):
+    n = len(candidates)
+    H, W = WARP_H, WARP_W
+    total_px = H * W
+    overlap_penalty = DEFAULT_OVERLAP_PENALTY
+
+    remaining = []
+    for i in range(n):
+        if i in selected_idx:
+            continue
+        if reachable is not None and i not in reachable:
+            continue
+        remaining.append(i)
+
+    if not remaining:
+        return -1, 0.0, -999.0, 0
+
+    scores = {}
+    for ci in remaining:
+        cov = project_points_to_coverage(all_pts, candidates[ci], H, W)
+        covered = int(np.sum(cov))
+        new_r = (total_px - covered) / total_px
+        ovl_r = covered / total_px
+        scores[ci] = {
+            "gain": new_r,
+            "overlap": ovl_r,
+            "score": new_r - overlap_penalty * ovl_r,
+        }
+
+    best_ci, best_sc, best_g = -1, -999.0, 0.0
+    for ci in remaining:
+        if scores[ci]["score"] > best_sc:
+            best_sc = scores[ci]["score"]
+            best_ci = ci
+            best_g = scores[ci]["gain"]
+
+    return best_ci, best_g, best_sc, len(remaining)
+
+
+def compute_max_depth(candidates):
+    pos_arr = np.array(candidates)
+    diag = float(np.linalg.norm(pos_arr.max(0) - pos_arr.min(0)))
+    return diag * 1.5
+
+
+def load_depth_downsampled(path, H=WARP_H, W=WARP_W):
+    d = np.load(path).astype(np.float32)
+    d = np.nan_to_num(d, nan=0.0)
+    if d.shape == (H, W):
+        return d
+    try:
+        return cv2.resize(d, (W, H), interpolation=cv2.INTER_AREA)
+    except Exception:
+        h, w = d.shape
+        bh, bw = h // H, w // W
+        if bh < 1 or bw < 1:
+            r = np.zeros((H, W), dtype=np.float32)
+            r[:min(h, H), :min(w, W)] = d[:min(h, H), :min(w, W)]
+            return r
+        return d[:bh * H, :bw * W].reshape(H, bh, W, bw).mean(axis=(1, 3))
+
+
+def trim_depth(new_depth, new_pos, existing_pts, ray_dirs):
+    n_orig = int(np.sum(new_depth > 0))
+    if len(existing_pts) == 0:
+        return new_depth.copy(), n_orig, n_orig
+    cov = project_points_to_coverage(existing_pts, new_pos,
+                                     new_depth.shape[0], new_depth.shape[1])
+    trimmed = new_depth.copy()
+    trimmed[cov] = 0
+    return trimmed, n_orig, int(np.sum(trimmed > 0))
+
+
+def update_reachability(current_pos: np.ndarray, candidates, selected_idx,
+                        reachable: set, raycaster: RayCaster):
+    """从当前位置出发，检测哪些候选点可达（无遮挡直线视线）"""
+    if raycaster._intersector is None:
+        # 非 Mesh：所有候选都"可达"
+        for ci, c in enumerate(candidates):
+            if ci not in selected_idx:
+                reachable.add(ci)
+        return 0
+
+    n_new = 0
+    for ci, cand in enumerate(candidates):
+        if ci in selected_idx or ci in reachable:
+            continue
+        target = np.array(cand, dtype=np.float64)
+        dist_to_target = float(np.linalg.norm(target - current_pos))
+        if dist_to_target < 0.1:
+            reachable.add(ci)
+            n_new += 1
+            continue
+        direction = (target - current_pos) / dist_to_target
+        hit, hit_dist = raycaster.cast_ray(current_pos, direction)
+        if not hit or hit_dist >= dist_to_target * 0.95:
+            reachable.add(ci)
+            n_new += 1
+
+    return n_new
+
+
+def run_phase2(pts_world: np.ndarray,
+               colors_world,
+               faces,
+               candidates,
+               mesh_center,
+               raycaster: RayCaster,
+               output_dir: str,
+               max_frames: int,
+               resolution,
+               args):
+    """边选帧边渲染主循环（PLY 版本，逻辑与 Blender 版本对齐）"""
+    W_render, H_render = resolution
+    ray_dirs = get_ray_dirs(WARP_H, WARP_W)
+    max_depth = compute_max_depth(candidates)
+
+    selected_idx = set()
+    selected_pos = []
+    all_pts = np.empty((0, 3), dtype=np.float64)
+    pts_chunks = []
+    results = []
+    reachable = set()
+
+    stop_score = args.stop_score
+    stop_delta = args.stop_delta
+    min_frames = args.min_frames
+
+    ACTUAL_GAIN_WINDOW = 3
+    ACTUAL_GAIN_FLOOR = args.stop_gain
+    actual_gain_history = []
+    delta_history = []
+
+    # ── 异步 I/O 线程池：写盘与 GPU 渲染并行 ─────────────────────────────
+    _io_executor = ThreadPoolExecutor(max_workers=2)
+    _pending_io  = []   # list of Future，用于等待上一帧写盘完成
+
+    def _save_frame_async(rgb, depth, rgb_path, depth_npy, pos, cam_rot,
+                          pose_path, frame_id):
+        """在线程池中异步保存 PNG + npy + json"""
+        def _do_save():
+            cv2.imwrite(rgb_path, cv2.cvtColor(rgb, cv2.COLOR_RGB2BGR))
+            np.save(depth_npy, depth.astype(np.float32))
+            save_pose(pos, cam_rot, pose_path, frame_id)
+        return _io_executor.submit(_do_save)
+    consecutive_skips = 0
+    MAX_CONSECUTIVE_SKIPS = 3
+
+    # 楼层分组（按 Y 坐标聚类）
+    y_vals = sorted(set(round(c[1], 2) for c in candidates))
+    floors = [[y_vals[0]]]
+    for y in y_vals[1:]:
+        if y - floors[-1][-1] > 1.0:
+            floors.append([y])
+        else:
+            floors[-1].append(y)
+
+    n_floors = len(floors)
+    floor_mids = [sum(f) / len(f) for f in floors]
+    candidate_floor = [
+        min(range(n_floors), key=lambda i: abs(c[1] - floor_mids[i]))
+        for c in candidates
+    ]
+    current_floor = 0
+
+    def floor_set(fi):
+        return set(i for i, f in enumerate(candidate_floor) if f == fi)
+
+    floor_names = [f"楼层{i+1}(Y={min(f):.1f}~{max(f):.1f})" for i, f in enumerate(floors)]
+
+    print(f"\n{'='*60}")
+    print(f"[Phase 2] 边渲边选 (候选={len(candidates)}, 最多={max_frames}帧)")
+    print(f"{'='*60}")
+    print(f"  {n_floors} 个楼层: {floor_names}")
+
+    t_total = time.time()
+    time_select = time_render = time_depth = time_reach = 0.0
+
+    for frame_count in range(max_frames):
+
+        # ---- 选位置 ----
+        t_sel = time.time()
+        if frame_count == 0:
+            floor0_cands = [(i, c) for i, c in enumerate(candidates)
+                            if candidate_floor[i] == 0]
+            if floor0_cands:
+                f0_pts = np.array([c for _, c in floor0_cands])
+                xz_center = np.array([f0_pts[:, 0].mean(), f0_pts[:, 2].mean()])
+                floor0_ys = sorted(set(c[1] for _, c in floor0_cands))
+                y_target = min(floor0_ys) + 1.2
+                target = np.array([xz_center[0], y_target, xz_center[1]])
+                dists = [np.linalg.norm(np.array(c) - target)
+                         for _, c in floor0_cands]
+                ci = floor0_cands[int(np.argmin(dists))][0]
+            else:
+                mc = np.array(mesh_center, dtype=np.float64)
+                ci = int(np.argmin([np.linalg.norm(np.array(c) - mc)
+                                    for c in candidates]))
+            gain, score = 1.0, 1.0
+            print(f"\n  F{frame_count}: 选候选[{ci}] (楼层中心, Y={candidates[ci][1]:.2f}m) "
+                  f"[{floor_names[current_floor]}]")
+        else:
+            cur_floor_ids = floor_set(current_floor)
+            floor_reachable = reachable & cur_floor_ids if reachable else set()
+
+            ci, gain, score, n_remain = select_next_frame(
+                candidates, selected_idx, selected_pos, all_pts,
+                reachable=floor_reachable if floor_reachable else cur_floor_ids)
+
+            expand = False
+            if ci < 0 or score < stop_score:
+                ci2, gain2, score2, n2 = select_next_frame(
+                    candidates, selected_idx, selected_pos, all_pts,
+                    reachable=cur_floor_ids)
+                if ci2 >= 0 and (ci < 0 or score2 > score):
+                    ci, gain, score, n_remain = ci2, gain2, score2, n2
+                    expand = True
+
+            if ci < 0 or (score < stop_score and gain < ACTUAL_GAIN_FLOOR):
+                reason = "无可选候选" if ci < 0 else f"gain={gain:.1%} score={score:.3f}"
+                current_floor += 1
+                if current_floor < n_floors:
+                    print(f"\n  F{frame_count}: {reason}"
+                          f" → 切换到 {floor_names[current_floor]}")
+                    continue
+                else:
+                    print(f"\n  F{frame_count}: {reason} → 所有楼层拍满，停止")
+                    break
+
+            tag = "[扩展]" if expand else ""
+            print(f"\n  F{frame_count}: 选候选[{ci}]  "
+                  f"gain={gain:.1%}  score={score:.3f}  剩余={n_remain}"
+                  f"  [Y={candidates[ci][1]:.2f} {floor_names[current_floor]}]{tag}")
+
+        pos = candidates[ci]
+        selected_idx.add(ci)
+        selected_pos.append(pos)
+        dt_sel = time.time() - t_sel
+        time_select += dt_sel
+
+        # ---- 渲染（GPU 共享场景数据，减少重复上传）----
+        cam_rot = get_camera_rot(args.rotation_type, frame_count)
+        base = f"panorama_{frame_count:04d}"
+        rgb_path = os.path.join(output_dir, f"{base}.png")
+        depth_npy = os.path.join(output_dir, f"{base}_depth.npy")
+        pose_path = os.path.join(output_dir, f"pose_{frame_count:04d}.json")
+
+        print(f"    位置: [{pos[0]:.2f}, {pos[1]:.2f}, {pos[2]:.2f}]")
+        print(f"    渲染...", end="", flush=True)
+        t_r = time.time()
+
+        # 等待上一帧异步 I/O 完成（保证不超过 2 帧待写）
+        while len(_pending_io) >= 2:
+            _pending_io.pop(0).result()
+
+        # 使用 render_erp_batch_gpu：场景数据只上传一次
+        batch_results = render_erp_batch_gpu(
+            pts_world, colors_world,
+            cam_poses=[pos],
+            cam_rots=[cam_rot],
+            width=W_render,
+            height=H_render,
+            faces=faces,
+            point_size=args.point_size,
+        )
+        rgb, depth = batch_results[0]
+
+        # 异步写盘（与下一帧 GPU 渲染并行）
+        fut = _save_frame_async(
+            rgb, depth, rgb_path, depth_npy,
+            pos, cam_rot, pose_path, frame_count)
+        _pending_io.append(fut)
+
+        dt_r = time.time() - t_r
+        time_render += dt_r
+        print(f" {dt_r:.1f}s")
+
+        # ---- depth → 3D 点云 ----
+        t_dep = time.time()
+        actual_gain = 1.0
+        delta_ratio = 1.0
+
+        # 直接使用内存中的 depth（depth_npy 由异步线程写入，可能尚未落盘）
+        _d = depth.astype(np.float32)
+        _d = np.nan_to_num(_d, nan=0.0)
+        if _d.shape == (WARP_H, WARP_W):
+            depth_small = _d
+        else:
+            try:
+                depth_small = cv2.resize(_d, (WARP_W, WARP_H), interpolation=cv2.INTER_AREA)
+            except Exception:
+                h, w = _d.shape
+                bh, bw = h // WARP_H, w // WARP_W
+                if bh < 1 or bw < 1:
+                    depth_small = np.zeros((WARP_H, WARP_W), dtype=np.float32)
+                    depth_small[:min(h, WARP_H), :min(w, WARP_W)] = _d[:min(h, WARP_H), :min(w, WARP_W)]
+                else:
+                    depth_small = _d[:bh*WARP_H, :bw*WARP_W].reshape(WARP_H, bh, WARP_W, bw).mean(axis=(1, 3))
+        total_px = WARP_H * WARP_W
+        n_valid = int(np.sum(depth_small > 0))
+        valid_ratio = n_valid / total_px
+
+        if frame_count == 0:
+            new_pts = depth_to_3d_points(pos, depth_small, ray_dirs, max_depth)
+            pts_chunks.append(new_pts)
+            all_pts = new_pts
+            actual_gain = valid_ratio
+            print(f"    depth: {n_valid}px ({valid_ratio:.0%} 有效)"
+                  f" → {len(new_pts)} 个 3D 点 (全部)")
+        else:
+            MIN_VALID_RATIO = 0.10   # PLY 点云空洞较多，阈值适当降低
+            if valid_ratio < MIN_VALID_RATIO:
+                print(f"    depth: {n_valid}px ({valid_ratio:.0%} 有效) < "
+                      f"{MIN_VALID_RATIO:.0%} → 跳过此帧")
+                results.append({
+                    "frame_id": frame_count,
+                    "candidate_idx": ci,
+                    "position": pos,
+                    "gain": float(gain),
+                    "actual_gain": 0.0,
+                    "delta_ratio": 0.0,
+                    "score": float(score),
+                    "skipped": True,
+                    "skip_reason": f"valid_ratio={valid_ratio:.1%}",
+                })
+                for fp in [rgb_path, depth_npy]:
+                    if os.path.exists(fp):
+                        try:
+                            os.remove(fp)
+                        except OSError:
+                            pass
+                consecutive_skips += 1
+                if consecutive_skips >= MAX_CONSECUTIVE_SKIPS:
+                    current_floor += 1
+                    consecutive_skips = 0
+                    if current_floor < n_floors:
+                        print(f"    连续 {MAX_CONSECUTIVE_SKIPS} 帧空洞"
+                              f" → 切换到 {floor_names[current_floor]}")
+                    else:
+                        print(f"    连续 {MAX_CONSECUTIVE_SKIPS} 帧空洞，停止")
+                        break
+                time_depth += time.time() - t_dep
+                continue
+
+            trimmed, n_orig, n_new = trim_depth(depth_small, pos, all_pts, ray_dirs)
+            new_pts = depth_to_3d_points(pos, trimmed, ray_dirs, max_depth)
+            pts_chunks.append(new_pts)
+            all_pts = np.concatenate(pts_chunks)
+            actual_gain = n_new / total_px
+            delta_ratio = len(new_pts) / len(all_pts) if len(all_pts) > 0 else 1.0
+            print(f"    depth: {n_valid}px ({valid_ratio:.0%} 有效)"
+                  f" → trim → {n_new}px 新增 → {len(new_pts)} 个新 3D 点")
+            print(f"    累积点云: {len(all_pts)}, 实际gain: {actual_gain:.1%}")
+            consecutive_skips = 0
+
+        time_depth += time.time() - t_dep
+
+        results.append({
+            "frame_id": frame_count,
+            "candidate_idx": ci,
+            "position": pos,
+            "gain": float(gain),
+            "actual_gain": float(actual_gain),
+            "delta_ratio": float(delta_ratio),
+            "score": float(score),
+        })
+
+        # ---- 可达性更新 ----
+        t_reach = time.time()
+        n_new_r = update_reachability(
+            np.array(pos), candidates, selected_idx, reachable, raycaster)
+        dt_reach = time.time() - t_reach
+        time_reach += dt_reach
+        print(f"    [可达性] 新增 {n_new_r} 个，总 {len(reachable)}/{len(candidates)} "
+              f"({dt_reach:.1f}s)")
+
+        # ---- 停止条件 ----
+        if frame_count > 0:
+            actual_gain_history.append(actual_gain)
+            delta_history.append(delta_ratio)
+
+        if frame_count > 0 and frame_count >= min_frames:
+            if len(actual_gain_history) >= ACTUAL_GAIN_WINDOW:
+                recent_gain = actual_gain_history[-ACTUAL_GAIN_WINDOW:]
+                recent_delta = delta_history[-ACTUAL_GAIN_WINDOW:]
+                gain_exhausted = all(g < ACTUAL_GAIN_FLOOR for g in recent_gain)
+                delta_exhausted = all(d < stop_delta for d in recent_delta)
+
+                if gain_exhausted or delta_exhausted:
+                    current_floor += 1
+                    if current_floor < n_floors:
+                        reason = (f"gain<{ACTUAL_GAIN_FLOOR:.0%}" if gain_exhausted
+                                  else f"delta<{stop_delta:.0%}")
+                        print(f"    连续 {ACTUAL_GAIN_WINDOW} 帧 {reason}"
+                              f" → 切换到 {floor_names[current_floor]}")
+                    else:
+                        print(f"    所有楼层拍满，停止")
+                        break
+
+    # 补帧：确保 4n+1
+    while len(results) > 1 and (len(results) - 1) % 4 != 0:
+        frame_count = results[-1]["frame_id"] + 1
+        if frame_count >= max_frames + 3:
+            break
+        print(f"\n  [补帧] 当前 {len(results)} 帧，需补至 4n+1")
+        ci, gain, score, n_remain = select_next_frame(
+            candidates, selected_idx, selected_pos, all_pts, reachable=None)
+        if ci < 0:
+            break
+
+        pos = candidates[ci]
+        selected_idx.add(ci)
+        selected_pos.append(pos)
+
+        cam_rot = get_camera_rot(args.rotation_type, frame_count)
+        base = f"panorama_{frame_count:04d}"
+        rgb_path = os.path.join(output_dir, f"{base}.png")
+        depth_npy = os.path.join(output_dir, f"{base}_depth.npy")
+
+        batch_res = render_erp_batch_gpu(
+            pts_world, colors_world,
+            cam_poses=[pos], cam_rots=[cam_rot],
+            width=W_render, height=H_render,
+            faces=faces, point_size=args.point_size,
+        )
+        rgb, depth = batch_res[0]
+        try:
+            cv2.imwrite(rgb_path, cv2.cvtColor(rgb, cv2.COLOR_RGB2BGR))
+        except Exception:
+            from PIL import Image
+            Image.fromarray(rgb).save(rgb_path)
+        np.save(depth_npy, depth.astype(np.float32))
+        save_pose(pos, cam_rot, os.path.join(output_dir, f"pose_{frame_count:04d}.json"),
+                  frame_count)
+
+        depth_small = load_depth_downsampled(depth_npy, WARP_H, WARP_W)
+        trimmed, n_orig, n_new = trim_depth(depth_small, pos, all_pts, ray_dirs)
+        new_pts = depth_to_3d_points(pos, trimmed, ray_dirs, max_depth)
+        pts_chunks.append(new_pts)
+        all_pts = np.concatenate(pts_chunks)
+        actual_gain = n_new / total_px
+        results.append({
+            "frame_id": frame_count,
+            "candidate_idx": ci,
+            "position": pos,
+            "gain": float(gain),
+            "actual_gain": float(actual_gain),
+            "delta_ratio": float(len(new_pts) / max(len(all_pts), 1)),
+            "score": float(score),
+            "supplementary": True,
+        })
+        print(f"    补帧 F{frame_count}: gain={actual_gain:.1%}")
+
+    # ── 等待所有异步 I/O 完成，关闭线程池 ────────────────────────────────
+    for fut in _pending_io:
+        try:
+            fut.result()
+        except Exception as e:
+            print(f"  [WARN] 异步写盘失败: {e}")
+    _io_executor.shutdown(wait=False)
+
+    dt = time.time() - t_total
+    print(f"\n  {'─'*50}")
+    print(f"  共 {len(results)} 帧, {dt:.1f}s ({dt/60:.1f}min)")
+    print(f"  耗时: 选帧={time_select:.1f}s  渲染={time_render:.1f}s  "
+          f"深度={time_depth:.1f}s  可达={time_reach:.1f}s")
+    return results
+
+
+def main():
+    args = parse_args()
+
+    ply_path = str(Path(args.ply).resolve())
+    output_dir = str(Path(args.output_dir).resolve())
+    resolution = tuple(int(x) for x in args.resolution.split(","))
+    os.makedirs(output_dir, exist_ok=True)
+    sel_dir = os.path.join(output_dir, "frame_selection")
+    os.makedirs(sel_dir, exist_ok=True)
+
+    print("=" * 60)
+    print("ERPT PLY Pipeline（边渲边选）")
+    print("=" * 60)
+    print(f"  PLY:        {ply_path}")
+    print(f"  Output:     {output_dir}")
+    print(f"  Max frames: {args.num_frames}")
+    print(f"  Resolution: {resolution[0]}x{resolution[1]}")
+    t_start = time.time()
+
+    # ===== Phase 0: 加载场景 =====
+    mesh_obj, pts_world, bmin, bmax, is_mesh, faces = load_ply_scene(
+        ply_path, z_up=args.z_up)
+
+    # 提取颜色
+    colors_world = _extract_ply_colors(mesh_obj)
+    if colors_world is not None:
+        print(f"  颜色: {len(colors_world)} 个顶点颜色")
+    else:
+        print(f"  颜色: 无顶点颜色，使用深度伪彩")
+
+    # 构建射线检测器
+    raycaster = RayCaster(mesh_obj, pts_world, bmin, bmax, is_mesh, z_up=args.z_up)
+
+    # ===== Phase 1: 撒点 + 过滤 =====
+    print(f"\n{'='*60}")
+    print("[Phase 1] 多层撒点 + 7 层过滤")
+    print(f"{'='*60}")
+
+    # Y-up 坐标系：Y=高度，floor=bmin[1]，ceiling=bmax[1]
+    floor_y = float(bmin[1])
+    ceiling_y = float(bmax[1])
+    print(f"  场景 Y 范围: {floor_y:.2f} ~ {ceiling_y:.2f}m (总高 {ceiling_y-floor_y:.2f}m)")
+
+    heights = compute_camera_heights(floor_y, ceiling_y, args.camera_height)
+    print(f"  相机高度层: {[f'{h:.2f}m' for h in heights]}")
+
+    x_range = float(bmax[0] - bmin[0])
+    z_range = float(bmax[2] - bmin[2])
+    x_sp = args.grid_spacing
+    z_sp = args.grid_spacing
+
+    # 候选点过多时自适应增大间距
+    n_xy = max(1, int((x_range - 2 * MARGIN) / x_sp)) * \
+           max(1, int((z_range - 2 * MARGIN) / z_sp))
+    total_est = n_xy * len(heights)
+    if total_est > 10000:
+        scale = math.sqrt(total_est / 10000)
+        x_sp = min(x_sp * scale, x_range / 4)
+        z_sp = min(z_sp * scale, z_range / 4)
+        print(f"  [自适应] 候选≈{total_est}个，间距调整为 X={x_sp:.1f}m Z={z_sp:.1f}m")
+
+    candidates = generate_candidate_grid(bmin, bmax, x_sp, z_sp, heights)
+    if not candidates:
+        print("  [Error] 没有候选点")
+        sys.exit(1)
+
+    room_height = ceiling_y - floor_y
+    candidates = raycast_filter(candidates, raycaster, room_height)
+    if not candidates:
+        print("  [Warning] 全部被过滤，使用 AABB 中心")
+        cx = float((bmin[0] + bmax[0]) / 2)
+        cy = float(heights[0])
+        cz = float((bmin[2] + bmax[2]) / 2)
+        candidates = [[cx, cy, cz]]
+
+    np.save(os.path.join(sel_dir, "candidates_filtered.npy"),
+            np.array(candidates))
+    print(f"  最终候选点: {len(candidates)} 个")
+
+    mesh_center = [
+        float((bmin[0] + bmax[0]) / 2),
+        float((bmin[1] + bmax[1]) / 2),
+        float((bmin[2] + bmax[2]) / 2),
+    ]
+
+    # ===== Phase 2: 边渲边选 =====
+    results = run_phase2(
+        pts_world=pts_world,
+        colors_world=colors_world,
+        faces=faces,
+        candidates=candidates,
+        mesh_center=mesh_center,
+        raycaster=raycaster,
+        output_dir=output_dir,
+        max_frames=args.num_frames,
+        resolution=resolution,
+        args=args,
+    )
+
+    # ===== 保存选帧摘要 =====
+    summary = {
+        "scene": os.path.basename(ply_path),
+        "total_frames": len(results),
+        "candidates_count": len(candidates),
+        "frames": [{
+            "frame_id": r["frame_id"],
+            "position": r["position"],
+            "gain": r["gain"],
+            "actual_gain": r["actual_gain"],
+            "delta_ratio": r["delta_ratio"],
+            "score": r["score"],
+        } for r in results if not r.get("skipped")],
+    }
+    with open(os.path.join(sel_dir, "selected_frames.json"), "w") as f:
+        json.dump(summary, f, indent=2, ensure_ascii=False)
+
+    dt = time.time() - t_start
+    print(f"\n{'='*60}")
+    print(f"完成! {len(results)} 帧, {dt:.1f}s ({dt/60:.1f}min)")
+    print(f"{'='*60}")
+    print(f"输出目录: {output_dir}/")
+    for r in results:
+        if not r.get("skipped"):
+            fid = r["frame_id"]
+            print(f"  panorama_{fid:04d}.png  +  _depth.npy  +  pose_{fid:04d}.json")
+
+
+if __name__ == "__main__":
+    main()

adapters/tartanground/README.md

@@ -0,0 +1,37 @@
+# TartanGround adapter — CM-EVS (re-encoding only)
+
+TartanGround is the outdoor source providing the largest depth dynamic range in CM-EVS. Like OB3D, this adapter only **re-encodes** upstream cubemap trajectories into the unified ERP + world-to-camera pose schema. The curator does **not** run on TartanGround in v1.0.
+
+> **License notice**: TartanGround / TartanAir typically ships under licenses (e.g. CC-BY-NC-SA) that **forbid redistribution of derived RGB-D frames**. This adapter package therefore contains zero TartanGround-derived imagery — only the re-encoding script + the list of trajectory IDs the paper runs over. See `../../LICENSE.md`.
+
+## Files
+
+- `config.yaml` — re-encoding parameters. Some fields are **placeholders** to be finalized; see `../../TODO.md`.
+- `reencoding_script.md` — exact command + expected upstream layout (cubemap face directories, depth as 1-of-10 frames, pose CSV / JSON format) + output schema.
+- `metadata/source_manifest.json` — list of 762 trajectory parts the paper's evaluation runs over. Note: paper §4.3 Table 4 reports the target as "63 environments / 783,944 frames"; the H100-side data CM-EVS was developed against currently has **11 environments / 762 parts**, with the remaining environments held offline. The full target will be reached as the upstream coverage is expanded — see `../../TODO.md`.
+
+## Reproducing the paper's TartanGround frames
+
+1. Obtain TartanGround source data per its upstream license (typically academic-only, non-commercial).
+2. Place under `data/tartanground/<env_name>-Data_<diff|omni>-P<XXXX>-part<N>/...` matching the layout in `reencoding_script.md`.
+3. Run the re-encoder:
+   ```bash
+   cd ../../code
+   python scripts/reencode_outdoor.py --source tartanground --config ../adapters/tartanground/config.yaml
+   ```
+4. Outputs land in `outputs/tartanground/<env_name>-...-part<N>/{rgb, depth, pose}/...` under the unified schema.
+
+## What the re-encoding does
+
+- **Cubemap → ERP** at the source's native resolution (2048×1024 per paper §4.3 Table 4).
+- **Pose unification**: rewrite original axis convention into right-handed `+X`-right `+Y`-up `+Z`-forward world frame; pose stored as scalar-first `q_wc = [w, x, y, z]` plus position relative to trajectory first frame.
+- **Trajectory partitioning**: each upstream trajectory is sliced into ~200-frame parts; the leftover partial part at the end is folded into the previous part. Part boundaries appear in the directory name as `part0, part1, …`.
+- **Sparse depth**: TartanGround upstream ships depth on a 1-of-10 frame subsample. Depth NPYs only exist for those frames; for other frames `panorama_NNNN_depth.npy` is absent.
+
+See paper §3.4 (Table 2 row "TartanGround") and §4.3 (Table 4 — outdoor / TartanGround row).
+
+## License
+
+- This adapter code: **MIT**.
+- Frames you produce by re-encoding TartanGround data: bound by the **upstream TartanGround / TartanAir license** (typically CC-BY-NC-SA or similar non-commercial). The MIT license on the adapter does **not** override upstream terms.
+- The `metadata/source_manifest.json` itself lists trajectory IDs only; before redistributing or quoting it verbatim, check whether the upstream license permits sharing IDs.

adapters/tartanground/config.yaml

@@ -0,0 +1,43 @@
+# TartanGround outdoor re-encoding adapter — CM-EVS
+#
+# Placeholder reflecting paper §3.4 (Table 2 row "TartanGround"). Concrete
+# parameters (cubemap face size, source axis convention, depth subsampling
+# stride) are tracked in TODO.md and will be finalized before HF push.
+
+experiment:
+  source: tartanground
+  input_kind: cubemap_dense_trajectory   # TartanGround upstream ships dense cubemap
+
+reencoding:
+  input_dir: data/tartanground
+  output_root: outputs/tartanground
+
+  # Source cubemap face size — TartanGround typically 1024×1024 per face. Confirm.
+  cubemap_face_size: TODO
+
+  # Final ERP resolution — paper §4.3 Table 4 lists TartanGround at 2048×1024.
+  erp_resolution: "2048,1024"
+
+  pose_format: world_to_camera_quaternion
+  source_axis_convention: TODO              # confirm from TartanGround upstream
+  target_axis_convention: y-up_z-forward    # CM-EVS world frame
+
+  depth_format: range
+  depth_unit: meters
+  invalid_marker: nan
+  # TartanGround upstream ships depth on a 1-of-10 frame subsample. The
+  # re-encoder respects this — depth NPYs only exist for the subsampled frames.
+  depth_subsample_stride: 10
+
+  # Trajectory slicing — TartanGround trajectories are long (often >2000 frames).
+  # The paper splits each trajectory into ~200-frame parts; leftover folds into
+  # the last part.
+  trajectory_partition: true
+  partition_size: 200
+
+  emit_meta_json: true
+  emit_per_step_log: false                  # curator does not run on outdoor in v1.0
+
+# Source manifest (which trajectory parts to re-encode):
+# see metadata/source_manifest.json (762 parts across 11 environments — paper
+# target is 63 environments; remaining environments held offline)

adapters/tartanground/metadata/source_manifest.json

@@ -0,0 +1,800 @@
+{
+  "source": "tartanground",
+  "label": "TartanGround",
+  "description": "Outdoor source. Re-encoding adapter only — no curator selection. H100 currently holds 11 environments / 762 trajectory parts; the paper target is 63 environments / 783,944 frames (remaining environments held offline).",
+  "license": "MIT (code) + per upstream TartanGround / TartanAir license (typically CC-BY-NC-SA)",
+  "release_policy": "frames produced by re-encoding remain under upstream license; non-commercial use only typical",
+  "id_field": "trajectory_part_id",
+  "id_count": 762,
+  "ids": [
+    "AbandonedCable-Data_diff-P1000-part1",
+    "AbandonedCable-Data_diff-P1000-part2",
+    "AbandonedCable-Data_diff-P1000-part3",
+    "AbandonedCable-Data_diff-P1001-part1",
+    "AbandonedCable-Data_diff-P1001-part2",
+    "AbandonedCable-Data_diff-P1001-part3",
+    "AbandonedCable-Data_diff-P1001-part4",
+    "AbandonedCable-Data_diff-P1002-part1",
+    "AbandonedCable-Data_diff-P1002-part2",
+    "AbandonedCable-Data_diff-P1002-part3",
+    "AbandonedCable-Data_diff-P1002-part4",
+    "AbandonedCable-Data_diff-P1002-part5",
+    "AbandonedCable-Data_diff-P1002-part6",
+    "AbandonedCable-Data_diff-P1002-part7",
+    "AbandonedCable-Data_diff-P1002-part8",
+    "AbandonedCable-Data_diff-P1003-part1",
+    "AbandonedCable-Data_diff-P1003-part10",
+    "AbandonedCable-Data_diff-P1003-part2",
+    "AbandonedCable-Data_diff-P1003-part3",
+    "AbandonedCable-Data_diff-P1003-part4",
+    "AbandonedCable-Data_diff-P1003-part5",
+    "AbandonedCable-Data_diff-P1003-part6",
+    "AbandonedCable-Data_diff-P1003-part7",
+    "AbandonedCable-Data_diff-P1003-part8",
+    "AbandonedCable-Data_diff-P1003-part9",
+    "AbandonedCable-Data_diff-P1004-part1",
+    "AbandonedCable-Data_diff-P1004-part10",
+    "AbandonedCable-Data_diff-P1004-part11",
+    "AbandonedCable-Data_diff-P1004-part12",
+    "AbandonedCable-Data_diff-P1004-part13",
+    "AbandonedCable-Data_diff-P1004-part14",
+    "AbandonedCable-Data_diff-P1004-part15",
+    "AbandonedCable-Data_diff-P1004-part16",
+    "AbandonedCable-Data_diff-P1004-part17",
+    "AbandonedCable-Data_diff-P1004-part18",
+    "AbandonedCable-Data_diff-P1004-part19",
+    "AbandonedCable-Data_diff-P1004-part2",
+    "AbandonedCable-Data_diff-P1004-part20",
+    "AbandonedCable-Data_diff-P1004-part21",
+    "AbandonedCable-Data_diff-P1004-part22",
+    "AbandonedCable-Data_diff-P1004-part3",
+    "AbandonedCable-Data_diff-P1004-part4",
+    "AbandonedCable-Data_diff-P1004-part5",
+    "AbandonedCable-Data_diff-P1004-part6",
+    "AbandonedCable-Data_diff-P1004-part7",
+    "AbandonedCable-Data_diff-P1004-part8",
+    "AbandonedCable-Data_diff-P1004-part9",
+    "AbandonedCable-Data_diff-P1005-part1",
+    "AbandonedCable-Data_diff-P1005-part2",
+    "AbandonedCable-Data_diff-P1005-part3",
+    "AbandonedCable-Data_diff-P1005-part4",
+    "AbandonedCable-Data_diff-P1005-part5",
+    "AbandonedCable-Data_diff-P1006-part1",
+    "AbandonedCable-Data_diff-P1006-part2",
+    "AbandonedCable-Data_diff-P1006-part3",
+    "AbandonedCable-Data_diff-P1006-part4",
+    "AbandonedCable-Data_diff-P1006-part5",
+    "AbandonedCable-Data_diff-P1007-part1",
+    "AbandonedCable-Data_diff-P1007-part10",
+    "AbandonedCable-Data_diff-P1007-part11",
+    "AbandonedCable-Data_diff-P1007-part12",
+    "AbandonedCable-Data_diff-P1007-part13",
+    "AbandonedCable-Data_diff-P1007-part14",
+    "AbandonedCable-Data_diff-P1007-part15",
+    "AbandonedCable-Data_diff-P1007-part16",
+    "AbandonedCable-Data_diff-P1007-part17",
+    "AbandonedCable-Data_diff-P1007-part18",
+    "AbandonedCable-Data_diff-P1007-part2",
+    "AbandonedCable-Data_diff-P1007-part3",
+    "AbandonedCable-Data_diff-P1007-part4",
+    "AbandonedCable-Data_diff-P1007-part5",
+    "AbandonedCable-Data_diff-P1007-part6",
+    "AbandonedCable-Data_diff-P1007-part7",
+    "AbandonedCable-Data_diff-P1007-part8",
+    "AbandonedCable-Data_diff-P1007-part9",
+    "AbandonedCable-Data_diff-P1008-part1",
+    "AbandonedCable-Data_diff-P1008-part2",
+    "AbandonedCable-Data_diff-P1008-part3",
+    "AbandonedCable-Data_diff-P1008-part4",
+    "AbandonedCable-Data_diff-P1009-part1",
+    "AbandonedCable-Data_diff-P1009-part2",
+    "AbandonedCable-Data_diff-P1009-part3",
+    "AbandonedCable-Data_diff-P1009-part4",
+    "AbandonedCable-Data_diff-P1009-part5",
+    "AbandonedCable-Data_diff-P1009-part6",
+    "AbandonedCable-Data_diff-P1009-part7",
+    "AbandonedCable-Data_diff-P1009-part8",
+    "AbandonedCable-Data_diff-P1009-part9",
+    "AbandonedCable-Data_diff-P1010-part1",
+    "AbandonedCable-Data_diff-P1010-part10",
+    "AbandonedCable-Data_diff-P1010-part11",
+    "AbandonedCable-Data_diff-P1010-part12",
+    "AbandonedCable-Data_diff-P1010-part2",
+    "AbandonedCable-Data_diff-P1010-part3",
+    "AbandonedCable-Data_diff-P1010-part4",
+    "AbandonedCable-Data_diff-P1010-part5",
+    "AbandonedCable-Data_diff-P1010-part6",
+    "AbandonedCable-Data_diff-P1010-part7",
+    "AbandonedCable-Data_diff-P1010-part8",
+    "AbandonedCable-Data_diff-P1010-part9",
+    "AbandonedCable-Data_omni-P0000-part1",
+    "AbandonedCable-Data_omni-P0000-part2",
+    "AbandonedCable-Data_omni-P0000-part3",
+    "AbandonedCable-Data_omni-P0000-part4",
+    "AbandonedCable-Data_omni-P0000-part5",
+    "AbandonedCable-Data_omni-P0000-part6",
+    "AbandonedCable-Data_omni-P0000-part7",
+    "AbandonedCable-Data_omni-P0001-part1",
+    "AbandonedCable-Data_omni-P0001-part2",
+    "AbandonedCable-Data_omni-P0001-part3",
+    "AbandonedCable-Data_omni-P0001-part4",
+    "AbandonedCable-Data_omni-P0002-part1",
+    "AbandonedCable-Data_omni-P0002-part10",
+    "AbandonedCable-Data_omni-P0002-part11",
+    "AbandonedCable-Data_omni-P0002-part12",
+    "AbandonedCable-Data_omni-P0002-part2",
+    "AbandonedCable-Data_omni-P0002-part3",
+    "AbandonedCable-Data_omni-P0002-part4",
+    "AbandonedCable-Data_omni-P0002-part5",
+    "AbandonedCable-Data_omni-P0002-part6",
+    "AbandonedCable-Data_omni-P0002-part7",
+    "AbandonedCable-Data_omni-P0002-part8",
+    "AbandonedCable-Data_omni-P0002-part9",
+    "AbandonedCable-Data_omni-P0003-part1",
+    "AbandonedCable-Data_omni-P0003-part10",
+    "AbandonedCable-Data_omni-P0003-part11",
+    "AbandonedCable-Data_omni-P0003-part12",
+    "AbandonedCable-Data_omni-P0003-part13",
+    "AbandonedCable-Data_omni-P0003-part14",
+    "AbandonedCable-Data_omni-P0003-part15",
+    "AbandonedCable-Data_omni-P0003-part16",
+    "AbandonedCable-Data_omni-P0003-part2",
+    "AbandonedCable-Data_omni-P0003-part3",
+    "AbandonedCable-Data_omni-P0003-part4",
+    "AbandonedCable-Data_omni-P0003-part5",
+    "AbandonedCable-Data_omni-P0003-part6",
+    "AbandonedCable-Data_omni-P0003-part7",
+    "AbandonedCable-Data_omni-P0003-part8",
+    "AbandonedCable-Data_omni-P0003-part9",
+    "AbandonedCable-Data_omni-P0004-part1",
+    "AbandonedCable-Data_omni-P0004-part10",
+    "AbandonedCable-Data_omni-P0004-part11",
+    "AbandonedCable-Data_omni-P0004-part12",
+    "AbandonedCable-Data_omni-P0004-part2",
+    "AbandonedCable-Data_omni-P0004-part3",
+    "AbandonedCable-Data_omni-P0004-part4",
+    "AbandonedCable-Data_omni-P0004-part5",
+    "AbandonedCable-Data_omni-P0004-part6",
+    "AbandonedCable-Data_omni-P0004-part7",
+    "AbandonedCable-Data_omni-P0004-part8",
+    "AbandonedCable-Data_omni-P0004-part9",
+    "AbandonedCable-Data_omni-P0005-part1",
+    "AbandonedCable-Data_omni-P0005-part2",
+    "AbandonedCable-Data_omni-P0005-part3",
+    "AbandonedCable-Data_omni-P0005-part4",
+    "AbandonedCable-Data_omni-P0005-part5",
+    "AbandonedCable-Data_omni-P0006-part1",
+    "AbandonedCable-Data_omni-P0006-part2",
+    "AbandonedCable-Data_omni-P0006-part3",
+    "AbandonedCable-Data_omni-P0006-part4",
+    "AbandonedCable-Data_omni-P0006-part5",
+    "AbandonedCable-Data_omni-P0006-part6",
+    "AbandonedCable-Data_omni-P0006-part7",
+    "AbandonedCable-Data_omni-P0006-part8",
+    "AbandonedCable-Data_omni-P0006-part9",
+    "AbandonedCable-Data_omni-P0007-part1",
+    "AbandonedCable-Data_omni-P0007-part2",
+    "AbandonedCable-Data_omni-P0007-part3",
+    "AbandonedCable-Data_omni-P0007-part4",
+    "AbandonedCable-Data_omni-P0007-part5",
+    "AbandonedCable-Data_omni-P0007-part6",
+    "AbandonedCable-Data_omni-P0007-part7",
+    "AbandonedCable-Data_omni-P0007-part8",
+    "AbandonedCable-Data_omni-P0008-part1",
+    "AbandonedCable-Data_omni-P0008-part10",
+    "AbandonedCable-Data_omni-P0008-part11",
+    "AbandonedCable-Data_omni-P0008-part12",
+    "AbandonedCable-Data_omni-P0008-part13",
+    "AbandonedCable-Data_omni-P0008-part14",
+    "AbandonedCable-Data_omni-P0008-part2",
+    "AbandonedCable-Data_omni-P0008-part3",
+    "AbandonedCable-Data_omni-P0008-part4",
+    "AbandonedCable-Data_omni-P0008-part5",
+    "AbandonedCable-Data_omni-P0008-part6",
+    "AbandonedCable-Data_omni-P0008-part7",
+    "AbandonedCable-Data_omni-P0008-part8",
+    "AbandonedCable-Data_omni-P0008-part9",
+    "AbandonedCable-Data_omni-P0009-part1",
+    "AbandonedCable-Data_omni-P0009-part2",
+    "AbandonedCable-Data_omni-P0009-part3",
+    "AbandonedCable-Data_omni-P0009-part4",
+    "AbandonedCable-Data_omni-P0009-part5",
+    "AbandonedCable-Data_omni-P0009-part6",
+    "AbandonedCable-Data_omni-P0009-part7",
+    "AbandonedCable-Data_omni-P0009-part8",
+    "AbandonedCable-Data_omni-P0010-part1",
+    "AbandonedCable-Data_omni-P0010-part2",
+    "AbandonedCable-Data_omni-P0010-part3",
+    "AbandonedCable-Data_omni-P0011-part1",
+    "AbandonedCable-Data_omni-P0011-part2",
+    "AbandonedCable-Data_omni-P0011-part3",
+    "AbandonedCable-Data_omni-P0011-part4",
+    "AbandonedCable-Data_omni-P0011-part5",
+    "AbandonedCable-Data_omni-P0011-part6",
+    "AbandonedCable-Data_omni-P0012-part1",
+    "AbandonedCable-Data_omni-P0012-part10",
+    "AbandonedCable-Data_omni-P0012-part11",
+    "AbandonedCable-Data_omni-P0012-part2",
+    "AbandonedCable-Data_omni-P0012-part3",
+    "AbandonedCable-Data_omni-P0012-part4",
+    "AbandonedCable-Data_omni-P0012-part5",
+    "AbandonedCable-Data_omni-P0012-part6",
+    "AbandonedCable-Data_omni-P0012-part7",
+    "AbandonedCable-Data_omni-P0012-part8",
+    "AbandonedCable-Data_omni-P0012-part9",
+    "AbandonedCable-Data_omni-P0013-part1",
+    "AbandonedCable-Data_omni-P0013-part10",
+    "AbandonedCable-Data_omni-P0013-part11",
+    "AbandonedCable-Data_omni-P0013-part12",
+    "AbandonedCable-Data_omni-P0013-part13",
+    "AbandonedCable-Data_omni-P0013-part14",
+    "AbandonedCable-Data_omni-P0013-part15",
+    "AbandonedCable-Data_omni-P0013-part2",
+    "AbandonedCable-Data_omni-P0013-part3",
+    "AbandonedCable-Data_omni-P0013-part4",
+    "AbandonedCable-Data_omni-P0013-part5",
+    "AbandonedCable-Data_omni-P0013-part6",
+    "AbandonedCable-Data_omni-P0013-part7",
+    "AbandonedCable-Data_omni-P0013-part8",
+    "AbandonedCable-Data_omni-P0013-part9",
+    "AbandonedFactory-Data_omni-P0000-part1",
+    "AbandonedFactory-Data_omni-P0000-part2",
+    "AbandonedFactory-Data_omni-P0000-part3",
+    "AbandonedFactory-Data_omni-P0000-part4",
+    "AbandonedFactory-Data_omni-P0000-part5",
+    "AbandonedFactory-Data_omni-P0001-part1",
+    "AbandonedFactory-Data_omni-P0001-part2",
+    "AbandonedFactory-Data_omni-P0001-part3",
+    "AbandonedFactory-Data_omni-P0001-part4",
+    "AbandonedFactory-Data_omni-P0001-part5",
+    "AbandonedFactory-Data_omni-P0001-part6",
+    "AbandonedFactory-Data_omni-P0002-part1",
+    "AbandonedFactory-Data_omni-P0002-part2",
+    "AbandonedFactory-Data_omni-P0002-part3",
+    "AbandonedFactory-Data_omni-P0002-part4",
+    "AbandonedFactory-Data_omni-P0002-part5",
+    "AbandonedFactory-Data_omni-P0004-part1",
+    "AbandonedFactory-Data_omni-P0004-part2",
+    "AbandonedFactory-Data_omni-P0004-part3",
+    "AbandonedFactory-Data_omni-P0004-part4",
+    "AbandonedFactory-Data_omni-P0005-part1",
+    "AbandonedFactory-Data_omni-P0005-part2",
+    "AbandonedFactory2-Data_diff-P1000-part1",
+    "AbandonedFactory2-Data_diff-P1000-part2",
+    "AbandonedFactory2-Data_diff-P1000-part3",
+    "AbandonedFactory2-Data_diff-P1000-part4",
+    "AbandonedFactory2-Data_diff-P1001-part1",
+    "AbandonedFactory2-Data_diff-P1001-part2",
+    "AbandonedFactory2-Data_diff-P1001-part3",
+    "AbandonedFactory2-Data_diff-P1001-part4",
+    "AbandonedFactory2-Data_diff-P1001-part5",
+    "AbandonedFactory2-Data_diff-P1002-part1",
+    "AbandonedFactory2-Data_diff-P1002-part2",
+    "AbandonedFactory2-Data_diff-P1002-part3",
+    "AbandonedFactory2-Data_diff-P1002-part4",
+    "AbandonedFactory2-Data_diff-P1002-part5",
+    "AbandonedFactory2-Data_diff-P1002-part6",
+    "AbandonedFactory2-Data_diff-P1002-part7",
+    "AbandonedFactory2-Data_omni-P0000-part1",
+    "AbandonedFactory2-Data_omni-P0000-part2",
+    "AbandonedFactory2-Data_omni-P0001-part1",
+    "AbandonedFactory2-Data_omni-P0001-part2",
+    "AbandonedFactory2-Data_omni-P0001-part3",
+    "AbandonedFactory2-Data_omni-P0001-part4",
+    "AbandonedFactory2-Data_omni-P0002-part1",
+    "AbandonedFactory2-Data_omni-P0002-part2",
+    "AbandonedFactory2-Data_omni-P0002-part3",
+    "AbandonedFactory2-Data_omni-P0003-part1",
+    "AbandonedFactory2-Data_omni-P0003-part2",
+    "AbandonedFactory2-Data_omni-P0003-part3",
+    "AbandonedFactory2-Data_omni-P0003-part4",
+    "AbandonedFactory2-Data_omni-P0003-part5",
+    "AbandonedFactory2-Data_omni-P0004-part1",
+    "AbandonedFactory2-Data_omni-P0004-part2",
+    "AbandonedFactory2-Data_omni-P0004-part3",
+    "AbandonedSchool-Data_omni-P0000-part1",
+    "AbandonedSchool-Data_omni-P0000-part2",
+    "AbandonedSchool-Data_omni-P0000-part3",
+    "AbandonedSchool-Data_omni-P0000-part4",
+    "AbandonedSchool-Data_omni-P0000-part5",
+    "AbandonedSchool-Data_omni-P0000-part6",
+    "AbandonedSchool-Data_omni-P0000-part7",
+    "AbandonedSchool-Data_omni-P0000-part8",
+    "AbandonedSchool-Data_omni-P0001-part1",
+    "AbandonedSchool-Data_omni-P0001-part2",
+    "AbandonedSchool-Data_omni-P0001-part3",
+    "AbandonedSchool-Data_omni-P0001-part4",
+    "AbandonedSchool-Data_omni-P0001-part5",
+    "AbandonedSchool-Data_omni-P0001-part6",
+    "AbandonedSchool-Data_omni-P0001-part7",
+    "AbandonedSchool-Data_omni-P0001-part8",
+    "AbandonedSchool-Data_omni-P0002-part1",
+    "AbandonedSchool-Data_omni-P0002-part2",
+    "AbandonedSchool-Data_omni-P0002-part3",
+    "AbandonedSchool-Data_omni-P0002-part4",
+    "AbandonedSchool-Data_omni-P0003-part1",
+    "AbandonedSchool-Data_omni-P0003-part10",
+    "AbandonedSchool-Data_omni-P0003-part11",
+    "AbandonedSchool-Data_omni-P0003-part12",
+    "AbandonedSchool-Data_omni-P0003-part13",
+    "AbandonedSchool-Data_omni-P0003-part2",
+    "AbandonedSchool-Data_omni-P0003-part3",
+    "AbandonedSchool-Data_omni-P0003-part4",
+    "AbandonedSchool-Data_omni-P0003-part5",
+    "AbandonedSchool-Data_omni-P0003-part6",
+    "AbandonedSchool-Data_omni-P0003-part7",
+    "AbandonedSchool-Data_omni-P0003-part8",
+    "AbandonedSchool-Data_omni-P0003-part9",
+    "AbandonedSchool-Data_omni-P0004-part1",
+    "AbandonedSchool-Data_omni-P0004-part10",
+    "AbandonedSchool-Data_omni-P0004-part11",
+    "AbandonedSchool-Data_omni-P0004-part12",
+    "AbandonedSchool-Data_omni-P0004-part2",
+    "AbandonedSchool-Data_omni-P0004-part3",
+    "AbandonedSchool-Data_omni-P0004-part4",
+    "AbandonedSchool-Data_omni-P0004-part5",
+    "AbandonedSchool-Data_omni-P0004-part6",
+    "AbandonedSchool-Data_omni-P0004-part7",
+    "AbandonedSchool-Data_omni-P0004-part8",
+    "AbandonedSchool-Data_omni-P0004-part9",
+    "AbandonedSchool-Data_omni-P0005-part1",
+    "AbandonedSchool-Data_omni-P0005-part10",
+    "AbandonedSchool-Data_omni-P0005-part11",
+    "AbandonedSchool-Data_omni-P0005-part12",
+    "AbandonedSchool-Data_omni-P0005-part13",
+    "AbandonedSchool-Data_omni-P0005-part2",
+    "AbandonedSchool-Data_omni-P0005-part3",
+    "AbandonedSchool-Data_omni-P0005-part4",
+    "AbandonedSchool-Data_omni-P0005-part5",
+    "AbandonedSchool-Data_omni-P0005-part6",
+    "AbandonedSchool-Data_omni-P0005-part7",
+    "AbandonedSchool-Data_omni-P0005-part8",
+    "AbandonedSchool-Data_omni-P0005-part9",
+    "AbandonedSchool-Data_omni-P0006-part1",
+    "AbandonedSchool-Data_omni-P0006-part2",
+    "AbandonedSchool-Data_omni-P0006-part3",
+    "AbandonedSchool-Data_omni-P0006-part4",
+    "AbandonedSchool-Data_omni-P0006-part5",
+    "AbandonedSchool-Data_omni-P0006-part6",
+    "AbandonedSchool-Data_omni-P0007-part1",
+    "AbandonedSchool-Data_omni-P0007-part2",
+    "AbandonedSchool-Data_omni-P0007-part3",
+    "AbandonedSchool-Data_omni-P0007-part4",
+    "AbandonedSchool-Data_omni-P0008-part1",
+    "AbandonedSchool-Data_omni-P0008-part2",
+    "AbandonedSchool-Data_omni-P0008-part3",
+    "AbandonedSchool-Data_omni-P0008-part4",
+    "AbandonedSchool-Data_omni-P0008-part5",
+    "AbandonedSchool-Data_omni-P0008-part6",
+    "AbandonedSchool-Data_omni-P0009-part1",
+    "AbandonedSchool-Data_omni-P0009-part2",
+    "AbandonedSchool-Data_omni-P0009-part3",
+    "AbandonedSchool-Data_omni-P0009-part4",
+    "HQWesternSaloon-Data_omni-P0000-part1",
+    "HQWesternSaloon-Data_omni-P0000-part2",
+    "HQWesternSaloon-Data_omni-P0001-part1",
+    "HQWesternSaloon-Data_omni-P0001-part2",
+    "HQWesternSaloon-Data_omni-P0002-part1",
+    "HQWesternSaloon-Data_omni-P0002-part2",
+    "HQWesternSaloon-Data_omni-P0002-part3",
+    "HQWesternSaloon-Data_omni-P0002-part4",
+    "Hospital-Data_diff-P1001-part1",
+    "Hospital-Data_diff-P1001-part10",
+    "Hospital-Data_diff-P1001-part11",
+    "Hospital-Data_diff-P1001-part12",
+    "Hospital-Data_diff-P1001-part13",
+    "Hospital-Data_diff-P1001-part14",
+    "Hospital-Data_diff-P1001-part15",
+    "Hospital-Data_diff-P1001-part16",
+    "Hospital-Data_diff-P1001-part2",
+    "Hospital-Data_diff-P1001-part3",
+    "Hospital-Data_diff-P1001-part4",
+    "Hospital-Data_diff-P1001-part5",
+    "Hospital-Data_diff-P1001-part6",
+    "Hospital-Data_diff-P1001-part7",
+    "Hospital-Data_diff-P1001-part8",
+    "Hospital-Data_diff-P1001-part9",
+    "Hospital-Data_diff-P1002-part1",
+    "Hospital-Data_diff-P1002-part10",
+    "Hospital-Data_diff-P1002-part11",
+    "Hospital-Data_diff-P1002-part12",
+    "Hospital-Data_diff-P1002-part13",
+    "Hospital-Data_diff-P1002-part14",
+    "Hospital-Data_diff-P1002-part2",
+    "Hospital-Data_diff-P1002-part3",
+    "Hospital-Data_diff-P1002-part4",
+    "Hospital-Data_diff-P1002-part5",
+    "Hospital-Data_diff-P1002-part6",
+    "Hospital-Data_diff-P1002-part7",
+    "Hospital-Data_diff-P1002-part8",
+    "Hospital-Data_diff-P1002-part9",
+    "Hospital-Data_diff-P1003-part1",
+    "Hospital-Data_diff-P1003-part10",
+    "Hospital-Data_diff-P1003-part11",
+    "Hospital-Data_diff-P1003-part2",
+    "Hospital-Data_diff-P1003-part3",
+    "Hospital-Data_diff-P1003-part4",
+    "Hospital-Data_diff-P1003-part5",
+    "Hospital-Data_diff-P1003-part6",
+    "Hospital-Data_diff-P1003-part7",
+    "Hospital-Data_diff-P1003-part8",
+    "Hospital-Data_diff-P1003-part9",
+    "Hospital-Data_diff-P1004-part1",
+    "Hospital-Data_diff-P1004-part10",
+    "Hospital-Data_diff-P1004-part11",
+    "Hospital-Data_diff-P1004-part12",
+    "Hospital-Data_diff-P1004-part13",
+    "Hospital-Data_diff-P1004-part14",
+    "Hospital-Data_diff-P1004-part15",
+    "Hospital-Data_diff-P1004-part16",
+    "Hospital-Data_diff-P1004-part17",
+    "Hospital-Data_diff-P1004-part18",
+    "Hospital-Data_diff-P1004-part2",
+    "Hospital-Data_diff-P1004-part3",
+    "Hospital-Data_diff-P1004-part4",
+    "Hospital-Data_diff-P1004-part5",
+    "Hospital-Data_diff-P1004-part6",
+    "Hospital-Data_diff-P1004-part7",
+    "Hospital-Data_diff-P1004-part8",
+    "Hospital-Data_diff-P1004-part9",
+    "Hospital-Data_diff-P1005-part1",
+    "Hospital-Data_diff-P1005-part10",
+    "Hospital-Data_diff-P1005-part11",
+    "Hospital-Data_diff-P1005-part2",
+    "Hospital-Data_diff-P1005-part3",
+    "Hospital-Data_diff-P1005-part4",
+    "Hospital-Data_diff-P1005-part5",
+    "Hospital-Data_diff-P1005-part6",
+    "Hospital-Data_diff-P1005-part7",
+    "Hospital-Data_diff-P1005-part8",
+    "Hospital-Data_diff-P1005-part9",
+    "Hospital-Data_omni-P0000-part1",
+    "Hospital-Data_omni-P0000-part10",
+    "Hospital-Data_omni-P0000-part2",
+    "Hospital-Data_omni-P0000-part3",
+    "Hospital-Data_omni-P0000-part4",
+    "Hospital-Data_omni-P0000-part5",
+    "Hospital-Data_omni-P0000-part6",
+    "Hospital-Data_omni-P0000-part7",
+    "Hospital-Data_omni-P0000-part8",
+    "Hospital-Data_omni-P0000-part9",
+    "Hospital-Data_omni-P0001-part1",
+    "Hospital-Data_omni-P0001-part2",
+    "Hospital-Data_omni-P0001-part3",
+    "Hospital-Data_omni-P0001-part4",
+    "Hospital-Data_omni-P0001-part5",
+    "Hospital-Data_omni-P0001-part6",
+    "Hospital-Data_omni-P0001-part7",
+    "Hospital-Data_omni-P0001-part8",
+    "Hospital-Data_omni-P0001-part9",
+    "Hospital-Data_omni-P0002-part1",
+    "Hospital-Data_omni-P0002-part10",
+    "Hospital-Data_omni-P0002-part11",
+    "Hospital-Data_omni-P0002-part12",
+    "Hospital-Data_omni-P0002-part13",
+    "Hospital-Data_omni-P0002-part2",
+    "Hospital-Data_omni-P0002-part3",
+    "Hospital-Data_omni-P0002-part4",
+    "Hospital-Data_omni-P0002-part5",
+    "Hospital-Data_omni-P0002-part6",
+    "Hospital-Data_omni-P0002-part7",
+    "Hospital-Data_omni-P0002-part8",
+    "Hospital-Data_omni-P0002-part9",
+    "Hospital-Data_omni-P0003-part1",
+    "Hospital-Data_omni-P0003-part10",
+    "Hospital-Data_omni-P0003-part11",
+    "Hospital-Data_omni-P0003-part12",
+    "Hospital-Data_omni-P0003-part2",
+    "Hospital-Data_omni-P0003-part3",
+    "Hospital-Data_omni-P0003-part4",
+    "Hospital-Data_omni-P0003-part5",
+    "Hospital-Data_omni-P0003-part6",
+    "Hospital-Data_omni-P0003-part7",
+    "Hospital-Data_omni-P0003-part8",
+    "Hospital-Data_omni-P0003-part9",
+    "Hospital-Data_omni-P0004-part1",
+    "Hospital-Data_omni-P0004-part2",
+    "Hospital-Data_omni-P0004-part3",
+    "Hospital-Data_omni-P0004-part4",
+    "Hospital-Data_omni-P0004-part5",
+    "Hospital-Data_omni-P0004-part6",
+    "Hospital-Data_omni-P0004-part7",
+    "Hospital-Data_omni-P0004-part8",
+    "Hospital-Data_omni-P0005-part1",
+    "Hospital-Data_omni-P0005-part10",
+    "Hospital-Data_omni-P0005-part11",
+    "Hospital-Data_omni-P0005-part12",
+    "Hospital-Data_omni-P0005-part13",
+    "Hospital-Data_omni-P0005-part14",
+    "Hospital-Data_omni-P0005-part15",
+    "Hospital-Data_omni-P0005-part16",
+    "Hospital-Data_omni-P0005-part17",
+    "Hospital-Data_omni-P0005-part2",
+    "Hospital-Data_omni-P0005-part3",
+    "Hospital-Data_omni-P0005-part4",
+    "Hospital-Data_omni-P0005-part5",
+    "Hospital-Data_omni-P0005-part6",
+    "Hospital-Data_omni-P0005-part7",
+    "Hospital-Data_omni-P0005-part8",
+    "Hospital-Data_omni-P0005-part9",
+    "House-Data_omni-P0000-part1",
+    "House-Data_omni-P0001-part1",
+    "House-Data_omni-P0001-part2",
+    "House-Data_omni-P0002-part1",
+    "House-Data_omni-P0002-part2",
+    "House-Data_omni-P0002-part3",
+    "House-Data_omni-P0002-part4",
+    "House-Data_omni-P0002-part5",
+    "House-Data_omni-P0002-part6",
+    "IndustrialHangar-Data_diff-P1000-part1",
+    "IndustrialHangar-Data_diff-P1000-part10",
+    "IndustrialHangar-Data_diff-P1000-part11",
+    "IndustrialHangar-Data_diff-P1000-part2",
+    "IndustrialHangar-Data_diff-P1000-part3",
+    "IndustrialHangar-Data_diff-P1000-part4",
+    "IndustrialHangar-Data_diff-P1000-part5",
+    "IndustrialHangar-Data_diff-P1000-part6",
+    "IndustrialHangar-Data_diff-P1000-part7",
+    "IndustrialHangar-Data_diff-P1000-part8",
+    "IndustrialHangar-Data_diff-P1000-part9",
+    "IndustrialHangar-Data_diff-P1001-part1",
+    "IndustrialHangar-Data_diff-P1001-part10",
+    "IndustrialHangar-Data_diff-P1001-part11",
+    "IndustrialHangar-Data_diff-P1001-part12",
+    "IndustrialHangar-Data_diff-P1001-part13",
+    "IndustrialHangar-Data_diff-P1001-part14",
+    "IndustrialHangar-Data_diff-P1001-part15",
+    "IndustrialHangar-Data_diff-P1001-part2",
+    "IndustrialHangar-Data_diff-P1001-part3",
+    "IndustrialHangar-Data_diff-P1001-part4",
+    "IndustrialHangar-Data_diff-P1001-part5",
+    "IndustrialHangar-Data_diff-P1001-part6",
+    "IndustrialHangar-Data_diff-P1001-part7",
+    "IndustrialHangar-Data_diff-P1001-part8",
+    "IndustrialHangar-Data_diff-P1001-part9",
+    "IndustrialHangar-Data_diff-P1002-part1",
+    "IndustrialHangar-Data_diff-P1002-part10",
+    "IndustrialHangar-Data_diff-P1002-part2",
+    "IndustrialHangar-Data_diff-P1002-part3",
+    "IndustrialHangar-Data_diff-P1002-part4",
+    "IndustrialHangar-Data_diff-P1002-part5",
+    "IndustrialHangar-Data_diff-P1002-part6",
+    "IndustrialHangar-Data_diff-P1002-part7",
+    "IndustrialHangar-Data_diff-P1002-part8",
+    "IndustrialHangar-Data_diff-P1002-part9",
+    "IndustrialHangar-Data_diff-P1003-part1",
+    "IndustrialHangar-Data_diff-P1003-part2",
+    "IndustrialHangar-Data_diff-P1003-part3",
+    "IndustrialHangar-Data_diff-P1003-part4",
+    "IndustrialHangar-Data_diff-P1003-part5",
+    "IndustrialHangar-Data_diff-P1003-part6",
+    "IndustrialHangar-Data_diff-P1003-part7",
+    "IndustrialHangar-Data_diff-P1003-part8",
+    "IndustrialHangar-Data_diff-P1004-part1",
+    "IndustrialHangar-Data_diff-P1004-part10",
+    "IndustrialHangar-Data_diff-P1004-part2",
+    "IndustrialHangar-Data_diff-P1004-part3",
+    "IndustrialHangar-Data_diff-P1004-part4",
+    "IndustrialHangar-Data_diff-P1004-part5",
+    "IndustrialHangar-Data_diff-P1004-part6",
+    "IndustrialHangar-Data_diff-P1004-part7",
+    "IndustrialHangar-Data_diff-P1004-part8",
+    "IndustrialHangar-Data_diff-P1004-part9",
+    "IndustrialHangar-Data_diff-P1005-part1",
+    "IndustrialHangar-Data_diff-P1005-part10",
+    "IndustrialHangar-Data_diff-P1005-part2",
+    "IndustrialHangar-Data_diff-P1005-part3",
+    "IndustrialHangar-Data_diff-P1005-part4",
+    "IndustrialHangar-Data_diff-P1005-part5",
+    "IndustrialHangar-Data_diff-P1005-part6",
+    "IndustrialHangar-Data_diff-P1005-part7",
+    "IndustrialHangar-Data_diff-P1005-part8",
+    "IndustrialHangar-Data_diff-P1005-part9",
+    "IndustrialHangar-Data_diff-P1006-part1",
+    "IndustrialHangar-Data_diff-P1006-part2",
+    "IndustrialHangar-Data_diff-P1006-part3",
+    "IndustrialHangar-Data_diff-P1006-part4",
+    "IndustrialHangar-Data_diff-P1007-part1",
+    "IndustrialHangar-Data_diff-P1007-part2",
+    "IndustrialHangar-Data_diff-P1007-part3",
+    "IndustrialHangar-Data_omni-P0000-part1",
+    "IndustrialHangar-Data_omni-P0000-part10",
+    "IndustrialHangar-Data_omni-P0000-part2",
+    "IndustrialHangar-Data_omni-P0000-part3",
+    "IndustrialHangar-Data_omni-P0000-part4",
+    "IndustrialHangar-Data_omni-P0000-part5",
+    "IndustrialHangar-Data_omni-P0000-part6",
+    "IndustrialHangar-Data_omni-P0000-part7",
+    "IndustrialHangar-Data_omni-P0000-part8",
+    "IndustrialHangar-Data_omni-P0000-part9",
+    "IndustrialHangar-Data_omni-P0001-part1",
+    "IndustrialHangar-Data_omni-P0001-part2",
+    "IndustrialHangar-Data_omni-P0001-part3",
+    "IndustrialHangar-Data_omni-P0001-part4",
+    "IndustrialHangar-Data_omni-P0001-part5",
+    "IndustrialHangar-Data_omni-P0001-part6",
+    "IndustrialHangar-Data_omni-P0002-part1",
+    "IndustrialHangar-Data_omni-P0002-part2",
+    "IndustrialHangar-Data_omni-P0002-part3",
+    "IndustrialHangar-Data_omni-P0003-part1",
+    "IndustrialHangar-Data_omni-P0003-part10",
+    "IndustrialHangar-Data_omni-P0003-part11",
+    "IndustrialHangar-Data_omni-P0003-part12",
+    "IndustrialHangar-Data_omni-P0003-part13",
+    "IndustrialHangar-Data_omni-P0003-part14",
+    "IndustrialHangar-Data_omni-P0003-part2",
+    "IndustrialHangar-Data_omni-P0003-part3",
+    "IndustrialHangar-Data_omni-P0003-part4",
+    "IndustrialHangar-Data_omni-P0003-part5",
+    "IndustrialHangar-Data_omni-P0003-part6",
+    "IndustrialHangar-Data_omni-P0003-part7",
+    "IndustrialHangar-Data_omni-P0003-part8",
+    "IndustrialHangar-Data_omni-P0003-part9",
+    "IndustrialHangar-Data_omni-P0004-part1",
+    "IndustrialHangar-Data_omni-P0004-part2",
+    "IndustrialHangar-Data_omni-P0004-part3",
+    "IndustrialHangar-Data_omni-P0004-part4",
+    "IndustrialHangar-Data_omni-P0004-part5",
+    "IndustrialHangar-Data_omni-P0004-part6",
+    "IndustrialHangar-Data_omni-P0004-part7",
+    "IndustrialHangar-Data_omni-P0004-part8",
+    "IndustrialHangar-Data_omni-P0005-part1",
+    "IndustrialHangar-Data_omni-P0005-part2",
+    "IndustrialHangar-Data_omni-P0005-part3",
+    "IndustrialHangar-Data_omni-P0005-part4",
+    "IndustrialHangar-Data_omni-P0005-part5",
+    "JapaneseAlley-Data_diff-P1000-part1",
+    "JapaneseAlley-Data_diff-P1000-part2",
+    "JapaneseAlley-Data_diff-P1000-part3",
+    "JapaneseAlley-Data_diff-P1000-part4",
+    "JapaneseAlley-Data_diff-P1000-part5",
+    "JapaneseAlley-Data_diff-P1000-part6",
+    "JapaneseAlley-Data_diff-P1001-part1",
+    "JapaneseAlley-Data_diff-P1001-part2",
+    "JapaneseAlley-Data_diff-P1001-part3",
+    "JapaneseAlley-Data_diff-P1001-part4",
+    "JapaneseAlley-Data_diff-P1001-part5",
+    "JapaneseAlley-Data_diff-P1002-part1",
+    "JapaneseAlley-Data_diff-P1002-part2",
+    "JapaneseAlley-Data_diff-P1002-part3",
+    "JapaneseAlley-Data_diff-P1002-part4",
+    "JapaneseAlley-Data_diff-P1002-part5",
+    "JapaneseAlley-Data_diff-P1002-part6",
+    "JapaneseAlley-Data_diff-P1002-part7",
+    "JapaneseAlley-Data_omni-P0000-part1",
+    "JapaneseAlley-Data_omni-P0000-part2",
+    "JapaneseAlley-Data_omni-P0000-part3",
+    "JapaneseAlley-Data_omni-P0000-part4",
+    "JapaneseAlley-Data_omni-P0000-part5",
+    "JapaneseAlley-Data_omni-P0000-part6",
+    "JapaneseAlley-Data_omni-P0001-part1",
+    "JapaneseAlley-Data_omni-P0001-part10",
+    "JapaneseAlley-Data_omni-P0001-part11",
+    "JapaneseAlley-Data_omni-P0001-part2",
+    "JapaneseAlley-Data_omni-P0001-part3",
+    "JapaneseAlley-Data_omni-P0001-part4",
+    "JapaneseAlley-Data_omni-P0001-part5",
+    "JapaneseAlley-Data_omni-P0001-part6",
+    "JapaneseAlley-Data_omni-P0001-part7",
+    "JapaneseAlley-Data_omni-P0001-part8",
+    "JapaneseAlley-Data_omni-P0001-part9",
+    "JapaneseAlley-Data_omni-P0002-part1",
+    "JapaneseAlley-Data_omni-P0002-part2",
+    "JapaneseAlley-Data_omni-P0002-part3",
+    "JapaneseAlley-Data_omni-P0002-part4",
+    "JapaneseAlley-Data_omni-P0002-part5",
+    "JapaneseAlley-Data_omni-P0002-part6",
+    "JapaneseAlley-Data_omni-P0002-part7",
+    "JapaneseAlley-Data_omni-P0002-part8",
+    "JapaneseCity-Data_omni-P0000-part1",
+    "JapaneseCity-Data_omni-P0000-part2",
+    "JapaneseCity-Data_omni-P0000-part3",
+    "JapaneseCity-Data_omni-P0001-part1",
+    "JapaneseCity-Data_omni-P0001-part2",
+    "JapaneseCity-Data_omni-P0001-part3",
+    "JapaneseCity-Data_omni-P0002-part1",
+    "JapaneseCity-Data_omni-P0002-part2",
+    "JapaneseCity-Data_omni-P0002-part3",
+    "JapaneseCity-Data_omni-P0002-part4",
+    "JapaneseCity-Data_omni-P0003-part1",
+    "JapaneseCity-Data_omni-P0003-part2",
+    "JapaneseCity-Data_omni-P0003-part3",
+    "JapaneseCity-Data_omni-P0003-part4",
+    "JapaneseCity-Data_omni-P0004-part1",
+    "JapaneseCity-Data_omni-P0004-part2",
+    "JapaneseCity-Data_omni-P0005-part1",
+    "JapaneseCity-Data_omni-P0005-part2",
+    "JapaneseCity-Data_omni-P0005-part3",
+    "JapaneseCity-Data_omni-P0006-part1",
+    "JapaneseCity-Data_omni-P0006-part2",
+    "JapaneseCity-Data_omni-P0006-part3",
+    "JapaneseCity-Data_omni-P0006-part4",
+    "JapaneseCity-Data_omni-P0006-part5",
+    "JapaneseCity-Data_omni-P0007-part1",
+    "JapaneseCity-Data_omni-P0007-part2",
+    "JapaneseCity-Data_omni-P0007-part3",
+    "JapaneseCity-Data_omni-P0008-part1",
+    "JapaneseCity-Data_omni-P0008-part2",
+    "JapaneseCity-Data_omni-P0008-part3",
+    "JapaneseCity-Data_omni-P0008-part4",
+    "JapaneseCity-Data_omni-P0009-part1",
+    "JapaneseCity-Data_omni-P0009-part2",
+    "JapaneseCity-Data_omni-P0009-part3",
+    "JapaneseCity-Data_omni-P0009-part4",
+    "JapaneseCity-Data_omni-P0009-part5",
+    "JapaneseCity-Data_omni-P0009-part6",
+    "JapaneseCity-Data_omni-P0009-part7",
+    "JapaneseCity-Data_omni-P0009-part8",
+    "MiddleEast-Data_diff-P1000-part1",
+    "MiddleEast-Data_diff-P1000-part2",
+    "MiddleEast-Data_diff-P1000-part3",
+    "MiddleEast-Data_diff-P1000-part4",
+    "MiddleEast-Data_diff-P1000-part5",
+    "MiddleEast-Data_diff-P1000-part6",
+    "MiddleEast-Data_diff-P1001-part1",
+    "MiddleEast-Data_diff-P1001-part2",
+    "MiddleEast-Data_diff-P1001-part3",
+    "MiddleEast-Data_diff-P1001-part4",
+    "MiddleEast-Data_diff-P1002-part1",
+    "MiddleEast-Data_diff-P1002-part2",
+    "MiddleEast-Data_diff-P1002-part3",
+    "MiddleEast-Data_diff-P1002-part4",
+    "MiddleEast-Data_diff-P1002-part5",
+    "MiddleEast-Data_diff-P1003-part1",
+    "MiddleEast-Data_diff-P1003-part2",
+    "MiddleEast-Data_diff-P1003-part3",
+    "MiddleEast-Data_diff-P1003-part4",
+    "MiddleEast-Data_diff-P1004-part1",
+    "MiddleEast-Data_diff-P1004-part2",
+    "MiddleEast-Data_diff-P1004-part3",
+    "MiddleEast-Data_diff-P1004-part4",
+    "MiddleEast-Data_diff-P1004-part5",
+    "MiddleEast-Data_diff-P1005-part1",
+    "MiddleEast-Data_diff-P1005-part2",
+    "MiddleEast-Data_diff-P1005-part3",
+    "MiddleEast-Data_diff-P1005-part4",
+    "MiddleEast-Data_diff-P1005-part5",
+    "MiddleEast-Data_omni-P0000-part1",
+    "MiddleEast-Data_omni-P0000-part2",
+    "MiddleEast-Data_omni-P0000-part3",
+    "MiddleEast-Data_omni-P0000-part4",
+    "MiddleEast-Data_omni-P0001-part1",
+    "MiddleEast-Data_omni-P0001-part2",
+    "MiddleEast-Data_omni-P0001-part3",
+    "MiddleEast-Data_omni-P0001-part4",
+    "MiddleEast-Data_omni-P0001-part5",
+    "MiddleEast-Data_omni-P0001-part6",
+    "MiddleEast-Data_omni-P0002-part1",
+    "MiddleEast-Data_omni-P0002-part2",
+    "MiddleEast-Data_omni-P0002-part3",
+    "MiddleEast-Data_omni-P0002-part4",
+    "MiddleEast-Data_omni-P0003-part1"
+  ],
+  "environments": [
+    "AbandonedCable",
+    "AbandonedFactory",
+    "AbandonedFactory2",
+    "AbandonedSchool",
+    "HQWesternSaloon",
+    "Hospital",
+    "House",
+    "IndustrialHangar",
+    "JapaneseAlley",
+    "JapaneseCity",
+    "MiddleEast"
+  ],
+  "environment_count": 11,
+  "parts_per_environment": {
+    "AbandonedCable": 230,
+    "AbandonedFactory": 22,
+    "AbandonedFactory2": 33,
+    "AbandonedSchool": 78,
+    "HQWesternSaloon": 8,
+    "Hospital": 139,
+    "House": 9,
+    "IndustrialHangar": 117,
+    "JapaneseAlley": 43,
+    "JapaneseCity": 39,
+    "MiddleEast": 44
+  }
+}

adapters/tartanground/reencoding_script.md

@@ -0,0 +1,68 @@
+# TartanGround Re-encoding — exact procedure
+
+## Upstream layout (input)
+
+TartanGround / TartanAir ships dense cubemap trajectories with sparse depth (1-of-10 frames). Place upstream data under `data/tartanground/` matching this layout:
+
+```
+data/tartanground/
+├── <env_name>/                                     # e.g. AbandonedCable, Hospital, JapaneseAlley
+│   ├── Data_diff/                                   # diffuse pass
+│   │   ├── P<XXXX>/                                 # per-trajectory id
+│   │   │   ├── image_left/<NNNN>.png               # cubemap face frames
+│   │   │   ├── depth_left/<NNNN>_depth.npy          # 1-of-10 frames only
+│   │   │   ├── pose_left.txt                       # all-frames pose
+│   │   │   └── …
+│   ├── Data_omni/                                   # omnidirectional pass
+│   │   └── (same structure)
+│   └── …
+```
+
+The script reads the layout from `config.yaml` so adjust `input_layout` if your TartanGround download differs.
+
+## Output schema (CM-EVS unified)
+
+Each upstream trajectory of N frames is sliced into `ceil(N/200)` parts; leftover < 200 frames is folded into the previous part. Output path:
+
+```
+outputs/tartanground/<env_name>-Data_<diff|omni>-P<XXXX>-part<N>/
+├── panorama_0000.png                                # ERP RGB, 2048×1024
+├── panorama_0000_depth.npy                          # ERP range depth (m), present only for 1-of-10 frames
+├── pose_0000.json                                    # { qwc: [w,x,y,z], position: [x,y,z], camera_type: "cubemap_reencoded" }
+├── panorama_0001.png
+└── …
+```
+
+Within a `part<N>` directory, frame indices restart from `0000`. Use a separate `metadata/part_manifest.json` (TODO) to map back to the upstream trajectory step.
+
+## Run
+
+```bash
+cd ../../code
+python scripts/reencode_outdoor.py \
+    --source tartanground \
+    --config ../adapters/tartanground/config.yaml
+```
+
+The script:
+
+1. Reads `config.yaml` → resolves cubemap face size, axis conversion, ERP target resolution, depth subsample stride, partition size (default 200).
+2. For each trajectory part listed in `metadata/source_manifest.json`:
+    - Reads cubemap faces per frame, projects to ERP at 2048×1024.
+    - Re-projects depth: cubemap perspective `z` → ERP **range** depth (radial). Only frames with upstream depth (1-of-10) get a `panorama_NNNN_depth.npy`.
+    - Reads pose, converts to CM-EVS world frame, emits `pose_NNNN.json`.
+3. Emits per-trajectory-part `meta.json` re-stating coordinate convention.
+
+## Verifying against paper
+
+After running, compare with paper §4.3 Table 4:
+
+- 63 environments / 783,944 frames is the **target**; H100-side data CM-EVS was developed against currently has 11 environments / 762 parts. Remaining environments held offline; see `../../TODO.md`.
+- Resolution 2048×1024 ✓
+- Median depth 3.63 m (computed on the 16,348 frames where a depth array exists per paper footnote) ✓
+
+## Caveats
+
+- **No curator selection**. All v1.0 outdoor frames are full re-encoded source trajectories.
+- **Sparse depth**: depth NPYs exist only on the 1-of-10 frame subsample.
+- **License**: TartanGround / TartanAir typically ships under non-commercial licenses (CC-BY-NC-SA or similar). The frames you produce by running this adapter are bound by that upstream license — **not redistributable**.

blender_indoor/README.md

@@ -0,0 +1,92 @@
+# Blender indoor — CM-EVS v1.0
+
+374 scene instances, 13,631 ERP RGB frames, 12,634 range-depth NumPy arrays, 13,631 pose JSON files. Resolution **2048×1024**. Released under **CC-BY 4.0**.
+
+This is the only redistributable RGB-D portion of CM-EVS. The four restricted sources (HM3D, ScanNet++, OB3D, TartanGround) ship adapter code only — see `../adapters/`.
+
+## Layout
+
+```
+blender_indoor/
+├── README.md                   (this file)
+├── SHA256SUMS                  (39,896 lines covering every panorama, depth, pose)
+├── scenes/
+│   ├── sence_indoor_0001/      (← from round1+2, original sence_indoor_0001)
+│   │   ├── panorama_0000.png
+│   │   ├── panorama_0000_depth.npy
+│   │   ├── pose_0000.json
+│   │   ├── panorama_0001.png
+│   │   ├── panorama_0001_depth.npy
+│   │   ├── pose_0001.json
+│   │   └── ...
+│   ├── sence_indoor_0002/
+│   ├── ...
+│   ├── sence_indoor_0201/      (last from round1+2)
+│   ├── sence_indoor_0202/      (first from round2)
+│   ├── ...
+│   └── sence_indoor_0374/      (last from round2)
+└── metadata/
+    ├── source_manifest.json    aggregate stats per round
+    ├── splits.json             scene-level 70/15/15 split
+    ├── frame_manifest.csv      one row per frame (14 columns matching croissant.json RecordSet)
+    ├── scene_id_mapping.csv    new_scene_id → (source_round, original_scene_id, frame_count)
+    └── frame_id_mapping.csv    new (scene_id, frame_idx) → original H100 path
+```
+
+## Naming
+
+- **Scene IDs** are renumbered consecutively `sence_indoor_0001 … sence_indoor_0374`. round1+2 (lexicographic) gets 1–201; round2 (lexicographic) gets 202–374. The 48 original `sence_indoor_XXXX` ids that appeared in **both** rounds are kept as **two separate instances** (different sampling outcomes, different SHA-256). Use `metadata/scene_id_mapping.csv` to recover the original id and source round.
+- **Frame IDs** are renumbered consecutively per scene starting at `panorama_0000`. The original frame number on H100 (which may be sparse / non-consecutive) is recoverable from `metadata/frame_id_mapping.csv`.
+- All three companion files for a single frame share the same numerical suffix: `panorama_NNNN.png` ↔ `panorama_NNNN_depth.npy` ↔ `pose_NNNN.json`. Some frames may lack `_depth.npy` if depth was not produced (per-frame invalid-depth ratio target ≈ 1.4% per paper §4.8).
+
+## Schema
+
+Each frame is recorded under a single coordinate convention so a downstream loader does not need to branch per source:
+
+- **World frame**: right-handed; `+X` right, `+Y` up, `+Z` forward.
+- **Camera frame**: OpenCV (`+x` image right, `+y` image down, `+z` camera forward).
+- **Pose**: world-to-camera quaternion `q_wc = [w, x, y, z]` (scalar-first) plus position `C_w − C_{w,0}` relative to the scene's first selected frame. Field names in JSON: `qwc`, `position`, `camera_type`.
+- **ERP**: longitude `(u/W − 0.5) · 2π`, latitude `(0.5 − v/H) · π`.
+- **Range depth** (not perspective `z`-depth): each pixel stores the radial distance from camera center to surface, in metres. Invalid pixels are NaN or 0.
+
+```python
+import json, numpy as np
+from PIL import Image
+sid, fid = "sence_indoor_0042", "0007"
+rgb   = np.asarray(Image.open(f"scenes/{sid}/panorama_{fid}.png"))   # (1024, 2048, 3) uint8
+depth = np.load(f"scenes/{sid}/panorama_{fid}_depth.npy")            # (1024, 2048) float32; NaN/0 = invalid
+pose  = json.load(open(f"scenes/{sid}/pose_{fid}.json"))             # {qwc: [w,x,y,z], position: [x,y,z], ...}
+```
+
+## Splits
+
+Default scene-level **70 / 15 / 15** via `sha256(new_scene_id) % 100`:
+
+- `train` if hash mod 100 < 70
+- `val` if 70 ≤ hash mod 100 < 85
+- `test` otherwise
+
+Concrete counts and lists are in `metadata/splits.json`. Use this as the canonical split for any reported number against this dataset.
+
+## Per-scene curator metadata (coming in v1.1)
+
+Once the curator runs on the merged 374-scene set, each scene will additionally contain:
+
+- `meta.json` — re-states coordinate convention + records absolute first-frame center
+- `metadata/selected_viewpoints.json` — chosen ids + scores + gains + conflicts
+- `metadata/candidates.jsonl` — feasible candidates with 26-direction validity flags
+- `metadata/per_step_log.jsonl` — per-step `G_t`, `L_t`, `s_t`, runtime
+
+These are documented in paper §4.1 Table; tracked under `TODO.md`.
+
+## Verifying integrity
+
+```bash
+cd blender_indoor
+shasum -a 256 -c SHA256SUMS
+# 39,896 / 39,896 should pass
+```
+
+## License
+
+Frames here are derived from CC0 / CC-BY-4.0 Blender scene assets. The CM-EVS release license for these frames is **CC-BY 4.0**. Attribution required for redistribution; cite the dataset paper. See top-level `LICENSE.md` for the full matrix.

blender_indoor/metadata/scene_id_mapping.csv

@@ -0,0 +1,375 @@
+new_scene_id,source_round,original_scene_id,frame_count
+sence_indoor_0001,round1+2,sence_indoor_0001,33
+sence_indoor_0002,round1+2,sence_indoor_0002,33
+sence_indoor_0003,round1+2,sence_indoor_0003,29
+sence_indoor_0004,round1+2,sence_indoor_0004,29
+sence_indoor_0005,round1+2,sence_indoor_0005,33
+sence_indoor_0006,round1+2,sence_indoor_0005-第二轮,47
+sence_indoor_0007,round1+2,sence_indoor_0007,12
+sence_indoor_0008,round1+2,sence_indoor_0008,53
+sence_indoor_0009,round1+2,sence_indoor_0009,23
+sence_indoor_0010,round1+2,sence_indoor_0012,53
+sence_indoor_0011,round1+2,sence_indoor_0013,53
+sence_indoor_0012,round1+2,sence_indoor_0014,33
+sence_indoor_0013,round1+2,sence_indoor_0015,33
+sence_indoor_0014,round1+2,sence_indoor_0016,35
+sence_indoor_0015,round1+2,sence_indoor_0018,33
+sence_indoor_0016,round1+2,sence_indoor_0018-第二轮,15
+sence_indoor_0017,round1+2,sence_indoor_0019,33
+sence_indoor_0018,round1+2,sence_indoor_0020,33
+sence_indoor_0019,round1+2,sence_indoor_0021,21
+sence_indoor_0020,round1+2,sence_indoor_0021-第二轮,31
+sence_indoor_0021,round1+2,sence_indoor_0023,16
+sence_indoor_0022,round1+2,sence_indoor_0024,53
+sence_indoor_0023,round1+2,sence_indoor_0027,29
+sence_indoor_0024,round1+2,sence_indoor_0028,21
+sence_indoor_0025,round1+2,sence_indoor_0030,22
+sence_indoor_0026,round1+2,sence_indoor_0031,7
+sence_indoor_0027,round1+2,sence_indoor_0036,23
+sence_indoor_0028,round1+2,sence_indoor_0036-第二轮,53
+sence_indoor_0029,round1+2,sence_indoor_0037,53
+sence_indoor_0030,round1+2,sence_indoor_0038,29
+sence_indoor_0031,round1+2,sence_indoor_0040,48
+sence_indoor_0032,round1+2,sence_indoor_0041,29
+sence_indoor_0033,round1+2,sence_indoor_0041-第二轮,12
+sence_indoor_0034,round1+2,sence_indoor_0043,53
+sence_indoor_0035,round1+2,sence_indoor_0044,33
+sence_indoor_0036,round1+2,sence_indoor_0045-第二轮,31
+sence_indoor_0037,round1+2,sence_indoor_0048-第二轮,53
+sence_indoor_0038,round1+2,sence_indoor_0050,53
+sence_indoor_0039,round1+2,sence_indoor_0051,21
+sence_indoor_0040,round1+2,sence_indoor_0054,15
+sence_indoor_0041,round1+2,sence_indoor_0057,25
+sence_indoor_0042,round1+2,sence_indoor_0058,23
+sence_indoor_0043,round1+2,sence_indoor_0060,29
+sence_indoor_0044,round1+2,sence_indoor_0067,9
+sence_indoor_0045,round1+2,sence_indoor_0069,15
+sence_indoor_0046,round1+2,sence_indoor_0070,53
+sence_indoor_0047,round1+2,sence_indoor_0071,33
+sence_indoor_0048,round1+2,sence_indoor_0072,52
+sence_indoor_0049,round1+2,sence_indoor_0074,25
+sence_indoor_0050,round1+2,sence_indoor_0074-第二轮,26
+sence_indoor_0051,round1+2,sence_indoor_0075,17
+sence_indoor_0052,round1+2,sence_indoor_0076,33
+sence_indoor_0053,round1+2,sence_indoor_0076-第二轮,17
+sence_indoor_0054,round1+2,sence_indoor_0077,21
+sence_indoor_0055,round1+2,sence_indoor_0083,33
+sence_indoor_0056,round1+2,sence_indoor_0084,53
+sence_indoor_0057,round1+2,sence_indoor_0085,53
+sence_indoor_0058,round1+2,sence_indoor_0086,53
+sence_indoor_0059,round1+2,sence_indoor_0088,33
+sence_indoor_0060,round1+2,sence_indoor_0089,23
+sence_indoor_0061,round1+2,sence_indoor_0091,17
+sence_indoor_0062,round1+2,sence_indoor_0092,33
+sence_indoor_0063,round1+2,sence_indoor_0092-第二轮,53
+sence_indoor_0064,round1+2,sence_indoor_0094,9
+sence_indoor_0065,round1+2,sence_indoor_0094-第二轮,46
+sence_indoor_0066,round1+2,sence_indoor_0095,33
+sence_indoor_0067,round1+2,sence_indoor_0096,30
+sence_indoor_0068,round1+2,sence_indoor_0098,52
+sence_indoor_0069,round1+2,sence_indoor_0100,33
+sence_indoor_0070,round1+2,sence_indoor_0100-第二轮,53
+sence_indoor_0071,round1+2,sence_indoor_0102,22
+sence_indoor_0072,round1+2,sence_indoor_0104,33
+sence_indoor_0073,round1+2,sence_indoor_0105,33
+sence_indoor_0074,round1+2,sence_indoor_0106,33
+sence_indoor_0075,round1+2,sence_indoor_0108,53
+sence_indoor_0076,round1+2,sence_indoor_0111,33
+sence_indoor_0077,round1+2,sence_indoor_0111-第二轮,12
+sence_indoor_0078,round1+2,sence_indoor_0112,33
+sence_indoor_0079,round1+2,sence_indoor_0113,29
+sence_indoor_0080,round1+2,sence_indoor_0113-第二轮,50
+sence_indoor_0081,round1+2,sence_indoor_0114,33
+sence_indoor_0082,round1+2,sence_indoor_0116,53
+sence_indoor_0083,round1+2,sence_indoor_0122,33
+sence_indoor_0084,round1+2,sence_indoor_0123,52
+sence_indoor_0085,round1+2,sence_indoor_0124,33
+sence_indoor_0086,round1+2,sence_indoor_0124-第二轮,49
+sence_indoor_0087,round1+2,sence_indoor_0125,53
+sence_indoor_0088,round1+2,sence_indoor_0127,29
+sence_indoor_0089,round1+2,sence_indoor_0128,33
+sence_indoor_0090,round1+2,sence_indoor_0128-第二轮,16
+sence_indoor_0091,round1+2,sence_indoor_0129,53
+sence_indoor_0092,round1+2,sence_indoor_0131,33
+sence_indoor_0093,round1+2,sence_indoor_0132,33
+sence_indoor_0094,round1+2,sence_indoor_0132-第二轮,7
+sence_indoor_0095,round1+2,sence_indoor_0134,33
+sence_indoor_0096,round1+2,sence_indoor_0135,13
+sence_indoor_0097,round1+2,sence_indoor_0135-第二轮,53
+sence_indoor_0098,round1+2,sence_indoor_0137,53
+sence_indoor_0099,round1+2,sence_indoor_0138,29
+sence_indoor_0100,round1+2,sence_indoor_0139,33
+sence_indoor_0101,round1+2,sence_indoor_0139-第二轮,15
+sence_indoor_0102,round1+2,sence_indoor_0140,29
+sence_indoor_0103,round1+2,sence_indoor_0141,33
+sence_indoor_0104,round1+2,sence_indoor_0142,33
+sence_indoor_0105,round1+2,sence_indoor_0144,25
+sence_indoor_0106,round1+2,sence_indoor_0145,13
+sence_indoor_0107,round1+2,sence_indoor_0146,33
+sence_indoor_0108,round1+2,sence_indoor_0150,29
+sence_indoor_0109,round1+2,sence_indoor_0153-第二轮,30
+sence_indoor_0110,round1+2,sence_indoor_0155,30
+sence_indoor_0111,round1+2,sence_indoor_0156,53
+sence_indoor_0112,round1+2,sence_indoor_0165-第二轮,53
+sence_indoor_0113,round1+2,sence_indoor_0169,9
+sence_indoor_0114,round1+2,sence_indoor_0169-第二轮,53
+sence_indoor_0115,round1+2,sence_indoor_0170,21
+sence_indoor_0116,round1+2,sence_indoor_0170-第二轮,51
+sence_indoor_0117,round1+2,sence_indoor_0172,36
+sence_indoor_0118,round1+2,sence_indoor_0173,33
+sence_indoor_0119,round1+2,sence_indoor_0174,29
+sence_indoor_0120,round1+2,sence_indoor_0175,29
+sence_indoor_0121,round1+2,sence_indoor_0177,13
+sence_indoor_0122,round1+2,sence_indoor_0177-第二轮,53
+sence_indoor_0123,round1+2,sence_indoor_0180,27
+sence_indoor_0124,round1+2,sence_indoor_0181,47
+sence_indoor_0125,round1+2,sence_indoor_0182,25
+sence_indoor_0126,round1+2,sence_indoor_0184,53
+sence_indoor_0127,round1+2,sence_indoor_0192,48
+sence_indoor_0128,round1+2,sence_indoor_0193,33
+sence_indoor_0129,round1+2,sence_indoor_0194,24
+sence_indoor_0130,round1+2,sence_indoor_0216,33
+sence_indoor_0131,round1+2,sence_indoor_0230,14
+sence_indoor_0132,round1+2,sence_indoor_0234,30
+sence_indoor_0133,round1+2,sence_indoor_0238,33
+sence_indoor_0134,round1+2,sence_indoor_0239,33
+sence_indoor_0135,round1+2,sence_indoor_0245,29
+sence_indoor_0136,round1+2,sence_indoor_0248,33
+sence_indoor_0137,round1+2,sence_indoor_0252,33
+sence_indoor_0138,round1+2,sence_indoor_0255,33
+sence_indoor_0139,round1+2,sence_indoor_0260,29
+sence_indoor_0140,round1+2,sence_indoor_0264,26
+sence_indoor_0141,round1+2,sence_indoor_0266,29
+sence_indoor_0142,round1+2,sence_indoor_0267,33
+sence_indoor_0143,round1+2,sence_indoor_0268,32
+sence_indoor_0144,round1+2,sence_indoor_0269,29
+sence_indoor_0145,round1+2,sence_indoor_0270,29
+sence_indoor_0146,round1+2,sence_indoor_0271,28
+sence_indoor_0147,round1+2,sence_indoor_0276,33
+sence_indoor_0148,round1+2,sence_indoor_0277,25
+sence_indoor_0149,round1+2,sence_indoor_0284,33
+sence_indoor_0150,round1+2,sence_indoor_0285,31
+sence_indoor_0151,round1+2,sence_indoor_0290,33
+sence_indoor_0152,round1+2,sence_indoor_0294,33
+sence_indoor_0153,round1+2,sence_indoor_0295,33
+sence_indoor_0154,round1+2,sence_indoor_0295-第二轮,53
+sence_indoor_0155,round1+2,sence_indoor_0296,33
+sence_indoor_0156,round1+2,sence_indoor_0296-第二轮,53
+sence_indoor_0157,round1+2,sence_indoor_0297,7
+sence_indoor_0158,round1+2,sence_indoor_0298,50
+sence_indoor_0159,round1+2,sence_indoor_0301,31
+sence_indoor_0160,round1+2,sence_indoor_0302,53
+sence_indoor_0161,round1+2,sence_indoor_0305,53
+sence_indoor_0162,round1+2,sence_indoor_0306,28
+sence_indoor_0163,round1+2,sence_indoor_0308,24
+sence_indoor_0164,round1+2,sence_indoor_0309,53
+sence_indoor_0165,round1+2,sence_indoor_0315,33
+sence_indoor_0166,round1+2,sence_indoor_0317,25
+sence_indoor_0167,round1+2,sence_indoor_0317-第二轮,16
+sence_indoor_0168,round1+2,sence_indoor_0319,22
+sence_indoor_0169,round1+2,sence_indoor_0320,23
+sence_indoor_0170,round1+2,sence_indoor_0320-第二轮,53
+sence_indoor_0171,round1+2,sence_indoor_0325,27
+sence_indoor_0172,round1+2,sence_indoor_0325-第二轮,53
+sence_indoor_0173,round1+2,sence_indoor_0326,33
+sence_indoor_0174,round1+2,sence_indoor_0327,53
+sence_indoor_0175,round1+2,sence_indoor_0328,19
+sence_indoor_0176,round1+2,sence_indoor_0329,31
+sence_indoor_0177,round1+2,sence_indoor_0330,53
+sence_indoor_0178,round1+2,sence_indoor_0331,47
+sence_indoor_0179,round1+2,sence_indoor_0334,53
+sence_indoor_0180,round1+2,sence_indoor_0335,33
+sence_indoor_0181,round1+2,sence_indoor_0339,40
+sence_indoor_0182,round1+2,sence_indoor_0341,26
+sence_indoor_0183,round1+2,sence_indoor_0343,51
+sence_indoor_0184,round1+2,sence_indoor_0347,53
+sence_indoor_0185,round1+2,sence_indoor_0349,34
+sence_indoor_0186,round1+2,sence_indoor_0350,53
+sence_indoor_0187,round1+2,sence_indoor_0355,33
+sence_indoor_0188,round1+2,sence_indoor_0358,33
+sence_indoor_0189,round1+2,sence_indoor_0360,3
+sence_indoor_0190,round1+2,sence_indoor_0362,29
+sence_indoor_0191,round1+2,sence_indoor_0364,19
+sence_indoor_0192,round1+2,sence_indoor_0365,33
+sence_indoor_0193,round1+2,sence_indoor_0372,33
+sence_indoor_0194,round1+2,sence_indoor_0377,31
+sence_indoor_0195,round1+2,sence_indoor_0379,33
+sence_indoor_0196,round1+2,sence_indoor_0381,33
+sence_indoor_0197,round1+2,sence_indoor_0382,33
+sence_indoor_0198,round1+2,sence_indoor_0385,33
+sence_indoor_0199,round1+2,sence_indoor_0389,33
+sence_indoor_0200,round1+2,sence_indoor_0393,26
+sence_indoor_0201,round1+2,sence_indoor_0394,20
+sence_indoor_0202,round2,sence_indoor_0002,53
+sence_indoor_0203,round2,sence_indoor_0009,53
+sence_indoor_0204,round2,sence_indoor_0019,38
+sence_indoor_0205,round2,sence_indoor_0020,47
+sence_indoor_0206,round2,sence_indoor_0022,19
+sence_indoor_0207,round2,sence_indoor_0030,53
+sence_indoor_0208,round2,sence_indoor_0032,52
+sence_indoor_0209,round2,sence_indoor_0033,48
+sence_indoor_0210,round2,sence_indoor_0034,41
+sence_indoor_0211,round2,sence_indoor_0035,48
+sence_indoor_0212,round2,sence_indoor_0038,37
+sence_indoor_0213,round2,sence_indoor_0039,18
+sence_indoor_0214,round2,sence_indoor_0047,44
+sence_indoor_0215,round2,sence_indoor_0051,53
+sence_indoor_0216,round2,sence_indoor_0062,21
+sence_indoor_0217,round2,sence_indoor_0064,28
+sence_indoor_0218,round2,sence_indoor_0065,51
+sence_indoor_0219,round2,sence_indoor_0073,20
+sence_indoor_0220,round2,sence_indoor_0081,53
+sence_indoor_0221,round2,sence_indoor_0087,53
+sence_indoor_0222,round2,sence_indoor_0089,53
+sence_indoor_0223,round2,sence_indoor_0090,14
+sence_indoor_0224,round2,sence_indoor_0091,30
+sence_indoor_0225,round2,sence_indoor_0095,42
+sence_indoor_0226,round2,sence_indoor_0096,37
+sence_indoor_0227,round2,sence_indoor_0101,34
+sence_indoor_0228,round2,sence_indoor_0102,53
+sence_indoor_0229,round2,sence_indoor_0103,39
+sence_indoor_0230,round2,sence_indoor_0104,29
+sence_indoor_0231,round2,sence_indoor_0114,38
+sence_indoor_0232,round2,sence_indoor_0115,52
+sence_indoor_0233,round2,sence_indoor_0117,17
+sence_indoor_0234,round2,sence_indoor_0118,29
+sence_indoor_0235,round2,sence_indoor_0119,50
+sence_indoor_0236,round2,sence_indoor_0120,43
+sence_indoor_0237,round2,sence_indoor_0126,51
+sence_indoor_0238,round2,sence_indoor_0131,49
+sence_indoor_0239,round2,sence_indoor_0133,53
+sence_indoor_0240,round2,sence_indoor_0134,35
+sence_indoor_0241,round2,sence_indoor_0136,53
+sence_indoor_0242,round2,sence_indoor_0138,45
+sence_indoor_0243,round2,sence_indoor_0140,31
+sence_indoor_0244,round2,sence_indoor_0147,29
+sence_indoor_0245,round2,sence_indoor_0148,53
+sence_indoor_0246,round2,sence_indoor_0161,50
+sence_indoor_0247,round2,sence_indoor_0164,53
+sence_indoor_0248,round2,sence_indoor_0166,53
+sence_indoor_0249,round2,sence_indoor_0167,53
+sence_indoor_0250,round2,sence_indoor_0171,53
+sence_indoor_0251,round2,sence_indoor_0182,33
+sence_indoor_0252,round2,sence_indoor_0187,50
+sence_indoor_0253,round2,sence_indoor_0191,35
+sence_indoor_0254,round2,sence_indoor_0193,46
+sence_indoor_0255,round2,sence_indoor_0195,53
+sence_indoor_0256,round2,sence_indoor_0196,14
+sence_indoor_0257,round2,sence_indoor_0197,53
+sence_indoor_0258,round2,sence_indoor_0198,29
+sence_indoor_0259,round2,sence_indoor_0199,53
+sence_indoor_0260,round2,sence_indoor_0200,53
+sence_indoor_0261,round2,sence_indoor_0201,6
+sence_indoor_0262,round2,sence_indoor_0202,2
+sence_indoor_0263,round2,sence_indoor_0203,4
+sence_indoor_0264,round2,sence_indoor_0204,53
+sence_indoor_0265,round2,sence_indoor_0205,53
+sence_indoor_0266,round2,sence_indoor_0206,54
+sence_indoor_0267,round2,sence_indoor_0207,1
+sence_indoor_0268,round2,sence_indoor_0208,53
+sence_indoor_0269,round2,sence_indoor_0209,3
+sence_indoor_0270,round2,sence_indoor_0210,53
+sence_indoor_0271,round2,sence_indoor_0211,9
+sence_indoor_0272,round2,sence_indoor_0212,53
+sence_indoor_0273,round2,sence_indoor_0213,53
+sence_indoor_0274,round2,sence_indoor_0215,53
+sence_indoor_0275,round2,sence_indoor_0216,12
+sence_indoor_0276,round2,sence_indoor_0217,16
+sence_indoor_0277,round2,sence_indoor_0218,53
+sence_indoor_0278,round2,sence_indoor_0219,53
+sence_indoor_0279,round2,sence_indoor_0220,53
+sence_indoor_0280,round2,sence_indoor_0221,53
+sence_indoor_0281,round2,sence_indoor_0222,39
+sence_indoor_0282,round2,sence_indoor_0224,49
+sence_indoor_0283,round2,sence_indoor_0225,21
+sence_indoor_0284,round2,sence_indoor_0226,53
+sence_indoor_0285,round2,sence_indoor_0227,53
+sence_indoor_0286,round2,sence_indoor_0228,22
+sence_indoor_0287,round2,sence_indoor_0229,53
+sence_indoor_0288,round2,sence_indoor_0230,53
+sence_indoor_0289,round2,sence_indoor_0231,53
+sence_indoor_0290,round2,sence_indoor_0232,53
+sence_indoor_0291,round2,sence_indoor_0233,21
+sence_indoor_0292,round2,sence_indoor_0234,53
+sence_indoor_0293,round2,sence_indoor_0235,53
+sence_indoor_0294,round2,sence_indoor_0236,53
+sence_indoor_0295,round2,sence_indoor_0237,37
+sence_indoor_0296,round2,sence_indoor_0238,53
+sence_indoor_0297,round2,sence_indoor_0239,53
+sence_indoor_0298,round2,sence_indoor_0242,9
+sence_indoor_0299,round2,sence_indoor_0243,6
+sence_indoor_0300,round2,sence_indoor_0244,2
+sence_indoor_0301,round2,sence_indoor_0247,53
+sence_indoor_0302,round2,sence_indoor_0248,53
+sence_indoor_0303,round2,sence_indoor_0249,25
+sence_indoor_0304,round2,sence_indoor_0250,48
+sence_indoor_0305,round2,sence_indoor_0252,2
+sence_indoor_0306,round2,sence_indoor_0253,53
+sence_indoor_0307,round2,sence_indoor_0254,3
+sence_indoor_0308,round2,sence_indoor_0255,53
+sence_indoor_0309,round2,sence_indoor_0256,53
+sence_indoor_0310,round2,sence_indoor_0257,2
+sence_indoor_0311,round2,sence_indoor_0258,53
+sence_indoor_0312,round2,sence_indoor_0260,45
+sence_indoor_0313,round2,sence_indoor_0261,3
+sence_indoor_0314,round2,sence_indoor_0262,37
+sence_indoor_0315,round2,sence_indoor_0263,53
+sence_indoor_0316,round2,sence_indoor_0264,53
+sence_indoor_0317,round2,sence_indoor_0265,48
+sence_indoor_0318,round2,sence_indoor_0266,53
+sence_indoor_0319,round2,sence_indoor_0268,49
+sence_indoor_0320,round2,sence_indoor_0269,1
+sence_indoor_0321,round2,sence_indoor_0270,53
+sence_indoor_0322,round2,sence_indoor_0271,16
+sence_indoor_0323,round2,sence_indoor_0272,29
+sence_indoor_0324,round2,sence_indoor_0273,4
+sence_indoor_0325,round2,sence_indoor_0274,14
+sence_indoor_0326,round2,sence_indoor_0275,53
+sence_indoor_0327,round2,sence_indoor_0276,53
+sence_indoor_0328,round2,sence_indoor_0277,53
+sence_indoor_0329,round2,sence_indoor_0278,53
+sence_indoor_0330,round2,sence_indoor_0279,53
+sence_indoor_0331,round2,sence_indoor_0280,15
+sence_indoor_0332,round2,sence_indoor_0281,53
+sence_indoor_0333,round2,sence_indoor_0282,53
+sence_indoor_0334,round2,sence_indoor_0283,53
+sence_indoor_0335,round2,sence_indoor_0284,53
+sence_indoor_0336,round2,sence_indoor_0286,53
+sence_indoor_0337,round2,sence_indoor_0287,53
+sence_indoor_0338,round2,sence_indoor_0288,53
+sence_indoor_0339,round2,sence_indoor_0289,14
+sence_indoor_0340,round2,sence_indoor_0290,2
+sence_indoor_0341,round2,sence_indoor_0291,5
+sence_indoor_0342,round2,sence_indoor_0292,53
+sence_indoor_0343,round2,sence_indoor_0293,37
+sence_indoor_0344,round2,sence_indoor_0294,53
+sence_indoor_0345,round2,sence_indoor_0297,53
+sence_indoor_0346,round2,sence_indoor_0299,53
+sence_indoor_0347,round2,sence_indoor_0300,1
+sence_indoor_0348,round2,sence_indoor_0301,53
+sence_indoor_0349,round2,sence_indoor_0303,53
+sence_indoor_0350,round2,sence_indoor_0304,53
+sence_indoor_0351,round2,sence_indoor_0306,53
+sence_indoor_0352,round2,sence_indoor_0307,53
+sence_indoor_0353,round2,sence_indoor_0308,53
+sence_indoor_0354,round2,sence_indoor_0310,53
+sence_indoor_0355,round2,sence_indoor_0311,53
+sence_indoor_0356,round2,sence_indoor_0312,53
+sence_indoor_0357,round2,sence_indoor_0313,2
+sence_indoor_0358,round2,sence_indoor_0314,53
+sence_indoor_0359,round2,sence_indoor_0315,6
+sence_indoor_0360,round2,sence_indoor_0316,53
+sence_indoor_0361,round2,sence_indoor_0318,53
+sence_indoor_0362,round2,sence_indoor_0319,53
+sence_indoor_0363,round2,sence_indoor_0321,53
+sence_indoor_0364,round2,sence_indoor_0323,53
+sence_indoor_0365,round2,sence_indoor_0324,20
+sence_indoor_0366,round2,sence_indoor_0326,53
+sence_indoor_0367,round2,sence_indoor_0328,53
+sence_indoor_0368,round2,sence_indoor_0332,28
+sence_indoor_0369,round2,sence_indoor_0333,26
+sence_indoor_0370,round2,sence_indoor_0338,13
+sence_indoor_0371,round2,sence_indoor_0340,51
+sence_indoor_0372,round2,sence_indoor_0342,31
+sence_indoor_0373,round2,sence_indoor_0344,45
+sence_indoor_0374,round2,sence_indoor_0346,41

blender_indoor/metadata/source_manifest.json

@@ -0,0 +1,29 @@
+{
+  "source": "blender_indoor",
+  "license": "CC-BY-4.0",
+  "scene_count": 374,
+  "frame_count": 13631,
+  "rounds": {
+    "round1+2": {
+      "scene_count": 201,
+      "frame_count": 6740
+    },
+    "round2": {
+      "scene_count": 173,
+      "frame_count": 6891
+    }
+  },
+  "scene_id_range": [
+    "sence_indoor_0001",
+    "sence_indoor_0374"
+  ],
+  "naming": {
+    "scene_id_format": "sence_indoor_{0001..NNNN}",
+    "frame_files": [
+      "panorama_{idx:04d}.png",
+      "panorama_{idx:04d}_depth.npy",
+      "pose_{idx:04d}.json"
+    ],
+    "id_origin_traceability": "see scene_id_mapping.csv and frame_id_mapping.csv"
+  }
+}

blender_indoor/metadata/splits.json

@@ -0,0 +1,388 @@
+{
+  "strategy": "scene-level 70/15/15 via sha256(new_scene_id) % 100",
+  "counts": {
+    "train": 254,
+    "val": 73,
+    "test": 47
+  },
+  "train": [
+    "sence_indoor_0002",
+    "sence_indoor_0003",
+    "sence_indoor_0004",
+    "sence_indoor_0005",
+    "sence_indoor_0008",
+    "sence_indoor_0009",
+    "sence_indoor_0012",
+    "sence_indoor_0013",
+    "sence_indoor_0014",
+    "sence_indoor_0015",
+    "sence_indoor_0018",
+    "sence_indoor_0019",
+    "sence_indoor_0020",
+    "sence_indoor_0021",
+    "sence_indoor_0022",
+    "sence_indoor_0023",
+    "sence_indoor_0025",
+    "sence_indoor_0026",
+    "sence_indoor_0027",
+    "sence_indoor_0028",
+    "sence_indoor_0030",
+    "sence_indoor_0031",
+    "sence_indoor_0033",
+    "sence_indoor_0034",
+    "sence_indoor_0036",
+    "sence_indoor_0038",
+    "sence_indoor_0040",
+    "sence_indoor_0041",
+    "sence_indoor_0042",
+    "sence_indoor_0043",
+    "sence_indoor_0046",
+    "sence_indoor_0047",
+    "sence_indoor_0048",
+    "sence_indoor_0049",
+    "sence_indoor_0050",
+    "sence_indoor_0051",
+    "sence_indoor_0052",
+    "sence_indoor_0053",
+    "sence_indoor_0055",
+    "sence_indoor_0056",
+    "sence_indoor_0057",
+    "sence_indoor_0059",
+    "sence_indoor_0060",
+    "sence_indoor_0062",
+    "sence_indoor_0063",
+    "sence_indoor_0064",
+    "sence_indoor_0068",
+    "sence_indoor_0069",
+    "sence_indoor_0072",
+    "sence_indoor_0074",
+    "sence_indoor_0075",
+    "sence_indoor_0076",
+    "sence_indoor_0077",
+    "sence_indoor_0078",
+    "sence_indoor_0079",
+    "sence_indoor_0080",
+    "sence_indoor_0082",
+    "sence_indoor_0083",
+    "sence_indoor_0084",
+    "sence_indoor_0085",
+    "sence_indoor_0087",
+    "sence_indoor_0088",
+    "sence_indoor_0089",
+    "sence_indoor_0090",
+    "sence_indoor_0091",
+    "sence_indoor_0092",
+    "sence_indoor_0094",
+    "sence_indoor_0096",
+    "sence_indoor_0097",
+    "sence_indoor_0098",
+    "sence_indoor_0100",
+    "sence_indoor_0102",
+    "sence_indoor_0104",
+    "sence_indoor_0105",
+    "sence_indoor_0106",
+    "sence_indoor_0107",
+    "sence_indoor_0108",
+    "sence_indoor_0109",
+    "sence_indoor_0110",
+    "sence_indoor_0112",
+    "sence_indoor_0113",
+    "sence_indoor_0114",
+    "sence_indoor_0115",
+    "sence_indoor_0116",
+    "sence_indoor_0117",
+    "sence_indoor_0118",
+    "sence_indoor_0119",
+    "sence_indoor_0120",
+    "sence_indoor_0123",
+    "sence_indoor_0124",
+    "sence_indoor_0125",
+    "sence_indoor_0129",
+    "sence_indoor_0130",
+    "sence_indoor_0132",
+    "sence_indoor_0133",
+    "sence_indoor_0134",
+    "sence_indoor_0135",
+    "sence_indoor_0137",
+    "sence_indoor_0138",
+    "sence_indoor_0140",
+    "sence_indoor_0141",
+    "sence_indoor_0142",
+    "sence_indoor_0143",
+    "sence_indoor_0148",
+    "sence_indoor_0149",
+    "sence_indoor_0150",
+    "sence_indoor_0152",
+    "sence_indoor_0154",
+    "sence_indoor_0156",
+    "sence_indoor_0157",
+    "sence_indoor_0158",
+    "sence_indoor_0159",
+    "sence_indoor_0160",
+    "sence_indoor_0161",
+    "sence_indoor_0162",
+    "sence_indoor_0163",
+    "sence_indoor_0165",
+    "sence_indoor_0167",
+    "sence_indoor_0168",
+    "sence_indoor_0169",
+    "sence_indoor_0170",
+    "sence_indoor_0171",
+    "sence_indoor_0174",
+    "sence_indoor_0176",
+    "sence_indoor_0177",
+    "sence_indoor_0179",
+    "sence_indoor_0181",
+    "sence_indoor_0183",
+    "sence_indoor_0184",
+    "sence_indoor_0185",
+    "sence_indoor_0186",
+    "sence_indoor_0187",
+    "sence_indoor_0189",
+    "sence_indoor_0194",
+    "sence_indoor_0195",
+    "sence_indoor_0197",
+    "sence_indoor_0200",
+    "sence_indoor_0202",
+    "sence_indoor_0204",
+    "sence_indoor_0205",
+    "sence_indoor_0206",
+    "sence_indoor_0207",
+    "sence_indoor_0209",
+    "sence_indoor_0212",
+    "sence_indoor_0213",
+    "sence_indoor_0214",
+    "sence_indoor_0215",
+    "sence_indoor_0217",
+    "sence_indoor_0218",
+    "sence_indoor_0221",
+    "sence_indoor_0223",
+    "sence_indoor_0225",
+    "sence_indoor_0227",
+    "sence_indoor_0228",
+    "sence_indoor_0229",
+    "sence_indoor_0233",
+    "sence_indoor_0234",
+    "sence_indoor_0235",
+    "sence_indoor_0238",
+    "sence_indoor_0239",
+    "sence_indoor_0240",
+    "sence_indoor_0241",
+    "sence_indoor_0244",
+    "sence_indoor_0245",
+    "sence_indoor_0246",
+    "sence_indoor_0249",
+    "sence_indoor_0252",
+    "sence_indoor_0254",
+    "sence_indoor_0256",
+    "sence_indoor_0258",
+    "sence_indoor_0261",
+    "sence_indoor_0263",
+    "sence_indoor_0264",
+    "sence_indoor_0266",
+    "sence_indoor_0267",
+    "sence_indoor_0268",
+    "sence_indoor_0269",
+    "sence_indoor_0272",
+    "sence_indoor_0273",
+    "sence_indoor_0274",
+    "sence_indoor_0275",
+    "sence_indoor_0276",
+    "sence_indoor_0277",
+    "sence_indoor_0278",
+    "sence_indoor_0279",
+    "sence_indoor_0281",
+    "sence_indoor_0282",
+    "sence_indoor_0283",
+    "sence_indoor_0284",
+    "sence_indoor_0285",
+    "sence_indoor_0286",
+    "sence_indoor_0288",
+    "sence_indoor_0289",
+    "sence_indoor_0291",
+    "sence_indoor_0292",
+    "sence_indoor_0293",
+    "sence_indoor_0294",
+    "sence_indoor_0295",
+    "sence_indoor_0296",
+    "sence_indoor_0299",
+    "sence_indoor_0300",
+    "sence_indoor_0302",
+    "sence_indoor_0304",
+    "sence_indoor_0305",
+    "sence_indoor_0307",
+    "sence_indoor_0308",
+    "sence_indoor_0310",
+    "sence_indoor_0311",
+    "sence_indoor_0316",
+    "sence_indoor_0317",
+    "sence_indoor_0318",
+    "sence_indoor_0320",
+    "sence_indoor_0321",
+    "sence_indoor_0323",
+    "sence_indoor_0324",
+    "sence_indoor_0325",
+    "sence_indoor_0326",
+    "sence_indoor_0328",
+    "sence_indoor_0331",
+    "sence_indoor_0333",
+    "sence_indoor_0334",
+    "sence_indoor_0335",
+    "sence_indoor_0336",
+    "sence_indoor_0337",
+    "sence_indoor_0338",
+    "sence_indoor_0339",
+    "sence_indoor_0340",
+    "sence_indoor_0341",
+    "sence_indoor_0343",
+    "sence_indoor_0344",
+    "sence_indoor_0345",
+    "sence_indoor_0346",
+    "sence_indoor_0347",
+    "sence_indoor_0348",
+    "sence_indoor_0349",
+    "sence_indoor_0350",
+    "sence_indoor_0351",
+    "sence_indoor_0353",
+    "sence_indoor_0354",
+    "sence_indoor_0355",
+    "sence_indoor_0356",
+    "sence_indoor_0357",
+    "sence_indoor_0358",
+    "sence_indoor_0360",
+    "sence_indoor_0361",
+    "sence_indoor_0363",
+    "sence_indoor_0365",
+    "sence_indoor_0367",
+    "sence_indoor_0368",
+    "sence_indoor_0369",
+    "sence_indoor_0370",
+    "sence_indoor_0371",
+    "sence_indoor_0372",
+    "sence_indoor_0374"
+  ],
+  "val": [
+    "sence_indoor_0001",
+    "sence_indoor_0006",
+    "sence_indoor_0010",
+    "sence_indoor_0011",
+    "sence_indoor_0017",
+    "sence_indoor_0035",
+    "sence_indoor_0037",
+    "sence_indoor_0039",
+    "sence_indoor_0045",
+    "sence_indoor_0058",
+    "sence_indoor_0061",
+    "sence_indoor_0065",
+    "sence_indoor_0066",
+    "sence_indoor_0073",
+    "sence_indoor_0081",
+    "sence_indoor_0086",
+    "sence_indoor_0099",
+    "sence_indoor_0103",
+    "sence_indoor_0122",
+    "sence_indoor_0128",
+    "sence_indoor_0131",
+    "sence_indoor_0139",
+    "sence_indoor_0144",
+    "sence_indoor_0146",
+    "sence_indoor_0151",
+    "sence_indoor_0166",
+    "sence_indoor_0172",
+    "sence_indoor_0173",
+    "sence_indoor_0175",
+    "sence_indoor_0178",
+    "sence_indoor_0180",
+    "sence_indoor_0182",
+    "sence_indoor_0188",
+    "sence_indoor_0191",
+    "sence_indoor_0192",
+    "sence_indoor_0193",
+    "sence_indoor_0196",
+    "sence_indoor_0199",
+    "sence_indoor_0201",
+    "sence_indoor_0203",
+    "sence_indoor_0208",
+    "sence_indoor_0210",
+    "sence_indoor_0216",
+    "sence_indoor_0219",
+    "sence_indoor_0224",
+    "sence_indoor_0226",
+    "sence_indoor_0231",
+    "sence_indoor_0232",
+    "sence_indoor_0236",
+    "sence_indoor_0237",
+    "sence_indoor_0248",
+    "sence_indoor_0250",
+    "sence_indoor_0251",
+    "sence_indoor_0255",
+    "sence_indoor_0257",
+    "sence_indoor_0259",
+    "sence_indoor_0260",
+    "sence_indoor_0262",
+    "sence_indoor_0270",
+    "sence_indoor_0280",
+    "sence_indoor_0290",
+    "sence_indoor_0297",
+    "sence_indoor_0301",
+    "sence_indoor_0312",
+    "sence_indoor_0314",
+    "sence_indoor_0315",
+    "sence_indoor_0319",
+    "sence_indoor_0330",
+    "sence_indoor_0342",
+    "sence_indoor_0352",
+    "sence_indoor_0359",
+    "sence_indoor_0362",
+    "sence_indoor_0373"
+  ],
+  "test": [
+    "sence_indoor_0007",
+    "sence_indoor_0016",
+    "sence_indoor_0024",
+    "sence_indoor_0029",
+    "sence_indoor_0032",
+    "sence_indoor_0044",
+    "sence_indoor_0054",
+    "sence_indoor_0067",
+    "sence_indoor_0070",
+    "sence_indoor_0071",
+    "sence_indoor_0093",
+    "sence_indoor_0095",
+    "sence_indoor_0101",
+    "sence_indoor_0111",
+    "sence_indoor_0121",
+    "sence_indoor_0126",
+    "sence_indoor_0127",
+    "sence_indoor_0136",
+    "sence_indoor_0145",
+    "sence_indoor_0147",
+    "sence_indoor_0153",
+    "sence_indoor_0155",
+    "sence_indoor_0164",
+    "sence_indoor_0190",
+    "sence_indoor_0198",
+    "sence_indoor_0211",
+    "sence_indoor_0220",
+    "sence_indoor_0222",
+    "sence_indoor_0230",
+    "sence_indoor_0242",
+    "sence_indoor_0243",
+    "sence_indoor_0247",
+    "sence_indoor_0253",
+    "sence_indoor_0265",
+    "sence_indoor_0271",
+    "sence_indoor_0287",
+    "sence_indoor_0298",
+    "sence_indoor_0303",
+    "sence_indoor_0306",
+    "sence_indoor_0309",
+    "sence_indoor_0313",
+    "sence_indoor_0322",
+    "sence_indoor_0327",
+    "sence_indoor_0329",
+    "sence_indoor_0332",
+    "sence_indoor_0364",
+    "sence_indoor_0366"
+  ]
+}

code/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 Anonymous Authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

code/README.md

@@ -0,0 +1,70 @@
+# CM-EVS curator code (reviewer reference)
+
+This directory mirrors the curator source code from the (anonymized) GitHub release. It's included here so reviewers can cross-reference implementation details against the paper without needing two URLs.
+
+## Layout
+
+```
+code/
+├── core/                       (curator core modules — coordinate, ERP projection / warping,
+│                                tangent extraction, depth fusion, …)
+├── scripts/                    (per-step CLI scripts — build_candidates, select_views,
+│                                render_selected, evaluate_coverage, evaluate_oracle_gap,
+│                                audit_quality, run_tiny.sh, …)
+├── pipelines/                  (per-source end-to-end runners — Blender, HM3D,
+│                                ScanNet++, full multi-source pipeline)
+├── tools/                      (helper tools — make_sha256sums.sh,
+│                                update_croissant_with_real_hashes.py, …)
+├── configs/                    (per-source YAML configs used by pipelines)
+├── metadata_examples/          (JSON schemas: candidates, selected_viewpoints,
+│                                per_step_log)
+├── examples/tiny_blender_scene/  (smoke-test fixture — run scripts/run_tiny.sh)
+├── dataset_metadata/           (croissant.json reference copy; same as top-level
+│                                ../croissant.json)
+├── environment.yml             (conda environment)
+├── requirements.txt            (pip fallback)
+└── LICENSE                     (MIT)
+```
+
+## Quick start
+
+```bash
+conda env create -f environment.yml
+conda activate cmevs
+
+# tiny smoke test (uses examples/tiny_blender_scene/)
+bash scripts/run_tiny.sh
+
+# real run:
+python pipelines/run_blend_pipeline.py    --config configs/blender_indoor.yaml
+python pipelines/run_hm3d_pipeline.py     --config configs/hm3d.yaml
+python pipelines/run_ply_pipeline.py      --config configs/scannetpp.yaml
+```
+
+## Mapping paper sections → code
+
+| Paper section | Code |
+| --- | --- |
+| §3.1 Setup (candidates, budget, coverage) | `scripts/build_candidates.py`, `core/coordinate.py` |
+| §3.2 Conflict-aware warping oracle | `core/erp_warp.py`, `scripts/selection_metrics.py` |
+| §3.3 Pipeline three phases | `pipelines/run_blend_pipeline.py`, `run_hm3d_pipeline.py`, `run_ply_pipeline.py` |
+| §3.4 Adapters (Table 2) | `pipelines/run_*_pipeline.py` per source |
+| Algorithm 1 (greedy) | `scripts/select_views.py` |
+| §3.6 Adaptive frame budgets (early stop) | `scripts/select_views.py` (`stop_gain`, `stop_score`, `stop_delta` flags) |
+| §4.1 Output schema | `core/coordinate.py`, `core/erp_projection.py`, `metadata_examples/*.schema.json` |
+| §4.8 per-frame quality | `scripts/audit_quality.py` |
+| §5.1 Fixed-budget coverage | `scripts/evaluate_coverage.py` |
+| §5.2 Warping oracle vs pre-render-all | `scripts/evaluate_oracle_gap.py` |
+| §F.2 50-frame audit | `scripts/audit_quality.py` (extended audit mode) |
+
+## Reproducibility
+
+All curator parameters that affect paper numbers are in `configs/*.yaml`. The reviewer can:
+
+1. Inspect each YAML to confirm parameter values match the paper.
+2. Run a smoke test against `examples/tiny_blender_scene/` to confirm the code executes end-to-end.
+3. Reproduce the full pipeline against actual data (Blender indoor frames are in `../blender_indoor/`; HM3D / ScanNet++ / outdoor data must be obtained from upstream).
+
+## License
+
+MIT — see `LICENSE` and the top-level `../LICENSE.md` for the full per-component matrix.

code/README_REPRODUCE.md

@@ -0,0 +1,95 @@
+# Reproducibility Guide
+
+This guide maps the code release to the experiments in the paper. The primary reproducibility path is Blender indoor; other sources are retained as secondary adapters for robustness checks.
+
+## Primary Asset Requirement
+
+| Source | Expected Input | Primary Command |
+| --- | --- | --- |
+| Blender indoor | `.blend` scenes | `scripts/run_blender_indoor.sh` |
+
+The repository does not redistribute scene assets. Reviewers can run the no-data smoke test immediately, and can run the full path after mounting local `.blend` scenes.
+
+## Secondary Assets
+
+| Source | Expected Input | Config |
+| --- | --- | --- |
+| Blender outdoor / generic meshes | `.glb` or `.gltf` | `configs/blender_outdoor.yaml` |
+| HM3D | `.glb` or `.gltf` plus optional semantic/navmesh files | `configs/hm3d.yaml` |
+| ScanNet++ | `.ply` | `configs/scannetpp.yaml` |
+
+## Building Blocks Available in This Release
+
+| Module | Purpose | Entry Point |
+| --- | --- | --- |
+| Candidate generation | Phase 1 of §3 — produce \(\mathcal{P}_\varphi\) | `scripts/build_candidates.py` |
+| Conflict-aware selection | Phase 2 of §3 — greedy with \(s_t = G_t - \lambda L_t + \beta B_t\) | `scripts/select_views.py` |
+| Selected-view rendering | Phase 3 — final ERP render from chosen candidates | `scripts/render_selected.py` |
+| Coverage metric | §6.1 high-resolution oracle coverage | `scripts/evaluate_coverage.py` |
+| Oracle-gain validation | §6.2 warping vs. pre-render-all comparison | `scripts/evaluate_oracle_gap.py` |
+| Quality audit | Appendix F.2 50-frame audit | `scripts/audit_quality.py` |
+| Run summarization | Aggregate per-scene `selected_frames.json` into a CSV | `scripts/summarize_blender_indoor_run.py` |
+| Audit summarization | Aggregate per-frame audit results into a CSV | `scripts/summarize_quality_audit.py` |
+
+The §6 driver scripts that orchestrate these building blocks across an entire baseline sweep (e.g., the `K\!\in\!\{8,16,24,32\}` table of §6.1, the \(\lambda\) sweep of §6.5, and the four-source benchmark of §6.6) are scheduled to be released alongside the camera-ready paper.
+
+## Minimal Review Run
+
+```bash
+bash scripts/run_tiny.sh
+```
+
+This validates the Blender-indoor-style metadata format, greedy selection loop, render-output contract, coverage metric, oracle-gap script, and quality audit script — end-to-end without any private scene assets.
+
+## Blender-Indoor Full Run
+
+```bash
+DRY_RUN=1 \
+BLENDER=/path/to/blender \
+INPUT_DIR=/path/to/blend_scenes \
+OUTPUT_ROOT=outputs/blender_indoor \
+bash scripts/run_blender_indoor.sh
+```
+
+After confirming the detected scene list, remove `DRY_RUN=1`:
+
+```bash
+BLENDER=/path/to/blender \
+INPUT_DIR=/path/to/blend_scenes \
+OUTPUT_ROOT=outputs/blender_indoor \
+NUM_FRAMES=30 \
+RESOLUTION=2048,1024 \
+GRID_SPACING=0.5 \
+bash scripts/run_blender_indoor.sh
+```
+
+## Metric Scripts
+
+The native Blender-indoor pipeline emits `selected_frames.json` under each scene output directory. Summarize a completed run with:
+
+```bash
+python3 scripts/summarize_blender_indoor_run.py \
+  --output-root outputs/blender_indoor \
+  --output outputs/blender_indoor/results/coverage_main.csv
+```
+
+If you have consolidated candidate and selection metadata into the normalized JSONL/JSON contract used by the smoke test, use:
+
+```bash
+python3 scripts/evaluate_coverage.py \
+  --candidates outputs/blender_indoor/metadata/candidates.jsonl \
+  --selected outputs/blender_indoor/metadata/selected_viewpoints.json \
+  --output outputs/blender_indoor/results/coverage_main.csv
+
+python3 scripts/evaluate_oracle_gap.py \
+  --candidates outputs/blender_indoor/metadata/candidates.jsonl \
+  --selected outputs/blender_indoor/metadata/selected_viewpoints.json \
+  --output outputs/blender_indoor/results/oracle_validation.csv
+
+python3 scripts/audit_quality.py \
+  --render-dir outputs/blender_indoor/renders \
+  --metadata outputs/blender_indoor/metadata/selected_viewpoints.json \
+  --output outputs/blender_indoor/results/audit_50_frames.csv
+```
+
+The exact dataset paths should be adapted to the local machine. Do not commit generated data, logs, checkpoints, third-party repositories, or scene assets to the anonymous code repository.

code/configs/base_erpt.yaml

@@ -0,0 +1,142 @@
+# =============================================================================
+# ERPT Pipeline Configuration（移植自原版 ERPT）
+# 严格遵循 ERPT_native 坐标系约定：右手系 [X右, Y上, Z前]
+# =============================================================================
+
+# --- 数据路径 ---
+data:
+  data_dir: "inputs"
+  output_dir: "outputs"
+  depth_dir: null                    # 可选：外部深度目录
+
+# --- ERP 参数 ---
+erp:
+  auto_size: true                    # 自动从图像检测尺寸
+  width: 4096                        # 参考宽度
+  height: 2048                       # 参考高度
+
+# --- Tangent 切片参数（原版配置） ---
+tangent:
+  scheme: "icosahedron"
+  num_faces: 20
+  add_poles: true
+  face_resolution: 768               # 每个 face 的分辨率（像素）
+  fov_deg: 90.0                      # 普通 face 的基础 FOV（度）
+  padding_factor: 1.3                # 有效 FOV = 90 * 1.3 = 117°
+  pole_fov_deg: 160.0                # 极区切片使用更大 FOV
+  pole_resolution: 768               # 极区分辨率
+  pole_extra_rings: 2                # 额外极区密采样环数
+  seam_wrap: true
+
+# --- Depth Pro 参数（原版配置） ---
+depth_pro:
+  enabled: true
+  repo_dir: "third_party/ml-depth-pro"
+  checkpoint_path: "third_party/ml-depth-pro/checkpoints/depth_pro.pt"
+  precision: "fp16"                  # "fp32" | "fp16" | "bf16"
+  depth_def: "z"                     # "z" (z-depth) | "ray" (ray-depth)
+  pass_f_px: true                    # 传递已知焦距
+
+# --- 深度融合参数（原版配置） ---
+fusion:
+  blend_mode: "multiband"            # "softmin_invdepth" | "multiband"
+  output_scale: 1.10                 # 全局尺度校正
+
+  # 权重模式
+  weight_mode: "cosine"
+  k: 4                               # cosine 权重指数
+
+  # 深度竞争
+  depth_competition: "softmin_invdepth"
+  softmin_alpha: 10.0
+
+  # 极区处理
+  pole_boost: false
+  pole_boost_factor: 1.5
+  pole_latitude_deg: 75.0
+  pole_ramp_deg: 10.0
+
+  pole_ring:
+    enabled: false
+    min_latitude_deg: 60.0
+    ramp_deg: 10.0
+
+  face_pole_suppress:
+    enabled: false
+    min_latitude_deg: 70.0
+    ramp_deg: 10.0
+    min_scale: 0.4
+
+  # 极区一致性校正
+  pole_consistency:
+    enabled: true
+    min_latitude_deg: 60.0
+    min_overlap_pixels: 4000
+    max_abs_log_shift: 0.7
+    ref_slice_types: ["face", "pole_ring"]
+    target_slice_types: ["pole_north", "pole_south"]
+
+  # Z-buffer 门限
+  project_zbuffer_eps_abs_m: 0.02
+  project_zbuffer_eps_rel: 0.02
+
+  # Multiband 金字塔
+  multiband:
+    levels: 6
+    highfreq_levels: 2
+    eps: 1.0e-6
+
+  # 有效性
+  min_weight_sum: 1.0e-6
+
+# --- Warp 参数（原版配置） ---
+warp:
+  enabled: true
+  center_frame: 0
+  target_frames: "auto"              # "auto" 自动识别所有非中心帧；或指定列表如 [1, 2, 3]
+
+  # Splatting 方法
+  method: "softmax_splatting"        # "softmax_splatting" | "zbuffer_splatting" | "zbuffer_point"
+  alpha: 2.0                         # softmax 温度
+
+  # 自适应 Splat 半径
+  splat_radius_px: 1.5               # 基础半径
+  radius_min_px: 0.6                 # 半径下限
+  radius_max_px: 2.2                 # 中纬度上限
+  radius_max_pole_px: 3.4            # 极区上限
+  pole_radius_scale: 3.0             # 极区放大因子
+  pole_lat_threshold: 60.0           # 极区纬度阈值（度）
+  depth_radius_scale: false          # 深度缩放
+  depth_ref_m: 2.0                   # 深度参考值
+  depth_scale_factor: 1.0            # 深度已在 fusion.output_scale 烘焙
+  depth_edge_aware: true             # 深度边缘感知
+  depth_edge_threshold: 0.3          # 深度梯度阈值
+  depth_edge_min_scale: 0.12         # 边缘处最小半径缩放
+
+  # 遮挡门控
+  occlusion_gate:
+    enabled: true
+    abs_eps_m: 0.05
+    rel_eps: 0.05
+
+  # Z-buffer 参数
+  zbuffer_eps_abs_m: 0.03
+  zbuffer_eps_rel: 0.03
+  zbuffer_min_weight: 0.001
+
+  # 空洞填充
+  hole_fill_enabled: false
+  max_hole_px: 16
+
+  # 有效性
+  min_weight_sum: 1.0e-4
+  min_hit_sum: 1.0e-6
+
+  # 输出控制
+  output_flow: true
+  output_depth: true
+
+# --- 运行参数 ---
+run:
+  device: "cuda"
+  save_intermediates: true

code/configs/blender_indoor.yaml

@@ -0,0 +1,17 @@
+experiment:
+  source: blender_indoor
+  input_kind: blend
+
+pipeline:
+  blender: /path/to/blender
+  input_dir: data/blender_indoor
+  output_root: outputs/blender_indoor
+  num_frames: 30
+  resolution: "2048,1024"
+  grid_spacing: 0.5
+  camera_height: null
+  min_frames: 5
+  stop_gain: 0.08
+  stop_score: -0.3
+  stop_delta: 0.08
+

code/configs/blender_outdoor.yaml

@@ -0,0 +1,17 @@
+experiment:
+  source: blender_outdoor
+  input_kind: glb
+
+pipeline:
+  blender: /path/to/blender
+  input_dir: data/blender_outdoor
+  output_root: outputs/blender_outdoor
+  num_frames: 30
+  resolution: "2048,1024"
+  grid_spacing: 1.0
+  camera_height: null
+  min_frames: 5
+  stop_gain: 0.08
+  stop_score: -0.3
+  stop_delta: 0.08
+

code/configs/default.yaml

@@ -0,0 +1,22 @@
+# Default review configuration.
+# The anonymous release is organized around the Blender-indoor path.
+
+experiment:
+  source: blender_indoor
+  input_kind: blend
+  review_path: primary
+
+pipeline:
+  blender: /path/to/blender
+  input_dir: data/blender_indoor
+  output_root: outputs/blender_indoor
+  num_frames: 30
+  resolution: "2048,1024"
+  grid_spacing: 0.5
+  camera_height: null
+  min_frames: 5
+  stop_gain: 0.08
+  stop_score: -0.3
+  stop_delta: 0.08
+  rotation_type: random_yaw
+

code/configs/hm3d.yaml

@@ -0,0 +1,17 @@
+experiment:
+  source: hm3d
+  input_kind: glb
+
+pipeline:
+  blender: /path/to/blender
+  input_dir: data/hm3d
+  output_root: outputs/hm3d
+  num_frames: 30
+  resolution: "2048,1024"
+  grid_spacing: 0.5
+  camera_height: null
+  min_frames: 5
+  stop_gain: 0.08
+  stop_score: -0.3
+  stop_delta: 0.08
+

code/configs/scannetpp.yaml

@@ -0,0 +1,17 @@
+experiment:
+  source: scannetpp
+  input_kind: ply
+
+pipeline:
+  input_dir: data/scannetpp
+  output_root: outputs/scannetpp
+  num_frames: 30
+  resolution: "2048,1024"
+  grid_spacing: 0.5
+  point_size: 2.0
+  z_up: true
+  min_frames: 5
+  stop_gain: 0.08
+  stop_score: -0.3
+  stop_delta: 0.08
+

code/configs/tiny.yaml

@@ -0,0 +1,15 @@
+experiment:
+  name: blender_indoor_tiny_smoke_test
+  mode: blender_indoor_tiny
+  random_seed: 2026
+
+selection:
+  budget: 4
+  lambda_conflict: 0.35
+  min_gain: 0.01
+
+outputs:
+  root: outputs/tiny
+  metadata_dir: outputs/tiny/metadata
+  render_dir: outputs/tiny/renders
+  result_dir: outputs/tiny/results

code/core/__init__.py

@@ -0,0 +1,35 @@
+"""
+ERPT Core 模块
+
+包含：
+- tangent_extraction: ERP -> Tangent 切片生成
+- depth_estimation: Depth Pro 深度估计
+- depth_fusion: Tangent Depth -> ERP Depth 融合
+- coordinate: 坐标系定义（锁定）
+- erp_projection: ERP 投影（锁定）
+"""
+from .tangent_extraction import (
+    TangentSlice,
+    build_icosahedron_slices,
+    extract_all_tangents,
+    extract_tangent_from_erp,
+    compute_coverage_mask,
+    compute_ray_directions_for_slice,
+)
+
+from .depth_estimation import (
+    DepthEstimator,
+    estimate_all_tangent_depths,
+)
+
+from .depth_fusion import (
+    fuse_tangent_depths_to_erp,
+    visualize_depth,
+    save_depth_visualization,
+)
+
+from .erp_warp import (
+    WarpResult,
+    warp_erp_to_target,
+    create_comparison_image,
+)

code/core/coordinate.py

@@ -0,0 +1,191 @@
+"""
+坐标系约定和四元数工具
+
+ERPT_native 坐标系标准：
+- 世界坐标系：右手系 [X右, Y上, Z前]
+- 满足：X × Y = Z（右手法则）
+- ERP投影约定：
+  - lon = atan2(x, z)：经度，范围 [-π, π]
+  - lat = asin(y)：纬度，范围 [-π/2, π/2]
+  - 图像中心（u=W/2, v=H/2）看向 +Z 方向
+  - 图像顶部是 +Y 方向（上）
+
+位姿格式：
+- position: [x, y, z]，相机中心在世界坐标系的位置（米）
+- rotation_quaternion: [w, x, y, z]，表示 camera->world 旋转 (R_cw)
+
+数学约定：
+- P_world = R_cw @ P_cam + t（相机坐标系到世界坐标系）
+- P_cam = R_wc @ (P_world - t)（世界坐标系到相机坐标系）
+- R_wc = R_cw^T
+"""
+
+import numpy as np
+from typing import Tuple
+
+
+def quat_wxyz_to_rotation_matrix(q: np.ndarray) -> np.ndarray:
+    """
+    四元数转旋转矩阵
+    
+    输入四元数表示 camera->world 旋转 (R_cw)
+    
+    Args:
+        q: (4,) 四元数 [w, x, y, z]，需归一化
+        
+    Returns:
+        R: (3, 3) 旋转矩阵 R_cw
+    """
+    q = np.asarray(q, dtype=np.float64).flatten()
+    assert q.shape == (4,), f"Expected shape (4,), got {q.shape}"
+    
+    # 归一化
+    norm = np.linalg.norm(q)
+    if norm < 1e-9:
+        raise ValueError(f"Quaternion norm too small: {norm}")
+    q = q / norm
+    
+    w, x, y, z = q[0], q[1], q[2], q[3]
+    
+    # 旋转矩阵公式
+    R = np.array([
+        [1 - 2*(y*y + z*z), 2*(x*y - w*z),     2*(x*z + w*y)],
+        [2*(x*y + w*z),     1 - 2*(x*x + z*z), 2*(y*z - w*x)],
+        [2*(x*z - w*y),     2*(y*z + w*x),     1 - 2*(x*x + y*y)]
+    ], dtype=np.float64)
+    
+    return R
+
+
+def rotation_matrix_to_quat_wxyz(R: np.ndarray) -> np.ndarray:
+    """
+    旋转矩阵转四元数
+    
+    Args:
+        R: (3, 3) 旋转矩阵
+        
+    Returns:
+        q: (4,) 四元数 [w, x, y, z]
+    """
+    R = np.asarray(R, dtype=np.float64).reshape(3, 3)
+    
+    # 确保正交性（SVD正交化）
+    U, _, Vt = np.linalg.svd(R)
+    R = U @ Vt
+    if np.linalg.det(R) < 0:
+        U[:, -1] *= -1
+        R = U @ Vt
+    
+    # Shepperd's method
+    trace = np.trace(R)
+    
+    if trace > 0:
+        s = 2.0 * np.sqrt(trace + 1.0)
+        w = 0.25 * s
+        x = (R[2, 1] - R[1, 2]) / s
+        y = (R[0, 2] - R[2, 0]) / s
+        z = (R[1, 0] - R[0, 1]) / s
+    elif R[0, 0] > R[1, 1] and R[0, 0] > R[2, 2]:
+        s = 2.0 * np.sqrt(1.0 + R[0, 0] - R[1, 1] - R[2, 2])
+        w = (R[2, 1] - R[1, 2]) / s
+        x = 0.25 * s
+        y = (R[0, 1] + R[1, 0]) / s
+        z = (R[0, 2] + R[2, 0]) / s
+    elif R[1, 1] > R[2, 2]:
+        s = 2.0 * np.sqrt(1.0 + R[1, 1] - R[0, 0] - R[2, 2])
+        w = (R[0, 2] - R[2, 0]) / s
+        x = (R[0, 1] + R[1, 0]) / s
+        y = 0.25 * s
+        z = (R[1, 2] + R[2, 1]) / s
+    else:
+        s = 2.0 * np.sqrt(1.0 + R[2, 2] - R[0, 0] - R[1, 1])
+        w = (R[1, 0] - R[0, 1]) / s
+        x = (R[0, 2] + R[2, 0]) / s
+        y = (R[1, 2] + R[2, 1]) / s
+        z = 0.25 * s
+    
+    q = np.array([w, x, y, z], dtype=np.float64)
+    
+    # 归一化
+    q = q / np.linalg.norm(q)
+    
+    # 确保 w >= 0（唯一性）
+    if q[0] < 0:
+        q = -q
+    
+    return q
+
+
+def R_cw_to_R_wc(R_cw: np.ndarray) -> np.ndarray:
+    """
+    camera->world 旋转矩阵转换为 world->camera
+    
+    R_wc = R_cw^T
+    
+    Args:
+        R_cw: (3, 3) camera->world 旋转矩阵
+        
+    Returns:
+        R_wc: (3, 3) world->camera 旋转矩阵
+    """
+    return R_cw.T
+
+
+def R_wc_to_R_cw(R_wc: np.ndarray) -> np.ndarray:
+    """
+    world->camera 旋转矩阵转换为 camera->world
+    
+    R_cw = R_wc^T
+    
+    Args:
+        R_wc: (3, 3) world->camera 旋转矩阵
+        
+    Returns:
+        R_cw: (3, 3) camera->world 旋转矩阵
+    """
+    return R_wc.T
+
+
+def validate_rotation_matrix(R: np.ndarray, tol: float = 1e-5) -> Tuple[bool, str]:
+    """
+    验证旋转矩阵的有效性
+    
+    Args:
+        R: (3, 3) 待验证的矩阵
+        tol: 容差
+        
+    Returns:
+        (is_valid, message)
+    """
+    R = np.asarray(R, dtype=np.float64).reshape(3, 3)
+    
+    # 检查正交性：R^T @ R = I
+    I = R.T @ R
+    orth_err = np.max(np.abs(I - np.eye(3)))
+    if orth_err > tol:
+        return False, f"Orthogonality error: {orth_err:.6e} > {tol}"
+    
+    # 检查行列式：det(R) = +1
+    det = np.linalg.det(R)
+    if np.abs(det - 1.0) > tol:
+        return False, f"Determinant error: det(R)={det:.6f}, expected 1.0"
+    
+    return True, "Valid rotation matrix"
+
+
+def orthonormalize_rotation(R: np.ndarray) -> np.ndarray:
+    """
+    使用SVD正交化旋转矩阵
+    
+    Args:
+        R: (3, 3) 近似旋转矩阵
+        
+    Returns:
+        R_orth: (3, 3) 正交化后的旋转矩阵
+    """
+    U, _, Vt = np.linalg.svd(R)
+    R_orth = U @ Vt
+    if np.linalg.det(R_orth) < 0:
+        U[:, -1] *= -1
+        R_orth = U @ Vt
+    return R_orth

code/core/depth_estimation.py

@@ -0,0 +1,185 @@
+"""
+Depth Pro Wrapper（移植自原版 ERPT）
+
+封装 Apple Depth Pro 单目深度估计模型。
+
+API 使用说明:
+    1. 使用 depth_pro.create_model_and_transforms() 创建模型和预处理 transforms
+    2. 输入 RGB 图像 (PIL Image 或 numpy array)
+    3. 调用 model.infer(image, f_px=focal_length) 得到深度
+    4. 输出 depth 单位为米 (m)
+
+深度定义:
+    - Depth Pro 输出的是透视相机的 z-depth (沿相机前向轴的深度)
+"""
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+import numpy as np
+import torch
+from PIL import Image
+
+from .tangent_extraction import TangentSlice
+
+# 模型缓存，避免重复加载
+_MODEL_CACHE: Dict[str, Tuple[torch.nn.Module, Any]] = {}
+
+
+def _get_precision(cfg: Dict[str, Any]) -> torch.dtype:
+    """获取计算精度"""
+    prec = cfg.get("depth_pro", {}).get("precision", "fp16")
+    if prec == "fp16":
+        return torch.float16
+    elif prec == "bf16":
+        return torch.bfloat16
+    return torch.float32
+
+
+def _load_depthpro_model(
+    cfg: Dict[str, Any],
+    device: torch.device,
+) -> Tuple[torch.nn.Module, Any]:
+    """
+    加载 Depth Pro 模型和 transforms
+
+    Depth Pro 默认从 ./checkpoints/depth_pro.pt 加载权重，
+    因此需要切换到 repo 目录加载模型。
+    """
+    dcfg = cfg.get("depth_pro", {})
+
+    # 获取 Depth Pro 仓库目录
+    repo_dir = Path(dcfg.get("repo_dir", "third_party/ml-depth-pro"))
+    if not repo_dir.is_absolute():
+        root = Path(str(cfg.get("_project_root", Path.cwd())))
+        repo_dir = root / repo_dir
+
+    checkpoint_path = repo_dir / "checkpoints" / "depth_pro.pt"
+
+    precision = _get_precision(cfg)
+    cache_key = f"{checkpoint_path}_{device}_{precision}"
+
+    if cache_key in _MODEL_CACHE:
+        return _MODEL_CACHE[cache_key]
+
+    # 添加 Depth Pro 路径到 sys.path
+    if repo_dir.exists():
+        src_path = str(repo_dir / "src")
+        if src_path not in sys.path:
+            sys.path.insert(0, src_path)
+        if str(repo_dir) not in sys.path:
+            sys.path.insert(0, str(repo_dir))
+
+    try:
+        import depth_pro
+    except ImportError as e:
+        raise RuntimeError(
+            f"Failed to import depth_pro module. "
+            f"Please ensure ml-depth-pro is installed at {repo_dir}\n"
+            f"Error: {e}"
+        ) from e
+
+    if not checkpoint_path.exists():
+        raise FileNotFoundError(
+            f"Depth Pro checkpoint not found: {checkpoint_path}\n"
+            f"Please place depth_pro.pt in {checkpoint_path.parent}"
+        )
+
+    print(f"[DepthPro] Loading model from {checkpoint_path}")
+    print(f"[DepthPro] Device: {device}, Precision: {precision}")
+
+    # 保存当前目录并切换到 repo_dir（Depth Pro 默认从 ./checkpoints 加载）
+    original_cwd = os.getcwd()
+    try:
+        os.chdir(repo_dir)
+
+        # 使用官方 API 加载模型
+        model, transform = depth_pro.create_model_and_transforms(
+            device=device,
+            precision=precision,
+        )
+
+        model.eval()
+        print(f"[DepthPro] Model loaded successfully")
+
+    finally:
+        os.chdir(original_cwd)
+
+    _MODEL_CACHE[cache_key] = (model, transform)
+    return model, transform
+
+
+class DepthEstimator:
+    """
+    Depth Pro 深度估计器封装类
+
+    提供统一的接口用于批量深度估计。
+    """
+
+    def __init__(self, cfg: Dict[str, Any], device: torch.device):
+        self.cfg = cfg
+        self.device = device
+        self.model, self.transform = _load_depthpro_model(cfg, device)
+        self.pass_f_px = bool(cfg.get("depth_pro", {}).get("pass_f_px", True))
+
+    @torch.no_grad()
+    def predict_single(self, rgb: np.ndarray, f_px: Optional[float] = None) -> np.ndarray:
+        """
+        单张图像深度预测
+
+        Args:
+            rgb: (H, W, 3) uint8 numpy array
+            f_px: 可选的 focal length (像素)
+
+        Returns:
+            (H, W) float32 numpy array, 单位米
+        """
+        pil_img = Image.fromarray(rgb.astype(np.uint8))
+        img_tensor = self.transform(pil_img)
+
+        f_px_tensor = None
+        if f_px is not None and self.pass_f_px:
+            f_px_tensor = torch.tensor([f_px], device=self.device)
+
+        prediction = self.model.infer(img_tensor, f_px=f_px_tensor)
+        return prediction["depth"].detach().cpu().float().numpy().astype(np.float32)
+
+
+def estimate_all_tangent_depths(
+    tangent_rgbs: Dict[str, np.ndarray],
+    slices: List[TangentSlice],
+    cfg: Dict[str, Any],
+    device: torch.device,
+) -> Dict[str, np.ndarray]:
+    """
+    对所有切片估计深度
+
+    Args:
+        tangent_rgbs: {slice_id: rgb_array} 字典
+        slices: 切片规格列表
+        cfg: 配置字典
+        device: 计算设备
+
+    Returns:
+        tangent_depths: {slice_id: depth_array} 字典
+    """
+    estimator = DepthEstimator(cfg, device)
+
+    # 建立 slice_id -> f_px 映射
+    f_px_map = {s.slice_id: s.f_px for s in slices}
+
+    results = {}
+    total = len(tangent_rgbs)
+
+    for i, (slice_id, rgb) in enumerate(tangent_rgbs.items()):
+        f_px = f_px_map.get(slice_id)
+        depth = estimator.predict_single(rgb, f_px=f_px)
+        results[slice_id] = depth
+
+        print(f"  [{i+1}/{total}] {slice_id}: "
+              f"depth range [{depth.min():.2f}, {depth.max():.2f}] m")
+
+    return results

code/core/depth_fusion.py

@@ -0,0 +1,769 @@
+"""
+Tangent Depth -> ERP Depth 融合模块（完整移植自原版 ERPT）
+
+核心功能：
+1. 将每个切片的深度回投影到 ERP
+2. 使用 cosine 权重实现平滑融合（无块状边界）
+3. 使用 softmin(1/depth) 处理重叠区深度竞争
+4. 极区增强处理
+5. Multiband 金字塔融合（消除接缝）
+6. Pole consistency 极区深度对齐
+7. Z-buffer 门控投影（保持边缘锐利）
+
+关键算法：
+- Cosine 权重: w_face = max(0, dot(ray, face_center))^k
+- Depth 竞争: softmin(1/depth) 确保近处优先且平滑过渡
+- Forward splatting 将切片像素投影到 ERP
+- Multiband: Gaussian/Laplacian 金字塔融合
+
+输出：
+- depth_range: ERP range depth (float32, meters)
+- weight_sum: 权重和（用于 debug）
+- valid_mask: 有效掩码
+"""
+from __future__ import annotations
+
+import math
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+import numpy as np
+import torch
+
+from .tangent_extraction import TangentSlice
+
+
+# =============================================================================
+# 基础工具函数
+# =============================================================================
+
+def compute_cosine_weight(
+    ray_dirs: torch.Tensor,
+    face_center: torch.Tensor,
+    k: float = 4.0,
+) -> torch.Tensor:
+    """
+    计算 cosine 权重: w = max(0, dot(ray, face_center))^k
+    """
+    dots = torch.sum(ray_dirs * face_center.view(1, 1, 3), dim=-1)
+    weights = torch.clamp(dots, min=0.0) ** k
+    return weights
+
+
+def _dirs_to_erp_uv(
+    dirs_world: torch.Tensor,
+    erp_h: int,
+    erp_w: int,
+) -> Tuple[torch.Tensor, torch.Tensor]:
+    """将世界坐标方向转换为 ERP 像素坐标"""
+    x = dirs_world[..., 0]
+    y = dirs_world[..., 1]
+    z = dirs_world[..., 2]
+
+    lon = torch.atan2(x, z)
+    lat = torch.asin(torch.clamp(y, -1.0, 1.0))
+
+    u = (lon + math.pi) / (2.0 * math.pi) * float(erp_w)
+    u = torch.remainder(u, float(erp_w))
+    v = (math.pi / 2.0 - lat) / math.pi * float(erp_h - 1)
+    v = torch.clamp(v, 0.0, float(erp_h - 1))
+
+    return u, v
+
+
+# =============================================================================
+# 极区权重处理
+# =============================================================================
+
+def _apply_pole_weights(
+    slice_type: str,
+    dirs_world: torch.Tensor,
+    base_weight: torch.Tensor,
+    fusion_cfg: Dict[str, Any],
+) -> torch.Tensor:
+    """极区权重门控与增强"""
+    # pole_ring gating
+    pole_ring_cfg = fusion_cfg.get("pole_ring", {})
+    pole_ring_enabled = bool(pole_ring_cfg.get("enabled", True))
+    pole_ring_min_lat_deg = float(pole_ring_cfg.get("min_latitude_deg", 60.0))
+    pole_ring_ramp_deg = float(pole_ring_cfg.get("ramp_deg", 10.0))
+
+    if slice_type == "pole_ring":
+        if not pole_ring_enabled:
+            return torch.zeros_like(base_weight)
+        lat = torch.asin(torch.clamp(dirs_world[..., 1], -1.0, 1.0)) * (180.0 / math.pi)
+        abs_lat = torch.abs(lat)
+        ramp = torch.clamp(
+            (abs_lat - pole_ring_min_lat_deg) / max(pole_ring_ramp_deg, 1e-3),
+            min=0.0, max=1.0,
+        )
+        return base_weight * ramp
+
+    # pole caps progressive boost
+    pole_boost = bool(fusion_cfg.get("pole_boost", True))
+    pole_boost_factor = float(fusion_cfg.get("pole_boost_factor", 1.5))
+    pole_latitude_deg = float(fusion_cfg.get("pole_latitude_deg", 75.0))
+    pole_ramp_deg = float(fusion_cfg.get("pole_ramp_deg", 10.0))
+
+    if pole_boost and slice_type in ("pole_north", "pole_south"):
+        lat = torch.asin(torch.clamp(dirs_world[..., 1], -1.0, 1.0)) * (180.0 / math.pi)
+        abs_lat = torch.abs(lat)
+        ramp = torch.clamp(
+            (abs_lat - pole_latitude_deg) / max(pole_ramp_deg, 1e-3),
+            min=0.0, max=1.0,
+        )
+        mult = 1.0 + ramp * (pole_boost_factor - 1.0)
+        return base_weight * mult
+
+    # faces 在极区衰减
+    face_pole_cfg = fusion_cfg.get("face_pole_suppress", {})
+    if slice_type == "face" and bool(face_pole_cfg.get("enabled", True)):
+        min_lat = float(face_pole_cfg.get("min_latitude_deg", 70.0))
+        ramp_deg = float(face_pole_cfg.get("ramp_deg", 10.0))
+        min_scale = float(face_pole_cfg.get("min_scale", 0.4))
+        lat = torch.asin(torch.clamp(dirs_world[..., 1], -1.0, 1.0)) * (180.0 / math.pi)
+        abs_lat = torch.abs(lat)
+        t = torch.clamp((abs_lat - min_lat) / max(ramp_deg, 1e-3), 0.0, 1.0)
+        scale = 1.0 - t * (1.0 - min_scale)
+        return base_weight * scale
+
+    return base_weight
+
+
+# =============================================================================
+# Forward splatting（softmin_invdepth 模式用）
+# =============================================================================
+
+def _forward_splat(
+    erp_h: int,
+    erp_w: int,
+    u: torch.Tensor,
+    v: torch.Tensor,
+    range_depth: torch.Tensor,
+    weight: torch.Tensor,
+    accum_weighted_invdepth: torch.Tensor,
+    accum_weight: torch.Tensor,
+    depth_competition: str,
+    softmin_alpha: float,
+    pole_boost: bool,
+    pole_boost_factor: float,
+    pole_latitude_deg: float,
+) -> None:
+    """Forward splatting with bilinear interpolation"""
+    u_flat = u.reshape(-1)
+    v_flat = v.reshape(-1)
+    d_flat = range_depth.reshape(-1)
+    w_flat = weight.reshape(-1)
+
+    valid = torch.isfinite(d_flat) & (d_flat > 0.0) & torch.isfinite(w_flat) & (w_flat > 0.0)
+
+    u0 = torch.floor(u_flat).to(torch.int64)
+    v0 = torch.floor(v_flat).to(torch.int64)
+    du = (u_flat - u0.to(u_flat.dtype)).clamp(0.0, 1.0)
+    dv = (v_flat - v0.to(v_flat.dtype)).clamp(0.0, 1.0)
+
+    u0_wrap = torch.remainder(u0, erp_w)
+    u1_wrap = torch.remainder(u0 + 1, erp_w)
+    v1 = v0 + 1
+
+    w00 = (1.0 - du) * (1.0 - dv)
+    w10 = du * (1.0 - dv)
+    w01 = (1.0 - du) * dv
+    w11 = du * dv
+
+    if depth_competition == "softmin_invdepth":
+        inv_depth = 1.0 / torch.clamp(d_flat, min=1e-6)
+        value_to_splat = inv_depth
+    elif depth_competition == "softmax_negdepth":
+        exp_weight = torch.exp(-softmin_alpha * d_flat)
+        w_flat = w_flat * exp_weight
+        value_to_splat = d_flat
+    else:
+        value_to_splat = d_flat
+
+    def _add(u_idx, v_idx, bilinear_w):
+        v_ok = (v_idx >= 0) & (v_idx < erp_h)
+        m = valid & v_ok
+        u_safe = torch.where(m, u_idx, torch.zeros_like(u_idx))
+        v_safe = torch.where(m, v_idx, torch.zeros_like(v_idx))
+        idx = v_safe * erp_w + u_safe
+        final_w = torch.where(m, bilinear_w * w_flat, torch.zeros_like(bilinear_w))
+        final_val = torch.where(m, bilinear_w * w_flat * value_to_splat, torch.zeros_like(bilinear_w))
+        accum_weight.scatter_add_(0, idx, final_w)
+        accum_weighted_invdepth.scatter_add_(0, idx, final_val)
+
+    _add(u0_wrap, v0, w00)
+    _add(u1_wrap, v0, w10)
+    _add(u0_wrap, v1, w01)
+    _add(u1_wrap, v1, w11)
+
+
+# =============================================================================
+# Z-buffer 门控投影（multiband 模式用）
+# =============================================================================
+
+def _project_slice_to_erp_disp_weight_zbuffer(
+    depth_t: torch.Tensor,
+    slice_spec: TangentSlice,
+    cfg: Dict[str, Any],
+    erp_h: int,
+    erp_w: int,
+    depth_def: str,
+    k: float,
+    device: torch.device,
+) -> Tuple[torch.Tensor, torch.Tensor]:
+    """
+    将单个切片投影到 ERP，输出 disparity(1/range) 与 weight。
+    采用 per-slice z-buffer（min depth）避免同一 slice 内的边缘被平均糊掉。
+    """
+    fusion_cfg = cfg.get("fusion", {})
+    weight_mode = str(fusion_cfg.get("weight_mode", "cosine"))
+
+    res = slice_spec.resolution
+    K = slice_spec.K
+    R_cw = slice_spec.R_cw
+
+    fx, fy = float(K[0, 0]), float(K[1, 1])
+    cx, cy = float(K[0, 2]), float(K[1, 2])
+
+    xs = torch.arange(res, device=device, dtype=torch.float32)
+    ys = torch.arange(res, device=device, dtype=torch.float32)
+    yv, xv = torch.meshgrid(ys, xs, indexing="ij")
+
+    x_cam = (xv - cx) / fx
+    y_cam = -(yv - cy) / fy
+    z_cam = torch.ones_like(x_cam)
+
+    dirs_cam = torch.stack([x_cam, y_cam, z_cam], dim=-1)
+    ray_len = torch.norm(dirs_cam, dim=-1, keepdim=True).clamp(min=1e-9)
+    dirs_cam = dirs_cam / ray_len
+
+    R = torch.tensor(R_cw, device=device, dtype=torch.float32)
+    dirs_world = torch.einsum("ij,hwj->hwi", R, dirs_cam)
+
+    # range depth
+    if depth_def == "z":
+        range_depth = depth_t * ray_len.squeeze(-1)
+    else:
+        range_depth = depth_t
+
+    u, v = _dirs_to_erp_uv(dirs_world, erp_h, erp_w)
+
+    if weight_mode == "cosine":
+        face_center = torch.tensor(slice_spec.center_dir, device=device, dtype=torch.float32)
+        base_w = compute_cosine_weight(dirs_world, face_center, k=k)
+    else:
+        base_w = torch.ones_like(range_depth)
+
+    base_w = _apply_pole_weights(slice_spec.slice_type, dirs_world, base_w, fusion_cfg)
+
+    u_flat = u.reshape(-1)
+    v_flat = v.reshape(-1)
+    d_flat = range_depth.reshape(-1)
+    w_flat = base_w.reshape(-1)
+
+    valid = torch.isfinite(d_flat) & (d_flat > 0.0) & torch.isfinite(w_flat) & (w_flat > 0.0)
+
+    u0 = torch.floor(u_flat).to(torch.int64)
+    v0 = torch.floor(v_flat).to(torch.int64)
+    du = (u_flat - u0.float()).clamp(0.0, 1.0)
+    dv = (v_flat - v0.float()).clamp(0.0, 1.0)
+
+    u0w = torch.remainder(u0, erp_w)
+    u1w = torch.remainder(u0 + 1, erp_w)
+    v1 = v0 + 1
+
+    bw00 = (1.0 - du) * (1.0 - dv)
+    bw10 = du * (1.0 - dv)
+    bw01 = (1.0 - du) * dv
+    bw11 = du * dv
+
+    # Pass A: min depth
+    min_depth = torch.full((erp_h * erp_w,), float("inf"), device=device, dtype=torch.float32)
+
+    def _amin(ui, vi, bw):
+        m = valid & (vi >= 0) & (vi < erp_h)
+        ui_safe = torch.where(m, ui, torch.zeros_like(ui))
+        vi_safe = torch.where(m, vi, torch.zeros_like(vi))
+        idx = vi_safe * erp_w + ui_safe
+        cand = torch.where(m, d_flat, torch.full_like(d_flat, float("inf")))
+        min_depth.scatter_reduce_(0, idx, cand, reduce="amin", include_self=True)
+
+    _amin(u0w, v0, bw00)
+    _amin(u1w, v0, bw10)
+    _amin(u0w, v1, bw01)
+    _amin(u1w, v1, bw11)
+
+    # Pass B: accumulate disparity near min depth
+    disp_acc = torch.zeros(erp_h * erp_w, device=device, dtype=torch.float32)
+    w_acc = torch.zeros(erp_h * erp_w, device=device, dtype=torch.float32)
+
+    eps_abs = float(fusion_cfg.get("project_zbuffer_eps_abs_m", 0.02))
+    eps_rel = float(fusion_cfg.get("project_zbuffer_eps_rel", 0.02))
+
+    inv_d = 1.0 / torch.clamp(d_flat, min=1e-6)
+
+    def _acc(ui, vi, bw):
+        m = valid & (vi >= 0) & (vi < erp_h)
+        ui_safe = torch.where(m, ui, torch.zeros_like(ui))
+        vi_safe = torch.where(m, vi, torch.zeros_like(vi))
+        idx = vi_safe * erp_w + ui_safe
+        md = min_depth.gather(0, idx)
+        gate = d_flat <= (md * (1.0 + eps_rel) + eps_abs)
+        mm = m & gate
+        w_here = torch.where(mm, bw * w_flat, torch.zeros_like(bw))
+        disp_here = torch.where(mm, w_here * inv_d, torch.zeros_like(w_here))
+        w_acc.scatter_add_(0, idx, w_here)
+        disp_acc.scatter_add_(0, idx, disp_here)
+
+    _acc(u0w, v0, bw00)
+    _acc(u1w, v0, bw10)
+    _acc(u0w, v1, bw01)
+    _acc(u1w, v1, bw11)
+
+    w_map = w_acc.view(erp_h, erp_w)
+    disp_map = torch.zeros_like(w_map)
+    m = w_map > 1e-9
+    disp_map[m] = disp_acc.view(erp_h, erp_w)[m] / w_map[m]
+    return disp_map, w_map
+
+
+# =============================================================================
+# Multiband 金字塔工具
+# =============================================================================
+
+def _pad_circular_w(x: torch.Tensor, pad: int) -> torch.Tensor:
+    if pad <= 0:
+        return x
+    return torch.cat([x[..., -pad:], x, x[..., :pad]], dim=-1)
+
+
+def _gauss5_kernel(device: torch.device, dtype: torch.dtype) -> torch.Tensor:
+    k1 = torch.tensor([1.0, 4.0, 6.0, 4.0, 1.0], device=device, dtype=dtype)
+    k1 = k1 / k1.sum()
+    k2 = (k1[:, None] * k1[None, :]).view(1, 1, 5, 5)
+    return k2
+
+
+def _blur_circular_w(x: torch.Tensor, kernel: torch.Tensor) -> torch.Tensor:
+    import torch.nn.functional as F
+    pad = kernel.shape[-1] // 2
+    xw = _pad_circular_w(x, pad)
+    xwh = F.pad(xw, (0, 0, pad, pad), mode="reflect")
+    return F.conv2d(xwh, kernel)
+
+
+def _down2(x: torch.Tensor) -> torch.Tensor:
+    return x[..., ::2, ::2]
+
+
+def _upsample2_circular_w(x: torch.Tensor, out_h: int, out_w: int) -> torch.Tensor:
+    import torch.nn.functional as F
+    x3 = torch.cat([x, x, x], dim=-1)
+    y3 = F.interpolate(x3, size=(out_h, out_w * 3), mode="bilinear", align_corners=False)
+    return y3[..., out_w: 2 * out_w]
+
+
+# =============================================================================
+# 主融合函数
+# =============================================================================
+
+@torch.no_grad()
+def fuse_tangent_depths_to_erp(
+    tangent_depths: Dict[str, np.ndarray],
+    slices: List[TangentSlice],
+    cfg: Dict[str, Any],
+    device: torch.device,
+    debug_dir: Optional[Path] = None,
+) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """
+    将所有切片深度融合为 ERP range depth
+
+    Args:
+        tangent_depths: {slice_id: depth_array}
+        slices: 切片规格列表
+        cfg: 配置字典
+        device: 计算设备
+
+    Returns:
+        depth_range: (erp_h, erp_w) ERP range depth, float32
+        weight_sum: (erp_h, erp_w) 权重和
+        valid_mask: (erp_h, erp_w) uint8
+    """
+    erp_cfg = cfg.get("erp", {})
+    erp_h = int(erp_cfg.get("height", 1024))
+    erp_w = int(erp_cfg.get("width", 2048))
+
+    fusion_cfg = cfg.get("fusion", {})
+    blend_mode = str(fusion_cfg.get("blend_mode", "softmin_invdepth"))
+
+    if blend_mode == "multiband":
+        depth_np, weight_np, valid_np = _fuse_multiband(
+            tangent_depths, slices, cfg, device, erp_h, erp_w, debug_dir,
+        )
+    else:
+        depth_np, weight_np, valid_np = _fuse_softmin(
+            tangent_depths, slices, cfg, device, erp_h, erp_w,
+        )
+
+    # output_scale 校正
+    output_scale = float(fusion_cfg.get("output_scale", 1.0))
+    if output_scale != 1.0:
+        valid = np.isfinite(depth_np) & (depth_np > 0)
+        depth_np[valid] *= output_scale
+
+    return depth_np, weight_np, valid_np
+
+
+def _fuse_softmin(
+    tangent_depths: Dict[str, np.ndarray],
+    slices: List[TangentSlice],
+    cfg: Dict[str, Any],
+    device: torch.device,
+    erp_h: int,
+    erp_w: int,
+) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """softmin_invdepth 模式融合"""
+    fusion_cfg = cfg.get("fusion", {})
+    weight_mode = str(fusion_cfg.get("weight_mode", "cosine"))
+    k = float(fusion_cfg.get("k", 4.0))
+    depth_competition = str(fusion_cfg.get("depth_competition", "softmin_invdepth"))
+    softmin_alpha = float(fusion_cfg.get("softmin_alpha", 10.0))
+    min_weight_sum = float(fusion_cfg.get("min_weight_sum", 1e-6))
+    pole_boost = bool(fusion_cfg.get("pole_boost", True))
+    pole_boost_factor = float(fusion_cfg.get("pole_boost_factor", 1.5))
+    pole_latitude_deg = float(fusion_cfg.get("pole_latitude_deg", 75.0))
+    pole_ring_cfg = fusion_cfg.get("pole_ring", {})
+    pole_ring_enabled = bool(pole_ring_cfg.get("enabled", True))
+    pole_ring_min_lat_deg = float(pole_ring_cfg.get("min_latitude_deg", 60.0))
+    pole_ring_ramp_deg = float(pole_ring_cfg.get("ramp_deg", 5.0))
+    depth_def = str(cfg.get("depth_pro", {}).get("depth_def", "z"))
+
+    accum_weighted_invdepth = torch.zeros(erp_h * erp_w, device=device, dtype=torch.float32)
+    accum_weight = torch.zeros(erp_h * erp_w, device=device, dtype=torch.float32)
+
+    for s in slices:
+        if s.slice_id not in tangent_depths:
+            continue
+        depth_np = tangent_depths[s.slice_id]
+        depth_t = torch.from_numpy(depth_np.astype(np.float32)).to(device)
+
+        res = s.resolution
+        K = s.K
+        R_cw = s.R_cw
+        fx, fy = float(K[0, 0]), float(K[1, 1])
+        cx, cy = float(K[0, 2]), float(K[1, 2])
+
+        xs = torch.arange(res, device=device, dtype=torch.float32)
+        ys = torch.arange(res, device=device, dtype=torch.float32)
+        yv, xv = torch.meshgrid(ys, xs, indexing="ij")
+
+        x_cam = (xv - cx) / fx
+        y_cam = -(yv - cy) / fy
+        z_cam = torch.ones_like(x_cam)
+
+        dirs_cam = torch.stack([x_cam, y_cam, z_cam], dim=-1)
+        dirs_cam = dirs_cam / torch.clamp(torch.norm(dirs_cam, dim=-1, keepdim=True), min=1e-9)
+
+        R = torch.tensor(R_cw, device=device, dtype=torch.float32)
+        dirs_world = torch.einsum("ij,hwj->hwi", R, dirs_cam)
+
+        if depth_def == "z":
+            ray_length = torch.sqrt(x_cam ** 2 + y_cam ** 2 + 1.0)
+            range_depth = depth_t * ray_length
+        else:
+            range_depth = depth_t
+
+        u, v = _dirs_to_erp_uv(dirs_world, erp_h, erp_w)
+
+        if weight_mode == "cosine":
+            face_center = torch.tensor(s.center_dir, device=device, dtype=torch.float32)
+            base_weight = compute_cosine_weight(dirs_world, face_center, k=k)
+        else:
+            base_weight = torch.ones_like(range_depth)
+
+        if s.slice_type == "pole_ring":
+            if not pole_ring_enabled:
+                base_weight = torch.zeros_like(base_weight)
+            else:
+                lat = torch.asin(torch.clamp(dirs_world[..., 1], -1.0, 1.0)) * (180.0 / math.pi)
+                abs_lat = torch.abs(lat)
+                ramp = torch.clamp(
+                    (abs_lat - pole_ring_min_lat_deg) / max(pole_ring_ramp_deg, 1e-3),
+                    min=0.0, max=1.0,
+                )
+                base_weight = base_weight * ramp
+
+        if pole_boost and s.slice_type in ("pole_north", "pole_south"):
+            base_weight = base_weight * pole_boost_factor
+
+        _forward_splat(
+            erp_h, erp_w, u, v, range_depth, base_weight,
+            accum_weighted_invdepth, accum_weight,
+            depth_competition, softmin_alpha,
+            pole_boost, pole_boost_factor, pole_latitude_deg,
+        )
+
+    valid_mask_t = accum_weight > min_weight_sum
+
+    if depth_competition == "softmin_invdepth":
+        avg_invdepth = torch.zeros_like(accum_weighted_invdepth)
+        avg_invdepth[valid_mask_t] = accum_weighted_invdepth[valid_mask_t] / accum_weight[valid_mask_t]
+        depth_out = torch.zeros_like(avg_invdepth)
+        depth_out[valid_mask_t] = 1.0 / torch.clamp(avg_invdepth[valid_mask_t], min=1e-6)
+    else:
+        depth_out = torch.zeros_like(accum_weighted_invdepth)
+        depth_out[valid_mask_t] = accum_weighted_invdepth[valid_mask_t] / accum_weight[valid_mask_t]
+
+    depth_out[~valid_mask_t] = float("nan")
+
+    depth_out = depth_out.reshape(erp_h, erp_w)
+    weight_sum = accum_weight.reshape(erp_h, erp_w)
+    valid_mask = valid_mask_t.reshape(erp_h, erp_w)
+
+    return (
+        depth_out.cpu().numpy().astype(np.float32),
+        weight_sum.cpu().numpy().astype(np.float32),
+        valid_mask.cpu().numpy().astype(np.uint8),
+    )
+
+
+def _fuse_multiband(
+    tangent_depths: Dict[str, np.ndarray],
+    slices: List[TangentSlice],
+    cfg: Dict[str, Any],
+    device: torch.device,
+    erp_h: int,
+    erp_w: int,
+    debug_dir: Optional[Path] = None,
+) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """Multiband 金字塔融合"""
+    fusion_cfg = cfg.get("fusion", {})
+    mb_cfg = fusion_cfg.get("multiband", {})
+    levels = int(mb_cfg.get("levels", 6))
+    highfreq_levels = int(mb_cfg.get("highfreq_levels", 2))
+    eps = float(mb_cfg.get("eps", 1e-6))
+    min_weight_sum = float(fusion_cfg.get("min_weight_sum", 1e-6))
+
+    depth_def = str(cfg.get("depth_pro", {}).get("depth_def", "z"))
+    k = float(fusion_cfg.get("k", 4.0))
+
+    # Pole consistency 配置
+    pole_cons_cfg = fusion_cfg.get("pole_consistency", {})
+    if not isinstance(pole_cons_cfg, dict):
+        pole_cons_cfg = {}
+    pole_cons_enabled = bool(pole_cons_cfg.get("enabled", False))
+    pole_cons_min_lat_deg = float(pole_cons_cfg.get("min_latitude_deg", 60.0))
+    pole_cons_min_overlap = int(pole_cons_cfg.get("min_overlap_pixels", 4000))
+    pole_cons_max_abs_log_shift = float(pole_cons_cfg.get("max_abs_log_shift", 0.7))
+    pole_cons_ref_types = [str(x) for x in pole_cons_cfg.get("ref_slice_types", ["face", "pole_ring"])]
+    pole_cons_target_types = [str(x) for x in pole_cons_cfg.get("target_slice_types", ["pole_north", "pole_south"])]
+
+    top_v_max = int(math.floor((90.0 - pole_cons_min_lat_deg) / 180.0 * float(max(erp_h - 1, 1))))
+    bot_v_min = int(math.ceil((90.0 + pole_cons_min_lat_deg) / 180.0 * float(max(erp_h - 1, 1))))
+    top_v_max = max(0, min(erp_h - 1, top_v_max))
+    bot_v_min = max(0, min(erp_h - 1, bot_v_min))
+
+    ref_num_top = ref_den_top = ref_num_bot = ref_den_bot = None
+    pole_pending: List[TangentSlice] = []
+    if pole_cons_enabled:
+        ref_num_top = torch.zeros((top_v_max + 1, erp_w), device=device, dtype=torch.float32)
+        ref_den_top = torch.zeros_like(ref_num_top)
+        ref_num_bot = torch.zeros((erp_h - bot_v_min, erp_w), device=device, dtype=torch.float32)
+        ref_den_bot = torch.zeros_like(ref_num_bot)
+
+    # Per-level accumulators
+    kernel = _gauss5_kernel(device=device, dtype=torch.float32)
+
+    Hs = [erp_h]
+    Ws = [erp_w]
+    for _ in range(1, levels):
+        Hs.append(max(1, Hs[-1] // 2))
+        Ws.append(max(1, Ws[-1] // 2))
+
+    fused_lap: List[torch.Tensor] = []
+    best_w: List[torch.Tensor] = []
+    sum_w: List[torch.Tensor] = []
+    sum_w_lap: List[torch.Tensor] = []
+
+    for l in range(levels):
+        shape = (1, 1, Hs[l], Ws[l])
+        if l < highfreq_levels:
+            fused_lap.append(torch.zeros(shape, device=device, dtype=torch.float32))
+            best_w.append(torch.zeros(shape, device=device, dtype=torch.float32))
+        else:
+            fused_lap.append(torch.zeros(shape, device=device, dtype=torch.float32))
+            sum_w.append(torch.zeros(shape, device=device, dtype=torch.float32))
+            sum_w_lap.append(torch.zeros(shape, device=device, dtype=torch.float32))
+
+    weight_sum0 = torch.zeros(erp_h, erp_w, device=device, dtype=torch.float32)
+
+    def _process_one_slice(s: TangentSlice, depth_np: np.ndarray):
+        depth_t = torch.from_numpy(depth_np.astype(np.float32)).to(device)
+
+        disp0, w0 = _project_slice_to_erp_disp_weight_zbuffer(
+            depth_t, s, cfg, erp_h, erp_w, depth_def, k, device,
+        )
+        return disp0, w0
+
+    def _blend_into_pyramid(disp0: torch.Tensor, w0: torch.Tensor):
+        nonlocal weight_sum0
+        weight_sum0 += w0
+
+        disp_pyr = [disp0.unsqueeze(0).unsqueeze(0)]
+        w_pyr = [w0.unsqueeze(0).unsqueeze(0)]
+
+        for l in range(1, levels):
+            num = _blur_circular_w(disp_pyr[l - 1] * w_pyr[l - 1], kernel)
+            den = _blur_circular_w(w_pyr[l - 1], kernel)
+            num_ds = _down2(num)
+            den_ds = _down2(den)
+            disp_ds = num_ds / torch.clamp(den_ds, min=eps)
+            disp_pyr.append(disp_ds)
+            w_pyr.append(den_ds)
+
+        lap_pyr: List[torch.Tensor] = []
+        for l in range(levels - 1):
+            up = _upsample2_circular_w(disp_pyr[l + 1], Hs[l], Ws[l])
+            lap_pyr.append(disp_pyr[l] - up)
+        lap_pyr.append(disp_pyr[-1])
+
+        for l in range(levels):
+            wl = w_pyr[l]
+            Ll = lap_pyr[l]
+            if l < highfreq_levels:
+                better = wl > best_w[l]
+                fused_lap[l] = torch.where(better, Ll, fused_lap[l])
+                best_w[l] = torch.where(better, wl, best_w[l])
+            else:
+                idx = l - highfreq_levels
+                sum_w_lap[idx] += wl * Ll
+                sum_w[idx] += wl
+
+    # Process non-pole slices first
+    for s in slices:
+        if s.slice_id not in tangent_depths:
+            continue
+        if pole_cons_enabled and (s.slice_type in pole_cons_target_types):
+            pole_pending.append(s)
+            continue
+
+        disp0, w0 = _process_one_slice(s, tangent_depths[s.slice_id])
+
+        # Reference accumulation for pole consistency
+        if pole_cons_enabled and (s.slice_type in pole_cons_ref_types):
+            if ref_num_top is not None and top_v_max >= 0:
+                ref_num_top += disp0[:top_v_max + 1] * w0[:top_v_max + 1]
+                ref_den_top += w0[:top_v_max + 1]
+            if ref_num_bot is not None and bot_v_min < erp_h:
+                ref_num_bot += disp0[bot_v_min:] * w0[bot_v_min:]
+                ref_den_bot += w0[bot_v_min:]
+
+        _blend_into_pyramid(disp0, w0)
+
+    # Pole consistency pass
+    if pole_cons_enabled and pole_pending and ref_num_top is not None:
+        ref_disp_top = ref_num_top / torch.clamp(ref_den_top, min=eps)
+        ref_disp_bot = ref_num_bot / torch.clamp(ref_den_bot, min=eps)
+
+        for s in pole_pending:
+            disp0, w0 = _process_one_slice(s, tangent_depths[s.slice_id])
+
+            try:
+                if s.slice_type == "pole_north":
+                    disp_other = disp0[:top_v_max + 1]
+                    w_other = w0[:top_v_max + 1]
+                    disp_ref = ref_disp_top
+                    den_ref = ref_den_top
+                else:
+                    disp_other = disp0[bot_v_min:]
+                    w_other = w0[bot_v_min:]
+                    disp_ref = ref_disp_bot
+                    den_ref = ref_den_bot
+
+                overlap = (w_other > 1e-9) & (den_ref > 1e-9) & (disp_other > eps) & (disp_ref > eps)
+                n_overlap = int(overlap.sum().item())
+                if n_overlap >= pole_cons_min_overlap:
+                    log_ref = -torch.log(disp_ref[overlap].clamp(min=eps))
+                    log_other = -torch.log(disp_other[overlap].clamp(min=eps))
+                    shift = float(torch.median(log_ref - log_other).item())
+                    shift = max(-pole_cons_max_abs_log_shift, min(pole_cons_max_abs_log_shift, shift))
+                    disp0 = disp0 * float(math.exp(-shift))
+            except Exception:
+                pass
+
+            _blend_into_pyramid(disp0, w0)
+
+    # Finalize lowfreq levels
+    for l in range(highfreq_levels, levels):
+        idx = l - highfreq_levels
+        fused_lap[l] = sum_w_lap[idx] / torch.clamp(sum_w[idx], min=eps)
+
+    # Reconstruct fused disparity
+    disp = fused_lap[-1]
+    for l in range(levels - 2, -1, -1):
+        disp = _upsample2_circular_w(disp, Hs[l], Ws[l]) + fused_lap[l]
+
+    disp0_fused = disp.squeeze(0).squeeze(0)
+    depth = torch.zeros_like(disp0_fused)
+    m = disp0_fused > eps
+    depth[m] = 1.0 / disp0_fused[m]
+    depth[~m] = float("nan")
+
+    weight_np = weight_sum0.detach().cpu().numpy().astype(np.float32)
+    depth_np = depth.detach().cpu().numpy().astype(np.float32)
+    valid_np = (weight_np > min_weight_sum).astype(np.uint8)
+
+    return depth_np, weight_np, valid_np
+
+
+# =============================================================================
+# 可视化函数
+# =============================================================================
+
+def visualize_depth(
+    depth: np.ndarray,
+    vmin: Optional[float] = None,
+    vmax: Optional[float] = None,
+) -> np.ndarray:
+    """
+    可视化深度图（percentile + TURBO colormap）
+
+    Returns:
+        vis: (H, W, 3) uint8 RGB
+    """
+    d = depth.astype(np.float32).copy()
+    valid = np.isfinite(d) & (d > 0)
+
+    if not np.any(valid):
+        return np.zeros((d.shape[0], d.shape[1], 3), dtype=np.uint8)
+
+    if vmin is None:
+        vmin = float(np.percentile(d[valid], 2))
+    if vmax is None:
+        vmax = float(np.percentile(d[valid], 98))
+    vmax = max(vmax, vmin + 1e-6)
+
+    d_norm = (np.clip(d, vmin, vmax) - vmin) / (vmax - vmin)
+    d_norm[~valid] = 0.0
+    d_u8 = (d_norm * 255).astype(np.uint8)
+
+    try:
+        import cv2
+        cm = cv2.applyColorMap(d_u8, cv2.COLORMAP_TURBO)
+        return cv2.cvtColor(cm, cv2.COLOR_BGR2RGB)
+    except ImportError:
+        return np.stack([d_u8, d_u8, d_u8], axis=-1)
+
+
+def save_depth_visualization(
+    depth: np.ndarray,
+    output_path: Path,
+    vmin: Optional[float] = None,
+    vmax: Optional[float] = None,
+) -> None:
+    """保存深度可视化图像"""
+    import cv2
+    vis = visualize_depth(depth, vmin=vmin, vmax=vmax)
+    Path(output_path).parent.mkdir(parents=True, exist_ok=True)
+    cv2.imwrite(str(output_path), cv2.cvtColor(vis, cv2.COLOR_RGB2BGR))

code/core/erp_projection.py

@@ -0,0 +1,277 @@
+"""
+ERP 投影模块
+
+ERPT_native ERP投影约定：
+- 经度：lon = atan2(x, z)，范围 [-π, π]
+- 纬度：lat = asin(y)，范围 [-π/2, π/2]
+- 像素坐标：u ∈ [0, W), v ∈ [0, H)
+- 图像中心 (u=W/2, v=H/2) 对应 (lon=0, lat=0)，看向 +Z
+- 图像顶部 (v=0) 对应 lat=+π/2，看向 +Y（上）
+- 图像底部 (v=H-1) 对应 lat=-π/2，看向 -Y（下）
+- 图像右边 lon增加，对应 +X 方向
+
+像素到经纬度映射：
+  lon = (u / W) * 2π - π
+  lat = π/2 - (v / (H-1)) * π
+
+方向向量（相机坐标系，也是世界坐标系当无旋转时）：
+  x = sin(lon) * cos(lat)   # 右
+  y = sin(lat)              # 上
+  z = cos(lon) * cos(lat)   # 前
+"""
+
+import math
+import numpy as np
+import torch
+from typing import Tuple, Union
+
+
+def erp_to_lonlat(
+    u: Union[np.ndarray, torch.Tensor],
+    v: Union[np.ndarray, torch.Tensor],
+    H: int,
+    W: int,
+) -> Tuple[Union[np.ndarray, torch.Tensor], Union[np.ndarray, torch.Tensor]]:
+    """
+    ERP像素坐标转经纬度
+    
+    Args:
+        u: 水平像素坐标，范围 [0, W)
+        v: 垂直像素坐标，范围 [0, H)
+        H: 图像高度
+        W: 图像宽度
+        
+    Returns:
+        lon: 经度，范围 [-π, π]
+        lat: 纬度，范围 [-π/2, π/2]
+    """
+    # lon = (u / W) * 2π - π
+    lon = (u / float(W)) * (2.0 * math.pi) - math.pi
+    
+    # lat = π/2 - (v / (H-1)) * π
+    lat = (math.pi / 2.0) - (v / float(H - 1)) * math.pi
+    
+    return lon, lat
+
+
+def lonlat_to_erp(
+    lon: Union[np.ndarray, torch.Tensor],
+    lat: Union[np.ndarray, torch.Tensor],
+    H: int,
+    W: int,
+) -> Tuple[Union[np.ndarray, torch.Tensor], Union[np.ndarray, torch.Tensor]]:
+    """
+    经纬度转ERP像素坐标
+    
+    Args:
+        lon: 经度，范围 [-π, π]
+        lat: 纬度，范围 [-π/2, π/2]
+        H: 图像高度
+        W: 图像宽度
+        
+    Returns:
+        u: 水平像素坐标
+        v: 垂直像素坐标
+    """
+    # u = (lon + π) / (2π) * W
+    u = (lon + math.pi) / (2.0 * math.pi) * float(W)
+    
+    # v = (π/2 - lat) / π * (H-1)
+    v = (math.pi / 2.0 - lat) / math.pi * float(H - 1)
+    
+    return u, v
+
+
+def lonlat_to_direction(
+    lon: Union[np.ndarray, torch.Tensor],
+    lat: Union[np.ndarray, torch.Tensor],
+) -> Union[np.ndarray, torch.Tensor]:
+    """
+    经纬度转方向向量（单位向量）
+    
+    坐标系：[X右, Y上, Z前]
+    
+    Args:
+        lon: 经度
+        lat: 纬度
+        
+    Returns:
+        dirs: (..., 3) 单位方向向量 [x, y, z]
+    """
+    if isinstance(lon, torch.Tensor):
+        cos_lat = torch.cos(lat)
+        x = torch.sin(lon) * cos_lat  # 右
+        y = torch.sin(lat)            # 上
+        z = torch.cos(lon) * cos_lat  # 前
+        dirs = torch.stack([x, y, z], dim=-1)
+    else:
+        cos_lat = np.cos(lat)
+        x = np.sin(lon) * cos_lat
+        y = np.sin(lat)
+        z = np.cos(lon) * cos_lat
+        dirs = np.stack([x, y, z], axis=-1)
+    
+    return dirs
+
+
+def direction_to_lonlat(
+    dirs: Union[np.ndarray, torch.Tensor],
+) -> Tuple[Union[np.ndarray, torch.Tensor], Union[np.ndarray, torch.Tensor]]:
+    """
+    方向向量转经纬度
+    
+    Args:
+        dirs: (..., 3) 方向向量 [x, y, z]
+        
+    Returns:
+        lon: 经度
+        lat: 纬度
+    """
+    x = dirs[..., 0]
+    y = dirs[..., 1]
+    z = dirs[..., 2]
+    
+    if isinstance(dirs, torch.Tensor):
+        # 归一化
+        norm = torch.norm(dirs, dim=-1, keepdim=False)
+        norm = torch.clamp(norm, min=1e-9)
+        
+        # lon = atan2(x, z)
+        lon = torch.atan2(x, z)
+        
+        # lat = asin(y / norm)
+        y_normalized = torch.clamp(y / norm, -1.0, 1.0)
+        lat = torch.asin(y_normalized)
+    else:
+        norm = np.linalg.norm(dirs, axis=-1)
+        norm = np.maximum(norm, 1e-9)
+        
+        lon = np.arctan2(x, z)
+        y_normalized = np.clip(y / norm, -1.0, 1.0)
+        lat = np.arcsin(y_normalized)
+    
+    return lon, lat
+
+
+def erp_to_direction(
+    u: Union[np.ndarray, torch.Tensor],
+    v: Union[np.ndarray, torch.Tensor],
+    H: int,
+    W: int,
+) -> Union[np.ndarray, torch.Tensor]:
+    """
+    ERP像素坐标转方向向量
+    
+    Args:
+        u: 水平像素坐标
+        v: 垂直像素坐标
+        H: 图像高度
+        W: 图像宽度
+        
+    Returns:
+        dirs: (..., 3) 单位方向向量 [x, y, z]
+    """
+    lon, lat = erp_to_lonlat(u, v, H, W)
+    return lonlat_to_direction(lon, lat)
+
+
+def direction_to_erp(
+    dirs: Union[np.ndarray, torch.Tensor],
+    H: int,
+    W: int,
+) -> Tuple[Union[np.ndarray, torch.Tensor], Union[np.ndarray, torch.Tensor]]:
+    """
+    方向向量转ERP像素坐标
+    
+    Args:
+        dirs: (..., 3) 方向向量 [x, y, z]
+        H: 图像高度
+        W: 图像宽度
+        
+    Returns:
+        u: 水平像素坐标
+        v: 垂直像素坐标
+    """
+    lon, lat = direction_to_lonlat(dirs)
+    return lonlat_to_erp(lon, lat, H, W)
+
+
+def create_erp_grid(
+    H: int,
+    W: int,
+    device: torch.device = None,
+) -> Tuple[torch.Tensor, torch.Tensor]:
+    """
+    创建ERP像素网格
+    
+    Args:
+        H: 图像高度
+        W: 图像宽度
+        device: 计算设备
+        
+    Returns:
+        uu: (H, W) 水平坐标网格
+        vv: (H, W) 垂直坐标网格
+    """
+    if device is None:
+        device = torch.device("cpu")
+    
+    us = torch.arange(W, device=device, dtype=torch.float32)
+    vs = torch.arange(H, device=device, dtype=torch.float32)
+    vv, uu = torch.meshgrid(vs, us, indexing="ij")
+    
+    return uu, vv
+
+
+def create_direction_grid(
+    H: int,
+    W: int,
+    device: torch.device = None,
+) -> torch.Tensor:
+    """
+    创建ERP方向向量网格
+    
+    Args:
+        H: 图像高度
+        W: 图像宽度
+        device: 计算设备
+        
+    Returns:
+        dirs: (H, W, 3) 单位方向向量
+    """
+    uu, vv = create_erp_grid(H, W, device)
+    return erp_to_direction(uu, vv, H, W)
+
+
+def wrap_u(u: Union[np.ndarray, torch.Tensor], W: int) -> Union[np.ndarray, torch.Tensor]:
+    """
+    水平坐标环绕处理（ERP在水平方向是周期性的）
+    
+    Args:
+        u: 水平像素坐标
+        W: 图像宽度
+        
+    Returns:
+        u_wrapped: 环绕后的坐标，范围 [0, W)
+    """
+    if isinstance(u, torch.Tensor):
+        return torch.remainder(u, float(W))
+    else:
+        return np.mod(u, float(W))
+
+
+def clamp_v(v: Union[np.ndarray, torch.Tensor], H: int) -> Union[np.ndarray, torch.Tensor]:
+    """
+    垂直坐标裁剪处理
+    
+    Args:
+        v: 垂直像素坐标
+        H: 图像高度
+        
+    Returns:
+        v_clamped: 裁剪后的坐标，范围 [0, H-1]
+    """
+    if isinstance(v, torch.Tensor):
+        return torch.clamp(v, 0.0, float(H - 1))
+    else:
+        return np.clip(v, 0.0, float(H - 1))

code/core/erp_warp.py

@@ -0,0 +1,591 @@
+"""
+ERP Forward Warp 模块（移植自原版 ERPT erp_softsplat.py）
+
+使用锁定的投影/坐标系接口：
+- core.erp_projection: erp_to_direction, direction_to_erp, wrap_u, clamp_v
+- utils.pose_utils: Pose (R_cw, R_wc, position)
+
+算法流程：
+1. 对每个 src ERP 像素，通过 erp_to_direction 获取射线方向
+2. 根据深度计算 3D 点，变换到目标相机坐标系
+3. 通过 direction_to_erp 投影到目标 ERP
+4. Forward splatting 累积 RGB（softmax / zbuffer / point）
+
+支持的 splatting 方法：
+- softmax_splatting（默认）：自适应半径 + 高斯核 + softmax 深度竞争
+- zbuffer_splatting：两遍 z-buffer 硬遮挡
+- zbuffer_point：最近邻投影
+"""
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+from typing import Any, Dict, Optional, Tuple
+
+import cv2
+import numpy as np
+import torch
+
+from .erp_projection import (
+    erp_to_direction,
+    direction_to_erp,
+    wrap_u,
+    create_erp_grid,
+)
+
+import sys
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+from utils.pose_utils import Pose
+
+
+@dataclass
+class WarpResult:
+    """Warp 结果"""
+    warped_rgb: np.ndarray                      # (H, W, 3) uint8
+    valid_mask: np.ndarray                      # (H, W) uint8, 1=valid, 0=invalid
+    flow: Optional[np.ndarray]                  # (H, W, 2) float32, optical flow
+    weight_sum: np.ndarray                      # (H, W) float32
+    warped_depth: Optional[np.ndarray] = None   # (H, W) float32, NaN=invalid
+
+
+# =============================================================================
+# Forward Projection（坐标变换）
+# =============================================================================
+
+@torch.no_grad()
+def _forward_project(
+    src_depth_t: torch.Tensor,
+    src_pose: Pose,
+    tgt_pose: Pose,
+    erp_h: int,
+    erp_w: int,
+    device: torch.device,
+    uu: Optional[torch.Tensor] = None,
+    vv: Optional[torch.Tensor] = None,
+) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+    """
+    将源 ERP 像素投影到目标 ERP
+
+    使用锁定的 erp_projection 接口进行坐标变换。
+
+    Returns:
+        u_tgt, v_tgt: (H, W) 目标像素坐标
+        range_tgt: (H, W) 目标 range depth
+        dirs_tgt: (H, W, 3) 目标方向向量
+    """
+    if uu is None or vv is None:
+        uu, vv = create_erp_grid(erp_h, erp_w, device)
+
+    # 1. 源像素 -> 方向（源相机坐标系）
+    dirs_src = erp_to_direction(uu, vv, erp_h, erp_w)  # (H, W, 3)
+
+    # 2. 方向 * 深度 -> 源相机坐标系 3D 点
+    P_cam_src = dirs_src * src_depth_t.unsqueeze(-1)    # (H, W, 3)
+
+    # 3. 源相机 -> 世界
+    R_cw_src = torch.tensor(src_pose.R_cw, device=device, dtype=torch.float32)
+    t_src = torch.tensor(src_pose.position, device=device, dtype=torch.float32)
+    P_world = torch.einsum("ij,hwj->hwi", R_cw_src, P_cam_src) + t_src
+
+    # 4. 世界 -> 目标相机
+    R_wc_tgt = torch.tensor(tgt_pose.R_wc, device=device, dtype=torch.float32)
+    t_tgt = torch.tensor(tgt_pose.position, device=device, dtype=torch.float32)
+    P_cam_tgt = torch.einsum("ij,hwj->hwi", R_wc_tgt, P_world - t_tgt)
+
+    # 5. 目标 range depth 和方向
+    range_tgt = torch.norm(P_cam_tgt, dim=-1)
+    dirs_tgt = P_cam_tgt / torch.clamp(range_tgt.unsqueeze(-1), min=1e-9)
+
+    # 6. 方向 -> 目标 ERP 像素
+    u_tgt, v_tgt = direction_to_erp(dirs_tgt, erp_h, erp_w)
+    u_tgt = wrap_u(u_tgt, erp_w)
+
+    return u_tgt, v_tgt, range_tgt, dirs_tgt
+
+
+# =============================================================================
+# Adaptive Softmax Splatting
+# =============================================================================
+
+def _adaptive_splat_rgb(
+    erp_h: int,
+    erp_w: int,
+    u: torch.Tensor,
+    v: torch.Tensor,
+    rgb: torch.Tensor,
+    depth_compete: torch.Tensor,
+    valid: torch.Tensor,
+    alpha: float,
+    radius: torch.Tensor,
+    occlusion_gate: Optional[Dict[str, Any]] = None,
+) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+    """
+    自适应半径 softmax splatting
+
+    - 高斯核加权
+    - softmax(alpha * inv_depth) 深度竞争
+    - 可选 occlusion gate（近似 z-buffer 门控）
+    """
+    device = u.device
+    u_flat = u.reshape(-1)
+    v_flat = v.reshape(-1)
+    rgb_flat = rgb.reshape(-1, 3)
+    d_flat = depth_compete.reshape(-1)
+    valid_flat = valid.reshape(-1)
+    r_flat = radius.reshape(-1)
+
+    # 安全深度
+    safe_d = torch.where(
+        valid_flat & torch.isfinite(d_flat) & (d_flat > 0),
+        d_flat, torch.ones_like(d_flat),
+    )
+
+    # Softmax 权重 = exp(alpha * inv_depth)
+    inv_d = 1.0 / torch.clamp(safe_d, min=0.1)
+    valid_inv = inv_d[valid_flat]
+    inv_max = valid_inv.max() if len(valid_inv) > 0 else inv_d.max()
+    exp_w = torch.exp(alpha * (inv_d - inv_max))
+
+    # 可选 occlusion gate
+    gate_enabled = False
+    min_d_flat: Optional[torch.Tensor] = None
+    gate_abs = 0.0
+    gate_rel = 0.0
+    if occlusion_gate and bool(occlusion_gate.get("enabled", False)):
+        gate_enabled = True
+        gate_abs = float(occlusion_gate.get("abs_eps_m", 0.05))
+        gate_rel = float(occlusion_gate.get("rel_eps", 0.05))
+        u_nn = torch.round(u_flat).to(torch.long)
+        v_nn = torch.round(v_flat).to(torch.long)
+        u_nn = torch.remainder(u_nn, erp_w)
+        v_ok = (v_nn >= 0) & (v_nn < erp_h)
+        v_nn_c = torch.clamp(v_nn, 0, erp_h - 1)
+        idx_nn = v_nn_c * erp_w + u_nn
+        min_d_flat = torch.full((erp_h * erp_w,), float("inf"), device=device)
+        d_nn = torch.where(valid_flat & v_ok & torch.isfinite(d_flat),
+                           d_flat, torch.full_like(d_flat, float("inf")))
+        min_d_flat.scatter_reduce_(0, idx_nn, d_nn, reduce="amin", include_self=True)
+
+    accum_rgb = torch.zeros(erp_h, erp_w, 3, device=device, dtype=torch.float32)
+    accum_w = torch.zeros(erp_h, erp_w, device=device, dtype=torch.float32)
+    accum_hit = torch.zeros(erp_h, erp_w, device=device, dtype=torch.float32)
+    accum_d = torch.zeros(erp_h, erp_w, device=device, dtype=torch.float32)
+
+    u0 = torch.floor(u_flat).to(torch.int64)
+    v0 = torch.floor(v_flat).to(torch.int64)
+    du = (u_flat - u0.float()).clamp(0, 1)
+    dv = (v_flat - v0.float()).clamp(0, 1)
+
+    # Splat 范围
+    valid_radii = r_flat[valid_flat & torch.isfinite(r_flat)]
+    max_r = min(int(valid_radii.max().item()) + 1, 5) if len(valid_radii) > 0 else 2
+
+    def _add(u_idx, v_idx, bw):
+        v_ok = (v_idx >= 0) & (v_idx < erp_h)
+        m = valid_flat & v_ok & torch.isfinite(d_flat)
+        u_safe = torch.where(m, u_idx, torch.zeros_like(u_idx))
+        v_safe = torch.where(m, v_idx, torch.zeros_like(v_idx))
+        idx = v_safe * erp_w + u_safe
+
+        if gate_enabled and min_d_flat is not None:
+            md = min_d_flat.gather(0, idx)
+            gate = d_flat <= (md * (1.0 + gate_rel) + gate_abs)
+            mm = m & gate
+        else:
+            mm = m
+
+        final_w = torch.where(mm, bw * exp_w, torch.zeros_like(bw))
+        hit_w = torch.where(mm, bw, torch.zeros_like(bw))
+        accum_w.view(-1).scatter_add_(0, idx, final_w)
+        accum_hit.view(-1).scatter_add_(0, idx, hit_w)
+        accum_rgb.view(-1, 3).scatter_add_(
+            0, idx.unsqueeze(-1).expand(-1, 3),
+            (final_w.unsqueeze(-1) * rgb_flat).float(),
+        )
+        accum_d.view(-1).scatter_add_(0, idx, (final_w * d_flat).float())
+
+    for di in range(-max_r, max_r + 1):
+        for dj in range(-max_r, max_r + 1):
+            dist_ij = math.sqrt(di * di + dj * dj)
+            if dist_ij > max_r + 0.5:
+                continue
+            dx = float(di) - du
+            dy = float(dj) - dv
+            dist = torch.sqrt(dx * dx + dy * dy)
+            within = dist <= (r_flat + 0.5)
+            gauss_w = torch.where(
+                within,
+                torch.exp(-0.5 * (dist / r_flat.clamp(min=0.5)) ** 2),
+                torch.zeros_like(r_flat),
+            )
+            u_off = torch.remainder(u0 + di, erp_w)
+            v_off = v0 + dj
+            _add(u_off, v_off, gauss_w)
+
+    return accum_rgb, accum_w, accum_hit, accum_d
+
+
+# =============================================================================
+# Z-Buffer Splatting
+# =============================================================================
+
+def _zbuffer_splat_rgb(
+    erp_h: int, erp_w: int,
+    u: torch.Tensor, v: torch.Tensor,
+    rgb: torch.Tensor, depth_compete: torch.Tensor, valid: torch.Tensor,
+    eps_abs_m: float, eps_rel: float, min_w: float,
+) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+    """Z-buffer 硬遮挡 forward splatting（两遍法）"""
+    device = u.device
+    u_flat, v_flat = u.reshape(-1), v.reshape(-1)
+    d_flat = depth_compete.reshape(-1)
+    rgb_flat = rgb.reshape(-1, 3)
+    valid_flat = valid.reshape(-1)
+
+    m0 = valid_flat & torch.isfinite(u_flat) & torch.isfinite(v_flat) & \
+         torch.isfinite(d_flat) & (d_flat > 0.0)
+
+    u0 = torch.floor(u_flat).to(torch.int64)
+    v0 = torch.floor(v_flat).to(torch.int64)
+    du = (u_flat - u0.float()).clamp(0, 1)
+    dv = (v_flat - v0.float()).clamp(0, 1)
+    u0w = torch.remainder(u0, erp_w)
+    u1w = torch.remainder(u0 + 1, erp_w)
+    v1 = v0 + 1
+    w00 = (1 - du) * (1 - dv)
+    w10 = du * (1 - dv)
+    w01 = (1 - du) * dv
+    w11 = du * dv
+
+    # Pass A: min depth
+    min_depth = torch.full((erp_h * erp_w,), float("inf"), device=device)
+
+    def _amin(ui, vi, w):
+        m = m0 & (vi >= 0) & (vi < erp_h) & (w >= min_w)
+        us = torch.where(m, ui, torch.zeros_like(ui))
+        vs = torch.where(m, vi, torch.zeros_like(vi))
+        idx = vs * erp_w + us
+        cand = torch.where(m, d_flat, torch.full_like(d_flat, float("inf")))
+        min_depth.scatter_reduce_(0, idx, cand, reduce="amin", include_self=True)
+
+    _amin(u0w, v0, w00); _amin(u1w, v0, w10)
+    _amin(u0w, v1, w01); _amin(u1w, v1, w11)
+
+    # Pass B: accumulate near-front
+    accum_rgb = torch.zeros(erp_h, erp_w, 3, device=device)
+    accum_w = torch.zeros(erp_h, erp_w, device=device)
+    accum_hit = torch.zeros(erp_h, erp_w, device=device)
+    accum_d = torch.zeros(erp_h, erp_w, device=device)
+
+    def _acc(ui, vi, w):
+        m = m0 & (vi >= 0) & (vi < erp_h) & (w >= min_w)
+        us = torch.where(m, ui, torch.zeros_like(ui))
+        vs = torch.where(m, vi, torch.zeros_like(vi))
+        idx = vs * erp_w + us
+        md = min_depth.gather(0, idx)
+        gate = d_flat <= (md * (1 + eps_rel) + eps_abs_m)
+        mm = m & gate
+        wf = torch.where(mm, w, torch.zeros_like(w))
+        accum_w.view(-1).scatter_add_(0, idx, wf)
+        accum_hit.view(-1).scatter_add_(0, idx, wf)
+        accum_rgb.view(-1, 3).scatter_add_(
+            0, idx.unsqueeze(-1).expand(-1, 3),
+            (wf.unsqueeze(-1) * rgb_flat).float(),
+        )
+        accum_d.view(-1).scatter_add_(0, idx, (wf * d_flat).float())
+
+    _acc(u0w, v0, w00); _acc(u1w, v0, w10)
+    _acc(u0w, v1, w01); _acc(u1w, v1, w11)
+
+    return accum_rgb, accum_w, accum_hit, accum_d
+
+
+# =============================================================================
+# Z-Buffer Point
+# =============================================================================
+
+def _zbuffer_point_rgb(
+    erp_h: int, erp_w: int,
+    u: torch.Tensor, v: torch.Tensor,
+    rgb: torch.Tensor, depth_compete: torch.Tensor, valid: torch.Tensor,
+    eps_abs_m: float, eps_rel: float,
+) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+    """Z-buffer 点渲染（radius=0, winner-take-all）"""
+    device = u.device
+    u_flat, v_flat = u.reshape(-1), v.reshape(-1)
+    d_flat = depth_compete.reshape(-1)
+    rgb_flat = rgb.reshape(-1, 3)
+    valid_flat = valid.reshape(-1)
+
+    m0 = valid_flat & torch.isfinite(u_flat) & torch.isfinite(v_flat) & \
+         torch.isfinite(d_flat) & (d_flat > 0.0)
+
+    u_nn = torch.remainder(torch.round(u_flat).to(torch.int64), erp_w)
+    v_nn = torch.round(v_flat).to(torch.int64)
+    v_ok = (v_nn >= 0) & (v_nn < erp_h)
+    m = m0 & v_ok
+    us = torch.where(m, u_nn, torch.zeros_like(u_nn))
+    vs = torch.where(m, v_nn, torch.zeros_like(v_nn))
+    idx = vs * erp_w + us
+
+    # Pass A: min depth
+    min_depth = torch.full((erp_h * erp_w,), float("inf"), device=device)
+    cand = torch.where(m, d_flat, torch.full_like(d_flat, float("inf")))
+    min_depth.scatter_reduce_(0, idx, cand, reduce="amin", include_self=True)
+
+    # Pass B
+    md = min_depth.gather(0, idx)
+    gate = d_flat <= (md * (1 + eps_rel) + eps_abs_m)
+    mm = m & gate
+    wf = torch.where(mm, torch.ones_like(d_flat), torch.zeros_like(d_flat))
+
+    accum_rgb = torch.zeros(erp_h, erp_w, 3, device=device)
+    accum_w = torch.zeros(erp_h, erp_w, device=device)
+    accum_hit = torch.zeros(erp_h, erp_w, device=device)
+    accum_d = torch.zeros(erp_h, erp_w, device=device)
+
+    accum_w.view(-1).scatter_add_(0, idx, wf)
+    accum_hit.view(-1).scatter_add_(0, idx, wf)
+    accum_rgb.view(-1, 3).scatter_add_(
+        0, idx.unsqueeze(-1).expand(-1, 3),
+        (wf.unsqueeze(-1) * rgb_flat).float(),
+    )
+    accum_d.view(-1).scatter_add_(0, idx, (wf * d_flat).float())
+
+    return accum_rgb, accum_w, accum_hit, accum_d
+
+
+# =============================================================================
+# Hole Fill
+# =============================================================================
+
+def _edge_aware_hole_fill(
+    rgb: np.ndarray, mask: np.ndarray,
+    max_hole_px: int = 5,
+    inpaint_radius: int = 2,
+) -> Tuple[np.ndarray, np.ndarray]:
+    """小洞填充（只填充极小洞，避免 disocclusion 被错误填充）"""
+    holes = (mask == 0).astype(np.uint8)
+    if holes.sum() == 0:
+        return rgb, mask
+
+    num, labels, stats, _ = cv2.connectedComponentsWithStats(holes, connectivity=8)
+    fill_mask = np.zeros_like(holes)
+    max_area = max_hole_px * max_hole_px
+
+    for i in range(1, num):
+        area = stats[i, cv2.CC_STAT_AREA]
+        if area <= max_area:
+            fill_mask[labels == i] = 1
+
+    if fill_mask.sum() == 0:
+        return rgb, mask
+
+    rgb_bgr = cv2.cvtColor(rgb, cv2.COLOR_RGB2BGR)
+    filled = cv2.inpaint(rgb_bgr, fill_mask, inpaint_radius, cv2.INPAINT_TELEA)
+    filled_rgb = cv2.cvtColor(filled, cv2.COLOR_BGR2RGB)
+
+    rgb_out = rgb.copy()
+    mask_out = mask.copy()
+    fill_bool = fill_mask > 0
+    rgb_out[fill_bool] = filled_rgb[fill_bool]
+    mask_out[fill_bool] = 1
+
+    return rgb_out, mask_out
+
+
+# =============================================================================
+# 主函数
+# =============================================================================
+
+@torch.no_grad()
+def warp_erp_to_target(
+    src_rgb: np.ndarray,
+    src_depth: np.ndarray,
+    src_pose: Pose,
+    tgt_pose: Pose,
+    cfg: Dict[str, Any],
+    device: torch.device,
+) -> WarpResult:
+    """
+    从源 ERP 视角 warp 到目标 ERP 视角
+
+    使用锁定的 erp_projection.py 进行坐标变换，
+    ���用锁定的 pose_utils.Pose 进行位姿处理。
+
+    Args:
+        src_rgb: (H, W, 3) uint8 源 RGB
+        src_depth: (H, W) float32 源 range depth（米）
+        src_pose: 源相机位姿（Pose 实例）
+        tgt_pose: 目标相机位姿（Pose 实例）
+        cfg: 配置字典
+        device: 计算设备
+
+    Returns:
+        WarpResult
+    """
+    warp_cfg = cfg.get("warp", {})
+    method = str(warp_cfg.get("method", "softmax_splatting"))
+    alpha = float(warp_cfg.get("alpha", 2.0))
+    min_weight_sum = float(warp_cfg.get("min_weight_sum", 1e-4))
+    output_flow = bool(warp_cfg.get("output_flow", True))
+    output_depth = bool(warp_cfg.get("output_depth", True))
+    depth_scale_factor = float(warp_cfg.get("depth_scale_factor", 1.0))
+
+    # Z-buffer 参数
+    z_eps_abs = float(warp_cfg.get("zbuffer_eps_abs_m", 0.03))
+    z_eps_rel = float(warp_cfg.get("zbuffer_eps_rel", 0.03))
+    z_min_w = float(warp_cfg.get("zbuffer_min_weight", 1e-3))
+
+    # 自适应半径参数
+    base_radius = float(warp_cfg.get("splat_radius_px", 1.5))
+    radius_min = float(warp_cfg.get("radius_min_px", 0.6))
+    radius_max_eq = float(warp_cfg.get("radius_max_px", 2.2))
+    radius_max_pole = float(warp_cfg.get("radius_max_pole_px", 3.4))
+    pole_radius_scale = float(warp_cfg.get("pole_radius_scale", 3.0))
+    pole_lat_threshold = float(warp_cfg.get("pole_lat_threshold", 60.0)) * math.pi / 180.0
+    depth_radius_scale = bool(warp_cfg.get("depth_radius_scale", False))
+    depth_ref = float(warp_cfg.get("depth_ref_m", 2.0))
+    depth_edge_aware = bool(warp_cfg.get("depth_edge_aware", True))
+    depth_edge_threshold = float(warp_cfg.get("depth_edge_threshold", 0.3))
+    depth_edge_min_scale = float(warp_cfg.get("depth_edge_min_scale", 0.12))
+
+    # Hole fill
+    hole_fill = bool(warp_cfg.get("hole_fill_enabled", False)) and method not in ("zbuffer_splatting", "zbuffer_point")
+    max_hole_px = int(warp_cfg.get("max_hole_px", 16))
+
+    erp_h, erp_w = src_rgb.shape[:2]
+
+    # 转 tensor
+    src_rgb_t = torch.from_numpy(src_rgb.astype(np.float32)).to(device) / 255.0
+    src_depth_t = torch.from_numpy(src_depth.astype(np.float32)).to(device)
+    if depth_scale_factor != 1.0:
+        src_depth_t *= depth_scale_factor
+
+    valid = torch.isfinite(src_depth_t) & (src_depth_t > 0.0)
+
+    # --- 深度边缘掩码 ---
+    depth_edge_scale = torch.ones_like(src_depth_t)
+    if depth_edge_aware:
+        from torch.nn.functional import conv2d
+        sobel_x = torch.tensor([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]],
+                                dtype=torch.float32, device=device).view(1, 1, 3, 3)
+        sobel_y = torch.tensor([[-1, -2, -1], [0, 0, 0], [1, 2, 1]],
+                                dtype=torch.float32, device=device).view(1, 1, 3, 3)
+        safe_d = torch.where(valid, src_depth_t, src_depth_t[valid].median() if valid.any() else torch.ones_like(src_depth_t))
+        log_d = torch.log(torch.clamp(safe_d, min=0.1)).unsqueeze(0).unsqueeze(0)
+        gx = conv2d(log_d, sobel_x, padding=1).squeeze()
+        gy = conv2d(log_d, sobel_y, padding=1).squeeze()
+        grad = torch.sqrt(gx ** 2 + gy ** 2)
+        gmax = grad.max()
+        if gmax > 1e-6:
+            gnorm = grad / gmax
+        else:
+            gnorm = torch.zeros_like(grad)
+        depth_edge_scale = torch.clamp(
+            1.0 - gnorm / max(depth_edge_threshold, 1e-6),
+            min=depth_edge_min_scale, max=1.0,
+        )
+        depth_edge_scale = torch.where(torch.isfinite(depth_edge_scale),
+                                        depth_edge_scale, torch.ones_like(depth_edge_scale))
+
+    # --- ERP 网格 ---
+    uu, vv = create_erp_grid(erp_h, erp_w, device)
+
+    # --- Forward project ---
+    u_tgt, v_tgt, range_tgt, dirs_tgt = _forward_project(
+        src_depth_t, src_pose, tgt_pose, erp_h, erp_w, device, uu, vv,
+    )
+
+    # --- 自适应半径 ---
+    lat_tgt = torch.asin(torch.clamp(dirs_tgt[..., 1], -1.0, 1.0))
+    abs_lat = torch.abs(lat_tgt)
+    pole_factor = torch.clamp(
+        (abs_lat - pole_lat_threshold) / (0.5 * math.pi - pole_lat_threshold),
+        min=0.0, max=1.0,
+    )
+    lat_scale = 1.0 + pole_factor * (pole_radius_scale - 1.0)
+
+    if depth_radius_scale:
+        safe_range = torch.where(valid, range_tgt, torch.full_like(range_tgt, depth_ref))
+        d_scale = 1.0 / (1.0 + safe_range / depth_ref)
+    else:
+        d_scale = torch.ones_like(range_tgt)
+
+    adaptive_radius = base_radius * lat_scale * d_scale * depth_edge_scale
+    adaptive_radius = torch.where(valid, adaptive_radius, torch.full_like(adaptive_radius, base_radius))
+    radius_max_local = radius_max_eq + pole_factor * (radius_max_pole - radius_max_eq)
+    adaptive_radius = torch.clamp(adaptive_radius, min=radius_min)
+    adaptive_radius = torch.minimum(adaptive_radius, radius_max_local)
+
+    # --- Splatting ---
+    if method == "zbuffer_splatting":
+        _rgb, _w, _hit, _d = _zbuffer_splat_rgb(
+            erp_h, erp_w, u_tgt, v_tgt, src_rgb_t, range_tgt, valid,
+            z_eps_abs, z_eps_rel, z_min_w,
+        )
+    elif method == "zbuffer_point":
+        _rgb, _w, _hit, _d = _zbuffer_point_rgb(
+            erp_h, erp_w, u_tgt, v_tgt, src_rgb_t, range_tgt, valid,
+            z_eps_abs, z_eps_rel,
+        )
+    else:
+        _rgb, _w, _hit, _d = _adaptive_splat_rgb(
+            erp_h, erp_w, u_tgt, v_tgt, src_rgb_t, range_tgt, valid,
+            alpha, adaptive_radius, warp_cfg.get("occlusion_gate", None),
+        )
+
+    # --- 归一化 ---
+    denom = _w > 0.0
+    out_rgb = torch.zeros_like(_rgb)
+    out_rgb[denom] = _rgb[denom] / _w[denom].unsqueeze(-1)
+
+    min_hit = float(warp_cfg.get("min_hit_sum", 1e-6))
+    valid_mask = _hit > min_hit
+
+    warped_np = (out_rgb.clamp(0, 1) * 255).byte().cpu().numpy()
+    mask_np = valid_mask.cpu().numpy().astype(np.uint8)
+    weight_np = _hit.cpu().numpy().astype(np.float32)
+
+    # --- Warped depth ---
+    warped_depth_np = None
+    if output_depth:
+        out_d = torch.full((erp_h, erp_w), float("nan"), device=device)
+        out_d[denom] = _d[denom] / torch.clamp(_w[denom], min=1e-9)
+        out_d[~valid_mask] = float("nan")
+        warped_depth_np = out_d.cpu().numpy().astype(np.float32)
+
+    # --- Hole fill ---
+    if hole_fill:
+        warped_np, mask_np = _edge_aware_hole_fill(warped_np, mask_np, max_hole_px)
+
+    # --- Optical flow ---
+    flow_np = None
+    if output_flow:
+        du = u_tgt - uu
+        du = (du + 0.5 * erp_w) % erp_w - 0.5 * erp_w
+        dv = v_tgt - vv
+        flow_np = torch.stack([du, dv], dim=-1).cpu().numpy().astype(np.float32)
+
+    return WarpResult(
+        warped_rgb=warped_np,
+        valid_mask=mask_np,
+        flow=flow_np,
+        weight_sum=weight_np,
+        warped_depth=warped_depth_np,
+    )
+
+
+def create_comparison_image(
+    warped_rgb: np.ndarray,
+    valid_mask: np.ndarray,
+    gt_rgb: Optional[np.ndarray] = None,
+) -> np.ndarray:
+    """创建对比图（warped | GT），如无 GT 则只返回 warped"""
+    vis = warped_rgb.copy()
+    vis[valid_mask == 0] = 0
+
+    if gt_rgb is not None:
+        return np.concatenate([vis, gt_rgb], axis=0)
+    return vis

code/core/tangent_extraction.py

@@ -0,0 +1,566 @@
+"""
+ERP -> Tangent 切片生成模块（移植自原版 ERPT）
+
+功能：
+1. 生成 icosahedron 20 面的相机朝向
+2. 生成 north/south pole 额外切片（使用更大 FOV）
+3. 从 ERP 采样生成透视切片（支持 seam wrap）
+4. 输出切片 RGB 和元数据
+
+关键算法：
+- icosahedron 面法向计算
+- 相机坐标系构建（look-at）
+- ERP -> 透视投影（grid_sample with seam wrap）
+"""
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+
+
+@dataclass
+class TangentSlice:
+    """切片规格"""
+    slice_id: str                    # 切片 ID（如 "face_00", "north", "south"）
+    slice_type: str                  # 类型："face" | "pole_north" | "pole_south"
+    center_dir: np.ndarray           # 切片中心方向（世界坐标，单位向量）
+    R_cw: np.ndarray                 # 相机到世界的旋转矩阵 (3,3)
+    fov_deg: float                   # 视场角（度）
+    resolution: int                  # 输出分辨率（像素，正方形）
+    K: np.ndarray                    # 相机内参 (3,3)
+    f_px: float                      # 焦距（像素）
+
+    def to_dict(self) -> Dict[str, Any]:
+        """转换为可 JSON 序列化的字典"""
+        return {
+            "slice_id": self.slice_id,
+            "slice_type": self.slice_type,
+            "center_dir": self.center_dir.tolist(),
+            "R_cw": self.R_cw.tolist(),
+            "fov_deg": float(self.fov_deg),
+            "resolution": int(self.resolution),
+            "K": self.K.tolist(),
+            "f_px": float(self.f_px),
+        }
+
+
+def _compute_icosahedron_face_centers() -> List[np.ndarray]:
+    """
+    计算正二十面体 20 个面的中心方向（单位向量）
+
+    正二十面体有 12 个顶点、20 个面、30 条边。
+    每个面是等边三角形，面中心 = (v0 + v1 + v2) / 3 归一化
+
+    Returns:
+        20 个单位向量的列表，每个指向一个面的中心
+    """
+    # 黄金比例
+    phi = (1.0 + math.sqrt(5.0)) / 2.0
+
+    # 正二十面体 12 个顶点（坐标已归一化）
+    vertices = np.array([
+        [-1,  phi, 0],
+        [ 1,  phi, 0],
+        [-1, -phi, 0],
+        [ 1, -phi, 0],
+        [0, -1,  phi],
+        [0,  1,  phi],
+        [0, -1, -phi],
+        [0,  1, -phi],
+        [ phi, 0, -1],
+        [ phi, 0,  1],
+        [-phi, 0, -1],
+        [-phi, 0,  1],
+    ], dtype=np.float64)
+
+    # 归一化顶点
+    vertices = vertices / np.linalg.norm(vertices, axis=1, keepdims=True)
+
+    # 20 个面的顶点索引
+    faces = [
+        (0, 11, 5), (0, 5, 1), (0, 1, 7), (0, 7, 10), (0, 10, 11),
+        (1, 5, 9), (5, 11, 4), (11, 10, 2), (10, 7, 6), (7, 1, 8),
+        (3, 9, 4), (3, 4, 2), (3, 2, 6), (3, 6, 8), (3, 8, 9),
+        (4, 9, 5), (2, 4, 11), (6, 2, 10), (8, 6, 7), (9, 8, 1),
+    ]
+
+    centers = []
+    for i0, i1, i2 in faces:
+        center = vertices[i0] + vertices[i1] + vertices[i2]
+        center = center / np.linalg.norm(center)
+        centers.append(center.astype(np.float32))
+
+    return centers
+
+
+def _look_at_rotation(forward: np.ndarray, up_hint: Optional[np.ndarray] = None) -> np.ndarray:
+    """
+    构建从相机坐标系到世界坐标系的旋转矩阵
+
+    相机坐标系约定：
+    - +Z: 前向（forward）
+    - +Y: 上方（up）
+    - +X: 右方（right = up × forward）
+
+    Args:
+        forward: 相机前向方向（世界坐标，单位向量）
+        up_hint: 上方提示（默认世界 Y 轴）
+
+    Returns:
+        R_cw: (3,3) 旋转矩阵，v_world = R_cw @ v_cam
+    """
+    f = np.asarray(forward, dtype=np.float64).reshape(3)
+    f = f / (np.linalg.norm(f) + 1e-12)
+
+    if up_hint is None:
+        up_hint = np.array([0.0, 1.0, 0.0], dtype=np.float64)
+    u = np.asarray(up_hint, dtype=np.float64).reshape(3)
+    u = u / (np.linalg.norm(u) + 1e-12)
+
+    # 如果 forward 与 up_hint 几乎平行，换一个 up_hint
+    if abs(np.dot(f, u)) > 0.95:
+        u = np.array([0.0, 0.0, 1.0], dtype=np.float64)
+
+    # 右方向 = up × forward
+    r = np.cross(u, f)
+    r = r / (np.linalg.norm(r) + 1e-12)
+
+    # 真正的上方向 = forward × right
+    u2 = np.cross(f, r)
+    u2 = u2 / (np.linalg.norm(u2) + 1e-12)
+
+    # 旋转矩阵的列是相机坐标轴在世界坐标系中的表示
+    R_cw = np.stack([r, u2, f], axis=1)
+    return R_cw.astype(np.float32)
+
+
+def _compute_intrinsics(resolution: int, fov_deg: float) -> Tuple[np.ndarray, float]:
+    """
+    计算针孔相机内参
+
+    Args:
+        resolution: 图像分辨率（正方形）
+        fov_deg: 水平视场角（度）
+
+    Returns:
+        K: (3,3) 内参矩阵
+        f_px: 焦距（像素）
+    """
+    fov_rad = np.deg2rad(fov_deg)
+    f_px = 0.5 * resolution / np.tan(0.5 * fov_rad)
+
+    cx = (resolution - 1) * 0.5
+    cy = (resolution - 1) * 0.5
+
+    K = np.array([
+        [f_px, 0.0,  cx],
+        [0.0,  f_px, cy],
+        [0.0,  0.0,  1.0]
+    ], dtype=np.float32)
+
+    return K, float(f_px)
+
+
+def build_icosahedron_slices(cfg: Dict[str, Any]) -> List[TangentSlice]:
+    """
+    根据配置构建 icosahedron + poles 切片列表
+
+    360MonoDepth 风格：使用 padding_factor 而非 overlap_pad_deg
+    有效 FOV = base_fov * padding_factor
+
+    Args:
+        cfg: 配置字典（包含 tangent 配置）
+
+    Returns:
+        切片规格列表
+    """
+    tcfg = cfg.get("tangent", {})
+
+    # 基本参数
+    face_resolution = int(tcfg.get("face_resolution", 768))
+    fov_deg = float(tcfg.get("fov_deg", 90.0))
+
+    # 360MonoDepth 风格 padding（优先使用 padding_factor）
+    padding_factor = float(tcfg.get("padding_factor", 1.3))
+    overlap_pad_deg = float(tcfg.get("overlap_pad_deg", 0.0))  # 向后兼容
+
+    # 计算有效 FOV
+    if padding_factor > 1.0:
+        effective_fov = fov_deg * padding_factor
+    else:
+        effective_fov = fov_deg + overlap_pad_deg
+
+    # 限制最大 FOV 避免极端畸变
+    effective_fov = min(effective_fov, 170.0)
+
+    # 极区参数（增强覆盖）
+    add_poles = bool(tcfg.get("add_poles", True))
+    pole_fov_deg = float(tcfg.get("pole_fov_deg", 150.0))  # 默认更大
+    pole_resolution = int(tcfg.get("pole_resolution", face_resolution))
+    pole_extra_rings = int(tcfg.get("pole_extra_rings", 0))  # 额外极区密采样
+
+    slices = []
+
+    # 1. 添加 20 个 icosahedron 面
+    face_centers = _compute_icosahedron_face_centers()
+    for i, center in enumerate(face_centers):
+        R_cw = _look_at_rotation(center)
+        K, f_px = _compute_intrinsics(face_resolution, effective_fov)
+
+        slices.append(TangentSlice(
+            slice_id=f"face_{i:02d}",
+            slice_type="face",
+            center_dir=center,
+            R_cw=R_cw,
+            fov_deg=effective_fov,
+            resolution=face_resolution,
+            K=K,
+            f_px=f_px,
+        ))
+
+    # 2. 添加极区切片
+    if add_poles:
+        # 北极（+Y）
+        north_dir = np.array([0.0, 1.0, 0.0], dtype=np.float32)
+        R_north = _look_at_rotation(north_dir, up_hint=np.array([0.0, 0.0, -1.0]))
+        K_north, f_north = _compute_intrinsics(pole_resolution, pole_fov_deg)
+
+        slices.append(TangentSlice(
+            slice_id="north",
+            slice_type="pole_north",
+            center_dir=north_dir,
+            R_cw=R_north,
+            fov_deg=pole_fov_deg,
+            resolution=pole_resolution,
+            K=K_north,
+            f_px=f_north,
+        ))
+
+        # 南极（-Y）
+        south_dir = np.array([0.0, -1.0, 0.0], dtype=np.float32)
+        R_south = _look_at_rotation(south_dir, up_hint=np.array([0.0, 0.0, 1.0]))
+        K_south, f_south = _compute_intrinsics(pole_resolution, pole_fov_deg)
+
+        slices.append(TangentSlice(
+            slice_id="south",
+            slice_type="pole_south",
+            center_dir=south_dir,
+            R_cw=R_south,
+            fov_deg=pole_fov_deg,
+            resolution=pole_resolution,
+            K=K_south,
+            f_px=f_south,
+        ))
+
+        # 3. 额外极区密采样环（可选）
+        if pole_extra_rings > 0:
+            _add_polar_ring_slices(
+                slices, pole_extra_rings, pole_resolution, pole_fov_deg * 0.8
+            )
+
+    return slices
+
+
+def _add_polar_ring_slices(
+    slices: List[TangentSlice],
+    num_rings: int,
+    resolution: int,
+    fov_deg: float,
+) -> None:
+    """
+    添加额外的极区密采样切片（环状分布在极区附近）
+    """
+    latitudes = [math.radians(75)]
+    if num_rings > 1:
+        latitudes = [math.radians(60 + 25 * i / (num_rings - 1)) for i in range(num_rings)]
+
+    K, f_px = _compute_intrinsics(resolution, fov_deg)
+
+    for ring_idx, lat in enumerate(latitudes):
+        num_slices_per_ring = 6
+        for lon_idx in range(num_slices_per_ring):
+            lon = lon_idx * 2 * math.pi / num_slices_per_ring
+
+            # 北极附近
+            x_n = math.cos(lat) * math.sin(lon)
+            y_n = math.sin(lat)
+            z_n = math.cos(lat) * math.cos(lon)
+            dir_n = np.array([x_n, y_n, z_n], dtype=np.float32)
+            R_n = _look_at_rotation(dir_n)
+
+            slices.append(TangentSlice(
+                slice_id=f"pole_ring_n_{ring_idx}_{lon_idx}",
+                slice_type="pole_ring",
+                center_dir=dir_n,
+                R_cw=R_n,
+                fov_deg=fov_deg,
+                resolution=resolution,
+                K=K,
+                f_px=f_px,
+            ))
+
+            # 南极附近
+            y_s = -math.sin(lat)
+            dir_s = np.array([x_n, y_s, z_n], dtype=np.float32)
+            R_s = _look_at_rotation(dir_s)
+
+            slices.append(TangentSlice(
+                slice_id=f"pole_ring_s_{ring_idx}_{lon_idx}",
+                slice_type="pole_ring",
+                center_dir=dir_s,
+                R_cw=R_s,
+                fov_deg=fov_deg,
+                resolution=resolution,
+                K=K,
+                f_px=f_px,
+            ))
+
+
+def _build_sample_grid(
+    slice_spec: TangentSlice,
+    erp_h: int,
+    erp_w: int,
+    device: torch.device,
+) -> torch.Tensor:
+    """
+    构建从 ERP 采样到切片的网格
+
+    对于切片的每个像素 (u, v):
+    1. 反投影到相机坐标系射线方向
+    2. 旋转到世界坐标系
+    3. 计算球面经纬度
+    4. 映射到 ERP 像素坐标
+    """
+    res = slice_spec.resolution
+    K = slice_spec.K
+    R_cw = slice_spec.R_cw
+
+    fx, fy = float(K[0, 0]), float(K[1, 1])
+    cx, cy = float(K[0, 2]), float(K[1, 2])
+
+    # 切片像素坐标
+    xs = torch.arange(res, device=device, dtype=torch.float32)
+    ys = torch.arange(res, device=device, dtype=torch.float32)
+    yv, xv = torch.meshgrid(ys, xs, indexing="ij")  # (H, W)
+
+    # 反投影到相机坐标系
+    x_cam = (xv - cx) / fx
+    y_cam = -(yv - cy) / fy  # 图像 y 向下，相机 y 向上
+    z_cam = torch.ones_like(x_cam)
+
+    # 归一化射线方向
+    dirs_cam = torch.stack([x_cam, y_cam, z_cam], dim=-1)  # (H, W, 3)
+    dirs_cam = dirs_cam / torch.clamp(torch.norm(dirs_cam, dim=-1, keepdim=True), min=1e-9)
+
+    # 旋转到世界坐标系
+    R = torch.tensor(R_cw, device=device, dtype=torch.float32)
+    dirs_world = torch.einsum("ij,hwj->hwi", R, dirs_cam)  # (H, W, 3)
+
+    # 计算球面坐标
+    x = dirs_world[..., 0]
+    y = dirs_world[..., 1]
+    z = dirs_world[..., 2]
+
+    lon = torch.atan2(x, z)
+    lat = torch.asin(torch.clamp(y, -1.0, 1.0))
+
+    # 映射到 ERP 像素坐标
+    u = (lon + math.pi) / (2.0 * math.pi) * float(erp_w)
+    v = (math.pi / 2.0 - lat) / math.pi * float(erp_h - 1)
+
+    # Seam wrap: ERP 在 x 方向扩展 3 倍，采样时从中间段采样
+    u_padded = u + float(erp_w)
+    erp_w_padded = erp_w * 3
+
+    x_norm = (u_padded / float(erp_w_padded - 1)) * 2.0 - 1.0
+    y_norm = (v / float(erp_h - 1)) * 2.0 - 1.0
+
+    grid = torch.stack([x_norm, y_norm], dim=-1).unsqueeze(0)  # (1, H, W, 2)
+    return grid
+
+
+@torch.no_grad()
+def extract_tangent_from_erp(
+    erp_rgb: torch.Tensor,
+    slice_spec: TangentSlice,
+    device: torch.device,
+) -> np.ndarray:
+    """
+    从 ERP 提取单个切片
+
+    Args:
+        erp_rgb: (1, 3, H, W) ERP 图像
+        slice_spec: 切片规格
+        device: 计算设备
+
+    Returns:
+        tangent_rgb: (H, W, 3) uint8 numpy array
+    """
+    erp_h, erp_w = erp_rgb.shape[2], erp_rgb.shape[3]
+
+    # Seam wrap: 扩展 ERP 宽度
+    erp_padded = torch.cat([erp_rgb, erp_rgb, erp_rgb], dim=-1)  # (1, 3, H, 3W)
+
+    # 构建采样网格
+    grid = _build_sample_grid(slice_spec, erp_h, erp_w, device)
+
+    # 采样
+    tangent = F.grid_sample(
+        erp_padded,
+        grid,
+        mode="bilinear",
+        padding_mode="border",
+        align_corners=True,
+    )  # (1, 3, res, res)
+
+    # 转换为 numpy
+    tangent_np = (tangent.squeeze(0).permute(1, 2, 0).clamp(0, 1) * 255.0).byte().cpu().numpy()
+    return tangent_np
+
+
+@torch.no_grad()
+def extract_all_tangents(
+    erp_rgb_np: np.ndarray,
+    slices: List[TangentSlice],
+    device: torch.device,
+) -> Dict[str, np.ndarray]:
+    """
+    从 ERP 提取所有切片
+
+    Args:
+        erp_rgb_np: (H, W, 3) ERP 图像 numpy array
+        slices: 切片规格列表
+        device: 计算设备
+
+    Returns:
+        字典 {slice_id: tangent_rgb}
+    """
+    erp_t = torch.from_numpy(erp_rgb_np).to(device).permute(2, 0, 1).float() / 255.0
+    erp_t = erp_t.unsqueeze(0)  # (1, 3, H, W)
+
+    results = {}
+    for s in slices:
+        tangent = extract_tangent_from_erp(erp_t, s, device)
+        results[s.slice_id] = tangent
+
+    return results
+
+
+def compute_ray_directions_for_slice(
+    slice_spec: TangentSlice,
+    device: torch.device,
+) -> torch.Tensor:
+    """
+    计算切片每个像素对应的世界坐标系射线方向（融合时使用）
+
+    Returns:
+        dirs_world: (H, W, 3) 单位方向向量
+    """
+    res = slice_spec.resolution
+    K = slice_spec.K
+    R_cw = slice_spec.R_cw
+
+    fx, fy = float(K[0, 0]), float(K[1, 1])
+    cx, cy = float(K[0, 2]), float(K[1, 2])
+
+    xs = torch.arange(res, device=device, dtype=torch.float32)
+    ys = torch.arange(res, device=device, dtype=torch.float32)
+    yv, xv = torch.meshgrid(ys, xs, indexing="ij")
+
+    x_cam = (xv - cx) / fx
+    y_cam = -(yv - cy) / fy
+    z_cam = torch.ones_like(x_cam)
+
+    dirs_cam = torch.stack([x_cam, y_cam, z_cam], dim=-1)
+    dirs_cam = dirs_cam / torch.clamp(torch.norm(dirs_cam, dim=-1, keepdim=True), min=1e-9)
+
+    R = torch.tensor(R_cw, device=device, dtype=torch.float32)
+    dirs_world = torch.einsum("ij,hwj->hwi", R, dirs_cam)
+
+    return dirs_world
+
+
+@torch.no_grad()
+def compute_coverage_mask(
+    slices: List[TangentSlice],
+    erp_h: int,
+    erp_w: int,
+    device: torch.device,
+) -> Tuple[np.ndarray, Dict[str, float]]:
+    """
+    计算 ERP 覆盖率掩码（纯几何计算）
+
+    Returns:
+        coverage_mask: (H, W) uint8, 255=covered, 0=uncovered
+        stats: 覆盖率统计字典
+    """
+    coverage = torch.zeros(erp_h, erp_w, device=device, dtype=torch.float32)
+
+    for s in slices:
+        res = s.resolution
+        K = s.K
+        R_cw = s.R_cw
+
+        fx, fy = float(K[0, 0]), float(K[1, 1])
+        cx, cy = float(K[0, 2]), float(K[1, 2])
+
+        xs = torch.arange(res, device=device, dtype=torch.float32)
+        ys = torch.arange(res, device=device, dtype=torch.float32)
+        yv, xv = torch.meshgrid(ys, xs, indexing="ij")
+
+        x_cam = (xv - cx) / fx
+        y_cam = -(yv - cy) / fy
+        z_cam = torch.ones_like(x_cam)
+
+        dirs_cam = torch.stack([x_cam, y_cam, z_cam], dim=-1)
+        dirs_cam = dirs_cam / torch.clamp(torch.norm(dirs_cam, dim=-1, keepdim=True), min=1e-9)
+
+        R = torch.tensor(R_cw, device=device, dtype=torch.float32)
+        dirs_world = torch.einsum("ij,hwj->hwi", R, dirs_cam)
+
+        x = dirs_world[..., 0]
+        y = dirs_world[..., 1]
+        z = dirs_world[..., 2]
+
+        lon = torch.atan2(x, z)
+        lat = torch.asin(torch.clamp(y, -1.0, 1.0))
+
+        u = (lon + math.pi) / (2.0 * math.pi) * float(erp_w)
+        v = (math.pi / 2.0 - lat) / math.pi * float(erp_h - 1)
+
+        u_int = torch.round(u).to(torch.int64)
+        v_int = torch.round(v).to(torch.int64)
+
+        u_int = torch.clamp(u_int % erp_w, 0, erp_w - 1)
+        v_int = torch.clamp(v_int, 0, erp_h - 1)
+
+        idx = v_int * erp_w + u_int
+        idx = idx.reshape(-1)
+
+        coverage_flat = coverage.reshape(-1)
+        coverage_flat.scatter_add_(0, idx, torch.ones_like(idx, dtype=torch.float32))
+
+    covered = coverage > 0
+    coverage_mask = (covered.float() * 255).byte().cpu().numpy()
+
+    total_pixels = erp_h * erp_w
+    covered_pixels = int(covered.sum().item())
+
+    pole_rows = int(erp_h * 0.1)
+    north_covered = covered[:pole_rows, :].float().mean().item()
+    south_covered = covered[-pole_rows:, :].float().mean().item()
+
+    stats = {
+        "total_coverage": covered_pixels / total_pixels * 100,
+        "uncovered_pixels": total_pixels - covered_pixels,
+        "north_pole_coverage": north_covered * 100,
+        "south_pole_coverage": south_covered * 100,
+    }
+
+    return coverage_mask, stats

code/data/README.md

@@ -0,0 +1,16 @@
+# Data Directory
+
+Place local scene assets here when running experiments. Do not commit dataset files to the anonymous repository.
+
+Recommended layout:
+
+```text
+data/
+├── blender_indoor/
+├── blender_outdoor/
+├── hm3d/
+└── scannetpp/
+```
+
+You may also pass absolute paths directly to the pipeline CLI.
+

code/dataset_metadata/croissant.json

@@ -0,0 +1,308 @@
+{
+  "@context": {
+    "@language": "en",
+    "@vocab": "https://schema.org/",
+    "citeAs": "cr:citeAs",
+    "column": "cr:column",
+    "conformsTo": "dct:conformsTo",
+    "cr": "http://mlcommons.org/croissant/",
+    "rai": "http://mlcommons.org/croissant/RAI/",
+    "data": {
+      "@id": "cr:data",
+      "@type": "@json"
+    },
+    "dataType": {
+      "@id": "cr:dataType",
+      "@type": "@vocab"
+    },
+    "dct": "http://purl.org/dc/terms/",
+    "examples": {
+      "@id": "cr:examples",
+      "@type": "@json"
+    },
+    "extract": "cr:extract",
+    "field": "cr:field",
+    "fileProperty": "cr:fileProperty",
+    "fileObject": "cr:fileObject",
+    "fileSet": "cr:fileSet",
+    "format": "cr:format",
+    "includes": "cr:includes",
+    "isLiveDataset": "cr:isLiveDataset",
+    "jsonPath": "cr:jsonPath",
+    "key": "cr:key",
+    "md5": "cr:md5",
+    "parentField": "cr:parentField",
+    "path": "cr:path",
+    "recordSet": "cr:recordSet",
+    "references": "cr:references",
+    "regex": "cr:regex",
+    "repeated": "cr:repeated",
+    "replace": "cr:replace",
+    "samplingRate": "cr:samplingRate",
+    "sc": "https://schema.org/",
+    "separator": "cr:separator",
+    "source": "cr:source",
+    "subField": "cr:subField",
+    "transform": "cr:transform"
+  },
+  "@type": "sc:Dataset",
+  "conformsTo": "http://mlcommons.org/croissant/1.0",
+  "name": "CM-EVS",
+  "description": "CM-EVS is a curated panoramic RGB-D dataset built under a single principle: maximize the geometric coverage of a 3D scene with the fewest equirectangular (ERP) frames possible. The headline release contains 11,583 ERP RGB-depth-pose frames over 326 Blender indoor scenes (CC-BY 4.0), each paired with the per-step provenance log of the depth-conflict-aware curator that selected it. The full v1.0 release additionally provides 786,344 frames re-encoded from TartanGround (783,944 frames over 63 environments) and OB3D (2,400 frames over 12 scenes) outdoor sources into the same ERP and world-to-camera pose schema, plus license-aware adapter packages for HM3D (14,475 frames over 401 rooms after local regeneration) and ScanNet++ (8,267 frames over 500 scans after local regeneration) that produce matched frames locally without redistributing licensed assets.",
+  "version": "1.0.0",
+  "license": "https://creativecommons.org/licenses/by/4.0/",
+  "url": "https://anonymous.4open.science/r/cmevs-XXXX",
+  "citeAs": "@inproceedings{cmevs2026, title={{CM-EVS}: A Coverage-Curated Panoramic {RGB-D} Dataset for Indoor Scene Understanding}, author={Anonymous Author(s)}, booktitle={NeurIPS 2026 Datasets and Benchmarks Track (under review)}, year={2026}}",
+  "creator": {
+    "@type": "Organization",
+    "name": "Anonymous (double-blind submission)"
+  },
+  "datePublished": "2026-05-01",
+  "keywords": [
+    "panoramic",
+    "equirectangular",
+    "ERP",
+    "RGB-D",
+    "view planning",
+    "fixed-budget",
+    "data-centric",
+    "viewpoint provenance",
+    "indoor scene understanding",
+    "panoramic depth estimation",
+    "novel view synthesis",
+    "world model pretraining"
+  ],
+  "isLiveDataset": false,
+  "distribution": [
+    {
+      "@type": "cr:FileObject",
+      "@id": "blender-indoor-archive.tar",
+      "name": "blender-indoor-archive.tar",
+      "contentUrl": "https://anonymous.4open.science/r/cmevs-XXXX/blender_indoor.tar",
+      "encodingFormat": "application/x-tar",
+      "sha256": "TODO_SHA256"
+    },
+    {
+      "@type": "cr:FileSet",
+      "@id": "blender-indoor-rgb",
+      "name": "blender-indoor-rgb",
+      "containedIn": {"@id": "blender-indoor-archive.tar"},
+      "encodingFormat": "image/png",
+      "includes": "rgb/*.png"
+    },
+    {
+      "@type": "cr:FileSet",
+      "@id": "blender-indoor-depth",
+      "name": "blender-indoor-depth",
+      "containedIn": {"@id": "blender-indoor-archive.tar"},
+      "encodingFormat": "application/octet-stream",
+      "includes": "depth/*.npy"
+    },
+    {
+      "@type": "cr:FileSet",
+      "@id": "blender-indoor-pose",
+      "name": "blender-indoor-pose",
+      "containedIn": {"@id": "blender-indoor-archive.tar"},
+      "encodingFormat": "application/json",
+      "includes": "pose/*.json"
+    },
+    {
+      "@type": "cr:FileSet",
+      "@id": "blender-indoor-metadata",
+      "name": "blender-indoor-metadata",
+      "containedIn": {"@id": "blender-indoor-archive.tar"},
+      "encodingFormat": "application/json",
+      "includes": "metadata/*.json*"
+    },
+    {
+      "@type": "cr:FileObject",
+      "@id": "outdoor-tartanground-adapter.tar",
+      "name": "outdoor-tartanground-adapter.tar",
+      "contentUrl": "https://anonymous.4open.science/r/cmevs-XXXX/outdoor_tartanground_adapter.tar",
+      "encodingFormat": "application/x-tar",
+      "sha256": "TODO_SHA256"
+    },
+    {
+      "@type": "cr:FileObject",
+      "@id": "outdoor-ob3d-adapter.tar",
+      "name": "outdoor-ob3d-adapter.tar",
+      "contentUrl": "https://anonymous.4open.science/r/cmevs-XXXX/outdoor_ob3d_adapter.tar",
+      "encodingFormat": "application/x-tar",
+      "sha256": "TODO_SHA256"
+    },
+    {
+      "@type": "cr:FileObject",
+      "@id": "hm3d-adapter.tar",
+      "name": "hm3d-adapter.tar",
+      "contentUrl": "https://anonymous.4open.science/r/cmevs-XXXX/hm3d_adapter.tar",
+      "encodingFormat": "application/x-tar",
+      "sha256": "TODO_SHA256"
+    },
+    {
+      "@type": "cr:FileObject",
+      "@id": "scannetpp-adapter.tar",
+      "name": "scannetpp-adapter.tar",
+      "contentUrl": "https://anonymous.4open.science/r/cmevs-XXXX/scannetpp_adapter.tar",
+      "encodingFormat": "application/x-tar",
+      "sha256": "TODO_SHA256"
+    },
+    {
+      "@type": "cr:FileObject",
+      "@id": "curator-source-code.tar",
+      "name": "curator-source-code.tar",
+      "contentUrl": "https://anonymous.4open.science/r/cmevs-XXXX/code.tar",
+      "encodingFormat": "application/x-tar",
+      "sha256": "TODO_SHA256"
+    },
+    {
+      "@type": "cr:FileObject",
+      "@id": "documentation.tar",
+      "name": "documentation.tar",
+      "contentUrl": "https://anonymous.4open.science/r/cmevs-XXXX/docs.tar",
+      "encodingFormat": "application/x-tar",
+      "sha256": "TODO_SHA256"
+    },
+    {
+      "@type": "cr:FileObject",
+      "@id": "frame-manifest.csv",
+      "name": "frame-manifest.csv",
+      "contentUrl": "https://anonymous.4open.science/r/cmevs-XXXX/frame_manifest.csv",
+      "encodingFormat": "text/csv",
+      "sha256": "TODO_SHA256"
+    }
+  ],
+  "recordSet": [
+    {
+      "@type": "cr:RecordSet",
+      "@id": "erp-frame-records",
+      "name": "erp-frame-records",
+      "description": "One record per released ERP frame. Curator-only fields (viewpoint_score, coverage_gain, conflict_ratio, candidate_id) are populated only for frames produced by the depth-conflict-aware curator; outdoor re-encoded frames carry the schema fields without per-step provenance.",
+      "field": [
+        {
+          "@type": "cr:Field",
+          "@id": "erp-frame-records/frame_id",
+          "name": "frame_id",
+          "dataType": "sc:Text",
+          "source": {"fileObject": {"@id": "frame-manifest.csv"}, "extract": {"column": "frame_id"}}
+        },
+        {
+          "@type": "cr:Field",
+          "@id": "erp-frame-records/source",
+          "name": "source",
+          "dataType": "sc:Text",
+          "source": {"fileObject": {"@id": "frame-manifest.csv"}, "extract": {"column": "source"}}
+        },
+        {
+          "@type": "cr:Field",
+          "@id": "erp-frame-records/scene_id",
+          "name": "scene_id",
+          "dataType": "sc:Text",
+          "source": {"fileObject": {"@id": "frame-manifest.csv"}, "extract": {"column": "scene_id"}}
+        },
+        {
+          "@type": "cr:Field",
+          "@id": "erp-frame-records/room_id",
+          "name": "room_id",
+          "dataType": "sc:Text",
+          "source": {"fileObject": {"@id": "frame-manifest.csv"}, "extract": {"column": "room_id"}}
+        },
+        {
+          "@type": "cr:Field",
+          "@id": "erp-frame-records/split",
+          "name": "split",
+          "dataType": "sc:Text",
+          "source": {"fileObject": {"@id": "frame-manifest.csv"}, "extract": {"column": "split"}}
+        },
+        {
+          "@type": "cr:Field",
+          "@id": "erp-frame-records/rgb",
+          "name": "rgb",
+          "dataType": "sc:ImageObject",
+          "source": {"fileObject": {"@id": "frame-manifest.csv"}, "extract": {"column": "rgb_path"}}
+        },
+        {
+          "@type": "cr:Field",
+          "@id": "erp-frame-records/depth",
+          "name": "depth",
+          "dataType": "sc:Text",
+          "source": {"fileObject": {"@id": "frame-manifest.csv"}, "extract": {"column": "depth_path"}}
+        },
+        {
+          "@type": "cr:Field",
+          "@id": "erp-frame-records/pose_quaternion",
+          "name": "pose_quaternion",
+          "dataType": "sc:Text",
+          "source": {"fileObject": {"@id": "frame-manifest.csv"}, "extract": {"column": "pose_quaternion"}}
+        },
+        {
+          "@type": "cr:Field",
+          "@id": "erp-frame-records/pose_position",
+          "name": "pose_position",
+          "dataType": "sc:Text",
+          "source": {"fileObject": {"@id": "frame-manifest.csv"}, "extract": {"column": "pose_position"}}
+        },
+        {
+          "@type": "cr:Field",
+          "@id": "erp-frame-records/camera_type",
+          "name": "camera_type",
+          "dataType": "sc:Text",
+          "source": {"fileObject": {"@id": "frame-manifest.csv"}, "extract": {"column": "camera_type"}}
+        },
+        {
+          "@type": "cr:Field",
+          "@id": "erp-frame-records/viewpoint_score",
+          "name": "viewpoint_score",
+          "dataType": "sc:Float",
+          "source": {"fileObject": {"@id": "frame-manifest.csv"}, "extract": {"column": "viewpoint_score"}}
+        },
+        {
+          "@type": "cr:Field",
+          "@id": "erp-frame-records/coverage_gain",
+          "name": "coverage_gain",
+          "dataType": "sc:Float",
+          "source": {"fileObject": {"@id": "frame-manifest.csv"}, "extract": {"column": "coverage_gain"}}
+        },
+        {
+          "@type": "cr:Field",
+          "@id": "erp-frame-records/conflict_ratio",
+          "name": "conflict_ratio",
+          "dataType": "sc:Float",
+          "source": {"fileObject": {"@id": "frame-manifest.csv"}, "extract": {"column": "conflict_ratio"}}
+        },
+        {
+          "@type": "cr:Field",
+          "@id": "erp-frame-records/candidate_id",
+          "name": "candidate_id",
+          "dataType": "sc:Text",
+          "source": {"fileObject": {"@id": "frame-manifest.csv"}, "extract": {"column": "candidate_id"}}
+        }
+      ]
+    }
+  ],
+  "rai:dataCollection": "Indoor data is produced by the CM-EVS pipeline (asset loading, coordinate normalization, candidate generation, 26-direction geometric-validity filtering, conflict-aware greedy selection, 2048x1024 high-resolution Cycles ERP rendering, export under the unified schema). Outdoor data is sourced from TartanGround and OB3D and re-encoded into the unified schema; the curator is not run on outdoor sources in v1.0. HM3D and ScanNet++ frames are not redistributed; the release ships adapter regeneration scripts.",
+  "rai:dataPreprocessingProtocol": "Coordinate normalization to a right-handed +X-right, +Y-up, +Z-forward world frame with the OpenCV-style camera frame; pose stored as a scalar-first world-to-camera quaternion plus a position relative to the scene's first selected frame. AABB computation; source-specific candidate generation; 26-direction geometric-validity filter. Cubemap-to-ERP re-encoding at native resolution for outdoor sources; optional exposure adjustment for Blender; output schema conversion. Candidate probes, intermediate caches, pre-render-all oracle frames, and locally regenerated HM3D / ScanNet++ outputs are excluded from the public frame count F_pub.",
+  "rai:dataAnnotationProtocol": "No human annotation is performed. All labels (split, source, scene id, viewpoint score, coverage gain, conflict ratio) are produced automatically by the curator pipeline and recorded in metadata/per_step_log.jsonl and metadata/selected_viewpoints.json.",
+  "rai:dataReleaseMaintenancePlan": "Versioned releases on a 6-month cadence. Errata tracked via the project repository; SHA256 manifests refreshed at every release; HM3D and ScanNet++ regeneration scripts updated when upstream APIs, file layouts, or access terms change.",
+  "rai:dataUseCases": [
+    "Panoramic depth estimation",
+    "ERP novel-view synthesis",
+    "Panoramic Gaussian-splatting reconstruction",
+    "Panoramic world-model pretraining",
+    "Fixed-budget viewpoint policy evaluation"
+  ],
+  "rai:dataLimitations": [
+    "Real-scan derived frames (HM3D, ScanNet++) are not redistributed; users must accept upstream license terms and regenerate locally.",
+    "Outdoor frames are re-encoded source trajectories rather than curator-selected subsets and therefore do not carry per-step provenance.",
+    "Synthetic-real transfer must be validated separately by source; we do not claim Blender-only gains imply real-scan gains.",
+    "Geometry-validity filters may fail in atria, semi-outdoor spaces, narrow transitions, noisy scans, or pure point-cloud scenes."
+  ],
+  "rai:personalSensitiveInformation": "No new personal data is collected. Real-scan sources (HM3D, ScanNet++) may depict private indoor layouts and are not redistributed as derived frames. Even regeneration scripts and viewpoint metadata can reveal where observations would be sampled within a private space; users must comply with upstream source access terms.",
+  "rai:dataBiases": [
+    "Source assets inherit geographic, architectural, and scanning biases.",
+    "HM3D and ScanNet++ are skewed toward scanned residential indoor spaces.",
+    "Blender assets are skewed toward staged residential, office, and architectural scenes.",
+    "Outdoor sources (TartanGround, OB3D) are skewed toward simulator-generated terrain along circular trajectories.",
+    "Synthetic Blender materials may not match real-scan sensor noise."
+  ],
+  "rai:dataSocialImpact": "CM-EVS lowers the engineering cost of producing auditable panoramic RGB-D resources from existing 3D scenes. Positive uses include panoramic perception, data-centric evaluation, view-planning research, and 3D-consistent world-model pretraining. Potential harms include over-trusting synthetic data, obscuring upstream dataset bias, and using real indoor scans in privacy-sensitive settings. The release therefore separates public synthetic frames from licensed real-scan regeneration and documents intended uses, non-uses, and source licenses."
+}

code/environment.yml

@@ -0,0 +1,25 @@
+name: cmevs
+channels:
+  - pytorch
+  - nvidia
+  - conda-forge
+dependencies:
+  - python=3.10
+  - pip
+  - numpy>=1.24
+  - scipy
+  - pandas
+  - pyyaml
+  - pillow
+  - matplotlib
+  - scikit-learn
+  - pytorch
+  - torchvision
+  - cudatoolkit
+  - pip:
+      - opencv-python
+      - open3d
+      - trimesh
+      - tqdm
+      - jsonschema
+

code/examples/metadata/candidates.jsonl

@@ -0,0 +1,7 @@
+{"candidate_id":"tiny_000","source":"blender_indoor_tiny","scene_id":"tiny_blend_scene","position":[0.0,1.6,0.0],"yaw_deg":0.0,"valid":true,"rejection_layer":"accepted","single_view_probe_coverage":0.31,"conflict_prior":0.05,"covered_cells":["a","b","c","d"],"oracle_gain":0.30,"runtime_s":0.02}
+{"candidate_id":"tiny_001","source":"blender_indoor_tiny","scene_id":"tiny_blend_scene","position":[1.0,1.6,0.0],"yaw_deg":45.0,"valid":true,"rejection_layer":"accepted","single_view_probe_coverage":0.34,"conflict_prior":0.12,"covered_cells":["c","d","e","f","g"],"oracle_gain":0.28,"runtime_s":0.02}
+{"candidate_id":"tiny_002","source":"blender_indoor_tiny","scene_id":"tiny_blend_scene","position":[2.0,1.6,0.5],"yaw_deg":90.0,"valid":true,"rejection_layer":"accepted","single_view_probe_coverage":0.27,"conflict_prior":0.02,"covered_cells":["h","i","j"],"oracle_gain":0.24,"runtime_s":0.02}
+{"candidate_id":"tiny_003","source":"blender_indoor_tiny","scene_id":"tiny_blend_scene","position":[0.5,1.6,1.5],"yaw_deg":135.0,"valid":true,"rejection_layer":"accepted","single_view_probe_coverage":0.22,"conflict_prior":0.18,"covered_cells":["a","k","l"],"oracle_gain":0.16,"runtime_s":0.02}
+{"candidate_id":"tiny_004","source":"blender_indoor_tiny","scene_id":"tiny_blend_scene","position":[1.5,1.6,1.5],"yaw_deg":180.0,"valid":true,"rejection_layer":"accepted","single_view_probe_coverage":0.29,"conflict_prior":0.06,"covered_cells":["m","n","o","p"],"oracle_gain":0.26,"runtime_s":0.02}
+{"candidate_id":"tiny_005","source":"blender_indoor_tiny","scene_id":"tiny_blend_scene","position":[3.0,1.6,1.5],"yaw_deg":270.0,"valid":false,"rejection_layer":"visibility","single_view_probe_coverage":0.04,"conflict_prior":0.35,"covered_cells":[],"oracle_gain":0.01,"runtime_s":0.01}
+