OpenCV 的 SIFT 特征提取在图像拼接里有多好用，做视觉相关开发的朋友应该都有体会。这篇教程会从 SIFT 的原理讲起，一步步带你实现两张图的无缝拼接，代码我会逐段解释，还会分享我实际调试中踩过的坑，保证你是零基础也能跟着跑出来。

图像拼接的应用场景其实很常见，比如手机全景照片、无人机航拍地图拼接、扫描文档的碎片还原，核心都离不开特征点匹配和透视变换。我用 OpenCV 的 SIFT 算法做过不少类似的项目，从最开始只会调函数到后来能针对不同场景调参优化，中间确实积累了一些经验。这篇教程不扯虚的，直接讲怎么从零搭出一个可用的图像拼接流程，适合刚接触计算机视觉的初学者，也适合想系统理解 SIFT 拼接原理的开发者参考。

1. 为什么图像拼接要选 SIFT 算法

1.1 特征点匹配的基本思路

图像拼接的本质，是把两张有重叠区域的图片对齐并融合成一张大图。要实现对齐，第一步得找到两张图里对应的位置，也就是“特征点”。你可以把特征点理解成图像上比较特殊、容易认出来的角落、边缘交叉处、纹理丰富的位置。

实现这个思路有几个技术流派。早期的做法是直接做模板匹配，也就是拿一张图的小块区域去另一张图里滑动搜索最相似的位置，但这种方法对旋转、光照变化特别敏感，稍微换个角度就匹配错了。后来出现了角点检测算法，比如 Harris 角点，它比模板匹配稳健一些，但尺度变化一大——比如一张图拍得远、一张拍得近——就歇菜了。

真正解决这些痛点的就是 SIFT，全称是尺度不变特征变换。它的核心优势可以概括成三点：尺度不变、旋转不变、光照鲁棒。这意味着哪怕两张图拍摄角度不同、距离有远近、光线有明暗差异，它都能稳定地找到对应关系。

1.2 SIFT 相比其他特征算法的优势

我最早接触图像拼接时先用的是 ORB，原因很简单——快。ORB 的检测速度比 SIFT 快很多，在实时视频拼接场景里确实有优势。但 ORB 的鲁棒性在图像差异比较大的情况下明显不够用，比如上下两张图曝光差别大、或者有一定旋转角度时，匹配质量会肉眼可见地下降。

SIFT 的算法原理决定了它在精度上更可靠。它通过在尺度空间中检测极值点来确认特征点的位置，同时基于局部梯度方向统计生成 128 维的描述子，这个描述子对旋转和尺度变化有很强的容忍力。用大白话说，它给每个特征点发了一个“身份证”，这个身份证在图像发生形变后依然有效。

当然 SIFT 也有它的缺点，最直接的就是慢。每个特征点需要计算 128 维的浮点描述子，再加上高斯金字塔的构建开销，单张图处理几百个关键点的耗时远比 ORB 大。但静态图像拼接不是实时任务，我们完全可以用时间换精度。

提示：如果你做的是实时视频拼接，比如摄像头画面合成，可以考虑 ORB 或 AKAZE 换取帧率；如果是离线拼接，比如航拍图、扫描图合成，闭眼选 SIFT 就对了。

1.3 SIFT 在 OpenCV 中的开源状态变化

这里有个历史背景值得说一下。SIFT 算法最初是有专利保护的，所以在 OpenCV 的付费模块里待了很长一段时间。后来专利到期，OpenCV 从 4.4 版本开始把 SIFT 移到了主仓库，直接能用cv2.SIFT_create()创建。如果你还在用很老版本的 OpenCV，会发现这个函数导入报错，需要先升级库。

我见过不少朋友用了旧环境跑教程代码，第一步创建 SIFT 对象就卡住了。这里统一建议：把 OpenCV 升到 4.5 以上的版本，直接用pip install opencv-python安装最新版即可，不用额外装 opencv-contrib-python，因为 SIFT 已经不在 contrib 模块里了。

