PCL近邻搜索相关的类

首先PCL定义了搜索的基类pcl::search::Search<PointInT>

template<typename PointT>
    class Search

其子类包括：KD树，八叉树，FLANN快速搜索，暴力搜索（brute force），有序点云搜索。

The pcl_search library provides methods for searching for nearest neighbors using different data structures, including:

• kd-trees (via libpcl_kdtree);
• octrees (via libpcl_octree);
• brute force;
• specialized search for organized datasets.

search类都定义了两种最常见的近邻搜索模式：k近邻搜索，球状固定距离半径近邻搜索。

virtual int nearestKSearch (const PointT &point, int k, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances) const = 0;

virtual int  radiusSearch (const PointT& point, double radius, std::vector<int>& k_indices, std::vector<float>& k_sqr_distances, unsigned int max_nn = 0) const = 0;

还有一种比较有用的方式是：圆柱固定距离半径搜索，即在XOY平面的投影距离，目前没有看到PCL中的专门的实现方式，可以通过一种折中的方法解决octree。

还有就是通过累积地图实现的投影到XOY平面内的简单搜索。

Weinmann, M., et al. (2015). "Semantic point cloud interpretation based on optimal neighborhoods, relevant features and efficient classifiers." ISPRS Journal of Photogrammetry and Remote Sensing 105: 286-304.

在feature模块中大量使用了近邻搜索的东西。近邻搜索是很多点云计算的基础功能。

示例

