coherence.h

Go to the documentation of this file.

#ifndef PCL_TRACKING_COHERENCE_H_
#define PCL_TRACKING_COHERENCE_H_

#include <pcl/pcl_base.h>

namespace pcl
{

  namespace tracking
  {

    template <typename PointInT>
    class PointCoherence
    {
    public:
      typedef boost::shared_ptr< PointCoherence<PointInT> > Ptr;
      typedef boost::shared_ptr< const PointCoherence<PointInT> > ConstPtr;
      
    public:
      PointCoherence () : coherence_name_ () {}
      
      virtual ~PointCoherence () {}

      inline double
      compute (PointInT &source, PointInT &target);

    protected:

      std::string coherence_name_;

      virtual double 
      computeCoherence (PointInT &source, PointInT &target) = 0;

      inline const std::string& 
      getClassName () const { return (coherence_name_); }

    };

    template <typename PointInT>
    class PointCloudCoherence
    {
    public:
      typedef boost::shared_ptr< PointCloudCoherence<PointInT> > Ptr;
      typedef boost::shared_ptr< const PointCloudCoherence<PointInT> > ConstPtr;

      typedef pcl::PointCloud<PointInT> PointCloudIn;
      typedef typename PointCloudIn::Ptr PointCloudInPtr;
      typedef typename PointCloudIn::ConstPtr PointCloudInConstPtr;
      
      typedef typename PointCoherence<PointInT>::Ptr PointCoherencePtr;
      PointCloudCoherence () : coherence_name_ (), target_input_ (), point_coherences_ () {}

      virtual ~PointCloudCoherence () {}

      inline void
      compute (const PointCloudInConstPtr &cloud, const IndicesConstPtr &indices,
               float &w_i);

      inline std::vector<PointCoherencePtr>
      getPointCoherences () { return point_coherences_; }

      inline void
      setPointCoherences (std::vector<PointCoherencePtr> coherences) { point_coherences_ = coherences; }

      virtual bool initCompute ();
      
      inline void
      addPointCoherence (PointCoherencePtr coherence) { point_coherences_.push_back (coherence); }

      virtual inline void
      setTargetCloud (const PointCloudInConstPtr &cloud)  { target_input_ = cloud; }
      
    protected:
      virtual void
      computeCoherence (const PointCloudInConstPtr &cloud, const IndicesConstPtr &indices, float &w_j) = 0;
      
      inline double calcPointCoherence (PointInT &source, PointInT &target);
      
      inline const std::string& 
      getClassName () const { return (coherence_name_); }
      
      
      std::string coherence_name_;

      PointCloudInConstPtr target_input_;

      std::vector<PointCoherencePtr> point_coherences_;
    };
    
  }
}


#include <pcl/tracking/impl/coherence.hpp>


#endif