CheckImages.h

Go to the documentation of this file.

/*
 * CheckImages.h
 *
 *  Created on: May 30, 2017
 *      Author: mschefer
 */

#ifndef _SEIMPLEMENTATION_CHECKIMAGES_CHECKIMAGES_H_
#define _SEIMPLEMENTATION_CHECKIMAGES_CHECKIMAGES_H_

#include <mutex>
#include <map>
#include <iostream>

#include <boost/filesystem/path.hpp>

#include "SEFramework/Configuration/Configurable.h"
#include "SEFramework/CoordinateSystem/CoordinateSystem.h"
#include "SEFramework/Image/Image.h"
#include "SEFramework/Image/VectorImage.h"
#include "SEFramework/Image/ProcessedImage.h"
#include "SEFramework/Image/WriteableImage.h"
#include "SEFramework/Frame/Frame.h"

#include "SEImplementation/Image/LockedWriteableImage.h"


namespace SourceXtractor {

class CheckImages : public Configurable {

public:

  virtual ~CheckImages() = default;

  void saveImages();

  std::shared_ptr<WriteableImage<int>> getSegmentationImage(size_t index) const {
    if (index < m_segmentation_images.size()) {
      auto segmentation_image = m_segmentation_images.at(index);
      if (segmentation_image != nullptr) {
        return LockedWriteableImage<int>::create(segmentation_image);
      }
    }
    return nullptr;
  }

  std::shared_ptr<WriteableImage<int>> getPartitionImage(size_t index) const {
    if (index < m_partition_images.size()) {
      auto partition_image = m_partition_images.at(index);
      if (partition_image != nullptr) {
        return LockedWriteableImage<int>::create(partition_image);
      }
    }
    return nullptr;
  }

  std::shared_ptr<WriteableImage<int>> getGroupImage(size_t index) const {
    if (index < m_group_images.size()) {
      auto group_image = m_group_images.at(index);
      if (group_image != nullptr) {
        return LockedWriteableImage<int>::create(group_image);
      }
    }
    return nullptr;
  }

  std::shared_ptr<WriteableImage<int>> getDetectionAutoApertureImage(size_t index) const {
    if (index < m_auto_aperture_images.size()) {
      auto auto_aperture_image = m_auto_aperture_images.at(index);
      if (auto_aperture_image != nullptr) {
        return LockedWriteableImage<int>::create(auto_aperture_image);
      }
    }
    return nullptr;
  }

  std::shared_ptr<WriteableImage<int>> getDetectionApertureImage(size_t index) const {
    if (index < m_aperture_images.size()) {
      auto aperture_image = m_aperture_images.at(index);
      if (aperture_image != nullptr) {
        return LockedWriteableImage<int>::create(aperture_image);
      }
    }
    return nullptr;
  }

  std::shared_ptr<WriteableImage<SeFloat>> getMoffatImage(size_t index) const {
    if (index < m_moffat_images.size()) {
      auto moffat_image = m_moffat_images.at(index);
      if (moffat_image != nullptr) {
        return LockedWriteableImage<SeFloat>::create(moffat_image);
      }
    }
    return nullptr;
  }

  std::shared_ptr<WriteableImage<int>> getMeasurementAutoApertureImage(unsigned int frame_number);

  std::shared_ptr<WriteableImage<int>> getMeasurementApertureImage(unsigned int frame_number);

  std::shared_ptr<WriteableImage<MeasurementImage::PixelType>> getModelFittingImage(unsigned int frame_number);

  std::shared_ptr<WriteableImage<MeasurementImage::PixelType>> getPsfImage(unsigned int frame_number);

  std::shared_ptr<WriteableImage<float>> getMLDetectionImage(unsigned int plane_number, size_t index);

  void addBackgroundCheckImage(std::shared_ptr<Image<SeFloat>> background_image) {
    m_background_images.emplace_back(background_image);
  }

  void addVarianceCheckImage(std::shared_ptr<Image<SeFloat>> variance_image) {
    m_variance_images.emplace_back(variance_image);
  }

