oSensitivityGenerator.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 OSENSITIVITYGENERATOR_HH
#define OSENSITIVITYGENERATOR_HH 1

#include "gVariables.hh"
#include "oImageDimensionsAndQuantification.hh"
#include "oProjectorManager.hh"
#include "oImageConvolverManager.hh"
#include "oDeformationManager.hh"
#include "oDynamicModelManager.hh"
#include "oImageSpace.hh"
#include "vDataFile.hh"
#include "vDeformation.hh"
#include "sOutputManager.hh"
#include "vScanner.hh"



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


  // -------------------------------------------------------------------
  // Public member functions
  public:
    int CheckParameters();
    int Initialize();
    int Launch();


  // -------------------------------------------------------------------
  // Private member functions
  private:
    int InitializeAttenuationFiles();
    int InitializeNormalizationFiles();
    int LaunchCPU();
    #ifdef CASTOR_GPU

    int LaunchGPU();
    #endif

    int ComputeSensitivityFromHistogramDataFile(int a_bed);
    int ComputeSensitivityFromNormalizationFile(int a_bed);
    int ComputeSensitivityFromScanner(int a_bed);
    int ProcessThisLine(oProjectionLine* ap_Line, vEvent* ap_Event, int a_bed, int a_frame, int a_respGate, int a_cardGate, int a_thread);


  // -------------------------------------------------------------------
  // Public Get & Set functions
  public:
    string GetPathToSensitivityImage();
    inline void SetImageDimensionsAndQuantification(oImageDimensionsAndQuantification* ap_ImageDimensionsAndQuantification)
           {mp_ImageDimensionsAndQuantification = ap_ImageDimensionsAndQuantification;};
    inline void SetImageSpace(oImageSpace* ap_ImageSpace)
           {mp_ImageSpace = ap_ImageSpace;};
    inline void SetScanner(vScanner* ap_Scanner)
           {mp_Scanner = ap_Scanner;}
    inline void SetProjectorManager(oProjectorManager* ap_ProjectorManager)
           {mp_ProjectorManager = ap_ProjectorManager;};
    inline void SetImageConvolverManager(oImageConvolverManager* ap_ImageConvolverManager)
           {mp_ImageConvolverManager = ap_ImageConvolverManager;}
    inline void SetDeformationManager(oDeformationManager* ap_DeformationManager)
           {mp_DeformationManager = ap_DeformationManager;};
    inline void SetDataFile(vDataFile** a2p_DataFile)
           {m2p_DataFile = a2p_DataFile;};
    inline void SetComputeFromHistogramFlag(bool a_computeFromHistogramFlag)
           {m_computeFromHistogramFlag = a_computeFromHistogramFlag;}
    inline void SetPathToNormalizationFileName(vector<string> ap_pathToNormalizationFileName, bool a_inverseDataFileOrderFlag)
           { mp_pathToNormalizationFileName = ap_pathToNormalizationFileName;
             m_inverseDataFileOrderFlag = a_inverseDataFileOrderFlag; }
    inline void SetPathToAttenuationImage(string a_pathToAttenuationImage)
           {m_pathToAttenuationImage = a_pathToAttenuationImage;};
    inline void SetPathToMaskImage(string a_pathToMaskImage) {m_pathToMaskImg = a_pathToMaskImage;};
    inline void SetNumberOfAtnGateImages(int a_nbAtnRespGateImages, int a_nbAtnCardGateImages)
           {m_nbAtnRespGateImages = a_nbAtnRespGateImages; m_nbAtnCardGateImages = a_nbAtnCardGateImages;};
    inline void SetGPUflag(bool a_flagGPU)
           {m_flagGPU = a_flagGPU;};
    inline void SetVerbose(int a_verboseLevel)
           {m_verbose = a_verboseLevel;};


  // -------------------------------------------------------------------
  // Data members
  private:
    string m_pathToSensitivityImage;                  
    oImageDimensionsAndQuantification* 
                 mp_ImageDimensionsAndQuantification; 
    oImageSpace* mp_ImageSpace;                       
    vScanner* mp_Scanner;                             
    oProjectorManager* mp_ProjectorManager;           
    oImageConvolverManager* mp_ImageConvolverManager; 
    oDeformationManager* mp_DeformationManager;       
    vDataFile** m2p_DataFile;                         
    bool m_computeFromHistogramFlag;                  
    vector<string> mp_pathToNormalizationFileName;    
    bool m_inverseDataFileOrderFlag;                  
    vDataFile*** m3p_NormalizationDataFile;           
    bool m_oneNormalizationFileForAllBeds;            
    bool m_oneNormalizationFileForAllFrames;          
    string m_pathToAttenuationImage;                  
    string m_pathToMaskImg;                           
    bool m_mumapAttenuationFlag;                      
    bool m_forwardProjectAttenuation;                 
    int m_nbAtnRespGateImages;                        
    int m_nbAtnCardGateImages;                        
    uint64_t* mp_lineCounter;                         
    bool m_flagGPU;                                   
    int m_verbose;                                    
    bool m_checked;                                   
    bool m_initialized;                               
};

#endif