计算机视觉（7）基于NMS算法从一副图像中找出相同的目标物体

NMS算法（NonMaximumSuppression）：

非极大值抑制（NMS）顾名思义就是抑制不是极大值的元素，搜索局部的极大值。这个局部代表的是一个邻域，邻域有两个参数可变，一是邻域的维数，二是邻域的大小。这里不讨论通用的NMS算法，而是用于在目标检测中用于提取分数最高的窗口的。

例如在行人检测中，滑动窗口经提取特征，经分类器分类识别后，每个窗口都会得到一个分数。但是滑动窗口会导致很多窗口与其他窗口存在包含或者大部分交叉的情况。这时就需要用到NMS来选取那些邻域里分数最高（是行人的概率最大），并且抑制那些分数低的窗口。

实现步骤如下：

1. 设定目标框的置信度阈值，常用的阈值是0.5左右

2. 根据置信度降序排列候选框列表

3. 选取置信度最高的框A添加到输出列表，并将其从候选框列表中删除

4. 计算A与候选框列表中的所有框的IoU值，删除大于阈值的候选框

5. 重复上述过程，直到候选框列表为空，返回输出列表

 

import cv2
import numpy as np
import os
import time
import matplotlib.pyplot as plt
import copy



def NMS(boxes, overlapThresh = 0.4):
    #return an empty list, if no boxes given
    if len(boxes) == 0:
        return []
    x1 = boxes[:, 0]  # x coordinate of the top-left corner
    y1 = boxes[:, 1]  # y coordinate of the top-left corner
    x2 = boxes[:, 2]  # x coordinate of the bottom-right corner
    y2 = boxes[:, 3]  # y coordinate of the bottom-right corner
    # compute the area of the bounding boxes and sort the bounding
    # boxes by the bottom-right y-coordinate of the bounding box
    areas = (x2 - x1 + 1) * (y2 - y1 + 1) # We have a least a box of one pixel, therefore the +1
    indices = np.arange(len(x1))
    for i,box in enumerate(boxes):
        temp_indices = indices[indices!=i]
        xx1 = np.maximum(box[0], boxes[temp_indices,0])
        yy1 = np.maximum(box[1], boxes[temp_indices,1])
        xx2 = np.minimum(box[2], boxes[temp_indices,2])
        yy2 = np.minimum(box[3], boxes[temp_indices,3])
        w = np.maximum(0, xx2 - xx1 + 1)
        h = np.maximum(0, yy2 - yy1 + 1)
        # compute the ratio of overlap
        overlap = (w * h) / areas[temp_indices]
        if np.any(overlap) > treshold:
            indices = indices[indices != i]
    return boxes[indices].astype(int)

def bounding_boxes(image, template):
    (tH, tW) = template.shape[:2]             # getting height and width of template
    imageGray = cv2.cvtColor(image, 0)        # convert the image to grayscale
    templateGray = cv2.cvtColor(template, 0)  # convert the template to grayscale

    result = cv2.matchTemplate(imageGray, templateGray, cv2.TM_CCOEFF_NORMED)  # template matching return the correlatio
    print(result)
    print('--------------')
    (y1, x1) = np.where(result >= treshold)  # object is detected, where the correlation is above the treshold

    boxes = np.zeros((len(y1), 4))      # construct array of zeros
    x2 = x1 + tW                       # calculate x2 with the width of the template
    y2 = y1 + tH                       # calculate y2 with the height of the template
    # fill the bounding boxes array
    boxes[:, 0] = x1
    boxes[:, 1] = y1
    boxes[:, 2] = x2
    boxes[:, 3] = y2
    return boxes.astype(int)

def draw_bounding_boxes(image,boxes):
    for box in boxes:

    return image

if __name__ == "__main__":
    # time.sleep(2)
    treshold = 0.5837 # the correlation treshold, in order for an object to be recognised
    # template_diamonds = plt.imread(r"cones/ace_diamonds_plant_template.jpg")
    template_diamonds = plt.imread(r"cones/22.jpg")

    ace_diamonds_rotated = plt.imread(r"cones/11.jpg")

    boxes_redundant = bounding_boxes(ace_diamonds_rotated, template_diamonds) # calculate bounding boxes
    print(len(boxes_redundant))
    boxes = NMS(boxes_redundant)   # remove redundant bounding boxes

    print(boxes)
    overlapping_BB_image = draw_bounding_boxes(ace_diamonds_rotated,boxes_redundant)  # draw image with all redundant bounding boxes
    segmented_image = draw_bounding_boxes(ace_diamonds_rotated,boxes)           # draw the bounding boxes onto the image
    plt.imshow(overlapping_BB_image)
    plt.show()
    plt.imshow(segmented_image)
    plt.show()