简介：面向希望用Python实现指纹识别流程的开发者与计算机视觉学习者，这份下载包围绕OpenCV的SIFT特征展开，可用于指纹图像的特征提取、注册与匹配实验，适合具备Python基础、想理解传统视觉算法如何构成完整识别链路的中级读者。包内共78个文件，以74个bmp指纹图像作为主要样本数据，辅以2个txt数据/测试文本和2个py注册与匹配脚本，压缩包约1.76MB，目录轻便，适合在Windows 64位与Python 3.6.5环境下开展小规模实验。已有4382人学习下载，具备一定实践参考度。读者可据此观察指纹样本的组织方式，理解SIFT关键点与描述子在注册、匹配两个环节中的衔接，并借助脚本梳理从图像读取、特征提取到比对输出的实现思路，为后续调试、替换样本与扩展识别流程提供可复用的骨架。

1. 断网机器上的指纹比对，把我逼回了 OpenCV SIFT

去年接手一个小工具：几台不联网的工控机上要做指纹 1:1 比对，不能调云端接口，也不允许装大体积推理框架。手边只有 Python 和 OpenCV，这套「基于 OpenCV SIFT 的指纹识别算法 Python 实现」就是在这种约束下长出来的。它干的事很直接：读两张指纹图、做增强、提 SIFT 关键点和 128 维描述子、FLANN 做 KNN 匹配、ratio test 筛一遍、RANSAC 剔掉几何上说不通的点，最后给一个 0 到 1 的相似度分数和同源判定。适合拿来验证特征匹配这条路线、做课程设计或原型；要撑百万级底库的 1:N 检索，它不够用。

2. 技术选型：SIFT 凭什么能落在指纹脊线上

2.1 细节点路线与纹理特征路线，先分清自己要哪一种

指纹算法圈子里有两条主流路线。一条是细节点法：先估方向场，用 Gabor 滤波增强，二值化后把脊线细化成单像素骨架，再在骨架上找端点和分叉点，去伪之后按距离和角度做点对匹配。另一条是纹理特征法：不关心具体某个点是端点还是分叉，直接对图像本身提尺度不变特征，靠局部梯度分布做描述。SIFT 属于后者。两条路线的工程手感完全不同：细节点法精度上限高，但整条链路都吃参数，方向场估歪一点、细化断一截，后面全崩，属于典型的一步错步步错；SIFT 对预处理的要求宽松得多，只要脊线纹理还在，它就能提出点来。我当初选 SIFT，最现实的原因是它不需要我手写细化算法并调去伪规则，OpenCV 一行SIFT_create()就把特征提取这块接过去了，剩下的精力可以放在匹配和判定上。再加上指纹按压本身带旋转、缩放和局部非线性形变，SIFT 的尺度空间和方向分配刚好覆盖前两项，这是它在这类图上不至于太难看的原因。

2.2 SIFT 在指纹图上的能力边界，先认清再动手

指纹脊线是准周期结构，脊线间距在 500 dpi 采集下大约 8 到 10 个像素。这个尺度信息很关键：降采样到长边 512 之后，脊线间距只剩 4 到 5 像素，还在 SIFT 的可用范围内；再往下压到 300 以下，脊线糊成一片，关键点数量断崖式下跌。SIFT 提取到的点大多落在脊线端点、分叉点和曲率突变处，和细节点在空间上有相当程度的重合，但它描述的是一小片邻域的梯度方向直方图，不是拓扑结构。好处是对局部断裂、油污、轻微形变不敏感；坏处是周期结构会产生大量长得几乎一样的描述子，两张不同手指的图也可能凑出一批高相似度匹配。所以只做 ratio test 远远不够，后面必须再加一层几何一致性校验，这是这套实现里 RANSAC 存在的全部理由。另外要清楚它的天花板：模板大（每点 128 维 float32，一张图几百个点就是几十 KB），匹配复杂度随点数平方走，做 1:1 验证很舒服，做 1:N 大库检索基本没戏。定位定在验证和小规模比对，心态就稳了。

2.3 环境与依赖：一次装齐不返工

OpenCV 在 4.4 之后把 SIFT 收回了主模块，cv2.SIFT_create()可以直接调用，不再需要额外的专利包。但为了少踩版本坑，我一般直接装 contrib 版本，功能全，不至于哪天想换个匹配器又发现缺东西。

