diff --git a/Modules/DiffusionImaging/MiniApps/CopyGeometry.cpp b/Modules/DiffusionImaging/MiniApps/CopyGeometry.cpp
index 7fb1ae16ac..bc61b4f91c 100755
--- a/Modules/DiffusionImaging/MiniApps/CopyGeometry.cpp
+++ b/Modules/DiffusionImaging/MiniApps/CopyGeometry.cpp
@@ -1,81 +1,78 @@
 /*===================================================================
 
 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 <mitkImage.h>
 #include <mitkBaseDataIOFactory.h>
 #include <mitkIOUtil.h>
 #include "mitkCommandLineParser.h"
 
 using namespace mitk;
 
 
 int main(int argc, char* argv[])
 {
     mitkCommandLineParser parser;
 
     parser.setTitle("Copy Geometry");
     parser.setCategory("Preprocessing Tools");
     parser.setDescription("");
     parser.setContributor("MBI");
 
     parser.setArgumentPrefix("--", "-");
     parser.addArgument("in", "i", mitkCommandLineParser::InputFile, "Input:", "input image", us::Any(), false);
     parser.addArgument("ref", "r", mitkCommandLineParser::InputFile, "Reference:", "reference image", us::Any(), false);
     parser.addArgument("out", "o", mitkCommandLineParser::OutputFile, "Output:", "output image", us::Any(), false);
 
     map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
     if (parsedArgs.size()==0)
         return EXIT_FAILURE;
 
     // mandatory arguments
     string imageName = us::any_cast<string>(parsedArgs["in"]);
     string refImage = us::any_cast<string>(parsedArgs["ref"]);
     string outImage = us::any_cast<string>(parsedArgs["out"]);
 
     try
     {
-        const std::string s1="", s2="";
-        std::vector<BaseData::Pointer> infile = BaseDataIO::LoadBaseDataFromFile( refImage, s1, s2, false );
-        Image::Pointer source = dynamic_cast<Image*>(infile.at(0).GetPointer());
-        infile = BaseDataIO::LoadBaseDataFromFile( imageName, s1, s2, false );
-        Image::Pointer target = dynamic_cast<Image*>(infile.at(0).GetPointer());
+        Image::Pointer source = mitk::IOUtil::LoadImage(refImage);
+        Image::Pointer target = mitk::IOUtil::LoadImage(imageName);
 
         mitk::BaseGeometry* s_geom = source->GetGeometry();
         mitk::BaseGeometry* t_geom = target->GetGeometry();
 
         t_geom->SetIndexToWorldTransform(s_geom->GetIndexToWorldTransform());
         target->SetGeometry(t_geom);
 
-        mitk::IOUtil::Save(target.GetPointer(), outImage.c_str());
+        mitk::IOUtil::SaveImage(target, outImage);
     }
     catch (itk::ExceptionObject e)
     {
         std::cout << e;
         return EXIT_FAILURE;
     }
     catch (std::exception e)
     {
         std::cout << e.what();
         return EXIT_FAILURE;
     }
     catch (...)
     {
         std::cout << "ERROR!?!";
         return EXIT_FAILURE;
     }
     return EXIT_SUCCESS;
 }
diff --git a/Modules/DiffusionImaging/MiniApps/DiffusionIndices.cpp b/Modules/DiffusionImaging/MiniApps/DiffusionIndices.cpp
index 4454344ef2..a1bbb753e0 100644
--- a/Modules/DiffusionImaging/MiniApps/DiffusionIndices.cpp
+++ b/Modules/DiffusionImaging/MiniApps/DiffusionIndices.cpp
@@ -1,144 +1,144 @@
 /*===================================================================
 
 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 <itkExceptionObject.h>
 #include <itkImageFileWriter.h>
 #include <mitkBaseDataIOFactory.h>
 #include <mitkQBallImage.h>
 #include <itkTensorDerivedMeasurementsFilter.h>
 #include <itkDiffusionQballGeneralizedFaImageFilter.h>
 #include <mitkTensorImage.h>
 #include "mitkCommandLineParser.h"
 #include <boost/algorithm/string.hpp>
 #include <itksys/SystemTools.hxx>
 #include <itkMultiThreader.h>
+#include <mitkIOUtil.h>
 
 /**
  * Calculate indices derived from Qball or tensor images
  */
 int main(int argc, char* argv[])
 {
     mitkCommandLineParser parser;
 
     parser.setTitle("Diffusion Indices");
     parser.setCategory("Diffusion Related Measures");
     parser.setDescription("");
     parser.setContributor("MBI");
 
     parser.setArgumentPrefix("--", "-");
     parser.addArgument("input", "i", mitkCommandLineParser::InputFile, "Input:", "input image (tensor, Q-ball or FSL/MRTrix SH-coefficient image)", us::Any(), false);
     parser.addArgument("index", "idx", mitkCommandLineParser::String, "Index:", "index (fa, gfa, ra, ad, rd, ca, l2, l3, md)", us::Any(), false);
     parser.addArgument("outFile", "o", mitkCommandLineParser::OutputFile, "Output:", "output file", us::Any(), false);
 
     map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
     if (parsedArgs.size()==0)
         return EXIT_FAILURE;
 
     string inFileName = us::any_cast<string>(parsedArgs["input"]);
     string index = us::any_cast<string>(parsedArgs["index"]);
     string outFileName = us::any_cast<string>(parsedArgs["outFile"]);
 
     string ext = itksys::SystemTools::GetFilenameLastExtension(outFileName);
     if (ext.empty())
         outFileName += ".nrrd";
 
     try
     {
         // load input image
-        const std::string s1="", s2="";
-        std::vector<mitk::BaseData::Pointer> infile = mitk::BaseDataIO::LoadBaseDataFromFile( inFileName, s1, s2, false );
+        mitk::BaseData::Pointer infile = mitk::IOUtil::LoadBaseData( inFileName );
 
         if( boost::algorithm::ends_with(inFileName, ".qbi") && index=="gfa" )
         {
             typedef itk::Vector<float, QBALL_ODFSIZE>   OdfVectorType;
             typedef itk::Image<OdfVectorType,3>         ItkQballImageType;
-            mitk::QBallImage::Pointer mitkQballImage = dynamic_cast<mitk::QBallImage*>(infile.at(0).GetPointer());
+            mitk::QBallImage::Pointer mitkQballImage = dynamic_cast<mitk::QBallImage*>(infile.GetPointer());
             ItkQballImageType::Pointer itk_qbi = ItkQballImageType::New();
             mitk::CastToItkImage(mitkQballImage, itk_qbi);
 
 
             typedef itk::DiffusionQballGeneralizedFaImageFilter<float,float,QBALL_ODFSIZE> GfaFilterType;
             GfaFilterType::Pointer gfaFilter = GfaFilterType::New();
             gfaFilter->SetInput(itk_qbi);
             gfaFilter->SetComputationMethod(GfaFilterType::GFA_STANDARD);
             gfaFilter->Update();
 
             itk::ImageFileWriter< itk::Image<float,3> >::Pointer fileWriter = itk::ImageFileWriter< itk::Image<float,3> >::New();
             fileWriter->SetInput(gfaFilter->GetOutput());
             fileWriter->SetFileName(outFileName);
             fileWriter->Update();
         }
         else if( boost::algorithm::ends_with(inFileName, ".dti") )
         {
             typedef itk::Image< itk::DiffusionTensor3D<float>, 3 >    ItkTensorImage;
-            mitk::TensorImage::Pointer mitkTensorImage = dynamic_cast<mitk::TensorImage*>(infile.at(0).GetPointer());
+            mitk::TensorImage::Pointer mitkTensorImage = dynamic_cast<mitk::TensorImage*>(infile.GetPointer());
             ItkTensorImage::Pointer itk_dti = ItkTensorImage::New();
             mitk::CastToItkImage(mitkTensorImage, itk_dti);
 
             typedef itk::TensorDerivedMeasurementsFilter<float> MeasurementsType;
             MeasurementsType::Pointer measurementsCalculator = MeasurementsType::New();
             measurementsCalculator->SetInput(itk_dti.GetPointer() );
 
             if(index=="fa")
                 measurementsCalculator->SetMeasure(MeasurementsType::FA);
             else if(index=="ra")
                 measurementsCalculator->SetMeasure(MeasurementsType::RA);
             else if(index=="ad")
                 measurementsCalculator->SetMeasure(MeasurementsType::AD);
             else if(index=="rd")
                 measurementsCalculator->SetMeasure(MeasurementsType::RD);
             else if(index=="ca")
                 measurementsCalculator->SetMeasure(MeasurementsType::CA);
             else if(index=="l2")
                 measurementsCalculator->SetMeasure(MeasurementsType::L2);
             else if(index=="l3")
                 measurementsCalculator->SetMeasure(MeasurementsType::L3);
             else if(index=="md")
                 measurementsCalculator->SetMeasure(MeasurementsType::MD);
             else
             {
                 MITK_WARN << "No valid diffusion index for input image (tensor image) defined";
                 return EXIT_FAILURE;
             }
 
             measurementsCalculator->Update();
 
             itk::ImageFileWriter< itk::Image<float,3> >::Pointer fileWriter = itk::ImageFileWriter< itk::Image<float,3> >::New();
             fileWriter->SetInput(measurementsCalculator->GetOutput());
             fileWriter->SetFileName(outFileName);
             fileWriter->Update();
         }
         else
             std::cout << "Diffusion index " << index << " not supported for supplied file type.";
     }
     catch (itk::ExceptionObject e)
     {
         std::cout << e;
         return EXIT_FAILURE;
     }
     catch (std::exception e)
     {
         std::cout << e.what();
         return EXIT_FAILURE;
     }
     catch (...)
     {
         std::cout << "ERROR!?!";
         return EXIT_FAILURE;
     }
     return EXIT_SUCCESS;
 }
