Point Cloud Library (PCL)  1.9.1
 All Classes Namespaces Functions Variables Typedefs Enumerations Enumerator Friends Modules Pages
kernel.hpp
1 /*
2  * Software License Agreement (BSD License)
3  *
4  * Point Cloud Library (PCL) - www.pointclouds.org
5  * Copyright (c) 2012-, Open Perception, 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  */
37 
38 #ifndef PCL_2D_KERNEL_IMPL_HPP
39 #define PCL_2D_KERNEL_IMPL_HPP
40 
41 //////////////////////////////////////////////////////////////////////////////
42 template <typename PointT> void
44 {
45  switch (kernel_type_)
46  {
47  case SOBEL_X:
48  {
49  sobelKernelX (kernel);
50  break;
51  }
52  case SOBEL_Y:
53  {
54  sobelKernelY (kernel);
55  break;
56  }
57  case PREWITT_X:
58  {
59  prewittKernelX (kernel);
60  break;
61  }
62  case PREWITT_Y:
63  {
64  prewittKernelY (kernel);
65  break;
66  }
67  case ROBERTS_X:
68  {
69  robertsKernelX (kernel);
70  break;
71  }
72  case ROBERTS_Y:
73  {
74  robertsKernelY (kernel);
75  break;
76  }
77  case LOG:
78  {
79  loGKernel (kernel);
80  break;
81  }
82  case DERIVATIVE_CENTRAL_X:
83  {
84  derivativeXCentralKernel (kernel);
85  break;
86  }
87  case DERIVATIVE_FORWARD_X:
88  {
89  derivativeXForwardKernel (kernel);
90  break;
91  }
92  case DERIVATIVE_BACKWARD_X:
93  {
94  derivativeXBackwardKernel (kernel);
95  break;
96  }
97  case DERIVATIVE_CENTRAL_Y:
98  {
99  derivativeYCentralKernel (kernel);
100  break;
101  }
102  case DERIVATIVE_FORWARD_Y:
103  {
104  derivativeYForwardKernel (kernel);
105  break;
106  }
107  case DERIVATIVE_BACKWARD_Y:
108  {
109  derivativeYBackwardKernel (kernel);
110  break;
111  }
112  case GAUSSIAN:
113  {
114  gaussianKernel (kernel);
115  break;
116  }
117  }
118 }
119 
120 //////////////////////////////////////////////////////////////////////////////
121 template <typename PointT> void
123 {
124  float sum = 0;
125  kernel.resize (kernel_size_ * kernel_size_);
126  kernel.height = kernel_size_;
127  kernel.width = kernel_size_;
128 
129  double sigma_sqr = 2 * sigma_ * sigma_;
130 
131  for (int i = 0; i < kernel_size_; i++)
132  {
133  for (int j = 0; j < kernel_size_; j++)
134  {
135  int iks = (i - kernel_size_ / 2);
136  int jks = (j - kernel_size_ / 2);
137  kernel (j, i).intensity = expf (float (- double (iks * iks + jks * jks) / sigma_sqr));
138  sum += float (kernel (j, i).intensity);
139  }
140  }
141 
142  // Normalizing the kernel
143  for (size_t i = 0; i < kernel.size (); ++i)
144  kernel[i].intensity /= sum;
145 }
146 
147 //////////////////////////////////////////////////////////////////////////////
148 template<typename PointT> void
150 {
151  float sum = 0;
152  float temp = 0;
153  kernel.resize (kernel_size_ * kernel_size_);
154  kernel.height = kernel_size_;
155  kernel.width = kernel_size_;
156 
157  double sigma_sqr = 2 * sigma_ * sigma_;
158 
159  for (int i = 0; i < kernel_size_; i++)
160  {
161  for (int j = 0; j < kernel_size_; j++)
162  {
163  int iks = (i - kernel_size_ / 2);
164  int jks = (j - kernel_size_ / 2);
165  temp = float (double (iks * iks + jks * jks) / sigma_sqr);
166  kernel (j, i).intensity = (1.0f - temp) * expf (-temp);
167  sum += kernel (j, i).intensity;
168  }
169  }
170 
171  // Normalizing the kernel
172  for (size_t i = 0; i < kernel.size (); ++i)
173  kernel[i].intensity /= sum;
174 }
175 
176 //////////////////////////////////////////////////////////////////////////////
177 template <typename PointT> void
179 {
180  kernel.resize (9);
181  kernel.height = 3;
182  kernel.width = 3;
183  kernel (0, 0).intensity = -1; kernel (1, 0).intensity = 0; kernel (2, 0).intensity = 1;
184  kernel (0, 1).intensity = -2; kernel (1, 1).intensity = 0; kernel (2, 1).intensity = 2;
185  kernel (0, 2).intensity = -1; kernel (1, 2).intensity = 0; kernel (2, 2).intensity = 1;
186 }
187 
188 //////////////////////////////////////////////////////////////////////////////
189 template <typename PointT> void
191 {
192  kernel.resize (9);
193  kernel.height = 3;
194  kernel.width = 3;
195  kernel (0, 0).intensity = -1; kernel (1, 0).intensity = 0; kernel (2, 0).intensity = 1;
196  kernel (0, 1).intensity = -1; kernel (1, 1).intensity = 0; kernel (2, 1).intensity = 1;
197  kernel (0, 2).intensity = -1; kernel (1, 2).intensity = 0; kernel (2, 2).intensity = 1;
198 }
199 
200 //////////////////////////////////////////////////////////////////////////////
201 template <typename PointT> void
203 {
204  kernel.resize (4);
205  kernel.height = 2;
206  kernel.width = 2;
207  kernel (0, 0).intensity = 1; kernel (1, 0).intensity = 0;
208  kernel (0, 1).intensity = 0; kernel (1, 1).intensity = -1;
209 }
210 
211 //////////////////////////////////////////////////////////////////////////////
212 template <typename PointT> void
214 {
215  kernel.resize (9);
216  kernel.height = 3;
217  kernel.width = 3;
218  kernel (0, 0).intensity = -1; kernel (1, 0).intensity = -2; kernel (2, 0).intensity = -1;
219  kernel (0, 1).intensity = 0; kernel (1, 1).intensity = 0; kernel (2, 1).intensity = 0;
220  kernel (0, 2).intensity = 1; kernel (1, 2).intensity = 2; kernel (2, 2).intensity = 1;
221 }
222 
223 //////////////////////////////////////////////////////////////////////////////
224 template <typename PointT> void
226 {
227  kernel.resize (9);
228  kernel.height = 3;
229  kernel.width = 3;
230  kernel (0, 0).intensity = 1; kernel (1, 0).intensity = 1; kernel (2, 0).intensity = 1;
231  kernel (0, 1).intensity = 0; kernel (1, 1).intensity = 0; kernel (2, 1).intensity = 0;
232  kernel (0, 2).intensity = -1; kernel (1, 2).intensity = -1; kernel (2, 2).intensity = -1;
233 }
234 
235 template <typename PointT> void
237 {
238  kernel.resize (4);
239  kernel.height = 2;
240  kernel.width = 2;
241  kernel (0, 0).intensity = 0; kernel (1, 0).intensity = 1;
242  kernel (0, 1).intensity = -1; kernel (1, 1).intensity = 0;
243 }
244 
245 //////////////////////////////////////////////////////////////////////////////
246 template <typename PointT> void
248 {
249  kernel.resize (3);
250  kernel.height = 1;
251  kernel.width = 3;
252  kernel (0, 0).intensity = -1; kernel (1, 0).intensity = 0; kernel (2, 0).intensity = 1;
253 }
254 
255 //////////////////////////////////////////////////////////////////////////////
256 template <typename PointT> void
258 {
259  kernel.resize (3);
260  kernel.height = 1;
261  kernel.width = 3;
262  kernel (0, 0).intensity = 0; kernel (1, 0).intensity = -1; kernel (2, 0).intensity = 1;
263 }
264 
265 //////////////////////////////////////////////////////////////////////////////
266 template <typename PointT> void
268 {
269  kernel.resize (3);
270  kernel.height = 1;
271  kernel.width = 3;
272  kernel (0, 0).intensity = -1; kernel (1, 0).intensity = 1; kernel (2, 0).intensity = 0;
273 }
274 
275 //////////////////////////////////////////////////////////////////////////////
276 template <typename PointT> void
278 {
279  kernel.resize (3);
280  kernel.height = 3;
281  kernel.width = 1;
282  kernel (0, 0).intensity = -1; kernel (0, 1).intensity = 0; kernel (0, 2).intensity = 1;
283 }
284 
285 //////////////////////////////////////////////////////////////////////////////
286 template <typename PointT> void
288 {
289  kernel.resize (3);
290  kernel.height = 3;
291  kernel.width = 1;
292  kernel (0, 0).intensity = 0; kernel (0, 1).intensity = -1; kernel (0, 2).intensity = 1;
293 }
294 
295 //////////////////////////////////////////////////////////////////////////////
296 template <typename PointT> void
298 {
299  kernel.resize (3);
300  kernel.height = 3;
301  kernel.width = 1;
302  kernel (0, 0).intensity = -1; kernel (0, 1).intensity = 1; kernel (0, 2).intensity = 0;
303 }
304 
305 //////////////////////////////////////////////////////////////////////////////
306 //////////////////////////////////////////////////////////////////////////////
307 template <typename PointT> void
309 {
310  kernel_type_ = kernel_type;
311 }
312 
313 //////////////////////////////////////////////////////////////////////////////
314 template <typename PointT> void
316 {
317  kernel_size_ = kernel_size;
318 }
319 
320 //////////////////////////////////////////////////////////////////////////////
321 template <typename PointT> void
323 {
324  sigma_ = kernel_sigma;
325 }
326 
327 
328 #endif
void setKernelType(KERNEL_ENUM kernel_type)
Definition: kernel.hpp:308
void prewittKernelY(pcl::PointCloud< PointT > &kernel)
Definition: kernel.hpp:225
uint32_t width
The point cloud width (if organized as an image-structure).
Definition: point_cloud.h:413
size_t size() const
Definition: point_cloud.h:448
void prewittKernelX(pcl::PointCloud< PointT > &kernel)
Definition: kernel.hpp:190
void robertsKernelX(pcl::PointCloud< PointT > &kernel)
Definition: kernel.hpp:202
void derivativeYForwardKernel(pcl::PointCloud< PointT > &kernel)
Definition: kernel.hpp:287
void sobelKernelX(pcl::PointCloud< PointT > &kernel)
Definition: kernel.hpp:178
void derivativeYBackwardKernel(PointCloud< PointT > &kernel)
Definition: kernel.hpp:297
void sobelKernelY(pcl::PointCloud< PointT > &kernel)
Definition: kernel.hpp:213
void loGKernel(pcl::PointCloud< PointT > &kernel)
Definition: kernel.hpp:149
void setKernelSigma(float kernel_sigma)
Definition: kernel.hpp:322
KERNEL_ENUM
enumerates the different types of kernels available.
Definition: kernel.h:52
uint32_t height
The point cloud height (if organized as an image-structure).
Definition: point_cloud.h:415
PointCloud represents the base class in PCL for storing collections of 3D points. ...
void fetchKernel(pcl::PointCloud< PointT > &kernel)
Definition: kernel.hpp:43
void gaussianKernel(pcl::PointCloud< PointT > &kernel)
Definition: kernel.hpp:122
void derivativeXForwardKernel(pcl::PointCloud< PointT > &kernel)
Definition: kernel.hpp:257
void derivativeYCentralKernel(pcl::PointCloud< PointT > &kernel)
Definition: kernel.hpp:277
void derivativeXCentralKernel(pcl::PointCloud< PointT > &kernel)
Definition: kernel.hpp:247
void resize(size_t n)
Resize the cloud.
Definition: point_cloud.h:455
void derivativeXBackwardKernel(pcl::PointCloud< PointT > &kernel)
Definition: kernel.hpp:267
void robertsKernelY(pcl::PointCloud< PointT > &kernel)
Definition: kernel.hpp:236
void setKernelSize(int kernel_size)
Definition: kernel.hpp:315