ProjDataInfo.h

Go to the documentation of this file.

//
//
/*
    Copyright (C) 2000 PARAPET partners
    Copyright (C) 2000 - 2011-10-14, Hammersmith Imanet Ltd
    Copyright (C) 2011-07-01 - 2011, Kris Thielemans
    Copyright (C) 2016-17, University of Hull
    Copyright (C) 2017-2018, 2020, 2022, 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_ProjDataInfo_H__
#define __stir_ProjDataInfo_H__
 
#include "stir/SegmentIndices.h"
#include "stir/ViewgramIndices.h"
#include "stir/SinogramIndices.h"
#include "stir/VectorWithOffset.h"
#include "stir/Scanner.h"
#include "stir/shared_ptr.h"
#include "stir/unique_ptr.h"
#include <string>
#include <memory>
 
START_NAMESPACE_STIR
 
template <typename elemT>
class Sinogram;
template <typename elemT>
class Viewgram;
template <typename elemT>
class SegmentByView;
template <typename elemT>
class SegmentBySinogram;
template <typename elemT>
class RelatedViewgrams;
class DataSymmetriesForViewSegmentNumbers;
class ViewSegmentNumbers;
class Bin;
template <typename T>
class LOR;
template <typename T>
class LORInAxialAndNoArcCorrSinogramCoordinates;
class PMessage;

class ProjDataInfo
{
protected:
  typedef ProjDataInfo root_type;
 
public:
  /********** static members **************/

  static ProjDataInfo* ask_parameters();


  static ProjDataInfo* ProjDataInfoGE(const shared_ptr<Scanner>& scanner_ptr,
                                      const int max_delta,
                                      const int num_views,
                                      const int num_tangential_poss,
                                      const bool arc_corrected = true,
                                      const int tof_mash_factor = 0);


  static ProjDataInfo* ProjDataInfoCTI(const shared_ptr<Scanner>& scanner_ptr,
                                       const int span,
                                       const int max_delta,
                                       const int num_views,
                                       const int num_tangential_poss,
                                       const bool arc_corrected = true,
                                       const int tof_mash_factor = 0);


  static unique_ptr<ProjDataInfo> construct_proj_data_info(const shared_ptr<Scanner>& scanner_sptr,
                                                           const int span,
                                                           const int max_delta,
                                                           const int num_views,
                                                           const int num_tangential_poss,
                                                           const bool arc_corrected = true,
                                                           const int tof_mash_factor = 0);
 
  /************ constructors ***********/
  // TODO should probably be protected

  ProjDataInfo();


  ProjDataInfo(const shared_ptr<Scanner>& scanner_ptr,
               const VectorWithOffset<int>& num_axial_pos_per_segment,
               const int num_views,
               const int num_tangential_poss);

  ProjDataInfo(const shared_ptr<Scanner>& scanner_ptr,
               const VectorWithOffset<int>& num_axial_pos_per_segment,
               const int num_views,
               const int num_tangential_poss,
               const int tof_mash_factor);

  virtual ProjDataInfo* clone() const = 0;

  inline shared_ptr<ProjDataInfo> create_shared_clone() const;

  inline shared_ptr<ProjDataInfo> create_non_tof_clone() const;

  virtual ~ProjDataInfo() {}
 
  /**************** member functions *********/
 
  //  ProjDataInfo& operator=(const ProjDataInfo&);




  virtual void reduce_segment_range(const int min_segment_num, const int max_segment_num);

  virtual void set_num_views(const int num_views);

  virtual void set_num_tangential_poss(const int num_tang_poss);

  virtual void set_num_axial_poss_per_segment(const VectorWithOffset<int>& num_axial_poss_per_segment);


  virtual void set_min_axial_pos_num(const int min_ax_pos_num, const int segment_num);

  virtual void set_max_axial_pos_num(const int max_ax_pos_num, const int segment_num);


  virtual void set_min_tangential_pos_num(const int min_tang_poss);

  virtual void set_max_tangential_pos_num(const int max_tang_poss);

  virtual void set_tof_mash_factor(const int new_num);



  inline int get_num_segments() const;
  inline int get_num_axial_poss(const int segment_num) const;
  inline int get_num_views() const;
  inline int get_num_tangential_poss() const;
  inline int get_tof_bin(const double delta) const;
#if 0
// KT: code disabled as buggy but currently not needed
  inline int get_unmashed_tof_bin(const double delta) const;
