Datasets:

helioom
/

3dvlm-taskonomy_subset

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

```python
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](http://taskonomy.stanford.edu/), 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:

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