pyramid.hpp

/* $Id: $ */

#ifndef _PYRAMID_HPP_
#define _PYRAMID_HPP_

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

namespace jafar {
  namespace image {
    
    class Pyramid {
    public:
      typedef std::vector<jafar::image::Image>::iterator iterator;
      typedef std::vector<jafar::image::Image>::const_iterator const_iterator;
      iterator begin() { return p_pyr.begin(); };
      const_iterator begin() const { return p_pyr.begin(); };
      iterator end() { return p_pyr.end(); };
      const_iterator end() const { return p_pyr.end(); };

      Pyramid(int levels=0) : p_pyr(levels) {}; 

      Pyramid(jafar::image::Image const & img, int levels) {
  build(img,levels);
      }

      Pyramid(Pyramid const & pyr) : p_pyr(pyr.size()){
  p_pyr = pyr.p_pyr;
      };

      virtual ~Pyramid() {};

      Pyramid clone() const {
  Pyramid pyr(size());
  for(unsigned int i=0; i<size(); i++)
    pyr[i] = p_pyr[i].clone();
  return pyr;
      }
        
      size_t size() const {
  return p_pyr.size();
      }

      bool check() const {
  if ( size() == 0 ) {
    JFR_DEBUG("Empty pyramid");
    return false;
  }
  for(size_t i=0; i<size(); i++) {
    JFR_DEBUG("level " << i << ":" << p_pyr[i]);
    if (p_pyr[i].empty()) 
      return false;
  }
  return true;
      }

      jafar::image::Image & operator[] (int l) {
  return p_pyr[l];
      };

      jafar::image::Image const & operator[] (int l) const {
  return p_pyr[l];
      };

      template<typename type>
      type getPixelValue(int x, int y, int l, int ref_l=0,int channel=0) const;

      template<typename type>
      double getSubPixelValue(double x, double y, int l,int ref_l=0,int channel=0) const;

      Pyramid& operator= (Pyramid const & pyr) {
  p_pyr = pyr.p_pyr;
  return *this;
      };

      bool operator==(jafar::image::Image const & img) const {
  return ( !p_pyr[0].empty() ? ( p_pyr[0].compHeader(img) ) : false);
      }
      
      bool operator==(jafar::image::Pyramid const & pyr) const {
  return ( size() == 0 ? ( !p_pyr[0].empty() ? ( p_pyr[0].compHeader(pyr[0]) && 
                   p_pyr.size() == pyr.size() ) : false ) : false);
      }
      
      virtual void build(jafar::image::Image const & img, int l=0);
      
      
    protected:
      std::vector<jafar::image::Image> p_pyr;
    }; /* class Pyramid */

    

    /*************************************************************************/
    /*************************************************************************/
    
    template<typename type>
    type Pyramid::getPixelValue(int x, int y, int l, int ref_l, int channel) const {
      JFR_PRECOND( p_pyr.size() > 0, "Pyramid::getPixelValue: empty pyramid");
      JFR_PRECOND(l < p_pyr.size(), "Pyramid::getPixelValue: level parameter out of range");
      JFR_PRECOND( ( ref_l >= 0 && ref_l <= l ), "Pyramid::getPixelValue: incompatible level and reference level");
      if ( ref_l == l ) 
  return p_pyr[l].getPixelValue<type>(x,y,channel);
      int ii = x >> (l-ref_l), jj = y >> (l-ref_l);
      int ww = p_pyr[l].width() - 1, hh = p_pyr[l].height() - 1;
      if (ii > ww) ii = ww; if (jj > hh) jj = hh;
      return p_pyr[l].getPixelValue<type>(ii, jj, channel);
    }
    
    template<typename type>
    double Pyramid::getSubPixelValue(double x, double y, int l, int ref_l, int channel) const {
      JFR_PRECOND( p_pyr.size() > 0, "Pyramid::getPixelValue: empty pyramid");
      JFR_PRECOND(l < p_pyr.size(), "Pyramid::getPixelValue: level parameter out of range");
      JFR_PRECOND( ( ref_l >= 0 && ref_l <= l ), "Pyramid::getSubPixelValue: incompatible level and reference level");
      if ( ref_l == l )
  return p_pyr[l].getSubPixelValue<type>(x,y,channel);
      double fac = double(1 << (l-ref_l));
      double ii = x / fac, jj = y / fac;
      int ww = p_pyr[l].width() - 1, hh = p_pyr[l].height() - 1;
      if (ii > ww) ii = ww; if (jj > hh) jj = hh;
      return p_pyr[l].getSubPixelValue<type>(ii, jj, channel);
    }
    
    
    class GaussianPyramid : public Pyramid {
    public:
      GaussianPyramid (int l=0, double s=1.2, double s0=1.0) : Pyramid(l), sigma(s), sigma0(s0) {};
      virtual ~GaussianPyramid () {};

      virtual void build(jafar::image::Image const & img, int l=0);

    private:
      double sigma;
      double sigma0;
    };
    
    
    class GaborPyramid : public Pyramid {
    public:
      GaborPyramid (float theta, int l=0, float major_stddev=3.92, float minor_stddev=3.92, float period=7, int size=-1) : Pyramid(l) {
  gabor0 = jafar::image::filter::gaborkernel(major_stddev,minor_stddev,period,0.,theta,size);
  gabor90 = jafar::image::filter::gaborkernel(major_stddev,minor_stddev,period,90.,theta,size);
      };
      virtual ~GaborPyramid () {};

      virtual void build(jafar::image::Image const & img, int l=0);

      jafar::image::Image kernel0() const;
      jafar::image::Image kernel90() const;
      
    private:
      cv::Mat gabor0;     
      cv::Mat gabor90;
    };        
    
    class LinearPyramid : public Pyramid {
    public:
      LinearPyramid( int _levels) : Pyramid(_levels )
      {
      }
      virtual ~LinearPyramid() {}
      virtual void build( jafar::image::Image const & img, int l=0);
    };
    
  } /* namespace image */
} /* namespace jafar */


#endif /* _PYRAMID_HPP_ */