点云数据x-y平面网格化（电力线巡检点云分类step1）

 机载激光雷达电力线巡检点云分类第一步，将点云数据投影到x-y平面网格划分，以下代码利用libLAS库读取las点云数据，利用pcl库对点云数据进行处理。
参考https://blog.csdn.net/ethan_guo/article/details/80621998
  1#include <vtkAutoInit.h>
#include <QCoreApplication>
#include <QDebug>
#include <iostream>
#include <QVector>
#include <liblas/liblas.hpp>
#include <pcl/io/pcd_io.h>
#include <pcl/point_cloud.h>
#include <pcl/point_types.h>
#include <pcl/console/print.h>
#include <pcl/filters/extract_indices.h>
#include <pcl/visualization/cloud_viewer.h>
#include <pcl/visualization/pcl_visualizer.h>
using namespace std;
VTK_MODULE_INIT(vtkRenderingOpenGL)
//定义一个网格类型
class Grid
{
    public:
    bool  powerLine; //是否为电力线网格
    float h_mean;    //平均高程  
    float h_max;     //最大高程
    float h_min;     //最小高程
    int   num;       //点个数
    pcl::PointCloud<pcl::PointXYZRGB>::Ptr grid_cloud {new pcl::PointCloud<pcl::PointXYZRGB>};  //网格内点云
    pcl::PointIndices::Ptr grid_inliers {new pcl::PointIndices};                                //网格内点云索引
};
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    pcl::PointCloud<pcl::PointXYZRGB>::Ptr cloud_in (new pcl::PointCloud<pcl::PointXYZRGB>); //输入点云
    pcl::PointCloud<pcl::PointXYZRGB>::Ptr cloud_out(new pcl::PointCloud<pcl::PointXYZRGB>); //输出点云
    ifstream ifs("F:/lidar/powerLine/pointCloud/pt000001.las", std::ios::in | std::ios::binary);
    liblas::ReaderFactory f;
    liblas::Reader reader = f.CreateWithStream(ifs);
    unsigned long intnPoints = reader.GetHeader().GetPointRecordsCount();
    double maxX = reader.GetHeader().GetMaxX();
    double maxY = reader.GetHeader().GetMaxY();
    double maxZ = reader.GetHeader().GetMaxZ();
    double minX = reader.GetHeader().GetMinX();
    double minY = reader.GetHeader().GetMinY();
    double minZ = reader.GetHeader().GetMinZ();
    printf("intnPoints is %ld\n", intnPoints);
    printf("maxX is %lf\nmaxY is %lf\nmaxZ is %lf\nminX is %lf\nminY is %lf\nminZ is %lf\n", maxX, maxY, maxZ, minX, minY, minZ);
    cloud_in->width    = intnPoints;
    cloud_in->height   = 1;
    cloud_in->is_dense = false;
    cloud_in->resize(intnPoints);
    int k = 0;
    while(reader.ReadNextPoint())
    {
        cloud_in->points[k].x = reader.GetPoint().GetX();
        cloud_in->points[k].y = reader.GetPoint().GetY();
        cloud_in->points[k].z = reader.GetPoint().GetZ();
        k++;
    }
    //定义一个抽取器
    pcl::ExtractIndices<pcl::PointXYZRGB> extract;
    float grid_size = 30.0;
    QVector<QVector<Grid>> grid;
    grid.resize(20);
    for(int h = 0; h < 20; ++h)
    {
        grid[h].resize(20);
    }
    int j;
    int i;
    int l = 0;
    for(size_t m = 0; m < cloud_in->size(); m++)
    {
        i = floor(fabs(cloud_in->points[m].x / grid_size));
        j = floor(fabs(cloud_in->points[m].y / grid_size));
        grid[i][j].grid_cloud->push_back(cloud_in->points[m]);
        grid[i][j].grid_inliers->indices.push_back(m);
        grid[i][j].grid_inliers->header = cloud_in->header;
    }
    std::cout << "grid.size() is "<<grid.size()<<std::endl;
    std::cout << grid[4][5].grid_inliers->indices.size()<<std::endl;
    pcl::PointIndices::Ptr Indices (new pcl::PointIndices);
    for(int i = 0; i < grid.size(); ++i)
    {
        for(int j = 0; j < grid[i].size(); ++j)
        {
            if(grid[i][j].grid_inliers->indices.size() < 100)
            {
                std::cout<< "grid["<<i<<"]["<<j<<"]" << "is  empty"<<std::endl;
            }else {
                std::cout<< "grid["<<i<<"]["<<j<<"]" << " has "<< grid[i][j].grid_inliers->indices.size() << " points!"<<std::endl;
                Indices->indices.insert(Indices->indices.end(), grid[i][j].grid_inliers->indices.begin(), grid[i][j].grid_inliers->indices.end());
                if((i+j)%2 == 0)
                {
                    for(int k = 0; k < grid[i][j].grid_cloud->width; ++k)
                    {
                        grid[i][j].grid_cloud->points[k].r = 127;
                        grid[i][j].grid_cloud->points[k].g = 255;
                        grid[i][j].grid_cloud->points[k].b = 0;
                        int indice = grid[i][j].grid_inliers->indices[k];
                        cloud_in->points[indice].r = 127;
                        cloud_in->points[indice].g = 255;
                        cloud_in->points[indice].b = 0;
                    }
                }else {
                    for(int k = 0; k < grid[i][j].grid_cloud->width; ++k)
                    {
                        grid[i][j].grid_cloud->points[k].r = 255;
                        grid[i][j].grid_cloud->points[k].g = 20;
                        grid[i][j].grid_cloud->points[k].b = 147;
                        int indice = grid[i][j].grid_inliers->indices[k];
                        cloud_in->points[indice].r = 255;
                        cloud_in->points[indice].g = 20;
                        cloud_in->points[indice].b = 147;
                    }
                }
            }
        }
    }
    extract.setInputCloud(cloud_in);
    extract.setIndices(Indices);
    extract.setNegative(false);
    extract.filter(*cloud_out);

    pcl::visualization::PCLVisualizer::Ptr viewer(new pcl::visualization::PCLVisualizer("powerLine"));
    viewer->setBackgroundColor(0, 0, 0);
    viewer->addCoordinateSystem(1.0);
    pcl::visualization::PointCloudColorHandlerRGBField<pcl::PointXYZRGB> rgb(cloud_out);
    viewer->addPointCloud(cloud_out, rgb, "cloud grid");
    viewer->initCameraParameters();
    while(!viewer->wasStopped())
    {
        viewer->spinOnce(100);
        boost::this_thread::sleep(boost::posix_time::microseconds(100000));
    }

    return a.exec();
}