图像金字塔原理与实战：从多尺度分析到OpenCV实现

1. 从“多尺度”说起：为什么我们需要图像金字塔？

如果你处理过图像，无论是做计算机视觉、图像编辑，还是简单的缩放，大概率都听过“图像金字塔”这个词。听起来挺高大上，但它的核心思想其实非常朴素： 用不同的分辨率去看同一张图 。这就像你站在一幅巨大的壁画前，为了看清细节，你得凑近看；为了看清整体布局，你得退远看。图像金字塔就是帮你系统性地完成这个“凑近”和“退远”过程的数学工具。

我第一次真正理解它的威力，是在做一个车牌识别的项目里。当时直接用原始的高清图像去检测车牌，算法要么跑得慢，要么在小车牌上漏检。后来引入了图像金字塔，先在一张缩小的图上快速找到车牌可能存在的区域，再回到原图的对应位置进行精确定位和识别，效果和效率都提升了一个量级。这让我意识到，它绝不是一个课本里的数学玩具，而是解决实际工程问题的利器。

简单来说，图像金字塔通过一系列下采样（缩小）和上采样（放大）操作，生成一组分辨率逐层降低（或升高）的图像集合。最底层是原始的高分辨率图像，越往上走，图像尺寸越小，看起来越“模糊”，但保留的全局信息越强。这个结构之所以叫“金字塔”，就是因为从底到顶，图像尺寸越来越小，堆叠起来就像一个金字塔。

它的应用场景远比你想象的广泛：从最经典的SIFT、ORB特征点检测，到目标检测中的多尺度滑动窗口（比如早期的DPM、HOG检测器），再到图像融合（如拉普拉斯金字塔融合）、超分辨率重建，甚至在现代深度学习的某些预处理或后处理环节中，你都能看到它的身影。理解图像金字塔，是打通传统图像处理和现代视觉算法任督二脉的关键一步。

2. 金字塔的构建基石：高斯与拉普拉斯

图像金字塔主要有两大类： 高斯金字塔 和 拉普拉斯金字塔 。前者是基础，后者是前者的“微分”形式，蕴含了更多的细节信息。要搞懂它们，得先理解两个核心操作：高斯模糊和下采样。

2.1 高斯模糊：不是简单的平均

下采样前为什么一定要先模糊？这是新手最容易忽略的关键。想象一下，你有一张画满密集细线的图。如果你直接每隔一个像素扔掉一个像素（最简单的下采样），那些高频的细线可能会因为采样点错过线条而产生严重的“摩尔纹”或“混叠”效应，导致下采样后的图像出现原本不存在的奇怪图案。

高斯模糊的目的就是充当一个“低通滤波器”，平滑掉这些高频细节，只保留图像中变化平缓的低频信息。这样在下采样时，就不会有高频信号“混”进来捣乱了。高斯模糊不是简单的均值滤波，它用一个二维的高斯函数（钟形曲线）作为权重核，对图像进行卷积。离中心像素越近的像素，权重越大，这使得平滑效果更自然，能更好地保持边缘过渡。

一个常见的5x5高斯核可能长这样（数值已归一化）：

[[1,  4,  6,  4, 1],
 [4, 16, 24, 16, 4],
 [6, 24, 36, 24, 6],
 [4, 16, 24, 16, 4],
 [1,  4,  6,  4, 1]] / 256

在实际构建金字塔时，OpenCV等库通常会使用一个小的、可分离的高斯核（如5x5）进行迭代卷积，而不是直接用一个巨大的核，这样效率更高。

2.2 高斯金字塔的构建：迭代的“缩小”过程

高斯金字塔的构建是一个迭代过程，分为两个方向：

1. 向下采样（构建金字塔） ：从第i层（记为 G_i ）生成第i+1层（ G_{i+1} ）。

   • 步骤1：高斯模糊 。对 G_i 进行高斯模糊（使用上述高斯核卷积），得到模糊后的图像 Blur(G_i) 。这一步是为了抗混叠。
   • 步骤2：降采样 。将 Blur(G_i) 的尺寸缩小为原来的一半（通常长宽各减半）。最简单的做法是直接隔行隔列采样。这样得到的图像就是 G_{i+1} 。
   • 重复这个过程，直到图像尺寸小到无法继续（比如小于某个阈值，如4x4像素）。

