Merge pull request #68 from ebertin/feature/mf_checkimages_wcs

Generate check images for the model fitting via CheckImage classes

Author: marcschefer

SEFramework/SEFramework/Frame/Frame.h

@@ -151,6 +151,10 @@ class Frame {
     return sqrt(m_variance_map->getValue(0,0)) * m_detection_threshold;
   }
 
+  std::string getLabel() const {
+    return m_label;
+  }
+
   //
   // Setters
   //
@@ -197,6 +201,10 @@ class Frame {
     m_filtered_variance_map = nullptr;
   }
 
+  void setLabel(const std::string &label) {
+    m_label = label;
+  }
+
 private:
 
   void applyFilter() {
@@ -227,6 +235,8 @@ class Frame {
   std::shared_ptr<Image<T>> m_interpolated_image;
   std::shared_ptr<Image<T>> m_filtered_image;
   std::shared_ptr<Image<T>> m_filtered_variance_map;
+
+  std::string m_label;
 };
 
 using DetectionImageFrame = Frame<DetectionImage::PixelType>;

SEImplementation/SEImplementation/CheckImages/CheckImages.h

@@ -12,12 +12,15 @@
 #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/SubtractImage.h"
 #include "SEFramework/Image/WriteableImage.h"
+#include "SEFramework/Frame/Frame.h"
 
 
 namespace SExtractor {
@@ -30,10 +33,6 @@ class CheckImages : public Configurable {
 
   void saveImages();
 
-  std::shared_ptr<WriteableImage<DetectionImage::PixelType>> getModelFittingCheckImage() const {
-    return m_check_image_model_fitting;
-  }
-
   std::shared_ptr<WriteableImage<unsigned int>> getSegmentationImage() const {
     return m_segmentation_image;
   }
@@ -59,10 +58,13 @@ class CheckImages : public Configurable {
   }
 
   std::shared_ptr<WriteableImage<unsigned int>>
-  getAutoApertureImage(unsigned instance, int width, int height, const std::shared_ptr<CoordinateSystem> &);
+  getAutoApertureImage(std::shared_ptr<const MeasurementImageFrame> frame);
 
   std::shared_ptr<WriteableImage<unsigned int>>
-  getApertureImage(unsigned instance, int width, int height, const std::shared_ptr<CoordinateSystem> &);
+  getApertureImage(std::shared_ptr<const MeasurementImageFrame> frame);
+
+  std::shared_ptr<WriteableImage<MeasurementImage::PixelType>>
+  getModelFittingImage(std::shared_ptr<const MeasurementImageFrame> frame);
 
   void setBackgroundCheckImage(std::shared_ptr<Image<SeFloat>> background_image) {
     m_background_image = background_image;
@@ -80,8 +82,8 @@ class CheckImages : public Configurable {
     m_thresholded_image = thresholded_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);
+  //std::shared_ptr<WriteableImage<SeFloat>> getWriteableCheckImage(std::string id, int width, int height);
+  //void setCustomCheckImage(std::string id, std::shared_ptr<Image<SeFloat>> image);
 
   virtual void reportConfigDependencies(Euclid::Configuration::ConfigManager& manager) const override;
   virtual void configure(Euclid::Configuration::ConfigManager& manager) override;
@@ -108,15 +110,15 @@ class CheckImages : public Configurable {
   static std::unique_ptr<CheckImages> m_instance;
 
   // check image
-  std::shared_ptr<WriteableImage<DetectionImage::PixelType>> m_check_image_model_fitting;
   std::shared_ptr<WriteableImage<unsigned int>> m_segmentation_image;
   std::shared_ptr<WriteableImage<unsigned int>> m_partition_image;
   std::shared_ptr<WriteableImage<unsigned int>> m_group_image;
   std::shared_ptr<WriteableImage<unsigned int>> m_auto_aperture_image;
   std::shared_ptr<WriteableImage<unsigned int>> m_aperture_image;
   std::shared_ptr<WriteableImage<SeFloat>> m_moffat_image;
-  std::map<int, decltype(m_aperture_image)> m_measurement_aperture_images;
-  std::map<int, decltype(m_auto_aperture_image)> m_measurement_auto_aperture_images;
+  std::map<std::shared_ptr<const MeasurementImageFrame>, decltype(m_aperture_image)> m_measurement_aperture_images;
+  std::map<std::shared_ptr<const MeasurementImageFrame>, decltype(m_auto_aperture_image)> m_measurement_auto_aperture_images;
+  std::map<std::shared_ptr<const MeasurementImageFrame>, std::shared_ptr<WriteableImage<MeasurementImage::PixelType>>> m_check_image_model_fitting;
 
   std::shared_ptr<DetectionImage> m_detection_image;
   std::shared_ptr<Image<SeFloat>> m_background_image;
@@ -125,20 +127,20 @@ class CheckImages : public Configurable {
   std::shared_ptr<WeightImage> m_variance_image;
   std::shared_ptr<CoordinateSystem> m_coordinate_system;
 
-  std::string m_model_fitting_image_filename;
-  std::string m_residual_filename;
-  std::string m_model_background_filename;
-  std::string m_model_variance_filename;
-  std::string m_segmentation_filename;
-  std::string m_partition_filename;
-  std::string m_group_filename;
-  std::string m_filtered_filename;
-  std::string m_thresholded_filename;
-  std::string m_auto_aperture_filename;
-  std::string m_aperture_filename;
-  std::string m_moffat_filename;
-
-  std::map<std::string, std::tuple<std::shared_ptr<Image<SeFloat>>, bool>> m_custom_images;
+  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_auto_aperture_filename;
+  boost::filesystem::path m_aperture_filename;
+  boost::filesystem::path m_moffat_filename;
+
+  std::map<boost::filesystem::path, std::tuple<std::shared_ptr<Image<SeFloat>>, bool>> m_custom_images;
 
   std::mutex m_access_mutex;
 };

SEImplementation/SEImplementation/Configuration/DetectionImageConfig.h

@@ -32,7 +32,8 @@ class DetectionImageConfig : public Euclid::Configuration::Configuration {
   std::map<std::string, Configuration::OptionDescriptionList> getProgramOptions() override;
 
   void initialize(const UserValues& args) override;
-  
+
+  std::string getDetectionImagePath() const;
   std::shared_ptr<DetectionImage> getDetectionImage() const;
   std::shared_ptr<CoordinateSystem> getCoordinateSystem() const;
 
@@ -41,6 +42,7 @@ class DetectionImageConfig : public Euclid::Configuration::Configuration {
   int getInterpolationGap() const { return m_interpolation_gap; }
 
 private:
+  std::string m_detection_image_path;
   std::shared_ptr<DetectionImage> m_detection_image;
   std::shared_ptr<CoordinateSystem> m_coordinate_system;
   double m_gain;

SEImplementation/SEImplementation/Plugin/FlexibleModelFitting/FlexibleModelFittingTask.h

@@ -63,8 +63,6 @@ class FlexibleModelFittingTask : public GroupTask {
   std::vector<std::shared_ptr<FlexibleModelFittingParameter>> m_parameters;
   std::vector<std::shared_ptr<FlexibleModelFittingFrame>> m_frames;
   std::vector<std::shared_ptr<FlexibleModelFittingPrior>> m_priors;
-
-  std::string m_checkimage_prefix;
 };
 
 }

SEImplementation/src/lib/CheckImages/CheckImages.cpp

@@ -23,7 +23,7 @@ void CheckImages::reportConfigDependencies(Euclid::Configuration::ConfigManager
   manager.registerConfiguration<CheckImagesConfig>();
 }
 
-std::shared_ptr<WriteableImage<SeFloat>> CheckImages::getWriteableCheckImage(std::string id, int width, int height) {
+/*std::shared_ptr<WriteableImage<SeFloat>> CheckImages::getWriteableCheckImage(std::string id, int width, int height) {
   if (m_custom_images.count(id) != 0) {
     auto image = std::dynamic_pointer_cast<WriteableImage<SeFloat>>(std::get<0>(m_custom_images[id]));
     if (image != nullptr) {
@@ -41,7 +41,7 @@ std::shared_ptr<WriteableImage<SeFloat>> CheckImages::getWriteableCheckImage(std
 
 void CheckImages::setCustomCheckImage(std::string id, std::shared_ptr<Image<SeFloat>> image) {
   m_custom_images[id] = std::make_tuple(image, true);
-}
+}*/
 
 void CheckImages::configure(Euclid::Configuration::ConfigManager& manager) {
   m_detection_image = manager.getConfiguration<DetectionImageConfig>().getDetectionImage();
@@ -62,91 +62,115 @@ void CheckImages::configure(Euclid::Configuration::ConfigManager& manager) {
 
   m_coordinate_system = manager.getConfiguration<DetectionImageConfig>().getCoordinateSystem();
 
-  if (m_model_fitting_image_filename != "") {
-    m_check_image_model_fitting = FitsWriter::newImage<DetectionImage::PixelType>(m_model_fitting_image_filename,
-        m_detection_image->getWidth(), m_detection_image->getHeight(), m_coordinate_system);
-  }
-  else if (m_residual_filename != "") {
-    m_check_image_model_fitting = FitsWriter::newTemporaryImage<DetectionImage::PixelType>(
-      "sextractor_check_model_%%%%%%.fits", m_detection_image->getWidth(), m_detection_image->getHeight());
-  }
-
   if (m_segmentation_filename != "") {
-    m_segmentation_image = FitsWriter::newImage<unsigned int>(m_segmentation_filename,
+    m_segmentation_image = FitsWriter::newImage<unsigned int>(m_segmentation_filename.native(),
         m_detection_image->getWidth(), m_detection_image->getHeight(), m_coordinate_system);
   }
 
   if (m_partition_filename != "") {
-    m_partition_image = FitsWriter::newImage<unsigned int>(m_partition_filename,
+    m_partition_image = FitsWriter::newImage<unsigned int>(m_partition_filename.native(),
         m_detection_image->getWidth(), m_detection_image->getHeight(), m_coordinate_system);
   }
 
   if (m_group_filename != "") {
-    m_group_image = FitsWriter::newImage<unsigned int>(m_group_filename,
+    m_group_image = FitsWriter::newImage<unsigned int>(m_group_filename.native(),
         m_detection_image->getWidth(), m_detection_image->getHeight(), m_coordinate_system);
   }
 
   if (m_auto_aperture_filename != "") {
-    m_auto_aperture_image = FitsWriter::newImage<unsigned int>(m_auto_aperture_filename,
+    m_auto_aperture_image = FitsWriter::newImage<unsigned int>(m_auto_aperture_filename.native(),
         m_detection_image->getWidth(), m_detection_image->getHeight(), m_coordinate_system);
   }
 
   if (m_aperture_filename != "") {
-    m_aperture_image = FitsWriter::newImage<unsigned int>(m_aperture_filename,
+    m_aperture_image = FitsWriter::newImage<unsigned int>(m_aperture_filename.native(),
         m_detection_image->getWidth(), m_detection_image->getHeight(), m_coordinate_system
     );
   }
 
   if (m_moffat_filename != "") {
-    m_moffat_image = FitsWriter::newImage<SeFloat>(m_moffat_filename,
+    m_moffat_image = FitsWriter::newImage<SeFloat>(m_moffat_filename.native(),
         m_detection_image->getWidth(), m_detection_image->getHeight(), m_coordinate_system
     );
   }
 }
 
 std::shared_ptr<WriteableImage<unsigned int>>
-CheckImages::getAutoApertureImage(unsigned instance, int width, int height, const std::shared_ptr<CoordinateSystem> &cs) {
+CheckImages::getAutoApertureImage(std::shared_ptr<const MeasurementImageFrame> frame) {
   if (m_auto_aperture_filename.empty()) {
     return nullptr;
   }
 
   std::lock_guard<std::mutex> lock{m_access_mutex};
 
-  auto i = m_measurement_auto_aperture_images.find(instance);
+  auto i = m_measurement_auto_aperture_images.find(frame);
   if (i == m_measurement_auto_aperture_images.end()) {
-    auto frame_filename = m_auto_aperture_filename + "." + std::to_string(instance);
+    auto filename = m_auto_aperture_filename.stem();
+    filename += "_" + frame->getLabel();
+    filename.replace_extension(m_auto_aperture_filename.extension());
+    auto frame_filename = m_auto_aperture_filename.parent_path() / filename;
     i = m_measurement_auto_aperture_images.emplace(
       std::make_pair(
-        instance,
+        frame,
         FitsWriter::newImage<unsigned int>(
-          frame_filename,
-          width,
-          height,
-          cs
+          frame_filename.native(),
+          frame->getOriginalImage()->getWidth(),
+          frame->getOriginalImage()->getHeight(),
+          frame->getCoordinateSystem()
         ))).first;
   }
   return i->second;
 }
 
 std::shared_ptr<WriteableImage<unsigned int>>
-CheckImages::getApertureImage(unsigned instance, int width, int height, const std::shared_ptr<CoordinateSystem> &cs) {
+CheckImages::getApertureImage(std::shared_ptr<const MeasurementImageFrame> frame) {
   if (m_aperture_filename.empty()) {
     return nullptr;
   }
 
   std::lock_guard<std::mutex> lock{m_access_mutex};
 
-  auto i = m_measurement_aperture_images.find(instance);
+  auto i = m_measurement_aperture_images.find(frame);
   if (i == m_measurement_aperture_images.end()) {
-    auto frame_filename = m_aperture_filename + "." + std::to_string(instance);
+    auto filename = m_aperture_filename.stem();
+    filename += "_" + frame->getLabel();
+    filename.replace_extension(m_aperture_filename.extension());
+    auto frame_filename = m_aperture_filename.parent_path() / filename;
     i = m_measurement_aperture_images.emplace(
       std::make_pair(
-        instance,
+        frame,
         FitsWriter::newImage<unsigned int>(
-          frame_filename,
-          width,
-          height,
-          cs
+          frame_filename.native(),
+          frame->getOriginalImage()->getWidth(),
+          frame->getOriginalImage()->getHeight(),
+          frame->getCoordinateSystem()
+        ))).first;
+  }
+  return i->second;
+}
+
+std::shared_ptr<WriteableImage<MeasurementImage::PixelType>>
+CheckImages::getModelFittingImage(std::shared_ptr<const SExtractor::MeasurementImageFrame> frame) {
+  if (m_model_fitting_image_filename.empty()) {
+    return nullptr;
+  }
+
+  std::lock_guard<std::mutex> lock{m_access_mutex};
+
+  auto i = m_check_image_model_fitting.find(frame);
+  if (i == m_check_image_model_fitting.end()) {
+    auto filename = m_model_fitting_image_filename.stem();
+    filename += "_" + frame->getLabel();
+    filename.replace_extension(m_model_fitting_image_filename.extension());
+    auto frame_filename = m_model_fitting_image_filename.parent_path() / filename;
+    i = m_check_image_model_fitting.emplace(
+      std::make_pair(
+        frame,
+        FitsWriter::newImage<MeasurementImage::PixelType>(
+          frame_filename.native(),
+          frame->getOriginalImage()->getWidth(),
+          frame->getOriginalImage()->getHeight(),
+          frame->getCoordinateSystem()
         ))).first;
   }
   return i->second;
@@ -157,33 +181,42 @@ void CheckImages::saveImages() {
 
   // if possible, save the background image
   if (m_background_image != nullptr && m_model_background_filename != "") {
-    FitsWriter::writeFile(*m_background_image, m_model_background_filename, m_coordinate_system);
+    FitsWriter::writeFile(*m_background_image, m_model_background_filename.native(), m_coordinate_system);
   }
 
   // if possible, save the variance image
   if (m_variance_image != nullptr && m_model_variance_filename != "") {
-    FitsWriter::writeFile(*m_variance_image, m_model_variance_filename, m_coordinate_system);
+    FitsWriter::writeFile(*m_variance_image, m_model_variance_filename.native(), m_coordinate_system);
   }
 
   // if possible, save the filtered image
   if (m_filtered_image != nullptr && m_filtered_filename != "") {
-    FitsWriter::writeFile(*m_filtered_image, m_filtered_filename, m_coordinate_system);
+    FitsWriter::writeFile(*m_filtered_image, m_filtered_filename.native(), m_coordinate_system);
   }
 
   // if possible, save the thresholded image
   if (m_thresholded_image != nullptr && m_thresholded_filename != "") {
-    FitsWriter::writeFile(*m_thresholded_image, m_thresholded_filename, m_coordinate_system);
+    FitsWriter::writeFile(*m_thresholded_image, m_thresholded_filename.native(), m_coordinate_system);
   }
 
   // if possible, create and save the residual image
-  if (m_check_image_model_fitting != nullptr && m_residual_filename != "") {
-    auto residual_image = SubtractImage<SeFloat>::create(m_detection_image, m_check_image_model_fitting);
-    FitsWriter::writeFile(*residual_image, m_residual_filename, m_coordinate_system);
+  if (m_residual_filename != "") {
+    for (auto &ci : m_check_image_model_fitting) {
+      auto residual_image = SubtractImage<SeFloat>::create(ci.first->getSubtractedImage(), ci.second);
+      auto filename = m_residual_filename.stem();
+      filename += "_" + ci.first->getLabel();
+      filename.replace_extension(m_residual_filename.extension());
+      auto frame_filename = m_residual_filename.parent_path() / filename;
+      FitsWriter::writeFile(*residual_image, filename.native(), ci.first->getCoordinateSystem());
+    }
   }
 
   for (auto const& entry : m_custom_images) {
     if (std::get<1>(entry.second)) {
-      FitsWriter::writeFile(*std::get<0>(entry.second), entry.first + ".fits");
+      auto filename = entry.first;
+      if (!filename.has_extension())
+        filename.replace_extension(".fits");
+      FitsWriter::writeFile(*std::get<0>(entry.second), filename.native());
     }
   }