C++计算三维空间点的obb包围框，包含osg调用

最新推荐文章于 2024-04-03 16:09:05 发布
最新推荐文章于 2024-04-03 16:09:05 发布
阅读量620 收藏 8
点赞数
文章标签： c++ 3d 图形渲染
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42114265/article/details/134079785
版权

前言

C++计算obb包围盒的完整代码，渲染使用的是osg。参考了如何生成OBB（OrientedboundingBox）方向包围盒，代码流程差不多，但是我这篇代码更流畅，包含调用部分，原链接中的矩阵类不适用C++，所以在本文中有的用数组代替。另文中的Math::Vec3f等同于osg::Vec3f。代码还没有时间认真整理，后面有空可以再优化一下，另数学方面不是很精通，有什么错漏欢迎指出。

第一步 计算协方差矩阵

/*计算协方差矩阵 */
    std::vector<std::vector<float>> computeConvarienceMatrix(const std::vector<Math::Vec3f>& pVertices)
    {
        int numVertices = pVertices.size();
        std::vector<Math::Vec3f> pVectors(numVertices, Math::Vec3f(0.0, 0.0, 0.0));

        //Compute the average x,y,z  
        Math::Vec3f avg(0.0f, 0.0f, 0.0f);
        for (int i = 0; i < numVertices; i++)
        {
            pVectors[i] = (Math::Vec3f)pVertices[i];
            avg += pVertices[i];
        }
        avg /= numVertices;
        for (int i = 0; i < numVertices; i++)
            pVectors[i] -= (avg);

        //Compute the covariance   
        std::vector<std::vector<float>> covarianceMat(3, { 0.0,0.0,0.0 });
        for (int c = 0; c < 3; c++)
        {
            float data[3] = { 0 };
            for (int r = c; r < 3; r++)
            {
                float acc = 0.0f;
                for (int i = 0; i < numVertices; i++)
                {
                    data[0] = pVectors[i].x();
                    data[1] = pVectors[i].y();
                    data[2] = pVectors[i].z();
                    acc += data[c] * data[r];
                }
                acc /= numVertices;
                covarianceMat[c][r] = acc;
                covarianceMat[r][c] = acc;   //对称矩阵
            }
        }
        return covarianceMat;
    }

第二步 计算特征向量

计算出来的特征向量就是轴向量；

/*求特征向量 */
    void jacobiSolver(std::vector<std::vector<float>>& matrix, std::vector<Math::Vec3f>& eVectors)
    {
        float eps = (float)1.0E-5;

        float p, q, spq;
        float cosa = 0, sina = 0;  //cos(alpha) and sin(alpha)  
        float temp;
        float s1 = 0.0f;    //sums of squares of diagonal  
        float s2;          //elements  

        bool flag = true;  //determine whether to iterate again 

        Math::Vec3f eValue(0, 0, 0);
        float data[3];
        float t[3][3] = {
            1.0f,0,0,
            0,1.0f,0,
            0,0,1.0f };//To store the product of the rotation matrices.  
        do
        {
            for (int i = 0; i < 2; i++)
            {
                for (int j = i + 1; j < 3; j++)
                {
                    if (std::abs(matrix[i][j]) < eps)
                        matrix[i][j] = 0.0f;
                    else
                    {
                        q = std::abs(matrix[i][i] - matrix[j][j]);
                        if (q > eps)
                        {
                            p = (2.0f * matrix[i][j] * q) / (matrix[i][i] - matrix[j][j]);
                            spq = (float)std::sqrt(p * p + q * q);
                            cosa = (float)std::sqrt((1.0f + q / spq) / 2.0f);
                            sina = p / (2.0f * cosa * spq);
                        }
                        else
                            sina = cosa = (std::sqrt(2.0f)) / 2;  //INV_SQRT_TWO 2分之根号2

                        for (int k = 0; k < 3; k++)
                        {
                            temp = t[k][i];
                            t[k][i] = temp * cosa + t[k][j] * sina;
                            t[k][j] = temp * sina - t[k][j] * cosa;
                        }
                        for (int k = i; k < 3; k++)
                        {
                            if (k > j)
                            {
                                temp = matrix[i][k];
                                matrix[i][k] = cosa * temp + sina * matrix[j][k];
                                matrix[j][k] = sina * temp - cosa * matrix[j][k];
                            }
                            else
                            {
                                data[k] = matrix[i][k];
                                matrix[i][k] = cosa * data[k] + sina * matrix[k][j];
                                if (k == j)
                                    matrix[j][k] = sina * data[k] - cosa * matrix[j][k];
                            }
                        }
                        data[j] = sina * data[i] - cosa * data[j];

                        for (int k = 0; k <= j; k++)
                        {
                            if (k <= i)
                            {
                                temp = matrix[k][i];
                                matrix[k][i] = cosa * temp + sina * matrix[k][j];
                                matrix[k][j] = sina * temp - cosa * matrix[k][j];

                            }
                            else
                                matrix[k][j] = sina * data[k] - cosa * matrix[k][j];

                        }
                    }
                }
            }
            s2 = 0.0f;
            for (int i = 0; i < 3; i++)
            {
                eValue[i] = matrix[i][i];
                s2 += eValue[i] * eValue[i];
            }

            if (std::abs(s2) < (float)1.e-5 || std::abs(1 - s1 / s2) < eps)
                flag = false;
            else
                s1 = s2;
        } while (flag);

        eVectors[0].set(t[0][0], t[0][1], t[0][2]);
        eVectors[1].set(t[1][0], t[1][1], t[1][2]);
        eVectors[2].set(t[2][0], t[2][1], t[2][2]);

        Math::Vec3f cross;
        cross = eVectors[0].cross(eVectors[1]);
        if (cross.dot(eVectors[2]) < 0.0f)
            eVectors[2] = -eVectors[2];

    }

