GeneralisedObjectiveFunction.h

Go to the documentation of this file.

//
//
/*
    Copyright (C) 2003- 2009, Hammersmith Imanet Ltd
    Copyright (C) 2018, 2020, 2024 University College London
    Copyright (C) 2016, University of Hull
    This file is part of STIR.

    SPDX-License-Identifier: Apache-2.0

    See STIR/LICENSE.txt for details
*/
#ifndef __stir_recon_buildblock_GeneralisedObjectiveFunction_H__
#define __stir_recon_buildblock_GeneralisedObjectiveFunction_H__

#include "stir/RegisteredObject.h"
#include "stir/ParsingObject.h"
#include "stir/shared_ptr.h"
#include "stir/recon_buildblock/GeneralisedPrior.h"
#include <string>

#include "stir/ExamData.h"
#include "stir/ProjData.h"
#include "stir/recon_buildblock/BinNormalisation.h"

START_NAMESPACE_STIR

class Succeeded;

template <typename TargetT>
class GeneralisedObjectiveFunction : public RegisteredObject<GeneralisedObjectiveFunction<TargetT>>
{
public:
  GeneralisedObjectiveFunction()
      : already_set_up(false)
  {}

  ~GeneralisedObjectiveFunction() override;


  virtual TargetT* construct_target_ptr() const = 0;

  virtual Succeeded set_up(shared_ptr<TargetT> const& target_sptr);


  virtual void compute_sub_gradient(TargetT& gradient, const TargetT& current_estimate, const int subset_num);


  virtual void compute_sub_gradient_without_penalty(TargetT& gradient, const TargetT& current_estimate, const int subset_num) = 0;


  virtual void compute_gradient(TargetT& gradient, const TargetT& current_estimate);


  virtual void compute_gradient_without_penalty(TargetT& gradient, const TargetT& current_estimate);


  virtual double compute_objective_function_without_penalty(const TargetT& current_estimate, const int subset_num);


  virtual double compute_objective_function_without_penalty(const TargetT& current_estimate);


  double compute_penalty(const TargetT& current_estimate, const int subset_num);

  double compute_penalty(const TargetT& current_estimate);


  double compute_objective_function(const TargetT& current_estimate, const int subset_num);


  double compute_objective_function(const TargetT& current_estimate);

  double compute_value(const TargetT& current_estimate) { return compute_objective_function(current_estimate); }


  virtual void fill_nonidentifiable_target_parameters(TargetT& target, const float value) const {}


  Succeeded add_multiplication_with_approximate_sub_Hessian_without_penalty(TargetT& output,
                                                                            const TargetT& input,
                                                                            const int subset_num) const;
  Succeeded add_multiplication_with_approximate_sub_Hessian(TargetT& output, const TargetT& input, const int subset_num) const;
  Succeeded add_multiplication_with_approximate_Hessian_without_penalty(TargetT& output, const TargetT& input) const;
  Succeeded add_multiplication_with_approximate_Hessian(TargetT& output, const TargetT& input) const;


  Succeeded accumulate_Hessian_times_input(TargetT& output, const TargetT& current_image_estimate, const TargetT& input) const;

  Succeeded accumulate_Hessian_times_input_without_penalty(TargetT& output,
                                                           const TargetT& current_image_estimate,
                                                           const TargetT& input) const;

  Succeeded accumulate_sub_Hessian_times_input(TargetT& output,
                                               const TargetT& current_image_estimate,
                                               const TargetT& input,
                                               const int subset_num) const;
  Succeeded accumulate_sub_Hessian_times_input_without_penalty(TargetT& output,
                                                               const TargetT& current_image_estimate,
                                                               const TargetT& input,
                                                               const int subset_num) const;


  std::string get_objective_function_values_report(const TargetT& current_estimate);

  int get_num_subsets() const;

  //  //! Virtual get normalisation, it will be defined by the derived class
  //  virtual const shared_ptr<BinNormalisation> &
  //  get_normalisation_sptr() const =0;

  virtual std::unique_ptr<ExamInfo> get_exam_info_uptr_for_target() const
  {
    auto exam_info_uptr = unique_ptr<ExamInfo>(new ExamInfo(*(this->get_input_data().get_exam_info_sptr())));
    return exam_info_uptr;
  }


  virtual int set_num_subsets(const int num_subsets) = 0;


  bool subsets_are_approximately_balanced() const;

  bool subsets_are_approximately_balanced(std::string& warning_message) const;

  bool prior_is_zero() const;


  GeneralisedPrior<TargetT>* const get_prior_ptr() const;

  shared_ptr<GeneralisedPrior<TargetT>> get_prior_sptr();


  void set_prior_sptr(const shared_ptr<GeneralisedPrior<TargetT>>&);

  virtual void set_input_data(const shared_ptr<ExamData>&) = 0;


  virtual const ExamData& get_input_data() const = 0;

  virtual void set_additive_proj_data_sptr(const shared_ptr<ExamData>&) = 0;

  virtual void set_normalisation_sptr(const shared_ptr<BinNormalisation>&) = 0;

protected:
  int num_subsets;
  bool already_set_up;

  shared_ptr<GeneralisedPrior<TargetT>> prior_sptr;


  void set_defaults() override;

  void initialise_keymap() override;

  // virtual bool post_processing();


  virtual bool actual_subsets_are_approximately_balanced(std::string& warning_message) const = 0;


  virtual double actual_compute_objective_function_without_penalty(const TargetT& current_estimate, const int subset_num) = 0;


  virtual Succeeded actual_add_multiplication_with_approximate_sub_Hessian_without_penalty(TargetT& output,
                                                                                           const TargetT& input,
                                                                                           const int subset_num) const;


  virtual Succeeded actual_accumulate_sub_Hessian_times_input_without_penalty(TargetT& output,
                                                                              const TargetT& current_image_estimate,
                                                                              const TargetT& input,
                                                                              const int subset_num) const;
};
END_NAMESPACE_STIR

#endif