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;
 
 }