Image Degradation Models — Where Does Blur Come From?

Why Do Photos Get Blurry?

Scrolling through your phone gallery, you will always encounter such regrets: at the moment you pressed the shutter, you captured a beautiful moment, but the photo turned out blurry — maybe due to shaky hands, insufficient light, or the subject moving too fast. Old photos are even worse — the passage of time makes memories from back then become fuzzy.

Blur is not accidental. In the world of digital imaging, every photo undergoes a complex transformation process from the real scene to digital signals. Light passes through the lens, falls on the sensor, gets recorded by electronic systems — every link may introduce “degradation.” Understanding how these degradations occur is the first step to studying image restoration from a mathematical perspective.

Mathematical Model of Image Degradation

From Intuition to Formula

Imagine you have a perfect, sharp photo, but your hand shook a bit while taking the picture, so the photo became blurry. This “hand shake” process can be abstracted as a mathematical operation: mix each pixel of the original image with its surrounding pixels according to certain rules — this is convolution.

More precisely, the general mathematical model for image degradation is:

$$ g(x, y) = (h * f)(x, y) + n(x, y) $$

This formula describes the complete process of an image going from sharp to blurry. Let me explain the meaning of each symbol one by one:

• $f(x, y)$ is the original sharp image — a perfect image without any distortion in the ideal state
• $h(x, y)$ is the Point Spread Function (PSF) — describes how the imaging system “spreads” a point source, intuitively understood as the “blur kernel”
• $*$ represents the two-dimensional convolution operation — convolve the blur kernel $h$ with the original image $f$ to produce the blur effect
• $n(x, y)$ is additive noise — various random interferences like sensor thermal noise, electronic noise
• $g(x, y)$ is the final observed degraded image — the blurry photo we actually get

This model decomposes image degradation into two main factors: deterministic degradation (convolution) and random degradation (additive noise). Deterministic degradation describes how the system smooths the image, while random degradation describes unpredictable noise pollution.

Visualization of the Degradation Process

The diagram below shows the complete process from original image to degraded image:

flowchart TD
    A["Original Image<br/>f(x,y)"] --> B["Convolution<br/>h * f"]
    B --> C["Add Noise<br/>+ n(x,y)"]
    C --> D["Degradated Image<br/>g(x,y)"]

    style A fill:#4CAF50,color:#fff
    style B fill:#2196F3,color:#fff
    style C fill:#FF9800,color:#fff
    style D fill:#f44336,color:#fff

This flowchart explains the essence of image degradation: the original sharp image undergoes convolution processing with the blur kernel, then noise is superimposed, finally producing the blurry image we see. Each step corresponds to a physical process in the real world.

Intuitive Understanding of Convolution

Convolution is one of the most core mathematical tools in image processing. From an intuitive perspective, convolution is a form of “weighted average”: for each pixel in the image, take the pixel values within a certain range around it, perform a weighted sum according to the weights defined by the blur kernel, and get the new pixel value.

Here is a simple example: if the blur kernel is a $3 \times 3$ matrix where all elements are $1/9$, then the convolution operation is to slide a $3 \times 3$ window across the entire image and use the average of the 9 pixels in the window as the pixel value of the corresponding position in the new image — this is uniform blur.

$$(h * f)(x, y) = \sum_{u=-\infty}^{\infty} \sum_{v=-\infty}^{\infty} h(u, v) f(x-u, y-v)$$

This discrete convolution formula tells us: the value of image $(h*f)$ at position $(x,y)$ equals the result of the weighted sum of blur kernel $h$ and original image $f$ centered at $(x,y)$.

Representation in Frequency Domain

Convolution operations are computationally expensive in the time domain (spatial domain), but become simple multiplication operations in the frequency domain. This is the magic of the Fourier transform. Applying the Fourier transform to both sides of the degradation model, we get:

$$ G(u, v) = H(u, v) \cdot F(u, v) + N(u, v) $$

Where $G(u,v)$, $H(u,v)$, $F(u,v)$, $N(u,v)$ are the two-dimensional Fourier transforms of $g(x,y)$, $h(x,y)$, $f(x,y)$, $n(x,y)$ respectively. $H(u,v)$ is specifically called the Optical Transfer Function (OTF), which is the representation of the point spread function in the frequency domain.

