obb iou计算，旋转框iou,python和c++版本

已于 2024-05-16 13:06:46 修改
阅读量285 收藏 1
点赞数 2
文章标签： python 开发语言
于 2024-05-14 16:58:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gggi520/article/details/138861508
版权

python版本


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 = [274 ,614, 48 ,24 ,52.4832583462631987] #x,y,w,h,angle
    rbbox2 = [274 ,615 ,49 ,22 ,1.486161712080829]
    corners1 = rbbox_to_corners(rbbox1)
    corners2 = rbbox_to_corners(rbbox2)
    # print(corners1,"\n",corners2)
    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)
    area_union=rbbox1[2]*rbbox1[3]+rbbox2[2]*rbbox2[3]-polygon_area
    print('area: {}'.format(polygon_area/area_union))

c++

#include <iostream>
#include <cmath>
#include <vector>
#include <algorithm>
// box转化为角点
std::vector<float> rbbox_to_corners(const std::vector<float> &rbbox) {
    // generate clockwise corners and rotate it clockwise
    // 顺时针方向返回角点位置
    float cx = rbbox[0] + rbbox[2] / 2;
    float cy = rbbox[1] + rbbox[3] / 2;
    float x_d = rbbox[2];
    float y_d = rbbox[3];
    float angle = rbbox[4];
    float a_cos = std::cos(angle);
    float a_sin = std::sin(angle);
    std::vector<float> corners(8, 0.0);
    float corners_x[4] = {-x_d / 2, -x_d / 2, x_d / 2, x_d / 2};
    float corners_y[4] = {-y_d / 2, y_d / 2, y_d / 2, -y_d / 2};
    for (int i = 0; i < 4; ++i) {
        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;
}

// 检测点是否在四边形内的函数
bool point_in_quadrilateral(float pt_x, float pt_y, const std::vector<float>& corners) {
    float ab0 = corners[2] - corners[0];
    float ab1 = corners[3] - corners[1];

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

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

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

    return abab >= abap && abap >= 0 && adad >= adap && adap >= 0;
}


// 检测线段相交并计算交点的函数
int line_segment_intersection(const std::vector<float>& pts1, const std::vector<float>& pts2, int i, int j 
                                                             , bool &ret1,float &point_x,float &point_y) {
    // pts1, pts2 分别为 corners
    // i j 分别表示第几个交点，取其和其后一个点构成的线段
    // 返回 tuple(bool, pts) bool=true pts为交点
    std::vector<float> A(2), B(2), C(2), D(2), ret(2);
    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];

    float BA0 = B[0] - A[0];
    float BA1 = B[1] - A[1];
    float DA0 = D[0] - A[0];
    float CA0 = C[0] - A[0];
    float DA1 = D[1] - A[1];
    float CA1 = C[1] - A[1];

    // 叉乘判断方向
    bool acd = DA1 * CA0 > CA1 * DA0;
    bool bcd = (D[1] - B[1]) * (C[0] - B[0]) > (C[1] - B[1]) * (D[0] - B[0]);

    if (acd != bcd) {
        bool abc = CA1 * BA0 > BA1 * CA0;
        bool abd = DA1 * BA0 > BA1 * DA0;

        // 判断方向
        if (abc != abd) {
            float DC0 = D[0] - C[0];
            float DC1 = D[1] - C[1];
            float ABBA = A[0] * B[1] - B[0] * A[1];
            float CDDC = C[0] * D[1] - D[0] * C[1];
            float DH = BA1 * DC0 - BA0 * DC1;
            float Dx = ABBA * DC0 - BA0 * CDDC;
            float Dy = ABBA * DC1 - BA1 * CDDC;
            ret[0] = Dx / DH;
            ret[1] = Dy / DH;
            ret1=true;
            point_x=ret[0] ;
            point_y=ret[1] ;
            return 0;
        }
    }
    ret1=false;
    point_x=ret[0] ;
    point_y=ret[1] ;
    return 0;
}



// 比较函数，用于排序
bool compare_points(const std::vector<float>& pt1, const std::vector<float>& pt2, const std::vector<float>& center) {
    float vx1 = pt1[0] - center[0];
    float vy1 = pt1[1] - center[1];
    float vx2 = pt2[0] - center[0];
    float vy2 = pt2[1] - center[1];
    float d1 = std::sqrt(vx1 * vx1 + vy1 * vy1);
    float d2 = std::sqrt(vx2 * vx2 + vy2 * vy2);
    vx1 /= d1;
    vy1 /= d1;
    vx2 /= d2;
    vy2 /= d2;
    if (vy1 < 0) {
        vx1 = -2 - vx1;
    }
    if (vy2 < 0) {
        vx2 = -2 - vx2;
    }
    return vx1 < vx2;
}

