Point Cloud Library (PCL)
1.3.1
|
RangeImage is derived from pcl/PointCloud and provides functionalities with focus on situations where a 3D scene was captured from a specific view point. More...
#include <pcl/range_image/range_image.h>
Classes | |
struct | ExtractedPlane |
Helper struct to return the results of a plane extraction. More... | |
Public Types | |
enum | CoordinateFrame { CAMERA_FRAME = 0, LASER_FRAME = 1 } |
typedef pcl::PointCloud < PointWithRange > | BaseClass |
typedef std::vector < Eigen::Vector3f, Eigen::aligned_allocator < Eigen::Vector3f > > | VectorOfEigenVector3f |
typedef boost::shared_ptr < RangeImage > | Ptr |
typedef boost::shared_ptr < const RangeImage > | ConstPtr |
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 | RangeImage () |
Constructor. | |
PCL_EXPORTS | ~RangeImage () |
Destructor. | |
Ptr | makeShared () |
Get a boost shared pointer of a copy of this. | |
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. | |
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. | |
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 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. | |
const PointWithRange & | getPoint (int index) const |
Return the 3d point with range at the given index (whereas index=y*width+x) | |
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. | |
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. | |
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. | |
virtual void | getImagePoint (const Eigen::Vector3f &point, float &image_x, float &image_y, float &range) const |
Get imagePoint from 3D point in world coordinates. | |
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. | |
virtual void | getSubImage (int sub_image_image_offset_x, int sub_image_image_offset_y, int sub_image_width, int sub_image_height, int combine_pixels, RangeImage &sub_image) const |
Get a sub part of the complete image as a new range image. | |
virtual void | getHalfImage (RangeImage &half_image) const |
Get a range image with half the resolution. | |
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. | |
virtual RangeImage * | getNew () const |
Return a newly created Range image. | |
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 () |
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. | |
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... |
RangeImage is derived from pcl/PointCloud and provides functionalities with focus on situations where a 3D scene was captured from a specific view point.
Reimplemented in pcl::RangeImagePlanar.
Definition at line 60 of file range_image.h.
typedef VectorType::const_iterator pcl::PointCloud::const_iterator [inherited] |
Definition at line 228 of file point_cloud.h.
typedef boost::shared_ptr<const RangeImage> pcl::RangeImage::ConstPtr |
Reimplemented from pcl::PointCloud< PointWithRange >.
Reimplemented in pcl::RangeImagePlanar.
Definition at line 63 of file range_image.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<RangeImage> pcl::RangeImage::Ptr |
Reimplemented from pcl::PointCloud< PointWithRange >.
Reimplemented in pcl::RangeImagePlanar.
Definition at line 62 of file range_image.h.
typedef std::vector<Eigen::Vector3f, Eigen::aligned_allocator<Eigen::Vector3f> > pcl::RangeImage::VectorOfEigenVector3f |
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.
Definition at line 65 of file range_image.h.
PCL_EXPORTS pcl::RangeImage::RangeImage | ( | ) |
Constructor.
PCL_EXPORTS pcl::RangeImage::~RangeImage | ( | ) |
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::RangeImage::calculate3DPoint | ( | float | image_x, |
float | image_y, | ||
float | range, | ||
PointWithRange & | point | ||
) | const [inline] |
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] |
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, | ||
float | range, | ||
Eigen::Vector3f & | point | ||
) | const [inline, virtual] |
Calculate the 3D point according to the given image point and range.
Reimplemented in pcl::RangeImagePlanar.
Definition at line 543 of file range_image.hpp.
void pcl::RangeImage::calculate3DPoint | ( | float | image_x, |
float | image_y, | ||
Eigen::Vector3f & | point | ||
) | const [inline] |
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 | ( | ) |
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] |
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) |
||
) |
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 |
||
) |
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::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 |
||
) |
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 |
||
) |
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 |
||
) |
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 |
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 |
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] |
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 |
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] |
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] |
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] |
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 |
Calculate getAcutenessValue for every point.
void pcl::RangeImage::getAnglesFromImagePoint | ( | float | image_x, |
float | image_y, | ||
float & | angle_x, | ||
float & | angle_y | ||
) | const [inline] |
Get the angles corresponding to the given image point.
Definition at line 581 of file range_image.hpp.
float pcl::RangeImage::getAngularResolution | ( | ) | const [inline] |
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] |
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] |
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 |
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 |
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] |
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] |
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] |
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] |
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] |
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] |
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 void pcl::RangeImage::getHalfImage | ( | RangeImage & | half_image | ) | const [virtual] |
Get a range image with half the resolution.
Reimplemented in pcl::RangeImagePlanar.
int pcl::RangeImage::getImageOffsetX | ( | ) | const [inline] |
Getter for image_offset_x_.
Definition at line 509 of file range_image.h.
int pcl::RangeImage::getImageOffsetY | ( | ) | const [inline] |
Getter for image_offset_y_.
Definition at line 512 of file range_image.h.
void pcl::RangeImage::getImagePoint | ( | const Eigen::Vector3f & | point, |
float & | image_x, | ||
float & | image_y, | ||
float & | range | ||
) | const [inline, virtual] |
Get imagePoint from 3D point in world coordinates.
Reimplemented in pcl::RangeImagePlanar.
Definition at line 311 of file range_image.hpp.
void pcl::RangeImage::getImagePoint | ( | const Eigen::Vector3f & | point, |
int & | image_x, | ||
int & | image_y, | ||
float & | range | ||
) | const [inline] |
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] |
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] |
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] |
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] |
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] |
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] |
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] |
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] |
Same as above.
Definition at line 590 of file range_image.hpp.
float pcl::RangeImage::getImpactAngleBasedOnLocalNormal | ( | int | x, |
int | y, | ||
int | radius | ||
) | const [inline] |
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 |
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 |
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 |
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 |
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] |
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 |
Find the minimum and maximum range in the image.
virtual RangeImage* pcl::RangeImage::getNew | ( | ) | const [inline, virtual] |
Return a newly created Range image.
Can be reimplmented in derived classes like RangeImagePlanar to return an image of the same type.
Reimplemented in pcl::RangeImagePlanar.
Definition at line 672 of file range_image.h.
bool pcl::RangeImage::getNormal | ( | int | x, |
int | y, | ||
int | radius, | ||
Eigen::Vector3f & | normal, | ||
int | step_size = 1 |
||
) | const [inline] |
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] |
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 |
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] |
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] |
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] |
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 |
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] |
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] |
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] |
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] |
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] |
Same as above.
Definition at line 514 of file range_image.hpp.
void pcl::RangeImage::getPoint | ( | int | index, |
Eigen::Vector3f & | point | ||
) | const [inline] |
Same as above.
Definition at line 522 of file range_image.hpp.
const PointWithRange & pcl::RangeImage::getPoint | ( | int | index | ) | const [inline] |
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] |
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] |
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] |
Non-const-version of getPointNoCheck.
Definition at line 474 of file range_image.hpp.
float pcl::RangeImage::getRangeDifference | ( | const Eigen::Vector3f & | point | ) | const [inline] |
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 |
Project all points on the local plane approximation, thereby smoothing the surface of the scan.
PCL_EXPORTS float* pcl::RangeImage::getRangesArray | ( | ) | const |
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] |
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] |
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] |
Definition at line 1029 of file range_image.hpp.
virtual void pcl::RangeImage::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 in pcl::RangeImagePlanar.
void pcl::RangeImage::getSurfaceAngleChange | ( | int | x, |
int | y, | ||
int | radius, | ||
float & | angle_change_x, | ||
float & | angle_change_y | ||
) | const [inline] |
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 |
Uses the above function for every point in the image.
PCL_EXPORTS float pcl::RangeImage::getSurfaceChange | ( | int | x, |
int | y, | ||
int | radius | ||
) | const |
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 |
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] |
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] |
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] |
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] |
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] |
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] |
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] |
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 | ) |
Integrates the given far range measurements into the range image.
bool pcl::RangeImage::isInImage | ( | int | x, |
int | y | ||
) | const [inline] |
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] |
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] |
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] |
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] |
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] |
Check if a point has a finite range.
Definition at line 413 of file range_image.hpp.
Ptr pcl::RangeImage::makeShared | ( | ) | [inline] |
Get a boost shared pointer of a copy of this.
Reimplemented from pcl::PointCloud< PointWithRange >.
Reimplemented in pcl::RangeImagePlanar.
Definition at line 126 of file range_image.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] |
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 | ( | ) |
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 | ( | ) |
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] |
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.
void pcl::RangeImage::setImageOffsets | ( | int | offset_x, |
int | offset_y | ||
) | [inline] |
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] |
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 | ( | ) |
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] |
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] |
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.