Blame for README.md

---
pretty_name: RoSE - Robotic Spatial Environment
task_categories:
  - other
tags:
  - slam
  - 3d-reconstruction
  - indoor-scenes
  - depth
  - arcore
---

# RoSE: Robotic Spatial Environment

Indoor room scans captured with phones/tablets, plus 3D reconstructions, SLAM
point clouds and room layouts generated from them. Each top-level folder is one
room.

## Layout

```
<RoomID>/
  ScanVideos/             raw scan captures (input to every pipeline)
  EmbodiedVideos/         raw embodied videos (mp4)
  <Output>_<Input>/       processed data, see naming below
```

Room IDs (`Bedroom1`, `I12X`, `I64`, `I87X`, `P63`, `P64`) are room names. Treat them as
unique IDs. Not every room has every folder.

| Room     | Contents |
|----------|----------|
| Bedroom1 | ScanVideos, EmbodiedVideos (4), MasterSlam1_ScanVideo1, Spatiallm1_MasterSlam1, NeuCon1, Metascenes1_Spatiallm1_MasterSlam1 |
| I12X     | ScanVideos (`Video1_T3`, `Video2_T3`), EmbodiedVideos (2), RTABMAP1, RTABMAP2, MasterSlam1_ScanVideo1, MasterSlam2_ScanVideo1, MasterSlam3_ScanVideo2, MasterSlam4_ScanVideo2, Spatiallm1_MasterSlam1, Spatiallm2_MasterSlam2, Spatiallm3_MasterSlam3, Spatiallm4_MasterSlam4, Metascenes1_Spatiallm1_MasterSlam1, Metascenes2_Spatiallm2_MasterSlam2, Metascenes3_Spatiallm3_MasterSlam3, Metascenes4_Spatiallm4_MasterSlam4, Spatiallm5_RTABMAP1, Spatiallm6_RTABMAP2, Metascenes5_Spatiallm5_RTABMAP1, Metascenes6_Spatiallm6_RTABMAP2 |
| I64      | ScanVideos (`Video1_T3`), EmbodiedVideos (1), RTABMAP1, RTABMAP2, RTABMAP3, Spatiallm1_RTABMAP1, Metascenes1_Spatiallm1_RTABMAP1 |
| I87X     | ScanVideos (`Video1.MOV`, `Video2_T3`), MasterSlam1_ScanVideo2, MasterSlam2_ScanVideo2, Spatiallm1_MasterSlam1, Spatiallm2_MasterSlam2, Metascenes1_Spatiallm1_MasterSlam1, Metascenes2_Spatiallm2_MasterSlam2 |
| P63      | ScanVideos (`StrayScanner1`), MasterSlam1_StrayScanner1, Spatiallm1_MasterSlam1, Metascenes1_Spatiallm1_MasterSlam1 |
| P64      | ScanVideos (`Video1.MOV`), RTABMAP1, MasterSlam1_ScanVideo1, Spatiallm1_MasterSlam1, Metascenes1_Spatiallm1_MasterSlam1, Spatiallm2_RTABMAP1, Metascenes2_Spatiallm2_RTABMAP1 |

## Naming system

Folders that are generated from other data are named **`<Output>_<Input>`**:
the part before `_` is the tool that produced the folder (plus a run index),
the part after is the data it took as input. Read it as "Output takes input
from Input".

- `MasterSlam1_ScanVideo1`: MASt3R-SLAM run 1, fed with scan video 1
  (`ScanVideos/Video1.*` in the same room).
- `MasterSlam2_ScanVideo2`: MASt3R-SLAM run 2, fed with scan capture 2
  (`ScanVideos/Video2_T3` in I87X).
- `MasterSlam1_StrayScanner1`: MASt3R-SLAM run 1, fed with the Stray Scanner
  capture `ScanVideos/StrayScanner1`.
- `Spatiallm1_MasterSlam1`: SpatialLM run 1, fed with the output of
  `MasterSlam1_*` in the same room (`Spatiallm2_MasterSlam2`: fed with `MasterSlam2_*`).
