Point Cloud Library (PCL)  1.11.0
range_image.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  * 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 #pragma once
39 
40 #include <pcl/memory.h>
41 #include <pcl/point_cloud.h>
42 #include <pcl/pcl_macros.h>
43 #include <pcl/point_types.h>
44 #include <pcl/common/common_headers.h>
45 #include <pcl/common/vector_average.h>
46 #include <typeinfo>
47 
48 namespace pcl
49 {
50  /** \brief RangeImage is derived from pcl/PointCloud and provides functionalities with focus on situations where
51  * a 3D scene was captured from a specific view point.
52  * \author Bastian Steder
53  * \ingroup range_image
54  */
55  class RangeImage : public pcl::PointCloud<PointWithRange>
56  {
57  public:
58  // =====TYPEDEFS=====
60  using VectorOfEigenVector3f = std::vector<Eigen::Vector3f, Eigen::aligned_allocator<Eigen::Vector3f> >;
61  using Ptr = shared_ptr<RangeImage>;
62  using ConstPtr = shared_ptr<const RangeImage>;
63 
65  {
68  };
69 
70 
71  // =====CONSTRUCTOR & DESTRUCTOR=====
72  /** Constructor */
73  PCL_EXPORTS RangeImage ();
74  /** Destructor */
75  PCL_EXPORTS virtual ~RangeImage () = default;
76 
77  // =====STATIC VARIABLES=====
78  /** The maximum number of openmp threads that can be used in this class */
79  static int max_no_of_threads;
80 
81  // =====STATIC METHODS=====
82  /** \brief Get the size of a certain area when seen from the given pose
83  * \param viewer_pose an affine matrix defining the pose of the viewer
84  * \param center the center of the area
85  * \param radius the radius of the area
86  * \return the size of the area as viewed according to \a viewer_pose
87  */
88  static inline float
89  getMaxAngleSize (const Eigen::Affine3f& viewer_pose, const Eigen::Vector3f& center,
90  float radius);
91 
92  /** \brief Get Eigen::Vector3f from PointWithRange
93  * \param point the input point
94  * \return an Eigen::Vector3f representation of the input point
95  */
96  static inline Eigen::Vector3f
97  getEigenVector3f (const PointWithRange& point);
98 
99  /** \brief Get the transformation that transforms the given coordinate frame into CAMERA_FRAME
100  * \param coordinate_frame the input coordinate frame
101  * \param transformation the resulting transformation that warps \a coordinate_frame into CAMERA_FRAME
102  */
103  PCL_EXPORTS static void
105  Eigen::Affine3f& transformation);
106 
107  /** \brief Get the average viewpoint of a point cloud where each point carries viewpoint information as
108  * vp_x, vp_y, vp_z
109  * \param point_cloud the input point cloud
110  * \return the average viewpoint (as an Eigen::Vector3f)
111  */
112  template <typename PointCloudTypeWithViewpoints> static Eigen::Vector3f
113  getAverageViewPoint (const PointCloudTypeWithViewpoints& point_cloud);
114 
115  /** \brief Check if the provided data includes far ranges and add them to far_ranges
116  * \param point_cloud_data a PCLPointCloud2 message containing the input cloud
117  * \param far_ranges the resulting cloud containing those points with far ranges
118  */
119  PCL_EXPORTS static void
120  extractFarRanges (const pcl::PCLPointCloud2& point_cloud_data, PointCloud<PointWithViewpoint>& far_ranges);
121 
122  // =====METHODS=====
123  /** \brief Get a boost shared pointer of a copy of this */
124  inline Ptr
125  makeShared () { return Ptr (new RangeImage (*this)); }
126 
127  /** \brief Reset all values to an empty range image */
128  PCL_EXPORTS void
129  reset ();
130 
131  /** \brief Create the depth image from a point cloud
132  * \param point_cloud the input point cloud
133  * \param angular_resolution the angular difference (in radians) between the individual pixels in the image
134  * \param max_angle_width an angle (in radians) defining the horizontal bounds of the sensor
135  * \param max_angle_height an angle (in radians) defining the vertical bounds of the sensor
136  * \param sensor_pose an affine matrix defining the pose of the sensor (defaults to
137  * Eigen::Affine3f::Identity () )
138  * \param coordinate_frame the coordinate frame (defaults to CAMERA_FRAME)
139  * \param noise_level - The distance in meters inside of which the z-buffer will not use the minimum,
140  * but the mean of the points. If 0.0 it is equivalent to a normal z-buffer and
141  * will always take the minimum per cell.
142  * \param min_range the minimum visible range (defaults to 0)
143  * \param border_size the border size (defaults to 0)
144  */
145  template <typename PointCloudType> void
146  createFromPointCloud (const PointCloudType& point_cloud, float angular_resolution=pcl::deg2rad (0.5f),
147  float max_angle_width=pcl::deg2rad (360.0f), float max_angle_height=pcl::deg2rad (180.0f),
148  const Eigen::Affine3f& sensor_pose = Eigen::Affine3f::Identity (),
149  CoordinateFrame coordinate_frame=CAMERA_FRAME, float noise_level=0.0f,
150  float min_range=0.0f, int border_size=0);
151 
152  /** \brief Create the depth image from a point cloud
153  * \param point_cloud the input point cloud
154  * \param angular_resolution_x the angular difference (in radians) between the
155  * individual pixels in the image in the x-direction
156  * \param angular_resolution_y the angular difference (in radians) between the
157  * individual pixels in the image in the y-direction
158  * \param max_angle_width an angle (in radians) defining the horizontal bounds of the sensor
159  * \param max_angle_height an angle (in radians) defining the vertical bounds of the sensor
160  * \param sensor_pose an affine matrix defining the pose of the sensor (defaults to
161  * Eigen::Affine3f::Identity () )
162  * \param coordinate_frame the coordinate frame (defaults to CAMERA_FRAME)
163  * \param noise_level - The distance in meters inside of which the z-buffer will not use the minimum,
164  * but the mean of the points. If 0.0 it is equivalent to a normal z-buffer and
165  * will always take the minimum per cell.
166  * \param min_range the minimum visible range (defaults to 0)
167  * \param border_size the border size (defaults to 0)
168  */
169  template <typename PointCloudType> void
170  createFromPointCloud (const PointCloudType& point_cloud,
171  float angular_resolution_x=pcl::deg2rad (0.5f), float angular_resolution_y=pcl::deg2rad (0.5f),
172  float max_angle_width=pcl::deg2rad (360.0f), float max_angle_height=pcl::deg2rad (180.0f),
173  const Eigen::Affine3f& sensor_pose = Eigen::Affine3f::Identity (),
174  CoordinateFrame coordinate_frame=CAMERA_FRAME,
175  float noise_level=0.0f, float min_range=0.0f, int border_size=0);
176 
177  /** \brief Create the depth image from a point cloud, getting a hint about the size of the scene for
178  * faster calculation.
179  * \param point_cloud the input point cloud
180  * \param angular_resolution the angle (in radians) between each sample in the depth image
181  * \param point_cloud_center the center of bounding sphere
182  * \param point_cloud_radius the radius of the bounding sphere
183  * \param sensor_pose an affine matrix defining the pose of the sensor (defaults to
184  * Eigen::Affine3f::Identity () )
185  * \param coordinate_frame the coordinate frame (defaults to CAMERA_FRAME)
186  * \param noise_level - The distance in meters inside of which the z-buffer will not use the minimum,
187  * but the mean of the points. If 0.0 it is equivalent to a normal z-buffer and
188  * will always take the minimum per cell.
189  * \param min_range the minimum visible range (defaults to 0)
190  * \param border_size the border size (defaults to 0)
191  */
192  template <typename PointCloudType> void
193  createFromPointCloudWithKnownSize (const PointCloudType& point_cloud, float angular_resolution,
194  const Eigen::Vector3f& point_cloud_center, float point_cloud_radius,
195  const Eigen::Affine3f& sensor_pose = Eigen::Affine3f::Identity (),
196  CoordinateFrame coordinate_frame=CAMERA_FRAME,
197  float noise_level=0.0f, float min_range=0.0f, int border_size=0);
198 
199  /** \brief Create the depth image from a point cloud, getting a hint about the size of the scene for
200  * faster calculation.
201  * \param point_cloud the input point cloud
202  * \param angular_resolution_x the angular difference (in radians) between the
203  * individual pixels in the image in the x-direction
204  * \param angular_resolution_y the angular difference (in radians) between the
205  * individual pixels in the image in the y-direction
206  * \param point_cloud_center the center of bounding sphere
207  * \param point_cloud_radius the radius of the bounding sphere
208  * \param sensor_pose an affine matrix defining the pose of the sensor (defaults to
209  * Eigen::Affine3f::Identity () )
210  * \param coordinate_frame the coordinate frame (defaults to CAMERA_FRAME)
211  * \param noise_level - The distance in meters inside of which the z-buffer will not use the minimum,
212  * but the mean of the points. If 0.0 it is equivalent to a normal z-buffer and
213  * will always take the minimum per cell.
214  * \param min_range the minimum visible range (defaults to 0)
215  * \param border_size the border size (defaults to 0)
216  */
217  template <typename PointCloudType> void
218  createFromPointCloudWithKnownSize (const PointCloudType& point_cloud,
219  float angular_resolution_x, float angular_resolution_y,
220  const Eigen::Vector3f& point_cloud_center, float point_cloud_radius,
221  const Eigen::Affine3f& sensor_pose = Eigen::Affine3f::Identity (),
222  CoordinateFrame coordinate_frame=CAMERA_FRAME,
223  float noise_level=0.0f, float min_range=0.0f, int border_size=0);
224 
225  /** \brief Create the depth image from a point cloud, using the average viewpoint of the points
226  * (vp_x,vp_y,vp_z in the point type) in the point cloud as sensor pose (assuming a rotation of (0,0,0)).
227  * \param point_cloud the input point cloud
228  * \param angular_resolution the angle (in radians) between each sample in the depth image
229  * \param max_angle_width an angle (in radians) defining the horizontal bounds of the sensor
230  * \param max_angle_height an angle (in radians) defining the vertical bounds of the sensor
231  * \param coordinate_frame the coordinate frame (defaults to CAMERA_FRAME)
232  * \param noise_level - The distance in meters inside of which the z-buffer will not use the minimum,
233  * but the mean of the points. If 0.0 it is equivalent to a normal z-buffer and
234  * will always take the minimum per cell.
235  * \param min_range the minimum visible range (defaults to 0)
236  * \param border_size the border size (defaults to 0)
237  * \note If wrong_coordinate_system is true, the sensor pose will be rotated to change from a coordinate frame
238  * with x to the front, y to the left and z to the top to the coordinate frame we use here (x to the right, y
239  * to the bottom and z to the front) */
240  template <typename PointCloudTypeWithViewpoints> void
241  createFromPointCloudWithViewpoints (const PointCloudTypeWithViewpoints& point_cloud, float angular_resolution,
242  float max_angle_width, float max_angle_height,
243  CoordinateFrame coordinate_frame=CAMERA_FRAME, float noise_level=0.0f,
244  float min_range=0.0f, int border_size=0);
245 
246  /** \brief Create the depth image from a point cloud, using the average viewpoint of the points
247  * (vp_x,vp_y,vp_z in the point type) in the point cloud as sensor pose (assuming a rotation of (0,0,0)).
248  * \param point_cloud the input point cloud
249  * \param angular_resolution_x the angular difference (in radians) between the
250  * individual pixels in the image in the x-direction
251  * \param angular_resolution_y the angular difference (in radians) between the
252  * individual pixels in the image in the y-direction
253  * \param max_angle_width an angle (in radians) defining the horizontal bounds of the sensor
254  * \param max_angle_height an angle (in radians) defining the vertical bounds of the sensor
255  * \param coordinate_frame the coordinate frame (defaults to CAMERA_FRAME)
256  * \param noise_level - The distance in meters inside of which the z-buffer will not use the minimum,
257  * but the mean of the points. If 0.0 it is equivalent to a normal z-buffer and
258  * will always take the minimum per cell.
259  * \param min_range the minimum visible range (defaults to 0)
260  * \param border_size the border size (defaults to 0)
261  * \note If wrong_coordinate_system is true, the sensor pose will be rotated to change from a coordinate frame
262  * with x to the front, y to the left and z to the top to the coordinate frame we use here (x to the right, y
263  * to the bottom and z to the front) */
264  template <typename PointCloudTypeWithViewpoints> void
265  createFromPointCloudWithViewpoints (const PointCloudTypeWithViewpoints& point_cloud,
266  float angular_resolution_x, float angular_resolution_y,
267  float max_angle_width, float max_angle_height,
268  CoordinateFrame coordinate_frame=CAMERA_FRAME, float noise_level=0.0f,
269  float min_range=0.0f, int border_size=0);
270 
271  /** \brief Create an empty depth image (filled with unobserved points)
272  * \param[in] angular_resolution the angle (in radians) between each sample in the depth image
273  * \param[in] sensor_pose an affine matrix defining the pose of the sensor (defaults to Eigen::Affine3f::Identity () )
274  * \param[in] coordinate_frame the coordinate frame (defaults to CAMERA_FRAME)
275  * \param[in] angle_width an angle (in radians) defining the horizontal bounds of the sensor (defaults to 2*pi (360deg))
276  * \param[in] angle_height an angle (in radians) defining the vertical bounds of the sensor (defaults to pi (180deg))
277  */
278  void
279  createEmpty (float angular_resolution, const Eigen::Affine3f& sensor_pose=Eigen::Affine3f::Identity (),
280  RangeImage::CoordinateFrame coordinate_frame=CAMERA_FRAME, float angle_width=pcl::deg2rad (360.0f),
281  float angle_height=pcl::deg2rad (180.0f));
282 
283  /** \brief Create an empty depth image (filled with unobserved points)
284  * \param angular_resolution_x the angular difference (in radians) between the
285  * individual pixels in the image in the x-direction
286  * \param angular_resolution_y the angular difference (in radians) between the
287  * individual pixels in the image in the y-direction
288  * \param[in] sensor_pose an affine matrix defining the pose of the sensor (defaults to Eigen::Affine3f::Identity () )
289  * \param[in] coordinate_frame the coordinate frame (defaults to CAMERA_FRAME)
290  * \param[in] angle_width an angle (in radians) defining the horizontal bounds of the sensor (defaults to 2*pi (360deg))
291  * \param[in] angle_height an angle (in radians) defining the vertical bounds of the sensor (defaults to pi (180deg))
292  */
293  void
294  createEmpty (float angular_resolution_x, float angular_resolution_y,
295  const Eigen::Affine3f& sensor_pose=Eigen::Affine3f::Identity (),
296  RangeImage::CoordinateFrame coordinate_frame=CAMERA_FRAME, float angle_width=pcl::deg2rad (360.0f),
297  float angle_height=pcl::deg2rad (180.0f));
298 
299  /** \brief Integrate the given point cloud into the current range image using a z-buffer
300  * \param point_cloud the input point cloud
301  * \param noise_level - The distance in meters inside of which the z-buffer will not use the minimum,
302  * but the mean of the points. If 0.0 it is equivalent to a normal z-buffer and
303  * will always take the minimum per cell.
304  * \param min_range the minimum visible range
305  * \param top returns the minimum y pixel position in the image where a point was added
306  * \param right returns the maximum x pixel position in the image where a point was added
307  * \param bottom returns the maximum y pixel position in the image where a point was added
308  * \param left returns the minimum x pixel position in the image where a point was added
309  */
310  template <typename PointCloudType> void
311  doZBuffer (const PointCloudType& point_cloud, float noise_level,
312  float min_range, int& top, int& right, int& bottom, int& left);
313 
314  /** \brief Integrates the given far range measurements into the range image */
315  template <typename PointCloudType> void
316  integrateFarRanges (const PointCloudType& far_ranges);
317 
318  /** \brief Cut the range image to the minimal size so that it still contains all actual range readings.
319  * \param border_size allows increase from the minimal size by the specified number of pixels (defaults to 0)
320  * \param top if positive, this value overrides the position of the top edge (defaults to -1)
321  * \param right if positive, this value overrides the position of the right edge (defaults to -1)
322  * \param bottom if positive, this value overrides the position of the bottom edge (defaults to -1)
323  * \param left if positive, this value overrides the position of the left edge (defaults to -1)
324  */
325  PCL_EXPORTS void
326  cropImage (int border_size=0, int top=-1, int right=-1, int bottom=-1, int left=-1);
327 
328  /** \brief Get all the range values in one float array of size width*height
329  * \return a pointer to a new float array containing the range values
330  * \note This method allocates a new float array; the caller is responsible for freeing this memory.
331  */
332  PCL_EXPORTS float*
333  getRangesArray () const;
334 
335  /** Getter for the transformation from the world system into the range image system
336  * (the sensor coordinate frame) */
337  inline const Eigen::Affine3f&
339 
340  /** Setter for the transformation from the range image system
341  * (the sensor coordinate frame) into the world system */
342  inline void
343  setTransformationToRangeImageSystem (const Eigen::Affine3f& to_range_image_system);
344 
345  /** Getter for the transformation from the range image system
346  * (the sensor coordinate frame) into the world system */
347  inline const Eigen::Affine3f&
349 
350  /** Getter for the angular resolution of the range image in x direction in radians per pixel.
351  * Provided for downwards compatibility */
352  inline float
354 
355  /** Getter for the angular resolution of the range image in x direction in radians per pixel. */
356  inline float
358 
359  /** Getter for the angular resolution of the range image in y direction in radians per pixel. */
360  inline float
362 
363  /** Getter for the angular resolution of the range image in x and y direction (in radians). */
364  inline void
365  getAngularResolution (float& angular_resolution_x, float& angular_resolution_y) const;
366 
367  /** \brief Set the angular resolution of the range image
368  * \param angular_resolution the new angular resolution in x and y direction (in radians per pixel)
369  */
370  inline void
371  setAngularResolution (float angular_resolution);
372 
373  /** \brief Set the angular resolution of the range image
374  * \param angular_resolution_x the new angular resolution in x direction (in radians per pixel)
375  * \param angular_resolution_y the new angular resolution in y direction (in radians per pixel)
376  */
377  inline void
378  setAngularResolution (float angular_resolution_x, float angular_resolution_y);
379 
380 
381  /** \brief Return the 3D point with range at the given image position
382  * \param image_x the x coordinate
383  * \param image_y the y coordinate
384  * \return the point at the specified location (returns unobserved_point if outside of the image bounds)
385  */
386  inline const PointWithRange&
387  getPoint (int image_x, int image_y) const;
388 
389  /** \brief Non-const-version of getPoint */
390  inline PointWithRange&
391  getPoint (int image_x, int image_y);
392 
393  /** Return the 3d point with range at the given image position */
394  inline const PointWithRange&
395  getPoint (float image_x, float image_y) const;
396 
397  /** Non-const-version of the above */
398  inline PointWithRange&
399  getPoint (float image_x, float image_y);
400 
401  /** \brief Return the 3D point with range at the given image position. This methd performs no error checking
402  * to make sure the specified image position is inside of the image!
403  * \param image_x the x coordinate
404  * \param image_y the y coordinate
405  * \return the point at the specified location (program may fail if the location is outside of the image bounds)
406  */
407  inline const PointWithRange&
408  getPointNoCheck (int image_x, int image_y) const;
409 
410  /** Non-const-version of getPointNoCheck */
411  inline PointWithRange&
412  getPointNoCheck (int image_x, int image_y);
413 
414  /** Same as above */
415  inline void
416  getPoint (int image_x, int image_y, Eigen::Vector3f& point) const;
417 
418  /** Same as above */
419  inline void
420  getPoint (int index, Eigen::Vector3f& point) const;
421 
422  /** Same as above */
423  inline const Eigen::Map<const Eigen::Vector3f>
424  getEigenVector3f (int x, int y) const;
425 
426  /** Same as above */
427  inline const Eigen::Map<const Eigen::Vector3f>
428  getEigenVector3f (int index) const;
429 
430  /** Return the 3d point with range at the given index (whereas index=y*width+x) */
431  inline const PointWithRange&
432  getPoint (int index) const;
433 
434  /** Calculate the 3D point according to the given image point and range */
435  inline void
436  calculate3DPoint (float image_x, float image_y, float range, PointWithRange& point) const;
437  /** Calculate the 3D point according to the given image point and the range value at the closest pixel */
438  inline void
439  calculate3DPoint (float image_x, float image_y, PointWithRange& point) const;
440 
441  /** Calculate the 3D point according to the given image point and range */
442  virtual inline void
443  calculate3DPoint (float image_x, float image_y, float range, Eigen::Vector3f& point) const;
444  /** Calculate the 3D point according to the given image point and the range value at the closest pixel */
445  inline void
446  calculate3DPoint (float image_x, float image_y, Eigen::Vector3f& point) const;
447 
448  /** Recalculate all 3D point positions according to their pixel position and range */
449  PCL_EXPORTS void
451 
452  /** Get imagePoint from 3D point in world coordinates */
453  inline virtual void
454  getImagePoint (const Eigen::Vector3f& point, float& image_x, float& image_y, float& range) const;
455 
456  /** Same as above */
457  inline void
458  getImagePoint (const Eigen::Vector3f& point, int& image_x, int& image_y, float& range) const;
459 
460  /** Same as above */
461  inline void
462  getImagePoint (const Eigen::Vector3f& point, float& image_x, float& image_y) const;
463 
464  /** Same as above */
465  inline void
466  getImagePoint (const Eigen::Vector3f& point, int& image_x, int& image_y) const;
467 
468  /** Same as above */
469  inline void
470  getImagePoint (float x, float y, float z, float& image_x, float& image_y, float& range) const;
471 
472  /** Same as above */
473  inline void
474  getImagePoint (float x, float y, float z, float& image_x, float& image_y) const;
475 
476  /** Same as above */
477  inline void
478  getImagePoint (float x, float y, float z, int& image_x, int& image_y) const;
479 
480  /** point_in_image will be the point in the image at the position the given point would be. Returns
481  * the range of the given point. */
482  inline float
483  checkPoint (const Eigen::Vector3f& point, PointWithRange& point_in_image) const;
484 
485  /** Returns the difference in range between the given point and the range of the point in the image
486  * at the position the given point would be.
487  * (Return value is point_in_image.range-given_point.range) */
488  inline float
489  getRangeDifference (const Eigen::Vector3f& point) const;
490 
491  /** Get the image point corresponding to the given angles */
492  inline void
493  getImagePointFromAngles (float angle_x, float angle_y, float& image_x, float& image_y) const;
494 
495  /** Get the angles corresponding to the given image point */
496  inline void
497  getAnglesFromImagePoint (float image_x, float image_y, float& angle_x, float& angle_y) const;
498 
499  /** Transforms an image point in float values to an image point in int values */
500  inline void
501  real2DToInt2D (float x, float y, int& xInt, int& yInt) const;
502 
503  /** Check if a point is inside of the image */
504  inline bool
505  isInImage (int x, int y) const;
506 
507  /** Check if a point is inside of the image and has a finite range */
508  inline bool
509  isValid (int x, int y) const;
510 
511  /** Check if a point has a finite range */
512  inline bool
513  isValid (int index) const;
514 
515  /** Check if a point is inside of the image and has either a finite range or a max reading (range=INFINITY) */
516  inline bool
517  isObserved (int x, int y) const;
518 
519  /** Check if a point is a max range (range=INFINITY) - please check isInImage or isObserved first! */
520  inline bool
521  isMaxRange (int x, int y) const;
522 
523  /** Calculate the normal of an image point using the neighbors with a maximum pixel distance of radius.
524  * step_size determines how many pixels are used. 1 means all, 2 only every second, etc..
525  * Returns false if it was unable to calculate a normal.*/
526  inline bool
527  getNormal (int x, int y, int radius, Eigen::Vector3f& normal, int step_size=1) const;
528 
529  /** Same as above, but only the no_of_nearest_neighbors points closest to the given point are considered. */
530  inline bool
531  getNormalForClosestNeighbors (int x, int y, int radius, const PointWithRange& point,
532  int no_of_nearest_neighbors, Eigen::Vector3f& normal, int step_size=1) const;
533 
534  /** Same as above */
535  inline bool
536  getNormalForClosestNeighbors (int x, int y, int radius, const Eigen::Vector3f& point,
537  int no_of_nearest_neighbors, Eigen::Vector3f& normal,
538  Eigen::Vector3f* point_on_plane=nullptr, int step_size=1) const;
539 
540  /** Same as above, using default values */
541  inline bool
542  getNormalForClosestNeighbors (int x, int y, Eigen::Vector3f& normal, int radius=2) const;
543 
544  /** Same as above but extracts some more data and can also return the extracted
545  * information for all neighbors in radius if normal_all_neighbors is not NULL */
546  inline bool
547  getSurfaceInformation (int x, int y, int radius, const Eigen::Vector3f& point,
548  int no_of_closest_neighbors, int step_size,
549  float& max_closest_neighbor_distance_squared,
550  Eigen::Vector3f& normal, Eigen::Vector3f& mean, Eigen::Vector3f& eigen_values,
551  Eigen::Vector3f* normal_all_neighbors=nullptr,
552  Eigen::Vector3f* mean_all_neighbors=nullptr,
553  Eigen::Vector3f* eigen_values_all_neighbors=nullptr) const;
554 
555  // Return the squared distance to the n-th neighbors of the point at x,y
556  inline float
557  getSquaredDistanceOfNthNeighbor (int x, int y, int radius, int n, int step_size) const;
558 
559  /** Calculate the impact angle based on the sensor position and the two given points - will return
560  * -INFINITY if one of the points is unobserved */
561  inline float
562  getImpactAngle (const PointWithRange& point1, const PointWithRange& point2) const;
563  //! Same as above
564  inline float
565  getImpactAngle (int x1, int y1, int x2, int y2) const;
566 
567  /** Extract a local normal (with a heuristic not to include background points) and calculate the impact
568  * angle based on this */
569  inline float
570  getImpactAngleBasedOnLocalNormal (int x, int y, int radius) const;
571  /** Uses the above function for every point in the image */
572  PCL_EXPORTS float*
573  getImpactAngleImageBasedOnLocalNormals (int radius) const;
574 
575  /** Calculate a score [0,1] that tells how acute the impact angle is (1.0f - getImpactAngle/90deg)
576  * This uses getImpactAngleBasedOnLocalNormal
577  * Will return -INFINITY if no normal could be calculated */
578  inline float
579  getNormalBasedAcutenessValue (int x, int y, int radius) const;
580 
581  /** Calculate a score [0,1] that tells how acute the impact angle is (1.0f - getImpactAngle/90deg)
582  * will return -INFINITY if one of the points is unobserved */
583  inline float
584  getAcutenessValue (const PointWithRange& point1, const PointWithRange& point2) const;
585  //! Same as above
586  inline float
587  getAcutenessValue (int x1, int y1, int x2, int y2) const;
588 
589  /** Calculate getAcutenessValue for every point */
590  PCL_EXPORTS void
591  getAcutenessValueImages (int pixel_distance, float*& acuteness_value_image_x,
592  float*& acuteness_value_image_y) const;
593 
594  /** Calculates, how much the surface changes at a point. Pi meaning a flat suface and 0.0f
595  * would be a needle point */
596  //inline float
597  // getSurfaceChange (const PointWithRange& point, const PointWithRange& neighbor1,
598  // const PointWithRange& neighbor2) const;
599 
600  /** Calculates, how much the surface changes at a point. 1 meaning a 90deg angle and 0 a flat suface */
601  PCL_EXPORTS float
602  getSurfaceChange (int x, int y, int radius) const;
603 
604  /** Uses the above function for every point in the image */
605  PCL_EXPORTS float*
606  getSurfaceChangeImage (int radius) const;
607 
608  /** Calculates, how much the surface changes at a point. Returns an angle [0.0f, PI] for x and y direction.
609  * A return value of -INFINITY means that a point was unobserved. */
610  inline void
611  getSurfaceAngleChange (int x, int y, int radius, float& angle_change_x, float& angle_change_y) const;
612 
613  /** Uses the above function for every point in the image */
614  PCL_EXPORTS void
615  getSurfaceAngleChangeImages (int radius, float*& angle_change_image_x, float*& angle_change_image_y) const;
616 
617  /** Calculates the curvature in a point using pca */
618  inline float
619  getCurvature (int x, int y, int radius, int step_size) const;
620 
621  //! Get the sensor position
622  inline const Eigen::Vector3f
623  getSensorPos () const;
624 
625  /** Sets all -INFINITY values to INFINITY */
626  PCL_EXPORTS void
628 
629  //! Getter for image_offset_x_
630  inline int
631  getImageOffsetX () const { return image_offset_x_;}
632  //! Getter for image_offset_y_
633  inline int
634  getImageOffsetY () const { return image_offset_y_;}
635 
636  //! Setter for image offsets
637  inline void
638  setImageOffsets (int offset_x, int offset_y) { image_offset_x_=offset_x; image_offset_y_=offset_y;}
639 
640 
641 
642  /** Get a sub part of the complete image as a new range image.
643  * \param sub_image_image_offset_x - The x coordinate of the top left pixel of the sub image.
644  * This is always according to absolute 0,0 meaning -180°,-90°
645  * and it is already in the system of the new image, so the
646  * actual pixel used in the original image is
647  * combine_pixels* (image_offset_x-image_offset_x_)
648  * \param sub_image_image_offset_y - Same as image_offset_x for the y coordinate
649  * \param sub_image_width - width of the new image
650  * \param sub_image_height - height of the new image
651  * \param combine_pixels - shrinking factor, meaning the new angular resolution
652  * is combine_pixels times the old one
653  * \param sub_image - the output image
654  */
655  virtual void
656  getSubImage (int sub_image_image_offset_x, int sub_image_image_offset_y, int sub_image_width,
657  int sub_image_height, int combine_pixels, RangeImage& sub_image) const;
658 
659  //! Get a range image with half the resolution
660  virtual void
661  getHalfImage (RangeImage& half_image) const;
662 
663  //! Find the minimum and maximum range in the image
664  PCL_EXPORTS void
665  getMinMaxRanges (float& min_range, float& max_range) const;
666 
667  //! This function sets the sensor pose to 0 and transforms all point positions to this local coordinate frame
668  PCL_EXPORTS void
670 
671  /** Calculate a range patch as the z values of the coordinate frame given by pose.
672  * The patch will have size pixel_size x pixel_size and each pixel
673  * covers world_size/pixel_size meters in the world
674  * You are responsible for deleting the structure afterwards! */
675  PCL_EXPORTS float*
676  getInterpolatedSurfaceProjection (const Eigen::Affine3f& pose, int pixel_size, float world_size) const;
677 
678  //! Same as above, but using the local coordinate frame defined by point and the viewing direction
679  PCL_EXPORTS float*
680  getInterpolatedSurfaceProjection (const Eigen::Vector3f& point, int pixel_size, float world_size) const;
681 
682  //! Get the local coordinate frame with 0,0,0 in point, upright and Z as the viewing direction
683  inline Eigen::Affine3f
684  getTransformationToViewerCoordinateFrame (const Eigen::Vector3f& point) const;
685  //! Same as above, using a reference for the retrurn value
686  inline void
687  getTransformationToViewerCoordinateFrame (const Eigen::Vector3f& point,
688  Eigen::Affine3f& transformation) const;
689  //! Same as above, but only returning the rotation
690  inline void
691  getRotationToViewerCoordinateFrame (const Eigen::Vector3f& point, Eigen::Affine3f& transformation) const;
692 
693  /** Get a local coordinate frame at the given point based on the normal. */
694  PCL_EXPORTS bool
695  getNormalBasedUprightTransformation (const Eigen::Vector3f& point,
696  float max_dist, Eigen::Affine3f& transformation) const;
697 
698  /** Get the integral image of the range values (used for fast blur operations).
699  * You are responsible for deleting it after usage! */
700  PCL_EXPORTS void
701  getIntegralImage (float*& integral_image, int*& valid_points_num_image) const;
702 
703  /** Get a blurred version of the range image using box filters on the provided integral image*/
704  PCL_EXPORTS void // Template necessary so that this function also works in derived classes
705  getBlurredImageUsingIntegralImage (int blur_radius, float* integral_image, int* valid_points_num_image,
706  RangeImage& range_image) const;
707 
708  /** Get a blurred version of the range image using box filters */
709  PCL_EXPORTS virtual void // Template necessary so that this function also works in derived classes
710  getBlurredImage (int blur_radius, RangeImage& range_image) const;
711 
712  /** Get the squared euclidean distance between the two image points.
713  * Returns -INFINITY if one of the points was not observed */
714  inline float
715  getEuclideanDistanceSquared (int x1, int y1, int x2, int y2) const;
716  //! Doing the above for some steps in the given direction and averaging
717  inline float
718  getAverageEuclideanDistance (int x, int y, int offset_x, int offset_y, int max_steps) const;
719 
720  //! Project all points on the local plane approximation, thereby smoothing the surface of the scan
721  PCL_EXPORTS void
722  getRangeImageWithSmoothedSurface (int radius, RangeImage& smoothed_range_image) const;
723  //void getLocalNormals (int radius) const;
724 
725  /** Calculates the average 3D position of the no_of_points points described by the start
726  * point x,y in the direction delta.
727  * Returns a max range point (range=INFINITY) if the first point is max range and an
728  * unobserved point (range=-INFINITY) if non of the points is observed. */
729  inline void
730  get1dPointAverage (int x, int y, int delta_x, int delta_y, int no_of_points,
731  PointWithRange& average_point) const;
732 
733  /** Calculates the overlap of two range images given the relative transformation
734  * (from the given image to *this) */
735  PCL_EXPORTS float
736  getOverlap (const RangeImage& other_range_image, const Eigen::Affine3f& relative_transformation,
737  int search_radius, float max_distance, int pixel_step=1) const;
738 
739  /** Get the viewing direction for the given point */
740  inline bool
741  getViewingDirection (int x, int y, Eigen::Vector3f& viewing_direction) const;
742 
743  /** Get the viewing direction for the given point */
744  inline void
745  getViewingDirection (const Eigen::Vector3f& point, Eigen::Vector3f& viewing_direction) const;
746 
747  /** Return a newly created Range image.
748  * Can be reimplemented in derived classes like RangeImagePlanar to return an image of the same type. */
749  PCL_EXPORTS virtual RangeImage*
750  getNew () const { return new RangeImage; }
751 
752  /** Copy other to *this. Necessary for use in virtual functions that need to copy derived RangeImage classes (like RangeImagePlanar) */
753  PCL_EXPORTS virtual void
754  copyTo (RangeImage& other) const;
755 
756 
757  // =====MEMBER VARIABLES=====
758  // BaseClass:
759  // roslib::Header header;
760  // std::vector<PointT> points;
761  // std::uint32_t width;
762  // std::uint32_t height;
763  // bool is_dense;
764 
765  static bool debug; /**< Just for... well... debugging purposes. :-) */
766 
767  protected:
768  // =====PROTECTED MEMBER VARIABLES=====
769  Eigen::Affine3f to_range_image_system_; /**< Inverse of to_world_system_ */
770  Eigen::Affine3f to_world_system_; /**< Inverse of to_range_image_system_ */
771  float angular_resolution_x_; /**< Angular resolution of the range image in x direction in radians per pixel */
772  float angular_resolution_y_; /**< Angular resolution of the range image in y direction in radians per pixel */
773  float angular_resolution_x_reciprocal_; /**< 1.0/angular_resolution_x_ - provided for better performance of
774  * multiplication compared to division */
775  float angular_resolution_y_reciprocal_; /**< 1.0/angular_resolution_y_ - provided for better performance of
776  * multiplication compared to division */
777  int image_offset_x_, image_offset_y_; /**< Position of the top left corner of the range image compared to
778  * an image of full size (360x180 degrees) */
779  PointWithRange unobserved_point; /**< This point is used to be able to return
780  * a reference to a non-existing point */
781 
782  // =====PROTECTED METHODS=====
783 
784 
785  // =====STATIC PROTECTED=====
786  static const int lookup_table_size;
787  static std::vector<float> asin_lookup_table;
788  static std::vector<float> atan_lookup_table;
789  static std::vector<float> cos_lookup_table;
790  /** Create lookup tables for trigonometric functions */
791  static void
793 
794  /** Query the asin lookup table */
795  static inline float
796  asinLookUp (float value);
797 
798  /** Query the std::atan2 lookup table */
799  static inline float
800  atan2LookUp (float y, float x);
801 
802  /** Query the cos lookup table */
803  static inline float
804  cosLookUp (float value);
805 
806 
807  public:
809  };
810 
811  /**
812  * /ingroup range_image
813  */
814  inline std::ostream&
815  operator<< (std::ostream& os, const RangeImage& r)
816  {
817  os << "header: " << std::endl;
818  os << r.header;
819  os << "points[]: " << r.points.size () << std::endl;
820  os << "width: " << r.width << std::endl;
821  os << "height: " << r.height << std::endl;
822  os << "sensor_origin_: "
823  << r.sensor_origin_[0] << ' '
824  << r.sensor_origin_[1] << ' '
825  << r.sensor_origin_[2] << std::endl;
826  os << "sensor_orientation_: "
827  << r.sensor_orientation_.x () << ' '
828  << r.sensor_orientation_.y () << ' '
829  << r.sensor_orientation_.z () << ' '
830  << r.sensor_orientation_.w () << std::endl;
831  os << "is_dense: " << r.is_dense << std::endl;
832  os << "angular resolution: "
833  << RAD2DEG (r.getAngularResolutionX ()) << "deg/pixel in x and "
834  << RAD2DEG (r.getAngularResolutionY ()) << "deg/pixel in y.\n" << std::endl;
835  return (os);
836  }
837 
838 } // namespace end
839 
840 
841 #include <pcl/range_image/impl/range_image.hpp> // Definitions of templated and inline functions
float getImpactAngleBasedOnLocalNormal(int x, int y, int radius) const
Extract a local normal (with a heuristic not to include background points) and calculate the impact a...
bool isValid(int x, int y) const
Check if a point is inside of the image and has a finite range.
Ptr makeShared()
Get a boost shared pointer of a copy of this.
Definition: range_image.h:125
void createFromPointCloudWithViewpoints(const PointCloudTypeWithViewpoints &point_cloud, float angular_resolution, float max_angle_width, float max_angle_height, CoordinateFrame coordinate_frame=CAMERA_FRAME, float noise_level=0.0f, float min_range=0.0f, int border_size=0)
Create the depth image from a point cloud, using the average viewpoint of the points (vp_x...
virtual void getHalfImage(RangeImage &half_image) const
Get a range image with half the resolution.
virtual PCL_EXPORTS ~RangeImage()=default
Destructor.
float angular_resolution_x_
Angular resolution of the range image in x direction in radians per pixel.
Definition: range_image.h:771
float deg2rad(float alpha)
Convert an angle from degrees to radians.
Definition: angles.hpp:67
void getSurfaceAngleChange(int x, int y, int radius, float &angle_change_x, float &angle_change_y) const
Calculates, how much the surface changes at a point.
A point structure representing Euclidean xyz coordinates, padded with an extra range float...
virtual PCL_EXPORTS RangeImage * getNew() const
Return a newly created Range image.
Definition: range_image.h:750
std::vector< PointT, Eigen::aligned_allocator< PointT > > points
The point data.
Definition: point_cloud.h:410
virtual PCL_EXPORTS void getBlurredImage(int blur_radius, RangeImage &range_image) const
Get a blurred version of the range image using box filters.
PCL_EXPORTS void getIntegralImage(float *&integral_image, int *&valid_points_num_image) const
Get the integral image of the range values (used for fast blur operations).
float getEuclideanDistanceSquared(int x1, int y1, int x2, int y2) const
Get the squared euclidean distance between the two image points.
Eigen::Affine3f getTransformationToViewerCoordinateFrame(const Eigen::Vector3f &point) const
Get the local coordinate frame with 0,0,0 in point, upright and Z as the viewing direction.
void setImageOffsets(int offset_x, int offset_y)
Setter for image offsets.
Definition: range_image.h:638
RangeImage is derived from pcl/PointCloud and provides functionalities with focus on situations where...
Definition: range_image.h:55
PCL_EXPORTS float * getImpactAngleImageBasedOnLocalNormals(int radius) const
Uses the above function for every point in the image.
float getAverageEuclideanDistance(int x, int y, int offset_x, int offset_y, int max_steps) const
Doing the above for some steps in the given direction and averaging.
const PointWithRange & getPoint(int image_x, int image_y) const
Return the 3D point with range at the given image position.
int image_offset_y_
Position of the top left corner of the range image compared to an image of full size (360x180 degrees...
Definition: range_image.h:777
bool getViewingDirection(int x, int y, Eigen::Vector3f &viewing_direction) const
Get the viewing direction for the given point.
shared_ptr< RangeImage > Ptr
Definition: range_image.h:61
const Eigen::Affine3f & getTransformationToRangeImageSystem() const
Getter for the transformation from the world system into the range image system (the sensor coordinat...
Definition: range_image.h:338
bool getNormalForClosestNeighbors(int x, int y, int radius, const PointWithRange &point, int no_of_nearest_neighbors, Eigen::Vector3f &normal, int step_size=1) const
Same as above, but only the no_of_nearest_neighbors points closest to the given point are considered...
float getNormalBasedAcutenessValue(int x, int y, int radius) const
Calculate a score [0,1] that tells how acute the impact angle is (1.0f - getImpactAngle/90deg) This u...
const Eigen::Vector3f getSensorPos() const
Get the sensor position.
virtual void getImagePoint(const Eigen::Vector3f &point, float &image_x, float &image_y, float &range) const
Get imagePoint from 3D point in world coordinates.
bool getNormal(int x, int y, int radius, Eigen::Vector3f &normal, int step_size=1) const
Calculate the normal of an image point using the neighbors with a maximum pixel distance of radius...
void createFromPointCloudWithKnownSize(const PointCloudType &point_cloud, float angular_resolution, const Eigen::Vector3f &point_cloud_center, float point_cloud_radius, const Eigen::Affine3f &sensor_pose=Eigen::Affine3f::Identity(), CoordinateFrame coordinate_frame=CAMERA_FRAME, float noise_level=0.0f, float min_range=0.0f, int border_size=0)
Create the depth image from a point cloud, getting a hint about the size of the scene for faster calc...
static PCL_EXPORTS void getCoordinateFrameTransformation(RangeImage::CoordinateFrame coordinate_frame, Eigen::Affine3f &transformation)
Get the transformation that transforms the given coordinate frame into CAMERA_FRAME.
static PCL_EXPORTS void extractFarRanges(const pcl::PCLPointCloud2 &point_cloud_data, PointCloud< PointWithViewpoint > &far_ranges)
Check if the provided data includes far ranges and add them to far_ranges.
static void createLookupTables()
Create lookup tables for trigonometric functions.
void real2DToInt2D(float x, float y, int &xInt, int &yInt) const
Transforms an image point in float values to an image point in int values.
static const int lookup_table_size
Definition: range_image.h:786
static Eigen::Vector3f getEigenVector3f(const PointWithRange &point)
Get Eigen::Vector3f from PointWithRange.
#define PCL_MAKE_ALIGNED_OPERATOR_NEW
Macro to signal a class requires a custom allocator.
Definition: memory.h:63
virtual void getSubImage(int sub_image_image_offset_x, int sub_image_image_offset_y, int sub_image_width, int sub_image_height, int combine_pixels, RangeImage &sub_image) const
Get a sub part of the complete image as a new range image.
std::ostream & operator<<(std::ostream &os, const BivariatePolynomialT< real > &p)
void getAnglesFromImagePoint(float image_x, float image_y, float &angle_x, float &angle_y) const
Get the angles corresponding to the given image point.
void calculate3DPoint(float image_x, float image_y, float range, PointWithRange &point) const
Calculate the 3D point according to the given image point and range.
PCL_EXPORTS void reset()
Reset all values to an empty range image.
std::uint32_t width
The point cloud width (if organized as an image-structure).
Definition: point_cloud.h:413
Eigen::Vector4f sensor_origin_
Sensor acquisition pose (origin/translation).
Definition: point_cloud.h:421
void setTransformationToRangeImageSystem(const Eigen::Affine3f &to_range_image_system)
Setter for the transformation from the range image system (the sensor coordinate frame) into the worl...
float getImpactAngle(const PointWithRange &point1, const PointWithRange &point2) const
Calculate the impact angle based on the sensor position and the two given points - will return -INFIN...
static float getMaxAngleSize(const Eigen::Affine3f &viewer_pose, const Eigen::Vector3f &center, float radius)
Get the size of a certain area when seen from the given pose.
PCL_EXPORTS float getOverlap(const RangeImage &other_range_image, const Eigen::Affine3f &relative_transformation, int search_radius, float max_distance, int pixel_step=1) const
Calculates the overlap of two range images given the relative transformation (from the given image to...
bool isInImage(int x, int y) const
Check if a point is inside of the image.
PCL_EXPORTS float * getSurfaceChangeImage(int radius) const
Uses the above function for every point in the image.
int getImageOffsetY() const
Getter for image_offset_y_.
Definition: range_image.h:634
bool getSurfaceInformation(int x, int y, int radius, const Eigen::Vector3f &point, int no_of_closest_neighbors, int step_size, float &max_closest_neighbor_distance_squared, Eigen::Vector3f &normal, Eigen::Vector3f &mean, Eigen::Vector3f &eigen_values, Eigen::Vector3f *normal_all_neighbors=nullptr, Eigen::Vector3f *mean_all_neighbors=nullptr, Eigen::Vector3f *eigen_values_all_neighbors=nullptr) const
Same as above but extracts some more data and can also return the extracted information for all neigh...
int getImageOffsetX() const
Getter for image_offset_x_.
Definition: range_image.h:631
PCL_EXPORTS void setUnseenToMaxRange()
Sets all -INFINITY values to INFINITY.
float getCurvature(int x, int y, int radius, int step_size) const
Calculates the curvature in a point using pca.
static std::vector< float > cos_lookup_table
Definition: range_image.h:789
void createEmpty(float angular_resolution, const Eigen::Affine3f &sensor_pose=Eigen::Affine3f::Identity(), RangeImage::CoordinateFrame coordinate_frame=CAMERA_FRAME, float angle_width=pcl::deg2rad(360.0f), float angle_height=pcl::deg2rad(180.0f))
Create an empty depth image (filled with unobserved points)
void get1dPointAverage(int x, int y, int delta_x, int delta_y, int no_of_points, PointWithRange &average_point) const
Calculates the average 3D position of the no_of_points points described by the start point x...
virtual PCL_EXPORTS void copyTo(RangeImage &other) const
Copy other to *this.
PCL_EXPORTS void getRangeImageWithSmoothedSurface(int radius, RangeImage &smoothed_range_image) const
Project all points on the local plane approximation, thereby smoothing the surface of the scan...
void doZBuffer(const PointCloudType &point_cloud, float noise_level, float min_range, int &top, int &right, int &bottom, int &left)
Integrate the given point cloud into the current range image using a z-buffer.
Eigen::Quaternionf sensor_orientation_
Sensor acquisition pose (rotation).
Definition: point_cloud.h:423
void getRotationToViewerCoordinateFrame(const Eigen::Vector3f &point, Eigen::Affine3f &transformation) const
Same as above, but only returning the rotation.
static float atan2LookUp(float y, float x)
Query the std::atan2 lookup table.
Definition: range_image.hpp:63
PCL_EXPORTS float getSurfaceChange(int x, int y, int radius) const
Calculates, how much the surface changes at a point.
std::uint32_t height
The point cloud height (if organized as an image-structure).
Definition: point_cloud.h:415
void createFromPointCloud(const PointCloudType &point_cloud, float angular_resolution=pcl::deg2rad(0.5f), float max_angle_width=pcl::deg2rad(360.0f), float max_angle_height=pcl::deg2rad(180.0f), const Eigen::Affine3f &sensor_pose=Eigen::Affine3f::Identity(), CoordinateFrame coordinate_frame=CAMERA_FRAME, float noise_level=0.0f, float min_range=0.0f, int border_size=0)
Create the depth image from a point cloud.
Definition: range_image.hpp:97
static std::vector< float > asin_lookup_table
Definition: range_image.h:787
std::vector< Eigen::Vector3f, Eigen::aligned_allocator< Eigen::Vector3f > > VectorOfEigenVector3f
Definition: range_image.h:60
PCL_EXPORTS void recalculate3DPointPositions()
Recalculate all 3D point positions according to their pixel position and range.
PointCloud represents the base class in PCL for storing collections of 3D points. ...
float angular_resolution_y_reciprocal_
1.0/angular_resolution_y_ - provided for better performance of multiplication compared to division ...
Definition: range_image.h:775
pcl::PCLHeader header
The point cloud header.
Definition: point_cloud.h:407
void getImagePointFromAngles(float angle_x, float angle_y, float &image_x, float &image_y) const
Get the image point corresponding to the given angles.
PCL_EXPORTS void getSurfaceAngleChangeImages(int radius, float *&angle_change_image_x, float *&angle_change_image_y) const
Uses the above function for every point in the image.
float getAngularResolutionX() const
Getter for the angular resolution of the range image in x direction in radians per pixel...
Definition: range_image.h:357
float angular_resolution_x_reciprocal_
1.0/angular_resolution_x_ - provided for better performance of multiplication compared to division ...
Definition: range_image.h:773
const Eigen::Affine3f & getTransformationToWorldSystem() const
Getter for the transformation from the range image system (the sensor coordinate frame) into the worl...
Definition: range_image.h:348
PCL_EXPORTS void getBlurredImageUsingIntegralImage(int blur_radius, float *integral_image, int *valid_points_num_image, RangeImage &range_image) const
Get a blurred version of the range image using box filters on the provided integral image...
float getAngularResolutionY() const
Getter for the angular resolution of the range image in y direction in radians per pixel...
Definition: range_image.h:361
Eigen::Affine3f to_range_image_system_
Inverse of to_world_system_.
Definition: range_image.h:769
Eigen::Affine3f to_world_system_
Inverse of to_range_image_system_.
Definition: range_image.h:770
static int max_no_of_threads
The maximum number of openmp threads that can be used in this class.
Definition: range_image.h:79
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
static Eigen::Vector3f getAverageViewPoint(const PointCloudTypeWithViewpoints &point_cloud)
Get the average viewpoint of a point cloud where each point carries viewpoint information as vp_x...
void setAngularResolution(float angular_resolution)
Set the angular resolution of the range image.
const PointWithRange & getPointNoCheck(int image_x, int image_y) const
Return the 3D point with range at the given image position.
bool isObserved(int x, int y) const
Check if a point is inside of the image and has either a finite range or a max reading (range=INFINIT...
PCL_EXPORTS RangeImage()
Constructor.
PCL_EXPORTS void change3dPointsToLocalCoordinateFrame()
This function sets the sensor pose to 0 and transforms all point positions to this local coordinate f...
PCL_EXPORTS float * getInterpolatedSurfaceProjection(const Eigen::Affine3f &pose, int pixel_size, float world_size) const
Calculate a range patch as the z values of the coordinate frame given by pose.
static float cosLookUp(float value)
Query the cos lookup table.
Definition: range_image.hpp:89
float getRangeDifference(const Eigen::Vector3f &point) const
Returns the difference in range between the given point and the range of the point in the image at th...
PCL_EXPORTS void getMinMaxRanges(float &min_range, float &max_range) const
Find the minimum and maximum range in the image.
shared_ptr< const RangeImage > ConstPtr
Definition: range_image.h:62
static float asinLookUp(float value)
Query the asin lookup table.
Definition: range_image.hpp:53
PCL_EXPORTS float * getRangesArray() const
Get all the range values in one float array of size width*height.
float angular_resolution_y_
Angular resolution of the range image in y direction in radians per pixel.
Definition: range_image.h:772
float getAngularResolution() const
Getter for the angular resolution of the range image in x direction in radians per pixel...
Definition: range_image.h:353
PCL_EXPORTS bool getNormalBasedUprightTransformation(const Eigen::Vector3f &point, float max_dist, Eigen::Affine3f &transformation) const
Get a local coordinate frame at the given point based on the normal.
float getSquaredDistanceOfNthNeighbor(int x, int y, int radius, int n, int step_size) const
static bool debug
Just for...
Definition: range_image.h:765
static std::vector< float > atan_lookup_table
Definition: range_image.h:788
PointWithRange unobserved_point
This point is used to be able to return a reference to a non-existing point.
Definition: range_image.h:779
PCL_EXPORTS void getAcutenessValueImages(int pixel_distance, float *&acuteness_value_image_x, float *&acuteness_value_image_y) const
Calculate getAcutenessValue for every point.
bool isMaxRange(int x, int y) const
Check if a point is a max range (range=INFINITY) - please check isInImage or isObserved first! ...
PCL_EXPORTS void cropImage(int border_size=0, int top=-1, int right=-1, int bottom=-1, int left=-1)
Cut the range image to the minimal size so that it still contains all actual range readings...
float checkPoint(const Eigen::Vector3f &point, PointWithRange &point_in_image) const
point_in_image will be the point in the image at the position the given point would be...
float getAcutenessValue(const PointWithRange &point1, const PointWithRange &point2) const
Calculate a score [0,1] that tells how acute the impact angle is (1.0f - getImpactAngle/90deg) will r...
void integrateFarRanges(const PointCloudType &far_ranges)
Integrates the given far range measurements into the range image.