Loading...
Searching...
No Matches
pcl::RegionGrowingRGB< PointT, NormalT > Class Template Reference
Module segmentation

Implements the well known Region Growing algorithm used for segmentation based on color of points. More...

`#include <pcl/segmentation/region_growing_rgb.h>`

Inheritance diagram for pcl::RegionGrowingRGB< PointT, NormalT >:

## Public Member Functions

| RegionGrowingRGB ()
| Constructor that sets default values for member variables.
| ~RegionGrowingRGB () override
| Destructor that frees memory.
float | getPointColorThreshold () const
| Returns the color threshold value used for testing if points belong to the same region.
void | setPointColorThreshold (float thresh)
| This method specifies the threshold value for color test between the points.
float | getRegionColorThreshold () const
| Returns the color threshold value used for testing if regions can be merged.
void | setRegionColorThreshold (float thresh)
| This method specifies the threshold value for color test between the regions.
float | getDistanceThreshold () const
| Returns the distance threshold.
void | setDistanceThreshold (float thresh)
| Allows to set distance threshold.
unsigned int | getNumberOfRegionNeighbours () const
| Returns the number of nearest neighbours used for searching K nearest segments.
void | setNumberOfRegionNeighbours (unsigned int nghbr_number)
| This method allows to set the number of neighbours that is used for finding neighbouring segments.
bool | getNormalTestFlag () const
| Returns the flag that signalize if the smoothness test is turned on/off.
void | setNormalTestFlag (bool value)
| Allows to turn on/off the smoothness test.
void | setCurvatureTestFlag (bool value) override
| Allows to turn on/off the curvature test.
void | setResidualTestFlag (bool value) override
| Allows to turn on/off the residual test.
void | extract (std::vector< pcl::PointIndices > &clusters) override
| This method launches the segmentation algorithm and returns the clusters that were obtained during the segmentation.
void | getSegmentFromPoint (index_t index, pcl::PointIndices &cluster) override
| For a given point this function builds a segment to which it belongs and returns this segment.
Public Member Functions inherited from pcl::RegionGrowing< PointT, NormalT >
| RegionGrowing ()
| Constructor that sets default values for member variables.
| ~RegionGrowing () override
| This destructor destroys the cloud, normals and search method used for finding KNN.
pcl::uindex_t | getMinClusterSize ()
| Get the minimum number of points that a cluster needs to contain in order to be considered valid.
void | setMinClusterSize (pcl::uindex_t min_cluster_size)
| Set the minimum number of points that a cluster needs to contain in order to be considered valid.
pcl::uindex_t | getMaxClusterSize ()
| Get the maximum number of points that a cluster needs to contain in order to be considered valid.
void | setMaxClusterSize (pcl::uindex_t max_cluster_size)
| Set the maximum number of points that a cluster needs to contain in order to be considered valid.
bool | getSmoothModeFlag () const
| Returns the flag value.
void | setSmoothModeFlag (bool value)
| This function allows to turn on/off the smoothness constraint.
bool | getCurvatureTestFlag () const
| Returns the flag that signalize if the curvature test is turned on/off.
bool | getResidualTestFlag () const
| Returns the flag that signalize if the residual test is turned on/off.
float | getSmoothnessThreshold () const
| Returns smoothness threshold.
void | setSmoothnessThreshold (float theta)
| Allows to set smoothness threshold used for testing the points.
float | getResidualThreshold () const
| Returns residual threshold.
void | setResidualThreshold (float residual)
| Allows to set residual threshold used for testing the points.
float | getCurvatureThreshold () const
| Returns curvature threshold.
void | setCurvatureThreshold (float curvature)
| Allows to set curvature threshold used for testing the points.
unsigned int | getNumberOfNeighbours () const
| Returns the number of nearest neighbours used for KNN.
void | setNumberOfNeighbours (unsigned int neighbour_number)
| Allows to set the number of neighbours.
KdTreePtr | getSearchMethod () const
| Returns the pointer to the search method that is used for KNN.
void | setSearchMethod (const KdTreePtr &tree)
| Allows to set search method that will be used for finding KNN.
NormalPtr | getInputNormals () const
| Returns normals.
void | setInputNormals (const NormalPtr &norm)
| This method sets the normals.
pcl::PointCloud< pcl::PointXYZRGB >::Ptr | getColoredCloud ()
| If the cloud was successfully segmented, then function returns colored cloud.
pcl::PointCloud< pcl::PointXYZRGBA >::Ptr | getColoredCloudRGBA ()
| If the cloud was successfully segmented, then function returns colored cloud.
Public Member Functions inherited from pcl::PCLBase< PointT >
| PCLBase ()
| Empty constructor.
| PCLBase (const PCLBase &base)
| Copy constructor.
virtual | ~PCLBase ()=default
| Destructor.
virtual void | setInputCloud (const PointCloudConstPtr &cloud)
| Provide a pointer to the input dataset.
PointCloudConstPtr const | getInputCloud () const
| Get a pointer to the input point cloud dataset.
virtual void | setIndices (const IndicesPtr &indices)
| Provide a pointer to the vector of indices that represents the input data.
virtual void | setIndices (const IndicesConstPtr &indices)
| Provide a pointer to the vector of indices that represents the input data.
virtual void | setIndices (const PointIndicesConstPtr &indices)
| Provide a pointer to the vector of indices that represents the input data.
virtual void | setIndices (std::size_t row_start, std::size_t col_start, std::size_t nb_rows, std::size_t nb_cols)
| Set the indices for the points laying within an interest region of the point cloud.
IndicesPtr | getIndices ()
| Get a pointer to the vector of indices used.
IndicesConstPtr const | getIndices () const
| Get a pointer to the vector of indices used.
const PointT & | operator[] (std::size_t pos) const
| Override PointCloud operator[] to shorten code.

