43 #include <boost/version.hpp>
45 #include <pcl/features/normal_3d.h>
47 #include <pcl/pcl_base.h>
49 #include <pcl/point_cloud.h>
51 #include <pcl/octree/octree_search.h>
52 #include <pcl/octree/octree_pointcloud_adjacency.h>
53 #include <pcl/search/search.h>
54 #include <boost/ptr_container/ptr_list.hpp>
66 template <
typename Po
intT>
75 using Ptr = shared_ptr<Supervoxel<PointT> >;
76 using ConstPtr = shared_ptr<const Supervoxel<PointT> >;
97 normal_arg.normal_x =
normal_.normal_x;
98 normal_arg.normal_y =
normal_.normal_y;
99 normal_arg.normal_z =
normal_.normal_z;
125 template <
typename Po
intT>
129 class SupervoxelHelper;
130 friend class SupervoxelHelper;
139 xyz_ (0.0f, 0.0f, 0.0f),
140 rgb_ (0.0f, 0.0f, 0.0f),
141 normal_ (0.0f, 0.0f, 0.0f, 0.0f),
153 template<
typename Po
intT2 = Po
intT, traits::HasColor<Po
intT2> = true>
void
154 getPoint (
PointT &point_arg)
const
156 point_arg.rgba =
static_cast<std::uint32_t
>(rgb_[0]) << 16 |
157 static_cast<std::uint32_t
>(rgb_[1]) << 8 |
158 static_cast<std::uint32_t
>(rgb_[2]);
159 point_arg.x = xyz_[0];
160 point_arg.y = xyz_[1];
161 point_arg.z = xyz_[2];
164 template<
typename Po
intT2 = Po
intT, traits::HasNoColor<Po
intT2> = true>
void
165 getPoint (
PointT &point_arg )
const
168 point_arg.x = xyz_[0];
169 point_arg.y = xyz_[1];
170 point_arg.z = xyz_[2];
178 getNormal (
Normal &normal_arg)
const;
183 float curvature_{0.0f};
184 float distance_{0.0f};
205 using VoxelAdjacencyList = boost::adjacency_list<boost::setS, boost::setS, boost::undirectedS, std::uint32_t, float>;
206 using VoxelID = VoxelAdjacencyList::vertex_descriptor;
207 using EdgeID = VoxelAdjacencyList::edge_descriptor;
225 setVoxelResolution (
float resolution);
229 getVoxelResolution ()
const;
233 setSeedResolution (
float seed_resolution);
237 getSeedResolution ()
const;
241 setColorImportance (
float val);
245 setSpatialImportance (
float val);
249 setNormalImportance (
float val);
262 setUseSingleCameraTransform (
bool val);
288 refineSupervoxels (
int num_itr, std::map<std::uint32_t,
typename Supervoxel<PointT>::Ptr > &supervoxel_clusters);
293 getVoxelCentroidCloud ()
const;
300 getLabeledCloud ()
const;
307 getLabeledVoxelCloud ()
const;
319 getSupervoxelAdjacency (std::multimap<std::uint32_t, std::uint32_t> &label_adjacency)
const;
331 getMaxLabel ()
const;
338 prepareForSegmentation ();
344 selectInitialSupervoxelSeeds (
Indices &seed_indices);
350 createSupervoxelHelpers (
Indices &seed_indices);
354 expandSupervoxels (
int depth);
362 reseedSupervoxels ();
372 float seed_resolution_;
380 transformFunction (
PointT &p);
395 float color_importance_{0.1f};
397 float spatial_importance_{0.4f};
399 float normal_importance_{1.0f};
405 bool use_single_camera_transform_;
407 bool use_default_transform_behaviour_{
true};
413 class SupervoxelHelper
425 return leaf_data_left.
idx_ < leaf_data_right.
idx_;
428 using LeafSetT = std::set<LeafContainerT*, typename SupervoxelHelper::compareLeaves>;
429 using iterator =
typename LeafSetT::iterator;
430 using const_iterator =
typename LeafSetT::const_iterator;
438 addLeaf (LeafContainerT* leaf_arg);
441 removeLeaf (LeafContainerT* leaf_arg);
469 {
return centroid_.normal_; }
473 {
return centroid_.rgb_; }
477 {
return centroid_.xyz_;}
480 getXYZ (
float &x,
float &y,
float &z)
const
481 { x=centroid_.xyz_[0]; y=centroid_.xyz_[1]; z=centroid_.xyz_[2]; }
484 getRGB (std::uint32_t &rgba)
const
486 rgba =
static_cast<std::uint32_t
>(centroid_.rgb_[0]) << 16 |
487 static_cast<std::uint32_t
>(centroid_.rgb_[1]) << 8 |
488 static_cast<std::uint32_t
>(centroid_.rgb_[2]);
494 normal_arg.normal_x = centroid_.normal_[0];
495 normal_arg.normal_y = centroid_.normal_[1];
496 normal_arg.normal_z = centroid_.normal_[2];
497 normal_arg.
curvature = centroid_.curvature_;
501 getNeighborLabels (std::set<std::uint32_t> &neighbor_labels)
const;
505 {
return centroid_; }
508 size ()
const {
return leaves_.size (); }
512 std::uint32_t label_;
514 SupervoxelClustering* parent_;
521 #if BOOST_VERSION >= 107000
527 using HelperListT = boost::ptr_list<SupervoxelHelper>;
528 HelperListT supervoxel_helpers_;
538 #ifdef PCL_NO_PRECOMPILE
539 #include <pcl/segmentation/impl/supervoxel_clustering.hpp>
PointCloud represents the base class in PCL for storing collections of 3D points.
shared_ptr< PointCloud< PointT > > Ptr
shared_ptr< const PointCloud< PointT > > ConstPtr
VoxelData is a structure used for storing data within a pcl::octree::OctreePointCloudAdjacencyContain...
void getPoint(PointT &point_arg) const
Gets the data of in the form of a point.
SupervoxelHelper * owner_
Implements a supervoxel algorithm based on voxel structure, normals, and rgb values.
VoxelAdjacencyList::edge_descriptor EdgeID
std::vector< LeafContainerT * > LeafVectorT
pcl::IndicesPtr IndicesPtr
boost::adjacency_list< boost::setS, boost::setS, boost::undirectedS, std::uint32_t, float > VoxelAdjacencyList
VoxelAdjacencyList::vertex_descriptor VoxelID
~SupervoxelClustering() override
This destructor destroys the cloud, normals and search method used for finding neighbors.
Supervoxel container class - stores a cluster extracted using supervoxel clustering.
pcl::PointXYZRGBA centroid_
The centroid of the supervoxel - average voxel.
pcl::PointCloud< Normal >::Ptr normals_
A Pointcloud of the normals for the points in the supervoxel.
shared_ptr< const Supervoxel< PointT > > ConstPtr
void getCentroidPoint(PointXYZRGBA ¢roid_arg)
Gets the centroid of the supervoxel.
shared_ptr< Supervoxel< PointT > > Ptr
pcl::PointCloud< PointT >::Ptr voxels_
A Pointcloud of the voxels in the supervoxel.
pcl::Normal normal_
The normal calculated for the voxels contained in the supervoxel.
void getCentroidPointNormal(PointNormal &normal_arg)
Gets the point normal for the supervoxel.
Octree adjacency leaf container class- stores a list of pointers to neighbors, number of points added...
DataT & getData()
Returns a reference to the data member to access it without copying.
Octree pointcloud voxel class which maintains adjacency information for its voxels.
shared_ptr< OctreeAdjacencyT > Ptr
Octree pointcloud search class
shared_ptr< pcl::search::Search< PointT > > Ptr
Defines all the PCL implemented PointT point type structures.
Define methods for measuring time spent in code blocks.
#define PCL_MAKE_ALIGNED_OPERATOR_NEW
Macro to signal a class requires a custom allocator.
Defines functions, macros and traits for allocating and using memory.
IndicesAllocator<> Indices
Type used for indices in PCL.
shared_ptr< Indices > IndicesPtr
Defines all the PCL and non-PCL macros used.
A point structure representing normal coordinates and the surface curvature estimate.
A point structure representing Euclidean xyz coordinates, together with normal coordinates and the su...
A point structure representing Euclidean xyz coordinates, and the RGBA color.
A point structure representing Euclidean xyz coordinates, and the RGB color.
Comparator for LeafContainerT pointers - used for sorting set of leaves.