SPEEDTrack — High-Throughput Event-Based Feature Detection and Tracking on an Embedded CPU

The problem

An event camera produces events faster than any tracker we measured can consume them. SPEEDTrack is the first that keeps up.

Throughput is the rate at which a method processes events; the event rate is the rate the sensor emits them. Below that rate, subsampling becomes mandatory to maintain live operation, and the sampling policy must discard events before their information content is known. On an embedded platform this margin has to be achieved within a fixed power budget.

SPEEDTrack

6.45

SuperEvent GPU

1.95

DeepEvT GPU

1.04

RATE

0.37

HASTE

0.23

ETAP GPU

0.18

AEB-Tracker

0.13

EKLT

0.03

02467

EDS mean event rate 6.05 ↓

Mean throughput on the EDS dataset, million events per second. Everything to the left of the red line falls behind the sensor.

Key idea

Conventional pipelines slice the event stream on a clock and at best achieve thread-based parallelism for each stage. Still scenes burn compute, fast motion blurs, and cores sit idle waiting on each other. We change both halves of that.

Task graphs and thread occupancy for a conventional pipeline versus MDCS — Conventional scheduling leaves threads idle; the Motion-Defined Concurrent Slices architecture keeps them fed.

Each slice is defined by motion

Fill a slice until the mean number of events per active pixel crosses a threshold. Fast, dense motion produces slices quickly; a still scene never produces one, so compute and power scale directly with motion.

α = |S_j| A_active > α_th

A single threshold, α_th = 3, for every benchmark and every live demo.

Each slice is self-contained

Detection and tracklet fitting are slice-local, with no shared state. Only the association stage reaches across slices — so everything before it can run on any core, and slices need not finish in order.

Any core takes any stage

With slices independent, the pipeline becomes a task graph: a stage runs the moment its inputs land, on whichever core is free. Synchronisation is minimal and almost all CPU time goes to useful parallel work.

Event frames from fixed-time, fixed-size and activity-based slicing under slow and fast motion — Fixed-time and fixed-size batching (a–d) fall apart across motion speeds; one α_th (e–f) yields slices that look the same fast or slow.

Results

Speed is not paid for in accuracy. Seeded with the same detections, our tracker outperforms every event-only method that runs without a GPU, and both hybrid event+frame trackers on EDS.

Feature age	EDS SFA↑	EDS EFA↑	EC SFA↑	EC EFA↑
HASTE	0.070	0.050	0.425	0.410
AEB-Tracker	0.300	0.290	0.540	0.460
EKLT+frames	0.230	0.150	0.795	0.760
DeepEvT+frames	0.480	0.400	0.815	0.805
ETAPGPU	0.742	0.613	0.870	0.851
SPEEDTrack	0.558	0.421	0.822	0.713

On relative pose we place second of five, behind only SuperEvent (AUC@10°: 20.8 on EC, 14.0 on EDS). Our corners also associate longest at the lowest reprojection error on the ATIS Corner Dataset — 2.27 s at 2.71 px.

Tracks on the peanuts dark scene — Tracks on `peanuts dark`, `ziggy flying pieces`, `ziggy in the arena` and `rocket earth light` from EDS.

Tracks on the ziggy flying pieces scene — Tracks on `peanuts dark`, `ziggy flying pieces`, `ziggy in the arena` and `rocket earth light` from EDS.

Mean latency against mean throughput for event-based detectors and trackers — Latency against throughput, both axes measured; aim for the bottom right. Learned trackers sit an order of magnitude higher in latency, while we are at 36 µs per event and still past the event rate.

Roofline plot of event-only CPU feature trackers — Roofline for the CPU. Prior trackers are stuck in the memory-bound region, far below what the hardware can do; ours sits near the compute ceiling — which means more cores buy more throughput.

Live demonstrations

All recorded from a live Prophesee EVK4 stream on the embedded CPU. Tracking pauses when the scene goes still — that dormancy is the architecture, and it shows up in the compute and power draw too.

Indoor hallway with non-uniform scene depth and varying motion. livedemo-hallway.mp4

Desk scene; compute and power track the motion directly. livedemo-desk.mp4

Agile motion — acceleration, deceleration and sudden stops. livedemo-indoor-agile.mp4

Predominantly rotational motion. livedemo-indoor-rotational.mp4

Outdoor scene under general handheld motion. livedemo-outside-general.mp4

Outdoor start–stop translation; tracking suspends when still. livedemo-outside-start_stop.mp4

Static camera, thrown and caught pillow — tracked through complex motion. livedemo-pillow.mp4

Static camera; both the wheel and the frame's translation are tracked. livedemo-pushbike-back_and_forth.mp4

Spinning wheel under varying and fast rates of spin. livedemo-pushbike-spinning_wheel.mp4

Citation

@inproceedings{elms2026speedtrack,
  title     = {High-Throughput Event-Based Feature Detection and Tracking
               on an Embedded CPU},
  author    = {Elms, Ethan and Latif, Yasir and Chin, Tat-Jun},
  booktitle = {European Conference on Computer Vision (ECCV)},
  year      = {2026}
}