MaskedImage.h

Go to the documentation of this file.

/*
* MaskedImage.h
*
*  Created on: Feb 13, 2020
*      Author: Alejandro Alvarez Ayllon
*/

#ifndef SEFRAMEWORK_SEFRAMEWORK_IMAGE_MASKEDIMAGE_H_
#define SEFRAMEWORK_SEFRAMEWORK_IMAGE_MASKEDIMAGE_H_

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

namespace SourceXtractor {

template<typename T, typename M, template <typename> class Operator = std::bit_and>
class MaskedImage : public Image<T> {
private:
  MaskedImage(const std::shared_ptr<Image<T>>& image, const std::shared_ptr<Image<M>>& mask,
              T replacement, M mask_flag) : m_image{image}, m_mask{mask}, m_replacement{replacement},
                                            m_mask_flag{mask_flag}, m_n_masked{0}, m_n_total{0} {
  }

  std::shared_ptr<Image<T>> m_image;
  std::shared_ptr<Image<M>> m_mask;
  T m_replacement;
  M m_mask_flag;
  Operator<M> m_operator;

  mutable std::size_t m_n_masked;
  mutable std::size_t m_n_total;

public:
  virtual ~MaskedImage() = default;

  static std::shared_ptr<MaskedImage<T, M, Operator>>
  create(const std::shared_ptr<Image<T>>& image, const std::shared_ptr<Image<M>>& mask,
         T replacement, M mask_flag = 0x01) {
    assert(image->getWidth() == mask->getWidth() && image->getHeight() == mask->getHeight());
    return std::shared_ptr<MaskedImage<T, M, Operator>>(new MaskedImage<T, M, Operator>(image, mask, replacement, mask_flag));
  }

  std::string getRepr() const final {
    if (m_n_total == (m_image->getWidth()*m_image->getHeight())){
        char char_fract[8];
        // determine the percentage of masked pixels
        std::snprintf(char_fract, 7, "%.1f%", 100.0*this->getNMasked()/(m_image->getWidth()*m_image->getHeight()));
        return std::string("Masked(" + m_image->getRepr() + ") with "+std::string(char_fract)+" weight image masked pixels;");
    }
    else
      return std::string("Masked(" + m_image->getRepr() + ")");
  }

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

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

  std::size_t getNMasked() const {
    return m_n_masked;
  }

  std::size_t getNTotal() const {
    return m_n_total;
  }

  std::shared_ptr<ImageChunk<T>> getChunk(int x, int y, int width, int height) const final {
    auto chunk = UniversalImageChunk<T>::create(std::move(*m_image->getChunk(x, y, width, height)));
    auto mask_chunk = m_mask->getChunk(x, y, width, height);
    for (int iy = 0; iy < height; ++iy) {
        for (int ix = 0; ix < width; ++ix) {
            m_n_total += 1;
            if (m_operator(mask_chunk->getValue(ix, iy), m_mask_flag)){
                chunk->setValue(ix, iy, m_replacement);
                m_n_masked+=1;
            }
        }
    }
    return chunk;
  }

};

} // end of namespace SourceXtractor

#endif // SEFRAMEWORK_SEFRAMEWORK_IMAGE_MASKEDIMAGE_H_