diff --git a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/TensorImages/mitkNrrdTensorImageReader.cpp b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/TensorImages/mitkNrrdTensorImageReader.cpp
index d0ec59a1ac..6a7a366e84 100644
--- a/Modules/DiffusionImaging/DiffusionCore/IODataStructures/TensorImages/mitkNrrdTensorImageReader.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/IODataStructures/TensorImages/mitkNrrdTensorImageReader.cpp
@@ -1,291 +1,326 @@
 /*===================================================================
 
 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 "mitkNrrdTensorImageReader.h"
 
 #include "itkImageFileReader.h"
 #include "itkImageRegionIterator.h"
 #include "itkMetaDataObject.h"
 #include "itkNrrdImageIO.h"
 
 
 #include "mitkITKImageImport.h"
 #include "mitkImageDataItem.h"
 
 namespace mitk
 {
 
-  void NrrdTensorImageReader
-    ::GenerateData()
-  {
+void NrrdTensorImageReader
+::GenerateData()
+{
     if ( m_FileName == "")
     {
-      throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, the filename is empty!");
+        throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, the filename is empty!");
     }
     else
     {
-      try
-      {
-        const std::string& locale = "C";
-        const std::string& currLocale = setlocale( LC_ALL, NULL );
-
-        if ( locale.compare(currLocale)!=0 )
+        try
         {
-          try
-          {
-            setlocale(LC_ALL, locale.c_str());
-          }
-          catch(...)
-          {
-            MITK_INFO << "Could not set locale " << locale;
-          }
-        }
+            const std::string& locale = "C";
+            const std::string& currLocale = setlocale( LC_ALL, NULL );
 
-        typedef itk::VectorImage<float,3> ImageType;
-        itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
-        typedef itk::ImageFileReader<ImageType> FileReaderType;
-        FileReaderType::Pointer reader = FileReaderType::New();
-        reader->SetImageIO(io);
-        reader->SetFileName(this->m_FileName);
-        reader->Update();
-        ImageType::Pointer img = reader->GetOutput();
-
-        typedef itk::Image<itk::DiffusionTensor3D<float>,3> VecImgType;
-        VecImgType::Pointer vecImg = VecImgType::New();
-        vecImg->SetSpacing( img->GetSpacing() );   // Set the image spacing
-        vecImg->SetOrigin( img->GetOrigin() );     // Set the image origin
-        vecImg->SetDirection( img->GetDirection() );  // Set the image direction
-        vecImg->SetRegions( img->GetLargestPossibleRegion());
-        vecImg->Allocate();
-
-        itk::ImageRegionIterator<VecImgType> ot (vecImg, vecImg->GetLargestPossibleRegion() );
-        ot = ot.Begin();
-
-        itk::ImageRegionIterator<ImageType> it (img, img->GetLargestPossibleRegion() );
-        it = it.Begin();
-
-        typedef ImageType::PixelType  VarPixType;
-        typedef VecImgType::PixelType FixPixType;
-        int numComponents = img->GetNumberOfComponentsPerPixel();
-
-        itk::MetaDataDictionary imgMetaDictionary = img->GetMetaDataDictionary();
-        std::vector<std::string> imgMetaKeys = imgMetaDictionary.GetKeys();
-        std::vector<std::string>::const_iterator itKey = imgMetaKeys.begin();
-        std::string metaString;
-
-        bool readFrame = false;
-        double xx, xy, xz, yx, yy, yz, zx, zy, zz;
-        MeasurementFrameType measFrame;
-        measFrame.SetIdentity();
-        MeasurementFrameType measFrameTransp;
-        measFrameTransp.SetIdentity();
-
-        for (; itKey != imgMetaKeys.end(); itKey ++)
-        {
-          itk::ExposeMetaData<std::string> (imgMetaDictionary, *itKey, metaString);
-          if (itKey->find("measurement frame") != std::string::npos)
-          {
-            sscanf(metaString.c_str(), " ( %lf , %lf , %lf ) ( %lf , %lf , %lf ) ( %lf , %lf , %lf ) \n", &xx, &xy, &xz, &yx, &yy, &yz, &zx, &zy, &zz);
-
-            if (xx>10e-10 || xy>10e-10 || xz>10e-10 ||
-                yx>10e-10 || yy>10e-10 || yz>10e-10 ||
-                zx>10e-10 || zy>10e-10 || zz>10e-10 )
+            if ( locale.compare(currLocale)!=0 )
             {
-              readFrame = true;
-
-              measFrame(0,0) = xx;
-              measFrame(0,1) = xy;
-              measFrame(0,2) = xz;
-              measFrame(1,0) = yx;
-              measFrame(1,1) = yy;
-              measFrame(1,2) = yz;
-              measFrame(2,0) = zx;
-              measFrame(2,1) = zy;
-              measFrame(2,2) = zz;
-
-              measFrameTransp = measFrame.GetTranspose();
+                try
+                {
+                    setlocale(LC_ALL, locale.c_str());
+                }
+                catch(...)
+                {
+                    MITK_INFO << "Could not set locale " << locale;
+                }
             }
-          }
-        }
-
-        if (numComponents==6)
-        {
-          while (!it.IsAtEnd())
-          {
-            // T'=RTR'
-            VarPixType vec = it.Get();
-            FixPixType fixVec(vec.GetDataPointer());
 
-            if(readFrame)
+            MITK_INFO << "Loading tensor image ...";
+
+            typedef itk::VectorImage<float,3> ImageType;
+            itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
+            typedef itk::ImageFileReader<ImageType> FileReaderType;
+            FileReaderType::Pointer reader = FileReaderType::New();
+            reader->SetImageIO(io);
+            reader->SetFileName(this->m_FileName);
+            reader->Update();
+            ImageType::Pointer img = reader->GetOutput();
+
+            typedef itk::Image<itk::DiffusionTensor3D<float>,3> VecImgType;
+            VecImgType::Pointer vecImg = VecImgType::New();
+            vecImg->SetSpacing( img->GetSpacing() );   // Set the image spacing
+            vecImg->SetOrigin( img->GetOrigin() );     // Set the image origin
+            vecImg->SetDirection( img->GetDirection() );  // Set the image direction
+            vecImg->SetRegions( img->GetLargestPossibleRegion());
+            vecImg->Allocate();
+
+            itk::ImageRegionIterator<VecImgType> ot (vecImg, vecImg->GetLargestPossibleRegion() );
+            ot = ot.Begin();
+
+            itk::ImageRegionIterator<ImageType> it (img, img->GetLargestPossibleRegion() );
+            it = it.Begin();
+
+            typedef ImageType::PixelType  VarPixType;
+            typedef VecImgType::PixelType FixPixType;
+            int numComponents = img->GetNumberOfComponentsPerPixel();
+
+            itk::MetaDataDictionary imgMetaDictionary = img->GetMetaDataDictionary();
+            std::vector<std::string> imgMetaKeys = imgMetaDictionary.GetKeys();
+            std::vector<std::string>::const_iterator itKey = imgMetaKeys.begin();
+            std::string metaString;
+
+            bool readFrame = false;
+            double xx, xy, xz, yx, yy, yz, zx, zy, zz;
+            MeasurementFrameType measFrame;
+            measFrame.SetIdentity();
+            MeasurementFrameType measFrameTransp;
+            measFrameTransp.SetIdentity();
+
+            for (; itKey != imgMetaKeys.end(); itKey ++)
             {
-              itk::DiffusionTensor3D<float> tensor;
-              tensor.SetElement(0, vec.GetElement(0));
-              tensor.SetElement(1, vec.GetElement(1));
-              tensor.SetElement(2, vec.GetElement(2));
-              tensor.SetElement(3, vec.GetElement(3));
-              tensor.SetElement(4, vec.GetElement(4));
-              tensor.SetElement(5, vec.GetElement(5));
-
-              tensor = ConvertMatrixTypeToFixedArrayType(tensor.PreMultiply(measFrame));
-              tensor = ConvertMatrixTypeToFixedArrayType(tensor.PostMultiply(measFrameTransp));
-              fixVec = tensor;
+                itk::ExposeMetaData<std::string> (imgMetaDictionary, *itKey, metaString);
+                if (itKey->find("measurement frame") != std::string::npos)
+                {
+                    sscanf(metaString.c_str(), " ( %lf , %lf , %lf ) ( %lf , %lf , %lf ) ( %lf , %lf , %lf ) \n", &xx, &xy, &xz, &yx, &yy, &yz, &zx, &zy, &zz);
+
+                    if (xx>10e-10 || xy>10e-10 || xz>10e-10 ||
+                            yx>10e-10 || yy>10e-10 || yz>10e-10 ||
+                            zx>10e-10 || zy>10e-10 || zz>10e-10 )
+                    {
+                        readFrame = true;
+
+                        measFrame(0,0) = xx;
+                        measFrame(0,1) = xy;
+                        measFrame(0,2) = xz;
+                        measFrame(1,0) = yx;
+                        measFrame(1,1) = yy;
+                        measFrame(1,2) = yz;
+                        measFrame(2,0) = zx;
+                        measFrame(2,1) = zy;
+                        measFrame(2,2) = zz;
+
+                        measFrameTransp = measFrame.GetTranspose();
+                    }
+                }
             }
 
-            ot.Set(fixVec);
-            ++ot;
-            ++it;
-          }
-        }
-        else if(numComponents==9)
-        {
-          while (!it.IsAtEnd())
-          {
-            VarPixType vec = it.Get();
-            itk::DiffusionTensor3D<float> tensor;
-            tensor.SetElement(0, vec.GetElement(0));
-            tensor.SetElement(1, vec.GetElement(1));
-            tensor.SetElement(2, vec.GetElement(2));
-            tensor.SetElement(3, vec.GetElement(4));
-            tensor.SetElement(4, vec.GetElement(5));
-            tensor.SetElement(5, vec.GetElement(8));
-
-            if(readFrame)
+            if (numComponents==6)
+            {
+                while (!it.IsAtEnd())
+                {
+                    // T'=RTR'
+                    VarPixType vec = it.Get();
+                    FixPixType fixVec(vec.GetDataPointer());
+
+                    if(readFrame)
+                    {
+                        itk::DiffusionTensor3D<float> tensor;
+                        tensor.SetElement(0, vec.GetElement(0));
+                        tensor.SetElement(1, vec.GetElement(1));
+                        tensor.SetElement(2, vec.GetElement(2));
+                        tensor.SetElement(3, vec.GetElement(3));
+                        tensor.SetElement(4, vec.GetElement(4));
+                        tensor.SetElement(5, vec.GetElement(5));
+
+                        tensor = ConvertMatrixTypeToFixedArrayType(tensor.PreMultiply(measFrame));
+                        tensor = ConvertMatrixTypeToFixedArrayType(tensor.PostMultiply(measFrameTransp));
+                        fixVec = tensor;
+                    }
+
+                    ot.Set(fixVec);
+                    ++ot;
+                    ++it;
+                }
+            }
+            else if(numComponents==9)
+            {
+                while (!it.IsAtEnd())
+                {
+                    VarPixType vec = it.Get();
+                    itk::DiffusionTensor3D<float> tensor;
+                    tensor.SetElement(0, vec.GetElement(0));
+                    tensor.SetElement(1, vec.GetElement(1));
+                    tensor.SetElement(2, vec.GetElement(2));
+                    tensor.SetElement(3, vec.GetElement(4));
+                    tensor.SetElement(4, vec.GetElement(5));
+                    tensor.SetElement(5, vec.GetElement(8));
+
+                    if(readFrame)
+                    {
+                        tensor = ConvertMatrixTypeToFixedArrayType(tensor.PreMultiply(measFrame));
+                        tensor = ConvertMatrixTypeToFixedArrayType(tensor.PostMultiply(measFrameTransp));
+                    }
+
+                    FixPixType fixVec(tensor);
+                    ot.Set(fixVec);
+                    ++ot;
+                    ++it;
+                }
+            }
+            else if (numComponents==1)
             {
-              tensor = ConvertMatrixTypeToFixedArrayType(tensor.PreMultiply(measFrame));
-              tensor = ConvertMatrixTypeToFixedArrayType(tensor.PostMultiply(measFrameTransp));
+                typedef itk::Image<float,4> ImageType;
+                itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
+                typedef itk::ImageFileReader<ImageType> FileReaderType;
+                FileReaderType::Pointer reader = FileReaderType::New();
+                reader->SetImageIO(io);
+                reader->SetFileName(this->m_FileName);
+                reader->Update();
+                ImageType::Pointer img = reader->GetOutput();
+
+                itk::Size<4> size = img->GetLargestPossibleRegion().GetSize();
+
+                while (!ot.IsAtEnd())
+                {
+                    itk::DiffusionTensor3D<float> tensor;
+                    ImageType::IndexType idx;
+                    idx[0] = ot.GetIndex()[0]; idx[1] = ot.GetIndex()[1]; idx[2] = ot.GetIndex()[2];
+                    for (int te=0; te<size[3]; te++)
+                    {
+                        idx[3] = te;
+                        tensor.SetElement(te, img->GetPixel(idx));
+                    }
+                    if(readFrame)
+                    {
+                        tensor = ConvertMatrixTypeToFixedArrayType(tensor.PreMultiply(measFrame));
+                        tensor = ConvertMatrixTypeToFixedArrayType(tensor.PostMultiply(measFrameTransp));
+                    }
+                    FixPixType fixVec(tensor);
+                    ot.Set(fixVec);
+                    ++ot;
+                }
+            }
+            else
+            {
+                throw itk::ImageFileReaderException(__FILE__, __LINE__, "Image has wrong number of pixel components!");
             }
 
-            FixPixType fixVec(tensor);
-            ot.Set(fixVec);
-            ++ot;
-            ++it;
-          }
-        }
-        else
-        {
-          throw itk::ImageFileReaderException(__FILE__, __LINE__, "Image has wrong number of pixel components!");
-        }
+            this->GetOutput()->InitializeByItk(vecImg.GetPointer());
+            this->GetOutput()->SetVolume(vecImg->GetBufferPointer());
 
-        this->GetOutput()->InitializeByItk(vecImg.GetPointer());
-        this->GetOutput()->SetVolume(vecImg->GetBufferPointer());
+            try
+            {
+                setlocale(LC_ALL, currLocale.c_str());
+            }
+            catch(...)
+            {
+                MITK_INFO << "Could not reset locale " << currLocale;
+            }
 
-        try
+        }
+        catch(std::exception& e)
         {
-          setlocale(LC_ALL, currLocale.c_str());
+            throw itk::ImageFileReaderException(__FILE__, __LINE__, e.what());
         }
         catch(...)
         {
-          MITK_INFO << "Could not reset locale " << currLocale;
+            throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, an error occurred while reading the requested DTI file!");
         }
-
-      }
-      catch(std::exception& e)
-      {
-        throw itk::ImageFileReaderException(__FILE__, __LINE__, e.what());
-      }
-      catch(...)
-      {
-        throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, an error occurred while reading the requested DTI file!");
-      }
     }
-  }
+}
 
-  void NrrdTensorImageReader::GenerateOutputInformation()
-  {
+void NrrdTensorImageReader::GenerateOutputInformation()
+{
 
-  }
+}
 
 
 
-  const char* NrrdTensorImageReader
-    ::GetFileName() const
-  {
+const char* NrrdTensorImageReader
+::GetFileName() const
+{
     return m_FileName.c_str();
-  }
+}
 
 
-  void NrrdTensorImageReader
-    ::SetFileName(const char* aFileName)
-  {
+void NrrdTensorImageReader
+::SetFileName(const char* aFileName)
+{
     m_FileName = aFileName;
-  }
+}
 
 
-  const char* NrrdTensorImageReader
-    ::GetFilePrefix() const
-  {
+const char* NrrdTensorImageReader
+::GetFilePrefix() const
+{
     return m_FilePrefix.c_str();
-  }
+}
 
 
-  void NrrdTensorImageReader
-    ::SetFilePrefix(const char* aFilePrefix)
-  {
+void NrrdTensorImageReader
+::SetFilePrefix(const char* aFilePrefix)
+{
     m_FilePrefix = aFilePrefix;
-  }
+}
 
 
-  const char* NrrdTensorImageReader
-    ::GetFilePattern() const
-  {
+const char* NrrdTensorImageReader
+::GetFilePattern() const
+{
     return m_FilePattern.c_str();
-  }
+}
 
 
-  void NrrdTensorImageReader
-    ::SetFilePattern(const char* aFilePattern)
-  {
+void NrrdTensorImageReader
+::SetFilePattern(const char* aFilePattern)
+{
     m_FilePattern = aFilePattern;
-  }
+}
 
 
-  bool NrrdTensorImageReader
-    ::CanReadFile(const std::string filename, const std::string /*filePrefix*/, const std::string /*filePattern*/)
-  {
+bool NrrdTensorImageReader
+::CanReadFile(const std::string filename, const std::string /*filePrefix*/, const std::string /*filePattern*/)
+{
     // First check the extension
     if(  filename == "" )
     {
-      return false;
+        return false;
     }
     std::string ext = itksys::SystemTools::GetFilenameLastExtension(filename);
     ext = itksys::SystemTools::LowerCase(ext);
 
     if (ext == ".hdti" || ext == ".dti")
     {
-      return true;
+        return true;
     }
 
     return false;
-  }
+}
 
