EstimatorCache.h

 
#pragma once
 
#if defined(EstimatorCache_RECURSES)
#error Recursive header files inclusion detected in EstimatorCache.h
#else // defined(EstimatorCache_RECURSES)
#define EstimatorCache_RECURSES
 
#if !defined EstimatorCache_h
#define EstimatorCache_h
 
// Inclusions
#include <iostream>
#include <map>
#include "DGtal/base/Common.h"
#include "DGtal/base/Alias.h"
#include "DGtal/geometry/surfaces/estimation/CSurfelLocalEstimator.h"
 
namespace DGtal
{
  
  // template class EstimatorCache
  template <typename TEstimator,
            typename TContainer = std::map<typename TEstimator::Surfel,
                                           typename TEstimator::Quantity> >
  class EstimatorCache
  {
    // ----------------------- Standard services ------------------------------
  public:
    
    
    typedef TEstimator Estimator;
    BOOST_CONCEPT_ASSERT(( concepts::CSurfelLocalEstimator<TEstimator> ));
    
    typedef TContainer Container;
    BOOST_CONCEPT_ASSERT(( boost::PairAssociativeContainer<TContainer> ));
    
    //Concept of CSurfelLocalEstimator
    
    typedef typename Estimator::Surfel Surfel;
    
    typedef typename Estimator::Quantity Quantity;
    
    typedef EstimatorCache<Estimator,Container> Self;
 
    EstimatorCache(): myInit(false)
    {}
    
    EstimatorCache( Alias<Estimator> anEstimator): myEstimator(&anEstimator),
                                                   myInit(false)
    {}
    
    ~EstimatorCache()
    {}
    
    EstimatorCache(const Self &other): myContainer(other.myContainer),
                                       myEstimator(other.myEstimator),
                                       myInit(other.myInit)
    {}
   
    Self & operator= ( const Self & other )
    {
      myContainer = other.myContainer;
      myEstimator = other.myEstimator;
      myInit = other.myInit;
      
      return *this;
    }
    
    // ----------------------- CSurfelLocalEstimator Interface --------------------------------------
    
    template <typename SurfelConstIterator>
    void init(const double aH, SurfelConstIterator itb, SurfelConstIterator ite)
    {
      ASSERT(myEstimator);
      myEstimator->init(aH,itb,ite);
      myContainer.clear();
 
      //We estimate and store the quantities
      //(since SurfelConstIterator models are usually SinglePass, we
      //cannot use the optimized "range" eval on the estimator)
      for(SurfelConstIterator it = itb; it != ite; ++it)
        myContainer.insert( std::pair<Surfel, Quantity>(*it, myEstimator->eval(it) ) );
      
      myInit = true;
    }
    
    template <typename SurfelConstIterator>
    Quantity eval(const SurfelConstIterator it) const
    {
      ASSERT_MSG(myInit, " init() method must have been called first.");
      return myContainer.find( *it )->second;
    }
    
    Quantity eval(const Surfel s) const
    {
      ASSERT_MSG(myInit, " init() method must have been called first.");
      return myContainer.find( s )->second;
    }
    
    
    template <typename SurfelConstIterator,typename OutputIterator>
    OutputIterator eval(SurfelConstIterator itb,
                        SurfelConstIterator ite,
                        OutputIterator result ) const
    {
      ASSERT_MSG(myInit, " init() method must have been called first.");
      for(SurfelConstIterator it = itb; it != ite; ++it)
        *result++ = this->eval(it);
      
      return result;
    }
    
    double h() const
    {
      return myEstimator->h();
    }
    
    // ----------------------- Interface --------------------------------------
  public:
 
    typename Container::size_type size() const
    {
      ASSERT_MSG(myInit, " init() method must have been called first.");
      return myContainer.size();
    }
 
    void selfDisplay ( std::ostream & out ) const
    {
      out<< "[EstimatorCache] number of surfels="<<myContainer.size();
    }
    
    bool isValid() const
    {
      return myEstimator && myEstimator->isValid();
    }
    
    // ------------------------- Protected Datas ------------------------------
  private:
    // ------------------------- Private Datas --------------------------------
  private:
    
    
    Container myContainer;
    
    Estimator *myEstimator;
 
    bool myInit;
    
    // ------------------------- Internals ------------------------------------
  private:
    
  }; // end of class EstimatorCache
  
  
  template <typename T, typename TC>
  std::ostream&
  operator<< ( std::ostream & out, const EstimatorCache<T,TC> & object )
  {
    object.selfDisplay( out );
    return out;
  }
  
} // namespace DGtal
//                                                                           //
 
#endif // !defined EstimatorCache_h
 
#undef EstimatorCache_RECURSES
#endif // else defined(EstimatorCache_RECURSES)