- `Spatiallm5_RTABMAP1`: SpatialLM run 5 of that room, fed with `RTABMAP1/cloud.ply` in the same room.
  The run number counts every SpatialLM run in the room, whatever its input, so a room never has two
  folders with the same `SpatiallmN` (the same holds for `MasterSlamN` and `MetascenesN`). Later runs get the next number.

- `Metascenes2_Spatiallm2_MasterSlam2`: MetaScenes-style run 2, fed with the folder
  `Spatiallm2_MasterSlam2` in the same room. Here the input part is a full folder name, since
  one room can have several `Spatiallm*_*` folders.

Raw captures have no input, so they use plain names:

- `VideoN.<ext>`: video number N from that room, recorded with a phone/tablet
  camera app.
- `VideoN_T3`: capture number N recorded with the **T3** app. Here `_T3` names
  the app that wrote the data folder.
- `StrayScanner1`: capture 1 recorded with the Stray Scanner app.
- `NeuCon1`, `RTABMAP1`: tool output, run 1.

A trailing number is a run/capture index within the room.

## Tools

### Capture

| Tool | What | Output |
|------|------|--------|
| T3 | Custom-made ARCore Android app that records raw ARCore data. Run on a Samsung SM-S928B (Galaxy S24 Ultra). | `Video*_T3` |
| Stray Scanner | iOS app, RGB + LiDAR depth + odometry. | `StrayScanner1` |
| Phone/tablet camera apps | Plain video. Devices include Galaxy S24 Ultra, iPad Pro (11-inch, 2nd gen; P64), iPhone 14 Pro Max and a Samsung A-series phone. Per-file device is **TBD**, see Notes. | `ScanVideos/Video*.mp4/.MOV`, `EmbodiedVideos/*.mp4` |

### Processing / generation

