ProjData.h

Go to the documentation of this file.

/*
    Copyright (C) 2000 PARAPET partners
    Copyright (C) 2000- 2012, Hammersmith Imanet Ltd
    Copyright (C) 2016, 2017, University of Hull
    Copyright (C) 2013, 2015-2017, 2020, 2023 University College London
    This file is part of STIR.
 
    SPDX-License-Identifier: Apache-2.0 AND License-ref-PARAPET-license
 
    See STIR/LICENSE.txt for details
*/
#ifndef __stir_ProjData_H__
#define __stir_ProjData_H__
 
#include "stir/Array.h"
#include "stir/shared_ptr.h"
#include "stir/ProjDataInfo.h"
#include <string>
#include <iostream>
#include "stir/Succeeded.h"
#include "stir/SegmentBySinogram.h"
#include "stir/SegmentByView.h"
#include "stir/SegmentIndices.h"
#include "stir/ViewgramIndices.h"
#include "stir/SinogramIndices.h"
 
//#include <ios>
 
#include "stir/ExamData.h"
#include "stir/DataWithProjDataInfo.h"
 
START_NAMESPACE_STIR
 
template <typename elemT>
class RelatedViewgrams;
class DataSymmetriesForViewSegmentNumbers;
template <typename elemT>
class SegmentBySinogram;
template <typename elemT>
class SegmentByView;
template <typename elemT>
class Viewgram;
template <typename elemT>
class Sinogram;
class Succeeded;
class ProjDataInMemory;
// class ExamInfo;

class ProjData : public ExamData, public DataWithProjDataInfo
{
#ifdef STIR_COMPILING_SWIG_WRAPPER
public: // SWIG needs self_type exposed
#endif
  typedef ProjData self_type;
 
public:
  static shared_ptr<ProjData> read_from_file(const std::string& filename, const std::ios::openmode open_mode = std::ios::in);

  ProjData();
  ProjData(const shared_ptr<const ExamInfo>& exam_info_sptr, const shared_ptr<const ProjDataInfo>& proj_data_info_ptr);
#if 0
  // it would be nice to have something like this. However, it's implementation
  // normally fails as we'd need to use set_viewgram or so, which is virtual, but
  // this doesn't work inside a constructor
  ProjData(const ProjData&);
#endif


  virtual Viewgram<float> get_viewgram(const int view,
                                       const int segment_num,
                                       const bool make_num_tangential_poss_odd = false,
                                       const int timing_pos = 0) const = 0;
  inline Viewgram<float> get_viewgram(const ViewgramIndices&) const;

  virtual Succeeded set_viewgram(const Viewgram<float>&) = 0;

  virtual Sinogram<float> get_sinogram(const int ax_pos_num,
                                       const int segment_num,
                                       const bool make_num_tangential_poss_odd = false,
                                       const int timing_pos = 0) const = 0;
  inline Sinogram<float> get_sinogram(const SinogramIndices&) const;

  virtual Succeeded set_sinogram(const Sinogram<float>&) = 0;
  // //! Get Bin value
  // virtual float get_bin_value(const Bin& this_bin) const = 0;

  unique_ptr<ProjDataInMemory> get_subset(const std::vector<int>& views) const;

  Viewgram<float> get_empty_viewgram(const ViewgramIndices&) const;


  Viewgram<float> get_empty_viewgram(const int view,
                                     const int segment_num,
                                     const bool make_num_tangential_poss_odd = false,
                                     const int timing_pos = 0) const;

  Sinogram<float> get_empty_sinogram(const SinogramIndices&) const;


  Sinogram<float> get_empty_sinogram(const int ax_pos_num,
                                     const int segment_num,
                                     const bool make_num_tangential_poss_odd = false,
                                     const int timing_pos = 0) const;

  SegmentByView<float> get_empty_segment_by_view(const SegmentIndices&) const;
  SegmentBySinogram<float> get_empty_segment_by_sinogram(const SegmentIndices&) const;

  SegmentByView<float> get_empty_segment_by_view(const int segment_num,
                                                 const bool make_num_tangential_poss_odd = false,
                                                 const int timing_pos = 0) const;

  SegmentBySinogram<float> get_empty_segment_by_sinogram(const int segment_num,
                                                         const bool make_num_tangential_poss_odd = false,
                                                         const int timing_pos = 0) const;


  virtual SegmentBySinogram<float> get_segment_by_sinogram(const int segment_num, const int timing_pos = 0) const;

