Point Cloud Library (PCL) 1.14.0
Loading...
Searching...
No Matches
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
45namespace 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:
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 {
92 filter_name_ = "RadiusOutlierRemoval";
93 }
94
95 /** \brief Set the radius of the sphere that will determine which points are neighbors.
96 * \details The number of points within this distance from the query point will need to be equal or greater
97 * than setMinNeighborsInRadius() in order to be classified as an inlier point (i.e. will not be filtered).
98 * \param[in] radius The radius of the sphere for nearest neighbor searching.
99 */
100 inline void
101 setRadiusSearch (double radius)
102 {
103 search_radius_ = radius;
104 }
105
106 /** \brief Get the radius of the sphere that will determine which points are neighbors.
107 * \details The number of points within this distance from the query point will need to be equal or greater
108 * than setMinNeighborsInRadius() in order to be classified as an inlier point (i.e. will not be filtered).
109 * \return The radius of the sphere for nearest neighbor searching.
110 */
111 inline double
113 {
114 return (search_radius_);
115 }
116
117 /** \brief Set the number of neighbors that need to be present in order to be classified as an inlier.
118 * \details The number of points within setRadiusSearch() from the query point will need to be equal or greater
119 * than this number in order to be classified as an inlier point (i.e. will not be filtered).
120 * \param min_pts The minimum number of neighbors (default = 1).
121 */
122 inline void
124 {
125 min_pts_radius_ = min_pts;
126 }
127
128 /** \brief Get the number of neighbors that need to be present in order to be classified as an inlier.
129 * \details The number of points within setRadiusSearch() from the query point will need to be equal or greater
130 * than this number in order to be classified as an inlier point (i.e. will not be filtered).
131 * \return The minimum number of neighbors (default = 1).
132 */
133 inline int
135 {
136 return (min_pts_radius_);
137 }
138
139 /** \brief Provide a pointer to the search object.
140 * Calling this is optional. If not called, the search method will be chosen automatically.
141 * \param[in] searcher a pointer to the spatial search object.
142 */
143 inline void
144 setSearchMethod (const SearcherPtr &searcher) { searcher_ = searcher; }
145 protected:
146 using PCLBase<PointT>::input_;
155
156 /** \brief Filtered results are indexed by an indices array.
157 * \param[out] indices The resultant indices.
158 */
159 void
160 applyFilter (Indices &indices) override
161 {
162 applyFilterIndices (indices);
163 }
164
165 /** \brief Filtered results are indexed by an indices array.
166 * \param[out] indices The resultant indices.
167 */
168 void
169 applyFilterIndices (Indices &indices);
170
171 private:
172 /** \brief A pointer to the spatial search object. */
173 SearcherPtr searcher_;
174
175 /** \brief The nearest neighbors search radius for each point. */
176 double search_radius_{0.0};
177
178 /** \brief The minimum number of neighbors that a point needs to have in the given search radius to be considered an inlier. */
179 int min_pts_radius_{1};
180 };
181
182 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
183 /** \brief @b RadiusOutlierRemoval is a simple filter that removes outliers if the number of neighbors in a certain
184 * search radius is smaller than a given K.
185 * \author Radu Bogdan Rusu
186 * \ingroup filters
187 */
188 template<>
189 class PCL_EXPORTS RadiusOutlierRemoval<pcl::PCLPointCloud2> : public FilterIndices<pcl::PCLPointCloud2>
190 {
191 using Filter<pcl::PCLPointCloud2>::filter_name_;
192 using Filter<pcl::PCLPointCloud2>::getClassName;
193
194 using Filter<pcl::PCLPointCloud2>::removed_indices_;
195 using Filter<pcl::PCLPointCloud2>::extract_removed_indices_;
196
199
201 using PCLPointCloud2Ptr = PCLPointCloud2::Ptr;
202 using PCLPointCloud2ConstPtr = PCLPointCloud2::ConstPtr;
203
204 public:
205 /** \brief Empty constructor. */
206 RadiusOutlierRemoval (bool extract_removed_indices = false) :
207 FilterIndices<pcl::PCLPointCloud2>::FilterIndices (extract_removed_indices)
208 {
209 filter_name_ = "RadiusOutlierRemoval";
210 }
211
212 /** \brief Set the sphere radius that is to be used for determining the k-nearest neighbors for filtering.
213 * \param radius the sphere radius that is to contain all k-nearest neighbors
214 */
215 inline void
216 setRadiusSearch (double radius)
217 {
218 search_radius_ = radius;
219 }
220
221 /** \brief Get the sphere radius used for determining the k-nearest neighbors. */
222 inline double
224 {
225 return (search_radius_);
226 }
227
228 /** \brief Set the minimum number of neighbors that a point needs to have in the given search radius in order to
229 * be considered an inlier (i.e., valid).
230 * \param min_pts the minimum number of neighbors
231 */
232 inline void
234 {
235 min_pts_radius_ = min_pts;
236 }
237
238 /** \brief Get the minimum number of neighbors that a point needs to have in the given search radius to be
239 * considered an inlier and avoid being filtered.
240 */
241 inline double
243 {
244 return (min_pts_radius_);
245 }
246
247 protected:
248 /** \brief The nearest neighbors search radius for each point. */
249 double search_radius_{0.0};
250
251 /** \brief The minimum number of neighbors that a point needs to have in the given search radius to be considered
252 * an inlier.
253 */
254 int min_pts_radius_{1};
255
256 /** \brief A pointer to the spatial search object. */
257 KdTreePtr searcher_;
258
259 void
260 applyFilter (PCLPointCloud2 &output) override;
261
262 void
263 applyFilter (Indices &indices) override;
264 };
265}
266
267#ifdef PCL_NO_PRECOMPILE
268#include <pcl/filters/impl/radius_outlier_removal.hpp>
269#endif
Filter represents the base filter class.
Definition filter.h:81
bool extract_removed_indices_
Set to true if we want to return the indices of the removed points.
Definition filter.h:161
const std::string & getClassName() const
Get a string representation of the name of this class.
Definition filter.h:174
std::string filter_name_
The filter name.
Definition filter.h:158
IndicesPtr removed_indices_
Indices of the points that are removed.
Definition filter.h:155
FilterIndices represents the base class for filters that are about binary point removal.
float user_filter_value_
The user given value that the filtered point dimensions should be set to (default = NaN).
bool keep_organized_
False = remove points (default), true = redefine points, keep structure.
bool negative_
False = normal filter behavior (default), true = inverted behavior.
PCL base class.
Definition pcl_base.h:70
PointCloudConstPtr input_
The input point cloud dataset.
Definition pcl_base.h:147
IndicesPtr indices_
A pointer to the vector of point indices to use.
Definition pcl_base.h:150
PointCloud represents the base class in PCL for storing collections of 3D points.
shared_ptr< PointCloud< PointT > > Ptr
shared_ptr< const PointCloud< PointT > > ConstPtr
void applyFilter(Indices &indices) override
Abstract filter method for point cloud indices.
double getRadiusSearch()
Get the sphere radius used for determining the k-nearest neighbors.
double getMinNeighborsInRadius()
Get the minimum number of neighbors that a point needs to have in the given search radius to be consi...
void setRadiusSearch(double radius)
Set the sphere radius that is to be used for determining the k-nearest neighbors for filtering.
KdTreePtr searcher_
A pointer to the spatial search object.
RadiusOutlierRemoval(bool extract_removed_indices=false)
Empty constructor.
void applyFilter(PCLPointCloud2 &output) override
Abstract filter method for point cloud.
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...
RadiusOutlierRemoval filters points in a cloud based on the number of neighbors they have.
void applyFilterIndices(Indices &indices)
Filtered results are indexed by an indices array.
int getMinNeighborsInRadius()
Get the number of neighbors that need to be present in order to be classified as an inlier.
void applyFilter(Indices &indices) override
Filtered results are indexed by an indices array.
typename PointCloud::Ptr PointCloudPtr
void setMinNeighborsInRadius(int min_pts)
Set the number of neighbors that need to be present in order to be classified as an inlier.
typename PointCloud::ConstPtr PointCloudConstPtr
void setRadiusSearch(double radius)
Set the radius of the sphere that will determine which points are neighbors.
shared_ptr< RadiusOutlierRemoval< PointT > > Ptr
RadiusOutlierRemoval(bool extract_removed_indices=false)
Constructor.
shared_ptr< const RadiusOutlierRemoval< PointT > > ConstPtr
typename pcl::search::Search< PointT >::Ptr SearcherPtr
typename FilterIndices< PointT >::PointCloud PointCloud
double getRadiusSearch()
Get the radius of the sphere that will determine which points are neighbors.
void setSearchMethod(const SearcherPtr &searcher)
Provide a pointer to the search object.
shared_ptr< pcl::search::Search< PointT > > Ptr
Definition search.h:81
IndicesAllocator<> Indices
Type used for indices in PCL.
Definition types.h:133
shared_ptr< ::pcl::PCLPointCloud2 > Ptr
shared_ptr< const ::pcl::PCLPointCloud2 > ConstPtr
A point structure representing Euclidean xyz coordinates, and the RGB color.