objectRecognizer.hpp

/* $Id$ */

#ifndef _OBJECT_RECOGNIZER_HPP
#define _OBJECT_RECOGNIZER_HPP

#include "kernel/jafarException.hpp"
#include "kernel/csvFile.hpp"
#include "image/Image.hpp"
#include "image/iterator.hpp"
#include "jmath/jblas.hpp"
#include "premodeler/ifManager.hpp"
#include "premodeler/engine.hpp"
#include "gfm/GroupsMatcher.hpp"
#include "gfm/MatchingResult.hpp"
#include "gfm/DetectionResult.hpp"
#include "gfm/Detector.hpp"
#include "gfm/HarrisDetector.hpp"
#include "gfm/HarrisDescriptor.hpp"
#include "gfm/DoubleDescriptor.hpp"
#include "sift/SiftDetector.hpp"
#include "surf/SurfDetector.hpp"
#include "geom/Declarations.hpp"
#include "geom/Point.hpp"

namespace jafar {
  
  namespace oracle {
    const double ORACLE_RECOGNITION_THRESHOLD = 0.4;
    class ObjectRecognizer {

      /*
       * private attributes and methodes 
       */
      private:
      premodeler::SequenceMR smr;
      image::Image reqImg;
      std::string reqImgFileName;
      gfm::Detector *m_detector;
      gfm::GroupsMatcher* m_matcher;
      gfm::DetectionResult reqDetectResult;
      gfm::MatchSourceInfo* reqSourceInfo;
      struct ltMRst {
        bool operator()(const gfm::MatchingResult mr1, 
                        const gfm::MatchingResult mr2) const
        {
          return (mr1.matches().size() > mr2.matches().size());
        }
      };  
      std::map<gfm::MatchingResult, int, ltMRst> mrMap;

      public:
       ObjectRecognizer() { m_matcher = new gfm::GroupsMatcher(); };
      ObjectRecognizer(gfm::Detector* _detector,
                       gfm::GroupsMatcher* _matcher,
                       premodeler::SequenceMR _smr);
      ~ObjectRecognizer();
      void setRequestImage(const image::Image& _reqImg);
      void setRequestImage(const std::string& _reqImgFileName);
      void setDetector(gfm::Detector* _detector) {
        m_detector = _detector;
      }
      void setMatcher(gfm::GroupsMatcher* _matcher) {
        m_matcher = _matcher;
      }
      void setSequenceMatchingResult(const premodeler::SequenceMR& _smr){
        smr = _smr;
      }
      void process();
      std::map<int, jblas::vec2> detectedFeatures();
      std::map<int, geom::Point2D> detected2DPoints();
      inline image::Image requestImage() const {
        return reqImg;
      }
      inline std::string requestImageFileName() const {
        return reqImgFileName;
      }
      void setDetectionResult(const gfm::DetectionResult& _reqDetectionResult);
      inline gfm::DetectionResult detectionResult() const {
        return reqDetectResult;
      }
      int getBestView() const;
      gfm::vMatches getBestMatchesVector() const;
      double bestMatchingRatio() const;
      inline gfm::MatchingResult bestMatchingResult() const {
        return mrMap.begin()->first;
      }
      void mergeImages(const std::string& mergedImageName = "/home/nksallem/Desktop/merge.ppm");

      protected:
      int nextViewToProceed();
    };//class ObjectRecognizer

  }//namespace oracle

}//namespace jafar

#endif