utilities.hpp

// This file is part of the imaging2 class library.
//
// University of Innsbruck, Infmath Imaging, 2009.
// http://infmath.uibk.ac.at
//
// All rights reserved.


#ifndef IMAGE_UTILITIES_H
#define IMAGE_UTILITIES_H

#include <image/Image.hpp>
#include <image/Color.hpp>

namespace imaging
{
  template <class float_accessor_t, class vector_accessor_t>
  void compute_divergence_field(const float_accessor_t & image, vector_accessor_t & out)
  {
    const size_t dimension = float_accessor_t::dimension;

    if(image.size() != out.size())
      throw Exception("Exception: Dimensions in compute_divergence_field() do not agree.");

    for(size_t i = 0; i < dimension; ++i)
    {
      ublas::fixed_vector<size_t, dimension> index;
      index.assign(0);

      if(image.size()(i) == 0)
        break;

      do
      {
        out[index](i) = 1.0/float_t(dimension) * image[index];
      }
      while(increment_index(image.size(), i, index));

      ublas::fixed_vector<size_t, dimension> offset;
      offset.assign(0);

      for(size_t j = 1; j < image.size()(i); ++j)
      {
        index(i) = j;
        do
        {
          offset(i) = 1;
          out[index](i) = out[index - offset](i) + 1.0/float_t(dimension) * image[index];
          offset(i) = 0;
        }
        while(increment_index(image.size(), i, index));
      }
    }
  }
  
  template <class image_t>
  void blur(image_t & image, float_t width, float_t sigma)
  {}
  
  template <>
  void blur(Image<2, float_t> & image, float_t width, float_t sigma);
  
  template <class image_t>
  void edge(image_t & image, float_t radius)
  {}
  
  template <>
  void edge(Image<2, float_t> & image, float_t radius);
  
  template <class image_t>
  void absolute_gradient(image_t & image)
  {}
  
  template <>
  void absolute_gradient(Image<2, float_t> & image);
  
  template <class image_t>
  typename image_t::data_t max(const image_t & image)
  {
    if(image.empty()) 
      throw Exception("Exception: passed empty image to max(const ImageInterface &).");
    
    ublas::fixed_vector<size_t, image_t::dimension> index;
    index.assign(0);
    typename image_t::data_t max_value = image[index];
    do
    {
      typename image_t::data_t temp = image[index];
      if(max_value < temp) max_value = temp;
    }
    while(increment_index(image.size(), index));
    
    return max_value;
  }
  
  template <class image_t>
  typename image_t::data_t min(const image_t & image)
  {
    if(image.empty()) 
      throw Exception("Exception: passed empty image to max(const ImageInterface &).");
    
    ublas::fixed_vector<size_t, image_t::dimension> index;
    index.assign(0);
    typename image_t::data_t min_value = image[index];
    do
    {
      typename image_t::data_t temp = image[index];
      if(min_value > temp) min_value = temp;
    }
    while(increment_index(image.size(), index));
    
    return min_value;
  }
  
  template <class image_t>
  bool is_pixel(const image_t & image, const ublas::fixed_vector<size_t, image_t::dimension> & index)
  {
    for(size_t i = 0; i < image_t::dimension; ++i)
      if(index(i) >= image.size()(i))
        return false;
    
    return true;
  }
  
  
  void draw_level_set(const Image<2, float_t> & level_set_function, const float_t & level, const Color & color, ColorImage2d & image);
  
  void image2matrix(const Image<2, float_t> & image, ublas::matrix<float_t> & matrix);
}

#endif

---