RoadBench

RoadBench is a benchmark for evaluating the fine-grained spatial understanding and reasoning capabilities of multimodal large language models (MLLMs) in urban scenarios. It comprises eight tasks spanning bird's-eye-view (BEV, satellite) and first-person-view (FPV, in-vehicle camera) imagery, including lane counting, lane designation recognition, road network correction, road type classification, and two cross-view tasks.

⚠️ Important: how BEV satellite imagery is distributed

The BEV satellite images in RoadBench were originally captured from Google Maps, whose imagery must not be redistributed. Therefore this release does not contain any BEV satellite pixels. Instead, every BEV image is described by a manifest entry giving its WGS84 longitude/latitude bounding box (plus crop window), and a self-contained script (download_satellite.py) re-fetches the satellite tiles from Google and reconstructs each image.

FPV images are real in-vehicle camera photographs (anonymized) and are included directly in fpv_images/.

Note on fidelity. Reconstructed BEV images reflect current Google tiles. Because Google updates its imagery over time, a reconstructed image may differ slightly (season, new construction, freshness) from the image used at dataset creation time. The geographic extent and alignment are exact; only the pixel content can drift with time. This is an inherent property of the coordinate-based distribution approach.

Reference imagery date. The build-time BEV imagery (and the rgb_histogram fingerprints in bev_manifests/task1_2.jsonl) correspond to mid-2025 Google tiles (acquired with the download pipeline developed on 2025-07-19). Use verify_imagery.py to measure how much current tiles have drifted from this reference.

Directory layout

RoadBench/
├── README.md                       # this file
├── requirements.txt                # aiohttp, pillow
├── download_satellite.py           # BEV image reconstruction script (self-contained)
├── bev_manifests/                  # BEV coordinate manifests (replace satellite pixels)
│   ├── task1_2.jsonl               # 2908 entries (shared by Task 1 & 2)
│   ├── task3.jsonl                 # 840 entries
│   └── task4_5.jsonl               # 737 entries (cross-view BEV, shared by Task 4 & 5)
├── fpv_images/                     # FPV photos, shipped directly
│   ├── task4_5_6_7/  (737 images)  # shared by Task 4, 5, 6, 7
│   └── task8/        (991 images)  # Task 8
├── tasks/                          # per-task labels (one labels.jsonl each)
│   ├── task1_bev_lane_counting/
│   ├── task2_bev_lane_designation/
│   ├── task3_bev_roadnet_correction/
│   ├── task4_crossview_lane_counting/
│   ├── task5_crossview_lane_designation/
│   ├── task6_fpv_lane_counting/
│   ├── task7_fpv_lane_designation/
│   └── task8_fpv_road_type/
└── splits/                         # per-task train/test split (one <task_dir>.jsonl each)

Self-contained. This package has no external file dependencies. Every BEV manifest record fully describes its own image — the WGS84 bounding box and (for cropped tasks) the crop window are embedded inline, so nothing needs to be looked up outside this package. The only network access is download_satellite.py fetching Google tiles.

The eight tasks

Task	Name	Modality	Images	#cases	#test
1	BEV Lane Counting	BEV	manifest task1_2	2908	969
2	BEV Lane Designation Recognition	BEV	manifest task1_2 (shared with Task 1)	2908	969
3	BEV Road Network Correction	BEV	manifest task3	840	280
4	Cross-View Lane Counting	BEV + FPV	manifest task4_5 (BEV) + fpv_images/task4_5_6_7	737	131
5	Cross-View Lane Designation Recognition	BEV + FPV	manifest task4_5 (BEV) + fpv_images/task4_5_6_7	737	137
6	FPV Lane Counting	FPV	fpv_images/task4_5_6_7	737	115
7	FPV Lane Designation Recognition	FPV	fpv_images/task4_5_6_7	737	109
8	FPV Road Type Classification	FPV	fpv_images/task8	991	330
	Total			10595	3040

Task 1 & 2 share the same BEV image set (2908 crops); they differ only in the label used (num_lane vs laneinfo), so a single manifest bev_manifests/task1_2.jsonl serves both. Task 4, 5, 6, 7 share one FPV pool (fpv_images/task4_5_6_7/, 737 photos): Task 4 & 5 also add the cross-view BEV (bev_manifests/task4_5.jsonl), while Task 6 & 7 are FPV-only. Task 8 uses a separate FPV pool (fpv_images/task8/).

Train / test split (splits/)

Each task ships a train/test split in splits/<task_dir>.jsonl — one record per case:

{"id": "8b7f24156b0526f2ccbd501530f01671", "split": "test"}   // tasks 1/2/3/6/7/8
{"image_id": "dbb81fc2e6c548d49b1f867971f6e21d", "split": "test"}  // tasks 4/5

The id field matches the task's labels.jsonl (id for tasks 1/2/3/6/7/8, image_id for tasks 4/5), so a split row joins directly to a label row.

