Neuromorphic webcam · event-based vision

Your camera has no idea what just moved.

Every camera you own works one way: wake all the pixels on a clock, ship the entire picture, repeat thirty times a second — the motionless wall behind you included. An event camera throws that out. Each pixel watches its own patch of light and speaks only when that light changes. Nothing moves, nothing is sent. This page runs one of those sensors, live, on whatever you point it at.

Left panel An ordinary camera. The complete picture, every frame.
Right panel The same scene through an event camera. Only what changed.
The numbers Measured live from what you are pointing at, not looked up.

Point it at yourself. Hold still and you disappear. Move and you come back as edges. Your video is processed inside this page and never uploaded anywhere.

Ordinary camera demo scene

What your webcam actually transmits: a full picture, whether or not anything happened in it.

Event camera brighter darker

Everything the event camera would have transmitted. Black is not darkness — it is silence, pixels with nothing to report.

Try first Stop moving The right panel drains to black and the event rate collapses. A sensor that sees nothing sends nothing — that is the entire idea, in one gesture.
Then Wave a hand You return as outlines only. Blue where a pixel got brighter, red where it got darker. The flat middle of your shirt never appears, because nothing there is changing.
Then Drag the threshold At 0.03 the sensor is so touchy it reports its own noise. At 0.50 only fast, hard edges survive. Real hardware lives between 0.15 and 0.25.
Event rate 0k ev/s Individual pixel-level changes reported per second, over the last few seconds.
Pixels firing 0% Share of the array with anything to say this frame.
Frame stream 0kB/s What the ordinary camera sends, uncompressed.
Event stream 0kB/s What the event camera sends instead.
Data avoided 0× How much less is leaving the sensor right now. Sit still and watch it climb.
Source
Or a video file
Contrast threshold0.15 How large a change a pixel needs before it speaks up.
Refractory1 ms Enforced silence after firing, so one bright edge cannot flood the bus.
Persistence80 ms How long an event stays lit on screen. A display choice, not part of the sensor.
Array size
Run

Demo scene running. The block marked STATIC never moves, so the sensor never mentions it again after the first frame.

How a single pixel decides

Follow one pixel. The pale trace is the brightness it sees over three seconds. The stepped line is the only thing it remembers: the brightness it last reported. Whenever the trace pulls away from that memory by more than the threshold, the pixel fires one event and drags the memory to where it is now. Everything else about the scene is discarded.

Drag the contrast threshold above and this diagram redraws. Widen the steps and the pixel grows quiet and coarse; narrow them and it chatters. That single number is the whole trade, and on real hardware it is not software at all — it is set by a bias current inside the pixel circuit.

Why anyone builds these

Time, not frames

Each pixel timestamps itself to the microsecond. There is no shutter to be between, so there is no motion blur and nothing to miss between frames. A propeller, a bullet, a spark — all resolved by a sensor drawing a fraction of a watt.

Sun and shadow at once

Because the threshold is on relative change, a pixel behaves the same in glare and in near-darkness. Around 120 dB of range against roughly 60 dB for a conventional sensor: the difference between being blinded on exit from a tunnel and simply driving out of it.

Silence is free

An unchanged pixel costs no bandwidth, no memory and no computation. In a mostly-still world that is most of the array, most of the time — which is why these sensors turn up on drones, satellites and anything running off a battery.

The model, exactly

The whole sensor is four lines. Each pixel holds L_ref, the log brightness it last reported, and compares it against what it sees now.

L(x, y, t) = log( ε + I(x, y, t) ) if L − L_ref ≥ +C emit ON event, L_ref ← L_ref + C if L − L_ref ≤ −C emit OFF event, L_ref ← L_ref − C then stay silent for a refractory period Δt_r

Why the logarithm. A fixed threshold on log brightness is a fixed threshold on relative change, so a 20% change fires identically in direct sun and in a dim room. That one choice is where the dynamic range comes from.

How the data rates are computed. The frame figure is width × height × 1 byte × the measured frame rate — 8-bit greyscale, uncompressed. The event figure is the measured event rate × 4 bytes, the usual packing for an address-event packet carrying x, y, timestamp and polarity. Payload only: no compression, no protocol overhead, no readout circuitry on either side.

The reduction is a property of the scene, not a specification. Point this at a still wall and it runs away to infinity. Point it at fast, high-contrast, full-field texture and the event stream can cost more than the frames. Both are one slider away, and both happen in the real world.

What this demo cannot show you

It builds events out of ordinary video, so it inherits your webcam's frame rate. The sparsity you are watching is honest. The timing is not — a real event camera resolves to microseconds, roughly ten thousand times finer than the 33 ms grid these events land on. That timing, more than the data saving, is why the sensors exist.

Sources