ImageAccessor.h

Go to the documentation of this file.

#ifndef _SEFRAMEWORK_IMAGE_IMAGEACCESSOR_H
#define _SEFRAMEWORK_IMAGE_IMAGEACCESSOR_H

#include "SEFramework/Image/Image.h"
#include "SEFramework/Image/ImageChunk.h"

namespace SourceXtractor {

template<typename T>
class ImageAccessor: public Image<T> {
public:

  enum AccessHint {
    TOP_LEFT,     //< The first coordinate is likely the top left corner of what is going to be needed
    CENTERED,     //< The first coordinate is likely the center of a region
    BOTTOM_RIGHT, //< The first coordinate is likely the bottom right corner
  };

  ~ImageAccessor() = default;

  explicit ImageAccessor(std::shared_ptr<const Image<T>> img, AccessHint hint = TOP_LEFT, int w = 64, int h = 1)
      : m_image(img.get()), m_keep_alive(std::move(img)), m_hint(hint), m_read_width(w), m_read_height(h){};

  explicit ImageAccessor(const Image<T>& img, AccessHint hint = TOP_LEFT, int w = 64, int h = 64)
      : m_image(&img), m_hint(hint), m_read_width(w), m_read_height(h){};

  ImageAccessor(const ImageAccessor<T>&) = delete;

  ImageAccessor(ImageAccessor<T>&&) = default;

  ImageAccessor<T>& operator=(const ImageAccessor<T>&) = delete;

  T getValue(int x, int y) {
    selectChunk(PixelCoordinate(x, y));
    x -= m_chunk_min.m_x;
    y -= m_chunk_min.m_y;
    return m_chunk->getValue(x, y);
  }

  T getValue(const PixelCoordinate& coord) {
    selectChunk(coord);
    return m_chunk->getValue(coord - m_chunk_min);
  }

  /*
   * Forward these methods directly to the wrapped image
   */

  std::string getRepr() const override {
    return m_image->getRepr();
  }

  int getWidth() const override {
    return m_image->getWidth();
  }

  int getHeight() const override {
    return m_image->getHeight();
  }

  std::shared_ptr<ImageChunk<T>> getChunk(int x, int y, int width, int height) const override {
    return m_image->getChunk(x, y, width, height);
  };

private:
  const Image<T>* m_image;
  std::shared_ptr<const Image<T>> m_keep_alive;
  std::shared_ptr<const ImageChunk<T>> m_chunk;
  PixelCoordinate m_chunk_min, m_chunk_max;
  AccessHint m_hint;
  int m_read_width, m_read_height;

  void selectChunk(const PixelCoordinate& coord) {
    if (m_chunk && coord >= m_chunk_min && coord <= m_chunk_max) {
      return;
    }
    nextCoordinates(coord);
    m_chunk = m_image->getChunk(m_chunk_min, m_chunk_max);
  }

  void nextCoordinates(const PixelCoordinate& coord) {
    if (!m_chunk) {
      m_chunk_min = firstCoordinates(coord);
    }
    else {
      switch (m_hint) {
        case TOP_LEFT:
        case CENTERED:
          m_chunk_min.m_x = coord.m_x;
          m_chunk_min.m_y = coord.m_y;
          break;
        case BOTTOM_RIGHT:
          m_chunk_min.m_x = coord.m_x - m_read_width + 1;
          m_chunk_min.m_y = coord.m_y - m_read_height + 1;
          break;
      }
    }
    // Make sure we don't leave the image
    m_chunk_min.clip(m_image->getWidth(), m_image->getHeight());
    // Max pixel
    m_chunk_max.m_x = m_chunk_min.m_x + m_read_width;
    m_chunk_max.m_y = m_chunk_min.m_y + m_read_height;
    m_chunk_max.clip(m_image->getWidth(), m_image->getHeight());
  }

  PixelCoordinate firstCoordinates(const PixelCoordinate& coord) {
    switch (m_hint) {
      case CENTERED:
        return PixelCoordinate(coord.m_x - m_read_width / 2, coord.m_y - m_read_height / 2);
      case TOP_LEFT:
        return coord;
      case BOTTOM_RIGHT:
        return PixelCoordinate(coord.m_x - m_read_width, coord.m_y - m_read_height);
    }
    return coord;
  }
};

} // end of namespace SourceXtractor

#endif // _SEFRAMEWORK_IMAGE_IMAGEACCESSOR_H