Point Cloud Library (PCL)  1.11.1-dev
radius_outlier_removal.h
1 /*
2  * Software License Agreement (BSD License)
3  *
4  * Point Cloud Library (PCL) - www.pointclouds.org
5  * Copyright (c) 2010-2012, Willow Garage, Inc.
6  *
7  * All rights reserved.
8  *
9  * Redistribution and use in source and binary forms, with or without
10  * modification, are permitted provided that the following conditions
11  * are met:
12  *
13  * * Redistributions of source code must retain the above copyright
14  * notice, this list of conditions and the following disclaimer.
15  * * Redistributions in binary form must reproduce the above
16  * copyright notice, this list of conditions and the following
17  * disclaimer in the documentation and/or other materials provided
18  * with the distribution.
19  * * Neither the name of the copyright holder(s) nor the names of its
20  * contributors may be used to endorse or promote products derived
21  * from this software without specific prior written permission.
22  *
23  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
24  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
25  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
26  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
27  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
28  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
29  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
30  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
31  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
33  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
34  * POSSIBILITY OF SUCH DAMAGE.
35  *
36  * $Id$
37  *
38  */
39 
40 #pragma once
41 
42 #include <pcl/filters/filter_indices.h>
43 #include <pcl/search/search.h> // for Search, Search<>::Ptr
44 
45 namespace pcl
46 {
47  /** \brief @b RadiusOutlierRemoval filters points in a cloud based on the number of neighbors they have.
48  * \details Iterates through the entire input once, and for each point, retrieves the number of neighbors within a certain radius.
49  * The point will be considered an outlier if it has too few neighbors, as determined by setMinNeighborsInRadius().
50  * The radius can be changed using setRadiusSearch().
51  * <br>
52  * The neighbors found for each query point will be found amongst ALL points of setInputCloud(), not just those indexed by setIndices().
53  * The setIndices() method only indexes the points that will be iterated through as search query points.
54  * <br><br>
55  * Usage example:
56  * \code
57  * pcl::RadiusOutlierRemoval<PointType> rorfilter (true); // Initializing with true will allow us to extract the removed indices
58  * rorfilter.setInputCloud (cloud_in);
59  * rorfilter.setRadiusSearch (0.1);
60  * rorfilter.setMinNeighborsInRadius (5);
61  * rorfilter.setNegative (true);
62  * rorfilter.filter (*cloud_out);
63  * // The resulting cloud_out contains all points of cloud_in that have 4 or less neighbors within the 0.1 search radius
64  * indices_rem = rorfilter.getRemovedIndices ();
65  * // The indices_rem array indexes all points of cloud_in that have 5 or more neighbors within the 0.1 search radius
66  * \endcode
67  * \author Radu Bogdan Rusu
68  * \ingroup filters
69  */
70  template<typename PointT>
71  class RadiusOutlierRemoval : public FilterIndices<PointT>
72  {
73  protected:
75  using PointCloudPtr = typename PointCloud::Ptr;
78 
79  public:
80 
81  using Ptr = shared_ptr<RadiusOutlierRemoval<PointT> >;
82  using ConstPtr = shared_ptr<const RadiusOutlierRemoval<PointT> >;
83 
84 
85  /** \brief Constructor.
86  * \param[in] extract_removed_indices Set to true if you want to be able to extract the indices of points being removed (default = false).
87  */
88  RadiusOutlierRemoval (bool extract_removed_indices = false) :
89  FilterIndices<PointT> (extract_removed_indices),
90  searcher_ (),
91  search_radius_ (0.0),
92  min_pts_radius_ (1)
93  {
94  filter_name_ = "RadiusOutlierRemoval";
95  }
96 
97  /** \brief Set the radius of the sphere that will determine which points are neighbors.
98  * \details The number of points within this distance from the query point will need to be equal or greater
99  * than setMinNeighborsInRadius() in order to be classified as an inlier point (i.e. will not be filtered).
100  * \param[in] radius The radius of the sphere for nearest neighbor searching.
101  */
102  inline void
103  setRadiusSearch (double radius)
104  {
105  search_radius_ = radius;
106  }
107 
108  /** \brief Get the radius of the sphere that will determine which points are neighbors.
109  * \details The number of points within this distance from the query point will need to be equal or greater
110  * than setMinNeighborsInRadius() in order to be classified as an inlier point (i.e. will not be filtered).
111  * \return The radius of the sphere for nearest neighbor searching.
112  */
113  inline double
115  {
116  return (search_radius_);
117  }
118 
119  /** \brief Set the number of neighbors that need to be present in order to be classified as an inlier.
120  * \details The number of points within setRadiusSearch() from the query point will need to be equal or greater
121  * than this number in order to be classified as an inlier point (i.e. will not be filtered).
122  * \param min_pts The minimum number of neighbors (default = 1).
123  */
124  inline void
126  {
127  min_pts_radius_ = min_pts;
128  }
129 
130  /** \brief Get the number of neighbors that need to be present in order to be classified as an inlier.
131  * \details The number of points within setRadiusSearch() from the query point will need to be equal or greater
132  * than this number in order to be classified as an inlier point (i.e. will not be filtered).
133  * \return The minimum number of neighbors (default = 1).
134  */
135  inline int
137  {
138  return (min_pts_radius_);
139  }
140 
141  protected:
151 
152  /** \brief Filtered results are indexed by an indices array.
153  * \param[out] indices The resultant indices.
154  */
155  void
156  applyFilter (Indices &indices) override
157  {
158  applyFilterIndices (indices);
159  }
160 
161  /** \brief Filtered results are indexed by an indices array.
162  * \param[out] indices The resultant indices.
163  */
164  void
165  applyFilterIndices (Indices &indices);
166 
167  private:
168  /** \brief A pointer to the spatial search object. */
169  SearcherPtr searcher_;
170 
171  /** \brief The nearest neighbors search radius for each point. */
172  double search_radius_;
173 
174  /** \brief The minimum number of neighbors that a point needs to have in the given search radius to be considered an inlier. */
175  int min_pts_radius_;
176  };
177 
178  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
179  /** \brief @b RadiusOutlierRemoval is a simple filter that removes outliers if the number of neighbors in a certain
180  * search radius is smaller than a given K.
181  * \author Radu Bogdan Rusu
182  * \ingroup filters
183  */
184  template<>
185  class PCL_EXPORTS RadiusOutlierRemoval<pcl::PCLPointCloud2> : public FilterIndices<pcl::PCLPointCloud2>
186  {
189 
192 
194  using KdTreePtr = pcl::search::Search<pcl::PointXYZ>::Ptr;
195 
199 
200  public:
201  /** \brief Empty constructor. */
202  RadiusOutlierRemoval (bool extract_removed_indices = false) :
203  FilterIndices<pcl::PCLPointCloud2>::FilterIndices (extract_removed_indices),
204  search_radius_ (0.0), min_pts_radius_ (1)
205  {
206  filter_name_ = "RadiusOutlierRemoval";
207  }
208 
209  /** \brief Set the sphere radius that is to be used for determining the k-nearest neighbors for filtering.
210  * \param radius the sphere radius that is to contain all k-nearest neighbors
211  */
212  inline void
213  setRadiusSearch (double radius)
214  {
215  search_radius_ = radius;
216  }
217 
218  /** \brief Get the sphere radius used for determining the k-nearest neighbors. */
219  inline double
221  {
222  return (search_radius_);
223  }
224 
225  /** \brief Set the minimum number of neighbors that a point needs to have in the given search radius in order to
226  * be considered an inlier (i.e., valid).
227  * \param min_pts the minimum number of neighbors
228  */
229  inline void
231  {
232  min_pts_radius_ = min_pts;
233  }
234 
235  /** \brief Get the minimum number of neighbors that a point needs to have in the given search radius to be
236  * considered an inlier and avoid being filtered.
237  */
238  inline double
240  {
241  return (min_pts_radius_);
242  }
243 
244  protected:
245  /** \brief The nearest neighbors search radius for each point. */
247 
248  /** \brief The minimum number of neighbors that a point needs to have in the given search radius to be considered
249  * an inlier.
250  */
252 
253  /** \brief A pointer to the spatial search object. */
254  KdTreePtr searcher_;
255 
256  void
257  applyFilter (PCLPointCloud2 &output) override;
258 
259  void
260  applyFilter (Indices &indices) override;
261  };
262 }
263 
264 #ifdef PCL_NO_PRECOMPILE
265 #include <pcl/filters/impl/radius_outlier_removal.hpp>
266 #endif
pcl::search::Search< pcl::PointXYZ >
pcl::RadiusOutlierRemoval< pcl::PCLPointCloud2 >::searcher_
KdTreePtr searcher_
A pointer to the spatial search object.
Definition: radius_outlier_removal.h:254
pcl
Definition: convolution.h:46
pcl::RadiusOutlierRemoval::setMinNeighborsInRadius
void setMinNeighborsInRadius(int min_pts)
Set the number of neighbors that need to be present in order to be classified as an inlier.
Definition: radius_outlier_removal.h:125
pcl::RadiusOutlierRemoval::Ptr
shared_ptr< RadiusOutlierRemoval< PointT > > Ptr
Definition: radius_outlier_removal.h:81
pcl::PCLBase::PointCloudConstPtr
typename PointCloud::ConstPtr PointCloudConstPtr
Definition: pcl_base.h:74
pcl::PCLBase::PointCloudPtr
typename PointCloud::Ptr PointCloudPtr
Definition: pcl_base.h:73
pcl::RadiusOutlierRemoval::RadiusOutlierRemoval
RadiusOutlierRemoval(bool extract_removed_indices=false)
Constructor.
Definition: radius_outlier_removal.h:88
pcl::PCLPointCloud2::Ptr
shared_ptr< ::pcl::PCLPointCloud2 > Ptr
Definition: PCLPointCloud2.h:35
pcl::RadiusOutlierRemoval< pcl::PCLPointCloud2 >::getMinNeighborsInRadius
double getMinNeighborsInRadius()
Get the minimum number of neighbors that a point needs to have in the given search radius to be consi...
Definition: radius_outlier_removal.h:239
pcl::RadiusOutlierRemoval::applyFilterIndices
void applyFilterIndices(Indices &indices)
Filtered results are indexed by an indices array.
Definition: radius_outlier_removal.hpp:49
pcl::RadiusOutlierRemoval< pcl::PCLPointCloud2 >::min_pts_radius_
int min_pts_radius_
The minimum number of neighbors that a point needs to have in the given search radius to be considere...
Definition: radius_outlier_removal.h:251
pcl::PCLBase
PCL base class.
Definition: pcl_base.h:69
pcl::PCLBase< pcl::PCLPointCloud2 >::PCLPointCloud2ConstPtr
PCLPointCloud2::ConstPtr PCLPointCloud2ConstPtr
Definition: pcl_base.h:186
pcl::PointCloud
PointCloud represents the base class in PCL for storing collections of 3D points.
Definition: distances.h:55
pcl::PointXYZRGB
A point structure representing Euclidean xyz coordinates, and the RGB color.
Definition: point_types.hpp:628
pcl::RadiusOutlierRemoval::setRadiusSearch
void setRadiusSearch(double radius)
Set the radius of the sphere that will determine which points are neighbors.
Definition: radius_outlier_removal.h:103
pcl::RadiusOutlierRemoval::getMinNeighborsInRadius
int getMinNeighborsInRadius()
Get the number of neighbors that need to be present in order to be classified as an inlier.
Definition: radius_outlier_removal.h:136
pcl::PCLBase< pcl::PCLPointCloud2 >::PCLPointCloud2Ptr
PCLPointCloud2::Ptr PCLPointCloud2Ptr
Definition: pcl_base.h:185
pcl::RadiusOutlierRemoval< pcl::PCLPointCloud2 >::setRadiusSearch
void setRadiusSearch(double radius)
Set the sphere radius that is to be used for determining the k-nearest neighbors for filtering.
Definition: radius_outlier_removal.h:213
pcl::PCLPointCloud2::ConstPtr
shared_ptr< const ::pcl::PCLPointCloud2 > ConstPtr
Definition: PCLPointCloud2.h:36
pcl::RadiusOutlierRemoval< pcl::PCLPointCloud2 >::search_radius_
double search_radius_
The nearest neighbors search radius for each point.
Definition: radius_outlier_removal.h:246
pcl::RadiusOutlierRemoval< pcl::PCLPointCloud2 >::getRadiusSearch
double getRadiusSearch()
Get the sphere radius used for determining the k-nearest neighbors.
Definition: radius_outlier_removal.h:220
pcl::Filter::ConstPtr
shared_ptr< const Filter< PointT > > ConstPtr
Definition: filter.h:84
pcl::search::Search::Ptr
shared_ptr< pcl::search::Search< PointT > > Ptr
Definition: search.h:81
pcl::FilterIndices
FilterIndices represents the base class for filters that are about binary point removal.
Definition: filter_indices.h:74
pcl::Filter
Filter represents the base filter class.
Definition: filter.h:80
pcl::Indices
IndicesAllocator<> Indices
Type used for indices in PCL.
Definition: types.h:131
pcl::RadiusOutlierRemoval
RadiusOutlierRemoval filters points in a cloud based on the number of neighbors they have.
Definition: radius_outlier_removal.h:71
pcl::PCLPointCloud2
Definition: PCLPointCloud2.h:16
pcl::RadiusOutlierRemoval< pcl::PCLPointCloud2 >::setMinNeighborsInRadius
void setMinNeighborsInRadius(int min_pts)
Set the minimum number of neighbors that a point needs to have in the given search radius in order to...
Definition: radius_outlier_removal.h:230
pcl::Filter::filter_name_
std::string filter_name_
The filter name.
Definition: filter.h:158
pcl::PointCloud::Ptr
shared_ptr< PointCloud< PointT > > Ptr
Definition: point_cloud.h:407
pcl::RadiusOutlierRemoval::SearcherPtr
typename pcl::search::Search< PointT >::Ptr SearcherPtr
Definition: radius_outlier_removal.h:77
pcl::PointCloud::ConstPtr
shared_ptr< const PointCloud< PointT > > ConstPtr
Definition: point_cloud.h:408
pcl::RadiusOutlierRemoval::applyFilter
void applyFilter(Indices &indices) override
Filtered results are indexed by an indices array.
Definition: radius_outlier_removal.h:156
pcl::RadiusOutlierRemoval< pcl::PCLPointCloud2 >::RadiusOutlierRemoval
RadiusOutlierRemoval(bool extract_removed_indices=false)
Empty constructor.
Definition: radius_outlier_removal.h:202
pcl::RadiusOutlierRemoval::getRadiusSearch
double getRadiusSearch()
Get the radius of the sphere that will determine which points are neighbors.
Definition: radius_outlier_removal.h:114
PCL_EXPORTS
#define PCL_EXPORTS
Definition: pcl_macros.h:323