InterfileHeader.h

Go to the documentation of this file.

/*
    Copyright (C) 2002-2007, Hammersmith Imanet Ltd
    Copyright (C) 2013, 2016, 2018, 2020 University College London
    Copyright 2017 ETH Zurich, Institute of Particle Physics and Astrophysics
    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_INTERFILEHEADER_H__
#define __stir_INTERFILEHEADER_H__
 
#include "stir/ByteOrder.h"
#include "stir/NumericInfo.h"
#include "stir/KeyParser.h"
#include "stir/ProjDataFromStream.h"
#include "stir/ExamInfo.h"
#include "stir/date_time_functions.h"
 
START_NAMESPACE_STIR
 
class ProjDataInfo;

class MinimalInterfileHeader : public KeyParser
{
public:
  static const double double_value_not_set;
  MinimalInterfileHeader();
 
  ~MinimalInterfileHeader() override {}
 
protected:
  shared_ptr<ExamInfo> exam_info_sptr;
 
private:
  std::string imaging_modality_as_string;
  void set_imaging_modality();
 
public:
  shared_ptr<const ExamInfo> get_exam_info_sptr() const;
  const ExamInfo& get_exam_info() const;
 
  std::string version_of_keys;
 
  std::string siemens_mi_version;
 
protected:

  virtual void set_version_specific_keys();
};

class InterfileHeader : public MinimalInterfileHeader
{
public:
  InterfileHeader();
  // Returns false if OK, true if not.
  bool post_processing() override;
 
private:
  // TODO the next few ones should be made static members
  // Lists of possible values for some keywords
  ASCIIlist_type number_format_values;
  ASCIIlist_type byte_order_values;
  ASCIIlist_type patient_orientation_values;
  ASCIIlist_type patient_rotation_values;
 
  // Corresponding variables here
 
  int number_format_index;
  int byte_order_index;
  int patient_orientation_index;
  int patient_rotation_index;
 
  void set_type_of_data();
 
protected:
  int num_time_frames;
  std::vector<double> image_relative_start_times;
  std::vector<double> image_durations;
  int bytes_per_pixel;

  std::string isotope_name;
  std::vector<std::string> radionuclide_name;
  std::vector<float> radionuclide_half_life;
  std::vector<float> radionuclide_branching_ratio;
 
  float calibration_factor;
 
private:
  // Louvain la Neuve style of 'image scaling factors'
  double lln_quantification_units;
 
protected:
  void set_version_specific_keys() override;
  virtual void read_matrix_info();
  virtual void read_num_energy_windows();
  void read_frames_info();

  virtual int get_num_datasets() const { return num_time_frames; }
 
public:
  ASCIIlist_type type_of_data_values;
  int type_of_data_index;
 
  ASCIIlist_type PET_data_type_values;
  int PET_data_type_index;
 
  ASCIIlist_type process_status_values;
  int process_status_index;
 
  // 'Final' variables
 
  std::string data_file_name;
 
  DateTimeStrings study_date_time;

  NumericType type_of_numbers;
  ByteOrder file_byte_order;
 
  int num_dimensions;
  int num_energy_windows;
  std::vector<std::string> matrix_labels;
  std::vector<std::vector<int>> matrix_size;
  std::vector<float> pixel_sizes;
  std::vector<std::vector<double>> image_scaling_factors;
  std::vector<unsigned long> data_offset_each_dataset;
 
  // Acquisition parameters
  std::vector<float> lower_en_window_thresholds;

  std::vector<float> upper_en_window_thresholds;
  // end acquisition parameters
 
protected:
  // version 3.3 had only a single offset. we'll internally replace it with data_offset_each_dataset
  unsigned long data_offset;
 
  float bed_position_horizontal;
  float bed_position_vertical;
};

class InterfileImageHeader : public InterfileHeader
{
private:
  typedef InterfileHeader base_type;
 
public:
  InterfileImageHeader();
  std::vector<double> first_pixel_offsets;
  int num_image_data_types;
  std::vector<std::string> index_nesting_level;
  std::vector<std::string> image_data_type_description;
 
protected:
  void read_matrix_info() override;
  bool post_processing() override;
  void read_image_data_types();
  int get_num_datasets() const override { return num_time_frames * num_image_data_types; }
};

class InterfilePDFSHeader : public InterfileHeader
{
public:
  InterfilePDFSHeader();
 
protected:
  bool post_processing() override;
 
public:
  std::vector<int> segment_sequence;
  std::vector<int> min_ring_difference;
  std::vector<int> max_ring_difference;
  std::vector<int> num_rings_per_segment;
  std::vector<int> timing_poss_sequence;
 
  std::vector<std::string> applied_corrections;
 
  // derived values
  int num_timing_poss;
  int num_segments;
  int num_views;
  int num_bins;
  ProjDataFromStream::StorageOrder storage_order;
  shared_ptr<ProjDataInfo> data_info_sptr;
 
private:
  void resize_segments_and_set();
  int find_storage_order();
 
  // members that will be used to set Scanner
  // TODO parsing should be moved to Scanner
  int num_rings;
  int num_detectors_per_ring;
 
  double transaxial_FOV_diameter_in_cm;
  double inner_ring_diameter_in_cm;
  double average_depth_of_interaction_in_cm;
  double distance_between_rings_in_cm;
  double default_bin_size_in_cm;
  // this intrinsic tilt
  double view_offset_in_degrees;
  int max_num_non_arccorrected_bins;
  int default_num_arccorrected_bins;
 
  int num_axial_blocks_per_bucket;
  int num_transaxial_blocks_per_bucket;
  int num_axial_crystals_per_block;
  int num_transaxial_crystals_per_block;
  int num_axial_crystals_per_singles_unit;
  int num_transaxial_crystals_per_singles_unit;
  int num_detector_layers;

  float energy_resolution;
  float reference_energy;
 
  int max_num_timing_poss;
  float size_of_timing_pos;
  float timing_resolution;
 
  int tof_mash_factor;


  std::string scanner_geometry;
  float axial_distance_between_crystals_in_cm;
  float transaxial_distance_between_crystals_in_cm;
  float axial_distance_between_blocks_in_cm;
  float transaxial_distance_between_blocks_in_cm;


  std::string crystal_map;
  // end scanner parameters
 
  double effective_central_bin_size_in_cm;
  bool is_arccorrected;
};
 
END_NAMESPACE_STIR
 
#endif // __stir_INTERFILEHEADER_H__