BasicFunctors.h

 
#pragma once
 
#if defined(BasicFunctors_RECURSES)
#error Recursive header files inclusion detected in BasicFunctors.h
#else // defined(BasicFunctors_RECURSES)
#define BasicFunctors_RECURSES
 
#if !defined BasicFunctors_h
#define BasicFunctors_h
 
// Inclusions
#include <algorithm>
#include <functional>
#include <cmath>
#include "DGtal/io/Color.h"
#include "DGtal/base/Common.h"
#include "DGtal/base/BasicBoolFunctors.h"
 
namespace DGtal
{
  namespace functors
{
  template<typename T>
  struct Min
  {
    inline
    T operator() (const T&a, const T&b) const
    { return std::min(a,b); }
  };
 
  template<typename T>
  struct Max
  {
    inline
    T operator() (const T&a, const T&b) const
    { return std::max(a,b); }
  };
 
  template <class T>
  struct Minus
  {
    T operator() (const T& x, const T& y) const
    {return x-y;}
  };
 
  template <class T = void>
  struct Abs
  {
    inline
    T operator() (const T &x) const
    {
      if (x < 0)
        return -x;
      else
        return x;
    }
  };
 
  template <class T>
  struct UnaryMinus
  {
    inline
    T operator() (const T &x) const
    {
      return -x;
    }
  };
 
  template <class T>
  struct MultiplicationByScalar
  {
    inline
    MultiplicationByScalar( const T & aValue )
      : myValue( aValue )
    {}
 
    inline
    T operator() (const T &x) const
    {
      return myValue * x;
    }
 
    T myValue;
  };
 
  template < typename T = void >
  struct Round
    {
      inline
      auto operator() ( const T & value ) const
          -> decltype(std::round(value))
        {
          return std::round( value );
        }
    };
  
  template <>
  struct Round<void>
    {
      template < typename T >
      inline
      auto operator() ( const T & value ) const
          -> decltype(std::round(value))
        {
          return std::round( value );
        }
    };
 
  template < typename T = void >
  struct Floor
    {
      inline
      auto operator() ( const T & value ) const
          -> decltype(std::floor(value))
        {
          return std::floor( value );
        }
    };
  
  template <>
  struct Floor<void>
    {
      template < typename T >
      inline
      auto operator() ( const T & value ) const
          -> decltype(std::floor(value))
        {
          return std::floor( value );
        }
    };
  
  template < typename T = void >
  struct Ceil
    {
      inline
      auto operator() ( const T & value ) const
          -> decltype(std::ceil(value))
        {
          return std::ceil( value );
        }
    };
  
  template <>
  struct Ceil<void>
    {
      template < typename T >
      inline
      auto operator() ( const T & value ) const
          -> decltype(std::ceil(value))
        {
          return std::ceil( value );
        }
    };
 
  template < typename T = void >
  struct Trunc
    {
      inline
      auto operator() ( const T & value ) const
          -> decltype(std::trunc(value))
        {
          return std::trunc( value );
        }
    };
  
  template <>
  struct Trunc<void>
    {
      template < typename T >
      inline
      auto operator() ( const T & value ) const
          -> decltype(std::trunc(value))
        {
          return std::trunc( value );
        }
    };
 
// Some basic unary functors that may be useful
 
  struct Identity
  {
    template <typename T >
    inline
    T operator()(const T& aT) const
    {
      return aT;
    }
  };
 
  template <typename TValue>
  class ConstValue
  {
  public:
    typedef TValue Value;
 
    ConstValue(const Value& aValue = 0)
      :myValue(aValue) {};
 
    template <typename TInput>
    inline
    Value operator()(const TInput& /*aInput*/) const
    {
      return myValue;
    }
 
  private:
    Value myValue;
    
  };
 
  template <typename TQuantity, typename TCell>
  class ConstValueCell
  {
  public:
    typedef TCell Cell;
    typedef TQuantity Quantity;
 
    ConstValueCell(const Quantity& aQuantity = 0)
      :myQuantity(aQuantity) {}
 
    inline
    Quantity operator()(const Cell& /*aInput*/) const
    {
      return myQuantity;
    }
 
  private:
    Quantity myQuantity;
 
  };
 
 
  template <typename TOutput >
  struct Cast
  {
    template<typename TInput>
    inline
    TOutput operator()(const TInput& aInput) const
    {
      return static_cast<TOutput>(aInput);
    }
  };
 
