Matcher.hpp

/* $Id$ */

#ifndef _GFM_MATCHER_HPP_
#define _GFM_MATCHER_HPP_

#include "fdetect/InterestFeature.hpp"
#include "fdetect/DetectionResult.hpp"

namespace jafar {
  namespace gfm {
    class MatchingResult;

    class Matcher;
    class MatchSourceInfo {
      friend class Matcher;
    public:
      virtual ~MatchSourceInfo() { };
      virtual void reinit() { }
      inline const jafar::fdetect::DetectionResult& points() const { return m_points; }
      friend std::ostream& operator <<(std::ostream& s, const MatchSourceInfo& p_);
      
    protected:
      MatchSourceInfo( jafar::fdetect::DetectionResult points) : m_points(points) {}
    private:
      jafar::fdetect::DetectionResult m_points;
      friend class boost::serialization::access;
      template<class Archive>
      void serialize(Archive &ar, const unsigned int version)
      {
        ar & BOOST_SERIALIZATION_NVP(m_points);
      }
    };
    

    class Matcher {
      public:
        virtual ~Matcher() { };
        virtual MatchSourceInfo* initMatchSourceInfo( const jafar::fdetect::DetectionResult& pointsource )
        {
          return new MatchSourceInfo(pointsource);
        }
        virtual jafar::gfm::MatchingResult computeMatch( MatchSourceInfo* refsourceinfo, MatchSourceInfo* matchsourceinfo) =0;
    };
  }

  namespace gfm_v2 {
    template<typename D>
    class MatchingResult;
    template <typename D>
    class Matcher;
    template< typename InterestFeatureT >
    class MatchSourceInfo 
    {
      friend class gfm_v2::Matcher< InterestFeatureT >;
      public:
      typedef jafar::fdetect_v2::DetectionResult< InterestFeatureT > DetectionResult;
      virtual ~MatchSourceInfo() { };
      virtual void reinit() { }
      const DetectionResult& points() const 
      { 
        return m_points; 
      }
      friend std::ostream& operator <<(std::ostream& s, 
                                       const MatchSourceInfo<InterestFeatureT>& p_)
      {
        s << p_.points();
        return s;
      }

      protected:
      MatchSourceInfo(const DetectionResult& points) : 
        m_points(points) {}
      private:
      DetectionResult m_points;
      friend class boost::serialization::access;
      template<class Archive>
      void serialize(Archive &ar, const unsigned int version)
      {
        ar & BOOST_SERIALIZATION_NVP(m_points);
      }
    };


    template< typename InterestFeatureT >
    class Matcher 
    {
    public:
      // typedef jafar::fdetect_v2::DetectionResult< InterestFeatureT > DetectionResult;
      // typedef gfm_v2::MatchSourceInfo<InterestFeatureT> MatchSourceInfo;
      // typedef jafar::gfm_v2::MatchingResult<InterestFeatureT> MatchingResult;
      virtual ~Matcher() { };
      virtual MatchSourceInfo<InterestFeatureT>* 
      initMatchSourceInfo(const fdetect_v2::DetectionResult<InterestFeatureT>& pointsource)
      {
        return new MatchSourceInfo<InterestFeatureT>(pointsource);
      }
      virtual MatchingResult<InterestFeatureT> 
      computeMatch( MatchSourceInfo<InterestFeatureT>* refsourceinfo, 
                    MatchSourceInfo<InterestFeatureT>* matchsourceinfo) =0;
    };
  }
}

#endif