code/include/projector/vProjector.hh

Go to the documentation of this file.

#ifndef VPROJECTOR_HH
#define VPROJECTOR_HH 1

#include "gVariables.hh"
#include "vEvent.hh"
#include "oProjectionLine.hh"
#include "vScanner.hh"
#include "oImageDimensionsAndQuantification.hh"
#include "sChronoManager.hh"

#define USE_TOFHISTO 1

#define USE_TOFLIST 2

#define USE_NOTOF  3

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


  // -------------------------------------------------------------------
  // Public member functions
  public:
    void ShowHelp();
    static void ShowCommonHelp();
    int ReadCommonOptionsList(const string& a_optionsList);
    int CheckParameters();
    int Initialize();
    int Project(int a_direction, oProjectionLine* ap_ProjectionLine, uint32_t* ap_index1, uint32_t* ap_index2, int a_nbIndices);


  // -------------------------------------------------------------------
  // Virtual but not pure for children
  public:
    virtual INTNB EstimateMaxNumberOfVoxelsPerLine();


  // -------------------------------------------------------------------
  // Pure virtual public member functions that need to be implemented by children
  public:
    virtual int ReadConfigurationFile(const string& a_configurationFile) = 0;
    virtual int ReadOptionsList(const string& a_optionsList) = 0;


  // -------------------------------------------------------------------
  // Pure virtual private member functions that need to be implemented by children
  private:
    virtual void ShowHelpSpecific() = 0;
    virtual int CheckSpecificParameters() = 0;
    virtual int InitializeSpecific() = 0;
    virtual int ProjectWithoutTOF( int a_direction, oProjectionLine* ap_ProjectionLine ) = 0;
    virtual int ProjectTOFListmode( int a_direction, oProjectionLine* ap_ProjectionLine ) = 0;
    virtual int ProjectTOFHistogram( int a_direction, oProjectionLine* ap_ProjectionLine ) = 0;


  // -------------------------------------------------------------------
  // Public Get & Set functions
  public:
    inline void SetVerbose(int a_verbose)
           {m_verbose = a_verbose;}
    inline void SetScanner(vScanner* ap_Scanner)
           {mp_Scanner = ap_Scanner;}
    inline void SetSensitivityMode(bool a_sensitivityMode)
           {m_sensitivityMode = a_sensitivityMode;}
    inline void SetApplyTOF(int a_applyTOF)
           {m_TOFMethod = a_applyTOF;}
    inline void SetApplyPOI(bool a_applyPOI)
           {m_applyPOI = a_applyPOI;}
    int SetImageDimensionsAndQuantification(oImageDimensionsAndQuantification* ap_ImageDimensionsAndQuantification);
    inline bool GetCompatibilityWithSPECTAttenuationCorrection()
           {return m_compatibleWithSPECTAttenuationCorrection;}
    inline bool GetCompatibilityWithCompression()
           {return m_compatibleWithCompression;}
    inline void SetMask(bool* ap_mask){ mp_mask = ap_mask; m_hasMask = true;}
    inline FLTNB GetTOFResolutionInMm(int a_resolution)
           {return mp_TOFResolutionInMm[a_resolution];}
    inline FLTNB GetTOFProbabilities(int a_resolution)
           {return mp_TOFProbabilities[a_resolution];}
    inline FLTNB GetTOFOffsetInMm(int a_resolution)
           {return mp_TOFOffsetInMm[ a_resolution ];}
    inline void SetTOFResolutionInMm(FLTNB* ap_TOFResolutionInMm)
           {mp_TOFResolutionInMm = ap_TOFResolutionInMm;}
    inline void SetTOFProbabilities(FLTNB* ap_TOFProbabilities)
           {mp_TOFProbabilities = ap_TOFProbabilities;}  
    inline void SetTOFOffsetInMm(FLTNB* ap_TOFOffsetsInMm)
           {mp_TOFOffsetInMm = ap_TOFOffsetsInMm;}  
    inline FLTNB GetTOFMeasurementRangeInMm()
           {return m_TOFMeasurementRangeInMm;}
    inline void SetTOFMeasurementRangeInMm(FLTNB a_TOFMeasurementRangeInMm)
           {m_TOFMeasurementRangeInMm = a_TOFMeasurementRangeInMm;}
    inline void SetTOFEventResolutionFlag(FLTNB a_TOFEventResolutionFlag)
           {m_TOFEventResolutionFlag = a_TOFEventResolutionFlag;} 
    inline bool GetTOFEventResolutionFlag()
           {return m_TOFEventResolutionFlag;}
           
    inline FLTNB GetTOFBinSizeInMm()
           {return m_TOFBinSizeInMm;}
    inline void SetTOFBinSizeInMm(FLTNB a_TOFBinSizeInMm)
           {m_TOFBinSizeInMm = a_TOFBinSizeInMm;}

    inline int GetNbTOFResolutions()
           {return m_nbTOFResolutions;}
           
    inline void SetNbTOFResolutions(int a_nbTOFResolutions)
           {m_nbTOFResolutions = a_nbTOFResolutions;}
    
  // -------------------------------------------------------------------
  // Data members
  protected:
    // Few data from the oImageDimensionsAndQuantification to avoid getting them too often
    FLTNB mp_sizeVox[3];                   
    INTNB mp_nbVox[3];                     
    INTNB m_nbVoxXY;                       
    FLTNB mp_halfFOV[3];                   
    // Image dimensions
    oImageDimensionsAndQuantification* 
      mp_ImageDimensionsAndQuantification; 
    // Scanner
    vScanner* mp_Scanner;                  
    // TOF related
    int m_TOFMethod;                       
    FLTNB  m_TOFNbSigmas;                  
    INTNB  m_TOFWeightingFcnNbSamples;     
    bool   m_TOFWeightingFcnPrecomputedFlag;
    bool   m_TOFBinProperProcessingFlag;   
    HPFLTNB** m2p_TOFWeightingFcn;         
    int    m_nbTOFResolutions;             
    FLTNB  m_TOFBinSizeInMm;               
    FLTNB  m_TOFMeasurementRangeInMm;      
    FLTNB  m_TOFLargestResolutionInMm;     
    FLTNB* mp_TOFResolutionInMm;           
    FLTNB* mp_TOFProbabilities;            
    FLTNB* mp_TOFOffsetInMm;               
    FLTNB* mp_TOFGaussianNormCoef;         
    FLTNB  m_TOFPrecomputedSamplingFactor; 
    bool   m_TOFEventResolutionFlag;       
    // Voxel mask to remove voxels from projection
    bool* mp_mask;                         
    bool m_hasMask;                        
    // Flag for POI
    bool m_applyPOI;                       
    // Flag for sensitivity computation
    bool m_sensitivityMode;                
    // Flag that says if the projector is compatible with SPECT attenuation correction
    bool m_compatibleWithSPECTAttenuationCorrection; 
    // Flag that says if the projection is compatible with compression
    // (i.e. when the crystal indices in the projection line will be -1 as they are not unique for a given event)
    bool m_compatibleWithCompression; 
    // Verbosity
    int m_verbose;                         
    // Has been checked ?
    bool m_checked;                        
    // Has been initialized ?
    bool m_initialized;                    
};

// ----------------------------------------------------------------------
// Part of code that manages the auto declaration of children classes
// ----------------------------------------------------------------------

// Macro for the function that creates the object
#define FUNCTION_PROJECTOR(CLASS) \
  static vProjector *make_projector() { return new CLASS(); };

// Macro for the class that links the appropriate function to the map of objects
#define CLASS_PROJECTOR(NAME,CLASS)                                                           \
  class NAME##ProjectorCreator                                                                \
  {                                                                                           \
    public:                                                                                   \
      NAME##ProjectorCreator()                                                                \
        { sAddonManager::GetInstance()->mp_listOfProjectors[#NAME] = CLASS::make_projector; } \
  };                                                                                          \
  static NAME##ProjectorCreator ProjectorCreator##NAME;

#endif