ProjDataFromStream.h

Go to the documentation of this file.

//
//
/*
    Copyright (C) 2000 PARAPET partners
    Copyright (C) 2000- 2013, Hammersmith Imanet Ltd
    Copyright (C) 2016, University of Hull
    Copyright (C) 2020, 2022 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 __ProjDataFromStream_H__
#define __ProjDataFromStream_H__
 
#include "stir/ProjData.h"
#include "stir/NumericType.h"
#include "stir/ByteOrder.h"
#include "stir/shared_ptr.h"
#include "stir/Bin.h"
#include <iostream>
#include <vector>
 
START_NAMESPACE_STIR

class ProjDataFromStream : public ProjData
{
public:
  enum StorageOrder
  {
    Segment_AxialPos_View_TangPos,
    Timing_Segment_AxialPos_View_TangPos,
    Segment_View_AxialPos_TangPos,
    Timing_Segment_View_AxialPos_TangPos,
    Unsupported
  };
#if 0    
  static  ProjDataFromStream* ask_parameters(const bool on_disk = true);
#endif
 
#if 0   
  ProjDataFromStream()
    {}
#endif


  ProjDataFromStream(shared_ptr<const ExamInfo> const& exam_info_sptr,
                     shared_ptr<const ProjDataInfo> const& proj_data_info_ptr,
                     shared_ptr<std::iostream> const& s,
                     const std::streamoff offs,
                     const std::vector<int>& segment_sequence_in_stream,
                     StorageOrder o = Segment_View_AxialPos_TangPos,
                     NumericType data_type = NumericType::FLOAT,
                     ByteOrder byte_order = ByteOrder::native,
                     float scale_factor = 1.f);


  ProjDataFromStream(shared_ptr<const ExamInfo> const& exam_info_sptr,
                     shared_ptr<const ProjDataInfo> const& proj_data_info_ptr,
                     shared_ptr<std::iostream> const& s,
                     const std::streamoff offs = 0,
                     StorageOrder o = Segment_View_AxialPos_TangPos,
                     NumericType data_type = NumericType::FLOAT,
                     ByteOrder byte_order = ByteOrder::native,
                     float scale_factor = 1.f);

  inline StorageOrder get_storage_order() const;

  // inline int get_offset_in_stream() const;
  inline std::streamoff get_offset_in_stream() const;

  inline NumericType get_data_type_in_stream() const;

  inline ByteOrder get_byte_order_in_stream() const;

  inline std::vector<int> get_segment_sequence_in_stream() const;
  inline std::vector<int> get_timing_poss_sequence_in_stream() const;
  void set_timing_poss_sequence_in_stream(const std::vector<int>& seq);

  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_num = 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;

  float get_scale_factor() const;

  virtual float get_bin_value(const Bin& this_bin) const;

  virtual void set_bin_value(const Bin& bin);
 
protected:
  shared_ptr<std::iostream> sino_stream;


  std::streamoff get_offset(const Bin&) const;
 
private:
  void activate_TOF();
  std::streamoff offset;
  std::streamoff offset_3d_data;

  std::vector<int> segment_sequence;
  std::vector<int> timing_poss_sequence;
 
  inline int find_segment_index_in_sequence(const int segment_num) const;
 
  StorageOrder storage_order;
 
  NumericType on_disk_data_type;
 
  ByteOrder on_disk_byte_order;
 
  // scale_factor is only used when reading data from file. Data are stored in
  // memory as float, with the scale factor multiplied out
  float scale_factor;
 
private:
#if __cplusplus > 199711L
  ProjDataFromStream& operator=(ProjDataFromStream&&) = delete;
#endif
};
 
END_NAMESPACE_STIR
 
#include "stir/ProjDataFromStream.inl"
 
#endif