# 用 contrib 包，避免主包精简掉部分特征模块 pip install "opencv-contrib-python>=4.5" "numpy>=1.21" tqdm # 验证 SIFT 是否可用，这行不通后面全白搭 python -c "import cv2; print(cv2.__version__); print(cv2.SIFT_create())"

安装完先跑这一行验证。见过太多次环境里装的是 headless 精简版，SIFT_create直接报 attribute 不存在，调半天代码才发现是包的问题。

3. 工程骨架与预处理链路：一张指纹图进算法前要过几道工序

3.1 目录结构：把 IO、预处理、特征、匹配、评估切开

这套实现刻意做成了小模块，单文件也能写，但一改成批量跑分就难受。分开之后每个文件职责单一，改预处理不影响匹配逻辑，换匹配器也不用动特征提取。

fp_sift/ ├── cli.py # 命令行入口，单对比对 ├── config.py # 所有阈值和路径集中在这里 ├── io_utils.py # 读图、缩放、模板落盘与加载 ├── preprocess.py # CLAHE、Gabor、二值化、清理 ├── features.py # SIFT 参数与特征提取 ├── matcher.py # FLANN 匹配、RANSAC、打分 ├── evaluate.py # 批量跑分、阈值扫描、FAR/FRR └── data/ ├── gallery/ # 底库图，注册侧 └── probe/ # 待比对图，验证侧

config.py这个文件看起来最没技术含量，实际最该有。匹配阈值、ratio、降采样长边这些数字会被反复调，散落在各处的时候，改一次要全文搜，血泪经验。

3.2 预处理五步：增强的是脊线对比度，不是整体亮度

预处理的目标只有一个：让脊线和谷线的对比度稳定下来，让 SIFT 在低质量图上也能提出足够多的点。顺序是灰度化、CLAHE、Gabor 方向增强、归一化回 8 位、轻度高斯平滑。

import cv2 import numpy as np def to_gray_u8(img): """统一成单通道 8 位。16 位 PNG 直接截断会丢掉整个动态范围""" if img.ndim == 3: img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) if img.dtype != np.uint8: # 16 位图按最大最小值拉伸到 0-255，别用 astype 硬转 img = cv2.normalize(img, None, 0, 255, cv2.NORM_MINMAX).astype(np.uint8) return img def clahe_enhance(gray, clip=3.0, grid=8): """限制对比度的自适应均衡，clip 越大增强越猛，也越容易放大噪声""" op = cv2.createCLAHE(clipLimit=clip, tileGridSize=(grid, grid)) return op.apply(gray) def gabor_enhance(gray, ksize=15, sigma=4.0, lambd=9.0, gamma=0.5, theta=np.pi / 4): """按固定方向做脊线增强。lambd 要贴近脊线周期，500dpi 下取 9 左右""" kernel = cv2.getGaborKernel((ksize, ksize), sigma, theta, lambd, gamma, 0, ktype=cv2.CV_32F) # Gabor 核均值为 0，用绝对值之和归一化，避免滤波后整体亮度漂移 kernel /= (np.abs(kernel).sum() + 1e-6) resp = cv2.filter2D(gray.astype(np.float32), cv2.CV_32F, kernel) resp = cv2.normalize(resp, None, 0, 255, cv2.NORM_MINMAX) return resp.astype(np.uint8) def preprocess(path, long_side=512): img = cv2.imread(path, cv2.IMREAD_UNCHANGED) if img is None: raise FileNotFoundError(path) gray = to_gray_u8(img) # 先按长边缩放，统一尺度后再增强，避免不同分辨率下参数含义漂移 h, w = gray.shape scale = long_side / max(h, w) if scale < 1.0: gray = cv2.resize(gray, (int(w * scale), int(h * scale)), interpolation=cv2.INTER_AREA) gray = clahe_enhance(gray) gray = gabor_enhance(gray) # 轻度平滑，压掉 Gabor 放大出来的高频噪点 return cv2.GaussianBlur(gray, (3, 3), 0)

to_gray_u8里那段 16 位处理不是凑数的，工业采集设备导出的 PNG 经常是 16 位，直接astype(np.uint8)会把整张图压成接近全黑，SIFT 一个点都提不出来，这个坑后面还会专门讲。long_side=512是精度和速度的折中：太小脊线糊，太大匹配耗时翻倍。Gabor 的lambd参数最需要跟着采集分辨率走，换成 1000 dpi 的图还写 9，滤波方向就和脊线周期对不上了，增强等于白做。

