jerryzeng/thirdParty
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
thirdParty/PCL 1.12.0/include/pcl-1.12/pcl/range_image/range_image.h

841 lines
44 KiB
C
Raw Normal View History

thirdParty (VzNLSDK, PCL 1.12.0, opencv) initial check in
2025-06-11 21:59:23 +08:00
/*
* Software License Agreement (BSD License)
*
* Point Cloud Library (PCL) - www.pointclouds.org
* Copyright (c) 2010-2012, Willow Garage, Inc.
* Copyright (c) 2012-, Open Perception, Inc.
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of the copyright holder(s) nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#pragma once
#include <pcl/memory.h>
#include <pcl/point_cloud.h>
#include <pcl/pcl_macros.h>
#include <pcl/point_types.h>
#include <pcl/common/angles.h> // for deg2rad
namespace pcl { struct PCLPointCloud2; }
namespace pcl
{
/** \brief RangeImage is derived from pcl/PointCloud and provides functionalities with focus on situations where
* a 3D scene was captured from a specific view point.
* \author Bastian Steder
* \ingroup range_image
*/
class RangeImage : public pcl::PointCloud<PointWithRange>
{
public:
// =====TYPEDEFS=====
using BaseClass = pcl::PointCloud<PointWithRange>;
using VectorOfEigenVector3f = std::vector<Eigen::Vector3f, Eigen::aligned_allocator<Eigen::Vector3f> >;
using Ptr = shared_ptr<RangeImage>;
using ConstPtr = shared_ptr<const RangeImage>;
enum CoordinateFrame
{
CAMERA_FRAME = 0,
LASER_FRAME = 1
};
// =====CONSTRUCTOR & DESTRUCTOR=====
/** Constructor */
PCL_EXPORTS RangeImage ();
/** Destructor */
PCL_EXPORTS virtual ~RangeImage () = default;
// =====STATIC VARIABLES=====
/** The maximum number of openmp threads that can be used in this class */
static int max_no_of_threads;
// =====STATIC METHODS=====
/** \brief Get the size of a certain area when seen from the given pose
* \param viewer_pose an affine matrix defining the pose of the viewer
* \param center the center of the area
* \param radius the radius of the area
* \return the size of the area as viewed according to \a viewer_pose
*/
static inline float
getMaxAngleSize (const Eigen::Affine3f& viewer_pose, const Eigen::Vector3f& center,
float radius);
/** \brief Get Eigen::Vector3f from PointWithRange
* \param point the input point
* \return an Eigen::Vector3f representation of the input point
*/
static inline Eigen::Vector3f
getEigenVector3f (const PointWithRange& point);
/** \brief Get the transformation that transforms the given coordinate frame into CAMERA_FRAME
* \param coordinate_frame the input coordinate frame
* \param transformation the resulting transformation that warps \a coordinate_frame into CAMERA_FRAME
*/
PCL_EXPORTS static void
getCoordinateFrameTransformation (RangeImage::CoordinateFrame coordinate_frame,
Eigen::Affine3f& transformation);
/** \brief Get the average viewpoint of a point cloud where each point carries viewpoint information as
* vp_x, vp_y, vp_z
* \param point_cloud the input point cloud
* \return the average viewpoint (as an Eigen::Vector3f)
*/
template <typename PointCloudTypeWithViewpoints> static Eigen::Vector3f
getAverageViewPoint (const PointCloudTypeWithViewpoints& point_cloud);
/** \brief Check if the provided data includes far ranges and add them to far_ranges
* \param point_cloud_data a PCLPointCloud2 message containing the input cloud
* \param far_ranges the resulting cloud containing those points with far ranges
*/
PCL_EXPORTS static void
extractFarRanges (const pcl::PCLPointCloud2& point_cloud_data, PointCloud<PointWithViewpoint>& far_ranges);
// =====METHODS=====
/** \brief Get a boost shared pointer of a copy of this */
inline Ptr
makeShared () { return Ptr (new RangeImage (*this)); }
/** \brief Reset all values to an empty range image */
PCL_EXPORTS void
reset ();
/** \brief Create the depth image from a point cloud
* \param point_cloud the input point cloud
* \param angular_resolution the angular difference (in radians) between the individual pixels in the image
* \param max_angle_width an angle (in radians) defining the horizontal bounds of the sensor
* \param max_angle_height an angle (in radians) defining the vertical bounds of the sensor
* \param sensor_pose an affine matrix defining the pose of the sensor (defaults to
* Eigen::Affine3f::Identity () )
* \param coordinate_frame the coordinate frame (defaults to CAMERA_FRAME)
* \param noise_level - The distance in meters inside of which the z-buffer will not use the minimum,
* but the mean of the points. If 0.0 it is equivalent to a normal z-buffer and
* will always take the minimum per cell.
* \param min_range the minimum visible range (defaults to 0)
* \param border_size the border size (defaults to 0)
*/
template <typename PointCloudType> 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);
/** \brief Create the depth image from a point cloud
* \param point_cloud the input point cloud
* \param angular_resolution_x the angular difference (in radians) between the
* individual pixels in the image in the x-direction
* \param angular_resolution_y the angular difference (in radians) between the
* individual pixels in the image in the y-direction
* \param max_angle_width an angle (in radians) defining the horizontal bounds of the sensor
* \param max_angle_height an angle (in radians) defining the vertical bounds of the sensor
* \param sensor_pose an affine matrix defining the pose of the sensor (defaults to
* Eigen::Affine3f::Identity () )
* \param coordinate_frame the coordinate frame (defaults to CAMERA_FRAME)
* \param noise_level - The distance in meters inside of which the z-buffer will not use the minimum,
* but the mean of the points. If 0.0 it is equivalent to a normal z-buffer and
* will always take the minimum per cell.
* \param min_range the minimum visible range (defaults to 0)
* \param border_size the border size (defaults to 0)
*/
template <typename PointCloudType> void
createFromPointCloud (const PointCloudType& point_cloud,
float angular_resolution_x=pcl::deg2rad (0.5f), float angular_resolution_y=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);
/** \brief Create the depth image from a point cloud, getting a hint about the size of the scene for
* faster calculation.
* \param point_cloud the input point cloud
* \param angular_resolution the angle (in radians) between each sample in the depth image
* \param point_cloud_center the center of bounding sphere
* \param point_cloud_radius the radius of the bounding sphere
* \param sensor_pose an affine matrix defining the pose of the sensor (defaults to
* Eigen::Affine3f::Identity () )
* \param coordinate_frame the coordinate frame (defaults to CAMERA_FRAME)
* \param noise_level - The distance in meters inside of which the z-buffer will not use the minimum,
* but the mean of the points. If 0.0 it is equivalent to a normal z-buffer and
* will always take the minimum per cell.
* \param min_range the minimum visible range (defaults to 0)
* \param border_size the border size (defaults to 0)
*/
template <typename PointCloudType> 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);
/** \brief Create the depth image from a point cloud, getting a hint about the size of the scene for
* faster calculation.
* \param point_cloud the input point cloud
* \param angular_resolution_x the angular difference (in radians) between the
* individual pixels in the image in the x-direction
* \param angular_resolution_y the angular difference (in radians) between the
* individual pixels in the image in the y-direction
* \param point_cloud_center the center of bounding sphere
* \param point_cloud_radius the radius of the bounding sphere
* \param sensor_pose an affine matrix defining the pose of the sensor (defaults to
* Eigen::Affine3f::Identity () )
* \param coordinate_frame the coordinate frame (defaults to CAMERA_FRAME)
* \param noise_level - The distance in meters inside of which the z-buffer will not use the minimum,
* but the mean of the points. If 0.0 it is equivalent to a normal z-buffer and
* will always take the minimum per cell.
* \param min_range the minimum visible range (defaults to 0)
* \param border_size the border size (defaults to 0)
*/
template <typename PointCloudType> void
createFromPointCloudWithKnownSize (const PointCloudType& point_cloud,
float angular_resolution_x, float angular_resolution_y,
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);
/** \brief Create the depth image from a point cloud, using the average viewpoint of the points
* (vp_x,vp_y,vp_z in the point type) in the point cloud as sensor pose (assuming a rotation of (0,0,0)).
* \param point_cloud the input point cloud
* \param angular_resolution the angle (in radians) between each sample in the depth image
* \param max_angle_width an angle (in radians) defining the horizontal bounds of the sensor
* \param max_angle_height an angle (in radians) defining the vertical bounds of the sensor
* \param coordinate_frame the coordinate frame (defaults to CAMERA_FRAME)
* \param noise_level - The distance in meters inside of which the z-buffer will not use the minimum,
* but the mean of the points. If 0.0 it is equivalent to a normal z-buffer and
* will always take the minimum per cell.
* \param min_range the minimum visible range (defaults to 0)
* \param border_size the border size (defaults to 0)
* \note If wrong_coordinate_system is true, the sensor pose will be rotated to change from a coordinate frame
* 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
* to the bottom and z to the front) */
template <typename PointCloudTypeWithViewpoints> 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);
/** \brief Create the depth image from a point cloud, using the average viewpoint of the points
* (vp_x,vp_y,vp_z in the point type) in the point cloud as sensor pose (assuming a rotation of (0,0,0)).
* \param point_cloud the input point cloud
* \param angular_resolution_x the angular difference (in radians) between the
* individual pixels in the image in the x-direction
* \param angular_resolution_y the angular difference (in radians) between the
* individual pixels in the image in the y-direction
* \param max_angle_width an angle (in radians) defining the horizontal bounds of the sensor
* \param max_angle_height an angle (in radians) defining the vertical bounds of the sensor
* \param coordinate_frame the coordinate frame (defaults to CAMERA_FRAME)
* \param noise_level - The distance in meters inside of which the z-buffer will not use the minimum,
* but the mean of the points. If 0.0 it is equivalent to a normal z-buffer and
* will always take the minimum per cell.
* \param min_range the minimum visible range (defaults to 0)
* \param border_size the border size (defaults to 0)
* \note If wrong_coordinate_system is true, the sensor pose will be rotated to change from a coordinate frame
* 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
* to the bottom and z to the front) */
template <typename PointCloudTypeWithViewpoints> void
createFromPointCloudWithViewpoints (const PointCloudTypeWithViewpoints& point_cloud,
float angular_resolution_x, float angular_resolution_y,
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);
/** \brief Create an empty depth image (filled with unobserved points)
* \param[in] angular_resolution the angle (in radians) between each sample in the depth image
* \param[in] sensor_pose an affine matrix defining the pose of the sensor (defaults to Eigen::Affine3f::Identity () )
* \param[in] coordinate_frame the coordinate frame (defaults to CAMERA_FRAME)
* \param[in] angle_width an angle (in radians) defining the horizontal bounds of the sensor (defaults to 2*pi (360deg))
* \param[in] angle_height an angle (in radians) defining the vertical bounds of the sensor (defaults to pi (180deg))
*/
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));
/** \brief Create an empty depth image (filled with unobserved points)
* \param angular_resolution_x the angular difference (in radians) between the
* individual pixels in the image in the x-direction
* \param angular_resolution_y the angular difference (in radians) between the
* individual pixels in the image in the y-direction
* \param[in] sensor_pose an affine matrix defining the pose of the sensor (defaults to Eigen::Affine3f::Identity () )
* \param[in] coordinate_frame the coordinate frame (defaults to CAMERA_FRAME)
* \param[in] angle_width an angle (in radians) defining the horizontal bounds of the sensor (defaults to 2*pi (360deg))
* \param[in] angle_height an angle (in radians) defining the vertical bounds of the sensor (defaults to pi (180deg))
*/
void
createEmpty (float angular_resolution_x, float angular_resolution_y,
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));
/** \brief Integrate the given point cloud into the current range image using a z-buffer
* \param point_cloud the input point cloud
* \param noise_level - The distance in meters inside of which the z-buffer will not use the minimum,
* but the mean of the points. If 0.0 it is equivalent to a normal z-buffer and
* will always take the minimum per cell.
* \param min_range the minimum visible range
* \param top returns the minimum y pixel position in the image where a point was added
* \param right returns the maximum x pixel position in the image where a point was added
* \param bottom returns the maximum y pixel position in the image where a point was added
* \param left returns the minimum x pixel position in the image where a point was added
*/
template <typename PointCloudType> void
doZBuffer (const PointCloudType& point_cloud, float noise_level,
float min_range, int& top, int& right, int& bottom, int& left);
/** \brief Integrates the given far range measurements into the range image */
template <typename PointCloudType> void
integrateFarRanges (const PointCloudType& far_ranges);
/** \brief Cut the range image to the minimal size so that it still contains all actual range readings.
* \param border_size allows increase from the minimal size by the specified number of pixels (defaults to 0)
* \param top if positive, this value overrides the position of the top edge (defaults to -1)
* \param right if positive, this value overrides the position of the right edge (defaults to -1)
* \param bottom if positive, this value overrides the position of the bottom edge (defaults to -1)
* \param left if positive, this value overrides the position of the left edge (defaults to -1)
*/
PCL_EXPORTS void
cropImage (int border_size=0, int top=-1, int right=-1, int bottom=-1, int left=-1);
/** \brief Get all the range values in one float array of size width*height
* \return a pointer to a new float array containing the range values
* \note This method allocates a new float array; the caller is responsible for freeing this memory.
*/
PCL_EXPORTS float*
getRangesArray () const;
/** Getter for the transformation from the world system into the range image system
* (the sensor coordinate frame) */
inline const Eigen::Affine3f&
getTransformationToRangeImageSystem () const { return (to_range_image_system_); }
/** Setter for the transformation from the range image system
* (the sensor coordinate frame) into the world system */
inline void
setTransformationToRangeImageSystem (const Eigen::Affine3f& to_range_image_system);
/** Getter for the transformation from the range image system
* (the sensor coordinate frame) into the world system */
inline const Eigen::Affine3f&
getTransformationToWorldSystem () const { return to_world_system_;}
/** Getter for the angular resolution of the range image in x direction in radians per pixel.
* Provided for downwards compatibility */
inline float
getAngularResolution () const { return angular_resolution_x_;}
/** Getter for the angular resolution of the range image in x direction in radians per pixel. */
inline float
getAngularResolutionX () const { return angular_resolution_x_;}
/** Getter for the angular resolution of the range image in y direction in radians per pixel. */
inline float
getAngularResolutionY () const { return angular_resolution_y_;}
/** Getter for the angular resolution of the range image in x and y direction (in radians). */
inline void
getAngularResolution (float& angular_resolution_x, float& angular_resolution_y) const;
/** \brief Set the angular resolution of the range image
* \param angular_resolution the new angular resolution in x and y direction (in radians per pixel)
*/
inline void
setAngularResolution (float angular_resolution);
/** \brief Set the angular resolution of the range image
* \param angular_resolution_x the new angular resolution in x direction (in radians per pixel)
* \param angular_resolution_y the new angular resolution in y direction (in radians per pixel)
*/
inline void
setAngularResolution (float angular_resolution_x, float angular_resolution_y);
/** \brief Return the 3D point with range at the given image position
* \param image_x the x coordinate
* \param image_y the y coordinate
* \return the point at the specified location (returns unobserved_point if outside of the image bounds)
*/
inline const PointWithRange&
getPoint (int image_x, int image_y) const;
/** \brief Non-const-version of getPoint */
inline PointWithRange&
getPoint (int image_x, int image_y);
/** Return the 3d point with range at the given image position */
inline const PointWithRange&
getPoint (float image_x, float image_y) const;
/** Non-const-version of the above */
inline PointWithRange&
getPoint (float image_x, float image_y);
/** \brief Return the 3D point with range at the given image position. This methd performs no error checking
* to make sure the specified image position is inside of the image!
* \param image_x the x coordinate
* \param image_y the y coordinate
* \return the point at the specified location (program may fail if the location is outside of the image bounds)
*/
inline const PointWithRange&
getPointNoCheck (int image_x, int image_y) const;
/** Non-const-version of getPointNoCheck */
inline PointWithRange&
getPointNoCheck (int image_x, int image_y);
/** Same as above */
inline void
getPoint (int image_x, int image_y, Eigen::Vector3f& point) const;
/** Same as above */
inline void
getPoint (int index, Eigen::Vector3f& point) const;
/** Same as above */
inline const Eigen::Map<const Eigen::Vector3f>
getEigenVector3f (int x, int y) const;
/** Same as above */
inline const Eigen::Map<const Eigen::Vector3f>
getEigenVector3f (int index) const;
/** Return the 3d point with range at the given index (whereas index=y*width+x) */
inline const PointWithRange&
getPoint (int index) const;
/** Calculate the 3D point according to the given image point and range */
inline void
calculate3DPoint (float image_x, float image_y, float range, PointWithRange& point) const;
/** Calculate the 3D point according to the given image point and the range value at the closest pixel */
inline void
calculate3DPoint (float image_x, float image_y, PointWithRange& point) const;
/** Calculate the 3D point according to the given image point and range */
virtual inline void
calculate3DPoint (float image_x, float image_y, float range, Eigen::Vector3f& point) const;
/** Calculate the 3D point according to the given image point and the range value at the closest pixel */
inline void
calculate3DPoint (float image_x, float image_y, Eigen::Vector3f& point) const;
/** Recalculate all 3D point positions according to their pixel position and range */
PCL_EXPORTS void
recalculate3DPointPositions ();
/** Get imagePoint from 3D point in world coordinates */
inline virtual void
getImagePoint (const Eigen::Vector3f& point, float& image_x, float& image_y, float& range) const;
/** Same as above */
inline void
getImagePoint (const Eigen::Vector3f& point, int& image_x, int& image_y, float& range) const;
/** Same as above */
inline void
getImagePoint (const Eigen::Vector3f& point, float& image_x, float& image_y) const;
/** Same as above */
inline void
getImagePoint (const Eigen::Vector3f& point, int& image_x, int& image_y) const;
/** Same as above */
inline void
getImagePoint (float x, float y, float z, float& image_x, float& image_y, float& range) const;
/** Same as above */
inline void
getImagePoint (float x, float y, float z, float& image_x, float& image_y) const;
/** Same as above */
inline void
getImagePoint (float x, float y, float z, int& image_x, int& image_y) const;
/** point_in_image will be the point in the image at the position the given point would be. Returns
* the range of the given point. */
inline float
checkPoint (const Eigen::Vector3f& point, PointWithRange& point_in_image) const;
/** Returns the difference in range between the given point and the range of the point in the image
* at the position the given point would be.
* (Return value is point_in_image.range-given_point.range) */
inline float
getRangeDifference (const Eigen::Vector3f& point) const;
/** Get the image point corresponding to the given angles */
inline void
getImagePointFromAngles (float angle_x, float angle_y, float& image_x, float& image_y) const;
/** Get the angles corresponding to the given image point */
inline void
getAnglesFromImagePoint (float image_x, float image_y, float& angle_x, float& angle_y) const;
/** Transforms an image point in float values to an image point in int values */
inline void
real2DToInt2D (float x, float y, int& xInt, int& yInt) const;
/** Check if a point is inside of the image */
inline bool
isInImage (int x, int y) const;
/** Check if a point is inside of the image and has a finite range */
inline bool
isValid (int x, int y) const;
/** Check if a point has a finite range */
inline bool
isValid (int index) const;
/** Check if a point is inside of the image and has either a finite range or a max reading (range=INFINITY) */
inline bool
isObserved (int x, int y) const;
/** Check if a point is a max range (range=INFINITY) - please check isInImage or isObserved first! */
inline bool
isMaxRange (int x, int y) const;
/** Calculate the normal of an image point using the neighbors with a maximum pixel distance of radius.
* step_size determines how many pixels are used. 1 means all, 2 only every second, etc..
* Returns false if it was unable to calculate a normal.*/
inline bool
getNormal (int x, int y, int radius, 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. */
inline 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 */
inline bool
getNormalForClosestNeighbors (int x, int y, int radius, const Eigen::Vector3f& point,
int no_of_nearest_neighbors, Eigen::Vector3f& normal,
Eigen::Vector3f* point_on_plane=nullptr, int step_size=1) const;
/** Same as above, using default values */
inline bool
getNormalForClosestNeighbors (int x, int y, Eigen::Vector3f& normal, int radius=2) const;
/** Same as above but extracts some more data and can also return the extracted
* information for all neighbors in radius if normal_all_neighbors is not NULL */
inline 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;
// Return the squared distance to the n-th neighbors of the point at x,y
inline float
getSquaredDistanceOfNthNeighbor (int x, int y, int radius, int n, int step_size) const;
/** Calculate the impact angle based on the sensor position and the two given points - will return
* -INFINITY if one of the points is unobserved */
inline float
getImpactAngle (const PointWithRange& point1, const PointWithRange& point2) const;
//! Same as above
inline float
getImpactAngle (int x1, int y1, int x2, int y2) const;
/** Extract a local normal (with a heuristic not to include background points) and calculate the impact
* angle based on this */
inline float
getImpactAngleBasedOnLocalNormal (int x, int y, int radius) const;
/** Uses the above function for every point in the image */
PCL_EXPORTS float*
getImpactAngleImageBasedOnLocalNormals (int radius) const;
/** Calculate a score [0,1] that tells how acute the impact angle is (1.0f - getImpactAngle/90deg)
* This uses getImpactAngleBasedOnLocalNormal
* Will return -INFINITY if no normal could be calculated */
inline 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)
* will return -INFINITY if one of the points is unobserved */
inline float
getAcutenessValue (const PointWithRange& point1, const PointWithRange& point2) const;
//! Same as above
inline float
getAcutenessValue (int x1, int y1, int x2, int y2) const;
/** Calculate getAcutenessValue for every point */
PCL_EXPORTS void
getAcutenessValueImages (int pixel_distance, float*& acuteness_value_image_x,
float*& acuteness_value_image_y) const;
/** Calculates, how much the surface changes at a point. Pi meaning a flat suface and 0.0f
* would be a needle point */
//inline float
// getSurfaceChange (const PointWithRange& point, const PointWithRange& neighbor1,
// const PointWithRange& neighbor2) const;
/** Calculates, how much the surface changes at a point. 1 meaning a 90deg angle and 0 a flat suface */
PCL_EXPORTS float
getSurfaceChange (int x, int y, int radius) const;
/** Uses the above function for every point in the image */
PCL_EXPORTS float*
getSurfaceChangeImage (int radius) const;
/** Calculates, how much the surface changes at a point. Returns an angle [0.0f, PI] for x and y direction.
* A return value of -INFINITY means that a point was unobserved. */
inline void
getSurfaceAngleChange (int x, int y, int radius, float& angle_change_x, float& angle_change_y) const;
/** Uses the above function for every point in the image */
PCL_EXPORTS void
getSurfaceAngleChangeImages (int radius, float*& angle_change_image_x, float*& angle_change_image_y) const;
/** Calculates the curvature in a point using pca */
inline float
getCurvature (int x, int y, int radius, int step_size) const;
//! Get the sensor position
inline const Eigen::Vector3f
getSensorPos () const;
/** Sets all -INFINITY values to INFINITY */
PCL_EXPORTS void
setUnseenToMaxRange ();
//! Getter for image_offset_x_
inline int
getImageOffsetX () const { return image_offset_x_;}
//! Getter for image_offset_y_
inline int
getImageOffsetY () const { return image_offset_y_;}
//! Setter for image offsets
inline void
setImageOffsets (int offset_x, int offset_y) { image_offset_x_=offset_x; image_offset_y_=offset_y;}
/** Get a sub part of the complete image as a new range image.
* \param sub_image_image_offset_x - The x coordinate of the top left pixel of the sub image.
* This is always according to absolute 0,0 meaning -180°,-90°
* and it is already in the system of the new image, so the
* actual pixel used in the original image is
* combine_pixels* (image_offset_x-image_offset_x_)
* \param sub_image_image_offset_y - Same as image_offset_x for the y coordinate
* \param sub_image_width - width of the new image
* \param sub_image_height - height of the new image
* \param combine_pixels - shrinking factor, meaning the new angular resolution
* is combine_pixels times the old one
* \param sub_image - the output image
*/
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 range image with half the resolution
virtual void
getHalfImage (RangeImage& half_image) const;
//! Find the minimum and maximum range in the image
PCL_EXPORTS void
getMinMaxRanges (float& min_range, float& max_range) const;
//! This function sets the sensor pose to 0 and transforms all point positions to this local coordinate frame
PCL_EXPORTS void
change3dPointsToLocalCoordinateFrame ();
/** Calculate a range patch as the z values of the coordinate frame given by pose.
* The patch will have size pixel_size x pixel_size and each pixel
* covers world_size/pixel_size meters in the world
* You are responsible for deleting the structure afterwards! */
PCL_EXPORTS float*
getInterpolatedSurfaceProjection (const Eigen::Affine3f& pose, int pixel_size, float world_size) const;
//! Same as above, but using the local coordinate frame defined by point and the viewing direction
PCL_EXPORTS float*
getInterpolatedSurfaceProjection (const Eigen::Vector3f& point, int pixel_size, float world_size) const;
//! Get the local coordinate frame with 0,0,0 in point, upright and Z as the viewing direction
inline Eigen::Affine3f
getTransformationToViewerCoordinateFrame (const Eigen::Vector3f& point) const;
//! Same as above, using a reference for the retrurn value
inline void
getTransformationToViewerCoordinateFrame (const Eigen::Vector3f& point,
Eigen::Affine3f& transformation) const;
//! Same as above, but only returning the rotation
inline void
getRotationToViewerCoordinateFrame (const Eigen::Vector3f& point, Eigen::Affine3f& transformation) const;
/** Get a local coordinate frame at the given point based on the normal. */
PCL_EXPORTS bool
getNormalBasedUprightTransformation (const Eigen::Vector3f& point,
float max_dist, Eigen::Affine3f& transformation) const;
/** Get the integral image of the range values (used for fast blur operations).
* You are responsible for deleting it after usage! */
PCL_EXPORTS void
getIntegralImage (float*& integral_image, int*& valid_points_num_image) const;
/** Get a blurred version of the range image using box filters on the provided integral image*/
PCL_EXPORTS void // Template necessary so that this function also works in derived classes
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 */
PCL_EXPORTS virtual void // Template necessary so that this function also works in derived classes
getBlurredImage (int blur_radius, RangeImage& range_image) const;
/** Get the squared euclidean distance between the two image points.
* Returns -INFINITY if one of the points was not observed */
inline float
getEuclideanDistanceSquared (int x1, int y1, int x2, int y2) const;
//! Doing the above for some steps in the given direction and averaging
inline float
getAverageEuclideanDistance (int x, int y, int offset_x, int offset_y, int max_steps) const;
//! Project all points on the local plane approximation, thereby smoothing the surface of the scan
PCL_EXPORTS void
getRangeImageWithSmoothedSurface (int radius, RangeImage& smoothed_range_image) const;
//void getLocalNormals (int radius) const;
/** Calculates the average 3D position of the no_of_points points described by the start
* point x,y in the direction delta.
* Returns a max range point (range=INFINITY) if the first point is max range and an
* unobserved point (range=-INFINITY) if non of the points is observed. */
inline void
get1dPointAverage (int x, int y, int delta_x, int delta_y, int no_of_points,
PointWithRange& average_point) const;
/** Calculates the overlap of two range images given the relative transformation
* (from the given image to *this) */
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;
/** Get the viewing direction for the given point */
inline bool
getViewingDirection (int x, int y, Eigen::Vector3f& viewing_direction) const;
/** Get the viewing direction for the given point */
inline void
getViewingDirection (const Eigen::Vector3f& point, Eigen::Vector3f& viewing_direction) const;
/** Return a newly created Range image.
* Can be reimplemented in derived classes like RangeImagePlanar to return an image of the same type. */
PCL_EXPORTS virtual RangeImage*
getNew () const { return new RangeImage; }
/** Copy other to *this. Necessary for use in virtual functions that need to copy derived RangeImage classes (like RangeImagePlanar) */
PCL_EXPORTS virtual void
copyTo (RangeImage& other) const;
// =====MEMBER VARIABLES=====
// BaseClass:
// roslib::Header header;
// std::vector<PointT> points;
// std::uint32_t width;
// std::uint32_t height;
// bool is_dense;
static bool debug; /**< Just for... well... debugging purposes. :-) */
protected:
// =====PROTECTED MEMBER VARIABLES=====
Eigen::Affine3f to_range_image_system_; /**< Inverse of to_world_system_ */
Eigen::Affine3f to_world_system_; /**< Inverse of to_range_image_system_ */
float angular_resolution_x_; /**< Angular resolution of the range image in x direction in radians per pixel */
float angular_resolution_y_; /**< Angular resolution of the range image in y direction in radians per pixel */
float angular_resolution_x_reciprocal_; /**< 1.0/angular_resolution_x_ - provided for better performance of
* multiplication compared to division */
float angular_resolution_y_reciprocal_; /**< 1.0/angular_resolution_y_ - provided for better performance of
* multiplication compared to division */
int image_offset_x_, image_offset_y_; /**< Position of the top left corner of the range image compared to
* an image of full size (360x180 degrees) */
PointWithRange unobserved_point; /**< This point is used to be able to return
* a reference to a non-existing point */
// =====PROTECTED METHODS=====
// =====STATIC PROTECTED=====
static const int lookup_table_size;
static std::vector<float> asin_lookup_table;
static std::vector<float> atan_lookup_table;
static std::vector<float> cos_lookup_table;
/** Create lookup tables for trigonometric functions */
static void
createLookupTables ();
/** Query the asin lookup table */
static inline float
asinLookUp (float value);
/** Query the std::atan2 lookup table */
static inline float
atan2LookUp (float y, float x);
/** Query the cos lookup table */
static inline float
cosLookUp (float value);
public:
PCL_MAKE_ALIGNED_OPERATOR_NEW
};
/**
* /ingroup range_image
*/
inline std::ostream&
operator<< (std::ostream& os, const RangeImage& r)
{
os << "header: " << std::endl;
os << r.header;
os << "points[]: " << r.size () << std::endl;
os << "width: " << r.width << std::endl;
os << "height: " << r.height << std::endl;
os << "sensor_origin_: "
<< r.sensor_origin_[0] << ' '
<< r.sensor_origin_[1] << ' '
<< r.sensor_origin_[2] << std::endl;
os << "sensor_orientation_: "
<< r.sensor_orientation_.x () << ' '
<< r.sensor_orientation_.y () << ' '
<< r.sensor_orientation_.z () << ' '
<< r.sensor_orientation_.w () << std::endl;
os << "is_dense: " << r.is_dense << std::endl;
os << "angular resolution: "
<< RAD2DEG (r.getAngularResolutionX ()) << "deg/pixel in x and "
<< RAD2DEG (r.getAngularResolutionY ()) << "deg/pixel in y.\n" << std::endl;
return (os);
}
} // namespace end
#include <pcl/range_image/impl/range_image.hpp> // Definitions of templated and inline functions
Reference in New Issue Copy Permalink