The paper reports results on the test split only — 3,040 cases (the #test column above). #cases is the full released set (train + test, plus extra labeled images for the shared FPV pool; see below), which is why #cases ≥ #test and the two totals differ (10,595 vs 3,040).

To reproduce the paper's evaluation set, keep only the labels whose id is marked test:

import json
split = "splits/task1_bev_lane_counting.jsonl"
key = "id"  # "image_id" for tasks 4/5
test_ids = {json.loads(l)[key] for l in open(split) if json.loads(l)["split"] == "test"}
labels = [json.loads(l) for l in open("tasks/task1_bev_lane_counting/labels.jsonl")
          if json.loads(l)[key] in test_ids]

Shared FPV pool (Tasks 4/5/6/7). These four tasks draw from one pool of 737 FPV photos, but each task uses only a subset in its experiment: the counting tasks (4 & 6) split the pool into two disjoint halves, as do the designation tasks (5 & 7). So a splits/ file for these tasks lists only that task's own subset — e.g. task4_crossview_lane_counting.jsonl has 131 test + 222 train = 353 ids; the remaining 384 photos belong to task 6's split and are simply absent here. The task's labels.jsonl still contains a label for every one of the 737 photos.

Reconstructing BEV images

pip install -r requirements.txt
# Task 1/2 (and 2 — same images):
python download_satellite.py --manifest bev_manifests/task1_2.jsonl --out bev_images/task1_2
# Task 3:
python download_satellite.py --manifest bev_manifests/task3.jsonl   --out bev_images/task3
# Cross-view Task 4/5 (full bbox images):
python download_satellite.py --manifest bev_manifests/task4_5.jsonl --out bev_images/task4_5

Options:

• --proxy http://127.0.0.1:7890 — use a proxy if mt*.google.com is not directly reachable.
• --workers 16 — parallel tile downloads.
• --limit N / --ids id1,id2 — process a subset (handy for testing).
• --cache tile_cache — reuse downloaded tiles across runs.

The script writes <id>.png (Task 1/2/3) or <image_id>.png (Task 4/5) into --out, matching the id/image_id keys in the corresponding tasks/*/labels.jsonl. The reconstructed image is the clean satellite crop; the reference line shown to models is drawn separately from each label's pixel_line (in the reconstructed-image coordinate frame).

Checking reconstructed imagery

Because Google updates its tiles over time, a reconstructed image may drift from the one used at dataset-build time. For Task 1/2, each bev_manifests/task1_2.jsonl record carries an rgb_histogram fingerprint of the build-time image; verify_imagery.py compares your reconstructed images against it:

# after reconstructing Task 1/2 images into bev_images/task1_2/
python verify_imagery.py verify --manifest bev_manifests/task1_2.jsonl --image-dir bev_images/task1_2

It prints cosine similarity stats (min/mean/median/max) and the 10 least-similar images. Rough guide: >= 0.95 faithful · 0.80–0.95 minor drift (season / imagery refresh) · < 0.80 substantial drift — re-check the crop window / coordinates. The fingerprint is resolution-independent (an L1-normalized binned RGB histogram), so reference and reconstructed images need not share pixel dimensions.

Manifest schema

JSON Lines, one record per BEV image. Only the fields needed to reconstruct the image are stored.

• task1_2.jsonl & task3.jsonl: id, wgs84_bbox {min_lon, min_lat, max_lon, max_lat} (the WGS84 box to download), crop_window {x0, y0, x1, y1} (region to crop from the downloaded bbox tile, in bbox pixel coords).
• task4_5.jsonl: image_id, wgs84_bbox (download the full bbox tile — no cropping).
• rgb_histogram (Task 1/2 only): a compact fingerprint of the build-time image for drift checking — base64 of little-endian uint16, 16 bins × 3 channels = 48 values, scaled by 65535 (see Checking reconstructed imagery).

Label schema (tasks/*/labels.jsonl)

Task	Fields
1	id, pixel_line, num_lane
2	id, pixel_line, laneinfo
3	id, pixel_line, ground_truth{lines,junctions}
4	image_id, pixel_line, num_lane
5	image_id, pixel_line, laneinfo
6	id, num_lane
7	id, laneinfo
8	id, road_type

pixel_line is the directed reference line (WKT LINESTRING) in the reconstructed-image coordinate frame — draw it on the BEV image to obtain the model input. FPV tasks (6/7/8) have no reference line.

laneinfo is a per-lane list of direction codes, one entry per lane ordered left → right (len(laneinfo) == num_lane). Each entry is one or more concatenated letters from the table below (multiple letters = a lane allowing several directions):

Code	Direction
A	U-turn
B	left-turn
C	straight
D	right-turn
G	variable lane (FPV / cross-view only)

For example, ["B", "C", "CD"] = a left-turn lane, a straight lane, and a straight+right-turn lane. G appears only in the FPV and cross-view designation tasks (5/7), matching the variable lane type used in the paper's MLLM prompt. road_type (Task 8) is main / service.