DyRAD/dyrad-synthetic

DyRAD Synthetic Radar Benchmark

Paper (arXiv) · Project page · Code

The synthetic off-path benchmark of DyRAD: Radar Novel View Synthesis for Dynamic Driving Scenes. A real driving recording covers one trajectory per scene, so a view rendered away from it has no ground truth. This benchmark renders each of five synthetic driving scenes from the driven (training) trajectory and from five off-path views (three laterally shifted paths and two sensor yaws), which gives ground-truth range–azimuth–Doppler (RAD) radar tensors for novel views away from the driven path.

The benchmark is fully synthetic and contains no RADIal or Boreas data. Its tensors follow the layout of the RADIal radar, so the DyRAD code reads it exactly as it reads RADIal sequences.

Contents

5 scenes × 6 views × 40 frames (0.1 s apart) = 1,200 frames.

Scene	Description
urban_canyon	Slow urban street between specular building facades, with parked cars and two slow movers: dense, strongly view-dependent static structure.
open_road_sparse	Fast open road with a few roadside poles, one distant sign and one fast oncoming vehicle: sparse static support, and radial speeds that wrap around the Doppler axis many times.
curve_ramp	Constant-radius left-hand curve with guardrails, two poles and one oncoming vehicle: the only scene with a curved ego path.
intersection	Ego braking from 14 m/s into a junction with two crossing vehicles: their radial velocity combines the decelerating ego's motion with their own, whose line-of-sight component passes through zero as they cross in front of the ego, so their Doppler drifts across several wraps within the sequence.
dual_carriageway	Divided highway at 28 m/s with a median barrier, sign gantries (bright point reflectors on the right shoulder), a stopped vehicle and three same-direction movers.

Views per scene:

• base: the training trajectory.
• lat-1.75, lat+1.75, lat+3.5: the same path shifted laterally by that many metres (positive = left of the direction of travel; on the curve the shift follows the path).
• yaw+5, yaw+10: the base path with the sensor rotated by that many degrees to the left.

Frame i of every view shows the same world state (static scene and moving objects at the same time instant); only the sensor pose differs.

Sensor and tensor format

• Tensor: [D=16, R=512, A=751] float32, linear amplitude (not power) in arbitrary units; take a log for display.
• Range: bin b is at b × 0.2012 m (103 m over 512 bins). Reflectors are rendered between 10 m and 92.7 m; the method's configs crop range bins 15–461.
• Azimuth: −75° to +75° in 0.2° steps; positive azimuth is to the left.
• Doppler: 16 bins of 0.1123 m/s, so radial velocity wraps every 1.797 m/s (as on the real sensor, nearly every return in a driving scene is aliased). Bin 0 is zero velocity, bins 1–7 are +0.11 to +0.79 m/s and bins 8–15 are −0.90 to −0.11 m/s; positive = receding. The tensor is not ego-motion compensated.
• Coordinates: the world frame is the sensor frame of the base view's first frame: x forward, y left, z up.

Load with 🤗 Datasets

Two configurations hold the same 1,200 frames. In both, train is the 200 base-view frames and test the 1,000 off-path frames.

• frames (default, small): every column below except the tensor, plus a preview image and the path of the tensor file. This is what the dataset viewer shows.
• rad: the same columns plus the full RAD tensor, without the preview and path (about 24.6 MB per frame, 29.5 GB in total). Load one scene and view at a time (one Parquet file, about 1 GB).

Both configurations require datasets 4.0 or newer.

The repository also holds the original .npy files used by the code (below), so the whole repository is about 59 GB; download only what you need.

from datasets import load_dataset

frames = load_dataset("DyRAD/dyrad-synthetic", split="test")  # small, no tensors

# Full tensors of one scene and view
rad = load_dataset("DyRAD/dyrad-synthetic", data_files={"train": "rad/intersection/base.parquet"},
                   split="train").with_format("numpy")
rad[0]["rad"].shape  # (16, 512, 751)

Column	Type	Description
scene, view	string	Scene and view name (see above).
frame	int32	Frame index, 0–39.
time_s	float32	frame × 0.1 s.
lateral_offset_m	float32	Lateral shift of the view (0 for base and the yaw views).
yaw_offset_deg	float32	Sensor yaw of the view (0 for base and the lateral views).
sensor_to_world	float64 [4, 4]	Sensor-to-world transform of this frame.
ego_velocity_mps	float32 [2]	Ego velocity in this frame's sensor frame (x forward, y left), m/s.
objects	list	Moving vehicles whose centroid is within 10–90 m and ±75°: name, x_m, y_m, z_m (centroid in the sensor frame), range_m, azimuth_deg, and doppler_fft_bin, the centroid's radial velocity as an index k on the 256-point Doppler FFT axis (k ≥ 128 stands for (k − 256) × 0.1123 m/s, otherwise k × 0.1123 m/s; receding positive; aliased beyond ±14.4 m/s, which applies to the oncoming vehicles in open_road_sparse and curve_ramp and, because of the ego's own speed, to the crossing vehicles in intersection).
ra_preview	image	frames only. Range–azimuth view for browsing: log10 of the mean over Doppler, range bins 15–461 with far range at the top and the sensor's left on the left, viridis colour map with one fixed scale for all frames (1st–99.9th percentile of the base views). Not for evaluation.
rad_path	string	frames only. Path of the frame's .npy tensor in this repository.
rad	float32 [16, 512, 751]	rad only. The RAD tensor, identical to the .npy file.