diff --git a/Modules/DiffusionImaging/MiniApps/DwiDenoising.cpp b/Modules/DiffusionImaging/MiniApps/DwiDenoising.cpp
index f30bfd5189..55d78ef51d 100644
--- a/Modules/DiffusionImaging/MiniApps/DwiDenoising.cpp
+++ b/Modules/DiffusionImaging/MiniApps/DwiDenoising.cpp
@@ -1,163 +1,146 @@
 /*===================================================================
 
 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 <mitkBaseDataIOFactory.h>
 #include "mitkCommandLineParser.h"
 #include <boost/algorithm/string.hpp>
 #include <mitkImage.h>
 #include <itkNonLocalMeansDenoisingFilter.h>
 #include <itkImage.h>
 #include <mitkIOUtil.h>
 #include <mitkDiffusionPropertyHelper.h>
 #include <mitkImageCast.h>
 #include <mitkITKImageImport.h>
 #include <mitkProperties.h>
 
 typedef mitk::Image DiffusionImageType;
 typedef itk::Image<short, 3> ImageType;
 
-mitk::BaseData::Pointer LoadFile(std::string filename)
-{
-  if( filename.empty() )
-    return NULL;
-
-  const std::string s1="", s2="";
-  std::vector<mitk::BaseData::Pointer> infile = mitk::BaseDataIO::LoadBaseDataFromFile( filename, s1, s2, false );
-  if( infile.empty() )
-  {
-    std::cout << "File " << filename << " could not be read!";
-    return NULL;
-  }
-
-  mitk::BaseData::Pointer baseData = infile.at(0);
-  return baseData;
-}
-
 /**
  * Denoises DWI using the Nonlocal - Means algorithm
  */
 int main(int argc, char* argv[])
 {
     std::cout << "DwiDenoising";
   mitkCommandLineParser parser;
 
   parser.setTitle("DWI Denoising");
   parser.setCategory("Preprocessing Tools");
   parser.setContributor("MBI");
   parser.setDescription("Denoising for diffusion weighted images using a non-local means algorithm.");
 
   parser.setArgumentPrefix("--", "-");
   parser.addArgument("input", "i", mitkCommandLineParser::InputFile, "Input:", "input image (DWI)", us::Any(), false);
   parser.addArgument("variance", "v", mitkCommandLineParser::Float, "Variance:", "noise variance", us::Any(), false);
 
   parser.addArgument("mask", "m", mitkCommandLineParser::InputFile, "Mask:", "brainmask for input image", us::Any(), true);
   parser.addArgument("search", "s", mitkCommandLineParser::Int, "Search radius:", "search radius", us::Any(), true);
   parser.addArgument("compare", "c", mitkCommandLineParser::Int, "Comparison radius:", "comparison radius", us::Any(), true);
   parser.addArgument("joint", "j", mitkCommandLineParser::Bool, "Joint information:", "use joint information");
   parser.addArgument("rician", "r", mitkCommandLineParser::Bool, "Rician adaption:", "use rician adaption");
 
   parser.changeParameterGroup("Output", "Output of this miniapp");
 
   parser.addArgument("output", "o", mitkCommandLineParser::OutputFile, "Output:", "output image (DWI)", us::Any(), false);
 
   map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0)
       return EXIT_FAILURE;
 
   string inFileName = us::any_cast<string>(parsedArgs["input"]);
   double variance = static_cast<double>(us::any_cast<float>(parsedArgs["variance"]));
   string maskName;
   if (parsedArgs.count("mask"))
     maskName = us::any_cast<string>(parsedArgs["mask"]);
   string outFileName = us::any_cast<string>(parsedArgs["output"]);
 //  boost::algorithm::erase_all(outFileName, ".dwi");
   int search = 4;
   if (parsedArgs.count("search"))
     search = us::any_cast<int>(parsedArgs["search"]);
   int compare = 1;
   if (parsedArgs.count("compare"))
     compare = us::any_cast<int>(parsedArgs["compare"]);
   bool joint = false;
   if (parsedArgs.count("joint"))
     joint = true;
   bool rician = false;
   if (parsedArgs.count("rician"))
     rician = true;
 
   try
   {
 
     if( boost::algorithm::ends_with(inFileName, ".dwi"))
     {
 
-      DiffusionImageType::Pointer dwi = dynamic_cast<DiffusionImageType*>(LoadFile(inFileName).GetPointer());
+      DiffusionImageType::Pointer dwi = mitk::IOUtil::LoadImage(inFileName);
 
       mitk::DiffusionPropertyHelper::ImageType::Pointer itkVectorImagePointer = mitk::DiffusionPropertyHelper::ImageType::New();
       mitk::CastToItkImage(dwi, itkVectorImagePointer);
 
       itk::NonLocalMeansDenoisingFilter<short>::Pointer filter = itk::NonLocalMeansDenoisingFilter<short>::New();
       filter->SetNumberOfThreads(12);
       filter->SetInputImage( itkVectorImagePointer );
 
       if (!maskName.empty())
       {
-        mitk::Image::Pointer mask = dynamic_cast<mitk::Image*>(LoadFile(maskName).GetPointer());
+        mitk::Image::Pointer mask = mitk::IOUtil::LoadImage(maskName);
         ImageType::Pointer itkMask = ImageType::New();
         mitk::CastToItkImage(mask, itkMask);
         filter->SetInputMask(itkMask);
       }
 
       filter->SetUseJointInformation(joint);
       filter->SetUseRicianAdaption(rician);
       filter->SetSearchRadius(search);
       filter->SetComparisonRadius(compare);
       filter->SetVariance(variance);
       filter->Update();
 
       DiffusionImageType::Pointer output = mitk::GrabItkImageMemory( filter->GetOutput() );
       output->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( mitk::DiffusionPropertyHelper::GetReferenceBValue(dwi) ) );
       output->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( mitk::DiffusionPropertyHelper::GetGradientContainer(dwi) ) );
       mitk::DiffusionPropertyHelper propertyHelper( output );
       propertyHelper.InitializeImage();
 
 //      std::stringstream name;
 //      name << outFileName << "_NLM_" << search << "-" << compare << "-" << variance << ".dwi";
 
       mitk::IOUtil::Save(output, outFileName.c_str());
     }
     else
     {
       std::cout << "Only supported for .dwi!";
     }
   }
   catch (itk::ExceptionObject e)
   {
       std::cout << e;
       return EXIT_FAILURE;
   }
   catch (std::exception e)
   {
       std::cout << e.what();
       return EXIT_FAILURE;
   }
   catch (...)
   {
       std::cout << "ERROR!?!";
       return EXIT_FAILURE;
   }
   return EXIT_SUCCESS;
 }
