hypothesis_filter.h

Go to the documentation of this file.

#ifndef MMVL_MIMAS_HYPOTHESIS_FILTER
#define MMVL_MIMAS_HYPOTHESIS_FILTER

#include <vector>
#include <cassert>
#include <cmath> 
#include <iostream>
#include <boost/shared_ptr.hpp>
#include <image.h>

#include "condensation.h"
#include "no_compensation.h"

using std::vector;
using std::cout;
using std::cerr;
using std::endl;
using boost::shared_ptr;

namespace mimas{
  namespace hf{
    typedef boost::numeric::ublas::vector<float> Point;


    template<typename Hypothesis_T, typename Pixel_T>
      class hypothesis_filter_data{
      public:
      image<Pixel_T> image;
      std::vector<Hypothesis_T > hypotheses;    
    };

    
    template <
      template <typename> class image_loader_P,
      template <typename, typename> class Observer_P,      //<provides double observe(Hypothesis_T h)
      template<typename, typename> class Analyse_result_T, //<provides analyse()
      typename Hypothesis_T,
      template <typename> class Picking_P = condensation,  
      template <typename> class Compensate_P = no_compensation,
      typename Pixel_T = unsigned char
      >
      class hypothesis_filter:
      public hypothesis_filter_data<Hypothesis_T, Pixel_T>, 
      public image_loader_P<Pixel_T>,
      public Observer_P<Hypothesis_T, Pixel_T>,
      public Analyse_result_T<Hypothesis_T, Pixel_T>,
      public Picking_P<Hypothesis_T>,
      public Compensate_P<Hypothesis_T>
      { 
  public:

  double max_weight(void);

  void track(void)
  {
    while(true){
      try{image_loader_P<Pixel_T>::next();}
      catch (mimasexception){return;}
      
      Hypothesis_T estimatedLocation;
      filter();
      estimatedLocation = Analyse_result_T<Hypothesis_T, Pixel_T>::analyse();
    
      std::cerr<<"estim: "
         <<estimatedLocation.x
         <<estimatedLocation.y
         <<std::endl;

      draw(estimatedLocation);                     //from Observer
      save_location(estimatedLocation);            //from Compensate policy 
    }
  }


  void reset(Hypothesis_T &init);
  
  void filter(void);
  
  hypothesis_filter(Hypothesis_T &initial,
        int n,
        typename image_loader_P<Pixel_T>::set il_param,
        typename Observer_P<Hypothesis_T, Pixel_T>::set obs_param, 
        typename Analyse_result_T<Hypothesis_T, Pixel_T>::set analyse_param)
  :image_loader_P<Pixel_T>(hypothesis_filter_data<Hypothesis_T, Pixel_T>::image,il_param),
  Observer_P<Hypothesis_T, Pixel_T>(hypothesis_filter_data<Hypothesis_T, Pixel_T>::image, obs_param),
  Analyse_result_T<Hypothesis_T, Pixel_T>(hypothesis_filter_data<Hypothesis_T, Pixel_T>::hypotheses, hypothesis_filter_data<Hypothesis_T, Pixel_T>::image, analyse_param),
  Picking_P<Hypothesis_T>(hypothesis_filter_data<Hypothesis_T, Pixel_T>::hypotheses),
  nb_hypothesis(n) 
  {
    for(int i = 0; i < n; ++i)
      hypothesis_filter_data<Hypothesis_T, Pixel_T>::hypotheses.push_back(initial.drift());
  };
  
  //if we don't have parameter to pass to the observer or the analyse policies we can simplify the instanciation of an hypothesis_filter class
  hypothesis_filter(Hypothesis_T &initial,
        int n,
        typename image_loader_P<Pixel_T>::set il_param)
  :image_loader_P<Pixel_T>(hypothesis_filter_data<Hypothesis_T, Pixel_T>::image,il_param),
  Observer_P<Hypothesis_T, Pixel_T>(hypothesis_filter_data<Hypothesis_T, Pixel_T>::image, typename Observer_P<Hypothesis_T, Pixel_T>::set()),
  Analyse_result_T<Hypothesis_T, Pixel_T>(hypothesis_filter_data<Hypothesis_T, Pixel_T>::hypotheses, hypothesis_filter_data<Hypothesis_T, Pixel_T>::image, typename Analyse_result_T<Hypothesis_T, Pixel_T>::set()),
  Picking_P<Hypothesis_T>(hypothesis_filter_data<Hypothesis_T, Pixel_T>::hypotheses),
  nb_hypothesis(n) 
  {
    for(int i = 0; i < n; ++i)
      hypothesis_filter_data<Hypothesis_T, Pixel_T>::hypotheses.push_back(initial.drift());
  };
  
  ~hypothesis_filter(){}
  protected:
  int nb_hypothesis;  

  private:  

  vector<Hypothesis_T> hypotheses_new;

  void reset_hypothesis(const Hypothesis_T & init);
  void update(void); 
      };

#include "hypothesis_filter.tcc"
  }
}
#endif



// !!!put some default parametre and typedef a few hypothesis tracker 




    

---