官方文档：Point Cloud Library (PCL): Module common

中文说明：

下面所有的程序共用如下的CmakeLists.txt文件

// CMakeLists.txt 文件
// 后面将projectname安装自己的名字更改
cmake_minimum_required(VERSION 2.6)
project(projectname)
 
find_package(PCL 1.10 REQUIRED)
include_directories(${PCL_INCLUDE_DIRS})
link_directories(${PCL_LIBRARY_DIRS})
add_definitions(${PCL_DEFINITIONS})

add_executable(projectname projectname.cpp)
target_link_libraries (projectname ${PCL_LIBRARIES} )

install(TARGETS projectname RUNTIME DESTINATION bin)

（1）angle角度转换

在pcl/common/angel.h文件中，有三个函数实现

// 从弧度到角度
pcl::rad2deg(float alpha) 
// 从角度到弧度
pcl::deg2rad(float aipha)
// 正则化角度在（-PI，PI）之间
pcl::normAngle(float alpha)

#include <iostream>
#include <pcl/common/angles.h>
using namespace std;

int main()
{
    float alpha = 30;
    cout << pcl::deg2rad(alpha) << "-" << 30.0*3.14159/180 << endl;
    double beta = pcl::deg2rad(alpha)*2;
    cout << pcl::rad2deg(beta) << endl;

    return 0;
}

（2）distance距离计算

在distance头文件中总共有五个函数，包括 lineToLineSegment 、sqrPointToLineDistance 、getMaxSegment、squaredEuclideanDistance 、euclideanDistance这五个函数。

// 获取两条三维直线之间的最短三维线段
pcl::lineToLineSegment (const Eigen::VectorXf &line_a, const Eigen::VectorXf &line_b, Eigen::Vector4f &pt1_seg, Eigen::Vector4f &pt2_seg)
// 在给定的一组点中获得最大分段，并返回最小和最大点。
pcl::getMaxSegment (const pcl::PointCloud< PointT > &cloud, PointT &pmin, PointT &pmax)
// 获取点到线的平方距离（由点和方向表示）
pcl::sqrPointToLineDistance (const Eigen::Vector4f &pt, const Eigen::Vector4f &line_pt, const Eigen::Vector4f &line_dir)
// 欧氏距离平方求解
pcl::squaredEuclideanDistance (const PointType1& p1, const PointType2& p2)
// 欧式距离求解
euclideanDistance (const PointType1& p1, const PointType2& p2)

#include <iostream>
#include <pcl/point_cloud.h>
#include <pcl/io/pcd_io.h>
#include <pcl/visualization/pcl_visualizer.h>
#include <pcl/common/distances.h>

using namespace std;