-  itk::DiffusionTensor3D<float> NrrdTensorImageReader
-    ::ConvertMatrixTypeToFixedArrayType(const itk::DiffusionTensor3D<float>::Superclass::MatrixType & matrix)
-  {
-     /*       | 0  1  2  |
+itk::DiffusionTensor3D<float> NrrdTensorImageReader
+::ConvertMatrixTypeToFixedArrayType(const itk::DiffusionTensor3D<float>::Superclass::MatrixType & matrix)
+{
+    /*       | 0  1  2  |
       *       | X  3  4  |
       *       | X  X  5  |
       */
     itk::DiffusionTensor3D<float> arr;
     arr.SetElement(0,matrix(0,0));
     arr.SetElement(1,matrix(0,1));
     arr.SetElement(2,matrix(0,2));
     arr.SetElement(3,matrix(1,3));
     arr.SetElement(4,matrix(1,4));
     arr.SetElement(5,matrix(2,5));
     return arr;
-  }
+}
 
 } //namespace MITK
diff --git a/Modules/DiffusionImaging/FiberTracking/MiniApps/CMakeLists.txt b/Modules/DiffusionImaging/FiberTracking/MiniApps/CMakeLists.txt
index 2dc0803dc4..0828ba2dd0 100755
--- a/Modules/DiffusionImaging/FiberTracking/MiniApps/CMakeLists.txt
+++ b/Modules/DiffusionImaging/FiberTracking/MiniApps/CMakeLists.txt
@@ -1,53 +1,54 @@
 OPTION(BUILD_FiberTrackingMiniApps "Build commandline tools for fiber tracking" OFF)
 
 IF(BUILD_FiberTrackingMiniApps)
 
   # include necessary modules here MitkExt QmitkExt
   MITK_CHECK_MODULE(_RESULT DiffusionCore FiberTracking )
   IF(_RESULT)
     MESSAGE("Warning: FiberTrackingMiniApps is missing ${_RESULT}")
   ELSE(_RESULT)
   MITK_USE_MODULE( DiffusionCore FiberTracking )
 
   # needed include directories
   INCLUDE_DIRECTORIES(
     ${CMAKE_CURRENT_SOURCE_DIR}
     ${CMAKE_CURRENT_BINARY_DIR}
     ${ALL_INCLUDE_DIRECTORIES})
 
   PROJECT( mitkFiberTrackingMiniApps )
 
   # fill in the standalone executables here
   SET(FIBERTRACKINGMINIAPPS
     mitkFiberTrackingMiniApps
   )
 
   # set additional files here
   SET(FIBERTRACKING_ADDITIONAL_FILES
     MiniAppManager.cpp
     GibbsTracking.cpp
     StreamlineTracking.cpp
     FiberProcessing.cpp
     PeakExtraction.cpp
     TractometerAngularErrorTool.cpp
     TractogramAngularError.cpp
     FiberDirectionExtraction.cpp
+    ImageFormatConverter.cpp
   )
 
   # create an executable foreach tool (only one at the moment)
   FOREACH(tool ${FIBERTRACKINGMINIAPPS})
     ADD_EXECUTABLE(
     ${tool}
     ${tool}.cpp
     ${FIBERTRACKING_ADDITIONAL_FILES}
     )
 
     TARGET_LINK_LIBRARIES(
       ${tool}
       ${ALL_LIBRARIES} )
   ENDFOREACH(tool)
   ENDIF()
 
   MITK_INSTALL_TARGETS(EXECUTABLES mitkFiberTrackingMiniApps )
 
 ENDIF(BUILD_FiberTrackingMiniApps)
