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 Data ------------------------------
  private:
    // ------------------------- Private Data --------------------------------
  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)