2. 向上采样（重建过程） ：这是向下采样的逆过程，用于从高层图像 G_{i+1} 近似重建低层图像 G_i 。

   • 步骤1：上采样 。将 G_{i+1} 的尺寸放大一倍（长宽各乘2）。新增的像素位置通常先填充0（零值）。
   • 步骤2：高斯模糊 。对放大后的图像再次进行高斯模糊（通常使用与向下采样时相同或相似的高斯核）。这一步是为了插值，使图像变得平滑，填补上采样引入的“空洞”。

需要注意的是，向上采样再模糊得到的图像，并不是原始的 G_i ，而是一个丢失了高频细节的、模糊化的 G_i ，我们称之为 Expand(G_{i+1}) 。高频细节去哪了？这就引出了拉普拉斯金字塔。

2.3 拉普拉斯金字塔：存储“丢失的细节”

拉普拉斯金字塔不是独立构建的，它直接来源于高斯金字塔。它的每一层，定义为当前层的高斯图像与上一层高斯图像经上采样重建后的差值： L_i = G_i - Expand(G_{i+1})

这里的 L_i 就是第i层的拉普拉斯图像。因为 Expand(G_{i+1}) 是 G_i 的低频近似，所以它们的差值 L_i 捕捉的正是 G_i 中那些被高斯平滑和下采样过程“丢掉”的 高频边缘和纹理细节 。你可以把拉普拉斯金字塔的每一层看作是一张“残差图”或“细节图”。

拉普拉斯金字塔的精妙之处在于它的 无损性 （在理想的无损计算下）。因为： G_i = L_i + Expand(G_{i+1}) 通过这个公式，我们可以从金字塔顶层的那个最小的高斯图像 G_top 开始，结合每一层的拉普拉斯细节 L_i ，逐层向上，完美地重建出原始图像 G_0 。这为图像压缩和多分辨率编辑提供了理论基础。

注意 ：在实际的数值计算（特别是使用8位无符号整型 uint8 ）时，做减法 G_i - Expand(G_{i+1}) 可能会产生负值。因此，通常会将拉普拉斯金字塔的像素值存储为有符号整型（如 int16 ），或者先进行偏移（如加128）再存储为 uint8 ，在重建时再减回去。这是实现时的一个小坑。

3. 手把手实现：用OpenCV和NumPy构建你的金字塔

理论说再多，不如动手写一遍。这里我用Python和OpenCV带你完整实现高斯和拉普拉斯金字塔，并解释每一步的意图。

3.1 环境准备与基础函数

首先，确保你安装了必要的库。我们主要用 OpenCV 和 NumPy 。

import cv2
import numpy as np
import matplotlib.pyplot as plt

def display_images(images, titles, rows, cols):
    """一个简单的多图显示函数"""
    fig, axes = plt.subplots(rows, cols, figsize=(15, rows*3))
    axes = axes.flatten()
    for ax, img, title in zip(axes, images, titles):
        if len(img.shape) == 2: # 灰度图
            ax.imshow(img, cmap='gray')
        else: # 彩色图
            # OpenCV默认是BGR，matplotlib显示需要转为RGB
            img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
            ax.imshow(img_rgb)
        ax.set_title(title)
        ax.axis('off')
    plt.tight_layout()
    plt.show()

3.2 实现高斯金字塔

OpenCV提供了现成的函数 cv2.pyrDown() 和 cv2.pyrUp() ，但为了理解原理，我们先自己实现一个简化版。

def my_gaussian_blur(image, ksize=5, sigma=1.0):
    """手动实现一个简单的高斯模糊（效率较低，仅用于教学）"""
    # 生成一维高斯核
    kernel_1d = cv2.getGaussianKernel(ksize, sigma)
    # 通过外积得到二维可分核
    kernel_2d = kernel_1d * kernel_1d.T
    # 应用卷积
    blurred = cv2.filter2D(image, -1, kernel_2d, borderType=cv2.BORDER_REFLECT)
    return blurred