  template <typename TFunctor1, typename TFunctor2, typename ReturnType >
  class Composer
  {
  public:
    typedef ReturnType Value;
 
    Composer(): myF1(NULL), myF2(NULL) {}
    Composer(const TFunctor1& aF1, const TFunctor2& aF2): myF1(&aF1), myF2(&aF2) {}
    Composer(const Composer& other): myF1(other.myF1), myF2(other.myF2) {}
 
    Composer& operator=(const Composer& other)
    {
      if (this != &other)
        {
          myF1 = other.myF1;
          myF2 = other.myF2;
        }
    return *this;
    }
 
 
    template<typename TInput>
    inline
    ReturnType operator()(const TInput& aInput) const
    {
      ASSERT( myF1 );
      ASSERT( myF2 );
      return myF2->operator()( myF1->operator()( aInput ) );
    }
 
  private:
    const TFunctor1* myF1;
    const TFunctor2* myF2;
  };
 
template <typename T, bool isLower = true, bool isEqual = true >
class Thresholder
 {
  public:
    BOOST_CONCEPT_ASSERT(( boost::EqualityComparable<T> ));
    BOOST_CONCEPT_ASSERT(( boost::LessThanComparable<T> ));
 
    typedef T Input;
 
    Thresholder(const Input& aT = 0):myT(aT) {}
    bool operator()(const Input& aI) const {
      std::less_equal<Input> c;
      return c(aI,myT);
    }
  private:
   Input myT;
};
 
//specializations
template <typename T>
struct Thresholder<T,false,false>
{
 
  public:
    BOOST_CONCEPT_ASSERT(( boost::EqualityComparable<T> ));
    BOOST_CONCEPT_ASSERT(( boost::LessThanComparable<T> ));
 
    typedef T Input;
 
    Thresholder(const Input& aT = 0):myT(aT) {}
 
    bool operator()(const Input& aI) const {
    std::greater<Input> c;
    return c(aI,myT);
    }
 
  private:
    Input myT;
};
template <typename T>
struct Thresholder<T,false,true>
 {
  public:
    BOOST_CONCEPT_ASSERT(( boost::EqualityComparable<T> ));
    BOOST_CONCEPT_ASSERT(( boost::LessThanComparable<T> ));
 
    typedef T Input;
 
    Thresholder(const Input& aT = 0):myT(aT) {}
    bool operator()(const Input& aI) const {
    std::greater_equal<Input> c;
    return c(aI,myT);
    }
 
  private:
    Input myT;
};
 
template <typename T>
struct Thresholder<T,true,false>
  {
  public:
    BOOST_CONCEPT_ASSERT(( boost::EqualityComparable<T> ));
    BOOST_CONCEPT_ASSERT(( boost::LessThanComparable<T> ));
 
    typedef T Input;
 
    Thresholder(const Input& aT = 0):myT(aT) {}
 
    bool operator()(const Input& aI) const {
    std::less<Input> c;
    return c(aI,myT);
    }
 
  private:
    Input myT;
};
 
template <typename T>
struct Thresholder<T,true,true>
 {
  public:
    BOOST_CONCEPT_ASSERT(( boost::EqualityComparable<T> ));
    BOOST_CONCEPT_ASSERT(( boost::LessThanComparable<T> ));
 
    typedef T Input;
 
    Thresholder(const Input& aT = 0):myT(aT) {}
 
    bool operator()(const Input& aI) const {
    std::less_equal<Input> c;
    return c(aI,myT);
    }
 
  private:
    Input myT;
};
 
  // template class PredicateCombiner
  template <typename TPredicate1, typename TPredicate2,
            typename TBinaryFunctor = BoolFunctor2 >
  struct PredicateCombiner
  {
    typedef TPredicate1 Predicate1;
    typedef TPredicate2 Predicate2;
 
    PredicateCombiner( const Predicate1 & pred1,
        const Predicate2 & pred2,
        const TBinaryFunctor & boolFunctor )
      : myPred1( &pred1 ), myPred2( &pred2 ), myBoolFunctor( &boolFunctor )
    {
    }
 
    PredicateCombiner(  const PredicateCombiner& other )
      : myPred1( other.myPred1 ), myPred2( other.myPred2 ), myBoolFunctor( other.myBoolFunctor )
    {
    }
 
