|
Point Cloud Library (PCL)
1.6.0
|
|
Point Cloud Library (PCL)
1.6.0
|
00001 /* 00002 * Software License Agreement (BSD License) 00003 * 00004 * Point Cloud Library (PCL) - www.pointclouds.org 00005 * Copyright (c) 2010-2011, Willow Garage, Inc. 00006 * 00007 * All rights reserved. 00008 * 00009 * Redistribution and use in source and binary forms, with or without 00010 * modification, are permitted provided that the following conditions 00011 * are met: 00012 * 00013 * * Redistributions of source code must retain the above copyright 00014 * notice, this list of conditions and the following disclaimer. 00015 * * Redistributions in binary form must reproduce the above 00016 * copyright notice, this list of conditions and the following 00017 * disclaimer in the documentation and/or other materials provided 00018 * with the distribution. 00019 * * Neither the name of Willow Garage, Inc. nor the names of its 00020 * contributors may be used to endorse or promote products derived 00021 * from this software without specific prior written permission. 00022 * 00023 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 00024 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 00025 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 00026 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 00027 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 00028 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 00029 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 00030 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 00031 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 00032 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN 00033 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 00034 * POSSIBILITY OF SUCH DAMAGE. 00035 * 00036 * $Id: point_operators.h 5355 2012-03-27 23:52:01Z nizar $ 00037 * 00038 */ 00039 00040 #ifndef PCL_COMMON_POINT_OPERATORS_H 00041 #define PCL_COMMON_POINT_OPERATORS_H 00042 00043 #include <pcl/point_types.h> 00044 00045 namespace pcl 00046 { 00047 namespace common 00048 { 00053 00054 template <typename PointT> inline PointT 00055 operator+ (const PointT& lhs, const PointT& rhs) 00056 { 00057 PointT result = lhs; 00058 result.getVector3fMap () += rhs.getVector3fMap (); 00059 return (result); 00060 } 00062 template <typename PointT> inline PointT 00063 operator- (const PointT& lhs, const PointT& rhs) 00064 { 00065 PointT result = lhs; 00066 result.getVector3fMap () -= rhs.getVector3fMap (); 00067 return (result); 00068 } 00070 template <typename PointT> inline PointT 00071 operator* (const float& scalar, const PointT& p) 00072 { 00073 PointT result = p; 00074 result.getVector3fMap () *= scalar; 00075 return (result); 00076 } 00078 template <typename PointT> inline PointT 00079 operator* (const PointT& p, const float& scalar) 00080 { 00081 PointT result = p; 00082 result.getVector3fMap () *= scalar; 00083 return (result); 00084 } 00086 template <typename PointT> inline PointT 00087 operator/ (const float& scalar, const PointT& p) 00088 { 00089 PointT result = p; 00090 result.getVector3fMap () /= scalar; 00091 return (result); 00092 } 00094 template <typename PointT> inline PointT 00095 operator/ (const PointT& p, const float& scalar) 00096 { 00097 PointT result = p; 00098 result.getVector3fMap () /= scalar; 00099 return (result); 00100 } 00102 template <typename PointT> inline PointT& 00103 operator+= (PointT& lhs, const PointT& rhs) 00104 { 00105 lhs.getVector3fMap () += rhs.getVector3fMap (); 00106 return (lhs); 00107 } 00109 template <typename PointT> inline PointT& 00110 operator-= (PointT& lhs, const PointT& rhs) 00111 { 00112 lhs.getVector3fMap () -= rhs.getVector3fMap (); 00113 return (lhs); 00114 } 00116 template <typename PointT> inline PointT& 00117 operator*= (PointT& p, const float& scalar) 00118 { 00119 p.getVector3fMap () *= scalar; 00120 return (PointT ()); 00121 } 00123 template <typename PointT> inline PointT& 00124 operator/= (PointT& p, const float& scalar) 00125 { 00126 p.getVector3fMap () /= scalar; 00127 return (p); 00128 } 00129 00131 template <> inline pcl::PointXYZI 00132 operator+ (const pcl::PointXYZI& lhs, const pcl::PointXYZI& rhs) 00133 { 00134 pcl::PointXYZI result = lhs; 00135 result.getVector3fMap () += rhs.getVector3fMap (); 00136 result.intensity += rhs.intensity; 00137 return (result); 00138 } 00140 template <> inline pcl::PointXYZI 00141 operator- (const pcl::PointXYZI& lhs, const pcl::PointXYZI& rhs) 00142 { 00143 pcl::PointXYZI result = lhs; 00144 result.getVector3fMap () -= rhs.getVector3fMap (); 00145 result.intensity -= rhs.intensity; 00146 return (result); 00147 } 00149 template <> inline pcl::PointXYZI 00150 operator* (const float& scalar, const pcl::PointXYZI& p) 00151 { 00152 pcl::PointXYZI result = p; 00153 result.getVector3fMap () *= scalar; 00154 result.intensity *= scalar; 00155 return (result); 00156 } 00158 template <> inline pcl::PointXYZI 00159 operator* (const pcl::PointXYZI& p, const float& scalar) 00160 { 00161 pcl::PointXYZI result = p; 00162 result.getVector3fMap () *= scalar; 00163 result.intensity *= scalar; 00164 return (result); 00165 } 00167 template <> inline pcl::PointXYZI& 00168 operator+= (pcl::PointXYZI& lhs, const pcl::PointXYZI& rhs) 00169 { 00170 lhs.getVector3fMap () += rhs.getVector3fMap (); 00171 lhs.intensity += rhs.intensity; 00172 return (lhs); 00173 } 00175 template <> inline pcl::PointXYZI& 00176 operator-= (pcl::PointXYZI& lhs, const pcl::PointXYZI& rhs) 00177 { 00178 lhs.getVector3fMap () -= rhs.getVector3fMap (); 00179 lhs.intensity -= rhs.intensity; 00180 return (lhs); 00181 } 00183 template <> inline pcl::PointXYZI& 00184 operator*= (pcl::PointXYZI& lhs, const float& scalar) 00185 { 00186 lhs.getVector3fMap () *= scalar; 00187 lhs.intensity *= scalar; 00188 return (lhs); 00189 } 00190 template <> inline pcl::PointXYZINormal 00191 operator+ (const pcl::PointXYZINormal& lhs, const pcl::PointXYZINormal& rhs) 00192 { 00193 pcl::PointXYZINormal result = lhs; 00194 result.getVector3fMap () += rhs.getVector3fMap (); 00195 result.getNormalVector3fMap () += rhs.getNormalVector3fMap (); 00196 result.intensity += rhs.intensity; 00197 result.curvature += rhs.curvature; 00198 return (result); 00199 } 00200 00201 template <> inline pcl::PointXYZINormal 00202 operator- (const pcl::PointXYZINormal& lhs, const pcl::PointXYZINormal& rhs) 00203 { 00204 pcl::PointXYZINormal result = lhs; 00205 result.getVector3fMap () -= rhs.getVector3fMap (); 00206 result.getNormalVector3fMap () -= rhs.getNormalVector3fMap (); 00207 result.intensity -= rhs.intensity; 00208 result.curvature -= rhs.curvature; 00209 return (result); 00210 } 00211 00212 template <> inline pcl::PointXYZINormal& 00213 operator+= (pcl::PointXYZINormal& lhs, const pcl::PointXYZINormal& rhs) 00214 { 00215 lhs.getVector3fMap () += rhs.getVector3fMap (); 00216 lhs.getNormalVector3fMap () += rhs.getNormalVector3fMap (); 00217 lhs.intensity += rhs.intensity; 00218 lhs.curvature += rhs.curvature; 00219 return (lhs); 00220 } 00221 00222 template <> inline pcl::PointXYZINormal& 00223 operator-= (pcl::PointXYZINormal& lhs, const pcl::PointXYZINormal& rhs) 00224 { 00225 lhs.getVector3fMap () -= rhs.getVector3fMap (); 00226 lhs.getNormalVector3fMap () -= rhs.getNormalVector3fMap (); 00227 lhs.intensity-= rhs.intensity; 00228 lhs.curvature-= rhs.curvature; 00229 return (lhs); 00230 } 00231 00232 template <> inline pcl::PointXYZINormal& 00233 operator*= (pcl::PointXYZINormal& lhs, const float& scalar) 00234 { 00235 lhs.getVector3fMap () *= scalar; 00236 lhs.getNormalVector3fMap () *= scalar; 00237 lhs.intensity *= scalar; 00238 lhs.curvature *= scalar; 00239 return (lhs); 00240 } 00241 00242 template <> inline pcl::PointXYZINormal 00243 operator* (const float& scalar, const pcl::PointXYZINormal& p) 00244 { 00245 pcl::PointXYZINormal result = p; 00246 result.getVector3fMap () *= scalar; 00247 result.getNormalVector3fMap () *= scalar; 00248 result.intensity *= scalar; 00249 result.curvature *= scalar; 00250 return (result); 00251 } 00252 00253 template <> inline pcl::PointXYZINormal 00254 operator* (const pcl::PointXYZINormal& p, const float& scalar) 00255 { 00256 return (operator* (scalar, p)); 00257 } 00258 00260 template <> inline pcl::Normal 00261 operator+ (const pcl::Normal& lhs, const pcl::Normal& rhs) 00262 { 00263 pcl::Normal result = lhs; 00264 result.getNormalVector3fMap () += rhs.getNormalVector3fMap (); 00265 result.curvature += rhs.curvature; 00266 return (result); 00267 } 00269 template <> inline pcl::Normal 00270 operator- (const pcl::Normal& lhs, const pcl::Normal& rhs) 00271 { 00272 pcl::Normal result = lhs; 00273 result.getNormalVector3fMap () -= rhs.getNormalVector3fMap (); 00274 result.curvature -= rhs.curvature; 00275 return (result); 00276 } 00278 template <> inline pcl::Normal 00279 operator* (const float& scalar, const pcl::Normal& p) 00280 { 00281 pcl::Normal result = p; 00282 result.getNormalVector3fMap () *= scalar; 00283 result.curvature *= scalar; 00284 return (result); 00285 } 00287 template <> inline pcl::Normal 00288 operator* (const pcl::Normal& p, const float& scalar) 00289 { 00290 pcl::Normal result = p; 00291 result.getNormalVector3fMap () *= scalar; 00292 result.curvature *= scalar; 00293 return (result); 00294 } 00296 template <> inline pcl::Normal& 00297 operator+= (pcl::Normal& lhs, const pcl::Normal& rhs) 00298 { 00299 lhs.getNormalVector3fMap () += rhs.getNormalVector3fMap (); 00300 lhs.curvature += rhs.curvature; 00301 return (lhs); 00302 } 00304 template <> inline pcl::Normal& 00305 operator-= (pcl::Normal& lhs, const pcl::Normal& rhs) 00306 { 00307 lhs.getNormalVector3fMap () -= rhs.getNormalVector3fMap (); 00308 lhs.curvature -= rhs.curvature; 00309 return (lhs); 00310 } 00312 template <> inline pcl::Normal& 00313 operator*= (pcl::Normal& lhs, const float& scalar) 00314 { 00315 lhs.getNormalVector3fMap () *= scalar; 00316 lhs.curvature *= scalar; 00317 return (lhs); 00318 } 00319 00321 template <> inline pcl::PointXYZRGB 00322 operator+ (const pcl::PointXYZRGB& lhs, const pcl::PointXYZRGB& rhs) 00323 { 00324 pcl::PointXYZRGB result; 00325 result.getVector3fMap () = lhs.getVector3fMap (); 00326 result.getVector3fMap () += rhs.getVector3fMap (); 00327 result.r = static_cast<uint8_t> (lhs.r + rhs.r); 00328 result.g = static_cast<uint8_t> (lhs.g + rhs.g); 00329 result.b = static_cast<uint8_t> (lhs.b + rhs.b); 00330 return (result); 00331 } 00333 template <> inline pcl::PointXYZRGB 00334 operator- (const pcl::PointXYZRGB& lhs, const pcl::PointXYZRGB& rhs) 00335 { 00336 pcl::PointXYZRGB result; 00337 result.getVector3fMap () = lhs.getVector3fMap (); 00338 result.getVector3fMap () -= rhs.getVector3fMap (); 00339 result.r = static_cast<uint8_t> (lhs.r - rhs.r); 00340 result.g = static_cast<uint8_t> (lhs.g - rhs.g); 00341 result.b = static_cast<uint8_t> (lhs.b - rhs.b); 00342 return (result); 00343 } 00344 00345 template <> inline pcl::PointXYZRGB 00346 operator* (const float& scalar, const pcl::PointXYZRGB& p) 00347 { 00348 pcl::PointXYZRGB result; 00349 result.getVector3fMap () = p.getVector3fMap (); 00350 result.getVector3fMap () *= scalar; 00351 result.r = static_cast<uint8_t> (scalar * p.r); 00352 result.g = static_cast<uint8_t> (scalar * p.g); 00353 result.b = static_cast<uint8_t> (scalar * p.b); 00354 return (result); 00355 } 00356 00357 template <> inline pcl::PointXYZRGB 00358 operator* (const pcl::PointXYZRGB& p, const float& scalar) 00359 { 00360 pcl::PointXYZRGB result; 00361 result.getVector3fMap () = p.getVector3fMap (); 00362 result.getVector3fMap () *= scalar; 00363 result.r = static_cast<uint8_t> (scalar * p.r); 00364 result.g = static_cast<uint8_t> (scalar * p.g); 00365 result.b = static_cast<uint8_t> (scalar * p.b); 00366 return (result); 00367 } 00368 00369 template <> inline pcl::PointXYZRGB& 00370 operator+= (pcl::PointXYZRGB& lhs, const pcl::PointXYZRGB& rhs) 00371 { 00372 lhs.getVector3fMap () += rhs.getVector3fMap (); 00373 lhs.r = static_cast<uint8_t> (lhs.r + rhs.r); 00374 lhs.g = static_cast<uint8_t> (lhs.g + rhs.g); 00375 lhs.b = static_cast<uint8_t> (lhs.b + rhs.b); 00376 return (lhs); 00377 } 00378 00379 template <> inline pcl::PointXYZRGB& 00380 operator-= (pcl::PointXYZRGB& lhs, const pcl::PointXYZRGB& rhs) 00381 { 00382 lhs.getVector3fMap () -= rhs.getVector3fMap (); 00383 lhs.r = static_cast<uint8_t> (lhs.r - rhs.r); 00384 lhs.g = static_cast<uint8_t> (lhs.g - rhs.g); 00385 lhs.b = static_cast<uint8_t> (lhs.b - rhs.b); 00386 return (lhs); 00387 } 00388 00389 template <> inline pcl::PointXYZRGB& 00390 operator*= (pcl::PointXYZRGB& lhs, const float& scalar) 00391 { 00392 lhs.getVector3fMap () *= scalar; 00393 lhs.r = static_cast<uint8_t> (lhs.r * scalar); 00394 lhs.g = static_cast<uint8_t> (lhs.g * scalar); 00395 lhs.b = static_cast<uint8_t> (lhs.b * scalar); 00396 return (lhs); 00397 } 00398 00400 template <> inline pcl::PointXYZRGBA 00401 operator+ (const pcl::PointXYZRGBA& lhs, const pcl::PointXYZRGBA& rhs) 00402 { 00403 pcl::PointXYZRGBA result; 00404 result.getVector3fMap () = lhs.getVector3fMap (); 00405 result.getVector3fMap () += rhs.getVector3fMap (); 00406 result.r = static_cast<uint8_t> (lhs.r + rhs.r); 00407 result.g = static_cast<uint8_t> (lhs.g + rhs.g); 00408 result.b = static_cast<uint8_t> (lhs.b + rhs.b); 00409 return (result); 00410 } 00412 template <> inline pcl::PointXYZRGBA 00413 operator- (const pcl::PointXYZRGBA& lhs, const pcl::PointXYZRGBA& rhs) 00414 { 00415 pcl::PointXYZRGBA result; 00416 result.getVector3fMap () = lhs.getVector3fMap (); 00417 result.getVector3fMap () -= rhs.getVector3fMap (); 00418 result.r = static_cast<uint8_t> (lhs.r - rhs.r); 00419 result.g = static_cast<uint8_t> (lhs.g - rhs.g); 00420 result.b = static_cast<uint8_t> (lhs.b - rhs.b); 00421 return (result); 00422 } 00423 00424 template <> inline pcl::PointXYZRGBA 00425 operator* (const float& scalar, const pcl::PointXYZRGBA& p) 00426 { 00427 pcl::PointXYZRGBA result; 00428 result.getVector3fMap () = p.getVector3fMap (); 00429 result.getVector3fMap () *= scalar; 00430 result.r = static_cast<uint8_t> (scalar * p.r); 00431 result.g = static_cast<uint8_t> (scalar * p.g); 00432 result.b = static_cast<uint8_t> (scalar * p.b); 00433 return (result); 00434 } 00435 00436 template <> inline pcl::PointXYZRGBA 00437 operator* (const pcl::PointXYZRGBA& p, const float& scalar) 00438 { 00439 pcl::PointXYZRGBA result; 00440 result.getVector3fMap () = p.getVector3fMap (); 00441 result.getVector3fMap () *= scalar; 00442 result.r = static_cast<uint8_t> (scalar * p.r); 00443 result.g = static_cast<uint8_t> (scalar * p.g); 00444 result.b = static_cast<uint8_t> (scalar * p.b); 00445 return (result); 00446 } 00447 00448 template <> inline pcl::PointXYZRGBA& 00449 operator+= (pcl::PointXYZRGBA& lhs, const pcl::PointXYZRGBA& rhs) 00450 { 00451 lhs.getVector3fMap () += rhs.getVector3fMap (); 00452 lhs.r = static_cast<uint8_t> (lhs.r + rhs.r); 00453 lhs.g = static_cast<uint8_t> (lhs.g + rhs.g); 00454 lhs.b = static_cast<uint8_t> (lhs.b + rhs.b); 00455 return (lhs); 00456 } 00457 00458 template <> inline pcl::PointXYZRGBA& 00459 operator-= (pcl::PointXYZRGBA& lhs, const pcl::PointXYZRGBA& rhs) 00460 { 00461 lhs.getVector3fMap () -= rhs.getVector3fMap (); 00462 lhs.r = static_cast<uint8_t> (lhs.r - rhs.r); 00463 lhs.g = static_cast<uint8_t> (lhs.g - rhs.g); 00464 lhs.b = static_cast<uint8_t> (lhs.b - rhs.b); 00465 return (lhs); 00466 } 00467 00468 template <> inline pcl::PointXYZRGBA& 00469 operator*= (pcl::PointXYZRGBA& lhs, const float& scalar) 00470 { 00471 lhs.getVector3fMap () *= scalar; 00472 lhs.r = static_cast<uint8_t> (lhs.r * scalar); 00473 lhs.g = static_cast<uint8_t> (lhs.g * scalar); 00474 lhs.b = static_cast<uint8_t> (lhs.b * scalar); 00475 return (lhs); 00476 } 00477 00479 template <> inline pcl::RGB 00480 operator+ (const pcl::RGB& lhs, const pcl::RGB& rhs) 00481 { 00482 pcl::RGB result; 00483 result.r = static_cast<uint8_t> (lhs.r + rhs.r); 00484 result.g = static_cast<uint8_t> (lhs.g + rhs.g); 00485 result.b = static_cast<uint8_t> (lhs.b + rhs.b); 00486 return (result); 00487 } 00489 template <> inline pcl::RGB 00490 operator- (const pcl::RGB& lhs, const pcl::RGB& rhs) 00491 { 00492 pcl::RGB result; 00493 result.r = static_cast<uint8_t> (lhs.r - rhs.r); 00494 result.g = static_cast<uint8_t> (lhs.g - rhs.g); 00495 result.b = static_cast<uint8_t> (lhs.b - rhs.b); 00496 return (result); 00497 } 00498 00499 template <> inline pcl::RGB 00500 operator* (const float& scalar, const pcl::RGB& p) 00501 { 00502 pcl::RGB result; 00503 result.r = static_cast<uint8_t> (scalar * p.r); 00504 result.g = static_cast<uint8_t> (scalar * p.g); 00505 result.b = static_cast<uint8_t> (scalar * p.b); 00506 return (result); 00507 } 00508 00509 template <> inline pcl::RGB 00510 operator* (const pcl::RGB& p, const float& scalar) 00511 { 00512 pcl::RGB result; 00513 result.r = static_cast<uint8_t> (scalar * p.r); 00514 result.g = static_cast<uint8_t> (scalar * p.g); 00515 result.b = static_cast<uint8_t> (scalar * p.b); 00516 return (result); 00517 } 00518 00519 template <> inline pcl::RGB& 00520 operator+= (pcl::RGB& lhs, const pcl::RGB& rhs) 00521 { 00522 lhs.r = static_cast<uint8_t> (lhs.r + rhs.r); 00523 lhs.g = static_cast<uint8_t> (lhs.g + rhs.g); 00524 lhs.b = static_cast<uint8_t> (lhs.b + rhs.b); 00525 return (lhs); 00526 } 00527 00528 template <> inline pcl::RGB& 00529 operator-= (pcl::RGB& lhs, const pcl::RGB& rhs) 00530 { 00531 lhs.r = static_cast<uint8_t> (lhs.r - rhs.r); 00532 lhs.g = static_cast<uint8_t> (lhs.g - rhs.g); 00533 lhs.b = static_cast<uint8_t> (lhs.b - rhs.b); 00534 return (lhs); 00535 } 00536 00537 template <> inline pcl::RGB& 00538 operator*= (pcl::RGB& lhs, const float& scalar) 00539 { 00540 lhs.r = static_cast<uint8_t> (lhs.r * scalar); 00541 lhs.g = static_cast<uint8_t> (lhs.g * scalar); 00542 lhs.b = static_cast<uint8_t> (lhs.b * scalar); 00543 return (lhs); 00544 } 00545 } 00546 } 00547 00548 #endif
1.7.6.1
