ArithmeticalDSS.h

#pragma once

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

#define ArithmeticalDSS_RECURSES

#if !defined ArithmeticalDSS_h

#define ArithmeticalDSS_h

// Inclusions
#include <iostream>
#include "DGtal/base/Common.h"
#include "DGtal/base/Exceptions.h"

#include "DGtal/geometry/curves/ArithmeticalDSL.h"
#include "DGtal/geometry/curves/ArithmeticalDSSCheck.h"
#include "DGtal/geometry/curves/ArithmeticalDSSFactory.h"
#include "DGtal/geometry/curves/ArithmeticalDSSConvexHull.h"
#include "DGtal/arithmetic/SternBrocot.h"
#include "DGtal/math/linalg/SimpleMatrix.h"

namespace DGtal
{

  // template class ArithmeticalDSS
  template <typename TCoordinate, 
            typename TInteger = TCoordinate, 
            unsigned short adjacency = 8>
  class ArithmeticalDSS
  {
    friend class ArithmeticalDSSFactory<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 ArithmeticalDSL<Coordinate, Integer, adjacency> DSL; 
    typedef typename DSL::Space Space; 
    typedef typename DSL::Point Point; 
    typedef typename DSL::Vector Vector; 
    typedef typename DSL::Steps Steps; 
    typedef Coordinate Position;
    typedef typename DSL::ConstIterator ConstIterator; 
    typedef typename DSL::ConstReverseIterator ConstReverseIterator; 

    typedef DGtal::PointVector<2, double> PointD; 

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

    ArithmeticalDSS(const Point& aPoint);

    ArithmeticalDSS(const Coordinate& aA, const Coordinate& aB, 
                    const Integer& aLowerBound, const Integer& aUpperBound, 
                    const Point& aF, const Point& aL,
                    const Point& aUf, const Point& aUl,
                    const Point& aLf, const Point& aLl, 
                    const Steps& aSteps, const Vector& aShift);

    ArithmeticalDSS(const DSL& aDSL, 
                    const Point& aF, const Point& aL,
                    const Point& aUf, const Point& aUl,
                    const Point& aLf, const Point& aLl);
    
    ArithmeticalDSS(const Coordinate& aA, const Coordinate& aB,
                    const Point& aF, const Point& aL,
                    const Point& aUf, const Point& aUl,
                    const Point& aLf, const Point& aLl);

    


    ArithmeticalDSS(const Point& aF, const Point& aL, 
                    const bool& areOnTheUpperLine = true);

    ArithmeticalDSS(const DSL& aDSL, const Point& aF, const Point& aL);

    ArithmeticalDSS(const ArithmeticalDSS& aDSS, const Point& aF, const Point& aL);

    template <typename Iterator>
    ArithmeticalDSS(const Iterator& aItb, const Iterator& aIte) throw( InputException );

    ArithmeticalDSS ( const ArithmeticalDSS & aOther );

    ArithmeticalDSS& operator= ( const ArithmeticalDSS & aOther );

    ArithmeticalDSS negate () const;

    bool equalsTo ( const ArithmeticalDSS & aOther ) const;

    bool operator== ( const ArithmeticalDSS & aOther ) const;

    bool operator!= ( const ArithmeticalDSS & aOther ) const;

    ~ArithmeticalDSS();

    // ----------------------- Interface --------------------------------------
  public:

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

    bool isValid() const;

    const DSL& dsl() const; 

    Coordinate a() const; 

    Coordinate b() const; 

    Integer mu() const; 

    Integer omega() const; 

    Vector shift() const; 
    Steps steps() const; 

    Point back() const; 

    Point front() const; 

    Point Uf() const; 

    Point Ul() const; 

    Point Lf() const; 

    Point Ll() const; 

    Integer remainder(const Point& aPoint) const; 

    Integer orthogonalPosition(const Point& aPoint) const; 

    Position position(const Point& aPoint) 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 isInDSS(const Point& aPoint) const; 
    
    bool operator()(const Point& aPoint) const; 
    
    
    bool isInDSL(const DSL& aDSL) const;

 
    bool isInDSL(const DSL& aDSL, std::vector<Point> &Ulp, std::vector<Point> &Llp, Point& outP) const;

    
   
    ArithmeticalDSS computeUnion(const ArithmeticalDSS & aOther) const;


