diff --git a/Modules/DiffusionImaging/MiniApps/DICOMLoader.cpp b/Modules/DiffusionImaging/MiniApps/DICOMLoader.cpp
index 3540aae5e8..40b1980dbf 100644
--- a/Modules/DiffusionImaging/MiniApps/DICOMLoader.cpp
+++ b/Modules/DiffusionImaging/MiniApps/DICOMLoader.cpp
@@ -1,283 +1,286 @@
 /*===================================================================
 
 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 "mitkBaseData.h"
 #include <mitkDiffusionPropertyHelper.h>
 #include <mitkImageCast.h>
 #include <mitkITKImageImport.h>
 
 #include <itkImageFileWriter.h>
 #include <itkNrrdImageIO.h>
 #include "mitkCommandLineParser.h"
 #include <itksys/SystemTools.hxx>
 #include <itksys/Directory.hxx>
 
 #include "mitkDiffusionDICOMFileReader.h"
 #include "mitkDICOMTagBasedSorter.h"
 #include "mitkDICOMSortByTag.h"
 
 #include "itkMergeDiffusionImagesFilter.h"
 #include <mitkIOUtil.h>
 
 static mitk::StringList& GetInputFilenames()
 {
   static mitk::StringList inputs;
   return inputs;
 }
 
 void SetInputFileNames( std::string input_directory )
 {
   // I. Get all files in directory
   itksys::Directory input;
   input.Load( input_directory.c_str() );
 
   // II. Push back files
   mitk::StringList inputlist;//, mergedlist;
   for( unsigned long idx=0; idx<input.GetNumberOfFiles(); idx++)
   {
     if( ! itksys::SystemTools::FileIsDirectory( input.GetFile(idx)) )
     {
       std::string fullpath = input_directory + "/" + std::string( input.GetFile(idx) );
       inputlist.push_back(  itksys::SystemTools::ConvertToOutputPath( fullpath.c_str() ) );
 
       MITK_INFO("dicom.loader.inputdir.addfile") << input.GetFile(idx);
     }
   }
 
   /*mergedlist.reserve( GetInputFilenames().size() + inputlist.size() );
 
   mergedlist.insert( mergedlist.end(), GetInputFilenames().begin(), GetInputFilenames().end() );
   mergedlist.insert( mergedlist.end(), inputlist.begin(), inputlist.end() );*/
 
   GetInputFilenames() = inputlist;//mergedlist;
 
   MITK_INFO("dicom.loader.setinputfiles.end") << "[]";
 }
 
 
 mitk::Image::Pointer ReadInDICOMFiles( mitk::StringList& input_files, std::string output_file )
 {
   // repeat test with some more realistic sorting
   mitk::DiffusionDICOMFileReader::Pointer gdcmReader = mitk::DiffusionDICOMFileReader::New(); // this also tests destruction
   mitk::DICOMTagBasedSorter::Pointer tagSorter = mitk::DICOMTagBasedSorter::New();
 
   // Use tags as in Qmitk
   // all the things that split by tag in DicomSeriesReader
   tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0028, 0x0010) ); // Number of Rows
   tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0028, 0x0011) ); // Number of Columns
   tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0028, 0x0030) ); // Pixel Spacing
   tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0018, 0x1164) ); // Imager Pixel Spacing
   tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0020, 0x0037) ); // Image Orientation (Patient) // TODO add tolerance parameter (l. 1572 of original code)
   tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0018, 0x0050) ); // Slice Thickness
   tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0028, 0x0008) ); // Number of Frames
   tagSorter->AddDistinguishingTag( mitk::DICOMTag(0x0020, 0x0052) ); // Frame of Reference UID
 
   mitk::DICOMSortCriterion::ConstPointer sorting =
       mitk::DICOMSortByTag::New( mitk::DICOMTag(0x0020, 0x0013), // instance number
                                  mitk::DICOMSortByTag::New( mitk::DICOMTag(0x0020, 0x0012) //acquisition number
                                                             ).GetPointer()
                                  ).GetPointer();
   tagSorter->SetSortCriterion( sorting );
 
   MITK_INFO("dicom.loader.read.init") << "[]" ;
   MITK_INFO("dicom.loader.read.inputs") << " " << input_files.size();
 
   gdcmReader->SetInputFiles( input_files );
   gdcmReader->AddSortingElement( tagSorter );
   gdcmReader->AnalyzeInputFiles();
   gdcmReader->LoadImages();
 
   mitk::Image::Pointer loaded_image = gdcmReader->GetOutput(0).GetMitkImage();
 
   return loaded_image;
 }
 
 typedef short DiffusionPixelType;
 typedef itk::VectorImage<DiffusionPixelType,3>         DwiImageType;
 typedef DwiImageType::PixelType                        DwiPixelType;
 typedef DwiImageType::RegionType                       DwiRegionType;
 typedef std::vector< DwiImageType::Pointer >  DwiImageContainerType;
 
 typedef mitk::Image          DiffusionImageType;
 typedef mitk::DiffusionPropertyHelper::GradientDirectionsContainerType    GradientContainerType;
 typedef std::vector< GradientContainerType::Pointer >  GradientListContainerType;
 
 void SearchForInputInSubdirs( std::string root_directory, std::string subdir_prefix , std::vector<DiffusionImageType::Pointer>& output_container)
 {
   // I. Get all dirs in directory
   itksys::Directory rootdir;
   rootdir.Load( root_directory.c_str() );
 
   MITK_INFO("dicom.loader.setinputdirs.start") << "Prefix = " << subdir_prefix;
 
   for( unsigned int idx=0; idx<rootdir.GetNumberOfFiles(); idx++)
   {
     std::string current_path = rootdir.GetFile(idx);
 
     std::string directory_path = std::string(rootdir.GetPath()) + std::string("/") + current_path;
 
     MITK_INFO("dicom.loader.inputrootdir.test") << "ProbePath:   " << current_path;
     MITK_INFO("dicom.loader.inputrootdir.test") << "IsDirectory: " << itksys::SystemTools::FileIsDirectory( itksys::SystemTools::ConvertToOutputPath( directory_path.c_str() ).c_str() )
                                                 << " StartsWith: " << itksys::SystemTools::StringStartsWith( current_path.c_str(), subdir_prefix.c_str() );
 
     // test for prefix
     if(    itksys::SystemTools::FileIsDirectory( itksys::SystemTools::ConvertToOutputPath( directory_path.c_str() ).c_str() )
            && itksys::SystemTools::StringStartsWith( current_path.c_str(), subdir_prefix.c_str() )
            )
     {
 
       MITK_INFO("dicom.loader.inputrootdir.searchin") << directory_path;
       SetInputFileNames( itksys::SystemTools::ConvertToOutputPath( directory_path.c_str() ) );
 
       MITK_INFO("dicom.loader.inputrootdir.preload") << "[]" ;
       DiffusionImageType::Pointer dwi = ReadInDICOMFiles( GetInputFilenames(), "" );
 
       output_container.push_back( dwi );
 
 
     }
   }
 
   MITK_INFO("dicom.loader.setinputdirs.end") << "[]";
 }
 
 
 
 using namespace mitk;
 /**
  * Read DICOM Files through the new (refactored) Diffusion DICOM Loader. It serves also as a first test of the new functionality, it will replace the
  * current loading mechanism after the necessary parts are merged into the master branch.
  */
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
   parser.setArgumentPrefix("--", "-");
 
   parser.setTitle("Diffusion Dicom Loader");
   parser.setCategory("Preprocessing Tools");
   parser.setDescription("Loads Diffusion Dicom files.");
   parser.setContributor("MBI");
 
   parser.addArgument("inputdir", "i", mitkCommandLineParser::InputDirectory, "Input Directory" ,"input directory containing dicom files", us::Any(), false);
   parser.addArgument("output", "o", mitkCommandLineParser::OutputFile, "Output File Name", "output file", us::Any(), false);
   parser.addArgument("dwprefix", "p", mitkCommandLineParser::String, "Recursive Scan Prefix", "prefix for subfolders search rootdir is specified by the 'inputdir' argument value", us::Any(), true);
   parser.addArgument("dryrun", "-s", mitkCommandLineParser::Bool, "Dry run","do not read, only look for input files ", us::Any(), true );
 
   map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0)
   {
     return EXIT_FAILURE;
   }
 
   std::string inputDirectory = us::any_cast<std::string>( parsedArgs["inputdir"] );
   MITK_INFO << "Loading data from directory: " << inputDirectory;
 
   // retrieve the prefix flag (if set)
   bool search_for_subdirs = false;
   std::string subdir_prefix;
   if( parsedArgs.count("dwprefix"))
   {
-    MITK_INFO << "Prefix specified, will search for subdirs in the input directory!";
     subdir_prefix = us::any_cast<std::string>( parsedArgs["dwprefix"] );
-    search_for_subdirs = true;
+    if (subdir_prefix != "")
+    {
+      MITK_INFO << "Prefix specified, will search for subdirs in the input directory!";
+      search_for_subdirs = true;
+    }
   }
 
   // retrieve the output
   std::string outputFile = us::any_cast< std::string >( parsedArgs["output"] );
 
   // if the executable is called with a single directory, just parse the given folder for files and read them into a diffusion image
   if( !search_for_subdirs )
   {
     SetInputFileNames( inputDirectory );
 
     MITK_INFO << "Got " << GetInputFilenames().size() << " input files.";
     mitk::Image::Pointer d_img = ReadInDICOMFiles( GetInputFilenames(), outputFile );
 
     try
     {
       mitk::IOUtil::Save(d_img, outputFile.c_str());
     }
     catch( const itk::ExceptionObject& e)
     {
       MITK_ERROR << "Failed to write out the output file. \n\t Reason : ITK Exception " << e.what();
     }
 
   }
   // if the --dwprefix flag is set, then we have to look for the directories, load each of them separately and afterwards merge the images
   else
   {
     std::vector<mitk::Image::Pointer> output_container;
 
     SearchForInputInSubdirs( inputDirectory, subdir_prefix, output_container );
 
     // final output image
     mitk::Image::Pointer image = mitk::Image::New();
     if( output_container.size() > 1 )
     {
       DwiImageContainerType       imageContainer;
       GradientListContainerType   gradientListContainer;
       std::vector< double >       bValueContainer;
 
       for ( std::vector< mitk::Image::Pointer >::iterator dwi = output_container.begin();
         dwi != output_container.end(); ++dwi )
       {
         mitk::DiffusionPropertyHelper::ImageType::Pointer itkVectorImagePointer = mitk::DiffusionPropertyHelper::ImageType::New();
         mitk::CastToItkImage(*dwi, itkVectorImagePointer);
 
         imageContainer.push_back(itkVectorImagePointer);
         gradientListContainer.push_back( mitk::DiffusionPropertyHelper::GetGradientContainer(*dwi));
         bValueContainer.push_back( mitk::DiffusionPropertyHelper::GetReferenceBValue(*dwi));
       }
 
       typedef itk::MergeDiffusionImagesFilter<short> FilterType;
       FilterType::Pointer filter = FilterType::New();
       filter->SetImageVolumes(imageContainer);
       filter->SetGradientLists(gradientListContainer);
       filter->SetBValues(bValueContainer);
       filter->Update();
 
       vnl_matrix_fixed< double, 3, 3 > mf; mf.set_identity();
 
       image = mitk::GrabItkImageMemory( filter->GetOutput() );
       image->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( filter->GetOutputGradients() ) );
       image->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( filter->GetB_Value() ) );
       image->SetProperty( mitk::DiffusionPropertyHelper::MEASUREMENTFRAMEPROPERTYNAME.c_str(), mitk::MeasurementFrameProperty::New( mf ) );
       mitk::DiffusionPropertyHelper propertyHelper( image );
       propertyHelper.InitializeImage();
     }
     // just output the image if there was only one folder found
     else
     {
       image = output_container.at(0);
     }
 
     MITK_INFO("dicom.import.writeout") << " [OutputFile] " << outputFile.c_str();
 
     try
     {
       mitk::IOUtil::Save(image, outputFile.c_str());
     }
     catch( const itk::ExceptionObject& e)
     {
       MITK_ERROR << "Failed to write out the output file. \n\t Reason : ITK Exception " << e.what();
     }
 
   }
 
   return 1;
 }
