DescriptorsBasedMatcher.hpp

#ifndef GFM_DESCRIPTORS_BASED_MATCHER_HPP
#define GFM_DESCRIPTORS_BASED_MATCHER_HPP
#include "gfm/Matcher.hpp"
#include "gfm/MatchingResult.hpp"
#include "fdetect/InterestFeature.hpp"
#include "fdetect/DetectionResult.hpp"
#include "jmath/jann.hpp"
#include "jmath/ublasExtra.hpp"
#include <opencv2/core/core.hpp>

namespace jafar {
  namespace gfm_v2 {
    template<typename InterestFeatureT>
    class DescriptorsBasedMatcher : public gfm_v2::Matcher<InterestFeatureT> {
    public:
      typedef typename InterestFeatureT::DescriptorType::RealType RealType;
      typedef DescriptorsBasedMatcher<InterestFeatureT> MatcherType;
      typedef fdetect_v2::DetectionResult<InterestFeatureT> DetectionResult;
      typedef gfm_v2::MatchingResult<InterestFeatureT> MatchingResult;
      typedef gfm_v2::MatchSourceInfo<InterestFeatureT> MatchSourceInfo;
    private:
      class DescriptorsMatchSourceInfo : public MatchSourceInfo {
      public:
        DescriptorsMatchSourceInfo(const fdetect_v2::DetectionResult<InterestFeatureT>& dr) : 
          MatchSourceInfo(dr) {
          JFR_ASSERT(dr.size() > 0, "detection result is empty")
            size_t descriptor_size = dr[0]->descriptor().size();
          JFR_ASSERT(descriptor_size > 0, "descriptors are empty")
            m_descriptors.resize(dr.size(), descriptor_size);
          size_t i, j;
          for(i = 0; i < dr.size(); i++)
            for(j = 0; j < descriptor_size; j++)
              m_descriptors(i,j) = dr[i]->descriptor().m_descr[j];
        }
        ~DescriptorsMatchSourceInfo() {}
        virtual void reinit() { m_descriptors.clear(); }
        size_t size() const { return this->points().size(); }
        const InterestFeatureT* operator[](int nindex) const { 
          return this->points()[index];
        }
        ublas::matrix< RealType > m_descriptors;
      };
      struct similar_feature{
        const InterestFeatureT* feature;
        RealType distance;
        similar_feature(const InterestFeatureT* _feature, 
                        RealType _distance) : 
          feature(_feature), distance(_distance) {}
        similar_feature(): feature(0), distance(0) {}
      };
      struct matched_feature{
        const InterestFeatureT* observed;
        std::vector<similar_feature> candidates;
        matched_feature(): observed(0), candidates(0) {}
      };

    public:
      virtual MatchSourceInfo* initMatchSourceInfo(fdetect_v2::DetectionResult<InterestFeatureT>& pointsource )
      {
        return new MatcherType::DescriptorsMatchSourceInfo(pointsource);
      }

      virtual gfm_v2::MatchingResult<InterestFeatureT> computeMatch( 
        gfm_v2::MatchSourceInfo<InterestFeatureT>* refsourceinfo, 
        gfm_v2::MatchSourceInfo<InterestFeatureT>* matchsourceinfo);

      DescriptorsBasedMatcher(int knn = 2,
                              int checks = 20,
                              RealType threshold = 0.8,
                              bool enforce = false,
                              RealType increment = 1.5,
                              int bins = 20) : 
        m_knn(knn), m_checks(checks), m_uniquess_threshold(threshold),
        m_enforce(enforce), m_increment(increment), m_bins(bins) {}

      static void vote_size_orientation(gfm_v2::MatchingResult<InterestFeatureT> &mr, 
                                        RealType scale_increment = 1.5, 
                                        int rotation_bins = 20);
      RealType distance(unsigned int matched_index)
      {
        typename std::map<unsigned int,RealType>::iterator dist_it;
        dist_it = m_distances.find(matched_index);
        JFR_ASSERT(dist_it != m_distances.end(),
                   "no matched feature with index "<<matched_index<<" found");
        return dist_it->second;
      }
      
    private:
      int m_knn;
      int m_checks;
      RealType m_uniquess_threshold;
      bool m_enforce;
      RealType m_increment;
      int m_bins;
      std::map<unsigned int,RealType> m_distances;
      void brute_force( gfm_v2::MatchSourceInfo<InterestFeatureT>* refsourceinfo, 
                        gfm_v2::MatchSourceInfo<InterestFeatureT>* matchsourceinfo,
                        std::vector<matched_feature>& matches,
                        int knn,
                        int checks);
      std::vector<matched_feature> 
      vote_oneness(std::vector<matched_feature>& matches, RealType threshold);
    };
    
    // typedef DescriptorsBasedMatcher<fdetect_v2::RealDescriptor<float> > 
    // FloatDescriptorsMatcher;
    // typedef DescriptorsBasedMatcher<fdetect_v2::RealDescriptor<double> > 
    // DoubleDescriptorsMatcher;
  }
}
#include "gfm/DescriptorsBasedMatcher.hxx"
#endif