ArithmeticalDSSComputer.h

#pragma once

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

#define ArithmeticalDSSComputer_RECURSES

#if !defined ArithmeticalDSSComputer_h

#define ArithmeticalDSSComputer_h

// Inclusions
#include <iostream>
#include <list>
#include "DGtal/base/Exceptions.h"
#include "DGtal/base/Common.h"
#include "DGtal/kernel/PointVector.h"
#include "DGtal/kernel/CInteger.h"
#include "DGtal/base/ReverseIterator.h"
#include "DGtal/geometry/curves/ArithmeticalDSS.h"


namespace DGtal
{
  // class ArithmeticalDSSComputer
  template <typename TIterator, 
    typename TInteger = typename IteratorCirculatorTraits<TIterator>::Value::Coordinate, 
    unsigned short adjacency = 8>
  class ArithmeticalDSSComputer
  {

    // ----------------------- inner types ------------------------------
  public:

    typedef TIterator ConstIterator;
    BOOST_CONCEPT_ASSERT(( boost_concepts::ReadableIteratorConcept<ConstIterator> )); 
    BOOST_CONCEPT_ASSERT(( boost_concepts::ForwardTraversalConcept<ConstIterator> )); 

    typedef typename IteratorCirculatorTraits<ConstIterator>::Value Point; 
    BOOST_STATIC_ASSERT(( Point::dimension == 2 ));

    typedef typename IteratorCirculatorTraits<TIterator>::Value::Coordinate Coordinate; 
    BOOST_CONCEPT_ASSERT(( concepts::CInteger<Coordinate> ));

    typedef TInteger Integer;
    BOOST_CONCEPT_ASSERT(( concepts::CInteger<Integer> ));

    typedef ArithmeticalDSS<Coordinate, Integer, adjacency> DSS; 
    //we expect that the iterator type returned DGtal points, used in the DSS representation
    BOOST_STATIC_ASSERT(( concepts::ConceptUtils::SameType< Point, typename DSS::Point >::value ));

    typedef DSS Primitive; 

    typedef Point Vector; 

    typedef ArithmeticalDSSComputer<ConstIterator,TInteger,adjacency> Self; 
    typedef ArithmeticalDSSComputer<ReverseIterator<ConstIterator>,TInteger,adjacency> Reverse;

    // ----------------------- Standard services ------------------------------
  public:

    ArithmeticalDSSComputer();

    ArithmeticalDSSComputer(const ConstIterator& it);

    void init(const ConstIterator& it);

    ArithmeticalDSSComputer ( const ArithmeticalDSSComputer & other );

    ArithmeticalDSSComputer& operator= ( const ArithmeticalDSSComputer & other );

    Self getSelf() const;

    Reverse getReverse() const;
        
    bool operator==( const ArithmeticalDSSComputer & other ) const;

    bool operator!=( const ArithmeticalDSSComputer & other ) const;

    ~ArithmeticalDSSComputer(){};

    // ----------------------- Interface --------------------------------------
  public:
     
    bool isExtendableFront();

    bool isExtendableBack();
    
    bool extendFront();

    bool extendBack();

    bool retractFront();

    bool retractBack();


    // ------------------------- Accessors ------------------------------
    const Primitive& primitive() const;
    Integer a() const;
    Integer b() const;
    Integer mu() const;
    Integer omega() const;
    Point Uf() const;
    Point Ul() const;
    Point Lf() const;
    Point Ll() const;
    Point back() const ;
    Point front() const ;
    ConstIterator begin() const;
    ConstIterator end() const;

    bool isValid() const;


    // ------------------ Useful tools -----------------------------------

    Integer remainder(const ConstIterator & it) const;

    Integer remainder( const Point& aPoint ) const;

    Integer position(const ConstIterator & it) const;

    Integer position( const Point& aPoint ) const;

    bool isInDSL( const Point& aPoint ) const;

    bool isInDSL(const ConstIterator & it) const;

    bool isInDSS( const Point& aPoint ) const;

    bool isInDSS(const ConstIterator & it) const;


    // ------------------------- Hidden services ------------------------------
  private:


    // ------------------------- Protected Datas ------------------------------
  protected:

    DSS myDSS; 
    ConstIterator myBegin; 
    ConstIterator myEnd; 
    
    // ------------------ Display ------------------------------------------

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

    
  }; // end of class ArithmeticalDSSComputer


template <typename TIterator, typename TInteger, unsigned short adjacency>
std::ostream&
operator<< ( std::ostream & out,  const ArithmeticalDSSComputer<TIterator,TInteger,adjacency> & object )
{
  object.selfDisplay( out);
  return out;
}

} // namespace DGtal

// Aliases
namespace DGtal
{
  template <typename TIterator, 
            typename TInteger = typename IteratorCirculatorTraits<TIterator>::Value::Coordinate>
  class StandardDSS4Computer: 
    public ArithmeticalDSSComputer<TIterator, TInteger, 4>
  {
  public: 
    typedef ArithmeticalDSSComputer<TIterator, TInteger, 4> Super;
    typedef typename Super::ConstIterator ConstIterator;

  public: 

    StandardDSS4Computer (); 

    StandardDSS4Computer(const ConstIterator& it);

    StandardDSS4Computer ( const StandardDSS4Computer & aOther ); 

    StandardDSS4Computer & operator= ( const StandardDSS4Computer & aOther );

  }; 

  template <typename TIterator, 
            typename TInteger = typename IteratorCirculatorTraits<TIterator>::Value::Coordinate>
  class NaiveDSS8Computer: 
    public ArithmeticalDSSComputer<TIterator, TInteger, 4>
  {
  public: 
    typedef ArithmeticalDSSComputer<TIterator, TInteger, 4> Super; 
    typedef typename Super::ConstIterator ConstIterator;

  public: 

    NaiveDSS8Computer (); 

    NaiveDSS8Computer(const ConstIterator& it);

    NaiveDSS8Computer ( const NaiveDSS8Computer & aOther ); 

    NaiveDSS8Computer & operator= ( const NaiveDSS8Computer & aOther );

  }; 

} // namespace DGtal


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

//                                                                           //

#endif // !defined ArithmeticalDSSComputer_h

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