Use with the DyRAD code

The <scene>/<view>/ folders are the benchmark as the code reads it. They are the files written by python -m dyrad.synthetic.prepare in the code repository (commit e952e90). Generation is deterministic (seed 42), so you can also regenerate them instead of downloading. To download them into the code's data directory:

git clone https://github.com/Dyrad-NVS/DyRAD && cd DyRAD
hf download DyRAD/dyrad-synthetic --repo-type dataset --exclude "frames/*" --exclude "rad/*" \
    --local-dir data/synthetic
python -m dyrad.train --config configs/synthetic/intersection_dyrad.yaml
python -m dyrad.evaluation.evaluate_offpath_synthetic --config configs/synthetic/intersection_dyrad.yaml \
    --views data/synthetic/intersection

Each view folder follows the layout of a processed RADIal sequence:

<scene>/<view>/
  rad_tensors/rad_00000.npy ... rad_00039.npy   RAD tensors (format above)
  range_bins_m.npy, az_bins_deg.npy, doppler_bins_mps.npy   axes of the tensor
  rd_doppler_bins_mps.npy   the 256-point Doppler FFT axis, centred: bin k of labels_CVPR.csv is
                            entry (k + 128) % 256
  poses/, poses_can/   radar_poses.npy: [40, 4, 4] sensor-to-world (the two folders are identical),
                       and poses_metadata.json (frame count, dt, initial ego speed, frame indices)
  ego_vel_can.npy   [40, 2] ego velocity in the sensor frame, m/s
  labels_CVPR.csv   moving-vehicle centroids in RADIal's label format, one row per vehicle and frame:
                    the pixel box columns are 0 (there is no camera), laser_X_m / laser_Y_m repeat
                    radar_X_m / radar_Y_m, laser_Z_m is the centroid height, radar_D_mps holds the
                    256-point Doppler FFT bin index, not m/s, RADIal's radar_P_db column is absent,
                    and an extra vehicle_id column names the vehicle
  label_index_remap.npy   identity frame-index map
  scene_gt.json   the scene's ground-truth point reflectors (identical in all views of a scene)
  norm.json   amplitude normalization used by the trainer (one range shared by all scenes;
              off-path views inherit the base view's file)

base/ also holds the initial point clouds built from the radar tensors, each with a .build.json record: radar_cloud_f0_39_full_1m_free_psf1.npy (with its .partition.json) for DyRAD and radar_cloud_f0_39_full_1m.npy for its static-only variant.

Generation

Each scene is a set of point reflectors (barriers, walls, poles, corner reflectors and vehicles on constant-velocity or constant-acceleration tracks) defined in dyrad/synthetic/scenes/. Every reflector is rendered into the RAD tensor through the sensor's range, azimuth and Doppler point-spread functions, with view-dependent specular gain, and spatially correlated log-normal background clutter is added. Off-path views re-render the same scene with the same random seed from a different sensor trajectory.

Limitations

The forward model is a simplified point-reflector simulator. It has no occlusion and no multipath: every reflector in the field of view and the 10–92.7 m window contributes, scaled by its beam and specular gain. The background clutter is drawn from the same random field in every view of a scene and is fixed to the tensor grid rather than the world: it is identical in the lateral views of the straight scenes, while in the yaw views and on curve_ramp its Doppler weighting differs. Off-path scores therefore measure how well a method extrapolates the geometry and motion of a scene under this simulator, not realism with respect to a real radar.

Intended use

Evaluating radar novel view synthesis away from the driven trajectory: fit a model to the base view of a scene and compare its renders at the off-path views with the ground-truth tensors.

Citation

@article{keidar2026dyrad,
  title         = {DyRAD: Radar Novel View Synthesis for Dynamic Driving Scenes},
  author        = {Keidar, Merav and Borreda, Tomer and Nandakumar, Rajalakshmi and Litany, Or},
  journal       = {arXiv preprint arXiv:2609.39841},
  year          = {2026},
  eprint        = {2609.39841},
  archivePrefix = {arXiv},
  url           = {https://arxiv.org/abs/2609.39841}
}

License and contact

The data are released under CC BY 4.0. The generator code (Dyrad-NVS/DyRAD) is MIT-licensed. Questions and issues: GitHub issues.