learner.hpp

/* $Id$ */

#ifndef _LEARNER_HPP
#define _LEARNER_HPP

#include "kernel/jafarException.hpp"
#include "fdetect/InterestFeature.hpp"
#include "gfm/MatchingResult.hpp"
#include "fdetect/Detector.hpp"
#include "premodeler/engine.hpp"
#include "premodeler/ifManager.hpp"
#include "kernel/csvFile.hpp"
#include "jmath/jblas.hpp"

namespace jafar {
  
  namespace premodeler {

    class Learner : public kernel::CSVFileSave {

      private:
      gfm::GroupsMatcher* m_matcher;
      fdetect::Detector* m_detector;
      premodeler::IFLists interestFeaturesLists;
      premodeler::Engine::DetectorType m_type;
      std::map<int, jblas::vec3> points;
      std::string detectorData(const std::string& separator);
      std::string matcherData(const std::string& separator);
      std::string featureData(fdetect::InterestFeature *ip,
                              const std::string& separator);
      
      jblas::vec3 bundled3dPoint(const int& id);

      protected:
      void saveCSVFile(kernel::CSVFile& csvFile);
      
      public:
      Learner() : kernel::CSVFileSave() {};
      Learner(const premodeler::Engine::DetectorType& _type,
              fdetect::Detector* _detector,
              gfm::GroupsMatcher* _matcher,
              const premodeler::IFLists& _ifLists,
              const std::map<int, jblas::vec3>& _points);
              
      Learner(const premodeler::Engine::DetectorType& _type,
              fdetect::Detector* _detector,
              gfm::GroupsMatcher* _matcher,
              const premodeler::IFLists& _ifLists);

//       /**constructor with parameters
//        * @parameter _engine premodeler engine used for the learning
//        * @parameter _manager premodeler interest features manager used
//        */
//       Learner(const premodeler::Engine& _engine,
//               const premodeler::IFManager& _manager);
      ~Learner();
      void setDetector(fdetect::Detector* _detector) {
        m_detector = _detector;
      }
      void setMatcher(gfm::GroupsMatcher* _matcher) {
        m_matcher = _matcher;
      }
      void setInterstFeaturesLists(const premodeler::IFLists& _ifLists){
        interestFeaturesLists = _ifLists;
      }
      void setBundledFeatures(const std::map<int, jblas::vec3>& _points){
        points = _points;
      }
      void setDetectorType(const Engine::DetectorType &_type);
      void setEngine(const premodeler::Engine& _engine);
      void setIFManager(const premodeler::IFManager& _manager);
//       /**
//        * @return sequence matching result
//        */
//       inline premodeler::Engine engine() {
//         return m_engine;
//       }
//       /**
//        * @return global sequence tracker
//        */
//       inline premodeler::IFManager manager() {
//         return m_manager;
//       }
      inline fdetect::Detector* detector() const {
        return m_detector;
      }
      inline gfm::GroupsMatcher* matcher() const {
        return m_matcher;
      }

    };//class Learner

  }//namespace premodeler

}//namespace jafar

#endif