diff --git a/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/FiberExtractionRoi.cpp b/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/FiberExtractionRoi.cpp
index bd12dfa03e..5306c39b48 100755
--- a/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/FiberExtractionRoi.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/FiberExtractionRoi.cpp
@@ -1,198 +1,198 @@
 /*===================================================================
 
 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 <boost/lexical_cast.hpp>
 #include <mitkCoreObjectFactory.h>
 #include <mitkPlanarFigure.h>
 #include <mitkPlanarFigureComposite.h>
 #include <mitkFiberBundle.h>
 #include <mitkImageCast.h>
 #include <mitkImageToItk.h>
 #include <mitkStandaloneDataStorage.h>
 #include <itksys/SystemTools.hxx>
 #include <itkFiberExtractionFilter.h>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 typedef itksys::SystemTools ist;
 typedef itk::Image<float, 3>    ItkFloatImgType;
 
 ItkFloatImgType::Pointer LoadItkImage(const std::string& filename)
 {
   mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(mitk::IOUtil::Load(filename)[0].GetPointer());
   ItkFloatImgType::Pointer itk_image = ItkFloatImgType::New();
   mitk::CastToItkImage(img, itk_image);
   return itk_image;
 }
 
 /*!
 \brief Extract fibers from a tractogram using binary image ROIs
 */
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
 
   parser.setTitle("Fiber Extraction With ROI Image");
   parser.setCategory("Fiber Tracking and Processing Methods");
   parser.setContributor("MIC");
   parser.setDescription("Extract fibers from a tractogram using binary image ROIs");
 
   parser.setArgumentPrefix("--", "-");
   parser.addArgument("input", "i", mitkCommandLineParser::String, "Input:", "input tractogram (.fib/.trk/.tck/.dcm)", us::Any(), false);
   parser.addArgument("out", "o", mitkCommandLineParser::String, "Output:", "output tractogram", us::Any(), false);
   parser.addArgument("rois", "", mitkCommandLineParser::StringList, "ROI images:", "ROI images", us::Any(), false);
 
   parser.addArgument("both_ends", "", mitkCommandLineParser::Bool, "Both ends:", "Fibers are extracted if both endpoints are located in the ROI.", false);
   parser.addArgument("overlap_fraction", "", mitkCommandLineParser::Float, "Overlap fraction:", "Extract by overlap, not by endpoints. Extract fibers that overlap to at least the provided factor (0-1) with the ROI.", -1);
   parser.addArgument("invert", "", mitkCommandLineParser::Bool, "Invert:", "get streamlines not positive for any of the ROI images", false);
   parser.addArgument("interpolate", "", mitkCommandLineParser::Bool, "Interpolate:", "interpolate ROI images", false);
