conspicuity.hpp

/* $Id$ */

#ifndef SAS_CONSPICUITY_HPP
#define SAS_CONSPICUITY_HPP

#include <vector>
#include "kernel/keyValueFile.hpp"
#include "image/Image.hpp"
#include "image/filter.hpp"
#include "image/pyramid.hpp"

namespace jafar {
  namespace sas {

    typedef enum MaxNormType {
      STD=0,
      NOV=1,
      FANCY=2,
      FFANCY=3
    };

    class CParams : public jafar::kernel::KeyValueFileLoad {
      public:
      int sml;
      int lmin;
      int lmax;
      int dmin;
      int dmax;
      int maxlevels;
      double nmin;
      double nmax;
      int niter;
      MaxNormType ntype;

      CParams(int sml_=3,int lmin_=2,int lmax_=4,int dmin_=3, int dmax_=4, double nmin_=0.0, double nmax_=10.0, int niter_=3, MaxNormType ntype_=FANCY) :
        sml(sml_),lmin(lmin_), lmax(lmax_),dmin(dmin_), dmax(dmax_),maxlevels(lmax_+dmax_+1),
        nmin(nmin_), nmax(nmax_), niter(niter_), ntype(ntype_) {};
      protected:
      void loadKeyValueFile(jafar::kernel::KeyValueFile const& keyValueFile);
    };

    class Conspicuity : public jafar::image::Pyramid {
      public:
      CParams params;
            
      Conspicuity(CParams const & params_=CParams()) : jafar::image::Pyramid(params_.maxlevels), params(params_) {};
      virtual ~Conspicuity() {};

      void process(jafar::image::Image const & img);
      
      jafar::image::Image const & getMap(std::string const & label) const {
        return fmaps.find(label)->second;
      };
      
      std::pair<std::string,float> getStrongestFMap(int wx, int wy) const {
        std::map<std::string,jafar::image::Image>::const_iterator it = fmaps.begin();
        std::pair<std::string,float> res("",-1.);
        for(; it != fmaps.end(); it++) {
          if ( it->first != "cmap") {
            float val = it->second.getPixelValue<float>(wx,wy);
            if ( val > res.second ) {
              res.first = it->first;
              res.second = val;
            }
          }
        }
        return res;
      };
      
      static void maxNormalize(jafar::image::Image& img, double mi, double ma, int niter, MaxNormType ntype);
      
      
      static std::string getLabel(int c, int s) {
        std::stringstream st;
        st << "fmap(" << c << "," << s << ")";
        return st.str();
      }
      
      protected: 
      
      std::map<std::string,jafar::image::Image> fmaps;
      
      void centerSurround(jafar::image::Image const & center,
                          jafar::image::Image const & surround,
                          jafar::image::Image & result,
                          bool absol=false);

      void centerSurroundR(jafar::image::Image const & center,
                           jafar::image::Image const & surround,
                           jafar::image::Image & result,
                           bool absol=false);
      
    }; // class Conspicuity

    
    class OrientedConspicuity : public Conspicuity {
      public:
      OrientedConspicuity(float theta_, CParams const & params_=CParams(), float period=7., int size=-1) : 
        Conspicuity(params_) {
        gabor0 = jafar::image::filter::gaborkernel(period*0.312,period*0.312,period,0.,theta_,size);
        gabor90 = jafar::image::filter::gaborkernel(period*0.312,period*0.312,period,90.,theta_,size);
      };

      virtual ~OrientedConspicuity() {};
      
      virtual void build(jafar::image::Image const & img, int l=0) {
        jafar::image::Pyramid::build(img,l);
        int anchorw = gabor0.cols()/2;
        int anchorh = gabor0.rows()/2;
        for(int i=0; i<size(); i++) {
          jafar::image::Image tmp = p_pyr[i].clone();
          cvFilter2D(p_pyr[i],p_pyr[i],gabor0,cvPoint(anchorw,anchorh));    
          cvFilter2D(tmp,tmp,gabor90,cvPoint(anchorw,anchorh));
          cvAdd(p_pyr[i],tmp,p_pyr[i]);
        }
      };
      
      private:
      CvMatrix gabor0;
      CvMatrix gabor90;
    }; // class ConspOrientation


  } // namespace sas
} // namespace jafar

#endif // SAS_CONSPICUITY_HPP