OneBalancedWordComputer.h

 
#pragma once
 
#if defined(OneBalancedWordComputer_RECURSES)
#error Recursive header files inclusion detected in OneBalancedWordComputer.h
#else // defined(OneBalancedWordComputer_RECURSES)
#define OneBalancedWordComputer_RECURSES
 
#if !defined OneBalancedWordComputer_h
#define OneBalancedWordComputer_h
 
// Inclusions
#include <iostream>
#include "DGtal/base/Common.h"
#include "DGtal/geometry/curves/FreemanChain.h"
#include "DGtal/base/OrderedAlphabet.h"
#include "DGtal/base/IteratorCirculatorTraits.h"
#include "DGtal/kernel/CInteger.h"
#include "DGtal/arithmetic/IntegerComputer.h"
#include "DGtal/geometry/curves/ArithmeticalDSL.h"
 
namespace DGtal
{
 
 
 
  // template class OneBalancedWordComputer
  template <typename TConstIterator, typename TInteger>
    class OneBalancedWordComputer  
  {
 
    // ----------------------- Types ------------------------------
    public :
      //Required type
      BOOST_CONCEPT_ASSERT(( concepts::CInteger<TInteger> ) );
      typedef TConstIterator ConstIterator;
      typedef TInteger Integer;
 
      //Required types
      typedef FreemanChain<TInteger> FreemanChainCode;
      typedef OneBalancedWordComputer<ConstIterator, Integer> Self;
      typedef OneBalancedWordComputer<ConstIterator, Integer> Reverse;
 
      //2D points and 2D vectors
      typedef DGtal::PointVector<2,Integer> Point;
      typedef DGtal::PointVector<2,Integer> Vector;
 
      typedef typename IteratorCirculatorTraits<ConstIterator>::Value Code;
      typedef int Size;
      typedef int Index;
 
      //The basic steps associate to the codes are given by a function `f: Code -> Vector` 
      typedef Vector (*DisplacementFct) (Code);
 
      //DSL
      typedef ArithmeticalDSL<TInteger, TInteger, 4> DSL; 
 
    private :
      template < class TIterator, class iterator_type = typename IteratorCirculatorTraits <TIterator>::Category >  class CodeHandler
        {
        public :
          CodeHandler()
            { }
          void init( const TIterator & it ) 
            { 
              myIter = it;
            }
 
          Code getCode( Index n ) const
            {
              return myCodes[ n ];
            }
 
          Code getCode( Index n )
            {
              while ( n >= myCodes.size() )
                {
                  myCodes.push_back( *myIter );
                  ++myIter;
                }
              return myCodes[ n ];
            }
 
        private :
        std::vector<Code> myCodes;
          TIterator myIter;
        };
 
      template < class TIterator >
        class CodeHandler< TIterator, BidirectionalCategory >
        {
        public :
          CodeHandler()
            {
            }
          void init( const TIterator & it ) 
            { 
              myFirst = it;
              myLast = it;
            }
 
          Code getCode( Index n ) const
            {
              return ( n >= 0 ) ? myPosCodes[ n ] : myNegCodes[ 1-n ];
            }
 
          Code getCode( Index n )
            {
              Code c;
              if ( n<0 )
                {
                  unsigned int i = 1-n;
                  while ( i >= myNegCodes.size() )
                    {
                      --myFirst;
                      myNegCodes.push_back( *myFirst );
                    }
                  c = myNegCodes[ n ];
                }
              else
                {
                  unsigned int i = n;
                  while ( i >= myPosCodes.size() )
                    {
                      myPosCodes.push_back( *myLast );
                      ++myLast;
                    }
                  c =  myPosCodes[ n ];
                }
              return c;
            }
 
        private :
          std::vector<Code> myPosCodes;
          std::vector<Code> myNegCodes;
          TIterator myFirst;
          TIterator myLast;
        };
 
      template < class TIterator>
        class CodeHandler<TIterator, RandomAccessCategory >
        {
          public :
            CodeHandler()
              { }
 
            void init ( const TIterator & it ) 
            { 
              myIter = it;
            }
 
            Code getCode( Index n ) const
              {
                return myIter[ n ];
              }
 
            Code getCode ( Index n )
              {
                return myIter[ n ];
              }
 
          private :
            TIterator myIter;
          };
 
 
    public :
 
      struct ConstPointIterator
        {
 
          typedef BidirectionalCategory iterator_category;
          typedef Point value_type;
          typedef Index difference_type;
          typedef Point * pointer;
          typedef Point & reference;
 
          const OneBalancedWordComputer * myDSS;
          Index i;
          Point p;
 
          ConstPointIterator( )
          {}
 
          ConstPointIterator( const OneBalancedWordComputer * dss, Index ind, Point pt ) :
            myDSS(dss), i(ind), p(pt) 
          {}
 
          ~ConstPointIterator() {}
            
          bool operator==( const ConstPointIterator other) const
            {
              return i == other.i;
            }
          bool operator!=( const ConstPointIterator other) const
            {
              return i != other.i;
            }
 
          Index operator-( const ConstPointIterator other) const
            {
              return i - other.i;
            }
 
          ConstPointIterator( const ConstPointIterator & other) = default;
 
          ConstPointIterator& operator=( const ConstPointIterator & other)
            {
              i = other.i;
              myDSS = other.myDSS;
              p = other.p;
              return *this;
            }
 
          Point operator*() const
            {
              return p;
            }
 
