stereo-dataset/stereo-dataset

Stereo Dataset

Dataset Summary

StereoDataset is a synthetic multiview stereo dataset rendered in Unreal Engine. Each scene combines a map, a character mesh, an animation clip, a validated spawn location, and a camera trajectory. The released scene folders contain synchronized per-camera RGB videos (cam_XX_rgb.mp4), per-camera depth videos (cam_XX_depth.mkv), and scene-level metadata including _scene_complete.json, trajectory.json, and baseline.json.

The dataset is organized by split (train, eval) and by camera-baseline regime. IPD_Gaussian, Uniform, and Pairwise_Uniform refer to different baseline sampling regimes used during generation; the realized baseline values for each scene are stored explicitly in baseline.json.

How the data was generated

The data were generated from Unreal Engine map assets under /Game/<MapRoot>/..., where <MapRoot> is also used as the map name in this dataset. For each scene, the pipeline selected a map, a character mesh, and an animation asset; placed the character at a validated spawn location; built a camera trajectory; instantiated a rigid 6-camera rig; and rendered synchronized RGB and depth sequences for all cameras.

During generation, the engine exported raw per-frame camera poses, camera intrinsics, the scene label, the map path, the spawn key, and the trajectory key. A post-processing step then converted these raw pose exports into the released metadata files, including trajectory.json, baseline.json, and _scene_complete.json.

Directory layout

<repo>/
├── train/
│   ├── IPD_Gaussian/<map>/scene_XXXXXX/...
│   ├── Pairwise_Uniform/<map>/scene_XXXXXX/...
│   └── Uniform/<map>/scene_XXXXXX/...
└── eval/
    ├── MapSeenInTrain/
    │   ├── IPD_Gaussian/<map>/scene_XXXXXX/...
    │   └── Uniform/<map>/scene_XXXXXX/...
    └── MapUnseenInTrain/
        ├── IPD_Gaussian/<map>/scene_XXXXXX/...
        └── Uniform/<map>/scene_XXXXXX/...

Each scene_XXXXXX/ contains 15 core files:

File	Purpose
_scene_complete.json	scene completeness marker
baseline.json	realized adjacent/pairwise baselines + camera intrinsics
trajectory.json	per-frame 6-camera poses + character / animation metadata
cam_00_rgb.mp4 … cam_05_rgb.mp4	RGB from 6 cameras
cam_00_depth.mkv … cam_05_depth.mkv	log-encoded metric depth from 6 cameras

Some train scenes also include _post_hf_addition.json, which marks scenes that were incorporated after the original Hugging Face upload. The marker is retained as provenance for those already-included scenes.

RGB, depth, and camera geometry contract

This section is about public loading and evaluation contract for the released scene files.

Frame alignment and camera indexing

Within each scene, the six RGB videos and six depth videos are synchronized by frame index. Frame t in cam_XX_rgb.mp4 corresponds to frame t in cam_XX_depth.mkv and to frames[t] in trajectory.json. Use this frame-index contract for RGB/depth/pose alignment; do not infer alignment from container timestamps alone.

The current release uses 1280 x 1280 videos with 81 frames per scene. RGB MP4 streams are encoded at 15 fps. Depth MKV streams have the same frame count and spatial resolution, but the FFV1 container stream metadata in the checked release files reports 30 fps. This does not change the frame-index alignment contract above.

Camera indices in filenames match the metadata: cam_00_* is camera index 0, ..., cam_05_* is camera index 5. The camera_order field in trajectory.json records the mapping from camera names to these output stems.

Depth video decoding

cam_XX_depth.mkv is an FFV1/gray16le uint16 video containing logarithmically encoded metric depth. It is not a linear uint16 depth scale. Decode each stored uint16 value v to meters with:

import numpy as np


def decode_depth_uint16(v: np.ndarray) -> np.ndarray:
    v = np.asarray(v, dtype=np.uint16)
    depth_m = np.full(v.shape, np.nan, dtype=np.float32)

    valid = v > 0
    t = (v[valid].astype(np.float32) - 1.0) / 65534.0
    depth_m[valid] = 0.1 * (50000.0 ** t)
    return depth_m

v == 0 is reserved for invalid pixels. v == 65535 is the maximum encoded value and decodes to the upper supported depth, 5000 m. It can include depths that were clipped to that upper bound, so evaluations that exclude far or saturated regions may choose to mask it.

The decoded depth_m values are metric optical-axis depth in meters. Metadata translations and baselines are stored in centimeters, so convert units before combining depth with camera metadata.

Intrinsics

Per-scene camera intrinsics are stored in baseline.json under camera_intrinsics. The released cameras in a scene share these intrinsics. For an image of width W and height H, compute pixel focal lengths as:

fx_px = focal_length_mm / sensor_width_mm * W
fy_px = focal_length_mm / sensor_height_mm * H

For the current 1280 x 1280 videos, use W = H = 1280 unless reading the size directly from the video stream. If no principal-point override is recorded in baseline.json, use the image center for (cx, cy).

Baselines and rectified-pair disparity

The released rig is a rigid rectified lateral camera array. Within a frame, the six cameras share orientation and differ by lateral translation along the stereo axis. baseline.json records realized scalar baseline distances in centimeters:

• adjacent_pairs gives neighboring camera pairs.
• pairwise_pairs gives all 15 unordered pairs in the 6-camera rig.
• baseline_cm is a distance magnitude. It is not by itself a signed image-x displacement; the sign of disparity depends on the chosen left/right camera order and projection convention.

The generation code constructs the array by offsetting cameras along the local camera right vector while keeping their rotation shared within the frame. This is why the scalar baseline is sufficient for an absolute-disparity sanity check on a selected rectified pair, but the camera order still determines the sign.

For a selected rectified pair, the expected absolute disparity sanity check is:

disparity_px = fx_px * baseline_m / depth_m

where baseline_m = baseline_cm / 100.0, depth_m is decoded as above, and fx_px is computed from the released intrinsics. If this value does not match the visible RGB disparity for a frame, first verify:

• the depth video was decoded with the logarithmic mapping above;
• centimeters from metadata were converted to meters before combining with decoded depth;
• fx_px was computed in pixels, not left in millimeters;
• the baseline was read for the same camera pair being compared;
• RGB, depth, and pose frame indices are aligned;
• the expected disparity sign matches the selected left/right camera order.

Poses and projective reprojection

trajectory.json stores per-frame poses for all six cameras. Translations are camera centers in the Unreal/world coordinate frame, in centimeters. rotation_representation is quaternion_xyzw; rotation_deg is also provided for readability. These records are exported from the Unreal camera actor pose: the camera optical axis is the actor forward vector, the horizontal image axis uses the actor right vector, and the vertical image axis uses the actor up vector. The generation-side projection check computes depth as dot(point - camera_center, forward), image x from the right-vector component, and image y from the up-vector component. If your pixel coordinate convention uses y increasing downward, handle that sign convention explicitly.

For geometry-sensitive evaluation or debugging, use the per-frame poses in trajectory.json together with the intrinsics from baseline.json to back-project source pixels using source depth, compose the source-to-target relative pose in a single chosen coordinate convention, and project into the target camera. For rectified lateral pairs, this full projective reprojection should agree with the scalar fx * baseline / depth sanity check up to camera ordering/sign, quantization, occlusion, and rounding effects.

Splits and sampling families

• Train split: 7754 complete scenes
  • IPD_Gaussian: 3289
  • Pairwise_Uniform: 3691
  • Uniform: 774
• Eval split: 739 complete scenes
  • MapSeenInTrain: 546
  • MapUnseenInTrain: 193
  • IPD_Gaussian within eval: 356
  • Uniform within eval: 383

MapSeenInTrain evaluates held-out scenes from maps that also appear in train. MapUnseenInTrain evaluates generalization to maps not present in the train split.

Per-scene captions

Each of the 8,493 scenes has a machine-generated description of a single sampled frame (camera cam_00, frame index 19 zero-based / 20 one-based). Captions are released as Parquet (one row per scene) and as JSONL (the same content plus the raw model output for reproducibility).

File	Rows	Notes
metadata/captions_train.parquet	7,754	one row per train scene
metadata/captions_eval.parquet	739	one row per eval scene
metadata/scene_descriptions_cam00_frame20_qwen_dataset_level/dataset_level_descriptions.jsonl	8,493	combined JSONL with raw_model_output
metadata/scene_descriptions_cam00_frame20_qwen_dataset_level/{summary,quality_stats,assign_to_scene_dirs_summary}.json	—	pipeline statistics (top scene types, word-length distributions, shard breakdown)

Each Parquet row has 24 fields:

Field	Type	Description
scene_id	string	Scene folder name (e.g. scene_000000)
split, branch, eval_subset, map, seen_group	string	Identifiers from the directory layout
scene_dir_rel, video_path_rel	string	Repo-relative paths to the scene directory and the captioned cam_00 video
scene_dir_hf_url, video_path_hf_url	string	Hugging Face resolve URLs
caption_short	string	One-line scene description (avg ~7 words)
caption_detailed	string	Multi-sentence scene description (avg ~44 words)
scene_type, setting, spatial_layout, lighting	string	Structured scene attributes
primary_elements, materials_surfaces, tags	list[string]	Free-form lists
frame_index_zero_based, frame_number_one_based	int	Sampled frame (always 19 / 20)
uncertainty_notes	string	Filled when the model expressed low confidence (often empty)
annotation_schema	string	dataset_level_scene_v1
model	string	Qwen/Qwen2.5-VL-3B-Instruct

Captions were produced automatically by the open-weights Qwen/Qwen2.5-VL-3B-Instruct vision-language model from a single RGB frame per scene. They are intended as auxiliary text metadata (e.g. for retrieval, conditioning, scene typing) and are not human-curated ground truth; expect VLM hallucinations and biases inherited from the underlying model. Field-level statistics are in metadata/scene_descriptions_cam00_frame20_qwen_dataset_level/quality_stats.json.

Current snapshot

• Total scenes: 8,493 (7,754 train + 739 eval), all with _scene_complete.json present.
• Croissant metadata: croissant.json at the repository root.

A 16-scene, ~1.8 GiB inspection sample is also available at stereo-dataset/stereo-dataset-small-sample-2gb

License

Rendered RGB, depth, and metadata in this dataset are released under CC-BY-4.0. Accompanying code (loaders, evaluation scripts, generation pipeline) is released under the MIT license in the linked code repositories. Source Unreal Engine assets used during generation retain their original licenses and are not redistributed here; this dataset only contains rendered outputs.