踩过这个坑之后，我养成了一个习惯：写视觉相关教程前先确认版本。运行cv2.__version__查看一下，确保是大版本 4 的近期版本，能省掉后面一堆排查时间。

2. 环境准备与图像预处理

2.1 搭建运行环境

基于 Python 环境来做，安装依赖很简单，两个库就够用：

pip install opencv-python numpy

建议用的 Python 版本是 3.8 及以上。装好之后快速验证一下导入是否正常：

import cv2 import numpy as np print(cv2.__version__)

能打印出类似4.8.0的版本号就说明环境没问题。

这里插一个重要提醒：cv2.imread()读入的图片默认是 BGR 通道顺序，但 SIFT 是基于灰度图提取特征的，所以我们要先把图像转成灰度图。这一步虽然简单，却是很多初学会忽略的细节，不转灰度直接传给 SIFT 虽然程序也能跑，但提取关键点还是基于单通道来做的，内部有转换逻辑，不过自己显式转一遍更加清晰可控。

2.2 图像缩放与降噪预处理

图像拼接时有个常见问题：原始照片尺寸太大。手机拍的照片动辄几千万像素，直接把原图喂给 SIFT 会导致两个后果，一是高斯金字塔构建非常耗时，二是特征点数量爆炸式增长，匹配时计算量陡增。

我处理这种情况的通用策略是：先把长边缩放到 1000 像素左右。这样既能保证特征点提取的精度，又不至于让程序跑太久。

def resize_image(image, max_width=1000): h, w = image.shape[:2] if max(h, w) > max_width: scale = max_width / max(h, w) new_w, new_h = int(w * scale), int(h * scale) return cv2.resize(image, (new_w, new_h)) return image

另一个值得做的预处理是降噪。图片有噪点时，SIFT 会把噪声当作特征点提取出来，这些噪声点匹配结果极不稳定。用高斯模糊做一个轻量降噪，可以用cv2.GaussianBlur(img, (5, 5), 1.5)。注意高斯核的大小不要太大，否则会把图像边缘细节也磨平。

我个人实际建议是：清晰度高的户外照片直接跳过降噪步骤，SIFT 本身的尺度空间构建就带有平滑操作；如果拼接夜拍或者低光环境下的图，降噪效果会比较明显。

3. SIFT 特征提取与匹配实现

3.1 特征提取核心代码

SIFT 特征的提取在 OpenCV 里调用起来非常简单，下面这段代码完成了从图读取到关键点信息提取的全过程：

import cv2 import numpy as np # 读取图像 img_left = cv2.imread('left.jpg') img_right = cv2.imread('right.jpg') # 缩放到合适尺寸 img_left = resize_image(img_left) img_right = resize_image(img_right) # 创建灰度图 gray_left = cv2.cvtColor(img_left, cv2.COLOR_BGR2GRAY) gray_right = cv2.cvtColor(img_right, cv2.COLOR_BGR2GRAY) # 创建 SIFT 检测器 sift = cv2.SIFT_create(nfeatures=2000) # 检测关键点和计算描述子 keypoints_left, descriptors_left = sift.detectAndCompute(gray_left, None) keypoints_right, descriptors_right = sift.detectAndCompute(gray_right, None)

nfeatures=2000这个参数需要解释一下，它的含义是 SIFT 最多提取 2000 个特征点。这个值设得越大，匹配的候选点越多，但耗时也线性增长。我自己测试下来，做两图拼接 2000 完全够用，500 张以上的大图拼接可以适当加到 5000。

detectAndCompute一次完成关键点定位和描述子计算，比分成detect和compute两步更高效。对于拿到手的keypoints对象，可以通过len()查看提取到的关键点个数，也可以直接把关键点画在图上直观感受特征分布：

img_with_keypoints = cv2.drawKeypoints(gray_left, keypoints_left, None) cv2.imwrite('keypoints_visualize.jpg', img_with_keypoints)

看到特征点密集分布在图像的纹理丰富区域，同时边缘和纯色区域很少出现特征点，说明提取质量是正常的。