| Tool | Used for | Output |
|------|----------|--------|
| [MASt3R-SLAM](https://github.com/rmurai0610/MASt3R-SLAM) | Dense SLAM point cloud and camera trajectory from video (Colab or a GPU server; uncalibrated unless noted in Run notes) | `MasterSlam*_*` |
| `room_plane_fit.py` (own script, in the folder) | Cleans the point cloud, aligns to gravity, fits wall planes, makes mesh, colliders and walls (Unity-ready) | `MasterSlam1_ScanVideo1/room_plane_fit_out/` |
| `ply2obj.py` (own script) | Converts `scan.ply` to a textured mesh (`--mesh`: Poisson + baked texture) | `scan_mesh.obj/.mtl/.png` |
| [SpatialLM](https://github.com/manycore-research/SpatialLM), run with the fork [lehoangan02/SpatialLM](https://github.com/lehoangan02/SpatialLM) (`stage3/pipeline.py`, commit `a10e67a`; `.glb` files re-exported with `7021237`) | Room layout (walls, objects) from a point cloud | `Spatiallm1_*/room.glb`, `room_with_scan.glb` |
| MetaScenes-style asset replacement (own scripts in `P64/Metascenes1_Spatiallm1_MasterSlam1/`), adapted from [MetaScenes](https://github.com/meta-scenes/MetaScenes) | Replaces each SpatialLM box with an Objaverse asset, then runs MetaScenes' physics step | `Metascenes1_*/` |
| NeuCon | Mesh reconstruction (trimesh export) | `Bedroom1/NeuCon1/neucon.ply` |
| RTAB-Map (`.db` recorded on the phone/tablet app, exported with `rtabmap-export`) | RGB-D mapping, textured mesh and RGB point cloud | `RTABMAP*/` |

## File reference

### `VideoN_T3/` (T3 app, raw ARCore)

| File | Content |
|------|---------|
| `rgb/` | RGB frames (JPEG; raw NV21 `.yuv` in `I12X/.../Video2_T3` and `I87X/.../Video2_T3`) |
| `session.mp4` | Video of the session |
| `depth/`, `depth_raw/`, `conf/` | ARCore depth, raw depth and confidence frames |
| `points/` | ARCore feature points per frame (`.bin`) |
| `cubemap/` | ARCore environmental-light cubemaps (`.bin`) |
| `poses.jsonl` | Per-frame camera pose (`p` position, `q` quaternion), tracking state |
| `planes.jsonl` | Detected planes |
| `light.jsonl` | Light estimation |
| `imu.csv` | IMU samples |
| `intrinsics.json`, `device_info.json`, `meta.json` | Camera intrinsics, device and sensors, session info (fps, frames, duration) |

### `StrayScanner1/` (Stray Scanner)

`rgb.mp4`, `depth/` (PNG), `confidence/`, `odometry.csv`, `camera_matrix.csv`, `imu.csv`.

### `MasterSlam1_*/` (MASt3R-SLAM)

| File | Content |
|------|---------|
| `scan.ply` | Reconstructed point cloud |
| `scan.txt` | Trajectory, one line per keyframe: `timestamp x y z qx qy qz qw` |
| `keyframes/` | Keyframe images |
| `run.log` | Run config and log |
| `config.yaml` | MASt3R-SLAM config used (runs made on the GPU server) |
| `calib_arcore.yaml` | Camera intrinsics passed with `--calib` (calibrated runs only) |
| `scan_mesh.*` | Textured mesh from `ply2obj.py scan.ply scan_mesh.obj --mesh`; `scan_mesh.log` is the tool output |

`MasterSlam1_ScanVideo1` also holds the scripts and outputs described above
(`room_plane_fit.py`, `ply2obj.py`, `requirements.txt`, `room_plane_fit_out/`,
`scan_mesh.*`).

### `RTABMAP*/` (RTAB-Map)

| File | Content |
|------|---------|
| `<name>.obj/.mtl/.jpg` | Textured mesh exported from the RTAB-Map app (`<name>` = recording timestamp `yymmdd-HHMMSS`) |
| `cloud.ply` | xyz + RGB point cloud, assembled from the depth images and optimized poses of the same `.db` |
| `export_clouds.py` | Script that makes the `.ply` from `.db` files (kept in `I12X/RTABMAP1/`) |

Producing the `.ply`: `python3 export_clouds.py <dir with .db files>` needs `rtabmap-export` on PATH and
`open3d`. It runs `rtabmap-export --cloud` (writes `<db>_cloud.ply` with normals), then drops normals
and curvature so viewers show the real colours, giving `<db>_rgb.ply`; that file is what is stored here,
renamed to `cloud.ply` (the `<name>` of its `.db` is the same as the mesh in that folder). The `.db` files themselves are not in the dataset (they are large); a trailing
`_1` on a db name is not part of `<name>`. Mapping: `P64/RTABMAP1` = `261104-120353`, `I64/RTABMAP1` =
`261105-111119`, `I12X/RTABMAP1` = `261106-090437`, `I12X/RTABMAP2` = `261106-091133`.
`I64/RTABMAP2` and `RTABMAP3` have no `.ply` yet (no `.db` available).

### `Spatiallm1_*/`

`room.glb` is the predicted layout. `room_with_scan.glb` is the layout together
with the input scan (300k scan points as a glTF point cloud; Apple Preview / Quick Look
cannot show point clouds and draw them as spikes). `room_with_scan_preview.glb` is the same
scene for Preview / Quick Look: each scan point is a 1.5 cm coloured tetrahedron (~34 MB). Each `Spatiallm*_*` folder also has
`layout.txt` (SpatialLM text format, metres, z up, floor at z=0), `seeds.png`
(top-down view of each seed), `summary.json` (settings, chosen seed, scores) and
`pipeline.log`.

### `Metascenes1_*/`

SpatialLM boxes replaced by Objaverse assets. Pipeline:

1. Crop the scan points inside each SpatialLM box.
2. Take 16 Objaverse-LVIS candidates of the matching category.
3. Rank them by ULIP-2 point-cloud embedding similarity to the crop (the backbone MetaScenes' Scan2Sim is
   trained from; the Scan2Sim checkpoint itself is gated) plus geometric fit.
4. Place the best one with MetaScenes' fixed-pose rule.
5. Run MetaScenes' MCMC overlap reduction and Blender rigid-body settling.

| File | Content |
|------|---------|
| `scene_fixed.glb` | `room.glb` of the input folder + assets at their fixed pose (before physics) |
| `scene_physics.glb` | Same after MCMC + physics |
| `views.png` | Top and front views of both, over the scan |
| `objects/*.glb` | Each placed asset, layout frame (z up, metres) |
| `placements.json` | Per box: label, chosen Objaverse uid, scores, 4x4 transform |
| `candidates.json` | All candidates per box with similarity, fit (chamfer, m), IoU, score |
| `physics.json`, `physics.log` | Per-object movement from MCMC and simulation |
| `assets_license.json` | Name, author, licence and Sketchfab link of each asset, for attribution |
| `retrieval.log` | Retrieval output |

## Run notes

- `P64/MasterSlam1_ScanVideo1`: MASt3R-SLAM `config/base.yaml`. Tracking was lost at frame 307
  (~10 s of 64 s, fast blurred pan onto a white wall) and never recovered, so the cloud covers only
  part of the room (30 keyframes). A looser config tracked the whole video but gave a twisted room,
  so it was not kept.
- `I87X/MasterSlam1_ScanVideo2`: `base.yaml`, uncalibrated. `I87X/MasterSlam2_ScanVideo2`: `base.yaml`
  with the ARCore intrinsics from `Video2_T3/intrinsics.json` (`--calib`). Input: the 1870 NV21
  frames converted to PNG (1920x1080). Against the ARCore poses (Sim3-aligned), both have ~15 cm
  ATE; the calibrated run has about half the rotation error between keyframes (0.60 vs 1.16 deg).
- `I12X/MasterSlam1..4`: `base.yaml`. Runs 1 and 3 are uncalibrated; runs 2 and 4 use the ARCore intrinsics
  (`--calib calib_arcore.yaml`). Runs 1-2 take `Video1_T3` (1915 JPEG frames), runs 3-4 take `Video2_T3` (1694 NV21
  frames converted to PNG); both are 1920x1080. Against the ARCore poses (Sim3-aligned, `compare_t3.py`):

  | Run | Input | Intrinsics | Keyframes | ATE rmse (max) | Rotation error between keyframes, mean (max) | Relocalizations |
  |-----|-------|------------|-----------|----------------|-----------------------------------------------|-----------------|
  | MasterSlam1_ScanVideo1 | Video1_T3 | no | 125 | 23.7 cm (52.5) | 1.35 deg (4.01) | 1 |
  | MasterSlam2_ScanVideo1 | Video1_T3 | ARCore | 122 | 21.4 cm (42.1) | 0.80 deg (3.76) | 0 |
  | MasterSlam3_ScanVideo2 | Video2_T3 | no | 114 | 47.9 cm (333.3) | 1.96 deg (25.78) | 48 |
  | MasterSlam4_ScanVideo2 | Video2_T3 | ARCore | 137 | 14.1 cm (28.7) | 1.11 deg (5.14) | 0 |

  `MasterSlam3_ScanVideo2` lost tracking many times and has misplaced keyframes. Prefer `MasterSlam4_ScanVideo2`.
  The scripts used for these runs (`t3_frames.py`: T3 frames to PNG plus calib file; `compare_t3.py`: comparison
  against ARCore) are in `I12X/MasterSlam1_ScanVideo1`.
- All `Spatiallm*_*` folders: fork `stage3/pipeline.py` (commit `a10e67a`; `.glb` re-exported with `7021237`, which closes wall gaps under 20 cm), Llama-1B, seeds 0 1 2, default
  2.6 m ceiling height (sets the scale). Non-default options, recorded in `summary.json`:
  - `P64/Spatiallm1_MasterSlam1`: `--up_hint=-y`. With `--up_hint auto` the wrong axis was taken
    as up (0.085 raw height, scale x30). Only seed 0 found walls.
  - `I87X/Spatiallm2_MasterSlam2`: `--no_crop`. On the cropped cloud every seed looped on one
    zero-length wall and the export failed.
  - `I87X/Spatiallm1_MasterSlam1`: defaults. 11 of its 15 windows are exact repeats at one spot.
  - `P63/Spatiallm1_MasterSlam1`: defaults. 31 of its 43 boxes are `plants` (SpatialLM repeating).
  - `Bedroom1/Spatiallm1_MasterSlam1`: defaults.
  - `I12X/Spatiallm1_MasterSlam1` to `Spatiallm4_MasterSlam4`: defaults, run directly with commit `7021237`. Each covers the scanned
    part of the room as one rectangle (4 walls), except `Spatiallm3_MasterSlam3` (8 walls, 11 boxes), whose
    input `MasterSlam3_ScanVideo2` has misplaced keyframes, so its extra walls are not reliable.
- `I12X/MasterSlam1..4`: `scan_mesh.*` made with `ply2obj.py scan.ply scan_mesh.obj --mesh` (default options).


- `Metascenes*_*` (all rooms): ULIP-2 `PointBERT-10k-xyzrgb-vit_g` as ranker, 16 candidates, seed 0,
  50 MCMC steps, 250 simulation frames, Blender 4.3 (`bpy`). Hanging objects (curtain, chandelier,
  painting) and carpets stay fixed. SpatialLM boxes often overlap (chairs inside table boxes), so the
  MCMC step can push objects away from where the scan has them; compare `scene_fixed.glb`.
  Asset licences (Objaverse annotation): 61 by, 3 by-sa.
  - `Bedroom1/Metascenes1_Spatiallm1_MasterSlam1`: 8 SpatialLM boxes, 8 after de-duplication (3 curtain, pillow, 2 computer, 2 chair); largest move in physics 1.03 m.
  - `P63/Metascenes1_Spatiallm1_MasterSlam1`: 43 SpatialLM boxes, 32 after de-duplication (painting, 5 curtain, 20 plants, sofa, chandelier, clothes_rack, 2 chair, carpet); largest move in physics 1.53 m.
  - `P64/Metascenes1_Spatiallm1_MasterSlam1`: 8 SpatialLM boxes, 8 after de-duplication (sideboard, 3 chair, side_table, coffee_table, chandelier, washing_cabinet); largest move in physics 0.64 m.
  - `I87X/Metascenes1_Spatiallm1_MasterSlam1`: 3 SpatialLM boxes, 3 after de-duplication (3 curtain); largest move in physics 0.00 m.
  - `I87X/Metascenes2_Spatiallm2_MasterSlam2`: 1 SpatialLM box, 1 after de-duplication (curtain); largest move in physics 0.00 m.
  - `I12X/Metascenes1_Spatiallm1_MasterSlam1`: 3 SpatialLM boxes, 3 after de-duplication (2 curtain, chandelier); largest move in physics 0.00 m.
  - `I12X/Metascenes2_Spatiallm2_MasterSlam2`: 1 SpatialLM box, 1 after de-duplication (curtain); largest move in physics 0.00 m.
  - `I12X/Metascenes3_Spatiallm3_MasterSlam3`: 11 SpatialLM boxes, 11 after de-duplication (7 curtain, painting, 3 chandelier); largest move in physics 0.00 m.
  - `I12X/Metascenes4_Spatiallm4_MasterSlam4`: 3 SpatialLM boxes, 3 after de-duplication (3 chandelier); largest move in physics 0.00 m.

## Notes

- Which device recorded which video is still being confirmed (TBD).
- Meaning of "EmbodiedVideos" and the NeuCon input are not yet documented (TBD).
- License and citation: TBD.