PCL point cloud library (3) — common module

Table of contents

3.1 Header files in common modules

3.2 Basic functions in the common module

(1)angle angle conversion

(2) distance distance calculation

(3) Random number generation

(4) sping expansion module

(5) time acquisition time module

(6) vector_average calculates the weighted average and covariance matrix

(7) time_trigger timing trigger

(8) colors color generation function

(9) centroid point cloud computing

(10) transforms point cloud transformation module

reference article

---

The common module mainly contains common data structures and methods commonly used in PCL libraries, such as the PointCloud class and many types used to represent points, surfaces, normal vectors, feature descriptions, etc., used to calculate distance, mean and covariance . Angle conversion and geometric change functions, etc. This module does not depend on other modules, so it can be compiled successfully. If compiled separately, you can use the data structure in it to develop it yourself.

3.1 Header files in common modules

Official documentation: Point Cloud Library (PCL): Module common

Chinese description:

head File	Function
angles.h	Defines the standard C interface angle calculation function
distances.h	Define a standard C interface for calculating distances
random.h	Define some functions for random point cloud generation
time.h	Defines a function for time calculation
time_trigger	Define timing triggers
centriod.h	Defines the estimation of the center point and the calculation of the covariance matrix
common.h	Standard C and C++ classes define all common methods
file_io.h	Defines some files to help write or read functions
geometry.h	Functions that define some basic geometric functions
intersection.h	Function that defines the intersection of a line and a line
norm.h	Defines the standard C method for computing matrix regularization
Point_types	Defines the types of data structures for all point clouds implemented by PCL
Other common functional methods
spring.h	Define the point cloud to be expanded by rows and columns, or mirrored and flipped
vector_average	Define calculation of weighted average and covariance matrix
color.h	Define color generation function
. . .

3.2 Basic functions in the common module

All the programs below share the following CmakeLists.txt file

// 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 angle conversion

In the pcl/common/angel.h file, there are three functions implemented

// 从弧度到角度
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 calculation

There are a total of five functions in the distance header file, including lineToLineSegment, sqrPointToLineDistance, getMaxSegment, squaredEuclideanDistance, and 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 number generation

//高斯噪声产生器
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 expansion module

// 按行扩展
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 acquisition time module

#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 calculates the weighted average and covariance matrix

#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 timing 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 color generation function

#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 point cloud computing

// 计算点云质心
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 point cloud transformation module

#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类型的点云字段

reference article

(1)Official document: Point Cloud Library (PCL): Module common

(2) Blog: Introduction to PCL basics_Xianhuama’s blog-CSDN blog