第三步 特征向量施密特正交化

/*正交化 */
    void schmidtOrthogonal(Math::Vec3f& v0, Math::Vec3f& v1, Math::Vec3f& v2)
    {
        v0.normalize();
        v1 = v1 - ((v1 * v0) * v0);
        v1.normalize();
        v2 = v0.cross(v1);
    }

第四步 计算中心点和半长款

有了中心点和半长宽，就能计算出包围盒的各个顶点

 //计算中心点和半场宽
    void computeCenterNHalflength(std::vector<Math::Vec3f>& vecVertex, osg::Vec3f& leftbottom, osg::Vec3f& rightTop, osg::Vec3f& rightbottom, osg::Vec3f& leftTop)
    {

        std::vector<std::vector<float>> conMatrix3f = computeConvarienceMatrix(vecVertex);

        std::vector<Math::Vec3f> eVectors(3, Math::Vec3f(0, 0, 0)); //特征向量
        jacobiSolver(conMatrix3f, eVectors);
        schmidtOrthogonal(eVectors[0], eVectors[1], eVectors[2]);

        float infinity = Base::POS_INFINITY32;
        Math::Vec3f minExtents(infinity, infinity, infinity);
        Math::Vec3f maxExtents(-infinity, -infinity, -infinity);

        std::vector<Math::Vec3f> vertices = vecVertex;
        int numVertices = vecVertex.size();

        //求中心点position
        Math::Vec3f position(0.0f, 0.0f, 0.0f);
        for (int i = 0; i < numVertices; i++)
        {
            position += vertices[i];
        }
        position /= numVertices;

        for (int index = 0; index < numVertices; index++)
        {
            Math::Vec3f displacement = vertices[index] - position;

            //计算每个点在方向轴上的点乘作为长度
            minExtents[0] = std::min(minExtents.x(), displacement.dot(eVectors[0]));
            minExtents[1] = std::min(minExtents.y(), displacement.dot(eVectors[1]));
            minExtents[2] = std::min(minExtents.z(), displacement.dot(eVectors[2]));

            maxExtents.x() = std::max(maxExtents.x(), displacement.dot(eVectors[0]));
            maxExtents.y() = std::max(maxExtents.y(), displacement.dot(eVectors[1]));
            maxExtents.z() = std::max(maxExtents.z(), displacement.dot(eVectors[2]));
        }
        Math::Vec3f offset = maxExtents - minExtents;
        offset /= (2.0f);
        offset += (minExtents);
        //矫正中心点
        position += (eVectors[0] * (offset.x()));
        position += (eVectors[1] * (offset.y()));
        position += (eVectors[2] * (offset.z()));

        Math::Vec3f halfExtents;
        halfExtents.x() = (maxExtents.x() - minExtents.x()) / 2.0f;
        halfExtents.y() = (maxExtents.y() - minExtents.y()) / 2.0f;
        halfExtents.z() = (maxExtents.z() - minExtents.z()) / 2.0f;

        Math::Vec3f mleftbtm = position - halfExtents.x() * eVectors[0] - halfExtents.z() * eVectors[2];
        Math::Vec3f mrightbottom = position + halfExtents.x() * eVectors[0] - halfExtents.z() * eVectors[2];
        Math::Vec3f mrightTop = position + halfExtents.x() * eVectors[0] + halfExtents.z() * eVectors[2];
        Math::Vec3f mleftTop = position - halfExtents.x() * eVectors[0] + halfExtents.z() * eVectors[2];

        leftbottom.set(mleftbtm.x(), mleftbtm.y(), mleftbtm.z());
        rightTop.set(mrightTop.x(), mrightTop.y(), mrightTop.z());
        rightbottom.set(mrightbottom.x(), mrightbottom.y(), mrightbottom.z());
        leftTop.set(mleftTop.x(), mleftTop.y(), mleftTop.z());
    }

