diff --git a/Modules/DiffusionImaging/DiffusionCmdApps/TractographyEvaluation/CMakeLists.txt b/Modules/DiffusionImaging/DiffusionCmdApps/TractographyEvaluation/CMakeLists.txt
index 5c191af76b..4328bcc7be 100755
--- a/Modules/DiffusionImaging/DiffusionCmdApps/TractographyEvaluation/CMakeLists.txt
+++ b/Modules/DiffusionImaging/DiffusionCmdApps/TractographyEvaluation/CMakeLists.txt
@@ -1,47 +1,46 @@
 option(BUILD_DiffusionTractographyEvaluationCmdApps "Build commandline tools for diffusion fiber tractography evaluation" OFF)
 
 if(BUILD_DiffusionTractographyEvaluationCmdApps OR MITK_BUILD_ALL_APPS)
 
   # needed include directories
   include_directories(
     ${CMAKE_CURRENT_SOURCE_DIR}
     ${CMAKE_CURRENT_BINARY_DIR}
     )
 
     # list of diffusion cmdapps
     # if an app requires additional dependencies
     # they are added after a "^^" and separated by "_"
     set( diffusionTractographyEvaluationcmdapps
     PeaksAngularError^^
-    TractometerMetrics^^
     MergeOverlappingTracts^^
     GetOverlappingTracts^^
     ExtractSimilarTracts^^
     AnchorConstrainedPlausibility^^
     CalculateOverlap^^
     CheckEpsAndOverlap^^
     ReferenceSimilarity^^
     TractDistance^^
     )
 
     foreach(diffusionTractographyEvaluationcmdapp ${diffusionTractographyEvaluationcmdapps})
       # extract cmd app name and dependencies
       string(REPLACE "^^" "\\;" cmdapp_info ${diffusionTractographyEvaluationcmdapp})
       set(cmdapp_info_list ${cmdapp_info})
       list(GET cmdapp_info_list 0 appname)
       list(GET cmdapp_info_list 1 raw_dependencies)
       string(REPLACE "_" "\\;" dependencies "${raw_dependencies}")
       set(dependencies_list ${dependencies})
 
       mitkFunctionCreateCommandLineApp(
         NAME ${appname}
         DEPENDS MitkDiffusionCmdApps ${dependencies_list}
         PACKAGE_DEPENDS
       )
     endforeach()
 
   if(EXECUTABLE_IS_ENABLED)
     MITK_INSTALL_TARGETS(EXECUTABLES ${EXECUTABLE_TARGET})
   endif()
 
   endif()
diff --git a/Modules/DiffusionImaging/DiffusionCmdApps/TractographyEvaluation/ExtractSimilarTracts.cpp b/Modules/DiffusionImaging/DiffusionCmdApps/TractographyEvaluation/ExtractSimilarTracts.cpp
index 9895f4bf97..4faf7202be 100644
--- a/Modules/DiffusionImaging/DiffusionCmdApps/TractographyEvaluation/ExtractSimilarTracts.cpp
+++ b/Modules/DiffusionImaging/DiffusionCmdApps/TractographyEvaluation/ExtractSimilarTracts.cpp
@@ -1,196 +1,196 @@
 /*===================================================================
 
 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 <mitkFiberBundle.h>
 #include <mitkCommandLineParser.h>
 #include <mitkLexicalCast.h>
 #include <mitkIOUtil.h>
 #include <itkTractClusteringFilter.h>
 #include <mitkClusteringMetricEuclideanMean.h>
 #include <mitkClusteringMetricEuclideanMax.h>
 #include <mitkClusteringMetricEuclideanStd.h>
 #include <mitkClusteringMetricAnatomic.h>
 #include <mitkClusteringMetricScalarMap.h>
 #include <mitkDiffusionDataIOHelper.h>
 
 typedef itk::Image<unsigned char, 3>    ItkFloatImgType;
 
 /*!
 \brief Spatially cluster fibers
 */
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
 
   parser.setTitle("Extract Similar Tracts");
   parser.setCategory("Fiber Tracking Evaluation");
   parser.setContributor("MIC");
 
   parser.setArgumentPrefix("--", "-");
   parser.addArgument("", "i", mitkCommandLineParser::InputFile, "Input:", "input fiber bundle (.fib, .trk, .tck)", us::Any(), false);
   parser.addArgument("ref_tracts", "", mitkCommandLineParser::StringList, "Ref. Tracts:", "reference tracts (.fib, .trk, .tck)", us::Any(), false);
   parser.addArgument("ref_masks", "", mitkCommandLineParser::StringList, "Ref. Masks:", "reference bundle masks", us::Any());
 
   parser.addArgument("", "o", mitkCommandLineParser::OutputDirectory, "Output:", "output root", us::Any(), false);
   parser.addArgument("distance", "", mitkCommandLineParser::Int, "Distance:", "", 10);
   parser.addArgument("metric", "", mitkCommandLineParser::String, "Metric:", "EU_MEAN (default), EU_STD, EU_MAX");
   parser.addArgument("subsample", "", mitkCommandLineParser::Float, "Subsampling factor:", "Only use specified fraction of input fibers", 1.0);
 
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0)
     return EXIT_FAILURE;
 
   std::string in_fib = us::any_cast<std::string>(parsedArgs["i"]);
   std::string out_root = us::any_cast<std::string>(parsedArgs["o"]);
   mitkCommandLineParser::StringContainerType ref_bundle_files = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["ref_tracts"]);
   mitkCommandLineParser::StringContainerType ref_mask_files;
   if (parsedArgs.count("ref_masks"))
     ref_mask_files = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["ref_masks"]);
 
   if (ref_mask_files.size()>0 && ref_mask_files.size()!=ref_bundle_files.size())
   {
     MITK_INFO << "If reference masks are used, there has to be one mask per reference tract.";
     return EXIT_FAILURE;
   }
 
   int distance = 10;
   if (parsedArgs.count("distance"))
     distance = us::any_cast<int>(parsedArgs["distance"]);
 
   std::string metric = "EU_MEAN";
   if (parsedArgs.count("metric"))
     metric = us::any_cast<std::string>(parsedArgs["metric"]);
 
   float subsample = 1.0;
   if (parsedArgs.count("subsample"))
     subsample = us::any_cast<float>(parsedArgs["subsample"]);
 
   try
   {
     mitk::FiberBundle::Pointer fib = mitk::IOUtil::Load<mitk::FiberBundle>(in_fib);
 
     std::srand(0);
-    if (subsample<1.0)
+    if (subsample<1.0f)
       fib = fib->SubsampleFibers(subsample, true);
 
     mitk::FiberBundle::Pointer resampled_fib = fib->GetDeepCopy();
     resampled_fib->ResampleToNumPoints(12);
 
     auto ref_fibs = mitk::DiffusionDataIOHelper::load_fibs(ref_bundle_files);
     auto ref_masks = mitk::DiffusionDataIOHelper::load_itk_images<ItkFloatImgType>(ref_mask_files);
 
     std::vector< float > distances;
     distances.push_back(distance);
 
     mitk::FiberBundle::Pointer extracted = mitk::FiberBundle::New(nullptr);
     unsigned int c = 0;
     for (auto ref_fib : ref_fibs)
     {
       MITK_INFO << "Extracting " << ist::GetFilenameName(ref_bundle_files.at(c));
 
       std::streambuf *old = cout.rdbuf(); // <-- save
       std::stringstream ss;
       std::cout.rdbuf (ss.rdbuf());       // <-- redirect
       try
       {
         itk::TractClusteringFilter::Pointer segmenter = itk::TractClusteringFilter::New();
 
         // calculate centroids from reference bundle
         {
           itk::TractClusteringFilter::Pointer clusterer = itk::TractClusteringFilter::New();
           clusterer->SetDistances({10,20,30});
           clusterer->SetTractogram(ref_fib);
           clusterer->SetMetrics({new mitk::ClusteringMetricEuclideanStd()});
           clusterer->SetMergeDuplicateThreshold(0.0);
           clusterer->Update();
           std::vector<mitk::FiberBundle::Pointer> tracts = clusterer->GetOutCentroids();
           ref_fib = mitk::FiberBundle::New(nullptr);
           ref_fib = ref_fib->AddBundles(tracts);
           mitk::IOUtil::Save(ref_fib, out_root + "centroids_" + ist::GetFilenameName(ref_bundle_files.at(c)));
           segmenter->SetInCentroids(ref_fib);
         }
 
         // segment tract
         segmenter->SetFilterMask(ref_masks.at(c));
-        segmenter->SetOverlapThreshold(0.8);
+        segmenter->SetOverlapThreshold(0.8f);
         segmenter->SetDistances(distances);
         segmenter->SetTractogram(resampled_fib);
         segmenter->SetMergeDuplicateThreshold(0.0);
         segmenter->SetDoResampling(false);
         if (metric=="EU_MEAN")
           segmenter->SetMetrics({new mitk::ClusteringMetricEuclideanMean()});
         else if (metric=="EU_STD")
           segmenter->SetMetrics({new mitk::ClusteringMetricEuclideanStd()});
         else if (metric=="EU_MAX")
           segmenter->SetMetrics({new mitk::ClusteringMetricEuclideanMax()});
         segmenter->Update();
 
         std::vector< std::vector< long > > clusters = segmenter->GetOutFiberIndices();
         if (clusters.size()>0)
         {
           vtkSmartPointer<vtkFloatArray> weights = vtkSmartPointer<vtkFloatArray>::New();
 
           mitk::FiberBundle::Pointer result = mitk::FiberBundle::New(nullptr);
           std::vector< mitk::FiberBundle::Pointer > result_fibs;
           for (unsigned int cluster_index=0; cluster_index<clusters.size()-1; ++cluster_index)
             result_fibs.push_back(mitk::FiberBundle::New(fib->GeneratePolyDataByIds(clusters.at(cluster_index), weights)));
           result = result->AddBundles(result_fibs);
 
           extracted = extracted->AddBundle(result);
           mitk::IOUtil::Save(result, out_root + "extracted_" + ist::GetFilenameName(ref_bundle_files.at(c)));
 
           fib = mitk::FiberBundle::New(fib->GeneratePolyDataByIds(clusters.back(), weights));
           resampled_fib = mitk::FiberBundle::New(resampled_fib->GeneratePolyDataByIds(clusters.back(), weights));
         }
       }
       catch(itk::ExceptionObject& excpt)
       {
         MITK_INFO << "Exception while processing " << ist::GetFilenameName(ref_bundle_files.at(c));
         MITK_INFO << excpt.GetDescription();
       }
       catch(std::exception& excpt)
       {
         MITK_INFO << "Exception while processing " << ist::GetFilenameName(ref_bundle_files.at(c));
         MITK_INFO << excpt.what();
       }
       std::cout.rdbuf (old);              // <-- restore
       if (fib->GetNumFibers()==0)
         break;
       ++c;
     }
     MITK_INFO << "Extracted streamlines: " << extracted->GetNumFibers();
     mitk::IOUtil::Save(extracted, out_root + "extracted_streamlines.trk");
 
     MITK_INFO << "Residual streamlines: " << fib->GetNumFibers();
     mitk::IOUtil::Save(fib, out_root + "residual_streamlines.trk");
   }
   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/DiffusionCmdApps/TractographyEvaluation/GetOverlappingTracts.cpp b/Modules/DiffusionImaging/DiffusionCmdApps/TractographyEvaluation/GetOverlappingTracts.cpp