An important advantage of frequency domain representation is: convolution becomes multiplication, and inverse problems become division. Theoretically, if we know $G(u,v)$ and $H(u,v)$, we can recover the original image through $F(u,v) = G(u,v) / H(u,v)$. But reality is much more complex than theory — $H(u,v)$ may approach zero at certain frequencies, and division will produce infinity or extremely unstable results. This is where the difficulty of inverse problems lies.

Common Blur Types

Different physical processes produce different types of blur. Understanding these differences is crucial for choosing appropriate image restoration algorithms.

Gaussian Blur

Gaussian blur is the most common type of blur, caused by imperfections in the optical system itself, atmospheric turbulence, or focal offset. Its point spread function follows a two-dimensional Gaussian distribution:

$$ h(x, y) = \frac{1}{2\pi\sigma^2} e^{-\frac{x^2+y^2}{2\sigma^2}} $$

Where $\sigma$ controls the intensity of the blur — the larger $\sigma$, the more severe the blur. Gaussian blur is characterized by isotropy (same degree of blur in all directions), smoothness, and central symmetry. In the frequency domain, Gaussian blur corresponds to a low-pass filter — high-frequency components (details) are attenuated, while low-frequency components (overall structure) are preserved.

Motion Blur

Motion blur occurs when the camera or object moves relative to each other during exposure. Its point spread function is a line segment along the direction of motion:

$$ h(x, y) = \begin{cases} \frac{1}{L} & \text{if } x \cos\theta + y \sin\theta \leq \frac{L}{2} \ 0 & \text{otherwise} \end{cases} $$

Where $L$ is the motion distance (in pixel units), and $\theta$ is the motion direction angle. Motion blur has strong directionality — details along the direction of motion are severely lost, while details perpendicular to the direction are relatively preserved. The “light trail” effect in night photography is a typical example of motion blur.

Defocus Blur

Defocus blur is caused by insufficient depth of field — when the subject is not accurately in focus, a point source will spread into a disk (or the shape of the camera aperture). Its point spread function can be represented as a disk function:

$$ h(x, y) = \begin{cases} \frac{1}{\pi R^2} & \text{if } x^2 + y^2 \leq R^2 \ 0 & \text{otherwise} \end{cases} $$

Where $R$ is the blur radius, depending on the size of the lens aperture and the focus offset. Defocus blur is bright in the center and fades at the edges, especially noticeable when shooting with large apertures (background blur effect).

Uniform Blur

Uniform blur is produced by the physical process of integral sampling — each pixel of the camera sensor does not measure a single point, but measures the average light intensity of a small area. Its point spread function is a rectangular window function:

$$ h(x, y) = \begin{cases} \frac{1}{ab} & \text{if } |x| \leq a/2 \text{ and } |y| \leq b/2 \ 0 & \text{otherwise} \end{cases} $$

Where $a$ and $b$ are the dimensions of sensor pixels in horizontal and vertical directions. Uniform blur can cause a “blocky” feel to the image, and in extreme cases, a mosaic effect can be observed.

Comparison of Blur Types

flowchart TD
    A["Image Degradation"] --> B["Gaussian Blur"]
    A --> C["Motion Blur"]
    A --> D["Defocus Blur"]
    A --> E["Uniform Blur"]

    B --> B1["Isotropic<br/>Center Symmetric"]
    C --> C1["Directional<br/>Light Trail Effect"]
    D --> D1["Bright Center Dark Edge<br/>Disk Shape"]
    E --> E1["Blocky Feel<br/>Sampling Effect"]

    style A fill:#9C27B0,color:#fff
    style B fill:#2196F3,color:#fff
    style C fill:#2196F3,color:#fff
    style D fill:#2196F3,color:#fff
    style E fill:#2196F3,color:#fff
    style B1 fill:#FF9800,color:#fff
    style C1 fill:#FF9800,color:#fff
    style D1 fill:#FF9800,color:#fff
    style E1 fill:#FF9800,color:#fff

The diagram above summarizes the core characteristics of four common blur types. In real-world scenarios, multiple types of blur often occur simultaneously — for example, night photography may simultaneously have motion blur, Gaussian blur, and sensor noise.

Low-Resolution Image Generation Model

In addition to blur, another common form of image degradation is resolution reduction — the process of generating low-resolution images from high-resolution images. This process is typically modeled as:

$$ g = D(h * f) + n $$

Where $D$ is the downsampling operator, most commonly row-and-column sampling or average pooling. Specifically:

