DynamicDiscretisedDensity.h

Go to the documentation of this file.

//
//
/*
    Copyright (C) 2005 - 2011-01-12, Hammersmith Imanet Ltd
    Copyright (C) 2011-07-01 - 2011, Kris Thielemans
    Copyright (C) 2018-2020 University College London
    This file is part of STIR.

    SPDX-License-Identifier: Apache-2.0

    See STIR/LICENSE.txt for details
*/

#ifndef __stir_DynamicDiscretisedDensity_H__
#define __stir_DynamicDiscretisedDensity_H__

#include "stir/DiscretisedDensity.h"
#include "stir/shared_ptr.h"
#include "stir/TimeFrameDefinitions.h"
#include "stir/Scanner.h"
#include "stir/NestedIterator.h"
#include "stir/is_null_ptr.h"
#include <vector>
#include <string>

START_NAMESPACE_STIR

class Succeeded;

class DynamicDiscretisedDensity : public ExamData
{
public:

  typedef DynamicDiscretisedDensity hierarchy_base_type;

  typedef DiscretisedDensity<3, float> singleDiscDensT;

private:
  typedef std::vector<shared_ptr<singleDiscDensT>> DensitiesT;

public:
  typedef NestedIterator<DensitiesT::iterator, PtrBeginEndAllFunction<DensitiesT::iterator>> full_iterator;
  typedef NestedIterator<DensitiesT::const_iterator, ConstPtrBeginEndAllFunction<DensitiesT::const_iterator>> const_full_iterator;

  static DynamicDiscretisedDensity* read_from_file(const std::string& filename);

  DynamicDiscretisedDensity() {}

  DynamicDiscretisedDensity(const DynamicDiscretisedDensity& argument);

  DynamicDiscretisedDensity(const TimeFrameDefinitions& time_frame_definitions,
                            const double scan_start_time_in_secs_since_1970,
                            const shared_ptr<Scanner>& scanner_sptr)
  {
    _densities.resize(time_frame_definitions.get_num_frames());
    shared_ptr<ExamInfo> _exam_info_sptr(new ExamInfo);
    _exam_info_sptr->set_time_frame_definitions(time_frame_definitions);
    _exam_info_sptr->start_time_in_secs_since_1970 = scan_start_time_in_secs_since_1970;
    this->exam_info_sptr = _exam_info_sptr;
    _scanner_sptr = scanner_sptr;
  }
  DynamicDiscretisedDensity(const TimeFrameDefinitions& time_frame_definitions,
                            const double scan_start_time_in_secs_since_1970,
                            const shared_ptr<Scanner>& scanner_sptr,
                            const shared_ptr<singleDiscDensT>& density_sptr)
  {
    _densities.resize(time_frame_definitions.get_num_frames());
    shared_ptr<ExamInfo> _exam_info_sptr;
    if (is_null_ptr(density_sptr->get_exam_info_sptr()))
      _exam_info_sptr.reset(new ExamInfo);
    else
      _exam_info_sptr = density_sptr->get_exam_info_sptr()->create_shared_clone();
    _exam_info_sptr->set_time_frame_definitions(time_frame_definitions);
    _exam_info_sptr->start_time_in_secs_since_1970 = scan_start_time_in_secs_since_1970;
    this->exam_info_sptr = _exam_info_sptr;

    _scanner_sptr = scanner_sptr;

    for (unsigned int frame_num = 1; frame_num <= time_frame_definitions.get_num_frames(); ++frame_num)
      {
        shared_ptr<singleDiscDensT> density_frame_sptr(density_sptr->get_empty_copy());
        ExamInfo this_exam_info(*exam_info_sptr);
        this_exam_info.set_time_frame_definitions(TimeFrameDefinitions(time_frame_definitions, frame_num));
        density_frame_sptr->set_exam_info(this_exam_info);
        this->_densities[frame_num - 1] = density_frame_sptr;
      }
  }

  DynamicDiscretisedDensity& operator=(const DynamicDiscretisedDensity& argument);

  inline full_iterator begin_all();
  inline const_full_iterator begin_all() const;
  inline const_full_iterator begin_all_const() const;
  inline full_iterator end_all();
  inline const_full_iterator end_all() const;
  inline const_full_iterator end_all_const() const;

  void set_density(const singleDiscDensT& density, const unsigned int frame_num);
  /*
    DynamicDiscretisedDensity(  TimeFrameDefinitions time_frame_defintions,shared_ptr<Scanner>,
    std::vector<shared_ptr<DiscretiseDensity<3,float> > _densities);
  */

  const std::vector<shared_ptr<singleDiscDensT>>& get_densities() const;

  const singleDiscDensT& get_density(const unsigned int frame_num) const;

  const singleDiscDensT& operator[](const unsigned int frame_num) const { return this->get_density(frame_num); }

  singleDiscDensT& get_density(const unsigned int frame_num);

  singleDiscDensT& operator[](const unsigned int frame_num) { return this->get_density(frame_num); }

  const float get_isotope_halflife() const;

  float get_calibration_factor() const;

  const singleDiscDensT& at(const unsigned int frame_num) const { return this->get_density(frame_num); }

  singleDiscDensT& at(const unsigned int frame_num) { return this->get_density(frame_num); }


  const double get_start_time_in_secs_since_1970() const;

  const float get_scanner_default_bin_size() const;

  void set_time_frame_definitions(const TimeFrameDefinitions& time_frame_definitions)
  {
    shared_ptr<ExamInfo> sptr = this->exam_info_sptr->create_shared_clone();
    sptr->set_time_frame_definitions(time_frame_definitions);
    this->exam_info_sptr = sptr;
  }

  void set_scanner(const Scanner& scanner) { this->_scanner_sptr.reset(new Scanner(scanner)); }

  const TimeFrameDefinitions& get_time_frame_definitions() const;

  unsigned get_num_time_frames() const { return this->get_time_frame_definitions().get_num_time_frames(); }

  Succeeded write_to_ecat7(const std::string& filename) const;

  void calibrate_frames() const;
  void decay_correct_frames();
  void set_if_decay_corrected(const bool is_decay_corrected);
  void set_calibration_factor(const float calibration_factor);
  void set_num_densities(const int num_densities) { _densities.resize(num_densities); }

private:
  // warning: if adding any new members, you have to change the copy constructor as well.
  // TimeFrameDefinitions _time_frame_definitions;
  DensitiesT _densities;
  shared_ptr<Scanner> _scanner_sptr;
  bool _is_decay_corrected;
  // double _start_time_in_secs_since_1970;
};

END_NAMESPACE_STIR

#include "stir/DynamicDiscretisedDensity.inl"

#endif //__stir_DynamicDiscretisedDensity_H__