PlaneProbingTetrahedronEstimator.h

 
#pragma once
 
#if defined(PlaneProbingTetrahedronEstimator_RECURSES)
#error Recursive header files inclusion detected in PlaneProbingTetrahedronEstimator.h
#else // defined(PlaneProbingTetrahedronEstimator_RECURSES)
#define PlaneProbingTetrahedronEstimator_RECURSES
 
#if !defined PlaneProbingTetrahedronEstimator_h
#define PlaneProbingTetrahedronEstimator_h
 
// Inclusions
#include <iostream>
#include <vector>
#include "DGtal/base/Common.h"
#include "DGtal/geometry/helpers/PlaneProbingEstimatorHelper.h"
#include "DGtal/geometry/surfaces/estimation/PlaneProbingNeighborhood.h"
#include "DGtal/kernel/CPointPredicate.h"
 
namespace DGtal
{
    enum class ProbingMode
    {
        H, 
        R, 
        R1, 
        L, 
    };
 
    inline
    std::ostream& operator<< (std::ostream& aOs, ProbingMode const& aMode)
    {
        switch (aMode)
        {
            case ProbingMode::H:
                aOs << "H";
                break;
 
            case ProbingMode::R:
                aOs << "R";
                break;
 
            case ProbingMode::R1:
                aOs << "R1";
                break;
 
            case ProbingMode::L:
                aOs << "L";
                break;
        }
 
        return aOs;
    }
 
  // template class PlaneProbingTetrahedronEstimator
  template <typename TPredicate, ProbingMode mode = ProbingMode::H>
  class PlaneProbingTetrahedronEstimator
  {
    BOOST_CONCEPT_ASSERT((concepts::CPointPredicate<TPredicate>));
 
    // ----------------------- Public types ------------------------------
  public:
      using Self                   = PlaneProbingTetrahedronEstimator<TPredicate, mode>;
      using Predicate              = TPredicate;
      using Point                  = typename Predicate::Point;
      using Vector                 = Point;
      using Neighborhood           = PlaneProbingNeighborhood<TPredicate>;
      using Triangle               = typename Neighborhood::Triangle;
      using Integer                = typename Point::Coordinate;
      using PointOnProbingRay      = typename Neighborhood::PointOnProbingRay;
      using Permutation            = typename PointOnProbingRay::Permutation;
      using Quantity               = Vector;
      using HexagonState           = typename Neighborhood::HexagonState;
      using UpdateOperation        = typename Neighborhood::UpdateOperation;
 
    // ----------------------- Standard services ------------------------------
  public:
    PlaneProbingTetrahedronEstimator() = delete;
 
    PlaneProbingTetrahedronEstimator (Point const& aPoint, Triangle const& aM, Predicate const& aPredicate);
 
    ~PlaneProbingTetrahedronEstimator();
 
    PlaneProbingTetrahedronEstimator ( const PlaneProbingTetrahedronEstimator & other ) = delete;
 
    PlaneProbingTetrahedronEstimator ( PlaneProbingTetrahedronEstimator && other ) = delete;
 
    PlaneProbingTetrahedronEstimator & operator= ( const PlaneProbingTetrahedronEstimator & other ) = delete;
 
    PlaneProbingTetrahedronEstimator & operator= ( PlaneProbingTetrahedronEstimator && other ) = delete;
 
    // ----------------------- Plane Probing services ------------------------------
  public:
    Vector const& m (int aIndex) const;
 
    Point const& q () const;
 
    Point getOrigin () const;
 
    Triangle vertices () const;
 
    std::pair<Vector, Vector> getBasis() const;
 
    bool isReduced () const;
 
    Vector getNormal () const;
 
    std::pair<bool, UpdateOperation> advance (std::vector<PointOnProbingRay> const& aNeighbors);
 
    std::pair<bool, UpdateOperation> advance ();
 
    Quantity compute (std::vector<PointOnProbingRay> const& aNeighbors);
 
    Quantity compute ();
 
    HexagonState hexagonState () const;
 
    void translateQ (Vector const& aTranslation);
 
    void translateQ ();
 
    void applyOperation (UpdateOperation const& aOp);
 
    // ----------------------- Interface --------------------------------------
  public:
 
    void selfDisplay ( std::ostream & out ) const;
    bool isValid() const;
    bool isProjectedInside (Triangle const& aTriangle) const;
    bool isProjectedInside () const;
    bool isInside() const; 
    bool isUnimodular() const;
 
    // ------------------------- Protected Datas ------------------------------
  protected:
 
    // ------------------------- Private Datas --------------------------------
  private:
    Triangle myM; 
    Predicate const& myPredicate; 
    Point myS; 
    Point myQ; 
    Neighborhood* myNeighborhood = nullptr; 
    std::vector<UpdateOperation> myOperations; 
    // ------------------------- Hidden services ------------------------------
  protected:
    
    // ------------------------- Internals ------------------------------------
  private:
    void update (UpdateOperation const& aOp);
 
  }; // end of class PlaneProbingTetrahedronEstimator
 
 
  template <typename TPredicate, ProbingMode mode>
  std::ostream&
  operator<< ( std::ostream & out, const PlaneProbingTetrahedronEstimator<TPredicate, mode> & object );
} // namespace DGtal
 
 
// Includes inline functions.
#include "DGtal/geometry/surfaces/estimation/PlaneProbingTetrahedronEstimator.ih"
 
//                                                                           //
 
#endif // !defined PlaneProbingTetrahedronEstimator_h
 
#undef PlaneProbingTetrahedronEstimator_RECURSES
#endif // else defined(PlaneProbingTetrahedronEstimator_RECURSES)