MelkmanConvexHull.h

#pragma once

#if defined(MelkmanConvexHull_RECURSES)
#error Recursive header files inclusion detected in MelkmanConvexHull.h
#else // defined(MelkmanConvexHull_RECURSES)

#define MelkmanConvexHull_RECURSES

#if !defined MelkmanConvexHull_h

#define MelkmanConvexHull_h

// Inclusions
#include <iostream>
#include "DGtal/base/Common.h"
#include "DGtal/base/Alias.h"
#include "DGtal/base/CountedConstPtrOrConstPtr.h"
#include "DGtal/base/IteratorCirculatorTraits.h"
#include "DGtal/base/FrontInsertionSequenceToStackAdapter.h"
#include "DGtal/base/BackInsertionSequenceToStackAdapter.h"

#include "DGtal/geometry/tools/determinant/COrientationFunctor2.h"
#include "DGtal/geometry/tools/determinant/PredicateFromOrientationFunctor2.h"

#include "DGtal/geometry/tools/Hull2DHelpers.h"

namespace DGtal
{

  // template class MelkmanConvexHull
  template <typename TPoint, 
            typename TOrientationFunctor >
  class MelkmanConvexHull
  {
    // ----------------------- Types ------------------------------------------
  public:

    typedef MelkmanConvexHull<TPoint, TOrientationFunctor> Self;

    typedef TPoint Point; 
    typedef TOrientationFunctor Functor;
    BOOST_CONCEPT_ASSERT(( concepts::COrientationFunctor2<Functor> )); 
    //the two types of points must be the same
    BOOST_STATIC_ASSERT (( boost::is_same< Point, typename Functor::Point >::value )); 

    typedef PredicateFromOrientationFunctor2<Functor,false,false> BackwardPredicate; 
    typedef PredicateFromOrientationFunctor2<Functor,true,false> ForwardPredicate; 

    typedef typename std::deque<Point>::const_iterator ConstIterator; 

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

    MelkmanConvexHull( Alias<Functor> aFunctor); 
    MelkmanConvexHull(); 
    
    // ----------------------- Interface --------------------------------------
  public:

    void add ( const Point& aPoint );

    ConstIterator begin() const;

    ConstIterator end() const;

    void selfDisplay ( std::ostream & out ) const;

    bool isValid() const;

    Self & operator= ( const Self & mch );

    const Point & operator[](unsigned int i) const;
    
    unsigned int size() const;
    
    void clear();
    
    void reverse();


    // ------------------------- Private Datas --------------------------------
  private:
    std::deque<Point> myContainer; 
    BackwardPredicate myBackwardPredicate; 
    ForwardPredicate myForwardPredicate; 
    Functor myDefaultFunctor;
    Point myFirstPoint; 

    // ------------------------- Internals ------------------------------------
  private:
    
  }; // end of class MelkmanConvexHull

  template <typename TPoint, typename TOrientationFunctor>
  std::ostream&
  operator<< ( std::ostream & out, const MelkmanConvexHull<TPoint, TOrientationFunctor> & object );

  namespace functions
  {
  namespace Hull2D
  {
    template <typename ForwardIterator, 
              typename OutputIterator, 
              typename Functor >
    void melkmanConvexHullAlgorithm(const ForwardIterator& itb, 
                                    const ForwardIterator& ite,  
                                    OutputIterator res, 
                                    Functor& aFunctor ); 
  } //namespace Hull2D
  } //namespace functions

} // namespace DGtal


// Includes inline functions.
#include "DGtal/geometry/tools/MelkmanConvexHull.ih"

//                                                                           //

#endif // !defined MelkmanConvexHull_h

#undef MelkmanConvexHull_RECURSES
#endif // else defined(MelkmanConvexHull_RECURSES)