PlaneProbingDigitalSurfaceLocalEstimator.h

 
#pragma once
 
#if defined(PlaneProbingDigitalSurfaceLocalEstimator_RECURSES)
#error Recursive header files inclusion detected in PlaneProbingDigitalSurfaceLocalEstimator.h
#else // defined(PlaneProbingDigitalSurfaceLocalEstimator_RECURSES)
#define PlaneProbingDigitalSurfaceLocalEstimator_RECURSES
 
#if !defined PlaneProbingDigitalSurfaceLocalEstimator_h
#define PlaneProbingDigitalSurfaceLocalEstimator_h
 
// Inclusions
#include <iostream>
#include <unordered_map>
#include "DGtal/base/Common.h"
#include "DGtal/geometry/surfaces/DigitalSurfacePredicate.h"
#include "DGtal/geometry/surfaces/estimation/MaximalSegmentSliceEstimation.h"
#include "DGtal/topology/KhalimskyCellHashFunctions.h"
#include "DGtal/topology/CDigitalSurfaceContainer.h"
 
namespace DGtal
{
 
  // template class PlaneProbingDigitalSurfaceLocalEstimator
  template <typename TSurface, typename TInternalProbingAlgorithm>
  class PlaneProbingDigitalSurfaceLocalEstimator
  {
    BOOST_CONCEPT_ASSERT(( concepts::CDigitalSurfaceContainer<typename TSurface::DigitalSurfaceContainer> ));
 
    // ----------------------- Public types ------------------------------
  public:
      using Surface                  = TSurface;
      using InternalProbingAlgorithm = TInternalProbingAlgorithm;
      using Point                    = typename InternalProbingAlgorithm::Point;
      using Scalar                   = double;
 
      struct ProbingFrame
      {
          Point p; 
          Point b1; 
          Point b2; 
          Point normal; 
          ProbingFrame rotatedCopy () const
          {
              Point newP      = p + b1,
                    newB1     = b2,
                    newB2     = -b1,
                    newNormal = newB1.crossProduct(newB2);
 
              return  { newP, newB1, newB2, newNormal };
          }
 
          Point shift () const
          {
              return b1 + b2 + normal;
          }
      };
 
      using Predicate               = DigitalSurfacePredicate<Surface>;
      using ProbingFactory          = std::function<InternalProbingAlgorithm*(const ProbingFrame&, Predicate const&)>;
      using PreEstimation           = MaximalSegmentSliceEstimation<Surface>;
      using PointOnProbingRay       = typename InternalProbingAlgorithm::PointOnProbingRay;
 
      // ----------------------- model of CDigitalSurfaceLocalEstimator ----------------
      using Surfel   = typename Surface::Surfel;
      using Quantity = typename InternalProbingAlgorithm::Quantity;
 
      // -------------------------------------- other types ----------------------------
      using KSpace    = typename Surface::KSpace;
      using SCell     = typename KSpace::SCell;
      using Cell      = typename KSpace::Cell;
      using Space     = typename KSpace::Space;
      using RealPoint = typename Space::RealPoint;
 
    // ----------------------- Standard services ------------------------------
  public:
    PlaneProbingDigitalSurfaceLocalEstimator();
 
    /*
     * Constructor.
     *
     * @param aSurface a digital surface.
     */
    PlaneProbingDigitalSurfaceLocalEstimator(ConstAlias<Surface> aSurface);
 
    /*
     * Constructor.
     *
     * @param aProbingFactory functor to produce a plane-probing estimator from a frame and a predicate.
     * @param aPreEstimations map of pre-estimated normal vectors (empty by default) to help choose the correct octant.
     * @param aVerbose a boolean indicating the level of verbosity.
     */
    PlaneProbingDigitalSurfaceLocalEstimator(ProbingFactory const& aProbingFactory,
                                             std::unordered_map<Surfel, RealPoint> const& aPreEstimations = {},
                                             bool aVerbose = false);
 
    /*
     * Constructor.
     *
     * @param aSurface a digital surface.
     * @param aProbingFactory functor to produce a plane-probing estimator from a frame and a predicate.
     * @param aPreEstimations map of pre-estimated normal vectors (empty by default) to help choose the correct octant.
     * @param aVerbose a boolean indicating the level of verbosity.
     */
    PlaneProbingDigitalSurfaceLocalEstimator(ConstAlias<Surface> aSurface,
                                             ProbingFactory const& aProbingFactory,
                                             std::unordered_map<Surfel, RealPoint> const& aPreEstimations = {},
                                             bool aVerbose = false);
 
    ~PlaneProbingDigitalSurfaceLocalEstimator();
 
    PlaneProbingDigitalSurfaceLocalEstimator ( const PlaneProbingDigitalSurfaceLocalEstimator & other );
 
