Digital Image Zooming – Sample Codes on MATLAB

Image zooming or image scaling is another basic operation in computer graphics. In this article I am trying to describe how to implement the image zooming or scaling from our own.  Image resize algorithms are try to interpolate the suitable image intensity values for the pixels of resized image which does not directly mapped to its original image. There are three major algorithms for image resizing,

1. Nearest Neighbour Interpolation

2. Bi-linear interpolation

3. Bi-cubic interpolation

You can read more about these methods in Wikipedia and from this web site and also by typing ‘doc imresize’ on MATLAB command prompt which is also the default operation for image resizing. I’ll try to briefly describe what’s going on in the each algorithm and a way to implement it on MATLAB.

Nearest Neighbour Interpolation

In the nearest neighbour algorithm, the intensity value for the point v(x,y is assigned to the nearest neighbouring pixel intensity f(x,y)which is the mapped pixel of the original image. The logic behind the approximation is as the equation below.

Sample code for this implementation is as below.

function imzoom = nnbr(image,zoom);
[r c d] = size(image);      % dimensions of image data
%% zoom
rn = floor(zoom*r);
cn = floor(zoom*c);
s = zoom;
im_zoom = zeros(rn,cn,d);
%% nearest neighbour
for i = 1:rn;
    x = i/s;
    near_i = cast(round(x),'uint16');
if near_i == 0
        near_i = 1;
    end
    for j = 1:cn;
        y = j/s;
near_j = cast(round(y),'uint16');
        if near_j == 0
            near_j = 1;
        end
        im_zoom(i,j,:) = image(near_i,near_j,:);
    end
end
imzoom = im_zoom;

Bilinear Interpolation

In the Bi-linear interpolation, intensity of the zoomed image pixel ‘P’ is defined by the weighted sum of the mapped 4 neighbouring pixels. If the zooming factor is ‘s’, then the mapped pixel point in the original image is given by ‘r’ and ‘c’ as follows.

And the distance from the point of interest to the mapped pixels can be obtain as follows,

So the neighbouring 4 pixels can be defined as,

By using these values we can approximate the intensity of the pixel in interest as follows.

Sample code for this implementation is as below.

function image_zoom = blnrm2(image, zoom)
[r c d] = size(image);
rn = floor(zoom*r);
cn = floor(zoom*c);
s = zoom;
im_zoom = zeros(rn,cn,d);
for i = 1:rn;
    x1 = cast(floor(i/s),'uint32');
    x2 = cast(ceil(i/s),'uint32');
    if x1 == 0
        x1 = 1;
    end
    x = rem(i/s,1);
    for j = 1:cn;
        y1 = cast(floor(j/s),'uint32');
        y2 = cast(ceil(j/s),'uint32');
        if y1 == 0
            y1 = 1;
        end
        ctl = image(x1,y1,:);
        cbl = image(x2,y1,:);
        ctr = image(x1,y2,:);
        cbr = image(x2,y2,:);
        y = rem(j/s,1);
        tr = (ctr*y)+(ctl*(1-y));
        br = (cbr*y)+(cbl*(1-y));
        im_zoom(i,j,:) = (br*x)+(tr*(1-x));
    end
end
image_zoom = cast(im_zoom,'uint8');

Bi-cubic Interpolation

When using the bi-cubic interpolation zoomed image internsity v(x,y) is defined using the weighted sum of mapped 16 neighbouring pixels of the original image. As in above method, let the zooming factor is ‘s’ and the mapped pixel point in the original image is given by ‘r’ and ‘c’. Then the neighbour-hood matrix can be defined as,

Using the bi-cubic algorithm;

The coefficients a_ij can be find using the La-grange equation.

When implementing this algorithm I made a mask for defining a_i and b_j using matrix and then I applied it to the matrix containing the selected 16 points, due to reduce the complexity of the algorithm in-order to reduce the calculation time. Zero padding is added to surround the original image to remove the zero reference error occurred.

Sample code for this implementation is as below.

function im_zoom = bicubic_m2(image,zoom);
[r c d] = size(image);
rn = floor(zoom*r);
cn = floor(zoom*c);
s = zoom;
im_zoom = cast(zeros(rn,cn,d),'uint8');
im_pad = zeros(r+4,c+4,d);
im_pad(2:r+1,2:c+1,:) = image;
im_pad = cast(im_pad,'double');
for m = 1:rn
    x1 = ceil(m/s); x2 = x1+1; x3 = x2+1;
    p = cast(x1,'uint16');
    if(s>1)
       m1 = ceil(s*(x1-1));
       m2 = ceil(s*(x1));
       m3 = ceil(s*(x2));
       m4 = ceil(s*(x3));
    else
       m1 = (s*(x1-1));
       m2 = (s*(x1));
       m3 = (s*(x2));
       m4 = (s*(x3));
    end
    X = [ (m-m2)*(m-m3)*(m-m4)/((m1-m2)*(m1-m3)*(m1-m4)) ...
          (m-m1)*(m-m3)*(m-m4)/((m2-m1)*(m2-m3)*(m2-m4)) ...
          (m-m1)*(m-m2)*(m-m4)/((m3-m1)*(m3-m2)*(m3-m4)) ...
          (m-m1)*(m-m2)*(m-m3)/((m4-m1)*(m4-m2)*(m4-m3))];
    for n = 1:cn
        y1 = ceil(n/s); y2 = y1+1; y3 = y2+1;
        if (s>1)
           n1 = ceil(s*(y1-1));
           n2 = ceil(s*(y1));
           n3 = ceil(s*(y2));
           n4 = ceil(s*(y3));
        else
           n1 = (s*(y1-1));
           n2 = (s*(y1));
           n3 = (s*(y2));
           n4 = (s*(y3));
        end
        Y = [ (n-n2)*(n-n3)*(n-n4)/((n1-n2)*(n1-n3)*(n1-n4));...
              (n-n1)*(n-n3)*(n-n4)/((n2-n1)*(n2-n3)*(n2-n4));...
              (n-n1)*(n-n2)*(n-n4)/((n3-n1)*(n3-n2)*(n3-n4));...
              (n-n1)*(n-n2)*(n-n3)/((n4-n1)*(n4-n2)*(n4-n3))];
        q = cast(y1,'uint16');
        sample = im_pad(p:p+3,q:q+3,:);
        im_zoom(m,n,1) = X*sample(:,:,1)*Y;
        if(d~=1)
              im_zoom(m,n,2) = X*sample(:,:,2)*Y;
              im_zoom(m,n,3) = X*sample(:,:,3)*Y;
        end
    end
end
im_zoom = cast(im_zoom,'uint8');

Results obtained from these three methods are as below.

Original Image Nearest-neighbour x1.6

Bi-linear interpolation x1.6 Bi-cubic interpolation x0.6

Calculation times for each method with zooming factor 1.6 and with 160x120x3 RGB image are as follows.

>> tic;imshow(nnbr(im,2.5));toc

Elapsed time is 1.774069 seconds.

>> tic;imshow(blnr(im,2.5));toc

Elapsed time is 4.052437 seconds.

>> tic;imshow(bicubic_m2(im,2.5));toc

Elapsed time is 3.772757 seconds.