嘿，这个问题我之前做模板匹配的时候也踩过坑！单个目标跑出一堆邻近的匹配点，确实挺烦的，除了你自己写的剔除逻辑，还有几个更直接、鲁棒性更强的方案，给你分享下：

1. 用非极大值抑制（NMS）——最通用的解决方案 #

这是计算机视觉里处理重复检测的标准操作，核心思路就是：保留每个区域里得分最高的匹配点，剔除那些和它重叠度高、得分低的候选点。比单纯按距离剔除更合理，因为它考虑了模板的尺寸（用交并比IOU判断重叠，而不是单纯的像素距离）。

给你一个现成的Python实现，直接就能用：

import numpy as np

def non_max_suppression(boxes, scores, iou_threshold=0.5):
    """
    非极大值抑制，剔除重叠的匹配框
    参数：
        boxes: 匹配框列表，每个元素为 [x, y, w, h]（x,y是左上角坐标，w,h是模板宽高）
        scores: 每个匹配框的得分（模板匹配的返回值）
        iou_threshold: 重叠阈值，超过这个值的框会被剔除
    返回：
        去重后的匹配框列表
    """
    if len(boxes) == 0:
        return []
    
    # 转换为numpy数组方便计算
    boxes = np.array(boxes)
    scores = np.array(scores)
    
    # 计算每个框的右下角坐标
    x1 = boxes[:, 0]
    y1 = boxes[:, 1]
    x2 = boxes[:, 0] + boxes[:, 2]
    y2 = boxes[:, 1] + boxes[:, 3]
    
    # 按得分从高到低排序
    sorted_indices = np.argsort(scores)[::-1]
    
    keep = []
    while len(sorted_indices) > 0:
        # 保留当前得分最高的框
        current_idx = sorted_indices[0]
        keep.append(current_idx)
        
        # 计算当前框和剩余框的IOU
        overlap_x1 = np.maximum(x1[current_idx], x1[sorted_indices[1:]])
        overlap_y1 = np.maximum(y1[current_idx], y1[sorted_indices[1:]])
        overlap_x2 = np.minimum(x2[current_idx], x2[sorted_indices[1:]])
        overlap_y2 = np.minimum(y2[current_idx], y2[sorted_indices[1:]])
        
        # 计算重叠区域的宽高
        overlap_w = np.maximum(0.0, overlap_x2 - overlap_x1)
        overlap_h = np.maximum(0.0, overlap_y2 - overlap_y1)
        overlap_area = overlap_w * overlap_h
        
        # 计算当前框和剩余框的面积
        current_area = (x2[current_idx] - x1[current_idx]) * (y2[current_idx] - y1[current_idx])
        other_areas = (x2[sorted_indices[1:]] - x1[sorted_indices[1:]]) * (y2[sorted_indices[1:]] - y1[sorted_indices[1:]])
        
        # 计算IOU
        iou = overlap_area / (current_area + other_areas - overlap_area)
        
        # 只保留IOU小于阈值的框的索引
        sorted_indices = sorted_indices[1:][iou <= iou_threshold]
    
    # 返回去重后的匹配框
    return boxes[keep].tolist()

使用方法： #

1. 先通过模板匹配得到所有得分超过你设定阈值的点：

   import cv2
   
   # 加载原图和模板
   img = cv2.imread('your_image.jpg', 0)
   template = cv2.imread('your_template.jpg', 0)
   w, h = template.shape[::-1]
   
   # 用归一化相关系数匹配（推荐用这个，得分更稳定）
   res = cv2.matchTemplate(img, template, cv2.TM_CCOEFF_NORMED)
   threshold = 0.8  # 根据你的情况调整
   loc = np.where(res >= threshold)
   

2. 把这些匹配点转换成[x, y, w, h]的框格式，同时收集对应的得分：

   boxes = []
   scores = []
   for pt in zip(*loc[::-1]):
       boxes.append([pt[0], pt[1], w, h])
       scores.append(res[pt[1], pt[0]])
   

3. 调用NMS函数去重：

   filtered_boxes = non_max_suppression(boxes, scores, iou_threshold=0.3)
   

4. 最后绘制去重后的结果：

   for box in filtered_boxes:
       x, y, w, h = box
       cv2.rectangle(img, (x, y), (x+w, y+h), (0, 255, 0), 2)
   cv2.imshow('Result', img)
   cv2.waitKey(0)
   

2. 调高匹配阈值——快速解决的简单方法 #

如果你的目标和模板匹配度很高，可以直接把匹配阈值调得更严格（比如从0.8调到0.9），这样只有那些得分极高的匹配点会被保留，自然就减少了邻近的低得分重复点。不过这个方法的缺点是，如果有些目标因为角度、光照等原因匹配得分稍低，可能会被漏掉，适合目标比较规整、匹配度高的场景。

3. 选择更合适的匹配方法 #

不同的模板匹配方法稳定性差异很大，推荐优先使用归一化的匹配方法：

• cv2.TM_CCOEFF_NORMED
• cv2.TM_CCORR_NORMED
• cv2.TM_SQDIFF_NORMED

这些方法对图像的亮度、对比度变化更鲁棒，返回的得分范围在0-1之间（或0到某个固定值），更容易设置合理的阈值，能从源头减少假阳性的重复匹配点。

最后说一句 #

你自己写的剔除相近位置的函数其实是NMS的简化版，而标准NMS考虑了模板的尺寸，用IOU判断重叠，在复杂场景下鲁棒性更强，是工业界常用的解决方案。如果是多模板的情况，你可以针对每个模板的匹配结果分别做NMS，也可以把所有模板的匹配框放在一起统一处理，根据你的需求来就行。

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