1. Blur: First apply the blur kernel $h$ to the high-resolution image $f$ (usually Gaussian blur) to prevent high-frequency components from generating aliasing during downsampling
2. Downsample: Then apply the downsampling operator $D$, selecting one pixel at fixed intervals (usually every 2 pixels)
3. Add Noise: Finally superimpose noise $n$

The goal of the Super-Resolution task is precisely to recover the high-resolution image $f$ from the low-resolution image $g$. This is a typical ill-posed problem — recovering infinite information from limited information.

Downsampling Process Illustration

flowchart TD
    A["High-Res Image<br/>f(x,y)"] --> B["Blur<br/>h * f"]
    B --> C["Downsample<br/>D"]
    C --> D["Add Noise<br/>+ n"]
    D --> E["Low-Res Image<br/>g"]

    style A fill:#4CAF50,color:#fff
    style B fill:#2196F3,color:#fff
    style C fill:#FF9800,color:#fff
    style D fill:#9C27B0,color:#fff
    style E fill:#f44336,color:#fff

This flowchart explains the generation process of low-resolution images: the high-resolution image first undergoes blur processing (to prevent aliasing), then resolution is reduced through downsampling, and finally noise is superimposed. This process is irreversible — lost information cannot be directly recovered from low-resolution images.

Inverse Problem and the Difficulty of Restoration

Recovering the original image $f$ from the degraded image $g$ is, in mathematics, an inverse problem. The forward problem is “given the original image, generate the degraded image,” and the inverse problem is “given the degraded image, recover the original image.” Inverse problems are typically much more difficult than forward problems, for the following reasons.

Ill-Posedness

Mathematician Hadamard defined three conditions for well-posed problems: existence, uniqueness, and stability. Image restoration problems face challenges in all three aspects:

1. Existence: Theoretical analysis assumes there exists an exact $f$ satisfying the degradation equation, but in reality the degradation model is an approximation, the noise term $n$ is imprecise, and $f$ may not exist at all
2. Uniqueness: Different original images may produce the same degraded image — blur is a process of information loss, multiple original images map to the same degraded result
3. Stability: Small perturbations in $g$ can lead to huge changes in the recovery result $f$ — this is the famous noise amplification problem

Noise Amplification

In the frequency domain, theoretically the original image can be recovered through division:

$$ F(u, v) = \frac{G(u, v) - N(u, v)}{H(u, v)} = \frac{G(u, v)}{H(u, v)} - \frac{N(u, v)}{H(u, v)} $$

The problem is, when $|H(u,v)|$ is very small (high-frequency regions), the term $\frac{N(u,v)}{H(u,v)}$ becomes extremely large — tiny noise $N(u,v)$ gets massively amplified. In extreme cases, $H(u,v)$ equals zero, and the recovery formula completely fails.

This is why direct inverse filtering works poorly in practice — high-frequency details are drowned out by noise, and the recovered image is full of spurious oscillations and artifacts.

The Essence of Information Loss

Image degradation is essentially an information compression process: high-resolution continuous scenes are compressed into limited pixels, and detailed information is destroyed by blur and sampling. Completely recovering the original information from compressed information is impossible — just like recovering 1200px details from a 300px photo, no matter how advanced the algorithm, it cannot create non-existent information out of thin air.

Modern deep learning methods, to some extent, “guess” the lost information by learning statistical patterns from large amounts of images. But guessing is still guessing — it cannot guarantee complete correctness. This also explains why super-resolution and deblurring remain open problems in computer vision.

Summary and Outlook

Image degradation models provide a mathematical framework for understanding blurry and low-resolution images. The core formula $g(x,y) = (h*f)(x,y) + n(x,y)$ decomposes images into three components: sharp image, blur kernel, and noise, laying the theoretical foundation for image restoration.

Different types of blur have different physical origins: Gaussian blur comes from optical system imperfections, motion blur comes from relative motion, defocus blur comes from focus offset, and uniform blur comes from sampling limitations. Understanding these differences allows us to choose appropriate restoration algorithms in a targeted manner.

The low-resolution image generation model $g = D(h*f) + n$ describes the complete process from high resolution to low resolution. This process is irreversible — information loss is the core difficulty facing image restoration.

The ill-posedness of inverse problems and noise amplification explain why image restoration is so difficult. From a mathematical perspective, we need to introduce regularization, constraints, or prior knowledge to reasonably recover the original image from degraded images.

In the next article, we will explore traditional image restoration methods, from inverse filtering to Wiener filtering, to the Richardson-Lucy algorithm, and see how mathematicians find a way out amid the difficulties of inverse problems.