Event-based Vision: A Survey

TL;DR

This survey reviews event-based vision sensors, their working principles, applications, algorithms, and processing techniques, emphasizing their advantages in high-speed, high dynamic range scenarios and discussing future challenges and opportunities.

Contribution

It provides a comprehensive overview of event-based vision, including sensor types, applications, processing algorithms, and future research directions in this emerging field.

Findings

Event cameras offer microsecond-level temporal resolution.

They provide high dynamic range and low power consumption.

Various algorithms and processors have been developed for event data processing.

Abstract

Event cameras are bio-inspired sensors that differ from conventional frame cameras: Instead of capturing images at a fixed rate, they asynchronously measure per-pixel brightness changes, and output a stream of events that encode the time, location and sign of the brightness changes. Event cameras offer attractive properties compared to traditional cameras: high temporal resolution (in the order of microseconds), very high dynamic range (140 dB vs. 60 dB), low power consumption, and high pixel bandwidth (on the order of kHz) resulting in reduced motion blur. Hence, event cameras have a large potential for robotics and computer vision in challenging scenarios for traditional cameras, such as low-latency, high speed, and high dynamic range. However, novel methods are required to process the unconventional output of these sensors in order to unlock their potential. This paper provides a comprehensive overview of the emerging field of event-based vision, with a focus on the applications and the algorithms developed to unlock the outstanding properties of event cameras. We present event cameras from their working principle, the actual sensors that are available and the tasks that they have been used for, from low-level vision (feature detection and tracking, optic flow, etc.) to high-level vision (reconstruction, segmentation, recognition). We also discuss the techniques developed to process events, including learning-based techniques, as well as specialized processors for these novel sensors, such as spiking neural networks. Additionally, we highlight the challenges that remain to be tackled and the opportunities that lie ahead in the search for a more efficient, bio-inspired way for machines to perceive and interact with the world.

Equations

$$\Delta L({\mathbf{x}}_k,t_k)\doteq L({\mathbf{x}}_k,t_k)-L({\mathbf{x}}_k,t_k-\Delta t_k),$$

$$\Delta L({\mathbf{x}}_k,t_k)=p_{k}C,$$

$$\frac{\partial L}{\partial t}({\mathbf{x}}_k,t_k)\approx \frac{p_{k}C}{\Delta t_k}.$$

$$\Delta L\approx -\nabla L\cdot \mathbf{v}\Delta t,$$

Full text

1 Introduction and Applications

“The brain is imagination, and that was exciting to me; I wanted to build a chip that could imagine something111https://youtu.be/FKemf6Idkd0?t=67.” that is how Misha Mahowald, a graduate student at Caltech in 1986, started to work with Prof. Carver Mead on the stereo problem from a joint biological and engineering perspective. A couple of years later, in 1991, the image of a cat in the cover of Scientific American [1], acquired by a novel “Silicon Retina” mimicking the neural architecture of the eye, showed a new, powerful way of doing computations, igniting the emerging field of neuromorphic engineering. Today, we still pursue the same visionary challenge: understanding how the brain works and building one on a computer chip. Current efforts include flagship billion-dollar projects, such as the Human Brain Project and the Blue Brain Project in Europe and the U.S. BRAIN (Brain Research through Advancing Innovative Neurotechnologies) Initiative.

This paper provides an overview of the bio-inspired technology of silicon retinas, or “event cameras”, such as [2, 3, 4, 5], with a focus on their application to solve classical as well as new computer vision and robotic tasks. Sight is, by far, the dominant sense in humans to perceive the world, and, together with the brain, learn new things. In recent years, this technology has attracted a lot of attention from academia and industry. This is due to the availability of prototype event cameras and the advantages that they offer to tackle problems that are difficult with standard frame-based image sensors (that provide stroboscopic synchronous sequences of pictures), such as high-speed motion estimation [6, 7] or high dynamic range (HDR) imaging [8].

Event cameras are asynchronous sensors that pose a paradigm shift in the way visual information is acquired. This is because they sample light based on the scene dynamics, rather than on a clock that has no relation to the viewed scene. Their advantages are: very high temporal resolution and low latency (both in the order of microseconds), very high dynamic range ($140\text{\,}\mathrm{dB}$ vs. $60\text{\,}\mathrm{dB}$ of standard cameras), and low power consumption. Hence, event cameras have a large potential for robotics and wearable applications in challenging scenarios for standard cameras, such as high speed and high dynamic range. Although event cameras have become commercially available only since 2008 [2], the recent body of literature on these new sensors222https://github.com/uzh-rpg/event-based_vision_resources [9] as well as the recent plans for mass production claimed by companies, such as Samsung [5] and Prophesee333http://rpg.ifi.uzh.ch/ICRA17_event_vision_workshop.html, highlight that there is a big commercial interest in exploiting these novel vision sensors for mobile robotic, augmented and virtual reality (AR/VR), and video game applications. However, because event cameras work in a fundamentally different way from standard cameras, measuring per-pixel brightness changes (called “events”) asynchronously rather than measuring “absolute” brightness at constant rate, novel methods are required to process their output and unlock their potential.

Applications of Event Cameras:

Typical scenarios where event cameras offer advantages over other sensing modalities include real-time interaction systems, such as robotics or wearable electronics [10], where operation under uncontrolled lighting conditions, latency, and power are important [11]. Event cameras are used for object tracking [12, 13], surveillance and monitoring [14], and object/gesture recognition [15, 16, 17]. They are also profitable for depth estimation [18, 19], structured light 3D scanning [20], optical flow estimation [21, 22], HDR image reconstruction [23, 24, 8] and Simultaneous Localization and Mapping (SLAM) [25, 26, 27]. Event-based vision is a growing field of research, and other applications, such as image deblurring [28] or star tracking [29, 30], will appear as event cameras become widely available [9].

Outline: The rest of the paper is organized as follows. Section 2 presents event cameras, their working principle and advantages, and the challenges that they pose as novel vision sensors. Section 3 discusses several methodologies commonly used to extract information from the event camera output, and discusses the biological inspiration behind some of the approaches. Section 4 reviews applications of event cameras, from low-level to high-level vision tasks, and some of the algorithms that have been designed to unlock their potential. Opportunities for future research and open challenges on each topic are also pointed out. Section 5 presents neuromorphic processors and embedded systems. Section 6 reviews the software, datasets and simulators to work on event cameras, as well as additional sources of information. The paper ends with a discussion (Section 7) and conclusions (Section 8).

2 Principle of Operation of Event Cameras

In contrast to standard cameras, which acquire full images at a rate specified by an external clock (e.g., $30\text{\,}\mathrm{f}\mathrm{p}\mathrm{s}$), event cameras, such as the Dynamic Vision Sensor (DVS) [31, 32, 33, 34, 2], respond to brightness changes in the scene asynchronously and independently for every pixel (Fig. 1b). Thus, the output of an event camera is a variable data-rate sequence of digital “events” or “spikes”, with each event representing a change of brightness (log intensity)444Brightness is a perceived quantity; for brevity we use it to refer to log intensity since they correspond closely for uniformly-lighted scenes. of predefined magnitude at a pixel at a particular time555Nomenclature: “Event cameras” output data-driven events that signal a place and time. This nomenclature has evolved over the past decade: originally they were known as address-event representation (AER) silicon retinas, and later they became event-based cameras. In general, events can signal any kind of information (intensity, local spatial contrast, etc.), but over the last five years or so, the term “event camera” has unfortunately become practically synonymous with the particular representation of brightness change output by DVS’s. (Fig. 1b) (Section 2.4). This encoding is inspired by the spiking nature of biological visual pathways (Section 3.3).

Each pixel memorizes the log intensity each time it sends an event, and continuously monitors for a change of sufficient magnitude from this memorized value (Fig. 1a). When the change exceeds a threshold, the camera sends an event, which is transmitted from the chip with the $x,y$ location, the time $t$, and the 1-bit polarity $p$ of the change (i.e., brightness increase (“ON”) or decrease (“OFF”)). This event output is illustrated in Figs. 1b, 1e and 1f.

The events are transmitted from the pixel array to periphery and then out of the camera using a shared digital output bus, typically by using address-event representation (AER) readout [37, 38]. This bus can become saturated, which perturbs the times that events are sent. Event cameras have readout rates ranging from $2\text{\,}\mathrm{MHz}$ [2] to $1200\text{\,}\mathrm{MHz}$ [39], depending on the chip and type of hardware interface.

Event cameras are data-driven sensors: their output depends on the amount of motion or brightness change in the scene. The faster the motion, the more events per second are generated, since each pixel adapts its delta modulator sampling rate to the rate of change of the log intensity signal that it monitors. Events are timestamped with microsecond resolution and are transmitted with sub-millisecond latency, which make these sensors react quickly to visual stimuli.

The incident light at a pixel is a product of scene illumination and surface reflectance. If illumination is approximately constant, a log intensity change signals a reflectance change. These changes in reflectance are mainly the result of the movement of objects in the field of view. That is why the DVS brightness change events have a built-in invariance to scene illumination [2].

Comparing Bandwidths of DVS Pixels and Frame-based Camera: Although DVS pixels are fast, like any physical transducer, they have a finite bandwidth: if the incoming light intensity varies too quickly, the front-end photoreceptor circuits filter out the variations [40]. The rise and fall time that is analogous to the exposure time in standard image sensors is the reciprocal of this bandwidth. Fig. 2 shows an example of measured DVS pixel frequency response (DVS128 in [2]). The measurement setup (Fig. 2a) uses a sinusoidally-varying generated signal to measure the response. Fig. 2b shows that, at low frequencies, the DVS pixel produces a certain number of events per cycle. Above some cutoff frequency, the variations are filtered out by the photoreceptor dynamics, and thus the number of events per cycle drops. This cutoff frequency is a monotonically increasing function of light intensity. At the brighter light intensity, the DVS pixel bandwidth is about $3\text{\,}\mathrm{kHz}$, equivalent to an exposure time of about $300\text{\,}\mathrm{\SIUnitSymbolMicro s}$. At 1000$\times$ lower intensity, the DVS bandwidth is reduced to about $300\text{\,}\mathrm{Hz}$. Even when the LED brightness is reduced by a factor of 1000, the frequency response of DVS pixels is ten times higher than the $30\text{\,}\mathrm{Hz}$ Nyquist frequency from a $60\text{\,}\mathrm{f}\mathrm{p}\mathrm{s}$ image sensor. Also, the frame-based camera aliases frequencies above the Nyquist frequency back to the baseband, whereas the DVS pixel does not due to the continuous time response.

2.1 Event Camera Designs

This section presents the most common event camera designs. The actual devices (commercial or prototype cameras such as the DAVIS240) are summarized in Section 2.5.

The first silicon retina was developed by Mahowald and Mead at Caltech during the period 1986-1992, in Ph.D. thesis work [41] that was awarded the prestigious Clauser prize666http://www.gradoffice.caltech.edu/current/clauser. Mahowald and Mead’s sensor had logarithmic pixels, was modeled after the three-layer Kufler retina, and produced as output spike events using the AER protocol. However, it suffered from several shortcomings: each wire-wrapped retina board required precise adjustment of biasing potentiometers; there was considerable mismatch between the responses of different pixels; and pixels were too large to be a device of practical use. Over the next decade the neuromorphic community developed a series of silicon retinas. These developments are summarized in [38, 36, 42, 43].

The DVS event camera [2] had its genesis in a frame-based silicon retina design where the continuous-time photoreceptor was capacitively coupled to a readout circuit that was reset each time the pixel was sampled [44]. More recent event camera technology has been reviewed in the electronics and neuroscience literature [45, 46, 47, 36, 38, 10]. Although surprisingly many applications can be solved by only processing DVS events (i.e., brightness changes), it became clear that some also require some form of static output (i.e., “absolute” brightness). To address this shortcoming, there have been several developments of cameras that concurrently output dynamic and static information.

The Asynchronous Time Based Image Sensor (ATIS) [48, 3] has pixels that contain a DVS subpixel (called change detection CD) that triggers another subpixel to read out the absolute intensity (exposure measurement EM). The trigger resets a capacitor to a high voltage. The charge is bled away from this capacitor by another photodiode. The brighter the light, the faster the capacitor discharges. The ATIS intensity readout transmits two more events coding the time between crossing two threshold voltages, as in [49]. This way, only pixels that change provide their new intensity values. The brighter the illumination, the shorter the time between these two events. The ATIS achieves large static dynamic range (>$$120\text{\,}\mathrm{dB}). However, the ATIS has the disadvantage that pixels are at least double the area of DVS pixels. Also, in dark scenes the time between the two intensity events can be long and the readout of intensity can be interrupted by new events ([50] proposes a workaround to this problem).

The widely-used Dynamic and Active Pixel Vision Sensor (DAVIS) [51, 4] illustrated in Fig. 1 combines a conventional active pixel sensor (APS) [52] in the same pixel with DVS. The advantage over ATIS is a much smaller pixel size since the photodiode is shared and the readout circuit only adds about $5\text{\,}\mathrm{\char 37\relax}$ to the DVS pixel area. Intensity (APS) frames can be triggered at a constant frame rate or on demand, by analysis of DVS events, although the latter is seldom exploited777https://github.com/SensorsINI/jaer/blob/master/src/eu/seebetter/ini/chips/davis/DavisAutoShooter.java. However, the APS readout has limited dynamic range ($55\text{\,}\mathrm{d}\mathrm{B}$) and like a standard camera, it is redundant if the pixels do not change.

Since the ATIS and DAVIS pixel designs include a DVS pixel (change detector) [36] we often use the term “DVS” to refer to the binary-polarity event output or circuitry, regardless of whether it is from a DVS, ATIS or DAVIS design.

2.2 Advantages of Event cameras

Event cameras offer numerous potential advantages over standard cameras:

High Temporal Resolution: monitoring of brightness changes is fast, in analog circuitry, and the read-out of the events is digital, with a $1\text{\,}\mathrm{MHz}$ clock, i.e., events are detected and timestamped with microsecond resolution. Therefore, event cameras can capture very fast motions, without suffering from motion blur typical of frame-based cameras.

Low Latency: each pixel works independently and there is no need to wait for a global exposure time of the frame: as soon as the change is detected, it is transmitted. Hence, event cameras have minimal latency: about $10\text{\,}\mathrm{\SIUnitSymbolMicro s}$ on the lab bench, and sub-millisecond in the real world.