如下调用了点云KD树近邻搜索实现了8个基于特征值的点云特征计算：

    QString filePly = dlg.txtPath->text();
    std::wstring pszRoomFile1 = filePly.toStdWString();
    char buffer[256];
    size_t ret = wcstombs(buffer, pszRoomFile1.c_str(), sizeof(buffer));
    const char * pszShapeFile = buffer;
    char * file_name = (char*)pszShapeFile;
    pcl::PointCloud<pcl::PointXYZ>::Ptr input_(new pcl::PointCloud<pcl::PointXYZ>);
    /*------------读取PLY文件-------------*/
    if (pcl::io::loadPLYFile<pcl::PointXYZ>(file_name, *input_) == -1) //* load the file 
    {
        PCL_ERROR("Couldn't read file test_pcd.pcd 
");
        QMessageBox::information(NULL, "Title", "Content", QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes);
    }
    double search_radius_ = dlg.sb_scale2->value();
    int k_=10;
    double search_parameter_ = 0.0;
    /*------------构造索引-------------*/
    boost::shared_ptr <std::vector<int> > indices_;
    if (!indices_)
    {
        indices_.reset(new std::vector<int>);
        try
        {
            indices_->resize(input_->points.size());
        }
        catch (const std::bad_alloc&)
        {
            PCL_ERROR("[initCompute] Failed to allocate %lu indices.
", input_->points.size());
        }
        for (size_t i = 0; i < indices_->size(); ++i) { (*indices_)[i] = static_cast<int>(i); }
    }
    std::vector<int> nn_indices(k_);
    std::vector<float> nn_dists(k_);
    /*---------------构造KD树-------------*/
    //pcl::search::Search<pcl::PointXYZ>::Ptr tree = boost::shared_ptr<pcl::search::Search<pcl::PointXYZ> >(new pcl::search::KdTree<pcl::PointXYZ>);
    pcl::search::KdTree<pcl::PointXYZ>::Ptr tree(new pcl::search::KdTree<pcl::PointXYZ>);
    tree->setInputCloud(input_);
    SearchMethodSurface search_method_surface_;
    if (search_radius_ != 0.0)
    {
        search_parameter_ = search_radius_;
        int (pcl::search::Search<pcl::PointXYZ>::*radiusSearchSurface)(const PointCloudIn &cloud, int index, double radius,
            std::vector<int> &k_indices, std::vector<float> &k_distances,
            unsigned int max_nn) const = &pcl::search::Search<pcl::PointXYZ>::radiusSearch;
        search_method_surface_ = boost::bind(radiusSearchSurface, boost::ref(tree), _1, _2, _3, _4, _5, 0);
    }
    else
    {
        search_parameter_ = k_;
        int (pcl::search::Search<pcl::PointXYZ>::*nearestKSearchSurface)(const PointCloudIn &cloud, int index, int k, std::vector<int> &k_indices,
            std::vector<float> &k_distances) const = &pcl::search::Search<pcl::PointXYZ>::nearestKSearch;
        search_method_surface_ = boost::bind(nearestKSearchSurface, boost::ref(tree), _1, _2, _3, _4, _5);
    }
    pcl::PointCloud<pcl::Normal>::Ptr cloud_normals(new pcl::PointCloud<pcl::Normal>);
    PointCloudOut& output = *cloud_normals;
    AxPointCloudOut output_pts;
    if (input_->size() < 3)
    {
        return;
    }
    else/*--------------计算特征值和特征向量-------------*/
    {
        output_pts.resize(input_->size());
        //output_pts.reserve(input_->size(), (new AxPoint()));
#ifdef _OPENMP
#pragma omp parallel for shared (output_pts) private (nn_indices, nn_dists) num_threads(threads_)
#endif
        // Iterating over the entire index vector
        for (int idx = 0; idx < static_cast<int> (indices_->size()); ++idx)
        {
            if (search_method_surface_(*input_, (*indices_)[idx], search_parameter_, nn_indices, nn_dists) == 0)
            {
                output.points[idx].normal[0] = output.points[idx].normal[1] = output.points[idx].normal[2] = output.points[idx].curvature = std::numeric_limits<float>::quiet_NaN();

                output.is_dense = false;
                continue;
            }

            EIGEN_ALIGN16 Eigen::Matrix3f covariance_matrix;
            // 16-bytes aligned placeholder for the XYZ centroid of a surface patch
            Eigen::Vector4f xyz_centroid;

            if (pcl::computeMeanAndCovarianceMatrix(*input_, nn_indices, covariance_matrix, xyz_centroid) == 0)
            {
                continue;
            }

            EIGEN_ALIGN16 Eigen::Matrix3f eigen_vector3;
            EIGEN_ALIGN16 Eigen::Vector3f eigen_values;
            //计算特征值和特征向量
            pcl::eigen33(covariance_matrix, eigen_vector3, eigen_values);
            double eig_val1 = eigen_values[0];
            double eig_val2 = eigen_values[1];
            double eig_val3 = eigen_values[2];
            
            output_pts[idx].x = input_->at((*indices_)[idx]).x;
            output_pts[idx].y = input_->at((*indices_)[idx]).y;
            output_pts[idx].z = input_->at((*indices_)[idx]).z;
            output_pts[idx].eig_val1 = eig_val1;
            output_pts[idx].eig_val2 = eig_val2;
            output_pts[idx].eig_val3 = eig_val3;
        }
        QString savefilePly = filePly.replace(".ply",".txt");
        std::wstring psaveFile1 = savefilePly.toStdWString();
        char buffer[256];
        size_t ret = wcstombs(buffer, psaveFile1.c_str(), sizeof(buffer));
        const char * psavetxtFile = buffer;
        char * file_name_2 = (char*)psavetxtFile;
        FILE*  saveFeaturePointCloud = fopen(file_name_2, "w");
        for (int i = 0; i < output_pts.size(); i++)
        {
            float x = output_pts[i].x;
            float y = output_pts[i].y;
            float z = output_pts[i].z;

            //注意：eig_val1最小
            float eig_val1 = output_pts[i].eig_val1;
            float eig_val2 = output_pts[i].eig_val2;
            float eig_val3 = output_pts[i].eig_val3;
            float eig_sum = eig_val1 + eig_val2 + eig_val3;

            float e1 = 0, e2 = 0, e3 = 0;
            float Linearity = 0;
            float Planarity = 0;
            float Scattering = 0;
            float Omnivariance = 0;
            float Anisotropy = 0;
            float EigenEntropy = 0;
            float changeOfcurvature = 0;
            if (eig_sum != 0)
            {
                e1 = eig_val3 / eig_sum;
                e2 = eig_val2 / eig_sum;
                e3 = eig_val1 / eig_sum;
                Linearity = (e1 - e2) / e1;
                Planarity = (e2 - e3) / e1;
                Scattering = e3 / e1;
                Omnivariance = pow(e1*e2*e3, 1 / 3);
                Anisotropy = (e1 - e3) / e1;
                EigenEntropy = -(e1*log(e1) + e2*log(e2) + e3*log(e3));
                //计算曲率变化
                changeOfcurvature = fabsf(e1 / (e1 + e2 + e3));
            }
            else
                changeOfcurvature = 0;
            //x,y,z,e1,e2,e3,
            //Linearity,Planarity,Scattering,Omnivariance,Anisotropy,
            //Eigenentropy,Sum of eigenvalues,Change of curvature
            fprintf(saveFeaturePointCloud, "%f %f %f %f %f %f %f %f %f %f %f %f %f %f
", x, y, z, eig_val1, eig_val2, eig_val3,
                Linearity, Planarity, Scattering, Omnivariance, Anisotropy, EigenEntropy, eig_sum, changeOfcurvature);
        }
        fclose(saveFeaturePointCloud);
    }