int main()
{
    pcl::visualization::PCLVisualizer::Ptr viewer(new pcl::visualization::PCLVisualizer);
    viewer->setWindowName("PCL Distance Demo");

#if 0
    // 1. lineToLineSegment
    Eigen::VectorXf line_a(6),line_b(6);
    Eigen::Vector4f pt1_seg, pt2_seg;

    line_a << -5,0,0,10,0,0;
    line_b << 0,-5,5,0,10,0;

    pcl::ModelCoefficients line_coeff;
    line_coeff.values.resize (6);

    // line_a
    line_coeff.values[0] = line_a(0);
    line_coeff.values[1] = line_a(1);
    line_coeff.values[2] = line_a(2);

    line_coeff.values[3] = line_a(3);
    line_coeff.values[4] = line_a(4);
    line_coeff.values[5] = line_a(5);
    viewer->addLine(line_coeff,"line_a");

    // line_b
    line_coeff.values[0] = line_b(0);
    line_coeff.values[1] = line_b(1);
    line_coeff.values[2] = line_b(2);

    line_coeff.values[3] = line_b(3);
    line_coeff.values[4] = line_b(4);
    line_coeff.values[5] = line_b(5);
    viewer->addLine(line_coeff,"line_b");

    pcl::lineToLineSegment(line_a,line_b,pt1_seg, pt2_seg);

    viewer->addLine(pcl::PointXYZ(pt1_seg.x(),pt1_seg.y(),pt1_seg.z()),
                    pcl::PointXYZ(pt2_seg.x(),pt2_seg.y(),pt2_seg.z()),
                    1.0,0,0,"lineseg");

    // 2. sqrPointToLineDistance
    double disSqr =  pcl::sqrPointToLineDistance(pt1_seg,
                                                 Eigen::Vector4f(line_b(0),line_b(1),line_b(2),0),
                                                 Eigen::Vector4f(line_b(3),line_b(4),line_b(5),0));

    cout << "pcl::sqrPointToLineDistance: " << disSqr << endl;

    // 3. squaredEuclideanDistance
    float dis = pcl::squaredEuclideanDistance(pcl::PointXYZ(pt1_seg.x(),pt1_seg.y(),pt1_seg.z()),
                                              pcl::PointXYZ(pt2_seg.x(),pt2_seg.y(),pt2_seg.z()));

    cout << "pcl::squaredEuclideanDistance: " << dis << endl;

    // 4. euclideanDistance
    dis = pcl::euclideanDistance(pcl::PointXYZ(pt1_seg.x(),pt1_seg.y(),pt1_seg.z()),
                                 pcl::PointXYZ(pt2_seg.x(),pt2_seg.y(),pt2_seg.z()));

    cout << "pcl::squaredEuclideanDistance: " << dis << endl;

#else
    // 5. getMaxSegment
    pcl::PointCloud<pcl::PointXYZRGB> cloud;
    pcl::io::loadPCDFile("../pig1.pcd",cloud);
    pcl::visualization::PointCloudColorHandlerRGBField<pcl::PointXYZRGB> rgb(cloud.makeShared());
    viewer->addPointCloud(cloud.makeShared(),rgb);

    pcl::PointXYZRGB pmin,pmax;
    double maxseg = pcl::getMaxSegment(cloud,pmin,pmax);
    cout << "pcl::getMaxSegment: " << maxseg << endl;
    viewer->addArrow(pmin,pmax,1.0,0.0,1.0,0,1.0,1.0);
#endif

    while(!viewer->wasStopped())
        viewer->spinOnce(100);

    return 0;
}

（3）random随机数生成

//高斯噪声产生器
pcl::common::CloudGenerator<pcl::PointXYZ, pcl::common::NormalGenerator<float> > generator;  
//均匀分布噪声产生器
pcl::common::UniformGenerator<pcl::PointXYZ, pcl::common::NormalGenerator<float> > 
//生成随机种子  
uint32_t seed = static_cast<uint32_t> (time(NULL));                                         

//根据参数添加x方向的噪声
pcl::common::NormalGenerator<float>::Parameters x_params(xmean, xstddev, seed++);
generator.setParametersForX(x_params);                                                  
//根据参数添加y方向的噪声   
pcl::common::NormalGenerator<float>::Parameters y_params(ymean, ystddev, seed++);
generator.setParametersForY(y_params);                                                 
//根据参数添加z方向的噪声    
pcl::common::NormalGenerator<float>::Parameters z_params(zmean, zstddev, seed++);
generator.setParametersForZ(z_params);                                                   

//产生等数据量的随机噪声    
generator.fill((*cloud).width, (*cloud).height, *gauss_cloud);                                

#include <iostream>
#include <ctime>
#include <pcl/common/random.h>
#include <pcl/point_cloud.h>
#include <pcl/visualization/pcl_visualizer.h>

using namespace std;

int main()
{
    pcl::PointCloud<pcl::PointXYZ> ncloud,ucloud;

    uint32_t seed = static_cast<uint32_t> (time(NULL));
    pcl::common::NormalGenerator<float> normal(0,5,seed);

    for(int i = 0; i < 2000; ++i)
    {
         ncloud.push_back(pcl::PointXYZ(normal.run(),normal.run(),normal.run()));
    }

    pcl::common::UniformGenerator<float> uniform(0,10,seed);

    for(int i = 0; i < 2000; ++i)
    {
        ucloud.push_back(pcl::PointXYZ(uniform.run()+10,uniform.run(),uniform.run()));
    }

    pcl::visualization::PCLVisualizer::Ptr viewer(new pcl::visualization::PCLVisualizer());
    viewer->setWindowName("PCL Random Test");
    pcl::visualization::PointCloudColorHandlerGenericField<pcl::PointXYZ> rgb(ncloud.makeShared(),"z");

    viewer->addPointCloud(ncloud.makeShared(),rgb,"normal");
    viewer->setPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_POINT_SIZE,4,"normal");
    viewer->addPointCloud(ucloud.makeShared(),rgb,"uniform");
    viewer->setPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_POINT_SIZE,4,"uniform");

    while(!viewer->wasStopped())
        viewer->spinOnce(100);

    return 0;
}