3.2 为什么要用 Lowe's Ratio Test

描述子匹配我推荐用BFMatcher结合 Lowe's ratio test，这个方案是视觉领域经典的稳定组合。

Lowe 的论文里提到一个经验参数：取最近邻距离和次近邻距离的比值，小于 0.7 时认为是稳定匹配。这个“最近邻”指的是待匹配点在另一个图里找到的相似度最高的那个点，次近邻则是第二相似的点。如果这两个距离非常接近，说明这个点在另一图里有很多相似候选，辨识度不高，这种匹配容易被误判。通过设置比率阈值可以过滤掉那些模糊的匹配项。

匹配的代码实现如下：

# 创建 BFMatcher 对象，使用欧氏距离 bf = cv2.BFMatcher(cv2.NORM_L2, crossCheck=False) # 对描述子执行 k 近邻匹配，取最近邻和次近邻 matches = bf.knnMatch(descriptors_left, descriptors_right, k=2) # Lowe's ratio test，筛选优质匹配点 good_matches = [] for m, n in matches: if m.distance < 0.75 * n.distance: good_matches.append(m)

crossCheck=False是因为我们用 knnMatch 自带的 k=2 模式来做比值筛选，如果你改用了match()函数，可以设置crossCheck=True，它要求双向互为最近邻才视为匹配，也是一种过滤策略。两者可以任选其一，不要叠加重用，不然匹配数量会降得特别狠。

我实际测试过不同 ratio 值的效果：0.6 以下匹配数量很少但质量极高；0.75 是比较平衡的，匹配数量充足且质量也能保证；0.8 以上会出现明显的误匹配。建议从 0.75 起步。

3.3 特征点匹配结果可视化

筛选完了匹配，可以画出来看看效果。OpenCV 提供了cv2.drawMatches方法，把两张图并排显示并用连线标出匹配对。

result_vis = cv2.drawMatches( img_left, keypoints_left, img_right, keypoints_right, good_matches, None, flags=cv2.DrawMatchesFlags_NOT_DRAW_SINGLE_POINTS ) cv2.imwrite('matches_visualize.jpg', result_vis)

看看画面里的连线是否规律地分布在重叠区域。如果匹配线乱成一团，或者有大量跨区域的横向错位连线，说明匹配质量有问题，这时候就要检查前面预处理环节。

4. 单应性矩阵求解与图像变换

4.1 单应性矩阵的数学意义

匹配只是找出了对应点，真正把两张图对齐需要算出一个变换关系。这个关系在数学上用一个 3x3 的矩阵来描述，叫单应性矩阵 H。

单应性矩阵可以把一张图上的像素坐标映射到另一张图的坐标，它适用于拍摄同一平面场景或者相机只绕光心旋转的情况。图像拼接正好属于这种情况，大部分拍摄之后的两张图能通过单应变换精准对齐。

用 OpenCV 求单应性矩阵的代码是一个核心步骤：

# 提取匹配点坐标 src_pts = np.float32([keypoints_left[m.queryIdx].pt for m in good_matches]).reshape(-1, 1, 2) dst_pts = np.float32([keypoints_right[m.trainIdx].pt for m in good_matches]).reshape(-1, 1, 2) # 计算单应性矩阵，使用 RANSAC 剔除误匹配 H, mask = cv2.findHomography(src_pts, dst_pts, cv2.RANSAC, 5.0)

4.2 RANSAC 参数选择与误匹配剔除

findHomography的第三个参数选择 RANSAC 是基于迭代的方式对匹配点做随机抽样，估算出最优的变换矩阵，同时自动标记哪些匹配点是内点，哪些是外点。这里有个关键的地方：前面用 ratio test 筛选过一轮，匹配中仍然可能残留少量误匹配，RANSAC 是第二道保险。

第四个参数 5.0 是 RANSAC 的重投影误差阈值，单位是像素。如果匹配点的坐标经过矩阵变换后和目标点偏差小于这个值，就认为是内点，否则当作外点剔除。