          // pre-increment ++i
          ConstPointIterator& operator++()
            {
              next();
              return *this;
            }
 
          // post-increment
          ConstPointIterator operator++( int )
            {
              ConstPointIterator it = *this;
              next();
              return it;
            }
 
 
          // pre-decrement --i
          ConstPointIterator& operator--()
            {
              prev();
              return *this;
            }
 
          // post-decrement
          ConstPointIterator operator--( int )
            {
              ConstPointIterator it = *this;
              prev();
              return it;
            }
 
          // Move to next position
          void next()
            {
              p += myDSS->myDisplacements( myDSS->getCode( i ) );
              ++i;
            }
 
          // Move to previous position
          void prev()
            {
              --i;
              p -= myDSS->myDisplacements( myDSS->getCode( i ) );
            }
 
 
          // Get a reference to the current Combinatorial DSS
          const OneBalancedWordComputer * getDSS() const
            {
              return myDSS;
            }
 
 
          // Get the index of the iterator
          Index getIndex() const
            {
              return i;
            }
 
        };
 
 
 
 
    // ----------------------- Standard services ------------------------------
    public:
 
      OneBalancedWordComputer();
 
      ~OneBalancedWordComputer();
 
 
      void init( const ConstIterator & it, 
                const Point & start = Point(0,0),
                Vector (*displacements) (Code) = defaultMoves );
 
 
 
      void init(const ConstPointIterator & i);
 
      void init(const FreemanChainCode & fc);
 
      void init(const typename FreemanChainCode::ConstIterator & it);
 
      OneBalancedWordComputer ( const Self & other );
 
      OneBalancedWordComputer & operator= ( const Self & other );
 
      Self getSelf( ) const;
 
 
 
      bool operator==( const Self & other ) const;
 
      bool operator!=( const Self & other ) const;
 
 
      Reverse getReverse() const;
 
 
      bool isExtendableFront();
 
      bool extendFront();
 
      bool extendBack();
 
      bool isExtendableBack();
 
      bool retractBack();
 
      bool retractFront();
 
      void setPosition( const Point & p );
 
 
      void translate( const Vector & v );
 
      DSL getArithmeticalDescription() const;
 
      Integer getA() const;
 
      Integer getB() const;
 
      Integer getMu() const;
 
      Integer getOmega() const;
 
 
      Integer remainder(const Point & aPoint) const;
 
      void computeLeaningPoints( Point & uf, Point & ul, 
                                 Point & lf, Point & ll ) const;
 
 
      Point Uf() const;
 
      Point Ul() const;
 
      Point Lf() const;
 
      Point Ll() const;
 
      bool isValid() const;
 
      bool longestChristoffelPrefix(
          ConstIterator it,
          const OrderedAlphabet & aOA);
 
      
      // ----------------------- Accessors --------------------------------------
      
    public:
 
      Point back() const;
 
      Point front() const;
 
      ConstPointIterator pointBegin() const;
 
      ConstPointIterator pointEnd() const;
 
      ConstIterator begin() const;
 
      ConstIterator end() const;
 
 
 
 
 
 
      // ----------------------- Interface --------------------------------------
    public:
 
      void selfDisplay ( std::ostream & out ) const;
 
 
    protected:
      // ------------------------- Protected Datas ------------------------------
      
      CodeHandler<ConstIterator> myCodeHandler;
 
      ConstIterator myBegin;
      ConstIterator myEnd;
 
      Point myFirstPoint;
      Point myLastPoint;
 
      Index myFirstLetter;
      Index myLastLetter;
 
 
      unsigned int myNbRepeat;
 
      Index myPatternBegin;
      Index myPatternEnd;
 
      Size myLeftPatternLength;
 
      Index myNextBefore;
      Index myNextAfter;
 
 
      Vector (*myDisplacements) ( Code ) ;
 
 
 
      // ------------------------- Private Datas --------------------------------
    private:
 
      // ------------------------- Hidden services ------------------------------
    public:
 
 
      Code getSmallLetter() const;
 
      Code getBigLetter() const;
 
      Code getCode(Index pos);
 
      Code getCode(Index pos) const;
 
      Size mainPatternLength() const;
 
      Vector mainPatternVector() const;
 
      Size suffixLength() const;
 
      Size prefixLength() const;
 
      bool isUL ( Index pos ) const;
 
      bool nextIsLL ( Index pos ) const;
 
      bool previousIsLL ( Index pos ) const;
 
      bool isTrivial() const;
 
      Vector displacement( Code c ) const;
 
 
 
    
    private:
      // ------------------------- Internals ------------------------------------
    public :
 
      static Vector defaultMoves( Code c )
        {
          Integer x = ( c == '0' ) ? 1 : ( ( c == '2' ) ? -1 : 0 ) ;
          Integer y = ( c == '1' ) ? 1 : ( ( c == '3' ) ? -1 : 0 ) ;
          return Vector( x, y );
        }
 
 
 
  }; // end of class OneBalancedWordComputer
 
  template < typename TConstIterator, typename TInteger >
  std::ostream&
  operator<< ( std::ostream & out, 
               const OneBalancedWordComputer<TConstIterator, TInteger> & object ); 
 
 
} // namespace DGtal
 
 
// Includes inline functions.
#include "DGtal/geometry/curves/OneBalancedWordComputer.ih"
//                                                                           //
 
#endif // !defined OneBalancedWordComputer_h
 
#undef OneBalancedWordComputer_RECURSES
#endif // else defined(OneBalancedWordComputer_RECURSES)