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)