def my_pyr_down(image):
    """向下采样一层：先高斯模糊，再隔点采样"""
    # 1. 高斯模糊 (抗混叠)
    blurred = my_gaussian_blur(image)
    # 2. 降采样：取所有偶数行和偶数列
    downsampled = blurred[::2, ::2]
    return downsampled

def my_pyr_up(image):
    """向上采样一层：先插零，再高斯模糊（模拟插值）"""
    h, w = image.shape[:2]
    # 1. 创建两倍大小的空矩阵，并在偶数位置填充原图像素
    upsampled = np.zeros((h*2, w*2) + image.shape[2:], dtype=image.dtype)
    upsampled[::2, ::2] = image
    # 2. 高斯模糊进行插值。注意：这里模糊的强度需要调整，以匹配pyrDown的效果。
    # 通常，上采样时的高斯核权重应是下采样时的4倍（因为像素数变为4倍？），
    # 但更常见的做法是直接用相同的核进行卷积，然后乘以4（对于8位图要小心溢出）。
    # 这里我们使用一个简单的5x5高斯核，并乘以4。
    kernel = cv2.getGaussianKernel(5, 1) * 2 # 乘以2是为了近似补偿
    kernel_2d = kernel * kernel.T
    upsampled = cv2.filter2D(upsampled, -1, kernel_2d, borderType=cv2.BORDER_REFLECT)
    # 由于我们插零后模糊，能量（像素值总和）会损失，乘以4是一个常见的近似补偿。
    # 但对于严格的拉普拉斯金字塔重建，这个因子必须与pyrDown的核精确匹配。
    return upsampled

def build_gaussian_pyramid_opencv(image, levels):
    """使用OpenCV内置函数构建高斯金字塔（推荐，更稳定高效）"""
    pyramid = [image]
    for i in range(levels-1):
        pyramid.append(cv2.pyrDown(pyramid[-1])) # 对列表最后一张图进行下采样
    return pyramid

# 读取一张示例图像
img = cv2.imread('your_image.jpg') # 请替换为你的图片路径
if img is None:
    # 如果没图片，创建一个简单的测试图
    img = np.zeros((256, 256, 3), dtype=np.uint8)
    cv2.rectangle(img, (50, 50), (150, 150), (0, 255, 0), -1)
    cv2.circle(img, (200, 100), 30, (0, 0, 255), -1)

gray_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) # 为简化，我们用灰度图演示

# 构建4层高斯金字塔
gaussian_pyramid = build_gaussian_pyramid_opencv(gray_img, 4)

# 显示
display_images(gaussian_pyramid,
               [f'Gaussian Level {i}: {gaussian_pyramid[i].shape}' for i in range(len(gaussian_pyramid))],
               rows=1, cols=4)

运行这段代码，你会看到图像尺寸逐层减半（例如 256x256 -> 128x128 -> 64x64 -> 32x32），图像内容也越来越模糊，但大致的形状和结构依然清晰可辨。

3.3 实现拉普拉斯金字塔

拉普拉斯金字塔需要高斯金字塔作为输入。

def build_laplacian_pyramid(gaussian_pyramid):
    """根据高斯金字塔构建拉普拉斯金字塔"""
    laplacian_pyramid = []
    num_levels = len(gaussian_pyramid)
    
    for i in range(num_levels - 1):
        # 获取当前层 Gi 和上一层 Gi+1
        gi = gaussian_pyramid[i]
        gi_plus1 = gaussian_pyramid[i + 1]
        
        # 将 Gi+1 上采样，使其尺寸与 Gi 相同
        # 注意：cv2.pyrUp 的尺寸是 2倍，所以需要指定目标尺寸为 gi 的尺寸
        # 但更标准的做法是：pyrUp(gi_plus1) 的尺寸应该是 gi_plus1*2，这不一定等于 gi。
        # 实际上，由于下采样可能舍入，gi 的尺寸可能是奇数，pyrUp后尺寸可能差1。
        # 因此，我们需要调整尺寸。
        upsampled = cv2.pyrUp(gi_plus1, dstsize=(gi.shape[1], gi.shape[0]))
        
        # 计算拉普拉斯层：Li = Gi - upsampled(Gi+1)
        # 注意：图像是 uint8，相减可能产生负数，需要转为有符号类型
        laplacian = cv2.subtract(gi.astype(np.int16), upsampled.astype(np.int16))
        # 或者，为了显示，可以将其缩放到0-255范围
        # laplacian_display = cv2.normalize(laplacian, None, 0, 255, cv2.NORM_MINMAX, dtype=cv2.CV_8U)
        
        laplacian_pyramid.append(laplacian)
    
    # 金字塔的顶层（最小那张高斯图）没有上一层可以减，通常直接作为拉普拉斯金字塔的顶层
    # 但严格来说，拉普拉斯金字塔顶层就是高斯金字塔顶层，因为它是低频信息的最终保留地。
    laplacian_pyramid.append(gaussian_pyramid[-1].astype(np.int16))
    
    return laplacian_pyramid

