我需要一个C++版本的代码，谢谢

好的，下面是一个基于 C++ 的求解三维点集最小包容盒的代码，与前面的 Python 代码思路相似，使用了 Eigen 库来进行矩阵计算：

#include <iostream>
#include <vector>
#include <Eigen/Core>
#include <Eigen/SVD>
#include <Eigen/Geometry>

Eigen::Vector3d getNormal(const Eigen::Vector3d& p1, const Eigen::Vector3d& p2, const Eigen::Vector3d& p3) {
    Eigen::Vector3d e1 = p2 - p1;
    Eigen::Vector3d e2 = p3 - p1;
    return e1.cross(e2).normalized();
}

void getBoundingBox(const std::vector<Eigen::Vector3d>& points, double& length, double& width, double& height, Eigen::Matrix3d& rotation) {
    Eigen::Matrix3Xd points_mat(3, points.size());
    for (int i = 0; i < points.size(); i++) {
        points_mat.col(i) = points[i];
    }

    Eigen::Matrix3Xd hull_points_mat;
    std::vector<int> hull_indices;

    // 计算凸包
    Eigen::Matrix3Xd vertices = points_mat.transpose();
    Eigen::MatrixXd hull = vertices.transpose().colPivHouseholderQr().solve(Eigen::MatrixXd::Ones(vertices.rows(), 1));
    hull_points_mat = vertices * hull;
    hull_points_mat.transposeInPlace();

    // 计算法向量
    Eigen::Vector3d normal = getNormal(hull_points_mat.col(0), hull_points_mat.col(1), hull_points_mat.col(2));

    // 计算最小包容盒的边界
    double c = hull_points_mat.col(0).dot(normal);
    double min_x = points_mat.row(0).minCoeff(), max_x = points_mat.row(0).maxCoeff();
    double min_y = points_mat.row(1).minCoeff(), max_y = points_mat.row(1).maxCoeff();
    double min_z = points_mat.row(2).minCoeff(), max_z = points_mat.row(2).maxCoeff();

    Eigen::Matrix<double, 3, 8> corners;
    corners << min_x, min_x, max_x, max_x, min_x, min_x, max_x, max_x,
               min_y, max_y, max_y, min_y, min_y, max_y, max_y, min_y,
               (c - normal(0) * min_x - normal(1) * min_y) / normal(2),
               (c - normal(0) * min_x - normal(1) * max_y) / normal(2),
               (c - normal(0) * max_x - normal(1) * max_y) / normal(2),
               (c - normal(0) * max_x - normal(1) * min_y) / normal(2),
               min_z, min_z, min_z, min_z,
               max_z, max_z, max_z, max_z;

    // 计算包容盒中心和旋转矩阵
    Eigen::Vector3d centroid = corners.rowwise().mean();
    corners.colwise() -= centroid;

    Eigen::JacobiSVD<Eigen::Matrix3d> svd(corners, Eigen::ComputeFullV);
    Eigen::Matrix3d rotation_matrix = svd.matrixV().col(0) * svd.matrixV().col(1).transpose();
    if (rotation_matrix.determinant() < 0) {
        rotation_matrix.col(2) *= -1;
    }

    length = (corners.row(0).maxCoeff() - corners.row(0).minCoeff()) / 2.0;
    width = (corners.row(1).maxCoeff() - corners.row(1).minCoeff()) / 2.0;
    height = (corners.row(2).maxCoeff() - corners.row(2).minCoeff()) / 2.0;
    rotation = rotation_matrix;
}

int main() {
    std::vector<Eigen::Vector3d> points {
        {0, 0, 0},
        {1, 0, 0},
        {0, 1, 0},
        {0, 0, 1},
        {1, 1, 1},
        {1, 1, 0},
        {1, 0, 1},
        {0, 1, 1}
    };

    double length, width, height;
    Eigen::Matrix3d rotation;

    getBoundingBox(points, length, width, height, rotation);

    std::cout << "Length: " << length << ", Width: " << width << ", Height: " << height << std::endl;
    std::cout << "Rotation Matrix: \n" << rotation << std::endl;

    return 0;
}

你可以传入一个 `std::vector<Eigen::Vector3d>` 类型的点集作为参数，函数将返回最小包容盒的长度、宽度、高度以及旋转矩阵，其中旋转矩阵是一个 3x3 的矩阵，表示将包容盒沿着 X、Y、Z 轴旋转的角度。这里使用 Eigen 库来进行矩阵计算，如果你没有安装 Eigen 库，可以通过以下命令进行安装：

sudo apt-get install libeigen3-dev