Add dataset card: contents, conventions, provenance, DA3 round-trip, citation

README.md

@@ -0,0 +1,125 @@
+---
+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}
+}
+```