# 构建拉普拉斯金字塔
laplacian_pyramid = build_laplacian_pyramid(gaussian_pyramid)

# 准备显示（将int16转换为可显示的uint8，注意拉普拉斯层有正有负，中心在128附近）
display_list = []
titles = []
for i, lap in enumerate(laplacian_pyramid):
    # 将值域线性映射到0-255以便显示
    lap_display = cv2.normalize(lap, None, 0, 255, cv2.NORM_MINMAX, dtype=cv2.CV_8U)
    display_list.append(lap_display)
    titles.append(f'Laplacian Level {i}: {lap.shape}')

display_images(display_list, titles, rows=1, cols=len(laplacian_pyramid))

观察拉普拉斯金字塔的图像，你会发现它们看起来像“边缘检测”图。最底层（Level 0）包含了最精细的边缘和纹理细节，越往上，细节越粗糙，主要剩下一些大的轮廓。中间灰度（128左右）的区域代表变化平缓的低频区域，在差值中接近0。

3.4 从拉普拉斯金字塔重建图像

这是验证我们金字塔构建是否正确、理解其无损性的关键一步。

def reconstruct_from_laplacian_pyramid(laplacian_pyramid):
    """从拉普拉斯金字塔重建原始图像"""
    # 从顶层开始，顶层就是最后一张高斯图
    reconstructed = laplacian_pyramid[-1].astype(np.float32) # 从顶层开始，用浮点避免精度损失
    
    # 从顶层向下（从倒数第二层开始，向上迭代）
    for i in range(len(laplacian_pyramid)-2, -1, -1):
        # 将当前重建图（低频部分）上采样
        upsampled = cv2.pyrUp(reconstructed, dstsize=(laplacian_pyramid[i].shape[1], laplacian_pyramid[i].shape[0]))
        # 加上当前层的拉普拉斯细节（高频部分）
        reconstructed = upsampled + laplacian_pyramid[i].astype(np.float32)
    
    # 将结果转换回uint8，并确保值域在0-255
    reconstructed = np.clip(reconstructed, 0, 255).astype(np.uint8)
    return reconstructed

# 重建图像
reconstructed_img = reconstruct_from_laplacian_pyramid(laplacian_pyramid)

# 比较原始图像和重建图像
print(f"Original shape: {gray_img.shape}, Reconstructed shape: {reconstructed_img.shape}")
print(f"Are they identical? {np.array_equal(gray_img, reconstructed_img)}")
# 由于浮点运算和OpenCV的pyrUp/pyrDown内部实现可能有微小差异，完全相等很难，我们看差异
diff = cv2.absdiff(gray_img, reconstructed_img)
print(f"Max difference: {np.max(diff)}")
print(f"Mean difference: {np.mean(diff)}")

# 显示原始、重建和差异图
display_images([gray_img, reconstructed_img, diff],
               ['Original Image', 'Reconstructed Image', f'Difference (max={np.max(diff)})'],
               rows=1, cols=3)

如果实现正确，重建的图像应该与原始图像几乎完全相同（最大像素差异通常只有1或2，这是由于计算过程中的舍入误差造成的）。这个实验完美地证明了拉普拉斯金字塔是一种无损（或近乎无损）的图像表示方式。

4. 不止于理论：图像金字塔的实战应用剖析

