diff --git a/Modules/Pharmacokinetics/include/mitkConcentrationCurveGenerator.h b/Modules/Pharmacokinetics/include/mitkConcentrationCurveGenerator.h
index 3b933970e7..b242ee292a 100644
--- a/Modules/Pharmacokinetics/include/mitkConcentrationCurveGenerator.h
+++ b/Modules/Pharmacokinetics/include/mitkConcentrationCurveGenerator.h
@@ -1,164 +1,159 @@
/*===================================================================
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(BaselineStartTimePoint, int);
itkGetConstReferenceMacro(BaselineStartTimePoint, int);
itkSetMacro(BaselineEndTimePoint, int);
itkGetConstReferenceMacro(BaselineEndTimePoint, 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);
/** 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();
- //template <typename TPixel1, unsigned int ImageDimension1, typename TPixel2, unsigned int VImageDimension2>
- //void mitk::(itk::Image<TPixel1, VImageDimension1>* imageA, itk::Image<TPixel2, VImageDimension2>* imageB)
- //{
- //}
-
-
private:
Image::ConstPointer m_DynamicImage;
Image::ConstPointer m_BaselineImage;
Image::ConstPointer m_T10Image;
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;
int m_BaselineStartTimePoint;
int m_BaselineEndTimePoint;
};
}
#endif // CONCENTRATIONCURVEGENERATOR_H
diff --git a/Modules/Pharmacokinetics/src/Common/mitkConcentrationCurveGenerator.cpp b/Modules/Pharmacokinetics/src/Common/mitkConcentrationCurveGenerator.cpp
index 386476e3b7..4741db6139 100644
--- a/Modules/Pharmacokinetics/src/Common/mitkConcentrationCurveGenerator.cpp
+++ b/Modules/Pharmacokinetics/src/Common/mitkConcentrationCurveGenerator.cpp
@@ -1,291 +1,380 @@
#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 "mitkArithmeticOperation.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>
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)
{
}
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 baselineImage0;
- baselineImage0 = imageTimeSelector->GetOutput();
- this->m_BaselineImage = imageTimeSelector->GetOutput();
+ mitk::Image::Pointer baselineImage;
+ baselineImage = imageTimeSelector->GetOutput();
+ if (m_BaselineStartTimePoint == m_BaselineEndTimePoint)
+ {
+ 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;
+ }
+ }
+}
-
- /*
- typedef itk::NaryAddImageFilter<InputBaslineImageType, OutputBaselineImageType> itkAddBaselineImagesFilterType;
-
- typename itkAddBaselineImagesFilterType::Pointer itkNaryAddImageFilter = itkAddBaselineImagesFilterType::New();
-
- mitk::ImageTimeSelector::Pointer imageTimeSelector1 = mitk::ImageTimeSelector::New();
- imageTimeSelector1->SetInput(this->m_DynamicImage);
- imageTimeSelector1->SetTimeNr(1);
- imageTimeSelector1->UpdateLargestPossibleRegion();
- mitk::Image::Pointer baselineImage1;
- baselineImage1 = imageTimeSelector1->GetOutput();
+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_BaselineStartTimePoint > m_BaselineEndTimePoint)
+ {
+ mitkThrow() << "Error in ConcentrationCurveGenerator::CalculateAverageBaselineImage. End time point is before start time point.";
+ }
-
- //add the time frames to the descriptor filter
- std::vector<Image::Pointer> baselineCache;
- for (unsigned int i = 0; i < this->m_DynamicImage->GetTimeSteps(); ++i)
+ typedef itk::Image<TPixel, 4> TPixel4DImageType;
+ typedef itk::Image<TPixel, 3> TPixel3DImageType;
+ typedef itk::Image<double, 3> Double3DImageType;
+
+ 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();
+ TPixel4DImageType::RegionType region_input = itkBaselineImage->GetLargestPossibleRegion();
+
+ if (m_BaselineEndTimePoint > region_input.GetSize()[3])
{
- mitk::ImageTimeSelector::Pointer imageTimeSelector = mitk::ImageTimeSelector::New();
- imageTimeSelector->SetInput(this->m_DynamicImage);
- imageTimeSelector->SetTimeNr(i);
- imageTimeSelector->UpdateLargestPossibleRegion();
- Image::Pointer baselineImage = imageTimeSelector->GetOutput();
- baselineCache.push_back(baselineImage);
- mitk::CastToItkImage(baselineImage, frameImage);
- itkAddNaryImageFilter->SetInput(i, frameImage);
+ mitkThrow() << "Error in ConcentrationCurveGenerator::CalculateAverageBaselineImage. End time point is larger than total number of time points.";
}
- itkAddNaryImageFilter->GetOutput();
+ // add the selected baseline time frames to the nary add image filter
- //AccessFixedDimensionByItk_n(m_magnFIDImage.GetPointer(), mitkItkConversionHelper::CastMitkImageToDoubleItkImage, 4, (itkMagnFIDImage));
- //AccessTwoImagesFixedDimensionByItk(baselineImage0, baselineImage1, CalculateAverageImage);
- */
+ for (int i = m_BaselineStartTimePoint-1; i < m_BaselineEndTimePoint; ++i)
+ {
+ ExtractImageFilterType::Pointer ExtractFilter = ExtractImageFilterType::New();
+ TPixel3DImageType::Pointer timePointImage = 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;
+ }
+ timePointImage = ExtractFilter->GetOutput();
+ AddBaselineImagesFilter->SetInput(i-(m_BaselineStartTimePoint-1), timePointImage);
+ }
+ try
+ {
+ AddBaselineImagesFilter->Update();
+ }
+ catch (itk::ExceptionObject & err)
+ {
+ std::cerr << "ExceptionObject caught!" << std::endl;
+ std::cerr << err << std::endl;
+ }
+ DoubleCastImageFilter->SetInput(AddBaselineImagesFilter->GetOutput());
+ try
+ {
+ DoubleCastImageFilter->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_BaselineEndTimePoint-m_BaselineStartTimePoint+1);
+ multiplyImageFilter->SetConstant(factor);
+ try
+ {
+ multiplyImageFilter->Update();
+ }
+ catch (itk::ExceptionObject & err)
+ {
+ std::cerr << "ExceptionObject caught!" << std::endl;
+ std::cerr << err << std::endl;
+ }
+ TPixelCastImageFilter->SetInput(multiplyImageFilter->GetOutput());
+ try
+ {
+ TPixelCastImageFilter->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);
+ this->m_BaselineImage = mitkBaselineImage;
}
-
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";
}
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)
{
typedef mitk::ConvertT2ConcentrationFunctor <Tpixel, Tpixel, double> ConversionFunctorT2Type;
typedef itk::BinaryFunctorImageFilter<InputImageType,InputImageType, 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->Update();
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;
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->Update();
outputImage = mitk::ImportItkImage(ConversionTurboFlashFilter->GetOutput())->Clone();
}
else if(this->m_UsingT1Map)
{
typename InputImageType::Pointer itkT10Image = InputImageType::New();
mitk::CastToItkImage(m_T10Image, itkT10Image);
typedef mitk::ConvertToConcentrationViaT1CalcFunctor <Tpixel, Tpixel, Tpixel, double> ConvertToConcentrationViaT1CalcFunctorType;
typedef itk::TernaryFunctorImageFilter<InputImageType, InputImageType, InputImageType,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->SetInput3(itkT10Image);
ConversionT1MapFilter->Update();
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;
ConversionFunctorAbsoluteType ConversionAbsoluteFunctor;
ConversionAbsoluteFunctor.initialize(this->m_Factor);
typename FilterAbsoluteType::Pointer ConversionAbsoluteFilter = FilterAbsoluteType::New();
ConversionAbsoluteFilter->SetFunctor(ConversionAbsoluteFunctor);
ConversionAbsoluteFilter->SetInput1(itkInputImage);
ConversionAbsoluteFilter->SetInput2(itkBaselineImage);
ConversionAbsoluteFilter->Update();
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;
ConversionFunctorRelativeType ConversionRelativeFunctor;
ConversionRelativeFunctor.initialize(this->m_Factor);
typename FilterRelativeType::Pointer ConversionRelativeFilter = FilterRelativeType::New();
ConversionRelativeFilter->SetFunctor(ConversionRelativeFunctor);
ConversionRelativeFilter->SetInput1(itkInputImage);
ConversionRelativeFilter->SetInput2(itkBaselineImage);
ConversionRelativeFilter->Update();
outputImage = mitk::ImportItkImage(ConversionRelativeFilter->GetOutput())->Clone();
}
}
return outputImage;
}
diff --git a/Plugins/org.mitk.gui.qt.pharmacokinetics.mri/src/internal/MRPerfusionView.cpp b/Plugins/org.mitk.gui.qt.pharmacokinetics.mri/src/internal/MRPerfusionView.cpp
index 07ba8177c9..6701c7320a 100644
--- a/Plugins/org.mitk.gui.qt.pharmacokinetics.mri/src/internal/MRPerfusionView.cpp
+++ b/Plugins/org.mitk.gui.qt.pharmacokinetics.mri/src/internal/MRPerfusionView.cpp
@@ -1,1403 +1,1403 @@
/*===================================================================
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.
===================================================================*/
#include "MRPerfusionView.h"
#include "boost/tokenizer.hpp"
#include "boost/math/constants/constants.hpp"
#include <iostream>
#include "mitkWorkbenchUtil.h"
#include "mitkAterialInputFunctionGenerator.h"
#include "mitkConcentrationCurveGenerator.h"
#include <mitkDescriptivePharmacokineticBrixModelFactory.h>
#include <mitkDescriptivePharmacokineticBrixModelParameterizer.h>
#include <mitkDescriptivePharmacokineticBrixModelValueBasedParameterizer.h>
#include "mitkThreeStepLinearModelFactory.h"
#include "mitkThreeStepLinearModelParameterizer.h"
#include <mitkExtendedToftsModelFactory.h>
#include <mitkExtendedToftsModelParameterizer.h>
#include <mitkStandardToftsModelFactory.h>
#include <mitkStandardToftsModelParameterizer.h>
#include "mitkTwoCompartmentExchangeModelFactory.h"
#include "mitkTwoCompartmentExchangeModelParameterizer.h"
#include "mitkNumericTwoCompartmentExchangeModelFactory.h"
#include "mitkNumericTwoCompartmentExchangeModelParameterizer.h"
#include <mitkInitialParameterizationDelegateBase.h>
#include <mitkNodePredicateAnd.h>
#include <mitkNodePredicateOr.h>
#include <mitkNodePredicateNot.h>
#include <mitkNodePredicateProperty.h>
#include <mitkNodePredicateDataType.h>
#include <mitkPixelBasedParameterFitImageGenerator.h>
#include <mitkROIBasedParameterFitImageGenerator.h>
#include <mitkLevenbergMarquardtModelFitFunctor.h>
#include <mitkSumOfSquaredDifferencesFitCostFunction.h>
#include <mitkNormalizedSumOfSquaredDifferencesFitCostFunction.h>
#include <mitkSimpleBarrierConstraintChecker.h>
#include <mitkModelFitResultHelper.h>
#include <mitkImageTimeSelector.h>
#include <mitkMaskedDynamicImageStatisticsGenerator.h>
#include <mitkExtractTimeGrid.h>
#include <QMessageBox>
#include <QThreadPool>
#include <QFileDialog>
#include <QmitkDataStorageComboBox.h>
// Includes for image casting between ITK and MITK
#include <mitkImage.h>
#include "mitkImageCast.h"
#include "mitkITKImageImport.h"
#include <itkImage.h>
#include <itkImageRegionIterator.h>
//#include <mitkDICOMPMPropertyHelper.h>
//#include <mitkDICOMQIPropertyHelper.h>
const std::string MRPerfusionView::VIEW_ID = "org.mitk.gui.qt.pharmacokinetics.mri";
inline double convertToDouble(const std::string& data)
{
std::istringstream stepStream(data);
stepStream.imbue(std::locale("C"));
double value = 0.0;
if (!(stepStream >> value) || !(stepStream.eof()))
{
mitkThrow() << "Cannot convert string to double. String: " << data;
}
return value;
}
void MRPerfusionView::SetFocus()
{
m_Controls.btnModelling->setFocus();
}
void MRPerfusionView::CreateQtPartControl(QWidget* parent)
{
m_Controls.setupUi(parent);
m_Controls.btnModelling->setEnabled(false);
m_Controls.errorMessageLabel->hide();
this->InitModelComboBox();
connect(m_Controls.btnModelling, SIGNAL(clicked()), this, SLOT(OnModellingButtonClicked()));
connect(m_Controls.comboModel, SIGNAL(currentIndexChanged(int)), this, SLOT(OnModellSet(int)));
connect(m_Controls.radioPixelBased, SIGNAL(toggled(bool)), this, SLOT(UpdateGUIControls()));
//AIF setting
m_Controls.groupAIF->hide();
m_Controls.btnAIFFile->setEnabled(false);
m_Controls.btnAIFFile->setEnabled(false);
m_Controls.radioAIFImage->setChecked(true);
m_Controls.comboAIFMask->SetDataStorage(this->GetDataStorage());
m_Controls.comboAIFMask->SetPredicate(m_IsMaskPredicate);
m_Controls.comboAIFMask->setVisible(true);
m_Controls.comboAIFMask->setEnabled(true);
m_Controls.comboAIFImage->SetDataStorage(this->GetDataStorage());
m_Controls.comboAIFImage->SetPredicate(m_IsNoMaskImagePredicate);
m_Controls.comboAIFImage->setEnabled(false);
m_Controls.checkDedicatedAIFImage->setEnabled(true);
m_Controls.HCLSpinBox->setValue(mitk::AterialInputFunctionGenerator::DEFAULT_HEMATOCRIT_LEVEL);
connect(m_Controls.radioAIFImage, SIGNAL(toggled(bool)), m_Controls.comboAIFMask, SLOT(setVisible(bool)));
connect(m_Controls.radioAIFImage, SIGNAL(toggled(bool)), m_Controls.labelAIFMask, SLOT(setVisible(bool)));
connect(m_Controls.radioAIFImage, SIGNAL(toggled(bool)), m_Controls.checkDedicatedAIFImage, SLOT(setVisible(bool)));
connect(m_Controls.radioAIFImage, SIGNAL(toggled(bool)), m_Controls.comboAIFMask, SLOT(setEnabled(bool)));
connect(m_Controls.radioAIFImage, SIGNAL(toggled(bool)), m_Controls.checkDedicatedAIFImage, SLOT(setEnabled(bool)));
connect(m_Controls.radioAIFImage, SIGNAL(toggled(bool)), m_Controls.checkDedicatedAIFImage, SLOT(setVisible(bool)));
connect(m_Controls.radioAIFImage, SIGNAL(toggled(bool)), m_Controls.comboAIFImage, SLOT(setVisible(bool)));
connect(m_Controls.checkDedicatedAIFImage, SIGNAL(toggled(bool)), m_Controls.comboAIFImage, SLOT(setEnabled(bool)));
connect(m_Controls.radioAIFImage, SIGNAL(toggled(bool)), this, SLOT(UpdateGUIControls()));
connect(m_Controls.radioAIFFile, SIGNAL(toggled(bool)), m_Controls.btnAIFFile, SLOT(setEnabled(bool)));
connect(m_Controls.radioAIFFile, SIGNAL(toggled(bool)), m_Controls.aifFilePath, SLOT(setEnabled(bool)));
connect(m_Controls.radioAIFFile, SIGNAL(toggled(bool)), this, SLOT(UpdateGUIControls()));
connect(m_Controls.btnAIFFile, SIGNAL(clicked()), this, SLOT(LoadAIFfromFile()));
//Brix setting
m_Controls.groupDescBrix->hide();
connect(m_Controls.injectiontime, SIGNAL(valueChanged(double)), this, SLOT(UpdateGUIControls()));
//Num2CX setting
m_Controls.groupNum2CXM->hide();
connect(m_Controls.odeStepSize, SIGNAL(valueChanged(double)), this, SLOT(UpdateGUIControls()));
//Model fit configuration
m_Controls.groupBox_FitConfiguration->hide();
m_Controls.checkBox_Constraints->setEnabled(false);
m_Controls.constraintManager->setEnabled(false);
m_Controls.initialValuesManager->setEnabled(false);
m_Controls.initialValuesManager->setDataStorage(this->GetDataStorage());
connect(m_Controls.radioButton_StartParameters, SIGNAL(toggled(bool)), this, SLOT(UpdateGUIControls()));
connect(m_Controls.checkBox_Constraints, SIGNAL(toggled(bool)), this, SLOT(UpdateGUIControls()));
connect(m_Controls.initialValuesManager, SIGNAL(initialValuesChanged(void)), this, SLOT(UpdateGUIControls()));
connect(m_Controls.radioButton_StartParameters, SIGNAL(toggled(bool)), m_Controls.initialValuesManager, SLOT(setEnabled(bool)));
connect(m_Controls.checkBox_Constraints, SIGNAL(toggled(bool)), m_Controls.constraintManager, SLOT(setEnabled(bool)));
connect(m_Controls.checkBox_Constraints, SIGNAL(toggled(bool)), m_Controls.constraintManager, SLOT(setVisible(bool)));
//Concentration
m_Controls.groupConcentration->hide();
m_Controls.groupBoxTurboFlash->hide();
m_Controls.radioButtonNoConversion->setChecked(true);
m_Controls.factorSpinBox->setEnabled(false);
m_Controls.groupBox_viaT1Map->hide();
m_Controls.spinBox_baselineStartTimePoint->setValue(1);
m_Controls.spinBox_baselineEndTimePoint->setValue(1);
connect(m_Controls.radioButtonTurboFlash, SIGNAL(toggled(bool)), m_Controls.groupBoxTurboFlash, SLOT(setVisible(bool)));
connect(m_Controls.radioButtonTurboFlash, SIGNAL(toggled(bool)), this, SLOT(UpdateGUIControls()));
connect(m_Controls.relaxationtime, SIGNAL(valueChanged(double)), this, SLOT(UpdateGUIControls()));
connect(m_Controls.recoverytime, SIGNAL(valueChanged(double)), this, SLOT(UpdateGUIControls()));
connect(m_Controls.relaxivity, SIGNAL(valueChanged(double)), this, SLOT(UpdateGUIControls()));
connect(m_Controls.radioButton_absoluteEnhancement, SIGNAL(toggled(bool)), this, SLOT(UpdateGUIControls()));
connect(m_Controls.radioButton_relativeEnchancement, SIGNAL(toggled(bool)), this, SLOT(UpdateGUIControls()));
connect(m_Controls.radioButton_absoluteEnhancement, SIGNAL(toggled(bool)), m_Controls.factorSpinBox, SLOT(setEnabled(bool)));
connect(m_Controls.radioButton_relativeEnchancement, SIGNAL(toggled(bool)), m_Controls.factorSpinBox, SLOT(setEnabled(bool)));
connect(m_Controls.factorSpinBox, SIGNAL(valueChanged(double)), this, SLOT(UpdateGUIControls()));
connect(m_Controls.radioButtonUsingT1, SIGNAL(toggled(bool)), m_Controls.groupBox_viaT1Map, SLOT(setVisible(bool)));
connect(m_Controls.radioButtonUsingT1, SIGNAL(toggled(bool)), this, SLOT(UpdateGUIControls()));
connect(m_Controls.FlipangleSpinBox, SIGNAL(valueChanged(double)), this, SLOT(UpdateGUIControls()));
connect(m_Controls.RelaxivitySpinBox, SIGNAL(valueChanged(double)), this, SLOT(UpdateGUIControls()));
connect(m_Controls.TRSpinBox, SIGNAL(valueChanged(double)), this, SLOT(UpdateGUIControls()));
m_Controls.ComboT1Map->SetDataStorage(this->GetDataStorage());
m_Controls.ComboT1Map->SetPredicate(m_IsNoMaskImagePredicate);
m_Controls.ComboT1Map->setEnabled(false);
connect(m_Controls.radioButtonUsingT1, SIGNAL(toggled(bool)), m_Controls.ComboT1Map, SLOT(setEnabled(bool)));
UpdateGUIControls();
}
bool MRPerfusionView::IsTurboFlashSequenceFlag() const
{
return this->m_Controls.radioButtonTurboFlash->isChecked();
};
void MRPerfusionView::UpdateGUIControls()
{
m_Controls.lineFitName->setPlaceholderText(QString::fromStdString(this->GetDefaultFitName()));
m_Controls.lineFitName->setEnabled(!m_FittingInProgress);
m_Controls.checkBox_Constraints->setEnabled(m_modelConstraints.IsNotNull());
bool isDescBrixFactory = dynamic_cast<mitk::DescriptivePharmacokineticBrixModelFactory*>
(m_selectedModelFactory.GetPointer()) != nullptr;
bool isToftsFactory = dynamic_cast<mitk::StandardToftsModelFactory*>
(m_selectedModelFactory.GetPointer()) != nullptr ||
dynamic_cast<mitk::ExtendedToftsModelFactory*>
(m_selectedModelFactory.GetPointer()) != nullptr;
bool is2CXMFactory = dynamic_cast<mitk::TwoCompartmentExchangeModelFactory*>
(m_selectedModelFactory.GetPointer()) != nullptr ||
dynamic_cast<mitk::NumericTwoCompartmentExchangeModelFactory*>
(m_selectedModelFactory.GetPointer()) != nullptr;
bool isNum2CXMFactory = dynamic_cast<mitk::NumericTwoCompartmentExchangeModelFactory*>
(m_selectedModelFactory.GetPointer()) != nullptr;
m_Controls.groupAIF->setVisible(isToftsFactory || is2CXMFactory);
m_Controls.groupDescBrix->setVisible(isDescBrixFactory);
m_Controls.groupNum2CXM->setVisible(isNum2CXMFactory);
m_Controls.groupConcentration->setVisible(isToftsFactory || is2CXMFactory);
m_Controls.groupBox_FitConfiguration->setVisible(m_selectedModelFactory);
m_Controls.groupBox->setEnabled(!m_FittingInProgress);
m_Controls.comboModel->setEnabled(!m_FittingInProgress);
m_Controls.groupAIF->setEnabled(!m_FittingInProgress);
m_Controls.groupDescBrix->setEnabled(!m_FittingInProgress);
m_Controls.groupNum2CXM->setEnabled(!m_FittingInProgress);
m_Controls.groupConcentration->setEnabled(!m_FittingInProgress);
m_Controls.groupBox_FitConfiguration->setEnabled(!m_FittingInProgress);
m_Controls.radioROIbased->setEnabled(m_selectedMask.IsNotNull());
m_Controls.btnModelling->setEnabled(m_selectedImage.IsNotNull()
&& m_selectedModelFactory.IsNotNull() && !m_FittingInProgress && CheckModelSettings());
}
void MRPerfusionView::OnModellSet(int index)
{
m_selectedModelFactory = nullptr;
if (index > 0)
{
if (static_cast<ModelFactoryStackType::size_type>(index) <= m_FactoryStack.size() )
{
m_selectedModelFactory = m_FactoryStack[index - 1];
}
else
{
MITK_WARN << "Invalid model index. Index outside of the factory stack. Factory stack size: "<< m_FactoryStack.size() << "; invalid index: "<< index;
}
}
if (m_selectedModelFactory)
{
this->m_modelConstraints = dynamic_cast<mitk::SimpleBarrierConstraintChecker*>
(m_selectedModelFactory->CreateDefaultConstraints().GetPointer());
m_Controls.initialValuesManager->setInitialValues(m_selectedModelFactory->GetParameterNames(),
m_selectedModelFactory->GetDefaultInitialParameterization());
if (this->m_modelConstraints.IsNull())
{
this->m_modelConstraints = mitk::SimpleBarrierConstraintChecker::New();
}
m_Controls.constraintManager->setChecker(this->m_modelConstraints,
this->m_selectedModelFactory->GetParameterNames());
}
UpdateGUIControls();
}
std::string MRPerfusionView::GetFitName() const
{
std::string fitName = m_Controls.lineFitName->text().toStdString();
if (fitName.empty())
{
fitName = m_Controls.lineFitName->placeholderText().toStdString();
}
return fitName;
}
std::string MRPerfusionView::GetDefaultFitName() const
{
std::string defaultName = "undefined model";
if (this->m_selectedModelFactory.IsNotNull())
{
defaultName = this->m_selectedModelFactory->GetClassID();
}
if (this->m_Controls.radioPixelBased->isChecked())
{
defaultName += "_pixel";
}
else
{
defaultName += "_roi";
}
return defaultName;
}
void MRPerfusionView::OnModellingButtonClicked()
{
//check if all static parameters set
if (m_selectedModelFactory.IsNotNull() && CheckModelSettings())
{
m_HasGeneratedNewInput = false;
m_HasGeneratedNewInputAIF = false;
mitk::ParameterFitImageGeneratorBase::Pointer generator = nullptr;
mitk::modelFit::ModelFitInfo::Pointer fitSession = nullptr;
bool isDescBrixFactory = dynamic_cast<mitk::DescriptivePharmacokineticBrixModelFactory*>
(m_selectedModelFactory.GetPointer()) != nullptr;
bool is3LinearFactory = dynamic_cast<mitk::ThreeStepLinearModelFactory*>
(m_selectedModelFactory.GetPointer()) != nullptr;
bool isExtToftsFactory = dynamic_cast<mitk::ExtendedToftsModelFactory*>
(m_selectedModelFactory.GetPointer()) != nullptr;
bool isStanToftsFactory = dynamic_cast<mitk::StandardToftsModelFactory*>
(m_selectedModelFactory.GetPointer()) != nullptr;
bool is2CXMFactory = dynamic_cast<mitk::TwoCompartmentExchangeModelFactory*>
(m_selectedModelFactory.GetPointer()) != nullptr;
bool isNum2CXMFactory = dynamic_cast<mitk::NumericTwoCompartmentExchangeModelFactory*>
(m_selectedModelFactory.GetPointer()) != nullptr;
if (isDescBrixFactory)
{
if (this->m_Controls.radioPixelBased->isChecked())
{
GenerateDescriptiveBrixModel_PixelBased(fitSession, generator);
}
else
{
GenerateDescriptiveBrixModel_ROIBased(fitSession, generator);
}
}
else if (is3LinearFactory)
{
if (this->m_Controls.radioPixelBased->isChecked())
{
Generate3StepLinearModelFit_PixelBased(fitSession, generator);
}
else
{
Generate3StepLinearModelFit_ROIBased(fitSession, generator);
}
}
else if (isStanToftsFactory)
{
if (this->m_Controls.radioPixelBased->isChecked())
{
GenerateAIFbasedModelFit_PixelBased<mitk::StandardToftsModelParameterizer>(fitSession, generator);
}
else
{
GenerateAIFbasedModelFit_ROIBased<mitk::StandardToftsModelParameterizer>(fitSession, generator);
}
}
else if (isExtToftsFactory)
{
if (this->m_Controls.radioPixelBased->isChecked())
{
GenerateAIFbasedModelFit_PixelBased<mitk::ExtendedToftsModelParameterizer>(fitSession, generator);
}
else
{
GenerateAIFbasedModelFit_ROIBased<mitk::ExtendedToftsModelParameterizer>(fitSession, generator);
}
}
else if (is2CXMFactory)
{
if (this->m_Controls.radioPixelBased->isChecked())
{
GenerateAIFbasedModelFit_PixelBased<mitk::TwoCompartmentExchangeModelParameterizer>(fitSession, generator);
}
else
{
GenerateAIFbasedModelFit_ROIBased<mitk::TwoCompartmentExchangeModelParameterizer>(fitSession, generator);
}
}
else if (isNum2CXMFactory)
{
if (this->m_Controls.radioPixelBased->isChecked())
{
GenerateAIFbasedModelFit_PixelBased<mitk::NumericTwoCompartmentExchangeModelParameterizer>(fitSession,
generator);
}
else
{
GenerateAIFbasedModelFit_ROIBased<mitk::NumericTwoCompartmentExchangeModelParameterizer>(fitSession,
generator);
}
}
//add other models with else if
if (generator.IsNotNull() && fitSession.IsNotNull())
{
m_FittingInProgress = true;
UpdateGUIControls();
DoFit(fitSession, generator);
}
else
{
QMessageBox box;
box.setText("Fitting error!");
box.setInformativeText("Could not establish fitting job. Error when setting ab generator, model parameterizer or session info.");
box.setStandardButtons(QMessageBox::Ok);
box.setDefaultButton(QMessageBox::Ok);
box.setIcon(QMessageBox::Warning);
box.exec();
}
}
else
{
QMessageBox box;
box.setText("Static parameters for model are not set!");
box.setInformativeText("Some static parameters, that are needed for calculation are not set and equal to zero. Modeling not possible");
box.setStandardButtons(QMessageBox::Ok);
box.setDefaultButton(QMessageBox::Ok);
box.setIcon(QMessageBox::Warning);
box.exec();
}
}
void MRPerfusionView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*source*/,
const QList<mitk::DataNode::Pointer>& selectedNodes)
{
m_selectedMaskNode = nullptr;
m_selectedMask = nullptr;
m_Controls.errorMessageLabel->setText("");
m_Controls.masklabel->setText("No (valid) mask selected.");
m_Controls.timeserieslabel->setText("No (valid) series selected.");
QList<mitk::DataNode::Pointer> nodes = selectedNodes;
if (nodes.size() > 0 && this->m_IsNoMaskImagePredicate->CheckNode(nodes.front()))
{
this->m_selectedNode = nodes.front();
auto selectedImage = dynamic_cast<mitk::Image*>(this->m_selectedNode->GetData());
m_Controls.timeserieslabel->setText((this->m_selectedNode->GetName()).c_str());
if (selectedImage != this->m_selectedImage)
{
if (selectedImage)
{
this->m_Controls.initialValuesManager->setReferenceImageGeometry(selectedImage->GetGeometry());
}
else
{
this->m_Controls.initialValuesManager->setReferenceImageGeometry(nullptr);
}
}
this->m_selectedImage = selectedImage;
nodes.pop_front();
}
else
{
this->m_selectedNode = nullptr;
this->m_selectedImage = nullptr;
this->m_Controls.initialValuesManager->setReferenceImageGeometry(nullptr);
}
if (nodes.size() > 0 && this->m_IsMaskPredicate->CheckNode(nodes.front()))
{
this->m_selectedMaskNode = nodes.front();
this->m_selectedMask = dynamic_cast<mitk::Image*>(this->m_selectedMaskNode->GetData());
if (this->m_selectedMask->GetTimeSteps() > 1)
{
MITK_INFO <<
"Selected mask has multiple timesteps. Only use first timestep to mask model fit. Mask name: " <<
m_selectedMaskNode->GetName();
mitk::ImageTimeSelector::Pointer maskedImageTimeSelector = mitk::ImageTimeSelector::New();
maskedImageTimeSelector->SetInput(this->m_selectedMask);
maskedImageTimeSelector->SetTimeNr(0);
maskedImageTimeSelector->UpdateLargestPossibleRegion();
this->m_selectedMask = maskedImageTimeSelector->GetOutput();
}
m_Controls.masklabel->setText((this->m_selectedMaskNode->GetName()).c_str());
}
if (m_selectedMask.IsNull())
{
this->m_Controls.radioPixelBased->setChecked(true);
}
m_Controls.errorMessageLabel->show();
UpdateGUIControls();
}
bool MRPerfusionView::CheckModelSettings() const
{
bool ok = true;
//check wether any model is set at all. Otherwise exit with false
if (m_selectedModelFactory.IsNotNull())
{
bool isDescBrixFactory = dynamic_cast<mitk::DescriptivePharmacokineticBrixModelFactory*>
(m_selectedModelFactory.GetPointer()) != nullptr;
bool is3LinearFactory = dynamic_cast<mitk::ThreeStepLinearModelFactory*>
(m_selectedModelFactory.GetPointer()) != nullptr;
bool isToftsFactory = dynamic_cast<mitk::StandardToftsModelFactory*>
(m_selectedModelFactory.GetPointer()) != nullptr||
dynamic_cast<mitk::ExtendedToftsModelFactory*>
(m_selectedModelFactory.GetPointer()) != nullptr;
bool is2CXMFactory = dynamic_cast<mitk::TwoCompartmentExchangeModelFactory*>
(m_selectedModelFactory.GetPointer()) != nullptr;
bool isNum2CXMFactory = dynamic_cast<mitk::NumericTwoCompartmentExchangeModelFactory*>
(m_selectedModelFactory.GetPointer()) != nullptr;
if (isDescBrixFactory)
{
//if all static parameters for this model are set, exit with true, Otherwise exit with false
ok = m_Controls.injectiontime->value() > 0;
}
else if (is3LinearFactory)
{
if (this->m_Controls.radioButtonTurboFlash->isChecked())
{
ok = ok && (m_Controls.recoverytime->value() > 0);
ok = ok && (m_Controls.relaxationtime->value() > 0);
ok = ok && (m_Controls.relaxivity->value() > 0);
ok = ok && (m_Controls.AifRecoverytime->value() > 0);
}
else if (this->m_Controls.radioButton_absoluteEnhancement->isChecked()
|| this->m_Controls.radioButton_relativeEnchancement->isChecked())
{
ok = ok && (m_Controls.factorSpinBox->value() > 0);
}
else if (this->m_Controls.radioButtonUsingT1->isChecked())
{
ok = ok && (m_Controls.FlipangleSpinBox->value() > 0);
ok = ok && (m_Controls.TRSpinBox->value() > 0);
ok = ok && (m_Controls.RelaxivitySpinBox->value() > 0);
ok = ok && (m_Controls.ComboT1Map->GetSelectedNode().IsNotNull());
}
else
{
ok = false;
}
}
else if (isToftsFactory || is2CXMFactory || isNum2CXMFactory)
{
if (this->m_Controls.radioAIFImage->isChecked())
{
ok = ok && m_Controls.comboAIFMask->GetSelectedNode().IsNotNull();
if (this->m_Controls.checkDedicatedAIFImage->isChecked())
{
ok = ok && m_Controls.comboAIFImage->GetSelectedNode().IsNotNull();
}
}
else if (this->m_Controls.radioAIFFile->isChecked())
{
ok = ok && (this->AIFinputGrid.size() != 0) && (this->AIFinputFunction.size() != 0);
}
else
{
ok = false;
}
if (this->m_Controls.radioButtonTurboFlash->isChecked())
{
ok = ok && (m_Controls.recoverytime->value() > 0);
ok = ok && (m_Controls.relaxationtime->value() > 0);
ok = ok && (m_Controls.relaxivity->value() > 0);
ok = ok && (m_Controls.AifRecoverytime->value() > 0);
}
else if (this->m_Controls.radioButton_absoluteEnhancement->isChecked()
|| this->m_Controls.radioButton_relativeEnchancement->isChecked())
{
ok = ok && (m_Controls.factorSpinBox->value() > 0);
}
else if (this->m_Controls.radioButtonUsingT1->isChecked())
{
ok = ok && (m_Controls.FlipangleSpinBox->value() > 0);
ok = ok && (m_Controls.TRSpinBox->value() > 0);
ok = ok && (m_Controls.RelaxivitySpinBox->value() > 0);
ok = ok && (m_Controls.ComboT1Map->GetSelectedNode().IsNotNull());
}
else
{
ok = false;
}
if (isNum2CXMFactory)
{
ok = ok && (this->m_Controls.odeStepSize->value() > 0);
}
}
//add other models as else if and check wether all needed static parameters are set
else
{
ok = false;
}
if (this->m_Controls.radioButton_StartParameters->isChecked() && !this->m_Controls.initialValuesManager->hasValidInitialValues())
{
std::string warning = "Warning. Invalid start parameters. At least one parameter as an invalid image setting as source.";
MITK_ERROR << warning;
m_Controls.infoBox->append(QString("<font color='red'><b>") + QString::fromStdString(warning) + QString("</b></font>"));
ok = false;
};
}
else
{
ok = false;
}
return ok;
}
void MRPerfusionView::ConfigureInitialParametersOfParameterizer(mitk::ModelParameterizerBase*
parameterizer) const
{
if (m_Controls.radioButton_StartParameters->isChecked())
{
//use user defined initial parameters
mitk::InitialParameterizationDelegateBase::Pointer paramDelegate = m_Controls.initialValuesManager->getInitialParametrizationDelegate();
parameterizer->SetInitialParameterizationDelegate(paramDelegate);
}
}
void MRPerfusionView::GenerateDescriptiveBrixModel_PixelBased(mitk::modelFit::ModelFitInfo::Pointer&
modelFitInfo, mitk::ParameterFitImageGeneratorBase::Pointer& generator)
{
mitk::PixelBasedParameterFitImageGenerator::Pointer fitGenerator =
mitk::PixelBasedParameterFitImageGenerator::New();
mitk::DescriptivePharmacokineticBrixModelParameterizer::Pointer modelParameterizer =
mitk::DescriptivePharmacokineticBrixModelParameterizer::New();
//Model configuration (static parameters) can be done now
modelParameterizer->SetTau(m_Controls.injectiontime->value());
mitk::ImageTimeSelector::Pointer imageTimeSelector = mitk::ImageTimeSelector::New();
imageTimeSelector->SetInput(this->m_selectedImage);
imageTimeSelector->SetTimeNr(0);
imageTimeSelector->UpdateLargestPossibleRegion();
mitk::DescriptivePharmacokineticBrixModelParameterizer::BaseImageType::Pointer baseImage;
mitk::CastToItkImage(imageTimeSelector->GetOutput(), baseImage);
modelParameterizer->SetBaseImage(baseImage);
this->ConfigureInitialParametersOfParameterizer(modelParameterizer);
//Specify fitting strategy and criterion parameters
mitk::ModelFitFunctorBase::Pointer fitFunctor = CreateDefaultFitFunctor(modelParameterizer);
//Parametrize fit generator
fitGenerator->SetModelParameterizer(modelParameterizer);
std::string roiUID = "";
if (m_selectedMask.IsNotNull())
{
fitGenerator->SetMask(m_selectedMask);
roiUID = mitk::EnsureModelFitUID(this->m_selectedMaskNode);
}
fitGenerator->SetDynamicImage(m_selectedImage);
fitGenerator->SetFitFunctor(fitFunctor);
generator = fitGenerator.GetPointer();
//Create model info
modelFitInfo = mitk::modelFit::CreateFitInfoFromModelParameterizer(modelParameterizer,
m_selectedNode->GetData(), mitk::ModelFitConstants::FIT_TYPE_VALUE_PIXELBASED(), this->GetFitName(), roiUID);
}
void MRPerfusionView::GenerateDescriptiveBrixModel_ROIBased(mitk::modelFit::ModelFitInfo::Pointer&
modelFitInfo, mitk::ParameterFitImageGeneratorBase::Pointer& generator)
{
if (m_selectedMask.IsNull())
{
return;
}
mitk::ROIBasedParameterFitImageGenerator::Pointer fitGenerator =
mitk::ROIBasedParameterFitImageGenerator::New();
mitk::DescriptivePharmacokineticBrixModelValueBasedParameterizer::Pointer modelParameterizer =
mitk::DescriptivePharmacokineticBrixModelValueBasedParameterizer::New();
//Compute ROI signal
mitk::MaskedDynamicImageStatisticsGenerator::Pointer signalGenerator =
mitk::MaskedDynamicImageStatisticsGenerator::New();
signalGenerator->SetMask(m_selectedMask);
signalGenerator->SetDynamicImage(m_selectedImage);
signalGenerator->Generate();
mitk::MaskedDynamicImageStatisticsGenerator::ResultType roiSignal = signalGenerator->GetMean();
//Model configuration (static parameters) can be done now
modelParameterizer->SetTau(m_Controls.injectiontime->value());
modelParameterizer->SetBaseValue(roiSignal[0]);
this->ConfigureInitialParametersOfParameterizer(modelParameterizer);
//Specify fitting strategy and criterion parameters
mitk::ModelFitFunctorBase::Pointer fitFunctor = CreateDefaultFitFunctor(modelParameterizer);
//Parametrize fit generator
fitGenerator->SetModelParameterizer(modelParameterizer);
fitGenerator->SetMask(m_selectedMask);
fitGenerator->SetFitFunctor(fitFunctor);
fitGenerator->SetSignal(roiSignal);
fitGenerator->SetTimeGrid(mitk::ExtractTimeGrid(m_selectedImage));
generator = fitGenerator.GetPointer();
std::string roiUID = mitk::EnsureModelFitUID(this->m_selectedMaskNode);
//Create model info
modelFitInfo = mitk::modelFit::CreateFitInfoFromModelParameterizer(modelParameterizer,
m_selectedNode->GetData(), mitk::ModelFitConstants::FIT_TYPE_VALUE_ROIBASED(), this->GetFitName(), roiUID);
mitk::ScalarListLookupTable::ValueType infoSignal;
for (mitk::MaskedDynamicImageStatisticsGenerator::ResultType::const_iterator pos =
roiSignal.begin(); pos != roiSignal.end(); ++pos)
{
infoSignal.push_back(*pos);
}
modelFitInfo->inputData.SetTableValue("ROI", infoSignal);
}
void MRPerfusionView::Generate3StepLinearModelFit_PixelBased(mitk::modelFit::ModelFitInfo::Pointer&
modelFitInfo, mitk::ParameterFitImageGeneratorBase::Pointer& generator)
{
mitk::PixelBasedParameterFitImageGenerator::Pointer fitGenerator =
mitk::PixelBasedParameterFitImageGenerator::New();
mitk::ThreeStepLinearModelParameterizer::Pointer modelParameterizer =
mitk::ThreeStepLinearModelParameterizer::New();
this->ConfigureInitialParametersOfParameterizer(modelParameterizer);
//Specify fitting strategy and criterion parameters
mitk::ModelFitFunctorBase::Pointer fitFunctor = CreateDefaultFitFunctor(modelParameterizer);
//Parametrize fit generator
fitGenerator->SetModelParameterizer(modelParameterizer);
std::string roiUID = "";
if (m_selectedMask.IsNotNull())
{
fitGenerator->SetMask(m_selectedMask);
roiUID = mitk::EnsureModelFitUID(this->m_selectedMaskNode);
}
fitGenerator->SetDynamicImage(m_selectedImage);
fitGenerator->SetFitFunctor(fitFunctor);
generator = fitGenerator.GetPointer();
//Create model info
modelFitInfo = mitk::modelFit::CreateFitInfoFromModelParameterizer(modelParameterizer,
m_selectedNode->GetData(), mitk::ModelFitConstants::FIT_TYPE_VALUE_PIXELBASED(), this->GetFitName(), roiUID);
}
void MRPerfusionView::Generate3StepLinearModelFit_ROIBased(mitk::modelFit::ModelFitInfo::Pointer&
modelFitInfo, mitk::ParameterFitImageGeneratorBase::Pointer& generator)
{
if (m_selectedMask.IsNull())
{
return;
}
mitk::ROIBasedParameterFitImageGenerator::Pointer fitGenerator =
mitk::ROIBasedParameterFitImageGenerator::New();
mitk::ThreeStepLinearModelParameterizer::Pointer modelParameterizer =
mitk::ThreeStepLinearModelParameterizer::New();
//Compute ROI signal
mitk::MaskedDynamicImageStatisticsGenerator::Pointer signalGenerator =
mitk::MaskedDynamicImageStatisticsGenerator::New();
signalGenerator->SetMask(m_selectedMask);
signalGenerator->SetDynamicImage(m_selectedImage);
signalGenerator->Generate();
mitk::MaskedDynamicImageStatisticsGenerator::ResultType roiSignal = signalGenerator->GetMean();
//Model configuration (static parameters) can be done now
this->ConfigureInitialParametersOfParameterizer(modelParameterizer);
//Specify fitting strategy and criterion parameters
mitk::ModelFitFunctorBase::Pointer fitFunctor = CreateDefaultFitFunctor(modelParameterizer);
//Parametrize fit generator
fitGenerator->SetModelParameterizer(modelParameterizer);
fitGenerator->SetMask(m_selectedMask);
fitGenerator->SetFitFunctor(fitFunctor);
fitGenerator->SetSignal(roiSignal);
fitGenerator->SetTimeGrid(mitk::ExtractTimeGrid(m_selectedImage));
generator = fitGenerator.GetPointer();
std::string roiUID = mitk::EnsureModelFitUID(this->m_selectedMaskNode);
//Create model info
modelFitInfo = mitk::modelFit::CreateFitInfoFromModelParameterizer(modelParameterizer,
m_selectedNode->GetData(), mitk::ModelFitConstants::FIT_TYPE_VALUE_ROIBASED(), this->GetFitName(), roiUID);
mitk::ScalarListLookupTable::ValueType infoSignal;
for (mitk::MaskedDynamicImageStatisticsGenerator::ResultType::const_iterator pos =
roiSignal.begin(); pos != roiSignal.end(); ++pos)
{
infoSignal.push_back(*pos);
}
modelFitInfo->inputData.SetTableValue("ROI", infoSignal);
}
template <typename TParameterizer>
void MRPerfusionView::GenerateAIFbasedModelFit_PixelBased(mitk::modelFit::ModelFitInfo::Pointer&
modelFitInfo, mitk::ParameterFitImageGeneratorBase::Pointer& generator)
{
mitk::PixelBasedParameterFitImageGenerator::Pointer fitGenerator =
mitk::PixelBasedParameterFitImageGenerator::New();
typename TParameterizer::Pointer modelParameterizer =
TParameterizer::New();
PrepareConcentrationImage();
mitk::AIFBasedModelBase::AterialInputFunctionType aif;
mitk::AIFBasedModelBase::AterialInputFunctionType aifTimeGrid;
GetAIF(aif, aifTimeGrid);
modelParameterizer->SetAIF(aif);
modelParameterizer->SetAIFTimeGrid(aifTimeGrid);
this->ConfigureInitialParametersOfParameterizer(modelParameterizer);
mitk::NumericTwoCompartmentExchangeModelParameterizer* numTCXParametrizer =
dynamic_cast<mitk::NumericTwoCompartmentExchangeModelParameterizer*>
(modelParameterizer.GetPointer());
if (numTCXParametrizer)
{
numTCXParametrizer->SetODEINTStepSize(this->m_Controls.odeStepSize->value());
}
//Specify fitting strategy and criterion parameters
mitk::ModelFitFunctorBase::Pointer fitFunctor = CreateDefaultFitFunctor(modelParameterizer);
//Parametrize fit generator
fitGenerator->SetModelParameterizer(modelParameterizer);
std::string roiUID = "";
if (m_selectedMask.IsNotNull())
{
fitGenerator->SetMask(m_selectedMask);
roiUID = mitk::EnsureModelFitUID(this->m_selectedMaskNode);
}
fitGenerator->SetDynamicImage(this->m_inputImage);
fitGenerator->SetFitFunctor(fitFunctor);
generator = fitGenerator.GetPointer();
//Create model info
modelFitInfo = mitk::modelFit::CreateFitInfoFromModelParameterizer(modelParameterizer,
this->m_inputImage, mitk::ModelFitConstants::FIT_TYPE_VALUE_PIXELBASED(), this->GetFitName(),
roiUID);
mitk::ScalarListLookupTable::ValueType infoSignal;
for (mitk::AIFBasedModelBase::AterialInputFunctionType::const_iterator pos =
aif.begin(); pos != aif.end(); ++pos)
{
infoSignal.push_back(*pos);
}
modelFitInfo->inputData.SetTableValue("AIF", infoSignal);
}
template <typename TParameterizer>
void MRPerfusionView::GenerateAIFbasedModelFit_ROIBased(
mitk::modelFit::ModelFitInfo::Pointer& modelFitInfo,
mitk::ParameterFitImageGeneratorBase::Pointer& generator)
{
if (m_selectedMask.IsNull())
{
return;
}
mitk::ROIBasedParameterFitImageGenerator::Pointer fitGenerator =
mitk::ROIBasedParameterFitImageGenerator::New();
typename TParameterizer::Pointer modelParameterizer =
TParameterizer::New();
PrepareConcentrationImage();
mitk::AIFBasedModelBase::AterialInputFunctionType aif;
mitk::AIFBasedModelBase::AterialInputFunctionType aifTimeGrid;
GetAIF(aif, aifTimeGrid);
modelParameterizer->SetAIF(aif);
modelParameterizer->SetAIFTimeGrid(aifTimeGrid);
this->ConfigureInitialParametersOfParameterizer(modelParameterizer);
mitk::NumericTwoCompartmentExchangeModelParameterizer* numTCXParametrizer =
dynamic_cast<mitk::NumericTwoCompartmentExchangeModelParameterizer*>
(modelParameterizer.GetPointer());
if (numTCXParametrizer)
{
numTCXParametrizer->SetODEINTStepSize(this->m_Controls.odeStepSize->value());
}
//Compute ROI signal
mitk::MaskedDynamicImageStatisticsGenerator::Pointer signalGenerator =
mitk::MaskedDynamicImageStatisticsGenerator::New();
signalGenerator->SetMask(m_selectedMask);
signalGenerator->SetDynamicImage(this->m_inputImage);
signalGenerator->Generate();
mitk::MaskedDynamicImageStatisticsGenerator::ResultType roiSignal = signalGenerator->GetMean();
//Specify fitting strategy and criterion parameters
mitk::ModelFitFunctorBase::Pointer fitFunctor = CreateDefaultFitFunctor(modelParameterizer);
//Parametrize fit generator
fitGenerator->SetModelParameterizer(modelParameterizer);
fitGenerator->SetMask(m_selectedMask);
fitGenerator->SetFitFunctor(fitFunctor);
fitGenerator->SetSignal(roiSignal);
fitGenerator->SetTimeGrid(mitk::ExtractTimeGrid(this->m_inputImage));
generator = fitGenerator.GetPointer();
std::string roiUID = mitk::EnsureModelFitUID(this->m_selectedMaskNode);
//Create model info
modelFitInfo = mitk::modelFit::CreateFitInfoFromModelParameterizer(modelParameterizer,
this->m_inputImage, mitk::ModelFitConstants::FIT_TYPE_VALUE_ROIBASED(), this->GetFitName(),
roiUID);
mitk::ScalarListLookupTable::ValueType infoSignal;
for (mitk::MaskedDynamicImageStatisticsGenerator::ResultType::const_iterator pos =
roiSignal.begin(); pos != roiSignal.end(); ++pos)
{
infoSignal.push_back(*pos);
}
modelFitInfo->inputData.SetTableValue("ROI", infoSignal);
infoSignal.clear();
for (mitk::AIFBasedModelBase::AterialInputFunctionType::const_iterator pos =
aif.begin(); pos != aif.end(); ++pos)
{
infoSignal.push_back(*pos);
}
modelFitInfo->inputData.SetTableValue("AIF", infoSignal);
}
void MRPerfusionView::DoFit(const mitk::modelFit::ModelFitInfo* fitSession,
mitk::ParameterFitImageGeneratorBase* generator)
{
std::stringstream message;
message << "<font color='green'>" << "Fitting Data Set . . ." << "</font>";
m_Controls.errorMessageLabel->setText(message.str().c_str());
m_Controls.errorMessageLabel->show();
/////////////////////////
//create job and put it into the thread pool
mitk::modelFit::ModelFitResultNodeVectorType additionalNodes;
if (m_HasGeneratedNewInput)
{
additionalNodes.push_back(m_inputNode);
}
if (m_HasGeneratedNewInputAIF)
{
additionalNodes.push_back(m_inputAIFNode);
}
ParameterFitBackgroundJob* pJob = new ParameterFitBackgroundJob(generator, fitSession,
this->m_selectedNode, additionalNodes);
pJob->setAutoDelete(true);
connect(pJob, SIGNAL(Error(QString)), this, SLOT(OnJobError(QString)));
connect(pJob, SIGNAL(Finished()), this, SLOT(OnJobFinished()));
connect(pJob, SIGNAL(ResultsAreAvailable(mitk::modelFit::ModelFitResultNodeVectorType,
const ParameterFitBackgroundJob*)), this,
SLOT(OnJobResultsAreAvailable(mitk::modelFit::ModelFitResultNodeVectorType,
const ParameterFitBackgroundJob*)), Qt::BlockingQueuedConnection);
connect(pJob, SIGNAL(JobProgress(double)), this, SLOT(OnJobProgress(double)));
connect(pJob, SIGNAL(JobStatusChanged(QString)), this, SLOT(OnJobStatusChanged(QString)));
QThreadPool* threadPool = QThreadPool::globalInstance();
threadPool->start(pJob);
}
MRPerfusionView::MRPerfusionView() : m_FittingInProgress(false), m_HasGeneratedNewInput(false), m_HasGeneratedNewInputAIF(false)
{
m_selectedImage = nullptr;
m_selectedMask = nullptr;
mitk::ModelFactoryBase::Pointer factory =
mitk::DescriptivePharmacokineticBrixModelFactory::New().GetPointer();
m_FactoryStack.push_back(factory);
factory = mitk::ThreeStepLinearModelFactory::New().GetPointer();
m_FactoryStack.push_back(factory);
factory = mitk::StandardToftsModelFactory::New().GetPointer();
m_FactoryStack.push_back(factory);
factory = mitk::ExtendedToftsModelFactory::New().GetPointer();
m_FactoryStack.push_back(factory);
factory = mitk::TwoCompartmentExchangeModelFactory::New().GetPointer();
m_FactoryStack.push_back(factory);
factory = mitk::NumericTwoCompartmentExchangeModelFactory::New().GetPointer();
m_FactoryStack.push_back(factory);
mitk::NodePredicateDataType::Pointer isLabelSet = mitk::NodePredicateDataType::New("LabelSetImage");
mitk::NodePredicateDataType::Pointer isImage = mitk::NodePredicateDataType::New("Image");
mitk::NodePredicateProperty::Pointer isBinary = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
mitk::NodePredicateAnd::Pointer isLegacyMask = mitk::NodePredicateAnd::New(isImage, isBinary);
mitk::NodePredicateOr::Pointer isMask = mitk::NodePredicateOr::New(isLegacyMask, isLabelSet);
mitk::NodePredicateAnd::Pointer isNoMask = mitk::NodePredicateAnd::New(isImage, mitk::NodePredicateNot::New(isMask));
this->m_IsMaskPredicate = mitk::NodePredicateAnd::New(isMask, mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object"))).GetPointer();
this->m_IsNoMaskImagePredicate = mitk::NodePredicateAnd::New(isNoMask, mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object"))).GetPointer();
}
void MRPerfusionView::OnJobFinished()
{
this->m_Controls.infoBox->append(QString("Fitting finished."));
this->m_FittingInProgress = false;
this->UpdateGUIControls();
};
void MRPerfusionView::OnJobError(QString err)
{
MITK_ERROR << err.toStdString().c_str();
m_Controls.infoBox->append(QString("<font color='red'><b>") + err + QString("</b></font>"));
};
void MRPerfusionView::OnJobResultsAreAvailable(mitk::modelFit::ModelFitResultNodeVectorType results,
const ParameterFitBackgroundJob* pJob)
{
//Store the resulting parameter fit image via convenience helper function in data storage
//(handles the correct generation of the nodes and their properties)
mitk::modelFit::StoreResultsInDataStorage(this->GetDataStorage(), results, pJob->GetParentNode());
//this stores the concentration image and AIF concentration image, if generated for this fit in the storage.
//if not generated for this fit, relevant nodes are empty.
mitk::modelFit::StoreResultsInDataStorage(this->GetDataStorage(), pJob->GetAdditionalRelevantNodes(), pJob->GetParentNode());
};
void MRPerfusionView::OnJobProgress(double progress)
{
QString report = QString("Progress. ") + QString::number(progress);
this->m_Controls.infoBox->append(report);
};
void MRPerfusionView::OnJobStatusChanged(QString info)
{
this->m_Controls.infoBox->append(info);
}
void MRPerfusionView::InitModelComboBox() const
{
this->m_Controls.comboModel->clear();
this->m_Controls.comboModel->addItem(tr("No model selected"));
for (ModelFactoryStackType::const_iterator pos = m_FactoryStack.begin();
pos != m_FactoryStack.end(); ++pos)
{
this->m_Controls.comboModel->addItem(QString::fromStdString((*pos)->GetClassID()));
}
this->m_Controls.comboModel->setCurrentIndex(0);
};
mitk::DataNode::Pointer MRPerfusionView::GenerateConcentrationNode(mitk::Image* image,
const std::string& nodeName) const
{
if (!image)
{
mitkThrow() << "Cannot generate concentration node. Passed image is null. parameter name: ";
}
mitk::DataNode::Pointer result = mitk::DataNode::New();
result->SetData(image);
result->SetName(nodeName);
result->SetVisibility(true);
mitk::EnsureModelFitUID(result);
return result;
};
mitk::Image::Pointer MRPerfusionView::ConvertConcentrationImage(bool AIFMode)
{
//Compute Concentration image
mitk::ConcentrationCurveGenerator::Pointer concentrationGen =
mitk::ConcentrationCurveGenerator::New();
if (m_Controls.checkDedicatedAIFImage->isChecked() && AIFMode)
{
concentrationGen->SetDynamicImage(this->m_selectedAIFImage);
}
else
{
concentrationGen->SetDynamicImage(this->m_selectedImage);
}
concentrationGen->SetisTurboFlashSequence(IsTurboFlashSequenceFlag());
concentrationGen->SetAbsoluteSignalEnhancement(m_Controls.radioButton_absoluteEnhancement->isChecked());
concentrationGen->SetRelativeSignalEnhancement(m_Controls.radioButton_relativeEnchancement->isChecked());
concentrationGen->SetUsingT1Map(m_Controls.radioButtonUsingT1->isChecked());
if (IsTurboFlashSequenceFlag())
{
if (AIFMode)
{
concentrationGen->SetRecoveryTime(m_Controls.AifRecoverytime->value());
}
else
{
concentrationGen->SetRecoveryTime(m_Controls.recoverytime->value());
}
concentrationGen->SetRelaxationTime(m_Controls.relaxationtime->value());
concentrationGen->SetRelaxivity(m_Controls.relaxivity->value());
}
else if (this->m_Controls.radioButtonUsingT1->isChecked())
{
concentrationGen->SetRecoveryTime(m_Controls.TRSpinBox->value());
concentrationGen->SetRelaxivity(m_Controls.RelaxivitySpinBox->value());
concentrationGen->SetT10Image(dynamic_cast<mitk::Image*>(m_Controls.ComboT1Map->GetSelectedNode()->GetData()));
//Convert Flipangle from degree to radiant
double alpha = m_Controls.FlipangleSpinBox->value()/360*2* boost::math::constants::pi<double>();
concentrationGen->SetFlipAngle(alpha);
}
else
{
concentrationGen->SetFactor(m_Controls.factorSpinBox->value());
concentrationGen->SetBaselineStartTimePoint(m_Controls.spinBox_baselineStartTimePoint->value());
- concentrationGen->SetBaselineStartTimePoint(m_Controls.spinBox_baselineEndTimePoint->value());
+ concentrationGen->SetBaselineEndTimePoint(m_Controls.spinBox_baselineEndTimePoint->value());
}
mitk::Image::Pointer concentrationImage = concentrationGen->GetConvertedImage();
return concentrationImage;
}
void MRPerfusionView::GetAIF(mitk::AIFBasedModelBase::AterialInputFunctionType& aif,
mitk::AIFBasedModelBase::AterialInputFunctionType& aifTimeGrid)
{
if (this->m_Controls.radioAIFFile->isChecked())
{
aif.clear();
aifTimeGrid.clear();
aif.SetSize(AIFinputFunction.size());
aifTimeGrid.SetSize(AIFinputGrid.size());
aif.fill(0.0);
aifTimeGrid.fill(0.0);
itk::Array<double>::iterator aifPos = aif.begin();
for (std::vector<double>::const_iterator pos = AIFinputFunction.begin();
pos != AIFinputFunction.end(); ++pos, ++aifPos)
{
*aifPos = *pos;
}
itk::Array<double>::iterator gridPos = aifTimeGrid.begin();
for (std::vector<double>::const_iterator pos = AIFinputGrid.begin(); pos != AIFinputGrid.end();
++pos, ++gridPos)
{
*gridPos = *pos;
}
}
else if (this->m_Controls.radioAIFImage->isChecked())
{
aif.clear();
aifTimeGrid.clear();
mitk::AterialInputFunctionGenerator::Pointer aifGenerator =
mitk::AterialInputFunctionGenerator::New();
//Hematocrit level
aifGenerator->SetHCL(this->m_Controls.HCLSpinBox->value());
//mask settings
this->m_selectedAIFMaskNode = m_Controls.comboAIFMask->GetSelectedNode();
this->m_selectedAIFMask = dynamic_cast<mitk::Image*>(this->m_selectedAIFMaskNode->GetData());
if (this->m_selectedAIFMask->GetTimeSteps() > 1)
{
MITK_INFO <<
"Selected AIF mask has multiple timesteps. Only use first timestep to mask model fit. AIF Mask name: "
<<
m_selectedAIFMaskNode->GetName() ;
mitk::ImageTimeSelector::Pointer maskedImageTimeSelector = mitk::ImageTimeSelector::New();
maskedImageTimeSelector->SetInput(this->m_selectedAIFMask);
maskedImageTimeSelector->SetTimeNr(0);
maskedImageTimeSelector->UpdateLargestPossibleRegion();
this->m_selectedAIFMask = maskedImageTimeSelector->GetOutput();
}
if (this->m_selectedAIFMask.IsNotNull())
{
aifGenerator->SetMask(this->m_selectedAIFMask);
}
//image settings
if (this->m_Controls.checkDedicatedAIFImage->isChecked())
{
this->m_selectedAIFImageNode = m_Controls.comboAIFImage->GetSelectedNode();
this->m_selectedAIFImage = dynamic_cast<mitk::Image*>(this->m_selectedAIFImageNode->GetData());
}
else
{
this->m_selectedAIFImageNode = m_selectedNode;
this->m_selectedAIFImage = m_selectedImage;
}
this->PrepareAIFConcentrationImage();
aifGenerator->SetDynamicImage(this->m_inputAIFImage);
aif = aifGenerator->GetAterialInputFunction();
aifTimeGrid = aifGenerator->GetAterialInputFunctionTimeGrid();
}
else
{
mitkThrow() << "Cannot generate AIF. View is in a invalide state. No AIF mode selected.";
}
}
void MRPerfusionView::LoadAIFfromFile()
{
QFileDialog dialog;
dialog.setNameFilter(tr("Images (*.csv"));
QString fileName = dialog.getOpenFileName();
m_Controls.aifFilePath->setText(fileName);
std::string m_aifFilePath = fileName.toStdString();
//Read Input
typedef boost::tokenizer< boost::escaped_list_separator<char> > Tokenizer;
/////////////////////////////////////////////////////////////////////////////////////////////////
//AIF Data
std::ifstream in1(m_aifFilePath.c_str());
if (!in1.is_open())
{
m_Controls.errorMessageLabel->setText("Could not open AIF File!");
}
std::vector< std::string > vec1;
std::string line1;
while (getline(in1, line1))
{
Tokenizer tok(line1);
vec1.assign(tok.begin(), tok.end());
this->AIFinputGrid.push_back(convertToDouble(vec1[0]));
this->AIFinputFunction.push_back(convertToDouble(vec1[1]));
}
}
void MRPerfusionView::PrepareConcentrationImage()
{
mitk::Image::Pointer concentrationImage = this->m_selectedImage;
mitk::DataNode::Pointer concentrationNode = this->m_selectedNode;
m_HasGeneratedNewInput = false;
if (!this->m_Controls.radioButtonNoConversion->isChecked())
{
concentrationImage = this->ConvertConcentrationImage(false);
concentrationNode = GenerateConcentrationNode(concentrationImage, "Concentration");
m_HasGeneratedNewInput = true;
}
m_inputImage = concentrationImage;
m_inputNode = concentrationNode;
mitk::EnsureModelFitUID(concentrationNode);
}
void MRPerfusionView::PrepareAIFConcentrationImage()
{
mitk::Image::Pointer concentrationImage = this->m_selectedImage;
mitk::DataNode::Pointer concentrationNode = this->m_selectedNode;
m_HasGeneratedNewInputAIF = false;
if (this->m_Controls.checkDedicatedAIFImage->isChecked())
{
concentrationImage = this->m_selectedAIFImage;
concentrationNode = this->m_selectedAIFImageNode;
}
if (!this->m_Controls.radioButtonNoConversion->isChecked())
{
if (!IsTurboFlashSequenceFlag() && !this->m_Controls.checkDedicatedAIFImage->isChecked())
{
if (m_inputImage.IsNull())
{
mitkThrow() <<
"Cannot get AIF concentration image. Invalid view state. Input image is not defined yet, but should be.";
}
//we can directly use the concentration input image/node (generated by GetConcentrationImage) also for the AIF
concentrationImage = this->m_inputImage;
concentrationNode = this->m_inputNode;
}
else
{
concentrationImage = this->ConvertConcentrationImage(true);
concentrationNode = GenerateConcentrationNode(concentrationImage, "AIF Concentration");
m_HasGeneratedNewInputAIF = true;
}
}
m_inputAIFImage = concentrationImage;
m_inputAIFNode = concentrationNode;
mitk::EnsureModelFitUID(concentrationNode);
}
mitk::ModelFitFunctorBase::Pointer MRPerfusionView::CreateDefaultFitFunctor(
const mitk::ModelParameterizerBase* parameterizer) const
{
mitk::LevenbergMarquardtModelFitFunctor::Pointer fitFunctor =
mitk::LevenbergMarquardtModelFitFunctor::New();
mitk::NormalizedSumOfSquaredDifferencesFitCostFunction::Pointer chi2 =
mitk::NormalizedSumOfSquaredDifferencesFitCostFunction::New();
fitFunctor->RegisterEvaluationParameter("Chi^2", chi2);
if (m_Controls.checkBox_Constraints->isChecked())
{
fitFunctor->SetConstraintChecker(m_modelConstraints);
}
mitk::ModelBase::Pointer refModel = parameterizer->GenerateParameterizedModel();
::itk::LevenbergMarquardtOptimizer::ScalesType scales;
scales.SetSize(refModel->GetNumberOfParameters());
scales.Fill(1.0);
fitFunctor->SetScales(scales);
fitFunctor->SetDebugParameterMaps(m_Controls.checkDebug->isChecked());
return fitFunctor.GetPointer();
}