（4）sping扩展模块

// 按行扩展
pcl::common::expandRows (const PointCloud<PointT>& input, PointCloud<PointT>& output,
                         const PointT& val, const std::size_t& amount)
// 按列扩展
pcl::common::expandColumns (const PointCloud<PointT>& input, PointCloud<PointT>& output, 
                            const PointT& val, const std::size_t& amount)
// 复制行
pcl::common::duplicateRows (const PointCloud<PointT>& input, PointCloud<PointT>& output,
                            const std::size_t& amount)
// 复制列
pcl::common::duplicateColumns (const PointCloud<PointT>& input, PointCloud<PointT>& output,
                               const std::size_t& amount)
// 删除行
pcl::common::deleteRows (const PointCloud<PointT>& input, PointCloud<PointT>& output,
                         const std::size_t& amount)
// 删除列
pcl::common::deleteCols (const PointCloud<PointT>& input, PointCloud<PointT>& output,
                         const std::size_t& amount)
// 镜像翻转行
pcl::common::mirrorRows (const PointCloud<PointT>& input, PointCloud<PointT>& output,
                         const std::size_t& amount)
// 镜像翻转列
pcl::common::mirrorColumns (const PointCloud<PointT>& input, PointCloud<PointT>& output,
                                  const std::size_t& amount)

#include <iostream>
#include <pcl/common/spring.h>
#include <pcl/point_cloud.h>
#include <pcl/point_types.h>

using namespace std;

void printCloud(pcl::PointCloud<pcl::PointXYZ> &cloud)
{
    int nrow = cloud.height;
    int ncol = cloud.width;

    for(int i = 0; i < nrow; ++i)
    {
        for(int j = 0; j < ncol; ++j)
        {
            cout << "(" << cloud.at(i*ncol + j).x << "," <<  cloud.at(i*ncol + j).y << "," << cloud.at(i*ncol + j).z << ") ";
        }
        cout << endl;
    }
}

int main()
{
    pcl::PointCloud<pcl::PointXYZ> cloud;
    for(int irow = 0; irow < 3; ++irow)
    {
        for(int icol = 0; icol < 4; ++icol)
        {
            cloud.push_back(pcl::PointXYZ(irow,icol,irow+icol));
        }
    }
    cloud.width = 3;
    cloud.height = 4;
    cout << cloud;
    printCloud(cloud);

    pcl::PointCloud<pcl::PointXYZ> ocloud;
    pcl::common::expandRows(cloud,ocloud,pcl::PointXYZ(99,99,99),2);
    cout << ocloud;
    printCloud(ocloud);
    cout << "----------------------------------" << endl;
    pcl::common::duplicateColumns(cloud,ocloud,1);

    cout << ocloud;
    printCloud(ocloud);
    cout << "----------------------------------" << endl;

    pcl::common::deleteRows(ocloud,ocloud,1);
    cout << ocloud;
    printCloud(ocloud);
    cout << "----------------------------------" << endl;

    pcl::common::mirrorRows(ocloud,cloud,1);
    cout << cloud;
    printCloud(cloud);

    return 0;
}

（5）time获取时间模块

#include <iostream>
#include <pcl/common/time.h>
using namespace std;

int main()
{
    pcl::StopWatch watch;
    pcl::EventFrequency freq;

    {
        pcl::ScopeTime scope("test for");
        int res;
        for(int i = 0; i < 1000000000; ++i)
        {
            res = i*i;
            if(i%100 == 0) freq.event();
        }
    }

    cout << watch.getTime() << "ms - "  << watch.getTimeSeconds() << "s" << endl;
    cout << (uint32_t)freq.getFrequency() << endl;

    DO_EVERY(20,[]{ cout << "test do every" << endl;}());

    return 0;
}

