interfile.h

Go to the documentation of this file.

//
//
#ifndef __stir_Interfile_h__
#define __stir_Interfile_h__

/*
    Copyright (C) 2000 PARAPET partners
    Copyright (C) 2000- 2011, Hammersmith Imanet Ltd
    Copyright (C) 2018, 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
*/
#include "stir/NumericType.h"
// note that I had to include Succeeded.h instead of just forward
// declaring the class. Otherwise every file that used write_*interfile*
// has to include Succeeded.h (even if it doesn't use the return value).
#include "stir/Succeeded.h"
#include "stir/ByteOrder.h"
#include "stir/ArrayFwd.h"
#include <iostream>
#include <string>

START_NAMESPACE_STIR

template <int num_dimensions>
class IndexRange;
template <int num_dimensions, typename elemT>
class DiscretisedDensity;
template <typename elemT>
class VectorWithOffset;
template <typename elemT>
class CartesianCoordinate3D;
template <typename elemT>
class Coordinate3D;
template <typename elemT>
class VoxelsOnCartesianGrid;
class ProjDataFromStream;
class DynamicDiscretisedDensity;
template <typename elemT>
class ParametricDiscretisedDensity;
template <typename elemT>
class VoxelsOnCartesianGrid;
template <int num_dimensions, typename elemT>
class KineticParameters;

class ExamInfo;


bool is_interfile_signature(const char* const signature);


VoxelsOnCartesianGrid<float>* read_interfile_image(std::istream& input, const std::string& directory_for_data = "");


VoxelsOnCartesianGrid<float>* read_interfile_image(const std::string& filename);

DynamicDiscretisedDensity* read_interfile_dynamic_image(std::istream& input, const std::string& directory_for_data);

DynamicDiscretisedDensity* read_interfile_dynamic_image(const std::string& filename);

ParametricDiscretisedDensity<VoxelsOnCartesianGrid<KineticParameters<2, float>>>*
read_interfile_parametric_image(std::istream& input, const std::string& directory_for_data);

ParametricDiscretisedDensity<VoxelsOnCartesianGrid<KineticParameters<2, float>>>*
read_interfile_parametric_image(const std::string& filename);


Succeeded write_basic_interfile_image_header(const std::string& header_file_name,
                                             const std::string& image_file_name,
                                             const ExamInfo& exam_info,
                                             const IndexRange<3>& index_range,
                                             const CartesianCoordinate3D<float>& voxel_size,
                                             const CartesianCoordinate3D<float>& origin,
                                             const NumericType output_type,
                                             const ByteOrder byte_order,
                                             const VectorWithOffset<float>& scaling_factors,
                                             const VectorWithOffset<unsigned long>& file_offsets,
                                             const std::vector<std::string>& data_type_descriptions = std::vector<std::string>());


const VectorWithOffset<unsigned long> compute_file_offsets(int number_of_time_frames,
                                                           const NumericType output_type,
                                                           const Coordinate3D<int>& dim,
                                                           unsigned long initial_offset = 0);


template <class elemT>
Succeeded write_basic_interfile(const std::string& filename,
                                const ArrayType<3, elemT>& image,
                                const CartesianCoordinate3D<float>& voxel_size,
                                const CartesianCoordinate3D<float>& origin,
                                const NumericType output_type = NumericType::FLOAT,
                                const float scale = 0,
                                const ByteOrder byte_order = ByteOrder::native);


template <class elemT>
Succeeded write_basic_interfile(const std::string& filename,
                                const ExamInfo& exam_info,
                                const ArrayType<3, elemT>& image,
                                const CartesianCoordinate3D<float>& voxel_size,
                                const CartesianCoordinate3D<float>& origin,
                                const NumericType output_type = NumericType::FLOAT,
                                const float scale = 0,
                                const ByteOrder byte_order = ByteOrder::native);


template <class elemT>
Succeeded write_basic_interfile(const std::string& filename,
                                const ArrayType<3, elemT>& image,
                                const NumericType output_type = NumericType::FLOAT,
                                const float scale = 0,
                                const ByteOrder byte_order = ByteOrder::native);


Succeeded write_basic_interfile(const std::string& filename,
                                const VoxelsOnCartesianGrid<float>& image,
                                const NumericType output_type = NumericType::FLOAT,
                                const float scale = 0,
                                const ByteOrder byte_order = ByteOrder::native);


Succeeded write_basic_interfile(const std::string& filename,
                                const DiscretisedDensity<3, float>& image,
                                const NumericType output_type = NumericType::FLOAT,
                                const float scale = 0,
                                const ByteOrder byte_order = ByteOrder::native);

Succeeded write_basic_interfile(const std::string& filename,
                                const ParametricDiscretisedDensity<VoxelsOnCartesianGrid<KineticParameters<2, float>>>& image,
                                const NumericType output_type = NumericType::FLOAT,
                                const float scale = 0,
                                const ByteOrder byte_order = ByteOrder::native);

Succeeded write_basic_interfile(const std::string& filename,
                                const DynamicDiscretisedDensity& image,
                                const NumericType output_type = NumericType::FLOAT,
                                const float scale = 0,
                                const ByteOrder byte_order = ByteOrder::native);


ProjDataFromStream* read_interfile_PDFS(std::istream& input,
                                        const std::string& directory_for_data = "",
                                        const std::ios::openmode openmode = std::ios::in);


ProjDataFromStream* read_interfile_PDFS(const std::string& filename, const std::ios::openmode open_mode);


Succeeded write_basic_interfile_PDFS_header(const std::string& header_filename,
                                            const std::string& data_filename,
                                            const ProjDataFromStream& pdfs);


Succeeded write_basic_interfile_PDFS_header(const std::string& data_filename, const ProjDataFromStream& pdfs);

END_NAMESPACE_STIR

#endif // __Interfile_h__