Point Cloud Library (PCL) 1.12.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 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:
142 using PCLBase<PointT>::input_;
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 {
187 using Filter<pcl::PCLPointCloud2>::filter_name_;
188 using Filter<pcl::PCLPointCloud2>::getClassName;
189
190 using Filter<pcl::PCLPointCloud2>::removed_indices_;
191 using Filter<pcl::PCLPointCloud2>::extract_removed_indices_;
192
195
197 using PCLPointCloud2Ptr = PCLPointCloud2::Ptr;
198 using PCLPointCloud2ConstPtr = PCLPointCloud2::ConstPtr;
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
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.
double search_radius_
The nearest neighbors search radius for each point.
int min_pts_radius_
The minimum number of neighbors that a point needs to have in the given search radius to be considere...
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.
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.