diff --git a/Modules/DiffusionImaging/DiffusionCmdApps/Tractography/StreamlineTractography.cpp b/Modules/DiffusionImaging/DiffusionCmdApps/Tractography/StreamlineTractography.cpp
index bfd69f92c4..755e9b45c2 100755
--- a/Modules/DiffusionImaging/DiffusionCmdApps/Tractography/StreamlineTractography.cpp
+++ b/Modules/DiffusionImaging/DiffusionCmdApps/Tractography/StreamlineTractography.cpp
@@ -1,562 +1,568 @@
 /*===================================================================
 
 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>
 
 #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);
   parser.addArgument("", "o", mitkCommandLineParser::OutputDirectory, "Output:", "output fiberbundle/probability map", us::Any(), false);
   parser.addArgument("algorithm", "", mitkCommandLineParser::String, "Algorithm:", "which algorithm to use (Peaks, DetTensor, ProbTensor, DetODF, ProbODF, DetRF, ProbRF)", 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());
   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());
   parser.addArgument("stop_image", "", mitkCommandLineParser::String, "Stop ROI image:", "streamlines entering the mask will stop immediately", us::Any());
   parser.addArgument("exclusion_image", "", mitkCommandLineParser::String, "Exclusion ROI image:", "streamlines entering the mask will be discarded", us::Any());
   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());
   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());
   parser.addArgument("prior_weight", "", mitkCommandLineParser::Float, "Prior weight", "weighting factor between prior and data.", 0.5);
   parser.addArgument("restrict_to_prior", "", mitkCommandLineParser::Bool, "Restrict to prior:", "restrict tractography to regions where the prior is valid.");
   parser.addArgument("new_directions_from_prior", "", mitkCommandLineParser::Bool, "New directios from prior:", "the prior can create directions where there are none in the data.");
   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());
   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());
   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.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 algorithm = us::any_cast<std::string>(parsedArgs["algorithm"]);
 
   std::string prior_image = "";
   if (parsedArgs.count("prior_image"))
     prior_image = us::any_cast<std::string>(parsedArgs["prior_image"]);
 
   float prior_weight = 0.5;
   if (parsedArgs.count("prior_weight"))
     prior_weight = us::any_cast<float>(parsedArgs["prior_weight"]);
 
+  bool fix_seed = false;
+  if (parsedArgs.count("fix_seed"))
+    fix_seed = us::any_cast<bool>(parsedArgs["fix_seed"]);
+
   bool restrict_to_prior = false;
   if (parsedArgs.count("restrict_to_prior"))
     restrict_to_prior = us::any_cast<bool>(parsedArgs["restrict_to_prior"]);
 
   bool new_directions_from_prior = false;
   if (parsedArgs.count("new_directions_from_prior"))
     new_directions_from_prior = us::any_cast<bool>(parsedArgs["new_directions_from_prior"]);
 
   bool sharpen_odfs = false;
   if (parsedArgs.count("sharpen_odfs"))
     sharpen_odfs = us::any_cast<bool>(parsedArgs["sharpen_odfs"]);
 
   bool interpolate = true;
   if (parsedArgs.count("no_data_interpolation"))
     interpolate = !us::any_cast<bool>(parsedArgs["no_data_interpolation"]);
 
   bool mask_interpolation = true;
   if (parsedArgs.count("no_mask_interpolation"))
     interpolate = !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"]);
 
   bool use_stop_votes = false;
   if (parsedArgs.count("use_stop_votes"))
     use_stop_votes = us::any_cast<bool>(parsedArgs["use_stop_votes"]);
 
   bool use_only_forward_samples = false;
   if (parsedArgs.count("use_only_forward_samples"))
     use_only_forward_samples = us::any_cast<bool>(parsedArgs["use_only_forward_samples"]);
 
   bool flip_x = false;
   if (parsedArgs.count("flip_x"))
     flip_x = us::any_cast<bool>(parsedArgs["flip_x"]);
   bool flip_y = false;
   if (parsedArgs.count("flip_y"))
     flip_y = us::any_cast<bool>(parsedArgs["flip_y"]);
   bool flip_z = false;
   if (parsedArgs.count("flip_z"))
     flip_z = us::any_cast<bool>(parsedArgs["flip_z"]);
 
   bool apply_image_rotation = false;
   if (parsedArgs.count("apply_image_rotation"))
     apply_image_rotation = us::any_cast<bool>(parsedArgs["apply_image_rotation"]);
 
   float compress = -1;
   if (parsedArgs.count("compress"))
     compress = us::any_cast<float>(parsedArgs["compress"]);
 
   float min_tract_length = 20;
   if (parsedArgs.count("min_tract_length"))
     min_tract_length = us::any_cast<float>(parsedArgs["min_tract_length"]);
 
   float loop_check = -1;
   if (parsedArgs.count("loop_check"))
     loop_check = 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"]);
 
   float cutoff = 0.1f;
   if (parsedArgs.count("cutoff"))
     cutoff = us::any_cast<float>(parsedArgs["cutoff"]);
 
   float odf_cutoff = 0.0;
   if (parsedArgs.count("odf_cutoff"))
     odf_cutoff = us::any_cast<float>(parsedArgs["odf_cutoff"]);
 
   float stepsize = -1;
   if (parsedArgs.count("step_size"))
     stepsize = us::any_cast<float>(parsedArgs["step_size"]);
 
   float sampling_distance = -1;
   if (parsedArgs.count("sampling_distance"))
     sampling_distance = us::any_cast<float>(parsedArgs["sampling_distance"]);
 
   unsigned int num_samples = 0;
   if (parsedArgs.count("num_samples"))
     num_samples = static_cast<unsigned int>(us::any_cast<int>(parsedArgs["num_samples"]));
 
   int num_seeds = 1;
   if (parsedArgs.count("seeds"))
     num_seeds = us::any_cast<int>(parsedArgs["seeds"]);
 
   unsigned int trials_per_seed = 10;
   if (parsedArgs.count("trials_per_seed"))
     trials_per_seed = static_cast<unsigned int>(us::any_cast<int>(parsedArgs["trials_per_seed"]));
 
   float tend_f = 1;
   if (parsedArgs.count("tend_f"))
     tend_f = us::any_cast<float>(parsedArgs["tend_f"]);
 
   float tend_g = 0;
   if (parsedArgs.count("tend_g"))
     tend_g = us::any_cast<float>(parsedArgs["tend_g"]);
 
   float angular_threshold = -1;
   if (parsedArgs.count("angular_threshold"))
     angular_threshold = us::any_cast<float>(parsedArgs["angular_threshold"]);
 
   int max_tracts = -1;
   if (parsedArgs.count("max_tracts"))
     max_tracts = 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();
 
     dynamic_cast<mitk::TrackingHandlerPeaks*>(priorhandler)->SetPeakImage(itkImg);
     dynamic_cast<mitk::TrackingHandlerPeaks*>(priorhandler)->SetPeakThreshold(0.0);
     dynamic_cast<mitk::TrackingHandlerPeaks*>(priorhandler)->SetInterpolate(interpolate);
     dynamic_cast<mitk::TrackingHandlerPeaks*>(priorhandler)->SetMode(mitk::TrackingDataHandler::MODE::DETERMINISTIC);
 
     tracker->SetTrackingPriorHandler(priorhandler);
     tracker->SetTrackingPriorWeight(prior_weight);
     tracker->SetTrackingPriorAsMask(restrict_to_prior);
     tracker->SetIntroduceDirectionsFromPrior(new_directions_from_prior);
   }
 
   mitk::TrackingDataHandler* handler;
   if (algorithm == "DetRF" || algorithm == "ProbRF")
   {
     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);
     }
 
     if (algorithm == "ProbRF")
       handler->SetMode(mitk::TrackingDataHandler::MODE::PROBABILISTIC);
   }
   else if (algorithm == "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);
     dynamic_cast<mitk::TrackingHandlerPeaks*>(handler)->SetApplyDirectionMatrix(apply_image_rotation);
     dynamic_cast<mitk::TrackingHandlerPeaks*>(handler)->SetPeakThreshold(cutoff);
   }
   else if (algorithm == "DetTensor")
   {
     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());
     }
 
     dynamic_cast<mitk::TrackingHandlerTensor*>(handler)->SetFaThreshold(cutoff);
     dynamic_cast<mitk::TrackingHandlerTensor*>(handler)->SetF(tend_f);
     dynamic_cast<mitk::TrackingHandlerTensor*>(handler)->SetG(tend_g);
 
     if (addImages.at(0).size()>0)
       dynamic_cast<mitk::TrackingHandlerTensor*>(handler)->SetFaImage(addImages.at(0).at(0));
   }
   else if (algorithm == "DetODF" || algorithm == "ProbODF" || algorithm == "ProbTensor")
   {
     handler = new mitk::TrackingHandlerOdf();
 
     mitk::OdfImage::ItkOdfImageType::Pointer itkImg = nullptr;
 
     if (algorithm == "ProbTensor")
     {
       MITK_INFO << "Converting Tensor to ODF image";
       auto input = mitk::IOUtil::Load<mitk::Image>(input_files.at(0));
       itkImg = mitk::convert::GetItkOdfFromTensorImage(input);
       sharpen_odfs = true;
       odf_cutoff = 0;
       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);
     dynamic_cast<mitk::TrackingHandlerOdf*>(handler)->SetGfaThreshold(cutoff);
     dynamic_cast<mitk::TrackingHandlerOdf*>(handler)->SetOdfThreshold(odf_cutoff);
     dynamic_cast<mitk::TrackingHandlerOdf*>(handler)->SetSharpenOdfs(sharpen_odfs);
 
     if (algorithm == "ProbODF" || algorithm == "ProbTensor")
       dynamic_cast<mitk::TrackingHandlerOdf*>(handler)->SetMode(mitk::TrackingHandlerOdf::MODE::PROBABILISTIC);
 
     if (addImages.at(0).size()>0)
       dynamic_cast<mitk::TrackingHandlerOdf*>(handler)->SetGfaImage(addImages.at(0).at(0));
   }
   else
   {
     MITK_INFO << "Unknown tractography algorithm (" + algorithm+"). Known types are Peaks, DetTensor, ProbTensor, DetODF, ProbODF, DetRF, ProbRF.";
     return EXIT_FAILURE;
   }
   handler->SetInterpolate(interpolate);
   handler->SetFlipX(flip_x);
   handler->SetFlipY(flip_y);
   handler->SetFlipZ(flip_z);
 
   if (ep_constraint=="NONE")
     tracker->SetEndpointConstraint(itk::StreamlineTrackingFilter::EndpointConstraints::NONE);
   else if (ep_constraint=="EPS_IN_TARGET")
     tracker->SetEndpointConstraint(itk::StreamlineTrackingFilter::EndpointConstraints::EPS_IN_TARGET);
   else if (ep_constraint=="EPS_IN_TARGET_LABELDIFF")
     tracker->SetEndpointConstraint(itk::StreamlineTrackingFilter::EndpointConstraints::EPS_IN_TARGET_LABELDIFF);
   else if (ep_constraint=="EPS_IN_SEED_AND_TARGET")
     tracker->SetEndpointConstraint(itk::StreamlineTrackingFilter::EndpointConstraints::EPS_IN_SEED_AND_TARGET);
   else if (ep_constraint=="MIN_ONE_EP_IN_TARGET")
     tracker->SetEndpointConstraint(itk::StreamlineTrackingFilter::EndpointConstraints::MIN_ONE_EP_IN_TARGET);
   else if (ep_constraint=="ONE_EP_IN_TARGET")
     tracker->SetEndpointConstraint(itk::StreamlineTrackingFilter::EndpointConstraints::ONE_EP_IN_TARGET);
   else if (ep_constraint=="NO_EP_IN_TARGET")
     tracker->SetEndpointConstraint(itk::StreamlineTrackingFilter::EndpointConstraints::NO_EP_IN_TARGET);
 
   MITK_INFO << "Tractography algorithm: " << algorithm;
   tracker->SetInterpolateMasks(mask_interpolation);
   tracker->SetNumberOfSamples(num_samples);
   tracker->SetAngularThreshold(angular_threshold);
   tracker->SetMaskImage(mask);
   tracker->SetSeedImage(seed);
   tracker->SetStoppingRegions(stop);
   tracker->SetTargetRegions(target);
   tracker->SetExclusionRegions(exclusion);
   tracker->SetSeedsPerVoxel(num_seeds);
   tracker->SetStepSize(stepsize);
   tracker->SetSamplingDistance(sampling_distance);
   tracker->SetUseStopVotes(use_stop_votes);
   tracker->SetOnlyForwardSamples(use_only_forward_samples);
   tracker->SetLoopCheck(loop_check);
   tracker->SetMaxNumTracts(max_tracts);
   tracker->SetTrialsPerSeed(trials_per_seed);
   tracker->SetTrackingHandler(handler);
   if (ext != ".fib" && ext != ".trk")
     tracker->SetUseOutputProbabilityMap(true);
   tracker->SetMinTractLength(min_tract_length);
+  tracker->SetRandom(!fix_seed);
   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/Plugins/org.mitk.gui.qt.diffusionimaging.tractography/src/internal/QmitkStreamlineTrackingView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging.tractography/src/internal/QmitkStreamlineTrackingView.cpp
index 7de96cb900..ebb483faa3 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,1000 +1,1001 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 #include <berryIStructuredSelection.h>
 
 // Qmitk
 #include "QmitkStreamlineTrackingView.h"
 #include "QmitkStdMultiWidget.h"
 
 // Qt
 #include <QMessageBox>
 
 // MITK
 #include <mitkLookupTable.h>
 #include <mitkLookupTableProperty.h>
 #include <mitkImageToItk.h>
 #include <mitkFiberBundle.h>
 #include <mitkImageCast.h>
 #include <mitkImageToItk.h>
 #include <mitkNodePredicateDataType.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkNodePredicateDimension.h>
 #include <mitkOdfImage.h>
 #include <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->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_fBox, SIGNAL(editingFinished()), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_gBox, SIGNAL(editingFinished()), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_NumSamplesBox, SIGNAL(editingFinished()), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_SeedRadiusBox, SIGNAL(editingFinished()), this, SLOT(InteractiveSeedChanged()) );
     connect( m_Controls->m_NumSeedsBox, SIGNAL(editingFinished()), this, SLOT(InteractiveSeedChanged()) );
     connect( m_Controls->m_OutputProbMap, SIGNAL(stateChanged(int)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_SharpenOdfsBox, SIGNAL(stateChanged(int)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_InterpolationBox, SIGNAL(stateChanged(int)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_MaskInterpolationBox, SIGNAL(stateChanged(int)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_FlipXBox, SIGNAL(stateChanged(int)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_FlipYBox, SIGNAL(stateChanged(int)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_FlipZBox, SIGNAL(stateChanged(int)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_FrontalSamplesBox, SIGNAL(stateChanged(int)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_StopVotesBox, SIGNAL(stateChanged(int)), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_LoopCheckBox, SIGNAL(editingFinished()), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_TrialsPerSeedBox, SIGNAL(editingFinished()), this, SLOT(OnParameterChanged()) );
     connect( m_Controls->m_EpConstraintsBox, SIGNAL(currentIndexChanged(int)), this, SLOT(OnParameterChanged()) );
 
     m_Controls->m_SeedsPerVoxelBox->editingFinished();
     m_Controls->m_NumFibersBox->editingFinished();
     m_Controls->m_ScalarThresholdBox->editingFinished();
     m_Controls->m_OdfCutoffBox->editingFinished();
     m_Controls->m_StepSizeBox->editingFinished();
     m_Controls->m_SamplingDistanceBox->editingFinished();
     m_Controls->m_AngularThresholdBox->editingFinished();
     m_Controls->m_MinTractLengthBox->editingFinished();
     m_Controls->m_fBox->editingFinished();
     m_Controls->m_gBox->editingFinished();
     m_Controls->m_NumSamplesBox->editingFinished();
     m_Controls->m_SeedRadiusBox->editingFinished();
     m_Controls->m_NumSeedsBox->editingFinished();
     m_Controls->m_LoopCheckBox->editingFinished();
     m_Controls->m_TrialsPerSeedBox->editingFinished();
 
     StartStopTrackingGui(false);
   }
 
   UpdateGui();
 }
 
 void QmitkStreamlineTrackingView::StopTractography()
 {
   if (m_Tracker.IsNull())
     return;
 
   m_Tracker->SetStopTracking(true);
 }
 
 void QmitkStreamlineTrackingView::TimerUpdate()
 {
   if (m_Tracker.IsNull())
     return;
 
   QString status_text(m_Tracker->GetStatusText().c_str());
   m_Controls->m_StatusTextBox->setText(status_text);
 }
 
 void QmitkStreamlineTrackingView::BeforeThread()
 {
   m_TrackingTimer->start(1000);
 }
 
 void QmitkStreamlineTrackingView::AfterThread()
 {
   m_TrackingTimer->stop();
   if (!m_Tracker->GetUseOutputProbabilityMap())
   {
     vtkSmartPointer<vtkPolyData> fiberBundle = m_Tracker->GetFiberPolyData();
 
     if (!m_Controls->m_InteractiveBox->isChecked() && fiberBundle->GetNumberOfLines() == 0)
     {
       QMessageBox warnBox;
       warnBox.setWindowTitle("Warning");
       warnBox.setText("No fiberbundle was generated!");
       warnBox.setDetailedText("No fibers were generated using the chosen parameters. Typical reasons are:\n\n- Cutoff too high. Some images feature very low FA/GFA/peak size. Try to lower this parameter.\n- Angular threshold too strict. Try to increase this parameter.\n- A small step sizes also means many steps to go wrong. Especially in the case of probabilistic tractography. Try to adjust the angular threshold.");
       warnBox.setIcon(QMessageBox::Warning);
       warnBox.exec();
 
       if (m_InteractivePointSetNode.IsNotNull())
         m_InteractivePointSetNode->SetProperty("color", mitk::ColorProperty::New(1,1,1));
       StartStopTrackingGui(false);
       if (m_DeleteTrackingHandler)
         DeleteTrackingHandler();
       UpdateGui();
 
       return;
     }
 
     mitk::FiberBundle::Pointer fib = mitk::FiberBundle::New(fiberBundle);
     fib->SetReferenceGeometry(dynamic_cast<mitk::Image*>(m_ParentNode->GetData())->GetGeometry());
     if (m_Controls->m_ResampleFibersBox->isChecked() && fiberBundle->GetNumberOfLines()>0)
       fib->Compress(m_Controls->m_FiberErrorBox->value());
     fib->ColorFibersByOrientation();
     m_Tracker->SetDicomProperties(fib);
 
     if (m_Controls->m_InteractiveBox->isChecked())
     {
       if (m_InteractiveNode.IsNull())
       {
         m_InteractiveNode = mitk::DataNode::New();
         QString name("Interactive");
         m_InteractiveNode->SetName(name.toStdString());
         GetDataStorage()->Add(m_InteractiveNode);
       }
       m_InteractiveNode->SetData(fib);
       m_InteractiveNode->SetFloatProperty("Fiber2DSliceThickness", m_Tracker->GetMinVoxelSize()/2);
 
       if (auto renderWindowPart = this->GetRenderWindowPart())
           renderWindowPart->RequestUpdate();
     }
     else
     {
       mitk::DataNode::Pointer node = mitk::DataNode::New();
       node->SetData(fib);
       QString name("FiberBundle_");
       name += m_ParentNode->GetName().c_str();
       name += "_Streamline";
       node->SetName(name.toStdString());
       node->SetFloatProperty("Fiber2DSliceThickness", m_Tracker->GetMinVoxelSize()/2);
       GetDataStorage()->Add(node, m_ParentNode);
     }
   }
   else
   {
     TrackerType::ItkDoubleImgType::Pointer outImg = m_Tracker->GetOutputProbabilityMap();
     mitk::Image::Pointer img = mitk::Image::New();
     img->InitializeByItk(outImg.GetPointer());
     img->SetVolume(outImg->GetBufferPointer());
 
     if (m_Controls->m_InteractiveBox->isChecked())
     {
       if (m_InteractiveNode.IsNull())
       {
         m_InteractiveNode = mitk::DataNode::New();
         QString name("Interactive");
         m_InteractiveNode->SetName(name.toStdString());
         GetDataStorage()->Add(m_InteractiveNode);
       }
       m_InteractiveNode->SetData(img);
 
       mitk::LookupTable::Pointer lut = mitk::LookupTable::New();
       lut->SetType(mitk::LookupTable::JET_TRANSPARENT);
       mitk::LookupTableProperty::Pointer lut_prop = mitk::LookupTableProperty::New();
       lut_prop->SetLookupTable(lut);
       m_InteractiveNode->SetProperty("LookupTable", lut_prop);
       m_InteractiveNode->SetProperty("opacity", mitk::FloatProperty::New(0.5));
       m_InteractiveNode->SetFloatProperty("Fiber2DSliceThickness", m_Tracker->GetMinVoxelSize()/2);
 
       if (auto renderWindowPart = this->GetRenderWindowPart())
           renderWindowPart->RequestUpdate();
     }
     else
     {
       mitk::DataNode::Pointer node = mitk::DataNode::New();
       node->SetData(img);
       QString name("ProbabilityMap_");
       name += m_ParentNode->GetName().c_str();
       node->SetName(name.toStdString());
 
       mitk::LookupTable::Pointer lut = mitk::LookupTable::New();
       lut->SetType(mitk::LookupTable::JET_TRANSPARENT);
       mitk::LookupTableProperty::Pointer lut_prop = mitk::LookupTableProperty::New();
       lut_prop->SetLookupTable(lut);
       node->SetProperty("LookupTable", lut_prop);
       node->SetProperty("opacity", mitk::FloatProperty::New(0.5));
 
       GetDataStorage()->Add(node, m_ParentNode);
     }
   }
   if (m_InteractivePointSetNode.IsNotNull())
     m_InteractivePointSetNode->SetProperty("color", mitk::ColorProperty::New(1,1,1));
   StartStopTrackingGui(false);
   if (m_DeleteTrackingHandler)
     DeleteTrackingHandler();
   UpdateGui();
 }
 
 void QmitkStreamlineTrackingView::InteractiveSeedChanged(bool posChanged)
 {
   if(!CheckAndStoreLastParams(sender()) && !posChanged)
     return;
   if (m_ThreadIsRunning || !m_Visible)
     return;
 
   if (!posChanged && (!m_Controls->m_InteractiveBox->isChecked() || !m_Controls->m_ParamUpdateBox->isChecked()) )
     return;
 
   std::srand(std::time(0));
   m_SeedPoints.clear();
 
   itk::Point<float> world_pos = this->GetRenderWindowPart()->GetSelectedPosition();
 
   m_SeedPoints.push_back(world_pos);
   float radius = m_Controls->m_SeedRadiusBox->value();
   int num = m_Controls->m_NumSeedsBox->value();
 
   mitk::PointSet::Pointer pointset = mitk::PointSet::New();
   pointset->InsertPoint(0, world_pos);
   m_InteractivePointSetNode->SetProperty("pointsize", mitk::FloatProperty::New(radius*2));
   m_InteractivePointSetNode->SetProperty("point 2D size", mitk::FloatProperty::New(radius*2));
   m_InteractivePointSetNode->SetData(pointset);
 
   for (int i=1; i<num; i++)
   {
     itk::Vector<float> p;
     p[0] = rand()%1000-500;
     p[1] = rand()%1000-500;
     p[2] = rand()%1000-500;
     p.Normalize();
     p *= radius;
     m_SeedPoints.push_back(world_pos+p);
   }
   m_InteractivePointSetNode->SetProperty("color", mitk::ColorProperty::New(1,0,0));
   DoFiberTracking();
 }
 
 bool QmitkStreamlineTrackingView::CheckAndStoreLastParams(QObject* obj)
 {
   if (obj!=nullptr)
   {
     std::string new_val = "";
     if(qobject_cast<QDoubleSpinBox*>(obj)!=nullptr)
       new_val = boost::lexical_cast<std::string>(qobject_cast<QDoubleSpinBox*>(obj)->value());
     else if (qobject_cast<QSpinBox*>(obj)!=nullptr)
       new_val = boost::lexical_cast<std::string>(qobject_cast<QSpinBox*>(obj)->value());
     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()
 {
   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( 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)->SetGfaThreshold(static_cast<float>(m_Controls->m_ScalarThresholdBox->value()));
       dynamic_cast<mitk::TrackingHandlerOdf*>(m_TrackingHandler)->SetOdfThreshold(0);
       dynamic_cast<mitk::TrackingHandlerOdf*>(m_TrackingHandler)->SetSharpenOdfs(true);
       dynamic_cast<mitk::TrackingHandlerOdf*>(m_TrackingHandler)->SetIsOdfFromTensor(true);
     }
     else
     {
       if (m_TrackingHandler==nullptr)
       {
         m_TrackingHandler = new mitk::TrackingHandlerTensor();
         for (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);
         }
       }
 
       dynamic_cast<mitk::TrackingHandlerTensor*>(m_TrackingHandler)->SetFaThreshold(static_cast<float>(m_Controls->m_ScalarThresholdBox->value()));
       dynamic_cast<mitk::TrackingHandlerTensor*>(m_TrackingHandler)->SetF(static_cast<float>(m_Controls->m_fBox->value()));
       dynamic_cast<mitk::TrackingHandlerTensor*>(m_TrackingHandler)->SetG(static_cast<float>(m_Controls->m_gBox->value()));
     }
   }
   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);
       }
     }
 
     dynamic_cast<mitk::TrackingHandlerOdf*>(m_TrackingHandler)->SetGfaThreshold(static_cast<float>(m_Controls->m_ScalarThresholdBox->value()));
     dynamic_cast<mitk::TrackingHandlerOdf*>(m_TrackingHandler)->SetOdfThreshold(static_cast<float>(m_Controls->m_OdfCutoffBox->value()));
     dynamic_cast<mitk::TrackingHandlerOdf*>(m_TrackingHandler)->SetSharpenOdfs(m_Controls->m_SharpenOdfsBox->isChecked());
   }
   else if ( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image*>(m_InputImageNodes.at(0)->GetData())) )
   {
     if ( m_Controls->m_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)
       {
         unsigned int num_previous_directions = 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);
         dynamic_cast<mitk::TrackingHandlerRandomForest<6, 100>*>(m_TrackingHandler)->SetNumPreviousDirections(num_previous_directions);
         forest_valid = dynamic_cast<mitk::TrackingHandlerRandomForest<6, 100>*>(m_TrackingHandler)->IsForestValid();
       }
       else
       {
         unsigned int num_previous_directions = 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);
         dynamic_cast<mitk::TrackingHandlerRandomForest<6, 28>*>(m_TrackingHandler)->SetNumPreviousDirections(num_previous_directions);
         forest_valid = dynamic_cast<mitk::TrackingHandlerRandomForest<6, 28>*>(m_TrackingHandler)->IsForestValid();
       }
 
       if (!forest_valid)
       {
         QMessageBox::information(nullptr, "Information", "Random forest is invalid. The forest signatue does not match the parameters of TrackingHandlerRandomForest.");
         StartStopTrackingGui(false);
         return;
       }
     }
   }
   else
   {
     if (m_Controls->m_ModeBox->currentIndex()==1)
     {
       QMessageBox::information(nullptr, "Information", "Probabilstic tractography is not implemented for peak images.");
       StartStopTrackingGui(false);
       return;
     }
     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())));
     }
 
     dynamic_cast<mitk::TrackingHandlerPeaks*>(m_TrackingHandler)->SetPeakThreshold(static_cast<float>(m_Controls->m_ScalarThresholdBox->value()));
   }
 
   m_TrackingHandler->SetFlipX(m_Controls->m_FlipXBox->isChecked());
   m_TrackingHandler->SetFlipY(m_Controls->m_FlipYBox->isChecked());
   m_TrackingHandler->SetFlipZ(m_Controls->m_FlipZBox->isChecked());
   m_TrackingHandler->SetInterpolate(m_Controls->m_InterpolationBox->isChecked());
   switch (m_Controls->m_ModeBox->currentIndex())
   {
   case 0:
     m_TrackingHandler->SetMode(mitk::TrackingDataHandler::MODE::DETERMINISTIC);
     break;
   case 1:
     m_TrackingHandler->SetMode(mitk::TrackingDataHandler::MODE::PROBABILISTIC);
     break;
   default:
     m_TrackingHandler->SetMode(mitk::TrackingDataHandler::MODE::DETERMINISTIC);
   }
 
   if (m_Controls->m_InteractiveBox->isChecked())
   {
     m_Tracker->SetSeedPoints(m_SeedPoints);
   }
   else if (m_Controls->m_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())
   {
     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);
       dynamic_cast<mitk::TrackingHandlerPeaks*>(m_TrackingPriorHandler)->SetPeakThreshold(0.0);
       m_LastPrior = m_Controls->m_PriorImageSelectionWidget->GetSelectedNode();
     }
 
     m_TrackingPriorHandler->SetInterpolate(m_Controls->m_InterpolationBox->isChecked());
     m_TrackingPriorHandler->SetMode(mitk::TrackingDataHandler::MODE::DETERMINISTIC);
 
     m_Tracker->SetTrackingPriorHandler(m_TrackingPriorHandler);
     m_Tracker->SetTrackingPriorWeight(m_Controls->m_PriorWeightBox->value());
     m_Tracker->SetTrackingPriorAsMask(m_Controls->m_PriorAsMaskBox->isChecked());
     m_Tracker->SetIntroduceDirectionsFromPrior(m_Controls->m_NewDirectionsFromPriorBox->isChecked());
   }
   else if (m_Controls->m_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);
   }
 
   // Endpoint constraints
   switch (m_Controls->m_EpConstraintsBox->currentIndex())
   {
   case 0:
     m_Tracker->SetEndpointConstraint(itk::StreamlineTrackingFilter::EndpointConstraints::NONE);
     m_Tracker->SetTargetRegions(nullptr);
     break;
   case 1:
     m_Tracker->SetEndpointConstraint(itk::StreamlineTrackingFilter::EndpointConstraints::EPS_IN_TARGET);
     break;
   case 2:
     m_Tracker->SetEndpointConstraint(itk::StreamlineTrackingFilter::EndpointConstraints::EPS_IN_TARGET_LABELDIFF);
     break;
   case 3:
     m_Tracker->SetEndpointConstraint(itk::StreamlineTrackingFilter::EndpointConstraints::EPS_IN_SEED_AND_TARGET);
     break;
   case 4:
     m_Tracker->SetEndpointConstraint(itk::StreamlineTrackingFilter::EndpointConstraints::MIN_ONE_EP_IN_TARGET);
     break;
   case 5:
     m_Tracker->SetEndpointConstraint(itk::StreamlineTrackingFilter::EndpointConstraints::ONE_EP_IN_TARGET);
     break;
   case 6:
     m_Tracker->SetEndpointConstraint(itk::StreamlineTrackingFilter::EndpointConstraints::NO_EP_IN_TARGET);
     break;
   }
 
   if (m_Tracker->GetEndpointConstraint()!=itk::StreamlineTrackingFilter::EndpointConstraints::NONE && m_Controls->m_TargetImageSelectionWidget->GetSelectedNode().IsNull())
   {
     QMessageBox::information(nullptr, "Error", "Endpoint constraints are used but no target image is set!");
     StartStopTrackingGui(false);
     return;
   }
   else if (m_Tracker->GetEndpointConstraint()==itk::StreamlineTrackingFilter::EndpointConstraints::EPS_IN_SEED_AND_TARGET
            && (m_Controls->m_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->SetInterpolateMasks(m_Controls->m_MaskInterpolationBox->isChecked());
   m_Tracker->SetVerbose(!m_Controls->m_InteractiveBox->isChecked());
   m_Tracker->SetSeedsPerVoxel(m_Controls->m_SeedsPerVoxelBox->value());
   m_Tracker->SetStepSize(m_Controls->m_StepSizeBox->value());
   m_Tracker->SetSamplingDistance(m_Controls->m_SamplingDistanceBox->value());
   m_Tracker->SetUseStopVotes(m_Controls->m_StopVotesBox->isChecked());
   m_Tracker->SetOnlyForwardSamples(m_Controls->m_FrontalSamplesBox->isChecked());
   m_Tracker->SetTrialsPerSeed(m_Controls->m_TrialsPerSeedBox->value());
   m_Tracker->SetMaxNumTracts(m_Controls->m_NumFibersBox->value());
   m_Tracker->SetNumberOfSamples(m_Controls->m_NumSamplesBox->value());
   m_Tracker->SetTrackingHandler(m_TrackingHandler);
   m_Tracker->SetLoopCheck(m_Controls->m_LoopCheckBox->value());
   m_Tracker->SetAngularThreshold(m_Controls->m_AngularThresholdBox->value());
   m_Tracker->SetMinTractLength(m_Controls->m_MinTractLengthBox->value());
   m_Tracker->SetUseOutputProbabilityMap(m_Controls->m_OutputProbMap->isChecked());
+  m_Tracker->SetRandom(!m_Controls->m_FixSeedBox->isChecked());
 
   m_ParentNode = m_InputImageNodes.at(0);
   m_TrackingThread.start(QThread::LowestPriority);
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.tractography/src/internal/QmitkStreamlineTrackingViewControls.ui b/Plugins/org.mitk.gui.qt.diffusionimaging.tractography/src/internal/QmitkStreamlineTrackingViewControls.ui
index 0c3d0f1200..e7ec1f72fc 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,1491 +1,1511 @@
 <?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="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>
      </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>
             </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>
        </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>
+        <y>-132</y>
         <width>421</width>
-        <height>343</height>
+        <height>366</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="11" 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="10" column="1">
-        <widget class="QDoubleSpinBox" name="m_gBox">
+        <widget class="QSpinBox" name="m_AngularThresholdBox">
          <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>
+          <string>Angular threshold between two steps (in degree). Default: 90° * step_size</string>
          </property>
-         <property name="decimals">
-          <number>2</number>
+         <property name="minimum">
+          <number>-1</number>
          </property>
          <property name="maximum">
-          <double>1.000000000000000</double>
+          <number>90</number>
          </property>
          <property name="singleStep">
-          <double>0.100000000000000</double>
+          <number>1</number>
          </property>
          <property name="value">
-          <double>0.000000000000000</double>
+          <number>-1</number>
          </property>
         </widget>
        </item>
-       <item row="0" 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="2" column="0">
-        <widget class="QLabel" name="m_FaThresholdLabel">
+       <item row="4" column="0">
+        <widget class="QLabel" name="mFaImageLabel">
          <property name="toolTip">
           <string/>
          </property>
          <property name="text">
-          <string>Cutoff:</string>
+          <string>FA/GFA Image:</string>
          </property>
         </widget>
        </item>
-       <item row="3" column="0">
-        <widget class="QLabel" name="mFaImageLabel">
+       <item row="5" column="0">
+        <widget class="QLabel" name="m_OdfCutoffLabel">
          <property name="toolTip">
           <string/>
          </property>
          <property name="text">
-          <string>FA/GFA Image:</string>
+          <string>ODF Cutoff:</string>
          </property>
         </widget>
        </item>
-       <item row="0" column="0">
-        <widget class="QLabel" name="m_FaThresholdLabel_3">
+       <item row="14" column="1">
+        <widget class="QCheckBox" name="m_FixSeedBox">
          <property name="toolTip">
-          <string/>
+          <string>Always produce the same random numbers.</string>
          </property>
          <property name="text">
-          <string>Mode:</string>
+          <string/>
          </property>
         </widget>
        </item>
-       <item row="7" column="0">
-        <widget class="QLabel" name="m_AngularThresholdLabel">
-         <property name="toolTip">
-          <string/>
+       <item row="15" column="0">
+        <spacer name="verticalSpacer_2">
+         <property name="orientation">
+          <enum>Qt::Vertical</enum>
          </property>
-         <property name="text">
-          <string>Angular Threshold:</string>
+         <property name="sizeHint" stdset="0">
+          <size>
+           <width>20</width>
+           <height>40</height>
+          </size>
          </property>
-        </widget>
+        </spacer>
        </item>
-       <item row="5" column="1">
-        <widget class="QDoubleSpinBox" name="m_StepSizeBox">
+       <item row="13" column="1">
+        <widget class="QDoubleSpinBox" name="m_gBox">
          <property name="toolTip">
-          <string>Step size (in voxels)</string>
+          <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="minimum">
-          <double>0.010000000000000</double>
-         </property>
          <property name="maximum">
-          <double>10.000000000000000</double>
+          <double>1.000000000000000</double>
          </property>
          <property name="singleStep">
           <double>0.100000000000000</double>
          </property>
          <property name="value">
-          <double>0.500000000000000</double>
+          <double>0.000000000000000</double>
          </property>
         </widget>
        </item>
        <item row="8" column="1">
-        <widget class="QSpinBox" name="m_LoopCheckBox">
+        <widget class="QDoubleSpinBox" name="m_MinTractLengthBox">
          <property name="toolTip">
-          <string>Maximum allowed angular SDTEV over 4 voxel lengths. Default: no loop check.</string>
+          <string>Minimum tract length in mm. Shorter fibers are discarded.</string>
          </property>
          <property name="statusTip">
-          <string/>
+          <string>Minimum fiber length (in mm)</string>
          </property>
-         <property name="minimum">
-          <number>-1</number>
+         <property name="decimals">
+          <number>1</number>
          </property>
          <property name="maximum">
-          <number>180</number>
+          <double>999.000000000000000</double>
+         </property>
+         <property name="singleStep">
+          <double>1.000000000000000</double>
          </property>
          <property name="value">
-          <number>-1</number>
+          <double>20.000000000000000</double>
          </property>
         </widget>
        </item>
-       <item row="5" column="0">
-        <widget class="QLabel" name="m_StepsizeLabel">
+       <item row="2" column="0">
+        <widget class="QLabel" name="m_FaThresholdLabel_5">
          <property name="toolTip">
           <string/>
          </property>
          <property name="text">
-          <string>Step Size:</string>
+          <string>Sharpen ODFs:</string>
          </property>
         </widget>
        </item>
-       <item row="4" column="1">
-        <widget class="QDoubleSpinBox" name="m_OdfCutoffBox">
+       <item row="3" column="1">
+        <widget class="QDoubleSpinBox" name="m_ScalarThresholdBox">
          <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>
+          <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.000250000000000</double>
+          <double>0.100000000000000</double>
          </property>
         </widget>
        </item>
-       <item row="9" column="1">
+       <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="1" column="1">
-        <widget class="QCheckBox" name="m_SharpenOdfsBox">
+       <item row="11" column="1">
+        <widget class="QSpinBox" name="m_LoopCheckBox">
          <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>
+          <string>Maximum allowed angular SDTEV over 4 voxel lengths. Default: no loop check.</string>
          </property>
-         <property name="text">
+         <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="9" column="0">
+       <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="6" column="0">
-        <widget class="QLabel" name="m_MinTractLengthLabel">
+       <item row="10" column="0">
+        <widget class="QLabel" name="m_AngularThresholdLabel">
          <property name="toolTip">
           <string/>
          </property>
          <property name="text">
-          <string>Min. Tract Length:</string>
+          <string>Angular Threshold:</string>
          </property>
         </widget>
        </item>
-       <item row="2" column="1">
-        <widget class="QDoubleSpinBox" name="m_ScalarThresholdBox">
+       <item row="6" column="1">
+        <widget class="QDoubleSpinBox" name="m_StepSizeBox">
          <property name="toolTip">
-          <string>Threshold on peak magnitude, FA, GFA, ...</string>
+          <string>Step size (in voxels)</string>
          </property>
          <property name="decimals">
-          <number>5</number>
+          <number>2</number>
+         </property>
+         <property name="minimum">
+          <double>0.010000000000000</double>
          </property>
          <property name="maximum">
-          <double>1.000000000000000</double>
+          <double>10.000000000000000</double>
          </property>
          <property name="singleStep">
           <double>0.100000000000000</double>
          </property>
          <property name="value">
-          <double>0.100000000000000</double>
+          <double>0.500000000000000</double>
          </property>
         </widget>
        </item>
-       <item row="4" column="0">
-        <widget class="QLabel" name="m_OdfCutoffLabel">
+       <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>ODF Cutoff:</string>
+          <string>Mode:</string>
          </property>
         </widget>
        </item>
-       <item row="6" column="1">
-        <widget class="QDoubleSpinBox" name="m_MinTractLengthBox">
+       <item row="6" column="0">
+        <widget class="QLabel" name="m_StepsizeLabel">
          <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>
+          <string/>
          </property>
-         <property name="value">
-          <double>20.000000000000000</double>
+         <property name="text">
+          <string>Step Size:</string>
          </property>
         </widget>
        </item>
-       <item row="8" column="0">
-        <widget class="QLabel" name="m_LoopCheckLabel">
+       <item row="3" column="0">
+        <widget class="QLabel" name="m_FaThresholdLabel">
          <property name="toolTip">
           <string/>
          </property>
          <property name="text">
-          <string>Loop Check:</string>
+          <string>Cutoff:</string>
          </property>
         </widget>
        </item>
-       <item row="7" column="1">
-        <widget class="QSpinBox" name="m_AngularThresholdBox">
+       <item row="5" column="1">
+        <widget class="QDoubleSpinBox" name="m_OdfCutoffBox">
          <property name="toolTip">
-          <string>Angular threshold between two steps (in degree). Default: 90° * step_size</string>
+          <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="minimum">
-          <number>-1</number>
+         <property name="decimals">
+          <number>5</number>
          </property>
          <property name="maximum">
-          <number>90</number>
+          <double>1.000000000000000</double>
          </property>
          <property name="singleStep">
-          <number>1</number>
+          <double>0.100000000000000</double>
          </property>
          <property name="value">
-          <number>-1</number>
-         </property>
-        </widget>
-       </item>
-       <item row="10" column="0">
-        <widget class="QLabel" name="m_gLabel">
-         <property name="toolTip">
-          <string/>
-         </property>
-         <property name="text">
-          <string>g:</string>
+          <double>0.000250000000000</double>
          </property>
         </widget>
        </item>
-       <item row="1" column="0">
-        <widget class="QLabel" name="m_FaThresholdLabel_5">
+       <item row="14" column="0">
+        <widget class="QLabel" name="m_FaThresholdLabel_6">
          <property name="toolTip">
           <string/>
          </property>
          <property name="text">
-          <string>Sharpen ODFs:</string>
+          <string>Fix Random Seed:</string>
          </property>
         </widget>
        </item>
-       <item row="3" column="1">
-        <widget class="QmitkSingleNodeSelectionWidget" name="m_FaImageSelectionWidget" native="true"/>
-       </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>
        </rect>
       </property>
       <attribute name="label">
        <string>Tractography Prior</string>
       </attribute>
       <layout class="QGridLayout" name="gridLayout_9">
        <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="1" column="0">
         <widget class="QLabel" name="m_PriorLabel_2">
          <property name="text">
           <string>Weight:</string>
          </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="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="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="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="0">
         <widget class="QLabel" name="m_PriorLabel_4">
          <property name="text">
           <string>New Directions from Prior:</string>
          </property>
         </widget>
        </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="0" column="1">
         <widget class="QmitkSingleNodeSelectionWidget" name="m_PriorImageSelectionWidget" native="true"/>
        </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>
        </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>
        </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>
        </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/>
  <connections/>
 </ui>