diff --git a/Modules/DiffusionCmdApps/Tractography/StreamlineTractography.cpp b/Modules/DiffusionCmdApps/Tractography/StreamlineTractography.cpp
index d25f851..346123c 100644
--- a/Modules/DiffusionCmdApps/Tractography/StreamlineTractography.cpp
+++ b/Modules/DiffusionCmdApps/Tractography/StreamlineTractography.cpp
@@ -1,582 +1,582 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center.
 
 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 <mitkDiffusionCommandLineParser.h>
 #include <mitkLog.h>
 #include <usAny.h>
 #include <mitkIOUtil.h>
 #include <iostream>
 #include <fstream>
 #include <itksys/SystemTools.hxx>
 #include <mitkCoreObjectFactory.h>
 #include <itksys/SystemTools.hxx>
 
 #include <mitkFiberBundle.h>
 #include <itkStreamlineTrackingFilter.h>
 #include <Algorithms/TrackingHandlers/mitkTrackingDataHandler.h>
 #include <Algorithms/TrackingHandlers/mitkTrackingHandlerRandomForest.h>
 #include <Algorithms/TrackingHandlers/mitkTrackingHandlerPeaks.h>
 #include <Algorithms/TrackingHandlers/mitkTrackingHandlerTensor.h>
 #include <Algorithms/TrackingHandlers/mitkTrackingHandlerOdf.h>
 #include <itkTensorImageToOdfImageFilter.h>
 #include <mitkTractographyForest.h>
 #include <mitkPreferenceListReaderOptionsFunctor.h>
 #include <mitkStreamlineTractographyParameters.h>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 const int numOdfSamples = 200;
 typedef itk::Image< itk::Vector< float, numOdfSamples > , 3 > SampledShImageType;
 
 /*!
 \brief
 */
 int main(int argc, char* argv[])
 {
   mitkDiffusionCommandLineParser parser;
 
   parser.setTitle("Streamline Tractography");
   parser.setCategory("Fiber Tracking and Processing Methods");
   parser.setDescription("Perform streamline tractography");
   parser.setContributor("MIC");
 
   // parameters fo all methods
   parser.setArgumentPrefix("--", "-");
 
   parser.beginGroup("1. Mandatory arguments:");
   parser.addArgument("", "i", mitkDiffusionCommandLineParser::StringList, "Input:", "input image (multiple possible for 'DetTensor' algorithm)", us::Any(), false, false, false, mitkDiffusionCommandLineParser::Input);
   parser.addArgument("", "o", mitkDiffusionCommandLineParser::String, "Output:", "output fiberbundle/probability map", us::Any(), false, false, false, mitkDiffusionCommandLineParser::Output);
   parser.addArgument("type", "", mitkDiffusionCommandLineParser::String, "Type:", "which tracker to use (Peaks; Tensor; ODF; ODF-DIPY/FSL; RF)", us::Any(), false);
   parser.addArgument("probabilistic", "", mitkDiffusionCommandLineParser::Bool, "Probabilistic:", "Probabilistic tractography", us::Any(false));
   parser.endGroup();
 
   parser.beginGroup("2. Seeding:");
   parser.addArgument("seeds", "", mitkDiffusionCommandLineParser::Int, "Seeds per voxel:", "number of seed points per voxel", 1);
   parser.addArgument("seed_image", "", mitkDiffusionCommandLineParser::String, "Seed image:", "mask image defining seed voxels", us::Any(), true, false, false, mitkDiffusionCommandLineParser::Input);
   parser.addArgument("trials_per_seed", "", mitkDiffusionCommandLineParser::Int, "Max. trials per seed:", "try each seed N times until a valid streamline is obtained (only for probabilistic tractography)", 10);
   parser.addArgument("max_tracts", "", mitkDiffusionCommandLineParser::Int, "Max. number of tracts:", "tractography is stopped if the reconstructed number of tracts is exceeded", -1);
   parser.endGroup();
 
   parser.beginGroup("3. Tractography constraints:");
   parser.addArgument("tracking_mask", "", mitkDiffusionCommandLineParser::String, "Mask image:", "streamlines leaving the mask will stop immediately", us::Any(), true, false, false, mitkDiffusionCommandLineParser::Input);
   parser.addArgument("stop_image", "", mitkDiffusionCommandLineParser::String, "Stop ROI image:", "streamlines entering the mask will stop immediately", us::Any(), true, false, false, mitkDiffusionCommandLineParser::Input);
   parser.addArgument("exclusion_image", "", mitkDiffusionCommandLineParser::String, "Exclusion ROI image:", "streamlines entering the mask will be discarded", us::Any(), true, false, false, mitkDiffusionCommandLineParser::Input);
   parser.addArgument("ep_constraint", "", mitkDiffusionCommandLineParser::String, "Endpoint constraint:", "determines which fibers are accepted based on their endpoint location - options are NONE, EPS_IN_TARGET, EPS_IN_TARGET_LABELDIFF, EPS_IN_SEED_AND_TARGET, MIN_ONE_EP_IN_TARGET, ONE_EP_IN_TARGET and NO_EP_IN_TARGET", us::Any());
   parser.addArgument("target_image", "", mitkDiffusionCommandLineParser::String, "Target ROI image:", "effact depends on the chosen endpoint constraint (option ep_constraint)", us::Any(), true, false, false, mitkDiffusionCommandLineParser::Input);
   parser.endGroup();
 
   parser.beginGroup("4. Streamline integration parameters:");
-  parser.addArgument("sharpen_odfs", "", mitkDiffusionCommandLineParser::Bool, "SHarpen ODFs:", "if you are using dODF images as input, it is advisable to sharpen the ODFs (min-max normalize and raise to the power of 4). this is not necessary for CSD fODFs, since they are narurally much sharper.");
+  parser.addArgument("sharpen_odfs", "", mitkDiffusionCommandLineParser::Int, "Sharpen ODFs:", "if you are using dODF images as input, it is advisable to sharpen the ODFs (power of X). this is not necessary for CSD fODFs, since they are narurally much sharper.");
   parser.addArgument("cutoff", "", mitkDiffusionCommandLineParser::Float, "Cutoff:", "set the FA, GFA or Peak amplitude cutoff for terminating tracks", 0.1);
   parser.addArgument("odf_cutoff", "", mitkDiffusionCommandLineParser::Float, "ODF Cutoff:", "threshold on the ODF magnitude. this is useful in case of CSD fODF tractography.", 0.0);
   parser.addArgument("step_size", "", mitkDiffusionCommandLineParser::Float, "Step size:", "step size (in voxels)", 0.5);
   parser.addArgument("min_tract_length", "", mitkDiffusionCommandLineParser::Float, "Min. tract length:", "minimum fiber length (in mm)", 20);
   parser.addArgument("angular_threshold", "", mitkDiffusionCommandLineParser::Float, "Angular threshold:", "angular threshold between two successive steps, (default: 90° * step_size, minimum 15°)");
   parser.addArgument("loop_check", "", mitkDiffusionCommandLineParser::Float, "Check for loops:", "threshold on angular stdev over the last 4 voxel lengths");
   parser.addArgument("peak_jitter", "", mitkDiffusionCommandLineParser::Float, "Peak jitter:", "important for probabilistic peak tractography and peak prior. actual jitter is drawn from a normal distribution with peak_jitter*fabs(direction_value) as standard deviation.", 0.01);
   parser.endGroup();
 
   parser.beginGroup("5. Tractography prior:");
   parser.addArgument("prior_image", "", mitkDiffusionCommandLineParser::String, "Peak prior:", "tractography prior in thr for of a peak image", us::Any(), true, false, false, mitkDiffusionCommandLineParser::Input);
   parser.addArgument("prior_weight", "", mitkDiffusionCommandLineParser::Float, "Prior weight", "weighting factor between prior and data.", 0.5);
   parser.addArgument("dont_restrict_to_prior", "", mitkDiffusionCommandLineParser::Bool, "Don't restrict to prior:", "don't restrict tractography to regions where the prior is valid.", us::Any(false));
   parser.addArgument("no_new_directions_from_prior", "", mitkDiffusionCommandLineParser::Bool, "No new directios from prior:", "the prior cannot create directions where there are none in the data.", us::Any(false));
   parser.addArgument("prior_flip_x", "", mitkDiffusionCommandLineParser::Bool, "Prior Flip X:", "multiply x-coordinate of prior direction by -1");
   parser.addArgument("prior_flip_y", "", mitkDiffusionCommandLineParser::Bool, "Prior Flip Y:", "multiply y-coordinate of prior direction by -1");
   parser.addArgument("prior_flip_z", "", mitkDiffusionCommandLineParser::Bool, "Prior Flip Z:", "multiply z-coordinate of prior direction by -1");
   parser.endGroup();
 
   parser.beginGroup("6. Neighborhood sampling:");
   parser.addArgument("num_samples", "", mitkDiffusionCommandLineParser::Int, "Num. neighborhood samples:", "number of neighborhood samples that are use to determine the next progression direction", 0);
   parser.addArgument("sampling_distance", "", mitkDiffusionCommandLineParser::Float, "Sampling distance:", "distance of neighborhood sampling points (in voxels)", 0.25);
   parser.addArgument("use_stop_votes", "", mitkDiffusionCommandLineParser::Bool, "Use stop votes:", "use stop votes");
   parser.addArgument("use_only_forward_samples", "", mitkDiffusionCommandLineParser::Bool, "Use only forward samples:", "use only forward samples");
   parser.endGroup();
 
   parser.beginGroup("7. Tensor tractography specific:");
   parser.addArgument("tend_f", "", mitkDiffusionCommandLineParser::Float, "Weight f", "weighting factor between first eigenvector (f=1 equals FACT tracking) and input vector dependent direction (f=0).", 1.0);
   parser.addArgument("tend_g", "", mitkDiffusionCommandLineParser::Float, "Weight g", "weighting factor between input vector (g=0) and tensor deflection (g=1 equals TEND tracking)", 0.0);
   parser.endGroup();
 
   parser.beginGroup("8. Random forest tractography specific:");
   parser.addArgument("forest", "", mitkDiffusionCommandLineParser::String, "Forest:", "input random forest (HDF5 file)", us::Any(), true, false, false, mitkDiffusionCommandLineParser::Input);
   parser.addArgument("use_sh_features", "", mitkDiffusionCommandLineParser::Bool, "Use SH features:", "use SH features");
   parser.endGroup();
 
   parser.beginGroup("9. Additional input:");
   parser.addArgument("additional_images", "", mitkDiffusionCommandLineParser::StringList, "Additional images:", "specify a list of float images that hold additional information (FA, GFA, additional features for RF tractography)", us::Any(), true, false, false, mitkDiffusionCommandLineParser::Input);
   parser.endGroup();
 
   parser.beginGroup("10. Misc:");
   parser.addArgument("flip_x", "", mitkDiffusionCommandLineParser::Bool, "Flip X:", "multiply x-coordinate of direction proposal by -1");
   parser.addArgument("flip_y", "", mitkDiffusionCommandLineParser::Bool, "Flip Y:", "multiply y-coordinate of direction proposal by -1");
   parser.addArgument("flip_z", "", mitkDiffusionCommandLineParser::Bool, "Flip Z:", "multiply z-coordinate of direction proposal by -1");
   parser.addArgument("no_data_interpolation", "", mitkDiffusionCommandLineParser::Bool, "Don't interpolate input data:", "don't interpolate input image values");
   parser.addArgument("no_mask_interpolation", "", mitkDiffusionCommandLineParser::Bool, "Don't interpolate masks:", "don't interpolate mask image values");
   parser.addArgument("compress", "", mitkDiffusionCommandLineParser::Bool, "Compress:", "compress output fibers (lossy)");
   parser.addArgument("fix_seed", "", mitkDiffusionCommandLineParser::Bool, "Fix Random Seed:", "always use the same random numbers");
   parser.addArgument("parameter_file", "", mitkDiffusionCommandLineParser::String, "Parameter File:", "load parameters from json file (svae using MITK Diffusion GUI). the parameters loaded form this file are overwritten by the manually set parameters.", us::Any(), true, false, false, mitkDiffusionCommandLineParser::Input);
   parser.endGroup();
 
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0)
     return EXIT_FAILURE;
 
   mitkDiffusionCommandLineParser::StringContainerType input_files = us::any_cast<mitkDiffusionCommandLineParser::StringContainerType>(parsedArgs["i"]);
   std::string outFile = us::any_cast<std::string>(parsedArgs["o"]);
   std::string type = us::any_cast<std::string>(parsedArgs["type"]);
 
   std::shared_ptr< mitk::StreamlineTractographyParameters > params = std::make_shared<mitk::StreamlineTractographyParameters>();
 
   if (parsedArgs.count("parameter_file"))
   {
     auto parameter_file = us::any_cast<std::string>(parsedArgs["parameter_file"]);
     params->LoadParameters(parameter_file);
   }
 
   if (parsedArgs.count("probabilistic"))
     params->m_Mode = mitk::StreamlineTractographyParameters::MODE::PROBABILISTIC;
   else {
     params->m_Mode = mitk::StreamlineTractographyParameters::MODE::DETERMINISTIC;
   }
 
   std::string prior_image = "";
   if (parsedArgs.count("prior_image"))
     prior_image = us::any_cast<std::string>(parsedArgs["prior_image"]);
 
   if (parsedArgs.count("prior_weight"))
     params->m_Weight = us::any_cast<float>(parsedArgs["prior_weight"]);
 
   if (parsedArgs.count("fix_seed"))
     params->m_FixRandomSeed = us::any_cast<bool>(parsedArgs["fix_seed"]);
 
   if (parsedArgs.count("dont_restrict_to_prior"))
     params->m_RestrictToPrior = !us::any_cast<bool>(parsedArgs["dont_restrict_to_prior"]);
 
   if (parsedArgs.count("no_new_directions_from_prior"))
     params->m_NewDirectionsFromPrior = !us::any_cast<bool>(parsedArgs["no_new_directions_from_prior"]);
 
   if (parsedArgs.count("sharpen_odfs"))
