---

bilateral_filter.h

Go to the documentation of this file.

#ifndef __BILATERAL_FILTER__
#define __BILATERAL_FILTER__

#include <cmath>

#include "array.h"
#include "math_tools.h"



/*

##########################
# class Bilateral_filter #
##########################

*/


template <typename Space_weight_function,
          typename Data_weight_function>
class Bilateral_filter{

public:

  typedef unsigned int size_type;
  
  Bilateral_filter(Space_weight_function& space_w,
                   Data_weight_function&  data_w);
  

  template<typename Data_array>
  void pixel_filter(const size_type x,
                    const size_type y,
                    const Data_array& data,
                    typename Data_array::value_type* const result);

  template<typename Data_array>
  void array_filter(const Data_array& data,
                    Data_array* const result);


private:

  Space_weight_function& space_weight;
  Data_weight_function&  data_weight;
};




/*

###############################
# class Gaussian_space_weight #
###############################

*/

class Gaussian_space_weight{

public:

  typedef unsigned int size_type;
  typedef float        real_type;

  inline Gaussian_space_weight(const real_type sig);

  inline size_type far() const;
  
  inline bool is_far(const int dx,const int dy) const;

  inline void set_reference_data(const size_type x,
                                 const size_type y);
  
  inline real_type operator()(const size_type x,
                              const size_type y) const;
  
private:
  const real_type sigma;
  const int       far_threshold;

  size_type x_ref,y_ref;

  Array_2D<real_type> weight;
};











/*
  ###########################################################
  ###########################################################
  ###########################################################
  ##############                               ##############
  ##############  I M P L E M E N T A T I O N  ##############
  ##############                               ##############
  ###########################################################
  ###########################################################
  ###########################################################
*/








/*

##########################
# class Bilateral_filter #
##########################

*/


template <typename Space_weight_function,
          typename Data_weight_function>
Bilateral_filter<Space_weight_function,Data_weight_function>::
Bilateral_filter(Space_weight_function& space_w,
                 Data_weight_function&  data_w):
  space_weight(space_w),
  data_weight(data_w){
}


template <typename Space_weight_function,
          typename Data_weight_function>
template <typename Data_array>
void
Bilateral_filter<Space_weight_function,Data_weight_function>::
pixel_filter(const size_type x,
             const size_type y,
             const Data_array& data,
             typename Data_array::value_type* const result){

  using namespace Math_tools;
  
  const size_type width  = data.x_size();
  const size_type height = data.y_size();

  const int far = static_cast<int>(space_weight.far());

  const size_type x_begin = clamp<int>(0,width-1,static_cast<int>(x)-far);
  const size_type x_end   = clamp<int>(0,width-1,static_cast<int>(x)+far);
  
  const size_type y_begin = clamp<int>(0,height-1,static_cast<int>(y)-far);
  const size_type y_end   = clamp<int>(0,height-1,static_cast<int>(y)+far);

  real_type weight_sum = 0;
  *result *= 0;

  space_weight.set_reference_data(x,y);
  data_weight.set_reference_data(x,y);
  
  for(size_type i=x_begin;i<=x_end;i++){
    for(size_type j=y_begin;j<=y_end;j++){

      real_type weight = space_weight(i,j) * data_weight(i,j);
      *result += weight * data(i,j);
      weight_sum += weight;
    }
  }

  if (weight_sum == 0){
    *result = data(x,y);
  }
  else{
    *result /= weight_sum;
  }
}



template <typename Space_weight_function,
          typename Data_weight_function>
template <typename Data_array>
void
Bilateral_filter<Space_weight_function,Data_weight_function>::
array_filter(const Data_array& data,
             Data_array* const result){

  const size_type width  = data.x_size();
  const size_type height = data.y_size();

  Data_array target(width,height);

  for(size_type x=0;x<width;x++){
    for(size_type y=0;y<height;y++){
      pixel_filter(x,y,data,&target);
    }
  }

  result->swap(target);
}



/*

###############################
# class Gaussian_space_weight #
###############################

*/



Gaussian_space_weight::Gaussian_space_weight(const real_type sig):
  sigma(sig),
  far_threshold(2*static_cast<int>(sig+1)){


  weight.resize(2*far_threshold+1,2*far_threshold+1);

  for(int dx=0;dx<=far_threshold;dx++){
    for(int dy=0;dy<=far_threshold;dy++){
      const real_type x = static_cast<real_type>(dx) / sigma;
      const real_type y = static_cast<real_type>(dy) / sigma;
      const real_type g = std::exp(-0.5*(x*x+y*y));

      weight(far_threshold-dx,far_threshold-dy) = g;
      weight(far_threshold+dx,far_threshold-dy) = g;
      weight(far_threshold+dx,far_threshold+dy) = g;
      weight(far_threshold-dx,far_threshold+dy) = g;
    }
  }
}



inline Gaussian_space_weight::size_type
Gaussian_space_weight::far() const{
  
  return far_threshold;
}



bool Gaussian_space_weight::is_far(const int dx,const int dy) const{

  return
    (dx>far_threshold) || (dx<-far_threshold) ||
    (dy>far_threshold) || (dy<-far_threshold);
}


void Gaussian_space_weight::set_reference_data(const size_type x,
                                               const size_type y){
    x_ref = x;
    y_ref = y;
  }


Gaussian_space_weight::real_type
Gaussian_space_weight::operator()(const size_type x,
                                  const size_type y) const{

  const int dx = static_cast<int>(x_ref) - static_cast<int>(x);
  const int dy = static_cast<int>(y_ref) - static_cast<int>(y);
  
  return (is_far(dx,dy) ? 0 : weight(far_threshold+dx,far_threshold+dy));
}

#endif

---