Legacy Documentation

Digital Image Processing (2000)

This is documentation for an obsolete product.
Current products and services
User's Guide / Geometric Operations /
Previous section-----Next section

4.2 Interpolation and Decimation

Interpolation and decimation are, respectively, operations used to magnify and reduce sampled signals, usually by an integer factor. Magnification of a sampled signal requires that new values, not present in the signal, be computed and inserted between the existing samples. The new value is estimated from a neighborhood of the samples of the original signal. Similarly, in decimation a new value is calculated from a neighborhood of samples and replaces these values in the minimized image. Integer factor interpolation and decimation algorithms may be implemented using efficient FIR filters and are therefore relatively fast. Alternatively, zooming by noninteger factors typically uses polynomial interpolation techniques resulting in somewhat slower algorithms.
The simplest zooming algorithms use replication to increase the size of an array. This is called nearest-neighbor or zero-order-hold interpolation. For example, in nearest-neighbor interpolation of the array given below, sample a is simply replicated to give rise to a new row and column.
    (
ab
c
) (
aab
aab
cc
)
This technique, although computationally simple, may result in objectionable and highly visible edge artifacts and unnatural blockiness in the image, especially at higher magnification factors.
Replicate[img]inserts copy of the nearest neighbor at each level of img
Replicate[img, k]returns img with k-
Replicate[img, {k1, k2, ...}]
threads ki-1 img at level i

Replicate function.

This loads the package.
In[1]:=
Here we increase the size of a list by replication.
In[2]:=
Out[2]//MatrixForm=Out[2]//MatrixForm=

Interpolate, Decimate, and Resize functions.

Functions Interpolate and Decimate change the dimensions by integer factors. Interpolation of order 2 doubles the size of a 1D array and quadruples the size of an image. A new value is inserted between every pair of elements. Linear filtering is used to calculate the new value. Here is an example of using a simple two-point linear interpolator.
    
Linear interpolation generally gives satisfactory results with a minimum of computational overhead and is therefore the default choice. The default filter has the form
where k is the magnification or minification factor. Here we show the result of interpolating a 3 × 3 array of integers.
In[3]:=
Out[3]//MatrixForm=Out[3]//MatrixForm=
If desired, higher order and larger filters may be used to achieve a desired level of smoothing. Although in principle any smoothing filter may be used, special Nyquist filters are recommended.
It is sometimes necessary to resize an array by a noninteger factor, for example by specifying some arbitrary desired dimensions. This may be conveniently accomplished with the function Resize. Resize uses the built-in function ListInterpolation (and accepts the same options) to return a result of any dimensions. Note that this operation may alter the aspect ratio of the image.
In[4]:=
Out[4]//MatrixForm=Out[4]//MatrixForm=
Downsampling and upsampling are basic sample rate conversion functions. Downsampling of image img by a factor k decreases the image dimensions by retaining every kth row and column of img. Upsampling of image img by a factor k is an operation of threading k rows and columns of zeros into img. Functions UpSample and DownSample operate on ImageData expressions and lists of any dimensions. Integer factor interpolation is implemented as an upsample operation followed by linear filtering, while decimation is a linear filtering followed by downsampling [Pro96].
DownSample[img]returns
DownSample[img, k]returns
DownSample[img, {k1, k2, ...}]returns every kith element at level i of img
UpSample[img]inserts
UpSample[img, k]inserts
UpSample[img, {k1, k2, ...}] threads ki-1 zero elements at level i of img

DownSample and UpSample functions.

Here we downsample a list.
In[5]:=
Out[5]=Out[5]=
Here we upsample the last result.
In[6]:=
Out[6]=Out[6]=
This demonstrates the operations of replication, bilinear interpolation, and interpolation with a third-order Nyquist filter h on a fragment of an example image. We read the example image, select a 100 × 100 subregion, and downsample by a factor of 2.
In[7]:=
This gives a visual, qualitative comparison of the three interpolation methods. The original is in the upper-left corner of the array of images.
In[8]:=
Out[8]=Out[8]=
Here we show the original image and respective interpolation errors.
In[9]:=
Out[9]=Out[9]=