bool compute_object(const int i) { // Call get_plane, get_cylinder, get_sphere float plane_score = compute_plane(); // plane_inliers_ has the pc. float cylinder_score = compute_cylinder(); // cylinder_inliers_ has the pc // Select the lowest score and store it in object_inliers_. inliers_object_ = (plane_score > cylinder_score ? inliers_plane_ : inliers_cylinder_); // inliers_object_ = inliers_plane_; // inliers_object_ = inliers_cylinder_; // Test if the point cloud is too small if (inliers_object_->indices.size() < CUT_THRESHOLD) { std::cerr << "object inliers has "<< inliers_object_->indices.size() << " < " << CUT_THRESHOLD <<" points. Aborting..." << std::endl; return false; } /* // Debugging info pcl::PointCloud<Point>::Ptr best_object_(new pcl::PointCloud<Point>); pcl::copyPointCloud(*cloud_filtered, *inliers_object_, *best_object_); std::stringstream debug_s0; debug_s0 << "no_cluster_object_" << i << ".pcd"; pcl::io::savePCDFile(debug_s0.str(), *best_object_); */ // Euclidean Clustering std::vector<pcl::PointIndices> clusters; cluster_.setInputCloud(cloud_filtered); cluster_.setIndices(inliers_object_); cluster_.extract(clusters); std::cout << "Number of Euclidian clusters found: " << clusters.size() << std::endl; // Check if there is no clusters if (clusters.size() == 0) { std::cerr << "No clusters found. Aborting..." << std::endl; return false; } main_cluster_.reset(new pcl::PointIndices(clusters.at(0))); // Extract the inliers from the input cloud extract.setInputCloud(cloud_filtered); extract.setIndices(main_cluster_); extract.setNegative(false); pcl::PointCloud<Point>::Ptr cloud_plane(new pcl::PointCloud<Point > ()); extract.filter(*cloud_plane); // Test if cluster[0] is too small if (main_cluster_->indices.size() < CUT_THRESHOLD) { std::cerr << "object cluster[0] has "<< main_cluster_->indices.size() << " < " << CUT_THRESHOLD <<" points. Not writing to disk..." << std::endl; } else { // Write the inliers to disk std::stringstream debug_s; if (inliers_object_ == inliers_cylinder_) { debug_s << "cylinder_object_" << i << ".pcd"; } else if (inliers_object_ == inliers_plane_) { debug_s << "plane_object_" << i << ".pcd"; } else { debug_s << "unknown_object_" << i << ".pcd"; } pcl::io::savePCDFile(debug_s.str(), *cloud_plane); std::cout << "PointCloud representing the extracted component: " << cloud_plane->points.size() << " data points." << std::endl; } // Remove cluster[0], update cloud_filtered and cloud_normals extract.setNegative(true); extract.filter(*cloud_filtered); extract_normals.setNegative(true); extract_normals.setInputCloud(cloud_normals); extract_normals.setIndices(main_cluster_); extract_normals.filter(*cloud_normals); return true; }
bool AnalyticFormFactor::compute(ShapeName shape, real_t tau, real_t eta, vector3_t transvec, std::vector<complex_t>& ff, shape_param_list_t& params, real_t single_layer_thickness, RotMatrix_t & rot #ifdef USE_MPI , woo::MultiNode& world_comm, std::string comm_key #endif ) { #ifdef FF_VERBOSE std::cout << "-- Computing form factor analytically ... " << std::endl; #endif // #ifdef TIME_DETAIL_1 woo::BoostChronoTimer compute_timer; compute_timer.start(); // #endif // TIME_DETAIL_1 switch(shape) { case shape_cube: // cube if(!compute_cube(nqx_, nqy_, nqz_, ff, params, tau, eta, transvec)) { std::cerr << "error: something went wrong while computing FF for a cube" << std::endl; return false; } // if break; case shape_box: // cube or box if(!compute_box(nqx_, nqy_, nqz_, ff, shape, params, tau, eta, transvec)) { std::cerr << "error: something went wrong while computing FF for a box" << std::endl; return false; } // if break; case shape_cylinder: // standing cylinder if(!compute_cylinder(params, tau, eta, ff, transvec)) { std::cerr << "error: something went wrong while computing FF for a cylinder" << std::endl; return false; } // if break; case shape_sphere: // simple sphere if(!compute_sphere(params, ff, transvec)) { std::cerr << "error: something went wrong while computing FF for a sphere" << std::endl; return false; } // if break; case shape_prism3: // triangular prism (prism with 3 sides) if(!compute_prism(params, ff, tau, eta, transvec)) { std::cerr << "error: something went wrong while computing FF for a prism3" << std::endl; return false; } // if break; case shape_prism6: // hexagonal prism (prism with 6 sides) if(!compute_prism6(params, ff, tau, eta, transvec)) { std::cerr << "error: something went wrong while computing FF for a prism6" << std::endl; return false; } // if break; case shape_sawtooth_down: // downwards sawtooth if(!compute_sawtooth_down()) { std::cerr << "error: something went wrong while computing FF for a sawtooth down" << std::endl; return false; } // if break; case shape_sawtooth_up: // upwards sawtooth if(!compute_sawtooth_up()) { std::cerr << "error: something went wrong while computing FF for a sawtooth up" << std::endl; return false; } // if break; case shape_prism3x: // triangular grating in x direction if(!compute_prism3x(params, ff, tau, eta, transvec)) { std::cerr << "error: something went wrong while computing FF for a prism3x" << std::endl; return false; } // if break; case shape_pyramid: // pyramid if(!compute_pyramid(params, ff, tau, eta, transvec)){ std::cerr << "error: something went wrong while computing FF for a pyramid" << std::endl; return false; } // if break; case shape_trunccone: // truncated cone if(!compute_truncated_cone(params, tau, eta, ff, transvec)) { std::cerr << "error: something went wrong while computing FF for a truncated cone" << std::endl; return false; } // if break; default: std::cerr << "error: invalid shape. given shape is not supported" << std::endl; return false; } // switch #ifdef TIME_DETAIL_1 compute_timer.stop(); std::cout << "** FF compute time: " << compute_timer.elapsed_msec() << " ms." << std::endl; #endif // TIME_DETAIL_1 return true; } // AnalyticFormFactor::compute()