## Protected Member Functions

bool | prepareForSegmentation () override
| This method simply checks if it is possible to execute the segmentation algorithm with the current settings.
void | findPointNeighbours () override
| This method finds KNN for each point and saves them to the array because the algorithm needs to find KNN a few times.
void | findSegmentNeighbours ()
| This method simply calls the findRegionsKNN for each segment and saves the results for later use.
void | findRegionsKNN (pcl::index_t index, pcl::uindex_t nghbr_number, Indices &nghbrs, std::vector< float > &dist)
| This method finds K nearest neighbours of the given segment.
void | applyRegionMergingAlgorithm ()
| This function implements the merging algorithm described in the article "Color-based segmentation of point clouds" by Qingming Zhan, Yubin Liang, Yinghui Xiao.
float | calculateColorimetricalDifference (std::vector< unsigned int > &first_color, std::vector< unsigned int > &second_color) const
| This method calculates the colorimetrical difference between two points.
void | findRegionNeighbours (std::vector< std::vector< std::pair< float, pcl::index_t > > > &neighbours_out, std::vector< std::vector< int > > &regions_in)
| This method assembles the array containing neighbours of each homogeneous region.
void | assembleRegions (std::vector< unsigned int > &num_pts_in_region, int num_regions)
| This function simply assembles the regions from list of point labels.
bool | validatePoint (index_t initial_seed, index_t point, index_t nghbr, bool &is_a_seed) const override
| This function is checking if the point with index 'nghbr' belongs to the segment.
Protected Member Functions inherited from pcl::RegionGrowing< PointT, NormalT >
void | applySmoothRegionGrowingAlgorithm ()
| This function implements the algorithm described in the article "Segmentation of point clouds using smoothness constraint" by T.
int | growRegion (int initial_seed, int segment_number)
| This method grows a segment for the given seed point.
void | assembleRegions ()
| This function simply assembles the regions from list of point labels.
Protected Member Functions inherited from pcl::PCLBase< PointT >
bool | initCompute ()
| This method should get called before starting the actual computation.
bool | deinitCompute ()
| This method should get called after finishing the actual computation.

## Protected Attributes