diff --git a/Modules/DiffusionImaging/MiniApps/ImageResampler.cpp b/Modules/DiffusionImaging/MiniApps/ImageResampler.cpp
index 19d75f71f8..c7058badc0 100644
--- a/Modules/DiffusionImaging/MiniApps/ImageResampler.cpp
+++ b/Modules/DiffusionImaging/MiniApps/ImageResampler.cpp
@@ -1,310 +1,314 @@
 /*===================================================================
 
 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 "mitkCommandLineParser.h"
 
 #include <mitkIOUtil.h>
 #include <mitkRegistrationWrapper.h>
 #include <mitkImage.h>
 #include <mitkImageCast.h>
 #include <mitkITKImageImport.h>
 #include <mitkImageTimeSelector.h>
 #include <mitkDiffusionPropertyHelper.h>
 #include <mitkProperties.h>
 
 // ITK
 #include <itksys/SystemTools.hxx>
 #include <itkDirectory.h>
 #include "itkLinearInterpolateImageFunction.h"
 #include "itkWindowedSincInterpolateImageFunction.h"
 #include "itkIdentityTransform.h"
 #include "itkResampleImageFilter.h"
 #include "itkResampleDwiImageFilter.h"
 
 typedef itk::Image<double, 3> InputImageType;
 
 
 static mitk::Image::Pointer TransformToReference(mitk::Image *reference, mitk::Image *moving, bool sincInterpol = false)
 {
   // Convert to itk Images
   InputImageType::Pointer itkReference = InputImageType::New();
   InputImageType::Pointer itkMoving = InputImageType::New();
   mitk::CastToItkImage(reference,itkReference);
   mitk::CastToItkImage(moving,itkMoving);
 
   // Identify Transform
   typedef itk::IdentityTransform<double, 3> T_Transform;
   T_Transform::Pointer _pTransform = T_Transform::New();
   _pTransform->SetIdentity();
 
   typedef itk::WindowedSincInterpolateImageFunction< InputImageType, 3> WindowedSincInterpolatorType;
   WindowedSincInterpolatorType::Pointer sinc_interpolator = WindowedSincInterpolatorType::New();
 
   typedef itk::ResampleImageFilter<InputImageType, InputImageType>  ResampleFilterType;
 
 
   ResampleFilterType::Pointer resampler = ResampleFilterType::New();
   resampler->SetInput(itkMoving);
   resampler->SetReferenceImage( itkReference );
   resampler->UseReferenceImageOn();
   resampler->SetTransform(_pTransform);
   resampler->SetInterpolator(sinc_interpolator);
   resampler->Update();
 
   // Convert back to mitk
   mitk::Image::Pointer result = mitk::Image::New();
   result->InitializeByItk(resampler->GetOutput());
   GrabItkImageMemory( resampler->GetOutput() , result );
   return result;
 }
 
 
 static std::vector<std::string> &split(const std::string &s, char delim, std::vector<std::string> &elems)
 {
   std::stringstream ss(s);
   std::string item;
   while (std::getline(ss, item, delim))
   {
     elems.push_back(item);
   }
   return elems;
 }
 
 static std::vector<std::string> split(const std::string &s, char delim)
 {
   std::vector < std::string > elems;
   return split(s, delim, elems);
 }
 
 
 static mitk::Image::Pointer ResampleBySpacing(mitk::Image *input, float *spacing, bool useLinInt = true)
 {
   InputImageType::Pointer itkImage = InputImageType::New();
   CastToItkImage(input,itkImage);
 
   /**
    * 1) Resampling
    *
    */
   // Identity transform.
   // We don't want any transform on our image except rescaling which is not
   // specified by a transform but by the input/output spacing as we will see
   // later.
   // So no transform will be specified.
   typedef itk::IdentityTransform<double, 3> T_Transform;
 
   // The resampler type itself.
   typedef itk::ResampleImageFilter<InputImageType, InputImageType>  T_ResampleFilter;
 
   // Prepare the resampler.
   // Instantiate the transform and specify it should be the id transform.
   T_Transform::Pointer _pTransform = T_Transform::New();
   _pTransform->SetIdentity();
 
   // Instantiate the resampler. Wire in the transform and the interpolator.
   T_ResampleFilter::Pointer _pResizeFilter = T_ResampleFilter::New();
 
   // Specify the input.
   _pResizeFilter->SetInput(itkImage);
 
   _pResizeFilter->SetTransform(_pTransform);
 
   // Set the output origin.
   _pResizeFilter->SetOutputOrigin(itkImage->GetOrigin());
 
   // Compute the size of the output.
   // The size (# of pixels) in the output is recomputed using
   // the ratio of the input and output sizes.
   InputImageType::SpacingType inputSpacing = itkImage->GetSpacing();
   InputImageType::SpacingType outputSpacing;
   const InputImageType::RegionType& inputSize = itkImage->GetLargestPossibleRegion();
 
   InputImageType::SizeType outputSize;
   typedef InputImageType::SizeType::SizeValueType SizeValueType;
 
   // Set the output spacing.
   outputSpacing[0] = spacing[0];
   outputSpacing[1] = spacing[1];
   outputSpacing[2] = spacing[2];
 
   outputSize[0] = static_cast<SizeValueType>(inputSize.GetSize()[0] * inputSpacing[0] / outputSpacing[0] + .5);
   outputSize[1] = static_cast<SizeValueType>(inputSize.GetSize()[1] * inputSpacing[1] / outputSpacing[1] + .5);
   outputSize[2] = static_cast<SizeValueType>(inputSize.GetSize()[2] * inputSpacing[2] / outputSpacing[2] + .5);
 
   _pResizeFilter->SetOutputSpacing(outputSpacing);
   _pResizeFilter->SetSize(outputSize);
 
   typedef itk::LinearInterpolateImageFunction< InputImageType > LinearInterpolatorType;
   LinearInterpolatorType::Pointer lin_interpolator = LinearInterpolatorType::New();
 
   typedef itk::WindowedSincInterpolateImageFunction< InputImageType, 4> WindowedSincInterpolatorType;
   WindowedSincInterpolatorType::Pointer sinc_interpolator = WindowedSincInterpolatorType::New();
 
   if (useLinInt)
     _pResizeFilter->SetInterpolator(lin_interpolator);
   else
     _pResizeFilter->SetInterpolator(sinc_interpolator);
 
   _pResizeFilter->Update();
 
   mitk::Image::Pointer image = mitk::Image::New();
   image->InitializeByItk(_pResizeFilter->GetOutput());
   mitk::GrabItkImageMemory( _pResizeFilter->GetOutput(), image);
   return image;
 }
 
 /// Save images according to file type
 static void SaveImage(std::string fileName, mitk::Image* image, std::string fileType )
 {
   std::cout << "----Save to " << fileName;
 
   mitk::IOUtil::Save(image, fileName);
 }
 
 mitk::Image::Pointer ResampleDWIbySpacing(mitk::Image::Pointer input, float* spacing, bool useLinInt = true)
 {
 
   itk::Vector<double, 3> spacingVector;
   spacingVector[0] = spacing[0];
   spacingVector[1] = spacing[1];
   spacingVector[2] = spacing[2];
 
   typedef itk::ResampleDwiImageFilter<short> ResampleFilterType;
 
   mitk::DiffusionPropertyHelper::ImageType::Pointer itkVectorImagePointer = mitk::DiffusionPropertyHelper::ImageType::New();
   mitk::CastToItkImage(input, itkVectorImagePointer);
 
   ResampleFilterType::Pointer resampler = ResampleFilterType::New();
   resampler->SetInput( itkVectorImagePointer );
   resampler->SetInterpolation(ResampleFilterType::Interpolate_Linear);
   resampler->SetNewSpacing(spacingVector);
   resampler->Update();
 
   mitk::Image::Pointer output = mitk::GrabItkImageMemory( resampler->GetOutput() );
   output->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( mitk::DiffusionPropertyHelper::GetGradientContainer(input) ) );
   output->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( mitk::DiffusionPropertyHelper::GetReferenceBValue(input) ) );
   mitk::DiffusionPropertyHelper propertyHelper( output );
   propertyHelper.InitializeImage();
 
   return output;
 }
 
 int main( int argc, char* argv[] )
 {
   mitkCommandLineParser parser;
   parser.setArgumentPrefix("--","-");
 
   parser.setTitle("Image Resampler");
   parser.setCategory("Preprocessing Tools");
   parser.setContributor("MBI");
   parser.setDescription("Resample an image to eigther a specific spacing or to a reference image.");
 
   // Add command line argument names
   parser.addArgument("help", "h",mitkCommandLineParser::Bool, "Show this help text");
   parser.addArgument("input", "i", mitkCommandLineParser::InputImage, "Input:", "Input file",us::Any(),false);
   parser.addArgument("output", "o", mitkCommandLineParser::OutputFile, "Output:", "Output file",us::Any(),false);
   parser.addArgument("spacing", "s", mitkCommandLineParser::String, "Spacing:", "Resample provide x,y,z spacing in mm (e.g. -r 1,1,3), is not applied to tensor data",us::Any());
   parser.addArgument("reference", "r", mitkCommandLineParser::InputImage, "Reference:", "Resample using supplied reference image. Also cuts image to same dimensions",us::Any());
   parser.addArgument("win-sinc", "w", mitkCommandLineParser::Bool, "Windowed-sinc interpolation:", "Use windowed-sinc interpolation (3) instead of linear interpolation ",us::Any());
 
 
   map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
 
   // Handle special arguments
   bool useSpacing = false;
   bool useLinearInterpol = true;
   {
     if (parsedArgs.size() == 0)
     {
       return EXIT_FAILURE;
     }
 
     if (parsedArgs.count("sinc-int"))
       useLinearInterpol = false;
 
     // Show a help message
     if ( parsedArgs.count("help") || parsedArgs.count("h"))
     {
       std::cout << parser.helpText();
       return EXIT_SUCCESS;
     }
-   }
+  }
 
   std::string outputFile = us::any_cast<string>(parsedArgs["output"]);
   std::string inputFile = us::any_cast<string>(parsedArgs["input"]);
 
   std::vector<std::string> spacings;
   float spacing[3];
   if (parsedArgs.count("spacing"))
   {
+
     std::string arg =  us::any_cast<string>(parsedArgs["spacing"]);
-    spacings = split(arg ,',');
-    spacing[0] = atoi(spacings.at(0).c_str());
-    spacing[1] = atoi(spacings.at(1).c_str());
-    spacing[2] = atoi(spacings.at(2).c_str());
-    useSpacing = true;
+    if (arg != "")
+    {
+      spacings = split(arg ,',');
+      spacing[0] = atoi(spacings.at(0).c_str());
+      spacing[1] = atoi(spacings.at(1).c_str());
+      spacing[2] = atoi(spacings.at(2).c_str());
+      useSpacing = true;
+    }
   }
 
   std::string refImageFile = "";
   if (parsedArgs.count("reference"))
   {
     refImageFile =  us::any_cast<string>(parsedArgs["reference"]);
   }
 
   if (refImageFile =="" && useSpacing == false)
   {
     MITK_ERROR << "No information how to resample is supplied. Use eigther --spacing or --reference !";
     return EXIT_FAILURE;
   }
 
 
   mitk::Image::Pointer refImage;
   if (!useSpacing)
-      refImage = mitk::IOUtil::LoadImage(refImageFile);
+    refImage = mitk::IOUtil::LoadImage(refImageFile);
 
   mitk::Image::Pointer inputDWI = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadBaseData(inputFile).GetPointer());
   if ( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(inputDWI))
   {
     mitk::Image::Pointer outputImage;
 
     if (useSpacing)
       outputImage = ResampleDWIbySpacing(inputDWI, spacing);
     else
     {
       MITK_WARN << "Not supported yet, to resample a DWI please set a new spacing.";
       return EXIT_FAILURE;
     }
 
     mitk::IOUtil::Save(outputImage, outputFile.c_str());
 
     return EXIT_SUCCESS;
   }
   mitk::Image::Pointer inputImage = mitk::IOUtil::LoadImage(inputFile);
 
 
   mitk::Image::Pointer resultImage;
 
   if (useSpacing)
     resultImage = ResampleBySpacing(inputImage,spacing);
   else
     resultImage = TransformToReference(refImage,inputImage);
 
 
   mitk::IOUtil::SaveImage(resultImage, outputFile);
 
   return EXIT_SUCCESS;
 }