Bilinear interpolation in Python

Question

I'm trying to evaluate the quality of image provided by implementing nearest neighbour and bi-linear interpolation to resize an image. Currently the two images look identical. I cannot seem to find out the reason for the bi-linear method not providing the smooth output picture it should. Below is nearest neighbour

def scale_image_NN(image, scaling_factor):
    cv2.imshow('Original image', lena)
    cv2.waitKey(0)
    print 'Running'
    size = np.shape(image)
    scaled_image = np.zeros((size[0]*scaling_factor, size[1]*scaling_factor,3), dtype=np.uint32)
    for i in range (0, scaling_factor*size[0]-3):
         for j in range (0, scaling_factor*size[1]-3):
              x = int(m.floor(i/scaling_factor))
              y = int(m.floor(j/scaling_factor))
                   for k in range (0, 3):
                      scaled_image[i+1, j+1, k] = image[x+1, y+1, k]

    cv2.imshow('Scaled image - NN', scaled_image)
    cv2.waitKey(0)
cv2.imwrite('NN.jpg',scaled_image)

and subsequently bi-linear interpolation

def scale_image_BL(image, scaling_factor):
    cv2.imshow('Original image', lena)
    cv2.waitKey(0)
    print 'Running'
    orig_size = np.shape(image)
    h = orig_size[0]
    w = orig_size[1]
    c = orig_size[2]
    r = scaling_factor 
    padded_image = np.zeros((h*scaling_factor, w*scaling_factor, c), dtype=np.uint8)

    for i in range (0, h*scaling_factor):
        x1 = int(m.floor(i/r))
        x2 = int(m.ceil(i/r))
        if x1 == 0:
            x1 = 1
       x = np.remainder(i/r,1)
       for j in range (0, w*scaling_factor):
            y1 = int(m.floor(j/r))
            y2 = int(m.ceil(j/r))
            if y1 == 0:
                y1 = 1
            ctl = image[x1, y1, :]
            cbl = image[x2, y1, :]
            ctr = image[x1, y2, :]
            cbr = image[x2, y2, :]      

            y = np.remainder(j/r, 1)
            tr = (ctr*y) + (ctl*(1-y))  
            br = (ctr*y) + (cbl*(1-y))
            padded_image[i, j, :] = (br*x)+(tr*(1-x))

    scaledImage = padded_image.astype(np.uint8)
    cv2.imshow('Scaled image - BL',scaledImage)
    cv2.waitKey(0)
    cv2.imwrite('BL.jpg',scaledImage)

score 0 · Accepted Answer · answered Aug 06 '17 at 18:58

The problem was due Why does Python return 0 for simple division calculation?

During the calculation of the two positions to interpolate between, say x1 or x2 in the bi-linear interpolation, python was returing 0 for simple division such as 1/2, and not 0.5, thus there weren't always two points to interpolate between resulting in the NN-type output.

For scale_image_BL(image, scaling_factor) to work, simply include :

from future import division

at the beginning of the script.

Bilinear interpolation in Python

1 Answers1