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/ArithmeticalDSS.h"
#include "DGtal/base/Circulator.h"
#include "DGtal/base/Exceptions.h"
#include "DGtal/base/Common.h"
#include "DGtal/io/Color.h"

namespace DGtal
{


   template <typename ArithmeticalDSS>
  class Adapter 
  {
    protected:
      ArithmeticalDSS* myDSS;
    public:
      virtual typename ArithmeticalDSS::Point firstLeaningPoint() const = 0;
      virtual typename ArithmeticalDSS::Point lastLeaningPoint() const = 0;
  };

  template <typename ArithmeticalDSS>
  class Adapter4ConvexPart : public Adapter<ArithmeticalDSS> 
  {
    public:
      Adapter4ConvexPart(ArithmeticalDSS& aDSS)
    {
      this->myDSS = &aDSS;
      }
    typename ArithmeticalDSS::Point firstLeaningPoint() const 
      {
        return this->myDSS->getUf();
      }
    typename ArithmeticalDSS::Point lastLeaningPoint() const
      {
        return this->myDSS->getUl();
      }
  };

  template <typename ArithmeticalDSS>
  class Adapter4ConcavePart : public Adapter<ArithmeticalDSS> 
  {
    public:
      Adapter4ConcavePart(ArithmeticalDSS& aDSS)
      {
        this->myDSS = &aDSS;
      }
    typename ArithmeticalDSS::Point firstLeaningPoint() const 
      {
        return this->myDSS->getLf();
      }
    typename ArithmeticalDSS::Point lastLeaningPoint() const
      {
        return this->myDSS->getLl();
      }
  };


  // template class FP
  template <typename TIterator, typename TInteger, int connectivity>
  class FP
  {

    // ----------------------- Types ------------------------------
  public:


    BOOST_CONCEPT_ASSERT(( 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::ArithmeticalDSS<TIterator,TInteger,connectivity> DSSComputer;
    typedef DGtal::ArithmeticalDSS<DGtal::Circulator<TIterator>,TInteger,connectivity> DSSComputerInLoop;
    
    typedef std::list<Point> Polygon;
    


    // ----------------------- Standard services ------------------------------
  public:

    FP(const TIterator& itb, const TIterator& ite) throw( InputException ) ;
  
    FP(const TIterator& itb, const TIterator& ite, const bool& isClosed) throw( InputException ) ;

    ~FP();

    // ----------------------- Interface --------------------------------------
  public:

    const Polygon & polygon() const
    {
      return myPolygon;
    };
    
    bool flagIsClosed() const
    {
      return myFlagIsClosed;
    };


    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:

    /*
    * list where each vertex of the FP is stored
    */
    Polygon myPolygon;

    /*
    * bool equal to 'true' if the list has to be consider as circular
    * 'false' otherwise
    */
    bool myFlagIsClosed;

    // ------------------------- Hidden services ------------------------------
  protected:



  private:

    template<typename DSS, typename Adapter>
    bool initConvexityConcavity( DSS &aDSS,  
                                 Adapter* &anAdapter,
                                 const typename DSS::ConstIterator& i );

    template<typename DSS, typename Adapter>
    void mainAlgorithm( DSS &currentDSS, Adapter* adapter, 
                        bool isConvex, 
                        typename DSS::ConstIterator i, 
                        const typename DSS::ConstIterator& end )  throw( InputException ) ;


    RealPoint getRealPoint (const Point& a,const Point& b, const Point& c) const;

    bool quadrant (const Vector& v, const int& q) const;

    FP ( const FP & other );

    FP & operator= ( const FP & other );

    // ------------------------- Display ------------------------------------
  public: 

    /*
     * Writes/Displays the object on an output stream.
     * @param out the output stream where the object is written.
     */
    void selfDisplay ( std::ostream & out ) const;
    
    
    // --------------- CDrawableWithBoard2D realization --------------------
  public:
    
    //DrawableWithBoard2D* defaultStyle( std::string mode = "" ) const;
    
    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)