This dataset contains derived renderings of three third-party scene datasets (HM3D, Replica, HSSD). Their original licences still bind you as a downstream user: HM3D follows the Matterport / habitat-matterport-3d-dataset academic terms, Replica is restricted to non-commercial research and education, and HSSD follows the HSSD-200 terms.

By requesting access you confirm that you will use this data for non-commercial research or education only, that you will obtain and comply with the upstream licence for whichever subset you use, and that you will not redistribute the scene renderings.

PanoQA — Panoramic Sequence + Spatial QA Dataset

Five-frame panoramic walks rendered in habitat-sim, each with RGB / depth / instance-ID equirectangular panoramas, camera poses, a fused point cloud, an object manifest, and English spatial-reasoning question–answer pairs grounded in the geometry.

Every QA answer is computed from the actual 3D data (distances, bearings, visibility), not written by a language model. An LLM is used only to (a) rephrase the question wording and (b) score each pair; the facts in the answers come from the geometry.

1. What is in it

Source	Scenes	Sequences	QA pairs	Notes
HM3D	148	5,482	136,516	real-world building scans
Replica	18	1,375	71,452	high-fidelity indoor scans
HSSD	161	23,494	(generating)	synthetic furnished homes

A sequence is one 5-frame walk: the agent takes 4 steps of 0.3–1.0 m, facing the direction of travel, and renders a full 360°×180° panorama at every step. The last frame (index 4) is the query frame — all poses and all QA are expressed relative to it.

Currently uploaded: HM3D and Replica (6,857 sequences, 34,285 panoramas, 207,968 QA pairs). HSSD QA generation is still running and will be added in a later revision.

2. Download and extract

The repository keeps one folder per source, so you can take only what you need:

hm3d/      hm3d-0000.tar.gz    ...   (5,482 sequences)
replica/   replica-0000.tar.gz ...   (1,375 sequences)
hssd/      (coming once QA generation finishes)
manifest.jsonl
README.md

pip install huggingface_hub

# just Replica (~35 GB) — good for a first look
hf download faceR-as/PanoQA-30K --repo-type dataset \
    --include "replica/*" --local-dir ./PanoQA

# or everything (~175 GB compressed)
hf download faceR-as/PanoQA-30K --repo-type dataset --local-dir ./PanoQA