理解了原理和实现，我们来看看它在实际项目中如何大显身手。这里我分享三个最经典也最实用的应用场景。

4.1 应用一：多尺度特征检测（以SIFT为例）

SIFT（尺度不变特征变换）算法是图像金字塔应用的典范。它的核心思想是： 真正的关键点，不仅要在空间位置（x, y）上稳定，还要在尺度空间（σ）上稳定 。图像金字塔（在这里是高斯差分金字塔DoG）就是用来构建这个“尺度空间”的。

过程简述 ：

1. 构建高斯尺度空间 ：对原始图像不断进行高斯模糊（增加σ），生成一系列不同尺度的图像，这构成了一个“八度”（Octave）的尺度空间。然后，将图像下采样一半，作为下一个八度的起始，重复这个过程。这就形成了一个高斯金字塔，但每一层内还有多个不同σ的尺度。
2. 构建高斯差分金字塔 ：在同一八度内，将相邻尺度的高斯图像相减，得到DoG图像。DoG是拉普拉斯算子（LoG）的近似，对边缘和角点响应强烈，且计算效率更高。
3. 关键点检测 ：在DoG金字塔的三维空间（x, y, σ）中寻找极值点。每个像素需要和它同一尺度的8个邻居，以及上下相邻尺度的各9个邻居（共26个）进行比较，只有当它是这26个点中的最大值或最小值时，才被认为是一个候选关键点。
4. 关键点定位 ：通过三维二次函数拟合来精确定位关键点的位置和尺度，并消除低对比度和边缘响应不稳定的点。

为什么金字塔在这里不可或缺？

• 尺度不变性 ：通过在多个尺度上搜索，找到的特征点不受图像缩放影响。一个在放大图像中清晰可见的角点，在缩小图像中可能只是一个像素块，但通过金字塔，我们能在合适的尺度上找到它。
• 效率 ：在低分辨率图像上搜索特征，速度远快于直接在全分辨率图像上搜索。SIFT通过先在下采样图像上找到大致区域，再映射回原图精修，平衡了精度和速度。

实操心得 ：在使用OpenCV的SIFT检测器时， nOctaveLayers 和 contrastThreshold 是两个关键参数。 nOctaveLayers 控制每个八度内的尺度层数，增加它会检测到更多尺度连续的特征，但计算量也更大。 contrastThreshold 过滤低对比度的点，在纹理丰富的场景可以调高以减少噪点。我通常会在目标图像上做一个小网格搜索，找到适合当前任务的最佳参数组合。

4.2 应用二：图像融合（拉普拉斯金字塔融合）

这是拉普拉斯金字塔最“魔法”的应用之一，用于实现无缝的图像拼接或混合。经典例子是“苹果和橘子”的融合，或者将一张图的天空与另一张图的地面完美结合。

原理与步骤 ：

1. 分别构建金字塔 ：对源图像A和源图像B分别构建高斯金字塔和拉普拉斯金字塔。
2. 构建掩模金字塔 ：对定义融合区域的二值掩模图像（比如左边是1，右边是0）构建高斯金字塔。注意，掩模也需要下采样，以匹配每一层拉普拉斯金字塔的尺寸。
3. 逐层融合 ：在每一层拉普拉斯金字塔上，按照对应层的掩模进行加权融合： L_fused_i = mask_i * L_A_i + (1 - mask_i) * L_B_i 。掩模经过高斯模糊后，边缘是平滑过渡的，这保证了融合边界在不同尺度上都是平滑的。
4. 重建 ：从融合后的拉普拉斯金字塔顶层开始，逐层向上采样并加上融合后的细节层，最终重建出融合后的图像。

为什么比直接融合好？ 如果直接在原图上用模糊的掩模进行融合，在颜色或纹理差异大的边界，仍然可能看到一条模糊但突兀的接缝。这是因为一次性处理了所有频率的信息。拉普拉斯金字塔融合将图像分解到不同频率带：低频层（高层金字塔）决定了图像的整体结构和颜色过渡，高频层（低层金字塔）决定了细节纹理。我们让低频信息在较大的区域上平滑过渡（掩模模糊半径大），而让高频信息在较小的区域上快速切换（掩模模糊半径小）。这样，最终重建的图像在 所有尺度上 都实现了平滑过渡，接缝在视觉上就“消失”了。

