图像数字化——Python实现双线性插值和双三次插值(不调用库函数)

图像插值：改变图像空间分辨率（放大和缩小），实现双线性插值和双三次插值

图像插值是图像处理中的重要技术，主要用于在图像缩放时确定新图像中的像素值。图像缩放可以是放大（提高分辨率）或缩小（降低分辨率），在此过程中需要根据原始图像的像素进行插值计算。常见的插值方法包括双线性插值和双三次插值，它们有着不同的计算复杂度和图像效果。

一、图像缩放基本原理

图像从原始尺寸 $(W,H)$ 缩放到新尺寸 $(W^{\prime },H^{\prime })$ 时，原图中的每个像素将映射到新图中的位置。为了完成缩放，我们需要根据新的像素位置 $(x^{\prime },y^{\prime })$ 找到对应原图中的浮点坐标 $(x,y)$，通过这个映射关系确定新像素的值。

原图的宽度为 $W$，高度为 $H$，缩放后的新图像宽度为 $W^{\prime }$，高度为 $H^{\prime }$。每个新图像的像素位置 $(x^{\prime },y^{\prime })$ 对应原图的像素位置 $(x,y)$，根据缩放比例，公式如下：
$$\begin{gathered} x=x^{\prime }\times \frac{W}{W^{\prime }} \\ y=y^{\prime }\times \frac{H}{H^{\prime }} \end{gathered}$$
此公式表明，在缩放过程中，我们通过比例因子来映射原图像素到新图像上。

二、双线性插值（Bilinear Interpolation）

1. 核心思想：
   双线性插值是一种简单的插值方法，通过对新图像中每个像素的值进行加权平均，从周围四个邻域像素中推算出新像素值。它考虑了水平方向和垂直方向的邻近像素，适用于较为简单的缩放需求。