    // ----------------------- Iterator services -------------------------------
    ConstIterator begin() const; 

    ConstIterator end() const; 

    ConstReverseIterator rbegin() const; 

    ConstReverseIterator rend() const; 

    // ----------------------- Dynamic methods --------------------------------

    unsigned short int isExtendableFront( const Point& aNewPoint ) const;

    unsigned short int isExtendableBack( const Point& aNewPoint ) const;

    bool extendFront( const Point& aNewPoint );
    bool extendBack( const Point& aNewPoint );

    bool retractFront();

    bool retractBack();

    // ------------------------- Display services ------------------------------
    PointD project( const Point& aM, double aR ) const;
    
    PointD project( const Point & aM, const Point & aP ) const;

    std::string className() const;

    // ------------------------- Hidden services ------------------------------
  protected:

    bool retractUpdateLeaningPoints( const Vector& aDirection, 
                                     const Point& aFirst,
                                     const Point& aLast, 
                                     const Point& aBezout, 
                                     const Point& aFirstAtOppositeSide, 
                                     Point& aLastAtOppositeSide, 
                                     Point& aFirstAtRemovalSide,
                                     const Point& aLastAtRemovalSide);

    void retractUpdateParameters( const Vector& aNewDirection );


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

    // -------------------- first and last point, leaning points ---------------
    Point myF;
    Point myL;
    Point myUf;
    Point myUl;
    Point myLf;
    Point myLl;

    //------------------------ DSL ---------------------------------------------
    DSL myDSL; 

  }; // end of class ArithmeticalDSS


  template <typename TCoordinate, typename TInteger, unsigned short adjacency>
  std::ostream&
  operator<< ( std::ostream & out, const ArithmeticalDSS<TCoordinate, TInteger, adjacency> & object );

} // namespace DGtal


// Aliases
namespace DGtal
{
  template <typename TCoordinate, typename TInteger = TCoordinate>
  class StandardDSS4: 
    public ArithmeticalDSS<TCoordinate, TInteger, 4>
  {
  public: 
    typedef ArithmeticalDSS<TCoordinate, TInteger, 4> Super;
    typedef typename Super::Point Point;
    typedef typename Super::Coordinate Coordinate;
    typedef typename Super::DSL DSL;

  public: 

    StandardDSS4(const Coordinate& aA, const Coordinate& aB,
                 const Point& aF, const Point& aL,
                 const Point& aUf, const Point& aUl,
                 const Point& aLf, const Point& aLl);

    StandardDSS4(const Point& aF, const Point& aL,
                 const bool& isOnTheUpperLine = true);

    StandardDSS4(const DSL& aDSL, 
                 const Point& aF, const Point& aL);

    StandardDSS4(const StandardDSS4& aDSS, 
                 const Point& aF, const Point& aL);

    template <typename Iterator>
    StandardDSS4(const Iterator& aItb, const Iterator& aIte) throw( InputException );

    StandardDSS4 ( const StandardDSS4 & aOther ); 

    StandardDSS4 & operator= ( const StandardDSS4 & aOther );

  }; 

  template <typename TCoordinate, typename TInteger = TCoordinate>
  class NaiveDSS8: 
    public ArithmeticalDSS<TCoordinate, TInteger, 8>
  {
  public: 
    typedef ArithmeticalDSS<TCoordinate, TInteger, 8> Super;
    typedef typename Super::Point Point;
    typedef typename Super::Coordinate Coordinate;
    typedef typename Super::DSL DSL;

  public: 
    NaiveDSS8(const Coordinate& aA, const Coordinate& aB,
              const Point& aF, const Point& aL,
              const Point& aUf, const Point& aUl,
              const Point& aLf, const Point& aLl);


    NaiveDSS8(const Point& aF, const Point& aL,
              const bool& isOnTheUpperLine = true);

    NaiveDSS8(const DSL& aDSL, 
              const Point& aF, const Point& aL);

    NaiveDSS8(const NaiveDSS8& aDSS, 
              const Point& aF, const Point& aL);

    template <typename Iterator>
    NaiveDSS8(const Iterator& aItb, const Iterator& aIte) throw( InputException );

    NaiveDSS8 ( const NaiveDSS8 & aOther ); 

    NaiveDSS8 & operator= ( const NaiveDSS8 & aOther );

  }; 
} // namespace DGtal


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

#endif // !defined ArithmeticalDSS_h

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