NX8.5,用C++ 写一个OBB算法，获取对象的最小包容盒

OBB（Oriented Bounding Box）算法是一种用于计算三维物体的最小包围盒的方法，它可以获取到物体的最小包容盒。下面是一个基于C++的OBB算法实现示例：

#include <iostream>
#include <vector>

using namespace std;

struct Point
{
    double x, y, z;
};

struct OBB
{
    Point center;
    vector<Point> axis;
    vector<double> extent;
};

// 计算点集的中心点
Point computeCenter(const vector<Point>& points)
{
    Point center;
    center.x = center.y = center.z = 0.0;
    for (unsigned int i = 0; i < points.size(); ++i)
    {
        center.x += points[i].x;
        center.y += points[i].y;
        center.z += points[i].z;
    }
    center.x /= points.size();
    center.y /= points.size();
    center.z /= points.size();
    return center;
}

// 计算协方差矩阵
void computeCovarianceMatrix(const vector<Point>& points, const Point& center, double* matrix)
{
    for (int i = 0; i < 9; ++i)
    {
        matrix[i] = 0.0;
    }

    for (unsigned int i = 0; i < points.size(); ++i)
    {
        double x = points[i].x - center.x;
        double y = points[i].y - center.y;
        double z = points[i].z - center.z;

        matrix[0] += x * x;
        matrix[1] += x * y;
        matrix[2] += x * z;
        matrix[3] += y * x;
        matrix[4] += y * y;
        matrix[5] += y * z;
        matrix[6] += z * x;
        matrix[7] += z * y;
        matrix[8] += z * z;
    }
}

// 计算特征值和特征向量
void computeEigen(const double* matrix, double* eigenvalues, double* eigenvectors)
{
    // 使用Jacobi算法计算特征值和特征向量
    const int n = 3;
    double* off = new double[n];
    double* p = new double[n * n];
    double* q = new double[n * n];
    for (int i = 0; i < n; ++i)
    {
        for (int j = 0; j < n; ++j)
        {
            p[i * n + j] = matrix[i * n + j];
            q[i * n + j] = 0.0;
        }
        q[i * n + i] = 1.0;
        off[i] = 0.0;
    }

    for (int k = 0; k < 50; ++k)
    {
        double s = 0.0;
        for (int i = 0; i < n - 1; ++i)
        {
            for (int j = i + 1; j < n; ++j)
            {
                double f = p[i * n + j];
                s += f * f;
                double h = off[j] - off[i];
                double c = 1.0;
                if (fabs(h) > 1e-12)
                {
                    double t = (p[i * n + i] - p[j * n + j]) / (2.0 * h);
                    double d = sqrt(1.0 + t * t);
                    if (t < 0.0)
                    {
                        d = -d;
                    }
                    c = 1.0 / sqrt(2.0 + (1.0 / d));
                }
                double sa = c;
                double sb = (fabs(c) < 1e-12) ? 1.0 : (1.0 / (c * d));
                off[i] -= f;
                off[j] += f;
                for (int l = 0; l < n; ++l)
                {
                    double t = p[i * n + l] * sa + p[j * n + l] * sb;
                    p[j * n + l] = p[i * n + l] * (-sb) + p[j * n + l] * sa;
                    p[i * n + l] = t;
                }
                for (int l = 0; l < n; ++l)
                {
                    double t = p[l * n + i] * sa + p[l * n + j] * sb;
                    p[l * n + j] = p[l * n + i] * (-sb) + p[l * n + j] * sa;
                    p[l * n + i] = t;
                }
                for (int l = 0; l < n; ++l)
                {
                    double t = q[i * n + l] * sa + q[j * n + l] * sb;
                    q[j * n + l] = q[i * n + l] * (-sb) + q[j * n + l] * sa;
                    q[i * n + l] = t;
                }
            }
        }
        eigenvalues[0] = off[0] + s;
        eigenvalues[1] = off[1] + s;
        eigenvalues[2] = off[2] + s;
        for (int i = 0; i < n; ++i)
        {
            eigenvectors[i * n + 0] = q[i * n + 0];
            eigenvectors[i * n + 1] = q[i * n + 1];
            eigenvectors[i * n + 2] = q[i * n + 2];
        }
        if (fabs(p[0]) <= 1e-12 && fabs(p[1]) <= 1e-12 && fabs(p[2]) <= 1e-12 && fabs(p[3]) <= 1e-12 && fabs(p[4]) <= 1e-12 && fabs(p[5]) <= 1e-12 && fabs(p[6]) <= 1e-12 && fabs(p[7]) <= 1e-12 && fabs(p[8]) <= 1e-12)
        {
            break;
        }
    }

    delete[] off;
    delete[] p;
    delete[] q;
}

// 计算OBB
OBB computeOBB(const vector<Point>& points)
{
    OBB obb;
    obb.center = computeCenter(points);

    double matrix[9];
    computeCovarianceMatrix(points, obb.center, matrix);

    double eigenvalues[3];
    double eigenvectors[9];
    computeEigen(matrix, eigenvalues, eigenvectors);

    obb.axis.resize(3);
    obb.extent.resize(3);
    for (int i = 0; i < 3; ++i)
    {
        obb.axis[i].x = eigenvectors[0 * 3 + i];
        obb.axis[i].y = eigenvectors[1 * 3 + i];
        obb.axis[i].z = eigenvectors[2 * 3 + i];
        obb.extent[i] = sqrt(eigenvalues[i]);
    }

    return obb;
}

int main()
{
    vector<Point> points;
    points.push_back({ 0.0, 0.0, 0.0 });
    points.push_back({ 1.0, 1.0, 1.0 });
    points.push_back({ -1.0, 1.0, 1.0 });
    points.push_back({ 1.0, -1.0, 1.0 });
    points.push_back({ 1.0, 1.0, -1.0 });

    OBB obb = computeOBB(points);
    cout << "Center: (" << obb.center.x << ", " << obb.center.y << ", " << obb.center.z << ")" << endl;
    cout << "Axis1: (" << obb.axis[0].x << ", " << obb.axis[0].y << ", " << obb.axis[0].z << ")" << endl;
    cout << "Axis2: (" << obb.axis[1].x << ", " << obb.axis[1].y << ", " << obb.axis[1].z << ")" << endl;
    cout << "Axis3: (" << obb.axis[2].x << ", " << obb.axis[2].y << ", " << obb.axis[2].z << ")" << endl;
    cout << "Extent1: " << obb.extent[0] << endl;
    cout << "Extent2: " << obb.extent[1] << endl;
    cout << "Extent3: " << obb.extent[2] << endl;

    return 0;
}

这个示例程序中，我们定义了一个Point结构体表示三维空间中的一个点，另外定义了一个OBB结构体表示物体的最小包容盒。我们首先实现了computeCenter函数来计算点集的中心点，然后实现了computeCovarianceMatrix函数来计算协方差矩阵，最后实现了computeEigen函数来计算特征值和特征向量。

在computeOBB函数中，我们首先计算点集的中心点，然后计算出协方差矩阵和特征值、特征向量，最后将特征向量作为包容盒的轴，将特征值开方作为包容盒的半长轴长度，并返回OBB结构体。

在main函数中，我们定义了一个点集points，将其传入computeOBB函数中计算出OBB，并输出OBB的信息。

需要注意的是，这个示例程序只是一个简单的实现示例，实际使用时需要考虑更多的情况，比如点集为空、点集只有一个点等特殊情况。