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;

    size_t size() const;

    void clear();

    void reverse();
 
 
    // ------------------------- Private Data --------------------------------
  private:
    Functor myDefaultFunctor{};
    std::deque<Point> myContainer;
    BackwardPredicate myBackwardPredicate;
    ForwardPredicate myForwardPredicate;
    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)