Digital Signal Processing Design Image Restoration Image ...

Digital Signal Processing 

Design 

g 

Lecture_IP 6 

Image Processing – Image 

Restoration Methods 

Model of Image 

Degradation/Restoration Process 

i Degradation process modeled as a degradation function, with an additive noise term, 

of the form: 

gxy ( , ) = Hfxy [ ( , )] + η( 

xy , ) 

f( x, y) 

is the original (undegraded) image 

H is the degradation function 

η( 

xy , ) is the additive noise term 

i Object of restoration is to obtain an estimate, fˆ( x, y), 

of the original image which is as 

close as possible to the original input image. 

i The more we know about 

H and η( 

x, y), the closer fˆ( x, y)will be to f( x, y) 

Noise Models 

• Two basic types of noise models: 

– noise in the spatial domain; described by a 

noise probability density function 

– noise in the frequency domain; described by 

various Fourier properties of the noise 

• Basic assumption about the noise models: 

– noise is assumed to be independent of image 

(coordinates) 

Image Restoration 

• Objective of image restoration is to improve a given 

image in some objective and pre-defined sense 

• Image restoration ≠ Image enhancement 

– image enhancement is a subjective process 

– image restoration is an objective process 

• Restoration attempts to reconstruct or recover an image 

that has been degraded by using apriori knowledge of 

the degradation phenomenon 

– restoration techniques try to model the degradation and apply 

the inverse process in order to recover the original image 

Image Restoration Model 

i If H is a linear, spatially invariant process, the degraded image is given 

in the spatial domain by: 

gxy ( , ) = hxy ( , ) ∗ fxy ( , ) + η( 

xy , ) 

where hxy ( , ) is the spatial representation of the degradation function 

and 

symbol ∗ denotes convolution. 

i In the frequency domain we can describe the process as: 

G ( uv , ) = Huv ( , ) ⋅ F ( uv , ) + Nuv ( , ) 

where Fuv ( , ) is the Fourier transform of f( xy , ), Huv ( , )is the Fourier transform 

of hxy ( , ) and Nuv ( , )is the Fourier transform of η( 

xy , ) 

i H( u, v) sometimes called the optical transfer function (OTF) and h( x, y) 

sometimes 

called the point spread function (PSF) 

i The OTF and PSF are a Fourier transform pair; can use MATLAB functions: 

otf2psf - optical transfer function to point spread function 

psf2otf - point spread function to optical transfer function 

i Initially we assume 

that H is the identity operator and we deal only with degradation 

due to the noise term 

Additive Noise Models 

• MATLAB function to add noise to an image: 

– g = imnoise(f, type, parameters) 

• f is input image 

– imnoise converts input image to class double with range [0, 1] before 

adding noise 

• to add Gaussian G noise of mean 64 6 and variance 400 00 to an uint8 8 image, g , need 

to scale mean to 64/255, and scale variance to 400/(255) 2 for input to 

imnoise 

– g = imnoise(f, ‘gaussian’, m, var) adds Gaussian noise of mean m and 

variance var to image f. (Default is 0 mean and 0.01 variance) 

– g = imnoise(f, ‘salt & pepper’, d) corrupts image f with salt and pepper 

noise, where d is the noise density (percent of image area containing 

noise values). (Default is 0.05 noise density). 

– g = imnoise(f, ‘speckle’, var) adds multiplicative noise to image f, using 

form g = f + n*f, where n is uniform noise with mean 0 and variance var. 

(Default value of var is 0.04). 

2010-08-26 

1

f=imread(‘lena.tif’); 

Lena Original Image 

g=imnoise(f,’gaussian’,0,0.01); 

mean=0, variance=0.01; 





Upper Left: lena original; Upper Right: lena with salt & pepper noise at 0.01; Lower Left: 

lena with salt & pepper noise at 0.1; Lower Right: lena with salt & pepper noise at 1.0 

Noise Models 

