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)