LUMEN Dataset

This is the official dataset release of LUMEN (SIGGRAPH Asia).

[Paper] [Project Page] [Code]

LUMEN is a synthetic indoor-scene dataset for spatially-varying HDR lighting estimation. For every procedurally generated indoor scene we provide:

• the original Blender scene file (.blend);
• multi-view LDR RGB renderings with camera intrinsics / extrinsics;
• per-view depth maps (EXR);
• HDR equirectangular environment maps captured at many light-probe positions inside the room, together with the probe positions and rotations.

All coordinates follow the Blender convention (right-handed, world Z-up; camera looks along its local -Z, local +Y is up and +X is right).

---

Repository Layout

The repository has two branches:

Branch	Content	Scenes
main	Blender scene files (blends/*.blend)	392
rendered	Rendered RGB, depth and light-probe environment maps	538 (509 box_* + 29 polygon_*)

Scene names are shared across branches, e.g. blends/box_1012146.blend on main corresponds to box_1012146/ on rendered. Every .blend on main has a rendered counterpart; some rendered scenes are released without a .blend file.

• box_*: rooms with a rectangular (box-shaped) floor plan.
• polygon_*: rooms with a general polygonal floor plan.

main branch

blends/
├── box_1012146.blend
├── box_1016191.blend
└── ...

rendered branch

<scene_name>/                     # e.g. box_1012146
├── rgb/
│   ├── frame_0001.png            # 512x512, RGBA, 8-bit
│   ├── ...
│   ├── frame_0012.png
│   └── transform.json            # camera intrinsics & extrinsics of every frame
├── depth/
│   ├── depth_0001.exr            # 512x512, single channel 'V', float32
│   ├── ...
│   └── depth_0012.exr
└── env/
    ├── frame0001_envmap01.exr    # 1024x512 equirectangular HDR, RGB float32
    ├── frame0001_envmap02.exr
    ├── ...
    ├── random_envmap0001.exr
    ├── ...
    └── envposition.json          # position & rotation of every light probe

• Each scene contains 12 views (frame_0001 ... frame_0012).
• depth/depth_XXXX.exr is aligned pixel-to-pixel with rgb/frame_XXXX.png.
• The number of environment maps varies across scenes (typically 20-30), see below.

---

File Formats

rgb/transform.json

{
  "frames": [
    {
      "frame": "frame_0001",         // -> rgb/frame_0001.png, depth/depth_0001.exr
      "w": 512, "h": 512,            // image resolution
      "fx": 412.0938, "fy": 412.0938,// focal length in pixels
      "cx": 256.0,   "cy": 256.0,    // principal point in pixels
      "c2w": [[...], [...], [...], [0, 0, 0, 1]],  // 4x4 camera-to-world (Blender camera)
      "w2c": [[...], [...], [...], [0, 0, 0, 1]],  // 4x4 world-to-camera, inverse of c2w
      "camera_position": [x, y, z]   // camera center in world space (= c2w[:3, 3])
    },
    ...
  ],
  "hdr_background": {
    "used_hdr": true,                        // whether an outdoor HDRI is used as world background
    "hdr_file": "railway_bridge_02_2k.hdr",  // HDRI file seen through windows / openings
    "strength": 0.4985                       // Blender world background strength
  }
}

c2w / w2c use the Blender camera convention (OpenGL-style): the camera looks along -Z, +Y is up and +X is right in camera space. To convert to the OpenCV convention (+Z forward, +Y down), flip the camera Y and Z axes:

c2w_opencv = c2w_blender @ np.diag([1, -1, -1, 1])

depth/depth_XXXX.exr

• Single float32 channel named V, resolution 512x512, in Blender scene units (meters).
• Pixels with no geometry hit (e.g. seen through a window) have value 1e10; mask them out before use (e.g. depth < 1e9).

env/*.exr (light probes)

• Equirectangular (lat-long) HDR panoramas, 1024x512, linear RGB float32 (channels R, G, B).
• Two kinds of probes:
  • frameXXXX_envmapYY.exr: the YY-th probe associated with view frame_XXXX. These probes lie inside the view frustum of frame_XXXX (they project into rgb/frame_XXXX.png), so they can be used as image-conditioned, spatially-varying lighting ground truth. Usually 2 per view; a few views have only 1.
  • random_envmapNNNN.exr: probes placed at random positions in the room, not tied to any view.

env/envposition.json

A list with one entry per environment map:

[
  {
    "envmap": "frame0001_envmap01",          // -> env/frame0001_envmap01.exr
    "position": "-0.492489, 0.119080, 0.622956",  // probe center in world space (x, y, z), comma-separated string
    "random_rotation_degrees": {             // rotation of the panoramic probe camera, Euler angles in degrees
      "x": 0.0,
      "y": 0.0,
      "z": 126.0244
    }
  },
  ...
]

• position is in the same Blender world frame as rgb/transform.json.
• random_rotation_degrees is the (Blender, XYZ Euler) rotation applied to the probe when the panorama was rendered. Undo this rotation if you need the environment map aligned with the world axes.

---

Download

The dataset is gated: please log in and accept the access conditions on the dataset page first, then authenticate with hf auth login.

# All rendered data
hf download BackRabb1t/LUMEN --repo-type dataset --revision rendered --local-dir LUMEN_rendered

# A single rendered scene
hf download BackRabb1t/LUMEN --repo-type dataset --revision rendered \
    --include "box_1012146/*" --local-dir LUMEN_rendered

# All Blender scene files
hf download BackRabb1t/LUMEN --repo-type dataset --revision main --local-dir LUMEN_blend

# A single Blender scene
hf download BackRabb1t/LUMEN blends/box_1012146.blend --repo-type dataset --revision main --local-dir LUMEN_blend

Python:

from huggingface_hub import snapshot_download

snapshot_download(
    repo_id="BackRabb1t/LUMEN",
    repo_type="dataset",
    revision="rendered",
    allow_patterns=["box_1012146/*"],
    local_dir="LUMEN_rendered",
)

---

Usage Example

Load one view and project its light probes into the image:

import json
import numpy as np
import imageio.v3 as iio   # pip install imageio[freeimage]  (or use OpenEXR / OpenCV for .exr)

scene = "LUMEN_rendered/box_1012146"

frames = json.load(open(f"{scene}/rgb/transform.json"))["frames"]
probes = json.load(open(f"{scene}/env/envposition.json"))

f = frames[0]                                            # frame_0001
rgb   = iio.imread(f"{scene}/rgb/{f['frame']}.png")      # (512, 512, 4) uint8
depth = iio.imread(f"{scene}/depth/depth_{f['frame'][-4:]}.exr")  # (512, 512) float32
valid = depth < 1e9

w2c = np.array(f["w2c"])
for p in probes:
    if not p["envmap"].startswith("frame" + f["frame"][-4:]):
        continue
    xyz = np.array([float(v) for v in p["position"].split(",")] + [1.0])
    xc, yc, zc = (w2c @ xyz)[:3]                         # Blender camera space, looks along -Z
    u = f["cx"] + f["fx"] * xc / -zc
    v = f["cy"] - f["fy"] * yc / -zc
    envmap = iio.imread(f"{scene}/env/{p['envmap']}.exr")  # (512, 1024, 3) float32, linear HDR
    print(p["envmap"], "pixel:", (u, v), "probe depth:", -zc)

---

Citation

If you find this dataset useful, please cite our paper:

@inproceedings{lumen,
  title     = {TODO},
  author    = {TODO},
  booktitle = {SIGGRAPH Asia Conference Papers},
  year      = {TODO}
}

License

TODO: specify the license and the terms of use. The outdoor HDRIs used as world backgrounds (see hdr_background.hdr_file) come from third-party sources (e.g. Poly Haven) and remain under their original licenses.

Contact

TODO