def laplacian_pyramid_blend(img_a, img_b, mask, levels=6):
    """拉普拉斯金字塔融合"""
    # 生成A和B的高斯金字塔
    gp_a = [img_a.astype(np.float32)]
    gp_b = [img_b.astype(np.float32)]
    gp_m = [mask.astype(np.float32) / 255.0] # 归一化到0-1
    
    for i in range(levels):
        gp_a.append(cv2.pyrDown(gp_a[-1]))
        gp_b.append(cv2.pyrDown(gp_b[-1]))
        gp_m.append(cv2.pyrDown(gp_m[-1]))
    
    # 生成A和B的拉普拉斯金字塔
    lp_a = [gp_a[levels-1]] # 顶层是高斯金字塔的顶层
    lp_b = [gp_b[levels-1]]
    for i in range(levels-1, 0, -1):
        # 拉普拉斯层 = 高斯层 - 上层高斯的上采样
        size = (gp_a[i-1].shape[1], gp_a[i-1].shape[0])
        ge_a = cv2.pyrUp(gp_a[i], dstsize=size)
        ge_b = cv2.pyrUp(gp_b[i], dstsize=size)
        lp_a.append(gp_a[i-1] - ge_a)
        lp_b.append(gp_b[i-1] - ge_b)
    lp_a.reverse() # 反转，使第0层是原图尺寸的细节层
    lp_b.reverse()
    
    # 融合拉普拉斯金字塔
    lp_fused = []
    for la, lb, gm in zip(lp_a, lp_b, gp_m[::-1]): # gp_m需要反转顺序以匹配lp
        lp_fused.append(gm * la + (1 - gm) * lb)
    
    # 从融合金字塔重建
    reconstructed = lp_fused[0]
    for i in range(1, levels):
        size = (lp_fused[i].shape[1], lp_fused[i].shape[0])
        reconstructed = cv2.pyrUp(reconstructed, dstsize=size)
        reconstructed = reconstructed + lp_fused[i]
    
    # 裁剪到0-255并转换类型
    reconstructed = np.clip(reconstructed, 0, 255).astype(np.uint8)
    return reconstructed

4.3 应用三：加速目标检测与图像匹配

在深度学习统治目标检测之前，基于滑动窗口和手工特征（如HOG+SVM）的方法是主流。直接在数百万像素的大图上用固定大小的窗口滑动，计算量是灾难性的。图像金字塔提供了优雅的解决方案。

工作流程 ：

1. 构建输入图像金字塔 ：对输入图像进行多尺度下采样。
2. 构建检测窗口金字塔 （可选）：如果你的检测器窗口大小固定，那么在不同尺度的图像上，这个固定窗口实际上对应着原始图像中不同大小的区域。例如，在缩小一半的图像上，一个64x64的窗口对应原图中128x128的区域。这样，一个固定大小的检测器就能检测不同大小的目标。
3. 逐尺度检测 ：从金字塔顶层（最小图）开始，用检测器进行滑动窗口检测。因为图像小，计算非常快，可以快速排除大片不可能存在目标的区域。
4. 映射与精修 ：将在小图上检测到的目标框，根据下采样的比例，映射回原始图像的大致区域。然后，可以在这个区域内用更精细的尺度（或直接在原图）进行二次检测或边界框回归，得到精确的位置。

在现代深度学习中的应用 ： 虽然CNN本身具有一定尺度不变性，但图像金字塔思想依然以其他形式存在：

• 特征金字塔网络 ：FPN（Feature Pyramid Network）可以看作是深度学习版的“特征金字塔”。它通过自顶向下和横向连接，将深层网络的高层语义特征与浅层网络的高分辨率特征融合，让检测器能在不同尺度的特征图上检测不同大小的目标。
• 多尺度测试 ：在模型推理时，将输入图像缩放到多个不同尺寸，分别进行预测，然后综合所有尺度的结果。这能显著提升对小目标和超大目标的检测精度，是刷高比赛指标时的常用技巧，当然也增加了计算成本。

