diff --git a/Modules/Pharmacokinetics/include/mitkConcentrationCurveGenerator.h b/Modules/Pharmacokinetics/include/mitkConcentrationCurveGenerator.h
index 0aeaea703c..6536e5f630 100644
--- a/Modules/Pharmacokinetics/include/mitkConcentrationCurveGenerator.h
+++ b/Modules/Pharmacokinetics/include/mitkConcentrationCurveGenerator.h
@@ -1,161 +1,161 @@
/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#ifndef CONCENTRATIONCURVEGENERATOR_H
#define CONCENTRATIONCURVEGENERATOR_H
#include <mitkImage.h>
#include <itkBinaryFunctorImageFilter.h>
#include "mitkConvertToConcentrationAbsoluteFunctor.h"
#include "mitkConvertToConcentrationRelativeFunctor.h"
#include "MitkPharmacokineticsExports.h"
namespace mitk {
/** \class ConcentrationCurveGenerator
* \brief Converts a given 4D mitk::Image with MR signal values into a 4D mitk::Image with corresponding contrast agent concentration values
*
* From a given 4D image, the Generator takes the 3D image of the first time point as baseline image. It then loops over all time steps, casts
* the current 3D image to itk and passes it to the ConvertToconcentrationFunctor. The returned 3D image has now values of concentration type and is stored at its timepoint
* in the return image.
*/
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;
/** Getter and Setter for 4D mitk::Image*/
itkSetConstObjectMacro(DynamicImage,Image);
itkGetConstObjectMacro(DynamicImage,Image);
/** Parameters Relevant for conversion Calculation; Have to be Set externally (Sequence Dependend)*/
itkSetMacro(RelaxationTime, double);
itkGetConstReferenceMacro(RelaxationTime, double);
itkSetMacro(Relaxivity, double);
itkGetConstReferenceMacro(Relaxivity, double);
itkSetMacro(RecoveryTime, double);
itkGetConstReferenceMacro(RecoveryTime, double);
itkSetMacro(FlipAngle, double);
itkGetConstReferenceMacro(FlipAngle, double);
itkSetMacro(Factor, double);
itkGetConstReferenceMacro(Factor, double);
/** Getter and Setter for T10 Map image*/
itkSetConstObjectMacro(T10Image,Image);
itkGetConstObjectMacro(T10Image,Image);
itkSetMacro(T2Factor, double);
itkGetConstReferenceMacro(T2Factor, double);
itkSetMacro(T2EchoTime, double);
itkGetConstReferenceMacro(T2EchoTime, double);
/** @brief Calls Convert and returns the 4D mitk::image in Concentration units*/
itkSetMacro(BaselineStartTimeStep, int);
itkGetConstReferenceMacro(BaselineStartTimeStep, int);
itkSetMacro(BaselineEndTimeStep, int);
itkGetConstReferenceMacro(BaselineEndTimeStep, 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>
- mitk::Image::Pointer convertToConcentration(const mitk::Image* inputImage, const mitk::Image* baselineImage);
+ 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);
/** Calls ConvertToconcentrationFunctor for passed 3D itk::image*/
mitk::Image::Pointer ConvertSignalToConcentrationCurve(const mitk::Image* inputImage, const mitk::Image* baselineImage);
/** @brief Takes the 3D image of the first timepoint to set as baseline image*/
void PrepareBaselineImage();
template<class TPixel>
void CalculateAverageBaselineImage(const itk::Image<TPixel,4> *itkBaselineImage);
/** @brief loops over all timepoints, casts the current timepoint 3D mitk::image to itk and passes it to ConvertSignalToConcentrationCurve */
virtual void Convert();
private:
Image::ConstPointer m_DynamicImage;
Image::ConstPointer m_BaselineImage;
Image::ConstPointer m_T10Image;
-
+ 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;
//=Repetition Time TR
double m_RecoveryTime;
//= pre-CA T1 time
double m_RelaxationTime;
//= contrast agent relaxivity
double m_Relaxivity;
double m_FlipAngle;
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).
int m_BaselineStartTimeStep;
// m_BaselinStopTimeStep is the last time frame, that is included into the baseline averaging.
int m_BaselineEndTimeStep;
};
}
#endif // CONCENTRATIONCURVEGENERATOR_H
diff --git a/Modules/Pharmacokinetics/src/Common/mitkConcentrationCurveGenerator.cpp b/Modules/Pharmacokinetics/src/Common/mitkConcentrationCurveGenerator.cpp
index 9924d9147a..c2c685f9f2 100644
--- a/Modules/Pharmacokinetics/src/Common/mitkConcentrationCurveGenerator.cpp
+++ b/Modules/Pharmacokinetics/src/Common/mitkConcentrationCurveGenerator.cpp
@@ -1,380 +1,327 @@
#include "mitkConcentrationCurveGenerator.h"
#include "mitkConvertToConcentrationTurboFlashFunctor.h"
#include "mitkConvertT2ConcentrationFunctor.h"
#include "mitkConvertToConcentrationViaT1Functor.h"
#include "mitkImageTimeSelector.h"
#include "mitkImageCast.h"
#include "mitkITKImageImport.h"
#include "mitkModelBase.h"
#include "mitkExtractTimeGrid.h"
#include "mitkArbitraryTimeGeometry.h"
#include "itkNaryAddImageFilter.h"
#include "mitkImageAccessByItk.h"
#include "itkImageIOBase.h"
#include "itkBinaryFunctorImageFilter.h"
#include "itkTernaryFunctorImageFilter.h"
#include <itkExtractImageFilter.h>
-#include <itkMultiplyImageFilter.h>
-#include <itkCastImageFilter.h>
+#include "itkMeanProjectionImageFilter.h"
mitk::ConcentrationCurveGenerator::ConcentrationCurveGenerator() : m_isT2weightedImage(false), m_isTurboFlashSequence(false),
m_AbsoluteSignalEnhancement(false), m_RelativeSignalEnhancement(0.0), m_UsingT1Map(false), m_Factor(0.0), m_RecoveryTime(0.0), m_RelaxationTime(0.0),
- m_Relaxivity(0.0), m_FlipAngle(0.0), m_T2Factor(0.0), m_T2EchoTime(0.0)
+ m_Relaxivity(0.0), m_FlipAngle(0.0), m_T2Factor(0.0), m_T2EchoTime(0.0)
{
}
mitk::ConcentrationCurveGenerator::~ConcentrationCurveGenerator()
{
}
mitk::Image::Pointer mitk::ConcentrationCurveGenerator::GetConvertedImage()
{
if(this->m_DynamicImage.IsNull())
{
itkExceptionMacro( << "Dynamic Image not set!");
}
else {
Convert();
}
return m_ConvertedImage;
}
void mitk::ConcentrationCurveGenerator::Convert()
{
mitk::Image::Pointer tempImage = mitk::Image::New();
mitk::PixelType pixeltype = mitk::MakeScalarPixelType<double>();
tempImage->Initialize(pixeltype,*this->m_DynamicImage->GetTimeGeometry());
mitk::TimeGeometry::Pointer timeGeometry = (this->m_DynamicImage->GetTimeGeometry())->Clone();
tempImage->SetTimeGeometry(timeGeometry);
PrepareBaselineImage();
mitk::ImageTimeSelector::Pointer imageTimeSelector = mitk::ImageTimeSelector::New();
imageTimeSelector->SetInput(this->m_DynamicImage);
for(unsigned int i = 0; i< this->m_DynamicImage->GetTimeSteps(); ++i)
{
imageTimeSelector->SetTimeNr(i);
imageTimeSelector->UpdateLargestPossibleRegion();
mitk::Image::Pointer mitkInputImage = imageTimeSelector->GetOutput();
mitk::Image::Pointer outputImage = mitk::Image::New();
outputImage = ConvertSignalToConcentrationCurve(mitkInputImage,this->m_BaselineImage);
mitk::ImageReadAccessor accessor(outputImage);
tempImage->SetVolume(accessor.GetData(), i);
}
this->m_ConvertedImage = tempImage;
}
void mitk::ConcentrationCurveGenerator::PrepareBaselineImage()
{
mitk::ImageTimeSelector::Pointer imageTimeSelector = mitk::ImageTimeSelector::New();
imageTimeSelector->SetInput(this->m_DynamicImage);
imageTimeSelector->SetTimeNr(0);
imageTimeSelector->UpdateLargestPossibleRegion();
mitk::Image::Pointer baselineImage;
baselineImage = imageTimeSelector->GetOutput();
if (m_BaselineStartTimeStep == m_BaselineEndTimeStep)
{
this->m_BaselineImage = imageTimeSelector->GetOutput();
}
else
{
try
{
AccessFixedDimensionByItk(this->m_DynamicImage, mitk::ConcentrationCurveGenerator::CalculateAverageBaselineImage, 4);
}
catch (itk::ExceptionObject & err)
{
std::cerr << "ExceptionObject in ConcentrationCurveGenerator::CalculateAverageBaselineImage caught!" << std::endl;
std::cerr << err << std::endl;
}
}
}
template<class TPixel>
void mitk::ConcentrationCurveGenerator::CalculateAverageBaselineImage(const itk::Image<TPixel, 4> *itkBaselineImage)
{
if (itkBaselineImage == NULL)
{
mitkThrow() << "Error in ConcentrationCurveGenerator::CalculateAverageBaselineImage. Input image is NULL.";
}
if (m_BaselineStartTimeStep > m_BaselineEndTimeStep)
{
mitkThrow() << "Error in ConcentrationCurveGenerator::CalculateAverageBaselineImage. End time point is before start time point.";
}
typedef itk::Image<TPixel, 4> TPixel4DImageType;
typedef itk::Image<TPixel, 3> TPixel3DImageType;
typedef itk::Image<double, 3> Double3DImageType;
+ typedef itk::Image<double, 4> Double4DImageType;
+ typedef itk::ExtractImageFilter<TPixel4DImageType, TPixel4DImageType> ExtractImageFilterType;
+ typedef itk::ExtractImageFilter<Double4DImageType, Double3DImageType> Extract3DImageFilterType;
+ typedef itk::MeanProjectionImageFilter<TPixel4DImageType,Double4DImageType> MeanProjectionImageFilterType;
- typedef itk::ExtractImageFilter<TPixel4DImageType, TPixel3DImageType> ExtractImageFilterType;
- typedef itk::NaryAddImageFilter<TPixel3DImageType, TPixel3DImageType> NaryAddBaselineImagesFilterType;
- typedef itk::MultiplyImageFilter<Double3DImageType, Double3DImageType, Double3DImageType > MultiplyImageFilterType;
- typedef itk::CastImageFilter<TPixel3DImageType, Double3DImageType> DoubleCastImageFilterType;
- typedef itk::CastImageFilter<Double3DImageType, TPixel3DImageType> TPixelCastImageFilterType;
-
- NaryAddBaselineImagesFilterType::Pointer AddBaselineImagesFilter = NaryAddBaselineImagesFilterType::New();
- MultiplyImageFilterType::Pointer multiplyImageFilter = MultiplyImageFilterType::New();
- DoubleCastImageFilterType::Pointer DoubleCastImageFilter = DoubleCastImageFilterType::New();
- TPixelCastImageFilterType::Pointer TPixelCastImageFilter = TPixelCastImageFilterType::New();
+ MeanProjectionImageFilterType::Pointer MeanProjectionImageFilter = MeanProjectionImageFilterType::New();
+ Extract3DImageFilterType::Pointer Extract3DImageFilter = Extract3DImageFilterType::New();
TPixel4DImageType::RegionType region_input = itkBaselineImage->GetLargestPossibleRegion();
if (m_BaselineEndTimeStep > region_input.GetSize()[3])
{
mitkThrow() << "Error in ConcentrationCurveGenerator::CalculateAverageBaselineImage. End time point is larger than total number of time points.";
}
- // add the selected baseline time frames to the nary add image filter
-
- for (int i = m_BaselineStartTimeStep; i <= m_BaselineEndTimeStep; ++i)
- {
- ExtractImageFilterType::Pointer ExtractFilter = ExtractImageFilterType::New();
- TPixel3DImageType::Pointer timeFrameImage = TPixel3DImageType::New();
- TPixel4DImageType::RegionType extractionRegion;
- TPixel4DImageType::SizeType size_input_aux = region_input.GetSize();
- size_input_aux[3] = 0;
- TPixel4DImageType::IndexType start_input_aux = region_input.GetIndex();
- start_input_aux[3] = i;
- extractionRegion.SetSize(size_input_aux);
- extractionRegion.SetIndex(start_input_aux);
- ExtractFilter->SetExtractionRegion(extractionRegion);
- ExtractFilter->SetInput(itkBaselineImage);
- ExtractFilter->SetDirectionCollapseToSubmatrix();
- try
- {
- ExtractFilter->Update();
- }
- catch (itk::ExceptionObject & err)
- {
- std::cerr << "ExceptionObject caught!" << std::endl;
- std::cerr << err << std::endl;
- }
- timeFrameImage = ExtractFilter->GetOutput();
- AddBaselineImagesFilter->SetInput(i-m_BaselineStartTimeStep, timeFrameImage);
- }
- try
- {
- AddBaselineImagesFilter->Update();
- }
- catch (itk::ExceptionObject & err)
- {
- std::cerr << "ExceptionObject caught!" << std::endl;
- std::cerr << err << std::endl;
- }
- DoubleCastImageFilter->SetInput(AddBaselineImagesFilter->GetOutput());
+ ExtractImageFilterType::Pointer ExtractFilter = ExtractImageFilterType::New();
+ TPixel4DImageType::Pointer baselineTimeFrameImage = TPixel4DImageType::New();
+ TPixel4DImageType::RegionType extractionRegion;
+ TPixel4DImageType::SizeType size_input_aux = region_input.GetSize();
+ size_input_aux[3] = m_BaselineEndTimeStep - m_BaselineStartTimeStep+1;
+ TPixel4DImageType::IndexType start_input_aux = region_input.GetIndex();
+ start_input_aux[3] = m_BaselineStartTimeStep;
+ extractionRegion.SetSize(size_input_aux);
+ extractionRegion.SetIndex(start_input_aux);
+ ExtractFilter->SetExtractionRegion(extractionRegion);
+ ExtractFilter->SetInput(itkBaselineImage);
+ ExtractFilter->SetDirectionCollapseToSubmatrix();
try
{
- DoubleCastImageFilter->Update();
+ ExtractFilter->Update();
}
catch (itk::ExceptionObject & err)
{
std::cerr << "ExceptionObject caught!" << std::endl;
std::cerr << err << std::endl;
}
- multiplyImageFilter->SetInput(DoubleCastImageFilter->GetOutput());
- double factor = 1.0/double(m_BaselineEndTimeStep-m_BaselineStartTimeStep+1);
- multiplyImageFilter->SetConstant(factor);
+ baselineTimeFrameImage = ExtractFilter->GetOutput();
+ MeanProjectionImageFilter->SetProjectionDimension(3);
+ MeanProjectionImageFilter->SetInput(baselineTimeFrameImage);
try
{
- multiplyImageFilter->Update();
+ MeanProjectionImageFilter->Update();
}
catch (itk::ExceptionObject & err)
{
std::cerr << "ExceptionObject caught!" << std::endl;
std::cerr << err << std::endl;
}
- TPixelCastImageFilter->SetInput(multiplyImageFilter->GetOutput());
+ Extract3DImageFilter->SetInput(MeanProjectionImageFilter->GetOutput());
+ size_input_aux[3] = 0;
+ start_input_aux[3] = 0;
+ extractionRegion.SetSize(size_input_aux);
+ extractionRegion.SetIndex(start_input_aux);
+ Extract3DImageFilter->SetExtractionRegion(extractionRegion);
+ Extract3DImageFilter->SetDirectionCollapseToSubmatrix();
try
{
- TPixelCastImageFilter->Update();
+ Extract3DImageFilter->Update();
}
catch (itk::ExceptionObject & err)
{
std::cerr << "ExceptionObject caught!" << std::endl;
std::cerr << err << std::endl;
}
+
Image::Pointer mitkBaselineImage = Image::New();
- CastToMitkImage(TPixelCastImageFilter->GetOutput(), mitkBaselineImage);
+ CastToMitkImage(Extract3DImageFilter->GetOutput(), mitkBaselineImage);
this->m_BaselineImage = mitkBaselineImage;
}
-mitk::Image::Pointer mitk::ConcentrationCurveGenerator::ConvertSignalToConcentrationCurve(const mitk::Image* inputImage, const mitk::Image* baselineImage)
+mitk::Image::Pointer mitk::ConcentrationCurveGenerator::ConvertSignalToConcentrationCurve(const mitk::Image* inputImage,const mitk::Image* baselineImage)
{
- mitk::PixelType m_PixelType = inputImage->GetPixelType();
- mitk::Image::Pointer outputImage;
-
- if(inputImage->GetPixelType().GetComponentType() != baselineImage->GetPixelType().GetComponentType())
- {
- mitkThrow() << "Input Image and Baseline Image have different Pixel Types. Data not supported";
- }
-
-
- if(m_PixelType.GetComponentType() == itk::ImageIOBase::USHORT)
- {
- outputImage = convertToConcentration<unsigned short>(inputImage, baselineImage);
- }
- else if(m_PixelType.GetComponentType() == itk::ImageIOBase::UINT)
- {
- outputImage = convertToConcentration<unsigned int>(inputImage, baselineImage);
- }
- else if(m_PixelType.GetComponentType() == itk::ImageIOBase::INT)
- {
- outputImage = convertToConcentration<int>(inputImage, baselineImage);
- }
- else if(m_PixelType.GetComponentType() == itk::ImageIOBase::SHORT)
- {
- outputImage = convertToConcentration<short>(inputImage, baselineImage);
- }
- else if(m_PixelType.GetComponentType() == itk::ImageIOBase::DOUBLE)
- {
- outputImage = convertToConcentration<double>(inputImage, baselineImage);
- }
- else if(m_PixelType.GetComponentType() == itk::ImageIOBase::FLOAT)
- {
- outputImage = convertToConcentration<double>(inputImage, baselineImage);
- }
- else
- {
- mitkThrow() << "PixelType is "<<m_PixelType.GetComponentTypeAsString()<< ". Data Pixel Type not supported";
- }
-
+ mitk::PixelType m_PixelType = inputImage->GetPixelType();
+ AccessTwoImagesFixedDimensionByItk(inputImage, baselineImage, mitk::ConcentrationCurveGenerator::convertToConcentration, 3);
+ return m_ConvertSignalToConcentrationCurve_OutputImage;
- return outputImage;
}
-template<class Tpixel>
-mitk::Image::Pointer mitk::ConcentrationCurveGenerator::convertToConcentration(const mitk::Image* inputImage, const mitk::Image* baselineImage)
-{
- typedef itk::Image<Tpixel, 3> InputImageType;
-
- typename InputImageType::Pointer itkInputImage = InputImageType::New();
- typename InputImageType::Pointer itkBaselineImage = InputImageType::New();
-
- mitk::CastToItkImage(inputImage, itkInputImage );
- mitk::CastToItkImage(baselineImage, itkBaselineImage );
-
-
- mitk::Image::Pointer outputImage;
- if(this->m_isT2weightedImage)
+template<class TPixel_input, class TPixel_baseline>
+mitk::Image::Pointer mitk::ConcentrationCurveGenerator::convertToConcentration(const itk::Image<TPixel_input, 3> *itkInputImage, const itk::Image<TPixel_baseline, 3> *itkBaselineImage)
+{
+ typedef itk::Image<TPixel_input, 3> InputImageType;
+ typedef itk::Image<TPixel_baseline, 3> BaselineImageType;
+ typedef itk::Image<double, 3> DoubleImageType;
+
+ typename DoubleImageType::Pointer itkDoubleInputImage = DoubleImageType::New();
+ typename DoubleImageType::Pointer itkDoubleBaselineImage = DoubleImageType::New();
+
+ typedef itk::CastImageFilter<InputImageType, DoubleImageType> CastInputImageToDoubleImageFilterType;
+ CastInputImageToDoubleImageFilterType::Pointer CastInputImageToDoubleImageFilter = CastInputImageToDoubleImageFilterType::New();
+ CastInputImageToDoubleImageFilter->SetInput(itkInputImage);
+ CastInputImageToDoubleImageFilter->Update();
+ itkDoubleInputImage = CastInputImageToDoubleImageFilter->GetOutput();
+
+ typedef itk::CastImageFilter<BaselineImageType, DoubleImageType> CastBaselineImageToDoubleImageFilterType;
+ CastBaselineImageToDoubleImageFilterType::Pointer CastBaselineImageToDoubleImageFilter = CastBaselineImageToDoubleImageFilterType::New();
+ CastBaselineImageToDoubleImageFilter->SetInput(itkBaselineImage);
+ CastBaselineImageToDoubleImageFilter->Update();
+ itkDoubleBaselineImage = CastBaselineImageToDoubleImageFilter->GetOutput();
+
+ if (this->m_isT2weightedImage)
{
- typedef mitk::ConvertT2ConcentrationFunctor <Tpixel, Tpixel, double> ConversionFunctorT2Type;
- typedef itk::BinaryFunctorImageFilter<InputImageType,InputImageType, ConvertedImageType, ConversionFunctorT2Type> FilterT2Type;
+ typedef mitk::ConvertT2ConcentrationFunctor <double, double, double> ConversionFunctorT2Type;
+ typedef itk::BinaryFunctorImageFilter<DoubleImageType, DoubleImageType, ConvertedImageType, ConversionFunctorT2Type> FilterT2Type;
ConversionFunctorT2Type ConversionT2Functor;
ConversionT2Functor.initialize(this->m_T2Factor, this->m_T2EchoTime);
typename FilterT2Type::Pointer ConversionT2Filter = FilterT2Type::New();
ConversionT2Filter->SetFunctor(ConversionT2Functor);
- ConversionT2Filter->SetInput1(itkInputImage);
- ConversionT2Filter->SetInput2(itkBaselineImage);
+ ConversionT2Filter->SetInput1(itkDoubleInputImage);
+ ConversionT2Filter->SetInput2(itkDoubleBaselineImage);
ConversionT2Filter->Update();
- outputImage = mitk::ImportItkImage(ConversionT2Filter->GetOutput())->Clone();
- }
+ m_ConvertSignalToConcentrationCurve_OutputImage = mitk::ImportItkImage(ConversionT2Filter->GetOutput())->Clone();
+ }
else
{
if(this->m_isTurboFlashSequence)
{
- typedef mitk::ConvertToConcentrationTurboFlashFunctor <Tpixel, Tpixel, double> ConversionFunctorTurboFlashType;
- typedef itk::BinaryFunctorImageFilter<InputImageType,InputImageType, ConvertedImageType, ConversionFunctorTurboFlashType> FilterTurboFlashType;
+ typedef mitk::ConvertToConcentrationTurboFlashFunctor <double, double, double> ConversionFunctorTurboFlashType;
+ typedef itk::BinaryFunctorImageFilter<DoubleImageType, DoubleImageType, ConvertedImageType, ConversionFunctorTurboFlashType> FilterTurboFlashType;
ConversionFunctorTurboFlashType ConversionTurboFlashFunctor;
ConversionTurboFlashFunctor.initialize(this->m_RelaxationTime, this->m_Relaxivity, this->m_RecoveryTime);
typename FilterTurboFlashType::Pointer ConversionTurboFlashFilter = FilterTurboFlashType::New();
ConversionTurboFlashFilter->SetFunctor(ConversionTurboFlashFunctor);
- ConversionTurboFlashFilter->SetInput1(itkInputImage);
- ConversionTurboFlashFilter->SetInput2(itkBaselineImage);
+ ConversionTurboFlashFilter->SetInput1(itkDoubleInputImage);
+ ConversionTurboFlashFilter->SetInput2(itkDoubleBaselineImage);
ConversionTurboFlashFilter->Update();
- outputImage = mitk::ImportItkImage(ConversionTurboFlashFilter->GetOutput())->Clone();
+ m_ConvertSignalToConcentrationCurve_OutputImage = mitk::ImportItkImage(ConversionTurboFlashFilter->GetOutput())->Clone();
}
else if(this->m_UsingT1Map)
{
- typename InputImageType::Pointer itkT10Image = InputImageType::New();
+ typename DoubleImageType::Pointer itkT10Image = DoubleImageType::New();
mitk::CastToItkImage(m_T10Image, itkT10Image);
- typedef mitk::ConvertToConcentrationViaT1CalcFunctor <Tpixel, Tpixel, Tpixel, double> ConvertToConcentrationViaT1CalcFunctorType;
- typedef itk::TernaryFunctorImageFilter<InputImageType, InputImageType, InputImageType,ConvertedImageType, ConvertToConcentrationViaT1CalcFunctorType> FilterT1MapType;
+ typedef mitk::ConvertToConcentrationViaT1CalcFunctor <double, double, double, double> ConvertToConcentrationViaT1CalcFunctorType;
+ typedef itk::TernaryFunctorImageFilter<DoubleImageType, DoubleImageType, DoubleImageType,ConvertedImageType, ConvertToConcentrationViaT1CalcFunctorType> FilterT1MapType;
ConvertToConcentrationViaT1CalcFunctorType ConversionT1MapFunctor;
ConversionT1MapFunctor.initialize(this->m_Relaxivity, this->m_RecoveryTime, this->m_FlipAngle);
typename FilterT1MapType::Pointer ConversionT1MapFilter = FilterT1MapType::New();
ConversionT1MapFilter->SetFunctor(ConversionT1MapFunctor);
- ConversionT1MapFilter->SetInput1(itkInputImage);
- ConversionT1MapFilter->SetInput2(itkBaselineImage);
+ ConversionT1MapFilter->SetInput1(itkDoubleInputImage);
+ ConversionT1MapFilter->SetInput2(itkDoubleBaselineImage);
ConversionT1MapFilter->SetInput3(itkT10Image);
ConversionT1MapFilter->Update();
- outputImage = mitk::ImportItkImage(ConversionT1MapFilter->GetOutput())->Clone();
+ m_ConvertSignalToConcentrationCurve_OutputImage = mitk::ImportItkImage(ConversionT1MapFilter->GetOutput())->Clone();
}
else if(this->m_AbsoluteSignalEnhancement)
{
- typedef mitk::ConvertToConcentrationAbsoluteFunctor <Tpixel, Tpixel, double> ConversionFunctorAbsoluteType;
- typedef itk::BinaryFunctorImageFilter<InputImageType,InputImageType, ConvertedImageType, ConversionFunctorAbsoluteType> FilterAbsoluteType;
+ typedef mitk::ConvertToConcentrationAbsoluteFunctor <double, double, double> ConversionFunctorAbsoluteType;
+ typedef itk::BinaryFunctorImageFilter<DoubleImageType, DoubleImageType, ConvertedImageType, ConversionFunctorAbsoluteType> FilterAbsoluteType;
ConversionFunctorAbsoluteType ConversionAbsoluteFunctor;
ConversionAbsoluteFunctor.initialize(this->m_Factor);
typename FilterAbsoluteType::Pointer ConversionAbsoluteFilter = FilterAbsoluteType::New();
ConversionAbsoluteFilter->SetFunctor(ConversionAbsoluteFunctor);
- ConversionAbsoluteFilter->SetInput1(itkInputImage);
- ConversionAbsoluteFilter->SetInput2(itkBaselineImage);
+ ConversionAbsoluteFilter->SetInput1(itkDoubleInputImage);
+ ConversionAbsoluteFilter->SetInput2(itkDoubleBaselineImage);
ConversionAbsoluteFilter->Update();
- outputImage = mitk::ImportItkImage(ConversionAbsoluteFilter->GetOutput())->Clone();
+ m_ConvertSignalToConcentrationCurve_OutputImage = mitk::ImportItkImage(ConversionAbsoluteFilter->GetOutput())->Clone();
}
else if(this->m_RelativeSignalEnhancement)
{
- typedef mitk::ConvertToConcentrationRelativeFunctor <Tpixel, Tpixel, double> ConversionFunctorRelativeType;
- typedef itk::BinaryFunctorImageFilter<InputImageType,InputImageType, ConvertedImageType, ConversionFunctorRelativeType> FilterRelativeType;
+ typedef mitk::ConvertToConcentrationRelativeFunctor <double, double, double> ConversionFunctorRelativeType;
+ typedef itk::BinaryFunctorImageFilter<DoubleImageType, DoubleImageType, ConvertedImageType, ConversionFunctorRelativeType> FilterRelativeType;
ConversionFunctorRelativeType ConversionRelativeFunctor;
ConversionRelativeFunctor.initialize(this->m_Factor);
typename FilterRelativeType::Pointer ConversionRelativeFilter = FilterRelativeType::New();
ConversionRelativeFilter->SetFunctor(ConversionRelativeFunctor);
- ConversionRelativeFilter->SetInput1(itkInputImage);
- ConversionRelativeFilter->SetInput2(itkBaselineImage);
+ ConversionRelativeFilter->SetInput1(itkDoubleInputImage);
+ ConversionRelativeFilter->SetInput2(itkDoubleBaselineImage);
ConversionRelativeFilter->Update();
- outputImage = mitk::ImportItkImage(ConversionRelativeFilter->GetOutput())->Clone();
+ m_ConvertSignalToConcentrationCurve_OutputImage = mitk::ImportItkImage(ConversionRelativeFilter->GetOutput())->Clone();
}
- }
-
-
- return outputImage;
+ }
+ return m_ConvertSignalToConcentrationCurve_OutputImage;
}