3.3 模板数据结构：注册一次、比对多次

SIFT 提取是整条链路里最慢的一步，如果每次比对都重新提一遍底库特征，批量跑分能把人熬死。所以模板要能落盘，结构上把关键点、描述子、原图尺寸打包在一起。

from dataclasses import dataclass import numpy as np import cv2 @dataclass class FingerTemplate: image_id: str keypoints: list # cv2.KeyPoint 列表 descriptors: np.ndarray # (N, 128) float32 shape: tuple # 预处理后的 (h, w) def __post_init__(self): if self.descriptors is None: self.descriptors = np.zeros((0, 128), dtype=np.float32) def save_template(path, tpl: FingerTemplate): """KeyPoint 不能直接 npz 存，摊平成 (x, y, size, angle, response, octave)""" kp = np.array( [(k.pt[0], k.pt[1], k.size, k.angle, k.response, k.octave) for k in tpl.keypoints], dtype=np.float32, ).reshape(-1, 6) np.savez_compressed(path, kp=kp, desc=tpl.descriptors, shape=np.array(tpl.shape)) def load_template(path) -> FingerTemplate: z = np.load(path) kps = [ cv2.KeyPoint(float(x), float(y), float(s), float(a), float(r), int(o)) for x, y, s, a, r, o in z["kp"] ] return FingerTemplate(path, kps, z["desc"].astype(np.float32), tuple(z["shape"].tolist()))

保存的时候要把cv2.KeyPoint摊平成数组，加载时再构造回去，构造参数顺序是(x, y, size, angle, response, octave)，写错顺序不会报错，但 RANSAC 用的坐标就全乱了，属于最难查的那类问题。这套结构让底库只提一次特征，之后每次验证只跑匹配，单次比对耗时能从秒级降到百毫秒级。

4. 核心代码拆解：从关键点到匹配分数的四段实现

4.1 SIFT 参数怎么定：三个数字决定关键点质量

SIFT_create()的参数不多，但在指纹图上每个都敏感。我的默认组合是保留全部关键点，靠对比度阈值控制数量上限，而不是用nfeatures硬截断。

import cv2 def build_sift(contrast=0.015, edge=10, sigma=1.6): """ contrastThreshold: 低对比度过滤，指纹图普遍偏低，默认 0.04 太严 edgeThreshold: 边缘响应抑制，脊线密集时适当调大 sigma: 金字塔初始尺度，保持 1.6，改了描述子分布就变了 """ return cv2.SIFT_create( nfeatures=0, contrastThreshold=contrast, edgeThreshold=edge, sigma=sigma, ) def extract(gray, sift): kp, desc = sift.detectAndCompute(gray, None) if desc is None or len(kp) == 0: return [], __import__("numpy").zeros((0, 128), dtype=__import__("numpy").float32) return kp, desc.astype(__import__("numpy").float32)

contrastThreshold是最该动的那个。0.04 是面向自然图像的默认值，指纹图经过 Gabor 增强后整体对比度被拉平，用 0.04 会提不出点，一张图可能只剩十几个关键点；降到 0.015 左右，正常质量的图能稳定出 200 到 500 个点。但也不能一路往下降，0.005 的时候噪声点大量涌入，匹配阶段会出现一堆看起来很唬人的假匹配。

4.2 匹配器：FLANN 加 Lowe ratio test

描述子是 128 维浮点向量，用暴力匹配也能跑，但点数上到几百之后差距明显。FLANN 用 KD 树做近似最近邻，checks控制搜索精度，32 到 50 之间够用。

import cv2 def knn_match(desc1, desc2, ratio=0.7, checks=32): """ratio test 是这里的关键：最近邻距离必须明显小于次近邻""" if desc1 is None or desc2 is None or len(desc1) < 2 or len(desc2) < 2: return [] index_params = dict(algorithm=1, trees=5) # 1 == FLANN_INDEX_KDTREE search_params = dict(checks=checks) matcher = cv2.FlannBasedMatcher(index_params, search_params) raw = matcher.knnMatch(desc1, desc2, k=2) good = [] for pair in raw: if len(pair) < 2: continue m, n = pair # 0.7 是自然图像的常用值，指纹周期结构强，实际收到 0.65 更稳 if m.distance < ratio * n.distance: good.append(m) return good