5. 避坑指南：实现与应用中的常见问题

纸上得来终觉浅，在实际编码和应用图像金字塔时，有几个坑我几乎每次都会遇到，这里总结一下。

5.1 尺寸对齐与舍入误差

这是最恼人的问题之一。图像的长宽不一定是2的整数次幂，或者可能是奇数。 cv2.pyrDown 和 cv2.pyrUp 对尺寸的处理遵循一个近似公式：

• pyrDown : dst_width = (src_width + 1) // 2 , dst_height = (src_height + 1) // 2
• pyrUp : dst_width = src_width * 2 , dst_height = src_height * 2

这意味着，对一个 (99, 99) 的图像做 pyrDown ，会得到 (50, 50) 的图像。再对它做 pyrUp ，会得到 (100, 100) 的图像。尺寸对不上了！

解决方案 ：

1. 指定目标尺寸 ： cv2.pyrUp(src, dstsize=(target_width, target_height)) 。在重建拉普拉斯金字塔时，必须精确指定目标尺寸为上一层的尺寸。
2. 保持一致 ：在构建和重建金字塔的整个循环中，始终使用同一套尺寸计算逻辑。最好写一个辅助函数来管理每一层的尺寸。
3. 预先裁剪 ：对于要求严格的场景（如需要完美重建），可以先将图像裁剪或填充至长宽为 2^n 的尺寸。

5.2 数据类型与数值溢出

图像通常是 uint8 类型（0-255）。但在构建拉普拉斯金字塔时，做减法 G_i - Expand(G_{i+1}) 会产生负数。如果用 uint8 直接计算，负数会下溢变成很大的正数（如-1变成255），导致重建完全错误。

解决方案 ：

• 在计算拉普拉斯层前，先将高斯图像转换为有符号类型，如 np.int16 或 np.float32 。
• 存储拉普拉斯金字塔时，也使用有符号类型。
• 重建时，最后一步再将结果用 np.clip 截断并转回 uint8 。

5.3 模糊核的选择与“频带分离”效果

高斯金字塔的质量很大程度上取决于高斯模糊核的大小（ ksize ）和标准差（ sigma ）。OpenCV的 pyrDown 使用一个固定的、不可配置的核。如果你自己实现，需要小心选择。

• 核太小 ：抗混叠效果不足，下采样后图像可能出现锯齿。
• 核太大 ：过度模糊，导致细节丢失严重，上层金字塔图像过于平滑，信息损失大。
• 经验值 ：通常， sigma 设为 0.5 * ((ksize-1)*0.5 - 1) + 0.8 。OpenCV默认的 pyrDown 行为大致相当于一个5x5的核。对于拉普拉斯金字塔融合，有时会使用更大的核（如7x7）来获得更平滑的低频过渡。

5.4 在深度学习 pipeline 中的集成

将图像金字塔集成到现代深度学习框架（如PyTorch, TensorFlow）中时，需要注意：

• 数据加载效率 ：实时构建多尺度图像金字塔可能成为数据加载的瓶颈。通常的做法是在预处理阶段预先计算好多个尺度的图像，或者使用支持 torchvision.transforms.Resize 等操作的 DataLoader 进行在线缩放。
• 批处理 ：一个批次（batch）内的图像必须尺寸相同。因此，多尺度训练通常是以“图像中心裁剪+缩放”或“随机缩放后填充到固定尺寸”的方式实现的，而不是在一个batch里放不同尺度的图。
• 梯度流 ：如果你在自定义层中实现了金字塔操作（例如一个可微分的图像金字塔采样），需要确保所有操作都是可微的，以便梯度能够反向传播。标准的 cv2.pyrDown 是不可微的，你需要用 torch.nn.functional.interpolate 配合高斯滤波来实现可微版本。

图像金字塔是一个古老而强大的工具，它的思想穿透了传统图像处理和现代深度学习。理解它，不仅能帮你解决很多实际的工程问题，更能让你对“多尺度”这个计算机视觉的核心概念有更深刻的体会。下次当你面对一个需要处理不同大小目标的视觉任务时，不妨先想想：这里是不是可以用金字塔来优雅地解决？