diff --git a/Modules/DiffusionImaging/MiniApps/FileFormatConverter.cpp b/Modules/DiffusionImaging/MiniApps/FileFormatConverter.cpp
index 3035f187bf..60187a5f41 100755
--- a/Modules/DiffusionImaging/MiniApps/FileFormatConverter.cpp
+++ b/Modules/DiffusionImaging/MiniApps/FileFormatConverter.cpp
@@ -1,93 +1,92 @@
 /*===================================================================
 
 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 "MiniAppManager.h"
 #include <mitkImageCast.h>
 #include <mitkDiffusionImage.h>
 #include <mitkBaseDataIOFactory.h>
 #include <mitkIOUtil.h>
 #include <mitkNrrdDiffusionImageWriter.h>
 #include <mitkFiberBundleX.h>
-#include <mitkFiberBundleXWriter.h>
 #include "ctkCommandLineParser.h"
 #include "ctkCommandLineParser.cpp"
 
 using namespace mitk;
 
 int FileFormatConverter(int argc, char* argv[])
 {
     ctkCommandLineParser parser;
 
     parser.setTitle("Format Converter");
     parser.setCategory("Fiber Tracking and Processing Methods");
     parser.setDescription("");
     parser.setContributor("MBI");
 
     parser.setArgumentPrefix("--", "-");
     parser.addArgument("in", "i", ctkCommandLineParser::InputFile, "Input:", "input file", us::Any(), false);
     parser.addArgument("out", "o", ctkCommandLineParser::OutputFile, "Output:", "output file", us::Any(), false);
 
     map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
     if (parsedArgs.size()==0)
         return EXIT_FAILURE;
 
     // mandatory arguments
     string inName = us::any_cast<string>(parsedArgs["in"]);
     string outName = us::any_cast<string>(parsedArgs["out"]);
 
     try
     {
         const std::string s1="", s2="";
         std::vector<BaseData::Pointer> infile = BaseDataIO::LoadBaseDataFromFile( inName, s1, s2, false );
         mitk::BaseData::Pointer baseData = infile.at(0);
 
         if ( dynamic_cast<DiffusionImage<short>*>(baseData.GetPointer()) )
         {
             DiffusionImage<short>::Pointer dwi = dynamic_cast<DiffusionImage<short>*>(baseData.GetPointer());
             NrrdDiffusionImageWriter<short>::Pointer writer = NrrdDiffusionImageWriter<short>::New();
             writer->SetFileName(outName);
             writer->SetInput(dwi);
             writer->Update();
         }
         else if ( dynamic_cast<Image*>(baseData.GetPointer()) )
         {
             mitk::IOUtil::Save(dynamic_cast<Image*>(baseData.GetPointer()), outName.c_str());
         }
         else if ( dynamic_cast<FiberBundleX*>(baseData.GetPointer()) )
         {
             mitk::IOUtil::Save(dynamic_cast<FiberBundleX*>(baseData.GetPointer()) ,outName.c_str());
         }
         else
             MITK_INFO << "File type currently not supported!";
     }
     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;
     }
     return EXIT_SUCCESS;
 }
 RegisterDiffusionMiniApp(FileFormatConverter);
diff --git a/Modules/DiffusionImaging/MiniApps/PeakExtraction.cpp b/Modules/DiffusionImaging/MiniApps/PeakExtraction.cpp
index 188b247c06..c1a0bbad7f 100755
--- a/Modules/DiffusionImaging/MiniApps/PeakExtraction.cpp
+++ b/Modules/DiffusionImaging/MiniApps/PeakExtraction.cpp
@@ -1,379 +1,378 @@
 /*===================================================================
 
 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 "MiniAppManager.h"
 
 #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 <mitkCoreObjectFactory.h>
 #include "ctkCommandLineParser.h"
-#include <mitkFiberBundleXWriter.h>
 #include <itkShCoefficientImageImporter.h>
 #include <itkFlipImageFilter.h>
 #include <boost/lexical_cast.hpp>
 #include <boost/algorithm/string.hpp>
 
 #include <mitkIOUtil.h>
 
 mitk::Image::Pointer LoadData(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() )
     {
         MITK_INFO << "File " << filename << " could not be read!";
         return NULL;
     }
 
     mitk::BaseData::Pointer baseData = infile.at(0);
     return dynamic_cast<mitk::Image*>(baseData.GetPointer());
 }
 
 
 template<int shOrder>
 int StartPeakExtraction(int argc, char* argv[])
 {
     MITK_INFO << "StartPeakExtraction";
     ctkCommandLineParser parser;
     parser.setArgumentPrefix("--", "-");
     parser.addArgument("image", "i", ctkCommandLineParser::InputFile, "Input image", "sh coefficient image", us::Any(), false);
     parser.addArgument("outroot", "o", ctkCommandLineParser::OutputDirectory, "Output directory", "output root", us::Any(), false);
     parser.addArgument("mask", "m", ctkCommandLineParser::InputFile, "Mask", "mask image");
     parser.addArgument("normalization", "n", ctkCommandLineParser::Int, "Normalization", "0=no norm, 1=max norm, 2=single vec norm", 1, true);
     parser.addArgument("numpeaks", "p", ctkCommandLineParser::Int, "Max. number of peaks", "maximum number of extracted peaks", 2, true);
     parser.addArgument("peakthres", "r", ctkCommandLineParser::Float, "Peak threshold", "peak threshold relative to largest peak", 0.4, true);
     parser.addArgument("abspeakthres", "a", ctkCommandLineParser::Float, "Absolute peak threshold", "absolute peak threshold weighted with local GFA value", 0.06, true);
     parser.addArgument("shConvention", "s", ctkCommandLineParser::String, "Use specified SH-basis", "use specified SH-basis (MITK, FSL, MRtrix)", string("MITK"), true);
     parser.addArgument("noFlip", "f", ctkCommandLineParser::Bool, "No flip", "do not flip input image to match MITK coordinate convention");
 
     parser.setCategory("Preprocessing Tools");
     parser.setTitle("Peak Extraction");
     parser.setDescription("");
     parser.setContributor("MBI");
 
     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["image"]);
     string outRoot = us::any_cast<string>(parsedArgs["outroot"]);
 
     // optional arguments
     string maskImageName("");
     if (parsedArgs.count("mask"))
         maskImageName = us::any_cast<string>(parsedArgs["mask"]);
 
     int normalization = 1;
     if (parsedArgs.count("normalization"))
         normalization = us::any_cast<int>(parsedArgs["normalization"]);
 
     int numPeaks = 2;
     if (parsedArgs.count("numpeaks"))
         numPeaks = us::any_cast<int>(parsedArgs["numpeaks"]);
 
     float peakThres = 0.4;
     if (parsedArgs.count("peakthres"))
         peakThres = us::any_cast<float>(parsedArgs["peakthres"]);
 
     float absPeakThres = 0.06;
     if (parsedArgs.count("abspeakthres"))
         absPeakThres = us::any_cast<float>(parsedArgs["abspeakthres"]);
 
     bool noFlip = false;
     if (parsedArgs.count("noFlip"))
         noFlip = us::any_cast<bool>(parsedArgs["noFlip"]);
 
     MITK_INFO << "image: " << imageName;
     MITK_INFO << "outroot: " << outRoot;
     if (!maskImageName.empty())
         MITK_INFO << "mask: " << maskImageName;
     else
         MITK_INFO << "no mask image selected";
     MITK_INFO << "numpeaks: " << numPeaks;
     MITK_INFO << "peakthres: " << peakThres;
     MITK_INFO << "abspeakthres: " << absPeakThres;
     MITK_INFO << "shOrder: " << shOrder;
 
     try
     {
         mitk::Image::Pointer image = LoadData(imageName);
         mitk::Image::Pointer mask = LoadData(maskImageName);
 
         typedef itk::Image<unsigned char, 3>  ItkUcharImgType;
         typedef itk::FiniteDiffOdfMaximaExtractionFilter< float, shOrder, 20242 > MaximaExtractionFilterType;
         typename MaximaExtractionFilterType::Pointer filter = MaximaExtractionFilterType::New();
 
         int toolkitConvention = 0;
 
         if (parsedArgs.count("shConvention"))
         {
             string convention = us::any_cast<string>(parsedArgs["shConvention"]).c_str();
             if ( boost::algorithm::equals(convention, "FSL") )
             {
                 toolkitConvention = 1;
                 MITK_INFO << "Using FSL SH-basis";
             }
             else if ( boost::algorithm::equals(convention, "MRtrix") )
             {
                 toolkitConvention = 2;
                 MITK_INFO << "Using MRtrix SH-basis";
             }
             else
                 MITK_INFO << "Using MITK SH-basis";
         }
         else
             MITK_INFO << "Using MITK SH-basis";
 
         ItkUcharImgType::Pointer itkMaskImage = NULL;
         if (mask.IsNotNull())
         {
             try{
                 itkMaskImage = ItkUcharImgType::New();
                 mitk::CastToItkImage(mask, itkMaskImage);
                 filter->SetMaskImage(itkMaskImage);
             }
             catch(...)
             {
 
             }
         }
 
         if (toolkitConvention>0)
         {
             MITK_INFO << "Converting coefficient image to MITK format";
             typedef itk::ShCoefficientImageImporter< float, shOrder > ConverterType;
             typedef mitk::ImageToItk< itk::Image< float, 4 > > CasterType;
             CasterType::Pointer caster = CasterType::New();
             caster->SetInput(image);
             caster->Update();
             itk::Image< float, 4 >::Pointer itkImage = caster->GetOutput();
 
             typename ConverterType::Pointer converter = ConverterType::New();
 
             if (noFlip)
             {
                 converter->SetInputImage(itkImage);
             }
             else
             {
                 MITK_INFO << "Flipping image";
                 itk::FixedArray<bool, 4> flipAxes;
                 flipAxes[0] = true;
                 flipAxes[1] = true;
                 flipAxes[2] = false;
                 flipAxes[3] = false;
                 itk::FlipImageFilter< itk::Image< float, 4 > >::Pointer flipper = itk::FlipImageFilter< itk::Image< float, 4 > >::New();
                 flipper->SetInput(itkImage);
                 flipper->SetFlipAxes(flipAxes);
                 flipper->Update();
                 itk::Image< float, 4 >::Pointer flipped = flipper->GetOutput();
                 itk::Matrix< double,4,4 > m = itkImage->GetDirection(); m[0][0] *= -1; m[1][1] *= -1;
                 flipped->SetDirection(m);
 
                 itk::Point< float, 4 > o = itkImage->GetOrigin();
                 o[0] -= (flipped->GetLargestPossibleRegion().GetSize(0)-1);
                 o[1] -= (flipped->GetLargestPossibleRegion().GetSize(1)-1);
                 flipped->SetOrigin(o);
                 converter->SetInputImage(flipped);
             }
 
             MITK_INFO << "Starting conversion";
             switch (toolkitConvention)
             {
             case 1:
                 converter->SetToolkit(ConverterType::FSL);
                 filter->SetToolkit(MaximaExtractionFilterType::FSL);
                 break;
             case 2:
                 converter->SetToolkit(ConverterType::MRTRIX);
                 filter->SetToolkit(MaximaExtractionFilterType::MRTRIX);
                 break;
             default:
                 converter->SetToolkit(ConverterType::FSL);
                 filter->SetToolkit(MaximaExtractionFilterType::FSL);
                 break;
             }
             converter->GenerateData();
             filter->SetInput(converter->GetCoefficientImage());
         }
         else
         {
             try{
                 typedef mitk::ImageToItk< typename MaximaExtractionFilterType::CoefficientImageType > CasterType;
                 typename CasterType::Pointer caster = CasterType::New();
                 caster->SetInput(image);
                 caster->Update();
                 filter->SetInput(caster->GetOutput());
             }
             catch(...)
             {
                 MITK_INFO << "wrong image type";
                 return EXIT_FAILURE;
             }
         }
 
         filter->SetMaxNumPeaks(numPeaks);
         filter->SetPeakThreshold(peakThres);
         filter->SetAbsolutePeakThreshold(absPeakThres);
         filter->SetAngularThreshold(1);
 
         switch (normalization)
         {
         case 0:
             filter->SetNormalizationMethod(MaximaExtractionFilterType::NO_NORM);
             break;
         case 1:
             filter->SetNormalizationMethod(MaximaExtractionFilterType::MAX_VEC_NORM);
             break;
         case 2:
             filter->SetNormalizationMethod(MaximaExtractionFilterType::SINGLE_VEC_NORM);
             break;
         }
 
         MITK_INFO << "Starting extraction";
         filter->Update();
 
         // write direction images
         {
             typedef typename MaximaExtractionFilterType::ItkDirectionImageContainer ItkDirectionImageContainer;
             typename ItkDirectionImageContainer::Pointer container = filter->GetDirectionImageContainer();
             for (unsigned int i=0; i<container->Size(); i++)
             {
                 typename MaximaExtractionFilterType::ItkDirectionImage::Pointer itkImg = container->GetElement(i);
 
                 if (itkMaskImage.IsNotNull())
                 {
                     itkImg->SetDirection(itkMaskImage->GetDirection());
                     itkImg->SetOrigin(itkMaskImage->GetOrigin());
                 }
 
                 string outfilename = outRoot;
                 outfilename.append("_DIRECTION_");
                 outfilename.append(boost::lexical_cast<string>(i));
                 outfilename.append(".nrrd");
 
                 typedef itk::ImageFileWriter< typename MaximaExtractionFilterType::ItkDirectionImage > WriterType;
                 typename WriterType::Pointer writer = WriterType::New();
                 writer->SetFileName(outfilename);
                 writer->SetInput(itkImg);
                 writer->Update();
             }
         }
 
         // write num directions image
         {
             ItkUcharImgType::Pointer numDirImage = filter->GetNumDirectionsImage();
 
             if (itkMaskImage.IsNotNull())
             {
                 numDirImage->SetDirection(itkMaskImage->GetDirection());
                 numDirImage->SetOrigin(itkMaskImage->GetOrigin());
             }
 
             string outfilename = outRoot.c_str();
             outfilename.append("_NUM_DIRECTIONS.nrrd");
             typedef itk::ImageFileWriter< ItkUcharImgType > WriterType;
             WriterType::Pointer writer = WriterType::New();
             writer->SetFileName(outfilename);
             writer->SetInput(numDirImage);
             writer->Update();
         }
 
         // write vector field
         {
             mitk::FiberBundleX::Pointer directions = filter->GetOutputFiberBundle();
 
             string outfilename = outRoot.c_str();
             outfilename.append("_VECTOR_FIELD.fib");
             mitk::IOUtil::Save(directions.GetPointer(),outfilename.c_str());
         }
     }
     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;
     }
     return EXIT_SUCCESS;
 }
 
 int PeakExtraction(int argc, char* argv[])
 {
     ctkCommandLineParser parser;
     parser.setArgumentPrefix("--", "-");
     parser.addArgument("image", "i", ctkCommandLineParser::InputFile, "Input image", "sh coefficient image", us::Any(), false);
     parser.addArgument("shOrder", "sh", ctkCommandLineParser::Int, "Spherical harmonics order", "spherical harmonics order");
     parser.addArgument("outroot", "o", ctkCommandLineParser::OutputDirectory, "Output directory", "output root", us::Any(), false);
     parser.addArgument("mask", "m", ctkCommandLineParser::InputFile, "Mask", "mask image");
     parser.addArgument("normalization", "n", ctkCommandLineParser::Int, "Normalization", "0=no norm, 1=max norm, 2=single vec norm", 1, true);
     parser.addArgument("numpeaks", "p", ctkCommandLineParser::Int, "Max. number of peaks", "maximum number of extracted peaks", 2, true);
     parser.addArgument("peakthres", "r", ctkCommandLineParser::Float, "Peak threshold", "peak threshold relative to largest peak", 0.4, true);
     parser.addArgument("abspeakthres", "a", ctkCommandLineParser::Float, "Absolute peak threshold", "absolute peak threshold weighted with local GFA value", 0.06, true);
     parser.addArgument("shConvention", "s", ctkCommandLineParser::String, "Use specified SH-basis", "use specified SH-basis (MITK, FSL, MRtrix)", string("MITK"), true);
     parser.addArgument("noFlip", "f", ctkCommandLineParser::Bool, "No flip", "do not flip input image to match MITK coordinate convention");
 
     parser.setCategory("Preprocessing Tools");
     parser.setTitle("Peak Extraction");
     parser.setDescription("");
     parser.setContributor("MBI");
 
     map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
     if (parsedArgs.size()==0)
         return EXIT_FAILURE;
 
 
     int shOrder = -1;
     if (parsedArgs.count("shOrder"))
         shOrder = us::any_cast<int>(parsedArgs["shOrder"]);
 
     switch (shOrder)
     {
     case 4:
         return StartPeakExtraction<4>(argc, argv);
     case 6:
         return StartPeakExtraction<6>(argc, argv);
     case 8:
         return StartPeakExtraction<8>(argc, argv);
     case 10:
         return StartPeakExtraction<10>(argc, argv);
     case 12:
         return StartPeakExtraction<12>(argc, argv);
     }
     return EXIT_FAILURE;
 }
 RegisterDiffusionMiniApp(PeakExtraction);
diff --git a/Modules/DiffusionImaging/MiniApps/StreamlineTracking.cpp b/Modules/DiffusionImaging/MiniApps/StreamlineTracking.cpp
index 4e71015370..286274fd54 100755
--- a/Modules/DiffusionImaging/MiniApps/StreamlineTracking.cpp
+++ b/Modules/DiffusionImaging/MiniApps/StreamlineTracking.cpp
@@ -1,187 +1,186 @@
 /*===================================================================
 
 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 "MiniAppManager.h"
 #include <mitkImageCast.h>
 #include <mitkTensorImage.h>
 #include <mitkIOUtil.h>
 #include <mitkBaseDataIOFactory.h>
 #include <mitkFiberBundleX.h>
 #include <itkStreamlineTrackingFilter.h>
 #include <itkDiffusionTensor3D.h>
 #include "ctkCommandLineParser.h"
 #include <mitkCoreObjectFactory.h>
-#include <mitkFiberBundleXWriter.h>
 
 int StreamlineTracking(int argc, char* argv[])
 {
     MITK_INFO << "StreamlineTracking";
     ctkCommandLineParser parser;
     parser.setArgumentPrefix("--", "-");
     parser.addArgument("input", "i", ctkCommandLineParser::StringList, "Input image", "input tensor image (.dti)", us::Any(), false);
     parser.addArgument("seed", "si", ctkCommandLineParser::InputFile, "Seed image", "binary seed image", us::Any(), true);
     parser.addArgument("mask", "mi", ctkCommandLineParser::InputFile, "Mask", "binary mask image", us::Any(), true);
     parser.addArgument("faImage", "fai", ctkCommandLineParser::InputFile, "FA image", "FA image", us::Any(), true);
     parser.addArgument("minFA", "fa", ctkCommandLineParser::Float, "Min. FA threshold", "minimum fractional anisotropy threshold", 0.15, true);
     parser.addArgument("minCurv", "c", ctkCommandLineParser::Float, "Min. curvature radius", "minimum curvature radius in mm (default = 0.5*minimum-spacing)");
     parser.addArgument("stepSize", "s", ctkCommandLineParser::Float, "Step size", "step size in mm (default = 0.1*minimum-spacing)");
     parser.addArgument("tendf", "f", ctkCommandLineParser::Float, "Weight f", "Weighting factor between first eigenvector (f=1 equals FACT tracking) and input vector dependent direction (f=0).", 1.0, true);
     parser.addArgument("tendg", "g", ctkCommandLineParser::Float, "Weight g", "Weighting factor between input vector (g=0) and tensor deflection (g=1 equals TEND tracking)", 0.0, true);
     parser.addArgument("numSeeds", "n", ctkCommandLineParser::Int, "Seeds per voxel", "Number of seeds per voxel.", 1, true);
     parser.addArgument("minLength", "l", ctkCommandLineParser::Float, "Min. fiber length", "minimum fiber length in mm", 20, true);
 
     parser.addArgument("interpolate", "ip", ctkCommandLineParser::Bool, "Interpolate", "Use linear interpolation", false, true);
     parser.addArgument("outFile", "o", ctkCommandLineParser::String, "Output file", "output fiber bundle (.fib)", us::Any(), false);
 
     parser.setCategory("Fiber Tracking and Processing Methods");
     parser.setTitle("Streamline Tracking");
     parser.setDescription("");
     parser.setContributor("MBI");
 
     map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
     if (parsedArgs.size()==0)
         return EXIT_FAILURE;
 
     ctkCommandLineParser::StringContainerType inputImages = us::any_cast<ctkCommandLineParser::StringContainerType>(parsedArgs["input"]);
     string dtiFileName;
     string outFileName = us::any_cast<string>(parsedArgs["outFile"]);
 
     float minFA = 0.15;
     float minCurv = -1;
     float stepSize = -1;
     float tendf = 1;
     float tendg = 0;
     float minLength = 20;
     int numSeeds = 1;
     bool interpolate = false;
 
     if (parsedArgs.count("minCurv"))
         minCurv = us::any_cast<float>(parsedArgs["minCurv"]);
     if (parsedArgs.count("minFA"))
         minFA = us::any_cast<float>(parsedArgs["minFA"]);
     if (parsedArgs.count("stepSize"))
         stepSize = us::any_cast<float>(parsedArgs["stepSize"]);
     if (parsedArgs.count("tendf"))
         tendf = us::any_cast<float>(parsedArgs["tendf"]);
     if (parsedArgs.count("tendg"))
         tendg = us::any_cast<float>(parsedArgs["tendg"]);
     if (parsedArgs.count("minLength"))
         minLength = us::any_cast<float>(parsedArgs["minLength"]);
     if (parsedArgs.count("numSeeds"))
         numSeeds = us::any_cast<int>(parsedArgs["numSeeds"]);
 
 
     if (parsedArgs.count("interpolate"))
         interpolate = us::any_cast<bool>(parsedArgs["interpolate"]);
 
 
 
     try
     {
         typedef itk::StreamlineTrackingFilter< float > FilterType;
         FilterType::Pointer filter = FilterType::New();
 
         mitk::Image::Pointer mitkImage = NULL;
 
         MITK_INFO << "Loading tensor images ...";
         typedef itk::Image< itk::DiffusionTensor3D<float>, 3 >    ItkTensorImage;
         dtiFileName = inputImages.at(0);
         for (unsigned int i=0; i<inputImages.size(); i++)
         {
             try
             {
                 mitkImage = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(inputImages.at(i))->GetData());
                 mitk::TensorImage::Pointer img = dynamic_cast<mitk::TensorImage*>(mitk::IOUtil::LoadDataNode(inputImages.at(i))->GetData());
                 ItkTensorImage::Pointer itk_dti = ItkTensorImage::New();
                 mitk::CastToItkImage(img, itk_dti);
                 filter->SetInput(i, itk_dti);
             }
             catch(...){ MITK_INFO << "could not load: " << inputImages.at(i); }
         }
 
         MITK_INFO << "Loading seed image ...";
         typedef itk::Image< unsigned char, 3 >    ItkUCharImageType;
         mitk::Image::Pointer mitkSeedImage = NULL;
         if (parsedArgs.count("seed"))
             mitkSeedImage = mitk::IOUtil::LoadImage(us::any_cast<string>(parsedArgs["seed"]));
 
         MITK_INFO << "Loading mask image ...";
         mitk::Image::Pointer mitkMaskImage = NULL;
         if (parsedArgs.count("mask"))
             mitkMaskImage = mitk::IOUtil::LoadImage(us::any_cast<string>(parsedArgs["mask"]));
 
         // instantiate tracker
         filter->SetSeedsPerVoxel(numSeeds);
         filter->SetFaThreshold(minFA);
         filter->SetMinCurvatureRadius(minCurv);
         filter->SetStepSize(stepSize);
         filter->SetF(tendf);
         filter->SetG(tendg);
         filter->SetInterpolate(interpolate);
         filter->SetMinTractLength(minLength);
 
         if (mitkSeedImage.IsNotNull())
         {
             ItkUCharImageType::Pointer mask = ItkUCharImageType::New();
             mitk::CastToItkImage(mitkSeedImage, mask);
             filter->SetSeedImage(mask);
         }
 
         if (mitkMaskImage.IsNotNull())
         {
             ItkUCharImageType::Pointer mask = ItkUCharImageType::New();
             mitk::CastToItkImage(mitkMaskImage, mask);
             filter->SetMaskImage(mask);
         }
 
         filter->Update();
 
         vtkSmartPointer<vtkPolyData> fiberBundle = filter->GetFiberPolyData();
         if ( fiberBundle->GetNumberOfLines()==0 )
         {
             MITK_INFO << "No fibers reconstructed. Check parametrization.";
             return EXIT_FAILURE;
         }
         mitk::FiberBundleX::Pointer fib = mitk::FiberBundleX::New(fiberBundle);
         fib->SetReferenceGeometry(mitkImage->GetGeometry());
 
         mitk::CoreObjectFactory::FileWriterList fileWriters = mitk::CoreObjectFactory::GetInstance()->GetFileWriters();
         for (mitk::CoreObjectFactory::FileWriterList::iterator it = fileWriters.begin() ; it != fileWriters.end() ; ++it)
         {
             if ( (*it)->CanWriteBaseDataType(fib.GetPointer()) ) {
                 (*it)->SetFileName( outFileName.c_str() );
                 (*it)->DoWrite( fib.GetPointer() );
             }
         }
     }
     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;
     }
     return EXIT_SUCCESS;
 }
 RegisterDiffusionMiniApp(StreamlineTracking);