SourceXtractorPlusPlus  0.16
Please provide a description of the project.
CheckImages.cpp
Go to the documentation of this file.
1 
17 /*
18  * CheckImages.cpp
19  *
20  * Created on: May 30, 2017
21  * Author: mschefer
22  */
23 
30 
32 
33 namespace SourceXtractor {
34 
36 
38 }
39 
45 }
46 
48  if (m_custom_images.count(id) != 0) {
49  auto image = std::dynamic_pointer_cast<WriteableImage<SeFloat>>(std::get<0>(m_custom_images[id]));
50  if (image != nullptr) {
51  return image;
52  }
53  }
54 
55 
56  auto image = FitsWriter::newImage<SeFloat>(id + ".fits",
57  width, height);
58  m_custom_images[id] = std::make_tuple(image, false);
59 
60  return image;
61 }
62 
64  m_custom_images[id] = std::make_tuple(image, true);
65 }
66 
68  m_detection_image = manager.getConfiguration<DetectionImageConfig>().getDetectionImage();
69  auto& config = manager.getConfiguration<CheckImagesConfig>();
70 
71  m_model_fitting_image_filename = config.getModelFittingImageFilename();
72  m_residual_filename = config.getModelFittingResidualFilename();
73  m_model_background_filename = config.getModelBackgroundFilename();
74  m_model_variance_filename = config.getModelVarianceFilename();
75  m_segmentation_filename = config.getSegmentationFilename();
76  m_partition_filename = config.getPartitionFilename();
77  m_group_filename = config.getGroupFilename();
78  m_filtered_filename = config.getFilteredFilename();
79  m_thresholded_filename = config.getThresholdedFilename();
80  m_snr_filename = config.getSnrFilename();
81  m_auto_aperture_filename = config.getAutoApertureFilename();
82  m_aperture_filename = config.getApertureFilename();
83  m_moffat_filename = config.getMoffatFilename();
84  m_psf_filename = config.getPsfFilename();
85  m_ml_detection_filename = config.getMLDetectionFilename();
86 
87  m_coordinate_system = manager.getConfiguration<DetectionImageConfig>().getCoordinateSystem();
88 
89  if (m_segmentation_filename != "") {
90  m_segmentation_image = FitsWriter::newImage<int>(m_segmentation_filename.native(),
91  m_detection_image->getWidth(), m_detection_image->getHeight(), m_coordinate_system);
92  }
93 
94  if (m_partition_filename != "") {
95  m_partition_image = FitsWriter::newImage<int>(m_partition_filename.native(),
96  m_detection_image->getWidth(), m_detection_image->getHeight(), m_coordinate_system);
97  }
98 
99  if (m_group_filename != "") {
100  m_group_image = FitsWriter::newImage<int>(m_group_filename.native(),
101  m_detection_image->getWidth(), m_detection_image->getHeight(), m_coordinate_system);
102  }
103 
104  if (m_auto_aperture_filename != "") {
105  m_auto_aperture_image = FitsWriter::newImage<int>(m_auto_aperture_filename.native(),
106  m_detection_image->getWidth(), m_detection_image->getHeight(), m_coordinate_system);
107  }
108 
109  if (m_aperture_filename != "") {
110  m_aperture_image = FitsWriter::newImage<int>(m_aperture_filename.native(),
111  m_detection_image->getWidth(), m_detection_image->getHeight(), m_coordinate_system
112  );
113  }
114 
115  if (m_moffat_filename != "") {
116  m_moffat_image = FitsWriter::newImage<SeFloat>(m_moffat_filename.native(),
117  m_detection_image->getWidth(), m_detection_image->getHeight(), m_coordinate_system
118  );
119  }
120 
121  // Measurement images
122  const auto& measurement_images_info = manager.getConfiguration<MeasurementImageConfig>().getImageInfos();
123  const auto& frames = manager.getConfiguration<MeasurementFrameConfig>().getFrames();
124  for (auto& info : measurement_images_info) {
125  std::stringstream label;
126  label << boost::filesystem::basename(info.m_path) << "_" << info.m_image_hdu;
127 
128  m_measurement_frames[info.m_id] = FrameInfo {
129  label.str(),
130  info.m_measurement_image->getWidth(),
131  info.m_measurement_image->getHeight(),
132  info.m_coordinate_system,
133  frames.at(info.m_id)->getImage(LayerSubtractedImage)
134  };
135  }
136 }
137 
139  if (m_auto_aperture_filename.empty()) {
140  return nullptr;
141  }
142 
144 
145  auto i = m_measurement_auto_aperture_images.find(frame_number);
147  auto& frame_info = m_measurement_frames.at(frame_number);
148  auto filename = m_auto_aperture_filename.stem();
149  filename += "_" + frame_info.m_label;
150  filename += m_auto_aperture_filename.extension();
151  auto frame_filename = m_auto_aperture_filename.parent_path() / filename;
154  frame_number,
155  FitsWriter::newImage<int>(
156  frame_filename.native(),
157  frame_info.m_width,
158  frame_info.m_height,
159  frame_info.m_coordinate_system
160  ))).first;
161  }
162  return LockedWriteableImage<int>::create(i->second);
163 }
164 
166  if (m_aperture_filename.empty()) {
167  return nullptr;
168  }
169 
171 
172  auto i = m_measurement_aperture_images.find(frame_number);
173  if (i == m_measurement_aperture_images.end()) {
174  auto& frame_info = m_measurement_frames.at(frame_number);
175  auto filename = m_aperture_filename.stem();
176  filename += "_" + frame_info.m_label;
177  filename += m_aperture_filename.extension();
178  auto frame_filename = m_aperture_filename.parent_path() / filename;
181  frame_number,
182  FitsWriter::newImage<int>(
183  frame_filename.native(),
184  frame_info.m_width,
185  frame_info.m_height,
186  frame_info.m_coordinate_system
187  ))).first;
188  }
189  return LockedWriteableImage<int>::create(i->second);
190 }
191 
193 CheckImages::getModelFittingImage(unsigned int frame_number) {
194  if (m_model_fitting_image_filename.empty() && m_residual_filename.empty()) {
195  return nullptr;
196  }
197 
199 
200  auto i = m_check_image_model_fitting.find(frame_number);
201  if (i == m_check_image_model_fitting.end()) {
202  auto& frame_info = m_measurement_frames.at(frame_number);
204 
205  if (m_model_fitting_image_filename.empty()) {
206  writeable_image = FitsWriter::newTemporaryImage<DetectionImage::PixelType>(
207  "sourcextractor_check_model_%%%%%%.fits",
208  frame_info.m_width, frame_info.m_height
209  );
210  } else {
212  filename += "_" + frame_info.m_label;
214  auto frame_filename = m_model_fitting_image_filename.parent_path() / filename;
215  writeable_image = FitsWriter::newImage<MeasurementImage::PixelType>(
216  frame_filename.native(),
217  frame_info.m_width,
218  frame_info.m_height,
219  frame_info.m_coordinate_system
220  );
221  }
222  i = m_check_image_model_fitting.emplace(std::make_pair(frame_number, writeable_image)).first;
223  }
225 }
226 
228  if (m_psf_filename.empty()) {
229  return nullptr;
230  }
231 
233 
234  auto i = m_check_image_psf.find(frame_number);
235  if (i == m_check_image_psf.end()) {
236  auto& frame_info = m_measurement_frames.at(frame_number);
237  auto filename = m_psf_filename.stem();
238  filename += "_" + frame_info.m_label;
239  filename += m_psf_filename.extension();
240  auto frame_filename = m_psf_filename.parent_path() / filename;
241  i = m_check_image_psf.emplace(
243  frame_number,
244  FitsWriter::newImage<MeasurementImage::PixelType>(
245  frame_filename.native(),
246  frame_info.m_width,
247  frame_info.m_height,
248  frame_info.m_coordinate_system
249  ))).first;
250  }
252 }
253 
255  if (m_ml_detection_filename.empty()) {
256  return nullptr;
257  }
258 
260 
261  auto i = m_check_image_ml_detection.find(plane_number);
262  if (i == m_check_image_ml_detection.end()) {
263  auto filename = m_ml_detection_filename.stem();
264  filename += "_" + std::to_string(plane_number);
265  filename += m_ml_detection_filename.extension();
266  auto frame_filename = m_ml_detection_filename.parent_path() / filename;
267  i = m_check_image_ml_detection.emplace(
269  plane_number,
270  FitsWriter::newImage<MeasurementImage::PixelType>(
271  frame_filename.native(),
272  m_detection_image->getWidth(),
273  m_detection_image->getHeight(),
275  ))).first;
276  }
278 }
279 
282 
283  // if possible, save the background image
284  if (m_background_image != nullptr && m_model_background_filename != "") {
285  FitsWriter::writeFile(*m_background_image, m_model_background_filename.native(), m_coordinate_system);
286  }
287 
288  // if possible, save the variance image
289  if (m_variance_image != nullptr && m_model_variance_filename != "") {
290  FitsWriter::writeFile(*m_variance_image, m_model_variance_filename.native(), m_coordinate_system);
291  }
292 
293  // if possible, save the filtered image
294  if (m_filtered_image != nullptr && m_filtered_filename != "") {
295  FitsWriter::writeFile(*m_filtered_image, m_filtered_filename.native(), m_coordinate_system);
296  }
297 
298  // if possible, save the thresholded image
299  if (m_thresholded_image != nullptr && m_thresholded_filename != "") {
300  FitsWriter::writeFile(*m_thresholded_image, m_thresholded_filename.native(), m_coordinate_system);
301  }
302 
303  // if possible, save the SNR image
304  if (m_snr_image != nullptr && m_snr_filename != "") {
305  FitsWriter::writeFile(*m_snr_image, m_snr_filename.native(), m_coordinate_system);
306  }
307 
308  // if possible, create and save the residual image
309  if (m_residual_filename != "") {
310  for (auto &ci : m_check_image_model_fitting) {
311  auto& frame_info = m_measurement_frames.at(ci.first);
312 
313  auto residual_image = SubtractImage<SeFloat>::create(frame_info.m_subtracted_image, ci.second);
314  auto filename = m_residual_filename.stem();
315  filename += "_" + frame_info.m_label;
316  filename += m_residual_filename.extension();
317  auto frame_filename = m_residual_filename.parent_path() / filename;
318  FitsWriter::writeFile(*residual_image, frame_filename.native(), frame_info.m_coordinate_system);
319  }
320  }
321 
322  for (auto const& entry : m_custom_images) {
323  if (std::get<1>(entry.second)) {
324  auto filename = entry.first;
325  if (!filename.has_extension()) {
326  filename += ".fits";
327  }
328  FitsWriter::writeFile(*std::get<0>(entry.second), filename.native());
329  }
330  }
331 }
332 
333 }
boost::filesystem::path m_partition_filename
Definition: CheckImages.h:183
std::shared_ptr< WriteableImage< float > > getMLDetectionImage(unsigned int plane_number)
boost::filesystem::path m_group_filename
Definition: CheckImages.h:184
std::shared_ptr< WriteableImage< int > > getApertureImage() const
Definition: CheckImages.h:86
std::map< unsigned int, std::shared_ptr< WriteableImage< MeasurementImage::PixelType > > > m_check_image_psf
Definition: CheckImages.h:167
std::shared_ptr< WriteableImage< int > > m_segmentation_image
Definition: CheckImages.h:159
std::shared_ptr< WriteableImage< SeFloat > > m_moffat_image
Definition: CheckImages.h:164
std::map< unsigned int, decltype(m_auto_aperture_image)> m_measurement_auto_aperture_images
Definition: CheckImages.h:166
boost::filesystem::path m_ml_detection_filename
Definition: CheckImages.h:192
boost::filesystem::path m_residual_filename
Definition: CheckImages.h:179
boost::filesystem::path m_filtered_filename
Definition: CheckImages.h:185
std::shared_ptr< WriteableImage< int > > m_partition_image
Definition: CheckImages.h:160
std::shared_ptr< Image< SeFloat > > m_filtered_image
Definition: CheckImages.h:172
boost::filesystem::path m_model_background_filename
Definition: CheckImages.h:180
std::shared_ptr< WeightImage > m_variance_image
Definition: CheckImages.h:175
static std::unique_ptr< CheckImages > m_instance
Definition: CheckImages.h:149
boost::filesystem::path m_model_variance_filename
Definition: CheckImages.h:181
virtual void configure(Euclid::Configuration::ConfigManager &manager) override
Method which should initialize the object.
Definition: CheckImages.cpp:67
std::shared_ptr< WriteableImage< SeFloat > > getWriteableCheckImage(std::string id, int width, int height)
Definition: CheckImages.cpp:47
boost::filesystem::path m_auto_aperture_filename
Definition: CheckImages.h:188
std::map< unsigned int, std::shared_ptr< WriteableImage< MeasurementImage::PixelType > > > m_check_image_model_fitting
Definition: CheckImages.h:167
boost::filesystem::path m_moffat_filename
Definition: CheckImages.h:190
std::shared_ptr< Image< SeFloat > > m_snr_image
Definition: CheckImages.h:174
boost::filesystem::path m_snr_filename
Definition: CheckImages.h:187
std::shared_ptr< WriteableImage< int > > m_auto_aperture_image
Definition: CheckImages.h:162
boost::filesystem::path m_psf_filename
Definition: CheckImages.h:191
std::shared_ptr< WriteableImage< MeasurementImage::PixelType > > getPsfImage(unsigned int frame_number)
boost::filesystem::path m_segmentation_filename
Definition: CheckImages.h:182
virtual void reportConfigDependencies(Euclid::Configuration::ConfigManager &manager) const override
Registers all the Configuration dependencies.
Definition: CheckImages.cpp:40
std::shared_ptr< WriteableImage< int > > getAutoApertureImage() const
Definition: CheckImages.h:78
std::shared_ptr< WriteableImage< int > > m_aperture_image
Definition: CheckImages.h:163
std::map< unsigned int, decltype(m_aperture_image)> m_measurement_aperture_images
Definition: CheckImages.h:165
std::shared_ptr< CoordinateSystem > m_coordinate_system
Definition: CheckImages.h:176
std::shared_ptr< WriteableImage< int > > m_group_image
Definition: CheckImages.h:161
boost::filesystem::path m_thresholded_filename
Definition: CheckImages.h:186
boost::filesystem::path m_aperture_filename
Definition: CheckImages.h:189
std::shared_ptr< Image< SeFloat > > m_background_image
Definition: CheckImages.h:171
std::shared_ptr< WriteableImage< MeasurementImage::PixelType > > getModelFittingImage(unsigned int frame_number)
boost::filesystem::path m_model_fitting_image_filename
Definition: CheckImages.h:178
void setCustomCheckImage(std::string id, std::shared_ptr< Image< SeFloat >> image)
Definition: CheckImages.cpp:63
std::shared_ptr< DetectionImage > m_detection_image
Definition: CheckImages.h:170
std::map< unsigned int, std::shared_ptr< WriteableImage< float > > > m_check_image_ml_detection
Definition: CheckImages.h:168
std::map< int, FrameInfo > m_measurement_frames
Definition: CheckImages.h:196
std::shared_ptr< Image< SeFloat > > m_thresholded_image
Definition: CheckImages.h:173
std::map< boost::filesystem::path, std::tuple< std::shared_ptr< Image< SeFloat > >, bool > > m_custom_images
Definition: CheckImages.h:194
Provides the detection image.
Interface representing an image.
Definition: Image.h:43
static std::shared_ptr< LockedWriteableImage< T > > create(Args &&... args)
static std::shared_ptr< ProcessedImage< T, P > > create(std::shared_ptr< const Image< T >> image_a, std::shared_ptr< const Image< T >> image_b)
T emplace(T... args)
T end(T... args)
T find(T... args)
T lock(T... args)
T make_pair(T... args)
T make_tuple(T... args)
@ LayerSubtractedImage
Definition: Frame.h:38
string filename
Definition: conf.py:63
T str(T... args)
T to_string(T... args)