ArithmeticalDSSConvexHull.h

 
#pragma once
 
#if defined(ArithmeticalDSSConvexHull_RECURSES)
#error Recursive header files inclusion detected in ArithmeticalDSSConvexHull.h
#else // defined(ArithmeticalDSSConvexHull_RECURSES)
#define ArithmeticalDSSConvexHull_RECURSES
 
#if !defined ArithmeticalDSSConvexHull_h
#define ArithmeticalDSSConvexHull_h
 
// Inclusions
#include <iostream>
#include "DGtal/base/Common.h"
 
namespace DGtal
{
 
  namespace functors {
 
    template <typename Vector, typename TPosition>
    struct PositionFunctorFrom2DPoint
    {
    public: 
      typedef TPosition Position; 
    private: 
      Vector myShift; 
    public:
      PositionFunctorFrom2DPoint(const Vector& aShift): myShift(aShift) {}
      template <typename PointVector>
      inline
      Position operator()(const PointVector& aPointVector) const
      {
        return ( - myShift[1] * aPointVector[0]
                 + myShift[0] * aPointVector[1] );
      }
    }; 
 
    template <typename Integer>
    struct LargeTruncationFunctor
    {
    public: 
      inline
      Integer operator()(const Integer& a, const Integer& b) const
      {
        ASSERT( b != NumberTraits<Integer>::ZERO );
        return a / b; 
      }
    }; 
 
    template <typename Integer>
    struct StrictTruncationFunctor
    {
    public: 
      inline
      Integer operator()(const Integer& a, const Integer& b) const 
      {
        ASSERT( a != NumberTraits<Integer>::ZERO ); 
        ASSERT( b != NumberTraits<Integer>::ZERO );
 
        Integer i = a / b;
        if (a == i*b)
          {
            if (i >= NumberTraits<Integer>::ZERO) 
              --i; 
            else 
              ++i;
          }
        return i; 
      } 
    }; 
 
  } // namespace functors
 
 
  namespace functions {
 
    template<typename Position, typename Coordinate, typename PointVector, 
             typename OutputIterator,
             typename PositionFunctor,
             typename TruncationFunctor1, typename TruncationFunctor2>
    inline
    bool
    smartCHNextVertex(const Position& positionBound,
                      const Coordinate& remainderBound,
                      PointVector& X,
                      Coordinate& rX, 
                      const PointVector& Y,
                      const Coordinate& rY, 
                      PointVector& V, 
                      Coordinate& rV,
                      OutputIterator ito,
                      const PositionFunctor& pos, 
                      const TruncationFunctor1& f1, 
                      const TruncationFunctor2& f2); 
 
    template<typename PointVector, typename Coordinate, typename Position, 
             typename PositionFunctor, typename OutputIterator>
    inline
    PointVector
    smartCH(const PointVector& aFirstPoint, 
            const Coordinate& aRemainderBound, 
            const Position& aPositionBound, 
            const PointVector& aStep,
            const Coordinate& aRStep, 
            const PointVector& aShift, 
            const Coordinate& aRShift,  
            const PositionFunctor& aPositionFunctor, 
            OutputIterator uIto, OutputIterator lIto); 
 
    template<typename DSL, typename OutputIterator>
    inline
    typename DSL::Vector smartCH(const DSL& aDSL, 
                                 const typename DSL::Point& aFirstPoint, 
                                 const typename DSL::Position& aLength, 
                                 OutputIterator uIto, OutputIterator lIto); 
 
 
    template<typename PointVector, typename Position, 
             typename OutputIterator, 
             typename TruncationFunctor1, typename TruncationFunctor2, 
             typename PositionFunctor>
    inline
    bool smartCHPreviousVertex(PointVector& X, const PointVector& Y, PointVector& V, 
                               const Position& aFirstPosition, const Position& aLastPosition, 
                               OutputIterator ito, 
                               const PositionFunctor& pos,
                               const TruncationFunctor1& f1, 
                               const TruncationFunctor2& f2); 
 
    template<typename PointVector, typename Position, typename PositionFunctor, typename OutputIterator>
    inline
    PointVector reversedSmartCH(PointVector U, PointVector L, PointVector V, 
                               const Position& aFirstPosition, const Position& aLastPosition,
                               const PositionFunctor& aPositionFunctor, 
                               OutputIterator uIto, OutputIterator lIto); 
 
    template<typename DSS, typename OutputIterator>
    inline
    typename DSS::Vector reversedSmartCH(const DSS& aDSS, 
                                        const typename DSS::Position& aPositionBound, 
                                        OutputIterator uIto, OutputIterator lIto); 
 
  } // namespace functions
 
 
} // namespace DGtal
 
 
// Includes inline functions.
#include "DGtal/geometry/curves/ArithmeticalDSSConvexHull.ih"
 
//                                                                           //
 
#endif // !defined ArithmeticalDSSConvexHull_h
 
#undef ArithmeticalDSSConvexHull_RECURSES
#endif // else defined(ArithmeticalDSSConvexHull_RECURSES)