diff --git a/Modules/Classification/CLMiniApps/ManualSegmentationEvaluation.cpp b/Modules/Classification/CLMiniApps/ManualSegmentationEvaluation.cpp
index a20b0b4a53..a159c55a72 100644
--- a/Modules/Classification/CLMiniApps/ManualSegmentationEvaluation.cpp
+++ b/Modules/Classification/CLMiniApps/ManualSegmentationEvaluation.cpp
@@ -1,364 +1,364 @@
 /*===================================================================
 
 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 <mitkCoreObjectFactory.h>
 #include "mitkImage.h"
-#include <boost/lexical_cast.hpp>
+#include <mitkLexicalCast.h>
 #include <vnl/vnl_random.h>
 #include "mitkCommandLineParser.h"
 #include <mitkIOUtil.h>
 #include <itksys/SystemTools.hxx>
 #include <mitkITKImageImport.h>
 #include <mitkImageCast.h>
 #include <mitkProperties.h>
 
 // ITK
 #include <itkImageRegionIterator.h>
 
 // MITK
 #include <mitkIOUtil.h>
 
 // Classification
 #include <mitkCLUtil.h>
 #include <mitkVigraRandomForestClassifier.h>
 
 #include <QDir>
 #include <QString>
 #include <QStringList>
 
 #include <itkLabelOverlapMeasuresImageFilter.h>
 #include <itkImageRegionIteratorWithIndex.h>
 #include <itkNeighborhoodFunctorImageFilter.h>
 #include <itkFirstOrderStatisticsFeatureFunctor.h>
 #include <itkNeighborhood.h>
 #include <itkHessianMatrixEigenvalueImageFilter.h>
 #include <itkStructureTensorEigenvalueImageFilter.h>
 #include <itkLineHistogramBasedMassImageFilter.h>
 
 using namespace mitk;
 
 std::vector<mitk::Image::Pointer> m_FeatureImageVector;
 
 void ProcessFeatureImages(const mitk::Image::Pointer & raw_image, const mitk::Image::Pointer & brain_mask)
 {
   typedef itk::Image<double,3> DoubleImageType;
   typedef itk::Image<short,3> ShortImageType;
   typedef itk::ConstNeighborhoodIterator<DoubleImageType> NeighborhoodType; // Neighborhood iterator to access image
   typedef itk::Functor::NeighborhoodFirstOrderStatistics<NeighborhoodType, double> FunctorType;
   typedef itk::NeighborhoodFunctorImageFilter<DoubleImageType, DoubleImageType, FunctorType> FOSFilerType;
 
   m_FeatureImageVector.clear();
 
   // RAW
   m_FeatureImageVector.push_back(raw_image);
 
   // GAUSS
   mitk::Image::Pointer smoothed;
   mitk::CLUtil::GaussianFilter(raw_image,smoothed,1);
   m_FeatureImageVector.push_back(smoothed);
 
   // Calculate Probability maps (parameters used from literatur)
   // CSF
   mitk::Image::Pointer csf_prob = mitk::Image::New();
   mitk::CLUtil::ProbabilityMap(smoothed,13.9, 8.3,csf_prob);
   m_FeatureImageVector.push_back(csf_prob);
 
   // Lesion
 
   mitk::Image::Pointer les_prob = mitk::Image::New();
   mitk::CLUtil::ProbabilityMap(smoothed,59, 11.6,les_prob);
   m_FeatureImageVector.push_back(les_prob);
 
   // Barin (GM/WM)
 
   mitk::Image::Pointer brain_prob = mitk::Image::New();
   mitk::CLUtil::ProbabilityMap(smoothed,32, 5.6,brain_prob);
   m_FeatureImageVector.push_back(brain_prob);
 
   std::vector<unsigned int> FOS_sizes;
   FOS_sizes.push_back(1);
 
   DoubleImageType::Pointer input;
   ShortImageType::Pointer mask;
   mitk::CastToItkImage(smoothed, input);
   mitk::CastToItkImage(brain_mask, mask);
 
   for(unsigned int i = 0 ; i < FOS_sizes.size(); i++)
   {
     FOSFilerType::Pointer filter = FOSFilerType::New();
     filter->SetNeighborhoodSize(FOS_sizes[i]);
     filter->SetInput(input);
     filter->SetMask(mask);
 
     filter->Update();
     FOSFilerType::DataObjectPointerArray array = filter->GetOutputs();
 
     for( unsigned int i = 0; i < FunctorType::OutputCount; i++)
     {
       mitk::Image::Pointer featureimage;
       mitk::CastToMitkImage(dynamic_cast<DoubleImageType *>(array[i].GetPointer()),featureimage);
       m_FeatureImageVector.push_back(featureimage);
       //      AddImageAsDataNode(featureimage,FunctorType::GetFeatureName(i))->SetVisibility(show_nodes);
     }
   }
 
   {
     itk::HessianMatrixEigenvalueImageFilter< DoubleImageType >::Pointer filter = itk::HessianMatrixEigenvalueImageFilter< DoubleImageType >::New();
     filter->SetInput(input);
     filter->SetImageMask(mask);
     filter->SetSigma(3);
     filter->Update();
 
     mitk::Image::Pointer o1,o2,o3;
     mitk::CastToMitkImage(filter->GetOutput(0),o1);
     mitk::CastToMitkImage(filter->GetOutput(1),o2);
     mitk::CastToMitkImage(filter->GetOutput(2),o3);
 
     m_FeatureImageVector.push_back(o1);
     m_FeatureImageVector.push_back(o2);
     m_FeatureImageVector.push_back(o3);
   }
 
   {
     itk::StructureTensorEigenvalueImageFilter< DoubleImageType >::Pointer filter = itk::StructureTensorEigenvalueImageFilter< DoubleImageType >::New();
     filter->SetInput(input);
     filter->SetImageMask(mask);
     filter->SetInnerScale(1.5);
     filter->SetOuterScale(3);
     filter->Update();
 
     mitk::Image::Pointer o1,o2,o3;
     mitk::CastToMitkImage(filter->GetOutput(0),o1);
     mitk::CastToMitkImage(filter->GetOutput(1),o2);
     mitk::CastToMitkImage(filter->GetOutput(2),o3);
 
     m_FeatureImageVector.push_back(o1);
     m_FeatureImageVector.push_back(o2);
     m_FeatureImageVector.push_back(o3);
   }
 
   {
     itk::LineHistogramBasedMassImageFilter< DoubleImageType >::Pointer filter = itk::LineHistogramBasedMassImageFilter< DoubleImageType >::New();
     filter->SetInput(input);
     filter->SetImageMask(mask);
     filter->Update();
 
     mitk::Image::Pointer o1;
     mitk::CastToMitkImage(filter->GetOutput(0),o1);
 
     m_FeatureImageVector.push_back(o1);
   }
 }
 
 std::vector<mitk::Point3D> PointSetToVector(const mitk::PointSet::Pointer & mps)
 {
   std::vector<mitk::Point3D> result;
   for(int i = 0 ; i < mps->GetSize(); i++)
     result.push_back(mps->GetPoint(i));
   return result;
 }
 
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
   parser.setArgumentPrefix("--", "-");
 
   // required params
   parser.addArgument("inputdir", "i", mitkCommandLineParser::InputDirectory, "Input Directory", "Contains input feature files.", us::Any(), false);
   parser.addArgument("outputdir", "o", mitkCommandLineParser::OutputDirectory, "Output Directory", "Destination of output files.", us::Any(), false);
   parser.addArgument("mitkprojectdata", "d", mitkCommandLineParser::InputFile, "original class mask and raw image", "Orig. data.", us::Any(), false);
   parser.addArgument("csfmps", "csf", mitkCommandLineParser::InputFile, "CSF Pointset", ".", us::Any(), false);
   parser.addArgument("lesmps", "les", mitkCommandLineParser::InputFile, "LES Pointset", ".", us::Any(), false);
   parser.addArgument("bramps", "bra", mitkCommandLineParser::InputFile, "BRA Pointset", ".", us::Any(), false);
   //  parser.addArgument("points", "p", mitkCommandLineParser::Int, "Ensure that p points are selected", ".", us::Any(), false);
 
   // Miniapp Infos
   parser.setCategory("Classification Tools");
   parser.setTitle("Evaluationtool for Manual-Segmentation");
   parser.setDescription("Uses Datacollection to calculate DICE scores for CSF LES BRA");
   parser.setContributor("MBI");
 
   // Params parsing
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0)
     return EXIT_FAILURE;
 
   std::string inputdir = us::any_cast<std::string>(parsedArgs["inputdir"]);
   std::string outputdir = us::any_cast<std::string>(parsedArgs["outputdir"]);
   std::string mitkprojectdata = us::any_cast<std::string>(parsedArgs["mitkprojectdata"]);
   std::string csf_mps_name = us::any_cast<std::string>(parsedArgs["csfmps"]);
   std::string les_mps_name = us::any_cast<std::string>(parsedArgs["lesmps"]);
   std::string bra_mps_name = us::any_cast<std::string>(parsedArgs["bramps"]);
 
   mitk::Image::Pointer class_mask_sampled, raw_image, class_mask;
   mitk::PointSet::Pointer CSF_mps, LES_mps, BRA_mps;
 
   // Load from mitk-project
   auto so = mitk::IOUtil::Load(inputdir + "/" + mitkprojectdata);
   std::map<unsigned int, unsigned int> map;
   mitk::CLUtil::CountVoxel(dynamic_cast<mitk::Image *>(so[1].GetPointer()), map);
   raw_image = map.size() <= 7 ? dynamic_cast<mitk::Image *>(so[0].GetPointer()) : dynamic_cast<mitk::Image *>(so[1].GetPointer());
   class_mask = map.size() <= 7 ? dynamic_cast<mitk::Image *>(so[1].GetPointer()) : dynamic_cast<mitk::Image *>(so[0].GetPointer());
 
   CSF_mps = mitk::IOUtil::Load<mitk::PointSet>(inputdir + "/" + csf_mps_name);
   LES_mps = mitk::IOUtil::Load<mitk::PointSet>(inputdir + "/" + les_mps_name);
   BRA_mps = mitk::IOUtil::Load<mitk::PointSet>(inputdir + "/" + bra_mps_name);
 
   unsigned int num_points = CSF_mps->GetSize() + LES_mps->GetSize() + BRA_mps->GetSize();
   MITK_INFO << "Found #" << num_points << " points over all classes.";
 
   ProcessFeatureImages(raw_image, class_mask);
 
   std::map<unsigned int, unsigned int> tmpMap;
   tmpMap[0] = 0;
   tmpMap[1] = 1;
   tmpMap[2] = 1;
   tmpMap[3] = 1;
   tmpMap[4] = 2;
   tmpMap[5] = 3;
   tmpMap[6] = 3;
   mitk::CLUtil::MergeLabels( class_mask, tmpMap);
   class_mask_sampled = class_mask->Clone();
   itk::Image<short,3>::Pointer itk_classmask_sampled;
   mitk::CastToItkImage(class_mask_sampled,itk_classmask_sampled);
   itk::ImageRegionIteratorWithIndex<itk::Image<short,3> >::IndexType index;
   itk::ImageRegionIteratorWithIndex<itk::Image<short,3> > iit(itk_classmask_sampled,itk_classmask_sampled->GetLargestPossibleRegion());
 
   std::ofstream myfile;
   myfile.open (inputdir + "/results_3.csv");
 
   Eigen::MatrixXd X_test;
 
   unsigned int count_test = 0;
   mitk::CLUtil::CountVoxel(class_mask, count_test);
   X_test = Eigen::MatrixXd(count_test, m_FeatureImageVector.size());
 
   unsigned int pos = 0;
   for( const auto & image : m_FeatureImageVector)
   {
     X_test.col(pos) = mitk::CLUtil::Transform<double>(image,class_mask);
     ++pos;
   }
 
   unsigned int runs = 20;
   for(unsigned int k = 0 ; k < runs; k++)
   {
     auto CSF_vec = PointSetToVector(CSF_mps);
     auto LES_vec = PointSetToVector(LES_mps);
     auto BRA_vec = PointSetToVector(BRA_mps);
 
     itk_classmask_sampled->FillBuffer(0);
 
     // initial draws
     std::random_shuffle(CSF_vec.begin(), CSF_vec.end());
     class_mask->GetGeometry()->WorldToIndex(CSF_vec.back(),index);
     iit.SetIndex(index);
     iit.Set(1);
     CSF_vec.pop_back();
 
     std::random_shuffle(LES_vec.begin(), LES_vec.end());
     class_mask->GetGeometry()->WorldToIndex(LES_vec.back(),index);
     iit.SetIndex(index);
     iit.Set(2);
     LES_vec.pop_back();
 
     std::random_shuffle(BRA_vec.begin(), BRA_vec.end());
     class_mask->GetGeometry()->WorldToIndex(BRA_vec.back(),index);
     iit.SetIndex(index);
     iit.Set(3);
     BRA_vec.pop_back();
 
     std::stringstream ss;
 
     while(!(CSF_vec.empty() && LES_vec.empty() && BRA_vec.empty()))
     {
       mitk::CastToMitkImage(itk_classmask_sampled, class_mask_sampled);
 
       // Train forest
       mitk::VigraRandomForestClassifier::Pointer classifier = mitk::VigraRandomForestClassifier::New();
       classifier->SetTreeCount(40);
       classifier->SetSamplesPerTree(0.66);
 
       Eigen::MatrixXd X_train;
 
       unsigned int count_train = 0;
       mitk::CLUtil::CountVoxel(class_mask_sampled, count_train);
       X_train = Eigen::MatrixXd(count_train, m_FeatureImageVector.size() );
 
       unsigned int pos = 0;
       for( const auto & image : m_FeatureImageVector)
       {
         X_train.col(pos) = mitk::CLUtil::Transform<double>(image,class_mask_sampled);
         ++pos;
       }
 
       Eigen::MatrixXi Y = mitk::CLUtil::Transform<int>(class_mask_sampled,class_mask_sampled);
       classifier->Train(X_train,Y);
 
       Eigen::MatrixXi Y_test = classifier->Predict(X_test);
 
       mitk::Image::Pointer result_mask = mitk::CLUtil::Transform<int>(Y_test, class_mask);
       itk::Image<short,3>::Pointer itk_result_mask, itk_class_mask;
 
       mitk::CastToItkImage(result_mask,itk_result_mask);
       mitk::CastToItkImage(class_mask, itk_class_mask);
 
       itk::LabelOverlapMeasuresImageFilter<itk::Image<short,3> >::Pointer overlap_filter = itk::LabelOverlapMeasuresImageFilter<itk::Image<short,3> >::New();
       overlap_filter->SetInput(0,itk_result_mask);
       overlap_filter->SetInput(1,itk_class_mask);
       overlap_filter->Update();
 
       MITK_INFO << "DICE (" << num_points - (CSF_vec.size() + LES_vec.size() + BRA_vec.size()) << "): " << overlap_filter->GetDiceCoefficient();
       ss << overlap_filter->GetDiceCoefficient() <<",";
 
       // random class selection
 
       if(!CSF_vec.empty())
       {
         std::random_shuffle(CSF_vec.begin(), CSF_vec.end());
         class_mask->GetGeometry()->WorldToIndex(CSF_vec.back(),index);
         iit.SetIndex(index);
         iit.Set(1);
         CSF_vec.pop_back();
       }
 
       if(!LES_vec.empty())
       {
         std::random_shuffle(LES_vec.begin(), LES_vec.end());
         class_mask->GetGeometry()->WorldToIndex(LES_vec.back(),index);
         iit.SetIndex(index);
         iit.Set(2);
         LES_vec.pop_back();
       }
 
       if(!BRA_vec.empty())
       {
         std::random_shuffle(BRA_vec.begin(), BRA_vec.end());
         class_mask->GetGeometry()->WorldToIndex(BRA_vec.back(),index);
         iit.SetIndex(index);
         iit.Set(3);
         BRA_vec.pop_back();
       }
     }
 
     myfile << ss.str() << "\n";
     myfile.flush();
   }
 
   myfile.close();
 
   return EXIT_SUCCESS;
 }
diff --git a/Modules/Classification/CLMiniApps/NativeHeadCTSegmentation.cpp b/Modules/Classification/CLMiniApps/NativeHeadCTSegmentation.cpp
index e1e33c607c..0d7a11d4da 100644
--- a/Modules/Classification/CLMiniApps/NativeHeadCTSegmentation.cpp
+++ b/Modules/Classification/CLMiniApps/NativeHeadCTSegmentation.cpp
@@ -1,236 +1,236 @@
 /*===================================================================
 
 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 <mitkCoreObjectFactory.h>
 #include "mitkImage.h"
-#include <boost/lexical_cast.hpp>
+#include <mitkLexicalCast.h>
 #include "mitkCommandLineParser.h"
 #include <mitkIOUtil.h>
 #include <itksys/SystemTools.hxx>
 #include <mitkITKImageImport.h>
 #include <mitkImageCast.h>
 #include <mitkProperties.h>
 
 // ITK
 #include <itkImageRegionIterator.h>
 
 // MITK
 #include <mitkIOUtil.h>
 
 // Classification
 #include <mitkCLUtil.h>
 #include <mitkVigraRandomForestClassifier.h>
 #include <mitkAbstractFileReader.h>
 
 #include <QDir>
 #include <QString>
 #include <QStringList>
 
 #include <mitkImageAccessByItk.h>
 
 using namespace mitk;
 
 typedef unsigned int uint;
 void ReadMitkProjectImageAndMask(std::string input_file, mitk::Image::Pointer & raw_image, mitk::Image::Pointer & class_mask, Image::Pointer &brain_mask);
 std::map<unsigned int, double> VolumeUnderMaskByLabel(mitk::Image::Pointer mask);
 
 /**
 *
 */
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
   parser.setArgumentPrefix("--", "-");
 
   // required params
   parser.addArgument("inputdir", "i", mitkCommandLineParser::InputDirectory, "Input Directory", "Contains input feature files.", us::Any(), false);
   parser.addArgument("outputdir", "o", mitkCommandLineParser::OutputDirectory, "Output Directory", "Destination of output files.", us::Any(), false);
 
   // optional params
   parser.addArgument("select", "s", mitkCommandLineParser::String, "Item selection", "Using Regular expression, seperated by space e.g.: '*.nrrd *.vtk *test*'",std::string("*.mitk"),true);
   //  parser.addArgument("treecount", "tc", mitkCommandLineParser::Int, "Treecount", "Number of trees.",50,true);
   //  parser.addArgument("treedepth", "td", mitkCommandLineParser::Int, "Treedepth", "Maximal tree depth.",50,true);
   //  parser.addArgument("minsplitnodesize", "min", mitkCommandLineParser::Int, "Minimum split node size.", "Minimum split node size.",2,true);
   //  parser.addArgument("precision", "p", mitkCommandLineParser::Float, "Split precision.", "Precision.", mitk::eps,true);
   //  parser.addArgument("fraction", "f", mitkCommandLineParser::Float, "Fraction of samples per tree.", "Fraction of samples per tree.", 0.6f,true);
   //  parser.addArgument("replacment", "r", mitkCommandLineParser::Bool, "Sample with replacement.", "Sample with replacement.", true,true);
 
   // Miniapp Infos
   parser.setCategory("Classification Tools");
   parser.setTitle("Native Head CT Segmentation");
   parser.setDescription("Using vigra random forest");
   parser.setContributor("Jonas Cordes");
 
   // Params parsing
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0)
     return EXIT_FAILURE;
 
   std::string inputdir = us::any_cast<std::string>(parsedArgs["inputdir"]);
   std::string outputdir = us::any_cast<std::string>(parsedArgs["outputdir"]);
 
   //  int treecount = parsedArgs.count("treecount") ? us::any_cast<int>(parsedArgs["treecount"]) : 50;
   //  int treedepth = parsedArgs.count("treedepth") ? us::any_cast<int>(parsedArgs["treedepth"]) : 50;
   //  int minsplitnodesize = parsedArgs.count("minsplitnodesize") ? us::any_cast<int>(parsedArgs["minsplitnodesize"]) : 2;
   //  float precision = parsedArgs.count("precision") ? us::any_cast<float>(parsedArgs["precision"]) : mitk::eps;
   //  float fraction = parsedArgs.count("fraction") ? us::any_cast<float>(parsedArgs["fraction"]) : 0.6;
   //  bool withreplacement = parsedArgs.count("replacment") ? us::any_cast<float>(parsedArgs["replacment"]) : true;
   std::string filt_select = parsedArgs.count("select") ? us::any_cast<std::string>(parsedArgs["select"]) : "*.mitk";
 
   QString filter(filt_select.c_str());
   QDir dir(inputdir.c_str());
   auto strl = dir.entryList(filter.split(" "),QDir::Files);
 
   // create the one
   mitk::VigraRandomForestClassifier::Pointer classifier = mitk::VigraRandomForestClassifier::New();
   uint n_samples = 45000;
   uint n_samples_per_image = n_samples / strl.size();
   uint n_features = 2;
 
   {// Training
     Eigen::MatrixXd feature_matrix(n_samples, n_features);
     Eigen::MatrixXi label_matrix(n_samples, 1);
 
     uint pos = 0;
 
     for(auto entry : strl)
     {
       mitk::Image::Pointer raw_image, class_mask, brain_mask;
       ReadMitkProjectImageAndMask(inputdir + entry.toStdString(), raw_image, class_mask, brain_mask);
 
       mitk::Image::Pointer brain_mask_sampled;
       AccessFixedDimensionByItk_2(brain_mask, mitk::CLUtil::itkSampleLabel, 3, brain_mask_sampled, n_samples_per_image);
 
       mitk::Image::Pointer csf_prob;
       mitk::CLUtil::ProbabilityMap(raw_image,13.9, 8.3,csf_prob);
       mitk::CLUtil::ErodeGrayscale(csf_prob,1,mitk::CLUtil::Axial,csf_prob);
       mitk::CLUtil::DilateGrayscale(csf_prob,3,mitk::CLUtil::Axial,csf_prob);
       mitk::CLUtil::FillHoleGrayscale(csf_prob,csf_prob);
 
       feature_matrix.block(pos, 0, n_samples_per_image, 1) = mitk::CLUtil::Transform<double>(raw_image,brain_mask_sampled);
       feature_matrix.block(pos, 1, n_samples_per_image, 1) = mitk::CLUtil::Transform<double>(csf_prob,brain_mask_sampled);
 
       label_matrix.block(pos, 0, n_samples_per_image, 1) = mitk::CLUtil::Transform<int>(class_mask, brain_mask_sampled);
       pos += n_samples_per_image;
     }
     classifier->Train(feature_matrix, label_matrix);
     classifier->PrintParameter();
   }
 
   std::map<std::string, std::pair<double, double> > map_error;
 
   for(auto entry: strl)
   {
     mitk::Image::Pointer raw_image, class_mask, brain_mask;
     ReadMitkProjectImageAndMask(inputdir + entry.toStdString(), raw_image, class_mask, brain_mask);
 
     auto map_true = VolumeUnderMaskByLabel(class_mask);
 
     mitk::Image::Pointer csf_prob;
     mitk::CLUtil::ProbabilityMap(raw_image,13.9, 8.3,csf_prob);
     mitk::CLUtil::ErodeGrayscale(csf_prob,1,mitk::CLUtil::Axial,csf_prob);
     mitk::CLUtil::DilateGrayscale(csf_prob,3,mitk::CLUtil::Axial,csf_prob);
     mitk::CLUtil::FillHoleGrayscale(csf_prob,csf_prob);
 
     uint count = 0;
     mitk::CLUtil::CountVoxel(brain_mask,count);
 
     Eigen::MatrixXd feature_matrix(count,n_features);
     feature_matrix.block(0, 0, count, 1) = mitk::CLUtil::Transform<double>(raw_image,brain_mask);
     feature_matrix.block(0, 1, count, 1) = mitk::CLUtil::Transform<double>(csf_prob,brain_mask);
 
     mitk::Image::Pointer result_mask = mitk::CLUtil::Transform<int>(classifier->Predict(feature_matrix),brain_mask);
 
     std::string name = itksys::SystemTools::GetFilenameWithoutExtension(entry.toStdString());
     mitk::IOUtil::Save(result_mask,outputdir + name + ".nrrd");
 
     auto map_pred = VolumeUnderMaskByLabel(result_mask);
 
     map_error[entry.toStdString()] = std::make_pair(std::abs(map_true[1] - map_pred[1]) / map_true[1], map_true[2] != 0 ? std::abs(map_true[2] - map_pred[2]) / map_true[2]: 0);
   }
 
   double mean_error_csf = 0;
   double mean_error_les = 0;
   double num_subjects = map_error.size();
   for(auto entry: map_error)
   {
     MITK_INFO(entry.first.c_str()) << "CSF error: " << entry.second.first << "%\t LES error: " << entry.second.second << "%";
     mean_error_csf += entry.second.first;
     mean_error_les += entry.second.second;
   }
   MITK_INFO("Mean") << "CSF error: " << mean_error_csf/num_subjects << "%\t LES error: " << mean_error_les/num_subjects << "%";
 
   return EXIT_SUCCESS;
 }
 
 void ReadMitkProjectImageAndMask(std::string input_file, mitk::Image::Pointer & raw_image, mitk::Image::Pointer & class_mask, mitk::Image::Pointer & brain_mask)
 {
   auto so = mitk::IOUtil::Load(input_file);
 
   std::map<uint, uint> map;
 
   mitk::CLUtil::CountVoxel(dynamic_cast<mitk::Image *>(so[1].GetPointer()), map);
 
   raw_image = map.size() <= 7 ? dynamic_cast<mitk::Image *>(so[0].GetPointer()) : dynamic_cast<mitk::Image *>(so[1].GetPointer());
   class_mask = map.size() <= 7 ? dynamic_cast<mitk::Image *>(so[1].GetPointer()) : dynamic_cast<mitk::Image *>(so[0].GetPointer());
 
   std::map<uint, uint> merge_instructions;// = {{0,0},{1,1},{2,1},{3,1},{4,2},{5,3},{6,3}};
   merge_instructions[0] = 0;
   merge_instructions[1] = 1;
   merge_instructions[2] = 1;
   merge_instructions[3] = 1;
   merge_instructions[4] = 2;
   merge_instructions[5] = 3;
   merge_instructions[6] = 3;
   mitk::CLUtil::MergeLabels(class_mask, merge_instructions);
 
   brain_mask = class_mask->Clone();
   //merge_instructions = {{0,0},{1,1},{2,1},{3,1},{4,1},{5,1},{6,1}};
   merge_instructions[0] = 0;
   merge_instructions[1] = 1;
   merge_instructions[2] = 1;
   merge_instructions[3] = 1;
   merge_instructions[4] = 1;
   merge_instructions[5] = 1;
   merge_instructions[6] = 1;
   mitk::CLUtil::MergeLabels(brain_mask, merge_instructions);
 }
 
 std::map<unsigned int, double> VolumeUnderMaskByLabel(mitk::Image::Pointer mask)
 {
   itk::Image<unsigned int, 3>::Pointer img;
   mitk::CastToItkImage(mask,img);
 
   std::map<unsigned int, double> volume_map;
   itk::ImageRegionConstIterator<itk::Image<unsigned int, 3>> it(img,img->GetLargestPossibleRegion());
   while(!it.IsAtEnd())
   {
     itk::Image<unsigned int, 3>::PixelType value = it.Value();
     if(volume_map.find(value)== volume_map.end())
       volume_map[value] = 0;
     volume_map[value]++;
     ++it;
   }
 
   auto spacing = img->GetSpacing();
   double volumeUnit = spacing[0] * spacing[1] * spacing[2];
   volumeUnit *= 0.001;
 
   for(auto entry: volume_map)
     entry.second *= volumeUnit;
 
   return volume_map;
 }
diff --git a/Modules/Classification/CLMiniApps/RandomForestTraining.cpp b/Modules/Classification/CLMiniApps/RandomForestTraining.cpp
index e818994033..57b0e3db29 100644
--- a/Modules/Classification/CLMiniApps/RandomForestTraining.cpp
+++ b/Modules/Classification/CLMiniApps/RandomForestTraining.cpp
@@ -1,152 +1,152 @@
 /*===================================================================
 
 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 <mitkCoreObjectFactory.h>
 #include "mitkImage.h"
-#include <boost/lexical_cast.hpp>
+#include <mitkLexicalCast.h>
 #include "mitkCommandLineParser.h"
 #include <mitkIOUtil.h>
 #include <itksys/SystemTools.hxx>
 #include <mitkITKImageImport.h>
 #include <mitkImageCast.h>
 #include <mitkProperties.h>
 
 // ITK
 #include <itkImageRegionIterator.h>
 
 // MITK
 #include <mitkIOUtil.h>
 
 // Classification
 #include <mitkCLUtil.h>
 #include <mitkVigraRandomForestClassifier.h>
 
 #include <QDir>
 #include <QString>
 #include <QStringList>
 
 
 using namespace mitk;
 
 /**
  *
  */
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
   parser.setArgumentPrefix("--", "-");
 
   // required params
   parser.addArgument("inputdir", "i", mitkCommandLineParser::InputDirectory, "Input Directory", "Contains input feature files.", us::Any(), false);
   parser.addArgument("outputdir", "o", mitkCommandLineParser::OutputDirectory, "Output Directory", "Destination of output files.", us::Any(), false);
   parser.addArgument("classmask", "m", mitkCommandLineParser::InputFile, "Class mask image", "Contains several classes.", us::Any(), false);
 
   // optional params
   parser.addArgument("select", "s", mitkCommandLineParser::String, "Item selection", "Using Regular expression, seperated by space e.g.: '*.nrrd *.vtk *test*'",std::string("*.nrrd"),true);
   parser.addArgument("treecount", "tc", mitkCommandLineParser::Int, "Treecount", "Number of trees.",50,true);
   parser.addArgument("treedepth", "td", mitkCommandLineParser::Int, "Treedepth", "Maximal tree depth.",50,true);
   parser.addArgument("minsplitnodesize", "min", mitkCommandLineParser::Int, "Minimum split node size.", "Minimum split node size.",2,true);
   parser.addArgument("precision", "p", mitkCommandLineParser::Float, "Split precision.", "Precision.", mitk::eps,true);
   parser.addArgument("fraction", "f", mitkCommandLineParser::Float, "Fraction of samples per tree.", "Fraction of samples per tree.", 0.6f,true);
   parser.addArgument("replacment", "r", mitkCommandLineParser::Bool, "Sample with replacement.", "Sample with replacement.", true,true);
 
   // Miniapp Infos
   parser.setCategory("Classification Tools");
   parser.setTitle("Random Forest Training");
   parser.setDescription("Vigra RF impl.");
   parser.setContributor("MBI");
 
   // Params parsing
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0)
     return EXIT_FAILURE;
 
   std::string inputdir = us::any_cast<std::string>(parsedArgs["inputdir"]);
   std::string outputdir = us::any_cast<std::string>(parsedArgs["outputdir"]);
   std::string classmask = us::any_cast<std::string>(parsedArgs["classmask"]);
 
   int treecount = parsedArgs.count("treecount") ? us::any_cast<int>(parsedArgs["treecount"]) : 50;
   int treedepth = parsedArgs.count("treedepth") ? us::any_cast<int>(parsedArgs["treedepth"]) : 50;
   int minsplitnodesize = parsedArgs.count("minsplitnodesize") ? us::any_cast<int>(parsedArgs["minsplitnodesize"]) : 2;
   float precision = parsedArgs.count("precision") ? us::any_cast<float>(parsedArgs["precision"]) : mitk::eps;
   float fraction = parsedArgs.count("fraction") ? us::any_cast<float>(parsedArgs["fraction"]) : 0.6;
   bool withreplacement = parsedArgs.count("replacment") ? us::any_cast<float>(parsedArgs["replacment"]) : true;
   std::string filt_select =/* parsedArgs.count("select") ? us::any_cast<std::string>(parsedArgs["select"]) :*/ "*.nrrd";
 
   QString filter(filt_select.c_str());
 
   // **** in principle repeat this block to create a feature matrix X_all for all subjects (in dir)
   // Get nrrd filepath
   QDir dir(inputdir.c_str());
   auto strl = dir.entryList(filter.split(" "),QDir::Files);
 
   // load class mask
   mitk::Image::Pointer mask = mitk::IOUtil::Load<mitk::Image>(classmask);
   unsigned int num_samples = 0;
   mitk::CLUtil::CountVoxel(mask,num_samples);
 
   // initialize featurematrix [num_samples, num_featureimages]
   Eigen::MatrixXd X(num_samples, strl.size());
 
   for(int i = 0 ; i < strl.size(); i++)
   {
     // load feature image
     mitk::Image::Pointer img = mitk::IOUtil::Load<mitk::Image>(inputdir + strl[i].toStdString());
     // transfom it into a [num_samples, 1] vector depending on the classmask
     Eigen::MatrixXd _x = mitk::CLUtil::Transform<double>(img,mask);
     // replace i-th (empty) col with feature vector in _x
     X.block(0,i,num_samples,1) = _x;
   }
   // ****
 
   // transform classmask into the label-vector [num_samples, 1]
   Eigen::MatrixXi Y = mitk::CLUtil::Transform<int>(mask,mask);
 
   mitk::VigraRandomForestClassifier::Pointer classifier = mitk::VigraRandomForestClassifier::New();
   classifier->SetTreeCount(treecount);
   classifier->SetMaximumTreeDepth(treedepth);
   classifier->SetMinimumSplitNodeSize(minsplitnodesize);
   classifier->SetPrecision(precision);
   classifier->SetSamplesPerTree(fraction);
   classifier->UseSampleWithReplacement(withreplacement);
 
   classifier->PrintParameter();
   classifier->Train(X,Y);
 
   MITK_INFO << classifier->IsEmpty();
 
   // no metainformations are saved currently
   // only the raw vigra rf data
   mitk::IOUtil::Save(classifier, outputdir + "RandomForest.hdf5");
 
   Eigen::MatrixXi Y_pred = classifier->Predict(X);
   Eigen::MatrixXd Probs = classifier->GetPointWiseProbabilities();
 
   MITK_INFO << Y_pred.rows() << " " << Y_pred.cols();
   MITK_INFO << Probs.rows() << " " << Probs.cols();
 
   //    mitk::Image::Pointer prediction = mitk::CLUtil::Transform<int>(Y_pred,mask);
   mitk::Image::Pointer probs_1 = mitk::CLUtil::Transform<double>(Probs.col(0),mask);
   mitk::Image::Pointer probs_2 = mitk::CLUtil::Transform<double>(Probs.col(1),mask);
   mitk::Image::Pointer probs_3 = mitk::CLUtil::Transform<double>(Probs.col(2),mask);
 
   mitk::IOUtil::Save(probs_1, outputdir + "probs_1.nrrd");
   mitk::IOUtil::Save(probs_2, outputdir + "probs_2.nrrd");
   mitk::IOUtil::Save(probs_3, outputdir + "probs_3.nrrd");
   //    mitk::IOUtil::Save(probs_2, outputdir + "test.nrrd");
 
   return EXIT_SUCCESS;
 }
diff --git a/Modules/Core/include/mitkLexicalCast.h b/Modules/Core/include/mitkLexicalCast.h
new file mode 100644
index 0000000000..65829242a5
--- /dev/null
+++ b/Modules/Core/include/mitkLexicalCast.h
@@ -0,0 +1,75 @@
+/*===================================================================
+
+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 mitkLexicalCast_h
+#define mitkLexicalCast_h
+
+#include <boost/lexical_cast.hpp>
+
+namespace mitk
+{
+  template <typename Target>
+  inline Target lexical_cast(const std::string &arg)
+  {
+    Target result = Target();
+
+    // Let Boost try to do the lexical cast, which will most probably succeed!
+    if (!boost::conversion::detail::try_lexical_convert(arg, result))
+    {
+      // Fallback to our own conversion using std::istringstream. This happens with
+      // Apple LLVM version 9.1.0 (clang-902.0.39.1) on darwin17.5.0 and very small
+      // floating point numbers like 0.2225e-307.
+      std::istringstream stream(arg);
+      stream.exceptions(std::ios::badbit);
+
+      try
+      {
+        stream.unsetf(std::ios::skipws);
+        stream.precision(boost::detail::lcast_get_precision<Target>());
+        stream >> result;
+      }
+      catch (const std::ios_base::failure &)
+      {
+        boost::conversion::detail::throw_bad_cast<std::string, Target>();
+      }
+    }
+
+    return result;
+  }
+}
+
+namespace boost
+{
+  template <>
+  inline float lexical_cast<float, std::string>(const std::string &arg)
+  {
+    return mitk::lexical_cast<float>(arg);
+  }
+
+  template <>
+  inline double lexical_cast<double, std::string>(const std::string &arg)
+  {
+    return mitk::lexical_cast<double>(arg);
+  }
+
+  template <>
+  inline long double lexical_cast<long double, std::string>(const std::string &arg)
+  {
+    return mitk::lexical_cast<long double>(arg);
+  }
+}
+
+#endif
diff --git a/Modules/Core/src/IO/mitkGeometry3DToXML.cpp b/Modules/Core/src/IO/mitkGeometry3DToXML.cpp
index 379441bb22..d0019ebddf 100644
--- a/Modules/Core/src/IO/mitkGeometry3DToXML.cpp
+++ b/Modules/Core/src/IO/mitkGeometry3DToXML.cpp
@@ -1,240 +1,240 @@
 /*===================================================================
 
 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 "mitkGeometry3DToXML.h"
 
-#include <boost/lexical_cast.hpp>
+#include <mitkLexicalCast.h>
 
 #include <tinyxml.h>
 
 TiXmlElement *mitk::Geometry3DToXML::ToXML(const Geometry3D *geom3D)
 {
   assert(geom3D);
 
   // really serialize
   const AffineTransform3D *transform = geom3D->GetIndexToWorldTransform();
 
   // get transform parameters that would need to be serialized
   AffineTransform3D::MatrixType matrix = transform->GetMatrix();
   AffineTransform3D::OffsetType offset = transform->GetOffset();
 
   bool isImageGeometry = geom3D->GetImageGeometry();
   BaseGeometry::BoundsArrayType bounds = geom3D->GetBounds();
 
   // create XML file
   // construct XML tree describing the geometry
   auto *geomElem = new TiXmlElement("Geometry3D");
   geomElem->SetAttribute("ImageGeometry", isImageGeometry ? "true" : "false");
   geomElem->SetAttribute("FrameOfReferenceID", geom3D->GetFrameOfReferenceID());
 
   // coefficients are matrix[row][column]!
   auto *matrixElem = new TiXmlElement("IndexToWorld");
   matrixElem->SetAttribute("type", "Matrix3x3");
   matrixElem->SetAttribute("m_0_0", boost::lexical_cast<std::string>(matrix[0][0]));
   matrixElem->SetAttribute("m_0_1", boost::lexical_cast<std::string>(matrix[0][1]));
   matrixElem->SetAttribute("m_0_2", boost::lexical_cast<std::string>(matrix[0][2]));
   matrixElem->SetAttribute("m_1_0", boost::lexical_cast<std::string>(matrix[1][0]));
   matrixElem->SetAttribute("m_1_1", boost::lexical_cast<std::string>(matrix[1][1]));
   matrixElem->SetAttribute("m_1_2", boost::lexical_cast<std::string>(matrix[1][2]));
   matrixElem->SetAttribute("m_2_0", boost::lexical_cast<std::string>(matrix[2][0]));
   matrixElem->SetAttribute("m_2_1", boost::lexical_cast<std::string>(matrix[2][1]));
   matrixElem->SetAttribute("m_2_2", boost::lexical_cast<std::string>(matrix[2][2]));
   geomElem->LinkEndChild(matrixElem);
 
   auto *offsetElem = new TiXmlElement("Offset");
   offsetElem->SetAttribute("type", "Vector3D");
   offsetElem->SetAttribute("x", boost::lexical_cast<std::string>(offset[0]));
   offsetElem->SetAttribute("y", boost::lexical_cast<std::string>(offset[1]));
   offsetElem->SetAttribute("z", boost::lexical_cast<std::string>(offset[2]));
   geomElem->LinkEndChild(offsetElem);
 
   auto *boundsElem = new TiXmlElement("Bounds");
   auto *boundsMinElem = new TiXmlElement("Min");
   boundsMinElem->SetAttribute("type", "Vector3D");
   boundsMinElem->SetAttribute("x", boost::lexical_cast<std::string>(bounds[0]));
   boundsMinElem->SetAttribute("y", boost::lexical_cast<std::string>(bounds[2]));
   boundsMinElem->SetAttribute("z", boost::lexical_cast<std::string>(bounds[4]));
   boundsElem->LinkEndChild(boundsMinElem);
   auto *boundsMaxElem = new TiXmlElement("Max");
   boundsMaxElem->SetAttribute("type", "Vector3D");
   boundsMaxElem->SetAttribute("x", boost::lexical_cast<std::string>(bounds[1]));
   boundsMaxElem->SetAttribute("y", boost::lexical_cast<std::string>(bounds[3]));
   boundsMaxElem->SetAttribute("z", boost::lexical_cast<std::string>(bounds[5]));
   boundsElem->LinkEndChild(boundsMaxElem);
   geomElem->LinkEndChild(boundsElem);
 
   return geomElem;
 }
 
 mitk::Geometry3D::Pointer mitk::Geometry3DToXML::FromXML(TiXmlElement *geometryElement)
 {
   if (!geometryElement)
   {
     MITK_ERROR << "Cannot deserialize Geometry3D from nullptr.";
     return nullptr;
   }
 
   AffineTransform3D::MatrixType matrix;
   AffineTransform3D::OffsetType offset;
   bool isImageGeometry(false);
   unsigned int frameOfReferenceID(0);
   BaseGeometry::BoundsArrayType bounds;
 
   if (TIXML_SUCCESS != geometryElement->QueryUnsignedAttribute("FrameOfReferenceID", &frameOfReferenceID))
   {
     MITK_WARN << "Missing FrameOfReference for Geometry3D.";
   }
 
   if (TIXML_SUCCESS != geometryElement->QueryBoolAttribute("ImageGeometry", &isImageGeometry))
   {
     MITK_WARN << "Missing bool ImageGeometry for Geometry3D.";
   }
 
   // matrix
   if (TiXmlElement *matrixElem = geometryElement->FirstChildElement("IndexToWorld")->ToElement())
   {
     bool matrixComplete = true;
     for (unsigned int r = 0; r < 3; ++r)
     {
       for (unsigned int c = 0; c < 3; ++c)
       {
         std::stringstream element_namer;
         element_namer << "m_" << r << "_" << c;
 
         std::string string_value;
         if (TIXML_SUCCESS == matrixElem->QueryStringAttribute(element_namer.str().c_str(), &string_value))
         {
           try
           {
             matrix[r][c] = boost::lexical_cast<double>(string_value);
           }
           catch (boost::bad_lexical_cast &e)
           {
             MITK_ERROR << "Could not parse '" << string_value << "' as number: " << e.what();
             return nullptr;
           }
         }
         else
         {
           matrixComplete = false;
         }
       }
     }
 
     if (!matrixComplete)
     {
       MITK_ERROR << "Could not parse all Geometry3D matrix coefficients!";
       return nullptr;
     }
   }
   else
   {
     MITK_ERROR << "Parse error: expected Matrix3x3 child below Geometry3D node";
     return nullptr;
   }
 
   // offset
   if (TiXmlElement *offsetElem = geometryElement->FirstChildElement("Offset")->ToElement())
   {
     bool vectorComplete = true;
     std::string offset_string[3];
     vectorComplete &= TIXML_SUCCESS == offsetElem->QueryStringAttribute("x", &offset_string[0]);
     vectorComplete &= TIXML_SUCCESS == offsetElem->QueryStringAttribute("y", &offset_string[1]);
     vectorComplete &= TIXML_SUCCESS == offsetElem->QueryStringAttribute("z", &offset_string[2]);
 
     if (!vectorComplete)
     {
       MITK_ERROR << "Could not parse complete Geometry3D offset!";
       return nullptr;
     }
 
     for (unsigned int d = 0; d < 3; ++d)
       try
       {
         offset[d] = boost::lexical_cast<double>(offset_string[d]);
       }
       catch (boost::bad_lexical_cast &e)
       {
         MITK_ERROR << "Could not parse '" << offset_string[d] << "' as number: " << e.what();
         return nullptr;
       }
   }
   else
   {
     MITK_ERROR << "Parse error: expected Offset3D child below Geometry3D node";
     return nullptr;
   }
 
   // bounds
   if (TiXmlElement *boundsElem = geometryElement->FirstChildElement("Bounds")->ToElement())
   {
     bool vectorsComplete(true);
     std::string bounds_string[6];
     if (TiXmlElement *minElem = boundsElem->FirstChildElement("Min")->ToElement())
     {
       vectorsComplete &= TIXML_SUCCESS == minElem->QueryStringAttribute("x", &bounds_string[0]);
       vectorsComplete &= TIXML_SUCCESS == minElem->QueryStringAttribute("y", &bounds_string[2]);
       vectorsComplete &= TIXML_SUCCESS == minElem->QueryStringAttribute("z", &bounds_string[4]);
     }
     else
     {
       vectorsComplete = false;
     }
 
     if (TiXmlElement *maxElem = boundsElem->FirstChildElement("Max")->ToElement())
     {
       vectorsComplete &= TIXML_SUCCESS == maxElem->QueryStringAttribute("x", &bounds_string[1]);
       vectorsComplete &= TIXML_SUCCESS == maxElem->QueryStringAttribute("y", &bounds_string[3]);
       vectorsComplete &= TIXML_SUCCESS == maxElem->QueryStringAttribute("z", &bounds_string[5]);
     }
     else
     {
       vectorsComplete = false;
     }
 
     if (!vectorsComplete)
     {
       MITK_ERROR << "Could not parse complete Geometry3D bounds!";
       return nullptr;
     }
 
     for (unsigned int d = 0; d < 6; ++d)
       try
       {
         bounds[d] = boost::lexical_cast<double>(bounds_string[d]);
       }
       catch (boost::bad_lexical_cast &e)
       {
         MITK_ERROR << "Could not parse '" << bounds_string[d] << "' as number: " << e.what();
         return nullptr;
       }
   }
 
   // build GeometryData from matrix/offset
   AffineTransform3D::Pointer newTransform = AffineTransform3D::New();
   newTransform->SetMatrix(matrix);
   newTransform->SetOffset(offset);
 
   Geometry3D::Pointer newGeometry = Geometry3D::New();
   newGeometry->SetFrameOfReferenceID(frameOfReferenceID);
   newGeometry->SetImageGeometry(isImageGeometry);
 
   newGeometry->SetIndexToWorldTransform(newTransform);
 
   newGeometry->SetBounds(bounds);
 
   return newGeometry;
 }
diff --git a/Modules/Core/src/IO/mitkProportionalTimeGeometryToXML.cpp b/Modules/Core/src/IO/mitkProportionalTimeGeometryToXML.cpp
index 58594fe397..8925d6245c 100644
--- a/Modules/Core/src/IO/mitkProportionalTimeGeometryToXML.cpp
+++ b/Modules/Core/src/IO/mitkProportionalTimeGeometryToXML.cpp
@@ -1,166 +1,166 @@
 /*===================================================================
 
 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 "mitkProportionalTimeGeometryToXML.h"
 
 #include "mitkGeometry3DToXML.h"
 
 #include <tinyxml.h>
 
-#include <boost/lexical_cast.hpp>
+#include <mitkLexicalCast.h>
 
 TiXmlElement *mitk::ProportionalTimeGeometryToXML::ToXML(const ProportionalTimeGeometry *timeGeom)
 {
   assert(timeGeom);
 
   auto *timeGeomElem = new TiXmlElement("ProportionalTimeGeometry");
   timeGeomElem->SetAttribute("NumberOfTimeSteps", timeGeom->CountTimeSteps());
   // TinyXML cannot serialize infinity (default value for time step)
   // So we guard this value and the first time point against serialization problems
   // by not writing them. The reader can then tell that absence of those values
   // means "keep the default values"
   if (timeGeom->GetFirstTimePoint() != -std::numeric_limits<TimePointType>::max())
     timeGeomElem->SetAttribute("FirstTimePoint", boost::lexical_cast<std::string>(timeGeom->GetFirstTimePoint()));
   if (timeGeom->GetStepDuration() != std::numeric_limits<TimePointType>::infinity())
     timeGeomElem->SetAttribute("StepDuration", boost::lexical_cast<std::string>(timeGeom->GetStepDuration()));
 
   for (TimeStepType t = 0; t < timeGeom->CountTimeSteps(); ++t)
   {
     // add a node for the geometry of each time step
     const Geometry3D *geom3D(nullptr);
     if ((geom3D = dynamic_cast<const Geometry3D *>(timeGeom->GetGeometryForTimeStep(t).GetPointer())))
     {
       TiXmlElement *geom3DElement = Geometry3DToXML::ToXML(geom3D);
       geom3DElement->SetAttribute("TimeStep", t); // mark order for us
       timeGeomElem->LinkEndChild(geom3DElement);
     }
     else
     {
       MITK_WARN << "Serializing a ProportionalTimeGeometry that contains something other than Geometry3D!"
                 << " (in time step " << t << ")"
                 << " File will miss information!";
     }
   }
 
   return timeGeomElem;
 }
 
 mitk::ProportionalTimeGeometry::Pointer mitk::ProportionalTimeGeometryToXML::FromXML(TiXmlElement *timeGeometryElement)
 {
   if (!timeGeometryElement)
   {
     MITK_ERROR << "Cannot deserialize ProportionalTimeGeometry from nullptr.";
     return nullptr;
   }
 
   int numberOfTimeSteps = 0;
 
   if (TIXML_SUCCESS != timeGeometryElement->QueryIntAttribute("NumberOfTimeSteps", &numberOfTimeSteps))
   {
     MITK_WARN << "<ProportionalTimeGeometry> found without NumberOfTimeSteps attribute. Counting...";
   }
 
   // might be missing!
   TimePointType firstTimePoint;
   std::string firstTimePoint_s;
   TimePointType stepDuration;
   std::string stepDuration_s;
   try
   {
     if (TIXML_SUCCESS == timeGeometryElement->QueryStringAttribute("FirstTimePoint", &firstTimePoint_s))
     {
       firstTimePoint = boost::lexical_cast<double>(firstTimePoint_s);
     }
     else
     {
       firstTimePoint = -std::numeric_limits<TimePointType>::max();
     }
 
     if (TIXML_SUCCESS == timeGeometryElement->QueryStringAttribute("StepDuration", &stepDuration_s))
     {
       stepDuration = boost::lexical_cast<double>(stepDuration_s);
     }
     else
     {
       stepDuration = std::numeric_limits<TimePointType>::infinity();
     }
   }
   catch (boost::bad_lexical_cast &e)
   {
     MITK_ERROR << "Could not parse string as number: " << e.what();
     return nullptr;
   }
 
   // list of all geometries with their time steps
   std::multimap<TimeStepType, BaseGeometry::Pointer> allReadGeometries;
 
   int indexForUnlabeledTimeStep(-1);
   for (TiXmlElement *currentElement = timeGeometryElement->FirstChildElement(); currentElement != nullptr;
        currentElement = currentElement->NextSiblingElement())
   {
     // different geometries could have been inside a ProportionalTimeGeometry.
     // By now, we only support Geometry3D
     std::string tagName = currentElement->Value();
     if (tagName == "Geometry3D")
     {
       Geometry3D::Pointer restoredGeometry = Geometry3DToXML::FromXML(currentElement);
       if (restoredGeometry.IsNotNull())
       {
         int timeStep(-1);
         if (TIXML_SUCCESS != currentElement->QueryIntAttribute("TimeStep", &timeStep))
         {
           timeStep = indexForUnlabeledTimeStep--; // decrement index for next one
           MITK_WARN << "Found <Geometry3D> without 'TimeStep' attribute in <ProportionalTimeGeometry>. No guarantees "
                        "on order anymore.";
         }
 
         if (allReadGeometries.count(static_cast<TimeStepType>(timeStep)) > 0)
         {
           MITK_WARN << "Found <Geometry3D> tags with identical 'TimeStep' attribute in <ProportionalTimeGeometry>. No "
                        "guarantees on order anymore.";
         }
 
         allReadGeometries.insert(std::make_pair(static_cast<TimeStepType>(timeStep), restoredGeometry.GetPointer()));
       }
     }
     else
     {
       MITK_WARN << "Found unsupported tag <" << tagName << "> inside <ProportionalTimeGeometry>. Ignoring.";
     }
   }
 
   // now add all BaseGeometries that were read to a new instance
   // of ProportionalTimeGeometry
   ProportionalTimeGeometry::Pointer newTimeGeometry = ProportionalTimeGeometry::New();
   newTimeGeometry->SetFirstTimePoint(firstTimePoint);
   newTimeGeometry->SetStepDuration(stepDuration);
   newTimeGeometry->ReserveSpaceForGeometries(allReadGeometries.size());
 
   TimeStepType t(0);
   for (auto entry : allReadGeometries)
   {
     // We add items with newly assigned time steps.
     // This avoids great confusion when a file contains
     // bogus numbers.
     newTimeGeometry->SetTimeStepGeometry(entry.second, t++);
   }
 
   // Need to re-calculate global bounding box.
   // This is neither stored in a file, nor done by SetTimeStepGeometry
   newTimeGeometry->UpdateBoundingBox();
 
   return newTimeGeometry;
 }
diff --git a/Modules/Core/test/DirectOverlayTest.cpp b/Modules/Core/test/DirectOverlayTest.cpp
index efd216fe9e..620160f593 100644
--- a/Modules/Core/test/DirectOverlayTest.cpp
+++ b/Modules/Core/test/DirectOverlayTest.cpp
@@ -1,237 +1,237 @@
 #include <mitkIOUtil.h>
 #include <mitkITKImageImport.h>
 #include <mitkImage.h>
 #include <mitkImageAccessByItk.h>
 #include <mitkImageCast.h>
 #include <mitkTestingMacros.h>
 
 #include <itkBinaryThresholdImageFilter.h>
 #include <itkImageFileWriter.h>
 #include <itkTestingComparisonImageFilter.h>
 
 #include <mitkImagePixelReadAccessor.h>
 
-//#include <boost/lexical_cast.hpp>
+//#include <mitkLexicalCast.h>
 
 class DirectOverlayTestClass
 {
 public:
   template <typename TPixel, unsigned int VDimensions>
   static void InternalThreshold(const itk::Image<TPixel, VDimensions> *image,
                                 mitk::Image::Pointer &output,
                                 const double th[])
   {
     typedef itk::Image<TPixel, VDimensions> InputImageType;
     typedef itk::Image<unsigned int, VDimensions> OutputImageType;
     typedef itk::BinaryThresholdImageFilter<InputImageType, OutputImageType> BinaryThresholdFilterType;
 
     typename BinaryThresholdFilterType::Pointer thresholder = BinaryThresholdFilterType::New();
     thresholder->SetInput(image);
     thresholder->SetLowerThreshold(th[0]);
     thresholder->SetUpperThreshold(th[1]);
     thresholder->SetInsideValue(255);
     thresholder->SetOutsideValue(0);
     thresholder->Update();
 
     output = mitk::ImportItkImage(thresholder->GetOutput());
     // mitk::IOUtil::Save( output, "/tmp/out.nii" );
     std::cout << "extra line";
   }
 
   template <typename TPixel, unsigned int VDimensions>
   static void InternalThreshold2(const itk::Image<TPixel, VDimensions> *image,
                                  itk::Image<unsigned int, 3>::Pointer &output,
                                  const double th[])
   {
     typedef itk::Image<TPixel, VDimensions> InputImageType;
     typedef itk::Image<unsigned int, VDimensions> OutputImageType;
     typedef itk::BinaryThresholdImageFilter<InputImageType, OutputImageType> BinaryThresholdFilterType;
 
     typename BinaryThresholdFilterType::Pointer thresholder = BinaryThresholdFilterType::New();
     thresholder->SetInput(image);
     thresholder->SetLowerThreshold(th[0]);
     thresholder->SetUpperThreshold(th[1]);
     thresholder->SetInsideValue(255);
     thresholder->SetOutsideValue(0);
     thresholder->Update();
 
     output = thresholder->GetOutput();
   }
 
   static void TestOverlay(mitk::Image::Pointer original,
                           mitk::Image::Pointer truth,
                           const double lower,
                           const double upper)
   {
     mitk::Image::Pointer overlayImage;
     const double th[] = {lower, upper};
     typedef itk::Image<unsigned int, 3> ImageType;
     ImageType::Pointer itkOverlayImage = ImageType::New();
 
     AccessByItk_2(original, InternalThreshold, overlayImage, th);
     /*
         AccessFixedDimensionByItk_2( original, InternalThreshold2,
                                      3, itkOverlayImage,
                                      th );
 
         overlayImage = mitk::ImportItkImage( itkOverlayImage );
     */
     // mitk::IOUtil::Save(truth, "/tmp/truth_TestOverlay.nii");
     try
     {
       // mitk::Image::Pointer temp = overlayImage;
       mitk::IOUtil::Save(overlayImage, "/tmp/overlayImage_TestOverlay.nrrd");
     }
     catch (const itk::ExceptionObject &e)
     {
       MITK_ERROR << "Save image: exception : " << e.what();
     }
 
     typedef itk::Image<unsigned int, 3> InputImageType;
 
     InputImageType::Pointer overlayItk;
     try
     {
       mitk::CastToItkImage(overlayImage, overlayItk);
     }
     catch (const mitk::Exception &e)
     {
       MITK_ERROR << "(CAST) Catched exception while creating accessor " << e.what();
       // MITK_TEST_FAILED_MSG("Exception for ouverlay image");
     }
 
     /*
         typedef  itk::ImageFileWriter< InputImageType  > WriterType;
         WriterType::Pointer writer = WriterType::New();
         writer->SetFileName("/tmp/overlayITK_TestOverlay.nii");
         writer->SetInput(overlayItk);
         writer->Update();
     */
     InputImageType::Pointer truthItk;
     mitk::CastToItkImage(truth, truthItk);
 
     bool difference = false;
     /*
         try
         {
           typedef unsigned int TPixel;
 
           itk::ImageRegionConstIteratorWithIndex< InputImageType > iter( truthItk, truthItk->GetLargestPossibleRegion()
        );
           iter.GoToBegin();
 
           mitk::ImagePixelReadAccessor< TPixel, 3 > readAccessor( overlayImage, overlayImage->GetVolumeData(0),
        mitk::ImageAccessorBase::ExceptionIfLocked );
 
           while( !iter.IsAtEnd() )
           {
             TPixel ref = iter.Get();
             TPixel val = readAccessor.GetPixelByIndex( iter.GetIndex() );
 
             difference |= ( ref != val );
             //if( difference )
             //{
               std::cout << iter.GetIndex() << ":" << ref << " ? " << val << "\n";
             //}
             ++iter;
           }
         }
         catch( const mitk::Exception &e)
         {
           MITK_ERROR << "Catched exception while creating accessor "<< e.what();
           //MITK_TEST_FAILED_MSG("Exception for ouverlay image");
         }
 
 
 
     */
 
     /*
         typedef itk::Testing::ComparisonImageFilter
           <InputImageType, InputImageType> ComparisonImageFilterType;
         ComparisonImageFilterType::Pointer comp =
           ComparisonImageFilterType::New();
         comp->SetValidInput(truthItk);
         comp->SetTestInput(overlayItk);
         try
         {
           comp->Update();
         }
         catch( const itk::ExceptionObject& e)
         {
           MITK_ERROR << "ITK Exception: " << e.what();
         }
     */
     typedef unsigned int TPixel;
 
     itk::ImageRegionConstIteratorWithIndex<InputImageType> iter(truthItk, truthItk->GetLargestPossibleRegion());
     itk::ImageRegionConstIteratorWithIndex<InputImageType> iter2(overlayItk, overlayItk->GetLargestPossibleRegion());
     iter.GoToBegin();
 
     unsigned int counter = 0;
     while (!iter.IsAtEnd() && !iter2.IsAtEnd())
     {
       TPixel ref = iter.Get();
       TPixel val = iter2.Get();
 
       if (ref != val)
       {
         counter++;
         //     std::cout << iter.GetIndex() << ":" << ref << " ? " << val << "\n";
       }
 
       ++iter;
       ++iter2;
     }
 
     std::cout << "Differs in " << counter << "voxels" << std::endl;
 
     MITK_TEST_CONDITION_REQUIRED(
       // comp->GetNumberOfPixelsWithDifferences() == 0,
       counter == 0,
       "Comparing overlay with ground truth")
   }
 
   static void TestDirectOverlay(char *in, char *gt, const int lower, const int upper)
   {
     mitk::Image::Pointer original = mitk::IOUtil::Load<mitk::Image>(in);
     mitk::Image::Pointer truth = mitk::IOUtil::Load<mitk::Image>(gt);
 
     if (original.IsNotNull() && original->GetDimension() == 3 && truth.IsNotNull() && truth->GetDimension() == 3 &&
         upper > lower)
     {
       TestOverlay(original, truth, lower, upper);
     }
     else
     {
       MITK_TEST_FAILED_MSG(<< "Invalid parameters");
     }
   }
 };
 
 int DirectOverlayTest(int argc, char *argv[])
 {
   MITK_TEST_BEGIN("DirectOverlay")
 
   MITK_TEST_CONDITION_REQUIRED(argc >= 5, "File to load has been specified on the command line");
 
   unsigned int lower = 0, upper = 0;
 
   try
   {
     sscanf(argv[3], "%u", &lower);
     sscanf(argv[4], "%u", &upper);
     // lower = boost::lexical_cast<double>(argv[3]);
     // upper = boost::lexical_cast<double>(argv[4]);
 
     MITK_INFO << "Got values: " << lower << " : " << upper;
   }
   catch (std::exception &e)
   {
     MITK_TEST_FAILED_MSG(<< e.what());
   }
 
   DirectOverlayTestClass::TestDirectOverlay(argv[1], argv[2], lower, upper);
 
   MITK_TEST_END()
 }
diff --git a/Modules/Core/test/mitkFloatToStringTest.cpp b/Modules/Core/test/mitkFloatToStringTest.cpp
index 027bd48aa7..bbb53654eb 100644
--- a/Modules/Core/test/mitkFloatToStringTest.cpp
+++ b/Modules/Core/test/mitkFloatToStringTest.cpp
@@ -1,146 +1,146 @@
 /*===================================================================
 
 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 "mitkTestFixture.h"
 #include "mitkTestingMacros.h"
 
-#include <boost/lexical_cast.hpp>
+#include <mitkLexicalCast.h>
 
 #include "mitkEqual.h"
 #include <cmath>
 
 #include "mitkLog.h"
 
 #include <functional>
 #include <limits>
 
 //!
 //! Verifies boost::lexical<cast> for MITK's serialization purposes
 //!
 //! Verifies:
 //! - special numbers behavior:
 //!   - infinity converted to "inf", parsed from "inf" or "infinity" (case-independent)
 //!   - not-a-number converted to "nan", parsed from "nan" (case-independent)
 //! - Default round-trip conversion double-to-string-to-double compares equal given
 //!   the MITK default epsilon value (mitk::Equal)
 //!
 class mitkFloatToStringTestSuite : public mitk::TestFixture
 {
   CPPUNIT_TEST_SUITE(mitkFloatToStringTestSuite);
   MITK_TEST(ConfirmStringValues<float>);
   MITK_TEST(ConfirmStringValues<double>);
   MITK_TEST(TestConversions<float>);
   MITK_TEST(TestConversions<double>);
   CPPUNIT_TEST_SUITE_END();
 
 public:
   template <typename DATATYPE>
   void ConfirmNumberToString(DATATYPE number, const std::string &s)
 
   {
     CPPUNIT_ASSERT_EQUAL(boost::lexical_cast<std::string>(number), s);
   }
 
   template <typename DATATYPE>
   void ConfirmStringToNumber(const std::string &s, DATATYPE number)
 
   {
     CPPUNIT_ASSERT_EQUAL(number, boost::lexical_cast<DATATYPE>(s));
   }
 
   template <typename DATATYPE>
   void ConfirmStringValues()
   {
     // we want to make sure that the following strings will be accepted and returned
     // by our conversion functions. This must not change in the future to ensure compatibility
     auto nan = boost::lexical_cast<DATATYPE>("nan");
     CPPUNIT_ASSERT_MESSAGE("nan==nan must be false", !(nan == nan));
     nan = boost::lexical_cast<DATATYPE>("NAN");
     CPPUNIT_ASSERT_MESSAGE("NAN==NAN must be false", !(nan == nan));
 
     std::string s_nan = boost::lexical_cast<std::string>(nan);
     CPPUNIT_ASSERT_EQUAL(std::string("nan"), s_nan);
 
     ConfirmStringToNumber("inf", std::numeric_limits<DATATYPE>::infinity());
     ConfirmStringToNumber("INF", std::numeric_limits<DATATYPE>::infinity());
     ConfirmStringToNumber("infinity", std::numeric_limits<DATATYPE>::infinity());
     ConfirmStringToNumber("INFINITY", std::numeric_limits<DATATYPE>::infinity());
 
     ConfirmStringToNumber("-inf", -std::numeric_limits<DATATYPE>::infinity());
     ConfirmStringToNumber("-INF", -std::numeric_limits<DATATYPE>::infinity());
     ConfirmStringToNumber("-infinity", -std::numeric_limits<DATATYPE>::infinity());
     ConfirmStringToNumber("-INFINITY", -std::numeric_limits<DATATYPE>::infinity());
 
     ConfirmNumberToString(std::numeric_limits<DATATYPE>::infinity(), "inf");
     ConfirmNumberToString(-std::numeric_limits<DATATYPE>::infinity(), "-inf");
   }
 
   template <typename DATATYPE>
   void CheckRoundTrip(DATATYPE number, DATATYPE tolerance)
   {
     std::string s = boost::lexical_cast<std::string>(number);
     auto number2 = boost::lexical_cast<DATATYPE>(s);
 
     CPPUNIT_ASSERT_MESSAGE(std::string("Must not parse string ") + s + " as NaN", number2 == number2);
     if (tolerance == 0)
     {
       CPPUNIT_ASSERT_EQUAL(number, number2);
     }
     else // mitk::Equal cannot take 0 as tolerance
     {
       CPPUNIT_ASSERT(mitk::Equal(number, number2, tolerance));
     }
   }
 
   template <typename DATATYPE>
   void CheckRoundTrip(const std::string &input)
   {
     auto number = boost::lexical_cast<DATATYPE>(input);
     std::string result = boost::lexical_cast<std::string>(number);
 
     // There are normal imprecisions when converting to string
     // We do only compare if the numeric values match "close enough"
     auto number2 = boost::lexical_cast<DATATYPE>(result);
     CPPUNIT_ASSERT(mitk::Equal(number, number2));
   }
 
   template <typename DATATYPE>
   void TestConversions()
   {
     // we cannot test the NaN roundtrip because nan == nan will never be true
     CheckRoundTrip<DATATYPE>(std::numeric_limits<DATATYPE>::infinity(), 0.0);
     CheckRoundTrip<DATATYPE>(-std::numeric_limits<DATATYPE>::infinity(), 0.0);
 
     CheckRoundTrip<DATATYPE>(std::numeric_limits<DATATYPE>::denorm_min(), mitk::eps);
     CheckRoundTrip<DATATYPE>(std::numeric_limits<DATATYPE>::epsilon(), mitk::eps);
     CheckRoundTrip<DATATYPE>(std::numeric_limits<DATATYPE>::lowest(), mitk::eps);
     CheckRoundTrip<DATATYPE>(std::numeric_limits<DATATYPE>::min(), mitk::eps);
     CheckRoundTrip<DATATYPE>(std::numeric_limits<DATATYPE>::max(), mitk::eps);
     CheckRoundTrip<DATATYPE>(sqrt(2), mitk::eps);
     CheckRoundTrip<DATATYPE>(0.000000042, mitk::eps);
     CheckRoundTrip<DATATYPE>(422345678.2345678, mitk::eps);
     CheckRoundTrip<DATATYPE>(0.0, 0);
     CheckRoundTrip<DATATYPE>(-0.0, 0);
 
     CheckRoundTrip<DATATYPE>("1");
     CheckRoundTrip<DATATYPE>("1.1");
     CheckRoundTrip<DATATYPE>("1.12121212");
     CheckRoundTrip<DATATYPE>("1.1e-2");
   }
 
 }; // class
 
 MITK_TEST_SUITE_REGISTRATION(mitkFloatToString)
diff --git a/Modules/DicomRT/autoload/IO/mitkRTDoseReaderService.cpp b/Modules/DicomRT/autoload/IO/mitkRTDoseReaderService.cpp
index 74b935d036..3b75360031 100644
--- a/Modules/DicomRT/autoload/IO/mitkRTDoseReaderService.cpp
+++ b/Modules/DicomRT/autoload/IO/mitkRTDoseReaderService.cpp
@@ -1,172 +1,172 @@
 /*===================================================================
 
 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 "mitkRTDoseReaderService.h"
 
-#include <boost/lexical_cast.hpp>
+#include <mitkLexicalCast.h>
 
 #include <mitkImageAccessByItk.h>
 #include <mitkImageCast.h>
 #include <mitkDICOMFileReaderSelector.h>
 #include <mitkDICOMFileReader.h>
 #include <mitkRTConstants.h>
 #include <mitkImageStatisticsHolder.h>
 #include <mitkDICOMTagPath.h>
 #include "mitkDICOMDCMTKTagScanner.h"
 #include "mitkDicomRTIOMimeTypes.h"
 #include <mitkDICOMIOHelper.h>
 
 #include "dcmtk/dcmrt/drtdose.h"
 
 #include <itkShiftScaleImageFilter.h>
 #include <itkCastImageFilter.h>
 
 namespace mitk
 {
 
   RTDoseReaderService::RTDoseReaderService() : AbstractFileReader(CustomMimeType(mitk::DicomRTIOMimeTypes::DICOMRT_DOSE_MIMETYPE_NAME()), mitk::DicomRTIOMimeTypes::DICOMRT_DOSE_MIMETYPE_DESCRIPTION()) {
     m_FileReaderServiceReg = RegisterService();
   }
 
   RTDoseReaderService::RTDoseReaderService(const RTDoseReaderService& other) : mitk::AbstractFileReader(other)
   {
 
   }
 
   RTDoseReaderService::~RTDoseReaderService() {}
 
   template<typename TPixel, unsigned int VImageDimension>
   void RTDoseReaderService::MultiplyGridScaling(itk::Image<TPixel, VImageDimension>* image, float gridscale)
   {
     typedef itk::Image<Float32, VImageDimension> OutputImageType;
     typedef itk::Image<TPixel, VImageDimension> InputImageType;
 
     typedef itk::CastImageFilter<InputImageType, OutputImageType> CastFilterType;
     typedef itk::ShiftScaleImageFilter<OutputImageType, OutputImageType> ScaleFilterType;
     typename CastFilterType::Pointer castFilter = CastFilterType::New();
     typename ScaleFilterType::Pointer scaleFilter = ScaleFilterType::New();
 
     castFilter->SetInput(image);
     scaleFilter->SetInput(castFilter->GetOutput());
     scaleFilter->SetScale(gridscale);
     scaleFilter->Update();
     typename OutputImageType::Pointer scaledOutput = scaleFilter->GetOutput();
     this->scaledDoseImage = mitk::Image::New();
 
     mitk::CastToMitkImage(scaledOutput, this->scaledDoseImage);
   }
 
   std::vector<itk::SmartPointer<BaseData> > RTDoseReaderService::Read()
   {
     std::vector<itk::SmartPointer<mitk::BaseData> > result;
 
 
     mitk::IDICOMTagsOfInterest* toiSrv = GetDicomTagsOfInterestService();
 
     auto tagsOfInterest = toiSrv->GetTagsOfInterest();
 
     DICOMTagPathList tagsOfInterestList;
     for (const auto& tag : tagsOfInterest) {
       tagsOfInterestList.push_back(tag.first);
     }
 
     std::string location = GetInputLocation();
     mitk::DICOMFileReaderSelector::Pointer selector = mitk::DICOMFileReaderSelector::New();
     selector->LoadBuiltIn3DConfigs();
     selector->SetInputFiles({ location });
 
     mitk::DICOMFileReader::Pointer reader = selector->GetFirstReaderWithMinimumNumberOfOutputImages();
     reader->SetAdditionalTagsOfInterest(toiSrv->GetTagsOfInterest());
 
     reader->SetInputFiles({ location });
     reader->AnalyzeInputFiles();
     reader->LoadImages();
 
     if (reader->GetNumberOfOutputs() == 0) {
       MITK_ERROR << "Could not determine a DICOM reader for this file" << std::endl;
       return result;
     }
 
     mitk::DICOMDCMTKTagScanner::Pointer scanner = mitk::DICOMDCMTKTagScanner::New();
     scanner->SetInputFiles({ location });
     scanner->AddTagPaths(tagsOfInterestList);
     scanner->Scan();
 
     mitk::DICOMDatasetAccessingImageFrameList frames = scanner->GetFrameInfoList();
     if (frames.empty()) {
       MITK_ERROR << "Error reading the RTDOSE file" << std::endl;
       return result;
     }
 
     const mitk::DICOMImageBlockDescriptor& desc = reader->GetOutput(0);
 
     mitk::Image::Pointer originalImage = desc.GetMitkImage();
 
     if (originalImage.IsNull())
     {
       MITK_ERROR << "Error reading the RTDOSE file in mitk::DicomFileReader" << std::endl;
       return result;
     }
 
     DcmFileFormat fileformat;
     OFCondition outp = fileformat.loadFile(location.c_str(), EXS_Unknown);
     if (outp.bad())
     {
       MITK_ERROR << "Error reading the RTDOSE file in DCMTK" << std::endl;
       return result;
     }
     DcmDataset *dataset = fileformat.getDataset();
 
     DRTDoseIOD doseObject;
     OFCondition DCMTKresult = doseObject.read(*dataset);
 
     if (DCMTKresult.bad())
     {
       MITK_ERROR << "Error reading the RTDOSE file in DCMTK" << std::endl;
       return result;
     }
 
     auto findingsGridScaling = frames.front()->GetTagValueAsString(DICOMTagPath(0x3004, 0x000e)); //(0x3004, 0x000e) is grid scaling
 
     double gridScaling;
     if (findingsGridScaling.empty()) {
       MITK_ERROR << "Could not find DoseGridScaling tag" << std::endl;
       return result;
     }
     else {
       gridScaling = boost::lexical_cast<double>(findingsGridScaling.front().value);
     }
 
     AccessByItk_1(originalImage, MultiplyGridScaling, gridScaling);
 
     auto statistics = this->scaledDoseImage->GetStatistics();
     double maxDose = statistics->GetScalarValueMax();
 
     this->scaledDoseImage->SetPropertyList(originalImage->GetPropertyList());
     this->scaledDoseImage->SetProperty(mitk::RTConstants::PRESCRIBED_DOSE_PROPERTY_NAME.c_str(), mitk::GenericProperty<double>::New(0.8*maxDose));
     auto findings = ExtractPathsOfInterest(tagsOfInterestList, frames);
     SetProperties(this->scaledDoseImage, findings);
 
     result.push_back(this->scaledDoseImage.GetPointer());
     return result;
   }
 
   RTDoseReaderService* RTDoseReaderService::Clone() const
   {
     return new RTDoseReaderService(*this);
   }
 }
diff --git a/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkNrrdTensorImageReader.cpp b/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkNrrdTensorImageReader.cpp
index f1315466d6..c6449ec8c0 100644
--- a/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkNrrdTensorImageReader.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkNrrdTensorImageReader.cpp
@@ -1,428 +1,428 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "mitkNrrdTensorImageReader.h"
 #include <mitkCustomMimeType.h>
 #include "mitkDiffusionCoreIOMimeTypes.h"
 
 #include "itkImageFileReader.h"
 #include "itkImageRegionIterator.h"
 #include "itkMetaDataObject.h"
 #include "itkNrrdImageIO.h"
 #include <itkNiftiImageIO.h>
 
 #include "mitkITKImageImport.h"
 #include "mitkImageDataItem.h"
 #include <mitkLocaleSwitch.h>
 #include <mitkIOUtil.h>
-#include <boost/lexical_cast.hpp>
+#include <mitkLexicalCast.h>
 
 namespace mitk
 {
 
   NrrdTensorImageReader::NrrdTensorImageReader(const NrrdTensorImageReader& other)
     : mitk::AbstractFileReader(other)
   {
   }
 
   NrrdTensorImageReader::NrrdTensorImageReader()
     : mitk::AbstractFileReader( CustomMimeType( mitk::DiffusionCoreIOMimeTypes::DTI_MIMETYPE() ), mitk::DiffusionCoreIOMimeTypes::DTI_MIMETYPE_DESCRIPTION() )
   {
     m_ServiceReg = this->RegisterService();
   }
 
   NrrdTensorImageReader::~NrrdTensorImageReader()
   {
   }
 
   std::vector<itk::SmartPointer<BaseData> > NrrdTensorImageReader::Read()
   {
     std::vector<itk::SmartPointer<mitk::BaseData> > result;
     std::string location = GetInputLocation();
 
     if ( location == "")
     {
       throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, the filename is empty!");
     }
     else
     {
       try
       {
         mitk::LocaleSwitch localeSwitch("C");
 
         try
         {
           std::string fname3 = mitk::IOUtil::GetTempPath()+"/temp_dti.nii.gz";
 
           int c = 0;
           while( itksys::SystemTools::FileExists(fname3) )
           {
             fname3 = mitk::IOUtil::GetTempPath()+"/temp_dti_" + boost::lexical_cast<std::string>(c) + ".nii.gz";
             ++c;
           }
 
           itksys::SystemTools::CopyAFile(location.c_str(), fname3.c_str());
 
           typedef itk::VectorImage<float,3> ImageType;
           itk::NiftiImageIO::Pointer io = itk::NiftiImageIO::New();
           typedef itk::ImageFileReader<ImageType> FileReaderType;
           FileReaderType::Pointer reader = FileReaderType::New();
           reader->SetImageIO(io);
           reader->SetFileName(fname3);
           reader->Update();
           ImageType::Pointer img = reader->GetOutput();
 
           TensorImage::ItkTensorImageType::Pointer vecImg = TensorImage::ItkTensorImageType::New();
           vecImg->SetSpacing( img->GetSpacing() );   // Set the image spacing
           vecImg->SetOrigin( img->GetOrigin() );     // Set the image origin
           vecImg->SetDirection( img->GetDirection() );  // Set the image direction
           vecImg->SetRegions( img->GetLargestPossibleRegion());
           vecImg->Allocate();
 
           itk::ImageRegionIterator<TensorImage::ItkTensorImageType> ot (vecImg, vecImg->GetLargestPossibleRegion() );
           ot.GoToBegin();
 
           itk::ImageRegionIterator<ImageType> it (img, img->GetLargestPossibleRegion() );
           it.GoToBegin();
 
           typedef ImageType::PixelType  VarPixType;
           typedef TensorImage::PixelType FixPixType;
           int numComponents = img->GetNumberOfComponentsPerPixel();
 
           if (numComponents==6)
           {
             MITK_INFO << "Trying to load dti as 6-comp nifti ...";
             while (!it.IsAtEnd())
             {
               VarPixType vec = it.Get();
               FixPixType fixVec(vec.GetDataPointer());
 
               TensorImage::PixelType tensor;
               tensor.SetElement(0, vec.GetElement(0));
               tensor.SetElement(1, vec.GetElement(1));
               tensor.SetElement(2, vec.GetElement(2));
               tensor.SetElement(3, vec.GetElement(3));
               tensor.SetElement(4, vec.GetElement(4));
               tensor.SetElement(5, vec.GetElement(5));
 
               fixVec = tensor;
 
               ot.Set(fixVec);
               ++ot;
               ++it;
             }
           }
           else if(numComponents==9)
           {
             MITK_INFO << "Trying to load dti as 9-comp nifti ...";
             while (!it.IsAtEnd())
             {
               VarPixType vec = it.Get();
               TensorImage::PixelType tensor;
               tensor.SetElement(0, vec.GetElement(0));
               tensor.SetElement(1, vec.GetElement(1));
               tensor.SetElement(2, vec.GetElement(2));
               tensor.SetElement(3, vec.GetElement(4));
               tensor.SetElement(4, vec.GetElement(5));
               tensor.SetElement(5, vec.GetElement(8));
 
               FixPixType fixVec(tensor);
               ot.Set(fixVec);
               ++ot;
               ++it;
             }
           }
           else if (numComponents==1)
           {
             MITK_INFO << "Trying to load dti as 4D nifti ...";
             typedef itk::Image<float,4> ImageType;
             typedef itk::ImageFileReader<ImageType> FileReaderType;
             FileReaderType::Pointer reader = FileReaderType::New();
             reader->SetImageIO(io);
             reader->SetFileName(fname3);
             reader->Update();
             ImageType::Pointer img = reader->GetOutput();
 
             itk::Size<4> size = img->GetLargestPossibleRegion().GetSize();
 
             while (!ot.IsAtEnd())
             {
               TensorImage::PixelType tensor;
               ImageType::IndexType idx;
               idx[0] = ot.GetIndex()[0]; idx[1] = ot.GetIndex()[1]; idx[2] = ot.GetIndex()[2];
 
               if (size[3]==6)
               {
                 for (unsigned int te=0; te<size[3]; te++)
                 {
                   idx[3] = te;
                   tensor.SetElement(te, img->GetPixel(idx));
                 }
               }
               else if (size[3]==9)
               {
                 idx[3] = 0;
                 tensor.SetElement(0, img->GetPixel(idx));
                 idx[3] = 1;
                 tensor.SetElement(1, img->GetPixel(idx));
                 idx[3] = 2;
                 tensor.SetElement(2, img->GetPixel(idx));
                 idx[3] = 4;
                 tensor.SetElement(3, img->GetPixel(idx));
                 idx[3] = 5;
                 tensor.SetElement(4, img->GetPixel(idx));
                 idx[3] = 8;
                 tensor.SetElement(5, img->GetPixel(idx));
               }
               else
                 throw itk::ImageFileReaderException(__FILE__, __LINE__, "Unknown number of components for DTI file. Should be 6 or 9!");
 
               FixPixType fixVec(tensor);
               ot.Set(fixVec);
               ++ot;
             }
           }
           OutputType::Pointer resultImage = OutputType::New();
           resultImage->InitializeByItk( vecImg.GetPointer() );
           resultImage->SetVolume( vecImg->GetBufferPointer() );
           result.push_back( resultImage.GetPointer() );
         }
         catch(...)
         {
           MITK_INFO << "Trying to load dti as nrrd ...";
 
           typedef itk::VectorImage<float,3> ImageType;
           itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
           typedef itk::ImageFileReader<ImageType> FileReaderType;
           FileReaderType::Pointer reader = FileReaderType::New();
           reader->SetImageIO(io);
           reader->SetFileName(location);
           reader->Update();
           ImageType::Pointer img = reader->GetOutput();
 
           TensorImage::ItkTensorImageType::Pointer vecImg = TensorImage::ItkTensorImageType::New();
           vecImg->SetSpacing( img->GetSpacing() );   // Set the image spacing
           vecImg->SetOrigin( img->GetOrigin() );     // Set the image origin
           vecImg->SetDirection( img->GetDirection() );  // Set the image direction
           vecImg->SetRegions( img->GetLargestPossibleRegion());
           vecImg->Allocate();
 
           itk::ImageRegionIterator<TensorImage::ItkTensorImageType> ot (vecImg, vecImg->GetLargestPossibleRegion() );
           ot.GoToBegin();
 
           itk::ImageRegionIterator<ImageType> it (img, img->GetLargestPossibleRegion() );
           it.GoToBegin();
 
           typedef ImageType::PixelType  VarPixType;
           typedef TensorImage::PixelType FixPixType;
           int numComponents = img->GetNumberOfComponentsPerPixel();
 
           itk::MetaDataDictionary imgMetaDictionary = img->GetMetaDataDictionary();
           std::vector<std::string> imgMetaKeys = imgMetaDictionary.GetKeys();
           std::vector<std::string>::const_iterator itKey = imgMetaKeys.begin();
           std::string metaString;
 
           bool readFrame = false;
           double xx, xy, xz, yx, yy, yz, zx, zy, zz;
           MeasurementFrameType measFrame;
           measFrame.SetIdentity();
           MeasurementFrameType measFrameTransp;
           measFrameTransp.SetIdentity();
 
           for (; itKey != imgMetaKeys.end(); itKey ++)
           {
             itk::ExposeMetaData<std::string> (imgMetaDictionary, *itKey, metaString);
             if (itKey->find("measurement frame") != std::string::npos)
             {
               sscanf(metaString.c_str(), " ( %lf , %lf , %lf ) ( %lf , %lf , %lf ) ( %lf , %lf , %lf ) \n", &xx, &xy, &xz, &yx, &yy, &yz, &zx, &zy, &zz);
 
               if (xx>10e-10 || xy>10e-10 || xz>10e-10 ||
                 yx>10e-10 || yy>10e-10 || yz>10e-10 ||
                 zx>10e-10 || zy>10e-10 || zz>10e-10 )
               {
                 readFrame = true;
 
                 measFrame(0,0) = xx;
                 measFrame(0,1) = xy;
                 measFrame(0,2) = xz;
                 measFrame(1,0) = yx;
                 measFrame(1,1) = yy;
                 measFrame(1,2) = yz;
                 measFrame(2,0) = zx;
                 measFrame(2,1) = zy;
                 measFrame(2,2) = zz;
 
                 measFrameTransp = measFrame.GetTranspose();
               }
             }
           }
 
           if (numComponents==6)
           {
             while (!it.IsAtEnd())
             {
               // T'=RTR'
               VarPixType vec = it.Get();
               FixPixType fixVec(vec.GetDataPointer());
 
               if(readFrame)
               {
                 TensorImage::PixelType tensor;
                 tensor.SetElement(0, vec.GetElement(0));
                 tensor.SetElement(1, vec.GetElement(1));
                 tensor.SetElement(2, vec.GetElement(2));
                 tensor.SetElement(3, vec.GetElement(3));
                 tensor.SetElement(4, vec.GetElement(4));
                 tensor.SetElement(5, vec.GetElement(5));
 
                 tensor = ConvertMatrixTypeToFixedArrayType(tensor.PreMultiply(measFrame));
                 tensor = ConvertMatrixTypeToFixedArrayType(tensor.PostMultiply(measFrameTransp));
                 fixVec = tensor;
               }
 
               ot.Set(fixVec);
               ++ot;
               ++it;
             }
           }
           else if(numComponents==9)
           {
             while (!it.IsAtEnd())
             {
               VarPixType vec = it.Get();
               TensorImage::PixelType tensor;
               tensor.SetElement(0, vec.GetElement(0));
               tensor.SetElement(1, vec.GetElement(1));
               tensor.SetElement(2, vec.GetElement(2));
               tensor.SetElement(3, vec.GetElement(4));
               tensor.SetElement(4, vec.GetElement(5));
               tensor.SetElement(5, vec.GetElement(8));
 
               if(readFrame)
               {
                 tensor = ConvertMatrixTypeToFixedArrayType(tensor.PreMultiply(measFrame));
                 tensor = ConvertMatrixTypeToFixedArrayType(tensor.PostMultiply(measFrameTransp));
               }
 
               FixPixType fixVec(tensor);
               ot.Set(fixVec);
               ++ot;
               ++it;
             }
           }
           else if (numComponents==1)
           {
             typedef itk::Image<float,4> ImageType;
             itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
             typedef itk::ImageFileReader<ImageType> FileReaderType;
             FileReaderType::Pointer reader = FileReaderType::New();
             reader->SetImageIO(io);
             reader->SetFileName(location);
             reader->Update();
             ImageType::Pointer img = reader->GetOutput();
 
             itk::Size<4> size = img->GetLargestPossibleRegion().GetSize();
 
             while (!ot.IsAtEnd())
             {
               TensorImage::PixelType tensor;
               ImageType::IndexType idx;
               idx[0] = ot.GetIndex()[0]; idx[1] = ot.GetIndex()[1]; idx[2] = ot.GetIndex()[2];
 
               if (size[3]==6)
               {
                 for (unsigned int te=0; te<size[3]; te++)
                 {
                   idx[3] = te;
                   tensor.SetElement(te, img->GetPixel(idx));
                 }
               }
               else if (size[3]==9)
               {
                 idx[3] = 0;
                 tensor.SetElement(0, img->GetPixel(idx));
                 idx[3] = 1;
                 tensor.SetElement(1, img->GetPixel(idx));
                 idx[3] = 2;
                 tensor.SetElement(2, img->GetPixel(idx));
                 idx[3] = 4;
                 tensor.SetElement(3, img->GetPixel(idx));
                 idx[3] = 5;
                 tensor.SetElement(4, img->GetPixel(idx));
                 idx[3] = 8;
                 tensor.SetElement(5, img->GetPixel(idx));
               }
               else
                 throw itk::ImageFileReaderException(__FILE__, __LINE__, "Unknown number of komponents for DTI file. Should be 6 or 9!");
 
               if(readFrame)
               {
                 tensor = ConvertMatrixTypeToFixedArrayType(tensor.PreMultiply(measFrame));
                 tensor = ConvertMatrixTypeToFixedArrayType(tensor.PostMultiply(measFrameTransp));
               }
               FixPixType fixVec(tensor);
               ot.Set(fixVec);
               ++ot;
             }
           }
           else
           {
             throw itk::ImageFileReaderException(__FILE__, __LINE__, "Image has wrong number of pixel components!");
           }
 
           OutputType::Pointer resultImage = OutputType::New();
           resultImage->InitializeByItk( vecImg.GetPointer() );
           resultImage->SetVolume( vecImg->GetBufferPointer() );
           result.push_back( resultImage.GetPointer() );
         }
 
       }
       catch(std::exception& e)
       {
         throw itk::ImageFileReaderException(__FILE__, __LINE__, e.what());
       }
       catch(...)
       {
         throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, an error occurred while reading the requested DTI file!");
       }
     }
 
     return result;
   }
 
 TensorImage::PixelType NrrdTensorImageReader
 ::ConvertMatrixTypeToFixedArrayType(const TensorImage::PixelType::Superclass::MatrixType & matrix)
 {
     /*       | 0  1  2  |
       *       | X  3  4  |
       *       | X  X  5  |
       */
     TensorImage::PixelType arr;
     arr.SetElement(0,matrix(0,0));
     arr.SetElement(1,matrix(0,1));
     arr.SetElement(2,matrix(0,2));
     arr.SetElement(3,matrix(1,3));
     arr.SetElement(4,matrix(1,4));
     arr.SetElement(5,matrix(2,5));
     return arr;
 }
 
 } //namespace MITK
 
 mitk::NrrdTensorImageReader* mitk::NrrdTensorImageReader::Clone() const
 {
   return new NrrdTensorImageReader(*this);
 }
diff --git a/Modules/DiffusionImaging/DiffusionCore/cmdapps/ResampleGradients.cpp b/Modules/DiffusionImaging/DiffusionCore/cmdapps/ResampleGradients.cpp
index c87ecf2b02..74b85c1966 100644
--- a/Modules/DiffusionImaging/DiffusionCore/cmdapps/ResampleGradients.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/cmdapps/ResampleGradients.cpp
@@ -1,243 +1,243 @@
 /*===================================================================
 
 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 <vector>
 #include <iostream>
 #include <fstream>
 #include <algorithm>
 #include <string>
 #include <istream>
 
 #include <itkImageFileWriter.h>
 #include <itkMetaDataObject.h>
 #include <itkVectorImage.h>
 #include <mitkImageCast.h>
 
 #include <mitkBaseData.h>
 #include "mitkCommandLineParser.h"
-#include <boost/lexical_cast.hpp>
+#include <mitkLexicalCast.h>
 #include <mitkCoreObjectFactory.h>
 #include <mitkIOUtil.h>
 
 #include <mitkBValueMapProperty.h>
 #include <mitkGradientDirectionsProperty.h>
 #include <itkElectrostaticRepulsionDiffusionGradientReductionFilter.h>
 
 
 // itk includes
 #include <itkImage.h>
 
 // mitk includes
 #include <mitkImage.h>
 #include "itkDWIVoxelFunctor.h"
 #include <mitkDiffusionPropertyHelper.h>
 
 typedef short DiffusionPixelType;
 typedef itk::VectorImage< short, 3 > ItkDwiType;
 
 // itk includes
 #include "itkTimeProbe.h"
 #include "itkB0ImageExtractionImageFilter.h"
 #include "itkB0ImageExtractionToSeparateImageFilter.h"
 #include "itkBrainMaskExtractionImageFilter.h"
 #include "itkCastImageFilter.h"
 #include "itkVectorContainer.h"
 #include <itkElectrostaticRepulsionDiffusionGradientReductionFilter.h>
 #include <itkMergeDiffusionImagesFilter.h>
 #include <itkDwiGradientLengthCorrectionFilter.h>
 #include <itkDwiNormilzationFilter.h>
 #include <mitkTensorImage.h>
 #include <mitkOdfImage.h>
 
 // Multishell includes
 #include <itkRadialMultishellToSingleshellImageFilter.h>
 
 // Multishell Functors
 #include <itkADCAverageFunctor.h>
 #include <itkKurtosisFitFunctor.h>
 #include <itkBiExpFitFunctor.h>
 #include <itkADCFitFunctor.h>
 
 // mitk includes
 #include "mitkProgressBar.h"
 #include "mitkStatusBar.h"
 #include "mitkNodePredicateDataType.h"
 #include "mitkProperties.h"
 #include "mitkVtkResliceInterpolationProperty.h"
 #include "mitkLookupTable.h"
 #include "mitkLookupTableProperty.h"
 #include "mitkTransferFunction.h"
 #include "mitkTransferFunctionProperty.h"
 //#include "mitkDataNodeObject.h"
 #include "mitkOdfNormalizationMethodProperty.h"
 #include "mitkOdfScaleByProperty.h"
 #include <mitkPointSet.h>
 #include <itkAdcImageFilter.h>
 #include <itkBrainMaskExtractionImageFilter.h>
 #include <mitkImageCast.h>
 #include <mitkRotationOperation.h>
 //#include <QTableWidgetItem>
 //#include <QTableWidget>
 #include <mitkInteractionConst.h>
 #include <mitkImageAccessByItk.h>
 #include <itkResampleDwiImageFilter.h>
 #include <itkResampleImageFilter.h>
 #include <itkImageDuplicator.h>
 #include <itkMaskImageFilter.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateOr.h>
 #include <itkCropImageFilter.h>
 #include <itkDiffusionTensor3DReconstructionImageFilter.h>
 #include <itkRemoveDwiChannelFilter.h>
 #include <itkExtractDwiChannelFilter.h>
 #include <mitkITKImageImport.h>
 #include <mitkBValueMapProperty.h>
 #include <mitkGradientDirectionsProperty.h>
 #include <mitkMeasurementFrameProperty.h>
 #include <itkImageDuplicator.h>
 #include <itkFlipImageFilter.h>
 #include <mitkITKImageImport.h>
 #include "mitkPreferenceListReaderOptionsFunctor.h"
 
 mitk::Image::Pointer DoReduceGradientDirections(mitk::Image::Pointer image, double BValue, unsigned int numOfGradientsToKeep)
 {
 
   bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(image) );
   if ( !isDiffusionImage ) {
     std::cout << "Image is not a Diffusion Weighted Image" << std::endl;
     //return;
   }
 
   typedef itk::ElectrostaticRepulsionDiffusionGradientReductionFilter<DiffusionPixelType, DiffusionPixelType> FilterType;
   typedef mitk::BValueMapProperty::BValueMap BValueMap;
 
   BValueMap shellSlectionMap;
   BValueMap originalShellMap = static_cast<mitk::BValueMapProperty*>
     (image->GetProperty(mitk::DiffusionPropertyHelper::BVALUEMAPPROPERTYNAME.c_str()).GetPointer() )
       ->GetBValueMap();
 
   std::vector<unsigned int> newNumGradientDirections;
 
   //Keeps 1 b0 gradient
   double B0Value = 0;
   shellSlectionMap[B0Value] = originalShellMap[B0Value];
   unsigned int num = 1;
   newNumGradientDirections.push_back(num);
 
   //BValue = 1000;
   shellSlectionMap[BValue] = originalShellMap[BValue];
   //numOfGradientsToKeep = 32;
   newNumGradientDirections.push_back(numOfGradientsToKeep);
 
 
   if (newNumGradientDirections.empty()) {
     std::cout << "newNumGradientDirections is empty" << std::endl;
     //return;
   }
 
   itk::DwiGradientLengthCorrectionFilter::GradientDirectionContainerType::Pointer gradientContainer
       = static_cast<mitk::GradientDirectionsProperty*>
         ( image->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )
           ->GetGradientDirectionsContainer();
 
 
   ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
   mitk::CastToItkImage(image, itkVectorImagePointer);
   std::cout << "1" << std::endl;
   FilterType::Pointer filter = FilterType::New();
   filter->SetInput( itkVectorImagePointer );
   filter->SetOriginalGradientDirections(gradientContainer);
   filter->SetNumGradientDirections(newNumGradientDirections);
   filter->SetOriginalBValueMap(originalShellMap);
   filter->SetShellSelectionBValueMap(shellSlectionMap);
   filter->Update();
   std::cout << "2" << std::endl;
 
   if( filter->GetOutput() == nullptr) {
     std::cout << "filter get output is nullptr" << std::endl;
   }
 
   mitk::Image::Pointer newImage = mitk::GrabItkImageMemory( filter->GetOutput() );
   mitk::DiffusionPropertyHelper::CopyProperties(image, newImage, true);
 
   newImage->GetPropertyList()->ReplaceProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(),
                          mitk::GradientDirectionsProperty::New( filter->GetGradientDirections() ) );
 
   mitk::DiffusionPropertyHelper propertyHelper( newImage );
   propertyHelper.InitializeImage(); //needed?
 
   return newImage;
 }
 
 
 
 /*!
 \brief Resample gradients of input DWI image.
 */
 int main(int argc, char* argv[])
 {
     mitkCommandLineParser parser;
 
     parser.setTitle("Resample Gradients");
     parser.setCategory("Preprocessing Tools");
     parser.setDescription("Resample gradients of input DWI image. You can select one b-value shell and the number of gradients within this shell you want to have. It will also keep one b0 image.");
     parser.setContributor("MIC");
 
     parser.setArgumentPrefix("--", "-");
     parser.addArgument("input", "i", mitkCommandLineParser::String, "Input:", "input image", us::Any(), false);
     parser.addArgument("output", "o", mitkCommandLineParser::String, "Output:", "output image", us::Any(), false);
     parser.addArgument("bValue", "b", mitkCommandLineParser::Float, "b-value:", "float", 1000, false);
     parser.addArgument("nrOfGradients", "n", mitkCommandLineParser::Int, "Nr of gradients:", "integer", 32, false);
 
 
     std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
     if (parsedArgs.size()==0)
         return EXIT_FAILURE;
 
 
     std::string inFileName = us::any_cast<std::string>(parsedArgs["input"]);
     std::string outFileName = us::any_cast<std::string>(parsedArgs["output"]);
     double bValue = us::any_cast<float>(parsedArgs["bValue"]);
     unsigned int nrOfGradients = us::any_cast<int>(parsedArgs["nrOfGradients"]);
 
     try
     {
         mitk::PreferenceListReaderOptionsFunctor functor = mitk::PreferenceListReaderOptionsFunctor({ "Diffusion Weighted Images" }, {});
         mitk::Image::Pointer mitkImage = mitk::IOUtil::Load<mitk::Image>(inFileName, &functor);
         mitk::Image::Pointer newImage = DoReduceGradientDirections(mitkImage, bValue, nrOfGradients);
         //mitk::IOUtil::Save(newImage, outFileName); //save as dwi image
         mitk::IOUtil::Save(newImage, "application/vnd.mitk.nii.gz", outFileName);  //save as nifti image
 
     }
     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/DiffusionIO/mitkFiberBundleDicomReader.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleDicomReader.cpp
index 17e0a7e30d..07d33c1ca0 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleDicomReader.cpp
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleDicomReader.cpp
@@ -1,180 +1,180 @@
 /*===================================================================
 
 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 "mitkFiberBundleDicomReader.h"
 #include <itkMetaDataObject.h>
 #include <vtkPolyData.h>
 #include <vtkDataReader.h>
 #include <vtkPolyDataReader.h>
 #include <vtkMatrix4x4.h>
 #include <vtkPolyLine.h>
 #include <vtkCellArray.h>
 #include <vtkDataArray.h>
 #include <vtkFloatArray.h>
 #include <vtkCellData.h>
 #include <vtkPointData.h>
 #include <itksys/SystemTools.hxx>
 #include <tinyxml.h>
 #include <vtkCleanPolyData.h>
 #include <mitkTrackvis.h>
 #include <mitkCustomMimeType.h>
 #include "mitkDiffusionIOMimeTypes.h"
 #include <vtkTransformPolyDataFilter.h>
-#include <boost/lexical_cast.hpp>
+#include <mitkLexicalCast.h>
 
 #include "dcmtk/config/osconfig.h"    /* make sure OS specific configuration is included first */
 #include "dcmtk/dcmtract/trctractographyresults.h"
 #include "dcmtk/dcmtract/trctrack.h"
 
 mitk::FiberBundleDicomReader::FiberBundleDicomReader()
   : mitk::AbstractFileReader( mitk::DiffusionIOMimeTypes::FIBERBUNDLE_DICOM_MIMETYPE_NAME(), "DICOM Fiber Bundle Reader" )
 {
   m_ServiceReg = this->RegisterService();
 }
 
 mitk::FiberBundleDicomReader::FiberBundleDicomReader(const FiberBundleDicomReader &other)
   :mitk::AbstractFileReader(other)
 {
 }
 
 mitk::FiberBundleDicomReader * mitk::FiberBundleDicomReader::Clone() const
 {
   return new FiberBundleDicomReader(*this);
 }
 
 std::vector<itk::SmartPointer<mitk::BaseData> > mitk::FiberBundleDicomReader::Read()
 {
 
   std::vector<itk::SmartPointer<mitk::BaseData> > output_fibs;
   try
   {
     const std::string& locale = "C";
     const std::string& currLocale = setlocale( LC_ALL, nullptr );
     setlocale(LC_ALL, locale.c_str());
 
     std::string filename = this->GetInputLocation();
 
     OFCondition result;
     TrcTractographyResults *trc = nullptr;
     result = TrcTractographyResults::loadFile(filename.c_str(), trc);
     if (result.bad())
       mitkThrow() << "Unable to load tractography dicom file: " << result.text();
 
     OFString val = "-";
     trc->getPatient().getPatientName(val);
     MITK_INFO << "Patient Name: " <<  val; val = "-";
     trc->getStudy().getStudyInstanceUID(val);
     MITK_INFO << "Study       : " << val; val = "-";
     trc->getSeries().getSeriesInstanceUID(val);
     MITK_INFO << "Series      : " << val; val = "-";
     trc->getSOPCommon().getSOPInstanceUID(val);
     MITK_INFO << "Instance    : " << val; val = "-";
     MITK_INFO << "-------------------------------------------------------------------------";
     size_t numTrackSets = trc->getNumberOfTrackSets();
     OFVector<TrcTrackSet*>& sets = trc->getTrackSets();
     for (size_t ts = 0; ts < numTrackSets; ts++)
     {
       size_t numTracks = sets[ts]->getNumberOfTracks();
       MITK_INFO << "  Track Set #" << ts << ": " << numTracks << " Tracks, "
            << sets[ts]->getNumberOfTrackSetStatistics() << " Track Set Statistics, "
            << sets[ts]->getNumberOfTrackStatistics() << " Track Statistics, "
            << sets[ts]->getNumberOfMeasurements() << " Measurements ";
 
       vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
       vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
 
       for (size_t t = 0; t < numTracks; t++)
       {
         vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
         TrcTrack* track = sets[ts]->getTracks()[t];
         const Float32* vals = nullptr;
         size_t numPoints = track->getTrackData(vals);
 
         for (size_t v = 0; v < numPoints; ++v)
         {
           vtkIdType id = vtkNewPoints->InsertNextPoint(vals[v*3],vals[v*3+1],vals[v*3+2]);
           container->GetPointIds()->InsertNextId(id);
         }
 
         vtkNewCells->InsertNextCell(container);
       }
 
       vtkSmartPointer<vtkPolyData> fiberPolyData = vtkSmartPointer<vtkPolyData>::New();
       fiberPolyData->SetPoints(vtkNewPoints);
       fiberPolyData->SetLines(vtkNewCells);
 
 //      // transform polydata from RAS (MRtrix) to LPS (MITK)
 //      mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New();
 //      vtkSmartPointer< vtkMatrix4x4 > matrix = vtkSmartPointer< vtkMatrix4x4 >::New();
 //      matrix->Identity();
 //      matrix->SetElement(0,0,-matrix->GetElement(0,0));
 //      matrix->SetElement(1,1,-matrix->GetElement(1,1));
 //      geometry->SetIndexToWorldTransformByVtkMatrix(matrix);
 
 //      vtkSmartPointer<vtkTransformPolyDataFilter> transformFilter = vtkSmartPointer<vtkTransformPolyDataFilter>::New();
 //      transformFilter->SetInputData(fiberPolyData);
 //      transformFilter->SetTransform(geometry->GetVtkTransform());
 //      transformFilter->Update();
 
       FiberBundle::Pointer fib = FiberBundle::New(fiberPolyData);
 
       CodeSequenceMacro* algoCode = sets[ts]->getTrackingAlgorithmIdentification().at(0);
       val = "-"; algoCode->getCodeValue(val);
       fib->GetPropertyList()->SetStringProperty("DICOM.algo_code.value",val.c_str());
       val = "-"; algoCode->getCodeMeaning(val);
       fib->GetPropertyList()->SetStringProperty("DICOM.algo_code.meaning",val.c_str());
 
       CodeSequenceMacro modelCode = sets[ts]->getDiffusionModelCode();
       val = "-"; modelCode.getCodeValue(val);
       fib->GetPropertyList()->SetStringProperty("DICOM.model_code.value",val.c_str());
       val = "-"; modelCode.getCodeMeaning(val);
       fib->GetPropertyList()->SetStringProperty("DICOM.model_code.meaning",val.c_str());
 
       CodeWithModifiers anatomy = sets[ts]->getTrackSetAnatomy();
       val = "-"; anatomy.getCodeValue(val);
       fib->GetPropertyList()->SetStringProperty("DICOM.anatomy.value",val.c_str());
       val = "-"; anatomy.getCodeMeaning(val);
       fib->GetPropertyList()->SetStringProperty("DICOM.anatomy.meaning",val.c_str());
 
       val = "-"; trc->getPatient().getPatientID(val);
       fib->GetPropertyList()->SetStringProperty("DICOM.patient_id",val.c_str());
       val = "-"; trc->getPatient().getPatientName(val);
       fib->GetPropertyList()->SetStringProperty("DICOM.patient_name",val.c_str());
       val = "-"; trc->getStudy().getStudyInstanceUID(val);
       fib->GetPropertyList()->SetStringProperty("DICOM.study_instance_uid",val.c_str());
       val = "-"; trc->getSeries().getSeriesInstanceUID(val);
       fib->GetPropertyList()->SetStringProperty("DICOM.series_instance_uid",val.c_str());
       val = "-"; trc->getSOPCommon().getSOPInstanceUID(val);
       fib->GetPropertyList()->SetStringProperty("DICOM.sop_instance_uid",val.c_str());
       val = "-"; trc->getSOPCommon().getSOPClassUID(val);
       fib->GetPropertyList()->SetStringProperty("DICOM.sop_class_uid",val.c_str());
       val = "-"; trc->getFrameOfReference().getFrameOfReferenceUID(val);
       fib->GetPropertyList()->SetStringProperty("DICOM.frame_of_reference_uid",val.c_str());
 
       output_fibs.push_back(fib.GetPointer());
       MITK_INFO << "Fiber bundle read";
     }
     delete trc;
 
     setlocale(LC_ALL, currLocale.c_str());
     return output_fibs;
   }
   catch(...)
   {
     throw;
   }
   return output_fibs;
 }
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleTckReader.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleTckReader.cpp
index cc326c9b2c..2c427b9039 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleTckReader.cpp
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleTckReader.cpp
@@ -1,164 +1,164 @@
 /*===================================================================
 
 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 "mitkFiberBundleTckReader.h"
 #include <itkMetaDataObject.h>
 #include <vtkPolyData.h>
 #include <vtkDataReader.h>
 #include <vtkPolyDataReader.h>
 #include <vtkMatrix4x4.h>
 #include <vtkPolyLine.h>
 #include <vtkCellArray.h>
 #include <vtkDataArray.h>
 #include <vtkFloatArray.h>
 #include <vtkCellData.h>
 #include <vtkPointData.h>
 #include <itksys/SystemTools.hxx>
 #include <tinyxml.h>
 #include <vtkCleanPolyData.h>
 #include <mitkTrackvis.h>
 #include <mitkCustomMimeType.h>
 #include "mitkDiffusionIOMimeTypes.h"
 #include <vtkTransformPolyDataFilter.h>
-#include <boost/lexical_cast.hpp>
+#include <mitkLexicalCast.h>
 
 
 mitk::FiberBundleTckReader::FiberBundleTckReader()
   : mitk::AbstractFileReader( mitk::DiffusionIOMimeTypes::FIBERBUNDLE_TCK_MIMETYPE_NAME(), "tck Fiber Bundle Reader (MRtrix format)" )
 {
   m_ServiceReg = this->RegisterService();
 }
 
 mitk::FiberBundleTckReader::FiberBundleTckReader(const FiberBundleTckReader &other)
   :mitk::AbstractFileReader(other)
 {
 }
 
 mitk::FiberBundleTckReader * mitk::FiberBundleTckReader::Clone() const
 {
   return new FiberBundleTckReader(*this);
 }
 
 std::vector<itk::SmartPointer<mitk::BaseData> > mitk::FiberBundleTckReader::Read()
 {
 
   std::vector<itk::SmartPointer<mitk::BaseData> > result;
   try
   {
     const std::string& locale = "C";
     const std::string& currLocale = setlocale( LC_ALL, nullptr );
     setlocale(LC_ALL, locale.c_str());
 
     std::string filename = this->GetInputLocation();
 
     std::string ext = itksys::SystemTools::GetFilenameLastExtension(filename);
     ext = itksys::SystemTools::LowerCase(ext);
 
     if (ext==".tck")
     {
       MITK_INFO << "Loading tractogram (MRtrix format): " << itksys::SystemTools::GetFilenameName(filename);
       std::FILE* filePointer = std::fopen(filename.c_str(),"r+b");
       std::string header = "";
 
       bool header_end = false;
       int count = 0;
       while (!header_end)
       {
         char c;
         count += std::fread(&c, 1, 1, filePointer);
         header += c;
         if (header.size() >= 3 && header.compare(header.size() - 3, 3, "END") == 0)
           header_end = true;
       }
       MITK_INFO << "TCK Header:";
       MITK_INFO << header;
 
       int header_size = -1;
       try
       {
         std::string delimiter = "file: . ";
         size_t pos = 0;
         pos = header.find(delimiter);
         header.erase(0, pos + delimiter.length());
         pos = header.find("\n");
         header_size = boost::lexical_cast<int>(header.substr(0, pos));
       }
       catch(...)
       {
 
       }
 
       if (header_size==-1)
         mitkThrow() << "Could not parse header size from " << filename;
       std::fseek ( filePointer , header_size , SEEK_SET );
 
       vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
       vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
       vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
 
       float tmp[3];
       count = 1;
       int fiber_length = 0;
       while (std::fread((char*)tmp, 1, 12, filePointer)==12)
       {
         if (std::isinf(tmp[0]) || std::isinf(tmp[1]) || std::isinf(tmp[1]))
           break;
         else if (std::isnan(tmp[0]) || std::isnan(tmp[1]) || std::isnan(tmp[2]))
         {
           count++;
           fiber_length = 0;
           vtkNewCells->InsertNextCell(container);
           container = vtkSmartPointer<vtkPolyLine>::New();
         }
         else
         {
           fiber_length++;
           vtkIdType id = vtkNewPoints->InsertNextPoint(tmp);
           container->GetPointIds()->InsertNextId(id);
         }
       }
 
       vtkSmartPointer<vtkPolyData> fiberPolyData = vtkSmartPointer<vtkPolyData>::New();
       fiberPolyData->SetPoints(vtkNewPoints);
       fiberPolyData->SetLines(vtkNewCells);
 
       // transform polydata from RAS (MRtrix) to LPS (MITK)
       mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New();
       vtkSmartPointer< vtkMatrix4x4 > matrix = vtkSmartPointer< vtkMatrix4x4 >::New();
       matrix->Identity();
       matrix->SetElement(0,0,-matrix->GetElement(0,0));
       matrix->SetElement(1,1,-matrix->GetElement(1,1));
       geometry->SetIndexToWorldTransformByVtkMatrix(matrix);
 
       vtkSmartPointer<vtkTransformPolyDataFilter> transformFilter = vtkSmartPointer<vtkTransformPolyDataFilter>::New();
       transformFilter->SetInputData(fiberPolyData);
       transformFilter->SetTransform(geometry->GetVtkTransform());
       transformFilter->Update();
 
       FiberBundle::Pointer fib = FiberBundle::New(transformFilter->GetOutput());
       result.push_back(fib.GetPointer());
     }
 
     setlocale(LC_ALL, currLocale.c_str());
     MITK_INFO << "Fiber bundle read";
     return result;
   }
   catch(...)
   {
     throw;
   }
   return result;
 }
diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkPlanarFigureCompositeReader.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkPlanarFigureCompositeReader.cpp
index fd4ea8063d..e2710e3e85 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkPlanarFigureCompositeReader.cpp
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkPlanarFigureCompositeReader.cpp
@@ -1,100 +1,100 @@
 /*===================================================================
 
 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 "mitkPlanarFigureCompositeReader.h"
 #include <itkMetaDataObject.h>
 #include <itksys/SystemTools.hxx>
 #include <tinyxml.h>
 #include <vtkCleanPolyData.h>
 #include <mitkTrackvis.h>
 #include <mitkCustomMimeType.h>
 #include "mitkDiffusionIOMimeTypes.h"
 #include <boost/property_tree/ptree.hpp>
 #define RAPIDXML_NO_EXCEPTIONS
 #include <boost/property_tree/xml_parser.hpp>
 #include <boost/foreach.hpp>
-#include <boost/lexical_cast.hpp>
+#include <mitkLexicalCast.h>
 #include <mitkPlanarFigureComposite.h>
 
 
 mitk::PlanarFigureCompositeReader::PlanarFigureCompositeReader()
     : mitk::AbstractFileReader( mitk::DiffusionIOMimeTypes::PLANARFIGURECOMPOSITE_MIMETYPE(), "Planar Figure Composite Reader" )
 {
     m_ServiceReg = this->RegisterService();
 }
 
 mitk::PlanarFigureCompositeReader::PlanarFigureCompositeReader(const PlanarFigureCompositeReader &other)
     :mitk::AbstractFileReader(other)
 {
 }
 
 mitk::PlanarFigureCompositeReader * mitk::PlanarFigureCompositeReader::Clone() const
 {
     return new PlanarFigureCompositeReader(*this);
 }
 
 
 std::vector<itk::SmartPointer<mitk::BaseData> > mitk::PlanarFigureCompositeReader::Read()
 {
 
     std::vector<itk::SmartPointer<mitk::BaseData> > result;
     try
     {
         const std::string& locale = "C";
         const std::string& currLocale = setlocale( LC_ALL, nullptr );
         setlocale(LC_ALL, locale.c_str());
 
         std::string filename = this->GetInputLocation();
 
         std::string ext = itksys::SystemTools::GetFilenameLastExtension(filename);
         ext = itksys::SystemTools::LowerCase(ext);
 
         boost::property_tree::ptree tree;
         boost::property_tree::xml_parser::read_xml(filename, tree);
         int comptype = tree.get<int>("comptype");
 
         mitk::PlanarFigureComposite::Pointer pfc = mitk::PlanarFigureComposite::New();
         switch(comptype)
         {
         case 0:
             pfc->setOperationType(mitk::PlanarFigureComposite::AND);
             MITK_INFO << "loading AND composition";
             break;
         case 1:
             pfc->setOperationType(mitk::PlanarFigureComposite::OR);
             MITK_INFO << "loading OR composition";
             break;
         case 2:
             pfc->setOperationType(mitk::PlanarFigureComposite::NOT);
             MITK_INFO << "loading NOT composition";
             break;
         default:
             MITK_ERROR << filename << " contains no valid composition type!";
         }
 
         std::vector<itk::SmartPointer<mitk::BaseData> > result;
         result.push_back(pfc.GetPointer());
 
         setlocale(LC_ALL, currLocale.c_str());
 
         return result;
     }
     catch(...)
     {
         throw;
     }
     return result;
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkGibbsTrackingFilter.cpp b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkGibbsTrackingFilter.cpp
index d31b7d25c2..413e4215b3 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkGibbsTrackingFilter.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkGibbsTrackingFilter.cpp
@@ -1,515 +1,515 @@
 /*===================================================================
 
 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 "itkGibbsTrackingFilter.h"
 
 // MITK
 #include <itkOrientationDistributionFunction.h>
 #include <itkDiffusionOdfGeneralizedFaImageFilter.h>
 #include <mitkStandardFileLocations.h>
 #include <mitkFiberBuilder.h>
 #include <mitkMetropolisHastingsSampler.h>
 //#include <mitkEnergyComputer.h>
 #include <itkTensorImageToOdfImageFilter.h>
 #include <mitkGibbsEnergyComputer.h>
 
 // ITK
 #include <itkImageDuplicator.h>
 #include <itkResampleImageFilter.h>
 #include <itkTimeProbe.h>
 
 // MISC
 #include <fstream>
 // #include <QFile>
 #include <tinyxml.h>
 #include <boost/progress.hpp>
-#include <boost/lexical_cast.hpp>
+#include <mitkLexicalCast.h>
 #include <boost/algorithm/string.hpp>
 
 namespace itk{
 
 template< class ItkOdfImageType >
 GibbsTrackingFilter< ItkOdfImageType >::GibbsTrackingFilter():
   m_StartTemperature(0.1),
   m_EndTemperature(0.001),
   m_Iterations(1e9),
   m_CurrentIteration(0.0),
   m_CurrentStep(0),
   m_ParticleWeight(0),
   m_ParticleWidth(0),
   m_ParticleLength(0),
   m_ConnectionPotential(10),
   m_InexBalance(0),
   m_ParticlePotential(0.2),
   m_MinFiberLength(10),
   m_AbortTracking(false),
   m_NumAcceptedFibers(0),
   m_BuildFibers(false),
   m_ProposalAcceptance(0),
   m_CurvatureThreshold(0.7),
   m_DuplicateImage(true),
   m_NumParticles(0),
   m_NumConnections(0),
   m_RandomSeed(-1),
   m_LoadParameterFile(""),
   m_LutPath(""),
   m_IsInValidState(true)
 {
 
 }
 
 template< class ItkOdfImageType >
 GibbsTrackingFilter< ItkOdfImageType >::~GibbsTrackingFilter()
 {
 
 }
 
 // fill output fiber bundle datastructure
 template< class ItkOdfImageType >
 typename GibbsTrackingFilter< ItkOdfImageType >::FiberPolyDataType GibbsTrackingFilter< ItkOdfImageType >::GetFiberBundle()
 {
   if (!m_AbortTracking)
   {
     m_BuildFibers = true;
     while (m_BuildFibers){}
   }
 
   return m_FiberPolyData;
 }
 
 template< class ItkOdfImageType >
 void
 GibbsTrackingFilter< ItkOdfImageType >
 ::EstimateParticleWeight()
 {
   MITK_INFO << "GibbsTrackingFilter: estimating particle weight";
 
   float minSpacing;
   if(m_OdfImage->GetSpacing()[0]<m_OdfImage->GetSpacing()[1] && m_OdfImage->GetSpacing()[0]<m_OdfImage->GetSpacing()[2])
     minSpacing = m_OdfImage->GetSpacing()[0];
   else if (m_OdfImage->GetSpacing()[1] < m_OdfImage->GetSpacing()[2])
     minSpacing = m_OdfImage->GetSpacing()[1];
   else
     minSpacing = m_OdfImage->GetSpacing()[2];
   float m_ParticleLength = 1.5*minSpacing;
   float m_ParticleWidth = 0.5*minSpacing;
 
   // seed random generators
   Statistics::MersenneTwisterRandomVariateGenerator::Pointer randGen = Statistics::MersenneTwisterRandomVariateGenerator::New();
   if (m_RandomSeed>-1)
     randGen->SetSeed(m_RandomSeed);
   else
     randGen->SetSeed();
 
   // instantiate all necessary components
   SphereInterpolator* interpolator = new SphereInterpolator(m_LutPath);
   // handle lookup table not found cases
   if( !interpolator->IsInValidState() )
   {
     m_IsInValidState = false;
     m_AbortTracking = true;
     m_BuildFibers = false;
     mitkThrow() << "Unable to load lookup tables.";
   }
   ParticleGrid* particleGrid = new ParticleGrid(m_MaskImage, m_ParticleLength, m_ParticleGridCellCapacity);
   GibbsEnergyComputer* encomp = new GibbsEnergyComputer(m_OdfImage, m_MaskImage, particleGrid, interpolator, randGen);
 
   //    EnergyComputer* encomp = new EnergyComputer(m_OdfImage, m_MaskImage, particleGrid, interpolator, randGen);
   MetropolisHastingsSampler* sampler = new MetropolisHastingsSampler(particleGrid, encomp, randGen, m_CurvatureThreshold);
 
   float alpha = log(m_EndTemperature/m_StartTemperature);
   m_ParticleWeight = 0.01;
   int ppv = 0;
   // main loop
   int neededParts = 3000;
   while (ppv<neededParts)
   {
     if (ppv<1000)
       m_ParticleWeight /= 2;
     else
       m_ParticleWeight = ppv*m_ParticleWeight/neededParts;
 
     encomp->SetParameters(m_ParticleWeight,m_ParticleWidth,m_ConnectionPotential*m_ParticleLength*m_ParticleLength,m_CurvatureThreshold,m_InexBalance,m_ParticlePotential);
     for( int step = 0; step < 10; step++ )
     {
       // update temperatur for simulated annealing process
       float temperature = m_StartTemperature * exp(alpha*(((1.0)*step)/((1.0)*10)));
       sampler->SetTemperature(temperature);
 
       for (unsigned long i=0; i<10000; i++)
         sampler->MakeProposal();
     }
     ppv = particleGrid->m_NumParticles;
     particleGrid->ResetGrid();
   }
   delete sampler;
   delete encomp;
   delete particleGrid;
   delete interpolator;
 
   MITK_INFO << "GibbsTrackingFilter: finished estimating particle weight";
 }
 
 // perform global tracking
 template< class ItkOdfImageType >
 void GibbsTrackingFilter< ItkOdfImageType >::GenerateData()
 {
   TimeProbe preClock; preClock.Start();
   // check if input is Odf or tensor image and generate Odf if necessary
   if (m_OdfImage.IsNull() && m_TensorImage.IsNotNull())
   {
     TensorImageToOdfImageFilter<float,float>::Pointer filter = TensorImageToOdfImageFilter<float,float>::New();
     filter->SetInput( m_TensorImage );
     filter->Update();
     m_OdfImage = filter->GetOutput();
   }
   else if (m_DuplicateImage) // generate local working copy of Odf image (if not disabled)
   {
     typedef itk::ImageDuplicator< ItkOdfImageType > DuplicateFilterType;
     typename DuplicateFilterType::Pointer duplicator = DuplicateFilterType::New();
     duplicator->SetInputImage( m_OdfImage );
     duplicator->Update();
     m_OdfImage = duplicator->GetOutput();
   }
 
   // perform mean subtraction on odfs
   typedef ImageRegionIterator< ItkOdfImageType > InputIteratorType;
   InputIteratorType it(m_OdfImage, m_OdfImage->GetLargestPossibleRegion() );
   it.GoToBegin();
   while (!it.IsAtEnd())
   {
     itk::OrientationDistributionFunction<float, ODF_SAMPLING_SIZE> odf(it.Get().GetDataPointer());
     float mean = odf.GetMeanValue();
     odf -= mean;
     it.Set(odf.GetDataPointer());
     ++it;
   }
 
   // check if mask image is given if it needs resampling
   PrepareMaskImage();
 
   // load parameter file
   LoadParameters();
 
   // prepare parameters
   float minSpacing;
   if(m_OdfImage->GetSpacing()[0]<m_OdfImage->GetSpacing()[1] && m_OdfImage->GetSpacing()[0]<m_OdfImage->GetSpacing()[2])
     minSpacing = m_OdfImage->GetSpacing()[0];
   else if (m_OdfImage->GetSpacing()[1] < m_OdfImage->GetSpacing()[2])
     minSpacing = m_OdfImage->GetSpacing()[1];
   else
     minSpacing = m_OdfImage->GetSpacing()[2];
 
   if(m_ParticleLength == 0)
     m_ParticleLength = 1.5*minSpacing;
   if(m_ParticleWidth == 0)
     m_ParticleWidth = 0.5*minSpacing;
 
   if(m_ParticleWeight == 0)
     EstimateParticleWeight();
 
   float alpha = log(m_EndTemperature/m_StartTemperature);
 
   if (m_CurvatureThreshold < mitk::eps)
     m_CurvatureThreshold = 0;
 
   // seed random generators
   Statistics::MersenneTwisterRandomVariateGenerator::Pointer randGen = Statistics::MersenneTwisterRandomVariateGenerator::New();
   if (m_RandomSeed>-1)
     randGen->SetSeed(m_RandomSeed);
   else
     randGen->SetSeed();
 
   // load sphere interpolator to evaluate the ODFs
   SphereInterpolator* interpolator = new SphereInterpolator(m_LutPath);
 
   // handle lookup table not found cases
   if( !interpolator->IsInValidState() )
   {
     m_IsInValidState = false;
     m_AbortTracking = true;
     m_BuildFibers = false;
     mitkThrow() << "Unable to load lookup tables.";
   }
   // initialize the actual tracking components (ParticleGrid, Metropolis Hastings Sampler and Energy Computer)
   ParticleGrid* particleGrid;
   GibbsEnergyComputer* encomp;
   MetropolisHastingsSampler* sampler;
   try{
     particleGrid = new ParticleGrid(m_MaskImage, m_ParticleLength, m_ParticleGridCellCapacity);
     encomp = new GibbsEnergyComputer(m_OdfImage, m_MaskImage, particleGrid, interpolator, randGen);
     encomp->SetParameters(m_ParticleWeight,m_ParticleWidth,m_ConnectionPotential*m_ParticleLength*m_ParticleLength,m_CurvatureThreshold,m_InexBalance,m_ParticlePotential);
     sampler = new MetropolisHastingsSampler(particleGrid, encomp, randGen, m_CurvatureThreshold);
   }
   catch(...)
   {
     MITK_ERROR  << "Particle grid allocation failed. Not enough memory? Try to increase the particle length.";
     m_IsInValidState = false;
     m_AbortTracking = true;
     m_BuildFibers = false;
     return;
   }
 
   MITK_INFO << "----------------------------------------";
   MITK_INFO << "Iterations: " << m_Iterations;
   MITK_INFO << "Particle length: " << m_ParticleLength;
   MITK_INFO << "Particle width: " << m_ParticleWidth;
   MITK_INFO << "Particle weight: " << m_ParticleWeight;
   MITK_INFO << "Start temperature: " << m_StartTemperature;
   MITK_INFO << "End temperature: " << m_EndTemperature;
   MITK_INFO << "In/Ex balance: " << m_InexBalance;
   MITK_INFO << "Min. fiber length: " << m_MinFiberLength;
   MITK_INFO << "Curvature threshold: " << m_CurvatureThreshold;
   MITK_INFO << "Random seed: " << m_RandomSeed;
   MITK_INFO << "----------------------------------------";
 
   // main loop
   preClock.Stop();
   TimeProbe clock; clock.Start();
   m_NumAcceptedFibers = 0;
   m_CurrentIteration = 0;
   bool just_built_fibers = false;
   boost::progress_display disp(m_Iterations);
   if (!m_AbortTracking)
     while (m_CurrentIteration<m_Iterations)
     {
       just_built_fibers = false;
       ++disp;
       m_CurrentIteration++;
       if (m_AbortTracking)
         break;
 
       // update temperatur for simulated annealing process
       float temperature = m_StartTemperature * exp(alpha*m_CurrentIteration/m_Iterations);
       sampler->SetTemperature(temperature);
       sampler->MakeProposal();
 
       m_ProposalAcceptance = (float)sampler->GetNumAcceptedProposals()/m_CurrentIteration;
       m_NumParticles = particleGrid->m_NumParticles;
       m_NumConnections = particleGrid->m_NumConnections;
 
       if (m_AbortTracking)
         break;
 
       if (m_BuildFibers)
       {
         FiberBuilder fiberBuilder(particleGrid, m_MaskImage);
         m_FiberPolyData = fiberBuilder.iterate(m_MinFiberLength);
         m_NumAcceptedFibers = m_FiberPolyData->GetNumberOfLines();
         m_BuildFibers = false;
         just_built_fibers = true;
       }
     }
   if (!just_built_fibers)
   {
     FiberBuilder fiberBuilder(particleGrid, m_MaskImage);
     m_FiberPolyData = fiberBuilder.iterate(m_MinFiberLength);
     m_NumAcceptedFibers = m_FiberPolyData->GetNumberOfLines();
   }
   clock.Stop();
 
   delete sampler;
   delete encomp;
   delete interpolator;
   delete particleGrid;
   m_AbortTracking = true;
   m_BuildFibers = false;
 
   int h = clock.GetTotal()/3600;
   int m = ((int)clock.GetTotal()%3600)/60;
   int s = (int)clock.GetTotal()%60;
   MITK_INFO << "GibbsTrackingFilter: finished gibbs tracking in " << h << "h, " << m << "m and " << s << "s";
   m = (int)preClock.GetTotal()/60;
   s = (int)preClock.GetTotal()%60;
   MITK_INFO << "GibbsTrackingFilter: preparation of the data took " << m << "m and " << s << "s";
   MITK_INFO << "GibbsTrackingFilter: " << m_NumAcceptedFibers << " fibers accepted";
 
   //    sampler->PrintProposalTimes();
 
   SaveParameters();
 }
 
 template< class ItkOdfImageType >
 void GibbsTrackingFilter< ItkOdfImageType >::PrepareMaskImage()
 {
   if(m_MaskImage.IsNull())
   {
     MITK_INFO << "GibbsTrackingFilter: generating default mask image";
     m_MaskImage = ItkFloatImageType::New();
     m_MaskImage->SetSpacing( m_OdfImage->GetSpacing() );
     m_MaskImage->SetOrigin( m_OdfImage->GetOrigin() );
     m_MaskImage->SetDirection( m_OdfImage->GetDirection() );
     m_MaskImage->SetRegions( m_OdfImage->GetLargestPossibleRegion() );
     m_MaskImage->Allocate();
     m_MaskImage->FillBuffer(1.0);
   }
   else if ( m_MaskImage->GetLargestPossibleRegion().GetSize()[0]!=m_OdfImage->GetLargestPossibleRegion().GetSize()[0] ||
             m_MaskImage->GetLargestPossibleRegion().GetSize()[1]!=m_OdfImage->GetLargestPossibleRegion().GetSize()[1] ||
             m_MaskImage->GetLargestPossibleRegion().GetSize()[2]!=m_OdfImage->GetLargestPossibleRegion().GetSize()[2] ||
             m_MaskImage->GetSpacing()[0]!=m_OdfImage->GetSpacing()[0] ||
             m_MaskImage->GetSpacing()[1]!=m_OdfImage->GetSpacing()[1] ||
             m_MaskImage->GetSpacing()[2]!=m_OdfImage->GetSpacing()[2] )
   {
     MITK_INFO << "GibbsTrackingFilter: resampling mask image";
     typedef itk::ResampleImageFilter< ItkFloatImageType, ItkFloatImageType, float > ResamplerType;
     ResamplerType::Pointer resampler = ResamplerType::New();
     resampler->SetOutputSpacing( m_OdfImage->GetSpacing() );
     resampler->SetOutputOrigin( m_OdfImage->GetOrigin() );
     resampler->SetOutputDirection( m_OdfImage->GetDirection() );
     resampler->SetSize( m_OdfImage->GetLargestPossibleRegion().GetSize() );
 
     resampler->SetInput( m_MaskImage );
     resampler->SetDefaultPixelValue(0.0);
     resampler->Update();
     m_MaskImage = resampler->GetOutput();
     MITK_INFO << "GibbsTrackingFilter: resampling finished";
   }
 }
 
 // load tracking paramters from xml file (.gtp)
 template< class ItkOdfImageType >
 bool GibbsTrackingFilter< ItkOdfImageType >::LoadParameters()
 {
   m_AbortTracking = true;
   try
   {
     if( m_LoadParameterFile.length()==0 )
     {
       m_AbortTracking = false;
       return true;
     }
 
     MITK_INFO << "GibbsTrackingFilter: loading parameter file " << m_LoadParameterFile;
 
     TiXmlDocument doc( m_LoadParameterFile );
     doc.LoadFile();
 
     TiXmlHandle hDoc(&doc);
     TiXmlElement* pElem;
     TiXmlHandle hRoot(nullptr);
 
     pElem = hDoc.FirstChildElement().Element();
     hRoot = TiXmlHandle(pElem);
     pElem = hRoot.FirstChildElement("parameter_set").Element();
 
     std::string iterations(pElem->Attribute("iterations"));
     m_Iterations = boost::lexical_cast<double>(iterations);
 
     std::string particleLength(pElem->Attribute("particle_length"));
     m_ParticleLength = boost::lexical_cast<float>(particleLength);
 
     std::string particleWidth(pElem->Attribute("particle_width"));
     m_ParticleWidth = boost::lexical_cast<float>(particleWidth);
 
     std::string partWeight(pElem->Attribute("particle_weight"));
     m_ParticleWeight = boost::lexical_cast<float>(partWeight);
 
     std::string startTemp(pElem->Attribute("temp_start"));
     m_StartTemperature = boost::lexical_cast<float>(startTemp);
 
     std::string endTemp(pElem->Attribute("temp_end"));
     m_EndTemperature = boost::lexical_cast<float>(endTemp);
 
     std::string inExBalance(pElem->Attribute("inexbalance"));
     m_InexBalance = boost::lexical_cast<float>(inExBalance);
 
     std::string fiberLength(pElem->Attribute("fiber_length"));
     m_MinFiberLength = boost::lexical_cast<float>(fiberLength);
 
     std::string curvThres(pElem->Attribute("curvature_threshold"));
     m_CurvatureThreshold = cos(boost::lexical_cast<float>(curvThres)*itk::Math::pi/180);
     m_AbortTracking = false;
     MITK_INFO << "GibbsTrackingFilter: parameter file loaded successfully";
     return true;
   }
   catch(...)
   {
     MITK_INFO << "GibbsTrackingFilter: could not load parameter file";
     return false;
   }
 }
 
 // save current tracking paramters to xml file (.gtp)
 template< class ItkOdfImageType >
 bool GibbsTrackingFilter< ItkOdfImageType >::SaveParameters()
 {
   try
   {
     if( m_SaveParameterFile.length()==0 )
     {
       MITK_INFO << "GibbsTrackingFilter: no filename specified to save parameters";
       return true;
     }
 
     MITK_INFO << "GibbsTrackingFilter: saving parameter file " << m_SaveParameterFile;
 
     TiXmlDocument documentXML;
     TiXmlDeclaration* declXML = new TiXmlDeclaration( "1.0", "", "" );
     documentXML.LinkEndChild( declXML );
 
     TiXmlElement* mainXML = new TiXmlElement("global_tracking_parameter_file");
     mainXML->SetAttribute("file_version",  "0.1");
     documentXML.LinkEndChild(mainXML);
 
     TiXmlElement* paramXML = new TiXmlElement("parameter_set");
     paramXML->SetAttribute("iterations", boost::lexical_cast<std::string>(m_Iterations));
     paramXML->SetAttribute("particle_length", boost::lexical_cast<std::string>(m_ParticleLength));
     paramXML->SetAttribute("particle_width", boost::lexical_cast<std::string>(m_ParticleWidth));
     paramXML->SetAttribute("particle_weight", boost::lexical_cast<std::string>(m_ParticleWeight));
     paramXML->SetAttribute("temp_start", boost::lexical_cast<std::string>(m_StartTemperature));
     paramXML->SetAttribute("temp_end", boost::lexical_cast<std::string>(m_EndTemperature));
     paramXML->SetAttribute("inexbalance", boost::lexical_cast<std::string>(m_InexBalance));
     paramXML->SetAttribute("fiber_length", boost::lexical_cast<std::string>(m_MinFiberLength));
     paramXML->SetAttribute("curvature_threshold", boost::lexical_cast<std::string>(m_CurvatureThreshold));
     mainXML->LinkEndChild(paramXML);
 
     if(!boost::algorithm::ends_with(m_SaveParameterFile, ".gtp"))
       m_SaveParameterFile.append(".gtp");
     documentXML.SaveFile( m_SaveParameterFile );
 
     MITK_INFO << "GibbsTrackingFilter: parameter file saved successfully";
     return true;
   }
   catch(...)
   {
     MITK_INFO << "GibbsTrackingFilter: could not save parameter file";
     return false;
   }
 }
 
 template< class ItkOdfImageType >
 void GibbsTrackingFilter< ItkOdfImageType >::SetDicomProperties(mitk::FiberBundle::Pointer fib)
 {
   std::string model_code_value = "-";
   std::string model_code_meaning = "-";
   std::string algo_code_value = "sup181_ee03";
   std::string algo_code_meaning = "Global";
 
 
   fib->SetProperty("DICOM.anatomy.value", mitk::StringProperty::New("T-A0095"));
   fib->SetProperty("DICOM.anatomy.meaning", mitk::StringProperty::New("White matter of brain and spinal cord"));
 
   fib->SetProperty("DICOM.algo_code.value", mitk::StringProperty::New(algo_code_value));
   fib->SetProperty("DICOM.algo_code.meaning", mitk::StringProperty::New(algo_code_meaning));
 
   fib->SetProperty("DICOM.model_code.value", mitk::StringProperty::New(model_code_value));
   fib->SetProperty("DICOM.model_code.meaning", mitk::StringProperty::New(model_code_meaning));
 }
 
 }
 
 
 
 
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkStreamlineTrackingFilter.cpp b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkStreamlineTrackingFilter.cpp
index 4d3adb37d6..4beab1fb73 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkStreamlineTrackingFilter.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkStreamlineTrackingFilter.cpp
@@ -1,1024 +1,1024 @@
 /*===================================================================
 
 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 <ctime>
 #include <cstdio>
 #include <cstdlib>
 
 #include <omp.h>
 #include "itkStreamlineTrackingFilter.h"
 #include <itkImageRegionConstIterator.h>
 #include <itkImageRegionConstIteratorWithIndex.h>
 #include <itkImageRegionIterator.h>
 #include <itkImageFileWriter.h>
 #include "itkPointShell.h"
 #include <itkRescaleIntensityImageFilter.h>
-#include <boost/lexical_cast.hpp>
+#include <mitkLexicalCast.h>
 #include <TrackingHandlers/mitkTrackingDataHandler.h>
 #include <TrackingHandlers/mitkTrackingHandlerOdf.h>
 #include <TrackingHandlers/mitkTrackingHandlerPeaks.h>
 #include <TrackingHandlers/mitkTrackingHandlerTensor.h>
 #include <TrackingHandlers/mitkTrackingHandlerRandomForest.h>
 #include <mitkDiffusionFunctionCollection.h>
 
 namespace itk {
 
 
 StreamlineTrackingFilter
 ::StreamlineTrackingFilter()
   : m_PauseTracking(false)
   , m_AbortTracking(false)
   , m_BuildFibersFinished(false)
   , m_BuildFibersReady(0)
   , m_FiberPolyData(nullptr)
   , m_Points(nullptr)
   , m_Cells(nullptr)
   , m_StoppingRegions(nullptr)
   , m_TargetRegions(nullptr)
   , m_SeedImage(nullptr)
   , m_MaskImage(nullptr)
   , m_ExclusionRegions(nullptr)
   , m_OutputProbabilityMap(nullptr)
   , m_MinVoxelSize(-1)
   , m_AngularThresholdDeg(-1)
   , m_StepSizeVox(-1)
   , m_SamplingDistanceVox(-1)
   , m_AngularThreshold(-1)
   , m_StepSize(0)
   , m_MaxLength(10000)
   , m_MinTractLength(20.0)
   , m_MaxTractLength(400.0)
   , m_SeedsPerVoxel(1)
   , m_AvoidStop(true)
   , m_RandomSampling(false)
   , m_SamplingDistance(-1)
   , m_DeflectionMod(1.0)
   , m_OnlyForwardSamples(true)
   , m_UseStopVotes(true)
   , m_NumberOfSamples(30)
   , m_NumPreviousDirections(1)
   , m_MaxNumTracts(-1)
   , m_Verbose(true)
   , m_LoopCheck(-1)
   , m_DemoMode(false)
   , m_Random(true)
   , m_UseOutputProbabilityMap(false)
   , m_CurrentTracts(0)
   , m_Progress(0)
   , m_StopTracking(false)
   , m_InterpolateMasks(true)
   , m_TrialsPerSeed(10)
   , m_EndpointConstraint(EndpointConstraints::NONE)
   , m_IntroduceDirectionsFromPrior(true)
   , m_TrackingPriorAsMask(true)
   , m_TrackingPriorWeight(1.0)
   , m_TrackingPriorHandler(nullptr)
 {
   this->SetNumberOfRequiredInputs(0);
 }
 
 std::string StreamlineTrackingFilter::GetStatusText()
 {
   std::string status = "Seedpoints processed: " + boost::lexical_cast<std::string>(m_Progress) + "/" + boost::lexical_cast<std::string>(m_SeedPoints.size());
   if (m_SeedPoints.size()>0)
     status += " (" + boost::lexical_cast<std::string>(100*m_Progress/m_SeedPoints.size()) + "%)";
   if (m_MaxNumTracts>0)
     status += "\nFibers accepted: " + boost::lexical_cast<std::string>(m_CurrentTracts) + "/" + boost::lexical_cast<std::string>(m_MaxNumTracts);
   else
     status += "\nFibers accepted: " + boost::lexical_cast<std::string>(m_CurrentTracts);
 
   return status;
 }
 
 void StreamlineTrackingFilter::BeforeTracking()
 {
   m_StopTracking = false;
   m_TrackingHandler->SetRandom(m_Random);
   m_TrackingHandler->InitForTracking();
   m_FiberPolyData = PolyDataType::New();
   m_Points = vtkSmartPointer< vtkPoints >::New();
   m_Cells = vtkSmartPointer< vtkCellArray >::New();
 
   itk::Vector< double, 3 > imageSpacing = m_TrackingHandler->GetSpacing();
 
   if(imageSpacing[0]<imageSpacing[1] && imageSpacing[0]<imageSpacing[2])
     m_MinVoxelSize = imageSpacing[0];
   else if (imageSpacing[1] < imageSpacing[2])
     m_MinVoxelSize = imageSpacing[1];
   else
     m_MinVoxelSize = imageSpacing[2];
 
   if (m_StepSizeVox<mitk::eps)
     m_StepSize = 0.5*m_MinVoxelSize;
   else
     m_StepSize = m_StepSizeVox*m_MinVoxelSize;
 
   if (m_AngularThresholdDeg<0)
   {
     if  (m_StepSize/m_MinVoxelSize<=0.966)  // minimum 15° for automatic estimation
       m_AngularThreshold = std::cos( 0.5 * itk::Math::pi * m_StepSize/m_MinVoxelSize );
     else
       m_AngularThreshold = std::cos( 0.5 * itk::Math::pi * 0.966 );
   }
   else
     m_AngularThreshold = std::cos( m_AngularThresholdDeg*itk::Math::pi/180.0 );
   m_TrackingHandler->SetAngularThreshold(m_AngularThreshold);
 
   if (m_TrackingPriorHandler!=nullptr)
   {
     m_TrackingPriorHandler->SetRandom(m_Random);
     m_TrackingPriorHandler->InitForTracking();
     m_TrackingPriorHandler->SetAngularThreshold(m_AngularThreshold);
   }
 
   if (m_SamplingDistanceVox<mitk::eps)
     m_SamplingDistance = m_MinVoxelSize*0.25;
   else
     m_SamplingDistance = m_SamplingDistanceVox * m_MinVoxelSize;
 
   m_PolyDataContainer.clear();
   for (unsigned int i=0; i<this->GetNumberOfThreads(); i++)
   {
     PolyDataType poly = PolyDataType::New();
     m_PolyDataContainer.push_back(poly);
   }
 
   if (m_UseOutputProbabilityMap)
   {
     m_OutputProbabilityMap = ItkDoubleImgType::New();
     m_OutputProbabilityMap->SetSpacing(imageSpacing);
     m_OutputProbabilityMap->SetOrigin(m_TrackingHandler->GetOrigin());
     m_OutputProbabilityMap->SetDirection(m_TrackingHandler->GetDirection());
     m_OutputProbabilityMap->SetRegions(m_TrackingHandler->GetLargestPossibleRegion());
     m_OutputProbabilityMap->Allocate();
     m_OutputProbabilityMap->FillBuffer(0);
   }
 
   m_MaskInterpolator = itk::LinearInterpolateImageFunction< ItkFloatImgType, float >::New();
   m_StopInterpolator = itk::LinearInterpolateImageFunction< ItkFloatImgType, float >::New();
   m_SeedInterpolator = itk::LinearInterpolateImageFunction< ItkFloatImgType, float >::New();
   m_TargetInterpolator = itk::LinearInterpolateImageFunction< ItkFloatImgType, float >::New();
   m_ExclusionInterpolator = itk::LinearInterpolateImageFunction< ItkFloatImgType, float >::New();
 
   if (m_StoppingRegions.IsNull())
   {
     m_StoppingRegions = ItkFloatImgType::New();
     m_StoppingRegions->SetSpacing( imageSpacing );
     m_StoppingRegions->SetOrigin( m_TrackingHandler->GetOrigin() );
     m_StoppingRegions->SetDirection( m_TrackingHandler->GetDirection() );
     m_StoppingRegions->SetRegions( m_TrackingHandler->GetLargestPossibleRegion() );
     m_StoppingRegions->Allocate();
     m_StoppingRegions->FillBuffer(0);
   }
   else
     std::cout << "StreamlineTracking - Using stopping region image" << std::endl;
   m_StopInterpolator->SetInputImage(m_StoppingRegions);
 
   if (m_ExclusionRegions.IsNotNull())
   {
     std::cout << "StreamlineTracking - Using exclusion region image" << std::endl;
     m_ExclusionInterpolator->SetInputImage(m_ExclusionRegions);
   }
 
   if (m_TargetRegions.IsNull())
   {
     m_TargetImageSet = false;
     m_TargetRegions = ItkFloatImgType::New();
     m_TargetRegions->SetSpacing( imageSpacing );
     m_TargetRegions->SetOrigin( m_TrackingHandler->GetOrigin() );
     m_TargetRegions->SetDirection( m_TrackingHandler->GetDirection() );
     m_TargetRegions->SetRegions( m_TrackingHandler->GetLargestPossibleRegion() );
     m_TargetRegions->Allocate();
     m_TargetRegions->FillBuffer(1);
   }
   else
   {
     m_TargetImageSet = true;
     m_TargetInterpolator->SetInputImage(m_TargetRegions);
     std::cout << "StreamlineTracking - Using target region image" << std::endl;
   }
 
   if (m_SeedImage.IsNull())
   {
     m_SeedImageSet = false;
     m_SeedImage = ItkFloatImgType::New();
     m_SeedImage->SetSpacing( imageSpacing );
     m_SeedImage->SetOrigin( m_TrackingHandler->GetOrigin() );
     m_SeedImage->SetDirection( m_TrackingHandler->GetDirection() );
     m_SeedImage->SetRegions( m_TrackingHandler->GetLargestPossibleRegion() );
     m_SeedImage->Allocate();
     m_SeedImage->FillBuffer(1);
   }
   else
   {
     m_SeedImageSet = true;
     std::cout << "StreamlineTracking - Using seed image" << std::endl;
   }
   m_SeedInterpolator->SetInputImage(m_SeedImage);
 
   if (m_MaskImage.IsNull())
   {
     // initialize mask image
     m_MaskImage = ItkFloatImgType::New();
     m_MaskImage->SetSpacing( imageSpacing );
     m_MaskImage->SetOrigin( m_TrackingHandler->GetOrigin() );
     m_MaskImage->SetDirection( m_TrackingHandler->GetDirection() );
     m_MaskImage->SetRegions( m_TrackingHandler->GetLargestPossibleRegion() );
     m_MaskImage->Allocate();
     m_MaskImage->FillBuffer(1);
   }
   else
     std::cout << "StreamlineTracking - Using mask image" << std::endl;
   m_MaskInterpolator->SetInputImage(m_MaskImage);
 
   // Autosettings for endpoint constraints
   if (m_EndpointConstraint==EndpointConstraints::NONE && m_TargetImageSet && m_SeedImageSet)
   {
     MITK_INFO << "No endpoint constraint chosen but seed and target image set --> setting constraint to EPS_IN_SEED_AND_TARGET";
     m_EndpointConstraint = EndpointConstraints::EPS_IN_SEED_AND_TARGET;
   }
   else if (m_EndpointConstraint==EndpointConstraints::NONE && m_TargetImageSet)
   {
     MITK_INFO << "No endpoint constraint chosen but target image set --> setting constraint to EPS_IN_TARGET";
     m_EndpointConstraint = EndpointConstraints::EPS_IN_TARGET;
   }
 
   // Check if endpoint constraints are valid
   FiberType test_fib; itk::Point<float> p; p.Fill(0);
   test_fib.push_back(p); test_fib.push_back(p);
   IsValidFiber(&test_fib);
 
   if (m_SeedPoints.empty())
     GetSeedPointsFromSeedImage();
 
   m_BuildFibersReady = 0;
   m_BuildFibersFinished = false;
   m_Tractogram.clear();
   m_SamplingPointset = mitk::PointSet::New();
   m_AlternativePointset = mitk::PointSet::New();
   m_StopVotePointset = mitk::PointSet::New();
   m_StartTime = std::chrono::system_clock::now();
 
   if (m_DemoMode)
     omp_set_num_threads(1);
 
   if (m_TrackingHandler->GetMode()==mitk::TrackingDataHandler::MODE::DETERMINISTIC)
     std::cout << "StreamlineTracking - Mode: deterministic" << std::endl;
   else if(m_TrackingHandler->GetMode()==mitk::TrackingDataHandler::MODE::PROBABILISTIC)
   {
     std::cout << "StreamlineTracking - Mode: probabilistic" << std::endl;
     std::cout << "StreamlineTracking - Trials per seed: " << m_TrialsPerSeed << std::endl;
   }
   else
     std::cout << "StreamlineTracking - Mode: ???" << std::endl;
 
   if (m_EndpointConstraint==EndpointConstraints::NONE)
     std::cout << "StreamlineTracking - Endpoint constraint: NONE" << std::endl;
   else if (m_EndpointConstraint==EndpointConstraints::EPS_IN_TARGET)
     std::cout << "StreamlineTracking - Endpoint constraint: EPS_IN_TARGET" << std::endl;
   else if (m_EndpointConstraint==EndpointConstraints::EPS_IN_TARGET_LABELDIFF)
     std::cout << "StreamlineTracking - Endpoint constraint: EPS_IN_TARGET_LABELDIFF" << std::endl;
   else if (m_EndpointConstraint==EndpointConstraints::EPS_IN_SEED_AND_TARGET)
     std::cout << "StreamlineTracking - Endpoint constraint: EPS_IN_SEED_AND_TARGET" << std::endl;
   else if (m_EndpointConstraint==EndpointConstraints::MIN_ONE_EP_IN_TARGET)
     std::cout << "StreamlineTracking - Endpoint constraint: MIN_ONE_EP_IN_TARGET" << std::endl;
   else if (m_EndpointConstraint==EndpointConstraints::ONE_EP_IN_TARGET)
     std::cout << "StreamlineTracking - Endpoint constraint: ONE_EP_IN_TARGET" << std::endl;
   else if (m_EndpointConstraint==EndpointConstraints::NO_EP_IN_TARGET)
     std::cout << "StreamlineTracking - Endpoint constraint: NO_EP_IN_TARGET" << std::endl;
 
   std::cout << "StreamlineTracking - Angular threshold: " << m_AngularThreshold << " (" << 180*std::acos( m_AngularThreshold )/itk::Math::pi << "°)" << std::endl;
   std::cout << "StreamlineTracking - Stepsize: " << m_StepSize << "mm (" << m_StepSize/m_MinVoxelSize << "*vox)" << std::endl;
   std::cout << "StreamlineTracking - Seeds per voxel: " << m_SeedsPerVoxel << std::endl;
   std::cout << "StreamlineTracking - Max. tract length: " << m_MaxTractLength << "mm" << std::endl;
   std::cout << "StreamlineTracking - Min. tract length: " << m_MinTractLength << "mm" << std::endl;
   std::cout << "StreamlineTracking - Max. num. tracts: " << m_MaxNumTracts << std::endl;
   std::cout << "StreamlineTracking - Loop check: " << m_LoopCheck << "°" << std::endl;
 
   std::cout << "StreamlineTracking - Num. neighborhood samples: " << m_NumberOfSamples << std::endl;
   std::cout << "StreamlineTracking - Max. sampling distance: " << m_SamplingDistance << "mm (" << m_SamplingDistance/m_MinVoxelSize << "*vox)" << std::endl;
   std::cout << "StreamlineTracking - Deflection modifier: " << m_DeflectionMod << std::endl;
 
   std::cout << "StreamlineTracking - Use stop votes: " << m_UseStopVotes << std::endl;
   std::cout << "StreamlineTracking - Only frontal samples: " << m_OnlyForwardSamples << std::endl;
 
   if (m_TrackingPriorHandler!=nullptr)
     std::cout << "StreamlineTracking - Using directional prior for tractography (w=" << m_TrackingPriorWeight << ")" << std::endl;
 
   if (m_DemoMode)
   {
     std::cout << "StreamlineTracking - Running in demo mode";
     std::cout << "StreamlineTracking - Starting streamline tracking using 1 thread" << std::endl;
   }
   else
     std::cout << "StreamlineTracking - Starting streamline tracking using " << omp_get_max_threads() << " threads" << std::endl;
 }
 
 void StreamlineTrackingFilter::CalculateNewPosition(itk::Point<float, 3>& pos, vnl_vector_fixed<float, 3>& dir)
 {
   pos[0] += dir[0]*m_StepSize;
   pos[1] += dir[1]*m_StepSize;
   pos[2] += dir[2]*m_StepSize;
 }
 
 std::vector< vnl_vector_fixed<float,3> > StreamlineTrackingFilter::CreateDirections(int NPoints)
 {
   std::vector< vnl_vector_fixed<float,3> > pointshell;
 
   if (NPoints<2)
     return pointshell;
 
   std::vector< float > theta; theta.resize(NPoints);
 
   std::vector< float > phi; phi.resize(NPoints);
 
   float C = sqrt(4*itk::Math::pi);
 
   phi[0] = 0.0;
   phi[NPoints-1] = 0.0;
 
   for(int i=0; i<NPoints; i++)
   {
     theta[i] = acos(-1.0+2.0*i/(NPoints-1.0)) - itk::Math::pi / 2.0;
     if( i>0 && i<NPoints-1)
     {
       phi[i] = (phi[i-1] + C / sqrt(NPoints*(1-(-1.0+2.0*i/(NPoints-1.0))*(-1.0+2.0*i/(NPoints-1.0)))));
       // % (2*DIST_POINTSHELL_PI);
     }
   }
 
 
   for(int i=0; i<NPoints; i++)
   {
     vnl_vector_fixed<float,3> d;
     d[0] = cos(theta[i]) * cos(phi[i]);
     d[1] = cos(theta[i]) * sin(phi[i]);
     d[2] = sin(theta[i]);
     pointshell.push_back(d);
   }
 
   return pointshell;
 }
 
 
 vnl_vector_fixed<float,3> StreamlineTrackingFilter::GetNewDirection(const itk::Point<float, 3> &pos, std::deque<vnl_vector_fixed<float, 3> >& olddirs, itk::Index<3> &oldIndex)
 {
   if (m_DemoMode)
   {
     m_SamplingPointset->Clear();
     m_AlternativePointset->Clear();
     m_StopVotePointset->Clear();
   }
   vnl_vector_fixed<float,3> direction; direction.fill(0);
 
   if (mitk::imv::IsInsideMask<float>(pos, m_InterpolateMasks, m_MaskInterpolator) && !mitk::imv::IsInsideMask<float>(pos, m_InterpolateMasks, m_StopInterpolator))
     direction = m_TrackingHandler->ProposeDirection(pos, olddirs, oldIndex); // get direction proposal at current streamline position
   else
     return direction;
 
   int stop_votes = 0;
   int possible_stop_votes = 0;
   if (!olddirs.empty())
   {
     vnl_vector_fixed<float,3> olddir = olddirs.back();
     std::vector< vnl_vector_fixed<float,3> > probeVecs = CreateDirections(m_NumberOfSamples);
     itk::Point<float, 3> sample_pos;
     int alternatives = 1;
     for (unsigned int i=0; i<probeVecs.size(); i++)
     {
       vnl_vector_fixed<float,3> d;
       bool is_stop_voter = false;
       if (m_Random && m_RandomSampling)
       {
         d[0] = m_TrackingHandler->GetRandDouble(-0.5, 0.5);
         d[1] = m_TrackingHandler->GetRandDouble(-0.5, 0.5);
         d[2] = m_TrackingHandler->GetRandDouble(-0.5, 0.5);
         d.normalize();
         d *= m_TrackingHandler->GetRandDouble(0,m_SamplingDistance);
       }
       else
       {
         d = probeVecs.at(i);
         float dot = dot_product(d, olddir);
         if (m_UseStopVotes && dot>0.7)
         {
           is_stop_voter = true;
           possible_stop_votes++;
         }
         else if (m_OnlyForwardSamples && dot<0)
           continue;
         d *= m_SamplingDistance;
       }
 
       sample_pos[0] = pos[0] + d[0];
       sample_pos[1] = pos[1] + d[1];
       sample_pos[2] = pos[2] + d[2];
 
       vnl_vector_fixed<float,3> tempDir; tempDir.fill(0.0);
       if (mitk::imv::IsInsideMask<float>(sample_pos, m_InterpolateMasks, m_MaskInterpolator))
         tempDir = m_TrackingHandler->ProposeDirection(sample_pos, olddirs, oldIndex); // sample neighborhood
       if (tempDir.magnitude()>mitk::eps)
       {
         direction += tempDir;
 
         if(m_DemoMode)
           m_SamplingPointset->InsertPoint(i, sample_pos);
       }
       else if (m_AvoidStop && olddir.magnitude()>0.5) // out of white matter
       {
         if (is_stop_voter)
           stop_votes++;
         if (m_DemoMode)
           m_StopVotePointset->InsertPoint(i, sample_pos);
 
         float dot = dot_product(d, olddir);
         if (dot >= 0.0) // in front of plane defined by pos and olddir
           d = -d + 2*dot*olddir; // reflect
         else
           d = -d; // invert
 
         // look a bit further into the other direction
         sample_pos[0] = pos[0] + d[0];
         sample_pos[1] = pos[1] + d[1];
         sample_pos[2] = pos[2] + d[2];
         alternatives++;
         vnl_vector_fixed<float,3> tempDir; tempDir.fill(0.0);
         if (mitk::imv::IsInsideMask<float>(sample_pos, m_InterpolateMasks, m_MaskInterpolator))
           tempDir = m_TrackingHandler->ProposeDirection(sample_pos, olddirs, oldIndex); // sample neighborhood
 
         if (tempDir.magnitude()>mitk::eps)  // are we back in the white matter?
         {
           direction += d * m_DeflectionMod;         // go into the direction of the white matter
           direction += tempDir;  // go into the direction of the white matter direction at this location
 
           if(m_DemoMode)
             m_AlternativePointset->InsertPoint(alternatives, sample_pos);
         }
         else
         {
           if (m_DemoMode)
             m_StopVotePointset->InsertPoint(i, sample_pos);
         }
       }
       else
       {
         if (m_DemoMode)
           m_StopVotePointset->InsertPoint(i, sample_pos);
 
         if (is_stop_voter)
           stop_votes++;
       }
     }
   }
 
   bool valid = false;
   if (direction.magnitude()>0.001 && (possible_stop_votes==0 || (float)stop_votes/possible_stop_votes<0.5) )
   {
     direction.normalize();
     valid = true;
   }
   else
     direction.fill(0);
 
   if (m_TrackingPriorHandler!=nullptr && (m_IntroduceDirectionsFromPrior || valid))
   {
     vnl_vector_fixed<float,3> prior = m_TrackingPriorHandler->ProposeDirection(pos, olddirs, oldIndex);
     if (prior.magnitude()>0.001)
     {
       prior.normalize();
       if (dot_product(prior,direction)<0)
         prior *= -1;
       direction = (1.0f-m_TrackingPriorWeight) * direction + m_TrackingPriorWeight * prior;
       direction.normalize();
     }
     else if (m_TrackingPriorAsMask)
       direction.fill(0.0);
   }
 
   return direction;
 }
 
 
 float StreamlineTrackingFilter::FollowStreamline(itk::Point<float, 3> pos, vnl_vector_fixed<float,3> dir, FiberType* fib, DirectionContainer* container, float tractLength, bool front, bool &exclude)
 {
   vnl_vector_fixed<float,3> zero_dir; zero_dir.fill(0.0);
   std::deque< vnl_vector_fixed<float,3> > last_dirs;
   for (unsigned int i=0; i<m_NumPreviousDirections-1; i++)
     last_dirs.push_back(zero_dir);
 
   for (int step=0; step< m_MaxLength/2; step++)
   {
     itk::Index<3> oldIndex;
     m_TrackingHandler->WorldToIndex(pos, oldIndex);
 
     // get new position
     CalculateNewPosition(pos, dir);
 
     if (m_ExclusionRegions.IsNotNull() && mitk::imv::IsInsideMask<float>(pos, m_InterpolateMasks, m_ExclusionInterpolator))
     {
       exclude = true;
       return tractLength;
     }
 
     if (m_AbortTracking)
       return tractLength;
 
     // if yes, add new point to streamline
     dir.normalize();
     if (front)
     {
       fib->push_front(pos);
       container->push_front(dir);
     }
     else
     {
       fib->push_back(pos);
       container->push_back(dir);
     }
     tractLength +=  m_StepSize;
 
     if (m_LoopCheck>=0 && CheckCurvature(container, front)>m_LoopCheck)
       return tractLength;
 
     if (tractLength>m_MaxTractLength)
       return tractLength;
 
     if (m_DemoMode && !m_UseOutputProbabilityMap) // CHECK: warum sind die samplingpunkte der streamline in der visualisierung immer einen schritt voras?
     {
 #pragma omp critical
       {
         m_BuildFibersReady++;
         m_Tractogram.push_back(*fib);
         BuildFibers(true);
         m_Stop = true;
 
         while (m_Stop){
         }
       }
     }
 
     last_dirs.push_back(dir);
     if (last_dirs.size()>m_NumPreviousDirections)
       last_dirs.pop_front();
     dir = GetNewDirection(pos, last_dirs, oldIndex);
 
     while (m_PauseTracking){}
 
     if (dir.magnitude()<0.0001)
       return tractLength;
   }
   return tractLength;
 }
 
 
 float StreamlineTrackingFilter::CheckCurvature(DirectionContainer* fib, bool front)
 {
   if (fib->size()<8)
     return 0;
   float m_Distance = std::max(m_MinVoxelSize*4, m_StepSize*8);
   float dist = 0;
 
   std::vector< vnl_vector_fixed< float, 3 > > vectors;
   vnl_vector_fixed< float, 3 > meanV; meanV.fill(0);
   float dev = 0;
 
   if (front)
   {
     int c = 0;
     while(dist<m_Distance && c<(int)fib->size()-1)
     {
       dist += m_StepSize;
       vnl_vector_fixed< float, 3 > v = fib->at(c);
       if (dot_product(v,meanV)<0)
         v = -v;
       vectors.push_back(v);
       meanV += v;
       c++;
     }
   }
   else
   {
     int c = fib->size()-1;
     while(dist<m_Distance && c>=0)
     {
       dist += m_StepSize;
       vnl_vector_fixed< float, 3 > v = fib->at(c);
       if (dot_product(v,meanV)<0)
         v = -v;
       vectors.push_back(v);
       meanV += v;
       c--;
     }
   }
   meanV.normalize();
 
   for (unsigned int c=0; c<vectors.size(); c++)
   {
     float angle = std::fabs(dot_product(meanV, vectors.at(c)));
     if (angle>1.0)
       angle = 1.0;
     dev += acos(angle)*180/itk::Math::pi;
   }
   if (vectors.size()>0)
     dev /= vectors.size();
 
   return dev;
 }
 
 void StreamlineTrackingFilter::SetTrackingPriorHandler(mitk::TrackingDataHandler *TrackingPriorHandler)
 {
   m_TrackingPriorHandler = TrackingPriorHandler;
 }
 
 void StreamlineTrackingFilter::GetSeedPointsFromSeedImage()
 {
   MITK_INFO << "StreamlineTracking - Calculating seed points.";
   m_SeedPoints.clear();
 
   typedef ImageRegionConstIterator< ItkFloatImgType >     MaskIteratorType;
   MaskIteratorType    sit(m_SeedImage, m_SeedImage->GetLargestPossibleRegion());
   sit.GoToBegin();
 
   while (!sit.IsAtEnd())
   {
     if (sit.Value()>0)
     {
       ItkFloatImgType::IndexType index = sit.GetIndex();
       itk::ContinuousIndex<float, 3> start;
       start[0] = index[0];
       start[1] = index[1];
       start[2] = index[2];
       itk::Point<float> worldPos;
       m_SeedImage->TransformContinuousIndexToPhysicalPoint(start, worldPos);
 
       if ( mitk::imv::IsInsideMask<float>(worldPos, m_InterpolateMasks, m_MaskInterpolator) )
       {
         m_SeedPoints.push_back(worldPos);
         for (int s = 1; s < m_SeedsPerVoxel; s++)
         {
           start[0] = index[0] + m_TrackingHandler->GetRandDouble(-0.5, 0.5);
           start[1] = index[1] + m_TrackingHandler->GetRandDouble(-0.5, 0.5);
           start[2] = index[2] + m_TrackingHandler->GetRandDouble(-0.5, 0.5);
 
           itk::Point<float> worldPos;
           m_SeedImage->TransformContinuousIndexToPhysicalPoint(start, worldPos);
           m_SeedPoints.push_back(worldPos);
         }
       }
     }
     ++sit;
   }
 }
 
 void StreamlineTrackingFilter::GenerateData()
 {
   this->BeforeTracking();
   if (m_Random)
     std::random_shuffle(m_SeedPoints.begin(), m_SeedPoints.end());
 
   m_CurrentTracts = 0;
   int num_seeds = m_SeedPoints.size();
   itk::Index<3> zeroIndex; zeroIndex.Fill(0);
   m_Progress = 0;
   int i = 0;
   int print_interval = num_seeds/100;
   if (print_interval<100)
     m_Verbose=false;
 
 #pragma omp parallel
   while (i<num_seeds && !m_StopTracking)
   {
     int temp_i = 0;
 #pragma omp critical
     {
       temp_i = i;
       i++;
     }
 
     if (temp_i>=num_seeds || m_StopTracking)
       continue;
     else if (m_Verbose && i%print_interval==0)
 #pragma omp critical
     {
       m_Progress += print_interval;
       std::cout << "                                                                                                     \r";
       if (m_MaxNumTracts>0)
         std::cout << "Tried: " << m_Progress << "/" << num_seeds << " | Accepted: " << m_CurrentTracts << "/" << m_MaxNumTracts << '\r';
       else
         std::cout << "Tried: " << m_Progress << "/" << num_seeds << " | Accepted: " << m_CurrentTracts << '\r';
       cout.flush();
     }
 
     const itk::Point<float> worldPos = m_SeedPoints.at(temp_i);
 
     for (unsigned int trials=0; trials<m_TrialsPerSeed; ++trials)
     {
       FiberType fib;
       DirectionContainer direction_container;
       float tractLength = 0;
       unsigned int counter = 0;
 
       // get starting direction
       vnl_vector_fixed<float,3> dir; dir.fill(0.0);
       std::deque< vnl_vector_fixed<float,3> > olddirs;
       dir = GetNewDirection(worldPos, olddirs, zeroIndex) * 0.5f;
 
       bool exclude = false;
       if (m_ExclusionRegions.IsNotNull() && mitk::imv::IsInsideMask<float>(worldPos, m_InterpolateMasks, m_ExclusionInterpolator))
         exclude = true;
 
       bool success = false;
       if (dir.magnitude()>0.0001 && !exclude)
       {
         // forward tracking
         tractLength = FollowStreamline(worldPos, dir, &fib, &direction_container, 0, false, exclude);
         fib.push_front(worldPos);
 
         // backward tracking
         if (!exclude)
           tractLength = FollowStreamline(worldPos, -dir, &fib, &direction_container, tractLength, true, exclude);
 
         counter = fib.size();
 
         if (tractLength>=m_MinTractLength && counter>=2 && !exclude)
         {
 #pragma omp critical
           if ( IsValidFiber(&fib) )
           {
             if (!m_StopTracking)
             {
               if (!m_UseOutputProbabilityMap)
                 m_Tractogram.push_back(fib);
               else
                 FiberToProbmap(&fib);
               m_CurrentTracts++;
               success = true;
             }
             if (m_MaxNumTracts > 0 && m_CurrentTracts>=static_cast<unsigned int>(m_MaxNumTracts))
             {
               if (!m_StopTracking)
               {
                 std::cout << "                                                                                                     \r";
                 MITK_INFO << "Reconstructed maximum number of tracts (" << m_CurrentTracts << "). Stopping tractography.";
               }
               m_StopTracking = true;
             }
           }
         }
       }
 
       if (success || m_TrackingHandler->GetMode()!=mitk::TrackingDataHandler::PROBABILISTIC)
         break;  // we only try one seed point multiple times if we use a probabilistic tracker and have not found a valid streamline yet
 
     }// trials per seed
 
   }// seed points
 
   this->AfterTracking();
 }
 
 bool StreamlineTrackingFilter::IsValidFiber(FiberType* fib)
 {
   if (m_EndpointConstraint==EndpointConstraints::NONE)
   {
     return true;
   }
   else if (m_EndpointConstraint==EndpointConstraints::EPS_IN_TARGET)
   {
     if (m_TargetImageSet)
     {
       if ( mitk::imv::IsInsideMask<float>(fib->front(), m_InterpolateMasks, m_TargetInterpolator)
            && mitk::imv::IsInsideMask<float>(fib->back(), m_InterpolateMasks, m_TargetInterpolator) )
         return true;
       return false;
     }
     else
       mitkThrow() << "No target image set but endpoint constraint EPS_IN_TARGET chosen!";
   }
   else if (m_EndpointConstraint==EndpointConstraints::EPS_IN_TARGET_LABELDIFF)
   {
     if (m_TargetImageSet)
     {
       float v1 = mitk::imv::GetImageValue<float>(fib->front(), false, m_TargetInterpolator);
       float v2 = mitk::imv::GetImageValue<float>(fib->back(), false, m_TargetInterpolator);
       if ( v1>0.0 && v2>0.0 && v1!=v2  )
         return true;
       return false;
     }
     else
       mitkThrow() << "No target image set but endpoint constraint EPS_IN_TARGET_LABELDIFF chosen!";
   }
   else if (m_EndpointConstraint==EndpointConstraints::EPS_IN_SEED_AND_TARGET)
   {
     if (m_TargetImageSet && m_SeedImageSet)
     {
       if ( mitk::imv::IsInsideMask<float>(fib->front(), m_InterpolateMasks, m_SeedInterpolator)
            && mitk::imv::IsInsideMask<float>(fib->back(), m_InterpolateMasks, m_TargetInterpolator) )
         return true;
       if ( mitk::imv::IsInsideMask<float>(fib->back(), m_InterpolateMasks, m_SeedInterpolator)
            && mitk::imv::IsInsideMask<float>(fib->front(), m_InterpolateMasks, m_TargetInterpolator) )
         return true;
       return false;
     }
     else
       mitkThrow() << "No target or seed image set but endpoint constraint EPS_IN_SEED_AND_TARGET chosen!";
   }
   else if (m_EndpointConstraint==EndpointConstraints::MIN_ONE_EP_IN_TARGET)
   {
     if (m_TargetImageSet)
     {
       if ( mitk::imv::IsInsideMask<float>(fib->front(), m_InterpolateMasks, m_TargetInterpolator)
            || mitk::imv::IsInsideMask<float>(fib->back(), m_InterpolateMasks, m_TargetInterpolator) )
         return true;
       return false;
     }
     else
       mitkThrow() << "No target image set but endpoint constraint MIN_ONE_EP_IN_TARGET chosen!";
   }
   else if (m_EndpointConstraint==EndpointConstraints::ONE_EP_IN_TARGET)
   {
     if (m_TargetImageSet)
     {
       if ( mitk::imv::IsInsideMask<float>(fib->front(), m_InterpolateMasks, m_TargetInterpolator)
            && !mitk::imv::IsInsideMask<float>(fib->back(), m_InterpolateMasks, m_TargetInterpolator) )
         return true;
       if ( !mitk::imv::IsInsideMask<float>(fib->back(), m_InterpolateMasks, m_TargetInterpolator)
            && mitk::imv::IsInsideMask<float>(fib->front(), m_InterpolateMasks, m_TargetInterpolator) )
         return true;
       return false;
     }
     else
       mitkThrow() << "No target image set but endpoint constraint ONE_EP_IN_TARGET chosen!";
   }
   else if (m_EndpointConstraint==EndpointConstraints::NO_EP_IN_TARGET)
   {
     if (m_TargetImageSet)
     {
       if ( mitk::imv::IsInsideMask<float>(fib->front(), m_InterpolateMasks, m_TargetInterpolator)
            || mitk::imv::IsInsideMask<float>(fib->back(), m_InterpolateMasks, m_TargetInterpolator) )
         return false;
       return true;
     }
     else
       mitkThrow() << "No target image set but endpoint constraint NO_EP_IN_TARGET chosen!";
   }
 
   return true;
 }
 
 void StreamlineTrackingFilter::FiberToProbmap(FiberType* fib)
 {
   ItkDoubleImgType::IndexType last_idx; last_idx.Fill(0);
   for (auto p : *fib)
   {
     ItkDoubleImgType::IndexType idx;
     m_OutputProbabilityMap->TransformPhysicalPointToIndex(p, idx);
 
     if (idx != last_idx)
     {
       if (m_OutputProbabilityMap->GetLargestPossibleRegion().IsInside(idx))
         m_OutputProbabilityMap->SetPixel(idx, m_OutputProbabilityMap->GetPixel(idx)+1);
       last_idx = idx;
     }
   }
 }
 
 void StreamlineTrackingFilter::BuildFibers(bool check)
 {
   if (m_BuildFibersReady<omp_get_num_threads() && check)
     return;
 
   m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
   vtkSmartPointer<vtkCellArray> vNewLines = vtkSmartPointer<vtkCellArray>::New();
   vtkSmartPointer<vtkPoints> vNewPoints = vtkSmartPointer<vtkPoints>::New();
 
   for (unsigned int i=0; i<m_Tractogram.size(); i++)
   {
     vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
     FiberType fib = m_Tractogram.at(i);
     for (FiberType::iterator it = fib.begin(); it!=fib.end(); ++it)
     {
       vtkIdType id = vNewPoints->InsertNextPoint((*it).GetDataPointer());
       container->GetPointIds()->InsertNextId(id);
     }
     vNewLines->InsertNextCell(container);
   }
 
   if (check)
     for (int i=0; i<m_BuildFibersReady; i++)
       m_Tractogram.pop_back();
   m_BuildFibersReady = 0;
 
   m_FiberPolyData->SetPoints(vNewPoints);
   m_FiberPolyData->SetLines(vNewLines);
   m_BuildFibersFinished = true;
 }
 
 void StreamlineTrackingFilter::AfterTracking()
 {
   if (m_Verbose)
     std::cout << "                                                                                                     \r";
   if (!m_UseOutputProbabilityMap)
   {
     MITK_INFO << "Reconstructed " << m_Tractogram.size() << " fibers.";
     MITK_INFO << "Generating polydata ";
     BuildFibers(false);
   }
   else
   {
     itk::RescaleIntensityImageFilter< ItkDoubleImgType, ItkDoubleImgType >::Pointer filter = itk::RescaleIntensityImageFilter< ItkDoubleImgType, ItkDoubleImgType >::New();
     filter->SetInput(m_OutputProbabilityMap);
     filter->SetOutputMaximum(1.0);
     filter->SetOutputMinimum(0.0);
     filter->Update();
     m_OutputProbabilityMap = filter->GetOutput();
   }
   MITK_INFO << "done";
 
   m_EndTime = std::chrono::system_clock::now();
   std::chrono::hours   hh = std::chrono::duration_cast<std::chrono::hours>(m_EndTime - m_StartTime);
   std::chrono::minutes mm = std::chrono::duration_cast<std::chrono::minutes>(m_EndTime - m_StartTime);
   std::chrono::seconds ss = std::chrono::duration_cast<std::chrono::seconds>(m_EndTime - m_StartTime);
   mm %= 60;
   ss %= 60;
   MITK_INFO << "Tracking took " << hh.count() << "h, " << mm.count() << "m and " << ss.count() << "s";
 
   m_SeedPoints.clear();
 }
 
 void StreamlineTrackingFilter::SetDicomProperties(mitk::FiberBundle::Pointer fib)
 {
   std::string model_code_value = "-";
   std::string model_code_meaning = "-";
   std::string algo_code_value = "-";
   std::string algo_code_meaning = "-";
 
   if (m_TrackingHandler->GetMode()==mitk::TrackingDataHandler::DETERMINISTIC && dynamic_cast<mitk::TrackingHandlerTensor*>(m_TrackingHandler) && !m_TrackingHandler->GetInterpolate())
   {
     algo_code_value = "sup181_ee04";
     algo_code_meaning = "FACT";
   }
   else if (m_TrackingHandler->GetMode()==mitk::TrackingDataHandler::DETERMINISTIC)
   {
     algo_code_value = "sup181_ee01";
     algo_code_meaning = "Deterministic";
   }
   else if (m_TrackingHandler->GetMode()==mitk::TrackingDataHandler::PROBABILISTIC)
   {
     algo_code_value = "sup181_ee02";
     algo_code_meaning = "Probabilistic";
   }
 
   if (dynamic_cast<mitk::TrackingHandlerTensor*>(m_TrackingHandler) || (dynamic_cast<mitk::TrackingHandlerOdf*>(m_TrackingHandler) && dynamic_cast<mitk::TrackingHandlerOdf*>(m_TrackingHandler)->GetIsOdfFromTensor() ) )
   {
     if ( dynamic_cast<mitk::TrackingHandlerTensor*>(m_TrackingHandler) && dynamic_cast<mitk::TrackingHandlerTensor*>(m_TrackingHandler)->GetNumTensorImages()>1 )
     {
       model_code_value = "sup181_bb02";
       model_code_meaning = "Multi Tensor";
     }
     else
     {
       model_code_value = "sup181_bb01";
       model_code_meaning = "Single Tensor";
     }
   }
   else if (dynamic_cast<mitk::TrackingHandlerRandomForest<6, 28>*>(m_TrackingHandler) || dynamic_cast<mitk::TrackingHandlerRandomForest<6, 100>*>(m_TrackingHandler))
   {
     model_code_value = "sup181_bb03";
     model_code_meaning = "Model Free";
   }
   else if (dynamic_cast<mitk::TrackingHandlerOdf*>(m_TrackingHandler))
   {
     model_code_value = "-";
     model_code_meaning = "ODF";
   }
   else if (dynamic_cast<mitk::TrackingHandlerPeaks*>(m_TrackingHandler))
   {
     model_code_value = "-";
     model_code_meaning = "Peaks";
   }
 
   fib->SetProperty("DICOM.anatomy.value", mitk::StringProperty::New("T-A0095"));
   fib->SetProperty("DICOM.anatomy.meaning", mitk::StringProperty::New("White matter of brain and spinal cord"));
 
   fib->SetProperty("DICOM.algo_code.value", mitk::StringProperty::New(algo_code_value));
   fib->SetProperty("DICOM.algo_code.meaning", mitk::StringProperty::New(algo_code_meaning));
 
   fib->SetProperty("DICOM.model_code.value", mitk::StringProperty::New(model_code_value));
   fib->SetProperty("DICOM.model_code.meaning", mitk::StringProperty::New(model_code_meaning));
 }
 
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/Fiberfox/itkTractsToDWIImageFilter.cpp b/Modules/DiffusionImaging/FiberTracking/Fiberfox/itkTractsToDWIImageFilter.cpp
index 28da14ba91..c246971545 100755
--- a/Modules/DiffusionImaging/FiberTracking/Fiberfox/itkTractsToDWIImageFilter.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Fiberfox/itkTractsToDWIImageFilter.cpp
@@ -1,1742 +1,1742 @@
 /*===================================================================
 
 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 "itkTractsToDWIImageFilter.h"
 #include <boost/progress.hpp>
 #include <vtkSmartPointer.h>
 #include <vtkPolyData.h>
 #include <vtkCellArray.h>
 #include <vtkPoints.h>
 #include <vtkPolyLine.h>
 #include <itkImageRegionIteratorWithIndex.h>
 #include <itkResampleImageFilter.h>
 #include <itkNearestNeighborInterpolateImageFunction.h>
 #include <itkBSplineInterpolateImageFunction.h>
 #include <itkCastImageFilter.h>
 #include <itkImageFileWriter.h>
 #include <itkRescaleIntensityImageFilter.h>
 #include <itkWindowedSincInterpolateImageFunction.h>
 #include <itkResampleDwiImageFilter.h>
 #include <itkKspaceImageFilter.h>
 #include <itkDftImageFilter.h>
 #include <itkAddImageFilter.h>
 #include <itkConstantPadImageFilter.h>
 #include <itkCropImageFilter.h>
 #include <mitkAstroStickModel.h>
 #include <vtkTransform.h>
 #include <iostream>
 #include <fstream>
 #include <exception>
 #include <itkImageDuplicator.h>
 #include <itksys/SystemTools.hxx>
 #include <mitkIOUtil.h>
 #include <itkDiffusionTensor3DReconstructionImageFilter.h>
 #include <itkDiffusionTensor3D.h>
 #include <itkTractDensityImageFilter.h>
-#include <boost/lexical_cast.hpp>
+#include <mitkLexicalCast.h>
 #include <itkTractsToVectorImageFilter.h>
 #include <itkInvertIntensityImageFilter.h>
 #include <itkShiftScaleImageFilter.h>
 #include <itkExtractImageFilter.h>
 #include <itkResampleDwiImageFilter.h>
 #include <boost/algorithm/string/replace.hpp>
 #include <omp.h>
 
 namespace itk
 {
 
 template< class PixelType >
 TractsToDWIImageFilter< PixelType >::TractsToDWIImageFilter()
   : m_FiberBundle(nullptr)
   , m_StatusText("")
   , m_UseConstantRandSeed(false)
   , m_RandGen(itk::Statistics::MersenneTwisterRandomVariateGenerator::New())
 {
   m_RandGen->SetSeed();
   m_DoubleInterpolator = itk::LinearInterpolateImageFunction< ItkDoubleImgType, float >::New();
   m_NullDir.Fill(0);
 }
 
 template< class PixelType >
 TractsToDWIImageFilter< PixelType >::~TractsToDWIImageFilter()
 {
 
 }
 
 template< class PixelType >
 TractsToDWIImageFilter< PixelType >::DoubleDwiType::Pointer TractsToDWIImageFilter< PixelType >::
 SimulateKspaceAcquisition( std::vector< DoubleDwiType::Pointer >& compartment_images )
 {
   unsigned int numFiberCompartments = m_Parameters.m_FiberModelList.size();
   // create slice object
   ImageRegion<2> sliceRegion;
   sliceRegion.SetSize(0, m_WorkingImageRegion.GetSize()[0]);
   sliceRegion.SetSize(1, m_WorkingImageRegion.GetSize()[1]);
   Vector< double, 2 > sliceSpacing;
   sliceSpacing[0] = m_WorkingSpacing[0];
   sliceSpacing[1] = m_WorkingSpacing[1];
 
   DoubleDwiType::PixelType nullPix; nullPix.SetSize(compartment_images.at(0)->GetVectorLength()); nullPix.Fill(0.0);
   auto magnitudeDwiImage = DoubleDwiType::New();
   magnitudeDwiImage->SetSpacing( m_Parameters.m_SignalGen.m_ImageSpacing );
   magnitudeDwiImage->SetOrigin( m_Parameters.m_SignalGen.m_ImageOrigin );
   magnitudeDwiImage->SetDirection( m_Parameters.m_SignalGen.m_ImageDirection );
   magnitudeDwiImage->SetLargestPossibleRegion( m_Parameters.m_SignalGen.m_CroppedRegion );
   magnitudeDwiImage->SetBufferedRegion( m_Parameters.m_SignalGen.m_CroppedRegion );
   magnitudeDwiImage->SetRequestedRegion( m_Parameters.m_SignalGen.m_CroppedRegion );
   magnitudeDwiImage->SetVectorLength( compartment_images.at(0)->GetVectorLength() );
   magnitudeDwiImage->Allocate();
   magnitudeDwiImage->FillBuffer(nullPix);
 
   m_PhaseImage = DoubleDwiType::New();
   m_PhaseImage->SetSpacing( m_Parameters.m_SignalGen.m_ImageSpacing );
   m_PhaseImage->SetOrigin( m_Parameters.m_SignalGen.m_ImageOrigin );
   m_PhaseImage->SetDirection( m_Parameters.m_SignalGen.m_ImageDirection );
   m_PhaseImage->SetLargestPossibleRegion( m_Parameters.m_SignalGen.m_CroppedRegion );
   m_PhaseImage->SetBufferedRegion( m_Parameters.m_SignalGen.m_CroppedRegion );
   m_PhaseImage->SetRequestedRegion( m_Parameters.m_SignalGen.m_CroppedRegion );
   m_PhaseImage->SetVectorLength( compartment_images.at(0)->GetVectorLength() );
   m_PhaseImage->Allocate();
   m_PhaseImage->FillBuffer(nullPix);
 
   m_KspaceImage = DoubleDwiType::New();
   m_KspaceImage->SetSpacing( m_Parameters.m_SignalGen.m_ImageSpacing );
   m_KspaceImage->SetOrigin( m_Parameters.m_SignalGen.m_ImageOrigin );
   m_KspaceImage->SetDirection( m_Parameters.m_SignalGen.m_ImageDirection );
   m_KspaceImage->SetLargestPossibleRegion( m_Parameters.m_SignalGen.m_CroppedRegion );
   m_KspaceImage->SetBufferedRegion( m_Parameters.m_SignalGen.m_CroppedRegion );
   m_KspaceImage->SetRequestedRegion( m_Parameters.m_SignalGen.m_CroppedRegion );
   m_KspaceImage->SetVectorLength( m_Parameters.m_SignalGen.m_NumberOfCoils );
   m_KspaceImage->Allocate();
   m_KspaceImage->FillBuffer(nullPix);
 
   std::vector< unsigned int > spikeVolume;
   for (unsigned int i=0; i<m_Parameters.m_SignalGen.m_Spikes; i++)
     spikeVolume.push_back(m_RandGen->GetIntegerVariate()%(compartment_images.at(0)->GetVectorLength()));
   std::sort (spikeVolume.begin(), spikeVolume.end());
   std::reverse (spikeVolume.begin(), spikeVolume.end());
 
   // calculate coil positions
   double a = m_Parameters.m_SignalGen.m_ImageRegion.GetSize(0)*m_Parameters.m_SignalGen.m_ImageSpacing[0];
   double b = m_Parameters.m_SignalGen.m_ImageRegion.GetSize(1)*m_Parameters.m_SignalGen.m_ImageSpacing[1];
   double c = m_Parameters.m_SignalGen.m_ImageRegion.GetSize(2)*m_Parameters.m_SignalGen.m_ImageSpacing[2];
   double diagonal = sqrt(a*a+b*b)/1000;   // image diagonal in m
 
   m_CoilPointset = mitk::PointSet::New();
   std::vector< itk::Vector<double, 3> > coilPositions;
   itk::Vector<double, 3> pos; pos.Fill(0.0); pos[1] = -diagonal/2;
   itk::Vector<double, 3> center;
   center[0] = a/2-m_Parameters.m_SignalGen.m_ImageSpacing[0]/2;
   center[1] = b/2-m_Parameters.m_SignalGen.m_ImageSpacing[2]/2;
   center[2] = c/2-m_Parameters.m_SignalGen.m_ImageSpacing[1]/2;
   for (int c=0; c<m_Parameters.m_SignalGen.m_NumberOfCoils; c++)
   {
     coilPositions.push_back(pos);
     m_CoilPointset->InsertPoint(c, pos*1000 + m_Parameters.m_SignalGen.m_ImageOrigin.GetVectorFromOrigin() + center );
 
     double rz = 360.0/m_Parameters.m_SignalGen.m_NumberOfCoils * itk::Math::pi/180;
     vnl_matrix_fixed< double, 3, 3 > rotZ; rotZ.set_identity();
     rotZ[0][0] = cos(rz);
     rotZ[1][1] = rotZ[0][0];
     rotZ[0][1] = -sin(rz);
     rotZ[1][0] = -rotZ[0][1];
 
     pos.SetVnlVector(rotZ*pos.GetVnlVector());
   }
 
   PrintToLog("0%   10   20   30   40   50   60   70   80   90   100%", false, true, false);
   PrintToLog("|----|----|----|----|----|----|----|----|----|----|\n*", false, false, false);
   unsigned long lastTick = 0;
 
   boost::progress_display disp(compartment_images.at(0)->GetVectorLength()*compartment_images.at(0)->GetLargestPossibleRegion().GetSize(2));
 
 #pragma omp parallel for
   for (int g=0; g<(int)compartment_images.at(0)->GetVectorLength(); g++)
   {
     if (this->GetAbortGenerateData())
       continue;
 
     std::vector< unsigned int > spikeSlice;
 #pragma omp critical
     while (!spikeVolume.empty() && (int)spikeVolume.back()==g)
     {
       spikeSlice.push_back(m_RandGen->GetIntegerVariate()%compartment_images.at(0)->GetLargestPossibleRegion().GetSize(2));
       spikeVolume.pop_back();
     }
     std::sort (spikeSlice.begin(), spikeSlice.end());
     std::reverse (spikeSlice.begin(), spikeSlice.end());
 
     for (unsigned int z=0; z<compartment_images.at(0)->GetLargestPossibleRegion().GetSize(2); z++)
     {
       std::vector< Float2DImageType::Pointer > compartment_slices;
       std::vector< float > t2Vector;
       std::vector< float > t1Vector;
 
       for (unsigned int i=0; i<compartment_images.size(); i++)
       {
         DiffusionSignalModel<double>* signalModel;
         if (i<numFiberCompartments)
           signalModel = m_Parameters.m_FiberModelList.at(i);
         else
           signalModel = m_Parameters.m_NonFiberModelList.at(i-numFiberCompartments);
 
         auto slice = Float2DImageType::New();
         slice->SetLargestPossibleRegion( sliceRegion );
         slice->SetBufferedRegion( sliceRegion );
         slice->SetRequestedRegion( sliceRegion );
         slice->SetSpacing(sliceSpacing);
         slice->Allocate();
         slice->FillBuffer(0.0);
 
         // extract slice from channel g
         for (unsigned int y=0; y<compartment_images.at(0)->GetLargestPossibleRegion().GetSize(1); y++)
           for (unsigned int x=0; x<compartment_images.at(0)->GetLargestPossibleRegion().GetSize(0); x++)
           {
             Float2DImageType::IndexType index2D; index2D[0]=x; index2D[1]=y;
             DoubleDwiType::IndexType index3D; index3D[0]=x; index3D[1]=y; index3D[2]=z;
 
             slice->SetPixel(index2D, compartment_images.at(i)->GetPixel(index3D)[g]);
           }
 
         compartment_slices.push_back(slice);
         t2Vector.push_back(signalModel->GetT2());
         t1Vector.push_back(signalModel->GetT1());
       }
 
       int numSpikes = 0;
       while (!spikeSlice.empty() && spikeSlice.back()==z)
       {
         numSpikes++;
         spikeSlice.pop_back();
       }
       int spikeCoil = m_RandGen->GetIntegerVariate()%m_Parameters.m_SignalGen.m_NumberOfCoils;
 
       if (this->GetAbortGenerateData())
         continue;
 
       for (int c=0; c<m_Parameters.m_SignalGen.m_NumberOfCoils; c++)
       {
         // create k-sapce (inverse fourier transform slices)
         auto idft = itk::KspaceImageFilter< Float2DImageType::PixelType >::New();
         idft->SetCompartmentImages(compartment_slices);
         idft->SetT2(t2Vector);
         idft->SetT1(t1Vector);
         idft->SetUseConstantRandSeed(m_UseConstantRandSeed);
         idft->SetParameters(&m_Parameters);
         idft->SetZ((float)z-(float)( compartment_images.at(0)->GetLargestPossibleRegion().GetSize(2)
                                      -compartment_images.at(0)->GetLargestPossibleRegion().GetSize(2)%2 ) / 2.0);
         idft->SetZidx(z);
         idft->SetCoilPosition(coilPositions.at(c));
         idft->SetFiberBundle(m_FiberBundleWorkingCopy);
         idft->SetTranslation(m_Translations.at(g));
         idft->SetRotation(m_Rotations.at(g));
         idft->SetDiffusionGradientDirection(m_Parameters.m_SignalGen.GetGradientDirection(g));
         if (c==spikeCoil)
           idft->SetSpikesPerSlice(numSpikes);
         idft->Update();
 
 #pragma omp critical
         if (c==spikeCoil && numSpikes>0)
         {
           m_SpikeLog += "Volume " + boost::lexical_cast<std::string>(g) + " Coil " + boost::lexical_cast<std::string>(c) + "\n";
           m_SpikeLog += idft->GetSpikeLog();
         }
 
         Complex2DImageType::Pointer fSlice;
         fSlice = idft->GetOutput();
 
         // fourier transform slice
         Complex2DImageType::Pointer newSlice;
         auto dft = itk::DftImageFilter< Float2DImageType::PixelType >::New();
         dft->SetInput(fSlice);
         dft->SetParameters(m_Parameters);
         dft->Update();
         newSlice = dft->GetOutput();
 
         // put slice back into channel g
         for (unsigned int y=0; y<fSlice->GetLargestPossibleRegion().GetSize(1); y++)
           for (unsigned int x=0; x<fSlice->GetLargestPossibleRegion().GetSize(0); x++)
           {
             DoubleDwiType::IndexType index3D; index3D[0]=x; index3D[1]=y; index3D[2]=z;
             Complex2DImageType::IndexType index2D; index2D[0]=x; index2D[1]=y;
 
             Complex2DImageType::PixelType cPix = newSlice->GetPixel(index2D);
             double magn = sqrt(cPix.real()*cPix.real()+cPix.imag()*cPix.imag());
             double phase = 0;
             if (cPix.real()!=0)
               phase = atan( cPix.imag()/cPix.real() );
 
             DoubleDwiType::PixelType real_pix = m_OutputImagesReal.at(c)->GetPixel(index3D);
             real_pix[g] = cPix.real();
             m_OutputImagesReal.at(c)->SetPixel(index3D, real_pix);
 
             DoubleDwiType::PixelType imag_pix = m_OutputImagesImag.at(c)->GetPixel(index3D);
             imag_pix[g] = cPix.imag();
             m_OutputImagesImag.at(c)->SetPixel(index3D, imag_pix);
 
             DoubleDwiType::PixelType dwiPix = magnitudeDwiImage->GetPixel(index3D);
             DoubleDwiType::PixelType phasePix = m_PhaseImage->GetPixel(index3D);
 
             if (m_Parameters.m_SignalGen.m_NumberOfCoils>1)
             {
               dwiPix[g] += magn*magn;
               phasePix[g] += phase*phase;
             }
             else
             {
               dwiPix[g] = magn;
               phasePix[g] = phase;
             }
 
             //#pragma omp critical
             {
               magnitudeDwiImage->SetPixel(index3D, dwiPix);
               m_PhaseImage->SetPixel(index3D, phasePix);
 
               // k-space image
               if (g==0)
               {
                 DoubleDwiType::PixelType kspacePix = m_KspaceImage->GetPixel(index3D);
                 kspacePix[c] = idft->GetKSpaceImage()->GetPixel(index2D);
                 m_KspaceImage->SetPixel(index3D, kspacePix);
               }
             }
           }
       }
 
       if (m_Parameters.m_SignalGen.m_NumberOfCoils>1)
       {
         for (int y=0; y<static_cast<int>(magnitudeDwiImage->GetLargestPossibleRegion().GetSize(1)); y++)
           for (int x=0; x<static_cast<int>(magnitudeDwiImage->GetLargestPossibleRegion().GetSize(0)); x++)
           {
             DoubleDwiType::IndexType index3D; index3D[0]=x; index3D[1]=y; index3D[2]=z;
             DoubleDwiType::PixelType magPix = magnitudeDwiImage->GetPixel(index3D);
             magPix[g] = sqrt(magPix[g]/m_Parameters.m_SignalGen.m_NumberOfCoils);
 
             DoubleDwiType::PixelType phasePix = m_PhaseImage->GetPixel(index3D);
             phasePix[g] = sqrt(phasePix[g]/m_Parameters.m_SignalGen.m_NumberOfCoils);
 
             //#pragma omp critical
             {
               magnitudeDwiImage->SetPixel(index3D, magPix);
               m_PhaseImage->SetPixel(index3D, phasePix);
             }
           }
       }
 
       ++disp;
       unsigned long newTick = 50*disp.count()/disp.expected_count();
       for (unsigned long tick = 0; tick<(newTick-lastTick); tick++)
         PrintToLog("*", false, false, false);
       lastTick = newTick;
     }
   }
 
 
   PrintToLog("\n", false);
   return magnitudeDwiImage;
 }
 
 template< class PixelType >
 TractsToDWIImageFilter< PixelType >::ItkDoubleImgType::Pointer TractsToDWIImageFilter< PixelType >::
 NormalizeInsideMask(ItkDoubleImgType::Pointer image)
 {
   double max = itk::NumericTraits< double >::min();
   double min = itk::NumericTraits< double >::max();
 
   itk::ImageRegionIterator< ItkDoubleImgType > it(image, image->GetLargestPossibleRegion());
   while(!it.IsAtEnd())
   {
     if (m_Parameters.m_SignalGen.m_MaskImage.IsNotNull() && m_Parameters.m_SignalGen.m_MaskImage->GetPixel(it.GetIndex())<=0)
     {
       it.Set(0.0);
       ++it;
       continue;
     }
 
     if (it.Get()>max)
       max = it.Get();
     if (it.Get()<min)
       min = it.Get();
     ++it;
   }
   auto scaler = itk::ShiftScaleImageFilter< ItkDoubleImgType, ItkDoubleImgType >::New();
   scaler->SetInput(image);
   scaler->SetShift(-min);
   scaler->SetScale(1.0/(max-min));
   scaler->Update();
   return scaler->GetOutput();
 }
 
 template< class PixelType >
 void TractsToDWIImageFilter< PixelType >::CheckVolumeFractionImages()
 {
   m_UseRelativeNonFiberVolumeFractions = false;
 
   // check for fiber volume fraction maps
   unsigned int fibVolImages = 0;
   for (std::size_t i=0; i<m_Parameters.m_FiberModelList.size(); i++)
   {
     if (m_Parameters.m_FiberModelList[i]->GetVolumeFractionImage().IsNotNull())
     {
       PrintToLog("Using volume fraction map for fiber compartment " + boost::lexical_cast<std::string>(i+1));
       fibVolImages++;
     }
   }
 
   // check for non-fiber volume fraction maps
   unsigned int nonfibVolImages = 0;
   for (std::size_t i=0; i<m_Parameters.m_NonFiberModelList.size(); i++)
   {
     if (m_Parameters.m_NonFiberModelList[i]->GetVolumeFractionImage().IsNotNull())
     {
       PrintToLog("Using volume fraction map for non-fiber compartment " + boost::lexical_cast<std::string>(i+1));
       nonfibVolImages++;
     }
   }
 
   // not all fiber compartments are using volume fraction maps
   // --> non-fiber volume fractions are assumed to be relative to the
   // non-fiber volume and not absolute voxel-volume fractions.
   // this means if two non-fiber compartments are used but only one of them
   // has an associated volume fraction map, the repesctive other volume fraction map
   // can be determined as inverse (1-val) of the present volume fraction map-
   if ( fibVolImages<m_Parameters.m_FiberModelList.size() && nonfibVolImages==1 && m_Parameters.m_NonFiberModelList.size()==2)
   {
     PrintToLog("Calculating missing non-fiber volume fraction image by inverting the other.\n"
                "Assuming non-fiber volume fraction images to contain values relative to the"
                " remaining non-fiber volume, not absolute values.");
 
     auto inverter = itk::InvertIntensityImageFilter< ItkDoubleImgType, ItkDoubleImgType >::New();
     inverter->SetMaximum(1.0);
     if ( m_Parameters.m_NonFiberModelList[0]->GetVolumeFractionImage().IsNull()
          && m_Parameters.m_NonFiberModelList[1]->GetVolumeFractionImage().IsNotNull() )
     {
       // m_Parameters.m_NonFiberModelList[1]->SetVolumeFractionImage(
       // NormalizeInsideMask( m_Parameters.m_NonFiberModelList[1]->GetVolumeFractionImage() ) );
       inverter->SetInput( m_Parameters.m_NonFiberModelList[1]->GetVolumeFractionImage() );
       inverter->Update();
       m_Parameters.m_NonFiberModelList[0]->SetVolumeFractionImage(inverter->GetOutput());
     }
     else if ( m_Parameters.m_NonFiberModelList[1]->GetVolumeFractionImage().IsNull()
               && m_Parameters.m_NonFiberModelList[0]->GetVolumeFractionImage().IsNotNull() )
     {
       // m_Parameters.m_NonFiberModelList[0]->SetVolumeFractionImage(
       // NormalizeInsideMask( m_Parameters.m_NonFiberModelList[0]->GetVolumeFractionImage() ) );
       inverter->SetInput( m_Parameters.m_NonFiberModelList[0]->GetVolumeFractionImage() );
       inverter->Update();
       m_Parameters.m_NonFiberModelList[1]->SetVolumeFractionImage(inverter->GetOutput());
     }
     else
     {
       itkExceptionMacro("Something went wrong in automatically calculating the missing non-fiber volume fraction image!"
                         " Did you use two non fiber compartments but only one volume fraction image?"
                         " Then it should work and this error is really strange.");
     }
     m_UseRelativeNonFiberVolumeFractions = true;
 
     nonfibVolImages++;
   }
 
   // Up to two fiber compartments are allowed without volume fraction maps since the volume fractions can then be determined automatically
   if (m_Parameters.m_FiberModelList.size()>2
       && fibVolImages!=m_Parameters.m_FiberModelList.size())
     itkExceptionMacro("More than two fiber compartment selected but no corresponding volume fraction maps set!");
 
   // One non-fiber compartment is allowed without volume fraction map since the volume fraction can then be determined automatically
   if (m_Parameters.m_NonFiberModelList.size()>1
       && nonfibVolImages!=m_Parameters.m_NonFiberModelList.size())
     itkExceptionMacro("More than one non-fiber compartment selected but no volume fraction maps set!");
 
   if (fibVolImages<m_Parameters.m_FiberModelList.size() && nonfibVolImages>0)
   {
     PrintToLog("Not all fiber compartments are using an associated volume fraction image.\n"
                "Assuming non-fiber volume fraction images to contain values relative to the"
                " remaining non-fiber volume, not absolute values.");
     m_UseRelativeNonFiberVolumeFractions = true;
 
     //        itk::ImageFileWriter<ItkDoubleImgType>::Pointer wr = itk::ImageFileWriter<ItkDoubleImgType>::New();
     //        wr->SetInput(m_Parameters.m_NonFiberModelList[1]->GetVolumeFractionImage());
     //        wr->SetFileName("/local/volumefraction.nrrd");
     //        wr->Update();
   }
 
   // initialize the images that store the output volume fraction of each compartment
   m_VolumeFractions.clear();
   for (std::size_t i=0; i<m_Parameters.m_FiberModelList.size()+m_Parameters.m_NonFiberModelList.size(); i++)
   {
     auto doubleImg = ItkDoubleImgType::New();
     doubleImg->SetSpacing( m_WorkingSpacing );
     doubleImg->SetOrigin( m_WorkingOrigin );
     doubleImg->SetDirection( m_Parameters.m_SignalGen.m_ImageDirection );
     doubleImg->SetLargestPossibleRegion( m_WorkingImageRegion );
     doubleImg->SetBufferedRegion( m_WorkingImageRegion );
     doubleImg->SetRequestedRegion( m_WorkingImageRegion );
     doubleImg->Allocate();
     doubleImg->FillBuffer(0);
     m_VolumeFractions.push_back(doubleImg);
   }
 }
 
 template< class PixelType >
 void TractsToDWIImageFilter< PixelType >::InitializeData()
 {
   m_Rotations.clear();
   m_Translations.clear();
   m_MotionLog = "";
   m_SpikeLog = "";
 
   // initialize output dwi image
   m_Parameters.m_SignalGen.m_CroppedRegion = m_Parameters.m_SignalGen.m_ImageRegion;
   m_Parameters.m_SignalGen.m_CroppedRegion.SetSize( 1, m_Parameters.m_SignalGen.m_CroppedRegion.GetSize(1)
                                                     *m_Parameters.m_SignalGen.m_CroppingFactor);
 
   itk::Point<double,3> shiftedOrigin = m_Parameters.m_SignalGen.m_ImageOrigin;
   shiftedOrigin[1] += (m_Parameters.m_SignalGen.m_ImageRegion.GetSize(1)
                        -m_Parameters.m_SignalGen.m_CroppedRegion.GetSize(1))*m_Parameters.m_SignalGen.m_ImageSpacing[1]/2;
 
   m_OutputImage = OutputImageType::New();
   m_OutputImage->SetSpacing( m_Parameters.m_SignalGen.m_ImageSpacing );
   m_OutputImage->SetOrigin( shiftedOrigin );
   m_OutputImage->SetDirection( m_Parameters.m_SignalGen.m_ImageDirection );
   m_OutputImage->SetLargestPossibleRegion( m_Parameters.m_SignalGen.m_CroppedRegion );
   m_OutputImage->SetBufferedRegion( m_Parameters.m_SignalGen.m_CroppedRegion );
   m_OutputImage->SetRequestedRegion( m_Parameters.m_SignalGen.m_CroppedRegion );
   m_OutputImage->SetVectorLength( m_Parameters.m_SignalGen.GetNumVolumes() );
   m_OutputImage->Allocate();
   typename OutputImageType::PixelType temp;
   temp.SetSize(m_Parameters.m_SignalGen.GetNumVolumes());
   temp.Fill(0.0);
   m_OutputImage->FillBuffer(temp);
 
   // images containing real and imaginary part of the dMRI signal for each coil
   m_OutputImagesReal.clear();
   m_OutputImagesImag.clear();
   for (int i=0; i<m_Parameters.m_SignalGen.m_NumberOfCoils; ++i)
   {
     typename DoubleDwiType::Pointer outputImageReal = DoubleDwiType::New();
     outputImageReal->SetSpacing( m_Parameters.m_SignalGen.m_ImageSpacing );
     outputImageReal->SetOrigin( shiftedOrigin );
     outputImageReal->SetDirection( m_Parameters.m_SignalGen.m_ImageDirection );
     outputImageReal->SetLargestPossibleRegion( m_Parameters.m_SignalGen.m_CroppedRegion );
     outputImageReal->SetBufferedRegion( m_Parameters.m_SignalGen.m_CroppedRegion );
     outputImageReal->SetRequestedRegion( m_Parameters.m_SignalGen.m_CroppedRegion );
     outputImageReal->SetVectorLength( m_Parameters.m_SignalGen.GetNumVolumes() );
     outputImageReal->Allocate();
     outputImageReal->FillBuffer(temp);
     m_OutputImagesReal.push_back(outputImageReal);
 
     typename DoubleDwiType::Pointer outputImageImag = DoubleDwiType::New();
     outputImageImag->SetSpacing( m_Parameters.m_SignalGen.m_ImageSpacing );
     outputImageImag->SetOrigin( shiftedOrigin );
     outputImageImag->SetDirection( m_Parameters.m_SignalGen.m_ImageDirection );
     outputImageImag->SetLargestPossibleRegion( m_Parameters.m_SignalGen.m_CroppedRegion );
     outputImageImag->SetBufferedRegion( m_Parameters.m_SignalGen.m_CroppedRegion );
     outputImageImag->SetRequestedRegion( m_Parameters.m_SignalGen.m_CroppedRegion );
     outputImageImag->SetVectorLength( m_Parameters.m_SignalGen.GetNumVolumes() );
     outputImageImag->Allocate();
     outputImageImag->FillBuffer(temp);
     m_OutputImagesImag.push_back(outputImageImag);
   }
 
   // Apply in-plane upsampling for Gibbs ringing artifact
   double upsampling = 1;
   if (m_Parameters.m_SignalGen.m_DoAddGibbsRinging)
     upsampling = 2;
   m_WorkingSpacing = m_Parameters.m_SignalGen.m_ImageSpacing;
   m_WorkingSpacing[0] /= upsampling;
   m_WorkingSpacing[1] /= upsampling;
   m_WorkingImageRegion = m_Parameters.m_SignalGen.m_ImageRegion;
   m_WorkingImageRegion.SetSize(0, m_Parameters.m_SignalGen.m_ImageRegion.GetSize()[0]*upsampling);
   m_WorkingImageRegion.SetSize(1, m_Parameters.m_SignalGen.m_ImageRegion.GetSize()[1]*upsampling);
   m_WorkingOrigin = m_Parameters.m_SignalGen.m_ImageOrigin;
   m_WorkingOrigin[0] -= m_Parameters.m_SignalGen.m_ImageSpacing[0]/2;
   m_WorkingOrigin[0] += m_WorkingSpacing[0]/2;
   m_WorkingOrigin[1] -= m_Parameters.m_SignalGen.m_ImageSpacing[1]/2;
   m_WorkingOrigin[1] += m_WorkingSpacing[1]/2;
   m_WorkingOrigin[2] -= m_Parameters.m_SignalGen.m_ImageSpacing[2]/2;
   m_WorkingOrigin[2] += m_WorkingSpacing[2]/2;
   m_VoxelVolume = m_WorkingSpacing[0]*m_WorkingSpacing[1]*m_WorkingSpacing[2];
 
   // generate double images to store the individual compartment signals
   m_CompartmentImages.clear();
   int numFiberCompartments = m_Parameters.m_FiberModelList.size();
   int numNonFiberCompartments = m_Parameters.m_NonFiberModelList.size();
   for (int i=0; i<numFiberCompartments+numNonFiberCompartments; i++)
   {
     auto doubleDwi = DoubleDwiType::New();
     doubleDwi->SetSpacing( m_WorkingSpacing );
     doubleDwi->SetOrigin( m_WorkingOrigin );
     doubleDwi->SetDirection( m_Parameters.m_SignalGen.m_ImageDirection );
     doubleDwi->SetLargestPossibleRegion( m_WorkingImageRegion );
     doubleDwi->SetBufferedRegion( m_WorkingImageRegion );
     doubleDwi->SetRequestedRegion( m_WorkingImageRegion );
     doubleDwi->SetVectorLength( m_Parameters.m_SignalGen.GetNumVolumes() );
     doubleDwi->Allocate();
     DoubleDwiType::PixelType pix;
     pix.SetSize(m_Parameters.m_SignalGen.GetNumVolumes());
     pix.Fill(0.0);
     doubleDwi->FillBuffer(pix);
     m_CompartmentImages.push_back(doubleDwi);
   }
 
   if (m_FiberBundle.IsNull() && m_InputImage.IsNotNull())
   {
     m_CompartmentImages.clear();
 
     m_Parameters.m_SignalGen.m_DoAddMotion = false;
     m_Parameters.m_SignalGen.m_DoSimulateRelaxation = false;
 
     PrintToLog("Simulating acquisition for input diffusion-weighted image.", false);
     auto caster = itk::CastImageFilter< OutputImageType, DoubleDwiType >::New();
     caster->SetInput(m_InputImage);
     caster->Update();
 
     if (m_Parameters.m_SignalGen.m_DoAddGibbsRinging)
     {
       PrintToLog("Upsampling input diffusion-weighted image for Gibbs ringing simulation.", false);
 
       auto resampler = itk::ResampleDwiImageFilter< double >::New();
       resampler->SetInput(caster->GetOutput());
       itk::Vector< double, 3 > samplingFactor;
       samplingFactor[0] = upsampling;
       samplingFactor[1] = upsampling;
       samplingFactor[2] = 1;
       resampler->SetSamplingFactor(samplingFactor);
       resampler->SetInterpolation(itk::ResampleDwiImageFilter< double >::Interpolate_WindowedSinc);
       resampler->Update();
       m_CompartmentImages.push_back(resampler->GetOutput());
     }
     else
       m_CompartmentImages.push_back(caster->GetOutput());
 
     for (unsigned int g=0; g<m_Parameters.m_SignalGen.GetNumVolumes(); g++)
     {
       m_Rotation.Fill(0.0);
       m_Translation.Fill(0.0);
       m_Rotations.push_back(m_Rotation);
       m_Translations.push_back(m_Translation);
     }
   }
 
   // resample mask image and frequency map to fit upsampled geometry
   if (m_Parameters.m_SignalGen.m_DoAddGibbsRinging)
   {
     if (m_Parameters.m_SignalGen.m_MaskImage.IsNotNull())
     {
       // rescale mask image (otherwise there are problems with the resampling)
       auto rescaler = itk::RescaleIntensityImageFilter<ItkUcharImgType,ItkUcharImgType>::New();
       rescaler->SetInput(0,m_Parameters.m_SignalGen.m_MaskImage);
       rescaler->SetOutputMaximum(100);
       rescaler->SetOutputMinimum(0);
       rescaler->Update();
 
       // resample mask image
       auto resampler = itk::ResampleImageFilter<ItkUcharImgType, ItkUcharImgType>::New();
       resampler->SetInput(rescaler->GetOutput());
       resampler->SetOutputParametersFromImage(m_Parameters.m_SignalGen.m_MaskImage);
       resampler->SetSize(m_WorkingImageRegion.GetSize());
       resampler->SetOutputSpacing(m_WorkingSpacing);
       resampler->SetOutputOrigin(m_WorkingOrigin);
       auto nn_interpolator = itk::NearestNeighborInterpolateImageFunction<ItkUcharImgType, double>::New();
       resampler->SetInterpolator(nn_interpolator);
       resampler->Update();
       m_Parameters.m_SignalGen.m_MaskImage = resampler->GetOutput();
     }
     // resample frequency map
     if (m_Parameters.m_SignalGen.m_FrequencyMap.IsNotNull())
     {
       auto resampler = itk::ResampleImageFilter<ItkFloatImgType, ItkFloatImgType>::New();
       resampler->SetInput(m_Parameters.m_SignalGen.m_FrequencyMap);
       resampler->SetOutputParametersFromImage(m_Parameters.m_SignalGen.m_FrequencyMap);
       resampler->SetSize(m_WorkingImageRegion.GetSize());
       resampler->SetOutputSpacing(m_WorkingSpacing);
       resampler->SetOutputOrigin(m_WorkingOrigin);
       auto nn_interpolator = itk::NearestNeighborInterpolateImageFunction<ItkFloatImgType, double>::New();
       resampler->SetInterpolator(nn_interpolator);
       resampler->Update();
       m_Parameters.m_SignalGen.m_FrequencyMap = resampler->GetOutput();
     }
   }
 
   m_MaskImageSet = true;
   if (m_Parameters.m_SignalGen.m_MaskImage.IsNull())
   {
     // no input tissue mask is set -> create default
     PrintToLog("No tissue mask set", false);
     m_Parameters.m_SignalGen.m_MaskImage = ItkUcharImgType::New();
     m_Parameters.m_SignalGen.m_MaskImage->SetSpacing( m_WorkingSpacing );
     m_Parameters.m_SignalGen.m_MaskImage->SetOrigin( m_WorkingOrigin );
     m_Parameters.m_SignalGen.m_MaskImage->SetDirection( m_Parameters.m_SignalGen.m_ImageDirection );
     m_Parameters.m_SignalGen.m_MaskImage->SetLargestPossibleRegion( m_WorkingImageRegion );
     m_Parameters.m_SignalGen.m_MaskImage->SetBufferedRegion( m_WorkingImageRegion );
     m_Parameters.m_SignalGen.m_MaskImage->SetRequestedRegion( m_WorkingImageRegion );
     m_Parameters.m_SignalGen.m_MaskImage->Allocate();
     m_Parameters.m_SignalGen.m_MaskImage->FillBuffer(100);
     m_MaskImageSet = false;
   }
   else
   {
     if (m_Parameters.m_SignalGen.m_MaskImage->GetLargestPossibleRegion()!=m_WorkingImageRegion)
     {
       itkExceptionMacro("Mask image and specified DWI geometry are not matching!");
     }
     PrintToLog("Using tissue mask", false);
   }
 
   if (m_Parameters.m_SignalGen.m_DoAddMotion)
   {
     if (m_Parameters.m_SignalGen.m_DoRandomizeMotion)
     {
       PrintToLog("Random motion artifacts:", false);
       PrintToLog("Maximum rotation: +/-" + boost::lexical_cast<std::string>(m_Parameters.m_SignalGen.m_Rotation) + "°", false);
       PrintToLog("Maximum translation: +/-" + boost::lexical_cast<std::string>(m_Parameters.m_SignalGen.m_Translation) + "mm", false);
     }
     else
     {
       PrintToLog("Linear motion artifacts:", false);
       PrintToLog("Maximum rotation: " + boost::lexical_cast<std::string>(m_Parameters.m_SignalGen.m_Rotation) + "°", false);
       PrintToLog("Maximum translation: " + boost::lexical_cast<std::string>(m_Parameters.m_SignalGen.m_Translation) + "mm", false);
     }
   }
   if ( m_Parameters.m_SignalGen.m_MotionVolumes.empty() )
   {
     // no motion in first volume
     m_Parameters.m_SignalGen.m_MotionVolumes.push_back(false);
 
     // motion in all other volumes
     while ( m_Parameters.m_SignalGen.m_MotionVolumes.size() < m_Parameters.m_SignalGen.GetNumVolumes() )
     {
       m_Parameters.m_SignalGen.m_MotionVolumes.push_back(true);
     }
   }
   // we need to know for every volume if there is motion. if this information is missing, then set corresponding fal to false
   while ( m_Parameters.m_SignalGen.m_MotionVolumes.size()<m_Parameters.m_SignalGen.GetNumVolumes() )
   {
     m_Parameters.m_SignalGen.m_MotionVolumes.push_back(false);
   }
 
   m_NumMotionVolumes = 0;
   for (unsigned int i=0; i<m_Parameters.m_SignalGen.GetNumVolumes(); ++i)
   {
     if (m_Parameters.m_SignalGen.m_MotionVolumes[i])
       ++m_NumMotionVolumes;
   }
   m_MotionCounter = 0;
 
   // creat image to hold transformed mask (motion artifact)
   m_TransformedMaskImage = ItkUcharImgType::New();
   auto duplicator = itk::ImageDuplicator<ItkUcharImgType>::New();
   duplicator->SetInputImage(m_Parameters.m_SignalGen.m_MaskImage);
   duplicator->Update();
   m_TransformedMaskImage = duplicator->GetOutput();
 
   // second upsampling needed for motion artifacts
   ImageRegion<3>      upsampledImageRegion = m_WorkingImageRegion;
   DoubleVectorType    upsampledSpacing = m_WorkingSpacing;
   upsampledSpacing[0] /= 4;
   upsampledSpacing[1] /= 4;
   upsampledSpacing[2] /= 4;
   upsampledImageRegion.SetSize(0, m_WorkingImageRegion.GetSize()[0]*4);
   upsampledImageRegion.SetSize(1, m_WorkingImageRegion.GetSize()[1]*4);
   upsampledImageRegion.SetSize(2, m_WorkingImageRegion.GetSize()[2]*4);
   itk::Point<double,3> upsampledOrigin = m_WorkingOrigin;
   upsampledOrigin[0] -= m_WorkingSpacing[0]/2;
   upsampledOrigin[0] += upsampledSpacing[0]/2;
   upsampledOrigin[1] -= m_WorkingSpacing[1]/2;
   upsampledOrigin[1] += upsampledSpacing[1]/2;
   upsampledOrigin[2] -= m_WorkingSpacing[2]/2;
   upsampledOrigin[2] += upsampledSpacing[2]/2;
 
   m_UpsampledMaskImage = ItkUcharImgType::New();
   auto upsampler = itk::ResampleImageFilter<ItkUcharImgType, ItkUcharImgType>::New();
   upsampler->SetInput(m_Parameters.m_SignalGen.m_MaskImage);
   upsampler->SetOutputParametersFromImage(m_Parameters.m_SignalGen.m_MaskImage);
   upsampler->SetSize(upsampledImageRegion.GetSize());
   upsampler->SetOutputSpacing(upsampledSpacing);
   upsampler->SetOutputOrigin(upsampledOrigin);
 
   auto nn_interpolator = itk::NearestNeighborInterpolateImageFunction<ItkUcharImgType, double>::New();
   upsampler->SetInterpolator(nn_interpolator);
   upsampler->Update();
   m_UpsampledMaskImage = upsampler->GetOutput();
 }
 
 template< class PixelType >
 void TractsToDWIImageFilter< PixelType >::InitializeFiberData()
 {
   // resample fiber bundle for sufficient voxel coverage
   PrintToLog("Resampling fibers ...");
   m_SegmentVolume = 0.0001;
   float minSpacing = 1;
   if( m_WorkingSpacing[0]<m_WorkingSpacing[1]
       && m_WorkingSpacing[0]<m_WorkingSpacing[2])
   {
     minSpacing = m_WorkingSpacing[0];
   }
   else if (m_WorkingSpacing[1] < m_WorkingSpacing[2])
   {
     minSpacing = m_WorkingSpacing[1];
   }
   else
   {
     minSpacing = m_WorkingSpacing[2];
   }
 
   // working copy is needed because we need to resample the fibers but do not want to change the original bundle
   m_FiberBundleWorkingCopy = m_FiberBundle->GetDeepCopy();
   double volumeAccuracy = 10;
   m_FiberBundleWorkingCopy->ResampleLinear(minSpacing/volumeAccuracy);
   m_mmRadius = m_Parameters.m_SignalGen.m_AxonRadius/1000;
 
   auto caster = itk::CastImageFilter< itk::Image<unsigned char, 3>, itk::Image<float, 3> >::New();
   caster->SetInput(m_TransformedMaskImage);
   caster->Update();
 
   vtkSmartPointer<vtkFloatArray> weights = m_FiberBundleWorkingCopy->GetFiberWeights();
   float mean_weight = 0;
   for (int i=0; i<weights->GetSize(); i++)
     mean_weight += weights->GetValue(i);
   mean_weight /= weights->GetSize();
 
   if (mean_weight>0.000001)
     for (int i=0; i<weights->GetSize(); i++)
       m_FiberBundleWorkingCopy->SetFiberWeight(i, weights->GetValue(i)/mean_weight);
   else
     PrintToLog("\nWarning: streamlines have VERY low weights. Average weight: " + boost::lexical_cast<std::string>(mean_weight) + ". Possible source of calculation errors.", false, true, true);
 
 
   auto density_calculator = itk::TractDensityImageFilter< itk::Image<float, 3> >::New();
   density_calculator->SetFiberBundle(m_FiberBundleWorkingCopy);
   density_calculator->SetInputImage(caster->GetOutput());
   density_calculator->SetBinaryOutput(false);
   density_calculator->SetUseImageGeometry(true);
   density_calculator->SetDoFiberResampling(false);
   density_calculator->SetOutputAbsoluteValues(true);
   density_calculator->SetWorkOnFiberCopy(false);
   density_calculator->Update();
   float max_density = density_calculator->GetMaxDensity();
 
   if (m_mmRadius>0)
   {
     m_SegmentVolume = itk::Math::pi*m_mmRadius*m_mmRadius*minSpacing/volumeAccuracy;
     std::stringstream stream;
     stream << std::fixed << setprecision(2) << max_density * m_SegmentVolume;
     std::string s = stream.str();
     PrintToLog("\nMax. fiber volume: " + s + "mm².", false, true, true);
   }
   else
   {
     std::stringstream stream;
     stream << std::fixed << setprecision(2) << max_density * m_SegmentVolume;
     std::string s = stream.str();
     PrintToLog("\nMax. fiber volume: " + s + "mm² (before rescaling to voxel volume).", false, true, true);
   }
   float voxel_volume = m_WorkingSpacing[0]*m_WorkingSpacing[1]*m_WorkingSpacing[2];
   float new_seg_vol = voxel_volume/max_density;
   float new_fib_radius = 1000*std::sqrt(new_seg_vol*volumeAccuracy/(minSpacing*itk::Math::pi));
   std::stringstream stream;
   stream << std::fixed << setprecision(2) << new_fib_radius;
   std::string s = stream.str();
   PrintToLog("\nA full fiber voxel corresponds to a fiber radius of ~" + s + "µm, given the current fiber configuration.", false, true, true);
 
   // a second fiber bundle is needed to store the transformed version of the m_FiberBundleWorkingCopy
   m_FiberBundleTransformed = m_FiberBundleWorkingCopy;
 }
 
 
 template< class PixelType >
 bool TractsToDWIImageFilter< PixelType >::PrepareLogFile()
 {
   assert( ! m_Logfile.is_open() );
 
   std::string filePath;
   std::string fileName;
 
   // Get directory name:
   if (m_Parameters.m_Misc.m_OutputPath.size() > 0)
   {
     filePath = m_Parameters.m_Misc.m_OutputPath;
     if( *(--(filePath.cend())) != '/')
     {
       filePath.push_back('/');
     }
   }
   else
   {
     filePath = mitk::IOUtil::GetTempPath() + '/';
   }
   // check if directory exists, else use /tmp/:
   if( itksys::SystemTools::FileIsDirectory( filePath ) )
   {
     while( *(--(filePath.cend())) == '/')
     {
       filePath.pop_back();
     }
     filePath = filePath + '/';
   }
   else
   {
     filePath = mitk::IOUtil::GetTempPath() + '/';
   }
 
   // Get file name:
   if( ! m_Parameters.m_Misc.m_ResultNode->GetName().empty() )
   {
     fileName = m_Parameters.m_Misc.m_ResultNode->GetName();
   }
   else
   {
     fileName = "";
   }
 
   if( ! m_Parameters.m_Misc.m_OutputPrefix.empty() )
   {
     fileName = m_Parameters.m_Misc.m_OutputPrefix + fileName;
   }
   else
   {
     fileName = "fiberfox";
   }
 
   // check if file already exists and DO NOT overwrite existing files:
   std::string NameTest = fileName;
   int c = 0;
   while( itksys::SystemTools::FileExists( filePath + '/' + fileName + ".log" )
          && c <= std::numeric_limits<int>::max() )
   {
     fileName = NameTest + "_" + boost::lexical_cast<std::string>(c);
     ++c;
   }
 
   try
   {
     m_Logfile.open( ( filePath + '/' + fileName + ".log" ).c_str() );
   }
   catch (const std::ios_base::failure &fail)
   {
     MITK_ERROR << "itkTractsToDWIImageFilter.cpp: Exception " << fail.what()
                << " while trying to open file" << filePath << '/' << fileName << ".log";
     return false;
   }
 
   if ( m_Logfile.is_open() )
   {
     PrintToLog( "Logfile: " + filePath + '/' + fileName + ".log", false );
     return true;
   }
   else
   {
     m_StatusText += "Logfile could not be opened!\n";
     MITK_ERROR << "itkTractsToDWIImageFilter.cpp: Logfile could not be opened!";
     return false;
   }
 }
 
 
 template< class PixelType >
 void TractsToDWIImageFilter< PixelType >::GenerateData()
 {
   // prepare logfile
   if ( ! PrepareLogFile() )
   {
     this->SetAbortGenerateData( true );
     return;
   }
 
   m_TimeProbe.Start();
 
   // check input data
   if (m_FiberBundle.IsNull() && m_InputImage.IsNull())
     itkExceptionMacro("Input fiber bundle and input diffusion-weighted image is nullptr!");
 
   if (m_Parameters.m_FiberModelList.empty() && m_InputImage.IsNull())
     itkExceptionMacro("No diffusion model for fiber compartments defined and input diffusion-weighted"
                       " image is nullptr! At least one fiber compartment is necessary to simulate diffusion.");
 
   if (m_Parameters.m_NonFiberModelList.empty() && m_InputImage.IsNull())
     itkExceptionMacro("No diffusion model for non-fiber compartments defined and input diffusion-weighted"
                       " image is nullptr! At least one non-fiber compartment is necessary to simulate diffusion.");
 
   if (m_Parameters.m_SignalGen.m_DoDisablePartialVolume)  // no partial volume? remove all but first fiber compartment
     while (m_Parameters.m_FiberModelList.size()>1)
       m_Parameters.m_FiberModelList.pop_back();
 
   //    int baselineIndex = m_Parameters.m_SignalGen.GetFirstBaselineIndex();
   //    if (baselineIndex<0) { itkExceptionMacro("No baseline index found!"); }
 
   if (!m_Parameters.m_SignalGen.m_SimulateKspaceAcquisition)  // No upsampling of input image needed if no k-space simulation is performed
     m_Parameters.m_SignalGen.m_DoAddGibbsRinging = false;
 
   if (m_UseConstantRandSeed)  // always generate the same random numbers?
     m_RandGen->SetSeed(0);
   else
     m_RandGen->SetSeed();
 
   InitializeData();
   if ( m_FiberBundle.IsNotNull() )    // if no fiber bundle is found, we directly proceed to the k-space acquisition simulation
   {
     CheckVolumeFractionImages();
     InitializeFiberData();
 
     int numFiberCompartments = m_Parameters.m_FiberModelList.size();
     int numNonFiberCompartments = m_Parameters.m_NonFiberModelList.size();
 
     double maxVolume = 0;
     unsigned long lastTick = 0;
     int signalModelSeed = m_RandGen->GetIntegerVariate();
 
     PrintToLog("\n", false, false);
     PrintToLog("Generating " + boost::lexical_cast<std::string>(numFiberCompartments+numNonFiberCompartments)
                + "-compartment diffusion-weighted signal.");
 
     std::vector< int > bVals = m_Parameters.m_SignalGen.GetBvalues();
     PrintToLog("b-values: ", false, false, true);
     for (auto v : bVals)
       PrintToLog(boost::lexical_cast<std::string>(v) + " ", false, false, true);
     PrintToLog("\n", false, false, true);
     PrintToLog("\n", false, false, true);
 
     int numFibers = m_FiberBundleWorkingCopy->GetNumFibers();
     boost::progress_display disp(numFibers*m_Parameters.m_SignalGen.GetNumVolumes());
 
     if (m_FiberBundle->GetMeanFiberLength()<5.0)
       omp_set_num_threads(2);
 
     PrintToLog("0%   10   20   30   40   50   60   70   80   90   100%", false, true, false);
     PrintToLog("|----|----|----|----|----|----|----|----|----|----|\n*", false, false, false);
 
     for (unsigned int g=0; g<m_Parameters.m_SignalGen.GetNumVolumes(); ++g)
     {
       // move fibers
       SimulateMotion(g);
 
       // Set signal model random generator seeds to get same configuration in each voxel
       for (std::size_t i=0; i<m_Parameters.m_FiberModelList.size(); i++)
         m_Parameters.m_FiberModelList.at(i)->SetSeed(signalModelSeed);
       for (std::size_t i=0; i<m_Parameters.m_NonFiberModelList.size(); i++)
         m_Parameters.m_NonFiberModelList.at(i)->SetSeed(signalModelSeed);
 
       // storing voxel-wise intra-axonal volume in mm³
       auto intraAxonalVolumeImage = ItkDoubleImgType::New();
       intraAxonalVolumeImage->SetSpacing( m_WorkingSpacing );
       intraAxonalVolumeImage->SetOrigin( m_WorkingOrigin );
       intraAxonalVolumeImage->SetDirection( m_Parameters.m_SignalGen.m_ImageDirection );
       intraAxonalVolumeImage->SetLargestPossibleRegion( m_WorkingImageRegion );
       intraAxonalVolumeImage->SetBufferedRegion( m_WorkingImageRegion );
       intraAxonalVolumeImage->SetRequestedRegion( m_WorkingImageRegion );
       intraAxonalVolumeImage->Allocate();
       intraAxonalVolumeImage->FillBuffer(0);
       maxVolume = 0;
 
       if (this->GetAbortGenerateData())
         continue;
 
       vtkPolyData* fiberPolyData = m_FiberBundleTransformed->GetFiberPolyData();
       // generate fiber signal (if there are any fiber models present)
       if (!m_Parameters.m_FiberModelList.empty())
       {
 #pragma omp parallel for
         for( int i=0; i<numFibers; i++ )
         {
           if (this->GetAbortGenerateData())
             continue;
 
           float fiberWeight = m_FiberBundleTransformed->GetFiberWeight(i);
 
           int numPoints = -1;
           std::vector< itk::Vector<double, 3> > points_copy;
 #pragma omp critical
           {
             vtkCell* cell = fiberPolyData->GetCell(i);
             numPoints = cell->GetNumberOfPoints();
             vtkPoints* points = cell->GetPoints();
             for (int j=0; j<numPoints; j++)
               points_copy.push_back(GetItkVector(points->GetPoint(j)));
           }
 
           if (numPoints<2)
             continue;
 
           for( int j=0; j<numPoints; j++)
           {
             if (this->GetAbortGenerateData())
             {
               j=numPoints;
               continue;
             }
 
             itk::Point<float, 3> vertex = points_copy.at(j);
             itk::Vector<double> v = points_copy.at(j);
 
             itk::Vector<double, 3> dir(3);
             if (j<numPoints-1) { dir = points_copy.at(j+1)-v; }
             else { dir = v-points_copy.at(j-1); }
 
             if ( dir.GetSquaredNorm()<0.0001 || dir[0]!=dir[0] || dir[1]!=dir[1] || dir[2]!=dir[2] )
               continue;
 
             itk::Index<3> idx;
             itk::ContinuousIndex<float, 3> contIndex;
             m_TransformedMaskImage->TransformPhysicalPointToIndex(vertex, idx);
             m_TransformedMaskImage->TransformPhysicalPointToContinuousIndex(vertex, contIndex);
 
             if (!m_TransformedMaskImage->GetLargestPossibleRegion().IsInside(idx) || m_TransformedMaskImage->GetPixel(idx)<=0)
               continue;
             dir.Normalize();
 
             // generate signal for each fiber compartment
             for (int k=0; k<numFiberCompartments; k++)
             {
               DoubleDwiType::PixelType pix = m_CompartmentImages.at(k)->GetPixel(idx);
               pix[g] += fiberWeight*m_SegmentVolume*m_Parameters.m_FiberModelList[k]->SimulateMeasurement(g, dir);
               m_CompartmentImages.at(k)->SetPixel(idx, pix);
             }
 
             // update fiber volume image
             double vol = intraAxonalVolumeImage->GetPixel(idx) + m_SegmentVolume*fiberWeight;
             intraAxonalVolumeImage->SetPixel(idx, vol);
 
             // we assume that the first volume is always unweighted!
             if (vol>maxVolume) { maxVolume = vol; }
           }
 
 #pragma omp critical
           {
             // progress report
             ++disp;
             unsigned long newTick = 50*disp.count()/disp.expected_count();
             for (unsigned int tick = 0; tick<(newTick-lastTick); ++tick)
               PrintToLog("*", false, false, false);
             lastTick = newTick;
           }
         }
       }
 
       // axon radius not manually defined --> set fullest voxel (maxVolume) to full fiber voxel
       double density_correctiony_global = 1.0;
       if (m_Parameters.m_SignalGen.m_AxonRadius<0.0001)
         density_correctiony_global = m_VoxelVolume/maxVolume;
 
       // generate non-fiber signal
       ImageRegionIterator<ItkUcharImgType> it3(m_TransformedMaskImage, m_TransformedMaskImage->GetLargestPossibleRegion());
       while(!it3.IsAtEnd())
       {
         if (it3.Get()>0)
         {
           DoubleDwiType::IndexType index = it3.GetIndex();
           double iAxVolume = intraAxonalVolumeImage->GetPixel(index);
 
           // get non-transformed point (remove headmotion tranformation)
           // this point lives in the volume fraction image space
           itk::Point<double, 3> volume_fraction_point;
           if ( m_Parameters.m_SignalGen.m_DoAddMotion && m_Parameters.m_SignalGen.m_MotionVolumes[g] )
             volume_fraction_point = GetMovedPoint(index, false);
           else
             m_TransformedMaskImage->TransformIndexToPhysicalPoint(index, volume_fraction_point);
 
           if (m_Parameters.m_SignalGen.m_DoDisablePartialVolume)
           {
             if (iAxVolume>0.0001) // scale fiber compartment to voxel
             {
               DoubleDwiType::PixelType pix = m_CompartmentImages.at(0)->GetPixel(index);
               pix[g] *= m_VoxelVolume/iAxVolume;
               m_CompartmentImages.at(0)->SetPixel(index, pix);
 
               if (g==0)
                 m_VolumeFractions.at(0)->SetPixel(index, 1);
             }
             else
             {
               DoubleDwiType::PixelType pix = m_CompartmentImages.at(0)->GetPixel(index);
               pix[g] = 0;
               m_CompartmentImages.at(0)->SetPixel(index, pix);
               SimulateExtraAxonalSignal(index, volume_fraction_point, 0, g);
             }
           }
           else
           {
             // manually defined axon radius and voxel overflow --> rescale to voxel volume
             if ( m_Parameters.m_SignalGen.m_AxonRadius>=0.0001 && iAxVolume>m_VoxelVolume )
             {
               for (int i=0; i<numFiberCompartments; ++i)
               {
                 DoubleDwiType::PixelType pix = m_CompartmentImages.at(i)->GetPixel(index);
                 pix[g] *= m_VoxelVolume/iAxVolume;
                 m_CompartmentImages.at(i)->SetPixel(index, pix);
               }
               iAxVolume = m_VoxelVolume;
             }
 
             // if volume fraction image is set use it, otherwise use global scaling factor
             double density_correction_voxel = density_correctiony_global;
             if ( m_Parameters.m_FiberModelList[0]->GetVolumeFractionImage()!=nullptr && iAxVolume>0.0001 )
             {
               m_DoubleInterpolator->SetInputImage(m_Parameters.m_FiberModelList[0]->GetVolumeFractionImage());
               double volume_fraction = mitk::imv::GetImageValue<double>(volume_fraction_point, true, m_DoubleInterpolator);
               if (volume_fraction<0)
                 mitkThrow() << "Volume fraction image (index 1) contains negative values (intra-axonal compartment)!";
               density_correction_voxel = m_VoxelVolume*volume_fraction/iAxVolume; // remove iAxVolume sclaing and scale to volume_fraction
             }
             else if (m_Parameters.m_FiberModelList[0]->GetVolumeFractionImage()!=nullptr)
               density_correction_voxel = 0.0;
 
             // adjust intra-axonal compartment volume by density correction factor
             DoubleDwiType::PixelType pix = m_CompartmentImages.at(0)->GetPixel(index);
             pix[g] *= density_correction_voxel;
             m_CompartmentImages.at(0)->SetPixel(index, pix);
 
             // normalize remaining fiber volume fractions (they are rescaled in SimulateExtraAxonalSignal)
             if (iAxVolume>0.0001)
             {
               for (int i=1; i<numFiberCompartments; i++)
               {
                 DoubleDwiType::PixelType pix = m_CompartmentImages.at(i)->GetPixel(index);
                 pix[g] /= iAxVolume;
                 m_CompartmentImages.at(i)->SetPixel(index, pix);
               }
             }
             else
             {
               for (int i=1; i<numFiberCompartments; i++)
               {
                 DoubleDwiType::PixelType pix = m_CompartmentImages.at(i)->GetPixel(index);
                 pix[g] = 0;
                 m_CompartmentImages.at(i)->SetPixel(index, pix);
               }
             }
 
             iAxVolume = density_correction_voxel*iAxVolume; // new intra-axonal volume = old intra-axonal volume * correction factor
 
             // simulate other compartments
             SimulateExtraAxonalSignal(index, volume_fraction_point, iAxVolume, g);
           }
         }
         ++it3;
       }
     }
 
     PrintToLog("\n", false);
   }
 
   if (this->GetAbortGenerateData())
   {
     PrintToLog("\n", false, false);
     PrintToLog("Simulation aborted");
     return;
   }
 
   DoubleDwiType::Pointer doubleOutImage;
   double signalScale = m_Parameters.m_SignalGen.m_SignalScale;
   if ( m_Parameters.m_SignalGen.m_SimulateKspaceAcquisition ) // do k-space stuff
   {
     PrintToLog("\n", false, false);
     PrintToLog("Simulating k-space acquisition using "
                +boost::lexical_cast<std::string>(m_Parameters.m_SignalGen.m_NumberOfCoils)
                +" coil(s)");
 
     switch (m_Parameters.m_SignalGen.m_AcquisitionType)
     {
     case SignalGenerationParameters::SingleShotEpi:
     {
       PrintToLog("Acquisition type: single shot EPI", false);
       break;
     }
     case SignalGenerationParameters::SpinEcho:
     {
       PrintToLog("Acquisition type: classic spin echo with cartesian k-space trajectory", false);
       break;
     }
     default:
     {
       PrintToLog("Acquisition type: single shot EPI", false);
       break;
     }
     }
 
     if (m_Parameters.m_SignalGen.m_NoiseVariance>0 && m_Parameters.m_Misc.m_CheckAddNoiseBox)
       PrintToLog("Simulating complex Gaussian noise", false);
     if (m_Parameters.m_SignalGen.m_DoSimulateRelaxation)
       PrintToLog("Simulating signal relaxation", false);
     if (m_Parameters.m_SignalGen.m_FrequencyMap.IsNotNull())
       PrintToLog("Simulating distortions", false);
     if (m_Parameters.m_SignalGen.m_DoAddGibbsRinging)
       PrintToLog("Simulating ringing artifacts", false);
     if (m_Parameters.m_SignalGen.m_EddyStrength>0)
       PrintToLog("Simulating eddy currents", false);
     if (m_Parameters.m_SignalGen.m_Spikes>0)
       PrintToLog("Simulating spikes", false);
     if (m_Parameters.m_SignalGen.m_CroppingFactor<1.0)
       PrintToLog("Simulating aliasing artifacts", false);
     if (m_Parameters.m_SignalGen.m_KspaceLineOffset>0)
       PrintToLog("Simulating ghosts", false);
 
     doubleOutImage = SimulateKspaceAcquisition(m_CompartmentImages);
     signalScale = 1; // already scaled in SimulateKspaceAcquisition()
   }
   else    // don't do k-space stuff, just sum compartments
   {
     PrintToLog("Summing compartments");
     doubleOutImage = m_CompartmentImages.at(0);
 
     for (unsigned int i=1; i<m_CompartmentImages.size(); i++)
     {
       auto adder = itk::AddImageFilter< DoubleDwiType, DoubleDwiType, DoubleDwiType>::New();
       adder->SetInput1(doubleOutImage);
       adder->SetInput2(m_CompartmentImages.at(i));
       adder->Update();
       doubleOutImage = adder->GetOutput();
     }
   }
   if (this->GetAbortGenerateData())
   {
     PrintToLog("\n", false, false);
     PrintToLog("Simulation aborted");
     return;
   }
 
   PrintToLog("Finalizing image");
   if (signalScale>1)
     PrintToLog(" Scaling signal", false);
   if (m_Parameters.m_NoiseModel)
     PrintToLog(" Adding noise", false);
   unsigned int window = 0;
   unsigned int min = itk::NumericTraits<unsigned int>::max();
   ImageRegionIterator<OutputImageType> it4 (m_OutputImage, m_OutputImage->GetLargestPossibleRegion());
   DoubleDwiType::PixelType signal; signal.SetSize(m_Parameters.m_SignalGen.GetNumVolumes());
   boost::progress_display disp2(m_OutputImage->GetLargestPossibleRegion().GetNumberOfPixels());
 
   PrintToLog("0%   10   20   30   40   50   60   70   80   90   100%", false, true, false);
   PrintToLog("|----|----|----|----|----|----|----|----|----|----|\n*", false, false, false);
   int lastTick = 0;
 
   while(!it4.IsAtEnd())
   {
     if (this->GetAbortGenerateData())
     {
       PrintToLog("\n", false, false);
       PrintToLog("Simulation aborted");
       return;
     }
 
     ++disp2;
     unsigned long newTick = 50*disp2.count()/disp2.expected_count();
     for (unsigned long tick = 0; tick<(newTick-lastTick); tick++)
       PrintToLog("*", false, false, false);
     lastTick = newTick;
 
     typename OutputImageType::IndexType index = it4.GetIndex();
     signal = doubleOutImage->GetPixel(index)*signalScale;
 
     if (m_Parameters.m_NoiseModel)
       m_Parameters.m_NoiseModel->AddNoise(signal);
 
     for (unsigned int i=0; i<signal.Size(); i++)
     {
       if (signal[i]>0)
         signal[i] = floor(signal[i]+0.5);
       else
         signal[i] = ceil(signal[i]-0.5);
 
       if ( (!m_Parameters.m_SignalGen.IsBaselineIndex(i) || signal.Size()==1) && signal[i]>window)
         window = signal[i];
       if ( (!m_Parameters.m_SignalGen.IsBaselineIndex(i) || signal.Size()==1) && signal[i]<min)
         min = signal[i];
     }
     it4.Set(signal);
     ++it4;
   }
   window -= min;
   unsigned int level = window/2 + min;
   m_LevelWindow.SetLevelWindow(level, window);
   this->SetNthOutput(0, m_OutputImage);
 
   PrintToLog("\n", false);
   PrintToLog("Finished simulation");
   m_TimeProbe.Stop();
 
   if (m_Parameters.m_SignalGen.m_DoAddMotion)
   {
     PrintToLog("\nHead motion log:", false);
     PrintToLog(m_MotionLog, false, false);
   }
 
   if (m_Parameters.m_SignalGen.m_Spikes>0)
   {
     PrintToLog("\nSpike log:", false);
     PrintToLog(m_SpikeLog, false, false);
   }
 
   if (m_Logfile.is_open()) m_Logfile.close();
 }
 
 
 template< class PixelType >
 void TractsToDWIImageFilter< PixelType >::PrintToLog(std::string m, bool addTime, bool linebreak, bool stdOut)
 {
   // timestamp
   if (addTime)
   {
     m_Logfile << this->GetTime() << " > ";
     m_StatusText += this->GetTime() + " > ";
     if (stdOut)
       std::cout << this->GetTime() << " > ";
   }
 
   // message
   if (m_Logfile.is_open())
     m_Logfile << m;
   m_StatusText += m;
   if (stdOut)
     std::cout << m;
 
   // new line
   if (linebreak)
   {
     if (m_Logfile.is_open())
       m_Logfile << "\n";
     m_StatusText += "\n";
     if (stdOut)
       std::cout << "\n";
   }
 }
 
 template< class PixelType >
 void TractsToDWIImageFilter< PixelType >::SimulateMotion(int g)
 {
   // is motion artifact enabled?
   // is the current volume g affected by motion?
   if ( m_Parameters.m_SignalGen.m_DoAddMotion
        && m_Parameters.m_SignalGen.m_MotionVolumes[g]
        && g<static_cast<int>(m_Parameters.m_SignalGen.GetNumVolumes()) )
   {
     if ( m_Parameters.m_SignalGen.m_DoRandomizeMotion )
     {
       // either undo last transform or work on fresh copy of untransformed fibers
       m_FiberBundleTransformed = m_FiberBundleWorkingCopy->GetDeepCopy();
 
       m_Rotation[0] = m_RandGen->GetVariateWithClosedRange(m_Parameters.m_SignalGen.m_Rotation[0]*2)
           -m_Parameters.m_SignalGen.m_Rotation[0];
       m_Rotation[1] = m_RandGen->GetVariateWithClosedRange(m_Parameters.m_SignalGen.m_Rotation[1]*2)
           -m_Parameters.m_SignalGen.m_Rotation[1];
       m_Rotation[2] = m_RandGen->GetVariateWithClosedRange(m_Parameters.m_SignalGen.m_Rotation[2]*2)
           -m_Parameters.m_SignalGen.m_Rotation[2];
 
       m_Translation[0] = m_RandGen->GetVariateWithClosedRange(m_Parameters.m_SignalGen.m_Translation[0]*2)
           -m_Parameters.m_SignalGen.m_Translation[0];
       m_Translation[1] = m_RandGen->GetVariateWithClosedRange(m_Parameters.m_SignalGen.m_Translation[1]*2)
           -m_Parameters.m_SignalGen.m_Translation[1];
       m_Translation[2] = m_RandGen->GetVariateWithClosedRange(m_Parameters.m_SignalGen.m_Translation[2]*2)
           -m_Parameters.m_SignalGen.m_Translation[2];
     }
     else
     {
       m_Rotation = m_Parameters.m_SignalGen.m_Rotation / m_NumMotionVolumes;
       m_Translation = m_Parameters.m_SignalGen.m_Translation / m_NumMotionVolumes;
       m_MotionCounter++;
     }
 
     // move mask image
     if (m_MaskImageSet)
     {
       ImageRegionIterator<ItkUcharImgType> maskIt(m_UpsampledMaskImage, m_UpsampledMaskImage->GetLargestPossibleRegion());
       m_TransformedMaskImage->FillBuffer(0);
 
       while(!maskIt.IsAtEnd())
       {
         if (maskIt.Get()<=0)
         {
           ++maskIt;
           continue;
         }
 
         DoubleDwiType::IndexType index = maskIt.GetIndex();
         m_TransformedMaskImage->TransformPhysicalPointToIndex(GetMovedPoint(index, true), index);
 
         if (m_TransformedMaskImage->GetLargestPossibleRegion().IsInside(index))
           m_TransformedMaskImage->SetPixel(index,100);
         ++maskIt;
       }
     }
 
     if (m_Parameters.m_SignalGen.m_DoRandomizeMotion)
     {
       m_Rotations.push_back(m_Rotation);
       m_Translations.push_back(m_Translation);
 
       m_MotionLog += boost::lexical_cast<std::string>(g) + " rotation: " + boost::lexical_cast<std::string>(m_Rotation[0])
           + "," + boost::lexical_cast<std::string>(m_Rotation[1])
           + "," + boost::lexical_cast<std::string>(m_Rotation[2]) + ";";
 
       m_MotionLog += " translation: " + boost::lexical_cast<std::string>(m_Translation[0])
           + "," + boost::lexical_cast<std::string>(m_Translation[1])
           + "," + boost::lexical_cast<std::string>(m_Translation[2]) + "\n";
     }
     else
     {
       m_Rotations.push_back(m_Rotation*m_MotionCounter);
       m_Translations.push_back(m_Translation*m_MotionCounter);
 
       m_MotionLog += boost::lexical_cast<std::string>(g) + " rotation: " + boost::lexical_cast<std::string>(m_Rotation[0]*m_MotionCounter)
           + "," + boost::lexical_cast<std::string>(m_Rotation[1]*m_MotionCounter)
           + "," + boost::lexical_cast<std::string>(m_Rotation[2]*m_MotionCounter) + ";";
 
       m_MotionLog += " translation: " + boost::lexical_cast<std::string>(m_Translation[0]*m_MotionCounter)
           + "," + boost::lexical_cast<std::string>(m_Translation[1]*m_MotionCounter)
           + "," + boost::lexical_cast<std::string>(m_Translation[2]*m_MotionCounter) + "\n";
     }
 
     m_FiberBundleTransformed->TransformFibers(m_Rotation[0],m_Rotation[1],m_Rotation[2],m_Translation[0],m_Translation[1],m_Translation[2]);
   }
   else
   {
     m_Rotation.Fill(0.0);
     m_Translation.Fill(0.0);
     m_Rotations.push_back(m_Rotation);
     m_Translations.push_back(m_Translation);
 
     m_MotionLog += boost::lexical_cast<std::string>(g) + " rotation: " + boost::lexical_cast<std::string>(m_Rotation[0])
         + "," + boost::lexical_cast<std::string>(m_Rotation[1])
         + "," + boost::lexical_cast<std::string>(m_Rotation[2]) + ";";
 
     m_MotionLog += " translation: " + boost::lexical_cast<std::string>(m_Translation[0])
         + "," + boost::lexical_cast<std::string>(m_Translation[1])
         + "," + boost::lexical_cast<std::string>(m_Translation[2]) + "\n";
   }
 }
 
 template< class PixelType >
 itk::Point<double, 3> TractsToDWIImageFilter< PixelType >::GetMovedPoint(itk::Index<3>& index, bool forward)
 {
   itk::Point<double, 3> transformed_point;
   if (forward)
   {
     m_UpsampledMaskImage->TransformIndexToPhysicalPoint(index, transformed_point);
     if (m_Parameters.m_SignalGen.m_DoRandomizeMotion)
     {
       transformed_point = m_FiberBundleWorkingCopy->TransformPoint(transformed_point.GetVnlVector(),
                                                                    m_Rotation[0],m_Rotation[1],m_Rotation[2],
           m_Translation[0],m_Translation[1],m_Translation[2]);
     }
     else
     {
       transformed_point = m_FiberBundleWorkingCopy->TransformPoint(transformed_point.GetVnlVector(),
                                                                    m_Rotation[0]*m_MotionCounter,m_Rotation[1]*m_MotionCounter,m_Rotation[2]*m_MotionCounter,
           m_Translation[0]*m_MotionCounter,m_Translation[1]*m_MotionCounter,m_Translation[2]*m_MotionCounter);
     }
   }
   else
   {
     m_TransformedMaskImage->TransformIndexToPhysicalPoint(index, transformed_point);
     if (m_Parameters.m_SignalGen.m_DoRandomizeMotion)
     {
       transformed_point = m_FiberBundleWorkingCopy->TransformPoint( transformed_point.GetVnlVector(),
                                                                     -m_Rotation[0], -m_Rotation[1], -m_Rotation[2],
           -m_Translation[0], -m_Translation[1], -m_Translation[2] );
     }
     else
     {
       transformed_point = m_FiberBundleWorkingCopy->TransformPoint( transformed_point.GetVnlVector(),
                                                                     -m_Rotation[0]*m_MotionCounter, -m_Rotation[1]*m_MotionCounter, -m_Rotation[2]*m_MotionCounter,
           -m_Translation[0]*m_MotionCounter, -m_Translation[1]*m_MotionCounter, -m_Translation[2]*m_MotionCounter );
     }
   }
   return transformed_point;
 }
 
 template< class PixelType >
 void TractsToDWIImageFilter< PixelType >::
 SimulateExtraAxonalSignal(ItkUcharImgType::IndexType& index, itk::Point<double, 3>& volume_fraction_point, double intraAxonalVolume, int g)
 {
   int numFiberCompartments = m_Parameters.m_FiberModelList.size();
   int numNonFiberCompartments = m_Parameters.m_NonFiberModelList.size();
 
   if (m_Parameters.m_SignalGen.m_DoDisablePartialVolume)
   {
     // simulate signal for largest non-fiber compartment
     int max_compartment_index = 0;
     double max_fraction = 0;
     if (numNonFiberCompartments>1)
     {
       for (int i=0; i<numNonFiberCompartments; ++i)
       {
         m_DoubleInterpolator->SetInputImage(m_Parameters.m_NonFiberModelList[i]->GetVolumeFractionImage());
         double compartment_fraction = mitk::imv::GetImageValue<double>(volume_fraction_point, true, m_DoubleInterpolator);
         if (compartment_fraction<0)
           mitkThrow() << "Volume fraction image (index " << i << ") contains values less than zero!";
 
         if (compartment_fraction>max_fraction)
         {
           max_fraction = compartment_fraction;
           max_compartment_index = i;
         }
       }
     }
 
     DoubleDwiType::Pointer doubleDwi = m_CompartmentImages.at(max_compartment_index+numFiberCompartments);
     DoubleDwiType::PixelType pix = doubleDwi->GetPixel(index);
     pix[g] += m_Parameters.m_NonFiberModelList[max_compartment_index]->SimulateMeasurement(g, m_NullDir)*m_VoxelVolume;
     doubleDwi->SetPixel(index, pix);
 
     if (g==0)
       m_VolumeFractions.at(max_compartment_index+numFiberCompartments)->SetPixel(index, 1);
   }
   else
   {
     std::vector< double > fractions;
     if (g==0)
       m_VolumeFractions.at(0)->SetPixel(index, intraAxonalVolume/m_VoxelVolume);
 
     double extraAxonalVolume = m_VoxelVolume-intraAxonalVolume;    // non-fiber volume
     if (extraAxonalVolume<0)
     {
       if (extraAxonalVolume<-0.001)
         MITK_ERROR << "Corrupted intra-axonal signal voxel detected. Fiber volume larger voxel volume! " << m_VoxelVolume << "<" << intraAxonalVolume;
       extraAxonalVolume = 0;
     }
     double interAxonalVolume = 0;
     if (numFiberCompartments>1)
       interAxonalVolume = extraAxonalVolume * intraAxonalVolume/m_VoxelVolume;   // inter-axonal fraction of non fiber compartment
     double nonFiberVolume = extraAxonalVolume - interAxonalVolume;        // rest of compartment
     if (nonFiberVolume<0)
     {
       if (nonFiberVolume<-0.001)
         MITK_ERROR << "Corrupted signal voxel detected. Fiber volume larger voxel volume!";
       nonFiberVolume = 0;
       interAxonalVolume = extraAxonalVolume;
     }
 
     double compartmentSum = intraAxonalVolume;
     fractions.push_back(intraAxonalVolume/m_VoxelVolume);
 
     // rescale extra-axonal fiber signal
     for (int i=1; i<numFiberCompartments; ++i)
     {
       if (m_Parameters.m_FiberModelList[i]->GetVolumeFractionImage()!=nullptr)
       {
         m_DoubleInterpolator->SetInputImage(m_Parameters.m_FiberModelList[i]->GetVolumeFractionImage());
         interAxonalVolume = mitk::imv::GetImageValue<double>(volume_fraction_point, true, m_DoubleInterpolator)*m_VoxelVolume;
         if (interAxonalVolume<0)
           mitkThrow() << "Volume fraction image (index " << i+1 << ") contains negative values!";
       }
 
       DoubleDwiType::PixelType pix = m_CompartmentImages.at(i)->GetPixel(index);
       pix[g] *= interAxonalVolume;
       m_CompartmentImages.at(i)->SetPixel(index, pix);
 
       compartmentSum += interAxonalVolume;
       fractions.push_back(interAxonalVolume/m_VoxelVolume);
       if (g==0)
         m_VolumeFractions.at(i)->SetPixel(index, interAxonalVolume/m_VoxelVolume);
     }
 
     for (int i=0; i<numNonFiberCompartments; ++i)
     {
       double volume = nonFiberVolume;
       if (m_Parameters.m_NonFiberModelList[i]->GetVolumeFractionImage()!=nullptr)
       {
         m_DoubleInterpolator->SetInputImage(m_Parameters.m_NonFiberModelList[i]->GetVolumeFractionImage());
         volume = mitk::imv::GetImageValue<double>(volume_fraction_point, true, m_DoubleInterpolator)*m_VoxelVolume;
         if (volume<0)
           mitkThrow() << "Volume fraction image (index " << numFiberCompartments+i+1 << ") contains negative values (non-fiber compartment)!";
 
         if (m_UseRelativeNonFiberVolumeFractions)
           volume *= nonFiberVolume/m_VoxelVolume;
       }
 
       DoubleDwiType::PixelType pix = m_CompartmentImages.at(i+numFiberCompartments)->GetPixel(index);
       pix[g] += m_Parameters.m_NonFiberModelList[i]->SimulateMeasurement(g, m_NullDir)*volume;
       m_CompartmentImages.at(i+numFiberCompartments)->SetPixel(index, pix);
 
       compartmentSum += volume;
       fractions.push_back(volume/m_VoxelVolume);
       if (g==0)
         m_VolumeFractions.at(i+numFiberCompartments)->SetPixel(index, volume/m_VoxelVolume);
     }
 
     if (compartmentSum/m_VoxelVolume>1.05)
     {
       MITK_ERROR << "Compartments do not sum to 1 in voxel " << index << " (" << compartmentSum/m_VoxelVolume << ")";
       for (auto val : fractions)
         MITK_ERROR << val;
     }
   }
 }
 
 template< class PixelType >
 itk::Point<float, 3> TractsToDWIImageFilter< PixelType >::GetItkPoint(double point[3])
 {
   itk::Point<float, 3> itkPoint;
   itkPoint[0] = point[0];
   itkPoint[1] = point[1];
   itkPoint[2] = point[2];
   return itkPoint;
 }
 
 template< class PixelType >
 itk::Vector<double, 3> TractsToDWIImageFilter< PixelType >::GetItkVector(double point[3])
 {
   itk::Vector<double, 3> itkVector;
   itkVector[0] = point[0];
   itkVector[1] = point[1];
   itkVector[2] = point[2];
   return itkVector;
 }
 
 template< class PixelType >
 vnl_vector_fixed<double, 3> TractsToDWIImageFilter< PixelType >::GetVnlVector(double point[3])
 {
   vnl_vector_fixed<double, 3> vnlVector;
   vnlVector[0] = point[0];
   vnlVector[1] = point[1];
   vnlVector[2] = point[2];
   return vnlVector;
 }
 
 template< class PixelType >
 vnl_vector_fixed<double, 3> TractsToDWIImageFilter< PixelType >::GetVnlVector(Vector<float,3>& vector)
 {
   vnl_vector_fixed<double, 3> vnlVector;
   vnlVector[0] = vector[0];
   vnlVector[1] = vector[1];
   vnlVector[2] = vector[2];
   return vnlVector;
 }
 
 template< class PixelType >
 double TractsToDWIImageFilter< PixelType >::RoundToNearest(double num) {
   return (num > 0.0) ? floor(num + 0.5) : ceil(num - 0.5);
 }
 
 template< class PixelType >
 std::string TractsToDWIImageFilter< PixelType >::GetTime()
 {
   m_TimeProbe.Stop();
   unsigned long total = RoundToNearest(m_TimeProbe.GetTotal());
   unsigned long hours = total/3600;
   unsigned long minutes = (total%3600)/60;
   unsigned long seconds = total%60;
   std::string out = "";
   out.append(boost::lexical_cast<std::string>(hours));
   out.append(":");
   out.append(boost::lexical_cast<std::string>(minutes));
   out.append(":");
   out.append(boost::lexical_cast<std::string>(seconds));
   m_TimeProbe.Start();
   return out;
 }
 
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/IODataStructures/mitkFiberfoxParameters.cpp b/Modules/DiffusionImaging/FiberTracking/IODataStructures/mitkFiberfoxParameters.cpp
index 6f8d0d5246..98beecf072 100644
--- a/Modules/DiffusionImaging/FiberTracking/IODataStructures/mitkFiberfoxParameters.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/IODataStructures/mitkFiberfoxParameters.cpp
@@ -1,985 +1,985 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #define RAPIDXML_NO_EXCEPTIONS
 #include <boost/foreach.hpp>
-#include <boost/lexical_cast.hpp>
+#include <mitkLexicalCast.h>
 #include <itkImageFileWriter.h>
 #include <itkImageFileReader.h>
 #include <mitkLog.h>
 #include <algorithm>
 #include <string>
 #include <mitkFiberfoxParameters.h>
 
 mitk::FiberfoxParameters::FiberfoxParameters()
   : m_NoiseModel(nullptr)
 {
 
 }
 
 mitk::FiberfoxParameters::FiberfoxParameters(const mitk::FiberfoxParameters& params)
   : m_NoiseModel(nullptr)
 {
   m_FiberGen = params.m_FiberGen;
   m_SignalGen = params.m_SignalGen;
   m_Misc = params.m_Misc;
 
   if (params.m_NoiseModel!=nullptr)
   {
     if (dynamic_cast<mitk::RicianNoiseModel<>*>(params.m_NoiseModel.get()))
       m_NoiseModel = std::make_shared< mitk::RicianNoiseModel<> >();
     else if (dynamic_cast<mitk::ChiSquareNoiseModel<>*>(params.m_NoiseModel.get()))
       m_NoiseModel = std::make_shared< mitk::ChiSquareNoiseModel<> >();
     m_NoiseModel->SetNoiseVariance(params.m_NoiseModel->GetNoiseVariance());
   }
 
   for (unsigned int i=0; i<params.m_FiberModelList.size()+params.m_NonFiberModelList.size(); i++)
   {
     mitk::DiffusionSignalModel<>* outModel = nullptr;
     mitk::DiffusionSignalModel<>* signalModel = nullptr;
     if (i<params.m_FiberModelList.size())
       signalModel = params.m_FiberModelList.at(i);
     else
       signalModel = params.m_NonFiberModelList.at(i-params.m_FiberModelList.size());
 
     if (dynamic_cast<mitk::StickModel<>*>(signalModel))
       outModel = new mitk::StickModel<>(dynamic_cast<mitk::StickModel<>*>(signalModel));
     else  if (dynamic_cast<mitk::TensorModel<>*>(signalModel))
       outModel = new mitk::TensorModel<>(dynamic_cast<mitk::TensorModel<>*>(signalModel));
     else  if (dynamic_cast<mitk::RawShModel<>*>(signalModel))
       outModel = new mitk::RawShModel<>(dynamic_cast<mitk::RawShModel<>*>(signalModel));
     else  if (dynamic_cast<mitk::BallModel<>*>(signalModel))
       outModel = new mitk::BallModel<>(dynamic_cast<mitk::BallModel<>*>(signalModel));
     else if (dynamic_cast<mitk::AstroStickModel<>*>(signalModel))
       outModel = new mitk::AstroStickModel<>(dynamic_cast<mitk::AstroStickModel<>*>(signalModel));
     else  if (dynamic_cast<mitk::DotModel<>*>(signalModel))
       outModel = new mitk::DotModel<>(dynamic_cast<mitk::DotModel<>*>(signalModel));
 
     if (i<params.m_FiberModelList.size())
       m_FiberModelList.push_back(outModel);
     else
       m_NonFiberModelList.push_back(outModel);
   }
 }
 
 
 mitk::FiberfoxParameters::~FiberfoxParameters()
 {
 
 }
 
 void mitk::SignalGenerationParameters::GenerateGradientHalfShell()
 {
   int NPoints = 2*m_NumGradients;
   m_GradientDirections.clear();
 
   m_NumBaseline = NPoints/20;
   if (m_NumBaseline==0)
     m_NumBaseline=1;
 
   GradientType g;
   g.Fill(0.0);
   for (unsigned int i=0; i<m_NumBaseline; i++)
     m_GradientDirections.push_back(g);
 
   if (NPoints==0)
     return;
 
   vnl_vector<double> theta; theta.set_size(NPoints);
   vnl_vector<double> phi; phi.set_size(NPoints);
   double C = sqrt(4*itk::Math::pi);
   phi(0) = 0.0;
   phi(NPoints-1) = 0.0;
   for(int i=0; i<NPoints; i++)
   {
     theta(i) = acos(-1.0+2.0*i/(NPoints-1.0)) - itk::Math::pi / 2.0;
     if( i>0 && i<NPoints-1)
     {
       phi(i) = (phi(i-1) + C /
                 sqrt(NPoints*(1-(-1.0+2.0*i/(NPoints-1.0))*(-1.0+2.0*i/(NPoints-1.0)))));
     }
   }
 
   for(int i=0; i<NPoints; i++)
   {
     g[2] = sin(theta(i));
     if (g[2]<0)
       continue;
     g[0] = cos(theta(i)) * cos(phi(i));
     g[1] = cos(theta(i)) * sin(phi(i));
     m_GradientDirections.push_back(g);
   }
 }
 
 std::vector< int > mitk::SignalGenerationParameters::GetBaselineIndices()
 {
   std::vector< int > result;
   for( unsigned int i=0; i<this->m_GradientDirections.size(); i++)
     if (m_GradientDirections.at(i).GetNorm()<0.0001)
       result.push_back(i);
   return result;
 }
 
 unsigned int mitk::SignalGenerationParameters::GetFirstBaselineIndex()
 {
   for( unsigned int i=0; i<this->m_GradientDirections.size(); i++)
     if (m_GradientDirections.at(i).GetNorm()<0.0001)
       return i;
   return -1;
 }
 
 bool mitk::SignalGenerationParameters::IsBaselineIndex(unsigned int idx)
 {
   if (m_GradientDirections.size()>idx && m_GradientDirections.at(idx).GetNorm()<0.0001)
     return true;
   return false;
 }
 
 unsigned int mitk::SignalGenerationParameters::GetNumWeightedVolumes()
 {
   return m_NumGradients;
 }
 
 unsigned int mitk::SignalGenerationParameters::GetNumBaselineVolumes()
 {
   return m_NumBaseline;
 }
 
 unsigned int mitk::SignalGenerationParameters::GetNumVolumes()
 {
   return m_GradientDirections.size();
 }
 
 mitk::SignalGenerationParameters::GradientListType mitk::SignalGenerationParameters::GetGradientDirections()
 {
   return m_GradientDirections;
 }
 
 mitk::SignalGenerationParameters::GradientType mitk::SignalGenerationParameters::GetGradientDirection(unsigned int i)
 {
   return m_GradientDirections.at(i);
 }
 
 void mitk::SignalGenerationParameters::SetNumWeightedVolumes(int numGradients)
 {
   m_NumGradients = numGradients;
   GenerateGradientHalfShell();
 }
 
 std::vector< int > mitk::SignalGenerationParameters::GetBvalues()
 {
   std::vector< int > bVals;
   for( GradientType g : m_GradientDirections)
   {
     float norm = g.GetNorm();
     int bVal = std::round(norm*norm*m_Bvalue);
     if ( std::find(bVals.begin(), bVals.end(), bVal) == bVals.end() )
       bVals.push_back(bVal);
   }
   return bVals;
 }
 
 double mitk::SignalGenerationParameters::GetBvalue()
 {
   return m_Bvalue;
 }
 
 void mitk::SignalGenerationParameters::SetGradienDirections(GradientListType gradientList)
 {
   m_GradientDirections = gradientList;
   m_NumGradients = 0;
   m_NumBaseline = 0;
 
   for( unsigned int i=0; i<this->m_GradientDirections.size(); i++)
   {
     float norm = m_GradientDirections.at(i).GetNorm();
     if (norm>0.0001)
       m_NumGradients++;
     else
       m_NumBaseline++;
   }
 }
 
 void mitk::SignalGenerationParameters::SetGradienDirections(mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::Pointer gradientList)
 {
   m_NumGradients = 0;
   m_NumBaseline = 0;
   m_GradientDirections.clear();
 
   for( unsigned int i=0; i<gradientList->Size(); i++)
   {
     GradientType g;
     g[0] = gradientList->at(i)[0];
     g[1] = gradientList->at(i)[1];
     g[2] = gradientList->at(i)[2];
     m_GradientDirections.push_back(g);
 
     float norm = m_GradientDirections.at(i).GetNorm();
     if (norm>0.0001)
       m_NumGradients++;
     else
       m_NumBaseline++;
   }
 }
 
 
 void mitk::FiberfoxParameters::SaveParameters(std::string filename)
 {
   if(filename.empty())
     return;
   if(".ffp"!=filename.substr(filename.size()-4, 4))
     filename += ".ffp";
 
   const std::string& locale = "C";
   const std::string& currLocale = setlocale( LC_ALL, nullptr );
 
   if ( locale.compare(currLocale)!=0 )
   {
     try
     {
       setlocale(LC_ALL, locale.c_str());
     }
     catch(...)
     {
       MITK_INFO << "Could not set locale " << locale;
     }
   }
 
   boost::property_tree::ptree parameters;
 
   // fiber generation parameters
   parameters.put("fiberfox.fibers.distribution", m_FiberGen.m_Distribution);
   parameters.put("fiberfox.fibers.variance", m_FiberGen.m_Variance);
   parameters.put("fiberfox.fibers.density", m_FiberGen.m_Density);
   parameters.put("fiberfox.fibers.spline.sampling", m_FiberGen.m_Sampling);
   parameters.put("fiberfox.fibers.spline.tension", m_FiberGen.m_Tension);
   parameters.put("fiberfox.fibers.spline.continuity", m_FiberGen.m_Continuity);
   parameters.put("fiberfox.fibers.spline.bias", m_FiberGen.m_Bias);
   parameters.put("fiberfox.fibers.rotation.x", m_FiberGen.m_Rotation[0]);
   parameters.put("fiberfox.fibers.rotation.y", m_FiberGen.m_Rotation[1]);
   parameters.put("fiberfox.fibers.rotation.z", m_FiberGen.m_Rotation[2]);
   parameters.put("fiberfox.fibers.translation.x", m_FiberGen.m_Translation[0]);
   parameters.put("fiberfox.fibers.translation.y", m_FiberGen.m_Translation[1]);
   parameters.put("fiberfox.fibers.translation.z", m_FiberGen.m_Translation[2]);
   parameters.put("fiberfox.fibers.scale.x", m_FiberGen.m_Scale[0]);
   parameters.put("fiberfox.fibers.scale.y", m_FiberGen.m_Scale[1]);
   parameters.put("fiberfox.fibers.scale.z", m_FiberGen.m_Scale[2]);
 
   // image generation parameters
   parameters.put("fiberfox.image.basic.size.x", m_SignalGen.m_ImageRegion.GetSize(0));
   parameters.put("fiberfox.image.basic.size.y", m_SignalGen.m_ImageRegion.GetSize(1));
   parameters.put("fiberfox.image.basic.size.z", m_SignalGen.m_ImageRegion.GetSize(2));
   parameters.put("fiberfox.image.basic.spacing.x", m_SignalGen.m_ImageSpacing[0]);
   parameters.put("fiberfox.image.basic.spacing.y", m_SignalGen.m_ImageSpacing[1]);
   parameters.put("fiberfox.image.basic.spacing.z", m_SignalGen.m_ImageSpacing[2]);
   parameters.put("fiberfox.image.basic.origin.x", m_SignalGen.m_ImageOrigin[0]);
   parameters.put("fiberfox.image.basic.origin.y", m_SignalGen.m_ImageOrigin[1]);
   parameters.put("fiberfox.image.basic.origin.z", m_SignalGen.m_ImageOrigin[2]);
   parameters.put("fiberfox.image.basic.direction.1", m_SignalGen.m_ImageDirection[0][0]);
   parameters.put("fiberfox.image.basic.direction.2", m_SignalGen.m_ImageDirection[0][1]);
   parameters.put("fiberfox.image.basic.direction.3", m_SignalGen.m_ImageDirection[0][2]);
   parameters.put("fiberfox.image.basic.direction.4", m_SignalGen.m_ImageDirection[1][0]);
   parameters.put("fiberfox.image.basic.direction.5", m_SignalGen.m_ImageDirection[1][1]);
   parameters.put("fiberfox.image.basic.direction.6", m_SignalGen.m_ImageDirection[1][2]);
   parameters.put("fiberfox.image.basic.direction.7", m_SignalGen.m_ImageDirection[2][0]);
   parameters.put("fiberfox.image.basic.direction.8", m_SignalGen.m_ImageDirection[2][1]);
   parameters.put("fiberfox.image.basic.direction.9", m_SignalGen.m_ImageDirection[2][2]);
   parameters.put("fiberfox.image.basic.numgradients", m_SignalGen.GetNumWeightedVolumes());
   for( unsigned int i=0; i<this->m_SignalGen.GetNumVolumes(); i++)
   {
     parameters.put("fiberfox.image.gradients."+boost::lexical_cast<std::string>(i)+".x", m_SignalGen.GetGradientDirection(i)[0]);
     parameters.put("fiberfox.image.gradients."+boost::lexical_cast<std::string>(i)+".y", m_SignalGen.GetGradientDirection(i)[1]);
     parameters.put("fiberfox.image.gradients."+boost::lexical_cast<std::string>(i)+".z", m_SignalGen.GetGradientDirection(i)[2]);
   }
 
   parameters.put("fiberfox.image.acquisitiontype", m_SignalGen.m_AcquisitionType);
   parameters.put("fiberfox.image.coilsensitivityprofile", m_SignalGen.m_CoilSensitivityProfile);
   parameters.put("fiberfox.image.numberofcoils", m_SignalGen.m_NumberOfCoils);
   parameters.put("fiberfox.image.reversephase", m_SignalGen.m_ReversePhase);
   parameters.put("fiberfox.image.partialfourier", m_SignalGen.m_PartialFourier);
   parameters.put("fiberfox.image.noisevariance", m_SignalGen.m_NoiseVariance);
   parameters.put("fiberfox.image.trep", m_SignalGen.m_tRep);
   parameters.put("fiberfox.image.signalScale", m_SignalGen.m_SignalScale);
   parameters.put("fiberfox.image.tEcho", m_SignalGen.m_tEcho);
   parameters.put("fiberfox.image.tLine", m_SignalGen.m_tLine);
   parameters.put("fiberfox.image.tInhom", m_SignalGen.m_tInhom);
   parameters.put("fiberfox.image.bvalue", m_SignalGen.m_Bvalue);
   parameters.put("fiberfox.image.simulatekspace", m_SignalGen.m_SimulateKspaceAcquisition);
   parameters.put("fiberfox.image.axonRadius", m_SignalGen.m_AxonRadius);
   parameters.put("fiberfox.image.doSimulateRelaxation", m_SignalGen.m_DoSimulateRelaxation);
   parameters.put("fiberfox.image.doDisablePartialVolume", m_SignalGen.m_DoDisablePartialVolume);
   parameters.put("fiberfox.image.artifacts.spikesnum", m_SignalGen.m_Spikes);
   parameters.put("fiberfox.image.artifacts.spikesscale", m_SignalGen.m_SpikeAmplitude);
   parameters.put("fiberfox.image.artifacts.kspaceLineOffset", m_SignalGen.m_KspaceLineOffset);
   parameters.put("fiberfox.image.artifacts.eddyStrength", m_SignalGen.m_EddyStrength);
   parameters.put("fiberfox.image.artifacts.eddyTau", m_SignalGen.m_Tau);
   parameters.put("fiberfox.image.artifacts.aliasingfactor", m_SignalGen.m_CroppingFactor);
   parameters.put("fiberfox.image.artifacts.addringing", m_SignalGen.m_DoAddGibbsRinging);
   parameters.put("fiberfox.image.artifacts.doAddMotion", m_SignalGen.m_DoAddMotion);
   parameters.put("fiberfox.image.artifacts.randomMotion", m_SignalGen.m_DoRandomizeMotion);
   parameters.put("fiberfox.image.artifacts.translation0", m_SignalGen.m_Translation[0]);
   parameters.put("fiberfox.image.artifacts.translation1", m_SignalGen.m_Translation[1]);
   parameters.put("fiberfox.image.artifacts.translation2", m_SignalGen.m_Translation[2]);
   parameters.put("fiberfox.image.artifacts.rotation0", m_SignalGen.m_Rotation[0]);
   parameters.put("fiberfox.image.artifacts.rotation1", m_SignalGen.m_Rotation[1]);
   parameters.put("fiberfox.image.artifacts.rotation2", m_SignalGen.m_Rotation[2]);
   parameters.put("fiberfox.image.artifacts.motionvolumes", m_Misc.m_MotionVolumesBox);
   parameters.put("fiberfox.image.artifacts.addnoise", m_Misc.m_CheckAddNoiseBox);
   parameters.put("fiberfox.image.artifacts.addghosts", m_Misc.m_CheckAddGhostsBox);
   parameters.put("fiberfox.image.artifacts.addaliasing", m_Misc.m_CheckAddAliasingBox);
   parameters.put("fiberfox.image.artifacts.addspikes", m_Misc.m_CheckAddSpikesBox);
   parameters.put("fiberfox.image.artifacts.addeddycurrents", m_Misc.m_CheckAddEddyCurrentsBox);
   parameters.put("fiberfox.image.artifacts.doAddDistortions", m_Misc.m_CheckAddDistortionsBox);
   parameters.put("fiberfox.image.outputvolumefractions", m_Misc.m_CheckOutputVolumeFractionsBox);
   parameters.put("fiberfox.image.showadvanced", m_Misc.m_CheckAdvancedSignalOptionsBox);
   parameters.put("fiberfox.image.signalmodelstring", m_Misc.m_SignalModelString);
   parameters.put("fiberfox.image.artifactmodelstring", m_Misc.m_ArtifactModelString);
   parameters.put("fiberfox.image.outpath", m_Misc.m_OutputPath);
   parameters.put("fiberfox.fibers.realtime", m_Misc.m_CheckRealTimeFibersBox);
   parameters.put("fiberfox.fibers.showadvanced", m_Misc.m_CheckAdvancedFiberOptionsBox);
   parameters.put("fiberfox.fibers.constantradius", m_Misc.m_CheckConstantRadiusBox);
   parameters.put("fiberfox.fibers.includeFiducials", m_Misc.m_CheckIncludeFiducialsBox);
 
   if (m_NoiseModel!=nullptr)
   {
     parameters.put("fiberfox.image.artifacts.noisevariance", m_NoiseModel->GetNoiseVariance());
     if (dynamic_cast<mitk::RicianNoiseModel<>*>(m_NoiseModel.get()))
       parameters.put("fiberfox.image.artifacts.noisetype", "rice");
     else if (dynamic_cast<mitk::ChiSquareNoiseModel<>*>(m_NoiseModel.get()))
       parameters.put("fiberfox.image.artifacts.noisetype", "chisquare");
   }
 
   for (std::size_t i=0; i<m_FiberModelList.size()+m_NonFiberModelList.size(); i++)
   {
     mitk::DiffusionSignalModel<>* signalModel = nullptr;
     if (i<m_FiberModelList.size())
     {
       signalModel = m_FiberModelList.at(i);
       parameters.put("fiberfox.image.compartments."+boost::lexical_cast<std::string>(i)+".type", "fiber");
     }
     else
     {
       signalModel = m_NonFiberModelList.at(i-m_FiberModelList.size());
       parameters.put("fiberfox.image.compartments."+boost::lexical_cast<std::string>(i)+".type", "non-fiber");
     }
 
     if (dynamic_cast<mitk::StickModel<>*>(signalModel))
     {
       mitk::StickModel<>* model = dynamic_cast<mitk::StickModel<>*>(signalModel);
       parameters.put("fiberfox.image.compartments."+boost::lexical_cast<std::string>(i)+".model", "stick");
       parameters.put("fiberfox.image.compartments."+boost::lexical_cast<std::string>(i)+".d", model->GetDiffusivity());
       parameters.put("fiberfox.image.compartments."+boost::lexical_cast<std::string>(i)+".t2", model->GetT2());
       parameters.put("fiberfox.image.compartments."+boost::lexical_cast<std::string>(i)+".t1", model->GetT1());
     }
     else  if (dynamic_cast<mitk::TensorModel<>*>(signalModel))
     {
       mitk::TensorModel<>* model = dynamic_cast<mitk::TensorModel<>*>(signalModel);
       parameters.put("fiberfox.image.compartments."+boost::lexical_cast<std::string>(i)+".model", "tensor");
       parameters.put("fiberfox.image.compartments."+boost::lexical_cast<std::string>(i)+".d1", model->GetDiffusivity1());
       parameters.put("fiberfox.image.compartments."+boost::lexical_cast<std::string>(i)+".d2", model->GetDiffusivity2());
       parameters.put("fiberfox.image.compartments."+boost::lexical_cast<std::string>(i)+".d3", model->GetDiffusivity3());
       parameters.put("fiberfox.image.compartments."+boost::lexical_cast<std::string>(i)+".t2", model->GetT2());
       parameters.put("fiberfox.image.compartments."+boost::lexical_cast<std::string>(i)+".t1", model->GetT1());
     }
     else  if (dynamic_cast<mitk::RawShModel<>*>(signalModel))
     {
       mitk::RawShModel<>* model = dynamic_cast<mitk::RawShModel<>*>(signalModel);
       parameters.put("fiberfox.image.compartments."+boost::lexical_cast<std::string>(i)+".model", "prototype");
       parameters.put("fiberfox.image.compartments."+boost::lexical_cast<std::string>(i)+".minFA", model->GetFaRange().first);
       parameters.put("fiberfox.image.compartments."+boost::lexical_cast<std::string>(i)+".maxFA", model->GetFaRange().second);
       parameters.put("fiberfox.image.compartments."+boost::lexical_cast<std::string>(i)+".minADC", model->GetAdcRange().first);
       parameters.put("fiberfox.image.compartments."+boost::lexical_cast<std::string>(i)+".maxADC", model->GetAdcRange().second);
       parameters.put("fiberfox.image.compartments."+boost::lexical_cast<std::string>(i)+".maxNumSamples", model->GetMaxNumKernels());
       parameters.put("fiberfox.image.compartments."+boost::lexical_cast<std::string>(i)+".numSamples", model->GetNumberOfKernels());
       int shOrder = model->GetShOrder();
       parameters.put("fiberfox.image.compartments."+boost::lexical_cast<std::string>(i)+".numCoeffs", (shOrder*shOrder + shOrder + 2)/2 + shOrder);
 
       for (unsigned int j=0; j<model->GetNumberOfKernels(); j++)
       {
         vnl_vector< double > coeffs = model->GetCoefficients(j);
         for (unsigned int k=0; k<coeffs.size(); k++)
           parameters.put("fiberfox.image.compartments."+boost::lexical_cast<std::string>(i)+".kernels."+boost::lexical_cast<std::string>(j)+".coeffs."+boost::lexical_cast<std::string>(k), coeffs[k]);
         parameters.put("fiberfox.image.compartments."+boost::lexical_cast<std::string>(i)+".kernels."+boost::lexical_cast<std::string>(j)+".B0", model->GetBaselineSignal(j));
       }
     }
     else  if (dynamic_cast<mitk::BallModel<>*>(signalModel))
     {
       mitk::BallModel<>* model = dynamic_cast<mitk::BallModel<>*>(signalModel);
       parameters.put("fiberfox.image.compartments."+boost::lexical_cast<std::string>(i)+".model", "ball");
       parameters.put("fiberfox.image.compartments."+boost::lexical_cast<std::string>(i)+".d", model->GetDiffusivity());
       parameters.put("fiberfox.image.compartments."+boost::lexical_cast<std::string>(i)+".t2", model->GetT2());
       parameters.put("fiberfox.image.compartments."+boost::lexical_cast<std::string>(i)+".t1", model->GetT1());
     }
     else  if (dynamic_cast<mitk::AstroStickModel<>*>(signalModel))
     {
       mitk::AstroStickModel<>* model = dynamic_cast<mitk::AstroStickModel<>*>(signalModel);
       parameters.put("fiberfox.image.compartments."+boost::lexical_cast<std::string>(i)+".model", "astrosticks");
       parameters.put("fiberfox.image.compartments."+boost::lexical_cast<std::string>(i)+".d", model->GetDiffusivity());
       parameters.put("fiberfox.image.compartments."+boost::lexical_cast<std::string>(i)+".t2", model->GetT2());
       parameters.put("fiberfox.image.compartments."+boost::lexical_cast<std::string>(i)+".t1", model->GetT1());
       parameters.put("fiberfox.image.compartments."+boost::lexical_cast<std::string>(i)+".randomize", model->GetRandomizeSticks());
     }
     else  if (dynamic_cast<mitk::DotModel<>*>(signalModel))
     {
       mitk::DotModel<>* model = dynamic_cast<mitk::DotModel<>*>(signalModel);
       parameters.put("fiberfox.image.compartments."+boost::lexical_cast<std::string>(i)+".model", "dot");
       parameters.put("fiberfox.image.compartments."+boost::lexical_cast<std::string>(i)+".t2", model->GetT2());
       parameters.put("fiberfox.image.compartments."+boost::lexical_cast<std::string>(i)+".t1", model->GetT1());
     }
 
     if (signalModel!=nullptr)
     {
       parameters.put("fiberfox.image.compartments."+boost::lexical_cast<std::string>(i)+".ID", signalModel->m_CompartmentId);
 
       if (signalModel->GetVolumeFractionImage().IsNotNull())
       {
         try{
           itk::ImageFileWriter<ItkDoubleImgType>::Pointer writer = itk::ImageFileWriter<ItkDoubleImgType>::New();
           writer->SetFileName(filename+"_VOLUME"+boost::lexical_cast<std::string>(signalModel->m_CompartmentId)+".nii.gz");
           writer->SetInput(signalModel->GetVolumeFractionImage());
           writer->Update();
           MITK_INFO << "Volume fraction image for compartment "+boost::lexical_cast<std::string>(signalModel->m_CompartmentId)+" saved.";
         }
         catch(...)
         {
         }
       }
     }
   }
 
   boost::property_tree::xml_writer_settings<std::string> writerSettings(' ', 2);
   boost::property_tree::xml_parser::write_xml(filename, parameters, std::locale(), writerSettings);
 
   try{
     itk::ImageFileWriter<ItkFloatImgType>::Pointer writer = itk::ImageFileWriter<ItkFloatImgType>::New();
     writer->SetFileName(filename+"_FMAP.nii.gz");
     writer->SetInput(m_SignalGen.m_FrequencyMap);
     writer->Update();
   }
   catch(...)
   {
     MITK_INFO << "No frequency map saved.";
   }
   try{
     itk::ImageFileWriter<ItkUcharImgType>::Pointer writer = itk::ImageFileWriter<ItkUcharImgType>::New();
     writer->SetFileName(filename+"_MASK.nii.gz");
     writer->SetInput(m_SignalGen.m_MaskImage);
     writer->Update();
   }
   catch(...)
   {
     MITK_INFO << "No mask image saved.";
   }
 
   setlocale(LC_ALL, currLocale.c_str());
 }
 
 
 
 template< class ParameterType >
 ParameterType mitk::FiberfoxParameters::ReadVal(boost::property_tree::ptree::value_type const& v, std::string tag, ParameterType defaultValue, bool essential)
 {
   try
   {
     return v.second.get<ParameterType>(tag);
   }
   catch (...)
   {
     if (essential)
     {
       mitkThrow() << "Parameter file corrupted. Essential tag is missing: '" << tag << "'";
     }
     if (tag!="artifacts.noisetype")
     {
       MITK_INFO << "Tag '" << tag << "' not found. Using default value '" << defaultValue << "'.";
       m_MissingTags += "\n- ";
       m_MissingTags += tag;
     }
     return defaultValue;
   }
 }
 
 void mitk::FiberfoxParameters::UpdateSignalModels()
 {
   for (mitk::DiffusionSignalModel<>* m : m_FiberModelList)
   {
     m->SetGradientList(m_SignalGen.m_GradientDirections);
     m->SetBvalue(m_SignalGen.m_Bvalue);
   }
   for (mitk::DiffusionSignalModel<>* m : m_NonFiberModelList)
   {
     m->SetGradientList(m_SignalGen.m_GradientDirections);
     m->SetBvalue(m_SignalGen.m_Bvalue);
   }
 }
 
 void mitk::FiberfoxParameters::SetNumWeightedVolumes(int numGradients)
 {
   m_SignalGen.SetNumWeightedVolumes(numGradients);
   UpdateSignalModels();
 }
 
 void mitk::FiberfoxParameters::SetGradienDirections(mitk::SignalGenerationParameters::GradientListType gradientList)
 {
   m_SignalGen.SetGradienDirections(gradientList);
   UpdateSignalModels();
 }
 
 void mitk::FiberfoxParameters::SetGradienDirections(mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::Pointer gradientList)
 {
   m_SignalGen.SetGradienDirections(gradientList);
   UpdateSignalModels();
 }
 
 void mitk::FiberfoxParameters::SetBvalue(double Bvalue)
 {
   m_SignalGen.m_Bvalue = Bvalue;
   UpdateSignalModels();
 }
 
 void mitk::FiberfoxParameters::GenerateGradientHalfShell()
 {
   m_SignalGen.GenerateGradientHalfShell();
   UpdateSignalModels();
 }
 
 void mitk::FiberfoxParameters::LoadParameters(std::string filename)
 {
   m_MissingTags = "";
   if(filename.empty()) { return; }
 
   const std::string& locale = "C";
   const std::string& currLocale = setlocale( LC_ALL, nullptr );
 
   if ( locale.compare(currLocale)!=0 )
   {
     try
     {
       setlocale(LC_ALL, locale.c_str());
     }
     catch(...)
     {
       MITK_INFO << "Could not set locale " << locale;
     }
   }
 
 
   boost::property_tree::ptree parameterTree;
   boost::property_tree::xml_parser::read_xml( filename, parameterTree );
 
 
   m_FiberModelList.clear();
   m_NonFiberModelList.clear();
   if (m_NoiseModel) { m_NoiseModel = nullptr; }
 
   BOOST_FOREACH( boost::property_tree::ptree::value_type const& v1, parameterTree.get_child("fiberfox") )
   {
     if( v1.first == "fibers" )
     {
       m_Misc.m_CheckRealTimeFibersBox = ReadVal<bool>(v1,"realtime", m_Misc.m_CheckRealTimeFibersBox);
       m_Misc.m_CheckAdvancedFiberOptionsBox = ReadVal<bool>(v1,"showadvanced", m_Misc.m_CheckAdvancedFiberOptionsBox);
       m_Misc.m_CheckConstantRadiusBox = ReadVal<bool>(v1,"constantradius", m_Misc.m_CheckConstantRadiusBox);
       m_Misc.m_CheckIncludeFiducialsBox = ReadVal<bool>(v1,"includeFiducials", m_Misc.m_CheckIncludeFiducialsBox);
 
       switch (ReadVal<unsigned int>(v1,"distribution", 0))
       {
       case 0:
         m_FiberGen.m_Distribution = FiberGenerationParameters::DISTRIBUTE_UNIFORM;
         break;
       case 1:
         m_FiberGen.m_Distribution = FiberGenerationParameters::DISTRIBUTE_GAUSSIAN;
         break;
       default:
         m_FiberGen.m_Distribution = FiberGenerationParameters::DISTRIBUTE_UNIFORM;
       }
       m_FiberGen.m_Variance = ReadVal<double>(v1,"variance", m_FiberGen.m_Variance);
       m_FiberGen.m_Density = ReadVal<unsigned int>(v1,"density", m_FiberGen.m_Density);
       m_FiberGen.m_Sampling = ReadVal<double>(v1,"spline.sampling", m_FiberGen.m_Sampling);
       m_FiberGen.m_Tension = ReadVal<double>(v1,"spline.tension", m_FiberGen.m_Tension);
       m_FiberGen.m_Continuity = ReadVal<double>(v1,"spline.continuity", m_FiberGen.m_Continuity);
       m_FiberGen.m_Bias = ReadVal<double>(v1,"spline.bias", m_FiberGen.m_Bias);
       m_FiberGen.m_Rotation[0] = ReadVal<double>(v1,"rotation.x", m_FiberGen.m_Rotation[0]);
       m_FiberGen.m_Rotation[1] = ReadVal<double>(v1,"rotation.y", m_FiberGen.m_Rotation[1]);
       m_FiberGen.m_Rotation[2] = ReadVal<double>(v1,"rotation.z", m_FiberGen.m_Rotation[2]);
       m_FiberGen.m_Translation[0] = ReadVal<double>(v1,"translation.x", m_FiberGen.m_Translation[0]);
       m_FiberGen.m_Translation[1] = ReadVal<double>(v1,"translation.y", m_FiberGen.m_Translation[1]);
       m_FiberGen.m_Translation[2] = ReadVal<double>(v1,"translation.z", m_FiberGen.m_Translation[2]);
       m_FiberGen.m_Scale[0] = ReadVal<double>(v1,"scale.x", m_FiberGen.m_Scale[0]);
       m_FiberGen.m_Scale[1] = ReadVal<double>(v1,"scale.y", m_FiberGen.m_Scale[1]);
       m_FiberGen.m_Scale[2] = ReadVal<double>(v1,"scale.z", m_FiberGen.m_Scale[2]);
     }
     else if ( v1.first == "image" )
     {
       m_Misc.m_SignalModelString = ReadVal<std::string>(v1,"signalmodelstring", m_Misc.m_SignalModelString);
       m_Misc.m_ArtifactModelString = ReadVal<std::string>(v1,"artifactmodelstring", m_Misc.m_ArtifactModelString);
       m_Misc.m_OutputPath = ReadVal<std::string>(v1,"outpath", m_Misc.m_OutputPath);
       m_Misc.m_CheckOutputVolumeFractionsBox = ReadVal<bool>(v1,"outputvolumefractions", m_Misc.m_CheckOutputVolumeFractionsBox);
       m_Misc.m_CheckAdvancedSignalOptionsBox = ReadVal<bool>(v1,"showadvanced", m_Misc.m_CheckAdvancedSignalOptionsBox);
       m_Misc.m_CheckAddDistortionsBox = ReadVal<bool>(v1,"artifacts.doAddDistortions", m_Misc.m_CheckAddDistortionsBox);
       m_Misc.m_CheckAddNoiseBox = ReadVal<bool>(v1,"artifacts.addnoise", m_Misc.m_CheckAddNoiseBox);
       m_Misc.m_CheckAddGhostsBox = ReadVal<bool>(v1,"artifacts.addghosts", m_Misc.m_CheckAddGhostsBox);
       m_Misc.m_CheckAddAliasingBox = ReadVal<bool>(v1,"artifacts.addaliasing", m_Misc.m_CheckAddAliasingBox);
       m_Misc.m_CheckAddSpikesBox = ReadVal<bool>(v1,"artifacts.addspikes", m_Misc.m_CheckAddSpikesBox);
       m_Misc.m_CheckAddEddyCurrentsBox = ReadVal<bool>(v1,"artifacts.addeddycurrents", m_Misc.m_CheckAddEddyCurrentsBox);
 
       m_SignalGen.m_ImageRegion.SetSize(0, ReadVal<int>(v1,"basic.size.x",m_SignalGen.m_ImageRegion.GetSize(0)));
       m_SignalGen.m_ImageRegion.SetSize(1, ReadVal<int>(v1,"basic.size.y",m_SignalGen.m_ImageRegion.GetSize(1)));
       m_SignalGen.m_ImageRegion.SetSize(2, ReadVal<int>(v1,"basic.size.z",m_SignalGen.m_ImageRegion.GetSize(2)));
       m_SignalGen.m_ImageSpacing[0] = ReadVal<float>(v1,"basic.spacing.x",m_SignalGen.m_ImageSpacing[0]);
       m_SignalGen.m_ImageSpacing[1] = ReadVal<float>(v1,"basic.spacing.y",m_SignalGen.m_ImageSpacing[1]);
       m_SignalGen.m_ImageSpacing[2] = ReadVal<float>(v1,"basic.spacing.z",m_SignalGen.m_ImageSpacing[2]);
       m_SignalGen.m_ImageOrigin[0] = ReadVal<float>(v1,"basic.origin.x",m_SignalGen.m_ImageOrigin[0]);
       m_SignalGen.m_ImageOrigin[1] = ReadVal<float>(v1,"basic.origin.y",m_SignalGen.m_ImageOrigin[1]);
       m_SignalGen.m_ImageOrigin[2] = ReadVal<float>(v1,"basic.origin.z",m_SignalGen.m_ImageOrigin[2]);
       m_SignalGen.m_ImageDirection[0][0] = ReadVal<float>(v1,"basic.direction.1",m_SignalGen.m_ImageDirection[0][0]);
       m_SignalGen.m_ImageDirection[0][1] = ReadVal<float>(v1,"basic.direction.2",m_SignalGen.m_ImageDirection[0][1]);
       m_SignalGen.m_ImageDirection[0][2] = ReadVal<float>(v1,"basic.direction.3",m_SignalGen.m_ImageDirection[0][2]);
       m_SignalGen.m_ImageDirection[1][0] = ReadVal<float>(v1,"basic.direction.4",m_SignalGen.m_ImageDirection[1][0]);
       m_SignalGen.m_ImageDirection[1][1] = ReadVal<float>(v1,"basic.direction.5",m_SignalGen.m_ImageDirection[1][1]);
       m_SignalGen.m_ImageDirection[1][2] = ReadVal<float>(v1,"basic.direction.6",m_SignalGen.m_ImageDirection[1][2]);
       m_SignalGen.m_ImageDirection[2][0] = ReadVal<float>(v1,"basic.direction.7",m_SignalGen.m_ImageDirection[2][0]);
       m_SignalGen.m_ImageDirection[2][1] = ReadVal<float>(v1,"basic.direction.8",m_SignalGen.m_ImageDirection[2][1]);
       m_SignalGen.m_ImageDirection[2][2] = ReadVal<float>(v1,"basic.direction.9",m_SignalGen.m_ImageDirection[2][2]);
 
       m_SignalGen.m_AcquisitionType = (SignalGenerationParameters::AcquisitionType)
                                       ReadVal<int>(v1,"acquisitiontype", m_SignalGen.m_AcquisitionType);
       m_SignalGen.m_CoilSensitivityProfile = (SignalGenerationParameters::CoilSensitivityProfile)
                                              ReadVal<int>(v1,"coilsensitivityprofile", m_SignalGen.m_CoilSensitivityProfile);
       m_SignalGen.m_NumberOfCoils = ReadVal<int>(v1,"numberofcoils", m_SignalGen.m_NumberOfCoils);
       m_SignalGen.m_ReversePhase = ReadVal<bool>(v1,"reversephase", m_SignalGen.m_ReversePhase);
       m_SignalGen.m_PartialFourier = ReadVal<float>(v1,"partialfourier", m_SignalGen.m_PartialFourier);
       m_SignalGen.m_NoiseVariance = ReadVal<float>(v1,"noisevariance", m_SignalGen.m_NoiseVariance);
       m_SignalGen.m_tRep = ReadVal<float>(v1,"trep", m_SignalGen.m_tRep);
       m_SignalGen.m_SignalScale = ReadVal<float>(v1,"signalScale", m_SignalGen.m_SignalScale);
       m_SignalGen.m_tEcho = ReadVal<float>(v1,"tEcho", m_SignalGen.m_tEcho);
       m_SignalGen.m_tLine = ReadVal<float>(v1,"tLine", m_SignalGen.m_tLine);
       m_SignalGen.m_tInhom = ReadVal<float>(v1,"tInhom", m_SignalGen.m_tInhom);
       m_SignalGen.m_Bvalue = ReadVal<double>(v1,"bvalue", m_SignalGen.m_Bvalue);
       m_SignalGen.m_SimulateKspaceAcquisition = ReadVal<bool>(v1,"simulatekspace", m_SignalGen.m_SimulateKspaceAcquisition);
 
       m_SignalGen.m_AxonRadius = ReadVal<double>(v1,"axonRadius", m_SignalGen.m_AxonRadius);
       m_SignalGen.m_Spikes = ReadVal<unsigned int>(v1,"artifacts.spikesnum", m_SignalGen.m_Spikes);
       m_SignalGen.m_SpikeAmplitude = ReadVal<float>(v1,"artifacts.spikesscale", m_SignalGen.m_SpikeAmplitude);
       m_SignalGen.m_KspaceLineOffset = ReadVal<float>(v1,"artifacts.kspaceLineOffset", m_SignalGen.m_KspaceLineOffset);
       m_SignalGen.m_EddyStrength = ReadVal<float>(v1,"artifacts.eddyStrength", m_SignalGen.m_EddyStrength);
       m_SignalGen.m_Tau = ReadVal<float>(v1,"artifacts.eddyTau", m_SignalGen.m_Tau);
       m_SignalGen.m_CroppingFactor = ReadVal<float>(v1,"artifacts.aliasingfactor", m_SignalGen.m_CroppingFactor);
       m_SignalGen.m_DoAddGibbsRinging = ReadVal<bool>(v1,"artifacts.addringing", m_SignalGen.m_DoAddGibbsRinging);
       m_SignalGen.m_DoSimulateRelaxation = ReadVal<bool>(v1,"doSimulateRelaxation", m_SignalGen.m_DoSimulateRelaxation);
       m_SignalGen.m_DoDisablePartialVolume = ReadVal<bool>(v1,"doDisablePartialVolume", m_SignalGen.m_DoDisablePartialVolume);
       m_SignalGen.m_DoAddMotion = ReadVal<bool>(v1,"artifacts.doAddMotion", m_SignalGen.m_DoAddMotion);
       m_SignalGen.m_DoRandomizeMotion = ReadVal<bool>(v1,"artifacts.randomMotion", m_SignalGen.m_DoRandomizeMotion);
       m_SignalGen.m_Translation[0] = ReadVal<float>(v1,"artifacts.translation0", m_SignalGen.m_Translation[0]);
       m_SignalGen.m_Translation[1] = ReadVal<float>(v1,"artifacts.translation1", m_SignalGen.m_Translation[1]);
       m_SignalGen.m_Translation[2] = ReadVal<float>(v1,"artifacts.translation2", m_SignalGen.m_Translation[2]);
       m_SignalGen.m_Rotation[0] = ReadVal<float>(v1,"artifacts.rotation0", m_SignalGen.m_Rotation[0]);
       m_SignalGen.m_Rotation[1] = ReadVal<float>(v1,"artifacts.rotation1", m_SignalGen.m_Rotation[1]);
       m_SignalGen.m_Rotation[2] = ReadVal<float>(v1,"artifacts.rotation2", m_SignalGen.m_Rotation[2]);
 
 
       // m_SignalGen.SetNumWeightedVolumes(ReadVal<unsigned int>(v1,"numgradients", m_SignalGen.GetNumWeightedVolumes()));
       SignalGenerationParameters::GradientListType gradients;
       BOOST_FOREACH( boost::property_tree::ptree::value_type const& v2, v1.second.get_child("gradients") )
       {
         SignalGenerationParameters::GradientType g;
         g[0] = ReadVal<double>(v2,"x",0);
         g[1] = ReadVal<double>(v2,"y",0);
         g[2] = ReadVal<double>(v2,"z",0);
         gradients.push_back(g);
       }
       m_SignalGen.SetGradienDirections(gradients);
 
 
       m_Misc.m_MotionVolumesBox = ReadVal<std::string>(v1,"artifacts.motionvolumes", m_Misc.m_MotionVolumesBox);
       m_SignalGen.m_MotionVolumes.clear();
 
       if ( m_Misc.m_MotionVolumesBox == "random" )
       {
         for ( size_t i=0; i < m_SignalGen.GetNumVolumes(); ++i )
         {
           m_SignalGen.m_MotionVolumes.push_back( bool( rand()%2 ) );
         }
         MITK_DEBUG << "mitkFiberfoxParameters.cpp: Case m_Misc.m_MotionVolumesBox == \"random\".";
       }
       else if ( ! m_Misc.m_MotionVolumesBox.empty() )
       {
         std::stringstream stream( m_Misc.m_MotionVolumesBox );
         std::vector<int> numbers;
         int nummer = std::numeric_limits<int>::max();
         while( stream >> nummer )
         {
           if( nummer < std::numeric_limits<int>::max() )
           {
             numbers.push_back( nummer );
           }
         }
         // If a list of negative numbers is given:
         if( *(std::min_element( numbers.begin(), numbers.end() )) < 0
             && *(std::max_element( numbers.begin(), numbers.end() )) <= 0 ) // cave: -0 == +0
         {
           for ( size_t i=0; i<m_SignalGen.GetNumVolumes(); ++i )
           {
             m_SignalGen.m_MotionVolumes.push_back( true );
           }
           // set all true except those given.
           for (auto number : numbers)
           {
             if (-number < static_cast<int>(m_SignalGen.GetNumVolumes()) && -number >= 0 )
               m_SignalGen.m_MotionVolumes.at(-number) = false;
           }
           MITK_DEBUG << "mitkFiberfoxParameters.cpp: Case list of negative numbers.";
         }
         // If a list of positive numbers is given:
         else if( *(std::min_element( numbers.begin(), numbers.end() )) >= 0
                  && *(std::max_element( numbers.begin(), numbers.end() )) >= 0 )
         {
           for ( size_t i=0; i<m_SignalGen.GetNumVolumes(); ++i )
           {
             m_SignalGen.m_MotionVolumes.push_back( false );
           }
           // set all false except those given.
           for (auto number : numbers)
           {
             if (number < static_cast<int>(m_SignalGen.GetNumVolumes()) && number >= 0)
               m_SignalGen.m_MotionVolumes.at(number) = true;
           }
           MITK_DEBUG << "mitkFiberfoxParameters.cpp: Case list of positive numbers.";
         }
         else
         {
           MITK_WARN << "mitkFiberfoxParameters.cpp: Inconsistent list of numbers in m_MotionVolumesBox.";
           break;
         }
       }
       else
       {
         MITK_WARN << "mitkFiberfoxParameters.cpp: Cannot make sense of string in m_MotionVolumesBox.";
         break;
       }
 
 
       try
       {
         if (ReadVal<std::string>(v1,"artifacts.noisetype","")=="rice")
         {
           m_NoiseModel = std::make_shared< mitk::RicianNoiseModel<> >();
           m_NoiseModel->SetNoiseVariance(ReadVal<float>(v1,"artifacts.noisevariance",m_NoiseModel->GetNoiseVariance()));
         }
       }
       catch(...)
       {
         MITK_DEBUG << "mitkFiberfoxParameters.cpp: caught some error while trying m_NoiseModel->SetNoiseVariance()";
         // throw;
       }
 
       try
       {
         if (ReadVal<std::string>(v1,"artifacts.noisetype","")=="chisquare")
         {
           m_NoiseModel = std::make_shared< mitk::ChiSquareNoiseModel<> >();
           m_NoiseModel->SetNoiseVariance(ReadVal<float>(v1,"artifacts.noisevariance",m_NoiseModel->GetNoiseVariance()));
         }
       }
       catch(...)
       {
         MITK_DEBUG << "mitkFiberfoxParameters.cpp: caught some error while trying m_NoiseModel->SetNoiseVariance()";
         // throw;
       }
 
 
       BOOST_FOREACH( boost::property_tree::ptree::value_type const& v2, v1.second.get_child("compartments") )
       {
         mitk::DiffusionSignalModel<>* signalModel = nullptr;
 
         std::string model = ReadVal<std::string>(v2,"model","",true);
         if (model=="stick")
         {
           mitk::StickModel<>* model = new mitk::StickModel<>();
           model->SetDiffusivity(ReadVal<double>(v2,"d",model->GetDiffusivity()));
           model->SetT2(ReadVal<double>(v2,"t2",model->GetT2()));
           model->SetT1(ReadVal<double>(v2,"t1",model->GetT1()));
           model->SetBvalue(m_SignalGen.m_Bvalue);
           model->m_CompartmentId = ReadVal<unsigned int>(v2,"ID",0,true);
           if (ReadVal<std::string>(v2,"type","",true)=="fiber")
             m_FiberModelList.push_back(model);
           else if (ReadVal<std::string>(v2,"type","",true)=="non-fiber")
             m_NonFiberModelList.push_back(model);
           signalModel = model;
         }
         else if (model=="tensor")
         {
           mitk::TensorModel<>* model = new mitk::TensorModel<>();
           model->SetDiffusivity1(ReadVal<double>(v2,"d1",model->GetDiffusivity1()));
           model->SetDiffusivity2(ReadVal<double>(v2,"d2",model->GetDiffusivity2()));
           model->SetDiffusivity3(ReadVal<double>(v2,"d3",model->GetDiffusivity3()));
           model->SetT2(ReadVal<double>(v2,"t2",model->GetT2()));
           model->SetT1(ReadVal<double>(v2,"t1",model->GetT1()));
           model->SetBvalue(m_SignalGen.m_Bvalue);
           model->m_CompartmentId = ReadVal<unsigned int>(v2,"ID",0,true);
           if (ReadVal<std::string>(v2,"type","",true)=="fiber")
             m_FiberModelList.push_back(model);
           else if (ReadVal<std::string>(v2,"type","",true)=="non-fiber")
             m_NonFiberModelList.push_back(model);
           signalModel = model;
         }
         else if (model=="ball")
         {
           mitk::BallModel<>* model = new mitk::BallModel<>();
           model->SetDiffusivity(ReadVal<double>(v2,"d",model->GetDiffusivity()));
           model->SetT2(ReadVal<double>(v2,"t2",model->GetT2()));
           model->SetT1(ReadVal<double>(v2,"t1",model->GetT1()));
           model->SetBvalue(m_SignalGen.m_Bvalue);
           model->m_CompartmentId = ReadVal<unsigned int>(v2,"ID",0,true);
           if (ReadVal<std::string>(v2,"type","",true)=="fiber")
             m_FiberModelList.push_back(model);
           else if (ReadVal<std::string>(v2,"type","",true)=="non-fiber")
             m_NonFiberModelList.push_back(model);
           signalModel = model;
         }
         else if (model=="astrosticks")
         {
           mitk::AstroStickModel<>* model = new AstroStickModel<>();
           model->SetDiffusivity(ReadVal<double>(v2,"d",model->GetDiffusivity()));
           model->SetT2(ReadVal<double>(v2,"t2",model->GetT2()));
           model->SetT1(ReadVal<double>(v2,"t1",model->GetT1()));
           model->SetBvalue(m_SignalGen.m_Bvalue);
           model->SetRandomizeSticks(ReadVal<bool>(v2,"randomize",model->GetRandomizeSticks()));
           model->m_CompartmentId = ReadVal<unsigned int>(v2,"ID",0,true);
           if (ReadVal<std::string>(v2,"type","",true)=="fiber")
             m_FiberModelList.push_back(model);
           else if (ReadVal<std::string>(v2,"type","",true)=="non-fiber")
             m_NonFiberModelList.push_back(model);
           signalModel = model;
         }
         else if (model=="dot")
         {
           mitk::DotModel<>* model = new mitk::DotModel<>();
           model->SetT2(ReadVal<double>(v2,"t2",model->GetT2()));
           model->SetT1(ReadVal<double>(v2,"t1",model->GetT1()));
           model->m_CompartmentId = ReadVal<unsigned int>(v2,"ID",0,true);
           if (ReadVal<std::string>(v2,"type","",true)=="fiber")
             m_FiberModelList.push_back(model);
           else if (ReadVal<std::string>(v2,"type","",true)=="non-fiber")
             m_NonFiberModelList.push_back(model);
           signalModel = model;
         }
         else if (model=="prototype")
         {
           mitk::RawShModel<>* model = new mitk::RawShModel<>();
           model->SetMaxNumKernels(ReadVal<unsigned int>(v2,"maxNumSamples",model->GetMaxNumKernels()));
           model->SetFaRange(ReadVal<double>(v2,"minFA",model->GetFaRange().first), ReadVal<double>(v2,"maxFA",model->GetFaRange().second));
           model->SetAdcRange(ReadVal<double>(v2,"minADC",model->GetAdcRange().first), ReadVal<double>(v2,"maxADC",model->GetAdcRange().second));
           model->m_CompartmentId = ReadVal<unsigned int>(v2,"ID",0,true);
           unsigned int numCoeffs = ReadVal<unsigned int>(v2,"numCoeffs",0,true);
           unsigned int numSamples = ReadVal<unsigned int>(v2,"numSamples",0,true);
 
           for (unsigned int j=0; j<numSamples; j++)
           {
             vnl_vector< double > coeffs(numCoeffs);
             for (unsigned int k=0; k<numCoeffs; k++)
             {
               coeffs[k] = ReadVal<double>(v2,"kernels."+boost::lexical_cast<std::string>(j)+".coeffs."+boost::lexical_cast<std::string>(k),0,true);
             }
             model->SetShCoefficients( coeffs, ReadVal<double>(v2,"kernels."+boost::lexical_cast<std::string>(j)+".B0",0,true) );
           }
 
           if (ReadVal<std::string>(v2,"type","",true)=="fiber")
           { m_FiberModelList.push_back(model); }
           else if (ReadVal<std::string>(v2,"type","",true)=="non-fiber")
           { m_NonFiberModelList.push_back(model); }
           // else ?
           signalModel = model;
         }
 
         if (signalModel!=nullptr)
         {
           signalModel->SetGradientList(gradients);
 
           try
           {
             itk::ImageFileReader<ItkDoubleImgType>::Pointer reader = itk::ImageFileReader<ItkDoubleImgType>::New();
             if ( itksys::SystemTools::FileExists(filename+"_VOLUME"+ReadVal<std::string>(v2,"ID","")+".nii.gz") )
               reader->SetFileName(filename+"_VOLUME"+ReadVal<std::string>(v2,"ID","")+".nii.gz");
             else if ( itksys::SystemTools::FileExists(filename+"_VOLUME"+ReadVal<std::string>(v2,"ID","")+".nii") )
               reader->SetFileName(filename+"_VOLUME"+ReadVal<std::string>(v2,"ID","")+".nii");
             else
               reader->SetFileName(filename+"_VOLUME"+ReadVal<std::string>(v2,"ID","")+".nrrd");
             reader->Update();
             signalModel->SetVolumeFractionImage(reader->GetOutput());
             MITK_INFO << "Volume fraction image loaded for compartment " << signalModel->m_CompartmentId;
           }
           catch(...)
           {
             MITK_INFO << "No volume fraction image found for compartment " << signalModel->m_CompartmentId;
           }
         }
       }
     }
     else
     {
 
     }
   }
 
   try
   {
     itk::ImageFileReader<ItkFloatImgType>::Pointer reader = itk::ImageFileReader<ItkFloatImgType>::New();
     reader->SetFileName(filename+"_FMAP.nrrd");
     if ( itksys::SystemTools::FileExists(filename+"_FMAP.nii.gz") )
       reader->SetFileName(filename+"_FMAP.nii.gz");
     else if ( itksys::SystemTools::FileExists(filename+"_FMAP.nii") )
       reader->SetFileName(filename+"_FMAP.nii");
     else
       reader->SetFileName(filename+"_FMAP.nrrd");
     reader->Update();
     m_SignalGen.m_FrequencyMap = reader->GetOutput();
     MITK_INFO << "Frequency map loaded.";
   }
   catch(...)
   {
     MITK_INFO << "No frequency map found.";
   }
 
   try
   {
     itk::ImageFileReader<ItkUcharImgType>::Pointer reader = itk::ImageFileReader<ItkUcharImgType>::New();
     if ( itksys::SystemTools::FileExists(filename+"_MASK.nii.gz") )
       reader->SetFileName(filename+"_MASK.nii.gz");
     else if ( itksys::SystemTools::FileExists(filename+"_MASK.nii") )
       reader->SetFileName(filename+"_MASK.nii");
     else
       reader->SetFileName(filename+"_MASK.nrrd");
     reader->Update();
     m_SignalGen.m_MaskImage = reader->GetOutput();
     m_SignalGen.m_ImageRegion = m_SignalGen.m_MaskImage->GetLargestPossibleRegion();
     m_SignalGen.m_ImageSpacing = m_SignalGen.m_MaskImage->GetSpacing();
     m_SignalGen.m_ImageOrigin = m_SignalGen.m_MaskImage->GetOrigin();
     m_SignalGen.m_ImageDirection = m_SignalGen.m_MaskImage->GetDirection();
     MITK_INFO << "Mask image loaded.";
   }
   catch(...)
   {
     MITK_INFO << "No mask image found.";
   }
 
   setlocale(LC_ALL, currLocale.c_str());
 }
 
 
 void mitk::FiberfoxParameters::PrintSelf()
 {
   MITK_INFO << "Not implemented :(";
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/Testing/mitkLocalFiberPlausibilityTest.cpp b/Modules/DiffusionImaging/FiberTracking/Testing/mitkLocalFiberPlausibilityTest.cpp
index 95c60988a8..1bb35113ca 100755
--- a/Modules/DiffusionImaging/FiberTracking/Testing/mitkLocalFiberPlausibilityTest.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Testing/mitkLocalFiberPlausibilityTest.cpp
@@ -1,156 +1,156 @@
 /*===================================================================
 
 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 <itkTractsToVectorImageFilter.h>
 #include <usAny.h>
 #include <itkImageFileWriter.h>
 #include <mitkIOUtil.h>
-#include <boost/lexical_cast.hpp>
+#include <mitkLexicalCast.h>
 #include <iostream>
 #include <fstream>
 #include <itksys/SystemTools.hxx>
 #include <mitkTestingMacros.h>
 #include <mitkCompareImageDataFilter.h>
 #include <mitkCoreObjectFactory.h>
 #include <omp.h>
 
 int mitkLocalFiberPlausibilityTest(int argc, char* argv[])
 {
     omp_set_num_threads(1);
     MITK_TEST_BEGIN("mitkLocalFiberPlausibilityTest");
     MITK_TEST_CONDITION_REQUIRED(argc==8,"check for input data")
 
     std::string fibFile = argv[1];
     std::vector< std::string > referenceImages;
     referenceImages.push_back(argv[2]);
     referenceImages.push_back(argv[3]);
     std::string LDFP_ERROR_IMAGE = argv[4];
     std::string LDFP_NUM_DIRECTIONS = argv[5];
     std::string LDFP_VECTOR_FIELD = argv[6];
     std::string LDFP_ERROR_IMAGE_IGNORE = argv[7];
 
     float angularThreshold = 30;
 
     try
     {
         typedef itk::Image<unsigned char, 3>                                    ItkUcharImgType;
         typedef itk::Image< itk::Vector< float, 3>, 3 >                         ItkDirectionImage3DType;
         typedef itk::VectorContainer< unsigned int, ItkDirectionImage3DType::Pointer >   ItkDirectionImageContainerType;
         typedef itk::EvaluateDirectionImagesFilter< float >                     EvaluationFilterType;
 
         // load fiber bundle
         mitk::FiberBundle::Pointer inputTractogram = mitk::IOUtil::Load<mitk::FiberBundle>(fibFile);
 
         // load reference directions
         ItkDirectionImageContainerType::Pointer referenceImageContainer = ItkDirectionImageContainerType::New();
         for (unsigned int i=0; i<referenceImages.size(); i++)
         {
             try
             {
                 mitk::Image::Pointer img = mitk::IOUtil::Load<mitk::Image>(referenceImages.at(i));
                 typedef mitk::ImageToItk< ItkDirectionImage3DType > CasterType;
                 CasterType::Pointer caster = CasterType::New();
                 caster->SetInput(img);
                 caster->Update();
                 ItkDirectionImage3DType::Pointer itkImg = caster->GetOutput();
                 referenceImageContainer->InsertElement(referenceImageContainer->Size(),itkImg);
             }
             catch(...){ MITK_INFO << "could not load: " << referenceImages.at(i); }
         }
 
         ItkUcharImgType::Pointer itkMaskImage = ItkUcharImgType::New();
         ItkDirectionImage3DType::Pointer dirImg = referenceImageContainer->GetElement(0);
         itkMaskImage->SetSpacing( dirImg->GetSpacing() );
         itkMaskImage->SetOrigin( dirImg->GetOrigin() );
         itkMaskImage->SetDirection( dirImg->GetDirection() );
         itkMaskImage->SetLargestPossibleRegion( dirImg->GetLargestPossibleRegion() );
         itkMaskImage->SetBufferedRegion( dirImg->GetLargestPossibleRegion() );
         itkMaskImage->SetRequestedRegion( dirImg->GetLargestPossibleRegion() );
         itkMaskImage->Allocate();
         itkMaskImage->FillBuffer(1);
 
         // extract directions from fiber bundle
         itk::TractsToVectorImageFilter<float>::Pointer fOdfFilter = itk::TractsToVectorImageFilter<float>::New();
         fOdfFilter->SetFiberBundle(inputTractogram);
         fOdfFilter->SetMaskImage(itkMaskImage);
         fOdfFilter->SetAngularThreshold(cos(angularThreshold*itk::Math::pi/180));
         fOdfFilter->SetNormalizationMethod(itk::TractsToVectorImageFilter<float>::NormalizationMethods::SINGLE_VEC_NORM);
         fOdfFilter->SetMaxNumDirections(3);
         fOdfFilter->SetSizeThreshold(0.3);
 
         fOdfFilter->SetUseWorkingCopy(false);
         fOdfFilter->SetNumberOfThreads(1);
         fOdfFilter->Update();
         itk::TractsToVectorImageFilter<float>::ItkDirectionImageType::Pointer direction_image = fOdfFilter->GetDirectionImage();
 
         // Get directions and num directions image
         ItkUcharImgType::Pointer numDirImage = fOdfFilter->GetNumDirectionsImage();
         mitk::Image::Pointer mitkNumDirImage = mitk::Image::New();
         mitkNumDirImage->InitializeByItk( numDirImage.GetPointer() );
         mitkNumDirImage->SetVolume( numDirImage->GetBufferPointer() );
 //        mitk::FiberBundle::Pointer testDirections = fOdfFilter->GetOutputFiberBundle();
 
         // evaluate directions with missing directions
         EvaluationFilterType::Pointer evaluationFilter = EvaluationFilterType::New();
         // evaluationFilter->SetImageSet(directionImageContainer);
         evaluationFilter->SetReferenceImageSet(referenceImageContainer);
         evaluationFilter->SetMaskImage(itkMaskImage);
         evaluationFilter->SetIgnoreMissingDirections(false);
         evaluationFilter->Update();
 
         EvaluationFilterType::OutputImageType::Pointer angularErrorImage = evaluationFilter->GetOutput(0);
         mitk::Image::Pointer mitkAngularErrorImage = mitk::Image::New();
         mitkAngularErrorImage->InitializeByItk( angularErrorImage.GetPointer() );
         mitkAngularErrorImage->SetVolume( angularErrorImage->GetBufferPointer() );
 
         // evaluate directions without missing directions
         evaluationFilter->SetIgnoreMissingDirections(true);
         evaluationFilter->Update();
 
         EvaluationFilterType::OutputImageType::Pointer angularErrorImageIgnore = evaluationFilter->GetOutput(0);
         mitk::Image::Pointer mitkAngularErrorImageIgnore = mitk::Image::New();
         mitkAngularErrorImageIgnore->InitializeByItk( angularErrorImageIgnore.GetPointer() );
         mitkAngularErrorImageIgnore->SetVolume( angularErrorImageIgnore->GetBufferPointer() );
 
         mitk::Image::Pointer gtAngularErrorImageIgnore = mitk::IOUtil::Load<mitk::Image>(LDFP_ERROR_IMAGE_IGNORE);
         mitk::Image::Pointer gtAngularErrorImage = mitk::IOUtil::Load<mitk::Image>(LDFP_ERROR_IMAGE);
         mitk::Image::Pointer gtNumTestDirImage = mitk::IOUtil::Load<mitk::Image>(LDFP_NUM_DIRECTIONS);
 
         MITK_ASSERT_EQUAL(gtAngularErrorImageIgnore, mitkAngularErrorImageIgnore, "Check if error images are equal (ignored missing directions).");
         MITK_ASSERT_EQUAL(gtAngularErrorImage, mitkAngularErrorImage, "Check if error images are equal.");
         MITK_ASSERT_EQUAL(gtNumTestDirImage, mitkNumDirImage, "Check if num direction images are equal.");
     }
     catch (itk::ExceptionObject e)
     {
         MITK_INFO << e;
         return EXIT_FAILURE;
     }
     catch (std::exception e)
     {
         MITK_INFO << e.what();
         return EXIT_FAILURE;
     }
     catch (...)
     {
         MITK_INFO << "ERROR!?!";
         return EXIT_FAILURE;
     }
     MITK_TEST_END();
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/FiberClustering.cpp b/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/FiberClustering.cpp
index 00559e4c71..61ae8e9bf3 100644
--- a/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/FiberClustering.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/FiberClustering.cpp
@@ -1,251 +1,251 @@
 /*===================================================================
 
 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 <boost/lexical_cast.hpp>
+#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 <mitkClusteringMetricInnerAngles.h>
 #include <mitkClusteringMetricLength.h>
 
 mitk::FiberBundle::Pointer LoadFib(std::string filename)
 {
   std::vector<mitk::BaseData::Pointer> fibInfile = mitk::IOUtil::Load(filename);
   if( fibInfile.empty() )
     std::cout << "File " << filename << " could not be read!";
   mitk::BaseData::Pointer baseData = fibInfile.at(0);
   return dynamic_cast<mitk::FiberBundle*>(baseData.GetPointer());
 }
 
 /*!
 \brief Spatially cluster fibers
 */
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
 
   parser.setTitle("Fiber Clustering");
   parser.setCategory("Fiber Processing");
   parser.setContributor("MIC");
 
   parser.setArgumentPrefix("--", "-");
   parser.addArgument("", "i", mitkCommandLineParser::InputFile, "Input:", "input fiber bundle (.fib, .trk, .tck)", us::Any(), false);
   parser.addArgument("", "o", mitkCommandLineParser::OutputDirectory, "Output:", "output root", us::Any(), false);
 
   parser.addArgument("cluster_size", "", mitkCommandLineParser::Int, "Cluster size:", "", 10);
   parser.addArgument("fiber_points", "", mitkCommandLineParser::Int, "Fiber points:", "", 12);
   parser.addArgument("min_fibers", "", mitkCommandLineParser::Int, "Min. fibers per cluster:", "", 1);
   parser.addArgument("max_clusters", "", mitkCommandLineParser::Int, "Max. clusters:", "");
   parser.addArgument("merge_clusters", "", mitkCommandLineParser::Float, "Merge clusters:", "", -1.0);
   parser.addArgument("output_centroids", "", mitkCommandLineParser::Bool, "Output centroids:", "");
   parser.addArgument("metrics", "", mitkCommandLineParser::StringList, "Metrics:", "EU_MEAN, EU_STD, EU_MAX, ANAT, MAP, LENGTH");
   parser.addArgument("metric_weights", "", mitkCommandLineParser::StringList, "Metric weights:", "add one float weight for each used metric");
   parser.addArgument("input_centroids", "", mitkCommandLineParser::String, "Input centroids:", "");
   parser.addArgument("scalar_map", "", mitkCommandLineParser::String, "Scalar map:", "");
   parser.addArgument("parcellation", "", mitkCommandLineParser::String, "Parcellation:", "");
   parser.addArgument("file_ending", "", mitkCommandLineParser::String, "File ending:", "");
 
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0)
     return EXIT_FAILURE;
 
   std::string inFileName = us::any_cast<std::string>(parsedArgs["i"]);
   std::string out_root = us::any_cast<std::string>(parsedArgs["o"]);
 
   int cluster_size = 10;
   if (parsedArgs.count("cluster_size"))
     cluster_size = us::any_cast<int>(parsedArgs["cluster_size"]);
 
   int fiber_points = 12;
   if (parsedArgs.count("fiber_points"))
     fiber_points = us::any_cast<int>(parsedArgs["fiber_points"]);
 
   int min_fibers = 1;
   if (parsedArgs.count("min_fibers"))
     min_fibers = us::any_cast<int>(parsedArgs["min_fibers"]);
 
   int max_clusters = 0;
   if (parsedArgs.count("max_clusters"))
     max_clusters = us::any_cast<int>(parsedArgs["max_clusters"]);
 
   float merge_clusters = -1.0;
   if (parsedArgs.count("merge_clusters"))
     merge_clusters = us::any_cast<float>(parsedArgs["merge_clusters"]);
 
   bool output_centroids = false;
   if (parsedArgs.count("output_centroids"))
     output_centroids = us::any_cast<bool>(parsedArgs["output_centroids"]);
 
   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"]);
 
   std::string input_centroids = "";
   if (parsedArgs.count("input_centroids"))
     input_centroids = us::any_cast<std::string>(parsedArgs["input_centroids"]);
 
   std::string scalar_map = "";
   if (parsedArgs.count("scalar_map"))
     scalar_map = us::any_cast<std::string>(parsedArgs["scalar_map"]);
 
   std::string parcellation = "";
   if (parsedArgs.count("parcellation"))
     parcellation = us::any_cast<std::string>(parsedArgs["parcellation"]);
 
   std::string file_ending = ".fib";
   if (parsedArgs.count("file_ending"))
     file_ending = us::any_cast<std::string>(parsedArgs["file_ending"]);
 
   if (metric_strings.size()!=metric_weights.size())
   {
     MITK_INFO << "Each metric needs an associated metric weight!";
     return EXIT_FAILURE;
   }
 
   try
   {
     typedef itk::Image< float, 3 > FloatImageType;
     typedef itk::Image< short, 3 > ShortImageType;
 
     mitk::FiberBundle::Pointer fib = LoadFib(inFileName);
 
     float max_d = 0;
     int i=1;
     std::vector< float > distances;
     while (max_d < fib->GetGeometry()->GetDiagonalLength()/2)
     {
       distances.push_back(cluster_size*i);
       max_d = cluster_size*i;
       ++i;
     }
 
     itk::TractClusteringFilter::Pointer clusterer = itk::TractClusteringFilter::New();
     clusterer->SetDistances(distances);
     clusterer->SetTractogram(fib);
 
     if (input_centroids!="")
     {
 
       mitk::FiberBundle::Pointer in_centroids = LoadFib(input_centroids);
       clusterer->SetInCentroids(in_centroids);
     }
 
     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()});
       else if (m=="ANGLES")
         metrics.push_back({new mitk::ClusteringMetricInnerAngles()});
       else if (m=="LENGTH")
         metrics.push_back({new mitk::ClusteringMetricLength()});
       else if (m=="MAP" && scalar_map!="")
       {
         mitk::Image::Pointer mitk_map = mitk::IOUtil::Load<mitk::Image>(scalar_map);
         if (mitk_map->GetDimension()==3)
         {
           FloatImageType::Pointer itk_map = FloatImageType::New();
           mitk::CastToItkImage(mitk_map, itk_map);
 
           mitk::ClusteringMetricScalarMap* metric = new mitk::ClusteringMetricScalarMap();
           metric->SetImages({itk_map});
           metric->SetScale(distances.at(0));
           metrics.push_back(metric);
         }
       }
       else if (m=="ANAT" && parcellation!="")
       {
         mitk::Image::Pointer mitk_map = mitk::IOUtil::Load<mitk::Image>(parcellation);
         if (mitk_map->GetDimension()==3)
         {
           ShortImageType::Pointer itk_map = ShortImageType::New();
           mitk::CastToItkImage(mitk_map, itk_map);
 
           mitk::ClusteringMetricAnatomic* metric = new mitk::ClusteringMetricAnatomic();
           metric->SetParcellations({itk_map});
           metrics.push_back(metric);
         }
       }
       metrics.back()->SetScale(w);
       mc++;
     }
 
     if (metrics.empty())
     {
       MITK_INFO << "No metric selected!";
       return EXIT_FAILURE;
     }
 
     clusterer->SetMetrics(metrics);
     clusterer->SetMergeDuplicateThreshold(merge_clusters);
     clusterer->SetNumPoints(fiber_points);
     clusterer->SetMaxClusters(max_clusters);
     clusterer->SetMinClusterSize(min_fibers);
     clusterer->Update();
     std::vector<mitk::FiberBundle::Pointer> tracts = clusterer->GetOutTractograms();
     std::vector<mitk::FiberBundle::Pointer> centroids = clusterer->GetOutCentroids();
 
     MITK_INFO << "Saving clusters";
     std::streambuf *old = cout.rdbuf(); // <-- save
     std::stringstream ss;
     std::cout.rdbuf (ss.rdbuf());       // <-- redirect
     unsigned int c = 0;
     for (auto f : tracts)
     {
       mitk::IOUtil::Save(f, out_root + "Cluster_" + boost::lexical_cast<std::string>(c) + file_ending);
 
       if (output_centroids)
         mitk::IOUtil::Save(centroids.at(c), out_root + "Centroid_" + boost::lexical_cast<std::string>(c) + file_ending);
       ++c;
     }
     std::cout.rdbuf (old);              // <-- restore
 
   }
   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/FiberProcessing/FiberDirectionExtraction.cpp b/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/FiberDirectionExtraction.cpp
index 225c8516d6..e57b84aee0 100755
--- a/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/FiberDirectionExtraction.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/FiberDirectionExtraction.cpp
@@ -1,175 +1,175 @@
 /*===================================================================
 
 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 <boost/lexical_cast.hpp>
+#include <mitkLexicalCast.h>
 #include <itkEvaluateDirectionImagesFilter.h>
 #include <itkTractsToVectorImageFilter.h>
 #include <mitkCoreObjectFactory.h>
 
 /*!
 \brief Extract principal fiber directions from a tractogram
 */
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
 
   parser.setTitle("Fiber Direction Extraction");
   parser.setCategory("Fiber Tracking and Processing Methods");
   parser.setDescription("Extract principal fiber directions from a tractogram");
   parser.setContributor("MIC");
 
   parser.setArgumentPrefix("--", "-");
   parser.addArgument("input", "i", mitkCommandLineParser::InputFile, "Input:", "input tractogram (.fib/.trk)", us::Any(), false);
   parser.addArgument("out", "o", mitkCommandLineParser::OutputDirectory, "Output:", "output root", us::Any(), false);
   parser.addArgument("mask", "m", mitkCommandLineParser::InputFile, "Mask:", "mask image");
   parser.addArgument("athresh", "a", mitkCommandLineParser::Float, "Angular threshold:", "angular threshold in degrees. closer fiber directions are regarded as one direction and clustered together.", 25, true);
   parser.addArgument("peakthresh", "t", mitkCommandLineParser::Float, "Peak size threshold:", "peak size threshold relative to largest peak in voxel", 0.2, true);
   parser.addArgument("verbose", "v", mitkCommandLineParser::Bool, "Verbose:", "output optional and intermediate calculation results");
   parser.addArgument("numdirs", "d", mitkCommandLineParser::Int, "Max. num. directions:", "maximum number of fibers per voxel", 3, true);
   parser.addArgument("normalization", "n", mitkCommandLineParser::Int, "Normalization method:", "1=global maximum, 2=single vector, 3=voxel-wise maximum", 1);
   parser.addArgument("file_ending", "f", mitkCommandLineParser::String, "Image type:", ".nrrd, .nii, .nii.gz");
 
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0)
     return EXIT_FAILURE;
 
   std::string fibFile = us::any_cast<std::string>(parsedArgs["input"]);
 
   std::string maskImage("");
   if (parsedArgs.count("mask"))
     maskImage = us::any_cast<std::string>(parsedArgs["mask"]);
 
   float peakThreshold = 0.2;
   if (parsedArgs.count("peakthresh"))
     peakThreshold = us::any_cast<float>(parsedArgs["peakthresh"]);
 
   float angularThreshold = 25;
   if (parsedArgs.count("athresh"))
     angularThreshold = us::any_cast<float>(parsedArgs["athresh"]);
 
   std::string outRoot = us::any_cast<std::string>(parsedArgs["out"]);
 
   bool verbose = false;
   if (parsedArgs.count("verbose"))
     verbose = us::any_cast<bool>(parsedArgs["verbose"]);
 
   int maxNumDirs = 3;
   if (parsedArgs.count("numdirs"))
     maxNumDirs = us::any_cast<int>(parsedArgs["numdirs"]);
 
   int normalization = 1;
   if (parsedArgs.count("normalization"))
     normalization = us::any_cast<int>(parsedArgs["normalization"]);
 
   std::string file_ending = ".nrrd";
   if (parsedArgs.count("file_ending"))
     file_ending = us::any_cast<std::string>(parsedArgs["file_ending"]);
 
 
   try
   {
     typedef itk::Image<unsigned char, 3>                                    ItkUcharImgType;
 
     // load fiber bundle
     mitk::FiberBundle::Pointer inputTractogram = mitk::IOUtil::Load<mitk::FiberBundle>(fibFile);
 
     // load/create mask image
     ItkUcharImgType::Pointer itkMaskImage = nullptr;
     if (maskImage.compare("")!=0)
     {
       std::cout << "Using mask image";
       itkMaskImage = ItkUcharImgType::New();
       mitk::Image::Pointer mitkMaskImage = mitk::IOUtil::Load<mitk::Image>(maskImage);
       mitk::CastToItkImage(mitkMaskImage, itkMaskImage);
     }
 
     // extract directions from fiber bundle
     itk::TractsToVectorImageFilter<float>::Pointer fOdfFilter = itk::TractsToVectorImageFilter<float>::New();
     fOdfFilter->SetFiberBundle(inputTractogram);
     fOdfFilter->SetMaskImage(itkMaskImage);
     fOdfFilter->SetAngularThreshold(cos(angularThreshold*itk::Math::pi/180));
     switch (normalization)
     {
     case 1:
       fOdfFilter->SetNormalizationMethod(itk::TractsToVectorImageFilter<float>::NormalizationMethods::GLOBAL_MAX);
       break;
     case 2:
       fOdfFilter->SetNormalizationMethod(itk::TractsToVectorImageFilter<float>::NormalizationMethods::SINGLE_VEC_NORM);
       break;
     case 3:
       fOdfFilter->SetNormalizationMethod(itk::TractsToVectorImageFilter<float>::NormalizationMethods::MAX_VEC_NORM);
       break;
     }
     fOdfFilter->SetUseWorkingCopy(false);
     fOdfFilter->SetSizeThreshold(peakThreshold);
     fOdfFilter->SetMaxNumDirections(maxNumDirs);
     fOdfFilter->Update();
 
     {
       itk::TractsToVectorImageFilter<float>::ItkDirectionImageType::Pointer itkImg = fOdfFilter->GetDirectionImage();
       typedef itk::ImageFileWriter< itk::TractsToVectorImageFilter<float>::ItkDirectionImageType > WriterType;
       WriterType::Pointer writer = WriterType::New();
 
       std::string outfilename = outRoot;
       outfilename.append("_DIRECTIONS");
       outfilename.append(file_ending);
 
       writer->SetFileName(outfilename.c_str());
       writer->SetInput(itkImg);
       writer->Update();
     }
 
     if (verbose)
     {
       // write num direction image
       ItkUcharImgType::Pointer numDirImage = fOdfFilter->GetNumDirectionsImage();
       typedef itk::ImageFileWriter< ItkUcharImgType > WriterType;
       WriterType::Pointer writer = WriterType::New();
 
       std::string outfilename = outRoot;
       outfilename.append("_NUM_DIRECTIONS");
       outfilename.append(file_ending);
 
       writer->SetFileName(outfilename.c_str());
       writer->SetInput(numDirImage);
       writer->Update();
     }
   }
   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/FiberProcessing/FiberExtraction.cpp b/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/FiberExtraction.cpp
index b534839be1..5cad39e703 100755
--- a/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/FiberExtraction.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/FiberExtraction.cpp
@@ -1,151 +1,151 @@
 /*===================================================================
 
 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 <mitkLexicalCast.h>
 #include <mitkCoreObjectFactory.h>
 #include <mitkPlanarFigure.h>
 #include <mitkPlanarFigureComposite.h>
 #include <mitkFiberBundle.h>
 #include <mitkImageCast.h>
 #include <mitkImageToItk.h>
 #include <mitkStandaloneDataStorage.h>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 /*!
 \brief Extract fibers from a tractogram using planar figure ROIs
 */
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
 
   parser.setTitle("Fiber Extraction");
   parser.setCategory("Fiber Tracking and Processing Methods");
   parser.setContributor("MIC");
   parser.setDescription("Extract fibers from a tractogram using planar figure ROIs");
 
   parser.setArgumentPrefix("--", "-");
   parser.addArgument("input", "i", mitkCommandLineParser::String, "Input:", "input tractogram (.fib/.trk)", us::Any(), false);
   parser.addArgument("out", "o", mitkCommandLineParser::String, "Output:", "output tractogram", us::Any(), false);
   parser.addArgument("planfirgure1", "pf1", mitkCommandLineParser::String, "Figure 1:", "first planar figure ROI", us::Any(), false);
   parser.addArgument("planfirgure2", "pf2", mitkCommandLineParser::String, "Figure 2:", "second planar figure ROI", us::Any());
   parser.addArgument("operation", "op", mitkCommandLineParser::String, "Operation:", "logical operation (AND, OR, NOT)", us::Any());
 
 
   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"]);
   std::string pf1_path = us::any_cast<std::string>(parsedArgs["planfirgure1"]);
 
   std::string operation("");
   std::string pf2_path("");
   if (parsedArgs.count("operation"))
   {
     operation = us::any_cast<std::string>(parsedArgs["operation"]);
     if (parsedArgs.count("planfirgure2") && (operation=="AND" || operation=="OR"))
       pf2_path = us::any_cast<std::string>(parsedArgs["planfirgure2"]);
   }
 
   try
   {
     // load fiber bundle
     mitk::FiberBundle::Pointer inputTractogram = mitk::IOUtil::Load<mitk::FiberBundle>(inFib);
     mitk::FiberBundle::Pointer result;
 
     mitk::StandaloneDataStorage::Pointer storage = mitk::StandaloneDataStorage::New();
     auto data = mitk::IOUtil::Load(pf1_path)[0];
     auto input1 = mitk::DataNode::New();
     input1->SetData(data);
 
     if (input1.IsNotNull())
     {
       mitk::PlanarFigureComposite::Pointer pfc = mitk::PlanarFigureComposite::New();
       mitk::DataNode::Pointer pfcNode = mitk::DataNode::New();
       pfcNode->SetData(pfc);
       mitk::DataStorage::SetOfObjects::Pointer set1 = mitk::DataStorage::SetOfObjects::New();
       set1->push_back(pfcNode);
       storage->Add(pfcNode);
 
       auto input2 = mitk::DataNode::New();
       if (!pf2_path.empty())
       {
         data = mitk::IOUtil::Load(pf2_path)[0];
         input2->SetData(data);
       }
 
       if (operation.empty())
       {
         result = inputTractogram->ExtractFiberSubset(input1, nullptr);
       }
       else if (operation=="NOT")
       {
         pfc->setOperationType(mitk::PlanarFigureComposite::NOT);
         storage->Add(input1, set1);
         result = inputTractogram->ExtractFiberSubset(pfcNode, storage);
       }
       else if (operation=="AND" && input2.IsNotNull())
       {
         pfc->setOperationType(mitk::PlanarFigureComposite::AND);
         storage->Add(input1, set1);
         storage->Add(input2, set1);
         result = inputTractogram->ExtractFiberSubset(pfcNode, storage);
       }
       else if (operation=="OR" && input2.IsNotNull())
       {
         pfc->setOperationType(mitk::PlanarFigureComposite::OR);
         storage->Add(input1, set1);
         storage->Add(input2, set1);
         result = inputTractogram->ExtractFiberSubset(pfcNode, storage);
       }
       else
       {
         std::cout << "Could not process input:";
         std::cout << pf1_path;
         std::cout << pf2_path;
         std::cout << operation;
       }
     }
 
     if (result.IsNotNull())
       mitk::IOUtil::Save(result, outFib);
     else
       std::cout << "No valid fiber bundle extracted.";
   }
   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/FiberProcessing/FiberExtractionRoi.cpp b/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/FiberExtractionRoi.cpp
index a23ae3e9dc..7c63ae10b0 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 <mitkLexicalCast.h>
 #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 = mitk::IOUtil::Load<mitk::Image>(filename);
   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", 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 = mitk::IOUtil::Load<mitk::FiberBundle>(inFib);
 
     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/FiberProcessing/FiberJoin.cpp b/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/FiberJoin.cpp
index 62f5da6516..c7bce4f46f 100755
--- a/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/FiberJoin.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/FiberJoin.cpp
@@ -1,100 +1,100 @@
 /*===================================================================
 
 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 <mitkIOUtil.h>
 #include <metaCommand.h>
 #include "mitkCommandLineParser.h"
 #include <usAny.h>
 #include <mitkIOUtil.h>
-#include <boost/lexical_cast.hpp>
+#include <mitkLexicalCast.h>
 #include <mitkCoreObjectFactory.h>
 #include <mitkPlanarFigure.h>
 #include <mitkPlanarFigureComposite.h>
 #include <mitkFiberBundle.h>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 mitk::FiberBundle::Pointer LoadFib(std::string filename)
 {
   std::vector<mitk::BaseData::Pointer> fibInfile = mitk::IOUtil::Load(filename);
   if( fibInfile.empty() )
     std::cout << "File " << filename << " could not be read!";
   mitk::BaseData::Pointer baseData = fibInfile.at(0);
   return dynamic_cast<mitk::FiberBundle*>(baseData.GetPointer());
 }
 
 /*!
 \brief Join multiple tractograms
 */
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
 
   parser.setTitle("Fiber Join");
   parser.setCategory("Fiber Tracking and Processing Methods");
   parser.setContributor("MIC");
   parser.setDescription("Join multiple tractograms");
 
   parser.setArgumentPrefix("--", "-");
   parser.addArgument("input", "i", mitkCommandLineParser::StringList, "Input:", "input tractograms", us::Any(), false);
   parser.addArgument("out", "o", mitkCommandLineParser::String, "Output:", "output tractogram", us::Any(), false);
 
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0)
     return EXIT_FAILURE;
 
   mitkCommandLineParser::StringContainerType inFibs = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["input"]);
   std::string outFib = us::any_cast<std::string>(parsedArgs["out"]);
 
   if (inFibs.size()<=1)
   {
     std::cout << "More than one input tractogram required!";
     return EXIT_FAILURE;
   }
 
   try
   {
     std::vector< mitk::FiberBundle::Pointer > tractograms;
     mitk::FiberBundle::Pointer result = LoadFib(inFibs.at(0));
     for (std::size_t i=1; i<inFibs.size(); ++i)
     {
       try
       {
         tractograms.push_back(LoadFib(inFibs.at(i)));
       }
       catch(...){ std::cout << "could not load: " << inFibs.at(i); }
     }
     result = result->AddBundles(tractograms);
     mitk::IOUtil::Save(result, outFib);
   }
   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/FiberProcessing/FiberProcessing.cpp b/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/FiberProcessing.cpp
index 6b18065250..77e5da6ecc 100644
--- a/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/FiberProcessing.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/FiberProcessing.cpp
@@ -1,246 +1,246 @@
 /*===================================================================
 
 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 <vector>
 #include <iostream>
 #include <fstream>
 #include <algorithm>
 
 #include <itkImageFileWriter.h>
 #include <itkMetaDataObject.h>
 #include <itkVectorImage.h>
 
 #include <mitkBaseData.h>
 #include <mitkFiberBundle.h>
 #include "mitkCommandLineParser.h"
-#include <boost/lexical_cast.hpp>
+#include <mitkLexicalCast.h>
 #include <mitkCoreObjectFactory.h>
 #include <mitkIOUtil.h>
 #include <itkFiberCurvatureFilter.h>
 
 
 mitk::FiberBundle::Pointer LoadFib(std::string filename)
 {
     std::vector<mitk::BaseData::Pointer> fibInfile = mitk::IOUtil::Load(filename);
     if( fibInfile.empty() )
         std::cout << "File " << filename << " could not be read!";
     mitk::BaseData::Pointer baseData = fibInfile.at(0);
     return dynamic_cast<mitk::FiberBundle*>(baseData.GetPointer());
 }
 
 /*!
 \brief Modify input tractogram: fiber resampling, compression, pruning and transformation.
 */
 int main(int argc, char* argv[])
 {
     mitkCommandLineParser parser;
 
     parser.setTitle("Fiber Processing");
     parser.setCategory("Fiber Tracking and Processing Methods");
     parser.setDescription("Modify input tractogram: fiber resampling, compression, pruning and transformation.");
     parser.setContributor("MIC");
 
     parser.setArgumentPrefix("--", "-");
 
     parser.beginGroup("1. Mandatory arguments:");
     parser.addArgument("input", "i", mitkCommandLineParser::InputFile, "Input:", "Input fiber bundle (.fib, .trk, .tck)", us::Any(), false);
     parser.addArgument("outFile", "o", mitkCommandLineParser::OutputFile, "Output:", "Output fiber bundle (.fib, .trk)", us::Any(), false);
     parser.endGroup();
 
     parser.beginGroup("2. Resampling:");
     parser.addArgument("spline_resampling", "", mitkCommandLineParser::Float, "Spline resampling:", "Resample fiber using splines with the given point distance (in mm)");
     parser.addArgument("linear_resampling", "", mitkCommandLineParser::Float, "Linear resampling:", "Resample fiber linearly with the given point distance (in mm)");
     parser.addArgument("num_resampling", "", mitkCommandLineParser::Int, "Num. fiber points resampling:", "Resample all fibers to the given number of points");
     parser.addArgument("compress", "", mitkCommandLineParser::Float, "Compress:", "Compress fiber using the given error threshold (in mm)");
     parser.endGroup();
 
     parser.beginGroup("3. Filtering:");
     parser.addArgument("min_length", "", mitkCommandLineParser::Float, "Minimum length:", "Minimum fiber length (in mm)");
     parser.addArgument("max_length", "", mitkCommandLineParser::Float, "Maximum length:", "Maximum fiber length (in mm)");
     parser.addArgument("max_angle", "", mitkCommandLineParser::Float, "Maximum angle:", "Maximum angular STDEV over 1cm (in degree)");
     parser.addArgument("remove", "", mitkCommandLineParser::Bool, "Remove fibers exceeding curvature threshold:", "If false, only the high curvature parts are removed");
     parser.endGroup();
 
     parser.beginGroup("4. Transformation:");
     parser.addArgument("mirror", "", mitkCommandLineParser::Int, "Invert coordinates:", "Invert fiber coordinates XYZ (e.g. 010 to invert y-coordinate of each fiber point)");
 
     parser.addArgument("rotate_x", "", mitkCommandLineParser::Float, "Rotate x-axis:", "Rotate around x-axis (in deg)");
     parser.addArgument("rotate_y", "", mitkCommandLineParser::Float, "Rotate y-axis:", "Rotate around y-axis (in deg)");
     parser.addArgument("rotate_z", "", mitkCommandLineParser::Float, "Rotate z-axis:", "Rotate around z-axis (in deg)");
 
     parser.addArgument("scale_x", "", mitkCommandLineParser::Float, "Scale x-axis:", "Scale in direction of x-axis");
     parser.addArgument("scale_y", "", mitkCommandLineParser::Float, "Scale y-axis:", "Scale in direction of y-axis");
     parser.addArgument("scale_z", "", mitkCommandLineParser::Float, "Scale z-axis", "Scale in direction of z-axis");
 
     parser.addArgument("translate_x", "", mitkCommandLineParser::Float, "Translate x-axis:", "Translate in direction of x-axis (in mm)");
     parser.addArgument("translate_y", "", mitkCommandLineParser::Float, "Translate y-axis:", "Translate in direction of y-axis (in mm)");
     parser.addArgument("translate_z", "", mitkCommandLineParser::Float, "Translate z-axis:", "Translate in direction of z-axis (in mm)");
     parser.endGroup();
 
 
     std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
     if (parsedArgs.size()==0)
         return EXIT_FAILURE;
 
     bool remove = false;
     if (parsedArgs.count("remove"))
         remove = us::any_cast<bool>(parsedArgs["remove"]);
 
     float spline_resampling = -1;
     if (parsedArgs.count("spline_resampling"))
         spline_resampling = us::any_cast<float>(parsedArgs["spline_resampling"]);
 
     float linear_resampling = -1;
     if (parsedArgs.count("linear_resampling"))
         linear_resampling = us::any_cast<float>(parsedArgs["linear_resampling"]);
 
     int num_resampling = -1;
     if (parsedArgs.count("num_resampling"))
         num_resampling = us::any_cast<int>(parsedArgs["num_resampling"]);
 
     float compress = -1;
     if (parsedArgs.count("compress"))
         compress = us::any_cast<float>(parsedArgs["compress"]);
 
     float minFiberLength = -1;
     if (parsedArgs.count("min_length"))
         minFiberLength = us::any_cast<float>(parsedArgs["min_length"]);
 
     float maxFiberLength = -1;
     if (parsedArgs.count("max_length"))
         maxFiberLength = us::any_cast<float>(parsedArgs["max_length"]);
 
     float maxAngularDev = -1;
     if (parsedArgs.count("max_angle"))
         maxAngularDev = us::any_cast<float>(parsedArgs["max_angle"]);
 
     int axis = 0;
     if (parsedArgs.count("mirror"))
         axis = us::any_cast<int>(parsedArgs["mirror"]);
 
     float rotateX = 0;
     if (parsedArgs.count("rotate_x"))
         rotateX = us::any_cast<float>(parsedArgs["rotate_x"]);
 
     float rotateY = 0;
     if (parsedArgs.count("rotate_y"))
         rotateY = us::any_cast<float>(parsedArgs["rotate_y"]);
 
     float rotateZ = 0;
     if (parsedArgs.count("rotate_z"))
         rotateZ = us::any_cast<float>(parsedArgs["rotate_z"]);
 
     float scaleX = 0;
     if (parsedArgs.count("scale_x"))
         scaleX = us::any_cast<float>(parsedArgs["scale_x"]);
 
     float scaleY = 0;
     if (parsedArgs.count("scale_y"))
         scaleY = us::any_cast<float>(parsedArgs["scale_y"]);
 
     float scaleZ = 0;
     if (parsedArgs.count("scale_z"))
         scaleZ = us::any_cast<float>(parsedArgs["scale_z"]);
 
     float translateX = 0;
     if (parsedArgs.count("translate_x"))
         translateX = us::any_cast<float>(parsedArgs["translate_x"]);
 
     float translateY = 0;
     if (parsedArgs.count("translate_y"))
         translateY = us::any_cast<float>(parsedArgs["translate_y"]);
 
     float translateZ = 0;
     if (parsedArgs.count("translate_z"))
         translateZ = us::any_cast<float>(parsedArgs["translate_z"]);
 
 
     std::string inFileName = us::any_cast<std::string>(parsedArgs["input"]);
     std::string outFileName = us::any_cast<std::string>(parsedArgs["outFile"]);
 
     try
     {
         mitk::FiberBundle::Pointer fib = LoadFib(inFileName);
 
         if (maxAngularDev>0)
         {
             auto filter = itk::FiberCurvatureFilter::New();
             filter->SetInputFiberBundle(fib);
             filter->SetAngularDeviation(maxAngularDev);
             filter->SetDistance(10);
             filter->SetRemoveFibers(remove);
             filter->Update();
             fib = filter->GetOutputFiberBundle();
         }
 
         if (minFiberLength>0)
             fib->RemoveShortFibers(minFiberLength);
 
         if (maxFiberLength>0)
             fib->RemoveLongFibers(maxFiberLength);
 
         if (spline_resampling>0)
             fib->ResampleSpline(spline_resampling);
 
         if (linear_resampling>0)
             fib->ResampleLinear(linear_resampling);
 
         if (num_resampling>0)
             fib->ResampleToNumPoints(num_resampling);
 
         if (compress>0)
             fib->Compress(compress);
 
         if (axis/100==1)
             fib->MirrorFibers(0);
 
         if ((axis%100)/10==1)
             fib->MirrorFibers(1);
 
         if (axis%10==1)
             fib->MirrorFibers(2);
 
 
         if (rotateX > 0 || rotateY > 0 || rotateZ > 0){
             std::cout << "Rotate " << rotateX << " " << rotateY << " " << rotateZ;
             fib->RotateAroundAxis(rotateX, rotateY, rotateZ);
         }
         if (translateX > 0 || translateY > 0 || translateZ > 0){
             fib->TranslateFibers(translateX, translateY, translateZ);
         }
         if (scaleX > 0 || scaleY > 0 || scaleZ > 0)
             fib->ScaleFibers(scaleX, scaleY, scaleZ);
 
         mitk::IOUtil::Save(fib.GetPointer(), outFileName );
 
     }
     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/FiberProcessing/GetOverlappingTracts.cpp b/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/GetOverlappingTracts.cpp
index 33bbaaafb4..9fe96b6b7e 100755
--- a/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/GetOverlappingTracts.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/GetOverlappingTracts.cpp
@@ -1,173 +1,173 @@
 /*===================================================================
 
 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 <mitkLexicalCast.h>
 #include <mitkCoreObjectFactory.h>
 #include <mitkFiberBundle.h>
 #include <mitkImageCast.h>
 #include <mitkImageToItk.h>
 #include <itksys/SystemTools.hxx>
 #include <itkTractDensityImageFilter.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("input", "i", mitkCommandLineParser::StringList, "Input:", "input tractograms (.fib/.trk/.tck/.dcm)", us::Any(), false);
   parser.addArgument("reference", "r", mitkCommandLineParser::StringList, "Reference:", "reference tractograms or mask images", us::Any(), false);
   parser.addArgument("out", "o", mitkCommandLineParser::OutputDirectory, "Output Folder:", "move input tracts that do/don't overlap here", 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["input"]);
   mitkCommandLineParser::StringContainerType reference = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["reference"]);
 
   std::string out_folder = us::any_cast<std::string>(parsedArgs["out"]);
 
   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
   {
     itk::TractDensityImageFilter< ItkFloatImgType >::Pointer filter = itk::TractDensityImageFilter< ItkFloatImgType >::New();
     filter->SetDoFiberResampling(true);
     filter->SetUpsamplingFactor(0.25);
     filter->SetBinaryOutput(true);
     MITK_INFO << "Loading references";
     std::vector< ItkFloatImgType::Pointer > masks;
     for (auto f : reference)
     {
       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
     }
 
     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)
     {
       ++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);
       fib->ResampleLinear(2);
 
       float overlap = 0;
       float max_overlap = 0;
       std::string max_ref = "-";
       int i = 0;
       std::string overlap_string = ist::GetFilenameWithoutExtension(f);
       for (auto m : masks)
       {
         overlap = fib->GetOverlap(m, false);
         if (overlap>max_overlap)
         {
           max_overlap = overlap;
           max_ref = ist::GetFilenameWithoutExtension(reference.at(i));
         }
         if (use_any_overlap && overlap>=overlap_threshold)
           break;
         overlap_string += " " + ist::GetFilenameWithoutExtension(reference.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";
       logfile2 << overlap_string << "\n";
 
       if (!dont_save_tracts && is_overlapping)
         ist::CopyAFile(f, out_folder + ist::GetFilenameName(f));
       std::cout.rdbuf (old);              // <-- restore
     }
     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/FiberTracking/cmdapps/FiberProcessing/Sift2WeightCopy.cpp b/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/Sift2WeightCopy.cpp
index 18c6358ef8..2dd38fb7e8 100644
--- a/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/Sift2WeightCopy.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/Sift2WeightCopy.cpp
@@ -1,108 +1,108 @@
 /*===================================================================
 
 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 <vector>
 #include <iostream>
 #include <fstream>
 #include <algorithm>
 #include <string>
 #include <istream>
 
 #include <itkImageFileWriter.h>
 #include <itkMetaDataObject.h>
 #include <itkVectorImage.h>
 #include <mitkImageCast.h>
 
 #include <mitkBaseData.h>
 #include <mitkFiberBundle.h>
 #include "mitkCommandLineParser.h"
-#include <boost/lexical_cast.hpp>
+#include <mitkLexicalCast.h>
 #include <mitkCoreObjectFactory.h>
 #include <mitkIOUtil.h>
 #include <itkTractDensityImageFilter.h>
 #include <itkTractsToFiberEndingsImageFilter.h>
 
 
 mitk::FiberBundle::Pointer LoadFib(std::string filename)
 {
     std::vector<mitk::BaseData::Pointer> fibInfile = mitk::IOUtil::Load(filename);
     if( fibInfile.empty() )
         std::cout << "File " << filename << " could not be read!";
     mitk::BaseData::Pointer baseData = fibInfile.at(0);
     return dynamic_cast<mitk::FiberBundle*>(baseData.GetPointer());
 }
 
 /*!
 \brief Import Sift2 Fiber Weights txt file.
 */
 int main(int argc, char* argv[])
 {
     mitkCommandLineParser parser;
 
     parser.setTitle("SIFT2 Fiber Weight Import");
     parser.setCategory("Fiber Tracking and Processing Methods");
     parser.setDescription("Import SIFT2 fiber weights.");
     parser.setContributor("MIC");
 
     parser.setArgumentPrefix("--", "-");
     parser.addArgument("input", "i", mitkCommandLineParser::String, "Input:", "input fiber bundle", us::Any(), false);
     parser.addArgument("weights", "w", mitkCommandLineParser::String, "Weights:", "input weights file (.txt)", us::Any(), false);
     parser.addArgument("output", "o", mitkCommandLineParser::String, "Output:", "output fiber bundle (.fib)", us::Any(), false);
 
 
     std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
     if (parsedArgs.size()==0)
         return EXIT_FAILURE;
 
     std::string inFileName = us::any_cast<std::string>(parsedArgs["input"]);
     std::string weightsFileName = us::any_cast<std::string>(parsedArgs["weights"]);
     std::string outFileName = us::any_cast<std::string>(parsedArgs["output"]);
 
     try
     {
         mitk::FiberBundle::Pointer fib = LoadFib(inFileName);
 
         std::ifstream fin;
         fin.open(weightsFileName);
         if (!fin.good())
           return 1; // exit if file not found
 
         std::vector<float> weights;
         for (float d; fin >> d; ) { weights.push_back(d); }
 
         for(std::size_t i = 0; i != weights.size(); i++) {
           fib->SetFiberWeight(i, weights[i]);
         }
 
         mitk::IOUtil::Save(fib.GetPointer(), outFileName );
     }
     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/FiberProcessing/TractDensity.cpp b/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/TractDensity.cpp
index 13098ed6b0..ead6ac999d 100644
--- a/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/TractDensity.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/TractDensity.cpp
@@ -1,215 +1,215 @@
 /*===================================================================
 
 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 <vector>
 #include <iostream>
 #include <fstream>
 #include <algorithm>
 #include <string>
 
 #include <itkImageFileWriter.h>
 #include <itkMetaDataObject.h>
 #include <itkVectorImage.h>
 #include <mitkImageCast.h>
 
 #include <mitkBaseData.h>
 #include <mitkFiberBundle.h>
 #include "mitkCommandLineParser.h"
-#include <boost/lexical_cast.hpp>
+#include <mitkLexicalCast.h>
 #include <mitkCoreObjectFactory.h>
 #include <mitkIOUtil.h>
 #include <itkTractDensityImageFilter.h>
 #include <itkTractsToFiberEndingsImageFilter.h>
 
 
 mitk::FiberBundle::Pointer LoadFib(std::string filename)
 {
   std::vector<mitk::BaseData::Pointer> fibInfile = mitk::IOUtil::Load(filename);
   if( fibInfile.empty() )
     std::cout << "File " << filename << " could not be read!";
   mitk::BaseData::Pointer baseData = fibInfile.at(0);
   return dynamic_cast<mitk::FiberBundle*>(baseData.GetPointer());
 }
 
 /*!
 \brief Modify input tractogram: fiber resampling, compression, pruning and transformation.
 */
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
 
   parser.setTitle("Tract Density");
   parser.setCategory("Fiber Tracking and Processing Methods");
   parser.setDescription("Generate tract density image, fiber envelope or fiber endpoints image.");
   parser.setContributor("MIC");
 
   parser.setArgumentPrefix("--", "-");
   parser.addArgument("input", "i", mitkCommandLineParser::String, "Input:", "input fiber bundle (.fib)", us::Any(), false);
   parser.addArgument("output", "o", mitkCommandLineParser::String, "Output:", "output image", us::Any(), false);
   parser.addArgument("binary", "", mitkCommandLineParser::Bool, "Binary output:", "calculate binary tract envelope", us::Any());
   parser.addArgument("normalize", "", mitkCommandLineParser::Bool, "Normalized output:", "normalize output to 0-1", us::Any());
   parser.addArgument("endpoints", "", mitkCommandLineParser::Bool, "Output endpoints image:", "calculate image of fiber endpoints instead of mask", us::Any());
   parser.addArgument("reference_image", "", mitkCommandLineParser::String, "Reference image:", "output image will have geometry of this reference image", us::Any());
   parser.addArgument("upsampling", "", mitkCommandLineParser::Float, "Upsampling:", "upsampling", 1.0);
 
 
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0)
     return EXIT_FAILURE;
 
   bool binary = false;
   if (parsedArgs.count("binary"))
     binary = us::any_cast<bool>(parsedArgs["binary"]);
 
   bool endpoints = false;
   if (parsedArgs.count("endpoints"))
     endpoints = us::any_cast<bool>(parsedArgs["endpoints"]);
 
   bool normalize = false;
   if (parsedArgs.count("normalize"))
     normalize = us::any_cast<bool>(parsedArgs["normalize"]);
 
   float upsampling = 1.0;
   if (parsedArgs.count("upsampling"))
     upsampling = us::any_cast<float>(parsedArgs["upsampling"]);
 
   MITK_INFO << "Upsampling: " << upsampling;
 
   std::string reference_image = "";
   if (parsedArgs.count("reference_image"))
     reference_image = us::any_cast<std::string>(parsedArgs["reference_image"]);
 
   std::string inFileName = us::any_cast<std::string>(parsedArgs["input"]);
   std::string outFileName = us::any_cast<std::string>(parsedArgs["output"]);
 
   try
   {
     mitk::FiberBundle::Pointer fib = LoadFib(inFileName);
 
     mitk::Image::Pointer ref_img;
     if (!reference_image.empty())
       ref_img = mitk::IOUtil::Load<mitk::Image>(reference_image);
 
     if (endpoints)
     {
       typedef unsigned int OutPixType;
       typedef itk::Image<OutPixType, 3> OutImageType;
 
       typedef itk::TractsToFiberEndingsImageFilter< OutImageType > ImageGeneratorType;
       ImageGeneratorType::Pointer generator = ImageGeneratorType::New();
       generator->SetFiberBundle(fib);
       generator->SetUpsamplingFactor(upsampling);
 
       if (ref_img.IsNotNull())
       {
         OutImageType::Pointer itkImage = OutImageType::New();
         CastToItkImage(ref_img, itkImage);
         generator->SetInputImage(itkImage);
         generator->SetUseImageGeometry(true);
 
       }
       generator->Update();
 
       // get output image
       typedef itk::Image<OutPixType,3> OutType;
       OutType::Pointer outImg = generator->GetOutput();
       mitk::Image::Pointer img = mitk::Image::New();
       img->InitializeByItk(outImg.GetPointer());
       img->SetVolume(outImg->GetBufferPointer());
 
       mitk::IOUtil::Save(img, outFileName );
     }
     else if (binary)
     {
       typedef unsigned char OutPixType;
       typedef itk::Image<OutPixType, 3> OutImageType;
 
       itk::TractDensityImageFilter< OutImageType >::Pointer generator = itk::TractDensityImageFilter< OutImageType >::New();
       generator->SetFiberBundle(fib);
       generator->SetBinaryOutput(binary);
       generator->SetOutputAbsoluteValues(!normalize);
       generator->SetWorkOnFiberCopy(false);
       generator->SetUpsamplingFactor(upsampling);
 
       if (ref_img.IsNotNull())
       {
         OutImageType::Pointer itkImage = OutImageType::New();
         CastToItkImage(ref_img, itkImage);
         generator->SetInputImage(itkImage);
         generator->SetUseImageGeometry(true);
 
       }
       generator->Update();
 
       // get output image
       typedef itk::Image<OutPixType,3> OutType;
       OutType::Pointer outImg = generator->GetOutput();
       mitk::Image::Pointer img = mitk::Image::New();
       img->InitializeByItk(outImg.GetPointer());
       img->SetVolume(outImg->GetBufferPointer());
 
       mitk::IOUtil::Save(img, outFileName );
     }
     else
     {
       typedef float OutPixType;
       typedef itk::Image<OutPixType, 3> OutImageType;
 
       itk::TractDensityImageFilter< OutImageType >::Pointer generator = itk::TractDensityImageFilter< OutImageType >::New();
       generator->SetFiberBundle(fib);
       generator->SetBinaryOutput(binary);
       generator->SetOutputAbsoluteValues(!normalize);
       generator->SetWorkOnFiberCopy(false);
       generator->SetUpsamplingFactor(upsampling);
 
       if (ref_img.IsNotNull())
       {
         OutImageType::Pointer itkImage = OutImageType::New();
         CastToItkImage(ref_img, itkImage);
         generator->SetInputImage(itkImage);
         generator->SetUseImageGeometry(true);
 
       }
       generator->Update();
 
       // get output image
       typedef itk::Image<OutPixType,3> OutType;
       OutType::Pointer outImg = generator->GetOutput();
       mitk::Image::Pointer img = mitk::Image::New();
       img->InitializeByItk(outImg.GetPointer());
       img->SetVolume(outImg->GetBufferPointer());
 
       mitk::IOUtil::Save(img, outFileName );
     }
 
   }
   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/FiberProcessing/TractDensityFilter.cpp b/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/TractDensityFilter.cpp
index a71cd7d507..1f789fe9ce 100755
--- a/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/TractDensityFilter.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/cmdapps/FiberProcessing/TractDensityFilter.cpp
@@ -1,111 +1,111 @@
 /*===================================================================
 
 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 <mitkLexicalCast.h>
 #include <mitkFiberBundle.h>
 #include <mitkImageCast.h>
 #include <mitkImageToItk.h>
 #include <itksys/SystemTools.hxx>
 #include <itkFiberExtractionFilter.h>
 #include <itkTractDensityImageFilter.h>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 typedef itksys::SystemTools ist;
 typedef itk::Image<float, 3>    ItkFloatImgType;
 
 /*!
 \brief Extract fibers from a tractogram using binary image ROIs
 */
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
 
   parser.setTitle("Filter Outliers by Tract Density");
   parser.setCategory("Fiber Tracking and Processing Methods");
   parser.setContributor("MIC");
 
   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("threshold", "", mitkCommandLineParser::Float, "Threshold:", "positive means ROI image value threshold", 0.05);
   parser.addArgument("overlap", "", mitkCommandLineParser::Float, "Overlap:", "positive means ROI image value threshold", 0.5);
   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"]);
 
   int min_fibers = 0;
   if (parsedArgs.count("min_fibers"))
     min_fibers = us::any_cast<int>(parsedArgs["min_fibers"]);
 
   float overlap = 0.5;
   if (parsedArgs.count("overlap"))
     overlap = us::any_cast<float>(parsedArgs["overlap"]);
 
   float threshold = 0.05;
   if (parsedArgs.count("threshold"))
     threshold = us::any_cast<float>(parsedArgs["threshold"]);
 
   try
   {
     mitk::FiberBundle::Pointer inputTractogram = mitk::IOUtil::Load<mitk::FiberBundle>(inFib);
 
     itk::TractDensityImageFilter< ItkFloatImgType >::Pointer generator = itk::TractDensityImageFilter< ItkFloatImgType >::New();
     generator->SetFiberBundle(inputTractogram);
     generator->SetBinaryOutput(false);
     generator->SetOutputAbsoluteValues(false);
     generator->SetWorkOnFiberCopy(true);
     generator->Update();
 
     itk::FiberExtractionFilter<float>::Pointer extractor = itk::FiberExtractionFilter<float>::New();
     extractor->SetRoiImages({generator->GetOutput()});
     extractor->SetInputFiberBundle(inputTractogram);
     extractor->SetOverlapFraction(overlap);
     extractor->SetInterpolate(true);
     extractor->SetThreshold(threshold);
     extractor->SetNoNegatives(true);
     extractor->Update();
     if (extractor->GetPositives().at(0)->GetNumFibers()>=min_fibers)
       mitk::IOUtil::Save(extractor->GetPositives().at(0), outFib);
   }
   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/Fiberfox.cpp b/Modules/DiffusionImaging/FiberTracking/cmdapps/Fiberfox/Fiberfox.cpp
index 037c650768..46664b3d4e 100755
--- a/Modules/DiffusionImaging/FiberTracking/cmdapps/Fiberfox/Fiberfox.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/cmdapps/Fiberfox/Fiberfox.cpp
@@ -1,249 +1,249 @@
 /*===================================================================
 
 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 <mitkLexicalCast.h>
 #include <mitkPreferenceListReaderOptionsFunctor.h>
 #include <itksys/SystemTools.hxx>
 #include <mitkFiberfoxParameters.h>
 
 using namespace mitk;
 
 /*!
 * \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("Fiberfox");
   parser.setCategory("Diffusion Simulation Tools");
   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("out", "o", mitkCommandLineParser::OutputFile, "Output root:", "output root", us::Any(), false);
   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());
   parser.addArgument("verbose", "v", mitkCommandLineParser::Bool, "Output additional images:", "output volume fraction images etc.", us::Any());
 
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0)
   {
     return EXIT_FAILURE;
   }
   std::string outName = us::any_cast<std::string>(parsedArgs["out"]);
   std::string paramName = us::any_cast<std::string>(parsedArgs["parameters"]);
 
   std::string input="";
   if (parsedArgs.count("input"))
   {
     input = us::any_cast<std::string>(parsedArgs["input"]);
   }
   bool verbose = false;
   if (parsedArgs.count("verbose"))
     verbose = us::any_cast<bool>(parsedArgs["verbose"]);
 
   FiberfoxParameters parameters;
   parameters.LoadParameters(paramName);
 
   // Test if /path/dir is an existing directory:
   std::string file_extension = "";
   if( itksys::SystemTools::FileIsDirectory( outName ) )
   {
     while( *(--(outName.cend())) == '/')
     {
       outName.pop_back();
     }
     outName = outName + '/';
     parameters.m_Misc.m_OutputPath = outName;
     outName = outName + parameters.m_Misc.m_OutputPrefix; // using default m_OutputPrefix as initialized.
   }
   else
   {
     // outName is NOT an existing directory, so we need to remove all trailing slashes:
     while( *(--(outName.cend())) == '/')
     {
       outName.pop_back();
     }
 
     // now split up the given outName into directory and (prefix of) filename:
     if( ! itksys::SystemTools::GetFilenamePath( outName ).empty()
         && itksys::SystemTools::FileIsDirectory(itksys::SystemTools::GetFilenamePath( outName ) ) )
     {
       parameters.m_Misc.m_OutputPath = itksys::SystemTools::GetFilenamePath( outName ) + '/';
     }
     else
     {
       parameters.m_Misc.m_OutputPath = itksys::SystemTools::GetCurrentWorkingDirectory() + '/';
     }
 
     file_extension = itksys::SystemTools::GetFilenameExtension(outName);
     if( ! itksys::SystemTools::GetFilenameWithoutExtension( outName ).empty() )
     {
       parameters.m_Misc.m_OutputPrefix = itksys::SystemTools::GetFilenameWithoutExtension( outName );
     }
     else
     {
       parameters.m_Misc.m_OutputPrefix = "fiberfox";
     }
 
     outName = parameters.m_Misc.m_OutputPath + parameters.m_Misc.m_OutputPrefix;
   }
 
   // check if log file already exists and avoid overwriting existing files:
   std::string NameTest = outName;
   int c = 0;
   while( itksys::SystemTools::FileExists( outName + ".log" )
          && c <= std::numeric_limits<int>::max() )
   {
     outName = NameTest + "_" + boost::lexical_cast<std::string>(c);
     ++c;
   }
 
   mitk::PreferenceListReaderOptionsFunctor functor = mitk::PreferenceListReaderOptionsFunctor({"Diffusion Weighted Images", "Fiberbundles"}, {});
   mitk::BaseData::Pointer inputData = mitk::IOUtil::Load(input, &functor)[0];
 
   itk::TractsToDWIImageFilter< short >::Pointer tractsToDwiFilter = itk::TractsToDWIImageFilter< short >::New();
 
   if ( dynamic_cast<mitk::FiberBundle*>(inputData.GetPointer()) )   // simulate dataset from fibers
   {
     tractsToDwiFilter->SetFiberBundle(dynamic_cast<mitk::FiberBundle*>(inputData.GetPointer()));
 
     if (parsedArgs.count("template"))
     {
       MITK_INFO << "Loading template image";
       typedef itk::VectorImage< short, 3 >    ItkDwiType;
       mitk::BaseData::Pointer templateData = mitk::IOUtil::Load(us::any_cast<std::string>(parsedArgs["template"]), &functor)[0];
       mitk::Image::Pointer dwi = dynamic_cast<mitk::Image*>(templateData.GetPointer());
 
       ItkDwiType::Pointer itkVectorImagePointer = mitk::DiffusionPropertyHelper::GetItkVectorImage(dwi);
 
       parameters.m_SignalGen.m_ImageRegion = itkVectorImagePointer->GetLargestPossibleRegion();
       parameters.m_SignalGen.m_ImageSpacing = itkVectorImagePointer->GetSpacing();
       parameters.m_SignalGen.m_ImageOrigin = itkVectorImagePointer->GetOrigin();
       parameters.m_SignalGen.m_ImageDirection = itkVectorImagePointer->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());
     }
   }
   else if ( dynamic_cast<mitk::Image*>(inputData.GetPointer()) )  // add artifacts to existing image
   {
     typedef itk::VectorImage< short, 3 >    ItkDwiType;
     mitk::Image::Pointer diffImg = dynamic_cast<mitk::Image*>(inputData.GetPointer());
     ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
     mitk::CastToItkImage(diffImg, itkVectorImagePointer);
 
     parameters.m_SignalGen.m_SignalScale = 1;
     parameters.m_SignalGen.m_ImageRegion = itkVectorImagePointer->GetLargestPossibleRegion();
     parameters.m_SignalGen.m_ImageSpacing = itkVectorImagePointer->GetSpacing();
     parameters.m_SignalGen.m_ImageOrigin = itkVectorImagePointer->GetOrigin();
     parameters.m_SignalGen.m_ImageDirection = itkVectorImagePointer->GetDirection();
     parameters.SetBvalue(static_cast<mitk::FloatProperty*>
                                       (diffImg->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )
                                       ->GetValue());
     parameters.SetGradienDirections( static_cast<mitk::GradientDirectionsProperty*>
                                                  ( diffImg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )
                                                  ->GetGradientDirectionsContainer() );
 
     tractsToDwiFilter->SetInputImage(itkVectorImagePointer);
   }
 
   if (verbose)
   {
     MITK_DEBUG << outName << ".ffp";
     parameters.SaveParameters(outName+".ffp");
   }
   tractsToDwiFilter->SetParameters(parameters);
   tractsToDwiFilter->Update();
 
   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();
 
   if (file_extension=="")
     mitk::IOUtil::Save(image, "application/vnd.mitk.nii.gz", outName+".nii.gz");
   else if (file_extension==".nii" || file_extension==".nii.gz")
     mitk::IOUtil::Save(image, "application/vnd.mitk.nii.gz", outName+file_extension);
   else
     mitk::IOUtil::Save(image, outName+file_extension);
 
   if (verbose)
   {
     std::vector< itk::TractsToDWIImageFilter< short >::ItkDoubleImgType::Pointer > volumeFractions = tractsToDwiFilter->GetVolumeFractions();
     for (unsigned int k=0; k<volumeFractions.size(); k++)
     {
       mitk::Image::Pointer image = mitk::Image::New();
       image->InitializeByItk(volumeFractions.at(k).GetPointer());
       image->SetVolume(volumeFractions.at(k)->GetBufferPointer());
       mitk::IOUtil::Save(image, outName+"_Compartment"+boost::lexical_cast<std::string>(k+1)+".nii.gz");
     }
 
     if (tractsToDwiFilter->GetPhaseImage().IsNotNull())
     {
       mitk::Image::Pointer image = mitk::Image::New();
       itk::TractsToDWIImageFilter< short >::DoubleDwiType::Pointer itkPhase = tractsToDwiFilter->GetPhaseImage();
       image = mitk::GrabItkImageMemory( itkPhase.GetPointer() );
       mitk::IOUtil::Save(image, outName+"_Phase.nii.gz");
     }
 
     if (tractsToDwiFilter->GetKspaceImage().IsNotNull())
     {
       mitk::Image::Pointer image = mitk::Image::New();
       itk::TractsToDWIImageFilter< short >::DoubleDwiType::Pointer itkImage = tractsToDwiFilter->GetKspaceImage();
       image = mitk::GrabItkImageMemory( itkImage.GetPointer() );
       mitk::IOUtil::Save(image, outName+"_kSpace.nii.gz");
     }
 
     int c = 1;
     std::vector< itk::TractsToDWIImageFilter< short >::DoubleDwiType::Pointer > output_real = tractsToDwiFilter->GetOutputImagesReal();
     for (auto real : output_real)
     {
       mitk::Image::Pointer image = mitk::Image::New();
       image->InitializeByItk(real.GetPointer());
       image->SetVolume(real->GetBufferPointer());
       mitk::IOUtil::Save(image, outName+"_Coil-"+boost::lexical_cast<std::string>(c)+"-real.nii.gz");
       ++c;
     }
 
     c = 1;
     std::vector< itk::TractsToDWIImageFilter< short >::DoubleDwiType::Pointer > output_imag = tractsToDwiFilter->GetOutputImagesImag();
     for (auto imag : output_imag)
     {
       mitk::Image::Pointer image = mitk::Image::New();
       image->InitializeByItk(imag.GetPointer());
       image->SetVolume(imag->GetBufferPointer());
       mitk::IOUtil::Save(image, outName+"_Coil-"+boost::lexical_cast<std::string>(c)+"-imag.nii.gz");
       ++c;
     }
   }
 
   return EXIT_SUCCESS;
 }
 
diff --git a/Modules/DiffusionImaging/FiberTracking/cmdapps/Fiberfox/FiberfoxOptimization.cpp b/Modules/DiffusionImaging/FiberTracking/cmdapps/Fiberfox/FiberfoxOptimization.cpp
index 66c83ba95c..070cf357b2 100644
--- a/Modules/DiffusionImaging/FiberTracking/cmdapps/Fiberfox/FiberfoxOptimization.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/cmdapps/Fiberfox/FiberfoxOptimization.cpp
@@ -1,831 +1,831 @@
 /*===================================================================
 
 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 <random>
 
 #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 <mitkLexicalCast.h>
 #include <mitkPreferenceListReaderOptionsFunctor.h>
 #include <itksys/SystemTools.hxx>
 #include <mitkFiberfoxParameters.h>
 #include <random>
 #include <mitkTensorImage.h>
 #include <itkTensorDerivedMeasurementsFilter.h>
 #include <itkAdcImageFilter.h>
 #include <itkMaskedImageToHistogramFilter.h>
 #include <itkTdiToVolumeFractionFilter.h>
 #include <itkImageFileReader.h>
 
 using namespace mitk;
 
 double CalcErrorSignal(const std::vector<double>& histo_mod, itk::VectorImage< short, 3 >* reference, itk::VectorImage< short, 3 >* simulation, itk::Image< unsigned char,3 >::Pointer mask, itk::Image< double,3 >::Pointer fa)
 {
   typedef itk::Image< double, 3 > DoubleImageType;
   typedef itk::VectorImage< short, 3 > DwiImageType;
   if (fa.IsNotNull())
   {
     itk::ImageRegionIterator< DwiImageType > it1(reference, reference->GetLargestPossibleRegion());
     itk::ImageRegionIterator< DwiImageType > it2(simulation, simulation->GetLargestPossibleRegion());
     itk::ImageRegionConstIterator< DoubleImageType > it3(fa, fa->GetLargestPossibleRegion());
 
     unsigned int count = 0;
     double error = 0;
     while(!it1.IsAtEnd())
     {
       if (mask.IsNull() || (mask.IsNotNull() && mask->GetLargestPossibleRegion().IsInside(it1.GetIndex()) && mask->GetPixel(it1.GetIndex())>0) )
       {
         double fa = it3.Get();
         if (fa>0)
         {
           double mod = 1.0;
           for (int i=histo_mod.size()-1; i>=0; --i)
             if (fa >= (double)i/histo_mod.size())
             {
               mod = histo_mod.at(i);
               break;
             }
 
           for (unsigned int i=0; i<reference->GetVectorLength(); ++i)
           {
             if (it1.Get()[i]>0)
             {
               double diff = (double)it2.Get()[i]/it1.Get()[i] - 1.0;
               error += std::pow(mod, 4) * fabs(diff);
               count++;
             }
           }
         }
       }
       ++it1;
       ++it2;
       ++it3;
     }
     return error/count;
   }
   else
   {
     itk::ImageRegionIterator< DwiImageType > it1(reference, reference->GetLargestPossibleRegion());
     itk::ImageRegionIterator< DwiImageType > it2(simulation, simulation->GetLargestPossibleRegion());
 
     unsigned int count = 0;
     double error = 0;
     while(!it1.IsAtEnd())
     {
       if (mask.IsNull() || (mask.IsNotNull() && mask->GetLargestPossibleRegion().IsInside(it1.GetIndex()) && mask->GetPixel(it1.GetIndex())>0) )
       {
         for (unsigned int i=0; i<reference->GetVectorLength(); ++i)
         {
           if (it1.Get()[i]>0)
           {
             double diff = (double)it2.Get()[i]/it1.Get()[i] - 1.0;
             error += fabs(diff);
             count++;
           }
         }
       }
       ++it1;
       ++it2;
     }
     return error/count;
   }
   return -1;
 }
 
 double CalcErrorFA(const std::vector<double>& histo_mod, mitk::Image::Pointer dwi1, itk::VectorImage< short, 3 >* dwi2, itk::Image< unsigned char,3 >::Pointer mask, itk::Image< double,3 >::Pointer fa1, itk::Image< double,3 >::Pointer md1, bool b0_contrast)
 {
   typedef itk::TensorDerivedMeasurementsFilter<double> MeasurementsType;
   typedef itk::Image< double, 3 > DoubleImageType;
   typedef  itk::VectorImage< short, 3 > DwiType;
 
   DwiType::Pointer dwi1_itk = mitk::DiffusionPropertyHelper::GetItkVectorImage(dwi1);
   typedef itk::DiffusionTensor3DReconstructionImageFilter<short, short, double > TensorReconstructionImageFilterType;
   DoubleImageType::Pointer fa2;
   {
     mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::Pointer gradientContainerCopy = mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::New();
     for(auto it = mitk::DiffusionPropertyHelper::GetGradientContainer(dwi1)->Begin(); it != mitk::DiffusionPropertyHelper::GetGradientContainer(dwi1)->End(); it++)
       gradientContainerCopy->push_back(it.Value());
 
     TensorReconstructionImageFilterType::Pointer tensorReconstructionFilter = TensorReconstructionImageFilterType::New();
     tensorReconstructionFilter->SetBValue( mitk::DiffusionPropertyHelper::GetReferenceBValue(dwi1) );
     tensorReconstructionFilter->SetGradientImage(gradientContainerCopy, dwi2 );
     tensorReconstructionFilter->Update();
 
     MeasurementsType::Pointer measurementsCalculator = MeasurementsType::New();
     measurementsCalculator->SetInput( tensorReconstructionFilter->GetOutput() );
     measurementsCalculator->SetMeasure(MeasurementsType::FA);
     measurementsCalculator->Update();
     fa2 = measurementsCalculator->GetOutput();
   }
 
   DoubleImageType::Pointer md2;
   if (md1.IsNotNull())
   {
     typedef itk::AdcImageFilter< short, double > AdcFilterType;
     AdcFilterType::Pointer filter = AdcFilterType::New();
     filter->SetInput( dwi2 );
     filter->SetGradientDirections( mitk::DiffusionPropertyHelper::GetGradientContainer(dwi1) );
     filter->SetB_value( mitk::DiffusionPropertyHelper::GetReferenceBValue(dwi1) );
     filter->SetFitSignal(false);
     filter->Update();
     md2 = filter->GetOutput();
   }
 
   itk::ImageRegionConstIterator< DoubleImageType > it1(fa1, fa1->GetLargestPossibleRegion());
   itk::ImageRegionConstIterator< DoubleImageType > it2(fa2, fa2->GetLargestPossibleRegion());
 
   itk::ImageRegionConstIterator< itk::VectorImage< short, 3 > > it_diff1(dwi1_itk, dwi1_itk->GetLargestPossibleRegion());
   itk::ImageRegionConstIterator< itk::VectorImage< short, 3 > > it_diff2(dwi2, dwi2->GetLargestPossibleRegion());
 
   unsigned int count = 0;
   double error = 0;
   if (md1.IsNotNull() && md2.IsNotNull())
   {
     itk::ImageRegionConstIterator< DoubleImageType > it3(md1, md1->GetLargestPossibleRegion());
     itk::ImageRegionConstIterator< DoubleImageType > it4(md2, md2->GetLargestPossibleRegion());
     while(!it1.IsAtEnd())
     {
       if (mask.IsNull() || (mask.IsNotNull() && mask->GetLargestPossibleRegion().IsInside(it1.GetIndex()) && mask->GetPixel(it1.GetIndex())>0) )
       {
         double fa = it1.Get();
         if (fa>0 && it3.Get()>0)
         {
           double mod = 1.0;
           for (int i=histo_mod.size()-1; i>=0; --i)
             if (fa >= (double)i/histo_mod.size())
             {
               mod = histo_mod.at(i);
               break;
             }
 
           double fa_diff = std::fabs(it2.Get()/fa - 1.0);
           double md_diff = std::fabs(it4.Get()/it3.Get() - 1.0);
           error += std::pow(mod, 4) * (fa_diff + md_diff);
           count += 2;
 
           if (b0_contrast && it_diff1.Get()[0]>0)
           {
             double b0_diff = (double)it_diff2.Get()[0]/it_diff1.Get()[0] - 1.0;
             error += std::pow(mod, 4) * std::fabs(b0_diff);
             ++count;
           }
         }
       }
       ++it1;
       ++it2;
       ++it3;
       ++it4;
       ++it_diff1;
       ++it_diff2;
     }
   }
   else
   {
     unsigned int count = 0;
     double error = 0;
     while(!it1.IsAtEnd())
     {
       if (mask.IsNull() || (mask.IsNotNull() && mask->GetLargestPossibleRegion().IsInside(it1.GetIndex()) && mask->GetPixel(it1.GetIndex())>0) )
       {
         double fa = it1.Get();
         if (fa>0)
         {
           double mod = 1.0;
           for (int i=histo_mod.size()-1; i>=0; --i)
             if (fa >= (double)i/histo_mod.size())
             {
               mod = histo_mod.at(i);
               break;
             }
 
           double fa_diff = fabs(it2.Get()/fa - 1.0);
           error += std::pow(mod, 4) * fa_diff;
           ++count;
 
           if (b0_contrast && it_diff1.Get()[0]>0)
           {
             double b0_diff = (double)it_diff2.Get()[0]/it_diff1.Get()[0] - 1.0;
             error += std::pow(mod, 4) * std::fabs(b0_diff);
             ++count;
           }
         }
       }
       ++it1;
       ++it2;
       ++it_diff1;
       ++it_diff2;
     }
   }
 
   return error/count;
 }
 
 FiberfoxParameters MakeProposalScale(FiberfoxParameters old_params, double temperature)
 {
   FiberfoxParameters new_params(old_params);
   std::random_device r;
   std::default_random_engine randgen(r());
 
   std::normal_distribution<double> normal_dist(0, new_params.m_SignalGen.m_SignalScale*0.1*temperature);
   double add = 0;
   while (add == 0)
     add =  normal_dist(randgen);
   new_params.m_SignalGen.m_SignalScale += add;
   MITK_INFO << "Proposal Signal Scale: " << new_params.m_SignalGen.m_SignalScale << " (" << add << ")";
   return new_params;
 }
 
 FiberfoxParameters MakeProposalRelaxation(FiberfoxParameters old_params, double temperature)
 {
   FiberfoxParameters new_params(old_params);
   std::random_device r;
   std::default_random_engine randgen(r());
   std::uniform_int_distribution<int> uint1(0, 3);
   int prop = uint1(randgen);
 
   switch(prop)
   {
   case 0:
   {
     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);
 
     if ( (t2+add)*1.5 > new_params.m_NonFiberModelList[model_index]->GetT1() )
       add = -add;
     t2 += add;
     new_params.m_NonFiberModelList[model_index]->SetT2(t2);
     MITK_INFO << "Proposal T2 (Non-Fiber " << model_index << "): " << t2 << " (" << add << ")";
     break;
   }
   case 1:
   {
     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);
 
     if ( (t2+add)*1.5 > new_params.m_FiberModelList[model_index]->GetT1() )
       add = -add;
     t2 += add;
     new_params.m_FiberModelList[model_index]->SetT2(t2);
     MITK_INFO << "Proposal T2 (Fiber " << model_index << "): " << t2 << " (" << add << ")";
     break;
   }
   case 2:
   {
     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);
 
     if ( t1+add < new_params.m_NonFiberModelList[model_index]->GetT2() * 1.5 )
       add = -add;
     t1 += add;
     new_params.m_NonFiberModelList[model_index]->SetT1(t1);
     MITK_INFO << "Proposal T1 (Non-Fiber " << model_index << "): " << t1 << " (" << add << ")";
     break;
   }
   case 3:
   {
     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);
 
     if ( t1+add < new_params.m_FiberModelList[model_index]->GetT2() * 1.5 )
       add = -add;
     t1 += add;
     new_params.m_FiberModelList[model_index]->SetT1(t1);
     MITK_INFO << "Proposal T1 (Fiber " << model_index << "): " << t1 << " (" << add << ")";
     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);
 
   if (d+add > 0.0025)
     d -= add;
   else if ( d+add < 0.0 )
     d -= add;
   else
     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);
     double new_d = UpdateDiffusivity(m->GetDiffusivity(), temperature);
     MITK_INFO << "d: " << new_d << " (" << new_d-m->GetDiffusivity() << ")";
     m->SetDiffusivity(new_d);
   }
   else  if (dynamic_cast<mitk::TensorModel<>*>(signalModel))
   {
     mitk::TensorModel<>* m = dynamic_cast<mitk::TensorModel<>*>(signalModel);
     double new_d1 = UpdateDiffusivity(m->GetDiffusivity1(), temperature);
     double new_d2 = UpdateDiffusivity(m->GetDiffusivity2(), temperature);
     while (new_d1<new_d2)
       new_d2 = UpdateDiffusivity(m->GetDiffusivity2(), temperature);
 
     MITK_INFO << "d1: " << new_d1 << " (" << new_d1-m->GetDiffusivity1() << ")";
     MITK_INFO << "d2: " << new_d2 << " (" << new_d2-m->GetDiffusivity2() << ")";
 
     m->SetDiffusivity1(new_d1);
     m->SetDiffusivity2(new_d2);
     m->SetDiffusivity3(new_d2);
   }
   else  if (dynamic_cast<mitk::BallModel<>*>(signalModel))
   {
     mitk::BallModel<>* m = dynamic_cast<mitk::BallModel<>*>(signalModel);
 
     double new_d = UpdateDiffusivity(m->GetDiffusivity(), temperature);
     MITK_INFO << "d: " << new_d << " (" << new_d-m->GetDiffusivity() << ")";
     m->SetDiffusivity(new_d);
   }
   else if (dynamic_cast<mitk::AstroStickModel<>*>(signalModel))
   {
     mitk::AstroStickModel<>* m = dynamic_cast<mitk::AstroStickModel<>*>(signalModel);
 
     double new_d = UpdateDiffusivity(m->GetDiffusivity(), temperature);
     MITK_INFO << "d: " << new_d << " (" << new_d-m->GetDiffusivity() << ")";
     m->SetDiffusivity(new_d);
   }
 }
 
 FiberfoxParameters MakeProposalDiff(FiberfoxParameters old_params, double temperature)
 {
   FiberfoxParameters new_params(old_params);
 
   std::random_device r;
   std::default_random_engine randgen(r());
 
   std::uniform_int_distribution<int> uint1(0, new_params.m_NonFiberModelList.size() + new_params.m_FiberModelList.size() - 1);
   unsigned int prop = uint1(randgen);
 
   if (prop<new_params.m_NonFiberModelList.size())
   {
     MITK_INFO << "Proposal D (Non-Fiber " << prop << ")";
     ProposeDiffusivities( new_params.m_NonFiberModelList[prop], temperature );
   }
   else
   {
     prop -= new_params.m_NonFiberModelList.size();
     MITK_INFO << "Proposal D (Fiber " << prop  << ")";
     ProposeDiffusivities( new_params.m_FiberModelList[prop], temperature );
   }
 
   return new_params;
 }
 
 FiberfoxParameters MakeProposalVolume(double old_tdi_thr, double old_sqrt, double& new_tdi_thr, double& new_sqrt, FiberfoxParameters old_params, std::vector< itk::Image< double, 3 >::Pointer > frac, double temperature)
 {
   FiberfoxParameters new_params(old_params);
 
   MITK_INFO << "Proposal Volume";
   std::random_device r;
   std::default_random_engine randgen(r());
 
   {
     std::normal_distribution<double> normal_dist(0, old_tdi_thr*0.1*temperature);
     new_tdi_thr = old_tdi_thr + normal_dist(randgen);
     while (new_tdi_thr<=0.01)
       new_tdi_thr = old_tdi_thr + normal_dist(randgen);
   }
   {
     std::normal_distribution<double> normal_dist(0, old_sqrt*0.1*temperature);
     new_sqrt = old_sqrt + normal_dist(randgen);
     while (new_sqrt<=0.01)
       new_sqrt = old_sqrt + normal_dist(randgen);
   }
 
   itk::TdiToVolumeFractionFilter< double >::Pointer fraction_generator = itk::TdiToVolumeFractionFilter< double >::New();
   fraction_generator->SetTdiThreshold(new_tdi_thr);
   fraction_generator->SetSqrt(new_sqrt);
   fraction_generator->SetInput(0, frac.at(0));
   fraction_generator->SetInput(1, frac.at(1));
   fraction_generator->SetInput(2, frac.at(2));
   fraction_generator->SetInput(3, frac.at(3));
   fraction_generator->SetInput(4, frac.at(4));
   fraction_generator->Update();
 
   new_params.m_FiberModelList[0]->SetVolumeFractionImage(fraction_generator->GetOutput(0));
   new_params.m_FiberModelList[1]->SetVolumeFractionImage(fraction_generator->GetOutput(1));
   new_params.m_NonFiberModelList[0]->SetVolumeFractionImage(fraction_generator->GetOutput(2));
   new_params.m_NonFiberModelList[1]->SetVolumeFractionImage(fraction_generator->GetOutput(3));
 
   MITK_INFO << "TDI Threshold: " << new_tdi_thr << " (" << new_tdi_thr-old_tdi_thr << ")";
   MITK_INFO << "SQRT: " << new_sqrt << " (" << new_sqrt-old_sqrt << ")";
 
   return new_params;
 }
 
 /*!
 * \brief Command line interface to optimize Fiberfox parameters.
 */
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
   parser.setTitle("FiberfoxOptimization");
   parser.setCategory("Optimize Fiberfox Parameters");
   parser.setContributor("MIC");
   parser.setArgumentPrefix("--", "-");
 
   parser.beginGroup("1. Mandatory Input:");
   parser.addArgument("parameters", "p", mitkCommandLineParser::InputFile, "Parameter File:", "fiberfox parameter file (.ffp)", us::Any(), false);
   parser.addArgument("tracts", "t", mitkCommandLineParser::String, "Input Tractogram:", "Input tractogram.", us::Any(), false);
   parser.addArgument("out_folder", "o", mitkCommandLineParser::String, "Output Folder:", "", us::Any(), false);
   parser.addArgument("dmri", "d", mitkCommandLineParser::String, "Target image:", "Target dMRI to approximate.", us::Any(), false);
   parser.addArgument("mask", "", mitkCommandLineParser::InputFile, "Mask image:", "Error is only calculated inside the mask image", false);
   parser.endGroup();
 
   parser.beginGroup("2. Parameters to optimize:");
   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:", "Don't optimize relaxation times");
   parser.addArgument("no_scale", "", mitkCommandLineParser::Bool, "Don't optimize signal scale:", "Don't optimize global signal scale");
   parser.endGroup();
 
   parser.beginGroup("3. Error measure:");
   parser.addArgument("fa_error", "", mitkCommandLineParser::Bool, "Optimize FA", "Optimize FA instead of raw signal. Requires FA image.");
   parser.addArgument("fa_image", "", mitkCommandLineParser::InputFile, "FA image:", "Weight error by FA histogram. Always necessary with option fa_error!");
   parser.addArgument("md_image", "", mitkCommandLineParser::InputFile, "MD image:", "Optimize MD in conjunction with FA (recommended when optimizing FA).");
   parser.endGroup();
 
   parser.beginGroup("4. Optimization of volume fraction maps:");
   parser.addArgument("tdi", "", mitkCommandLineParser::InputFile, "TDI:", "tract density image");
   parser.addArgument("wm", "", mitkCommandLineParser::InputFile, "WM:", "white matter volume fraction image");
   parser.addArgument("gm", "", mitkCommandLineParser::InputFile, "GM:", "gray matter volume fraction image");
   parser.addArgument("dgm", "", mitkCommandLineParser::InputFile, "DGM:", "subcortical gray matter volume fraction image");
   parser.addArgument("csf", "", mitkCommandLineParser::InputFile, "CSF:", "CSF volume fraction image");
   parser.addArgument("tdi_threshold", "", mitkCommandLineParser::Float, "", "", 0.75);
   parser.addArgument("sqrt", "", mitkCommandLineParser::Float, "", "", 1.0);
   parser.endGroup();
 
   parser.beginGroup("5. General parameters:");
   parser.addArgument("iterations", "", mitkCommandLineParser::Int, "Iterations:", "Number of optimizations steps", 1000);
   parser.addArgument("start_temp", "", mitkCommandLineParser::Float, "Start temperature:", "Higher temperature means larger parameter change proposals", 1.0);
   parser.addArgument("end_temp", "", mitkCommandLineParser::Float, "End temperature:", "Higher temperature means larger parameter change proposals", 0.1);
   parser.endGroup();
 
   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 out_folder = us::any_cast<std::string>(parsedArgs["out_folder"]);
   std::string tract_file = us::any_cast<std::string>(parsedArgs["tracts"]);
 
   MITK_INFO << "Loading target dMRI and parameters";
   FiberfoxParameters parameters;
   parameters.LoadParameters(paramName);
   typedef itk::VectorImage< short, 3 >    ItkDwiType;
   mitk::PreferenceListReaderOptionsFunctor functor = mitk::PreferenceListReaderOptionsFunctor({"Diffusion Weighted Images", "Fiberbundles"}, {});
   auto dwi = mitk::IOUtil::Load<mitk::Image>(us::any_cast<std::string>(parsedArgs["dmri"]), &functor);
   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());
 
   auto tracts = mitk::IOUtil::Load<mitk::FiberBundle>(tract_file, &functor);
 
   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"]);
 
   float tdi_threshold=0.75;
   if (parsedArgs.count("tdi_threshold"))
     tdi_threshold = us::any_cast<float>(parsedArgs["tdi_threshold"]);
 
   float sqrt=1.0;
   if (parsedArgs.count("sqrt"))
     sqrt = us::any_cast<float>(parsedArgs["sqrt"]);
 
   bool fa_error=false;
   if (parsedArgs.count("fa_error"))
     fa_error = true;
 
   std::string fa_file = "";
   if (parsedArgs.count("fa_image"))
     fa_file = us::any_cast<std::string>(parsedArgs["fa_image"]);
 
   std::string md_file = "";
   if (parsedArgs.count("md_image"))
     md_file = us::any_cast<std::string>(parsedArgs["md_image"]);
 
   std::vector< int > possible_proposals;
   if (!parsedArgs.count("no_diff"))
   {
     MITK_INFO << "Optimizing diffusivities";
     possible_proposals.push_back(0);
   }
   if (!parsedArgs.count("no_relax"))
   {
     MITK_INFO << "Optimizing relaxation constants";
     possible_proposals.push_back(1);
   }
   if (!parsedArgs.count("no_scale"))
   {
     MITK_INFO << "Optimizing global signal scale";
     possible_proposals.push_back(2);
   }
   if (possible_proposals.empty())
   {
     MITK_INFO << "Incompatible options. Nothing to optimize.";
     return EXIT_FAILURE;
   }
 
   itk::ImageFileReader< itk::Image< unsigned char, 3 > >::Pointer reader = itk::ImageFileReader< itk::Image< unsigned char, 3 > >::New();
   reader->SetFileName( us::any_cast<std::string>(parsedArgs["mask"]) );
   reader->Update();
   itk::Image< unsigned char,3 >::Pointer mask = reader->GetOutput();
 
   std::vector< itk::Image< double, 3 >::Pointer > fracs;
   if ( parsedArgs.count("tdi")>0 && parsedArgs.count("wm")>0 && parsedArgs.count("gm")>0 && parsedArgs.count("dgm")>0 && parsedArgs.count("csf")>0 )
   {
     MITK_INFO << "Optimizing volume fractions";
     {
       itk::ImageFileReader< itk::Image< double, 3 > >::Pointer reader = itk::ImageFileReader< itk::Image< double, 3 > >::New();
       reader->SetFileName( us::any_cast<std::string>(parsedArgs["tdi"]) );
       reader->Update();
       fracs.push_back(reader->GetOutput());
     }
     {
       itk::ImageFileReader< itk::Image< double, 3 > >::Pointer reader = itk::ImageFileReader< itk::Image< double, 3 > >::New();
       reader->SetFileName( us::any_cast<std::string>(parsedArgs["wm"]) );
       reader->Update();
       fracs.push_back(reader->GetOutput());
     }
     {
       itk::ImageFileReader< itk::Image< double, 3 > >::Pointer reader = itk::ImageFileReader< itk::Image< double, 3 > >::New();
       reader->SetFileName( us::any_cast<std::string>(parsedArgs["gm"]) );
       reader->Update();
       fracs.push_back(reader->GetOutput());
     }
     {
       itk::ImageFileReader< itk::Image< double, 3 > >::Pointer reader = itk::ImageFileReader< itk::Image< double, 3 > >::New();
       reader->SetFileName( us::any_cast<std::string>(parsedArgs["dgm"]) );
       reader->Update();
       fracs.push_back(reader->GetOutput());
     }
     {
       itk::ImageFileReader< itk::Image< double, 3 > >::Pointer reader = itk::ImageFileReader< itk::Image< double, 3 > >::New();
       reader->SetFileName( us::any_cast<std::string>(parsedArgs["csf"]) );
       reader->Update();
       fracs.push_back(reader->GetOutput());
     }
     MITK_INFO << "Initial sqrt: " << sqrt;
     MITK_INFO << "Initial TDI threshold: " << tdi_threshold;
 
     possible_proposals.push_back(3);
   }
 
   std::vector< double > histogram_modifiers;
   itk::Image< double,3 >::Pointer fa_image = nullptr;
   if (fa_file.compare("")!=0)
   {
     itk::ImageFileReader< itk::Image< double, 3 > >::Pointer reader = itk::ImageFileReader< itk::Image< double, 3 > >::New();
     reader->SetFileName( fa_file );
     reader->Update();
     fa_image = reader->GetOutput();
 
     int binsPerDimension = 20;
     using ImageToHistogramFilterType = itk::Statistics::MaskedImageToHistogramFilter< itk::Image< double,3 >, itk::Image< unsigned char,3 > >;
 
     ImageToHistogramFilterType::HistogramType::MeasurementVectorType lowerBound(binsPerDimension);
     lowerBound.Fill(0.0);
 
     ImageToHistogramFilterType::HistogramType::MeasurementVectorType upperBound(binsPerDimension);
     upperBound.Fill(1.0);
 
     ImageToHistogramFilterType::HistogramType::SizeType size(1);
     size.Fill(binsPerDimension);
 
     ImageToHistogramFilterType::Pointer imageToHistogramFilter = ImageToHistogramFilterType::New();
     imageToHistogramFilter->SetInput( fa_image );
     imageToHistogramFilter->SetHistogramBinMinimum( lowerBound );
     imageToHistogramFilter->SetHistogramBinMaximum( upperBound );
     imageToHistogramFilter->SetHistogramSize( size );
     imageToHistogramFilter->SetMaskImage(mask);
     imageToHistogramFilter->SetMaskValue(1);
     imageToHistogramFilter->Update();
 
     ImageToHistogramFilterType::HistogramType* histogram = imageToHistogramFilter->GetOutput();
     unsigned int max = 0;
     for(unsigned int i = 0; i < histogram->GetSize()[0]; ++i)
     {
       if (histogram->GetFrequency(i)>max)
         max = histogram->GetFrequency(i);
     }
     MITK_INFO << "FA histogram modifiers:";
     for(unsigned int i = 0; i < histogram->GetSize()[0]; ++i)
     {
       histogram_modifiers.push_back((double)max/histogram->GetFrequency(i));
       MITK_INFO << std::pow(histogram_modifiers.back(), 4);
     }
     if (fa_error)
       MITK_INFO << "Using FA error measure.";
   }
   itk::Image< double,3 >::Pointer md_image = nullptr;
   if (md_file.compare("")!=0)
   {
     itk::ImageFileReader< itk::Image< double, 3 > >::Pointer reader = itk::ImageFileReader< itk::Image< double, 3 > >::New();
     reader->SetFileName( md_file );
     reader->Update();
     md_image = reader->GetOutput();
     if (fa_error)
       MITK_INFO << "Using MD error measure.";
   }
   if (fa_error && fa_image.IsNull())
   {
     MITK_INFO << "Incompatible options. Need FA image to calculate FA error.";
     return EXIT_FAILURE;
   }
 
   itk::TractsToDWIImageFilter< short >::Pointer tractsToDwiFilter = itk::TractsToDWIImageFilter< short >::New();
   tractsToDwiFilter->SetFiberBundle(tracts);
   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, out_folder + "/initial.dwi");
   }
 
 
   double old_tdi_thr = tdi_threshold;
   double old_sqrt = sqrt;
   double new_tdi_thr;
   double new_sqrt;
   MITK_INFO << "\n\n";
   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;
 
   double last_error = 9999999;
   if (fa_error)
   {
     MITK_INFO << "Calculating FA error";
     last_error = CalcErrorFA(histogram_modifiers, dwi, sim, mask, fa_image, md_image, true);
   }
   else
   {
     MITK_INFO << "Calculating raw-image error";
     last_error = CalcErrorSignal(histogram_modifiers, reference, sim, mask, fa_image);
   }
   MITK_INFO << "Initial E = " << last_error;
   MITK_INFO << "\n\n**************************************************************************************";
 
   std::random_device r;
   std::default_random_engine randgen(r());
   std::uniform_int_distribution<int> uint1(0, possible_proposals.size()-1);
   for (int i=0; i<iterations; ++i)
   {
     double temperature = start_temp * exp(alpha*(double)i/iterations);
     MITK_INFO << "Iteration " << i+1 << "/" << iterations << " (t=" << temperature << ")";
 
     FiberfoxParameters proposal(parameters);
     int select = uint1(randgen);
     switch (possible_proposals.at(select))
     {
     case 0:
     {
       proposal = MakeProposalDiff(proposal, temperature);
       break;
     }
     case 1:
     {
       proposal = MakeProposalRelaxation(proposal, temperature);
       break;
     }
     case 2:
     {
       proposal = MakeProposalScale(proposal, temperature);
       break;
     }
     case 3:
     {
       proposal = MakeProposalVolume(old_tdi_thr, old_sqrt, new_tdi_thr, new_sqrt, proposal, fracs, temperature);
       break;
     }
     }
 
     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*>(tracts.GetPointer()));
     tractsToDwiFilter->SetParameters(proposal);
     tractsToDwiFilter->Update();
     ItkDwiType::Pointer sim = tractsToDwiFilter->GetOutput();
     std::cout.rdbuf (old);              // <-- restore
 
     double new_error = 9999999;
     if (fa_error && fa_image.IsNotNull())
       new_error = CalcErrorFA(histogram_modifiers, dwi, sim, mask, fa_image, md_image, true);
     else
       new_error = CalcErrorSignal(histogram_modifiers, reference, sim, mask, fa_image);
     MITK_INFO << "E = " << new_error << "(" << new_error-last_error << ")";
     if (last_error<new_error)
     {
       MITK_INFO << "Rejected (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, out_folder + "/optimized.dwi");
 
       proposal.SaveParameters(out_folder + "/optimized.ffp");
       std::cout.rdbuf (old);              // <-- restore
 
       accepted++;
 
       old_tdi_thr = new_tdi_thr;
       old_sqrt = new_sqrt;
 
       MITK_INFO << "Accepted (acc. rate " << (float)accepted/(i+1) << ")";
       parameters = FiberfoxParameters(proposal);
       last_error = new_error;
     }
     MITK_INFO << "\n\n\n";
   }
 
   return EXIT_SUCCESS;
 }
 
diff --git a/Modules/DiffusionImaging/FiberTracking/cmdapps/Misc/PeakExtraction.cpp b/Modules/DiffusionImaging/FiberTracking/cmdapps/Misc/PeakExtraction.cpp
index d3e4385371..ea2eac7eb8 100755
--- a/Modules/DiffusionImaging/FiberTracking/cmdapps/Misc/PeakExtraction.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/cmdapps/Misc/PeakExtraction.cpp
@@ -1,357 +1,357 @@
 /*===================================================================
 
 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 <itkImageFileWriter.h>
 #include <itkResampleImageFilter.h>
 #include <itkFiniteDiffOdfMaximaExtractionFilter.h>
 
 #include <mitkImage.h>
 #include <mitkOdfImage.h>
 #include <mitkImageCast.h>
 #include <mitkImageToItk.h>
 #include <mitkTensorImage.h>
 
 #include <mitkCoreObjectFactory.h>
 #include "mitkCommandLineParser.h"
 #include <itkShCoefficientImageImporter.h>
 #include <itkFlipImageFilter.h>
-#include <boost/lexical_cast.hpp>
+#include <mitkLexicalCast.h>
 #include <boost/algorithm/string.hpp>
 
 #include <mitkIOUtil.h>
 
 template<int shOrder>
 int StartPeakExtraction(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
   parser.setArgumentPrefix("--", "-");
   parser.addArgument("image", "i", mitkCommandLineParser::InputFile, "Input image", "sh coefficient image", us::Any(), false);
   parser.addArgument("outroot", "o", mitkCommandLineParser::OutputDirectory, "Output directory", "output root", us::Any(), false);
   parser.addArgument("mask", "m", mitkCommandLineParser::InputFile, "Mask", "mask image");
   parser.addArgument("normalization", "n", mitkCommandLineParser::Int, "Normalization", "0=no norm, 1=max norm, 2=single vec norm", 1, true);
   parser.addArgument("numpeaks", "p", mitkCommandLineParser::Int, "Max. number of peaks", "maximum number of extracted peaks", 2, true);
   parser.addArgument("peakthres", "r", mitkCommandLineParser::Float, "Peak threshold", "peak threshold relative to largest peak", 0.4, true);
   parser.addArgument("abspeakthres", "a", mitkCommandLineParser::Float, "Absolute peak threshold", "absolute peak threshold weighted with local GFA value", 0.06, true);
   parser.addArgument("shConvention", "s", mitkCommandLineParser::String, "Use specified SH-basis", "use specified SH-basis (MITK, FSL, MRtrix)", std::string("MITK"), true);
   parser.addArgument("noFlip", "f", mitkCommandLineParser::Bool, "No flip", "do not flip input image to match MITK coordinate convention");
   parser.addArgument("clusterThres", "c", mitkCommandLineParser::Float, "Clustering threshold", "directions closer together than the specified angular threshold will be clustered (in rad)", 0.9);
   parser.addArgument("flipX", "fx", mitkCommandLineParser::Bool, "Flip X", "Flip peaks in x direction");
   parser.addArgument("flipY", "fy", mitkCommandLineParser::Bool, "Flip Y", "Flip peaks in y direction");
   parser.addArgument("flipZ", "fz", mitkCommandLineParser::Bool, "Flip Z", "Flip peaks in z direction");
 
 
   parser.setCategory("Preprocessing Tools");
   parser.setTitle("Peak Extraction");
   parser.setDescription("");
   parser.setContributor("MIC");
 
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0)
     return EXIT_FAILURE;
 
   // mandatory arguments
   std::string imageName = us::any_cast<std::string>(parsedArgs["image"]);
   std::string outRoot = us::any_cast<std::string>(parsedArgs["outroot"]);
 
   // optional arguments
   std::string maskImageName("");
   if (parsedArgs.count("mask"))
     maskImageName = us::any_cast<std::string>(parsedArgs["mask"]);
 
   int normalization = 1;
   if (parsedArgs.count("normalization"))
     normalization = us::any_cast<int>(parsedArgs["normalization"]);
 
   int numPeaks = 2;
   if (parsedArgs.count("numpeaks"))
     numPeaks = us::any_cast<int>(parsedArgs["numpeaks"]);
 
   float peakThres = 0.4;
   if (parsedArgs.count("peakthres"))
     peakThres = us::any_cast<float>(parsedArgs["peakthres"]);
 
   float absPeakThres = 0.06;
   if (parsedArgs.count("abspeakthres"))
     absPeakThres = us::any_cast<float>(parsedArgs["abspeakthres"]);
 
   float clusterThres = 0.9;
   if (parsedArgs.count("clusterThres"))
     clusterThres = us::any_cast<float>(parsedArgs["clusterThres"]);
 
   bool noFlip = false;
   if (parsedArgs.count("noFlip"))
     noFlip = us::any_cast<bool>(parsedArgs["noFlip"]);
 
   bool flipX = false;
   if (parsedArgs.count("flipX"))
     flipX = us::any_cast<bool>(parsedArgs["flipX"]);
 
   bool flipY = false;
   if (parsedArgs.count("flipY"))
     flipY = us::any_cast<bool>(parsedArgs["flipY"]);
 
   bool flipZ = false;
   if (parsedArgs.count("flipZ"))
     flipZ = us::any_cast<bool>(parsedArgs["flipZ"]);
 
   std::cout << "image: " << imageName;
   std::cout << "outroot: " << outRoot;
   if (!maskImageName.empty())
     std::cout << "mask: " << maskImageName;
   else
     std::cout << "no mask image selected";
   std::cout << "numpeaks: " << numPeaks;
   std::cout << "peakthres: " << peakThres;
   std::cout << "abspeakthres: " << absPeakThres;
   std::cout << "shOrder: " << shOrder;
 
   try
   {
     mitk::Image::Pointer image = mitk::IOUtil::Load<mitk::Image>(imageName);
     mitk::Image::Pointer mask = mitk::IOUtil::Load<mitk::Image>(maskImageName);
 
     typedef itk::Image<unsigned char, 3>  ItkUcharImgType;
     typedef itk::FiniteDiffOdfMaximaExtractionFilter< float, shOrder, 20242 > MaximaExtractionFilterType;
     typename MaximaExtractionFilterType::Pointer peak_extraction_filter = MaximaExtractionFilterType::New();
 
     int toolkitConvention = 0;
 
     if (parsedArgs.count("shConvention"))
     {
       std::string convention = us::any_cast<std::string>(parsedArgs["shConvention"]).c_str();
       if ( boost::algorithm::equals(convention, "FSL") )
       {
         toolkitConvention = 1;
         std::cout << "Using FSL SH-basis";
       }
       else if ( boost::algorithm::equals(convention, "MRtrix") )
       {
         toolkitConvention = 2;
         std::cout << "Using MRtrix SH-basis";
       }
       else
         std::cout << "Using MITK SH-basis";
     }
     else
       std::cout << "Using MITK SH-basis";
 
     ItkUcharImgType::Pointer itkMaskImage = nullptr;
     if (mask.IsNotNull())
     {
       try{
         itkMaskImage = ItkUcharImgType::New();
         mitk::CastToItkImage(mask, itkMaskImage);
         peak_extraction_filter->SetMaskImage(itkMaskImage);
       }
       catch(...)
       {
 
       }
     }
 
     if (toolkitConvention>0)
     {
       std::cout << "Converting coefficient image to MITK format";
       typedef itk::ShCoefficientImageImporter< float, shOrder > ConverterType;
       typedef mitk::ImageToItk< itk::Image< float, 4 > > CasterType;
       CasterType::Pointer caster = CasterType::New();
       caster->SetInput(image);
       caster->Update();
       itk::Image< float, 4 >::Pointer itkImage = caster->GetOutput();
 
       typename ConverterType::Pointer converter = ConverterType::New();
 
       if (noFlip)
       {
         converter->SetInputImage(itkImage);
       }
       else
       {
         std::cout << "Flipping image";
         itk::FixedArray<bool, 4> flipAxes;
         flipAxes[0] = true;
         flipAxes[1] = true;
         flipAxes[2] = false;
         flipAxes[3] = false;
         itk::FlipImageFilter< itk::Image< float, 4 > >::Pointer flipper = itk::FlipImageFilter< itk::Image< float, 4 > >::New();
         flipper->SetInput(itkImage);
         flipper->SetFlipAxes(flipAxes);
         flipper->Update();
         itk::Image< float, 4 >::Pointer flipped = flipper->GetOutput();
         itk::Matrix< double,4,4 > m = itkImage->GetDirection(); m[0][0] *= -1; m[1][1] *= -1;
         flipped->SetDirection(m);
 
         itk::Point< float, 4 > o = itkImage->GetOrigin();
         o[0] -= (flipped->GetLargestPossibleRegion().GetSize(0)-1);
         o[1] -= (flipped->GetLargestPossibleRegion().GetSize(1)-1);
         flipped->SetOrigin(o);
         converter->SetInputImage(flipped);
       }
 
       std::cout << "Starting conversion";
       switch (toolkitConvention)
       {
       case 1:
         peak_extraction_filter->SetToolkit(MaximaExtractionFilterType::FSL);
         break;
       case 2:
         peak_extraction_filter->SetToolkit(MaximaExtractionFilterType::MRTRIX);
         break;
       default:
         peak_extraction_filter->SetToolkit(MaximaExtractionFilterType::FSL);
         break;
       }
       converter->GenerateData();
       peak_extraction_filter->SetInput(converter->GetCoefficientImage());
     }
     else
     {
       try{
         typedef mitk::ImageToItk< typename MaximaExtractionFilterType::CoefficientImageType > CasterType;
         typename CasterType::Pointer caster = CasterType::New();
         caster->SetInput(image);
         caster->Update();
         peak_extraction_filter->SetInput(caster->GetOutput());
       }
       catch(...)
       {
         std::cout << "wrong image type";
         return EXIT_FAILURE;
       }
     }
 
     peak_extraction_filter->SetMaxNumPeaks(numPeaks);
     peak_extraction_filter->SetPeakThreshold(peakThres);
     peak_extraction_filter->SetAbsolutePeakThreshold(absPeakThres);
     peak_extraction_filter->SetAngularThreshold(1);
     peak_extraction_filter->SetClusteringThreshold(clusterThres);
     peak_extraction_filter->SetFlipX(flipX);
     peak_extraction_filter->SetFlipY(flipY);
     peak_extraction_filter->SetFlipZ(flipZ);
 
     switch (normalization)
     {
     case 0:
       peak_extraction_filter->SetNormalizationMethod(MaximaExtractionFilterType::NO_NORM);
       break;
     case 1:
       peak_extraction_filter->SetNormalizationMethod(MaximaExtractionFilterType::MAX_VEC_NORM);
       break;
     case 2:
       peak_extraction_filter->SetNormalizationMethod(MaximaExtractionFilterType::SINGLE_VEC_NORM);
       break;
     }
 
     std::cout << "Starting extraction";
     peak_extraction_filter->Update();
 
     // write direction image
     {
       typename MaximaExtractionFilterType::PeakImageType::Pointer itkImg = peak_extraction_filter->GetPeakImage();
       std::string outfilename = outRoot;
       outfilename.append("_PEAKS.nrrd");
 
       typedef itk::ImageFileWriter< typename MaximaExtractionFilterType::PeakImageType > WriterType;
       typename WriterType::Pointer writer = WriterType::New();
       writer->SetFileName(outfilename);
       writer->SetInput(itkImg);
       writer->Update();
     }
 
     // write num directions image
     {
       ItkUcharImgType::Pointer numDirImage = peak_extraction_filter->GetNumDirectionsImage();
 
       if (itkMaskImage.IsNotNull())
       {
         numDirImage->SetDirection(itkMaskImage->GetDirection());
         numDirImage->SetOrigin(itkMaskImage->GetOrigin());
       }
 
       std::string outfilename = outRoot.c_str();
       outfilename.append("_NUM_PEAKS.nrrd");
       typedef itk::ImageFileWriter< ItkUcharImgType > WriterType;
       WriterType::Pointer writer = WriterType::New();
       writer->SetFileName(outfilename);
       writer->SetInput(numDirImage);
       writer->Update();
     }
   }
   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;
 }
 
 /*!
 \brief Extract maxima in the input spherical harmonics image.
 */
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
   parser.setArgumentPrefix("--", "-");
   parser.addArgument("image", "i", mitkCommandLineParser::InputFile, "Input image", "sh coefficient image", us::Any(), false);
   parser.addArgument("shOrder", "sh", mitkCommandLineParser::Int, "Spherical harmonics order", "spherical harmonics order");
   parser.addArgument("outroot", "o", mitkCommandLineParser::OutputDirectory, "Output directory", "output root", us::Any(), false);
   parser.addArgument("mask", "m", mitkCommandLineParser::InputFile, "Mask", "mask image");
   parser.addArgument("normalization", "n", mitkCommandLineParser::Int, "Normalization", "0=no norm, 1=max norm, 2=single vec norm", 1, true);
   parser.addArgument("numpeaks", "p", mitkCommandLineParser::Int, "Max. number of peaks", "maximum number of extracted peaks", 2, true);
   parser.addArgument("peakthres", "r", mitkCommandLineParser::Float, "Peak threshold", "peak threshold relative to largest peak", 0.4, true);
   parser.addArgument("abspeakthres", "a", mitkCommandLineParser::Float, "Absolute peak threshold", "absolute peak threshold weighted with local GFA value", 0.06, true);
   parser.addArgument("shConvention", "s", mitkCommandLineParser::String, "Use specified SH-basis", "use specified SH-basis (MITK, FSL, MRtrix)", std::string("MITK"), true);
   parser.addArgument("noFlip", "f", mitkCommandLineParser::Bool, "No flip", "do not flip input image to match MITK coordinate convention");
 
   parser.setCategory("Preprocessing Tools");
   parser.setTitle("Peak Extraction");
   parser.setDescription("Extract maxima in the input spherical harmonics image.");
   parser.setContributor("MIC");
 
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0)
     return EXIT_FAILURE;
 
 
   int shOrder = -1;
   if (parsedArgs.count("shOrder"))
     shOrder = us::any_cast<int>(parsedArgs["shOrder"]);
 
   switch (shOrder)
   {
   case 4:
     return StartPeakExtraction<4>(argc, argv);
   case 6:
     return StartPeakExtraction<6>(argc, argv);
   case 8:
     return StartPeakExtraction<8>(argc, argv);
   case 10:
     return StartPeakExtraction<10>(argc, argv);
   case 12:
     return StartPeakExtraction<12>(argc, argv);
   }
   return EXIT_FAILURE;
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/cmdapps/Misc/PythonTest.cpp b/Modules/DiffusionImaging/FiberTracking/cmdapps/Misc/PythonTest.cpp
index 8c570f93ba..b5c21e3952 100755
--- a/Modules/DiffusionImaging/FiberTracking/cmdapps/Misc/PythonTest.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/cmdapps/Misc/PythonTest.cpp
@@ -1,80 +1,80 @@
 /*===================================================================
 
 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 <itkImageFileWriter.h>
 #include <itkResampleImageFilter.h>
 
 #include <mitkImage.h>
 #include <mitkImageCast.h>
 #include <mitkImageToItk.h>
 
 #include <mitkCommandLineParser.h>
-#include <boost/lexical_cast.hpp>
+#include <mitkLexicalCast.h>
 
 #include <usModuleContext.h>
 #include <usGetModuleContext.h>
 #include <mitkIOUtil.h>
 #include <mitkIPythonService.h>
 
 typedef itk::Image< float, 3 >    ItkImageType;
 
 /*!
 \brief
 */
 int main(int argc, char* argv[])
 {
     mitkCommandLineParser parser;
     parser.setArgumentPrefix("--", "-");
     parser.addArgument("image", "i", mitkCommandLineParser::InputFile, "Input image", "sh coefficient image", us::Any(), false);
     parser.addArgument("script", "s", mitkCommandLineParser::InputFile, "", "", us::Any(), false);
     parser.addArgument("params", "p", mitkCommandLineParser::InputFile, "", "", us::Any(), false);
     parser.addArgument("out_file", "o", mitkCommandLineParser::OutputDirectory, "Output image", "output image", us::Any(), false);
 
     parser.setCategory("TEST");
     parser.setTitle("TEST");
     parser.setDescription("TEST");
     parser.setContributor("MIC");
 
     std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
     if (parsedArgs.size()==0)
         return EXIT_FAILURE;
 
     std::string image_file = us::any_cast<std::string>(parsedArgs["image"]);
     std::string script = us::any_cast<std::string>(parsedArgs["script"]);
     std::string params = us::any_cast<std::string>(parsedArgs["params"]);
     std::string out_file = us::any_cast<std::string>(parsedArgs["out_file"]);
 
     mitk::Image::Pointer mitk_image = mitk::IOUtil::Load<mitk::Image>(image_file);
     us::ModuleContext* context = us::GetModuleContext();
 
     us::ServiceReference<mitk::IPythonService> m_PythonServiceRef = context->GetServiceReference<mitk::IPythonService>();
     mitk::IPythonService* m_PythonService = dynamic_cast<mitk::IPythonService*> ( context->GetService<mitk::IPythonService>(m_PythonServiceRef) );
 
     mitk::IPythonService::ForceLoadModule();
 
     m_PythonService->Execute("import SimpleITK as sitk");
     m_PythonService->Execute("import SimpleITK._SimpleITK as _SimpleITK");
     m_PythonService->Execute("import numpy");
 
     m_PythonService->CopyToPythonAsSimpleItkImage( mitk_image, "myvar");
     m_PythonService->Execute("myparams=\""+params+"\"");
     m_PythonService->ExecuteScript(script);
 
     mitk::Image::Pointer out_seg = m_PythonService->CopySimpleItkImageFromPython("out_image");
     mitk::IOUtil::Save(out_seg, out_file);
 
     return EXIT_FAILURE;
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/AnchorConstrainedPlausibility.cpp b/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/AnchorConstrainedPlausibility.cpp
index d336f221fe..42338774b9 100755
--- a/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/AnchorConstrainedPlausibility.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/AnchorConstrainedPlausibility.cpp
@@ -1,575 +1,575 @@
 /*===================================================================
 
 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 <mitkLexicalCast.h>
 #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 Score input candidate tracts using ACP analysis
 */
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
 
   parser.setTitle("Anchor Constrained Plausibility");
   parser.setCategory("Fiber Tracking Evaluation");
   parser.setDescription("Score input candidate tracts using ACP analysis");
   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)");
   parser.addArgument("use_num_streamlines", "", mitkCommandLineParser::Bool, "Use number of streamlines as score:", "Don't fit candidates, simply use number of streamlines per candidate as score", false);
   parser.addArgument("use_weights", "", mitkCommandLineParser::Bool, "Use input weights as score:", "Don't fit candidates, simply use first input streamline weight per candidate as score", false);
   parser.addArgument("filter_zero_weights", "", mitkCommandLineParser::Bool, "Filter zero-weights", "Remove streamlines with weight 0 from candidates", false);
 
   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"]);
 
   bool filter_zero_weights = false;
   if (parsedArgs.count("filter_zero_weights"))
     filter_zero_weights = us::any_cast<bool>(parsedArgs["filter_zero_weights"]);
 
   std::string mask_file = "";
   if (parsedArgs.count("mask"))
     mask_file = us::any_cast<std::string>(parsedArgs["mask"]);
 
   mitkCommandLineParser::StringContainerType anchor_mask_files_folders;
   if (parsedArgs.count("anchor_masks"))
     anchor_mask_files_folders = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["anchor_masks"]);
 
   std::string regu = "NONE";
   if (parsedArgs.count("regu"))
     regu = us::any_cast<std::string>(parsedArgs["regu"]);
 
   bool use_weights = false;
   if (parsedArgs.count("use_weights"))
     use_weights = us::any_cast<bool>(parsedArgs["use_weights"]);
 
   bool use_num_streamlines = false;
   if (parsedArgs.count("use_num_streamlines"))
     use_num_streamlines = us::any_cast<bool>(parsedArgs["use_num_streamlines"]);
 
   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 = dynamic_cast<mitk::PeakImage*>(mitk::IOUtil::Load(peak_file_name, &functor)[0].GetPointer());
 
     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;
     std::vector< std::string > anchor_mask_files;
     for (auto filename : anchor_mask_files_folders)
     {
       if (itksys::SystemTools::PathExists(filename))
       {
         auto list = get_file_list(filename, {".nrrd",".nii.gz",".nii"});
         for (auto f : list)
         {
           MITK_INFO << f;
           itk::FitFibersToImageFilter::UcharImgType::Pointer ref_mask = nullptr;
           mitk::Image::Pointer ref_mitk_mask = mitk::IOUtil::Load<mitk::Image>(f);
           mitk::CastToItkImage(ref_mitk_mask, ref_mask);
           reference_masks.push_back(ref_mask);
           anchor_mask_files.push_back(f);
         }
       }
       else if (itksys::SystemTools::FileExists(filename))
       {
         anchor_mask_files.push_back(filename);
         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.";
     MITK_INFO << "Loaded " << reference_masks.size() << " reference masks.";
 
     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 (use_weights || use_num_streamlines)
     {
       MITK_INFO << "Using tract weights as scores";
       int c = 0;
       for (auto fib : input_candidates)
       {
         int mod = 1;
         double score = 0;
         if (use_weights)
         {
           score = fib->GetFiberWeight(0);
           mod = 100000;
         }
         else if (use_num_streamlines)
           score = fib->GetNumFibers();
         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)(mod*score)) + "_" + 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) << score << " " << 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;
       }
 
     }
     else 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
         if (filter_zero_weights)
           fib = fib->FilterByWeights(0);
         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
         if (filter_zero_weights)
           best_candidate = best_candidate->FilterByWeights(0);
         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/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/ExtractSimilarTracts.cpp b/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/ExtractSimilarTracts.cpp
index 2645e71a7d..5cefcfc547 100644
--- a/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/ExtractSimilarTracts.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/ExtractSimilarTracts.cpp
@@ -1,237 +1,237 @@
 /*===================================================================
 
 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 <boost/lexical_cast.hpp>
+#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 <itksys/SystemTools.hxx>
 
 typedef itksys::SystemTools ist;
 typedef itk::Image<unsigned char, 3>    ItkFloatImgType;
 
 mitk::FiberBundle::Pointer LoadFib(std::string filename)
 {
   std::vector<mitk::BaseData::Pointer> fibInfile = mitk::IOUtil::Load(filename);
   if( fibInfile.empty() )
     std::cout << "File " << filename << " could not be read!";
   mitk::BaseData::Pointer baseData = fibInfile.at(0);
   return dynamic_cast<mitk::FiberBundle*>(baseData.GetPointer());
 }
 
 ItkFloatImgType::Pointer LoadItkImage(const std::string& filename)
 {
   mitk::Image::Pointer img = mitk::IOUtil::Load<mitk::Image>(filename);
   ItkFloatImgType::Pointer itkMask = ItkFloatImgType::New();
   mitk::CastToItkImage(img, itkMask);
   return itkMask;
 }
 
 /*!
 \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 = LoadFib(in_fib);
 
     std::srand(0);
     if (subsample<1.0)
       fib = fib->SubsampleFibers(subsample);
 
     mitk::FiberBundle::Pointer resampled_fib = fib->GetDeepCopy();
     resampled_fib->ResampleToNumPoints(12);
 
     std::vector< mitk::FiberBundle::Pointer > ref_fibs;
     std::vector< ItkFloatImgType::Pointer > ref_masks;
     for (std::size_t i=0; i<ref_bundle_files.size(); ++i)
     {
       MITK_INFO << "Loading " << ist::GetFilenameName(ref_bundle_files.at(i));
       if (i<ref_mask_files.size())
         MITK_INFO << "Loading " << ist::GetFilenameName(ref_mask_files.at(i));
 
       std::streambuf *old = cout.rdbuf(); // <-- save
       std::stringstream ss;
       std::cout.rdbuf (ss.rdbuf());       // <-- redirect
       try
       {
         ref_fibs.push_back(LoadFib(ref_bundle_files.at(i)));
         if (i<ref_mask_files.size())
           ref_masks.push_back(LoadItkImage(ref_mask_files.at(i)));
         else
           ref_masks.push_back(nullptr);
         std::cout.rdbuf (old);              // <-- restore
       }
       catch(...){
         std::cout.rdbuf (old);              // <-- restore
         std::cout << "could not load: " << ref_bundle_files.at(i);
         return EXIT_FAILURE;
       }
     }
 
     std::vector< float > distances;
     distances.push_back(distance);
 
     mitk::FiberBundle::Pointer anchor_tractogram = 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->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);
 
           anchor_tractogram = anchor_tractogram->AddBundle(result);
           mitk::IOUtil::Save(result, out_root + "anchor_" + 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 << "Streamlines in anchor tractogram: " << anchor_tractogram->GetNumFibers();
     mitk::IOUtil::Save(anchor_tractogram, out_root + "anchor_tractogram.trk");
 
     MITK_INFO << "Streamlines remaining in candidate tractogram: " << fib->GetNumFibers();
     mitk::IOUtil::Save(fib, out_root + "candidate_tractogram.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/FiberTracking/cmdapps/TractographyEvaluation/LocalDirectionalFiberPlausibility.cpp b/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/LocalDirectionalFiberPlausibility.cpp
index b47893d07e..368c4dcd47 100755
--- a/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/LocalDirectionalFiberPlausibility.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/LocalDirectionalFiberPlausibility.cpp
@@ -1,315 +1,315 @@
 /*===================================================================
 
 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 <boost/lexical_cast.hpp>
+#include <mitkLexicalCast.h>
 #include <iostream>
 #include <fstream>
 #include <itksys/SystemTools.hxx>
 #include <mitkCoreObjectFactory.h>
 
 /*!
 \brief Calculate angular error of a tractogram with respect to the input reference directions.
 */
 int main(int argc, char* argv[])
 {
     mitkCommandLineParser parser;
 
     parser.setTitle("Local Directional Fiber Plausibility");
     parser.setCategory("Fiber Tracking Evaluation");
     parser.setDescription("Calculate angular error of a tractogram with respect to the input reference directions.");
     parser.setContributor("MIC");
 
     parser.setArgumentPrefix("--", "-");
     parser.addArgument("input", "i", mitkCommandLineParser::InputFile, "Input:", "input tractogram (.fib, vtk ascii file format)", us::Any(), false);
     parser.addArgument("reference", "r", mitkCommandLineParser::StringList, "Reference images:", "reference direction images", us::Any(), false);
     parser.addArgument("out", "o", mitkCommandLineParser::OutputDirectory, "Output:", "output root", us::Any(), false);
     parser.addArgument("mask", "m", mitkCommandLineParser::StringList, "Masks:", "mask images");
     parser.addArgument("athresh", "a", mitkCommandLineParser::Float, "Angular threshold:", "angular threshold in degrees. closer fiber directions are regarded as one direction and clustered together.", 25, true);
     parser.addArgument("sthresh", "s", mitkCommandLineParser::Float, "Size threshold:", "Relative peak size threshold per voxel.", 0.0, true);
     parser.addArgument("maxdirs", "md", mitkCommandLineParser::Int, "Max. Clusters:", "Maximum number of fiber clusters.", 0, true);
     parser.addArgument("verbose", "v", mitkCommandLineParser::Bool, "Verbose:", "output optional and intermediate calculation results");
     parser.addArgument("ignore", "n", mitkCommandLineParser::Bool, "Ignore:", "don't increase error for missing or too many directions");
     parser.addArgument("empty", "e", mitkCommandLineParser::Bool, "Empty Voxels:", "don't increase error for empty voxels");
     parser.addArgument("fileID", "id", mitkCommandLineParser::String, "ID:", "optional ID field");
 
     map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
     if (parsedArgs.size()==0)
         return EXIT_FAILURE;
 
     mitkCommandLineParser::StringContainerType referenceImages = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["reference"]);
     mitkCommandLineParser::StringContainerType maskImages;
     if (parsedArgs.count("mask"))
         maskImages = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["mask"]);
 
     string fibFile = us::any_cast<string>(parsedArgs["input"]);
 
     float angularThreshold = 25;
     if (parsedArgs.count("athresh"))
         angularThreshold = us::any_cast<float>(parsedArgs["athresh"]);
 
     float sizeThreshold = 0;
     if (parsedArgs.count("sthresh"))
         sizeThreshold = us::any_cast<float>(parsedArgs["sthresh"]);
 
     int maxDirs = 0;
     if (parsedArgs.count("maxdirs"))
         maxDirs = us::any_cast<int>(parsedArgs["maxdirs"]);
 
     string outRoot = us::any_cast<string>(parsedArgs["out"]);
 
     bool verbose = false;
     if (parsedArgs.count("verbose"))
         verbose = us::any_cast<bool>(parsedArgs["verbose"]);
 
     bool ignoreMissing = false;
     if (parsedArgs.count("ignore"))
         ignoreMissing = us::any_cast<bool>(parsedArgs["ignore"]);
 
     bool ignoreEmpty = false;
     if (parsedArgs.count("empty"))
         ignoreEmpty = us::any_cast<bool>(parsedArgs["empty"]);
 
     string fileID = "";
     if (parsedArgs.count("fileID"))
         fileID = us::any_cast<string>(parsedArgs["fileID"]);
 
 
     try
     {
         typedef itk::Image<unsigned char, 3>                                    ItkUcharImgType;
         typedef itk::Image< itk::Vector< float, 3>, 3 >                         ItkDirectionImage3DType;
         typedef itk::VectorContainer< unsigned int, ItkDirectionImage3DType::Pointer >   ItkDirectionImageContainerType;
         typedef itk::EvaluateDirectionImagesFilter< float >                     EvaluationFilterType;
 
         // load fiber bundle
         mitk::FiberBundle::Pointer inputTractogram = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::LoadData(fibFile)[0].GetPointer());
 
         // load reference directions
         ItkDirectionImageContainerType::Pointer referenceImageContainer = ItkDirectionImageContainerType::New();
         for (unsigned int i=0; i<referenceImages.size(); i++)
         {
             try
             {
                 mitk::Image::Pointer img = mitk::IOUtil::Load<mitk::Image>(referenceImages.at(i));
                 typedef mitk::ImageToItk< ItkDirectionImage3DType > CasterType;
                 CasterType::Pointer caster = CasterType::New();
                 caster->SetInput(img);
                 caster->Update();
                 ItkDirectionImage3DType::Pointer itkImg = caster->GetOutput();
                 referenceImageContainer->InsertElement(referenceImageContainer->Size(),itkImg);
             }
             catch(...){ std::cout << "could not load: " << referenceImages.at(i); }
         }
 
         ItkUcharImgType::Pointer itkMaskImage = ItkUcharImgType::New();
         ItkDirectionImage3DType::Pointer dirImg = referenceImageContainer->GetElement(0);
         itkMaskImage->SetSpacing( dirImg->GetSpacing() );
         itkMaskImage->SetOrigin( dirImg->GetOrigin() );
         itkMaskImage->SetDirection( dirImg->GetDirection() );
         itkMaskImage->SetLargestPossibleRegion( dirImg->GetLargestPossibleRegion() );
         itkMaskImage->SetBufferedRegion( dirImg->GetLargestPossibleRegion() );
         itkMaskImage->SetRequestedRegion( dirImg->GetLargestPossibleRegion() );
         itkMaskImage->Allocate();
         itkMaskImage->FillBuffer(1);
 
         // extract directions from fiber bundle
         itk::TractsToVectorImageFilter<float>::Pointer fOdfFilter = itk::TractsToVectorImageFilter<float>::New();
         fOdfFilter->SetFiberBundle(inputTractogram);
         fOdfFilter->SetMaskImage(itkMaskImage);
         fOdfFilter->SetAngularThreshold(cos(angularThreshold*itk::Math::pi/180));
         fOdfFilter->SetNormalizeVectors(true);
         fOdfFilter->SetUseWorkingCopy(false);
         fOdfFilter->SetSizeThreshold(sizeThreshold);
         fOdfFilter->SetMaxNumDirections(maxDirs);
         fOdfFilter->Update();
 
         if (verbose)
         {
             // write vector field
             mitk::FiberBundle::Pointer directions = fOdfFilter->GetOutputFiberBundle();
 
             string outfilename = outRoot;
             outfilename.append("_VECTOR_FIELD.fib");
 
             mitk::IOUtil::Save(directions.GetPointer(), outfilename );
 
             // write direction images
             {
                 itk::TractsToVectorImageFilter<float>::ItkDirectionImageType::Pointer itkImg = fOdfFilter->GetDirectionImage();
                 typedef itk::ImageFileWriter< itk::TractsToVectorImageFilter<float>::ItkDirectionImageType > WriterType;
                 WriterType::Pointer writer = WriterType::New();
 
                 string outfilename = outRoot;
                 outfilename.append("_DIRECTIONS.nrrd");
 
                 writer->SetFileName(outfilename.c_str());
                 writer->SetInput(itkImg);
                 writer->Update();
             }
 
             // write num direction image
             {
                 ItkUcharImgType::Pointer numDirImage = fOdfFilter->GetNumDirectionsImage();
                 typedef itk::ImageFileWriter< ItkUcharImgType > WriterType;
                 WriterType::Pointer writer = WriterType::New();
 
                 string outfilename = outRoot;
                 outfilename.append("_NUM_DIRECTIONS.nrrd");
 
                 writer->SetFileName(outfilename.c_str());
                 writer->SetInput(numDirImage);
                 writer->Update();
             }
         }
 
         string logFile = outRoot;
         logFile.append("_ANGULAR_ERROR.csv");
         ofstream file;
         file.open (logFile.c_str());
 
         if (maskImages.size()>0)
         {
             for (unsigned int i=0; i<maskImages.size(); i++)
             {
                 mitk::Image::Pointer mitkMaskImage = mitk::IOUtil::Load<mitk::Image>(maskImages.at(i));
                 mitk::CastToItkImage(mitkMaskImage, itkMaskImage);
 
                 // evaluate directions
                 EvaluationFilterType::Pointer evaluationFilter = EvaluationFilterType::New();
                 //evaluationFilter->SetImageSet(directionImageContainer);
                 evaluationFilter->SetReferenceImageSet(referenceImageContainer);
                 evaluationFilter->SetMaskImage(itkMaskImage);
                 evaluationFilter->SetIgnoreMissingDirections(ignoreMissing);
                 evaluationFilter->SetIgnoreEmptyVoxels(ignoreEmpty);
                 evaluationFilter->Update();
 
                 if (verbose)
                 {
                     EvaluationFilterType::OutputImageType::Pointer angularErrorImage = evaluationFilter->GetOutput(0);
                     typedef itk::ImageFileWriter< EvaluationFilterType::OutputImageType > WriterType;
                     WriterType::Pointer writer = WriterType::New();
 
                     string outfilename = outRoot;
                     outfilename.append("_ERROR_IMAGE.nrrd");
 
                     writer->SetFileName(outfilename.c_str());
                     writer->SetInput(angularErrorImage);
                     writer->Update();
                 }
 
                 string maskFileName = itksys::SystemTools::GetFilenameWithoutExtension(maskImages.at(i));
                 unsigned found = maskFileName.find_last_of("_");
 
                 string sens = itksys::SystemTools::GetFilenameWithoutLastExtension(fibFile);
                 if (!fileID.empty())
                     sens = fileID;
                 sens.append(",");
 
                 sens.append(maskFileName.substr(found+1));
                 sens.append(",");
 
                 sens.append(boost::lexical_cast<string>(evaluationFilter->GetMeanAngularError()));
                 sens.append(",");
 
                 sens.append(boost::lexical_cast<string>(evaluationFilter->GetMedianAngularError()));
                 sens.append(",");
 
                 sens.append(boost::lexical_cast<string>(evaluationFilter->GetMaxAngularError()));
                 sens.append(",");
 
                 sens.append(boost::lexical_cast<string>(evaluationFilter->GetMinAngularError()));
                 sens.append(",");
 
                 sens.append(boost::lexical_cast<string>(std::sqrt(evaluationFilter->GetVarAngularError())));
                 sens.append(";\n");
                 file << sens;
             }
         }
         else
         {
             // evaluate directions
             EvaluationFilterType::Pointer evaluationFilter = EvaluationFilterType::New();
             //evaluationFilter->SetImageSet(directionImageContainer);
             evaluationFilter->SetReferenceImageSet(referenceImageContainer);
             evaluationFilter->SetMaskImage(itkMaskImage);
             evaluationFilter->SetIgnoreMissingDirections(ignoreMissing);
             evaluationFilter->SetIgnoreEmptyVoxels(ignoreEmpty);
             evaluationFilter->Update();
 
             if (verbose)
             {
                 EvaluationFilterType::OutputImageType::Pointer angularErrorImage = evaluationFilter->GetOutput(0);
                 typedef itk::ImageFileWriter< EvaluationFilterType::OutputImageType > WriterType;
                 WriterType::Pointer writer = WriterType::New();
 
                 string outfilename = outRoot;
                 outfilename.append("_ERROR_IMAGE.nrrd");
 
                 writer->SetFileName(outfilename.c_str());
                 writer->SetInput(angularErrorImage);
                 writer->Update();
             }
 
             string sens = itksys::SystemTools::GetFilenameWithoutLastExtension(fibFile);
             if (!fileID.empty())
                 sens = fileID;
             sens.append(",");
 
             sens.append(boost::lexical_cast<string>(evaluationFilter->GetMeanAngularError()));
             sens.append(",");
 
             sens.append(boost::lexical_cast<string>(evaluationFilter->GetMedianAngularError()));
             sens.append(",");
 
             sens.append(boost::lexical_cast<string>(evaluationFilter->GetMaxAngularError()));
             sens.append(",");
 
             sens.append(boost::lexical_cast<string>(evaluationFilter->GetMinAngularError()));
             sens.append(",");
 
             sens.append(boost::lexical_cast<string>(std::sqrt(evaluationFilter->GetVarAngularError())));
             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/FiberTracking/cmdapps/TractographyEvaluation/MergeOverlappingTracts.cpp b/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/MergeOverlappingTracts.cpp
index 56df393e72..1147856404 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 <mitkLexicalCast.h>
 #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", 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 = mitk::IOUtil::Load<mitk::FiberBundle>(f);
       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;
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/PeaksAngularError.cpp b/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/PeaksAngularError.cpp
index 3c6d23ce7a..1031da0df4 100755
--- a/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/PeaksAngularError.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/PeaksAngularError.cpp
@@ -1,207 +1,207 @@
 /*===================================================================
 
 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 <boost/lexical_cast.hpp>
+#include <mitkLexicalCast.h>
 #include <iostream>
 #include <fstream>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 /*!
 \brief Calculate angular error between two sets of directions stored in multiple 3D vector images where each pixel corresponds to a vector (itk::Image< itk::Vector< float, 3>, 3 >)
 */
 int main(int argc, char* argv[])
 {
     mitkCommandLineParser parser;
     parser.setArgumentPrefix("--", "-");
     parser.addArgument("test", "t", mitkCommandLineParser::StringList, "Test images", "test direction images", us::Any(), false);
     parser.addArgument("reference", "r", mitkCommandLineParser::StringList, "Reference images", "reference direction images", us::Any(), false);
     parser.addArgument("out", "o", mitkCommandLineParser::OutputDirectory, "Output directory", "output root", us::Any(), false);
     parser.addArgument("mask", "m", mitkCommandLineParser::InputFile, "Mask", "mask image");
     parser.addArgument("verbose", "v", mitkCommandLineParser::Bool, "Verbose", "output optional and intermediate calculation results");
     parser.addArgument("ignore", "i", mitkCommandLineParser::Bool, "Ignore", "don't increase error for missing or too many directions");
 
     parser.setCategory("Fiber Tracking Evaluation");
     parser.setTitle("Peaks Angular Error");
     parser.setDescription("Calculate angular error between two sets of directions stored in multiple 3D vector images where each pixel corresponds to a vector (itk::Image< itk::Vector< float, 3>, 3 >)");
     parser.setContributor("MIC");
 
     std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
     if (parsedArgs.size()==0)
         return EXIT_FAILURE;
 
     mitkCommandLineParser::StringContainerType testImages = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["test"]);
     mitkCommandLineParser::StringContainerType referenceImages = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["reference"]);
 
     std::string maskImage("");
     if (parsedArgs.count("mask"))
         maskImage = us::any_cast<std::string>(parsedArgs["mask"]);
 
     std::string outRoot = us::any_cast<std::string>(parsedArgs["out"]);
 
     bool verbose = false;
     if (parsedArgs.count("verbose"))
         verbose = us::any_cast<bool>(parsedArgs["verbose"]);
 
     bool ignore = false;
     if (parsedArgs.count("ignore"))
         ignore = us::any_cast<bool>(parsedArgs["ignore"]);
 
     try
     {
         typedef itk::Image<unsigned char, 3>                                    ItkUcharImgType;
         typedef itk::Image< itk::Vector< float, 3>, 3 >                         ItkDirectionImage3DType;
         typedef itk::VectorContainer< unsigned int, ItkDirectionImage3DType::Pointer >   ItkDirectionImageContainerType;
         typedef itk::EvaluateDirectionImagesFilter< float >                     EvaluationFilterType;
 
         ItkDirectionImageContainerType::Pointer directionImageContainer = ItkDirectionImageContainerType::New();
         for (unsigned int i=0; i<testImages.size(); i++)
         {
             try
             {
                 mitk::Image::Pointer img = mitk::IOUtil::Load<mitk::Image>(testImages.at(i));
                 typedef mitk::ImageToItk< ItkDirectionImage3DType > CasterType;
                 CasterType::Pointer caster = CasterType::New();
                 caster->SetInput(img);
                 caster->Update();
                 ItkDirectionImage3DType::Pointer itkImg = caster->GetOutput();
                 directionImageContainer->InsertElement(directionImageContainer->Size(),itkImg);
             }
             catch(...){ std::cout << "could not load: " << referenceImages.at(i); }
         }
 
         // load reference directions
         ItkDirectionImageContainerType::Pointer referenceImageContainer = ItkDirectionImageContainerType::New();
         for (unsigned int i=0; i<referenceImages.size(); i++)
         {
             try
             {
                 mitk::Image::Pointer img = mitk::IOUtil::Load<mitk::Image>(referenceImages.at(i));
                 typedef mitk::ImageToItk< ItkDirectionImage3DType > CasterType;
                 CasterType::Pointer caster = CasterType::New();
                 caster->SetInput(img);
                 caster->Update();
                 ItkDirectionImage3DType::Pointer itkImg = caster->GetOutput();
                 referenceImageContainer->InsertElement(referenceImageContainer->Size(),itkImg);
             }
             catch(...){ std::cout << "could not load: " << referenceImages.at(i); }
         }
 
         // load/create mask image
         ItkUcharImgType::Pointer itkMaskImage = ItkUcharImgType::New();
         if (maskImage.compare("")==0)
         {
             ItkDirectionImage3DType::Pointer dirImg = referenceImageContainer->GetElement(0);
             itkMaskImage->SetSpacing( dirImg->GetSpacing() );
             itkMaskImage->SetOrigin( dirImg->GetOrigin() );
             itkMaskImage->SetDirection( dirImg->GetDirection() );
             itkMaskImage->SetLargestPossibleRegion( dirImg->GetLargestPossibleRegion() );
             itkMaskImage->SetBufferedRegion( dirImg->GetLargestPossibleRegion() );
             itkMaskImage->SetRequestedRegion( dirImg->GetLargestPossibleRegion() );
             itkMaskImage->Allocate();
             itkMaskImage->FillBuffer(1);
         }
         else
         {
             mitk::Image::Pointer mitkMaskImage = mitk::IOUtil::Load<mitk::Image>(maskImage);
             mitk::CastToItkImage(mitkMaskImage, itkMaskImage);
         }
 
         // evaluate directions
         EvaluationFilterType::Pointer evaluationFilter = EvaluationFilterType::New();
         evaluationFilter->SetImageSet(directionImageContainer);
         evaluationFilter->SetReferenceImageSet(referenceImageContainer);
         evaluationFilter->SetMaskImage(itkMaskImage);
         evaluationFilter->SetIgnoreMissingDirections(ignore);
         evaluationFilter->Update();
 
         if (verbose)
         {
             EvaluationFilterType::OutputImageType::Pointer angularErrorImage = evaluationFilter->GetOutput(0);
             typedef itk::ImageFileWriter< EvaluationFilterType::OutputImageType > WriterType;
             WriterType::Pointer writer = WriterType::New();
 
             std::string outfilename = outRoot;
             outfilename.append("_ERROR_IMAGE.nrrd");
 
             writer->SetFileName(outfilename.c_str());
             writer->SetInput(angularErrorImage);
             writer->Update();
         }
 
         std::string logFile = outRoot;
         logFile.append("_ANGULAR_ERROR.csv");
 
         ofstream file;
         file.open (logFile.c_str());
 
         std::string sens = "Mean:";
         sens.append(",");
         sens.append(boost::lexical_cast<std::string>(evaluationFilter->GetMeanAngularError()));
         sens.append(";\n");
 
         sens.append("Median:");
         sens.append(",");
         sens.append(boost::lexical_cast<std::string>(evaluationFilter->GetMedianAngularError()));
         sens.append(";\n");
 
         sens.append("Maximum:");
         sens.append(",");
         sens.append(boost::lexical_cast<std::string>(evaluationFilter->GetMaxAngularError()));
         sens.append(";\n");
 
         sens.append("Minimum:");
         sens.append(",");
         sens.append(boost::lexical_cast<std::string>(evaluationFilter->GetMinAngularError()));
         sens.append(";\n");
 
         sens.append("STDEV:");
         sens.append(",");
         sens.append(boost::lexical_cast<std::string>(std::sqrt(evaluationFilter->GetVarAngularError())));
         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/FiberTracking/cmdapps/TractographyEvaluation/TractometerMetrics.cpp b/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/TractometerMetrics.cpp
index d64eeb5420..01030c2a78 100755
--- a/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/TractometerMetrics.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/TractometerMetrics.cpp
@@ -1,415 +1,415 @@
 /*===================================================================
 
 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 <boost/lexical_cast.hpp>
+#include <mitkLexicalCast.h>
 #include <iostream>
 #include <fstream>
 #include <itksys/SystemTools.hxx>
 #include <mitkCoreObjectFactory.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("input", "i", mitkCommandLineParser::InputFile, "Input:", "input tractogram (.fib, vtk ascii file format)", us::Any(), false);
     parser.addArgument("out", "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["input"]);
     std::string labelImageFile = us::any_cast<std::string>(parsedArgs["labelimage"]);
 
     std::string outRoot = us::any_cast<std::string>(parsedArgs["out"]);
 
     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(inputTractogram->GetNumFibers());
         for (int i=0; i<inputTractogram->GetNumFibers(); i++)
         {
             ++disp;
 
             vtkCell* cell = polyData->GetCell(i);
             int numPoints = cell->GetNumberOfPoints();
             vtkPoints* points = cell->GetPoints();
 
 
             if (numPoints>1)
             {
                 double* start = points->GetPoint(0);
                 itk::Point<float, 3> itkStart;
                 itkStart[0] = start[0]; itkStart[1] = start[1]; itkStart[2] = start[2];
                 itk::Index<3> idxStart;
                 labelImage->TransformPhysicalPointToIndex(itkStart, idxStart);
 
                 double* end = points->GetPoint(numPoints-1);
                 itk::Point<float, 3> itkEnd;
                 itkEnd[0] = end[0]; itkEnd[1] = end[1]; itkEnd[2] = end[2];
                 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;
                                 itkP[0] = p[0]; itkP[1] = p[1]; itkP[2] = p[2];
                                 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;
                                     itkP[0] = p[0]; itkP[1] = p[1]; itkP[2] = p[2];
                                     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 );
 
             {
                 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/Quantification/IODataStructures/TbssImages/mitkNrrdTbssImageWriter.cpp b/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkNrrdTbssImageWriter.cpp
index 1554faf924..672d79a6c9 100644
--- a/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkNrrdTbssImageWriter.cpp
+++ b/Modules/DiffusionImaging/Quantification/IODataStructures/TbssImages/mitkNrrdTbssImageWriter.cpp
@@ -1,165 +1,165 @@
 /*===================================================================
 
 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 __mitkNrrdTbssImageWriter__cpp
 #define __mitkNrrdTbssImageWriter__cpp
 
 #include "mitkNrrdTbssImageWriter.h"
 #include "itkMetaDataDictionary.h"
 #include "itkMetaDataObject.h"
 #include "itkNrrdImageIO.h"
 //#include "itkNiftiImageIO.h"
 #include "itkImageFileWriter.h"
 #include "itksys/SystemTools.hxx"
-#include "boost/lexical_cast.hpp"
+#include "mitkLexicalCast.h"
 
 #include <iostream>
 #include <fstream>
 
 
 mitk::NrrdTbssImageWriter::NrrdTbssImageWriter()
   : m_FileName(""), m_FilePrefix(""), m_FilePattern(""), m_Success(false)
 {
   this->SetNumberOfRequiredInputs( 1 );
 }
 
 mitk::NrrdTbssImageWriter::~NrrdTbssImageWriter()
 {}
 
 
 void mitk::NrrdTbssImageWriter::GenerateData()
 {
   m_Success = false;
   InputType* input = this->GetInput();
   if (input == nullptr)
   {
     itkWarningMacro(<<"Sorry, input to NrrdTbssImageWriter is nullptr!");
     return;
   }
   if ( m_FileName == "" )
   {
     itkWarningMacro( << "Sorry, filename has not been set!" );
     return ;
   }
 
 
 
   itk::VectorImage<float, 3>::Pointer img = input->GetImage();
 
 
 
 
   std::string key;
   std::string val;
 
 
   /* For the case of a tbss image containing data of the patients:
      Save info about the groups and the type of measurement */
 
 
 
 
   std::vector< std::pair <std::string, int> > groups = input->GetGroupInfo();
   auto it = groups.begin();
 
   int i=0;
   while(it != groups.end())
   {
     std::pair<std::string, int> p = *it;
 
     key = "Group_index_" + boost::lexical_cast<std::string>(i);
     val = " " + p.first + " " + boost::lexical_cast<std::string>(p.second);
     //sprintf( keybuffer, "Group_index_%04d", std::string(i) );
     // sprintf( valbuffer, "%1d %1d", p.first, p.second);
 
     //std::cout << valbuffer << std::endl;
 
     //itk::EncapsulateMetaData< std::string >(input->GetImage()->GetMetaDataDictionary(),std::string(keybuffer),std::string(valbuffer));
     itk::EncapsulateMetaData< std::string >(input->GetImage()->GetMetaDataDictionary(),key,val);
     it++;
     ++i;
   }
 
   key = "Measurement info";
   val = input->GetMeasurementInfo();
   itk::EncapsulateMetaData< std::string >(input->GetImage()->GetMetaDataDictionary(),key,val);
 
 
 
 
 
   typedef itk::VectorImage<float,3> ImageType;
 
   itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
   io->SetFileType( itk::ImageIOBase::Binary );
   io->UseCompressionOn();
 
 
   typedef itk::ImageFileWriter<ImageType> WriterType;
   WriterType::Pointer nrrdWriter = WriterType::New();
   nrrdWriter->UseInputMetaDataDictionaryOn();
   nrrdWriter->SetInput( img );
   nrrdWriter->SetImageIO(io);
   nrrdWriter->SetFileName(m_FileName);
   nrrdWriter->UseCompressionOn();
   nrrdWriter->SetImageIO(io);
   try
   {
     nrrdWriter->Update();
   }
   catch (itk::ExceptionObject e)
   {
     std::cout << e << std::endl;
   }
 
   m_Success = true;
 }
 
 
 
 
 void mitk::NrrdTbssImageWriter::SetInput( InputType* tbssVol )
 {
   this->ProcessObject::SetNthInput( 0, tbssVol );
 }
 
 
 mitk::TbssImage* mitk::NrrdTbssImageWriter::GetInput()
 {
   if ( this->GetNumberOfInputs() < 1 )
   {
     return nullptr;
   }
   else
   {
     return dynamic_cast<InputType*> ( this->ProcessObject::GetInput( 0 ) );
   }
 }
 
 
 std::vector<std::string> mitk::NrrdTbssImageWriter::GetPossibleFileExtensions()
 {
   std::vector<std::string> possibleFileExtensions;
   possibleFileExtensions.push_back(".tbss");
   return possibleFileExtensions;
 }
 
 std::string mitk::NrrdTbssImageWriter::GetSupportedBaseData() const
 {
   return TbssImage::GetStaticNameOfClass();
 }
 
 #endif //__mitkNrrdTbssImageWriter__cpp
diff --git a/Modules/DiffusionImaging/Quantification/cmdapps/MultishellMethods.cpp b/Modules/DiffusionImaging/Quantification/cmdapps/MultishellMethods.cpp
index 3dc5a4d61b..68fc83c1ea 100644
--- a/Modules/DiffusionImaging/Quantification/cmdapps/MultishellMethods.cpp
+++ b/Modules/DiffusionImaging/Quantification/cmdapps/MultishellMethods.cpp
@@ -1,216 +1,216 @@
 /*===================================================================
 
 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 <vector>
 #include <iostream>
 #include <fstream>
 #include <algorithm>
 
 #include <itkImage.h>
 #include <itkImageFileReader.h>
 #include <itkExceptionObject.h>
 #include <itkImageFileWriter.h>
 #include <itkMetaDataObject.h>
 #include <itkVectorImage.h>
 #include <itkResampleImageFilter.h>
 
 #include <mitkImage.h>
 #include <mitkOdfImage.h>
 #include <mitkBaseData.h>
 #include "mitkCommandLineParser.h"
-#include <boost/lexical_cast.hpp>
+#include <mitkLexicalCast.h>
 
 #include <itkRadialMultishellToSingleshellImageFilter.h>
 #include <itkADCAverageFunctor.h>
 #include <itkBiExpFitFunctor.h>
 #include <itkKurtosisFitFunctor.h>
 #include <itkDwiGradientLengthCorrectionFilter.h>
 #include <mitkIOUtil.h>
 #include <mitkDiffusionPropertyHelper.h>
 #include <mitkProperties.h>
 #include <mitkImageCast.h>
 #include <mitkITKImageImport.h>
 #include <mitkPreferenceListReaderOptionsFunctor.h>
 
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
 
   parser.setTitle("Multishell Methods");
   parser.setCategory("Preprocessing Tools");
   parser.setDescription("");
   parser.setContributor("MIC");
 
   parser.setArgumentPrefix("--", "-");
   parser.addArgument("in", "i", mitkCommandLineParser::InputFile, "Input:", "input file", us::Any(), false);
   parser.addArgument("out", "o", mitkCommandLineParser::OutputFile, "Output:", "output file", us::Any(), false);
   parser.addArgument("adc", "D", mitkCommandLineParser::Bool, "ADC:", "ADC Average", us::Any(), false);
   parser.addArgument("akc", "K", mitkCommandLineParser::Bool, "Kurtosis fit:", "Kurtosis Fit", us::Any(), false);
   parser.addArgument("biexp", "B", mitkCommandLineParser::Bool, "BiExp fit:", "BiExp fit", us::Any(), false);
   parser.addArgument("targetbvalue", "b", mitkCommandLineParser::String, "b Value:", "target bValue (mean, min, max)", us::Any(), false);
 
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0)
     return EXIT_FAILURE;
 
   // mandatory arguments
   std::string inName = us::any_cast<std::string>(parsedArgs["in"]);
   std::string outName = us::any_cast<std::string>(parsedArgs["out"]);
   bool applyADC = us::any_cast<bool>(parsedArgs["adc"]);
   bool applyAKC = us::any_cast<bool>(parsedArgs["akc"]);
   bool applyBiExp = us::any_cast<bool>(parsedArgs["biexp"]);
   std::string targetType = us::any_cast<std::string>(parsedArgs["targetbvalue"]);
 
   try
   {
     std::cout << "Loading " << inName;
 
     mitk::PreferenceListReaderOptionsFunctor functor = mitk::PreferenceListReaderOptionsFunctor({"Diffusion Weighted Images"}, {});
     mitk::Image::Pointer dwi = mitk::IOUtil::Load<mitk::Image>(inName, &functor);
 
     if ( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dwi ) )
     {
       typedef itk::RadialMultishellToSingleshellImageFilter<short, short> FilterType;
 
       typedef itk::DwiGradientLengthCorrectionFilter  CorrectionFilterType;
 
       CorrectionFilterType::Pointer roundfilter = CorrectionFilterType::New();
       roundfilter->SetRoundingValue( 1000 );
       roundfilter->SetReferenceBValue(mitk::DiffusionPropertyHelper::GetReferenceBValue( dwi ));
       roundfilter->SetReferenceGradientDirectionContainer(mitk::DiffusionPropertyHelper::GetGradientContainer(dwi));
       roundfilter->Update();
 
       dwi->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( roundfilter->GetNewBValue()  ) );
       dwi->GetPropertyList()->ReplaceProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( roundfilter->GetOutputGradientDirectionContainer() ) );
 
       // filter input parameter
       const mitk::DiffusionPropertyHelper::BValueMapType
         &originalShellMap  = mitk::DiffusionPropertyHelper::GetBValueMap(dwi);
 
       mitk::DiffusionPropertyHelper::ImageType::Pointer vectorImage = mitk::DiffusionPropertyHelper::ImageType::New();
       mitk::CastToItkImage(dwi, vectorImage);
 
       const mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::Pointer
           gradientContainer = mitk::DiffusionPropertyHelper::GetGradientContainer(dwi);
 
       const unsigned int
           &bValue            = mitk::DiffusionPropertyHelper::GetReferenceBValue( dwi );
 
       // filter call
 
 
       vnl_vector<double> bValueList(originalShellMap.size()-1);
       double targetBValue = bValueList.mean();
 
       mitk::DiffusionPropertyHelper::BValueMapType::const_iterator it = originalShellMap.begin();
       ++it; int i = 0 ;
       for(; it != originalShellMap.end(); ++it)
         bValueList.put(i++,it->first);
 
       if( targetType == "mean" )
         targetBValue = bValueList.mean();
       else if( targetType == "min" )
         targetBValue = bValueList.min_value();
       else if( targetType == "max" )
         targetBValue = bValueList.max_value();
 
       if(applyADC)
       {
         FilterType::Pointer filter = FilterType::New();
         filter->SetInput(vectorImage);
         filter->SetOriginalGradientDirections(gradientContainer);
         filter->SetOriginalBValueMap(originalShellMap);
         filter->SetOriginalBValue(bValue);
 
         itk::ADCAverageFunctor::Pointer functor = itk::ADCAverageFunctor::New();
         functor->setListOfBValues(bValueList);
         functor->setTargetBValue(targetBValue);
 
         filter->SetFunctor(functor);
         filter->Update();
         // create new DWI image
         mitk::Image::Pointer outImage = mitk::GrabItkImageMemory( filter->GetOutput() );
         outImage->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( targetBValue  ) );
         outImage->GetPropertyList()->ReplaceProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( filter->GetTargetGradientDirections() ) );
         mitk::DiffusionPropertyHelper propertyHelper( outImage );
         propertyHelper.InitializeImage();
 
         mitk::IOUtil::Save(outImage, (outName + "_ADC.dwi").c_str());
       }
       if(applyAKC)
       {
         FilterType::Pointer filter = FilterType::New();
         filter->SetInput(vectorImage);
         filter->SetOriginalGradientDirections(gradientContainer);
         filter->SetOriginalBValueMap(originalShellMap);
         filter->SetOriginalBValue(bValue);
 
         itk::KurtosisFitFunctor::Pointer functor = itk::KurtosisFitFunctor::New();
         functor->setListOfBValues(bValueList);
         functor->setTargetBValue(targetBValue);
 
         filter->SetFunctor(functor);
         filter->Update();
         // create new DWI image
         mitk::Image::Pointer outImage = mitk::GrabItkImageMemory( filter->GetOutput() );
         outImage->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( targetBValue  ) );
         outImage->GetPropertyList()->ReplaceProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( filter->GetTargetGradientDirections() ) );
         mitk::DiffusionPropertyHelper propertyHelper( outImage );
         propertyHelper.InitializeImage();
 
         mitk::IOUtil::Save(outImage, (std::string(outName) + "_AKC.dwi").c_str());
       }
       if(applyBiExp)
       {
         FilterType::Pointer filter = FilterType::New();
         filter->SetInput(vectorImage);
         filter->SetOriginalGradientDirections(gradientContainer);
         filter->SetOriginalBValueMap(originalShellMap);
         filter->SetOriginalBValue(bValue);
 
         itk::BiExpFitFunctor::Pointer functor = itk::BiExpFitFunctor::New();
         functor->setListOfBValues(bValueList);
         functor->setTargetBValue(targetBValue);
 
         filter->SetFunctor(functor);
         filter->Update();
         // create new DWI image
         mitk::Image::Pointer outImage = mitk::GrabItkImageMemory( filter->GetOutput() );
         outImage->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( targetBValue  ) );
         outImage->GetPropertyList()->ReplaceProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( filter->GetTargetGradientDirections() ) );
         mitk::DiffusionPropertyHelper propertyHelper( outImage );
         propertyHelper.InitializeImage();
 
         mitk::IOUtil::Save(outImage, (std::string(outName) + "_BiExp.dwi").c_str());
       }
     }
   }
   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/Quantification/cmdapps/QballReconstruction.cpp b/Modules/DiffusionImaging/Quantification/cmdapps/QballReconstruction.cpp
index dc12f4571a..01c2dab1ab 100644
--- a/Modules/DiffusionImaging/Quantification/cmdapps/QballReconstruction.cpp
+++ b/Modules/DiffusionImaging/Quantification/cmdapps/QballReconstruction.cpp
@@ -1,263 +1,263 @@
 /*===================================================================
 
 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 <mitkCoreObjectFactory.h>
 #include "mitkImage.h"
 #include "itkAnalyticalDiffusionQballReconstructionImageFilter.h"
-#include <boost/lexical_cast.hpp>
+#include <mitkLexicalCast.h>
 #include "mitkCommandLineParser.h"
 #include <mitkIOUtil.h>
 #include <itksys/SystemTools.hxx>
 #include <mitkDiffusionPropertyHelper.h>
 #include <mitkITKImageImport.h>
 #include <mitkImageCast.h>
 #include <mitkProperties.h>
 #include <mitkIOUtil.h>
 #include <mitkPreferenceListReaderOptionsFunctor.h>
 
 /**
  * Perform Q-ball reconstruction using a spherical harmonics basis
  */
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
   parser.setArgumentPrefix("--", "-");
   parser.addArgument("input", "i", mitkCommandLineParser::InputFile, "Input file", "input raw dwi (.dwi or .nii/.nii.gz)", us::Any(), false);
   parser.addArgument("outFile", "o", mitkCommandLineParser::OutputFile, "Output file", "output file", us::Any(), false);
   parser.addArgument("shOrder", "sh", mitkCommandLineParser::Int, "Spherical harmonics order", "spherical harmonics order", 4, true);
   parser.addArgument("b0Threshold", "t", mitkCommandLineParser::Int, "b0 threshold", "baseline image intensity threshold", 0, true);
   parser.addArgument("lambda", "r", mitkCommandLineParser::Float, "Lambda", "ragularization factor lambda", 0.006, true);
   parser.addArgument("csa", "csa", mitkCommandLineParser::Bool, "Constant solid angle consideration", "use constant solid angle consideration");
   parser.addArgument("outputCoeffs", "shc", mitkCommandLineParser::Bool, "Output coefficients", "output file containing the SH coefficients");
   parser.addArgument("mrtrix", "mb", mitkCommandLineParser::Bool, "MRtrix", "use MRtrix compatible spherical harmonics definition");
 
   parser.setCategory("Signal Modelling");
   parser.setTitle("Qball Reconstruction");
   parser.setDescription("");
   parser.setContributor("MIC");
 
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0)
     return EXIT_FAILURE;
 
   std::string inFileName = us::any_cast<std::string>(parsedArgs["input"]);
   std::string outfilename = us::any_cast<std::string>(parsedArgs["outFile"]);
   outfilename = itksys::SystemTools::GetFilenamePath(outfilename)+"/"+itksys::SystemTools::GetFilenameWithoutExtension(outfilename);
 
   int threshold = 0;
   if (parsedArgs.count("b0Threshold"))
     threshold = us::any_cast<int>(parsedArgs["b0Threshold"]);
 
   int shOrder = 4;
   if (parsedArgs.count("shOrder"))
     shOrder = us::any_cast<int>(parsedArgs["shOrder"]);
 
   float lambda = 0.006;
   if (parsedArgs.count("lambda"))
     lambda = us::any_cast<float>(parsedArgs["lambda"]);
 
   int normalization = 0;
   if (parsedArgs.count("csa") && us::any_cast<bool>(parsedArgs["csa"]))
     normalization = 6;
 
   bool outCoeffs = false;
   if (parsedArgs.count("outputCoeffs"))
     outCoeffs = us::any_cast<bool>(parsedArgs["outputCoeffs"]);
 
   bool mrTrix = false;
   if (parsedArgs.count("mrtrix"))
     mrTrix = us::any_cast<bool>(parsedArgs["mrtrix"]);
 
   try
   {
     mitk::PreferenceListReaderOptionsFunctor functor = mitk::PreferenceListReaderOptionsFunctor({"Diffusion Weighted Images"}, {});
     std::vector< mitk::BaseData::Pointer > infile = mitk::IOUtil::Load(inFileName, &functor);
 
     mitk::Image::Pointer dwi = dynamic_cast<mitk::Image*>(infile.at(0).GetPointer());
     mitk::DiffusionPropertyHelper propertyHelper(dwi);
     propertyHelper.AverageRedundantGradients(0.001);
     propertyHelper.InitializeImage();
 
     mitk::OdfImage::Pointer image = mitk::OdfImage::New();
     mitk::Image::Pointer coeffsImage = mitk::Image::New();
 
     std::cout << "SH order: " << shOrder;
     std::cout << "lambda: " << lambda;
     std::cout << "B0 threshold: " << threshold;
     switch ( shOrder )
     {
     case 4:
     {
       typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,4,ODF_SAMPLING_SIZE> FilterType;
       mitk::DiffusionPropertyHelper::ImageType::Pointer itkVectorImagePointer = mitk::DiffusionPropertyHelper::ImageType::New();
       mitk::CastToItkImage(dwi, itkVectorImagePointer);
 
       FilterType::Pointer filter = FilterType::New();
       filter->SetBValue(mitk::DiffusionPropertyHelper::GetReferenceBValue(dwi));
       filter->SetGradientImage( mitk::DiffusionPropertyHelper::GetGradientContainer(dwi), itkVectorImagePointer );
       filter->SetThreshold( threshold );
       filter->SetLambda(lambda);
       filter->SetUseMrtrixBasis(mrTrix);
       if (normalization==0)
         filter->SetNormalizationMethod(FilterType::QBAR_STANDARD);
       else
         filter->SetNormalizationMethod(FilterType::QBAR_SOLID_ANGLE);
       filter->Update();
       image->InitializeByItk( filter->GetOutput() );
       image->SetVolume( filter->GetOutput()->GetBufferPointer() );
       coeffsImage->InitializeByItk( filter->GetCoefficientImage().GetPointer() );
       coeffsImage->SetVolume( filter->GetCoefficientImage()->GetBufferPointer() );
       break;
     }
     case 6:
     {
       typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,6,ODF_SAMPLING_SIZE> FilterType;
       mitk::DiffusionPropertyHelper::ImageType::Pointer itkVectorImagePointer = mitk::DiffusionPropertyHelper::ImageType::New();
       mitk::CastToItkImage(dwi, itkVectorImagePointer);
 
       FilterType::Pointer filter = FilterType::New();
       filter->SetBValue(mitk::DiffusionPropertyHelper::GetReferenceBValue(dwi));
       filter->SetGradientImage( mitk::DiffusionPropertyHelper::GetGradientContainer(dwi), itkVectorImagePointer );
       filter->SetThreshold( threshold );
       filter->SetLambda(lambda);
       filter->SetUseMrtrixBasis(mrTrix);
       if (normalization==0)
         filter->SetNormalizationMethod(FilterType::QBAR_STANDARD);
       else
         filter->SetNormalizationMethod(FilterType::QBAR_SOLID_ANGLE);
       filter->Update();
       image->InitializeByItk( filter->GetOutput() );
       image->SetVolume( filter->GetOutput()->GetBufferPointer() );
       coeffsImage->InitializeByItk( filter->GetCoefficientImage().GetPointer() );
       coeffsImage->SetVolume( filter->GetCoefficientImage()->GetBufferPointer() );
       break;
     }
     case 8:
     {
       typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,8,ODF_SAMPLING_SIZE> FilterType;
       mitk::DiffusionPropertyHelper::ImageType::Pointer itkVectorImagePointer = mitk::DiffusionPropertyHelper::ImageType::New();
       mitk::CastToItkImage(dwi, itkVectorImagePointer);
 
       FilterType::Pointer filter = FilterType::New();
       filter->SetBValue(mitk::DiffusionPropertyHelper::GetReferenceBValue(dwi));
       filter->SetGradientImage( mitk::DiffusionPropertyHelper::GetGradientContainer(dwi), itkVectorImagePointer );
       filter->SetThreshold( threshold );
       filter->SetLambda(lambda);
       filter->SetUseMrtrixBasis(mrTrix);
       if (normalization==0)
         filter->SetNormalizationMethod(FilterType::QBAR_STANDARD);
       else
         filter->SetNormalizationMethod(FilterType::QBAR_SOLID_ANGLE);
       filter->Update();
       image->InitializeByItk( filter->GetOutput() );
       image->SetVolume( filter->GetOutput()->GetBufferPointer() );
       coeffsImage->InitializeByItk( filter->GetCoefficientImage().GetPointer() );
       coeffsImage->SetVolume( filter->GetCoefficientImage()->GetBufferPointer() );
       break;
     }
     case 10:
     {
       typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,10,ODF_SAMPLING_SIZE> FilterType;
       mitk::DiffusionPropertyHelper::ImageType::Pointer itkVectorImagePointer = mitk::DiffusionPropertyHelper::ImageType::New();
       mitk::CastToItkImage(dwi, itkVectorImagePointer);
 
       FilterType::Pointer filter = FilterType::New();
       filter->SetBValue(mitk::DiffusionPropertyHelper::GetReferenceBValue(dwi));
       filter->SetGradientImage( mitk::DiffusionPropertyHelper::GetGradientContainer(dwi), itkVectorImagePointer );
       filter->SetThreshold( threshold );
       filter->SetLambda(lambda);
       filter->SetUseMrtrixBasis(mrTrix);
       if (normalization==0)
         filter->SetNormalizationMethod(FilterType::QBAR_STANDARD);
       else
         filter->SetNormalizationMethod(FilterType::QBAR_SOLID_ANGLE);
       filter->Update();
       image->InitializeByItk( filter->GetOutput() );
       image->SetVolume( filter->GetOutput()->GetBufferPointer() );
       coeffsImage->InitializeByItk( filter->GetCoefficientImage().GetPointer() );
       coeffsImage->SetVolume( filter->GetCoefficientImage()->GetBufferPointer() );
       break;
     }
     case 12:
     {
       typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,12,ODF_SAMPLING_SIZE> FilterType;
       mitk::DiffusionPropertyHelper::ImageType::Pointer itkVectorImagePointer = mitk::DiffusionPropertyHelper::ImageType::New();
       mitk::CastToItkImage(dwi, itkVectorImagePointer);
 
       FilterType::Pointer filter = FilterType::New();
       filter->SetBValue(mitk::DiffusionPropertyHelper::GetReferenceBValue(dwi));
       filter->SetGradientImage( mitk::DiffusionPropertyHelper::GetGradientContainer(dwi), itkVectorImagePointer );
       filter->SetThreshold( threshold );
       filter->SetLambda(lambda);
       if (normalization==0)
         filter->SetNormalizationMethod(FilterType::QBAR_STANDARD);
       else
         filter->SetNormalizationMethod(FilterType::QBAR_SOLID_ANGLE);
       filter->Update();
       image->InitializeByItk( filter->GetOutput() );
       image->SetVolume( filter->GetOutput()->GetBufferPointer() );
       coeffsImage->InitializeByItk( filter->GetCoefficientImage().GetPointer() );
       coeffsImage->SetVolume( filter->GetCoefficientImage()->GetBufferPointer() );
       break;
     }
     default:
     {
       std::cout << "Supplied SH order not supported. Using default order of 4.";
       typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,4,ODF_SAMPLING_SIZE> FilterType;
       mitk::DiffusionPropertyHelper::ImageType::Pointer itkVectorImagePointer = mitk::DiffusionPropertyHelper::ImageType::New();
       mitk::CastToItkImage(dwi, itkVectorImagePointer);
 
       FilterType::Pointer filter = FilterType::New();
       filter->SetBValue(mitk::DiffusionPropertyHelper::GetReferenceBValue(dwi));
       filter->SetGradientImage( mitk::DiffusionPropertyHelper::GetGradientContainer(dwi), itkVectorImagePointer );
       filter->SetThreshold( threshold );
       filter->SetLambda(lambda);
       filter->SetUseMrtrixBasis(mrTrix);
       if (normalization==0)
         filter->SetNormalizationMethod(FilterType::QBAR_STANDARD);
       else
         filter->SetNormalizationMethod(FilterType::QBAR_SOLID_ANGLE);
       filter->Update();
       image->InitializeByItk( filter->GetOutput() );
       image->SetVolume( filter->GetOutput()->GetBufferPointer() );
       coeffsImage->InitializeByItk( filter->GetCoefficientImage().GetPointer() );
       coeffsImage->SetVolume( filter->GetCoefficientImage()->GetBufferPointer() );
     }
     }
 
     std::string coeffout = outfilename;
     coeffout += "_shcoeffs.nrrd";
 
     outfilename += ".odf";
     mitk::IOUtil::Save(image, outfilename);
 
     if (outCoeffs)
       mitk::IOUtil::Save(coeffsImage, coeffout);
   }
   catch ( itk::ExceptionObject &err)
   {
     std::cout << "Exception: " << err;
   }
   catch ( std::exception err)
   {
     std::cout << "Exception: " << err.what();
   }
   catch ( ... )
   {
     std::cout << "Exception!";
   }
   return EXIT_SUCCESS;
 }
diff --git a/Modules/SceneSerializationBase/include/mitkStringsToNumbers.h b/Modules/SceneSerializationBase/include/mitkStringsToNumbers.h
index 7f3ab613f8..f94a1e6a44 100644
--- a/Modules/SceneSerializationBase/include/mitkStringsToNumbers.h
+++ b/Modules/SceneSerializationBase/include/mitkStringsToNumbers.h
@@ -1,61 +1,61 @@
 /*===================================================================
 
 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 mitkVectorPropertySerializer_h
 #define mitkVectorPropertySerializer_h
 
-#include <boost/lexical_cast.hpp>
+#include <mitkLexicalCast.h>
 
 namespace mitk
 {
   //! Convert an array of strings to an array of numbers via boost::lexical_cast.
   //!
   //! Call mitk::StringsToNumbers for all count elements of something that can be accessed
   //! via operator[], e.g. to fill a Point3D / Vector3D.
   //!
   //! \param count the number of elements to convert from "strings" to "numbers"
   //! \param numbers a container for at least "count" numeric values with indices starting from 0
   //! \param strings a container for at least three string values with indices starting from 0
   //!
   //! \warning This method has absolutely no means of verifying that your containers
   //!          are big enough. It is the caller's responsibility to make sure that
   //!          both the input and the output container can be addressed via [0], [1], [2].
   //!
   //! \exception propagates boost::bad_lexical_cast exception when unparsable strings are encountered
   //!
   //! \code
   //! std::vector<std::string> serialized_double_values = ... read from some file ...
   //! mitk::Point3D point;
   //! try
   //! {
   //!   mitk::StringToDouble(3, serialized_double_values, point);
   //! }
   //! catch (boost::bad_lexical_cast& e)
   //! {
   //!   MITK_ERROR << "Bad cast from string to double: " << e.what();
   //! }
   //! \endcode
   template <typename NUMBER_TYPE, typename STRING_ARRAY, typename DOUBLE_ARRAY>
   void StringsToNumbers(unsigned int count, const STRING_ARRAY &strings, DOUBLE_ARRAY &numbers)
   {
     for (unsigned int i = 0; i < count; ++i)
     {
       numbers[i] = boost::lexical_cast<NUMBER_TYPE>(strings[i]);
     }
   }
 }
 
 #endif
diff --git a/Modules/SceneSerializationBase/include/mitkVectorPropertySerializer.h b/Modules/SceneSerializationBase/include/mitkVectorPropertySerializer.h
index 9fe5c58daa..4721c0ad92 100644
--- a/Modules/SceneSerializationBase/include/mitkVectorPropertySerializer.h
+++ b/Modules/SceneSerializationBase/include/mitkVectorPropertySerializer.h
@@ -1,157 +1,157 @@
 /*===================================================================
 
 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 mitkVectorPropertySerializer_h
 #define mitkVectorPropertySerializer_h
 
 #include "mitkBasePropertySerializer.h"
 
 #include "mitkVectorProperty.h"
 
-#include <boost/lexical_cast.hpp>
+#include <mitkLexicalCast.h>
 
 namespace mitk
 {
   /**
     \brief Serializes a VectorProperty
 
     Serializes an instance of VectorProperty into a XML structure like
 
     \verbatim
     <Values>
       <Value idx="0" value="17.3"/>
       <Value idx="1" value="7.2"/>
       <Value idx="2" value="-17.3"/>
     </Values>
     \endverbatim
 
     This class is implemented as a template and makes use of std::stringstream
     for necessary conversions of specific data types to and from string.
 
     For numeric types, the class adds a precision token to stringstream that
     should usually suffice.
   */
   template <typename DATATYPE>
   class MITKSCENESERIALIZATIONBASE_EXPORT VectorPropertySerializer : public BasePropertySerializer
   {
   public:
     // Expand manually most of mitkClassMacro:
     // mitkClassMacro(VectorProperty<DATATYPE>, mitk::BaseProperty);
     // This manual expansion is done to override explicitely
     // the GetNameOfClass methods
     typedef VectorProperty<DATATYPE> PropertyType;
     typedef VectorPropertySerializer<DATATYPE> Self;
     typedef BasePropertySerializer SuperClass;
     typedef itk::SmartPointer<Self> Pointer;
     typedef itk::SmartPointer<const Self> ConstPointer;
     std::vector<std::string> GetClassHierarchy() const override { return mitk::GetClassHierarchy<Self>(); }
     // This function must return different
     // strings in function of the template parameter!
     // Serialization depends on this feature.
     static const char *GetStaticNameOfClass()
     {
       // concatenate a prefix dependent on the template type and our own classname
       static std::string nameOfClass =
         std::string(VectorPropertyDataType<DATATYPE>::prefix()) + "VectorPropertySerializer";
       return nameOfClass.c_str();
     }
 
     const char *GetNameOfClass() const override { return this->GetStaticNameOfClass(); }
     itkFactorylessNewMacro(Self);
     itkCloneMacro(Self)
 
       //! Build an XML version of this property
       TiXmlElement *Serialize() override
     {
       auto listElement = new TiXmlElement("Values");
 
       if (const PropertyType *prop = dynamic_cast<const PropertyType *>(m_Property.GetPointer()))
       {
         typename PropertyType::VectorType elements = prop->GetValue();
         unsigned int index(0);
         for (auto listEntry : elements)
         {
           std::stringstream indexS;
           indexS << index++;
 
           auto entryElement = new TiXmlElement("Value");
           entryElement->SetAttribute("idx", indexS.str());
           entryElement->SetAttribute("value", boost::lexical_cast<std::string>(listEntry));
           listElement->LinkEndChild(entryElement);
         }
 
         return listElement;
       }
       else
       {
         return nullptr;
       }
     }
 
     //! Construct a property from an XML serialization
     BaseProperty::Pointer Deserialize(TiXmlElement *listElement) override
     {
       typename PropertyType::VectorType datalist;
 
       if (listElement)
       {
         MITK_DEBUG << "Deserializing " << *listElement;
 
         unsigned int index(0);
         std::string valueString;
         DATATYPE value;
         for (TiXmlElement *valueElement = listElement->FirstChildElement("Value"); valueElement;
              valueElement = valueElement->NextSiblingElement("Value"))
         {
           if (valueElement->QueryValueAttribute("value", &valueString) != TIXML_SUCCESS)
           {
             MITK_ERROR << "Missing value attribute in <Values> list";
             return nullptr;
           }
 
           try
           {
             value = boost::lexical_cast<DATATYPE>(valueString);
           }
           catch (boost::bad_lexical_cast &e)
           {
             MITK_ERROR << "Could not parse '" << valueString << "' as number: " << e.what();
             return nullptr;
           }
 
           datalist.push_back(value);
           ++index;
         }
 
         typename PropertyType::Pointer property = PropertyType::New();
         property->SetValue(datalist);
         return property.GetPointer();
       }
       else
       {
         MITK_ERROR << "Missing <Values> tag.";
       }
 
       return nullptr;
     }
   };
 
   typedef VectorPropertySerializer<double> DoubleVectorPropertySerializer;
   typedef VectorPropertySerializer<int> IntVectorPropertySerializer;
 
 } // namespace
 
 #endif
diff --git a/Modules/SceneSerializationBase/src/mitkDoublePropertySerializer.cpp b/Modules/SceneSerializationBase/src/mitkDoublePropertySerializer.cpp
index 87fe4909fd..483b36fe00 100644
--- a/Modules/SceneSerializationBase/src/mitkDoublePropertySerializer.cpp
+++ b/Modules/SceneSerializationBase/src/mitkDoublePropertySerializer.cpp
@@ -1,87 +1,87 @@
 /*===================================================================
 
 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 mitkDoublePropertySerializer_h_included
 #define mitkDoublePropertySerializer_h_included
 
 #include "mitkBasePropertySerializer.h"
 
 #include "mitkProperties.h"
-#include <boost/lexical_cast.hpp>
+#include <mitkLexicalCast.h>
 
 #include <MitkSceneSerializationBaseExports.h>
 
 #include <mitkLocaleSwitch.h>
 
 namespace mitk
 {
   class DoublePropertySerializer : public BasePropertySerializer
   {
   public:
     mitkClassMacro(DoublePropertySerializer, BasePropertySerializer);
     itkFactorylessNewMacro(Self) itkCloneMacro(Self)
 
       TiXmlElement *Serialize() override
     {
       if (const DoubleProperty *prop = dynamic_cast<const DoubleProperty *>(m_Property.GetPointer()))
       {
         LocaleSwitch localeSwitch("C");
 
         auto element = new TiXmlElement("double");
         element->SetAttribute("value", boost::lexical_cast<std::string>(prop->GetValue()));
         return element;
       }
       else
         return nullptr;
     }
 
     BaseProperty::Pointer Deserialize(TiXmlElement *element) override
     {
       if (!element)
         return nullptr;
 
       LocaleSwitch localeSwitch("C");
 
       std::string d;
       if (element->QueryStringAttribute("value", &d) == TIXML_SUCCESS)
       {
         try
         {
           return DoubleProperty::New(boost::lexical_cast<double>(d)).GetPointer();
         }
         catch (boost::bad_lexical_cast &e)
         {
           MITK_ERROR << "Could not parse string as number: " << e.what();
           return nullptr;
         }
       }
       else
       {
         return nullptr;
       }
     }
 
   protected:
     DoublePropertySerializer() {}
     ~DoublePropertySerializer() override {}
   };
 
 } // namespace
 
 // important to put this into the GLOBAL namespace (because it starts with 'namespace mitk')
 MITK_REGISTER_SERIALIZER(DoublePropertySerializer);
 
 #endif
diff --git a/Modules/SceneSerializationBase/src/mitkFloatLookupTablePropertySerializer.cpp b/Modules/SceneSerializationBase/src/mitkFloatLookupTablePropertySerializer.cpp
index 56e1657a10..ea6bb8630f 100644
--- a/Modules/SceneSerializationBase/src/mitkFloatLookupTablePropertySerializer.cpp
+++ b/Modules/SceneSerializationBase/src/mitkFloatLookupTablePropertySerializer.cpp
@@ -1,95 +1,95 @@
 /*===================================================================
 
 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 mitkFloatLookupTablePropertySerializer_h_included
 #define mitkFloatLookupTablePropertySerializer_h_included
 
 #include "mitkBasePropertySerializer.h"
 #include "mitkProperties.h"
-#include <boost/lexical_cast.hpp>
+#include <mitkLexicalCast.h>
 #include <mitkLocaleSwitch.h>
 
 namespace mitk
 {
   class FloatLookupTablePropertySerializer : public BasePropertySerializer
   {
   public:
     mitkClassMacro(FloatLookupTablePropertySerializer, BasePropertySerializer);
     itkFactorylessNewMacro(Self) itkCloneMacro(Self)
 
       TiXmlElement *Serialize() override
     {
       const FloatLookupTableProperty *prop = dynamic_cast<const FloatLookupTableProperty *>(m_Property.GetPointer());
       if (prop == nullptr)
         return nullptr;
 
       LocaleSwitch localeSwitch("C");
 
       FloatLookupTable lut = prop->GetValue();
       // if (lut.IsNull())
       //  return nullptr; // really?
       const FloatLookupTable::LookupTableType &map = lut.GetLookupTable();
 
       auto element = new TiXmlElement("FloatLookupTableTable");
       for (auto it = map.begin(); it != map.end(); ++it)
       {
         auto tableEntry = new TiXmlElement("LUTValue");
         tableEntry->SetAttribute("id", it->first);
         tableEntry->SetAttribute("value", boost::lexical_cast<std::string>(it->second));
         element->LinkEndChild(tableEntry);
       }
       return element;
     }
 
     BaseProperty::Pointer Deserialize(TiXmlElement *element) override
     {
       if (!element)
         return nullptr;
 
       LocaleSwitch localeSwitch("C");
 
       FloatLookupTable lut;
       for (TiXmlElement *child = element->FirstChildElement("LUTValue"); child != nullptr;
            child = child->NextSiblingElement("LUTValue"))
       {
         int tempID;
         if (child->QueryIntAttribute("id", &tempID) != TIXML_SUCCESS)
           return nullptr;
         FloatLookupTable::IdentifierType id = static_cast<FloatLookupTable::IdentifierType>(tempID);
         std::string value_string;
         if (child->QueryStringAttribute("value", &value_string) != TIXML_SUCCESS)
           return nullptr;
         try
         {
           lut.SetTableValue(id, boost::lexical_cast<float>(value_string));
         }
         catch (boost::bad_lexical_cast &e)
         {
           MITK_ERROR << "Could not parse string as number: " << e.what();
           return nullptr;
         }
       }
       return FloatLookupTableProperty::New(lut).GetPointer();
     }
 
   protected:
     FloatLookupTablePropertySerializer() {}
     ~FloatLookupTablePropertySerializer() override {}
   };
 } // namespace
 // important to put this into the GLOBAL namespace (because it starts with 'namespace mitk')
 MITK_REGISTER_SERIALIZER(FloatLookupTablePropertySerializer);
 #endif
diff --git a/Modules/SceneSerializationBase/src/mitkLevelWindowPropertySerializer.cpp b/Modules/SceneSerializationBase/src/mitkLevelWindowPropertySerializer.cpp
index 455dbc0097..79f1c217d2 100644
--- a/Modules/SceneSerializationBase/src/mitkLevelWindowPropertySerializer.cpp
+++ b/Modules/SceneSerializationBase/src/mitkLevelWindowPropertySerializer.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.
 
 ===================================================================*/
 
 #ifndef mitkLevelWindowPropertySerializer_h_included
 #define mitkLevelWindowPropertySerializer_h_included
 
 #include "mitkBasePropertySerializer.h"
 #include "mitkLevelWindowProperty.h"
-#include <boost/lexical_cast.hpp>
+#include <mitkLexicalCast.h>
 #include <mitkLocaleSwitch.h>
 
 namespace mitk
 {
   class LevelWindowPropertySerializer : public BasePropertySerializer
   {
   public:
     mitkClassMacro(LevelWindowPropertySerializer, BasePropertySerializer);
     itkFactorylessNewMacro(Self) itkCloneMacro(Self)
 
       TiXmlElement *Serialize() override
     {
       if (const LevelWindowProperty *prop = dynamic_cast<const LevelWindowProperty *>(m_Property.GetPointer()))
       {
         LocaleSwitch localeSwitch("C");
 
         auto element = new TiXmlElement("LevelWindow");
 
         LevelWindow lw = prop->GetLevelWindow();
         std::string boolString("false");
         if (lw.IsFixed() == true)
           boolString = "true";
         element->SetAttribute("fixed", boolString.c_str());
 
         std::string boolStringFltImage("false");
         if (lw.IsFloatingValues() == true)
           boolStringFltImage = "true";
         element->SetAttribute("isFloatingImage", boolStringFltImage.c_str());
 
         auto child = new TiXmlElement("CurrentSettings");
         element->LinkEndChild(child);
         child->SetAttribute("level", boost::lexical_cast<std::string>(lw.GetLevel()));
         child->SetAttribute("window", boost::lexical_cast<std::string>(lw.GetWindow()));
 
         child = new TiXmlElement("DefaultSettings");
         element->LinkEndChild(child);
         child->SetAttribute("level", boost::lexical_cast<std::string>(lw.GetDefaultLevel()));
         child->SetAttribute("window", boost::lexical_cast<std::string>(lw.GetDefaultWindow()));
 
         child = new TiXmlElement("CurrentRange");
         element->LinkEndChild(child);
         child->SetAttribute("min", boost::lexical_cast<std::string>(lw.GetRangeMin()));
         child->SetAttribute("max", boost::lexical_cast<std::string>(lw.GetRangeMax()));
 
         return element;
       }
       else
         return nullptr;
     }
 
     BaseProperty::Pointer Deserialize(TiXmlElement *element) override
     {
       if (!element)
         return nullptr;
 
       LocaleSwitch localeSwitch("C");
 
       bool isFixed(false);
       if (element->Attribute("fixed"))
         isFixed = std::string(element->Attribute("fixed")) == "true";
       bool isFloatingImage(false);
       if (element->Attribute("isFloatingImage"))
         isFloatingImage = std::string(element->Attribute("isFloatingImage")) == "true";
 
       std::string level_string;
       std::string window_string;
       TiXmlElement *child = element->FirstChildElement("CurrentSettings");
       if (child->QueryStringAttribute("level", &level_string) != TIXML_SUCCESS)
         return nullptr;
       if (child->QueryStringAttribute("window", &window_string) != TIXML_SUCCESS)
         return nullptr;
 
       std::string defaultLevel_string;
       std::string defaultWindow_string;
       child = element->FirstChildElement("DefaultSettings");
       if (child->QueryStringAttribute("level", &defaultLevel_string) != TIXML_SUCCESS)
         return nullptr;
       if (child->QueryStringAttribute("window", &defaultWindow_string) != TIXML_SUCCESS)
         return nullptr;
 
       std::string minRange_string;
       std::string maxRange_string;
       child = element->FirstChildElement("CurrentRange");
       if (child->QueryStringAttribute("min", &minRange_string) != TIXML_SUCCESS)
         return nullptr;
       if (child->QueryStringAttribute("max", &maxRange_string) != TIXML_SUCCESS)
         return nullptr;
 
       LevelWindow lw;
       try
       {
         lw.SetRangeMinMax(boost::lexical_cast<double>(minRange_string), boost::lexical_cast<double>(maxRange_string));
         lw.SetDefaultLevelWindow(boost::lexical_cast<double>(defaultLevel_string),
                                  boost::lexical_cast<double>(defaultWindow_string));
         lw.SetLevelWindow(boost::lexical_cast<double>(level_string), boost::lexical_cast<double>(window_string));
         lw.SetFixed(isFixed);
         lw.SetFloatingValues(isFloatingImage);
       }
       catch (boost::bad_lexical_cast &e)
       {
         MITK_ERROR << "Could not parse string as number: " << e.what();
         return nullptr;
       }
       return LevelWindowProperty::New(lw).GetPointer();
     }
 
   protected:
     LevelWindowPropertySerializer() {}
     ~LevelWindowPropertySerializer() override {}
   };
 
 } // namespace
 
 // important to put this into the GLOBAL namespace (because it starts with 'namespace mitk')
 MITK_REGISTER_SERIALIZER(LevelWindowPropertySerializer);
 
 #endif
diff --git a/Modules/SceneSerializationBase/src/mitkTransferFunctionPropertySerializer.cpp b/Modules/SceneSerializationBase/src/mitkTransferFunctionPropertySerializer.cpp
index 27a4213e6d..42d29cbae9 100644
--- a/Modules/SceneSerializationBase/src/mitkTransferFunctionPropertySerializer.cpp
+++ b/Modules/SceneSerializationBase/src/mitkTransferFunctionPropertySerializer.cpp
@@ -1,264 +1,264 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "mitkTransferFunctionPropertySerializer.h"
-#include <boost/lexical_cast.hpp>
+#include <mitkLexicalCast.h>
 #include <mitkLocaleSwitch.h>
 
 namespace mitk
 {
   mitk::TransferFunctionPropertySerializer::TransferFunctionPropertySerializer() {}
   mitk::TransferFunctionPropertySerializer::~TransferFunctionPropertySerializer() {}
   TiXmlElement *mitk::TransferFunctionPropertySerializer::Serialize()
   {
     if (const auto *prop =
           dynamic_cast<const TransferFunctionProperty *>(mitk::BasePropertySerializer::m_Property.GetPointer()))
     {
       LocaleSwitch localeSwitch("C");
 
       TransferFunction *transferfunction = prop->GetValue();
       if (!transferfunction)
         return nullptr;
 
       auto element = new TiXmlElement("TransferFunction");
 
       // serialize scalar opacity function
       auto scalarOpacityPointlist = new TiXmlElement("ScalarOpacity");
 
       TransferFunction::ControlPoints scalarOpacityPoints = transferfunction->GetScalarOpacityPoints();
       for (auto iter = scalarOpacityPoints.begin(); iter != scalarOpacityPoints.end(); ++iter)
       {
         auto pointel = new TiXmlElement("point");
         pointel->SetAttribute("x", boost::lexical_cast<std::string>(iter->first));
         pointel->SetAttribute("y", boost::lexical_cast<std::string>(iter->second));
         scalarOpacityPointlist->LinkEndChild(pointel);
       }
       element->LinkEndChild(scalarOpacityPointlist);
       // serialize gradient opacity function
       auto gradientOpacityPointlist = new TiXmlElement("GradientOpacity");
       TransferFunction::ControlPoints gradientOpacityPoints = transferfunction->GetGradientOpacityPoints();
       for (auto iter = gradientOpacityPoints.begin(); iter != gradientOpacityPoints.end(); ++iter)
       {
         auto pointel = new TiXmlElement("point");
         pointel->SetAttribute("x", boost::lexical_cast<std::string>(iter->first));
         pointel->SetAttribute("y", boost::lexical_cast<std::string>(iter->second));
         gradientOpacityPointlist->LinkEndChild(pointel);
       }
       element->LinkEndChild(gradientOpacityPointlist);
 
       // serialize color function
       vtkColorTransferFunction *ctf = transferfunction->GetColorTransferFunction();
       if (ctf == nullptr)
         return nullptr;
       auto pointlist = new TiXmlElement("Color");
       for (int i = 0; i < ctf->GetSize(); i++)
       {
         double myVal[6];
         ctf->GetNodeValue(i, myVal);
         auto pointel = new TiXmlElement("point");
         pointel->SetAttribute("x", boost::lexical_cast<std::string>(myVal[0]));
         pointel->SetAttribute("r", boost::lexical_cast<std::string>(myVal[1]));
         pointel->SetAttribute("g", boost::lexical_cast<std::string>(myVal[2]));
         pointel->SetAttribute("b", boost::lexical_cast<std::string>(myVal[3]));
         pointel->SetAttribute("midpoint", boost::lexical_cast<std::string>(myVal[4]));
         pointel->SetAttribute("sharpness", boost::lexical_cast<std::string>(myVal[5]));
         pointlist->LinkEndChild(pointel);
       }
       element->LinkEndChild(pointlist);
       return element;
     }
     else
       return nullptr;
   }
 
   bool mitk::TransferFunctionPropertySerializer::SerializeTransferFunction(const char *filename,
                                                                            TransferFunction::Pointer tf)
   {
     TransferFunctionPropertySerializer::Pointer tfps = TransferFunctionPropertySerializer::New();
     tfps->SetProperty(TransferFunctionProperty::New(tf));
     TiXmlElement *s = tfps->Serialize();
 
     if (!s)
     {
       MITK_ERROR << "cant serialize transfer function";
 
       return false;
     }
 
     TiXmlDocument document;
     auto decl = new TiXmlDeclaration(
       "1.0",
       "UTF-8",
       ""); // TODO what to write here? encoding? standalone would mean that we provide a DTD somewhere...
     document.LinkEndChild(decl);
 
     auto version = new TiXmlElement("Version");
     version->SetAttribute("TransferfunctionVersion", 1);
 
     document.LinkEndChild(version);
     document.LinkEndChild(s);
 
     if (!document.SaveFile(filename))
     {
       MITK_ERROR << "Could not write scene to " << filename << "\nTinyXML reports '" << document.ErrorDesc() << "'";
       return false;
     }
     return true;
   }
 
   BaseProperty::Pointer mitk::TransferFunctionPropertySerializer::Deserialize(TiXmlElement *element)
   {
     if (!element)
       return nullptr;
 
     mitk::LocaleSwitch localeSwitch("C");
 
     TransferFunction::Pointer tf = TransferFunction::New();
 
     // deserialize scalar opacity function
     TiXmlElement *scalarOpacityPointlist = element->FirstChildElement("ScalarOpacity");
     if (scalarOpacityPointlist == nullptr)
     {
       return nullptr;
     }
 
     tf->ClearScalarOpacityPoints();
 
     try
     {
       for (TiXmlElement *pointElement = scalarOpacityPointlist->FirstChildElement("point"); pointElement != nullptr;
            pointElement = pointElement->NextSiblingElement("point"))
       {
         std::string x;
         std::string y;
         if (pointElement->QueryStringAttribute("x", &x) != TIXML_SUCCESS)
           return nullptr;
         if (pointElement->QueryStringAttribute("y", &y) != TIXML_SUCCESS)
           return nullptr;
         tf->AddScalarOpacityPoint(boost::lexical_cast<double>(x), boost::lexical_cast<double>(y));
       }
 
       TiXmlElement *gradientOpacityPointlist = element->FirstChildElement("GradientOpacity");
       if (gradientOpacityPointlist == nullptr)
       {
         return nullptr;
       }
 
       tf->ClearGradientOpacityPoints();
 
       for (TiXmlElement *pointElement = gradientOpacityPointlist->FirstChildElement("point"); pointElement != nullptr;
            pointElement = pointElement->NextSiblingElement("point"))
       {
         std::string x;
         std::string y;
         if (pointElement->QueryStringAttribute("x", &x) != TIXML_SUCCESS)
           return nullptr;
         if (pointElement->QueryStringAttribute("y", &y) != TIXML_SUCCESS)
           return nullptr;
         tf->AddGradientOpacityPoint(boost::lexical_cast<double>(x), boost::lexical_cast<double>(y));
       }
 
       TiXmlElement *rgbPointlist = element->FirstChildElement("Color");
       if (rgbPointlist == nullptr)
       {
         return nullptr;
       }
       vtkColorTransferFunction *ctf = tf->GetColorTransferFunction();
       if (ctf == nullptr)
       {
         return nullptr;
       }
 
       ctf->RemoveAllPoints();
 
       for (TiXmlElement *pointElement = rgbPointlist->FirstChildElement("point"); pointElement != nullptr;
            pointElement = pointElement->NextSiblingElement("point"))
       {
         std::string x;
         std::string r, g, b, midpoint, sharpness;
         if (pointElement->QueryStringAttribute("x", &x) != TIXML_SUCCESS)
           return nullptr;
         if (pointElement->QueryStringAttribute("r", &r) != TIXML_SUCCESS)
           return nullptr;
         if (pointElement->QueryStringAttribute("g", &g) != TIXML_SUCCESS)
           return nullptr;
         if (pointElement->QueryStringAttribute("b", &b) != TIXML_SUCCESS)
           return nullptr;
         if (pointElement->QueryStringAttribute("midpoint", &midpoint) != TIXML_SUCCESS)
           return nullptr;
         if (pointElement->QueryStringAttribute("sharpness", &sharpness) != TIXML_SUCCESS)
           return nullptr;
         ctf->AddRGBPoint(boost::lexical_cast<double>(x),
                          boost::lexical_cast<double>(r),
                          boost::lexical_cast<double>(g),
                          boost::lexical_cast<double>(b),
                          boost::lexical_cast<double>(midpoint),
                          boost::lexical_cast<double>(sharpness));
       }
     }
     catch (boost::bad_lexical_cast &e)
     {
       MITK_ERROR << "Could not parse string as number: " << e.what();
 
       return nullptr;
     }
 
     return TransferFunctionProperty::New(tf).GetPointer();
   }
 
   mitk::TransferFunction::Pointer mitk::TransferFunctionPropertySerializer::DeserializeTransferFunction(
     const char *filePath)
   {
     TiXmlDocument document(filePath);
 
     if (!document.LoadFile())
     {
       MITK_ERROR << "Could not open/read/parse " << filePath << "\nTinyXML reports: " << document.ErrorDesc()
                  << std::endl;
       return nullptr;
     }
 
     // find version node --> note version in some variable
     int fileVersion = 1;
     TiXmlElement *versionObject = document.FirstChildElement("Version");
     if (versionObject)
     {
       if (versionObject->QueryIntAttribute("TransferfunctionVersion", &fileVersion) != TIXML_SUCCESS)
       {
         MITK_WARN << "Transferfunction file " << filePath
                   << " does not contain version information! Trying version 1 format.";
       }
     }
 
     TiXmlElement *input = document.FirstChildElement("TransferFunction");
 
     TransferFunctionPropertySerializer::Pointer tfpd = TransferFunctionPropertySerializer::New();
     BaseProperty::Pointer bp = tfpd->Deserialize(input);
     TransferFunctionProperty::Pointer tfp = dynamic_cast<TransferFunctionProperty *>(bp.GetPointer());
 
     if (tfp.IsNotNull())
     {
       TransferFunction::Pointer tf = tfp->GetValue();
       return tf;
     }
     MITK_WARN << "Can't deserialize transfer function";
     return nullptr;
   }
 
 } // namespace
 
 // important to put this into the GLOBAL namespace (because it starts with 'namespace mitk')
 MITK_REGISTER_SERIALIZER(TransferFunctionPropertySerializer);
diff --git a/Modules/SceneSerializationBase/test/mitkVectorPropertySerializerTest.cpp b/Modules/SceneSerializationBase/test/mitkVectorPropertySerializerTest.cpp
index 957c13cf03..3666847a1a 100644
--- a/Modules/SceneSerializationBase/test/mitkVectorPropertySerializerTest.cpp
+++ b/Modules/SceneSerializationBase/test/mitkVectorPropertySerializerTest.cpp
@@ -1,145 +1,145 @@
 /*===================================================================
 
 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 "mitkTestFixture.h"
 #include "mitkTestingMacros.h"
 
 #include "mitkBasePropertySerializer.h"
 #include "mitkVectorProperty.h"
-#include <boost/lexical_cast.hpp>
+#include <mitkLexicalCast.h>
 
 #include <limits>
 #include <cmath>
 
 #include "mitkEqual.h"
 
 /**
  \brief Test for VectorPropertySerializer.
 
  Creates simple std::vector instances, puts them
  into a VectorProperty of appropriate type, then
  asks a serializer to serialize them into XML.
 
  Test expects that there is a deserializer somewhere
  in the system (i.e. registered with the ITK object
  factory. The test further expects that this
  deserializer is able to create a VectorProperty
  from XML and that this VectorProperty equals the
  input of serialization.
 */
 class mitkVectorPropertySerializerTestSuite : public mitk::TestFixture
 {
   CPPUNIT_TEST_SUITE(mitkVectorPropertySerializerTestSuite);
   MITK_TEST(TestSerialize<int>);
   MITK_TEST(TestSerialize<double>);
   MITK_TEST(TestSerializeIntTypedef);
   MITK_TEST(TestSerializeDoubleTypedef);
   CPPUNIT_TEST_SUITE_END();
 
 public:
   void setUp() override {}
   void tearDown() override {}
   template <typename DATATYPE>
   typename mitk::VectorProperty<DATATYPE>::Pointer MakeExampleProperty()
   {
     typename mitk::VectorProperty<DATATYPE>::Pointer vectorProperty = mitk::VectorProperty<DATATYPE>::New();
     std::vector<DATATYPE> data;
     data.push_back(static_cast<DATATYPE>(-918273674.6172838));
     data.push_back(0);
     data.push_back(static_cast<DATATYPE>(+6172838.918273674));
     data.push_back(sqrt(2));
     if (std::numeric_limits<DATATYPE>::has_infinity)
     {
       data.push_back(std::numeric_limits<DATATYPE>::infinity());
       data.push_back(-std::numeric_limits<DATATYPE>::infinity());
     }
     // do NOT test NaN: cannot be == to itself, so cannot be tested like the others
     // NaN is covered in a different test (FloatToStringTest at the time of writing this)
     // data.push_back( std::numeric_limits<DATATYPE>::quiet_NaN() );
     vectorProperty->SetValue(data);
 
     return vectorProperty;
   }
 
   mitk::BaseProperty::Pointer TestSerialize(mitk::BaseProperty *property)
   {
     std::string serializername = std::string(property->GetNameOfClass()) + "Serializer";
 
     std::list<itk::LightObject::Pointer> allSerializers =
       itk::ObjectFactoryBase::CreateAllInstance(serializername.c_str());
     CPPUNIT_ASSERT_EQUAL(size_t(1), allSerializers.size());
 
     auto *serializer =
       dynamic_cast<mitk::BasePropertySerializer *>(allSerializers.begin()->GetPointer());
     CPPUNIT_ASSERT(serializer != nullptr);
     if (!serializer)
       return nullptr;
 
     serializer->SetProperty(property);
     TiXmlElement *serialization(nullptr);
     try
     {
       serialization = serializer->Serialize();
     }
     catch (...)
     {
     }
     CPPUNIT_ASSERT(serialization != nullptr);
     if (!serialization)
       return nullptr;
 
     mitk::BaseProperty::Pointer restoredProperty = serializer->Deserialize(serialization);
     CPPUNIT_ASSERT(restoredProperty.IsNotNull());
     return restoredProperty;
   }
 
   template <typename DATATYPE>
   void TestSerialize()
   {
     auto property = MakeExampleProperty<DATATYPE>();
     mitk::BaseProperty::Pointer restored_property = TestSerialize(property);
 
     typename mitk::VectorProperty<DATATYPE>::Pointer restored_vector_property =
       dynamic_cast<mitk::VectorProperty<DATATYPE> *>(restored_property.GetPointer());
     CPPUNIT_ASSERT(restored_vector_property.IsNotNull());
 
     auto orig_vector = property->GetValue();
     auto restored_vector = restored_vector_property->GetValue();
 
     CPPUNIT_ASSERT_EQUAL(orig_vector.size(), restored_vector.size());
     for (unsigned int i = 0; i < orig_vector.size(); ++i)
     {
       // compare using Equal, i.e. with tolerance of mitk::eps
       CPPUNIT_ASSERT_MESSAGE(std::string("Verifying element ") + boost::lexical_cast<std::string>(i),
                              mitk::Equal(orig_vector[i], restored_vector[i]));
     }
   }
 
   void TestSerializeIntTypedef()
   {
     mitk::IntVectorProperty::Pointer intVectorProperty = MakeExampleProperty<int>().GetPointer();
     TestSerialize(intVectorProperty.GetPointer());
   }
 
   void TestSerializeDoubleTypedef()
   {
     mitk::DoubleVectorProperty::Pointer doubleVectorProperty = MakeExampleProperty<double>().GetPointer();
     TestSerialize(doubleVectorProperty.GetPointer());
   }
 
 }; // class
 
 MITK_TEST_SUITE_REGISTRATION(mitkVectorPropertySerializer)
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberprocessing/src/internal/QmitkFiberQuantificationView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging.fiberprocessing/src/internal/QmitkFiberQuantificationView.cpp
index cd1848de92..aca647f8fe 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberprocessing/src/internal/QmitkFiberQuantificationView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging.fiberprocessing/src/internal/QmitkFiberQuantificationView.cpp
@@ -1,441 +1,441 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkFiberQuantificationView.h"
 
 // Qt
 #include <QMessageBox>
 
 // MITK
 #include <mitkNodePredicateDataType.h>
 #include <mitkNodePredicateDimension.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkImageCast.h>
 #include <mitkPeakImage.h>
 #include <mitkLabelSetImage.h>
 #include <mitkDICOMSegmentationConstants.h>
 #include <mitkDICOMSegmentationPropertyHelper.cpp>
 
 // ITK
 #include <itkTractDensityImageFilter.h>
 #include <itkTractsToRgbaImageFilter.h>
 #include <itkTractsToVectorImageFilter.h>
 #include <itkTractsToFiberEndingsImageFilter.h>
 
-#include <boost/lexical_cast.hpp>
+#include <mitkLexicalCast.h>
 
 const std::string QmitkFiberQuantificationView::VIEW_ID = "org.mitk.views.fiberquantification";
 using namespace mitk;
 
 QmitkFiberQuantificationView::QmitkFiberQuantificationView()
   : QmitkAbstractView()
   , m_Controls( 0 )
   , m_UpsamplingFactor(5)
   , m_Visible(false)
 {
 
 }
 
 // Destructor
 QmitkFiberQuantificationView::~QmitkFiberQuantificationView()
 {
 
 }
 
 void QmitkFiberQuantificationView::CreateQtPartControl( QWidget *parent )
 {
   // build up qt view, unless already done
   if ( !m_Controls )
   {
     // create GUI widgets from the Qt Designer's .ui file
     m_Controls = new Ui::QmitkFiberQuantificationViewControls;
     m_Controls->setupUi( parent );
 
     connect( m_Controls->m_ProcessFiberBundleButton, SIGNAL(clicked()), this, SLOT(ProcessSelectedBundles()) );
     connect( m_Controls->m_ExtractFiberPeaks, SIGNAL(clicked()), this, SLOT(CalculateFiberDirections()) );
 
     m_Controls->m_TractBox->SetDataStorage(this->GetDataStorage());
     mitk::TNodePredicateDataType<mitk::FiberBundle>::Pointer isFib = mitk::TNodePredicateDataType<mitk::FiberBundle>::New();
     m_Controls->m_TractBox->SetPredicate( isFib );
 
     m_Controls->m_ImageBox->SetDataStorage(this->GetDataStorage());
     m_Controls->m_ImageBox->SetZeroEntryText("--");
     mitk::TNodePredicateDataType<mitk::Image>::Pointer isImagePredicate = mitk::TNodePredicateDataType<mitk::Image>::New();
     mitk::NodePredicateDimension::Pointer is3D = mitk::NodePredicateDimension::New(3);
     m_Controls->m_ImageBox->SetPredicate( mitk::NodePredicateAnd::New(isImagePredicate, is3D) );
 
     connect( (QObject*)(m_Controls->m_TractBox), SIGNAL(currentIndexChanged(int)), this, SLOT(UpdateGui()));
     connect( (QObject*)(m_Controls->m_ImageBox), SIGNAL(currentIndexChanged(int)), this, SLOT(UpdateGui()));
   }
 }
 
 void QmitkFiberQuantificationView::Activated()
 {
 
 }
 
 void QmitkFiberQuantificationView::Deactivated()
 {
 
 }
 
 void QmitkFiberQuantificationView::Visible()
 {
   m_Visible = true;
 }
 
 void QmitkFiberQuantificationView::Hidden()
 {
   m_Visible = false;
 }
 
 void QmitkFiberQuantificationView::SetFocus()
 {
   m_Controls->m_ProcessFiberBundleButton->setFocus();
 }
 
 void QmitkFiberQuantificationView::CalculateFiberDirections()
 {
   typedef itk::Image<unsigned char, 3>                                            ItkUcharImgType;
 
   // load fiber bundle
   mitk::FiberBundle::Pointer inputTractogram = dynamic_cast<mitk::FiberBundle*>(m_SelectedFB.back()->GetData());
 
   itk::TractsToVectorImageFilter<float>::Pointer fOdfFilter = itk::TractsToVectorImageFilter<float>::New();
   if (m_SelectedImage.IsNotNull())
   {
     ItkUcharImgType::Pointer itkMaskImage = ItkUcharImgType::New();
     mitk::CastToItkImage<ItkUcharImgType>(m_SelectedImage, itkMaskImage);
     fOdfFilter->SetMaskImage(itkMaskImage);
   }
 
   // extract directions from fiber bundle
   fOdfFilter->SetFiberBundle(inputTractogram);
   fOdfFilter->SetAngularThreshold(cos(m_Controls->m_AngularThreshold->value()*itk::Math::pi/180));
   switch (m_Controls->m_FiberDirNormBox->currentIndex())
   {
   case 0:
     fOdfFilter->SetNormalizationMethod(itk::TractsToVectorImageFilter<float>::NormalizationMethods::GLOBAL_MAX);
     break;
   case 1:
     fOdfFilter->SetNormalizationMethod(itk::TractsToVectorImageFilter<float>::NormalizationMethods::SINGLE_VEC_NORM);
     break;
   case 2:
     fOdfFilter->SetNormalizationMethod(itk::TractsToVectorImageFilter<float>::NormalizationMethods::MAX_VEC_NORM);
     break;
   }
   fOdfFilter->SetUseWorkingCopy(true);
   fOdfFilter->SetSizeThreshold(m_Controls->m_PeakThreshold->value());
   fOdfFilter->SetMaxNumDirections(m_Controls->m_MaxNumDirections->value());
   fOdfFilter->Update();
 
   QString name = m_SelectedFB.back()->GetName().c_str();
 
   if (m_Controls->m_NumDirectionsBox->isChecked())
   {
     mitk::Image::Pointer mitkImage = mitk::Image::New();
     mitkImage->InitializeByItk( fOdfFilter->GetNumDirectionsImage().GetPointer() );
     mitkImage->SetVolume( fOdfFilter->GetNumDirectionsImage()->GetBufferPointer() );
 
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     node->SetData(mitkImage);
     node->SetName((name+"_NUM_DIRECTIONS").toStdString().c_str());
     GetDataStorage()->Add(node, m_SelectedFB.back());
   }
 
   Image::Pointer mitkImage = dynamic_cast<Image*>(PeakImage::New().GetPointer());
   mitk::CastToMitkImage(fOdfFilter->GetDirectionImage(), mitkImage);
   mitkImage->SetVolume(fOdfFilter->GetDirectionImage()->GetBufferPointer());
 
   mitk::DataNode::Pointer node = mitk::DataNode::New();
   node->SetData(mitkImage);
   node->SetName( (name+"_DIRECTIONS").toStdString().c_str());
   GetDataStorage()->Add(node, m_SelectedFB.back());
 }
 
 void QmitkFiberQuantificationView::UpdateGui()
 {
   m_SelectedFB.clear();
   if (m_Controls->m_TractBox->GetSelectedNode().IsNotNull())
     m_SelectedFB.push_back(m_Controls->m_TractBox->GetSelectedNode());
 
   m_SelectedImage = nullptr;
   if (m_Controls->m_ImageBox->GetSelectedNode().IsNotNull())
     m_SelectedImage = dynamic_cast<mitk::Image*>(m_Controls->m_ImageBox->GetSelectedNode()->GetData());
 
   m_Controls->m_ProcessFiberBundleButton->setEnabled(!m_SelectedFB.empty());
   m_Controls->m_ExtractFiberPeaks->setEnabled(!m_SelectedFB.empty());
 }
 
 void QmitkFiberQuantificationView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/, const QList<mitk::DataNode::Pointer>& )
 {
   UpdateGui();
 }
 
 void QmitkFiberQuantificationView::ProcessSelectedBundles()
 {
   if ( m_SelectedFB.empty() ){
     QMessageBox::information( nullptr, "Warning", "No fibe bundle selected!");
     MITK_WARN("QmitkFiberQuantificationView") << "no fibe bundle selected";
     return;
   }
 
   int generationMethod = m_Controls->m_GenerationBox->currentIndex();
 
   for( unsigned int i=0; i<m_SelectedFB.size(); i++ )
   {
     mitk::DataNode::Pointer node = m_SelectedFB[i];
     if (node.IsNotNull() && dynamic_cast<mitk::FiberBundle*>(node->GetData()))
     {
       mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(node->GetData());
       QString name(node->GetName().c_str());
       DataNode::Pointer newNode = nullptr;
       switch(generationMethod){
       case 0:
         newNode = GenerateTractDensityImage(fib, false, true);
         name += "_TDI";
         break;
       case 1:
         newNode = GenerateTractDensityImage(fib, false, false);
         name += "_TDI";
         break;
       case 2:
         newNode = GenerateTractDensityImage(fib, true, false);
         name += "_envelope";
         break;
       case 3:
         newNode = GenerateColorHeatmap(fib);
         break;
       case 4:
         newNode = GenerateFiberEndingsImage(fib);
         name += "_fiber_endings";
         break;
       case 5:
         newNode = GenerateFiberEndingsPointSet(fib);
         name += "_fiber_endings";
         break;
       }
       if (newNode.IsNotNull())
       {
         newNode->SetName(name.toStdString());
         GetDataStorage()->Add(newNode);
       }
     }
   }
 }
 
 // generate pointset displaying the fiber endings
 mitk::DataNode::Pointer QmitkFiberQuantificationView::GenerateFiberEndingsPointSet(mitk::FiberBundle::Pointer fib)
 {
   mitk::PointSet::Pointer pointSet = mitk::PointSet::New();
   vtkSmartPointer<vtkPolyData> fiberPolyData = fib->GetFiberPolyData();
 
   int count = 0;
   int numFibers = fib->GetNumFibers();
   for( int i=0; i<numFibers; i++ )
   {
     vtkCell* cell = fiberPolyData->GetCell(i);
     int numPoints = cell->GetNumberOfPoints();
     vtkPoints* points = cell->GetPoints();
 
     if (numPoints>0)
     {
       double* point = points->GetPoint(0);
       itk::Point<float,3> itkPoint;
       itkPoint[0] = point[0];
       itkPoint[1] = point[1];
       itkPoint[2] = point[2];
       pointSet->InsertPoint(count, itkPoint);
       count++;
     }
     if (numPoints>2)
     {
       double* point = points->GetPoint(numPoints-1);
       itk::Point<float,3> itkPoint;
       itkPoint[0] = point[0];
       itkPoint[1] = point[1];
       itkPoint[2] = point[2];
       pointSet->InsertPoint(count, itkPoint);
       count++;
     }
   }
 
   mitk::DataNode::Pointer node = mitk::DataNode::New();
   node->SetData( pointSet );
   return node;
 }
 
 // generate image displaying the fiber endings
 mitk::DataNode::Pointer QmitkFiberQuantificationView::GenerateFiberEndingsImage(mitk::FiberBundle::Pointer fib)
 {
   typedef unsigned int OutPixType;
   typedef itk::Image<OutPixType,3> OutImageType;
 
   typedef itk::TractsToFiberEndingsImageFilter< OutImageType > ImageGeneratorType;
   ImageGeneratorType::Pointer generator = ImageGeneratorType::New();
   generator->SetFiberBundle(fib);
   generator->SetUpsamplingFactor(m_Controls->m_UpsamplingSpinBox->value());
   if (m_SelectedImage.IsNotNull())
   {
     OutImageType::Pointer itkImage = OutImageType::New();
     CastToItkImage(m_SelectedImage, itkImage);
     generator->SetInputImage(itkImage);
     generator->SetUseImageGeometry(true);
   }
   generator->Update();
 
   // get output image
   OutImageType::Pointer outImg = generator->GetOutput();
   mitk::Image::Pointer img = mitk::Image::New();
   img->InitializeByItk(outImg.GetPointer());
   img->SetVolume(outImg->GetBufferPointer());
 
   // init data node
   mitk::DataNode::Pointer node = mitk::DataNode::New();
   node->SetData(img);
   return node;
 }
 
 // generate rgba heatmap from fiber bundle
 mitk::DataNode::Pointer QmitkFiberQuantificationView::GenerateColorHeatmap(mitk::FiberBundle::Pointer fib)
 {
   typedef itk::RGBAPixel<unsigned char> OutPixType;
   typedef itk::Image<OutPixType, 3> OutImageType;
   typedef itk::TractsToRgbaImageFilter< OutImageType > ImageGeneratorType;
   ImageGeneratorType::Pointer generator = ImageGeneratorType::New();
   generator->SetFiberBundle(fib);
   generator->SetUpsamplingFactor(m_Controls->m_UpsamplingSpinBox->value());
   if (m_SelectedImage.IsNotNull())
   {
     itk::Image<unsigned char, 3>::Pointer itkImage = itk::Image<unsigned char, 3>::New();
     CastToItkImage(m_SelectedImage, itkImage);
     generator->SetInputImage(itkImage);
     generator->SetUseImageGeometry(true);
   }
   generator->Update();
 
   // get output image
   typedef itk::Image<OutPixType,3> OutType;
   OutType::Pointer outImg = generator->GetOutput();
   mitk::Image::Pointer img = mitk::Image::New();
   img->InitializeByItk(outImg.GetPointer());
   img->SetVolume(outImg->GetBufferPointer());
 
   // init data node
   mitk::DataNode::Pointer node = mitk::DataNode::New();
   node->SetData(img);
   return node;
 }
 
 // generate tract density image from fiber bundle
 mitk::DataNode::Pointer QmitkFiberQuantificationView::GenerateTractDensityImage(mitk::FiberBundle::Pointer fib, bool binary, bool absolute)
 {
   mitk::DataNode::Pointer node = mitk::DataNode::New();
   if (binary)
   {
     typedef unsigned char OutPixType;
     typedef itk::Image<OutPixType, 3> OutImageType;
 
     itk::TractDensityImageFilter< OutImageType >::Pointer generator = itk::TractDensityImageFilter< OutImageType >::New();
     generator->SetFiberBundle(fib);
     generator->SetBinaryOutput(binary);
     generator->SetOutputAbsoluteValues(absolute);
     generator->SetUpsamplingFactor(m_Controls->m_UpsamplingSpinBox->value());
     if (m_SelectedImage.IsNotNull())
     {
       OutImageType::Pointer itkImage = OutImageType::New();
       CastToItkImage(m_SelectedImage, itkImage);
       generator->SetInputImage(itkImage);
       generator->SetUseImageGeometry(true);
 
     }
     generator->Update();
 
     // get output image
     typedef itk::Image<OutPixType,3> OutType;
     OutType::Pointer outImg = generator->GetOutput();
     mitk::Image::Pointer img = mitk::Image::New();
     img->InitializeByItk(outImg.GetPointer());
     img->SetVolume(outImg->GetBufferPointer());
 
 
     if (m_SelectedImage.IsNotNull())
     {
       mitk::LabelSetImage::Pointer multilabelImage = mitk::LabelSetImage::New();
       multilabelImage->InitializeByLabeledImage(img);
 
 
 
       mitk::Label::Pointer label = multilabelImage->GetActiveLabel();
       label->SetName("Tractogram");
 //      label->SetColor(color);
       label->SetValue(1);
 //      multilabelImage->GetActiveLabelSet()->AddLabel(label);
       multilabelImage->GetActiveLabelSet()->SetActiveLabel(1);
 
       PropertyList::Pointer dicomSegPropertyList = mitk::DICOMSegmentationPropertyHandler::GetDICOMSegmentationProperties(m_SelectedImage->GetPropertyList());
 
       multilabelImage->GetPropertyList()->ConcatenatePropertyList(dicomSegPropertyList);
       mitk::DICOMSegmentationPropertyHandler::GetDICOMSegmentProperties(multilabelImage->GetActiveLabel(multilabelImage->GetActiveLayer()));
       // init data node
       node->SetData(multilabelImage);
     }
     else
     {
       // init data node
       node->SetData(img);
     }
 
   }
   else
   {
     typedef float OutPixType;
     typedef itk::Image<OutPixType, 3> OutImageType;
 
     itk::TractDensityImageFilter< OutImageType >::Pointer generator = itk::TractDensityImageFilter< OutImageType >::New();
     generator->SetFiberBundle(fib);
     generator->SetBinaryOutput(binary);
     generator->SetOutputAbsoluteValues(absolute);
     generator->SetUpsamplingFactor(m_Controls->m_UpsamplingSpinBox->value());
     if (m_SelectedImage.IsNotNull())
     {
       OutImageType::Pointer itkImage = OutImageType::New();
       CastToItkImage(m_SelectedImage, itkImage);
       generator->SetInputImage(itkImage);
       generator->SetUseImageGeometry(true);
 
     }
     //generator->SetDoFiberResampling(false);
     generator->Update();
 
     // get output image
     typedef itk::Image<OutPixType,3> OutType;
     OutType::Pointer outImg = generator->GetOutput();
     mitk::Image::Pointer img = mitk::Image::New();
     img->InitializeByItk(outImg.GetPointer());
     img->SetVolume(outImg->GetBufferPointer());
 
     // init data node
     node->SetData(img);
   }
   return node;
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberprocessing/src/internal/QmitkTractometryView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging.fiberprocessing/src/internal/QmitkTractometryView.cpp
index 50d11a0469..99c8aa88eb 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberprocessing/src/internal/QmitkTractometryView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging.fiberprocessing/src/internal/QmitkTractometryView.cpp
@@ -1,339 +1,339 @@
 /*===================================================================
 
 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 <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 #include "QmitkTractometryView.h"
 
 #include <mitkNodePredicateDataType.h>
 #include <mitkNodePredicateDimension.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkImageCast.h>
 #include <mitkImageAccessByItk.h>
 #include <mitkImage.h>
 #include <mitkFiberBundle.h>
 #include <mitkDiffusionPropertyHelper.h>
 #include <mitkITKImageImport.h>
 #include <QmitkChartWidget.h>
 #include <mitkPixelTypeMultiplex.h>
 #include <mitkImagePixelReadAccessor.h>
 #include <berryIPreferences.h>
 #include <berryWorkbenchPlugin.h>
 #include <berryQtPreferences.h>
 #include <vtkLookupTable.h>
 #include <QClipboard>
-#include <boost/lexical_cast.hpp>
+#include <mitkLexicalCast.h>
 #include <QmitkChartWidget.h>
 
 const std::string QmitkTractometryView::VIEW_ID = "org.mitk.views.tractometry";
 using namespace mitk;
 
 QmitkTractometryView::QmitkTractometryView()
   : QmitkAbstractView()
   , m_Controls( nullptr )
   , m_Visible(false)
 {
 
 }
 
 // Destructor
 QmitkTractometryView::~QmitkTractometryView()
 {
 
 }
 
 void QmitkTractometryView::CreateQtPartControl( QWidget *parent )
 {
   // build up qt view, unless already done
   if ( !m_Controls )
   {
     // create GUI widgets from the Qt Designer's .ui file
     m_Controls = new Ui::QmitkTractometryViewControls;
     m_Controls->setupUi( parent );
 
     connect( m_Controls->m_SamplingPointsBox, SIGNAL(valueChanged(int)), this, SLOT(UpdateGui()) );
     connect( m_Controls->m_StDevBox, SIGNAL(stateChanged(int)), this, SLOT(UpdateGui()) );
 
     mitk::TNodePredicateDataType<mitk::Image>::Pointer imageP = mitk::TNodePredicateDataType<mitk::Image>::New();
     mitk::NodePredicateDimension::Pointer dimP = mitk::NodePredicateDimension::New(3);
 
     m_Controls->m_ImageBox->SetDataStorage(this->GetDataStorage());
     m_Controls->m_ImageBox->SetPredicate(mitk::NodePredicateAnd::New(imageP, dimP));
 
     m_Controls->m_ChartWidget->SetXAxisLabel("Tract position");
     m_Controls->m_ChartWidget->SetYAxisLabel("Image Value");
 
   }
 }
 
 void QmitkTractometryView::OnPageSuccessfullyLoaded()
 {
   berry::IPreferencesService* prefService = berry::WorkbenchPlugin::GetDefault()->GetPreferencesService();
   berry::IPreferences::Pointer m_StylePref = prefService->GetSystemPreferences()->Node(berry::QtPreferences::QT_STYLES_NODE);
 
   QString styleName = m_StylePref->Get(berry::QtPreferences::QT_STYLE_NAME, "");
 
   if (styleName == ":/org.blueberry.ui.qt/darkstyle.qss")
   {
     this->m_Controls->m_ChartWidget->SetTheme(QmitkChartWidget::ChartStyle::darkstyle);
   }
   else
   {
     this->m_Controls->m_ChartWidget->SetTheme(QmitkChartWidget::ChartStyle::lightstyle);
   }
 }
 
 void QmitkTractometryView::SetFocus()
 {
 }
 
 void QmitkTractometryView::UpdateGui()
 {
   berry::IWorkbenchPart::Pointer nullPart;
   OnSelectionChanged(nullPart, QList<mitk::DataNode::Pointer>(m_CurrentSelection));
 }
 
 bool QmitkTractometryView::Flip(vtkSmartPointer< vtkPolyData > polydata1, int i, vtkSmartPointer< vtkPolyData > ref_poly)
 {
   float d_direct = 0;
   float d_flipped = 0;
 
   vtkCell* cell1 = polydata1->GetCell(0);
   if (ref_poly!=nullptr)
     cell1 = ref_poly->GetCell(0);
   int numPoints1 = cell1->GetNumberOfPoints();
   vtkPoints* points1 = cell1->GetPoints();
 
   vtkCell* cell2 = polydata1->GetCell(i);
   vtkPoints* points2 = cell2->GetPoints();
 
   for (int j=0; j<numPoints1; ++j)
   {
     double* p1 = points1->GetPoint(j);
     double* p2 = points2->GetPoint(j);
     d_direct = (p1[0]-p2[0])*(p1[0]-p2[0]) + (p1[1]-p2[1])*(p1[1]-p2[1]) + (p1[2]-p2[2])*(p1[2]-p2[2]);
 
     double* p3 = points2->GetPoint(numPoints1-j-1);
     d_flipped = (p1[0]-p3[0])*(p1[0]-p3[0]) + (p1[1]-p3[1])*(p1[1]-p3[1]) + (p1[2]-p3[2])*(p1[2]-p3[2]);
   }
 
   if (d_direct>d_flipped)
     return true;
   return false;
 }
 
 template <typename TPixel>
 void QmitkTractometryView::ImageValuesAlongTract(const mitk::PixelType, mitk::Image::Pointer image, mitk::FiberBundle::Pointer fib, std::vector<std::vector<double> > &data, std::string& clipboard_string)
 {
   int num_points = m_Controls->m_SamplingPointsBox->value();
   mitk::ImagePixelReadAccessor<TPixel,3> readimage(image, image->GetVolumeData(0));
   mitk::FiberBundle::Pointer working_fib = fib->GetDeepCopy();
   working_fib->ResampleToNumPoints(num_points);
   vtkSmartPointer< vtkPolyData > polydata = working_fib->GetFiberPolyData();
 
   std::vector<std::vector<double> > all_values;
   std::vector< double > mean_values;
   for (int i=0; i<num_points; ++i)
     mean_values.push_back(0);
 
   double min = 100000;
   double max = 0;
   double mean = 0;
   for (int i=0; i<working_fib->GetNumFibers(); ++i)
   {
     vtkCell* cell = polydata->GetCell(i);
     int numPoints = cell->GetNumberOfPoints();
     vtkPoints* points = cell->GetPoints();
 
     std::vector< double > fib_vals;
 
     bool flip = false;
     if (i>0)
       flip = Flip(polydata, i);
     else if (m_ReferencePolyData!=nullptr)
       flip = Flip(polydata, 0, m_ReferencePolyData);
 
     for (int j=0; j<numPoints; j++)
     {
       double* p;
       if (flip)
         p = points->GetPoint(numPoints - j - 1);
       else
         p = points->GetPoint(j);
 
       Point3D px;
       px[0] = p[0];
       px[1] = p[1];
       px[2] = p[2];
       double pixelValue = readimage.GetPixelByWorldCoordinates(px);
       fib_vals.push_back(pixelValue);
       mean += pixelValue;
       if (pixelValue<min)
         min = pixelValue;
       else if (pixelValue>max)
         max = pixelValue;
 
       mean_values.at(j) += pixelValue;
     }
 
     all_values.push_back(fib_vals);
   }
 
   if (m_ReferencePolyData==nullptr)
     m_ReferencePolyData = polydata;
 
   std::vector< double > std_values1;
   std::vector< double > std_values2;
   for (int i=0; i<num_points; ++i)
   {
     mean_values.at(i) /= working_fib->GetNumFibers();
     double stdev = 0;
 
     for (unsigned int j=0; j<all_values.size(); ++j)
     {
       double diff = mean_values.at(i) - all_values.at(j).at(i);
       diff *= diff;
       stdev += diff;
     }
     stdev /= all_values.size();
     stdev = std::sqrt(stdev);
     std_values1.push_back(mean_values.at(i) + stdev);
     std_values2.push_back(mean_values.at(i) - stdev);
 
     clipboard_string += boost::lexical_cast<std::string>(mean_values.at(i));
     clipboard_string += " ";
     clipboard_string += boost::lexical_cast<std::string>(stdev);
     clipboard_string += "\n";
   }
   clipboard_string += "\n";
 
   data.push_back(mean_values);
   data.push_back(std_values1);
   data.push_back(std_values2);
 
   MITK_INFO << "Min: " << min;
   MITK_INFO << "Max: " << max;
   MITK_INFO << "Mean: " << mean/working_fib->GetNumberOfPoints();
 }
 
 void QmitkTractometryView::Activated()
 {
 
 }
 
 void QmitkTractometryView::Deactivated()
 {
 
 }
 
 void QmitkTractometryView::Visible()
 {
   m_Visible = true;
   QList<mitk::DataNode::Pointer> selection = GetDataManagerSelection();
   berry::IWorkbenchPart::Pointer nullPart;
   OnSelectionChanged(nullPart, selection);
 }
 
 void QmitkTractometryView::Hidden()
 {
   m_Visible = false;
 }
 
 std::string QmitkTractometryView::RGBToHexString(double *rgb)
 {
   std::ostringstream os;
   for (int i = 0; i < 3; ++i)
     {
     os << std::setw(2) << std::setfill('0') << std::hex
        << static_cast<int>(rgb[i] * 255);
     }
   return os.str();
 }
 
 void QmitkTractometryView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/, const QList<mitk::DataNode::Pointer>& nodes)
 {
   if (!m_Visible)
     return;
 
   m_CurrentSelection.clear();
   if(m_Controls->m_ImageBox->GetSelectedNode().IsNull())
     return;
 
   std::string clipboardString = "";
   m_ReferencePolyData = nullptr;
   mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(m_Controls->m_ImageBox->GetSelectedNode()->GetData());
 
   vtkSmartPointer<vtkLookupTable> lookupTable = vtkSmartPointer<vtkLookupTable>::New();
   lookupTable->SetTableRange(0.0, 1.0);
   lookupTable->Build();
 
   int num_tracts = 0;
   for (auto node: nodes)
     if ( dynamic_cast<mitk::FiberBundle*>(node->GetData()) )
       num_tracts++;
 
   int c = 1;
   this->m_Controls->m_ChartWidget->Clear();
   for (auto node: nodes)
   {
     if ( dynamic_cast<mitk::FiberBundle*>(node->GetData()) )
     {
       clipboardString += node->GetName() + "\n";
       clipboardString += "mean stdev\n";
       mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(node->GetData());
       m_CurrentSelection.push_back(node);
 
       std::vector< std::vector< double > > data;
       mitkPixelTypeMultiplex4( ImageValuesAlongTract, image->GetPixelType(), image, fib, data, clipboardString );
 
       m_Controls->m_ChartWidget->AddData1D(data.at(0), node->GetName() + " Mean", QmitkChartWidget::ChartType::line);
       if (m_Controls->m_StDevBox->isChecked())
       {
         this->m_Controls->m_ChartWidget->AddData1D(data.at(1), node->GetName() + " +STDEV", QmitkChartWidget::ChartType::line);
         this->m_Controls->m_ChartWidget->AddData1D(data.at(2), node->GetName() + " -STDEV", QmitkChartWidget::ChartType::line);
       }
 
       double color[3];
       if (num_tracts>1)
       {
         float scalar_color = ( (float)c/num_tracts - 1.0/num_tracts )/(1.0-1.0/num_tracts);
         lookupTable->GetColor(1.0 - scalar_color, color);
       }
       else
         lookupTable->GetColor(0, color);
 
       this->m_Controls->m_ChartWidget->SetColor(node->GetName() + " Mean", RGBToHexString(color));
 
       if (m_Controls->m_StDevBox->isChecked())
       {
         color[0] *= 0.5;
         color[1] *= 0.5;
         color[2] *= 0.5;
         this->m_Controls->m_ChartWidget->SetColor(node->GetName() + " +STDEV", RGBToHexString(color));
         this->m_Controls->m_ChartWidget->SetColor(node->GetName() + " -STDEV", RGBToHexString(color));
       }
 
       this->m_Controls->m_ChartWidget->Show(true);
       this->m_Controls->m_ChartWidget->SetShowDataPoints(false);
       ++c;
     }
   }
 
   QApplication::clipboard()->setText(clipboardString.c_str(), QClipboard::Clipboard);
 
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.reconstruction/src/internal/QmitkDiffusionQuantificationView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging.reconstruction/src/internal/QmitkDiffusionQuantificationView.cpp
index 944e77f2d4..532072513f 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging.reconstruction/src/internal/QmitkDiffusionQuantificationView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging.reconstruction/src/internal/QmitkDiffusionQuantificationView.cpp
@@ -1,668 +1,668 @@
 /*===================================================================
 
 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 "QmitkDiffusionQuantificationView.h"
 #include "mitkDiffusionImagingConfigure.h"
 
 #include "itkTimeProbe.h"
 #include "itkImage.h"
 
 #include "mitkNodePredicateDataType.h"
 #include "mitkDataNodeObject.h"
 #include "mitkOdfImage.h"
 #include <mitkTensorImage.h>
 #include "mitkImageCast.h"
 #include "mitkStatusBar.h"
 #include "itkDiffusionOdfGeneralizedFaImageFilter.h"
 #include "itkShiftScaleImageFilter.h"
 #include "itkTensorFractionalAnisotropyImageFilter.h"
 #include "itkTensorRelativeAnisotropyImageFilter.h"
 #include "itkTensorDerivedMeasurementsFilter.h"
 
 #include "QmitkDataStorageComboBox.h"
 #include <QMessageBox>
 #include "berryIWorkbenchWindow.h"
 #include "berryISelectionService.h"
 
 #include <mitkDiffusionPropertyHelper.h>
 #include <itkAdcImageFilter.h>
 #include <itkBallAndSticksImageFilter.h>
 #include <itkMultiTensorImageFilter.h>
 #include <mitkLookupTable.h>
 #include <mitkLookupTableProperty.h>
 #include <mitkITKImageImport.h>
-#include <boost/lexical_cast.hpp>
+#include <mitkLexicalCast.h>
 
 #include <mitkNodePredicateIsDWI.h>
 #include <mitkNodePredicateDataType.h>
 #include <mitkNodePredicateOr.h>
 #include <QmitkStyleManager.h>
 
 const std::string QmitkDiffusionQuantificationView::VIEW_ID = "org.mitk.views.diffusionquantification";
 
 
 QmitkDiffusionQuantificationView::QmitkDiffusionQuantificationView()
   : QmitkAbstractView(),
     m_Controls(nullptr)
 {
 
 }
 
 QmitkDiffusionQuantificationView::~QmitkDiffusionQuantificationView()
 {
 
 }
 
 void QmitkDiffusionQuantificationView::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkDiffusionQuantificationViewControls;
     m_Controls->setupUi(parent);
     this->CreateConnections();
     GFACheckboxClicked();
 
 #ifndef DIFFUSION_IMAGING_EXTENDED
     m_Controls->m_StandardGFACheckbox->setVisible(false);
     m_Controls->frame_3->setVisible(false);
     m_Controls->m_CurvatureButton->setVisible(false);
 #endif
 
     m_Controls->m_BallStickButton->setVisible(false);
     m_Controls->m_MultiTensorButton->setVisible(false);
   }
 }
 
 void QmitkDiffusionQuantificationView::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( (QObject*)(m_Controls->m_StandardGFACheckbox), SIGNAL(clicked()), this, SLOT(GFACheckboxClicked()) );
     connect( (QObject*)(m_Controls->m_GFAButton), SIGNAL(clicked()), this, SLOT(GFA()) );
     connect( (QObject*)(m_Controls->m_CurvatureButton), SIGNAL(clicked()), this, SLOT(Curvature()) );
     connect( (QObject*)(m_Controls->m_FAButton), SIGNAL(clicked()), this, SLOT(FA()) );
     connect( (QObject*)(m_Controls->m_RAButton), SIGNAL(clicked()), this, SLOT(RA()) );
     connect( (QObject*)(m_Controls->m_ADButton), SIGNAL(clicked()), this, SLOT(AD()) );
     connect( (QObject*)(m_Controls->m_RDButton), SIGNAL(clicked()), this, SLOT(RD()) );
     connect( (QObject*)(m_Controls->m_MDButton), SIGNAL(clicked()), this, SLOT(MD()) );
     connect( (QObject*)(m_Controls->m_MdDwiButton), SIGNAL(clicked()), this, SLOT(MD_DWI()) );
     connect( (QObject*)(m_Controls->m_AdcDwiButton), SIGNAL(clicked()), this, SLOT(ADC_DWI()) );
     connect( (QObject*)(m_Controls->m_ClusteringAnisotropy), SIGNAL(clicked()), this, SLOT(ClusterAnisotropy()) );
     connect( (QObject*)(m_Controls->m_BallStickButton), SIGNAL(clicked()), this, SLOT(DoBallStickCalculation()) );
     connect( (QObject*)(m_Controls->m_MultiTensorButton), SIGNAL(clicked()), this, SLOT(DoMultiTensorCalculation()) );
 
 //    m_Controls->m_FAButton->setIcon(QmitkStyleManager::ThemeIcon(QStringLiteral(":/org_mitk_icons/icons/awesome/scalable/actions/go-next.svg")));
 
     m_Controls->m_ImageBox->SetDataStorage(this->GetDataStorage());
     mitk::TNodePredicateDataType<mitk::TensorImage>::Pointer isDti = mitk::TNodePredicateDataType<mitk::TensorImage>::New();
     mitk::TNodePredicateDataType<mitk::OdfImage>::Pointer isOdf = mitk::TNodePredicateDataType<mitk::OdfImage>::New();
     mitk::NodePredicateIsDWI::Pointer isDwi = mitk::NodePredicateIsDWI::New();
     m_Controls->m_ImageBox->SetPredicate( mitk::NodePredicateOr::New(isDti, mitk::NodePredicateOr::New(isOdf, isDwi)) );
 
     connect( (QObject*)(m_Controls->m_ImageBox), SIGNAL(currentIndexChanged(int)), this, SLOT(UpdateGui()));
   }
 }
 
 void QmitkDiffusionQuantificationView::SetFocus()
 {
   m_Controls->m_ScaleImageValuesBox->setFocus();
 }
 
 void QmitkDiffusionQuantificationView::UpdateGui()
 {
   bool foundOdfVolume = false;
   bool foundTensorVolume = false;
   bool foundDwVolume = false;
   mitk::DataNode::Pointer  selNode = m_Controls->m_ImageBox->GetSelectedNode();
 
   if( selNode.IsNotNull() && dynamic_cast<mitk::OdfImage*>(selNode->GetData()) )
     foundOdfVolume = true;
   else if( selNode.IsNotNull() && dynamic_cast<mitk::TensorImage*>(selNode->GetData()) )
     foundTensorVolume = true;
   else if( selNode.IsNotNull())
     foundDwVolume = true;
 
   m_Controls->m_GFAButton->setEnabled(foundOdfVolume);
   m_Controls->m_CurvatureButton->setEnabled(foundOdfVolume);
 
   m_Controls->m_FAButton->setEnabled(foundTensorVolume);
   m_Controls->m_RAButton->setEnabled(foundTensorVolume);
   m_Controls->m_ADButton->setEnabled(foundTensorVolume);
   m_Controls->m_RDButton->setEnabled(foundTensorVolume);
   m_Controls->m_MDButton->setEnabled(foundTensorVolume);
   m_Controls->m_ClusteringAnisotropy->setEnabled(foundTensorVolume);
   m_Controls->m_AdcDwiButton->setEnabled(foundDwVolume);
   m_Controls->m_MdDwiButton->setEnabled(foundDwVolume);
   m_Controls->m_BallStickButton->setEnabled(foundDwVolume);
   m_Controls->m_MultiTensorButton->setEnabled(foundDwVolume);
 }
 
 void QmitkDiffusionQuantificationView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/, const QList<mitk::DataNode::Pointer>& )
 {
   UpdateGui();
 }
 
 void QmitkDiffusionQuantificationView::ADC_DWI()
 {
   DoAdcCalculation(true);
 }
 
 void QmitkDiffusionQuantificationView::MD_DWI()
 {
   DoAdcCalculation(false);
 }
 
 void QmitkDiffusionQuantificationView::DoBallStickCalculation()
 {
   if (m_Controls->m_ImageBox->GetSelectedNode().IsNotNull())
   {
     mitk::DataNode* node = m_Controls->m_ImageBox->GetSelectedNode();
     mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
 
     typedef itk::BallAndSticksImageFilter< short, double > FilterType;
 
     ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
     mitk::CastToItkImage(image, itkVectorImagePointer);
     FilterType::Pointer filter = FilterType::New();
     filter->SetInput( itkVectorImagePointer );
 
     filter->SetGradientDirections( static_cast<mitk::GradientDirectionsProperty*>
                                    ( image->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )
                                    ->GetGradientDirectionsContainer() );
 
     filter->SetB_value( static_cast<mitk::FloatProperty*>
                         (image->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )
                         ->GetValue() );
 
     filter->Update();
 
     mitk::Image::Pointer newImage = mitk::Image::New();
     newImage->InitializeByItk( filter->GetOutput() );
     newImage->SetVolume( filter->GetOutput()->GetBufferPointer() );
     mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
     imageNode->SetData( newImage );
     QString name = node->GetName().c_str();
 
     imageNode->SetName((name+"_f").toStdString().c_str());
     GetDataStorage()->Add(imageNode, node);
 
     {
       FilterType::PeakImageType::Pointer itkImg = filter->GetPeakImage();
       mitk::Image::Pointer newImage = mitk::Image::New();
       CastToMitkImage(itkImg, newImage);
 
       mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
       imageNode->SetData( newImage );
       QString name = node->GetName().c_str();
 
       imageNode->SetName((name+"_Sticks").toStdString().c_str());
       GetDataStorage()->Add(imageNode, node);
     }
 
     {
       mitk::Image::Pointer dOut = mitk::GrabItkImageMemory( filter->GetOutDwi().GetPointer() );
 
       dOut->GetPropertyList()->ReplaceProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), image->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() );
       dOut->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), image->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() );
       mitk::DiffusionPropertyHelper propertyHelper( dOut );
       propertyHelper.InitializeImage();
 
       mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
       imageNode->SetData( dOut );
       QString name = node->GetName().c_str();
       imageNode->SetName((name+"_Estimated-DWI").toStdString().c_str());
       GetDataStorage()->Add(imageNode, node);
     }
   }
 }
 
 void QmitkDiffusionQuantificationView::DoMultiTensorCalculation()
 {
   if (m_Controls->m_ImageBox->GetSelectedNode().IsNotNull()) // for all items
   {
     mitk::DataNode* node = m_Controls->m_ImageBox->GetSelectedNode();
     mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
 
     typedef itk::MultiTensorImageFilter< short, double > FilterType;
 
     ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
     mitk::CastToItkImage(image, itkVectorImagePointer);
     FilterType::Pointer filter = FilterType::New();
     filter->SetInput( itkVectorImagePointer );
 
     filter->SetGradientDirections( static_cast<mitk::GradientDirectionsProperty*>
                                    ( image->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )
                                    ->GetGradientDirectionsContainer() );
 
     filter->SetB_value( static_cast<mitk::FloatProperty*>
                         (image->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )
                         ->GetValue() );
 
     filter->Update();
 
     typedef mitk::TensorImage::ItkTensorImageType TensorImageType;
     for (int i=0; i<NUM_TENSORS; i++)
     {
       TensorImageType::Pointer tensorImage = filter->GetTensorImages().at(i);
       mitk::TensorImage::Pointer image = mitk::TensorImage::New();
       image->InitializeByItk( tensorImage.GetPointer() );
       image->SetVolume( tensorImage->GetBufferPointer() );
 
       mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
       imageNode->SetData( image );
       QString name = node->GetName().c_str();
       name.append("_Tensor");
       name.append(boost::lexical_cast<std::string>(i).c_str());
       imageNode->SetName(name.toStdString().c_str());
       GetDataStorage()->Add(imageNode, node);
     }
   }
 }
 
 void QmitkDiffusionQuantificationView::DoAdcCalculation(bool fit)
 {
   if (m_Controls->m_ImageBox->GetSelectedNode().IsNotNull())
   {
     mitk::DataNode* node = m_Controls->m_ImageBox->GetSelectedNode();
     mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
 
     typedef itk::AdcImageFilter< short, double > FilterType;
 
     ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
     mitk::CastToItkImage(image, itkVectorImagePointer);
     FilterType::Pointer filter = FilterType::New();
     filter->SetInput( itkVectorImagePointer );
 
     filter->SetGradientDirections( mitk::DiffusionPropertyHelper::GetGradientContainer(image) );
     filter->SetB_value( mitk::DiffusionPropertyHelper::GetReferenceBValue(image) );
 
     filter->SetFitSignal(fit);
     filter->Update();
 
     typedef itk::ShiftScaleImageFilter<itk::AdcImageFilter< short, double >::OutputImageType, itk::AdcImageFilter< short, double >::OutputImageType> ShiftScaleFilterType;
     ShiftScaleFilterType::Pointer multi = ShiftScaleFilterType::New();
     multi->SetShift(0.0);
     multi->SetScale(m_Controls->m_ScaleImageValuesBox->value());
     multi->SetInput(filter->GetOutput());
     multi->Update();
 
     mitk::Image::Pointer newImage = mitk::Image::New();
     newImage->InitializeByItk( multi->GetOutput() );
     newImage->SetVolume( multi->GetOutput()->GetBufferPointer() );
     mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
     imageNode->SetData( newImage );
     QString name = node->GetName().c_str();
 
     mitk::LookupTable::Pointer lut = mitk::LookupTable::New();
     lut->SetType( mitk::LookupTable::JET_TRANSPARENT );
     mitk::LookupTableProperty::Pointer lut_prop = mitk::LookupTableProperty::New();
     lut_prop->SetLookupTable( lut );
 
     imageNode->SetProperty("LookupTable", lut_prop );
     if (fit)
       imageNode->SetName((name+"_ADC").toStdString().c_str());
     else
       imageNode->SetName((name+"_MD").toStdString().c_str());
     GetDataStorage()->Add(imageNode, node);
   }
 }
 
 void QmitkDiffusionQuantificationView::GFACheckboxClicked()
 {
   m_Controls->frame_2->setVisible(m_Controls->m_StandardGFACheckbox->isChecked());
 }
 
 void QmitkDiffusionQuantificationView::GFA()
 {
   if(m_Controls->m_StandardGFACheckbox->isChecked())
   {
     OdfQuantify(13);
   }
   else
   {
     OdfQuantify(0);
   }
 }
 
 void QmitkDiffusionQuantificationView::Curvature()
 {
   OdfQuantify(12);
 }
 
 void QmitkDiffusionQuantificationView::FA()
 {
   TensorQuantify(0);
 }
 
 void QmitkDiffusionQuantificationView::RA()
 {
   TensorQuantify(1);
 }
 
 void QmitkDiffusionQuantificationView::AD()
 {
   TensorQuantify(2);
 }
 
 void QmitkDiffusionQuantificationView::RD()
 {
   TensorQuantify(3);
 }
 
 void QmitkDiffusionQuantificationView::ClusterAnisotropy()
 {
   TensorQuantify(4);
 }
 
 void QmitkDiffusionQuantificationView::MD()
 {
   TensorQuantify(5);
 }
 
 void QmitkDiffusionQuantificationView::OdfQuantify(int method)
 {
   OdfQuantification(method);
 }
 
 void QmitkDiffusionQuantificationView::TensorQuantify(int method)
 {
   TensorQuantification(method);
 }
 
 void QmitkDiffusionQuantificationView::OdfQuantification(int method)
 {
   QString status;
 
   if (m_Controls->m_ImageBox->GetSelectedNode().IsNotNull())
   {
     mitk::DataNode* node = m_Controls->m_ImageBox->GetSelectedNode();
 
     typedef float TOdfPixelType;
     typedef itk::Vector<TOdfPixelType,ODF_SAMPLING_SIZE> OdfVectorType;
     typedef itk::Image<OdfVectorType,3> OdfVectorImgType;
     mitk::Image* vol = static_cast<mitk::Image*>(node->GetData());
     OdfVectorImgType::Pointer itkvol = OdfVectorImgType::New();
     mitk::CastToItkImage(vol, itkvol);
 
     std::string nodename = node->GetName();
 
     float p1 = m_Controls->m_ParamKEdit->text().toFloat();
     float p2 = m_Controls->m_ParamPEdit->text().toFloat();
 
     mitk::StatusBar::GetInstance()->DisplayText(status.sprintf("Computing GFA for %s", nodename.c_str()).toLatin1());
     typedef itk::DiffusionOdfGeneralizedFaImageFilter<TOdfPixelType,TOdfPixelType,ODF_SAMPLING_SIZE> GfaFilterType;
     GfaFilterType::Pointer gfaFilter = GfaFilterType::New();
     gfaFilter->SetInput(itkvol);
 
     std::string newname;
     newname.append(nodename);
     switch(method)
     {
     case 0:
     {
       gfaFilter->SetComputationMethod(GfaFilterType::GFA_STANDARD);
       newname.append("GFA");
       break;
     }
     case 1:
     {
       gfaFilter->SetComputationMethod(GfaFilterType::GFA_QUANTILES_HIGH_LOW);
       newname.append("01");
       break;
     }
     case 2:
     {
       gfaFilter->SetComputationMethod(GfaFilterType::GFA_QUANTILE_HIGH);
       newname.append("02");
       break;
     }
     case 3:
     {
       gfaFilter->SetComputationMethod(GfaFilterType::GFA_MAX_ODF_VALUE);
       newname.append("03");
       break;
     }
     case 4:
     {
       gfaFilter->SetComputationMethod(GfaFilterType::GFA_DECONVOLUTION_COEFFS);
       newname.append("04");
       break;
     }
     case 5:
     {
       gfaFilter->SetComputationMethod(GfaFilterType::GFA_MIN_MAX_NORMALIZED_STANDARD);
       newname.append("05");
       break;
     }
     case 6:
     {
       gfaFilter->SetComputationMethod(GfaFilterType::GFA_NORMALIZED_ENTROPY);
       newname.append("06");
       break;
     }
     case 7:
     {
       gfaFilter->SetComputationMethod(GfaFilterType::GFA_NEMATIC_ORDER_PARAMETER);
       newname.append("07");
       break;
     }
     case 8:
     {
       gfaFilter->SetComputationMethod(GfaFilterType::GFA_QUANTILES_LOW_HIGH);
       newname.append("08");
       break;
     }
     case 9:
     {
       gfaFilter->SetComputationMethod(GfaFilterType::GFA_QUANTILE_LOW);
       newname.append("09");
       break;
     }
     case 10:
     {
       gfaFilter->SetComputationMethod(GfaFilterType::GFA_MIN_ODF_VALUE);
       newname.append("10");
       break;
     }
     case 11:
     {
       gfaFilter->SetComputationMethod(GfaFilterType::GFA_STD_BY_MAX);
       newname.append("11");
       break;
     }
     case 12:
     {
       p1 = m_Controls->MinAngle->text().toFloat();
       p2 = m_Controls->MaxAngle->text().toFloat();
       gfaFilter->SetComputationMethod(GfaFilterType::GFA_PRINCIPLE_CURVATURE);
       QString paramString;
       paramString = paramString.append("PC%1-%2").arg(p1).arg(p2);
       newname.append(paramString.toLatin1());
       gfaFilter->SetParam1(p1);
       gfaFilter->SetParam2(p2);
       break;
     }
     case 13:
     {
       gfaFilter->SetComputationMethod(GfaFilterType::GFA_GENERALIZED_GFA);
       QString paramString;
       paramString = paramString.append("GFAK%1P%2").arg(p1).arg(p2);
       newname.append(paramString.toLatin1());
       gfaFilter->SetParam1(p1);
       gfaFilter->SetParam2(p2);
       break;
     }
     default:
     {
       newname.append("0");
       gfaFilter->SetComputationMethod(GfaFilterType::GFA_STANDARD);
     }
     }
     gfaFilter->Update();
 
     typedef itk::Image<TOdfPixelType, 3> ImgType;
     ImgType::Pointer img = ImgType::New();
     img->SetSpacing( gfaFilter->GetOutput()->GetSpacing() );   // Set the image spacing
     img->SetOrigin( gfaFilter->GetOutput()->GetOrigin() );     // Set the image origin
     img->SetDirection( gfaFilter->GetOutput()->GetDirection() );  // Set the image direction
     img->SetLargestPossibleRegion( gfaFilter->GetOutput()->GetLargestPossibleRegion());
     img->SetBufferedRegion( gfaFilter->GetOutput()->GetLargestPossibleRegion() );
     img->Allocate();
     itk::ImageRegionIterator<ImgType> ot (img, img->GetLargestPossibleRegion() );
     ot.GoToBegin();
     itk::ImageRegionConstIterator<GfaFilterType::OutputImageType> it
         (gfaFilter->GetOutput(), gfaFilter->GetOutput()->GetLargestPossibleRegion() );
 
     for (it.GoToBegin(); !it.IsAtEnd(); ++it)
     {
       GfaFilterType::OutputImageType::PixelType val = it.Get();
       ot.Set(val * m_Controls->m_ScaleImageValuesBox->value());
       ++ot;
     }
 
 
     // GFA TO DATATREE
     mitk::Image::Pointer image = mitk::Image::New();
     image->InitializeByItk( img.GetPointer() );
     image->SetVolume( img->GetBufferPointer() );
     mitk::DataNode::Pointer new_node=mitk::DataNode::New();
     new_node->SetData( image );
     new_node->SetProperty( "name", mitk::StringProperty::New(newname) );
 
     mitk::LookupTable::Pointer lut = mitk::LookupTable::New();
     lut->SetType( mitk::LookupTable::JET_TRANSPARENT );
     mitk::LookupTableProperty::Pointer lut_prop = mitk::LookupTableProperty::New();
     lut_prop->SetLookupTable( lut );
     new_node->SetProperty("LookupTable", lut_prop );
 
     GetDataStorage()->Add(new_node, node);
 
     mitk::StatusBar::GetInstance()->DisplayText("Computation complete.");
   }
 
   this->GetRenderWindowPart()->RequestUpdate();
 
 }
 
 void QmitkDiffusionQuantificationView::TensorQuantification(int method)
 {
   QString status;
 
   if (m_Controls->m_ImageBox->GetSelectedNode().IsNotNull())
   {
     mitk::DataNode* node = m_Controls->m_ImageBox->GetSelectedNode();
 
     typedef mitk::TensorImage::ScalarPixelType    TTensorPixelType;
     typedef mitk::TensorImage::ItkTensorImageType TensorImageType;
 
     mitk::Image* vol = static_cast<mitk::Image*>(node->GetData());
     TensorImageType::Pointer itkvol = TensorImageType::New();
     mitk::CastToItkImage(vol, itkvol);
 
     std::string nodename = node->GetName();
 
     mitk::StatusBar::GetInstance()->DisplayText(status.sprintf("Computing FA for %s", nodename.c_str()).toLatin1());
     typedef itk::Image< TTensorPixelType, 3 > FAImageType;
 
     typedef itk::ShiftScaleImageFilter<FAImageType, FAImageType> ShiftScaleFilterType;
     ShiftScaleFilterType::Pointer multi = ShiftScaleFilterType::New();
     multi->SetShift(0.0);
     multi->SetScale(m_Controls->m_ScaleImageValuesBox->value());
 
     typedef itk::TensorDerivedMeasurementsFilter<TTensorPixelType> MeasurementsType;
 
     if(method == 0) //FA
     {
       MeasurementsType::Pointer measurementsCalculator = MeasurementsType::New();
       measurementsCalculator->SetInput(itkvol.GetPointer() );
       measurementsCalculator->SetMeasure(MeasurementsType::FA);
       measurementsCalculator->Update();
       multi->SetInput(measurementsCalculator->GetOutput());
       nodename = QString(nodename.c_str()).append("_FA").toStdString();
 
     }
     else if(method == 1) //RA
     {
       MeasurementsType::Pointer measurementsCalculator = MeasurementsType::New();
       measurementsCalculator->SetInput(itkvol.GetPointer() );
       measurementsCalculator->SetMeasure(MeasurementsType::RA);
       measurementsCalculator->Update();
       multi->SetInput(measurementsCalculator->GetOutput());
       nodename = QString(nodename.c_str()).append("_RA").toStdString();
 
     }
     else if(method == 2) // AD (Axial diffusivity)
     {
       MeasurementsType::Pointer measurementsCalculator = MeasurementsType::New();
       measurementsCalculator->SetInput(itkvol.GetPointer() );
       measurementsCalculator->SetMeasure(MeasurementsType::AD);
       measurementsCalculator->Update();
       multi->SetInput(measurementsCalculator->GetOutput());
       nodename = QString(nodename.c_str()).append("_AD").toStdString();
     }
     else if(method == 3) // RD (Radial diffusivity, (Lambda2+Lambda3)/2
     {
       MeasurementsType::Pointer measurementsCalculator = MeasurementsType::New();
       measurementsCalculator->SetInput(itkvol.GetPointer() );
       measurementsCalculator->SetMeasure(MeasurementsType::RD);
       measurementsCalculator->Update();
       multi->SetInput(measurementsCalculator->GetOutput());
       nodename = QString(nodename.c_str()).append("_RD").toStdString();
     }
     else if(method == 4) // 1-(Lambda2+Lambda3)/(2*Lambda1)
     {
       MeasurementsType::Pointer measurementsCalculator = MeasurementsType::New();
       measurementsCalculator->SetInput(itkvol.GetPointer() );
       measurementsCalculator->SetMeasure(MeasurementsType::CA);
       measurementsCalculator->Update();
       multi->SetInput(measurementsCalculator->GetOutput());
       nodename = QString(nodename.c_str()).append("_CA").toStdString();
     }
     else if(method == 5) // MD (Mean Diffusivity, (Lambda1+Lambda2+Lambda3)/3 )
     {
       MeasurementsType::Pointer measurementsCalculator = MeasurementsType::New();
       measurementsCalculator->SetInput(itkvol.GetPointer() );
       measurementsCalculator->SetMeasure(MeasurementsType::MD);
       measurementsCalculator->Update();
       multi->SetInput(measurementsCalculator->GetOutput());
       nodename = QString(nodename.c_str()).append("_MD").toStdString();
     }
 
     multi->Update();
 
     // FA TO DATATREE
     mitk::Image::Pointer image = mitk::Image::New();
     image->InitializeByItk( multi->GetOutput() );
     image->SetVolume( multi->GetOutput()->GetBufferPointer() );
     mitk::DataNode::Pointer new_node=mitk::DataNode::New();
     new_node->SetData( image );
     new_node->SetProperty( "name", mitk::StringProperty::New(nodename) );
 
     mitk::LookupTable::Pointer lut = mitk::LookupTable::New();
     lut->SetType( mitk::LookupTable::JET_TRANSPARENT );
     mitk::LookupTableProperty::Pointer lut_prop = mitk::LookupTableProperty::New();
     lut_prop->SetLookupTable( lut );
     new_node->SetProperty("LookupTable", lut_prop );
 
     GetDataStorage()->Add(new_node, node);
 
     mitk::StatusBar::GetInstance()->DisplayText("Computation complete.");
   }
 
   this->GetRenderWindowPart()->RequestUpdate();
 
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.tbss/src/internal/QmitkTbssSkeletonizationView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging.tbss/src/internal/QmitkTbssSkeletonizationView.cpp
index 6c388e9c7c..fd8444008f 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging.tbss/src/internal/QmitkTbssSkeletonizationView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging.tbss/src/internal/QmitkTbssSkeletonizationView.cpp
@@ -1,502 +1,502 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 // Qmitk
 #include "QmitkTbssSkeletonizationView.h"
 
 
 #include <itkSkeletonizationFilter.h>
 #include <itkProjectionFilter.h>
 #include <itkDistanceMapFilter.h>
 #include <itkBinaryThresholdImageFilter.h>
 
 #include <itkImageFileReader.h>
 
 // mitk
 #include <mitkImagePixelReadAccessor.h>
 #include <mitkImagePixelWriteAccessor.h>
 #include <mitkPixelTypeMultiplex.h>
 #include <mitkImage.h>
 
 // Qt
 #include <QInputDialog>
 #include <QMessageBox>
 
 //vtk
 #include <vtkLinearTransform.h>
 #include <vtkMatrix4x4.h>
 
 // Boost
-#include <boost/lexical_cast.hpp>
+#include <mitkLexicalCast.h>
 
 
 
 const std::string QmitkTbssSkeletonizationView::VIEW_ID = "org.mitk.views.tbssskeletonization";
 
 using namespace berry;
 
 
 QmitkTbssSkeletonizationView::QmitkTbssSkeletonizationView()
   : QmitkAbstractView()
   , m_Controls( 0 )
   , m_Activated(false)
 {
 
 }
 
 QmitkTbssSkeletonizationView::~QmitkTbssSkeletonizationView()
 {
 }
 
 void QmitkTbssSkeletonizationView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/, const QList<mitk::DataNode::Pointer>& nodes)
 {
 
 
   //datamanager selection changed
   if (!this->IsActivated())
     return;
 
   bool found3dImage = false;
   bool found4dImage = false;
 
   this->m_Controls->m_TubularName->setText(QString("Tubular Structure Mask: "));
   this->m_Controls->m_TubularName->setEnabled(false);
   this->m_Controls->m_MeanLabel->setText(QString("Mean: "));
   this->m_Controls->m_MeanLabel->setEnabled(false);
   this->m_Controls->m_PatientDataLabel->setText(QString("Patient Data: "));
   this->m_Controls->m_PatientDataLabel->setEnabled(false);
 
 
   // iterate selection
   for (mitk::DataNode::Pointer node: nodes)
   {
     // only look at interesting types from valid nodes
     mitk::BaseData* nodeData = node->GetData();
     std::string name = "";
     node->GetStringProperty("name", name);
 
 
     if(nodeData)
     {
       if(QString("Image").compare(nodeData->GetNameOfClass())==0)
       {
         mitk::Image* img = static_cast<mitk::Image*>(nodeData);
 
         if(img->GetDimension() == 3)
         {
           bool isBinary(false);
           node->GetBoolProperty("binary", isBinary);
 
 
           if(isBinary)
           {
             QString label("Tubular Structure Mask: ");
             label.append(QString(name.c_str()));
             this->m_Controls->m_TubularName->setText(label);
             this->m_Controls->m_TubularName->setEnabled(true);
           }
           else
           {
             found3dImage = true;
             QString label("Mean: ");
             label.append(QString(name.c_str()));
             this->m_Controls->m_MeanLabel->setText(label);
             this->m_Controls->m_MeanLabel->setEnabled(true);
           }
         }
         else if(img->GetDimension() == 4)
         {
           found4dImage = true;
           QString label("Patient Data: ");
           label.append(QString(name.c_str()));
           this->m_Controls->m_PatientDataLabel->setText(label);
           this->m_Controls->m_PatientDataLabel->setEnabled(true);
         }
       }
     }
 
   }
 
   this->m_Controls->m_Skeletonize->setEnabled(found3dImage);
   this->m_Controls->m_Project->setEnabled(found3dImage && found4dImage);
   this->m_Controls->m_OutputMask->setEnabled(found3dImage && found4dImage);
   this->m_Controls->m_OutputDistanceMap->setEnabled(found3dImage && found4dImage);
 
 }
 
 
 
 void QmitkTbssSkeletonizationView::CreateQtPartControl( QWidget *parent )
 {
   // build up qt view, unless already done
   if ( !m_Controls )
   {
     // create GUI widgets from the Qt Designer's .ui file
     m_Controls = new Ui::QmitkTbssSkeletonizationViewControls;
     m_Controls->setupUi( parent );
     this->CreateConnections();
   }
 
 }
 
 void QmitkTbssSkeletonizationView::SetFocus()
 {
   m_Controls->m_Skeletonize->setFocus();
 }
 
 void QmitkTbssSkeletonizationView::Activated()
 {
   m_Activated = true;
 }
 
 void QmitkTbssSkeletonizationView::Deactivated()
 {
   m_Activated = false;
 }
 
 bool QmitkTbssSkeletonizationView::IsActivated() const
 {
   return m_Activated;
 }
 
 void QmitkTbssSkeletonizationView::Visible()
 {
 }
 
 void QmitkTbssSkeletonizationView::Hidden()
 {
 }
 
 void QmitkTbssSkeletonizationView::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( (QObject*)(m_Controls->m_Skeletonize), SIGNAL(clicked()), this, SLOT(Skeletonize() ));
     connect( (QObject*)(m_Controls->m_Project), SIGNAL(clicked()), this, SLOT(Project() ));
   }
 }
 
 
 
 void QmitkTbssSkeletonizationView::Skeletonize()
 {
 
 
 
 
   typedef itk::SkeletonizationFilter<FloatImageType, FloatImageType> SkeletonisationFilterType;
   SkeletonisationFilterType::Pointer skeletonizer = SkeletonisationFilterType::New();
 
 
   QList<mitk::DataNode::Pointer> nodes = this->GetDataManagerSelection();
 
 
   mitk::Image::Pointer meanImage = mitk::Image::New();
   std::string name = "";
 
   for (auto node: nodes)
   {
     // process only on valid nodes
     mitk::BaseData* nodeData = node->GetData();
 
     if(nodeData)
     {
       if(QString("Image").compare(nodeData->GetNameOfClass())==0)
       {
 
         bool isBinary(false);
         node->GetBoolProperty("binary", isBinary);
 
         mitk::Image* img = static_cast<mitk::Image*>(nodeData);
         if(img->GetDimension() == 3 && !isBinary)
         {
           meanImage = img;
           name = node->GetName();
         }
       }
     }
   }
 
 
   // Calculate skeleton
   FloatImageType::Pointer itkImg = FloatImageType::New();
   mitk::CastToItkImage(meanImage, itkImg);
   skeletonizer->SetInput(itkImg);
   skeletonizer->Update();
 
 
   FloatImageType::Pointer output = skeletonizer->GetOutput();
   mitk::Image::Pointer mitkOutput = mitk::Image::New();
   mitk::CastToMitkImage(output, mitkOutput);
   name += "_skeleton";
   AddToDataStorage(mitkOutput, name);
 
 
 
 }
 
 void QmitkTbssSkeletonizationView::Project()
 {
 
   typedef itk::SkeletonizationFilter<FloatImageType, FloatImageType> SkeletonisationFilterType;
   typedef itk::ProjectionFilter ProjectionFilterType;
   typedef itk::DistanceMapFilter<FloatImageType, FloatImageType> DistanceMapFilterType;
 
   SkeletonisationFilterType::Pointer skeletonizer = SkeletonisationFilterType::New();
 
 
 
   QList<mitk::DataNode::Pointer> nodes = this->GetDataManagerSelection();
 
 
   mitk::Image::Pointer meanImage = mitk::Image::New();
   mitk::Image::Pointer subjects = mitk::Image::New();
   mitk::Image::Pointer tubular = mitk::Image::New();
 
   for (auto node: nodes)
   {
     // process only on valid nodes
     mitk::BaseData* nodeData = node->GetData();
 
     if(nodeData)
     {
       if(QString("Image").compare(nodeData->GetNameOfClass())==0)
       {
         mitk::Image* img = static_cast<mitk::Image*>(nodeData);
         if(img->GetDimension() == 3)
         {
 
           bool isBinary(false);
           node->GetBoolProperty("binary", isBinary);
 
 
           if(isBinary)
           {
             tubular = img;
           }
           else
           {
             meanImage = img;
           }
         }
 
         else if(img->GetDimension() == 4)
         {
           subjects = img;
         }
       }
     }
 
   }
 
   Float4DImageType::Pointer allFA;
   mitkPixelTypeMultiplex2(ConvertToItk,subjects->GetChannelDescriptor().GetPixelType(),subjects, allFA);
 
     // Calculate skeleton
   FloatImageType::Pointer itkImg = FloatImageType::New();
   mitk::CastToItkImage(meanImage, itkImg);
   skeletonizer->SetInput(itkImg);
   skeletonizer->Update();
 
 
   FloatImageType::Pointer output = skeletonizer->GetOutput();
   mitk::Image::Pointer mitkOutput = mitk::Image::New();
   mitk::CastToMitkImage(output, mitkOutput);
   AddToDataStorage(mitkOutput, "mean_FA_skeletonised");
 
 
 
   // Retrieve direction image needed later by the projection filter
   DirectionImageType::Pointer directionImg = skeletonizer->GetVectorImage();
 
 
   // Calculate distance image
   DistanceMapFilterType::Pointer distanceMapFilter = DistanceMapFilterType::New();
   distanceMapFilter->SetInput(output);
   distanceMapFilter->Update();
   FloatImageType::Pointer distanceMap = distanceMapFilter->GetOutput();
 
   if(m_Controls->m_OutputDistanceMap->isChecked())
   {
     mitk::Image::Pointer mitkDistance = mitk::Image::New();
     mitk::CastToMitkImage(distanceMap, mitkDistance);
     AddToDataStorage(mitkDistance, "distance map");
   }
 
   // Do projection
 
   // Ask a threshold to create a skeleton mask
   double threshold = -1.0;
   while(threshold == -1.0)
   {
     threshold = QInputDialog::getDouble(m_Controls->m_Skeletonize, tr("Specify the FA threshold"),
                                         tr("Threshold:"), QLineEdit::Normal,
                                         0.2);
 
     if(threshold < 0.0 || threshold > 1.0)
     {
       QMessageBox msgBox;
       msgBox.setText("Please choose a value between 0 and 1");
       msgBox.exec();
       threshold = -1.0;
     }
   }
 
   typedef itk::BinaryThresholdImageFilter<FloatImageType, CharImageType> ThresholdFilterType;
   ThresholdFilterType::Pointer thresholder = ThresholdFilterType::New();
   thresholder->SetInput(output);
   thresholder->SetLowerThreshold(threshold);
   thresholder->SetUpperThreshold(std::numeric_limits<float>::max());
   thresholder->SetOutsideValue(0);
   thresholder->SetInsideValue(1);
   thresholder->Update();
 
 
   CharImageType::Pointer thresholdedImg = thresholder->GetOutput();
 
 
   if(m_Controls->m_OutputMask->isChecked())
   {
     mitk::Image::Pointer mitkThresholded = mitk::Image::New();
     mitk::CastToMitkImage(thresholdedImg, mitkThresholded);
     std::string maskName = "skeleton_mask_at_" + boost::lexical_cast<std::string>(threshold);
     AddToDataStorage(mitkThresholded, maskName);
   }
 
 
 
 
   CharImageType::Pointer itkTubular = CharImageType::New();
   mitk::CastToItkImage(tubular, itkTubular);
 
 
   ProjectionFilterType::Pointer projectionFilter = ProjectionFilterType::New();
   projectionFilter->SetDistanceMap(distanceMap);
   projectionFilter->SetDirections(directionImg);
   projectionFilter->SetAllFA(allFA);
   projectionFilter->SetTube(itkTubular);
   projectionFilter->SetSkeleton(thresholdedImg);
   projectionFilter->Project();
 
   Float4DImageType::Pointer projected = projectionFilter->GetProjections();
 
   mitk::Image::Pointer mitkProjections = mitk::Image::New();
   mitk::CastToMitkImage(projected, mitkProjections);
 
   AddToDataStorage(mitkProjections, "all_FA_projected");
 
 
 
 }
 
 void QmitkTbssSkeletonizationView::AddToDataStorage(mitk::Image* img, std::string name)
 {
   mitk::DataNode::Pointer result = mitk::DataNode::New();
   result->SetProperty( "name", mitk::StringProperty::New(name) );
   result->SetData( img );
 
   // add new image to data storage and set as active to ease further processing
   GetDataStorage()->Add( result );
 }
 
 
 
 template <class TPixel>
 void QmitkTbssSkeletonizationView::ConvertToItk(mitk::PixelType, mitk::Image* image, Float4DImageType::Pointer output)
 {
   output = Float4DImageType::New();
 
   mitk::BaseGeometry* geo = image->GetGeometry();
   mitk::Vector3D mitkSpacing = geo->GetSpacing();
   mitk::Point3D mitkOrigin = geo->GetOrigin();
 
   Float4DImageType::SpacingType spacing;
   spacing[0] = mitkSpacing[0];
   spacing[1] = mitkSpacing[1];
   spacing[2] = mitkSpacing[2];
   spacing[3] = 1.0; // todo: check if spacing has length 4
 
   Float4DImageType::PointType origin;
   origin[0] = mitkOrigin[0];
   origin[1] = mitkOrigin[1];
   origin[2] = mitkOrigin[2];
   origin[3] = 0;
 
   Float4DImageType::SizeType size;
   size[0] = image->GetDimension(0);
   size[1] = image->GetDimension(1);
   size[2] = image->GetDimension(2);
   size[3] = image->GetDimension(3);
 
   Float4DImageType::DirectionType dir;
   vtkLinearTransform* lin = geo->GetVtkTransform();
   vtkMatrix4x4 *m = lin->GetMatrix();
 
   dir.Fill(0.0);
   for(int x=0; x<3; x++)
   {
     for(int y=0; y<3; y++)
     {
       dir[x][y] = m->GetElement(x,y);
     }
   }
   dir[3][3] = 1;
 
 
 
   output->SetSpacing(spacing);
   output->SetOrigin(origin);
   output->SetRegions(size);
   output->SetDirection(dir);
   output->Allocate();
 
 
   if(image->GetDimension() == 4)
   {
     unsigned int timesteps = image->GetDimension(3);
 
     try{
       // REPLACE THIS METHODE()ConvertToItk) WITH mitk::CastToItk
 
       // iterate through the subjects and copy data to output
       for(unsigned int t=0; t<timesteps; t++)
       {
         mitk::ImagePixelReadAccessor <TPixel,3> inAcc(image,image->GetVolumeData(t));
 
         for(unsigned int x=0; x<image->GetDimension(0); x++)
         {
           for(unsigned int y=0; y<image->GetDimension(1); y++)
           {
             for(unsigned int z=0; z<image->GetDimension(2); z++)
             {
               itk::Index<3> ix = {{x, y, z}};
               itk::Index<4> ix4 = {{x, y, z, t}};
 
               output->SetPixel(ix4, inAcc.GetPixelByIndex(ix));
 
             }
           }
         }
       }
     }
     catch(const std::exception & e)
     {
       MITK_INFO << e.what();
     }
 
   }
 
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.tractography/src/internal/QmitkStreamlineTrackingView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging.tractography/src/internal/QmitkStreamlineTrackingView.cpp
index 94b0c2aea0..58a19d4aa9 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging.tractography/src/internal/QmitkStreamlineTrackingView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging.tractography/src/internal/QmitkStreamlineTrackingView.cpp
@@ -1,1026 +1,1026 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 #include <berryIStructuredSelection.h>
 
 // Qmitk
 #include "QmitkStreamlineTrackingView.h"
 #include "QmitkStdMultiWidget.h"
 
 // Qt
 #include <QMessageBox>
 
 // MITK
 #include <mitkLookupTable.h>
 #include <mitkLookupTableProperty.h>
 #include <mitkImageToItk.h>
 #include <mitkFiberBundle.h>
 #include <mitkImageCast.h>
 #include <mitkImageToItk.h>
 #include <mitkNodePredicateDataType.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkNodePredicateDimension.h>
 #include <mitkOdfImage.h>
 #include <mitkSliceNavigationController.h>
 
 // VTK
 #include <vtkRenderWindowInteractor.h>
 #include <vtkPolyData.h>
 #include <vtkPoints.h>
 #include <vtkCellArray.h>
 #include <vtkSmartPointer.h>
 #include <vtkPolyLine.h>
 #include <vtkCellData.h>
 
 #include <itkTensorImageToOdfImageFilter.h>
 #include <omp.h>
-#include <boost/lexical_cast.hpp>
+#include <mitkLexicalCast.h>
 
 const std::string QmitkStreamlineTrackingView::VIEW_ID = "org.mitk.views.streamlinetracking";
 const std::string id_DataManager = "org.mitk.views.datamanager";
 using namespace berry;
 
 QmitkStreamlineTrackingWorker::QmitkStreamlineTrackingWorker(QmitkStreamlineTrackingView* view)
     : m_View(view)
 {
 }
 
 void QmitkStreamlineTrackingWorker::run()
 {
     m_View->m_Tracker->Update();
     m_View->m_TrackingThread.quit();
 }
 
 QmitkStreamlineTrackingView::QmitkStreamlineTrackingView()
   : m_TrackingWorker(this)
   , m_Controls(nullptr)
   , m_FirstTensorProbRun(true)
   , m_FirstInteractiveRun(true)
   , m_TrackingHandler(nullptr)
   , m_ThreadIsRunning(false)
   , m_DeleteTrackingHandler(false)
   , m_Visible(false)
   , m_LastPrior("")
   , m_TrackingPriorHandler(nullptr)
 {
   m_TrackingWorker.moveToThread(&m_TrackingThread);
   connect(&m_TrackingThread, SIGNAL(started()), this, SLOT(BeforeThread()));
   connect(&m_TrackingThread, SIGNAL(started()), &m_TrackingWorker, SLOT(run()));
   connect(&m_TrackingThread, SIGNAL(finished()), this, SLOT(AfterThread()));
   m_TrackingTimer = new QTimer(this);
 }
 
 // Destructor
 QmitkStreamlineTrackingView::~QmitkStreamlineTrackingView()
 {
   if (m_Tracker.IsNull())
     return;
 
   m_Tracker->SetStopTracking(true);
   m_TrackingThread.wait();
 }
 
 void QmitkStreamlineTrackingView::CreateQtPartControl( QWidget *parent )
 {
   if ( !m_Controls )
   {
     // create GUI widgets from the Qt Designer's .ui file
     m_Controls = new Ui::QmitkStreamlineTrackingViewControls;
     m_Controls->setupUi( parent );
     m_Controls->m_FaImageBox->SetDataStorage(this->GetDataStorage());
     m_Controls->m_SeedImageBox->SetDataStorage(this->GetDataStorage());
     m_Controls->m_MaskImageBox->SetDataStorage(this->GetDataStorage());
     m_Controls->m_TargetImageBox->SetDataStorage(this->GetDataStorage());
     m_Controls->m_PriorImageBox->SetDataStorage(this->GetDataStorage());
     m_Controls->m_StopImageBox->SetDataStorage(this->GetDataStorage());
     m_Controls->m_ForestBox->SetDataStorage(this->GetDataStorage());
     m_Controls->m_ExclusionImageBox->SetDataStorage(this->GetDataStorage());
 
     mitk::TNodePredicateDataType<mitk::PeakImage>::Pointer isPeakImagePredicate = mitk::TNodePredicateDataType<mitk::PeakImage>::New();
     mitk::TNodePredicateDataType<mitk::Image>::Pointer isImagePredicate = mitk::TNodePredicateDataType<mitk::Image>::New();
     mitk::TNodePredicateDataType<mitk::TractographyForest>::Pointer isTractographyForest = mitk::TNodePredicateDataType<mitk::TractographyForest>::New();
 
     mitk::NodePredicateProperty::Pointer isBinaryPredicate = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
     mitk::NodePredicateNot::Pointer isNotBinaryPredicate = mitk::NodePredicateNot::New( isBinaryPredicate );
     mitk::NodePredicateAnd::Pointer isNotABinaryImagePredicate = mitk::NodePredicateAnd::New( isImagePredicate, isNotBinaryPredicate );
     mitk::NodePredicateDimension::Pointer dimensionPredicate = mitk::NodePredicateDimension::New(3);
 
     m_Controls->m_ForestBox->SetPredicate(isTractographyForest);
     m_Controls->m_FaImageBox->SetPredicate( mitk::NodePredicateAnd::New(isNotABinaryImagePredicate, dimensionPredicate) );
     m_Controls->m_FaImageBox->SetZeroEntryText("--");
     m_Controls->m_SeedImageBox->SetPredicate( mitk::NodePredicateAnd::New(isImagePredicate, dimensionPredicate) );
     m_Controls->m_SeedImageBox->SetZeroEntryText("--");
     m_Controls->m_MaskImageBox->SetPredicate( mitk::NodePredicateAnd::New(isImagePredicate, dimensionPredicate) );
     m_Controls->m_MaskImageBox->SetZeroEntryText("--");
     m_Controls->m_StopImageBox->SetPredicate( mitk::NodePredicateAnd::New(isImagePredicate, dimensionPredicate) );
     m_Controls->m_StopImageBox->SetZeroEntryText("--");
     m_Controls->m_TargetImageBox->SetPredicate( mitk::NodePredicateAnd::New(isImagePredicate, dimensionPredicate) );
     m_Controls->m_TargetImageBox->SetZeroEntryText("--");
     m_Controls->m_PriorImageBox->SetPredicate( isPeakImagePredicate );
     m_Controls->m_PriorImageBox->SetZeroEntryText("--");
     m_Controls->m_ExclusionImageBox->SetPredicate( mitk::NodePredicateAnd::New(isImagePredicate, dimensionPredicate) );
     m_Controls->m_ExclusionImageBox->SetZeroEntryText("--");
 
     connect( m_TrackingTimer, SIGNAL(timeout()), this, SLOT(TimerUpdate()) );
     connect( m_Controls->commandLinkButton_2, SIGNAL(clicked()), this, SLOT(StopTractography()) );
     connect( m_Controls->commandLinkButton, SIGNAL(clicked()), this, SLOT(DoFiberTracking()) );
     connect( m_Controls->m_InteractiveBox, SIGNAL(stateChanged(int)), this, SLOT(ToggleInteractive()) );
     connect( m_Controls->m_ModeBox, SIGNAL(currentIndexChanged(int)), this, SLOT(UpdateGui()) );
     connect( m_Controls->m_FaImageBox, SIGNAL(currentIndexChanged(int)), this, SLOT(DeleteTrackingHandler()) );
     connect( m_Controls->m_ModeBox, SIGNAL(currentIndexChanged(int)), this, SLOT(DeleteTrackingHandler()) );
     connect( m_Controls->m_OutputProbMap, SIGNAL(stateChanged(int)), this, SLOT(OutputStyleSwitched()) );
 
     connect( m_Controls->m_SeedImageBox, SIGNAL(currentIndexChanged(int)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_ModeBox, SIGNAL(currentIndexChanged(int)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_StopImageBox, SIGNAL(currentIndexChanged(int)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_TargetImageBox, SIGNAL(currentIndexChanged(int)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_PriorImageBox, SIGNAL(currentIndexChanged(int)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_ExclusionImageBox, SIGNAL(currentIndexChanged(int)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_MaskImageBox, SIGNAL(currentIndexChanged(int)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_FaImageBox, SIGNAL(currentIndexChanged(int)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_ForestBox, SIGNAL(currentIndexChanged(int)), this, SLOT(ForestSwitched()) );
     connect( m_Controls->m_ForestBox, SIGNAL(currentIndexChanged(int)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_SeedsPerVoxelBox, SIGNAL(editingFinished()), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_NumFibersBox, SIGNAL(editingFinished()), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_ScalarThresholdBox, SIGNAL(editingFinished()), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_OdfCutoffBox, SIGNAL(editingFinished()), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_StepSizeBox, SIGNAL(editingFinished()), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_SamplingDistanceBox, SIGNAL(editingFinished()), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_AngularThresholdBox, SIGNAL(editingFinished()), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_MinTractLengthBox, SIGNAL(editingFinished()), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_fBox, SIGNAL(editingFinished()), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_gBox, SIGNAL(editingFinished()), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_NumSamplesBox, SIGNAL(editingFinished()), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_SeedRadiusBox, SIGNAL(editingFinished()), this, SLOT(InteractiveSeedChanged()) );
     connect( m_Controls->m_NumSeedsBox, SIGNAL(editingFinished()), this, SLOT(InteractiveSeedChanged()) );
     connect( m_Controls->m_OutputProbMap, SIGNAL(stateChanged(int)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_SharpenOdfsBox, SIGNAL(stateChanged(int)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_InterpolationBox, SIGNAL(stateChanged(int)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_MaskInterpolationBox, SIGNAL(stateChanged(int)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_FlipXBox, SIGNAL(stateChanged(int)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_FlipYBox, SIGNAL(stateChanged(int)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_FlipZBox, SIGNAL(stateChanged(int)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_FrontalSamplesBox, SIGNAL(stateChanged(int)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_StopVotesBox, SIGNAL(stateChanged(int)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_LoopCheckBox, SIGNAL(editingFinished()), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_TrialsPerSeedBox, SIGNAL(editingFinished()), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_EpConstraintsBox, SIGNAL(currentIndexChanged(int)), this, SLOT(OnParameterChanged()) );
 
     m_Controls->m_SeedsPerVoxelBox->editingFinished();
     m_Controls->m_NumFibersBox->editingFinished();
     m_Controls->m_ScalarThresholdBox->editingFinished();
     m_Controls->m_OdfCutoffBox->editingFinished();
     m_Controls->m_StepSizeBox->editingFinished();
     m_Controls->m_SamplingDistanceBox->editingFinished();
     m_Controls->m_AngularThresholdBox->editingFinished();
     m_Controls->m_MinTractLengthBox->editingFinished();
     m_Controls->m_fBox->editingFinished();
     m_Controls->m_gBox->editingFinished();
     m_Controls->m_NumSamplesBox->editingFinished();
     m_Controls->m_SeedRadiusBox->editingFinished();
     m_Controls->m_NumSeedsBox->editingFinished();
     m_Controls->m_LoopCheckBox->editingFinished();
     m_Controls->m_TrialsPerSeedBox->editingFinished();
 
     StartStopTrackingGui(false);
   }
 
   UpdateGui();
 }
 
 void QmitkStreamlineTrackingView::StopTractography()
 {
   if (m_Tracker.IsNull())
     return;
 
   m_Tracker->SetStopTracking(true);
 }
 
 void QmitkStreamlineTrackingView::TimerUpdate()
 {
   if (m_Tracker.IsNull())
     return;
 
   QString status_text(m_Tracker->GetStatusText().c_str());
   m_Controls->m_StatusTextBox->setText(status_text);
 }
 
 void QmitkStreamlineTrackingView::BeforeThread()
 {
   m_TrackingTimer->start(1000);
 }
 
 void QmitkStreamlineTrackingView::AfterThread()
 {
   m_TrackingTimer->stop();
   if (!m_Tracker->GetUseOutputProbabilityMap())
   {
     vtkSmartPointer<vtkPolyData> fiberBundle = m_Tracker->GetFiberPolyData();
 
     if (!m_Controls->m_InteractiveBox->isChecked() && fiberBundle->GetNumberOfLines() == 0)
     {
       QMessageBox warnBox;
       warnBox.setWindowTitle("Warning");
       warnBox.setText("No fiberbundle was generated!");
       warnBox.setDetailedText("No fibers were generated using the chosen parameters. Typical reasons are:\n\n- Cutoff too high. Some images feature very low FA/GFA/peak size. Try to lower this parameter.\n- Angular threshold too strict. Try to increase this parameter.\n- A small step sizes also means many steps to go wrong. Especially in the case of probabilistic tractography. Try to adjust the angular threshold.");
       warnBox.setIcon(QMessageBox::Warning);
       warnBox.exec();
 
       if (m_InteractivePointSetNode.IsNotNull())
         m_InteractivePointSetNode->SetProperty("color", mitk::ColorProperty::New(1,1,1));
       StartStopTrackingGui(false);
       if (m_DeleteTrackingHandler)
         DeleteTrackingHandler();
       UpdateGui();
 
       return;
     }
 
     mitk::FiberBundle::Pointer fib = mitk::FiberBundle::New(fiberBundle);
     fib->SetReferenceGeometry(dynamic_cast<mitk::Image*>(m_ParentNode->GetData())->GetGeometry());
     if (m_Controls->m_ResampleFibersBox->isChecked() && fiberBundle->GetNumberOfLines()>0)
       fib->Compress(m_Controls->m_FiberErrorBox->value());
     fib->ColorFibersByOrientation();
     m_Tracker->SetDicomProperties(fib);
 
     if (m_Controls->m_InteractiveBox->isChecked())
     {
       if (m_InteractiveNode.IsNull())
       {
         m_InteractiveNode = mitk::DataNode::New();
         QString name("Interactive");
         m_InteractiveNode->SetName(name.toStdString());
         GetDataStorage()->Add(m_InteractiveNode);
       }
       m_InteractiveNode->SetData(fib);
       m_InteractiveNode->SetFloatProperty("Fiber2DSliceThickness", m_Tracker->GetMinVoxelSize()/2);
 
       if (auto renderWindowPart = this->GetRenderWindowPart())
           renderWindowPart->RequestUpdate();
     }
     else
     {
       mitk::DataNode::Pointer node = mitk::DataNode::New();
       node->SetData(fib);
       QString name("FiberBundle_");
       name += m_ParentNode->GetName().c_str();
       name += "_Streamline";
       node->SetName(name.toStdString());
       node->SetFloatProperty("Fiber2DSliceThickness", m_Tracker->GetMinVoxelSize()/2);
       GetDataStorage()->Add(node, m_ParentNode);
     }
   }
   else
   {
     TrackerType::ItkDoubleImgType::Pointer outImg = m_Tracker->GetOutputProbabilityMap();
     mitk::Image::Pointer img = mitk::Image::New();
     img->InitializeByItk(outImg.GetPointer());
     img->SetVolume(outImg->GetBufferPointer());
 
     if (m_Controls->m_InteractiveBox->isChecked())
     {
       if (m_InteractiveNode.IsNull())
       {
         m_InteractiveNode = mitk::DataNode::New();
         QString name("Interactive");
         m_InteractiveNode->SetName(name.toStdString());
         GetDataStorage()->Add(m_InteractiveNode);
       }
       m_InteractiveNode->SetData(img);
 
       mitk::LookupTable::Pointer lut = mitk::LookupTable::New();
       lut->SetType(mitk::LookupTable::JET_TRANSPARENT);
       mitk::LookupTableProperty::Pointer lut_prop = mitk::LookupTableProperty::New();
       lut_prop->SetLookupTable(lut);
       m_InteractiveNode->SetProperty("LookupTable", lut_prop);
       m_InteractiveNode->SetProperty("opacity", mitk::FloatProperty::New(0.5));
       m_InteractiveNode->SetFloatProperty("Fiber2DSliceThickness", m_Tracker->GetMinVoxelSize()/2);
 
       if (auto renderWindowPart = this->GetRenderWindowPart())
           renderWindowPart->RequestUpdate();
     }
     else
     {
       mitk::DataNode::Pointer node = mitk::DataNode::New();
       node->SetData(img);
       QString name("ProbabilityMap_");
       name += m_ParentNode->GetName().c_str();
       node->SetName(name.toStdString());
 
       mitk::LookupTable::Pointer lut = mitk::LookupTable::New();
       lut->SetType(mitk::LookupTable::JET_TRANSPARENT);
       mitk::LookupTableProperty::Pointer lut_prop = mitk::LookupTableProperty::New();
       lut_prop->SetLookupTable(lut);
       node->SetProperty("LookupTable", lut_prop);
       node->SetProperty("opacity", mitk::FloatProperty::New(0.5));
 
       GetDataStorage()->Add(node, m_ParentNode);
     }
   }
   if (m_InteractivePointSetNode.IsNotNull())
     m_InteractivePointSetNode->SetProperty("color", mitk::ColorProperty::New(1,1,1));
   StartStopTrackingGui(false);
   if (m_DeleteTrackingHandler)
     DeleteTrackingHandler();
   UpdateGui();
 }
 
 void QmitkStreamlineTrackingView::InteractiveSeedChanged(bool posChanged)
 {
   if(!CheckAndStoreLastParams(sender()) && !posChanged)
     return;
   if (m_ThreadIsRunning || !m_Visible)
     return;
 
   if (!posChanged && (!m_Controls->m_InteractiveBox->isChecked() || !m_Controls->m_ParamUpdateBox->isChecked()) )
     return;
 
   std::srand(std::time(0));
   m_SeedPoints.clear();
 
   itk::Point<float> world_pos = this->GetRenderWindowPart()->GetSelectedPosition();
 
   m_SeedPoints.push_back(world_pos);
   float radius = m_Controls->m_SeedRadiusBox->value();
   int num = m_Controls->m_NumSeedsBox->value();
 
   mitk::PointSet::Pointer pointset = mitk::PointSet::New();
   pointset->InsertPoint(0, world_pos);
   m_InteractivePointSetNode->SetProperty("pointsize", mitk::FloatProperty::New(radius*2));
   m_InteractivePointSetNode->SetProperty("point 2D size", mitk::FloatProperty::New(radius*2));
   m_InteractivePointSetNode->SetData(pointset);
 
   for (int i=1; i<num; i++)
   {
     itk::Vector<float> p;
     p[0] = rand()%1000-500;
     p[1] = rand()%1000-500;
     p[2] = rand()%1000-500;
     p.Normalize();
     p *= radius;
     m_SeedPoints.push_back(world_pos+p);
   }
   m_InteractivePointSetNode->SetProperty("color", mitk::ColorProperty::New(1,0,0));
   DoFiberTracking();
 }
 
 bool QmitkStreamlineTrackingView::CheckAndStoreLastParams(QObject* obj)
 {
   if (obj!=nullptr)
   {
     std::string new_val = "";
     if(qobject_cast<QDoubleSpinBox*>(obj)!=nullptr)
       new_val = boost::lexical_cast<std::string>(qobject_cast<QDoubleSpinBox*>(obj)->value());
     else if (qobject_cast<QSpinBox*>(obj)!=nullptr)
       new_val = boost::lexical_cast<std::string>(qobject_cast<QSpinBox*>(obj)->value());
 
     if (m_LastTractoParams.find(obj->objectName())==m_LastTractoParams.end())
     {
       m_LastTractoParams[obj->objectName()] = new_val;
       return false;
     }
     else if (m_LastTractoParams.at(obj->objectName()) != new_val)
     {
       m_LastTractoParams[obj->objectName()] = new_val;
       return true;
     }
     else if (m_LastTractoParams.at(obj->objectName()) == new_val)
       return false;
   }
   return true;
 }
 
 void QmitkStreamlineTrackingView::OnParameterChanged()
 {
   UpdateGui();
 
   if(!CheckAndStoreLastParams(sender()))
     return;
 
   if (m_Controls->m_InteractiveBox->isChecked() && m_Controls->m_ParamUpdateBox->isChecked())
     DoFiberTracking();
 }
 
 void QmitkStreamlineTrackingView::ToggleInteractive()
 {
   UpdateGui();
 
   m_Controls->m_SeedsPerVoxelBox->setEnabled(!m_Controls->m_InteractiveBox->isChecked());
   m_Controls->m_SeedsPerVoxelLabel->setEnabled(!m_Controls->m_InteractiveBox->isChecked());
   m_Controls->m_SeedImageBox->setEnabled(!m_Controls->m_InteractiveBox->isChecked());
   m_Controls->label_6->setEnabled(!m_Controls->m_InteractiveBox->isChecked());
 
   if ( m_Controls->m_InteractiveBox->isChecked() )
   {
     if (m_FirstInteractiveRun)
     {
       QMessageBox::information(nullptr, "Information", "Place and move a spherical seed region anywhere in the image by left-clicking and dragging. If the seed region is colored red, tracking is in progress. If the seed region is colored white, tracking is finished.\nPlacing the seed region for the first time in a newly selected dataset might cause a short delay, since the tracker needs to be initialized.");
       m_FirstInteractiveRun = false;
     }
 
     QApplication::setOverrideCursor(Qt::PointingHandCursor);
     QApplication::processEvents();
 
     m_InteractivePointSetNode = mitk::DataNode::New();
     m_InteractivePointSetNode->SetProperty("color", mitk::ColorProperty::New(1,1,1));
     m_InteractivePointSetNode->SetName("InteractiveSeedRegion");
     mitk::PointSetShapeProperty::Pointer shape_prop = mitk::PointSetShapeProperty::New();
     shape_prop->SetValue(mitk::PointSetShapeProperty::PointSetShape::CIRCLE);
     m_InteractivePointSetNode->SetProperty("Pointset.2D.shape", shape_prop);
     GetDataStorage()->Add(m_InteractivePointSetNode);
 
 
     m_SliceChangeListener.RenderWindowPartActivated(this->GetRenderWindowPart());
     connect(&m_SliceChangeListener, SIGNAL(SliceChanged()), this, SLOT(OnSliceChanged()));
   }
   else
   {
     QApplication::restoreOverrideCursor();
     QApplication::processEvents();
 
     m_InteractiveNode = nullptr;
     m_InteractivePointSetNode = nullptr;
 
     m_SliceChangeListener.RenderWindowPartActivated(this->GetRenderWindowPart());
     disconnect(&m_SliceChangeListener, SIGNAL(SliceChanged()), this, SLOT(OnSliceChanged()));
   }
 }
 
 void QmitkStreamlineTrackingView::Activated()
 {
 
 }
 
 void QmitkStreamlineTrackingView::Deactivated()
 {
 
 }
 
 void QmitkStreamlineTrackingView::Visible()
 {
   m_Visible = true;
 }
 
 void QmitkStreamlineTrackingView::Hidden()
 {
   m_Visible = false;
   m_Controls->m_InteractiveBox->setChecked(false);
   ToggleInteractive();
 }
 
 void QmitkStreamlineTrackingView::OnSliceChanged()
 {
   InteractiveSeedChanged(true);
 }
 
 void QmitkStreamlineTrackingView::SetFocus()
 {
 }
 
 void QmitkStreamlineTrackingView::DeleteTrackingHandler()
 {
   if (!m_ThreadIsRunning && m_TrackingHandler != nullptr)
   {
     delete m_TrackingHandler;
     m_TrackingHandler = nullptr;
     m_DeleteTrackingHandler = false;
     m_LastPrior = "";
     if (m_TrackingPriorHandler != nullptr)
       delete m_TrackingPriorHandler;
   }
   else if (m_ThreadIsRunning)
   {
     m_DeleteTrackingHandler = true;
   }
 }
 
 void QmitkStreamlineTrackingView::ForestSwitched()
 {
   DeleteTrackingHandler();
 }
 
 void QmitkStreamlineTrackingView::OutputStyleSwitched()
 {
   if (m_InteractiveNode.IsNotNull())
     GetDataStorage()->Remove(m_InteractiveNode);
   m_InteractiveNode = nullptr;
 }
 
 void QmitkStreamlineTrackingView::OnSelectionChanged( berry::IWorkbenchPart::Pointer , const QList<mitk::DataNode::Pointer>& nodes )
 {
   std::vector< mitk::DataNode::Pointer > last_nodes = m_InputImageNodes;
   m_InputImageNodes.clear();
   m_InputImages.clear();
   m_AdditionalInputImages.clear();
   bool retrack = false;
 
   for( auto node : nodes )
   {
 
     if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
     {
       if( dynamic_cast<mitk::TensorImage*>(node->GetData()) )
       {
         m_InputImageNodes.push_back(node);
         m_InputImages.push_back(dynamic_cast<mitk::Image*>(node->GetData()));
         retrack = true;
       }
       else if ( dynamic_cast<mitk::OdfImage*>(node->GetData()) )
       {
         m_InputImageNodes.push_back(node);
         m_InputImages.push_back(dynamic_cast<mitk::Image*>(node->GetData()));
         retrack = true;
       }
       else if ( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(node->GetData())) )
       {
         m_InputImageNodes.push_back(node);
         m_InputImages.push_back(dynamic_cast<mitk::Image*>(node->GetData()));
         retrack = true;
       }
       else
       {
         mitk::Image* img = dynamic_cast<mitk::Image*>(node->GetData());
         if (img!=nullptr)
         {
           int dim = img->GetDimension();
           unsigned int* dimensions = img->GetDimensions();
           if (dim==4 && dimensions[3]%3==0)
           {
             m_InputImageNodes.push_back(node);
             m_InputImages.push_back(dynamic_cast<mitk::Image*>(node->GetData()));
             retrack = true;
           }
           else if (dim==3)
           {
             m_AdditionalInputImages.push_back(dynamic_cast<mitk::Image*>(node->GetData()));
           }
         }
       }
     }
   }
 
   // sometimes the OnSelectionChanged event is sent twice and actually no selection has changed for the first event. We need to catch that.
   if (last_nodes.size() == m_InputImageNodes.size())
   {
     bool same_nodes = true;
     for (unsigned int i=0; i<m_InputImageNodes.size(); i++)
       if (last_nodes.at(i)!=m_InputImageNodes.at(i))
       {
         same_nodes = false;
         break;
       }
     if (same_nodes)
       return;
   }
 
   DeleteTrackingHandler();
   UpdateGui();
   if (retrack)
     OnParameterChanged();
 }
 
 void QmitkStreamlineTrackingView::UpdateGui()
 {
   m_Controls->m_TensorImageLabel->setText("<font color='red'>select in data-manager</font>");
 
   m_Controls->m_fBox->setEnabled(false);
   m_Controls->m_fLabel->setEnabled(false);
   m_Controls->m_gBox->setEnabled(false);
   m_Controls->m_gLabel->setEnabled(false);
   m_Controls->m_FaImageBox->setEnabled(true);
   m_Controls->mFaImageLabel->setEnabled(true);
   m_Controls->m_OdfCutoffBox->setEnabled(false);
   m_Controls->m_OdfCutoffLabel->setEnabled(false);
   m_Controls->m_SharpenOdfsBox->setEnabled(false);
   m_Controls->m_ForestBox->setVisible(false);
   m_Controls->m_ForestLabel->setVisible(false);
   m_Controls->commandLinkButton->setEnabled(false);
   m_Controls->m_TrialsPerSeedBox->setEnabled(false);
   m_Controls->m_TrialsPerSeedLabel->setEnabled(false);
   m_Controls->m_TargetImageBox->setEnabled(false);
   m_Controls->m_TargetImageLabel->setEnabled(false);
 
   if (m_Controls->m_InteractiveBox->isChecked())
   {
     m_Controls->m_InteractiveSeedingFrame->setVisible(true);
     m_Controls->m_StaticSeedingFrame->setVisible(false);
     m_Controls->commandLinkButton_2->setVisible(false);
     m_Controls->commandLinkButton->setVisible(false);
   }
   else
   {
     m_Controls->m_InteractiveSeedingFrame->setVisible(false);
     m_Controls->m_StaticSeedingFrame->setVisible(true);
     m_Controls->commandLinkButton_2->setVisible(m_ThreadIsRunning);
     m_Controls->commandLinkButton->setVisible(!m_ThreadIsRunning);
   }
 
   if (m_Controls->m_EpConstraintsBox->currentIndex()>0)
   {
     m_Controls->m_TargetImageBox->setEnabled(true);
     m_Controls->m_TargetImageLabel->setEnabled(true);
   }
 
   // trials per seed are only important for probabilistic tractography
   if (m_Controls->m_ModeBox->currentIndex()==1)
   {
     m_Controls->m_TrialsPerSeedBox->setEnabled(true);
     m_Controls->m_TrialsPerSeedLabel->setEnabled(true);
   }
 
   if(!m_InputImageNodes.empty())
   {
     if (m_InputImageNodes.size()>1)
       m_Controls->m_TensorImageLabel->setText( ( std::to_string(m_InputImageNodes.size()) + " images selected").c_str() );
     else
       m_Controls->m_TensorImageLabel->setText(m_InputImageNodes.at(0)->GetName().c_str());
     m_Controls->commandLinkButton->setEnabled(!m_Controls->m_InteractiveBox->isChecked() && !m_ThreadIsRunning);
 
     m_Controls->m_ScalarThresholdBox->setEnabled(true);
     m_Controls->m_FaThresholdLabel->setEnabled(true);
 
     if ( dynamic_cast<mitk::TensorImage*>(m_InputImageNodes.at(0)->GetData()) )
     {
       m_Controls->m_fBox->setEnabled(true);
       m_Controls->m_fLabel->setEnabled(true);
       m_Controls->m_gBox->setEnabled(true);
       m_Controls->m_gLabel->setEnabled(true);
     }
     else if ( dynamic_cast<mitk::OdfImage*>(m_InputImageNodes.at(0)->GetData()) )
     {
       m_Controls->m_OdfCutoffBox->setEnabled(true);
       m_Controls->m_OdfCutoffLabel->setEnabled(true);
       m_Controls->m_SharpenOdfsBox->setEnabled(true);
     }
     else if (  mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(m_InputImageNodes.at(0)->GetData())) )
     {
       m_Controls->m_ForestBox->setVisible(true);
       m_Controls->m_ForestLabel->setVisible(true);
       m_Controls->m_ScalarThresholdBox->setEnabled(false);
       m_Controls->m_FaThresholdLabel->setEnabled(false);
     }
   }
 }
 
 void QmitkStreamlineTrackingView::StartStopTrackingGui(bool start)
 {
   m_ThreadIsRunning = start;
 
   if (!m_Controls->m_InteractiveBox->isChecked())
   {
     m_Controls->commandLinkButton_2->setVisible(start);
     m_Controls->commandLinkButton->setVisible(!start);
     m_Controls->m_InteractiveBox->setEnabled(!start);
     m_Controls->m_StatusTextBox->setVisible(start);
   }
 }
 
 void QmitkStreamlineTrackingView::DoFiberTracking()
 {
   if (m_InputImages.empty())
   {
     QMessageBox::information(nullptr, "Information", "Please select an input image in the datamaneger (tensor, ODF, peak or dMRI image)!");
     return;
   }
   if (m_ThreadIsRunning || !m_Visible)
     return;
   if (m_Controls->m_InteractiveBox->isChecked() && m_SeedPoints.empty())
     return;
   StartStopTrackingGui(true);
 
   m_Tracker = TrackerType::New();
 
   if( dynamic_cast<mitk::TensorImage*>(m_InputImageNodes.at(0)->GetData()) )
   {
     if (m_Controls->m_ModeBox->currentIndex()==1)
     {
       if (m_InputImages.size()>1)
       {
         QMessageBox::information(nullptr, "Information", "Probabilistic tensor tractography is only implemented for single-tensor mode!");
         StartStopTrackingGui(false);
         return;
       }
 
       if (m_TrackingHandler==nullptr)
       {
         m_TrackingHandler = new mitk::TrackingHandlerOdf();
         mitk::TensorImage::ItkTensorImageType::Pointer itkImg = mitk::TensorImage::ItkTensorImageType::New();
         mitk::CastToItkImage(m_InputImages.at(0), itkImg);
 
         typedef itk::TensorImageToOdfImageFilter< float, float > FilterType;
         FilterType::Pointer filter = FilterType::New();
         filter->SetInput( itkImg );
         filter->Update();
         dynamic_cast<mitk::TrackingHandlerOdf*>(m_TrackingHandler)->SetOdfImage(filter->GetOutput());
 
         if (m_Controls->m_FaImageBox->GetSelectedNode().IsNotNull())
         {
           ItkFloatImageType::Pointer itkImg = ItkFloatImageType::New();
           mitk::CastToItkImage(dynamic_cast<mitk::Image*>(m_Controls->m_FaImageBox->GetSelectedNode()->GetData()), itkImg);
 
           dynamic_cast<mitk::TrackingHandlerOdf*>(m_TrackingHandler)->SetGfaImage(itkImg);
         }
       }
 
       dynamic_cast<mitk::TrackingHandlerOdf*>(m_TrackingHandler)->SetGfaThreshold(m_Controls->m_ScalarThresholdBox->value());
       dynamic_cast<mitk::TrackingHandlerOdf*>(m_TrackingHandler)->SetOdfThreshold(0);
       dynamic_cast<mitk::TrackingHandlerOdf*>(m_TrackingHandler)->SetSharpenOdfs(true);
       dynamic_cast<mitk::TrackingHandlerOdf*>(m_TrackingHandler)->SetIsOdfFromTensor(true);
     }
     else
     {
       if (m_TrackingHandler==nullptr)
       {
         m_TrackingHandler = new mitk::TrackingHandlerTensor();
         for (int i=0; i<(int)m_InputImages.size(); i++)
         {
           typedef mitk::ImageToItk< mitk::TrackingHandlerTensor::ItkTensorImageType > CasterType;
           CasterType::Pointer caster = CasterType::New();
           caster->SetInput(m_InputImages.at(i));
           caster->Update();
           mitk::TrackingHandlerTensor::ItkTensorImageType::ConstPointer itkImg = caster->GetOutput();
 
           dynamic_cast<mitk::TrackingHandlerTensor*>(m_TrackingHandler)->AddTensorImage(itkImg);
         }
 
         if (m_Controls->m_FaImageBox->GetSelectedNode().IsNotNull())
         {
           ItkFloatImageType::Pointer itkImg = ItkFloatImageType::New();
           mitk::CastToItkImage(dynamic_cast<mitk::Image*>(m_Controls->m_FaImageBox->GetSelectedNode()->GetData()), itkImg);
 
           dynamic_cast<mitk::TrackingHandlerTensor*>(m_TrackingHandler)->SetFaImage(itkImg);
         }
       }
 
       dynamic_cast<mitk::TrackingHandlerTensor*>(m_TrackingHandler)->SetFaThreshold(m_Controls->m_ScalarThresholdBox->value());
       dynamic_cast<mitk::TrackingHandlerTensor*>(m_TrackingHandler)->SetF((float)m_Controls->m_fBox->value());
       dynamic_cast<mitk::TrackingHandlerTensor*>(m_TrackingHandler)->SetG((float)m_Controls->m_gBox->value());
     }
   }
   else if ( dynamic_cast<mitk::OdfImage*>(m_InputImageNodes.at(0)->GetData()) )
   {
     if (m_TrackingHandler==nullptr)
     {
       m_TrackingHandler = new mitk::TrackingHandlerOdf();
       mitk::TrackingHandlerOdf::ItkOdfImageType::Pointer itkImg = mitk::TrackingHandlerOdf::ItkOdfImageType::New();
       mitk::CastToItkImage(m_InputImages.at(0), itkImg);
       dynamic_cast<mitk::TrackingHandlerOdf*>(m_TrackingHandler)->SetOdfImage(itkImg);
 
       if (m_Controls->m_FaImageBox->GetSelectedNode().IsNotNull())
       {
         ItkFloatImageType::Pointer itkImg = ItkFloatImageType::New();
         mitk::CastToItkImage(dynamic_cast<mitk::Image*>(m_Controls->m_FaImageBox->GetSelectedNode()->GetData()), itkImg);
         dynamic_cast<mitk::TrackingHandlerOdf*>(m_TrackingHandler)->SetGfaImage(itkImg);
       }
     }
 
     dynamic_cast<mitk::TrackingHandlerOdf*>(m_TrackingHandler)->SetGfaThreshold(m_Controls->m_ScalarThresholdBox->value());
     dynamic_cast<mitk::TrackingHandlerOdf*>(m_TrackingHandler)->SetOdfThreshold(m_Controls->m_OdfCutoffBox->value());
     dynamic_cast<mitk::TrackingHandlerOdf*>(m_TrackingHandler)->SetSharpenOdfs(m_Controls->m_SharpenOdfsBox->isChecked());
   }
   else if ( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image*>(m_InputImageNodes.at(0)->GetData())) )
   {
     if ( m_Controls->m_ForestBox->GetSelectedNode().IsNull() )
     {
       QMessageBox::information(nullptr, "Information", "Not random forest for machine learning based tractography (raw dMRI tractography) selected. Did you accidentally select the raw diffusion-weighted image in the datamanager?");
       StartStopTrackingGui(false);
       return;
     }
 
     if (m_TrackingHandler==nullptr)
     {
       mitk::TractographyForest::Pointer forest = dynamic_cast<mitk::TractographyForest*>(m_Controls->m_ForestBox->GetSelectedNode()->GetData());
       mitk::Image::Pointer dwi = dynamic_cast<mitk::Image*>(m_InputImageNodes.at(0)->GetData());
 
       std::vector< std::vector< ItkFloatImageType::Pointer > > additionalFeatureImages;
       additionalFeatureImages.push_back(std::vector< ItkFloatImageType::Pointer >());
       for (auto img : m_AdditionalInputImages)
       {
         ItkFloatImageType::Pointer itkimg = ItkFloatImageType::New();
         mitk::CastToItkImage(img, itkimg);
         additionalFeatureImages.at(0).push_back(itkimg);
       }
 
       bool forest_valid = false;
       if (forest->GetNumFeatures()>=100)
       {
         int num_previous_directions = (forest->GetNumFeatures() - (100 + additionalFeatureImages.at(0).size()))/3;
         m_TrackingHandler = new mitk::TrackingHandlerRandomForest<6, 100>();
         dynamic_cast<mitk::TrackingHandlerRandomForest<6, 100>*>(m_TrackingHandler)->AddDwi(dwi);
         dynamic_cast<mitk::TrackingHandlerRandomForest<6, 100>*>(m_TrackingHandler)->SetAdditionalFeatureImages(additionalFeatureImages);
         dynamic_cast<mitk::TrackingHandlerRandomForest<6, 100>*>(m_TrackingHandler)->SetForest(forest);
         dynamic_cast<mitk::TrackingHandlerRandomForest<6, 100>*>(m_TrackingHandler)->SetNumPreviousDirections(num_previous_directions);
         forest_valid = dynamic_cast<mitk::TrackingHandlerRandomForest<6, 100>*>(m_TrackingHandler)->IsForestValid();
       }
       else
       {
         int num_previous_directions = (forest->GetNumFeatures() - (28 + additionalFeatureImages.at(0).size()))/3;
         m_TrackingHandler = new mitk::TrackingHandlerRandomForest<6, 28>();
         dynamic_cast<mitk::TrackingHandlerRandomForest<6, 28>*>(m_TrackingHandler)->AddDwi(dwi);
         dynamic_cast<mitk::TrackingHandlerRandomForest<6, 28>*>(m_TrackingHandler)->SetAdditionalFeatureImages(additionalFeatureImages);
         dynamic_cast<mitk::TrackingHandlerRandomForest<6, 28>*>(m_TrackingHandler)->SetForest(forest);
         dynamic_cast<mitk::TrackingHandlerRandomForest<6, 28>*>(m_TrackingHandler)->SetNumPreviousDirections(num_previous_directions);
         forest_valid = dynamic_cast<mitk::TrackingHandlerRandomForest<6, 28>*>(m_TrackingHandler)->IsForestValid();
       }
 
       if (!forest_valid)
       {
         QMessageBox::information(nullptr, "Information", "Random forest is invalid. The forest signatue does not match the parameters of TrackingHandlerRandomForest.");
         StartStopTrackingGui(false);
         return;
       }
     }
   }
   else
   {
     if (m_Controls->m_ModeBox->currentIndex()==1)
     {
       QMessageBox::information(nullptr, "Information", "Probabilstic tractography is not implemented for peak images.");
       StartStopTrackingGui(false);
       return;
     }
     try {
 
       if (m_TrackingHandler==nullptr)
       {
         typedef mitk::ImageToItk< mitk::TrackingHandlerPeaks::PeakImgType > CasterType;
         CasterType::Pointer caster = CasterType::New();
         caster->SetInput(m_InputImages.at(0));
         caster->SetCopyMemFlag(true);
         caster->Update();
         mitk::TrackingHandlerPeaks::PeakImgType::Pointer itkImg = caster->GetOutput();
         m_TrackingHandler = new mitk::TrackingHandlerPeaks();
         dynamic_cast<mitk::TrackingHandlerPeaks*>(m_TrackingHandler)->SetPeakImage(itkImg);
       }
 
       dynamic_cast<mitk::TrackingHandlerPeaks*>(m_TrackingHandler)->SetPeakThreshold(m_Controls->m_ScalarThresholdBox->value());
     }
     catch(...)
     {
       QMessageBox::information(nullptr, "Error", "Peak tracker could not be initialized. Is your input image in the correct format (4D float image, peaks in the 4th dimension)?");
       StartStopTrackingGui(false);
       return;
     }
   }
 
   m_TrackingHandler->SetFlipX(m_Controls->m_FlipXBox->isChecked());
   m_TrackingHandler->SetFlipY(m_Controls->m_FlipYBox->isChecked());
   m_TrackingHandler->SetFlipZ(m_Controls->m_FlipZBox->isChecked());
   m_TrackingHandler->SetInterpolate(m_Controls->m_InterpolationBox->isChecked());
   switch (m_Controls->m_ModeBox->currentIndex())
   {
   case 0:
     m_TrackingHandler->SetMode(mitk::TrackingDataHandler::MODE::DETERMINISTIC);
     break;
   case 1:
     m_TrackingHandler->SetMode(mitk::TrackingDataHandler::MODE::PROBABILISTIC);
     break;
   default:
     m_TrackingHandler->SetMode(mitk::TrackingDataHandler::MODE::DETERMINISTIC);
   }
 
   if (m_Controls->m_InteractiveBox->isChecked())
   {
     m_Tracker->SetSeedPoints(m_SeedPoints);
   }
   else if (m_Controls->m_SeedImageBox->GetSelectedNode().IsNotNull())
   {
     ItkFloatImageType::Pointer mask = ItkFloatImageType::New();
     mitk::CastToItkImage(dynamic_cast<mitk::Image*>(m_Controls->m_SeedImageBox->GetSelectedNode()->GetData()), mask);
     m_Tracker->SetSeedImage(mask);
   }
 
   if (m_Controls->m_MaskImageBox->GetSelectedNode().IsNotNull())
   {
     ItkFloatImageType::Pointer mask = ItkFloatImageType::New();
     mitk::CastToItkImage(dynamic_cast<mitk::Image*>(m_Controls->m_MaskImageBox->GetSelectedNode()->GetData()), mask);
     m_Tracker->SetMaskImage(mask);
   }
 
   if (m_Controls->m_StopImageBox->GetSelectedNode().IsNotNull())
   {
     ItkFloatImageType::Pointer mask = ItkFloatImageType::New();
     mitk::CastToItkImage(dynamic_cast<mitk::Image*>(m_Controls->m_StopImageBox->GetSelectedNode()->GetData()), mask);
     m_Tracker->SetStoppingRegions(mask);
   }
 
   if (m_Controls->m_TargetImageBox->GetSelectedNode().IsNotNull())
   {
     ItkFloatImageType::Pointer mask = ItkFloatImageType::New();
     mitk::CastToItkImage(dynamic_cast<mitk::Image*>(m_Controls->m_TargetImageBox->GetSelectedNode()->GetData()), mask);
     m_Tracker->SetTargetRegions(mask);
   }
 
   if (m_Controls->m_PriorImageBox->GetSelectedNode().IsNotNull())
   {
     if (m_LastPrior!=m_Controls->m_PriorImageBox->GetSelectedNode()->GetUID() || m_TrackingPriorHandler==nullptr)
     {
       typedef mitk::ImageToItk< mitk::TrackingHandlerPeaks::PeakImgType > CasterType;
       CasterType::Pointer caster = CasterType::New();
       caster->SetInput(dynamic_cast<mitk::PeakImage*>(m_Controls->m_PriorImageBox->GetSelectedNode()->GetData()));
       caster->SetCopyMemFlag(true);
       caster->Update();
       mitk::TrackingHandlerPeaks::PeakImgType::Pointer itkImg = caster->GetOutput();
       m_TrackingPriorHandler = new mitk::TrackingHandlerPeaks();
       dynamic_cast<mitk::TrackingHandlerPeaks*>(m_TrackingPriorHandler)->SetPeakImage(itkImg);
       dynamic_cast<mitk::TrackingHandlerPeaks*>(m_TrackingPriorHandler)->SetPeakThreshold(0.0);
       m_LastPrior = m_Controls->m_PriorImageBox->GetSelectedNode()->GetUID();
     }
 
     m_TrackingPriorHandler->SetInterpolate(m_Controls->m_InterpolationBox->isChecked());
     m_TrackingPriorHandler->SetMode(mitk::TrackingDataHandler::MODE::DETERMINISTIC);
 
     m_Tracker->SetTrackingPriorHandler(m_TrackingPriorHandler);
     m_Tracker->SetTrackingPriorWeight(m_Controls->m_PriorWeightBox->value());
     m_Tracker->SetTrackingPriorAsMask(m_Controls->m_PriorAsMaskBox->isChecked());
     m_Tracker->SetIntroduceDirectionsFromPrior(m_Controls->m_NewDirectionsFromPriorBox->isChecked());
   }
   else if (m_Controls->m_PriorImageBox->GetSelectedNode().IsNull())
     m_Tracker->SetTrackingPriorHandler(nullptr);
 
   if (m_Controls->m_ExclusionImageBox->GetSelectedNode().IsNotNull())
   {
     ItkFloatImageType::Pointer mask = ItkFloatImageType::New();
     mitk::CastToItkImage(dynamic_cast<mitk::Image*>(m_Controls->m_ExclusionImageBox->GetSelectedNode()->GetData()), mask);
     m_Tracker->SetExclusionRegions(mask);
   }
 
   // Endpoint constraints
   switch (m_Controls->m_EpConstraintsBox->currentIndex())
   {
   case 0:
     m_Tracker->SetEndpointConstraint(itk::StreamlineTrackingFilter::EndpointConstraints::NONE);
     m_Tracker->SetTargetRegions(nullptr);
     break;
   case 1:
     m_Tracker->SetEndpointConstraint(itk::StreamlineTrackingFilter::EndpointConstraints::EPS_IN_TARGET);
     break;
   case 2:
     m_Tracker->SetEndpointConstraint(itk::StreamlineTrackingFilter::EndpointConstraints::EPS_IN_TARGET_LABELDIFF);
     break;
   case 3:
     m_Tracker->SetEndpointConstraint(itk::StreamlineTrackingFilter::EndpointConstraints::EPS_IN_SEED_AND_TARGET);
     break;
   case 4:
     m_Tracker->SetEndpointConstraint(itk::StreamlineTrackingFilter::EndpointConstraints::MIN_ONE_EP_IN_TARGET);
     break;
   case 5:
     m_Tracker->SetEndpointConstraint(itk::StreamlineTrackingFilter::EndpointConstraints::ONE_EP_IN_TARGET);
     break;
   case 6:
     m_Tracker->SetEndpointConstraint(itk::StreamlineTrackingFilter::EndpointConstraints::NO_EP_IN_TARGET);
     break;
   }
 
   if (m_Tracker->GetEndpointConstraint()!=itk::StreamlineTrackingFilter::EndpointConstraints::NONE && m_Controls->m_TargetImageBox->GetSelectedNode().IsNull())
   {
     QMessageBox::information(nullptr, "Error", "Endpoint constraints are used but no target image is set!");
     StartStopTrackingGui(false);
     return;
   }
   else if (m_Tracker->GetEndpointConstraint()==itk::StreamlineTrackingFilter::EndpointConstraints::EPS_IN_SEED_AND_TARGET
            && (m_Controls->m_SeedImageBox->GetSelectedNode().IsNull()|| m_Controls->m_TargetImageBox->GetSelectedNode().IsNull()) )
   {
     QMessageBox::information(nullptr, "Error", "Endpoint constraint EPS_IN_SEED_AND_TARGET is used but no target or no seed image is set!");
     StartStopTrackingGui(false);
     return;
   }
 
   m_Tracker->SetInterpolateMasks(m_Controls->m_MaskInterpolationBox->isChecked());
   m_Tracker->SetVerbose(!m_Controls->m_InteractiveBox->isChecked());
   m_Tracker->SetSeedsPerVoxel(m_Controls->m_SeedsPerVoxelBox->value());
   m_Tracker->SetStepSize(m_Controls->m_StepSizeBox->value());
   m_Tracker->SetSamplingDistance(m_Controls->m_SamplingDistanceBox->value());
   m_Tracker->SetUseStopVotes(m_Controls->m_StopVotesBox->isChecked());
   m_Tracker->SetOnlyForwardSamples(m_Controls->m_FrontalSamplesBox->isChecked());
   m_Tracker->SetTrialsPerSeed(m_Controls->m_TrialsPerSeedBox->value());
   m_Tracker->SetMaxNumTracts(m_Controls->m_NumFibersBox->value());
   m_Tracker->SetNumberOfSamples(m_Controls->m_NumSamplesBox->value());
   m_Tracker->SetTrackingHandler(m_TrackingHandler);
   m_Tracker->SetLoopCheck(m_Controls->m_LoopCheckBox->value());
   m_Tracker->SetAngularThreshold(m_Controls->m_AngularThresholdBox->value());
   m_Tracker->SetMinTractLength(m_Controls->m_MinTractLengthBox->value());
   m_Tracker->SetUseOutputProbabilityMap(m_Controls->m_OutputProbMap->isChecked());
 
   m_ParentNode = m_InputImageNodes.at(0);
   m_TrackingThread.start(QThread::LowestPriority);
 }