detector.hpp

/* $Id$ */

#ifndef SAMS_DETECTOR_HPP
#define SAMS_DETECTOR_HPP

#include <vector>
#include <string>
#include "kernel/keyValueFile.hpp"
#include "image/Image.hpp"
#include "gfm/HarrisLaplaceDetector.hpp"
#include "sams/feature.hpp"

namespace jafar {
  namespace sams {

    class Detector : public jafar::kernel::KeyValueFileSaveLoad {
    public:
      virtual ~Detector() {};

        virtual void compute(const jafar::image::Image& src_, 
        std::vector< jafar::sams::Feature *>& fVec_) const =0;

    }; // class Detector

    class SSDetector : public Detector {
      public :
      SSDetector() : byDefault(true) {};

        SSDetector(const std::string& file_);

        SSDetector(bool harrisPreProc_,
        int startScale_,
        int stopScale_,
        int nbins_,
        double yt_,
        double wt_,
        bool fplogpFlag_,
        int fplogpprec_ = 10000);

      virtual ~SSDetector() {
      };


        virtual void compute(const jafar::image::Image& src_, 
        std::vector< jafar::sams::Feature *>& fVec_) const;


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

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

    private:
      bool byDefault;
      bool harrisPreProc;
      int startScale;
      int stopScale;
      int nbins;
      double yt;
      double wt;
      bool fplogpFlag;
      int fplogpprec;

      std::vector<double> fplogp;

      void do_CalcSalScale1D(const jafar::image::Image &Image_,
        std::vector<jafar::sams::Feature *> &fVec_) const; 

      void clusterize(std::vector<jafar::sams::Feature *>& features_,
        std::vector<jafar::sams::Feature *>& clust_) const;


    }; // class SSDetector


    class DOGDetector : public Detector {
    public:
      DOGDetector () {};
      virtual ~DOGDetector () {};

        virtual void compute(const jafar::image::Image& src_, 
        std::vector< jafar::sams::Feature *>& fVec_) const;
    protected:
      void loadKeyValueFile(jafar::kernel::KeyValueFile const& keyValueFile) {
        JFR_WARNING("SIFTDetector::loadKeyValueFile: Not implemented");
      };

      void saveKeyValueFile(jafar::kernel::KeyValueFile& keyValueFile){
        JFR_WARNING("SIFTDetector::saveKeyValueFile: Not implemented");
      };
    }; /* class DOGDetector */

    class SHDetector : public Detector {
    public:
      struct Params {
        int startScale;
        int stopScale;
        int nbins;
        double yt;
        double wt;
        int max_count;

        Params(int start=3,int stop=33, int bins=16, double y=0.0, double w=0.5,int mc=500) :
        startScale(start), stopScale(stop), nbins(bins), yt(y), wt(w), max_count(mc) {};
      };

      SHDetector(Params params_=Params()) : params(params_) {};

      virtual ~SHDetector() {
      };


        virtual void compute(const jafar::image::Image& src_, 
        std::vector< jafar::sams::Feature *>& fVec_) const;
    protected:
      void loadKeyValueFile(jafar::kernel::KeyValueFile const& keyValueFile) {
        JFR_WARNING("SHDetector::loadKeyValueFile: Not implemented");
      };

      void saveKeyValueFile(jafar::kernel::KeyValueFile& keyValueFile){
        JFR_WARNING("SHDetector::saveKeyValueFile: Not implemented");
      };
    private:
      Params params;
    }; // class SHDetector

    // class HLDetector : public Detector {
//    public:
//      struct Params {
//        double scale_step;
//        int scaleSpaceSize;
// 
//        Params(double sstep=1.2, int ssize=17) 
//          : scale_step(sstep), scaleSpaceSize(ssize) {};
//      };
// 
//      HLDetector (Params p=Params()) 
//        : params(p), hld(2.0,jafar::gfm::HarrisDetector::HS_EIGEN,3.0,p.scale_step,p.scaleSpaceSize) {};
//      virtual ~HLDetector ();
// 
//      virtual void compute(const jafar::image::Image& src_, 
//        std::vector< jafar::sams::Feature *>& fVec_) const;
//    protected:
//      /*! Load parameters from file
//      * @param keyValueFile path to data file
//      */
//      void loadKeyValueFile(jafar::kernel::KeyValueFile const& keyValueFile) {
//        JFR_WARNING("SHDetector::loadKeyValueFile: Not implemented");
//      };
// 
//      /*! save parameters from file
//      * @param keyValueFile path to data file
//      */
//      void saveKeyValueFile(jafar::kernel::KeyValueFile& keyValueFile){
//        JFR_WARNING("SHDetector::saveKeyValueFile: Not implemented");
//      };
//    private:
//      Params params;
//      mutable jafar::gfm::HarrisLaplaceDetector hld;
//    }; // class HLDetector

  } // namespace sams
} // namespace jafar

#endif // SAMS_DETECTOR_HPP