ratio这个数字在指纹图上要比自然图像更紧。原因是脊线周期性重复，同一个点的第二近邻经常也是"很像但不是"，放宽到 0.8 会让一大批本该被排除的匹配留下来，后面的 RANSAC 就得替你擦屁股。实践中 0.65 到 0.7 是甜点区，再紧到 0.6 以下，低质量图的对数会掉得很难看。另外注意 FLANN 的knnMatch返回的是列表套列表，k=2时每项长度是 2，但描述子过少时可能出现长度 1 的项，不判len(pair) < 2会直接抛异常。

4.3 几何校验：RANSAC 单应矩阵把胡说八道的匹配剔掉

ratio test 只看了描述子距离，完全不关心这些点在空间上是否说得通。指纹按压存在非线性形变，但局部区域内仍然可以近似成一个单应变换，所以用findHomography加 RANSAC 做一致性过滤是合适的。

import cv2 import numpy as np def geometric_filter(kp1, kp2, good, reproj=5.0): """返回 (内点坐标, 内点数, 单应矩阵)，内点少于 4 个视为无效匹配""" if len(good) < 4: return np.empty((0, 2), dtype=np.float32), 0, None src = np.float32([kp1[m.queryIdx].pt for m in good]).reshape(-1, 1, 2) dst = np.float32([kp2[m.trainIdx].pt for m in good]).reshape(-1, 1, 2) H, mask = cv2.findHomography( src, dst, cv2.RANSAC, reproj, maxIters=2000, confidence=0.995 ) if H is None or mask is None: return np.empty((0, 2), dtype=np.float32), 0, None mask = mask.ravel().astype(bool) return src[mask].reshape(-1, 2), int(mask.sum()), H

reproj是重投影误差阈值，默认 3.0 对指纹来说有时偏严：Gabor 增强后关键点位置会有轻微偏移，加上按压形变，3 个像素的容差容易把正确的点也判成外点。我一般放到 5.0。maxIters和confidence影响 RANSAC 的采样轮数，2000 轮和 0.995 是在几百个匹配点规模下的稳妥取值，点数很少时可以适当降，省下的时间在批量跑分时能看出来。还有一点，理论上仿射变换（estimateAffinePartial2D，4 自由度）比单应（8 自由度）更不容易过拟合，样本少的时候更稳；样本够的时候单应能容纳更多形变。我一般先用单应，等发现内点数虚高再换仿射对比。

4.4 打分与判定：把内点数变成能定阈值的分数

内点数是绝对量，点数多的图天然占便宜，直接拿它当分数，阈值根本没法统一。所以要归一化，我用了两个维度的加权：内点占好匹配的比例（纯度），以及内点相对参与匹配的关键点总数的覆盖度。

def similarity(inlier_num, good_num, kp1_num, kp2_num, coverage_target=0.25): """ ratio_inlier: 匹配纯度，防止 ratio test 漏网的假匹配 coverage: 几何一致点的覆盖度，coverage_target 取 0.25 表示覆盖到 25% 即满分 """ if good_num == 0 or inlier_num < 4: return 0.0 ratio_inlier = inlier_num / good_num base = max(min(kp1_num, kp2_num), 1) coverage = min((inlier_num / base) / coverage_target, 1.0) return round(0.65 * ratio_inlier + 0.35 * coverage, 4)

权重 0.65 和 0.35 不是拍脑袋，纯度更能区分同源和异源，覆盖度主要用于惩罚那些只匹配上零星几个点的退化情况，所以给纯度更高权重。coverage_target=0.25这个数要按数据集看：高质量图内点占比能到 0.3 以上，低质量图 0.1 都费劲，定得太低会让低质量图轻松满分，定得太高又会让它永远拿不到分。

4.5 命令行跑通一次 1:1 比对

把所有环节串起来，入口用 argparse 暴露常用参数，方便调参时不用改代码。

