oImageDimensionsAndQuantification.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-2018 all CASToR contributors listed below:

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

This is CASToR version 2.0.
*/

#ifndef OIMAGEDIMENSIONSANDQUANTIFICATION_HH
#define OIMAGEDIMENSIONSANDQUANTIFICATION_HH 1

#include "gVariables.hh"
#include "sOutputManager.hh"
#include "gOptions.hh"
#include "oDynamicDataManager.hh"

class oImageDimensionsAndQuantification
{
  // -----------------------------------------------------------------------------------------
  // Constructor & Destructor
  public:
    oImageDimensionsAndQuantification();
    ~oImageDimensionsAndQuantification();


  // -----------------------------------------------------------------------------------------
  // Public member functions
  public:
    void SetDefault();
    int CheckParameters();
    int Initialize();
    void CheckNumberOfProjectionThreadsConsistencyWithDataFileSize(vDataFile** a2p_DataFile);
    int DealWithBedPositions(vDataFile** a2p_DataFile);

  // -----------------------------------------------------------------------------------------
  // Private member functions
  private:
    int InitializeFramingAndQuantification();
    int InitializeTimeBasisFunctions();
    int InitializeRespBasisFunctions();
    int InitializeCardBasisFunctions();
    int InitializeIgnoredCorrections();


  // -----------------------------------------------------------------------------------------
  // Public dynamic data management functions
  public:
    inline void ResetCurrentDynamicIndices()
           {mp_DynamicDataManager->ResetCurrentDynamicIndices();}
    int InitDynamicData( string a_pathTo4DDataSplittingFile,
                         int a_respMotionCorrectionFlag, int a_cardMotionCorrectionFlag, int a_doubleMotionCorrectionFlag, int a_invMotionCorrectionFlag,
                         int a_nbRespGates, int a_nbCardGates );
    int CheckDynamicParameters(int64_t a_nbEvents);
    inline int DynamicSwitch( int64_t a_currentEventIndex, uint32_t a_currentTime, int a_bed, int a_th )
           {return mp_DynamicDataManager->DynamicSwitch(a_currentEventIndex, a_currentTime, a_bed, a_th);}


  // -----------------------------------------------------------------------------------------
  // Public Get & Set functions related to the dynamic data management
  public:
    inline void SetRespMotionFlagOn()
           {mp_DynamicDataManager->SetRespMotionFlagOn();}
    inline void SetCardMotionFlagOn()
           {mp_DynamicDataManager->SetCardMotionFlagOn();}
    inline void SetPMotionFlagOn()
           {mp_DynamicDataManager->SetPMotionFlagOn();}   
    inline int GetCurrentRespGate(int a_th)
           {return mp_DynamicDataManager->GetCurrentRespGate(a_th);}
    inline int GetCurrentCardGate(int a_th)
           {return mp_DynamicDataManager->GetCurrentCardGate(a_th);}
    inline int GetPMotionFirstIndexForLMS(int a_fr)
           {return mp_DynamicDataManager->GetPMotionFirstIndexForLMS(a_fr);}
    inline int GetNb1stMotImgsForLMS(int a_fr)
           {return mp_DynamicDataManager->GetNb1stMotImgsForLMS(a_fr);}
    inline int GetNb2ndMotImgsForLMS()
           {return mp_DynamicDataManager->GetNb2ndMotImgsForLMS();}
    inline int GetCurrentRespImage(int a_th)
           {return mp_DynamicDataManager->GetCurrentRespImage(a_th);}
    inline int GetCurrentCardImage(int a_th)
           {return mp_DynamicDataManager->GetCurrentCardImage(a_th);}
    inline int GetCurrentTimeFrame(int a_th)
           {return mp_DynamicDataManager->GetCurrentTimeFrame(a_th);}
    inline int GetCurrentPMotionIndex(int a_th)
           {return mp_DynamicDataManager->GetCurrentPMotionIndex(a_th);}

