BinomialConvolver.h

#pragma once

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

#define BinomialConvolver_RECURSES

#if !defined BinomialConvolver_h

#define BinomialConvolver_h

// Inclusions
#include <iostream>
#include <map>
#include "DGtal/base/Common.h"
#include "DGtal/math/Signal.h"

namespace DGtal
{

  // template class BinomialConvolver
  template <typename TConstIteratorOnPoints, typename TValue = double>
  class BinomialConvolver
  {
    // ----------------------- Standard services ------------------------------
  public:
    typedef TValue Value;
    typedef TConstIteratorOnPoints ConstIteratorOnPoints;
    typedef typename ConstIteratorOnPoints::value_type Point;

    BinomialConvolver( unsigned int n = 1 );

       
    ~BinomialConvolver();

    void setSize( unsigned int n );

    unsigned int size() const;

    static
    unsigned int suggestedSize( const double h, 
        const ConstIteratorOnPoints& itb, 
        const ConstIteratorOnPoints& ite );

    void init( const double h, 
         const ConstIteratorOnPoints& itb, 
         const ConstIteratorOnPoints& ite,
         const bool isClosed );

    int index( const ConstIteratorOnPoints& it ) const;

    std::pair<Value,Value> x( int i ) const;

    std::pair<Value,Value> dx( int i ) const;

    std::pair<Value,Value> d2x( int i ) const;

    std::pair<Value,Value> tangent( int i ) const;

    Value curvature( int i ) const;


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

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

    bool isValid() const;

    // ------------------------- Protected Datas ------------------------------
  protected:
    unsigned int myN;
    double myH;
    Signal<Value> myX;
    Signal<Value> myY;
    Signal<Value> myDX;
    Signal<Value> myDY;
    Signal<Value> myDDX;
    Signal<Value> myDDY;

    ConstIteratorOnPoints myBegin;
    
    ConstIteratorOnPoints myEnd;

    // Stores the mapping Iterator => Index.
    std::map<ConstIteratorOnPoints,int> myMapIt2Idx;

    // ------------------------- Private Datas --------------------------------
  private:

    // ------------------------- Hidden services ------------------------------
  protected:

  private:

    BinomialConvolver ( const BinomialConvolver & other );

    BinomialConvolver & operator= ( const BinomialConvolver & other );

    // ------------------------- Internals ------------------------------------
  private:

  }; // end of class BinomialConvolver

  template <typename TBinomialConvolver, typename TRealPoint>
  struct TangentFromBinomialConvolverFunctor
  {
  public: 
    // ----------------------- inner type ------------------------------
    typedef TRealPoint Value;
    typedef TRealPoint RealPoint;
    typedef TBinomialConvolver BinomialConvolver;
    typedef typename TBinomialConvolver::Value SignalValue;
    typedef typename TBinomialConvolver::ConstIteratorOnPoints ConstIteratorOnPoints;
    
    Value operator()( const BinomialConvolver & bc,
          const ConstIteratorOnPoints & it ) const;

  };

  template <typename TBinomialConvolver, typename TReal>
  struct CurvatureFromBinomialConvolverFunctor
  {
  public: 
    // ----------------------- inner type ------------------------------
    typedef TReal Value;
    typedef TReal Real;
    typedef TBinomialConvolver BinomialConvolver;
    typedef typename TBinomialConvolver::Value SignalValue;
    typedef typename TBinomialConvolver::ConstIteratorOnPoints ConstIteratorOnPoints;
    
    Value operator()( const BinomialConvolver & bc,
          const ConstIteratorOnPoints & it ) const;

  };

  template <typename TBinomialConvolver, typename TBinomialConvolverFunctor>
  class BinomialConvolverEstimator
  {
  public:
    typedef TBinomialConvolver BinomialConvolver;
    typedef TBinomialConvolverFunctor BinomialConvolverFunctor;
    typedef typename BinomialConvolver::ConstIteratorOnPoints ConstIteratorOnPoints;
    typedef ConstIteratorOnPoints ConstIterator;
    typedef typename BinomialConvolverFunctor::Value Value;
    typedef Value Quantity;

    BinomialConvolverEstimator( unsigned int n = 0,
        const BinomialConvolverFunctor & f
        = BinomialConvolverFunctor() );

    void init( const double h, 
         const ConstIterator & itb, 
         const ConstIterator & ite,
         const bool isClosed);
    
    Quantity eval( const ConstIterator& it );
    
    template <typename OutputIterator>
    OutputIterator eval( const ConstIterator& itb, 
       const ConstIterator& ite, 
       OutputIterator result ); 



  private:
    BinomialConvolver myBC;
    BinomialConvolverFunctor myFunctor;

  };

  template <typename TConstIteratorOnPoints, typename TValue >
  std::ostream&
  operator<< ( std::ostream & out, 
         const BinomialConvolver<TConstIteratorOnPoints,TValue> & object );

} // namespace DGtal


// Includes inline functions.
#include "DGtal/geometry/curves/BinomialConvolver.ih"

//                                                                           //

#endif // !defined BinomialConvolver_h

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