ArithmeticalDSL.h

 
#pragma once
 
#if defined(ArithmeticalDSL_RECURSES)
#error Recursive header files inclusion detected in ArithmeticalDSL.h
#else // defined(ArithmeticalDSL_RECURSES)
 
#define ArithmeticalDSL_RECURSES
 
#if !defined ArithmeticalDSL_h
 
#define ArithmeticalDSL_h
 
// Inclusions
#include <iostream>
#include <utility>
#include "DGtal/base/Common.h"
#include "DGtal/base/Exceptions.h"
#include "DGtal/base/ReverseIterator.h"
#include "DGtal/kernel/CInteger.h"
#include "DGtal/kernel/CSignedNumber.h"
#include "DGtal/kernel/SpaceND.h"
#include "DGtal/kernel/PointVector.h"
#include "DGtal/arithmetic/IntegerComputer.h"
 
#include "DGtal/geometry/curves/ArithmeticalDSLKernel.h"
 
 
namespace DGtal
{
 
  //forward declaration of ArithmeticalDSS for the friendship
  template <typename TCoordinate,
            typename TInteger,
            unsigned short adjacency>
  class ArithmeticalDSS;
 
  // template class ArithmeticalDSL
  template <typename TCoordinate,
            typename TInteger = TCoordinate,
            unsigned short adjacency = 8>
  class ArithmeticalDSL
  {
 
    // ----------------------- Friend class -----------------------------------
  public:
    friend class ArithmeticalDSS<TCoordinate, TInteger, adjacency>;
 
    // ----------------------- static members -----------------------------------
  public:
    static const unsigned short foregroundAdjacency = adjacency;
 
    // ----------------------- Inner types -----------------------------------
  public:
 
    typedef TCoordinate Coordinate;
    BOOST_CONCEPT_ASSERT(( concepts::CInteger<Coordinate> ));
    typedef TInteger Integer;
    BOOST_CONCEPT_ASSERT(( concepts::CInteger<Integer> ));
    typedef typename ArithmeticalDSLKernel<Coordinate,adjacency>::Space Space;
    typedef typename Space::Point Point;
    typedef typename Space::Vector Vector;
    typedef std::pair<Vector,Vector> Steps;
    typedef Coordinate Position;
 
  typedef std::pair<unsigned char, unsigned char> Octant;
 
  
 
    class ConstIterator
      : public boost::iterator_facade<ConstIterator, //derived type, the ConstIterator class itself
                                      Point const,   //value type
                                      boost::random_access_traversal_tag, //traversal tag
                                      Point const,    //reference type
                                      //NB: since there is no underlying container,
                                      //we cannot return a reference.
                                      Position  //difference type
                                      >
    {
 
      // ------------------------- Private data -----------------------
    private:
 
      const ArithmeticalDSL* myDSLPtr;
 
      Point  myCurrentPoint;
 
      Integer  myQuantityToAdd;
 
      Integer  myQuantityToRemove;
 
      Integer  myCurrentRemainder;
 
      // ------------------------- Standard services -----------------------
    public:
 
      ConstIterator();
 
      ConstIterator( const ArithmeticalDSL* aDSL, const Point& aPoint );
 
      ConstIterator( const ConstIterator & aOther );
      ConstIterator& operator= ( const ConstIterator & aOther );
 
      ~ConstIterator();
 
      // ------------------------- useful services -------------------------
   public: 
      Integer remainder() const;
 
      // ------------------------- iteration services -------------------------
    private:
      friend class boost::iterator_core_access;
 
      Point const dereference() const;
 
      void increment();
 
      void decrement();
 
      bool equal(const ConstIterator& aOther) const;
 
      void advance(const Position& aShift);
 
      Position distance_to(const ConstIterator& aOther) const; 
 
    };
 
    typedef DGtal::ReverseIterator<ConstIterator> ConstReverseIterator;
 
    // ----------------------- Standard services ------------------------------
  public:
 
    ArithmeticalDSL(const Coordinate& aA, const Coordinate& aB,
                    const Integer& aLowerIntercept, const Integer& aUpperIntercept,
                    const Steps& aSteps, const Vector& aShift);
 
    ArithmeticalDSL(const Coordinate& aA, const Coordinate& aB,
                    const Integer& aMu);
 
 
    ArithmeticalDSL ( const ArithmeticalDSL & aOther );
 
    ArithmeticalDSL& operator= ( const ArithmeticalDSL & aOther );
 
    ArithmeticalDSL negate () const;
 
    bool equalsTo ( const ArithmeticalDSL & aOther ) const;
 
    bool operator== ( const ArithmeticalDSL & aOther ) const;
 
    bool operator!= ( const ArithmeticalDSL & aOther ) const;
 
  bool sameOctant ( const ArithmeticalDSL & aOther, typename Octant::first_type *theOctant ) const;
 
 
  bool isUpperLeaningPoint(const Point& aPoint) const;
  
  bool isLowerLeaningPoint(const Point& aPoint) const;
  
 
  Octant octant() const;
 
 
    ~ArithmeticalDSL();
 
    // ----------------------- Interface --------------------------------------
  public:
 
    void selfDisplay ( std::ostream & out ) const;
 
    bool checkShiftAndSteps() const;
 
    bool isValid() const;
 
    Coordinate a() const;
 
    Coordinate b() const;
 
