Blur2Vid: Recovering Video from Blurred Images

• Blur2Vid is the task of recovering a temporally ordered sequence of sharp frames from a single motion-blurred image by inverting the temporal integration inherent in the capture process.
• Early approaches used symmetric pairwise reconstruction and ordering-invariant losses, while later methods employ recurrent motion-latent frameworks and explicit ordering regularization to enhance temporal consistency.
• Recent diffusion-based generative models extend the task by predicting past, present, and future frames, advancing applications in motion analysis and dynamic 3D scene reconstruction.

Blur2Vid denotes the problem of recovering a temporally ordered sharp video from a single motion-blurred image. In its basic form, the observation is modeled as the temporal average of latent sharp frames during exposure, so the task is to invert an averaging process that destroys both high-frequency detail and temporal order. Early formulations treated the blurred image as a compressed record of a short latent sequence, while later work reframed the task as motion-latent decoding or conditional video generation with large-scale video priors (Jin et al., 2018, Purohit et al., 2022, Tedla et al., 22 Dec 2025).

1. Problem definition and image formation

The canonical Blur2Vid model writes a motion-blurred image as a temporal integration or average of latent sharp frames. One formulation is

$$y = g\left(\frac{1}{\tau}\int_0^\tau \tilde x(t)\,dt\right) = g\left(\frac{1}{T}\sum_{i=0}^{T-1} x[i]\right),$$

where $y$ is the observed blurred image, $g(\cdot)$ is the camera response function, and $x[i]$ are latent frames over discretized exposure bins (Jin et al., 2018). A later formulation states the same principle as

$x_B \approx \frac{1}{N}\sum_{n=1}^{N} x_n,$

with $x_B$ the blurred image and $\{x_n\}_{n=1}^N$ the latent sharp frames (Purohit et al., 2022). In the 2025 generative formulation, blur is written as

$$I = g\left(\int_{t\in \mathcal{T}} E(t)\,dt\right),$$

emphasizing that a video is a physically faithful explanation of the measurement (Tedla et al., 22 Dec 2025).

Two ambiguities define the field. First, the inversion is a blind deconvolution problem, so many sharp sequences can average to the same blurred observation. Second, averaging destroys temporal ordering: a forward sequence and its reversal can produce the same blur. This makes Blur2Vid distinct from conventional deblurring, which seeks one sharp image, and from standard video restoration, which already has multiple time-indexed observations (Jin et al., 2018).

A recurrent theme across the literature is that motion blur is not treated merely as corruption. It is treated as a compressed temporal signal encoding scene motion, camera motion, occlusion patterns, and sometimes depth variation. This suggests that Blur2Vid is fundamentally a spatio-temporal inverse problem rather than a single-frame enhancement problem (Purohit et al., 2022, Tedla et al., 22 Dec 2025).

2. Early single-image sequence extraction

The earliest deep formulations reconstructed the latent sequence from one blurred image by exploiting symmetry around a middle frame. In "Learning to Extract a Video Sequence from a Single Motion-Blurred Image" (Jin et al., 2018), the main experiments used $T=7$ latent frames, with one network $\phi_4$ for the middle frame and separate networks for symmetric pairs $y$0, $y$1, and $y$2. The middle frame was supervised directly using

$y$3

while non-middle frames used ordering-invariant losses over symmetric pairs.

The critical technical device was the pairwise ordering-invariant loss

$y$4

which compares sums and absolute differences of symmetric frame pairs and therefore does not force a unique temporal direction (Jin et al., 2018). The same work reported that a global ordering-invariant loss based only on frame sums was too weak, especially when the blur averages more than 3 frames.

Architecturally, this line of work used a large receptive field, resampling convolution with factor 4, residual blocks, and dilated convolutions to address the ill-posedness of deblurring from a single image. The middle-frame estimator was also evaluated as a practical deblurring network. On a test set matched to its training blur, it reported 32.20 dB PSNR versus 30.52 dB for Nah et al.; on its own test set, 29.02 dB versus 28.19 dB; and on Nah’s original harder test images, 26.98 dB versus 28.48 dB (Jin et al., 2018). These numbers already exposed a persistent property of Blur2Vid systems: performance depends strongly on the blur regime represented during training.

