Les grappes de segmentation en croissance régionale sont fausses?

Question

Je suis en train d'effectuer une segmentation croissante de la région d'un nuage de points que j'ai de ma chambre via la bibliothèque de nuages ​​de points PCL. Le nuage de couleur ressemble à ceci:

Comme vous pouvez le voir, la plupart des clusters ressemblent à la surface. Cependant, quand je montre chaque groupe separatedly, voici quelques-uns des résultats:

Il est clair que les grappes ne sont pas les mêmes que dans le nuage de couleur, mais je ne comprends pas pourquoi. J'utilise ce code pour stocker les grappes dans les nuages ​​de points séparés:

//Store clusters into new pcls and all the clusters in an array of pcls 
    std::vector<pcl::PointCloud<pcl::PointXYZRGB>::Ptr> clusters_pcl; 
    for (int i = 0; i < clusters.size(); ++i) { 
      pcl::PointCloud<pcl::PointXYZRGB>::Ptr cloud_cluster( 
          new pcl::PointCloud<pcl::PointXYZRGB>); 
      cloud_cluster->width = clusters[i].indices.size(); 
      cloud_cluster->height = 1; 
      cloud_cluster->is_dense = true; 
      for (int j = 0; j < clusters[i].indices.size(); ++j) { 
        //Take the corresponding point of the filtered cloud from the indices for the new pcl 
        cloud_cluster->push_back( 
            point_cloud_ptr->at(clusters[i].indices[j])); 
      } 
      indices2.clear(); 
      //pcl::removeNaNFromPointCloud(*cloud_cluster, *cloud_cluster, indices2); 
      clusters_pcl.push_back(cloud_cluster); 
    } 

Est-il mon code qui fait quelque chose de mal ou est la sortie de la région de segmentation croissante fait droit?

Vive

------------- EDIT -----------------

Here est le nuage point que je J'utilise pour les tests.

Voici le code de segmentation région de plus en plus complète, il est semblable à celui dans le tutoriel:

std::vector<pcl::PointCloud<pcl::PointXYZRGB>::Ptr> region_growing_segmentation(
    pcl::PointCloud<pcl::PointXYZRGB>::Ptr point_cloud_ptr) { 
pcl::PointCloud<pcl::PointXYZRGB>& point_cloud = *point_cloud_ptr; 
std::vector<int> indices2; 
// Create the filtering object: downsample the dataset using a leaf size of 1cm 
pcl::VoxelGrid<pcl::PointXYZRGB> vg; 
pcl::PointCloud<pcl::PointXYZRGB>::Ptr cloud_filtered(
     new pcl::PointCloud<pcl::PointXYZRGB>); 
vg.setInputCloud(point_cloud_ptr); 
vg.setLeafSize(0.025f, 0.025f, 0.025f); 
vg.filter(*cloud_filtered); 
std::cout << "PointCloud after filtering has: " 
     << cloud_filtered->points.size() << " data points." << std::endl; 

pcl::search::Search<pcl::PointXYZRGB>::Ptr tree = boost::shared_ptr< 
     pcl::search::Search<pcl::PointXYZRGB> >(
     new pcl::search::KdTree<pcl::PointXYZRGB>); 
pcl::PointCloud<pcl::Normal>::Ptr normals(new pcl::PointCloud<pcl::Normal>); 
pcl::NormalEstimation<pcl::PointXYZRGB, pcl::Normal> normal_estimator; 
normal_estimator.setSearchMethod(tree); 
normal_estimator.setInputCloud(cloud_filtered); 
normal_estimator.setKSearch(50); 
normal_estimator.compute(*normals); 

pcl::RegionGrowing<pcl::PointXYZRGB, pcl::Normal> reg; 
reg.setMinClusterSize(50); 
reg.setMaxClusterSize(1000000); 
reg.setSearchMethod(tree); 
reg.setNumberOfNeighbours(100); 
reg.setInputCloud(cloud_filtered); 
reg.setInputNormals(normals); 
reg.setSmoothnessThreshold(5.0/180.0 * M_PI); 
reg.setCurvatureThreshold(1); 

std::vector<pcl::PointIndices> clusters; 
reg.extract(clusters); 
pcl::PointCloud<pcl::PointXYZRGB>::Ptr colored_cloud = 
     reg.getColoredCloud(); 
pcl::visualization::CloudViewer viewer("Cluster viewer"); 
viewer.showCloud(colored_cloud); 
while (!viewer.wasStopped()) { 
} 
std::vector<pcl::PointCloud<pcl::PointXYZRGB>::Ptr> clusters_pcl; 
for (int i = 0; i < clusters.size(); ++i) { 
pcl::PointCloud<pcl::PointXYZRGB>::Ptr cloud_cluster(
new pcl::PointCloud<pcl::PointXYZRGB>); 
cloud_cluster->width = clusters[i].indices.size(); 
cloud_cluster->height = 1; 
cloud_cluster->is_dense = true; 
for (int j = 0; j < clusters[i].indices.size(); ++j) { 
//Take the corresponding point of the filtered cloud from the indices for the new pcl 
cloud_cluster->push_back(
point_cloud_ptr->at(clusters[i].indices[j])); 
} 
indices2.clear(); 
//pcl::removeNaNFromPointCloud(*cloud_cluster, *cloud_cluster, indices2); 
clusters_pcl.push_back(cloud_cluster); 
} 

return clusters_pcl; 
} 

Answer 1

Alors je me suis juste, c'était trop simple je ne pouvais pas le voir; Pardon. Lorsque je copiais les points dans les clusters, j'utilisais le nuage de points d'origine au lieu de celui filtré. Peut-être que des résultats où comme ça je n'ai même pas pensé à ça.

donc ceci:

cloud_cluster->push_back(
       point_cloud_ptr->at(clusters[i].indices[j])); 

doit être remplacé par:

cloud_cluster->push_back(
       cloud_filtered->at(clusters[i].indices[j])); 

Vive

Answer 2

Essayez ce code:

pcl::ExtractIndices<pcl::PointXYZRGB> extract; 
    std::vector<pcl::PointCloud<pcl::PointXYZRGB>::Ptr> output_clouds; //vector of point clouds that will hold the cluster clouds 

    for (int i = 0; i < clusters.size(); ++i){ 
     upcloud cloud_temp(new pcl::PointCloud<pcl::PointXYZRGB>); 

     //extract the cloud from the cluster indicies 
     extract.setInputCloud(input_cloud); 
     pcl::PointIndices cluster = clusters[i]; 
     boost::shared_ptr<pcl::PointIndices> indicies = boost::make_shared<pcl::PointIndices>(cluster); 
     extract.setIndices(indicies); 
     extract.setNegative(false); 
     extract.filter(*cloud_temp); 

     output_clouds.push_back(cloud_temp); 
    }