（6）vector_average计算加权平均值和协方差矩阵

#include <iostream>
#include <pcl/common/vector_average.h>
using namespace std;

int main()
{
    pcl::VECtor
    pcl::VectorAverage<float,4> vec;
    pcl::VectorAverage<float,4>::VectorType sample1;
    sample1 << 1,2,3,4;
    vec.add(sample1);

    Eigen::Vector4f sample2;
    sample2 << 2,5,7,1;
    vec.add(sample2,2);

    Eigen::Matrix<float, 4, 1> sample3;
    sample3 << 0,7,8,4;
    vec.add(sample3);

    cout << vec.getMean() << endl << vec.getCovariance() << endl;

    Eigen::Vector4f v,v1,v2,v3;
    vec.doPCA(v,v1,v2,v3);

    cout << v << endl << v1 << endl << v2 << endl << v3 << endl;

    return 0;
}

（7）time_trigger计时触发器

#include <iostream>
#include <pcl/common/time_trigger.h>
using namespace std;

static int cnt = 0;
struct callBack
{
    void operator() (){
        cout << "callBack " << cnt++ << endl;
    }
};

int main()
{
    // 定义计时触发器类
    pcl::TimeTrigger triger/*(1,callBack())*/;
    triger.setInterval(0.5);
    triger.registerCallback(callBack());
    triger.start();
    // 将主线程暂停100s
    std::this_thread::sleep_for(std::chrono::seconds(100));

    return 0;
}

（8）colors颜色生成函数

#include <iostream>
#include <pcl/common/colors.h>
#include <array>

using namespace std;

int main()
{
    srand(time(nullptr));
    pcl::RGB rgb = pcl::getRandomColor(0.5,1.5);
    cout << "(" << (int)rgb.r << "," << (int)rgb.b << "," << (int)rgb.g  << "," << (int)rgb.a << ")" << endl;

    pcl::ColorLUT<pcl::LUT_GLASBEY> glut; //等价于pcl::GlasbeyLUT glut;
    pcl::ColorLUT<pcl::LUT_VIRIDIS> vlut; //等价于pcl::ViridisLUT vlut;

    cout << glut.at(127) << endl << vlut.at(127) << endl << glut.size() << " " << vlut.size() << endl;
    cout << pcl::ColorLUT<pcl::LUT_GLASBEY>::at(100) << endl << pcl::ViridisLUT::at(100) << endl;

    return 0;
}

（9）centroid点云计算

// 计算点云质心
pcl::compute3DCentroid(*cloud_smoothed,centroid); 
// 计算点云协方差矩阵
pcl::computeCovarianceMatrix<pcl::PointXYZRGB,double>
// 计算点云标准化协方差矩阵
pcl::computeCovarianceMatrixNormalized(*cloud,centroid1,covariance_matrix);

#include <iostream>
#include <pcl/point_cloud.h>
#include <pcl/visualization/pcl_visualizer.h>
#include <pcl/io/pcd_io.h>
#include <pcl/common/centroid.h>
#include <Eigen/Eigen>

using namespace std;

int main()
{
    pcl::PointCloud<pcl::PointXYZRGB> cloud;
    pcl::io::loadPCDFile("../pig.pcd",cloud);

    Eigen::Matrix<float, 4, 1> centroid;
    pcl::compute3DCentroid<pcl::PointXYZRGB,float>(cloud,centroid);

    cout << "float centroid: \n" << centroid << endl;

    Eigen::Matrix<double, 4, 1> centroid1;
    pcl::compute3DCentroid<pcl::PointXYZRGB,double>(cloud,centroid1);
    cout << "double centroid: \n" << centroid1 << endl;

    Eigen::Matrix<double, 3, 3> covariance_matrix;
    pcl::computeCovarianceMatrix<pcl::PointXYZRGB,double>(cloud,centroid1,covariance_matrix);
    cout << "double covariance_matrix: \n" << covariance_matrix << endl;

    pcl::computeCovarianceMatrixNormalized<pcl::PointXYZRGB,double>(cloud,centroid1,covariance_matrix);
    cout << "double covariance_matrix Normalized: \n" << covariance_matrix << endl;

    pcl::visualization::PCLVisualizer::Ptr viewer(new pcl::visualization::PCLVisualizer());
    pcl::visualization::PointCloudColorHandlerRGBField<pcl::PointXYZRGB> rgb(cloud.makeShared());
    viewer->addPointCloud(cloud.makeShared(),rgb);

    while (!viewer->wasStopped()) {
        viewer->spinOnce(1000);
    }

    return 0;
}