Lena original; Lena with poisson noise added 

Additive Noise Models 

• g = imnoise(f, type, parameters) 

– g = imnoise(f, ‘gaussian’, m, var); % Gaussian noise 

of mean m and variance var; default is m = 0, var = 

0.01 

– g = imnoise(f imnoise(f, ‘salt salt & pepper’ pepper , d); adds salt and 

pepper noise, where d is the noise density (i.e., 

percent of image area containing noise values) 

– g = imnoise(f, ‘speckle’, var); adds multiplicative noise 

using equation g = f + n.*f, where n is uniformly 

distributed random noise with mean 0 and variance 

var; default var = 0.004 

– g = imnoise(f, ‘poisson’); generates Poisson noise 

from data 

Upper Left: lena original; Upper Right: lena with speckle noise at 0.004; Lower 

Left: lena with speckle noise at 0.04; Lower Right: lena with speckle noise at 0.4 

Summary 

of Noise 

Models 

2010-08-26 

2

Original Image (lena.tif) 

Noise Models 

Image corrupted by Gaussian 

noise of mean 0, variance 

400/(255*255) 

Noise with Specified Distribution 

• Sometimes want to generate noise with a given 

probability density function (PDF) or a given 

cummulative distribution function (CDF) 

i If f w is a uniformly f distributed random variable in the interval (0 (0, 1) 1), 

then we can obtain a random variable z with a specified CDF, Fz, 

by 

solving the equation 

−1 

z = Fz( w) 

or, equivalently, by finding 

a solution to the equation 

Fz( z) = w 

Noise Distributions in the 

Real World 

• Gaussian noise occurs in imaging sensors 

operating at low light levels 

• Salt-and-pepper p pp noise arises in faulty y 

switching devices 

• Rayleigh noise arises in range imaging 

• Exponential and Erlang noise occur in 

laser imaging 

Image corrupted by ‘salt & 

pepper’ noise with density 0.1 

Noise Models 

Image corrupted by ‘speckle’ 

noise with mean 0 and variance 

0.04 

Noise with Specified Distribution 

i Assume a uniform random number, w, 

in the interval (0, 1), and 

we wish to generate random numbers, z, 

with a Rayleigh CDF of the form: 

2 

⎧ −( z−a) / bfor 

z ≥ a⎫ 

⎪1− 

e 

Fz( z) 

= ⎨ ⎬ 

⎪⎩ 0 for z < a⎭ 

where b > 0. To find z we solve the equation 

2 

−( z−a) / b 

1− 

e = w 

z = a + − b ln(1 − w ) 

i MATLAB: R = a + sqrt(-b*log(1-rand(M, N))); 

Rayleigh CDF with a=0, 

b=1 

Generation of RVs 

2010-08-26 

3

MATLAB Noise Generation 

• A = rand(M, N) – generates M x N array of uniformly 

distributed numbers in interval (0, 1) 

• A = randn(M, N) – generates M x N array of Gaussian 

distributed numbers with zero mean and unit variance 

• g = imnoise(f, type, parameters) – adds M x N array of 

noise of various types (e.g., ‘gaussian’, ‘salt & pepper’, 

‘speckle’, ‘poisson’) to an existing image, f 

• R = imnoise2(type, M, N, a, b) – generates M x N array 

of noise of types (‘uniform’,’gaussian’,’salt & 

pepper’,’lognormal’,’rayleigh’,’exponential’,’erlang’) 

– no scaling of noise array to (0, 1) interval 

– ‘salt & pepper’ noise has three values – 0 for pepper noise, 1 for 

salt noise, and 0,5 for no noise 

Random Number Histograms 

R = imnoise2(‘gaussian’, 10000, 1 0 1); 

P = hist(r, bins); -- bins=50 

Estimating Noise Parameters 

i Let z be a discrete random variable that denotes intensity levels in an image, 

i 

and let pz ( i ), i= 0,1,2,..., L−1, 

be the corresponding normalized histogram, 

where L is the number of possible intensity values. 

A histogram component, 

pz ( i ), is an estimate of the probability of occurrence of intensity value zi, 

and 

the histogram may be viewed as an approximation of the intensity PDF. 

i Use the histogram central moment to describe histogram shape, i.e., 

L L− 

1 

n 

n = ∑ zi −m 

p zi 

i = 0 

μ ( ) ( ) 

where n is the moment order, and m is the mean: 

L−1 

m = ∑ zip( zi) 

i = 0 

i Since the histogram is normalized (to a sum of 1.0), we 

see that μ0 = 1, μ1 

= 0, and 

the second moment is the variance, i.e., 

L−1 

2 

μ = ( z −m) 

p( z ) 

2 

∑ 

i i 

i = 0 

Salt & Pepper Noise 

• Salt & Pepper noise viewed as generating an image with three 

values; e.g., for uint8 images (with eight bits) 

– value 1 – 0, with probability Pp, – value 2 – 255, with probability Ps, – value 3 –k,with probability (1-(Pp+ Ps)) where k is any number between 

the two extremes 

• Denote the generated noise as r(x,y); the salt & pepper corrupted 

image is obtained by assigning a 0 to all locations in f where a 0 

occurs in r; similarly assigning a 255 to all locations in f where 255 

occurs in r; finally we leave unchanged in f all locations in which r 

contains the value k 

• P= Pp+ Ps called the noise density; if Pp=0.02 and Ps=0.01, then 

approximately 2% of pixels are corrupted by pepper noise, 1% are 

corruped by salt noise, and the noise density is 0.03. 


• Need to estimate noise parameters from 

the image data 

– generally estimate mean, m, and variance, σ2 , 

and then convert to noise distribution 

parameters a and b to specify PDF of interest 


• MATLAB code for estimating moments of a 

distribution: 

– [v, unv] = statmoments(p, n); 

– v(1) = m (mean); 

– v(k) = μ k, k=2,3,…,n 

– v contains normalized moments based on random 

variable scaled to range [0, 1] 

– unv contains same moments as v but computed with 

the data in its original range of values 

– p is histogram vector (size(p)=256 for uint8 images) 

– n number of moments to compute 

2010-08-26 

4


• Often noise parameters estimated directly from a 

given noisy image 

• Approach is to select a region of the image with 

as featureless a background g as p possible ( (ROI – 

Region of Interest) 

– B = roipoly(f, c, r); % polygonal ROI 

– f = image 

– c and r are vectors of column and row coordinates of 

the vertices of the polygon 

– B is binary image, same size as f, with 0’s outside 

ROI and 1’s inside 

Regions of Interest 

(a) Noisy image 

(b) Mask, B, generated 

interactively using command: 

[B, c, r] = roipoly(f); 

(c) Histogram of ROI generated 

using command: 

[h, npix] = histroi(f, c,r); 

figure, bar(h, 1); 

(d) Mean and variance of region 

masked by B obtained using 

command: 

[v, unv] = statmoments(h, 2); 

v=[0.5803, 0.0063] ; 

unv=[147.9814, 407.8679]; 

Histogram of Gaussian noise 

with same mean and variance 

as estimated above. 

Spatial Noise Filters 


• Interactively 

finding the ROI: 

– B = roipoly(f); % 

user specifies a 

polygon using the 

mouse and the set 

of commands at 

right side of figure 

Restoration – Noise Only Case 

i When the only degradation is noise, the model is: 

gxy ( , ) = f( xy , ) + η( 

xy , ) 

i Method of choice for restoration is spatial filtering. 

i SSpatial ti l filt filters of f iinterest: t t 

− Sxy denotes an mxn subimage (region) of noisy input image g 

− ( xy , ) is set of coordinates at center of region 

− fˆ( x, y) is an estimate of f( x, y), 

the filter response at ( xy , ) 

i The linear filters of the table (on next slide) are implemented using imfilter 

i The median non-linear filteris implemented using medfilt2 

i The max and min filters are implemented using imdilate and imerode 

i MATLAB routine spfile implements all these filters in the spatial domain 

Restoration Example – Noise 

Only Case 

Figure in (a) – pepper noise only 

[M, N] = size(f); 

R = imnoise2(salt & pepper’, M, N, 0.1, 0); 

gp = f; 

gp(R == 0) = 0; 

Figure in (b) – salt noise only 

R = imnoise2(‘salt imnoise2( salt % pepper’ pepper , MM, NN, 00, 00.1); 1); 

gs = f; 

gs(R == 1) = 255; 

Figure in (c) – contraharmonic filtering of (a) 

fp = spfilt(gp, ‘chmean’, e, e, 1.5); 

Figure in (d) – contraharmonic filtering of (b) 

fs = spfilt(gs, ‘chmean’, 3, 3, -1.5); 

Figures in (e) and (f) – max (part (a)) and 

min (part (b)) filters 

fpmax = spfilt(gp, ‘max’, 3, 3); 

fsmin = spfilt(gs, ‘min’, 3, 3); 

2010-08-26 

5

MATLAB Find Function 

• I = find(A) – I contains all the indices of array A that point to nonzero 

elements 

• [r, c] = find(A) – returns the row and column indices of non-zero 

elements of A 

• [r, c, v] = find(A) – returns also the nonzero values in A in column 

vector v 

• Example: find and set to 0 all pixels in A whose values are less than 

8 

– I = find(A < 8); 

A(find(A= 64 & A = 64 & A motion of 9 pixels in the horizontal direction 

2010-08-26 

6

Degraded Image Creation 

• use MATLAB function imfilter to create degraded image 

with a PSF that is either known or computed (as in 

previous slide): 

g = imfilter(f, PSF, ‘circular’); % minimize border effects 

• add appropriate noise to model degraded image 

g = g + noise; % noise same size as g; generated using one of 

methods discussed previously 

• use checkerboard pattern as image example 

c = checkerboard(NP, M, N); % NP= number pixels on the side 

of each square; M row; N columns; 

% light squares on left half are white; light squares on right half 

are gray; all light squares white using 

K = checkerboard(NP, M, N) > 0.5; % range of K is [0 1] (class 

double) 

Degraded Image Restoration 

• Method 1 – Direct Inverse Filtering 

– ignore noise term 

– form estimate of the form: 

ˆ Guv ( , ) 

Fuv ( , ) 

= 

Huv ( , ) 

– where G(u,v) is the FT of the degraded 

image, and H(u,v) is the FT of the estimated 

blurring filter 

– take the inverse Fourier transform as the 

estimate of the deblurred image 


i Weiner filtering solution; seek an estimate, fˆ, 

that minimizes 

the statistical error function: 

2 2 

e = E{ ( f −fˆ) 

} 

where E is the expected value operator, and f is the undegraded 

image. 

i Th The solution l ti (i (in 

th the frequency f domain) d i ) is: i 

⎡ 2 

ˆ 

1 | Huv ( , )| ⎤ 

Fuv ( , ) = ⎢ ( , ) 

2 

⎥ Guv 

⎢⎣Huv ( , ) | Huv ( , )| + Sη( uv , )/ Sf( uv , ) ⎥⎦ 

where: 

Huv ( , ) is the degradation function 

2 

Sη( u, v) = | N( u, v) 

| is the power spectrum of the noise 

2 

Sf 

( uv , ) = | Fuv ( , ) | is the power spectrum of the undegraded image 

S ( u, v) / S ( u, v ) is called the noise - to - signal power ratio 

η 

f 

Degraded Image Creation 

(a) f = checkerboard(8); % 8 x 

8 image of class double 

(b) PSF = fspecial(‘motion’, 7, 

45); % spatial filter 

gb = imfilter(f, PSF, 

‘circular’); 

(c) Gaussian noise image with 

mean 0 and variance 0.001 

noise = 

imnoise2(‘Gaussian’, 

size(f,1), size(f,2), 0, 

sqrt(0.001)); 

(d) g = gb + noise; 


• Method 2 – Direct Inverse Filter with Noise Term 

– include noise term 

– form estimate of the form: 

ˆ Nuv ( , ) 

Fuv ( , ) = Fuv ( , ) + 

Huv ( , ) 

– shows that even if we knew H(u,v) exactly we could 

not recover F(u,v) exactly because the noise 

component is a random function whose FT, N(u,v), is 

not known. 

– typical approach is to use Method 1 in limited 

frequency range 


i Wiener filtering solution (simplified) 

i Compute average noise and image power, i.e., 

1 

η A = ∑∑Sη( 

u, v) 

MN u v 

1 

f fA = ∑∑ S Sf ( u u, v ) 

MN u v 

i Compute ratio: 

ηA 

R = 

fA 

i Utilize constant R in place of function Sη( u, v) 

/ Sf( u, v) 

for simple approximation to ideal Wiener filter (called 

parametric Wiener filter) 

2010-08-26 

7

MATLAB Implementation of 

Wiener Filter 

• MATLAB Code: g is degraded image, frest is the 

restored image, 3 possible implementations 

frest = deconvwnr(g, PSF); 

• assumes noise-to-signal ratio is zero; result same as 

inverse filter 

frest = deconvwnr(g, PSF, NSPR); 

• assumes noise-to-signal ratio is known, either as a 

constant or as an array 

frest = deconvwnr(f, PSF, NACORR, FACORR); 

• assumes that the autocorrelation functions, NACORR 

and FACORR of the noise and the undegraded image 

are known 

Beyond Wiener Filtering 

• Previous example assumed that the original image and 

noise functions were known 

– hence we were able to estimate the correct parameters 

– result in part (d) is that best that can be accomplished with 

Wiener deconvolution in this case 

– challenge, in practice, is to choose appropriate functions for the 

blur and noise when these quantities are not known apriori. 

• Other solutions: 

– constrained least squares filtering 

– iterative nonlinear restoration using the Lucy- 

Richardson algorithm 

– blind deconvolution 

– image reconstruction from projections 

Wiener Filtering 

Summary 

(b) frest1 = deconvwnr(g, PSF); % noise 

dominates image 

(c) computed ratio R as: 

Sn = abs(fft2(noise)).^2; noise power spectrum 

nA = sum(Sn(:))/numel(noise); % noise 

average power 

Sf = abs(fft2(f)).^2; % image power spectrum 

fA = sum(Sf(:))/numel(f); % image average 

power 

R = nAfA; 

frest2 = deconvwnr(g, PSF, R); 

(d) use autocorrelations: 

NCORR = fftshift(real(ifft2(Sn))); 

ICORR = fftshift(real(ifft2(Sf))); 

frest3 = deconvwnr(g, PSF, NCORR, ICORR); 

• Methods of Image Restoration 

– model degradation (assuming apriori knowledge of degradation filter, H, and noise statistics, η) 

– apply inverse process to degradation 

• Noise Models 

– spatial/frequency domain models 

– use MATLAB routine imnoise to add noise to image; Gaussian, salt & pepper, speckle, 

Poisson, etc. 

• Generate Noise with Specified PDF or CDF 

– use MATLAB routine imnoise2 

• Estimate Noise Statistics 

– use MATLAB routine statmoments 

– use regions of interest for better estimates 

• Noise Only Restoration 

– use linear, median, min, max spatial filters 

– use adaptive spatial filters for better estimates 

• Image Blur With Noise 

– direct inverse filtering methods 

– Wiener filtering method 

– alternative approaches 

2010-08-26 

8

Digital Signal Processing Design Image Restoration Image ...

Create successful ePaper yourself

Delete template?

Save as template?