Engine.hpp

/* $Id$ */
#ifndef _GFM_ENGINE_HPP_
#define _GFM_ENGINE_HPP_

#include <boost/serialization/nvp.hpp>
#include <boost/serialization/utility.hpp>
#include <boost/serialization/version.hpp>
#include <boost/noncopyable.hpp>

#include "image/Image.hpp"
#include "fdetect/Detector.hpp"
#include "fdetect/Descriptor.hpp"
#include "gfm/Matcher.hpp"
#include "gfm/MatchingResult.hpp"


namespace jafar {
  namespace gfm {
    //    class DescriptorFactory;
    //    class Detector;
    //    class Matcher;
    //    class MatchingResult;
    class Engine: public boost::noncopyable {
      public:
        Engine(jafar::fdetect::Detector* detector, jafar::gfm::Matcher* matcher, jafar::fdetect::Detector* snddetector/*, jafar::gfm::DescriptorFactory* descriptor = 0*/)
        : m_detector(detector), m_snddetector(snddetector ? snddetector : detector), m_descriptorFactory(0 /*descriptor*/), m_matcher(matcher)
        { }
        ~Engine();
      public:
        jafar::gfm::MatchingResult computeMatch(jafar::image::Image const& image_ref, jafar::image::Image const& image_match );
      private:
        fdetect::Detector* m_detector, *m_snddetector;
        fdetect::DescriptorFactory* m_descriptorFactory;
        Matcher* m_matcher;
      friend class boost::serialization::access;
      template<class Archive>
      void serialize(Archive &ar, const unsigned int version)
      {
        ar & BOOST_SERIALIZATION_NVP(m_detector);
        ar & BOOST_SERIALIZATION_NVP(m_snddetector);
        ar & BOOST_SERIALIZATION_NVP(m_matcher);
      }

    };
  }

  namespace gfm_v2 {
    template<typename InterestFeatureT>
    class Engine: public boost::noncopyable {
      public:
      Engine(jafar::fdetect_v2::Detector<InterestFeatureT>* detector, 
             jafar::gfm_v2::Matcher<InterestFeatureT>* matcher, 
             jafar::fdetect_v2::Detector<InterestFeatureT>* snddetector
             /*, jafar::gfm::DescriptorFactory* descriptor = 0*/)
        : m_detector(detector), 
          m_snddetector(snddetector ? snddetector : detector), 
          m_descriptorFactory(0 /*descriptor*/), 
          m_matcher(matcher)
        { }
      ~Engine()
      {
        JFR_DEBUG("delete Engine()");
        if(m_snddetector != m_detector)
          delete m_snddetector;
        delete m_detector;
        if(m_descriptorFactory)
          delete m_descriptorFactory;
        delete m_matcher;
      }
      public:
      MatchingResult<InterestFeatureT> computeMatch(jafar::image::Image const& image_ref, 
                                              jafar::image::Image const& image_match )
      {
        using namespace fdetect_v2;
        DetectionResult<InterestFeatureT> points_ref = m_detector->detectIn(image_ref) ;
        DetectionResult<InterestFeatureT> points_match = m_snddetector->detectIn(image_match);
        if(m_descriptorFactory)
        {
          m_descriptorFactory->createDescriptor(points_ref, image_ref);
          m_descriptorFactory->createDescriptor(points_match, image_match);
        }
        MatchSourceInfo<InterestFeatureT>* inforef = m_matcher->initMatchSourceInfo(points_ref);
        MatchSourceInfo<InterestFeatureT>* infosource = m_matcher->initMatchSourceInfo(points_match);
        MatchingResult<InterestFeatureT> result = m_matcher->computeMatch(inforef, infosource);
        delete inforef;
        delete infosource;
        JFR_DEBUG("Found " << result.matches().size() << " matches");
        return result;
      }

      private:
      fdetect_v2::Detector<InterestFeatureT>* m_detector, *m_snddetector;
      fdetect_v2::DescriptorFactory<InterestFeatureT>* m_descriptorFactory;
      Matcher<InterestFeatureT>* m_matcher;
      friend class boost::serialization::access;
      template<class Archive>
      void serialize(Archive &ar, const unsigned int version)
      {
        ar & BOOST_SERIALIZATION_NVP(m_detector);
        ar & BOOST_SERIALIZATION_NVP(m_snddetector);
        ar & BOOST_SERIALIZATION_NVP(m_matcher);
      }
    };
  }
}

#endif