这个阈值的取值也是有讲究的：阈值设得越小，要求越严格，被剔掉的外点越多，但有效的匹配可能也被误杀；设得太大，误匹配可能混进计算，导致变换矩阵不准。我做全景拼接的经验值是 4-8 的范围，比较平衡，图片像素密度高的场景可以用 6 或 8。

一个更好的做法是查看 RANSAC 之后的内点比例，判断整体匹配质量：

inlier_count = np.sum(mask) total_count = len(mask) inlier_ratio = inlier_count / total_count print(f"内点数量: {inlier_count}, 总匹配数量: {total_count}, 内点比例: {inlier_ratio:.2f}")

内点比例高于 0.5 基本说明匹配质量非常理想；如果比例低于 0.3，建议回头调参数，或者检查输入图像的重叠区域是否真的太少了。

4.3 图像透视变换与画布扩展

算出单应性矩阵之后，接下来要做的就是把右图通过透视变换映射到左图的坐标系里。透视变换在 OpenCV 中对应cv2.warpPerspective。

拼接不是简单的warpPerspective就完事的，还牵涉输出画布大小的计算。直接按左图尺寸变换的话，右图可能有一部分超出边界，拼接图就不完整。正确流程是：先根据 H 算出右图四个角变换后的坐标，再结合左图边界确定最终的画布大小。

我封装了一个函数处理这个问题，实现思路是：

def compute_canvas_size(img_left, img_right, H): h_left, w_left = img_left.shape[:2] h_right, w_right = img_right.shape[:2] # 右图四个角点坐标 corners = np.float32([ [0, 0], [0, h_right - 1], [w_right - 1, h_right - 1], [w_right - 1, 0] ]).reshape(-1, 1, 2) # 通过单应性矩阵变换到左图坐标系 transformed_corners = cv2.perspectiveTransform(corners, H) # 合并左图边界和变换后的右图角点坐标 all_corners = np.concatenate((np.array([[0, 0], [0, h_left - 1], [w_left - 1, h_left - 1], [w_left - 1, 0]]), transformed_corners.reshape(-1, 2))) # 计算边界 [x_min, y_min] = np.int32(all_corners.min(axis=0)) [x_max, y_max] = np.int32(all_corners.max(axis=0)) # 平移量 tx, ty = -x_min, -y_min canvas_w = x_max - x_min canvas_h = y_max - y_min # 扩展矩阵，加入平移变换 H_translation = np.array([[1, 0, tx], [0, 1, ty], [0, 0, 1]], dtype=np.float32) H_adjusted = H_translation.dot(H) return canvas_w, canvas_h, H_adjusted, tx, ty

这里要稍微解释一下：perspectiveTransform接受 1xN 的 N 通道坐标数组，所以输入形状是(-1, 1, 2)。不能直接用cv2.transform，那是仿射变换用的。

之后用计算出的H_adjusted来变换右图，并创建对应尺寸的画布放置左图：

canvas_w, canvas_h, H_adjusted, tx, ty = compute_canvas_size(img_left, img_right, H) # 变换右图 warped_right = cv2.warpPerspective( img_right, H_adjusted, (canvas_w, canvas_h) ) # 左图平移到画布对应位置 canvas = np.zeros((canvas_h, canvas_w, 3), dtype=np.uint8) canvas[ty:ty + img_left.shape[0], tx:tx + img_left.shape[1]] = img_left

这一步完成了两个图在同一个坐标系下的对齐，但重叠区域直接覆盖的话会有一条明显的拼接缝，后面需要做融合处理。

5. 图像融合与接缝消除

5.1 直接拼接的问题

最粗暴的拼接方式是把两张图直接叠加，重叠区域取左图或者右图的像素。这种方式会出现一条肉眼可见的分界线，尤其是在曝光条件不一致的情况下。原因很简单：两张图在重叠区域的像素值存在亮度、色差差异，硬切一刀必然产生突变。

