include/image/oImageDimensionsAndQuantification.hh

Go to the documentation of this file.

#ifndef OIMAGEDIMENSIONSANDQUANTIFICATION_HH
#define OIMAGEDIMENSIONSANDQUANTIFICATION_HH 1

#include "gVariables.hh"
#include "sOutputManager.hh"
#include "gOptions.hh"
#include "oDynamicDataManager.hh"
#include "oArterialInputCurve.hh"
// #include "oDynamicModelManager.hh"


#define STATIC_RECO 0

#define DYN_RECO_FRAMING 1

#define DYN_RECO_GATING 2

#define DYN_RECO_MCGATING 3

#define DYN_RECO_IPMC 4

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);
    int ResetQuantificationFactors();


  // -----------------------------------------------------------------------------------------
  // 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_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);}


    inline bool IsRespMotionEnabled()
           {return mp_DynamicDataManager->IsRespMotionEnabled();}
    inline bool IsCardMotionEnabled()
           {return mp_DynamicDataManager->IsCardMotionEnabled();}
    inline bool IsPMotionEnabled()
           {return mp_DynamicDataManager->IsPMotionEnabled();}
           
  // -----------------------------------------------------------------------------------------
  // 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 GetPMotionFirstIndexForFrame(int a_fr)
           {return mp_DynamicDataManager->GetPMotionFirstIndexForFrame(a_fr);}

    inline int GetPMotionLastIndexForFrame(int a_fr)
           {return mp_DynamicDataManager->GetPMotionLastIndexForFrame(a_fr);}
           
    inline int GetNb1stMotImgsForLMS(int a_fr)
           {return mp_DynamicDataManager->GetNb1stMotImgsForLMS(a_fr);}
    inline int GetNb2ndMotImgsForLMS()
           {return mp_DynamicDataManager->GetNb2ndMotImgsForLMS();}
           
           
    inline FLTNB GetListPMotionWeightInFrameForLMS(int a_fr, int a_pmsset)
           {return mp_DynamicDataManager->GetListPMotionWeightInFrameForLMS(a_fr, a_pmsset);}
           
           
           
    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();}

    inline HPFLTNB GetdurationPerGate(int a_fr, int a_respGate)
    {return mp_DynamicDataManager->GetDurationPerGate(a_fr,a_respGate);}

    inline bool GateDurationProvided()
            {return mp_DynamicDataManager->GateDurationProvided();}

    inline int GetDynRecoType()
           {return m_dynRecoTypeFlag;}
           
           
  // -----------------------------------------------------------------------------------------
  // 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 uint32_t* GetFramesTimeStartsArray(int a_bed)
           {return m2p_frameTimeStartInMs[a_bed];}
    inline uint32_t* GetFramesTimeStopArray(int a_bed)
           {return m2p_frameTimeStopInMs[a_bed];}
    inline uint32_t* GetFramesTimeDurationsArray(int a_bed)
           {return m2p_frameDurationsInMs[a_bed];}
    inline void SetFrames(const string& a_frameList)
           {m_frameList = a_frameList;}
    // TODO: Remove this function and option from castor-recon
    inline void SetNbTimeBasisFunctions(int a_nbTimeBasisFunctions)
           {m_nbTimeBasisFunctions = a_nbTimeBasisFunctions;}
    inline void SetTimeBasisFunctions(FLTNB** a_m2pTimeBasisFunctions)
         {m2p_timeBasisFunctions = a_m2pTimeBasisFunctions;}
    inline void SetRespBasisFunctions(FLTNB** a_m2pRespBasisFunctions)
         {m2p_respBasisFunctions = a_m2pRespBasisFunctions;}
    inline void SetCardBasisFunctions(FLTNB** a_m2pCardBasisFunctions)
         {m2p_cardBasisFunctions = a_m2pCardBasisFunctions;}
    int SetAcquisitionTime(int a_bed, FLTNB a_timeStartInSec, FLTNB a_durationInSec, string a_GateListDurationsInSec);
    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);
    inline long double GetLambda() {return m_lambda;}
    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);

    int ProcessAndSetMask(FLTNB* ap_maskImage);
    bool IsVoxelMasked(INTNB a_voxIndex);

    inline void SetIgnoredCorrections(const string& a_ignoredCorrectionsList)
           {m_ignoredCorrectionsList = a_ignoredCorrectionsList;}
    inline bool GetIgnoreAttnCorrectionFlag()
           {return m_ignoreAttnCorrectionFlag;}
    inline void SetIgnoreAttnCorrectionFlag(bool a_ignoreAttnCorrectionFlag)
           {m_ignoreAttnCorrectionFlag = a_ignoreAttnCorrectionFlag;}
    inline bool GetIgnoreNormCorrectionFlag()
           {return m_ignoreNormCorrectionFlag;}
    inline void SetIgnoreNormCorrectionFlag(bool a_ignoreNormCorrectionFlag)
           {m_ignoreNormCorrectionFlag = a_ignoreNormCorrectionFlag;}
    inline bool GetIgnoreScatCorrectionFlag()
           {return m_ignoreScatCorrectionFlag;}
    inline void SetIgnoreScatCorrectionFlag(bool a_ignoreScatCorrectionFlag)
           {m_ignoreScatCorrectionFlag = a_ignoreScatCorrectionFlag;}
    inline bool GetIgnoreRandCorrectionFlag()
           {return m_ignoreRandCorrectionFlag;}
    inline void SetIgnoreRandCorrectionFlag(bool a_ignoreRandCorrectionFlag)
           {m_ignoreRandCorrectionFlag = a_ignoreRandCorrectionFlag;}
    inline bool GetIgnoreDecaCorrectionFlag()
           {return m_ignoreDecaCorrectionFlag;}
    inline void SetIgnoreDecaCorrectionFlag(bool a_ignoreDecaCorrectionFlag)
           {m_ignoreDecaCorrectionFlag = a_ignoreDecaCorrectionFlag;}
    inline bool GetIgnoreBratCorrectionFlag()
           {return m_ignoreBratCorrectionFlag;}
    inline void SetIgnoreBratCorrectionFlag(bool a_ignoreBratCorrectionFlag)
           {m_ignoreBratCorrectionFlag = a_ignoreBratCorrectionFlag;}
    inline bool GetIgnoreFdurCorrectionFlag()
           {return m_ignoreFdurCorrectionFlag;}
    inline void SetIgnoreFdurCorrectionFlag(bool a_ignoreFdurCorrectionFlag)
           {m_ignoreFdurCorrectionFlag = a_ignoreFdurCorrectionFlag;}
    inline bool GetIgnoreCaliCorrectionFlag()
           {return m_ignoreCaliCorrectionFlag;}
    inline void SetIgnoreCaliCorrectionFlag(bool a_ignoreCaliCorrectionFlag)
           {m_ignoreCaliCorrectionFlag = a_ignoreCaliCorrectionFlag;}
    inline int GetNbMultiModalImages()
           {return m_nbMultiModalImages;}
     inline int GetNbFramesToSkip()
           {return m_nbFramesToSkip;}
    inline void SetNbMultiModalImages(int a_nbMultiModalImages)
           {m_nbMultiModalImages = a_nbMultiModalImages;}
    inline void SetTimeStaticFlag(bool a_flag)
            {m_timeStaticFlag = a_flag ;}
    inline void SetRespStaticFlag(bool a_flag)
            {m_respStaticFlag = a_flag ;}
    inline void SetCardStaticFlag(bool a_flag)
            {m_cardStaticFlag = a_flag ;}
    inline void SetnbFramesToSkip(int a_FramesToSkip)
            {m_nbFramesToSkip = a_FramesToSkip ;}
    inline bool IsInitialized() {return m_initialized;}
    inline bool HasMask() {return m_hasMask;}


           

  // -----------------------------------------------------------------------------------------
  // Data members
  private:
    oDynamicDataManager* mp_DynamicDataManager; 
    // oDynamicModelManager* mp_DynamicModelManager; /*!< oDynamicModelManager object related to dynamic model management*/
    // 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_nbFramesToSkip;               
    int m_nbTimeBasisFunctions;         
    int m_nbTimeFrames;                 
    FLTNB** m2p_timeBasisFunctions;     
    uint32_t** m2p_frameDurationsInMs;  
    uint32_t** m2p_frameTimeStartInMs;  
    uint32_t** m2p_frameTimeStopInMs;   
    bool m_timeStaticFlag;              
    int  m_dynRecoTypeFlag;             
    // 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;    
    long double m_lambda;               
    // 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;          
    // Bool mask to exclude voxels from computations (projection, convolution, etc.)
    bool m_hasMask;
    bool* mp_mask;                         
};

#endif