MultipleProjData.h

Go to the documentation of this file.

/*
    Copyright (C) 2005 - 2007-10-08, Hammersmith Imanet Ltd
    Copyright (C) 2013, Kris Thielemans
    Copyright (C) 2013, 2016-2020 University College London
    This file is part of STIR.

    SPDX-License-Identifier: Apache-2.0

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

#include "stir/ProjData.h"
#include "stir/ExamData.h"
#include "stir/shared_ptr.h"
#include "stir/Array.h"
#include "stir/is_null_ptr.h"
#include "stir/copy_fill.h"
#include "stir/error.h"
//#include "stir/Scanner.h"
#include <vector>

START_NAMESPACE_STIR

class MultipleProjData : public ExamData
{
public:
  MultipleProjData()
      : ExamData()
  {}

  MultipleProjData(const shared_ptr<const ExamInfo>& exam_info_sptr)
      : ExamData(exam_info_sptr)
  {}

  MultipleProjData(const shared_ptr<const ExamInfo>& exam_info_sptr, const int num_gates);

  static unique_ptr<MultipleProjData> read_from_file(const std::string& parameter_file);

  // N.E.14/07/16 Inherited from ExamData
  //  //! Get a pointer to the exam information
  //  const ExamInfo*
  //    get_exam_info_ptr() const
  //  {
  //    return this->_exam_info_sptr.get();
  //  }

  //  //! Get a shared pointer to the exam information
  //  shared_ptr<ExamInfo>
  //    get_exam_info_sptr() const
  //  {
  //    return this->_exam_info_sptr;
  //  }

  unsigned get_num_proj_data() const { return static_cast<unsigned>(this->_proj_datas.size()); }

  std::size_t get_proj_data_size() const { return _proj_datas.at(0)->size_all(); }


  void resize(const unsigned new_size) { this->_proj_datas.resize(new_size); }


  void set_proj_data_sptr(const shared_ptr<ProjData>& proj_data_sptr, const unsigned int index);
  const ProjData& operator[](const unsigned int index) const
  {
    assert(index >= 1);
    assert(index <= this->get_num_proj_data());
    return *this->_proj_datas[index - 1];
  }
  const ProjData& get_proj_data(const unsigned int index) const { return (*this)[index]; }

  shared_ptr<ProjData> get_proj_data_sptr(const unsigned int index) const
  {
    assert(index >= 1);
    assert(index <= this->get_num_proj_data());
    return this->_proj_datas[index - 1];
  }

  const shared_ptr<const ProjDataInfo> get_proj_data_info_sptr() const;
  // return get_proj_data_sptr(1))->get_proj_data_info_sptr()

  unsigned int get_num_gates() const { return static_cast<unsigned int>(_proj_datas.size()); }

  template <typename iterT>
  iterT copy_to(iterT array_iter) const
  {
    for (std::vector<shared_ptr<ProjData>>::const_iterator it = _proj_datas.begin(); it != _proj_datas.end(); ++it)
      {
        if (is_null_ptr(*(it)))
          error("Dynamic/gated ProjData have not been properly allocated. Abort.");

        array_iter = stir::copy_to(*(*it), array_iter);
      }
    return array_iter;
  }

  template <typename iterT>
  void fill_from(iterT array_iter)
  {
    for (std::vector<shared_ptr<ProjData>>::iterator it = _proj_datas.begin(); it != _proj_datas.end(); ++it)
      {
        if (is_null_ptr(*(it)))
          error("Dynamic ProjData have not been properly allocated.Abort.");

        array_iter = (*it)->fill_from(array_iter);
      }
  }

  std::size_t size_all() const
  {
    std::size_t size = 0;
    for (std::size_t i_gate = 0; i_gate < this->get_num_gates(); i_gate++)
      size += _proj_datas.at(i_gate)->size_all();

    return size;
  }

protected:
  std::vector<shared_ptr<ProjData>> _proj_datas;
  // shared_ptr<Scanner> _scanner_sptr;
protected:
  // N.E:14/07/16 Inherited from ExamData.
  //  shared_ptr<ExamInfo> _exam_info_sptr;
};


template <>
struct CopyFill<MultipleProjData>
{
  template <typename iterT>
  static iterT copy_to(const MultipleProjData& stir_object, iterT iter)
  {
    // std::cerr<<"Using MultipleProjData::copy_to\n";
    return stir_object.copy_to(iter);
  }
};


template <typename iterT>
void
fill_from(MultipleProjData& stir_object, iterT iter, iterT /*iter_end*/)
{
  return stir_object.fill_from(iter);
}

END_NAMESPACE_STIR
#endif