实际项目中我用过三种融合方案，按效果从低到高排列：直接覆盖、线性加权融合、多频段融合。对于入门教程，线性加权融合足够满足大部分需求，而且代码量不大，理解起来也直观。

5.2 线性加权融合的实现

线性加权融合的核心思想是：重叠区域中越靠近左图的像素以左图为主，越靠近右图的像素以右图为主，中间区域按距离线性过渡。实现上是计算每个像素位置的权重系数，然后加权求和。

有一个细节需要注意：重叠区域的权重值必须基于左图在画布中的实际位置来计算，而不是简单用整张图的坐标。

def linear_blend(canvas, warped_right, tx, ty): # 计算右图变换后左上角在画布中的位置 # 需要找到左右图重叠的区域 left_mask = np.zeros((canvas.shape[0], canvas.shape[1]), dtype=np.float32) left_mask[ty:ty + img_left.shape[0], tx:tx + img_left.shape[1]] = 1.0 right_mask = np.zeros((canvas.shape[0], canvas.shape[1]), dtype=np.float32) right_mask[warped_right[:, :, 0] > 0] = 1.0 # 重叠区域 overlap_mask = left_mask * right_mask # 生成左右图像的权重，渐变过渡 # 对重叠区域的两侧，分别计算到边界的距离作为权重 left_weight = np.zeros_like(left_mask) right_weight = np.zeros_like(right_mask) # 简化方案：在重叠区按列做渐变 # 找到重叠区域的列范围 cols = np.where(overlap_mask.sum(axis=0) > 0)[0] if len(cols) > 0: col_start, col_end = cols[0], cols[-1] col_range = col_end - col_start for x in range(col_start, col_end + 1): ratio = (x - col_start) / col_range left_weight[:, x] = 1 - ratio right_weight[:, x] = ratio # 合成 result = canvas * (left_weight[:, :, np.newaxis]) + warped_right * (right_weight[:, :, np.newaxis]) result = np.where(overlap_mask[:, :, np.newaxis] > 0, result, canvas + warped_right) return np.uint8(np.clip(result, 0, 255))

这不是最精简的写法，但胜在逻辑清晰，新手能看明白每一步在做什么。实际处理时，单元格级别效率不高可以用 NumPy 的向量化操作优化，但这个版本对于两张缩放到 1000 像素的图，Python 循环完全可以接受。

5.3 消除亮度差异的颜色校正

线性加权融合虽然消除了接缝线，但重叠区域两边原本的亮度差异还是会在过渡带上产生色差渐变。更强的做法是先做全局颜色校正——把两张图的重叠区域像素做亮度、对比度对齐后再融合。

常用的方法是直方图匹配，或者更简单地对右图乘以一个补偿系数。计算方式：提取重叠区域的左右两部分像素均值，算出比率，然后缩放右图整体像素。

def color_adjust(img_left, warped_right, left_mask, right_mask, overlap_mask): # 分别取重叠区域的左右像素值 overlap_left = img_left * (overlap_mask[ty:ty + img_left.shape[0], tx:tx + img_left.shape[1], np.newaxis] > 0).astype(np.float32) overlap_right = warped_right[ty:ty + img_left.shape[0], tx:tx + img_left.shape[1]] * (overlap_mask[ty:ty + img_left.shape[0], tx:tx + img_left.shape[1], np.newaxis] > 0).astype(np.float32) # 计算均值比 mean_left = overlap_left[overlap_left > 0].mean() if (overlap_left > 0).any() else 1 mean_right = overlap_right[overlap_right > 0].mean() if (overlap_right > 0).any() else 1 scale = mean_left / (mean_right + 1e-6) warped_right_adjusted = np.clip(warped_right * scale, 0, 255).astype(np.uint8) return warped_right_adjusted

在我的实际项目中，曝光差异在 30% 以内时这个补偿手段效果还不错。如果差异很大，建议考虑更复杂的曝光融合算法，但那就是后话了。

6. 常用参数调优与效果优化建议

6.1 影响拼接效果的参数清单