  void addFilteredCheckImage(std::shared_ptr<Image<SeFloat>> filtered_image) {
    m_filtered_images.emplace_back(filtered_image);
  }

  void addThresholdedCheckImage(std::shared_ptr<Image<SeFloat>> thresholded_image) {
    m_thresholded_images.emplace_back(thresholded_image);
  }

  void addSnrCheckImage(std::shared_ptr<Image<SeFloat>> snr_image) {
    m_snr_images.emplace_back(snr_image);
  }

  std::shared_ptr<WriteableImage<SeFloat>> getWriteableCheckImage(std::string id, int width, int height);
  void setCustomCheckImage(std::string id, std::shared_ptr<Image<SeFloat>> image);

  void reportConfigDependencies(Euclid::Configuration::ConfigManager& manager) const override;
  void configure(Euclid::Configuration::ConfigManager& manager) override;

  static CheckImages& getInstance() {
    if (m_instance == nullptr) {
      m_instance.reset(new CheckImages);
    }

    return *m_instance;
  }

private:
  CheckImages();

  static std::unique_ptr<CheckImages> m_instance;

  struct FrameInfo {
    std::string m_label;
    int m_width, m_height;
    std::shared_ptr<CoordinateSystem> m_coordinate_system;
    std::shared_ptr<DetectionImage> m_subtracted_image;
  };

  // check image
  std::vector<std::shared_ptr<WriteableImage<int>>> m_segmentation_images;
  std::vector<std::shared_ptr<WriteableImage<int>>> m_partition_images;
  std::vector<std::shared_ptr<WriteableImage<int>>> m_group_images;
  std::vector<std::shared_ptr<WriteableImage<int>>> m_auto_aperture_images;
  std::vector<std::shared_ptr<WriteableImage<int>>> m_aperture_images;
  std::vector<std::shared_ptr<WriteableImage<SeFloat>>> m_moffat_images;

  std::map<unsigned int, std::shared_ptr<WriteableImage<int>>> m_measurement_aperture_images;
  std::map<unsigned int, std::shared_ptr<WriteableImage<int>>> m_measurement_auto_aperture_images;
  std::map<unsigned int, std::shared_ptr<WriteableImage<MeasurementImage::PixelType>>> m_check_image_model_fitting, m_check_image_psf;
  std::vector<std::map<unsigned int, std::shared_ptr<WriteableImage<float>>>> m_check_image_ml_detection;

  std::vector<std::shared_ptr<DetectionImage>> m_detection_images;
  std::vector<std::shared_ptr<Image<SeFloat>>> m_background_images;
  std::vector<std::shared_ptr<Image<SeFloat>>> m_filtered_images;
  std::vector<std::shared_ptr<Image<SeFloat>>> m_thresholded_images;
  std::vector<std::shared_ptr<Image<SeFloat>>> m_snr_images;
  std::vector<std::shared_ptr<WeightImage>> m_variance_images;


  std::vector<std::shared_ptr<CoordinateSystem>> m_coordinate_systems;

  boost::filesystem::path m_model_fitting_image_filename;
  boost::filesystem::path m_residual_filename;
  boost::filesystem::path m_model_background_filename;
  boost::filesystem::path m_model_variance_filename;
  boost::filesystem::path m_segmentation_filename;
  boost::filesystem::path m_partition_filename;
  boost::filesystem::path m_group_filename;
  boost::filesystem::path m_filtered_filename;
  boost::filesystem::path m_thresholded_filename;
  boost::filesystem::path m_snr_filename;
  boost::filesystem::path m_auto_aperture_filename;
  boost::filesystem::path m_aperture_filename;
  boost::filesystem::path m_moffat_filename;
  boost::filesystem::path m_psf_filename;
  boost::filesystem::path m_ml_detection_filename;

  std::map<boost::filesystem::path, std::tuple<std::shared_ptr<Image<SeFloat>>, bool>> m_custom_images;

  std::map<int, FrameInfo> m_measurement_frames;

  std::mutex m_access_mutex;
};

}



#endif /* _SEIMPLEMENTATION_CHECKIMAGES_CHECKIMAGES_H_ */