Low Power: Because event cameras transmit only brightness changes, and thus remove redundant data, power is only used to process changing pixels. At the die level, most cameras use about $10\text{\,}\mathrm{mW}$, and there are prototypes that achieve less than $10\text{\,}\mathrm{\SIUnitSymbolMicro W}$. Embedded event-camera systems where the sensor is directly interfaced to a processor have shown system-level power consumption (i.e., sensing plus processing) of $100\text{\,}\mathrm{mW}$ or less [53, 54, 55, 17].

High Dynamic Range (HDR). The very high dynamic range of event cameras (>$$120\text{\,}\mathrm{dB}) notably exceeds the $60\text{\,}\mathrm{dB}$ of high-quality, frame-based cameras, making them able to acquire information from moonlight to daylight. It is due to the facts that the photoreceptors of the pixels operate in logarithmic scale and each pixel works independently, not waiting for a global shutter. Like biological retinas, DVS pixels can adapt to very dark as well as very bright stimuli.

2.3 Challenges Due To The Novel Sensing Paradigm

Event cameras represent a paradigm shift in acquisition of visual information. Hence, they pose the challenge of designing novel methods (algorithms and hardware) to process the acquired data and extract information from it in order to unlock the advantages of the camera. Specifically:

1. Coping with different space-time output: The output of event cameras is fundamentally different from that of standard cameras: events are asynchronous and spatially sparse, whereas images are synchronous and dense. Hence, frame-based vision algorithms designed for image sequences are not directly applicable to event data.

2. Coping with different photometric sensing: In contrast to the grayscale information that standard cameras provide, each event contains binary (increase/decrease) brightness change information. Brightness changes depend not only on the scene brightness, but also on the current and past relative motion between the scene and the camera.

3. Coping with noise and dynamic effects: All vision sensors are noisy because of the inherent shot noise in photons and from transistor circuit noise, and they also have non-idealities. This situation is especially true for event cameras, where the process of quantizing temporal contrast is complex and has not been completely characterized.

Therefore, new methods need to rethink the space-time, photometric and stochastic nature of event data. This poses the following questions: What is the best way to extract information from the events relevant for a given task? and How can noise and non-ideal effects be modeled to better extract meaningful information from the events?

2.4 Event Generation Model

An event camera [2] has independent pixels that respond to changes in their log photocurrent $L\doteq\log(I)$ (“brightness”). Specifically, in a noise-free scenario, an event $e_{k}\doteq(\mathbf{x}_{k},t_{k},p_{k})$ is triggered at pixel $\mathbf{x}_{k}\doteq(x_{k},y_{k})^{\top}$ and at time $t_{k}$ as soon as the brightness increment since the last event at the pixel, i.e.

[TABLE]

reaches a temporal contrast threshold $\pm C$ (Fig. 1b), i.e.,

[TABLE]

where $C>0$,  $\Delta t_{k}$ is the time elapsed since the last event at the same pixel, and the polarity $p_{k}\in\{+1,-1\}$ is the sign of the brightness change [2].

The contrast sensitivity $C$ is determined by the pixel bias currents [56, 57], which set the speed and threshold voltages of the change detector in Fig. 1 and are generated by an on-chip digitally-programmed bias generator. The sensitivity $C$ can be estimated knowing these currents [56]. In practice, positive (“ON”) and negative (“OFF”) events may be triggered according to different thresholds, $C^{+},C^{-}$. Typical DVS’s [2, 5] can set thresholds between $10\text{\,}\mathrm{\char 37\relax}50\text{\,}\mathrm{\char 37\relax}$ illumination change. The lower limit on $C$ is determined by noise and pixel-to-pixel mismatch (variability); setting $C$ too low results in a storm of noise events, starting from pixels with low values of $C$. Experimental DVS’s with higher photoreceptor gain are capable of lower thresholds, e.g., $1\text{\,}\mathrm{\char 37\relax}$ [58, 59, 60]; however these values are only obtained under very bright illumination and ideal conditions. Fundamentally, the pixel must react to a small change in the photocurrent in spite of the shot noise present in this current. This shot noise limitation sets the relation between threshold and speed of the DVS under a particular illumination and desired detection reliability condition [61, 60].

Events and the Temporal Derivative of Brightness: Eq. (2) states that event camera pixels set a threshold on magnitude of the brightness change since the last event happened. For a small $\Delta t_{k}$, such an increment (2) can be approximated using Taylor’s expansion by $\Delta L(\mathbf{x}_{k},t_{k})\approx\frac{\partial L}{\partial t}(\mathbf{x}_{k},t_{k})\Delta t_{k}$, which allows us to interpret the events as providing information about the temporal derivative:

[TABLE]

This is an indirect way of measuring brightness, since with standard cameras we are used to measuring absolute brightness. Note that DVS events are triggered by a change in brightness magnitude (2), not by the brightness derivative (3) exceeding a threshold. The above interpretation may be taken into account to design physically-grounded event-based algorithms, such as [23, 24, 7, 62, 63, 64, 65, 28], as opposed to algorithms that simply process events as a collection of points with vague photometric meaning.

Events are Caused by Moving Edges: Assuming constant illumination, linearizing (2) and using the brightness constancy assumption one can show that events are caused by moving edges. For small $\Delta t$, the intensity increment (2) can be approximated by888Eq. (4) can be shown [66] by substituting the brightness constancy assumption (i.e., optical flow constraint) $\frac{\partial L}{\partial t}(\mathbf{x}(t),t)+\nabla L(\mathbf{x}(t),t)\cdot\dot{\mathbf{x}}(t)=0,$ with image-point velocity $\mathbf{v}\equiv\dot{\mathbf{x}}$, in Taylor’s approximation $\Delta L(\mathbf{x},t)\doteq L(\mathbf{x},t)-L(\mathbf{x},t-\Delta t)\approx\frac{\partial L}{\partial t}(\mathbf{x},t)\Delta t$.:

[TABLE]

that is, it is caused by a brightness gradient $\nabla L(\mathbf{x}_{k},t_{k})=(\partial_{x}L,\partial_{y}L)^{\top}$ moving with velocity $\mathbf{v}(\mathbf{x}_{k},t_{k})$ on the image plane, over a displacement $\Delta\mathbf{x}\doteq\mathbf{v}\Delta t$. As the dot product (4) conveys: (i) if the motion is parallel to the edge, no event is generated since $\mathbf{v}\cdot\nabla L=0$; (ii) if the motion is perpendicular to the edge ($\mathbf{v}\parallel\nabla L$) events are generated at the highest rate (i.e., minimal time is required to achieve a brightness change of size $|C|$).

Probabilistic Event Generation Models: Equation (2) is an idealized model for the generation of events. A more realistic model takes into account sensor noise and transistor mismatch, yielding a mixture of frozen and temporally varying stochastic triggering conditions represented by a probability function, which is itself a complex function of local illumination level and sensor operating parameters. The measurement of such probability density was shown in [2] (for the DVS128), suggesting a normal distribution centered at the contrast threshold $C$. The 1$\sigma$ width of the distribution is typically 2-4% temporal contrast. This event generation model can be included in emulators [73] and simulators [74] of event cameras, and in event processing algorithms [24, 66]. Other probabilistic event generation models have been proposed, such as: the likelihood of event generation being proportional to the magnitude of the image gradient [75] (for scenes where large intensity gradients are the source of most event data), or the likelihood being modeled by a mixture distribution to be robust to sensor noise [7]. Future even more realistic models may include the refractory period (i.e., the duration in time that the pixel ignores log brightness changes after it has generated an event; the larger the refractory period the fewer events are produced by fast moving objects), and bus congestion [76].