index b2b2148bd6..3469ad361c 100755
--- a/Modules/DiffusionImaging/DiffusionCmdApps/TractographyEvaluation/GetOverlappingTracts.cpp
+++ b/Modules/DiffusionImaging/DiffusionCmdApps/TractographyEvaluation/GetOverlappingTracts.cpp
@@ -1,171 +1,167 @@
 /*===================================================================
 
 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 <metaCommand.h>
 #include "mitkCommandLineParser.h"
 #include <usAny.h>
 #include <mitkIOUtil.h>
 #include <mitkLexicalCast.h>
 #include <mitkCoreObjectFactory.h>
 #include <mitkFiberBundle.h>
 #include <mitkImageCast.h>
 #include <mitkImageToItk.h>
 #include <itksys/SystemTools.hxx>
 #include <itkTractDensityImageFilter.h>
+#include <mitkDiffusionDataIOHelper.h>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 typedef itksys::SystemTools ist;
 typedef itk::Image<unsigned char, 3>    ItkFloatImgType;
 
 /*!
 \brief Extract fibers from a tractogram using binary image ROIs
 */
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
 
   parser.setTitle("Get Overlapping Tracts");
   parser.setCategory("Fiber Tracking and Processing Methods");
   parser.setContributor("MIC");
   parser.setDescription("Find tracts that overlap with the reference masks or tracts");
 
   parser.setArgumentPrefix("--", "-");
   parser.addArgument("", "i", mitkCommandLineParser::StringList, "Input:", "input tractograms (.fib/.trk/.tck/.dcm)", us::Any(), false);
   parser.addArgument("", "o", mitkCommandLineParser::OutputDirectory, "Output Folder:", "move input tracts that do/don't overlap here", us::Any(), false);
   parser.addArgument("reference", "", mitkCommandLineParser::StringList, "Reference:", "reference tractograms or mask images", us::Any(), false);
 
   parser.addArgument("overlap_fraction", "", mitkCommandLineParser::Float, "Overlap fraction:", "", 0.9);
   parser.addArgument("use_any_overlap", "", mitkCommandLineParser::Bool, "Use any overlap:", "Don't find maximum overlap but use first overlap larger threshold");
   parser.addArgument("dont_save_tracts", "", mitkCommandLineParser::Bool, "Don't save tracts:", "if true, only text files documenting the overlaps are saved and no tract files are copied");
 
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0)
     return EXIT_FAILURE;
 
   mitkCommandLineParser::StringContainerType input = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["i"]);
   mitkCommandLineParser::StringContainerType reference = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["reference"]);
 
   std::string out_folder = us::any_cast<std::string>(parsedArgs["o"]);
 
   bool use_any_overlap = false;
   if (parsedArgs.count("use_any_overlap"))
     use_any_overlap = us::any_cast<bool>(parsedArgs["use_any_overlap"]);
 
   bool dont_save_tracts = false;
   if (parsedArgs.count("dont_save_tracts"))
     dont_save_tracts = us::any_cast<bool>(parsedArgs["dont_save_tracts"]);
 
   float overlap_threshold = 0.9;
   if (parsedArgs.count("overlap_fraction"))
     overlap_threshold = us::any_cast<float>(parsedArgs["overlap_fraction"]);
 
   try
   {
+    MITK_INFO << "Loading references";
+    std::vector< std::string > reference_names;
+    auto masks = mitk::DiffusionDataIOHelper::load_itk_images<ItkFloatImgType>(reference, &reference_names);
+    auto reference_fibs = mitk::DiffusionDataIOHelper::load_fibs(reference, &reference_names);
+
+    std::streambuf *old = cout.rdbuf(); // <-- save
+    std::stringstream ss;
+    std::cout.rdbuf (ss.rdbuf());       // <-- redirect
     itk::TractDensityImageFilter< ItkFloatImgType >::Pointer filter = itk::TractDensityImageFilter< ItkFloatImgType >::New();
     filter->SetUpsamplingFactor(0.25);
     filter->SetBinaryOutput(true);
-    MITK_INFO << "Loading references";
-    std::vector< ItkFloatImgType::Pointer > masks;
-    for (auto f : reference)
+    for (auto fib : reference_fibs)
     {
-      MITK_INFO << f;
-      std::streambuf *old = cout.rdbuf(); // <-- save
-      std::stringstream ss;
-      std::cout.rdbuf (ss.rdbuf());       // <-- redirect
-      mitk::FiberBundle::Pointer fib = mitk::IOUtil::Load<mitk::FiberBundle>(f);
-      if (fib.IsNotNull())
-      {
         filter->SetFiberBundle(fib);
         filter->Update();
         masks.push_back(filter->GetOutput());
-      }
-      else
-      {
-        mitk::Image::Pointer m = mitk::IOUtil::Load<mitk::Image>(f);
-        ItkFloatImgType::Pointer itkImage = ItkFloatImgType::New();
-        CastToItkImage(m, itkImage);
-        masks.push_back(itkImage);
-      }
-      std::cout.rdbuf (old);              // <-- restore
     }
+    std::cout.rdbuf (old);              // <-- restore
+
+    MITK_INFO << "Loading input tractograms";
+    std::vector< std::string > input_names;
+    auto input_fibs = mitk::DiffusionDataIOHelper::load_fibs(input, &input_names);
 
     MITK_INFO << "Finding overlaps";
     ofstream logfile;
     logfile.open (out_folder + "Overlaps.txt");
 
     ofstream logfile2;
     logfile2.open (out_folder + "AllOverlaps.txt");
 
     boost::progress_display disp(input.size());
-    for (auto f : input)
+    unsigned int c = 0;
+    for (auto fib : input_fibs)
     {
       ++disp;
       std::streambuf *old = cout.rdbuf(); // <-- save
       std::stringstream ss;
       std::cout.rdbuf (ss.rdbuf());       // <-- redirect
       bool is_overlapping = false;
-      mitk::FiberBundle::Pointer fib = mitk::IOUtil::Load<mitk::FiberBundle>(f);
-
       float overlap = 0;
       float max_overlap = 0;
       std::string max_ref = "-";
       int i = 0;
-      std::string overlap_string = ist::GetFilenameWithoutExtension(f);
+      std::string overlap_string = ist::GetFilenameWithoutExtension(input_names.at(c));
       for (auto m : masks)
       {
         overlap = fib->GetOverlap(m);
         if (overlap>max_overlap)
         {
           max_overlap = overlap;
-          max_ref = ist::GetFilenameWithoutExtension(reference.at(i));
+          max_ref = ist::GetFilenameWithoutExtension(reference_names.at(i));
         }
         if (use_any_overlap && overlap>=overlap_threshold)
           break;
-        overlap_string += " " + ist::GetFilenameWithoutExtension(reference.at(i)) + " " + boost::lexical_cast<std::string>(overlap);
+        overlap_string += " " + ist::GetFilenameWithoutExtension(reference_names.at(i)) + " " + boost::lexical_cast<std::string>(overlap);
         ++i;
       }
       if (overlap>=overlap_threshold)
         is_overlapping = true;
 
-      logfile << ist::GetFilenameWithoutExtension(f) << " - " << max_ref << ": " << boost::lexical_cast<std::string>(max_overlap) << "\n";
+      logfile << ist::GetFilenameWithoutExtension(input_names.at(c)) << " - " << max_ref << ": " << boost::lexical_cast<std::string>(max_overlap) << "\n";
       logfile2 << overlap_string << "\n";
 
       if (!dont_save_tracts && is_overlapping)
-        ist::CopyAFile(f, out_folder + ist::GetFilenameName(f));
+        ist::CopyAFile(input_names.at(c), out_folder + ist::GetFilenameName(input_names.at(c)));
       std::cout.rdbuf (old);              // <-- restore
+      ++c;
     }
     logfile.close();
     logfile2.close();
   }
   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/DiffusionCmdApps/TractographyEvaluation/MergeOverlappingTracts.cpp b/Modules/DiffusionImaging/DiffusionCmdApps/TractographyEvaluation/MergeOverlappingTracts.cpp