新手最困惑的一点是同一套代码换图片之后结果时好时坏。归根结底是参数没有跟着场景走。我这里整理一份常用的参数速查表，方便你快速定位问题。

6.2 纹理缺失与重复纹理的应对

拼接遇到纯色墙面这类纹理极少的区域时，特征点数量会急剧下降，匹配数量不足导致单应性矩阵计算失败。这种情况除了降低contrastThreshold，还可以提高nfeatures，让 SIFT 尽量从微弱的边缘中提取特征。

反过来，遇到窗户排列、地板格纹这类重复纹理的图片时，误匹配率会飙升。因为很多相似结构的点会互相匹配错误。这种情况我建议先把 ratio 值降到 0.6，再增加 RANSAC 的迭代次数（OpenCV 会根据需要自动迭代，但你可以通过cv2.findHomography的第五个参数设置最大迭代次数）。

6.3 多图拼接的扩展思路

两图拼接跑通之后，扩展到多图拼接的思路是逐张递进拼接。把前两张拼接结果作为新的“左图”，再和第三张做同样的流程。但有两点值得注意：

第一，误差累积问题。前面拼接的小误差会逐步传递，拼接多张后需要做全局优化。正规的做法是用捆集调整来联合优化所有图像的变换参数。第二，画布会越变越大，特征提取前记得重新缩放。

如果只是做简单的连续多图拼接，可以每拼完一张就裁剪掉边缘的黑色区域，减少后续计算量。我试过用这个方法拼接一圈 6 张全景图，效果可行，只要重叠区域足够（建议 30% 以上）。

7. 常见运行报错与实用排错技巧

7.1 报错 Type Descriptor 不匹配

这个报错通常出现在描述子数据类型不匹配时，SIFT 产生的描述子是uint8类型的numpy.ndarray，但某些版本的 OpenCV 在调用BFMatcher时对描述子类型有严格要求。解决方案是显式转换类型：

descriptors_left = np.float32(descriptors_left) descriptors_right = np.float32(descriptors_right)

7.2 拼接结果出现严重错位

错位大概率是在单应性矩阵计算时混入了过多误匹配，RANSAC 没能把它们全部剔除。先看前面打印的内点比例，如果偏低，说明匹配阶段质量就不行。这时候尝试：

• 降低 ratio test 阈值到 0.6
• 对输入图做轻量的直方图均衡化增强对比度
• 确认两图的重叠区域是否包含足够的纹理信息

7.3 特征点全部集中在某一侧

如果检测结果中所有关键点批量落在画面一边，另一边的特征点寥寥无几，大概率是图像曝光不均匀造成的。比如左边过曝、右边正常，过曝区域基本提取不到有效特征。可以尝试对灰度图做 CLAHE 自适应直方图均衡化，再送入 SIFT。

clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8)) gray_left_eq = clahe.apply(gray_left) gray_right_eq = clahe.apply(gray_right)

7.4 warpPerspective 后图像大面积黑色

这是变换矩阵超出了合理范围，但程序没报错继续算的结果。常见原因是匹配点分布太集中，计算出的矩阵对实际情况不适用。解决方法是增加nfeatures保证特征点分布均匀，或者在提取关键点后按网格筛选，确保特征点在画面内分散。

8. 项目完整代码与封装建议

把前面的内容整合成可以直接运行的完整脚本。为了便于复用，把核心流程封装成函数，主函数只负责串流程。