#endif
  inline int get_num_tof_poss() const;
  inline int get_min_segment_num() const;
  inline int get_max_segment_num() const;
  inline int get_min_axial_pos_num(const int segment_num) const;
  inline int get_max_axial_pos_num(const int segment_num) const;
  inline int get_min_view_num() const;
  inline int get_max_view_num() const;
  inline int get_min_tangential_pos_num() const;
  inline int get_max_tangential_pos_num() const;
  /* 0 indicates non-TOF data, as well as the max number of TOF bins for the scanner
   (as all TOF bins will then be added). */
  inline int get_tof_mash_factor() const;
  inline int get_min_tof_pos_num() const;
  inline int get_max_tof_pos_num() const;


  inline int get_num_sinograms() const;

  inline int get_num_non_tof_sinograms() const;
  inline std::size_t size_all() const;

  inline bool is_tof_data() const;


  virtual std::vector<int> get_original_view_nums() const;
 
  //| \name Functions that return geometrical info for a Bin

  virtual float get_tantheta(const Bin&) const = 0;


  inline float get_costheta(const Bin&) const;


  virtual float get_phi(const Bin&) const = 0;


  virtual float get_t(const Bin&) const = 0;


  virtual inline float get_m(const Bin&) const;


  virtual float get_s(const Bin&) const = 0;

  float get_k(const Bin&) const;

  double get_tof_delta_time(const Bin&) const;


  virtual void get_LOR(LORInAxialAndNoArcCorrSinogramCoordinates<float>&, const Bin&) const = 0;



  virtual float get_sampling_in_t(const Bin&) const;


  virtual float get_sampling_in_m(const Bin&) const;


  virtual float get_sampling_in_s(const Bin&) const;

  float get_sampling_in_k(const Bin&) const;


  virtual Bin get_bin(const LOR<float>&, const double delta_time = 0.0) const = 0;



  bool operator==(const ProjDataInfo& proj) const;
 
  bool operator!=(const ProjDataInfo& proj) const;

  virtual bool operator>=(const ProjDataInfo& proj) const;




  Viewgram<float> get_empty_viewgram(const ViewgramIndices&) const;
  Sinogram<float> get_empty_sinogram(const SinogramIndices&) const;
  SegmentByView<float> get_empty_segment_by_view(const SegmentIndices&) const;
  SegmentBySinogram<float> get_empty_segment_by_sinogram(const SegmentIndices&) const;


  Viewgram<float> get_empty_viewgram(const int view_num,
                                     const int segment_num,
                                     const bool make_num_tangential_poss_odd = false,
                                     const int timing_pos_num = 0) 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_num = 0) const;


  SegmentByView<float> get_empty_segment_by_view(const int segment_num,
                                                 const bool make_num_tangential_poss_odd = false,
                                                 const int timing_pos_num = 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_num = 0) const;


  // TODOTOF
  RelatedViewgrams<float> get_empty_related_viewgrams(const ViewgramIndices&,
                                                      const shared_ptr<DataSymmetriesForViewSegmentNumbers>&,
                                                      const bool make_num_tangential_poss_odd = false,
                                                      const int timing_pos_num = 0) const;

  inline const Scanner* get_scanner_ptr() const;

  inline shared_ptr<Scanner> get_scanner_sptr() const;

  virtual std::string parameter_info() const;

  struct Float1Float2
  {
    float low_lim;
    float high_lim;
  };

  mutable VectorWithOffset<Float1Float2> tof_bin_boundaries_mm;
  mutable VectorWithOffset<Float1Float2> tof_bin_boundaries_ps;
#if 0
  mutable VectorWithOffset<Float1Float2> tof_bin_unmashed_boundaries_mm;
  mutable VectorWithOffset<Float1Float2> tof_bin_unmashed_boundaries_ps;
#endif

  void set_bed_position_horizontal(const float bed_position_horizontal_arg)
  {
    bed_position_horizontal = bed_position_horizontal_arg;
  }

  float get_bed_position_horizontal() const
  {
    return bed_position_horizontal;
  }

  void set_bed_position_vertical(const float bed_position_vertical_arg)
  {
    bed_position_vertical = bed_position_vertical_arg;
  }

  float get_bed_position_vertical() const
  {
    return bed_position_vertical;
  }
 
  inline bool has_energy_information() const
  {
    return scanner_ptr->has_energy_information();
  }
 
protected:
  virtual bool blindly_equals(const root_type* const) const = 0;
 
private:
  shared_ptr<Scanner> scanner_ptr;
  int min_view_num;
  int max_view_num;
  int min_tangential_pos_num;
  int max_tangential_pos_num;
  int min_tof_pos_num;
  int max_tof_pos_num;
#if 0
  int min_unmashed_tof_pos_num;
  int max_unmashed_tof_pos_num;
#endif
  int tof_mash_factor;
  float tof_increament_in_mm;
  int num_tof_bins;
  VectorWithOffset<int> min_axial_pos_per_seg;
  VectorWithOffset<int> max_axial_pos_per_seg;
  float bed_position_horizontal;
  float bed_position_vertical;
};
 
END_NAMESPACE_STIR
 
#include "stir/ProjDataInfo.inl"
 
#endif //  __ProjDataInfo_H__