| # UE4-Stereo — acquisition and example scripts |
|
|
| Scripts used to generate the [UE4-Stereo](https://huggingface.co/datasets/yanmorona/UE4-Stereo) |
| dataset in Unreal Engine 4.27 with Microsoft AirSim, plus a small example |
| showing how to read a sequence. |
|
|
| | File | Purpose | |
| |---|---| |
| | `settings.json` | AirSim configuration: camera resolution, field of view and initial rig placement | |
| | `acquire_stepwise.py` | Acquisition for Scenes 1 and 2 stop at each waypoint, rotate in place, proceed | |
| | `acquire_continuous.py` | Acquisition for Scenes 3 and 4 continuous velocity with rate-limited heading | |
| | `load_sequence.py` | Example loader: reads images, depth, poses and camera parameters | |
|
|
| ## Requirements |
|
|
| ``` |
| airsim numpy opencv-python matplotlib |
| ``` |
|
|
| `settings.json` goes in `Documents/AirSim/` (Windows) or `~/Documents/AirSim/` |
| (Linux) before starting the simulator. The acquisition scripts connect to a |
| simulator that is already running. |
|
|
| ## Why two acquisition scripts |
|
|
| The two groups of scenes were captured with different motion strategies, which |
| is the source of their different trajectory characteristics. |
|
|
| `acquire_stepwise.py` commands the vehicle through successive position and |
| heading targets. It flies to a waypoint, stops, rotates in place towards the |
| next heading, and only then proceeds, so heading changes are concentrated in |
| pure-rotation segments. |
|
|
| `acquire_continuous.py` drives the vehicle with continuous velocity commands, |
| interpolating the heading along each segment and limiting it to a maximum yaw |
| rate, so the vehicle never stops. It also runs capture and disk writing in |
| separate threads, which keeps the sampling rate stable at the requested value. |
| The stepwise script writes frames in the capture loop itself, so its achieved |
| rate is lower than the nominal one, roughly 3 Hz with the default settings. |
|
|
| ## Usage |
|
|
| ```bash |
| # Scene 1, sequence01: centred route, 24 cm baseline, parallel cameras |
| python acquire_stepwise.py --output scene_1/sequence01 \ |
| --route route_a_dir1 --baseline 0.24 |
| |
| # Scene 1, sequence05: 32 cm baseline |
| python acquire_stepwise.py --output scene_1/sequence05 \ |
| --route route_a_dir1 --baseline 0.32 |
| |
| # Scene 1, sequence07: converging cameras, 5 degrees inward each |
| python acquire_stepwise.py --output scene_1/sequence07 \ |
| --route route_a_dir1 --baseline 0.24 --convergence 5 |
| |
| # Scene 3, sequence01: same route, continuous motion at 10 Hz |
| python acquire_continuous.py --output scene_3/sequence01 \ |
| --route route_a_dir1 --baseline 0.24 --rate 10 |
| ``` |
|
|
| Reading a sequence back: |
|
|
| ```bash |
| python load_sequence.py --sequence scene_1/sequence01 |
| python load_sequence.py --sequence scene_1/sequence05 --baseline 0.32 --show 0 |
| ``` |
|
|
| Run any script with `--help` for the full list of options, including |
| `--depth-visual`, which additionally writes 8-bit depth previews. Those |
| previews are not metric and are provided in the published dataset for Scenes 1 |
| and 2 only; the metric `.npy` arrays are available for all sequences. |
|
|
| ## Routes |
|
|
| Both scripts define the same eight routes, following the pattern |
| `route_{a|b}_dir{1|2}[_offset]`: |
|
|
| - `route_a` and `route_b` are the two loop geometries. |
| - `dir1` and `dir2` traverse the same loop in opposite directions. |
| - `_offset` marks the laterally displaced variants. In `route_b` these are also |
| flown 0.5 m higher. |
|
|
| The waypoint coordinates of `route_b` differ slightly between the two scripts, |
| reflecting the adjustments made between the two acquisition campaigns; each |
| script carries the values used for its own scenes. |
|
|
| Waypoints are `(x, y, z, yaw)` in the AirSim world frame: metres, `z` negative |
| upwards, yaw in degrees. |
|
|
| ## Output format |
|
|
| Each run produces one sequence directory: |
|
|
| ``` |
| sequence01/ |
| left_rgb/000000.png ... 8-bit BGR, 640x480 |
| right_rgb/000000.png ... 8-bit BGR, 640x480 |
| depth_npy/000000.npy ... float32 planar depth in metres |
| depth_visual/000000.png ... optional 8-bit preview, not metric |
| groundtruth.txt timestamp tx ty tz qx qy qz qw |
| associate_rgb.txt left/right pairing |
| associate_rgbd.txt left/depth pairing |
| ``` |
|
|
| Left image, right image, depth array and pose of a frame share a single |
| timestamp, so no temporal interpolation is needed to align them. |
|
|
| ## Camera model and reference frames |
|
|
| The virtual cameras are ideal pinhole cameras with no lens distortion, so their |
| intrinsics are exact by construction rather than estimated by calibration: |
|
|
| ``` |
| fx = fy = (W / 2) / tan(hFOV / 2) = 320.0 px for 640x480 at 90 degrees |
| cx, cy = 320.0, 240.0 px |
| ``` |
|
|
| Depth is planar measured along the optical axis, not radially so depth and |
| disparity are related by `Z = fx * B / d`. A depth of exactly `0.0` marks an |
| invalid pixel. |
|
|
| `groundtruth.txt` follows the TUM RGB-D convention. The recorded pose is that |
| of the vehicle body frame, expressed in the AirSim world frame: right-handed |
| North-East-Down, in metres, with the origin at the spawn point. This differs |
| from the native Unreal Engine world frame, which is left-handed and in |
| centimetres. |
|
|
| To obtain the left camera optical frame, compose the recorded pose with the rig |
| extrinsics: a translation of `(1.00, -B/2, 0.10)` m in the body frame followed |
| by a `-23°` pitch rotation. Use `+B/2` for the right camera. With |
| `--convergence C`, the left camera additionally yaws by `+C` and the right by |
| `-C`, toeing them inwards. |
|
|
| ## Reproducibility |
|
|
| The scenes are static and the acquisition involves no stochastic component or |
| random seed, so trajectories are geometrically repeatable across runs. Frame |
| capture is paced against wall-clock time while the simulator runs in real time, |
| so the exact number of frames recorded along a given route varies slightly with |
| host load. This is why otherwise equivalent sequences differ by a few frames. |
|
|
| The published sequences were generated on a laptop with an Intel Core i7-10750H, |
| 32 GB of RAM and an NVIDIA RTX 2070 Max-Q, taking roughly three minutes per |
| sequence. |
|
|
| Two notes on `settings.json`. The `Pitch` values it declares for the cameras are |
| overridden at runtime by the acquisition scripts, which set the rig pose through |
| `simSetCameraPose`. The scripts are the authoritative source for the extrinsics. |
|
|
| ## Citation |
|
|
| ```bibtex |
| @misc{morona2026ue4stereo, |
| author = {Morona, Yan Medeiros and Pinto, Tiago Loureiro Figaro da Costa and Regner, Daniel Juchem}, |
| title = {UE4-Stereo: A Photorealistic Synthetic Stereo Dataset with Ground-Truth Depth and 6-DoF Poses}, |
| year = {2026}, |
| publisher = {Hugging Face}, |
| doi = {10.57967/hf/8959}, |
| url = {https://huggingface.co/datasets/yanmorona/UE4-Stereo} |
| } |
| ``` |
|
|
