• slam 点云退化

    Lidar Slam退化问题分析报告

    摘要：激光雷达在空旷区域存在点云采集数据较少，特征无法对机器人的位置起到约束的作用，考虑LIW融合对最终定位的影响。当错误的LIW即发生退化，位姿输出不准存在较大误差，如果未检测到退化，协方差没有及时调整，会导致融合模块位置发生异常。退化检测精度对融合位姿输出影响较大。

    • 点云PCA分析（Principle Component Analysis主成分分析）

    PCA（Principal Components Analysis）主成分分析，应用于点云预处理，平面检测，法向量求解，降维、分类，解压（升维），用PCA对点云中的点分类，地面点，墙面点，物体上的点等，是一种数据降维技术，用于数据预处理。PCA是将三维投影到某个面上，用于发现其主要方向。面的选择依据是选择尽量使得点的分布方差最大，分布较散的面，方差越大，它的信息量越大。

    1.1点云特征形式

    点云特征可以分为一维线特征(b)、二维面特征(c)、三维空间特征(a)三种情况，如下图所示。

    1.2 点云特征对定位的影响

    定位一般包含位置(x,y,z)与姿态(roll,pitch,yaw)的估计，激光雷达采集到的点云数据后，与上一帧数据进行匹配，计算出雷达的相对位姿变化。线特征无法对旋转进行约束，面特征无法对平行与该平面的位置进行约束，若想满足对车的位姿进行全方位的约束就需要为空间特征。

    1.3空间特征评估标准

    对于直线特征为直线的斜率及截距；对于平面特征，表征平面向量的方法为坐标原点的及法向量;对于三维空间特征相应的以质心和三个法向量表征，即原点和空间的三个基坐标。点云的法向量用特征向量表示。特征向量最直观的解释之一是它总是指向数据方差最大的方向。更准确地说，第一特征向量是数据方差最大的方向，第二特征向量是与第一特征向量垂直的方向上数据方差最大的方向，第三特征向量是与第一和第二特征向量垂直的方向上数据方差最大的方向，类似于空间坐标系下的基坐标系，以此类推。

    假设在平面坐标系中，每个数据样本都是可以用坐标x、y表示的二维点。这些数据样本的协方差矩阵的特征向量是u和v。较长的u是第一特征向量，较短的v是第二特征向量。特征值的大小用箭头的长度表示。我们可以看到，第一个特征向量（从数据的平均值）指向欧几里德空间中数据方差最大的方向，第二个特征向量跟第一特征向量是垂直的。

    下图是二维空间的一个例子：

    三维空间中的特征向量就比较复杂，如图所示：

    数据在某个基上的投影值(也是在这个基上的坐标值)越分散，方差越大，这个基保留的信息也就越多，信息量保存能力最大的基向量一定是的协方差矩阵的特征向量,并且这个特征向量保存的信息量就是它对应的特征值。

    • 实际测试

    为验证退化检测的有效性，运行了两组数据并进行了分析。

    2.1非退化场景测试

    场景一特征比较丰富，特征较多，场景如下图所示：

    采用此方法检测结果如下：

    根据特征值与特征向量的结果，将特征值按从大到小排序特征值大的表示特征较多。其中橙色与黄色的为第一与第二特征值(图中为了显示缩小了1000倍)，蓝色为特征值最小的取值范围，设置退化的阈值为sort_degen(2)<500且sort_degen(1)/sort_degen(2)>200，当最小方向的特征值过小且第二方向的特征值大于其200倍时认为发散(主要区分只有一个平面特征的情况，如单独无人车的地面特征无法进行位置估计).

    此时的Z方向最高为3米，三个方向特征值为57046、31874、1584，点云分布及特征向量如上图所示。

    以RTK为真值，计算相邻两帧的运动的距离l，与融合相邻两帧的距离为l1，计算l-l1的插值，如下图所示：

    从图中可以看出，rtk与fusion的结果，两帧之间的变化范围在0.3-0.4m，两个结果匹配较高。

    2.2退化场景测试

    退化场景二在场景的右侧点云较少，退化严重。

    matlab显示的结果如下图所示，圆圈标注部分为检测到退化部分。

    退化时点云情况如下：

    三个方向的特征值分别为：43307、12635、52.退化较轻，z方向点较少，最高1m。

    场景三：场景中的特征值分别为：3787、2399、2.95,不满足约束条件。

    下图为添加了退化检测的融合方案，从rtk与融合轨迹对比，未发现由退化引起的位姿输出异常的情况。

    参考：https://github.com/TixiaoShan/LIO-SAM.git

    https://www.cnblogs.com/chenlinchong/p/14907439.html

    https://frc.ri.cmu.edu/~zhangji/publications/ICRA_2016.pdf

    《PCL点云库学习&VS2010(X64)》Part 43 协方差矩阵的特征向量_点云协方差矩阵_梁Rio的博客-CSDN博客

    点云的基本特征和描述，PCA主成分分析_点云特征值_一抹烟霞的博客-CSDN博客

    SLAM中的退化问题_slam退化_Kinetis60的博客-CSDN博客

    lio-sam退化检测：

    1. for (int i = 0; i < laserCloudSelNum; i++) {
    2.             // lidar -> camera
    3.             pointOri.x = laserCloudOri->points[i].y;
    4.             pointOri.y = laserCloudOri->points[i].z;
    5.             pointOri.z = laserCloudOri->points[i].x;
    6.             // lidar -> camera
    7.             coeff.x = coeffSel->points[i].y;
    8.             coeff.y = coeffSel->points[i].z;
    9.             coeff.z = coeffSel->points[i].x;
    10.             coeff.intensity = coeffSel->points[i].intensity;
    11.             // in camera
    12.             float arx = (crx * sry * srz * pointOri.x + crx * crz * sry * pointOri.y - srx * sry * pointOri.z) * coeff.x
    13.                         + (-srx * srz * pointOri.x - crz * srx * pointOri.y - crx * pointOri.z) * coeff.y
    14.                         + (crx * cry * srz * pointOri.x + crx * cry * crz * pointOri.y - cry * srx * pointOri.z) * coeff.z;
    15.  
    16.             float ary = ((cry * srx * srz - crz * sry) * pointOri.x
    17.                          + (sry * srz + cry * crz * srx) * pointOri.y + crx * cry * pointOri.z)
    18.                             * coeff.x
    19.                         + ((-cry * crz - srx * sry * srz) * pointOri.x
    20.                            + (cry * srz - crz * srx * sry) * pointOri.y - crx * sry * pointOri.z)
    21.                               * coeff.z;
    22.  
    23.             float arz = ((crz * srx * sry - cry * srz) * pointOri.x + (-cry * crz - srx * sry * srz) * pointOri.y) * coeff.x
    24.                         + (crx * crz * pointOri.x - crx * srz * pointOri.y) * coeff.y
    25.                         + ((sry * srz + cry * crz * srx) * pointOri.x + (crz * sry - cry * srx * srz) * pointOri.y) * coeff.z;
    26.             // camera -> lidar
    27.             matA.at<float>(i, 0) = arz;
    28.             matA.at<float>(i, 1) = arx;
    29.             matA.at<float>(i, 2) = ary;
    30.             matA.at<float>(i, 3) = coeff.z;
    31.             matA.at<float>(i, 4) = coeff.x;
    32.             matA.at<float>(i, 5) = coeff.y;
    33.             matB.at<float>(i, 0) = -coeff.intensity;
    34.         }
    35.  
    36.         cv::transpose(matA, matAt);
    37.         matAtA = matAt * matA;
    38.         matAtB = matAt * matB;
    39.         cv::solve(matAtA, matAtB, matX, cv::DECOMP_QR);
    40.  
    41.         if (iterCount == 0) {
    42.             cv::Mat matE(1, 6, CV_32F, cv::Scalar::all(0));
    43.             cv::Mat matV(6, 6, CV_32F, cv::Scalar::all(0));
    44.             cv::Mat matV2(6, 6, CV_32F, cv::Scalar::all(0));
    45.  
    46.             cv::eigen(matAtA, matE, matV);
    47.             matV.copyTo(matV2);
    48.  
    49.             isDegenerate = false;
    50.             float eignThre[6] = {100, 100, 100, 100, 100, 100};
    51.             for (int i = 5; i >= 0; i--) {
    52.                 if (matE.at<float>(0, i) < eignThre[i]) {
    53.                     for (int j = 0; j < 6; j++) {
    54.                         matV2.at<float>(i, j) = 0;
    55.                     }
    56.                     isDegenerate = true;
    57.                 } else {
    58.                     break;
    59.                 }
    60.             }
    61.             matP = matV.inv() * matV2;
    62.         }

     fast-lio2打滑检测：

    1.  pcl::compute3DCentroid(*feats_undistort, xyz_centroid);
    2.             pcl::computeCovarianceMatrix(*feats_undistort, xyz_centroid, all_covariance);
    3.  
    4.             Eigen::EigenSolver<Eigen::Matrix3f> es(all_covariance);
    5.             Eigen::VectorXf eigenvalues = es.eigenvalues().real();
    6.             Eigen::VectorXf sorted_eigen;
    7.             Eigen::VectorXi index;
    8.             sort_vec(eigenvalues, sorted_eigen, index);
    9.             fout_degen << sorted_eigen(0) << " "
    10.                        << sorted_eigen(1) << " "
    11.                        << sorted_eigen(2) << std::endl;
    12.             if (sorted_eigen(2) < 1000 && log10(abs(sorted_eigen(1)) / abs(sorted_eigen(2))) > ls_map.eskf_stt_.eigen_degen) {
    13.                 ls_map.car_stt_.flag_degen = true;
    14.                 p_imu->flag_degen_ = true;
    15.                 ls_map.lidar_stt_.savepcd++;
    16.                 if (feats_undistort->points.size() > 0) {
    17.                     std::cerr << "feats_undistort:" << feats_undistort->points.size() << std::endl;
    18.                     savepcl(string(root_dir + "/PCD/" + to_string(ls_map.lidar_stt_.savepcd) + ".pcd"), *feats_undistort);
    19.                 }
    20.                 flag_degen_num = 0;
    21.             }

    matlab显示特征值：

    1. X = load('nodegene/pose_degen.txt');
    2. b1=X(:,1);
    3. b2=X(:,2);
    4. b3=X(:,3);
    5. Y=load('nodegene/pose_out.txt');
    6. ax = Y(:,2);
    7. ay = Y(:,3);
    8. b4=b3;
    9. figure(1)
    10. for i=1:length(b1)
    11.     if(b3(i)<1500&&log10(b2(i) /b3(i) ) > 2.3)%200倍
    12.         plot(ax(i),ay(i),'o');
    13.         b4(i)=0;
    14.         hold on;
    15.     else
    16.         b4(i)=1000;
    17.     end
    18. end
    19. plot(ax,ay)
    20. figure(2)
    21. plot(b3)
    22. hold on;
    23. plot(b1/200)
    24. hold on;
    25. plot(b2/200)
    26. hold on;
    27. plot(b4)

     c++特征值特征向量显示

    1. #include <Eigen/Core>
    2. #include <Eigen/Dense>
    3. #include <boost/thread/thread.hpp>
    4. #include <iostream>
    5. #include <pcl/common/centroid.h>
    6. #include <pcl/common/common_headers.h>
    7. #include <pcl/console/parse.h>
    8. #include <pcl/features/feature.h>
    9. #include <pcl/features/normal_3d.h>
    10. #include <pcl/filters/voxel_grid.h>
    11. #include <pcl/io/pcd_io.h>
    12. #include <pcl/point_cloud.h>
    13. #include <pcl/point_types.h>
    14. #include <pcl/visualization/cloud_viewer.h>
    15. #include <pcl/visualization/pcl_visualizer.h>
    16. #include <string>
    17. #include <unistd.h>
    18.  
    19. using namespace pcl;
    20. using namespace pcl::io;
    21. using namespace Eigen;
    22. using namespace std;
    23. #define PRITF 5
    24. struct VecFeat {
    25.   float val;
    26.   float vec[3];
    27. };
    28. int point_size = 0;
    29. /************************************************************************************************************
    30. /*****************************可视化单个点云：应用PCL
    31. Visualizer可视化类显示单个具有XYZ信息的点云****************/
    32. /************************************************************************************************************/
    33.  
    34. // simpleVis函数实现最基本的点云可视化操作，
    35. boost::shared_ptr<pcl::visualization::PCLVisualizer>
    36. simpleVis(pcl::PointCloud<pcl::PointXYZ>::ConstPtr cloud) {
    37.   // --------------------------------------------
    38.   // -----Open 3D viewer and add point cloud-----
    39.   // --------------------------------------------
    40.   //创建视窗对象并给标题栏设置一个名称“3D
    41.   // Viewer”并将它设置为boost::shared_ptr智能共享指针，这样可以保证指针在程序中全局使用，而不引起内存错误
    42.   boost::shared_ptr<pcl::visualization::PCLVisualizer> viewer(
    43.       new pcl::visualization::PCLVisualizer("3D Viewer"));
    44.   //设置视窗的背景色，可以任意设置RGB的颜色，这里是设置为黑色
    45.   viewer->setBackgroundColor(0, 0, 0);
    46.   /*这是最重要的一行，我们将点云添加到视窗对象中，并定一个唯一的字符串作为ID
    47.    号，利用此字符串保证在其他成员中也能
    48.     标志引用该点云，多次调用addPointCloud可以实现多个点云的添加，，每调用一次就会创建一个新的ID号，如果想更新一个
    49.     已经显示的点云，必须先调用removePointCloud（），并提供需要更新的点云ID 号，
    50.    *******************************************************************************************/
    51.   viewer->addPointCloud<pcl::PointXYZ>(cloud, "sample cloud");
    52.   //用于改变显示点云的尺寸，可以利用该方法控制点云在视窗中的显示方法，
    53.   viewer->setPointCloudRenderingProperties(
    54.       pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 1, "sample cloud");
    55.   /*******************************************************************************************************
    56.     查看复杂的点云，经常让人感到没有方向感，为了保持正确的坐标判断，需要显示坐标系统方向，可以通过使用X（红色）
    57.     Y（绿色 ）Z
    58.    （蓝色）圆柱体代表坐标轴的显示方式来解决，圆柱体的大小可以通过scale参数来控制，本例中scale设置为1.0
    59.  
    60.    ******************************************************************************************************/
    61.   viewer->addCoordinateSystem(1.0);
    62.   //通过设置照相机参数使得从默认的角度和方向观察点云
    63.   viewer->initCameraParameters();
    64.   return (viewer);
    65. }
    66. /*****************************可视化点云颜色特征******************************************************/
    67. /**************************************************************************************************
    68. 多数情况下点云显示不采用简单的XYZ类型，常用的点云类型是XYZRGB点，包含颜色数据，除此之外，还可以给指定的点云定制颜色
    69.  以示得点云在视窗中比较容易区分。点赋予不同的颜色表征其对应的Z轴值不同，PCL
    70. Visualizer可根据所存储的颜色数据为点云 赋色，
    71. 比如许多设备kinect可以获取带有RGB数据的点云，PCL
    72. Vizualizer可视化类可使用这种颜色数据为点云着色，rgbVis函数中的代码
    73. 用于完成这种操作。
    74.  ***************************************************************************************************/
    75. /**************************************************************************
    76.  与前面的示例相比点云的类型发生了变化，这里使用的点云带有RGB数据的属性字段，
    77. ****************************************************************************/
    78. boost::shared_ptr<pcl::visualization::PCLVisualizer>
    79. rgbVis(pcl::PointCloud<pcl::PointXYZRGB>::ConstPtr cloud) {
    80.   // --------------------------------------------
    81.   // -----Open 3D viewer and add point cloud-----
    82.   // --------------------------------------------
    83.   boost::shared_ptr<pcl::visualization::PCLVisualizer> viewer(
    84.       new pcl::visualization::PCLVisualizer("3D Viewer"));
    85.   viewer->setBackgroundColor(0, 0, 0);
    86.   /***************************************************************************************************************
    87.   设置窗口的背景颜色后，创建一个颜色处理对象，PointCloudColorHandlerRGBField利用这样的对象显示自定义颜色数据，PointCloudColorHandlerRGBField
    88.    对象得到每个点云的RGB颜色字段，
    89.   **************************************************************************************************************/
    91.   pcl::visualization::PointCloudColorHandlerRGBField<pcl::PointXYZRGB> rgb(
    92.       cloud);
    93.   viewer->addPointCloud<pcl::PointXYZRGB>(cloud, rgb, "sample cloud");
    94.   viewer->setPointCloudRenderingProperties(
    95.       pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 3, "sample cloud");
    96.   viewer->addCoordinateSystem(1.0);
    97.   viewer->initCameraParameters();
    98.   return (viewer);
    99. }
    100. /******************可视化点云自定义颜色特征**********************************************************/
    101. /****************************************************************************************************
    102. 演示怎样给点云着上单独的一种颜色，可以利用该技术给指定的点云着色，以区别其他的点云，
    103. *****************************************************************************************************/
    104. //点云类型为XYZ类型，customColourVis函数将点云赋值为绿色，
    105. boost::shared_ptr<pcl::visualization::PCLVisualizer>
    106. customColourVis(pcl::PointCloud<pcl::PointXYZ>::ConstPtr cloud) {
    107.   // --------------------------------------------
    108.   // -----Open 3D viewer and add point cloud-----
    109.   // --------------------------------------------
    110.   boost::shared_ptr<pcl::visualization::PCLVisualizer> viewer(
    111.       new pcl::visualization::PCLVisualizer("3D Viewer"));
    112.   viewer->setBackgroundColor(0, 0, 0);
    113.   //创建一个自定义的颜色处理器PointCloudColorHandlerCustom对象，并设置颜色为纯绿色
    114.   pcl::visualization::PointCloudColorHandlerCustom<pcl::PointXYZ> single_color(
    115.       cloud, 0, 255, 0);
    116.   // addPointCloud<>()完成对颜色处理器对象的传递
    117.   viewer->addPointCloud<pcl::PointXYZ>(cloud, single_color, "sample cloud");
    118.   viewer->setPointCloudRenderingProperties(
    119.       pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 3, "sample cloud");
    120.   viewer->addCoordinateSystem(1.0);
    121.   viewer->initCameraParameters();
    122.   return (viewer);
    123. }
    124.  
    125. //*******************可视化点云法线和其他特征*************************************************/
    126. /*********************************************************************************************
    127.  显示法线是理解点云的一个重要步骤，点云法线特征是非常重要的基础特征，PCL
    128.  visualizer可视化类可用于绘制法线，
    129.   也可以绘制表征点云的其他特征，比如主曲率和几何特征，normalsVis函数中演示了如何实现点云的法线，
    130.  ***********************************************************************************************/
    131. boost::shared_ptr<pcl::visualization::PCLVisualizer>
    132. normalsVis(pcl::PointCloud<pcl::PointXYZRGB>::ConstPtr cloud,
    133.            pcl::PointCloud<pcl::Normal>::ConstPtr normals) {
    134.   // --------------------------------------------------------
    135.   // -----Open 3D viewer and add point cloud and normals-----
    136.   // --------------------------------------------------------
    137.   boost::shared_ptr<pcl::visualization::PCLVisualizer> viewer(
    138.       new pcl::visualization::PCLVisualizer("3D Viewer"));
    139.   viewer->setBackgroundColor(0, 0, 0);
    140.   pcl::visualization::PointCloudColorHandlerRGBField<pcl::PointXYZRGB> rgb(
    141.       cloud);
    142.   viewer->addPointCloud<pcl::PointXYZRGB>(cloud, rgb, "sample cloud");
    143.   viewer->setPointCloudRenderingProperties(
    144.       pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 3, "sample cloud");
    145.   //实现对点云法线的显示
    146.   viewer->addPointCloudNormals<pcl::PointXYZRGB, pcl::Normal>(
    147.       cloud, normals, 10, 0.05, "normals");
    148.   viewer->addCoordinateSystem(1.0);
    149.   viewer->initCameraParameters();
    150.   return (viewer);
    151. }
    152.  
    153. //*****************绘制普通形状************************************************//
    154. /**************************************************************************************************************
    155.  PCL
    156. visualizer可视化类允许用户在视窗中绘制一般图元，这个类常用于显示点云处理算法的可视化结果，例如
    157. 通过可视化球体
    158.  包围聚类得到的点云集以显示聚类结果，shapesVis函数用于实现添加形状到视窗中，添加了四种形状：从点云中的一个点到最后一个点
    159.  之间的连线，原点所在的平面，以点云中第一个点为中心的球体，沿Y轴的椎体
    160. *************************************************************************************************************/
    161. boost::shared_ptr<pcl::visualization::PCLVisualizer>
    162. shapesVis(pcl::PointCloud<pcl::PointXYZRGB>::ConstPtr cloud) {
    163.   // --------------------------------------------
    164.   // -----Open 3D viewer and add point cloud添加点云到视窗实例代码-----
    165.   // --------------------------------------------
    166.   boost::shared_ptr<pcl::visualization::PCLVisualizer> viewer(
    167.       new pcl::visualization::PCLVisualizer("3D Viewer"));
    168.   viewer->setBackgroundColor(0, 0, 0);
    169.   pcl::visualization::PointCloudColorHandlerRGBField<pcl::PointXYZRGB> rgb(
    170.       cloud);
    171.   viewer->addPointCloud<pcl::PointXYZRGB>(cloud, rgb, "sample cloud");
    172.   viewer->setPointCloudRenderingProperties(
    173.       pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 3, "sample cloud");
    174.   viewer->addCoordinateSystem(1.0);
    175.   viewer->initCameraParameters();
    176.   /************************************************************************************************
    177.   绘制形状的实例代码，绘制点之间的连线，
    178. *************************************************************************************************/
    179.   viewer->addLine<pcl::PointXYZRGB>(cloud->points[0],
    180.                                     cloud->points[cloud->size() - 1], "line");
    181.   //添加点云中第一个点为中心，半径为0.2的球体，同时可以自定义颜色
    182.   viewer->addSphere(cloud->points[0], 0.2, 0.5, 0.5, 0.0, "sphere");
    183.  
    184.   //---------------------------------------
    185.   //-----Add shapes at other
    186.   // locations添加绘制平面使用标准平面方程ax+by+cz+d=0来定义平面，这个平面以原点为中心，方向沿着Z方向-----
    187.   //---------------------------------------
    188.   pcl::ModelCoefficients coeffs;
    189.   coeffs.values.push_back(0.0);
    190.   coeffs.values.push_back(0.0);
    191.   coeffs.values.push_back(1.0);
    192.   coeffs.values.push_back(0.0);
    193.   viewer->addPlane(coeffs, "plane");
    194.   //添加锥形的参数
    195.   coeffs.values.clear();
    196.   coeffs.values.push_back(0.3);
    197.   coeffs.values.push_back(0.3);
    198.   coeffs.values.push_back(0.0);
    199.   coeffs.values.push_back(0.0);
    200.   coeffs.values.push_back(1.0);
    201.   coeffs.values.push_back(0.0);
    202.   coeffs.values.push_back(5.0);
    203.   viewer->addCone(coeffs, "cone");
    204.  
    205.   return (viewer);
    206. }
    207. /***************
    208.  * cov show
    209.  *************************************************************************************************************/
    210. boost::shared_ptr<pcl::visualization::PCLVisualizer>
    211. CovshapesVis(pcl::PointCloud<pcl::PointXYZRGB>::ConstPtr cloud,
    212.              const Eigen::Vector4f xyz_centroid, VecFeat *vecfeat) {
    213.   // --------------------------------------------
    214.   // -----Open 3D viewer and add point cloud添加点云到视窗实例代码-----
    215.   // --------------------------------------------
    216.   boost::shared_ptr<pcl::visualization::PCLVisualizer> viewer(
    217.       new pcl::visualization::PCLVisualizer("3D Viewer"));
    218.   viewer->setBackgroundColor(1, 1, 1);
    219.   pcl::visualization::PointCloudColorHandlerRGBField<pcl::PointXYZRGB> rgb(
    220.       cloud);
    221.   viewer->addPointCloud<pcl::PointXYZRGB>(cloud, rgb, "sample cloud");
    222.   viewer->setPointCloudRenderingProperties(
    223.       pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 3, "sample cloud");
    224.   // viewer->addCoordinateSystem(1.0);
    225.   // viewer->initCameraParameters();
    226.   pcl::PointXYZRGB center_point, cord_xyz[3];
    227.   center_point.x = xyz_centroid[0];
    228.   center_point.y = xyz_centroid[1];
    229.   center_point.z = xyz_centroid[2];
    230.   double rgb_show[3];
    231.   for (int i = 0; i < 3; i++) {
    232.     rgb_show[i] =
    233.         vecfeat[i].val / (vecfeat[0].val + vecfeat[1].val + vecfeat[2].val);
    234.     cord_xyz[i].x =
    235.         point_size * rgb_show[i] * vecfeat[i].vec[0] + center_point.x;
    236.     cord_xyz[i].y =
    237.         point_size * rgb_show[i] * vecfeat[i].vec[1] + center_point.y;
    238.     cord_xyz[i].z =
    239.         point_size * rgb_show[i] * vecfeat[i].vec[2] + center_point.z;
    240.     string lin_name = to_string(i);
    241.     viewer->addLine<pcl::PointXYZRGB>(center_point, cord_xyz[i], rgb_show[i],
    242.                                       rgb_show[i], rgb_show[i], lin_name);
    243.   }
    244.  
    245.   // viewer->addLine<pcl::PointXYZRGB>(center_point,
    246.   //                              cloud->points[cloud->size() - 1], "line");
    247.   //添加点云中第一个点为中心，半径为0.2的球体，同时可以自定义颜色
    248.   // viewer->addSphere(cloud->points[0], 0.2, 0.5, 0.5, 0.0, "sphere");
    249.  
    250.   //---------------------------------------
    251.   //-----Add shapes at other
    252.   // locations添加绘制平面使用标准平面方程ax+by+cz+d=0来定义平面，这个平面以原点为中心，方向沿着Z方向-----
    253.   //---------------------------------------
    254.   //   pcl::ModelCoefficients coeffs;
    255.   //   coeffs.values.push_back(0.0);
    256.   //   coeffs.values.push_back(0.0);
    257.   //   coeffs.values.push_back(1.0);
    258.   //   coeffs.values.push_back(0.0);
    259.   //   viewer->addPlane(coeffs, "plane");
    260.   //添加锥形的参数
    261.   //   coeffs.values.clear();
    262.   //   coeffs.values.push_back(0.3);
    263.   //   coeffs.values.push_back(0.3);
    264.   //   coeffs.values.push_back(0.0);
    265.   //   coeffs.values.push_back(0.0);
    266.   //   coeffs.values.push_back(1.0);
    267.   //   coeffs.values.push_back(0.0);
    268.   //   coeffs.values.push_back(5.0);
    269.   //   viewer->addCone(coeffs, "cone");
    270.  
    271.   return (viewer);
    272. }
    273. /******************************************************************************************
    274.  多视角显示：PCL
    275. visealizer可视化类允许用户通过不同的窗口（Viewport）绘制多个点云这样方便对点云比较
    276.  viewportsVis函数演示如何用多视角来显示点云计算法线的方法结果对比
    277. ******************************************************************************************/
    278.  
    279. boost::shared_ptr<pcl::visualization::PCLVisualizer>
    280. viewportsVis(pcl::PointCloud<pcl::PointXYZRGB>::ConstPtr cloud,
    281.              pcl::PointCloud<pcl::Normal>::ConstPtr normals1,
    282.              pcl::PointCloud<pcl::Normal>::ConstPtr normals2) {
    283.   // --------------------------------------------------------
    284.   // -----Open 3D viewer and add point cloud and normals-----
    285.   // --------------------------------------------------------
    286.   boost::shared_ptr<pcl::visualization::PCLVisualizer> viewer(
    287.       new pcl::visualization::PCLVisualizer("3D Viewer"));
    288.   viewer->initCameraParameters();
    289.   //以上是创建视图的标准代码
    290.  
    291.   int v1(0); //创建新的视口
    292.   viewer->createViewPort(
    293.       0.0, 0.0, 0.5, 1.0,
    294.       v1); // 4个参数分别是X轴的最小值，最大值，Y轴的最小值，最大值，取值0-1，v1是标识
    295.   viewer->setBackgroundColor(0, 0, 0, v1); //设置视口的背景颜色
    296.   viewer->addText(
    297.       "Radius: 0.01", 10, 10, "v1 text",
    298.       v1); //添加一个标签区别其他窗口  利用RGB颜色着色器并添加点云到视口中
    299.   pcl::visualization::PointCloudColorHandlerRGBField<pcl::PointXYZRGB> rgb(
    300.       cloud);
    301.   viewer->addPointCloud<pcl::PointXYZRGB>(cloud, rgb, "sample cloud1", v1);
    302.   //对第二视口做同样的操作，使得做创建的点云分布于右半窗口，将该视口背景赋值于灰色，以便明显区别，虽然添加同样的点云，给点云自定义颜色着色
    303.   int v2(0);
    304.   viewer->createViewPort(0.5, 0.0, 1.0, 1.0, v2);
    305.   viewer->setBackgroundColor(0.3, 0.3, 0.3, v2);
    306.   viewer->addText("Radius: 0.1", 10, 10, "v2 text", v2);
    307.   pcl::visualization::PointCloudColorHandlerCustom<pcl::PointXYZRGB>
    308.       single_color(cloud, 0, 255, 0);
    309.   viewer->addPointCloud<pcl::PointXYZRGB>(cloud, single_color, "sample cloud2",
    310.                                           v2);
    311.   //为所有视口设置属性，
    312.   viewer->setPointCloudRenderingProperties(
    313.       pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 3, "sample cloud1");
    314.   viewer->setPointCloudRenderingProperties(
    315.       pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 3, "sample cloud2");
    316.   viewer->addCoordinateSystem(1.0);
    317.   //添加法线  每个视图都有一组对应的法线
    318.   viewer->addPointCloudNormals<pcl::PointXYZRGB, pcl::Normal>(
    319.       cloud, normals1, 10, 0.05, "normals1", v1);
    320.   viewer->addPointCloudNormals<pcl::PointXYZRGB, pcl::Normal>(
    321.       cloud, normals2, 10, 0.05, "normals2", v2);
    322.  
    323.   return (viewer);
    324. }
    325. /*******************************************************************************************************
    326.  这里是处理鼠标事件的函数，每次相应鼠标时间都会回电函数，需要从event实例提取事件信息，本例中查找鼠标左键的释放事件
    327.  每次响应这种事件都会在鼠标按下的位置上生成一个文本标签。
    328.  *********************************************************************************************************/
    330. unsigned int text_id = 0;
    331. void keyboardEventOccurred(const pcl::visualization::KeyboardEvent &event,
    332.                            void *viewer_void) {
    333.   pcl::visualization::PCLVisualizer *viewer =
    334.       static_cast<pcl::visualization::PCLVisualizer *>(viewer_void);
    335.   if (event.getKeySym() == "r" && event.keyDown()) {
    336.     std::cout << "r was pressed => removing all text" << std::endl;
    337.  
    338.     char str[512];
    339.     for (unsigned int i = 0; i < text_id; ++i) {
    340.       sprintf(str, "text#%03d", i);
    341.       viewer->removeShape(str);
    342.     }
    343.     text_id = 0;
    344.   }
    345. }
    346. /********************************************************************************************
    347. 键盘事件 我们按下哪个按键  如果按下r健
    348. 则删除前面鼠标所产生的文本标签，需要注意的是，当按下R键时 3D相机仍然会重置
    349.  所以在PCL中视窗中注册事件响应回调函数，不会覆盖其他成员对同一事件的响应
    350. **************************************************************************************************/
    351. void mouseEventOccurred(const pcl::visualization::MouseEvent &event,
    352.                         void *viewer_void) {
    353.   pcl::visualization::PCLVisualizer *viewer =
    354.       static_cast<pcl::visualization::PCLVisualizer *>(viewer_void);
    355.   if (event.getButton() == pcl::visualization::MouseEvent::LeftButton &&
    356.       event.getType() == pcl::visualization::MouseEvent::MouseButtonRelease) {
    357.     std::cout << "Left mouse button released at position (" << event.getX()
    358.               << ", " << event.getY() << ")" << std::endl;
    359.  
    360.     char str[512];
    361.     sprintf(str, "text#%03d", text_id++);
    362.     viewer->addText("clicked here", event.getX(), event.getY(), str);
    363.   }
    364. }
    365.  
    366. /******************自定义交互*****************************************************************************/
    367. /******************************************************************************************************
    368.  多数情况下，默认的鼠标和键盘交互设置不能满足用户的需求，用户想扩展函数的某一些功能，
    369.  比如按下键盘时保存点云的信息， 或者通过鼠标确定点云的位置
    370.  interactionCustomizationVis函数进行演示如何捕捉鼠标和键盘事件，在窗口点击，将会显示
    371.  一个2D的文本标签，按下r健出去文本
    372.  ******************************************************************************************************/
    374. boost::shared_ptr<pcl::visualization::PCLVisualizer>
    375. interactionCustomizationVis() {
    376.   boost::shared_ptr<pcl::visualization::PCLVisualizer> viewer(
    377.       new pcl::visualization::PCLVisualizer("3D Viewer"));
    378.   viewer->setBackgroundColor(0, 0, 0);
    379.   //以上是实例化视窗的标准代码
    380.   viewer->addCoordinateSystem(1.0);
    381.   //分别注册响应键盘和鼠标事件，keyboardEventOccurred
    382.   // mouseEventOccurred回调函数，需要将boost::shared_ptr强制转换为void*
    383.   viewer->registerKeyboardCallback(keyboardEventOccurred, (void *)viewer.get());
    384.   viewer->registerMouseCallback(mouseEventOccurred, (void *)viewer.get());
    385.  
    386.   return (viewer);
    387. }
    388. /********************************************************
    389.  * 计算点云中点坐标
    390.  * 功能与函数相同
    391.  * pcl::compute3DCentroid(*feats_undistort, xyz_centroid);
    392.  */
    393. Eigen::Vector4f ComputeCent(const pcl::PointCloud<pcl::PointXYZ>::Ptr cloud) {
    394.   //计算中心点坐标
    395.   Eigen::Vector4f pcl_center = Eigen::Vector4f::Zero(4);
    396.   for (int i = 0; i < cloud->points.size(); i++) {
    397.     pcl_center[0] += cloud->points[i].x;
    398.     pcl_center[1] += cloud->points[i].y;
    399.     pcl_center[2] += cloud->points[i].z;
    400.   }
    401.   pcl_center = pcl_center / cloud->points.size();
    402.   pcl_center[3] = 1.0;
    403.   return pcl_center;
    404. }
    405. /****************************
    406.  * 根据点云的中点和点云计算点云的方差
    407.  * pcl::computeCovarianceMatrix(*feats_undistort, xyz_centroid,
    408.                                    all_covariance);
    409.  */
    410. Eigen::Matrix3f ComputeCov(Eigen::Vector4f &center,
    411.                            const pcl::PointCloud<pcl::PointXYZ>::Ptr cloud) {
    412.   int cld_sz = 1.0;
    413.   double xx = 0, xy = 0, xz = 0, yy = 0, yz = 0, zz = 0;
    414.   for (int i = 0; i < cloud->points.size(); i++) {
    415.     xx += (cloud->points[i].x - center[0]) * (cloud->points[i].x - center[0]);
    416.     xy += (cloud->points[i].x - center[0]) * (cloud->points[i].y - center[1]);
    417.     xz += (cloud->points[i].x - center[0]) * (cloud->points[i].z - center[2]);
    418.     yy += (cloud->points[i].y - center[1]) * (cloud->points[i].y - center[1]);
    419.     yz += (cloud->points[i].y - center[1]) * (cloud->points[i].z - center[2]);
    420.     zz += (cloud->points[i].z - center[2]) * (cloud->points[i].z - center[2]);
    421.   }
    422.   //大小为3*3的协方差矩阵
    423.   Eigen::Matrix3f covMat(3, 3);
    424.   covMat(0, 0) = xx / cld_sz;
    425.   covMat(0, 1) = covMat(1, 0) = xy / cld_sz;
    426.   covMat(0, 2) = covMat(2, 0) = xz / cld_sz;
    427.   covMat(1, 1) = yy / cld_sz;
    428.   covMat(1, 2) = covMat(2, 1) = yz / cld_sz;
    429.   covMat(2, 2) = zz / cld_sz;
    430.   return covMat;
    431. }
    432. /*************************************
    433.  *input: vec特征值
    434.  *output:sorted_vec 排序后的特征值
    435.  *      :ind 排序后的特征值对应的特征向量编号
    436.  *
    437.  ***************************************/
    438. void sort_vec(const Vector3f &vec, Vector3f &sorted_vec, Vector3i &ind) {
    439.   ind = Vector3i::LinSpaced(vec.size(), 0, vec.size() - 1);
    440.   auto rule = [vec](int i, int j) -> bool { return abs(vec(i)) > abs(vec(j)); };
    441.   std::sort(ind.data(), ind.data() + ind.size(), rule);
    442.   sorted_vec.resize(vec.size());
    443.   for (int i = 0; i < vec.size(); i++) {
    444.     sorted_vec(i) = vec(ind(i));
    445.   }
    446. }
    447. /******************************************
    448.  * 计算特征值和特征向量
    449.  *input:cloud-点云
    450.  *output:xyz_centroid-点云中心坐标
    451.  *      特征值与特征向量vecfeat为3维数组
    452.  *
    453.  *****************************************/
    454. void ComputePclVec(const pcl::PointCloud<pcl::PointXYZ>::Ptr cloud,
    455.                    Eigen::Vector4f &xyz_centroid, VecFeat *vecfeat) {
    456.   Eigen::Matrix3f all_covariance;
    457.   pcl::compute3DCentroid(*cloud, xyz_centroid);
    458.   pcl::computeCovarianceMatrix(*cloud, xyz_centroid, all_covariance);
    459.   if (PRITF == 1)
    460.     std::cerr << "begin:" << xyz_centroid << ";" << ComputeCent(cloud) << ";"
    461.               << ComputeCov(xyz_centroid, cloud) << ";" << all_covariance
    462.               << std::endl;
    463.   //求特征值与特征向量
    464.   Eigen::EigenSolver<Eigen::Matrix3f> es(all_covariance);
    465.   Eigen::Matrix3f valMat = es.pseudoEigenvalueMatrix(); //特征值矩阵
    466.   Eigen::Vector3f val = es.eigenvalues().real();        //特征值
    467.   Eigen::Matrix3f vec = es.pseudoEigenvectors();        //特征向量
    468.                                                  //找到最小特征值t1
    469.   // val(0,0) val(1,1) val(2,2)协方差矩阵中，就是
    470.   // 只有对角线元素不为零，两个变量是独立的
    471.   //对应三个特征向量
    472.   if (PRITF == 2)
    473.     std::cerr << "特征值" << val << "value 2" << es.eigenvalues().real()
    474.               << " 特征向量" << vec << std::endl;
    475.   Eigen::Vector3f sorted_eigen; //排序后的特征值
    476.   Eigen::Vector3i index; //按特征值大小排序后的特征向量编号
    477.   sort_vec(val, sorted_eigen, index);
    478.   for (int i = 0; i < 3; i++) {
    479.     vecfeat[i].val = sorted_eigen[i];
    480.     std::cerr << "num " << i << " :"
    481.               << "val is :" << vecfeat[i].val << std::endl;
    482.     for (int j = 0; j < 3; j++)
    483.       vecfeat[i].vec[j] = vec(j, i);
    484.     std::cerr << "vec is:" << vecfeat[0].vec[i] << "," << vecfeat[1].vec[i]
    485.               << "," << vecfeat[2].vec[i] << std::endl;
    486.   }
    487.   std::cerr << vecfeat << std::endl;
    488. }
    489. /**
    490.  * 保存点云
    491.  * name:a.pcd
    492.  * @return int
    493.  */
    494. template <typename T> int savepcl(string name, T &incloud) {
    495.   pcl::PointCloud<pcl::PointXYZ> cloud;
    496.   // 创建点云
    497.   cloud.width = 1;
    498.   cloud.height = incloud.points.size();
    499.   cloud.is_dense = false;
    500.   cloud.points.resize(incloud.points.size());
    501.  
    502.   for (size_t i = 0; i < incloud.points.size(); ++i) {
    503.     // 坐标范围在[0,1024),正方体内随机取点
    504.     cloud.points[i].x = incloud.points[i].x;
    505.     cloud.points[i].y = incloud.points[i].y;
    506.     cloud.points[i].z = incloud.points[i].z;
    507.   }
    508.   pcl::io::savePCDFileASCII(name, cloud);
    509.   return (0);
    510. }
    511. /*****
    512.  * 生成点云
    513.  * 形式
    514.  */
    515. template <typename T> int genpcl(T &cloud, int mode) {
    516.   // pcl::PointCloud<pcl::PointXYZ> cloud;
    517.   // 创建点云
    518.   if (mode == 0) {
    519.     cloud.width = 10000;
    520.     cloud.height = 1;
    521.     cloud.is_dense = false;
    522.     cloud.points.resize(cloud.width * cloud.height);
    523.  
    524.     for (size_t i = 0; i < cloud.points.size(); ++i) {
    525.       // 坐标范围在[0,1024),正方体内随机取点
    526.       cloud.points[i].x = 1024 * (rand() / (RAND_MAX + 1.0f));
    527.       cloud.points[i].y = 1024 * (rand() / (RAND_MAX + 1.0f));
    528.       cloud.points[i].z = 1024 * (rand() / (RAND_MAX + 1.0f));
    529.     }
    530.   }
    531.   return (0);
    532. }
    533. /***
    534.  * 读取点云
    535.  *
    536.  */
    537. int readpcl(pcl::PointCloud<pcl::PointXYZ>::Ptr cloud, string name) {
    538.   if (pcl::io::loadPCDFile<pcl::PointXYZ>(name, *cloud) == -1) //*打开点云文件
    539.   {
    540.     PCL_ERROR("Couldn't read file test_pcd.pcd\n");
    541.     return (-1);
    542.   }
    543. } /***
    544.    *删除过远点
    545.    */
    546. void removefar(pcl::PointCloud<pcl::PointXYZ>::Ptr cloud, float distance,
    547.                float dismin) {
    548.   pcl::PointCloud<pcl::PointXYZ> cloudtmp;
    549.   double maxz = 0;
    550.   for (int i = 0; i < cloud->points.size(); i++) {
    551.     double dis = sqrt(cloud->points[i].x * cloud->points[i].x +
    552.                       cloud->points[i].y * cloud->points[i].y);
    553.     if (cloud->points[i].z > maxz)
    554.       maxz = cloud->points[i].z;
    555.     if ((abs(cloud->points[i].x) < distance) &&
    556.         (abs(cloud->points[i].y) < distance) && dis > dismin) {
    557.       cloudtmp.points.push_back(cloud->points[i]);
    558.     }
    559.   }
    560.   std::cerr << "max z:" << maxz << std::endl;
    561.   *cloud = cloudtmp;
    562. }
    563. int main(int argc, char **argv) {
    564.   int choose = atoi(argv[1]);
    565.   int points_cloud_mod = atoi(argv[2]);
    566.   if (1) {
    567.     // ------------------------------------
    568.     // -----Create example point cloud-----
    569.     // ------------------------------------
    570.     pcl::PointCloud<pcl::PointXYZ>::Ptr basic_cloud_ptr(
    571.         new pcl::PointCloud<pcl::PointXYZ>);
    572.     pcl::PointCloud<pcl::PointXYZRGB>::Ptr point_cloud_ptr(
    573.         new pcl::PointCloud<pcl::PointXYZRGB>);
    574.     std::cout << "Genarating example point clouds.\n\n";
    575.     // We're going to make an ellipse extruded along the z-axis. The colour for
    576.     // the XYZRGB cloud will gradually go from red to green to blue.
    577.     uint8_t r(255), g(15), b(15);
    578.     /*点云模式选择：
    579.     ***0:圆 45*num
    580.     **1:矩形
    581.     */
    582.     if (points_cloud_mod == 0) {
    583.       int choose_angle = 2.0;
    584.       point_size = 1.0;
    585.       for (float z(-1.0); z <= 1.0; z += 0.05) {
    586.         for (float angle(0.0); angle <= choose_angle * 45; angle += 5.0) {
    587.           pcl::PointXYZ basic_point;
    588.           basic_point.x = 0.5 * cosf(pcl::deg2rad(angle));
    589.           basic_point.y = sinf(pcl::deg2rad(angle));
    590.           basic_point.z = z;
    591.           basic_cloud_ptr->points.push_back(basic_point);
    593.           pcl::PointXYZRGB point;
    594.           point.x = basic_point.x;
    595.           point.y = basic_point.y;
    596.           point.z = basic_point.z;
    597.           uint32_t rgb =
    598.               (static_cast(r) << 16 | static_cast(g) << 8 |
    599.                static_cast(b));
    600.           point.rgb = *reinterpret_cast(&rgb);
    601.           point_cloud_ptr->points.push_back(point);
    602.         }
    603.         if (z < 0.0) {
    604.           r -= 12;
    605.           g += 12;
    606.         } else {
    607.           g -= 12;
    608.           b += 12;
    609.         }
    610.       }
    611.     } else if (points_cloud_mod == 1) {
    612.       point_size = 1024;
    613.       for (int i = 0; i < 1024; i++) {
    614.         pcl::PointXYZ basic_point;
    615.         basic_point.x = 1024 * (rand() / (RAND_MAX + 1.0f));
    616.         basic_point.y = 1024 * (rand() / (RAND_MAX + 1.0f));
    617.         basic_point.z = 1 * (rand() / (RAND_MAX + 1.0f));
    618.         basic_cloud_ptr->points.push_back(basic_point);
    619.         pcl::PointXYZRGB point;
    620.         point.x = basic_point.x;
    621.         point.y = basic_point.y;
    622.         point.z = basic_point.z;
    623.         uint32_t rgb =
    624.             (static_cast(r) << 16 | static_cast(g) << 8 |
    625.              static_cast(b));
    626.         point.rgb = *reinterpret_cast(&rgb);
    627.         point_cloud_ptr->points.push_back(point);
    628.         if (basic_point.z < 1024.0) {
    629.           r -= 12;
    630.           g += 12;
    631.         } else {
    632.           g -= 12;
    633.           b += 12;
    634.         }
    635.       }
    636.     } else if (points_cloud_mod == 2) {
    637.       point_size = 1024;
    638.       for (int i = 0; i < 1024; i++) {
    639.         pcl::PointXYZ basic_point;
    640.         basic_point.x = 1024 * (rand() / (RAND_MAX + 1.0f));
    641.         basic_point.y = 1024 * (rand() / (RAND_MAX + 1.0f));
    642.         basic_point.z = 1;
    643.         basic_cloud_ptr->points.push_back(basic_point);
    644.         pcl::PointXYZRGB point;
    645.         point.x = basic_point.x;
    646.         point.y = basic_point.y;
    647.         point.z = basic_point.z;
    648.         uint32_t rgb =
    649.             (static_cast(r) << 16 | static_cast(g) << 8 |
    650.              static_cast(b));
    651.         point.rgb = *reinterpret_cast(&rgb);
    652.         point_cloud_ptr->points.push_back(point);
    653.         if (basic_point.z < 1024.0) {
    654.           r -= 12;
    655.           g += 12;
    656.         } else {
    657.           g -= 12;
    658.           b += 12;
    659.         }
    660.       }
    661.     } else if (points_cloud_mod == 3) {
    662.       point_size = 50;
    663.       string file_name = "../pcd/" + (string)argv[3];
    664.       readpcl(basic_cloud_ptr, file_name);
    665.       removefar(basic_cloud_ptr, 70, 0);
    666.       pcl::copyPointCloud(*basic_cloud_ptr, *point_cloud_ptr);
    667.     } else if (points_cloud_mod == 4) {
    668.       point_size = 50;
    669.       genpcl(*basic_cloud_ptr, 0);
    670.       savepcl("../pcd/pcl.pcd", *basic_cloud_ptr);
    671.       pcl::copyPointCloud(*basic_cloud_ptr, *point_cloud_ptr);
    672.     }
    673.     basic_cloud_ptr->width = (int)basic_cloud_ptr->points.size();
    674.     basic_cloud_ptr->height = 1;
    675.     point_cloud_ptr->width = (int)point_cloud_ptr->points.size();
    676.     point_cloud_ptr->height = 1;
    678.     // ----------------------------------------------------------------
    679.     // -----Calculate surface normals with a search radius of 0.05-----
    680.     // ----------------------------------------------------------------
    681.     pcl::NormalEstimation ne;
    682.     ne.setInputCloud(point_cloud_ptr);
    683.     pcl::search::KdTree::Ptr tree(
    684.         new pcl::search::KdTree());
    685.     ne.setSearchMethod(tree);
    686.     pcl::PointCloud::Ptr cloud_normals1(
    687.         new pcl::PointCloud);
    688.     ne.setRadiusSearch(0.05);
    689.     ne.compute(*cloud_normals1);
    691.     // ---------------------------------------------------------------
    692.     // -----Calculate surface normals with a search radius of 0.1-----
    693.     // ---------------------------------------------------------------
    694.     pcl::PointCloud::Ptr cloud_normals2(
    695.         new pcl::PointCloud);
    696.     ne.setRadiusSearch(0.1);
    697.     ne.compute(*cloud_normals2);
    699.     boost::shared_ptr viewer;
    700.     if (choose == 1) {
    701.       viewer = simpleVis(basic_cloud_ptr);
    702.     } else if (choose == 2) {
    703.       viewer = rgbVis(point_cloud_ptr);
    704.     } else if (choose == 3) {
    705.       viewer = customColourVis(basic_cloud_ptr);
    706.     } else if (choose == 4) {
    707.       viewer = normalsVis(point_cloud_ptr, cloud_normals2);
    708.     } else if (choose == 5) {
    709.       viewer = shapesVis(point_cloud_ptr);
    710.     } else if (choose == 6) {
    711.       viewer = viewportsVis(point_cloud_ptr, cloud_normals1, cloud_normals2);
    712.     } else if (choose == 7) {
    713.       viewer = interactionCustomizationVis();
    714.     } else if (choose == 8) {
    715.       Eigen::Vector4f xyz_centroid;
    716.       VecFeat vecfeat[3];
    717.       ComputePclVec(basic_cloud_ptr, xyz_centroid, &vecfeat[0]);
    718.       viewer = CovshapesVis(point_cloud_ptr, xyz_centroid, &vecfeat[0]);
    719.     }
    721.     //--------------------
    722.     // -----Main loop-----
    723.     //--------------------
    724.     while (!viewer->wasStopped()) {
    725.       viewer->spinOnce(100);
    726.       boost::this_thread::sleep(boost::posix_time::microseconds(100000));
    727.     }
    728.   }
    729.   return 0;
    730. }

     特征值求解solver

     

  • 相关阅读:
    山与路远程控制 一个基于electron和golang实现的远控软件
    通达信交易接口
    python的反射机制
    大模型培训老师叶梓 AI编程的未来：GitHub Copilot的创新之旅与实践智慧
    c++11 智能指针-辅助类 （std::enable_shared_from_this）
    ComfyUI中实现反推提示词的多种方案
    Spring Cloud Alibaba（Nacos+Open Feign）微服务项目如何在本地调试，每次都调用本地的服务？
    PMBOK史上最大的改版，你知道到底有什么精华嘛？
    制造企业有了ERP，是否需要MES系统？
    2023/9/15 -- C++/QT
  • 原文地址：https://blog.csdn.net/JanKin_BY/article/details/132851723