PlaneProbingParallelepipedEstimator.h

 
#pragma once
 
#if defined(PlaneProbingParallelepipedEstimator_RECURSES)
#error Recursive header files inclusion detected in PlaneProbingParallelepipedEstimator.h
#else // defined(PlaneProbingParallelepipedEstimator_RECURSES)
#define PlaneProbingParallelepipedEstimator_RECURSES
 
#if !defined PlaneProbingParallelepipedEstimator_h
#define PlaneProbingParallelepipedEstimator_h
 
// Inclusions
#include <iostream>
#include "DGtal/base/Common.h"
#include "DGtal/geometry/helpers/PlaneProbingEstimatorHelper.h"
#include "DGtal/geometry/surfaces/estimation/PlaneProbingTetrahedronEstimator.h"
#include "DGtal/kernel/CPointPredicate.h"
 
namespace DGtal
{
 
  // template class PlaneProbingParallelepipedEstimator
  template <typename TPredicate, ProbingMode mode>
  class PlaneProbingParallelepipedEstimator
  {
    BOOST_CONCEPT_ASSERT((concepts::CPointPredicate<TPredicate>));
 
    // ----------------------- Public types ------------------------------
  public:
      class NotAbovePredicate;
      using Self                        = PlaneProbingParallelepipedEstimator<TPredicate, mode>;
      using Predicate                   = TPredicate;
      using Point                       = typename Predicate::Point;
      using Vector                      = Point;
      using Integer                     = typename Predicate::Integer;
      using TetrahedronEstimator        = PlaneProbingTetrahedronEstimator<NotAbovePredicate, mode>;
      using Triangle                    = typename TetrahedronEstimator::Triangle;
      using PointOnProbingRay           = typename TetrahedronEstimator::PointOnProbingRay;
      using Quantity                    = typename TetrahedronEstimator::Quantity;
      using UpdateOperation             = typename TetrahedronEstimator::UpdateOperation;
      using HexagonState                = typename TetrahedronEstimator::HexagonState;
 
      class NotAbovePredicate
      {
      public:
 
      using Point   = typename Self::Point;
      using Integer = typename Self::Integer;
 
          NotAbovePredicate (Predicate const& aPredicate, Integer const& aBound, Self* aParallelepipedEstimator);
 
          NotAbovePredicate& operator= (const NotAbovePredicate & other);
 
          bool inPlane (Point const& aPoint) const;
 
          bool operator() (Point const& aPoint) const;
 
      private:
          const Predicate* myPredicate = nullptr; 
          Integer myBound; 
          Self* myParallelpipedEstimator = nullptr; 
          Point q () const;
      };
 
 
    // ----------------------- Standard services ------------------------------
  public:
    PlaneProbingParallelepipedEstimator() = delete;
 
    PlaneProbingParallelepipedEstimator(Point const& aPoint, Triangle const& aM,
                                        Predicate const& aPredicate, Integer const& aBound);
 
    ~PlaneProbingParallelepipedEstimator() = default;
 
    PlaneProbingParallelepipedEstimator ( const PlaneProbingParallelepipedEstimator & other ) = delete;
 
    PlaneProbingParallelepipedEstimator ( PlaneProbingParallelepipedEstimator && other ) = delete;
 
    PlaneProbingParallelepipedEstimator & operator= ( const PlaneProbingParallelepipedEstimator & other ) = delete;
 
    PlaneProbingParallelepipedEstimator & operator= ( PlaneProbingParallelepipedEstimator && other ) = delete;
 
    // ----------------------- Plane Probing services ------------------------------
  public:
    Vector m (int aIndex) const;
 
    Point q () const;
 
    Point getOrigin () const;
 
    int getState () const;
 
    bool isSeparating () const;
 
    bool advance (std::vector<PointOnProbingRay> const& aNeighbors);
 
    bool advance ();
 
    Quantity compute (std::vector<PointOnProbingRay> const& aNeighbors);
 
    Quantity compute ();
 
    HexagonState hexagonState () const;
 
    Vector getNormal() const;
 
    std::pair<Vector, Vector> getBasis () const;
 
    bool isReduced () const;
 
    bool isInReverseState () const;
 
    // ----------------------- Interface --------------------------------------
  public:
 
    void selfDisplay ( std::ostream & out ) const;
 
    bool isValid() const;
 
    // ------------------------- Protected Datas ------------------------------
  protected:
 
    // ------------------------- Private Datas --------------------------------
  private:
 
    // ------------------------- Hidden services ------------------------------
  protected:
 
    // ------------------------- Internals ------------------------------------
  private:
    NotAbovePredicate myNotAbovePredicate; 
    TetrahedronEstimator myTetrahedronEstimator; 
    bool myIsInReverseState; 
    std::vector<UpdateOperation> geometricalDecomposition (UpdateOperation const& aOp) const;
 
    bool translateIf (UpdateOperation const& aOp);
 
    bool inPlane (Point const& aPoint) const;
 
  }; // end of class PlaneProbingParallelepipedEstimator
 
 
  template <typename TPredicate, ProbingMode mode>
  std::ostream&
  operator<< ( std::ostream & out, const PlaneProbingParallelepipedEstimator<TPredicate, mode> & object );
 
} // namespace DGtal
 
 
// Includes inline functions.
#include "DGtal/geometry/surfaces/estimation/PlaneProbingParallelepipedEstimator.ih"
 
//                                                                           //
 
#endif // !defined PlaneProbingParallelepipedEstimator_h
 
#undef PlaneProbingParallelepipedEstimator_RECURSES
#endif // else defined(PlaneProbingParallelepipedEstimator_RECURSES)