-    params->m_SharpenOdfs = us::any_cast<bool>(parsedArgs["sharpen_odfs"]);
+    params->m_SharpenOdfs = us::any_cast<int>(parsedArgs["sharpen_odfs"]);
 
   if (parsedArgs.count("no_data_interpolation"))
     params->m_InterpolateTractographyData = !us::any_cast<bool>(parsedArgs["no_data_interpolation"]);
 
   params->m_InterpolateRoiImages = true;
   if (parsedArgs.count("no_mask_interpolation"))
     params->m_InterpolateRoiImages = !us::any_cast<bool>(parsedArgs["no_mask_interpolation"]);
 
   bool use_sh_features = false;
   if (parsedArgs.count("use_sh_features"))
     use_sh_features = us::any_cast<bool>(parsedArgs["use_sh_features"]);
 
   if (parsedArgs.count("use_stop_votes"))
     params->m_StopVotes = us::any_cast<bool>(parsedArgs["use_stop_votes"]);
 
   if (parsedArgs.count("use_only_forward_samples"))
     params->m_OnlyForwardSamples = us::any_cast<bool>(parsedArgs["use_only_forward_samples"]);
 
   if (parsedArgs.count("flip_x"))
     params->m_FlipX = us::any_cast<bool>(parsedArgs["flip_x"]);
   if (parsedArgs.count("flip_y"))
     params->m_FlipY = us::any_cast<bool>(parsedArgs["flip_y"]);
   if (parsedArgs.count("flip_z"))
     params->m_FlipZ = us::any_cast<bool>(parsedArgs["flip_z"]);
 
   if (parsedArgs.count("prior_flip_x"))
     params->m_PriorFlipX = us::any_cast<bool>(parsedArgs["prior_flip_x"]);
   if (parsedArgs.count("prior_flip_y"))
     params->m_PriorFlipY = us::any_cast<bool>(parsedArgs["prior_flip_y"]);
   if (parsedArgs.count("prior_flip_z"))
     params->m_PriorFlipZ = us::any_cast<bool>(parsedArgs["prior_flip_z"]);
 
   if (parsedArgs.count("apply_image_rotation"))
     params->m_ApplyDirectionMatrix = us::any_cast<bool>(parsedArgs["apply_image_rotation"]);
 
   if (parsedArgs.count("compress"))
     params->m_CompressFibers = us::any_cast<bool>(parsedArgs["compress"]);
 
   if (parsedArgs.count("min_tract_length"))
     params->m_MinTractLengthMm = us::any_cast<float>(parsedArgs["min_tract_length"]);
 
   if (parsedArgs.count("loop_check"))
     params->SetLoopCheckDeg(us::any_cast<float>(parsedArgs["loop_check"]));
 
   std::string forestFile;
   if (parsedArgs.count("forest"))
     forestFile = us::any_cast<std::string>(parsedArgs["forest"]);
 
   std::string maskFile = "";
   if (parsedArgs.count("tracking_mask"))
     maskFile = us::any_cast<std::string>(parsedArgs["tracking_mask"]);
 
   std::string seedFile = "";
   if (parsedArgs.count("seed_image"))
     seedFile = us::any_cast<std::string>(parsedArgs["seed_image"]);
 
   std::string targetFile = "";
   if (parsedArgs.count("target_image"))
     targetFile = us::any_cast<std::string>(parsedArgs["target_image"]);
 
   std::string exclusionFile = "";
   if (parsedArgs.count("exclusion_image"))
     exclusionFile = us::any_cast<std::string>(parsedArgs["exclusion_image"]);
 
   std::string stopFile = "";
   if (parsedArgs.count("stop_image"))
     stopFile = us::any_cast<std::string>(parsedArgs["stop_image"]);
 
   if (parsedArgs.count("ep_constraint"))
   {
     if (us::any_cast<std::string>(parsedArgs["ep_constraint"]) == "NONE")
       params->m_EpConstraints = mitk::StreamlineTractographyParameters::EndpointConstraints::NONE;
     else if (us::any_cast<std::string>(parsedArgs["ep_constraint"]) == "EPS_IN_TARGET")
       params->m_EpConstraints = mitk::StreamlineTractographyParameters::EndpointConstraints::EPS_IN_TARGET;
     else if (us::any_cast<std::string>(parsedArgs["ep_constraint"]) == "EPS_IN_TARGET_LABELDIFF")
       params->m_EpConstraints = mitk::StreamlineTractographyParameters::EndpointConstraints::EPS_IN_TARGET_LABELDIFF;
     else if (us::any_cast<std::string>(parsedArgs["ep_constraint"]) == "EPS_IN_SEED_AND_TARGET")
       params->m_EpConstraints = mitk::StreamlineTractographyParameters::EndpointConstraints::EPS_IN_SEED_AND_TARGET;
     else if (us::any_cast<std::string>(parsedArgs["ep_constraint"]) == "MIN_ONE_EP_IN_TARGET")
       params->m_EpConstraints = mitk::StreamlineTractographyParameters::EndpointConstraints::MIN_ONE_EP_IN_TARGET;
     else if (us::any_cast<std::string>(parsedArgs["ep_constraint"]) == "ONE_EP_IN_TARGET")
       params->m_EpConstraints = mitk::StreamlineTractographyParameters::EndpointConstraints::ONE_EP_IN_TARGET;
     else if (us::any_cast<std::string>(parsedArgs["ep_constraint"]) == "NO_EP_IN_TARGET")
       params->m_EpConstraints = mitk::StreamlineTractographyParameters::EndpointConstraints::NO_EP_IN_TARGET;
   }
 
   if (parsedArgs.count("cutoff"))
     params->m_Cutoff = us::any_cast<float>(parsedArgs["cutoff"]);
 
   if (parsedArgs.count("odf_cutoff"))
     params->m_OdfCutoff = us::any_cast<float>(parsedArgs["odf_cutoff"]);
 
   if (parsedArgs.count("peak_jitter"))
     params->m_PeakJitter = us::any_cast<float>(parsedArgs["peak_jitter"]);
 
   if (parsedArgs.count("step_size"))
     params->SetStepSizeVox(us::any_cast<float>(parsedArgs["step_size"]));
 
   if (parsedArgs.count("sampling_distance"))
     params->SetSamplingDistanceVox(us::any_cast<float>(parsedArgs["sampling_distance"]));
 
   if (parsedArgs.count("num_samples"))
     params->m_NumSamples = static_cast<unsigned int>(us::any_cast<int>(parsedArgs["num_samples"]));
 
   if (parsedArgs.count("seeds"))
     params->m_SeedsPerVoxel = us::any_cast<int>(parsedArgs["seeds"]);
 
   if (parsedArgs.count("trials_per_seed"))
     params->m_TrialsPerSeed = static_cast<unsigned int>(us::any_cast<int>(parsedArgs["trials_per_seed"]));
 
   if (parsedArgs.count("tend_f"))
     params->m_F = us::any_cast<float>(parsedArgs["tend_f"]);
 
   if (parsedArgs.count("tend_g"))
     params->m_G = us::any_cast<float>(parsedArgs["tend_g"]);
 
   if (parsedArgs.count("angular_threshold"))
     params->SetAngularThresholdDeg(us::any_cast<float>(parsedArgs["angular_threshold"]));
 
   if (parsedArgs.count("max_tracts"))
     params->m_MaxNumFibers = us::any_cast<int>(parsedArgs["max_tracts"]);
 
 
   std::string ext = itksys::SystemTools::GetFilenameExtension(outFile);
   if (ext != ".fib" && ext != ".trk")
   {
     MITK_INFO << "Output file format not supported. Use one of .fib, .trk, .nii, .nii.gz, .nrrd";
     return EXIT_FAILURE;
   }
 
   // LOAD DATASETS
   mitkDiffusionCommandLineParser::StringContainerType addFiles;
   if (parsedArgs.count("additional_images"))
     addFiles = us::any_cast<mitkDiffusionCommandLineParser::StringContainerType>(parsedArgs["additional_images"]);
 
   typedef itk::Image<float, 3> ItkFloatImgType;
 
   ItkFloatImgType::Pointer mask = nullptr;
   if (!maskFile.empty())
   {
     MITK_INFO << "loading mask image";
     mitk::Image::Pointer img = mitk::IOUtil::Load<mitk::Image>(maskFile);
     mask = ItkFloatImgType::New();
     mitk::CastToItkImage(img, mask);
   }
 
   ItkFloatImgType::Pointer seed = nullptr;
   if (!seedFile.empty())
   {
     MITK_INFO << "loading seed ROI image";
     mitk::Image::Pointer img = mitk::IOUtil::Load<mitk::Image>(seedFile);
     seed = ItkFloatImgType::New();
     mitk::CastToItkImage(img, seed);
   }
 
   ItkFloatImgType::Pointer stop = nullptr;
   if (!stopFile.empty())
   {
     MITK_INFO << "loading stop ROI image";
     mitk::Image::Pointer img = mitk::IOUtil::Load<mitk::Image>(stopFile);
     stop = ItkFloatImgType::New();
     mitk::CastToItkImage(img, stop);
   }
 
   ItkFloatImgType::Pointer target = nullptr;
   if (!targetFile.empty())
   {
     MITK_INFO << "loading target ROI image";
     mitk::Image::Pointer img = mitk::IOUtil::Load<mitk::Image>(targetFile);
     target = ItkFloatImgType::New();
     mitk::CastToItkImage(img, target);
   }
 
   ItkFloatImgType::Pointer exclusion = nullptr;
   if (!exclusionFile.empty())
   {
     MITK_INFO << "loading exclusion ROI image";
     mitk::Image::Pointer img = mitk::IOUtil::Load<mitk::Image>(exclusionFile);
     exclusion = ItkFloatImgType::New();
     mitk::CastToItkImage(img, exclusion);
   }
 
   MITK_INFO << "loading additional images";
   std::vector< std::vector< ItkFloatImgType::Pointer > > addImages;
   addImages.push_back(std::vector< ItkFloatImgType::Pointer >());
   for (auto file : addFiles)
   {
     mitk::Image::Pointer img = mitk::IOUtil::Load<mitk::Image>(file);
     ItkFloatImgType::Pointer itkimg = ItkFloatImgType::New();
     mitk::CastToItkImage(img, itkimg);
     addImages.at(0).push_back(itkimg);
   }
 
   //    //////////////////////////////////////////////////////////////////
   //      omp_set_num_threads(1);
 
   typedef itk::StreamlineTrackingFilter TrackerType;
   TrackerType::Pointer tracker = TrackerType::New();
 
   if (!prior_image.empty())
   {
     mitk::PreferenceListReaderOptionsFunctor functor = mitk::PreferenceListReaderOptionsFunctor({"Peak Image"}, std::vector<std::string>());
     mitk::PeakImage::Pointer priorImage = mitk::IOUtil::Load<mitk::PeakImage>(prior_image, &functor);
 
     if (priorImage.IsNull())
     {
       MITK_INFO << "Only peak images are supported as prior at the moment!";
       return EXIT_FAILURE;
     }
 
     mitk::TrackingDataHandler* priorhandler = new mitk::TrackingHandlerPeaks();
 
     typedef mitk::ImageToItk< mitk::TrackingHandlerPeaks::PeakImgType > CasterType;
     CasterType::Pointer caster = CasterType::New();
     caster->SetInput(priorImage);
     caster->Update();
     mitk::TrackingHandlerPeaks::PeakImgType::Pointer itkImg = caster->GetOutput();
 
     std::shared_ptr< mitk::StreamlineTractographyParameters > prior_params = std::make_shared< mitk::StreamlineTractographyParameters >(*params);
     prior_params->m_FlipX = params->m_PriorFlipX;
     prior_params->m_FlipY = params->m_PriorFlipY;
     prior_params->m_FlipZ = params->m_PriorFlipZ;
     prior_params->m_Cutoff = 0.0;
     dynamic_cast<mitk::TrackingHandlerPeaks*>(priorhandler)->SetPeakImage(itkImg);
     priorhandler->SetParameters(prior_params);
     tracker->SetTrackingPriorHandler(priorhandler);
   }
 
   mitk::TrackingDataHandler* handler;
   mitk::Image::Pointer reference_image;
   if (type == "RF")
   {
     mitk::TractographyForest::Pointer forest = mitk::IOUtil::Load<mitk::TractographyForest>(forestFile);
     if (forest.IsNull())
       mitkThrow() << "Forest file " << forestFile << " could not be read.";
 
     std::vector<std::string> include = {"Diffusion Weighted Images"};
     std::vector<std::string> exclude = {};
     mitk::PreferenceListReaderOptionsFunctor functor = mitk::PreferenceListReaderOptionsFunctor(include, exclude);
     auto input = mitk::IOUtil::Load<mitk::Image>(input_files.at(0), &functor);
     reference_image = input;
 
     if (use_sh_features)
     {
       handler = new mitk::TrackingHandlerRandomForest<6,28>();
       dynamic_cast<mitk::TrackingHandlerRandomForest<6,28>*>(handler)->SetForest(forest);
       dynamic_cast<mitk::TrackingHandlerRandomForest<6,28>*>(handler)->AddDwi(input);
       dynamic_cast<mitk::TrackingHandlerRandomForest<6,28>*>(handler)->SetAdditionalFeatureImages(addImages);
     }
     else
     {
       handler = new mitk::TrackingHandlerRandomForest<6,100>();
       dynamic_cast<mitk::TrackingHandlerRandomForest<6,100>*>(handler)->SetForest(forest);
       dynamic_cast<mitk::TrackingHandlerRandomForest<6,100>*>(handler)->AddDwi(input);
       dynamic_cast<mitk::TrackingHandlerRandomForest<6,100>*>(handler)->SetAdditionalFeatureImages(addImages);
     }
   }
   else if (type == "Peaks")
   {
     handler = new mitk::TrackingHandlerPeaks();
 
     MITK_INFO << "loading input peak image";
     mitk::Image::Pointer mitkImage = mitk::IOUtil::Load<mitk::Image>(input_files.at(0));
     reference_image = mitkImage;
     mitk::TrackingHandlerPeaks::PeakImgType::Pointer itkImg = mitk::convert::GetItkPeakFromPeakImage(mitkImage);
     dynamic_cast<mitk::TrackingHandlerPeaks*>(handler)->SetPeakImage(itkImg);
   }
   else if (type == "Tensor" && params->m_Mode == mitk::StreamlineTractographyParameters::MODE::DETERMINISTIC)
   {
     handler = new mitk::TrackingHandlerTensor();
 
     MITK_INFO << "loading input tensor images";
     std::vector< mitk::Image::Pointer > input_images;
     for (unsigned int i=0; i<input_files.size(); i++)
     {
       mitk::Image::Pointer mitkImage = mitk::IOUtil::Load<mitk::Image>(input_files.at(i));
       reference_image = mitkImage;
       mitk::TensorImage::ItkTensorImageType::Pointer itkImg = mitk::convert::GetItkTensorFromTensorImage(mitkImage);
       dynamic_cast<mitk::TrackingHandlerTensor*>(handler)->AddTensorImage(itkImg.GetPointer());
     }
 
     if (addImages.at(0).size()>0)
       dynamic_cast<mitk::TrackingHandlerTensor*>(handler)->SetFaImage(addImages.at(0).at(0));
   }
   else if (type == "ODF" || type == "ODF-DIPY/FSL" || (type == "Tensor" && params->m_Mode == mitk::StreamlineTractographyParameters::MODE::PROBABILISTIC))
   {
     handler = new mitk::TrackingHandlerOdf();
 
     mitk::OdfImage::ItkOdfImageType::Pointer itkImg = nullptr;
 
     if (type == "Tensor")
     {
       MITK_INFO << "Converting Tensor to ODF image";
       auto input = mitk::IOUtil::Load<mitk::Image>(input_files.at(0));
       reference_image = input;
       itkImg = mitk::convert::GetItkOdfFromTensorImage(input);
       dynamic_cast<mitk::TrackingHandlerOdf*>(handler)->SetIsOdfFromTensor(true);
     }
     else
     {
       std::vector<std::string> include = {"SH Image", "ODF Image"};
       std::vector<std::string> exclude = {};
       mitk::PreferenceListReaderOptionsFunctor functor = mitk::PreferenceListReaderOptionsFunctor(include, exclude);
       auto input = mitk::IOUtil::Load(input_files.at(0), &functor)[0];
       reference_image = dynamic_cast<mitk::Image*>(input.GetPointer());
       if (dynamic_cast<mitk::ShImage*>(input.GetPointer()))
       {
         MITK_INFO << "Converting SH to ODF image";
         mitk::ShImage::Pointer mitkShImage = dynamic_cast<mitk::ShImage*>(input.GetPointer());
         if (type == "ODF-DIPY/FSL")
           mitkShImage->SetShConvention(mitk::ShImage::SH_CONVENTION::FSL);
         mitk::Image::Pointer mitkImg = dynamic_cast<mitk::Image*>(mitkShImage.GetPointer());
         itkImg = mitk::convert::GetItkOdfFromShImage(mitkImg);
       }
       else if (dynamic_cast<mitk::OdfImage*>(input.GetPointer()))
       {
         mitk::Image::Pointer mitkImg = dynamic_cast<mitk::Image*>(input.GetPointer());
         itkImg = mitk::convert::GetItkOdfFromOdfImage(mitkImg);
       }
       else
         mitkThrow() << "";
     }
 
     dynamic_cast<mitk::TrackingHandlerOdf*>(handler)->SetOdfImage(itkImg);
 
     if (addImages.at(0).size()>0)
       dynamic_cast<mitk::TrackingHandlerOdf*>(handler)->SetGfaImage(addImages.at(0).at(0));
   }
   else
   {
     MITK_INFO << "Unknown tractography algorithm (" + type+"). Known types are Peaks, DetTensor, ProbTensor, DetODF, ProbODF, DetRF, ProbRF.";
     return EXIT_FAILURE;
   }
 
   float max_size = 0;
   for (int i=0; i<3; ++i)
     if (reference_image->GetGeometry()->GetExtentInMM(i)>max_size)
       max_size = reference_image->GetGeometry()->GetExtentInMM(i);
   if (params->m_MinTractLengthMm >= max_size)
   {
     MITK_INFO << "Max. image size: " << max_size << "mm";
     MITK_INFO << "Min. tract length: " << params->m_MinTractLengthMm << "mm";
     MITK_ERROR << "Minimum tract length exceeds the maximum image extent! Recommended value is about 1/10 of the image extent.";
     return EXIT_FAILURE;
   }
   else if (params->m_MinTractLengthMm > max_size/10)
   {
     MITK_INFO << "Max. image size: " << max_size << "mm";
     MITK_INFO << "Min. tract length: " << params->m_MinTractLengthMm << "mm";
     MITK_WARN <<  "Minimum tract length is larger than 1/10 the maximum image extent! Decrease recommended.";
   }
 
   MITK_INFO << "Tractography algorithm: " << type;
   tracker->SetMaskImage(mask);
   tracker->SetSeedImage(seed);
   tracker->SetStoppingRegions(stop);
   tracker->SetTargetRegions(target);
   tracker->SetExclusionRegions(exclusion);
   tracker->SetTrackingHandler(handler);
   if (ext != ".fib" && ext != ".trk")
     params->m_OutputProbMap = true;
   tracker->SetParameters(params);
   tracker->Update();
 
   if (ext == ".fib" || ext == ".trk")
   {
 
     vtkSmartPointer< vtkPolyData > poly = tracker->GetFiberPolyData();
     mitk::FiberBundle::Pointer outFib = mitk::FiberBundle::New(poly);
     if (params->m_CompressFibers)
     {
       float min_sp = 999;
       auto spacing = handler->GetSpacing();
       if (spacing[0] < min_sp)
         min_sp = spacing[0];
       if (spacing[1] < min_sp)
         min_sp = spacing[1];
       if (spacing[2] < min_sp)
         min_sp = spacing[2];
       params->m_Compression = min_sp/10;
 
       outFib->Compress(params->m_Compression);
     }
     outFib->SetTrackVisHeader(reference_image->GetGeometry());
 
     mitk::IOUtil::Save(outFib, outFile);
   }
   else
   {
     TrackerType::ItkDoubleImgType::Pointer outImg = tracker->GetOutputProbabilityMap();
     mitk::Image::Pointer img = mitk::Image::New();
     img->InitializeByItk(outImg.GetPointer());
     img->SetVolume(outImg->GetBufferPointer());
 
     if (ext != ".nii" && ext != ".nii.gz" && ext != ".nrrd")
       outFile += ".nii.gz";
 
     mitk::IOUtil::Save(img, outFile);
   }
 
   delete handler;
 
   return EXIT_SUCCESS;
 }
diff --git a/Modules/FiberTracking/Algorithms/TrackingHandlers/mitkTrackingHandlerOdf.cpp b/Modules/FiberTracking/Algorithms/TrackingHandlers/mitkTrackingHandlerOdf.cpp
index ab3e64f..2dea114 100644
--- a/Modules/FiberTracking/Algorithms/TrackingHandlers/mitkTrackingHandlerOdf.cpp
+++ b/Modules/FiberTracking/Algorithms/TrackingHandlers/mitkTrackingHandlerOdf.cpp
@@ -1,307 +1,295 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center.
 
 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 "mitkTrackingHandlerOdf.h"
 #include <itkDiffusionOdfGeneralizedFaImageFilter.h>
 #include <itkImageRegionIterator.h>
 #include <itkPointShell.h>
 #include <omp.h>
 #include <cmath>
 
 namespace mitk
 {
 
 TrackingHandlerOdf::TrackingHandlerOdf()
   : m_NumProbSamples(1)
   , m_OdfFromTensor(false)
 {
   m_GfaInterpolator = itk::LinearInterpolateImageFunction< itk::Image< float, 3 >, float >::New();
   m_OdfInterpolator = itk::LinearInterpolateImageFunction< itk::Image< ItkOdfImageType::PixelType, 3 >, float >::New();
 }
 
 TrackingHandlerOdf::~TrackingHandlerOdf()
 {
 }
 
 bool TrackingHandlerOdf::WorldToIndex(itk::Point<float, 3>& pos, itk::Index<3>& index)
 {
   m_OdfImage->TransformPhysicalPointToIndex(pos, index);
   return m_OdfImage->GetLargestPossibleRegion().IsInside(index);
 }
 
 void TrackingHandlerOdf::InitForTracking()
 {
   MITK_INFO << "Initializing ODF tracker.";
 
   if (m_NeedsDataInit)
   {
     m_OdfHemisphereIndices.clear();
     itk::OrientationDistributionFunction< float, ODF_SAMPLING_SIZE > odf;
     vnl_vector_fixed<double,3> ref; ref.fill(0); ref[0]=1;
 
     for (int i=0; i<ODF_SAMPLING_SIZE; i++)
       if (dot_product(ref, odf.GetDirection(i))>0)
         m_OdfHemisphereIndices.push_back(i);
     m_OdfFloatDirs.set_size(m_OdfHemisphereIndices.size(), 3);
 
     auto double_dir = m_OdfImage->GetDirection().GetVnlMatrix();
     for (int r=0; r<3; r++)
       for (int c=0; c<3; c++)
       {
         m_FloatImageRotation[r][c] = double_dir[r][c];
       }
 
     for (unsigned int i=0; i<m_OdfHemisphereIndices.size(); i++)
     {
       m_OdfFloatDirs[i][0] = odf.GetDirection(m_OdfHemisphereIndices[i])[0];
       m_OdfFloatDirs[i][1] = odf.GetDirection(m_OdfHemisphereIndices[i])[1];
       m_OdfFloatDirs[i][2] = odf.GetDirection(m_OdfHemisphereIndices[i])[2];
     }
 
     if (m_GfaImage.IsNull())
     {
       MITK_INFO << "Calculating GFA image.";
       typedef itk::DiffusionOdfGeneralizedFaImageFilter<float,float,ODF_SAMPLING_SIZE> GfaFilterType;
       GfaFilterType::Pointer gfaFilter = GfaFilterType::New();
       gfaFilter->SetInput(m_OdfImage);
       gfaFilter->SetComputationMethod(GfaFilterType::GFA_STANDARD);
       gfaFilter->Update();
       m_GfaImage = gfaFilter->GetOutput();
     }
 
     m_NeedsDataInit = false;
   }
 
   if (m_OdfFromTensor)
   {
 //    m_Parameters->m_OdfCutoff = 0;
 //    m_Parameters->m_SharpenOdfs = false;
   }
 
   m_GfaInterpolator->SetInputImage(m_GfaImage);
   m_OdfInterpolator->SetInputImage(m_OdfImage);
   this->CalculateMinVoxelSize();
 
   std::cout << "TrackingHandlerOdf - GFA threshold: " << m_Parameters->m_Cutoff << std::endl;
   std::cout << "TrackingHandlerOdf - ODF threshold: " << m_Parameters->m_OdfCutoff << std::endl;
-  if (m_Parameters->m_SharpenOdfs)
-    std::cout << "TrackingHandlerOdf - Sharpening ODfs" << std::endl;
+  if (m_Parameters->m_SharpenOdfs > 1)
+    std::cout << "TrackingHandlerOdf - Raising ODf values to the power of " << m_Parameters->m_SharpenOdfs << std::endl;
 }
 
 int TrackingHandlerOdf::SampleOdf(vnl_vector< float >& probs, vnl_vector< float >& angles)
 {
   boost::random::discrete_distribution<int, float> dist(probs.begin(), probs.end());
   int sampled_idx = 0;
   int max_sample_idx = -1;
   float max_prob = 0;
   int trials = 0;
 
   for (int i=0; i<m_NumProbSamples; i++)  // we sample m_NumProbSamples times and retain the sample with maximum probabilty
   {
     trials++;
 #pragma omp critical
     {
       boost::random::variate_generator<boost::random::mt19937&, boost::random::discrete_distribution<int,float>> sampler(m_Rng, dist);
       sampled_idx = sampler();
     }
     if (probs[sampled_idx]>max_prob && probs[sampled_idx]>m_Parameters->m_OdfCutoff && fabs(angles[sampled_idx])>=m_Parameters->GetAngularThresholdDot())
     {
       max_prob = probs[sampled_idx];
       max_sample_idx = sampled_idx;
     }
     else if ( (probs[sampled_idx]<=m_Parameters->m_OdfCutoff || fabs(angles[sampled_idx])<m_Parameters->GetAngularThresholdDot()) && trials<50) // we allow 50 trials to exceed the ODF threshold
       i--;
   }
 
   return max_sample_idx;
 }
 
 void TrackingHandlerOdf::SetIsOdfFromTensor(bool OdfFromTensor)
 {
   m_OdfFromTensor = OdfFromTensor;
 }
 
 bool TrackingHandlerOdf::GetIsOdfFromTensor() const
 {
   return m_OdfFromTensor;
 }
 
 vnl_vector_fixed<float,3> TrackingHandlerOdf::ProposeDirection(const itk::Point<float, 3>& pos, std::deque<vnl_vector_fixed<float, 3> >& olddirs, itk::Index<3>& oldIndex)
 {
 
   vnl_vector_fixed<float,3> output_direction; output_direction.fill(0);
 
   itk::Index<3> idx;
   m_OdfImage->TransformPhysicalPointToIndex(pos, idx);
 
   if ( !m_OdfImage->GetLargestPossibleRegion().IsInside(idx) )
     return output_direction;
 
   // check GFA threshold for termination
   float gfa = mitk::imv::GetImageValue<float>(pos, m_Parameters->m_InterpolateTractographyData, m_GfaInterpolator);
   if (gfa<m_Parameters->m_Cutoff)
     return output_direction;
 
   vnl_vector_fixed<float,3> last_dir;
   if (!olddirs.empty())
     last_dir = olddirs.back();
 
   if (!m_Parameters->m_InterpolateTractographyData && oldIndex==idx)
     return last_dir;
 
   ItkOdfImageType::PixelType odf_values = mitk::imv::GetImageValue<ItkOdfImageType::PixelType>(pos, m_Parameters->m_InterpolateTractographyData, m_OdfInterpolator);
   vnl_vector< float > probs; probs.set_size(m_OdfHemisphereIndices.size());
   vnl_vector< float > angles; angles.set_size(m_OdfHemisphereIndices.size()); angles.fill(1.0);
 
   // Find ODF maximum and remove <0 values
   float max_odf_val = 0;
-  float min_odf_val = 999;
   int max_idx_d = -1;
   int c = 0;
   for (int i : m_OdfHemisphereIndices)
   {
     if (odf_values[i]<0)
       odf_values[i] = 0;
+    odf_values[i] = pow(odf_values[i], m_Parameters->m_SharpenOdfs);
 
     if (odf_values[i]>max_odf_val)
     {
       max_odf_val = odf_values[i];
       max_idx_d = c;
     }
-    if (odf_values[i]<min_odf_val)
-      min_odf_val = odf_values[i];
 
     probs[c] = odf_values[i];
     c++;
   }
 
-  if (m_Parameters->m_SharpenOdfs)
-  {
-    // sharpen ODF
-    probs -= min_odf_val;
-    probs /= (max_odf_val-min_odf_val);
-    for (unsigned int i=0; i<probs.size(); i++)
-      probs[i] = pow(probs[i], 4);
-    float odf_sum = probs.sum();
-    if (odf_sum>0)
-    {
-      probs /= odf_sum;
-      max_odf_val /= odf_sum;
-    }
-  }
+  float odf_sum = probs.sum();
+  if (odf_sum>0)
+    probs /= odf_sum;
+  max_odf_val = max_odf_val/odf_sum;
 
   // no previous direction
   if (max_odf_val>m_Parameters->m_OdfCutoff && (olddirs.empty() || last_dir.magnitude()<=0.5))
   {
     if (m_Parameters->m_Mode==MODE::DETERMINISTIC)  // return maximum peak
     {
       output_direction = m_OdfFloatDirs.get_row(max_idx_d);
       return output_direction * max_odf_val;
     }
     else if (m_Parameters->m_Mode==MODE::PROBABILISTIC) // sample from complete ODF
     {
       int max_sample_idx = SampleOdf(probs, angles);
       if (max_sample_idx>=0)
         output_direction = m_OdfFloatDirs.get_row(max_sample_idx) * probs[max_sample_idx];
       return output_direction;
     }
   }
   else if (max_odf_val<=m_Parameters->m_OdfCutoff) // return (0,0,0)
   {
     return output_direction;
   }
 
   // correct previous direction
   if (m_Parameters->m_FlipX)
     last_dir[0] *= -1;
   if (m_Parameters->m_FlipY)
     last_dir[1] *= -1;
   if (m_Parameters->m_FlipZ)
     last_dir[2] *= -1;
 
   // calculate angles between previous direction and ODF directions
   angles = m_OdfFloatDirs*last_dir;
 
   float probs_sum = 0;
   float max_prob = 0;
   for (unsigned int i=0; i<m_OdfHemisphereIndices.size(); i++)
   {
     float odf_val = probs[i];
     float angle = angles[i];
     float abs_angle = fabs(angle);
 
     odf_val *= abs_angle; // weight probabilities according to deviation from last direction
     if (m_Parameters->m_Mode==MODE::DETERMINISTIC && odf_val>max_prob && odf_val>m_Parameters->m_OdfCutoff)
     {
       // use maximum peak of the ODF weighted with the directional prior
       max_prob = odf_val;
       vnl_vector_fixed<float,3> d = m_OdfFloatDirs.get_row(i);
       if (angle<0)
         d *= -1;
       output_direction = odf_val*d;
     }
     else if (m_Parameters->m_Mode==MODE::PROBABILISTIC)
     {
       // update ODF probabilties with the ODF values pow(abs_angle, m_DirPriorPower)
       probs[i] = odf_val;
       probs_sum += probs[i];
     }
   }
 
   // do probabilistic sampling
   if (m_Parameters->m_Mode==MODE::PROBABILISTIC && probs_sum>0.0001)
   {
     int max_sample_idx = SampleOdf(probs, angles);
     if (max_sample_idx>=0)
     {
       output_direction = m_OdfFloatDirs.get_row(max_sample_idx);
       if (angles[max_sample_idx]<0)
         output_direction *= -1;
       output_direction *= probs[max_sample_idx];
     }
   }
 
   // check hard angular threshold
   float mag = output_direction.magnitude();
   if (mag>=0.0001)
   {
     output_direction.normalize();
     float a = dot_product(output_direction, last_dir);
     if (a<m_Parameters->GetAngularThresholdDot())
       output_direction.fill(0);
   }
   else
     output_direction.fill(0);
 
   if (m_Parameters->m_FlipX)
     output_direction[0] *= -1;
   if (m_Parameters->m_FlipY)
     output_direction[1] *= -1;
   if (m_Parameters->m_FlipZ)
     output_direction[2] *= -1;
   if (m_Parameters->m_ApplyDirectionMatrix)
     output_direction = m_FloatImageRotation*output_direction;
 
   return output_direction;
 }
 
 void TrackingHandlerOdf::SetNumProbSamples(int NumProbSamples)
 {
   m_NumProbSamples = NumProbSamples;
 }
 
 }
 
