mitkConcentrationCurveGenerator.h

Go to the documentation of this file.

/*============================================================================
 
The Medical Imaging Interaction Toolkit (MITK)
 
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
 
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
 
============================================================================*/
#ifndef mitkConcentrationCurveGenerator_h
#define mitkConcentrationCurveGenerator_h
 
#include <mitkImage.h>
#include <itkBinaryFunctorImageFilter.h>
#include "mitkConvertToConcentrationAbsoluteFunctor.h"
#include "mitkConvertToConcentrationRelativeFunctor.h"
 
#include "MitkPharmacokineticsExports.h"
 
namespace mitk {
 
class MITKPHARMACOKINETICS_EXPORT ConcentrationCurveGenerator : public itk::Object
{
public:
 
    mitkClassMacroItkParent(ConcentrationCurveGenerator, itk::Object);
    itkNewMacro(Self);
 
    //typedef itk::Image<double,3> ImageType;
    typedef itk::Image<double,3> ConvertedImageType;
 
 
    itkSetConstObjectMacro(DynamicImage,Image);
    itkGetConstObjectMacro(DynamicImage,Image);
 
    itkSetMacro(RelaxationTime, double);
    itkGetConstReferenceMacro(RelaxationTime, double);
 
    itkSetMacro(Relaxivity, double);
    itkGetConstReferenceMacro(Relaxivity, double);
 
    itkSetMacro(RecoveryTime, double);
    itkGetConstReferenceMacro(RecoveryTime, double);
 
    itkSetMacro(RepetitionTime, double);
    itkGetConstReferenceMacro(RepetitionTime, double);
 
    itkSetMacro(FlipAngle, double);
    itkGetConstReferenceMacro(FlipAngle, double);
 
    itkSetMacro(FlipAnglePDW, double);
    itkGetConstReferenceMacro(FlipAnglePDW, double);
 
    itkSetMacro(Factor, double);
    itkGetConstReferenceMacro(Factor, double);
 
    itkSetConstObjectMacro(PDWImage,Image);
    itkGetConstObjectMacro(PDWImage,Image);
 
    itkSetMacro(T2Factor, double);
    itkGetConstReferenceMacro(T2Factor, double);
 
    itkSetMacro(T2EchoTime, double);
    itkGetConstReferenceMacro(T2EchoTime, double);
 
 
    itkSetMacro(BaselineStartTimeStep, unsigned int);
    itkGetConstReferenceMacro(BaselineStartTimeStep, unsigned int);
 
    itkSetMacro(BaselineEndTimeStep, unsigned int);
    itkGetConstReferenceMacro(BaselineEndTimeStep, unsigned int);
 
    itkSetMacro(isTurboFlashSequence,bool);
    itkGetConstReferenceMacro(isTurboFlashSequence,bool);
 
    itkSetMacro(AbsoluteSignalEnhancement,bool);
    itkGetConstReferenceMacro(AbsoluteSignalEnhancement,bool);
 
    itkSetMacro(RelativeSignalEnhancement,bool);
    itkGetConstReferenceMacro(RelativeSignalEnhancement,bool);
 
    itkSetMacro(UsingT1Map,bool);
    itkGetConstReferenceMacro(UsingT1Map,bool);
 
 
    itkSetMacro(isT2weightedImage,bool);
    itkGetConstReferenceMacro(isT2weightedImage,bool);
 
    Image::Pointer GetConvertedImage();
 
protected:
 
    ConcentrationCurveGenerator();
     ~ConcentrationCurveGenerator() override;
 
 
     template<class TPixel_input, class TPixel_baseline>
     mitk::Image::Pointer convertToConcentration(const itk::Image<TPixel_input, 3> *itkInputImage, const itk::Image<TPixel_baseline, 3> *itkBaselineImage);
 
    mitk::Image::Pointer ConvertSignalToConcentrationCurve(const mitk::Image* inputImage, const mitk::Image* baselineImage);
 
 
 
    void PrepareBaselineImage();
 
    template<class TPixel>
    void CalculateAverageBaselineImage(const itk::Image<TPixel,4> *itkBaselineImage);
 
    virtual void Convert();
 
 
private:
    Image::ConstPointer m_DynamicImage;
    Image::ConstPointer m_BaselineImage;
    Image::ConstPointer m_PDWImage;
    Image::Pointer m_ConvertSignalToConcentrationCurve_OutputImage;
    Image::Pointer m_ConvertedImage;
 
    bool m_isT2weightedImage;
 
    bool m_isTurboFlashSequence;
    bool m_AbsoluteSignalEnhancement;
    bool m_RelativeSignalEnhancement;
    bool m_UsingT1Map;
 
    double m_Factor;
    //=Recovery Time
    double m_RecoveryTime;
    //=Repetition Time TR
    double m_RepetitionTime;
    //= pre-CA T1 time
    double m_RelaxationTime;
    //= contrast agent relaxivity
    double m_Relaxivity;
 
    double m_FlipAngle;
 
    double m_FlipAnglePDW;
 
    double m_T2Factor;
    double m_T2EchoTime;
    // The baseline image is averaged from the signal within time step range [m_BaselineStartTimeStep, m_BaselineEndTimeStep].
    // m_BaselineStartTimeStep is the first time frame, that is included into the baseline averaging (starting with 0).
    unsigned int m_BaselineStartTimeStep;
    // m_BaselinStopTimeStep is the last time frame, that is included into the baseline averaging.
    unsigned int m_BaselineEndTimeStep;
};
 
}
#endif