TEST (PCL, NormalEstimationOpenMPEigen) { NormalEstimationOMP<PointXYZ, Eigen::MatrixXf> n (4); // instantiate 4 threads // Object PointCloud<Eigen::MatrixXf>::Ptr normals (new PointCloud<Eigen::MatrixXf>); // set parameters PointCloud<PointXYZ>::Ptr cloudptr = cloud.makeShared (); n.setInputCloud (cloudptr); EXPECT_EQ (n.getInputCloud (), cloudptr); boost::shared_ptr<vector<int> > indicesptr (new vector<int> (indices)); n.setIndices (indicesptr); EXPECT_EQ (n.getIndices (), indicesptr); n.setSearchMethod (tree); EXPECT_EQ (n.getSearchMethod (), tree); n.setKSearch (static_cast<int> (indices.size ())); // estimate n.computeEigen (*normals); EXPECT_EQ (normals->points.rows (), indices.size ()); for (int i = 0; i < normals->points.rows (); ++i) { EXPECT_NEAR (normals->points.row (i)[0], -0.035592, 1e-4); EXPECT_NEAR (normals->points.row (i)[1], -0.369596, 1e-4); EXPECT_NEAR (normals->points.row (i)[2], -0.928511, 1e-4); EXPECT_NEAR (normals->points.row (i)[3], 0.0693136, 1e-4); } }
int main (int argc, char** argv) { PointCloud<PointXYZ>::Ptr cloud (new PointCloud<PointXYZ>); if(io::loadPLYFile<PointXYZ> (argv[1], *cloud) == -1){ cout << "ERROR: couldn't find file" << endl; return (1); } else { cout << "loaded" << endl; NormalEstimationOMP<PointXYZ, Normal> ne; search::KdTree<PointXYZ>::Ptr tree1 (new search::KdTree<PointXYZ>); tree1->setInputCloud (cloud); ne.setInputCloud (cloud); ne.setSearchMethod (tree1); ne.setKSearch (20); PointCloud<Normal>::Ptr normals (new PointCloud<Normal>); ne.compute (*normals); // Concatenate the XYZ and normal fields* PointCloud<PointNormal>::Ptr cloud_with_normals (new PointCloud<PointNormal>); concatenateFields(*cloud, *normals, *cloud_with_normals); // Create search tree* search::KdTree<PointNormal>::Ptr tree (new search::KdTree<PointNormal>); tree->setInputCloud (cloud_with_normals); cout << "begin marching cubes reconstruction" << endl; MarchingCubesRBF<PointNormal> mc; PolygonMesh::Ptr triangles(new PolygonMesh); mc.setInputCloud (cloud_with_normals); mc.setSearchMethod (tree); mc.reconstruct (*triangles); cout << triangles->polygons.size() << " triangles created" << endl; } return (0); }
int main (int argc, char **argv) { /* if (argc != 1) { PCL_ERROR ("Syntax: %s input.pcd output.ply\n", argv[0]); return -1; }*/ PointCloud<PointXYZ>::Ptr cloud (new PointCloud<PointXYZ> ()); io::loadPCDFile (argv[1], *cloud); MovingLeastSquares<PointXYZ, PointXYZ> mls; mls.setInputCloud (cloud); mls.setSearchRadius (4); mls.setPolynomialFit (true); mls.setPolynomialOrder (1); mls.setUpsamplingMethod (MovingLeastSquares<PointXYZ, PointXYZ>::SAMPLE_LOCAL_PLANE); mls.setUpsamplingRadius (1); mls.setUpsamplingStepSize (0.03); PointCloud<PointXYZ>::Ptr cloud_smoothed (new PointCloud<PointXYZ> ()); mls.process (*cloud_smoothed); NormalEstimationOMP<PointXYZ, Normal> ne; ne.setNumberOfThreads (8); ne.setInputCloud (cloud_smoothed); ne.setRadiusSearch (0.8); Eigen::Vector4f centroid; compute3DCentroid (*cloud_smoothed, centroid); ne.setViewPoint (centroid[0], centroid[1], centroid[2]); PointCloud<Normal>::Ptr cloud_normals (new PointCloud<Normal> ()); ne.compute (*cloud_normals); for (size_t i = 0; i < cloud_normals->size (); ++i) { cloud_normals->points[i].normal_x *= -1; cloud_normals->points[i].normal_y *= -1; cloud_normals->points[i].normal_z *= -1; } PointCloud<PointNormal>::Ptr cloud_smoothed_normals (new PointCloud<PointNormal> ()); concatenateFields (*cloud_smoothed, *cloud_normals, *cloud_smoothed_normals); Poisson<pcl::PointNormal> poisson; poisson.setDepth (9); poisson.setInputCloud (cloud_smoothed_normals); PolygonMesh mesh_poisson; poisson.reconstruct (mesh_poisson); pcl::io::savePLYFile("mesh.ply", mesh_poisson); return 0; }
int main(int argc, char** argv) { readOptions(argc, argv); PointCloud<PointXYZRGB>::Ptr in(new PointCloud<PointXYZRGB>); PointCloud<Normal>::Ptr n(new PointCloud<Normal>); PointCloud<Normal>::Ptr n_mls(new PointCloud<Normal>); PointCloud<PointXYZRGB>::Ptr p_mls(new PointCloud<PointXYZRGB>); PointCloud<FPFHSignature33>::Ptr fpfh(new PointCloud<FPFHSignature33>); PointCloud<PrincipalCurvatures>::Ptr pc(new PointCloud<PrincipalCurvatures>); //PointCloud<PrincipalRadiiRSD>::Ptr rsd(new PointCloud<PrincipalRadiiRSD>); for (size_t i = 0; i < scenes_.size(); i++) { io::loadPCDFile<PointXYZRGB>(folder_ + "raw_labeled/" + scenes_[i] + ".pcd", *in); PassThrough<PointXYZRGB> pass; pass.setInputCloud(in); pass.setFilterFieldName("z"); pass.setFilterLimits(0.0f, limit_); pass.filter(*in); #ifdef PCL_VERSION_COMPARE //fuerte pcl::search::KdTree<PointXYZRGB>::Ptr tree (new pcl::search::KdTree<PointXYZRGB>()); #else //electric pcl::KdTreeFLANN<PointXYZRGB>::Ptr tree (new pcl::KdTreeFLANN<PointXYZRGB> ()); #endif tree->setInputCloud(in); for (float r_n = r_min_; r_n <= r_max_; r_n += r_step_) { string str_rn = fl2label(r_n,3) + "rn"; NormalEstimationOMP<PointXYZRGB, Normal> norm; norm.setNumberOfThreads(1); norm.setInputCloud(in); norm.setSearchMethod(tree); norm.setRadiusSearch(r_n); norm.compute(*n); #ifdef PCL_MINOR_VERSION #if PCL_MINOR_VERSION >=6 std::cerr << "current implementation of mls doesn't work with pcl1.7" << std::endl; exit(-1); #else MovingLeastSquares<PointXYZRGB, Normal> mls; mls.setInputCloud(in); mls.setOutputNormals(n_mls); mls.setPolynomialFit(true); mls.setPolynomialOrder(2); mls.setSearchMethod(tree); mls.setSearchRadius(r_n); mls.reconstruct(*p_mls); #endif #endif for (size_t p = 0; p < n_mls->points.size(); ++p) { flipNormalTowardsViewpoint(p_mls->points[p], 0.0f, 0.0f, 0.0f, n_mls->points[p].normal[0], n_mls->points[p].normal[1], n_mls->points[p].normal[2]); } io::savePCDFileASCII<PointXYZRGB>(folder_+"normals/"+scenes_[i]+ "/mls_"+scenes_[i]+"_"+str_rn+".pcd",*p_mls); #ifdef PCL_VERSION_COMPARE //fuerte pcl::search::KdTree<PointXYZRGB>::Ptr tree_mls (new pcl::search::KdTree<PointXYZRGB>()); #else //electric pcl::KdTreeFLANN<PointXYZRGB>::Ptr tree_mls (new pcl::KdTreeFLANN<PointXYZRGB> ()); #endif tree_mls->setInputCloud(p_mls); for (float r_f = r_n; r_f <= r_max_; r_f += r_step_) { cout << "scene: " << scenes_[i] << "\tnormals: " << r_n << "\tfeatures: " << r_f << endl; string str_rf = fl2label(r_f,3) + "rf"; FPFHEstimationOMP<PointXYZRGB, Normal, FPFHSignature33> fpfh_est; fpfh_est.setNumberOfThreads(1); fpfh_est.setInputCloud(in); fpfh_est.setInputNormals(n); fpfh_est.setSearchMethod(tree); fpfh_est.setRadiusSearch(r_f); fpfh_est.compute(*fpfh); // filename example: // <folder_>/fpfh/kitchen01/fpfh_kitchen01_020rn_025rf.pcd // <folder_>/fpfh/kitchen02/fpfh_kitchen02_030rnmls_060rf.pcd io::savePCDFileASCII<FPFHSignature33>(folder_ + "0_fpfh/" + scenes_[i] + "/fpfh_" + scenes_[i] +"_"+str_rn+"_"+str_rf+".pcd", *fpfh); FPFHEstimationOMP<PointXYZRGB, Normal, FPFHSignature33> fpfh_est_mls; fpfh_est_mls.setNumberOfThreads(1); fpfh_est_mls.setInputCloud(p_mls); fpfh_est_mls.setInputNormals(n_mls); fpfh_est_mls.setSearchMethod(tree_mls); fpfh_est_mls.setRadiusSearch(r_f); fpfh_est_mls.compute(*fpfh); io::savePCDFileASCII<FPFHSignature33>(folder_ + "0_fpfh/" + scenes_[i] + "/fpfh_" + scenes_[i] +"_"+str_rn+"mls_"+str_rf+".pcd", *fpfh); PrincipalCurvaturesEstimation<PointXYZRGB, Normal, PrincipalCurvatures> pc_est; pc_est.setInputCloud(in); pc_est.setInputNormals(n); pc_est.setSearchMethod(tree); pc_est.setRadiusSearch(r_f); pc_est.compute(*pc); io::savePCDFileASCII<PrincipalCurvatures>(folder_ + "0_pc/" + scenes_[i] + "/pc_" + scenes_[i] +"_"+str_rn+"_"+str_rf+".pcd", *pc); PrincipalCurvaturesEstimation<PointXYZRGB, Normal, PrincipalCurvatures> pc_est_mls; pc_est_mls.setInputCloud(p_mls); pc_est_mls.setInputNormals(n_mls); pc_est_mls.setSearchMethod(tree_mls); pc_est_mls.setRadiusSearch(r_f); pc_est_mls.compute(*pc); io::savePCDFileASCII<PrincipalCurvatures>(folder_ + "0_pc/" + scenes_[i] + "/pc_" + scenes_[i] +"_"+str_rn+"mls_"+str_rf+".pcd", *pc); /*RSDEstimation<PointXYZRGB, Normal, PrincipalRadiiRSD> rsd_est; rsd_est.setInputCloud(in); rsd_est.setInputNormals(n); rsd_est.setSearchMethod(tree); rsd_est.setPlaneRadius(0.5); rsd_est.setRadiusSearch(r_f); rsd_est.compute(*rsd); io::savePCDFileASCII<PrincipalRadiiRSD>(folder_ + "0_rsd/" + scenes_[i] + "/rsd_" + scenes_[i] +"_"+str_rn+"_"+str_rf+".pcd", *rsd); RSDEstimation<PointXYZRGB, Normal, PrincipalRadiiRSD> rsd_est_mls; rsd_est_mls.setInputCloud(p_mls); rsd_est_mls.setInputNormals(n_mls); rsd_est_mls.setSearchMethod(tree_mls); rsd_est_mls.setPlaneRadius(0.5); rsd_est_mls.setRadiusSearch(r_f); rsd_est_mls.compute(*rsd); io::savePCDFileASCII<PrincipalRadiiRSD>(folder_ + "0_rsd/" + scenes_[i] + "/rsd_" + scenes_[i] +"_"+str_rn+"mls_"+str_rf+".pcd", *rsd);*/ } } } return 0; }