在大图像中测试对象检测算法时，我们将检测到的边界框与给定的地面实况矩形坐标进行对比。
根据 Pascal VOC 挑战，有这样的：
如果预测的边界框与真实边界框重叠超过 50%，则认为该边界框是正确的，否则该边界框被认为是误报检测。多次检测会受到惩罚。如果一个系统预测了几个与单个真实边界框重叠的边界框，则只有一个预测被认为是正确的，其他预测被认为是误报。
这意味着我们需要计算重叠的百分比。这是否意味着检测到的边界框覆盖了地面实况框 50%？还是 50% 的边界框被地面实况框吸收？
我已经搜索过，但我还没有找到一个标准算法——这很令人惊讶，因为我认为这在计算机视觉中很常见。（我是新手）。我错过了吗？有谁知道这类问题的标准算法是什么？
对于轴对齐的边界框，它相对简单。“轴对齐”表示边界框不旋转；或者换句话说，框线平行于轴。下面是计算两个轴对齐边界框的 IoU 的方法。
def get_iou(bb1, bb2):
"""
Calculate the Intersection over Union (IoU) of two bounding boxes.
Parameters
----------
bb1 : dict
Keys: {'x1', 'x2', 'y1', 'y2'}
The (x1, y1) position is at the top left corner,
the (x2, y2) position is at the bottom right corner
bb2 : dict
Keys: {'x1', 'x2', 'y1', 'y2'}
The (x, y) position is at the top left corner,
the (x2, y2) position is at the bottom right corner
Returns
-------
float
in [0, 1]
"""
assert bb1['x1'] < bb1['x2']
assert bb1['y1'] < bb1['y2']
assert bb2['x1'] < bb2['x2']
assert bb2['y1'] < bb2['y2']
# determine the coordinates of the intersection rectangle
x_left = max(bb1['x1'], bb2['x1'])
y_top = max(bb1['y1'], bb2['y1'])
x_right = min(bb1['x2'], bb2['x2'])
y_bottom = min(bb1['y2'], bb2['y2'])
if x_right < x_left or y_bottom < y_top:
return 0.0
# The intersection of two axis-aligned bounding boxes is always an
# axis-aligned bounding box
intersection_area = (x_right - x_left) * (y_bottom - y_top)
# compute the area of both AABBs
bb1_area = (bb1['x2'] - bb1['x1']) * (bb1['y2'] - bb1['y1'])
bb2_area = (bb2['x2'] - bb2['x1']) * (bb2['y2'] - bb2['y1'])
# compute the intersection over union by taking the intersection
# area and dividing it by the sum of prediction + ground-truth
# areas - the interesection area
iou = intersection_area / float(bb1_area + bb2_area - intersection_area)
assert iou >= 0.0
assert iou <= 1.0
return iou
图片来自这个答案
如果您使用屏幕（像素）坐标，投票率最高的答案会出现数学错误！几周前我提交了一份编辑，为所有读者提供了很长的解释，以便他们理解数学。但是那个编辑没有被审稿人理解并被删除，所以我再次提交了相同的编辑，但这次更简要地总结了。（更新：拒绝 2vs1，因为它被认为是“重大变化”，呵呵）。
所以我将在这个单独的答案中用它的数学来完全解释这个大问题。
所以，是的，一般来说，票数最高的答案是正确的，是计算 IoU 的好方法。但是（正如其他人也指出的那样）它的数学对于计算机屏幕是完全不正确的。你不能只做(x2 - x1) * (y2 - y1)，因为这不会产生正确的面积计算。屏幕索引从像素开始，0,0到width-1,height-1. 屏幕坐标的范围是inclusive:inclusive（包括两端），所以像素坐标的范围 from 0to10实际上是 11 个像素宽，因为它包括0 1 2 3 4 5 6 7 8 9 10（11 个项目）。因此，要计算屏幕坐标的面积，您必须因此在每个维度上加上 +1，如下所示(x2 - x1 + 1) * (y2 - y1 + 1)：
inclusive:exclusive如果您在范围不包含在内的其他坐标系0中工作（例如10表示“元素 0-9 但不是 10”的系统），则不需要额外的数学运算。但最有可能的是，您正在处理基于像素的边界框。好吧，屏幕坐标从那里开始0,0并从那里上升。
屏幕1920x1080的索引从0（第一个像素）到1919（水平的最后一个像素）和从0（第一个像素）到1079（垂直的最后一个像素）。
因此，如果我们在“像素坐标空间”中有一个矩形，要计算它的面积，我们必须在每个方向上加 1。否则，我们得到面积计算的错误答案。
想象一下，我们的1920x1080屏幕有一个基于像素坐标的矩形left=0,top=0,right=1919,bottom=1079（覆盖整个屏幕上的所有像素）。
好吧，我们知道1920x1080像素就是2073600像素，这是1080p屏幕的正确区域。
但是如果数学错误area = (x_right - x_left) * (y_bottom - y_top)，我们会得到：(1919 - 0) * (1079 - 0)= 1919 * 1079=2070601像素！那是错误的！
这就是为什么我们必须添加+1到每个计算中，这给了我们以下更正的数学：area = (x_right - x_left + 1) * (y_bottom - y_top + 1)，给我们：(1919 - 0 + 1) * (1079 - 0 + 1)= 1920 * 1080=2073600像素！这确实是正确的答案！
最简短的总结是：像素坐标范围是inclusive:inclusive，所以如果我们想要像素坐标范围的真实区域，我们必须添加+ 1到每个轴。
有关为什么+1需要的更多详细信息，请参阅 Jindil 的回答：https ://stackoverflow.com/a/51730512/8874388
以及这篇 pyimagesearch 文章： https ://www.pyimagesearch.com/2016/11/07/intersection-over-union-iou-for-object-detection/
而这个 GitHub 评论： https ://github.com/AlexeyAB/darknet/issues/3995#issuecomment-535697357
由于固定数学没有被批准，任何从投票最多的答案复制代码的人都希望看到这个答案，并且能够自己修复它，只需复制下面的错误修复断言和面积计算行，它们已经固定inclusive:inclusive（像素）坐标范围：
assert bb1['x1'] <= bb1['x2']
assert bb1['y1'] <= bb1['y2']
assert bb2['x1'] <= bb2['x2']
assert bb2['y1'] <= bb2['y2']
................................................
# The intersection of two axis-aligned bounding boxes is always an
# axis-aligned bounding box.
# NOTE: We MUST ALWAYS add +1 to calculate area when working in
# screen coordinates, since 0,0 is the top left pixel, and w-1,h-1
# is the bottom right pixel. If we DON'T add +1, the result is wrong.
intersection_area = (x_right - x_left + 1) * (y_bottom - y_top + 1)
# compute the area of both AABBs
bb1_area = (bb1['x2'] - bb1['x1'] + 1) * (bb1['y2'] - bb1['y1'] + 1)
bb2_area = (bb2['x2'] - bb2['x1'] + 1) * (bb2['y2'] - bb2['y1'] + 1)
一种适用于任何多边形的简单方法。
（图片未按比例绘制）
from shapely.geometry import Polygon
def calculate_iou(box_1, box_2):
poly_1 = Polygon(box_1)
poly_2 = Polygon(box_2)
iou = poly_1.intersection(poly_2).area / poly_1.union(poly_2).area
return iou
box_1 = [[511, 41], [577, 41], [577, 76], [511, 76]]
box_2 = [[544, 59], [610, 59], [610, 94], [544, 94]]
print(calculate_iou(box_1, box_2))
结果将是0.138211...什么意思13.82%。
注意：shapely 库中坐标系的原点是左下角，而计算机图形中的坐标系原点是左上角。这种差异不会影响 IoU 计算，但如果您进行其他类型的计算，此信息可能会有所帮助。
您可以计算torchvision如下。bbox 的格式为[x1, y1, x2, y2].
import torch
import torchvision.ops.boxes as bops
box1 = torch.tensor([[511, 41, 577, 76]], dtype=torch.float)
box2 = torch.tensor([[544, 59, 610, 94]], dtype=torch.float)
iou = bops.box_iou(box1, box2)
# tensor([[0.1382]])
对于相交距离，我们不应该加一个+1以便有
intersection_area = (x_right - x_left + 1) * (y_bottom - y_top + 1)
（AABB 也一样）
喜欢这个pyimage 搜索帖子
我同意(x_right - x_left) x (y_bottom - y_top)在数学中使用点坐标，但由于我们处理的是像素，所以我认为不同。
考虑一个一维示例：
编辑：我最近知道这是一种“小方块”方法。
但是，如果您将像素视为点样本（即边界框角将位于像素的中心，显然在 matplotlib 中），那么您不需要 +1。
请参阅此评论和此插图
import numpy as np
def box_area(arr):
# arr: np.array([[x1, y1, x2, y2]])
width = arr[:, 2] - arr[:, 0]
height = arr[:, 3] - arr[:, 1]
return width * height
def _box_inter_union(arr1, arr2):
# arr1 of [N, 4]
# arr2 of [N, 4]
area1 = box_area(arr1)
area2 = box_area(arr2)
# Intersection
top_left = np.maximum(arr1[:, :2], arr2[:, :2]) # [[x, y]]
bottom_right = np.minimum(arr1[:, 2:], arr2[:, 2:]) # [[x, y]]
wh = bottom_right - top_left
# clip: if boxes not overlap then make it zero
intersection = wh[:, 0].clip(0) * wh[:, 1].clip(0)
#union
union = area1 + area2 - intersection
return intersection, union
def box_iou(arr1, arr2):
# arr1[N, 4]
# arr2[N, 4]
# N = number of bounding boxes
assert(arr1[:, 2:] > arr[:, :2]).all()
assert(arr2[:, 2:] > arr[:, :2]).all()
inter, union = _box_inter_union(arr1, arr2)
iou = inter / union
print(iou)
box1 = np.array([[10, 10, 80, 80]])
box2 = np.array([[20, 20, 100, 100]])
box_iou(box1, box2)
参考：https ://pytorch.org/vision/stable/_modules/torchvision/ops/boxes.html#nms
在下面的片段中，我沿着第一个框的边缘构造了一个多边形。然后我使用 Matplotlib 将多边形剪辑到第二个框。生成的多边形包含四个顶点，但是我们只对左上角和右下角感兴趣，所以我取坐标的最大值和最小值，得到一个边界框，返回给用户。
import numpy as np
from matplotlib import path, transforms
def clip_boxes(box0, box1):
path_coords = np.array([[box0[0, 0], box0[0, 1]],
[box0[1, 0], box0[0, 1]],
[box0[1, 0], box0[1, 1]],
[box0[0, 0], box0[1, 1]]])
poly = path.Path(np.vstack((path_coords[:, 0],
path_coords[:, 1])).T, closed=True)
clip_rect = transforms.Bbox(box1)
poly_clipped = poly.clip_to_bbox(clip_rect).to_polygons()[0]
return np.array([np.min(poly_clipped, axis=0),
np.max(poly_clipped, axis=0)])
box0 = np.array([[0, 0], [1, 1]])
box1 = np.array([[0, 0], [0.5, 0.5]])
print clip_boxes(box0, box1)
这种方法怎么样？可以扩展到任意数量的联合形状
surface = np.zeros([1024,1024])
surface[1:1+10, 1:1+10] += 1
surface[100:100+500, 100:100+100] += 1
unionArea = (surface==2).sum()
print(unionArea)