diff --git a/Modules/DiffusionImaging/DiffusionCore/Testing/mitkImageReconstructionTest.cpp b/Modules/DiffusionImaging/DiffusionCore/Testing/mitkImageReconstructionTest.cpp
index 8010609d10..792a365674 100755
--- a/Modules/DiffusionImaging/DiffusionCore/Testing/mitkImageReconstructionTest.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/Testing/mitkImageReconstructionTest.cpp
@@ -1,156 +1,156 @@
 /*===================================================================
 
 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 <mitkImageCast.h>
 #include <mitkTensorImage.h>
 #include <mitkQBallImage.h>
 #include <mitkDiffusionImage.h>
 #include <mitkIOUtil.h>
 #include <mitkBaseDataIOFactory.h>
 #include <mitkDiffusionCoreObjectFactory.h>
 #include <itkDiffusionTensor3D.h>
 #include <mitkTestingMacros.h>
 #include <itkDiffusionTensor3DReconstructionImageFilter.h>
 #include <itkDiffusionTensor3D.h>
 #include <itkDiffusionQballReconstructionImageFilter.h>
 #include <itkAnalyticalDiffusionQballReconstructionImageFilter.h>
 #include <mitkNrrdQBallImageWriter.h>
 
 using namespace std;
 
 int mitkImageReconstructionTest(int argc, char* argv[])
 {
     MITK_TEST_BEGIN("mitkImageReconstructionTest");
 
     MITK_TEST_CONDITION_REQUIRED(argc>1,"check for input data")
 
     try
     {
         RegisterDiffusionCoreObjectFactory();
 
         mitk::DiffusionImage<short>::Pointer dwi = dynamic_cast<mitk::DiffusionImage<short>*>(mitk::IOUtil::LoadDataNode(argv[1])->GetData());
 
         {
             MITK_INFO << "Tensor reconstruction " << argv[2];
             mitk::TensorImage::Pointer tensorImage = dynamic_cast<mitk::TensorImage*>(mitk::IOUtil::LoadDataNode(argv[2])->GetData());
             typedef itk::DiffusionTensor3DReconstructionImageFilter< short, short, float > TensorReconstructionImageFilterType;
             TensorReconstructionImageFilterType::Pointer filter = TensorReconstructionImageFilterType::New();
             filter->SetGradientImage( dwi->GetDirections(), dwi->GetVectorImage() );
             filter->SetBValue(dwi->GetB_Value());
             filter->Update();
             mitk::TensorImage::Pointer testImage = mitk::TensorImage::New();
             testImage->InitializeByItk( filter->GetOutput() );
             testImage->SetVolume( filter->GetOutput()->GetBufferPointer() );
             MITK_TEST_CONDITION_REQUIRED(mitk::Equal(testImage, tensorImage, 0.0001, true), "tensor reconstruction test.");
         }
 
         {
             MITK_INFO << "Numerical Q-ball reconstruction " << argv[3];
             mitk::QBallImage::Pointer qballImage = dynamic_cast<mitk::QBallImage*>(mitk::IOUtil::LoadDataNode(argv[3])->GetData());
             typedef itk::DiffusionQballReconstructionImageFilter<short, short, float, QBALL_ODFSIZE> QballReconstructionImageFilterType;
             QballReconstructionImageFilterType::Pointer filter = QballReconstructionImageFilterType::New();
             filter->SetGradientImage( dwi->GetDirections(), dwi->GetVectorImage() );
             filter->SetBValue(dwi->GetB_Value());
             filter->SetNormalizationMethod(QballReconstructionImageFilterType::QBR_STANDARD);
             filter->Update();
             mitk::QBallImage::Pointer testImage = mitk::QBallImage::New();
             testImage->InitializeByItk( filter->GetOutput() );
             testImage->SetVolume( filter->GetOutput()->GetBufferPointer() );
             MITK_TEST_CONDITION_REQUIRED(mitk::Equal(testImage, qballImage, 0.0001, true), "Numerical Q-ball reconstruction test.");
         }
 
         {
             MITK_INFO << "Standard Q-ball reconstruction " << argv[4];
             mitk::QBallImage::Pointer qballImage = dynamic_cast<mitk::QBallImage*>(mitk::IOUtil::LoadDataNode(argv[4])->GetData());
             typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,4,QBALL_ODFSIZE> FilterType;
-            typename FilterType::Pointer filter = FilterType::New();
+            FilterType::Pointer filter = FilterType::New();
             filter->SetGradientImage( dwi->GetDirections(), dwi->GetVectorImage() );
             filter->SetBValue(dwi->GetB_Value());
             filter->SetLambda(0.006);
             filter->SetNormalizationMethod(FilterType::QBAR_STANDARD);
             filter->Update();
             mitk::QBallImage::Pointer testImage = mitk::QBallImage::New();
             testImage->InitializeByItk( filter->GetOutput() );
             testImage->SetVolume( filter->GetOutput()->GetBufferPointer() );
             MITK_TEST_CONDITION_REQUIRED(mitk::Equal(testImage, qballImage, 0.0001, true), "Standard Q-ball reconstruction test.");
         }
 
         {
             MITK_INFO << "CSA Q-ball reconstruction " << argv[5];
             mitk::QBallImage::Pointer qballImage = dynamic_cast<mitk::QBallImage*>(mitk::IOUtil::LoadDataNode(argv[5])->GetData());
             typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,4,QBALL_ODFSIZE> FilterType;
-            typename FilterType::Pointer filter = FilterType::New();
+            FilterType::Pointer filter = FilterType::New();
             filter->SetGradientImage( dwi->GetDirections(), dwi->GetVectorImage() );
             filter->SetBValue(dwi->GetB_Value());
             filter->SetLambda(0.006);
             filter->SetNormalizationMethod(FilterType::QBAR_SOLID_ANGLE);
             filter->Update();
             mitk::QBallImage::Pointer testImage = mitk::QBallImage::New();
             testImage->InitializeByItk( filter->GetOutput() );
             testImage->SetVolume( filter->GetOutput()->GetBufferPointer() );
             MITK_TEST_CONDITION_REQUIRED(mitk::Equal(testImage, qballImage, 0.0001, true), "CSA Q-ball reconstruction test.");
         }
 
         {
             MITK_INFO << "ADC profile reconstruction " << argv[6];
             mitk::QBallImage::Pointer qballImage = dynamic_cast<mitk::QBallImage*>(mitk::IOUtil::LoadDataNode(argv[6])->GetData());
             typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,4,QBALL_ODFSIZE> FilterType;
-            typename FilterType::Pointer filter = FilterType::New();
+            FilterType::Pointer filter = FilterType::New();
             filter->SetGradientImage( dwi->GetDirections(), dwi->GetVectorImage() );
             filter->SetBValue(dwi->GetB_Value());
             filter->SetLambda(0.006);
             filter->SetNormalizationMethod(FilterType::QBAR_ADC_ONLY);
             filter->Update();
             mitk::QBallImage::Pointer testImage = mitk::QBallImage::New();
             testImage->InitializeByItk( filter->GetOutput() );
             testImage->SetVolume( filter->GetOutput()->GetBufferPointer() );
             MITK_TEST_CONDITION_REQUIRED(mitk::Equal(testImage, qballImage, 0.0001, true), "ADC profile reconstruction test.");
         }
 
         {
             MITK_INFO << "Raw signal modeling " << argv[7];
             mitk::QBallImage::Pointer qballImage = dynamic_cast<mitk::QBallImage*>(mitk::IOUtil::LoadDataNode(argv[7])->GetData());
             typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,4,QBALL_ODFSIZE> FilterType;
-            typename FilterType::Pointer filter = FilterType::New();
+            FilterType::Pointer filter = FilterType::New();
             filter->SetGradientImage( dwi->GetDirections(), dwi->GetVectorImage() );
             filter->SetBValue(dwi->GetB_Value());
             filter->SetLambda(0.006);
             filter->SetNormalizationMethod(FilterType::QBAR_RAW_SIGNAL);
             filter->Update();
             mitk::QBallImage::Pointer testImage = mitk::QBallImage::New();
             testImage->InitializeByItk( filter->GetOutput() );
             testImage->SetVolume( filter->GetOutput()->GetBufferPointer() );
             MITK_TEST_CONDITION_REQUIRED(mitk::Equal(testImage, qballImage, 0.0001, true), "Raw signal modeling test.");
         }
     }
     catch (itk::ExceptionObject e)
     {
         MITK_INFO << e;
         return EXIT_FAILURE;
     }
     catch (std::exception e)
     {
         MITK_INFO << e.what();
         return EXIT_FAILURE;
     }
     catch (...)
     {
         MITK_INFO << "ERROR!?!";
         return EXIT_FAILURE;
     }
 
     MITK_TEST_END();
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/Testing/mitkPeakExtractionTest.cpp b/Modules/DiffusionImaging/FiberTracking/Testing/mitkPeakExtractionTest.cpp
index b17b6f9864..a2e3fb786b 100755
--- a/Modules/DiffusionImaging/FiberTracking/Testing/mitkPeakExtractionTest.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Testing/mitkPeakExtractionTest.cpp
@@ -1,114 +1,114 @@
 /*===================================================================
 
 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 <itkImageFileWriter.h>
 #include <itkResampleImageFilter.h>
 #include <itkFiniteDiffOdfMaximaExtractionFilter.h>
 
 #include <mitkBaseDataIOFactory.h>
 #include <mitkDiffusionImage.h>
 #include <mitkQBallImage.h>
 #include <mitkImageCast.h>
 #include <mitkImageToItk.h>
 #include <mitkTensorImage.h>
 
 #include <mitkDiffusionCoreObjectFactory.h>
 #include <mitkFiberTrackingObjectFactory.h>
 #include <mitkCoreObjectFactory.h>
 #include <mitkFiberBundleXWriter.h>
 #include <itkShCoefficientImageImporter.h>
 #include <mitkNrrdQBallImageWriter.h>
 #include <itkFlipImageFilter.h>
 #include <boost/lexical_cast.hpp>
 #include <boost/algorithm/string.hpp>
 #include <mitkTestingMacros.h>
 #include <mitkIOUtil.h>
 
 using namespace std;
 
 int mitkPeakExtractionTest(int argc, char* argv[])
 {
     MITK_TEST_BEGIN("mitkStreamlineTrackingTest");
 
     MITK_TEST_CONDITION_REQUIRED(argc>3,"check for input data")
 
     string shCoeffFileName = argv[1];
     string maskFileName = argv[2];
     string referenceFileName = argv[3];
 
     MITK_INFO << "SH-coefficient file: " << shCoeffFileName;
     MITK_INFO << "Mask file: " << maskFileName;
     MITK_INFO << "Reference fiber file: " << referenceFileName;
 
     try
     {
         mitk::CoreObjectFactory::GetInstance();
 
         RegisterDiffusionCoreObjectFactory();
         RegisterFiberTrackingObjectFactory();
 
         mitk::Image::Pointer image = mitk::IOUtil::LoadImage(shCoeffFileName);
         mitk::Image::Pointer mitkMaskImage = mitk::IOUtil::LoadImage(maskFileName);
 
         typedef itk::Image<unsigned char, 3>  ItkUcharImgType;
         typedef itk::FiniteDiffOdfMaximaExtractionFilter< float, 4, 20242 > MaximaExtractionFilterType;
-        typename MaximaExtractionFilterType::Pointer filter = MaximaExtractionFilterType::New();
+        MaximaExtractionFilterType::Pointer filter = MaximaExtractionFilterType::New();
 
         MITK_INFO << "Casting mask image ...";
         ItkUcharImgType::Pointer itkMask = ItkUcharImgType::New();
         mitk::CastToItkImage<ItkUcharImgType>(mitkMaskImage, itkMask);
         filter->SetMaskImage(itkMask);
 
         MITK_INFO << "Casting SH image ...";
-        typedef mitk::ImageToItk< typename MaximaExtractionFilterType::CoefficientImageType > CasterType;
-        typename CasterType::Pointer caster = CasterType::New();
+        typedef mitk::ImageToItk< MaximaExtractionFilterType::CoefficientImageType > CasterType;
+        CasterType::Pointer caster = CasterType::New();
         caster->SetInput(image);
         caster->Update();
         filter->SetInput(caster->GetOutput());
         filter->SetMaxNumPeaks(2);
         filter->SetPeakThreshold(0.4);
         filter->SetAbsolutePeakThreshold(0.01);
         filter->SetAngularThreshold(25);
         filter->SetNormalizationMethod(MaximaExtractionFilterType::MAX_VEC_NORM);
         MITK_INFO << "Starting extraction ...";
         filter->Update();
         mitk::FiberBundleX::Pointer fib1 = filter->GetOutputFiberBundle();
 
         MITK_INFO << "Loading reference ...";
         const std::string s1="", s2="";
         std::vector<mitk::BaseData::Pointer> infile = mitk::BaseDataIO::LoadBaseDataFromFile( referenceFileName, s1, s2, false );
         mitk::FiberBundleX::Pointer fib2 = dynamic_cast<mitk::FiberBundleX*>(infile.at(0).GetPointer());
 
         MITK_TEST_CONDITION_REQUIRED(fib1->Equals(fib2), "Check if tractograms are equal.");
     }
     catch (itk::ExceptionObject e)
     {
         MITK_INFO << e;
         return EXIT_FAILURE;
     }
     catch (std::exception e)
     {
         MITK_INFO << e.what();
         return EXIT_FAILURE;
     }
     catch (...)
     {
         MITK_INFO << "ERROR!?!";
         return EXIT_FAILURE;
     }
 
     MITK_TEST_END();
 }