vProjector.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-2019 all CASToR contributors listed below:

    --> Didier BENOIT, Claude COMTAT, Marina FILIPOVIC, Thibaut MERLIN, Mael MILLARDET, Simon STUTE, Valentin VIELZEUF

This is CASToR version 3.0.
*/

#ifndef VPROJECTOR_HH
#define VPROJECTOR_HH 1

#include "gVariables.hh"
#include "vEvent.hh"
#include "oProjectionLine.hh"
#include "vScanner.hh"
#include "oImageDimensionsAndQuantification.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()
           {return m_TOFResolutionInMm;}
    inline void SetTOFResolutionInMm(FLTNB a_TOFResolutionInMm)
           {m_TOFResolutionInMm = a_TOFResolutionInMm;}
    inline FLTNB GetTOFMeasurementRangeInMm()
           {return m_TOFMeasurementRangeInMm;}
    inline void SetTOFMeasurementRangeInMm(FLTNB a_TOFMeasurementRangeInMm)
           {m_TOFMeasurementRangeInMm = a_TOFMeasurementRangeInMm;}
    inline FLTNB GetTOFBinSizeInMm()
           {return m_TOFBinSizeInMm;}
    inline void SetTOFBinSizeInMm(FLTNB a_TOFBinSizeInMm)
           {m_TOFBinSizeInMm = a_TOFBinSizeInMm;}
  // -------------------------------------------------------------------
  // 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* mp_TOFWeightingFcn;           
    FLTNB m_TOFBinSizeInMm;                
    FLTNB m_TOFMeasurementRangeInMm;       
    FLTNB m_TOFResolutionInMm;             
    FLTNB m_TOFGaussianNormCoef;           
    FLTNB m_TOFPrecomputedSamplingFactor;  
    // 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