Galaxis Codebase: EuclideanDetector Class Reference

#include <PCLObjectDetector.hpp>

Inheritance diagram for EuclideanDetector:

Collaboration diagram for EuclideanDetector:

Public Member Functions
	EuclideanDetector ()

std::shared_ptr< std::vector< pcl::PointCloud< pcl::PointXYZ >::Ptr > >	cluster_data (pclPtrType p_pclPtr, std::vector< Object > &p_objectsVecRef, float clusterTolerance, int minClusterSize, int maxClusterSize) const

Public Member Functions inherited from PCLObjectDetector
int	filter_pcl (pclPtrType p_pclPtr, pclPtrType p_cloudFiltered, float p_leafsize, float y_min, float y_max)

std::string	get_name (void)

Public Attributes
float	m_minSizeX = 0.1

float	m_minSizeY = 0.2

float	m_minSizeZ = 0.001f

float	m_maxSizeX = 1.f

float	m_maxSizeY = 1.f

float	m_maxSizeZ = 1.f

float	m_postProcessingClusterSizeMin = 200

float	m_postProcessingClusterSizeMax = 2000

Additional Inherited Members
Protected Attributes inherited from PCLObjectDetector
std::string	m_name = "none"

Detailed Description

Definition at line 61 of file PCLObjectDetector.hpp.

Constructor & Destructor Documentation

◆ EuclideanDetector()

EuclideanDetector::EuclideanDetector ( )

inline

Definition at line 63 of file PCLObjectDetector.hpp.

                       {
     m_name = "euclidean detector";
   };

References PCLObjectDetector::m_name.

Member Function Documentation

◆ cluster_data()

std::shared_ptr< std::vector< pcl::PointCloud< pcl::PointXYZ >::Ptr > > EuclideanDetector::cluster_data	(	pclPtrType	p_pclPtr,
		std::vector< Object > &	p_objectsVecRef,
		float	clusterTolerance,
		int	minClusterSize,
		int	maxClusterSize
	)		const

virtual

Implements PCLObjectDetector.

Definition at line 7 of file PCLObjectDetector.cpp.

                                                                                                                                                                                                                      {
   
   auto pointCloudPtrVectorSPtr = std::make_shared<std::vector<pcl::PointCloud<pcl::PointXYZ>::Ptr>>();
   
   // check if filtered cloud is empty to skip unnecessary computation
   if(p_pclPtr->size() == 0) return pointCloudPtrVectorSPtr;
  
   pcl::search::KdTree<pcl::PointXYZ>::Ptr tree(new pcl::search::KdTree<pcl::PointXYZ>);
   tree->setInputCloud(p_pclPtr);
  
   std::vector<pcl::PointIndices> clusterIndices;
   pcl::EuclideanClusterExtraction<pcl::PointXYZ> ec;
   ec.setClusterTolerance(clusterTolerance); // m
   ec.setMinClusterSize(minClusterSize);
   ec.setMaxClusterSize(maxClusterSize);
   ec.setSearchMethod(tree);
   ec.setInputCloud(p_pclPtr);
   ec.extract(clusterIndices);
  
  
   float sizeX, sizeY, sizeZ;
   for(std::vector<pcl::PointIndices>::const_iterator it = clusterIndices.begin(); it != clusterIndices.end(); ++it) {
     pcl::PointCloud<pcl::PointXYZ>::Ptr cloudClusterPtr(new pcl::PointCloud<pcl::PointXYZ>);
  
     // create a sub cloud with all the indices extracted above
     for(std::vector<int>::const_iterator pit = it->indices.begin(); pit != it->indices.end(); ++pit) {
       cloudClusterPtr->points.push_back(p_pclPtr->points[*pit]);
     }
  
     // post processing
     pcl::PointXYZ minDimensions;
     pcl::PointXYZ maxDimensions;
     pcl::getMinMax3D(*cloudClusterPtr, minDimensions, maxDimensions);
  
     sizeX = std::fabs(maxDimensions.x - minDimensions.x);
     sizeY = std::fabs(maxDimensions.y - minDimensions.y);
     sizeZ = std::fabs(maxDimensions.z - minDimensions.z);
  
     if(cloudClusterPtr->size() < m_postProcessingClusterSizeMin) {
       log_debug("[RealSense] Object too small (min cluster points)");
       continue;
     }
  
     if(cloudClusterPtr->size() > m_postProcessingClusterSizeMax) {
       log_debug("[RealSense] Object too large (max cluster points)");
       continue;
     }
  
     if(sizeX > m_maxSizeX) {
       log_debug("[RealSense] Object too large (x)");
       continue;
     }
     if (sizeY > m_maxSizeY) {
       log_debug("[RealSense] Object too large (y)");
       continue;
     }
     if(sizeZ > m_maxSizeZ) {
       log_debug("[RealSense] Object too large (z)");
       continue;
     }
  
     if(sizeX < m_minSizeX) {
       log_debug("[RealSense] Object too small (x)");
       continue;
     }
     if (sizeY < m_minSizeY) {
       log_debug("[RealSense] Object too small (y)");
       continue;
     }
     if(sizeZ < m_minSizeZ) {
       log_debug("[RealSense] Object too small (z)");
       continue;
     }
  
     pcl::PointXYZ centerPoint;
     // get centerpoint and MinMax dimensions
     int centroidReturnValue = pcl::computeCentroid(*cloudClusterPtr, centerPoint);
  
     // store object in return vector
     Object foundObject;
     foundObject.set_max_dimensions(maxDimensions);
     foundObject.set_min_dimensions(minDimensions);
     foundObject.set_center_point(centerPoint);
     foundObject.size = cloudClusterPtr->size();
     p_objectsVecRef.push_back(foundObject);
  
     pointCloudPtrVectorSPtr->push_back(cloudClusterPtr);
   }
  
   log_debug("Objects Detected: ", p_objectsVecRef.size());
  
   return pointCloudPtrVectorSPtr;
 }