Point Cloud Library (PCL)  1.11.1-dev
transforms.hpp
1 /*
2  * Software License Agreement (BSD License)
3  *
4  * Point Cloud Library (PCL) - www.pointclouds.org
5  * Copyright (c) 2010, Willow Garage, Inc.
6  * Copyright (c) 2012-, Open Perception, Inc.
7  *
8  * All rights reserved.
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  *
14  * * Redistributions of source code must retain the above copyright
15  * notice, this list of conditions and the following disclaimer.
16  * * Redistributions in binary form must reproduce the above
17  * copyright notice, this list of conditions and the following
18  * disclaimer in the documentation and/or other materials provided
19  * with the distribution.
20  * * Neither the name of the copyright holder(s) nor the names of its
21  * contributors may be used to endorse or promote products derived
22  * from this software without specific prior written permission.
23  *
24  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
25  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
26  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
27  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
28  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
29  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
30  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
31  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
32  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
33  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
34  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
35  * POSSIBILITY OF SUCH DAMAGE.
36  *
37  *
38  */
39 
40 #pragma once
41 
42 #include <pcl/common/transforms.h>
43 
44 #if defined(__SSE2__)
45 #include <xmmintrin.h>
46 #endif
47 
48 #if defined(__AVX__)
49 #include <immintrin.h>
50 #endif
51 
52 #include <algorithm>
53 #include <cmath>
54 #include <cstddef>
55 #include <vector>
56 
57 
58 namespace pcl
59 {
60 
61 namespace detail
62 {
63 
64 /** A helper struct to apply an SO3 or SE3 transform to a 3D point.
65  * Supports single and double precision transform matrices. */
66 template<typename Scalar>
68 {
69  const Eigen::Matrix<Scalar, 4, 4>& tf;
70 
71  /** Construct a transformer object.
72  * The transform matrix is captured by const reference. Make sure that it does not go out of scope before this
73  * object does. */
74  Transformer (const Eigen::Matrix<Scalar, 4, 4>& transform) : tf (transform) { };
75 
76  /** Apply SO3 transform (top-left corner of the transform matrix).
77  * \param[in] src input 3D point (pointer to 3 floats)
78  * \param[out] tgt output 3D point (pointer to 4 floats), can be the same as input. The fourth element is set to 0. */
79  void so3 (const float* src, float* tgt) const
80  {
81  const Scalar p[3] = { src[0], src[1], src[2] }; // need this when src == tgt
82  tgt[0] = static_cast<float> (tf (0, 0) * p[0] + tf (0, 1) * p[1] + tf (0, 2) * p[2]);
83  tgt[1] = static_cast<float> (tf (1, 0) * p[0] + tf (1, 1) * p[1] + tf (1, 2) * p[2]);
84  tgt[2] = static_cast<float> (tf (2, 0) * p[0] + tf (2, 1) * p[1] + tf (2, 2) * p[2]);
85  tgt[3] = 0;
86  }
87 
88  /** Apply SE3 transform.
89  * \param[in] src input 3D point (pointer to 3 floats)
90  * \param[out] tgt output 3D point (pointer to 4 floats), can be the same as input. The fourth element is set to 1. */
91  void se3 (const float* src, float* tgt) const
92  {
93  const Scalar p[3] = { src[0], src[1], src[2] }; // need this when src == tgt
94  tgt[0] = static_cast<float> (tf (0, 0) * p[0] + tf (0, 1) * p[1] + tf (0, 2) * p[2] + tf (0, 3));
95  tgt[1] = static_cast<float> (tf (1, 0) * p[0] + tf (1, 1) * p[1] + tf (1, 2) * p[2] + tf (1, 3));
96  tgt[2] = static_cast<float> (tf (2, 0) * p[0] + tf (2, 1) * p[1] + tf (2, 2) * p[2] + tf (2, 3));
97  tgt[3] = 1;
98  }
99 };
100 
101 #if defined(__SSE2__)
102 
103 /** Optimized version for single-precision transforms using SSE2 intrinsics. */
104 template<>
105 struct Transformer<float>
106 {
107  /// Columns of the transform matrix stored in XMM registers.
108  __m128 c[4];
109 
110  Transformer(const Eigen::Matrix4f& tf)
111  {
112  for (std::size_t i = 0; i < 4; ++i)
113  c[i] = _mm_load_ps (tf.col (i).data ());
114  }
115 
116  void so3 (const float* src, float* tgt) const
117  {
118  __m128 p0 = _mm_mul_ps (_mm_load_ps1 (&src[0]), c[0]);
119  __m128 p1 = _mm_mul_ps (_mm_load_ps1 (&src[1]), c[1]);
120  __m128 p2 = _mm_mul_ps (_mm_load_ps1 (&src[2]), c[2]);
121  _mm_store_ps (tgt, _mm_add_ps(p0, _mm_add_ps(p1, p2)));
122  }
123 
124  void se3 (const float* src, float* tgt) const
125  {
126  __m128 p0 = _mm_mul_ps (_mm_load_ps1 (&src[0]), c[0]);
127  __m128 p1 = _mm_mul_ps (_mm_load_ps1 (&src[1]), c[1]);
128  __m128 p2 = _mm_mul_ps (_mm_load_ps1 (&src[2]), c[2]);
129  _mm_store_ps (tgt, _mm_add_ps(p0, _mm_add_ps(p1, _mm_add_ps(p2, c[3]))));
130  }
131 };
132 
133 #if !defined(__AVX__)
134 
135 /** Optimized version for double-precision transform using SSE2 intrinsics. */
136 template<>
137 struct Transformer<double>
138 {
139  /// Columns of the transform matrix stored in XMM registers.
140  __m128d c[4][2];
141 
142  Transformer(const Eigen::Matrix4d& tf)
143  {
144  for (std::size_t i = 0; i < 4; ++i)
145  {
146  c[i][0] = _mm_load_pd (tf.col (i).data () + 0);
147  c[i][1] = _mm_load_pd (tf.col (i).data () + 2);
148  }
149  }
150 
151  void so3 (const float* src, float* tgt) const
152  {
153  __m128d xx = _mm_cvtps_pd (_mm_load_ps1 (&src[0]));
154  __m128d p0 = _mm_mul_pd (xx, c[0][0]);
155  __m128d p1 = _mm_mul_pd (xx, c[0][1]);
156 
157  for (std::size_t i = 1; i < 3; ++i)
158  {
159  __m128d vv = _mm_cvtps_pd (_mm_load_ps1 (&src[i]));
160  p0 = _mm_add_pd (_mm_mul_pd (vv, c[i][0]), p0);
161  p1 = _mm_add_pd (_mm_mul_pd (vv, c[i][1]), p1);
162  }
163 
164  _mm_store_ps (tgt, _mm_movelh_ps (_mm_cvtpd_ps (p0), _mm_cvtpd_ps (p1)));
165  }
166 
167  void se3 (const float* src, float* tgt) const
168  {
169  __m128d p0 = c[3][0];
170  __m128d p1 = c[3][1];
171 
172  for (std::size_t i = 0; i < 3; ++i)
173  {
174  __m128d vv = _mm_cvtps_pd (_mm_load_ps1 (&src[i]));
175  p0 = _mm_add_pd (_mm_mul_pd (vv, c[i][0]), p0);
176  p1 = _mm_add_pd (_mm_mul_pd (vv, c[i][1]), p1);
177  }
178 
179  _mm_store_ps (tgt, _mm_movelh_ps (_mm_cvtpd_ps (p0), _mm_cvtpd_ps (p1)));
180  }
181 };
182 
183 #else
184 
185 /** Optimized version for double-precision transform using AVX intrinsics. */
186 template<>
187 struct Transformer<double>
188 {
189  __m256d c[4];
190 
191  Transformer(const Eigen::Matrix4d& tf)
192  {
193  for (std::size_t i = 0; i < 4; ++i)
194  c[i] = _mm256_load_pd (tf.col (i).data ());
195  }
196 
197  void so3 (const float* src, float* tgt) const
198  {
199  __m256d p0 = _mm256_mul_pd (_mm256_cvtps_pd (_mm_load_ps1 (&src[0])), c[0]);
200  __m256d p1 = _mm256_mul_pd (_mm256_cvtps_pd (_mm_load_ps1 (&src[1])), c[1]);
201  __m256d p2 = _mm256_mul_pd (_mm256_cvtps_pd (_mm_load_ps1 (&src[2])), c[2]);
202  _mm_store_ps (tgt, _mm256_cvtpd_ps (_mm256_add_pd(p0, _mm256_add_pd(p1, p2))));
203  }
204 
205  void se3 (const float* src, float* tgt) const
206  {
207  __m256d p0 = _mm256_mul_pd (_mm256_cvtps_pd (_mm_load_ps1 (&src[0])), c[0]);
208  __m256d p1 = _mm256_mul_pd (_mm256_cvtps_pd (_mm_load_ps1 (&src[1])), c[1]);
209  __m256d p2 = _mm256_mul_pd (_mm256_cvtps_pd (_mm_load_ps1 (&src[2])), c[2]);
210  _mm_store_ps (tgt, _mm256_cvtpd_ps (_mm256_add_pd(p0, _mm256_add_pd(p1, _mm256_add_pd(p2, c[3])))));
211  }
212 };
213 
214 #endif // !defined(__AVX__)
215 #endif // defined(__SSE2__)
216 
217 } // namespace detail
218 
219 
220 template <typename PointT, typename Scalar> void
222  pcl::PointCloud<PointT> &cloud_out,
223  const Eigen::Matrix<Scalar, 4, 4> &transform,
224  bool copy_all_fields)
225 {
226  if (&cloud_in != &cloud_out)
227  {
228  cloud_out.header = cloud_in.header;
229  cloud_out.is_dense = cloud_in.is_dense;
230  cloud_out.width = cloud_in.width;
231  cloud_out.height = cloud_in.height;
232  cloud_out.reserve (cloud_in.size ());
233  if (copy_all_fields)
234  cloud_out.assign (cloud_in.begin (), cloud_in.end ());
235  else
236  cloud_out.resize (cloud_in.size ());
237  cloud_out.sensor_orientation_ = cloud_in.sensor_orientation_;
238  cloud_out.sensor_origin_ = cloud_in.sensor_origin_;
239  }
240 
241  pcl::detail::Transformer<Scalar> tf (transform);
242  if (cloud_in.is_dense)
243  {
244  // If the dataset is dense, simply transform it!
245  for (std::size_t i = 0; i < cloud_out.size (); ++i)
246  tf.se3 (cloud_in[i].data, cloud_out[i].data);
247  }
248  else
249  {
250  // Dataset might contain NaNs and Infs, so check for them first,
251  // otherwise we get errors during the multiplication (?)
252  for (std::size_t i = 0; i < cloud_out.size (); ++i)
253  {
254  if (!std::isfinite (cloud_in[i].x) ||
255  !std::isfinite (cloud_in[i].y) ||
256  !std::isfinite (cloud_in[i].z))
257  continue;
258  tf.se3 (cloud_in[i].data, cloud_out[i].data);
259  }
260  }
261 }
262 
263 
264 template <typename PointT, typename Scalar> void
266  const Indices &indices,
267  pcl::PointCloud<PointT> &cloud_out,
268  const Eigen::Matrix<Scalar, 4, 4> &transform,
269  bool copy_all_fields)
270 {
271  std::size_t npts = indices.size ();
272  // In order to transform the data, we need to remove NaNs
273  cloud_out.is_dense = cloud_in.is_dense;
274  cloud_out.header = cloud_in.header;
275  cloud_out.width = static_cast<int> (npts);
276  cloud_out.height = 1;
277  cloud_out.resize (npts);
278  cloud_out.sensor_orientation_ = cloud_in.sensor_orientation_;
279  cloud_out.sensor_origin_ = cloud_in.sensor_origin_;
280 
281  pcl::detail::Transformer<Scalar> tf (transform);
282  if (cloud_in.is_dense)
283  {
284  // If the dataset is dense, simply transform it!
285  for (std::size_t i = 0; i < npts; ++i)
286  {
287  // Copy fields first, then transform xyz data
288  if (copy_all_fields)
289  cloud_out[i] = cloud_in[indices[i]];
290  tf.se3 (cloud_in[indices[i]].data, cloud_out[i].data);
291  }
292  }
293  else
294  {
295  // Dataset might contain NaNs and Infs, so check for them first,
296  // otherwise we get errors during the multiplication (?)
297  for (std::size_t i = 0; i < npts; ++i)
298  {
299  if (copy_all_fields)
300  cloud_out[i] = cloud_in[indices[i]];
301  if (!std::isfinite (cloud_in[indices[i]].x) ||
302  !std::isfinite (cloud_in[indices[i]].y) ||
303  !std::isfinite (cloud_in[indices[i]].z))
304  continue;
305  tf.se3 (cloud_in[indices[i]].data, cloud_out[i].data);
306  }
307  }
308 }
309 
310 
311 template <typename PointT, typename Scalar> void
313  pcl::PointCloud<PointT> &cloud_out,
314  const Eigen::Matrix<Scalar, 4, 4> &transform,
315  bool copy_all_fields)
316 {
317  if (&cloud_in != &cloud_out)
318  {
319  // Note: could be replaced by cloud_out = cloud_in
320  cloud_out.header = cloud_in.header;
321  cloud_out.width = cloud_in.width;
322  cloud_out.height = cloud_in.height;
323  cloud_out.is_dense = cloud_in.is_dense;
324  cloud_out.reserve (cloud_out.size ());
325  if (copy_all_fields)
326  cloud_out.assign (cloud_in.begin (), cloud_in.end ());
327  else
328  cloud_out.resize (cloud_in.size ());
329  cloud_out.sensor_orientation_ = cloud_in.sensor_orientation_;
330  cloud_out.sensor_origin_ = cloud_in.sensor_origin_;
331  }
332 
333  pcl::detail::Transformer<Scalar> tf (transform);
334  // If the data is dense, we don't need to check for NaN
335  if (cloud_in.is_dense)
336  {
337  for (std::size_t i = 0; i < cloud_out.size (); ++i)
338  {
339  tf.se3 (cloud_in[i].data, cloud_out[i].data);
340  tf.so3 (cloud_in[i].data_n, cloud_out[i].data_n);
341  }
342  }
343  // Dataset might contain NaNs and Infs, so check for them first.
344  else
345  {
346  for (std::size_t i = 0; i < cloud_out.size (); ++i)
347  {
348  if (!std::isfinite (cloud_in[i].x) ||
349  !std::isfinite (cloud_in[i].y) ||
350  !std::isfinite (cloud_in[i].z))
351  continue;
352  tf.se3 (cloud_in[i].data, cloud_out[i].data);
353  tf.so3 (cloud_in[i].data_n, cloud_out[i].data_n);
354  }
355  }
356 }
357 
358 
359 template <typename PointT, typename Scalar> void
361  const Indices &indices,
362  pcl::PointCloud<PointT> &cloud_out,
363  const Eigen::Matrix<Scalar, 4, 4> &transform,
364  bool copy_all_fields)
365 {
366  std::size_t npts = indices.size ();
367  // In order to transform the data, we need to remove NaNs
368  cloud_out.is_dense = cloud_in.is_dense;
369  cloud_out.header = cloud_in.header;
370  cloud_out.width = static_cast<int> (npts);
371  cloud_out.height = 1;
372  cloud_out.resize (npts);
373  cloud_out.sensor_orientation_ = cloud_in.sensor_orientation_;
374  cloud_out.sensor_origin_ = cloud_in.sensor_origin_;
375 
376  pcl::detail::Transformer<Scalar> tf (transform);
377  // If the data is dense, we don't need to check for NaN
378  if (cloud_in.is_dense)
379  {
380  for (std::size_t i = 0; i < cloud_out.size (); ++i)
381  {
382  // Copy fields first, then transform
383  if (copy_all_fields)
384  cloud_out[i] = cloud_in[indices[i]];
385  tf.se3 (cloud_in[indices[i]].data, cloud_out[i].data);
386  tf.so3 (cloud_in[indices[i]].data_n, cloud_out[i].data_n);
387  }
388  }
389  // Dataset might contain NaNs and Infs, so check for them first.
390  else
391  {
392  for (std::size_t i = 0; i < cloud_out.size (); ++i)
393  {
394  // Copy fields first, then transform
395  if (copy_all_fields)
396  cloud_out[i] = cloud_in[indices[i]];
397 
398  if (!std::isfinite (cloud_in[indices[i]].x) ||
399  !std::isfinite (cloud_in[indices[i]].y) ||
400  !std::isfinite (cloud_in[indices[i]].z))
401  continue;
402 
403  tf.se3 (cloud_in[indices[i]].data, cloud_out[i].data);
404  tf.so3 (cloud_in[indices[i]].data_n, cloud_out[i].data_n);
405  }
406  }
407 }
408 
409 
410 template <typename PointT, typename Scalar> inline void
412  pcl::PointCloud<PointT> &cloud_out,
413  const Eigen::Matrix<Scalar, 3, 1> &offset,
414  const Eigen::Quaternion<Scalar> &rotation,
415  bool copy_all_fields)
416 {
417  Eigen::Translation<Scalar, 3> translation (offset);
418  // Assemble an Eigen Transform
419  Eigen::Transform<Scalar, 3, Eigen::Affine> t (translation * rotation);
420  transformPointCloud (cloud_in, cloud_out, t, copy_all_fields);
421 }
422 
423 
424 template <typename PointT, typename Scalar> inline void
426  pcl::PointCloud<PointT> &cloud_out,
427  const Eigen::Matrix<Scalar, 3, 1> &offset,
428  const Eigen::Quaternion<Scalar> &rotation,
429  bool copy_all_fields)
430 {
431  Eigen::Translation<Scalar, 3> translation (offset);
432  // Assemble an Eigen Transform
433  Eigen::Transform<Scalar, 3, Eigen::Affine> t (translation * rotation);
434  transformPointCloudWithNormals (cloud_in, cloud_out, t, copy_all_fields);
435 }
436 
437 
438 template <typename PointT, typename Scalar> inline PointT
439 transformPoint (const PointT &point, const Eigen::Transform<Scalar, 3, Eigen::Affine> &transform)
440 {
441  PointT ret = point;
442  pcl::detail::Transformer<Scalar> tf (transform.matrix ());
443  tf.se3 (point.data, ret.data);
444  return (ret);
445 }
446 
447 
448 template <typename PointT, typename Scalar> inline PointT
449 transformPointWithNormal (const PointT &point, const Eigen::Transform<Scalar, 3, Eigen::Affine> &transform)
450 {
451  PointT ret = point;
452  pcl::detail::Transformer<Scalar> tf (transform.matrix ());
453  tf.se3 (point.data, ret.data);
454  tf.so3 (point.data_n, ret.data_n);
455  return (ret);
456 }
457 
458 
459 template <typename PointT, typename Scalar> double
461  Eigen::Transform<Scalar, 3, Eigen::Affine> &transform)
462 {
463  EIGEN_ALIGN16 Eigen::Matrix<Scalar, 3, 3> covariance_matrix;
464  Eigen::Matrix<Scalar, 4, 1> centroid;
465 
466  pcl::computeMeanAndCovarianceMatrix (cloud, covariance_matrix, centroid);
467 
468  EIGEN_ALIGN16 Eigen::Matrix<Scalar, 3, 3> eigen_vects;
469  Eigen::Matrix<Scalar, 3, 1> eigen_vals;
470  pcl::eigen33 (covariance_matrix, eigen_vects, eigen_vals);
471 
472  double rel1 = eigen_vals.coeff (0) / eigen_vals.coeff (1);
473  double rel2 = eigen_vals.coeff (1) / eigen_vals.coeff (2);
474 
475  transform.translation () = centroid.head (3);
476  transform.linear () = eigen_vects;
477 
478  return (std::min (rel1, rel2));
479 }
480 
481 } // namespace pcl
482 
pcl::computeMeanAndCovarianceMatrix
unsigned int computeMeanAndCovarianceMatrix(const pcl::PointCloud< PointT > &cloud, Eigen::Matrix< Scalar, 3, 3 > &covariance_matrix, Eigen::Matrix< Scalar, 4, 1 > &centroid)
Compute the normalized 3x3 covariance matrix and the centroid of a given set of points in a single lo...
Definition: centroid.hpp:485
pcl
Definition: convolution.h:46
pcl::PointCloud::height
std::uint32_t height
The point cloud height (if organized as an image-structure).
Definition: point_cloud.h:415
pcl::PointCloud::begin
iterator begin() noexcept
Definition: point_cloud.h:444
pcl::PointCloud
PointCloud represents the base class in PCL for storing collections of 3D points.
Definition: distances.h:55
pcl::eigen33
void eigen33(const Matrix &mat, typename Matrix::Scalar &eigenvalue, Vector &eigenvector)
determines the eigenvector and eigenvalue of the smallest eigenvalue of the symmetric positive semi d...
Definition: eigen.hpp:296
pcl::PointXYZRGB
A point structure representing Euclidean xyz coordinates, and the RGB color.
Definition: point_types.hpp:628
pcl::transformPointCloud
void transformPointCloud(const pcl::PointCloud< PointT > &cloud_in, pcl::PointCloud< PointT > &cloud_out, const Eigen::Matrix< Scalar, 4, 4 > &transform, bool copy_all_fields)
Apply a rigid transform defined by a 4x4 matrix.
Definition: transforms.hpp:221
pcl::PointCloud::width
std::uint32_t width
The point cloud width (if organized as an image-structure).
Definition: point_cloud.h:413
pcl::transformPointCloudWithNormals
void transformPointCloudWithNormals(const pcl::PointCloud< PointT > &cloud_in, pcl::PointCloud< PointT > &cloud_out, const Eigen::Matrix< Scalar, 4, 4 > &transform, bool copy_all_fields)
Transform a point cloud and rotate its normals using an Eigen transform.
Definition: transforms.hpp:312
pcl::PointCloud::end
iterator end() noexcept
Definition: point_cloud.h:445
pcl::PointCloud::reserve
void reserve(std::size_t n)
Definition: point_cloud.h:460
pcl::PointCloud::sensor_origin_
Eigen::Vector4f sensor_origin_
Sensor acquisition pose (origin/translation).
Definition: point_cloud.h:421
pcl::PointCloud::sensor_orientation_
Eigen::Quaternionf sensor_orientation_
Sensor acquisition pose (rotation).
Definition: point_cloud.h:423
pcl::detail::Transformer
A helper struct to apply an SO3 or SE3 transform to a 3D point.
Definition: transforms.hpp:67
pcl::detail::Transformer::se3
void se3(const float *src, float *tgt) const
Apply SE3 transform.
Definition: transforms.hpp:91
pcl::PointCloud::is_dense
bool is_dense
True if no points are invalid (e.g., have NaN or Inf values in any of their floating point fields).
Definition: point_cloud.h:418
pcl::PointCloud::resize
void resize(std::size_t count)
Resizes the container to contain count elements.
Definition: point_cloud.h:477
pcl::PointCloud::header
pcl::PCLHeader header
The point cloud header.
Definition: point_cloud.h:407
pcl::Indices
IndicesAllocator<> Indices
Type used for indices in PCL.
Definition: types.h:141
pcl::detail::Transformer::tf
const Eigen::Matrix< Scalar, 4, 4 > & tf
Definition: transforms.hpp:69
pcl::PointCloud::size
std::size_t size() const
Definition: point_cloud.h:458
pcl::PointCloud::assign
void assign(index_t count, const PointT &value)
Replaces the points with count copies of value
Definition: point_cloud.h:524
pcl::detail::Transformer::so3
void so3(const float *src, float *tgt) const
Apply SO3 transform (top-left corner of the transform matrix).
Definition: transforms.hpp:79
pcl::transformPointWithNormal
PointT transformPointWithNormal(const PointT &point, const Eigen::Transform< Scalar, 3, Eigen::Affine > &transform)
Transform a point with members x,y,z,normal_x,normal_y,normal_z.
Definition: transforms.hpp:449
pcl::PointCloud::data
PointT * data() noexcept
Definition: point_cloud.h:462
pcl::detail::Transformer::Transformer
Transformer(const Eigen::Matrix< Scalar, 4, 4 > &transform)
Construct a transformer object.
Definition: transforms.hpp:74
pcl::getPrincipalTransformation
double getPrincipalTransformation(const pcl::PointCloud< PointT > &cloud, Eigen::Transform< Scalar, 3, Eigen::Affine > &transform)
Calculates the principal (PCA-based) alignment of the point cloud.
Definition: transforms.hpp:460
pcl::transformPoint
void transformPoint(const Eigen::Matrix< Scalar, 3, 1 > &point_in, Eigen::Matrix< Scalar, 3, 1 > &point_out, const Eigen::Transform< Scalar, 3, Eigen::Affine > &transformation)
Transform a point using an affine matrix.
Definition: eigen.h:417