PlaneProbingEstimatorHelper.h

 
#pragma once
 
#if defined(PlaneProbingEstimatorHelper_RECURSES)
#error Recursive header files inclusion detected in PlaneProbingEstimatorHelper.h
#else // defined(PlaneProbingEstimatorHelper_RECURSES)
#define PlaneProbingEstimatorHelper_RECURSES
 
#if !defined PlaneProbingEstimatorHelper_h
#define PlaneProbingEstimatorHelper_h
 
// Inclusions
#include <array>
#include <cassert>
#include "DGtal/math/linalg/SimpleMatrix.h"
#include "DGtal/base/Common.h"
#include "DGtal/kernel/CInteger.h"
 
namespace DGtal
{
    namespace detail
    {
        template < typename Point >
        typename Point::Coordinate squaredNorm (Point const& aPoint);
 
        template < int N, typename T >
        T determinant (const T aMatrix[N][N]);
 
        template < typename Point >
        inline
        typename Point::Coordinate distToSphere (std::array<Point, 5> const& aPoints);
 
        template < typename Point >
        inline
        bool isBasisReduced (Point const& aU, Point const& aV);
 
        // template class PointOnProbingRay
      template < typename Integer = int, typename Index = std::size_t >
        class PointOnProbingRay
        {
            BOOST_CONCEPT_ASSERT(( concepts::CInteger<Integer> ) );
 
            // ----------------------- Public types ------------------------------
            public:
                using Permutation = std::array<Index, 3>;
 
            public:
                PointOnProbingRay () = default;
 
                PointOnProbingRay (Permutation const& aSigma, Integer const& aInt = Integer(0));
 
                PointOnProbingRay getBase () const;
 
                Permutation const& sigma () const;
 
                Index sigma (Index const& aIndex) const;
 
                Integer const& position () const;
 
                 template < typename Point >
                 Point relativePoint (std::array<Point, 3> const& aM) const;
          
                bool operator== (PointOnProbingRay const& aRay) const;
 
                bool operator!= (PointOnProbingRay const& aRay) const;
 
                bool operator<= (PointOnProbingRay const& aRay) const;
 
                PointOnProbingRay next (Integer const& aInc) const;
 
                PointOnProbingRay previous (Integer const& aDec) const;
 
            private:
                Permutation mySigma; 
                Integer myPosition; 
        }; // end of class PointOnProbingRay
 
      template < typename Integer, typename Index >
      std::ostream& operator<< (std::ostream& aOs, PointOnProbingRay<Integer,Index> const& aRay);
 
      // template class GridPoint
      template < typename Integer = int, typename Index = std::size_t >
      class GridPoint
      {
        BOOST_CONCEPT_ASSERT(( concepts::CInteger<Integer> ) );
        
      public:
        
        GridPoint () = default;
 
        GridPoint (std::pair<Integer,Integer> const& aDir, Index const& aK ) : myDir(aDir), myK(aK) {}
 
        GridPoint (Integer const& aX, Integer const& aY, Index const& aK ) : myDir(std::make_pair(aX,aY)), myK(aK) {}
          
        std::pair<Integer,Integer> direction() const {
          return myDir; 
        }
 
        Index k() const {
          return myK; 
        }
        
        template < typename Vector >
        Vector directionVector (std::array<Vector, 3> const& aM) const {
          return aM[(myK+1)%3]*myDir.first + aM[(myK+2)%3]*myDir.second;
        }
 
        template < typename Point >
        Point relativePoint (std::array<Point, 3> const& aM) const {
          return -aM[myK] + directionVector(aM); 
        }
        
        bool operator== (GridPoint const& other) const {
          return (myDir == other.myDir) && (myK == other.myK);
        }
 
        bool operator!= (GridPoint const& other) const {
          return !(*this == other);
        }
 
        GridPoint getOnSameGrid(const std::pair<Integer,Integer>& aDir) const {   
          return GridPoint(aDir,myK);                                    
        }
 
        GridPoint operator+(const GridPoint & other) const {   
          ASSERT(myK == other.myK);
          std::pair<Integer,Integer> d = std::make_pair(myDir.first+other.myDir.first,
                                                myDir.second+other.myDir.second);
          return getOnSameGrid(d);                                    
        }
 
        GridPoint operator*(Integer aValue) const {   
          std::pair<Integer,Integer> d = std::make_pair(myDir.first*aValue,
                                                myDir.second*aValue);
          return getOnSameGrid(d);                                    
        } 
        
        bool isValid() const {
          if ( (myDir.first != 0) || (myDir.second != 0) ) { //not both null
            return ( (myDir.first >= 0) && (myDir.second >= 0)
                     && (myK >= 0) && (myK <= 2)
                     );
          } else {
            return false; 
          }
        }
        
      private:
 
        std::pair<Integer,Integer> myDir; 
        Index myK; 
      }; //end of class GridPoint
 
      template < typename Integer, typename Index >
      std::ostream& operator<< (std::ostream& aOs, GridPoint<Integer,Index> const& aGridPoint) {
        aOs << "GridPoint[k=" << aGridPoint.k()
            << ", a=" << aGridPoint.direction().first
            << ", b=" << aGridPoint.direction().second
            << "]";
        return aOs; 
      }
 
      // template class GridPointOnProbingRay
      template < typename Integer = int, typename Index = std::size_t >
      class GridPointOnProbingRay
      {
        BOOST_CONCEPT_ASSERT(( concepts::CInteger<Integer> ) );
 
      public: 
        GridPointOnProbingRay () = default;
 
        GridPointOnProbingRay (const GridPoint<Integer, Index>& aGridPoint,
                               const std::pair<Integer,Integer>& aDirection,
                               const Integer& aIdx = 0)
          : myOrigin(aGridPoint), myDirection(aDirection), myIdx(aIdx) {}
 
        bool operator== (GridPointOnProbingRay const& other) const {
          return ( (myOrigin == other.myOrigin) &&
                   (myDirection == other.myDirection) &&
                   (myIdx == other.myIdx) );
        }
 
        bool operator!= (GridPointOnProbingRay const& other) const {
          return !(*this == other);
        }
 
        GridPointOnProbingRay next(const Integer& aInc) const {
          return GridPointOnProbingRay(myOrigin, myDirection, myIdx+aInc); 
        }
 
        GridPointOnProbingRay previous(const Integer& aDec) const {
          return GridPointOnProbingRay(myOrigin, myDirection, myIdx-aDec); 
        }
        
        Integer index() const {
          return myIdx; 
        }
 
        GridPoint<Integer, Index> gridPoint() const {
          return myOrigin + myOrigin.getOnSameGrid(myDirection)*myIdx; 
        }
 
        template < typename Point >
        Point relativePoint (std::array<Point, 3> const& aM) const {
          return gridPoint().relativePoint(aM); 
        }
 
 
      private: 
        GridPoint<Integer, Index> myOrigin; 
        std::pair<Integer, Integer> myDirection; 
        Integer myIdx; 
      }; //end of class GridPointOnProbingRay
      
    } // namespace detail
} // namespace DGtal
 
// Includes inline functions.
#include "DGtal/geometry/helpers/PlaneProbingEstimatorHelper.ih"
 
//                                                                           //
 
#endif // !defined PlaneProbingEstimatorHelper_h
 
#undef PlaneProbingEstimatorHelper_RECURSES
#endif // else defined(PlaneProbingEstimatorHelper_RECURSES)