diff --git a/Modules/DiffusionImaging/FiberTracking/cmdapps/Tractography/RfTraining.cpp b/Modules/DiffusionImaging/FiberTracking/cmdapps/Tractography/RfTraining.cpp
index f989b0c168..a6e7a1d79b 100755
--- a/Modules/DiffusionImaging/FiberTracking/cmdapps/Tractography/RfTraining.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/cmdapps/Tractography/RfTraining.cpp
@@ -1,239 +1,239 @@
 /*===================================================================
 
 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 <itkImageFileWriter.h>
 #include <mitkIOUtil.h>
 #include <iostream>
 #include <fstream>
 #include <itksys/SystemTools.hxx>
 #include <mitkCoreObjectFactory.h>
 #include <mitkPreferenceListReaderOptionsFunctor.h>
 #include <mitkFiberBundle.h>
 #include <mitkTrackingHandlerRandomForest.h>
 #include <mitkTractographyForest.h>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 /*!
 \brief Train random forest classifier for machine learning based streamline tractography
 */
 int main(int argc, char* argv[])
 {
     MITK_INFO << "RfTraining";
     mitkCommandLineParser parser;
 
     parser.setTitle("Trains Random Forests for Machine Learning Based Tractography");
     parser.setCategory("Fiber Tracking and Processing Methods");
     parser.setDescription("Train random forest classifier for machine learning based streamline tractography");
     parser.setContributor("MIC");
 
     parser.setArgumentPrefix("--", "-");
 
     parser.beginGroup("1. Mandatory arguments:");
     parser.addArgument("images", "i", mitkCommandLineParser::StringList, "DWIs:", "input diffusion-weighted images", us::Any(), false);
     parser.addArgument("tractograms", "t", mitkCommandLineParser::StringList, "Tractograms:", "input training tractograms (.fib, vtk ascii file format)", us::Any(), false);
     parser.addArgument("forest", "f", mitkCommandLineParser::OutputFile, "Forest:", "output random forest (HDF5)", us::Any(), false);
     parser.endGroup();
 
     parser.beginGroup("2. Additional input images:");
     parser.addArgument("masks", "", mitkCommandLineParser::StringList, "Masks:", "restrict training using a binary mask image", us::Any());
     parser.addArgument("wm_masks", "", mitkCommandLineParser::StringList, "WM-Masks:", "if no binary white matter mask is specified, the envelope of the input tractogram is used", us::Any());
     parser.addArgument("volume_modification_images", "", mitkCommandLineParser::StringList, "Volume modification images:", "specify a list of float images that modify the fiber density", us::Any());
     parser.addArgument("additional_feature_images", "", mitkCommandLineParser::StringList, "Additional feature images:", "specify a list of float images that hold additional features (float)", us::Any());
     parser.endGroup();
 
     parser.beginGroup("3. Forest parameters:");
     parser.addArgument("num_trees", "", mitkCommandLineParser::Int, "Number of trees:", "number of trees", 30);
     parser.addArgument("max_tree_depth", "", mitkCommandLineParser::Int, "Max. tree depth:", "maximum tree depth", 25);
     parser.addArgument("sample_fraction", "", mitkCommandLineParser::Float, "Sample fraction:", "fraction of samples used per tree", 0.7);
     parser.endGroup();
 
     parser.beginGroup("4. Feature parameters:");
     parser.addArgument("use_sh_features", "", mitkCommandLineParser::Bool, "Use SH features:", "use SH features", false);
     parser.addArgument("sampling_distance", "", mitkCommandLineParser::Float, "Sampling distance:", "resampling parameter for the input tractogram in mm (determines number of white-matter samples)", us::Any());
     parser.addArgument("max_wm_samples", "", mitkCommandLineParser::Int, "Max. num. WM samples:", "upper limit for the number of WM samples");
     parser.addArgument("num_gm_samples", "", mitkCommandLineParser::Int, "Number of gray matter samples per voxel:", "Number of gray matter samples per voxel", us::Any());
     parser.endGroup();
 
     std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
     if (parsedArgs.size()==0)
         return EXIT_FAILURE;
 
     bool shfeatures = false;
     if (parsedArgs.count("use_sh_features"))
         shfeatures = us::any_cast<bool>(parsedArgs["use_sh_features"]);
 
     mitkCommandLineParser::StringContainerType imageFiles = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["images"]);
     mitkCommandLineParser::StringContainerType wmMaskFiles;
     if (parsedArgs.count("wm_masks"))
         wmMaskFiles = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["wm_masks"]);
 
     mitkCommandLineParser::StringContainerType volModFiles;
     if (parsedArgs.count("volume_modification_images"))
         volModFiles = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["volume_modification_images"]);
 
     mitkCommandLineParser::StringContainerType addFeatFiles;
     if (parsedArgs.count("additional_feature_images"))
         addFeatFiles = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["additional_feature_images"]);
 
     mitkCommandLineParser::StringContainerType maskFiles;
     if (parsedArgs.count("masks"))
         maskFiles = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["masks"]);
 
     std::string forestFile = us::any_cast<std::string>(parsedArgs["forest"]);
 
     mitkCommandLineParser::StringContainerType tractogramFiles;
     if (parsedArgs.count("tractograms"))
         tractogramFiles = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["tractograms"]);
 
     int num_trees = 30;
     if (parsedArgs.count("num_trees"))
         num_trees = us::any_cast<int>(parsedArgs["num_trees"]);
 
     int gm_samples = -1;
     if (parsedArgs.count("num_gm_samples"))
         gm_samples = us::any_cast<int>(parsedArgs["num_gm_samples"]);
 
     float sampling_distance = -1;
     if (parsedArgs.count("sampling_distance"))
         sampling_distance = us::any_cast<float>(parsedArgs["sampling_distance"]);
 
     int max_tree_depth = 25;
     if (parsedArgs.count("max_tree_depth"))
         max_tree_depth = us::any_cast<int>(parsedArgs["max_tree_depth"]);
 
     double sample_fraction = 0.7;
     if (parsedArgs.count("sample_fraction"))
         sample_fraction = us::any_cast<float>(parsedArgs["sample_fraction"]);
 
     int maxWmSamples = -1;
     if (parsedArgs.count("max_wm_samples"))
         maxWmSamples = us::any_cast<int>(parsedArgs["max_wm_samples"]);
 
 
     MITK_INFO << "loading diffusion-weighted images";
     std::vector< mitk::Image::Pointer > rawData;
     mitk::PreferenceListReaderOptionsFunctor functor = mitk::PreferenceListReaderOptionsFunctor({"Diffusion Weighted Images"}, {});
     for (auto imgFile : imageFiles)
     {
-        auto dwi = mitk::IOUtil::Load<mitk::Image>(imgFile, &functor));
+        auto dwi = mitk::IOUtil::Load<mitk::Image>(imgFile, &functor);
         rawData.push_back(dwi);
     }
 
     typedef itk::Image<float, 3> ItkFloatImgType;
     typedef itk::Image<unsigned char, 3> ItkUcharImgType;
     MITK_INFO << "loading mask images";
     std::vector< ItkUcharImgType::Pointer > maskImageVector;
     for (auto maskFile : maskFiles)
     {
         mitk::Image::Pointer img = mitk::IOUtil::Load<mitk::Image>(maskFile);
         ItkUcharImgType::Pointer mask = ItkUcharImgType::New();
         mitk::CastToItkImage(img, mask);
         maskImageVector.push_back(mask);
     }
 
     MITK_INFO << "loading white matter mask images";
     std::vector< ItkUcharImgType::Pointer > wmMaskImageVector;
     for (auto wmFile : wmMaskFiles)
     {
         mitk::Image::Pointer img = mitk::IOUtil::Load<mitk::Image>(wmFile);
         ItkUcharImgType::Pointer wmmask = ItkUcharImgType::New();
         mitk::CastToItkImage(img, wmmask);
         wmMaskImageVector.push_back(wmmask);
     }
 
     MITK_INFO << "loading tractograms";
     std::vector< mitk::FiberBundle::Pointer > tractograms;
     for (auto tractFile : tractogramFiles)
     {
         mitk::FiberBundle::Pointer fib = mitk::IOUtil::Load<mitk::FiberBundle>(tractFile);
         tractograms.push_back(fib);
     }
 
     MITK_INFO << "loading white volume modification images";
     std::vector< ItkFloatImgType::Pointer > volumeModImages;
     for (auto file : volModFiles)
     {
         mitk::Image::Pointer img = mitk::IOUtil::Load<mitk::Image>(file);
         ItkFloatImgType::Pointer itkimg = ItkFloatImgType::New();
         mitk::CastToItkImage(img, itkimg);
         volumeModImages.push_back(itkimg);
     }
 
     MITK_INFO << "loading additional feature images";
     std::vector< std::vector< ItkFloatImgType::Pointer > > addFeatImages;
     for (std::size_t i=0; i<rawData.size(); ++i)
         addFeatImages.push_back(std::vector< ItkFloatImgType::Pointer >());
 
     int c = 0;
     for (auto file : addFeatFiles)
     {
         mitk::Image::Pointer img = mitk::IOUtil::Load<mitk::Image>(file);
         ItkFloatImgType::Pointer itkimg = ItkFloatImgType::New();
         mitk::CastToItkImage(img, itkimg);
         addFeatImages.at(c%addFeatImages.size()).push_back(itkimg);
         c++;
     }
 
     mitk::TractographyForest::Pointer forest = nullptr;
     if (shfeatures)
     {
         mitk::TrackingHandlerRandomForest<6,28> forestHandler;
         forestHandler.SetDwis(rawData);
         forestHandler.SetMaskImages(maskImageVector);
         forestHandler.SetWhiteMatterImages(wmMaskImageVector);
         forestHandler.SetFiberVolumeModImages(volumeModImages);
         forestHandler.SetAdditionalFeatureImages(addFeatImages);
         forestHandler.SetTractograms(tractograms);
         forestHandler.SetNumTrees(num_trees);
         forestHandler.SetMaxTreeDepth(max_tree_depth);
         forestHandler.SetGrayMatterSamplesPerVoxel(gm_samples);
         forestHandler.SetSampleFraction(sample_fraction);
         forestHandler.SetFiberSamplingStep(sampling_distance);
         forestHandler.SetMaxNumWmSamples(maxWmSamples);
         forestHandler.StartTraining();
         forest = forestHandler.GetForest();
     }
     else
     {
         mitk::TrackingHandlerRandomForest<6,100> forestHandler;
         forestHandler.SetDwis(rawData);
         forestHandler.SetMaskImages(maskImageVector);
         forestHandler.SetWhiteMatterImages(wmMaskImageVector);
         forestHandler.SetFiberVolumeModImages(volumeModImages);
         forestHandler.SetAdditionalFeatureImages(addFeatImages);
         forestHandler.SetTractograms(tractograms);
         forestHandler.SetNumTrees(num_trees);
         forestHandler.SetMaxTreeDepth(max_tree_depth);
         forestHandler.SetGrayMatterSamplesPerVoxel(gm_samples);
         forestHandler.SetSampleFraction(sample_fraction);
         forestHandler.SetFiberSamplingStep(sampling_distance);
         forestHandler.SetMaxNumWmSamples(maxWmSamples);
         forestHandler.StartTraining();
         forest = forestHandler.GetForest();
     }
 
     mitk::IOUtil::Save(forest, forestFile);
 
     return EXIT_SUCCESS;
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/AnchorBasedScoring.cpp b/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/AnchorBasedScoring.cpp
index 2fe1fa5134..35bb3ffafe 100755
--- a/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/AnchorBasedScoring.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/AnchorBasedScoring.cpp
@@ -1,473 +1,473 @@
 /*===================================================================
 
 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 <itksys/SystemTools.hxx>
 #include <itkDirectory.h>
 #include <mitkFiberBundle.h>
 #include <mitkPreferenceListReaderOptionsFunctor.h>
 #include <itkImageFileWriter.h>
 #include <mitkPeakImage.h>
 #include <itkFitFibersToImageFilter.h>
 #include <boost/lexical_cast.hpp>
 #include <itkTractDensityImageFilter.h>
 
 typedef itksys::SystemTools ist;
 typedef itk::Point<float, 4> PointType4;
 typedef itk::Image< float, 4 >  PeakImgType;
 typedef itk::Image< unsigned char, 3 >  ItkUcharImageType;
 
 std::vector< mitk::FiberBundle::Pointer > CombineTractograms(std::vector< mitk::FiberBundle::Pointer > reference, std::vector< mitk::FiberBundle::Pointer > candidates, int skip=-1)
 {
   std::vector< mitk::FiberBundle::Pointer > fib;
   for (auto f : reference)
     fib.push_back(f);
 
   int c = 0;
   for (auto f : candidates)
   {
     if (c!=skip)
       fib.push_back(f);
     ++c;
   }
 
   return fib;
 }
 
 std::vector< std::string > get_file_list(const std::string& path, std::vector< std::string > extensions={".fib", ".trk"})
 {
   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;
         }
       }
     }
   }
   return file_list;
 }
 
 /*!
 \brief Fits the tractogram to the input peak image by assigning a weight to each fiber (similar to https://doi.org/10.1016/j.neuroimage.2015.06.092).
 */
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
 
   parser.setTitle("Anchor Based Scoring");
   parser.setCategory("Fiber Tracking Evaluation");
   parser.setDescription("");
   parser.setContributor("MIC");
 
   parser.setArgumentPrefix("--", "-");
   parser.addArgument("", "a", mitkCommandLineParser::InputFile, "Anchor tractogram:", "anchor tracts in one tractogram file", us::Any(), false);
   parser.addArgument("", "p", mitkCommandLineParser::InputFile, "Input peaks:", "input peak image", us::Any(), false);
   parser.addArgument("", "c", mitkCommandLineParser::InputDirectory, "Candidates folder:", "folder containing candidate tracts", us::Any(), false);
   parser.addArgument("", "o", mitkCommandLineParser::OutputDirectory, "Output folder:", "output folder", us::Any(), false);
 
   parser.addArgument("anchor_masks", "", mitkCommandLineParser::StringList, "Reference Masks:", "reference tract masks for accuracy evaluation");
   parser.addArgument("mask", "", mitkCommandLineParser::InputFile, "Mask image:", "scoring is only performed inside the mask image");
   parser.addArgument("greedy_add", "", mitkCommandLineParser::Bool, "Greedy:", "if enabled, the candidate tracts are not jointly fitted to the residual image but one after the other employing a greedy scheme", false);
   parser.addArgument("lambda", "", mitkCommandLineParser::Float, "Lambda:", "modifier for regularization", 0.1);
   parser.addArgument("filter_outliers", "", mitkCommandLineParser::Bool, "Filter outliers:", "perform second optimization run with an upper weight bound based on the first weight estimation (99% quantile)", false);
   parser.addArgument("regu", "", mitkCommandLineParser::String, "Regularization:", "MSM, Variance, VoxelVariance, Lasso, GroupLasso, GroupVariance, NONE (default)");
 
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0)
     return EXIT_FAILURE;
 
   std::string anchors_file = us::any_cast<std::string>(parsedArgs["a"]);
   std::string peak_file_name = us::any_cast<std::string>(parsedArgs["p"]);
   std::string candidate_tract_folder = us::any_cast<std::string>(parsedArgs["c"]);
   std::string out_folder = us::any_cast<std::string>(parsedArgs["o"]);
 
   bool greedy_add = false;
   if (parsedArgs.count("greedy_add"))
     greedy_add = us::any_cast<bool>(parsedArgs["greedy_add"]);
 
   float lambda = 0.1;
   if (parsedArgs.count("lambda"))
     lambda = us::any_cast<float>(parsedArgs["lambda"]);
 
   bool filter_outliers = false;
   if (parsedArgs.count("filter_outliers"))
     filter_outliers = us::any_cast<bool>(parsedArgs["filter_outliers"]);
 
   std::string mask_file = "";
   if (parsedArgs.count("mask"))
     mask_file = us::any_cast<std::string>(parsedArgs["mask"]);
 
   mitkCommandLineParser::StringContainerType anchor_mask_files;
   if (parsedArgs.count("anchor_masks"))
     anchor_mask_files = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["anchor_masks"]);
 
   std::string regu = "NONE";
   if (parsedArgs.count("regu"))
     regu = us::any_cast<std::string>(parsedArgs["regu"]);
 
   try
   {
     itk::TimeProbe clock;
     clock.Start();
 
     if (!ist::PathExists(out_folder))
     {
       MITK_INFO << "Creating output directory";
       ist::MakeDirectory(out_folder);
     }
 
     MITK_INFO << "Loading data";
     std::streambuf *old = cout.rdbuf(); // <-- save
     std::stringstream ss;
     std::cout.rdbuf (ss.rdbuf());       // <-- redirect
 
     ofstream logfile;
     logfile.open (out_folder + "log.txt");
 
     itk::ImageFileWriter< PeakImgType >::Pointer peak_image_writer = itk::ImageFileWriter< PeakImgType >::New();
     mitk::PreferenceListReaderOptionsFunctor functor = mitk::PreferenceListReaderOptionsFunctor({"Peak Image", "Fiberbundles"}, {});
-    mitk::Image::Pointer inputImage = mitk::IOUtil::Load<mitk::PeakImage>(peak_file_name, &functor);
+    auto inputImage = mitk::IOUtil::Load<mitk::PeakImage>(peak_file_name, &functor);
 
     float minSpacing = 1;
     if(inputImage->GetGeometry()->GetSpacing()[0]<inputImage->GetGeometry()->GetSpacing()[1] && inputImage->GetGeometry()->GetSpacing()[0]<inputImage->GetGeometry()->GetSpacing()[2])
       minSpacing = inputImage->GetGeometry()->GetSpacing()[0];
     else if (inputImage->GetGeometry()->GetSpacing()[1] < inputImage->GetGeometry()->GetSpacing()[2])
       minSpacing = inputImage->GetGeometry()->GetSpacing()[1];
     else
       minSpacing = inputImage->GetGeometry()->GetSpacing()[2];
 
     // Load mask file. Fit is only performed inside the mask
     itk::FitFibersToImageFilter::UcharImgType::Pointer mask = nullptr;
     if (mask_file.compare("")!=0)
     {
       mitk::Image::Pointer mitk_mask = mitk::IOUtil::Load<mitk::Image>(mask_file);
       mitk::CastToItkImage(mitk_mask, mask);
     }
 
     // Load masks covering the true positives for evaluation purposes
     std::vector< itk::FitFibersToImageFilter::UcharImgType::Pointer > reference_masks;
     for (auto filename : anchor_mask_files)
     {
       itk::FitFibersToImageFilter::UcharImgType::Pointer ref_mask = nullptr;
       mitk::Image::Pointer ref_mitk_mask = mitk::IOUtil::Load<mitk::Image>(filename);
       mitk::CastToItkImage(ref_mitk_mask, ref_mask);
       reference_masks.push_back(ref_mask);
     }
 
     // Load peak image
     typedef mitk::ImageToItk< PeakImgType > CasterType;
     CasterType::Pointer caster = CasterType::New();
     caster->SetInput(inputImage);
     caster->Update();
     PeakImgType::Pointer peak_image = caster->GetOutput();
 
     // Load all candidate tracts
     std::vector< std::string > candidate_tract_files = get_file_list(candidate_tract_folder);
     std::vector< mitk::FiberBundle::Pointer > input_candidates;
     for (std::string f : candidate_tract_files)
     {
       mitk::FiberBundle::Pointer fib = mitk::IOUtil::Load<mitk::FiberBundle>(f);
       if (fib.IsNull())
         continue;
       if (fib->GetNumFibers()<=0)
         continue;
       fib->ResampleLinear(minSpacing/10.0);
       input_candidates.push_back(fib);
     }
     std::cout.rdbuf (old);              // <-- restore
     MITK_INFO << "Loaded " << candidate_tract_files.size() << " candidate tracts.";
 
     double rmse = 0.0;
     int iteration = 0;
     std::string name = "NOANCHOR";
     // Load reference tractogram consisting of all known tracts
     std::vector< mitk::FiberBundle::Pointer > input_reference;
     mitk::FiberBundle::Pointer anchor_tractogram = mitk::IOUtil::Load<mitk::FiberBundle>(anchors_file);
     if ( !(anchor_tractogram.IsNull() || anchor_tractogram->GetNumFibers()==0) )
     {
       std::streambuf *old = cout.rdbuf(); // <-- save
       std::stringstream ss;
       std::cout.rdbuf (ss.rdbuf());       // <-- redirect
       anchor_tractogram->ResampleLinear(minSpacing/10.0);
       std::cout.rdbuf (old);              // <-- restore
       input_reference.push_back(anchor_tractogram);
 
       // Fit known tracts to peak image to obtain underexplained image
       MITK_INFO << "Fit anchor tracts";
       itk::FitFibersToImageFilter::Pointer fitter = itk::FitFibersToImageFilter::New();
       fitter->SetTractograms(input_reference);
       fitter->SetLambda(lambda);
       fitter->SetFilterOutliers(filter_outliers);
       fitter->SetPeakImage(peak_image);
       fitter->SetVerbose(true);
       fitter->SetResampleFibers(false);
       fitter->SetMaskImage(mask);
       fitter->SetRegularization(VnlCostFunction::REGU::NONE);
       fitter->Update();
       rmse = fitter->GetRMSE();
       vnl_vector<double> rms_diff = fitter->GetRmsDiffPerBundle();
       logfile << "RMS_DIFF: " << setprecision(5) << rms_diff[0] << " " << name << " RMSE: " << rmse << "\n";
 
       name = ist::GetFilenameWithoutExtension(anchors_file);
       mitk::FiberBundle::Pointer anchor_tracts = fitter->GetTractograms().at(0);
       anchor_tracts->SetFiberColors(255,255,255);
       mitk::IOUtil::Save(anchor_tracts, out_folder + boost::lexical_cast<std::string>((int)(100000*rms_diff[0])) + "_" + name + ".fib");
 
       peak_image = fitter->GetUnderexplainedImage();
       peak_image_writer->SetInput(peak_image);
       peak_image_writer->SetFileName(out_folder + "Residual_" + name + ".nii.gz");
       peak_image_writer->Update();
     }
 
     if (!greedy_add)
     {
       MITK_INFO << "Fit candidate tracts";
       itk::FitFibersToImageFilter::Pointer fitter = itk::FitFibersToImageFilter::New();
       fitter->SetLambda(lambda);
       fitter->SetFilterOutliers(filter_outliers);
       fitter->SetVerbose(true);
       fitter->SetPeakImage(peak_image);
       fitter->SetResampleFibers(false);
       fitter->SetMaskImage(mask);
       fitter->SetTractograms(input_candidates);
       fitter->SetFitIndividualFibers(true);
 
       if (regu=="MSM")
         fitter->SetRegularization(VnlCostFunction::REGU::MSM);
       else if (regu=="Variance")
         fitter->SetRegularization(VnlCostFunction::REGU::VARIANCE);
       else if (regu=="Lasso")
         fitter->SetRegularization(VnlCostFunction::REGU::LASSO);
       else if (regu=="VoxelVariance")
         fitter->SetRegularization(VnlCostFunction::REGU::VOXEL_VARIANCE);
       else if (regu=="GroupLasso")
         fitter->SetRegularization(VnlCostFunction::REGU::GROUP_LASSO);
       else if (regu=="GroupVariance")
         fitter->SetRegularization(VnlCostFunction::REGU::GROUP_VARIANCE);
       else if (regu=="NONE")
         fitter->SetRegularization(VnlCostFunction::REGU::NONE);
 
       fitter->Update();
       vnl_vector<double> rms_diff = fitter->GetRmsDiffPerBundle();
 
       vnl_vector<double> log_rms_diff = rms_diff-rms_diff.min_value() + 1;
       log_rms_diff = log_rms_diff.apply(std::log);
       log_rms_diff /= log_rms_diff.max_value();
       int c = 0;
       for (auto fib : input_candidates)
       {
         fib->SetFiberWeights( log_rms_diff[c] );
         fib->ColorFibersByOrientation();
 
         std::string bundle_name = ist::GetFilenameWithoutExtension(candidate_tract_files.at(c));
 
         std::streambuf *old = cout.rdbuf(); // <-- save
         std::stringstream ss;
         std::cout.rdbuf (ss.rdbuf());       // <-- redirect
         mitk::IOUtil::Save(fib, out_folder + boost::lexical_cast<std::string>((int)(100000*rms_diff[c])) + "_" + bundle_name + ".fib");
 
         float best_overlap = 0;
         int best_overlap_index = -1;
         int m_idx = 0;
         for (auto ref_mask : reference_masks)
         {
           float overlap = fib->GetOverlap(ref_mask, false);
           if (overlap>best_overlap)
           {
             best_overlap = overlap;
             best_overlap_index = m_idx;
           }
           ++m_idx;
         }
 
         unsigned int num_voxels = 0;
         {
           itk::TractDensityImageFilter< ItkUcharImageType >::Pointer masks_filter = itk::TractDensityImageFilter< ItkUcharImageType >::New();
           masks_filter->SetInputImage(mask);
           masks_filter->SetBinaryOutput(true);
           masks_filter->SetFiberBundle(fib);
           masks_filter->SetUseImageGeometry(true);
           masks_filter->Update();
           num_voxels = masks_filter->GetNumCoveredVoxels();
         }
 
         double weight_sum = 0;
         for (int i=0; i<fib->GetNumFibers(); i++)
           weight_sum += fib->GetFiberWeight(i);
 
         std::cout.rdbuf (old);              // <-- restore
 
         logfile << "RMS_DIFF: " << setprecision(5) << rms_diff[c] << " " << bundle_name << " " << num_voxels << " " << fib->GetNumFibers() << " " << weight_sum << "\n";
         if (best_overlap_index>=0)
           logfile << "Best_overlap: " << setprecision(5) << best_overlap << " " << ist::GetFilenameWithoutExtension(anchor_mask_files.at(best_overlap_index)) << "\n";
         else
           logfile << "No_overlap\n";
 
         ++c;
       }
 
       mitk::FiberBundle::Pointer out_fib = mitk::FiberBundle::New();
       out_fib = out_fib->AddBundles(input_candidates);
       out_fib->ColorFibersByFiberWeights(false, true);
       mitk::IOUtil::Save(out_fib, out_folder + "AllCandidates.fib");
 
       peak_image = fitter->GetUnderexplainedImage();
       peak_image_writer->SetInput(peak_image);
       peak_image_writer->SetFileName(out_folder + "Residual_AllCandidates.nii.gz");
       peak_image_writer->Update();
     }
     else
     {
       MITK_INFO << "RMSE: " << setprecision(5) << rmse;
       //    fitter->SetPeakImage(peak_image);
 
       // Iteratively add candidate bundles in a greedy manner
       while (!input_candidates.empty())
       {
         double next_rmse = rmse;
         double num_peaks = 0;
         mitk::FiberBundle::Pointer best_candidate = nullptr;
         PeakImgType::Pointer best_candidate_peak_image = nullptr;
 
         for (int i=0; i<(int)input_candidates.size(); ++i)
         {
           // WHY NECESSARY AGAIN??
           itk::FitFibersToImageFilter::Pointer fitter = itk::FitFibersToImageFilter::New();
           fitter->SetLambda(lambda);
           fitter->SetFilterOutliers(filter_outliers);
           fitter->SetVerbose(false);
           fitter->SetPeakImage(peak_image);
           fitter->SetResampleFibers(false);
           fitter->SetMaskImage(mask);
           // ******************************
           fitter->SetTractograms({input_candidates.at(i)});
 
           std::streambuf *old = cout.rdbuf(); // <-- save
           std::stringstream ss;
           std::cout.rdbuf (ss.rdbuf());       // <-- redirect
           fitter->Update();
           std::cout.rdbuf (old);              // <-- restore
 
           double candidate_rmse = fitter->GetRMSE();
 
           if (candidate_rmse<next_rmse)
           {
             next_rmse = candidate_rmse;
             num_peaks = fitter->GetNumCoveredDirections();
             best_candidate = fitter->GetTractograms().at(0);
             best_candidate_peak_image = fitter->GetUnderexplainedImage();
           }
         }
 
         if (best_candidate.IsNull())
           break;
 
         //      fitter->SetPeakImage(peak_image);
         peak_image = best_candidate_peak_image;
 
         int i=0;
         std::vector< mitk::FiberBundle::Pointer > remaining_candidates;
         std::vector< std::string > remaining_candidate_files;
         for (auto fib : input_candidates)
         {
           if (fib!=best_candidate)
           {
             remaining_candidates.push_back(fib);
             remaining_candidate_files.push_back(candidate_tract_files.at(i));
           }
           else
             name = ist::GetFilenameWithoutExtension(candidate_tract_files.at(i));
           ++i;
         }
         input_candidates = remaining_candidates;
         candidate_tract_files = remaining_candidate_files;
 
         iteration++;
         std::streambuf *old = cout.rdbuf(); // <-- save
         std::stringstream ss;
         std::cout.rdbuf (ss.rdbuf());       // <-- redirect
         // Save winning candidate
         mitk::IOUtil::Save(best_candidate, out_folder + boost::lexical_cast<std::string>(iteration) + "_" + name + ".fib");
         peak_image_writer->SetInput(peak_image);
         peak_image_writer->SetFileName(out_folder + boost::lexical_cast<std::string>(iteration) + "_" + name + ".nrrd");
         peak_image_writer->Update();
 
         // Calculate best overlap with reference masks for evaluation purposes
         float best_overlap = 0;
         int best_overlap_index = -1;
         i = 0;
         for (auto ref_mask : reference_masks)
         {
           float overlap = best_candidate->GetOverlap(ref_mask, false);
           if (overlap>best_overlap)
           {
             best_overlap = overlap;
             best_overlap_index = i;
           }
           ++i;
         }
         std::cout.rdbuf (old);              // <-- restore
 
         logfile << "RMSE: " << setprecision(5) << rmse << " " << name << " " << num_peaks << "\n";
         if (best_overlap_index>=0)
           logfile << "Best_overlap: " << setprecision(5) << best_overlap << " " << ist::GetFilenameWithoutExtension(anchor_mask_files.at(best_overlap_index)) << "\n";
         else
           logfile << "No_overlap\n";
       }
     }
 
     clock.Stop();
     int h = clock.GetTotal()/3600;
     int m = ((int)clock.GetTotal()%3600)/60;
     int s = (int)clock.GetTotal()%60;
     MITK_INFO << "Plausibility estimation took " << h << "h, " << m << "m and " << s << "s";
     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/Remeshing/Testing/mitkACVDTest.cpp b/Modules/Remeshing/Testing/mitkACVDTest.cpp
index 0208444623..0490f451c3 100644
--- a/Modules/Remeshing/Testing/mitkACVDTest.cpp
+++ b/Modules/Remeshing/Testing/mitkACVDTest.cpp
@@ -1,142 +1,142 @@
 /*===================================================================
 
 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 <mitkACVD.h>
 #include <mitkIOUtil.h>
 #include <mitkTestingMacros.h>
 #include <sstream>
 #include <vtkDebugLeaks.h>
 #include <vtkPolyData.h>
 #include <vtkSmartPointer.h>
 
 #define _MITK_TEST_FOR_EXCEPTION(STATEMENT, EXCEPTION, MESSAGE)                                                        \
   MITK_TEST_OUTPUT_NO_ENDL(<< MESSAGE)                                                                                 \
   try                                                                                                                  \
   {                                                                                                                    \
     STATEMENT;                                                                                                         \
     MITK_TEST_OUTPUT(<< " [FAILED]")                                                                                   \
     mitk::TestManager::GetInstance()->TestFailed();                                                                    \
   }                                                                                                                    \
   catch (const EXCEPTION &e)                                                                                           \
   {                                                                                                                    \
     MITK_TEST_OUTPUT(<< "\n  " << e.GetDescription() << " [PASSED]")                                                   \
     mitk::TestManager::GetInstance()->TestPassed();                                                                    \
   }
 
 template <typename T>
 static T lexical_cast(const std::string &string)
 {
   std::istringstream sstream(string);
   T value;
 
   sstream >> value;
 
   if (sstream.fail())
   {
     MITK_ERROR << "Lexical cast failed for '" << string << "'!";
     exit(EXIT_FAILURE);
   }
 
   return value;
 }
 
 static void Remesh_SurfaceIsNull_ThrowsException()
 {
   mitk::Surface::ConstPointer surface;
   _MITK_TEST_FOR_EXCEPTION(
     mitk::ACVD::Remesh(surface, 0, 100, 0.0), mitk::Exception, "Remesh_SurfaceIsNull_ThrowsException")
 }
 
 static void Remesh_PolyDataIsNull_ThrowsException()
 {
   mitk::Surface::ConstPointer surface = mitk::Surface::New().GetPointer();
   _MITK_TEST_FOR_EXCEPTION(
     mitk::ACVD::Remesh(surface, 0, 100, 0.0), mitk::Exception, "Remesh_PolyDataIsNull_ThrowsException")
 }
 
 static void Remesh_SurfaceDoesNotHaveDataAtTimeStep_ThrowsException()
 {
   mitk::Surface::ConstPointer surface = mitk::Surface::New().GetPointer();
   _MITK_TEST_FOR_EXCEPTION(mitk::ACVD::Remesh(surface, 1, 100, 0.0),
                            mitk::Exception,
                            "Remesh_SurfaceDoesNotHaveDataAtTimeStep_ThrowsException")
 }
 
 static void Remesh_SurfaceHasNoPolygons_ThrowsException()
 {
   mitk::Surface::Pointer surface = mitk::Surface::New();
   vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
   surface->SetVtkPolyData(polyData);
   _MITK_TEST_FOR_EXCEPTION(mitk::ACVD::Remesh(surface.GetPointer(), 0, 100, 0.0),
                            mitk::Exception,
                            "Remesh_SurfaceHasNoPolygons_ThrowsException")
 }
 
 static void Remesh_SurfaceIsValid_ReturnsRemeshedSurface(const std::string &filename,
                                                          unsigned int t,
                                                          int numVertices,
                                                          double gradation,
                                                          int subsampling,
                                                          double edgeSplitting,
                                                          int optimizationLevel,
                                                          bool forceManifold,
                                                          bool boundaryFixing)
 {
-  mitk::Surface::ConstPointer surface = mitk::IOUtil::Load<mitk::Surface>(filename);
+  auto surface = mitk::IOUtil::Load<mitk::Surface>(filename);
   mitk::Surface::Pointer remeshedSurface = mitk::ACVD::Remesh(
     surface, t, numVertices, gradation, subsampling, edgeSplitting, optimizationLevel, forceManifold, boundaryFixing);
   MITK_TEST_CONDITION(remeshedSurface.IsNotNull() && remeshedSurface->GetVtkPolyData() != nullptr &&
                         remeshedSurface->GetVtkPolyData()->GetNumberOfPolys() != 0,
                       "Remesh_SurfaceIsValid_ReturnsRemeshedSurface")
 }
 
 int mitkACVDTest(int argc, char *argv[])
 {
   if (argc != 10)
   {
     MITK_ERROR << "Invalid argument count!\n"
                << "Usage: mitkACVDTest <filename> <t> <numVertices> <gradation> <subsampling>\n"
                << "                    <edgeSplitting> <optimizationLevel> <forceManifiold>\n"
                << "                    <boundaryFixing>\n"
                << "  See MITK API documentation of mitk::ACVD::Remesh() for details.";
 
     return EXIT_FAILURE;
   }
 
   const std::string filename = argv[1];
   const unsigned int t = lexical_cast<unsigned int>(argv[2]);
   const int numVertices = lexical_cast<int>(argv[3]);
   const double gradation = lexical_cast<double>(argv[4]);
   const int subsampling = lexical_cast<int>(argv[5]);
   const double edgeSplitting = lexical_cast<double>(argv[6]);
   const int optimizationLevel = lexical_cast<int>(argv[7]);
   const bool forceManifold = lexical_cast<bool>(argv[8]);
   const bool boundaryFixing = lexical_cast<bool>(argv[9]);
 
   MITK_TEST_BEGIN("mitkACVDTest")
 
   vtkDebugLeaks::SetExitError(0);
 
   Remesh_SurfaceIsNull_ThrowsException();
   Remesh_PolyDataIsNull_ThrowsException();
   Remesh_SurfaceDoesNotHaveDataAtTimeStep_ThrowsException();
   Remesh_SurfaceHasNoPolygons_ThrowsException();
 
   Remesh_SurfaceIsValid_ReturnsRemeshedSurface(
     filename, t, numVertices, gradation, subsampling, edgeSplitting, optimizationLevel, forceManifold, boundaryFixing);
 
   MITK_TEST_END()
 }