QString filePly = dlg.txtPath->text();

     std::wstring pszRoomFile1 = filePly.toStdWString();

     char buffer[];

     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_) == -) //* load the file

     {

         PCL_ERROR("Couldn't read file test_pcd.pcd \n");

         QMessageBox::information(NULL, "Title", "Content", QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes);

     }

     double search_radius_ = dlg.sb_scale2->value();

     int k_=;

     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.\n", input_->points.size());

         }

         for (size_t i = ; 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, );

     }

     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() < )

     {

         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 = ; idx < static_cast<int> (indices_->size()); ++idx)

         {

             if (search_method_surface_(*input_, (*indices_)[idx], search_parameter_, nn_indices, nn_dists) == )

             {

                 output.points[idx].normal[] = output.points[idx].normal[] = output.points[idx].normal[] = 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) == )

             {

                 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[];

             double eig_val2 = eigen_values[];

             double eig_val3 = eigen_values[];

             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[];

         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 = ; 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 = , e2 = , e3 = ;

             float Linearity = ;

             float Planarity = ;

             float Scattering = ;

             float Omnivariance = ;

             float Anisotropy = ;

             float EigenEntropy = ;

             float changeOfcurvature = ;

             if (eig_sum != )

             {

                 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,  / );

                 Anisotropy = (e1 - e3) / e1;

                 EigenEntropy = -(e1*log(e1) + e2*log(e2) + e3*log(e3));

                 //计算曲率变化

                 changeOfcurvature = fabsf(e1 / (e1 + e2 + e3));

             }

             else

                 changeOfcurvature = ;

             //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\n", x, y, z, eig_val1, eig_val2, eig_val3,

                 Linearity, Planarity, Scattering, Omnivariance, Anisotropy, EigenEntropy, eig_sum, changeOfcurvature);

         }

         fclose(saveFeaturePointCloud);

     }