PholyPeng/GenRec4D-CALRA

GenRec4D

GenRec4D is a synthetic driving dataset rendered with the CARLA simulator (0.9.16) for dynamic-scene reconstruction and novel view synthesis. Each scene is a 5-second clip from a car driving through traffic, captured by a Waymo-style rig of three forward-facing cameras. Every frame comes with RGB, metric depth, surface normals, a sky mask, exact camera poses and a point cloud. Each scene also includes 8 extra camera trajectories (shifted and rotated copies of the front camera), rendered at the same moments with the same moving vehicles, so novel-view renderings can be scored against real images.

At a glance

Scenes	10 (CARLA Town01–Town05, two each)
Clip length	50 frames at 10 Hz (5 s)
Main cameras	3: front, front-left (−45°), front-right (+45°)
Novel-view cameras	8 per scene (lateral shifts, yaw rotations, both)
Resolution	1920 × 1280, horizontal FOV 49.97°, f = 2060.143 px
Per frame and camera	RGB, metric depth, world-space normals, sky mask
Per frame	ego pose, calibration, point cloud from depth
Dynamic content	24–39 vehicles per scene on autopilot
Size	about 75 GB, about 37,000 files (about 7.5 GB per scene)
Format	Waymo / KITTI-style layout, directly loadable by DeSiRe-GS

Scenes

The same table is in scenes.csv and scenes.json.

scene_id	Town	Weather	Vehicles	Ego displacement
scene_00_Town01	Town01	Clear Noon	32	11.9 m
scene_01_Town02	Town02	Cloudy Noon	25	26.8 m
scene_02_Town03	Town03	Light Rain Noon	31	40.1 m
scene_03_Town04	Town04	Cloudy Noon	39	40.0 m
scene_04_Town05	Town05	Clear Noon	24	31.3 m
scene_05_Town01	Town01	Clear Sunset	34	32.9 m
scene_06_Town02	Town02	Clear Sunset	27	29.2 m
scene_07_Town03	Town03	Clear Noon	35	11.0 m
scene_08_Town04	Town04	Cloudy Noon	38	65.6 m
scene_09_Town05	Town05	Cloudy Night	31	13.2 m

"Vehicles" is the number of other cars spawned in the scene, not the number visible. "Ego displacement" is the straight-line distance between the first and last frame. scenes.csv also has the driven path length.

Repository layout

README.md
scenes.csv / scenes.json          scene index (town, weather, traffic, ego motion, size)
preview/                          contact sheets and side-by-side videos for browsing
  towns_front_grid.jpg            front camera, frame 25, all scenes
  all_scenes_3cam.jpg             three main cameras, frame 25, all scenes
  all_scenes_time_strip.jpg       front camera at frames 1/13/25/37/50, all scenes
  all_scenes_data_types.jpg       RGB / depth / normals / sky / point cloud, all scenes
  novel_views/<scene>_views.jpg   original + all 8 novel views, frame 25
  shift_videos/<scene>_shift.mp4  left 2 m | left 1 m | original | right 1 m | right 2 m
scenes/<scene_id>/
  image_{0,1,2}/0000001.png …     RGB
  depth_{0,1,2}/0000001.npy …     depth in metres (float32), plus a 16-bit .png copy in mm
  normal_{0,1,2}/0000001.jpg …    world-space surface normals
  sky_{0,1,2}/0000001.png …       sky mask
  pose/0000001.txt …              ego → world, 4×4
  calib/0000001.txt …             intrinsics and ego → camera extrinsics
  velodyne/0000001.bin …          point cloud back-projected from the three depth maps
  NVS/<mode>/<view>/              8 novel-view cameras (see below)
  videos/rgb.mp4, depth.mp4       three cameras side by side (left | front | right)
  meta.json                       camera rig definition
  report.json                     frame count, timing and per-camera image statistics
  carla_sequence.json             CARLA version, map, weather parameters, simulation settings, actors
  carla_recording.log             CARLA recorder log of the whole clip (replayable)
  trajectory.csv                  ego pose at every simulation step

Frames are numbered 0000001 to 0000050. The same number means the same instant in every folder, including all novel views.

Cameras

Index	Name	Yaw	Position on the car
0	front	0°	x = 0, y = 0, z = 2.40 m
1	front-left	−45°	same
2	front-right	+45°	same

All three cameras share one optical centre, 2.40 m above the ego origin, and are pitched down 3°. They use identical pinhole intrinsics with no distortion:

K = [[2060.143, 0,        960],
     [0,        2060.143, 640],
     [0,        0,        1  ]]

File formats

