SimpleMatcher.hpp

/* $Id$ */

#ifndef _GFM_SIMPLEMATCH_HPP_
#define _GFM_SIMPLEMATCH_HPP_

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

#include "gfm/Matcher.hpp"
#include "kernel/jafarMacro.hpp"
namespace jafar {
  namespace gfm {
    class SimpleMatcher : public Matcher {
    public:
      SimpleMatcher(double good_match_threshold, int search_win_half_width, int search_win_half_height);
    public:
      virtual jafar::gfm::MatchingResult computeMatch( MatchSourceInfo* refsourceinfo, MatchSourceInfo* matchsourceinfo);
    private:
      fdetect::InterestFeature* testFor(fdetect::InterestFeature* ip, 
                                        fdetect::DetectionResult& points);
    private:
      double m_zncc_threshold;
      int m_search_win_half_width, m_search_win_half_height;
      friend class boost::serialization::access;
      template<class Archive>
      void serialize(Archive &ar, const unsigned int version)
      {
        ar & BOOST_SERIALIZATION_NVP(m_zncc_threshold);
        ar & BOOST_SERIALIZATION_NVP(m_search_win_half_width);
        ar & BOOST_SERIALIZATION_NVP(m_search_win_half_height);
      }
    };
  }

  namespace gfm_v2 {
    template<typename InterestFeatureT>
    class SimpleMatcher : public Matcher<InterestFeatureT> 
    {
    public:
      typedef jafar::fdetect_v2::DetectionResult< InterestFeatureT > DetectionResult;
      typedef gfm_v2::MatchSourceInfo<InterestFeatureT> MatchSourceInfo;
      typedef jafar::gfm_v2::MatchingResult<InterestFeatureT> MatchingResult;

      SimpleMatcher(double good_match_threshold, 
                    int search_win_half_width, 
                    int search_win_half_height) : 
        m_zncc_threshold(good_match_threshold), 
        m_search_win_half_width(search_win_half_width), 
        m_search_win_half_height(search_win_half_height) { }
    public:
      virtual MatchingResult computeMatch( MatchSourceInfo* refsourceinfo, 
                                           MatchSourceInfo* matchsourceinfo)
      {
        using namespace fdetect_v2;
        DetectionResult points_ref = refsourceinfo->points();
        DetectionResult points_match = matchsourceinfo->points();
        
        MatchingResult result(points_ref, points_match);
        int eliminated = 0;
        for(typename DetectionResult::const_iterator it=points_ref.begin(); 
            it != points_ref.end(); 
            ++it)
        {
          InterestFeatureT* ip = testFor( *it, points_match);
          if(ip)
          {
            InterestFeatureT* ret = testFor( ip, points_ref);
            if(ret == *it)
            {
              result.addMatch(*it, ip);
            } else {
              eliminated++;
            }
          }
        }
        JFR_DEBUG("Eliminated = " << eliminated);
        return result;
      }
      
    private:
      InterestFeatureT* testFor(InterestFeatureT* ip, 
                                DetectionResult& points)
      {
        using namespace fdetect_v2;
        float startu = ip->u() - m_search_win_half_width;
        float endu = ip->u() + m_search_win_half_width;
        float startv = ip->v() - m_search_win_half_height;
        float endv = ip->v() + m_search_win_half_height;
        
        double bestzncc = 0.;
        InterestFeatureT* bestpoint = 0;
        
        for(typename DetectionResult::const_iterator it = points.begin(); 
            it != points.end(); 
            ++it)
        {
          if( (*it)->u() > startu && (*it)->u() < endu && (*it)->v() > startv && (*it)->v() < endv)
          {
            double zncc = ((*it)->descriptor()).strongComparison(ip->descriptor(), 0.);
            if( zncc > m_zncc_threshold )
            {
              bestzncc = zncc;
              bestpoint = *it;
            }
          }
        }
        return bestpoint;
      }
      double m_zncc_threshold;
      int m_search_win_half_width, m_search_win_half_height;
      friend class boost::serialization::access;
      template<class Archive>
      void serialize(Archive &ar, const unsigned int version)
      {
        ar & BOOST_SERIALIZATION_NVP(m_zncc_threshold);
        ar & BOOST_SERIALIZATION_NVP(m_search_win_half_width);
        ar & BOOST_SERIALIZATION_NVP(m_search_win_half_height);
      }
    };
  }
}

#endif