StandardDSLQ0.h

#pragma once

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

#define StandardDSLQ0_RECURSES

#if !defined StandardDSLQ0_h

#define StandardDSLQ0_h

// Inclusions
#include <iostream>
#include "DGtal/base/Common.h"
#include "DGtal/base/ConstAlias.h"
#include "DGtal/arithmetic/IntegerComputer.h"
#include "DGtal/arithmetic/Pattern.h"

namespace DGtal
{

  // template class StandardDSLQ0
  template <typename TFraction>
  class StandardDSLQ0
  {
    // ----------------------- Standard types ------------------------------
  public:
    typedef TFraction Fraction;
    typedef StandardDSLQ0<TFraction> Self;
    typedef typename Fraction::Integer Integer;
    typedef typename Fraction::UnsignedInteger UnsignedInteger;
    typedef typename Fraction::Quotient Quotient;

    // BOOST_CONCEPT_ASSERT(( CFraction<Fraction> ));

    typedef IntegerComputer<Integer> IC;
    typedef typename IC::IntegerParamType IntegerParamType;
    typedef typename IC::Vector2I Vector2I;
    typedef typename IC::Point2I Point2I;

    // Model of concepts::CPointPredicate
    typedef typename IC::Point2I Point;

    struct ConstIterator {
      typedef ConstIterator Self;
      typedef Point Value;

      // stl iterator types.
      typedef std::forward_iterator_tag iterator_category;
      typedef Point value_type;
      typedef std::ptrdiff_t difference_type; 
      typedef const Point* pointer;
      typedef const Point& reference;

      inline ConstIterator()
        : myPtrDSL( 0 )
      {}
      inline ConstIterator( ConstAlias< StandardDSLQ0<TFraction> > myDSL,
                            const Point & p )
        : myPtrDSL( & myDSL ), myP( p )
      {}
      inline ConstIterator( const Self & other )
        : myPtrDSL( other.myPtrDSL ), myP( other.myP )
      {}
      inline Self& operator=( const Self & other )
      {
        if ( this != &other )
          {
            myPtrDSL = other.myPtrDSL;
            myP = other.myP;
          }
        return *this;
      }

      inline reference operator*() const
      {
        ASSERT( myPtrDSL != 0 );
        return myP;
      }

      inline pointer operator->() const
      { 
        ASSERT( myPtrDSL != 0 );
        return &myP;
      }

      inline Self& operator++()
      {
        Integer rem = myPtrDSL->r( myP );
        if ( rem - myPtrDSL->b() >= myPtrDSL->mu() )
          ++myP[ 1 ]; // +y;
        else
          ++myP[ 0 ]; // +x;
        return *this;
      }

      inline
      Self
      operator++(int)
      {
        Self __tmp = *this;
        this->operator++();
        return __tmp;
      }
      
      inline
      bool operator==( const Self & other ) const
      {
        ASSERT( myPtrDSL == other.myPtrDSL );
        return myP == other.myP;
      }

      inline
      bool operator!=( const Self & other ) const
      {
        return ! ( this->operator==( other ) );
      }


    private:
      const StandardDSLQ0<TFraction>* myPtrDSL;
      Point myP;
      
    };
    // ----------------------- Standard services ------------------------------
  public:

    ~StandardDSLQ0();

    StandardDSLQ0();

    StandardDSLQ0 ( const StandardDSLQ0 & other );

    StandardDSLQ0 & operator= ( const StandardDSLQ0 & other );

    StandardDSLQ0( Fraction aSlope, IntegerParamType aMu );

    StandardDSLQ0( IntegerParamType a1, IntegerParamType b1, 
                   IntegerParamType mu1 );

    bool operator()( const Point & p ) const;

    Fraction slope() const;

    const Integer & mu() const;

    Integer mup() const;

    Integer a() const;
    Integer b() const;
    Vector2I v() const;

    ConstIterator begin( Point p ) const;

    ConstIterator end( Point p ) const;

    const Pattern<Fraction> & pattern() const;

    Integer r( const Point & p ) const;

    Point U() const;
    Point L() const;

    Point lowestY( IntegerParamType x ) const;
    Point uppermostY( IntegerParamType x ) const;
    Point lowestX( IntegerParamType y ) const;
    Point uppermostX( IntegerParamType y ) const;

    bool before( const Point & p1, const Point & p2 ) const;
    bool beforeOrEqual( const Point & p1, const Point & p2 ) const;
    

    Self reversedSmartDSS( const Point & A, const Point & B ) const;

    Self reversedSmartDSS( Point U1, Point U2,
                           const Point & A, const Point & B ) const;

    Self DSSWithinTwoPatterns( Point U1, Point U2,
                               const Point & A, const Point & B ) const;


    Self smartDSS( const Point & A, const Point & B ) const;

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

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

    bool isValid() const;

    // ------------------------- Protected Datas ------------------------------
  protected:
    Pattern<Fraction> myPattern;
    Integer myMu;

    // ------------------------- Private Datas --------------------------------
  private:
    IC ic;

    // ------------------------- Hidden services ------------------------------
  protected:
    
    // ------------------------- Internals ------------------------------------
  private:
    static Fraction deepest( Fraction f1, Fraction f2, Fraction f3 );
    static Fraction deepest( Fraction f1, Fraction f2 );
  }; // end of class StandardDSLQ0


  template <typename TFraction>
  std::ostream&
  operator<< ( std::ostream & out, const StandardDSLQ0<TFraction> & object );

} // namespace DGtal


// Includes inline functions.
#include "DGtal/arithmetic/StandardDSLQ0.ih"

//                                                                           //

#endif // !defined StandardDSLQ0_h

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