Add files using upload-large-folder tool

ASE_exported/README.md

@@ -0,0 +1,113 @@
+# ASE 导出
+
+## 目录
+
+```text
+ASE_exported/
+├── README.md
+├── data/
+│   ├── index.json
+│   ├── original/<split>/<scene>/
+│   │   ├── ase_scene_language.txt
+│   │   └── object_instances_to_classes.json
+│   └── atek/cubercnn/train/<scene>/annotations.tar.gz
+├── kits/
+│   ├── download_ase.py
+│   ├── convert_ase.py
+│   ├── unify_ase.py
+│   └── verify_ase.py
+├── ase.jsonl
+├── source_inventory.json
+├── json_room.json
+└── multiroom/
+    ├── json_multi_merged.json
+    └── json_multi_split.json
+```
+
+`data/` 仅保留已选源标注，不含视频、RGB 或完整远端分片。上游缺失的语言或类别文件不会补造。`index.json` 是转换所需的源文件定位与选择索引；`annotations.tar.gz` 存放选中的原始 GT 成员。
+
+上图为本地及解压后的目录。Hugging Face 交付将 `data/original/` 原样打包为 `data/original.tar.gz`，避免其 train 下 100,000 个场景目录超过 Hub 每层 10,000 条目的限制。下载后在 `ASE_exported/` 内执行 `tar -xzf data/original.tar.gz -C data` 即恢复上述路径，随后脚本与 `index.json` 无需修改；其余文件保持原目录结构。
+
+`ase.jsonl` 与 `multiroom/json_multi_merged.json` 分别以 JSONL、JSON 数组保存 8,373 个完整场景；`json_room.json` 包含全部 16,375 个逐房间场景；`json_multi_split.json` 仅包含多房间场景拆出的 12,936 个房间。完整场景共含 396,948 条已归房家具，保留其中 331 个空房间。`source_inventory.json` 是这 8,373 个场景的源信息与未归房实例配套清单。
+
+`kits/` 保留下载、转换、汇总和验收脚本。本地 `.git/`、`.gitignore` 可保留，上传 Hugging Face 时排除。
+
+## 上游源数据
+
+源数据为 Meta 的 Aria Synthetic Environments。原始 ZIP 提供场景语言和实例类别；ATEK 的 `cubercnn/train` 标注提供实例框、位姿和相机下的 GT 记录。两者通过原始场景号、实例 ID 对应。
+
+下载入口来自官方 [EFM3D 数据说明](https://github.com/facebookresearch/efm3d/blob/61d30ed4eca836ab0d5e63df18bb4b915050fa89/data/README.md)及 [ATEK 仓库](https://github.com/facebookresearch/atek/tree/aae40aa7d5b9573b5b81460467d7377c519127fb)，对应清单为 `aria_synthetic_environments_dataset_download_urls.json`、`AriaSyntheticEnvironment_ATEK_download_urls.json`。具体本地选择以 `data/index.json` 为准。
+
+原始索引覆盖 101,000 个场景，但所用 ATEK 清单只覆盖 9,966 个 train 场景。导出还要求能够形成房间记录，且至少一个房间有已归入家具，因此当前交付为 8,373 个 train 场景，不代表原数据集全量。`source_subset` 始终取原始 ZIP 的划分，不改写为模型任务划分。
+
+## schema 字段表
+
+字段以[转换脚本](kits/convert_ase.py)和[汇总脚本](kits/unify_ase.py)为准。长度为米，面积为平方米。原坐标 Z-up、场景全局原点，源未声明手性；家具位置为源 OBB 中心，尺寸为局部 XYZ 全尺寸，旋转满足 `R = Rz · Ry · Rx`，单位为度。
+
+### 场景字段
+
+| 字段 | 类型 | 来源与取值 |
+|---|---|---|
+| `scene_id` | string | 完整场景为 `ase_<split>_<源场景号补足7位>`；逐房间视图改为对应 `room_id`。 |
+| `sample_id` | string | 与所在视图的 `scene_id` 相同。 |
+| `dataset` | string | `ASE`。 |
+| `source_dataset` | string | `aria_synthetic_environments`。 |
+| `source_subset` | string | 原始 ZIP 划分 `train` 或 `test`；当前交付只有 `train`。 |
+| `room_count` | integer | `len(rooms)`，逐房间视图为 1。 |
+| `total_area` | number / null | 完整场景累加已知房间面积，全部缺失则 `null`；逐房间视图取该房间面积。部分缺失时只是已知部分之和。 |
+| `building_style` | null | 无源风格标注。 |
+| `description` | null | 不从场景命令生成描述。 |
+| `description_source` | null | 无描述来源。 |
+| `provenance` | object | `source_file` 为原始 ZIP 文件名，`source_scene_index` 为原始场景号整数，`split` 为原始划分。 |
+| `rooms` | array<object> | 按墙端点连通组建立房间，按组内最小 wall ID 排序；保留场景中的空房间。 |
+
+### 房间字段
+
+| 字段 | 类型 | 来源与取值 |
+|---|---|---|
+| `room_id` | string | `<完整scene_id>::room_<room_index>`。 |
+| `room_index` | integer | 墙组排序后的连续索引，从 0 开始。 |
+| `room_type` | string / null | 项目决定：按已归房家具的 ATEK `category_ids` 与边界顶点数推断，规则见下文。 |
+| `room_type_source` | string | 有推断为 `inferred_from_furniture`，否则 `unavailable`。 |
+| `room_boundary` | array<[number, number]> / null | 沿源墙端点邻接关系遍历链或环所得 XY 顶点，不重复起点；开放链以首尾连线闭合，不能完整表达则 `null`。 |
+| `room_boundary_type` | string / null | 有边界为 `wall_polygon`，否则 `null`。 |
+| `room_area_m2` | number / null | 上述轮廓的鞋带面积；无边界则 `null`。 |
+| `room_height` | number / null | 本组源墙 `height` 全部一致时取该值，缺失或不一致则 `null`，不平均。 |
+| `coordinate_system` | string | 固定说明米制、源手性未声明、Z-up、场景全局原点、OBB 中心与局部尺寸、ZYX 欧拉角。 |
+| `doors` | array<object> | 源 `make_door` 通过 wall ID 关联本组，每项为 `{position:{x,y,z}, width, height}`；无记录为 `[]`。 |
+| `windows` | array<object> | 同 `doors`，来源为 `make_window`。同一开口关联两房间时分别保留。 |
+| `furniture_quantity` | integer | `len(furniture)`，不是源类别表总数。 |
+| `furniture` | array<object> | 非结构实例按源 OBB 中心 XY 唯一归房，按实例 ID 排序；无法唯一归房的进入配套清单。 |
+| `source_fields` | object | `make_wall`、`make_door`、`make_window` 数组，保留本组墙和关联开口的完整原参数。 |
+
+房型使用 ATEK 类别 ID 6 作为睡眠信号、ID 4 作为沙发信号。边界顶点多于 4 时，有睡眠信号为 `apartment`，否则有沙发为 `living room`；其他情况下，两种信号均有为 `studio`，只有睡眠为 `bedroom`，只有沙发为 `living room`。无信号为 `null`。这些是项目推断，不是上游房型标签。
+
+### 家具字段
+
+| 字段 | 类型 | 来源与取值 |
+|---|---|---|
+| `furniture_category` | string / null | 仅取 `object_instances_to_classes.json[str(instance_id)]` 原字符串；缺失则 `null`，不用 ATEK 合并类别补值。 |
+| `furniture_instance_id` | string | `<完整scene_id>::inst_<源instance_id>`。 |
+| `furniture_position` | object / null | ATEK `ts_world_object` 平移列对应的 `{x,y,z}`；无 GT 则 `null`。 |
+| `furniture_rotation` | object | ATEK 旋转矩阵分解出的 `{x:roll,y:pitch,z:yaw}`，角度归一到 `[-180,180)`，保留 8 位小数；无 GT 则三个分量均为 `null`。 |
+| `furniture_size` | object / null | 源 `object_dimensions` 的 X/Y/Z 对应 `{width,length,height}`；不乘 2、不按长短边重排，无 GT 则 `null`。 |
+| `source_fields` | object | 有 GT 时保留 `source_file`、`obb3_gt`、`obb2_gt`；无 GT 为 `{}`。源路径相对导出根目录，归档成员以 `::` 定位。 |
+
+`obb3_gt` 按源 camera 保存单实例切片，保留 `instance_ids`、`category_names`、`category_ids`、`object_dimensions`、`ts_world_object` 的原键与批维。`obb2_gt` 同样保留 `instance_ids`、`category_names`、`category_ids`、`box_ranges`、`visibility_ratios`；缺失 2D 记录为 `{}`。
+
+### 配套清单字段
+
+| 字段 | 类型 | 来源与取值 |
+|---|---|---|
+| `scene_id` | string | 对应完整场景 ID。 |
+| `unassigned_objects` | array<object> | 家具 schema 的实例记录：无位置、未落入任何房间或落入多个房间。 |
+| `structural_instances` | array<object> | 被识别为 `wall`、`floor`、`ceiling`、`door`、`window` 的实例记录，不计入房间家具。 |
+| `source_fields` | object | `object_instances_to_classes` 原类别表，以及场景语言的全部命令及参数。 |
+
+## 已知缺陷
+
+- 所选 GT 只覆盖原数据集的一部分场景和实例；有类别表不代表有几何。全部房间为空或没有房间的场景不进入交付，其配套清单也不输出，需回查源数据。
+- 墙端点连通组不等于建筑学房间，可能包含整个住宅。开放墙链的首尾连线没有缺口距离限制；分叉或无法遍历的组边界为空，影响面积和家具归属。
+- 家具按中心点唯一归房，不按物体实际占地切分；边界附近、跨房间或几何缺失的对象可能进入未归房清单。
+- 房型仅有 `apartment`、`studio`、`bedroom`、`living room` 四类及 `null`，无法表达厨房等类型；源家具类别与 ATEK 推断类别采用不同词表。
+- 同一实例有多条 GT 时采用所选记录中的第一条；所留片段不能保证覆盖完整序列中的所有冲突或可见实例。门窗是墙引用的开口，不能视为与实例清单一一对应。

ASE_exported/data/atek/cubercnn/train/80967/annotations.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f5d194000aa76ef834d1f7e97db64af83e6e01d917ab611d37423388bb3b6e5f
+size 16807

ASE_exported/data/atek/cubercnn/train/80993/annotations.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ae34b42630b34ea0cc0207258ae6dbb3106bb865189f189593ab8520b3060c25
+size 33767

ASE_exported/data/atek/cubercnn/train/81089/annotations.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b7167b85a31c2a353f5eee3af0cba357ab74bcc008bcfa5deedd59ab5d93c702
+size 18559

ASE_exported/data/atek/cubercnn/train/81277/annotations.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2dbe11c96eb4c6bfa1ee85db09c98be5af2b4acf845b44c1c9699034bff8b58a
+size 47589

ASE_exported/data/atek/cubercnn/train/81419/annotations.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3e3ab44a87d85c9c20a48a59f870c18d6e0654fff32a117845fde420dfd7693e
+size 56079

ASE_exported/data/atek/cubercnn/train/81841/annotations.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:406fd0266867b75cc9a02b9c91267c13842468e52625d471d513cea71dc58cb4
+size 13212

ASE_exported/data/atek/cubercnn/train/82268/annotations.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6bbc67eeed9be7b44841a907ecbc54845081ebe15a8bfb7e6938ca36d2ad0d08
+size 25838

ASE_exported/data/atek/cubercnn/train/82866/annotations.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4079eea5ee401092e26be1bd1c085049aabb41f2e5a1497b00e113c154d682b4
+size 36718

ASE_exported/data/atek/cubercnn/train/82892/annotations.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f380df0e1a8350d59bb8b893b223fe8b2e6a303ab3c99fe488210611cceb9f42
+size 31967

ASE_exported/data/atek/cubercnn/train/83188/annotations.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:769469db93f973e8dd663fc534cebe69956693e5b68753f7d38e61798fb4e377
+size 32784

ASE_exported/data/atek/cubercnn/train/83518/annotations.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5b81a50a55ab20af09b20d26d5316bd7006000216819c10e9bfcd48b5e75b1b7
+size 12672

ASE_exported/data/atek/cubercnn/train/83520/annotations.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1b4dbd77a0b3ea76fc8c17509b67df95caae55d5fb0976051154e027ed092faa
+size 8813

ASE_exported/data/atek/cubercnn/train/83527/annotations.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8c09685bd7e49c68115bbbfa7c1f8cb260bdba94239d3dcd81ca02f32104757c
+size 36304

ASE_exported/data/atek/cubercnn/train/83940/annotations.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:03c1979fb32b59bacbe5021273c597b268e681c685d47643092aa27440721761
+size 8354

ASE_exported/data/atek/cubercnn/train/84359/annotations.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:01549eed809ceb3b8f090c40db34de80dd305ffd3ee7c5154f5b460e951f293e
+size 4620

ASE_exported/data/atek/cubercnn/train/84705/annotations.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3068f8ef1a70f54893df3079dd5a38072d50b37816d6bd72bf45d1d0c2e9a8cb
+size 10189

ASE_exported/data/atek/cubercnn/train/84957/annotations.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6671d05e1a0bf72a52485f8f9f91d36423c9a66af7060652f2b3b8ba4f75d969
+size 36435

ASE_exported/data/atek/cubercnn/train/85429/annotations.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ca2a16e8964fc961267132bd349664f53fdf37f6b3fe59de3398b3f72b74b127
+size 30644

ASE_exported/data/atek/cubercnn/train/85871/annotations.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cebab1c2e7cc5a5d4a71f74ff1ad34e780a92031d09cced7b283e3af620f59c3
+size 9304

ASE_exported/data/atek/cubercnn/train/8588/annotations.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a247d9381f29185da1a995df35173554a2ffa40083f424b556fc036ff85dd3ac
+size 13145

ASE_exported/data/atek/cubercnn/train/85885/annotations.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0184ab116bbc701601f42fff2aa188ac8417b62f7552aded5295f7bcd9ee18e7
+size 30442

ASE_exported/data/atek/cubercnn/train/86052/annotations.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:79f2ba946c642b7207dd39b50600dbbafd3ebc01ad69037319fa58cda3f804df
+size 38695

ASE_exported/data/atek/cubercnn/train/86055/annotations.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:857c67885bf712279e344a2dad3391004f7993b12406903261b40ff6d2c0a81f
+size 19314

ASE_exported/data/atek/cubercnn/train/86258/annotations.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:031b55c1c48f7cc0ece4326a1ab024ea9baaa05cefcf8a468470e3e35cf6e0c6
+size 31482

ASE_exported/data/atek/cubercnn/train/86856/annotations.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ede3e062bc65d55b88eea68de25250ae038d7c620c2379aa4cb2c6b94f253b62
+size 10762

ASE_exported/data/atek/cubercnn/train/87180/annotations.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dca06e3942c952db17093953afdd9bc0881ed2fb72142fc0ac1f4a15caeb54d7
+size 22883

ASE_exported/data/atek/cubercnn/train/87187/annotations.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4d582d9685c85ba492d42d45300067da5011fc6ae790ad1bfd6da95d0ae81dbd
+size 32007

ASE_exported/data/atek/cubercnn/train/87528/annotations.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e636960fedbc7fbfe47771d779bfe4b36ad5bc506cc4c43db5ac4274db48f030
+size 15360

ASE_exported/data/atek/cubercnn/train/87970/annotations.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:23d0da615e6ebc2c358c4c6330f514ccb660c0b551772ac190950117284cea60
+size 7038

ASE_exported/data/atek/cubercnn/train/87984/annotations.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0601b5a385d3ef67963214769c663ae55cad18626b563f8f3247a2794e876e12
+size 23529

ASE_exported/data/atek/cubercnn/train/88104/annotations.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0f520a2644031c30deb68948e97de99e87f7873568802a38d65edea6da951817
+size 15257

ASE_exported/data/atek/cubercnn/train/88336/annotations.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0225631c47b3109b974bf18fe40f88c85333c6a131ad77ce4bd1e79da2f6e939
+size 64885

ASE_exported/data/atek/cubercnn/train/88560/annotations.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6b31af3864acaa70c6191c75fa80d152651879c0870400f83f384c9556565ffa
+size 11368

ASE_exported/data/atek/cubercnn/train/88594/annotations.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8d0a89e87e3bd022d023524a52b00d14e4d0bf879fa7850c55a020c4f4ece8c5
+size 84118

ASE_exported/data/atek/cubercnn/train/88752/annotations.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bfc4065b79cb7266fe6ea246ff8b3fdd86773a7e42f6773dcffe8bc0abd2fabf
+size 49962

ASE_exported/data/atek/cubercnn/train/88938/annotations.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:029d43f5ac85c8bd97b481f6fca9ba341c37e37e3c9f849a1b5fd54bfbbe08ee
+size 19991

ASE_exported/data/atek/cubercnn/train/89022/annotations.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5c425c39c89091af4afa8cd20373370a215a61debf0f0fdf4817b5850090fee1
+size 63459

ASE_exported/data/atek/cubercnn/train/89210/annotations.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:38202a5eecf5c3a19446f74e9aa0b0277fe4b9d66d2f458449a407a0cb96de51
+size 71420

ASE_exported/data/atek/cubercnn/train/89228/annotations.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d2dd0c9151386610b86bb73c9f9c287dd9a55d4db7193e674fd1a27a7e32652f
+size 19940

ASE_exported/data/atek/cubercnn/train/8924/annotations.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a63d92762154db195d5315c971bdcce3d702616f442f5b85c64b9fd9f320f4d0
+size 46816

ASE_exported/data/atek/cubercnn/train/89446/annotations.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3d68ae018ba75a39ef60c6d7d3a0581b21ff68f37b849a2f64ebead12f07db59
+size 7127

ASE_exported/data/atek/cubercnn/train/89674/annotations.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a26336fe42ce11bceb3d927cc38871498048c0047982a08487c784bab095655a
+size 4707

ASE_exported/data/atek/cubercnn/train/89680/annotations.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:25e3397cf460009410a6cded1af5e645e7534ba97f4c998a8ac2e501e117b7d8
+size 70356

ASE_exported/data/atek/cubercnn/train/901/annotations.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bb63db6b98b9e2829048f0e1f4ab8afea31c9fa4c78587f52e18b380e3b7a253
+size 46064

ASE_exported/data/atek/cubercnn/train/9234/annotations.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6ba8ec6b6438acada040bfe7f5cb2eb26cbff2db9c76dc4c762be88e3605ee8e
+size 37635

ASE_exported/kits/convert_ase.py

@@ -0,0 +1,438 @@
+"""Convert selected ASE source records to the fixed scene/room/furniture schema.
+
+Field calculations are the independently reviewed ASE preview implementation.
+No runtime dependency on development files or another exported dataset.
+"""
+from __future__ import annotations
+import argparse
+from collections import defaultdict
+from contextlib import contextmanager
+import json
+import io
+import math
+import os
+import tarfile
+import zipfile
+from pathlib import Path
+
+class JsonWriter:
+    def __init__(self, path, *, lines=False):
+        self.path = Path(path)
+        self.lines = lines
+        self.count = 0
+
+    def __enter__(self):
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        self.tmp = self.path.with_suffix(self.path.suffix + '.part')
+        self.handle = self.tmp.open('w', encoding='utf-8')
+        if not self.lines:
+            self.handle.write('[\n')
+        return self
+
+    def write(self, value):
+        encoded = json.dumps(value, ensure_ascii=False, allow_nan=False, separators=(',', ':'))
+        if self.count and not self.lines:
+            self.handle.write(',\n')
+        self.handle.write(encoded)
+        if self.lines:
+            self.handle.write('\n')
+        self.count += 1
+
+    def __exit__(self, kind, value, traceback):
+        try:
+            if kind is None:
+                if not self.lines:
+                    self.handle.write('\n]\n')
+                self.handle.flush()
+                os.fsync(self.handle.fileno())
+        finally:
+            self.handle.close()
+        if kind is None:
+            os.replace(self.tmp, self.path)
+        else:
+            self.tmp.unlink(missing_ok=True)
+
+
+def load_selection(data_dir, limit):
+    index = json.loads((Path(data_dir) / 'index.json').read_text(encoding='utf-8'))
+    rows = sorted(index['scenes'], key=lambda r: (r['split'], r['scene_index']))
+    identities = [(r['split'], r['scene_index']) for r in rows]
+    if len(identities) != len(set(identities)):
+        raise ValueError('Duplicate split/scene identities in input index')
+    # Enumerate the index, not language/GT files: absent annotations retain scenes.
+    return index, rows[:limit] if limit is not None else rows
+
+
+@contextmanager
+def source_members(reference):
+    """Read original members from loose files or archive::member references."""
+    filename, separator, member = str(reference).partition('::')
+    if separator and filename.endswith('.tar.gz'):
+        with tarfile.open(filename, 'r:gz') as archive:
+            folder = Path(member).parent.as_posix()
+            def read(name):
+                target = name if folder == '.' else folder + '/' + name
+                return archive.extractfile(target).read()
+            yield Path(member).name, read
+    elif separator:
+        with zipfile.ZipFile(filename) as archive:
+            folder = Path(member).parent.as_posix()
+            def read(name):
+                target = name if folder == '.' else folder + '/' + name
+                return archive.read(target)
+            yield Path(member).name, read
+    else:
+        path = Path(filename)
+        yield path.name, lambda name: (path.parent / name).read_bytes()
+
+
+SCENE_KEYS = 'scene_id sample_id dataset source_dataset source_subset room_count total_area building_style description description_source provenance rooms'.split()
+ROOM_KEYS = 'room_id room_index room_type room_type_source room_boundary room_boundary_type room_area_m2 room_height coordinate_system doors windows furniture_quantity furniture source_fields'.split()
+FURNITURE_KEYS = 'furniture_category furniture_instance_id furniture_position furniture_rotation furniture_size source_fields'.split()
+# The two ATEK cubercnn GT namespaces, with the raw member keys each one carries.
+GT_KEYS = {'obb3_gt': ('instance_ids', 'category_ids', 'object_dimensions', 'ts_world_object'),
+           'obb2_gt': ('instance_ids', 'category_ids', 'box_ranges', 'visibility_ratios')}
+# Structured3D STRUCTURAL_LABELS; original ASE names, not ATEK's "other".
+STRUCTURAL = {'wall', 'floor', 'ceiling', 'door', 'window'}
+COORDINATES = ('meter; source handedness not declared; Z-up; scene-global origin; '
+               'furniture position=source OBB center; size=local XYZ full extents; '
+               'rotation=ZYX intrinsic Euler degrees, R=Rz*Ry*Rx; openings=source center')
+
+
+# Pinned InteriorGS geometry; approved ASE-specific room-type rules (see README).
+def finite(value: object) -> bool:
+    return isinstance(value, (int, float)) and math.isfinite(float(value))
+
+def point_xy(point: object) -> tuple[float, float] | None:
+    if isinstance(point, dict):
+        x, y = point.get("x"), point.get("y")
+    elif isinstance(point, list) and len(point) >= 2:
+        x, y = point[0], point[1]
+    else:
+        return None
+    if not (finite(x) and finite(y)):
+        return None
+    return float(x), float(y)
+
+def polygon_area(profile: list[object]) -> float | None:
+    points = [point_xy(p) for p in profile]
+    if len(points) < 3 or any(p is None for p in points):
+        return None
+    area = 0.0
+    for (x1, y1), (x2, y2) in zip(points, points[1:] + points[:1]):
+        area += x1 * y2 - x2 * y1
+    return abs(area) / 2.0
+
+def point_in_polygon(x: float, y: float, profile: list[object], eps: float = 1e-8) -> bool:
+    points = [point_xy(p) for p in profile]
+    if len(points) < 3 or any(p is None for p in points):
+        return False
+    inside = False
+    for (x1, y1), (x2, y2) in zip(points, points[1:] + points[:1]):
+        cross = (x - x1) * (y2 - y1) - (y - y1) * (x2 - x1)
+        dot = (x - x1) * (x2 - x1) + (y - y1) * (y2 - y1)
+        length_sq = (x2 - x1) ** 2 + (y2 - y1) ** 2
+        if abs(cross) <= eps and -eps <= dot <= length_sq + eps:
+            return True
+        if (y1 > y) != (y2 > y):
+            crossing_x = (x2 - x1) * (y - y1) / (y2 - y1) + x1
+            if x < crossing_x:
+                inside = not inside
+    return inside
+
+def atek_name(entry):
+    """Native ATEK label for one instance, the only naming a scene without
+    object_instances_to_classes.json has."""
+    for record in (entry or {}).get('source_fields', {}).get('obb3_gt', {}).values():
+        names = record.get('category_names')
+        if names:
+            return names[0]
+    return None
+
+
+def atek_category_id(entry):
+    """Native ATEK class id. Preferred over the name for room-type inference:
+    the id space is global, so it survives the 28,120 scenes that ship no
+    object_instances_to_classes.json, where category_names is also absent."""
+    for record in (entry or {}).get('source_fields', {}).get('obb3_gt', {}).values():
+        ids = record.get('category_ids')
+        if ids:
+            return ids[0]
+    return None
+
+
+# Neither ASE vocabulary names a bathroom, kitchen or office fixture, so sleeping
+# and seating are the only functions a wall ring can be shown to hold. Chair
+# (95.9% of rooms) and table (76.2%) are too common to discriminate alone.
+# ASE models no interior partitions, so one ring can enclose a whole dwelling.
+# The ring's own shape says which: ASE walls are axis aligned, so a four-vertex
+# ring is exactly one rectangular room and more vertices are a compound footprint.
+# Shape is read first, because what a single room holds and what a whole dwelling
+# holds are different questions.
+SLEEPING_ID, SEATING_ID = 6, 4  # bed / mattress / sleeping bag; sofa
+
+def infer_room_type(category_ids, boundary):
+    ids = set(category_ids)
+    sleeping, seating = SLEEPING_ID in ids, SEATING_ID in ids
+    if boundary and len(boundary) > 4:
+        return 'apartment' if sleeping else 'living room' if seating else None
+    if sleeping:
+        return 'studio' if seating else 'bedroom'
+    return 'living room' if seating else None
+
+
+def euler(matrix):
+    # SceneSmith euler_xyz_from_angle_axis(), from the matrix decomposition
+    # onward. ASE already supplies R, so no angle-axis conversion is needed.
+    sy = math.hypot(matrix[0][0], matrix[1][0])
+    if sy > 1e-12:
+        roll = math.atan2(matrix[2][1], matrix[2][2])
+        pitch = math.atan2(-matrix[2][0], sy)
+        yaw = math.atan2(matrix[1][0], matrix[0][0])
+    else:
+        roll = math.atan2(-matrix[1][2], matrix[1][1])
+        pitch = math.atan2(-matrix[2][0], sy)
+        yaw = 0.0
+    def degrees(value):
+        value = (math.degrees(value) + 180) % 360 - 180
+        return round(0.0 if abs(value) < 5e-13 else value, 8)
+    return dict(zip('xyz', map(degrees, (roll, pitch, yaw))))
+
+
+def read_language(path):
+    commands = defaultdict(list)
+    if path is not None:
+        for line in path.read_text().splitlines():
+            if not line.strip():
+                continue
+            name, *items = line.split(', ')
+            raw = {key: float(value) for key, value in (item.split('=') for item in items)}
+            for key in raw:
+                if key == 'id' or key.endswith('_id'):
+                    raw[key] = int(raw[key])
+            commands[name].append(raw)
+    return commands
+
+
+def endpoint(wall, side):
+    return tuple(wall[f'{side}_{axis}'] for axis in 'xyz')
+
+
+def wall_groups(walls):
+    adjacency = defaultdict(list)
+    for index, wall in enumerate(walls):
+        a, b = endpoint(wall, 'a'), endpoint(wall, 'b')
+        adjacency[a].append((b, index))
+        adjacency[b].append((a, index))
+    remaining = set(adjacency)
+    groups = []
+    while remaining:
+        stack, vertices, edge_ids = [min(remaining)], set(), set()
+        while stack:
+            point = stack.pop()
+            if point in vertices:
+                continue
+            vertices.add(point)
+            for other, edge in adjacency[point]:
+                edge_ids.add(edge)
+                stack.append(other)
+        remaining -= vertices
+        group_walls = sorted((walls[i] for i in edge_ids), key=lambda w: w['id'])
+        # Same endpoint adjacency as SAGE10k. For an open chain, start at
+        # its endpoint and retain the terminal vertex (project adaptation).
+        ends = sorted(p for p in vertices if len(adjacency[p]) == 1)
+        chain_or_cycle = (len(ends) in (0, 2) and all(len(adjacency[p]) in (1, 2) for p in vertices))
+        ordered, used = [], set()
+        if chain_or_cycle:
+            point = ends[0] if ends else min(vertices)
+            while True:
+                ordered.append(point)
+                choices = sorted((i, q) for q, i in adjacency[point] if i not in used)
+                if not choices:
+                    break
+                edge, point = choices[0]
+                used.add(edge)
+                if point == ordered[0]:
+                    break
+        poly = [list(p[:2]) for p in ordered] if len(ordered) >= 3 and used == edge_ids else None
+        groups.append((group_walls, poly, bool(ends)))
+    return sorted(groups, key=lambda item: item[0][0]['id'])
+
+
+def load_gt(paths, export_root, observations=None):
+    objects, conflicts = {}, []
+    if not paths:
+        return objects, conflicts
+    import torch
+    # Only cached snippets, ordered by source sample/time/camera. Repeated
+    # static labels are deduplicated by native instance ID, without averaging.
+    for path in sorted(paths):
+        with source_members(path) as (name, read):
+            prefix = name[:-len('gt_data.json')]
+            metadata = json.loads(read(name))
+            gt = metadata['obb3_gt']
+            chosen = {tuple(pair) for pair in observations[str(path)]} if observations is not None else None
+            for camera in sorted(gt):
+                if chosen is not None and (camera,) not in chosen:
+                    continue
+                def load(space, key):
+                    return torch.load(io.BytesIO(read(f'{prefix}gt_data#{space}+{camera}+{key}.pth')),
+                                      map_location='cpu', weights_only=True).tolist()
+                spaces = {'obb3_gt': {key: load('obb3_gt', key) for key in GT_KEYS['obb3_gt']}}
+                try:
+                    spaces['obb2_gt'] = {key: load('obb2_gt', key) for key in GT_KEYS['obb2_gt']}
+                except KeyError:  # a frame the source left without 2D annotations
+                    spaces['obb2_gt'] = {}
+                fields = spaces['obb3_gt']
+                # obb2 lists its own detections; align them by native instance ID.
+                second = {sid: i for i, sid in enumerate(spaces['obb2_gt'].get('instance_ids', []))}
+                for i, instance_id in enumerate(fields['instance_ids']):
+                    raw = {key: [values[i]] for key, values in fields.items()}
+                    raw['category_names'] = [gt[camera]['category_names'][i]]
+                    j = second.get(instance_id)
+                    raw2 = {} if j is None else dict(
+                        {key: [values[j]] for key, values in spaces['obb2_gt'].items()},
+                        category_names=[metadata['obb2_gt'][camera]['category_names'][j]])
+                    value = {'pose': fields['ts_world_object'][i], 'dims': fields['object_dimensions'][i],
+                             'source_fields': {'source_file': Path(os.path.relpath(path, export_root)).as_posix(),
+                                               'obb3_gt': {camera: raw},
+                                               'obb2_gt': {camera: raw2} if raw2 else {}}}
+                    if instance_id in objects:
+                        if objects[instance_id]['pose'] != value['pose'] or objects[instance_id]['dims'] != value['dims']:
+                            conflicts.append({'instance_id': instance_id,
+                                              'selected_source': objects[instance_id]['source_fields'],
+                                              'conflicting_source': value['source_fields']})
+                    else:
+                        objects[instance_id] = value
+    return objects, conflicts
+
+
+def furniture_record(scene, instance_id, category, gt):
+    return {
+        'furniture_category': category,
+        'furniture_instance_id': f'{scene}::inst_{instance_id}',
+        'furniture_position': dict(zip('xyz', [row[3] for row in gt['pose']])) if gt else None,
+        'furniture_rotation': euler(gt['pose']) if gt else dict.fromkeys('xyz'),
+        'furniture_size': dict(zip(('width', 'length', 'height'), gt['dims'])) if gt else None,
+        'source_fields': gt['source_fields'] if gt else {},
+    }
+
+
+def opening(raw):
+    return {'position': {axis: raw[f'position_{axis}'] for axis in 'xyz'},
+            'width': raw['width'], 'height': raw['height']}
+
+
+def build_scene(scene_id, split, commands, classes, gt):
+    scene = f'ase_{split}_{scene_id:07d}'
+    rooms = []
+    for index, (walls, poly, open_chain) in enumerate(wall_groups(commands.get('make_wall', []))):
+        ids = {w['id'] for w in walls}
+        door_raw = [w for w in commands.get('make_door', []) if ids & {w['wall0_id'], w['wall1_id']}]
+        window_raw = [w for w in commands.get('make_window', []) if ids & {w['wall0_id'], w['wall1_id']}]
+        heights = {w.get('height') for w in walls}
+        room = {
+            'room_id': f'{scene}::room_{index}', 'room_index': index,
+            'room_type': None, 'room_type_source': 'unavailable',
+            'room_boundary': poly, 'room_boundary_type': 'wall_polygon' if poly else None,
+            'room_area_m2': polygon_area(poly) if poly else None,
+            'room_height': next(iter(heights)) if len(heights) == 1 else None,
+            'coordinate_system': COORDINATES,
+            'doors': list(map(opening, door_raw)), 'windows': list(map(opening, window_raw)),
+            'furniture_quantity': 0, 'furniture': [],
+            'source_fields': {'make_wall': walls, 'make_door': door_raw, 'make_window': window_raw},
+        }
+        rooms.append(room)
+    unassigned, structural = [], []
+    room_ids = defaultdict(list)
+    for instance_id in sorted({int(k) for k in classes} | set(gt)):
+        category = classes.get(str(instance_id))  # single category source for the published field
+        entry = gt.get(instance_id)
+        item = furniture_record(scene, instance_id, category, entry)
+        # Recognise structure through either vocabulary: where the classes file
+        # is absent the ATEK label is the only evidence this is not furniture.
+        name = category or atek_name(entry)
+        if name in STRUCTURAL:
+            structural.append(item)
+            continue
+        pos = item['furniture_position']
+        matches = [i for i, room in enumerate(rooms) if pos and room['room_boundary']
+                   and point_in_polygon(pos['x'], pos['y'], room['room_boundary'])]
+        if len(matches) == 1:
+            rooms[matches[0]]['furniture'].append(item)
+            category_id = atek_category_id(entry)
+            if category_id is not None:
+                room_ids[matches[0]].append(category_id)
+        else:
+            unassigned.append(item)
+    for index, room in enumerate(rooms):
+        kind = infer_room_type(room_ids[index], room['room_boundary']) if room['furniture'] else None
+        room['room_type'] = kind
+        room['room_type_source'] = 'inferred_from_furniture' if kind else 'unavailable'
+        room['furniture_quantity'] = len(room['furniture'])
+    areas = [r['room_area_m2'] for r in rooms if r['room_area_m2'] is not None]
+    result = {
+        'scene_id': scene, 'sample_id': scene, 'dataset': 'ASE',
+        'source_dataset': 'aria_synthetic_environments', 'source_subset': split,
+        'room_count': len(rooms), 'total_area': sum(areas) if areas else None,
+        'building_style': None, 'description': None, 'description_source': None,
+        'provenance': {'source_file': f'{split}_chunk_{scene_id // 10:07d}.zip',
+                       'source_scene_index': scene_id, 'split': split}, 'rooms': rooms,
+    }
+    # Companion source inventory, NOT additional keys in the fixed scene schema.
+    retained = {'scene_id': scene, 'unassigned_objects': unassigned, 'structural_instances': structural,
+                'source_fields': {'object_instances_to_classes': classes, **dict(commands)}}
+    return result, retained
+
+
+def convert(data_dir, out_dir, limit=None):
+    _, rows = load_selection(data_dir, limit)
+    counts = {'scenes': 0, 'dropped_scenes': 0, 'rooms': 0, 'assigned_objects': 0,
+              'unassigned_records': 0, 'structural_records': 0, 'conflicting_gt_observations': 0}
+    with JsonWriter(out_dir / 'ase.jsonl', lines=True) as scenes, \
+            JsonWriter(out_dir / 'source_inventory.json') as inventory:
+        for row in rows:
+            language = data_dir / row['language_file'] if row['language_file'] else None
+            classes = json.loads((data_dir / row['classes_file']).read_text(encoding='utf-8')) if row['classes_file'] else {}
+            observations = ({str(data_dir / name): pairs for name, pairs in row['gt_observations'].items()}
+                            if 'gt_observations' in row else None)
+            gt, conflicts = load_gt([data_dir / name for name in row['gt_files']], out_dir, observations)
+            scene, retained = build_scene(row['scene_index'], row['split'], read_language(language), classes, gt)
+            scene['provenance']['source_file'] = row['source_file']
+            assert set(scene) == set(SCENE_KEYS)
+            for room in scene['rooms']:
+                assert set(room) == set(ROOM_KEYS)
+                for item in room['furniture']:
+                    assert set(item) == set(FURNITURE_KEYS)
+            # A scene whose every room is empty carries no furniture supervision.
+            if not any(room['furniture'] for room in scene['rooms']):
+                counts['dropped_scenes'] += 1
+                continue
+            scenes.write(scene)
+            inventory.write(retained)
+            counts['scenes'] += 1
+            counts['rooms'] += len(scene['rooms'])
+            counts['assigned_objects'] += sum(r['furniture_quantity'] for r in scene['rooms'])
+            counts['unassigned_records'] += len(retained['unassigned_objects'])
+            counts['structural_records'] += len(retained['structural_instances'])
+            counts['conflicting_gt_observations'] += len(conflicts)
+            if counts['scenes'] % 1000 == 0:
+                print(json.dumps(counts), flush=True)
+    return counts
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--data-dir', type=Path, default=Path(__file__).resolve().parents[1] / 'data')
+    parser.add_argument('--out-dir', type=Path, default=Path(__file__).resolve().parents[1])
+    scope = parser.add_mutually_exclusive_group(required=True)
+    scope.add_argument('--limit', type=int)
+    scope.add_argument('--all', action='store_true')
+    args = parser.parse_args()
+    if args.limit is not None and args.limit < 1:
+        parser.error('--limit must be positive')
+    print(json.dumps(convert(args.data_dir, args.out_dir, args.limit)))
+
+
+if __name__ == '__main__':
+    main()

ASE_exported/kits/download_ase.py

@@ -0,0 +1,369 @@
+"""Download ASE scene annotations and selected GT members into data/."""
+from __future__ import annotations
+import argparse
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import hashlib
+import io
+import json
+import os
+from pathlib import Path
+import re
+import tarfile
+import time
+import zipfile
+import requests
+from urllib3.exceptions import HTTPError as ResponseReadError
+
+class RangeFile(io.RawIOBase):
+    """A seekable remote file: never accept a server's whole-file response."""
+    def __init__(self, url, size=None, block_size=16384):
+        self.block_size, self.start, self.buffer = block_size, 0, b''
+        self.url, self.size, self.pos, self.received = url, size, 0, 0
+        self.session = requests.Session()
+        if size is None:
+            self.fetch(0, 1)
+
+    def fetch(self, start, size):
+        return with_retries(self._fetch_once, start, size)
+
+    def _fetch_once(self, start, size):
+        end = start + size - 1
+        try:
+            with self.session.get(self.url, headers={
+                    'Range': f'bytes={start}-{end}', 'Accept-Encoding': 'identity'},
+                    timeout=30, stream=True) as response:
+                match = re.fullmatch(r'bytes (\d+)-(\d+)/(\d+)', response.headers.get('Content-Range', ''))
+                if response.status_code >= 400:
+                    raise RuntimeError(f'Range request failed: HTTP {response.status_code}')
+                if response.status_code != 206 or not match or tuple(map(int, match.group(1, 2))) != (start, end):
+                    raise ValueError('Server did not return the requested byte range')
+                total = int(match.group(3))
+                if self.size is not None and self.size != total:
+                    raise ValueError('Remote size disagrees with manifest or previous response')
+                self.size = total
+                if response.headers.get('Content-Encoding', 'identity') != 'identity':
+                    raise ValueError('Unexpected content encoding')
+                blob = response.raw.read(size + 1)
+                self.received += len(blob)
+                # A short read is a transport failure, not a broken contract:
+                # raise it as RuntimeError so with_retries() retries the range
+                # instead of losing the whole chunk to one truncated response.
+                if len(blob) != size:
+                    raise RuntimeError('Range request failed: truncated range response')
+        except requests.RequestException:
+            raise RuntimeError('Range request failed: network connection error') from None
+        return blob
+
+    def close(self):
+        self.session.close()
+        super().close()
+
+    def readable(self):
+        return True
+
+    def seekable(self):
+        return True
+
+    def tell(self):
+        return self.pos
+
+    def seek(self, offset, whence=0):
+        self.pos = offset if whence == 0 else self.pos + offset if whence == 1 else self.size + offset
+        if self.pos < 0:
+            raise ValueError('Negative seek')
+        return self.pos
+
+    def read(self, size=-1):
+        size = min(self.size - self.pos, self.size - self.pos if size < 0 else size)
+        if size <= 0:
+            return b''
+        if self.pos == 0 and size == self.size:
+            raise ValueError('Whole-file read refused')
+        if self.start <= self.pos and self.pos + size <= self.start + len(self.buffer):
+            offset = self.pos - self.start
+            result = self.buffer[offset:offset + size]
+        else:
+            amount = min(self.size - self.pos, max(size, self.block_size))
+            if self.pos == 0 and amount == self.size:
+                amount = size
+            self.start = self.pos
+            self.buffer = self.fetch(self.pos, amount)
+            result = self.buffer[:size]
+        self.pos += size
+        return result
+
+
+def save_member(out, relative, blob, files):
+    path = out / relative
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = path.with_suffix(path.suffix + '.part')
+    tmp.write_bytes(blob)
+    tmp.replace(path)
+    files[relative] = {'bytes': len(blob), 'sha256': hashlib.sha256(blob).hexdigest()}
+    return relative
+
+
+GT_NAMESPACES = ('obb3_gt', 'obb2_gt')
+GT_KEYS = {'obb3_gt': ('instance_ids', 'category_ids', 'object_dimensions', 'ts_world_object'),
+           'obb2_gt': ('instance_ids', 'category_ids', 'box_ranges', 'visibility_ratios')}
+
+
+def wanted_gt(name):
+    name = Path(name).name
+    return name.endswith('.gt_data.json') or (
+        any(f'.gt_data#{space}+' in name for space in GT_NAMESPACES) and name.endswith('.pth'))
+
+
+def new_row(split, sid, source_file, listed):
+    return {'split': split, 'scene_index': sid, 'source_file': source_file,
+            'language_file': None, 'classes_file': None, 'gt_files': [],
+            'atek_listed': listed}
+
+
+def write_json(path, value):
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = path.with_suffix(path.suffix + '.part')
+    text = json.dumps(value, ensure_ascii=False, indent=2, allow_nan=False) + '\n'
+    tmp.write_text(text, encoding='utf-8')
+    os.replace(tmp, path)
+
+
+def positive_int(value):
+    value = int(value)
+    if value < 1:
+        raise ValueError('Expected a positive integer')
+    return value
+
+
+def add_scope_arguments(parser):
+    group = parser.add_mutually_exclusive_group(required=True)
+    group.add_argument('--limit', type=positive_int, help='Process at most N indexed scenes')
+    group.add_argument('--all', action='store_true', help='All indexed scenes; requires user authorization')
+
+
+def read_manifests(args):
+    originals = json.loads(args.original_manifest.read_text(encoding='utf-8'))
+    metadata = json.loads(args.atek_manifest.read_text(encoding='utf-8'))
+    config = metadata['atek_data_for_all_configs']['cubercnn']
+    if (metadata['raw_dataset_name'], metadata['raw_dataset_release_version'], config['atek_wds_version']) != ('AriaSyntheticEnvironment', '1.0', 'v0.1.1'):
+        raise ValueError('Expected ASE release 1.0 / cubercnn WDS v0.1.1')
+    return originals, config['wds_file_urls']
+
+
+def with_retries(function, *args):
+    for attempt in range(3):
+        try:
+            return function(*args)
+        except (RuntimeError, OSError, EOFError, zipfile.BadZipFile, ResponseReadError):
+            if attempt == 2:
+                raise
+            time.sleep(attempt + 1)
+
+
+def select_originals(args, originals):
+    entries = sorted(originals, key=lambda r: r['filename'])
+    if args.split != 'both':
+        entries = [r for r in entries if r['filename'].startswith(args.split + '_chunk_')]
+    if args.scene_ids is not None:
+        chunks = {sid // 10 for sid in args.scene_ids}
+        entries = [r for r in entries if int(Path(r['filename']).stem.rsplit('_', 1)[1]) in chunks]
+    elif args.limit is not None:
+        entries = entries[:max(1, (args.limit + 9) // 10)]
+    return entries
+
+
+def probe_sample(offsets, read, selected, read_many=None):
+    """Read IDs first; retain raw members only where a new ID needs geometry.
+
+    A cubercnn sample is a single frame, so its gt_data.json nests camera only.
+    Retention still follows the source order: sample key, then camera.
+    """
+    import torch
+    if read_many is None:
+        read_many = lambda names: [read(name) for name in names]
+    blobs, observations, probed = {}, {}, 0
+    for name in sorted(n for n in offsets if n.endswith('.gt_data.json')):
+        metadata = read(name)
+        records = json.loads(metadata)['obb3_gt']
+        prefix = name[:-len('gt_data.json')]
+        rows = [(camera, f'{prefix}gt_data#obb3_gt+{camera}+') for camera in sorted(records)]
+        ids_blobs = read_many([stem + 'instance_ids.pth' for _, stem in rows])
+        needed = []
+        for (camera, stem), ids_blob in zip(rows, ids_blobs):
+            ids = torch.load(io.BytesIO(ids_blob), map_location='cpu', weights_only=True).tolist()
+            probed += 1
+            if not set(ids) - selected:
+                continue
+            blobs[name] = metadata
+            blobs[stem + 'instance_ids.pth'] = ids_blob
+            needed.extend(stem + key + '.pth'
+                          for key in ('ts_world_object', 'object_dimensions', 'category_ids'))
+            # The 2D annotations ride along in the same sample; keep them unmapped.
+            # A frame without them must not abort a full run, so take what is there.
+            needed.extend(f'{prefix}gt_data#obb2_gt+{camera}+{key}.pth'
+                          for key in GT_KEYS['obb2_gt'])
+            observations.setdefault(name, []).append([camera])
+            selected.update(ids)
+        needed = [member for member in needed if member in offsets]
+        blobs.update(zip(needed, read_many(needed)))
+    return blobs, observations, probed
+
+
+def file_digest(path):
+    digest = hashlib.sha256()
+    with path.open('rb') as handle:
+        for block in iter(lambda: handle.read(1024 * 1024), b''):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def original_chunk(out_dir, entry, listed_scenes, scene_ids=None, limit=None):
+    files, rows = {}, []
+    split = entry['filename'].split('_chunk_')[0]
+    with RangeFile(entry['cdn']) as remote, zipfile.ZipFile(remote) as archive:
+        members = set(archive.namelist())
+        ids = sorted({int(name.split('/')[0]) for name in members
+                      if name.split('/')[0].isdigit()})
+        if scene_ids is not None:
+            ids = [sid for sid in ids if sid in scene_ids]
+        if limit is not None:
+            ids = ids[:limit]
+        for sid in ids:
+            row = new_row(split, sid, entry['filename'], split == 'train' and str(sid) in listed_scenes)
+            for key, filename in [('language_file', 'ase_scene_language.txt'),
+                                  ('classes_file', 'object_instances_to_classes.json')]:
+                member = f'{sid}/{filename}'
+                if member in members:
+                    relative = f'original/{split}/{sid}/{filename}'
+                    row[key] = save_member(out_dir, relative, archive.read(member), files)
+            rows.append(row)
+    return rows, files
+
+
+def fetch_originals(args, originals, listed_scenes):
+    entries = select_originals(args, originals)
+    rows, files = [], {}
+    if args.limit is not None:
+        # Limit before writing source files, including a partial final ZIP.
+        for entry in entries:
+            chunk_rows, chunk_files = with_retries(
+                original_chunk, args.out_dir, entry, listed_scenes, args.scene_ids,
+                args.limit - len(rows))
+            rows.extend(chunk_rows)
+            files.update(chunk_files)
+            if len(rows) == args.limit:
+                break
+    else:
+        with ThreadPoolExecutor(max_workers=args.workers) as pool:
+            futures = [pool.submit(with_retries, original_chunk, args.out_dir,
+                                   entry, listed_scenes, args.scene_ids) for entry in entries]
+            for completed, future in enumerate(as_completed(futures), 1):
+                chunk_rows, chunk_files = future.result()
+                rows.extend(chunk_rows)
+                files.update(chunk_files)
+                if completed % 25 == 0 or completed == len(entries):
+                    print(f'Original ZIPs: {completed}/{len(entries)}', flush=True)
+    rows.sort(key=lambda row: (row['split'], row['scene_index']))
+    return rows, files
+
+
+def fetch_shard(session, entry):
+    """cubercnn shards are ~8 MiB, so one GET beats thousands of header probes."""
+    expected = int(entry['file_size_bytes'])
+    def once():
+        response = session.get(entry['download_url'], headers={'Accept-Encoding': 'identity'},
+                               timeout=180)
+        if response.status_code != 200:
+            raise RuntimeError(f'Shard request failed: HTTP {response.status_code}')
+        if len(response.content) != expected:
+            raise ValueError('Shard length disagrees with the manifest')
+        return response.content
+    return with_retries(once)
+
+
+def shard_samples(archive):
+    """Group a shard's GT members by sample, in tar order, mirroring tar_gt_offsets."""
+    groups, order = {}, []
+    for member in archive.getmembers():
+        if not member.isfile():
+            continue
+        name = Path(member.name).name
+        sample = name.split('.', 1)[0]
+        if sample not in groups:
+            groups[sample] = {}
+            order.append(sample)
+        if wanted_gt(name):
+            groups[sample][name] = member.name
+    return [(sample, groups[sample]) for sample in order if groups[sample]]
+
+
+def gt_scene(out_dir, sid, shards):
+    relative = f'atek/cubercnn/train/{sid}/annotations.tar.gz'
+    target = out_dir / relative
+    target.parent.mkdir(parents=True, exist_ok=True)
+    temporary = target.with_suffix(target.suffix + '.part')
+    selected, observations = set(), {}
+    session = requests.Session()
+    try:
+        # Write selected members directly into the scene's single source archive.
+        with tarfile.open(temporary, 'w:gz') as output:
+            for shard, entry in sorted(shards.items()):
+                with tarfile.open(fileobj=io.BytesIO(fetch_shard(session, entry))) as source:
+                    for sample, paths in shard_samples(source):
+                        def read(name, _s=source, _p=paths):
+                            return _s.extractfile(_p[name]).read()
+                        blobs, chosen, _ = probe_sample(paths, read, selected)
+                        for name, payload in blobs.items():
+                            member = tarfile.TarInfo(shard + '/' + name)
+                            member.size = len(payload)
+                            output.addfile(member, io.BytesIO(payload))
+                        observations.update({relative + '::' + shard + '/' + name: pairs
+                                             for name, pairs in chosen.items()})
+        temporary.replace(target)
+    finally:
+        session.close()
+        temporary.unlink(missing_ok=True)
+    return {'gt_files': sorted(observations), 'gt_observations': observations,
+            'gt_probe_complete': True}, {
+                relative: {'bytes': target.stat().st_size, 'sha256': file_digest(target)}}
+
+
+def download(args):
+    index_path = args.out_dir / 'index.json'
+    # An interrupted rerun must not leave an old index certifying new partial files.
+    index_path.unlink(missing_ok=True)
+    originals, listed_scenes = read_manifests(args)
+    rows, files = fetch_originals(args, originals, listed_scenes)
+    gt_rows = [row for row in rows if row['atek_listed']]
+    with ThreadPoolExecutor(max_workers=args.workers) as pool:
+        futures = {pool.submit(gt_scene, args.out_dir, row['scene_index'],
+                               listed_scenes[str(row['scene_index'])]): row for row in gt_rows}
+        for completed, future in enumerate(as_completed(futures), 1):
+            fields, gt_files = future.result()
+            futures[future].update(fields)
+            files.update(gt_files)
+            print(f'GT scenes: {completed}/{len(gt_rows)}', flush=True)
+    scope = ('all original ASE scenes' if args.all and args.split == 'both'
+             and args.scene_ids is None else 'selected source scenes')
+    index = {'scope': scope, 'atek_config': 'cubercnn', 'raw_release': '1.0',
+             'wds_version': 'v0.1.1', 'scenes': rows, 'files': files}
+    write_json(index_path, index)
+    print(json.dumps({'scenes': len(rows), 'gt_scenes': len(gt_rows),
+                      'source_files': len(files), 'output': str(args.out_dir)}), flush=True)
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--original-manifest', type=Path, required=True)
+    parser.add_argument('--atek-manifest', type=Path, required=True)
+    parser.add_argument('--out-dir', type=Path, default=Path(__file__).resolve().parents[1] / 'data')
+    parser.add_argument('--workers', type=positive_int, default=8)
+    parser.add_argument('--split', choices=('both', 'train', 'test'), default='both')
+    parser.add_argument('--scene-ids', type=lambda text: [int(value) for value in text.split(',')])
+    add_scope_arguments(parser)
+    download(parser.parse_args())
+
+
+if __name__ == '__main__':
+    main()

ASE_exported/kits/unify_ase.py

@@ -0,0 +1,56 @@
+"""Write complete-scene, all-room and multi-scene-room JSON array views.
+
+File roles follow pinned Structured3D unify_structured3d.py. Room objects retain
+scene-global coordinates and their IDs/indices, as in 3D-FRONT's view projection.
+"""
+from __future__ import annotations
+import argparse
+import json
+from pathlib import Path
+from convert_ase import JsonWriter
+
+
+def room_scene(scene, room):
+    result = dict(scene)
+    result.update(scene_id=room['room_id'], sample_id=room['room_id'],
+                  room_count=1, total_area=room['room_area_m2'], rooms=[room])
+    return result
+
+
+def unify(jsonl, out_dir, limit=None):
+    with jsonl.open(encoding='utf-8') as source, \
+            JsonWriter(out_dir / 'multiroom/json_multi_merged.json') as merged, \
+            JsonWriter(out_dir / 'json_room.json') as rooms, \
+            JsonWriter(out_dir / 'multiroom/json_multi_split.json') as split:
+        for line in source:
+            if limit is not None and merged.count >= limit:
+                break
+            if not line.strip():
+                continue
+            scene = json.loads(line)
+            merged.write(scene)  # Includes zero-room and single-room scenes.
+            for room in scene['rooms']:
+                item = room_scene(scene, room)
+                rooms.write(item)
+                if scene['room_count'] > 1:
+                    split.write(item)
+    return {'merged_scenes': merged.count, 'room_records': rooms.count,
+            'multi_split_records': split.count}
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    base = Path(__file__).resolve().parents[1]
+    parser.add_argument('--jsonl', type=Path, default=base / 'ase.jsonl')
+    parser.add_argument('--out-dir', type=Path, default=base)
+    scope = parser.add_mutually_exclusive_group(required=True)
+    scope.add_argument('--limit', type=int)
+    scope.add_argument('--all', action='store_true')
+    args = parser.parse_args()
+    if args.limit is not None and args.limit < 1:
+        parser.error('--limit must be positive')
+    print(json.dumps(unify(args.jsonl, args.out_dir, args.limit)))
+
+
+if __name__ == '__main__':
+    main()

ASE_exported/kits/verify_ase.py

@@ -0,0 +1,278 @@
+"""Check ASE artifacts against selected inputs without importing the converter.
+
+Checks the fixed keys, source geometry, lossless ID retention and JSON views.
+Missing source values and open wall chains are not scene-rejection conditions.
+"""
+from __future__ import annotations
+import argparse
+from collections import Counter
+from contextlib import contextmanager
+import hashlib
+import json
+import io
+import math
+import tarfile
+import zipfile
+from itertools import zip_longest
+from pathlib import Path
+
+def load_selection(data_dir, limit):
+    index = json.loads((Path(data_dir) / 'index.json').read_text(encoding='utf-8'))
+    rows = sorted(index['scenes'], key=lambda r: (r['split'], r['scene_index']))
+    identities = [(r['split'], r['scene_index']) for r in rows]
+    if len(identities) != len(set(identities)):
+        raise ValueError('Duplicate split/scene identities in input index')
+    # Enumerate the index, not language/GT files: absent annotations retain scenes.
+    return index, rows[:limit] if limit is not None else rows
+
+
+def read_jsonl(path):
+    with Path(path).open(encoding='utf-8') as handle:
+        for line in handle:
+            if line.strip():
+                yield json.loads(line)
+
+
+@contextmanager
+def source_members(reference):
+    """Read original members from loose files or archive::member references."""
+    filename, separator, member = str(reference).partition('::')
+    if separator and filename.endswith('.tar.gz'):
+        with tarfile.open(filename, 'r:gz') as archive:
+            folder = Path(member).parent.as_posix()
+            def read(name):
+                target = name if folder == '.' else folder + '/' + name
+                return archive.extractfile(target).read()
+            yield Path(member).name, read
+    elif separator:
+        with zipfile.ZipFile(filename) as archive:
+            folder = Path(member).parent.as_posix()
+            def read(name):
+                target = name if folder == '.' else folder + '/' + name
+                return archive.read(target)
+            yield Path(member).name, read
+    else:
+        path = Path(filename)
+        yield path.name, lambda name: (path.parent / name).read_bytes()
+
+
+def source_key(reference):
+    filename, separator, member = str(reference).partition('::')
+    return str(Path(filename).resolve()), member if separator else None
+
+
+SCENE_KEYS = set('scene_id sample_id dataset source_dataset source_subset room_count total_area building_style description description_source provenance rooms'.split())
+ROOM_KEYS = set('room_id room_index room_type room_type_source room_boundary room_boundary_type room_area_m2 room_height coordinate_system doors windows furniture_quantity furniture source_fields'.split())
+FURNITURE_KEYS = set('furniture_category furniture_instance_id furniture_position furniture_rotation furniture_size source_fields'.split())
+STRUCTURAL = {'wall', 'floor', 'ceiling', 'door', 'window'}
+ROOM_TYPES = {'bedroom', 'studio', 'apartment', 'living room', None}
+GT_KEYS = {'obb3_gt': ('instance_ids', 'category_ids', 'object_dimensions', 'ts_world_object'),
+           'obb2_gt': ('instance_ids', 'category_ids', 'box_ranges', 'visibility_ratios')}
+
+
+def source_gt(paths, observations=None):
+    """Independently select the first raw source row by sample/time/camera."""
+    selected = {}
+    if not paths:
+        return selected
+    import torch
+    for path in sorted(paths):
+        with source_members(path) as (name, read):
+            document = json.loads(read(name))
+            prefix = name[:-len('gt_data.json')]
+            chosen = {tuple(pair) for pair in observations[str(path)]} if observations is not None else None
+            for camera, record in sorted(document['obb3_gt'].items()):
+                if chosen is not None and (camera,) not in chosen:
+                    continue
+                def load(space, key):
+                    return torch.load(io.BytesIO(read(f'{prefix}gt_data#{space}+{camera}+{key}.pth')),
+                                      map_location='cpu', weights_only=True).tolist()
+                spaces = {'obb3_gt': {key: load('obb3_gt', key) for key in GT_KEYS['obb3_gt']}}
+                try:
+                    spaces['obb2_gt'] = {key: load('obb2_gt', key) for key in GT_KEYS['obb2_gt']}
+                except KeyError:  # a frame the source left without 2D annotations
+                    spaces['obb2_gt'] = {}
+                values = dict(spaces['obb3_gt'], category_names=record['category_names'])
+                flat = (dict(spaces['obb2_gt'],
+                             category_names=document['obb2_gt'][camera]['category_names'])
+                        if spaces['obb2_gt'] else {})
+                second = {sid: i for i, sid in enumerate(flat.get('instance_ids', []))}
+                for offset, sid in enumerate(values['instance_ids']):
+                    j = second.get(sid)
+                    pair = {} if j is None else {key: [value[j]] for key, value in flat.items()}
+                    selected.setdefault(sid, (path, camera,
+                                              {key: [value[offset]] for key, value in values.items()},
+                                              pair))
+    return selected
+
+
+def joint_name(item, classes, gt, scene_id):
+    """Category under either vocabulary; ATEK names the instances a scene
+    missing object_instances_to_classes.json leaves unnamed."""
+    instance_id = int(item['furniture_instance_id'][len(scene_id + '::inst_'):])
+    category = classes.get(str(instance_id))
+    if category:
+        return category
+    entry = gt.get(instance_id)
+    return entry[2]['category_names'][0] if entry else None
+
+
+def verify_item(item, classes, gt, scene_id, out_dir):
+    assert set(item) == FURNITURE_KEYS
+    prefix = scene_id + '::inst_'
+    assert item['furniture_instance_id'].startswith(prefix)
+    instance_id = int(item['furniture_instance_id'][len(prefix):])
+    assert item['furniture_category'] == classes.get(str(instance_id))
+    if instance_id not in gt:
+        assert item['furniture_position'] is None and item['furniture_size'] is None
+        assert item['furniture_rotation'] == {'x': None, 'y': None, 'z': None}
+        assert item['source_fields'] == {}
+        return instance_id, 0.0
+    path, camera, raw, raw2 = gt[instance_id]
+    sf = item['source_fields']
+    assert set(sf) == {'source_file', 'obb3_gt', 'obb2_gt'}
+    assert source_key(out_dir / sf['source_file']) == source_key(path)
+    assert sf['obb3_gt'] == {camera: raw}
+    assert sf['obb2_gt'] == ({camera: raw2} if raw2 else {})
+    matrix, dims = raw['ts_world_object'][0], raw['object_dimensions'][0]
+    assert item['furniture_position'] == dict(zip('xyz', [row[3] for row in matrix]))
+    assert item['furniture_size'] == dict(zip(('width', 'length', 'height'), dims))
+    angles = [item['furniture_rotation'][axis] for axis in 'xyz']
+    assert all(-180 <= angle < 180 for angle in angles)
+    x, y, z = map(math.radians, angles)
+    cx, cy, cz, sx, sy, sz = math.cos(x), math.cos(y), math.cos(z), math.sin(x), math.sin(y), math.sin(z)
+    rebuilt = [[cz*cy, cz*sy*sx-sz*cx, cz*sy*cx+sz*sx],
+               [sz*cy, sz*sy*sx+cz*cx, sz*sy*cx-cz*sx], [-sy, cy*sx, cy*cx]]
+    error = max(abs(rebuilt[i][j] - matrix[i][j]) for i in range(3) for j in range(3))
+    assert error < 1e-6, (item['furniture_instance_id'], error)
+    return instance_id, error
+
+
+def array_records(path):
+    """Our writer stores one complete JSON object on each array line."""
+    with path.open(encoding='utf-8') as handle:
+        assert next(handle).strip() == '['
+        for line in handle:
+            text = line.strip()
+            if text == ']':
+                assert not handle.read().strip()
+                return
+            if text:
+                yield json.loads(text[:-1] if text.endswith(',') else text)
+    raise ValueError(f'Incomplete JSON array: {path}')
+
+
+def verify(data_dir, out_dir, limit):
+    index, selected = load_selection(data_dir, limit)
+    merged = array_records(out_dir / 'multiroom/json_multi_merged.json')
+    singles = array_records(out_dir / 'json_room.json')
+    split = array_records(out_dir / 'multiroom/json_multi_split.json')
+    inventories = array_records(out_dir / 'source_inventory.json')
+    for name, meta in index['files'].items():
+        path = data_dir / name
+        digest = hashlib.sha256()
+        with path.open('rb') as handle:
+            for blob in iter(lambda: handle.read(1024 * 1024), b''):
+                digest.update(blob)
+        assert path.stat().st_size == meta['bytes'] and digest.hexdigest() == meta['sha256'], name
+    totals = Counter(scenes=0, room_records=0, multi_split_records=0)
+    max_error = 0.0
+    rows = iter(selected)
+    for scene, inventory, intermediate in zip_longest(merged, inventories, read_jsonl(out_dir / 'ase.jsonl')):
+        assert all(value is not None for value in (scene, inventory, intermediate))
+        assert scene == intermediate
+        # Scenes without any furnished room are dropped, so walk the index
+        # forward to the retained one and account for everything skipped.
+        for row in rows:
+            expected_id = f"ase_{row['split']}_{row['scene_index']:07d}"
+            if scene['scene_id'] == expected_id:
+                break
+            totals['dropped_scenes'] += 1
+            # No geometry means no instance could ever land inside a room.
+            if row['gt_files']:
+                totals['dropped_scenes_with_geometry'] += 1
+        else:
+            raise AssertionError(f"{scene['scene_id']} is not in the input index")
+        assert scene['scene_id'] == inventory['scene_id'] == expected_id
+        assert any(room['furniture'] for room in scene['rooms']), scene['scene_id']
+        totals['scenes'] += 1
+        assert set(scene) == SCENE_KEYS
+        assert scene['dataset'] == 'ASE' and scene['source_dataset'] == 'aria_synthetic_environments'
+        assert scene['sample_id'] == scene['scene_id'] and scene['source_subset'] == row['split']
+        assert scene['provenance'] == {'source_file': row['source_file'], 'source_scene_index': row['scene_index'], 'split': row['split']}
+        assert all(scene[key] is None for key in ('building_style', 'description', 'description_source'))
+        assert scene['room_count'] == len(scene['rooms'])
+        areas = [r['room_area_m2'] for r in scene['rooms'] if r['room_area_m2'] is not None]
+        assert scene['total_area'] == (sum(areas) if areas else None)
+        classes = json.loads((data_dir / row['classes_file']).read_text(encoding='utf-8')) if row['classes_file'] else {}
+        assert inventory['source_fields']['object_instances_to_classes'] == classes
+        observations = ({str(data_dir / name): pairs for name, pairs in row['gt_observations'].items()}
+                        if 'gt_observations' in row else None)
+        gt = source_gt([data_dir / name for name in row['gt_files']], observations)
+        seen = []
+        for i, room in enumerate(scene['rooms']):
+            totals['room_records'] += 1
+            totals['room_type_null'] += room['room_type'] is None
+            totals['rooms_without_assigned_furniture'] += not room['furniture']
+            assert set(room) == ROOM_KEYS
+            assert room['room_id'] == f"{scene['scene_id']}::room_{i}" and room['room_index'] == i
+            assert room['furniture_quantity'] == len(room['furniture'])
+            # Furniture without a sleeping or seating anchor leaves no type.
+            assert room['room_type'] in ROOM_TYPES, room['room_id']
+            assert room['furniture'] or room['room_type'] is None, room['room_id']
+            assert room['room_type_source'] == ('inferred_from_furniture' if room['room_type'] else 'unavailable')
+            assert room['room_boundary_type'] == ('wall_polygon' if room['room_boundary'] else None)
+            for item in room['furniture']:
+                assert joint_name(item, classes, gt, scene['scene_id']) not in STRUCTURAL
+                assert item['furniture_position'] is not None
+                sid, error = verify_item(item, classes, gt, scene['scene_id'], out_dir)
+                seen.append(sid)
+                max_error = max(max_error, error)
+                totals['assigned_objects'] += 1
+            single = dict(scene)
+            single.update(scene_id=room['room_id'], sample_id=room['room_id'], rooms=[room], room_count=1, total_area=room['room_area_m2'])
+            assert next(singles) == single
+            if scene['room_count'] > 1:
+                assert next(split) == single
+                totals['multi_split_records'] += 1
+        for bucket in ('unassigned_objects', 'structural_instances'):
+            totals[bucket] += len(inventory[bucket])
+            for item in inventory[bucket]:
+                assert (joint_name(item, classes, gt, scene['scene_id']) in STRUCTURAL) == (bucket == 'structural_instances')
+                sid, error = verify_item(item, classes, gt, scene['scene_id'], out_dir)
+                seen.append(sid)
+                max_error = max(max_error, error)
+        assert len(seen) == len(set(seen)), scene['scene_id']
+        assert set(seen) == {int(k) for k in classes} | set(gt), scene['scene_id']
+        totals['retained_source_ids'] += len(seen)
+        totals['gt_instances'] += len(gt)
+    assert next(singles, None) is None and next(split, None) is None
+    for row in rows:  # scenes dropped after the last retained one
+        totals['dropped_scenes'] += 1
+        if row['gt_files']:
+            totals['dropped_scenes_with_geometry'] += 1
+    assert totals['scenes'] + totals['dropped_scenes'] == len(selected)
+    return {'passed': True, **dict(totals), 'max_rotation_reconstruction_error': max_error,
+            'input_file_hashes_match': True, 'every_retained_scene_is_furnished': True,
+            'all_source_ids_retained_once': True, 'views_preserve_room_objects': True,
+            'scope': index['scope'],
+            'gt_probe_complete_scenes': sum(r.get('gt_probe_complete', False) for r in selected)}
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    base = Path(__file__).resolve().parents[1]
+    parser.add_argument('--data-dir', type=Path, default=base / 'data')
+    parser.add_argument('--out-dir', type=Path, default=base)
+    scope = parser.add_mutually_exclusive_group(required=True)
+    scope.add_argument('--limit', type=int)
+    scope.add_argument('--all', action='store_true')
+    args = parser.parse_args()
+    if args.limit is not None and args.limit < 1:
+        parser.error('--limit must be positive')
+    result = verify(args.data_dir, args.out_dir, args.limit)
+    print(json.dumps(result))
+
+
+if __name__ == '__main__':
+    main()