Image Interpolation in MATLAB: Implementing Bilinear and Bicubic Interpolation

# 2.1 Bilinear Interpolation Principle

Bilinear interpolation is an image interpolation algorithm that estimates the value of a target pixel by using the values of four neighboring pixels in the source image. This algorithm assumes that pixel values change linearly in two directions (horizontal and vertical).

Specifically, the bilinear interpolation algorithm uses the following formula to calculate the value of the target pixel:

P(x, y) = (1 - α)(1 - β)P(x0, y0) + (1 - α)βP(x0, y1) + α(1 - β)P(x1, y0) + αβP(x1, y1)

Where:

* P(x, y) is the value of the target pixel
* P(x0, y0), P(x0, y1), P(x1, y0), P(x1, y1) are the values of the four adjacent pixels surrounding the target pixel
* α = (x - x0) / (x1 - x0)
* β = (y - y0) / (y1 - y0)

This formula represents the value of the target pixel as a weighted average of the four adjacent pixel values, where the weights are determined by the distance between the target pixel and the adjacent pixels.

# 2. Bilinear Interpolation Algorithm

### 2.1 Bilinear Interpolation Principle

Bilinear interpolation is an image interpolation algorithm used for enlarging or reducing the size of an image. It is a simple yet effective algorithm that produces smooth interpolation results.

The basic principle of bilinear interpolation is to use the grayscale values of four surrounding pixels for a target pixel in an image for a weighted average. The weighting coefficients are determined by the distance between the target pixel and the adjacent pixels.

Let the coordinates of the target pixel be (x, y), and the coordinates of its four adjacent pixels be (x1, y1), (x2, y1), (x1, y2), and (x2, y2), respectively. Their grayscale values are f(x1, y1), f(x2, y1), f(x1, y2), and f(x2, y2).

Then the interpolated grayscale value f(x, y) of the target pixel is calculated using the following formula:

f(x, y) = (1 - α)(1 - β)f(x1, y1) + (1 - α)βf(x2, y1) + α(1 - β)f(x1, y2) + αβf(x2, y2)

Where α and β are the weighting coefficients, calculated as follows:

α = (x - x1) / (x2 - x1)
β = (y - y1) / (y2 - y1)

### 2.2 Bilinear Interpolation Algorithm Implementation

The bilinear interpolation algorithm can be implemented through the following steps:

1. **Obtain the coordinates of the target pixel**: Determine the coordinates (x, y) of the pixel to be interpolated.
2. **Obtain the coordinates and grayscale values of adjacent pixels**: Determine the coordinates and grayscale values of the four adjacent pixels surrounding the target pixel.
3. **Calculate weighting coefficients**: Use the formulas α = (x - x1) / (x2 - x1) and β = (y - y1) / (y2 - y1) to calculate the weighting coefficients α and β.
4. **Calculate the interpolated grayscale value**: Use the formula f(x, y) = (1 - α)(1 - β)f(x1, y1) + (1 - α)βf(x2, y1) + α(1 - β)f(x1, y2) + αβf(x2, y2) to calculate the interpolated grayscale value of the target pixel.

import numpy as np

def bilinear_interpolation(image, x, y):
   """
   Bilinear interpolation algorithm

   Args:
     image: Input image
     x: Target pixel's x coordinate
     y: Target pixel's y coordinate

   Returns:
     Interpolated grayscale value
   """

   # Obtain the coordinates of the target pixel
   x0 = int(x)
   y0 = int(y)

   # Obtain the coordinates and grayscale values of adjacent pixels
   x1 = min(x0 + 1, image.shape[1] - 1)
   y1 = min(y0 + 1, image.shape[0] - 1)
   f00 = image[y0, x0]
   f01 = image[y0, x1]
   f10 = image[y1, x0]
   f11 = image[y1, x1]

   # Calculate weighting coefficients
   alpha = (x - x0) / (x1 - x0)
   beta = (y - y0) / (y1 - y0)

   # Calculate the interpolated grayscale value
   return (1 - alpha) * (1 - beta) * f00 + (1 - alpha) * beta * f01 + alpha * (1 - beta) * f10 + alpha * beta * f11

# 3. Bicubic Interpolation Algorithm