Allow disabling PSF renormalization in model fitting (#597)

marcschefer · web-flow · commit 715e3b170d35 · 2025-03-20T16:27:51.000+01:00
* psf renormalization on/off option WIP

* DownSampledImagePsf renormalization

* propagate renormalization configuration from MeasurementImage

* remove unsued include, fix warnings in MoffatModelFitting

* propagate config for and fix DownsampledPsf
diff --git a/SEImplementation/SEImplementation/Configuration/MeasurementImageConfig.h b/SEImplementation/SEImplementation/Configuration/MeasurementImageConfig.h
@@ -65,6 +65,8 @@ class MeasurementImageConfig : public Euclid::Configuration::Configuration {
     bool m_is_data_cube;
     int m_image_layer;
     int m_weight_layer;
+
+    bool m_psf_renormalize;
   };
 
   explicit MeasurementImageConfig(long manager_id);
diff --git a/SEImplementation/SEImplementation/Image/DownSampledImagePsf.h b/SEImplementation/SEImplementation/Image/DownSampledImagePsf.h
@@ -41,11 +41,13 @@ namespace SourceXtractor {
 class DownSampledImagePsf {
 public:
 
-  DownSampledImagePsf(double pixel_scale, std::shared_ptr<VectorImage<SeFloat>> image, double down_scaling=1.0);
+  DownSampledImagePsf(double pixel_scale, std::shared_ptr<VectorImage<SeFloat>> image,
+      double down_scaling=1.0, bool normalize_psf = true);
 
   virtual ~DownSampledImagePsf() = default;
 
   double getPixelScale() const;
+
   std::size_t getSize() const;
   std::shared_ptr<VectorImage<SourceXtractor::SeFloat>> getScaledKernel(SeFloat scale) const;
   void convolve(std::shared_ptr<WriteableImage<float>> image) const;
@@ -57,6 +59,7 @@ class DownSampledImagePsf {
 private:
   double m_down_scaling;
   std::shared_ptr<ImagePsf> m_psf;
+  bool m_normalize_psf { true };
 };
 
 } // end of SourceXtractor
diff --git a/SEImplementation/SEImplementation/Plugin/FlexibleModelFitting/FlexibleModelFittingIterativeTask.h b/SEImplementation/SEImplementation/Plugin/FlexibleModelFitting/FlexibleModelFittingIterativeTask.h
@@ -32,6 +32,8 @@
 #include "SEImplementation/Plugin/FlexibleModelFitting/FlexibleModelFittingFrame.h"
 #include "SEImplementation/Plugin/FlexibleModelFitting/FlexibleModelFittingPrior.h"
 
+#include "SEImplementation/Image/DownSampledImagePsf.h"
+
 namespace SourceXtractor {
 
 class FlexibleModelFittingIterativeTask : public GroupTask {
@@ -54,6 +56,7 @@ class FlexibleModelFittingIterativeTask : public GroupTask {
       std::vector<std::shared_ptr<FlexibleModelFittingParameter>> parameters,
       std::vector<std::shared_ptr<FlexibleModelFittingFrame>> frames,
       std::vector<std::shared_ptr<FlexibleModelFittingPrior>> priors,
+      std::vector<bool> should_renormalize,
       double scale_factor=1.0,
       int meta_iterations=3,
       double deblend_factor=1.0,
@@ -129,6 +132,11 @@ class FlexibleModelFittingIterativeTask : public GroupTask {
   PixelRectangle clipFittingRect(PixelRectangle fitting_rect, SourceInterface& source, int frame_index) const;
   PixelRectangle getUnclippedFittingRect(SourceInterface& source, int frame_index) const;
 
+  ModelFitting::FrameModel<DownSampledImagePsf, std::shared_ptr<VectorImage<SourceXtractor::SeFloat>>> createFrameModel(
+      SourceInterface& source, double pixel_scale, FlexibleModelFittingParameterManager& manager,
+      std::shared_ptr<FlexibleModelFittingFrame> frame, PixelRectangle stamp_rect, double down_scaling=1.0) const;
+
+
   // Task configuration
   std::string m_least_squares_engine;
   unsigned int m_max_iterations;
@@ -143,6 +151,7 @@ class FlexibleModelFittingIterativeTask : public GroupTask {
   std::vector<std::shared_ptr<FlexibleModelFittingFrame>> m_frames;
   std::vector<std::shared_ptr<FlexibleModelFittingPrior>> m_priors;
 
+  std::vector<bool> m_should_renormalize;
   WindowType m_window_type { WindowType::RECTANGLE };
   double m_ellipse_scale = 3.0;
 };
diff --git a/SEImplementation/SEImplementation/Plugin/FlexibleModelFitting/FlexibleModelFittingTaskFactory.h b/SEImplementation/SEImplementation/Plugin/FlexibleModelFitting/FlexibleModelFittingTaskFactory.h
@@ -62,6 +62,9 @@ class FlexibleModelFittingTaskFactory : public TaskFactory {
 
   double m_scale_factor {1.0};
   double m_max_fit_size {100};
+
+  // should we renormalize the PSF for each frame?
+  std::vector<bool> m_should_renormalize;
 };
 
 }
diff --git a/SEImplementation/SEImplementation/Plugin/SourcePsf/SourcePsfTask.h b/SEImplementation/SEImplementation/Plugin/SourcePsf/SourcePsfTask.h
@@ -27,7 +27,9 @@ class SourcePsfTask: public SourceTask {
 public:
   virtual ~SourcePsfTask() = default;
 
-  SourcePsfTask(unsigned instance, const std::shared_ptr<Psf> &vpsf);
+  SourcePsfTask(unsigned instance, const std::shared_ptr<Psf>& vpsf, bool normalize_psf = true)
+      : m_instance(instance), m_vpsf(vpsf), m_normalize_psf(normalize_psf) {
+  }
 
   void computeProperties(SourceInterface& source) const override;
 
@@ -37,6 +39,7 @@ class SourcePsfTask: public SourceTask {
 private:
   unsigned m_instance;
   std::shared_ptr<Psf> m_vpsf;
+  bool m_normalize_psf { true };
 };
 
 } // end SourceXtractor
diff --git a/SEImplementation/SEImplementation/Plugin/SourcePsf/SourcePsfTaskFactory.h b/SEImplementation/SEImplementation/Plugin/SourcePsf/SourcePsfTaskFactory.h
@@ -37,7 +37,13 @@ class SourcePsfTaskFactory: public TaskFactory {
   std::shared_ptr<Task> createTask(const PropertyId& property_id) const override;
 
 private:
-  std::map<int, std::shared_ptr<Psf>> m_vpsf;
+
+  struct PsfInfo {
+    std::shared_ptr<Psf> m_psf;
+    bool m_normalize_psf;
+  };
+
+  std::map<int, PsfInfo> m_psf_infos;
 };
 
 } // end SourceXtractor
diff --git a/SEImplementation/SEImplementation/PythonConfig/PyMeasurementImage.h b/SEImplementation/SEImplementation/PythonConfig/PyMeasurementImage.h
@@ -54,6 +54,8 @@ class PyMeasurementImage : public PyId {
   bool is_data_cube;
   int image_layer;
   int weight_layer;
+
+  bool psf_renormalize;
 };
 
 }
diff --git a/SEImplementation/python/sourcextractor/config/measurement_images.py b/SEImplementation/python/sourcextractor/config/measurement_images.py
@@ -107,6 +107,8 @@ class MeasurementImage(cpp.MeasurementImage):
         For multi-extension FITS file specifies the HDU number for the psf. Defaults to the same value as image_hdu
     weight_hdu : int
         For multi-extension FITS file specifies the HDU number for the weight. Defaults to the same value as image_hdu
+    psf_renormalize : bool
+        If True, the PSF will be renormalized to have a total flux of 1.0. Default True
     """
 
     def _set_checked(self, attr_name, value):
@@ -122,7 +124,7 @@ def __init__(self, fits_file, psf_file=None, weight_file=None, gain=None,
                  flux_scale=None, flux_scale_keyword='FLXSCALE',
                  weight_type='none', weight_absolute=False, weight_scaling=1.,
                  weight_threshold=None, constant_background=None,
-                 image_hdu=0, psf_hdu=None, weight_hdu=None
+                 image_hdu=0, psf_hdu=None, weight_hdu=None, psf_renormalize=True
                  ):
         """
         Constructor.
@@ -201,6 +203,8 @@ def __init__(self, fits_file, psf_file=None, weight_file=None, gain=None,
             self._set_checked('weight_hdu', image_hdu)
         else:
             self._set_checked('weight_hdu', weight_hdu)
+            
+        self.psf_renormalize = psf_renormalize
 
     def __str__(self):
         """
diff --git a/SEImplementation/src/lib/Configuration/MeasurementImageConfig.cpp b/SEImplementation/src/lib/Configuration/MeasurementImageConfig.cpp
@@ -220,6 +220,8 @@ void MeasurementImageConfig::initialize(const UserValues&) {
       info.m_psf_hdu = py_image.psf_hdu + 1;
       info.m_weight_hdu = py_image.weight_hdu + 1;
 
+      info.m_psf_renormalize = py_image.psf_renormalize;
+
       m_image_infos.emplace_back(std::move(info));
     }
   } else {
@@ -252,10 +254,14 @@ void MeasurementImageConfig::initialize(const UserValues&) {
 
       0, // id
 
-      1,1,1 // HDUs
-    });
+      1,1,1, // HDUs
 
+      false, // is_data_cube
+      0, // image_layer
+      0, // weight_layer
 
+      true // psf_renormalize
+    });
   }
 }
 
diff --git a/SEImplementation/src/lib/Image/DownSampledImagePsf.cpp b/SEImplementation/src/lib/Image/DownSampledImagePsf.cpp
@@ -30,8 +30,8 @@
 namespace SourceXtractor {
 
 DownSampledImagePsf::DownSampledImagePsf(
-    double pixel_scale, std::shared_ptr<VectorImage<SeFloat>> image, double down_scaling)
-    : m_down_scaling(down_scaling) {
+    double pixel_scale, std::shared_ptr<VectorImage<SeFloat>> image, double down_scaling, bool normalize_psf)
+    : m_down_scaling(down_scaling), m_normalize_psf(normalize_psf)  {
   if (image != nullptr) {
     using Traits = ::ModelFitting::ImageTraits<std::shared_ptr<VectorImage<SeFloat>>>;
 
@@ -52,9 +52,18 @@ DownSampledImagePsf::DownSampledImagePsf(
       Traits::addImageToImage(new_image, image, down_scaling, new_size / 2.0, new_size / 2.0);
 
       // renormalize psf
-      auto psf_sum = std::accumulate(new_image->getData().begin(), new_image->getData().end(), 0.);
-      for (auto& pixel : new_image->getData()) {
-        pixel /= psf_sum;
+      if (m_normalize_psf) {
+        auto psf_sum = std::accumulate(new_image->getData().begin(), new_image->getData().end(), 0.);
+        for (auto& pixel : new_image->getData()) {
+          pixel /= psf_sum;
+        }
+      } else {
+        auto original_psf_sum = std::accumulate(image->getData().begin(), image->getData().end(), 0.);
+        auto new_psf_sum = std::accumulate(new_image->getData().begin(), new_image->getData().end(), 0.);
+
+        for (auto& pixel : new_image->getData()) {
+          pixel *= original_psf_sum / new_psf_sum;
+        }
       }
 
       m_psf = std::make_shared<ImagePsf>(pixel_scale / down_scaling, new_image);
diff --git a/SEImplementation/src/lib/Plugin/FlexibleModelFitting/FlexibleModelFittingIterativeTask.cpp b/SEImplementation/src/lib/Plugin/FlexibleModelFitting/FlexibleModelFittingIterativeTask.cpp
@@ -21,7 +21,6 @@
 #include "ModelFitting/Engine/LeastSquareEngineManager.h"
 
 #include "SEImplementation/Image/ImagePsf.h"
-#include "SEImplementation/Image/DownSampledImagePsf.h"
 #include "SEImplementation/Image/VectorImageDataVsModelInputTraits.h"
 
 #include "SEImplementation/CheckImages/CheckImages.h"
@@ -54,6 +53,7 @@ FlexibleModelFittingIterativeTask::FlexibleModelFittingIterativeTask(const std::
     std::vector<std::shared_ptr<FlexibleModelFittingParameter>> parameters,
     std::vector<std::shared_ptr<FlexibleModelFittingFrame>> frames,
     std::vector<std::shared_ptr<FlexibleModelFittingPrior>> priors,
+    std::vector<bool> should_renormalize,
     double scale_factor,
     int meta_iterations,
     double deblend_factor,
@@ -66,8 +66,8 @@ FlexibleModelFittingIterativeTask::FlexibleModelFittingIterativeTask(const std::
       m_modified_chi_squared_scale(modified_chi_squared_scale), m_scale_factor(scale_factor),
       m_meta_iterations(meta_iterations), m_deblend_factor(deblend_factor), m_meta_iteration_stop(meta_iteration_stop),
       m_max_fit_size(max_fit_size * max_fit_size), m_parameters(parameters), m_frames(frames), m_priors(priors),
-      m_window_type(window_type), m_ellipse_scale(ellipse_scale) {
-}
+      m_should_renormalize(should_renormalize),
+      m_window_type(window_type), m_ellipse_scale(ellipse_scale) {}
 
 FlexibleModelFittingIterativeTask::~FlexibleModelFittingIterativeTask() {
 }
@@ -249,11 +249,10 @@ std::shared_ptr<VectorImage<SeFloat>> FlexibleModelFittingIterativeTask::createI
 }
 
 
-namespace {
-
-FrameModel<DownSampledImagePsf, std::shared_ptr<VectorImage<SourceXtractor::SeFloat>>> createFrameModel(
+FrameModel<DownSampledImagePsf, std::shared_ptr<VectorImage<SourceXtractor::SeFloat>>>
+FlexibleModelFittingIterativeTask::createFrameModel(
     SourceInterface& source, double pixel_scale, FlexibleModelFittingParameterManager& manager,
-    std::shared_ptr<FlexibleModelFittingFrame> frame, PixelRectangle stamp_rect, double down_scaling=1.0) {
+    std::shared_ptr<FlexibleModelFittingFrame> frame, PixelRectangle stamp_rect, double down_scaling) const {
 
   int frame_index = frame->getFrameNb();
 
@@ -267,7 +266,8 @@ FrameModel<DownSampledImagePsf, std::shared_ptr<VectorImage<SourceXtractor::SeFl
   // It will be used to compute the rastering grid size, and after convolving with the PSF the result will be
   // downscaled before copied into the frame image.
   // We can multiply here then, as the unit is pixel/pixel, rather than "/pixel or similar
-  auto source_psf = DownSampledImagePsf(psf_property.getPixelSampling(), psf_property.getPsf(), down_scaling);
+  auto source_psf = DownSampledImagePsf(psf_property.getPixelSampling(), psf_property.getPsf(),
+      down_scaling, m_should_renormalize[frame_index]);
 
   std::vector<ConstantModel> constant_models;
   std::vector<PointModel> point_models;
@@ -287,8 +287,6 @@ FrameModel<DownSampledImagePsf, std::shared_ptr<VectorImage<SourceXtractor::SeFl
   return frame_model;
 }
 
-}
-
 std::shared_ptr<VectorImage<SeFloat>> FlexibleModelFittingIterativeTask::createWeightImage(
     SourceInterface& source, int frame_index) const {
   const auto& frame_images = source.getProperty<MeasurementFrameImages>(frame_index);
@@ -904,5 +902,3 @@ SeFloat FlexibleModelFittingIterativeTask::computeChiSquared(SourceGroupInterfac
 
 }
 
-
-
diff --git a/SEImplementation/src/lib/Plugin/FlexibleModelFitting/FlexibleModelFittingTaskFactory.cpp b/SEImplementation/src/lib/Plugin/FlexibleModelFitting/FlexibleModelFittingTaskFactory.cpp
@@ -30,6 +30,7 @@
 #include "SEImplementation/Configuration/ModelFittingConfig.h"
 
 #include "SEImplementation/Configuration/SamplingConfig.h"
+#include "SEImplementation/Configuration/MeasurementImageConfig.h"
 
 namespace SourceXtractor {
 
@@ -39,7 +40,7 @@ std::shared_ptr<Task> FlexibleModelFittingTaskFactory::createTask(const Property
   if (property_id == PropertyId::create<FlexibleModelFitting>()) {
     if (m_use_iterative_fitting) {
       return std::make_shared<FlexibleModelFittingIterativeTask>(m_least_squares_engine, m_max_iterations,
-          m_modified_chi_squared_scale, m_parameters, m_frames, m_priors, m_scale_factor,
+          m_modified_chi_squared_scale, m_parameters, m_frames, m_priors, m_should_renormalize, m_scale_factor,
           m_meta_iterations, m_deblend_factor, m_meta_iteration_stop, m_max_fit_size, m_window_type, m_ellipse_scale);
     } else {
       return std::make_shared<FlexibleModelFittingTask>(m_least_squares_engine, m_max_iterations,
@@ -52,6 +53,8 @@ std::shared_ptr<Task> FlexibleModelFittingTaskFactory::createTask(const Property
 
 void FlexibleModelFittingTaskFactory::reportConfigDependencies(Euclid::Configuration::ConfigManager& manager) const {
   manager.registerConfiguration<ModelFittingConfig>();
+  manager.registerConfiguration<SamplingConfig>();
+  manager.registerConfiguration<MeasurementImageConfig>();
 }
 
 void FlexibleModelFittingTaskFactory::configure(Euclid::Configuration::ConfigManager& manager) {
@@ -94,6 +97,11 @@ void FlexibleModelFittingTaskFactory::configure(Euclid::Configuration::ConfigMan
 
   m_scale_factor = sampling_config.getScaleFactor();
   m_max_fit_size = sampling_config.getMaxFitSize();
+
+  const auto& image_infos = manager.getConfiguration<MeasurementImageConfig>().getImageInfos();
+  for (const auto& info : image_infos) {
+    m_should_renormalize.push_back(info.m_psf_renormalize);
+  }
 }
 
 void FlexibleModelFittingTaskFactory::registerPropertyInstances(OutputRegistry& registry) {
diff --git a/SEImplementation/src/lib/Plugin/MoffatModelFitting/MoffatModelFittingTask.cpp b/SEImplementation/src/lib/Plugin/MoffatModelFitting/MoffatModelFittingTask.cpp
@@ -29,7 +29,6 @@
 #include <mutex>
 
 #include "AlexandriaKernel/memory_tools.h"
-#include "SEImplementation/Plugin/Psf/PsfProperty.h"
 #include "SEImplementation/Plugin/MoffatModelFitting/MoffatModelFitting.h"
 #include "SEImplementation/Plugin/MoffatModelFitting/MoffatModelFittingTask.h"
 #include "ElementsKernel/PathSearch.h"
@@ -260,16 +259,16 @@ void MoffatModelFittingTask::computeProperties(SourceInterface& source) const {
   {
 
     // renders an image of the model for a single source with the final parameters
-    std::vector<std::shared_ptr<ModelFitting::ExtendedModel<ImageInterfaceTypePtr>>> extended_models{};
-    std::vector<PointModel> point_models{};
-    std::vector<ConstantModel> constant_models{};
-    source_model->createModels(extended_models, point_models);
+    std::vector<std::shared_ptr<ModelFitting::ExtendedModel<ImageInterfaceTypePtr>>> tmp_extended_models{};
+    std::vector<PointModel> tmp_point_models{};
+    std::vector<ConstantModel> tmp_constant_models{};
+    source_model->createModels(tmp_extended_models, tmp_point_models);
     FrameModel<NullPsf<VectorImageType>, VectorImageType> frame_model_after{1,
                                                                             (size_t)source_stamp.getWidth(),
                                                                             (size_t)source_stamp.getHeight(),
-                                                                            std::move(constant_models),
-                                                                            std::move(point_models),
-                                                                            std::move(extended_models)};
+                                                                            std::move(tmp_constant_models),
+                                                                            std::move(tmp_point_models),
+                                                                            std::move(tmp_extended_models)};
     auto                                                  final_image = frame_model_after.getImage();
 
     // integrates the flux for that source
diff --git a/SEImplementation/src/lib/Plugin/SourcePsf/SourcePsfTask.cpp b/SEImplementation/src/lib/Plugin/SourcePsf/SourcePsfTask.cpp
@@ -45,10 +45,6 @@ std::map<std::string, SourcePsfTask::ValueGetter> SourcePsfTask::component_value
   {"YMODEL_IMAGE", getCoordY}
 };
 
-SourcePsfTask::SourcePsfTask(unsigned instance, const std::shared_ptr<Psf> &vpsf)
-    : m_instance(instance), m_vpsf(vpsf) {
-}
-
 void SourcePsfTask::computeProperties(SourceXtractor::SourceInterface &source) const {
   if (m_vpsf != nullptr) {
     std::vector<double> component_values;
@@ -57,11 +53,14 @@ void SourcePsfTask::computeProperties(SourceXtractor::SourceInterface &source) c
       component_values.push_back(component_value_getters[component](source, m_instance));
     }
 
-    auto psf = m_vpsf->getPsf(component_values);
-    // The result may not be normalized!
-    auto psf_sum = std::accumulate(psf->getData().begin(), psf->getData().end(), 0.);
-    auto psf_normalized = VectorImage<SeFloat>::create(*MultiplyImage<SeFloat>::create(psf, 1. / psf_sum));
-    source.setIndexedProperty<SourcePsfProperty>(m_instance, m_vpsf->getPixelSampling(), psf_normalized);
+    std::shared_ptr<VectorImage<SeFloat>> psf = m_vpsf->getPsf(component_values);
+
+    if (m_normalize_psf) {
+      // The result may not be normalized!
+      auto psf_sum = std::accumulate(psf->getData().begin(), psf->getData().end(), 0.);
+      psf = VectorImage<SeFloat>::create(*MultiplyImage<SeFloat>::create(psf, 1. / psf_sum));
+    }
+    source.setIndexedProperty<SourcePsfProperty>(m_instance, m_vpsf->getPixelSampling(), psf);
 
     // Check image
     auto check_image = CheckImages::getInstance().getPsfImage(m_instance);
@@ -70,7 +69,7 @@ void SourcePsfTask::computeProperties(SourceXtractor::SourceInterface &source) c
       auto y = component_value_getters["Y_IMAGE"](source, m_instance);
 
       ModelFitting::ImageTraits<ModelFitting::WriteableInterfaceTypePtr>::addImageToImage(
-        check_image, psf_normalized, m_vpsf->getPixelSampling(), x, y);
+        check_image, psf, m_vpsf->getPixelSampling(), x, y);
     }
   } else {
     source.setIndexedProperty<SourcePsfProperty>(m_instance, 1.0, nullptr);
diff --git a/SEImplementation/src/lib/Plugin/SourcePsf/SourcePsfTaskFactory.cpp b/SEImplementation/src/lib/Plugin/SourcePsf/SourcePsfTaskFactory.cpp
diff --git a/SEImplementation/src/lib/PythonConfig/PyMeasurementImage.cpp b/SEImplementation/src/lib/PythonConfig/PyMeasurementImage.cpp
diff --git a/SEImplementation/src/lib/PythonConfig/PythonModule.cpp b/SEImplementation/src/lib/PythonConfig/PythonModule.cpp
diff --git a/SEImplementation/tests/src/Plugin/MoffatModelFitting/MoffatModelFitting_test.cpp b/SEImplementation/tests/src/Plugin/MoffatModelFitting/MoffatModelFitting_test.cpp

Original file line number	Diff line number	Diff line change
`@@ -62,6 +62,9 @@ class FlexibleModelFittingTaskFactory : public TaskFactory {`
`62`	`62`
`63`	`63`	`double m_scale_factor {1.0};`
`64`	`64`	`double m_max_fit_size {100};`
	`65`	`+`
	`66`	`+ // should we renormalize the PSF for each frame?`
	`67`	`+ std::vector<bool> m_should_renormalize;`
`65`	`68`	`};`
`66`	`69`
`67`	`70`	`}`
Original file line number	Diff line number	Diff line change
`@@ -54,6 +54,8 @@ class PyMeasurementImage : public PyId {`
`54`	`54`	`bool is_data_cube;`
`55`	`55`	`int image_layer;`
`56`	`56`	`int weight_layer;`
	`57`	`+`
	`58`	`+ bool psf_renormalize;`
`57`	`59`	`};`
`58`	`60`
`59`	`61`	`}`
Original file line number	Diff line number	Diff line change
`@@ -220,6 +220,8 @@ void MeasurementImageConfig::initialize(const UserValues&) {`
`220`	`220`	`info.m_psf_hdu = py_image.psf_hdu + 1;`
`221`	`221`	`info.m_weight_hdu = py_image.weight_hdu + 1;`
`222`	`222`
	`223`	`+ info.m_psf_renormalize = py_image.psf_renormalize;`
	`224`	`+`
`223`	`225`	`m_image_infos.emplace_back(std::move(info));`
`224`	`226`	`}`
`225`	`227`	`} else {`
`@@ -252,10 +254,14 @@ void MeasurementImageConfig::initialize(const UserValues&) {`
`252`	`254`
`253`	`255`	`0, // id`
`254`	`256`
`255`		`- 1,1,1 // HDUs`
`256`		`- });`
	`257`	`+ 1,1,1, // HDUs`
`257`	`258`
	`259`	`+ false, // is_data_cube`
	`260`	`+ 0, // image_layer`
	`261`	`+ 0, // weight_layer`
`258`	`262`
	`263`	`+ true // psf_renormalize`
	`264`	`+ });`
`259`	`265`	`}`
`260`	`266`	`}`
`261`	`267`