stir_ecat7.h

Go to the documentation of this file.

/*
    Copyright (C) 2000 PARAPET partners
    Copyright (C) 2000 - 2011-12-31, Hammersmith Imanet Ltd
    Copyright (C) 2013, 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 __stir_IO_stir_ecat7_H__
#define __stir_IO_stir_ecat7_H__

#include "stir/IO/stir_ecat_common.h"
#include "stir/NumericType.h"

#ifdef HAVE_LLN_MATRIX
#  define CTISinogram ::Sinogram

#  include "matrix.h"
extern "C"
{
  int map_main_header(char* bufr, Main_header* header);
  int mh_update(MatrixFile*);
}

#  include <string>
#  include <iostream>
#  include "stir/shared_ptr.h"

START_NAMESPACE_STIR

class Succeeded;
class ByteOrder;
class Scanner;
template <int num_dimensions, typename elemT>
class DiscretisedDensity;
template <typename elemT>
class VoxelsOnCartesianGrid;
template <typename elemT>
class Sinogram;
class ExamInfo;
class ProjData;
class ProjDataInfo;
class ProjDataFromStream;

START_NAMESPACE_ECAT
START_NAMESPACE_ECAT7

bool is_ECAT7_file(const std::string& filename);
bool is_ECAT7_image_file(const std::string& filename);
bool is_ECAT7_emission_file(const std::string& filename);
bool is_ECAT7_attenuation_file(const std::string& filename);

Succeeded read_ECAT7_main_header(Main_header& mhead, const std::string& filename);


void find_scanner(shared_ptr<Scanner>& scanner_ptr, const Main_header& mhead);


Succeeded DiscretisedDensity_to_ECAT7(DiscretisedDensity<3, float> const& density,
                                      std::string const& cti_name,
                                      std::string const& orig_name,
                                      const Scanner& scanner,
                                      const int frame_num = 1,
                                      const int gate_num = 1,
                                      const int data_num = 0,
                                      const int bed_num = 0);


Succeeded DiscretisedDensity_to_ECAT7(MatrixFile* mptr,
                                      DiscretisedDensity<3, float> const& density,
                                      const int frame_num = 1,
                                      const int gate_num = 1,
                                      const int data_num = 0,
                                      const int bed_num = 0);


Succeeded ProjData_to_ECAT7(ProjData const& proj_data,
                            NumericType output_type,
                            std::string const& cti_name,
                            std::string const& orig_name,
                            const int frame_num = 1,
                            const int gate_num = 1,
                            const int data_num = 0,
                            const int bed_num = 0,
                            const bool write_as_attenuation = false,
                            float scale_factor = 0.0F);


Succeeded ProjData_to_ECAT7(MatrixFile* mptr,
                            ProjData const& proj_data,
                            const int frame_num = 1,
                            const int gate_num = 1,
                            const int data_num = 0,
                            const int bed_num = 0,
                            float scale_factor = 0.0F);


shared_ptr<ExamInfo> read_ECAT7_exam_info(MatrixFile* mptr);


shared_ptr<ExamInfo> read_ECAT7_exam_info(const std::string& filename);


void make_ECAT7_main_header(Main_header&, const Scanner&, const std::string& orig_name, ExamInfo const& exam_info);


void make_ECAT7_main_header(Main_header& mhead,
                            Scanner const& scanner,
                            const std::string& orig_name,
                            DiscretisedDensity<3, float> const& density);


NumericType make_ECAT7_main_header(Main_header& mhead,
                                   const std::string& orig_name,
                                   ExamInfo const& exam_info,
                                   ProjDataInfo const& proj_data_info,
                                   const bool write_as_attenuation = false,
                                   NumericType output_type = NumericType::FLOAT);


void make_subheader_for_ECAT7(Attn_subheader& shead, const Main_header& mhead, const ProjDataInfo& proj_data_info);

void make_subheader_for_ECAT7(Scan3D_subheader& shead, const Main_header& mhead, const ProjDataInfo& proj_data_info);


ProjDataFromStream*
make_pdfs_from_matrix(MatrixFile* const mptr, MatrixData* const matrix, const shared_ptr<std::iostream>& stream_ptr);


Succeeded write_basic_interfile_header_for_ECAT7(std::string& interfile_header_name,
                                                 const std::string& ECAT7_filename,
                                                 const int frame_num,
                                                 const int gate_num,
                                                 const int data_num,
                                                 const int bed_num);

/*
  \brief Read an image from an ECAT7 file.
  \ingroup ECAT
  \warning do not use directly, but use read_from_file<DiscretisedDensity<3,float> >().

  \return a pointer to a newly allocated image, or 0 if it failed.
*/
VoxelsOnCartesianGrid<float>* ECAT7_to_VoxelsOnCartesianGrid(
    const std::string& ECAT7_filename, const int frame_num, const int gate_num, const int data_num, const int bed_num);
/*
  \brief Read projection data from an ECAT7 file
  \ingroup ECAT
  \warning do not use directly, but use ProjData::read_from_file().

  \return a pointer to a newly allocated ProjDataFromStream object, or 0 if it failed.
*/
ProjDataFromStream*
ECAT7_to_PDFS(const std::string& ECAT7_filename, const int frame_num, const int gate_num, const int data_num, const int bed_num);

END_NAMESPACE_ECAT7
END_NAMESPACE_ECAT
END_NAMESPACE_STIR

#endif

#endif