README.md

metadata

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

Taskonomy Subset (3DVLM)

A small, fast-to-download slice of the Taskonomy real indoor-scan dataset, converted to a uniform posed-RGB-D format for quick model test-runs. This is a subset: 25 buildings (seeded pick, seed 0, from the Omnidata tiny split) × 100 frames each = 2,500 frames.

These are real photographs of scanned buildings with sensor-grade 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-structured3d_subset (same on-disk layout and conventions).

Contents

25 buildings, one .tar each under taskonomy/. Each tar extracts to a building directory:

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

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. Taskonomy is single-image: each frame is a separate (point, view) photograph at a distinct camera position, not a video trajectory. meta.json sets is_single_image: true; do not assume cross-frame overlap or temporal continuity within a building.

Conventions

• Coordinate frame: OpenCV (x-right, y-down, z-forward). extrinsics is the world→camera (w2c) matrix; invert it for camera→world. Poses are converted from the source Blender frame (Z-up world, OpenGL-style camera) via a Blender→OpenCV camera-axis flip before inversion.
• Depth: projective z-depth in metres (distance along the camera z-axis, not Euclidean ray length). Decoded from the source 16-bit depth_zbuffer (÷512); the source is already planar z-buffer depth, so no Euclidean→z cosine correction is applied. Invalid pixels (source sentinel 65535, e.g. sky/missing geometry) are zeroed — use valid_mask to ignore them. Typical valid coverage is ≈98%, with depths in roughly the 0.4–14 m range.
• Intrinsics: per-frame pinhole K, reconstructed from each frame's field of view on a square image (fx=fy, principal point centred). Image size is 512×512.

Source & provenance

Built from the public EPFL Taskonomy mirror (https://datasets.epfl.ch/taskonomy/{building}_{domain}.tar, no authentication). Buildings are drawn from the Omnidata tiny split (forbidden buildings removed); seed 0 selects 25 of them. Only three modalities per frame are used: rgb, depth_zbuffer, and point_info (camera FOV + Blender pose). Each building keeps the first 100 frames in source-tar order. Depth and poses are Taskonomy's own ground-truth values — no depth model or pseudo-labelling is involved (is_pseudo: false). The reconstructed (K, w2c) are verified to round-trip through the project's ray-map (DA3) convention.

There is no separate "full" mirror of this conversion; this 25-building slice 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-taskonomy_subset", "taskonomy/hanson.tar", repo_type="dataset")
tarfile.open(p).extractall("taskonomy/")

meta  = json.load(open("taskonomy/hanson/meta.json"))
depth = np.load("taskonomy/hanson/depth.npy")        # (100, 512, 512)
mask  = np.load("taskonomy/hanson/valid_mask.npy")   # (100, 512, 512)
K     = np.load("taskonomy/hanson/intrinsics.npy")   # (100, 3, 3)
w2c   = np.load("taskonomy/hanson/extrinsics.npy")    # (100, 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 Taskonomy, released for research use only under the Stanford Taskonomy license (redistribution of derived subsets permitted for research); the same terms apply to this derived subset. If you use this data, please cite the original paper:

@inproceedings{zamir2018taskonomy,
  title     = {Taskonomy: Disentangling Task Transfer Learning},
  author    = {Zamir, Amir R. and Sax, Alexander and Shen, William B. and Guibas, Leonidas J. and Malik, Jitendra and Savarese, Silvio},
  booktitle = {Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR)},
  year      = {2018}
}