float | color_p2p_threshold_ {1225.0f}
| Thershold used in color test for points.
float | color_r2r_threshold_ {10.0f}
| Thershold used in color test for regions.
float | distance_threshold_ {0.05f}
| Threshold that tells which points we need to assume neighbouring.
unsigned int | region_neighbour_number_ {100}
| Number of neighbouring segments to find.
std::vector< std::vector< float > > | point_distances_
| Stores distances for the point neighbours from point_neighbours_.
std::vector< pcl::Indices > | segment_neighbours_
| Stores the neighboures for the corresponding segments.
std::vector< std::vector< float > > | segment_distances_
| Stores distances for the segment neighbours from segment_neighbours_.
std::vector< int > | segment_labels_
| Stores new indices for segments that were obtained at the region growing stage.
Protected Attributes inherited from pcl::RegionGrowing< PointT, NormalT >
pcl::uindex_t | min_pts_per_cluster_ {1}
| Stores the minimum number of points that a cluster needs to contain in order to be considered valid.
pcl::uindex_t | max_pts_per_cluster_ {std::numeric_limits<pcl::uindex_t>::max()}
| Stores the maximum number of points that a cluster needs to contain in order to be considered valid.
bool | smooth_mode_flag_ {true}
| Flag that signalizes if the smoothness constraint will be used.
bool | curvature_flag_ {true}
| If set to true then curvature test will be done during segmentation.
bool | residual_flag_ {false}
| If set to true then residual test will be done during segmentation.
float | theta_threshold_ {30.0f / 180.0f * static_cast<float>(M_PI)}
| Threshold used for testing the smoothness between points.
float | residual_threshold_ {0.05f}
| Threshold used in residual test.
float | curvature_threshold_ {0.05f}
| Threshold used in curvature test.
unsigned int | neighbour_number_ {30}
| Number of neighbours to find.
KdTreePtr | search_ {nullptr}
| Search method that will be used for KNN.
NormalPtr | normals_ {nullptr}
| Contains normals of the points that will be segmented.
std::vector< pcl::Indices > | point_neighbours_ {}
| Contains neighbours of each point.
std::vector< int > | point_labels_ {}
| Point labels that tells to which segment each point belongs.
bool | normal_flag_ {true}
| If set to true then normal/smoothness test will be done during segmentation.
std::vector< pcl::uindex_t > | num_pts_in_segment_ {}
| Tells how much points each segment contains.
std::vector< pcl::PointIndices > | clusters_ {}
| After the segmentation it will contain the segments.
int | number_of_segments_ {0}
| Stores the number of segments.
Protected Attributes inherited from pcl::PCLBase< PointT >
PointCloudConstPtr | input_
| The input point cloud dataset.
IndicesPtr | indices_
| A pointer to the vector of point indices to use.
bool | use_indices_
| Set to true if point indices are used.
bool | fake_indices_
| If no set of indices are given, we construct a set of fake indices that mimic the input PointCloud.

## Additional Inherited Members

Public Types inherited from pcl::RegionGrowing< PointT, NormalT >
using | KdTree = pcl::search::Search< PointT >
using | KdTreePtr = typename KdTree::Ptr
using | Normal = pcl::PointCloud< NormalT >
using | NormalPtr = typename Normal::Ptr
using | PointCloud = pcl::PointCloud< PointT >
Public Types inherited from pcl::PCLBase< PointT >
using | PointCloud = pcl::PointCloud< PointT >
using | PointCloudPtr = typename PointCloud::Ptr
using | PointCloudConstPtr = typename PointCloud::ConstPtr
using | PointIndicesPtr = PointIndices::Ptr
using | PointIndicesConstPtr = PointIndices::ConstPtr

## Detailed Description

template<typename PointT, typename NormalT = pcl::Normal>
class pcl::RegionGrowingRGB< PointT, NormalT >

Implements the well known Region Growing algorithm used for segmentation based on color of points.

Description can be found in the article "Color-based segmentation of point clouds" by Qingming Zhan, Yubin Liang, Yinghui Xiao

Definition at line 56 of file region_growing_rgb.h.

## Constructor & Destructor Documentation

## RegionGrowingRGB()

template<typename PointT , typename NormalT >

pcl::RegionGrowingRGB< PointT, NormalT >::RegionGrowingRGB | ( |  | ) |

Constructor that sets default values for member variables.

Definition at line 52 of file region_growing_rgb.hpp.

References pcl::RegionGrowing< PointT, NormalT >::curvature_flag_, pcl::RegionGrowing< PointT, NormalT >::min_pts_per_cluster_, pcl::RegionGrowing< PointT, NormalT >::normal_flag_, and pcl::RegionGrowing< PointT, NormalT >::residual_flag_.

## ~RegionGrowingRGB()

template<typename PointT , typename NormalT >

pcl::RegionGrowingRGB< PointT, NormalT >::~RegionGrowingRGB | ( |  | ) |

override

Destructor that frees memory.

Definition at line 66 of file region_growing_rgb.hpp.

## Member Function Documentation

## applyRegionMergingAlgorithm()

template<typename PointT , typename NormalT >

void pcl::RegionGrowingRGB< PointT, NormalT >::applyRegionMergingAlgorithm | ( |  | ) |

protected

This function implements the merging algorithm described in the article "Color-based segmentation of point clouds" by Qingming Zhan, Yubin Liang, Yinghui Xiao.

Definition at line 362 of file region_growing_rgb.hpp.

