LocalEstimatorFromSurfelFunctorAdapter.h

 
#pragma once

 
#if defined(LocalEstimatorFromSurfelFunctorAdapter_RECURSES)
#error Recursive header files inclusion detected in LocalEstimatorFromSurfelFunctorAdapter.h
#else // defined(LocalEstimatorFromSurfelFunctorAdapter_RECURSES)
#define LocalEstimatorFromSurfelFunctorAdapter_RECURSES
 
#if !defined LocalEstimatorFromSurfelFunctorAdapter_h
#define LocalEstimatorFromSurfelFunctorAdapter_h

// Inclusions
#include <iostream>
#include <functional>
#include "DGtal/base/Common.h"
#include "DGtal/base/Alias.h"
#include "DGtal/base/ConstAlias.h"
#include "DGtal/base/CUnaryFunctor.h"
#include "DGtal/topology/CanonicSCellEmbedder.h"
#include "DGtal/topology/CSCellEmbedder.h"
#include "DGtal/topology/CDigitalSurfaceContainer.h"
#include "DGtal/topology/DigitalSurface.h"
#include "DGtal/graph/DistanceBreadthFirstVisitor.h"
#include "DGtal/geometry/volumes/distance/CMetricSpace.h"
#include "DGtal/base/BasicFunctors.h"
#include "DGtal/geometry/surfaces/estimation/estimationFunctors/CLocalEstimatorFromSurfelFunctor.h"
 
namespace DGtal
{

  // template class LocalEstimatorFromSurfelFunctorAdapter
  template <typename TDigitalSurfaceContainer, typename TMetric, 
            typename TFunctorOnSurfel, typename TConvolutionFunctor>
  class LocalEstimatorFromSurfelFunctorAdapter
  {
    // ----------------------- Standard services ------------------------------
  public:

    BOOST_CONCEPT_ASSERT(( concepts::CMetricSpace<TMetric>));
    BOOST_CONCEPT_ASSERT(( concepts::CLocalEstimatorFromSurfelFunctor<TFunctorOnSurfel>));
    BOOST_CONCEPT_ASSERT(( concepts::CUnaryFunctor<TConvolutionFunctor,double,double> ));
    BOOST_CONCEPT_ASSERT(( concepts::CDigitalSurfaceContainer<TDigitalSurfaceContainer> ));

    typedef TDigitalSurfaceContainer DigitalSurfaceContainer;

    typedef TMetric Metric;

    typedef typename Metric::Value Value;

    typedef typename Metric::Point Point;
    BOOST_STATIC_ASSERT(( concepts::ConceptUtils::SameType<typename Point::Component,double>::value ));

    typedef TFunctorOnSurfel FunctorOnSurfel;

    typedef TConvolutionFunctor ConvolutionFunctor;

    typedef typename TFunctorOnSurfel::Quantity Quantity;

    typedef double Scalar;

    typedef DigitalSurface< DigitalSurfaceContainer > Surface;

    typedef typename DigitalSurfaceContainer::Surfel Surfel;
 
    
    
  private:

    typedef typename FunctorOnSurfel::SCellEmbedder Embedder;
    typedef typename Embedder::RealPoint            RealPoint;
    typedef std::function< Value ( Point ) > MetricToPoint;
    typedef functors::Composer<Embedder, MetricToPoint, Value> VertexFunctor;
    typedef DistanceBreadthFirstVisitor< Surface, 
                                         VertexFunctor> Visitor;
 
 
  public:

    LocalEstimatorFromSurfelFunctorAdapter ();

    LocalEstimatorFromSurfelFunctorAdapter
    ( ConstAlias< Surface >  aSurface,
      ConstAlias<TMetric> aMetric,
      Alias<FunctorOnSurfel>  aFunctor,
      ConstAlias<ConvolutionFunctor> aConvolutionFunctor );

    LocalEstimatorFromSurfelFunctorAdapter ( const LocalEstimatorFromSurfelFunctorAdapter & other ):
      mySurface(other.mySurface), myFunctor(other.myFunctor), myMetric(other.myMetric),
      myEmbedder(other.myEmbedder), myConvFunctor(other.myConvFunctor)
    {  }
    LocalEstimatorFromSurfelFunctorAdapter ( const LocalEstimatorFromSurfelFunctorAdapter & other ): {…}
    

    LocalEstimatorFromSurfelFunctorAdapter & operator= ( const LocalEstimatorFromSurfelFunctorAdapter & other )
    {
      mySurface = other.mySurface;
      myFunctor = other.myFunctor;
      myMetric = other.myMetric;
      myEmbedder = other.myEmbedder;
      myConvFunctor = other.myConvFunctor;
      return *this;
    }
    LocalEstimatorFromSurfelFunctorAdapter & operator= ( const LocalEstimatorFromSurfelFunctorAdapter & other ) {…}
    
    ~LocalEstimatorFromSurfelFunctorAdapter();
 
    // ----------------------- Interface --------------------------------------
  public:

    Scalar h() const;

    void attach( ConstAlias<Surface> aSurface );

    void setParams( ConstAlias<TMetric> aMetric,
                    Alias<FunctorOnSurfel>  aFunctor,
                    ConstAlias<ConvolutionFunctor> aConvolutionFunctor,
                    const Value radius);

    template<typename SurfelConstIterator>
    void init(const double _h, SurfelConstIterator itb, SurfelConstIterator ite);
 

    template< typename SurfelConstIterator>
    Quantity eval(const SurfelConstIterator& it) const;

    Quantity eval(const Surfel& scell) const;

    template< typename SurfelConstIterator, typename OutputIterator>
    OutputIterator eval(const SurfelConstIterator& itb,
                        const SurfelConstIterator& ite,
                        OutputIterator result) const;

    template<typename OutputIterator>
    OutputIterator evalAll(OutputIterator result) const;
 
 

    void selfDisplay ( std::ostream & out ) const;

    bool isValid() const;
 
    // ------------------------- Hidden services ------------------------------
 
  private:
 
 
    // ------------------------- Internals ------------------------------------
  private:

    CountedConstPtrOrConstPtr<Surface> mySurface;

    FunctorOnSurfel* myFunctor;

    CountedConstPtrOrConstPtr<Metric> myMetric;

    double myH;

    bool myInit;

    Embedder myEmbedder;

    CountedConstPtrOrConstPtr<ConvolutionFunctor> myConvFunctor;

    Value myRadius;
 
  }; // end of class LocalEstimatorFromSurfelFunctorAdapter
  class LocalEstimatorFromSurfelFunctorAdapter {…};

  template <typename TD, typename TV, typename TF, typename TC>
  std::ostream&
  operator<< ( std::ostream & out, const LocalEstimatorFromSurfelFunctorAdapter<TD,TV,TF,TC> & object );
} // namespace DGtal
 

// Includes inline functions.
#include "DGtal/geometry/surfaces/estimation//LocalEstimatorFromSurfelFunctorAdapter.ih"
 
//                                                                           //
 
#endif // !defined LocalEstimatorFromSurfelFunctorAdapter_h
 
#undef LocalEstimatorFromSurfelFunctorAdapter_RECURSES
#endif // else defined(LocalEstimatorFromSurfelFunctorAdapter_RECURSES)