index 7f0424fa7f..0f9fb0d226 100755
--- a/Modules/DiffusionImaging/DiffusionCmdApps/TractographyEvaluation/MergeOverlappingTracts.cpp
+++ b/Modules/DiffusionImaging/DiffusionCmdApps/TractographyEvaluation/MergeOverlappingTracts.cpp
@@ -1,214 +1,214 @@
 /*===================================================================
 
 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 <mitkBaseData.h>
 #include <mitkImageCast.h>
 #include <mitkImageToItk.h>
 #include <metaCommand.h>
 #include <mitkCommandLineParser.h>
 #include <usAny.h>
 #include <mitkIOUtil.h>
 #include <mitkLexicalCast.h>
 #include <mitkFiberBundle.h>
 #include <vtkTransformPolyDataFilter.h>
 #include <fstream>
 #include <chrono>
 #include <boost/progress.hpp>
 #include <itkTractsToFiberEndingsImageFilter.h>
 #include <itkTractDensityImageFilter.h>
 #include <itkImageRegionConstIterator.h>
 #include <mitkDiffusionDataIOHelper.h>
 
 typedef itk::Image<unsigned char, 3>    ItkFloatImgType;
 typedef itk::Image<unsigned int, 3>    ItkUIntImgType;
 
 
 /*!
 \brief
 */
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
 
   parser.setTitle("Merge Overlapping Tracts");
   parser.setCategory("Fiber Tracking Evaluation");
   parser.setDescription("");
   parser.setContributor("MIC");
 
   parser.setArgumentPrefix("--", "-");
-  parser.addArgument("", "i", mitkCommandLineParser::InputFile, "Input Folder:", "input folder", us::Any(), false);
+  parser.addArgument("", "i", mitkCommandLineParser::StringList, "Input:", "input tracts", us::Any(), false);
   parser.addArgument("", "o", mitkCommandLineParser::OutputDirectory, "Output Folder:", "output folder", us::Any(), false);
   parser.addArgument("overlap", "", mitkCommandLineParser::Float, "Overlap threshold:", "Tracts with overlap larger than this threshold are merged", 0.8, false);
 
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0)
     return EXIT_FAILURE;
 
