Frame.h

Go to the documentation of this file.

/*
 * Frame.h
 *
 *  Created on: Mar 13, 2017
 *      Author: mschefer
 */

#ifndef _SEFRAMEWORK_FRAME_FRAME_H_
#define _SEFRAMEWORK_FRAME_FRAME_H_

#include <algorithm>

#include "SEUtils/Types.h"
#include "SEFramework/Image/Image.h"
#include "SEFramework/Image/ImageSource.h"
#include "SEFramework/CoordinateSystem/CoordinateSystem.h"

namespace SourceXtractor {

enum FrameImageLayer {
  LayerOriginalImage = 0,
  LayerInterpolatedImage,
  LayerSubtractedImage,
  LayerFilteredImage,
  LayerThresholdedImage,
  LayerSignalToNoiseMap,
  LayerOriginalVarianceMap,
  LayerUnfilteredVarianceMap,
  LayerVarianceMap,
  LayerDetectionThresholdMap
};

template<typename T>
class Frame {

public:

  class ImageFilter {
  public:
    virtual ~ImageFilter() = default;
    virtual std::shared_ptr<Image<T>> processImage(std::shared_ptr<Image<T>> image, std::shared_ptr<Image<T>> variance, T threshold) const = 0;
  };

  Frame(std::shared_ptr<Image<T>> detection_image,
        std::shared_ptr<WeightImage> variance_map,
        WeightImage::PixelType variance_threshold,
        std::shared_ptr<CoordinateSystem> coordinate_system,
        SeFloat gain, SeFloat saturation, int interpolation_gap);

  // FIXME: this simplified version is used in unit tests, get rid of it
  explicit Frame(std::shared_ptr<Image<T>> detection_image,
                 std::shared_ptr<CoordinateSystem> coordinate_system = nullptr,
                 std::shared_ptr<WeightImage> variance_map = nullptr);

  //
  // Methods to get the image in one form or another
  //

  std::shared_ptr<Image<T>> getImage(FrameImageLayer layer) const;


  // Just the original image
  std::shared_ptr<Image<T>> getOriginalImage() const {
    return m_image;
  }

  size_t getHduIndex() const {
   return m_hdu_index;
  }

  void setHduIndex(size_t hdu_index) {
    m_hdu_index = hdu_index;
  }

  // Metadata of the original image
  const std::map<std::string, MetadataEntry>& getMetadata() const {
    return m_metadata;
  };

  void setMetadata(const std::map<std::string, MetadataEntry>& metadata) {
    m_metadata = metadata;
  };

  // Returns the image with bad pixels interpolated (if interpolation is active, otherwise returns original)
  std::shared_ptr<Image<T>> getInterpolatedImage() const;

  // Get the image with the background subtracted
  std::shared_ptr<Image<T>> getSubtractedImage() const;

  // Get the image with a filter applied to the subtracted image
  std::shared_ptr<Image<T>> getFilteredImage() const;

  // Get the filtered image with the detection threshold subtracted from it
  std::shared_ptr<Image<T>> getThresholdedImage() const;

  // Get the SNR image
  std::shared_ptr<Image<T>> getSnrImage() const;

  //
  // Methods to get the image in one form or another
  //

  std::shared_ptr<WeightImage> getVarianceMap() const;

  std::shared_ptr<WeightImage> getUnfilteredVarianceMap() const;

  std::shared_ptr<WeightImage> getOriginalVarianceMap() const {
    return m_variance_map;
  }

  //
  // Methods to get frame metadata
  //

  std::shared_ptr<CoordinateSystem> getCoordinateSystem() const {
    return m_coordinate_system;
  }

  typename WeightImage::PixelType getVarianceThreshold() const {
    return m_variance_threshold;
  }

  SeFloat getGain() const {
    return m_gain;
  }

  SeFloat getSaturation() const {
    return m_saturation;
  }

  SeFloat getBackgroundMedianRms() const {
    return m_background_rms;
  }

  std::shared_ptr<Image<T>> getDetectionThresholdMap() const;

  std::string getLabel() const {
    return m_label;
  }

  //
  // Setters
  //

  void setVarianceMap(std::shared_ptr<WeightImage> variance_map);

  void setVarianceThreshold(WeightImage::PixelType threshold);

  std::shared_ptr<Image<T>> getBackgroundLevelMap() const;

  void setDetectionThreshold(T detection_threshold);

  void setBackgroundLevel(T background_level);

  void setBackgroundLevel(std::shared_ptr<Image<T>> background_level_map, T background_rms);

  void setFilter(std::shared_ptr<ImageFilter> filter);

  void setLabel(const std::string &label);

private:

  void applyFilter();
  void applyInterpolation();

  std::shared_ptr<Image<T>> m_image;
  std::shared_ptr<WeightImage> m_variance_map;
  std::shared_ptr<Image<T>> m_background_level_map;

  std::shared_ptr<CoordinateSystem> m_coordinate_system;

  SeFloat m_gain;
  SeFloat m_saturation;
  SeFloat m_background_rms;

  T m_detection_threshold;
  typename WeightImage::PixelType m_variance_threshold;

  int m_interpolation_gap; // max interpolation gap, 0 == no interpolation

  std::shared_ptr<ImageFilter> m_filter;
  std::shared_ptr<Image<T>> m_interpolated_image;
  std::shared_ptr<Image<WeightImage::PixelType>> m_interpolated_variance;
  std::shared_ptr<Image<T>> m_filtered_image;
  std::shared_ptr<Image<T>> m_filtered_variance_map;

  std::string m_label;
  size_t m_hdu_index = 0;
  std::map<std::string, MetadataEntry> m_metadata {};
};

using DetectionImageFrame = Frame<DetectionImage::PixelType>;
using MeasurementImageFrame = Frame<MeasurementImage::PixelType>;

}

#endif /* _SEFRAMEWORK_FRAME_FRAME_H_ */