import argparse import json import cv2 from preprocess import preprocess from features import build_sift, extract from matcher import knn_match, geometric_filter, similarity def compare(probe_path, gallery_path, ratio=0.68, reproj=5.0, threshold=0.45): sift = build_sift() g1 = preprocess(probe_path) g2 = preprocess(gallery_path) kp1, d1 = extract(g1, sift) kp2, d2 = extract(g2, sift) good = knn_match(d1, d2, ratio=ratio) _, inliers, _ = geometric_filter(kp1, kp2, good, reproj=reproj) s = similarity(inliers, len(good), len(kp1), len(kp2)) return { "probe": probe_path, "gallery": gallery_path, "kp_probe": len(kp1), "kp_gallery": len(kp2), "good_matches": len(good), "inliers": inliers, "score": s, "matched": s >= threshold, } if __name__ == "__main__": ap = argparse.ArgumentParser() ap.add_argument("--probe", required=True) ap.add_argument("--gallery", required=True) ap.add_argument("--ratio", type=float, default=0.68) ap.add_argument("--threshold", type=float, default=0.45) args = ap.parse_args() print(json.dumps(compare(args.probe, args.gallery, args.ratio, threshold=args.threshold), ensure_ascii=False, indent=2))

python cli.py --probe data/probe/p001.bmp --gallery data/gallery/g001.bmp

正常输出里四个数字要连起来看：kp_probe和kp_gallery都在 200 以上说明预处理没问题；good_matches在同源时一般有几十到一两百，异源时往往只有个位数；inliers应该占good_matches的一半以上。如果good_matches有上百但inliers只有五六个，基本可以断定是周期结构导致的假匹配，这时候该收紧 ratio 而不是加 RANSAC 的容差。

4.6 批量评估：阈值是标出来的，不是想出来的

单对跑通只能说明代码没崩，阈值合不合理要靠一批带标签的样本。评估脚本的核心是扫一遍候选阈值，统计 FAR（异源被判同源）和 FRR（同源被判异源），取两者相对平衡的位置。

def evaluate(pairs, threshold): """pairs: [(score, label)]，label=1 同源，0 异源""" tp = sum(1 for s, l in pairs if s >= threshold and l == 1) fn = sum(1 for s, l in pairs if s < threshold and l == 1) fp = sum(1 for s, l in pairs if s >= threshold and l == 0) tn = sum(1 for s, l in pairs if s < threshold and l == 0) far = fp / max(fp + tn, 1) frr = fn / max(fn + tp, 1) return {"threshold": round(threshold, 2), "far": round(far, 4), "frr": round(frr, 4)} def sweep(pairs, lo=0.3, hi=0.8, step=0.02): rows = [] t = lo while t <= hi + 1e-9: rows.append(evaluate(pairs, t)) t = round(t + step, 4) # 取 |FAR - FRR| 最小的那档，作为阈值初值 return sorted(rows, key=lambda r: abs(r["far"] - r["frr"]))[0]

扫描区间 0.3 到 0.8、步长 0.02，是我在几百对样本上试出来的合理范围。样本量少的时候（比如一百对以下），FAR 会剧烈抖动，单个阈值扫出来的结果并不值得信，这时候更实际的做法是看分数分布：同源分数大多在 0.5 以上、异源在 0.3 以下，中间这段空档就是安全区，阈值往空档中间放。

5. 避坑与排查：SIFT 指纹匹配最常见的五类翻车

5.1 现象：一张图只能提出十几个关键点，分数永远是 0

原因通常不在代码，在输入。工业采集设备导出的图很多是 16 位灰度 PNG，cv2.imread读进来 dtype 是uint16，直接喂给detectAndCompute不会报错，但 SIFT 内部按 8 位动态范围处理，等价于整张图接近全黑，关键点数自然塌到个位数。另一种情况是彩色扫描图被当成三通道直接送进去，SIFT 只认单通道，OpenCV 会静默处理但语义已经不对了。解决办法是把位深和通道统一收在预处理入口：用cv2.IMREAD_UNCHANGED读原图，判断dtype != np.uint8就用cv2.normalize做最小最大拉伸再转 8 位，三通道一律cvtColor转灰度。改完之后同样一张图关键点从十几个涨到三四百个，这是我自己最早翻的一次车。

5.2 现象：不同手指的图也能拿到 0.6 以上的高分

这是最危险的一类问题，因为它在验证集上看起来"效果很好"。根源是指纹脊线的准周期结构，同一张图不同区域提取出的描述子本身就高度相似，两张不同手指的图只要纹理粗细接近，ratio test 就能凑出一批距离很小的匹配。光靠收紧 ratio 治标，把 0.7 收到 0.6 只是把假匹配从几十个压到十几个。真正的解法是三层叠加：ratio 收到 0.65 左右，RANSAC 的重投影阈值别放太松（5.0 够了，放到 10 什么都能算内点），再加一条空间分布约束，检查内点在图像上的空间跨度是否覆盖了两个以上象限，全部挤在一小块区域的内点基本可以判为无效。这条规则加进去之后，异源高分的尾巴被削掉了大半。

