Hull2DHelpers.h

 
#pragma once
 
#if defined(Hull2DHelpers_RECURSES)
#error Recursive header files inclusion detected in Hull2DHelpers.h
#else // defined(Hull2DHelpers_RECURSES)
#define Hull2DHelpers_RECURSES
 
#if !defined Hull2DHelpers_h
#define Hull2DHelpers_h
 
// Inclusions
#include <iostream>
#include <list>
#include <vector>
#include "boost/utility.hpp"
 
#include "DGtal/base/Common.h"
#include "DGtal/base/IteratorCirculatorTraits.h"
#include "DGtal/base/FrontInsertionSequenceToStackAdapter.h"
#include "DGtal/base/BackInsertionSequenceToStackAdapter.h"
#include "DGtal/base/CStack.h"
#include "DGtal/geometry/tools/CPolarPointComparator2D.h"
#include "DGtal/geometry/tools/PolarPointComparatorBy2x2DetComputer.h"
#include "DGtal/geometry/tools/determinant/COrientationFunctor2.h"
#include "DGtal/geometry/tools/determinant/PredicateFromOrientationFunctor2.h"
#include "DGtal/geometry/tools/determinant/AvnaimEtAl2x2DetSignComputer.h"
#include "DGtal/geometry/tools/determinant/Simple2x2DetComputer.h"
 
namespace DGtal
{
 
  namespace functions
  {
  namespace Hull2D
  {
    // used to compare point alignement in computeHullThickness. 
    constexpr double angleTolerance = 1e-6;
    enum ThicknessDefinition {HorizontalVerticalThickness, EuclideanThickness};
 
 
    template <typename Stack, 
              typename Point, 
              typename Predicate>
    void updateHullWithStack(Stack& aStack, 
                             const Point& aNewPoint, 
                             const Predicate& aPredicate); 
 
    template <typename Stack, 
              typename Point, 
              typename Predicate>
    void updateHullWithAdaptedStack(Stack aStack, 
                                    const Point& aNewPoint, 
                                    const Predicate& aPredicate); 
 
    template <typename Stack, 
              typename ForwardIterator, 
              typename Predicate>
    void buildHullWithStack(Stack& aStack, 
                            const ForwardIterator& itb, 
                            const ForwardIterator& ite,
                            const Predicate& aPredicate); 
 
    template <typename Stack, 
              typename ForwardIterator, 
              typename Predicate>
    void buildHullWithAdaptedStack(Stack aStack, 
                                   const ForwardIterator& itb, 
                                   const ForwardIterator& ite,
                                   const Predicate& aPredicate); 
 
    template <typename ForwardIterator, 
              typename OutputIterator, 
              typename Predicate>
    void openGrahamScan(const ForwardIterator& itb, 
                        const ForwardIterator& ite,  
                        OutputIterator res, 
                        const Predicate& aPredicate); 
 
    template <typename ForwardIterator, 
              typename OutputIterator, 
              typename Predicate>
    void closedGrahamScanFromVertex(const ForwardIterator& itb, 
                                    const ForwardIterator& ite,  
                                    OutputIterator res, 
                                    const Predicate& aPredicate); 
 
    template <typename ForwardIterator, 
              typename OutputIterator, 
              typename Predicate>
    void closedGrahamScanFromAnyPoint(const ForwardIterator& itb, 
                                      const ForwardIterator& ite,  
                                      OutputIterator res, 
                                      const Predicate& aPredicate); 
 
    template <typename ForwardIterator, 
              typename OutputIterator, 
              typename Predicate, 
              typename PolarComparator >
    void grahamConvexHullAlgorithm(const ForwardIterator& itb, 
                                   const ForwardIterator& ite,  
                                   OutputIterator res, 
                                   const Predicate& aPredicate, 
                                   PolarComparator& aPolarComparator); 
 
    template <typename ForwardIterator, 
              typename OutputIterator, 
              typename Predicate, 
              typename PolarComparator >
    void grahamConvexHullAlgorithm(const ForwardIterator& itb, 
                                   const ForwardIterator& ite,  
                                   OutputIterator res, 
                                   const Predicate& aPredicate); 
 
    template <typename ForwardIterator, 
              typename OutputIterator, 
              typename Predicate >
    void andrewConvexHullAlgorithm(const ForwardIterator& itb, 
                                   const ForwardIterator& ite,  
                                   OutputIterator res, 
                                   const Predicate& aPredicate ); 
 
 
    template <typename ForwardIterator >
    double computeHullThickness(const ForwardIterator& itb, 
                                const ForwardIterator& ite,
                                const ThicknessDefinition& def);
 
 
    template <typename ForwardIterator, 
              typename TInputPoint >
    double computeHullThickness(const ForwardIterator& itb, 
                                const ForwardIterator& ite,
                                const ThicknessDefinition& def,
                                TInputPoint& antipodalEdgeP,
                                TInputPoint& antipodalEdgeQ,
                                TInputPoint& antipodalVertexR);
 
 
    template<typename TInputPoint>
    inline
    double getAngle(const TInputPoint& a, const TInputPoint& b,const TInputPoint& c,const  TInputPoint& d);
 
    
    template<typename TInputPoint>
    inline
    bool isCoLinearOpp(const TInputPoint& a, const TInputPoint& b,
                       const TInputPoint& c, const TInputPoint& d );
 
 
    
    
    template<typename TInputPoint>
    double getThicknessAntipodalPair(const TInputPoint& p, const TInputPoint& q, 
                                     const TInputPoint& r, const ThicknessDefinition& def);
 
    template< typename TInputPoint>
    double
    computeHProjDistance(const TInputPoint& a, const TInputPoint& b, const TInputPoint& c, bool& isInside );
 
 
    template< typename TInputPoint>
    double
    computeVProjDistance(const TInputPoint& a, const TInputPoint& b, const TInputPoint& c, bool& isInside );
 
 
    template< typename TInputPoint>
    double
    computeEuclideanDistance(const TInputPoint& a, const TInputPoint& b, const TInputPoint& c, bool& isInside );
    
      
 
  } // namespace convexHull2D
 
  } // namespace functions
 
} // namespace DGtal
 
// Includes friend functions.
#include "DGtal/geometry/tools/MelkmanConvexHull.h"
 
// Includes inline functions.
#include "DGtal/geometry/tools/Hull2DHelpers.ih"
 
//                                                                           //
 
#endif // !defined Hull2DHelpers_h
 
#undef Hull2DHelpers_RECURSES
#endif // else defined(Hull2DHelpers_RECURSES)