References pcl::comparePair().

## assembleRegions()

template<typename PointT , typename NormalT >

void pcl::RegionGrowingRGB< PointT, NormalT >::assembleRegions | ( | std::vector< unsigned int > & | num_pts_in_region,
|  | int | num_regions
| ) |  |

protected

This function simply assembles the regions from list of point labels.

Parameters

  [in] | num_pts_in_region | for each final region it stores the corresponding number of points in it
  [in] | num_regions | number of regions to assemble

Definition at line 548 of file region_growing_rgb.hpp.

References pcl::PointIndices::indices.

## calculateColorimetricalDifference()

template<typename PointT , typename NormalT >

float pcl::RegionGrowingRGB< PointT, NormalT >::calculateColorimetricalDifference | ( | std::vector< unsigned int > & | first_color,
|  | std::vector< unsigned int > & | second_color
| ) |  | const

protected

This method calculates the colorimetrical difference between two points.

In this case it simply returns the euclidean distance between two colors.

Parameters

  [in] | first_color | the color of the first point
  [in] | second_color | the color of the second point

Definition at line 505 of file region_growing_rgb.hpp.

## extract()

template<typename PointT , typename NormalT >

void pcl::RegionGrowingRGB< PointT, NormalT >::extract | ( | std::vector< pcl::PointIndices > & | clusters | ) |

override virtual

This method launches the segmentation algorithm and returns the clusters that were obtained during the segmentation.

Parameters

  [out] | clusters | clusters that were obtained. Each cluster is an array of point indices.

Reimplemented from pcl::RegionGrowing< PointT, NormalT >.

Definition at line 160 of file region_growing_rgb.hpp.

References pcl::RegionGrowing< PointT, NormalT >::assembleRegions().

## findPointNeighbours()

template<typename PointT , typename NormalT >

void pcl::RegionGrowingRGB< PointT, NormalT >::findPointNeighbours | ( |  | ) |

override protected virtual

This method finds KNN for each point and saves them to the array because the algorithm needs to find KNN a few times.

Reimplemented from pcl::RegionGrowing< PointT, NormalT >.

Definition at line 269 of file region_growing_rgb.hpp.

## findRegionNeighbours()

template<typename PointT , typename NormalT >

void pcl::RegionGrowingRGB< PointT, NormalT >::findRegionNeighbours | ( | std::vector< std::vector< std::pair< float, pcl::index_t > > > & | neighbours_out,
|  | std::vector< std::vector< int > > & | regions_in
| ) |  |

protected

This method assembles the array containing neighbours of each homogeneous region.

Homogeneous region is the union of some segments. This array is used when the regions with a few points need to be merged with the neighbouring region.

Parameters

  [out] | neighbours_out | vector of lists of neighbours for every homogeneous region
  [in] | regions_in | vector of lists, each list contains indices of segments that belong to the corresponding homogeneous region.

Definition at line 516 of file region_growing_rgb.hpp.

References pcl::comparePair().

## findRegionsKNN()

template<typename PointT , typename NormalT >

void pcl::RegionGrowingRGB< PointT, NormalT >::findRegionsKNN | ( | pcl::index_t | index,
|  | pcl::uindex_t | nghbr_number,
|  | pcl::Indices & | nghbrs,
|  | std::vector< float > & | dist
| ) |  |

protected

This method finds K nearest neighbours of the given segment.

Parameters

  [in] | index | index of the segment for which neighbours will be found
  [in] | nghbr_number | the number of neighbours to find
  [out] | nghbrs | the array of indices of the neighbours that were found
  [out] | dist | the array of distances to the corresponding neighbours

Definition at line 308 of file region_growing_rgb.hpp.

## findSegmentNeighbours()

template<typename PointT , typename NormalT >

void pcl::RegionGrowingRGB< PointT, NormalT >::findSegmentNeighbours | ( |  | ) |

protected

This method simply calls the findRegionsKNN for each segment and saves the results for later use.

Definition at line 289 of file region_growing_rgb.hpp.

## getDistanceThreshold()

template<typename PointT , typename NormalT >

float pcl::RegionGrowingRGB< PointT, NormalT >::getDistanceThreshold | ( |  | ) | const

Returns the distance threshold.

If the distance between two points is less or equal to distance threshold value, then those points assumed to be neighbouring points.

Definition at line 104 of file region_growing_rgb.hpp.

## getNormalTestFlag()

template<typename PointT , typename NormalT >

