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 <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/io/Color.h"

#include "DGtal/geometry/curves/SegmentComputerUtils.h"



namespace DGtal
{


  // class ArithmeticalDSS
  template <typename TIterator, 
    typename TInteger = typename IteratorCirculatorTraits<TIterator>::Value::Coordinate, 
    int connectivity = 8>
  class ArithmeticalDSS
  {



    // generic class for computing the norm of (a,b)
    // max(a,b) for 8-connectivity 
    // |a|+|b| for 4-connectivity

    //default (for 8-connectivity) 
    template <typename TInt, int c>
    struct Tools
    {
      static TInt norm(const TInt& a, const TInt& b) 
      {
        TInt x;
        if (a>=0) x = a;
        else x = -a;
        TInt y;
        if (b>=0) y = b;
        else y = -b;
        return (x>=y)?x:y;
      }
      static TInt dualNorm(const TInt& a, const TInt& b) 
      {
        if (a > 0) {
          if (b > 0) {
            return (a+b);
          } else {
            return (a-b);    
          }
        } else {
          if (b > 0) {
            return (-a+b);            
          } else {
            return (-a-b);    
          }
        }
      }
    };

    //specialisation for 4-connectivity
    template <typename TInt>
    struct Tools<TInt,4> 
    {
      static TInt norm(const TInt& a, const TInt& b) 
      {
        if (a > 0) {
          if (b > 0) {
            return (a+b);
          } else {
            return (a-b);    
          }
        } else {
          if (b > 0) {
            return (-a+b);            
          } else {
            return (-a-b);    
          }
        }
      }

      static TInt dualNorm(const TInt& a, const TInt& b) 
      {
        TInt x;
        if (a>=0) x = a;
        else x = -a;
        TInt y;
        if (b>=0) y = b;
        else y = -b;
        return (x>=y)?x:y;
      }

    };


    // ----------------------- inner types ------------------------------
  public:

    //entier
    BOOST_CONCEPT_ASSERT(( CInteger<TInteger> ));
    typedef TInteger Integer;

    //requiered types
    typedef TIterator ConstIterator;
    typedef ArithmeticalDSS<ConstIterator,TInteger,connectivity> Self; 
    typedef ArithmeticalDSS<ReverseIterator<ConstIterator>,TInteger,connectivity> Reverse;

    //2D point and 2D vector
    typedef typename IteratorCirculatorTraits<ConstIterator>::Value Point; 
    typedef typename IteratorCirculatorTraits<ConstIterator>::Value Vector; 

    //Point should be 2D Point
    //uncomment if CPointVector is written
    //BOOST_CONCEPT_ASSERT(( CPointVector<Point> ));
    BOOST_STATIC_ASSERT(( Point::dimension == 2 ));

    typedef PointVector<2,double> PointD;  


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


    ArithmeticalDSS();

    ArithmeticalDSS(const ConstIterator& it);

    void init(const ConstIterator& it);


    ArithmeticalDSS ( const Self & other );

    Self& operator= ( const Self & other );

    Self getSelf() const;

    Reverse getReverse() const;
        

    bool operator==( const Self & other ) const;

    bool operator!=( const Self & other ) const;

    ~ArithmeticalDSS(){};

    // ----------------------- Interface --------------------------------------
  public:
     
    bool isExtendableForward(const ConstIterator & itf);

    bool isExtendableForward();

    bool isExtendableBackward();
    
    bool extendForward(const ConstIterator & itf);

    bool extendBackward(const ConstIterator & itb);

    bool extendForward();

    bool extendBackward();

    bool retractForward();

    bool retractBackward();





    // ------------------------- Accessors ------------------------------
    Integer getA() const;
    Integer getB() const;
    Integer getMu() const;
    Integer getOmega() const;
    Point getUf() const;
    Point getUl() const;
    Point getLf() const;
    Point getLl() const;
    Point getBackPoint() const;
    Point getFrontPoint() const;
    Point getFirstPoint() const;
    Point getLastPoint() const;
    ConstIterator getBack() const;
    ConstIterator getFront() const;
    ConstIterator begin() const;
    ConstIterator end() const;


    bool isValid() const;


    // ------------------ Useful tools -----------------------------------

    Integer getRemainder(const ConstIterator & it) const;

    Integer getRemainder( const Point& aPoint ) const;

    Integer getPosition(const ConstIterator & it) const;

    Integer getPosition( 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:

    bool isExtendableForward( const Point & lastPoint, 
                              const Vector & lastMove );
    
    bool extendForward( const ConstIterator & it, 
                        ConstIterator & lastIt, 
                        const Vector & lastMove,
                        Point & Uf,  Point & Ul,
                        Point & Lf,  Point & Ll );
    
    bool retractForward( ConstIterator & firstIt,
                        ConstIterator & lastIt,
                        ConstIterator & nextIt,       
                        Point & Uf,  Point & Ul,
                        Point & Lf,  Point & Ll,
                        const Integer& s );


    bool hasLessThanTwoSteps(const Vector& aStep) const;


    Vector vectorFrom0ToOmega() const;



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

    //parameters of the DSS
    Integer myA;
    Integer myB;
    Integer myMu;
    Integer myOmega;

    //number of upper and lower patterns
    Integer myNbUpPat;
    Integer myNbLowPat; 

    
    std::vector<Vector> mySteps;
    
    // ------------------------- Private Datas --------------------------------
  
  private:


    // ------------------ Display ------------------------------------------

  public:
    //leaning points (here because Display2DFactory, todo: accessors)
    Point myUf;
    Point myUl;
    Point myLf;
    Point myLl;
    
    //Iterators to the first (at the back) and last (at the front) 
    //points of the DSS  (here because Display2DFactory, todo: accessors)
    ConstIterator myF;
    ConstIterator myL;
    
    PointD project( const Point & m ) const;

    PointD project( const Point & m, double r ) const;
    
    PointD project( const Point & m, const Point & p ) const;
  

    double projectedSegmentLength() const;
    
    void selfDisplay ( std::ostream & out ) ; 
    
    
    // ------------------------- Private Datas --------------------------------
  private:



    // --------------- CDrawableWithBoard2D realization --------------------
  public:
    
    //DrawableWithBoard2D* defaultStyle( std::string mode = "" ) const;
    
    std::string className() const;

    
  }; // end of class ArithmeticalDSS


template <typename TIterator, typename TInteger, int connectivity>
std::ostream&
operator<< ( std::ostream & out,  ArithmeticalDSS<TIterator,TInteger,connectivity> & object )
{
  object.selfDisplay( out);
  return out;
}


} // namespace DGtal



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

//                                                                           //

#endif // !defined ArithmeticalDSS_h

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