README.md

metadata

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

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, 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:

@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}
}