Pattern.h

 
#pragma once
 
#if defined(Pattern_RECURSES)
#error Recursive header files inclusion detected in Pattern.h
#else // defined(Pattern_RECURSES)
#define Pattern_RECURSES
 
#if !defined Pattern_h
#define Pattern_h
 
// Inclusions
#include <iostream>
#include <string>
#include "DGtal/base/Common.h"
#include "DGtal/arithmetic/CPositiveIrreducibleFraction.h"
#include "DGtal/arithmetic/IntegerComputer.h"
#include "DGtal/arithmetic/SternBrocot.h"
 
namespace DGtal
{
 
  // template class Pattern
  template <typename TFraction>
  class Pattern
  {
  public:
    typedef TFraction Fraction;
    BOOST_CONCEPT_ASSERT(( concepts::CPositiveIrreducibleFraction< Fraction > ));
 
    typedef Pattern<TFraction> Self;
    typedef typename Fraction::Integer Integer;
    typedef typename Fraction::Quotient Quotient;
    
    // BOOST_CONCEPT_ASSERT(( CInteger< Quotient > ));
 
    // ----------------------- associated types ------------------------------
  public:
 
    typedef IntegerComputer<Integer> IC;
    typedef typename IC::Point2I Point2I;
    typedef typename IC::Vector2I Vector2I;
 
    // ----------------------- Standard services ------------------------------
  public:
 
    ~Pattern();
 
    Pattern( Fraction f = Fraction( 0 ) );
 
    Pattern( Integer p, Integer q );
 
    Pattern ( const Pattern & other );
 
    Pattern & operator= ( const Pattern & other );
 
    // ----------------------- Pattern services -------------------------------
  public:
 
    std::string rE() const;
 
    std::string rEs( const std::string & seps = "(|)" ) const;
 
    Fraction slope() const;
 
    Integer length() const;
 
    Integer posU( Quotient k ) const;
 
    Integer posL( Quotient k ) const;
 
    Point2I U( Quotient k ) const;
 
    Point2I L( Quotient k ) const;
 
    Vector2I bezout() const;
    Vector2I v() const;
 
    Pattern previousPattern() const;
 
 
    bool
    getSmallestCoveringSubpattern( Pattern & subpattern,
                                   Quotient & nb,
                                   Vector2I & startPos,
                                   Integer posA, Integer posB,
                                   bool reversed = false ) const;
 
    bool
    getGreatestIncludedSubpattern( Pattern & subpattern,
                                   Quotient & nb,
                                   Vector2I & startPos,
                                   Integer posA, Integer posB,
                                   bool reversed = false ) const;
 
    // ----------------------- Interface --------------------------------------
  public:
 
    void selfDisplay ( std::ostream & out ) const;
 
    bool isValid() const;
 
    // ------------------------- Protected Datas ------------------------------
  private:
    // ------------------------- Private Datas --------------------------------
  private:
 
    Fraction mySlope;
 
    // ------------------------- Hidden services ------------------------------
  protected:
 
    // ------------------------- Internals ------------------------------------
  private:
 
  }; // end of class Pattern
 
 
  template <typename TFraction>
  std::ostream&
  operator<< ( std::ostream & out, const Pattern<TFraction> & object );
 
} // namespace DGtal
 
 
// Includes inline functions.
#include "DGtal/arithmetic/Pattern.ih"
 
//                                                                           //
 
#endif // !defined Pattern_h
 
#undef Pattern_RECURSES
#endif // else defined(Pattern_RECURSES)