anhdao69/uav_ugv_pilot

UAV–UGV Active QA & Navigation — pilot demo (CARLA-Air, Town10HD)

Two recorded demonstration episodes for an active air–ground question-answering and navigation benchmark. A drone (UAV) and a ground vehicle (UGV) answer a visual question that neither robot can answer alone from its starting view. Then the UGV drives to a safe inspection position in front of the answer object and stops.

SCRIPTED ORACLE DEMO. The robots follow a fixed route written from the episode's private ground truth. This is an engineering reference that shows the task is solvable with real controllers in the simulator. It is not a trained or learned policy, and no agent inputs are simulated.

Question (both episodes): "Among the two white cars next to the blue truck, which one has its headlights on—the closer or farther car? Navigate the UGV to that car."

	Use case 1 · uc1_blue_truck_far_group	Use case 2 · uc2_blue_truck_near_group
Scene	blue truck in the far parking group	truck colours exchanged: blue truck in the near group
Headlights	identical in both: one lit car in each group	identical in both
Answer / target	farther / A_far	closer / B_near
What the UAV contributes	finds the blue truck 60 m ahead; the UGV can't see it from its start	finds the blue truck right beside the UGV
What the UGV contributes	drives past a lit car in the red-truck group (a distractor), checks the lights of the blue-truck group, stops in front of the lit car	merges in, checks the lights, backs up 2 m to an inspection position
Result (private evaluator)	✓ joint success: answer ✓, stopped 0.05 m from a validated inspection position	✓ joint success: answer ✓, stopped 0.31 m from a validated inspection position
Highlight video	25.6 s (travel at 2.5×, labelled)	29.6 s (real time)

Why two use cases. Both episodes have the same street, the same robot starts and the same headlight states. Only the truck colours differ, and the UAV resolves those from the air. That one aerial fact sends the UGV to a different group. The lit car that is the answer in use case 1 becomes the distractor in use case 2. Headlight state is resolved up close by the UGV; from 35 m the UAV can't read it.

Videos

Use case 1: blue truck in the far group

Use case 2: blue truck in the near group

Each use case folder has these videos (H.264), all real simulator footage:

File	Content
videos/showcase_all_views.mp4	1920×1080 composite of UAV + UGV + top-down. Shows the question, phase (UAV SEARCHING → UGV INSPECTING → ANSWER FOUND → NAVIGATING → TASK SUCCESS), the answer only after the evidence frames exist, the final metrics, and a SCRIPTED ORACLE DEMO label. Edited highlight of 20–30 s: travel may be sped up, and the speed is always labelled on screen.
videos/showcase_all_views_realtime.mp4	The same composite at the original real-time timing (full length)
videos/uav.mp4	UAV camera (1280×720, real time)
videos/ugv.mp4	UGV first-person camera (1280×720, real time)
videos/topdown.mp4	Independent world-fixed top-down camera (1920×460, real time) with both robots, labels and trajectory trails. This camera is not a robot sensor.
videos/video_sync.json	For every frame of the real-time videos: sim time, and the source sim frame and time offset of each stream. For the highlight: the sim time and playback speed of every output frame.

uav.mp4, ugv.mp4, topdown.mp4 and showcase_all_views_realtime.mp4 share one 10 fps timeline. Frame k of each shows the recorded frame nearest the same sim time; the largest offset is 75 ms, under one camera period. The cameras run at 10 Hz and no frames are interpolated.

Overlay labels (truck colours, target box, valid stop positions, "lit car · other group (ignored)") are drawn from the episode's ground truth and recorded trajectories, to help viewers. The target and distractor labels appear only after the answer is found.

Folder layout (per use case)

uc1_blue_truck_far_group/            (uc2_blue_truck_near_group/ has the same layout)
├── videos/                          showcase_all_views.mp4, uav.mp4, ugv.mp4, topdown.mp4,
│                                    showcase_all_views_realtime.mp4, video_sync.json
├── episode/
│   ├── task.json                    policy-visible task: question, answer options, action space, budget, camera calibration
│   ├── graph.json                   policy-visible viewpoint graph (UGV lane lattice + UAV viewpoints, opaque node ids)
│   └── ground_truth.json            PRIVATE: answer, target, full scene config, validated inspection positions,
│                                    tolerances, spawned actor ids, background-actor specs
├── trajectories/
│   ├── robots.csv                   every simulator tick: t_sim, UAV and UGV x y z yaw pitch roll vx vy vz speed
│   ├── dynamic_actors.csv           every tick: background car and pedestrian x y z yaw vx vy vz speed
│   └── trajectory.jsonl             the raw per-tick log (same data)
├── observations/                    camera snapshots taken by the robots at each step (PNG, 1280×720)
│   └── observations.jsonl           per snapshot: sim time and frame, camera pose, robot pose, intrinsics, producing action
├── oracle_actions.json              the scripted oracle route (plan) and what was executed: phase, action, start/end time,
│                                    controller outcome, position error, resulting snapshot, evidence used for the answer
├── evaluation.json                  private evaluator output (joint success and every condition with its reason)
├── verification.json                pre-publication checks (see below)
└── logs/                            actions, every controller command (controls.jsonl), decisions, collisions,
                                     background-actor collisions and control events, evidence checks,
                                     final state, timing, top-down camera pose, run manifest (versions, file hashes)

