Point Cloud Library (PCL)  1.6.0
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
point_operators.h
Go to the documentation of this file.
1 /*
2  * Software License Agreement (BSD License)
3  *
4  * Point Cloud Library (PCL) - www.pointclouds.org
5  * Copyright (c) 2010-2011, 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 Willow Garage, Inc. 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: point_operators.h 5355 2012-03-27 23:52:01Z nizar $
37  *
38  */
39 
40 #ifndef PCL_COMMON_POINT_OPERATORS_H
41 #define PCL_COMMON_POINT_OPERATORS_H
42 
43 #include <pcl/point_types.h>
44 
45 namespace pcl
46 {
47  namespace common
48  {
53  template <typename PointT> inline PointT
55  operator+ (const PointT& lhs, const PointT& rhs)
56  {
57  PointT result = lhs;
58  result.getVector3fMap () += rhs.getVector3fMap ();
59  return (result);
60  }
62  template <typename PointT> inline PointT
63  operator- (const PointT& lhs, const PointT& rhs)
64  {
65  PointT result = lhs;
66  result.getVector3fMap () -= rhs.getVector3fMap ();
67  return (result);
68  }
70  template <typename PointT> inline PointT
71  operator* (const float& scalar, const PointT& p)
72  {
73  PointT result = p;
74  result.getVector3fMap () *= scalar;
75  return (result);
76  }
78  template <typename PointT> inline PointT
79  operator* (const PointT& p, const float& scalar)
80  {
81  PointT result = p;
82  result.getVector3fMap () *= scalar;
83  return (result);
84  }
86  template <typename PointT> inline PointT
87  operator/ (const float& scalar, const PointT& p)
88  {
89  PointT result = p;
90  result.getVector3fMap () /= scalar;
91  return (result);
92  }
94  template <typename PointT> inline PointT
95  operator/ (const PointT& p, const float& scalar)
96  {
97  PointT result = p;
98  result.getVector3fMap () /= scalar;
99  return (result);
100  }
102  template <typename PointT> inline PointT&
103  operator+= (PointT& lhs, const PointT& rhs)
104  {
105  lhs.getVector3fMap () += rhs.getVector3fMap ();
106  return (lhs);
107  }
109  template <typename PointT> inline PointT&
110  operator-= (PointT& lhs, const PointT& rhs)
111  {
112  lhs.getVector3fMap () -= rhs.getVector3fMap ();
113  return (lhs);
114  }
116  template <typename PointT> inline PointT&
117  operator*= (PointT& p, const float& scalar)
118  {
119  p.getVector3fMap () *= scalar;
120  return (PointT ());
121  }
123  template <typename PointT> inline PointT&
124  operator/= (PointT& p, const float& scalar)
125  {
126  p.getVector3fMap () /= scalar;
127  return (p);
128  }
129 
131  template <> inline pcl::PointXYZI
132  operator+ (const pcl::PointXYZI& lhs, const pcl::PointXYZI& rhs)
133  {
134  pcl::PointXYZI result = lhs;
135  result.getVector3fMap () += rhs.getVector3fMap ();
136  result.intensity += rhs.intensity;
137  return (result);
138  }
140  template <> inline pcl::PointXYZI
141  operator- (const pcl::PointXYZI& lhs, const pcl::PointXYZI& rhs)
142  {
143  pcl::PointXYZI result = lhs;
144  result.getVector3fMap () -= rhs.getVector3fMap ();
145  result.intensity -= rhs.intensity;
146  return (result);
147  }
149  template <> inline pcl::PointXYZI
150  operator* (const float& scalar, const pcl::PointXYZI& p)
151  {
152  pcl::PointXYZI result = p;
153  result.getVector3fMap () *= scalar;
154  result.intensity *= scalar;
155  return (result);
156  }
158  template <> inline pcl::PointXYZI
159  operator* (const pcl::PointXYZI& p, const float& scalar)
160  {
161  pcl::PointXYZI result = p;
162  result.getVector3fMap () *= scalar;
163  result.intensity *= scalar;
164  return (result);
165  }
167  template <> inline pcl::PointXYZI&
168  operator+= (pcl::PointXYZI& lhs, const pcl::PointXYZI& rhs)
169  {
170  lhs.getVector3fMap () += rhs.getVector3fMap ();
171  lhs.intensity += rhs.intensity;
172  return (lhs);
173  }
175  template <> inline pcl::PointXYZI&
176  operator-= (pcl::PointXYZI& lhs, const pcl::PointXYZI& rhs)
177  {
178  lhs.getVector3fMap () -= rhs.getVector3fMap ();
179  lhs.intensity -= rhs.intensity;
180  return (lhs);
181  }
183  template <> inline pcl::PointXYZI&
184  operator*= (pcl::PointXYZI& lhs, const float& scalar)
185  {
186  lhs.getVector3fMap () *= scalar;
187  lhs.intensity *= scalar;
188  return (lhs);
189  }
190  template <> inline pcl::PointXYZINormal
191  operator+ (const pcl::PointXYZINormal& lhs, const pcl::PointXYZINormal& rhs)
192  {
193  pcl::PointXYZINormal result = lhs;
194  result.getVector3fMap () += rhs.getVector3fMap ();
195  result.getNormalVector3fMap () += rhs.getNormalVector3fMap ();
196  result.intensity += rhs.intensity;
197  result.curvature += rhs.curvature;
198  return (result);
199  }
200 
201  template <> inline pcl::PointXYZINormal
202  operator- (const pcl::PointXYZINormal& lhs, const pcl::PointXYZINormal& rhs)
203  {
204  pcl::PointXYZINormal result = lhs;
205  result.getVector3fMap () -= rhs.getVector3fMap ();
206  result.getNormalVector3fMap () -= rhs.getNormalVector3fMap ();
207  result.intensity -= rhs.intensity;
208  result.curvature -= rhs.curvature;
209  return (result);
210  }
211 
212  template <> inline pcl::PointXYZINormal&
213  operator+= (pcl::PointXYZINormal& lhs, const pcl::PointXYZINormal& rhs)
214  {
215  lhs.getVector3fMap () += rhs.getVector3fMap ();
216  lhs.getNormalVector3fMap () += rhs.getNormalVector3fMap ();
217  lhs.intensity += rhs.intensity;
218  lhs.curvature += rhs.curvature;
219  return (lhs);
220  }
221 
222  template <> inline pcl::PointXYZINormal&
223  operator-= (pcl::PointXYZINormal& lhs, const pcl::PointXYZINormal& rhs)
224  {
225  lhs.getVector3fMap () -= rhs.getVector3fMap ();
226  lhs.getNormalVector3fMap () -= rhs.getNormalVector3fMap ();
227  lhs.intensity-= rhs.intensity;
228  lhs.curvature-= rhs.curvature;
229  return (lhs);
230  }
231 
232  template <> inline pcl::PointXYZINormal&
233  operator*= (pcl::PointXYZINormal& lhs, const float& scalar)
234  {
235  lhs.getVector3fMap () *= scalar;
236  lhs.getNormalVector3fMap () *= scalar;
237  lhs.intensity *= scalar;
238  lhs.curvature *= scalar;
239  return (lhs);
240  }
241 
242  template <> inline pcl::PointXYZINormal
243  operator* (const float& scalar, const pcl::PointXYZINormal& p)
244  {
245  pcl::PointXYZINormal result = p;
246  result.getVector3fMap () *= scalar;
247  result.getNormalVector3fMap () *= scalar;
248  result.intensity *= scalar;
249  result.curvature *= scalar;
250  return (result);
251  }
252 
253  template <> inline pcl::PointXYZINormal
254  operator* (const pcl::PointXYZINormal& p, const float& scalar)
255  {
256  return (operator* (scalar, p));
257  }
258 
260  template <> inline pcl::Normal
261  operator+ (const pcl::Normal& lhs, const pcl::Normal& rhs)
262  {
263  pcl::Normal result = lhs;
264  result.getNormalVector3fMap () += rhs.getNormalVector3fMap ();
265  result.curvature += rhs.curvature;
266  return (result);
267  }
269  template <> inline pcl::Normal
270  operator- (const pcl::Normal& lhs, const pcl::Normal& rhs)
271  {
272  pcl::Normal result = lhs;
273  result.getNormalVector3fMap () -= rhs.getNormalVector3fMap ();
274  result.curvature -= rhs.curvature;
275  return (result);
276  }
278  template <> inline pcl::Normal
279  operator* (const float& scalar, const pcl::Normal& p)
280  {
281  pcl::Normal result = p;
282  result.getNormalVector3fMap () *= scalar;
283  result.curvature *= scalar;
284  return (result);
285  }
287  template <> inline pcl::Normal
288  operator* (const pcl::Normal& p, const float& scalar)
289  {
290  pcl::Normal result = p;
291  result.getNormalVector3fMap () *= scalar;
292  result.curvature *= scalar;
293  return (result);
294  }
296  template <> inline pcl::Normal&
297  operator+= (pcl::Normal& lhs, const pcl::Normal& rhs)
298  {
299  lhs.getNormalVector3fMap () += rhs.getNormalVector3fMap ();
300  lhs.curvature += rhs.curvature;
301  return (lhs);
302  }
304  template <> inline pcl::Normal&
305  operator-= (pcl::Normal& lhs, const pcl::Normal& rhs)
306  {
307  lhs.getNormalVector3fMap () -= rhs.getNormalVector3fMap ();
308  lhs.curvature -= rhs.curvature;
309  return (lhs);
310  }
312  template <> inline pcl::Normal&
313  operator*= (pcl::Normal& lhs, const float& scalar)
314  {
315  lhs.getNormalVector3fMap () *= scalar;
316  lhs.curvature *= scalar;
317  return (lhs);
318  }
319 
321  template <> inline pcl::PointXYZRGB
322  operator+ (const pcl::PointXYZRGB& lhs, const pcl::PointXYZRGB& rhs)
323  {
324  pcl::PointXYZRGB result;
325  result.getVector3fMap () = lhs.getVector3fMap ();
326  result.getVector3fMap () += rhs.getVector3fMap ();
327  result.r = static_cast<uint8_t> (lhs.r + rhs.r);
328  result.g = static_cast<uint8_t> (lhs.g + rhs.g);
329  result.b = static_cast<uint8_t> (lhs.b + rhs.b);
330  return (result);
331  }
333  template <> inline pcl::PointXYZRGB
334  operator- (const pcl::PointXYZRGB& lhs, const pcl::PointXYZRGB& rhs)
335  {
336  pcl::PointXYZRGB result;
337  result.getVector3fMap () = lhs.getVector3fMap ();
338  result.getVector3fMap () -= rhs.getVector3fMap ();
339  result.r = static_cast<uint8_t> (lhs.r - rhs.r);
340  result.g = static_cast<uint8_t> (lhs.g - rhs.g);
341  result.b = static_cast<uint8_t> (lhs.b - rhs.b);
342  return (result);
343  }
344 
345  template <> inline pcl::PointXYZRGB
346  operator* (const float& scalar, const pcl::PointXYZRGB& p)
347  {
348  pcl::PointXYZRGB result;
349  result.getVector3fMap () = p.getVector3fMap ();
350  result.getVector3fMap () *= scalar;
351  result.r = static_cast<uint8_t> (scalar * p.r);
352  result.g = static_cast<uint8_t> (scalar * p.g);
353  result.b = static_cast<uint8_t> (scalar * p.b);
354  return (result);
355  }
356 
357  template <> inline pcl::PointXYZRGB
358  operator* (const pcl::PointXYZRGB& p, const float& scalar)
359  {
360  pcl::PointXYZRGB result;
361  result.getVector3fMap () = p.getVector3fMap ();
362  result.getVector3fMap () *= scalar;
363  result.r = static_cast<uint8_t> (scalar * p.r);
364  result.g = static_cast<uint8_t> (scalar * p.g);
365  result.b = static_cast<uint8_t> (scalar * p.b);
366  return (result);
367  }
368 
369  template <> inline pcl::PointXYZRGB&
370  operator+= (pcl::PointXYZRGB& lhs, const pcl::PointXYZRGB& rhs)
371  {
372  lhs.getVector3fMap () += rhs.getVector3fMap ();
373  lhs.r = static_cast<uint8_t> (lhs.r + rhs.r);
374  lhs.g = static_cast<uint8_t> (lhs.g + rhs.g);
375  lhs.b = static_cast<uint8_t> (lhs.b + rhs.b);
376  return (lhs);
377  }
378 
379  template <> inline pcl::PointXYZRGB&
380  operator-= (pcl::PointXYZRGB& lhs, const pcl::PointXYZRGB& rhs)
381  {
382  lhs.getVector3fMap () -= rhs.getVector3fMap ();
383  lhs.r = static_cast<uint8_t> (lhs.r - rhs.r);
384  lhs.g = static_cast<uint8_t> (lhs.g - rhs.g);
385  lhs.b = static_cast<uint8_t> (lhs.b - rhs.b);
386  return (lhs);
387  }
388 
389  template <> inline pcl::PointXYZRGB&
390  operator*= (pcl::PointXYZRGB& lhs, const float& scalar)
391  {
392  lhs.getVector3fMap () *= scalar;
393  lhs.r = static_cast<uint8_t> (lhs.r * scalar);
394  lhs.g = static_cast<uint8_t> (lhs.g * scalar);
395  lhs.b = static_cast<uint8_t> (lhs.b * scalar);
396  return (lhs);
397  }
398 
400  template <> inline pcl::PointXYZRGBA
401  operator+ (const pcl::PointXYZRGBA& lhs, const pcl::PointXYZRGBA& rhs)
402  {
403  pcl::PointXYZRGBA result;
404  result.getVector3fMap () = lhs.getVector3fMap ();
405  result.getVector3fMap () += rhs.getVector3fMap ();
406  result.r = static_cast<uint8_t> (lhs.r + rhs.r);
407  result.g = static_cast<uint8_t> (lhs.g + rhs.g);
408  result.b = static_cast<uint8_t> (lhs.b + rhs.b);
409  return (result);
410  }
412  template <> inline pcl::PointXYZRGBA
413  operator- (const pcl::PointXYZRGBA& lhs, const pcl::PointXYZRGBA& rhs)
414  {
415  pcl::PointXYZRGBA result;
416  result.getVector3fMap () = lhs.getVector3fMap ();
417  result.getVector3fMap () -= rhs.getVector3fMap ();
418  result.r = static_cast<uint8_t> (lhs.r - rhs.r);
419  result.g = static_cast<uint8_t> (lhs.g - rhs.g);
420  result.b = static_cast<uint8_t> (lhs.b - rhs.b);
421  return (result);
422  }
423 
424  template <> inline pcl::PointXYZRGBA
425  operator* (const float& scalar, const pcl::PointXYZRGBA& p)
426  {
427  pcl::PointXYZRGBA result;
428  result.getVector3fMap () = p.getVector3fMap ();
429  result.getVector3fMap () *= scalar;
430  result.r = static_cast<uint8_t> (scalar * p.r);
431  result.g = static_cast<uint8_t> (scalar * p.g);
432  result.b = static_cast<uint8_t> (scalar * p.b);
433  return (result);
434  }
435 
436  template <> inline pcl::PointXYZRGBA
437  operator* (const pcl::PointXYZRGBA& p, const float& scalar)
438  {
439  pcl::PointXYZRGBA result;
440  result.getVector3fMap () = p.getVector3fMap ();
441  result.getVector3fMap () *= scalar;
442  result.r = static_cast<uint8_t> (scalar * p.r);
443  result.g = static_cast<uint8_t> (scalar * p.g);
444  result.b = static_cast<uint8_t> (scalar * p.b);
445  return (result);
446  }
447 
448  template <> inline pcl::PointXYZRGBA&
449  operator+= (pcl::PointXYZRGBA& lhs, const pcl::PointXYZRGBA& rhs)
450  {
451  lhs.getVector3fMap () += rhs.getVector3fMap ();
452  lhs.r = static_cast<uint8_t> (lhs.r + rhs.r);
453  lhs.g = static_cast<uint8_t> (lhs.g + rhs.g);
454  lhs.b = static_cast<uint8_t> (lhs.b + rhs.b);
455  return (lhs);
456  }
457 
458  template <> inline pcl::PointXYZRGBA&
459  operator-= (pcl::PointXYZRGBA& lhs, const pcl::PointXYZRGBA& rhs)
460  {
461  lhs.getVector3fMap () -= rhs.getVector3fMap ();
462  lhs.r = static_cast<uint8_t> (lhs.r - rhs.r);
463  lhs.g = static_cast<uint8_t> (lhs.g - rhs.g);
464  lhs.b = static_cast<uint8_t> (lhs.b - rhs.b);
465  return (lhs);
466  }
467 
468  template <> inline pcl::PointXYZRGBA&
469  operator*= (pcl::PointXYZRGBA& lhs, const float& scalar)
470  {
471  lhs.getVector3fMap () *= scalar;
472  lhs.r = static_cast<uint8_t> (lhs.r * scalar);
473  lhs.g = static_cast<uint8_t> (lhs.g * scalar);
474  lhs.b = static_cast<uint8_t> (lhs.b * scalar);
475  return (lhs);
476  }
477 
479  template <> inline pcl::RGB
480  operator+ (const pcl::RGB& lhs, const pcl::RGB& rhs)
481  {
482  pcl::RGB result;
483  result.r = static_cast<uint8_t> (lhs.r + rhs.r);
484  result.g = static_cast<uint8_t> (lhs.g + rhs.g);
485  result.b = static_cast<uint8_t> (lhs.b + rhs.b);
486  return (result);
487  }
489  template <> inline pcl::RGB
490  operator- (const pcl::RGB& lhs, const pcl::RGB& rhs)
491  {
492  pcl::RGB result;
493  result.r = static_cast<uint8_t> (lhs.r - rhs.r);
494  result.g = static_cast<uint8_t> (lhs.g - rhs.g);
495  result.b = static_cast<uint8_t> (lhs.b - rhs.b);
496  return (result);
497  }
498 
499  template <> inline pcl::RGB
500  operator* (const float& scalar, const pcl::RGB& p)
501  {
502  pcl::RGB result;
503  result.r = static_cast<uint8_t> (scalar * p.r);
504  result.g = static_cast<uint8_t> (scalar * p.g);
505  result.b = static_cast<uint8_t> (scalar * p.b);
506  return (result);
507  }
508 
509  template <> inline pcl::RGB
510  operator* (const pcl::RGB& p, const float& scalar)
511  {
512  pcl::RGB result;
513  result.r = static_cast<uint8_t> (scalar * p.r);
514  result.g = static_cast<uint8_t> (scalar * p.g);
515  result.b = static_cast<uint8_t> (scalar * p.b);
516  return (result);
517  }
518 
519  template <> inline pcl::RGB&
520  operator+= (pcl::RGB& lhs, const pcl::RGB& rhs)
521  {
522  lhs.r = static_cast<uint8_t> (lhs.r + rhs.r);
523  lhs.g = static_cast<uint8_t> (lhs.g + rhs.g);
524  lhs.b = static_cast<uint8_t> (lhs.b + rhs.b);
525  return (lhs);
526  }
527 
528  template <> inline pcl::RGB&
529  operator-= (pcl::RGB& lhs, const pcl::RGB& rhs)
530  {
531  lhs.r = static_cast<uint8_t> (lhs.r - rhs.r);
532  lhs.g = static_cast<uint8_t> (lhs.g - rhs.g);
533  lhs.b = static_cast<uint8_t> (lhs.b - rhs.b);
534  return (lhs);
535  }
536 
537  template <> inline pcl::RGB&
538  operator*= (pcl::RGB& lhs, const float& scalar)
539  {
540  lhs.r = static_cast<uint8_t> (lhs.r * scalar);
541  lhs.g = static_cast<uint8_t> (lhs.g * scalar);
542  lhs.b = static_cast<uint8_t> (lhs.b * scalar);
543  return (lhs);
544  }
545  }
546 }
547 
548 #endif
Generated on Sat Aug 24 2013 17:28:27 for Point Cloud Library (PCL) by   doxygen 1.8.4