FrameModel.icpp

Go to the documentation of this file.

/** Copyright © 2019 Université de Genève, LMU Munich - Faculty of Physics, IAP-CNRS/Sorbonne Université
 *
 * This library is free software; you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License as published by the Free
 * Software Foundation; either version 3.0 of the License, or (at your option)
 * any later version.
 *
 * This library is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
 * details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */
/** 
 * @file FrameModel.icpp
 * @date September 1, 2015
 * @author Nikolaos Apostolakos
 */
 
namespace ModelFitting {
 
template <typename PsfType>
FrameModelPsfContainer<PsfType>::FrameModelPsfContainer(size_t): PsfType() {}
 
template <typename PsfType>
FrameModelPsfContainer<PsfType>::FrameModelPsfContainer(PsfType psf, size_t): PsfType(std::move(psf)) {}
 
template <typename PsfType>
FrameModelPsfContextContainer<PsfType>::FrameModelPsfContextContainer(size_t n_extended_models)
  : PsfType(), m_psf_contexts(n_extended_models) {}
 
template <typename PsfType>
FrameModelPsfContextContainer<PsfType>::FrameModelPsfContextContainer(PsfType psf, size_t n_extended_models)
: PsfType(std::move(psf)), m_psf_contexts(n_extended_models) {}
 
template <typename PsfType, typename ImageType>
FrameModel<PsfType, ImageType>::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)
        : m_pixel_scale{pixel_scale}, m_width{width}, m_height{height},
          m_constant_model_list{std::move(constant_model_list)},
          m_point_model_list{std::move(point_model_list)},
          m_extended_model_list{std::move(extended_model_list)},
          m_psf{std::move(psf), m_extended_model_list.size()} {
}
 
template <typename PsfType, typename ImageType>
FrameModel<PsfType, ImageType>::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)
        : m_pixel_scale{pixel_scale}, m_width{width}, m_height{height},
          m_constant_model_list{std::move(constant_model_list)},
          m_point_model_list{std::move(point_model_list)},
          m_extended_model_list{std::move(extended_model_list)},
          m_psf{m_extended_model_list.size()} {
}
 
template <typename PsfType, typename ImageType>
FrameModel<PsfType, ImageType>::~FrameModel() = default;
 
namespace _impl {
  
template <typename ImageType>
void addConstantModels(ImageType& image, const std::vector<ConstantModel>& model_list) {
  using Traits = ImageTraits<ImageType>;
  for (auto& model : model_list) {
    double value = model.getValue();
    for(auto it=Traits::begin(image); it!=Traits::end(image); ++it) {
      *it += value;
    }
  }
}
  
template <typename ImageType, typename PsfType>
void addPointModels(ImageType& image, const std::vector<PointModel>& model_list,
                    const PsfType& psf, double pixel_scale) {
  using Traits = ImageTraits<ImageType>;
  auto scale_factor = psf.getPixelScale() / pixel_scale;
  for (auto& model : model_list) {
    Traits::addImageToImage(image, psf.getScaledKernel(model.getValue()), scale_factor, model.getX(), model.getY());
  }
}
  
template <typename ImageType, typename PsfType>
void addExtendedModels(ImageType& image, const std::vector<std::shared_ptr<ExtendedModel<ImageType>>>& model_list,
                       PsfType& psf, double pixel_scale) {
  using Traits = ImageTraits<ImageType>;
  auto scale_factor = psf.getPixelScale() / pixel_scale;
 
  for (size_t i = 0; i < model_list.size(); ++i) {
    auto& model = model_list[i];
    std::size_t width = std::ceil(model->getWidth() / psf.getPixelScale() + psf.getSize());
    if (width % 2 == 0) {
      ++width;
    }
    std::size_t height = std::ceil(model->getHeight() / psf.getPixelScale() + psf.getSize());
    if (height % 2 == 0) {
      ++height;
    }
 
    auto extended_image = model->getRasterizedImage(psf.getPixelScale(), width, height);
    psf.convolve(i, extended_image);
    Traits::addImageToImage(image, extended_image, scale_factor, model->getX(), model->getY());
  }
}
 
} // end of namespace _impl
 
template <typename PsfType, typename ImageType>
void FrameModel<PsfType, ImageType>::recomputeImage() {
  using Traits = ImageTraits<ImageType>;
  m_model_image.reset(new ImageType(Traits::factory(m_width, m_height)));
  rasterToImage(*m_model_image);
}
 
template <typename PsfType, typename ImageType>
const ImageType& FrameModel<PsfType, ImageType>::getImage() {
  recomputeImage();
  return *m_model_image;
}
 
template <typename PsfType, typename ImageType>
void FrameModel<PsfType, ImageType>::rasterToImage(ImageType &model_image) {
  _impl::addConstantModels(model_image, m_constant_model_list);
  _impl::addPointModels(model_image, m_point_model_list, m_psf, m_pixel_scale);
  _impl::addExtendedModels(model_image, m_extended_model_list, m_psf, m_pixel_scale);
}
 
template <typename PsfType, typename ImageType>
auto FrameModel<PsfType, ImageType>::begin() -> const_iterator {
  recomputeImage();
  return ImageTraits<ImageType>::begin(*m_model_image);
}
 
template <typename PsfType, typename ImageType>
auto FrameModel<PsfType, ImageType>::end() -> const_iterator {
  return ImageTraits<ImageType>::end(*m_model_image);
}
 
template <typename PsfType, typename ImageType>
std::size_t FrameModel<PsfType, ImageType>::size() const {
  return m_width * m_height;
}
 
} // end of namespace ModelFitting