-  parser.addArgument("threshold", "", mitkCommandLineParser::Float, "Threshold:", "positive means ROI image value threshold", false, 0.5);
+  parser.addArgument("threshold", "", mitkCommandLineParser::Float, "Threshold:", "positive means ROI image value threshold", 0.5);
   parser.addArgument("labels", "", mitkCommandLineParser::StringList, "Labels:", "positive means roi image value in labels vector", false);
   parser.addArgument("split_labels", "", mitkCommandLineParser::Bool, "Split labels:", "output a separate tractogram for each label-->label tract", false);
   parser.addArgument("skip_self_connections", "", mitkCommandLineParser::Bool, "Skip self connections:", "ignore streamlines between two identical labels", false);
   parser.addArgument("min_fibers", "", mitkCommandLineParser::Int, "Min. num. fibers:", "discard positive tracts with less fibers", 0);
 
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0)
     return EXIT_FAILURE;
 
   std::string inFib = us::any_cast<std::string>(parsedArgs["input"]);
   std::string outFib = us::any_cast<std::string>(parsedArgs["out"]);
   mitkCommandLineParser::StringContainerType roi_files = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["rois"]);
 
   bool both_ends = false;
   if (parsedArgs.count("both_ends"))
     both_ends = us::any_cast<bool>(parsedArgs["both_ends"]);
 
   bool invert = false;
   if (parsedArgs.count("invert"))
     invert = us::any_cast<bool>(parsedArgs["invert"]);
 
   unsigned int min_fibers = 0;
   if (parsedArgs.count("min_fibers"))
     min_fibers = us::any_cast<int>(parsedArgs["min_fibers"]);
 
   bool split_labels = false;
   if (parsedArgs.count("split_labels"))
     split_labels = us::any_cast<bool>(parsedArgs["split_labels"]);
 
   bool skip_self_connections = false;
   if (parsedArgs.count("skip_self_connections"))
     skip_self_connections = us::any_cast<bool>(parsedArgs["skip_self_connections"]);
 
   float overlap_fraction = -1;
   if (parsedArgs.count("overlap_fraction"))
     overlap_fraction = us::any_cast<float>(parsedArgs["overlap_fraction"]);
 
   bool any_point = false;
   if (overlap_fraction>=0)
     any_point = true;
 
   bool interpolate = false;
   if (parsedArgs.count("interpolate"))
     interpolate = us::any_cast<bool>(parsedArgs["interpolate"]);
 
   float threshold = 0.5;
   if (parsedArgs.count("threshold"))
     threshold = us::any_cast<float>(parsedArgs["threshold"]);
 
   mitkCommandLineParser::StringContainerType labels;
   if (parsedArgs.count("labels"))
     labels = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["labels"]);
 
   try
   {
     // load fiber bundle
     mitk::FiberBundle::Pointer inputTractogram = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::Load(inFib)[0].GetPointer());
 
     std::vector< ItkFloatImgType::Pointer > roi_images;
     for (std::size_t i=0; i<roi_files.size(); ++i)
       roi_images.push_back( LoadItkImage(roi_files.at(i)) );
 
     std::vector< ItkFloatImgType* > roi_images2;
     for (auto roi : roi_images)
       roi_images2.push_back(roi);
 
     std::vector< unsigned short > short_labels;
     for (auto l : labels)
       short_labels.push_back(boost::lexical_cast<unsigned short>(l));
 
     itk::FiberExtractionFilter<float>::Pointer extractor = itk::FiberExtractionFilter<float>::New();
     extractor->SetInputFiberBundle(inputTractogram);
     extractor->SetRoiImages(roi_images2);
     extractor->SetOverlapFraction(overlap_fraction);
     extractor->SetBothEnds(both_ends);
     extractor->SetInterpolate(interpolate);
     extractor->SetThreshold(threshold);
     extractor->SetLabels(short_labels);
     extractor->SetSplitLabels(split_labels);
     extractor->SetMinFibersPerTract(min_fibers);
     extractor->SetSkipSelfConnections(skip_self_connections);
     if (invert)
       extractor->SetNoPositives(true);
     else
       extractor->SetNoNegatives(true);
     if (!any_point)
       extractor->SetMode(itk::FiberExtractionFilter<float>::MODE::ENDPOINTS);
     if (short_labels.size()>0)
       extractor->SetInputType(itk::FiberExtractionFilter<float>::INPUT::LABEL_MAP);
     extractor->Update();
 
     mitk::FiberBundle::Pointer newFib = mitk::FiberBundle::New(nullptr);
     if (invert)
       mitk::IOUtil::Save(extractor->GetNegatives().at(0), outFib);
     else
     {
       if (!split_labels)
       {
         newFib = newFib->AddBundles(extractor->GetPositives());
         mitk::IOUtil::Save(newFib, outFib);
       }
       else
       {
         int c = 0;
         std::vector< std::pair< unsigned int, unsigned int > > positive_labels = extractor->GetPositiveLabels();
         for (auto fib : extractor->GetPositives())
         {
           std::pair< unsigned int, unsigned int > l = positive_labels.at(c);
           mitk::IOUtil::Save(fib, outFib + "_" + boost::lexical_cast<std::string>(l.first) + "-" + boost::lexical_cast<std::string>(l.second) + ".trk");
           ++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/FiberTracking/cmdapps/Fiberfox/FiberfoxOptimization.cpp b/Modules/DiffusionImaging/FiberTracking/cmdapps/Fiberfox/FiberfoxOptimization.cpp
index dc708a9656..c24b45eb70 100755
--- a/Modules/DiffusionImaging/FiberTracking/cmdapps/Fiberfox/FiberfoxOptimization.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/cmdapps/Fiberfox/FiberfoxOptimization.cpp
@@ -1,383 +1,384 @@
 /*===================================================================
 
 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 <mitkImageCast.h>
 #include <mitkITKImageImport.h>
 #include <mitkProperties.h>
 #include <mitkImage.h>
 #include <mitkIOUtil.h>
 #include <mitkFiberBundle.h>
 #include <mitkFiberfoxParameters.h>
 #include "mitkCommandLineParser.h"
 
 #include <itkTractsToDWIImageFilter.h>
 #include <boost/lexical_cast.hpp>
 #include <mitkPreferenceListReaderOptionsFunctor.h>
 #include <itksys/SystemTools.hxx>
 #include <mitkFiberfoxParameters.h>
+#include <random>
 
 using namespace mitk;
 
 float CompareDwi(itk::VectorImage< short, 3 >* dwi1, itk::VectorImage< short, 3 >* dwi2)
 {
   typedef itk::VectorImage< short, 3 > DwiImageType;
   try{
     itk::ImageRegionIterator< DwiImageType > it1(dwi1, dwi1->GetLargestPossibleRegion());
     itk::ImageRegionIterator< DwiImageType > it2(dwi2, dwi2->GetLargestPossibleRegion());
     unsigned int count = 0;
     float difference = 0;
     while(!it1.IsAtEnd())
     {
       for (unsigned int i=0; i<dwi1->GetVectorLength(); ++i)
       {
         difference += abs(it1.Get()[i]-it2.Get()[i]);
         count++;
       }
       ++it1;
       ++it2;
     }
     return difference/count;
   }
   catch(...)
   {
     return -1;
   }
   return -1;
 }
 
 FiberfoxParameters MakeProposalRelaxation(FiberfoxParameters old_params, double temperature)
 {
   std::random_device r;
   std::default_random_engine randgen(r());
 
   std::uniform_int_distribution<int> uint1(0, 4);
 
   FiberfoxParameters new_params(old_params);
   int prop = uint1(randgen);
   switch(prop)
   {
   case 0:
   {
     std::normal_distribution<double> normal_dist(0, new_params.m_SignalGen.m_SignalScale*0.1*temperature);
     float add = 0;
     while (add == 0)
       add =  normal_dist(randgen);
     new_params.m_SignalGen.m_SignalScale += add;
     MITK_INFO << "Proposal Signal Scale: " << add << " (" << new_params.m_SignalGen.m_SignalScale << ")";
     break;
   }
   case 1:
   {
     int model_index = rand()%new_params.m_NonFiberModelList.size();
     double t2 = new_params.m_NonFiberModelList[model_index]->GetT2();
     std::normal_distribution<double> normal_dist(0, t2*0.1*temperature);
 
     double add = 0;
     while (add == 0)
       add = normal_dist(randgen);
     t2 += add;
     new_params.m_NonFiberModelList[model_index]->SetT2(t2);
     MITK_INFO << "Proposal T2 (Non-Fiber " << model_index << "): " << add << " (" << t2 << ")";
     break;
   }
   case 2:
   {
     int model_index = rand()%new_params.m_FiberModelList.size();
     double t2 = new_params.m_FiberModelList[model_index]->GetT2();
     std::normal_distribution<double> normal_dist(0, t2*0.1*temperature);
 
     double add = 0;
     while (add == 0)
       add = normal_dist(randgen);
     t2 += add;
     new_params.m_FiberModelList[model_index]->SetT2(t2);
     MITK_INFO << "Proposal T2 (Fiber " << model_index << "): " << add << " (" << t2 << ")";
     break;
   }
   case 3:
   {
     int model_index = rand()%new_params.m_NonFiberModelList.size();
     double t1 = new_params.m_NonFiberModelList[model_index]->GetT1();
     std::normal_distribution<double> normal_dist(0, t1*0.1*temperature);
 
     double add = 0;
     while (add == 0)
       add = normal_dist(randgen);
     t1 += add;
     new_params.m_NonFiberModelList[model_index]->SetT1(t1);
     MITK_INFO << "Proposal T1 (Non-Fiber " << model_index << "): " << add << " (" << t1 << ")";
     break;
   }
   case 4:
   {
     int model_index = rand()%new_params.m_FiberModelList.size();
     double t1 = new_params.m_FiberModelList[model_index]->GetT1();
     std::normal_distribution<double> normal_dist(0, t1*0.1*temperature);
 
     double add = 0;
     while (add == 0)
       add = normal_dist(randgen);
     t1 += add;
     new_params.m_FiberModelList[model_index]->SetT1(t1);
     MITK_INFO << "Proposal T1 (Fiber " << model_index << "): " << add << " (" << t1 << ")";
     break;
   }
   }
 
   return new_params;
 }
 
 double UpdateDiffusivity(double d, double temperature)
 {
   std::random_device r;
   std::default_random_engine randgen(r());
 
   std::normal_distribution<double> normal_dist(0, d*0.1*temperature);
 
   double add = 0;
   while (add == 0)
     add = normal_dist(randgen);
   d += add;
 
   return d;
 }
 
 void ProposeDiffusivities(mitk::DiffusionSignalModel<>* signalModel, double temperature)
 {
   if (dynamic_cast<mitk::StickModel<>*>(signalModel))
   {
     mitk::StickModel<>* m = dynamic_cast<mitk::StickModel<>*>(signalModel);
     m->SetDiffusivity(UpdateDiffusivity(m->GetDiffusivity(), temperature));
     MITK_INFO << "d: " << m->GetDiffusivity();
   }
   else  if (dynamic_cast<mitk::TensorModel<>*>(signalModel))
   {
     mitk::TensorModel<>* m = dynamic_cast<mitk::TensorModel<>*>(signalModel);
     m->SetDiffusivity1(UpdateDiffusivity(m->GetDiffusivity1(), temperature));
     double new_d2 = UpdateDiffusivity(m->GetDiffusivity2(), temperature);
     while (m->GetDiffusivity1()<new_d2)
       new_d2 = UpdateDiffusivity(m->GetDiffusivity2(), temperature);
     m->SetDiffusivity2(new_d2);
     m->SetDiffusivity3(new_d2);
     MITK_INFO << "d1: " << m->GetDiffusivity1();
     MITK_INFO << "d2: " << m->GetDiffusivity2();
     MITK_INFO << "d3: " << m->GetDiffusivity3();
   }
   else  if (dynamic_cast<mitk::BallModel<>*>(signalModel))
   {
     mitk::BallModel<>* m = dynamic_cast<mitk::BallModel<>*>(signalModel);
     m->SetDiffusivity(UpdateDiffusivity(m->GetDiffusivity(), temperature));
     MITK_INFO << "d: " << m->GetDiffusivity();
   }
   else if (dynamic_cast<mitk::AstroStickModel<>*>(signalModel))
   {
     mitk::AstroStickModel<>* m = dynamic_cast<mitk::AstroStickModel<>*>(signalModel);
     m->SetDiffusivity(UpdateDiffusivity(m->GetDiffusivity(), temperature));
     MITK_INFO << "d: " << m->GetDiffusivity();
   }
 }
 
 FiberfoxParameters MakeProposalDiff(FiberfoxParameters old_params, double temperature)
 {
   std::random_device r;
   std::default_random_engine randgen(r());
 
   std::uniform_int_distribution<int> uint1(0, 1);
 
   FiberfoxParameters new_params(old_params);
   int prop = uint1(randgen);
   switch(prop)
   {
   case 0:
   {
     int model_index = rand()%new_params.m_NonFiberModelList.size();
     ProposeDiffusivities( new_params.m_NonFiberModelList[model_index], temperature );
     MITK_INFO << "Proposal D (Non-Fiber " << model_index << ")";
     break;
   }
   case 1:
   {
     int model_index = rand()%new_params.m_FiberModelList.size();
     ProposeDiffusivities( new_params.m_FiberModelList[model_index], temperature );
     MITK_INFO << "Proposal D (Fiber " << model_index << ")";
     break;
   }
   }
 
   return new_params;
 }
 
 /*!
 * \brief Command line interface to Fiberfox.
 * Simulate a diffusion-weighted image from a tractogram using the specified parameter file.
 */
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
   parser.setTitle("FiberfoxOptimization");
   parser.setCategory("Optimize Fiberfox Parameters");
   parser.setContributor("MIC");
   parser.setDescription("Command line interface to Fiberfox." " Simulate a diffusion-weighted image from a tractogram using the specified parameter file.");
   parser.setArgumentPrefix("--", "-");
   parser.addArgument("parameters", "p", mitkCommandLineParser::InputFile, "Parameter file:", "fiberfox parameter file (.ffp)", us::Any(), false);
   parser.addArgument("input", "i", mitkCommandLineParser::String, "Input:", "Input tractogram or diffusion-weighted image.", us::Any(), false);
   parser.addArgument("template", "t", mitkCommandLineParser::String, "Template image:", "Use parameters of the template diffusion-weighted image.", us::Any(), false);
   parser.addArgument("iterations", "", mitkCommandLineParser::Int, "Iterations:", "Number of optimizations steps", 1000);
   parser.addArgument("start_temp", "", mitkCommandLineParser::Float, "Start temperature:", "", 1.0);
   parser.addArgument("end_temp", "", mitkCommandLineParser::Float, "End temperature:", "", 0.1);
   parser.addArgument("no_diff", "", mitkCommandLineParser::Bool, "Don't optimize diffusivities:", "Don't optimize diffusivities");
   parser.addArgument("no_relax", "", mitkCommandLineParser::Bool, "Don't optimize relaxation times and signal scale:", "Don't optimize relaxation times and signal scale");
 
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0)
     return EXIT_FAILURE;
 
   std::string paramName = us::any_cast<std::string>(parsedArgs["parameters"]);
 
   std::string input = us::any_cast<std::string>(parsedArgs["input"]);
 
   int iterations=1000;
   if (parsedArgs.count("iterations"))
     iterations = us::any_cast<int>(parsedArgs["iterations"]);
 
   float start_temp=1.0;
   if (parsedArgs.count("start_temp"))
     start_temp = us::any_cast<float>(parsedArgs["start_temp"]);
 
   float end_temp=0.1;
   if (parsedArgs.count("end_temp"))
     end_temp = us::any_cast<float>(parsedArgs["end_temp"]);
 
   bool no_diff=false;
   if (parsedArgs.count("no_diff"))
     no_diff = true;
 
   bool no_relax=false;
   if (parsedArgs.count("no_relax"))
     no_relax = true;
 
   if (no_relax && no_diff)
   {
     MITK_INFO << "Incompatible options. Nothing to optimize.";
     return EXIT_FAILURE;
   }
 
   FiberfoxParameters parameters;
   parameters.LoadParameters(paramName);
 
   MITK_INFO << "Loading template image";
   typedef itk::VectorImage< short, 3 >    ItkDwiType;
   mitk::PreferenceListReaderOptionsFunctor functor = mitk::PreferenceListReaderOptionsFunctor({"Diffusion Weighted Images", "Fiberbundles"}, {});
   mitk::Image::Pointer dwi = dynamic_cast<mitk::Image*>(mitk::IOUtil::Load(us::any_cast<std::string>(parsedArgs["template"]), &functor)[0].GetPointer());
   ItkDwiType::Pointer reference = mitk::DiffusionPropertyHelper::GetItkVectorImage(dwi);
   parameters.m_SignalGen.m_ImageRegion = reference->GetLargestPossibleRegion();
   parameters.m_SignalGen.m_ImageSpacing = reference->GetSpacing();
   parameters.m_SignalGen.m_ImageOrigin = reference->GetOrigin();
   parameters.m_SignalGen.m_ImageDirection = reference->GetDirection();
   parameters.SetBvalue(static_cast<mitk::FloatProperty*>(dwi->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue());
   parameters.SetGradienDirections(static_cast<mitk::GradientDirectionsProperty*>( dwi->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer());
 
   mitk::BaseData::Pointer inputData = mitk::IOUtil::Load(input, &functor)[0];
 
   itk::TractsToDWIImageFilter< short >::Pointer tractsToDwiFilter = itk::TractsToDWIImageFilter< short >::New();
   tractsToDwiFilter->SetFiberBundle(dynamic_cast<mitk::FiberBundle*>(inputData.GetPointer()));
   tractsToDwiFilter->SetParameters(parameters);
   tractsToDwiFilter->Update();
   ItkDwiType::Pointer sim = tractsToDwiFilter->GetOutput();
 
   {
     mitk::Image::Pointer image = mitk::GrabItkImageMemory( tractsToDwiFilter->GetOutput() );
     image->GetPropertyList()->ReplaceProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(),
                                                mitk::GradientDirectionsProperty::New( parameters.m_SignalGen.GetGradientDirections() ) );
     image->GetPropertyList()->ReplaceProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(),
                                                mitk::FloatProperty::New( parameters.m_SignalGen.GetBvalue() ) );
     mitk::DiffusionPropertyHelper propertyHelper( image );
     propertyHelper.InitializeImage();
     mitk::IOUtil::Save(image, "initial.dwi");
   }
 
   MITK_INFO << "Iterations: " << iterations;
   MITK_INFO << "start_temp: " << start_temp;
   MITK_INFO << "end_temp: " << end_temp;
   double alpha = log(end_temp/start_temp);
   int accepted = 0;
 
   float last_diff =  CompareDwi(sim, reference);
   for (int i=0; i<1000; ++i)
   {
     double temperature = start_temp * exp(alpha*(double)i/iterations);
     MITK_INFO << "Temperature: " << temperature << " (" << i+1 << "/" << iterations << ")";
 
     std::random_device r;
     std::default_random_engine randgen(r());
     std::uniform_int_distribution<int> uint1(0, 1);
 
     FiberfoxParameters proposal(parameters);
     int select = uint1(randgen);
     if (no_relax)
       select = 0;
     else if (no_diff)
       select = 1;
 
     if (select==0)
       proposal = MakeProposalDiff(proposal, temperature);
     else
       proposal = MakeProposalRelaxation(proposal, temperature);
 
     std::streambuf *old = cout.rdbuf(); // <-- save
     std::stringstream ss;
     std::cout.rdbuf (ss.rdbuf());
     itk::TractsToDWIImageFilter< short >::Pointer tractsToDwiFilter = itk::TractsToDWIImageFilter< short >::New();
     tractsToDwiFilter->SetFiberBundle(dynamic_cast<mitk::FiberBundle*>(inputData.GetPointer()));
     tractsToDwiFilter->SetParameters(proposal);
     tractsToDwiFilter->Update();
     ItkDwiType::Pointer sim = tractsToDwiFilter->GetOutput();
     std::cout.rdbuf (old);              // <-- restore
 
     float diff = CompareDwi(sim, reference);
     if (last_diff<diff)
     {
       MITK_INFO << "Rejected proposal (acc. rate " << (float)accepted/(i+1) << ")";
     }
     else
     {
       std::streambuf *old = cout.rdbuf(); // <-- save
       std::stringstream ss;
       std::cout.rdbuf (ss.rdbuf());
       mitk::Image::Pointer image = mitk::GrabItkImageMemory( tractsToDwiFilter->GetOutput() );
       image->GetPropertyList()->ReplaceProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(),
                                                  mitk::GradientDirectionsProperty::New( parameters.m_SignalGen.GetGradientDirections() ) );
       image->GetPropertyList()->ReplaceProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(),
                                                  mitk::FloatProperty::New( parameters.m_SignalGen.GetBvalue() ) );
       mitk::DiffusionPropertyHelper propertyHelper( image );
       propertyHelper.InitializeImage();
       mitk::IOUtil::Save(image, "optimized.dwi");
 
       proposal.SaveParameters("optimized.ffp");
       std::cout.rdbuf (old);              // <-- restore
 
       accepted++;
 
       MITK_INFO << "Accepted proposal (acc. rate " << (float)accepted/(i+1) << ")";
       parameters = FiberfoxParameters(proposal);
       last_diff = diff;
     }
     MITK_INFO << "\n\n\n";
   }
 
   return EXIT_SUCCESS;
 }
 
