FP.h

 
#pragma once
 
#if defined(FP_RECURSES)
#error Recursive header files inclusion detected in FP.h
#else // defined(FP_RECURSES)
#define FP_RECURSES
 
#if !defined FP_h
#define FP_h
 
// Inclusions
#include <iostream>
#include <list>
#include "DGtal/kernel/CInteger.h"
#include "DGtal/kernel/PointVector.h"
#include "DGtal/geometry/curves/ArithmeticalDSSComputer.h"
#include "DGtal/base/Circulator.h"
#include "DGtal/base/Exceptions.h"
#include "DGtal/base/Common.h"
#include "DGtal/io/Color.h"
 
namespace DGtal
{
 
  namespace detail 
  {
 
    template <typename TDSS>
    class DSSDecorator 
    {
    public: 
      typedef TDSS DSS; 
    protected:
      TDSS* myDSS;
    public:
      bool isExtendableFront() const
      {
        return myDSS->isExtendableFront(); 
      }
      bool extendFront()
      {
        return myDSS->extendFront(); 
      }
      bool retractBack()
      {
        return myDSS->retractBack(); 
      }
      typename DSS::ConstIterator end()
      {
        return myDSS->end(); 
      }
 
      virtual ~DSSDecorator() {}
      virtual typename TDSS::Point firstLeaningPoint() const = 0;
      virtual typename TDSS::Point lastLeaningPoint() const = 0;
      virtual bool isInConvexPart() const = 0;
    };
 
    template <typename TDSS>
    class DSSDecorator4ConvexPart : public DSSDecorator<TDSS> 
    {
    public:
      DSSDecorator4ConvexPart(TDSS& aDSS)
      {
        this->myDSS = &aDSS;
      }
      typename TDSS::Point firstLeaningPoint() const 
      {
        return this->myDSS->Uf();
      }
      typename TDSS::Point lastLeaningPoint() const
      {
        return this->myDSS->Ul();
      }
      bool isInConvexPart() const { return true; }
 
    };
 
    template <typename TDSS>
    class DSSDecorator4ConcavePart : public DSSDecorator<TDSS> 
    {
    public:
      DSSDecorator4ConcavePart(TDSS& aDSS)
      {
        this->myDSS = &aDSS;
      }
      typename TDSS::Point firstLeaningPoint() const 
      {
        return this->myDSS->Lf();
      }
      typename TDSS::Point lastLeaningPoint() const
      {
        return this->myDSS->Ll();
      }
      bool isInConvexPart() const { return false; }
    };
 
  } //end namespace detail
 
 
  // template class FP
  template <typename TIterator, typename TInteger, int connectivity>
  class FP
  {
 
    // ----------------------- Types ------------------------------
  public:
 
 
    BOOST_CONCEPT_ASSERT(( concepts::CInteger<TInteger> ) );
    
    typedef DGtal::PointVector<2,TInteger> Point;
    typedef DGtal::PointVector<2,TInteger> Vector;
    
    typedef DGtal::PointVector<2, double> RealPoint;
    typedef DGtal::PointVector<2, double> RealVector;
    
    typedef DGtal::ArithmeticalDSSComputer<TIterator,TInteger,connectivity> DSSComputer;
    
    typedef std::list<Point> Polygon;
    
 
 
    // ----------------------- Standard services ------------------------------
  public:
 
    FP(const TIterator& itb, const TIterator& ite);
  
    ~FP();
 
    // ----------------------- Interface --------------------------------------
  public:
 
    const Polygon& polygon() const;
    
    bool isClosed() const;
 
 
    bool isValid() const;
 
 
    typename Polygon::size_type size() const;
 
 
    template <typename OutputIterator>
    OutputIterator copyFP(OutputIterator result) const; 
 
    template <typename OutputIterator>
    OutputIterator copyMLP(OutputIterator result) const; 
 
 
    // ------------------------- Protected Datas ------------------------------
  private:
    
    // ------------------------- Private Datas --------------------------------
  private:
 
    Polygon myPolygon;
 
  protected:
 
 
 
    // ------------------------- Hidden services ------------------------------
  private:
 
    template<typename Adapter>
    Adapter* initConvexityConcavity( typename Adapter::DSS &aDSS );
 
    template<typename Adapter>
    bool removingStep( Adapter* adapter );
 
    template<typename Adapter>
    bool addingStep( Adapter* adapter, 
                     const typename Adapter::DSS::ConstIterator& itEnd );
 
    template<typename Adapter>
    void addingStep( Adapter* adapter );
 
 
    void algorithm(const TIterator& itb, const TIterator& ite);
 
    void algorithm(const TIterator& itb, const TIterator& ite, IteratorType );
 
    void algorithm(const TIterator& itb, const TIterator& ite, CirculatorType );
 
 
 
    // ------------------------- Hidden helpers ------------------------------
 
    bool isValid(const Point& a,const Point& b, const Point& c) const;
 
    bool quadrant (const Vector& v, const int& q) const;
 
    RealPoint getRealPoint (const Point& a,const Point& b, const Point& c) const;
 
 
    // ----------------------------------------------------------------------
    FP ( const FP & other );
 
    FP & operator= ( const FP & other );
 
    // ------------------------- Display ------------------------------------
  public: 
 
    void selfDisplay ( std::ostream & out ) const;
    
    
    // --------------- CDrawableWithBoard2D realization --------------------
  public:
 
    std::string className() const;
 
  }; // end of class FP
 
 
  template <typename TIterator, typename TInteger, int connectivity>
  std::ostream&
  operator<< ( std::ostream & out, const FP<TIterator,TInteger,connectivity> & object );
 
} // namespace DGtal
 
 
// Includes inline functions.
#include "DGtal/geometry/curves/FP.ih"
 
//                                                                           //
 
#endif // !defined FP_h
 
#undef FP_RECURSES
#endif // else defined(FP_RECURSES)