EngineOfflineTracking.hpp

/* $Id$ */

#ifndef _GFM_ENGINEOFFLINETRACKING_HPP_
#define _GFM_ENGINEOFFLINETRACKING_HPP_

#include <fstream>
#include <image/Image.hpp>

#include "fdetect/InterestFeature.hpp"
#include "fdetect/DetectionResult.hpp"
#include "fdetect/Detector.hpp"
#include "fdetect/Descriptor.hpp"
#include "gfm/Matcher.hpp"
#include "gfm/MatchingResult.hpp"

namespace jafar {
  
  namespace gfm {

    class MatchSourceInfo;
    class DescriptorFactory;
    class Detector;
    class Matcher;
    class MatchingResult;
    
    class EngineOfflineTracking {

    public:
      
      EngineOfflineTracking(jafar::fdetect::Detector* detector, 
          jafar::gfm::Matcher* matcher, 
          jafar::fdetect::DescriptorFactory* descriptor = 0) : 
  nextId(1),
  m_detector(detector), 
  m_descriptorFactory(descriptor), 
  m_matcher(matcher), 
  m_sourceInfoRef(0),
  optFeatureIdForSequenceTracking(false)
      { }
      
      ~EngineOfflineTracking();
      
    public:
      
      const jafar::fdetect::DetectionResult& currentPoints() const;

      void initTracking(jafar::image::Image const& image_ref );

      MatchingResult nextImage(jafar::image::Image const& image_next, unsigned int indView);
      
      void setOptFeatureIdForSequenceTracking(bool val)
      {
  optFeatureIdForSequenceTracking = val;
      }
      
    protected:
      
      inline MatchSourceInfo* sourceInfoRef() const { return m_sourceInfoRef; }
      inline Matcher* matcher() { return m_matcher; }
      inline fdetect::DescriptorFactory* descriptorFactory() { return m_descriptorFactory; }
      inline fdetect::Detector* detector() { return m_detector; }
    
    private:
      
      unsigned int nextId; 
      fdetect::Detector* m_detector;
      fdetect::DescriptorFactory* m_descriptorFactory;
      Matcher* m_matcher;
      MatchSourceInfo* m_sourceInfoRef;
      
      bool optFeatureIdForSequenceTracking;
    };
    
  }
}

#endif