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/arithmetic/IntegerComputer.h"
#include "DGtal/arithmetic/Pattern.h"

namespace DGtal
{

  // template class StandardDSLQ0
  /*
  Description of template class 'StandardDSLQ0' <p> \brief Aim:
  Represents a digital straight line with slope in the first quadrant (Q0: x >= 0,
  y >= 0 ).

  It is the 4-connected set of points (x,y) of Z2 satisfying:

  \f$ mu <= ax - by < mu + a + b \f$

  You may move on it point by point with iterators ConstIterator.
  You can find upper and lower leaning points, find points on the
  DSL given one coordinate.  You may extract subsegment with smartDSS and
  reversedSmartDSS algorithms.

  @param TFraction the type chosen to represent fractions, a model
  of CFraction. You may use SternBrocot<>::Fraction for instance.

  Model of boost::CopyConstructible, boost::Assignable, CPointPredicate

  @see dgtal_digstraighness_sec3
  */
  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 CPointPredicate
    typedef typename IC::Point2I Point;

    struct ConstIterator {
      typedef ConstIterator Self;
      typedef Point Value;

      // stl iterator types.
      typedef std::input_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( const 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)