bool pcl::RegionGrowingRGB< PointT, NormalT >::getNormalTestFlag | ( |  | ) | const

Returns the flag that signalize if the smoothness test is turned on/off.

Definition at line 132 of file region_growing_rgb.hpp.

## getNumberOfRegionNeighbours()

template<typename PointT , typename NormalT >

unsigned int pcl::RegionGrowingRGB< PointT, NormalT >::getNumberOfRegionNeighbours | ( |  | ) | const

Returns the number of nearest neighbours used for searching K nearest segments.

Note that here it refers to the segments(not the points).

Definition at line 118 of file region_growing_rgb.hpp.

## getPointColorThreshold()

template<typename PointT , typename NormalT >

float pcl::RegionGrowingRGB< PointT, NormalT >::getPointColorThreshold | ( |  | ) | const

Returns the color threshold value used for testing if points belong to the same region.

Definition at line 76 of file region_growing_rgb.hpp.

## getRegionColorThreshold()

template<typename PointT , typename NormalT >

float pcl::RegionGrowingRGB< PointT, NormalT >::getRegionColorThreshold | ( |  | ) | const

Returns the color threshold value used for testing if regions can be merged.

Definition at line 90 of file region_growing_rgb.hpp.

## getSegmentFromPoint()

template<typename PointT , typename NormalT >

void pcl::RegionGrowingRGB< PointT, NormalT >::getSegmentFromPoint | ( | pcl::index_t | index,
|  | pcl::PointIndices & | cluster
| ) |  |

override virtual

For a given point this function builds a segment to which it belongs and returns this segment.

Parameters

  [in] | index | index of the initial point which will be the seed for growing a segment.
  | cluster |

Reimplemented from pcl::RegionGrowing< PointT, NormalT >.

Definition at line 672 of file region_growing_rgb.hpp.

References pcl::RegionGrowing< PointT, NormalT >::assembleRegions(), and pcl::PointIndices::indices.

## prepareForSegmentation()

template<typename PointT , typename NormalT >

bool pcl::RegionGrowingRGB< PointT, NormalT >::prepareForSegmentation | ( |  | ) |

override protected virtual

This method simply checks if it is possible to execute the segmentation algorithm with the current settings.

If it is possible then it returns true.

Reimplemented from pcl::RegionGrowing< PointT, NormalT >.

Definition at line 214 of file region_growing_rgb.hpp.

## setCurvatureTestFlag()

template<typename PointT , typename NormalT >

void pcl::RegionGrowingRGB< PointT, NormalT >::setCurvatureTestFlag | ( | bool | value | ) |

override virtual

Allows to turn on/off the curvature test.

Parameters

  [in] | value | new value for curvature test. If set to true then the test will be turned on

Reimplemented from pcl::RegionGrowing< PointT, NormalT >.

Definition at line 146 of file region_growing_rgb.hpp.

## setDistanceThreshold()

template<typename PointT , typename NormalT >

void pcl::RegionGrowingRGB< PointT, NormalT >::setDistanceThreshold | ( | float | thresh | ) |

Allows to set distance threshold.

Parameters

  [in] | thresh | new threshold value for neighbour test

Definition at line 111 of file region_growing_rgb.hpp.

## setNormalTestFlag()

template<typename PointT , typename NormalT >

void pcl::RegionGrowingRGB< PointT, NormalT >::setNormalTestFlag | ( | bool | value | ) |

Allows to turn on/off the smoothness test.

Parameters

  [in] | value | new value for normal/smoothness test. If set to true then the test will be turned on

Definition at line 139 of file region_growing_rgb.hpp.

## setNumberOfRegionNeighbours()

template<typename PointT , typename NormalT >

void pcl::RegionGrowingRGB< PointT, NormalT >::setNumberOfRegionNeighbours | ( | unsigned int | nghbr_number | ) |

This method allows to set the number of neighbours that is used for finding neighbouring segments.

Neighbouring segments are needed for the merging process.

Parameters

  [in] | nghbr_number | the number of neighbouring segments to find

Definition at line 125 of file region_growing_rgb.hpp.

## setPointColorThreshold()

template<typename PointT , typename NormalT >

void pcl::RegionGrowingRGB< PointT, NormalT >::setPointColorThreshold | ( | float | thresh | ) |

This method specifies the threshold value for color test between the points.

This kind of testing is made at the first stage of the algorithm(region growing). If the difference between points color is less than threshold value, then they are considered to be in the same region.

Parameters

  [in] | thresh | new threshold value for color test

