Learning to Deblur and Generate High Frame Rate Video with an Event Camera

by   Chen Haoyu, et al.
Peking University

Event cameras are bio-inspired cameras which can measure the change of intensity asynchronously with high temporal resolution. One of the event cameras' advantages is that they do not suffer from motion blur when recording high-speed scenes. In this paper, we formulate the deblurring task on traditional cameras directed by events to be a residual learning one, and we propose corresponding network architectures for effective learning of deblurring and high frame rate video generation tasks. We first train a modified U-Net network to restore a sharp image from a blurry image using corresponding events. Then we train another similar network with different downsampling blocks to generate high frame rate video using the restored sharp image and events. Experiment results show that our method can restore sharper images and videos than state-of-the-art methods.



page 1

page 2

page 3

page 4

page 5

page 6

page 7

page 9


Bringing a Blurry Frame Alive at High Frame-Rate with an Event Camera

Event-based cameras can measure intensity changes (called ` events') wit...

TimeReplayer: Unlocking the Potential of Event Cameras for Video Interpolation

Recording fast motion in a high FPS (frame-per-second) requires expensiv...

How Asynchronous Events Encode Video

As event-based sensing gains in popularity, theoretical understanding is...

Smart Time-Multiplexing of Quads Solves the Multicamera Interference Problem

Time-of-flight (ToF) cameras are becoming increasingly popular for 3D im...

Bringing Blurry Alive at High Frame-Rate with an Event Camera

Event-based cameras can measure intensity changes (called ` events') wit...

Event Enhanced High-Quality Image Recovery

With extremely high temporal resolution, event cameras have a large pote...
This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

Event cameras, such as the Dynamic Vision System (DVS) [18] and the Dynamic and Active-pixel Vision Sensor (DAVIS) [3], are bio-inspired sensors that asynchronously detect the change of log intensity at each pixel independently, comparing to traditional cameras that sample intensity at each pixel during the exposure time and form a picture. If the intensity change reaches a threshold, the camera will trigger an event, , in which is the coordinate of the pixel, is the timestamp when the event is generated, and is the polarity of the event. For a pixel u whose intensity is in an event camera, it measures the change of intensity. If at time the log intensity () change , it will output an event (or ) if the difference is greater (or less) than 0. So outputs of event cameras are not frames but a sequence of events with coordinate, timestamp, and polarity information.

Compared with traditional cameras, event cameras have several advantages such as higher temporal resolution (around 1

s) and higher dynamic range (140dB). As a result, event cameras would not suffer from many problems that traditional cameras have. An important one of them is the motion blurring of images whose removal is still a challenging problem in computer vision research.

Motion blur is the result of the relative motion between the camera and the scene during the integration time of image capturing, such as camera shake or object motion. Traditional methods to restore a sharp image from a blurry one apply various constraints to model characteristics of blur (, non-blind uniform/blind uniform/non-uniform), and utilize different natural image priors to regularize the solution space [5, 6, 7, 36, 17, 23]

. Most of these methods involve intensive, sometimes heuristic, parameter-tuning and expensive computation. Recently, learning-based methods have also been proposed for deblurring. Early methods follow the idea of traditional methods and substitute some operators with learned modules 

[34, 31, 14]. Recent methods focus on designing end-to-end network structures for image deblurring [21, 37, 35]

and performing blind deblurring without estimating the blur kernels.

Event cameras have been applied to various computer vision tasks by making compatible representations with image-based computer vision algorithms [27, 2, 33, 39]. It is natural to apply event cameras for motion deblurring due to their high sensitivity to object motion. By connecting images with motion blur and events [4, 29, 24], the complementary information from two types of cameras could accomplish the motion deblurring task with higher performance and lower cost.

In this paper, we propose a learning-based method combined with events to restore a sharp image from a blurry image and generate a high frame rate (HFR) video. Unlike existing works that generate sharp images using events directly, we formulate the deblurring task to be a residual learning one and propose a modified U-Net [28] architecture with DenseNet [15] blocks in which event stacks can be transformed to be a mask. By adding the mask to a blurry image, the sharp one will be restored. After the deblurring procedure, we can use the restored sharp image with events to generate HFR video using a similar residual learning network architecture, in which DenseNet blocks are replaced by Conv-LSTM blocks. The contributions of this paper can be summarized as:

  • We revisit the relationship between a blurry image and events, and propose a residual model suitable for learning image deblurring and HFR video generation.

  • We propose a modified U-Net with a global residual connection which is particularly effective for our residual model and obtains a better result on deblurring than state-of-the-art methods (Figure 


  • We propose another residual network to recurrently generate the next clear frame guided by events and design a pipeline to concatenate several blurry images to an HFR video.

2 Related Work

In this section, we will review the previous image deblurring and event-based methods related to our work.

2.1 Learning-based image and video deblurring

As deep learning has shown its striking effects in solving computer vision problems such as object detection and segmentation, image and video deblurring also benefits from deep learning methods. Sun

et al[34]

proposed a deep learning approach to predicting the probabilistic distribution of motion blur at the patch level using a convolutional neural network and removed the motion blur by a non-uniform deblurring model using a patch-level image prior.

Unlike the early method [34] that replaced the calculation of blur kernel with a classification network, end-to-end methods generating deblurring images directly were proposed. Nah et al[21] proposed a multi-scale CNN that directly restores latent images without assuming any restricted blur kernel model without estimating explicit blur kernels. Further, Tao et al[35] proposed a multi-scale encoder-decoder network. Inspired by the coarse-to-fine scheme the blurry image was restored on different resolutions in the scale-recurrent structured network, which had a simpler network structure, a smaller number of parameters and was easier to train. Kupyn et al[13] used another popular network structure, generative adversarial network (GAN), to perform the deblurring task. They formulated the deblurring task to be a residual learning one. Their method could restore the image using fewer calculation resources in a shorter time. Jin et al[11] proposed a network to extract video from a blurry image by restoring the middle sharp image and calculating temporal ambiguities. Zhang et al[38] proposed a 3D convolution to both spatial and temporal domains to extract the motion features in the video and used a GAN to make the restored video sharper and more realistic.

2.2 Event-based computer vision methods

Events have shown unique advantages in estimating optical flows. Bardow et al[1] aimed to simultaneously recover optical flow and HDR images employing minimization of a cost function that contains the asynchronous event data as well as spatial and temporal regularisation. Zhu et al[39] proposed a FlowNet-liked [8]

network for unsupervised learning the optical flow, egomotion and depths only from the event stream.

There are also several works trying to relate events with intensity frames and reconstruct high-quality images even high frame-rated videos. Reinbacher et al[27] proposed a variational model enabling reconstruction of intensity images with an arbitrary frame rate in real-time via an event manifold induced by the relative timestamps of events. Scheerlinck et al[29] proposed a continuous-time formulation of event-based intensity estimation using complementary filtering to combine image frames with events and obtained continuous-time image intensities. Mohammad et al[20] used event-based cGAN [19] to create images/videos from an adjustable portion of the event data stream based on the spatio-temporal intensity changes.

Events are also used in the deblurring and high-speed video generation tasks because of the advantage of high temporal resolution and reliable motion information encoded in captured events. Pan et al[24] proposed an optimization method for estimating a single scalar variable, named the Event-based Double Integral (EDI) model, to restore a sharp image. Then an HFR video can be generated from the restored image using the optimized scalar, which is physically corresponding to the threshold of triggering the event. Rebecq et al[9] proposed a U-Net-like network with Conv-LSTM blocks and generated a video directly from encoded events in a spatio-temporal voxel grid.

The input and output of our method is the same as [24], and our method is also inspired by the physical model of an event camera. However, our model suffers less from noisy events and avoids rapid accumulation of errors through due to the stronger representation power of residual mode, as we will prove using extensive experiments

3 Proposed Method

In this section, we will introduce our proposed learning-based methods for the deblurring task (Section 3.1) and the design methodology of the network (Section 3.2). Based on the output of the deblurring task, we propose a method to generate a sequence of frames using the restored image and related events (Section 3.3). We will discuss and compare our method with existing methods that restore and generate images using events (Section 3.4). We will also explain the architecture and training details of our networks respectively.

3.1 Event-based residual image formation model

3.1.1 Image deblurring model

To restore a blurry image using events from a DVS camera, we should build the connection between them.

Given the intensity of sharp images, as described in [21], blur accumulation process can be modeled as,


Supposing that is the incoming event stream at a pixel from to , then the latent image at can be expressed as


in which is the threshold of intensity change to trigger the -th event

. Such a threshold has different values for positive and negative intensity change, and it is not a constant which generally follows a normal distribution over time 

[26]. It is non-trivial to give an analytical expression for the change caused by at time , so we donate it as . We expect to accurately estimate the change of an event using the local intensity and gradient information.

By combining Equation 1 and Equation 2 we obtain


Taking the logarithm on the both sides of Equation 3, in which , and rearranging the equation, yields


While in the deblurring task, the intensity value of the sharp image is unavailable. Actually, in the blurry image, gradient information can still be observed along the edge of the blurry part. So we approximately use B as a proxy of for in Equation 4 as the following equation:


3.1.2 HFR video generation model

Equation 5 provides the mapping from a blurry image to a sharp image using a residual term encoded with events. Baesd on the restored shape image and subsequent events, we can generate HFR videos thanks to the high temporal resolution of events. Using the log representation of Equation 2, we obtain the residual relationship between two adjacent frames:


where is the restored image, and the Q generated images are combined to be an HFR video.

In the following subsections, we propose two corresponding network designs to learn deblurring using Equation 5 and HFR video generation using Equation 6.

Figure 2: The architecture of our event-based residual deblurring/HFR video generation net. The DenseNet/Conv-LSTM blocks are used in the downsampling procedure as the feature blocks. The input of the network is concatenation of binned events and an image, which is the blurry image/previous frame. The output is the sharp image/next frame.

3.2 Event-based residual deblurring net

Network architecture.

According to Equation 5, our goal is restoring a sharp image using events. While the function is highly undetermined and hard to be explicitly described. So we design a learning-based method to learn such a function from training data. We propose a generation network whose architecture is shown in Figure 2. In addition, we introduce a global skip connection, which matches our formulation and makes the generation results better, then our network can be treated as a residual learning one.

As described above, given the blurry image and events, we denote our prediction as


where is the output of our network trained with the event sequence , blurry image B and , which consists of all network parameters to be learned. According to the results in [24], features like gradient can guide the deblurring tasks effectively. So our network should learn the relationship between the event sequence and the change of intensity depending on the local information and features in the blurry image.

Our network consists of two parts: the encoder part, which is used to extract features in the blurry images and stacked events frames, and the decoder part, which is used to fuse encoded blurry images with the encoded events.

The encoder part is designed based on DenseNet to extract local features, which may simply be the gradient of the blurry image and the gradient of the current estimate, possibly thresholded in flat regions [16]. Recent works also show that DenseNet can be trained to extract high-level features in an image even better than the popular ResNet [10]

. We also train our encoder with stacked event frames to extract features from events in a neighborhood. To use the features extracted from our DenseNet based encoder, we replace the fully-connected layers in DenseNet model by a

convolutional layer so we can input them into our decoder.

After extracting features with our encoder, we design a feature fusion block in decoder of our network to fuse features extracted by the encoder from the image stream and event stream. To fuse features and learn the change of intensity caused by events at a pixel, we use a convolutional layer to skip connect features in downsampling procedure with those in the upsampling procedure. Moreover, to fuse features depending on the local area of a pixel, we use a

convolutional layer in the upsampling procedure. Our network can also filter the noise from input event sequence to a certain degree. Noisy event, which is sparse locally, will not cause effective activation because of the ReLU structure in the network.

Data input.

The output of event cameras is a sequence consisting of event tuples . We need to find a representation of events so that we can feed them into our network. We adopt the representation in [20] which constructs 3D event volume via merging and stacking the events within a small time interval. We apply this representation to our input of event sequences. Then events are concatenated with the blurry image as several channels of the input. Moreover, as described in [20], stacking events into multiple frames is better than one. More details of the data input will be shown in Section 4.2.

Loss function.

We define our loss function as follows:


where means generated images and means blurry images. is the -loss or MAE loss between and . The perceptual loss  [12] is an improved kind of

-loss based on VGG19 trained on ImageNet. It does not calculate the difference between generated images and target images but the sum of differences in the feature maps. Perceptual loss measures high-level perceptual and semantic differences between images to provide more robust constraints than

-loss. The perceptual loss can be defined as the following:


where is the feature map obtained by the -th convolution (after activation) before the -th maxpooling layer, and are the dimensions of the feature maps.

3.3 Event-based residual HFR video generation net

Network architecture.

Similar to deblur task, we can design a residual learning network to solve the problem in Equation 6 for HFR video generation. Given events and the previous frame, we denote the prediction as


A straightforward design of network is using events and one frame as input and the output is the next frame. However, we experimentally find this design is hard to train and lead to poor performance because of rapid accumulation of error (the generated image quality drops catastrophically after the third frame). Considering this consequence, we propose our network to be a residual net, which also follows the video generation model we propose in Section 3.1.

We still use the structure we proposed for the deblurring task as shown in Figure 2. While this time, we replace the DenseNet blocks in the downsampling procedures with Conv-LSTM [32] blocks to learn the temporal information in the event sequences because temporal consistency is the key in video generation task, which is proved to be valid in [9].

Data input.

The inputs of our HFR video generation network are a sharp picture and events in the next period of time. The first sharp picture is the restored one using our event-based deblurring residual net. Then we will recurrently use the generated frame to be the input in the next step. As described in Section 3.2, we divide the input events into 6 bins. The loss function is also the same as Equation 8.

Figure 3: The pipeline of our method to restore HFR video from a blurry image. At the first stage, we use our event-based deblurring residual net (Figure 2 with DenseNet in downsampling blocks) with all the events and the blurry image B to obtain the sharp image . Next, we recurrently use our event-based HFR video generation residual net (Figure 2 with Conv-LSTM in downsampling blocks) with part of the events and the output frame to predict the next frame .

The pipeline of our method to restore HFR video from a blurry image is described in Figure 3. It consists of two stages. At the first stage, using events and blurry image, our event-based deblurring residual net restores a sharp image, which will be used as the first frame at the second stage. Then our event-based HFR video generation residual net recurrently uses part of the events and a sharp frame to generate the corresponding next frame.

Figure 4: An example of restoring a sharp image from a blurry one (a) by Pan et al[24] (b), Rebecq et al[9] (c) and our method (d). Artifacts such as noise around the restored alphabets (b) and oversmooth of the folds (c) could be observed.
Average result of deblurring on synthetic dataset
Nah et al[21] Tao et al[35] Kupyn et al[13] Purohit et al[25] Pan et al[24] Baseline-d Ours
PSNR 31.30 30.54 29.29 30.58 30.68 27.67 32.99
SSIM 0.9113 0.924 0.8990 0.9410 0.9088 0.8995 0.9353
Average result of HFR video generation on synthetic dataset
Jin et al[11] Scheerlinck et al[29] Nah et al[22] Pan et al[24] Baseline-v1 Baseline-v2 Ours
PSNR 28.01 25.84 29.97 28.06 26.75 31.52 31.76
SSIM 0.8670 0.7904 0.8947 0.8623 0.8424 0.9252 0.9202
Table 1: Quantitative results using synthetic data containing both blurry images and event stacks. All the methods listed are tested under the same blurry condition. We have one deblurring baseline and two video generation baselines for comparison. Baseline-d and baseline-v1 do not use the residual learning method, and baseline-v2 does not use Conv-LSTM block. Although baseline-v2 has a slightly higher SSIM compared to our method, the visual quality of its generation shows a rather unstable appearance. Please refer to the supplement video for detailed comparison.

3.4 Relationship with existing models

The EDI model described in [24] can be treated as a special case of our model, by setting all as constant. It formulated the deblurring task with events to be a non-convex optimization problem and solved the constant threshold to restore the sharp image. While as we described above, the threshold in the physical model of the event camera is not a constant and the constant global threshold will lead to error and generate artifacts in the restored image, as Figure 4(b) shows.

The learning-based model proposed in [9] also used events to generate HFR video. While they used only events as input, lacking background and texture information in the generated video. Our residual net combines the restored clear background from intensity image with events and can generate a sharper video with richer background details, as Figure 4(c) shows. More comparisons will be listed in the experiment section.

4 Experiments and Evaluation

In this section, we compare our method with state-of-the-art methods on image deblurring and HFR video generation. To qualitatively and quantitatively evaluate our method, we test our method on both synthetic and real datasets.

4.1 Data preparation

Synthetic dataset.

In order to quantitatively compare our experiment result with other deblurring methods, we generate a synthetic dataset based on the GoPro dataset [21]. This dataset consists of 240 FPS videos taken with GOPRO camera and then averaged varying number (7 13) of successive latent frames to produce blurs of different strengths. To make a fair comparison, we also average 7 images to generate a blurry image as done in [21]. And we generate events between two images using the simulator provided by Rebecq et al[26].

Real dataset.

The dataset we use to evaluate our method is from [24], in which frames and events are captured by a DVS240 event camera, and consists of different scenes and motion patterns (e.g., camera shake, objects motion) that naturally introduce motion blur into the intensity images. We also record a dataset using a DVS346 event camera. Our dataset will be released with our code.

4.2 Training details

Our network is trained on an NVIDIA Titan X GPU and is implemented on Tensorflow platform. The optimizer we choose is ADMM, and its learning rate is the constant 0.002. In our experiment, we find that 50 epochs are enough for our model to converge. During each epoch, we use a batch of 8 blurry images and related events.

It is due to only blurry images existing in the real dataset that we only use the synthetic dataset to train our network. The GoPro dataset is divided into two parts with a proportion of . During the training procedure, an image of 7201280 will be randomly cropped to 256256, having enough events in that area. Moreover, we convert pictures in the GoPro dataset to grayscale images, because that there are only grayscale images in the real dataset.

Moreover, we divide the input events into 6 bins, which means we make the input events 6 channels rather than just stack them into 1 channel because according to [20], more channels work better than simply 1 channel. In our experiment, 6 channels have shown higher restoration quality, which is 32.99dB vs. 29.93dB on PSNR and 0.9353 vs. 0.9043 on SSIM.

Figure 5: An example of deblurring and HFR video generation results on our synthetic event dataset based on the GoPro dataset [21]. (a) The input blurry image. (b)(f) Deblurring results of Nah et al[21], Tao et al[35], Jin et al[11], Pan et al[24] and our method. (g) and (h) Frames from the generated video by Pan et al[24] and our method.

4.3 Experimental results


We compare our proposed method with state-of-the-art learning-based image deblurring methods on synthetic dataset, including [21, 13, 35, 37]. We also compare with the result of EDI model [24]. We generate synthetic events on each channel of the images, which is consistent with the principle of color DVS [30]. Then we restore three channels separately and combine them for final output. To prove the effectiveness of the proposed residual network, we propose a baseline-d method without the global residual connection.

The deblurring results comparison is shown in Table 1 and Figure 5(a)(f). As indicated in Table 1, our method achieves the best performance on PSNR and promising result on SSIM comparing to state-of-the-art methods.

We also compare our proposed method on a real dataset, whose results are shown in Figure 1 and Figure 2. We can find clearly that our method restores a clearer image than the other learning-based methods. Comparing to the EDI model [24], our model suffers less from the background noise caused by the event camera, which leads to less noise in the restored image.

Figure 6: Examples of deblurring and HFR video generation results on the real dataset from [24]. (a) The input blurry image. (b) The corresponding event data. (c)(f) Deblurring results of Nah et al[21], Tao et al[35], Pan et al[24] and our method. (g)(i) Frames of videos generated by Rebecq et al[9]222For a better figure layout, we put placeholders where this method does not output a frame., Pan et al[24] and our method.
Figure 7: A failure example of our method, in which the checkerboard still remains blurry.
HFR video generation.

We compare our video generation method with state-of-the-art generation methods [29, 11, 24, 9] in Figure 5(g) and (h), Table 1 for synthetic dataset and in Figure 2 for real dataset. To prove the efficiency of our residual learning method to generate HFR video, we design two baseline methods: baseline-v1 without the global residual connection and baseline-v2 using Dense block in the downsampling procedure.

Compared with image-based method [11], our method achieves higher quality. In comparison to event-based generation methods, the video generated by our method has less noise than [24] and richer details than [9]. As for the baseline-v2, the quality of its output drops more rapidly than our method, though it has comparable results of PSNR and SSIM. Please refer to the supplement video for visual quality comparison.

4.4 Failure samples

There are indeed some pictures in the real dataset from  [24] which our method cannot restore well, as shown in Figure 7. It is due to that the event camera parameters in our synthetic dataset for training are different from those used in [24]. The threshold and the bandwidth can both influence distribution of events. The steep intensity change like a checkerboard is not covered in our training data, resulting in poor performance as the example shown in Figure 7.

5 Conclusion

We propose a residual learning deblurring method using event cameras, which has a modified U-Net structure with DenseNet blocks in each layer. Because of the high temporal resolution of event cameras, motion information is encoded in the output events. With events, our method can avoid restoring blurry images blindly as image-based methods and get more accurate results than existing event-based methods thanks to the effectiveness of the proposed residual representation and network. Using a similar structure with Conv-LSTM blocks, we can further generate an HFR video with a restored image and events.

Our method does not get satisfying results when the event camera parameters are different from our synthetic data. The resolution of DVS is much lower (346260 and below) than an RGB camera. In our future work, we hope to combine high resolution color cameras with event cameras and construct a hybrid system to achieve higher resolution in either deblurring or HFR video generation tasks.


  • [1] P. Bardow, A. J. Davison, and S. Leutenegger. Simultaneous optical flow and intensity estimation from an event camera. In

    Proc. of Computer Vision and Pattern Recognition

    , 2016.
  • [2] S. Barua, Y. Miyatani, and A. Veeraraghavan.

    Direct face detection and video reconstruction from event cameras.

    In IEEE Winter Conference on Applications of Computer Vision, 2016.
  • [3] C. Brandli, R. Berner, M. Yang, S. C. Liu, and T. Delbruck. A 240x180 130db 3us latency global shutter spatiotemporal vision sensor. IEEE Journal of Solid-State Circuits, 2014.
  • [4] C. Brandli, L. Muller, and T. Delbruck. Real-time, high-speed video decompression using a frame and event-based davis sensor. In IEEE International Symposium on Circuits and Systems, 2014.
  • [5] T. F. Chan and C. K. Wong. Total variation blind deconvolution. 7(3):370–375, 1998.
  • [6] S. Cho and S. Lee. Fast motion deblurring. In Proc. of ACM SIGGRAPH Asia, 2009.
  • [7] W. Dong, L. Zhang, G. Shi, and L. Xin. Nonlocally centralized sparse representation for image restoration. IEEE Transactions on Image Processing, 22(4):1618–1628, 2013.
  • [8] A. Dosovitskiy, P. Fischery, E. Ilg, P. Hausser, C. Hazirbas, V. Golkov, P. V. D. Smagt, D. Cremers, and T. Brox. Flownet: Learning optical flow with convolutional networks. In Proc. of Computer Vision and Pattern Recognition, 2015.
  • [9] V. K. Henri Rebecq, Rene Ranftl and D. Scaramuzza. High speed and high dynamic range video with an event camera. In Proc. of Computer Vision and Pattern Recognition, 2019.
  • [10] G. Huang, Z. Liu, L. van der Maaten, and K. Q. Weinberger. Densely connected convolutional networks. In Proc. of Computer Vision and Pattern Recognition, 2017.
  • [11] M. Jin, G. Meishvili, and P. Favaro. Learning to extract a video sequence from a single motion-blurred image. In Proc. of Computer Vision and Pattern Recognition, 2018.
  • [12] J. Johnson, A. Alahi, and F. F. Li.

    Perceptual losses for real-time style transfer and super-resolution.

    In Proc. of European Conference on Computer Vision, 2016.
  • [13] O. Kupyn, T. Martyniuk, J. Wu, and Z. Wang. DeblurGAN-v2: Deblurring (orders-of-magnitude) faster and better. In Proc. of Internatoinal Conference on Computer Vision, 2019.
  • [14] X. Lei, J. Wang, W. Heidrich, and M. Hirsch. Learning high-order filters for efficient blind deconvolution of document photographs. In Proc. of European Conference on Computer Vision, 2016.
  • [15] D. Li, L. Li, and X. Li. Classification of remote sensing images based on densely connected convolutional networks. In Proc. of Computer Vision and Pattern Recognition, 2017.
  • [16] X. Li and J. Jia. Two-phase kernel estimation for robust motion deblurring. In Proc. of European Conference on Computer Vision, 2010.
  • [17] X. Li, S. Zheng, and J. Jia. Unnatural l0 sparse representation for natural image deblurring. In Proc. of Computer Vision and Pattern Recognition, 2013.
  • [18] P. Lichtsteiner, C. Posch, and T. Delbruck. A 128 128 120 db 15 s latency asynchronous temporal contrast vision sensor. IEEE Journal of Solid-State Circuits, 43(2):566–576, 2008.
  • [19] M. Mirza and S. Osindero. Conditional generative adversarial nets. Computer Science, pages 2672–2680, 2014.
  • [20] S. M. Mostafavi i, L. Wang, Y.-S. Ho, and K.-J. Yoon. Event-based high dynamic range image and very high frame rate video generation using conditional generative adversarial networks. In Proc. of Computer Vision and Pattern Recognition, 2019.
  • [21] S. Nah, T. H. Kim, and K. M. Lee. Deep multi-scale convolutional neural network for dynamic scene deblurring. In Proc. of Computer Vision and Pattern Recognition, 2017.
  • [22] S. Nah, S. Son, and K. M. Lee. Recurrent neural networks with intra-frame iterations for video deblurring. In Proc. of Computer Vision and Pattern Recognition, 2019.
  • [23] J. Pan, Z. Hu, Z. Su, and M.-H. Yang. Deblurring text images via l0-regularized intensity and gradient prior. In Proc. of Computer Vision and Pattern Recognition, 2014.
  • [24] L. Pan, C. Scheerlinck, X. Yu, R. Hartley, M. Liu, and Y. Dai. Bringing a blurry frame alive at high frame-rate with an event camera. In Proc. of Computer Vision and Pattern Recognition, 2019.
  • [25] K. Purohit, A. Shah, and A. Rajagopalan.

    Bringing alive blurred moments.

    In Proc. of Computer Vision and Pattern Recognition, 2019.
  • [26] H. Rebecq, D. Gehrig, and D. Scaramuzza. ESIM: an open event camera simulator. Conf. on Robotics Learning (CoRL), Oct. 2018.
  • [27] C. Reinbacher, G. Graber, and T. Pock. Real-time intensity-image reconstruction for event cameras using manifold regularisation. In The British Machine Vision Conference, 2016.
  • [28] O. Ronneberger. U-net convolutional networks for biomedical image segmentation. In Medical Image Computing and Computer Assisted Interventions Conference, 2015.
  • [29] C. Scheerlinck, N. Barnes, and R. Mahony. Continuous-time intensity estimation using event cameras. In Prof. Asian Conference on Computer Vision, 2018.
  • [30] C. Scheerlinck, H. Rebecq, T. Stoffregen, R. M. N. Barnes, and D. Scaramuzza. Ced: Color event camera dataset. In Proc. of Computer Vision and Pattern Recognition, 2019.
  • [31] C. J. Schuler, M. Hirsch, S. Harmeling, and B. Scholkopf. Learning to deblur. IEEE Transactions on Pattern Analysis and Machine Intelligence, 38(7):1439–1451, 2016.
  • [32] X. Shi, Z. Chen, H. Wang, D.-Y. Yeung, W.-K. Wong, and W.-c. Woo.

    Convolutional lstm network: A machine learning approach for precipitation nowcasting.

    In Advances in neural information processing systems, pages 802–810, 2015.
  • [33] A. Sironi, M. Brambilla, N. Bourdis, X. Lagorce, and R. Benosman. Hats: Histograms of averaged time surfaces for robust event-based object classification. In Proc. of Computer Vision and Pattern Recognition, 2018.
  • [34] J. Sun, W. Cao, Z. Xu, and J. Ponce. Learning a convolutional neural network for non-uniform motion blur removal. In Proc. of Computer Vision and Pattern Recognition, 2015.
  • [35] X. Tao, H. Gao, Y. Wang, X. Shen, J. Wang, and J. Jia. Scale-recurrent network for deep image deblurring. In Proc. of Computer Vision and Pattern Recognition, 2018.
  • [36] H. Zhang, D. Wipf, and Y. Zhang. Multi-image blind deblurring using a coupled adaptive sparse prior. In Proc. of Computer Vision and Pattern Recognition, 2013.
  • [37] J. Zhang, J. Pan, J. S. J. Ren, Y. Song, L. Bao, R. W. H. Lau, and M. Yang. Dynamic scene deblurring using spatially variant recurrent neural networks. In Proc. of Computer Vision and Pattern Recognition, 2018.
  • [38] K. Zhang, W. Luo, Y. Zhong, L. Ma, W. Liu, and H. Li. Adversarial spatio-temporal learning for video deblurring. In IEEE Transactions on Image Processing, 2018.
  • [39] A. Z. Zhu, L. Yuan, K. Chaney, and K. Daniilidis. Unsupervised event-based learning of optical flow, depth, and egomotion. In Proc. of Computer Vision and Pattern Recognition, 2018.