5.3 现象：换台机器跑，报module 'cv2' has no attribute 'SIFT_create'

代码没问题，是环境装的包不对。常见两种情况：一是装了 4.4 之前的旧版本，SIFT 那时还在cv2.xfeatures2d里且需要额外条件；二是装了opencv-python-headless这类精简包，虽然版本号够，但部分模块被裁剪。排查顺序是先打印cv2.__version__，再dir(cv2)看有没有SIFT_create，两步就能定位。解决办法是统一依赖声明，在requirements.txt里写死opencv-contrib-python>=4.5，别让环境自己决定装什么。另外同一个环境里同时装opencv-python和opencv-contrib-python会互相覆盖，症状是时好时坏，这个坑很隐蔽，pip list | grep opencv一眼就能看出来。

5.4 现象：单次比对两秒以上，批量跑分一晚上跑不完

慢的原因通常有三处，优先级从高到低是：重复提取底库特征、图像没降采样、FLANN 的checks开太大。第一条最致命，注册侧提一次存 npz，验证侧直接加载，这一项就能把耗时砍掉一半以上。第二条是很多人忽略的，原始图可能是 1000 乘 1000，降到长边 512 之后关键点数量差不多但匹配的向量规模降了四倍。第三条属于微调，checks从 50 降到 32 精度损失很小，速度能提一截。我一般的组合是：底库预提取、长边 512、checks=32、trees=5，单对在普通笔记本上稳定在 150 毫秒上下。如果还慢，就该考虑是不是在循环里反复创建 matcher 对象了，这个开销不小，提到循环外复用能再省一点。

5.5 现象：肉眼明显是同源，RANSAC 却返回 0 个内点

两种情况。一种是good_matches本身不足 4 个，findHomography直接返回 None，代码里没判空就会在下一步报错，或者被判成完全不同的指纹。这类图往往是低质量按压，脊线断得厉害，解决办法是回退到预处理，把contrastThreshold降到 0.01、clipLimit提到 4.0 再试一次。另一种是匹配数量够但重投影阈值太严，3.0 的容差在 Gabor 增强后的图上经常不够用，关键点位置有轻微偏移，正确的点被当成外点剔掉，表现就是内点数少得离谱。把reproj放到 5.0 通常能救回来。如果两种情况同时存在，先调阈值再调预处理，顺序反了会白折腾很久。

6. 二次开发：把比对器改成注册加验证的两段式服务

这套代码跑通之后，最自然的改造方向是拆成注册和验证两段。注册侧只做一次预处理和特征提取，把FingerTemplate落盘成 npz；验证侧加载模板，只对 probe 提一次特征，然后走匹配打分。这样单次验证的耗时能压到百毫秒级，也才有了被上层业务调用的可能。下面几个方向按投入产出排了序，前两个改起来最快。

一个具体技巧：验证接口不要暴露"相似度"这种模糊概念给上层，而是明确返回三态——通过、拒绝、无法判定。第三态对应的是关键点太少、好匹配不足 4 个这类退化情况，把它单独拎出来，比硬塞进二元判定要有用得多，上层可以选择让用户重按一次。

def verify(tpl_probe, tpl_gallery, threshold=0.45, min_kp=80): # 退化输入不参与打分，直接给"无法判定"，避免污染阈值统计 if len(tpl_probe.keypoints) < min_kp or len(tpl_gallery.keypoints) < min_kp: return {"decision": "unknown", "reason": "low_keypoints", "score": 0.0} good = knn_match(tpl_probe.descriptors, tpl_gallery.descriptors) _, inliers, _ = geometric_filter(tpl_probe.keypoints, tpl_gallery.keypoints, good) s = similarity(inliers, len(good), len(tpl_probe.keypoints), len(tpl_gallery.keypoints)) if s >= threshold: return {"decision": "accept", "score": s} return {"decision": "reject", "score": s}

从那以后我每次改匹配逻辑，都强制先跑一遍固定样本集的分数分布再动阈值——单看几对图的手感太不可靠，同源和异源的分数在某些图上就是会重叠，只有分布图能告诉你重叠区有多宽。这套东西不大，但把预处理、特征、匹配、评估四块切开之后，每块都能单独替换，换成 ORB 或者别的描述子也只是换个文件的事。希望帮到你。

本文还有配套的精品资源，点击获取