ScalingAccessor.hpp

#ifndef IMAGE_SCALINGACCESSOR_H
#define IMAGE_SCALINGACCESSOR_H

#include <image/ImageAccessorInterface.hpp>

namespace imaging
{
  template <class float_accessor_t>
  class ScalingAccessor : public ImageAccessorInterface<float_accessor_t, float_t>
  {
  public:
    static const size_t dimension = ImageAccessorInterface<float_accessor_t, float_t>::dimension;
    typedef float_t data_t;

  private:
    class data_reference
    {
      ScalingAccessor<float_accessor_t> & _accessor_reference;
      const ublas::fixed_vector<size_t, dimension> & _index_reference;

    public:
      data_reference(ScalingAccessor<float_accessor_t> & accessor, const ublas::fixed_vector<size_t, dimension> & index) : _accessor_reference(accessor), _index_reference(index) {}

      float_t operator=(const float_t & input)
      { _accessor_reference._image_reference[_index_reference] = input / _accessor_reference._factor - _accessor_reference._level; return input; }

      operator float_t() const { return  _accessor_reference._factor * (_accessor_reference._image_reference[_index_reference] + _accessor_reference._level); }
    };
    float_t _factor;
    float_t _level;

  public:
    ScalingAccessor(float_accessor_t & image, float_t factor = 1.0, float_t level = 0.0) :
    ImageAccessorInterface<float_accessor_t, float_t>(image), _factor(factor), _level(level) {}

    float_t operator[](const ublas::fixed_vector<size_t, dimension> & index) const { return _factor * (ImageAccessorInterface<float_accessor_t, float_t>::_image_reference[index] + _level); }
    data_reference operator[](const ublas::fixed_vector<size_t, dimension> & index) { return data_reference(*this, index); }
  };

}

#endif

---