ChamferNorm2D.h

 
#pragma once
 
#if defined(ChamferNorm2D_RECURSES)
#error Recursive header files inclusion detected in ChamferNorm2D.h
#else // defined(ChamferNorm2D_RECURSES)
#define ChamferNorm2D_RECURSES
 
#if !defined ChamferNorm2D_h
#define ChamferNorm2D_h
 
// Inclusions
#include <iostream>
#include <vector>
#include <algorithm>
#include "DGtal/base/Common.h"
#include "DGtal/kernel/CSpace.h"
 
namespace DGtal
{
  namespace experimental
  {
    // template class ChamferNorm2D
    template <typename TSpace>
    class ChamferNorm2D
    {
      // ----------------------- Standard services ------------------------------
    public:
 
      BOOST_CONCEPT_ASSERT(( concepts::CSpace<TSpace> ));
      BOOST_STATIC_ASSERT( TSpace::dimension == 2 );
 
      typedef TSpace Space;
 
      typedef typename Space::Vector Vector;
      typedef typename Space::Point Point;
    
      typedef std::vector< Vector > Directions;
      typedef typename Directions::const_iterator ConstIterator;
 
      typedef double Value;
      typedef typename Space::Integer RawValue;
 
      typedef typename Vector::Component Abscissa;
    
    
      ChamferNorm2D(const unsigned int aN);
 
      ChamferNorm2D(const Directions &aDirectionSet,
                    const Directions &aNormalDirectionSet,
                    const Value norm = 1.0 );   
    
      ~ChamferNorm2D();
 
      /****
       * @brief Vector comparator (1st quadrant)
       */
      struct LessThanAngular
      {
        bool operator() (const Vector& a, const Vector& b) const
        {
          return  (( a[0]*b[1] - a[1]*b[0] ) > 0);
        }
      };
    
  
      /****
       * @brief Vector comparator (1st quadrant)
       */
      struct LessOrEqThanAngular
      {
        bool operator() (const Vector& a, const Vector& b) const
        {
          return  (( a[0]*b[1] - a[1]*b[0] ) >= 0);
        }
      };
 
 
      // ----------------------- Interface --------------------------------------
    public:
 
      ConstIterator getCone(const Vector &aDirection,
                            ConstIterator aBegin ,
                            ConstIterator aEnd ) const;
 
  
      ConstIterator getCone(const Vector &aDirection) const
      {
        return getCone(aDirection, myDirections.begin(), myDirections.end());
      }
 
      Vector getNormalFromCone(ConstIterator aCone) const;
    
  
      Vector canonicalRay(const Vector &aRay) const;
    
      // ----------------------- CMetricSpace concept -----------------------------------
      Value operator()(const Point &P, const Point &Q) const;
    
      RawValue rawDistance(const Point &P, const Point &Q) const;
 
    
      DGtal::Closest closest(const Point &origin,
                             const Point &first,
                             const Point &second) const
      {
        Value a = this->operator()(origin,first),
          b = this->operator()(origin,second);
        if (a<b)
          return ClosestFIRST;
        else
          if (a>b)
            return ClosestSECOND;
          else
            return ClosestBOTH;
      }
    
      ChamferNorm2D ( const ChamferNorm2D & other )
      {
        this->myDirections = other.myDirections;
        this->myNormals = other.myNormals;
      }
    
    
      ChamferNorm2D<Space> & operator= ( const ChamferNorm2D<Space> & other )
      {
        this->myDirections = other.myDirections;
        this->myNormals = other.myNormals;
        return *this;
      }
 
      // ----------- CSeparableMetric concept -----------------------------------
 
      Abscissa getLowerRayIntersection(const Vector &aP, const Vector &aQ,
                                       const Point &Lmin, const Point &Lmax,
                                       const Dimension aDimension) const ;
    
      Abscissa getUpperRayIntersection(const Vector &aP, const Vector &aQ,
                                       const Point &Lmin, const Point &Lmax,
                                       const Dimension aDimension) const ;
    
    
    
      ConstIterator shrinkPSubMask(ConstIterator aBegin,
                                   ConstIterator aEnd,
                                   const Point &aP, const Point &aQ,
                                   const Point &Lmin, const Point &Lmax,
                                   const Dimension aDimension,
                                   Point &midPoint,
                                   Point &nextMidPoint) const ;
    
    
      ConstIterator shrinkP(ConstIterator aBegin,
                            ConstIterator aEnd,
                            const Point &aP, const Point &aQ,
                            const Point &Lmin, const Point &Lmax,
                            const Dimension aDimension,
                            Point &midPoint,
                            Point &nextMidPoint) const ;
    
    
    
      Abscissa getLowerVoronoiEdgeAbscissa(const Point &u,
                                           const Point &v,
                                           const Point &startingPoint,
                                           const Point &endPoint,
                                           const Dimension dim) const;
    
    
    
      bool hiddenBy(const Point &u,
                    const Point &v,
                    const Point &w,
                    const Point &startingPoint,
                    const Point &endPoint,
                    const Dimension dim) const;
 
                                         
                                         
      // ------------------------- Directions iterators ------------------------------
      ConstIterator begin()
      {
        return myDirections.begin();
      }
    
      ConstIterator end()
      {
        return myDirections.end();
      }
    
      inline
      unsigned int size() const
      {
        return myDirections.size();
      }
    
      // ------------------------- Other services ------------------------------
      void selfDisplay ( std::ostream & out ) const;
 
      bool isValid() const;
 
 
      // ------------------------- Hidden services ------------------------------
    protected:
 
      ChamferNorm2D();
 
      // ------------------------- Internals ------------------------------------
    private:
 
      Directions myDirections;
 
      Directions myNormals;
 
      LessThanAngular myLessThanAngular;
 
      BOOST_STATIC_CONSTANT(Abscissa, myInfinity = 32562);
    
      Value myNorm;
    
    }; // end of class ChamferNorm2D
 
  }//namespace experimental
  
  template <typename T>
  std::ostream&
  operator<< ( std::ostream & out, 
               const experimental::ChamferNorm2D<T> & object );
 
} // namespace DGtal
 
 
// Includes inline functions.
#include "DGtal/geometry/volumes/distance//ChamferNorm2D.ih"
 
//                                                                           //
 
#endif // !defined ChamferNorm2D_h
 
#undef ChamferNorm2D_RECURSES
#endif // else defined(ChamferNorm2D_RECURSES)