diff --git a/Modules/DiffusionImaging/MiniApps/QballReconstruction.cpp b/Modules/DiffusionImaging/MiniApps/QballReconstruction.cpp
index 13ea2b526b..2bd680e8ab 100644
--- a/Modules/DiffusionImaging/MiniApps/QballReconstruction.cpp
+++ b/Modules/DiffusionImaging/MiniApps/QballReconstruction.cpp
@@ -1,263 +1,263 @@
 /*===================================================================
 
 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 "mitkBaseDataIOFactory.h"
 #include <mitkCoreObjectFactory.h>
 #include "mitkImage.h"
 #include "itkAnalyticalDiffusionQballReconstructionImageFilter.h"
 #include <boost/lexical_cast.hpp>
 #include "mitkCommandLineParser.h"
 #include <mitkIOUtil.h>
 #include <itksys/SystemTools.hxx>
 #include <mitkDiffusionPropertyHelper.h>
 #include <mitkITKImageImport.h>
 #include <mitkImageCast.h>
 #include <mitkProperties.h>
+#include <mitkIOUtil.h>
 
 using namespace mitk;
 
 /**
  * Perform Q-ball reconstruction using a spherical harmonics basis
  */
 int main(int argc, char* argv[])
 {
     mitkCommandLineParser parser;
     parser.setArgumentPrefix("--", "-");
     parser.addArgument("input", "i", mitkCommandLineParser::InputFile, "Input file", "input raw dwi (.dwi or .fsl/.fslgz)", us::Any(), false);
     parser.addArgument("outFile", "o", mitkCommandLineParser::OutputFile, "Output file", "output file", us::Any(), false);
     parser.addArgument("shOrder", "sh", mitkCommandLineParser::Int, "Spherical harmonics order", "spherical harmonics order", 4, true);
     parser.addArgument("b0Threshold", "t", mitkCommandLineParser::Int, "b0 threshold", "baseline image intensity threshold", 0, true);
     parser.addArgument("lambda", "r", mitkCommandLineParser::Float, "Lambda", "ragularization factor lambda", 0.006, true);
     parser.addArgument("csa", "csa", mitkCommandLineParser::Bool, "Constant solid angle consideration", "use constant solid angle consideration");
     parser.addArgument("outputCoeffs", "shc", mitkCommandLineParser::Bool, "Output coefficients", "output file containing the SH coefficients");
     parser.addArgument("mrtrix", "mb", mitkCommandLineParser::Bool, "MRtrix", "use MRtrix compatible spherical harmonics definition");
 
     parser.setCategory("Preprocessing Tools");
     parser.setTitle("Qball Reconstruction");
     parser.setDescription("");
     parser.setContributor("MBI");
 
     map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
     if (parsedArgs.size()==0)
         return EXIT_FAILURE;
 
     std::string inFileName = us::any_cast<string>(parsedArgs["input"]);
     std::string outfilename = us::any_cast<string>(parsedArgs["outFile"]);
     outfilename = itksys::SystemTools::GetFilenamePath(outfilename)+"/"+itksys::SystemTools::GetFilenameWithoutExtension(outfilename);
 
     int threshold = 0;
     if (parsedArgs.count("b0Threshold"))
         threshold = us::any_cast<int>(parsedArgs["b0Threshold"]);
 
     int shOrder = 4;
     if (parsedArgs.count("shOrder"))
         shOrder = us::any_cast<int>(parsedArgs["shOrder"]);
 
     float lambda = 0.006;
     if (parsedArgs.count("lambda"))
         lambda = us::any_cast<float>(parsedArgs["lambda"]);
 
     int normalization = 0;
     if (parsedArgs.count("csa") && us::any_cast<bool>(parsedArgs["csa"]))
         normalization = 6;
 
     bool outCoeffs = false;
     if (parsedArgs.count("outputCoeffs"))
         outCoeffs = us::any_cast<bool>(parsedArgs["outputCoeffs"]);
 
     bool mrTrix = false;
     if (parsedArgs.count("mrtrix"))
         mrTrix = us::any_cast<bool>(parsedArgs["mrtrix"]);
 
     try
     {
-        const std::string s1="", s2="";
-        std::vector<BaseData::Pointer> infile = BaseDataIO::LoadBaseDataFromFile( inFileName, s1, s2, false );
+        std::vector<BaseData::Pointer> infile = mitk::IOUtil::Load(inFileName);
         Image::Pointer dwi = dynamic_cast<Image*>(infile.at(0).GetPointer());
         mitk::DiffusionPropertyHelper propertyHelper(dwi);
         propertyHelper.AverageRedundantGradients(0.001);
         propertyHelper.InitializeImage();
 
         mitk::QBallImage::Pointer image = mitk::QBallImage::New();
         mitk::Image::Pointer coeffsImage = mitk::Image::New();
 
         std::cout << "SH order: " << shOrder;
         std::cout << "lambda: " << lambda;
         std::cout << "B0 threshold: " << threshold;
         switch ( shOrder )
         {
         case 4:
         {
             typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,4,QBALL_ODFSIZE> FilterType;
             mitk::DiffusionPropertyHelper::ImageType::Pointer itkVectorImagePointer = mitk::DiffusionPropertyHelper::ImageType::New();
             mitk::CastToItkImage(dwi, itkVectorImagePointer);
 
             FilterType::Pointer filter = FilterType::New();
             filter->SetGradientImage( mitk::DiffusionPropertyHelper::GetGradientContainer(dwi), itkVectorImagePointer );
             filter->SetBValue(mitk::DiffusionPropertyHelper::GetReferenceBValue(dwi));
             filter->SetThreshold( threshold );
             filter->SetLambda(lambda);
             filter->SetUseMrtrixBasis(mrTrix);
             if (normalization==0)
                 filter->SetNormalizationMethod(FilterType::QBAR_STANDARD);
             else
                 filter->SetNormalizationMethod(FilterType::QBAR_SOLID_ANGLE);
             filter->Update();
             image->InitializeByItk( filter->GetOutput() );
             image->SetVolume( filter->GetOutput()->GetBufferPointer() );
             coeffsImage->InitializeByItk( filter->GetCoefficientImage().GetPointer() );
             coeffsImage->SetVolume( filter->GetCoefficientImage()->GetBufferPointer() );
             break;
         }
         case 6:
         {
             typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,6,QBALL_ODFSIZE> FilterType;
             mitk::DiffusionPropertyHelper::ImageType::Pointer itkVectorImagePointer = mitk::DiffusionPropertyHelper::ImageType::New();
             mitk::CastToItkImage(dwi, itkVectorImagePointer);
 
             FilterType::Pointer filter = FilterType::New();
             filter->SetGradientImage( mitk::DiffusionPropertyHelper::GetGradientContainer(dwi), itkVectorImagePointer );
             filter->SetBValue(mitk::DiffusionPropertyHelper::GetReferenceBValue(dwi));
             filter->SetThreshold( threshold );
             filter->SetLambda(lambda);
             filter->SetUseMrtrixBasis(mrTrix);
             if (normalization==0)
                 filter->SetNormalizationMethod(FilterType::QBAR_STANDARD);
             else
                 filter->SetNormalizationMethod(FilterType::QBAR_SOLID_ANGLE);
             filter->Update();
             image->InitializeByItk( filter->GetOutput() );
             image->SetVolume( filter->GetOutput()->GetBufferPointer() );
             coeffsImage->InitializeByItk( filter->GetCoefficientImage().GetPointer() );
             coeffsImage->SetVolume( filter->GetCoefficientImage()->GetBufferPointer() );
             break;
         }
         case 8:
         {
             typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,8,QBALL_ODFSIZE> FilterType;
             mitk::DiffusionPropertyHelper::ImageType::Pointer itkVectorImagePointer = mitk::DiffusionPropertyHelper::ImageType::New();
             mitk::CastToItkImage(dwi, itkVectorImagePointer);
 
             FilterType::Pointer filter = FilterType::New();
             filter->SetGradientImage( mitk::DiffusionPropertyHelper::GetGradientContainer(dwi), itkVectorImagePointer );
             filter->SetBValue(mitk::DiffusionPropertyHelper::GetReferenceBValue(dwi));
             filter->SetThreshold( threshold );
             filter->SetLambda(lambda);
             filter->SetUseMrtrixBasis(mrTrix);
             if (normalization==0)
                 filter->SetNormalizationMethod(FilterType::QBAR_STANDARD);
             else
                 filter->SetNormalizationMethod(FilterType::QBAR_SOLID_ANGLE);
             filter->Update();
             image->InitializeByItk( filter->GetOutput() );
             image->SetVolume( filter->GetOutput()->GetBufferPointer() );
             coeffsImage->InitializeByItk( filter->GetCoefficientImage().GetPointer() );
             coeffsImage->SetVolume( filter->GetCoefficientImage()->GetBufferPointer() );
             break;
         }
         case 10:
         {
             typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,10,QBALL_ODFSIZE> FilterType;
             mitk::DiffusionPropertyHelper::ImageType::Pointer itkVectorImagePointer = mitk::DiffusionPropertyHelper::ImageType::New();
             mitk::CastToItkImage(dwi, itkVectorImagePointer);
 
             FilterType::Pointer filter = FilterType::New();
             filter->SetGradientImage( mitk::DiffusionPropertyHelper::GetGradientContainer(dwi), itkVectorImagePointer );
             filter->SetBValue(mitk::DiffusionPropertyHelper::GetReferenceBValue(dwi));
             filter->SetThreshold( threshold );
             filter->SetLambda(lambda);
             filter->SetUseMrtrixBasis(mrTrix);
             if (normalization==0)
                 filter->SetNormalizationMethod(FilterType::QBAR_STANDARD);
             else
                 filter->SetNormalizationMethod(FilterType::QBAR_SOLID_ANGLE);
             filter->Update();
             image->InitializeByItk( filter->GetOutput() );
             image->SetVolume( filter->GetOutput()->GetBufferPointer() );
             coeffsImage->InitializeByItk( filter->GetCoefficientImage().GetPointer() );
             coeffsImage->SetVolume( filter->GetCoefficientImage()->GetBufferPointer() );
             break;
         }
         case 12:
         {
             typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,12,QBALL_ODFSIZE> FilterType;
             mitk::DiffusionPropertyHelper::ImageType::Pointer itkVectorImagePointer = mitk::DiffusionPropertyHelper::ImageType::New();
             mitk::CastToItkImage(dwi, itkVectorImagePointer);
 
             FilterType::Pointer filter = FilterType::New();
             filter->SetGradientImage( mitk::DiffusionPropertyHelper::GetGradientContainer(dwi), itkVectorImagePointer );
             filter->SetBValue(mitk::DiffusionPropertyHelper::GetReferenceBValue(dwi));
             filter->SetThreshold( threshold );
             filter->SetLambda(lambda);
             if (normalization==0)
                 filter->SetNormalizationMethod(FilterType::QBAR_STANDARD);
             else
                 filter->SetNormalizationMethod(FilterType::QBAR_SOLID_ANGLE);
             filter->Update();
             image->InitializeByItk( filter->GetOutput() );
             image->SetVolume( filter->GetOutput()->GetBufferPointer() );
             coeffsImage->InitializeByItk( filter->GetCoefficientImage().GetPointer() );
             coeffsImage->SetVolume( filter->GetCoefficientImage()->GetBufferPointer() );
             break;
         }
         default:
         {
             std::cout << "Supplied SH order not supported. Using default order of 4.";
             typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,4,QBALL_ODFSIZE> FilterType;
             mitk::DiffusionPropertyHelper::ImageType::Pointer itkVectorImagePointer = mitk::DiffusionPropertyHelper::ImageType::New();
             mitk::CastToItkImage(dwi, itkVectorImagePointer);
 
             FilterType::Pointer filter = FilterType::New();
             filter->SetGradientImage( mitk::DiffusionPropertyHelper::GetGradientContainer(dwi), itkVectorImagePointer );
             filter->SetBValue(mitk::DiffusionPropertyHelper::GetReferenceBValue(dwi));
             filter->SetThreshold( threshold );
             filter->SetLambda(lambda);
             filter->SetUseMrtrixBasis(mrTrix);
             if (normalization==0)
                 filter->SetNormalizationMethod(FilterType::QBAR_STANDARD);
             else
                 filter->SetNormalizationMethod(FilterType::QBAR_SOLID_ANGLE);
             filter->Update();
             image->InitializeByItk( filter->GetOutput() );
             image->SetVolume( filter->GetOutput()->GetBufferPointer() );
             coeffsImage->InitializeByItk( filter->GetCoefficientImage().GetPointer() );
             coeffsImage->SetVolume( filter->GetCoefficientImage()->GetBufferPointer() );
         }
         }
 
         std::string coeffout = outfilename;
         coeffout += "_shcoeffs.nrrd";
 
         outfilename += ".qbi";
         mitk::IOUtil::SaveBaseData(image, outfilename);
 
         if (outCoeffs)
             mitk::IOUtil::SaveImage(coeffsImage, coeffout);
     }
     catch ( itk::ExceptionObject &err)
     {
         std::cout << "Exception: " << err;
     }
     catch ( std::exception err)
     {
         std::cout << "Exception: " << err.what();
     }
     catch ( ... )
     {
         std::cout << "Exception!";
     }
     return EXIT_SUCCESS;
 }