3. Motion-latent recurrent formulations

A more structured formulation was introduced in "Unfolding a blurred image" (Purohit et al., 2022). It proposed a two-stage, fully convolutional, end-to-end differentiable framework: first learn motion representation from sharp videos using a self-supervised video autoencoder, then transfer that representation to blurred images by training a Blurred Image Encoder (BIE) under guidance from the learned decoder.

The video autoencoder consists of a Recurrent Video Encoder (RVE) and Recurrent Video Decoder (RVD). For input frames $y$5, the encoder recurrence is

$y$6

and the final hidden state $y$7 becomes the learned motion representation (Purohit et al., 2022). The encoder uses 4 convolutional blocks with $y$8 filters, feature map sizes $y$9, and a $g(\cdot)$0 ConvLSTM kernel. The decoder is initialized by

$g(\cdot)$1

and recurrently predicts multi-scale optical flow maps $g(\cdot)$2, which warp a central frame through a differentiable transformer: $g(\cdot)$3

This formulation does not generate pixels directly. It decodes motion and applies that motion to a sharp reference frame. The surrogate reconstruction loss for the video autoencoder is

$g(\cdot)$4

At test time, a separate Deblurring Module (DM) first estimates a sharp center frame,

$g(\cdot)$5

then BIE extracts a motion embedding $g(\cdot)$6, and the RVD decodes the video

$g(\cdot)$7

This framework separates content restoration, motion extraction, and temporal generation. The DM is an encoder-decoder with Residual Dense Blocks in the encoder, bottleneck blocks in the decoder, skip connections at 3 scales, and a U-Net-like structure (Purohit et al., 2022). The BIE–RVD pair is trained with a reconstruction term plus a motion smoothness regularizer,

$g(\cdot)$8

A central issue is temporal ambiguity. The paper states that blur is temporally ambiguous and directional ambiguity remains, especially with multiple moving objects. To address this, the BIE–RVD pair is trained with an ordering-invariant frame reconstruction loss and a spatial motion smoothness loss, while staged training is preferred over direct joint training because otherwise the model must learn motion extraction from blur and frame generation from latent motion simultaneously (Purohit et al., 2022).

Quantitatively, using the ambiguity-invariant loss, the method reports 44.12 versus 49.06 for Jin et al. in the 7-frame blur setting, and 48.24 in the 9-frame blur setting, where Jin et al. is not applicable due to rigid 7-frame design (Purohit et al., 2022). It also reports a more compact model, 34 MB versus 70 MB, deblurring runtime 0.02 s versus 0.45 s, and video generation runtime 0.39 s versus 1.10 s (Purohit et al., 2022).

Representative work	Core mechanism	Distinctive property
"Learning to Extract a Video Sequence from a Single Motion-Blurred Image" (Jin et al., 2018)	Sequential pairwise reconstruction with ordering-invariant losses	Recovers a 7-frame sequence around a middle frame
"Unfolding a blurred image" (Purohit et al., 2022)	RVE–RVD motion-latent framework with DM and BIE	Recurrent flow-based decoding from a single blurred image
"HyperCUT" (Pham et al., 2023)	Hyperplane-based self-supervised ordering regularization	Assigns an explicit temporal order label
"Generating the Past, Present and Future from a Motion-Blurred Image" (Tedla et al., 22 Dec 2025)	Fine-tuned latent video diffusion with exposure-interval encoding	Supports present reconstruction and past/future generation

4. Ordering ambiguity and explicit ordering supervision

The forward/backward ambiguity was made the primary target of optimization in "HyperCUT: Video Sequence from a Single Blurry Image using Unsupervised Ordering" (Pham et al., 2023). Instead of relying only on order-invariant losses, HyperCUT learns an explicit order label in a latent space. It defines a mapping

