ird.hpp

#ifndef SAS_IRD_HPP
#define SAS_IRD_HPP

#include <map>
#include "kernel/keyValueFile.hpp"
#include "image/Image.hpp"
#include "sas/conspicuity.hpp"
#include "sas/irdm.hpp"

#define VISU 0

namespace jafar {
  namespace sas {

    typedef enum RElevel {
      SALIENCY=0,
      CMAP=1,
      FMAP=2
    };

    class IRDParams : public jafar::kernel::KeyValueFileLoad {
    public:
      jafar::sas::CParams cparams;
      double wI;
      double wC;
      double wO;
      double cThd;
      double sThd;
      int loglevels;
      int logkernsize;

      IRDParams(jafar::sas::CParams cparams_=jafar::sas::CParams(),double wI_=1.0, 
                double wC_=1.0, double wO_=1.0, double cThd_=0.1, double sThd_=0.5,
                int loglevels_=10, int logkernsize_=5) :
      cparams(cparams_),wI(wI_), wC(wC_), wO(wO_), cThd(cThd_), sThd(sThd_), loglevels(loglevels_), logkernsize(logkernsize_) {};

      inline void loadCParams(std::string const & filename) {
        cparams.load(filename);
      };
      
    protected:
      void loadKeyValueFile(jafar::kernel::KeyValueFile const& keyValueFile);
    };

    class IRD {
    public:


      IRD(IRDM * dm_, IRDParams const & params_=IRDParams());

      static inline IRD * createIRD(IRDM * dm_, std::string const & filename) {
        IRDParams params;
        params.load(filename);
        params.loadCParams(filename);
        return new IRD(dm_,params);
      };
      
      ~IRD();

      void computeSaliency();

      void extractRoisCC(bool maskOnly = false, RElevel rel=CMAP);

#if 0

      void extractRoisSS(bool maskOnly = false, RElevel rel=CMAP);
#endif
      
      void process(RElevel rel=CMAP) {
        computeSaliency();
        extractRoisCC(false,rel);
      };

      jafar::image::Image draw(jafar::image::Image & display);

    protected:

      IRDM * dm;

      IRDParams params;

      std::map<std::string, Conspicuity *> cmaps;
      
      std::vector<jafar::image::Image> LOG;
      
      void extractChannels(jafar::image::Image const & src);

      void extractChannels_walther(jafar::image::Image const & src);

      std::pair<std::string,std::string> selectMap(CvPoint pmax) const;
      
#if 0 

      void computeLOG();
#endif    
      
    friend class Engine;
      
    }; // class IRD

  } // namespace sas
} // namespace jafar

#endif // SAS_FEATURESALIENCY_HPP