Definition at line 83 of file region_growing_rgb.hpp.

## setRegionColorThreshold()

template<typename PointT , typename NormalT >

void pcl::RegionGrowingRGB< PointT, NormalT >::setRegionColorThreshold | ( | float | thresh | ) |

This method specifies the threshold value for color test between the regions.

This kind of testing is made at the second stage of the algorithm(region merging). If the difference between segments color is less than threshold value, then they are merged together.

Parameters

  [in] | thresh | new threshold value for color test

Definition at line 97 of file region_growing_rgb.hpp.

## setResidualTestFlag()

template<typename PointT , typename NormalT >

void pcl::RegionGrowingRGB< PointT, NormalT >::setResidualTestFlag | ( | bool | value | ) |

override virtual

Allows to turn on/off the residual test.

Parameters

  [in] | value | new value for residual test. If set to true then the test will be turned on

Reimplemented from pcl::RegionGrowing< PointT, NormalT >.

Definition at line 153 of file region_growing_rgb.hpp.

## validatePoint()

template<typename PointT , typename NormalT >

bool pcl::RegionGrowingRGB< PointT, NormalT >::validatePoint | ( | pcl::index_t | initial_seed,
|  | pcl::index_t | point,
|  | pcl::index_t | nghbr,
|  | bool & | is_a_seed
| ) |  | const

override protected virtual

This function is checking if the point with index 'nghbr' belongs to the segment.

If so, then it returns true. It also checks if this point can serve as the seed.

Parameters

  [in] | initial_seed | index of the initial point that was passed to the growRegion() function
  [in] | point | index of the current seed point
  [in] | nghbr | index of the point that is neighbour of the current seed
  [out] | is_a_seed | this value is set to true if the point with index 'nghbr' can serve as the seed

Reimplemented from pcl::RegionGrowing< PointT, NormalT >.

Definition at line 593 of file region_growing_rgb.hpp.

## Member Data Documentation

## color_p2p_threshold_

template<typename PointT , typename NormalT = pcl::Normal>

float pcl::RegionGrowingRGB< PointT, NormalT >::color_p2p_threshold_ {1225.0f}

protected

Thershold used in color test for points.

Definition at line 255 of file region_growing_rgb.h.

## color_r2r_threshold_

template<typename PointT , typename NormalT = pcl::Normal>

float pcl::RegionGrowingRGB< PointT, NormalT >::color_r2r_threshold_ {10.0f}

protected

Thershold used in color test for regions.

Definition at line 258 of file region_growing_rgb.h.

## distance_threshold_

template<typename PointT , typename NormalT = pcl::Normal>

float pcl::RegionGrowingRGB< PointT, NormalT >::distance_threshold_ {0.05f}

protected

Threshold that tells which points we need to assume neighbouring.

Definition at line 261 of file region_growing_rgb.h.

## point_distances_

template<typename PointT , typename NormalT = pcl::Normal>

std::vector< std::vector<float> > pcl::RegionGrowingRGB< PointT, NormalT >::point_distances_

protected

Stores distances for the point neighbours from point_neighbours_.

Definition at line 267 of file region_growing_rgb.h.

## region_neighbour_number_

template<typename PointT , typename NormalT = pcl::Normal>

unsigned int pcl::RegionGrowingRGB< PointT, NormalT >::region_neighbour_number_ {100}

protected

Number of neighbouring segments to find.

Definition at line 264 of file region_growing_rgb.h.

## segment_distances_

template<typename PointT , typename NormalT = pcl::Normal>

std::vector< std::vector<float> > pcl::RegionGrowingRGB< PointT, NormalT >::segment_distances_

protected

Stores distances for the segment neighbours from segment_neighbours_.

Definition at line 273 of file region_growing_rgb.h.

## segment_labels_

template<typename PointT , typename NormalT = pcl::Normal>

std::vector<int> pcl::RegionGrowingRGB< PointT, NormalT >::segment_labels_

protected

Stores new indices for segments that were obtained at the region growing stage.

Definition at line 276 of file region_growing_rgb.h.

## segment_neighbours_

template<typename PointT , typename NormalT = pcl::Normal>

std::vector< pcl::Indices > pcl::RegionGrowingRGB< PointT, NormalT >::segment_neighbours_

protected

Stores the neighboures for the corresponding segments.

Definition at line 270 of file region_growing_rgb.h.

The documentation for this class was generated from the following files:

- pcl/segmentation/region_growing_rgb.h
- pcl/segmentation/impl/region_growing_rgb.hpp