---
license: other
license_name: structured3d-research-only
task_categories:
- depth-estimation
- image-to-3d
tags:
- 3d
- depth
- posed-rgbd
- indoor-scenes
- synthetic
- structured3d
pretty_name: Structured3D Subset (3DVLM)
size_categories:
- 1K<n<10K
---

# Structured3D Subset (3DVLM)

A small, fast-to-download slice of the Structured3D synthetic indoor dataset,
converted to a uniform posed-RGB-D format for quick model test-runs. This is a
**subset**: **100 scenes** (randomly sampled, seed 0) from collection `00`, using
the pre-rendered **`full`** (furnished) perspective views. Across the 100 scenes
there are **2,198 frames** (3–49 per scene).

These are photorealistic synthetic renders with **perfect dense ground-truth
depth** and exact camera poses — no reconstruction or pseudo-labelling involved.

This subset is part of a family of uniformly-formatted posed-RGB-D test-run
datasets: see also `3dvlm-replica_subset`, `3dvlm-hm3d_subset`, and
`3dvlm-taskonomy_subset` (same on-disk layout and conventions).

## Contents

100 scenes, one `.tar` each under `structured3d/`. Each tar extracts to a scene
directory:

```
scene_00000/
├── images/            # frame_000000.jpg … (N RGB frames, 720×1280)
├── depth.npy          # (N, 720, 1280) float32
├── valid_mask.npy     # (N, 720, 1280) bool   — True where depth is valid
├── extrinsics.npy     # (N, 4, 4)       float32 — world→camera (w2c)
├── intrinsics.npy     # (N, 3, 3)       float32 — pinhole K (per-frame)
└── meta.json          # scene_id, frame_ids, image_size, is_single_image
```

`N` varies per scene (3–49 frames). The first axis of every array is the frame,
in the same order as `meta.json`'s `frame_ids` and the sorted `images/` files.

> **Note — independent captures.** Each frame is a separate perspective view at a
> distinct room/camera position, **not** a video trajectory. `meta.json` sets
> `is_single_image: true`; do **not** assume cross-frame overlap or temporal
> continuity within a scene.

## Conventions

- **Coordinate frame:** OpenCV (x-right, y-down, z-forward). `extrinsics` is the
  **world→camera (w2c)** matrix; invert it for camera→world. The translation is in
  **metres** (the source millimetre world is rescaled on conversion).
- **Depth:** projective **z-depth in metres** (distance along the camera z-axis,
  not Euclidean ray length). Decoded from the source 16-bit millimetre depth
  (`÷1000`); the source is already planar z-buffer depth, so **no Euclidean→z
  cosine correction is applied**. Invalid pixels (source value `0`) are zeroed —
  use `valid_mask` to ignore them. Typical valid coverage is **≈99.5%**, with
  depths in roughly the **0.05–7 m** range.
- **Intrinsics:** **per-frame** pinhole `K`, reconstructed from each frame's
  horizontal/vertical field of view (separate `fx`/`fy`, principal point centred).
  Image size is 720×1280 (H×W). The reconstructed `(K, w2c)` are verified to
  round-trip through the project's ray-map (DA3) convention.

## Source & provenance

Built from the official **Structured3D perspective `full`** renders, collection
`00` (`Structured3D_perspective_full_00.zip`). Only three files per frame are used:
`rgb_rawlight.png` (the RGB modality in the full-perspective zip is
`rgb_rawlight.png`, **not** `rgb.png`), `depth.png`, and `camera_pose.txt`. Camera
poses come straight from `camera_pose.txt` (eye / view-dir / up / half-FOVs), built
into a right-handed look-at and converted to OpenCV `w2c`. No depth model or
pseudo-labelling is involved — depth and poses are the renderer's exact values.

There is no separate "full" mirror of this conversion; this 100-scene slice of
collection `00` is the published extent.

## Quick start

```python
import tarfile, json, numpy as np
from huggingface_hub import hf_hub_download

p = hf_hub_download("helioom/3dvlm-structured3d_subset", "structured3d/scene_00000.tar", repo_type="dataset")
tarfile.open(p).extractall("structured3d/")

meta  = json.load(open("structured3d/scene_00000/meta.json"))
depth = np.load("structured3d/scene_00000/depth.npy")        # (N, 720, 1280)
mask  = np.load("structured3d/scene_00000/valid_mask.npy")   # (N, 720, 1280)
K     = np.load("structured3d/scene_00000/intrinsics.npy")   # (N, 3, 3)
w2c   = np.load("structured3d/scene_00000/extrinsics.npy")    # (N, 4, 4)

# Back-project frame 0 to a camera-frame point cloud (metres):
H, W = meta["image_size"]
fx, fy, cx, cy = K[0,0,0], K[0,1,1], K[0,0,2], K[0,1,2]
ys, xs = np.mgrid[0:H, 0:W]
z = depth[0]
X = (xs - cx) / fx * z
Y = (ys - cy) / fy * z
pts = np.stack([X, Y, z], -1)[mask[0]]   # (M, 3) valid points
```

## License & citation

Built on [Structured3D](https://github.com/bertjiazheng/Structured3D), released for
**research use only** under its original data agreement; the same terms apply to
this derived subset. If you use this data, please cite the original paper:

```bibtex
@inproceedings{Structured3D,
  title     = {Structured3D: A Large Photo-realistic Dataset for Structured 3D Modeling},
  author    = {Zheng, Jia and Zhang, Junfei and Li, Jing and Tang, Rui and Gao, Shenghua and Zhou, Zihan},
  booktitle = {Proceedings of The European Conference on Computer Vision (ECCV)},
  year      = {2020}
}
```