// 对凸多边形的顶点进行排序
void sort_vertex_in_convex_polygon(std::vector<std::vector<float>>& int_pts, int num_of_inter) {
    if (num_of_inter > 0) {
        std::vector<float> center(2, 0);
        for (int i = 0; i < num_of_inter; ++i) {
            center[0] += int_pts[i][0];
            center[1] += int_pts[i][1];
        }
        center[0] /= num_of_inter;
        center[1] /= num_of_inter;
        std::sort(int_pts.begin(), int_pts.end(), [&center](const std::vector<float>& pt1, const std::vector<float>& pt2) {
            return compare_points(pt1, pt2, center);
        });
    }
}

// 计算三角形的面积
float triangle_area(const std::vector<float>& a, const std::vector<float>& b, const std::vector<float>& c) {
    return std::abs((a[0] - c[0]) * (b[1] - c[1]) - (a[1] - c[1]) * (b[0] - c[0])) / 2.0;
}

// 计算多边形转化为多个三角形面积之和
float polygon_area(const std::vector<std::vector<float>>& int_pts, int num_of_inter) {
    float area_val = 0.0;
    for (int i = 1; i < num_of_inter - 1; ++i) {
        area_val += triangle_area(int_pts[0], int_pts[i], int_pts[i + 1]);
    }
    return area_val;
}


int main(int argc, char *argv[])