import cv2 import numpy as np def resize_image(image, max_width=1000): h, w = image.shape[:2] if max(h, w) > max_width: scale = max_width / max(h, w) new_w, new_h = int(w * scale), int(h * scale) return cv2.resize(image, (new_w, new_h)) return image def sift_matching(img_left, img_right): gray_left = cv2.cvtColor(img_left, cv2.COLOR_BGR2GRAY) gray_right = cv2.cvtColor(img_right, cv2.COLOR_BGR2GRAY) sift = cv2.SIFT_create(nfeatures=2000) kp_left, des_left = sift.detectAndCompute(gray_left, None) kp_right, des_right = sift.detectAndCompute(gray_right, None) bf = cv2.BFMatcher(cv2.NORM_L2) matches = bf.knnMatch(des_left, des_right, k=2) good_matches = [] for m, n in matches: if m.distance < 0.75 * n.distance: good_matches.append(m) src_pts = np.float32([kp_left[m.queryIdx].pt for m in good_matches]).reshape(-1, 1, 2) dst_pts = np.float32([kp_right[m.trainIdx].pt for m in good_matches]).reshape(-1, 1, 2) H, mask = cv2.findHomography(src_pts, dst_pts, cv2.RANSAC, 5.0) return H, kp_left, kp_right, good_matches, mask def stitch_images(img_left, img_right): H, kp_left, kp_right, good_matches, mask = sift_matching(img_left, img_right) # 计算画布大小 h_left, w_left = img_left.shape[:2] h_right, w_right = img_right.shape[:2] corners = np.float32([ [0, 0], [0, h_right - 1], [w_right - 1, h_right - 1], [w_right - 1, 0] ]).reshape(-1, 1, 2) transformed_corners = cv2.perspectiveTransform(corners, H) all_corners = np.concatenate(( np.array([[0, 0], [0, h_left - 1], [w_left - 1, h_left - 1], [w_left - 1, 0]], dtype=np.float32), transformed_corners.reshape(-1, 2) )) [x_min, y_min] = np.int32(all_corners.min(axis=0)) [x_max, y_max] = np.int32(all_corners.max(axis=0)) tx, ty = -x_min, -y_min canvas_w = x_max - x_min canvas_h = y_max - y_min H_translation = np.array([[1, 0, tx], [0, 1, ty], [0, 0, 1]], dtype=np.float32) H_adjusted = H_translation.dot(H) warped_right = cv2.warpPerspective(img_right, H_adjusted, (canvas_w, canvas_h)) canvas = np.zeros((canvas_h, canvas_w, 3), dtype=np.uint8) canvas[ty:ty + h_left, tx:tx + w_left] = img_left # 简化的线性融合 result = canvas.copy() overlap_mask = (canvas > 0) & (warped_right > 0) result[overlap_mask] = canvas[overlap_mask] // 2 + warped_right[overlap_mask] // 2 return result if __name__ == '__main__': img_left = cv2.imread('left.jpg') img_right = cv2.imread('right.jpg') img_left = resize_image(img_left) img_right = resize_image(img_right) result = stitch_images(img_left, img_right) cv2.imwrite('result.jpg', result) print("拼接完成，结果已保存为 result.jpg")

这个完整版本我做了一点简化处理，重叠区直接用均值替代了复杂的渐入渐出权重，实际效果在曝光均衡的图片上已经看不出明显的接缝。如果你要更精细的效果，把前面第 5 章的线性融合函数替换到result[overlap_mask]这一行即可。

封装思路也很清晰：sift_matching负责特征和矩阵计算，stitch_images负责变换融合，以后换图片测试只需要改主函数里的文件路径。想扩展多图拼接，在这里循环调用stitch_images就行。

我在实际项目里用这套流程拼过无人机拍的农田拼接图、手机拍的全景照片、显微镜视野拼接，大多数情况只需微调比例参数就能获得很好的效果。你要是在某个环节卡住了，优先检查特征点匹配的可视化图，可视化永远是定位问题最直观的手段。

最后分享一个个人经验：图像拼接这个事，特征匹配阶段决定成败，融合阶段决定观感。前面参数没调好，后面做再多美化都救不回来。所以入门阶段一定把大部分精力花在理解bf.knnMatch和findHomography这两个环节上，多画匹配可视化图，多看匹配线的规律，积累视觉直觉之后，调参就是水到渠成的事。

这篇教程里的代码和思路是我从多个项目里总结出来的通用方案，希望能帮你少走一些弯路。整个流程跑通之后，建议自己用手机拍一组带重叠区域的照片试试，亲手调一次参数比看十遍教程都管用。