diff --git a/Modules/DiffusionImaging/MiniApps/TensorReconstruction.cpp b/Modules/DiffusionImaging/MiniApps/TensorReconstruction.cpp
index a1b066cc54..8844f8f202 100644
--- a/Modules/DiffusionImaging/MiniApps/TensorReconstruction.cpp
+++ b/Modules/DiffusionImaging/MiniApps/TensorReconstruction.cpp
@@ -1,103 +1,102 @@
 /*===================================================================
 
 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 "mitkBaseDataIOFactory.h"
 #include "mitkImage.h"
 #include <mitkImageCast.h>
 #include "mitkBaseData.h"
 #include <mitkDiffusionPropertyHelper.h>
 
 #include <itkDiffusionTensor3DReconstructionImageFilter.h>
 #include <itkDiffusionTensor3D.h>
 #include <itkImageFileWriter.h>
 #include <itkNrrdImageIO.h>
 #include "mitkCommandLineParser.h"
 #include <itksys/SystemTools.hxx>
+#include <mitkIOUtil.h>
 
 using namespace mitk;
 /**
  * Convert files from one ending to the other
  */
 int main(int argc, char* argv[])
 {
     std::cout << "TensorReconstruction";
     mitkCommandLineParser parser;
     parser.setArgumentPrefix("--", "-");
     parser.addArgument("input", "i", mitkCommandLineParser::InputFile, "Input file", "input raw dwi (.dwi or .fsl/.fslgz)", us::Any(), false);
     parser.addArgument("outFile", "o", mitkCommandLineParser::OutputFile, "Output file", "output file", us::Any(), false);
     parser.addArgument("b0Threshold", "t", mitkCommandLineParser::Int, "b0 threshold", "baseline image intensity threshold", 0, true);
 
     parser.setCategory("Preprocessing Tools");
     parser.setTitle("Tensor Reconstruction");
     parser.setDescription("");
     parser.setContributor("MBI");
 
     map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
     if (parsedArgs.size()==0)
         return EXIT_FAILURE;
 
     std::string inFileName = us::any_cast<string>(parsedArgs["input"]);
     std::string outfilename = us::any_cast<string>(parsedArgs["outFile"]);
     outfilename = itksys::SystemTools::GetFilenamePath(outfilename)+"/"+itksys::SystemTools::GetFilenameWithoutExtension(outfilename);
     outfilename += ".dti";
 
     int threshold = 0;
     if (parsedArgs.count("b0Threshold"))
         threshold = us::any_cast<int>(parsedArgs["b0Threshold"]);
 
     try
     {
-        const std::string s1="", s2="";
-        std::vector<BaseData::Pointer> infile = BaseDataIO::LoadBaseDataFromFile( inFileName, s1, s2, false );
-        Image::Pointer dwi = dynamic_cast<Image*>(infile.at(0).GetPointer());
+        Image::Pointer dwi = IOUtil::LoadImage(inFileName);
 
         mitk::DiffusionPropertyHelper::ImageType::Pointer itkVectorImagePointer = mitk::DiffusionPropertyHelper::ImageType::New();
         mitk::CastToItkImage(dwi, itkVectorImagePointer);
 
         typedef itk::DiffusionTensor3DReconstructionImageFilter< short, short, float > TensorReconstructionImageFilterType;
         TensorReconstructionImageFilterType::Pointer filter = TensorReconstructionImageFilterType::New();
         filter->SetGradientImage( mitk::DiffusionPropertyHelper::GetGradientContainer(dwi), itkVectorImagePointer );
         filter->SetBValue( mitk::DiffusionPropertyHelper::GetReferenceBValue( dwi ));
         filter->SetThreshold(threshold);
         filter->Update();
 
         // Save tensor image
         itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
         io->SetFileType( itk::ImageIOBase::Binary );
         io->UseCompressionOn();
 
         itk::ImageFileWriter< itk::Image< itk::DiffusionTensor3D< float >, 3 > >::Pointer writer = itk::ImageFileWriter< itk::Image< itk::DiffusionTensor3D< float >, 3 > >::New();
         writer->SetInput(filter->GetOutput());
         writer->SetFileName(outfilename);
         writer->SetImageIO(io);
         writer->UseCompressionOn();
         writer->Update();
     }
     catch ( itk::ExceptionObject &err)
     {
         std::cout << "Exception: " << err;
     }
     catch ( std::exception err)
     {
         std::cout << "Exception: " << err.what();
     }
     catch ( ... )
     {
         std::cout << "Exception!";
     }
     return EXIT_SUCCESS;
 
 }