如何加速Python中嵌套循环实现的OpenCV特征匹配代码？

原代码的性能瓶颈主要集中在O(N²)的嵌套循环、重复初始化匹配器、DataFrame逐元素赋值的低效率这几个点上，下面是针对性的优化方案：

1. 基础优化：减少重复操作+替换低效赋值 #

优化点： #

• 提前初始化BFMatcher，避免在循环内重复创建对象
• 用numpy数组存储结果，替代DataFrame逐元素修改（Pandas的loc逐元素赋值效率极低）
• 用列表推导式替代内部的good列表循环，提升统计效率

优化后代码： #

import cv2 as cv
import numpy as np
import pandas as pd
from tqdm import tqdm

# 提前创建匹配器，仅初始化一次
bf = cv.BFMatcher(cv.NORM_L1)
n = len(descriptors_1)

# 用numpy数组初始化结果，比DataFrame高效得多
result = np.full((n, n), np.nan)

for i in tqdm(range(n)):
    des1 = descriptors_1[i]
    for j in range(n):
        if i == j:
            continue  # 对角线保持nan，跳过计算
        des2 = descriptors_1[j]
        matches = bf.knnMatch(des1, des2, k=2)
        # 用列表推导式快速统计符合条件的匹配数
        good_count = sum(1 for m, n_match in matches if m.distance < 0.8 * n_match.distance)
        result[i, j] = good_count

# 最后转成DataFrame
df = pd.DataFrame(result)

2. 进阶优化：利用多核并行计算 #

由于每个(i,j)对的计算完全独立，可以用并行计算把任务拆分到多个CPU核心上执行，直接缩短运行时间。这里用joblib实现并行：

import cv2 as cv
import numpy as np
import pandas as pd
from joblib import Parallel, delayed

# 提前初始化匹配器
bf = cv.BFMatcher(cv.NORM_L1)
n = len(descriptors_1)

def compute_match_count(i, j):
    if i == j:
        return np.nan
    des1 = descriptors_1[i]
    des2 = descriptors_1[j]
    matches = bf.knnMatch(des1, des2, k=2)
    return sum(1 for m, n_match in matches if m.distance < 0.8 * n_match.distance)

# 生成所有需要计算的(i,j)对
all_pairs = [(i, j) for i in range(n) for j in range(n)]

# 并行计算，n_jobs=-1表示用满所有CPU核心
results = Parallel(n_jobs=-1, verbose=10)(
    delayed(compute_match_count)(i, j) for i, j in all_pairs
)

# 把结果转成二维数组再转DataFrame
result_array = np.array(results).reshape(n, n)
df = pd.DataFrame(result_array)

3. 高级优化：替换匹配器为FLANN #

如果特征数量极大，BFMatcher的暴力匹配效率会很低，可以改用FLANN匹配器——它是针对大规模特征集设计的近似匹配算法，速度远快于暴力匹配，精度可通过参数调整接近暴力匹配：

import cv2 as cv
import numpy as np
import pandas as pd
from tqdm import tqdm

# FLANN匹配器参数配置
FLANN_INDEX_LSH = 6
index_params = dict(
    algorithm=FLANN_INDEX_LSH,
    table_number=6,    # 数值越大精度越高，速度越慢
    key_size=12,       # 同上
    multi_probe_level=1
)
search_params = dict(checks=50)  # 搜索次数，权衡速度与精度

flann = cv.FlannBasedMatcher(index_params, search_params)
n = len(descriptors_1)
result = np.full((n, n), np.nan)

for i in tqdm(range(n)):
    des1 = descriptors_1[i]
    for j in range(n):
        if i == j:
            continue
        des2 = descriptors_1[j]
        matches = flann.knnMatch(des1, des2, k=2)
        good_count = sum(1 for m, n_match in matches if m.distance < 0.8 * n_match.distance)
        result[i, j] = good_count

df = pd.DataFrame(result)

4. 额外优化：利用对称性减少计算量 #

如果业务场景允许认为(i,j)和(j,i)的匹配结果是对称的（或可接受双向匹配结果），可以只计算上三角/下三角区域，再把结果复制到对称位置，直接减少近一半的计算量：

import cv2 as cv
import numpy as np
import pandas as pd
from tqdm import tqdm

bf = cv.BFMatcher(cv.NORM_L1)
n = len(descriptors_1)
result = np.full((n, n), np.nan)

for i in tqdm(range(n)):
    des1 = descriptors_1[i]
    for j in range(i + 1, n):
        des2 = descriptors_1[j]
        # 计算i->j的匹配数
        matches_ij = bf.knnMatch(des1, des2, k=2)
        count_ij = sum(1 for m, n_match in matches_ij if m.distance < 0.8 * n_match.distance)
        # 计算j->i的匹配数（若不需要双向可省略，直接复制count_ij）
        matches_ji = bf.knnMatch(des2, des1, k=2)
        count_ji = sum(1 for m, n_match in matches_ji if m.distance < 0.8 * n_match.distance)
        result[i, j] = count_ij
        result[j, i] = count_ji

df = pd.DataFrame(result)

内容的提问来源于stack exchange，提问作者Alberto__23