AdamHines/springfield-event-vpr

Springfield-Event

Springfield-Event is an evaluation dataset for event-based visual place recognition. It contains raw events from a Prophesee EVK4, synchronised GPS and phone telemetry, seven database traversals with different viewing directions, and 5,557 query windows captured during day and dawn conditions in Springfield, Queensland, Australia.

The dataset is evaluation-only and does not define training or validation splits.

At a glance

Sensor	Prophesee EVK4, 1280 x 720
Database	7 sessions, 115 HDF5 partitions
Gallery	132,569 valid 50 ms windows
Queries	5,557 selected 50 ms windows from 38 passes
Conditions	Day and dawn
Ground truth	GPS distance <= 25 m
Download size	Approximately 810 GiB

Organisation

Keep the downloaded directory in the following form. In particular, query_slices.csv belongs directly inside queries/.

springfield/
|-- database/
|   `-- <session-id>/
|       |-- events_p*.h5
|       |-- session.json
|       |-- partitions.jsonl
|       |-- camera_sync.csv
|       |-- phone.jsonl
|       `-- derived/
`-- queries/
    |-- query_day/
    |   `-- <session-id>/...
    |-- query_dawn/
    |   `-- <session-id>/...
    |-- query_slices.csv
    `-- sessions.txt

Download the repository with the Hugging Face CLI by replacing the repository identifier below:

hf download <namespace>/<dataset> --repo-type dataset --local-dir springfield

Contents

Each session contains:

Path	Description
events_p*.h5	Raw event arrays. Database traversals are divided into several partitions; each query pass has one partition.
session.json	Sensor, capture, timing, distance, and partition metadata.
partitions.jsonl	Partition boundaries and associated GPS fixes.
camera_sync.csv	Samples relating the camera clock to the host clock.
phone.jsonl	Raw phone telemetry.
derived/gps_interp.csv	Processed GPS samples used by the evaluation.
derived/sync.json	Fitted camera, phone, and host clock relationships.
derived/*.csv	Processed location, orientation, and inertial measurements.

An event HDF5 file contains four equal-length datasets:

Dataset	Type	Meaning
events/x	uint16	Pixel x-coordinate.
events/y	uint16	Pixel y-coordinate.
events/t	int64	Camera timestamp in microseconds.
events/p	uint8	Polarity, encoded as 0 or 1.

The root HDF5 attributes record the sensor width, height, and timestamp scale. Events are raw; no event representation or background-activity filter has been applied.

Database viewpoints

The gallery combines all seven sessions:

Session	Coverage	Camera facing
20260829T000024Z	Full route	Forward
20260829T005503Z	Full route	Left
20260829T023529Z	Full route	Right
20260829T032741Z	Extra location A	Forward
20260829T033229Z	Extra location A	Right
20260829T033917Z	Extra location B	Forward
20260829T034314Z	Extra location B	Right

Query selection

queries/query_slices.csv is the authoritative query list. The recordings contain additional raw events, but only the listed windows belong to the benchmark.

Column	Meaning
session	Query session identifier.
sweep	Capture condition: day or dawn.
slice_index	Zero-based 50 ms window index within the session event file.
psi_deg	Signed camera bearing relative to the local route direction.
x_enu_m, y_enu_m	Query position in the shared local ENU coordinate frame.

Sweep	Passes	Query windows
Day	19	3,169
Dawn	19	2,388

The published subset excludes reversed views using abs(psi_deg) < 135. Consequently, the selected slice_index values need not be contiguous.

Loading a query

Install EventCV, then open the recording as a lazy 50 ms reader. The example loads the first selected query without reading the full HDF5 file:

pip install eventcv

import csv
from pathlib import Path

import eventcv as ecv


root = Path("springfield")
with (root / "queries" / "query_slices.csv").open(newline="") as file:
    row = next(csv.DictReader(file))

session = root / "queries" / f"query_{row['sweep']}" / row["session"]
event_file = next(session.glob("events_p*.h5"))

reader = ecv.open(
    str(event_file),
    dt_ms=50,
    sensor_size=(1280, 720),
    hot_pixel_filter=True,
    hot_pixel_std=3.0,
)
query = reader.slice(int(row["slice_index"]))
events = query.numpy()  # [N, 4] columns: x, y, t, p
frame = query.countmask(white_frame=False).numpy()  # [3, 720, 1280]

print(events.shape, frame.shape)

Set hot_pixel_filter=False to retrieve the recorded events without the reference evaluation's hot-pixel filtering. EventCV can render other representations from the same query stream.

Evaluation protocol

1. Divide every database partition into consecutive 50 ms windows beginning at its first event timestamp. Discard windows without valid synchronised GPS.
2. Combine the remaining database windows into one gallery. This gives 132,569 gallery entries at the native sampling density.
3. Evaluate the 5,557 windows listed in queries/query_slices.csv.
4. Treat a retrieved gallery entry as correct when its interpolated GPS position is within 25 m of the query position.
5. Report Recall@1, Recall@5, Recall@10, and Recall@20.

The reference evaluation renders raw events with 50 ms accumulation, applies the eventcv hot-pixel filter with standard-deviation threshold 3, and leaves the background-activity filter disabled. Other event representations can be built from the same raw recordings.

Citation

If you use Springfield-Event, please cite the associated paper and dataset.

@misc{hines2026megaevent,
      title={Multi-viewpoint Geo-localization with Event Cameras}, 
      author={Adam D. Hines and Michael Milford and Tobias Fischer},
      year={2026},
      eprint={2609.21219},
      archivePrefix={arXiv},
      primaryClass={cs.CV},
      url={https://arxiv.org/abs/2609.21219}, 
}