SourceXtractorPlusPlus  0.15
Please provide a description of the project.
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
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) {
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 
86  m_coordinate_system = manager.getConfiguration<DetectionImageConfig>().getCoordinateSystem();
87 
88  if (m_segmentation_filename != "") {
89  m_segmentation_image = FitsWriter::newImage<int>(m_segmentation_filename.native(),
90  m_detection_image->getWidth(), m_detection_image->getHeight(), m_coordinate_system);
91  }
92 
93  if (m_partition_filename != "") {
94  m_partition_image = FitsWriter::newImage<int>(m_partition_filename.native(),
95  m_detection_image->getWidth(), m_detection_image->getHeight(), m_coordinate_system);
96  }
97 
98  if (m_group_filename != "") {
99  m_group_image = FitsWriter::newImage<int>(m_group_filename.native(),
100  m_detection_image->getWidth(), m_detection_image->getHeight(), m_coordinate_system);
101  }
102 
103  if (m_auto_aperture_filename != "") {
104  m_auto_aperture_image = FitsWriter::newImage<int>(m_auto_aperture_filename.native(),
105  m_detection_image->getWidth(), m_detection_image->getHeight(), m_coordinate_system);
106  }
107 
108  if (m_aperture_filename != "") {
109  m_aperture_image = FitsWriter::newImage<int>(m_aperture_filename.native(),
110  m_detection_image->getWidth(), m_detection_image->getHeight(), m_coordinate_system
111  );
112  }
113 
114  if (m_moffat_filename != "") {
115  m_moffat_image = FitsWriter::newImage<SeFloat>(m_moffat_filename.native(),
116  m_detection_image->getWidth(), m_detection_image->getHeight(), m_coordinate_system
117  );
118  }
119 
120  // Measurement images
121  const auto& measurement_images_info = manager.getConfiguration<MeasurementImageConfig>().getImageInfos();
122  const auto& frames = manager.getConfiguration<MeasurementFrameConfig>().getFrames();
123  for (auto& info : measurement_images_info) {
124  std::stringstream label;
125  label << boost::filesystem::basename(info.m_path) << "_" << info.m_image_hdu;
126 
127  m_measurement_frames[info.m_id] = FrameInfo {
128  label.str(),
129  info.m_measurement_image->getWidth(),
130  info.m_measurement_image->getHeight(),
131  info.m_coordinate_system,
132  frames.at(info.m_id)->getImage(LayerSubtractedImage)
133  };
134  }
135 }
136 
138  if (m_auto_aperture_filename.empty()) {
139  return nullptr;
140  }
141 
143 
144  auto i = m_measurement_auto_aperture_images.find(frame_number);
146  auto& frame_info = m_measurement_frames.at(frame_number);
147  auto filename = m_auto_aperture_filename.stem();
148  filename += "_" + frame_info.m_label;
149  filename += m_auto_aperture_filename.extension();
150  auto frame_filename = m_auto_aperture_filename.parent_path() / filename;
153  frame_number,
154  FitsWriter::newImage<int>(
155  frame_filename.native(),
156  frame_info.m_width,
157  frame_info.m_height,
158  frame_info.m_coordinate_system
159  ))).first;
160  }
161  return LockedWriteableImage<int>::create(i->second);
162 }
163 
165  if (m_aperture_filename.empty()) {
166  return nullptr;
167  }
168 
170 
171  auto i = m_measurement_aperture_images.find(frame_number);
172  if (i == m_measurement_aperture_images.end()) {
173  auto& frame_info = m_measurement_frames.at(frame_number);
174  auto filename = m_aperture_filename.stem();
175  filename += "_" + frame_info.m_label;
176  filename += m_aperture_filename.extension();
177  auto frame_filename = m_aperture_filename.parent_path() / filename;
180  frame_number,
181  FitsWriter::newImage<int>(
182  frame_filename.native(),
183  frame_info.m_width,
184  frame_info.m_height,
185  frame_info.m_coordinate_system
186  ))).first;
187  }
188  return LockedWriteableImage<int>::create(i->second);
189 }
190 
192 CheckImages::getModelFittingImage(unsigned int frame_number) {
193  if (m_model_fitting_image_filename.empty() && m_residual_filename.empty()) {
194  return nullptr;
195  }
196 
198 
199  auto i = m_check_image_model_fitting.find(frame_number);
200  if (i == m_check_image_model_fitting.end()) {
201  auto& frame_info = m_measurement_frames.at(frame_number);
203 
204  if (m_model_fitting_image_filename.empty()) {
205  writeable_image = FitsWriter::newTemporaryImage<DetectionImage::PixelType>(
206  "sourcextractor_check_model_%%%%%%.fits",
207  frame_info.m_width, frame_info.m_height
208  );
209  } else {
211  filename += "_" + frame_info.m_label;
213  auto frame_filename = m_model_fitting_image_filename.parent_path() / filename;
214  writeable_image = FitsWriter::newImage<MeasurementImage::PixelType>(
215  frame_filename.native(),
216  frame_info.m_width,
217  frame_info.m_height,
218  frame_info.m_coordinate_system
219  );
220  }
221  i = m_check_image_model_fitting.emplace(std::make_pair(frame_number, writeable_image)).first;
222  }
224 }
225 
227  if (m_psf_filename.empty()) {
228  return nullptr;
229  }
230 
232 
233  auto i = m_check_image_psf.find(frame_number);
234  if (i == m_check_image_psf.end()) {
235  auto& frame_info = m_measurement_frames.at(frame_number);
236  auto filename = m_psf_filename.stem();
237  filename += "_" + frame_info.m_label;
238  filename += m_psf_filename.extension();
239  auto frame_filename = m_psf_filename.parent_path() / filename;
240  i = m_check_image_psf.emplace(
242  frame_number,
243  FitsWriter::newImage<MeasurementImage::PixelType>(
244  frame_filename.native(),
245  frame_info.m_width,
246  frame_info.m_height,
247  frame_info.m_coordinate_system
248  ))).first;
249  }
251 }
252 
255 
256  // if possible, save the background image
257  if (m_background_image != nullptr && m_model_background_filename != "") {
258  FitsWriter::writeFile(*m_background_image, m_model_background_filename.native(), m_coordinate_system);
259  }
260 
261  // if possible, save the variance image
262  if (m_variance_image != nullptr && m_model_variance_filename != "") {
263  FitsWriter::writeFile(*m_variance_image, m_model_variance_filename.native(), m_coordinate_system);
264  }
265 
266  // if possible, save the filtered image
267  if (m_filtered_image != nullptr && m_filtered_filename != "") {
268  FitsWriter::writeFile(*m_filtered_image, m_filtered_filename.native(), m_coordinate_system);
269  }
270 
271  // if possible, save the thresholded image
272  if (m_thresholded_image != nullptr && m_thresholded_filename != "") {
273  FitsWriter::writeFile(*m_thresholded_image, m_thresholded_filename.native(), m_coordinate_system);
274  }
275 
276  // if possible, save the SNR image
277  if (m_snr_image != nullptr && m_snr_filename != "") {
278  FitsWriter::writeFile(*m_snr_image, m_snr_filename.native(), m_coordinate_system);
279  }
280 
281  // if possible, create and save the residual image
282  if (m_residual_filename != "") {
283  for (auto &ci : m_check_image_model_fitting) {
284  auto& frame_info = m_measurement_frames.at(ci.first);
285 
286  auto residual_image = SubtractImage<SeFloat>::create(frame_info.m_subtracted_image, ci.second);
287  auto filename = m_residual_filename.stem();
288  filename += "_" + frame_info.m_label;
289  filename += m_residual_filename.extension();
290  auto frame_filename = m_residual_filename.parent_path() / filename;
291  FitsWriter::writeFile(*residual_image, frame_filename.native(), frame_info.m_coordinate_system);
292  }
293  }
294 
295  for (auto const& entry : m_custom_images) {
296  if (std::get<1>(entry.second)) {
297  auto filename = entry.first;
298  if (!filename.has_extension()) {
299  filename += ".fits";
300  }
301  FitsWriter::writeFile(*std::get<0>(entry.second), filename.native());
302  }
303  }
304 }
305 
306 }
boost::filesystem::path m_partition_filename
Definition: CheckImages.h:180
boost::filesystem::path m_model_background_filename
Definition: CheckImages.h:177
std::shared_ptr< WriteableImage< int > > m_auto_aperture_image
Definition: CheckImages.h:160
std::shared_ptr< CoordinateSystem > m_coordinate_system
Definition: CheckImages.h:173
static std::shared_ptr< LockedWriteableImage< T > > create(Args &&...args)
boost::filesystem::path m_filtered_filename
Definition: CheckImages.h:182
boost::filesystem::path m_thresholded_filename
Definition: CheckImages.h:183
void setCustomCheckImage(std::string id, std::shared_ptr< Image< SeFloat >> image)
Definition: CheckImages.cpp:63
std::shared_ptr< WriteableImage< int > > m_aperture_image
Definition: CheckImages.h:161
std::shared_ptr< WriteableImage< int > > m_partition_image
Definition: CheckImages.h:158
std::map< boost::filesystem::path, std::tuple< std::shared_ptr< Image< SeFloat > >, bool > > m_custom_images
Definition: CheckImages.h:190
boost::filesystem::path m_model_variance_filename
Definition: CheckImages.h:178
std::shared_ptr< WriteableImage< int > > m_segmentation_image
Definition: CheckImages.h:157
boost::filesystem::path m_aperture_filename
Definition: CheckImages.h:186
std::map< unsigned int, decltype(m_auto_aperture_image)> m_measurement_auto_aperture_images
Definition: CheckImages.h:164
T make_tuple(T...args)
T end(T...args)
boost::filesystem::path m_snr_filename
Definition: CheckImages.h:184
std::map< int, FrameInfo > m_measurement_frames
Definition: CheckImages.h:192
static std::unique_ptr< CheckImages > m_instance
Definition: CheckImages.h:147
Provides the detection image.
STL class.
std::shared_ptr< Image< SeFloat > > m_filtered_image
Definition: CheckImages.h:169
boost::filesystem::path m_auto_aperture_filename
Definition: CheckImages.h:185
boost::filesystem::path m_group_filename
Definition: CheckImages.h:181
boost::filesystem::path m_psf_filename
Definition: CheckImages.h:188
string filename
Definition: conf.py:63
std::map< unsigned int, std::shared_ptr< WriteableImage< MeasurementImage::PixelType > > > m_check_image_model_fitting
Definition: CheckImages.h:165
T lock(T...args)
T str(T...args)
T make_pair(T...args)
virtual void configure(Euclid::Configuration::ConfigManager &manager) override
Method which should initialize the object.
Definition: CheckImages.cpp:67
T dynamic_pointer_cast(T...args)
std::map< unsigned int, std::shared_ptr< WriteableImage< MeasurementImage::PixelType > > > m_check_image_psf
Definition: CheckImages.h:165
virtual void reportConfigDependencies(Euclid::Configuration::ConfigManager &manager) const override
Registers all the Configuration dependencies.
Definition: CheckImages.cpp:40
std::shared_ptr< WriteableImage< SeFloat > > m_moffat_image
Definition: CheckImages.h:162
std::shared_ptr< WriteableImage< MeasurementImage::PixelType > > getPsfImage(unsigned int frame_number)
T find(T...args)
std::shared_ptr< Image< SeFloat > > m_snr_image
Definition: CheckImages.h:171
STL class.
std::shared_ptr< Image< SeFloat > > m_background_image
Definition: CheckImages.h:168
T emplace(T...args)
Interface representing an image.
Definition: Image.h:43
std::shared_ptr< Image< SeFloat > > m_thresholded_image
Definition: CheckImages.h:170
std::shared_ptr< WriteableImage< int > > m_group_image
Definition: CheckImages.h:159
std::shared_ptr< DetectionImage > m_detection_image
Definition: CheckImages.h:167
std::shared_ptr< WriteableImage< SeFloat > > getWriteableCheckImage(std::string id, int width, int height)
Definition: CheckImages.cpp:47
boost::filesystem::path m_moffat_filename
Definition: CheckImages.h:187
boost::filesystem::path m_residual_filename
Definition: CheckImages.h:176
std::map< unsigned int, decltype(m_aperture_image)> m_measurement_aperture_images
Definition: CheckImages.h:163
boost::filesystem::path m_model_fitting_image_filename
Definition: CheckImages.h:175
std::shared_ptr< WriteableImage< int > > getApertureImage() const
Definition: CheckImages.h:86
std::shared_ptr< WeightImage > m_variance_image
Definition: CheckImages.h:172
std::shared_ptr< WriteableImage< int > > getAutoApertureImage() const
Definition: CheckImages.h:78
static std::shared_ptr< ProcessedImage< T, P > > create(std::shared_ptr< const Image< T >> image_a, std::shared_ptr< const Image< T >> image_b)
boost::filesystem::path m_segmentation_filename
Definition: CheckImages.h:179
std::shared_ptr< WriteableImage< MeasurementImage::PixelType > > getModelFittingImage(unsigned int frame_number)