FrameModel.h

Go to the documentation of this file.

 
#ifndef MODELFITTING_FRAMEMODEL_H
#define MODELFITTING_FRAMEMODEL_H
 
#include <vector>
#include <cmath>
#include "ModelFitting/Models/ConstantModel.h"
#include "ModelFitting/Models/PointModel.h"
#include "ModelFitting/Models/ExtendedModel.h"
#include "ModelFitting/Image/ImageTraits.h"
#include "ModelFitting/Image/PsfTraits.h"
 
namespace ModelFitting {

template <typename PsfType>
class FrameModelPsfContainer: public PsfType {
public:

  FrameModelPsfContainer(std::size_t n_extended_models);

  FrameModelPsfContainer(PsfType psf, std::size_t n_extended_models);

  template<typename... Args>
  void convolve(size_t, Args&&... args) {
    PsfType::convolve(std::forward<Args>(args)...);
  }
};

template <typename PsfType>
class FrameModelPsfContextContainer: public PsfType {
public:

  FrameModelPsfContextContainer(std::size_t n_extended_models);

  FrameModelPsfContextContainer(PsfType psf, std::size_t n_extended_models);

  template<typename... Args>
  void convolve(size_t i, Args&&... args) {
    auto& context = m_psf_contexts[i];
    if (!context) {
      context = PsfType::prepare(std::forward<Args>(args)...);
      m_psf_contexts[i] = std::move(context);
    }
    PsfType::convolve(std::forward<Args>(args)..., m_psf_contexts[i]);
  }
 
private:
  std::vector<typename PsfTraits<PsfType>::context_t> m_psf_contexts;
};
 
 
template <typename PsfType, typename ImageType>
class FrameModel {
private:
 
  // PsfTraits must have a has_context boolean with the value of true
  // if PsfType has a context type and a prepare method.
  // If it is the case, the PSF will be wrapped by FrameModelPsfContextContainer:
  // each model will have its own context.
  // Otherwise, the PSF will be just wrapped by FrameModelPsfContainer, which
  // forwards directly the calls.
  using psf_container_t = typename std::conditional<
    PsfTraits<PsfType>::has_context,
    FrameModelPsfContextContainer<PsfType>,
    FrameModelPsfContainer<PsfType>
  >::type;
 
public:
 
  using const_iterator = typename ImageTraits<ImageType>::iterator;
  
  FrameModel(double pixel_scale, std::size_t width, std::size_t height,
             std::vector<ConstantModel> constant_model_list,
             std::vector<PointModel> point_model_list,
             std::vector<std::shared_ptr<ExtendedModel<ImageType>>> extended_model_list,
             PsfType psf);
  
  FrameModel(double pixel_scale, std::size_t width, std::size_t height,
             std::vector<ConstantModel> constant_model_list,
             std::vector<PointModel> point_model_list,
             std::vector<std::shared_ptr<ExtendedModel<ImageType>>> extended_model_list);
 
 
  FrameModel(FrameModel&&) = default;
  
  virtual ~FrameModel();
  
  void recomputeImage();
  
  const ImageType& getImage();
 
  void rasterToImage(ImageType&);
  
  const_iterator begin();
  
  const_iterator end();
  
  std::size_t size() const;
  
private:
  
  double m_pixel_scale;
  std::size_t m_width;
  std::size_t m_height;
  std::vector<ConstantModel> m_constant_model_list;
  std::vector<PointModel> m_point_model_list;
  std::vector<std::shared_ptr<ExtendedModel<ImageType>>> m_extended_model_list;
  psf_container_t m_psf;
  std::unique_ptr<ImageType> m_model_image {};
  
}; // end of class FrameModel
 
} // end of namespace ModelFitting
 
#include "_impl/FrameModel.icpp"
 
#endif  /* MODELFITTING_FRAMEMODEL_H */