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/images/CImage.h"
#include "DGtal/images/ImageHelper.h"
#include "DGtal/kernel/sets/CDigitalSet.h"
#include "DGtal/kernel/sets/SetPredicate.h"
#include "DGtal/kernel/CPointPredicate.h"
#include "DGtal/kernel/CPointFunctor.h"
#include "DGtal/geometry/volumes/distance/FMMPointFunctors.h"


namespace DGtal
{

  namespace details
  {
  // template class PointValueCompare
    template<typename T>
    class PointValueCompare {
    public: 
      bool operator()(const T& a, const T& b) 
      {
        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(( CImage<TImage> ));
    BOOST_CONCEPT_ASSERT(( CDigitalSet<TSet> ));
    BOOST_CONCEPT_ASSERT(( CPointPredicate<TPointPredicate> ));
    BOOST_CONCEPT_ASSERT(( CPointFunctor<TPointFunctor> ));

    typedef TImage Image; 
    typedef TSet AcceptedPointSet; 
    typedef TPointPredicate PointPredicate; 

    //points
    typedef typename Image::Point Vector;
    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 = Point::dimension;

    //distance
    typedef TPointFunctor PointFunctor; 
    typedef typename PointFunctor::Value Value; 


  private: 

    //intern data types
    typedef std::pair<Point, Value> PointValue; 
    typedef std::set<PointValue,
                     details::PointValueCompare<PointValue> > CandidatePointSet; 
    typedef unsigned long 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,
        const PointPredicate& aPointPredicate);
    
    FMM(Image& aImg, AcceptedPointSet& aSet, 
        const PointPredicate& aPointPredicate, 
        const Area& aAreaThreshold, const Value& aValueThreshold);
    
    FMM(Image& aImg, AcceptedPointSet& aSet,
        const PointPredicate& aPointPredicate, 
        PointFunctor& aPointFunctor );
    
    FMM(Image& aImg, AcceptedPointSet& aSet, 
        const 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 = false);
    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 = false);


    template <typename TIteratorOnPairs>
    static void initFromIncidentPointsRange(const TIteratorOnPairs& itb, const TIteratorOnPairs& ite, 
                                   Image& aImg, AcceptedPointSet& aSet, 
                                   const Value& aValue, 
                                   bool aFlagIsPositive = false);

  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)