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;
    
    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 & operator= ( const LocalEstimatorFromSurfelFunctorAdapter & other )
    {
      mySurface = other.mySurface;
      myFunctor = other.myFunctor;
      myMetric = other.myMetric;
      myEmbedder = other.myEmbedder;
      myConvFunctor = other.myConvFunctor;
      return *this;
    }
    
    ~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;
 
    template< typename SurfelConstIterator, typename OutputIterator>
    OutputIterator eval(const SurfelConstIterator& itb,
                        const SurfelConstIterator& ite,
                        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
 
  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)