ProjDataInMemory.h

Go to the documentation of this file.

/*
 *  Copyright (C) 2016, UCL
    Copyright (C) 2002 - 2011-02-23, Hammersmith Imanet Ltd
    Copyright (C) 2019-2020, 2023, UCL
    This file is part of STIR.

    SPDX-License-Identifier: Apache-2.0

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

#include "stir/ProjData.h"
#include "stir/Array.h"
#include <string>

START_NAMESPACE_STIR

class Succeeded;

class ProjDataInMemory : public ProjData
{
#ifdef STIR_COMPILING_SWIG_WRAPPER
  // SWIG needs this typedef to be public
public:
#endif
  typedef ProjDataInMemory self_type;
  typedef ProjData base_type;

public:

  ProjDataInMemory(shared_ptr<const ExamInfo> const& exam_info_sptr,
                   shared_ptr<const ProjDataInfo> const& proj_data_info_ptr,
                   const bool initialise_with_0 = true);

  ProjDataInMemory(const ProjData& proj_data);

  ProjDataInMemory(const ProjDataInMemory& proj_data);

  static shared_ptr<ProjDataInMemory> read_from_file(const std::string& filename);

  Viewgram<float> get_viewgram(const int view_num,
                               const int segment_num,
                               const bool make_num_tangential_poss_odd = false,
                               const int timing_pos = 0) const override;
  Succeeded set_viewgram(const Viewgram<float>& v) override;

  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 override;

  Succeeded set_sinogram(const Sinogram<float>& s) override;

  SegmentBySinogram<float> get_segment_by_sinogram(const int segment_num, const int timing_pos = 0) const override;
  SegmentByView<float> get_segment_by_view(const int segment_num, const int timing_pos = 0) const override;

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


  void fill(const float value) override;


  void fill(const ProjData&) override;

  ~ProjDataInMemory() override;

  float get_bin_value(Bin& bin);

  void set_bin_value(const Bin& bin);

  float sum() const override;

  float find_max() const override;

  float find_min() const override;

  double norm() const override;

  double norm_squared() const override;

  self_type operator+(const self_type& iv) const;

  self_type operator-(const self_type& iv) const;

  self_type operator*(const self_type& iv) const;

  self_type operator/(const self_type& iv) const;

  self_type operator+(const float a) const;

  self_type operator-(const float a) const;

  self_type operator*(const float a) const;

  self_type operator/(const float a) const;

  // corresponding assignment operators

  self_type& operator+=(const base_type& v) override;

  self_type& operator-=(const base_type& v) override;

  self_type& operator*=(const base_type& v) override;

  self_type& operator/=(const base_type& v) override;

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

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

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

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

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

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

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

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

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

  typedef Array<1, float>::iterator iterator;
  typedef Array<1, float>::const_iterator const_iterator;
  typedef Array<1, float>::full_iterator full_iterator;
  typedef Array<1, float>::const_full_iterator const_full_iterator;

  iterator begin()
  {
    return buffer.begin();
  }
  const_iterator begin() const
  {
    return buffer.begin();
  }
  iterator end()
  {
    return buffer.end();
  }
  const_iterator end() const
  {
    return buffer.end();
  }
  iterator begin_all()
  {
    return buffer.begin_all();
  }
  const_iterator begin_all() const
  {
    return buffer.begin_all();
  }
  iterator end_all()
  {
    return buffer.end_all();
  }
  const_iterator end_all() const
  {
    return buffer.end_all();
  }


  float* get_data_ptr()
  {
    return buffer.get_data_ptr();
  }

  const float* get_const_data_ptr() const
  {
    return buffer.get_const_data_ptr();
  }

  void release_data_ptr()
  {
    buffer.release_data_ptr();
  }

  void release_const_data_ptr() const
  {
    buffer.release_const_data_ptr();
  }

private:
  Array<1, float> buffer;

  void create_buffer(const bool initialise_with_0 = false);
  std::streamoff offset;
  std::streamoff offset_3d_data;

  std::vector<int> segment_sequence;
  std::vector<int> timing_poss_sequence;


  std::streamoff get_index(const Bin&) const;
};

inline double
norm(const ProjDataInMemory& p)
{
  return p.norm();
}

inline double
norm_squared(const ProjDataInMemory& p)
{
  return p.norm_squared();
}

END_NAMESPACE_STIR

#endif