FMMPointFunctors.h

#pragma once

#if defined(FMMPointFunctors_RECURSES)
#error Recursive header files inclusion detected in FMMPointFunctors.h
#else // defined(FMMPointFunctors_RECURSES)

#define FMMPointFunctors_RECURSES

#if !defined FMMPointFunctors_h

#define FMMPointFunctors_h

// Inclusions
#include <iostream>
#include <limits>
#include <vector>
#include <queue>
#include "DGtal/base/Common.h"
#include "DGtal/base/ConstAlias.h"

#include "DGtal/kernel/sets/CDigitalSet.h"
#include "DGtal/kernel/CPointFunctor.h"
#include "DGtal/images/CImage.h"
#include "DGtal/images/ImageHelper.h"

namespace DGtal
{

  // template class L2FirstOrderLocalDistance
  template <typename TImage, typename TSet>
  class L2FirstOrderLocalDistance
  {

    // ----------------------- Types ------------------------------
  public:


    BOOST_CONCEPT_ASSERT(( concepts::CImage<TImage> ));
    typedef TImage Image;
    typedef typename Image::Point Point;
    typedef typename Image::Value Value; 

    BOOST_CONCEPT_ASSERT(( concepts::CDigitalSet<TSet> ));
    typedef TSet Set;
    BOOST_STATIC_ASSERT(( boost::is_same< Point, typename TSet::Point >::value ));

  private: 

    typedef std::vector<Value> Values; 
  
    // ----------------------- Data -------------------------------------
  public: 
    Image* myImgPtr; 
    Set* mySetPtr; 


    // ----------------------- Interface --------------------------------------
  public:

    L2FirstOrderLocalDistance(Image& aImg, TSet& aSet);

    L2FirstOrderLocalDistance ( const L2FirstOrderLocalDistance & other );

    L2FirstOrderLocalDistance & operator= ( const L2FirstOrderLocalDistance & other); 

    ~L2FirstOrderLocalDistance(); 

    Value operator() (const Point& aPoint);

    void selfDisplay ( std::ostream & out ) const;

    // ----------------------- Internals -------------------------------------

  private: 

    Value compute(Values& aValueList) const; 


    Value gradientNorm(const Value& aValue, const Values& aValueList) const;
  }; 

  // template class L2SecondOrderLocalDistance
  template <typename TImage, typename TSet>
  class L2SecondOrderLocalDistance
  {

    // ----------------------- Types ------------------------------
  public:


    BOOST_CONCEPT_ASSERT(( concepts::CImage<TImage> ));
    typedef TImage Image;
    typedef typename Image::Point Point;
    typedef typename Image::Value Value; 

    BOOST_CONCEPT_ASSERT(( concepts::CDigitalSet<TSet> ));
    typedef TSet Set;
    BOOST_STATIC_ASSERT(( boost::is_same< Point, typename TSet::Point >::value ));

  private: 

    typedef std::pair<double, Value> CoeffValue; 
    typedef std::vector<CoeffValue> List; 
  
    // ----------------------- Data -------------------------------------
  public: 
    Image* myImgPtr; 
    Set* mySetPtr; 


    // ----------------------- Interface --------------------------------------
  public:

    L2SecondOrderLocalDistance(Image& aImg, TSet& aSet);

    L2SecondOrderLocalDistance ( const L2SecondOrderLocalDistance & other );

    L2SecondOrderLocalDistance & operator= ( const L2SecondOrderLocalDistance & other); 

    ~L2SecondOrderLocalDistance(); 

    Value operator() (const Point& aPoint);

    void selfDisplay ( std::ostream & out ) const;

    // ----------------------- Internals -------------------------------------

  private: 

    Value compute(List& aList) const; 


    Value getValue(const Value& aValue1, const Value& aValue2) const;
  }; 


  // template class LInfLocalDistance
  template <typename TImage, typename TSet>
  class LInfLocalDistance
  {
    // ----------------------- Types ------------------------------
  public:


    BOOST_CONCEPT_ASSERT(( concepts::CImage<TImage> ));
    typedef TImage Image;
    typedef typename Image::Point Point;
    typedef typename Image::Value Value; 

    BOOST_CONCEPT_ASSERT(( concepts::CDigitalSet<TSet> ));
    typedef TSet Set;
    BOOST_STATIC_ASSERT(( boost::is_same< Point, typename TSet::Point >::value ));

  private: 

    typedef std::vector<Value> Values; 

    // ----------------------- Data -------------------------------------
  public: 
    Image* myImgPtr; 
    Set* mySetPtr; 


    // ----------------------- Interface --------------------------------------
  public:

    LInfLocalDistance(Image& aImg, TSet& aSet);

    LInfLocalDistance ( const LInfLocalDistance & other );

    LInfLocalDistance & operator= ( const LInfLocalDistance & other); 

    ~LInfLocalDistance(); 


