include/projector/oProjectionLine.hh

Go to the documentation of this file.

#ifndef OPROJECTIONLINE_HH
#define OPROJECTIONLINE_HH 1

#include "gVariables.hh"
#include "oImageDimensionsAndQuantification.hh"

#define IMAGE_COMPUTATION_STRATEGY 1

#define FIXED_LIST_COMPUTATION_STRATEGY 2

#define ADAPTATIVE_LIST_COMPUTATION_STRATEGY 3

#define FORWARD 0

#define BACKWARD 1

class vProjector;


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

  // -------------------------------------------------------------------
  // Public member functions
  public:
    int CheckParameters();
    int Initialize();
    void ComputeLineLength();
    bool NotEmptyLine();
    void Reset();
    void ApplyOffset();
    void ApplyBedOffset();
    INTNB GetVoxelIndex(int a_direction, int a_TOFBin, INTNB a_voxelInLine);
    void AddVoxelInTOFBin(int a_direction, int a_TOFBin, INTNB a_voxelIndice, FLTNB a_voxelWeight);
    void AddVoxelAllTOFBins(int a_direction, INTNB a_voxelIndex, FLTNB a_voxelWeight, HPFLTNB* a_tofWeights, INTNB a_tofBinFirst, INTNB a_tofBinLast);
    void AddVoxel(int a_direction, INTNB a_voxelIndice, FLTNB a_voxelWeight);
    FLTNB ForwardProject(FLTNB* ap_image = NULL);
    FLTNB ForwardProjectWithSPECTAttenuation(FLTNB* ap_attenuation, FLTNB* ap_image = NULL);
    void BackwardProject(FLTNB* ap_image, FLTNB a_value);
    void BackwardProjectWithSPECTAttenuation(FLTNB* ap_attenuation, FLTNB* ap_image, FLTNB a_value);
    FLTNB ComputeLineIntegral(int a_direction);


  // -------------------------------------------------------------------
  // Get functions
  public:
    inline FLTNB GetVoxelWeights(int a_direction, int a_TOFBin, INTNB a_voxelInLine)
           {return m3p_voxelWeights[a_direction][a_TOFBin][a_voxelInLine];}
    inline INTNB GetCurrentNbVoxels (int a_direction, int a_TOFBin)
           {return m2p_currentNbVoxels[a_direction][a_TOFBin];}
    inline int GetNbTOFBins()
           {return m_nbTOFBins;}
    inline FLTNB GetLength()
           {return m_length;}
    inline int GetComputationStrategy()
           {return m_computationStrategy;}
    inline FLTNB* GetPosition1()
           {return mp_position1;}
    inline FLTNB* GetPosition2()
           {return mp_position2;}
    inline FLTNB* GetBufferPosition1()
           {return mp_bufferPosition1;}
    inline FLTNB* GetBufferPosition2()
           {return mp_bufferPosition2;}
    inline FLTNB* GetOrientation1()
           {return mp_orientation1;}
    inline FLTNB* GetOrientation2()
           {return mp_orientation2;}
    inline FLTNB* GetBufferOrientation1()
           {return mp_bufferOrientation1;}
    inline FLTNB* GetBufferOrientation2()
           {return mp_bufferOrientation2;}
    inline FLTNB* GetPOI1()
           {return mp_POI1;}
    inline FLTNB* GetPOI2()
           {return mp_POI2;}
    inline FLTNB GetTOFMeasurementInPs()
           {return m_TOFMeasurementInPs;}
    inline FLTNB GetTOFResolutionInPs() const
           {return m_TOFResolutionInPs;}

    inline int GetIndex1()
           {return m_index1;}
    inline int GetIndex2()
           {return m_index2;}
    inline int GetThreadNumber()
           {return m_threadNumber;}
    inline FLTNB GetBedOffset()
           {return m_bedOffset;}


  // -------------------------------------------------------------------
  // Set functions
  public:
    inline void SetLength(FLTNB a_length)
           {m_length = a_length;}
    inline void SetPOI1(FLTNB* ap_POI1)
           {mp_POI1 = ap_POI1;}
    inline void SetPOI2(FLTNB* ap_POI2)
           {mp_POI2 = ap_POI2;}
    inline void SetTOFMeasurementInPs(FLTNB a_TOFMeasurementInPs)
           {m_TOFMeasurementInPs = a_TOFMeasurementInPs;}
    inline void SetTOFSigmaInPs(FLTNB a_TOFSigmaInPs)
           { m_TOFResolutionInPs = a_TOFSigmaInPs;}

    inline void SetIndex1(int a_index1)
           {m_index1 = a_index1;}
    inline void SetIndex2(int a_index2)
           {m_index2 = a_index2;}
    inline void SetNbTOFBins(int a_nbTOFBins)
           {m_nbTOFBins = a_nbTOFBins;}
    inline void SetCurrentTOFBin(int a_TOFBin)
           {m_currentTOFBin = a_TOFBin;}
    inline void SetMatchedProjectors(bool a_UseMatchedProjectors)
           {m_useMatchedProjectors = a_UseMatchedProjectors;}
    inline void SetPOIResolution(FLTNB* ap_POIResolution)
           {mp_POIResolution = ap_POIResolution;}
    inline int GetNbCustomFLTData()
               {return m_nbCustomFLTData;}
               
    inline int GetNbCustomINTData()
               {return m_nbCustomINTData;}
               
    inline void SetNbCustomFLTData( int a_value )
               {m_nbCustomFLTData = a_value;}
    inline void SetNbCustomINTData( int a_value )
               {m_nbCustomINTData = a_value;}
    inline EVTFLTDATA* GetCustomFLTData()
               {return mp_customFLTData;}
               
    inline EVTINTDATA* GetCustomINTData()
               {return mp_customINTData;}
               
    inline EVTFLTDATA GetCustomFLTData(int a_idx)
               {return mp_customFLTData[ a_idx ];}
    
    inline EVTINTDATA GetCustomINTData(int a_idx)
               {return mp_customINTData[ a_idx ];}

    inline void SetCustomFLTData(EVTFLTDATA* ap_pointer)
               {mp_customFLTData = ap_pointer;}
    inline void SetCustomINTData(EVTINTDATA* ap_pointer)
               {mp_customINTData = ap_pointer;}
    
    inline void SetImageDimensionsAndQuantification(oImageDimensionsAndQuantification* ap_ImageDimensionsAndQuantification)
           {mp_ImageDimensionsAndQuantification = ap_ImageDimensionsAndQuantification;}
    inline void SetComputationStrategy(int a_computationStrategy)
           {m_computationStrategy = a_computationStrategy;}
    inline void SetForwardProjector(vProjector* ap_Projector)
           {mp_ForwardProjector = ap_Projector;}
    inline void SetBackwardProjector(vProjector* ap_Projector)
           {mp_BackwardProjector = ap_Projector;}
    inline void SetThreadNumber(int a_threadNumber)
           {m_threadNumber = a_threadNumber;}
    inline void SetMultiplicativeCorrection(FLTNB a_multiplicativeCorrection)
           {m_multiplicativeCorrection = a_multiplicativeCorrection;}
    inline void SetVerbose(int a_verbose)
           {m_verbose = a_verbose;}
    inline void SetBedOffset(FLTNB a_bedOffset)
           {m_bedOffset = a_bedOffset;}
    inline void SetEventIndex(int a_eventIndex)
           {m_eventIndex = a_eventIndex;}
    inline int64_t GetEventIndex()
           {return m_eventIndex;}


  // -------------------------------------------------------------------
  // Data members
  private:

    // Verbose level
    int m_verbose;                         
    // Has been checked ?
    bool m_checked;                        
    // Has been initialized ?
    bool m_initialized;                    
    // ---------------------------------------------------------------------------------------------------
    // Common stuff
    // ---------------------------------------------------------------------------------------------------

    // The thread number associated to this projection line
    int m_threadNumber;                    
    // The current multiplicative correction factor (that will be applied during forward and backward projections)
    FLTNB m_multiplicativeCorrection;      
    // Image dimensions
    oImageDimensionsAndQuantification* 
      mp_ImageDimensionsAndQuantification; 
    // The computation strategy for multiple lines (see comments above)
    int m_computationStrategy;             
    // The bed offset (when multiple bed positions are reconstructed simultaneously
    FLTNB m_bedOffset;                     
    // The number of TOF bins, TOF resolution and measurement
    int m_nbTOFBins;                       
    FLTNB m_TOFMeasurementInPs;            
    FLTNB m_TOFResolutionInPs;              
    int m_currentTOFBin;                   
    // The POI and its resolution along the 3 axis
    FLTNB* mp_POI1;                        
    FLTNB* mp_POI2;                        
    FLTNB* mp_POIResolution;               
    // Pointer to optional additionnal data present in the event, and related variable
    EVTFLTDATA* mp_customFLTData;  
    EVTINTDATA* mp_customINTData;  
    int m_nbCustomFLTData;    
    int m_nbCustomINTData;    
    // This is the length of the line
    FLTNB m_length;                        
    // These are the positions and orientations of the two end points (the buffer ones are used only as buffer when compression)
    FLTNB* mp_position1;                   
    FLTNB* mp_position2;                   
    FLTNB* mp_bufferPosition1;             
    FLTNB* mp_bufferPosition2;             
    FLTNB* mp_orientation1;                
    FLTNB* mp_orientation2;                
    FLTNB* mp_bufferOrientation1;          
    FLTNB* mp_bufferOrientation2;          
    // These are the indices associated to the two end points (in case of compression, set to -1)
    int m_index1;                          
    int m_index2;                          
    // The rest of the data members can be different for forward and backward operations.
    // However only one operation can be used for simple forward or backward needs.
    // This is managed by this boolean flag that said if we use matched projectors or not.
    bool m_useMatchedProjectors;           
    vProjector* mp_ForwardProjector;       
    vProjector* mp_BackwardProjector;      
    int64_t m_eventIndex;                  
    // ------------------------------------------------------------------------------------------------------
    // For the rest below, the first pointer is used to discriminate between forward and backward projectors,
    // while the second pointer discriminates between TOF bins
    // ------------------------------------------------------------------------------------------------------

    // The allocated number of voxels corresponds to the maximum number of contributing
    // voxels a line of the ProjectionLine can handle. Whereas the current number of voxels
    // is the number of voxels that a line is currently using, when using the LIST_COMPUTATION
    // strategy.
    INTNB** m2p_allocatedNbVoxels;         
    INTNB** m2p_currentNbVoxels;           
    // This contains the voxels indices for each lines, when using the both LIST_COMPUTATION strategies
    INTNB*** m3p_voxelIndices;             
    // This contains the voxels weights for both computation strategies
    FLTNB*** m3p_voxelWeights;             
};

#endif