ttaa9713/Blender-5-Real-256

Blender-5-Real 256

Five photorealistic dynamic scenes, each recorded by five equirectangular (360°) cameras walking through it for 256 frames (24 fps, 10.7 s, 2048 × 1024). Every frame comes with dense ground truth: linear HDR colour, radial depth, forward and backward optical flow, object index and cryptomatte. Each scene adds soft dynamic masks, 8,192 3D point tracks projected into every camera, and per-frame camera poses.

The cameras have fixed roles (A, A2, T, B, C) chosen by how much of each camera's static scene the others see. The roles support clean train/test protocols for dynamic novel-view synthesis and 4D reconstruction from panoramic video, e.g. fit on A and test on A2 (easy) and T (hard), or fit on A + B and test on T.

The scenes were generated with Infinigen and populated with walking people and animals, toy cars, fliers, wind-driven plants, falling leaves and water, then rendered with Blender 5.2.1 (Cycles, 64 samples per pixel, denoised colour).

Scenes	5 (two-storey house, forest, river valley, indoor home, desert)
Cameras	5 per scene, equirectangular, 2048 × 1024
Frames	256 per camera, 6,400 in all
Per frame	colour (half-float, scene-linear Rec.709), radial depth, forward/backward flow, object index, cryptomatte, soft dynamic mask
Per scene	camera poses, 4,096 dynamic + 4,096 static point tracks, object lists, check records, preview videos
Size	about 151 GB of frames, 0.6 GB of tracks, 2.2 GB of masks
Licence	CC BY 4.0, with third-party credits (see Licence)

---

Contents

1. Scenes
2. Cameras and their roles
3. Repository layout
4. Download
5. Frame files
6. Poses and the equirectangular camera
7. Point tracks
8. Dynamic masks
9. Manifests, check records and previews
10. Per-scene notes
11. Known limitations
12. Licence
13. Citation

---

Scenes

Scene	id (<sid>)	Frame window	Setting	What moves	Frames	Tracks
Two-storey house	house_walk256	1–256	Home with a usable staircase, 1,426 static objects	5 people, 5 dogs, 4 toy cars kicked by the walkers, a ceiling fan, a drone, a curtain (non-rigid); grass outside in the wind	20 GB	122 MB
Forest	forest_walk256	1–256	Closed canopy over fine rocky ground, 1,003 static objects	22 animals of 7 species; wind-driven ferns and grass	38 GB	126 MB
River valley	river_walk256	521–776	Autumn valley at low sun, opaque river, 923 static objects	7 people, 24 animals of 13 species (including a hippo and a rhino), 4 birds, ~850 falling leaves, the river surface	43 GB	123 MB
Indoor home	indoor_walk256	1–256	Single-storey house, 647 static objects, daylight through the windows	6 people, 11 dogs, 7 toy cars kicked by the walkers; grass outside in the wind	20 GB	122 MB
Desert	desert_walk256	521–776	Dunes, scrub and rocks, 305 static objects	27 animals of 12 species, ~850 falling leaves, wind-driven plants	30 GB	126 MB