# extract — every shard restores paths of the form <source>/<scene>/<index>/...
mkdir -p data
for f in PanoQA/*/*.tar.gz; do tar xzf "$f" -C ./data; done

After extraction the three sources sit side by side and never mix:

data/
├── hm3d/00006-HkseAnWCgqk/000/...
├── replica/apartment_0/000/...
└── hssd/102817200/000/...

Shards hold ~200 sequences each. manifest.jsonl lists, for every shard, exactly which sequences are inside — use it to fetch only the scenes you need.

3. Directory layout

<source>/<scene_id>/<sequence_idx>/
├── rgb/{0..4}.png              1024×512 equirectangular RGB
├── depth/{0..4}.npy            float32, metres, 0 = invalid
├── id/{0..4}.npy               uint16 instance IDs, 0 = background/unlabelled
├── pose/pose.json              per-frame pose, relative to the query frame
├── pointcloud/fused.ply        all 5 frames fused into the query frame
├── objects/
│   ├── manifest.json           per-instance geometry + category
│   └── token_instance_map.npy  (5, 24, 48) uint16 — instance ID per ViT patch
└── qa/qa.json                  question–answer pairs

Frame index i is the same across rgb/, depth/, id/ and pose/, so the four modalities are aligned by filename — no lookup table needed.

4. Coordinate system — read this before doing geometry

All 3D quantities use one target frame, anchored at the query frame (frame 4):

+X = left        +Y = up        +Z = forward
origin = the camera of the query frame

The query frame's own pose is exactly position = (0,0,0), yaw = 0.
Earlier frames carry their position in the query frame's coordinates; a negative Z therefore means "behind where you ended up", which is the normal case for a forward walk.
Bearings use theta = atan2(x, z) — the same convention as the panorama's horizontal axis, so "to your left" in text matches the left side of the image.
phi = asin(y / distance) is elevation.

Panorama pixel (u, v) maps to a ray by

theta = (0.5 - (u + 0.5) / W) * 2 * np.pi     # +X(left) at theta = +pi/2
phi   = (0.5 - (v + 0.5) / H) * np.pi         # +Y(up)  at phi  = +pi/2
ray   = np.stack([np.cos(phi) * np.sin(theta),
                  np.sin(phi),
                  np.cos(phi) * np.cos(theta)], -1)
xyz   = ray * depth[..., None]                # metres, in the frame's own camera frame

Verified on this release: for every sequence, re-deriving the poses from the raw simulator state reproduces pose.json to ~1e-16, pairwise frame distances are preserved to <1e-7 m (rigid-transform check), and the floor plane sits within 0.3–2.8° of perpendicular to +Y.

5. File formats

`pose/pose.json`

{
  "query_frame": 4,
  "frames": [
    {"frame": 0, "is_query_frame": false,
     "position_xyz": [-0.024, 0.0, -0.874], "yaw_rad": 0.856},
    ...
    {"frame": 4, "is_query_frame": true,
     "position_xyz": [0.0, 0.0, 0.0], "yaw_rad": 0.0}
  ]
}

yaw_rad is that frame's heading expressed in the query frame, using the same atan2(x, z) convention.

`objects/manifest.json`

{"query_frame": 4, "n_instances": 58,
 "instances": [
   {"instance_id": 30, "category": "chair",
    "centroid_xyz": [...], "bbox_min": [...], "bbox_max": [...], "size_xyz": [...],
    "distance_m": 2.06, "theta_rad": -0.41, "phi_rad": -0.18,
    "visible_frames": [2, 3, 4], "visible_in_query": true, "occluded_in_query": false,
    "token_count_per_frame": {"0": 0, "1": 0, "2": 7, "3": 22, "4": 39},
    "point_count": 15321}
 ]}

instance_id indexes directly into id/{i}.npy. Instances are sorted by distance. token_count_per_frame says how many of the 24×48 ViT patches that instance occupies — useful if you want to drop targets that are too small for a model to actually perceive.

`objects/token_instance_map.npy`

(5, 24, 48) uint16 — the majority instance ID inside each 14×14 patch after resizing the panorama to 336×672. Flatten with .reshape(5, -1) to line up with a ViT patch sequence.

`qa/qa.json`

{"n_kept": 53, "n_dropped": 1,
 "kept": [
   {"q": "Which is closer to you, the chair or the kitchen counter?",
    "a": "Chair, 1.5 meters.",
    "level": "ALLROUND", "difficulty": "medium",
    "targets": ["chair", "kitchen counter"],
    "gt": {"expected_direction": "...", "closest_distance_m": 1.5},
    "scores": {"correctness": 5, "fluency": 5, "actionability": 5},
    "scene": "00009-vLpv2VX547B", "local_idx": "001",
    "images": ["rgb/0.png", "...", "rgb/4.png"], "query_frame": 4}
 ]}

Use kept. dropped holds pairs the judge scored below threshold — kept only for transparency. gt carries the machine-computed facts the judge was asked to check the answer against.

6. Question types

15 types, deliberately balanced (each 3–9% of the total) rather than left to whatever the templates happened to produce most of:

Type	Asks about
`N2`	what lies in a given direction
`O2O` / `E2O` / `ALLROUND`	object↔object and ego↔object relations, distances
`COUNT`	how many instances of a category are visible
`EXISTENCE` / `EXISTENCE_EVER`	presence now / at any point in the walk (includes true negatives)
`TEMPORAL_LOC` / `DISCOVERY` / `ORDER`	when something was first/last seen, what is new, which came first
`MOTION`	translation and turning relative to an earlier point in the walk
`SIZE_COMPARE`	relative object size
`NAVIGATE`	where a target is and whether the path to it is clear
`REANCHOR`	perspective taking — "if you were sitting on X, where would Y be"
`OPENNESS`	which side is more open to walk through

Difficulty is split roughly 35% easy / 30% medium / 35% hard by reasoning hops.

Temporal references are natural language ("a little while ago", "right at the start of this walk"), not frame numbers — the intended consumer reasons over fused space, not a per-frame log.

Judge scores on the released pairs: correctness 4.98, fluency 5.00, actionability 5.00 (1–5 scale, two Qwen3 models: one rewrites the question, a different one scores).

7. Minimal loading example

import json, numpy as np, imageio.v3 as iio

seq = "data/hm3d/00009-vLpv2VX547B/001"

rgb   = iio.imread(f"{seq}/rgb/4.png")          # (512, 1024, 3) uint8
depth = np.load(f"{seq}/depth/4.npy")           # (512, 1024) float32, metres
ids   = np.load(f"{seq}/id/4.npy")              # (512, 1024) uint16
pose  = json.load(open(f"{seq}/pose/pose.json"))
objs  = json.load(open(f"{seq}/objects/manifest.json"))
qa    = json.load(open(f"{seq}/qa/qa.json"))["kept"]

# where is the nearest chair, and is it visible right now?
chair = next(o for o in objs["instances"] if o["category"] == "chair")
print(chair["distance_m"], np.degrees(chair["theta_rad"]), chair["visible_in_query"])

# its pixels in the query frame
mask = ids == chair["instance_id"]

8. How it was built

Sample a 5-waypoint path on the scene navmesh, facing the direction of travel.
Render 6 cube faces (RGB + depth + semantic) per waypoint, convert to equirectangular.
Reject any frame with >3% invalid depth pixels, a connected hole >5% of the image, or an implausible median depth — a whole sequence is dropped if any of its frames fails.
Fuse the 5 frames into the query frame; build the per-instance manifest and patch-level ID map.
Generate QA facts deterministically from the manifest, then rewrite the wording and score each pair with local LLMs; keep only pairs above the score threshold.

Starting points within a scene are chosen far from already-used ones, so sequences from the same scene cover different rooms instead of clustering.

9. Licensing — important

This release contains derived renderings of three third-party scene datasets. The original terms still apply to you as a downstream user, and they differ per source:

HM3D — Matterport / habitat-matterport-3d-dataset terms, academic use.
Replica — Replica Dataset research licence (non-commercial research and education).
HSSD — HSSD-200 terms.

You must obtain and comply with the upstream licences for whichever subset you use. The QA text, manifests, pose files and the packaging in this repository are released for research use under the same spirit; they are not usable independently of the scene licences above.

10. Known characteristics

No wall / floor / ceiling instances in the HSSD split. Those surfaces belong to the stage mesh, which carries no per-object label — unlike HM3D and Replica, where they are labelled instances.
unknown categories exist (~21% of HSSD instances, far fewer elsewhere) where the upstream dataset has no usable class name. QA generation already skips them as answer targets.
Replica renders are flat-shaded (shader_type: flat, no lights), so they look lower-contrast than HM3D. That is how the upstream dataset ships; geometry and labels are unaffected.
Some panoramas contain small genuinely-empty regions where the original scan has holes; they are bounded by the 3% invalid-pixel acceptance rule.

Downloads last month: 294

Total file size:

723 GB