{
  // 定义两个包围盒的数据
    std::vector<float> rbbox1 = {274 ,614, 48 ,24 ,52.4832583462631987};
    std::vector<float> rbbox2 = {274 ,615 ,49 ,22 ,1.486161712080829};
    
    // 调用函数得到角点数据
    std::vector<float> corners1 = rbbox_to_corners(rbbox1);
    std::vector<float> corners2 = rbbox_to_corners(rbbox2);
    
    std::vector<std::vector<float>> pts;
    int num_pts = 0;
    // 检测角点是否在对方的四边形内
    for (int i = 0; i < 4; ++i) {
        float point_x = corners1[2 * i];
        float point_y = corners1[2 * i + 1];
        if (point_in_quadrilateral(point_x, point_y, corners2)) {
            num_pts++;
            pts.push_back({point_x, point_y});
        }
    }
    for (int i = 0; i < 4; ++i) {
        float point_x = corners2[2 * i];
        float point_y = corners2[2 * i + 1];
        if (point_in_quadrilateral(point_x, point_y, corners1)) {
            num_pts++;
            pts.push_back({point_x, point_y});
        }
    }


    for (int i = 0; i < 4; ++i) {
        for (int j = 0; j < 4; ++j) {
            float point_x,point_y;
            bool ret;
            line_segment_intersection(corners1, corners2, i, j,ret,point_x,point_y);
            if (ret) {
                num_pts++;
                pts.push_back({point_x, point_y});
            }
        }
    }


    sort_vertex_in_convex_polygon(pts, num_pts);
 

    float polygon_area_val = polygon_area(pts, num_pts);

    // 计算 area_union
    float area_union = rbbox1[2] * rbbox1[3] + rbbox2[2] * rbbox2[3] - polygon_area_val;

        // 计算并输出结果
    std::cout << "area: " << polygon_area_val / area_union << std::endl;
  return 0;

}
gggi520
关注
iou 合并代码
jacke121的专栏
11-13 237
iou 合并代码
复习笔记——动手开撸“完美”IOU计算C++版本全家桶
啥都会一点的小程的博客
03-16 2646
复习笔记——动手撸IOU全家桶（C++版本） 最近需要调整下，故开此系列复习下基础，有些大厂面试会让你手撕IOU，这里我自己整理思路，编了一套C++版本的IOU礼包，该篇简单粗暴，不和你讲道理（您只需要关注我，免费获取）目的是自己造下轮子同时复习下基础知识，校招的同学们看完了可以直接反手打一个暴击，告诉面试的我不仅会IOU，我还给你写GIOU,CIOU,DIOU ！ 动机：分享和自己复习，主要是算法分享系列写起来太累，有时候细节知识点我真的生疏或者理解没到位，需要再反复琢磨下！晚些更。 文章目录复习笔记—
旋转框（obb）目标检测计算iou的方法
athrunsunny的博客
11-30 1625
首先先定义一组多边形，这里的数据来自前后帧的检测结果其中的每个列表元素代表一个多边形，列表中包含四个元素，分别代表多边形的顶点坐标。
[原创]使用C++实现一个计算IOU的类
adeclaire的博客
06-12 305
两个类：一个用于表示检测框，一个用于计算iou。
2DBox和3DBox和旋转Box的iou计算
weixin_41803339的博客
11-11 2008
序言 面试过程中遇到的问题，如何对2Dbox、3Dbox和旋转box求iou。 2D Box计算代码 def cal_2dbox(box1, box2): """ box format: xyxy """ x1 = max(box1[0], box2[0]) y1 = max(box1[1], box2[1]) x2 = min(box1[2], box2[2]) y2 = min(box1[3], box2[3]) union = (x2 -
计算机视觉：两个旋转检测框bbox的IoU计算
博学而笃志，切问而近思。
06-12 2465
计算机视觉：两个旋转检测框bbox的IoU计算
如何计算旋转框的IOU
slamer111的博客
05-09 2259
面试旋转IOU的计算
解决rotatedRectangleIntersection计算目标检测旋转框IOU不准确问题C++、opencv
zjn-ai的博客
03-08 5747
问题 cv::rotatedRectangleIntersection(cv::RotatedRect r1， cv::RotatedRect r1， vector<cv::Point2f> vertices)用来计算两个旋转矩形框的相交多边形，返回的结果vertices是多边形的点坐标，最多返回8个点的坐标。 再通过double cv::contourArea(InputArray contour, bool oriented=false)计算多边形面积，这样就得到了相交多边形的面积。
矩形框的IOU计算C++实现
期待黎明的博客
08-30 6948
可以利用opencv进行实现，非常简单，如果不使用opencv也可以使用min，max也不难。因此下面的C++代码包含了两种计算矩形框IOU的方法。 #include<iostream> #include<algorithm> #include<vector> #include<opencv2/opencv.hpp> using namesp...
目标检测-斜框IOU,nms计算
qq_29296685的博客
08-21 7702
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 ...
分别使用OpenCV与ONNXRuntime部署yolov5旋转目标检测源码+模型(c++和python两个版本程序).zip
01-06
分别使用OpenCV与ONNXRuntime部署yolov5旋转目标检测源码+模型(c++和python两个版本程序).zip 分别使用OpenCV、ONNXRuntime部署yolov5旋转目标检测，包含C++和Python两个版本的程序。 使用OpenCV部署yolov5旋转目标...
roLabelImg标注obb旋转框工具-yolov8-obb标注工具，无需安装，下载即用
最新发布
09-17
roLabelImg标注obb旋转框工具-yolov8-obb标注工具，无需安装，下载即用
yolov5 obb旋转框训练demo
05-20
4. **损失函数**：OBB训练通常会涉及到旋转框的损失计算，这包括位置、尺度和角度的损失。理解这些损失函数是如何工作的对于优化模型至关重要。 5. **模型评估与可视化**：训练完成后，使用`validate.py`来评估模型...
C++ opencv部署yolov8旋转框目标检测源码
01-26
测试环境： vs2019 cmake==3.24.3 opencv==4.7.0 博客地址： blog.csdn.net/FL1623863129/article/details/135857915 视频演示： bilibili.com/video/BV1ce411e79k/
基于onnxruntime+opencv部署yolov8的onnx模型支持检测分割旋转框C++源码+使用说明
09-02
基于onnxruntime+opencv部署yolov8的onnx模型支持检测分割旋转框C++源码+使用说明，在本项目中，我们主要关注的是如何利用ONNXRuntime和OpenCV库来部署Yolov8的ONNX模型，以实现目标检测、分割以及旋转框的处理。...
航拍车辆旋转框定位以及航向检测
留缘的博客
05-04 4336
引言 近年来，随着经济的快速发展，中国城市化发展迅速，城市车辆增多，交通网络也日益复杂。但交通的发展在给人们生活和工作带来便捷的同时，车多路繁的状况也给出行安全带来了隐患，更是给交通管理和监控提出了难题。在这一背景下，智能交通成为了解决问题的方向之一。 交通监控系统是智能交通系统的重要组成部分，包含道路监控，巡查，检测等功能，可以快速采集有效道路交通信息，进行自动的分析检测统计。现有的交通监控还是主要依赖于部署在各个路段的定点摄像头，但其本身的固有特点比如视角固定且狭隘，图像清晰度低，存在众多监控死角等
OBB目标检测的IOU计算
如果想成为中心，那么就到中心去吧。
11-04 700
文章目录1. 基于opencv 1. 基于opencv 检测框格式：cx, cy, w, h, a. def iou_rotate_calculate(boxes1, boxes2): # print("####boxes2:", boxes1.shape) # print("####boxes2:", boxes2.shape) area1 = boxes1[2] * boxes1[3] area2 = boxes2[2] * boxes2[3] r1 = ((boxe
任意两个旋转矩形的IOU计算方法
hajungong007的博客
07-31 7005
方法一： 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...
倾斜框IOU计算实现（c++,python）
年轻即出发，
06-13 6383
c++实现方式1： #include <iostream> #include <vector> #include <math.h> #include <string.h> #include <algorithm> #include <opencv2/opencv.hpp> #include "caffe/nms.h" u...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值