oProjectionLine.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 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 GetTOFResolution()
           {return m_TOFResolution;}
    inline FLTNB GetTOFMeasurement()
           {return m_TOFMeasurement;}
    inline FLTNB GetTOFBinSize()
           {return m_TOFBinSize;}
    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 SetTOFMeasurement(FLTNB a_TOFMeasurement)
           {m_TOFMeasurement = a_TOFMeasurement;}
    inline void SetTOFBinSize(FLTNB a_TOFBinSize)
           {m_TOFBinSize = a_TOFBinSize;}
    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 SetTOFResolution(FLTNB a_TOFResolution)
           {m_TOFResolution = a_TOFResolution;}
    inline void SetPOIResolution(FLTNB* ap_POIResolution)
           {mp_POIResolution = ap_POIResolution;}
    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;}


  // -------------------------------------------------------------------
  // 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_TOFResolution;                 
    FLTNB m_TOFMeasurement;                
    int m_currentTOFBin;                   
    FLTNB m_TOFBinSize;                    
    // The POI and its resolution along the 3 axis
    FLTNB* mp_POI1;                        
    FLTNB* mp_POI2;                        
    FLTNB* mp_POIResolution;               
    // 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;      
    // ------------------------------------------------------------------------------------------------------
    // 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