ProjDataInfoCylindrical.h

Go to the documentation of this file.

/*
    Copyright (C) 2000 PARAPET partners
    Copyright (C) 2000-2009, Hammersmith Imanet Ltd
    Copyright (C) 2013, 2022 University College London
    Copyright (C) 2013, Institute for Bioengineering of Catalonia
    Copyright (C) 2016, University of Hull
    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_ProjDataInfoCylindrical_H__
#define __stir_ProjDataInfoCylindrical_H__

#include "stir/ProjDataInfo.h"
#include "stir/CartesianCoordinate3D.h"
#include <utility>
#include <vector>

START_NAMESPACE_STIR

class Succeeded;

// TODOdoc more
class ProjDataInfoCylindrical : public ProjDataInfo
{
private:
  typedef ProjDataInfo base_type;
  typedef ProjDataInfoCylindrical self_type;

public:
  typedef std::vector<std::pair<int, int>> RingNumPairs;

  ProjDataInfoCylindrical();

  ProjDataInfoCylindrical(const shared_ptr<Scanner>& scanner_ptr,
                          const VectorWithOffset<int>& num_axial_poss_per_segment,
                          const VectorWithOffset<int>& min_ring_diff,
                          const VectorWithOffset<int>& max_ring_diff,
                          const int num_views,
                          const int num_tangential_poss);

  inline float get_tantheta(const Bin&) const override;

  inline float get_phi(const Bin&) const override;

  inline float get_t(const Bin&) const override;


  inline float get_m(const Bin&) const override;

  void get_LOR(LORInAxialAndNoArcCorrSinogramCoordinates<float>& lor, const Bin& bin) const override;
#if 0
  // KT disabled these as untested (and unused)

  void
  get_LOR_as_two_points(CartesianCoordinate3D<float>& coord_1,
                        CartesianCoordinate3D<float>& coord_2,
                        const Bin& bin) const;

  void
  get_LOR_as_two_points_alt(CartesianCoordinate3D<float>& coord_1,
                            CartesianCoordinate3D<float>& coord_2,
                            const int det1,
                            const int det2,
                            const int ring1,
                            const int ring2,
                            const int timing_pos) const;
#endif
  void set_azimuthal_angle_offset(const float angle);
  void set_azimuthal_angle_sampling(const float angle);

  // void set_axial_sampling(const float samp, int segment_num);


  void set_num_views(const int new_num_views) override;

  void set_tof_mash_factor(const int new_num) override;

  inline float get_azimuthal_angle_offset() const;
  inline float get_azimuthal_angle_sampling() const;
  inline float get_sampling_in_t(const Bin&) const override;
  inline float get_sampling_in_m(const Bin&) const override;


  virtual inline float get_axial_sampling(int segment_num) const;

  virtual inline bool axial_sampling_is_uniform() const
  {
    return true;
  }

  inline float get_average_ring_difference(int segment_num) const;
  inline int get_min_ring_difference(int segment_num) const;
  inline int get_max_ring_difference(int segment_num) const;

  void set_min_ring_difference(int min_ring_diff_v, int segment_num);
  void set_max_ring_difference(int max_ring_diff_v, int segment_num);

  void set_num_axial_poss_per_segment(const VectorWithOffset<int>& num_axial_poss_per_segment) override;
  void set_min_axial_pos_num(const int min_ax_pos_num, const int segment_num) override;
  void set_max_axial_pos_num(const int max_ax_pos_num, const int segment_num) override;
  void reduce_segment_range(const int min_segment_num, const int max_segment_num) override;

  inline void set_ring_radii_for_all_views(const VectorWithOffset<float>& new_ring_radius);

  inline VectorWithOffset<float> get_ring_radii_for_all_views() const;

  inline float get_ring_radius() const;

  inline float get_ring_radius(const int view_num) const;
  inline float get_ring_spacing() const;

  void set_ring_spacing(float ring_spacing_v);


  inline int get_view_mashing_factor() const;


  inline Succeeded get_segment_num_for_ring_difference(int& segment_num, const int ring_diff) const;


  inline Succeeded
  get_segment_axial_pos_num_for_ring_pair(int& segment_num, int& axial_pos_num, const int ring1, const int ring2) const;


  inline const RingNumPairs& get_all_ring_pairs_for_segment_axial_pos_num(const int segment_num, const int axial_pos_num) const;

  inline unsigned get_num_ring_pairs_for_segment_axial_pos_num(const int segment_num, const int axial_pos_num) const;


  void get_ring_pair_for_segment_axial_pos_num(int& ring1, int& ring2, const int segment_num, const int axial_pos_num) const;

  std::string parameter_info() const override;

protected:

  bool sampling_corresponds_to_physical_rings;

protected:
  bool blindly_equals(const root_type* const) const override = 0;

private:
  float azimuthal_angle_offset;
  float azimuthal_angle_sampling;
  VectorWithOffset<float> ring_radius;
  float ring_spacing;
  VectorWithOffset<int> min_ring_diff;
  VectorWithOffset<int> max_ring_diff;

  /*
    Next members have to be mutable as they can be modified by const member
    functions. We need this because of the presence of set_min_ring_difference()
    which invalidates these precalculated arrays.
    If your compiler does not support mutable (and you don't want to upgrade
    it to something more sensible), your best bet is to remove the
    set_*ring_difference functions, and move the content of
    initialise_ring_diff_arrays() to the constructor. (Not recommended!)
  */

  mutable bool ring_diff_arrays_computed;
  mutable VectorWithOffset<float> m_offset;

  mutable VectorWithOffset<int> ax_pos_num_offset;
  mutable VectorWithOffset<int> ring_diff_to_segment_num;
  mutable VectorWithOffset<VectorWithOffset<int>> segment_axial_pos_to_ring1_plus_ring2;

  void initialise_ring_diff_arrays() const;


  inline void initialise_ring_diff_arrays_if_not_done_yet() const;

  inline int get_num_axial_poss_per_ring_inc(const int segment_num) const;

  mutable VectorWithOffset<VectorWithOffset<shared_ptr<RingNumPairs>>> segment_axial_pos_to_ring_pair;

  void allocate_segment_axial_pos_to_ring_pair() const;


  void compute_segment_axial_pos_to_ring_pair(const int segment_num, const int axial_pos_num) const;
};

END_NAMESPACE_STIR

#include "stir/ProjDataInfoCylindrical.inl"

#endif