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(); 
    
    MelkmanConvexHull( const MelkmanConvexHull & mch ) = default;
 
    // ----------------------- 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)