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 = true );
 
    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)