diff --git a/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/MergeOverlappingTracts.cpp b/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/MergeOverlappingTracts.cpp
index e7c8f64a0e..2dcd23c2b8 100755
--- a/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/MergeOverlappingTracts.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/MergeOverlappingTracts.cpp
@@ -1,250 +1,250 @@
 /*===================================================================
 
 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 <boost/lexical_cast.hpp>
 #include <itksys/SystemTools.hxx>
 #include <itkDirectory.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 <itkImageFileWriter.h>
 
 typedef itksys::SystemTools ist;
 typedef itk::Image<unsigned char, 3>    ItkFloatImgType;
 typedef itk::Image<unsigned int, 3>    ItkUIntImgType;
 
 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
 */
 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("in", "i", mitkCommandLineParser::InputFile, "Input Folder:", "input folder", us::Any(), false);
   parser.addArgument("out", "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", false, 0.8);
+  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["in"]);
   std::string out_folder = us::any_cast<std::string>(parsedArgs["out"]);
 
   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< std::string > fib_files = get_file_list(input_folder, {".fib", ".trk", ".tck"});
     if (fib_files.empty())
       return EXIT_FAILURE;
 
     std::streambuf *old = cout.rdbuf(); // <-- save
     std::stringstream ss;
     std::cout.rdbuf (ss.rdbuf());       // <-- redirect
 
     std::vector< mitk::FiberBundle::Pointer > fibs;
     for (std::string f : fib_files)
     {
       mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::Load(f)[0].GetPointer());
       fibs.push_back(fib);
     }
 
     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));
             MITK_INFO << 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;
 }