When a camera captures a blurry image, the underlying physical process can be modeled as a convolution: an unknown sharp image $X$ is convolved with an unknown blur kernel $K$ (or point spread function) to produce the observed blurry image $Y$.
$$Y = X * K + N$$
where $N$ represents noise. If we know the blur kernel $K$, recovering $X$ is a standard non-blind inverse problem. However, in real-world scenarios, we rarely know how the camera shook or exactly when the lens went out of focus. We must estimate both $X$ and $K$ simultaneously from a single observation $Y$. This is the task of blind deblurring.
As noted across decades of image processing literature—from early recursive filtering frameworks (Li Chen et al.) to modern deep learning regimes (Diego Valsesia et al.)—blind deblurring is a fundamentally ill-posed inverse problem. The core challenge is not just numerical instability, but a deep mathematical symmetry known as the kernel-image ambiguity.
The Kernel-Image Ambiguity Trap
To understand why blind deblurring is so difficult, imagine an observed blurry image $Y$. One mathematically valid explanation is that the true scene was perfectly sharp ($X$), but the camera shook along a path described by $K$.
However, there is another equally valid explanation: the camera was perfectly still ($K$ is a single, sharp delta function), but the physical object itself was blurry. Without further constraints, an optimization algorithm cannot distinguish between a sharp image blurred by a wide kernel and a blurry image "blurred" by a sharp kernel.
In fact, standard maximum a posteriori (MAP) optimization frameworks often fall into a trap: they converge to the trivial "no-blur" solution where the estimated image is simply the blurry input $Y$ and the estimated kernel is an identity operator. This happens because a blurry image typically has lower total variation and looks more "likely" under naive statistical priors than a sharp image with complex textures.
To successfully unscramble the image, researchers must break this symmetry. They do this by introducing structural priors, restricting the space of valid blurs, or leveraging auxiliary hardware signals that independently constrain either $X$ or $K$.
Breaking Symmetry with Structural Priors
One way to prevent an algorithm from choosing the trivial solution is to enforce mathematical priors that favor the statistical properties of sharp images over blurry ones.
For example, natural text images possess a highly distinct, two-toned intensity profile. Jinshan Pan et al. leveraged this property by introducing an $L_0$-regularized prior on both image intensity and gradients. Because blur smooths out these discrete transitions, minimizing the $L_0$ norm forces the optimization away from the blurry input and toward a sharp, high-contrast reconstruction.
Blurry Edge (Smooth Gradient) Sharp Edge (L0 Sparse Gradient)
________ ____
/ \ | |
_____/ \_____ ______| |______
For more complex, non-text scenes, generic sparsity metrics can fail because high-frequency textures (like grass or fabric) can be mistaken for blur artifacts. To combat this, Dong Gong et al. proposed an automatic gradient activation strategy. Instead of penalizing all gradients globally, their method selectively isolates the most informative structural edges to guide kernel estimation, ignoring confusing fine-grained textures. Similarly, Bai Yuanchao et al. modeled image patches as signals on weighted graphs, using a Reweighted Graph Total Variation prior to preserve sharp structural skeletons while smoothing out noise.
Restricting the Kernel Manifold
Instead of only constraining the image $X$, another powerful strategy is to constrain the kernel $K$. In the real world, camera shake and defocus follow physical laws; a blur kernel cannot be an arbitrary collection of random pixels.
Traditional methods often struggled with space-variant blur, where the kernel changes across the frame due to camera rotation or depth variations (Stefan Harmeling et al.; Jian Sun et al.). To make this tractable, Phong Tran et al. proposed learning a continuous, low-dimensional "blur kernel space" from data. By forcing the estimated kernels to reside within this learned manifold, the optimization algorithm is physically blocked from exploring mathematically valid but unrealistic "no-blur" solutions.
Other approaches enforce self-consistency through architectural design. Yuxin Mao et al. introduced the concept of mathematical idempotence to neural networks. An ideal deblurring operator $f$ should be idempotent: once an image is sharp, applying the deblurring function a second time should change nothing ($f(f(X)) = f(X)$). Enforcing this constraint prevents the network from over-sharpening or introducing ghosting artifacts.
Divide and Conquer Across Scales and Time
When the blur kernel is large, the search space for potential solutions grows exponentially. To prevent optimization algorithms from getting lost in local minima, researchers frequently use a coarse-to-fine strategy.
[Coarse Scale] --> [Intermediate Scale] --> [Fine Scale]
Low Resolution Medium Resolution Full Resolution
Small Kernel Space Refining Details Sharp Image Output
Xin Tao formalized this in deep learning with the Scale-Recurrent Network (SRN-DeblurNet). At a very low resolution, fine textures disappear, and a large blur kernel shrinks to a fraction of its size. The network can easily resolve the macroscopic blur structure at this coarse scale, and then pass this hidden state down to finer scales to guide the recovery of sharp details. Kiyeon Kim et al. later optimized this paradigm by adjusting the depth of the sub-networks across scales, ensuring that computational power is spent where the structural ambiguity is highest.
Rather than dividing the problem spatially by scale, Dongwon Park et al. proposed dividing it temporally. Their multi-temporal recurrent framework breaks a single, severe motion blur down into a sequence of virtual, incremental temporal steps, effectively treating deblurring as a progressive video reconstruction problem at full resolution.
Sidestepping Ambiguity with Auxiliary Sensors
The most definitive way to resolve an under-determined problem is to introduce independent equations. In computational photography, this means capturing auxiliary data streams that directly record either the scene geometry or the camera's motion path.
Several hardware-driven paradigms have emerged to completely bypass the kernel-image ambiguity:
- Dual-Pixel Sensors: Modern smartphone cameras can capture dual-pixel (DP) data, which provides a left- and right-eye view through the lens. Abdullah Abuolaim et al. demonstrated that the subtle phase disparity between these two views contains direct geometric cues about defocus blur, allowing networks to instantly distinguish between a blurry object and a blurry texture.
- Inertial Sensors: Since camera shake is caused by physical rotation, Janne Mustaniemi et al. integrated smartphone gyroscope readings directly into a neural network. The gyroscope provides a noisy but independent measurement of the blur kernel $K$, leaving the network to focus entirely on restoring $X$.
- Event Cameras: Event sensors record asynchronous changes in brightness at microsecond resolution. When a camera shakes, the event stream maps out the exact trajectory of the edges over time. By fusing standard frames with event data, frameworks like those proposed by Jinjian Wu et al. and Davide Scaramuzza et al. can reconstruct sharp images and 3D neural radiance fields even under extreme motion, effectively turning a blind problem into a guided one.