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/NumberTraits.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; 
 
    };
    class ConstIterator {…};

    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
  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 );
 
  };
  class StandardDSL: {…};

  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 );
 
  };
  class NaiveDSL: {…};
} // 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);
      }
      static TOutput cast(const TInput& aInput)  {…}
    };
    struct toCoordinateImpl {…};
 
    //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);
      }
      static TOutput cast(const DGtal::BigInteger& aInput) {…}
    };
    struct toCoordinateImpl<DGtal::BigInteger, TOutput> {…};
    template <>
    struct toCoordinateImpl<DGtal::BigInteger, DGtal::BigInteger>
    {
      
      inline
      static DGtal::BigInteger cast(const DGtal::BigInteger& aInput)
      {
        return aInput;
      }
      static DGtal::BigInteger cast(const DGtal::BigInteger& aInput) {…}
    };
    struct toCoordinateImpl<DGtal::BigInteger, DGtal::BigInteger> {…};
 
  } //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)