    inline int GetNbIPatMotionSubsets()
           {return mp_DynamicDataManager->GetNbIPatMotionSubsets();}
           
           
  // -----------------------------------------------------------------------------------------
  // Get & Set functions
  public:
    inline void SetVerbose(int a_verbose)
           {m_verbose = a_verbose;}
    inline int GetNbThreadsForProjection()
           {return m_nbThreadsForProjection;}
    inline int GetNbThreadsForImageComputation()
           {return m_nbThreadsForImageComputation;}
    inline int GetNbThreadsMax()
           { if (m_nbThreadsForProjection>m_nbThreadsForImageComputation) return m_nbThreadsForProjection;
             else return m_nbThreadsForImageComputation; }
    int SetNbThreads(const string& a_nbThreads);
    inline void SetMPIRankAndSize(int a_mpiRank, int a_mpiSize)
           {m_mpiRank = a_mpiRank; m_mpiSize = a_mpiSize;}
    inline int GetMPISize()
           {return m_mpiSize;}
    inline int GetMPIRank()
           {return m_mpiRank;}
    inline int GetNbBeds()
           {return m_nbBeds;}
    inline void SetNbBeds(int a_nbBeds)
           {m_nbBeds = a_nbBeds; if (mp_bedPositions!=NULL) free(mp_bedPositions); mp_bedPositions = (FLTNB*)calloc(m_nbBeds,sizeof(FLTNB));}
    inline FLTNB GetBedPosition(int a_bedIndex)
           {return mp_bedPositions[a_bedIndex];}
    inline bool GetProvidedBedPositionFlag() {return m_providedBedPosition;}
    inline int GetNbTimeFrames()
           {return m_nbTimeFrames;}
    inline int GetNbTimeBasisFunctions()
           {return m_nbTimeBasisFunctions;}
    inline FLTNB GetTimeBasisCoefficient(int a_timeBasisFunction, int a_timeFrame)
           {return m2p_timeBasisFunctions[a_timeBasisFunction][a_timeFrame];}
    inline FLTNB GetFrameDurationInSec(int a_bed, int a_frame)
           {return ((FLTNB)(m2p_frameDurationsInMs[a_bed][a_frame]))/1000.;}
    inline FLTNB GetFrameTimeStartInSec(int a_bed, int a_frame)
           {return ((FLTNB)(m2p_frameTimeStartInMs[a_bed][a_frame]))/1000.;}
    inline FLTNB GetFrameTimeStopInSec(int a_bed, int a_frame)
           {return ((FLTNB)(m2p_frameTimeStopInMs[a_bed][a_frame]))/1000.;}
    inline FLTNB GetFinalTimeStopInSec(int a_bed)
           {return ((FLTNB)(m2p_frameTimeStopInMs[a_bed][m_nbTimeFrames-1]))/1000.;}
    inline uint32_t GetFrameDurationInMs(int a_bed, int a_frame)
           {return m2p_frameDurationsInMs[a_bed][a_frame];}
    inline uint32_t GetFrameTimeStartInMs(int a_bed, int a_frame)
           {return m2p_frameTimeStartInMs[a_bed][a_frame];}
    inline uint32_t GetFrameTimeStopInMs(int a_bed, int a_frame)
           {return m2p_frameTimeStopInMs[a_bed][a_frame];}
    inline uint32_t GetFinalTimeStopInMs(int a_bed)
           {return m2p_frameTimeStopInMs[a_bed][m_nbTimeFrames-1];}
    inline void SetFrames(const string& a_frameList)
           {m_frameList = a_frameList;}
    inline void SetNbTimeBasisFunctions(int a_nbTimeBasisFunctions)
           {m_nbTimeBasisFunctions = a_nbTimeBasisFunctions;}
    inline void SetTimeBasisFunctionsFile(const string& a_timeBasisFunctionsFile)
           {m_timeBasisFunctionsFile = a_timeBasisFunctionsFile;}
    int SetAcquisitionTime(int a_bed, FLTNB a_timeStartInSec, FLTNB a_durationInSec);
    inline bool GetTimeStaticFlag()
           {return m_timeStaticFlag;}
    inline int GetNbRespGates()
           {return m_nbRespGates;}
    inline int GetNbRespBasisFunctions()
           {return m_nbRespBasisFunctions;}
    inline FLTNB GetRespBasisCoefficient(int a_respBasisFunction, int a_respGate)
           {return m2p_respBasisFunctions[a_respBasisFunction][a_respGate];}
    inline void SetNbRespGates(int a_nbRespGates)
           {m_nbRespGates = a_nbRespGates;}
    inline void SetNbRespBasisFunctions(int a_nbRespBasisFunctions)
           {m_nbRespBasisFunctions = a_nbRespBasisFunctions;}
    inline void SetRespBasisFunctionsFile(const string& a_respBasisFunctionsFile)
           {m_respBasisFunctionsFile = a_respBasisFunctionsFile;}
    inline bool GetRespStaticFlag()
           {return m_respStaticFlag;}
    inline int GetNbCardGates()
           {return m_nbCardGates;}
    inline int GetNbCardBasisFunctions()
           {return m_nbCardBasisFunctions;}
    inline FLTNB GetCardBasisCoefficient(int a_cardBasisFunction, int a_cardGate)
           {return m2p_cardBasisFunctions[a_cardBasisFunction][a_cardGate];}
    inline void SetNbCardGates(int a_nbCardGates)
           {m_nbCardGates = a_nbCardGates;}
    inline void SetNbCardBasisFunctions(int a_nbCardBasisFunctions)
           {m_nbCardBasisFunctions = a_nbCardBasisFunctions;}
    inline void SetCardBasisFunctionsFile(const string& a_cardBasisFunctionsFile)
           {m_cardBasisFunctionsFile = a_cardBasisFunctionsFile;}
    inline bool GetCardStaticFlag()
           {return m_cardStaticFlag;}
    inline INTNB GetNbVoxX()
           {return m_nbVoxX;}
    inline INTNB GetNbVoxY()
           {return m_nbVoxY;}
    inline INTNB GetNbVoxZ()
           {return m_nbVoxZ;}
    inline INTNB GetNbVoxXY()
           {return m_nbVoxXY;}
    inline INTNB GetNbVoxXYZ()
           {return m_nbVoxXYZ;}
    inline INTNB GetNbVoxDiagonal()
           { return ((INTNB)(sqrt( ((FLTNB)m_nbVoxX) * ((FLTNB)m_nbVoxX) +
                                   ((FLTNB)m_nbVoxY) * ((FLTNB)m_nbVoxY) +
                                   ((FLTNB)m_nbVoxZ) * ((FLTNB)m_nbVoxZ) ))); }
    inline void SetNbVoxX(INTNB a_nbVoxX)
           {m_nbVoxX = a_nbVoxX;}
    inline void SetNbVoxY(INTNB a_nbVoxY)
           {m_nbVoxY = a_nbVoxY;}
    inline void SetNbVoxZ(INTNB a_nbVoxZ)
           {m_nbVoxZ = a_nbVoxZ;}
    inline FLTNB GetVoxSizeX()
           {return m_voxSizeX;}
    inline FLTNB GetVoxSizeY()
           {return m_voxSizeY;}
    inline FLTNB GetVoxSizeZ()
           {return m_voxSizeZ;}
    inline FLTNB GetFOVSizeX()
           {return m_fovSizeX;}
    inline FLTNB GetFOVSizeY()
           {return m_fovSizeY;}
    inline FLTNB GetFOVSizeZ()
           {return m_fovSizeZ;}
    inline void SetVoxSizeX(FLTNB a_voxSizeX)
           {m_voxSizeX = a_voxSizeX;}
    inline void SetVoxSizeY(FLTNB a_voxSizeY)
           {m_voxSizeY = a_voxSizeY;}
    inline void SetVoxSizeZ(FLTNB a_voxSizeZ)
           {m_voxSizeZ = a_voxSizeZ;}
    inline void SetFOVSizeX(FLTNB a_fovSizeX)
           {m_fovSizeX = a_fovSizeX;}
    inline void SetFOVSizeY(FLTNB a_fovSizeY)
           {m_fovSizeY = a_fovSizeY;}
    inline void SetFOVSizeZ(FLTNB a_fovSizeZ)
           {m_fovSizeZ = a_fovSizeZ;}
    inline void SetFOVOutMasking(FLTNB a_fovOutPercent, INTNB a_nbSliceOutMask)
           {m_fovOutPercent = a_fovOutPercent; m_nbSliceOutMask = a_nbSliceOutMask;}
    inline FLTNB GetFOVOutPercent()
           {return m_fovOutPercent;}
    inline INTNB GetNbSliceOutMask()
           {return m_nbSliceOutMask;}
    int SetFlipOut(const string& a_flipOut);
    inline bool GetFlipOutX()
           {return m_flipOutX;}
    inline bool GetFlipOutY()
           {return m_flipOutY;}
    inline bool GetFlipOutZ()
           {return m_flipOutZ;}
    inline FLTNB GetOffsetX()
           {return m_offsetX;}
    inline FLTNB GetOffsetY()
           {return m_offsetY;}
    inline FLTNB GetOffsetZ()
           {return m_offsetZ;}
    inline void SetOffsetX(FLTNB a_offsetX)
           {m_offsetX = a_offsetX;}
    inline void SetOffsetY(FLTNB a_offsetY)
           {m_offsetY = a_offsetY;}
    inline void SetOffsetZ(FLTNB a_offsetZ)
           {m_offsetZ = a_offsetZ;}
    FLTNB GetQuantificationFactor(int a_bed, int a_frame, int a_respGate, int a_cardGate);
    int SetCalibrationFactor(int a_bed, FLTNB a_calibrationFactor);
    int SetPETIsotope(int a_bed, const string& a_isotope);
    int SetSPECTIsotope(int a_bed, const string& a_isotope);
    int SetDynamicSpecificQuantificationFactors(const string& a_quantificationFile);
    inline void SetIgnoredCorrections(const string& a_ignoredCorrectionsList)
           {m_ignoredCorrectionsList = a_ignoredCorrectionsList;}
    inline bool GetIgnoreAttnCorrectionFlag()
           {return m_ignoreAttnCorrectionFlag;}
    inline bool GetIgnoreNormCorrectionFlag()
           {return m_ignoreNormCorrectionFlag;}
    inline bool GetIgnoreScatCorrectionFlag()
           {return m_ignoreScatCorrectionFlag;}
    inline bool GetIgnoreRandCorrectionFlag()
           {return m_ignoreRandCorrectionFlag;}
    inline bool GetIgnoreDecaCorrectionFlag()
           {return m_ignoreDecaCorrectionFlag;}
    inline bool GetIgnoreBratCorrectionFlag()
           {return m_ignoreBratCorrectionFlag;}
    inline bool GetIgnoreFdurCorrectionFlag()
           {return m_ignoreFdurCorrectionFlag;}
    inline bool GetIgnoreCaliCorrectionFlag()
           {return m_ignoreCaliCorrectionFlag;}
    inline int GetNbMultiModalImages()
           {return m_nbMultiModalImages;}
    inline void SetNbMultiModalImages(int a_nbMultiModalImages)
           {m_nbMultiModalImages = a_nbMultiModalImages;}

