oInterfileIO.hh

Go to the documentation of this file.

/*
This file is part of CASToR.

    CASToR is free software: you can redistribute it and/or modify it under the
    terms of the GNU General Public License as published by the Free Software
    Foundation, either version 3 of the License, or (at your option) any later
    version.

    CASToR is distributed in the hope that it will be useful, but WITHOUT ANY
    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
    FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
    details.

    You should have received a copy of the GNU General Public License along with
    CASToR (in file GNU_GPL.TXT). If not, see <http://www.gnu.org/licenses/>.

Copyright 2017-2019 all CASToR contributors listed below:

    --> Didier BENOIT, Claude COMTAT, Marina FILIPOVIC, Thibaut MERLIN, Mael MILLARDET, Simon STUTE, Valentin VIELZEUF

This is CASToR version 3.0.
*/

#ifndef OINTERFILEIO_HH
#define OINTERFILEIO_HH 1

#include "oImageDimensionsAndQuantification.hh"
#include "sScannerManager.hh"

// ---------------------------------------------------------------------
#define INTF_BIG_ENDIAN 0

#define INTF_LITTLE_ENDIAN 1

#define INTF_IMG_STATIC 0

#define INTF_IMG_DYNAMIC 1

#define INTF_IMG_PET 2

#define INTF_IMG_SPECT 3

#define INTF_IMG_GATED 4

#define INTF_IMG_GSPECT 5

#define INTF_IMG_UNKNOWN 6

#define INTF_LERP_DISABLED false

#define INTF_LERP_ENABLED true

#define BIT_str "bit"

#define UINT32_str "unsigned integer"

#define INT32_str "signed integer"

#define FLT32_str "short float"
#define FLT32_str2 "float"

#define FLT64_str "long float"

#define LONGDOUBLE_str "long long float"

#define ASCII_str "ASCII"

#define INTF_SUPINE_HEADIN_TRANSAXIAL 0

#define INTF_SUPINE_HEADIN_SAGITTAL 1

#define INTF_SUPINE_HEADIN_CORONAL 2 

#define INTF_SUPINE_FEETIN_TRANSAXIAL 3

#define INTF_SUPINE_FEETIN_SAGITTAL 4

#define INTF_SUPINE_FEETIN_CORONAL 5

#define INTF_PRONE_HEADIN_TRANSAXIAL 6

#define INTF_PRONE_HEADIN_SAGITTAL 7

#define INTF_PRONE_HEADIN_CORONAL 8

#define INTF_PRONE_FEETIN_TRANSAXIAL 9

#define INTF_PRONE_FEETIN_SAGITTAL 10

#define INTF_PRONE_FEETIN_CORONAL 11

#define INTF_TRANSVERSE 0

#define INTF_CORONAL 1

#define INTF_SAGITTAL 2

#define INTF_OTHER 3

#define INTF_SUPINE 0

#define INTF_PRONE 1

#define INTF_HEADIN 0

#define INTF_FEETIN 1

struct Intf_key
{
  string korig;  
  string kcase;  
  string klcase; 
  string kvalue; 
};
// ---------------------------------------------------------------------
struct Intf_fields
{
  string path_to_image; 
  string originating_system; 
  uint8_t endianness; 
  uint32_t data_offset; 
  string nb_format; 
  uint8_t nb_dims; 
  uint32_t mtx_size[7]; 
  FLTNB vox_offset[3]; 
//  float vox_size[3]; /*!< Voxel dimensions in mm.\n
  FLTNB vox_size[3]; 
//  float slice_thickness_mm ;  /*!< Read from the key 'slice thickness (pixels)'.\n
  FLTNB slice_thickness_mm ;  
  int nb_bed_positions; 
  FLTNB bed_relative_position; 
  bool bed_position_provided; 
  uint16_t ctr_to_ctr_separation;  
  uint16_t nb_time_frames ; 
  uint16_t nb_resp_gates ; 
  uint16_t nb_card_gates ; 
  uint32_t nb_total_imgs; 
  uint8_t nb_bytes_pixel; 
  int8_t slice_orientation; 
  int8_t pat_rotation;      
  int8_t pat_orientation;   
  FLTNB rescale_slope; 
  FLTNB quant_units; 
  FLTNB rescale_intercept; 
  uint32_t cmtx_size[3]; 
  FLTNB cvox_size[3]; 
  FLTNB cvox_offset[3]; 
  bool is_mtx_size_different; 
  int data_type; 
//  float study_duration; /*!< Acquisition duration.\n
  FLTNB study_duration; 
  vector<FLTNB> image_duration; 
  vector<FLTNB> image_start_time; 
  uint32_t nb_time_windows; 
  string process_status; 
  // --- Fields related to an image in a group  --- // // todo
  