（10）transforms点云变换模块

#include <iostream>
#include <pcl/point_cloud.h>
#include <pcl/visualization/pcl_visualizer.h>
#include <pcl/io/pcd_io.h>
#include <pcl/common/transforms.h>
#include <pcl/common/centroid.h>

using namespace std;

using PCRGB = pcl::PointCloud<pcl::PointXYZRGB>;

void transform1(PCRGB &in_cloud,PCRGB &out_cloud)
{
#if 0
    Eigen::Affine3f transform = Eigen::Affine3f::Identity();
    transform.translation() << 20,-10,10;
    transform.rotate(Eigen::AngleAxisf(M_PI/4,Eigen::Vector3f::UnitX()));
#else
    Eigen::Transform<float,3,Eigen::Affine> transform = Eigen::Transform<float,3,Eigen::Affine>::Identity();
    transform.translation() << 10,-5,5;
    transform.rotate(Eigen::AngleAxisf(M_PI/4,Eigen::Vector3f::UnitX()));
    transform.scale(2);
#endif

    cout << transform.matrix() << endl;

    pcl::transformPointCloud(in_cloud,out_cloud,transform);
}

void transform2(PCRGB &in_cloud,PCRGB &out_cloud)
{
#if 0
    Eigen::Matrix4f transform = Eigen::Matrix4f::Identity();
    float theta = M_PI/2;
//    transform(0,0) *= 2;
    transform(1,1) = cos(theta);
    transform(2,2) = cos(theta);
    transform(2,1) = sin(theta);
    transform(1,2) = -sin(theta);

    transform(0,3) = 20;
    transform(1,3) = -10;
    transform(2,3) = 20;
#else
    Eigen::Matrix<float, 4, 4> transform = Eigen::Matrix<float, 4, 4>::Identity();
    float theta = M_PI/2;
    transform(0,0) *= 1;
    transform(1,1) = 1*cos(theta);
    transform(2,2) = 1*cos(theta);
    transform(2,1) = 1*sin(theta);
    transform(1,2) = -1*sin(theta);

    transform(0,3) = 10;
    transform(1,3) = -5;
    transform(2,3) = 10;
#endif

    pcl::transformPointCloud(in_cloud,out_cloud,transform);
}

void transform3(PCRGB &in_cloud,PCRGB &out_cloud)
{
#if 0
    Eigen::Vector3f offset(20,-10,10);
    Eigen::Quaternionf rotation(Eigen::AngleAxisf(-M_PI/2,Eigen::Vector3f::UnitX()));
#else
    Eigen::Matrix<float,3,1> offset(10,-5,5);
    Eigen::Quaternion<float> rotation(Eigen::AngleAxisf(-M_PI/2,Eigen::Vector3f::UnitX()));
#endif

    pcl::transformPointCloud(in_cloud,out_cloud,offset,rotation);
}

void trans(PCRGB &in_cloud,PCRGB &out_cloud,int type)
{
    switch(type){
    case 1:
        transform1(in_cloud,out_cloud);
        break;
    case 2:
        transform2(in_cloud,out_cloud);
        break;
    case 3:
        transform3(in_cloud,out_cloud);
        break;
    default:
        break;
    }
}