    inline bool IsInitialized() {return m_initialized;}
           

  // -----------------------------------------------------------------------------------------
  // Data members
  private:
    oDynamicDataManager* mp_DynamicDataManager; 
    // Number of threads
    int m_nbThreadsForProjection;       
    int m_nbThreadsForImageComputation; 
    // MPI size and rank
    int m_mpiRank;                      
    int m_mpiSize;                      
    // Number of beds
    int m_nbBeds;                       
    FLTNB* mp_bedPositions;             
    bool m_providedBedPosition;         
    // Framing of the acquisition
    string m_frameList;                 
    int m_nbTimeBasisFunctions;         
    int m_nbTimeFrames;                 
    FLTNB** m2p_timeBasisFunctions;     
    uint32_t** m2p_frameDurationsInMs;  
    uint32_t** m2p_frameTimeStartInMs;  
    uint32_t** m2p_frameTimeStopInMs;   
    string m_timeBasisFunctionsFile;    
    bool m_timeStaticFlag;              
    // Quantification
    FLTNB*** m3p_quantificationFactors; 
    string m_ignoredCorrectionsList;    
    bool m_ignoreAttnCorrectionFlag;    
    bool m_ignoreNormCorrectionFlag;    
    bool m_ignoreRandCorrectionFlag;    
    bool m_ignoreScatCorrectionFlag;    
    bool m_ignoreDecaCorrectionFlag;    
    bool m_ignoreBratCorrectionFlag;    
    bool m_ignoreFdurCorrectionFlag;    
    bool m_ignoreCaliCorrectionFlag;    
    // Respiratory gating
    int m_nbRespBasisFunctions;         
    int m_nbRespGates;                  
    FLTNB** m2p_respBasisFunctions;     
    string m_respBasisFunctionsFile;    
    bool m_respStaticFlag;              
    // Cardiac gating
    int m_nbCardBasisFunctions;         
    int m_nbCardGates;                  
    FLTNB** m2p_cardBasisFunctions;     
    string m_cardBasisFunctionsFile;    
    bool m_cardStaticFlag;              
    // Image discretization
    INTNB m_nbVoxX;                    
    INTNB m_nbVoxY;                    
    INTNB m_nbVoxZ;                    
    INTNB m_nbVoxXY;                   
    INTNB m_nbVoxXYZ;                  
    FLTNB m_voxSizeX;                  
    FLTNB m_voxSizeY;                  
    FLTNB m_voxSizeZ;                  
    FLTNB m_fovSizeX;                  
    FLTNB m_fovSizeY;                  
    FLTNB m_fovSizeZ;                  
    FLTNB m_offsetX;                   
    FLTNB m_offsetY;                   
    FLTNB m_offsetZ;                   
    // Percentage of transaxial FOV unmasked before saving
    FLTNB m_fovOutPercent;             
    INTNB m_nbSliceOutMask;            
    // Output flip
    bool m_flipOutX;                   
    bool m_flipOutY;                   
    bool m_flipOutZ;                   
    // Parameters checked
    bool m_checked;                    
    // Object initialized
    bool m_initialized;                
    // Verbose
    int m_verbose;                     
    int m_nbMultiModalImages;          
};

#endif