Rotated IoU 计算

最新推荐文章于 2023-11-30 18:10:38 发布
最新推荐文章于 2023-11-30 18:10:38 发布
阅读量6.3k 收藏 70
点赞数 24
分类专栏： 目标检测模块
原文链接：https://blog.csdn.net/Hoooo_233/article/details/108308795
版权

文章目录

简介

在目标检测的领域，基于Anchor的方法需要对Anchor分配正负样本的标签。通常，对于axis-aligned的anchor和ground truth，可以直接通过 [top left right down]四个值计算他们之间的重叠面积。但是针对于旋转的矩形框，这个问题就变得尤为复杂。

我参考了3D目标检测论文SECOND的源码，来尝试解释一下如何计算旋转包围盒的重叠面积。

代码全部来自second.pytorch这个项目的早期版本，去掉了numba/cuda加速的代码。

旋转包围盒的编码方式

作者代码使用了两种方式

1、通过包围盒中心点位置，尺度以及角度来编码rbbox

rbbox = [x, y, x_d (w), y_d (h), angle]

2、通过包围盒的4个顶点corners来编码

矢量的旋转公式

在这里插入图片描述

包围盒转化为角点

在这里插入图片描述
如图，rbbox为绿色的包围盒，是原始黑色包围盒通过逆时针旋转 θ 角度得到。分析 A ’ 的真实坐标：
在这里插入图片描述

代码表示

下段代码将[x, y, x_d, y_d, angle]转化为顺时针方方向表示的顶点坐标[x0, y0, x1, y1, x2, y2, x3, y3]

import math
def rbbox_to_corners(rbbox):
    # generate clockwise corners and rotate it clockwise
    # 顺时针方向返回角点位置
    cx, cy, x_d, y_d, angle = rbbox
    a_cos = math.cos(angle)
    a_sin = math.sin(angle)
    corners_x = [-x_d / 2, -x_d / 2, x_d / 2, x_d / 2]
    corners_y = [-y_d / 2, y_d / 2, y_d / 2, -y_d / 2]
    corners = [0] * 8
    for i in range(4):
        corners[2 *
                i] = a_cos * corners_x[i] + \
                     a_sin * corners_y[i] + cx
        corners[2 * i +
                1] = -a_sin * corners_x[i] + \
                     a_cos * corners_y[i] + cy
    return corners

测试一下结果：

rbbox = [0, 0, 2, 4, math.pi / 2]
corners = rbbox_to_corners(rbbox)
print([round(_) for _ in corners])
# [-2, 1, 2, 1, 2, -1, -2, -1]

相交区域的特点

两个四边形(矩形)，求交叠面积，可以先求出相交的多边形(Polygon)的顶点, 构成多边形的顶点可由两种类型的点构成：

原始四边形的顶点
四边形的边相交产生的交点

对应问题为：

判断点在四边形内
判断线段的交点

点在四边形(矩形)内

如图所示，四边形(矩形)通过ABCD四个顶点表示，可以使用较强的规则判断P在矩形内，即AP在AB 的投影在线段AB上，在AD的投影在线段AD上。
在这里插入图片描述

点积的物理意义

两个矢量的点积是标量，点积满足交换律：
在这里插入图片描述所以代码的思路就是，通过点积得到投影长度，通过判断投影长度确定点在矩形框内。

代码

SECOND函数为 point_in_quadrilateral

def point_in_quadrilateral(pt_x, pt_y, corners):
    ab0 = corners[2] - corners[0]
    ab1 = corners[3] - corners[1]

    ad0 = corners[6] - corners[0]
    ad1 = corners[7] - corners[1]

    ap0 = pt_x - corners[0]
    ap1 = pt_y - corners[1]

    abab = ab0 * ab0 + ab1 * ab1
    abap = ab0 * ap0 + ab1 * ap1
    adad = ad0 * ad0 + ad1 * ad1
    adap = ad0 * ap0 + ad1 * ap1

    return abab >= abap and abap >= 0 and adad >= adap and adap >= 0

线段交点

判断线段是否相交

参考：判断线段相交的最简方法

对于两个直线是否相交，一种方法是计算线段斜率，首先确定不平行，然后联立方程，计算交点坐标，最后运用定比分点公式，判断交点是否在线段上。但是使用斜率和定比分点，可能会出现精度丢失的现象，同时浮点数运算耗时。
在这里插入图片描述
上图可以表示两个线段位置的所有可能情况。定义direct(a, b) 为向量有序对的旋转方向。其旋转方向为 使 a 能够旋转一个小于 180 度的角并与 b 重合的方向，简记为 direct(a, b)。若 a 和 b 反向共线，则旋转方向取任意值。