The above event generation models are simple, developed to some extent based on sensor noise characterization. Just like standard image sensors, DVS’s also have fixed pattern noise (FPN999https://en.wikipedia.org/wiki/Fixed-pattern_noise), but in DVS it manifests as pixel-to-pixel variation in the event threshold. Standard DVS’s can achieve minimum $C\approx\pm$15\text{,}\mathrm{\char 37\relax}$$, with a standard deviation of about $2.5\text{\,}\mathrm{\char 37\relax}4\text{\,}\mathrm{\char 37\relax}$ contrast between pixels [2, 77], and there have been attempts to measure pixelwise thresholds by comparing brightness changes due to DVS events and due to differences of consecutive DAVIS APS frames [78]. However, understanding of temporal DVS pixel and readout noise is preliminary [2, 79, 59, 76], and noise filtering methods have been developed mainly based on computational efficiency, assuming that events from real objects should be more correlated spatially and temporally than noise events [80, 38, 81, 82, 83]. We are far from having a model that can predict event camera noise statistics under arbitrary illumination and biasing conditions. Solving this challenge would lead to better estimation methods.

2.5 Event Camera Availability

Table I summarizes the most popular or recent cameras. The numbers therein are approximate since they were not measured using a common testbed. Event camera characteristics are considerably different from other CMOS image sensor (CIS) technology, and so there is a need for an agreement on standard specifications to be better used by researchers. As Table I shows, since the first practical event camera [2] there has been a trend mainly to increase spatial resolution, increase readout speed, and add features, such as: gray level output (in ATIS and DAVIS), integration with an Inertial Measurement Unit (IMU) [84] and multi-camera timestamp synchronization [85]. IMUs act as a vestibular sense that may improve camera pose estimation, as in visual-inertial odometry. Only recently has the focus turned more towards the difficult task of reducing pixel size for economical mass production of sensors with large pixel arrays. In this respect, 3D wafer stacking fabrication has the biggest impact in reducing pixel size and increasing the fill factor.

Pixel Size: The most widely used event cameras have quite large pixels: $40\text{\,}\mathrm{\SIUnitSymbolMicro m}$ (DVS128), $30\text{\,}\mathrm{\SIUnitSymbolMicro m}$ (ATIS), $18.5\text{\,}\mathrm{\SIUnitSymbolMicro m}$ (DAVIS240, DAVIS346) (Table I). The smallest published DVS pixel [68] is $4.86\text{\,}\mathrm{\SIUnitSymbolMicro m}$; while conventional global shutter industrial APS are typically in the range of $2\text{\,}\mathrm{\SIUnitSymbolMicro m}4\text{\,}\mathrm{\SIUnitSymbolMicro m}$. Low spatial resolution is certainly a limitation for application, although many of the seminal publications are based on the $128\times 128$ pixel DVS128 [2]. The DVS with largest published array size has only about $1\text{\,}\mathrm{M}\mathrm{p}\mathrm{i}\mathrm{x}\mathrm{e}\mathrm{l}$ spatial resolution ($1280\times 960$ pixels [39]). Event camera pixel size has shrunk pretty closely following feature size scaling, which is remarkable considering that a DVS pixel is a mixed-signal circuit, which generally do not scale following technology. However, achieving even smaller pixels is difficult and may require abandoning the strictly asynchronous circuit design philosophy that the cameras started with [86]. Camera cost is constrained by die size (since silicon costs about $5-$10$\mathrm{/}\mathrm{c}\mathrm{m}^{2}$ in mass production), and optics (designing new mass production miniaturized optics to fit a different sensor format can cost tens of millions of dollars).

Fill Factor: A major obstacle for early event camera mass production prospects was the limited fill factor of the pixels (i.e., the ratio of a pixel’s light sensitive area to its total area). Because the pixel circuit is complex, a smaller pixel area can be used for the photodiode that collects light. For example, a pixel with $20\text{\,}\mathrm{\char 37\relax}$ fill factor throws away 4 out of 5 photons. Obviously this is not acceptable for optimum performance; nonetheless, even the earliest event cameras could sense high contrast features under moonlight illumination [2]. Early CIS sensors dealt with this problem by including microlenses that focused the light onto the pixel photodiode. What is probably better, however, is to use back-side illumination technology (BSI). BSI flips the chip so that it is illuminated from the back, so that in principle the entire pixel area can collect photons. Nearly all smartphone cameras are now back illuminated, but the additional cost of BSI fabrication has meant that only recently BSI event cameras were demonstrated [87, 69, 68, 39]. BSI also brings problems: light can create additional ‘parasitic’ photocurrents that lead to spurious ‘leak’ events [56].

Cost: Currently, a practical obstacle to adoption of event camera technology is the high cost of several thousand dollars per camera, similar to the situation with early time of flight, structured lighting and thermal cameras. The high costs are due to non-recurring engineering costs for the silicon design and fabrication (even when much of it is provided by research funding) and the limited samples available from prototype runs. It is anticipated that this price will drop precipitously once this technology enters mass production, as shown by the “Samsung SmartThings Vision” consumer-grade home monitoring device: it contains an event camera [5] and sells for 100 dollars.

Advanced Event Cameras

There are active developments of more advanced event cameras that are only available through scientific collaborations with the developers. Next, we discuss issues related to advanced camera developments and the types of new cameras that are being developed.

Color: Most diurnal animals have some form of color vision, and most conventional cameras offer color sensitivity. Early attempts at color sensitive event cameras [88, 89, 90] tried to use the “vertacolor” principle of splitting colors according to the amount of penetration of the different light wavelengths into silicon, pioneered by Foveon [91, 92]. However, it resulted in poor color separation performance. So far, there are few publications of practical color event cameras, with either integrated color filter arrays (CFA) [93, 94, 95] or color-splitter prisms [96]; splitters have a much higher cost than CFA.

Higher Contrast Sensitivity: Efforts have been made to improve the temporal contrast sensitivity of event cameras, leading to experimental sensors with higher sensitivity [58, 59, 60] (down to laboratory condition $\sim$1\text{,}\mathrm{\char 37\relax}$$). These sensors are based on variations of the idea of a thermal bolometer [97], i.e., increasing the gain before the change detector (Fig. 1) to reduce the input-referred FPN. However this intermediate preamplifier requires active gain control to avoid clipping. Increasing the contrast sensitivity is possible, at the expense of decreasing the dynamic range (e.g., [5]).

3 Event Processing

One of the key questions of the paradigm shift posed by event cameras is how to extract meaningful information from the event data to fulfill a given task. This is a very broad question, since the answer is application dependent, and it drives the algorithmic design of the task solver.

Event cameras acquire information in an asynchronous and sparse way, with high temporal resolution and low latency. Hence, the temporal aspect, specially latency, plays an essential role in the way events are processed. Depending on how many events are processed simultaneously, two categories of algorithms can be distinguished: (i) methods that operate on an event-by-event basis, where the state of the system (the estimated unknowns) can change upon the arrival of a single event, thus achieving minimum latency, and (ii) methods that operate on groups or packets of events, which introduce some latency. Discounting latency considerations, methods based on groups (i.e., temporal windows) of events can still provide a state update upon the arrival of each event if the window slides by one event. Hence, the distinction between both categories is more subtle: an event alone does not provide enough information for estimation, and so additional information, in the form of past events or extra knowledge, is needed. We review this categorization.

Orthogonally, depending on how events are processed, we can distinguish between model-based approaches and model-free (i.e., data-driven, machine learning) approaches. Assuming events are processed in an optimization framework, another classification concerns the type of objective or loss function used: geometric- vs. temporal- vs. photometric-based (e.g., a function of the event polarity or the event activity). Each category presents methods with advantages and disadvantages and current research focuses on exploring the possibilities that each method can offer.

3.1 Event Representations

Events are processed and often transformed into alternative representations (Fig. 3) that facilitate the extraction of meaningful information (“features”) to solve a given task. Here we review popular representations of event data. Several of them arise from the need to aggregate the little information conveyed by individual events in the absence of additional knowledge. Some representations are simple, hand-crafted data transformations whereas others are more elaborate.

Individual events $e_{k}\doteq(\mathbf{x}_{k},t_{k},p_{k})$ are used by event-by-event processing methods, such as probabilistic filters and Spiking Neural Networks (SNNs) (Section 3.3). The filter or SNN has additional information, built up from past events or given by additional knowledge, that is fused with the incoming event asynchronously to produce an output. Examples include: [101, 24, 7, 62, 102].

Event packet: Events $\mathcal{E}\doteq\{e_{k}\}_{k=1}^{N_{e}}$ in a spatio-temporal neighborhood are processed together to produce an output. Precise timestamp and polarity information is retained by this representation. Choosing the appropriate packet size $N_{e}$ is critical to satisfy the assumptions of the algorithm (e.g., constant motion speed during the span of the packet), which varies with the task. Examples are [18, 103, 19, 104].

Event frame/image or 2D histogram: The events in a spatio-temporal neighborhood are converted in a simple way (e.g., by counting events or accumulating polarity pixel-wise) into an image (2D grid) that can be fed to image-based computer vision algorithms. Some algorithms may work in spite of the different statistics of event frames and natural images. Such histograms can provide a natural activity-driven sample rate; see  [105] for methods to accumulate such frames for computing flow. However, this practice is not ideal in the event-based paradigm because it quantizes event timestamps, can discard sparsity (but see [106]), and the resulting images are highly sensitive to the number of events used. Nevertheless the high impact of event frames in the literature [107, 23, 105, 26, 108, 64] is clear because (i) they are a simple way to convert an unfamiliar event stream into a familiar 2D representation containing spatial information about scene edges, which are the most informative regions in natural images, (ii) they inform not only about the presence of events but also about their absence (which is informative), (iii) they have an intuitive interpretation (e.g., an edge map, a brightness increment image) and (iv) they are the data structure compatible with conventional computer vision.

Time surface (TS): A TS is a 2D map where each pixel stores a single time value (e.g., the timestamp of the last event at that pixel [80, 109]). Thus events are converted into an image whose “intensity” is a function of the motion history at that location, with larger values corresponding to a more recent motion. TSs are called Motion History Images in classical computer vision [110]. They explicitly expose the rich temporal information of the events and can be updated asynchronously. Using an exponential kernel, TSs emphasize recent events over past events. To achieve invariance to motion speed, normalization is proposed [111, 112]. Compared to other grid-like representations of events, TSs highly compress information as they only keep one timestamp per pixel, thus their effectiveness degrades on textured scenes, in which pixels spike frequently. To make TSs less sensitive to noise, each pixel value may be computed by filtering the events in a space-time window [113]. More examples include [21, 114, 115, 116].

Voxel Grid: is a space-time (3D) histogram of events, where each voxel represents a particular pixel and time interval. This representation preserves better the temporal information of the events by avoiding to collapse them on a 2D grid (Fig. 3). If polarity is used the voxel grid is an intuitive discretization of a scalar field (polarity $p(x,y,t)$ or brightness variation $\partial L(x,y,t)/\partial t$) defined on the image plane, with absence of events marked by zero polarity. Each event’s polarity may be accumulated on a voxel [117, 118] or spread among its closest voxels using a kernel [119, 120, 8]. Both schemes quantize event timestamps but the latter (interpolated voxel grid) provides sub-voxel accuracy.

3D point set: Events in a spatio-temporal neighborhood are treated as points in 3D space, $(x_{k},y_{k},t_{k})\!\in\!\mathbb{R}^{3}$. Thus the temporal dimension becomes a geometric one. It is a sparse representation, and is used on point-based geometric processing methods, such as plane fitting [21] or PointNet [121].

Point sets on image plane: Events are treated as an evolving set of 2D points on the image plane. It is a popular representation among early shape tracking methods based on mean-shift or ICP [122, 123, 124, 125, 126], where events provide the only data needed to track edge patterns.

Motion-compensated event image [127, 128]: is a representation that depends not only on events but also on motion hypothesis. The idea of motion compensation is that, as an edge moves on the image plane, it triggers events on the pixels it traverses; the motion of the edge can be estimated by warping the events to a reference time and maximizing their alignment, producing a sharp image (i.e., histogram) of warped events (IWE) [128]. Hence, this representation (IWE) suggests a criterion to measure how well events fit a candidate motion: the sharper the edges produced by warping events, the better the fit [99]. Moreover, the resulting motion-compensated images have an intuitive meaning (i.e., the edge patterns causing the events) and provide a more familiar representation of visual information than the events. In a sense, motion compensation reveals a hidden (“motion-invariant”) map of edges in the event stream. The images may be useful for further processing, such as feature tracking [129, 64]. There are motion-compensated versions of point sets [130, 131] and time surfaces [132, 133].

Reconstructed images: Brightness images obtained by image reconstruction (Section 4.6) can be interpreted as a more motion-invariant representation than event frames or TSs, and be used for inference [8] yielding first-rate results.

Event polarity may be considered in two ways: processing positive and negative events separately and merging results (e.g., using TSs [109]), or processing them together in a common representation (e.g., brightness increments images [64]), where polarity is often aggregated among neighboring events. Event polarity depends on motion direction, hence it is a nuisance for tasks that should be independent of motion, such as object recognition (to mitigate this, training data from multiple motion directions should be available). For motion estimation tasks, polarity may be useful, especially to detect abrupt changes of direction.

A general framework for converting event data into some of the above grid-based representations is presented in [100]. It also studies how the choice of representation passed to an artificial neural network (ANN) affects task performance and consequently proposes to automatically learn the representation that maximizes such performance.

3.2 Methods for Event Processing

Event processing systems consist of several stages: pre-processing (input adaptation), core processing (feature extraction and analysis) and post-processing (output creation). The event representations in Section 3.1 may occur at different stages: for example, in [127] an event packet is used at pre-processing, and motion-compensated event images are the internal representation at the core processing stage. In other cases, the above representations may be used only at pre-processing: in [22] events are converted to event images and time surfaces that are then processed by an ANN.

The methods used to process events are influenced by the choice of representation and hardware platform available. These three factors influence each other. For example, it is natural to use dense representations and design algorithms accordingly that are executed on standard processors (e.g., CPUs or GPUs). At the same time, it is also natural to process events one-by-one on SNNs (Section 3.3) that are implemented on neuromorphic hardware (Section 5.1), in search for more efficient and low-latency solutions. Major exponents of event-by-event methods are filters (deterministic or probabilistic) and SNNs. For events processed in packets there are also many methods: hand-crafted feature extractors, deep neural networks (DNNs), etc. Next, we review some of the most common methods.

Event-by-event–based Methods: Deterministic filters, such as (space-time) convolutions and activity filters have been used for noise reduction, feature extraction [134], image reconstruction [135, 62] and brightness filtering [63], among other applications. Probabilistic filters (Bayesian methods), such as Kalman- and particle filters have been used for pose tracking in SLAM systems [101, 75, 24, 25, 7]. These methods rely on the availability of additional information (typically “appearance” information, e.g., grayscale images or a map of the scene), which may be provided by past events or by additional sensors. Then, each incoming event is compared against such information and the resulting mismatch provides innovation to update the filter state. Filters are a dominant class of methods for event-by-event processing because they naturally (i) handle asynchronous data, thus providing minimum processing latency, preserving the sensor’s characteristics, and (ii) aggregate information from multiple small sources (e.g., events).

The other dominant class of methods takes the form of a multi-layer ANN (whether spiking or not) containing many parameters which must be computed from the event data. Networks trained with unsupervised learning typically act as feature extractors for a classifier (e.g., SVM), which still requires some labeled data for training [15, 136, 109]. If enough labeled data is available, supervised learning methods such as backpropagation can be used to train a network without the need for a separate classifier. Many approaches use packets of events during training (deep learning on frames), and later convert the trained network to an SNN that processes data event-by-event [137, 138, 139, 140, 141]. Event-by-event model-free methods have mostly been applied to classify objects [137, 138, 15, 109] or actions [16, 17, 142], and have targeted embedded applications [137], often using custom SNN hardware [15, 17] (Section 5.1). SNNs trained with deep learning typically provide higher accuracy than those relying on unsupervised learning for feature extraction, but there is growing interest in finding efficient ways to implement supervised learning directly in SNNs [143, 142] and in embedded devices [144].

Methods for Groups of Events: Because each event carries little information and is subject to noise, several events are often processed together to yield a sufficient signal-to-noise ratio for the problem considered. Methods for groups of events use the above representations (event packet, event frame, etc.) to gather the information contained in the events in order to estimate the problem unknowns, usually without requiring additional data. Hence, events are processed differently depending on their representation.

Many representations just perform data pre-processing to enable the re-utilization of image-based computer vision tools. In this respect, event frames are a practical representation that has been used by multiple methods on various tasks. In [107, 145] event frames allow to re-utilize traditional stereo methods, providing modest results. They also provide an adaptive frame rate signal that is profitable for camera pose estimation [26] (by image alignment) or optical flow computation [105] (by block matching). Event frames are also a simple yet effective input for image-based learning methods (DNNs, SVMs, Random Forests) [146, 108, 147, 22]. Few works design algorithms taking into account their photometric meaning (4). This was done in [23], showing that such a simple representation allows to jointly compute several visual quantities of interest (optical flow, brightness, etc.). Intensity increment images (4) are also used for feature tracking [64], image deblurring [28] or camera tracking [65].

Because time surfaces (TSs) are sensitive to scene edges and the direction of motion they have been utilized for many tasks involving motion analysis and shape recognition. For example, fitting local planes to the TS yields optical flow information [21, 148]. TSs are used as building blocks of hierarchical feature extractors, similar to neural networks, that aggregate information from successively larger space-time neighborhoods and is then passed to a classifier for recognition [109, 113]. TSs provide proxy intensity images for matching in stereo methods [149, 116], where the photometric matching criterion becomes temporal: matching pixels based on event concurrence and similarity of event timestamps across image planes. Recently, TSs have been probed as input to convolutional ANNs (CNNs) to compute optical flow [22], where the network acts both as feature extractor and velocity regressor. TSs are popular for corner detection using adaptations of image-based methods (Harris, FAST) [114, 115, 111] or new learning-based ones [112]. However, their performance degrades on highly textured scenes [115] due to the “motion overwriting” problem [110].

Methods working on voxel grids include variational optimization and ANNs (e.g., DNNs). They require more memory and often more computations than methods working on lower dimensional representations but are able to provide better results because temporal information is better preserved. In these methods voxel grids are used as an internal representation [117] (e.g., to compute optical flow) or as the multichannel input/output of a DNN [119, 120]. Thus, voxel grids are processed by means of convolutions [119, 120] or the operations derived from the optimality conditions of an objective function [117].

Once events have been converted to grid-like representations, countless tools from conventional vision can be applied to extract information: from feature extractors (e.g., CNNs) to similarity metrics (e.g., cross-correlation) that measure the goodness of fit or consistency between data and task-model hypothesis (the degree of event alignment, etc.). Such metrics are used as objective functions for classification (SVMs, CNNs), clustering, data association, motion estimation, etc. In the neuroscience literature there are efforts to design metrics that act directly on spikes (e.g., event stream), to avoid the issues that arise due to data conversion.

Deep learning methods for groups of events consist of a deep neural network (DNN). Sample applications include classification [150, 151], image reconstruction [8, 118], steering angle prediction [152, 108], and estimation of optical flow [22, 153, 119], depth [153] or ego-motion [119]. These methods differentiate themselves mainly in the representation of the input and in the loss functions optimized during training. Several representations have been used, such as event images [108, 147], TSs [22, 153, 133], voxel grids [119, 120] or point sets [121] (Section 3.1). While loss functions in classification tasks use manually annotated labels, networks for regression tasks from events may be supervised by a third party ground truth (e.g., a pose) [108, 147] or by an associated grayscale image [22] to measure photoconsistency, or be completely unsupervised (depending only on the training input events) [119, 153]. Loss functions for unsupervised learning from events are studied in [99]. In terms of architecture, most networks have an encoder-decoder structure, as in Fig. 4. Such a structure allows the use of convolutions only, thus minimizing the number of network weights. Moreover, a loss function can be applied at every spatial scale of the decoder.

Finally, motion compensation is a technique to estimate the parameters of the motion that best fits a group of events. It has a continuous-time warping model that allows to exploit the fine temporal resolution of events (Section 3.1), and hence departs from conventional image-based algorithms. Motion compensation can be used to estimate ego-motion [127, 128], optical flow [130, 154, 128, 119], depth [128, 19, 99], motion segmentation [154, 132, 155] or feature motion for VIO [129, 131]. The technique in [104] also has a continuous-time motion model, albeit not used for motion compensation but rather to fuse event data with IMU data. To find the parameters of the continuous-time motion models [99, 104], standard optimization methods, e.g., conjugate gradient or Gauss-Newton, may be applied.

The number of events per group (i.e., size of the spatio-temporal neighborhood) is an important hyper-parameter of many methods. It highly depends on the processing algorithm and the available resources, and accepts multiple selection strategies [127, 105, 11, 118], such as constant number of events, constant observation time (i.e., constant frame rate), or more adaptive ones (thresholding the number of events in regions of the image plane) [105]. Utilizing a constant number of events fits naturally with the camera’s output rate but it does not account for spatial variations of the rate. A constant frame rate selects a varying number of events, which may be too few or too many, depending on the scene. Criteria more adapted to the scene dynamics (in time and space) are often preferred but nontrivial to design.

3.3 Biologically Inspired Visual Processing

Biological principles and computational primitives drive the design of event camera pixels and some of the event-processing algorithms (and hardware), such as Spiking Neural Networks (SNNs).

Visual pathways: The DVS [2] was inspired by the function of biological visual pathways, which have “transient” pathways dedicated to processing dynamic visual information in the so-called “where” pathway101010https://en.wikipedia.org/wiki/Two-streams_hypothesis. Animals ranging from insects to humans all have these transient pathways. In humans, the transient pathway occupies about $30\text{\,}\mathrm{\char 37\relax}$ of the visual system. It starts with transient ganglion cells, which are mostly found in retina outside the fovea. It continues with magno layers of the thalamus and particular sublayers of area V1. It then continues to area MT and MST, which are part of the dorsal pathway where many motion selective cells are found [45]. The DVS corresponds to the part of the transient pathway(s) up to retinal ganglion cells. Similarly, the grayscale (EM) events of the ATIS correspond to the “sustained” or “what” pathway through the parvo layers of the brain [36, 43].

Event processing by SNNs: Artificial neurons, such as Leaky-Integrate and Fire or Adaptive Exponential, are computational primitives inspired in neurons found in the mammalian’s visual cortex. They are the basic building blocks of artificial SNNs. A neuron receives input spikes (“events”) from a small region of the visual space (a receptive field), which modify its internal state (membrane potential) and produce an output spike (action potential) when the state surpasses a threshold. Neurons are connected in a hierarchical way, forming an SNN. Spikes may be produced by pixels of the event camera or by neurons of the SNN. Information travels along the hierarchy, from the event camera pixels to the first layers of the SNN and then through to higher (deeper) layers. Most first layer receptive fields are based on Difference of Gaussians (selective to center-surround contrast), Gabor filters (selective to oriented edges), and their combinations. The receptive fields become increasingly more complex as information travels deeper into the network. In ANNs, the computation performed by inner layers is approximated as a convolution. One common approach in artificial SNNs is to assume that a neuron will not generate any output spikes if it has not received any input spikes from the preceding SNN layer. This assumption allows computation to be skipped for such neurons. The result of this visual processing is almost simultaneous with the stimulus presentation [156], which is very different from traditional CNNs, where convolution is computed simultaneously at all locations at fixed time intervals.

Tasks: Bio-inspired models have been adopted for several low-level visual tasks. For example, event-based optical flow can be estimated by using spatio-temporally oriented filters [80, 157, 134] that mimic the working principle of receptive fields in the primary visual cortex [158, 159]. The same type of oriented filters have been used to implement a spike-based model of selective attention [160] based on the biological proposal from [161]. Bio-inspired models from binocular vision, such as recurrent lateral connectivity and excitatory-inhibitory neural connections [162], have been used to solve the event-based stereo correspondence problem [41, 163, 164, 165, 166] or to control binocular vergence on humanoid robots [167]. The visual cortex has also inspired the hierarchical feature extraction model proposed in [168], which has been implemented in SNNs and used for object recognition. The performance of such networks improves the better they extract information from the precise timing of the spikes [169]. Early networks were hand-crafted (e.g., Gabor filters) [53], but recent efforts let the network build receptive fields through brain-inspired learning, such as Spike-Timing Dependent Plasticity (STDP), yielding better recognition rates [136]. This research is complemented by approaches where more computationally inspired types of supervised learning, such as back-propagation, are used in deep networks to efficiently implement spiking deep convolutional networks [170, 171, 143, 172, 173]. The advantages of the above methods over their traditional vision counterparts are lower latency and higher efficiency.

To build small, efficient and reactive computational systems, insect vision is also a source of inspiration for event-based processing. To this end, systems for fast and efficient obstacle avoidance and target acquisition in small robots have been developed [174, 175, 176] based on models of neurons driven by DVS output that respond to looming objects and trigger escape reflexes.

4 Algorithms / Applications

In this section, we review several works on event-based vision, presented according to the task addressed. We start with low-level vision on the image plane, such as feature detection, tracking, and optical flow estimation. Then, we discuss tasks that pertain to the 3D structure of the scene, such as depth estimation, visual odometry (VO) and historically related subjects, e.g., intensity image reconstruction. Finally, we consider motion segmentation, recognition and coupling perception with control.

4.1 Feature Detection and Tracking

Feature detection and tracking on the image plane are fundamental building blocks of many vision tasks such as visual odometry, object segmentation and scene understanding. Event cameras make it possible to track asynchronously, adapted to the dynamics of the scene and with low latency, high dynamic range and low power (Section 2.2). Thus, they allow to track in the “blind” time between the frames of a standard camera. To do so, the methods developed need to deal with the unique space-time and photometric characteristics of the visual signal: events report only brightness changes, asynchronously (Section 2.3).

Challenges: Since events represent brightness changes, which depend on motion direction, one of the main challenges of feature detection and tracking with event cameras is overcoming the variation of scene appearance caused by such motion dependency (Fig. 5). Tracking requires the establishment of correspondences between events (or features built from the events) at different times (i.e., data association), which is difficult due to the varying appearance. The second main challenge consists of dealing with sensor noise and possible event clutter caused by the camera motion.

Literature Review: Early event-based feature methods were very simple and focused on demonstrating the low-latency and low-processing requirements of event-driven vision systems. Hence they assumed a stationary camera scenario and tracked moving objects as clustered blob-like sources of events [122, 14, 6, 177, 12], circles [178] or lines [54]. Only pixels that generated events needed to be processed. Simple Gaussian correlation filters sufficed to detect blobs of events, which could be modeled by Gaussian Mixtures [179]. For tracking, each incoming event was associated to the nearest existing blob/feature and used to asynchronously update its parameters (location, size, etc.). Circles [178] and lines [54] were treated as blobs in the Hough transform space. These methods were used in traffic monitoring and surveillance [122, 14, 179], high-speed robotic tracking [6, 12] and particle tracking in fluids [177] or microrobotics [178]. However, they worked only for a limited class of object shapes.

Tracking of more complex, high-contrast user-defined shapes has been demonstrated using event-by-event adaptations of the Iterative Closest Point (ICP) algorithm [123], gradient descent [124], Mean-shift and Monte-Carlo methods [180], or particle filtering [181]. The iterative methods in [123, 124] used a nearest-neighbor strategy to associate incoming events to the target shape and update its transformation parameters, showing very high-speed tracking ($200\text{\,}\mathrm{kHz}$ equivalent frame rate). Other works [180] handled geometric transformations of the target shape (aka “kernel”) by matching events against a pool of rotated and scaled versions of it. The predefined kernels tracked the object without overlapping themselves due to a built-in repulsion mechanism. Complex objects, such as faces or human bodies, have been tracked with part-based shape models [182], where objects are represented as a set of basic elements linked by springs [183]. The part trackers simply follow incoming blobs of events generated by ellipse-like shapes, and the elastic energy of this virtual mechanical system provides a quality criterion for tracking. In most tracking methods events are treated as individual points (without polarity) and update the system’s state asynchronously, with minimal latency. The performance of the methods strongly depends on the tuning of several model parameters, which is done experimentally according to the object to track [180, 182].

The previous methods require a priori knowledge or user input to determine the objects to track. This restriction is valid for scenarios like tracking cars on a highway or balls approaching a goal, where knowing the objects greatly simplifies the computations. But when the space of objects becomes larger, methods to determine more realistic features become necessary. The features proposed in [125, 130] consist of local edge patterns that are represented as point sets. Incoming events are registered to them by means of some form of ICP. Other methods [129, 27] proposed to re-utilize well-known feature detectors [184] and trackers [185] on patches of motion-compensated event images (Section 3.1), providing good results. All these methods allowed to track features for cameras moving in natural scenes, hence enabling ego-motion estimation in realistic scenarios [126, 131, 129]. Features built from motion-compensated events (in image form [129] or point-set form [130]) provide a useful representation of edge patterns. However, they depend on motion direction, and, therefore, trackers suffer from drift as event appearance changes over time [64]. To track with no drift, motion-invariant features are needed.

Combining Events and Frames: Data association (Fig. 5) simplifies if the absolute intensity of the pattern to be tracked (Fig. 5c, i.e., a motion-invariant representation or “map” of the feature) is available. This is the approach followed by works that leverage the strengths of a combined frame- and event-based sensor (à la DAVIS [4]). The algorithms in [125, 126, 64] automatically detect arbitrary edge patterns (features) on the frames and track them asynchronously with events. The feature location is given by the Harris corner detector [184] and the feature descriptor is given by the edge pattern around the corner: [125, 126] convert Canny edges to point sets used as templates for ICP tracking, thus they assume events are mostly triggered at strong edges. In contrast, the edge pattern in [64] is given by the frame intensities, and tracking consists of finding the motion parameters that minimize the photometric error between the events and their frame prediction using a generative model (4). A comparison of five feature trackers is provided in [64], showing that the generative model is most accurate, with sub-pixel performance, albeit it is computationally expensive. Finally, [64] also shows the interesting fact that an event-based sensor suffices: frames can be replaced by images reconstructed from events (Section 4.6) and still achieve similar detection and tracking results.

Corner Detection and Tracking: Since event cameras naturally respond to edges in the scene, they shorten the detection of lower-level primitives such as keypoints or “corners”. Such primitives identify pixels of interest around which local features can be extracted without suffering from the aperture problem, and therefore provide reliable tracking information. The method in [186] computes corners as the intersection of two moving edges, which are obtained by fitting planes in the space-time stream of events. To deal with event noise, least-squares is supplemented by a sampling technique similar to RANSAC. This method of fitting planes locally to time surfaces has also been profitable to estimate optical flow [21] and “event lifetime” [148], which are obtained from the coefficients of the planes. Recently, extensions of popular frame-based keypoint detectors, such as Harris [184] and FAST [187], have been developed for event cameras [114, 115, 111], by operating on time surfaces (TSs) as if they were natural intensity images. In [114] the TS is binarized before applying the derivative filters of Harris’ detector. To speed up detection, [115] replaces the derivative filters with pixelwise comparisons on two concentric circles of the TS around the current event. Moving corners produce local TSs with two clearly separated regions: recent vs. old events. Hence, corners are obtained by searching for arcs of contiguous pixels with higher TS values than the rest. The method in [111] improves the detector in [115] and proposes a strategy to track the corners. Assuming corners follow continuous trajectories on the image plane and the detected event corners are accurate, these are threaded by proximity along trajectories, following a tree-based hypothesis graph. The above TS-based hand-crafted corner detectors suffer from variations of the TS due to changes in motion direction. To overcome them, [112] proposes a data-driven method to learn the TS appearance of intensity-image corners. To this end, a grayscale input (from DAVIS or ATIS camera) provides the supervisory signal to label the corners. As a trade-off between accuracy and speed, a random forest classifier is used. Event corners find multiple applications, such as visual odometry or ego-motion segmentation [188]; yet there are only a few demonstrations.

Opportunities: In spite of the abundance of detection and tracking methods, they are rarely evaluated on common datasets for performance comparison. Establishing benchmark datasets [189] and evaluation procedures will foster progress in this and other topics. Also, in most algorithms, parameters are defined experimentally according to the tracking target. It would be desirable to have adaptive parameter tuning to increase the range of operation of the trackers. Learning-based feature detection and tracking methods also offer considerable room for research.

4.2 Optical Flow Estimation

Optical flow estimation is the problem of computing the velocity of objects on the image plane without knowledge about the scene geometry or motion. The problem is ill-posed and thus requires regularization to become tractable.

Event-based optical flow estimation is challenging because of the unfamiliar way in which events encode visual information (Section 2). In conventional cameras optical flow is obtained by analyzing two consecutive images. These provide spatial and temporal derivatives that are substituted in the brightness constancy assumption (p. 8), which together with smoothness assumptions provide enough equations to solve for the flow at each image pixel. In contrast, events provide neither absolute brightness nor spatially continuous data. Each event does not carry enough information to determine flow, and so events need to be aggregated to produce an estimate, which leads to the unusual question of where in the $x$-$y$-$t$-space of the image plane spanned by the events is flow computed. Ideally one would like to know the flow field over the whole space, which deems computationally expensive. In practice, optical flow is computed only at specific points: at the event locations, or at images with artificially-chosen times. Nevertheless, computing flow from events is attractive because they represent edges, which are the parts of the scene where flow estimation is less ambiguous, and because their fine timing information allows measuring high speed flow [11]. Finally, another challenge is to design a flow estimation algorithm that is biologically plausible, i.e., compatible with what is known from neuroscience about early processing in the primate visual cortex, and that can be implemented efficiently in neuromorphic processors.

Literature Review: Table II lists some event-based optical flow methods, categorized according to different criteria. Early works [191] tried to adapt classical approaches in computer vision to event-based data (Fig. 6b). These are based on the brightness constancy assumption [185], and discussion focused on whether events carried enough information to estimate flow with such approaches [134]. Events allow to estimate the temporal derivative of brightness (3), and so additional assumptions were needed to approximate the spatial derivative $\nabla L$ in order to apply such classical methods [185]. However, due to the potentially very small number of events generated at each pixel as an edge crosses over it, it is difficult to estimate derivatives ($\nabla L,\partial L/\partial t$) reliably [134], which leads gradient-based methods like [191] to inconclusive flow estimates. Approaches that consider the local distribution of events in the $x$-$y$-$t$-space, as in [21], are more robust and therefore preferred.

The method in [21] reasons about the local distribution of events geometrically, in terms of time surfaces and planar approximations. As an edge moves it produces events that resemble points on a surface in space-time (the time surface, Section 3). The surface slopes in the $x$-$t$ and $y$-$t$ cross sections encode the edge motion, thus optical flow is estimated by fitting planes to the surface and reading the slopes from the plane coefficients. In spite of providing only normal flow (i.e., the component of the optical flow perpendicular to the edge), the method works even in the case of only a few generated events. Of course, the goodness of fit depends on the size of the spatio-temporal neighborhood (this remark generalizes to other methods). If the neighborhood is too small then the plane fit may become arbitrary. If the neighborhood is too large then the event stream may not be well approximated by a local plane.

A hierarchical architecture for optical flow estimation building on experimental findings of the primate visual system is proposed in [134]. It applies a set of spatio-temporal filters on the event stream to yield selectivity to different motion speeds and directions (à la Gabor filters) while maintaining the sparse representation of events. Such filters are formally equivalent to spatio-temporal correlation detectors. Other biologically-inspired methods [157, 102] can also be interpreted as filter banks sampling the event stream along different spatio-temporal orientations; [157] and [134] define hand-crafted filters, whereas [102] learns them from event data using a novel STDP rule. The SNN in [157] detects motion patterns by delaying events through synaptic connections and employing neurons as coincidence detectors. Its neurons are sensitive to 8 speeds and 8 directions (i.e., 64 velocities) over receptive fields of $5\times 5$ pixels. These methods are implementable in neuromorphic hardware, offering low-power, efficient computations.

The method in [193] targets the issue of flow estimation at textured regions. It converts events into event frames and applies a Gabor filter bank. Then, assuming constancy of the (spatio-temporal) edges of the event frame, optical flow is given by the phase gradient [198] of the filter bank output. Due to the aperture problem, only the velocity in the direction of the spatial phase gradient can be computed.

Methods like [117, 23] estimate optical flow jointly with other quantities, notably image intensity, so that the quantities involved bring in well-known equations and boost each other towards convergence. Knowing image intensity, or equivalently ($\nabla L,\partial L/\partial t$), is desirable since it can be used on the brightness constancy law to provide constraints on the optical flow. In this respect, [117] combines multiple equations ((2), brightness constancy, smoothness priors, etc.) as penalty terms into an objective function that is optimized via calculus of variations. The method finds the optical flow and image intensity on the image plane that minimizes the objective function, i.e., that best explains the distribution of events in the $x$-$y$-$t$-space (using a voxel grid). Thus, it outputs a dense flow (i.e., flow at every pixel). Flow vectors at pixels where no events were produced (i.e., regions of homogeneous brightness) are due to the smoothness priors, thus they are less reliable than those computed at pixels where events were triggered (i.e., at edges).

The method in [105] estimates optical flow by computing event frames (Section 3) at an adaptive rate and applying video coding techniques (block matching). It can be interpreted as finding the optical flow vector that best matches the distributions of events within two cuboids (collapsed into event frames). Thus, the optical flow problem is posed as that of finding event correspondences, i.e., events triggered by the same scene point (at different times). The method defines two sets of events (“blocks”) and a similarity metric to compare them. It is assumed that the appearance of event frames do not change significantly for short times and hence simple metrics, such as sum of absolute distances, suffice to compare them. The method can be implemented in FPGA, trading off efficiency for accuracy.

The framework in [128, 154, 99] computes optical flow by maximizing the sharpness of image patches obtained by warping cuboids of events, producing motion-compensated images (Section 3). It can be interpreted as applying an adaptive filter to the events, where the filter coefficients define the spatio-temporal direction that maximizes the filter’s response. Motion compensation was also used to compute flow in [130], albeit using point sets.

Recently, deep learning methods have emerged [22, 119, 153]. These are based on the availability of large amounts of event data paired with an ANN. In [22], an encoder-decoder CNN is trained using a self-supervised scheme to estimate dense optical flow. The loss function measures the error between DAVIS grayscale images aligned using the flow produced by the network. The trained network is able to accurately predict optical flow from events only, passed as time surfaces and event frames. The work [153] presents the first monocular ANN architecture to estimate dense optical flow, depth and ego-motion (i.e., learning structure from motion) from events only. The input to the ANN consists of events over multiple time slices, given as event frames and time surfaces with average timestamps. This reduces event noise and preserves the structure of the event stream better than [22]. The network is trained unsupervised, measuring the photometric error between the events in neighboring time slices aligned using the estimated flow. Later, [22] was extended to unsupervised learning of flow and ego-motion in [119] using a motion-compensation loss function in terms of time surfaces.

Evaluation: Optical flow estimation is computationally expensive. Some methods [117, 22, 153, 119] require a GPU, while other approaches are more lightweight [105], albeit not as accurate. Few algorithms [157, 21, 134, 105] have been pushed to hardware logic circuits that offload CPU and minimize latency. The review [190] compared some early event-based optical flow methods [80, 191, 21], but only on flow fields generated by a rotating camera, i.e., lacking motion parallax and occlusion. For newer methods, there are multiple trade offs (accuracy vs. efficiency vs. latency) that have not been properly quantified yet.

Opportunities: Comprehensive datasets with accurate ground truth optical flow in multiple scenarios (varying texture, speed, parallax, occlusions, illumination, etc.) and a common evaluation methodology would be essential to assess progress and reproducibility in this paramount low-level vision task. Providing ground truth event-based optical flow in real scenes is challenging, especially for moving objects not conforming to the motion field induced by the camera’s ego-motion. A thorough quantitative comparison of existing event-based optical flow methods would help identify key ideas to develop improved methods.

4.3 3D reconstruction. Monocular and Stereo

Depth estimation with event cameras is a broad field. It can be divided according to the considered scenario and camera setup or motion, which determine the problem assumptions.

Instantaneous Stereo: Most works on depth estimation with event cameras target the problem of “instantaneous” stereo, i.e., 3D reconstruction using events on a very short time (ideally on a per-event basis) from two or more synchronized cameras that are rigidly attached. Being synchronized, the events from different image planes share a common clock. These works follow the classical two-step stereo solution: first solve the event correspondence problem across image planes (i.e., epipolar matching) and then triangulate the location of the 3D point [199]. The main challenge is finding correspondences between events; it is the computationally intensive step. Events are matched (i) using traditional stereo metrics (e.g., normalized cross-correlation) on event frames [200, 145] or time surfaces [149] (Section 3), and/or (ii) by exploiting simultaneity and temporal correlations of the events across sensors [201, 202, 149]. These approaches are local, matching events by comparing their neighborhoods since events cannot be matched based on individual timestamps [203, 170]. Additional constraints, such as the epipolar constraint [204], ordering, uniqueness, edge orientation and polarity may be used to reduce matching ambiguities and false correspondences, thus improving depth estimation [18, 205, 170]. Event matching can also be done by comparing local context descriptors [206, 207] of the spatial distribution of events on both stereo image planes.

Global approaches produce better depth estimates (i.e., less sensitive to ambiguities) than local approaches by considering additional regularity constraints. In this category, we find extensions of Marr and Poggio’s cooperative stereo algorithm [162] for the case of event cameras [41, 166, 208, 164, 165]. These approaches consist of a network of disparity sensitive neurons that receive events from both cameras and perform various operations (amplification, inhibition) that implement matching constraints (uniqueness, continuity) to extract disparities. They use not only the temporal similarity to match events but also their spatio-temporal neighborhoods, with iterative nonlinear operations that result in an overall globally-optimal solution. A discussion of cooperative stereo is provided in [43]. Also in this category are [209, 210, 211], which use Belief Propagation on a Markov Random Field or semiglobal matching [212] to improve stereo matching. These methods are primarily based on optimization, trying to define a well-behaved energy function whose minimizer is the correct correspondence map. The energy function incorporates regularity constraints, which enforce coupling of correspondences at neighboring points and therefore make the solution map less sensitive to ambiguities than local methods, at the expense of computational effort. A table comparing different stereo methods is provided in [213]; however, it should be interpreted with caution since the methods were not benchmarked on the same dataset.

Recently, brute-force space-sweeping using dedicated hardware (a GPU) has been proposed [214]. The method is based on ideas similar to [19, 128]: the correct depth manifests as “in focus” voxels of displaced events in the Disparity Space Image [215, 19]. In contrast, other approaches pair event cameras with neuromorphic processors (Section 5.1) to produce fully event-based low-power ($100\text{\,}\mathrm{mW}$), high-speed stereo systems [165, 213]. There is an efficiency vs. accuracy trade-off that has not been quantified yet.

Most of the methods above are demonstrated in scenes with static cameras and few moving objects, so that correspondences are easy to find due to uncluttered event data. Event matching happens with low latency, at high rate (\sim$$1\text{\,}\mathrm{kHz}) and consuming little power, which shows that event cameras are promising for high-speed 3D reconstructions of moving objects or in uncluttered scenes.

Multi-Perspective Panoramas: Some works [216, 217] also target the problem of instantaneous stereo (depth maps produced using events over very short time intervals), but using two non-simultaneous event cameras. These methods exploit a constrained hardware setup (two rotating event cameras with known motion) to either (i) recover intensity images on which conventional stereo is applied [216] or (ii) match events using temporal metrics [217].

Monocular Depth Estimation: Depth estimation with a single event camera has been shown in [19, 25, 128]. It is a significantly different problem from previous ones because temporal correlation between events across multiple image planes cannot be exploited. These methods recover a semi-dense 3D reconstruction of the scene (i.e., 3D edge map) by integrating information from the events of a moving camera over time, and therefore require knowledge of camera motion. Hence they do not pursue instantaneous depth estimation, but rather depth estimation for SLAM [218].

The method in [25] is part of a pipeline that uses three filters operating in parallel to jointly estimate the motion of the event camera, a 3D map of the scene, and the intensity image. Their depth estimation approach requires using an additional quantity—the intensity image—to solve for data association. In contrast, [19] (Fig. 7) proposes a space-sweep method that leverages the sparsity of the event stream to perform 3D reconstruction without having to establish event matches or recover the intensity images. It back-projects events into space, creating a ray density volume [219], and then finds scene structure as local maxima of ray density. It is computationally efficient and used for VO in [26].

Stereo Depth for SLAM: Recently, inspired by work in small-baseline multi-view stereo [220], a stereo depth estimation method for SLAM has been presented [116]. It obtains a semi-dense 3D reconstruction of the scene by optimizing the local spatio-temporal consistency of events across image planes using time surfaces. It does not follow the classical paradigm of event matching plus triangulation [149], but rather a forward-projection approach that enables depth estimation without establishing event correspondences explicitly. The method opens the door for bringing the advantages of event cameras to event-based stereo SLAM applications such as self-driving cars.

Depth Estimation using Structured Light: All the above 3D reconstruction methods are passive, i.e., do not interfere with the scene. In contrast, there are some works on event-based active 3D reconstruction, based on emitting light onto the scene and measuring reflection with event cameras [221, 20, 222]. For example, [221] combines a DVS with a pulsed line laser to allow fast terrain reconstruction, in the style of a 3D line scanner. Motion Contrast 3D scanning [20] is a structured light technique that simultaneously achieves high resolution, high speed and robust performance in challenging 3D scanning environments (e.g., strong illumination, or highly reflective and moving surfaces). Active systems with pulsed lasers exploit the high temporal resolution and redundancy suppression of event cameras, but they are application specific and may not be safe (depending on the power of the laser needed to scan far away objects).

Opportunities: Although there are many methods for event-based depth estimation, it is difficult to compare their performance since they are not evaluated on the same dataset. In this sense, it would be desirable to (i) provide a comprehensive dataset and testbed for event-based depth evaluation and (ii) benchmark many existing methods on the dataset, to be able to compare their performance.

4.4 Pose Estimation and SLAM

Addressing the Simultaneous Localization and Mapping (SLAM) problem with event cameras has been difficult because most methods and concepts developed for conventional cameras (feature detection, matching, iterative image alignment, etc.) are not applicable or were not available; events are fundamentally different from images. The challenge is therefore to design new SLAM techniques that are able to unlock the camera’s advantages (Sections 2.3 and 2.2), showing their usefulness to tackle difficult scenarios for current frame-based cameras. Historically, the design goal of such techniques has focused on preserving the low-latency nature of the data, i.e., being able to produce a state estimate for every incoming event (Section 3). However, each event does not contain enough information to estimate the state from scratch (e.g., the six degrees of freedom (DOF) pose of a calibrated camera), and so the goal becomes that each event be able to asynchronously update the state of the system. Probabilistic (Bayesian) filters [223] are popular in event-based SLAM [224, 75, 24, 7] because they naturally fit with this description. Their main adaptation for event cameras consists of designing sensible likelihood functions based on the event generation process (Section 2.4).

Since events are caused by the apparent motion of intensity edges, the majority of maps emerging from SLAM systems naturally consist only of scene edges, i.e., semi-dense maps (Fig. 8 and [19]). However, note that an event camera does not directly measure intensity gradients but only temporal changes (2), and so the presence, orientation and strength of edges (on the image plane and in 3D) must be estimated together with the camera’s motion. The strength of the intensity gradient at a scene point is correlated with the firing rate of events corresponding to that point, and it enables reliable tracking [103]. Edge information for tracking may also be obtained from gradients of brightness maps [24, 25, 7] used in generative models (Section 2.4).

The event-based SLAM problem in its most general setting (6-DOF motion and natural 3D scenes) is a challenging problem that has been addressed step-by-step in scenarios with increasing complexity. Three complexity axes can be identified: dimensionality of the problem, type of motion and type of scene. The literature is dominated by methods that address the localization subproblem first (i.e., motion estimation) because it has fewer degrees of freedom to estimate. Regarding the type of motion, solutions for constrained motions, such as rotational or planar (both being 3-DOF), have been investigated before addressing the most complex case of a freely moving camera (6-DOF). Solutions for artificial scenes in terms of photometry (high contrast) and/or structure (line-based or 2D maps) have been proposed before focusing on the most difficult case: natural scenes (3D and with arbitrary photometric variations). Some proposed solutions require additional sensing (e.g., RGB-D) to reduce the complexity of the problem. This, however, introduces some of the bottlenecks present in frame-based systems (e.g., latency and motion blur). Table III classifies the related work using these complexity axes.

Camera Tracking Methods: Pose tracking with an event camera was first presented in [101]. It proposed a particle filter to track the motion of a ground robot that was viewing a flat scene, which was parallel to the plane of motion and consisted of artificial B&W line patterns. The main innovation was the design of the likelihood function to quantify the event generation probability given the robot’s pose and scene map. The function was based on the reprojection error between the event’s location and the nearest edge in the map. In [75], a standard grayscale camera was attached to a DVS to estimate, using a Bayesian filter, the small displacement between the current event and the previous frame of the standard camera. The system was developed for planar motion and B&W scenes. The likelihood function was proportional to the strength of the gradient of the map at the event’s location (Section 2.4). In [227], pose tracking under a non-holonomic and planar motion was proposed, supporting loop closure and topologically-correct trajectories. It converted events into frames and used traditional method SeqSLAM.

Estimation of the 3D orientation of an event camera has been addressed in [24, 127, 103]. The rotational motion of the camera was tracked by [24] using a particle filter, whose likelihood function was approximately Gaussian centered at a contrast sensitivity $C\approx 0.2$ (Section 2.4). The work in [103] estimated the camera’s rotation by minimization of a photometric error at the event locations; it used a map of event probabilities that represented the strength of the scene edges [224]. Finally, the motion-compensation optimization framework (Section 3) was introduced in [127] to estimate the angular velocity of the camera rather than its absolute rotation. These systems are restricted to rotational motions, and, thus, do not account for translation or depth. Nevertheless they inspire ideas to solve more complex problems, such as [25, 129, 128].

Camera tracking in 6-DOF is the most challenging one. An event-based algorithm to track the pose of a DVS during very high-speed motion was presented in [226]. This was a hand-crafted method developed for artificial, B&W line-based maps, rather than a probabilistic filter. It assumed that events were generated only by one of the map lines (the one closest to the event), which were tracked and intersected to provide points for PnP methods (camera resectioning). A continuous-time formulation and extension of such method was given in [228]. It computed the camera trajectory, rather than individual poses, by non-linear optimization of the event-to-line reprojection error. By contrast, [7, 65] showed 6-DOF high-speed tracking capabilities in natural scenes. They used a generative model: [7] proposed a probabilistic filter with a robust likelihood function comprising mixture densities (Section 2.4), whereas [65] pursued non-linear optimization of the photometric error between brightness increment images (Section 3.1) and their prediction given the scene map. The latter gave slightly better results.

Tracking and Mapping: Let us focus on methods that address the tracking-and-mapping problem. Cook et al. [23] proposed a generic message-passing algorithm within an interacting network to jointly estimate ego-motion, image intensity and optical flow from events. However, the system was restricted to rotational motion. Joint estimation is appealing because it allows to employ as many equations as possible relating the variables (e.g., (4) and rotational prior) in the hope of finding a better solution to the problem.

An event-based 2D SLAM system was presented in [224] by extension of [101], and thus it was restricted to planar motion and high-contrast scenes. The method used a particle filter for tracking, with the event likelihood function inversely related to the the reprojection error of the event with respect to the map. The map of scene edges was concurrently built; it consisted of an occupancy map [223], with each pixel representing the probability that the pixel triggered events. The method was extended to 3D in [225], but it relied on an external RGB-D sensor attached to the event camera for depth estimation. The depth sensor introduced bottlenecks, which deprived the system of the low latency and high-speed advantages of event cameras.

The filter-based approach in [24] showed how to simultaneously track the 3D orientation of a rotating event camera and create high-resolution panoramas of natural scenes. It operated probabilistic filters in parallel for both subtasks. A panoramic gradient was built using per-pixel Kalman filters, each one estimating the orientation and strength of the scene edge at its location. This gradient map was then upgraded to an absolute intensity one with super-resolution and HDR properties by Poisson integration. SLAM during rotational motion was also presented in [103], where camera tracking was performed by minimization of a photometric error at the event locations given a probabilistic edge map. The map was simultaneously built, and each map point represented the probability of events being generated at that location [224]. Hence it was a panoramic occupancy map measuring the strength of the scene edges.

Recently, solutions to the full problem of event-based 3D SLAM for 6-DOF motions and natural scenes, not relying on additional sensing, have been proposed [25, 26] (Table III). The approach in [25] extends [24] and consists of three interleaved probabilistic filters to perform pose tracking as well as depth and intensity estimation. However, it suffers from limited robustness (especially during initialization) due to the assumption of uncorrelated depth, intensity gradient, and camera motion. Furthermore, it is computationally intensive, requiring a GPU for real-time operation. In contrast, the semi-dense approach in [26] shows that intensity reconstruction is not needed for depth estimation or pose tracking. The approach has a geometric foundation: it performs space sweeping for 3D reconstruction [19] and edge-map alignment (non-linear optimization with few events per frame) for pose tracking. The resulting SLAM system runs in real-time on a CPU.

Trading off latency for efficiency, probabilistic filters [224, 24, 25] can operate on small groups of events. Other approaches are natively designed for groups, based for example on non-linear optimization [26, 127, 128], and run in real time on the CPU. Processing multiple events simultaneously is also beneficial to reduce noise.

Opportunities: The above-mentioned SLAM methods lack loop-closure capabilities to reduce drift. Currently, the scales of the scenes on which event-based SLAM has been demonstrated are considerably smaller than those of frame-based SLAM. However, trying to match both scales may not be a sensible goal since event cameras may not be used to tackle the same problems as standard cameras; both sensors are complementary, as argued in [75, 7, 27, 64]. Stereo event-based SLAM [229] is an unexplored topic, as well as designing more accurate, efficient and robust methods than the existing monocular ones. Robustness of SLAM systems can be improved by sensor fusion with IMUs [218, 27].

4.5 Visual-Inertial Odometry (VIO)

The robustness of event-based visual odometry and SLAM systems can be improved by combining an event camera with an inertial measurement unit (IMU) rigidly attached. VIO is qualitatively different from VO: a VO system may lose track (i.e., fail to produce an output pose). In contrast, a VIO system does not “fail” (there is always an output pose), it drifts. For this and other reasons, some event cameras have an integrated IMU (see Table I).

A key issue in VIO is how to temporally fuse data from the synchronous, high-rate IMU (e.g., $1\text{\,}\mathrm{kHz}$) and the asynchronous event camera. There are three options in the literature: (i) use an asynchronous probabilistic filter [131], (ii) use pre-integration theory [230] to convert IMU data into lower-rate pieces of information at desired times where events are collected [131, 129, 27] or (iii) consider a continuous-time framework so that both sensor measurements are referred to a common temporal axis that is also used to model the solution (i.e., the camera poses) [104].

Feature-based VIO: The majority of existing event-based VIO systems are “feature-based”, consisting of two stages: first, features tracks are extracted from the events (Section 4.1), and then these point trajectories on the image plane are fused with IMU data using modern VIO algorithms, such as [231, 232, 230]. That is, a front-end converts the photometric information conveyed by the events into geometric information that is then processed by highly optimized geometric VIO pipelines. For example, [131] tracked features using [130], and combined them with IMU data by means of a Kalman filter [231]. Recently, [129] proposed to synthesize motion-compensated event images from spatio-temporal windows of events (Section 3) and then detect-and-track features using classical methods [187, 185]. Feature tracks were fused with inertial data by means of keyframe-based nonlinear optimization [232] to recover the camera trajectory and a sparse map of 3D landmarks. Later, the nonlinear optimization in [129] was extended to also fuse intensity frames [27], and was demonstrated on a resource-constrained platform (quadrotor), enabling it to fly in low light and HDR scenarios by exploiting the advantages of event cameras. The above methods are benchmarked on the 6-DOF motion dataset [98], and each method outperforms its predecessor.

Reprojection-error–based VIO: The work in [104] presents a different approach, fusing events and inertial data using a continuous-time framework [233]. As opposed to the above-mentioned feature-based methods, it optimizes a combined objective with inertial- and event-reprojection error terms over a segment of the camera trajectory, in the style of visual-inertial bundle adjustment.

Opportunities: The above works adapt state-of-the-art VIO methods for conventional cameras by first converting events into geometric information. However, it should be possible to avoid this conversion step and directly recover the camera motion and scene structure from the events, as suggested by [128]; for example, by optimizing a function with photometric (i.e., event firing rate [26]) and inertial error terms, akin to VI-DSO [234] for standard cameras.

Stereo event-based VIO is an unexplored topic, and it would be interesting to see how ideas from event-based depth estimation can be combined with SLAM and VIO.

Also to be explored are learning-based approaches to tackle all of the above problems. Currently, literature is dominated by model-based methods, but, as it happened in frame-based vision, we anticipate that learning-based methods will also play a major role in event-based processing. Some works in this direction are [109, 108, 113, 119].

4.6 Image Reconstruction

Events represent brightness changes, and so, in ideal conditions (noise-free scenario, perfect sensor response, etc.) integration of the events yields “absolute” brightness. This is intuitive, since events are just a non-redundant (i.e., “compressed”) per-pixel way of encoding the visual content in the scene. Event integration or, more generically, image reconstruction (Fig. 9) can be interpreted as “decompressing” the visual data encoded in the event stream. Due to the very high temporal resolution of the events, brightness images can be reconstructed at very high frame rate (e.g., $2\text{\,}\mathrm{kHz}5\text{\,}\mathrm{kHz}$ [235, 8]) or even continuously in time [62].

As the literature reveals, the insight about image reconstruction from events is that it requires regularization. Event cameras have independent pixels that report brightness changes, and, consequently, per-pixel integration of such changes during a time interval only produces brightness increment images. To recover the absolute brightness at the end of the interval, an offset image (i.e., the brightness image at the start of the interval) would need to be added to the increment [98, 78]. Surprisingly, some works have used spatial and/or temporal smoothing [135, 235, 236, 62] to reconstruct brightness starting from a zero initial condition, i.e., without knowledge of the offset image. Other forms of regularization, using learned features from natural scenes [235, 120, 118, 8] are also effective.

Literature Review: Image reconstruction from events was first established in [23] under rotational camera motion and static scene assumptions. These assumptions together with the brightness constancy (4) were used in a message-passing algorithm between pixels in a network of visual maps to jointly estimate several quantities, such as scene brightness. Also under the above motion and scene assumptions, [24] showed how to reconstruct high-resolution panoramas from the events, and they popularized the idea of event-based HDR image reconstruction. Each pixel of the panoramic image used a Kalman filter to estimate the brightness gradient (based on (4)), which was then integrated using Poisson reconstruction to yield absolute brightness. The method in [238] exploited the constrained motion of a platform rotating around a single axis to reconstruct images that were then used for stereo depth estimation.

Motion restrictions were then replaced by regularizing assumptions to enable image reconstruction for generic motions and scenes [117]. In this work, image brightness and optical flow were simultaneously estimated using a variational framework that contained several penalty terms (on data fitting (1) and smoothness of the solution) to best explain a space-time volume of events discretized as a voxel grid. This method was the first to show reconstructed video from events in dynamic scenes. Later [135, 236, 235] showed that image reconstruction was possible even without having to estimate motion. This was done using a variational image denoising approach based on time surfaces [135, 236] or using sparse signal processing with a patch-based learned dictionary that mapped events to image gradients, which were then Poisson-integrated [235]. Concurrently, the VO methods in [25, 26] extended the image reconstruction technique in [24] to 6-DOF camera motions by using the computed scene depth and poses: [25] used a robust variational regularizer to reduce noise and improve contrast of the reconstructed image, whereas [26] showed image reconstruction as an ancillary result, since it was not needed to achieve VO. Recently, [62] proposed a temporal smoothing filter for image reconstruction and for continuously fusing events and frames. The filter acted independently on every pixel, thus showing that no spatial regularization on the image plane was needed to recover brightness, although it naturally reduced noise and artefacts at the expense of sacrificing some real detail. More recently, [120, 8] has presented a deep learning approach that achieves considerable gains over previous methods and mitigates visual artefacts. Reflecting back on earlier works, the motion restrictions or hand-crafted regularizers that enabled image reconstruction have been replaced by perceptual, data-driven priors from natural scenes that consequently produced more natural-looking images. Note that image reconstruction methods used in VO or SLAM [23, 24, 25] assume static scenes, whereas methods with weak or no motion assumptions [117, 135, 235, 236, 62, 120, 8] are naturally used to reconstruct videos of arbitrary (e.g., dynamic) scenes.

Besides image reconstruction from events, another category of methods tackles the problem of fusing events and frames (e.g., from the DAVIS [4]), thus enhancing the brightness information from the frames with high temporal resolution and HDR properties of events [78, 62, 28]. These methods also do not rely on motion knowledge and are ultimately based on (2). The method in [78] performs direct event integration between frames, pixel-wise. However, the fused brightness becomes quickly corrupted by event noise (due to non-ideal effects, sensitivity mismatch, missing events, etc.), and so fusion is reset with every incoming frame. To mitigate noise, events and frames are fused in [62] using a per-pixel, temporal complementary filter that is high-pass in the events and low-pass in the frames. It is an efficient solution that takes into account the complementary sensing modality of events and frames: frames carry slow-varying brightness information (i.e., low temporal frequency), whereas events carry “change” information (i.e., high frequency). The fusion method in [28] exploits the high temporal resolution of the events to additionally remove motion blur from the frames, producing high frame-rate, sharp video from a single blurry frame and events. It is based on a double integral model (one integral to recover brightness and another one to remove blur) within an optimization framework. A limitation of the above methods is that they still suffer from artefacts due to event noise. These might be mitigated if combined with learning-based approaches [8].

Image quality: The quality of the reconstructed image is directly affected by noise in the contrast threshold (Section 2.4), which changes per pixel (due to manufacturing mismatch) and also due to dynamical effects (incident light, time, etc.) [78]. Image quality has been quantified in several works [236, 62, 118, 120, 8] and is also affected by the spatial resolution of the sensor.

Applications: Image reconstruction implies that, in principle, it is possible to convert the events into brightness images and then apply mature computer vision algorithms [120, 8, 95]. This can have a high impact on both, event- and frame-based communities. The resulting images capture high-speed motions and HDR scenes, which may be beneficial in some applications, but it comes at the expense of computational cost, latency and power consumption.

Despite image reconstruction having been useful to support tasks such as recognition [235], SLAM [25] or optical flow estimation [117], there are also works in the literature, such as [128, 113, 153, 119], showing that it is not needed to fulfill such tasks. One of the most valuable aspects of image reconstruction is that it provides scene representations (e.g., appearance maps [24, 7]) that are more invariant to motion than events and also facilitate establishing event correspondences, which is one of the biggest challenges of some event data processing tasks, such as feature tracking [64].

4.7 Motion Segmentation

Segmentation of moving objects viewed by a stationary event camera is simple because events are solely imputable to the motion of the objects (assuming constant illumination) [122, 180, 124]. The challenges arise in the scenario of a moving camera because events are triggered everywhere on the image plane [13, 132, 155] (Fig. 10), produced by moving objects and the static scene (whose apparent motion is induced by the camera’s ego-motion) and the goal is to infer this causal classification for each event. However, each event carries very little information, and therefore it is challenging to perform the mentioned per-event classification.

Overcoming these challenges has been done by tackling segmentation scenarios of increasing complexity, obtained by reducing the amount of additional information given to solve the problem. Such additional information adopts the form of known object shape or known motion, i.e., the algorithm knows “what object to look for” or “what type of motion it expects” and objects are segmented by detecting (in-)consistency with respect to the expectation. The less additional information is provided, the more unsupervised the problem becomes (e.g., clustering). In such a case, segmentation is enabled by the key insight that moving objects produce distinctive traces of events on the image plane and it is possible to infer the trajectories of the objects that generate those traces, yielding the segmented objects [155]. Like clustering, this is a joint optimization problem in the motion parameters of the objects (i.e., the “clusters”) and the event-object associations (i.e., the segmentation).

Literature Review: Considering known object shape, [13] presents a method to detect and track a circle in the presence of event clutter caused by the moving camera. It is based on the Hough transform using optical flow information extracted from temporal windows of events. The method was extended in [181] using a particle filter to improve tracking robustness: the duration of the observation window was dynamically selected to accommodate for sudden motion changes due to accelerations of the object. More generic object shapes were detected and tracked by [188] using event corners (Section 4.1) as geometric primitives. In this method, additional knowledge of the robot joints controlling the camera motion was required.

Segmentation has been addressed by [154, 132, 155] under mild assumptions leveraging the idea of motion-compensated event images [127] (Section 3). Essentially this technique associates events that produce sharp edges when warped according to a motion hypothesis. The simplest hypothesis is a linear motion model (i.e., constant optical flow), yet it is sufficiently expressive: for short times, scenes may be described as collections of objects producing events that fit different linear motion models. Such a scene description is what the cited segmentation algorithms seek for. Specifically, the method in [154] first fits a linear motion-compensation model to the dominant events, then removes these and fits another linear model to the remaining events, greedily. Thus, it clusters events according to optical flow, yielding motion-compensated images with sharp object contours. Similarly, [132] detects moving objects in clutter by fitting a motion-compensation model to the dominant events (i.e., the background) and detecting inconsistencies with respect to it (i.e., the objects). They test the method in challenging scenarios inaccessible to standard cameras (HDR, high-speed) and release a dataset. The work in [155] proposes an iterative clustering algorithm that jointly estimates the event-object associations (i.e., segmentation) and the motion parameters of the objects (i.e., clusters) that produce sharpest motion-compensated event images. It allows for general parametric motion models [128] to describe each object and produces better results than greedy methods [132, 154]. In [133] a learning-based approach for segmentation using motion-compensation is proposed: ANNs are used to estimate depth, ego-motion, segmentation masks of independently moving objects and object 3D velocities. An event-based dataset is provided for supervised learning, which includes accurate pixel-wise motion masks of 3D-scanned objects that are reliable even in poor lighting conditions and during fast motion.

Segmentation is a paramount topic in frame-based vision, yet it is rather unexplored in event-based vision. As more complex scenes are addressed and more advanced event-based vision techniques are developed, more works targeting this challenging problem are expected to appear.

4.8 Recognition

Algorithms: Recognition algorithms for event cameras have grown in complexity, from template matching of simple shapes to classifying arbitrary edge patterns using either traditional machine learning on hand-crafted features or modern deep learning methods. This evolution aims at endowing recognition systems with more expressibility (i.e., approximation capacity) and robustness to data distortions.

Early research with event-based sensors began with tracking a moving object using a static sensor. An event-driven update of the position of a model of the object shape was used to detect and track objects with a known simple shape, such as a blob [6], circle [53, 239] or line [54]. Simple shapes can also be detected by matching against a predefined template, which removes the need to describe the geometry of the object. This template matching approach was implemented using convolutions in early hardware [53].

For more complex objects, templates can be used to match low level features instead of the entire object, after which a classifier can be used to make a decision based on the distribution of features observed [109]. Nearest Neighbor classifiers are typically used, with distances calculated in feature space. Accuracy can be improved by increasing feature invariance, which can be achieved using a hierarchical model where feature complexity increases in each layer. With a good choice of features, only the final classifier needs to be retrained when switching tasks. This leads to the problem of selecting which features to use. Hand-crafted orientation features were used in early works, but far better results are obtained by learning the features from the data itself. In the simplest case, each template can be obtained from an individual sample, but such templates are sensitive to noise in the sample data [15]. One may follow a generative approach, learning features that enable to accurately reconstruct the input, as was done in [138] with a Deep Belief Network (DBN). More recent work obtains features by unsupervised learning, clustering the event data and using the center of each cluster as a feature [109]. During inference, each event is associated to its closest feature, and a classifier operates on the distributions of features observed. With the rise of deep learning in frame-based computer vision, many have sought to leverage deep learning tools for event-based recognition, using back-propagation to learn features. This approach has the advantage of not requiring a separate classifier at the output, but the disadvantage of requiring far more labeled data for training. Image recognition with events also suffers from the practical problem of the availability of training data in the event domain [240]. In [241] the authors use wormhole learning, a semi-supervised approach in which, starting from a detector in the RGB domain, one is able to train a detector in the event domain; moreover, in a second phase the teacher becomes the student, and some of the illumination invariance of the event sensor is transferred to the RGB-only detector.

Most learning-based approaches convert events/spikes into (dense) tensors, a convenient representation for image-based hierarchical models, e.g., ANNs (Fig 11). There are different ways the value of each tensor element can be computed (Section 3.1). Simple methods use the time surfaces, or event histogram frames. A more robust method uses time surfaces with exponential decay [109] or with average timestamps [113]. Image reconstruction methods (Section 4.6) may also be used. Some recognition approaches rely on converting spikes to frames during inference [150, 235], while others convert the trained ANN to an SNN which can operate directly on the event data [137]. Similar ideas can be applied for tasks other than recognition [108, 22]. As neuromorphic hardware advances (Section 5.1), there is increasing interest in learning directly in SNNs [143] or even directly in the neuromorphic hardware itself [144].

Tasks: Early tasks focused on detecting the presence of a simple shape (such as a circle) from a static sensor [6, 239, 53], but soon progressed to the classification of more complex shapes, such as card pips [137] (Fig. 11b), block letters [15] and faces [109, 235]. A popular task throughout has been the classification of hand-written digits. Inspired by the role it has played in frame-based computer vision, a few event-based MNIST datasets have been generated from the original MNIST dataset [242, 58]. These datasets remain a good test for algorithm development, with many algorithms now achieving over $98\text{\,}\mathrm{\char 37\relax}$ accuracy on the task [143, 243, 244, 245, 142, 113], but few would propose digit recognition as a strength of event-based vision. More difficult tasks involve either more difficult objects, such as the Caltech-101 and Caltech-256 datasets (both of which are still considered easy by computer vision) or more difficult scenarios, such as recognition from on-board a moving vehicle [113]. Very few works tackle these tasks so far, and those that do typically fall back on generating event frames and processing them using a traditional deep learning framework.

A key challenge for recognition is that event cameras respond to relative motion in the scene (Section 2.3), and thus require either the object or the camera to be moving. It is therefore unlikely that event cameras will be a strong choice for recognizing static or slow moving objects, although little has been done to combine the advantages of frame- and event-based cameras for these applications. The event-based appearance of an object is highly dependent on the above-mentioned relative motion (Fig. 5), thus tight control of the camera motion could be used to aid recognition [242].

Since the camera responds to dynamic signals, obvious applications include recognizing objects by the way they move [246], or recognizing dynamic scenes such as gestures or actions [16, 17]. These tasks are typically more challenging than static object recognition because they include a time dimension, but this is exactly where event cameras excel.

Opportunities: Event cameras exhibit many alluring properties, but event-based recognition has a long way to go if it is to compete with modern frame-based approaches. While it is important to compare event- and frame-based methods, one must remember that each sensor has its own strengths. The ideal acquisition scenario for a frame-based sensor consists of both the sensor and object being static, which is the worst possible scenario for event cameras. For event-based recognition to find widespread adoption, it will need to find applications which play to its strengths. Such applications are unlikely to be similar to well established computer vision recognition tasks which play to the frame-based sensor’s strengths. Instead, such applications are likely to involve resource constrained recognition of dynamic sequences, or recognition from on-board a moving platform. Finding and demonstrating the use of event-based sensors in such applications remains an open challenge.

Although event-based datasets have improved in quality in recent years, there is still room for improvement. Much more data is being collected, but annotation remains challenging. There is not yet an agreed upon or standard tool or format for annotations. Many event-based datasets are derived from frame-based vision. While these datasets have played an important role in the field, they inherently play to the strengths of frame-based vision and are thus unlikely to give rise to new event-based sensor applications. Data collection and annotation is a tiresome and thankless task, but developing an easy-to-use pipeline for collecting and annotating event-based data would be a significant contribution to the field, especially if the tools can mature to the stage where the task can be outsourced to laymen.

4.9 Neuromorphic Control

In living creatures, most information processing happens through spike-based representation: spikes encode the sensory data; spikes perform the computation; and spikes transmit actuator “commands”. Therefore, biology shows that the event-based paradigm is, in principle, applicable not just to perception and inference, but also to control.

Neuromorphic-vision-driven Control Architecture: In this type of architecture (Fig. 12), there is a neuromorphic sensor, an event-based estimator, and a traditional controller. The estimator computes a state, and the controller computes the control based on the provided state. The controller is not aware of the asynchronicity of the architecture.

Neuromorphic-vision-driven control architectures have been demonstrated since the early days of neuromorphic cameras, and they have proved the two advantages of low latency and computational efficiency. The earliest demonstrators were the spike-based convolutional target tracking demo in the CAVIAR project [53] and the “robot goalie” described in [6, 12]. Another early example was the pencil-balancing robot [54]. In that demonstrator two DVS’s observed a pencil as inverted pendulum placed on a small movable cart. The pencil’s state in 3D was estimated in below $1\text{\,}\mathrm{ms}$ latency. A simple hand tuned PID controller kept the pencil balanced upright. It was also demonstrated on an embedded system, thereby establishing the ability to run on severely constrained computing resources.

Event-based Control Theory: Event-based techniques can be motivated from the perspective of control and decision theory. Using a biological metaphor, event-based control can be understood as a form of what economics calls rational inattention [247]: more information allows for better decisions, but if there are costs associated to obtaining or processing the information, it is rational to take decisions with only partial information available.

In event-based control, the control signal is changed asynchronously [248]. There are several variations of the concept depending on how the “control events” are generated. One important distinction is between event-triggered control and self-triggered control [249]. In event-based control the events are generated “exogenously” based on certain condition; for example, a “recompute control” request might be triggered when the trajectory’s tracking error exceeds a threshold. In self-triggered control, the controller decides by itself when is the next time it should be called based on the situation. For example, a controller might decide to “sleep” for longer if the state is near the target, or to recompute the control signal sooner if it is required.

The advantages of event-based control are usually justified considering a trade-off between computation / communication cost and control performance. The basic consideration is that, while the best control performance is obtained by recomputing the control infinitely often (for an infinite cost), there are strongly diminishing returns. A solid principle of control theory is that the control frequency depends on the time constant of the plant and the sensor: it does not make sense to change the control much quicker than the new incoming information or the speed of the actuators. This motivates choosing control frequencies that are comparable with the plant dynamics and adapt to the situation. For example, one can show that an event-triggered controller achieves the same performance with a fraction of the computation; or, conversely, a better performance with the same amount of computation. In some cases (scalar linear Gaussian) these trade-offs can be obtained in closed form [250, 251]. (Analogously, certain trade-offs can be obtained in closed form for perception [252].)

Unfortunately, the large literature in event-based control is of restricted utility for the embodied neuromorphic setting. Beyond the superficial similarity of dealing with “events” the settings are quite different. For example, in network-based control, one deals with typically low-dimensional states and occasional events—the focus is on making the most of each single event. By contrast, for an autonomous vehicle equipped with event cameras, the problem is typically how to find useful signals in potentially millions of events per second. Particularizing the event-based control theory to the neuromorphic case is a relatively young avenue of research [253, 254, 255, 256]. The challenges lie in handling the non-linearities typical of the vision modality, which prevents clean closed-form results.

Open questions in Neuromorphic Control: Finally, we describe some of open problems in this topic.

Task-driven sensing: In animals, perception has value because it is followed by action, and the information collected is actionable information that helps with the task. A significant advance would be the ability for a controller to modulate the sensing process based on the task and the context. In current hardware there is limited software-modulated control for the sensing processing, though it is possible to modulate some of the hardware biases. Integration with region-of-interest mechanisms, heterogeneous camera bias settings, etc. would provide additional flexibility and more computationally efficient control.

Thinking fast and slow: Existing research has focused on obtaining low-latency control, but there has been little work on how to integrate this sensorimotor level into the rest of an agent’s cognitive architecture. Using again a bio-inspired metaphor, and following Kahneman [257], the fast/instinctive/“emotional” system must be integrated with the slower/deliberative system.

5 Event-based Systems and Applications

5.1 Neuromorphic Computing

Neuromorphic engineering tries to capture some of the unparalleled computational power and efficiency of the brain by mimicking its structure and function. Typically this results in a massively parallel hardware accelerator for SNNs (Section 3.3), which is how we will define a neuromorphic processor. Since the neuron spikes within such a processor are inherently asynchronous, a neuromorphic processor is the best computational partner for an event camera. Neuromorphic processors act on the events injected by the event camera directly, without conversion, and offer better data-processing locality (spatially and temporally) than standard architectures such as CPUs, yielding low power and low latency computer vision systems.

Neuromorphic processors may be categorized by their neuron model implementations (Table IV), which are broadly divided between analog neurons (Neurogrid, BrainScaleS, ROLLS, DYNAP-se), digital neurons (TrueNorth, Loihi, ODIN) and software neurons (SpiNNaker). Some architectures also support on-chip learning (Loihi, ODIN, DYNAP-le). When evaluating a neuromorphic processor for an event-based vision system, the following criteria should be considered in addition to the processor’s functionality and performance: (i) the software development ecosystem: a minimal toolchain includes an API to compose and train a network, a compiler to prepare the network for the hardware, and a runtime library to deploy the network in hardware, (ii) event-based vision systems typically require that a processor be available as a standalone system suitable for mobile applications, and not just hosted in a remote server, (iii) the availability of neuromorphic processors.

Several developments are necessary to enable a more widespread use of these processors, such as: (i) developing a more user-friendly ecosystem (an easier way to program the desired method for deployment in hardware), (ii) enabling more processing capabilities of the hardware platform, (iii) increasing the availability of devices beyond early access programs targeted at selected partners.

The following processors (Table IV) have the most mature developer workflows, combined with the widest availability of standalone systems. More details are given in [263, 264].

SpiNNaker (Spiking Neural Network Architecture) uses general-purpose ARM cores to simulate biologically realistic models of the human brain [265]. Unlike the other processors that choose specific simplified neuron models to embed in custom transistor circuits, SpiNNaker implements neurons as software running on the cores, sacrificing hardware acceleration to maximize model flexibility. The SpiNNaker has been coupled with event cameras for stereo depth estimation [165, 266], optic flow computation [267, 266], and for object tracking [268] and recognition [269].

TrueNorth uses digital neurons to perform real-time inference. Each chip simulates $1\text{\,}\mathrm{M}$ (million) neurons and $256\text{\,}\mathrm{M}$ synapses, distributed among 4096 neurosynaptic cores. There is no on-chip learning, so networks are trained offline using a GPU or other processor [270].

TrueNorth has been paired with event cameras to produce end-to-end, low power and low-latency event-based vision systems for gesture recognition [17], stereo reconstruction [213] and optical flow estimation [196].

Loihi uses digital neurons to perform real-time inference and online learning. Each chip simulates up to 131 thousand spiking neurons and $130\text{\,}\mathrm{M}$ synapses. A learning engine in each neuromorphic core updates each synapse using rules that includes STDP and reinforcement learning [260]. Non-spiking networks can be trained in TensorFlow and approximated by spiking networks for Loihi using the Nengo Deep Learning toolkit from Applied Brain Research [271]. There are plans to build a larger system called Pohoiki Springs with 768 Loihi chips ($100\text{\,}\mathrm{M}$ neurons and 100 billion synapses), which is still small compared to the human brain’s 800 trillion synapses.

DYNAP: The Dynamic Neuromorphic Asynchronous Processor (DYNAP) from aiCTX has two variants, one optimized for scalable inference (Dynap-se), and another for online learning (Dynap-le).

Braindrop prototypes a single core of the $1\text{\,}\mathrm{M}$-neuron Brainstorm system [262]. It is programmed using Nengo [272] and implements the Neural Engineering Framework [273]. Braindrop is Stanford University’s follow-on to the Neurogrid processor.

5.2 Applications in Real-Time On-Board Robotics

As event-based vision sensors often produce significantly less data per time interval compared to traditional cameras, multiple applications can be envisioned where extracting relevant vision information can happen in real-time within a simple computing system directly connected to the sensor, avoiding USB connection. Fig 13 shows an example of such, where a dual-core ARM micro controller running at $200\text{\,}\mathrm{MHz}$ with $136\text{\,}\mathrm{kB}$ on-board SRAM fetches and processes events in real-time. The combined embedded system of sensor and micro controller here operate a simple wheeled robot in tasks such as line following, active and passive object tracking, distance estimation, and simple mapping [274].

A different example of near-sensor processing (“edge computing”) is the Speck SoC111111https://www.speck.ai/, which combines a DVS and the Dynap-se neuromorphic CNN processor. Its peak power consumption is less than $1\text{\,}\mathrm{mW}$ and latency is less than $30\text{\,}\mathrm{ms}$. Application domains are low-power, continuous object detection, surveillance, and automotive systems.

Event cameras have also been used on-board quadrotors with limited computational resources, both for autonomous landing [275] or flight [27] (Fig. 13b), in challenging scenes.

6 Resources

The List of Event-based Vision Resources [9] is a collaborative effort to collect relevant resources in the field: links to information (papers, videos, organizations, companies and workshops) as well as software, drivers, code, datasets, simulators and other essential tools in event-based vision.

6.1 Software

To date, there is no open-source standard library integrated to OpenCV that provides algorithms for event-based vision. This would be a very desirable resource to accelerate the adoption of event cameras. There are, however, many quite highly developed open-source software resources:

$\bullet$ jAER [276]121212https://jaerproject.org is a Java-based environment for event sensors and processing like noise reduction, feature extraction, optical flow, de-rotation using IMU, CNN and RNN inference, etc. Several non-mobile robots [6, 54, 12, 277] and even one mobile DVS [150] robot have been built in jAER, although Java is not ideal for mobile robots. It provides a desktop GUI based interface for easily recording and playing data that also exposes the complex internal configurations of these devices. It mainly supports the sensors developed at the Inst. of Neuroinformatics (UZH-ETH Zurich) that are distributed by iniVation.

$\bullet$ libcaer131313https://github.com/inilabs/libcaer is a minimal C library to access, configure and get data from iniVation and aiCTX neuromorphic sensors and processors. It supports the DVS and DAVIS cameras, and the Dynap-SE neuromorphic processor.

$\bullet$ The ROS DVS package141414https://github.com/uzh-rpg/rpg_dvs_ros developed in the Robotics and Perception Group of UZH-ETH Zurich is based on libcaer. It provides C++ drivers for the DVS and DAVIS. It is popular in robotics since it integrates with the Robot Operating System (ROS) [278] and therefore provides high-level tools for easily recording and playing data, connecting to other sensors and actuators, etc. Popular datasets [98, 197] are provided in this format. The package also provides a calibration tool for both intrinsic and stereo calibration.

$\bullet$ The event-driven YARP Project151515https://github.com/robotology/event-driven [279] comprises libraries to handle neuromorphic sensors, such as the DVS, installed on the iCub humanoid robot, along with algorithms to process event data. It is based on the Yet Another Robot Platform (YARP) middleware.

$\bullet$ pyAER161616https://github.com/duguyue100/pyaer is a python wrapper around libcaer developed at the Inst. of Neuroinformatics (UZH-ETH) that will probably become popular for rapid experimentation.

$\bullet$ DV171717https://inivation.gitlab.io/dv/dv-docs/ is the C++ open-source software for the iniVation DVS/DAVIS and is also the software of their official SDK. It enables fast, easy deployment of advanced processing algorithms for next-generation embedded and IoT applications.

Other open-source software utilities and processing algorithms (in Python, CUDA, Matlab, etc.) are spread throughout the web, on the pages of the research groups working on event-based vision [9]. Proprietary software includes the development kits (SDKs) developed by companies.

6.2 Datasets and Simulators

Datasets and simulators are fundamental tools to facilitate adoption of event-driven technology and advance its research. They allow to reduce costs (currently, event cameras are considerably more expensive than standard cameras) and to monitor progress with quantitative benchmarks (as in traditional computer vision: the case of datasets such as Middlebury, MPI Sintel, KITTI, EuRoC, etc.).

The number of event-based vision datasets and simulators is growing fast. Several of them are listed in [9], sorted by task. Broadly, they can be categorized as those that target motion estimation or image reconstruction (regression) tasks, those that target recognition (classification) tasks, and end-to-end human-labeled data like driving [280]. In the first group, there are datasets for optical flow, SLAM, object tracking, segmentation, etc. The second group comprises datasets for object and action recognition.

Datasets for optical flow include [190, 281, 22]. Since ground-truth optical flow is difficult to acquire, [190] considers only flow during purely rotational motion recorded with an IMU, and so, the dataset lacks flow due to translational (parallax) motion. The datasets in [281, 22] provide optical flow as the motion field induced on the image plane by the camera motion and the depth of the scene (measured with a range sensor, such as an RGB-D camera, a stereo pair or a LiDAR). Naturally, ground truth optical flow is subject to noise and inaccuracies in alignment and calibration of the different sensors involved.

Datasets for pose estimation and SLAM include [225]181818http://ebvds.neurocomputing.systems, [98, 281, 197, 282]. The most popular one is described in [98], which has been used to benchmark visual odometry and visual-inertial odometry methods [131, 129, 27, 104, 127, 103, 128]. This dataset is also popular to evaluate corner detectors [115, 111] and feature trackers [126, 64].

Datasets for recognition are currently of limited size compared to traditional computer vision ones. They consist of cards of a deck (4 classes), faces (7 classes), handwritten digits (36 classes), gestures (rocks, papers, scissors) in dynamic scenes, cars, etc. Neuromorphic versions of popular frame-based computer vision datasets, such as MNIST and Caltech101, have been obtained by using saccade-like motions [242, 283]. Newer datasets [17, 113, 284, 285] are acquired in real scenarios (not generated from frame-based data). These datasets have been used in [137, 15, 109, 151, 150, 113], among others, to benchmark event-based recognition algorithms.

The DVS emulators in [73, 286] and the simulators in [98] are based on the working principle of an ideal DVS pixel (2). Given a virtual 3D scene and the trajectory of a moving DAVIS within it, the simulator generates the corresponding stream of events, intensity frames and depth maps. The simulator has been extended in [74]: it uses an adaptive rendering scheme, is more photo-realistic, includes a simple event noise model and returns estimated optical flow. The v2e tool [40] generates events from video with a realistic non-ideal noisy DVS pixel model that extends modeling to low lighting conditions. A comprehensive characterization of the noise and dynamic effects of existing event cameras has not been carried out yet, and so, the noise models used are currently somewhat oversimplified.

6.3 Workshops

There are two yearly Summer schools fostering research, among other topics, on event-based vision: the Telluride Neuromorphic Cognition Engineering Workshop (27th edition in 2020, in USA) and the Capo Caccia Workshop (12th edition in 2020, in Europe). Recently, workshops have been organized alongside major robotics conferences (IROS’15191919http://innovative-sensing.mit.edu/, ICRA’17202020http://rpg.ifi.uzh.ch/ICRA17_event_vision_workshop.html or IROS’18212121http://www.jmartel.net/irosws-home). Live demos of event-based systems have been shown at top-tier conferences, such as ISSCC’06, NIPS’09, CVPR’18, ECCV’18, ICRA’17, IROS’18, CVPR’19222222http://rpg.ifi.uzh.ch/CVPR19_event_vision_workshop.html, multiple ISCAS, etc. As the event-based vision community grows, more workshops and live demos are expected to happen in traditional computer vision venues.

7 Discussion

Event-based vision is a topic that spans many fields, such as computer vision, robotics and neuromorphic engineering. Each community focuses on exploiting different advantages of the event-based paradigm. Some focus on the low power consumption for “always on” or embedded applications on resource-constrained platforms; others favor low latency to enable highly reactive systems, and others prefer the availability of information to better perceive the environment (high temporal resolution and HDR), with fewer constraints on computational resources.

Event-based vision is an emerging technology in the era of mature frame-based camera hardware and software. Comparisons are, in some terms, unfair since they are not carried out under the same maturity level. Nevertheless event cameras show potential, able to overcome some of the limitations of frame-based cameras, reaching new scenarios previously inaccessible. There is considerable room for improvement (research and development), as pointed out in numerous opportunities throughout the paper.

There is no agreement on what is the best method (and representation) to process events, notably because it depends on the application. There are different trade-offs involved, such as latency vs. power consumption and accuracy, or sensitivity vs. bandwidth and processing capacity. For example, reducing the contrast threshold and/or increasing the resolution produces more events, which will be processed by an algorithm and platform with finite capacity. A challenging research area is to quantify such trade-offs and to develop techniques to dynamically adjust the sensor and/or algorithm parameters for optimal performance.

Another big challenge is to develop bio-inspired systems that are natively event-based end-to-end (from perception to control and actuation) that are also more efficient and long-term solutions than synchronous, frame-based systems. Event cameras pose the challenge of rethinking perception, control and actuation, and, in particular, the current main stream of deep learning methods in computer vision: adapting them or transferring ideas to process events while being as top-performing. Active vision (pairing perception and control) is specially relevant on event cameras because the events distinctly depends on motion, which may be due to the actuation of a robot.

Event cameras can be seen as an entry point for more efficient, near-sensor processing, such that only high-level, non-redundant information is transmitted, thus reducing bandwidth, latency and power consumption. This could be done by pairing an event camera with hardware on the same sensor device (Speck in Section 5.2), or by alternative bio-inspired imaging sensors, such as cellular processor arrays [287] [288] which every pixel has a processor that allows to perform several types of computations with the brightness of the pixel and its neighbors.

8 Conclusion

Event cameras are revolutionary sensors that offer many advantages over traditional, frame-based cameras, such as low latency, low power, high speed and high dynamic range. Hence, they have a large potential for computer vision and robotic applications in challenging scenarios currently inaccessible to traditional cameras. We have provided an overview of the field of event-based vision, covering perception, computing and control, with a focus on the working principle of event cameras and the algorithms developed to unlock their outstanding properties in selected applications, from low-level vision to high-level vision. Neuromorphic perception and control are emerging topics; and so, there are plenty of opportunities, as we have pointed out throughout the text. Many challenges remain ahead, and we hope that this paper provides an introductory exposition of the topic, as a step in humanity’s longstanding quest to build intelligent machines endowed with a more efficient, bio-inspired way of perceiving and interacting with the world.

Acknowledgments

The authors would like to thank all the people who contributed to this paper. We would like to thank the event camera manufacturers for providing the values in Table I and for discussing the difficulties in their comparison due to the lack of a common testbed. In particular, we thank Hyunsurk Eric Ryu (Samsung Electronics), Chenghan Li (iniVation), Davide Migliore (Prophesee), Marc Osswald (Insightness) and Prof. Chen (CelePixel). We are also thankful to all members of our research laboratories, for discussion and comments on early versions of this document. We also thank the editors and anonymous reviewers of IEEE TPAMI for their suggestions, which led us to improve the paper.