NiftyPETHelper.h

Go to the documentation of this file.

//
//
 
#ifndef __stir_gpu_NiftyPETHelper_h__
#define __stir_gpu_NiftyPETHelper_h__
/*
    Copyright (C) 2019-2020, University College London
    This file is part of STIR.
 
    SPDX-License-Identifier: Apache-2.0
 
    See STIR/LICENSE.txt for details
*/
 
#include "stir/shared_ptr.h"
#include "stir/Scanner.h"
 
// Forward declarations
struct Cnst;
struct txLUTs;
struct axialLUT;
 
START_NAMESPACE_STIR
 
template <int num_dimensions, typename elemT>
class DiscretisedDensity;
class ProjData;
template <typename elemT>
class Viewgram;
template <typename elemT>
class VoxelsOnCartesianGrid;

class NiftyPETHelper
{
public:
  NiftyPETHelper()
      : _already_set_up(false),
        _span(-1),
        _devid(0),
        _att(-1),
        _scanner_type(Scanner::Unknown_scanner)
  {}

  virtual ~NiftyPETHelper();

  void set_cuda_device_id(const int devid) { _devid = char(devid); }

  void set_span(const char span) { _span = span; }

  void set_att(const char att) { _att = att; }

  void set_verbose(const bool verbose) { _verbose = verbose; }

  void set_scanner_type(const Scanner::Type scanner_type) { _scanner_type = scanner_type; }

  void set_up();

  static std::vector<float> create_niftyPET_image();

  static shared_ptr<VoxelsOnCartesianGrid<float>> create_stir_im();

  std::vector<float> create_niftyPET_sinogram_no_gaps() const;

  std::vector<float> create_niftyPET_sinogram_with_gaps() const;

  static void convert_image_stir_to_niftyPET(std::vector<float>& np, const DiscretisedDensity<3, float>& stir);

  static void convert_image_niftyPET_to_stir(DiscretisedDensity<3, float>& stir, const std::vector<float>& np_vec);

  void convert_proj_data_stir_to_niftyPET(std::vector<float>& np_vec, const ProjData& stir) const;

  void convert_viewgram_stir_to_niftyPET(std::vector<float>& np_vec, const Viewgram<float>& viewgram) const;

  void convert_proj_data_niftyPET_to_stir(ProjData& stir_sptr, const std::vector<float>& np_vec) const;

  void remove_gaps(std::vector<float>& sino_no_gaps, const std::vector<float>& sino_w_gaps) const;

  void put_gaps(std::vector<float>& sino_w_gaps, const std::vector<float>& sino_no_gaps) const;

  void back_project(std::vector<float>& image, const std::vector<float>& sino_no_gaps) const;

  void forward_project(std::vector<float>& sino_no_gaps, const std::vector<float>& image) const;

  static shared_ptr<ProjData> create_stir_sino();

  void lm_to_proj_data(shared_ptr<ProjData>& prompts_sptr,
                       shared_ptr<ProjData>& delayeds_sptr,
                       shared_ptr<ProjData>& randoms_sptr,
                       shared_ptr<ProjData>& norm_sptr,
                       const int tstart,
                       const int tstop,
                       const std::string& lm_binary_file,
                       const std::string& norm_binary_file = "") const;
 
private:
  void check_set_up() const;

  void permute(std::vector<float>& output_array,
               const std::vector<float>& orig_array,
               const unsigned output_dims[3],
               const unsigned* permute_order) const;

  unsigned convert_NiftyPET_proj_3d_to_1d_idx(const unsigned ang, const unsigned bins, const unsigned sino) const;

  void convert_NiftyPET_proj_1d_to_3d_idx(unsigned& ang, unsigned& bins, unsigned& sino, const unsigned idx) const;
 
  bool _already_set_up;
  char _span;
  char _devid;
  shared_ptr<Cnst> _cnt_sptr;
  int _nsinos;
  char _att;
  std::vector<int> _isub;
  bool _verbose;
  Scanner::Type _scanner_type;
  shared_ptr<txLUTs> _txlut_sptr;
  shared_ptr<axialLUT> _axlut_sptr;
 
  std::vector<float> _crs;
  std::vector<short> _s2c;
 
  // Get axLUT
  std::vector<float> _li2rng;
  std::vector<short> _li2sn;
  std::vector<char> _li2nos;
};
 
END_NAMESPACE_STIR
 
#endif // __stir_gpu_NiftyPETHelper_h__