    PlaneProbingDigitalSurfaceLocalEstimator ( PlaneProbingDigitalSurfaceLocalEstimator && other ) = delete;
 
    PlaneProbingDigitalSurfaceLocalEstimator & operator= ( const PlaneProbingDigitalSurfaceLocalEstimator & other );
 
    PlaneProbingDigitalSurfaceLocalEstimator & operator= ( PlaneProbingDigitalSurfaceLocalEstimator && other ) = delete;
 
    // ----------------- model of CSurfelLocalEstimator -----------------------
  public:
    template < typename SurfelConstIterator >
    void init (Scalar const& h, SurfelConstIterator itb, SurfelConstIterator ite);
 
    template < typename SurfelConstIterator >
    Quantity eval (SurfelConstIterator it);
 
    template < typename SurfelConstIterator, typename OutputIterator >
    OutputIterator eval (SurfelConstIterator itb, SurfelConstIterator ite, OutputIterator out);
 
    Scalar h () const;
 
    // --------------- model of CDigitalSurfaceLocalEstimator ------------------
  public:
    void attach (ConstAlias<Surface> aSurface);
 
    void setParams (ProbingFactory const& aProbingFactory,
                    std::unordered_map<Surfel, RealPoint> const& aPreEstimations = {},
                    bool aVerbose = false);
 
    // ----------------------- Interface --------------------------------------
  public:
 
    void selfDisplay ( std::ostream & out ) const;
 
    bool isValid() const;
 
    template < typename SurfelConstIterator >
    RealPoint getPreEstimation (SurfelConstIterator it) const;
 
    // ------------------------- Protected Datas ------------------------------
  protected:
 
    // ------------------------- Private Datas --------------------------------
  private:
    InternalProbingAlgorithm* myProbingAlgorithm = nullptr; 
    Scalar myH; 
    CountedConstPtrOrConstPtr<Surface> mySurface; 
    Predicate myPredicate; 
    PreEstimation myPreEstimationEstimator; 
    ProbingFactory myProbingFactory; 
    mutable std::unordered_map<Surfel, RealPoint> myPreEstimations; 
    bool myVerbose; 
    // ------------------------- Hidden services ------------------------------
  protected:
 
    // ------------------------- Internals ------------------------------------
  private:
    ProbingFrame probingFrameFromSurfel (Surfel const& aSurfel) const;
 
    std::pair<bool, ProbingFrame> probingFrameWithPreEstimation (ProbingFrame const& aInitialFrame, RealPoint const& aPreEstimation) const;
 
    static int signComponent (double x)
    {
        return (x >= 0) ? 1 : -1;
    }
 
    static std::vector<int> findZeros (RealPoint const& p)
    {
        std::vector<int> zeros;
 
        for (int i = 0; i < 3; ++i)
        {
            if (p[i] == 0)
            {
                zeros.push_back(i);
            }
        }
 
        return zeros;
    }
 
    static std::vector<PointOnProbingRay> getProbingRaysOneFlatDirection (int aIndex)
    {
        if (aIndex == 0)
        {
            return { PointOnProbingRay({ 2, 1, 0 }), PointOnProbingRay({ 1, 2, 0 }) };
        }
        else if (aIndex == 1)
        {
            return { PointOnProbingRay({ 0, 2, 1 }), PointOnProbingRay({ 2, 0, 1 }) };
        }
        else
        {
            ASSERT(aIndex == 2);
            return { PointOnProbingRay({ 1, 0, 2 }), PointOnProbingRay({ 0, 1, 2 }) };
        }
    }
 
    Point getNormalOneFlatDirection (int aIndex) const
    {
        int im1 = (aIndex - 1 + 3) % 3,
            im2 = (aIndex - 2 + 3) % 3;
 
        return myProbingAlgorithm->m(im1).crossProduct(myProbingAlgorithm->m(aIndex)) +
            myProbingAlgorithm->m(aIndex).crossProduct(myProbingAlgorithm->m(im2));
    }
  }; // end of class PlaneProbingDigitalSurfaceLocalEstimator
 
 
  template < typename TSurface, typename TInternalProbingAlgorithm >
  std::ostream&
  operator<< ( std::ostream & out, const PlaneProbingDigitalSurfaceLocalEstimator<TSurface, TInternalProbingAlgorithm> & object );
 
} // namespace DGtal
 
 
// Includes inline functions.
#include "DGtal/geometry/surfaces/estimation/PlaneProbingDigitalSurfaceLocalEstimator.ih"
 
//                                                                           //
 
#endif // !defined PlaneProbingDigitalSurfaceLocalEstimator_h
 
#undef PlaneProbingDigitalSurfaceLocalEstimator_RECURSES
#endif // else defined(PlaneProbingDigitalSurfaceLocalEstimator_RECURSES)