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/base/Common.h"
#include "DGtal/base/BasicBoolFunctors.h"

namespace DGtal
{
namespace functors
{
  template<typename T>
  struct Min : std::binary_function <T,T,T>
  {
    inline
    T operator() (const T&a, const T&b) const
    { return std::min(a,b); }
  };

  template<typename T>
  struct Max : std::binary_function <T,T,T>
  {
    inline
    T operator() (const T&a, const T&b) const
    { return std::max(a,b); }
  };

  template <class T>
  struct Minus : std::binary_function <T,T,T>
  {
    T operator() (const T& x, const T& y) const
    {return x-y;}
  };

  template <class T>
  struct Abs : std::unary_function<T,T>
  {
    inline
    T operator() (const T &x) const
    {
      if (x < 0)
        return -x;
      else
        return x;
    }
  };

  template <class T>
  struct UnaryMinus : std::unary_function<T,T>
  {
    inline
    T operator() (const T &x) const
    {
      return -x;
    }
  };

  template <class T>
  struct MultiplicationByScalar : std::unary_function<T,T>
  {
    inline
    MultiplicationByScalar( const T & aValue )
      : myValue( aValue )
    {}

    inline
    T operator() (const T &x) const
    {
      return myValue * x;
    }

    T myValue;
  };

// 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 : std::unary_function <TValue,TValue>
  {
  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 : std::unary_function <TQuantity,TQuantity>
  {
  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 std::unary_function <T,bool>
 {
  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 std::unary_function <T,bool>
{

  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 std::unary_function <T,bool>
 {
  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 std::unary_function <T,bool>
  {
  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 std::unary_function <T,bool>
 {
  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.pred1 ), myPred2( other.pred2 ), myBoolFunctor( other.boolFunctor )
    {
    }

    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 std::unary_function <T,bool>
{
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)