2. 数学步骤：

   • 假设我们已经确定了新图像中一个像素 $(x^{\prime },y^{\prime })$，其对应的原图中的浮点坐标为 $(x,y)$，我们需要从原图中找到四个邻近像素来进行加权计算。

   • 这些邻域点分别是：
     $$\{\begin{array}{l}(x_1,y_1)=(\lfloor x\rfloor ,\lfloor y\rfloor )\\ (x_2,y_1)=(\lfloor x\rfloor +1,\lfloor y\rfloor )\\ (x_1,y_2)=(\lfloor x\rfloor ,\lfloor y\rfloor +1)\\ (x_2,y_2)=(\lfloor x\rfloor +1,\lfloor y\rfloor +1)\end{array}$$

     其中，$\lfloor x\rfloor$ 和 $\lfloor y\rfloor$ 分别表示向下取整得到的坐标。通过这些四个点，我们可以计算出新像素的值。

   • 接下来，我们需要计算水平和垂直的权重值，这两个权重决定了各个邻近像素对最终插值结果的影响：
     $$\begin{gathered} \alpha =x-x_1(\text{水平偏移量}) \\ \beta =y-y_1(\text{垂直偏移量}) \end{gathered}$$

   • 最终的插值结果通过以下公式计算：
     $$\begin{gathered} I(x,y)=(1-\alpha )(1-\beta )I(x_1,y_1)+\alpha (1-\beta )I(x_2,y_1) \\ +(1-\alpha )\beta I(x_1,y_2)+\alpha \beta I(x_2,y_2) \end{gathered}$$

     其中 $I(x_1,y_1)$, $I(x_2,y_1)$, $I(x_1,y_2)$, $I(x_2,y_2)$ 是四个邻近像素的值，$\alpha$ 和 $\beta$ 分别是水平和垂直的权重。

3. 特性分析：

   • 计算复杂度：$O(4WH)$ 次加权运算。每个像素的值需要从周围四个邻近像素进行加权计算，因此计算量相对较小。
   • 效果：双线性插值能够产生平滑过渡的图像，适合一些对图像质量要求不高的应用，但可能会产生边缘模糊的现象。

三、双三次插值（Bicubic Interpolation）

1. 核心思想：
   双三次插值相比双线性插值，采用了更多的邻域像素进行插值计算，具体是16个邻域像素。它基于三次多项式对邻域像素进行加权，可以保留更多的图像细节，生成更加平滑的图像。

2. 权重函数（Key公式）：
   双三次插值的权重函数基于一个分段的三次多项式：
   $$W(d)=\{\begin{array}{ll}(a+2)|d{|}^3-(a+3)|d{|}^2+1& \text{当 }|d|\le 1\\ a|d{|}^3-5a|d{|}^2+8a|d|-4a& \text{当 }1<|d|<2\\ 0& \text{其他}\end{array}$$
   其中 $a=-0.5$ 是常用的参数。这个权重函数定义了在不同距离 $d$ 上，邻域像素的加权方式。它会根据像素的距离来调整每个邻域像素的影响程度。

3. 计算步骤：

   • 对于目标像素 $(x^{\prime },y^{\prime })$，我们首先计算其对应的原图坐标 $(x,y)$。然后，选择距离该坐标最近的16个邻域像素，定义为 $(x_i,y_j)$，其中 $x_i=\lfloor x\rfloor -1+i$，$y_j=\lfloor y\rfloor -1+j$，$i,j\in \{0,1,2,3\}$。

   • 对于每个邻域像素，应用权重函数 $W(x-x_i)$ 和 $W(y-y_j)$ 对其进行加权。最终，像素值的计算公式为：
     $$I(x,y)=\sum _{i=0}^3\sum _{j=0}^{3}I(x_i,y_j)\cdot W(x-x_i)\cdot W(y-y_j)$$

   • 需要进行归一化处理：
     $$I_{final}=\frac{I(x,y)}{\sum W(x-x_i)W(y-y_j)}$$

     这个归一化步骤确保了加权和不超过1，从而保证了插值结果的准确性。

4. 特性分析：

   • 计算复杂度：$O(16WH)$ 次加权运算。由于使用了16个邻域像素，计算量比双线性插值要大得多。
   • 效果：双三次插值能更好地保留图像的细节，尤其是在放大图像时，能够有效减少锯齿和模糊现象。但它也可能引入一些“振铃效应”（Ringings），即在图像边缘附近出现不自然的波纹。

四、关键参数说明

1. 缩放因子：
   缩放因子决定了图像是放大还是缩小。在放大的情况下，$\frac{W}{W^{\prime }}<1$，而在缩小时，$\frac{W}{W^{\prime }}>1$。在代码实现中，可以通过 x_ratio = w / new_width 来获取缩放因子，进而对图像进行缩放。

2. 边界处理：
   当计算邻域像素时，有可能会出现像素索引超出图像边界的情况。因此，在处理坐标时需要确保像素位置不越界。通常通过以下公式来限制坐标范围：
   $$x_i=\max (0,\min (w-1,x_i))$$

3. 颜色通道：
   每个像素可能包含多个颜色通道（如RGB三个通道），插值需要对每个通道独立进行计算。对于每个颜色通道，可以分别应用双线性或双三次插值算法进行插值：
   $$I_{channel}=f(I_{red},I_{green},I_{blue})$$

五、算法对比

特性	双线性插值	双三次插值
邻域范围	$2\times 2$	$4\times 4$
计算量	$O(4n)$	$O(16n)$
边缘保持	中等	较好
计算速度	快	慢
适用场景	实时处理	高质量缩放

六、实现注意事项

1. 坐标映射：
   新图像的坐标 $(x^{\prime },y^{\prime })$ 到原图坐标 $(x,y)$ 的映射需要注意对齐。坐标转换的公式如下：
   $$x=(x^{\prime }+0.5)\frac{W}{W^{\prime }}-0.5$$

2. 数据类型：
   在插值计算过程中，为了避免精度损失，通常使用浮点型数据进行计算。最终的图像结果需要将浮点型数据转换为 uint8 类型（0到255的整数），以适应标准图像格式。

3. 优化技巧：

   • 可以通过预计算权重表（Lookup Table, LUT）来提高插值计算的效率，避免重复计算相同的权重值。
   • 采用分离式计算方法（例如，先在水平方向进行插值，再在垂直方向进行插值）可以减少计算量，提高速度。

通过合理选择插值方法和优化策略，图像缩放过程可以在保证质量的前提下，提升计算效率。

七、代码实现

下面是图像插值实现代码，分块讲解：

---

1. 导入必要的库

import numpy as np
from PIL import Image
from IPython.display import display

• numpy: 用于处理图像数据和进行数学计算。
• PIL: Python Imaging Library，用于加载和处理图像。
• IPython.display: 用于在 Jupyter Notebook 中显示图像。

---

2. 基础图像处理函数

2.1 加载图像

def load_image(path):
    """加载测试图像"""
    img = Image.open(path)
    return np.array(img)

• load_image 函数用于加载指定路径的图像。通过 PIL.Image.open 打开图像文件，然后将其转换为 numpy 数组（np.array(img)），便于后续处理。

2.2 显示图像

def show_image(img, title="", scale=1):
    """显示图像（修正后的版本）"""
    if isinstance(img, np.ndarray):
        img = Image.fromarray(img)
    
    if scale != 1:
        w, h = img.size
        img = img.resize((int(w*scale), int(h*scale)))
    
    display(img.convert('RGB'))

• show_image 函数用于显示图像。首先检查图像是否为 numpy 数组，如果是，则将其转换为 PIL 图像。可以选择通过 scale 参数调整图像的显示大小，并最终通过 display() 函数在 Jupyter 中显示图像。

---

3. 插值核心算法

3.1 双线性插值

def bilinear_interpolation(image, new_height, new_width):
    """双线性插值实现"""
    h, w = image.shape[:2]
    resized = np.zeros((new_height, new_width, 3), dtype=np.uint8)
    
    x_ratio = w / new_width
    y_ratio = h / new_height
    
    for y in range(new_height):
        for x in range(new_width):
            # 计算在原图中的位置
            x_orig = x * x_ratio
            y_orig = y * y_ratio
            
            # 获取四个邻近点
            x1 = int(x_orig)
            y1 = int(y_orig)
            x2 = min(x1 + 1, w - 1)
            y2 = min(y1 + 1, h - 1)
            
            # 计算权重
            dx = x_orig - x1
            dy = y_orig - y1
            
            # 对每个通道进行插值
            for c in range(3):
                val = (1-dx)*(1-dy)*image[y1,x1,c] + dx*(1-dy)*image[y1,x2,c] + \
                      (1-dx)*dy*image[y2,x1,c] + dx*dy*image[y2,x2,c]
                resized[y,x,c] = int(round(val))
    
    return resized

• 双线性插值：该方法通过计算目标像素位置在原图像中相邻四个像素的加权平均值来估算新像素值。
  • x_ratio 和 y_ratio 用于计算每个目标像素相对原图的比例。
  • 对于每个目标像素 (x, y)，我们计算它在原图中的位置 (x_orig, y_orig)。
  • 获取四个邻近的像素点，计算它们的加权值，并根据这四个像素的值来估算目标像素的值。
  • 该过程对 RGB 三个通道分别进行。

---

3.2 双三次插值

def cubic_weight(x):
    """双三次插值权重函数"""
    a = -0.5  # 常用参数
    x = abs(x)
    if x <= 1:
        return (a+2)*x**3 - (a+3)*x**2 + 1
    elif x < 2:
        return a*x**3 - 5*a*x**2 + 8*a*x - 4*a
    else:
        return 0

def bicubic_interpolation(image, new_height, new_width):
    """双三次插值实现"""
    h, w = image.shape[:2]
    resized = np.zeros((new_height, new_width, 3), dtype=np.uint8)
    
    x_ratio = w / new_width
    y_ratio = h / new_height
    
    for y in range(new_height):
        for x in range(new_width):
            x_orig = x * x_ratio
            y_orig = y * y_ratio
            
            x0 = int(x_orig) - 1
            y0 = int(y_orig) - 1
            
            # 初始化累加器和权重和
            pixel = np.zeros(3)
            total_weight = 0
            
            # 遍历16个邻近点
            for m in range(4):
                for n in range(4):
                    xi = min(max(x0 + n, 0), w - 1)
                    yi = min(max(y0 + m, 0), h - 1)
                    
                    # 计算权重
                    dx = x_orig - (x0 + n)
                    dy = y_orig - (y0 + m)
                    wx = cubic_weight(dx)
                    wy = cubic_weight(dy)
                    weight = wx * wy
                    
                    # 累加
                    pixel += image[yi, xi] * weight
                    total_weight += weight
            
            # 归一化
            if total_weight > 0:
                pixel /= total_weight
            resized[y, x] = np.clip(pixel, 0, 255)
    
    return resized

• 双三次插值：该方法通过对目标像素的周围 16 个像素应用加权平均值来估算新像素值。它比双线性插值更加平滑，能更好地处理图像细节。
  • cubic_weight 函数计算权重，使用了一个常见的双三次插值函数。
  • 每个目标像素的值通过对周围 16 个像素点应用加权和得到，计算过程考虑了像素与目标位置的距离。
  • 归一化所有的权重和像素值，确保最终计算结果在合适的范围内。

---

4. 测试代码

# 加载测试图像
try:
    test_img = load_image("imori.jpg")
    print("原始图像 (256x256):")
    show_image(test_img)

    # 放大图像 (512x512)
    print("\n双线性插值放大结果:")
    bilinear_img = bilinear_interpolation(test_img, 512, 512)
    show_image(bilinear_img)

    print("\n双三次插值放大结果:")
    bicubic_img = bicubic_interpolation(test_img, 512, 512)
    show_image(bicubic_img)

    # 缩小图像 (128x128)
    print("\n双线性插值缩小结果:")
    bilinear_small = bilinear_interpolation(test_img, 128, 128)
    show_image(bilinear_small, scale=2)  # 放大显示便于观察

    print("\n双三次插值缩小结果:")
    bicubic_small = bicubic_interpolation(test_img, 128, 128)
    show_image(bicubic_small, scale=2)
    
except FileNotFoundError:
    print("找不到测试图像 'imori.jpg'，请确保图像文件存在")
except Exception as e:
    print(f"发生错误: {str(e)}")

• 加载和显示图像：测试代码首先加载图像，然后使用双线性插值和双三次插值分别对图像进行放大和缩小操作，并显示结果。
• 异常处理：在加载图像和进行插值计算时，使用 try-except 语句来捕获文件未找到的错误和其他异常。

---

测试结果

以下是各图像结果的描述：

1. 原始图像 (256x256):
   这张图像的尺寸为256x256像素，呈现了一个较为清晰且细节丰富的图像。由于其较小的尺寸，图像的每个像素信息较为集中，呈现出较为清晰的边缘和细节。
   

2. 双线性插值放大结果:
   双线性插值通过计算原图中四个邻近像素的加权平均值来插值生成新图像。
   

3. 双三次插值放大结果:
   双三次插值相较于双线性插值，使用了更多的邻近像素（16个像素点）来进行插值，能够保留更多的细节。

4. 双线性插值缩小结果:
   在图像缩小的过程中，双线性插值较为平滑地压缩了图像的细节，图像的边缘较为模糊。
   

5. 双三次插值缩小结果:
   双三次插值在缩小图像时能够更好地保留图像的细节和边缘信息。

八、总结

• 本代码实现了图像的双线性插值和双三次插值，通过这两种常见的插值方法，可以在不使用 OpenCV 等高级库的情况下，对图像进行大小变化操作。
• 双线性插值相对简单，适合快速处理，适用于大部分一般图像放大或缩小的情况。
• 双三次插值则能更好地保留图像的细节和质量，但计算量较大，适合需要更高质量图像缩放的应用。