-  std::string input_folder = us::any_cast<std::string>(parsedArgs["i"]);
+  mitkCommandLineParser::StringContainerType input_folder = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["i"]);
   std::string out_folder = us::any_cast<std::string>(parsedArgs["o"]);
 
   float overlap = 0.8;
   if (parsedArgs.count("overlap"))
     overlap = us::any_cast<float>(parsedArgs["overlap"]);
 
   try
   {
     if (!ist::PathExists(out_folder))
       ist::MakeDirectory(out_folder);
 
-    std::vector< mitk::FiberBundle::Pointer > fibs = mitk::DiffusionDataIOHelper::load_fibs({input_folder});
+    std::vector< mitk::FiberBundle::Pointer > fibs = mitk::DiffusionDataIOHelper::load_fibs(input_folder);
 
 
     std::streambuf *old = cout.rdbuf(); // <-- save
     std::stringstream ss;
     std::cout.rdbuf (ss.rdbuf());       // <-- redirect
 
     mitk::FiberBundle::Pointer combined = mitk::FiberBundle::New();
     combined = combined->AddBundles(fibs);
 
     itk::TractsToFiberEndingsImageFilter< ItkFloatImgType >::Pointer endings = itk::TractsToFiberEndingsImageFilter< ItkFloatImgType >::New();
     endings->SetFiberBundle(combined);
     endings->SetUpsamplingFactor(0.25);
     endings->Update();
     ItkFloatImgType::Pointer ref_image = endings->GetOutput();
 
     std::cout.rdbuf (old);              // <-- restore
 
     for (int its = 0; its<3; its++)
     {
       std::streambuf *old = cout.rdbuf(); // <-- save
       std::stringstream ss;
       std::cout.rdbuf (ss.rdbuf());       // <-- redirect
 
       std::vector< ItkFloatImgType::Pointer > mask_images;
       for (auto fib : fibs)
       {
         itk::TractDensityImageFilter< ItkFloatImgType >::Pointer masks = itk::TractDensityImageFilter< ItkFloatImgType >::New();
         masks->SetInputImage(ref_image);
         masks->SetBinaryOutput(true);
         masks->SetFiberBundle(fib);
         masks->SetUseImageGeometry(true);
         masks->Update();
         mask_images.push_back(masks->GetOutput());
       }
 
       int r=0;
       vnl_matrix< int > mat; mat.set_size(mask_images.size(), mask_images.size()); mat.fill(0);
       for (auto m1 : mask_images)
       {
         float max_overlap = overlap;
         int c = 0;
         for (auto m2 : mask_images)
         {
           if (c<=r)
           {
             ++c;
             continue;
           }
 
           itk::ImageRegionConstIterator<ItkFloatImgType> it1(m1, m1->GetLargestPossibleRegion());
           itk::ImageRegionConstIterator<ItkFloatImgType> it2(m2, m2->GetLargestPossibleRegion());
 
           unsigned int c1 = 0;
           unsigned int c2 = 0;
           unsigned int intersect = 0;
           while( !it1.IsAtEnd() )
           {
             if( it1.Get()>0 && it2.Get()>0)
               ++intersect;
             if(it1.Get()>0)
               ++c1;
             if(it2.Get()>0)
               ++c2;
             ++it1;
             ++it2;
           }
 
           if ( (float)intersect/c1>max_overlap )
           {
             max_overlap = (float)intersect/c1;
             mat.put(r,c, 1);
           }
           if ( (float)intersect/c2>max_overlap )
           {
             max_overlap = (float)intersect/c2;
             mat.put(r,c, 1);
           }
           ++c;
         }
 
         ++r;
       }
 
       std::vector< mitk::FiberBundle::Pointer > out_fibs;
       std::vector< bool > used;
       for (unsigned int i=0; i<fibs.size(); i++)
         used.push_back(false);
       for (unsigned int r=0; r<mask_images.size(); r++)
       {
         if (used.at(r))
           continue;
 
         mitk::FiberBundle::Pointer fib = fibs.at(r);
         for (unsigned int c=r+1; c<mask_images.size(); c++)
         {
           if (mat.get(r,c)>0)
           {
             fib = fib->AddBundle(fibs.at(c));
             used[c] = true;
           }
         }
 
         out_fibs.push_back(fib);
       }
       std::cout.rdbuf (old);              // <-- restore
 
       MITK_INFO << fibs.size() << " --> " << out_fibs.size();
 
       if (fibs.size()==out_fibs.size())
         break;
       fibs = out_fibs;
     }
 
     int c = 0;
     for (auto fib : fibs)
     {
       std::streambuf *old = cout.rdbuf(); // <-- save
       std::stringstream ss;
       std::cout.rdbuf (ss.rdbuf());       // <-- redirect
       mitk::IOUtil::Save(fib, out_folder + "/bundle_" + boost::lexical_cast<std::string>(c) + ".trk");
       std::cout.rdbuf (old);              // <-- restore
 
       ++c;
     }
   }
   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/DiffusionCmdApps/TractographyEvaluation/TractDistance.cpp b/Modules/DiffusionImaging/DiffusionCmdApps/TractographyEvaluation/TractDistance.cpp
