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);
 
    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);
 
    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);
 
    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)