FMM.h

 
#pragma once
 
#if defined(FMM_RECURSES)
#error Recursive header files inclusion detected in FMM.h
#else // defined(FMM_RECURSES)
 
#define FMM_RECURSES
 
#if !defined FMM_h
 
#define FMM_h
 
// Inclusions
#include <iostream>
#include <limits>
#include <map>
#include <set>
#include "DGtal/base/Common.h"
#include "DGtal/base/ConstAlias.h"
#include "DGtal/images/CImage.h"
#include "DGtal/images/ImageHelper.h"
#include "DGtal/kernel/sets/CDigitalSet.h"
#include "DGtal/kernel/CPointPredicate.h"
#include "DGtal/kernel/CPointFunctor.h"
#include "DGtal/geometry/volumes/distance/FMMPointFunctors.h"
 
 
namespace DGtal
{
 
  namespace detail
  {
  // template class PointValueCompare
    template<typename T>
    class PointValueCompare {
    public: 
      bool operator()(const T& a, const T& b) const
      {
        if ( std::abs(a.second) == std::abs(b.second) ) 
          { //point comparison
            return (a.first < b.first); 
          }
        else //distance comparison
          //(in absolute value in order to deal with
          //signed distance values) 
          return ( std::abs(a.second) < std::abs(b.second) ); 
      }
    };
  }
 
  // template class FMM
  template <typename TImage, typename TSet, typename TPointPredicate, 
            typename TPointFunctor = L2FirstOrderLocalDistance<TImage,TSet> >
  class FMM
  {
 
    // ----------------------- Types ------------------------------
  public:
 
 
    //concept assert
    BOOST_CONCEPT_ASSERT(( concepts::CImage<TImage> ));
    BOOST_CONCEPT_ASSERT(( concepts::CDigitalSet<TSet> ));
    BOOST_CONCEPT_ASSERT(( concepts::CPointPredicate<TPointPredicate> ));
    BOOST_CONCEPT_ASSERT(( concepts::CPointFunctor<TPointFunctor> ));
 
    typedef TImage Image; 
    typedef TSet AcceptedPointSet; 
    typedef TPointPredicate PointPredicate; 
 
    //points
    typedef typename Image::Point Point;
    BOOST_STATIC_ASSERT(( boost::is_same< Point, typename AcceptedPointSet::Point >::value ));
    BOOST_STATIC_ASSERT(( boost::is_same< Point, typename PointPredicate::Point >::value ));
 
    //dimension
    typedef typename Point::Dimension Dimension;
    static const Dimension dimension; 
 
    //distance
    typedef TPointFunctor PointFunctor; 
    typedef typename PointFunctor::Value Value; 
 
 
  private: 
 
    //intern data types
    typedef std::pair<Point, Value> PointValue; 
    typedef std::set<PointValue,
                     detail::PointValueCompare<PointValue> > CandidatePointSet; 
    typedef DGtal::uint64_t Area;
 
    // ------------------------- Private Datas --------------------------------
  private:
    
    Image& myImage; 
 
    AcceptedPointSet& myAcceptedPoints; 
 
    CandidatePointSet myCandidatePoints; 
 
    PointFunctor* myPointFunctorPtr; 
 
    const bool myFlagIsOwning; 
 
    const PointPredicate& myPointPredicate; 
 
    Area myAreaThreshold; 
 
    Value myValueThreshold; 
 
    Value myMinValue; 
 
    Value myMaxValue; 
 
 
    // ----------------------- Standard services ------------------------------
  public:
 
    FMM(Image& aImg, AcceptedPointSet& aSet,
        ConstAlias<PointPredicate> aPointPredicate);
    
    FMM(Image& aImg, AcceptedPointSet& aSet, 
        ConstAlias<PointPredicate> aPointPredicate, 
        const Area& aAreaThreshold, const Value& aValueThreshold);
    
    FMM(Image& aImg, AcceptedPointSet& aSet,
        ConstAlias<PointPredicate> aPointPredicate, 
        PointFunctor& aPointFunctor );
    
    FMM(Image& aImg, AcceptedPointSet& aSet, 
        ConstAlias<PointPredicate> aPointPredicate, 
        const Area& aAreaThreshold, const Value& aValueThreshold,
        PointFunctor& aPointFunctor );
    
    ~FMM();
 
  
    // ----------------------- Interface --------------------------------------
  public:
    
    void compute();
 
    bool computeOneStep(Point& aPoint, Value& aValue);
 
    Value min() const;
 
    Value max() const;
 
    Value getMin() const;
 
    Value getMax() const;
 
    void selfDisplay ( std::ostream & out ) const;
 
    bool isValid() const;
 
    // ------------------------- static functions for init --------------------
 
 
    template <typename TIteratorOnPoints>
    static void initFromPointsRange(const TIteratorOnPoints& itb, const TIteratorOnPoints& ite, 
                                Image& aImg, AcceptedPointSet& aSet, 
                                const Value& aValue);
 
    template <typename KSpace, typename TIteratorOnBels>
    static void initFromBelsRange(const KSpace& aK, 
                                  const TIteratorOnBels& itb, const TIteratorOnBels& ite, 
                                  Image& aImg, AcceptedPointSet& aSet, 
                                  const Value& aValue, 
                                  bool aFlagIsPositive = true);
 
    template <typename KSpace, typename TIteratorOnBels, typename TImplicitFunction>
    static void initFromBelsRange(const KSpace& aK, 
                                  const TIteratorOnBels& itb, const TIteratorOnBels& ite,
                                  const TImplicitFunction& aF, 
                                  Image& aImg, AcceptedPointSet& aSet, 
                                  bool aFlagIsPositive = true);
 
 
    template <typename TIteratorOnPairs>
    static void initFromIncidentPointsRange(const TIteratorOnPairs& itb, const TIteratorOnPairs& ite, 
                                   Image& aImg, AcceptedPointSet& aSet, 
                                   const Value& aValue, 
                                   bool aFlagIsPositive = true);
 
  private:
 
    FMM ( const FMM & other );
 
    FMM & operator= ( const FMM & other );
 
    // ------------------------- Internals ------------------------------------
  private:
 
    void init();
    
    bool addNewAcceptedPoint(Point& aPoint, Value& aValue);
 
    void update(const Point& aPoint);
 
    bool addNewCandidate(const Point& aPoint);
 
 
  }; // end of class FMM
 
 
  template <typename TImage, typename TSet, typename TPointPredicate, typename TPointFunctor >
  std::ostream&
  operator<< ( std::ostream & out, const FMM<TImage, TSet, TPointPredicate, TPointFunctor> & object );
 
} // namespace DGtal
 
 
// Includes inline functions.
#include "DGtal/geometry/volumes/distance/FMM.ih"
 
//                                                                           //
 
#endif // !defined FMM_h
 
#undef FMM_RECURSES
#endif // else defined(FMM_RECURSES)