  uint32_t nb_img_in_frame_groups; 
//  float image_pause; /*!< Pause between time windows ?\n
  //FLTNB image_pause; 
  vector<FLTNB> frame_group_pause; 
  // --- SPECT and projection related data --- //
  uint16_t nb_detector_heads; 
  uint32_t nb_energy_windows; 
  uint16_t nb_projections; 
//  float extent_rotation; /*!< Angular span ex: 180, 360.\n
  FLTNB extent_rotation; 
  string direction_rotation; 
//  float first_angle; /*!< Angle of the first view.\n
  FLTNB first_angle; 
  string projection_angles; 
  string radius; 
};
#include "gVariables.hh"
#include "sOutputManager.hh"
#include "gOptions.hh"

  // -------------------------------------------------------------------
  // ----- "PUBLIC" FUNCTIONS WHICH COULD AND SHOULD BE ANYWHERE IN THE CODE WHERE INTERFILE IS REQUIRED -----

    template <typename T> int IntfKeyGetValueFromFile(const string& a_pathToHeader, const string& a_key, T* ap_return, int a_nbElts, int a_mandatoryFlag);

    template <typename T> int IntfKeyGetRecurringValueFromFile(const string& a_pathToHeader, const string& a_key, T* ap_return, int a_nbElts, int a_mandatoryFlag, uint16_t a_nbOccurrences);

    int IntfReadProjectionImage( const string& a_pathToHeaderFile, 
                                FLTNB* ap_ImgMatrix,
                          Intf_fields* ap_IF, 
                                   int vb, 
                                  bool a_lerpFlag);

    int IntfCheckDimensionsConsistency(Intf_fields ImgFields1, Intf_fields ImgFields2);

    FLTNB* IntfLoadImageFromScratch( const string& a_pathToHeaderFile, 
                                     Intf_fields* ap_ImgFields,
                                     int vb );
    int IntfWriteImageFromIntfFields( const string& a_pathToImg,
                                      FLTNB* ap_ImgMatrix,
                                      Intf_fields Img_fields,
                                      int vb );

    int IntfReadImage(   const string& a_pathToHeaderFile, 
                             FLTNB* ap_ImgMatrix,
    oImageDimensionsAndQuantification* ap_ID, 
                                   int vb, 
                                  bool a_lerpFlag);
                                  
    int IntfReadImage(   const string& a_pathToHeaderFile, 
                          FLTNB**** a4p_ImgMatrix, 
    oImageDimensionsAndQuantification* ap_ID, 
                                   int vb, 
                                  bool a_lerpFlag);
    
    int IntfReadImgDynCoeffFile(const string& a_pathToHeaderFile, 
                                   FLTNB** a2p_ImgMatrix, 
           oImageDimensionsAndQuantification* ap_ID,
                                          int a_nbFbases, 
                                          int vb, 
                                         bool a_lerpFlag);
  
  
  // -------------------------------------------------------------------
  // ----- FUNCTIONS DEDICATED TO IMAGE DATA READING/WRITING -----

    int IntfCheckConsistency(Intf_fields* ap_IF, oImageDimensionsAndQuantification* ap_ID, int vb, int a_lerpFlag);

    int IntfGetPixelTypeAndReadData(Intf_fields a_IF, 
                                      ifstream* ap_iFile, 
                                      FLTNB* ap_outImgMatrix, 
                                      FLTNB* ap_inImgMatrix, 
                                      uint32_t* a_offset, 
                                            int a_nbVox, 
                                            int vb);

    template <class T>
    int IntfReadData(Intf_fields a_IF, 
                       ifstream* ap_iFile, 
                       FLTNB* ap_outImgMatrix, 
                       FLTNB* ap_inImgMatrix, 
                       uint32_t* a_offset, 
                             int a_nbVox, 
                             int vb, 
                              T* bytes);


    int ImageInterpolation(FLTNB *ap_iImg,               FLTNB *ap_oImg, 
                     const uint32_t ap_iDimVox[3], const uint32_t ap_oDimVox[3],
                     const FLTNB ap_iSizeVox[3],   const FLTNB ap_oSizeVox[3],
                     const FLTNB ap_iOffVox[3],    const FLTNB ap_oOffVox[3] );
          

    int IntfWriteImgFile(const string& a_pathToImg, FLTNB* ap_ImgMatrix, const Intf_fields& ap_IntfF, int vb);

    int IntfWriteImgFile(const string& a_pathToImg, FLTNB* ap_ImgMatrix, oImageDimensionsAndQuantification* ap_ID, int vb);

    int IntfWriteProjFile(const string& a_pathToImg, FLTNB** a2p_ImgMatrix, oImageDimensionsAndQuantification* ap_ID, Intf_fields a_Imgfields, int vb);

    int IntfWriteImgDynCoeffFile(const string& a_pathToImg, FLTNB** a2p_ImgMatrix, oImageDimensionsAndQuantification* ap_ID, int a_nbParImgs, int vb, bool a_mergeDynImgFlag=false);

    int IntfWriteImgFile(const string& a_pathToImg, FLTNB**** a4p_ImgMatrix, oImageDimensionsAndQuantification* ap_ID, int vb);

    int IntfWriteWholeDynBasisCoeffImgFile(const string& a_pathToImg, FLTNB**** a4p_ImgMatrix, oImageDimensionsAndQuantification* ap_ID, int vb);

    int IntfWriteImage(const string& a_pathToImg, FLTNB* ap_outImgMtx, uint32_t a_dim, int vb);

    int IntfWriteImage(vector<string> ap_pathToImgs, FLTNB** a2p_outImgMtx, uint32_t ap_dim[2], int vb);

    int IntfWriteImage(vector<string> ap_pathToImgs, FLTNB**** a4p_outImgMtx, uint32_t ap_dim[4], int vb);

    int IntfWriteData(ofstream* ap_oFile, FLTNB* ap_outImgMatrix, int a_nbVox, int vb);


  // -------------------------------------------------------------------
  // ----- FUNCTIONS DEDICATED TO INTERFILE HEADER KEYs DECODING/PARSING/READING -----

    int IntfIsMHD(string a_pathToFile, vector<string> &ap_lPathToImgs);

    int IntfWriteMHD(const string& a_pathToMhd, const vector<string> &ap_lPathToImgs, Intf_fields a_IntfF, oImageDimensionsAndQuantification* ap_ID, int vb);

    int IntfReadHeader(const string& a_pathToHeaderFile, Intf_fields* ap_IntfFields, int vb);

    int IntfWriteHeaderMainData(const string& a_path, const Intf_fields& ap_IntfF, int vb);

    int IntfWriteHeaderImgData(ofstream &ap_ofile, const Intf_fields& ap_IntfF, int vb);

    void IntfKeyInitFields(Intf_fields* ap_IF);
    
    void IntfKeySetFieldsOutput(Intf_fields* ap_IF, oImageDimensionsAndQuantification* ap_ID);

    void IntfKeyPrintFields(Intf_fields a_IF);

    int IntfRecoverKey(Intf_key* ap_Key, const string& a_line);

    int IntfCheckKeyMatch(Intf_key a_Key, const string& a_field);

    int IntfKeyIsArray(Intf_key ap_Key);

    int IntfKeyGetArrayNbElts(Intf_key ap_Key);    

    int IntfKeyGetMaxArrayKey(Intf_key ap_Key);

    template <typename T> int IntfKeyGetArrayElts(Intf_key a_Key, T* ap_return);

    string IntfKeyGetEndianStr(int a_val);

    string IntfKeyGetModalityStr(int a_modalityIdx);

    int IntfKeyGetInputImgDataType(const string& a_str);

    int IntfKeyGetOutputImgDataType(oImageDimensionsAndQuantification* ap_ID);

    string IntfKeyGetPixTypeStr();


  // -------------------------------------------------------------------
  // ----- NOT IMPLEMENTED KEY FUNCTION -----

    int IntfKeyGetPatOrientation(Intf_fields ap_IF);
    
    int IntfGetVoxIdxSHTOrientation(Intf_fields a_IF, int a_voxId);


  // -------------------------------------------------------------------
  // ----- SOME UTILITY FUNCTIONS -----

    void IntfAllocInterpImg(FLTNB** a2p_img, Intf_fields a_IF);
    
    void GetUserEndianness();

    void IntfEraseSpaces(string* input_str);
    
    void IntfToLowerCase(string* ap_str);

    string IntfKeyGetPatientNameTag();

    template <class Type> void SwapBytes(Type *ap_type);

#endif