$g(\cdot)$9

such that a frame pair and its reversal lie on opposite sides of a hyperplane $x[i]$0: $x[i]$1

The associated separation loss is

$x[i]$2

and the learned ordering network is then frozen and used as a regularizer for a Blur2Vid backbone: $x[i]$3 This changes the training problem from “accept both orders” to “choose one consistent order.”

HyperCUT is explicitly a plug-in regularizer. The base loss $x[i]$4 may be either a standard $x[i]$5 loss or the order-invariant loss from Jin et al. (Pham et al., 2023). The method was evaluated by measuring whether the hyperplane separates forward and reversed frame pairs correctly. Reported ordering results include REDS: hit 95.7, con@2 96.5, con@3 94.4; B-Aist++: hit 97.5, con@2 95.6, con@3 91.2; RB2V-Street: hit 98.7, con@2 98.3, con@3 96.8 (Pham et al., 2023).

The same work also introduced the Real Blur2Vid (RB2V) dataset, collected with a beam splitter camera system using two GoPro Hero-8 cameras, one at 25 fps and one at 100 fps (Pham et al., 2023). RB2V contains three subsets: RB2V-Street, RB2V-Face, and RB2V-Hand, with splits of 9000 / 2053, 8000 / 2157, and 12000 / 4722 for training/testing respectively. This is significant because earlier Blur2Vid work depended primarily on synthetic blur generation.

A plausible implication is that explicit ordering supervision reduces one of the main optimization pathologies of earlier methods: regression toward symmetric averages or temporally inconsistent pair selection. The reported improvements on border frames and trajectory recovery support that interpretation, but they do not eliminate the underlying physical ambiguity of the inverse problem (Pham et al., 2023).

5. Diffusion-based Blur2Vid and past/present/future generation

The 2025 paper "Generating the Past, Present and Future from a Motion-Blurred Image" recasts Blur2Vid as conditional video generation with large-scale generative priors (Tedla et al., 22 Dec 2025). Its central claim is that a single motion-blurred image is better treated as a partially observed video than as a corrupted still image. The model fine-tunes CogVideoX-2B, a 2B-parameter latent video diffusion transformer, and learns the conditional distribution

$x[i]$6

where $x[i]$7 is the blurred image and $x[i]$8 is the generated video.

The main novel conditioning signal is exposure-interval encoding. Each scalar time value is encoded as

$x[i]$9

and latent-frame exposure intervals are concatenated and linearly projected: $x_B \approx \frac{1}{N}\sum_{n=1}^{N} x_n,$0 The blurred image’s own exposure interval is normalized to $x_B \approx \frac{1}{N}\sum_{n=1}^{N} x_n,$1 and encoded in the same way (Tedla et al., 22 Dec 2025).

Training minimizes the expected $x_B \approx \frac{1}{N}\sum_{n=1}^{N} x_n,$2 error between the predicted denoised latent video $x_B \approx \frac{1}{N}\sum_{n=1}^{N} x_n,$3 and the clean latent video $x_B \approx \frac{1}{N}\sum_{n=1}^{N} x_n,$4,

$x_B \approx \frac{1}{N}\sum_{n=1}^{N} x_n,$5

while fine-tuning the entire diffusion transformer plus the exposure-interval projection layer. The model supports two modes. In present-only mode, output frames lie within the original exposure interval. In past/present/future mode, frames can extend before or after that interval, so the method generates plausible temporal continuations beyond the observation (Tedla et al., 22 Dec 2025).

Training data are upsampled to 1920 FPS via frame interpolation before blur synthesis, specifically to handle long exposures and dead time between frames. Inference uses 50 diffusion steps with a DDPM solver and classifier-free guidance scale 1.1 (Tedla et al., 22 Dec 2025). Evaluation adopts bidirectional patch-based metrics that account for time-reversal ambiguity, including bidirectional patch PSNR, SSIM, LPIPS, FVD, EPE, and motion-blur consistency.