    PredicateCombiner& operator=( const PredicateCombiner& other )
    {
      if (this != &other)
        {
          myPred1 = other.myPred1;
          myPred2 = other.myPred2;
          myBoolFunctor = other.myBoolFunctor;
        }
    return *this;
    }
 
    ~PredicateCombiner() {}
 
    template<typename T>
    bool operator()( const T & t ) const
    {
      return myBoolFunctor->operator()( myPred1->operator()( t ),
                                        myPred2->operator()( t ) );
    }
 
    const Predicate1* myPred1;
    const Predicate2* myPred2;
    const TBinaryFunctor* myBoolFunctor;
  };
 
template <typename T>
class IntervalThresholder
{
public:
  BOOST_CONCEPT_ASSERT(( boost::EqualityComparable<T> ));
  BOOST_CONCEPT_ASSERT(( boost::LessThanComparable<T> ));
 
  typedef T Input;
 
  typedef Thresholder<T,false,true> Tlow;
  typedef Thresholder<T,true,true> Tup;
  typedef PredicateCombiner<Tlow,Tup,AndBoolFct2 > CombinedPredicate;
 
  IntervalThresholder(const Input& low, const Input& up)
    : myTlow( low), myTup ( up ),
      myPred( myTlow, myTup, AndBoolFct2() ) {}
 
  bool operator()(const Input& aI) const
  {
    return myPred(aI);
  }
private:
  Tlow myTlow;
  Tup myTup;
  CombinedPredicate myPred;
};
 
 
  template <typename ReturnType>
  class Pair1st
  {
  public:
 
    template <typename TPair>
    inline
    ReturnType operator()(const TPair& aPair) const
    {
      return aPair.first;
    }
 
  };
 
  template <typename ReturnType>
  class Pair2nd
  {
  public:
 
    template <typename TPair>
    inline
    ReturnType operator()(const TPair& aPair) const
    {
      return aPair.second;
    }
 
  };
 
  template <typename ReturnType>
  class Pair1stMutator
  {
  public:
 
    template <typename TPair>
    inline
    ReturnType& operator()(TPair& aPair) const
    {
      return aPair.first;
    }
 
    template <typename TPair>
    inline
    const ReturnType& operator()(const TPair& aPair) const
    {
      return aPair.first;
    }
 
  };
 
  template <typename ReturnType>
  class Pair2ndMutator
  {
  public:
 
    template <typename TPair>
    inline
    ReturnType& operator()(TPair& aPair) const
    {
      return aPair.second;
    }
 
    template <typename TPair>
    inline
    const ReturnType& operator()(const TPair& aPair) const
    {
      return aPair.second;
    }
 
  };
 
  template<typename TInputType, typename TOutputType>
  struct Rescaling
  {
      TInputType myInitMin;
      TInputType myInitMax;
      TInputType myInitRange;
 
      TOutputType myNewMin;
      TOutputType myNewMax;
      TOutputType myNewRange;
 
      Rescaling( const TInputType &initMin, const TInputType &initMax, const TOutputType &newMin, const TOutputType &newMax ) :
                          myInitMin(initMin), myInitMax(initMax), myInitRange(initMax-initMin), myNewMin(newMin), myNewMax(newMax), myNewRange(newMax-newMin) {}
      inline
      TOutputType operator() (const TInputType& anInitVal) const
      { return anInitVal<myInitMin ? myNewMin : anInitVal > myInitMax ? myNewMax : (anInitVal-myInitMin)*myNewRange/myInitRange + myNewMin; }
  };
 
 
  struct GaussianKernel
  {
    GaussianKernel(const double aSigma) :mySigma(aSigma)
    {
      myCoef = 1.0/(mySigma * sqrt(2.0*M_PI));
      myCoef2 = 1.0/(2.0*M_PI);
   }
 
    inline
    double operator()(const double aVal) const
    {
      ASSERT((aVal <= 1) && (aVal>=0));
      return myCoef*exp(-aVal*aVal*myCoef2);
    }
 
    double mySigma;
 
    double myCoef;
  private: 
    double myCoef2;
  };
}
}
 
 
#endif // !defined BasicFunctors_h
 
#undef BasicFunctors_RECURSES
#endif // else defined(BasicFunctors_RECURSES)