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>
  using StandardDSS4Computer = ArithmeticalDSSComputer<TIterator, TInteger, 4>;

  template <typename TIterator,
            typename TInteger = typename IteratorCirculatorTraits<TIterator>::Value::Coordinate>
  using NaiveDSS8Computer = ArithmeticalDSSComputer<TIterator, TInteger, 8>;

} // namespace DGtal


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

//                                                                           //

#endif // !defined ArithmeticalDSSComputer_h

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