Point Cloud Library (PCL) 1.15.0
Loading...
Searching...
No Matches
convolution_3d.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/pcl_base.h>
43#include <pcl/search/search.h> // for pcl::search::Search
44#include <boost/optional.hpp>
45#include <pcl/search/search.h>
46
47namespace pcl
48{
49 namespace filters
50 {
51 /** \brief Class ConvolvingKernel base class for all convolving kernels
52 * \ingroup filters
53 */
54 template<typename PointInT, typename PointOutT>
56 {
57 public:
58 using Ptr = shared_ptr<ConvolvingKernel<PointInT, PointOutT> >;
59 using ConstPtr = shared_ptr<const ConvolvingKernel<PointInT, PointOutT> >;
60
62
63 /// \brief empty constructor
65
66 /// \brief empty destructor
67 virtual ~ConvolvingKernel() = default;
68
69 /** \brief Set input cloud
70 * \param[in] input source point cloud
71 */
72 void
73 setInputCloud (const PointCloudInConstPtr& input) { input_ = input; }
74
75 /** \brief Convolve point at the center of this local information
76 * \param[in] indices indices of the point in the source point cloud
77 * \param[in] distances euclidean distance squared from the query point
78 * \return the convolved point
79 */
80 virtual PointOutT
81 operator() (const Indices& indices, const std::vector<float>& distances) = 0;
82
83 /** \brief Must call this method before doing any computation
84 * \note make sure to override this with at least
85 * \code
86 * bool initCompute ()
87 * {
88 * return (true);
89 * }
90 * \endcode
91 * in your kernel interface, else you are going nowhere!
92 */
93 virtual bool
94 initCompute () { return false; }
95
96 /** \brief Utility function that annihilates a point making it fail the \ref pcl::isFinite test
97 * \param p point to annihilate
98 */
99 static void
100 makeInfinite (PointOutT& p)
101 {
102 p.x = p.y = p.z = std::numeric_limits<float>::quiet_NaN ();
103 }
104
105 protected:
106 /// source cloud
108 };
109
110 /** \brief Gaussian kernel implementation interface
111 * Use this as implementation reference
112 * \ingroup filters
113 */
114 template<typename PointInT, typename PointOutT>
115 class GaussianKernel : public ConvolvingKernel <PointInT, PointOutT>
116 {
117 public:
118 using ConvolvingKernel<PointInT, PointOutT>::initCompute;
119 using ConvolvingKernel<PointInT, PointOutT>::input_;
120 using ConvolvingKernel<PointInT, PointOutT>::operator ();
121 using ConvolvingKernel<PointInT, PointOutT>::makeInfinite;
122 using Ptr = shared_ptr<GaussianKernel<PointInT, PointOutT> >;
123 using ConstPtr = shared_ptr<GaussianKernel<PointInT, PointOutT> >;
124
125 /** Default constructor */
127 : ConvolvingKernel <PointInT, PointOutT> ()
128 , sigma_ (0)
129 , threshold_ (std::numeric_limits<float>::infinity ())
130 {}
131
132 /** Set the sigma parameter of the Gaussian
133 * \param[in] sigma
134 */
135 inline void
136 setSigma (float sigma) { sigma_ = sigma; }
137
138 /** Set the distance threshold relative to a sigma factor i.e. points such as
139 * ||pi - q|| > sigma_coefficient^2 * sigma^2 are not considered.
140 */
141 inline void
142 setThresholdRelativeToSigma (float sigma_coefficient)
143 {
144 sigma_coefficient_.reset (sigma_coefficient);
145 }
146
147 /** Set the distance threshold such as pi, ||pi - q|| > threshold are not considered. */
148 inline void
149 setThreshold (float threshold) { threshold_ = threshold; }
150
151 /** Must call this method before doing any computation */
152 bool initCompute ();
153
154 virtual PointOutT
155 operator() (const Indices& indices, const std::vector<float>& distances);
156
157 protected:
158 float sigma_;
161 boost::optional<float> sigma_coefficient_;
162 };
163
164 /** \brief Gaussian kernel implementation interface with RGB channel handling
165 * Use this as implementation reference
166 * \ingroup filters
167 */
168 template<typename PointInT, typename PointOutT>
169 class GaussianKernelRGB : public GaussianKernel <PointInT, PointOutT>
170 {
171 public:
172 using GaussianKernel<PointInT, PointOutT>::initCompute;
173 using GaussianKernel<PointInT, PointOutT>::input_;
174 using GaussianKernel<PointInT, PointOutT>::operator ();
175 using GaussianKernel<PointInT, PointOutT>::makeInfinite;
176 using GaussianKernel<PointInT, PointOutT>::sigma_sqr_;
177 using GaussianKernel<PointInT, PointOutT>::threshold_;
178 using Ptr = shared_ptr<GaussianKernelRGB<PointInT, PointOutT> >;
179 using ConstPtr = shared_ptr<GaussianKernelRGB<PointInT, PointOutT> >;
180
181 /** Default constructor */
183 : GaussianKernel <PointInT, PointOutT> ()
184 {}
185
186 PointOutT
187 operator() (const Indices& indices, const std::vector<float>& distances);
188 };
189
190 /** Convolution3D handles the non organized case where width and height are unknown or if you
191 * are only interested in convolving based on local neighborhood information.
192 * The convolving kernel MUST be a radial symmetric and implement \ref ConvolvingKernel
193 * interface.
194 */
195 template <typename PointIn, typename PointOut, typename KernelT>
196 class Convolution3D : public pcl::PCLBase <PointIn>
197 {
198 public:
200 using PointCloudInConstPtr = typename PointCloudIn::ConstPtr;
202 using KdTreePtr = typename KdTree::Ptr;
204 using Ptr = shared_ptr<Convolution3D<PointIn, PointOut, KernelT> >;
205 using ConstPtr = shared_ptr<Convolution3D<PointIn, PointOut, KernelT> >;
206
207 using pcl::PCLBase<PointIn>::indices_;
208 using pcl::PCLBase<PointIn>::input_;
209
210 /** \brief Constructor */
211 Convolution3D ();
212
213 /** \brief Initialize the scheduler and set the number of threads to use.
214 * \param nr_threads the number of hardware threads to use (0 sets the value back to automatic)
215 */
216 inline void
217 setNumberOfThreads (unsigned int nr_threads = 0) { threads_ = nr_threads; }
218
219 /** \brief Set convolving kernel
220 * \param[in] kernel convolving element
221 */
222 inline void
223 setKernel (const KernelT& kernel) { kernel_ = kernel; }
224
225 /** \brief Provide a pointer to the input dataset that we need to estimate features at every point for.
226 * \param cloud the const boost shared pointer to a PointCloud message
227 */
228 inline void
230
231 /** \brief Get a pointer to the surface point cloud dataset. */
233 getSearchSurface () { return (surface_); }
234
235 /** \brief Provide a pointer to the search object.
236 * \param tree a pointer to the spatial search object.
237 */
238 inline void
239 setSearchMethod (const KdTreePtr &tree) { tree_ = tree; }
240
241 /** \brief Get a pointer to the search method used. */
242 inline KdTreePtr
243 getSearchMethod () { return (tree_); }
244
245 /** \brief Set the sphere radius that is to be used for determining the nearest neighbors
246 * \param radius the sphere radius used as the maximum distance to consider a point a neighbor
247 */
248 inline void
249 setRadiusSearch (double radius) { search_radius_ = radius; }
250
251 /** \brief Get the sphere radius used for determining the neighbors. */
252 inline double
254
255 /** Convolve point cloud.
256 * \param[out] output the convolved cloud
257 */
258 void
259 convolve (PointCloudOut& output);
260
261 protected:
262 /** \brief initialize computation */
263 bool initCompute ();
264
265 /** \brief An input point cloud describing the surface that is to be used for nearest neighbors estimation. */
267
268 /** \brief A pointer to the spatial search object. */
270
271 /** \brief The nearest neighbors search radius for each point. */
273
274 /** \brief number of threads */
275 unsigned int threads_{1};
276
277 /** \brief convlving kernel */
278 KernelT kernel_;
279 };
280 }
281}
282
283#include <pcl/filters/impl/convolution_3d.hpp>
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< const PointCloud< PointT > > ConstPtr
Convolution3D handles the non organized case where width and height are unknown or if you are only in...
KdTreePtr getSearchMethod()
Get a pointer to the search method used.
void setKernel(const KernelT &kernel)
Set convolving kernel.
pcl::PointCloud< PointIn > PointCloudIn
bool initCompute()
initialize computation
typename KdTree::Ptr KdTreePtr
KernelT kernel_
convlving kernel
double getRadiusSearch()
Get the sphere radius used for determining the neighbors.
void setNumberOfThreads(unsigned int nr_threads=0)
Initialize the scheduler and set the number of threads to use.
void setSearchSurface(const PointCloudInConstPtr &cloud)
Provide a pointer to the input dataset that we need to estimate features at every point for.
typename PointCloudIn::ConstPtr PointCloudInConstPtr
void setRadiusSearch(double radius)
Set the sphere radius that is to be used for determining the nearest neighbors.
KdTreePtr tree_
A pointer to the spatial search object.
PointCloudInConstPtr surface_
An input point cloud describing the surface that is to be used for nearest neighbors estimation.
unsigned int threads_
number of threads
shared_ptr< Convolution3D< PointIn, PointOut, KernelT > > Ptr
void setSearchMethod(const KdTreePtr &tree)
Provide a pointer to the search object.
void convolve(PointCloudOut &output)
Convolve point cloud.
pcl::PointCloud< PointOut > PointCloudOut
PointCloudInConstPtr getSearchSurface()
Get a pointer to the surface point cloud dataset.
shared_ptr< Convolution3D< PointIn, PointOut, KernelT > > ConstPtr
double search_radius_
The nearest neighbors search radius for each point.
Class ConvolvingKernel base class for all convolving kernels.
shared_ptr< ConvolvingKernel< PointInT, PointOutT > > Ptr
virtual PointOutT operator()(const Indices &indices, const std::vector< float > &distances)=0
Convolve point at the center of this local information.
ConvolvingKernel()
empty constructor
static void makeInfinite(PointOutT &p)
Utility function that annihilates a point making it fail the pcl::isFinite test.
PointCloudInConstPtr input_
source cloud
shared_ptr< const ConvolvingKernel< PointInT, PointOutT > > ConstPtr
typename PointCloud< PointInT >::ConstPtr PointCloudInConstPtr
void setInputCloud(const PointCloudInConstPtr &input)
Set input cloud.
virtual ~ConvolvingKernel()=default
empty destructor
virtual bool initCompute()
Must call this method before doing any computation.
Gaussian kernel implementation interface Use this as implementation reference.
shared_ptr< GaussianKernel< PointInT, PointOutT > > Ptr
void setThresholdRelativeToSigma(float sigma_coefficient)
Set the distance threshold relative to a sigma factor i.e.
shared_ptr< GaussianKernel< PointInT, PointOutT > > ConstPtr
boost::optional< float > sigma_coefficient_
virtual PointOutT operator()(const Indices &indices, const std::vector< float > &distances)
Convolve point at the center of this local information.
void setSigma(float sigma)
Set the sigma parameter of the Gaussian.
bool initCompute()
Must call this method before doing any computation.
GaussianKernel()
Default constructor.
void setThreshold(float threshold)
Set the distance threshold such as pi, ||pi - q|| > threshold are not considered.
Gaussian kernel implementation interface with RGB channel handling Use this as implementation referen...
shared_ptr< GaussianKernelRGB< PointInT, PointOutT > > ConstPtr
PointOutT operator()(const Indices &indices, const std::vector< float > &distances)
Convolve point at the center of this local information.
GaussianKernelRGB()
Default constructor.
shared_ptr< GaussianKernelRGB< PointInT, PointOutT > > Ptr
Generic search class.
Definition search.h:75
shared_ptr< pcl::search::Search< PointT > > Ptr
Definition search.h:81
IndicesAllocator<> Indices
Type used for indices in PCL.
Definition types.h:133