region_growing.h

Go to the documentation of this file.

/*
 * Software License Agreement (BSD License)
 *
 *  Point Cloud Library (PCL) - www.pointclouds.org
 *
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions
 *  are met:
 *
 *   * Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *   * Redistributions in binary form must reproduce the above
 *     copyright notice, this list of conditions and the following
 *     disclaimer in the documentation and/or other materials provided
 *     with the distribution.
 *   * Neither the name of the copyright holder(s) nor the names of its
 *     contributors may be used to endorse or promote products derived
 *     from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
 *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 *  POSSIBILITY OF SUCH DAMAGE.
 *
 * Author : Sergey Ushakov
 * Email  : mine_all_mine@bk.ru
 *
 */

#ifndef PCL_REGION_GROWING_H_
#define PCL_REGION_GROWING_H_

#include <pcl/pcl_base.h>
#include <pcl/search/search.h>
#include <pcl/point_cloud.h>
#include <pcl/point_types.h>
#include <list>
#include <math.h>
#include <time.h>

namespace pcl
{
  template <typename PointT, typename NormalT>
  class PCL_EXPORTS RegionGrowing : public pcl::PCLBase<PointT>
  {
    public:

      typedef pcl::search::Search <PointT> KdTree;
      typedef typename KdTree::Ptr KdTreePtr;
      typedef pcl::PointCloud <NormalT> Normal;
      typedef typename Normal::Ptr NormalPtr;
      typedef pcl::PointCloud <PointT> PointCloud;

      using PCLBase <PointT>::input_;
      using PCLBase <PointT>::indices_;
      using PCLBase <PointT>::initCompute;
      using PCLBase <PointT>::deinitCompute;

    public:

      RegionGrowing ();

      virtual
      ~RegionGrowing ();

      int
      getMinClusterSize ();

      void
      setMinClusterSize (int min_cluster_size);

      int
      getMaxClusterSize ();

      void
      setMaxClusterSize (int max_cluster_size);

      bool
      getSmoothModeFlag () const;

      void
      setSmoothModeFlag (bool value);

      bool
      getCurvatureTestFlag () const;

      virtual void
      setCurvatureTestFlag (bool value);

      bool
      getResidualTestFlag () const;

      virtual void
      setResidualTestFlag (bool value);

      float
      getSmoothnessThreshold () const;

      void
      setSmoothnessThreshold (float theta);

      float
      getResidualThreshold () const;

      void
      setResidualThreshold (float residual);

      float
      getCurvatureThreshold () const;

      void
      setCurvatureThreshold (float curvature);

      unsigned int
      getNumberOfNeighbours () const;

      void
      setNumberOfNeighbours (unsigned int neighbour_number);

      KdTreePtr
      getSearchMethod () const;

      void
      setSearchMethod (const KdTreePtr& tree);

      NormalPtr
      getInputNormals () const;

      void
      setInputNormals (const NormalPtr& norm);

      virtual void
      extract (std::vector <pcl::PointIndices>& clusters);

      virtual void
      getSegmentFromPoint (int index, pcl::PointIndices& cluster);

      pcl::PointCloud<pcl::PointXYZRGB>::Ptr
      getColoredCloud ();

      pcl::PointCloud<pcl::PointXYZRGBA>::Ptr
      getColoredCloudRGBA ();

    protected:

      virtual bool
      prepareForSegmentation ();

      virtual void
      findPointNeighbours ();

      void
      applySmoothRegionGrowingAlgorithm ();

      int
      growRegion (int initial_seed, int segment_number);

      virtual bool
      validatePoint (int initial_seed, int point, int nghbr, bool& is_a_seed) const;

      void
      assembleRegions ();

    protected:

      int min_pts_per_cluster_;

      int max_pts_per_cluster_;

      bool smooth_mode_flag_;

      bool curvature_flag_;

      bool residual_flag_;

      float theta_threshold_;

      float residual_threshold_;

      float curvature_threshold_;

      unsigned int neighbour_number_;

      KdTreePtr search_;

      NormalPtr normals_;

      std::vector<std::vector<int> > point_neighbours_;

      std::vector<int> point_labels_;

      bool normal_flag_;

      std::vector<int> num_pts_in_segment_;

      std::vector <pcl::PointIndices> clusters_;

      int number_of_segments_;

    public:
      EIGEN_MAKE_ALIGNED_OPERATOR_NEW
  };

  inline bool
  comparePair (std::pair<float, int> i, std::pair<float, int> j)
  {
    return (i.first < j.first);
  }
}

#ifdef PCL_NO_PRECOMPILE
#include <pcl/segmentation/impl/region_growing.hpp>
#endif

#endif