diff --git a/Modules/DiffusionImaging/FiberTracking/MiniApps/ImageFormatConverter.cpp b/Modules/DiffusionImaging/FiberTracking/MiniApps/ImageFormatConverter.cpp
new file mode 100755
index 0000000000..0b0d1fb97e
--- /dev/null
+++ b/Modules/DiffusionImaging/FiberTracking/MiniApps/ImageFormatConverter.cpp
@@ -0,0 +1,84 @@
+/*===================================================================
+
+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 <mitkDiffusionCoreObjectFactory.h>
+#include <mitkIOUtil.h>
+#include <mitkNrrdDiffusionImageWriter.h>
+
+using namespace mitk;
+#include "ctkCommandLineParser.h"
+
+int ImageFormatConverter(int argc, char* argv[])
+{
+    ctkCommandLineParser parser;
+    parser.setArgumentPrefix("--", "-");
+    parser.addArgument("in", "i", ctkCommandLineParser::String, "input image", mitk::Any(), false);
+    parser.addArgument("out", "o", ctkCommandLineParser::String, "output image", mitk::Any(), false);
+
+    map<string, mitk::Any> parsedArgs = parser.parseArguments(argc, argv);
+    if (parsedArgs.size()==0)
+        return EXIT_FAILURE;
+
+    // mandatory arguments
+    string imageName = mitk::any_cast<string>(parsedArgs["in"]);
+    string outImage = mitk::any_cast<string>(parsedArgs["out"]);
+
+    try
+    {
+        RegisterDiffusionCoreObjectFactory();
+
+        MITK_INFO << "Loading image ...";
+        const std::string s1="", s2="";
+        std::vector<BaseData::Pointer> infile = BaseDataIO::LoadBaseDataFromFile( imageName, s1, s2, false );
+
+        MITK_INFO << "Writing " << outImage;
+        if ( dynamic_cast<DiffusionImage<short>*>(infile.at(0).GetPointer()) )
+        {
+            DiffusionImage<short>::Pointer dwi = dynamic_cast<DiffusionImage<short>*>(infile.at(0).GetPointer());
+            NrrdDiffusionImageWriter<short>::Pointer writer = NrrdDiffusionImageWriter<short>::New();
+            writer->SetFileName(outImage);
+            writer->SetInput(dwi);
+            writer->Update();
+        }
+        else if ( dynamic_cast<Image*>(infile.at(0).GetPointer()) )
+        {
+            Image::Pointer image = dynamic_cast<Image*>(infile.at(0).GetPointer());
+            mitk::IOUtil::SaveImage(image, outImage);
+        }
+    }
+    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_INFO << "DONE";
+    return EXIT_SUCCESS;
+}
+RegisterFiberTrackingMiniApp(ImageFormatConverter);
diff --git a/Modules/DiffusionImaging/FiberTracking/MiniApps/TractometerAngularErrorTool.cpp b/Modules/DiffusionImaging/FiberTracking/MiniApps/TractometerAngularErrorTool.cpp
index c93777a355..78297e6f0c 100755
--- a/Modules/DiffusionImaging/FiberTracking/MiniApps/TractometerAngularErrorTool.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/MiniApps/TractometerAngularErrorTool.cpp
@@ -1,264 +1,264 @@
 /*===================================================================
 
 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 <mitkBaseDataIOFactory.h>
 #include <mitkBaseData.h>
 #include <mitkImageCast.h>
 #include <mitkImageToItk.h>
 #include <mitkDiffusionCoreObjectFactory.h>
 #include <mitkFiberTrackingObjectFactory.h>
 #include <itkEvaluateDirectionImagesFilter.h>
 #include <metaCommand.h>
 #include "ctkCommandLineParser.h"
 #include "ctkCommandLineParser.cpp"
 #include <itkTractsToVectorImageFilter.h>
 #include <mitkAny.h>
 #include <itkImageFileWriter.h>
 #include <mitkIOUtil.h>
 #include <boost/lexical_cast.hpp>
 #include <iostream>
 #include <fstream>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 int TractometerAngularErrorTool(int argc, char* argv[])
 {
     ctkCommandLineParser parser;
     parser.setArgumentPrefix("--", "-");
     parser.addArgument("input", "i", ctkCommandLineParser::String, "input tractogram (.fib, vtk ascii file format)", mitk::Any(), false);
     parser.addArgument("reference", "r", ctkCommandLineParser::StringList, "reference direction images", mitk::Any(), false);
     parser.addArgument("out", "o", ctkCommandLineParser::String, "output root", mitk::Any(), false);
     parser.addArgument("mask", "m", ctkCommandLineParser::String, "mask image");
     parser.addArgument("athresh", "a", ctkCommandLineParser::Float, "angular threshold in degrees. closer fiber directions are regarded as one direction and clustered together.", 25, true);
     parser.addArgument("verbose", "v", ctkCommandLineParser::Bool, "output optional and intermediate calculation results");
     parser.addArgument("ignore", "n", ctkCommandLineParser::Bool, "don't increase error for missing or too many directions");
 
     map<string, mitk::Any> parsedArgs = parser.parseArguments(argc, argv);
     if (parsedArgs.size()==0)
         return EXIT_FAILURE;
 
     ctkCommandLineParser::StringContainerType referenceImages = mitk::any_cast<ctkCommandLineParser::StringContainerType>(parsedArgs["reference"]);
 
     string fibFile = mitk::any_cast<string>(parsedArgs["input"]);
 
     string maskImage("");
     if (parsedArgs.count("mask"))
         maskImage = mitk::any_cast<string>(parsedArgs["mask"]);
 
     float angularThreshold = 25;
     if (parsedArgs.count("athresh"))
         angularThreshold = mitk::any_cast<float>(parsedArgs["athresh"]);
 
     string outRoot = mitk::any_cast<string>(parsedArgs["out"]);
 
     bool verbose = false;
     if (parsedArgs.count("verbose"))
         verbose = mitk::any_cast<bool>(parsedArgs["verbose"]);
 
     bool ignore = false;
     if (parsedArgs.count("ignore"))
         ignore = mitk::any_cast<bool>(parsedArgs["ignore"]);
 
     try
     {
         RegisterDiffusionCoreObjectFactory();
         RegisterFiberTrackingObjectFactory();
 
         typedef itk::Image<unsigned char, 3>                                    ItkUcharImgType;
         typedef itk::Image< itk::Vector< float, 3>, 3 >                         ItkDirectionImage3DType;
         typedef itk::VectorContainer< int, ItkDirectionImage3DType::Pointer >   ItkDirectionImageContainerType;
         typedef itk::EvaluateDirectionImagesFilter< float >                     EvaluationFilterType;
 
         // load fiber bundle
         mitk::FiberBundleX::Pointer inputTractogram = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(fibFile)->GetData());
 
         // load reference directions
         ItkDirectionImageContainerType::Pointer referenceImageContainer = ItkDirectionImageContainerType::New();
         for (int i=0; i<referenceImages.size(); i++)
         {
             try
             {
                 mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(referenceImages.at(i))->GetData());
                 typedef mitk::ImageToItk< ItkDirectionImage3DType > CasterType;
                 CasterType::Pointer caster = CasterType::New();
                 caster->SetInput(img);
                 caster->Update();
                 ItkDirectionImage3DType::Pointer itkImg = caster->GetOutput();
                 referenceImageContainer->InsertElement(referenceImageContainer->Size(),itkImg);
             }
             catch(...){ MITK_INFO << "could not load: " << referenceImages.at(i); }
         }
 
         // load/create mask image
         ItkUcharImgType::Pointer itkMaskImage = ItkUcharImgType::New();
         if (maskImage.compare("")==0)
         {
             ItkDirectionImage3DType::Pointer dirImg = referenceImageContainer->GetElement(0);
             itkMaskImage->SetSpacing( dirImg->GetSpacing() );
             itkMaskImage->SetOrigin( dirImg->GetOrigin() );
             itkMaskImage->SetDirection( dirImg->GetDirection() );
             itkMaskImage->SetLargestPossibleRegion( dirImg->GetLargestPossibleRegion() );
             itkMaskImage->SetBufferedRegion( dirImg->GetLargestPossibleRegion() );
             itkMaskImage->SetRequestedRegion( dirImg->GetLargestPossibleRegion() );
             itkMaskImage->Allocate();
             itkMaskImage->FillBuffer(1);
         }
         else
         {
             mitk::Image::Pointer mitkMaskImage = dynamic_cast<mitk::Image*>(mitk::IOUtil::LoadDataNode(maskImage)->GetData());
             mitk::CastToItkImage<ItkUcharImgType>(mitkMaskImage, itkMaskImage);
         }
 
 
         // extract directions from fiber bundle
-        itk::TractsToVectorImageFilter::Pointer fOdfFilter = itk::TractsToVectorImageFilter::New();
+        itk::TractsToVectorImageFilter<float>::Pointer fOdfFilter = itk::TractsToVectorImageFilter<float>::New();
         fOdfFilter->SetFiberBundle(inputTractogram);
         fOdfFilter->SetMaskImage(itkMaskImage);
         fOdfFilter->SetAngularThreshold(cos(angularThreshold*M_PI/180));
         fOdfFilter->SetNormalizeVectors(true);
         fOdfFilter->SetUseWorkingCopy(false);
         fOdfFilter->Update();
         ItkDirectionImageContainerType::Pointer directionImageContainer = fOdfFilter->GetDirectionImageContainer();
 
         if (verbose)
         {
             // write vector field
             mitk::FiberBundleX::Pointer directions = fOdfFilter->GetOutputFiberBundle();
             mitk::CoreObjectFactory::FileWriterList fileWriters = mitk::CoreObjectFactory::GetInstance()->GetFileWriters();
             for (mitk::CoreObjectFactory::FileWriterList::iterator it = fileWriters.begin() ; it != fileWriters.end() ; ++it)
             {
                 if ( (*it)->CanWriteBaseDataType(directions.GetPointer()) ) {
                     string outfilename = outRoot;
                     outfilename.append("_VECTOR_FIELD.fib");
                     (*it)->SetFileName( outfilename.c_str() );
                     (*it)->DoWrite( directions.GetPointer() );
                 }
             }
 
             // write direction images
             for (int i=0; i<directionImageContainer->Size(); i++)
             {
-                itk::TractsToVectorImageFilter::ItkDirectionImageType::Pointer itkImg = directionImageContainer->GetElement(i);
-                typedef itk::ImageFileWriter< itk::TractsToVectorImageFilter::ItkDirectionImageType > WriterType;
+                itk::TractsToVectorImageFilter<float>::ItkDirectionImageType::Pointer itkImg = directionImageContainer->GetElement(i);
+                typedef itk::ImageFileWriter< itk::TractsToVectorImageFilter<float>::ItkDirectionImageType > WriterType;
                 WriterType::Pointer writer = WriterType::New();
 
                 string outfilename = outRoot;
                 outfilename.append("_DIRECTION_");
                 outfilename.append(boost::lexical_cast<string>(i));
                 outfilename.append(".nrrd");
 
                 MITK_INFO << "writing " << outfilename;
                 writer->SetFileName(outfilename.c_str());
                 writer->SetInput(itkImg);
                 writer->Update();
             }
 
             // write num direction image
             {
                 ItkUcharImgType::Pointer numDirImage = fOdfFilter->GetNumDirectionsImage();
                 typedef itk::ImageFileWriter< ItkUcharImgType > WriterType;
                 WriterType::Pointer writer = WriterType::New();
 
                 string outfilename = outRoot;
                 outfilename.append("_NUM_DIRECTIONS.nrrd");
 
                 MITK_INFO << "writing " << outfilename;
                 writer->SetFileName(outfilename.c_str());
                 writer->SetInput(numDirImage);
                 writer->Update();
             }
         }
 
         // evaluate directions
         EvaluationFilterType::Pointer evaluationFilter = EvaluationFilterType::New();
         evaluationFilter->SetImageSet(directionImageContainer);
         evaluationFilter->SetReferenceImageSet(referenceImageContainer);
         evaluationFilter->SetMaskImage(itkMaskImage);
         evaluationFilter->SetIgnoreMissingDirections(ignore);
         evaluationFilter->Update();
 
         if (verbose)
         {
             EvaluationFilterType::OutputImageType::Pointer angularErrorImage = evaluationFilter->GetOutput(0);
             typedef itk::ImageFileWriter< EvaluationFilterType::OutputImageType > WriterType;
             WriterType::Pointer writer = WriterType::New();
 
             string outfilename = outRoot;
             outfilename.append("_ERROR_IMAGE.nrrd");
 
             MITK_INFO << "writing " << outfilename;
             writer->SetFileName(outfilename.c_str());
             writer->SetInput(angularErrorImage);
             writer->Update();
         }
 
         string logFile = outRoot;
         logFile.append("_ANGULAR_ERROR.csv");
 
         ofstream file;
         file.open (logFile.c_str());
 
         string sens = "Mean:";
         sens.append(",");
         sens.append(boost::lexical_cast<string>(evaluationFilter->GetMeanAngularError()));
         sens.append(";\n");
 
         sens.append("Median:");
         sens.append(",");
         sens.append(boost::lexical_cast<string>(evaluationFilter->GetMedianAngularError()));
         sens.append(";\n");
 
         sens.append("Maximum:");
         sens.append(",");
         sens.append(boost::lexical_cast<string>(evaluationFilter->GetMaxAngularError()));
         sens.append(";\n");
 
         sens.append("Minimum:");
         sens.append(",");
         sens.append(boost::lexical_cast<string>(evaluationFilter->GetMinAngularError()));
         sens.append(";\n");
 
         sens.append("STDEV:");
         sens.append(",");
         sens.append(boost::lexical_cast<string>(std::sqrt(evaluationFilter->GetVarAngularError())));
         sens.append(";\n");
 
         file << sens;
 
         file.close();
 
         MITK_INFO << "DONE";
     }
     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;
 }
 RegisterFiberTrackingMiniApp(TractometerAngularErrorTool);