调用代码


    void updateRectBox(std::vector<Math::Vec3f> vecVertex)
    {
        osg::Vec3f leftbottom, rightTop, rightbottom, leftTop;
        computeCenterNHalflength(vecVertex, leftbottom, rightTop, rightbottom, leftTop);

        //绘制边框
        osg::ref_ptr<osg::Geometry> geomLine = new osg::Geometry;
        osg::ref_ptr<osg::Vec3Array> temVertex = new osg::Vec3Array();

        temVertex->push_back(leftbottom);
        temVertex->push_back(rightbottom);
        temVertex->push_back(rightTop);
        temVertex->push_back(leftTop);

        geomLine->setVertexAttribArray(0, temVertex);
        geomLine->setVertexAttribBinding(0, osg::Geometry::BIND_PER_VERTEX);
        //颜色数组
        osg::Vec4Array* vColors = new osg::Vec4Array;
        vColors->push_back(COLOR_RECT);
        geomLine->setColorArray(vColors);
        geomLine->setColorBinding(osg::Geometry::BIND_OVERALL);
        //绘制图元属性
        osg::ref_ptr<osg::DrawArrays> vPri = new osg::DrawArrays(osg::PrimitiveSet::LINE_LOOP, 0, temVertex->size());
        geomLine->addPrimitiveSet(vPri.get());

        osg::Geode* pRectGeode = new osg::Geode;
        pRectGeode->getOrCreateStateSet()->setMode(GL_DEPTH_TEST, osg::StateAttribute::OFF);
        pRectGeode->addDrawable(geomLine);
    }