int main()
{
    PCRGB in_cloud,out_cloud;
    pcl::io::loadPCDFile("../pig.pcd",in_cloud);
    Eigen::Matrix<float, 4, 1> centroid;
    pcl::compute3DCentroid(in_cloud,centroid);

    Eigen::Affine3f transform0 = Eigen::Affine3f::Identity();
    transform0.translation() << -centroid(0),-centroid(1),-centroid(2);
    pcl::transformPointCloud(in_cloud,in_cloud,transform0);

    trans(in_cloud,out_cloud,2);

    pcl::visualization::PCLVisualizer::Ptr viewer(new pcl::visualization::PCLVisualizer());
    pcl::visualization::PointCloudColorHandlerRGBField<pcl::PointXYZRGB> rgb(in_cloud.makeShared());
    viewer->addPointCloud(in_cloud.makeShared(),rgb,"in_cloud");

    pcl::visualization::PointCloudColorHandlerGenericField<pcl::PointXYZRGB> rgbt(out_cloud.makeShared(),"z");
    viewer->addPointCloud(out_cloud.makeShared(),rgbt,"out_cloud");


    while(!viewer->wasStopped())
    {
        viewer->spinOnce(100);
    }

    return 0;
}

common模块中的基本函数

pcl::rad2deg(fllat alpha) 
从弧度到角度

pcl::deg2rad(float aipha)
从角度到弧度

pcl::normAngle(float alpha)
正则化角度在（-PI，PI）之间

pcl::compute3DCentroid (const pcl::PointCloud< PointT > &cloud, Eigen::Matrix< Scalar, 4, 1 > &centroid)
计算给定一群点的3D中心点，并且返回一个三维向量

pcl::computeCovarianceMatrix (const pcl::PointCloud< PointT > &cloud, const Eigen::Matrix< Scalar, 4, 1 > &centroid, Eigen::Matrix< Scalar, 3, 3 > &covariance_matrix)
计算给定的三维点云的协方差矩阵。

