matching.hpp

/* $Id$ */

#ifndef SAMS_MATCHER_HPP
#define SAMS_MATCHER_HPP

#include "jafarConfig.h"

#include <functional>
#include <algorithm>
#include <vector>
#include "sams/frame.hpp"
#include "sams/model.hpp"

namespace jafar {
  namespace sams { 

    class Match {
    public:
      ViewPartLink * modelRef;
      Feature * frameRef;       
      bool valid;
      Match(ViewPartLink * mref_=0, Feature * fref_=0, double valid_=false) :
      modelRef(mref_), frameRef(fref_), valid(valid_) {};

      bool operator== (Match const & mi_) const {
        return ( modelRef == mi_.modelRef );
      };

      inline static std::vector<Match> extractByView(std::vector<Match> const & m_, int id_) {
        std::vector<Match> m4v;
        for(std::vector<Match>::const_iterator it=m_.begin(); it!=m_.end(); it++) {
          if ( it->modelRef->view()->id() == id_)
            m4v.push_back(*it);
        }
        return m4v;
      };

      inline static ViewPartLink *  getMatch(std::vector<Match> const & m_, Feature * const fref_) {
        checkFeature cf(fref_);
        std::vector<Match>::const_iterator found = std::find_if(m_.begin(),m_.end(),cf);
        return ( found == m_.end() ? NULL : ( found->valid == true ? found->modelRef : NULL ) ); 
      };

    private:
      struct checkFeature :
      std::unary_function<Match& , bool> {
        Feature * f;
        checkFeature(Feature * f_) : f(f_) {};
        bool operator() (Match const & y_) const {
          return ( f == y_.frameRef );
        };
      };
    };      


    class Matcher {
    public:
      virtual ~Matcher() {};
      virtual int operator() (jafar::sams::Model const & md_,
        jafar::sams::Frame const & f_,
        std::vector<Match> & mt_) const = 0;
    };

    class SNNMatcher : public jafar::sams::Matcher {
    public:
      virtual ~SNNMatcher () {};
      virtual int operator() (jafar::sams::Model const & md_,
        jafar::sams::Frame const & f_,
        std::vector<Match> & mt_) const ;

    };// class SNNMatcher


#ifdef HAVE_BOOST_SANDBOX
#ifdef HAVE_LAPACK


    class SVDMatcher : public jafar::sams::Matcher {
    public:
      virtual ~SVDMatcher () {};

      virtual int operator() (const jafar::sams::Model& md_,
        const jafar::sams::Frame& f_,
        std::vector<Match> & mt_) const;

    }; // class SVDMatcher

#endif // HAVE_LAPACK
#endif // HAVE_BOOST_SANDBOX

  } // namespace sams
} // namespace jafar

#endif // SAMS_MATCHING_HPP