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