diff --git a/Modules/FiberTracking/Testing/mitkStreamlineTractographyTest.cpp b/Modules/FiberTracking/Testing/mitkStreamlineTractographyTest.cpp
index a5e07f6..cfb7b10 100644
--- a/Modules/FiberTracking/Testing/mitkStreamlineTractographyTest.cpp
+++ b/Modules/FiberTracking/Testing/mitkStreamlineTractographyTest.cpp
@@ -1,439 +1,439 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center.
 
 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 <mitkImageToItk.h>
 #include <mitkTensorImage.h>
 #include <mitkOdfImage.h>
 #include <mitkIOUtil.h>
 #include <mitkFiberBundle.h>
 #include <itkStreamlineTrackingFilter.h>
 #include <Algorithms/TrackingHandlers/mitkTrackingDataHandler.h>
 #include <Algorithms/TrackingHandlers/mitkTrackingHandlerOdf.h>
 #include <Algorithms/TrackingHandlers/mitkTrackingHandlerPeaks.h>
 #include <Algorithms/TrackingHandlers/mitkTrackingHandlerTensor.h>
 #include <itkDiffusionTensor3D.h>
 #include <mitkTestingMacros.h>
 #include <mitkTestFixture.h>
 #include <mitkFiberBundle.h>
 #include <omp.h>
 #include <itksys/SystemTools.hxx>
 #include <mitkEqual.h>
 #include <mitkStreamlineTractographyParameters.h>
 
 class mitkStreamlineTractographyTestSuite : public mitk::TestFixture
 {
 
   CPPUNIT_TEST_SUITE(mitkStreamlineTractographyTestSuite);
   MITK_TEST(Test_Peak1);
   MITK_TEST(Test_Peak2);
   MITK_TEST(Test_Tensor1);
   MITK_TEST(Test_Tensor2);
   MITK_TEST(Test_Tensor3);
   MITK_TEST(Test_Odf1);
   MITK_TEST(Test_Odf2);
   MITK_TEST(Test_Odf3);
   MITK_TEST(Test_Odf4);
   MITK_TEST(Test_Odf5);
   MITK_TEST(Test_Odf6);
   CPPUNIT_TEST_SUITE_END();
 
   typedef itk::VectorImage< short, 3>   ItkDwiType;
 
 private:
 
 public:
 
   /** Members used inside the different (sub-)tests. All members are initialized via setUp().*/
 
   typedef itk::Image<float, 3> ItkFloatImgType;
 
   mitk::TrackingHandlerOdf::ItkOdfImageType::Pointer itk_odf_image;
   mitk::TrackingHandlerTensor::ItkTensorImageType::ConstPointer itk_tensor_image;
   mitk::TrackingHandlerPeaks::PeakImgType::Pointer itk_peak_image;
   ItkFloatImgType::Pointer itk_seed_image;
   ItkFloatImgType::Pointer itk_mask_image;
   ItkFloatImgType::Pointer itk_gfa_image;
 
   float gfa_threshold;
   float odf_threshold;
   float peak_threshold;
   std::shared_ptr<mitk::StreamlineTractographyParameters> params;
 
   itk::StreamlineTrackingFilter::Pointer tracker;
 
   void setUp() override
   {
     omp_set_num_threads(1);
 
     gfa_threshold = 0.2f;
     odf_threshold = 0.1f;
     peak_threshold = 0.1f;
 
     mitk::Image::Pointer odf_image = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("DiffusionImaging/StreamlineTractography/qball_image.qbi"));
     mitk::Image::Pointer tensor_image = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("DiffusionImaging/StreamlineTractography/tensor_image.dti"));
     mitk::Image::Pointer peak_image = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("DiffusionImaging/StreamlineTractography/qball_peak_image.nii.gz"));
     mitk::Image::Pointer seed_image = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("DiffusionImaging/StreamlineTractography/seed_image.nii.gz"));
     mitk::Image::Pointer mask_image = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("DiffusionImaging/StreamlineTractography/mask_image.nii.gz"));
     mitk::Image::Pointer gfa_image = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("DiffusionImaging/StreamlineTractography/gfa_image.nii.gz"));
 
     params = std::make_shared<mitk::StreamlineTractographyParameters>();
     params->m_FixRandomSeed = true;
     params->m_InterpolateRoiImages = false;
     params->SetLoopCheckDeg(-1);  // todo: test loop check
 
     {
       typedef mitk::ImageToItk< mitk::TrackingHandlerPeaks::PeakImgType > CasterType;
       CasterType::Pointer caster = CasterType::New();
       caster->SetInput(peak_image);
       caster->Update();
       itk_peak_image = caster->GetOutput();
     }
 
     {
       typedef mitk::ImageToItk< mitk::TrackingHandlerTensor::ItkTensorImageType > CasterType;
       CasterType::Pointer caster = CasterType::New();
       caster->SetInput(tensor_image);
       caster->Update();
       itk_tensor_image = caster->GetOutput();
     }
 
     {
       typedef mitk::ImageToItk< mitk::TrackingHandlerOdf::ItkOdfImageType > CasterType;
       CasterType::Pointer caster = CasterType::New();
       caster->SetInput(odf_image);
       caster->Update();
       itk_odf_image = caster->GetOutput();
     }
 
     itk_gfa_image = ItkFloatImgType::New();
     mitk::CastToItkImage(gfa_image, itk_gfa_image);
 
     itk_seed_image = ItkFloatImgType::New();
     mitk::CastToItkImage(seed_image, itk_seed_image);
 
     itk_mask_image = ItkFloatImgType::New();
     mitk::CastToItkImage(mask_image, itk_mask_image);
   }
 
   mitk::FiberBundle::Pointer LoadReferenceFib(std::string filename)
   {
     mitk::FiberBundle::Pointer fib = nullptr;
 
     if (itksys::SystemTools::FileExists(GetTestDataFilePath("DiffusionImaging/StreamlineTractography/ReferenceFibs/" + filename)))
     {
       mitk::BaseData::Pointer baseData = mitk::IOUtil::Load(GetTestDataFilePath("DiffusionImaging/StreamlineTractography/ReferenceFibs/" + filename)).at(0);
       fib = dynamic_cast<mitk::FiberBundle*>(baseData.GetPointer());
     }
     return fib;
   }
 
   mitk::Image::Pointer LoadReferenceImage(std::string filename)
   {
     mitk::Image::Pointer img = nullptr;
 
     if (itksys::SystemTools::FileExists(GetTestDataFilePath("DiffusionImaging/StreamlineTractography/ReferenceFibs/" + filename)))
     {
       img = mitk::IOUtil::Load<mitk::Image>(GetTestDataFilePath("DiffusionImaging/StreamlineTractography/ReferenceFibs/" + filename));
     }
     return img;
   }
 
   void SetupTracker(mitk::TrackingDataHandler* handler)
   {
 
     tracker = itk::StreamlineTrackingFilter::New();
 
 //    tracker->SetInterpolateMasks(false);
 //    tracker->SetNumberOfSamples(0);
 //    tracker->SetAngularThreshold(-1);
     tracker->SetMaskImage(itk_mask_image);
     tracker->SetSeedImage(itk_seed_image);
     tracker->SetStoppingRegions(nullptr);
 //    tracker->SetSeedsPerVoxel(1);
 //    tracker->SetStepSize(0.5);
 //    tracker->SetSamplingDistance(0.25);
 //    tracker->SetUseStopVotes(true);
 //    tracker->SetOnlyForwardSamples(true);
 //    tracker->SetMinTractLength(20);
 //    tracker->SetMaxNumTracts(-1);
     tracker->SetTrackingHandler(handler);
 //    tracker->SetUseOutputProbabilityMap(false);
     tracker->SetParameters(params);
   }
 
   void tearDown() override
   {
 
   }
 
   void CheckFibResult(std::string ref_file, mitk::FiberBundle::Pointer test_fib)
   {
     mitk::FiberBundle::Pointer ref = LoadReferenceFib(ref_file);
     if (ref.IsNull())
     {
       mitk::IOUtil::Save(test_fib, mitk::IOUtil::GetTempPath()+ref_file);
       CPPUNIT_FAIL("Reference file not found. Saving test file to " + mitk::IOUtil::GetTempPath() + ref_file);
     }
     else
     {
       bool is_equal = ref->Equals(test_fib);
       if (!is_equal)
       {
         mitk::IOUtil::Save(test_fib, mitk::IOUtil::GetTempPath()+ref_file);
         CPPUNIT_FAIL("Tractograms are not equal! Saving test file to " + mitk::IOUtil::GetTempPath() + ref_file);
       }
     }
   }
 
   void CheckImageResult(std::string ref_file, mitk::Image::Pointer test_img)
   {
     mitk::Image::Pointer ref = LoadReferenceImage(ref_file);
     if (ref.IsNull())
     {
       mitk::IOUtil::Save(test_img, mitk::IOUtil::GetTempPath()+ref_file);
       CPPUNIT_FAIL("Reference file not found. Saving test file to " + mitk::IOUtil::GetTempPath() + ref_file);
     }
     else
     {
       MITK_ASSERT_EQUAL(test_img, ref, "Images should be equal");
     }
   }
 
   void Test_Peak1()
   {
     mitk::TrackingHandlerPeaks* handler = new mitk::TrackingHandlerPeaks();
     handler->SetPeakImage(itk_peak_image);
     params->m_Cutoff = peak_threshold;
 
     SetupTracker(handler);
     tracker->Update();
 
     vtkSmartPointer< vtkPolyData > poly = tracker->GetFiberPolyData();
     mitk::FiberBundle::Pointer outFib = mitk::FiberBundle::New(poly);
 
     CheckFibResult("Test_Peak1.fib", outFib);
 
     delete handler;
   }
 
   void Test_Peak2()
   {
     mitk::TrackingHandlerPeaks* handler = new mitk::TrackingHandlerPeaks();
     handler->SetPeakImage(itk_peak_image);
     params->m_Cutoff = peak_threshold;
     params->m_InterpolateTractographyData = false;
 
     SetupTracker(handler);
     tracker->Update();
 
     vtkSmartPointer< vtkPolyData > poly = tracker->GetFiberPolyData();
     mitk::FiberBundle::Pointer outFib = mitk::FiberBundle::New(poly);
 
     CheckFibResult("Test_Peak2.fib", outFib);
 
     delete handler;
   }
 
   void Test_Tensor1()
   {
     mitk::TrackingHandlerTensor* handler = new mitk::TrackingHandlerTensor();
     handler->SetTensorImage(itk_tensor_image);
     params->m_Cutoff = gfa_threshold;
 
     SetupTracker(handler);
     tracker->Update();
 
     vtkSmartPointer< vtkPolyData > poly = tracker->GetFiberPolyData();
     mitk::FiberBundle::Pointer outFib = mitk::FiberBundle::New(poly);
 
     CheckFibResult("Test_Tensor1.fib", outFib);
 
     delete handler;
   }
 
   void Test_Tensor2()
   {
     mitk::TrackingHandlerTensor* handler = new mitk::TrackingHandlerTensor();
     handler->SetTensorImage(itk_tensor_image);
     params->m_Cutoff = gfa_threshold;
     params->m_InterpolateTractographyData = false;
 
     SetupTracker(handler);
     tracker->Update();
 
     vtkSmartPointer< vtkPolyData > poly = tracker->GetFiberPolyData();
     mitk::FiberBundle::Pointer outFib = mitk::FiberBundle::New(poly);
 
     CheckFibResult("Test_Tensor2.fib", outFib);
 
     delete handler;
   }
 
   void Test_Tensor3()
   {
     mitk::TrackingHandlerTensor* handler = new mitk::TrackingHandlerTensor();
     handler->SetTensorImage(itk_tensor_image);
     params->m_Cutoff = gfa_threshold;
     params->m_InterpolateTractographyData = false;
     params->m_F = 0;
     params->m_G = 1;
 
     SetupTracker(handler);
     tracker->Update();
 
     vtkSmartPointer< vtkPolyData > poly = tracker->GetFiberPolyData();
     mitk::FiberBundle::Pointer outFib = mitk::FiberBundle::New(poly);
 
     CheckFibResult("Test_Tensor3.fib", outFib);
 
     delete handler;
   }
 
   void Test_Odf1()
   {
     mitk::TrackingHandlerOdf* handler = new mitk::TrackingHandlerOdf();
     handler->SetOdfImage(itk_odf_image);
 
     params->m_Cutoff = gfa_threshold;
     params->m_OdfCutoff = 0;
-    params->m_SharpenOdfs = true;
+    params->m_SharpenOdfs = 1;
 
     SetupTracker(handler);
     tracker->Update();
 
     vtkSmartPointer< vtkPolyData > poly = tracker->GetFiberPolyData();
     mitk::FiberBundle::Pointer outFib = mitk::FiberBundle::New(poly);
 
     CheckFibResult("Test_Odf1.fib", outFib);
 
     delete handler;
   }
 
   void Test_Odf2()
   {
     mitk::TrackingHandlerOdf* handler = new mitk::TrackingHandlerOdf();
     handler->SetOdfImage(itk_odf_image);
 
     params->m_Cutoff = gfa_threshold;
     params->m_OdfCutoff = 0;
-    params->m_SharpenOdfs = false;
+    params->m_SharpenOdfs = 8;
 
     SetupTracker(handler);
     tracker->Update();
 
     vtkSmartPointer< vtkPolyData > poly = tracker->GetFiberPolyData();
     mitk::FiberBundle::Pointer outFib = mitk::FiberBundle::New(poly);
 
     CheckFibResult("Test_Odf2.fib", outFib);
 
     delete handler;
   }
 
 
   void Test_Odf3()
   {
     mitk::TrackingHandlerOdf* handler = new mitk::TrackingHandlerOdf();
     handler->SetOdfImage(itk_odf_image);
 
     params->m_Cutoff = gfa_threshold;
     params->m_OdfCutoff = 0;
-    params->m_SharpenOdfs = true;
+    params->m_SharpenOdfs = 1;
     params->m_InterpolateTractographyData = false;
 
     SetupTracker(handler);
     tracker->Update();
 
     vtkSmartPointer< vtkPolyData > poly = tracker->GetFiberPolyData();
     mitk::FiberBundle::Pointer outFib = mitk::FiberBundle::New(poly);
 
     CheckFibResult("Test_Odf3.fib", outFib);
 
     delete handler;
   }
 
   void Test_Odf4()
   {
     mitk::TrackingHandlerOdf* handler = new mitk::TrackingHandlerOdf();
     handler->SetOdfImage(itk_odf_image);
 
     params->m_Cutoff = gfa_threshold;
     params->m_OdfCutoff = 0;
-    params->m_SharpenOdfs = true;
+    params->m_SharpenOdfs = 1;
     params->m_SeedsPerVoxel = 3;
 
     SetupTracker(handler);
     tracker->Update();
 
     vtkSmartPointer< vtkPolyData > poly = tracker->GetFiberPolyData();
     mitk::FiberBundle::Pointer outFib = mitk::FiberBundle::New(poly);
 
     CheckFibResult("Test_Odf4.fib", outFib);
 
     delete handler;
   }
 
   void Test_Odf5()
   {
     mitk::TrackingHandlerOdf* handler = new mitk::TrackingHandlerOdf();
     handler->SetOdfImage(itk_odf_image);
 
     params->m_Cutoff = gfa_threshold;
     params->m_OdfCutoff = 0;
-    params->m_SharpenOdfs = true;
-    params->m_SeedsPerVoxel = 3;
+    params->m_SeedsPerVoxel = 10;
+    params->m_SharpenOdfs = 8;
     params->m_Mode = mitk::TrackingDataHandler::MODE::PROBABILISTIC;
 
     SetupTracker(handler);
     tracker->Update();
 
     vtkSmartPointer< vtkPolyData > poly = tracker->GetFiberPolyData();
     mitk::FiberBundle::Pointer outFib = mitk::FiberBundle::New(poly);
 
     CheckFibResult("Test_Odf5.fib", outFib);
 
     delete handler;
   }
 
   void Test_Odf6()
   {
     mitk::TrackingHandlerOdf* handler = new mitk::TrackingHandlerOdf();
     handler->SetOdfImage(itk_odf_image);
 
     params->m_Cutoff = gfa_threshold;
     params->m_OdfCutoff = 0;
-    params->m_SharpenOdfs = true;
     params->m_SeedsPerVoxel = 10;
+    params->m_SharpenOdfs = 8;
     params->m_Mode = mitk::TrackingDataHandler::MODE::PROBABILISTIC;
     params->m_OutputProbMap = true;
 
     SetupTracker(handler);
     tracker->Update();
 
     itk::StreamlineTrackingFilter::ItkDoubleImgType::Pointer outImg = tracker->GetOutputProbabilityMap();
     mitk::Image::Pointer img = mitk::Image::New();
     img->InitializeByItk(outImg.GetPointer());
     img->SetVolume(outImg->GetBufferPointer());
 
     mitk::IOUtil::Save(img, mitk::IOUtil::GetTempPath()+"Test_Odf6.nrrd");
     CheckImageResult("Test_Odf6.nrrd", img);
 
     delete handler;
   }
 
 };
 
 MITK_TEST_SUITE_REGISTRATION(mitkStreamlineTractography)