Coordinates. CARLA world frame: metres, x forward, y right, z up; yaw in degrees. UAV velocity is computed by finite differences, because the drone's CARLA actor reports zero velocity. t_sim is simulator time in seconds.

The episode

• Map: Town10HD, the straight west street (road 10, x ∈ [−25, 65] m). Fixed lighting: sun altitude 15°, 30% cloud.
• Objects: two curb-side parking groups, each with one truck and two white vehicle.lincoln.mkz_2020. Every vehicle faces −x.
  • Group B is first along the street, group A second.
  • Trucks are vehicle.carlamotors.european_hgv, blue 20,60,200 or red 200,25,25.
  • Lit headlights mean the light state LowBeam|Position.
• Robots:
  • UGV: vehicle.mini.cooper_s_2021, driven by pure-pursuit plus speed control through VehicleControl.
  • UAV: AirSim SimpleFlight multirotor with a −40° camera, flown with moveToPositionAsync.
  • There is no teleporting while the episode runs.
• Background actors (both use cases):
  • An orange vehicle.tesla.model3 drives +x in a lane the UGV never uses, at a constant 3.5 m/s under physics, then brakes to a stop at the end of the street.
  • A pedestrian walks along the far sidewalk at 1.3 m/s.
  • Both are logged every tick.
• Oracle route (from oracle_actions.json):

Step	Phase	UC1 action → result	UC2 action → result
0	UAV SEARCHING	UAV → u_022 (x 25, 18 m high), 21.1 s	UAV → u_016 (x −20, 18 m high), 10.9 s
1	UGV INSPECTING	UGV → g_023 (13 m in front of the group), 14.3 s, 0.04 m error	UGV → g_008 (merge, 8 m in front), 6.3 s, 0.07 m error
2	ANSWER FOUND → NAVIGATING	answer farther; UGV → g_024, 3.4 s, 0.05 m error	answer closer; UGV backs up → g_007, 3.6 s, 0.31 m error
3	FINISH → TASK SUCCESS	submit farther, evidence uav_0001, ugv_0001, ugv_0002	submit closer, same evidence ids

Evaluation and verification

Evaluator rule (from the benchmark): joint success = correct answer ∧ valid inspection of the target ∧ within budget (10 actions, 240 s) ∧ no collision.

What counts as a valid inspection. It is judged from the final recorded state:

• the UGV is stopped (≤ 0.1 m/s);
• it is within 1.0 m and 12° of any validated inspection position of the target;
• a co-mounted instance-segmentation camera sees at least 50% of the target's headlamp points, unoccluded, within 12.5 m.

verification.json records these checks, all passing in both use cases:

Check	UC1	UC2
Robots really move: per-tick motion with no jumps	UGV 42.0 m, max 3.8 m/s; UAV 68.5 m, max 5.4 m/s	UGV 12.0 m, max 3.4 m/s; UAV 26.8 m, max 5.6 m/s
Motion produced by controller commands, logged during the episode	543 UGV VehicleControl + 4 UAV AirSim commands	222 + 6
Background actors moved safely	car 81 m, pedestrian 62 m; closest footprint clearance to the UGV 2.45 m; 0 collisions	car 81 m, pedestrian 39 m; clearance 2.39 m; 0 collisions
Robot collisions	0	0
Answer shown only after evidence	UGV ugv_0001: target headlamps 100% visible at 13.0 m and actually ON; UAV uav_0001: 4.5k px of the blue truck	ugv_0001: 83% visible at 8.0 m, ON; uav_0001: 6.2k px of the blue truck
Videos synchronised	474 frames per stream, max offset 70 ms	296 frames per stream, max offset 75 ms
Evaluator	joint success; traceability, evidence and snapshot quality all OK	joint success; all OK

Simulator tick rate was 35 Hz (UC1) and 27 Hz (UC2). The GPU was shared with other jobs; the pilot benchmark runs reach 60 Hz on a free GPU. The controllers still met the evaluator's tolerances.

Notes and limitations

• Scripted oracle only. The route and the answer come from ground truth. The demo shows the benchmark, controllers, recording and evaluator working end to end. It says nothing about how well a learned policy would do.
• The inspection lane is the oncoming lane. Road 10 is two-way: lanes at y = −64.4 and −67.9 run −x, lanes at −60.9 and −57.4 run +x. The validated inspection positions are in the y = −64.4 lane, which is the oncoming lane for a UGV driving +x. This is safe in this controlled scene, where no traffic uses that lane, but it is not traffic-legal.
• Real-time asynchronous simulation. Repeat runs differ slightly. For example, final position errors are 0.05–0.3 m.
• Single scene family. These episodes derive from benchmark variants E1 (UC1) and E4 (UC2) of a pilot with five controlled variants. The same scene appears in both episodes.
• Licensing. Footage is rendered with CARLA-Air (CARLA 0.9.16 + AirSim 1.8.1, Unreal Engine 4.26). Check the upstream licences of CARLA-Air and its assets before reuse.

Reproduce

The episodes were produced with the airground_qa pilot code, from its directory, with the CARLA-Air v0.1.7 server running in Town10HD:

python -m aqa.showcase build          # episodes/showcase_uc1, episodes/showcase_uc2 (from benchmark E1 / E4)
python -m aqa.showcase run uc1        # record (also: uc2)
python -m aqa.showcase verify uc1
python -m aqa.showcase render uc1     # videos
python -m aqa.showcase export         # this folder layout