ScaledImageSource.h

Go to the documentation of this file.

 
#ifndef _SEFRAMEWORK_IMAGE_SCALEDIMAGESOURCE_H
#define _SEFRAMEWORK_IMAGE_SCALEDIMAGESOURCE_H
 
#include "SEFramework/Image/ImageAccessor.h"
#include "SEFramework/Image/ImageSource.h"
#include "MathUtils/interpolation/interpolation.h"
 
namespace SourceXtractor {
 
template<typename T>
class ScaledImageSource : public ImageSource {
public:
  enum class InterpolationType {
    BILINEAR, BICUBIC
  };
 
  ScaledImageSource(const std::shared_ptr<Image<T>>& image, int width, int height, InterpolationType interp_type = InterpolationType::BICUBIC)
    : m_image(image), m_width(width), m_height(height) {
    m_wscale = std::ceil(static_cast<float>(width) / image->getWidth());
    m_hscale = std::ceil(static_cast<float>(height) / image->getHeight());
 
    ImageAccessor<T> accessor(image);
 
    switch (interp_type) {
      case InterpolationType::BICUBIC:
        m_interpolation_type = Euclid::MathUtils::InterpolationType::CUBIC_SPLINE;
        break;
      case InterpolationType::BILINEAR:
        m_interpolation_type = Euclid::MathUtils::InterpolationType::LINEAR;
        break;
    }
 
    // Generate y coordinates on the original image
    std::vector<double> y_coords(image->getHeight());
    for (size_t i = 0; i < y_coords.size(); ++i) {
      y_coords[i] = std::floor((i + 0.5) * m_hscale);
    }
 
    // Generate x coordinates on the original image
    m_x_coords.resize(image->getWidth());
    for (size_t i = 0; i < m_x_coords.size(); ++i) {
      m_x_coords[i] = std::floor((i + 0.5) * m_wscale);
    }
 
    // Store interpolation along columns
    m_interpolated_cols.reserve(image->getWidth());
    for (int x = 0; x < image->getWidth(); ++x) {
      std::vector<double> values(image->getHeight());
      for (int y = 0; y < image->getHeight(); ++y) {
        values[y] = accessor.getValue(x, y);
      }
      m_interpolated_cols.emplace_back(
        Euclid::MathUtils::interpolate(y_coords, values, m_interpolation_type, true));
    }
  }
 
  virtual ~ScaledImageSource() = default;
 
  std::string getRepr() const final {
    return std::string("ScaledImageSource");
  }
 
  std::shared_ptr<ImageTile> getImageTile(int x, int y, int width, int height) const final {
    auto tile = ImageTile::create(ImageTile::getTypeValue(T()), x, y, width, height);
 
    for (int off_y = 0; off_y < height; ++off_y) {
      std::vector<double> v(m_x_coords);
      for (size_t ix = 0; ix < m_x_coords.size(); ++ix) {
        auto& fy = *m_interpolated_cols[ix];
        v[ix] = fy(y + off_y);
      }
      auto fx = Euclid::MathUtils::interpolate(m_x_coords, v, m_interpolation_type, true);
      for (int off_x = 0; off_x < width; ++off_x) {
        tile->setValue(x + off_x, y + off_y, T((*fx)(x + off_x)));
      }
    }
    return tile;
  }
 
  void saveTile(ImageTile&) final {
    assert(false);
  }
 
  int getWidth() const final {
    return m_width;
  }
 
  int getHeight() const final {
    return m_height;
  }
 
  ImageTile::ImageType getType() const override {
    return ImageTile::getTypeValue(T());
  }
 
private:
  std::shared_ptr<Image<T>> m_image;
  int m_width, m_height;
  Euclid::MathUtils::InterpolationType m_interpolation_type;
  std::vector<std::unique_ptr<Euclid::MathUtils::Function>> m_interpolated_cols;
  std::vector<double> m_x_coords;
  double m_wscale, m_hscale;
};
 
} // end of namespace SourceXtractor
 
#endif // _SEFRAMEWORK_IMAGE_SCALEDIMAGESOURCE_H