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)