Use CheckImages for the debug and residuals

Copy WCS headers, and use the original file name to make it easier to
track.

Author: ayllon

SEImplementation/SEImplementation/CheckImages/CheckImages.h

@@ -33,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;
   }
@@ -67,6 +63,9 @@ class CheckImages : public Configurable {
   std::shared_ptr<WriteableImage<unsigned int>>
   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;
   }
@@ -83,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;
@@ -111,7 +110,6 @@ 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;
@@ -120,6 +118,7 @@ class CheckImages : public Configurable {
   std::shared_ptr<WriteableImage<SeFloat>> m_moffat_image;
   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;

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,15 +62,6 @@ 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.native(),
-        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.native(),
         m_detection_image->getWidth(), m_detection_image->getHeight(), m_coordinate_system);
@@ -158,6 +149,33 @@ CheckImages::getApertureImage(std::shared_ptr<const MeasurementImageFrame> frame
   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;
+}
+
 void CheckImages::saveImages() {
   lock();
 
@@ -182,9 +200,15 @@ void CheckImages::saveImages() {
   }
 
   // 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.native(), 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) {

SEImplementation/src/lib/Plugin/FlexibleModelFitting/FlexibleModelFittingTask.cpp

@@ -323,29 +323,21 @@ void FlexibleModelFittingTask::updateCheckImages(SourceGroupInterface& group,
       auto final_stamp = frame_model.getImage();
 
       auto stamp_rect = group.getProperty<MeasurementFrameGroupRectangle>(frame_index);
-
-      CheckImages::getInstance().lock();
       auto frame = group.begin()->getProperty<MeasurementFrame>(frame_index).getFrame();
 
-      std::stringstream checkimage_id;
-      checkimage_id << m_checkimage_prefix << "_debug_" << frame_id;
-      auto debug_image = CheckImages::getInstance().getWriteableCheckImage(checkimage_id.str(),
-          frame->getSubtractedImage()->getWidth(), frame->getSubtractedImage()->getHeight());
-
-      for (int x=0; x<final_stamp->getWidth(); x++) {
-        for (int y=0; y<final_stamp->getHeight(); y++) {
-          auto x_coord = stamp_rect.getTopLeft().m_x + x;
-          auto y_coord = stamp_rect.getTopLeft().m_y + y;
-          debug_image->setValue(x_coord, y_coord, debug_image->getValue(x_coord, y_coord) + final_stamp->getValue(x,y));
+      auto debug_image = CheckImages::getInstance().getModelFittingImage(frame);
+      if (debug_image) {
+        CheckImages::getInstance().lock();
+        for (int x = 0; x < final_stamp->getWidth(); x++) {
+          for (int y = 0; y < final_stamp->getHeight(); y++) {
+            auto x_coord = stamp_rect.getTopLeft().m_x + x;
+            auto y_coord = stamp_rect.getTopLeft().m_y + y;
+            debug_image->setValue(x_coord, y_coord,
+                                  debug_image->getValue(x_coord, y_coord) + final_stamp->getValue(x, y));
+          }
         }
       }
 
-      auto residual_image = SubtractImage<SeFloat>::create(frame->getSubtractedImage(), debug_image);
-
-      std::stringstream checkimage_residual_id;
-      checkimage_residual_id << m_checkimage_prefix << "_residual_" << frame_id;
-      CheckImages::getInstance().setCustomCheckImage(checkimage_residual_id.str(), residual_image);
-
       CheckImages::getInstance().unlock();
     }
     frame_id++;