Event Cameras

Normal cameras photograph the whole scene thirty times a second. Event cameras report only what changed, pixel by pixel, the microsecond it changes — nothing moves without a timestamp.

Frames smear a fast edge into blur while the event stream traces its exact path dot by dot

Why Does This Exist?

Frames fail at speed and range. A propeller at $10{,}000$ RPM crosses a $30$ fps exposure hundreds of times per frame — pure blur. A tunnel exit spans brightness ratios no single exposure covers — clip one end or the other. Raising frame rates multiplies bandwidth and power for pixels that mostly repeat the previous frame.

Event cameras (dynamic vision sensors) invert the contract: each pixel watches its own log-brightness and emits an event $(x, y, t, p)$ only when it changes past threshold — microsecond timestamps, $120+$ dB range, and bandwidth proportional to motion, not resolution. Fast, sparse, and dark-friendly by construction. The family map is alternative sensing; the motion sibling is optical flow.

The one idea you need first. An event fires when a pixel's log-intensity moves by more than threshold $\theta$ since its last event: ON polarity for brighter, OFF for darker, with the exact microsecond attached. Static scenes emit nothing; edges in motion emit spacetime trails. Frames become a choice, accumulated from events when some downstream tool wants them — not the sensor's native tongue.

Think of It Like This

A guard who only shouts about movement

One guard describes the empty warehouse every second: "still empty, still empty, still empty" — thirty reports a second, all identical, until the burglary blurs past between two reports. The other guard stands silent for hours and shouts the instant a shadow moves, with the exact second and direction.

Event pixels are the second guard. Silence is the normal state and costs nothing; motion triggers precise, timestamped shouts. Frame cameras are the first guard: diligent, exhaustive, and blind between sentences. For burglars (drones, balls, gestures) you want the shouter; for inventory (static scenes) you want the describer.

How It Actually Works

Each pixel holds a memorized log-brightness and a comparator. Incoming light integrates; when the level differs from memory by $\theta$ (typically $10$ – $30\%$ in log space), the pixel emits its event, updates memory, and rearms — all asynchronously, no global shutter, no exposure window. Readout streams address-events off chip in arrival order. Downstream code either processes events natively (spiking networks, event-based flow) or bins them into frames, voxel grids, or time surfaces for conventional networks.

Dynamic range follows from the log pixel: brightness is encoded relatively, so moonlight and headlights coexist without exposure control.

Worked example

A pixel's memorized log-level is $5.0$ ; light rises to $5.5$ ; threshold $\theta = 0.3$ . Change $= 0.5$ ; events fired $= \lfloor 0.5 / 0.3 \rfloor = 1$ (ON polarity), remainder $0.5 - 0.3 = 0.2$ carried as the new baseline offset. Had light jumped to $6.0$ , change $1.0$ would fire $\lfloor 1.0/0.3 \rfloor = 3$ events in one burst — brighter steps speak more, proportionally.

Bandwidth follows motion: a $1$ -megapixel sensor with $1\%$ of pixels seeing one threshold-crossing per millisecond emits $10{,}000 \times 1{,}000 = 10^7$ events per second — while a static scene emits near zero and a $1{,}000$ fps frame camera would ship $10^9$ pixels per second regardless.

Code

The point of this snippet is the pixel rule: threshold crossings become counted, polarized events.

1def pixel_events(levels: list, theta: float = 0.3) -> list:2    mem = levels[0]3    out = []4    for lv in levels[1:]:5        while abs(lv - mem) >= theta:  # one event per threshold crossed6            mem += theta if lv > mem else -theta7            out.append(1 if lv > mem else -1)8    return out9
10
11print(pixel_events([5.0, 5.5]))  # -> [1]12print(pixel_events([5.0, 6.0]))  # -> [1, 1, 1]

Watch Out For

Stillness is invisibility

No change means no events: a parked car at a stoplight fades from the stream within milliseconds and never returns until something moves. Detectors trained on events alone lose stationary objects that any frame camera holds trivially.

Fuse with frames (DAVIS-style hybrid sensors) or maintain decaying memory surfaces for static content. Event purity is elegant and blind; production systems are hybrids.

Noise events in the dark

At low light, photon shot noise jiggles pixels across thresholds and the sensor chatters: thousands of phantom events per second with no scene motion behind them. Denoising by blind threshold-raising also erases genuine faint motion.

Filter spatiotemporally (real motion correlates across neighbors; noise does not) and validate night performance on real dark recordings, not dimmed daylight. Lab darkness and street darkness differ in spectrum and flicker.

The Quick Version

Event pixels emit $(x, y, t, p)$ when log-brightness crosses threshold — no frames, no shutter, no exposure.
The worked fixture fires $1$ event for a $0.5$ rise and $3$ for a $1.0$ jump at threshold $0.3$ .
Microsecond timing and $120+$ dB range capture propellers and tunnel exits that blur or clip frames.
Static scenes vanish from the stream, so fuse with frames or keep decaying memory.
Low light brings shot-noise chatter; filter by spatiotemporal correlation, not blunt thresholds.