On GoPro, the model reports 30.01 PSNR$x_B \approx \frac{1}{N}\sum_{n=1}^{N} x_n,$6, 0.9359 SSIM$x_B \approx \frac{1}{N}\sum_{n=1}^{N} x_n,$7, 0.010 LPIPS$x_B \approx \frac{1}{N}\sum_{n=1}^{N} x_n,$8, FVD 21.46, and EPE 0.39, compared with MotionETR’s 26.54 / 0.8825 / 0.015 / 94.90 / 1.46 and Jin et al.’s 25.23 / 0.8190 / 0.084 / 235.53 / 3.38 (Tedla et al., 22 Dec 2025). On B-AIST++, it reports 27.37 PSNR$x_B \approx \frac{1}{N}\sum_{n=1}^{N} x_n,$9, 0.9306 SSIM$x_B$0, 0.027 LPIPS$x_B$1, FVD 37.16, and EPE 1.78, outperforming Animation from Blur’s 26.69 / 0.9209 / 0.042 / 138.27 / 2.65. For motion-blur consistency on GoPro, the average of generated frames reaches 35.47 dB, versus 33.64 for Jin et al. and 32.17 for MotionETR.

This generative formulation also changes the interpretation of output. The paper is explicit that the generated future or past is not guaranteed to be what actually occurred; it is a plausible temporal explanation constrained by the blur (Tedla et al., 22 Dec 2025). That statement addresses a common misconception: stronger video priors improve realism and coherence, but they do not remove the non-identifiability of the original physical inverse problem.

6. Relation to video deblurring, applications, and limitations

Blur2Vid is adjacent to, but not identical with, video deblurring. Methods such as VDTR, BSSTNet, MB2D, DAVID, and motion-magnitude-guided RNNs assume access to multiple blurry frames and restore a sharp center frame or a restored video sequence (Cao et al., 2022, Zhang et al., 2024, Park et al., 2020, Wu et al., 2019, Wang et al., 2022). Blur2Vid instead asks whether a single blurred observation can be expanded back into a temporally ordered video. This makes it more ill-posed but also more closely tied to exposure-time image formation.

Several applications follow directly from the generated sequences. The 2025 diffusion model reports downstream use for recovering camera trajectories, object motion, and dynamic 3D scene structure, and shows that generated videos can be fed into MegaSaM or head-tracking pipelines (Tedla et al., 22 Dec 2025). HyperCUT reports improvements on face trajectory recovery from 5.75 to 4.87 and hand trajectory recovery from 11.67 to 9.2 when added to a Blur2Vid backbone (Pham et al., 2023). Earlier recurrent frameworks emphasized plausible temporally consistent sharp frames on planar scenes, depth variation, moving foreground objects, and real motion-blurred images (Purohit et al., 2022).

The field also has stable failure modes. Early sequential models are sensitive to middle-frame quality and degrade on very large blur (Jin et al., 2018). Recurrent motion-latent methods assume that a central sharp frame is recoverable or approximable and remain ambiguous under complex multi-object motion (Purohit et al., 2022). HyperCUT focuses on standard motion blur and may not directly handle complex nonrigid motion or long-exposure blur (Pham et al., 2023). The diffusion formulation assumes blur from a single contiguous exposure interval and struggles on composited images, timelapse-like images, extremely long exposures, and cases combining strong camera panning with complex scene motion (Tedla et al., 22 Dec 2025).

Taken together, these results suggest a clear technical trajectory. Early Blur2Vid systems imposed structure through symmetry and ordering-invariant losses; recurrent formulations learned a motion latent space and decoded flow-conditioned videos; explicit ordering methods replaced implicit ambiguity handling with learned temporal direction; and generative video priors extended the task from reconstructing exposure-time video to generating the past, present, and future. Across these variants, the central principle remains unchanged: a motion-blurred image is treated as a temporally integrated observation whose inversion requires simultaneous reasoning about content, motion, and temporal ordering (Jin et al., 2018, Purohit et al., 2022, Pham et al., 2023, Tedla et al., 22 Dec 2025).