SourceXtractorPlusPlus  0.14
Please provide a description of the project.
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
BenchRendering.cpp
Go to the documentation of this file.
1 
17 /*
18  * BenchRendering.cpp
19  *
20  * Created on: Aug 7, 2019
21  * Author: mschefer
22  */
23 
24 
25 #include <boost/timer/timer.hpp>
26 
28 
33 
45 
47 
50 
51 namespace po = boost::program_options;
52 namespace fs = boost::filesystem;
53 
54 using namespace ModelFitting;
55 using namespace SourceXtractor;
56 
57 template <typename ImageType>
58 class DummyPsf {
59 public:
60  DummyPsf() : m_kernel(VectorImage<SeFloat>::create(1, 1)) {}
61 
62  double getPixelScale() const {
63  return 1.0;
64  }
65 
66  std::size_t getSize() const {
67  return 1;
68  }
69 
71  return m_kernel;
72  }
73 
74  void convolve(ImageType& /*image*/) const {
75  }
76 
77 private:
79 
80 };
81 
82 
83 template <typename ImageType>
84 class DummyModel : public ExtendedModel<ImageType> {
85 
86 public:
90  : ExtendedModel<ImageType>({}, x_scale, y_scale, rotation, width, height, x, y)
91  {}
92 
93  virtual ~DummyModel() = default;
94 
95  double getValue(double x, double y) const override { return 0.0; }
96 
97  ImageType getRasterizedImage(double pixel_scale, std::size_t size_x, std::size_t size_y) const override {
99  ImageType image = Traits::factory(size_x, size_y);
100  return image;
101  }
102 };
103 
104 template <typename ImageType>
105 class DummyFillModel : public ExtendedModel<ImageType> {
106 
107 public:
112  {}
113 
114  virtual ~DummyFillModel() = default;
115 
116  double getValue(double x, double y) const override { return 0.0; }
117 
118  ImageType getRasterizedImage(double pixel_scale, std::size_t size_x, std::size_t size_y) const override {
120  ImageType image = Traits::factory(size_x, size_y);
121 
122  for (std::size_t x=0; x<size_x; ++x) {
123  for (std::size_t y=0; y<size_y; ++y) {
124  Traits::at(image, x, y) = x+y;
125  }
126  }
127 
128 
129  return image;
130  }
131 };
132 
133 template <typename ImageType>
134 class DummyExpModel : public ExtendedModel<ImageType> {
135 
136 public:
141  {}
142 
143  virtual ~DummyExpModel() = default;
144 
145  double getValue(double x, double y) const override { return 0.0; }
146 
147  ImageType getRasterizedImage(double pixel_scale, std::size_t size_x, std::size_t size_y) const override {
149  ImageType image = Traits::factory(size_x, size_y);
150 
151  for (std::size_t x=0; x<size_x; ++x) {
152  for (std::size_t y=0; y<size_y; ++y) {
153  Traits::at(image, x, y) = std::exp(float(x+y));
154  }
155  }
156 
157  return image;
158  }
159 };
160 
161 template <typename ImageType>
162 class DummySersicModel : public ExtendedModel<ImageType> {
163 
164 public:
169  {}
170 
171  virtual ~DummySersicModel() = default;
172 
173  double getValue(double x, double y) const override { return 0.0; }
174 
175  ImageType getRasterizedImage(double pixel_scale, std::size_t size_x, std::size_t size_y) const override {
177  ImageType image = Traits::factory(size_x, size_y);
178 
179  for (std::size_t x=0; x<size_x; ++x) {
180  for (std::size_t y=0; y<size_y; ++y) {
181  Traits::at(image, x, y) = 2.0f * std::exp(-1.5f * std::pow(float(x*x+y*y), 1.f / 4.0f));;
182  }
183  }
184 
185  return image;
186  }
187 };
188 
189 
190 
191 
193 
194 public:
195 
196 // po::options_description defineSpecificProgramOptions() override {
197 // po::options_description config_options { "TestImage options" };
198 //
199 // // Add the specific program options
200 // config_options.add_options()
201 // ("output", po::value<string>()->required(), "filename to save the created test image")
202 // ;
203 //
204 // return config_options;
205 // }
206 
207 
208 
210  std::vector<ConstantModel> constant_models;
212  std::vector<PointModel> point_models;
213 
214  double pixel_scale = 1.0f;
215  int image_size = 256;
216 
218  pixel_scale,
219  (std::size_t) image_size, (std::size_t) image_size,
220  std::move(constant_models),
221  std::move(point_models),
222  std::move(extended_models),
223  };
224 
225  return frame_model;
226  }
227 
229  std::vector<ConstantModel> constant_models;
231  std::vector<PointModel> point_models;
232 
233  // Devaucouleurs component
234 
235  auto x_param = std::make_shared<ManualParameter>(128);
236  auto y_param = std::make_shared<ManualParameter>(128);
237 
238  auto xs = std::make_shared<ManualParameter>(1);
239  auto ys = std::make_shared<ManualParameter>(1);
240 
241  auto rot = std::make_shared<ManualParameter>(0);
242  auto dev_n = std::make_shared<ManualParameter>(4);
243  auto dev_k = std::make_shared<ManualParameter>(10);
244  auto dev_i0 = std::make_shared<ManualParameter>(1000);
245 
247  auto exp = Euclid::make_unique<SersicModelComponent>(Euclid::make_unique<OldSharp>(), dev_i0, dev_n, dev_k);
248  component_list.clear();
249  component_list.emplace_back(std::move(exp));
251  std::move(component_list), xs, ys, rot, 256, 256, x_param, y_param));
252 
253 
254  double pixel_scale = 1.0f;
255  int image_size = 256;
256 
258  pixel_scale,
259  (std::size_t) image_size, (std::size_t) image_size,
260  std::move(constant_models),
261  std::move(point_models),
262  std::move(extended_models),
263  };
264 
265  return frame_model;
266  }
267 
269  std::vector<ConstantModel> constant_models;
271  std::vector<PointModel> point_models;
272 
273  // Devaucouleurs component
274  auto x_param = std::make_shared<ManualParameter>(128);
275  auto y_param = std::make_shared<ManualParameter>(128);
276 
277  auto xs = std::make_shared<ManualParameter>(1);
278  auto ys = std::make_shared<ManualParameter>(1);
279 
280  auto rot = std::make_shared<ManualParameter>(0);
281  auto n = std::make_shared<ManualParameter>(4);
282  auto k = std::make_shared<ManualParameter>(10);
283  auto i0 = std::make_shared<ManualParameter>(1000);
284 
285  auto flux = std::make_shared<ManualParameter>(100000); // FIXME use a value that makes sense
286 
288  3.0, i0, k, n,
289  xs, ys, rot, 256, 256, x_param, y_param, flux, std::make_tuple(1, 0, 0, 1)));
290 
291  double pixel_scale = 1.0f;
292  int image_size = 256;
293 
295  pixel_scale,
296  (std::size_t) image_size, (std::size_t) image_size,
297  std::move(constant_models),
298  std::move(point_models),
299  std::move(extended_models),
300  };
301 
302  return frame_model;
303  }
304 
305  template<typename T>
307  std::vector<ConstantModel> constant_models;
309  std::vector<PointModel> point_models;
310 
311  // Devaucouleurs component
312  auto x_param = std::make_shared<ManualParameter>(128);
313  auto y_param = std::make_shared<ManualParameter>(128);
314 
315  auto xs = std::make_shared<ManualParameter>(1);
316  auto ys = std::make_shared<ManualParameter>(1);
317 
318  auto rot = std::make_shared<ManualParameter>(0);
319  auto n = std::make_shared<ManualParameter>(4);
320  auto k = std::make_shared<ManualParameter>(10);
321  auto i0 = std::make_shared<ManualParameter>(1000);
322 
323  extended_models.emplace_back(std::make_shared<T>(
324  xs, ys, rot, 256, 256, x_param, y_param));
325 
326  double pixel_scale = 1.0f;
327  int image_size = 256;
328 
330  pixel_scale,
331  (std::size_t) image_size, (std::size_t) image_size,
332  std::move(constant_models),
333  std::move(point_models),
334  std::move(extended_models),
335  };
336 
337  return frame_model;
338  }
339 
340 
341  template<typename T>
343  auto image = VectorImage<SeFloat>::create(256, 256);
344 
345  for (int i=0; i<iterations; i++) {
346  frame_model.rasterToImage(image);
347  }
348 
349  return image;
350  }
351 
354 
355  int iterations = 300;
356 
357  auto empty_frame_model = makeEmptyFrameModel();
358  auto dummy_frame_model = makeDummyFrameModel<DummyModel<ImageInterfaceTypePtr>>();
359  auto dummy_fill_frame_model = makeDummyFrameModel<DummyFillModel<ImageInterfaceTypePtr>>();
360  auto dummy_exp_frame_model = makeDummyFrameModel<DummyExpModel<ImageInterfaceTypePtr>>();
361  auto dummy_sersic_frame_model = makeDummyFrameModel<DummySersicModel<ImageInterfaceTypePtr>>();
362  auto sersic_frame_model = makeSersicFrameModel();
363  auto compact_frame_model = makeCompactSersicFrameModel();
364 
365  logger.info() << "Testing with empty frame";
366  {
367  boost::timer::auto_cpu_timer t;
368  measureRasterToImage(iterations, empty_frame_model);
369  }
370  logger.info() << "Testing with dummy (nop) model";
371  {
372  boost::timer::auto_cpu_timer t;
373  measureRasterToImage(iterations, dummy_frame_model);
374  }
375  logger.info() << "Testing with dummy (fill) model";
376  {
377  boost::timer::auto_cpu_timer t;
378  measureRasterToImage(iterations, dummy_fill_frame_model);
379  }
380  logger.info() << "Testing with dummy (fill exp) model";
381  {
382  boost::timer::auto_cpu_timer t;
383  measureRasterToImage(iterations, dummy_exp_frame_model);
384  }
385  logger.info() << "Testing with dummy (sersic) model";
386  {
387  boost::timer::auto_cpu_timer t;
388  measureRasterToImage(iterations, dummy_sersic_frame_model);
389  }
390  logger.info() << "Testing with old style Sersic model";
391  {
392  boost::timer::auto_cpu_timer t;
393  measureRasterToImage(iterations, sersic_frame_model);
394  }
395  logger.info() << "Testing with compact Sersic model";
396  {
397  boost::timer::auto_cpu_timer t;
398  measureRasterToImage(iterations, compact_frame_model);
399  }
400 
401  return Elements::ExitCode::OK;
402  }
403 
404 };
405 
double getValue(double x, double y) const override
T exp(T...args)
std::shared_ptr< VectorImage< SourceXtractor::SeFloat > > getScaledKernel(double) const
ImageType getRasterizedImage(double pixel_scale, std::size_t size_x, std::size_t size_y) const override
void info(const std::string &logMessage)
SeFloat32 SeFloat
Definition: Types.h:32
T make_tuple(T...args)
FrameModel< DummyPsf< ImageInterfaceTypePtr >, ImageInterfaceTypePtr > makeSersicFrameModel()
FrameModel< DummyPsf< ImageInterfaceTypePtr >, ImageInterfaceTypePtr > makeCompactSersicFrameModel()
static Elements::Logging logger
STL class.
DummyFillModel(std::shared_ptr< BasicParameter > x_scale, std::shared_ptr< BasicParameter > y_scale, std::shared_ptr< BasicParameter > rotation, double width, double height, std::shared_ptr< BasicParameter > x, std::shared_ptr< BasicParameter > y)
std::shared_ptr< VectorImage< SourceXtractor::SeFloat > > m_kernel
std::shared_ptr< VectorImage< SeFloat > > measureRasterToImage(int iterations, T &frame_model)
Image implementation which keeps the pixel values in memory.
Definition: VectorImage.h:53
#define MAIN_FOR(ELEMENTS_PROGRAM_NAME)
double getValue(double x, double y) const override
FrameModel< DummyPsf< ImageInterfaceTypePtr >, ImageInterfaceTypePtr > makeDummyFrameModel()
FrameModel< DummyPsf< ImageInterfaceTypePtr >, ImageInterfaceTypePtr > makeEmptyFrameModel()
DummyExpModel(std::shared_ptr< BasicParameter > x_scale, std::shared_ptr< BasicParameter > y_scale, std::shared_ptr< BasicParameter > rotation, double width, double height, std::shared_ptr< BasicParameter > x, std::shared_ptr< BasicParameter > y)
void convolve(ImageType &) const
DummySersicModel(std::shared_ptr< BasicParameter > x_scale, std::shared_ptr< BasicParameter > y_scale, std::shared_ptr< BasicParameter > rotation, double width, double height, std::shared_ptr< BasicParameter > x, std::shared_ptr< BasicParameter > y)
T move(T...args)
std::size_t getSize() const
STL class.
double getValue(double x, double y) const override
T make_shared(T...args)
T pow(T...args)
double getPixelScale() const
ImageType getRasterizedImage(double pixel_scale, std::size_t size_x, std::size_t size_y) const override
DummyModel(std::shared_ptr< BasicParameter > x_scale, std::shared_ptr< BasicParameter > y_scale, std::shared_ptr< BasicParameter > rotation, double width, double height, std::shared_ptr< BasicParameter > x, std::shared_ptr< BasicParameter > y)
Elements::ExitCode mainMethod(std::map< std::string, po::variable_value > &args) override
static Logging getLogger(const std::string &name="")
ImageType getRasterizedImage(double pixel_scale, std::size_t size_x, std::size_t size_y) const override
double getValue(double x, double y) const override
const double pixel_scale
Definition: TestImage.cpp:75
ImageType getRasterizedImage(double pixel_scale, std::size_t size_x, std::size_t size_y) const override
T emplace_back(T...args)