    Integer mu() const;
 
    Integer omega() const;
 
    Position patternLength() const;
 
    Vector shift() const;
 
    Steps steps() const;
 
    static Integer remainder(const Coordinate& aA,
                             const Coordinate& aB,
                             const Point& aPoint);
 
    Integer remainder(const Point& aPoint) const;
 
    Integer orthogonalPosition(const Point& aPoint) const;
 
    Position position(const Point& aPoint) const;
 
    Point getPoint() const;
 
    Point getPoint(const Position& aPosition) const;
 
    bool before (const Point& aP1, const Point& aP2) const;
 
    bool beforeOrEqual (const Point& aP1, const Point& aP2) const;
 
    bool isInDSL(const Point& aPoint) const;
 
  
  
    bool operator()(const Point& aPoint) const;
 
 
    // ----------------------- Iterator services -------------------------------
    ConstIterator begin(const Point& aPoint) const;
 
    ConstIterator end(const Point& aPoint) const;
 
    ConstReverseIterator rbegin(const Point& aPoint) const;
 
    ConstReverseIterator rend(const Point& aPoint) const;
 
 
    // ------------------------- Other services ------------------------------
  public:
    static Coordinate toCoordinate(const Integer& aI); 
 
    // ------------------------- Protected Datas ------------------------------
  protected:
 
    // -------------------------vectors ---------------------------------------
    Steps mySteps;
    Vector myShift;
 
    //------------------------ parameters of the DSL --------------------------
    Coordinate myA;
    Coordinate myB;
    Integer myLowerBound;
    Integer myUpperBound;
 
 
 
  }; // end of class ArithmeticalDSL
 
 
  template <typename TCoordinate, typename TInteger, unsigned short adjacency>
  std::ostream&
  operator<< ( std::ostream & out, const ArithmeticalDSL<TCoordinate, TInteger, adjacency> & object );
 
} // namespace DGtal
 
 
// Aliases
namespace DGtal
{
  template <typename TCoordinate, typename TInteger = TCoordinate>
  class StandardDSL:
    public ArithmeticalDSL<TCoordinate, TInteger, 4>
  {
  public:
    typedef ArithmeticalDSL<TCoordinate, TInteger, 4> Super;
    typedef typename Super::Coordinate Coordinate;
    typedef typename Super::Integer Integer;
 
  public:
    StandardDSL (const Coordinate& aA,
                 const Coordinate& aB,
                 const Integer& aMu);
 
    StandardDSL ( const StandardDSL & aOther );
 
    StandardDSL & operator= ( const StandardDSL & aOther );
 
  };
 
  template <typename TCoordinate, typename TInteger = TCoordinate>
  class NaiveDSL:
    public ArithmeticalDSL<TCoordinate, TInteger, 8>
  {
  public:
    typedef ArithmeticalDSL<TCoordinate, TInteger, 8> Super;
    typedef typename Super::Coordinate Coordinate;
    typedef typename Super::Integer Integer;
 
  public:
    NaiveDSL (const Coordinate& aA,
              const Coordinate& aB,
              const Integer& aMu);
 
 
    NaiveDSL ( const NaiveDSL & aOther );
 
    NaiveDSL & operator= ( const NaiveDSL & aOther );
 
  };
} // namespace DGtal
 
// Tools
namespace DGtal
{
  namespace detail {
    
    template <typename TInput, typename TOutput >
    struct toCoordinateImpl
    {
      BOOST_CONCEPT_ASSERT(( concepts::CSignedNumber<TInput> ));
      BOOST_CONCEPT_ASSERT(( concepts::CSignedNumber<TOutput> ));
      BOOST_CONCEPT_ASSERT(( concepts::CInteger<TInput> ));
      BOOST_CONCEPT_ASSERT(( concepts::CInteger<TOutput> ));
      inline
      static TOutput cast(const TInput& aInput) 
      {
        return static_cast<TOutput>(aInput);
      }
    };
#ifdef WITH_BIGINTEGER
    //specialized versions for DGtal::BigInteger
    template <typename TOutput>
    struct toCoordinateImpl<DGtal::BigInteger, TOutput>
    {
      BOOST_CONCEPT_ASSERT(( concepts::CSignedNumber<TOutput> ));
      BOOST_CONCEPT_ASSERT(( concepts::CInteger<TOutput> ));
 
      inline
      static TOutput cast(const DGtal::BigInteger& aInput)
      {
        ASSERT( (aInput <= static_cast<DGtal::BigInteger>(std::numeric_limits<TOutput>::max())) &&
                (aInput >= static_cast<DGtal::BigInteger>(std::numeric_limits<TOutput>::min())) ); 
        return static_cast<TOutput>(aInput.get_si()); 
      }
    };
    template <>
    struct toCoordinateImpl<DGtal::BigInteger, DGtal::BigInteger>
    {
 
      inline
      static DGtal::BigInteger cast(const DGtal::BigInteger& aInput)
      {
        return aInput; 
      }
    };
#endif
 
  } //namespace detail
 
} // namespace DGtal
 
// Includes inline functions.
#include "DGtal/geometry/curves/ArithmeticalDSL.ih"
//                                                                           //
 
#endif // !defined ArithmeticalDSL_h
 
#undef ArithmeticalDSL_RECURSES
#endif // else defined(ArithmeticalDSL_RECURSES)