index df0bcd6e9e..fa14cd0340 100644
--- a/Modules/DiffusionImaging/DiffusionCmdApps/TractographyEvaluation/TractDistance.cpp
+++ b/Modules/DiffusionImaging/DiffusionCmdApps/TractographyEvaluation/TractDistance.cpp
@@ -1,139 +1,139 @@
 /*===================================================================
 
 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 <mitkFiberBundle.h>
 #include <mitkCommandLineParser.h>
 #include <mitkLexicalCast.h>
 #include <mitkIOUtil.h>
 #include <itkTractDistanceFilter.h>
 #include <mitkClusteringMetricEuclideanMean.h>
 #include <mitkClusteringMetricEuclideanMax.h>
 #include <mitkClusteringMetricEuclideanStd.h>
 #include <mitkDiffusionDataIOHelper.h>
 
 
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
 
   parser.setTitle("Tract Distance");
   parser.setCategory("Fiber Processing");
   parser.setContributor("MIC");
 
   parser.setArgumentPrefix("--", "-");
-  parser.addArgument("", "i1", mitkCommandLineParser::String, "Input Folder 1:", "input tracts folder 1", us::Any(), false);
-  parser.addArgument("", "i2", mitkCommandLineParser::String, "Input Folder 2:", "input tracts folder 2", us::Any(), false);
+  parser.addArgument("", "i1", mitkCommandLineParser::StringList, "Input tracts 1:", "input tracts 1", us::Any(), false);
+  parser.addArgument("", "i2", mitkCommandLineParser::StringList, "Input tracts 2:", "input tracts 2", us::Any(), false);
   parser.addArgument("", "o", mitkCommandLineParser::String, "Output:", "output logfile", us::Any(), false);
 
   parser.addArgument("fiber_points", "", mitkCommandLineParser::Int, "Fiber points:", "", 12);
   parser.addArgument("metrics", "", mitkCommandLineParser::StringList, "Metrics:", "EU_MEAN (default), EU_STD, EU_MAX");
   parser.addArgument("metric_weights", "", mitkCommandLineParser::StringList, "Metric weights:", "add one float weight for each used metric");
 
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0)
     return EXIT_FAILURE;
 
-  std::string t1_folder = us::any_cast<std::string>(parsedArgs["i1"]);
-  std::string t2_folder = us::any_cast<std::string>(parsedArgs["i2"]);
+  mitkCommandLineParser::StringContainerType t1_folder = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["i1"]);
+  mitkCommandLineParser::StringContainerType t2_folder = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["i2"]);
   std::string out_file = us::any_cast<std::string>(parsedArgs["o"]);
 
   int fiber_points = 12;
   if (parsedArgs.count("fiber_points"))
     fiber_points = us::any_cast<int>(parsedArgs["fiber_points"]);
 
   std::vector< std::string > metric_strings = {"EU_MEAN"};
   if (parsedArgs.count("metrics"))
     metric_strings = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["metrics"]);
 
   std::vector< std::string > metric_weights = {"1.0"};
   if (parsedArgs.count("metric_weights"))
     metric_weights = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["metric_weights"]);
 
   if (metric_strings.size()!=metric_weights.size())
   {
     MITK_INFO << "Each metric needs an associated metric weight!";
     return EXIT_FAILURE;
   }
 
   try
   {
     std::vector<std::string> t1_files;
-    std::vector< mitk::FiberBundle::Pointer > tractograms1 = mitk::DiffusionDataIOHelper::load_fibs({t1_folder}, &t1_files);
+    std::vector< mitk::FiberBundle::Pointer > tractograms1 = mitk::DiffusionDataIOHelper::load_fibs(t1_folder, &t1_files);
     std::vector<std::string> t2_files;
-    std::vector< mitk::FiberBundle::Pointer > tractograms2 = mitk::DiffusionDataIOHelper::load_fibs({t2_folder}, &t2_files);
+    std::vector< mitk::FiberBundle::Pointer > tractograms2 = mitk::DiffusionDataIOHelper::load_fibs(t2_folder, &t2_files);
 
     MITK_INFO << "Loaded " << tractograms1.size() << " source tractograms.";
     MITK_INFO << "Loaded " << tractograms2.size() << " target tractograms.";
 
     itk::TractDistanceFilter::Pointer distance_calculator = itk::TractDistanceFilter::New();
     distance_calculator->SetNumPoints(fiber_points);
     distance_calculator->SetTracts1(tractograms1);
     distance_calculator->SetTracts2(tractograms2);
 
     std::vector< mitk::ClusteringMetric* > metrics;
     int mc = 0;
     for (auto m : metric_strings)
     {
       float w = boost::lexical_cast<float>(metric_weights.at(mc));
       MITK_INFO << "Metric: " << m << " (w=" << w << ")";
       if (m=="EU_MEAN")
         metrics.push_back({new mitk::ClusteringMetricEuclideanMean()});
       else if (m=="EU_STD")
         metrics.push_back({new mitk::ClusteringMetricEuclideanStd()});
       else if (m=="EU_MAX")
         metrics.push_back({new mitk::ClusteringMetricEuclideanMax()});
       metrics.back()->SetScale(w);
       mc++;
     }
 
     if (metrics.empty())
     {
       MITK_INFO << "No metric selected!";
       return EXIT_FAILURE;
     }
 
     distance_calculator->SetMetrics(metrics);
     distance_calculator->Update();
     MITK_INFO << "Distances:";
     auto distances = distance_calculator->GetMinDistances();
     auto indices = distance_calculator->GetMinIndices();
 
     ofstream logfile;
     logfile.open (out_file);
     for (unsigned int i=0; i<distances.size(); ++i)
     {
       std::cout << ist::GetFilenameWithoutExtension(t1_files.at(i)) << " << " << ist::GetFilenameWithoutExtension(t2_files.at(indices[i])) << ": " << distances[i] << std::endl;
       logfile << ist::GetFilenameWithoutExtension(t1_files.at(i)) << " " << ist::GetFilenameWithoutExtension(t2_files.at(indices[i])) << " " << distances[i] << std::endl;
     }
     logfile.close();
   }
   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/DiffusionCmdApps/TractographyEvaluation/TractometerMetrics.cpp b/Modules/DiffusionImaging/DiffusionCmdApps/TractographyEvaluation/TractometerMetrics.cpp
deleted file mode 100755
index 43bc3d3550..0000000000
--- a/Modules/DiffusionImaging/DiffusionCmdApps/TractographyEvaluation/TractometerMetrics.cpp
+++ /dev/null
@@ -1,412 +0,0 @@
-/*===================================================================
-
-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 <mitkBaseData.h>
-#include <mitkImageCast.h>
-#include <mitkImageToItk.h>
-#include <itkEvaluateDirectionImagesFilter.h>
-#include <metaCommand.h>
-#include "mitkCommandLineParser.h"
-#include <itkTractsToVectorImageFilter.h>
-#include <usAny.h>
-#include <itkImageFileWriter.h>
-#include <mitkIOUtil.h>
-#include <mitkLexicalCast.h>
-#include <iostream>
-#include <fstream>
-#include <itksys/SystemTools.hxx>
-#include <mitkCoreObjectFactory.h>
-#include <mitkLocaleSwitch.h>
-
-#define _USE_MATH_DEFINES
-#include <math.h>
-
-/*!
-\brief Calculates the Tractometer evaluation metrics for tractograms (http://www.tractometer.org/)
-*/
-int main(int argc, char* argv[])
-{
-  mitkCommandLineParser parser;
-
-  parser.setTitle("Tractometer Metrics");
-  parser.setCategory("Fiber Tracking Evaluation");
-  parser.setDescription("Calculates the Tractometer evaluation metrics for tractograms (http://www.tractometer.org/)");
-  parser.setContributor("MIC");
-
-  parser.setArgumentPrefix("--", "-");
-  parser.addArgument("", "i", mitkCommandLineParser::InputFile, "Input:", "input tractogram", us::Any(), false);
-  parser.addArgument("", "o", mitkCommandLineParser::OutputDirectory, "Output:", "output root", us::Any(), false);
-  parser.addArgument("labels", "l", mitkCommandLineParser::StringList, "Label pairs:", "label pairs", false);
-  parser.addArgument("labelimage", "li", mitkCommandLineParser::String, "Label image:", "label image", false);
-  parser.addArgument("verbose", "v", mitkCommandLineParser::Bool, "Verbose:", "output valid, invalid and no connections as fiber bundles");
-  parser.addArgument("fileID", "id", mitkCommandLineParser::String, "ID:", "optional ID field");
-
-  std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
-  if (parsedArgs.size()==0)
-    return EXIT_FAILURE;
-
-  mitkCommandLineParser::StringContainerType labelpairs = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["labels"]);
-
-  std::string fibFile = us::any_cast<std::string>(parsedArgs["i"]);
-  std::string labelImageFile = us::any_cast<std::string>(parsedArgs["labelimage"]);
-
-  std::string outRoot = us::any_cast<std::string>(parsedArgs["o"]);
-
-  std::string fileID = "";
-  if (parsedArgs.count("fileID"))
-    fileID = us::any_cast<std::string>(parsedArgs["fileID"]);
-
-  bool verbose = false;
-  if (parsedArgs.count("verbose"))
-    verbose = us::any_cast<bool>(parsedArgs["verbose"]);
-
-  try
-  {
-    typedef itk::Image<short, 3>    ItkShortImgType;
-    typedef itk::Image<unsigned char, 3>    ItkUcharImgType;
-
-    // load fiber bundle
-    mitk::FiberBundle::Pointer inputTractogram = mitk::IOUtil::Load<mitk::FiberBundle>(fibFile);
-
-    mitk::Image::Pointer img = mitk::IOUtil::Load<mitk::Image>(labelImageFile);
-    typedef mitk::ImageToItk< ItkShortImgType > CasterType;
-    CasterType::Pointer caster = CasterType::New();
-    caster->SetInput(img);
-    caster->Update();
-    ItkShortImgType::Pointer labelImage = caster->GetOutput();
-
-    std::string path = itksys::SystemTools::GetFilenamePath(labelImageFile);
-
-    std::vector< bool > detected;
-    std::vector< std::pair< int, int > > labelsvector;
-    std::vector< ItkUcharImgType::Pointer > bundleMasks;
-    std::vector< ItkUcharImgType::Pointer > bundleMasksCoverage;
-    short max = 0;
-    for (unsigned int i=0; i<labelpairs.size()-1; i+=2)
-    {
-      std::pair< short, short > l;
-      l.first = boost::lexical_cast<short>(labelpairs.at(i));
-      l.second = boost::lexical_cast<short>(labelpairs.at(i+1));
-      std::cout << labelpairs.at(i);
-      std::cout << labelpairs.at(i+1);
-      if (l.first>max)
-        max=l.first;
-      if (l.second>max)
-        max=l.second;
-
-      labelsvector.push_back(l);
-      detected.push_back(false);
-
-      {
-        mitk::Image::Pointer img = mitk::IOUtil::Load<mitk::Image>(path+"/Bundle"+boost::lexical_cast<std::string>(labelsvector.size())+"_MASK.nrrd");
-        typedef mitk::ImageToItk< ItkUcharImgType > CasterType;
-        CasterType::Pointer caster = CasterType::New();
-        caster->SetInput(img);
-        caster->Update();
-        ItkUcharImgType::Pointer bundle = caster->GetOutput();
-        bundleMasks.push_back(bundle);
-      }
-
-      {
-        mitk::Image::Pointer img = mitk::IOUtil::Load<mitk::Image>(path+"/Bundle"+boost::lexical_cast<std::string>(labelsvector.size())+"_MASK_COVERAGE.nrrd");
-        typedef mitk::ImageToItk< ItkUcharImgType > CasterType;
-        CasterType::Pointer caster = CasterType::New();
-        caster->SetInput(img);
-        caster->Update();
-        ItkUcharImgType::Pointer bundle = caster->GetOutput();
-        bundleMasksCoverage.push_back(bundle);
-      }
-    }
-    vnl_matrix< unsigned char > matrix; matrix.set_size(max, max); matrix.fill(0);
-
-    vtkSmartPointer<vtkPolyData> polyData = inputTractogram->GetFiberPolyData();
-
-    int validConnections = 0;
-    int noConnection = 0;
-    int validBundles = 0;
-    int invalidBundles = 0;
-    int invalidConnections = 0;
-
-    ItkUcharImgType::Pointer coverage = ItkUcharImgType::New();
-    coverage->SetSpacing(labelImage->GetSpacing());
-    coverage->SetOrigin(labelImage->GetOrigin());
-    coverage->SetDirection(labelImage->GetDirection());
-    coverage->SetLargestPossibleRegion(labelImage->GetLargestPossibleRegion());
-    coverage->SetBufferedRegion( labelImage->GetLargestPossibleRegion() );
-    coverage->SetRequestedRegion( labelImage->GetLargestPossibleRegion() );
-    coverage->Allocate();
-    coverage->FillBuffer(0);
-
-    vtkSmartPointer<vtkPoints> noConnPoints = vtkSmartPointer<vtkPoints>::New();
-    vtkSmartPointer<vtkCellArray> noConnCells = vtkSmartPointer<vtkCellArray>::New();
-
-    vtkSmartPointer<vtkPoints> invalidPoints = vtkSmartPointer<vtkPoints>::New();
-    vtkSmartPointer<vtkCellArray> invalidCells = vtkSmartPointer<vtkCellArray>::New();
-
-    vtkSmartPointer<vtkPoints> validPoints = vtkSmartPointer<vtkPoints>::New();
-    vtkSmartPointer<vtkCellArray> validCells = vtkSmartPointer<vtkCellArray>::New();
-
-    boost::progress_display disp(static_cast<unsigned int>(inputTractogram->GetNumFibers()));
-    for (unsigned int i=0; i<inputTractogram->GetNumFibers(); i++)
-    {
-      ++disp;
-
-      vtkCell* cell = polyData->GetCell(i);
-      auto numPoints = cell->GetNumberOfPoints();
-      vtkPoints* points = cell->GetPoints();
-
-
-      if (numPoints>1)
-      {
-        double* start = points->GetPoint(0);
-        itk::Point<float, 3> itkStart = mitk::imv::GetItkPoint(start);
-        itk::Index<3> idxStart;
-        labelImage->TransformPhysicalPointToIndex(itkStart, idxStart);
-
-        double* end = points->GetPoint(numPoints-1);
-        itk::Point<float, 3> itkEnd = mitk::imv::GetItkPoint(end);
-        itk::Index<3> idxEnd;
-        labelImage->TransformPhysicalPointToIndex(itkEnd, idxEnd);
-
-
-        if ( labelImage->GetPixel(idxStart)==0 || labelImage->GetPixel(idxEnd)==0 )
-        {
-          noConnection++;
-
-          if (verbose)
-          {
-            vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
-            for (int j=0; j<numPoints; j++)
-            {
-              double* p = points->GetPoint(j);
-              vtkIdType id = noConnPoints->InsertNextPoint(p);
-              container->GetPointIds()->InsertNextId(id);
-            }
-            noConnCells->InsertNextCell(container);
-          }
-        }
-        else
-        {
-          bool invalid = true;
-          for (unsigned int i=0; i<labelsvector.size(); i++)
-          {
-            bool outside = false;
-            ItkUcharImgType::Pointer bundle = bundleMasks.at(i);
-            std::pair< short, short > l = labelsvector.at(i);
-            if ( (labelImage->GetPixel(idxStart)==l.first && labelImage->GetPixel(idxEnd)==l.second) ||
-                 (labelImage->GetPixel(idxStart)==l.second && labelImage->GetPixel(idxEnd)==l.first) )
-            {
-              for (int j=0; j<numPoints; j++)
-              {
-                double* p = points->GetPoint(j);
-                itk::Point<float, 3> itkP = mitk::imv::GetItkPoint(p);
-                itk::Index<3> idx;
-                bundle->TransformPhysicalPointToIndex(itkP, idx);
-
-                if ( bundle->GetPixel(idx) == 0 && bundle->GetLargestPossibleRegion().IsInside(idx) )
-                {
-                  outside=true;
-                }
-              }
-
-              if (!outside)
-              {
-                validConnections++;
-                if (detected.at(i)==false)
-                  validBundles++;
-                detected.at(i) = true;
-                invalid = false;
-
-
-                vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
-                for (int j=0; j<numPoints; j++)
-                {
-                  double* p = points->GetPoint(j);
-                  vtkIdType id = validPoints->InsertNextPoint(p);
-                  container->GetPointIds()->InsertNextId(id);
-
-                  itk::Point<float, 3> itkP = mitk::imv::GetItkPoint(p);
-                  itk::Index<3> idx;
-                  coverage->TransformPhysicalPointToIndex(itkP, idx);
-                  if ( coverage->GetLargestPossibleRegion().IsInside(idx) )
-                    coverage->SetPixel(idx, 1);
-                }
-                validCells->InsertNextCell(container);
-              }
-              break;
-            }
-          }
-          if (invalid==true)
-          {
-            invalidConnections++;
-            int x = labelImage->GetPixel(idxStart)-1;
-            int y = labelImage->GetPixel(idxEnd)-1;
-            if (x>=0 && y>0 && x<static_cast<int>(matrix.cols()) && y<static_cast<int>(matrix.rows()) && (matrix[x][y]==0 || matrix[y][x]==0) )
-            {
-              invalidBundles++;
-              matrix[x][y]=1;
-              matrix[y][x]=1;
-            }
-
-            if (verbose)
-            {
-              vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
-              for (int j=0; j<numPoints; j++)
-              {
-                double* p = points->GetPoint(j);
-                vtkIdType id = invalidPoints->InsertNextPoint(p);
-                container->GetPointIds()->InsertNextId(id);
-              }
-              invalidCells->InsertNextCell(container);
-            }
-          }
-        }
-      }
-    }
-
-    if (verbose)
-    {
-      vtkSmartPointer<vtkPolyData> noConnPolyData = vtkSmartPointer<vtkPolyData>::New();
-      noConnPolyData->SetPoints(noConnPoints);
-      noConnPolyData->SetLines(noConnCells);
-      mitk::FiberBundle::Pointer noConnFib = mitk::FiberBundle::New(noConnPolyData);
-
-      std::string ncfilename = outRoot;
-      ncfilename.append("_NC.fib");
-
-      mitk::IOUtil::Save(noConnFib.GetPointer(), ncfilename );
-
-      vtkSmartPointer<vtkPolyData> invalidPolyData = vtkSmartPointer<vtkPolyData>::New();
-      invalidPolyData->SetPoints(invalidPoints);
-      invalidPolyData->SetLines(invalidCells);
-      mitk::FiberBundle::Pointer invalidFib = mitk::FiberBundle::New(invalidPolyData);
-
-      std::string icfilename = outRoot;
-      icfilename.append("_IC.fib");
-
-      mitk::IOUtil::Save(invalidFib.GetPointer(), icfilename );
-
-      vtkSmartPointer<vtkPolyData> validPolyData = vtkSmartPointer<vtkPolyData>::New();
-      validPolyData->SetPoints(validPoints);
-      validPolyData->SetLines(validCells);
-      mitk::FiberBundle::Pointer validFib = mitk::FiberBundle::New(validPolyData);
-
-      std::string vcfilename = outRoot;
-      vcfilename.append("_VC.fib");
-
-      mitk::IOUtil::Save(validFib.GetPointer(), vcfilename );
-
-      {
-        mitk::LocaleSwitch localeSwitch("C");
-        typedef itk::ImageFileWriter< ItkUcharImgType > WriterType;
-        WriterType::Pointer writer = WriterType::New();
-        writer->SetFileName(outRoot+"_ABC.nrrd");
-        writer->SetInput(coverage);
-        writer->Update();
-      }
-    }
-
-    // calculate coverage
-    int wmVoxels = 0;
-    int coveredVoxels = 0;
-    itk::ImageRegionIterator<ItkUcharImgType> it (coverage, coverage->GetLargestPossibleRegion());
-    while(!it.IsAtEnd())
-    {
-      bool wm = false;
-      for (unsigned int i=0; i<bundleMasksCoverage.size(); i++)
-      {
-        ItkUcharImgType::Pointer bundle = bundleMasksCoverage.at(i);
-        if (bundle->GetPixel(it.GetIndex())>0)
-        {
-          wm = true;
-          wmVoxels++;
-          break;
-        }
-      }
-      if (wm && it.Get()>0)
-        coveredVoxels++;
-      ++it;
-    }
-
-    int numFibers = inputTractogram->GetNumFibers();
-    double nc = (double)noConnection/numFibers;
-    double vc = (double)validConnections/numFibers;
-    double ic = (double)invalidConnections/numFibers;
-    if (numFibers==0)
-    {
-      nc = 0.0;
-      vc = 0.0;
-      ic = 0.0;
-    }
-    int vb = validBundles;
-    int ib = invalidBundles;
-    double abc = (double)coveredVoxels/wmVoxels;
-
-    std::cout << "NC: " << nc;
-    std::cout << "VC: " << vc;
-    std::cout << "IC: " << ic;
-    std::cout << "VB: " << vb;
-    std::cout << "IB: " << ib;
-    std::cout << "ABC: " << abc;
-
-    std::string logFile = outRoot;
-    logFile.append("_TRACTOMETER.csv");
-    ofstream file;
-    file.open (logFile.c_str());
-    {
-      std::string sens = itksys::SystemTools::GetFilenameWithoutLastExtension(fibFile);
-      if (!fileID.empty())
-        sens = fileID;
-      sens.append(",");
-
-      sens.append(boost::lexical_cast<std::string>(nc));
-      sens.append(",");
-
-      sens.append(boost::lexical_cast<std::string>(vc));
-      sens.append(",");
-
-      sens.append(boost::lexical_cast<std::string>(ic));
-      sens.append(",");
-
-      sens.append(boost::lexical_cast<std::string>(validBundles));
-      sens.append(",");
-
-      sens.append(boost::lexical_cast<std::string>(invalidBundles));
-      sens.append(",");
-
-      sens.append(boost::lexical_cast<std::string>(abc));
-      sens.append(";\n");
-      file << sens;
-    }
-    file.close();
-  }
-  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/DiffusionCmdApps/mitkDiffusionDataIOHelper.cpp b/Modules/DiffusionImaging/DiffusionCmdApps/mitkDiffusionDataIOHelper.cpp
index 585b1cee3f..201f548b87 100644
--- a/Modules/DiffusionImaging/DiffusionCmdApps/mitkDiffusionDataIOHelper.cpp
+++ b/Modules/DiffusionImaging/DiffusionCmdApps/mitkDiffusionDataIOHelper.cpp
@@ -1,115 +1,127 @@
 /*===================================================================
 
 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 "mitkDiffusionDataIOHelper.h"
 
 std::vector< std::string > mitk::DiffusionDataIOHelper::get_file_list(const std::string& path, const std::vector<std::string> extensions)
 {
   std::vector< std::string > file_list;
   itk::Directory::Pointer dir = itk::Directory::New();
 
   if (dir->Load(path.c_str()))
   {
     int n = dir->GetNumberOfFiles();
     for (int r = 0; r < n; r++)
     {
       const char *filename = dir->GetFile(r);
       std::string ext = ist::GetFilenameExtension(filename);
       for (auto e : extensions)
       {
         if (ext==e)
         {
           file_list.push_back(path + '/' + filename);
           break;
         }
       }
     }
   }
   std::sort(file_list.begin(), file_list.end());
   return file_list;
 }
 
 std::vector< mitk::Image::Pointer > mitk::DiffusionDataIOHelper::load_mitk_images(const std::vector<std::string> files, std::vector<std::string>* filenames)
 {
   mitk::LocaleSwitch localeSwitch("C");
   std::streambuf *old = cout.rdbuf(); // <-- save
   std::stringstream ss;
   std::cout.rdbuf (ss.rdbuf());       // <-- redirect
   std::vector< mitk::Image::Pointer > out;
   for (auto f : files)
   {
     if (itksys::SystemTools::FileExists(f, true))
     {
       mitk::Image::Pointer image = mitk::IOUtil::Load<mitk::Image>(f);
-      out.push_back(image);
-      if (filenames!=nullptr)
-        filenames->push_back(f);
+      if (image.IsNotNull())
+      {
+        out.push_back(image);
+        if (filenames!=nullptr)
+          filenames->push_back(f);
+      }
     }
     else if (itksys::SystemTools::PathExists(f))
     {
       if (!f.empty() && f.back() != '/')
         f += "/";
 
       auto list = get_file_list(f, {".nrrd",".nii.gz",".nii"});
       for (auto file : list)
       {
         mitk::Image::Pointer image = mitk::IOUtil::Load<mitk::Image>(file);
-        out.push_back(image);
-        if (filenames!=nullptr)
-          filenames->push_back(file);
+        if (image.IsNotNull())
+        {
+          out.push_back(image);
+          if (filenames!=nullptr)
+            filenames->push_back(file);
+        }
       }
     }
   }
 
   std::cout.rdbuf (old);              // <-- restore
   MITK_INFO << "Loaded " << out.size() << " images";
   return out;
 }
 
 std::vector< mitk::FiberBundle::Pointer > mitk::DiffusionDataIOHelper::load_fibs(const std::vector<std::string> files, std::vector<std::string>* filenames)
 {
   std::streambuf *old = cout.rdbuf(); // <-- save
   std::stringstream ss;
   std::cout.rdbuf (ss.rdbuf());       // <-- redirect
   std::vector< mitk::FiberBundle::Pointer > out;
   for (auto f : files)
   {
     if (itksys::SystemTools::PathExists(f))
     {
       if (!f.empty() && f.back() != '/')
         f += "/";
 
       auto list = get_file_list(f, {".fib",".trk",".tck"});
       for (auto file : list)
       {
         mitk::FiberBundle::Pointer fib = mitk::IOUtil::Load<mitk::FiberBundle>(file);
-        out.push_back(fib);
-        if (filenames!=nullptr)
-          filenames->push_back(file);
+        if (fib.IsNotNull())
+        {
+          out.push_back(fib);
+          if (filenames!=nullptr)
+            filenames->push_back(file);
+        }
       }
     }
     else if (itksys::SystemTools::FileExists(f))
     {
       mitk::FiberBundle::Pointer fib = mitk::IOUtil::Load<mitk::FiberBundle>(f);
-      out.push_back(fib);
-      if (filenames!=nullptr)
-        filenames->push_back(f);
+      if (fib.IsNotNull())
+      {
+        out.push_back(fib);
+        if (filenames!=nullptr)
+          filenames->push_back(f);
+      }
     }
   }
   std::cout.rdbuf (old);              // <-- restore
   MITK_INFO << "Loaded " << out.size() << " tractograms";
   return out;
 }
diff --git a/Modules/DiffusionImaging/DiffusionCmdApps/mitkDiffusionDataIOHelper.h b/Modules/DiffusionImaging/DiffusionCmdApps/mitkDiffusionDataIOHelper.h
index fc11619af6..ff1d046eef 100644
--- a/Modules/DiffusionImaging/DiffusionCmdApps/mitkDiffusionDataIOHelper.h
+++ b/Modules/DiffusionImaging/DiffusionCmdApps/mitkDiffusionDataIOHelper.h
@@ -1,128 +1,134 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #ifndef __mitkDiffusionDataIOHelper_h_
 #define __mitkDiffusionDataIOHelper_h_
 
 #include <MitkDiffusionCmdAppsExports.h>
 #include <itkImage.h>
 #include <mitkImage.h>
 #include <mitkIOUtil.h>
 #include <mitkFiberBundle.h>
 #include <mitkImageToItk.h>
 
 #include <itksys/SystemTools.hxx>
 #include <itkDirectory.h>
 #include <mitkLocaleSwitch.h>
 
 typedef itksys::SystemTools ist;
 
 namespace mitk{
 
 class MITKDIFFUSIONCMDAPPS_EXPORT DiffusionDataIOHelper
 {
 public:
 
   static std::vector< std::string > get_file_list(const std::string& path, const std::vector< std::string > extensions={".fib", ".trk"});
 
   static std::vector< mitk::FiberBundle::Pointer > load_fibs(const std::vector<std::string> files, std::vector<std::string>* filenames=nullptr);
 
   static std::vector< mitk::Image::Pointer > load_mitk_images(const std::vector<std::string> files, std::vector<std::string>* filenames=nullptr);
 
   template< class TYPE >
   static typename TYPE::Pointer load_itk_image(const std::string file)
   {
     mitk::LocaleSwitch localeSwitch("C");
     std::streambuf *old = cout.rdbuf(); // <-- save
     std::stringstream ss;
     std::cout.rdbuf (ss.rdbuf());       // <-- redirect
     std::vector< typename TYPE::Pointer > out;
     if (file.compare("")!=0 && itksys::SystemTools::FileExists(file))
     {
-      mitk::Image::Pointer image = mitk::IOUtil::Load<mitk::Image>(file);
-
-      typedef mitk::ImageToItk< TYPE > CasterType;
-      typename CasterType::Pointer caster = CasterType::New();
-      caster->SetInput(image);
-      caster->Update();
-      typename TYPE::Pointer itk_image = caster->GetOutput();
-      std::cout.rdbuf (old);              // <-- restore
-      MITK_INFO << "Loaded 1 image";
-      return itk_image;
+      mitk::Image::Pointer image = mitk::IOUtil::Load<mitk::Image>(file);  
+      if (image.IsNotNull())
+      {
+        typedef mitk::ImageToItk< TYPE > CasterType;
+        typename CasterType::Pointer caster = CasterType::New();
+        caster->SetInput(image);
+        caster->Update();
+        typename TYPE::Pointer itk_image = caster->GetOutput();
+        std::cout.rdbuf (old);              // <-- restore
+        MITK_INFO << "Loaded 1 image";
+        return itk_image;
+      }
     }
     std::cout.rdbuf (old);              // <-- restore    // <-- restore
     MITK_INFO << "Loaded 0 images";
     return nullptr;
   }
 
   template< class TYPE >
   static std::vector< typename TYPE::Pointer > load_itk_images(const std::vector<std::string> files, std::vector<std::string>* filenames=nullptr)
   {
     mitk::LocaleSwitch localeSwitch("C");
     std::streambuf *old = cout.rdbuf(); // <-- save
     std::stringstream ss;
     std::cout.rdbuf (ss.rdbuf());       // <-- redirect
     std::vector< typename TYPE::Pointer > out;
     for (auto f : files)
     {
       if (itksys::SystemTools::FileExists(f, true))
       {
         mitk::Image::Pointer image = mitk::IOUtil::Load<mitk::Image>(f);
+        if (image.IsNotNull())
+        {
+          typedef mitk::ImageToItk< TYPE > CasterType;
+          typename CasterType::Pointer caster = CasterType::New();
+          caster->SetInput(image);
+          caster->Update();
+          typename TYPE::Pointer itk_image = caster->GetOutput();
 
-        typedef mitk::ImageToItk< TYPE > CasterType;
-        typename CasterType::Pointer caster = CasterType::New();
-        caster->SetInput(image);
-        caster->Update();
-        typename TYPE::Pointer itk_image = caster->GetOutput();
-
-        out.push_back(itk_image);
-        if (filenames!=nullptr)
-          filenames->push_back(f);
+          out.push_back(itk_image);
+          if (filenames!=nullptr)
+            filenames->push_back(f);
+        }
       }
       else if (itksys::SystemTools::PathExists(f))
       {
         if (!f.empty() && f.back() != '/')
           f += "/";
 
         auto list = get_file_list(f, {".nrrd",".nii.gz",".nii"});
         for (auto file : list)
         {
           mitk::Image::Pointer image = mitk::IOUtil::Load<mitk::Image>(file);
-
-          typedef mitk::ImageToItk< TYPE > CasterType;
-          typename CasterType::Pointer caster = CasterType::New();
-          caster->SetInput(image);
-          caster->Update();
-          typename TYPE::Pointer itk_image = caster->GetOutput();
-
-          out.push_back(itk_image);
-          if (filenames!=nullptr)
-            filenames->push_back(file);
+          if (image.IsNotNull())
+          {
+            typedef mitk::ImageToItk< TYPE > CasterType;
+            typename CasterType::Pointer caster = CasterType::New();
+            caster->SetInput(image);
+            caster->Update();
+            typename TYPE::Pointer itk_image = caster->GetOutput();
+
+            out.push_back(itk_image);
+            if (filenames!=nullptr)
+              filenames->push_back(file);
+          }
         }
       }
     }
 
     std::cout.rdbuf (old);              // <-- restore
     MITK_INFO << "Loaded " << out.size() << " images";
     return out;
   }
 
 };
 
 }
 
 #endif //__mitkDiffusionDataIOHelper_h_