RGB (image_k/*.png): 1920 × 1280, 8-bit RGB.

Depth (depth_k/*.npy): 1280 × 1920 float32 in metres. This is planar depth (the z coordinate in the camera frame), not the distance along the ray. Sky and anything farther than 1000 m read as 1000 m. The .png next to each .npy stores the same depth as uint16 millimetres, so it saturates at 65.535 m; use the .npy when you need real depth.

Normals (normal_k/*.jpg): world-space unit normals encoded as n = rgb / 127.5 − 1, read in R, G, B order to get world x, y, z (z is up, so a flat road reads about (0, 0, 1)). JPEG, quality 95, so values are slightly lossy.

Sky mask (sky_k/*.png): single-channel uint8, 255 = sky (CARLA semantic class 11), 0 = anything else.

Pose (pose/*.txt): 4 × 4 ego → world matrix. The ego origin is CARLA's vehicle origin, which is at ground level.

Calibration (calib/*.txt): 11 lines in the format DeSiRe-GS's Waymo loader expects:

Line	Meaning
P0 … P4	3 × 4 projection [K | 0], row-major; identical for all cameras
R0_rect	3 × 3 identity
Tr_velo_to_cam_0 … _2	3 × 4 ego → camera transform for cameras 0, 1, 2, row-major
Tr_velo_to_cam_3, _4	copies of camera 2, padding for the 5-camera format

The calibration is the same in every frame because the rig is rigid. It's repeated per frame for loader compatibility.

Point cloud (velodyne/*.bin): float32, N × 6. Columns 0–2 are x, y, z in the ego frame (metres), and columns 3–5 are zero. Points come from back-projecting every 8th pixel of the three depth maps, keeping depths between 0.5 m and 400 m. This is not a simulated LiDAR: it has the cameras' field of view and no returns behind the car.

Trajectory (trajectory.csv): frame, x, y, z, roll, pitch, yaw, with the ego position in metres and angles in degrees, in CARLA world coordinates. There's one row per simulation step (30 Hz), so it's 3× denser than the exported frames. frame is CARLA's internal frame counter.

Videos (videos/*.mp4, and rgb.mp4 / depth.mp4 inside each novel-view folder): MPEG-4 Part 2 at 10 fps, meant for quick viewing. Some browsers won't play this codec; the H.264 videos in preview/ play everywhere. The depth videos are colour-mapped from 0 to 120 m.

Coordinate frames

Frame	Axes	Notes
World	CARLA world, metres, z up	Unreal Engine convention, so the world is left-handed
Ego	x forward, y right, z up	CARLA's native vehicle frame; Waymo's ego frame has y pointing left
Camera	x right, y down, z forward	OpenCV convention, consistent with K

The matrices are consistent with each other. To get a camera-to-world matrix:

cam_to_world_k = pose @ inverse([Tr_velo_to_cam_k ; 0 0 0 1])

A pixel (u, v) with depth d in camera k is at cam_to_world_k @ [(u − 960) d / f, (v − 640) d / f, d, 1] in world coordinates. Projecting world points works the other way round: K @ (Tr_velo_to_cam_k @ inverse(pose) @ X).

Handedness. pose has determinant +1, but Tr_velo_to_cam_k and cam_to_world_k have determinant −1, because the y-right ego frame is a mirror image of the right-handed camera frame. Projection and back-projection with the formulas above are correct as they are. If your code needs proper rotations (for example, converting to quaternions, as most 3D Gaussian splatting code does), flip the y axis everywhere with F = diag(1, −1, 1, 1):

pose_rh  = F @ pose @ F                  # ego → world, ego frame becomes x forward, y left, z up (Waymo)
Tr_rh_k  = Tr_velo_to_cam_k @ F          # ego → camera
cam_to_world_rh_k = pose_rh @ inverse(Tr_rh_k)    # = F @ cam_to_world_k, determinant +1

All three then have determinant +1, and the world becomes right-handed (CARLA world with y negated). Apply the same flip to anything else in world or ego coordinates: negate y of velodyne points, of world-space normals, and of positions in trajectory.csv. The roll/pitch/yaw angles in trajectory.csv follow CARLA's own convention, so take orientations from pose/ instead.

Loading example

Back-project the front camera's depth into a coloured world-space point cloud:

import numpy as np
from PIL import Image

scene = "scenes/scene_02_Town03"
frame = "0000001"

def read_calib(path):
    calib = {}
    for line in open(path):
        key, vals = line.split(":", 1)
        calib[key] = np.array(vals.split(), dtype=np.float64)
    return calib

calib = read_calib(f"{scene}/calib/{frame}.txt")
K = calib["P0"].reshape(3, 4)[:, :3]                     # same for all cameras
ego_to_cam = [np.vstack([calib[f"Tr_velo_to_cam_{k}"].reshape(3, 4), [0, 0, 0, 1]])
              for k in range(3)]                          # 0 front, 1 front-left, 2 front-right
ego_to_world = np.loadtxt(f"{scene}/pose/{frame}.txt")    # 4x4
cam_to_world = [ego_to_world @ np.linalg.inv(T) for T in ego_to_cam]

rgb = np.asarray(Image.open(f"{scene}/image_0/{frame}.png"))    # (1280, 1920, 3) uint8
depth = np.load(f"{scene}/depth_0/{frame}.npy")                   # (1280, 1920) float32, metres
sky = np.asarray(Image.open(f"{scene}/sky_0/{frame}.png")) > 0    # True = sky

# back-project the front camera to world points
v, u = np.nonzero(~sky)
z = depth[v, u]
pts_cam = np.stack([(u - K[0, 2]) / K[0, 0] * z, (v - K[1, 2]) / K[1, 1] * z, z, np.ones_like(z)])
pts_world = (cam_to_world[0] @ pts_cam)[:3].T                     # (N, 3)
colors = rgb[v, u]

To train DeSiRe-GS on a scene, point --source_path at scenes/<scene_id> and use --cam_num 3. Add --load_normal_map to use the normals.

Novel views

Each scene has 8 extra cameras attached to the ego car, defined relative to the front camera. They share its height (2.40 m), pitch (−3°) and intrinsics.

Folder	Lateral offset	Yaw
NVS/shift/y_left_2.00m	2.0 m left	0°
NVS/shift/y_left_1.00m	1.0 m left	0°
NVS/shift/y_right_1.00m	1.0 m right	0°
NVS/shift/y_right_2.00m	2.0 m right	0°
NVS/rotate/yaw_left_20deg	0	20° left
NVS/rotate/yaw_right_20deg	0	20° right
NVS/shift_rotate/y_left_1.00m_yaw_left_15deg	1.0 m left	15° left
NVS/shift_rotate/y_right_1.00m_yaw_right_15deg	1.0 m right	15° right

Each view folder uses the single-camera version of the main layout: image_0/, depth_0/, normal_0/, sky_0/, pose/, calib/, plus meta.json with the view's offsets, intrinsics and ego → camera transform. pose/ is the same ego pose as the main sequence, and Tr_velo_to_cam_0 in calib/ is this view's extrinsic, so cam_to_world = pose @ inverse(Tr_velo_to_cam_0) works unchanged. Novel views have no point clouds.

How they were rendered. After the main pass, the simulation was frozen. For every frame, the ego car and every other vehicle were moved back to their recorded poses and the 8 cameras rendered that instant. Moving vehicles are therefore in the same place in a novel view as in the main cameras at the same frame number. We checked this by reprojecting main-camera depth into the novel views. Because the novel views come from a separate render pass, auto-exposure and other screen-space effects may differ slightly from the main cameras.

How the data was generated

• Simulator: CARLA 0.9.16, Epic quality, off-screen rendering, synchronous mode with a fixed 1/30 s step. The cameras capture every third step, giving 10 Hz.
• Maps and weather: Town01–Town05, two scenes each. Weather comes from CARLA's presets: Clear, Cloudy or Light Rain at noon, Clear Sunset, and one Cloudy Night scene. The full weather parameters for each scene are in carla_sequence.json.
• Ego car: a Tesla Model 3 driven by CARLA's Traffic Manager autopilot. It obeys traffic lights.
• Traffic: 24–39 vehicles of random models, also on autopilot. A few are placed on the lanes ahead of the ego car (same direction and oncoming, 25–100 m ahead), and the rest at the nearest spawn points. All are at least 20 m from the ego car and 12 m from each other, so nothing collides at spawn time. There are no pedestrians.
• Warm-up: traffic runs for 3 s before the first exported frame, so cars are already moving when the clip starts.
• Quality checks: a clip was re-recorded from a different spawn point if the ego car moved less than 5 m, or if any output file failed to decode. All files in this release decode.

Limitations

• Synthetic data with CARLA's rendering and assets; there is a domain gap to real camera footage.
• Only 10 short clips. Scenes 00, 07 and 09 cover only 11–13 m of ego motion.
• No pedestrians, cyclists or animated objects other than vehicles and traffic lights.
• The night scene (scene_09) is dark and low-contrast.
• Depth PNGs saturate at 65.5 m and normals are 8-bit JPEG; use the .npy depth for exact values.
• The point clouds come from depth, not from a LiDAR model.
• CARLA's world frame is left-handed and the extrinsics have determinant −1. Code that assumes Waymo's y-left ego frame or needs proper rotations should apply the flip in "Coordinate frames".

Replaying a scene in CARLA

carla_recording.log is a CARLA recorder file covering the whole clip, starting about 1 s before the first exported frame. With CARLA 0.9.16 you can replay it with client.replay_file(...) on the same map, for example to render extra sensors. carla_sequence.json lists the map, simulation step, camera rig, weather, and each actor's blueprint and transform at the end of the clip.

License and attribution

This dataset is released under the MIT License. The images are rendered from CARLA's maps and vehicle assets, which the CARLA project distributes under CC BY 4.0. If you use this data, please also credit CARLA:

@inproceedings{Dosovitskiy17,
  title     = {{CARLA}: {An} Open Urban Driving Simulator},
  author    = {Alexey Dosovitskiy and German Ros and Felipe Codevilla and Antonio Lopez and Vladlen Koltun},
  booktitle = {Proceedings of the 1st Annual Conference on Robot Learning},
  pages     = {1--16},
  year      = {2017}
}