MaximalSegmentSliceEstimation.h

 
#pragma once
 
#if defined(MaximalSegmentSliceEstimation_RECURSES)
#error Recursive header files inclusion detected in MaximalSegmentSliceEstimation.h
#else // defined(MaximalSegmentSliceEstimation_RECURSES)
#define MaximalSegmentSliceEstimation_RECURSES
 
#if !defined MaximalSegmentSliceEstimation_h
#define MaximalSegmentSliceEstimation_h
 
// Inclusions
#include <iostream>
#include <vector>
#include "DGtal/base/Common.h"
#include "DGtal/geometry/surfaces/ArithmeticalDSSComputerOnSurfels.h"
#include "DGtal/topology/DigitalSurface2DSlice.h"
#include "DGtal/topology/CDigitalSurfaceContainer.h"
 
namespace DGtal
{
 
  // template class MaximalSegmentSliceEstimation
  template <typename TSurface>
  class MaximalSegmentSliceEstimation
  {
    BOOST_CONCEPT_ASSERT(( concepts::CDigitalSurfaceContainer<typename TSurface::DigitalSurfaceContainer> ));
 
    // ----------------------- Public types ------------------------------
  public:
      using Surface      = TSurface;
      using Tracker      = typename Surface::DigitalSurfaceTracker;
      using SurfaceSlice = DigitalSurface2DSlice<Tracker>;
      using Scalar       = double;
 
      // -------------------------------------- other types ----------------------------
      using KSpace     = typename Surface::KSpace;
      using SCell      = typename KSpace::SCell;
      using Cell       = typename KSpace::Cell;
      using Point      = typename Surface::Point;
      using Vector     = Point;
      using Integer    = typename Point::Coordinate;
      using Space      = typename KSpace::Space;
      using RealPoint  = typename Space::RealPoint;
      using RealVector = RealPoint;
 
      // ----------------------- model of CDigitalSurfaceLocalEstimator ----------------
      using Surfel   = typename Surface::Surfel;
      using Quantity = RealVector;
 
    // ----------------------- Private types ------------------------------
  private:
      using Point2      = PointVector<2, Integer>;
      using RealPoint2  = PointVector<2, double>;
      using Container   = std::deque<SCell>;
      using Iterator    = typename Container::const_iterator;
      using DSSComputer = ArithmeticalDSSComputerOnSurfels<KSpace, Circulator<Iterator>, Integer, 4>;
 
    // ----------------------- Standard services ------------------------------
  public:
    MaximalSegmentSliceEstimation();
 
    MaximalSegmentSliceEstimation(ConstAlias<Surface> aSurface);
 
    ~MaximalSegmentSliceEstimation();
 
    MaximalSegmentSliceEstimation ( const MaximalSegmentSliceEstimation & other );
 
    MaximalSegmentSliceEstimation & operator= ( const MaximalSegmentSliceEstimation & other );
 
    // ----------------- model of CSurfelLocalEstimator -----------------------
  public:
    template < typename SurfelConstIterator >
    void init (Scalar const& h, SurfelConstIterator itb, SurfelConstIterator ite);
 
    template < typename SurfelConstIterator >
    Quantity eval (SurfelConstIterator it) const;
 
    template < typename SurfelConstIterator, typename OutputIterator >
    OutputIterator eval (SurfelConstIterator itb, SurfelConstIterator ite, OutputIterator out) const;
 
    Scalar h () const;
 
    // --------------- model of CDigitalSurfaceLocalEstimator ------------------
  public:
    void attach (ConstAlias<Surface> aSurface);
 
    // ----------------------- Interface --------------------------------------
  public:
 
    void selfDisplay ( std::ostream & out ) const;
 
    bool isValid() const;
 
    // ------------------------- Protected Datas ------------------------------
  protected:
 
    // ------------------------- Private Datas --------------------------------
  private:
    CountedConstPtrOrConstPtr<Surface> mySurface; 
    Scalar myH; 
    // ------------------------- Hidden services ------------------------------
  protected:
 
    // ------------------------- Internals ------------------------------------
  private:
    KSpace const& space () const;
 
    std::pair<Point2, Point2> getExtremalPoints (SurfaceSlice const& aSlice,
                                                 Dimension const& aProjectDir1, Dimension const& aProjectDir2) const;
 
    Vector trivialNormal (Surfel const& aSurfel) const;
  }; // end of class MaximalSegmentSliceEstimation
 
 
  template <typename TSurface>
  std::ostream&
  operator<< ( std::ostream & out, const MaximalSegmentSliceEstimation<TSurface> & object );
 
} // namespace DGtal
 
 
// Includes inline functions.
#include "DGtal/geometry/surfaces/estimation/MaximalSegmentSliceEstimation.ih"
 
//                                                                           //
 
#endif // !defined MaximalSegmentSliceEstimation_h
 
#undef MaximalSegmentSliceEstimation_RECURSES
#endif // else defined(MaximalSegmentSliceEstimation_RECURSES)