pcl::computeMeanAndCovarianceMatrix (const pcl::PointCloud< PointT > &cloud, Eigen::Matrix< Scalar, 3, 3 > &covariance_matrix, Eigen::Matrix< Scalar, 4, 1 > &centroid
计算正则化的3*3的协方差矩阵以及给定点云数据的中心点

pcl::demeanPointCloud (const pcl::PointCloud< PointT > &cloud_in, const Eigen::Matrix< Scalar, 4, 1 > &centroid, pcl::PointCloud< PointT > &cloud_out)

pcl::computeNDCentroid (const pcl::PointCloud< PointT > &cloud, Eigen::Matrix< Scalar, Eigen::Dynamic, 1 > &centroid)
利用一组点的指数对其进行一般的、通用的nD中心估计。

pcl::getAngle3D (const Eigen::Vector4f &v1, const Eigen::Vector4f &v2, const bool in_degree=false)
计算两个向量之间的角度

pcl::getMeanStd (const std::vector< float > &values, double &mean, double &stddev)
同时计算给定点云数据的均值和标准方差

pcl::getPointsInBox (const pcl::PointCloud< PointT > &cloud, Eigen::Vector4f &min_pt, Eigen::Vector4f &max_pt, std::vector< int > &indices)
在给定边界的情况下，获取一组位于框中的点

pcl::getMaxDistance (const pcl::PointCloud< PointT > &cloud, const Eigen::Vector4f &pivot_pt, Eigen::Vector4f &max_pt)
给定点云数据中点与点之间的最大距离的值

pcl::getMinMax3D (const pcl::PointCloud< PointT > &cloud, PointT &min_pt, PointT &max_pt)
获取给定点云中的在XYZ轴上的最大和最小值

pcl::getCircumcircleRadius (const PointT &pa, const PointT &pb, const PointT &pc)
计算由三个点pa、pb和pc构成的三角形的外接圆半径。

pcl::getMinMax (const PointT &histogram, int len, float &min_p, float &max_p)
获取点直方图上的最小值和最大值。

pcl::calculatePolygonArea (const pcl::PointCloud< PointT > &polygon)
根据给定的多边形的点云计算多边形的面积

pcl::copyPoint (const PointInT &point_in, PointOutT &point_out)
从Point_in把字段数据赋值到Point_out

pcl::lineToLineSegment (const Eigen::VectorXf &line_a, const Eigen::VectorXf &line_b, Eigen::Vector4f &pt1_seg, Eigen::Vector4f &pt2_seg)
获取两条三维直线之间的最短三维线段

pcl::sqrPointToLineDistance (const Eigen::Vector4f &pt, const Eigen::Vector4f &line_pt, const Eigen::Vector4f &line_dir)
获取点到线的平方距离（由点和方向表示）

pcl::getMaxSegment (const pcl::PointCloud< PointT > &cloud, PointT &pmin, PointT &pmax)
在给定的一组点中获得最大分段，并返回最小和最大点。

pcl::eigen22 (const Matrix &mat, typename Matrix::Scalar &eigenvalue, Vector &eigenvector)
确定最小特征值及其对应的特征向量

pcl::computeCorrespondingEigenVector (const Matrix &mat, const typename Matrix::Scalar &eigenvalue, Vector &eigenvector)
确定对称半正定输入矩阵给定特征值对应的特征向量

pcl::eigen33 (const Matrix &mat, typename Matrix::Scalar &eigenvalue, Vector &eigenvector)
确定对称半正定输入矩阵最小特征值的特征向量和特征值

pcl::invert2x2 (const Matrix &matrix, Matrix &inverse)
计算2x2矩阵的逆。

pcl::invert3x3SymMatrix (const Matrix &matrix, Matrix &inverse)
计算3x3对称矩阵的逆。

pcl::determinant3x3Matrix (const Matrix &matrix)
计算3x3矩阵的行列式

pcl::getTransFromUnitVectorsZY (const Eigen::Vector3f &z_axis, const Eigen::Vector3f &y_direction, Eigen::Affine3f &transformation)
获得唯一 的3D旋转，将Z轴旋转成（0，0，1）Y轴旋转成（0,1,0）并且两个轴是正交的。

pcl::getTransformationFromTwoUnitVectorsAndOrigin (const Eigen::Vector3f &y_direction, const Eigen::Vector3f &z_axis, const Eigen::Vector3f &origin, Eigen::Affine3f &transformation)
得到将origin转化为（0，0，0）的变换，并将Z轴旋转成（0，0，1）和Y方向（0，1，0）

pcl::getEulerAngles (const Eigen::Transform< Scalar, 3, Eigen::Affine > &t, Scalar &roll, Scalar &pitch, Scalar &yaw)
从给定的变换矩阵中提取欧拉角

pcl::getTranslationAndEulerAngles (const Eigen::Transform< Scalar, 3, Eigen::Affine > &t, Scalar &x, Scalar &y, Scalar &z, Scalar &roll, Scalar &pitch, Scalar &yaw)
给定的转换中，提取XYZ以及欧拉角

pcl::getTransformation (float x, float y, float z, float roll, float pitch, float yaw)
从给定的平移和欧拉角创建转换矩阵

pcl::saveBinary (const Eigen::MatrixBase< Derived > &matrix, std::ostream &file)
保存或者写矩阵到一个输出流中

pcl::loadBinary (Eigen::MatrixBase< Derived > const &matrix, std::istream &file)
从输入流中读取矩阵

pcl::lineWithLineIntersection (const Eigen::VectorXf &line_a, const Eigen::VectorXf &line_b, Eigen::Vector4f &point, double sqr_eps=1e-4)
获取空间中两条三维直线作为三维点的交点。

pcl::getFieldIndex (const pcl::PCLPointCloud2 &cloud, const std::string &field_name)
获取指定字段的索引（即维度/通道）

pcl::getFieldsList (const pcl::PointCloud< PointT > &cloud)
获取给定点云中所有可用字段的列表

pcl::getFieldSize (const int datatype)
获取特定字段数据类型的大小（字节）。

pcl::concatenatePointCloud (const pcl::PCLPointCloud2 &cloud1, const pcl::PCLPointCloud2 &cloud2, pcl::PCLPointCloud2 &cloud_out)

连接 pcl::PCLPointCloud2类型的点云字段

参考文章

（1）官方文档：Point Cloud Library (PCL): Module common

（2）博客：PCL基础介绍_像话吗的博客-CSDN博客