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

以下是一个简单的C++实现，假设你已经有了对象的顶点列表：

#include <algorithm>
#include <vector>

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

// 计算OBB的中心点和边长
void ComputeOBB(const std::vector<Vector3d>& vertices, Vector3d& center, Vector3d& lengths)
{
    // 计算中心点
    center = {0, 0, 0};
    for (const auto& vertex : vertices) {
        center.x += vertex.x;
        center.y += vertex.y;
        center.z += vertex.z;
    }
    center.x /= vertices.size();
    center.y /= vertices.size();
    center.z /= vertices.size();

    // 计算协方差矩阵
    double cov[3][3] = {0};
    for (const auto& vertex : vertices) {
        cov[0][0] += (vertex.x - center.x) * (vertex.x - center.x);
        cov[0][1] += (vertex.x - center.x) * (vertex.y - center.y);
        cov[0][2] += (vertex.x - center.x) * (vertex.z - center.z);
        cov[1][1] += (vertex.y - center.y) * (vertex.y - center.y);
        cov[1][2] += (vertex.y - center.y) * (vertex.z - center.z);
        cov[2][2] += (vertex.z - center.z) * (vertex.z - center.z);
    }
    cov[0][0] /= vertices.size();
    cov[0][1] /= vertices.size();
    cov[0][2] /= vertices.size();
    cov[1][1] /= vertices.size();
    cov[1][2] /= vertices.size();
    cov[2][2] /= vertices.size();
    cov[1][0] = cov[0][1];
    cov[2][0] = cov[0][2];
    cov[2][1] = cov[1][2];

    // 计算协方差矩阵的特征值和特征向量
    double eigen[3][3], eigenv[3][3];
    EigenSolver(cov, eigen, eigenv);

    // 将特征向量作为OBB的三个轴方向
    Vector3d axis[3] = {
        {eigenv[0][0], eigenv[1][0], eigenv[2][0]},
        {eigenv[0][1], eigenv[1][1], eigenv[2][1]},
        {eigenv[0][2], eigenv[1][2], eigenv[2][2]},
    };

    // 计算每个轴方向上的最小和最大值
    double minValues[3] = {std::numeric_limits<double>::max(),
                           std::numeric_limits<double>::max(),
                           std::numeric_limits<double>::max()};
    double maxValues[3] = {std::numeric_limits<double>::lowest(),
                           std::numeric_limits<double>::lowest(),
                           std::numeric_limits<double>::lowest()};
    for (const auto& vertex : vertices) {
        double dotProducts[3] = {
            (vertex.x - center.x) * axis[0].x + (vertex.y - center.y) * axis[0].y + (vertex.z - center.z) * axis[0].z,
            (vertex.x - center.x) * axis[1].x + (vertex.y - center.y) * axis[1].y + (vertex.z - center.z) * axis[1].z,
            (vertex.x - center.x) * axis[2].x + (vertex.y - center.y) * axis[2].y + (vertex.z - center.z) * axis[2].z,
        };
        for (int i = 0; i < 3; ++i) {
            minValues[i] = std::min(minValues[i], dotProducts[i]);
            maxValues[i] = std::max(maxValues[i], dotProducts[i]);
        }
    }

    // 计算OBB的边长
    lengths = {maxValues[0] - minValues[0], maxValues[1] - minValues[1], maxValues[2] - minValues[2]};
}

这个实现中使用了以下函数：

- `EigenSolver`：计算一个3x3矩阵的特征值和特征向量。由于这不是本题的重点，这里就不展开讲解了。你可以使用现成的库，比如Eigen或者OpenCV。
- `std::numeric_limits<double>::max()`和`std::numeric_limits<double>::lowest()`：表示`double`类型的最大值和最小值。