Point Cloud Library (PCL)
1.3.1
|
RangeImagePlanar is derived from the original range image and differs from it because it's not a spherical projection, but using a projection plane (as normal cameras do), therefore being better applicable for range sensors that already provide a range image by themselves (stereo cameras, ToF-cameras), so that a conversion to point cloud and then to a spherical range image becomes unnecessary. More...
#include <pcl/range_image/range_image_planar.h>
Public Types | |
typedef RangeImage | BaseClass |
typedef boost::shared_ptr < RangeImagePlanar > | Ptr |
typedef boost::shared_ptr < const RangeImagePlanar > | ConstPtr |
enum | CoordinateFrame { CAMERA_FRAME = 0, LASER_FRAME = 1 } |
typedef std::vector < Eigen::Vector3f, Eigen::aligned_allocator < Eigen::Vector3f > > | VectorOfEigenVector3f |
typedef PointT | PointType |
typedef std::vector< PointT, Eigen::aligned_allocator < PointT > > | VectorType |
typedef VectorType::iterator | iterator |
typedef VectorType::const_iterator | const_iterator |
Public Member Functions | |
PCL_EXPORTS | RangeImagePlanar () |
Constructor. | |
PCL_EXPORTS | ~RangeImagePlanar () |
Destructor. | |
virtual RangeImage * | getNew () const |
Return a newly created RangeImagePlanar. | |
Ptr | makeShared () |
Get a boost shared pointer of a copy of this. | |
PCL_EXPORTS void | setDisparityImage (const float *disparity_image, int di_width, int di_height, float focal_length, float base_line, float desired_angular_resolution=-1) |
Create the image from an existing disparity image. | |
PCL_EXPORTS void | setDepthImage (const float *depth_image, int di_width, int di_height, float di_center_x, float di_center_y, float di_focal_length_x, float di_focal_length_y, float desired_angular_resolution=-1) |
Create the image from an existing depth image. | |
PCL_EXPORTS void | setDepthImage (const unsigned short *depth_image, int di_width, int di_height, float di_center_x, float di_center_y, float di_focal_length_x, float di_focal_length_y, float desired_angular_resolution=-1) |
Create the image from an existing depth image. | |
template<typename PointCloudType > | |
void | createFromPointCloudWithFixedSize (const PointCloudType &point_cloud, int di_width, int di_height, float di_center_x, float di_center_y, float di_focal_length_x, float di_focal_length_y, const Eigen::Affine3f &sensor_pose, CoordinateFrame coordinate_frame=CAMERA_FRAME, float noise_level=0.0f, float min_range=0.0f) |
Create the image from an existing point cloud. | |
virtual 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 range. | |
virtual void | getImagePoint (const Eigen::Vector3f &point, float &image_x, float &image_y, float &range) const |
Calculate the image point and range from the given 3D point. | |
virtual PCL_EXPORTS 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. | |
virtual PCL_EXPORTS void | getHalfImage (RangeImage &half_image) const |
Get a range image with half the resolution. | |
const Eigen::Map< const Eigen::Vector3f > | getEigenVector3f (int x, int y) const |
Same as above. | |
const Eigen::Map< const Eigen::Vector3f > | getEigenVector3f (int index) const |
Same as above. | |
ConstPtr | makeShared () const |
Copy the cloud to the heap and return a constant smart pointer Note that deep copy is performed, so avoid using this function on non-empty clouds. | |
PCL_EXPORTS void | reset () |
Reset all values to an empty range image. | |
template<typename PointCloudType > | |
void | createFromPointCloud (const PointCloudType &point_cloud, float angular_resolution, float max_angle_width, float max_angle_height, const Eigen::Affine3f &sensor_pose, 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. | |
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, 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 calculation. | |
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) |
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)). | |
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) | |
PCL_EXPORTS void | integrateFarRanges (const PointCloud< PointWithViewpoint > &far_ranges) |
Integrates the given far range measurements into the range image. | |
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. | |
PCL_EXPORTS float * | getRangesArray () const |
Get all the range values in one float array of size width*height. | |
const Eigen::Affine3f & | getTransformationToRangeImageSystem () const |
Getter for the transformation from the world system into the range image system (the sensor coordinate frame) | |
void | setTransformationToRangeImageSystem (const Eigen::Affine3f &to_range_image_system) |
Setter for the transformation from the range image system (the sensor coordinate frame) into the world system. | |
const Eigen::Affine3f & | getTransformationToWorldSystem () const |
Getter for the transformation from the range image system (the sensor coordinate frame) into the world system. | |
float | getAngularResolution () const |
Getter for the angular resolution of the range image in radians per pixel. | |
void | setAngularResolution (float angular_resolution) |
Set the angular resolution of the range image. | |
const PointWithRange & | getPoint (int image_x, int image_y) const |
Return the 3D point with range at the given image position. | |
PointWithRange & | getPoint (int image_x, int image_y) |
Non-const-version of getPoint. | |
const PointWithRange & | getPoint (float image_x, float image_y) const |
Return the 3d point with range at the given image position. | |
PointWithRange & | getPoint (float image_x, float image_y) |
Non-const-version of the above. | |
void | getPoint (int image_x, int image_y, Eigen::Vector3f &point) const |
Same as above. | |
void | getPoint (int index, Eigen::Vector3f &point) const |
Same as above. | |
const PointWithRange & | getPoint (int index) const |
Return the 3d point with range at the given index (whereas index=y*width+x) | |
const PointWithRange & | getPointNoCheck (int image_x, int image_y) const |
Return the 3D point with range at the given image position. | |
PointWithRange & | getPointNoCheck (int image_x, int image_y) |
Non-const-version of getPointNoCheck. | |
const PointWithRange & | getPointConsideringWrapAround (int image_x, int image_y) const |
Return the 3d point with range at 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. | |
void | calculate3DPoint (float image_x, float image_y, PointWithRange &point) const |
Calculate the 3D point according to the given image point and the range value at the closest pixel. | |
void | calculate3DPoint (float image_x, float image_y, Eigen::Vector3f &point) const |
Calculate the 3D point according to the given image point and the range value at the closest pixel. | |
PCL_EXPORTS void | recalculate3DPointPositions () |
Recalculate all 3D point positions according to their pixel position and range. | |
void | getImagePoint (const Eigen::Vector3f &point, int &image_x, int &image_y, float &range) const |
Same as above. | |
void | getImagePoint (const Eigen::Vector3f &point, float &image_x, float &image_y) const |
Same as above. | |
void | getImagePoint (const Eigen::Vector3f &point, int &image_x, int &image_y) const |
Same as above. | |
void | getImagePoint (float x, float y, float z, float &image_x, float &image_y, float &range) const |
Same as above. | |
void | getImagePoint (float x, float y, float z, float &image_x, float &image_y) const |
Same as above. | |
void | getImagePoint (float x, float y, float z, int &image_x, int &image_y) const |
Same as above. | |
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 | 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 the position the given point would be. | |
void | getImagePointFromAngles (float angle_x, float angle_y, float &image_x, float &image_y) const |
Get the image point corresponding to the given angles. | |
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 | real2DToInt2D (float x, float y, int &xInt, int &yInt) const |
Transforms an image point in float values to an image point in int values. | |
bool | isInImage (int x, int y) const |
Check if a point is inside of the image. | |
bool | isValid (int x, int y) const |
Check if a point is inside of the image and has a finite range. | |
bool | isValid (int index) const |
Check if a point has a finite range. | |
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=INFINITY) | |
bool | isMaxRange (int x, int y) const |
Check if a point is a max range (range=INFINITY) - please check isInImage or isObserved first! | |
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. | |
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. | |
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=NULL, int step_size=1) const |
Same as above. | |
bool | getNormalForClosestNeighbors (int x, int y, Eigen::Vector3f &normal, int radius=2) const |
Same as above, using default values. | |
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=NULL, Eigen::Vector3f *mean_all_neighbors=NULL, Eigen::Vector3f *eigen_values_all_neighbors=NULL) 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. | |
float | getSquaredDistanceOfNthNeighbor (int x, int y, int radius, int n, int step_size) const |
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. | |
float | getImpactAngle (int x1, int y1, int x2, int y2) const |
Same as above. | |
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 angle based on this. | |
PCL_EXPORTS float * | getImpactAngleImageBasedOnLocalNormals (int radius) const |
Uses the above function for every point in the image. | |
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 uses getImpactAngleBasedOnLocalNormal Will return -INFINITY if no normal could be calculated. | |
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 return -INFINITY if one of the points is unobserved. | |
float | getAcutenessValue (int x1, int y1, int x2, int y2) const |
Same as above. | |
PCL_EXPORTS void | getAcutenessValueImages (int pixel_distance, float *´ness_value_image_x, float *´ness_value_image_y) const |
Calculate getAcutenessValue for every point. | |
PCL_EXPORTS float | getSurfaceChange (int x, int y, int radius) const |
Calculates, how much the surface changes at a point. | |
PCL_EXPORTS float * | getSurfaceChangeImage (int radius) const |
Uses the above function for every point in the image. | |
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. | |
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 | getCurvature (int x, int y, int radius, int step_size) const |
Calculates the curvature in a point using pca. | |
const Eigen::Vector3f | getSensorPos () const |
Get the sensor position. | |
PCL_EXPORTS void | setUnseenToMaxRange () |
Sets all -INFINITY values to INFINITY. | |
int | getImageOffsetX () const |
Getter for image_offset_x_. | |
int | getImageOffsetY () const |
Getter for image_offset_y_. | |
void | setImageOffsets (int offset_x, int offset_y) |
Setter for image offsets. | |
PCL_EXPORTS void | getMinMaxRanges (float &min_range, float &max_range) const |
Find the minimum and maximum range in the image. | |
PCL_EXPORTS void | change3dPointsToLocalCoordinateFrame () |
This function sets the sensor pose to 0 and transforms all point positions to this local coordinate frame. | |
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. | |
PCL_EXPORTS float * | getInterpolatedSurfaceProjection (const Eigen::Vector3f &point, int pixel_size, float world_size) const |
Same as above, but using the local coordinate frame defined by point and the viewing direction. | |
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 | getTransformationToViewerCoordinateFrame (const Eigen::Vector3f &point, Eigen::Affine3f &transformation) const |
Same as above, using a reference for the retrurn value. | |
void | getRotationToViewerCoordinateFrame (const Eigen::Vector3f &point, Eigen::Affine3f &transformation) const |
Same as above, but only returning the rotation. | |
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. | |
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). | |
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. | |
PCL_EXPORTS void | getBlurredImage (int blur_radius, RangeImage &range_image) const |
Get a blurred version of the range image using box filters. | |
float | getEuclideanDistanceSquared (int x1, int y1, int x2, int y2) const |
Get the squared euclidean distance between the two image points. | |
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. | |
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 | 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,y in the direction delta. | |
PCL_EXPORTS Eigen::Affine3f | doIcp (const VectorOfEigenVector3f &points, const Eigen::Affine3f &initial_guess, int search_radius, float max_distance_start, float max_distance_end, int num_iterations) const |
Perform ICP (Iterative closest point) on the given data. | |
PCL_EXPORTS Eigen::Affine3f | doIcp (const RangeImage &other_range_image, const Eigen::Affine3f &initial_guess, int search_radius, float max_distance_start, float max_distance_end, int num_iterations, int pixel_step_start=1, int pixel_step_end=1) const |
Perform ICP (Iterative closest point) on the given data pixel_step_start, pixel_step_end can be used to improve performance by starting with low resolution and going to higher resolution with later iterations (not used for default values) | |
PCL_EXPORTS void | extractPlanes (float initial_max_plane_error, std::vector< ExtractedPlane > &planes) const |
Extracts planes from the range image using a region growing approach. | |
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 *this) | |
bool | getViewingDirection (int x, int y, Eigen::Vector3f &viewing_direction) const |
Get the viewing direction for the given point. | |
void | getViewingDirection (const Eigen::Vector3f &point, Eigen::Vector3f &viewing_direction) const |
Get the viewing direction for the given point. | |
PointCloud & | operator+= (const PointCloud &rhs) |
PointT | at (int u, int v) const |
const PointT & | at (size_t n) const |
PointT & | at (size_t n) |
const PointT & | operator() (int u, int v) const |
PointT & | operator() (int u, int v) |
bool | isOrganized () const |
Return whether a dataset is organized (e.g., arranged in a structured grid). | |
Eigen::MatrixXf | getMatrixXfMap (int dim, int stride, int offset) |
Return an Eigen MatrixXf (assumes float values) mapped to the specified dimensions of the PointCloud. | |
Eigen::MatrixXf | getMatrixXfMap () |
Return an Eigen MatrixXf (assumes float values) mapped to the PointCloud. | |
iterator | begin () |
const_iterator | begin () const |
iterator | end () |
const_iterator | end () const |
size_t | size () const |
void | reserve (size_t n) |
void | resize (size_t n) |
bool | empty () const |
const PointT & | operator[] (size_t n) const |
PointT & | operator[] (size_t n) |
const PointT & | front () const |
PointT & | front () |
const PointT & | back () const |
PointT & | back () |
void | push_back (const PointT &p) |
iterator | insert (iterator position, const PointT &x) |
void | insert (iterator position, size_t n, const PointT &x) |
void | insert (iterator position, InputIterator first, InputIterator last) |
iterator | erase (iterator position) |
iterator | erase (iterator first, iterator last) |
void | swap (PointCloud< PointT > &rhs) |
void | clear () |
Static Public Member Functions | |
static float | getMaxAngleSize (const Eigen::Affine3f &viewer_pose, const Eigen::Vector3f ¢er, float radius) |
Get the size of a certain area when seen from the given pose. | |
static Eigen::Vector3f | getEigenVector3f (const PointWithRange &point) |
Get Eigen::Vector3f from PointWithRange. | |
static PCL_EXPORTS void | getCoordinateFrameTransformation (RangeImage::CoordinateFrame coordinate_frame, Eigen::Affine3f &transformation) |
Get the transformation that transforms the given coordinate frame into CAMERA_FRAME. | |
template<typename PointCloudTypeWithViewpoints > | |
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, vp_y, vp_z. | |
static PCL_EXPORTS void | extractFarRanges (const sensor_msgs::PointCloud2 &point_cloud_data, PointCloud< PointWithViewpoint > &far_ranges) |
Check if the provided data includes far ranges and add them to far_ranges. | |
static bool | isLargerPlane (const ExtractedPlane &p1, const ExtractedPlane &p2) |
Comparator to enable us to sort a vector of Planes regarding their size using std::sort(begin(), end(), RangeImage::isLargerPlane);. | |
Public Attributes | |
std_msgs::Header | header |
The point cloud header. | |
std::vector< PointT, Eigen::aligned_allocator < PointT > > | points |
The point data. | |
uint32_t | width |
The point cloud width (if organized as an image-structure). | |
uint32_t | height |
The point cloud height (if organized as an image-structure). | |
bool | is_dense |
True if no points are invalid (e.g., have NaN or Inf values). | |
Eigen::Vector4f | sensor_origin_ |
Sensor acquisition pose (origin/translation). | |
Eigen::Quaternionf | sensor_orientation_ |
Sensor acquisition pose (rotation). | |
EIGEN_MAKE_ALIGNED_OPERATOR_NEW | |
Static Public Attributes | |
static int | max_no_of_threads |
The maximum number of openmp threads that can be used in this class. | |
static bool | debug |
Just for... |
RangeImagePlanar is derived from the original range image and differs from it because it's not a spherical projection, but using a projection plane (as normal cameras do), therefore being better applicable for range sensors that already provide a range image by themselves (stereo cameras, ToF-cameras), so that a conversion to point cloud and then to a spherical range image becomes unnecessary.
Reimplemented from pcl::RangeImage.
Definition at line 53 of file range_image_planar.h.
typedef VectorType::const_iterator pcl::PointCloud::const_iterator [inherited] |
Definition at line 228 of file point_cloud.h.
typedef boost::shared_ptr<const RangeImagePlanar> pcl::RangeImagePlanar::ConstPtr |
Reimplemented from pcl::RangeImage.
Definition at line 55 of file range_image_planar.h.
typedef VectorType::iterator pcl::PointCloud::iterator [inherited] |
Definition at line 227 of file point_cloud.h.
typedef PointT pcl::PointCloud::PointType [inherited] |
Definition at line 221 of file point_cloud.h.
typedef boost::shared_ptr<RangeImagePlanar> pcl::RangeImagePlanar::Ptr |
Reimplemented from pcl::RangeImage.
Definition at line 54 of file range_image_planar.h.
typedef std::vector<Eigen::Vector3f, Eigen::aligned_allocator<Eigen::Vector3f> > pcl::RangeImage::VectorOfEigenVector3f [inherited] |
Definition at line 61 of file range_image.h.
typedef std::vector<PointT, Eigen::aligned_allocator<PointT> > pcl::PointCloud::VectorType [inherited] |
Definition at line 222 of file point_cloud.h.
enum pcl::RangeImage::CoordinateFrame [inherited] |
Definition at line 65 of file range_image.h.
PCL_EXPORTS pcl::RangeImagePlanar::RangeImagePlanar | ( | ) |
Constructor.
PCL_EXPORTS pcl::RangeImagePlanar::~RangeImagePlanar | ( | ) |
Destructor.
PointT pcl::PointCloud::at | ( | int | u, |
int | v | ||
) | const [inline, inherited] |
Definition at line 148 of file point_cloud.h.
const PointT& pcl::PointCloud::at | ( | size_t | n | ) | const [inline, inherited] |
Definition at line 243 of file point_cloud.h.
PointT& pcl::PointCloud::at | ( | size_t | n | ) | [inline, inherited] |
Definition at line 244 of file point_cloud.h.
const PointT& pcl::PointCloud::back | ( | ) | const [inline, inherited] |
Definition at line 247 of file point_cloud.h.
PointT& pcl::PointCloud::back | ( | ) | [inline, inherited] |
Definition at line 248 of file point_cloud.h.
iterator pcl::PointCloud::begin | ( | ) | [inline, inherited] |
Definition at line 229 of file point_cloud.h.
const_iterator pcl::PointCloud::begin | ( | ) | const [inline, inherited] |
Definition at line 231 of file point_cloud.h.
void pcl::RangeImagePlanar::calculate3DPoint | ( | float | image_x, |
float | image_y, | ||
float | range, | ||
Eigen::Vector3f & | point | ||
) | const [inline, virtual] |
Calculate the 3D point according to the given image point and range.
image_x | the x image position |
image_y | the y image position |
range | the range |
point | the resulting 3D point |
Reimplemented from pcl::RangeImage.
Definition at line 87 of file range_image_planar.hpp.
void pcl::RangeImage::calculate3DPoint | ( | float | image_x, |
float | image_y, | ||
float | range, | ||
PointWithRange & | point | ||
) | const [inline, inherited] |
Calculate the 3D point according to the given image point and range.
Definition at line 564 of file range_image.hpp.
void pcl::RangeImage::calculate3DPoint | ( | float | image_x, |
float | image_y, | ||
PointWithRange & | point | ||
) | const [inline, inherited] |
Calculate the 3D point according to the given image point and the range value at the closest pixel.
Definition at line 573 of file range_image.hpp.
void pcl::RangeImage::calculate3DPoint | ( | float | image_x, |
float | image_y, | ||
Eigen::Vector3f & | point | ||
) | const [inline, inherited] |
Calculate the 3D point according to the given image point and the range value at the closest pixel.
Definition at line 556 of file range_image.hpp.
PCL_EXPORTS void pcl::RangeImage::change3dPointsToLocalCoordinateFrame | ( | ) | [inherited] |
This function sets the sensor pose to 0 and transforms all point positions to this local coordinate frame.
float pcl::RangeImage::checkPoint | ( | const Eigen::Vector3f & | point, |
PointWithRange & | point_in_image | ||
) | const [inline, inherited] |
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.
Definition at line 350 of file range_image.hpp.
void pcl::PointCloud::clear | ( | ) | [inline, inherited] |
Definition at line 294 of file point_cloud.h.
void pcl::RangeImage::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) |
||
) | [inherited] |
Create an empty depth image (filled with unobserved points)
angular_resolution | the angle between each sample in the depth image |
sensor_pose | an affine matrix defining the pose of the sensor (defaults to Identity) |
coordinate_frame | the coordinate frame (defaults to CAMERA_FRAME) |
max_angle_width | an angle defining the horizontal bounds of the sensor (defaults to full 360deg) |
max_angle_height | an angle defining the vertical bounds of the sensor (defaults to full 180deg |
void pcl::RangeImage::createFromPointCloud | ( | const PointCloudType & | point_cloud, |
float | angular_resolution, | ||
float | max_angle_width, | ||
float | max_angle_height, | ||
const Eigen::Affine3f & | sensor_pose, | ||
RangeImage::CoordinateFrame | coordinate_frame = CAMERA_FRAME , |
||
float | noise_level = 0.0f , |
||
float | min_range = 0.0f , |
||
int | border_size = 0 |
||
) | [inherited] |
Create the depth image from a point cloud.
point_cloud | the input point cloud |
angular_resolution | the angle between each sample in the depth image |
max_angle_width | an angle defining the horizontal bounds of the sensor |
max_angle_height | an angle defining the vertical bounds of the sensor |
sensor_pose | an affine matrix defining the pose of the sensor |
coordinate_frame | the coordinate frame (defaults to CAMERA_FRAME) |
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. |
min_range | the minimum visible range (defaults to 0) |
border_size | the border size (defaults to 0) |
Definition at line 93 of file range_image.hpp.
void pcl::RangeImagePlanar::createFromPointCloudWithFixedSize | ( | const PointCloudType & | point_cloud, |
int | di_width, | ||
int | di_height, | ||
float | di_center_x, | ||
float | di_center_y, | ||
float | di_focal_length_x, | ||
float | di_focal_length_y, | ||
const Eigen::Affine3f & | sensor_pose, | ||
CoordinateFrame | coordinate_frame = CAMERA_FRAME , |
||
float | noise_level = 0.0f , |
||
float | min_range = 0.0f |
||
) |
Create the image from an existing point cloud.
point_cloud | the source point cloud |
di_width | the disparity image width |
di_height | the disparity image height |
di_center_x | the x-coordinate of the camera's center of projection |
di_center_y | the y-coordinate of the camera's center of projection |
di_focal_length_x | the camera's focal length in the horizontal direction |
di_focal_length_y | the camera's focal length in the vertical direction |
sensor_pose | the pose of the virtual depth camera |
coordinate_frame | the used coordinate frame of the point cloud |
noise_level | what is the typical noise of the sensor - is used for averaging in the z-buffer |
min_range | minimum range to consifder points |
Definition at line 45 of file range_image_planar.hpp.
void pcl::RangeImage::createFromPointCloudWithKnownSize | ( | const PointCloudType & | point_cloud, |
float | angular_resolution, | ||
const Eigen::Vector3f & | point_cloud_center, | ||
float | point_cloud_radius, | ||
const Eigen::Affine3f & | sensor_pose, | ||
RangeImage::CoordinateFrame | coordinate_frame = CAMERA_FRAME , |
||
float | noise_level = 0.0f , |
||
float | min_range = 0.0f , |
||
int | border_size = 0 |
||
) | [inherited] |
Create the depth image from a point cloud, getting a hint about the size of the scene for faster calculation.
point_cloud | the input point cloud |
angular_resolution | the angle between each sample in the depth image |
point_cloud_center | the center of bounding sphere |
point_cloud_radius | the radius of the bounding sphere |
sensor_pose | an affine matrix defining the pose of the sensor |
coordinate_frame | the coordinate frame (defaults to CAMERA_FRAME) |
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. |
min_range | the minimum visible range (defaults to 0) |
border_size | the border size (defaults to 0) |
Definition at line 146 of file range_image.hpp.
void pcl::RangeImage::createFromPointCloudWithViewpoints | ( | const PointCloudTypeWithViewpoints & | point_cloud, |
float | angular_resolution, | ||
float | max_angle_width, | ||
float | max_angle_height, | ||
RangeImage::CoordinateFrame | coordinate_frame = CAMERA_FRAME , |
||
float | noise_level = 0.0f , |
||
float | min_range = 0.0f , |
||
int | border_size = 0 |
||
) | [inherited] |
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)).
point_cloud | the input point cloud |
angular_resolution | the angle between each sample in the depth image |
max_angle_width | an angle defining the horizontal bounds of the sensor |
max_angle_height | an angle defining the vertical bounds of the sensor |
coordinate_frame | the coordinate frame (defaults to CAMERA_FRAME) |
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. |
min_range | the minimum visible range (defaults to 0) |
border_size | the border size (defaults to 0) |
Definition at line 131 of file range_image.hpp.
PCL_EXPORTS void pcl::RangeImage::cropImage | ( | int | border_size = 0 , |
int | top = -1 , |
||
int | right = -1 , |
||
int | bottom = -1 , |
||
int | left = -1 |
||
) | [inherited] |
Cut the range image to the minimal size so that it still contains all actual range readings.
border_size | allows increase from the minimal size by the specified number of pixels (defaults to 0) |
top | if positive, this value overrides the position of the top edge (defaults to -1) |
right | if positive, this value overrides the position of the right edge (defaults to -1) |
bottom | if positive, this value overrides the position of the bottom edge (defaults to -1) |
left | if positive, this value overrides the position of the left edge (defaults to -1) |
PCL_EXPORTS Eigen::Affine3f pcl::RangeImage::doIcp | ( | const VectorOfEigenVector3f & | points, |
const Eigen::Affine3f & | initial_guess, | ||
int | search_radius, | ||
float | max_distance_start, | ||
float | max_distance_end, | ||
int | num_iterations | ||
) | const [inherited] |
Perform ICP (Iterative closest point) on the given data.
PCL_EXPORTS Eigen::Affine3f pcl::RangeImage::doIcp | ( | const RangeImage & | other_range_image, |
const Eigen::Affine3f & | initial_guess, | ||
int | search_radius, | ||
float | max_distance_start, | ||
float | max_distance_end, | ||
int | num_iterations, | ||
int | pixel_step_start = 1 , |
||
int | pixel_step_end = 1 |
||
) | const [inherited] |
Perform ICP (Iterative closest point) on the given data pixel_step_start, pixel_step_end can be used to improve performance by starting with low resolution and going to higher resolution with later iterations (not used for default values)
bool pcl::PointCloud::empty | ( | ) | const [inline, inherited] |
Definition at line 238 of file point_cloud.h.
iterator pcl::PointCloud::end | ( | ) | [inline, inherited] |
Definition at line 230 of file point_cloud.h.
const_iterator pcl::PointCloud::end | ( | ) | const [inline, inherited] |
Definition at line 232 of file point_cloud.h.
Definition at line 274 of file point_cloud.h.
Definition at line 281 of file point_cloud.h.
static PCL_EXPORTS void pcl::RangeImage::extractFarRanges | ( | const sensor_msgs::PointCloud2 & | point_cloud_data, |
PointCloud< PointWithViewpoint > & | far_ranges | ||
) | [static, inherited] |
Check if the provided data includes far ranges and add them to far_ranges.
point_cloud_data | a PointCloud2 message containing the input cloud |
far_ranges | the resulting cloud containing those points with far ranges |
PCL_EXPORTS void pcl::RangeImage::extractPlanes | ( | float | initial_max_plane_error, |
std::vector< ExtractedPlane > & | planes | ||
) | const [inherited] |
Extracts planes from the range image using a region growing approach.
initial_max_plane_error | the maximum error that a point is allowed to have regarding the current plane estimate. This value is used only in the initial plane estimate, which will later on be refined, allowing only a maximum error of 3 sigma. |
planes | the found planes. The vector contains the individual found planes. |
const PointT& pcl::PointCloud::front | ( | ) | const [inline, inherited] |
Definition at line 245 of file point_cloud.h.
PointT& pcl::PointCloud::front | ( | ) | [inline, inherited] |
Definition at line 246 of file point_cloud.h.
void pcl::RangeImage::get1dPointAverage | ( | int | x, |
int | y, | ||
int | delta_x, | ||
int | delta_y, | ||
int | no_of_points, | ||
PointWithRange & | average_point | ||
) | const [inline, inherited] |
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.
Definition at line 779 of file range_image.hpp.
float pcl::RangeImage::getAcutenessValue | ( | const PointWithRange & | point1, |
const PointWithRange & | point2 | ||
) | const [inline, inherited] |
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.
Definition at line 629 of file range_image.hpp.
float pcl::RangeImage::getAcutenessValue | ( | int | x1, |
int | y1, | ||
int | x2, | ||
int | y2 | ||
) | const [inline, inherited] |
Same as above.
Definition at line 644 of file range_image.hpp.
PCL_EXPORTS void pcl::RangeImage::getAcutenessValueImages | ( | int | pixel_distance, |
float *& | acuteness_value_image_x, | ||
float *& | acuteness_value_image_y | ||
) | const [inherited] |
Calculate getAcutenessValue for every point.
void pcl::RangeImage::getAnglesFromImagePoint | ( | float | image_x, |
float | image_y, | ||
float & | angle_x, | ||
float & | angle_y | ||
) | const [inline, inherited] |
Get the angles corresponding to the given image point.
Definition at line 581 of file range_image.hpp.
float pcl::RangeImage::getAngularResolution | ( | ) | const [inline, inherited] |
Getter for the angular resolution of the range image in radians per pixel.
Definition at line 242 of file range_image.h.
float pcl::RangeImage::getAverageEuclideanDistance | ( | int | x, |
int | y, | ||
int | offset_x, | ||
int | offset_y, | ||
int | max_steps | ||
) | const [inline, inherited] |
Doing the above for some steps in the given direction and averaging.
Definition at line 834 of file range_image.hpp.
Eigen::Vector3f pcl::RangeImage::getAverageViewPoint | ( | const PointCloudTypeWithViewpoints & | point_cloud | ) | [static, inherited] |
Get the average viewpoint of a point cloud where each point carries viewpoint information as vp_x, vp_y, vp_z.
point_cloud | the input point cloud |
Definition at line 1102 of file range_image.hpp.
PCL_EXPORTS void pcl::RangeImage::getBlurredImage | ( | int | blur_radius, |
RangeImage & | range_image | ||
) | const [inherited] |
Get a blurred version of the range image using box filters.
PCL_EXPORTS void pcl::RangeImage::getBlurredImageUsingIntegralImage | ( | int | blur_radius, |
float * | integral_image, | ||
int * | valid_points_num_image, | ||
RangeImage & | range_image | ||
) | const [inherited] |
Get a blurred version of the range image using box filters on the provided integral image.
static PCL_EXPORTS void pcl::RangeImage::getCoordinateFrameTransformation | ( | RangeImage::CoordinateFrame | coordinate_frame, |
Eigen::Affine3f & | transformation | ||
) | [static, inherited] |
Get the transformation that transforms the given coordinate frame into CAMERA_FRAME.
coordinate_frame | the input coordinate frame |
transformation | the resulting transformation that warps coordinate_frame into CAMERA_FRAME |
float pcl::RangeImage::getCurvature | ( | int | x, |
int | y, | ||
int | radius, | ||
int | step_size | ||
) | const [inline, inherited] |
Calculates the curvature in a point using pca.
Definition at line 1077 of file range_image.hpp.
Eigen::Vector3f pcl::RangeImage::getEigenVector3f | ( | const PointWithRange & | point | ) | [inline, static, inherited] |
Get Eigen::Vector3f from PointWithRange.
point | the input point |
Definition at line 772 of file range_image.hpp.
const Eigen::Map< const Eigen::Vector3f > pcl::RangeImage::getEigenVector3f | ( | int | x, |
int | y | ||
) | const [inline, inherited] |
Same as above.
Definition at line 529 of file range_image.hpp.
const Eigen::Map< const Eigen::Vector3f > pcl::RangeImage::getEigenVector3f | ( | int | index | ) | const [inline, inherited] |
Same as above.
Definition at line 536 of file range_image.hpp.
float pcl::RangeImage::getEuclideanDistanceSquared | ( | int | x1, |
int | y1, | ||
int | x2, | ||
int | y2 | ||
) | const [inline, inherited] |
Get the squared euclidean distance between the two image points.
Returns -INFINITY if one of the points was not observed
Definition at line 819 of file range_image.hpp.
virtual PCL_EXPORTS void pcl::RangeImagePlanar::getHalfImage | ( | RangeImage & | half_image | ) | const [virtual] |
Get a range image with half the resolution.
Reimplemented from pcl::RangeImage.
int pcl::RangeImage::getImageOffsetX | ( | ) | const [inline, inherited] |
Getter for image_offset_x_.
Definition at line 509 of file range_image.h.
int pcl::RangeImage::getImageOffsetY | ( | ) | const [inline, inherited] |
Getter for image_offset_y_.
Definition at line 512 of file range_image.h.
void pcl::RangeImagePlanar::getImagePoint | ( | const Eigen::Vector3f & | point, |
float & | image_x, | ||
float & | image_y, | ||
float & | range | ||
) | const [inline, virtual] |
Calculate the image point and range from the given 3D point.
point | the resulting 3D point |
image_x | the resulting x image position |
image_y | the resulting y image position |
range | the resulting range |
Reimplemented from pcl::RangeImage.
Definition at line 100 of file range_image_planar.hpp.
void pcl::RangeImage::getImagePoint | ( | const Eigen::Vector3f & | point, |
int & | image_x, | ||
int & | image_y, | ||
float & | range | ||
) | const [inline, inherited] |
Same as above.
Definition at line 325 of file range_image.hpp.
void pcl::RangeImage::getImagePoint | ( | const Eigen::Vector3f & | point, |
float & | image_x, | ||
float & | image_y | ||
) | const [inline, inherited] |
Same as above.
Definition at line 333 of file range_image.hpp.
void pcl::RangeImage::getImagePoint | ( | const Eigen::Vector3f & | point, |
int & | image_x, | ||
int & | image_y | ||
) | const [inline, inherited] |
Same as above.
Definition at line 341 of file range_image.hpp.
void pcl::RangeImage::getImagePoint | ( | float | x, |
float | y, | ||
float | z, | ||
float & | image_x, | ||
float & | image_y, | ||
float & | range | ||
) | const [inline, inherited] |
Same as above.
Definition at line 286 of file range_image.hpp.
void pcl::RangeImage::getImagePoint | ( | float | x, |
float | y, | ||
float | z, | ||
float & | image_x, | ||
float & | image_y | ||
) | const [inline, inherited] |
Same as above.
Definition at line 294 of file range_image.hpp.
void pcl::RangeImage::getImagePoint | ( | float | x, |
float | y, | ||
float | z, | ||
int & | image_x, | ||
int & | image_y | ||
) | const [inline, inherited] |
Same as above.
Definition at line 302 of file range_image.hpp.
void pcl::RangeImage::getImagePointFromAngles | ( | float | angle_x, |
float | angle_y, | ||
float & | image_x, | ||
float & | image_y | ||
) | const [inline, inherited] |
Get the image point corresponding to the given angles.
Definition at line 384 of file range_image.hpp.
float pcl::RangeImage::getImpactAngle | ( | const PointWithRange & | point1, |
const PointWithRange & | point2 | ||
) | const [inline, inherited] |
Calculate the impact angle based on the sensor position and the two given points - will return.
-INFINITY if one of the points is unobserved
Definition at line 599 of file range_image.hpp.
float pcl::RangeImage::getImpactAngle | ( | int | x1, |
int | y1, | ||
int | x2, | ||
int | y2 | ||
) | const [inline, inherited] |
Same as above.
Definition at line 590 of file range_image.hpp.
float pcl::RangeImage::getImpactAngleBasedOnLocalNormal | ( | int | x, |
int | y, | ||
int | radius | ||
) | const [inline, inherited] |
Extract a local normal (with a heuristic not to include background points) and calculate the impact angle based on this.
Definition at line 862 of file range_image.hpp.
PCL_EXPORTS float* pcl::RangeImage::getImpactAngleImageBasedOnLocalNormals | ( | int | radius | ) | const [inherited] |
Uses the above function for every point in the image.
PCL_EXPORTS void pcl::RangeImage::getIntegralImage | ( | float *& | integral_image, |
int *& | valid_points_num_image | ||
) | const [inherited] |
Get the integral image of the range values (used for fast blur operations).
You are responsible for deleting it after usage!
PCL_EXPORTS float* pcl::RangeImage::getInterpolatedSurfaceProjection | ( | const Eigen::Affine3f & | pose, |
int | pixel_size, | ||
float | world_size | ||
) | const [inherited] |
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* pcl::RangeImage::getInterpolatedSurfaceProjection | ( | const Eigen::Vector3f & | point, |
int | pixel_size, | ||
float | world_size | ||
) | const [inherited] |
Same as above, but using the local coordinate frame defined by point and the viewing direction.
Eigen::MatrixXf pcl::PointCloud::getMatrixXfMap | ( | int | dim, |
int | stride, | ||
int | offset | ||
) | [inline, inherited] |
Return an Eigen MatrixXf (assumes float values) mapped to the specified dimensions of the PointCloud.
dim | the number of dimensions to consider for each point (will become the number of rows) |
stride | the number of values in each point (will be the number of values that separate two of the columns) |
offset | the number of dimensions to skip from the beginning of each point (note stride = offset + dim + x, where x is the number of dimensions to skip from the end of each point) |
Definition at line 187 of file point_cloud.h.
Eigen::MatrixXf pcl::PointCloud::getMatrixXfMap | ( | ) | [inline, inherited] |
Return an Eigen MatrixXf (assumes float values) mapped to the PointCloud.
Definition at line 196 of file point_cloud.h.
float pcl::RangeImage::getMaxAngleSize | ( | const Eigen::Affine3f & | viewer_pose, |
const Eigen::Vector3f & | center, | ||
float | radius | ||
) | [inline, static, inherited] |
Get the size of a certain area when seen from the given pose.
viewer_pose | an affine matrix defining the pose of the viewer |
center | the center of the area |
radius | the radius of the area |
Definition at line 765 of file range_image.hpp.
PCL_EXPORTS void pcl::RangeImage::getMinMaxRanges | ( | float & | min_range, |
float & | max_range | ||
) | const [inherited] |
Find the minimum and maximum range in the image.
virtual RangeImage* pcl::RangeImagePlanar::getNew | ( | ) | const [inline, virtual] |
Return a newly created RangeImagePlanar.
Reimplmentation to return an image of the same type.
Reimplemented from pcl::RangeImage.
Definition at line 66 of file range_image_planar.h.
bool pcl::RangeImage::getNormal | ( | int | x, |
int | y, | ||
int | radius, | ||
Eigen::Vector3f & | normal, | ||
int | step_size = 1 |
||
) | const [inline, inherited] |
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.
Definition at line 877 of file range_image.hpp.
float pcl::RangeImage::getNormalBasedAcutenessValue | ( | int | x, |
int | y, | ||
int | radius | ||
) | const [inline, inherited] |
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.
Definition at line 903 of file range_image.hpp.
PCL_EXPORTS bool pcl::RangeImage::getNormalBasedUprightTransformation | ( | const Eigen::Vector3f & | point, |
float | max_dist, | ||
Eigen::Affine3f & | transformation | ||
) | const [inherited] |
Get a local coordinate frame at the given point based on the normal.
bool pcl::RangeImage::getNormalForClosestNeighbors | ( | int | x, |
int | y, | ||
int | radius, | ||
const PointWithRange & | point, | ||
int | no_of_nearest_neighbors, | ||
Eigen::Vector3f & | normal, | ||
int | step_size = 1 |
||
) | const [inline, inherited] |
Same as above, but only the no_of_nearest_neighbors points closest to the given point are considered.
Definition at line 915 of file range_image.hpp.
bool pcl::RangeImage::getNormalForClosestNeighbors | ( | int | x, |
int | y, | ||
int | radius, | ||
const Eigen::Vector3f & | point, | ||
int | no_of_nearest_neighbors, | ||
Eigen::Vector3f & | normal, | ||
Eigen::Vector3f * | point_on_plane = NULL , |
||
int | step_size = 1 |
||
) | const [inline, inherited] |
Same as above.
Definition at line 1058 of file range_image.hpp.
bool pcl::RangeImage::getNormalForClosestNeighbors | ( | int | x, |
int | y, | ||
Eigen::Vector3f & | normal, | ||
int | radius = 2 |
||
) | const [inline, inherited] |
Same as above, using default values.
Definition at line 923 of file range_image.hpp.
PCL_EXPORTS float pcl::RangeImage::getOverlap | ( | const RangeImage & | other_range_image, |
const Eigen::Affine3f & | relative_transformation, | ||
int | search_radius, | ||
float | max_distance, | ||
int | pixel_step = 1 |
||
) | const [inherited] |
Calculates the overlap of two range images given the relative transformation (from the given image to *this)
const PointWithRange & pcl::RangeImage::getPoint | ( | int | image_x, |
int | image_y | ||
) | const [inline, inherited] |
Return the 3D point with range at the given image position.
image_x | the x coordinate |
image_y | the y coordinate |
Definition at line 458 of file range_image.hpp.
PointWithRange & pcl::RangeImage::getPoint | ( | int | image_x, |
int | image_y | ||
) | [inline, inherited] |
Non-const-version of getPoint.
Definition at line 481 of file range_image.hpp.
const PointWithRange & pcl::RangeImage::getPoint | ( | float | image_x, |
float | image_y | ||
) | const [inline, inherited] |
Return the 3d point with range at the given image position.
Definition at line 496 of file range_image.hpp.
PointWithRange & pcl::RangeImage::getPoint | ( | float | image_x, |
float | image_y | ||
) | [inline, inherited] |
Non-const-version of the above.
Definition at line 505 of file range_image.hpp.
void pcl::RangeImage::getPoint | ( | int | image_x, |
int | image_y, | ||
Eigen::Vector3f & | point | ||
) | const [inline, inherited] |
Same as above.
Definition at line 514 of file range_image.hpp.
void pcl::RangeImage::getPoint | ( | int | index, |
Eigen::Vector3f & | point | ||
) | const [inline, inherited] |
Same as above.
Definition at line 522 of file range_image.hpp.
const PointWithRange & pcl::RangeImage::getPoint | ( | int | index | ) | const [inline, inherited] |
Return the 3d point with range at the given index (whereas index=y*width+x)
Definition at line 489 of file range_image.hpp.
const PointWithRange & pcl::RangeImage::getPointConsideringWrapAround | ( | int | image_x, |
int | image_y | ||
) | const [inline, inherited] |
Return the 3d point with range at the given image point.
Additionally, if the given point is not an observed point if there might be a wrap around, e.g., we left the ride side of thed image and reentered on the left side (which might be the case in a 360deg 3D scan when we look at the local neighborhood of a point)
Definition at line 437 of file range_image.hpp.
const PointWithRange & pcl::RangeImage::getPointNoCheck | ( | int | image_x, |
int | image_y | ||
) | const [inline, inherited] |
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!
image_x | the x coordinate |
image_y | the y coordinate |
Definition at line 467 of file range_image.hpp.
PointWithRange & pcl::RangeImage::getPointNoCheck | ( | int | image_x, |
int | image_y | ||
) | [inline, inherited] |
Non-const-version of getPointNoCheck.
Definition at line 474 of file range_image.hpp.
float pcl::RangeImage::getRangeDifference | ( | const Eigen::Vector3f & | point | ) | const [inline, inherited] |
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)
Definition at line 364 of file range_image.hpp.
PCL_EXPORTS void pcl::RangeImage::getRangeImageWithSmoothedSurface | ( | int | radius, |
RangeImage & | smoothed_range_image | ||
) | const [inherited] |
Project all points on the local plane approximation, thereby smoothing the surface of the scan.
PCL_EXPORTS float* pcl::RangeImage::getRangesArray | ( | ) | const [inherited] |
Get all the range values in one float array of size width*height.
void pcl::RangeImage::getRotationToViewerCoordinateFrame | ( | const Eigen::Vector3f & | point, |
Eigen::Affine3f & | transformation | ||
) | const [inline, inherited] |
Same as above, but only returning the rotation.
Definition at line 1157 of file range_image.hpp.
const Eigen::Vector3f pcl::RangeImage::getSensorPos | ( | ) | const [inline, inherited] |
Get the sensor position.
Definition at line 653 of file range_image.hpp.
float pcl::RangeImage::getSquaredDistanceOfNthNeighbor | ( | int | x, |
int | y, | ||
int | radius, | ||
int | n, | ||
int | step_size | ||
) | const [inline, inherited] |
Definition at line 1029 of file range_image.hpp.
virtual PCL_EXPORTS void pcl::RangeImagePlanar::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 [virtual] |
Get a sub part of the complete image as a new range image.
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_) |
sub_image_image_offset_y | - Same as image_offset_x for the y coordinate |
sub_image_width | - width of the new image |
sub_image_height | - height of the new image |
combine_pixels | - shrinking factor, meaning the new angular resolution is combine_pixels times the old one |
sub_image | - the output image |
Reimplemented from pcl::RangeImage.
void pcl::RangeImage::getSurfaceAngleChange | ( | int | x, |
int | y, | ||
int | radius, | ||
float & | angle_change_x, | ||
float & | angle_change_y | ||
) | const [inline, inherited] |
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.
Definition at line 660 of file range_image.hpp.
PCL_EXPORTS void pcl::RangeImage::getSurfaceAngleChangeImages | ( | int | radius, |
float *& | angle_change_image_x, | ||
float *& | angle_change_image_y | ||
) | const [inherited] |
Uses the above function for every point in the image.
PCL_EXPORTS float pcl::RangeImage::getSurfaceChange | ( | int | x, |
int | y, | ||
int | radius | ||
) | const [inherited] |
Calculates, how much the surface changes at a point.
Pi meaning a flat suface and 0.0f would be a needle point Calculates, how much the surface changes at a point. 1 meaning a 90deg angle and 0 a flat suface
PCL_EXPORTS float* pcl::RangeImage::getSurfaceChangeImage | ( | int | radius | ) | const [inherited] |
Uses the above function for every point in the image.
bool pcl::RangeImage::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 = NULL , |
||
Eigen::Vector3f * | mean_all_neighbors = NULL , |
||
Eigen::Vector3f * | eigen_values_all_neighbors = NULL |
||
) | const [inline, inherited] |
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.
Definition at line 943 of file range_image.hpp.
const Eigen::Affine3f& pcl::RangeImage::getTransformationToRangeImageSystem | ( | ) | const [inline, inherited] |
Getter for the transformation from the world system into the range image system (the sensor coordinate frame)
Definition at line 228 of file range_image.h.
Eigen::Affine3f pcl::RangeImage::getTransformationToViewerCoordinateFrame | ( | const Eigen::Vector3f & | point | ) | const [inline, inherited] |
Get the local coordinate frame with 0,0,0 in point, upright and Z as the viewing direction.
Definition at line 1140 of file range_image.hpp.
void pcl::RangeImage::getTransformationToViewerCoordinateFrame | ( | const Eigen::Vector3f & | point, |
Eigen::Affine3f & | transformation | ||
) | const [inline, inherited] |
Same as above, using a reference for the retrurn value.
Definition at line 1149 of file range_image.hpp.
const Eigen::Affine3f& pcl::RangeImage::getTransformationToWorldSystem | ( | ) | const [inline, inherited] |
Getter for the transformation from the range image system (the sensor coordinate frame) into the world system.
Definition at line 238 of file range_image.h.
bool pcl::RangeImage::getViewingDirection | ( | int | x, |
int | y, | ||
Eigen::Vector3f & | viewing_direction | ||
) | const [inline, inherited] |
Get the viewing direction for the given point.
Definition at line 1123 of file range_image.hpp.
void pcl::RangeImage::getViewingDirection | ( | const Eigen::Vector3f & | point, |
Eigen::Vector3f & | viewing_direction | ||
) | const [inline, inherited] |
Get the viewing direction for the given point.
Definition at line 1133 of file range_image.hpp.
Definition at line 256 of file point_cloud.h.
void pcl::PointCloud::insert | ( | iterator | position, |
size_t | n, | ||
const PointT & | x | ||
) | [inline, inherited] |
Definition at line 263 of file point_cloud.h.
void pcl::PointCloud::insert | ( | iterator | position, |
InputIterator | first, | ||
InputIterator | last | ||
) | [inline, inherited] |
Definition at line 270 of file point_cloud.h.
PCL_EXPORTS void pcl::RangeImage::integrateFarRanges | ( | const PointCloud< PointWithViewpoint > & | far_ranges | ) | [inherited] |
Integrates the given far range measurements into the range image.
bool pcl::RangeImage::isInImage | ( | int | x, |
int | y | ||
) | const [inline, inherited] |
Check if a point is inside of the image.
Definition at line 399 of file range_image.hpp.
static bool pcl::RangeImage::isLargerPlane | ( | const ExtractedPlane & | p1, |
const ExtractedPlane & | p2 | ||
) | [inline, static, inherited] |
Comparator to enable us to sort a vector of Planes regarding their size using std::sort(begin(), end(), RangeImage::isLargerPlane);.
Definition at line 652 of file range_image.h.
bool pcl::RangeImage::isMaxRange | ( | int | x, |
int | y | ||
) | const [inline, inherited] |
Check if a point is a max range (range=INFINITY) - please check isInImage or isObserved first!
Definition at line 429 of file range_image.hpp.
bool pcl::RangeImage::isObserved | ( | int | x, |
int | y | ||
) | const [inline, inherited] |
Check if a point is inside of the image and has either a finite range or a max reading (range=INFINITY)
Definition at line 420 of file range_image.hpp.
bool pcl::PointCloud::isOrganized | ( | ) | const [inline, inherited] |
Return whether a dataset is organized (e.g., arranged in a structured grid).
Definition at line 173 of file point_cloud.h.
bool pcl::RangeImage::isValid | ( | int | x, |
int | y | ||
) | const [inline, inherited] |
Check if a point is inside of the image and has a finite range.
Definition at line 406 of file range_image.hpp.
bool pcl::RangeImage::isValid | ( | int | index | ) | const [inline, inherited] |
Check if a point has a finite range.
Definition at line 413 of file range_image.hpp.
Ptr pcl::RangeImagePlanar::makeShared | ( | ) | [inline] |
Get a boost shared pointer of a copy of this.
Reimplemented from pcl::RangeImage.
Definition at line 71 of file range_image_planar.h.
ConstPtr pcl::PointCloud::makeShared | ( | ) | const [inline, inherited] |
Copy the cloud to the heap and return a constant smart pointer Note that deep copy is performed, so avoid using this function on non-empty clouds.
Definition at line 312 of file point_cloud.h.
const PointT& pcl::PointCloud::operator() | ( | int | u, |
int | v | ||
) | const [inline, inherited] |
Definition at line 158 of file point_cloud.h.
PointT& pcl::PointCloud::operator() | ( | int | u, |
int | v | ||
) | [inline, inherited] |
Definition at line 164 of file point_cloud.h.
PointCloud& pcl::PointCloud::operator+= | ( | const PointCloud< PointWithRange > & | rhs | ) | [inline, inherited] |
Definition at line 119 of file point_cloud.h.
const PointT& pcl::PointCloud::operator[] | ( | size_t | n | ) | const [inline, inherited] |
Definition at line 241 of file point_cloud.h.
PointT& pcl::PointCloud::operator[] | ( | size_t | n | ) | [inline, inherited] |
Definition at line 242 of file point_cloud.h.
void pcl::PointCloud::push_back | ( | const PointT & | p | ) | [inline, inherited] |
Definition at line 251 of file point_cloud.h.
void pcl::RangeImage::real2DToInt2D | ( | float | x, |
float | y, | ||
int & | xInt, | ||
int & | yInt | ||
) | const [inline, inherited] |
Transforms an image point in float values to an image point in int values.
Definition at line 392 of file range_image.hpp.
PCL_EXPORTS void pcl::RangeImage::recalculate3DPointPositions | ( | ) | [inherited] |
Recalculate all 3D point positions according to their pixel position and range.
void pcl::PointCloud::reserve | ( | size_t | n | ) | [inline, inherited] |
Definition at line 236 of file point_cloud.h.
PCL_EXPORTS void pcl::RangeImage::reset | ( | ) | [inherited] |
Reset all values to an empty range image.
void pcl::PointCloud::resize | ( | size_t | n | ) | [inline, inherited] |
Definition at line 237 of file point_cloud.h.
void pcl::RangeImage::setAngularResolution | ( | float | angular_resolution | ) | [inline, inherited] |
Set the angular resolution of the range image.
angular_resolution | the new angular resolution (in radians per pixel) |
Definition at line 1165 of file range_image.hpp.
PCL_EXPORTS void pcl::RangeImagePlanar::setDepthImage | ( | const float * | depth_image, |
int | di_width, | ||
int | di_height, | ||
float | di_center_x, | ||
float | di_center_y, | ||
float | di_focal_length_x, | ||
float | di_focal_length_y, | ||
float | desired_angular_resolution = -1 |
||
) |
Create the image from an existing depth image.
depth_image | the input depth image data as float values |
di_width | the disparity image width |
di_height | the disparity image height |
di_center_x | the x-coordinate of the camera's center of projection |
di_center_y | the y-coordinate of the camera's center of projection |
di_focal_length_x | the camera's focal length in the horizontal direction |
di_focal_length_y | the camera's focal length in the vertical direction |
desired_angular_resolution | If this is set, the system will skip as many pixels as necessary to get as close to this angular resolution as possible while not going over this value (the density will not be lower than this value). The value is in radians per pixel. |
PCL_EXPORTS void pcl::RangeImagePlanar::setDepthImage | ( | const unsigned short * | depth_image, |
int | di_width, | ||
int | di_height, | ||
float | di_center_x, | ||
float | di_center_y, | ||
float | di_focal_length_x, | ||
float | di_focal_length_y, | ||
float | desired_angular_resolution = -1 |
||
) |
Create the image from an existing depth image.
depth_image | the input disparity image data as short values describing millimeters |
di_width | the disparity image width |
di_height | the disparity image height |
di_center_x | the x-coordinate of the camera's center of projection |
di_center_y | the y-coordinate of the camera's center of projection |
di_focal_length_x | the camera's focal length in the horizontal direction |
di_focal_length_y | the camera's focal length in the vertical direction |
desired_angular_resolution | If this is set, the system will skip as many pixels as necessary to get as close to this angular resolution as possible while not going over this value (the density will not be lower than this value). The value is in radians per pixel. |
PCL_EXPORTS void pcl::RangeImagePlanar::setDisparityImage | ( | const float * | disparity_image, |
int | di_width, | ||
int | di_height, | ||
float | focal_length, | ||
float | base_line, | ||
float | desired_angular_resolution = -1 |
||
) |
Create the image from an existing disparity image.
disparity_image | the input disparity image data |
di_width | the disparity image width |
di_height | the disparity image height |
focal_length | the focal length of the primary camera that generated the disparity image |
base_line | the baseline of the stereo pair that generated the disparity image |
desired_angular_resolution | If this is set, the system will skip as many pixels as necessary to get as close to this angular resolution as possible while not going over this value (the density will not be lower than this value). The value is in radians per pixel. |
void pcl::RangeImage::setImageOffsets | ( | int | offset_x, |
int | offset_y | ||
) | [inline, inherited] |
Setter for image offsets.
Definition at line 516 of file range_image.h.
void pcl::RangeImage::setTransformationToRangeImageSystem | ( | const Eigen::Affine3f & | to_range_image_system | ) | [inline, inherited] |
Setter for the transformation from the range image system (the sensor coordinate frame) into the world system.
Definition at line 1172 of file range_image.hpp.
PCL_EXPORTS void pcl::RangeImage::setUnseenToMaxRange | ( | ) | [inherited] |
Sets all -INFINITY values to INFINITY.
size_t pcl::PointCloud::size | ( | ) | const [inline, inherited] |
Definition at line 235 of file point_cloud.h.
void pcl::PointCloud::swap | ( | PointCloud< PointT > & | rhs | ) | [inline, inherited] |
Definition at line 288 of file point_cloud.h.
bool pcl::RangeImage::debug [static, inherited] |
pcl::PointCloud::EIGEN_MAKE_ALIGNED_OPERATOR_NEW [inherited] |
Definition at line 321 of file point_cloud.h.
std_msgs::Header pcl::PointCloud::header [inherited] |
The point cloud header.
It contains information about the acquisition time, as well as a transform frame (see tf).
Definition at line 203 of file point_cloud.h.
uint32_t pcl::PointCloud::height [inherited] |
The point cloud height (if organized as an image-structure).
Definition at line 211 of file point_cloud.h.
bool pcl::PointCloud::is_dense [inherited] |
True if no points are invalid (e.g., have NaN or Inf values).
Definition at line 214 of file point_cloud.h.
int pcl::RangeImage::max_no_of_threads [static, inherited] |
The maximum number of openmp threads that can be used in this class.
Definition at line 80 of file range_image.h.
std::vector<PointT, Eigen::aligned_allocator<PointT> > pcl::PointCloud::points [inherited] |
The point data.
Definition at line 206 of file point_cloud.h.
Eigen::Quaternionf pcl::PointCloud::sensor_orientation_ [inherited] |
Sensor acquisition pose (rotation).
Definition at line 219 of file point_cloud.h.
Eigen::Vector4f pcl::PointCloud::sensor_origin_ [inherited] |
Sensor acquisition pose (origin/translation).
Definition at line 217 of file point_cloud.h.
uint32_t pcl::PointCloud::width [inherited] |
The point cloud width (if organized as an image-structure).
Definition at line 209 of file point_cloud.h.