infinigen/infinigen2-flying-indoors

Infinigen2 Flying Indoors

Click here to see a 150 scene video preview on YouTube

This release provides 48k total stereo video frames, with ground truth for depth, flow, normals, segmentation, albedo, point tracking and more. Each video is 24 timesteps long and shows a fully procedural scene with flying objects and lights with an indoor background. Each group of 4 trajectories provides synchronized views of the same scene.

This data release was generated with a pre-release version of infinigen==2.0.0a2 which will be released soon.

Limitations: some surfaces not subdivided & no material names

This version did not densely subdivide some furniture objects, such as windows and shelves. Wall meshes and small objects are also noticeably triangulated when too close to the camera. This slightly affects ground truth geometry, as depth/flow/point tracking will not factor in geometry from material displacement e.g. wood grain or fine plastic texture. Surface normals are severely affected: normals are completely flat for many surfaces. We do not recommend this dataset for surface normal training.

Global per-pixel material IDs are included in material-segmentation-CameraLeft.mkv, but this release does not include semantic names for these indices; they can only be used to distinguish between subparts of an object.

Future data releases will correct these deficiencies. We have released this preview dataset in case it is useful for other tasks.

Citation

If you use this dataset in your work, please refer to it as Infinigen2 Flying Indoors Part A, or "Part A,B" for whichever Part/ folders you used. As of 2026-08-19 there is only Part A, but more may be added.

You should also cite our paper using this BibTeX:

@misc{raistrick2026procfunc,
    title={ProcFunc: Function-Oriented Abstractions for Procedural 3D Generation in Python},
    author={Alexander Raistrick and Karhan Kayan and Jack Nugent and David Yan and Lingjie Mei and Meenal Parakh and Hongyu Wen and Dylan Li and Yiming Zuo and Erich Liang and Jia Deng},
    year={2026},
    eprint={2604.26943},
    archivePrefix={arXiv},
    primaryClass={cs.CV},
    url={https://arxiv.org/abs/2604.26943},
}

Download

These commands will install cvdpack (https://github.com/princeton-vl/cvdpack) which is an open-source tool developed by us to compress/decompress the dataset using FFMPEG. This saves 80% on download size and storage cost vs storing frames individually, but incurs some CPU cost to decompress the data.

First you must manually install ffmpeg e.g. via one of the following:

sudo apt install ffmpeg
brew install ffmpeg
conda install ffmpeg

You can download a few specific scenes and ground truth types using a command similar to below.

uvx cvdpack unpack \
  --input https://huggingface.co/datasets/infinigen/infinigen2-flying-indoors/tree/main/PartA \
  --output flying_indoor \
  --tmp_folder flying_indoor_tmp \
  --hf_staging upfront \
  --subset scene=30377061_0 traj=0 gt_type=rgb,depth cam=CameraLeft

These --subset keys align with our YouTube video text annotations, which may help you choose what to download. --tmp_folder stores .png versions of depth before they are converted to the final .npy files. --hf_staging upfront downloads the selected packed files before processing them.

scene selects the 3D scene and traj selects which of its four camera trajectories you want. Omit traj to get all four trajectories of that scene, or omit scene to get, for example, traj=0 from every scene. Each key also accepts a comma-separated list, such as traj=0,2.

Or, download and unpack the entire dataset:

uvx cvdpack unpack \
  --input https://huggingface.co/datasets/infinigen/infinigen2-flying-indoors/tree/main/PartA \
  --output flying_indoor \
  --tmp_folder flying_indoor_tmp \
  --hf_staging per_job \
  --n_workers 4 --parallel_mode multiprocess

To unpack on a SLURM cluster, use the cvdpack[hf,slurm] extra and replace --parallel_mode multiprocess with --parallel_mode slurm --slurm_args slurm_account=myaccount. --hf_staging per_job lets each worker download and delete only its own inputs.

Or, you can use the traditional Hugging Face download, then run cvdpack once to get compressed .png files and again to get .npy files for depth and other ground truth:

uvx --from huggingface_hub hf download \
  infinigen/infinigen2-flying-indoors PartA \
  --repo-type dataset --local-dir flying_indoor_packed

uvx cvdpack unpack --input flying_indoor_packed/PartA --output flying_indoor_png \
  --tmp_folder flying_indoor_tmp --steps unpack_video --n_workers 4

uvx cvdpack unpack --input flying_indoor_png --output flying_indoor \
  --tmp_folder flying_indoor_tmp --steps unquantize --n_workers 4

Video Frames Schema

Each trajectory holds one video per pass and camera.

PartA/
└── 30377061_0_traj0/
    ├── rgb-CameraLeft.mkv
    ├── rgb-CameraRight.mkv
    ├── depth-CameraLeft.mkv
    ├── depth-CameraRight.mkv
    ├── diffuse-color-CameraLeft.mkv
    ├── environment-CameraLeft.mkv
    ├── optical-flow-CameraLeft.mkv
    ├── surface-normal-CameraLeft.mkv
    ├── semantic-segmentation-CameraLeft.mkv
    ├── material-segmentation-CameraLeft.mkv
    ├── camera-CameraLeft.npz
    ├── camera-CameraRight.npz
    ├── object-data.npz
    └── metadata.json

We include only RGB and depth for the right stereo camera. We omit the other ground-truth passes for the right camera, primarily to save storage. You can partially recover these by reprojecting with the left camera's depth and the known stereo baseline.

cvdpack unpack restores the frames from compressed .mkv video files to raw .png and .npy files:

30377061_0_traj0/
├── CameraLeft/
│   ├── 0000.png .. 0023.png                      rgb
│   ├── diffuse-color_0000.png .. _0023.png
│   ├── environment_0000.png .. _0023.png
│   ├── depth_0000.npy .. _0023.npy
│   ├── optical-flow_0000.npy .. _0023.npy
│   ├── surface-normal_0000.npy .. _0023.npy
│   ├── object_0000.npy .. _0023.npy              semantic segmentation
│   ├── material-index_0000.npy .. _0023.npy      material segmentation
│   └── camera.npz
├── CameraRight/
│   ├── 0000.png .. 0023.png
│   ├── depth_0000.npy .. _0023.npy
│   └── camera.npz
├── object-data.npz
└── metadata.json

Camera Data

camera-*.npz holds the intrinsics and per-frame poses, object-data.npz the name, pose and bounding box of every object in the room, and metadata.json the seed and per-pass render times. cvdpack copies all three unchanged, so they are byte-identical in the packed and unpacked layouts.

Below, N is the number of frames (always 24 in this release), O is the number of objects in the scene (varies per scene; 128–200 is typical), and H, W are the image height and width (always 720, 1280).

Coordinate conventions. World space is Blender's: right-handed, +Z up, meters, with the floor near z=0. Camera space is OpenCV's: +X right, +Y down, +Z forward along the view axis. depth_*.npy is distance in meters along camera +Z (planar z-depth), not ray length.

camera-<cam>.npz

key	shape	dtype	meaning
K	N x 3 x 3	float64	Pinhole intrinsics in pixels, [[fx, 0, cx], [0, fy, cy], [0, 0, 1]]. Zero skew, no distortion. Every scene in this release uses fx = fy = 600, cx = W/2 = 640, cy = H/2 = 360, unchanging across frames, but read it per frame rather than hardcoding it. The principal point is the exact image center. Pixel coordinates use the corner convention: (0, 0) is the image's top left corner, so pixel (u, v) has its center at (u + 0.5, v + 0.5).
T	N x 4 x 4	float64	Camera-to-world rigid transform, one per frame. T[i, :3, 3] is the camera position in world space and T[i, :3, :3] its rotation, using the OpenCV axes above. Invert it to get world-to-camera.
HW	N x 2	int64	(height, width) in pixels for that frame.

The stereo pair is already rectified: CameraRight is CameraLeft translated along the camera's +X axis, with identical rotation. The baseline is randomized per scene but constant along a trajectory, and ranges from roughly 0.06m to 0.36m. Recover it for a scene with np.linalg.inv(T_left[i]) @ T_right[i].

Object Data

object-data.npz

Per-object 3D ground truth for every mesh object in the scene, over the same frames. Axis 0 of every array is one row per object, in arbitrary order, so identify a row by object_index or object_name rather than by its position.

Rows are mesh objects only. The cameras and the scene's light sources are assigned segmentation ids alongside the meshes but get no row, which is why object_index has gaps; those ids never appear in the segmentation pass either, since neither renders as surface geometry. Lamp and ceiling-light fixtures are ordinary mesh rows. For camera pose use T in camera-<cam>.npz above.

key	shape	dtype	meaning
location_meters	O x 3 x N	float32	World-space object origin.
rotation_euler_rad	O x 3 x N	float32	World-space XYZ Euler angles in radians, i.e. R = Rz @ Ry @ Rx. Kept continuous across frames rather than wrapped into [-pi, pi], so consecutive frames can be differenced or interpolated directly.
scale	O x 3 x N	float32	Per-axis scale, applied to the local bbox below.
local_bbox_min	O x 3 x N	float32	Axis-aligned bounding box in the object's local frame, before scale.
local_bbox_max	O x 3 x N	float32
object_index	O	int32	The value this object takes in the semantic segmentation pass, object_*.npy. Unique per object, but neither contiguous nor related to row order. 0 is reserved for background, so no row uses it.
object_name	O	|S63	ASCII byte strings, e.g. b'room_floor.00' or b'chair_rand.001'; use .decode().
object_type	O	|S63	Blender object type, always b'MESH' in this release.
data_name	O	|S63	Name of the object's mesh datablock.
data_id	O	int32	Rows sharing one mesh datablock, i.e. instances of the same asset, share a data_id.
frame_start, frame_end	scalar	int32	Inclusive frame range, 0 and 23 here. Column i of the pose arrays is frame frame_start + i, which is frame file {frame_start + i:04d}.

Pose is location/rotation/scale rather than a 4x4, and the bounding box is stored in the object's local frame, so a world-space box corner is:

from mathutils import Euler   # or build Rz @ Ry @ Rx yourself

R = np.array(Euler(rotation_euler_rad[o, :, i], "XYZ").to_matrix())
corner_world = R @ (scale[o, :, i] * local_corner) + location_meters[o, :, i]

where local_corner is one of the 8 combinations of local_bbox_min and local_bbox_max. Projecting those 8 corners with the camera above gives the object's 3D box in the image, which encloses every pixel of that object's segmentation mask.

Most objects are static; typically about a dozen rows per scene move over the 24 frames, but the arrays are per-frame throughout so no row needs special casing. An object with no pose on a given frame is NaN there; this does not occur in the released scenes, but check rather than assume.

This release ships no object-index-table.json, so object-data.npz is also the only mapping from semantic segmentation ids back to object names. It covers every object in the scene, including ones the trajectory's cameras never see.