菜鸟小小小张
关注
碰撞检测 | 详解矩形AABB与OBB碰撞检测算法(附ROS C++可视化)
FRIGIDWINTER的博客
09-03 7089
矩形包围盒碰撞检测的核心原理是用矩形近似待检测物体轮廓，通过计算两个矩形间是否有重叠区域来进行碰撞判断。常用的包围形式有轴对齐包围盒(Axis-Aligned Bounding Box, AABB)以及更精细化具有角度的方向包围盒(Oriented Bounding Box, OBB)。本文详解这两种碰撞检测算法，并给出基于C++的算法实现和ROS可视化仿真案例
OBB-box.zip_OBB包围盒_OBB包围盒PCA_OSG 包围盒_osg_包围盒
07-15
通过osg图形引擎建立节点的OBB包围盒，效果不错
计算平面点集的OBB
最新发布
杂鱼Tong的博客
04-03 646
平面中OBB包围盒的一种计算方法
OSG创建并显示模型的OBB包围盒和AABB包围盒
MeteorChenBo的博客
08-11 5234
包围盒在碰撞检测等方面有着非常重要的应用，网上关于OBB包围盒的介绍很多，介绍的很好的一篇文章为https://blog.csdn.net/qing101hua/article/details/53100112这篇，想了解原理的话可以仔细看一看这篇文章。 最近在科研的过程中，碰到了求解模型的OOB包围盒的问题，因为自己使用的是OSG平台，所以就去网上找，发现基本没有能用的，就自己在GitHub上...
OSG获取模型XYZ范围并生成最小包围盒
kongj_18的博客
04-12 8354
OSG获取模型XYZ范围并生成最小包围盒
OBB碰撞检测可直接用的C++源码和TypeScript源码以及对应3D测试演示
vily_lei的专栏
05-07 1081
OBB碰撞检测可直接用的C++源码和TypeScript源码以及对应3D测试演示，加了3D演示程序，方便直观理解。
OBB包围盒生成算法
11-22
生成OBB（方向包围盒算法），java实现。
基于osg的obb包围盒计算
08-14
这是一个基于osg的方向包围盒计算的实现，利用协方差矩阵计算一组点的最小包围盒
基于osg的包围盒绘制
09-15
osg包围盒，不是包围球，更不是那个傻呼呼的正方体，使用了抗锯齿
osg_obb.rar
06-23
函数需要自己根据自己需要写导入数据的函数。 obb树的完整代码，可以运行。
OSG笔记：获取节点的包围盒
憧憬，思考，奋斗，飞翔
04-14 1115
获取osg节点的包围盒
使用osg获取模型的世界坐标下的包围盒
05-12
做虚实交互用，可以方便地获取模型在世界场景中的位置信息，方便进行碰撞检测。
一种快速收敛的自适应算法求解最小包围盒OBB
04-25
一种快速收敛的自适应算法求解最小包围盒OBB 最小包围盒沿坐标轴向包围盒AABB（Axis-Aligned Bounding Boxes）算法简单，适用场合有限。沿任意方向的包围盒OBB（Oriented Bounding Boxes）适用面广，但大多算法效率不高，一方面是模型本身复杂导致，另一方面是精度越高、循环叠代次数沿指数增加而导致。博主几年前提出的一种求解OBB问题的自适应算法，并用UG NX二次开发Grip语言实现了此算法，经过测试，运算效率和精度都十分理想
obb和obb树代码，使用EIGEN处理矩阵。
10-12
obb树的完整代码，可以运行，测试函数需要自己根据自己需要写导入数据的函数。
Open3D(C++) 计算点云包围盒
点云侠的博客
07-12 1404
C++版本Open3D点云AABB包围盒、OBB包围盒获取方法。
C++学习（二九一）Android的OBB路径
hankern的专栏
06-25 339
Opaque Binary Blob 如果我们设计一款资源包含比较多的游戏，可能你会发现最终生成的APK文件可能高达300MB，但是APK文件很大导致Android系统无法正常安装，而这么大其实都是游戏中用到的资源文件，我们放到SD卡上可能其他应用也可以访问，比如说系统的图片管理器会索引游戏中的图片资源，而音乐播放器也会索引资源中的音乐，所以Android 2.3的OBB文件(Opaque Binary Blob)可以很好的解决大文件在SD卡上分离出APK文件，同时别的程序没有权限访问这样一种隔离的文件系
OBB包围盒
m0_37329302的博客
05-15 5220
转自http://www.cnblogs.com/lyggqm/p/5386174.html OBB 前面提到了长条物体在旋转时AABB盒的变化，那么是否有能够在任意方向都更为精确的检测方式，答案是肯定的，这是一种基于OBB即定向包容盒子（Oriented Bounding Box,OBB）的技术，它已经广泛用于光线追踪和碰撞检测中。 OBB这种方法是根据物体本身的几何形状来决定
Yolov8_obb旋转检测网络Opencv部署（C++版）
低调猫熊的博客
03-22 1691
这里的输入是640*640的3通道图，输出可以看作是8400行7列的一个矩阵，每一行对应的值依次为预测框的中心坐标(x, y)和框的宽高w,h。对模型类别的判断使用minMaxLoc函数比较方便，包括各分类网络也都是使用取输出向量的最大值来获取类别的。到这里，其实就很简单了，剩下的就是遍历每一行，并将对应的值放到自己的结构体里面，供后面画框的时候使用了。根据输出的内容，我们可以建一个结构体，便于后面存储和使用。这一篇再分享一下OBB旋转检测的部署，也是仅使用Opencv的dnn库的C++部署。
用C++ obb包围盒算法
05-25
OBB（Oriented Bounding Box，有向包围盒）是一种用于包围物体的几何形状，它既能够保持物体的形状，又能够提供方便的碰撞检测和投影。以下是使用C++实现OBB包围盒算法的基本步骤： 1. 进行物体的三维建模，并获得每个顶点的位置信息。 2. 找到物体的最小和最大点，以确定物体的中心点。 3. 对于每个顶点，将其与物体中心点的位置向量相减，将这个向量存储在一个数组中。 4. 计算出物体的协方差矩阵，使用数组中的向量作为输入。 5. 对协方差矩阵进行特征值分解，以获得物体的主方向和大小。 6. 构建OBB包围盒的八个顶点，通过将物体中心点与主方向上的最小和最大边界点分别相加和相减得到。 以下是一个简单的C++代码示例，用于计算OBB包围盒的8个顶点： ```cpp #include <iostream> #include <vector> #include <Eigen/Dense> using namespace Eigen; void computeOBB(const std::vector<Vector3f>& points, Matrix3f& axes, Vector3f& center, Vector3f& extents) { int numPoints = points.size(); // Compute the center point of the object center.setZero(); for (int i = 0; i < numPoints; ++i) center += points[i]; center /= numPoints; // Compute the covariance matrix of the object Matrix3f covMat; covMat.setZero(); for (int i = 0; i < numPoints; ++i) { Vector3f v = points[i] - center; covMat += v * v.transpose(); } covMat /= numPoints; // Compute the eigenvalues and eigenvectors of the covariance matrix SelfAdjointEigenSolver<Matrix3f> eig(covMat); Vector3f eigenValues = eig.eigenvalues().real(); Matrix3f eigenVectors = eig.eigenvectors().real(); // Set the axes and extents of the OBB axes = eigenVectors.transpose(); extents = eigenValues.sqrt(); // Compute the 8 corners of the OBB std::vector<Vector3f> corners(8); for (int i = 0; i < 8; ++i) { Vector3f corner; for (int j = 0; j < 3; ++j) corner(j) = (i & (1 << j)) ? extents(j) : -extents(j); corners[i] = center + axes * corner; } } ``` 这个函数的输入是一个三维点的向量数组，表示物体的顶点位置。函数输出物体的OBB包围盒的8个顶点，以及旋转矩阵和大小向量。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值