River and desert use the frame numbers 521–776 (their generator's animation range); the other three use 1–256. File names, pose keys, tracks["frames"] and the masks all use these window frame numbers.

---

Cameras and their roles

Each scene has five cameras, CAM_ERP_<X> with <X> in A A2 T B C. A role is defined by static co-visibility: the solid-angle fraction of a target camera's static, non-sky pixels that some frame of the source cameras sees unoccluded, from within k × the target's distance.

Role	Intent	Target
A	the main walk	—
A2	a re-view of A, never more than about 3 m from A's path	A2 ← A ≥ 0.95 at 3×
T	overlaps A, but novel-view synthesis from A alone is hard	T ← A in 0.40–0.85 at 1.5× (desert: no maximum)
B	sees the parts of T that A cannot: A and B sandwich T	T ← A+B ≥ 0.95 at 3×
C	harder and less constrained, but not pure hallucination	C ← A ≥ 0.35, C ← A+B ≥ 0.50 at 3×

Every camera also has a floor: the union of the other four sees ≥ 0.30 of it, at 3×, in every 24-frame window. No camera walks where no other camera sees.

Measured on the rendered depth (renders/<sid>/covis_gate.json):

Scene	A2←A	T←A (1.5×)	T←A+B	C←A	C←A+B	every camera ← the others
house	.99	.82	1.00	.92	.92	≥ .92 (C's worst window .63)
forest	.98	.43	.99	.96	.99	≥ .98
river	1.00	.864	.97	.61	1.00	≥ .985
indoor	.99	.394	.99	.55	1.00	≥ .974
desert	1.00	.99	1.00	1.00	1.00	≥ .996

Two targets are missed narrowly: river T is slightly easier from A than the band allows (.864 against .85), and indoor T slightly harder (.394 against .40; its last ~60 frames are in a bedroom that A never enters and B covers). The desert's cameras are re-views of one another by design.

Suggested protocols (the roles were designed for these):

• One input camera: fit on A; test on A2 (near-path novel view), then on T (hard).
• Two input cameras: fit on A + B; test on T, then on C.
• Leave one camera out: fit on four cameras and test on the fifth.

Dynamic content is not co-visible by design: the movers appear to different cameras at different places and times, which tests whether a method carries what it learned about a mover across time. Camera B is a natural validation camera for A-only fits.

---

Repository layout

README.md                      this file
SHA256SUMS                     SHA-256 of every data file
LICENSE                        dataset licence (CC BY 4.0) and third-party notice
licenses/                      attribution and third-party licence texts
renders/<sid>/
  CAM_ERP_<X>/
    CAM_ERP_<X>_<NNNN>.exr     one multilayer OpenEXR per frame (256 per camera)
    CAM_ERP_<X>_poses.json     camera-to-world 4 × 4 per frame
  label_viz/CAM_ERP_<X>_{colour,depth,flow,instances,masks,tracks}.mp4    8-bit label previews
  videos/final_CAM_ERP_<X>.mp4                                            8-bit colour previews
  covis_gate.json, covis_gate.png   measured role targets
  facets.json, exposure.txt, confirmed_static.json, verify.log, post.log  check records
tracks/<sid>.npz               point tracks and poses for all cameras
masks/<sid>/CAM_ERP_<X>/CAM_ERP_<X>_<NNNN>.png          soft mask of everything that moves
masks/<sid>_actors/CAM_ERP_<X>/CAM_ERP_<X>_<NNNN>.png   people, animals, props and fliers only
manifests/<sid>.json           scene manifest: actors (with object index), cameras
manifests/objects/<sid>.json   which objects move, by kind; objects grouped into assets
manifests/checks/<sid>_*.json  geometry, contact, jitter, co-visibility and facet checks

---

Download

The full dataset is about 155 GB. Download all of it, or only the scenes and cameras you need:

pip install -U "huggingface_hub[cli]"
# everything
huggingface-cli download ttaa9713/Blender-5-Real-256 --repo-type dataset --local-dir Blender-5-Real-256
# one scene's camera A frames, plus its tracks and masks
huggingface-cli download ttaa9713/Blender-5-Real-256 --repo-type dataset --local-dir Blender-5-Real-256 \
  --include "renders/river_walk256/CAM_ERP_A/*" "tracks/river_walk256.npz" "masks/river_walk256/CAM_ERP_A/*"

Check the files with sha256sum -c SHA256SUMS --ignore-missing from the dataset root.

---

Frame files

Each CAM_ERP_<X>_<NNNN>.exr is one multilayer OpenEXR (ZIP compression, about 15–35 MB) with 22 channels:

Channel	Type	Content
ViewLayer.Combined	half RGBA	colour: denoised, scene-linear Rec.709 (colorInteropID = lin_rec709_scene); alpha 1
ViewLayer.Depth.Z	float32	radial distance from the camera centre along the pixel's ray, metres; sky = 1e10
ViewLayer.Vector.X/Y/Z/W	half	motion vectors (backward X/Y, forward Z/W)
ViewLayer.Object Index.X	float32 (integer values)	object pass index
ViewLayer.CryptoObject00/01/02.r/g/b/a	float32	cryptomatte: 6 ranks of (id, coverage) per pixel

Header keys:

• labelEncoding = "C", labelSupersample = 2.0, labelReduce = "k1";
• vectorScale = 0.5, vectorType = "half";
• depthMantissaBits = 15, skySentinel = 1e10;
• cryptomatte/<key>/manifest: JSON, object name → hash;
• Camera, Frame, and File (the scene file the frame was rendered from).

How the labels were made.

• Colour is the 64-samples-per-pixel render, denoised.
• Depth, flow, index and cryptomatte come from a separate label pass at 4096 × 2048 (2 × 2 sub-samples per output pixel, 16 samples per pixel, not denoised). Participating media are hidden in the label pass: volume-only objects are hidden and materials with both a surface and a volume lose only their volume, so glass and liquids are solid first hits.
• The label pass was merged into the colour file as follows:
  • Depth. A pixel is a hit if any of its 4 sub-samples hits a surface ("k1": thin structures against the sky do not blink). Its value is the lower median of the sub-samples that hit, so it lies on a real surface and is never an average across an edge. It is rounded to 15 mantissa bits (relative error ≤ 1.5e-5, 1.5 mm at 100 m). No-hit pixels are exactly 1e10.
  • Index and flow are read from the same winning sub-sample, so depth, flow and index describe one surface point.
  • Cryptomatte coverage is summed over the sub-samples.

Reading a frame (OpenEXR ≥ 3.3 Python bindings):

import numpy as np, OpenEXR

def read_frame(path):
    part = OpenEXR.File(path).parts[0]
    ch, h = part.channels, part.header
    rgb = np.asarray(ch["ViewLayer.Combined"].pixels, np.float32)[..., :3]   # linear, can exceed 1
    depth = np.asarray(ch["ViewLayer.Depth.Z"].pixels, np.float32)           # radial metres
    sky = depth >= 1e6                                                      # the sentinel is exactly 1e10
    s = float(h["vectorScale"])                                             # 0.5
    V = {k: np.asarray(ch[f"ViewLayer.Vector.{k}"].pixels, np.float32) for k in "XYZW"}
    fwd = np.stack([-V["Z"] * s, V["W"] * s], -1)     # (du, dv) to frame f+1, output pixels
    bwd = np.stack([V["X"] * s, -V["Y"] * s], -1)     # (du, dv) to frame f-1
    W = rgb.shape[1]
    for fl in (fwd, bwd):                             # the ERP seam: wrap du into [-W/2, W/2)
        fl[..., 0] = (fl[..., 0] + W / 2) % W - W / 2
    index = np.asarray(ch["ViewLayer.Object Index.X"].pixels).astype(np.int32)
    return rgb, depth, sky, fwd, bwd, index

Notes on each pass.

• Colour is linear and highlights exceed 1. For display use AgX (the scenes' view transform); a plain sRGB clip at 1.0 blows out sunlit ground. The share of the ground above AgX white is 0.00–0.77% per camera (renders/<sid>/exposure.txt).
• Depth is radial, not z-buffer depth: a world point is c + depth · R · d_cam(u + 0.5, v + 0.5) (next section). Treat any value ≥ 1e6 as sky.
• Flow is in output pixels once multiplied by vectorScale and includes camera motion: it is the image motion of the surface seen at the pixel. It is meaningless on sky pixels. At the window's first and last frame the vectors point to a frame outside the window.
• Object index: 0 is scenery and each actor has its own index (manifests/<sid>.json, actors[].object_index). Some index-0 objects move (wind-driven plants, falling leaves, the river surface): to know whether a pixel moves, use the masks, or cryptomatte with manifests/objects/<sid>.json.
• Cryptomatte identifies Blender objects by the MurmurHash3_32 of the object name, stored as the float with that bit pattern. Each of the three layers holds two ranks as (r = id, g = coverage, b = id, a = coverage). The header manifest maps names to hashes in hex; the float id is struct.unpack(">f", bytes.fromhex(hex_hash))[0]. One visible thing is often several objects (a person is body, head, legs and feet meshes); manifests/objects/<sid>.json → assets groups them.

---

Poses and the equirectangular camera

Poses are Blender camera-to-world matrices in world metres, Z up. The camera looks down its local −Z, with +Y up and +X right. They are stored per camera in renders/<sid>/CAM_ERP_<X>/CAM_ERP_<X>_poses.json ({"poses": {"<frame>": 4×4}, "convention": ...}) and in tracks/<sid>.npz as CAM_ERP_<X>_pose (256 × 4 × 4); the two are identical.

Pixel ↔ ray. For W × H = 2048 × 1024, u to the right and v down, in continuous pixel coordinates (pixel (i, j) covers [i, i+1) × [j, j+1); its centre is i + 0.5):

lon = (u / W − 0.5) · 2π          lat = (0.5 − v / H) · π
d_cam = (sin lon · cos lat,  sin lat,  −cos lon · cos lat)       # unit ray in the camera frame
d_world = R · d_cam               (R = pose[:3, :3], centre c = pose[:3, 3])

The centre column (u = W/2) looks straight ahead (−Z); the seam is behind the camera at u = 0 ≡ W.

Point → pixel:

d = R.T @ (p - c); r = np.linalg.norm(d); d /= r
lon = np.arctan2(d[0], -d[2]); lat = np.arcsin(d[1])
u = (lon / (2 * np.pi) + 0.5) * W; v = (0.5 - lat / np.pi) * H        # r is the radial depth

---

Point tracks

tracks/<sid>.npz holds 4,096 dynamic points sampled on the moving assets and 4,096 static points spread over the scenery, followed through the animation and projected into every camera.

Key	Shape	Content
frames	(256,)	window frame numbers
resolution	(2,)	2048, 1024
dynamic_xyz	(256, 4096, 3)	world position of each dynamic point in every frame
dynamic_index, dynamic_asset, dynamic_name	(4096,)	track id, the object index of the asset it sits on, the object's name
static_xyz	(4096, 3)	world position (scenery does not move)
static_index	(4096,)	track id
dynamic_ever_visible, static_ever_visible	(4096,)	seen by any camera in any frame
CAM_ERP_<X>_dynamic_uv, _static_uv	(256, 4096, 2)	ERP pixel coordinates (u, v), continuous, as above
CAM_ERP_<X>_dynamic_visible, _static_visible	(256, 4096)	the point is the surface drawn at its pixel
CAM_ERP_<X>_dynamic_distance, _static_distance	(256, 4096)	radial distance from the camera
CAM_ERP_<X>_dynamic_mover_coverage, _static_mover_coverage	(256, 4096) float16	how much of the point's pixel is covered by movers
CAM_ERP_<X>_pose	(256, 4, 4)	camera-to-world
nonstatic_names, nonstatic_why, nonstatic_kind	(K,)	index-0 objects that nevertheless move (wind, particles, animated); no static point lies on them
visibility_tolerance_m, static_mover_occlusion_threshold	scalars	0.05 m and 0.5 (the visibility rule)

Visible means that the rendered depth at the point's pixel equals the point's distance within 5 cm, and that movers cover at most half of that pixel. For clean static supervision, also require CAM_ERP_<X>_static_mover_coverage < 0.10: a few percent of visible static observations have a grass blade or leaf across them.

t = np.load("tracks/river_walk256.npz")
f = int(np.where(t["frames"] == 640)[0][0])
uv  = t["CAM_ERP_T_static_uv"][f]                                   # (4096, 2)
ok  = t["CAM_ERP_T_static_visible"][f] & (t["CAM_ERP_T_static_mover_coverage"][f] < 0.1)
xyz = t["dynamic_xyz"][:, 17]                                       # one dynamic point's 3D path

The reprojection of these tracks matches the stored pixels to 1e-4 px, and the forward flow matches the reprojected motion of static points to a median of 0.003 px (checked on river_walk256, camera T, frame 640).

---

Dynamic masks

masks/<sid>/CAM_ERP_<X>/CAM_ERP_<X>_<NNNN>.png is 16-bit greyscale; value / 65535 is the fraction of the pixel covered by something that moves (the cryptomatte coverage of every non-static object). It is a soft mask, so silhouette pixels carry their true mixture.

• masks/<sid>/ includes every kind of mover: actors, wind-driven plants, falling leaves and other particles, the river surface, driven or animated objects. In the river, 48% of a typical frame's pixels carry some motion (the water and the leaves).
• masks/<sid>_actors/ has the people, animals, props and fliers only (including the house's fan, drone and curtain).

manifests/objects/<sid>.json lists the kinds per scene: dynamic (all moving objects), kinds (actors / wind / particles / water / driven / animated → names), assets (objects grouped into whole assets) and static_count.

---

Manifests, check records and previews

• manifests/<sid>.json: the scene file, Blender version, frame_start, frames, fps; actors[] (name, object_index, mesh_count, a sampled path track_xyzh); cameras[] (name, type, clip_start, sampled track_xyzrpy). Its resolution and samples fields are the scene file's stored defaults, not the render settings (2048 × 1024, 64 samples per pixel, as the EXR headers say).
• manifests/checks/: the exact-geometry check (no penetration or contact; camera–actor and camera–camera clearances), the toy cars' kick contacts, pose jitter, terrain edges, the co-visibility role gate, terrain facets, and the generator-static objects that label verification settled.
• renders/<sid>/verify.log, post.log: label verification and post-processing records.
• Previews (renders/<sid>/label_viz/, renders/<sid>/videos/): 8-bit H.264 videos of colour, depth, flow, instances, masks and tracks. They are for looking at the data; do not train on them.

---

Per-scene notes

• House: the ceiling fan spins and the drone flies; glass (dining table, plant containers, glasses) is present in depth, index and cryptomatte. A and A2 follow C into the dining and living rooms.
• Forest: A2 is just outside A's arc and C runs between A and the clearing, so A is not isolated.
• River: the water is opaque, and depth on it was checked against the water plane. C walks the far bank; B walks beside it.
• Indoor home: A and T walk into their paths over the first 64 frames. B follows T into the bedroom. The light is moderate (0.03–0.77% of the ground above AgX white).
• Desert: the terrain was re-meshed around all five paths (median edge 24 mm within 15 m of the paths), so no flat-shaded facets appear. The three dragonflies hold still in this window. The cameras are re-views of one another by design.

---

Known limitations

• Two role targets are missed narrowly (river T ← A .864; indoor T ← A .394).
• Desert T passes 0.32–0.34 m from a voxelised leaf box on two frames (the clearance target was 0.30–0.35 m; the voxel proxy is conservative by up to 0.26 m).
• Mixed GPU types. The frames were rendered on RTX 4090, RTX PRO 4500 and RTX PRO 6000 GPUs in ranges of about 37 frames. Every frame is a complete, independent render with its own seed; nothing is stitched within a frame.
• Indoor scene file name. The indoor frames were rendered from home_walk.blend (the File header key says so).
• Visibility near movers. Track visibility and the soft masks come from 2 × 2 supersampled labels. Sub-pixel structures (leaves, grass blades) are present in cryptomatte and the masks more reliably than in depth.
• Scene files are not included. Only renders and labels are released (see the licence notes).

---

Licence

The dataset

The renders, labels, masks, tracks, poses and manifests in this repository are released under the Creative Commons Attribution 4.0 International licence (CC BY 4.0), https://creativecommons.org/licenses/by/4.0/. See LICENSE.

The images depict third-party assets. Every third-party asset in the five scenes is CC0 1.0 or CC BY 4.0, and generated content comes from Infinigen (BSD 3-Clause code). Nothing is non-commercial, share-alike, no-derivatives or of unknown origin. CC BY 4.0 is compatible with all of them; the CC BY 4.0 assets require the credits below.

Third-party content in the scenes

Asset	Licence	Source	Desert	Forest	River	House	Indoor
Quaternius, Ultimate Animated Animal Pack (12 species, meshes, rigs and walk animations)	CC0 1.0	quaternius.com (author's download)	27	22	22	5 dogs	11 dogs
Quaternius, Ultimate Modular Men and Ultimate Modular Women packs: Suit, Worker, Farmer (men), Formal, Casual (women)	CC0 1.0	quaternius.com (author's download)	–	–	7	5	6
Gobkit, Free Animal Pack: Hippo, Rhino	CC0 1.0	gobkit.itch.io	–	–	2	–	–
Kenney, Car Kit 3.1 toy cars	CC0 1.0	kenney.nl	–	–	–	4	7
"Ceiling Fan" by Nelesh_surve (mesh and textures; our rotation)	CC BY 4.0	Sketchfab, via the Objaverse 1.0 mirror	–	–	–	1	–
"S9 drone" by blockv_lb (mesh and propeller clip; our flight path)	CC BY 4.0	Sketchfab, via the Objaverse 1.0 mirror	–	–	–	1	–
Infinigen 1.19.1 scenes: terrain, water, plants, rocks, leaves, furniture, birds, dragonflies, figurines	BSD 3-Clause (the generator); the generated output is ours	generated	✓	✓	✓	✓	✓
Infinigen text and art textures (book covers, labels, screens, wall art)	generated; glyphs from 9 SIL OFL 1.1 font families bundled with Infinigen, plus Open Sans (Apache 2.0)	generated	–	–	–	✓	✓
KoleClouds sky node setup (Thomas Kole, bundled in Infinigen)	CC0 (author's statement)	Infinigen	✓	–	–	–	–
Blender built-ins (Nishita sky, glTF-importer bone shapes)	—	Blender 5.2.1	✓	✓	✓	✓	✓

Counts are objects in each rendered scene. No HDRIs, linked libraries, sounds, caches or assets from Blender's bundled asset library are used, and Infinigen downloads nothing at run time. Text textures are random strings with shapes and fake barcodes; no logos, brand names or real barcodes appear.

Required credits (CC BY 4.0 assets)

• "Ceiling Fan" by Nelesh_surve, https://sketchfab.com/3d-models/ceiling-fan-d983542fbecd4926aa07f1f8ec7e9b05, licensed under CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/). Modified: placed in the scene, animated (rotation) and rendered.
• "S9 drone" by blockv_lb, https://sketchfab.com/3d-models/s9-drone-4b547ed14efd460a8ac2155be7130097, licensed under CC BY 4.0. Modified: placed in the scene, animated (flight path; its propeller clip is used) and rendered.
• Scenes generated with Infinigen (Raistrick et al., CVPR 2023, https://github.com/princeton-vl/infinigen), Copyright (c) 2023 Princeton University, BSD 3-Clause License (text in licenses/third_party/).

When you redistribute this dataset or images from it, keep these credits and the CC BY 4.0 notice.

Courtesy credits (not required)

Quaternius (https://quaternius.com), Kenney (https://kenney.nl) and Gobkit (https://gobkit.itch.io), whose CC0 assets populate the scenes; Objaverse 1.0 (ODC-By 1.0), through which the two Sketchfab models were obtained; the font authors of the SIL OFL 1.1 families and Open Sans (Apache 2.0).

What else to know

• Scene files are not released. Only renders and labels are. The .blend scene files embed the asset files themselves and Infinigen's generated node trees, which would need separate care.
• Blender is GPL software; its output (these renders) is not covered by the GPL.
• Licence texts. licenses/third_party/ holds the licence files shipped with the assets, and licenses/ATTRIBUTION.md the credits.

---

Citation

A citation for the dataset will be added. Please also cite Infinigen and Infinigen Indoors (the house and indoor home are Infinigen Indoors scenes):

@inproceedings{infinigen2023infinite,
  title     = {Infinite Photorealistic Worlds Using Procedural Generation},
  author    = {Raistrick, Alexander and Lipson, Lahav and Ma, Zeyu and Mei, Lingjie and Wang, Mingzhe and
               Zuo, Yiming and Kayan, Karhan and Wen, Hongyu and Han, Beining and Wang, Yihan and
               Newell, Alejandro and Law, Hei and Goyal, Ankit and Yang, Kaiyu and Deng, Jia},
  booktitle = {Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition},
  pages     = {12630--12641},
  year      = {2023}
}

@inproceedings{infinigen2024indoors,
  author    = {Raistrick, Alexander and Mei, Lingjie and Kayan, Karhan and Yan, David and Zuo, Yiming and
               Han, Beining and Wen, Hongyu and Parakh, Meenal and Alexandropoulos, Stamatis and
               Lipson, Lahav and Ma, Zeyu and Deng, Jia},
  title     = {Infinigen Indoors: Photorealistic Indoor Scenes using Procedural Generation},
  booktitle = {Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR)},
  month     = {June},
  year      = {2024},
  pages     = {21783--21794}
}