engine.hpp

/* $Id$ */

#ifndef SAMS_ENGIN_HPP
#define SAMS_ENGIN_HPP

#include <iostream>
#include <string>
#include <vector>
#include "kernel/keyValueFile.hpp"
#include "jmath/jblas.hpp"
#include "jmath/ublasExtra.hpp"
#include "jmath/pca.hpp"
#include "sams/detector.hpp"
#include "sams/descriptor.hpp"
#include "sams/feature.hpp"
#include "sams/frame.hpp"
#include "sams/model.hpp"
#include "sams/matching.hpp"
#include "sams/hypothesis.hpp"
#include "sams/hough.hpp"
#include "sams/background.hpp"

namespace jafar {
  namespace sams {

    class Engine : public jafar::kernel::KeyValueFileSaveLoad {
    public:
    // attributes

      jafar::sams::SSDetector detector1;
      jafar::sams::DOGDetector detector2;
      jafar::sams::GIFTFactory descriptor;
      jafar::sams::SNNMatcher matcher;
      jafar::sams::ModelDB db;
      jafar::sams::BackgroundAnalysis backdb;

      Engine() : byDefault(true) {};

      Engine(const std::string& file_);


      inline void loadDetectorParams(const std::string& file_) {
        detector1.load(file_);
      }

      inline void saveDetectorParams(const std::string& file_) {
        detector1.save(file_);
      };


      inline void getFrame(const jafar::image::Image& src_, jafar::sams::Frame& f_) {
        f_.attachImage(src_);
        f_.generateFeatures(detector1);
        f_.generateFeatures(detector2);
        f_.generateDescriptors(descriptor);
      }; 

      inline jafar::sams::Hypothesis modelMatch(const jafar::sams::Model& md_, 
        const jafar::sams::Frame& f_,
      std::vector<Match> & m_) {
        matcher(md_,f_,m_);
        JFR_WARNING("found " << m_.size() << " matches");
        db.insert("test",&md_);
        JFR_DEBUG("m_pos.x: " << m_[0].modelRef->pos());
        jafar::sams::Hough hg;
        std::vector<jafar::sams::Hypothesis> res;
        res = hg.process(md_,f_,m_);
        Hypothesis::pruneByAff(m_,res);
        JFR_ASSERT( res.size() != 0, "No candidate");
        std::vector<jafar::sams::Hypothesis>::iterator it = std::max_element(res.begin(),res.end());
        JFR_DEBUG("best Hypothesis = " << std::distance(res.begin(),it) << " with weight " << it->m_wght << " and " << it->m_matches.size() << " matches");
        jafar::sams::Hypothesis hc = *it;
        JFR_ASSERT(hc.m_matches.size() > 3, "Engine::match: no match");
        hc.computeSimilarityTransform();
        hc.computeProbability();
        JFR_DEBUG("probabiliy = " << hc.m_p);
        return hc;
      };

      inline jafar::sams::Hypothesis match(const jafar::sams::Frame& md_, 
          const jafar::sams::Frame& f_,
          std::vector<Match> & m_) {
        Model model("generic",md_);
        matcher(model,f_,m_);
        JFR_WARNING("found " << m_.size() << " matches");
        db.insert("test",&model);
        JFR_DEBUG("m_pos.x: " << m_[0].modelRef->pos());
        jafar::sams::Hough hg;
        std::vector<jafar::sams::Hypothesis> res;
        res = hg.process(model,f_,m_);
        Hypothesis::pruneByAff(m_,res);
        JFR_ASSERT( res.size() != 0, "No candidate");
        std::vector<jafar::sams::Hypothesis>::iterator it = std::max_element(res.begin(),res.end());
        JFR_DEBUG("best Hypothesis = " << std::distance(res.begin(),it) << " with weight " << it->m_wght << " and " << it->m_matches.size() << " matches");
        jafar::sams::Hypothesis hc = *it;
        JFR_ASSERT(hc.m_matches.size() > 3, "Engine::match: no match");
        hc.computeSimilarityTransform();
        hc.computeProbability();
        JFR_DEBUG("probabiliy = " << hc.m_p);
        return hc;
      };

      double checking(std::string const & name_, 
        jafar::sams::Frame const & fr_,
        std::vector<Match> const & matches_,
        jafar::sams::Hypothesis const & hc_,
        jafar::sams::ModelDB const & db_) const;

      std::string learn(jafar::image::Image const & img, std::string const & label="");

      std::vector<jafar::sams::Hypothesis> recognize(jafar::sams::Frame const & f) const;

      void loadDB(std::string const & path_) {
        db.loadDB(path_);
      };

      void saveDB(std::string const & path_=".") const {
        db.saveDB(path_);
      };

    protected:
        void loadKeyValueFile(jafar::kernel::KeyValueFile const& keyValueFile);


        void saveKeyValueFile(jafar::kernel::KeyValueFile & keyValueFile);

    private:
      bool byDefault;
    };

  } // namespace sams
} // namespace jafar

#endif // SAMS_ENGIN_HPP