Go to the documentation of this file.00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038 #include <pcl/apps/optronic_viewer/cloud_filter.h>
00039
00040 #include <pcl/filters/voxel_grid.h>
00041 #include <pcl/filters/passthrough.h>
00042 #include <pcl/filters/radius_outlier_removal.h>
00043 #include <pcl/filters/bilateral.h>
00044 #include <pcl/filters/fast_bilateral.h>
00045 #include <pcl/filters/median_filter.h>
00046 #include <pcl/filters/random_sample.h>
00047
00048 #include <pcl/features/integral_image_normal.h>
00049
00050 #include <pcl/sample_consensus/ransac.h>
00051 #include <pcl/sample_consensus/sac_model_normal_plane.h>
00052 #include <pcl/segmentation/extract_clusters.h>
00053
00054 #include <pcl/io/pcd_io.h>
00055
00056 extern char pcl::apps::optronic_viewer::g_voxel_grid_cf_name[] = "VoxelGrid Filter";
00057 extern char pcl::apps::optronic_viewer::g_passthrough_cf_name[] = "PassThrough Filter";
00058 extern char pcl::apps::optronic_viewer::g_radius_outlier_cf_name[] = "RadiusOutlier Filter";
00059 extern char pcl::apps::optronic_viewer::g_fast_bilateral_cf_name[] = "Fast Bilateral Filter";
00060 extern char pcl::apps::optronic_viewer::g_median_cf_name[] = "Median Filter";
00061 extern char pcl::apps::optronic_viewer::g_random_sample_cf_name[] = "Random Sample Filter";
00062 extern char pcl::apps::optronic_viewer::g_plane_cf_name[] = "Plane Filter";
00063
00065 pcl::apps::optronic_viewer::
00066 VoxelGridCF::
00067 VoxelGridCF ()
00068 : filter_selection_page_ (new QWizardPage ())
00069 , voxel_grid_size_x_ (0.01)
00070 , voxel_grid_size_y_ (0.01)
00071 , voxel_grid_size_z_ (0.01)
00072 {
00073 voxel_grid_size_x_label_ = new QLabel (QObject::tr ("Voxel Grid Size in X-Direction:"));
00074 voxel_grid_size_x_line_edit_ = new QLineEdit ();
00075 voxel_grid_size_y_label_ = new QLabel (QObject::tr ("Voxel Grid Size in Y-Direction:"));
00076 voxel_grid_size_y_line_edit_ = new QLineEdit ();
00077 voxel_grid_size_z_label_ = new QLabel (QObject::tr ("Voxel Grid Size in Z-Direction:"));
00078 voxel_grid_size_z_line_edit_ = new QLineEdit ();
00079
00080 QDoubleValidator * double_validator = new QDoubleValidator ();
00081 voxel_grid_size_x_line_edit_->setValidator (double_validator);
00082 voxel_grid_size_y_line_edit_->setValidator (double_validator);
00083 voxel_grid_size_z_line_edit_->setValidator (double_validator);
00084
00085 std::stringstream ss_x;
00086 ss_x << voxel_grid_size_x_;
00087 voxel_grid_size_x_line_edit_->setText (QString (ss_x.str ().c_str ()));
00088
00089 std::stringstream ss_y;
00090 ss_y << voxel_grid_size_y_;
00091 voxel_grid_size_y_line_edit_->setText (QString (ss_y.str ().c_str ()));
00092
00093 std::stringstream ss_z;
00094 ss_z << voxel_grid_size_z_;
00095 voxel_grid_size_z_line_edit_->setText (QString (ss_z.str ().c_str ()));
00096
00097 main_layout_ = new QVBoxLayout (filter_selection_page_);
00098 main_layout_->addWidget (voxel_grid_size_x_label_);
00099 main_layout_->addWidget (voxel_grid_size_x_line_edit_);
00100 main_layout_->addWidget (voxel_grid_size_y_label_);
00101 main_layout_->addWidget (voxel_grid_size_y_line_edit_);
00102 main_layout_->addWidget (voxel_grid_size_z_label_);
00103 main_layout_->addWidget (voxel_grid_size_z_line_edit_);
00104 }
00105
00107 pcl::apps::optronic_viewer::
00108 VoxelGridCF::
00109 ~VoxelGridCF ()
00110 {
00111 }
00112
00114 void
00115 pcl::apps::optronic_viewer::
00116 VoxelGridCF::
00117 filter (
00118 pcl::PointCloud<pcl::PointXYZRGBA>::ConstPtr &cloud_in,
00119 pcl::PointCloud<pcl::PointXYZRGBA>::Ptr &cloud_out)
00120 {
00121 voxel_grid_size_x_ = voxel_grid_size_x_line_edit_->text ().toFloat ();
00122 voxel_grid_size_y_ = voxel_grid_size_y_line_edit_->text ().toFloat ();
00123 voxel_grid_size_z_ = voxel_grid_size_z_line_edit_->text ().toFloat ();
00124
00125 pcl::VoxelGrid<pcl::PointXYZRGBA> sor;
00126 sor.setInputCloud (cloud_in);
00127 sor.setLeafSize (voxel_grid_size_x_, voxel_grid_size_y_, voxel_grid_size_z_);
00128 sor.filter (*cloud_out);
00129 }
00130
00131
00133
00134
00136
00137
00139 pcl::apps::optronic_viewer::
00140 PassThroughCF::
00141 PassThroughCF ()
00142 : filter_selection_page_ (new QWizardPage ())
00143 , filter_field_name_ ("z")
00144 , filter_limits_min_ (0)
00145 , filter_limits_max_ (5)
00146 {
00147 filter_field_name_label_ = new QLabel (QObject::tr ("Filter Field Name:"));
00148 filter_field_name_line_edit_ = new QLineEdit ();
00149 filter_limits_min_label_ = new QLabel (QObject::tr ("Filter Limit - Minimum:"));
00150 filter_limits_min_line_edit_ = new QLineEdit ();
00151 filter_limits_max_label_ = new QLabel (QObject::tr ("Filter Limit - Maximum:"));
00152 filter_limits_max_line_edit_ = new QLineEdit ();
00153
00154 QDoubleValidator * double_validator = new QDoubleValidator ();
00155 filter_limits_min_line_edit_->setValidator (double_validator);
00156 filter_limits_max_line_edit_->setValidator (double_validator);
00157
00158 std::stringstream ss_x;
00159 ss_x << filter_field_name_;
00160 filter_field_name_line_edit_->setText (QString (ss_x.str ().c_str ()));
00161
00162 std::stringstream ss_y;
00163 ss_y << filter_limits_min_;
00164 filter_limits_min_line_edit_->setText (QString (ss_y.str ().c_str ()));
00165
00166 std::stringstream ss_z;
00167 ss_z << filter_limits_max_;
00168 filter_limits_max_line_edit_->setText (QString (ss_z.str ().c_str ()));
00169
00170 main_layout_ = new QVBoxLayout (filter_selection_page_);
00171 main_layout_->addWidget (filter_field_name_label_);
00172 main_layout_->addWidget (filter_field_name_line_edit_);
00173 main_layout_->addWidget (filter_limits_min_label_);
00174 main_layout_->addWidget (filter_limits_min_line_edit_);
00175 main_layout_->addWidget (filter_limits_max_label_);
00176 main_layout_->addWidget (filter_limits_max_line_edit_);
00177 }
00178
00180 pcl::apps::optronic_viewer::
00181 PassThroughCF::
00182 ~PassThroughCF ()
00183 {
00184 }
00185
00187 void
00188 pcl::apps::optronic_viewer::
00189 PassThroughCF::
00190 filter (
00191 pcl::PointCloud<pcl::PointXYZRGBA>::ConstPtr &cloud_in,
00192 pcl::PointCloud<pcl::PointXYZRGBA>::Ptr &cloud_out)
00193 {
00194 filter_field_name_ = filter_field_name_line_edit_->text ().toStdString ();
00195 filter_limits_min_ = filter_limits_min_line_edit_->text ().toFloat ();
00196 filter_limits_max_ = filter_limits_max_line_edit_->text ().toFloat ();
00197
00198 pcl::PassThrough<pcl::PointXYZRGBA> filter;
00199 filter.setInputCloud (cloud_in);
00200 filter.setFilterFieldName (filter_field_name_);
00201 filter.setFilterLimits (filter_limits_min_, filter_limits_max_);
00202 filter.filter (*cloud_out);
00203 }
00204
00205
00207
00208
00210
00211
00213 pcl::apps::optronic_viewer::
00214 RadiusOutlierCF::
00215 RadiusOutlierCF ()
00216 : filter_selection_page_ (new QWizardPage ())
00217 , search_radius_ (0.05f)
00218 , min_neighbors_in_radius_ (500)
00219 {
00220 search_radius_label_ = new QLabel (QObject::tr ("Search Radius:"));
00221 search_radius_line_edit_ = new QLineEdit ();
00222 min_neighbors_in_radius_label_ = new QLabel (QObject::tr ("Minimum Number of Neighbors within Radius:"));
00223 min_neighbors_in_radius_line_edit_ = new QLineEdit ();
00224
00225 QDoubleValidator * double_validator = new QDoubleValidator ();
00226 QIntValidator * int_validator = new QIntValidator ();
00227 search_radius_line_edit_->setValidator (double_validator);
00228 min_neighbors_in_radius_line_edit_->setValidator (int_validator);
00229
00230 std::stringstream ss_x;
00231 ss_x << search_radius_;
00232 search_radius_line_edit_->setText (QString (ss_x.str ().c_str ()));
00233
00234 std::stringstream ss_y;
00235 ss_y << min_neighbors_in_radius_;
00236 min_neighbors_in_radius_line_edit_->setText (QString (ss_y.str ().c_str ()));
00237
00238 main_layout_ = new QVBoxLayout (filter_selection_page_);
00239 main_layout_->addWidget (search_radius_label_);
00240 main_layout_->addWidget (search_radius_line_edit_);
00241 main_layout_->addWidget (min_neighbors_in_radius_label_);
00242 main_layout_->addWidget (min_neighbors_in_radius_line_edit_);
00243 }
00244
00246 pcl::apps::optronic_viewer::
00247 RadiusOutlierCF::
00248 ~RadiusOutlierCF ()
00249 {
00250 }
00251
00253 void
00254 pcl::apps::optronic_viewer::
00255 RadiusOutlierCF::
00256 filter (
00257 pcl::PointCloud<pcl::PointXYZRGBA>::ConstPtr &cloud_in,
00258 pcl::PointCloud<pcl::PointXYZRGBA>::Ptr &cloud_out)
00259 {
00260 search_radius_ = search_radius_line_edit_->text ().toFloat ();
00261 min_neighbors_in_radius_ = min_neighbors_in_radius_line_edit_->text ().toInt ();
00262
00263 pcl::RadiusOutlierRemoval<pcl::PointXYZRGBA> filter;
00264 filter.setInputCloud (cloud_in);
00265 filter.setRadiusSearch (search_radius_);
00266 filter.setMinNeighborsInRadius (min_neighbors_in_radius_);
00267 filter.filter (*cloud_out);
00268 }
00269
00270
00272
00273
00275
00276
00278 pcl::apps::optronic_viewer::
00279 FastBilateralCF::
00280 FastBilateralCF ()
00281 : filter_selection_page_ (new QWizardPage ())
00282 , sigma_s_ (5.0f)
00283 , sigma_r_ (0.03f)
00284 {
00285 sigma_s_label_ = new QLabel (QObject::tr ("Half Size (sigma s) (Minimum: 1.0):"));
00286 sigma_s_line_edit_ = new QLineEdit ();
00287 sigma_r_label_ = new QLabel (QObject::tr ("Standard Deviation (sigma r) (Minimum: 0.0001):"));
00288 sigma_r_line_edit_ = new QLineEdit ();
00289
00290 QDoubleValidator * double_validator = new QDoubleValidator ();
00291 sigma_s_line_edit_->setValidator (double_validator);
00292 sigma_r_line_edit_->setValidator (double_validator);
00293
00294 std::stringstream ss_x;
00295 ss_x << sigma_s_;
00296 sigma_s_line_edit_->setText (QString (ss_x.str ().c_str ()));
00297
00298 std::stringstream ss_y;
00299 ss_y << sigma_r_;
00300 sigma_r_line_edit_->setText (QString (ss_y.str ().c_str ()));
00301
00302 main_layout_ = new QVBoxLayout (filter_selection_page_);
00303 main_layout_->addWidget (sigma_s_label_);
00304 main_layout_->addWidget (sigma_s_line_edit_);
00305 main_layout_->addWidget (sigma_r_label_);
00306 main_layout_->addWidget (sigma_r_line_edit_);
00307 }
00308
00310 pcl::apps::optronic_viewer::
00311 FastBilateralCF::
00312 ~FastBilateralCF ()
00313 {
00314 }
00315
00317 void
00318 pcl::apps::optronic_viewer::
00319 FastBilateralCF::
00320 filter (
00321 pcl::PointCloud<pcl::PointXYZRGBA>::ConstPtr &cloud_in,
00322 pcl::PointCloud<pcl::PointXYZRGBA>::Ptr &cloud_out)
00323 {
00324 sigma_s_ = sigma_s_line_edit_->text ().toFloat ();
00325 sigma_r_ = sigma_r_line_edit_->text ().toFloat ();
00326
00327
00328
00329
00330 if (sigma_s_ <= 1.0f)
00331 sigma_s_ = 1.0f;
00332 if (sigma_r_ <= 0.0001f)
00333 sigma_r_ = 0.0001f;
00334
00335 pcl::FastBilateralFilter<pcl::PointXYZRGBA> fbf;
00336 fbf.setInputCloud (cloud_in);
00337 fbf.setSigmaS (sigma_s_);
00338 fbf.setSigmaR (sigma_r_);
00339 fbf.filter (*cloud_out);
00340 }
00341
00342
00344
00345
00347
00348
00350 pcl::apps::optronic_viewer::
00351 MedianCF::
00352 MedianCF ()
00353 : filter_selection_page_ (new QWizardPage ())
00354 , max_allowed_movement_ (1.0f)
00355 , window_size_ (1)
00356 {
00357 max_allowed_movement_label_ = new QLabel (QObject::tr ("Maximum Allowed Movement (Minimum: 0.0):"));
00358 max_allowed_movement_line_edit_ = new QLineEdit ();
00359 window_size_label_ = new QLabel (QObject::tr ("Window Size (Minimum: 1):"));
00360 window_size_line_edit_ = new QLineEdit ();
00361
00362 QDoubleValidator * double_validator = new QDoubleValidator ();
00363 QIntValidator * int_validator = new QIntValidator ();
00364 max_allowed_movement_line_edit_->setValidator (double_validator);
00365 window_size_line_edit_->setValidator (int_validator);
00366
00367 std::stringstream ss_x;
00368 ss_x << max_allowed_movement_;
00369 max_allowed_movement_line_edit_->setText (QString (ss_x.str ().c_str ()));
00370
00371 std::stringstream ss_y;
00372 ss_y << window_size_;
00373 window_size_line_edit_->setText (QString (ss_y.str ().c_str ()));
00374
00375 main_layout_ = new QVBoxLayout (filter_selection_page_);
00376 main_layout_->addWidget (max_allowed_movement_label_);
00377 main_layout_->addWidget (max_allowed_movement_line_edit_);
00378 main_layout_->addWidget (window_size_label_);
00379 main_layout_->addWidget (window_size_line_edit_);
00380 }
00381
00383 pcl::apps::optronic_viewer::
00384 MedianCF::
00385 ~MedianCF ()
00386 {
00387 }
00388
00390 void
00391 pcl::apps::optronic_viewer::
00392 MedianCF::
00393 filter (
00394 pcl::PointCloud<pcl::PointXYZRGBA>::ConstPtr &cloud_in,
00395 pcl::PointCloud<pcl::PointXYZRGBA>::Ptr &cloud_out)
00396 {
00397 max_allowed_movement_ = max_allowed_movement_line_edit_->text ().toFloat ();
00398 window_size_ = window_size_line_edit_->text ().toInt ();
00399
00400 if (max_allowed_movement_ <= 0.0f)
00401 max_allowed_movement_ = 0.0f;
00402 if (window_size_ < 1)
00403 window_size_ = 1;
00404
00405 pcl::MedianFilter<pcl::PointXYZRGBA> fbf;
00406 fbf.setInputCloud (cloud_in);
00407 fbf.setMaxAllowedMovement (max_allowed_movement_);
00408 fbf.setWindowSize (window_size_);
00409 fbf.filter (*cloud_out);
00410 }
00411
00412
00414
00415
00417
00418
00420 pcl::apps::optronic_viewer::
00421 RandomSampleCF::
00422 RandomSampleCF ()
00423 : filter_selection_page_ (new QWizardPage ())
00424 , seed_ (1)
00425 , sample_ (1000)
00426 {
00427 seed_label_ = new QLabel (QObject::tr ("Seed for Random Number Generator:"));
00428 seed_line_edit_ = new QLineEdit ();
00429 sample_label_ = new QLabel (QObject::tr ("Number of Samples drawn from the Input Cloud:"));
00430 sample_line_edit_ = new QLineEdit ();
00431
00432 QIntValidator * int_validator = new QIntValidator ();
00433 seed_line_edit_->setValidator (int_validator);
00434 sample_line_edit_->setValidator (int_validator);
00435
00436 std::stringstream ss_x;
00437 ss_x << seed_;
00438 seed_line_edit_->setText (QString (ss_x.str ().c_str ()));
00439
00440 std::stringstream ss_y;
00441 ss_y << sample_;
00442 sample_line_edit_->setText (QString (ss_y.str ().c_str ()));
00443
00444 main_layout_ = new QVBoxLayout (filter_selection_page_);
00445 main_layout_->addWidget (seed_label_);
00446 main_layout_->addWidget (seed_line_edit_);
00447 main_layout_->addWidget (sample_label_);
00448 main_layout_->addWidget (sample_line_edit_);
00449 }
00450
00452 pcl::apps::optronic_viewer::
00453 RandomSampleCF::
00454 ~RandomSampleCF ()
00455 {
00456 }
00457
00459 void
00460 pcl::apps::optronic_viewer::
00461 RandomSampleCF::
00462 filter (
00463 pcl::PointCloud<pcl::PointXYZRGBA>::ConstPtr &cloud_in,
00464 pcl::PointCloud<pcl::PointXYZRGBA>::Ptr &cloud_out)
00465 {
00466 seed_ = seed_line_edit_->text ().toFloat ();
00467 sample_ = sample_line_edit_->text ().toInt ();
00468
00469 if (sample_ < 1)
00470 sample_ = 1;
00471
00472 pcl::RandomSample<pcl::PointXYZRGBA> fbf;
00473 fbf.setInputCloud (cloud_in);
00474 fbf.setSeed (seed_);
00475 fbf.setSample (sample_);
00476 fbf.filter (*cloud_out);
00477 }
00478
00479
00481
00482
00484
00485
00487 pcl::apps::optronic_viewer::
00488 PlaneCF::
00489 PlaneCF ()
00490 : filter_selection_page_ (new QWizardPage ())
00491 , threshold_ (0.05f)
00492 , max_iterations_ (1000)
00493 , refinement_sigma_ (2)
00494 , max_refinement_iterations_ (50)
00495 , return_negative_ (false)
00496 , cluster_tolerance_ (0.02)
00497 , min_cluster_size_ (100)
00498 {
00499 threshold_label_ = new QLabel (QObject::tr ("Threshold for plane detection:"));
00500 threshold_line_edit_ = new QLineEdit ();
00501 max_iterations_label_ = new QLabel (QObject::tr ("Maximum number of iterations for plane estimation:"));
00502 max_iterations_line_edit_ = new QLineEdit ();
00503 refinement_sigma_label_ = new QLabel (QObject::tr ("Sigma for plane parameter refinement:"));
00504 refinement_sigma_line_edit_ = new QLineEdit ();
00505 max_refinement_iterations_label_ = new QLabel (QObject::tr ("Maximum number of iterations for plane parameter refinement:"));
00506 max_refinement_iterations_line_edit_ = new QLineEdit ();
00507 return_negative_label_ = new QLabel (QObject::tr ("Invert filter (return everything except plane)?"));
00508 return_negative_check_box_ = new QCheckBox ();
00509 cluster_tolerance_label_ = new QLabel (QObject::tr ("Cluster tolerance for plane segmentation:"));
00510 cluster_tolerance_line_edit_ = new QLineEdit ();
00511 min_cluster_size_label_ = new QLabel (QObject::tr ("Minimum cluster size:"));
00512 min_cluster_size_line_edit_ = new QLineEdit ();
00513
00514 QDoubleValidator * double_validator = new QDoubleValidator ();
00515 QIntValidator * int_validator = new QIntValidator ();
00516 threshold_line_edit_->setValidator (double_validator);
00517 refinement_sigma_line_edit_->setValidator (double_validator);
00518 cluster_tolerance_line_edit_->setValidator (double_validator);
00519 max_iterations_line_edit_->setValidator (int_validator);
00520 max_refinement_iterations_line_edit_->setValidator (int_validator);
00521 min_cluster_size_line_edit_->setValidator (int_validator);
00522
00523 {
00524 std::stringstream ss;
00525 ss << threshold_;
00526 threshold_line_edit_->setText (QString (ss.str ().c_str ()));
00527 }
00528 {
00529 std::stringstream ss;
00530 ss << max_iterations_;
00531 max_iterations_line_edit_->setText (QString (ss.str ().c_str ()));
00532 }
00533 {
00534 std::stringstream ss;
00535 ss << refinement_sigma_;
00536 refinement_sigma_line_edit_->setText (QString (ss.str ().c_str ()));
00537 }
00538 {
00539 std::stringstream ss;
00540 ss << max_refinement_iterations_;
00541 max_refinement_iterations_line_edit_->setText (QString (ss.str ().c_str ()));
00542 }
00543 {
00544 std::stringstream ss;
00545 ss << cluster_tolerance_;
00546 cluster_tolerance_line_edit_->setText (QString (ss.str ().c_str ()));
00547 }
00548 {
00549 std::stringstream ss;
00550 ss << min_cluster_size_;
00551 min_cluster_size_line_edit_->setText (QString (ss.str ().c_str ()));
00552 }
00553
00554 if (return_negative_)
00555 return_negative_check_box_->setCheckState (Qt::Checked);
00556 else
00557 return_negative_check_box_->setCheckState (Qt::Unchecked);
00558
00559 main_layout_ = new QVBoxLayout (filter_selection_page_);
00560 main_layout_->addWidget (threshold_label_);
00561 main_layout_->addWidget (threshold_line_edit_);
00562 main_layout_->addWidget (max_iterations_label_);
00563 main_layout_->addWidget (max_iterations_line_edit_);
00564 main_layout_->addWidget (refinement_sigma_label_);
00565 main_layout_->addWidget (refinement_sigma_line_edit_);
00566 main_layout_->addWidget (max_refinement_iterations_label_);
00567 main_layout_->addWidget (max_refinement_iterations_line_edit_);
00568 main_layout_->addWidget (return_negative_label_);
00569 main_layout_->addWidget (return_negative_check_box_);
00570 main_layout_->addWidget (cluster_tolerance_label_);
00571 main_layout_->addWidget (cluster_tolerance_line_edit_);
00572 main_layout_->addWidget (min_cluster_size_label_);
00573 main_layout_->addWidget (min_cluster_size_line_edit_);
00574 }
00575
00577 pcl::apps::optronic_viewer::
00578 PlaneCF::
00579 ~PlaneCF ()
00580 {
00581 }
00582
00584 void
00585 pcl::apps::optronic_viewer::
00586 PlaneCF::
00587 filter (
00588 pcl::PointCloud<pcl::PointXYZRGBA>::ConstPtr &cloud_in,
00589 pcl::PointCloud<pcl::PointXYZRGBA>::Ptr &cloud_out)
00590 {
00591 threshold_ = threshold_line_edit_->text ().toFloat ();
00592 max_iterations_ = max_iterations_line_edit_->text ().toInt ();
00593 refinement_sigma_ = refinement_sigma_line_edit_->text ().toFloat ();
00594 max_refinement_iterations_ = max_refinement_iterations_line_edit_->text ().toInt ();
00595 cluster_tolerance_ = cluster_tolerance_line_edit_->text ().toFloat ();
00596 min_cluster_size_ = min_cluster_size_line_edit_->text ().toInt ();
00597
00598 if (max_iterations_ < 0)
00599 max_iterations_ = 0;
00600 if (max_refinement_iterations_ < 0)
00601 max_refinement_iterations_ = 0;
00602
00603 if (cluster_tolerance_ < 0.0001)
00604 cluster_tolerance_ = 0.0001;
00605
00606 return_negative_ = return_negative_check_box_->checkState () == Qt::Checked;
00607
00608 pcl::SampleConsensusModelPlane<pcl::PointXYZRGBA>::Ptr model (new pcl::SampleConsensusModelPlane<pcl::PointXYZRGBA> (cloud_in));
00609 pcl::RandomSampleConsensus<pcl::PointXYZRGBA> sac (model, threshold_);
00610 sac.setMaxIterations (max_iterations_);
00611 bool res = sac.computeModel ();
00612
00613 std::vector<int> inliers;
00614 sac.getInliers (inliers);
00615
00616 if (!res || inliers.empty ())
00617 {
00618 std::cerr << "no planar model found!" << std::endl;
00619 return;
00620 }
00621
00622 sac.refineModel (refinement_sigma_, max_refinement_iterations_);
00623 sac.getInliers (inliers);
00624
00625 if (return_negative_)
00626 {
00627 pcl::PointIndices::Ptr everything_but_the_plane (new pcl::PointIndices ());
00628 std::vector<int> indices_fullset (cloud_in->size ());
00629 for (int p_it = 0; p_it < static_cast<int> (indices_fullset.size ()); ++p_it)
00630 indices_fullset[p_it] = p_it;
00631
00632 std::sort (inliers.begin (), inliers.end ());
00633 std::set_difference (indices_fullset.begin (), indices_fullset.end (),
00634 inliers.begin (), inliers.end (),
00635 inserter (everything_but_the_plane->indices, everything_but_the_plane->indices.begin ()));
00636
00637
00638 std::vector<pcl::PointIndices> cluster_indices;
00639 pcl::EuclideanClusterExtraction<PointXYZRGBA> ec;
00640 ec.setClusterTolerance (cluster_tolerance_);
00641 ec.setMinClusterSize (min_cluster_size_);
00642 ec.setInputCloud (cloud_in);
00643 ec.setIndices (everything_but_the_plane);
00644 ec.extract (cluster_indices);
00645
00646 if (!cluster_indices.empty ())
00647 {
00648
00649 pcl::copyPointCloud (*cloud_in, cluster_indices[0].indices, *cloud_out);
00650 }
00651 }
00652 else
00653 {
00654 pcl::copyPointCloud (*cloud_in, inliers, *cloud_out);
00655 }
00656 }
00657
00658
00659
00660
00661
00662