  inline SegmentBySinogram<float> get_segment_by_sinogram(const SegmentIndices&) const;


  virtual SegmentByView<float> get_segment_by_view(const int segment_num, const int timing_pos = 0) const;

  inline SegmentByView<float> get_segment_by_view(const SegmentIndices&) const;

  virtual Succeeded set_segment(const SegmentBySinogram<float>&);
  virtual Succeeded set_segment(const SegmentByView<float>&);

  // TODOTOF remove timing_pos arg
  virtual RelatedViewgrams<float> get_related_viewgrams(const ViewgramIndices&,
                                                        const shared_ptr<DataSymmetriesForViewSegmentNumbers>&,
                                                        const bool make_num_tangential_poss_odd = false,
                                                        const int timing_pos = 0) const;
  virtual Succeeded set_related_viewgrams(const RelatedViewgrams<float>& viewgrams);
  //  //! Get related bin values
  //  //! \todo This function temporaliry has as input a vector<Bin> instead this should be replaced by RelatedBins.
  //  std::vector<float> get_related_bin_values(const std::vector<Bin>&) const;

  RelatedViewgrams<float> get_empty_related_viewgrams(const ViewgramIndices& viewgram_indices,
                                                      const shared_ptr<DataSymmetriesForViewSegmentNumbers>& symmetries_ptr,
                                                      const bool make_num_tangential_poss_odd = false,
                                                      const int timing_pos = 0) const;


  virtual void fill(const float value);


  virtual void fill(const ProjData&);


  static std::vector<int> standard_segment_sequence(const ProjDataInfo& pdi);


  template <typename iterT>
  iterT fill_from(iterT array_iter)
  {
    // A type check would be useful.
    //      BOOST_STATIC_ASSERT((boost::is_same<typename std::iterator_traits<iterT>::value_type, Type>::value));
 
    for (int k = this->get_proj_data_info_sptr()->get_min_tof_pos_num();
         k <= this->get_proj_data_info_sptr()->get_max_tof_pos_num();
         ++k)
      {
        for (int s : standard_segment_sequence(*this->get_proj_data_info_sptr()))
          {
            auto segment = this->get_empty_segment_by_sinogram(s, false, k);
            // cannot use std::copy sadly as needs end-iterator for range
            for (auto seg_iter = segment.begin_all(); seg_iter != segment.end_all();
                 /*empty*/)
              *seg_iter++ = *array_iter++;
            this->set_segment(segment);
          }
      }
    return array_iter;
  }


  template <typename iterT>
  iterT copy_to(iterT array_iter) const
  {
    for (int k = this->get_proj_data_info_sptr()->get_min_tof_pos_num();
         k <= this->get_proj_data_info_sptr()->get_max_tof_pos_num();
         ++k)
      {
        for (int s : standard_segment_sequence(*this->get_proj_data_info_sptr()))
          {
            const auto segment = this->get_segment_by_sinogram(s, k);
            array_iter = std::copy(segment.begin_all_const(), segment.end_all_const(), array_iter);
          }
      }
    return array_iter;
  }


  inline int get_num_sinograms() const;

  inline int get_num_non_tof_sinograms() const;
  inline std::size_t size_all() const;
  inline std::vector<int> get_original_view_nums() const;

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

  virtual float sum() const;

  virtual float find_max() const;

  virtual float find_min() const;

  virtual double norm() const;

  virtual double norm_squared() const;

  virtual self_type& operator+=(const self_type& v);

  virtual self_type& operator-=(const self_type& v);

  virtual self_type& operator*=(const self_type& v);

  virtual self_type& operator/=(const self_type& v);

  virtual self_type& operator+=(const float v);

  virtual self_type& operator-=(const float v);

  virtual self_type& operator*=(const float v);

  virtual self_type& operator/=(const float v);

  STIR_DEPRECATED virtual void axpby(const float a, const ProjData& x, const float b, const ProjData& y);

  virtual void xapyb(const ProjData& x, const float a, const ProjData& y, const float b);

  virtual void xapyb(const ProjData& x, const ProjData& a, const ProjData& y, const ProjData& b);

  virtual void sapyb(const float a, const ProjData& y, const float b);

  virtual void sapyb(const ProjData& a, const ProjData& y, const ProjData& b);
};
 
END_NAMESPACE_STIR
 
#include "stir/ProjData.inl"
#endif