cluster_types.h

Go to the documentation of this file.

#ifndef __COB_3D_SEGMENTATION_CLUSTER_TYPES_H__
#define __COB_3D_SEGMENTATION_CLUSTER_TYPES_H__

#include <pcl/common/eigen.h>
#include <set>
#include <cob_3d_mapping_common/dominant_color.h>
#include <cob_3d_segmentation/polygon_extraction/polygon_types.h>

namespace cob_3d_segmentation
{

  class ClusterBase
  {
  public:
    typedef std::vector<int>::iterator iterator;
    typedef std::vector<int>::size_type size_type;
    typedef std::vector<int>::value_type value_type;

  public:
    explicit ClusterBase(int id)
      : indices_()
      , id_(id)
    { };
    virtual ~ClusterBase() { }

    inline const int id() const { return id_; }

    inline value_type& operator[](size_type idx) { return indices_.at(idx); }
    inline iterator begin() { return indices_.begin(); }
    inline iterator end() { return indices_.end(); }
    inline size_type size() const { return indices_.size(); }

    inline void addIndex(int idx) { indices_.push_back(idx); }

    std::vector<int> indices_;
  protected:
    int id_;

  };

  class DepthCluster : public ClusterBase
  {
    template <typename LabelT, typename PointT, typename PointNT> friend class DepthClusterHandler;

  public:
    DepthCluster(int id)
      : ClusterBase(id)
      , type(I_UNDEF)
      , type_probability(1.0)
      , is_planar_(false)
      , max_curvature(0.0)
      , min_curvature(0.0)
      , pca_point_comp1(0.0, 0.0, 0.0)
      , pca_point_comp2(0.0, 0.0, 0.0)
      , pca_point_comp3(0.0, 0.0, 0.0)
      , pca_point_values(0.0, 0.0, 0.0)
      , pca_inter_centroid(0.0, 0.0, 0.0)
      , pca_inter_comp1(0.0, 0.0, 0.0)
      , pca_inter_comp2(0.0, 0.0, 0.0)
      , pca_inter_comp3(0.0, 0.0, 0.0)
      , pca_inter_values(0.0, 0.0, 0.0)
      , border_points()
      , sum_points_(0.0, 0.0, 0.0)
      , sum_orientations_(0.0, 0.0, 0.0)
      , sum_rgb_(0,0,0)
    { }

    inline Eigen::Vector3f getCentroid() const { return sum_points_ / (float)indices_.size(); }
    inline Eigen::Vector3f getOrientation() const { return sum_orientations_ / (float)indices_.size(); }
    inline Eigen::Vector3i getMeanColorVector() const { return sum_rgb_ / indices_.size(); }
    inline int getMeanColorValue() const { Eigen::Vector3i c = getMeanColorVector(); return (c(0) << 16 | c(1) << 8 | c(2)); }
    inline Eigen::Vector3i computeDominantColorVector() const
    { uint8_t r,g,b; color_.getColor(r,g,b); return Eigen::Vector3i(r,g,b); }

  public:
    int type, label_color;
    float type_probability;
    bool is_planar_;
    float max_curvature;
    float min_curvature;

    Eigen::Vector3f pca_point_comp1;
    Eigen::Vector3f pca_point_comp2;
    Eigen::Vector3f pca_point_comp3;
    Eigen::Vector3f pca_point_values;

    Eigen::Vector3f pca_inter_centroid;
    Eigen::Vector3f pca_inter_comp1;
    Eigen::Vector3f pca_inter_comp2;
    Eigen::Vector3f pca_inter_comp3;
    Eigen::Vector3f pca_inter_values;

    std::vector<PolygonPoint> border_points;

  private:
    Eigen::Vector3f sum_points_;
    Eigen::Vector3f sum_orientations_;
    Eigen::Vector3i sum_rgb_;
    cob_3d_mapping::DominantColor color_;
  };

  inline const bool operator< (const ClusterBase& lhs, const ClusterBase& rhs){
    return lhs.size() < rhs.size();}
  inline const bool operator> (const ClusterBase& lhs, const ClusterBase& rhs){
    return  operator< (rhs, lhs);}
  inline const bool operator<=(const ClusterBase& lhs, const ClusterBase& rhs){
    return !operator> (lhs, rhs);}
  inline const bool operator>=(const ClusterBase& lhs, const ClusterBase& rhs){
    return !operator< (lhs, rhs);}
}

#endif