Datasets:
Generating SyncLight pairs
synclight_generate.py turns the per-light base files of this dataset into relighting pairs: two light states that differ in one light, rendered from every camera of a rig, plus a lightmap describing the edit. One script handles all three sources. The source field of the config selects how base files are read: EXR renders for Infinigen and BlenderKit, RAW photographs for the real captures.
pip install numpy opencv-python pyyaml scipy pillow OpenEXR rawpy # rawpy only needed for the real split
bash scripts/extract.sh ./synclight_raw infinigen train
python scripts/synclight_generate.py --config scripts/configs/infinigen.yaml \
--input ./synclight_raw/infinigen/train --output ./synclight_pairs/infinigen/train --workers 8
The output has the layout the SyncLight training code reads (<scene>/png_simple/transforms.json for Infinigen, <scene>/png_blended/transforms.json for the others). Finished scenes are skipped when the command is re-run.
How it works
1. Per-light images. Each camera of a scene has one linear HDR image per light source, with that light alone at full intensity. Lights come in three kinds, encoded in the file names:
| kind | meaning | can be edited? |
|---|---|---|
camvis |
visible from this camera | yes, it appears in the lightmap |
rigvis |
visible only from other cameras of the rig | no, but it is switched on and off randomly |
nonvis / ambient |
not visible from any camera (window light, ambient fill) | no |
2. Light states. A state gives every light an intensity in [0, 1] and an RGB colour. Light is additive, so the image of a state is
image = tonemap( exposure · Σ_i intensity_i · colour_i · light_i )
3. Samples. A sample is a before state and an after state that differ in exactly one camvis light: the edit. For every reference camera, two families of samples are generated:
- Solo sweep (
solo_sweep). Only when the scene has an ambient light. The before state is the ambient light alone. In the after state, one visible light is switched on in each of 8 saturated hues andn_temperaturescolour temperatures. This teaches the model clean colour edits. - Random combinations (
pairs.per_lightper editable light). The before state is random: each ambient light is on with probabilityp_ambient_on, each visible light with probabilityp_visible_on, at an intensity drawn fromon_intensity, and all lights share one colour drawn fromcolors.scene. The after state applies one edit to the target light, chosen with theeditsweights:toggle: on → off, or off → on at full intensityintensity: a bright light is dimmed (dim_to), a dim one brightened (brighten_to), an off one partially switched on (partial_on)color: the light gets a new colour drawn fromcolors.edit, and is switched on if it was off
4. Colours. Every colour draw is white, a colour temperature or a saturated hue, with the probabilities in colors.scene (the shared colour of the before state) or colors.edit (the new colour of a colour edit).
- Temperatures are picked from
colors.temperatures(Kelvin), or uniformly fromcolors.temperature_range. - Saturated hues depend on
colors.vivid.mode:named: one of 8 fixed huesjitter: random hue, saturation and value around those 8 huesany: any hue, with saturation and value ranges you set
- Per-light colours:
colors.per_light: truegives every light its own colour instead of one shared colour.
5. Views and pairs. Each sample is rendered for the reference camera, which gives the guide images and the lightmap, and for up to target_views other cameras of the same rig. Each other view gives one training pair. If the sample stores its reverse edit, it gives a second pair (after → before). So, per reference camera with k editable lights in a rig of C cameras:
samples = k · (8 + n_temperatures) [if there is an ambient light] + k · per_light
pairs = Σ_samples (C − 1) · (1 + reverse)
pairs.max_per_scene drops samples at random, keeping the same fraction in every camera, until the scene fits under the cap.
6. Tone mapping. Linear images are multiplied by exposure and mapped to 8-bit with operator and gamma:
- Operators:
reinhard(x/(1+x)),reinhard_white,aces,hable(filmic) orclip. - Auto exposure: with
auto_exposure: {percentile: 99, target: 0.9}the exposure is chosen per sample from the reference before image. It is then used for every image of that sample, so the before and after images stay photometrically consistent.
7. Lightmaps. The lightmap marks the pixels of the edited light, found by thresholding its light-position map at output.lightmap_threshold. Each pixel holds [activation, L, a, b]: activation is −1 (turn off), 0 (no change) or 1 (set to the target intensity L and colour a, b). By default lightmaps are written as 16-bit PNGs; read them with lightmap_io.load_lightmap. Set output.lightmap: npy for float32 .npy.
8. Determinism. Every reference camera has its own random generator, seeded from seed, the scene name, the rig and the camera. The same config therefore gives the same pairs no matter how many workers you use, and --dry-run counts exactly what a real run produces.
Configs
| Config | Matches |
|---|---|
configs/infinigen.yaml |
the released Infinigen pairs |
configs/blenderkit.yaml |
the released BlenderKit pairs |
configs/real.yaml |
the released real-capture pairs |
These configs use the same sampling rules, colour lists, tone mapping and light-map thresholds as the scripts that produced the pairs used in the paper. Because those runs were not seeded, a new run gives different pairs with the same distribution and the same scale:
| Source / split | Pairs released | Pairs generated | Images released | Images generated |
|---|---|---|---|---|
| Infinigen train | 898,267 | 920,878 | 1,579,444 | 1,617,594 |
| Infinigen test | 27,236 | 29,516 | 47,788 | 51,572 |
| BlenderKit train | 44,326 | 44,420 | 74,822 | 74,950 |
| BlenderKit test | 3,198 | 3,222 | 5,464 | 5,496 |
| Real train | 12,718 | 12,756 | 22,652 | 22,700 |
| Real test | 1,718 | 1,712 | 3,066 | 3,058 |
The renderer itself is exact. With output.precision: float64, the deterministic samples (the start of the solo sweep) are bit-identical to the released images and lightmaps for all three sources. The default float32 is faster and differs by at most one grey level.
The configs differ on purpose:
- Infinigen has 5 random samples per light, a cap of 5,000 pairs per scene, no colour edits, and an occasional saturated scene colour.
- BlenderKit and real have 10 random samples per light, no cap, and 20% colour edits.
- Real uses
cliptone mapping with exposure 1.0 and writes images with a longest side of 1280.
Colour palettes
colors.palette applies a preset on top of a config. Any colors.* value set with --set still overrides it.
| Palette | Scene colour (white / temperature / saturated) | Colour edits | Notes |
|---|---|---|---|
neutral |
50 / 50 / 0 | 20% white, 80% temperature | temperatures 3000–6500 K |
warm |
20 / 80 / 0 | temperature only | 2200–4000 K (tungsten) |
cool |
20 / 80 / 0 | temperature only | 5000–9000 K (daylight, fluorescent) |
colorful |
40 / 30 / 30 | 40% temperature, 60% saturated | hues jittered around the 8 named ones |
wild |
10 / 20 / 70 | 90% saturated | any hue; every light gets its own colour |
Parameter reference
| Key | Default | Meaning |
|---|---|---|
source |
infinigen | infinigen, blenderkit or real: how base files are found and read |
output_subdir |
png_simple | folder written inside each output scene |
seed |
0 | master seed |
pairs.per_light |
5 | random-combination samples per editable light, per reference camera |
pairs.max_per_scene |
null | cap on pairs per scene |
pairs.reverse |
true | also store the reverse edit of random samples |
pairs.target_views |
all | other views rendered per sample (all or a number) |
pairs.min_cameras |
2 | rigs with fewer cameras are skipped |
solo_sweep.enabled |
true | add the solo colour sweep |
solo_sweep.vivid |
8 hues | hues of the sweep |
solo_sweep.n_temperatures |
5 | colour temperatures added to the sweep, drawn from solo_sweep.temperatures |
solo_sweep.intensity |
1.0 | intensity of the swept light |
solo_sweep.reverse_first |
3 | only the first N sweep colours also store the reverse edit |
lights.p_ambient_on |
0.8 | probability that each ambient light is on in the before state |
lights.p_visible_on |
0.6 | probability that each visible light is on in the before state |
lights.on_intensity |
[0.4, 1.0] | intensity range of lights that are on |
edits.toggle / intensity / color |
0.7 / 0.3 / 0 | relative weights of the edit types |
edits.dim_to, brighten_to, partial_on |
[0.2,0.5], [0.7,1], [0.5,1] | target intensity ranges of intensity edits |
edits.bright_threshold |
0.6 | lights above it are dimmed, below it brightened |
colors.palette |
null | preset (see above) |
colors.scene |
0.7 / 0.18 / 0.12 | white / temperature / vivid weights of the shared scene colour |
colors.edit |
0 / 0.7 / 0.3 | weights of the new colour in colour edits |
colors.per_light |
false | every light draws its own colour |
colors.temperatures |
list | colour temperatures to choose from (K) |
colors.temperature_range |
null | continuous temperature range instead of the list |
colors.vivid.mode |
jitter | named, jitter or any |
colors.vivid.names |
8 hues | hues used by named and jitter |
colors.vivid.saturation, value |
[0.7,1], [0.7,1] | ranges used by any |
tonemap.operator |
reinhard | reinhard, reinhard_white, aces, hable, clip |
tonemap.white |
4.0 | white point of reinhard_white |
tonemap.exposure |
1.0 | multiplier on linear radiance |
tonemap.auto_exposure |
null | {percentile, target}: exposure per sample from the reference before image |
tonemap.gamma |
2.2 | display gamma, or srgb |
tonemap.quantize |
floor | floor (as in the release) or round |
output.max_side |
null | downscale outputs so the longest side is at most this many pixels |
output.resize_inputs |
false | downscale base images before mixing instead of after tone mapping: about 6× faster for RAW, with a mean difference under 1 grey level (up to ~40 on small, very bright spots) |
output.lightmap |
png16 | png16 or npy |
output.lightmap_size |
image | image (same size as the images) or native (size of the light-position maps) |
output.lightmap_threshold |
0.098 | light-position map value above which a pixel belongs to the light |
output.precision |
float32 | float64 reproduces the original renderer bit for bit |
Recipes
# count first: what would a config produce? (reads only file names)
python scripts/synclight_generate.py --config scripts/configs/blenderkit.yaml --input ./synclight_raw/blenderkit/train --dry-run
# twice the data, warm lights only
... --set pairs.per_light=10 colors.palette=warm
# colour edits only, any hue, every light its own colour
... --set colors.palette=wild edits.toggle=0 edits.intensity=0 edits.color=1
# filmic tone mapping with automatic exposure
... --set tonemap.operator=aces "tonemap.auto_exposure={percentile: 99, target: 0.9}"
# smaller, faster real-capture pairs
... --config scripts/configs/real.yaml --set output.max_side=768 output.resize_inputs=true
Speed
Measured on one CPU core (--workers 1) with the paper configs, reading base files from a local SSD:
| Scene | Pairs | Images | Time | Output size |
|---|---|---|---|---|
Infinigen Bathroom_1000 (test) |
804 | 1,580 | 252 s | 1.1 GB |
BlenderKit bare_room (test) |
1,728 | 2,944 | 477 s | 1.6 GB |
Real scene15 (test), exact |
312 | 536 | 907 s | 0.8 GB |
Real scene15 (test), resize_inputs: true |
312 | 536 | 138 s | 0.8 GB |
Rendering takes about 0.16 s per image for EXR scenes. Decoding full-resolution RAW photos makes real scenes slower unless output.resize_inputs is on. Scaled to full training splits (estimates):
| Split | Images | CPU time | With --workers 16 |
Disk |
|---|---|---|---|---|
| Infinigen train | 1.62 M | ~72 core-hours | ~4.5 h | ~1.1 TB |
| BlenderKit train | 75 K | ~3.4 core-hours | ~15 min | ~45 GB |
| Real train (exact / fast) | 23 K | ~11 / ~1.6 core-hours | ~40 / ~6 min | ~37 GB |
Peak memory per worker is under 0.5 GB for synthetic scenes and about 3.2 GB for full-resolution real captures. Use pairs.per_light, pairs.max_per_scene, pairs.target_views or output.max_side to make the output smaller and faster to produce.