diff --git a/Modules/FiberTracking/mitkStreamlineTractographyParameters.cpp b/Modules/FiberTracking/mitkStreamlineTractographyParameters.cpp
index ff02297..9d059e0 100644
--- a/Modules/FiberTracking/mitkStreamlineTractographyParameters.cpp
+++ b/Modules/FiberTracking/mitkStreamlineTractographyParameters.cpp
@@ -1,367 +1,367 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center.
 
 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 <boost/foreach.hpp>
 #include <mitkLexicalCast.h>
 #include <itkImageFileWriter.h>
 #include <itkImageFileReader.h>
 #include <mitkLog.h>
 #include <algorithm>
 #include <string>
 #include <mitkStreamlineTractographyParameters.h>
 #include <mitkDiffusionFunctionCollection.h>
 
 mitk::StreamlineTractographyParameters::StreamlineTractographyParameters()
 {
   AutoAdjust();
 }
 
 mitk::StreamlineTractographyParameters::~StreamlineTractographyParameters()
 {
 
 }
 
 void mitk::StreamlineTractographyParameters::SaveParameters(std::string filename)
 {
   if(filename.empty())
     return;
   if(".stp"!=filename.substr(filename.size()-4, 4))
     filename += ".stp";
 
   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;
 
   parameters.put("seeding.seeds_per_voxel", m_SeedsPerVoxel);
   parameters.put("seeding.trials_per_seed", m_TrialsPerSeed);
   parameters.put("seeding.max_num_fibers", m_MaxNumFibers);
   parameters.put("seeding.interactive_radius_mm", m_InteractiveRadiusMm);
   parameters.put("seeding.num_interactive_seeds", m_NumInteractiveSeeds);
   parameters.put("seeding.enable_interactive", m_EnableInteractive);
 
   parameters.put("roi_constraints.ep_constraints", m_EpConstraints);
 
   parameters.put("tractography.mode", m_Mode);
   parameters.put("tractography.sharpen_odfs", m_SharpenOdfs);
   parameters.put("tractography.cutoff", m_Cutoff);
   parameters.put("tractography.odf_cutoff", m_OdfCutoff);
   parameters.put("tractography.step_size_vox", m_StepSizeVox);
   parameters.put("tractography.min_tract_length_mm", m_MinTractLengthMm);
   parameters.put("tractography.max_tract_length_mm", m_MaxTractLengthMm);
   parameters.put("tractography.angluar_threshold_deg", m_AngularThresholdDeg);
   parameters.put("tractography.loop_check_deg", m_LoopCheckDeg);
   parameters.put("tractography.f", m_F);
   parameters.put("tractography.g", m_G);
   parameters.put("tractography.fix_seed", m_FixRandomSeed);
   parameters.put("tractography.peak_jitter", m_PeakJitter);
 
   parameters.put("prior.weight", m_Weight);
   parameters.put("prior.restrict_to_prior", m_RestrictToPrior);
   parameters.put("prior.new_directions", m_NewDirectionsFromPrior);
   parameters.put("prior.flip_x", m_PriorFlipX);
   parameters.put("prior.flip_y", m_PriorFlipY);
   parameters.put("prior.flip_z", m_PriorFlipZ);
 
   parameters.put("nsampling.num_samples", m_NumSamples);
   parameters.put("nsampling.sampling_distance_vox", m_SamplingDistanceVox);
   parameters.put("nsampling.only_frontal", m_OnlyForwardSamples);
   parameters.put("nsampling.stop_votes", m_StopVotes);
 
   parameters.put("data_handling.flip_x", m_FlipX);
   parameters.put("data_handling.flip_y", m_FlipY);
   parameters.put("data_handling.flip_z", m_FlipZ);
   parameters.put("data_handling.interpolate_tracto_data", m_InterpolateTractographyData);
   parameters.put("data_handling.interpolate_roi_images", m_InterpolateRoiImages);
 
   parameters.put("output.compress", m_CompressFibers);
   parameters.put("output.compression", m_Compression);
   parameters.put("output.prob_map", m_OutputProbMap);
 
   boost::property_tree::json_parser::write_json(filename, parameters, std::locale(), true);
 
 //  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.";
 //  }
 
   setlocale(LC_ALL, currLocale.c_str());
 }
 
 
 
 template< class ParameterType >
 ParameterType mitk::StreamlineTractographyParameters::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 << "'";
     }
     MITK_INFO << "Tag '" << tag << "' not found. Using default value '" << defaultValue << "'.";
     return defaultValue;
   }
 }
 
 void mitk::StreamlineTractographyParameters::LoadParameters(std::string filename)
 { 
   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::json_parser::read_json( filename, parameterTree );
 
   BOOST_FOREACH( boost::property_tree::ptree::value_type const& v1, parameterTree )
   {
     if( v1.first == "seeding" )
     {
       m_SeedsPerVoxel = ReadVal<unsigned int>(v1,"seeds_per_voxel", m_SeedsPerVoxel);
       m_TrialsPerSeed = ReadVal<unsigned int>(v1,"trials_per_seed", m_TrialsPerSeed);
       m_MaxNumFibers = ReadVal<int>(v1,"max_num_fibers", m_MaxNumFibers);
       m_InteractiveRadiusMm = ReadVal<float>(v1,"interactive_radius_mm", m_InteractiveRadiusMm);
       m_NumInteractiveSeeds = ReadVal<unsigned int>(v1,"num_interactive_seeds", m_NumInteractiveSeeds);
       m_EnableInteractive = ReadVal<bool>(v1,"enable_interactive", m_EnableInteractive);
     }
     else if( v1.first == "roi_constraints" )
     {
       switch( ReadVal<int>(v1,"ep_constraints", 0) )
       {
       default:
         m_EpConstraints = EndpointConstraints::NONE;
         break;
       case 1:
         m_EpConstraints = EndpointConstraints::EPS_IN_TARGET;
         break;
       case 2:
         m_EpConstraints = EndpointConstraints::EPS_IN_TARGET_LABELDIFF;
         break;
       case 3:
         m_EpConstraints = EndpointConstraints::EPS_IN_SEED_AND_TARGET;
         break;
       case 4:
         m_EpConstraints = EndpointConstraints::MIN_ONE_EP_IN_TARGET;
         break;
       case 5:
         m_EpConstraints = EndpointConstraints::ONE_EP_IN_TARGET;
         break;
       case 6:
         m_EpConstraints = EndpointConstraints::NO_EP_IN_TARGET;
         break;
       }
     }
     else if( v1.first == "tractography" )
     {
       if(ReadVal<int>(v1,"mode", 0) == 0)
         m_Mode = MODE::DETERMINISTIC;
       else
         m_Mode = MODE::PROBABILISTIC;
 
-      m_SharpenOdfs = ReadVal<bool>(v1,"sharpen_odfs", m_SharpenOdfs);
+      m_SharpenOdfs = ReadVal<int>(v1,"sharpen_odfs", m_SharpenOdfs);
       m_Cutoff = ReadVal<float>(v1,"cutoff", m_Cutoff);
       m_OdfCutoff = ReadVal<float>(v1,"odf_cutoff", m_OdfCutoff);
       SetStepSizeVox(ReadVal<float>(v1,"step_size_vox", m_StepSizeVox));
       m_MinTractLengthMm = ReadVal<float>(v1,"min_tract_length_mm", m_MinTractLengthMm);
       m_MaxTractLengthMm = ReadVal<float>(v1,"max_tract_length_mm", m_MaxTractLengthMm);
       SetAngularThresholdDeg(ReadVal<float>(v1,"angluar_threshold_deg", m_AngularThresholdDeg));
       SetLoopCheckDeg(ReadVal<float>(v1,"loop_check_deg", m_LoopCheckDeg));
       m_F = ReadVal<float>(v1,"f", m_F);
       m_G = ReadVal<float>(v1,"g", m_G);
       m_FixRandomSeed = ReadVal<bool>(v1,"fix_seed", m_FixRandomSeed);
       m_PeakJitter = ReadVal<float>(v1,"peak_jitter", m_PeakJitter);
     }
     else if( v1.first == "prior" )
     {
       m_Weight = ReadVal<float>(v1,"weight", m_Weight);
       m_RestrictToPrior = ReadVal<bool>(v1,"restrict_to_prior", m_RestrictToPrior);
       m_NewDirectionsFromPrior = ReadVal<bool>(v1,"new_directions", m_NewDirectionsFromPrior);
       m_PriorFlipX = ReadVal<bool>(v1,"flip_x", m_PriorFlipX);
       m_PriorFlipY = ReadVal<bool>(v1,"flip_y", m_PriorFlipY);
       m_PriorFlipZ = ReadVal<bool>(v1,"flip_z", m_PriorFlipZ);
     }
     else if( v1.first == "nsampling" )
     {
       m_NumSamples = ReadVal<unsigned int>(v1,"num_samples", m_NumSamples);
       m_SamplingDistanceVox = ReadVal<float>(v1,"sampling_distance_vox", m_SamplingDistanceVox);
       m_OnlyForwardSamples = ReadVal<bool>(v1,"only_frontal", m_OnlyForwardSamples);
       m_StopVotes = ReadVal<bool>(v1,"stop_votes", m_StopVotes);
     }
     else if( v1.first == "data_handling" )
     {
       m_FlipX = ReadVal<bool>(v1,"flip_x", m_FlipX);
       m_FlipY = ReadVal<bool>(v1,"flip_y", m_FlipY);
       m_FlipZ = ReadVal<bool>(v1,"flip_z", m_FlipZ);
       m_InterpolateTractographyData = ReadVal<bool>(v1,"interpolate_tracto_data", m_InterpolateTractographyData);
       m_InterpolateRoiImages = ReadVal<bool>(v1,"interpolate_roi_images", m_InterpolateRoiImages);
     }
     else if( v1.first == "output" )
     {
       m_CompressFibers = ReadVal<bool>(v1,"compress", m_CompressFibers);
       m_Compression = ReadVal<float>(v1,"compression", m_Compression);
       m_OutputProbMap = ReadVal<bool>(v1,"prob_map", m_OutputProbMap);
     }
   }
 
 //  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.";
 //  }
 
   setlocale(LC_ALL, currLocale.c_str());
 }
 
 float mitk::StreamlineTractographyParameters::GetSamplingDistanceMm() const
 {
   return m_SamplingDistanceMm;
 }
 
 void mitk::StreamlineTractographyParameters::SetSamplingDistanceVox(float sampling_distance_vox)
 {
   m_SamplingDistanceVox = sampling_distance_vox;
   AutoAdjust();
 }
 
 void mitk::StreamlineTractographyParameters::AutoAdjust()
 {
   if (m_StepSizeVox<static_cast<float>(mitk::eps))
     m_StepSizeVox = 0.5;
   m_StepSizeMm = m_StepSizeVox*m_MinVoxelSizeMm;
 
   if (m_AngularThresholdDeg<0)
   {
     if  (m_StepSizeMm/m_MinVoxelSizeMm<=0.966f)  // minimum 15° for automatic estimation
       m_AngularThresholdDot = static_cast<float>(std::cos( 0.5 * itk::Math::pi * static_cast<double>(m_StepSizeMm/m_MinVoxelSizeMm) ));
     else
       m_AngularThresholdDot = static_cast<float>(std::cos( 0.5 * itk::Math::pi * 0.966 ));
 
     m_AngularThresholdDeg = std::acos(m_AngularThresholdDot)*180.0/itk::Math::pi;
   }
   else
     m_AngularThresholdDot = static_cast<float>(std::cos( static_cast<double>(m_AngularThresholdDeg)*itk::Math::pi/180.0 ));
 
   if (m_SamplingDistanceVox<static_cast<float>(mitk::eps))
     m_SamplingDistanceVox = m_MinVoxelSizeMm*0.25f;
   m_SamplingDistanceMm = m_SamplingDistanceVox*m_MinVoxelSizeMm;
 }
 
 float mitk::StreamlineTractographyParameters::GetStepSizeVox() const
 {
     return m_StepSizeVox;
 }
 
 float mitk::StreamlineTractographyParameters::GetAngularThresholdDeg() const
 {
     return m_AngularThresholdDeg;
 }
 
 float mitk::StreamlineTractographyParameters::GetSamplingDistanceVox() const
 {
     return m_SamplingDistanceVox;
 }
 
 float mitk::StreamlineTractographyParameters::GetMinVoxelSizeMm() const
 {
     return m_MinVoxelSizeMm;
 }
 
 float mitk::StreamlineTractographyParameters::GetStepSizeMm() const
 {
   return m_StepSizeMm;
 }
 
 void mitk::StreamlineTractographyParameters::SetMinVoxelSizeMm(float min_voxel_size_mm)
 {
   m_MinVoxelSizeMm = min_voxel_size_mm;
   AutoAdjust();
 }
 
 float mitk::StreamlineTractographyParameters::GetAngularThresholdDot() const
 {
   return m_AngularThresholdDot;
 }
 
 void mitk::StreamlineTractographyParameters::SetStepSizeVox(float step_size_vox)
 {
   m_StepSizeVox = step_size_vox;
   AutoAdjust();
 }
 
 float mitk::StreamlineTractographyParameters::GetLoopCheckDeg() const
 {
   return m_LoopCheckDeg;
 }
 
 void mitk::StreamlineTractographyParameters::SetLoopCheckDeg(float loop_check_deg)
 {
   m_LoopCheckDeg = loop_check_deg;
 }
 
 void mitk::StreamlineTractographyParameters::SetAngularThresholdDeg(float angular_threshold_deg)
 {
   m_AngularThresholdDeg = angular_threshold_deg;
   AutoAdjust();
 }
