engine.hpp

/* $Id$ */

#ifndef _ENGINE_HPP
#define _ENGINE_HPP

#include "kernel/jafarException.hpp"
#include "kernel/jafarMacro.hpp"
#include "image/Image.hpp"
#include "gfm/GroupsMatcher.hpp"
#include "gfm/MatchingResult.hpp"
#include "gfm/EngineTracking.hpp"
#include "fdetect/Detector.hpp"
#include "fdetect/DetectionResult.hpp"
#include "premodeler/premodelerException.hpp"

namespace jafar {
  
  namespace premodeler {

    struct ViewMR {
      ViewMR():
        vIndex(-1), vMatchingResult()
      {
      }
      ViewMR(int _vIndex, 
             gfm::MatchingResult _vMatchingResult) :
        vIndex(_vIndex), vMatchingResult(_vMatchingResult)
      {
      }
      int vIndex;
      gfm::MatchingResult vMatchingResult;
    };

    typedef std::vector<premodeler::ViewMR*> SequenceMR;
    typedef SequenceMR::iterator smrIterator;
    class Engine {
      public :
      enum DetectorType {
        HARRIS,
        SIFT,
        SURF
      };//DetectorType
      /*
       * private attributes and methodes 
       */
      protected:
      DetectorType m_type;
      fdetect::Detector *m_detector;
      gfm::GroupsMatcher* m_matcher;
      gfm::EngineTracking* m_tracker;
      premodeler::SequenceMR smr;
      bool isInitialised;
      unsigned int m_GlobalId;
      protected:
      fdetect::DetectionResult processImage(const image::Image& image);

      public:
      Engine();
      Engine(const Engine::DetectorType& _type);
      ~Engine();
      void setDetectorType(const Engine::DetectorType& _type);
      void init(const image::Image& start);
      void process(const image::Image& next, const int& nextId);
      void print();
      std::vector<unsigned int> detectedFeaturesInImage(const int& imageIndex);
      inline gfm::EngineTracking* tracker() const {
        return m_tracker;
      }
      inline fdetect::Detector* detector() const {
        return m_detector;
      }
      inline SequenceMR result() const {
        return smr;
      }
      inline DetectorType type() const {
        return m_type;
      }
      inline gfm::GroupsMatcher* matcher() const {
        return m_matcher;
      }

    }; //class Engine

  } //namespace premodeler

}//namespace jafar

#endif