diff --git a/Modules/DiffusionImaging/DiffusionCmdApps/Tractography/StreamlineTractography.cpp b/Modules/DiffusionImaging/DiffusionCmdApps/Tractography/StreamlineTractography.cpp
index aa83634e1f..bf00ae0999 100755
--- a/Modules/DiffusionImaging/DiffusionCmdApps/Tractography/StreamlineTractography.cpp
+++ b/Modules/DiffusionImaging/DiffusionCmdApps/Tractography/StreamlineTractography.cpp
@@ -1,554 +1,561 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include <mitkBaseData.h>
 #include <mitkImageCast.h>
 #include <mitkImageToItk.h>
 #include <metaCommand.h>
 #include <mitkCommandLineParser.h>
 #include <mitkLog.h>
 #include <usAny.h>
 #include <mitkIOUtil.h>
 #include <iostream>
 #include <fstream>
 #include <itksys/SystemTools.hxx>
 #include <mitkCoreObjectFactory.h>
 #include <omp.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[])
 {
   mitkCommandLineParser 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", mitkCommandLineParser::StringList, "Input:", "input image (multiple possible for 'DetTensor' algorithm)", us::Any(), false, false, false, mitkCommandLineParser::Input);
   parser.addArgument("", "o", mitkCommandLineParser::String, "Output:", "output fiberbundle/probability map", us::Any(), false, false, false, mitkCommandLineParser::Output);
   parser.addArgument("type", "", mitkCommandLineParser::String, "Type:", "which tracker to use (Peaks; Tensor; ODF; RF)", us::Any(), false);
   parser.addArgument("probabilistic", "", mitkCommandLineParser::Bool, "Probabilistic:", "Probabilistic tractography", us::Any(false));
   parser.endGroup();
 
   parser.beginGroup("2. Seeding:");
   parser.addArgument("seeds", "", mitkCommandLineParser::Int, "Seeds per voxel:", "number of seed points per voxel", 1);
   parser.addArgument("seed_image", "", mitkCommandLineParser::String, "Seed image:", "mask image defining seed voxels", us::Any(), true, false, false, mitkCommandLineParser::Input);
   parser.addArgument("trials_per_seed", "", mitkCommandLineParser::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", "", mitkCommandLineParser::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", "", mitkCommandLineParser::String, "Mask image:", "streamlines leaving the mask will stop immediately", us::Any(), true, false, false, mitkCommandLineParser::Input);
   parser.addArgument("stop_image", "", mitkCommandLineParser::String, "Stop ROI image:", "streamlines entering the mask will stop immediately", us::Any(), true, false, false, mitkCommandLineParser::Input);
   parser.addArgument("exclusion_image", "", mitkCommandLineParser::String, "Exclusion ROI image:", "streamlines entering the mask will be discarded", us::Any(), true, false, false, mitkCommandLineParser::Input);
   parser.addArgument("ep_constraint", "", mitkCommandLineParser::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", "", mitkCommandLineParser::String, "Target ROI image:", "effact depends on the chosen endpoint constraint (option ep_constraint)", us::Any(), true, false, false, mitkCommandLineParser::Input);
   parser.endGroup();
 
   parser.beginGroup("4. Streamline integration parameters:");
   parser.addArgument("sharpen_odfs", "", mitkCommandLineParser::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("cutoff", "", mitkCommandLineParser::Float, "Cutoff:", "set the FA, GFA or Peak amplitude cutoff for terminating tracks", 0.1);
   parser.addArgument("odf_cutoff", "", mitkCommandLineParser::Float, "ODF Cutoff:", "threshold on the ODF magnitude. this is useful in case of CSD fODF tractography.", 0.0);
   parser.addArgument("step_size", "", mitkCommandLineParser::Float, "Step size:", "step size (in voxels)", 0.5);
   parser.addArgument("min_tract_length", "", mitkCommandLineParser::Float, "Min. tract length:", "minimum fiber length (in mm)", 20);
   parser.addArgument("angular_threshold", "", mitkCommandLineParser::Float, "Angular threshold:", "angular threshold between two successive steps, (default: 90° * step_size, minimum 15°)");
   parser.addArgument("loop_check", "", mitkCommandLineParser::Float, "Check for loops:", "threshold on angular stdev over the last 4 voxel lengths");
   parser.endGroup();
 
   parser.beginGroup("5. Tractography prior:");
   parser.addArgument("prior_image", "", mitkCommandLineParser::String, "Peak prior:", "tractography prior in thr for of a peak image", us::Any(), true, false, false, mitkCommandLineParser::Input);
   parser.addArgument("prior_weight", "", mitkCommandLineParser::Float, "Prior weight", "weighting factor between prior and data.", 0.5);
   parser.addArgument("dont_restrict_to_prior", "", mitkCommandLineParser::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", "", mitkCommandLineParser::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", "", mitkCommandLineParser::Bool, "Prior Flip X:", "multiply x-coordinate of prior direction by -1");
   parser.addArgument("prior_flip_y", "", mitkCommandLineParser::Bool, "Prior Flip Y:", "multiply y-coordinate of prior direction by -1");
   parser.addArgument("prior_flip_z", "", mitkCommandLineParser::Bool, "Prior Flip Z:", "multiply z-coordinate of prior direction by -1");
   parser.endGroup();
 
   parser.beginGroup("6. Neighborhood sampling:");
   parser.addArgument("num_samples", "", mitkCommandLineParser::Int, "Num. neighborhood samples:", "number of neighborhood samples that are use to determine the next progression direction", 0);
   parser.addArgument("sampling_distance", "", mitkCommandLineParser::Float, "Sampling distance:", "distance of neighborhood sampling points (in voxels)", 0.25);
   parser.addArgument("use_stop_votes", "", mitkCommandLineParser::Bool, "Use stop votes:", "use stop votes");
   parser.addArgument("use_only_forward_samples", "", mitkCommandLineParser::Bool, "Use only forward samples:", "use only forward samples");
   parser.endGroup();
 
   parser.beginGroup("7. Tensor tractography specific:");
   parser.addArgument("tend_f", "", mitkCommandLineParser::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", "", mitkCommandLineParser::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", "", mitkCommandLineParser::String, "Forest:", "input random forest (HDF5 file)", us::Any(), true, false, false, mitkCommandLineParser::Input);
   parser.addArgument("use_sh_features", "", mitkCommandLineParser::Bool, "Use SH features:", "use SH features");
   parser.endGroup();
 
   parser.beginGroup("9. Additional input:");
   parser.addArgument("additional_images", "", mitkCommandLineParser::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, mitkCommandLineParser::Input);
   parser.endGroup();
 
   parser.beginGroup("10. Misc:");
   parser.addArgument("flip_x", "", mitkCommandLineParser::Bool, "Flip X:", "multiply x-coordinate of direction proposal by -1");
   parser.addArgument("flip_y", "", mitkCommandLineParser::Bool, "Flip Y:", "multiply y-coordinate of direction proposal by -1");
   parser.addArgument("flip_z", "", mitkCommandLineParser::Bool, "Flip Z:", "multiply z-coordinate of direction proposal by -1");
   parser.addArgument("no_data_interpolation", "", mitkCommandLineParser::Bool, "Don't interpolate input data:", "don't interpolate input image values");
   parser.addArgument("no_mask_interpolation", "", mitkCommandLineParser::Bool, "Don't interpolate masks:", "don't interpolate mask image values");
   parser.addArgument("compress", "", mitkCommandLineParser::Float, "Compress:", "compress output fibers using the given error threshold (in mm)");
   parser.addArgument("fix_seed", "", mitkCommandLineParser::Bool, "Fix Random Seed:", "always use the same random numbers");
+  parser.addArgument("parameter_file", "", mitkCommandLineParser::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, mitkCommandLineParser::Input);
   parser.endGroup();
 
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0)
     return EXIT_FAILURE;
 
   mitkCommandLineParser::StringContainerType input_files = us::any_cast<mitkCommandLineParser::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"]);
 
   params->m_RestrictToPrior = true;
   if (parsedArgs.count("dont_restrict_to_prior"))
     params->m_RestrictToPrior = !us::any_cast<bool>(parsedArgs["dont_restrict_to_prior"]);
 
   params->m_NewDirectionsFromPrior = true;
   if (parsedArgs.count("no_new_directions_from_prior"))
     params->m_NewDirectionsFromPrior = !us::any_cast<bool>(parsedArgs["no_new_directions_from_prior"]);
 
   params->m_SharpenOdfs = false;
   if (parsedArgs.count("sharpen_odfs"))
     params->m_SharpenOdfs = us::any_cast<bool>(parsedArgs["sharpen_odfs"]);
 
   params->m_InterpolateTractographyData = true;
   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"]);
 
   params->m_StopVotes = false;
   if (parsedArgs.count("use_stop_votes"))
     params->m_StopVotes = us::any_cast<bool>(parsedArgs["use_stop_votes"]);
 
   params->m_OnlyForwardSamples = false;
   if (parsedArgs.count("use_only_forward_samples"))
     params->m_OnlyForwardSamples = us::any_cast<bool>(parsedArgs["use_only_forward_samples"]);
 
   params->m_FlipX = false;
   if (parsedArgs.count("flip_x"))
     params->m_FlipX = us::any_cast<bool>(parsedArgs["flip_x"]);
   params->m_FlipY = false;
   if (parsedArgs.count("flip_y"))
     params->m_FlipY = us::any_cast<bool>(parsedArgs["flip_y"]);
   params->m_FlipZ = false;
   if (parsedArgs.count("flip_z"))
     params->m_FlipZ = us::any_cast<bool>(parsedArgs["flip_z"]);
 
   bool prior_flip_x = false;
   if (parsedArgs.count("prior_flip_x"))
     prior_flip_x = us::any_cast<bool>(parsedArgs["prior_flip_x"]);
   bool prior_flip_y = false;
   if (parsedArgs.count("prior_flip_y"))
     prior_flip_y = us::any_cast<bool>(parsedArgs["prior_flip_y"]);
   bool prior_flip_z = false;
   if (parsedArgs.count("prior_flip_z"))
     prior_flip_z = us::any_cast<bool>(parsedArgs["prior_flip_z"]);
 
   params->m_ApplyDirectionMatrix = false;
   if (parsedArgs.count("apply_image_rotation"))
     params->m_ApplyDirectionMatrix = us::any_cast<bool>(parsedArgs["apply_image_rotation"]);
 
   float compress = -1;
   if (parsedArgs.count("compress"))
     compress = us::any_cast<float>(parsedArgs["compress"]);
 
   params->m_MinTractLengthMm = 20;
   if (parsedArgs.count("min_tract_length"))
     params->m_MinTractLengthMm = us::any_cast<float>(parsedArgs["min_tract_length"]);
 
   params->SetLoopCheckDeg(-1);
   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"]);
 
   std::string ep_constraint = "NONE";
   if (parsedArgs.count("ep_constraint"))
     ep_constraint = us::any_cast<std::string>(parsedArgs["ep_constraint"]);
 
   params->m_Cutoff = 0.1f;
   if (parsedArgs.count("cutoff"))
     params->m_Cutoff = us::any_cast<float>(parsedArgs["cutoff"]);
 
   params->m_OdfCutoff = 0.0;
   if (parsedArgs.count("odf_cutoff"))
     params->m_OdfCutoff = us::any_cast<float>(parsedArgs["odf_cutoff"]);
 
   params->SetStepSizeVox(-1);
   if (parsedArgs.count("step_size"))
     params->SetStepSizeVox(us::any_cast<float>(parsedArgs["step_size"]));
 
   params->SetSamplingDistanceVox(-1);
   if (parsedArgs.count("sampling_distance"))
     params->SetSamplingDistanceVox(us::any_cast<float>(parsedArgs["sampling_distance"]));
 
   params->m_NumSamples = 0;
   if (parsedArgs.count("num_samples"))
     params->m_NumSamples = static_cast<unsigned int>(us::any_cast<int>(parsedArgs["num_samples"]));
 
   params->m_SeedsPerVoxel = 1;
   if (parsedArgs.count("seeds"))
     params->m_SeedsPerVoxel = us::any_cast<int>(parsedArgs["seeds"]);
 
   params->m_TrialsPerSeed = 10;
   if (parsedArgs.count("trials_per_seed"))
     params->m_TrialsPerSeed = static_cast<unsigned int>(us::any_cast<int>(parsedArgs["trials_per_seed"]));
 
   params->m_F = 1;
   if (parsedArgs.count("tend_f"))
     params->m_F = us::any_cast<float>(parsedArgs["tend_f"]);
 
   params->m_G = 0;
   if (parsedArgs.count("tend_g"))
     params->m_G = us::any_cast<float>(parsedArgs["tend_g"]);
 
   params->SetAngularThresholdDeg(-1);
   if (parsedArgs.count("angular_threshold"))
     params->SetAngularThresholdDeg(us::any_cast<float>(parsedArgs["angular_threshold"]));
 
   params->m_MaxNumFibers = -1;
   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
   mitkCommandLineParser::StringContainerType addFiles;
   if (parsedArgs.count("additional_images"))
     addFiles = us::any_cast<mitkCommandLineParser::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"}, {});
     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 = prior_flip_x;
     prior_params->m_FlipY = prior_flip_y;
     prior_params->m_FlipZ = prior_flip_z;
     prior_params->m_Cutoff = 0.0;
     dynamic_cast<mitk::TrackingHandlerPeaks*>(priorhandler)->SetPeakImage(itkImg);
     priorhandler->SetParameters(prior_params);
     tracker->SetTrackingPriorHandler(priorhandler);
   }
 
   mitk::TrackingDataHandler* handler;
   if (type == "RF")
   {
     mitk::TractographyForest::Pointer forest = mitk::IOUtil::Load<mitk::TractographyForest>(forestFile);
     if (forest.IsNull())
       mitkThrow() << "Forest file " << forestFile << " could not be read.";
 
     mitk::PreferenceListReaderOptionsFunctor functor = mitk::PreferenceListReaderOptionsFunctor({"Diffusion Weighted Images"}, {});
     auto input = mitk::IOUtil::Load<mitk::Image>(input_files.at(0), &functor);
 
     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));
     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));
       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 == "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));
       itkImg = mitk::convert::GetItkOdfFromTensorImage(input);
       dynamic_cast<mitk::TrackingHandlerOdf*>(handler)->SetIsOdfFromTensor(true);
     }
     else
     {
       mitk::PreferenceListReaderOptionsFunctor functor = mitk::PreferenceListReaderOptionsFunctor({"SH Image", "ODF Image"}, {});
       auto input = mitk::IOUtil::Load(input_files.at(0), &functor)[0];
       if (dynamic_cast<mitk::ShImage*>(input.GetPointer()))
       {
         MITK_INFO << "Converting SH to ODF image";
         mitk::Image::Pointer mitkImg = dynamic_cast<mitk::Image*>(input.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;
   }
 
   if (ep_constraint=="NONE")
     params->m_EpConstraints = itk::StreamlineTrackingFilter::EndpointConstraints::NONE;
   else if (ep_constraint=="EPS_IN_TARGET")
     params->m_EpConstraints = itk::StreamlineTrackingFilter::EndpointConstraints::EPS_IN_TARGET;
   else if (ep_constraint=="EPS_IN_TARGET_LABELDIFF")
     params->m_EpConstraints = itk::StreamlineTrackingFilter::EndpointConstraints::EPS_IN_TARGET_LABELDIFF;
   else if (ep_constraint=="EPS_IN_SEED_AND_TARGET")
     params->m_EpConstraints = itk::StreamlineTrackingFilter::EndpointConstraints::EPS_IN_SEED_AND_TARGET;
   else if (ep_constraint=="MIN_ONE_EP_IN_TARGET")
     params->m_EpConstraints = itk::StreamlineTrackingFilter::EndpointConstraints::MIN_ONE_EP_IN_TARGET;
   else if (ep_constraint=="ONE_EP_IN_TARGET")
     params->m_EpConstraints = itk::StreamlineTrackingFilter::EndpointConstraints::ONE_EP_IN_TARGET;
   else if (ep_constraint=="NO_EP_IN_TARGET")
     params->m_EpConstraints = itk::StreamlineTrackingFilter::EndpointConstraints::NO_EP_IN_TARGET;
 
   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 (compress > 0)
       outFib->Compress(compress);
     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/DiffusionImaging/FiberTracking/Algorithms/itkStreamlineTrackingFilter.cpp b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkStreamlineTrackingFilter.cpp
index b1efe2cb03..0884ca0f39 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkStreamlineTrackingFilter.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkStreamlineTrackingFilter.cpp
@@ -1,976 +1,976 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include <ctime>
 #include <cstdio>
 #include <cstdlib>
 
 #include <omp.h>
 #include "itkStreamlineTrackingFilter.h"
 #include <itkImageRegionConstIterator.h>
 #include <itkImageRegionConstIteratorWithIndex.h>
 #include <itkImageRegionIterator.h>
 #include "itkPointShell.h"
 #include <itkRescaleIntensityImageFilter.h>
 #include <mitkLexicalCast.h>
 #include <TrackingHandlers/mitkTrackingDataHandler.h>
 #include <TrackingHandlers/mitkTrackingHandlerOdf.h>
 #include <TrackingHandlers/mitkTrackingHandlerPeaks.h>
 #include <TrackingHandlers/mitkTrackingHandlerTensor.h>
 #include <TrackingHandlers/mitkTrackingHandlerRandomForest.h>
 #include <mitkDiffusionFunctionCollection.h>
 
 namespace itk {
 
 
 StreamlineTrackingFilter
 ::StreamlineTrackingFilter()
   : m_PauseTracking(false)
   , m_AbortTracking(false)
   , m_BuildFibersFinished(false)
   , m_BuildFibersReady(0)
   , m_FiberPolyData(nullptr)
   , m_Points(nullptr)
   , m_Cells(nullptr)
   , m_StoppingRegions(nullptr)
   , m_TargetRegions(nullptr)
   , m_SeedImage(nullptr)
   , m_MaskImage(nullptr)
   , m_ExclusionRegions(nullptr)
   , m_OutputProbabilityMap(nullptr)
   , m_Verbose(true)
   , m_DemoMode(false)
   , m_CurrentTracts(0)
   , m_Progress(0)
   , m_StopTracking(false)
   , m_TrackingPriorHandler(nullptr)
 {
   this->SetNumberOfRequiredInputs(0);
 }
 
 std::string StreamlineTrackingFilter::GetStatusText()
 {
   std::string status = "Seedpoints processed: " + boost::lexical_cast<std::string>(m_Progress) + "/" + boost::lexical_cast<std::string>(m_SeedPoints.size());
   if (m_SeedPoints.size()>0)
     status += " (" + boost::lexical_cast<std::string>(100*m_Progress/m_SeedPoints.size()) + "%)";
   if (m_Parameters->m_MaxNumFibers>0)
     status += "\nFibers accepted: " + boost::lexical_cast<std::string>(m_CurrentTracts) + "/" + boost::lexical_cast<std::string>(m_Parameters->m_MaxNumFibers);
   else
     status += "\nFibers accepted: " + boost::lexical_cast<std::string>(m_CurrentTracts);
 
   return status;
 }
 
 void StreamlineTrackingFilter::BeforeTracking()
 {
   m_StopTracking = false;
   m_TrackingHandler->SetParameters(m_Parameters);
   m_TrackingHandler->InitForTracking();
   m_FiberPolyData = PolyDataType::New();
   m_Points = vtkSmartPointer< vtkPoints >::New();
   m_Cells = vtkSmartPointer< vtkCellArray >::New();
 
   if (m_TrackingPriorHandler!=nullptr)
   {
     m_TrackingPriorHandler->InitForTracking();
   }
 
   m_PolyDataContainer.clear();
   for (unsigned int i=0; i<this->GetNumberOfThreads(); i++)
   {
     PolyDataType poly = PolyDataType::New();
     m_PolyDataContainer.push_back(poly);
   }
 
   auto imageSpacing = m_TrackingHandler->GetSpacing();
   if (m_Parameters->m_OutputProbMap)
   {
     m_OutputProbabilityMap = ItkDoubleImgType::New();
     m_OutputProbabilityMap->SetSpacing(imageSpacing);
     m_OutputProbabilityMap->SetOrigin(m_TrackingHandler->GetOrigin());
     m_OutputProbabilityMap->SetDirection(m_TrackingHandler->GetDirection());
     m_OutputProbabilityMap->SetRegions(m_TrackingHandler->GetLargestPossibleRegion());
     m_OutputProbabilityMap->Allocate();
     m_OutputProbabilityMap->FillBuffer(0);
   }
 
   m_MaskInterpolator = itk::LinearInterpolateImageFunction< ItkFloatImgType, float >::New();
   m_StopInterpolator = itk::LinearInterpolateImageFunction< ItkFloatImgType, float >::New();
   m_SeedInterpolator = itk::LinearInterpolateImageFunction< ItkFloatImgType, float >::New();
   m_TargetInterpolator = itk::LinearInterpolateImageFunction< ItkFloatImgType, float >::New();
   m_ExclusionInterpolator = itk::LinearInterpolateImageFunction< ItkFloatImgType, float >::New();
 
   if (m_StoppingRegions.IsNull())
   {
     m_StoppingRegions = ItkFloatImgType::New();
     m_StoppingRegions->SetSpacing( imageSpacing );
     m_StoppingRegions->SetOrigin( m_TrackingHandler->GetOrigin() );
     m_StoppingRegions->SetDirection( m_TrackingHandler->GetDirection() );
     m_StoppingRegions->SetRegions( m_TrackingHandler->GetLargestPossibleRegion() );
     m_StoppingRegions->Allocate();
     m_StoppingRegions->FillBuffer(0);
   }
   else
     std::cout << "StreamlineTracking - Using stopping region image" << std::endl;
   m_StopInterpolator->SetInputImage(m_StoppingRegions);
 
   if (m_ExclusionRegions.IsNotNull())
   {
     std::cout << "StreamlineTracking - Using exclusion region image" << std::endl;
     m_ExclusionInterpolator->SetInputImage(m_ExclusionRegions);
   }
 
   if (m_TargetRegions.IsNull())
   {
     m_TargetImageSet = false;
     m_TargetRegions = ItkFloatImgType::New();
     m_TargetRegions->SetSpacing( imageSpacing );
     m_TargetRegions->SetOrigin( m_TrackingHandler->GetOrigin() );
     m_TargetRegions->SetDirection( m_TrackingHandler->GetDirection() );
     m_TargetRegions->SetRegions( m_TrackingHandler->GetLargestPossibleRegion() );
     m_TargetRegions->Allocate();
     m_TargetRegions->FillBuffer(1);
   }
   else
   {
     m_TargetImageSet = true;
     m_TargetInterpolator->SetInputImage(m_TargetRegions);
     std::cout << "StreamlineTracking - Using target region image" << std::endl;
   }
 
   if (m_SeedImage.IsNull())
   {
     m_SeedImageSet = false;
     m_SeedImage = ItkFloatImgType::New();
     m_SeedImage->SetSpacing( imageSpacing );
     m_SeedImage->SetOrigin( m_TrackingHandler->GetOrigin() );
     m_SeedImage->SetDirection( m_TrackingHandler->GetDirection() );
     m_SeedImage->SetRegions( m_TrackingHandler->GetLargestPossibleRegion() );
     m_SeedImage->Allocate();
     m_SeedImage->FillBuffer(1);
   }
   else
   {
     m_SeedImageSet = true;
     std::cout << "StreamlineTracking - Using seed image" << std::endl;
   }
   m_SeedInterpolator->SetInputImage(m_SeedImage);
 
   if (m_MaskImage.IsNull())
   {
     // initialize mask image
     m_MaskImage = ItkFloatImgType::New();
     m_MaskImage->SetSpacing( imageSpacing );
     m_MaskImage->SetOrigin( m_TrackingHandler->GetOrigin() );
     m_MaskImage->SetDirection( m_TrackingHandler->GetDirection() );
     m_MaskImage->SetRegions( m_TrackingHandler->GetLargestPossibleRegion() );
     m_MaskImage->Allocate();
     m_MaskImage->FillBuffer(1);
   }
   else
     std::cout << "StreamlineTracking - Using mask image" << std::endl;
   m_MaskInterpolator->SetInputImage(m_MaskImage);
 
   // Autosettings for endpoint constraints
   if (m_Parameters->m_EpConstraints==EndpointConstraints::NONE && m_TargetImageSet && m_SeedImageSet)
   {
     MITK_INFO << "No endpoint constraint chosen but seed and target image set --> setting constraint to EPS_IN_SEED_AND_TARGET";
     m_Parameters->m_EpConstraints = EndpointConstraints::EPS_IN_SEED_AND_TARGET;
   }
   else if (m_Parameters->m_EpConstraints==EndpointConstraints::NONE && m_TargetImageSet)
   {
     MITK_INFO << "No endpoint constraint chosen but target image set --> setting constraint to EPS_IN_TARGET";
     m_Parameters->m_EpConstraints = EndpointConstraints::EPS_IN_TARGET;
   }
 
   // Check if endpoint constraints are valid
   FiberType test_fib; itk::Point<float> p; p.Fill(0);
   test_fib.push_back(p); test_fib.push_back(p);
   IsValidFiber(&test_fib);
 
   if (m_SeedPoints.empty())
     GetSeedPointsFromSeedImage();
 
   m_BuildFibersReady = 0;
   m_BuildFibersFinished = false;
   m_Tractogram.clear();
   m_SamplingPointset = mitk::PointSet::New();
   m_AlternativePointset = mitk::PointSet::New();
   m_StopVotePointset = mitk::PointSet::New();
   m_StartTime = std::chrono::system_clock::now();
 
   if (m_DemoMode)
     omp_set_num_threads(1);
 
   if (m_Parameters->m_Mode==mitk::TrackingDataHandler::MODE::DETERMINISTIC)
     std::cout << "StreamlineTracking - Mode: deterministic" << std::endl;
   else if(m_Parameters->m_Mode==mitk::TrackingDataHandler::MODE::PROBABILISTIC)
   {
     std::cout << "StreamlineTracking - Mode: probabilistic" << std::endl;
     std::cout << "StreamlineTracking - Trials per seed: " << m_Parameters->m_TrialsPerSeed << std::endl;
   }
   else
     std::cout << "StreamlineTracking - Mode: ???" << std::endl;
 
   if (m_Parameters->m_EpConstraints==EndpointConstraints::NONE)
     std::cout << "StreamlineTracking - Endpoint constraint: NONE" << std::endl;
   else if (m_Parameters->m_EpConstraints==EndpointConstraints::EPS_IN_TARGET)
     std::cout << "StreamlineTracking - Endpoint constraint: EPS_IN_TARGET" << std::endl;
   else if (m_Parameters->m_EpConstraints==EndpointConstraints::EPS_IN_TARGET_LABELDIFF)
     std::cout << "StreamlineTracking - Endpoint constraint: EPS_IN_TARGET_LABELDIFF" << std::endl;
   else if (m_Parameters->m_EpConstraints==EndpointConstraints::EPS_IN_SEED_AND_TARGET)
     std::cout << "StreamlineTracking - Endpoint constraint: EPS_IN_SEED_AND_TARGET" << std::endl;
   else if (m_Parameters->m_EpConstraints==EndpointConstraints::MIN_ONE_EP_IN_TARGET)
     std::cout << "StreamlineTracking - Endpoint constraint: MIN_ONE_EP_IN_TARGET" << std::endl;
   else if (m_Parameters->m_EpConstraints==EndpointConstraints::ONE_EP_IN_TARGET)
     std::cout << "StreamlineTracking - Endpoint constraint: ONE_EP_IN_TARGET" << std::endl;
   else if (m_Parameters->m_EpConstraints==EndpointConstraints::NO_EP_IN_TARGET)
     std::cout << "StreamlineTracking - Endpoint constraint: NO_EP_IN_TARGET" << std::endl;
 
   std::cout << "StreamlineTracking - Angular threshold: " << m_Parameters->GetAngularThresholdDot() << "°" << std::endl;
   std::cout << "StreamlineTracking - Stepsize: " << m_Parameters->GetStepSizeMm() << "mm (" << m_Parameters->GetStepSizeMm()/m_Parameters->GetMinVoxelSizeMm() << "*vox)" << std::endl;
   std::cout << "StreamlineTracking - Seeds per voxel: " << m_Parameters->m_SeedsPerVoxel << std::endl;
-  std::cout << "StreamlineTracking - Max. tract length: " << m_Parameters->m_MaxTractLength << "mm" << std::endl;
+  std::cout << "StreamlineTracking - Max. tract length: " << m_Parameters->m_MaxTractLengthMm << "mm" << std::endl;
   std::cout << "StreamlineTracking - Min. tract length: " << m_Parameters->m_MinTractLengthMm << "mm" << std::endl;
   std::cout << "StreamlineTracking - Max. num. tracts: " << m_Parameters->m_MaxNumFibers << std::endl;
   std::cout << "StreamlineTracking - Loop check: " << m_Parameters->GetLoopCheckDeg() << "°" << std::endl;
 
   std::cout << "StreamlineTracking - Num. neighborhood samples: " << m_Parameters->m_NumSamples << std::endl;
   std::cout << "StreamlineTracking - Max. sampling distance: " << m_Parameters->GetSamplingDistanceMm() << "mm (" << m_Parameters->GetSamplingDistanceMm()/m_Parameters->GetMinVoxelSizeMm() << "*vox)" << std::endl;
   std::cout << "StreamlineTracking - Deflection modifier: " << m_Parameters->m_DeflectionMod << std::endl;
 
   std::cout << "StreamlineTracking - Use stop votes: " << m_Parameters->m_StopVotes << std::endl;
   std::cout << "StreamlineTracking - Only frontal samples: " << m_Parameters->m_OnlyForwardSamples << std::endl;
 
   if (m_TrackingPriorHandler!=nullptr)
     std::cout << "StreamlineTracking - Using directional prior for tractography (w=" << m_Parameters->m_Weight << ")" << std::endl;
 
   if (m_DemoMode)
   {
     std::cout << "StreamlineTracking - Running in demo mode";
     std::cout << "StreamlineTracking - Starting streamline tracking using 1 thread" << std::endl;
   }
   else
     std::cout << "StreamlineTracking - Starting streamline tracking using " << omp_get_max_threads() << " threads" << std::endl;
 }
 
 void StreamlineTrackingFilter::CalculateNewPosition(itk::Point<float, 3>& pos, vnl_vector_fixed<float, 3>& dir)
 {
   pos[0] += dir[0]*m_Parameters->GetStepSizeMm();
   pos[1] += dir[1]*m_Parameters->GetStepSizeMm();
   pos[2] += dir[2]*m_Parameters->GetStepSizeMm();
 }
 
 std::vector< vnl_vector_fixed<float,3> > StreamlineTrackingFilter::CreateDirections(unsigned int NPoints)
 {
   std::vector< vnl_vector_fixed<float,3> > pointshell;
 
   if (NPoints<2)
     return pointshell;
 
   std::vector< double > theta; theta.resize(NPoints);
 
   std::vector< double > phi; phi.resize(NPoints);
 
   auto C = sqrt(4*itk::Math::pi);
 
   phi[0] = 0.0;
   phi[NPoints-1] = 0.0;
 
   for(unsigned int i=0; i<NPoints; i++)
   {
     theta[i] = acos(-1.0+2.0*i/(NPoints-1.0)) - itk::Math::pi / 2.0;
     if( i>0 && i<NPoints-1)
     {
       phi[i] = (phi[i-1] + C / sqrt(NPoints*(1-(-1.0+2.0*i/(NPoints-1.0))*(-1.0+2.0*i/(NPoints-1.0)))));
       // % (2*DIST_POINTSHELL_PI);
     }
   }
 
 
   for(unsigned int i=0; i<NPoints; i++)
   {
     vnl_vector_fixed<float,3> d;
     d[0] = static_cast<float>(cos(theta[i]) * cos(phi[i]));
     d[1] = static_cast<float>(cos(theta[i]) * sin(phi[i]));
     d[2] = static_cast<float>(sin(theta[i]));
     pointshell.push_back(d);
   }
 
   return pointshell;
 }
 
 
 vnl_vector_fixed<float,3> StreamlineTrackingFilter::GetNewDirection(const itk::Point<float, 3> &pos, std::deque<vnl_vector_fixed<float, 3> >& olddirs, itk::Index<3> &oldIndex)
 {
   if (m_DemoMode)
   {
     m_SamplingPointset->Clear();
     m_AlternativePointset->Clear();
     m_StopVotePointset->Clear();
   }
   vnl_vector_fixed<float,3> direction; direction.fill(0);
 
   if (mitk::imv::IsInsideMask<float>(pos, m_Parameters->m_InterpolateRoiImages, m_MaskInterpolator) && !mitk::imv::IsInsideMask<float>(pos, m_Parameters->m_InterpolateRoiImages, m_StopInterpolator))
     direction = m_TrackingHandler->ProposeDirection(pos, olddirs, oldIndex); // get direction proposal at current streamline position
   else
     return direction;
 
   int stop_votes = 0;
   int possible_stop_votes = 0;
   if (!olddirs.empty())
   {
     vnl_vector_fixed<float,3> olddir = olddirs.back();
     std::vector< vnl_vector_fixed<float,3> > probeVecs = CreateDirections(m_Parameters->m_NumSamples);
     itk::Point<float, 3> sample_pos;
     unsigned int alternatives = 1;
     for (unsigned int i=0; i<probeVecs.size(); i++)
     {
       vnl_vector_fixed<float,3> d;
       bool is_stop_voter = false;
       if (!m_Parameters->m_FixRandomSeed && m_Parameters->m_RandomSampling)
       {
         d[0] = static_cast<float>(m_TrackingHandler->GetRandDouble(-0.5, 0.5));
         d[1] = static_cast<float>(m_TrackingHandler->GetRandDouble(-0.5, 0.5));
         d[2] = static_cast<float>(m_TrackingHandler->GetRandDouble(-0.5, 0.5));
         d.normalize();
         d *= static_cast<float>(m_TrackingHandler->GetRandDouble(0, static_cast<double>(m_Parameters->GetSamplingDistanceMm())));
       }
       else
       {
         d = probeVecs.at(i);
         float dot = dot_product(d, olddir);
         if (m_Parameters->m_StopVotes && dot>0.7f)
         {
           is_stop_voter = true;
           possible_stop_votes++;
         }
         else if (m_Parameters->m_OnlyForwardSamples && dot<0)
           continue;
         d *= m_Parameters->GetSamplingDistanceMm();
       }
 
       sample_pos[0] = pos[0] + d[0];
       sample_pos[1] = pos[1] + d[1];
       sample_pos[2] = pos[2] + d[2];
 
       vnl_vector_fixed<float,3> tempDir; tempDir.fill(0.0);
       if (mitk::imv::IsInsideMask<float>(sample_pos, m_Parameters->m_InterpolateRoiImages, m_MaskInterpolator))
         tempDir = m_TrackingHandler->ProposeDirection(sample_pos, olddirs, oldIndex); // sample neighborhood
       if (tempDir.magnitude()>static_cast<float>(mitk::eps))
       {
         direction += tempDir;
 
         if(m_DemoMode)
           m_SamplingPointset->InsertPoint(i, sample_pos);
       }
       else if (m_Parameters->m_AvoidStop && olddir.magnitude()>0.5f) // out of white matter
       {
         if (is_stop_voter)
           stop_votes++;
         if (m_DemoMode)
           m_StopVotePointset->InsertPoint(i, sample_pos);
 
         float dot = dot_product(d, olddir);
         if (dot >= 0.0f) // in front of plane defined by pos and olddir
           d = -d + 2*dot*olddir; // reflect
         else
           d = -d; // invert
 
         // look a bit further into the other direction
         sample_pos[0] = pos[0] + d[0];
         sample_pos[1] = pos[1] + d[1];
         sample_pos[2] = pos[2] + d[2];
         alternatives++;
         vnl_vector_fixed<float,3> tempDir; tempDir.fill(0.0);
         if (mitk::imv::IsInsideMask<float>(sample_pos, m_Parameters->m_InterpolateRoiImages, m_MaskInterpolator))
           tempDir = m_TrackingHandler->ProposeDirection(sample_pos, olddirs, oldIndex); // sample neighborhood
 
         if (tempDir.magnitude()>static_cast<float>(mitk::eps))  // are we back in the white matter?
         {
           direction += d * m_Parameters->m_DeflectionMod;         // go into the direction of the white matter
           direction += tempDir;  // go into the direction of the white matter direction at this location
 
           if(m_DemoMode)
             m_AlternativePointset->InsertPoint(alternatives, sample_pos);
         }
         else
         {
           if (m_DemoMode)
             m_StopVotePointset->InsertPoint(i, sample_pos);
         }
       }
       else
       {
         if (m_DemoMode)
           m_StopVotePointset->InsertPoint(i, sample_pos);
 
         if (is_stop_voter)
           stop_votes++;
       }
     }
   }
 
   bool valid = false;
   if (direction.magnitude()>0.001f && (possible_stop_votes==0 || static_cast<float>(stop_votes)/possible_stop_votes<0.5f) )
   {
     direction.normalize();
     valid = true;
   }
   else
     direction.fill(0);
 
   if (m_TrackingPriorHandler!=nullptr && (m_Parameters->m_NewDirectionsFromPrior || valid))
   {
     vnl_vector_fixed<float,3> prior = m_TrackingPriorHandler->ProposeDirection(pos, olddirs, oldIndex);
     if (prior.magnitude()>0.001f)
     {
       prior.normalize();
       if (dot_product(prior,direction)<0)
         prior *= -1;
       direction = (1.0f-m_Parameters->m_Weight) * direction + m_Parameters->m_Weight * prior;
       direction.normalize();
     }
     else if (m_Parameters->m_RestrictToPrior)
       direction.fill(0.0);
   }
 
   return direction;
 }
 
 
 float StreamlineTrackingFilter::FollowStreamline(itk::Point<float, 3> pos, vnl_vector_fixed<float,3> dir, FiberType* fib, DirectionContainer* container, float tractLength, bool front, bool &exclude)
 {
   vnl_vector_fixed<float,3> zero_dir; zero_dir.fill(0.0);
   std::deque< vnl_vector_fixed<float,3> > last_dirs;
   for (unsigned int i=0; i<m_Parameters->m_NumPreviousDirections-1; i++)
     last_dirs.push_back(zero_dir);
 
   for (int step=0; step< 5000; step++)
   {
     itk::Index<3> oldIndex;
     m_TrackingHandler->WorldToIndex(pos, oldIndex);
 
     // get new position
     CalculateNewPosition(pos, dir);
 
     if (m_ExclusionRegions.IsNotNull() && mitk::imv::IsInsideMask<float>(pos, m_Parameters->m_InterpolateRoiImages, m_ExclusionInterpolator))
     {
       exclude = true;
       return tractLength;
     }
 
     if (m_AbortTracking)
       return tractLength;
 
     // if yes, add new point to streamline
     dir.normalize();
     if (front)
     {
       fib->push_front(pos);
       container->push_front(dir);
     }
     else
     {
       fib->push_back(pos);
       container->push_back(dir);
     }
     tractLength +=  m_Parameters->GetStepSizeMm();
 
     if (m_Parameters->GetLoopCheckDeg()>=0 && CheckCurvature(container, front)>m_Parameters->GetLoopCheckDeg())
       return tractLength;
 
-    if (tractLength>m_Parameters->m_MaxTractLength)
+    if (tractLength>m_Parameters->m_MaxTractLengthMm)
       return tractLength;
 
     if (m_DemoMode && !m_Parameters->m_OutputProbMap) // CHECK: warum sind die samplingpunkte der streamline in der visualisierung immer einen schritt voras?
     {
 #pragma omp critical
       {
         m_BuildFibersReady++;
         m_Tractogram.push_back(*fib);
         BuildFibers(true);
         m_Stop = true;
 
         while (m_Stop){
         }
       }
     }
 
     last_dirs.push_back(dir);
     if (last_dirs.size()>m_Parameters->m_NumPreviousDirections)
       last_dirs.pop_front();
     dir = GetNewDirection(pos, last_dirs, oldIndex);
 
     while (m_PauseTracking){}
 
     if (dir.magnitude()<0.0001f)
       return tractLength;
   }
   return tractLength;
 }
 
 
 float StreamlineTrackingFilter::CheckCurvature(DirectionContainer* fib, bool front)
 {
   if (fib->size()<8)
     return 0;
   float m_Distance = std::max(m_Parameters->GetMinVoxelSizeMm()*4, m_Parameters->GetStepSizeMm()*8);
   float dist = 0;
 
   std::vector< vnl_vector_fixed< float, 3 > > vectors;
   vnl_vector_fixed< float, 3 > meanV; meanV.fill(0);
   float dev = 0;
 
   if (front)
   {
     int c = 0;
     while(dist<m_Distance && c<static_cast<int>(fib->size())-1)
     {
       dist += m_Parameters->GetStepSizeMm();
       vnl_vector_fixed< float, 3 > v = fib->at(static_cast<unsigned int>(c));
       if (dot_product(v,meanV)<0)
         v = -v;
       vectors.push_back(v);
       meanV += v;
       c++;
     }
   }
   else
   {
     int c = static_cast<int>(fib->size())-1;
     while(dist<m_Distance && c>=0)
     {
       dist += m_Parameters->GetStepSizeMm();
       vnl_vector_fixed< float, 3 > v = fib->at(static_cast<unsigned int>(c));
       if (dot_product(v,meanV)<0)
         v = -v;
       vectors.push_back(v);
       meanV += v;
       c--;
     }
   }
   meanV.normalize();
 
   for (unsigned int c=0; c<vectors.size(); c++)
   {
     float angle = std::fabs(dot_product(meanV, vectors.at(c)));
     if (angle>1.0f)
       angle = 1.0;
     dev += acos(angle)*180.0f/static_cast<float>(itk::Math::pi);
   }
   if (vectors.size()>0)
     dev /= vectors.size();
 
   return dev;
 }
 
 std::shared_ptr<mitk::StreamlineTractographyParameters> StreamlineTrackingFilter::GetParameters() const
 {
   return m_Parameters;
 }
 
 void StreamlineTrackingFilter::SetParameters(std::shared_ptr< mitk::StreamlineTractographyParameters > Parameters)
 {
   m_Parameters = Parameters;
 }
 
 void StreamlineTrackingFilter::SetTrackingPriorHandler(mitk::TrackingDataHandler *TrackingPriorHandler)
 {
   m_TrackingPriorHandler = TrackingPriorHandler;
 }
 
 void StreamlineTrackingFilter::GetSeedPointsFromSeedImage()
 {
   MITK_INFO << "StreamlineTracking - Calculating seed points.";
   m_SeedPoints.clear();
 
   typedef ImageRegionConstIterator< ItkFloatImgType >     MaskIteratorType;
   MaskIteratorType    sit(m_SeedImage, m_SeedImage->GetLargestPossibleRegion());
   sit.GoToBegin();
 
   while (!sit.IsAtEnd())
   {
     if (sit.Value()>0)
     {
       ItkFloatImgType::IndexType index = sit.GetIndex();
       itk::ContinuousIndex<float, 3> start;
       start[0] = index[0];
       start[1] = index[1];
       start[2] = index[2];
       itk::Point<float> worldPos;
       m_SeedImage->TransformContinuousIndexToPhysicalPoint(start, worldPos);
 
       if ( mitk::imv::IsInsideMask<float>(worldPos, m_Parameters->m_InterpolateRoiImages, m_MaskInterpolator) )
       {
         m_SeedPoints.push_back(worldPos);
         for (unsigned int s = 1; s < m_Parameters->m_SeedsPerVoxel; s++)
         {
           start[0] = index[0] + static_cast<float>(m_TrackingHandler->GetRandDouble(-0.5, 0.5));
           start[1] = index[1] + static_cast<float>(m_TrackingHandler->GetRandDouble(-0.5, 0.5));
           start[2] = index[2] + static_cast<float>(m_TrackingHandler->GetRandDouble(-0.5, 0.5));
 
           itk::Point<float> worldPos;
           m_SeedImage->TransformContinuousIndexToPhysicalPoint(start, worldPos);
           m_SeedPoints.push_back(worldPos);
         }
       }
     }
     ++sit;
   }
   if (m_SeedPoints.empty())
     mitkThrow() << "No valid seed point in seed image! Is your seed image registered with the image you are tracking on?";
 }
 
 void StreamlineTrackingFilter::GenerateData()
 {
   this->BeforeTracking();
   if (!m_Parameters->m_FixRandomSeed)
     std::random_shuffle(m_SeedPoints.begin(), m_SeedPoints.end());
 
   m_CurrentTracts = 0;
   int num_seeds = static_cast<int>(m_SeedPoints.size());
   itk::Index<3> zeroIndex; zeroIndex.Fill(0);
   m_Progress = 0;
   int i = 0;
   int print_interval = num_seeds/100;
   if (print_interval<100)
     m_Verbose=false;
 
 #pragma omp parallel
   while (i<num_seeds && !m_StopTracking)
   {
     int temp_i = 0;
 #pragma omp critical
     {
       temp_i = i;
       i++;
     }
 
     if (temp_i>=num_seeds || m_StopTracking)
       continue;
     else if (m_Verbose && i%print_interval==0)
 #pragma omp critical
     {
       m_Progress += static_cast<unsigned int>(print_interval);
       std::cout << "                                                                                                     \r";
       if (m_Parameters->m_MaxNumFibers>0)
         std::cout << "Tried: " << m_Progress << "/" << num_seeds << " | Accepted: " << m_CurrentTracts << "/" << m_Parameters->m_MaxNumFibers << '\r';
       else
         std::cout << "Tried: " << m_Progress << "/" << num_seeds << " | Accepted: " << m_CurrentTracts << '\r';
       cout.flush();
     }
 
     const itk::Point<float> worldPos = m_SeedPoints.at(static_cast<unsigned int>(temp_i));
 
     for (unsigned int trials=0; trials<m_Parameters->m_TrialsPerSeed; ++trials)
     {
       FiberType fib;
       DirectionContainer direction_container;
       float tractLength = 0;
       unsigned long counter = 0;
 
       // get starting direction
       vnl_vector_fixed<float,3> dir; dir.fill(0.0);
       std::deque< vnl_vector_fixed<float,3> > olddirs;
       dir = GetNewDirection(worldPos, olddirs, zeroIndex) * 0.5f;
 
       bool exclude = false;
       if (m_ExclusionRegions.IsNotNull() && mitk::imv::IsInsideMask<float>(worldPos, m_Parameters->m_InterpolateRoiImages, m_ExclusionInterpolator))
         exclude = true;
 
       bool success = false;
       if (dir.magnitude()>0.0001f && !exclude)
       {
         // forward tracking
         tractLength = FollowStreamline(worldPos, dir, &fib, &direction_container, 0, false, exclude);
         fib.push_front(worldPos);
 
         // backward tracking
         if (!exclude)
           tractLength = FollowStreamline(worldPos, -dir, &fib, &direction_container, tractLength, true, exclude);
 
         counter = fib.size();
 
         if (tractLength>=m_Parameters->m_MinTractLengthMm && counter>=2 && !exclude)
         {
 #pragma omp critical
           if ( IsValidFiber(&fib) )
           {
             if (!m_StopTracking)
             {
               if (!m_Parameters->m_OutputProbMap)
                 m_Tractogram.push_back(fib);
               else
                 FiberToProbmap(&fib);
               m_CurrentTracts++;
               success = true;
             }
             if (m_Parameters->m_MaxNumFibers > 0 && m_CurrentTracts>=static_cast<unsigned int>(m_Parameters->m_MaxNumFibers))
             {
               if (!m_StopTracking)
               {
                 std::cout << "                                                                                                     \r";
                 MITK_INFO << "Reconstructed maximum number of tracts (" << m_CurrentTracts << "). Stopping tractography.";
               }
               m_StopTracking = true;
             }
           }
         }
       }
 
       if (success || m_Parameters->m_Mode!=MODE::PROBABILISTIC)
         break;  // we only try one seed point multiple times if we use a probabilistic tracker and have not found a valid streamline yet
 
     }// trials per seed
 
   }// seed points
 
   this->AfterTracking();
 }
 
 bool StreamlineTrackingFilter::IsValidFiber(FiberType* fib)
 {
   if (m_Parameters->m_EpConstraints==EndpointConstraints::NONE)
   {
     return true;
   }
   else if (m_Parameters->m_EpConstraints==EndpointConstraints::EPS_IN_TARGET)
   {
     if (m_TargetImageSet)
     {
       if ( mitk::imv::IsInsideMask<float>(fib->front(), m_Parameters->m_InterpolateRoiImages, m_TargetInterpolator)
            && mitk::imv::IsInsideMask<float>(fib->back(), m_Parameters->m_InterpolateRoiImages, m_TargetInterpolator) )
         return true;
       return false;
     }
     else
       mitkThrow() << "No target image set but endpoint constraint EPS_IN_TARGET chosen!";
   }
   else if (m_Parameters->m_EpConstraints==EndpointConstraints::EPS_IN_TARGET_LABELDIFF)
   {
     if (m_TargetImageSet)
     {
       float v1 = mitk::imv::GetImageValue<float>(fib->front(), false, m_TargetInterpolator);
       float v2 = mitk::imv::GetImageValue<float>(fib->back(), false, m_TargetInterpolator);
       if ( v1>0.0f && v2>0.0f && v1!=v2  )
         return true;
       return false;
     }
     else
       mitkThrow() << "No target image set but endpoint constraint EPS_IN_TARGET_LABELDIFF chosen!";
   }
   else if (m_Parameters->m_EpConstraints==EndpointConstraints::EPS_IN_SEED_AND_TARGET)
   {
     if (m_TargetImageSet && m_SeedImageSet)
     {
       if ( mitk::imv::IsInsideMask<float>(fib->front(), m_Parameters->m_InterpolateRoiImages, m_SeedInterpolator)
            && mitk::imv::IsInsideMask<float>(fib->back(), m_Parameters->m_InterpolateRoiImages, m_TargetInterpolator) )
         return true;
       if ( mitk::imv::IsInsideMask<float>(fib->back(), m_Parameters->m_InterpolateRoiImages, m_SeedInterpolator)
            && mitk::imv::IsInsideMask<float>(fib->front(), m_Parameters->m_InterpolateRoiImages, m_TargetInterpolator) )
         return true;
       return false;
     }
     else
       mitkThrow() << "No target or seed image set but endpoint constraint EPS_IN_SEED_AND_TARGET chosen!";
   }
   else if (m_Parameters->m_EpConstraints==EndpointConstraints::MIN_ONE_EP_IN_TARGET)
   {
     if (m_TargetImageSet)
     {
       if ( mitk::imv::IsInsideMask<float>(fib->front(), m_Parameters->m_InterpolateRoiImages, m_TargetInterpolator)
            || mitk::imv::IsInsideMask<float>(fib->back(), m_Parameters->m_InterpolateRoiImages, m_TargetInterpolator) )
         return true;
       return false;
     }
     else
       mitkThrow() << "No target image set but endpoint constraint MIN_ONE_EP_IN_TARGET chosen!";
   }
   else if (m_Parameters->m_EpConstraints==EndpointConstraints::ONE_EP_IN_TARGET)
   {
     if (m_TargetImageSet)
     {
       if ( mitk::imv::IsInsideMask<float>(fib->front(), m_Parameters->m_InterpolateRoiImages, m_TargetInterpolator)
            && !mitk::imv::IsInsideMask<float>(fib->back(), m_Parameters->m_InterpolateRoiImages, m_TargetInterpolator) )
         return true;
       if ( !mitk::imv::IsInsideMask<float>(fib->back(), m_Parameters->m_InterpolateRoiImages, m_TargetInterpolator)
            && mitk::imv::IsInsideMask<float>(fib->front(), m_Parameters->m_InterpolateRoiImages, m_TargetInterpolator) )
         return true;
       return false;
     }
     else
       mitkThrow() << "No target image set but endpoint constraint ONE_EP_IN_TARGET chosen!";
   }
   else if (m_Parameters->m_EpConstraints==EndpointConstraints::NO_EP_IN_TARGET)
   {
     if (m_TargetImageSet)
     {
       if ( mitk::imv::IsInsideMask<float>(fib->front(), m_Parameters->m_InterpolateRoiImages, m_TargetInterpolator)
            || mitk::imv::IsInsideMask<float>(fib->back(), m_Parameters->m_InterpolateRoiImages, m_TargetInterpolator) )
         return false;
       return true;
     }
     else
       mitkThrow() << "No target image set but endpoint constraint NO_EP_IN_TARGET chosen!";
   }
 
   return true;
 }
 
 void StreamlineTrackingFilter::FiberToProbmap(FiberType* fib)
 {
   ItkDoubleImgType::IndexType last_idx; last_idx.Fill(0);
   for (auto p : *fib)
   {
     ItkDoubleImgType::IndexType idx;
     m_OutputProbabilityMap->TransformPhysicalPointToIndex(p, idx);
 
     if (idx != last_idx)
     {
       if (m_OutputProbabilityMap->GetLargestPossibleRegion().IsInside(idx))
         m_OutputProbabilityMap->SetPixel(idx, m_OutputProbabilityMap->GetPixel(idx)+1);
       last_idx = idx;
     }
   }
 }
 
 void StreamlineTrackingFilter::BuildFibers(bool check)
 {
   if (m_BuildFibersReady<omp_get_num_threads() && check)
     return;
 
   m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
   vtkSmartPointer<vtkCellArray> vNewLines = vtkSmartPointer<vtkCellArray>::New();
   vtkSmartPointer<vtkPoints> vNewPoints = vtkSmartPointer<vtkPoints>::New();
 
   for (unsigned int i=0; i<m_Tractogram.size(); i++)
   {
     vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
     FiberType fib = m_Tractogram.at(i);
     for (FiberType::iterator it = fib.begin(); it!=fib.end(); ++it)
     {
       vtkIdType id = vNewPoints->InsertNextPoint((*it).GetDataPointer());
       container->GetPointIds()->InsertNextId(id);
     }
     vNewLines->InsertNextCell(container);
   }
 
   if (check)
     for (int i=0; i<m_BuildFibersReady; i++)
       m_Tractogram.pop_back();
   m_BuildFibersReady = 0;
 
   m_FiberPolyData->SetPoints(vNewPoints);
   m_FiberPolyData->SetLines(vNewLines);
   m_BuildFibersFinished = true;
 }
 
 void StreamlineTrackingFilter::AfterTracking()
 {
   if (m_Verbose)
     std::cout << "                                                                                                     \r";
   if (!m_Parameters->m_OutputProbMap)
   {
     MITK_INFO << "Reconstructed " << m_Tractogram.size() << " fibers.";
     MITK_INFO << "Generating polydata ";
     BuildFibers(false);
   }
   else
   {
     itk::RescaleIntensityImageFilter< ItkDoubleImgType, ItkDoubleImgType >::Pointer filter = itk::RescaleIntensityImageFilter< ItkDoubleImgType, ItkDoubleImgType >::New();
     filter->SetInput(m_OutputProbabilityMap);
     filter->SetOutputMaximum(1.0);
     filter->SetOutputMinimum(0.0);
     filter->Update();
     m_OutputProbabilityMap = filter->GetOutput();
   }
   MITK_INFO << "done";
 
   m_EndTime = std::chrono::system_clock::now();
   std::chrono::hours   hh = std::chrono::duration_cast<std::chrono::hours>(m_EndTime - m_StartTime);
   std::chrono::minutes mm = std::chrono::duration_cast<std::chrono::minutes>(m_EndTime - m_StartTime);
   std::chrono::seconds ss = std::chrono::duration_cast<std::chrono::seconds>(m_EndTime - m_StartTime);
   mm %= 60;
   ss %= 60;
   MITK_INFO << "Tracking took " << hh.count() << "h, " << mm.count() << "m and " << ss.count() << "s";
 
   m_SeedPoints.clear();
 }
 
 void StreamlineTrackingFilter::SetDicomProperties(mitk::FiberBundle::Pointer fib)
 {
   std::string model_code_value = "-";
   std::string model_code_meaning = "-";
   std::string algo_code_value = "-";
   std::string algo_code_meaning = "-";
 
   if ( m_Parameters->m_Mode==MODE::DETERMINISTIC && dynamic_cast<mitk::TrackingHandlerTensor*>(m_TrackingHandler) && !m_Parameters->m_InterpolateTractographyData)
   {
     algo_code_value = "sup181_ee04";
     algo_code_meaning = "FACT";
   }
   else if (m_Parameters->m_Mode==MODE::DETERMINISTIC)
   {
     algo_code_value = "sup181_ee01";
     algo_code_meaning = "Deterministic";
   }
   else if (m_Parameters->m_Mode==MODE::PROBABILISTIC)
   {
     algo_code_value = "sup181_ee02";
     algo_code_meaning = "Probabilistic";
   }
 
   if (dynamic_cast<mitk::TrackingHandlerTensor*>(m_TrackingHandler) || (dynamic_cast<mitk::TrackingHandlerOdf*>(m_TrackingHandler) && dynamic_cast<mitk::TrackingHandlerOdf*>(m_TrackingHandler)->GetIsOdfFromTensor() ) )
   {
     if ( dynamic_cast<mitk::TrackingHandlerTensor*>(m_TrackingHandler) && dynamic_cast<mitk::TrackingHandlerTensor*>(m_TrackingHandler)->GetNumTensorImages()>1 )
     {
       model_code_value = "sup181_bb02";
       model_code_meaning = "Multi Tensor";
     }
     else
     {
       model_code_value = "sup181_bb01";
       model_code_meaning = "Single Tensor";
     }
   }
   else if (dynamic_cast<mitk::TrackingHandlerRandomForest<6, 28>*>(m_TrackingHandler) || dynamic_cast<mitk::TrackingHandlerRandomForest<6, 100>*>(m_TrackingHandler))
   {
     model_code_value = "sup181_bb03";
     model_code_meaning = "Model Free";
   }
   else if (dynamic_cast<mitk::TrackingHandlerOdf*>(m_TrackingHandler))
   {
     model_code_value = "-";
     model_code_meaning = "ODF";
   }
   else if (dynamic_cast<mitk::TrackingHandlerPeaks*>(m_TrackingHandler))
   {
     model_code_value = "-";
     model_code_meaning = "Peaks";
   }
 
   fib->SetProperty("DICOM.anatomy.value", mitk::StringProperty::New("T-A0095"));
   fib->SetProperty("DICOM.anatomy.meaning", mitk::StringProperty::New("White matter of brain and spinal cord"));
 
   fib->SetProperty("DICOM.algo_code.value", mitk::StringProperty::New(algo_code_value));
   fib->SetProperty("DICOM.algo_code.meaning", mitk::StringProperty::New(algo_code_meaning));
 
   fib->SetProperty("DICOM.model_code.value", mitk::StringProperty::New(model_code_value));
   fib->SetProperty("DICOM.model_code.meaning", mitk::StringProperty::New(model_code_meaning));
 }
 
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/IODataStructures/mitkStreamlineTractographyParameters.cpp b/Modules/DiffusionImaging/FiberTracking/IODataStructures/mitkStreamlineTractographyParameters.cpp
index d6475c9b63..9ff2ca06f8 100644
--- a/Modules/DiffusionImaging/FiberTracking/IODataStructures/mitkStreamlineTractographyParameters.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/IODataStructures/mitkStreamlineTractographyParameters.cpp
@@ -1,348 +1,365 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include <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("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.get_child("fiberfox") )
+  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_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,"min_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);
     }
     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;
+    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/DiffusionImaging/FiberTracking/IODataStructures/mitkStreamlineTractographyParameters.h b/Modules/DiffusionImaging/FiberTracking/IODataStructures/mitkStreamlineTractographyParameters.h
index 61fbb01404..4b80b27b4e 100644
--- a/Modules/DiffusionImaging/FiberTracking/IODataStructures/mitkStreamlineTractographyParameters.h
+++ b/Modules/DiffusionImaging/FiberTracking/IODataStructures/mitkStreamlineTractographyParameters.h
@@ -1,159 +1,162 @@
 #pragma once
 
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include <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;
     bool m_SharpenOdfs = false;
     float m_Cutoff = 0.1;
     // - fa/gfa image
     float m_OdfCutoff = 0.00025;
     float m_MinTractLengthMm = 20;
-    float m_MaxTractLength = 400;
+    float m_MaxTractLengthMm = 400;
     float m_F = 1;
     float m_G = 0;
     bool m_FixRandomSeed = false;
     unsigned int m_NumPreviousDirections = 1;
 
     // 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 = -1;
 
     float m_StepSizeVox = -1;
     float m_StepSizeMm;
 
     float m_MinVoxelSizeMm = 1.0;
   };
 }
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/files.cmake b/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/files.cmake
index 1e35e55a6c..ed8c2d8ef3 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/files.cmake
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/files.cmake
@@ -1,73 +1,77 @@
 set(SRC_CPP_FILES
   QmitkTensorModelParametersWidget.cpp
   QmitkZeppelinModelParametersWidget.cpp
   QmitkStickModelParametersWidget.cpp
   QmitkDotModelParametersWidget.cpp
   QmitkBallModelParametersWidget.cpp
   QmitkAstrosticksModelParametersWidget.cpp
   QmitkPrototypeSignalParametersWidget.cpp
 )
 
 set(INTERNAL_CPP_FILES
   QmitkFiberfoxView.cpp
   QmitkFieldmapGeneratorView.cpp
   QmitkFiberGenerationView.cpp
   mitkPluginActivator.cpp
   
   Perspectives/QmitkDIAppSyntheticDataGenerationPerspective.cpp
 )
 
 set(UI_FILES  
   src/internal/QmitkFiberfoxViewControls.ui
   src/internal/QmitkFieldmapGeneratorViewControls.ui
   src/internal/QmitkFiberGenerationViewControls.ui
   
   src/QmitkTensorModelParametersWidgetControls.ui
   src/QmitkZeppelinModelParametersWidgetControls.ui
   src/QmitkStickModelParametersWidgetControls.ui
   src/QmitkDotModelParametersWidgetControls.ui
   src/QmitkBallModelParametersWidgetControls.ui
   src/QmitkAstrosticksModelParametersWidgetControls.ui
   src/QmitkPrototypeSignalParametersWidgetControls.ui
 )
 
 set(MOC_H_FILES
   src/internal/mitkPluginActivator.h
   src/internal/QmitkFiberfoxView.h
   src/internal/QmitkFieldmapGeneratorView.h
   src/internal/QmitkFiberGenerationView.h
   
   src/QmitkTensorModelParametersWidget.h
   src/QmitkZeppelinModelParametersWidget.h
   src/QmitkStickModelParametersWidget.h
   src/QmitkDotModelParametersWidget.h
   src/QmitkBallModelParametersWidget.h
   src/QmitkAstrosticksModelParametersWidget.h
   src/QmitkPrototypeSignalParametersWidget.h
   
   src/internal/Perspectives/QmitkDIAppSyntheticDataGenerationPerspective.h
 )
 
 set(CACHED_RESOURCE_FILES
   plugin.xml
   
   resources/phantom.png
   resources/syntheticdata.png
   resources/fieldmap.png
   resources/models.png
+
+  resources/upload.ico
+  resources/download.ico
+  resources/right.ico
+  resources/stop.ico
 )
 
 set(QRC_FILES
-  resources/QmitkDiffusionImaging.qrc
 )
 
 
 set(CPP_FILES )
 
 foreach(file ${SRC_CPP_FILES})
   set(CPP_FILES ${CPP_FILES} src/${file})
 endforeach(file ${SRC_CPP_FILES})
 
 foreach(file ${INTERNAL_CPP_FILES})
   set(CPP_FILES ${CPP_FILES} src/internal/${file})
 endforeach(file ${INTERNAL_CPP_FILES})
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/QmitkDiffusionImaging.qrc b/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/QmitkDiffusionImaging.qrc
deleted file mode 100644
index 3bd9ee335f..0000000000
--- a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/QmitkDiffusionImaging.qrc
+++ /dev/null
@@ -1,30 +0,0 @@
-<RCC>
-    <qresource prefix="/QmitkDiffusionImaging">
-        <file>circle.png</file>
-        <file>general_icons/download.ico</file>
-        <file>general_icons/play.ico</file>
-        <file>general_icons/plus.ico</file>
-        <file>general_icons/refresh.ico</file>
-        <file>general_icons/right.ico</file>
-        <file>general_icons/save.ico</file>
-        <file>general_icons/undo.ico</file>
-        <file>general_icons/upload.ico</file>
-        <file>general_icons/abort.ico</file>
-        <file>general_icons/copy1.ico</file>
-        <file>general_icons/copy2.ico</file>
-        <file>general_icons/cut.ico</file>
-        <file>general_icons/deny1.ico</file>
-        <file>general_icons/deny2.ico</file>
-        <file>general_icons/down.ico</file>
-        <file>general_icons/left.ico</file>
-        <file>general_icons/magn_minus.ico</file>
-        <file>general_icons/magn_plus.ico</file>
-        <file>general_icons/search.ico</file>
-        <file>general_icons/stop.ico</file>
-        <file>general_icons/up.ico</file>
-        <file>general_icons/help.ico</file>
-        <file>general_icons/pencil.ico</file>
-        <file>general_icons/edit.ico</file>
-        <file>models.png</file>
-    </qresource>
-</RCC>
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/download.ico b/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/download.ico
similarity index 100%
copy from Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/download.ico
copy to Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/download.ico
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/abort.ico b/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/abort.ico
deleted file mode 100644
index b8edcbdc33..0000000000
Binary files a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/abort.ico and /dev/null differ
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/copy1.ico b/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/copy1.ico
deleted file mode 100644
index 22b77ce46a..0000000000
Binary files a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/copy1.ico and /dev/null differ
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/copy2.ico b/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/copy2.ico
deleted file mode 100644
index f09778af37..0000000000
Binary files a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/copy2.ico and /dev/null differ
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/cut.ico b/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/cut.ico
deleted file mode 100644
index bd757f5d10..0000000000
Binary files a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/cut.ico and /dev/null differ
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/deny1.ico b/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/deny1.ico
deleted file mode 100644
index b3d67e68e9..0000000000
Binary files a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/deny1.ico and /dev/null differ
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/deny2.ico b/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/deny2.ico
deleted file mode 100644
index 1c70699dc8..0000000000
Binary files a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/deny2.ico and /dev/null differ
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/down.ico b/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/down.ico
deleted file mode 100644
index 5a85a4136a..0000000000
Binary files a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/down.ico and /dev/null differ
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/edit.ico b/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/edit.ico
deleted file mode 100644
index 9f6951a514..0000000000
Binary files a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/edit.ico and /dev/null differ
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/help.ico b/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/help.ico
deleted file mode 100644
index 2a972dfbf8..0000000000
Binary files a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/help.ico and /dev/null differ
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/left.ico b/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/left.ico
deleted file mode 100644
index 964f60ad8e..0000000000
Binary files a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/left.ico and /dev/null differ
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/magn_minus.ico b/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/magn_minus.ico
deleted file mode 100644
index 10c7d311d0..0000000000
Binary files a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/magn_minus.ico and /dev/null differ
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/magn_plus.ico b/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/magn_plus.ico
deleted file mode 100644
index e520a689a0..0000000000
Binary files a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/magn_plus.ico and /dev/null differ
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/pencil.ico b/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/pencil.ico
deleted file mode 100644
index 0e58e1cc94..0000000000
Binary files a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/pencil.ico and /dev/null differ
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/play.ico b/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/play.ico
deleted file mode 100644
index d6379ce139..0000000000
Binary files a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/play.ico and /dev/null differ
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/plus.ico b/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/plus.ico
deleted file mode 100644
index a2b7a026b0..0000000000
Binary files a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/plus.ico and /dev/null differ
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/refresh.ico b/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/refresh.ico
deleted file mode 100644
index d603e55ff2..0000000000
Binary files a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/refresh.ico and /dev/null differ
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/save.ico b/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/save.ico
deleted file mode 100644
index 80c7ecdbdf..0000000000
Binary files a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/save.ico and /dev/null differ
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/search.ico b/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/search.ico
deleted file mode 100644
index 25802edcc9..0000000000
Binary files a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/search.ico and /dev/null differ
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/undo.ico b/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/undo.ico
deleted file mode 100644
index 2b6a67a2cb..0000000000
Binary files a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/undo.ico and /dev/null differ
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/up.ico b/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/up.ico
deleted file mode 100644
index e221d345e9..0000000000
Binary files a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/up.ico and /dev/null differ
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/right.ico b/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/right.ico
similarity index 100%
copy from Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/right.ico
copy to Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/right.ico
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/stop.ico b/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/stop.ico
similarity index 100%
copy from Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/stop.ico
copy to Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/stop.ico
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/upload.ico b/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/upload.ico
similarity index 100%
copy from Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/upload.ico
copy to Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/upload.ico
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/src/internal/QmitkFiberfoxViewControls.ui b/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/src/internal/QmitkFiberfoxViewControls.ui
index c59bf0cffa..b9a2018b76 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/src/internal/QmitkFiberfoxViewControls.ui
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/src/internal/QmitkFiberfoxViewControls.ui
@@ -1,2891 +1,2891 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkFiberfoxViewControls</class>
  <widget class="QWidget" name="QmitkFiberfoxViewControls">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>490</width>
     <height>2775</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string>Form</string>
   </property>
   <property name="styleSheet">
    <string notr="true"/>
   </property>
   <layout class="QGridLayout" name="gridLayout_2">
    <item row="3" column="0">
     <widget class="QGroupBox" name="m_IntraAxonalGroupBox">
      <property name="styleSheet">
       <string notr="true">QGroupBox {
   background-color: transparent;
 }</string>
      </property>
      <property name="title">
       <string>Intra-axonal Compartment</string>
      </property>
      <layout class="QGridLayout" name="gridLayout_13">
       <property name="leftMargin">
        <number>6</number>
       </property>
       <property name="topMargin">
        <number>6</number>
       </property>
       <property name="rightMargin">
        <number>6</number>
       </property>
       <property name="bottomMargin">
        <number>6</number>
       </property>
       <item row="3" column="0">
        <widget class="QmitkTensorModelParametersWidget" name="m_TensorWidget1" native="true"/>
       </item>
       <item row="1" column="0">
        <widget class="QmitkStickModelParametersWidget" name="m_StickWidget1" native="true"/>
       </item>
       <item row="4" column="0">
        <widget class="QmitkPrototypeSignalParametersWidget" name="m_PrototypeWidget1" native="true"/>
       </item>
       <item row="0" column="0">
        <widget class="QComboBox" name="m_Compartment1Box">
         <property name="toolTip">
          <string>Select signal model for intra-axonal compartment.</string>
         </property>
         <item>
          <property name="text">
           <string>Stick Model</string>
          </property>
         </item>
         <item>
          <property name="text">
           <string>Zeppelin Model</string>
          </property>
         </item>
         <item>
          <property name="text">
           <string>Tensor Model</string>
          </property>
         </item>
         <item>
          <property name="text">
           <string>Prototype Signal</string>
          </property>
         </item>
        </widget>
       </item>
       <item row="2" column="0">
        <widget class="QmitkZeppelinModelParametersWidget" name="m_ZeppelinWidget1" native="true"/>
       </item>
       <item row="5" column="0">
        <widget class="QFrame" name="m_Comp1FractionFrame">
         <property name="frameShape">
          <enum>QFrame::NoFrame</enum>
         </property>
         <property name="frameShadow">
          <enum>QFrame::Raised</enum>
         </property>
         <layout class="QGridLayout" name="gridLayout_26">
          <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_NoiseLabel_6">
            <property name="text">
             <string>Volume Fraction:</string>
            </property>
           </widget>
          </item>
          <item row="0" column="1">
           <widget class="QmitkDataStorageComboBoxWithSelectNone" name="m_Comp1VolumeFraction">
            <property name="toolTip">
             <string>Optional! If no volume fraction map for this compartment is set, the corresponding volume fractions are calculated from the input fibers.</string>
            </property>
           </widget>
          </item>
         </layout>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item row="4" column="0">
     <widget class="QGroupBox" name="groupBox_5">
      <property name="styleSheet">
       <string notr="true">QGroupBox {
   background-color: transparent;
 }</string>
      </property>
      <property name="title">
       <string>Inter-axonal Compartment</string>
      </property>
      <layout class="QGridLayout" name="gridLayout_17">
       <property name="leftMargin">
        <number>6</number>
       </property>
       <property name="topMargin">
        <number>6</number>
       </property>
       <property name="rightMargin">
        <number>6</number>
       </property>
       <property name="bottomMargin">
        <number>6</number>
       </property>
       <item row="0" column="0">
        <widget class="QComboBox" name="m_Compartment2Box">
         <property name="toolTip">
          <string>Select signal model for intra-axonal compartment.</string>
         </property>
         <item>
          <property name="text">
           <string>--</string>
          </property>
         </item>
         <item>
          <property name="text">
           <string>Stick Model</string>
          </property>
         </item>
         <item>
          <property name="text">
           <string>Zeppelin Model</string>
          </property>
         </item>
         <item>
          <property name="text">
           <string>Tensor Model</string>
          </property>
         </item>
        </widget>
       </item>
       <item row="1" column="0">
        <widget class="QmitkZeppelinModelParametersWidget" name="m_ZeppelinWidget2" native="true"/>
       </item>
       <item row="2" column="0">
        <widget class="QmitkStickModelParametersWidget" name="m_StickWidget2" native="true"/>
       </item>
       <item row="3" column="0">
        <widget class="QmitkTensorModelParametersWidget" name="m_TensorWidget2" native="true"/>
       </item>
       <item row="4" column="0">
        <widget class="QmitkPrototypeSignalParametersWidget" name="m_PrototypeWidget2" native="true"/>
       </item>
       <item row="5" column="0">
        <widget class="QFrame" name="m_Comp2FractionFrame">
         <property name="frameShape">
          <enum>QFrame::NoFrame</enum>
         </property>
         <property name="frameShadow">
          <enum>QFrame::Raised</enum>
         </property>
         <layout class="QGridLayout" name="gridLayout_27">
          <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_NoiseLabel_7">
            <property name="text">
             <string>Volume Fraction:</string>
            </property>
           </widget>
          </item>
          <item row="0" column="1">
           <widget class="QmitkDataStorageComboBoxWithSelectNone" name="m_Comp2VolumeFraction">
            <property name="toolTip">
             <string>Optional! If no volume fraction map for this compartment is set, the corresponding volume fractions are calculated from the input fibers.</string>
            </property>
           </widget>
          </item>
         </layout>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item row="2" column="0">
     <widget class="QGroupBox" name="groupBox">
      <property name="styleSheet">
       <string notr="true">QGroupBox {
   background-color: transparent;
 }</string>
      </property>
      <property name="title">
       <string>Image Settings</string>
      </property>
      <layout class="QGridLayout" name="gridLayout">
       <property name="leftMargin">
        <number>6</number>
       </property>
       <property name="topMargin">
        <number>6</number>
       </property>
       <property name="rightMargin">
        <number>6</number>
       </property>
       <property name="bottomMargin">
        <number>6</number>
       </property>
       <item row="2" column="0">
        <widget class="QLabel" name="m_GeometryMessage">
         <property name="styleSheet">
          <string notr="true">color: rgb(255, 0, 0);</string>
         </property>
         <property name="text">
          <string>Using  geometry of selected image!</string>
         </property>
        </widget>
       </item>
       <item row="9" column="0">
        <widget class="QFrame" name="m_AdvancedSignalOptionsFrame">
         <property name="frameShape">
          <enum>QFrame::NoFrame</enum>
         </property>
         <property name="frameShadow">
          <enum>QFrame::Raised</enum>
         </property>
         <layout class="QGridLayout" name="gridLayout_23">
          <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="horizontalSpacing">
           <number>6</number>
          </property>
          <item row="8" column="1">
           <widget class="QSpinBox" name="m_TIbox">
            <property name="toolTip">
             <string>Inversion time (in ms) for inversion recovery sequences. If 0, no inversion pulse is simulated.</string>
            </property>
            <property name="minimum">
             <number>0</number>
            </property>
            <property name="maximum">
             <number>999999999</number>
            </property>
            <property name="singleStep">
             <number>1</number>
            </property>
            <property name="value">
             <number>0</number>
            </property>
           </widget>
          </item>
          <item row="11" column="0">
           <widget class="QLabel" name="m_TensorsToDWIBValueLabel_12">
            <property name="toolTip">
             <string/>
            </property>
            <property name="statusTip">
             <string/>
            </property>
            <property name="whatsThis">
             <string/>
            </property>
            <property name="text">
             <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;&lt;span style=&quot; font-style:italic;&quot;&gt;T&lt;/span&gt;&lt;span style=&quot; font-style:italic; vertical-align:sub;&quot;&gt;inhom&lt;/span&gt; Relaxation: &lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
            </property>
            <property name="wordWrap">
             <bool>false</bool>
            </property>
           </widget>
          </item>
          <item row="11" column="1">
           <widget class="QSpinBox" name="m_T2starBox">
            <property name="toolTip">
             <string>Relaxation time due to magnetic field inhomogeneities (T2', in milliseconds).</string>
            </property>
            <property name="minimum">
             <number>1</number>
            </property>
            <property name="maximum">
             <number>10000</number>
            </property>
            <property name="singleStep">
             <number>1</number>
            </property>
            <property name="value">
             <number>50</number>
            </property>
           </widget>
          </item>
          <item row="7" column="0">
           <widget class="QLabel" name="m_TensorsToDWIBValueLabel_14">
            <property name="toolTip">
             <string/>
            </property>
            <property name="statusTip">
             <string/>
            </property>
            <property name="whatsThis">
             <string/>
            </property>
            <property name="text">
             <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Repetition Time &lt;span style=&quot; font-style:italic;&quot;&gt;TR&lt;/span&gt;: &lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
            </property>
            <property name="wordWrap">
             <bool>false</bool>
            </property>
           </widget>
          </item>
          <item row="5" column="1">
           <widget class="QSpinBox" name="m_TEbox">
            <property name="toolTip">
             <string>TE in milliseconds</string>
            </property>
            <property name="minimum">
             <number>1</number>
            </property>
            <property name="maximum">
             <number>999999999</number>
            </property>
            <property name="singleStep">
             <number>1</number>
            </property>
            <property name="value">
             <number>100</number>
            </property>
           </widget>
          </item>
          <item row="10" column="0">
           <widget class="QLabel" name="m_TensorsToDWIBValueLabel_32">
            <property name="toolTip">
             <string/>
            </property>
            <property name="statusTip">
             <string/>
            </property>
            <property name="whatsThis">
             <string/>
            </property>
            <property name="text">
             <string>Partial Fourier:</string>
            </property>
            <property name="wordWrap">
             <bool>false</bool>
            </property>
           </widget>
          </item>
          <item row="10" column="1">
           <widget class="QDoubleSpinBox" name="m_PartialFourier">
            <property name="toolTip">
             <string>Partial fourier factor (0.5-1)</string>
            </property>
            <property name="decimals">
             <number>3</number>
            </property>
            <property name="minimum">
             <double>0.500000000000000</double>
            </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="14" column="0">
           <widget class="QCheckBox" name="m_ReversePhaseBox">
            <property name="toolTip">
             <string>Output one image per compartment containing the corresponding volume fractions per voxel.</string>
            </property>
            <property name="text">
             <string>Reverse Phase Encoding Direction</string>
            </property>
            <property name="checked">
             <bool>false</bool>
            </property>
           </widget>
          </item>
          <item row="9" column="1">
           <widget class="QDoubleSpinBox" name="m_LineReadoutTimeBox">
            <property name="toolTip">
             <string>Dwell time (time to read one line in k-space) in ms.</string>
            </property>
            <property name="decimals">
             <number>4</number>
            </property>
            <property name="maximum">
             <double>100.000000000000000</double>
            </property>
            <property name="singleStep">
             <double>0.100000000000000</double>
            </property>
            <property name="value">
             <double>1.000000000000000</double>
            </property>
           </widget>
          </item>
          <item row="2" column="1">
           <widget class="QSpinBox" name="m_NumCoilsBox">
            <property name="toolTip">
             <string>Number of coil elements used for the acquisiton.</string>
            </property>
            <property name="minimum">
             <number>1</number>
            </property>
            <property name="maximum">
             <number>128</number>
            </property>
            <property name="singleStep">
             <number>1</number>
            </property>
            <property name="value">
             <number>1</number>
            </property>
           </widget>
          </item>
          <item row="13" column="1">
           <widget class="QDoubleSpinBox" name="m_FiberRadius">
            <property name="toolTip">
             <string>Fiber radius used to calculate volume fractions (in µm). Set to 0 for automatic radius estimation.</string>
            </property>
            <property name="maximum">
             <double>9999.000000000000000</double>
            </property>
           </widget>
          </item>
          <item row="9" column="0">
           <widget class="QLabel" name="m_TensorsToDWIBValueLabel_15">
            <property name="toolTip">
             <string/>
            </property>
            <property name="statusTip">
             <string/>
            </property>
            <property name="whatsThis">
             <string/>
            </property>
            <property name="text">
             <string>Dwell Time:</string>
            </property>
            <property name="wordWrap">
             <bool>false</bool>
            </property>
           </widget>
          </item>
          <item row="16" column="0">
           <widget class="QCheckBox" name="m_EnforcePureFiberVoxelsBox">
            <property name="toolTip">
             <string>Disable partial volume. Treat voxel content as fiber-only if at least one fiber is present.</string>
            </property>
            <property name="text">
             <string>Disable Partial Volume Effects</string>
            </property>
            <property name="checked">
             <bool>false</bool>
            </property>
           </widget>
          </item>
          <item row="0" column="0">
           <widget class="QLabel" name="m_TensorsToDWINumDirsLabel_6">
            <property name="text">
             <string>Acquisition Type:</string>
            </property>
           </widget>
          </item>
          <item row="13" column="0">
           <widget class="QLabel" name="m_TensorsToDWINumDirsLabel_4">
            <property name="text">
             <string>Fiber Radius:</string>
            </property>
           </widget>
          </item>
          <item row="1" column="0">
           <widget class="QLabel" name="m_TensorsToDWINumDirsLabel_5">
            <property name="text">
             <string>Signal Scale:</string>
            </property>
           </widget>
          </item>
          <item row="2" column="0">
           <widget class="QLabel" name="m_TensorsToDWIBValueLabel_13">
            <property name="toolTip">
             <string/>
            </property>
            <property name="statusTip">
             <string/>
            </property>
            <property name="whatsThis">
             <string/>
            </property>
            <property name="text">
             <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Number of Channels:&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
            </property>
            <property name="wordWrap">
             <bool>false</bool>
            </property>
           </widget>
          </item>
          <item row="7" column="1">
           <widget class="QSpinBox" name="m_TRbox">
            <property name="toolTip">
             <string>TR in milliseconds</string>
            </property>
            <property name="minimum">
             <number>1</number>
            </property>
            <property name="maximum">
             <number>999999999</number>
            </property>
            <property name="singleStep">
             <number>1</number>
            </property>
            <property name="value">
             <number>4000</number>
            </property>
           </widget>
          </item>
          <item row="0" column="1">
           <widget class="QComboBox" name="m_AcquisitionTypeBox">
            <item>
             <property name="text">
              <string>Single Shot EPI</string>
             </property>
            </item>
            <item>
             <property name="text">
              <string>Conventional Spin Echo</string>
             </property>
            </item>
            <item>
             <property name="text">
              <string>Fast Spin Echo</string>
             </property>
            </item>
           </widget>
          </item>
          <item row="1" column="1">
           <widget class="QSpinBox" name="m_SignalScaleBox">
            <property name="toolTip">
             <string/>
            </property>
            <property name="minimum">
             <number>1</number>
            </property>
            <property name="maximum">
             <number>100000</number>
            </property>
            <property name="singleStep">
             <number>1</number>
            </property>
            <property name="value">
             <number>100</number>
            </property>
           </widget>
          </item>
          <item row="3" column="1">
           <widget class="QComboBox" name="m_CoilSensBox">
            <item>
             <property name="text">
              <string>Constant</string>
             </property>
            </item>
            <item>
             <property name="text">
              <string>Linear</string>
             </property>
            </item>
            <item>
             <property name="text">
              <string>Exponential</string>
             </property>
            </item>
           </widget>
          </item>
          <item row="15" column="0">
           <widget class="QCheckBox" name="m_RelaxationBox">
            <property name="toolTip">
             <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;&lt;span style=&quot; font-style:italic;&quot;&gt;TE&lt;/span&gt;, &lt;span style=&quot; font-style:italic;&quot;&gt;T&lt;/span&gt;&lt;span style=&quot; font-style:italic; vertical-align:sub;&quot;&gt;inhom&lt;/span&gt; and &lt;span style=&quot; font-style:italic;&quot;&gt;T2&lt;/span&gt; will have no effect if unchecked.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
            </property>
            <property name="text">
             <string>Simulate Signal Relaxation</string>
            </property>
            <property name="checked">
             <bool>true</bool>
            </property>
           </widget>
          </item>
          <item row="5" column="0">
           <widget class="QLabel" name="m_TensorsToDWIBValueLabel_33">
            <property name="toolTip">
             <string/>
            </property>
            <property name="statusTip">
             <string/>
            </property>
            <property name="whatsThis">
             <string/>
            </property>
            <property name="text">
             <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Echo Time &lt;span style=&quot; font-style:italic;&quot;&gt;TE&lt;/span&gt;:  &lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
            </property>
            <property name="wordWrap">
             <bool>false</bool>
            </property>
           </widget>
          </item>
          <item row="3" column="0">
           <widget class="QLabel" name="m_TensorsToDWIBValueLabel_34">
            <property name="toolTip">
             <string/>
            </property>
            <property name="statusTip">
             <string/>
            </property>
            <property name="whatsThis">
             <string/>
            </property>
            <property name="text">
             <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Coil Sensitivity:&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
            </property>
            <property name="wordWrap">
             <bool>false</bool>
            </property>
           </widget>
          </item>
          <item row="8" column="0">
           <widget class="QLabel" name="m_TensorsToDWIBValueLabel_17">
            <property name="toolTip">
             <string/>
            </property>
            <property name="statusTip">
             <string/>
            </property>
            <property name="whatsThis">
             <string/>
            </property>
            <property name="text">
             <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Inversion Time &lt;span style=&quot; font-style:italic;&quot;&gt;TI&lt;/span&gt;: &lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
            </property>
            <property name="wordWrap">
             <bool>false</bool>
            </property>
           </widget>
          </item>
          <item row="17" column="0">
           <widget class="QCheckBox" name="m_VolumeFractionsBox">
            <property name="toolTip">
             <string>Output phase image and volume fraction maps.</string>
            </property>
            <property name="text">
             <string>Output Additional Images</string>
            </property>
            <property name="checked">
             <bool>false</bool>
            </property>
           </widget>
          </item>
          <item row="4" column="0">
           <widget class="QLabel" name="m_TensorsToDWIBValueLabel_35">
            <property name="toolTip">
             <string/>
            </property>
            <property name="statusTip">
             <string/>
            </property>
            <property name="whatsThis">
             <string/>
            </property>
            <property name="text">
             <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Echo Train Length: &lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
            </property>
            <property name="wordWrap">
             <bool>false</bool>
            </property>
           </widget>
          </item>
          <item row="4" column="1">
           <widget class="QSpinBox" name="m_EtlBox">
            <property name="toolTip">
             <string>Only relevant for Fast Spin Echo sequence (number of k-space lines acquired with one RF pulse)</string>
            </property>
            <property name="minimum">
             <number>1</number>
            </property>
            <property name="maximum">
             <number>999999999</number>
            </property>
            <property name="singleStep">
             <number>1</number>
            </property>
            <property name="value">
             <number>8</number>
            </property>
           </widget>
          </item>
         </layout>
        </widget>
       </item>
       <item row="7" column="0">
        <widget class="QFrame" name="m_GenerateGradientsFrame">
         <property name="frameShape">
          <enum>QFrame::NoFrame</enum>
         </property>
         <property name="frameShadow">
          <enum>QFrame::Raised</enum>
         </property>
         <layout class="QGridLayout" name="gridLayout_24">
          <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>6</number>
          </property>
          <item row="2" column="0">
           <widget class="QLabel" name="m_TensorsToDWIBValueLabel">
            <property name="toolTip">
             <string/>
            </property>
            <property name="statusTip">
             <string/>
            </property>
            <property name="whatsThis">
             <string/>
            </property>
            <property name="text">
             <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;b-Value&lt;span style=&quot; font-style:italic;&quot;&gt; [s/mm&lt;/span&gt;&lt;span style=&quot; font-style:italic; vertical-align:super;&quot;&gt;2&lt;/span&gt;&lt;span style=&quot; font-style:italic;&quot;&gt;]&lt;/span&gt;:&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
            </property>
            <property name="wordWrap">
             <bool>false</bool>
            </property>
           </widget>
          </item>
          <item row="2" column="1">
           <widget class="QSpinBox" name="m_BvalueBox">
            <property name="toolTip">
             <string>b-value in s/mm²</string>
            </property>
            <property name="minimum">
             <number>0</number>
            </property>
            <property name="maximum">
             <number>10000</number>
            </property>
            <property name="singleStep">
             <number>100</number>
            </property>
            <property name="value">
             <number>1000</number>
            </property>
           </widget>
          </item>
          <item row="1" column="0">
           <widget class="QLabel" name="m_TensorsToDWINumDirsLabel">
            <property name="text">
             <string>Gradient Directions:</string>
            </property>
           </widget>
          </item>
          <item row="1" column="1">
           <widget class="QSpinBox" name="m_NumGradientsBox">
            <property name="toolTip">
             <string>Number of gradient directions distributed over the half sphere.</string>
            </property>
            <property name="minimum">
             <number>0</number>
            </property>
            <property name="maximum">
             <number>10000</number>
            </property>
            <property name="singleStep">
             <number>1</number>
            </property>
            <property name="value">
             <number>30</number>
            </property>
           </widget>
          </item>
         </layout>
        </widget>
       </item>
       <item row="8" column="0">
        <widget class="QCheckBox" name="m_AdvancedOptionsBox_2">
         <property name="text">
          <string>Advanced Options</string>
         </property>
        </widget>
       </item>
       <item row="4" column="0">
        <widget class="QLabel" name="m_DiffusionPropsMessage">
         <property name="styleSheet">
          <string notr="true">color: rgb(255, 0, 0);</string>
         </property>
         <property name="text">
          <string>Using  gradients of selected DWI!</string>
         </property>
        </widget>
       </item>
       <item row="3" column="0">
        <widget class="QFrame" name="m_GeometryFrame">
         <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="2" column="2">
           <widget class="QDoubleSpinBox" name="m_SpacingY">
            <property name="decimals">
             <number>3</number>
            </property>
            <property name="minimum">
             <double>0.100000000000000</double>
            </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="label_2">
            <property name="text">
             <string>Image Spacing:</string>
            </property>
           </widget>
          </item>
          <item row="2" column="3">
           <widget class="QDoubleSpinBox" name="m_SpacingZ">
            <property name="decimals">
             <number>3</number>
            </property>
            <property name="minimum">
             <double>0.100000000000000</double>
            </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="1">
           <widget class="QDoubleSpinBox" name="m_SpacingX">
            <property name="decimals">
             <number>3</number>
            </property>
            <property name="minimum">
             <double>0.100000000000000</double>
            </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="0" column="0">
           <widget class="QLabel" name="label">
            <property name="text">
             <string>Image Dimensions:</string>
            </property>
           </widget>
          </item>
          <item row="0" column="1">
           <widget class="QSpinBox" name="m_SizeX">
            <property name="toolTip">
             <string>Fiber sampling factor which determines the accuracy of the calculated fiber and non-fiber volume fractions.</string>
            </property>
            <property name="minimum">
             <number>1</number>
            </property>
            <property name="maximum">
             <number>1000</number>
            </property>
            <property name="singleStep">
             <number>1</number>
            </property>
            <property name="value">
             <number>20</number>
            </property>
           </widget>
          </item>
          <item row="0" column="2">
           <widget class="QSpinBox" name="m_SizeY">
            <property name="toolTip">
             <string>Fiber sampling factor which determines the accuracy of the calculated fiber and non-fiber volume fractions.</string>
            </property>
            <property name="minimum">
             <number>1</number>
            </property>
            <property name="maximum">
             <number>1000</number>
            </property>
            <property name="singleStep">
             <number>1</number>
            </property>
            <property name="value">
             <number>20</number>
            </property>
           </widget>
          </item>
          <item row="0" column="3">
           <widget class="QSpinBox" name="m_SizeZ">
            <property name="toolTip">
             <string>Fiber sampling factor which determines the accuracy of the calculated fiber and non-fiber volume fractions.</string>
            </property>
            <property name="minimum">
             <number>1</number>
            </property>
            <property name="maximum">
             <number>1000</number>
            </property>
            <property name="singleStep">
             <number>1</number>
            </property>
            <property name="value">
             <number>3</number>
            </property>
           </widget>
          </item>
         </layout>
        </widget>
       </item>
       <item row="5" column="0">
        <widget class="QCheckBox" name="m_UseBvalsBvecsBox">
         <property name="text">
          <string>Use bvals/bvecs files</string>
         </property>
        </widget>
       </item>
       <item row="6" column="0">
        <widget class="QFrame" name="m_LoadGradientsFrame">
         <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="0" column="2">
           <widget class="QToolButton" name="m_LoadBvalsButton">
            <property name="text">
             <string>...</string>
            </property>
           </widget>
          </item>
          <item row="2" column="2">
           <widget class="QToolButton" name="m_LoadBvecsButton">
            <property name="text">
             <string>...</string>
            </property>
           </widget>
          </item>
          <item row="0" column="1">
           <widget class="QLineEdit" name="m_LoadBvalsEdit">
            <property name="text">
             <string>-</string>
            </property>
            <property name="readOnly">
             <bool>false</bool>
            </property>
           </widget>
          </item>
          <item row="2" column="0">
           <widget class="QLabel" name="label_12">
            <property name="toolTip">
             <string/>
            </property>
            <property name="statusTip">
             <string/>
            </property>
            <property name="whatsThis">
             <string/>
            </property>
            <property name="text">
             <string>Bvecs:</string>
            </property>
            <property name="wordWrap">
             <bool>false</bool>
            </property>
           </widget>
          </item>
          <item row="0" column="0">
           <widget class="QLabel" name="label_11">
            <property name="toolTip">
             <string/>
            </property>
            <property name="statusTip">
             <string/>
            </property>
            <property name="whatsThis">
             <string/>
            </property>
            <property name="text">
             <string>Bvals:</string>
            </property>
            <property name="wordWrap">
             <bool>false</bool>
            </property>
           </widget>
          </item>
          <item row="2" column="1">
           <widget class="QLineEdit" name="m_LoadBvecsEdit">
            <property name="text">
             <string>-</string>
            </property>
            <property name="readOnly">
             <bool>false</bool>
            </property>
           </widget>
          </item>
         </layout>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item row="5" column="0">
     <widget class="QGroupBox" name="groupBox_6">
      <property name="styleSheet">
       <string notr="true">QGroupBox {
   background-color: transparent;
 }</string>
      </property>
      <property name="title">
       <string>Extra-axonal Compartments</string>
      </property>
      <layout class="QGridLayout" name="gridLayout_14">
       <property name="leftMargin">
        <number>6</number>
       </property>
       <property name="topMargin">
        <number>6</number>
       </property>
       <property name="rightMargin">
        <number>6</number>
       </property>
       <property name="bottomMargin">
        <number>6</number>
       </property>
       <item row="18" column="0">
        <widget class="QFrame" name="m_Comp4FractionFrame">
         <property name="frameShape">
          <enum>QFrame::NoFrame</enum>
         </property>
         <property name="frameShadow">
          <enum>QFrame::Raised</enum>
         </property>
         <layout class="QGridLayout" name="gridLayout_30">
          <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_NoiseLabel_9">
            <property name="text">
             <string>Volume Fraction:</string>
            </property>
           </widget>
          </item>
          <item row="0" column="1">
           <widget class="QmitkDataStorageComboBoxWithSelectNone" name="m_Comp4VolumeFraction">
            <property name="toolTip">
             <string/>
            </property>
           </widget>
          </item>
         </layout>
        </widget>
       </item>
       <item row="6" column="0">
        <widget class="QComboBox" name="m_Compartment3Box">
         <property name="toolTip">
          <string>Select signal model for extra-axonal compartment.</string>
         </property>
         <item>
          <property name="text">
           <string>Ball Model</string>
          </property>
         </item>
         <item>
          <property name="text">
           <string>Astrosticks Model</string>
          </property>
         </item>
         <item>
          <property name="text">
           <string>Dot Model</string>
          </property>
         </item>
         <item>
          <property name="text">
           <string>Prototype Signal</string>
          </property>
         </item>
        </widget>
       </item>
       <item row="8" column="0">
        <widget class="QmitkAstrosticksModelParametersWidget" name="m_AstrosticksWidget1" native="true"/>
       </item>
       <item row="10" column="0">
        <widget class="QmitkPrototypeSignalParametersWidget" name="m_PrototypeWidget3" native="true"/>
       </item>
       <item row="16" column="0">
        <widget class="QmitkDotModelParametersWidget" name="m_DotWidget2" native="true"/>
       </item>
       <item row="9" column="0">
        <widget class="QmitkDotModelParametersWidget" name="m_DotWidget1" native="true"/>
       </item>
       <item row="12" column="0">
        <widget class="Line" name="line_2">
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
        </widget>
       </item>
       <item row="11" column="0">
        <widget class="QFrame" name="m_Comp3FractionFrame">
         <property name="frameShape">
          <enum>QFrame::NoFrame</enum>
         </property>
         <property name="frameShadow">
          <enum>QFrame::Raised</enum>
         </property>
         <layout class="QGridLayout" name="gridLayout_29">
          <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_NoiseLabel_8">
            <property name="text">
             <string>Volume Fraction:</string>
            </property>
           </widget>
          </item>
          <item row="0" column="1">
           <widget class="QmitkDataStorageComboBoxWithSelectNone" name="m_Comp3VolumeFraction">
            <property name="toolTip">
             <string>Optional! If no volume fraction map for this compartment is set, the corresponding volume fractions are calculated from the input fibers.</string>
            </property>
           </widget>
          </item>
         </layout>
        </widget>
       </item>
       <item row="14" column="0">
        <widget class="QmitkBallModelParametersWidget" name="m_BallWidget2" native="true"/>
       </item>
       <item row="7" column="0">
        <widget class="QmitkBallModelParametersWidget" name="m_BallWidget1" native="true"/>
       </item>
       <item row="15" column="0">
        <widget class="QmitkAstrosticksModelParametersWidget" name="m_AstrosticksWidget2" native="true"/>
       </item>
       <item row="13" column="0">
        <widget class="QComboBox" name="m_Compartment4Box">
         <property name="toolTip">
          <string>Select signal model for extra-axonal compartment.</string>
         </property>
         <item>
          <property name="text">
           <string>--</string>
          </property>
         </item>
         <item>
          <property name="text">
           <string>Ball Model</string>
          </property>
         </item>
         <item>
          <property name="text">
           <string>Astrosticks Model</string>
          </property>
         </item>
         <item>
          <property name="text">
           <string>Dot Model</string>
          </property>
         </item>
         <item>
          <property name="text">
           <string>Prototype Signal</string>
          </property>
         </item>
        </widget>
       </item>
       <item row="17" column="0">
        <widget class="QmitkPrototypeSignalParametersWidget" name="m_PrototypeWidget4" native="true"/>
       </item>
      </layout>
     </widget>
    </item>
    <item row="6" column="0">
     <widget class="QGroupBox" name="groupBox_3">
      <property name="styleSheet">
       <string notr="true">QGroupBox {
   background-color: transparent;
 }</string>
      </property>
      <property name="title">
       <string>Noise and other Artifacts</string>
      </property>
      <layout class="QGridLayout" name="gridLayout_6">
       <property name="leftMargin">
        <number>6</number>
       </property>
       <property name="topMargin">
        <number>6</number>
       </property>
       <property name="rightMargin">
        <number>6</number>
       </property>
       <property name="bottomMargin">
        <number>6</number>
       </property>
       <item row="8" column="0">
        <widget class="Line" name="line_7">
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
        </widget>
       </item>
       <item row="19" column="0">
        <widget class="QFrame" name="m_MotionArtifactFrame">
         <property name="enabled">
          <bool>true</bool>
         </property>
         <property name="frameShape">
          <enum>QFrame::NoFrame</enum>
         </property>
         <property name="frameShadow">
          <enum>QFrame::Raised</enum>
         </property>
         <layout class="QGridLayout" name="gridLayout_18">
          <property name="leftMargin">
           <number>0</number>
          </property>
          <property name="topMargin">
           <number>6</number>
          </property>
          <property name="rightMargin">
           <number>0</number>
          </property>
          <property name="bottomMargin">
           <number>0</number>
          </property>
          <property name="horizontalSpacing">
           <number>6</number>
          </property>
          <item row="0" column="0">
           <widget class="QCheckBox" name="m_RandomMotion">
            <property name="toolTip">
             <string>Toggle between random movement and linear movement.</string>
            </property>
            <property name="text">
             <string>Randomize motion</string>
            </property>
            <property name="checked">
             <bool>true</bool>
            </property>
           </widget>
          </item>
          <item row="3" column="0">
           <widget class="QGroupBox" name="m_RotationArtifactFrame">
            <property name="styleSheet">
             <string notr="true">QGroupBox {
   background-color: transparent;
 }</string>
            </property>
            <property name="title">
             <string>Rotation</string>
            </property>
            <layout class="QGridLayout" name="gridLayout_19">
             <property name="leftMargin">
              <number>6</number>
             </property>
             <property name="topMargin">
              <number>9</number>
             </property>
             <property name="rightMargin">
              <number>6</number>
             </property>
             <property name="bottomMargin">
              <number>6</number>
             </property>
             <item row="1" column="0">
              <widget class="QLabel" name="m_TensorsToDWIBValueLabel_36">
               <property name="toolTip">
                <string/>
               </property>
               <property name="statusTip">
                <string/>
               </property>
               <property name="whatsThis">
                <string/>
               </property>
               <property name="text">
                <string>Degree:</string>
               </property>
               <property name="wordWrap">
                <bool>false</bool>
               </property>
              </widget>
             </item>
             <item row="0" column="1">
              <widget class="QLabel" name="m_TensorsToDWIBValueLabel_29">
               <property name="toolTip">
                <string/>
               </property>
               <property name="statusTip">
                <string/>
               </property>
               <property name="whatsThis">
                <string/>
               </property>
               <property name="text">
                <string>x</string>
               </property>
               <property name="wordWrap">
                <bool>false</bool>
               </property>
              </widget>
             </item>
             <item row="0" column="0">
              <widget class="QLabel" name="m_TensorsToDWIBValueLabel_28">
               <property name="toolTip">
                <string/>
               </property>
               <property name="statusTip">
                <string/>
               </property>
               <property name="whatsThis">
                <string/>
               </property>
               <property name="text">
                <string>Axis:</string>
               </property>
               <property name="wordWrap">
                <bool>false</bool>
               </property>
              </widget>
             </item>
             <item row="1" column="1">
              <widget class="QDoubleSpinBox" name="m_MaxRotationBoxX">
               <property name="toolTip">
                <string>Maximum rotation around x-axis.</string>
               </property>
               <property name="decimals">
                <number>1</number>
               </property>
               <property name="minimum">
                <double>-360.000000000000000</double>
               </property>
               <property name="maximum">
                <double>360.000000000000000</double>
               </property>
               <property name="singleStep">
                <double>1.000000000000000</double>
               </property>
               <property name="value">
                <double>0.000000000000000</double>
               </property>
              </widget>
             </item>
             <item row="1" column="3">
              <widget class="QDoubleSpinBox" name="m_MaxRotationBoxZ">
               <property name="toolTip">
                <string>Maximum rotation around z-axis.</string>
               </property>
               <property name="decimals">
                <number>1</number>
               </property>
               <property name="minimum">
                <double>-360.000000000000000</double>
               </property>
               <property name="maximum">
                <double>360.000000000000000</double>
               </property>
               <property name="singleStep">
                <double>1.000000000000000</double>
               </property>
               <property name="value">
                <double>15.000000000000000</double>
               </property>
              </widget>
             </item>
             <item row="0" column="2">
              <widget class="QLabel" name="m_TensorsToDWIBValueLabel_30">
               <property name="toolTip">
                <string/>
               </property>
               <property name="statusTip">
                <string/>
               </property>
               <property name="whatsThis">
                <string/>
               </property>
               <property name="text">
                <string>y</string>
               </property>
               <property name="wordWrap">
                <bool>false</bool>
               </property>
              </widget>
             </item>
             <item row="0" column="3">
              <widget class="QLabel" name="m_TensorsToDWIBValueLabel_31">
               <property name="toolTip">
                <string/>
               </property>
               <property name="statusTip">
                <string/>
               </property>
               <property name="whatsThis">
                <string/>
               </property>
               <property name="text">
                <string>z</string>
               </property>
               <property name="wordWrap">
                <bool>false</bool>
               </property>
              </widget>
             </item>
             <item row="1" column="2">
              <widget class="QDoubleSpinBox" name="m_MaxRotationBoxY">
               <property name="toolTip">
                <string>Maximum rotation around y-axis.</string>
               </property>
               <property name="decimals">
                <number>1</number>
               </property>
               <property name="minimum">
                <double>-360.000000000000000</double>
               </property>
               <property name="maximum">
                <double>360.000000000000000</double>
               </property>
               <property name="singleStep">
                <double>1.000000000000000</double>
               </property>
               <property name="value">
                <double>0.000000000000000</double>
               </property>
              </widget>
             </item>
            </layout>
           </widget>
          </item>
          <item row="4" column="0">
           <widget class="QGroupBox" name="m_TranslationArtifactFrame">
            <property name="styleSheet">
             <string notr="true">QGroupBox {
   background-color: transparent;
 }</string>
            </property>
            <property name="title">
             <string>Translation</string>
            </property>
            <layout class="QGridLayout" name="gridLayout_28">
             <property name="leftMargin">
              <number>6</number>
             </property>
             <property name="rightMargin">
              <number>6</number>
             </property>
             <property name="bottomMargin">
              <number>6</number>
             </property>
             <item row="1" column="0">
              <widget class="QLabel" name="m_TensorsToDWIBValueLabel_48">
               <property name="toolTip">
                <string/>
               </property>
               <property name="statusTip">
                <string/>
               </property>
               <property name="whatsThis">
                <string/>
               </property>
               <property name="text">
                <string>Distance:</string>
               </property>
               <property name="wordWrap">
                <bool>false</bool>
               </property>
              </widget>
             </item>
             <item row="0" column="1">
              <widget class="QLabel" name="m_TensorsToDWIBValueLabel_51">
               <property name="toolTip">
                <string/>
               </property>
               <property name="statusTip">
                <string/>
               </property>
               <property name="whatsThis">
                <string/>
               </property>
               <property name="text">
                <string>x</string>
               </property>
               <property name="wordWrap">
                <bool>false</bool>
               </property>
              </widget>
             </item>
             <item row="0" column="2">
              <widget class="QLabel" name="m_TensorsToDWIBValueLabel_52">
               <property name="toolTip">
                <string/>
               </property>
               <property name="statusTip">
                <string/>
               </property>
               <property name="whatsThis">
                <string/>
               </property>
               <property name="text">
                <string>y</string>
               </property>
               <property name="wordWrap">
                <bool>false</bool>
               </property>
              </widget>
             </item>
             <item row="0" column="0">
              <widget class="QLabel" name="m_TensorsToDWIBValueLabel_47">
               <property name="toolTip">
                <string/>
               </property>
               <property name="statusTip">
                <string/>
               </property>
               <property name="whatsThis">
                <string/>
               </property>
               <property name="text">
                <string>Axis:</string>
               </property>
               <property name="wordWrap">
                <bool>false</bool>
               </property>
              </widget>
             </item>
             <item row="0" column="3">
              <widget class="QLabel" name="m_TensorsToDWIBValueLabel_53">
               <property name="toolTip">
                <string/>
               </property>
               <property name="statusTip">
                <string/>
               </property>
               <property name="whatsThis">
                <string/>
               </property>
               <property name="text">
                <string>z</string>
               </property>
               <property name="wordWrap">
                <bool>false</bool>
               </property>
              </widget>
             </item>
             <item row="1" column="1">
              <widget class="QDoubleSpinBox" name="m_MaxTranslationBoxX">
               <property name="toolTip">
                <string>Maximum translation along x-axis.</string>
               </property>
               <property name="decimals">
                <number>1</number>
               </property>
               <property name="minimum">
                <double>-1000.000000000000000</double>
               </property>
               <property name="maximum">
                <double>1000.000000000000000</double>
               </property>
               <property name="singleStep">
                <double>1.000000000000000</double>
               </property>
               <property name="value">
                <double>0.000000000000000</double>
               </property>
              </widget>
             </item>
             <item row="1" column="2">
              <widget class="QDoubleSpinBox" name="m_MaxTranslationBoxY">
               <property name="toolTip">
                <string>Maximum translation along y-axis.</string>
               </property>
               <property name="decimals">
                <number>1</number>
               </property>
               <property name="minimum">
                <double>-1000.000000000000000</double>
               </property>
               <property name="maximum">
                <double>1000.000000000000000</double>
               </property>
               <property name="singleStep">
                <double>1.000000000000000</double>
               </property>
               <property name="value">
                <double>0.000000000000000</double>
               </property>
              </widget>
             </item>
             <item row="1" column="3">
              <widget class="QDoubleSpinBox" name="m_MaxTranslationBoxZ">
               <property name="toolTip">
                <string>Maximum translation along z-axis.</string>
               </property>
               <property name="decimals">
                <number>1</number>
               </property>
               <property name="minimum">
                <double>-1000.000000000000000</double>
               </property>
               <property name="maximum">
                <double>1000.000000000000000</double>
               </property>
               <property name="singleStep">
                <double>1.000000000000000</double>
               </property>
               <property name="value">
                <double>0.000000000000000</double>
               </property>
              </widget>
             </item>
            </layout>
           </widget>
          </item>
          <item row="2" 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_31">
             <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_3">
               <property name="text">
                <string>Motion volumes:</string>
               </property>
              </widget>
             </item>
             <item row="0" column="1">
              <widget class="QLineEdit" name="m_MotionVolumesBox">
               <property name="toolTip">
                <string>Type in the volume indices that should be affected by motion (e.g. &quot;0 3 7&quot; whithout quotation marks). Leave blank for motion in all volumes. Type in &quot;random&quot; to randomly select volumes for motion. A list of negative numbers (e.g. -1 -2 -3) excludes volumes (e.g. 1 2 3) selects all remaining volumes.</string>
               </property>
               <property name="text">
                <string>random</string>
               </property>
              </widget>
             </item>
            </layout>
           </widget>
          </item>
         </layout>
        </widget>
       </item>
       <item row="4" column="0">
        <widget class="QFrame" name="m_SpikeFrame">
         <property name="frameShape">
          <enum>QFrame::NoFrame</enum>
         </property>
         <property name="frameShadow">
          <enum>QFrame::Raised</enum>
         </property>
         <layout class="QFormLayout" name="formLayout_9">
          <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_NoiseLabel_2">
            <property name="text">
             <string>Num. Spikes:</string>
            </property>
           </widget>
          </item>
          <item row="0" column="1">
           <widget class="QSpinBox" name="m_SpikeNumBox">
            <property name="toolTip">
             <string>The number of randomly occurring signal spikes.</string>
            </property>
            <property name="value">
             <number>1</number>
            </property>
           </widget>
          </item>
          <item row="1" column="1">
           <widget class="QDoubleSpinBox" name="m_SpikeScaleBox">
            <property name="toolTip">
             <string>Spike amplitude relative to the largest signal amplitude of the corresponding k-space slice.</string>
            </property>
            <property name="singleStep">
             <double>0.100000000000000</double>
            </property>
            <property name="value">
             <double>0.100000000000000</double>
            </property>
           </widget>
          </item>
          <item row="1" column="0">
           <widget class="QLabel" name="m_NoiseLabel_4">
            <property name="text">
             <string>Scale:</string>
            </property>
           </widget>
          </item>
         </layout>
        </widget>
       </item>
       <item row="10" column="0">
        <widget class="QFrame" name="m_AliasingFrame">
         <property name="enabled">
          <bool>true</bool>
         </property>
         <property name="frameShape">
          <enum>QFrame::NoFrame</enum>
         </property>
         <property name="frameShadow">
          <enum>QFrame::Raised</enum>
         </property>
         <layout class="QFormLayout" name="formLayout_10">
          <property name="horizontalSpacing">
           <number>6</number>
          </property>
          <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_TensorsToDWIBValueLabel_27">
            <property name="toolTip">
             <string/>
            </property>
            <property name="statusTip">
             <string/>
            </property>
            <property name="whatsThis">
             <string/>
            </property>
            <property name="text">
             <string>Shrink FOV (%):</string>
            </property>
            <property name="wordWrap">
             <bool>false</bool>
            </property>
           </widget>
          </item>
          <item row="0" column="1">
           <widget class="QDoubleSpinBox" name="m_WrapBox">
            <property name="toolTip">
             <string>Shrink FOV by this percentage.</string>
            </property>
            <property name="decimals">
             <number>1</number>
            </property>
            <property name="minimum">
             <double>0.000000000000000</double>
            </property>
            <property name="maximum">
             <double>90.000000000000000</double>
            </property>
            <property name="singleStep">
             <double>0.100000000000000</double>
            </property>
            <property name="value">
             <double>40.000000000000000</double>
            </property>
           </widget>
          </item>
         </layout>
        </widget>
       </item>
       <item row="5" column="0">
        <widget class="Line" name="line_8">
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
        </widget>
       </item>
       <item row="16" column="0">
        <widget class="QFrame" name="m_DriftFrame">
         <property name="enabled">
          <bool>true</bool>
         </property>
         <property name="frameShape">
          <enum>QFrame::NoFrame</enum>
         </property>
         <property name="frameShadow">
          <enum>QFrame::Raised</enum>
         </property>
         <layout class="QFormLayout" name="formLayout_11">
          <property name="horizontalSpacing">
           <number>6</number>
          </property>
          <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_35">
            <property name="toolTip">
             <string/>
            </property>
            <property name="statusTip">
             <string/>
            </property>
            <property name="whatsThis">
             <string/>
            </property>
            <property name="text">
             <string>Signal Reduction (%):</string>
            </property>
            <property name="wordWrap">
             <bool>false</bool>
            </property>
           </widget>
          </item>
          <item row="0" column="1">
           <widget class="QDoubleSpinBox" name="m_DriftFactor">
            <property name="toolTip">
             <string>Global signal in last simulated volume is specified percentage lower than in the first volume.</string>
            </property>
            <property name="decimals">
             <number>1</number>
            </property>
            <property name="maximum">
             <double>100.000000000000000</double>
            </property>
            <property name="singleStep">
             <double>1.000000000000000</double>
            </property>
            <property name="value">
             <double>6.000000000000000</double>
            </property>
           </widget>
          </item>
         </layout>
        </widget>
       </item>
       <item row="13" column="0">
        <widget class="QFrame" name="m_DistortionsFrame">
         <property name="enabled">
          <bool>true</bool>
         </property>
         <property name="frameShape">
          <enum>QFrame::NoFrame</enum>
         </property>
         <property name="frameShadow">
          <enum>QFrame::Raised</enum>
         </property>
         <layout class="QFormLayout" name="formLayout_7">
          <property name="horizontalSpacing">
           <number>6</number>
          </property>
          <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_TensorsToDWIBValueLabel_25">
            <property name="toolTip">
             <string/>
            </property>
            <property name="statusTip">
             <string/>
            </property>
            <property name="whatsThis">
             <string/>
            </property>
            <property name="text">
             <string>Frequency Map:</string>
            </property>
            <property name="wordWrap">
             <bool>false</bool>
            </property>
           </widget>
          </item>
          <item row="0" column="1">
           <widget class="QmitkDataStorageComboBox" name="m_FrequencyMapBox">
            <property name="toolTip">
             <string>Select image specifying the frequency inhomogeneities (in Hz).</string>
            </property>
           </widget>
          </item>
         </layout>
        </widget>
       </item>
       <item row="23" column="0">
        <widget class="QFrame" name="m_EddyFrame">
         <property name="enabled">
          <bool>true</bool>
         </property>
         <property name="frameShape">
          <enum>QFrame::NoFrame</enum>
         </property>
         <property name="frameShadow">
          <enum>QFrame::Raised</enum>
         </property>
         <layout class="QFormLayout" name="formLayout_8">
          <property name="fieldGrowthPolicy">
           <enum>QFormLayout::AllNonFixedFieldsGrow</enum>
          </property>
          <property name="horizontalSpacing">
           <number>6</number>
          </property>
          <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_TensorsToDWIBValueLabel_26">
            <property name="toolTip">
             <string/>
            </property>
            <property name="statusTip">
             <string/>
            </property>
            <property name="whatsThis">
             <string/>
            </property>
            <property name="text">
             <string>Gradient:</string>
            </property>
            <property name="wordWrap">
             <bool>false</bool>
            </property>
           </widget>
          </item>
          <item row="0" column="1">
           <widget class="QDoubleSpinBox" name="m_EddyGradientStrength">
            <property name="toolTip">
             <string>Eddy current induced magnetic field gradient (in mT/m).</string>
            </property>
            <property name="decimals">
             <number>5</number>
            </property>
            <property name="maximum">
             <double>1000.000000000000000</double>
            </property>
            <property name="singleStep">
             <double>0.001000000000000</double>
            </property>
            <property name="value">
             <double>0.002000000000000</double>
            </property>
           </widget>
          </item>
         </layout>
        </widget>
       </item>
       <item row="11" column="0">
        <widget class="Line" name="line_6">
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
        </widget>
       </item>
       <item row="22" column="0">
        <widget class="QCheckBox" name="m_AddEddy">
         <property name="toolTip">
          <string/>
         </property>
         <property name="text">
          <string>Add Eddy Current Effects</string>
         </property>
         <property name="checked">
          <bool>false</bool>
         </property>
        </widget>
       </item>
       <item row="12" column="0">
        <widget class="QCheckBox" name="m_AddDistortions">
         <property name="text">
          <string>Add Distortions</string>
         </property>
         <property name="checked">
          <bool>false</bool>
         </property>
        </widget>
       </item>
       <item row="3" column="0">
        <widget class="QCheckBox" name="m_AddSpikes">
         <property name="text">
          <string>Add Spikes</string>
         </property>
         <property name="checked">
          <bool>false</bool>
         </property>
        </widget>
       </item>
       <item row="15" column="0">
        <widget class="QCheckBox" name="m_AddDrift">
         <property name="text">
          <string>Add Signal Drift</string>
         </property>
         <property name="checked">
          <bool>false</bool>
         </property>
        </widget>
       </item>
       <item row="1" column="0">
        <widget class="QFrame" name="m_NoiseFrame">
         <property name="frameShape">
          <enum>QFrame::NoFrame</enum>
         </property>
         <property name="frameShadow">
          <enum>QFrame::Raised</enum>
         </property>
         <layout class="QFormLayout" name="formLayout_5">
          <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="QLabel" name="m_NoiseLabel">
            <property name="text">
             <string>Variance:</string>
            </property>
           </widget>
          </item>
          <item row="1" column="1">
           <widget class="QDoubleSpinBox" name="m_NoiseLevel">
            <property name="toolTip">
             <string>Variance of selected noise distribution.</string>
            </property>
            <property name="decimals">
             <number>10</number>
            </property>
            <property name="minimum">
             <double>0.000000000000000</double>
            </property>
            <property name="maximum">
             <double>999999999.000000000000000</double>
            </property>
            <property name="singleStep">
             <double>0.001000000000000</double>
            </property>
            <property name="value">
             <double>50.000000000000000</double>
            </property>
           </widget>
          </item>
          <item row="0" column="0">
           <widget class="QLabel" name="m_NoiseLabel_5">
            <property name="text">
             <string>Distribution:</string>
            </property>
           </widget>
          </item>
          <item row="0" column="1">
           <widget class="QComboBox" name="m_NoiseDistributionBox">
            <property name="toolTip">
             <string>Noise distribution</string>
            </property>
            <item>
             <property name="text">
              <string>Complex Gaussian</string>
             </property>
            </item>
            <item>
             <property name="text">
              <string>Rician</string>
             </property>
            </item>
           </widget>
          </item>
         </layout>
        </widget>
       </item>
       <item row="14" column="0">
        <widget class="Line" name="line_5">
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
        </widget>
       </item>
       <item row="17" column="0">
        <widget class="Line" name="line_10">
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
        </widget>
       </item>
       <item row="7" column="0">
        <widget class="QFrame" name="m_GhostFrame">
         <property name="enabled">
          <bool>true</bool>
         </property>
         <property name="frameShape">
          <enum>QFrame::NoFrame</enum>
         </property>
         <property name="frameShadow">
          <enum>QFrame::Raised</enum>
         </property>
         <layout class="QFormLayout" name="formLayout_6">
          <property name="horizontalSpacing">
           <number>6</number>
          </property>
          <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_TensorsToDWIBValueLabel_23">
            <property name="toolTip">
             <string/>
            </property>
            <property name="statusTip">
             <string/>
            </property>
            <property name="whatsThis">
             <string/>
            </property>
            <property name="text">
             <string>K-Space Line Offset:</string>
            </property>
            <property name="wordWrap">
             <bool>false</bool>
            </property>
           </widget>
          </item>
          <item row="0" column="1">
           <widget class="QDoubleSpinBox" name="m_kOffsetBox">
            <property name="toolTip">
             <string>A larger offset increases the inensity of the ghost image.</string>
            </property>
            <property name="decimals">
             <number>3</number>
            </property>
            <property name="maximum">
             <double>1.000000000000000</double>
            </property>
            <property name="singleStep">
             <double>0.010000000000000</double>
            </property>
            <property name="value">
             <double>0.250000000000000</double>
            </property>
           </widget>
          </item>
         </layout>
        </widget>
       </item>
       <item row="18" column="0">
        <widget class="QCheckBox" name="m_AddMotion">
         <property name="text">
          <string>Add Motion Artifacts</string>
         </property>
         <property name="checked">
          <bool>false</bool>
         </property>
        </widget>
       </item>
       <item row="6" column="0">
        <widget class="QCheckBox" name="m_AddGhosts">
         <property name="text">
          <string>Add N/2 Ghosts</string>
         </property>
         <property name="checked">
          <bool>false</bool>
         </property>
        </widget>
       </item>
       <item row="21" column="0">
        <widget class="Line" name="line_4">
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
        </widget>
       </item>
       <item row="25" column="0">
        <widget class="QCheckBox" name="m_AddGibbsRinging">
         <property name="toolTip">
          <string>Add ringing artifacts occuring at strong edges in the image.</string>
         </property>
         <property name="text">
          <string>Add Gibbs Ringing</string>
         </property>
         <property name="checked">
          <bool>false</bool>
         </property>
        </widget>
       </item>
       <item row="2" column="0">
        <widget class="Line" name="line_9">
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
        </widget>
       </item>
       <item row="0" column="0">
        <widget class="QCheckBox" name="m_AddNoise">
         <property name="text">
          <string>Add Noise</string>
         </property>
         <property name="checked">
          <bool>false</bool>
         </property>
        </widget>
       </item>
       <item row="24" column="0">
        <widget class="Line" name="line">
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
        </widget>
       </item>
       <item row="9" column="0">
        <widget class="QCheckBox" name="m_AddAliasing">
         <property name="text">
          <string>Add Aliasing</string>
         </property>
         <property name="checked">
          <bool>false</bool>
         </property>
        </widget>
       </item>
       <item row="26" column="0">
        <widget class="QSpinBox" name="m_ZeroRinging">
         <property name="toolTip">
          <string>If &gt; 0, ringing is simulated by by setting the defined percentage of higher frequencies to 0 in k-space. Otherwise, the input to the k-space simulation is generated with twice the resolution and cropped during k-space simulation (much slower).</string>
         </property>
         <property name="maximum">
          <number>100</number>
         </property>
         <property name="value">
          <number>10</number>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item row="7" 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>
    <item row="1" column="0">
     <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="1">
        <widget class="QCommandLinkButton" name="m_SaveParametersButton">
         <property name="enabled">
          <bool>true</bool>
         </property>
         <property name="toolTip">
          <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Start DWI generation from selected fiber bundle.&lt;/p&gt;&lt;p&gt;If no fiber bundle but an existing diffusion weighted image is selected, the enabled artifacts are added to this image.&lt;/p&gt;&lt;p&gt;If neither a fiber bundle nor a diffusion weighted image is selected, a grayscale image containing a simple gradient is generated.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
         </property>
         <property name="styleSheet">
          <string notr="true"/>
         </property>
         <property name="text">
          <string>Save Parameters</string>
         </property>
         <property name="icon">
-         <iconset resource="../../resources/QmitkDiffusionImaging.qrc">
-          <normaloff>:/QmitkDiffusionImaging/general_icons/download.ico</normaloff>:/QmitkDiffusionImaging/general_icons/download.ico</iconset>
+         <iconset resource="../../../../../debug/MITK-build/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/org_mitk_gui_qt_diffusionimaging_fiberfox_cached.qrc">
+          <normaloff>:/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/download.ico</normaloff>:/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/download.ico</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>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Start DWI generation from selected fiber bundle.&lt;/p&gt;&lt;p&gt;If no fiber bundle but an existing diffusion weighted image is selected, the enabled artifacts are added to this image.&lt;/p&gt;&lt;p&gt;If neither a fiber bundle nor a diffusion weighted image is selected, a grayscale image containing a simple gradient is generated.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
         </property>
         <property name="styleSheet">
          <string notr="true"/>
         </property>
         <property name="text">
          <string>Load Parameters</string>
         </property>
         <property name="icon">
-         <iconset resource="../../resources/QmitkDiffusionImaging.qrc">
-          <normaloff>:/QmitkDiffusionImaging/general_icons/upload.ico</normaloff>:/QmitkDiffusionImaging/general_icons/upload.ico</iconset>
+         <iconset resource="../../../../../debug/MITK-build/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/org_mitk_gui_qt_diffusionimaging_fiberfox_cached.qrc">
+          <normaloff>:/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/upload.ico</normaloff>:/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/upload.ico</iconset>
         </property>
        </widget>
       </item>
      </layout>
     </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_32">
       <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="QCommandLinkButton" name="m_GenerateImageButton">
         <property name="enabled">
          <bool>true</bool>
         </property>
         <property name="toolTip">
          <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Start DWI generation from selected fiber bundle.&lt;/p&gt;&lt;p&gt;If no fiber bundle but an existing diffusion weighted image is selected, the enabled artifacts are added to this image.&lt;/p&gt;&lt;p&gt;If neither a fiber bundle nor a diffusion weighted image is selected, a grayscale image containing a simple gradient is generated.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
         </property>
         <property name="styleSheet">
          <string notr="true"/>
         </property>
         <property name="text">
          <string>Start Simulation</string>
         </property>
         <property name="icon">
-         <iconset resource="../../resources/QmitkDiffusionImaging.qrc">
-          <normaloff>:/QmitkDiffusionImaging/general_icons/right.ico</normaloff>:/QmitkDiffusionImaging/general_icons/right.ico</iconset>
+         <iconset resource="../../../../../debug/MITK-build/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/org_mitk_gui_qt_diffusionimaging_fiberfox_cached.qrc">
+          <normaloff>:/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/right.ico</normaloff>:/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/right.ico</iconset>
         </property>
        </widget>
       </item>
       <item row="0" column="0">
        <widget class="QGroupBox" name="groupBox_2">
         <property name="styleSheet">
          <string notr="true">QGroupBox {
   background-color: transparent;
 }</string>
         </property>
         <property name="title">
          <string>Input Data</string>
         </property>
         <layout class="QGridLayout" name="gridLayout_10">
          <property name="leftMargin">
           <number>6</number>
          </property>
          <property name="topMargin">
           <number>6</number>
          </property>
          <property name="rightMargin">
           <number>6</number>
          </property>
          <property name="bottomMargin">
           <number>6</number>
          </property>
          <item row="4" column="2">
           <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_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="0">
              <widget class="QLineEdit" name="m_SavePathEdit">
               <property name="text">
                <string>-</string>
               </property>
              </widget>
             </item>
             <item row="0" column="1">
              <widget class="QToolButton" name="m_OutputPathButton">
               <property name="text">
                <string>...</string>
               </property>
              </widget>
             </item>
            </layout>
           </widget>
          </item>
          <item row="2" column="2">
           <widget class="QmitkDataStorageComboBoxWithSelectNone" name="m_MaskComboBox">
            <property name="toolTip">
             <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Select a binary image to define the area of signal generation. Outside of the mask image only noise will be actively generated.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
            </property>
            <property name="sizeAdjustPolicy">
             <enum>QComboBox::AdjustToMinimumContentsLength</enum>
            </property>
           </widget>
          </item>
          <item row="0" column="0" rowspan="2" colspan="2">
           <widget class="QLabel" name="m_TensorsToDWIBValueLabel_16">
            <property name="toolTip">
             <string/>
            </property>
            <property name="statusTip">
             <string/>
            </property>
            <property name="whatsThis">
             <string/>
            </property>
            <property name="text">
             <string>Fiber Bundle:</string>
            </property>
            <property name="wordWrap">
             <bool>false</bool>
            </property>
           </widget>
          </item>
          <item row="4" column="0">
           <widget class="QLabel" name="label_10">
            <property name="toolTip">
             <string/>
            </property>
            <property name="statusTip">
             <string/>
            </property>
            <property name="whatsThis">
             <string/>
            </property>
            <property name="text">
             <string>Save path:</string>
            </property>
            <property name="wordWrap">
             <bool>false</bool>
            </property>
           </widget>
          </item>
          <item row="2" column="0">
           <widget class="QLabel" name="m_TensorsToDWIBValueLabel_3">
            <property name="toolTip">
             <string/>
            </property>
            <property name="statusTip">
             <string/>
            </property>
            <property name="whatsThis">
             <string/>
            </property>
            <property name="text">
             <string>Tissue Mask:</string>
            </property>
            <property name="wordWrap">
             <bool>false</bool>
            </property>
           </widget>
          </item>
          <item row="1" column="2">
           <widget class="QmitkDataStorageComboBoxWithSelectNone" name="m_FiberBundleComboBox">
            <property name="toolTip">
             <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Select a fiber bundle to generate the white matter signal from. You can either use the fiber definition tab to manually define an input fiber bundle or you can also use any existing bundle, e.g. yielded by a tractography algorithm.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
            </property>
            <property name="sizeAdjustPolicy">
             <enum>QComboBox::AdjustToMinimumContentsLength</enum>
            </property>
           </widget>
          </item>
          <item row="3" column="0">
           <widget class="QLabel" name="m_TensorsToDWIBValueLabel_11">
            <property name="toolTip">
             <string/>
            </property>
            <property name="statusTip">
             <string/>
            </property>
            <property name="whatsThis">
             <string/>
            </property>
            <property name="text">
             <string>Template Image:</string>
            </property>
            <property name="wordWrap">
             <bool>false</bool>
            </property>
           </widget>
          </item>
          <item row="3" column="2">
           <widget class="QmitkDataStorageComboBoxWithSelectNone" name="m_TemplateComboBox">
            <property name="toolTip">
             <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;The parameters for the simulation (e.g. spacing, size, diffuison-weighted gradients, b-value) are adopted from this image.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
            </property>
            <property name="sizeAdjustPolicy">
             <enum>QComboBox::AdjustToMinimumContentsLength</enum>
            </property>
           </widget>
          </item>
         </layout>
        </widget>
       </item>
       <item row="2" column="0">
        <widget class="QCommandLinkButton" name="m_AbortSimulationButton">
         <property name="enabled">
          <bool>true</bool>
         </property>
         <property name="toolTip">
          <string>Stop current simulation.</string>
         </property>
         <property name="styleSheet">
          <string notr="true"/>
         </property>
         <property name="text">
          <string>Abort Simulation</string>
         </property>
         <property name="icon">
-         <iconset resource="../../resources/QmitkDiffusionImaging.qrc">
-          <normaloff>:/QmitkDiffusionImaging/general_icons/abort.ico</normaloff>:/QmitkDiffusionImaging/general_icons/abort.ico</iconset>
+         <iconset resource="../../../../../debug/MITK-build/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/org_mitk_gui_qt_diffusionimaging_fiberfox_cached.qrc">
+          <normaloff>:/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/stop.ico</normaloff>:/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/stop.ico</iconset>
         </property>
        </widget>
       </item>
       <item row="3" column="0">
        <widget class="QTextEdit" name="m_SimulationStatusText">
         <property name="font">
          <font>
           <family>Courier</family>
           <pointsize>7</pointsize>
          </font>
         </property>
         <property name="readOnly">
          <bool>true</bool>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>QmitkDataStorageComboBox</class>
    <extends>QComboBox</extends>
    <header location="global">QmitkDataStorageComboBox.h</header>
   </customwidget>
   <customwidget>
    <class>QmitkDataStorageComboBoxWithSelectNone</class>
    <extends>QComboBox</extends>
    <header>QmitkDataStorageComboBoxWithSelectNone.h</header>
   </customwidget>
   <customwidget>
    <class>QmitkTensorModelParametersWidget</class>
    <extends>QWidget</extends>
    <header location="global">QmitkTensorModelParametersWidget.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>QmitkStickModelParametersWidget</class>
    <extends>QWidget</extends>
    <header location="global">QmitkStickModelParametersWidget.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>QmitkZeppelinModelParametersWidget</class>
    <extends>QWidget</extends>
    <header location="global">QmitkZeppelinModelParametersWidget.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>QmitkBallModelParametersWidget</class>
    <extends>QWidget</extends>
    <header location="global">QmitkBallModelParametersWidget.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>QmitkAstrosticksModelParametersWidget</class>
    <extends>QWidget</extends>
    <header location="global">QmitkAstrosticksModelParametersWidget.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>QmitkDotModelParametersWidget</class>
    <extends>QWidget</extends>
    <header>QmitkDotModelParametersWidget.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>QmitkPrototypeSignalParametersWidget</class>
    <extends>QWidget</extends>
    <header>QmitkPrototypeSignalParametersWidget.h</header>
    <container>1</container>
   </customwidget>
  </customwidgets>
  <tabstops>
   <tabstop>m_FiberBundleComboBox</tabstop>
   <tabstop>m_MaskComboBox</tabstop>
   <tabstop>m_TemplateComboBox</tabstop>
   <tabstop>m_SavePathEdit</tabstop>
   <tabstop>m_OutputPathButton</tabstop>
   <tabstop>m_GenerateImageButton</tabstop>
   <tabstop>m_AbortSimulationButton</tabstop>
   <tabstop>m_SimulationStatusText</tabstop>
   <tabstop>m_LoadParametersButton</tabstop>
   <tabstop>m_SaveParametersButton</tabstop>
   <tabstop>m_SizeX</tabstop>
   <tabstop>m_SizeY</tabstop>
   <tabstop>m_SizeZ</tabstop>
   <tabstop>m_SpacingX</tabstop>
   <tabstop>m_SpacingY</tabstop>
   <tabstop>m_SpacingZ</tabstop>
   <tabstop>m_UseBvalsBvecsBox</tabstop>
   <tabstop>m_LoadBvalsEdit</tabstop>
   <tabstop>m_LoadBvalsButton</tabstop>
   <tabstop>m_LoadBvecsEdit</tabstop>
   <tabstop>m_LoadBvecsButton</tabstop>
   <tabstop>m_NumGradientsBox</tabstop>
   <tabstop>m_BvalueBox</tabstop>
   <tabstop>m_AdvancedOptionsBox_2</tabstop>
   <tabstop>m_AcquisitionTypeBox</tabstop>
   <tabstop>m_SignalScaleBox</tabstop>
   <tabstop>m_NumCoilsBox</tabstop>
   <tabstop>m_CoilSensBox</tabstop>
   <tabstop>m_TEbox</tabstop>
   <tabstop>m_TRbox</tabstop>
   <tabstop>m_TIbox</tabstop>
   <tabstop>m_LineReadoutTimeBox</tabstop>
   <tabstop>m_PartialFourier</tabstop>
   <tabstop>m_T2starBox</tabstop>
   <tabstop>m_FiberRadius</tabstop>
   <tabstop>m_ReversePhaseBox</tabstop>
   <tabstop>m_RelaxationBox</tabstop>
   <tabstop>m_EnforcePureFiberVoxelsBox</tabstop>
   <tabstop>m_VolumeFractionsBox</tabstop>
   <tabstop>m_Compartment1Box</tabstop>
   <tabstop>m_Comp1VolumeFraction</tabstop>
   <tabstop>m_Compartment2Box</tabstop>
   <tabstop>m_Comp2VolumeFraction</tabstop>
   <tabstop>m_Compartment3Box</tabstop>
   <tabstop>m_Comp3VolumeFraction</tabstop>
   <tabstop>m_Compartment4Box</tabstop>
   <tabstop>m_Comp4VolumeFraction</tabstop>
   <tabstop>m_AddNoise</tabstop>
   <tabstop>m_NoiseDistributionBox</tabstop>
   <tabstop>m_NoiseLevel</tabstop>
   <tabstop>m_AddSpikes</tabstop>
   <tabstop>m_SpikeNumBox</tabstop>
   <tabstop>m_SpikeScaleBox</tabstop>
   <tabstop>m_AddGhosts</tabstop>
   <tabstop>m_kOffsetBox</tabstop>
   <tabstop>m_AddAliasing</tabstop>
   <tabstop>m_WrapBox</tabstop>
   <tabstop>m_AddDistortions</tabstop>
   <tabstop>m_FrequencyMapBox</tabstop>
   <tabstop>m_AddDrift</tabstop>
   <tabstop>m_DriftFactor</tabstop>
   <tabstop>m_AddMotion</tabstop>
   <tabstop>m_RandomMotion</tabstop>
   <tabstop>m_MotionVolumesBox</tabstop>
   <tabstop>m_MaxRotationBoxX</tabstop>
   <tabstop>m_MaxRotationBoxY</tabstop>
   <tabstop>m_MaxRotationBoxZ</tabstop>
   <tabstop>m_MaxTranslationBoxX</tabstop>
   <tabstop>m_MaxTranslationBoxY</tabstop>
   <tabstop>m_MaxTranslationBoxZ</tabstop>
   <tabstop>m_AddEddy</tabstop>
   <tabstop>m_EddyGradientStrength</tabstop>
   <tabstop>m_AddGibbsRinging</tabstop>
   <tabstop>m_ZeroRinging</tabstop>
  </tabstops>
  <resources>
-  <include location="../../resources/QmitkDiffusionImaging.qrc"/>
+  <include location="../../../../../debug/MITK-build/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/org_mitk_gui_qt_diffusionimaging_fiberfox_cached.qrc"/>
  </resources>
  <connections/>
 </ui>
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 73168209fa..f78fb7586c 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,103 +1,104 @@
 /**
 \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 ditribution 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.
 - 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]
 
 \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/files.cmake b/Plugins/org.mitk.gui.qt.diffusionimaging.tractography/files.cmake
index aa364f9f67..f092a694af 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging.tractography/files.cmake
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging.tractography/files.cmake
@@ -1,47 +1,51 @@
 set(INTERNAL_CPP_FILES
   QmitkGibbsTrackingView.cpp
   QmitkStreamlineTrackingView.cpp
 
   Perspectives/QmitkGibbsTractographyPerspective.cpp
   Perspectives/QmitkStreamlineTractographyPerspective.cpp
 
   mitkPluginActivator.cpp
 )
 
 set(UI_FILES
   src/internal/QmitkGibbsTrackingViewControls.ui
   src/internal/QmitkStreamlineTrackingViewControls.ui
 )
 
 set(MOC_H_FILES
   src/internal/mitkPluginActivator.h
 
   src/internal/QmitkGibbsTrackingView.h
   src/internal/QmitkStreamlineTrackingView.h
 
   src/internal/Perspectives/QmitkGibbsTractographyPerspective.h
   src/internal/Perspectives/QmitkStreamlineTractographyPerspective.h
 )
 
 set(CACHED_RESOURCE_FILES
   plugin.xml
 
   resources/tract.png
   resources/tractogram.png
   resources/ml_tractography.png
+  resources/upload.ico
+  resources/download.ico
+  resources/right.ico
+  resources/stop.ico
 )
 
 set(QRC_FILES
 
 )
 
 
 set(CPP_FILES )
 
 foreach(file ${SRC_CPP_FILES})
   set(CPP_FILES ${CPP_FILES} src/${file})
 endforeach(file ${SRC_CPP_FILES})
 
 foreach(file ${INTERNAL_CPP_FILES})
   set(CPP_FILES ${CPP_FILES} src/internal/${file})
 endforeach(file ${INTERNAL_CPP_FILES})
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/download.ico b/Plugins/org.mitk.gui.qt.diffusionimaging.tractography/resources/download.ico
similarity index 100%
rename from Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/download.ico
rename to Plugins/org.mitk.gui.qt.diffusionimaging.tractography/resources/download.ico
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/right.ico b/Plugins/org.mitk.gui.qt.diffusionimaging.tractography/resources/right.ico
similarity index 100%
rename from Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/right.ico
rename to Plugins/org.mitk.gui.qt.diffusionimaging.tractography/resources/right.ico
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/stop.ico b/Plugins/org.mitk.gui.qt.diffusionimaging.tractography/resources/stop.ico
similarity index 100%
rename from Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/stop.ico
rename to Plugins/org.mitk.gui.qt.diffusionimaging.tractography/resources/stop.ico
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/upload.ico b/Plugins/org.mitk.gui.qt.diffusionimaging.tractography/resources/upload.ico
similarity index 100%
rename from Plugins/org.mitk.gui.qt.diffusionimaging.fiberfox/resources/general_icons/upload.ico
rename to Plugins/org.mitk.gui.qt.diffusionimaging.tractography/resources/upload.ico
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 cedeff348b..fcf36d578c 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,1033 +1,1159 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 #include <berryIStructuredSelection.h>
 
 // Qmitk
 #include "QmitkStreamlineTrackingView.h"
 #include "QmitkStdMultiWidget.h"
 
 // Qt
 #include <QMessageBox>
 #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, SIGNAL(CurrentSelectionChanged(QList<mitk::DataNode::Pointer>)), this, SLOT(DeleteTrackingHandler()) );
     connect( m_Controls->m_ModeBox, SIGNAL(currentIndexChanged(int)), this, SLOT(DeleteTrackingHandler()) );
     connect( m_Controls->m_OutputProbMap, SIGNAL(stateChanged(int)), this, SLOT(OutputStyleSwitched()) );
 
     connect( m_Controls->m_SeedImageSelectionWidget, SIGNAL(CurrentSelectionChanged(QList<mitk::DataNode::Pointer>)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_ModeBox, SIGNAL(currentIndexChanged(int)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_StopImageSelectionWidget, SIGNAL(CurrentSelectionChanged(QList<mitk::DataNode::Pointer>)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_TargetImageSelectionWidget, SIGNAL(CurrentSelectionChanged(QList<mitk::DataNode::Pointer>)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_PriorImageSelectionWidget, SIGNAL(CurrentSelectionChanged(QList<mitk::DataNode::Pointer>)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_ExclusionImageSelectionWidget, SIGNAL(CurrentSelectionChanged(QList<mitk::DataNode::Pointer>)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_MaskImageSelectionWidget, SIGNAL(CurrentSelectionChanged(QList<mitk::DataNode::Pointer>)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_FaImageSelectionWidget, SIGNAL(CurrentSelectionChanged(QList<mitk::DataNode::Pointer>)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_ForestSelectionWidget, SIGNAL(CurrentSelectionChanged(QList<mitk::DataNode::Pointer>)), this, SLOT(ForestSwitched()) );
     connect( m_Controls->m_ForestSelectionWidget, SIGNAL(CurrentSelectionChanged(QList<mitk::DataNode::Pointer>)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_SeedsPerVoxelBox, SIGNAL(editingFinished()), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_NumFibersBox, SIGNAL(editingFinished()), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_ScalarThresholdBox, SIGNAL(editingFinished()), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_OdfCutoffBox, SIGNAL(editingFinished()), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_StepSizeBox, SIGNAL(editingFinished()), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_SamplingDistanceBox, SIGNAL(editingFinished()), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_AngularThresholdBox, SIGNAL(editingFinished()), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_MinTractLengthBox, SIGNAL(editingFinished()), this, SLOT(OnParameterChanged()) );
+    connect( m_Controls->m_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_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()) );
 
     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();
 
     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_FiberErrorBox->setValue(params.m_Compression);
+  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_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);
+
+  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()
 {
+
+  // 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;
+
   std::shared_ptr<mitk::StreamlineTractographyParameters> params = std::make_shared<mitk::StreamlineTractographyParameters>();
+  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_Compression = m_Controls->m_FiberErrorBox->value();
+  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_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();
 
   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 Parameters"),
+        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->SetReferenceGeometry(dynamic_cast<mitk::Image*>(m_ParentNode->GetData())->GetGeometry());
     if (m_Controls->m_ResampleFibersBox->isChecked() && fiberBundle->GetNumberOfLines()>0)
       fib->Compress(m_Controls->m_FiberErrorBox->value());
     fib->ColorFibersByOrientation();
     m_Tracker->SetDicomProperties(fib);
 
     if (m_Controls->m_InteractiveBox->isChecked())
     {
       if (m_InteractiveNode.IsNull())
       {
         m_InteractiveNode = mitk::DataNode::New();
         QString name("Interactive");
         m_InteractiveNode->SetName(name.toStdString());
         GetDataStorage()->Add(m_InteractiveNode);
       }
       m_InteractiveNode->SetData(fib);
       m_InteractiveNode->SetFloatProperty("Fiber2DSliceThickness", 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());
 
     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<float> world_pos = this->GetRenderWindowPart()->GetSelectedPosition();
 
   m_SeedPoints.push_back(world_pos);
   float radius = m_Controls->m_SeedRadiusBox->value();
   int num = m_Controls->m_NumSeedsBox->value();
 
   mitk::PointSet::Pointer pointset = mitk::PointSet::New();
   pointset->InsertPoint(0, world_pos);
   m_InteractivePointSetNode->SetProperty("pointsize", mitk::FloatProperty::New(radius*2));
   m_InteractivePointSetNode->SetProperty("point 2D size", mitk::FloatProperty::New(radius*2));
   m_InteractivePointSetNode->SetData(pointset);
 
   for (int i=1; i<num; i++)
   {
     itk::Vector<float> p;
     p[0] = rand()%1000-500;
     p[1] = rand()%1000-500;
     p[2] = rand()%1000-500;
     p.Normalize();
     p *= radius;
     m_SeedPoints.push_back(world_pos+p);
   }
   m_InteractivePointSetNode->SetProperty("color", mitk::ColorProperty::New(1,0,0));
   DoFiberTracking();
 }
 
 bool QmitkStreamlineTrackingView::CheckAndStoreLastParams(QObject* obj)
 {
   if (obj!=nullptr)
   {
     std::string new_val = "";
     if(qobject_cast<QDoubleSpinBox*>(obj)!=nullptr)
       new_val = boost::lexical_cast<std::string>(qobject_cast<QDoubleSpinBox*>(obj)->value());
     else if (qobject_cast<QSpinBox*>(obj)!=nullptr)
       new_val = boost::lexical_cast<std::string>(qobject_cast<QSpinBox*>(obj)->value());
     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);
 
   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);
   }
 
   // trials per seed are only important for probabilistic tractography
   if (m_Controls->m_ModeBox->currentIndex()==1)
   {
     m_Controls->m_TrialsPerSeedBox->setEnabled(true);
     m_Controls->m_TrialsPerSeedLabel->setEnabled(true);
   }
 
   if(!m_InputImageNodes.empty())
   {
     if (m_InputImageNodes.size()>1)
       m_Controls->m_TensorImageLabel->setText( ( std::to_string(m_InputImageNodes.size()) + " images selected").c_str() );
     else
       m_Controls->m_TensorImageLabel->setText(m_InputImageNodes.at(0)->GetName().c_str());
     m_Controls->commandLinkButton->setEnabled(!m_Controls->m_InteractiveBox->isChecked() && !m_ThreadIsRunning);
 
     m_Controls->m_ScalarThresholdBox->setEnabled(true);
     m_Controls->m_FaThresholdLabel->setEnabled(true);
 
     if ( dynamic_cast<mitk::TensorImage*>(m_InputImageNodes.at(0)->GetData()) )
     {
       m_Controls->m_fBox->setEnabled(true);
       m_Controls->m_fLabel->setEnabled(true);
       m_Controls->m_gBox->setEnabled(true);
       m_Controls->m_gLabel->setEnabled(true);
     }
     else if ( dynamic_cast<mitk::OdfImage*>(m_InputImageNodes.at(0)->GetData()) ||
               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);
     }
   }
 }
 
 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_Controls->m_ModeBox->currentIndex()==1)
     {
       QMessageBox::information(nullptr, "Information", "Probabilstic tractography is not implemented for peak images.");
       StartStopTrackingGui(false);
       return;
     }
     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;
   }
 
   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/QmitkStreamlineTrackingView.h b/Plugins/org.mitk.gui.qt.diffusionimaging.tractography/src/internal/QmitkStreamlineTrackingView.h
index 3e392063b0..96b5d49952 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging.tractography/src/internal/QmitkStreamlineTrackingView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging.tractography/src/internal/QmitkStreamlineTrackingView.h
@@ -1,158 +1,160 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef QmitkStreamlineTrackingView_h
 #define QmitkStreamlineTrackingView_h
 
 #include <QmitkAbstractView.h>
 
 #include "ui_QmitkStreamlineTrackingViewControls.h"
 
 #include <mitkTensorImage.h>
 #include <mitkDataStorage.h>
 #include <mitkDataNode.h>
 #include <mitkImage.h>
 #include <itkImage.h>
 #include <itkStreamlineTrackingFilter.h>
 #include <Algorithms/TrackingHandlers/mitkTrackingHandlerTensor.h>
 #include <Algorithms/TrackingHandlers/mitkTrackingHandlerPeaks.h>
 #include <Algorithms/TrackingHandlers/mitkTrackingHandlerOdf.h>
 #include <Algorithms/TrackingHandlers/mitkTrackingHandlerRandomForest.h>
 #include <random>
 #include <mitkPointSet.h>
 #include <mitkPointSetShapeProperty.h>
 #include <mitkTractographyForest.h>
 #include <QThread>
 #include <QTimer>
 #include <QmitkStdMultiWidget.h>
 #include <QmitkSliceNavigationListener.h>
 #include <mitkILifecycleAwarePart.h>
 #include <mitkStreamlineTractographyParameters.h>
 
 class QmitkStreamlineTrackingView;
 
 class QmitkStreamlineTrackingWorker : public QObject
 {
   Q_OBJECT
 
 public:
 
   QmitkStreamlineTrackingWorker(QmitkStreamlineTrackingView* view);
 
 public slots:
 
   void run();
 
 private:
 
   QmitkStreamlineTrackingView* m_View;
 };
 
 /*!
 \brief View for tensor based deterministic streamline fiber tracking.
 */
 class QmitkStreamlineTrackingView : public QmitkAbstractView, public mitk::ILifecycleAwarePart
 {
   // this is needed for all Qt objects that should have a Qt meta-object
   // (everything that derives from QObject and wants to have signal/slots)
   Q_OBJECT
 
 public:
 
   static const std::string VIEW_ID;
 
   typedef itk::Image< unsigned int, 3 >   ItkUintImgType;
   typedef itk::Image< unsigned char, 3 >  ItkUCharImageType;
   typedef itk::Image< float, 3 >          ItkFloatImageType;
   typedef itk::StreamlineTrackingFilter   TrackerType;
 
   QmitkStreamlineTrackingView();
   virtual ~QmitkStreamlineTrackingView();
 
   virtual void CreateQtPartControl(QWidget *parent) override;
 
   ///
   /// Sets the focus to an internal widget.
   ///
   virtual void SetFocus() override;
 
   TrackerType::Pointer              m_Tracker;
   QmitkStreamlineTrackingWorker     m_TrackingWorker;
   QThread                           m_TrackingThread;
 
   virtual void Activated() override;
   virtual void Deactivated() override;
   virtual void Visible() override;
   virtual void Hidden() override;
 
 protected slots:
 
   void DoFiberTracking();   ///< start fiber tracking
   void UpdateGui();
   void ToggleInteractive();
   void DeleteTrackingHandler();
   void OnParameterChanged();
   void InteractiveSeedChanged(bool posChanged=false);
   void ForestSwitched();
   void OutputStyleSwitched();
   void AfterThread();                       ///< update gui etc. after tracking has finished
   void BeforeThread();                      ///< start timer etc.
   void TimerUpdate();
   void StopTractography();
   void OnSliceChanged();
   void SaveParameters();
+  void LoadParameters();
 
 protected:
 
   /// \brief called by QmitkAbstractView when DataManager's selection has changed
   virtual void OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList<mitk::DataNode::Pointer>& nodes) override;
 
   Ui::QmitkStreamlineTrackingViewControls* m_Controls;
 
 protected slots:
 
 private:
 
   bool CheckAndStoreLastParams(QObject* obj);
   void StartStopTrackingGui(bool start);
   std::shared_ptr< mitk::StreamlineTractographyParameters > GetParametersFromGui();
+  void ParametersToGui(mitk::StreamlineTractographyParameters& params);
 
   std::vector< itk::Point<float> >        m_SeedPoints;
   mitk::DataNode::Pointer                 m_ParentNode;
   mitk::DataNode::Pointer                 m_InteractiveNode;
   mitk::DataNode::Pointer                 m_InteractivePointSetNode;
 
   std::vector< mitk::DataNode::Pointer >  m_InputImageNodes; ///< input image nodes
   std::vector< mitk::Image::ConstPointer >     m_AdditionalInputImages;
   bool                                    m_FirstTensorProbRun;
   bool                                    m_FirstInteractiveRun;
 
   mitk::TrackingDataHandler*              m_TrackingHandler;
   bool                                    m_ThreadIsRunning;
   QTimer*                                 m_TrackingTimer;
   bool                                    m_DeleteTrackingHandler;
   QmitkSliceNavigationListener            m_SliceChangeListener;
   bool                                    m_Visible;
   mitk::DataNode::Pointer                 m_LastPrior;
   mitk::TrackingDataHandler*              m_TrackingPriorHandler;
   std::map< QString, std::string >        m_LastTractoParams;
   QString                                 m_ParameterFile;
 };
 
 
 
 #endif // _QMITKFIBERTRACKINGVIEW_H_INCLUDED
 
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 119a845d75..129085a998 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,1579 +1,1669 @@
 <?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="../../../../../debug/MITK-build/Plugins/org.mitk.gui.qt.diffusionimaging.tractography/org_mitk_gui_qt_diffusionimaging_tractography_cached.qrc">
+             <normaloff>:/org.mitk.gui.qt.diffusionimaging.tractography/resources/download.ico</normaloff>:/org.mitk.gui.qt.diffusionimaging.tractography/resources/download.ico</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="../../../../../debug/MITK-build/Plugins/org.mitk.gui.qt.diffusionimaging.tractography/org_mitk_gui_qt_diffusionimaging_tractography_cached.qrc">
+             <normaloff>:/org.mitk.gui.qt.diffusionimaging.tractography/resources/upload.ico</normaloff>:/org.mitk.gui.qt.diffusionimaging.tractography/resources/upload.ico</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="../../../../../debug/MITK-build/Plugins/org.mitk.gui.qt.diffusionimaging.tractography/org_mitk_gui_qt_diffusionimaging_tractography_cached.qrc">
+          <normaloff>:/org.mitk.gui.qt.diffusionimaging.tractography/resources/right.ico</normaloff>:/org.mitk.gui.qt.diffusionimaging.tractography/resources/right.ico</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="../../../../../debug/MITK-build/Plugins/org.mitk.gui.qt.diffusionimaging.tractography/org_mitk_gui_qt_diffusionimaging_tractography_cached.qrc">
+          <normaloff>:/org.mitk.gui.qt.diffusionimaging.tractography/resources/stop.ico</normaloff>:/org.mitk.gui.qt.diffusionimaging.tractography/resources/stop.ico</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>
-      <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>
-       </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>
-       </widget>
-      </item>
-      <item row="4" column="0">
-       <widget class="QCommandLinkButton" name="m_SaveParametersButton">
-        <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>Save Parameters</string>
-        </property>
-       </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>
                </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>
+             <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>232</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>0</y>
         <width>421</width>
-        <height>366</height>
+        <height>397</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="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="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="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="14" 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="15" 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="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="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="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="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="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="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="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="4" column="1">
         <widget class="QmitkSingleNodeSelectionWidget" name="m_FaImageSelectionWidget" native="true"/>
        </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="11" column="1">
         <widget class="QSpinBox" name="m_LoopCheckBox">
          <property name="toolTip">
           <string>Maximum allowed angular SDTEV over 4 voxel lengths. Default: no loop check.</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>-1</number>
          </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="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="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="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="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="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="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="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="14" 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="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="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>
       </layout>
      </widget>
      <widget class="QWidget" name="page_prior">
       <property name="geometry">
        <rect>
         <x>0</x>
         <y>0</y>
         <width>435</width>
-        <height>232</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>232</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>232</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>232</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="0" column="0">
         <widget class="QFrame" name="frame_5">
          <property name="frameShape">
           <enum>QFrame::NoFrame</enum>
          </property>
          <property name="frameShadow">
           <enum>QFrame::Raised</enum>
          </property>
          <layout class="QGridLayout" name="gridLayout_8">
           <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_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="0" column="1">
            <widget class="QDoubleSpinBox" name="m_FiberErrorBox">
             <property name="focusPolicy">
              <enum>Qt::StrongFocus</enum>
             </property>
             <property name="toolTip">
              <string>Lossy fiber compression. Recommended for large tractograms. Maximum error in mm.</string>
             </property>
             <property name="decimals">
              <number>3</number>
             </property>
             <property name="maximum">
              <double>10.000000000000000</double>
             </property>
             <property name="singleStep">
              <double>0.010000000000000</double>
             </property>
             <property name="value">
              <double>0.100000000000000</double>
             </property>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
        <item row="1" 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>
        <item row="2" 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>
       </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/>
+ <resources>
+  <include location="../../../../../debug/MITK-build/Plugins/org.mitk.gui.qt.diffusionimaging.tractography/org_mitk_gui_qt_diffusionimaging_tractography_cached.qrc"/>
+ </resources>
  <connections/>
 </ui>
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/files.cmake b/Plugins/org.mitk.gui.qt.diffusionimaging/files.cmake
index 3ccd164796..5e3c8cf288 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/files.cmake
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/files.cmake
@@ -1,66 +1,67 @@
 set(SRC_CPP_FILES
 )
 
 set(INTERNAL_CPP_FILES
   mitkPluginActivator.cpp
   QmitkDiffusionDicomImportView.cpp
   QmitkControlVisualizationPropertiesView.cpp
   QmitkDicomTractogramTagEditorView.cpp
 
   Perspectives/QmitkDiffusionDefaultPerspective.cpp
   Perspectives/QmitkSegmentationPerspective.cpp
 )
 
 set(UI_FILES
   src/internal/QmitkDiffusionDicomImportViewControls.ui
   src/internal/QmitkControlVisualizationPropertiesViewControls.ui
   src/internal/QmitkDicomTractogramTagEditorViewControls.ui
 )
 
 set(MOC_H_FILES
   src/internal/mitkPluginActivator.h
   src/internal/QmitkDiffusionDicomImportView.h
   src/internal/QmitkControlVisualizationPropertiesView.h
   src/internal/QmitkDicomTractogramTagEditorView.h
 
   src/internal/Perspectives/QmitkDiffusionDefaultPerspective.h
   src/internal/Perspectives/QmitkSegmentationPerspective.h
 )
 
 set(CACHED_RESOURCE_FILES
 # list of resource files which can be used by the plug-in
 # system without loading the plug-ins shared library,
 # for example the icon used in the menu and tabs for the
 # plug-in views in the workbench
   plugin.xml
 
   resources/dwiimport.png
   resources/vizControls.png
   resources/arrow.png
   resources/dwi.png
   resources/odf.png
   resources/tensor.png
   resources/tractogram.png
   resources/odf_peaks.png
   resources/ml_tractogram.png
   resources/sh.png
   resources/refresh.xpm
   resources/segmentation.svg
+  resources/color64.gif
  )
 
 set(QRC_FILES
 # uncomment the following line if you want to use Qt resources
   resources/QmitkDiffusionImaging.qrc
   #resources/QmitkTractbasedSpatialStatisticsView.qrc
 )
 
 set(CPP_FILES )
 
 foreach(file ${SRC_CPP_FILES})
   set(CPP_FILES ${CPP_FILES} src/${file})
 endforeach(file ${SRC_CPP_FILES})
 
 foreach(file ${INTERNAL_CPP_FILES})
   set(CPP_FILES ${CPP_FILES} src/internal/${file})
 endforeach(file ${INTERNAL_CPP_FILES})
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesViewControls.ui b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesViewControls.ui
index b6aa4a390d..916289c887 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesViewControls.ui
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkControlVisualizationPropertiesViewControls.ui
@@ -1,1001 +1,1002 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkControlVisualizationPropertiesViewControls</class>
  <widget class="QWidget" name="QmitkControlVisualizationPropertiesViewControls">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>567</width>
     <height>619</height>
    </rect>
   </property>
   <property name="sizePolicy">
    <sizepolicy hsizetype="Preferred" vsizetype="MinimumExpanding">
     <horstretch>0</horstretch>
     <verstretch>100</verstretch>
    </sizepolicy>
   </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="QVBoxLayout" name="verticalLayout_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>
     <widget class="QFrame" name="m_ImageControlsFrame">
      <property name="frameShape">
       <enum>QFrame::NoFrame</enum>
      </property>
      <property name="frameShadow">
       <enum>QFrame::Raised</enum>
      </property>
      <layout class="QVBoxLayout" name="verticalLayout">
       <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>
        <widget class="QFrame" name="frame_2">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="frameShape">
          <enum>QFrame::NoFrame</enum>
         </property>
         <property name="frameShadow">
          <enum>QFrame::Raised</enum>
         </property>
         <layout class="QHBoxLayout" name="horizontalLayout_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>
           <widget class="QToolButton" name="m_TSMenu">
            <property name="toolTip">
             <string>Multislice Projection</string>
            </property>
            <property name="statusTip">
             <string/>
            </property>
            <property name="whatsThis">
             <string/>
            </property>
            <property name="text">
             <string>MIP   </string>
            </property>
            <property name="popupMode">
             <enum>QToolButton::MenuButtonPopup</enum>
            </property>
            <property name="arrowType">
             <enum>Qt::NoArrow</enum>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QFrame" name="m_NumberGlyphsFrame">
            <property name="frameShape">
             <enum>QFrame::NoFrame</enum>
            </property>
            <property name="frameShadow">
             <enum>QFrame::Plain</enum>
            </property>
            <layout class="QHBoxLayout" name="horizontalLayout_6">
             <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>
              <widget class="QToolButton" name="m_VisibleOdfsON_T">
               <property name="toolTip">
                <string>Toggle visibility of ODF glyphs (axial)</string>
               </property>
               <property name="statusTip">
                <string/>
               </property>
               <property name="whatsThis">
                <string/>
               </property>
               <property name="text">
                <string/>
               </property>
               <property name="icon">
                <iconset resource="../../resources/QmitkDiffusionImaging.qrc">
                 <normaloff>:/QmitkDiffusionImaging/glyphsoff_T.png</normaloff>
                 <normalon>:/QmitkDiffusionImaging/glyphson_T.png</normalon>:/QmitkDiffusionImaging/glyphsoff_T.png</iconset>
               </property>
               <property name="checkable">
                <bool>true</bool>
               </property>
               <property name="checked">
                <bool>false</bool>
               </property>
              </widget>
             </item>
             <item>
              <widget class="QToolButton" name="m_VisibleOdfsON_S">
               <property name="toolTip">
                <string>Toggle visibility of ODF glyphs (sagittal)</string>
               </property>
               <property name="statusTip">
                <string/>
               </property>
               <property name="whatsThis">
                <string/>
               </property>
               <property name="text">
                <string/>
               </property>
               <property name="icon">
                <iconset resource="../../resources/QmitkDiffusionImaging.qrc">
                 <normaloff>:/QmitkDiffusionImaging/glyphsoff_S.png</normaloff>
                 <normalon>:/QmitkDiffusionImaging/glyphson_S.png</normalon>:/QmitkDiffusionImaging/glyphsoff_S.png</iconset>
               </property>
               <property name="checkable">
                <bool>true</bool>
               </property>
               <property name="checked">
                <bool>false</bool>
               </property>
              </widget>
             </item>
             <item>
              <widget class="QToolButton" name="m_VisibleOdfsON_C">
               <property name="toolTip">
                <string>Toggle visibility of ODF glyphs (coronal)</string>
               </property>
               <property name="statusTip">
                <string/>
               </property>
               <property name="whatsThis">
                <string/>
               </property>
               <property name="text">
                <string/>
               </property>
               <property name="icon">
                <iconset resource="../../resources/QmitkDiffusionImaging.qrc">
                 <normaloff>:/QmitkDiffusionImaging/glyphsoff_C.png</normaloff>
                 <normalon>:/QmitkDiffusionImaging/glyphson_C.png</normalon>:/QmitkDiffusionImaging/glyphsoff_C.png</iconset>
               </property>
               <property name="checkable">
                <bool>true</bool>
               </property>
               <property name="checked">
                <bool>false</bool>
               </property>
              </widget>
             </item>
             <item>
              <widget class="QLabel" name="label_glyphs">
               <property name="text">
                <string>#Glyphs</string>
               </property>
              </widget>
             </item>
             <item>
              <widget class="QSpinBox" name="m_ShowMaxNumber">
               <property name="maximum">
                <number>9999</number>
               </property>
              </widget>
             </item>
             <item>
              <spacer name="horizontalSpacer">
               <property name="orientation">
                <enum>Qt::Horizontal</enum>
               </property>
               <property name="sizeHint" stdset="0">
                <size>
                 <width>20</width>
                 <height>20</height>
                </size>
               </property>
              </spacer>
             </item>
            </layout>
           </widget>
          </item>
         </layout>
        </widget>
       </item>
       <item>
        <widget class="QFrame" name="m_GlyphFrame">
         <property name="frameShape">
          <enum>QFrame::NoFrame</enum>
         </property>
         <property name="frameShadow">
          <enum>QFrame::Raised</enum>
         </property>
         <layout class="QVBoxLayout" name="verticalLayout_2">
          <property name="spacing">
           <number>0</number>
          </property>
          <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>
           <widget class="QFrame" name="m_NormalizationScalingFrame">
            <property name="frameShape">
             <enum>QFrame::NoFrame</enum>
            </property>
            <property name="frameShadow">
             <enum>QFrame::Raised</enum>
            </property>
            <layout class="QGridLayout" name="gridLayout">
             <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="QFrame" name="m_NormalizationFrame">
               <property name="frameShape">
                <enum>QFrame::NoFrame</enum>
               </property>
               <property name="frameShadow">
                <enum>QFrame::Plain</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="5" column="1">
                 <widget class="QComboBox" name="m_NormalizationDropdown">
                  <property name="toolTip">
                   <string>ODF normalization</string>
                  </property>
                  <property name="frame">
                   <bool>false</bool>
                  </property>
                  <item>
                   <property name="text">
                    <string>Min-Max</string>
                   </property>
                  </item>
                  <item>
                   <property name="text">
                    <string>Max</string>
                   </property>
                  </item>
                  <item>
                   <property name="text">
                    <string>None</string>
                   </property>
                  </item>
                 </widget>
                </item>
                <item row="5" column="0">
                 <widget class="QLabel" name="m_NormalizationLabel">
                  <property name="text">
                   <string>ODF Normalization:</string>
                  </property>
                 </widget>
                </item>
                <item row="7" column="1">
                 <widget class="QComboBox" name="m_OdfColorBox">
                  <property name="toolTip">
                   <string>ODF normalization</string>
                  </property>
                  <property name="frame">
                   <bool>false</bool>
                  </property>
                  <item>
                   <property name="text">
                    <string>ODF Value</string>
                   </property>
                  </item>
                  <item>
                   <property name="text">
                    <string>Principal Direction</string>
                   </property>
                  </item>
                 </widget>
                </item>
                <item row="7" column="0">
                 <widget class="QLabel" name="label_4">
                  <property name="text">
                   <string>Color ODFs/Tensors by:</string>
                  </property>
                 </widget>
                </item>
               </layout>
              </widget>
             </item>
             <item row="1" column="0">
              <widget class="QFrame" name="m_ScalingFrame">
               <property name="frameShape">
                <enum>QFrame::NoFrame</enum>
               </property>
               <property name="frameShadow">
                <enum>QFrame::Plain</enum>
               </property>
               <layout class="QHBoxLayout" name="horizontalLayout_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>
                 <widget class="QLabel" name="label_2">
                  <property name="text">
                   <string>ODF Scale:</string>
                  </property>
                 </widget>
                </item>
                <item>
                 <widget class="QComboBox" name="m_AdditionalScaling">
                  <property name="frame">
                   <bool>false</bool>
                  </property>
                  <item>
                   <property name="text">
                    <string>None</string>
                   </property>
                  </item>
                  <item>
                   <property name="text">
                    <string>FA/GFA</string>
                   </property>
                  </item>
                 </widget>
                </item>
                <item>
                 <widget class="QLabel" name="label">
                  <property name="text">
                   <string>*</string>
                  </property>
                 </widget>
                </item>
                <item>
                 <widget class="QDoubleSpinBox" name="m_ScalingFactor">
                  <property name="toolTip">
                   <string>Additional scaling factor</string>
                  </property>
                  <property name="decimals">
                   <number>3</number>
                  </property>
                  <property name="maximum">
                   <double>999999999.000000000000000</double>
                  </property>
                  <property name="singleStep">
                   <double>0.100000000000000</double>
                  </property>
                  <property name="value">
                   <double>1.000000000000000</double>
                  </property>
                 </widget>
                </item>
               </layout>
              </widget>
             </item>
            </layout>
           </widget>
          </item>
         </layout>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <widget class="QFrame" name="m_BundleControlsFrame">
      <property name="frameShape">
       <enum>QFrame::NoFrame</enum>
      </property>
      <property name="frameShadow">
       <enum>QFrame::Raised</enum>
      </property>
      <layout class="QVBoxLayout" name="verticalLayout_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>
        <widget class="QFrame" name="frame_5">
         <property name="frameShape">
          <enum>QFrame::NoFrame</enum>
         </property>
         <property name="frameShadow">
          <enum>QFrame::Raised</enum>
         </property>
         <layout class="QHBoxLayout" name="horizontalLayout_11">
          <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>
           <widget class="QToolButton" name="m_SetColor2">
            <property name="toolTip">
-            <string>Reset to Default Coloring</string>
+            <string>Select Fiber Color</string>
            </property>
            <property name="text">
             <string/>
            </property>
            <property name="icon">
-            <iconset resource="../../resources/QmitkDiffusionImaging.qrc">
-             <normaloff>:/QmitkDiffusionImaging/color64.gif</normaloff>:/QmitkDiffusionImaging/color64.gif</iconset>
+            <iconset resource="../../../../../debug/MITK-build/Plugins/org.mitk.gui.qt.diffusionimaging/org_mitk_gui_qt_diffusionimaging_cached.qrc">
+             <normaloff>:/org.mitk.gui.qt.diffusionimaging/resources/color64.gif</normaloff>:/org.mitk.gui.qt.diffusionimaging/resources/color64.gif</iconset>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QToolButton" name="m_ResetColoring">
            <property name="toolTip">
             <string>Reset to Default Coloring</string>
            </property>
            <property name="text">
             <string/>
            </property>
            <property name="icon">
             <iconset resource="../../resources/QmitkDiffusionImaging.qrc">
              <normaloff>:/QmitkDiffusionImaging/reset.png</normaloff>:/QmitkDiffusionImaging/reset.png</iconset>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QToolButton" name="m_Crosshair">
            <property name="toolTip">
             <string>Position Crosshair by 3D-Click</string>
            </property>
            <property name="statusTip">
             <string/>
            </property>
            <property name="text">
             <string/>
            </property>
            <property name="icon">
             <iconset resource="../../resources/QmitkDiffusionImaging.qrc">
              <normaloff>:/QmitkDiffusionImaging/crosshair.png</normaloff>:/QmitkDiffusionImaging/crosshair.png</iconset>
            </property>
            <property name="checkable">
             <bool>true</bool>
            </property>
            <property name="checked">
             <bool>false</bool>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QToolButton" name="m_FiberFading2D">
            <property name="toolTip">
             <string>2D Fiberfading on/off</string>
            </property>
            <property name="text">
             <string/>
            </property>
           </widget>
          </item>
          <item>
           <spacer name="horizontalSpacer_2">
            <property name="orientation">
             <enum>Qt::Horizontal</enum>
            </property>
            <property name="sizeHint" stdset="0">
             <size>
              <width>40</width>
              <height>20</height>
             </size>
            </property>
           </spacer>
          </item>
         </layout>
        </widget>
       </item>
       <item>
        <widget class="QFrame" name="frame_6">
         <property name="frameShape">
          <enum>QFrame::NoFrame</enum>
         </property>
         <property name="frameShadow">
          <enum>QFrame::Raised</enum>
         </property>
         <layout class="QHBoxLayout" name="horizontalLayout_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>
           <widget class="QLabel" name="label_5">
            <property name="text">
             <string>2D Clipping</string>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QSlider" name="m_FiberThicknessSlider">
            <property name="maximum">
             <number>100</number>
            </property>
            <property name="pageStep">
             <number>10</number>
            </property>
            <property name="value">
             <number>10</number>
            </property>
            <property name="sliderPosition">
             <number>10</number>
            </property>
            <property name="orientation">
             <enum>Qt::Horizontal</enum>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QLabel" name="label_range">
            <property name="minimumSize">
             <size>
              <width>90</width>
              <height>0</height>
             </size>
            </property>
            <property name="maximumSize">
             <size>
              <width>10000</width>
              <height>16777215</height>
             </size>
            </property>
            <property name="text">
             <string>Range</string>
            </property>
           </widget>
          </item>
         </layout>
        </widget>
       </item>
       <item>
        <widget class="QFrame" name="frame_linewidth">
         <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="1" column="0">
           <widget class="QLabel" name="label_8">
            <property name="text">
             <string>Tube Radius</string>
            </property>
           </widget>
          </item>
          <item row="1" column="1">
           <widget class="QDoubleSpinBox" name="m_TubeWidth">
            <property name="decimals">
             <number>3</number>
            </property>
            <property name="singleStep">
             <double>0.100000000000000</double>
            </property>
           </widget>
          </item>
          <item row="2" column="0">
           <widget class="QLabel" name="label_9">
            <property name="text">
             <string>Ribbon Width</string>
            </property>
           </widget>
          </item>
          <item row="2" column="1">
           <widget class="QDoubleSpinBox" name="m_RibbonWidth">
            <property name="decimals">
             <number>3</number>
            </property>
            <property name="singleStep">
             <double>0.100000000000000</double>
            </property>
           </widget>
          </item>
         </layout>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <widget class="QLabel" name="m_lblRotatedPlanesWarning">
      <property name="font">
       <font>
        <weight>50</weight>
        <italic>false</italic>
        <bold>false</bold>
       </font>
      </property>
      <property name="text">
       <string>&lt;!DOCTYPE HTML PUBLIC &quot;-//W3C//DTD HTML 4.0//EN&quot; &quot;http://www.w3.org/TR/REC-html40/strict.dtd&quot;&gt;
 &lt;html&gt;&lt;head&gt;&lt;meta name=&quot;qrichtext&quot; content=&quot;1&quot; /&gt;&lt;style type=&quot;text/css&quot;&gt;
 p, li { white-space: pre-wrap; }
 &lt;/style&gt;&lt;/head&gt;&lt;body style=&quot; font-family:'Ubuntu'; font-size:11pt; font-weight:400; font-style:normal;&quot;&gt;
 &lt;p align=&quot;center&quot; style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;span style=&quot; color:#ff0000;&quot;&gt;One or more slices are rotated.  ODF Visualisation is not possible in rotated planes. Use 'Reinit' on the image node to reset. &lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
      </property>
      <property name="textFormat">
       <enum>Qt::AutoText</enum>
      </property>
      <property name="wordWrap">
       <bool>true</bool>
      </property>
     </widget>
    </item>
    <item>
     <widget class="QFrame" name="m_PeakImageFrame">
      <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="2">
        <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_6">
          <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="3">
           <widget class="QCheckBox" name="m_FlipPeaksY">
            <property name="text">
             <string>y</string>
            </property>
           </widget>
          </item>
          <item row="1" column="4">
           <widget class="QCheckBox" name="m_FlipPeaksZ">
            <property name="text">
             <string>z</string>
            </property>
           </widget>
          </item>
          <item row="1" column="2">
           <widget class="QCheckBox" name="m_FlipPeaksX">
            <property name="text">
             <string>x</string>
            </property>
           </widget>
          </item>
          <item row="1" column="1">
           <widget class="QCommandLinkButton" name="m_FlipPeaksButton">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="text">
             <string>Flip Peaks</string>
            </property>
           </widget>
          </item>
         </layout>
        </widget>
       </item>
       <item row="0" 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="1">
           <widget class="QToolButton" name="m_ResetColoring2">
            <property name="toolTip">
             <string>Reset to Default Coloring</string>
            </property>
            <property name="text">
             <string/>
            </property>
            <property name="icon">
             <iconset resource="../../resources/QmitkDiffusionImaging.qrc">
              <normaloff>:/QmitkDiffusionImaging/reset.png</normaloff>:/QmitkDiffusionImaging/reset.png</iconset>
            </property>
           </widget>
          </item>
          <item row="0" column="0">
           <widget class="QToolButton" name="m_SetColor1">
            <property name="toolTip">
-            <string>Reset to Default Coloring</string>
+            <string>Select Fiber Color</string>
            </property>
            <property name="text">
             <string/>
            </property>
            <property name="icon">
-            <iconset resource="../../resources/QmitkDiffusionImaging.qrc">
-             <normaloff>:/QmitkDiffusionImaging/color64.gif</normaloff>:/QmitkDiffusionImaging/color64.gif</iconset>
+            <iconset resource="../../../../../debug/MITK-build/Plugins/org.mitk.gui.qt.diffusionimaging/org_mitk_gui_qt_diffusionimaging_cached.qrc">
+             <normaloff>:/org.mitk.gui.qt.diffusionimaging/resources/color64.gif</normaloff>:/org.mitk.gui.qt.diffusionimaging/resources/color64.gif</iconset>
            </property>
           </widget>
          </item>
          <item row="0" column="2">
           <spacer name="horizontalSpacer_3">
            <property name="orientation">
             <enum>Qt::Horizontal</enum>
            </property>
            <property name="sizeHint" stdset="0">
             <size>
              <width>40</width>
              <height>20</height>
             </size>
            </property>
           </spacer>
          </item>
         </layout>
        </widget>
       </item>
       <item row="1" column="0">
        <widget class="QLabel" name="label_7">
         <property name="text">
          <string>Line Width</string>
         </property>
        </widget>
       </item>
       <item row="1" column="2">
        <widget class="QDoubleSpinBox" name="m_LineWidth">
         <property name="decimals">
          <number>1</number>
         </property>
         <property name="minimum">
          <double>1.000000000000000</double>
         </property>
         <property name="singleStep">
          <double>0.100000000000000</double>
         </property>
         <property name="value">
          <double>1.000000000000000</double>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <widget class="QGroupBox" name="m_3DClippingBox">
      <property name="title">
       <string>3D Clipping</string>
      </property>
      <layout class="QGridLayout" name="gridLayout_5">
       <property name="leftMargin">
        <number>6</number>
       </property>
       <property name="topMargin">
        <number>6</number>
       </property>
       <property name="rightMargin">
        <number>6</number>
       </property>
       <property name="bottomMargin">
        <number>6</number>
       </property>
       <property name="spacing">
        <number>0</number>
       </property>
       <item row="3" column="1">
        <widget class="QRadioButton" name="m_Clip3">
         <property name="text">
          <string>Coronal</string>
         </property>
        </widget>
       </item>
       <item row="2" column="1">
        <widget class="QRadioButton" name="m_Clip1">
         <property name="text">
          <string>Axial</string>
         </property>
        </widget>
       </item>
       <item row="2" column="0">
        <widget class="QRadioButton" name="m_Clip0">
         <property name="text">
          <string>No clipping</string>
         </property>
         <property name="checked">
          <bool>true</bool>
         </property>
        </widget>
       </item>
       <item row="3" column="0">
        <widget class="QRadioButton" name="m_Clip2">
         <property name="text">
          <string>Sagittal</string>
         </property>
        </widget>
       </item>
       <item row="4" column="0">
        <widget class="QCheckBox" name="m_FlipClipBox">
         <property name="text">
          <string>Flipp Clipping Direction</string>
         </property>
        </widget>
       </item>
       <item row="5" column="0">
        <widget class="QCheckBox" name="m_Enable3dPeaks">
         <property name="text">
          <string>Enable 3D Rendering</string>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <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>
  <layoutdefault spacing="6" margin="11"/>
  <includes>
   <include location="local">QmitkDataStorageComboBox.h</include>
  </includes>
  <resources>
   <include location="../../resources/QmitkDiffusionImaging.qrc"/>
+  <include location="../../../../../debug/MITK-build/Plugins/org.mitk.gui.qt.diffusionimaging/org_mitk_gui_qt_diffusionimaging_cached.qrc"/>
  </resources>
  <connections/>
 </ui>