diff --git a/Modules/FiberTracking/mitkStreamlineTractographyParameters.h b/Modules/FiberTracking/mitkStreamlineTractographyParameters.h
index 7f35ad4..a9b66fd 100644
--- a/Modules/FiberTracking/mitkStreamlineTractographyParameters.h
+++ b/Modules/FiberTracking/mitkStreamlineTractographyParameters.h
@@ -1,163 +1,163 @@
 #pragma once
 
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center.
 
 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 <mitkImage.h>
 #include <mitkDiffusionPropertyHelper.h>
 #include <boost/property_tree/ptree.hpp>
 #include <boost/property_tree/json_parser.hpp>
 #include <MitkFiberTrackingExports.h>
 
 namespace mitk
 {
   /**
   * \brief Datastructure to manage streamline tractography parameters.
   *
   */
   class MITKFIBERTRACKING_EXPORT StreamlineTractographyParameters
   {
 
   public:
 
     enum EndpointConstraints {
       NONE,                     ///< No constraints on endpoint locations
       EPS_IN_TARGET,            ///< Both EPs are required to be located in the target image
       EPS_IN_TARGET_LABELDIFF,  ///< Both EPs are required to be located in the target image and the image values at the respective position needs to be distinct
       EPS_IN_SEED_AND_TARGET,   ///< One EP is required to be located in the seed image and one in the target image
       MIN_ONE_EP_IN_TARGET,     ///< At least one EP is required to be located in the target image
       ONE_EP_IN_TARGET,         ///< Exactly one EP is required to be located in the target image
       NO_EP_IN_TARGET           ///< No EP is allowed to be located in the target image
     };
 
     enum MODE {
       DETERMINISTIC,
       PROBABILISTIC
     };
 
     typedef itk::Image<float, 3>                            ItkFloatImgType;
     typedef itk::Image<double, 3>                           ItkDoubleImgType;
     typedef itk::Image<unsigned char, 3>                    ItkUcharImgType;
 
     StreamlineTractographyParameters();
     StreamlineTractographyParameters(const StreamlineTractographyParameters &params) = default;
     ~StreamlineTractographyParameters();
 
     void SaveParameters(std::string filename);  ///< Save image generation parameters to .stp file.
     void LoadParameters(std::string filename);  ///< Load image generation parameters from .stp file.
 
     template< class ParameterType >
     ParameterType ReadVal(boost::property_tree::ptree::value_type const& v, std::string tag, ParameterType defaultValue, bool essential=false);
 
     // seeding
     unsigned int m_SeedsPerVoxel = 1;
     unsigned int m_TrialsPerSeed = 10;
     int m_MaxNumFibers = -1;
     // - seed image
 
     // interactive
     float m_InteractiveRadiusMm = 2;
     unsigned int m_NumInteractiveSeeds = 50;
     bool m_EnableInteractive = false;
 
     // ROI constraints
     EndpointConstraints m_EpConstraints;
     // - mask image
     // - stop image
     // - exclusion image
     // - target image
 
     // tractography
     MODE m_Mode= MODE::DETERMINISTIC;
-    bool m_SharpenOdfs = false;
+    int m_SharpenOdfs = 8;
     float m_Cutoff = 0.1;
     // - fa/gfa image
     float m_OdfCutoff = 0.00025;
     float m_MinTractLengthMm = 20;
     float m_MaxTractLengthMm = 400;
     float m_F = 1;
     float m_G = 0;
     bool m_FixRandomSeed = false;
     unsigned int m_NumPreviousDirections = 1;
     float m_PeakJitter = 0.01; // actual jitter is drawn from a normal distribution with m_PeakJitter*fabs(direction_value) as standard deviation
 
     // prior
     // - peak image
     float m_Weight = 0.5;
     bool m_RestrictToPrior = true;
     bool m_NewDirectionsFromPrior = true;
     bool m_PriorFlipX = false;
     bool m_PriorFlipY = false;
     bool m_PriorFlipZ = false;
 
     // neighborhood sampling
     unsigned int m_NumSamples = 0;
     bool m_OnlyForwardSamples = false;
     bool m_StopVotes = false;
     bool m_AvoidStop = true;
     bool m_RandomSampling = false;
     float m_DeflectionMod = 1.0;
 
     // data handling
     bool m_FlipX = false;
     bool m_FlipY = false;
     bool m_FlipZ = false;
     bool m_InterpolateTractographyData = true;
     bool m_InterpolateRoiImages;
     bool m_ApplyDirectionMatrix = false;
 
     // output and postprocessing
     bool m_CompressFibers = true;
     float m_Compression = 0.1;
     bool m_OutputProbMap = false;
 
     float GetAngularThresholdDot() const;
     float GetAngularThresholdDeg() const;
     void SetAngularThresholdDeg(float angular_threshold_deg);
 
     float GetLoopCheckDeg() const;
     void SetLoopCheckDeg(float loop_check_deg);
 
     float GetStepSizeMm() const;
     float GetStepSizeVox() const;
     void SetStepSizeVox(float step_size_vox);
 
     float GetSamplingDistanceMm() const;
     float GetSamplingDistanceVox() const;
     void SetSamplingDistanceVox(float sampling_distance_vox);
 
     void SetMinVoxelSizeMm(float min_voxel_size_mm);
     float GetMinVoxelSizeMm() const;
 
   private:
 
     void AutoAdjust();
 
     float m_SamplingDistanceVox = -1;
     float m_SamplingDistanceMm;
 
     float m_AngularThresholdDeg = -1;
     float m_AngularThresholdDot;
 
     float m_LoopCheckDeg = 30;
 
     float m_StepSizeVox = -1;
     float m_StepSizeMm;
 
     float m_MinVoxelSizeMm = 1.0;
   };
 }
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.tractography/documentation/UserManual/QmitkStreamlineTrackingViewUserManual.dox b/Plugins/org.mitk.gui.qt.diffusionimaging.tractography/documentation/UserManual/QmitkStreamlineTrackingViewUserManual.dox
index 32df94c..6bd2a06 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging.tractography/documentation/UserManual/QmitkStreamlineTrackingViewUserManual.dox
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging.tractography/documentation/UserManual/QmitkStreamlineTrackingViewUserManual.dox
@@ -1,105 +1,105 @@
 /**
 \page org_mitk_views_streamlinetracking Streamline Tractography
 
 This view enables streamline tractography on various input data. The corresponding command line application is named "MitkStreamlineTractography".
 
 Available sections:
 - \ref StrTrackUserManualInputData
 - \ref StrTrackUserManualSeeding
 - \ref StrTrackUserManualConstraints
 - \ref StrTrackUserManualParameters
 - \ref StrTrackUserManualNeighbourhoodSampling
 - \ref StrTrackUserManualDataHandling
 - \ref StrTrackUserManualPostprocessing
 - \ref StrTrackUserManualReferences
 
 \section StrTrackUserManualInputData Input Data
 
 Select the data you want to track on in the datamanager. Supported file types are:
 - One or multiple DTI images selected in the datamanager.
 - One ODF image, e.g. obtained using MITK Q-ball reconstruction or MRtrix CSD (tractography similar to [6]).
 - One peak image (4D float image).
 - One raw diffusion-weighted image for machine learning based tractography [1].
 -- Tractography Forest: Needed for machine learning based tractography [1].
 
 \section StrTrackUserManualSeeding Seeding
 
 Specify how, where and how many tractography seed points are placed. This can be either done statically using a seed image or in an interactive fashion. Interactive tractography enables the dynamic placement of spherical seed regions simply by clicking into the image (similar to [5]).
 
 Image based seeding:
 - Seed Image: ROI image used to define the seed voxels. If no seed mask is specified, the whole image volume is seeded.
 - Seeds per voxel: If set to 1, the seed is defined as the voxel center. If > 1 the seeds are distributet randomly inside the voxel.
 
 Interactive seeding:
 - Update on Parameter Change: When "Update on Parameter Change" is checked, each parameter change causes an instant retracking with the new parameters. This enables an intuitive exploration of the effects that the other tractography parameters have on the resulting tractogram.
 - Radius: Radius of the manually placed spherical seed region.
 - Num.Seeds: Number of seeds placed randomly inside the spherical seed region.
 
 Parameters for both seeding modes:
 - Trials Per Seed: Try each seed N times until a valid streamline is obtained (only for probabilistic tractography).
 - Max. Num. Fibers: Tractography is stopped after the desired number of fibers is reached, even before all seed points are processed.
 
 \section StrTrackUserManualConstraints ROI Constraints
 
 Specify various ROI and mask images to constrain the tractography process.
 
 - Mask Image: ROI image used to constrain the generated streamlines, typically a brain mask. Streamlines that leave the regions defined in this image will stop immediately.
 - Stop ROI Image: ROI image used to define stopping regions. Streamlines that enter the regions defined in this image will stop immediately.
 - Exclusion ROI Image: Fibers that enter a region defined in this image will be discarded.
 - Endpoint Constraints: Determines which fibers are accepted based on their endpoint location. Options are:
   - No constraints on endpoint locations (command line option NONE)
   - Both EPs are required to be located in the target image (command line option EPS_IN_TARGET)
   - Both EPs are required to be located in the target image and the image values at the respective position needs to be distinct (command line option EPS_IN_TARGET_LABELDIFF)
   - One EP is required to be located in the seed image and one in the target image (command line option EPS_IN_SEED_AND_TARGET)
   - At least one EP is required to be located in the target image (command line option MIN_ONE_EP_IN_TARGET)
   - Exactly one EP is required to be located in the target image (command line option ONE_EP_IN_TARGET)
   - No EP is allowed to be located in the target image (command line option NO_EP_IN_TARGET)
 - Target Image: ROI image needed for endpoint constraints.
 
 \section StrTrackUserManualParameters Tractography Parameters
 
-- Mode: Toggle between deterministic and probabilistic tractography (also affects tracking prior proposals). The probabilistic method simply samples the output direction from the discrete probability distribution provided by the discretized ODF. Probabilistic peak tracking does not derive probabilities from the data but simply adds a normally distributed jitter to the proposed direction.
-- Sharpen ODFs: If you are using dODF images as input, it is advisable to sharpen the ODFs (min-max normalize and raise to the power of 4). This is not necessary (and not recommended) for CSD fODFs, since they are naturally much sharper.
+- Mode: Toggle between deterministic and probabilistic tractography (also affects tracking prior proposals). The probabilistic method simply samples the output direction from the discrete probability distribution provided by the discretized ODF. In case of probabilistic tensor tractography, an ODF is calculated from the tensor. Probabilistic peak tracking does not derive probabilities from the data but simply adds a normally distributed jitter to the proposed direction.
+- Sharpen ODFs: If you are using dODF or tensor images as input for probabilistic tractography, it is advisable to sharpen the ODFs (raise to the power of X). This is not necessary (and not recommended) for CSD fODFs, since they are naturally much sharper.
 - Cutoff: If the streamline reaches a position with an FA value or peak magnitude lower than the speciefied threshold, tracking is terminated. Typical values are 0.2 for FA/GFA and 0.1 for CSD peaks.
 - FA/GFA image used to determine streamline termination. If no image is specified, the FA/GFA image is automatically calculated from the input image. If multiple tensor images are used as input, it is recommended to provide such an image since the FA maps calculated from the individual input tensor images can not provide a suitable termination criterion.
 - ODF Cutoff: Additional threshold on the ODF magnitude. This is useful in case of CSD fODF tractography. For fODFs a good default value is 0.1, for normalized dODFs, e.g. Q-ball ODFs, this threshold should be very low (0.00025) or 0.
 - Step Size: The algorithm proceeds along the streamline with a fixed stepsize. Default is 0.5*minSpacing.
 - Min. Tract Length: Shorter fibers are discarded.
 - Max. Tract Length: Longer fibers are discarded.
 - Angular Threshold: Maximum angle between two successive steps (in degree). Default is 90° * step_size. For probabilistic tractography, candidate directions exceeding this threshold have probability 0, i.e. the respective ODF value is set to zero. The probabilities of the valid directions are normalized to sum to 1.
 - Loop Check: Stop streamline if the threshold on the angular stdev over the last 4 voxel lengths is exceeded. -1 = no loop check.
 - f and g values to balance between FACT [2] and TEND [3,4] tracking (only for tensor based tractography). For further information please refer to [2,3]
 - Peak Jitter: Used for probabilistic peak tractography. Since no probability are provided by the data, a gausian jitter is added to the peaks. The value influences the standard deviataion of the gaussian (dir[i] += normal(0, peak_jitter*|dir[i]|)).
 
 \section StrTrackUserManualTractographyPrior Tractography Prior
 It is possible to use a peak image as prior for tractography on arbitrary other input images. The local progression direction is determined as the weighted average between the direction obtained from the prior and the input data.
 - Weight: Weighting factor between prior and input data directions. A weight of zero means that no prior iformation is used. With a weight of one, tractography is performed directly on the prior directions itself.
 - Restrict to Prior: The prior image is used as tractography mask. Voxels without prior peaks are excluded.
 - New Directions from Prior: By default, the prior is used even if there is no valid direction found in the data. If unchecked, the prior cannot create directions where there are none in the data.
 - Flip directions: Internally flips prior directions. This might be necessary depending on the input data.
 
 \section StrTrackUserManualDataHandling Data Handling
 - Flip directions: Internally flips progression directions. This might be necessary depending on the input data.
 - Interpolate Tractography Data: Trilinearly interpolate the input image used for tractography.
 - Interpolate ROI Images: Trilinearly interpolate the ROI images used to constrain the tractography.
 
 \section StrTrackUserManualNeighbourhoodSampling Neighbourhood Sampling (for details see [1])
 - Neighborhood Samples: Number of neighborhood samples that are used to determine the next fiber progression direction.
 - Sampling Distance: Distance of the sampling positions from the current streamline position (in voxels).
 - Use Only Frontal Samples: Only neighborhood samples in front of the current streamline position are considered.
 - Use Stop-Votes: If checked, the majority of sampling points has to place a stop-vote for the streamline to terminate. If not checked, all sampling positions have to vote for a streamline termination.
 
 \section StrTrackUserManualPostprocessing Output and Postprocessing
 - Compress Fibers: Whole brain tractograms obtained with a small step size can contain billions of points. The tractograms can be compressed by removing points that do not really contribute to the fiber shape, such as many points on a straight line. An error threshold (in mm) can be defined to specify which points should be removed and which not.
 - Output Probability Map: No streamline are generated. Instead, the tractography outputs a visitation-count map that indicates the probability of a fiber to reach a voxel from the selected seed region. For this measure to be sensible, the number of seeds per voxel needs to be rather large.
 
 \section StrTrackUserManualReferences References
 
 [1] Neher, Peter F., Marc-Alexandre Côté, Jean-Christophe Houde, Maxime Descoteaux, and Klaus H. Maier-Hein. “Fiber Tractography Using Machine Learning.” NeuroImage. Accessed July 19, 2017. doi:10.1016/j.neuroimage.2017.07.028.\n
 [2] Mori, Susumu, Walter E. Kaufmann, Godfrey D. Pearlson, Barbara J. Crain, Bram Stieltjes, Meiyappan Solaiyappan, and Peter C. M. Van Zijl. “In Vivo Visualization of Human Neural Pathways by Magnetic Resonance Imaging.” Annals of Neurology 47 (2000): 412–414.\n
 [3] Weinstein, David, Gordon Kindlmann, and Eric Lundberg. “Tensorlines: Advection-Diffusion Based Propagation through Diffusion Tensor Fields.” In Proceedings of the Conference on Visualization’99: Celebrating Ten Years, 249–253, n.d.\n
 [4] Lazar, Mariana, David M. Weinstein, Jay S. Tsuruda, Khader M. Hasan, Konstantinos Arfanakis, M. Elizabeth Meyerand, Benham Badie, et al. “White Matter Tractography Using Diffusion Tensor Deflection.” Human Brain Mapping 18, no. 4 (2003): 306–321.\n
 [5] Chamberland, M., K. Whittingstall, D. Fortin, D. Mathieu, and M. Descoteaux. “Real-Time Multi-Peak Tractography for Instantaneous Connectivity Display.” Front Neuroinform 8 (2014): 59. doi:10.3389/fninf.2014.00059.\n
 [6] Tournier, J-Donald, Fernando Calamante, and Alan Connelly. “MRtrix: Diffusion Tractography in Crossing Fiber Regions.” International Journal of Imaging Systems and Technology 22, no. 1 (March 2012): 53–66. doi:10.1002/ima.22005.
 
 */
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 5b3afa8..1d5307f 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,1215 +1,1216 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center.
 
 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>
 #include <QFileDialog>
 
 // 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 <mitkShImage.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 <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(nullptr)
   , 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_FaImageSelectionWidget->SetDataStorage(this->GetDataStorage());
     m_Controls->m_SeedImageSelectionWidget->SetDataStorage(this->GetDataStorage());
     m_Controls->m_MaskImageSelectionWidget->SetDataStorage(this->GetDataStorage());
     m_Controls->m_TargetImageSelectionWidget->SetDataStorage(this->GetDataStorage());
     m_Controls->m_PriorImageSelectionWidget->SetDataStorage(this->GetDataStorage());
     m_Controls->m_StopImageSelectionWidget->SetDataStorage(this->GetDataStorage());
     m_Controls->m_ForestSelectionWidget->SetDataStorage(this->GetDataStorage());
     m_Controls->m_ExclusionImageSelectionWidget->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_ForestSelectionWidget->SetNodePredicate(isTractographyForest);
     m_Controls->m_FaImageSelectionWidget->SetNodePredicate( mitk::NodePredicateAnd::New(isNotABinaryImagePredicate, dimensionPredicate) );
     m_Controls->m_FaImageSelectionWidget->SetEmptyInfo("--");
     m_Controls->m_FaImageSelectionWidget->SetSelectionIsOptional(true);
 
     m_Controls->m_SeedImageSelectionWidget->SetNodePredicate( mitk::NodePredicateAnd::New(isImagePredicate, dimensionPredicate) );
     m_Controls->m_SeedImageSelectionWidget->SetEmptyInfo("--");
     m_Controls->m_SeedImageSelectionWidget->SetSelectionIsOptional(true);
 
     m_Controls->m_MaskImageSelectionWidget->SetNodePredicate( mitk::NodePredicateAnd::New(isImagePredicate, dimensionPredicate) );
     m_Controls->m_MaskImageSelectionWidget->SetEmptyInfo("--");
     m_Controls->m_MaskImageSelectionWidget->SetSelectionIsOptional(true);
 
     m_Controls->m_StopImageSelectionWidget->SetNodePredicate( mitk::NodePredicateAnd::New(isImagePredicate, dimensionPredicate) );
     m_Controls->m_StopImageSelectionWidget->SetEmptyInfo("--");
     m_Controls->m_StopImageSelectionWidget->SetSelectionIsOptional(true);
 
     m_Controls->m_TargetImageSelectionWidget->SetNodePredicate( mitk::NodePredicateAnd::New(isImagePredicate, dimensionPredicate) );
     m_Controls->m_TargetImageSelectionWidget->SetEmptyInfo("--");
     m_Controls->m_TargetImageSelectionWidget->SetSelectionIsOptional(true);
 
     m_Controls->m_PriorImageSelectionWidget->SetNodePredicate( isPeakImagePredicate );
     m_Controls->m_PriorImageSelectionWidget->SetEmptyInfo("--");
     m_Controls->m_PriorImageSelectionWidget->SetSelectionIsOptional(true);
 
     m_Controls->m_ExclusionImageSelectionWidget->SetNodePredicate( mitk::NodePredicateAnd::New(isImagePredicate, dimensionPredicate) );
     m_Controls->m_ExclusionImageSelectionWidget->SetEmptyInfo("--");
     m_Controls->m_ExclusionImageSelectionWidget->SetSelectionIsOptional(true);
 
     connect( m_TrackingTimer, SIGNAL(timeout()), this, SLOT(TimerUpdate()) );
     connect( m_Controls->m_SaveParametersButton, SIGNAL(clicked()), this, SLOT(SaveParameters()) );
     connect( m_Controls->m_LoadParametersButton, SIGNAL(clicked()), this, SLOT(LoadParameters()) );
     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_FaImageSelectionWidget, &QmitkAbstractNodeSelectionWidget::CurrentSelectionChanged, this, &QmitkStreamlineTrackingView::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_SeedImageSelectionWidget, &QmitkAbstractNodeSelectionWidget::CurrentSelectionChanged, this, &QmitkStreamlineTrackingView::OnParameterChanged );
     connect( m_Controls->m_ModeBox, SIGNAL(currentIndexChanged(int)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_StopImageSelectionWidget, &QmitkAbstractNodeSelectionWidget::CurrentSelectionChanged, this, &QmitkStreamlineTrackingView::OnParameterChanged );
     connect( m_Controls->m_TargetImageSelectionWidget, &QmitkAbstractNodeSelectionWidget::CurrentSelectionChanged, this, &QmitkStreamlineTrackingView::OnParameterChanged );
     connect( m_Controls->m_PriorImageSelectionWidget, &QmitkAbstractNodeSelectionWidget::CurrentSelectionChanged, this, &QmitkStreamlineTrackingView::OnParameterChanged );
     connect( m_Controls->m_ExclusionImageSelectionWidget, &QmitkAbstractNodeSelectionWidget::CurrentSelectionChanged, this, &QmitkStreamlineTrackingView::OnParameterChanged );
     connect( m_Controls->m_MaskImageSelectionWidget, &QmitkAbstractNodeSelectionWidget::CurrentSelectionChanged, this, &QmitkStreamlineTrackingView::OnParameterChanged );
     connect( m_Controls->m_FaImageSelectionWidget, &QmitkAbstractNodeSelectionWidget::CurrentSelectionChanged, this, &QmitkStreamlineTrackingView::OnParameterChanged );
     connect( m_Controls->m_ForestSelectionWidget, &QmitkAbstractNodeSelectionWidget::CurrentSelectionChanged, this, &QmitkStreamlineTrackingView::ForestSwitched );
     connect( m_Controls->m_ForestSelectionWidget, &QmitkAbstractNodeSelectionWidget::CurrentSelectionChanged, this, &QmitkStreamlineTrackingView::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_MaxTractLengthBox, 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_SharpenOdfsBox, SIGNAL(editingFinished()), 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_PriorFlipXBox, SIGNAL(stateChanged(int)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_PriorFlipYBox, SIGNAL(stateChanged(int)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_PriorFlipZBox, 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()) );
     connect( m_Controls->m_PeakJitterBox, SIGNAL(editingFinished()), this, SLOT(OnParameterChanged()) );
 
+    m_Controls->m_SharpenOdfsBox->editingFinished();
     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_MaxTractLengthBox->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();
     m_Controls->m_PeakJitterBox->editingFinished();
 
     StartStopTrackingGui(false);
   }
   m_ParameterFile = QDir::currentPath()+"/param.stp";
 
   UpdateGui();
 }
 
 void QmitkStreamlineTrackingView::ParametersToGui(mitk::StreamlineTractographyParameters& params)
 {
   m_Controls->m_SeedRadiusBox->setValue(params.m_InteractiveRadiusMm);
 
   m_Controls->m_NumSeedsBox->setValue(params.m_NumInteractiveSeeds);
   m_Controls->m_InteractiveBox->setChecked(params.m_EnableInteractive);
   m_Controls->m_ResampleFibersBox->setChecked(params.m_CompressFibers);
 
   m_Controls->m_SeedRadiusBox->setValue(params.m_InteractiveRadiusMm);
   m_Controls->m_NumFibersBox->setValue(params.m_MaxNumFibers);
   m_Controls->m_ScalarThresholdBox->setValue(params.m_Cutoff);
   m_Controls->m_fBox->setValue(params.m_F);
   m_Controls->m_gBox->setValue(params.m_G);
 
   m_Controls->m_OdfCutoffBox->setValue(params.m_OdfCutoff);
-  m_Controls->m_SharpenOdfsBox->setChecked(params.m_SharpenOdfs);
+  m_Controls->m_SharpenOdfsBox->setValue(params.m_SharpenOdfs);
 
   m_Controls->m_PriorWeightBox->setValue(params.m_Weight);
   m_Controls->m_PriorAsMaskBox->setChecked(params.m_RestrictToPrior);
   m_Controls->m_NewDirectionsFromPriorBox->setChecked(params.m_NewDirectionsFromPrior);
 
   m_Controls->m_PriorFlipXBox->setChecked(params.m_PriorFlipX);
   m_Controls->m_PriorFlipYBox->setChecked(params.m_PriorFlipY);
   m_Controls->m_PriorFlipZBox->setChecked(params.m_PriorFlipZ);
 
   m_Controls->m_FlipXBox->setChecked(params.m_FlipX);
   m_Controls->m_FlipYBox->setChecked(params.m_FlipY);
   m_Controls->m_FlipZBox->setChecked(params.m_FlipZ);
   m_Controls->m_InterpolationBox->setChecked(params.m_InterpolateTractographyData);
 
 
   m_Controls->m_MaskInterpolationBox->setChecked(params.m_InterpolateRoiImages);
   m_Controls->m_SeedsPerVoxelBox->setValue(params.m_SeedsPerVoxel);
   m_Controls->m_StepSizeBox->setValue(params.GetStepSizeVox());
   m_Controls->m_SamplingDistanceBox->setValue(params.GetSamplingDistanceVox());
   m_Controls->m_StopVotesBox->setChecked(params.m_StopVotes);
   m_Controls->m_FrontalSamplesBox->setChecked(params.m_OnlyForwardSamples);
   m_Controls->m_TrialsPerSeedBox->setValue(params.m_TrialsPerSeed);
 
   m_Controls->m_NumSamplesBox->setValue(params.m_NumSamples);
   m_Controls->m_LoopCheckBox->setValue(params.GetLoopCheckDeg());
   m_Controls->m_AngularThresholdBox->setValue(params.GetAngularThresholdDeg());
   m_Controls->m_MinTractLengthBox->setValue(params.m_MinTractLengthMm);
   m_Controls->m_MaxTractLengthBox->setValue(params.m_MaxTractLengthMm);
   m_Controls->m_OutputProbMap->setChecked(params.m_OutputProbMap);
   m_Controls->m_FixSeedBox->setChecked(params.m_FixRandomSeed);
   m_Controls->m_PeakJitterBox->setValue(params.m_PeakJitter);
 
   switch (params.m_Mode)
   {
   case mitk::TrackingDataHandler::MODE::DETERMINISTIC:
     m_Controls->m_ModeBox->setCurrentIndex(0);
     break;
   case mitk::TrackingDataHandler::MODE::PROBABILISTIC:
     m_Controls->m_ModeBox->setCurrentIndex(1);
     break;
   }
 
   switch (params.m_EpConstraints)
   {
   case itk::StreamlineTrackingFilter::EndpointConstraints::NONE:
     m_Controls->m_EpConstraintsBox->setCurrentIndex(0);
     break;
   case itk::StreamlineTrackingFilter::EndpointConstraints::EPS_IN_TARGET:
     m_Controls->m_EpConstraintsBox->setCurrentIndex(1);
     break;
   case itk::StreamlineTrackingFilter::EndpointConstraints::EPS_IN_TARGET_LABELDIFF:
     m_Controls->m_EpConstraintsBox->setCurrentIndex(2);
     break;
   case itk::StreamlineTrackingFilter::EndpointConstraints::EPS_IN_SEED_AND_TARGET:
     m_Controls->m_EpConstraintsBox->setCurrentIndex(3);
     break;
   case itk::StreamlineTrackingFilter::EndpointConstraints::MIN_ONE_EP_IN_TARGET:
     m_Controls->m_EpConstraintsBox->setCurrentIndex(4);
     break;
   case itk::StreamlineTrackingFilter::EndpointConstraints::ONE_EP_IN_TARGET:
     m_Controls->m_EpConstraintsBox->setCurrentIndex(5);
     break;
   case itk::StreamlineTrackingFilter::EndpointConstraints::NO_EP_IN_TARGET:
     m_Controls->m_EpConstraintsBox->setCurrentIndex(6);
     break;
   }
 }
 
 std::shared_ptr<mitk::StreamlineTractographyParameters> QmitkStreamlineTrackingView::GetParametersFromGui()
 {
   std::shared_ptr<mitk::StreamlineTractographyParameters> params = std::make_shared<mitk::StreamlineTractographyParameters>();
 
   // NOT IN GUI
 //  unsigned int m_NumPreviousDirections = 1;
 //  bool m_AvoidStop = true;
 //  bool m_RandomSampling = false;
 //  float m_DeflectionMod = 1.0;
 //  bool m_ApplyDirectionMatrix = false;
 
   // NOT IN GUI BUT AUTOMATICALLY SET
   if (!m_InputImageNodes.empty())
   {
     float min_sp = 999;
     auto spacing = dynamic_cast<mitk::Image*>(m_InputImageNodes.at(0)->GetData())->GetGeometry()->GetSpacing();
     if (spacing[0] < min_sp)
       min_sp = spacing[0];
     if (spacing[1] < min_sp)
       min_sp = spacing[1];
     if (spacing[2] < min_sp)
       min_sp = spacing[2];
     params->m_Compression = min_sp/10;
   }
 
   params->m_InteractiveRadiusMm = m_Controls->m_SeedRadiusBox->value();
   params->m_NumInteractiveSeeds = m_Controls->m_NumSeedsBox->value();
   params->m_EnableInteractive = m_Controls->m_InteractiveBox->isChecked();
   params->m_CompressFibers = m_Controls->m_ResampleFibersBox->isChecked();
 
   params->m_InteractiveRadiusMm = m_Controls->m_SeedRadiusBox->value();
   params->m_MaxNumFibers = m_Controls->m_NumFibersBox->value();
   params->m_Cutoff = static_cast<float>(m_Controls->m_ScalarThresholdBox->value());
   params->m_F = static_cast<float>(m_Controls->m_fBox->value());
   params->m_G = static_cast<float>(m_Controls->m_gBox->value());
 
   params->m_OdfCutoff = static_cast<float>(m_Controls->m_OdfCutoffBox->value());
-  params->m_SharpenOdfs = m_Controls->m_SharpenOdfsBox->isChecked();
+  params->m_SharpenOdfs = m_Controls->m_SharpenOdfsBox->value();
 
   params->m_Weight = static_cast<float>(m_Controls->m_PriorWeightBox->value());
   params->m_RestrictToPrior = m_Controls->m_PriorAsMaskBox->isChecked();
   params->m_NewDirectionsFromPrior = m_Controls->m_NewDirectionsFromPriorBox->isChecked();
 
   params->m_PriorFlipX = m_Controls->m_PriorFlipXBox->isChecked();
   params->m_PriorFlipY = m_Controls->m_PriorFlipYBox->isChecked();
   params->m_PriorFlipZ = m_Controls->m_PriorFlipZBox->isChecked();
 
   params->m_FlipX = m_Controls->m_FlipXBox->isChecked();
   params->m_FlipY = m_Controls->m_FlipYBox->isChecked();
   params->m_FlipZ = m_Controls->m_FlipZBox->isChecked();
   params->m_InterpolateTractographyData = m_Controls->m_InterpolationBox->isChecked();
 
 
   params->m_InterpolateRoiImages = m_Controls->m_MaskInterpolationBox->isChecked();
   params->m_SeedsPerVoxel = m_Controls->m_SeedsPerVoxelBox->value();
   params->SetStepSizeVox(m_Controls->m_StepSizeBox->value());
   params->SetSamplingDistanceVox(m_Controls->m_SamplingDistanceBox->value());
   params->m_StopVotes = m_Controls->m_StopVotesBox->isChecked();
   params->m_OnlyForwardSamples = m_Controls->m_FrontalSamplesBox->isChecked();
   params->m_TrialsPerSeed = m_Controls->m_TrialsPerSeedBox->value();
 
   params->m_NumSamples = m_Controls->m_NumSamplesBox->value();
   params->SetLoopCheckDeg(m_Controls->m_LoopCheckBox->value());
   params->SetAngularThresholdDeg(m_Controls->m_AngularThresholdBox->value());
   params->m_MinTractLengthMm = m_Controls->m_MinTractLengthBox->value();
   params->m_MaxTractLengthMm = m_Controls->m_MaxTractLengthBox->value();
   params->m_OutputProbMap = m_Controls->m_OutputProbMap->isChecked();
   params->m_FixRandomSeed = m_Controls->m_FixSeedBox->isChecked();
   params->m_PeakJitter = static_cast<float>(m_Controls->m_PeakJitterBox->value());
 
   switch (m_Controls->m_ModeBox->currentIndex())
   {
   case 0:
     params->m_Mode = mitk::TrackingDataHandler::MODE::DETERMINISTIC;
     break;
   case 1:
     params->m_Mode = mitk::TrackingDataHandler::MODE::PROBABILISTIC;
     break;
   default:
     params->m_Mode = mitk::TrackingDataHandler::MODE::DETERMINISTIC;
   }
 
   switch (m_Controls->m_EpConstraintsBox->currentIndex())
   {
   case 0:
     params->m_EpConstraints = itk::StreamlineTrackingFilter::EndpointConstraints::NONE;
     break;
   case 1:
     params->m_EpConstraints = itk::StreamlineTrackingFilter::EndpointConstraints::EPS_IN_TARGET;
     break;
   case 2:
     params->m_EpConstraints = itk::StreamlineTrackingFilter::EndpointConstraints::EPS_IN_TARGET_LABELDIFF;
     break;
   case 3:
     params->m_EpConstraints = itk::StreamlineTrackingFilter::EndpointConstraints::EPS_IN_SEED_AND_TARGET;
     break;
   case 4:
     params->m_EpConstraints = itk::StreamlineTrackingFilter::EndpointConstraints::MIN_ONE_EP_IN_TARGET;
     break;
   case 5:
     params->m_EpConstraints = itk::StreamlineTrackingFilter::EndpointConstraints::ONE_EP_IN_TARGET;
     break;
   case 6:
     params->m_EpConstraints = itk::StreamlineTrackingFilter::EndpointConstraints::NO_EP_IN_TARGET;
     break;
   }
 
   return params;
 }
 
 void QmitkStreamlineTrackingView::SaveParameters()
 {
   QString filename = QFileDialog::getSaveFileName(
         0,
         tr("Save Tractography Parameters"),
         m_ParameterFile,
         tr("Streamline Tractography Parameters (*.stp)") );
 
   if(filename.isEmpty() || filename.isNull())
     return;
 
   m_ParameterFile = filename;
 
   auto params = GetParametersFromGui();
   params->SaveParameters(m_ParameterFile.toStdString());
 }
 
 void QmitkStreamlineTrackingView::LoadParameters()
 {
   QString filename = QFileDialog::getOpenFileName(
         0,
         tr("Load Tractography Parameters"),
         m_ParameterFile,
         tr("Streamline Tractography Parameters (*.stp)") );
 
   if(filename.isEmpty() || filename.isNull())
     return;
 
   m_ParameterFile = filename;
 
   mitk::StreamlineTractographyParameters params;
   params.LoadParameters(m_ParameterFile.toStdString());
   ParametersToGui(params);
 }
 
 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()
 {
   auto params = m_Tracker->GetParameters();
   m_TrackingTimer->stop();
   if (!params->m_OutputProbMap)
   {
     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->SetTrackVisHeader(dynamic_cast<mitk::Image*>(m_ParentNode->GetData())->GetGeometry());
     if (params->m_CompressFibers && fiberBundle->GetNumberOfLines()>0)
       fib->Compress(params->m_Compression);
     fib->ColorFibersByOrientation();
     m_Tracker->SetDicomProperties(fib);    
     mitk::DiffusionPropertyHelper::CopyDICOMProperties(m_ParentNode->GetData(), 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", params->GetMinVoxelSizeMm()/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", params->GetMinVoxelSizeMm()/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());
     mitk::DiffusionPropertyHelper::CopyDICOMProperties(m_ParentNode->GetData(), img);
 
     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", params->GetMinVoxelSizeMm()/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<double> 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());
     else
       return true;
 
     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_SeedImageSelectionWidget->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)
   {
     if (m_TrackingPriorHandler != nullptr)
     {
       delete m_TrackingPriorHandler;
       m_TrackingPriorHandler = nullptr;
     }
     delete m_TrackingHandler;
     m_TrackingHandler = nullptr;
     m_DeleteTrackingHandler = false;
     m_LastPrior = nullptr;
   }
   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_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()) ||
           dynamic_cast<mitk::OdfImage*>(node->GetData()) ||
           dynamic_cast<mitk::ShImage*>(node->GetData()) ||
           dynamic_cast<mitk::PeakImage*>(node->GetData()) ||
           mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(node->GetData())))
       {
         m_InputImageNodes.push_back(node);
         retrack = true;
       }
       else
       {
         mitk::Image* img = dynamic_cast<mitk::Image*>(node->GetData());
         if (img!=nullptr && img->GetDimension()==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_FaImageSelectionWidget->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_ForestSelectionWidget->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_TargetImageSelectionWidget->setEnabled(false);
   m_Controls->m_TargetImageLabel->setEnabled(false);
   m_Controls->m_PeakJitterBox->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_TargetImageSelectionWidget->setEnabled(true);
     m_Controls->m_TargetImageLabel->setEnabled(true);
   }
 
   // stuff that is 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()) )
     {
       if (m_Controls->m_ModeBox->currentIndex()==1)
       {
         m_Controls->m_OdfCutoffBox->setEnabled(true);
         m_Controls->m_OdfCutoffLabel->setEnabled(true);
         m_Controls->m_SharpenOdfsBox->setEnabled(true);
       }
       else
       {
         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()) ||
               dynamic_cast<mitk::ShImage*>(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_ForestSelectionWidget->setVisible(true);
       m_Controls->m_ForestLabel->setVisible(true);
       m_Controls->m_ScalarThresholdBox->setEnabled(false);
       m_Controls->m_FaThresholdLabel->setEnabled(false);
     }
     else if ( dynamic_cast<mitk::PeakImage*>(m_InputImageNodes.at(0)->GetData()) &&
               m_Controls->m_ModeBox->currentIndex()==1)
     {
       m_Controls->m_PeakJitterBox->setEnabled(true);
     }
   }
 }
 
 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()
 {
   auto params = GetParametersFromGui();
 
   if (m_InputImageNodes.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 (params->m_EpConstraints == itk::StreamlineTrackingFilter::EndpointConstraints::NONE)
       m_Tracker->SetTargetRegions(nullptr);
 
   if( dynamic_cast<mitk::TensorImage*>(m_InputImageNodes.at(0)->GetData()) )
   {
     if (m_Controls->m_ModeBox->currentIndex()==1)
     {
       if (m_InputImageNodes.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();
         typedef itk::TensorImageToOdfImageFilter< float, float > FilterType;
         FilterType::Pointer filter = FilterType::New();
         filter->SetInput( mitk::convert::GetItkTensorFromTensorImage(dynamic_cast<mitk::Image*>(m_InputImageNodes.at(0)->GetData())) );
         filter->Update();
         dynamic_cast<mitk::TrackingHandlerOdf*>(m_TrackingHandler)->SetOdfImage(filter->GetOutput());
 
         if (m_Controls->m_FaImageSelectionWidget->GetSelectedNode().IsNotNull())
         {
           ItkFloatImageType::Pointer itkImg = ItkFloatImageType::New();
           mitk::CastToItkImage(dynamic_cast<mitk::Image*>(m_Controls->m_FaImageSelectionWidget->GetSelectedNode()->GetData()), itkImg);
 
           dynamic_cast<mitk::TrackingHandlerOdf*>(m_TrackingHandler)->SetGfaImage(itkImg);
         }
       }
 
       dynamic_cast<mitk::TrackingHandlerOdf*>(m_TrackingHandler)->SetIsOdfFromTensor(true);
     }
     else
     {
       if (m_TrackingHandler==nullptr)
       {
         m_TrackingHandler = new mitk::TrackingHandlerTensor();
         for (unsigned int i=0; i<m_InputImageNodes.size(); ++i)
           dynamic_cast<mitk::TrackingHandlerTensor*>(m_TrackingHandler)->AddTensorImage(mitk::convert::GetItkTensorFromTensorImage(dynamic_cast<mitk::Image*>(m_InputImageNodes.at(i)->GetData())).GetPointer());
 
         if (m_Controls->m_FaImageSelectionWidget->GetSelectedNode().IsNotNull())
         {
           ItkFloatImageType::Pointer itkImg = ItkFloatImageType::New();
           mitk::CastToItkImage(dynamic_cast<mitk::Image*>(m_Controls->m_FaImageSelectionWidget->GetSelectedNode()->GetData()), itkImg);
 
           dynamic_cast<mitk::TrackingHandlerTensor*>(m_TrackingHandler)->SetFaImage(itkImg);
         }
       }
     }
   }
   else if ( dynamic_cast<mitk::OdfImage*>(m_InputImageNodes.at(0)->GetData()) ||
             dynamic_cast<mitk::ShImage*>(m_InputImageNodes.at(0)->GetData()))
   {
     if (m_TrackingHandler==nullptr)
     {
       m_TrackingHandler = new mitk::TrackingHandlerOdf();
 
       if (dynamic_cast<mitk::ShImage*>(m_InputImageNodes.at(0)->GetData()))
         dynamic_cast<mitk::TrackingHandlerOdf*>(m_TrackingHandler)->SetOdfImage(mitk::convert::GetItkOdfFromShImage(dynamic_cast<mitk::ShImage*>(m_InputImageNodes.at(0)->GetData())));
       else
         dynamic_cast<mitk::TrackingHandlerOdf*>(m_TrackingHandler)->SetOdfImage(mitk::convert::GetItkOdfFromOdfImage(dynamic_cast<mitk::OdfImage*>(m_InputImageNodes.at(0)->GetData())));
 
       if (m_Controls->m_FaImageSelectionWidget->GetSelectedNode().IsNotNull())
       {
         ItkFloatImageType::Pointer itkImg = ItkFloatImageType::New();
         mitk::CastToItkImage(dynamic_cast<mitk::Image*>(m_Controls->m_FaImageSelectionWidget->GetSelectedNode()->GetData()), itkImg);
         dynamic_cast<mitk::TrackingHandlerOdf*>(m_TrackingHandler)->SetGfaImage(itkImg);
       }
     }
   }
   else if ( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image*>(m_InputImageNodes.at(0)->GetData())) )
   {
     if ( m_Controls->m_ForestSelectionWidget->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_ForestSelectionWidget->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)
       {
         params->m_NumPreviousDirections = static_cast<unsigned int>((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);
         forest_valid = dynamic_cast<mitk::TrackingHandlerRandomForest<6, 100>*>(m_TrackingHandler)->IsForestValid();
       }
       else
       {
         params->m_NumPreviousDirections = static_cast<unsigned int>((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);
         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_TrackingHandler==nullptr)
     {
       m_TrackingHandler = new mitk::TrackingHandlerPeaks();
       dynamic_cast<mitk::TrackingHandlerPeaks*>(m_TrackingHandler)->SetPeakImage(mitk::convert::GetItkPeakFromPeakImage(dynamic_cast<mitk::Image*>(m_InputImageNodes.at(0)->GetData())));
     }
   }
 
   if (m_Controls->m_InteractiveBox->isChecked())
   {
     m_Tracker->SetSeedPoints(m_SeedPoints);
   }
   else if (m_Controls->m_SeedImageSelectionWidget->GetSelectedNode().IsNotNull())
   {
     ItkFloatImageType::Pointer mask = ItkFloatImageType::New();
     mitk::CastToItkImage(dynamic_cast<mitk::Image*>(m_Controls->m_SeedImageSelectionWidget->GetSelectedNode()->GetData()), mask);
     m_Tracker->SetSeedImage(mask);
   }
 
   if (m_Controls->m_MaskImageSelectionWidget->GetSelectedNode().IsNotNull())
   {
     ItkFloatImageType::Pointer mask = ItkFloatImageType::New();
     mitk::CastToItkImage(dynamic_cast<mitk::Image*>(m_Controls->m_MaskImageSelectionWidget->GetSelectedNode()->GetData()), mask);
     m_Tracker->SetMaskImage(mask);
   }
 
   if (m_Controls->m_StopImageSelectionWidget->GetSelectedNode().IsNotNull())
   {
     ItkFloatImageType::Pointer mask = ItkFloatImageType::New();
     mitk::CastToItkImage(dynamic_cast<mitk::Image*>(m_Controls->m_StopImageSelectionWidget->GetSelectedNode()->GetData()), mask);
     m_Tracker->SetStoppingRegions(mask);
   }
 
   if (m_Controls->m_TargetImageSelectionWidget->GetSelectedNode().IsNotNull())
   {
     ItkFloatImageType::Pointer mask = ItkFloatImageType::New();
     mitk::CastToItkImage(dynamic_cast<mitk::Image*>(m_Controls->m_TargetImageSelectionWidget->GetSelectedNode()->GetData()), mask);
     m_Tracker->SetTargetRegions(mask);
   }
 
   if (m_Controls->m_PriorImageSelectionWidget->GetSelectedNode().IsNotNull())
   {
     auto prior_params = GetParametersFromGui();
     if (m_LastPrior!=m_Controls->m_PriorImageSelectionWidget->GetSelectedNode() || m_TrackingPriorHandler==nullptr)
     {
       typedef mitk::ImageToItk< mitk::TrackingHandlerPeaks::PeakImgType > CasterType;
       CasterType::Pointer caster = CasterType::New();
       caster->SetInput(dynamic_cast<mitk::PeakImage*>(m_Controls->m_PriorImageSelectionWidget->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);
       m_LastPrior = m_Controls->m_PriorImageSelectionWidget->GetSelectedNode();
     }
 
     prior_params->m_FlipX = m_Controls->m_PriorFlipXBox->isChecked();
     prior_params->m_FlipY = m_Controls->m_PriorFlipYBox->isChecked();
     prior_params->m_FlipZ = m_Controls->m_PriorFlipZBox->isChecked();
     m_TrackingPriorHandler->SetParameters(prior_params);
 
     m_Tracker->SetTrackingPriorHandler(m_TrackingPriorHandler);
   }
   else if (m_Controls->m_PriorImageSelectionWidget->GetSelectedNode().IsNull())
     m_Tracker->SetTrackingPriorHandler(nullptr);
 
   if (m_Controls->m_ExclusionImageSelectionWidget->GetSelectedNode().IsNotNull())
   {
     ItkFloatImageType::Pointer mask = ItkFloatImageType::New();
     mitk::CastToItkImage(dynamic_cast<mitk::Image*>(m_Controls->m_ExclusionImageSelectionWidget->GetSelectedNode()->GetData()), mask);
     m_Tracker->SetExclusionRegions(mask);
   }
 
   if (params->m_EpConstraints!=itk::StreamlineTrackingFilter::EndpointConstraints::NONE && m_Controls->m_TargetImageSelectionWidget->GetSelectedNode().IsNull())
   {
     QMessageBox::information(nullptr, "Error", "Endpoint constraints are used but no target image is set!");
     StartStopTrackingGui(false);
     return;
   }
   else if (params->m_EpConstraints==itk::StreamlineTrackingFilter::EndpointConstraints::EPS_IN_SEED_AND_TARGET
            && (m_Controls->m_SeedImageSelectionWidget->GetSelectedNode().IsNull()|| m_Controls->m_TargetImageSelectionWidget->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;
   }
 
   float min_sp = 999;
   auto spacing = dynamic_cast<mitk::Image*>(m_InputImageNodes.at(0)->GetData())->GetGeometry()->GetSpacing();
   if (spacing[0] < min_sp)
     min_sp = spacing[0];
   if (spacing[1] < min_sp)
     min_sp = spacing[1];
   if (spacing[2] < min_sp)
     min_sp = spacing[2];
   params->m_Compression = min_sp/10;
 
   float max_size = 0;
   for (int i=0; i<3; ++i)
     if (dynamic_cast<mitk::Image*>(m_InputImageNodes.at(0)->GetData())->GetGeometry()->GetExtentInMM(i)>max_size)
       max_size = dynamic_cast<mitk::Image*>(m_InputImageNodes.at(0)->GetData())->GetGeometry()->GetExtentInMM(i);
   if (params->m_MinTractLengthMm >= max_size)
   {
     MITK_INFO << "Max. image size: " << max_size << "mm";
     MITK_INFO << "Min. tract length: " << params->m_MinTractLengthMm << "mm";
     QMessageBox::information(nullptr, "Error", "Minimum tract length exceeds the maximum image extent! Recommended value is about 1/10 of the image extent.");
     StartStopTrackingGui(false);
     return;
   }
   else if (params->m_MinTractLengthMm > max_size/10)
   {
     MITK_INFO << "Max. image size: " << max_size << "mm";
     MITK_INFO << "Min. tract length: " << params->m_MinTractLengthMm << "mm";
     MITK_WARN <<  "Minimum tract length is larger than 1/10 the maximum image extent! Decrease recommended.";
   }
 
   m_Tracker->SetParameters(params);
   m_Tracker->SetTrackingHandler(m_TrackingHandler);
   m_Tracker->SetVerbose(!m_Controls->m_InteractiveBox->isChecked());
 
   m_ParentNode = m_InputImageNodes.at(0);
   m_TrackingThread.start(QThread::LowestPriority);
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.tractography/src/internal/QmitkStreamlineTrackingViewControls.ui b/Plugins/org.mitk.gui.qt.diffusionimaging.tractography/src/internal/QmitkStreamlineTrackingViewControls.ui
index 89eedb8..65ef468 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging.tractography/src/internal/QmitkStreamlineTrackingViewControls.ui
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging.tractography/src/internal/QmitkStreamlineTrackingViewControls.ui
@@ -1,1652 +1,1655 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkStreamlineTrackingViewControls</class>
  <widget class="QWidget" name="QmitkStreamlineTrackingViewControls">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>453</width>
     <height>859</height>
    </rect>
   </property>
   <property name="minimumSize">
    <size>
     <width>0</width>
     <height>0</height>
    </size>
   </property>
   <property name="windowTitle">
    <string>QmitkTemplate</string>
   </property>
   <property name="styleSheet">
    <string>QCommandLinkButton:disabled {
   border: none;
 }
 
 QGroupBox {
   background-color: transparent;
 }</string>
   </property>
   <layout class="QGridLayout" name="gridLayout_11">
    <property name="topMargin">
     <number>3</number>
    </property>
    <property name="bottomMargin">
     <number>3</number>
    </property>
    <property name="horizontalSpacing">
     <number>0</number>
    </property>
    <property name="verticalSpacing">
     <number>40</number>
    </property>
    <item row="1" column="0">
     <widget class="QFrame" name="frame_6">
      <property name="frameShape">
       <enum>QFrame::NoFrame</enum>
      </property>
      <property name="frameShadow">
       <enum>QFrame::Raised</enum>
      </property>
      <layout class="QGridLayout" name="gridLayout_12">
       <property name="leftMargin">
        <number>0</number>
       </property>
       <property name="topMargin">
        <number>15</number>
       </property>
       <property name="rightMargin">
        <number>0</number>
       </property>
       <property name="bottomMargin">
        <number>0</number>
       </property>
       <property name="horizontalSpacing">
        <number>6</number>
       </property>
       <property name="verticalSpacing">
        <number>15</number>
       </property>
       <item row="1" column="0">
        <widget class="QTextEdit" name="m_StatusTextBox">
         <property name="enabled">
          <bool>true</bool>
         </property>
         <property name="sizePolicy">
          <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="readOnly">
          <bool>true</bool>
         </property>
        </widget>
       </item>
       <item row="4" column="0">
        <widget class="QFrame" name="frame_11">
         <property name="frameShape">
          <enum>QFrame::NoFrame</enum>
         </property>
         <property name="frameShadow">
          <enum>QFrame::Raised</enum>
         </property>
         <layout class="QGridLayout" name="gridLayout_21">
          <property name="leftMargin">
           <number>0</number>
          </property>
          <property name="topMargin">
           <number>0</number>
          </property>
          <property name="rightMargin">
           <number>0</number>
          </property>
          <property name="bottomMargin">
           <number>0</number>
          </property>
          <property name="verticalSpacing">
           <number>0</number>
          </property>
          <item row="0" column="1">
           <widget class="QCommandLinkButton" name="m_SaveParametersButton">
            <property name="enabled">
             <bool>true</bool>
            </property>
            <property name="toolTip">
             <string>Save parameters to json file</string>
            </property>
            <property name="text">
             <string>Save Parameters</string>
            </property>
            <property name="icon">
             <iconset resource="../../resources/QmitkTractography.qrc">
              <normaloff>:/QmitkTractography/download.png</normaloff>:/QmitkTractography/download.png</iconset>
            </property>
           </widget>
          </item>
          <item row="0" column="0">
           <widget class="QCommandLinkButton" name="m_LoadParametersButton">
            <property name="enabled">
             <bool>true</bool>
            </property>
            <property name="toolTip">
             <string>Load parameters from json file</string>
            </property>
            <property name="text">
             <string>Load Parameters</string>
            </property>
            <property name="icon">
             <iconset resource="../../resources/QmitkTractography.qrc">
              <normaloff>:/QmitkTractography/upload.png</normaloff>:/QmitkTractography/upload.png</iconset>
            </property>
           </widget>
          </item>
         </layout>
        </widget>
       </item>
       <item row="3" column="0">
        <widget class="QCommandLinkButton" name="commandLinkButton">
         <property name="enabled">
          <bool>false</bool>
         </property>
         <property name="text">
          <string>Start Tractography</string>
         </property>
         <property name="icon">
          <iconset resource="../../resources/QmitkTractography.qrc">
           <normaloff>:/QmitkTractography/right.png</normaloff>:/QmitkTractography/right.png</iconset>
         </property>
        </widget>
       </item>
       <item row="2" column="0">
        <widget class="QCommandLinkButton" name="commandLinkButton_2">
         <property name="enabled">
          <bool>true</bool>
         </property>
         <property name="toolTip">
          <string>Stop tractography and return all fibers reconstructed until now.</string>
         </property>
         <property name="text">
          <string>Stop Tractography</string>
         </property>
         <property name="icon">
          <iconset resource="../../resources/QmitkTractography.qrc">
           <normaloff>:/QmitkTractography/stop.png</normaloff>:/QmitkTractography/stop.png</iconset>
         </property>
        </widget>
       </item>
       <item row="0" column="0">
        <widget class="QFrame" name="frame_9">
         <property name="frameShape">
          <enum>QFrame::NoFrame</enum>
         </property>
         <property name="frameShadow">
          <enum>QFrame::Raised</enum>
         </property>
         <layout class="QGridLayout" name="gridLayout_19">
          <property name="leftMargin">
           <number>0</number>
          </property>
          <property name="topMargin">
           <number>0</number>
          </property>
          <property name="rightMargin">
           <number>0</number>
          </property>
          <property name="bottomMargin">
           <number>0</number>
          </property>
          <item row="0" column="0">
           <widget class="QLabel" name="label_2">
            <property name="toolTip">
             <string>Input Image. ODF, tensor and peak images are currently supported.</string>
            </property>
            <property name="text">
             <string>Input Image:</string>
            </property>
           </widget>
          </item>
          <item row="0" column="1">
           <widget class="QLabel" name="m_TensorImageLabel">
            <property name="toolTip">
             <string>Input Image. ODF, tensor, peak, and, in case of ML tractography, raw diffusion-weighted images are currently supported.</string>
            </property>
            <property name="text">
             <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;&lt;span style=&quot; color:#ff0000;&quot;&gt;select image in data-manager&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
            </property>
            <property name="wordWrap">
             <bool>true</bool>
            </property>
           </widget>
          </item>
          <item row="1" column="0">
           <widget class="QLabel" name="m_ForestLabel">
            <property name="toolTip">
             <string/>
            </property>
            <property name="text">
             <string>Tractography Forest:</string>
            </property>
           </widget>
          </item>
          <item row="1" column="1">
           <widget class="QmitkSingleNodeSelectionWidget" name="m_ForestSelectionWidget" native="true">
            <property name="styleSheet">
             <string notr="true"/>
            </property>
           </widget>
          </item>
         </layout>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item row="2" column="0" rowspan="6">
     <widget class="QToolBox" name="toolBox">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <property name="minimumSize">
       <size>
        <width>0</width>
        <height>0</height>
       </size>
      </property>
      <property name="font">
       <font>
        <weight>75</weight>
        <bold>true</bold>
       </font>
      </property>
      <property name="currentIndex">
       <number>0</number>
      </property>
      <widget class="QWidget" name="page_seed">
       <property name="geometry">
        <rect>
         <x>0</x>
         <y>0</y>
         <width>421</width>
         <height>254</height>
        </rect>
       </property>
       <attribute name="label">
        <string>Seeding</string>
       </attribute>
       <attribute name="toolTip">
        <string>Specify how, where and how many tractography seed points are placed.</string>
       </attribute>
       <layout class="QGridLayout" name="gridLayout_17">
        <item row="0" column="0">
         <widget class="QFrame" name="m_InteractiveSeedingFrame">
          <property name="frameShape">
           <enum>QFrame::NoFrame</enum>
          </property>
          <property name="frameShadow">
           <enum>QFrame::Raised</enum>
          </property>
          <layout class="QGridLayout" name="gridLayout_15">
           <property name="leftMargin">
            <number>0</number>
           </property>
           <property name="topMargin">
            <number>0</number>
           </property>
           <property name="rightMargin">
            <number>0</number>
           </property>
           <property name="bottomMargin">
            <number>0</number>
           </property>
           <item row="1" column="0">
            <widget class="QFrame" name="frame_7">
             <property name="frameShape">
              <enum>QFrame::NoFrame</enum>
             </property>
             <property name="frameShadow">
              <enum>QFrame::Raised</enum>
             </property>
             <layout class="QGridLayout" name="gridLayout_13">
              <property name="leftMargin">
               <number>0</number>
              </property>
              <property name="topMargin">
               <number>0</number>
              </property>
              <property name="rightMargin">
               <number>0</number>
              </property>
              <property name="bottomMargin">
               <number>0</number>
              </property>
              <item row="2" column="1">
               <widget class="QSpinBox" name="m_NumSeedsBox">
                <property name="toolTip">
                 <string>Number of seed points equally distributed around selected position. </string>
                </property>
                <property name="minimum">
                 <number>1</number>
                </property>
                <property name="maximum">
                 <number>9999999</number>
                </property>
                <property name="value">
                 <number>50</number>
                </property>
               </widget>
              </item>
              <item row="1" column="0">
               <widget class="QLabel" name="m_FaThresholdLabel_4">
                <property name="toolTip">
                 <string/>
                </property>
                <property name="text">
                 <string>Radius: </string>
                </property>
               </widget>
              </item>
              <item row="1" column="1">
               <widget class="QDoubleSpinBox" name="m_SeedRadiusBox">
                <property name="toolTip">
-                <string>Seedpoints are equally distributed within a sphere centered at the selected position with the specified radius (in mm).</string>
+                <string>Seedpoints are equally distributed within a sphere centered at the selected position with the specified radius  (in mm).</string>
                </property>
                <property name="decimals">
                 <number>2</number>
                </property>
                <property name="maximum">
                 <double>50.000000000000000</double>
                </property>
                <property name="singleStep">
                 <double>0.100000000000000</double>
                </property>
                <property name="value">
                 <double>2.000000000000000</double>
                </property>
               </widget>
              </item>
              <item row="2" column="0">
               <widget class="QLabel" name="m_SeedsPerVoxelLabel_4">
                <property name="toolTip">
                 <string/>
                </property>
                <property name="text">
                 <string>Num. Seeds:</string>
                </property>
               </widget>
              </item>
             </layout>
            </widget>
           </item>
           <item row="0" column="0">
            <widget class="QCheckBox" name="m_ParamUpdateBox">
             <property name="enabled">
              <bool>true</bool>
             </property>
             <property name="toolTip">
              <string>When checked, parameter changes cause instant retracking while in interactive mode.</string>
             </property>
             <property name="text">
              <string>Update on Parameter Change </string>
             </property>
             <property name="checked">
              <bool>true</bool>
             </property>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
        <item row="2" column="0">
         <widget class="QFrame" name="frame_8">
          <property name="frameShape">
           <enum>QFrame::NoFrame</enum>
          </property>
          <property name="frameShadow">
           <enum>QFrame::Raised</enum>
          </property>
          <layout class="QGridLayout" name="gridLayout_16">
           <property name="leftMargin">
            <number>0</number>
           </property>
           <property name="topMargin">
            <number>0</number>
           </property>
           <property name="rightMargin">
            <number>0</number>
           </property>
           <property name="bottomMargin">
            <number>0</number>
           </property>
           <item row="0" column="1">
            <widget class="QSpinBox" name="m_TrialsPerSeedBox">
             <property name="toolTip">
              <string>Try each seed N times until a valid streamline is obtained (only for probabilistic tractography).</string>
             </property>
             <property name="statusTip">
              <string>Minimum fiber length (in mm)</string>
             </property>
             <property name="minimum">
              <number>1</number>
             </property>
             <property name="maximum">
              <number>999</number>
             </property>
             <property name="value">
              <number>10</number>
             </property>
            </widget>
           </item>
           <item row="0" column="0">
            <widget class="QLabel" name="m_TrialsPerSeedLabel">
             <property name="toolTip">
              <string/>
             </property>
             <property name="text">
              <string>Trials Per Seed:</string>
             </property>
            </widget>
           </item>
           <item row="1" column="0">
            <widget class="QLabel" name="m_FaThresholdLabel_2">
             <property name="toolTip">
              <string/>
             </property>
             <property name="text">
              <string>Max. Num. Fibers:</string>
             </property>
            </widget>
           </item>
           <item row="1" column="1">
            <widget class="QSpinBox" name="m_NumFibersBox">
             <property name="toolTip">
              <string>Tractography is stopped after the desired number of fibers is reached, even before all seed points are processed (-1 means no limit).</string>
             </property>
             <property name="minimum">
              <number>-1</number>
             </property>
             <property name="maximum">
              <number>999999999</number>
             </property>
             <property name="value">
              <number>-1</number>
             </property>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
        <item row="1" column="0">
         <widget class="QFrame" name="m_StaticSeedingFrame">
          <property name="frameShape">
           <enum>QFrame::NoFrame</enum>
          </property>
          <property name="frameShadow">
           <enum>QFrame::Raised</enum>
          </property>
          <layout class="QGridLayout" name="gridLayout_2">
           <property name="leftMargin">
            <number>0</number>
           </property>
           <property name="topMargin">
            <number>0</number>
           </property>
           <property name="rightMargin">
            <number>0</number>
           </property>
           <property name="bottomMargin">
            <number>0</number>
           </property>
           <item row="2" column="0">
            <widget class="QLabel" name="m_SeedsPerVoxelLabel">
             <property name="toolTip">
              <string/>
             </property>
             <property name="text">
              <string>Seeds per Voxel:</string>
             </property>
            </widget>
           </item>
           <item row="0" column="0">
            <widget class="QLabel" name="label_6">
             <property name="toolTip">
              <string/>
             </property>
             <property name="text">
              <string>Seed Image:</string>
             </property>
            </widget>
           </item>
           <item row="2" column="1">
            <widget class="QSpinBox" name="m_SeedsPerVoxelBox">
             <property name="toolTip">
              <string>Number of seed points placed in each voxel.</string>
             </property>
             <property name="minimum">
              <number>1</number>
             </property>
             <property name="maximum">
              <number>9999999</number>
             </property>
            </widget>
           </item>
           <item row="0" column="1">
            <widget class="QmitkSingleNodeSelectionWidget" name="m_SeedImageSelectionWidget" native="true">
             <property name="styleSheet">
              <string notr="true"/>
             </property>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
        <item row="3" column="0">
         <widget class="QCheckBox" name="m_InteractiveBox">
          <property name="enabled">
           <bool>true</bool>
          </property>
          <property name="toolTip">
           <string>Dynamically pick a seed location by click into image.</string>
          </property>
          <property name="text">
           <string>Enable Interactive Tractography</string>
          </property>
         </widget>
        </item>
        <item row="4" column="0">
         <spacer name="verticalSpacer">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>40</height>
           </size>
          </property>
         </spacer>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="page_constraints">
       <property name="geometry">
        <rect>
         <x>0</x>
         <y>0</y>
         <width>435</width>
-        <height>181</height>
+        <height>184</height>
        </rect>
       </property>
       <attribute name="label">
        <string>ROI Constraints</string>
       </attribute>
       <attribute name="toolTip">
        <string>Specify various ROI and mask images to constrain the tractography process.</string>
       </attribute>
       <layout class="QGridLayout" name="gridLayout">
        <item row="0" column="0">
         <widget class="QLabel" name="label_7">
          <property name="toolTip">
           <string/>
          </property>
          <property name="text">
           <string>Mask Image:</string>
          </property>
         </widget>
        </item>
        <item row="3" column="1">
         <widget class="QComboBox" name="m_EpConstraintsBox">
          <property name="toolTip">
           <string>Select which fibers should be accepted or rejected based on the location of their endpoints.</string>
          </property>
          <property name="sizeAdjustPolicy">
           <enum>QComboBox::AdjustToMinimumContentsLength</enum>
          </property>
          <item>
           <property name="text">
            <string>No Constraints on EP locations</string>
           </property>
          </item>
          <item>
           <property name="text">
            <string>Both EPs in Target Image</string>
           </property>
          </item>
          <item>
           <property name="text">
            <string>Both EPs in Target Image But Different Label</string>
           </property>
          </item>
          <item>
           <property name="text">
            <string>One EP in Seed Image and One EP in Target Image</string>
           </property>
          </item>
          <item>
           <property name="text">
            <string>At Least One EP in Target Image</string>
           </property>
          </item>
          <item>
           <property name="text">
            <string>Exactly One EP in Target Image</string>
           </property>
          </item>
          <item>
           <property name="text">
            <string>No EP in Target Image</string>
           </property>
          </item>
         </widget>
        </item>
        <item row="3" column="0">
         <widget class="QLabel" name="label_10">
          <property name="toolTip">
           <string/>
          </property>
          <property name="text">
           <string>Endpoint Constraints:</string>
          </property>
         </widget>
        </item>
        <item row="1" column="0">
         <widget class="QLabel" name="label_9">
          <property name="toolTip">
           <string/>
          </property>
          <property name="text">
           <string>Stop ROI Image:</string>
          </property>
         </widget>
        </item>
        <item row="2" column="0">
         <widget class="QLabel" name="label_11">
          <property name="toolTip">
           <string/>
          </property>
          <property name="text">
           <string>Exclusion ROI Image:</string>
          </property>
         </widget>
        </item>
        <item row="4" column="0">
         <widget class="QLabel" name="m_TargetImageLabel">
          <property name="toolTip">
           <string/>
          </property>
          <property name="text">
           <string>Target ROI Image:</string>
          </property>
         </widget>
        </item>
        <item row="6" column="0">
         <spacer name="verticalSpacer_6">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>40</height>
           </size>
          </property>
         </spacer>
        </item>
        <item row="0" column="1">
         <widget class="QmitkSingleNodeSelectionWidget" name="m_MaskImageSelectionWidget" native="true"/>
        </item>
        <item row="1" column="1">
         <widget class="QmitkSingleNodeSelectionWidget" name="m_StopImageSelectionWidget" native="true"/>
        </item>
        <item row="2" column="1">
         <widget class="QmitkSingleNodeSelectionWidget" name="m_ExclusionImageSelectionWidget" native="true"/>
        </item>
        <item row="4" column="1">
         <widget class="QmitkSingleNodeSelectionWidget" name="m_TargetImageSelectionWidget" native="true"/>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="page_trackingparam">
       <property name="geometry">
        <rect>
         <x>0</x>
-        <y>-191</y>
+        <y>-19</y>
         <width>421</width>
-        <height>428</height>
+        <height>436</height>
        </rect>
       </property>
       <attribute name="label">
        <string>Tractography Parameters</string>
       </attribute>
       <attribute name="toolTip">
        <string>Specify the behavior of the tractography at each streamline integration step (step size, deterministic/probabilistic, ...).</string>
       </attribute>
       <layout class="QGridLayout" name="gridLayout_14">
        <item row="8" column="1">
         <widget class="QDoubleSpinBox" name="m_MinTractLengthBox">
          <property name="toolTip">
           <string>Minimum tract length in mm. Shorter fibers are discarded.</string>
          </property>
          <property name="statusTip">
           <string>Minimum fiber length (in mm)</string>
          </property>
          <property name="decimals">
           <number>1</number>
          </property>
          <property name="maximum">
           <double>999.000000000000000</double>
          </property>
          <property name="singleStep">
           <double>1.000000000000000</double>
          </property>
          <property name="value">
           <double>20.000000000000000</double>
          </property>
         </widget>
        </item>
        <item row="12" column="0">
         <widget class="QLabel" name="m_fLabel">
          <property name="toolTip">
           <string>f parameter of tensor tractography. f=1 + g=0 means FACT (depending on the chosen interpolation). f=0 and g=1 means TEND (disable interpolation for this mode!).</string>
          </property>
          <property name="text">
           <string>f:</string>
          </property>
         </widget>
        </item>
        <item row="13" column="1">
         <widget class="QDoubleSpinBox" name="m_gBox">
          <property name="toolTip">
           <string>f=1 + g=0 means FACT (depending on the chosen interpolation). f=0 and g=1 means TEND (disable interpolation for this mode!).</string>
          </property>
          <property name="decimals">
           <number>2</number>
          </property>
          <property name="maximum">
           <double>1.000000000000000</double>
          </property>
          <property name="singleStep">
           <double>0.100000000000000</double>
          </property>
          <property name="value">
           <double>0.000000000000000</double>
          </property>
         </widget>
        </item>
        <item row="2" column="0">
         <widget class="QLabel" name="m_FaThresholdLabel_5">
          <property name="toolTip">
           <string/>
          </property>
          <property name="text">
           <string>Sharpen ODFs:</string>
          </property>
         </widget>
        </item>
        <item row="15" column="0">
         <widget class="QLabel" name="m_FaThresholdLabel_6">
          <property name="toolTip">
           <string/>
          </property>
          <property name="text">
           <string>Fix Random Seed:</string>
          </property>
         </widget>
        </item>
        <item row="11" column="1">
         <widget class="QSpinBox" name="m_LoopCheckBox">
          <property name="toolTip">
           <string>Maximum allowed angular SDTEV over 4 voxel lengths. Default: 30°</string>
          </property>
          <property name="statusTip">
           <string/>
          </property>
          <property name="minimum">
           <number>-1</number>
          </property>
          <property name="maximum">
           <number>180</number>
          </property>
          <property name="value">
           <number>30</number>
          </property>
         </widget>
        </item>
        <item row="10" column="0">
         <widget class="QLabel" name="m_AngularThresholdLabel">
          <property name="toolTip">
           <string/>
          </property>
          <property name="text">
           <string>Angular Threshold:</string>
          </property>
         </widget>
        </item>
        <item row="9" column="0">
         <widget class="QLabel" name="m_MinTractLengthLabel_2">
          <property name="toolTip">
           <string/>
          </property>
          <property name="text">
           <string>Max. Tract Length:</string>
          </property>
         </widget>
        </item>
        <item row="3" column="0">
         <widget class="QLabel" name="m_FaThresholdLabel">
          <property name="toolTip">
           <string/>
          </property>
          <property name="text">
           <string>Cutoff:</string>
          </property>
         </widget>
        </item>
-       <item row="2" column="1">
-        <widget class="QCheckBox" name="m_SharpenOdfsBox">
-         <property name="toolTip">
-          <string>If you are using dODF images as input, it is advisable to sharpen the ODFs (min-max normalize and raise to the power of 4). This is not necessary for CSD fODFs, since they are naturally much sharper.</string>
-         </property>
-         <property name="text">
-          <string/>
-         </property>
-        </widget>
-       </item>
        <item row="10" column="1">
         <widget class="QSpinBox" name="m_AngularThresholdBox">
          <property name="toolTip">
           <string>Angular threshold between two steps (in degree). Default: 90° * step_size</string>
          </property>
          <property name="minimum">
           <number>-1</number>
          </property>
          <property name="maximum">
           <number>90</number>
          </property>
          <property name="singleStep">
           <number>1</number>
          </property>
          <property name="value">
           <number>-1</number>
          </property>
         </widget>
        </item>
        <item row="16" column="0">
         <spacer name="verticalSpacer_2">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>40</height>
           </size>
          </property>
         </spacer>
        </item>
        <item row="12" column="1">
         <widget class="QDoubleSpinBox" name="m_fBox">
          <property name="toolTip">
           <string>f=1 + g=0 means FACT (depending on the chosen interpolation). f=0 and g=1 means TEND (disable interpolation for this mode!).</string>
          </property>
          <property name="decimals">
           <number>2</number>
          </property>
          <property name="maximum">
           <double>1.000000000000000</double>
          </property>
          <property name="singleStep">
           <double>0.100000000000000</double>
          </property>
          <property name="value">
           <double>1.000000000000000</double>
          </property>
         </widget>
        </item>
        <item row="1" column="1">
         <widget class="QComboBox" name="m_ModeBox">
          <property name="toolTip">
           <string>Toggle between deterministic and probabilistic tractography. Some modes might not be available for all types of tractography.</string>
          </property>
          <item>
           <property name="text">
            <string>Deterministic</string>
           </property>
          </item>
          <item>
           <property name="text">
            <string>Probabilistic</string>
           </property>
          </item>
         </widget>
        </item>
        <item row="1" column="0">
         <widget class="QLabel" name="m_FaThresholdLabel_3">
          <property name="toolTip">
           <string/>
          </property>
          <property name="text">
           <string>Mode:</string>
          </property>
         </widget>
        </item>
        <item row="5" column="1">
         <widget class="QDoubleSpinBox" name="m_OdfCutoffBox">
          <property name="toolTip">
           <string>Additional threshold on the ODF magnitude. This is useful in case of CSD fODF tractography. For fODFs a good default value is 0.1, for normalized dODFs, e.g. Q-ball ODFs, this threshold should be very low (0.00025) or 0.</string>
          </property>
          <property name="decimals">
           <number>5</number>
          </property>
          <property name="maximum">
           <double>1.000000000000000</double>
          </property>
          <property name="singleStep">
           <double>0.100000000000000</double>
          </property>
          <property name="value">
           <double>0.000250000000000</double>
          </property>
         </widget>
        </item>
        <item row="8" column="0">
         <widget class="QLabel" name="m_MinTractLengthLabel">
          <property name="toolTip">
           <string/>
          </property>
          <property name="text">
           <string>Min. Tract Length:</string>
          </property>
         </widget>
        </item>
        <item row="4" column="0">
         <widget class="QLabel" name="mFaImageLabel">
          <property name="toolTip">
           <string/>
          </property>
          <property name="text">
           <string>FA/GFA Image:</string>
          </property>
         </widget>
        </item>
        <item row="11" column="0">
         <widget class="QLabel" name="m_LoopCheckLabel">
          <property name="toolTip">
           <string/>
          </property>
          <property name="text">
           <string>Loop Check:</string>
          </property>
         </widget>
        </item>
        <item row="9" column="1">
         <widget class="QDoubleSpinBox" name="m_MaxTractLengthBox">
          <property name="toolTip">
           <string>Minimum tract length in mm. Shorter fibers are discarded.</string>
          </property>
          <property name="statusTip">
           <string>Maximum fiber length (in mm)</string>
          </property>
          <property name="decimals">
           <number>1</number>
          </property>
          <property name="maximum">
           <double>999.000000000000000</double>
          </property>
          <property name="singleStep">
           <double>1.000000000000000</double>
          </property>
          <property name="value">
           <double>400.000000000000000</double>
          </property>
         </widget>
        </item>
        <item row="15" column="1">
         <widget class="QCheckBox" name="m_FixSeedBox">
          <property name="toolTip">
           <string>Always produce the same random numbers.</string>
          </property>
          <property name="text">
           <string/>
          </property>
         </widget>
        </item>
        <item row="6" column="0">
         <widget class="QLabel" name="m_StepsizeLabel">
          <property name="toolTip">
           <string/>
          </property>
          <property name="text">
           <string>Step Size:</string>
          </property>
         </widget>
        </item>
        <item row="5" column="0">
         <widget class="QLabel" name="m_OdfCutoffLabel">
          <property name="toolTip">
           <string/>
          </property>
          <property name="text">
           <string>ODF Cutoff:</string>
          </property>
         </widget>
        </item>
        <item row="6" column="1">
         <widget class="QDoubleSpinBox" name="m_StepSizeBox">
          <property name="toolTip">
           <string>Step size (in voxels)</string>
          </property>
          <property name="decimals">
           <number>2</number>
          </property>
          <property name="minimum">
           <double>0.010000000000000</double>
          </property>
          <property name="maximum">
           <double>10.000000000000000</double>
          </property>
          <property name="singleStep">
           <double>0.100000000000000</double>
          </property>
          <property name="value">
           <double>0.500000000000000</double>
          </property>
         </widget>
        </item>
        <item row="13" column="0">
         <widget class="QLabel" name="m_gLabel">
          <property name="toolTip">
           <string/>
          </property>
          <property name="text">
           <string>g:</string>
          </property>
         </widget>
        </item>
        <item row="4" column="1">
         <widget class="QmitkSingleNodeSelectionWidget" name="m_FaImageSelectionWidget" native="true"/>
        </item>
        <item row="3" column="1">
         <widget class="QDoubleSpinBox" name="m_ScalarThresholdBox">
          <property name="toolTip">
           <string>Threshold on peak magnitude, FA, GFA, ...</string>
          </property>
          <property name="decimals">
           <number>5</number>
          </property>
          <property name="maximum">
           <double>1.000000000000000</double>
          </property>
          <property name="singleStep">
           <double>0.100000000000000</double>
          </property>
          <property name="value">
           <double>0.100000000000000</double>
          </property>
         </widget>
        </item>
        <item row="14" column="0">
         <widget class="QLabel" name="m_PeakJitterLabel">
          <property name="toolTip">
           <string/>
          </property>
          <property name="text">
           <string>Peak Jitter:</string>
          </property>
         </widget>
        </item>
        <item row="14" column="1">
         <widget class="QDoubleSpinBox" name="m_PeakJitterBox">
          <property name="toolTip">
           <string>Important for probabilistic peak tractography and peak prior. Actual jitter is drawn from a normal distribution with peak_jitter*fabs(direction_value) as standard deviation.</string>
          </property>
          <property name="decimals">
           <number>3</number>
          </property>
          <property name="maximum">
           <double>1.000000000000000</double>
          </property>
          <property name="singleStep">
           <double>0.100000000000000</double>
          </property>
          <property name="value">
           <double>0.010000000000000</double>
          </property>
         </widget>
        </item>
+       <item row="2" column="1">
+        <widget class="QSpinBox" name="m_SharpenOdfsBox">
+         <property name="toolTip">
+          <string>Rais ODF to the power of X</string>
+         </property>
+         <property name="minimum">
+          <number>1</number>
+         </property>
+         <property name="value">
+          <number>8</number>
+         </property>
+        </widget>
+       </item>
       </layout>
      </widget>
      <widget class="QWidget" name="page_prior">
       <property name="geometry">
        <rect>
         <x>0</x>
         <y>0</y>
         <width>435</width>
-        <height>181</height>
+        <height>184</height>
        </rect>
       </property>
       <attribute name="label">
        <string>Tractography Prior</string>
       </attribute>
       <layout class="QGridLayout" name="gridLayout_9">
        <item row="1" column="0">
         <widget class="QLabel" name="m_PriorLabel_2">
          <property name="text">
           <string>Weight:</string>
          </property>
         </widget>
        </item>
        <item row="1" column="1">
         <widget class="QDoubleSpinBox" name="m_PriorWeightBox">
          <property name="toolTip">
           <string>Weighting factor between prior and data.</string>
          </property>
          <property name="maximum">
           <double>1.000000000000000</double>
          </property>
          <property name="singleStep">
           <double>0.100000000000000</double>
          </property>
          <property name="value">
           <double>0.500000000000000</double>
          </property>
         </widget>
        </item>
        <item row="0" column="0">
         <widget class="QLabel" name="m_PriorLabel">
          <property name="text">
           <string>Peak Image:</string>
          </property>
         </widget>
        </item>
        <item row="5" column="0">
         <spacer name="verticalSpacer_7">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>40</height>
           </size>
          </property>
         </spacer>
        </item>
        <item row="3" column="1">
         <widget class="QCheckBox" name="m_NewDirectionsFromPriorBox">
          <property name="toolTip">
           <string>If unchecked, the prior cannot create directions where there are none in the data.</string>
          </property>
          <property name="text">
           <string/>
          </property>
          <property name="checked">
           <bool>true</bool>
          </property>
         </widget>
        </item>
        <item row="3" column="0">
         <widget class="QLabel" name="m_PriorLabel_4">
          <property name="text">
           <string>New Directions from Prior:</string>
          </property>
         </widget>
        </item>
        <item row="2" column="0">
         <widget class="QLabel" name="m_PriorLabel_3">
          <property name="text">
           <string>Restrict to Prior:</string>
          </property>
         </widget>
        </item>
        <item row="0" column="1">
         <widget class="QmitkSingleNodeSelectionWidget" name="m_PriorImageSelectionWidget" native="true"/>
        </item>
        <item row="2" column="1">
         <widget class="QCheckBox" name="m_PriorAsMaskBox">
          <property name="toolTip">
           <string>Restrict tractography to regions where the prior is valid.</string>
          </property>
          <property name="text">
           <string/>
          </property>
          <property name="checked">
           <bool>true</bool>
          </property>
         </widget>
        </item>
        <item row="4" column="1">
         <widget class="QFrame" name="frame_10">
          <property name="frameShape">
           <enum>QFrame::NoFrame</enum>
          </property>
          <property name="frameShadow">
           <enum>QFrame::Raised</enum>
          </property>
          <layout class="QGridLayout" name="gridLayout_20">
           <property name="leftMargin">
            <number>0</number>
           </property>
           <property name="topMargin">
            <number>0</number>
           </property>
           <property name="rightMargin">
            <number>0</number>
           </property>
           <property name="bottomMargin">
            <number>0</number>
           </property>
           <property name="spacing">
            <number>0</number>
           </property>
           <item row="0" column="1">
            <widget class="QCheckBox" name="m_PriorFlipYBox">
             <property name="text">
              <string>y</string>
             </property>
            </widget>
           </item>
           <item row="0" column="0">
            <widget class="QCheckBox" name="m_PriorFlipXBox">
             <property name="text">
              <string>x</string>
             </property>
            </widget>
           </item>
           <item row="0" column="2">
            <widget class="QCheckBox" name="m_PriorFlipZBox">
             <property name="text">
              <string>z</string>
             </property>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
        <item row="4" column="0">
         <widget class="QLabel" name="m_PriorLabel_5">
          <property name="text">
           <string>Flip Directions:</string>
          </property>
         </widget>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="page_neighborhood">
       <property name="geometry">
        <rect>
         <x>0</x>
         <y>0</y>
         <width>435</width>
-        <height>181</height>
+        <height>184</height>
        </rect>
       </property>
       <attribute name="label">
        <string>Neighborhood Sampling</string>
       </attribute>
       <attribute name="toolTip">
        <string>Specify if and how information about the current streamline neighborhood should be used.</string>
       </attribute>
       <layout class="QGridLayout" name="gridLayout_18">
        <item row="1" column="0">
         <widget class="QCheckBox" name="m_FrontalSamplesBox">
          <property name="toolTip">
           <string>Only neighborhood samples in front of the current streamline position are considered.</string>
          </property>
          <property name="text">
           <string>Use Only Frontal Samples</string>
          </property>
          <property name="checked">
           <bool>false</bool>
          </property>
         </widget>
        </item>
        <item row="2" column="0">
         <widget class="QCheckBox" name="m_StopVotesBox">
          <property name="toolTip">
           <string>If checked, the majority of sampling points has to place a stop-vote for the streamline to terminate. If not checked, all sampling positions have to vote for a streamline termination.</string>
          </property>
          <property name="text">
           <string>Use Stop-Votes</string>
          </property>
          <property name="checked">
           <bool>false</bool>
          </property>
         </widget>
        </item>
        <item row="0" column="0">
         <widget class="QFrame" name="frame_4">
          <property name="frameShape">
           <enum>QFrame::NoFrame</enum>
          </property>
          <property name="frameShadow">
           <enum>QFrame::Raised</enum>
          </property>
          <layout class="QGridLayout" name="gridLayout_10">
           <property name="leftMargin">
            <number>0</number>
           </property>
           <property name="topMargin">
            <number>0</number>
           </property>
           <property name="rightMargin">
            <number>0</number>
           </property>
           <property name="bottomMargin">
            <number>0</number>
           </property>
           <item row="0" column="0">
            <widget class="QLabel" name="m_SeedsPerVoxelLabel_2">
             <property name="toolTip">
              <string/>
             </property>
             <property name="text">
              <string>Num. Samples:</string>
             </property>
            </widget>
           </item>
           <item row="0" column="1">
            <widget class="QSpinBox" name="m_NumSamplesBox">
             <property name="toolTip">
              <string>Number of neighborhood samples that are used to determine the next fiber progression direction.</string>
             </property>
             <property name="maximum">
              <number>50</number>
             </property>
            </widget>
           </item>
           <item row="1" column="0">
            <widget class="QLabel" name="m_SamplingDistanceLabel">
             <property name="toolTip">
              <string/>
             </property>
             <property name="text">
              <string>Sampling Distance:</string>
             </property>
            </widget>
           </item>
           <item row="1" column="1">
            <widget class="QDoubleSpinBox" name="m_SamplingDistanceBox">
             <property name="toolTip">
              <string>Sampling distance (in voxels)</string>
             </property>
             <property name="decimals">
              <number>2</number>
             </property>
             <property name="maximum">
              <double>10.000000000000000</double>
             </property>
             <property name="singleStep">
              <double>0.100000000000000</double>
             </property>
             <property name="value">
              <double>0.250000000000000</double>
             </property>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
        <item row="3" column="0">
         <spacer name="verticalSpacer_3">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>40</height>
           </size>
          </property>
         </spacer>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="page_data">
       <property name="geometry">
        <rect>
         <x>0</x>
         <y>0</y>
         <width>435</width>
-        <height>181</height>
+        <height>184</height>
        </rect>
       </property>
       <attribute name="label">
        <string>Data Handling</string>
       </attribute>
       <attribute name="toolTip">
        <string>Specify interpolation and direction flips.</string>
       </attribute>
       <layout class="QGridLayout" name="gridLayout_6">
        <item row="1" column="0">
         <widget class="QFrame" name="frame_3">
          <property name="frameShape">
           <enum>QFrame::NoFrame</enum>
          </property>
          <property name="frameShadow">
           <enum>QFrame::Raised</enum>
          </property>
          <layout class="QGridLayout" name="gridLayout_7">
           <property name="leftMargin">
            <number>0</number>
           </property>
           <property name="topMargin">
            <number>0</number>
           </property>
           <property name="rightMargin">
            <number>0</number>
           </property>
           <property name="bottomMargin">
            <number>0</number>
           </property>
           <item row="0" column="0">
            <widget class="QCheckBox" name="m_InterpolationBox">
             <property name="toolTip">
              <string>Trilinearly interpolate the input image used for tractography.</string>
             </property>
             <property name="text">
              <string>Interpolate Tractography Data</string>
             </property>
             <property name="checked">
              <bool>true</bool>
             </property>
            </widget>
           </item>
           <item row="1" column="0">
            <widget class="QCheckBox" name="m_MaskInterpolationBox">
             <property name="toolTip">
              <string>Trilinearly interpolate the ROI images used to constrain the tractography.</string>
             </property>
             <property name="text">
              <string>Interpolate ROI Images</string>
             </property>
             <property name="checked">
              <bool>true</bool>
             </property>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
        <item row="0" column="0">
         <widget class="QFrame" name="frame_2">
          <property name="frameShape">
           <enum>QFrame::NoFrame</enum>
          </property>
          <property name="frameShadow">
           <enum>QFrame::Raised</enum>
          </property>
          <layout class="QGridLayout" name="gridLayout_3">
           <property name="leftMargin">
            <number>0</number>
           </property>
           <property name="topMargin">
            <number>0</number>
           </property>
           <property name="rightMargin">
            <number>0</number>
           </property>
           <property name="bottomMargin">
            <number>0</number>
           </property>
           <item row="7" column="1">
            <widget class="QFrame" name="frame">
             <property name="frameShape">
              <enum>QFrame::NoFrame</enum>
             </property>
             <property name="frameShadow">
              <enum>QFrame::Raised</enum>
             </property>
             <layout class="QGridLayout" name="gridLayout_4">
              <property name="leftMargin">
               <number>0</number>
              </property>
              <property name="topMargin">
               <number>0</number>
              </property>
              <property name="rightMargin">
               <number>0</number>
              </property>
              <property name="bottomMargin">
               <number>0</number>
              </property>
              <item row="0" column="0">
               <widget class="QCheckBox" name="m_FlipXBox">
                <property name="toolTip">
                 <string>Internally flips progression directions. This might be necessary depending on the input data.</string>
                </property>
                <property name="text">
                 <string>x</string>
                </property>
               </widget>
              </item>
              <item row="0" column="1">
               <widget class="QCheckBox" name="m_FlipYBox">
                <property name="toolTip">
                 <string>Internally flips progression directions. This might be necessary depending on the input data.</string>
                </property>
                <property name="text">
                 <string>y</string>
                </property>
               </widget>
              </item>
              <item row="0" column="2">
               <widget class="QCheckBox" name="m_FlipZBox">
                <property name="toolTip">
                 <string>Internally flips progression directions. This might be necessary depending on the input data.</string>
                </property>
                <property name="text">
                 <string>z</string>
                </property>
               </widget>
              </item>
             </layout>
            </widget>
           </item>
           <item row="7" column="0">
            <widget class="QLabel" name="m_SeedsPerVoxelLabel_3">
             <property name="toolTip">
              <string/>
             </property>
             <property name="text">
              <string>Flip directions:</string>
             </property>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
        <item row="2" column="0">
         <spacer name="verticalSpacer_4">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>40</height>
           </size>
          </property>
         </spacer>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="page_output">
       <property name="geometry">
        <rect>
         <x>0</x>
         <y>0</y>
         <width>435</width>
-        <height>181</height>
+        <height>184</height>
        </rect>
       </property>
       <attribute name="label">
        <string>Output and Postprocessing</string>
       </attribute>
       <attribute name="toolTip">
        <string>Specify the tractography output (streamlines or probability maps) and postprocessing steps.</string>
       </attribute>
       <layout class="QGridLayout" name="gridLayout_5">
        <item row="3" column="0">
         <spacer name="verticalSpacer_5">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>40</height>
           </size>
          </property>
         </spacer>
        </item>
        <item row="1" column="0">
         <widget class="QCheckBox" name="m_ResampleFibersBox">
          <property name="toolTip">
           <string>Compress fibers using the specified error constraint.</string>
          </property>
          <property name="text">
           <string>Compress Fibers</string>
          </property>
          <property name="checked">
           <bool>true</bool>
          </property>
         </widget>
        </item>
        <item row="2" column="0">
         <widget class="QCheckBox" name="m_OutputProbMap">
          <property name="toolTip">
           <string>Output map with voxel-wise visitation counts instead of streamlines.</string>
          </property>
          <property name="text">
           <string>Output Probability Map</string>
          </property>
          <property name="checked">
           <bool>false</bool>
          </property>
         </widget>
        </item>
       </layout>
      </widget>
     </widget>
    </item>
   </layout>
  </widget>
  <layoutdefault spacing="6" margin="11"/>
  <customwidgets>
   <customwidget>
    <class>QmitkSingleNodeSelectionWidget</class>
    <extends>QWidget</extends>
    <header>QmitkSingleNodeSelectionWidget.h</header>
    <container>1</container>
   </customwidget>
  </customwidgets>
  <resources>
   <include location="../../resources/QmitkTractography.qrc"/>
  </resources>
  <connections/>
 </ui>