则上图三种情况可以概括为：

  1. direct(AC, AD) 和 direct(BC, BD) 为顺时针，direct(CA, CB) 为逆时针，direct(DA,DB)为顺时针
  2. direct(AC, AD)顺时针， direct(BC, BD)为任意方向，direct(CA, CB)为逆时针，direct(DA,DB) 为顺时针
  3. direct(AC, AD) 和 direct(DA, DB) 为顺时针，direct(BC, BD) 和 direct(CA, CB)为逆时针

可以得知，两条线段相交的充要条件是direct(AC, AD) != direct(BC, BD) 和 direct(CA, CB) != direct(DA, DB)
在这里插入图片描述

相交后转化为直线交点

Wiki [Line–line intersection](https://en.wikipedia.org/wiki/Line%E2%80%93line_intersection)
Using homogeneous coordinates

在这里插入图片描述

代码

def line_segment_intersection(pts1, pts2, i, j):
    # pts1, pts2 为corners
    # i j 分别表示第几个交点，取其和其后一个点构成的线段
    # 返回为 tuple(bool, pts) bool=True pts为交点
    A, B, C, D, ret = [0, 0], [0, 0], [0, 0], [0, 0], [0, 0]
    A[0] = pts1[2 * i]
    A[1] = pts1[2 * i + 1]

    B[0] = pts1[2 * ((i + 1) % 4)]
    B[1] = pts1[2 * ((i + 1) % 4) + 1]

    C[0] = pts2[2 * j]
    C[1] = pts2[2 * j + 1]

    D[0] = pts2[2 * ((j + 1) % 4)]
    D[1] = pts2[2 * ((j + 1) % 4) + 1]
    BA0 = B[0] - A[0]
    BA1 = B[1] - A[1]
    DA0 = D[0] - A[0]
    CA0 = C[0] - A[0]
    DA1 = D[1] - A[1]
    CA1 = C[1] - A[1]
    # 叉乘判断方向
    acd = DA1 * CA0 > CA1 * DA0
    bcd = (D[1] - B[1]) * (C[0] - B[0]) > (C[1] - B[1]) * (D[0] - B[0])
    if acd != bcd:
        abc = CA1 * BA0 > BA1 * CA0
        abd = DA1 * BA0 > BA1 * DA0
        # 判断方向
        if abc != abd:
            DC0 = D[0] - C[0]
            DC1 = D[1] - C[1]
            ABBA = A[0] * B[1] - B[0] * A[1]
            CDDC = C[0] * D[1] - D[0] * C[1]
            DH = BA1 * DC0 - BA0 * DC1
            Dx = ABBA * DC0 - BA0 * CDDC
            Dy = ABBA * DC1 - BA1 * CDDC
            ret[0] = Dx / DH
            ret[1] = Dy / DH
            return True, ret
    return False, ret

测试结果：

if __name__ == '__main__':
    rbbox1 = [0, 0, 2, 4, 0]
    rbbox2 = [0, 0, 4, 2, 0]
    corners1 = rbbox_to_corners(rbbox1)
    corners2 = rbbox_to_corners(rbbox2)
    for i in range(4):
        for j in range(4):
            ret, pts = line_segment_intersection(corners1, corners2, i, j)
            if ret:
                print('Px: {}, Py: {}'.format(*pts))
"""
Px: -1.0, Py: 1.0
Px: -1.0, Py: -1.0
Px: 1.0, Py: 1.0
Px: 1.0, Py: -1.0
"""

计算相交区域面积

当有了构成相交区域多边行的顶点后，可以通过以下两部分计算相交区域的面积：

  1. 将顶点按照顺时针或者逆时针排序
  2. 三角剖分计算面积

顶点排序

在凸多边形内部取一点，与顶点连线，可以通过连线与坐标轴构成的角度排序。操作如下

  1. 计算所有顶点的横纵坐标均值，记作中心点
  2. 计算中心点到每个单位向量[vx, vy]。
  3. 以x轴正方向为其实遍，按照顺时针方向扫描360度，对扫描到的点进行排序

在这里插入图片描述

顶点排序代码

def sort_vertex_in_convex_polygon(int_pts, num_of_inter):
    def _cmp(pt, center):
        vx = pt[0] - center[0]
        vy = pt[1] - center[1]
        d = math.sqrt(vx * vx + vy * vy)
        vx /= d
        vy /= d
        if vy < 0:
            vx = -2 - vx
        return vx

    if num_of_inter > 0:
        center = [0, 0]
        for i in range(num_of_inter):
            center[0] += int_pts[i][0]
            center[1] += int_pts[i][1]
        center[0] /= num_of_inter
        center[1] /= num_of_inter
        int_pts.sort(key=lambda x: _cmp(x, center))

简易版三角剖分

将多边形转化为多个三角形面积之和，具体操作为固定一个点，按照顺时针顺序依次选择剩下的2个点，计算三角形面积(利用叉积) 最后将三角形面积求和。

def area(int_pts, num_of_inter):
    def _trangle_area(a, b, c):
        return ((a[0] - c[0]) * (b[1] - c[1]) - (a[1] - c[1]) *
                (b[0] - c[0])) / 2.0

    area_val = 0.0
    for i in range(num_of_inter - 2):
        area_val += abs(
            _trangle_area(int_pts[0], int_pts[i + 1],
                          int_pts[i + 2]))
    return area_val

所有代码

主要是计算两个矩形框包围区域的面积

import math

#包围盒转化为角点
def rbbox_to_corners(rbbox):
    # generate clockwise corners and rotate it clockwise
    # 顺时针方向返回角点位置
    cx, cy, x_d, y_d, angle = rbbox
    a_cos = math.cos(angle)
    a_sin = math.sin(angle)
    corners_x = [-x_d / 2, -x_d / 2, x_d / 2, x_d / 2]
    corners_y = [-y_d / 2, y_d / 2, y_d / 2, -y_d / 2]
    corners = [0] * 8
    for i in range(4):
        corners[2 *
                i] = a_cos * corners_x[i] + \
                     a_sin * corners_y[i] + cx
        corners[2 * i +
                1] = -a_sin * corners_x[i] + \
                     a_cos * corners_y[i] + cy
    return corners

# 点在四边形(矩形)内?
def point_in_quadrilateral(pt_x, pt_y, corners):
    ab0 = corners[2] - corners[0]
    ab1 = corners[3] - corners[1]

    ad0 = corners[6] - corners[0]
    ad1 = corners[7] - corners[1]

    ap0 = pt_x - corners[0]
    ap1 = pt_y - corners[1]

    abab = ab0 * ab0 + ab1 * ab1
    abap = ab0 * ap0 + ab1 * ap1
    adad = ad0 * ad0 + ad1 * ad1
    adap = ad0 * ap0 + ad1 * ap1

    return abab >= abap and abap >= 0 and adad >= adap and adap >= 0

# 相交后转化为直线交点
def line_segment_intersection(pts1, pts2, i, j):
    # pts1, pts2 为corners
    # i j 分别表示第几个交点，取其和其后一个点构成的线段
    # 返回为 tuple(bool, pts) bool=True pts为交点
    A, B, C, D, ret = [0, 0], [0, 0], [0, 0], [0, 0], [0, 0]
    A[0] = pts1[2 * i]
    A[1] = pts1[2 * i + 1]

    B[0] = pts1[2 * ((i + 1) % 4)]
    B[1] = pts1[2 * ((i + 1) % 4) + 1]

    C[0] = pts2[2 * j]
    C[1] = pts2[2 * j + 1]

    D[0] = pts2[2 * ((j + 1) % 4)]
    D[1] = pts2[2 * ((j + 1) % 4) + 1]
    BA0 = B[0] - A[0]
    BA1 = B[1] - A[1]
    DA0 = D[0] - A[0]
    CA0 = C[0] - A[0]
    DA1 = D[1] - A[1]
    CA1 = C[1] - A[1]
    # 叉乘判断方向
    acd = DA1 * CA0 > CA1 * DA0
    bcd = (D[1] - B[1]) * (C[0] - B[0]) > (C[1] - B[1]) * (D[0] - B[0])
    if acd != bcd:
        abc = CA1 * BA0 > BA1 * CA0
        abd = DA1 * BA0 > BA1 * DA0
        # 判断方向
        if abc != abd:
            DC0 = D[0] - C[0]
            DC1 = D[1] - C[1]
            ABBA = A[0] * B[1] - B[0] * A[1]
            CDDC = C[0] * D[1] - D[0] * C[1]
            DH = BA1 * DC0 - BA0 * DC1
            Dx = ABBA * DC0 - BA0 * CDDC
            Dy = ABBA * DC1 - BA1 * CDDC
            ret[0] = Dx / DH
            ret[1] = Dy / DH
            return True, ret
    return False, ret

# 顶点排序
def sort_vertex_in_convex_polygon(int_pts, num_of_inter):
    def _cmp(pt, center):
        vx = pt[0] - center[0]
        vy = pt[1] - center[1]
        d = math.sqrt(vx * vx + vy * vy)
        vx /= d
        vy /= d
        if vy < 0:
            vx = -2 - vx
        return vx

    if num_of_inter > 0:
        center = [0, 0]
        for i in range(num_of_inter):
            center[0] += int_pts[i][0]
            center[1] += int_pts[i][1]
        center[0] /= num_of_inter
        center[1] /= num_of_inter
        int_pts.sort(key=lambda x: _cmp(x, center))

# 将多边形转化为多个三角形面积之和
def area(int_pts, num_of_inter):
    def _trangle_area(a, b, c):
        return ((a[0] - c[0]) * (b[1] - c[1]) - (a[1] - c[1]) *
                (b[0] - c[0])) / 2.0

    area_val = 0.0
    for i in range(num_of_inter - 2):
        area_val += abs(
            _trangle_area(int_pts[0], int_pts[i + 1],
                          int_pts[i + 2]))
    return area_val


if __name__ == '__main__':
    rbbox1 = [0, 0, 2, 4, 0]
    rbbox2 = [0, 0, 4, 2, 0]
    corners1 = rbbox_to_corners(rbbox1)
    corners2 = rbbox_to_corners(rbbox2)
    pts, num_pts = [], 0
    for i in range(4):
        point = [corners1[2 * i], corners1[2 * i + 1]]
        if point_in_quadrilateral(point[0], point[1],
                                  corners2):
            num_pts += 1
            pts.append(point)
    for i in range(4):
        point = [corners2[2 * i], corners2[2 * i + 1]]
        if point_in_quadrilateral(point[0], point[1],
                                  corners1):
            num_pts += 1
            pts.append(point)
    for i in range(4):
        for j in range(4):
            ret, point = line_segment_intersection(corners1, corners2, i, j)
            if ret:
                num_pts += 1
                pts.append(point)
    sort_vertex_in_convex_polygon(pts, num_pts)
    polygon_area = area(pts, num_pts)
    print('area: {}'.format(polygon_area))
THE@JOKER
关注
  • 24
    点赞
  • 踩
  • 70
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
[CV] Rotated IoU 如何计算带旋转矩形之间的重叠面积1
08-03
# generate clockwise corners and rotate it clockwise# [-2, 1, 2, 1, 2, -1, -2, -
计算机视觉：两个旋转检测框bbox的IoU计算
博学而笃志，切问而近思。
06-12 1606
计算机视觉：两个旋转检测框bbox的IoU计算
Rotated_IoU 计算
W1995S的博客
04-09 1292
两个旋转矩形的IOU计算方法 # 中心点 矩形的w h, 旋转的theta（角度，不是弧度） def iou_rotate_calculate(boxes1, boxes2): area1 = boxes1[:, 2] * boxes1[:, 3] area2 = boxes2[:, 2] * boxes2[:, 3] ious = [] for i, box1 in enumerate(boxes1): temp_ious = [] r1 =
旋转框（obb）目标检测计算iou的方法
最新发布
athrunsunny的博客
11-30 1030
首先先定义一组多边形，这里的数据来自前后帧的检测结果其中的每个列表元素代表一个多边形，列表中包含四个元素，分别代表多边形的顶点坐标。
Python计算机视觉里的IOU计算实例
09-18
今天小编就为大家分享一篇Python计算机视觉里的IOU计算实例，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
如何计算旋转框的IOU
slamer111的博客
05-09 1775
面试旋转IOU的计算
【深度学习】目标检测mAP计算及旋转检测IOU
qq_39165617的博客
01-03 1690
传统目标检测 这里仅作简要分析，源码地址（代码有些许改变）https://github.com/Cartucho/mAP/blob/master/main.py 1.文件夹分为两个，真实标签及检测标签 两个文件夹中的文件均为txt文件，每张图片对应一个txt文件，其中真值标签，每一行一个目标，类别名+坐标值 其中检测标签，每一行一个目标，类别名+置信度+坐标值 mAP计算步骤： 1.将所有真值标签读取并保存json文件，字典数据有以下3个， 按图片名划分文件夹保存 2.遍历所有文件，按照类别名保存b
任意两个旋转矩形的IOU计算方法
hajungong007的博客
07-31 6707
方法一： import cv2 import numpy as np image = cv2.imread('。。/Downloads/timg.jpeg') original_grasp_bboxes = np.array([[[361, 260.582 ], [301 ,315], [320 ,336],[380, 281.582]]], dtype = np.int32) predi...
Rotated_IoU
W1995S的博客
04-09 872
介绍 https://github.com/lilanxiao/Rotated_IoU 该报告是用于2D / 3D对象检测的IoU损失的非官方实现。 它包含Pytorch函数，该函数使用GPU计算定向矩形的相交面积。 注意 CUDA扩展最近进行了修改，以涵盖一些极端情况。 请考虑更新代码并重新编译扩展。 检查清单 pytorch函数查找定向矩形的交点 pytorch函数检查一个矩形的角是否位于另一个矩形中 CUDA扩展为两个矩形的相交多边形的逆时针排序顶点 Pytorch函数使用上述函数计算矩形.
目标检测-斜框IOU,nms计算
qq_29296685的博客
08-21 7437
1 旋转IOU """ 2019.7.4 计算旋转的iou """ #coding=utf-8 from __future__ import absolute_import from __future__ import division from __future__ import print_function import os import numpy as np import cv2 ...
Rotated Whale Optimization Algorithm
07-08
Algorithm Updated 2 minutes ago Wireless sensor network(WSN) attracts the attention of more and more researchers and it is applied in more and more environments. The localization information is one of the most important information in WSN. This pape proposed a novel algorithm called the rotated black hole(RBH) algorithm, which introduces a rotated optimal path and greatly improves the global search ability of the original black hole(BH) algorithm. Then, the novel algorithm is applied in reducing the localization error ofWSN in 3D terrain. CEC 2013 test suit is used to verify the performance of the novel algorithm, and the simulation results show the novel algorithm has better search performance than other famous intelligence computing algorithms. The localization simulation experiment results reveal the novel algorithm also has an excellent performance in solving practical problems.
sensor-fusion-demo.7z
01-20
国外一个非常给力的一个根据各类Sensor计算旋转角度的案例，非常有参考价值！ This application demonstrates the capabilities of various sensors and sensor-fusions. Data from the Gyroscope, Accelerometer and compass are combined in different ways and the result is shown as a cube that can be rotated by rotating the device.
mnist_rotation_new.zip
11-11
MNIST数据集中的数字图像在0~2Π之间均匀旋转产生的新版本 rotated-MNIST 。包含rotated_train.npz、rotated_valid.npz、rotated_test.npz
Rotated Rastrigin Function
09-04
Rotated Rastrigin Function matlab code
python计算二维矩形IOU实例
09-18
今天就为大家分享一篇python计算二维矩形IOU实例，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
Rotated_MaskRCNN
03-20
Rotated_MaskRCNN
Rotated QPSK：计算 Rotated & interleaved QPSK 方案的 BER-matlab开发
06-01
结果仅为 10dB SNR。 更高的 SNR 需要更多的时间。
C语言计算旋转矩形的IOU,计算两个矩形IOU的算法
weixin_29245767的博客
05-21 678
float intersectRect(const cv::Rect& rectA, const cv::Rect& rectB, cv::Rect& intersectRect){if (rectA.x > rectB.x + rectB.width) { return 0.; }if (rectA.y > rectB.y + rectB.height) { ...
shifted rotated rastrign
10-12
shifted rotated rastrigin函数是一个基于Rastrigin函数的变种函数。Rastrigin函数是一个经典的非线性优化问题，被广泛用于测试优化算法的性能。 shifted rotated rastrigin函数是在Rastrigin函数的基础上加上了平移和旋转的操作。平移操作将函数的整体位置向不同的方向移动，旋转操作将函数的整体形状进行旋转。这两种操作使得函数的景观发生了显著的变化，增加了优化问题的难度。 shifted rotated rastrigin函数的数学表达式为： f(x) = A * n + Σ(xi^2 - A*cos(2π*xi)) 其中，A是一个常数，n是变量的维度，xi是每个维度上的变量值。该函数的优化目标是使函数的最小值最小化。 shifted rotated rastrigin函数可以用于评估优化算法在处理具有平移和旋转操作的优化问题时的性能。由于函数具有非线性、多峰和高维的特点，使得优化算法面临了更大的挑战。通过设计适应性强的优化算法，我们可以更好地处理这类问题。 因此，shifted rotated rastrigin函数提供了一个用于评估算法性能的基准函数，可以帮助优化算法的研究者和开发人员更好地理解算法在处理复杂优化问题时的优劣。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值