    Value operator() (const Point& aPoint);

    void selfDisplay ( std::ostream & out ) const;

    // ----------------------- Internals -------------------------------------

  private: 

    Value compute(Values& aValueList) const; 

  }; 

  // template class L1LocalDistance
  template <typename TImage, typename TSet>
  class L1LocalDistance
  {
    // ----------------------- Types ------------------------------
  public:


    BOOST_CONCEPT_ASSERT(( concepts::CImage<TImage> ));
    typedef TImage Image;
    typedef typename Image::Point Point;
    typedef typename Image::Value Value; 

    BOOST_CONCEPT_ASSERT(( concepts::CDigitalSet<TSet> ));
    typedef TSet Set;
    BOOST_STATIC_ASSERT(( boost::is_same< Point, typename TSet::Point >::value ));

  private: 

    typedef std::vector<Value> Values; 

    // ----------------------- Data -------------------------------------
  public: 
    Image* myImgPtr; 
    Set* mySetPtr; 

    // ----------------------- Interface --------------------------------------
  public:

    L1LocalDistance(Image& aImg, TSet& aSet);

    L1LocalDistance ( const L1LocalDistance & other );

    L1LocalDistance & operator= ( const L1LocalDistance & other); 

    ~L1LocalDistance(); 

    Value operator() (const Point& aPoint);

    void selfDisplay ( std::ostream & out ) const;

    // ----------------------- Internals -------------------------------------

  private: 

    Value compute(Values& aValueList) const; 

  }; 


  // template class L2FirstOrderLocalDistanceFromCells
  template <typename TKSpace, typename TMap, bool isIndirect = false>
  class L2FirstOrderLocalDistanceFromCells
  {

    // ----------------------- Types ------------------------------
  public:


    typedef TMap Map;
    typedef typename Map::mapped_type Value; 

    typedef TKSpace KSpace; 
    typedef typename KSpace::Point Point; 
    typedef typename KSpace::Cell Cell; 

  private: 

    typedef std::vector<Value> Values; 
  
    // ----------------------- Data -------------------------------------
  public: 
    const KSpace* myKSpace; 
    Map* myMap; 

    // ----------------------- Interface --------------------------------------
  public:

    L2FirstOrderLocalDistanceFromCells( ConstAlias<KSpace> aK, Map& aMap);

    L2FirstOrderLocalDistanceFromCells ( const L2FirstOrderLocalDistanceFromCells & other );

    L2FirstOrderLocalDistanceFromCells & operator= ( const L2FirstOrderLocalDistanceFromCells & other); 

    ~L2FirstOrderLocalDistanceFromCells(); 

    Value operator() (const Point& aPoint);

    void selfDisplay ( std::ostream & out ) const;

    // ----------------------- Internals -------------------------------------

  private: 

    Value compute(Values& aValueList) const; 

  }; 


  // template class SpeedExtrapolator
  template <typename TDistanceImage, typename TSet, typename TSpeedFunctor>
  class SpeedExtrapolator
  {

    // ----------------------- Types ------------------------------
  public:


    BOOST_CONCEPT_ASSERT(( concepts::CImage<TDistanceImage> ));
    typedef TDistanceImage DistanceImage;
    typedef typename DistanceImage::Point Point;
    typedef typename DistanceImage::Value DistanceValue;
    BOOST_CONCEPT_ASSERT(( concepts::CPointFunctor<TSpeedFunctor> ));
    typedef TSpeedFunctor SpeedFunctor;
    BOOST_STATIC_ASSERT(( boost::is_same< Point, typename SpeedFunctor::Point >::value ));
    typedef typename SpeedFunctor::Value Value; 

    BOOST_CONCEPT_ASSERT(( concepts::CDigitalSet<TSet> ));
    typedef TSet Set;
    BOOST_STATIC_ASSERT(( boost::is_same< Point, typename TSet::Point >::value ));
  
    // ----------------------- Data -------------------------------------
  public: 
    const DistanceImage* myDistImgPtr; 
    const Set* mySetPtr; 
    SpeedFunctor* mySpeedFuncPtr; 


    // ----------------------- Interface --------------------------------------
  public:

    SpeedExtrapolator(const DistanceImage& aDistImg, const TSet& aSet, SpeedFunctor& aSpeedFunc);

    SpeedExtrapolator ( const SpeedExtrapolator & other );

    SpeedExtrapolator & operator= ( const SpeedExtrapolator & other); 

    ~SpeedExtrapolator(); 

    Value operator() (const Point& aPoint);


  }; 


} // namespace DGtal


// Includes inline functions.
#include "DGtal/geometry/volumes/distance/FMMPointFunctors.ih"

//                                                                           //

#endif // !defined FMMPointFunctors_h

#undef FMMPointFunctors_RECURSES
#endif // else defined(FMMPointFunctors_RECURSES)