PoissonLogLikelihoodWithLinearModelForMeanAndGatedProjDataWithMotion.h

Go to the documentation of this file.

/*
  Copyright (C) 2006- 2009, Hammersmith Imanet Ltd
  Copyright (C) 2010- 2013, King's College London
  Copyright (C) 2018, University College London
 
  SPDX-License-Identifier: Apache-2.0
 
  See STIR/LICENSE.txt for details
*/
 
#ifndef __stir_recon_buildblock_PoissonLogLikelihoodWithLinearModelForMeanAndGatedProjDataWithMotion_H__
#define __stir_recon_buildblock_PoissonLogLikelihoodWithLinearModelForMeanAndGatedProjDataWithMotion_H__
#include "stir/shared_ptr.h"
#include "stir/RegisteredObject.h"
#include "stir/RegisteredParsingObject.h"
#include "stir/ParseAndCreateFrom.h"
#include "stir/recon_buildblock/PoissonLogLikelihoodWithLinearModelForMeanAndProjData.h"
#include "stir/recon_buildblock/PoissonLogLikelihoodWithLinearModelForMean.h"
#include "stir/VectorWithOffset.h"
#include "stir/GatedProjData.h"
#include "stir/GatedDiscretisedDensity.h"
#include "stir/spatial_transformation/GatedSpatialTransformation.h"
 
START_NAMESPACE_STIR

 
template <typename TargetT>
class PoissonLogLikelihoodWithLinearModelForMeanAndGatedProjDataWithMotion
    : public RegisteredParsingObject<PoissonLogLikelihoodWithLinearModelForMeanAndGatedProjDataWithMotion<TargetT>,
                                     GeneralisedObjectiveFunction<TargetT>,
                                     PoissonLogLikelihoodWithLinearModelForMean<TargetT>>
{
private:
  typedef RegisteredParsingObject<PoissonLogLikelihoodWithLinearModelForMeanAndGatedProjDataWithMotion<TargetT>,
                                  GeneralisedObjectiveFunction<TargetT>,
                                  PoissonLogLikelihoodWithLinearModelForMean<TargetT>>
      base_type;
  typedef PoissonLogLikelihoodWithLinearModelForMeanAndProjData<DiscretisedDensity<3, float>> SingleGateObjFunc;
  VectorWithOffset<SingleGateObjFunc> _single_gate_obj_funcs;
 
  TimeGateDefinitions _time_gate_definitions;
 
public:
  static const char* const registered_name;
 
  PoissonLogLikelihoodWithLinearModelForMeanAndGatedProjDataWithMotion();


  TargetT* construct_target_ptr() const override;
 
  void actual_compute_subset_gradient_without_penalty(TargetT& gradient,
                                                      const TargetT& current_estimate,
                                                      const int subset_num,
                                                      const bool add_sensitivity) override;
 
  double actual_compute_objective_function_without_penalty(const TargetT& current_estimate, const int subset_num) override;
 
  Succeeded set_up_before_sensitivity(shared_ptr<const TargetT> const& target_sptr) override;

  void add_subset_sensitivity(TargetT& sensitivity, const int subset_num) const override;
 
  Succeeded actual_add_multiplication_with_approximate_sub_Hessian_without_penalty(TargetT& output,
                                                                                   const TargetT& input,
                                                                                   const int subset_num) const override;
  Succeeded actual_accumulate_sub_Hessian_times_input_without_penalty(TargetT& output,
                                                                      const TargetT& current_image_estimate,
                                                                      const TargetT& input,
                                                                      const int subset_num) const override;
 
  void set_time_gate_definitions(const TimeGateDefinitions& time_gate_definitions);

  const GatedProjData& get_gated_proj_data() const;
  const shared_ptr<GatedProjData>& get_gated_proj_data_sptr() const;
  const int get_max_segment_num_to_process() const;
  const bool get_zero_seg0_end_planes() const;
  const GatedProjData& get_additive_gated_proj_data() const;
  const shared_ptr<GatedProjData>& get_additive_gated_proj_data_sptr() const;
  const GatedProjData& get_normalisation_gated_proj_data() const;
  const shared_ptr<GatedProjData>& get_normalisation_gated_proj_data_sptr() const;
  const ProjectorByBinPair& get_projector_pair() const;
  const shared_ptr<ProjectorByBinPair>& get_projector_pair_sptr() const;

  void set_recompute_sensitivity(const bool);
  void set_sensitivity_sptr(const shared_ptr<TargetT>&);
  int set_num_subsets(const int num_subsets) override;
 
  void set_normalisation_sptr(const shared_ptr<BinNormalisation>&) override;
  void set_additive_proj_data_sptr(const shared_ptr<ExamData>&) override;
 
  void set_input_data(const shared_ptr<ExamData>&) override;
  const GatedProjData& get_input_data() const override;
protected:
  std::string _input_filename;
  std::string _motion_vectors_filename_prefix;
  std::string _reverse_motion_vectors_filename_prefix;
  std::string _gate_definitions_filename;

  shared_ptr<GatedProjData> _gated_proj_data_sptr;


  int _max_segment_num_to_process;
 
  const TimeGateDefinitions& get_time_gate_definitions() const;
 
  /**********************/
  ParseAndCreateFrom<TargetT, GatedProjData> target_parameter_parser;
  /********************************/
  std::string _additive_gated_proj_data_filename;

  std::string _normalisation_gated_proj_data_filename;


  shared_ptr<GatedProjData> _additive_gated_proj_data_sptr;
  shared_ptr<GatedProjData> _normalisation_gated_proj_data_sptr;
  std::string _normalisation_filename_prefix;
  shared_ptr<ProjectorByBinPair> _projector_pair_ptr;
  bool _zero_seg0_end_planes;
  int _motion_correction_type; // This could be set up in a more generic way in order to choose how motion correction will be
                               // applied//
  GatedSpatialTransformation _motion_vectors;
  GatedSpatialTransformation _reverse_motion_vectors;

  GatedDiscretisedDensity _gated_image_template;
  bool actual_subsets_are_approximately_balanced(std::string& warning_message) const override;

  void set_defaults() override;
  void initialise_keymap() override;
  bool post_processing() override;
};
 
END_NAMESPACE_STIR
 
#endif