diff --git a/Modules/DiffusionImaging/DiffusionCmdApps/Misc/DReg.cpp b/Modules/DiffusionImaging/DiffusionCmdApps/Misc/DReg.cpp
index 53e08a6018..5c83f6b0ec 100644
--- a/Modules/DiffusionImaging/DiffusionCmdApps/Misc/DReg.cpp
+++ b/Modules/DiffusionImaging/DiffusionCmdApps/Misc/DReg.cpp
@@ -1,134 +1,222 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include <mitkImageCast.h>
 #include <mitkImage.h>
 #include <mitkIOUtil.h>
 #include "mitkCommandLineParser.h"
 #include <mitkMultiModalRigidDefaultRegistrationAlgorithm.h>
 #include <mitkDiffusionPropertyHelper.h>
 #include <mitkAlgorithmHelper.h>
 #include <itkExtractDwiChannelFilter.h>
 #include <mitkRegistrationHelper.h>
 #include <mitkImageMappingHelper.h>
 #include <itksys/SystemTools.hxx>
 #include <mitkPreferenceListReaderOptionsFunctor.h>
+#include <itkComposeImageFilter.h>
+#include <mitkITKImageImport.h>
+#include <mitkDiffusionImageCorrectionFilter.h>
+#include <mitkDiffusionDataIOHelper.h>
 
 typedef mitk::DiffusionPropertyHelper DPH;
 
 
+mitk::Image::Pointer apply_transform(mitk::Image::Pointer moving, mitk::Image::Pointer fixed_single, mitk::MAPRegistrationWrapper::Pointer reg, bool resample)
+{
+  mitk::Image::Pointer registered_image;
+  if (!resample)
+  {
+    registered_image = mitk::ImageMappingHelper::refineGeometry(moving, reg, true);
+  }
+  else
+  {
+    if (!mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(moving))
+    {
+      registered_image = mitk::ImageMappingHelper::map(moving, reg, false, 0, fixed_single->GetGeometry(), false, 0, mitk::ImageMappingInterpolator::BSpline_3);
+    }
+    else
+    {
+      typedef itk::Image<mitk::DiffusionPropertyHelper::DiffusionPixelType, 3> ITKDiffusionVolumeType;
+      typedef itk::ComposeImageFilter < ITKDiffusionVolumeType > ComposeFilterType;
+      auto composer = ComposeFilterType::New();
+
+      auto itkVectorImagePointer = mitk::DiffusionPropertyHelper::GetItkVectorImage(moving);
+      for (unsigned int i=0; i<itkVectorImagePointer->GetVectorLength(); ++i)
+      {
+        itk::ExtractDwiChannelFilter< short >::Pointer filter = itk::ExtractDwiChannelFilter< short >::New();
+        filter->SetInput( itkVectorImagePointer);
+        filter->SetChannelIndex(i);
+        filter->Update();
+
+        mitk::Image::Pointer gradientVolume = mitk::Image::New();
+        gradientVolume->InitializeByItk( filter->GetOutput() );
+        gradientVolume->SetImportChannel( filter->GetOutput()->GetBufferPointer() );
+
+        mitk::Image::Pointer registered_mitk_image = mitk::ImageMappingHelper::map(gradientVolume, reg, false, 0, fixed_single->GetGeometry(), false, 0, mitk::ImageMappingInterpolator::BSpline_3);
+
+        auto registered_itk_image = ITKDiffusionVolumeType::New();
+        mitk::CastToItkImage(registered_mitk_image, registered_itk_image);
+        composer->SetInput(i, registered_itk_image);
+      }
+      composer->Update();
+
+      registered_image = mitk::GrabItkImageMemory( composer->GetOutput() );
+      mitk::DiffusionPropertyHelper::CopyProperties(moving, registered_image, true);
+
+      typedef mitk::DiffusionImageCorrectionFilter CorrectionFilterType;
+      CorrectionFilterType::Pointer corrector = CorrectionFilterType::New();
+      corrector->SetImage( registered_image );
+      corrector->CorrectDirections( mitk::MITKRegistrationHelper::getAffineMatrix(reg, false)->GetMatrix().GetVnlMatrix() );
+    }
+  }
+
+  return registered_image;
+}
+
+
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
 
   parser.setTitle("DREG");
   parser.setCategory("Preprocessing Tools");
   parser.setDescription("TEMPORARY: Rigid registration of two images");
   parser.setContributor("MIC");
 
   parser.setArgumentPrefix("--", "-");
   parser.addArgument("", "f", mitkCommandLineParser::InputFile, "Fixed:", "fixed image", us::Any(), false);
   parser.addArgument("", "m", mitkCommandLineParser::InputFile, "Moving:", "moving image", us::Any(), false);
   parser.addArgument("", "o", mitkCommandLineParser::OutputFile, "Output:", "output image", us::Any(), false);
+  parser.addArgument("resample", "", mitkCommandLineParser::Bool, "Resample:", "resample moving image", false);
+  parser.addArgument("coreg", "", mitkCommandLineParser::StringList, "", "additionally apply transform to these images", us::Any(), false);
 
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0)
     return EXIT_FAILURE;
 
   // mandatory arguments
   std::string f = us::any_cast<std::string>(parsedArgs["f"]);
   std::string m = us::any_cast<std::string>(parsedArgs["m"]);
   std::string o = us::any_cast<std::string>(parsedArgs["o"]);
 
+  bool resample = false;
+  if (parsedArgs.count("resample"))
+    resample = true;
+
+  mitkCommandLineParser::StringContainerType coreg;
+  if (parsedArgs.count("coreg"))
+    coreg = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["coreg"]);
+
   try
   {
     typedef itk::Image< float, 3 > ItkFloatImageType;
 
     mitk::PreferenceListReaderOptionsFunctor functor = mitk::PreferenceListReaderOptionsFunctor({"Diffusion Weighted Images"}, {});
     mitk::Image::Pointer fixed = mitk::IOUtil::Load<mitk::Image>(f, &functor);
     mitk::Image::Pointer moving = mitk::IOUtil::Load<mitk::Image>(m, &functor);
 
     mitk::Image::Pointer fixed_single = fixed;
     mitk::Image::Pointer moving_single = moving;
 
     mitk::MultiModalRigidDefaultRegistrationAlgorithm< ItkFloatImageType >::Pointer algo = mitk::MultiModalRigidDefaultRegistrationAlgorithm< ItkFloatImageType >::New();
     mitk::MITKAlgorithmHelper helper(algo);
 
     if (mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(fixed))
     {
       DPH::ImageType::Pointer itkVectorImagePointer = DPH::ImageType::New();
       mitk::CastToItkImage(fixed, itkVectorImagePointer);
 
       itk::ExtractDwiChannelFilter< short >::Pointer filter = itk::ExtractDwiChannelFilter< short >::New();
       filter->SetInput( itkVectorImagePointer);
       filter->SetChannelIndex(0);
       filter->Update();
 
       fixed_single = mitk::Image::New();
       fixed_single->InitializeByItk( filter->GetOutput() );
       fixed_single->SetImportChannel( filter->GetOutput()->GetBufferPointer() );
     }
 
     if (mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(moving))
     {
       DPH::ImageType::Pointer itkVectorImagePointer = DPH::ImageType::New();
       mitk::CastToItkImage(moving, itkVectorImagePointer);
 
       itk::ExtractDwiChannelFilter< short >::Pointer filter = itk::ExtractDwiChannelFilter< short >::New();
       filter->SetInput( itkVectorImagePointer);
       filter->SetChannelIndex(0);
       filter->Update();
 
       moving_single = mitk::Image::New();
       moving_single->InitializeByItk( filter->GetOutput() );
       moving_single->SetImportChannel( filter->GetOutput()->GetBufferPointer() );
     }
 
     helper.SetData(moving_single, fixed_single);
     mitk::MAPRegistrationWrapper::Pointer reg = helper.GetMITKRegistrationWrapper();
 
-    mitk::Image::Pointer registered_image = mitk::ImageMappingHelper::refineGeometry(moving, reg, true);
-
+    mitk::Image::Pointer registered_image = apply_transform(moving, fixed_single, reg, resample);
     if (mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(registered_image))
     {
       mitk::DiffusionPropertyHelper::InitializeImage( registered_image );
 
       std::string file_extension = itksys::SystemTools::GetFilenameExtension(o);
       if (file_extension==".nii" || file_extension==".nii.gz")
         mitk::IOUtil::Save(registered_image, "application/vnd.mitk.nii.gz", o);
       else
         mitk::IOUtil::Save(registered_image, o);
     }
     else
       mitk::IOUtil::Save(registered_image, o);
+
+    std::string path = ist::GetFilenamePath(o) + "/";
+    std::vector< std::string > file_names;
+    auto coreg_images = mitk::DiffusionDataIOHelper::load_mitk_images(coreg, &file_names);
+    for (unsigned int i=0; i<coreg_images.size(); ++i)
+    {
+      std::string ext = ist::GetFilenameExtension(file_names.at(i));
+      std::string out_name = path + ist::GetFilenameWithoutExtension(file_names.at(i)) + "_registered" + ext;
+
+      registered_image = apply_transform(coreg_images.at(i), fixed_single, reg, resample);
+      if (mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage(registered_image))
+      {
+        mitk::DiffusionPropertyHelper::InitializeImage( registered_image );
+
+        if (ext==".nii" || ext==".nii.gz")
+          mitk::IOUtil::Save(registered_image, "application/vnd.mitk.nii.gz", out_name);
+        else
+          mitk::IOUtil::Save(registered_image, out_name);
+      }
+      else
+        mitk::IOUtil::Save(registered_image, out_name);
+    }
   }
   catch (itk::ExceptionObject e)
   {
     std::cout << e;
     return EXIT_FAILURE;
   }
   catch (std::exception e)
   {
     std::cout << e.what();
     return EXIT_FAILURE;
   }
   catch (...)
   {
     std::cout << "ERROR!?!";
     return EXIT_FAILURE;
   }
   return EXIT_SUCCESS;
 }
diff --git a/Modules/DiffusionImaging/DiffusionCmdApps/mitkDiffusionDataIOHelper.cpp b/Modules/DiffusionImaging/DiffusionCmdApps/mitkDiffusionDataIOHelper.cpp
index 6547ed1646..585b1cee3f 100644
--- a/Modules/DiffusionImaging/DiffusionCmdApps/mitkDiffusionDataIOHelper.cpp
+++ b/Modules/DiffusionImaging/DiffusionCmdApps/mitkDiffusionDataIOHelper.cpp
@@ -1,78 +1,115 @@
 /*===================================================================
 
 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 "mitkDiffusionDataIOHelper.h"
 
 std::vector< std::string > mitk::DiffusionDataIOHelper::get_file_list(const std::string& path, const std::vector<std::string> extensions)
 {
   std::vector< std::string > file_list;
   itk::Directory::Pointer dir = itk::Directory::New();
 
   if (dir->Load(path.c_str()))
   {
     int n = dir->GetNumberOfFiles();
     for (int r = 0; r < n; r++)
     {
       const char *filename = dir->GetFile(r);
       std::string ext = ist::GetFilenameExtension(filename);
       for (auto e : extensions)
       {
         if (ext==e)
         {
           file_list.push_back(path + '/' + filename);
           break;
         }
       }
     }
   }
   std::sort(file_list.begin(), file_list.end());
   return file_list;
 }
 
+std::vector< mitk::Image::Pointer > mitk::DiffusionDataIOHelper::load_mitk_images(const std::vector<std::string> files, std::vector<std::string>* filenames)
+{
+  mitk::LocaleSwitch localeSwitch("C");
+  std::streambuf *old = cout.rdbuf(); // <-- save
+  std::stringstream ss;
+  std::cout.rdbuf (ss.rdbuf());       // <-- redirect
+  std::vector< mitk::Image::Pointer > out;
+  for (auto f : files)
+  {
+    if (itksys::SystemTools::FileExists(f, true))
+    {
+      mitk::Image::Pointer image = mitk::IOUtil::Load<mitk::Image>(f);
+      out.push_back(image);
+      if (filenames!=nullptr)
+        filenames->push_back(f);
+    }
+    else if (itksys::SystemTools::PathExists(f))
+    {
+      if (!f.empty() && f.back() != '/')
+        f += "/";
+
+      auto list = get_file_list(f, {".nrrd",".nii.gz",".nii"});
+      for (auto file : list)
+      {
+        mitk::Image::Pointer image = mitk::IOUtil::Load<mitk::Image>(file);
+        out.push_back(image);
+        if (filenames!=nullptr)
+          filenames->push_back(file);
+      }
+    }
+  }
+
+  std::cout.rdbuf (old);              // <-- restore
+  MITK_INFO << "Loaded " << out.size() << " images";
+  return out;
+}
+
 std::vector< mitk::FiberBundle::Pointer > mitk::DiffusionDataIOHelper::load_fibs(const std::vector<std::string> files, std::vector<std::string>* filenames)
 {
   std::streambuf *old = cout.rdbuf(); // <-- save
   std::stringstream ss;
   std::cout.rdbuf (ss.rdbuf());       // <-- redirect
   std::vector< mitk::FiberBundle::Pointer > out;
   for (auto f : files)
   {
     if (itksys::SystemTools::PathExists(f))
     {
       if (!f.empty() && f.back() != '/')
         f += "/";
 
       auto list = get_file_list(f, {".fib",".trk",".tck"});
       for (auto file : list)
       {
         mitk::FiberBundle::Pointer fib = mitk::IOUtil::Load<mitk::FiberBundle>(file);
         out.push_back(fib);
         if (filenames!=nullptr)
           filenames->push_back(file);
       }
     }
     else if (itksys::SystemTools::FileExists(f))
     {
       mitk::FiberBundle::Pointer fib = mitk::IOUtil::Load<mitk::FiberBundle>(f);
       out.push_back(fib);
       if (filenames!=nullptr)
         filenames->push_back(f);
     }
   }
   std::cout.rdbuf (old);              // <-- restore
   MITK_INFO << "Loaded " << out.size() << " tractograms";
   return out;
 }
diff --git a/Modules/DiffusionImaging/DiffusionCmdApps/mitkDiffusionDataIOHelper.h b/Modules/DiffusionImaging/DiffusionCmdApps/mitkDiffusionDataIOHelper.h
index 187d927070..6892e8ce9e 100644
--- a/Modules/DiffusionImaging/DiffusionCmdApps/mitkDiffusionDataIOHelper.h
+++ b/Modules/DiffusionImaging/DiffusionCmdApps/mitkDiffusionDataIOHelper.h
@@ -1,118 +1,120 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef __mitkDiffusionDataIOHelper_h_
 #define __mitkDiffusionDataIOHelper_h_
 
 #include <MitkDiffusionCmdAppsExports.h>
 #include <itkImage.h>
 #include <mitkImage.h>
 #include <mitkIOUtil.h>
 #include <mitkFiberBundle.h>
 #include <mitkImageToItk.h>
 
 #include <itksys/SystemTools.hxx>
 #include <itkDirectory.h>
 #include <mitkLocaleSwitch.h>
 
 typedef itksys::SystemTools ist;
 
 namespace mitk{
 
 class MITKDIFFUSIONCMDAPPS_EXPORT DiffusionDataIOHelper
 {
 public:
 
   static std::vector< std::string > get_file_list(const std::string& path, const std::vector< std::string > extensions={".fib", ".trk"});
 
   static std::vector< mitk::FiberBundle::Pointer > load_fibs(const std::vector<std::string> files, std::vector<std::string>* filenames=nullptr);
 
+  static std::vector< mitk::Image::Pointer > load_mitk_images(const std::vector<std::string> files, std::vector<std::string>* filenames=nullptr);
+
   template< class TYPE >
   static typename TYPE::Pointer load_itk_image(const std::string file)
   {
     mitk::LocaleSwitch localeSwitch("C");
     if (file.compare("")!=0 && itksys::SystemTools::FileExists(file))
     {
       mitk::Image::Pointer image = mitk::IOUtil::Load<mitk::Image>(file);
 
       typedef mitk::ImageToItk< TYPE > CasterType;
       typename CasterType::Pointer caster = CasterType::New();
       caster->SetInput(image);
       caster->Update();
       typename TYPE::Pointer itk_image = caster->GetOutput();
       return itk_image;
     }
     return nullptr;
   }
 
   template< class TYPE >
   static std::vector< typename TYPE::Pointer > load_itk_images(const std::vector<std::string> files, std::vector<std::string>* filenames=nullptr)
   {
     mitk::LocaleSwitch localeSwitch("C");
     std::streambuf *old = cout.rdbuf(); // <-- save
     std::stringstream ss;
     std::cout.rdbuf (ss.rdbuf());       // <-- redirect
     std::vector< typename TYPE::Pointer > out;
     for (auto f : files)
     {
       if (itksys::SystemTools::FileExists(f, true))
       {
         mitk::Image::Pointer image = mitk::IOUtil::Load<mitk::Image>(f);
 
         typedef mitk::ImageToItk< TYPE > CasterType;
         typename CasterType::Pointer caster = CasterType::New();
         caster->SetInput(image);
         caster->Update();
         typename TYPE::Pointer itk_image = caster->GetOutput();
 
         out.push_back(itk_image);
         if (filenames!=nullptr)
           filenames->push_back(f);
       }
       else if (itksys::SystemTools::PathExists(f))
       {
         if (!f.empty() && f.back() != '/')
           f += "/";
 
         auto list = get_file_list(f, {".nrrd",".nii.gz",".nii"});
         for (auto file : list)
         {
           mitk::Image::Pointer image = mitk::IOUtil::Load<mitk::Image>(file);
 
           typedef mitk::ImageToItk< TYPE > CasterType;
           typename CasterType::Pointer caster = CasterType::New();
           caster->SetInput(image);
           caster->Update();
           typename TYPE::Pointer itk_image = caster->GetOutput();
 
           out.push_back(itk_image);
           if (filenames!=nullptr)
             filenames->push_back(file);
         }
       }
     }
 
     std::cout.rdbuf (old);              // <-- restore
     MITK_INFO << "Loaded " << out.size() << " images";
     return out;
   }
 
 };
 
 }
 
 #endif //__mitkDiffusionDataIOHelper_h_
 
diff --git a/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberExtractionTest.cpp b/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberExtractionTest.cpp
index b861a20dac..32c3513861 100644
--- a/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberExtractionTest.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Testing/mitkFiberExtractionTest.cpp
@@ -1,147 +1,143 @@
 /*===================================================================
 
 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 <mitkTestingMacros.h>
 #include <mitkIOUtil.h>
 #include <mitkFiberBundle.h>
 #include <mitkPlanarFigure.h>
 #include <mitkPlanarFigureComposite.h>
 #include <mitkImageCast.h>
 #include <mitkStandaloneDataStorage.h>
 #include <vtkDebugLeaks.h>
 #include <omp.h>
 #include <itkFiberExtractionFilter.h>
 
 /**Documentation
  *  Test if fiber transfortaiom methods work correctly
  */
 int mitkFiberExtractionTest(int argc, char* argv[])
 {
   MITK_TEST_BEGIN("mitkFiberExtractionTest");
 
   /// \todo Fix VTK memory leaks. Bug 18097.
   vtkDebugLeaks::SetExitError(0);
 
   MITK_INFO << "argc: " << argc;
   MITK_TEST_CONDITION_REQUIRED(argc==13,"check for input data");
 
   omp_set_num_threads(1);
   try{
     mitk::FiberBundle::Pointer groundTruthFibs = mitk::IOUtil::Load<mitk::FiberBundle>(argv[1]);
     mitk::FiberBundle::Pointer testFibs = mitk::IOUtil::Load<mitk::FiberBundle>(argv[2]);
 
     // test planar figure based extraction
     auto data = mitk::IOUtil::Load(argv[3])[0];
     auto pf1 = mitk::DataNode::New();
     pf1->SetData(data);
 
     data = mitk::IOUtil::Load(argv[4])[0];
     auto pf2 = mitk::DataNode::New();
     pf2->SetData(data);
 
     data = mitk::IOUtil::Load(argv[5])[0];
     auto pf3 = mitk::DataNode::New();
     pf3->SetData(data);
 
     mitk::StandaloneDataStorage::Pointer storage = mitk::StandaloneDataStorage::New();
 
     mitk::PlanarFigureComposite::Pointer pfc2 = mitk::PlanarFigureComposite::New();
     pfc2->setOperationType(mitk::PlanarFigureComposite::OR);
     mitk::DataNode::Pointer pfcNode2 = mitk::DataNode::New();
     pfcNode2->SetData(pfc2);
     mitk::DataStorage::SetOfObjects::Pointer set2 = mitk::DataStorage::SetOfObjects::New();
     set2->push_back(pfcNode2);
 
     mitk::PlanarFigureComposite::Pointer pfc1 = mitk::PlanarFigureComposite::New();
     pfc1->setOperationType(mitk::PlanarFigureComposite::AND);
     mitk::DataNode::Pointer pfcNode1 = mitk::DataNode::New();
     pfcNode1->SetData(pfc1);
     mitk::DataStorage::SetOfObjects::Pointer set1 = mitk::DataStorage::SetOfObjects::New();
     set1->push_back(pfcNode1);
 
     storage->Add(pfcNode2);
     storage->Add(pf1, set2);
     storage->Add(pfcNode1, set2);
     storage->Add(pf2, set1);
     storage->Add(pf3, set1);
 
     MITK_INFO << "TEST1";
     mitk::FiberBundle::Pointer extractedFibs = groundTruthFibs->ExtractFiberSubset(pfcNode2, storage);
     MITK_INFO << "TEST2";
     MITK_TEST_CONDITION_REQUIRED(extractedFibs->Equals(testFibs),"check planar figure extraction");
 
     MITK_INFO << "TEST3";
     // test subtraction and addition
     mitk::FiberBundle::Pointer notExtractedFibs = groundTruthFibs->SubtractBundle(extractedFibs);
 
     MITK_INFO << argv[11];
     testFibs = mitk::IOUtil::Load<mitk::FiberBundle>(argv[11]);
     MITK_TEST_CONDITION_REQUIRED(notExtractedFibs->Equals(testFibs),"check bundle subtraction");
 
     mitk::FiberBundle::Pointer joinded = extractedFibs->AddBundle(notExtractedFibs);
     testFibs = mitk::IOUtil::Load<mitk::FiberBundle>(argv[12]);
     MITK_TEST_CONDITION_REQUIRED(joinded->Equals(testFibs),"check bundle addition");
 
     // test binary image based extraction
     mitk::Image::Pointer mitkRoiImage = mitk::IOUtil::Load<mitk::Image>(argv[6]);
     typedef itk::Image< unsigned char, 3 >    itkUCharImageType;
     itkUCharImageType::Pointer itkRoiImage = itkUCharImageType::New();
     mitk::CastToItkImage(mitkRoiImage, itkRoiImage);
 
     {
       testFibs = mitk::IOUtil::Load<mitk::FiberBundle>(argv[9]);
       itk::FiberExtractionFilter<unsigned char>::Pointer extractor = itk::FiberExtractionFilter<unsigned char>::New();
-      mitk::FiberBundle::Pointer test = groundTruthFibs->GetDeepCopy();
-      test->ResampleLinear(0.2);
-      extractor->SetInputFiberBundle(test);
+      extractor->SetInputFiberBundle(groundTruthFibs);
       extractor->SetRoiImages({itkRoiImage});
       extractor->SetOverlapFraction(0.0);
-      extractor->SetBothEnds(true);
-      extractor->SetDontResampleFibers(true);
       extractor->SetMode(itk::FiberExtractionFilter<unsigned char>::MODE::OVERLAP);
       extractor->Update();
       mitk::FiberBundle::Pointer passing = extractor->GetPositives().at(0);
       bool ok = passing->Equals(testFibs);
       if(!ok)
         mitk::IOUtil::Save(passing, mitk::IOUtil::GetTempPath()+"passing_mask.fib");
 
       MITK_TEST_CONDITION_REQUIRED(ok,"check passing mask extraction");
     }
 
     {
       testFibs = mitk::IOUtil::Load<mitk::FiberBundle>(argv[10]);
       itk::FiberExtractionFilter<unsigned char>::Pointer extractor = itk::FiberExtractionFilter<unsigned char>::New();
       extractor->SetInputFiberBundle(groundTruthFibs);
       extractor->SetRoiImages({itkRoiImage});
       extractor->SetOverlapFraction(0.0);
       extractor->SetBothEnds(true);
       extractor->SetMode(itk::FiberExtractionFilter<unsigned char>::MODE::ENDPOINTS);
       extractor->Update();
       mitk::FiberBundle::Pointer ending = extractor->GetPositives().at(0);
       bool ok = ending->Equals(testFibs);
       if(!ok)
         mitk::IOUtil::Save(ending, mitk::IOUtil::GetTempPath()+"ending_mask.fib");
 
       MITK_TEST_CONDITION_REQUIRED(ending->Equals(testFibs),"check ending in mask extraction");
     }
   }
   catch(...) {
     return EXIT_FAILURE;
   }
 
   // always end with this!
   MITK_TEST_END();
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging.python/src/internal/QmitkTractSegView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging.python/src/internal/QmitkTractSegView.cpp
index 7944ec2eb5..6e275a3641 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging.python/src/internal/QmitkTractSegView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging.python/src/internal/QmitkTractSegView.cpp
@@ -1,353 +1,353 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkTractSegView.h"
 
 #include <mitkNodePredicateDataType.h>
 #include <mitkIPythonService.h>
 #include <boost/lexical_cast.hpp>
 #include <QFile>
 #include <QMessageBox>
 #include <usModuleContext.h>
 #include <usGetModuleContext.h>
 #include <mitkPeakImage.h>
 #include <mitkImageCast.h>
 #include <mitkImageToItk.h>
 #include <mitkITKImageImport.h>
 #include <itkFourDToVectorImageFilter.h>
 #include <itkVectorImageToFourDImageFilter.h>
 #include <itkSplitVectorImageFilter.h>
 #include <itkFlipPeaksFilter.h>
 #include <mitkLookupTable.h>
 #include <mitkLookupTableProperty.h>
 #include <mitkLevelWindow.h>
 #include <mitkLevelWindowProperty.h>
 
 const std::string QmitkTractSegView::VIEW_ID = "org.mitk.views.tractseg";
 
 QmitkTractSegView::QmitkTractSegView()
   : QmitkAbstractView()
   , m_Controls( 0 )
 {
 
 }
 
 // Destructor
 QmitkTractSegView::~QmitkTractSegView()
 {
 }
 
 void QmitkTractSegView::CreateQtPartControl( QWidget *parent )
 {
   // build up qt view, unless already done
   if ( !m_Controls )
   {
     // create GUI widgets from the Qt Designer's .ui file
     m_Controls = new Ui::QmitkTractSegViewControls;
     m_Controls->setupUi( parent );
     connect( m_Controls->m_ImageBox, SIGNAL(currentIndexChanged(int)), this, SLOT(UpdateGUI()) );
     connect( m_Controls->m_StartButton, SIGNAL(clicked()), this, SLOT(Start()) );
     connect( m_Controls->m_OutputBox, SIGNAL(currentIndexChanged(int)), this, SLOT(UpdateGUI()) );
     connect( m_Controls->m_ModeBox, SIGNAL(currentIndexChanged(int)), this, SLOT(UpdateGUI()) );
     this->m_Parent = parent;
 
     m_Controls->m_ImageBox->SetDataStorage(this->GetDataStorage());
     mitk::NodePredicateDataType::Pointer isDwi = mitk::NodePredicateDataType::New("PeakImage");
     m_Controls->m_ImageBox->SetPredicate( isDwi );
 
     UpdateGUI();
   }
 }
 
 void QmitkTractSegView::OnSelectionChanged(berry::IWorkbenchPart::Pointer, const QList<mitk::DataNode::Pointer>& )
 {
 }
 
 void QmitkTractSegView::UpdateGUI()
 {
   if (m_Controls->m_ImageBox->GetSelectedNode().IsNotNull())
     m_Controls->m_StartButton->setEnabled(true);
   else
     m_Controls->m_StartButton->setEnabled(false);
 
   m_Controls->m_CollapseBox->setVisible(true);
   m_Controls->m_thresholdFrame->setVisible(true);
 
   if (m_Controls->m_OutputBox->currentIndex()==3 || m_Controls->m_OutputBox->currentIndex()==1)
     m_Controls->m_thresholdFrame->setVisible(false);
 
   if (m_Controls->m_OutputBox->currentIndex()>0)
     m_Controls->m_CollapseBox->setVisible(false);
 }
 
 void QmitkTractSegView::SetFocus()
 {
   UpdateGUI();
   m_Controls->m_StartButton->setFocus();
 }
 
 void QmitkTractSegView::Start()
 {
   std::locale::global(std::locale::classic());
   mitk::DataNode::Pointer node = m_Controls->m_ImageBox->GetSelectedNode();
   mitk::Image::Pointer input_image = dynamic_cast<mitk::Image*>(node->GetData());
 
   // get python script as string
   QString data;
   QString fileName(":/QmitkDiffusionImaging/tractseg.py");
   QFile file(fileName);
   if(!file.open(QIODevice::ReadOnly)) {
     qDebug()<<"filenot opened"<<endl;
   }
   else
   {
     qDebug()<<"file opened"<<endl;
     data = file.readAll();
   }
   file.close();
 
   us::ModuleContext* context = us::GetModuleContext();
   us::ServiceReference<mitk::IPythonService> m_PythonServiceRef = context->GetServiceReference<mitk::IPythonService>();
   mitk::IPythonService* m_PythonService = dynamic_cast<mitk::IPythonService*> ( context->GetService<mitk::IPythonService>(m_PythonServiceRef) );
   mitk::IPythonService::ForceLoadModule();
 
   typedef mitk::ImageToItk< mitk::PeakImage::ItkPeakImageType > CasterType;
   CasterType::Pointer caster = CasterType::New();
   caster->SetInput(input_image);
   caster->Update();
   mitk::PeakImage::ItkPeakImageType::Pointer itk_peaks = caster->GetOutput();
   if (itk_peaks->GetLargestPossibleRegion().GetSize()[3]!=9)
   {
     QMessageBox::warning(nullptr, "Error", "TractSeg only works with 3-peak images!", QMessageBox::Ok);
     return;
   }
 
   itk::FlipPeaksFilter< float >::Pointer flipper = itk::FlipPeaksFilter< float >::New();
   flipper->SetInput(itk_peaks);
   flipper->SetFlipX(false);
-  flipper->SetFlipY(true);
-  flipper->SetFlipZ(false);
+  flipper->SetFlipY(false);
+  flipper->SetFlipZ(true);
   flipper->Update();
 
   itk::FourDToVectorImageFilter< float >::Pointer converter = itk::FourDToVectorImageFilter< float >::New();
   converter->SetInputImage(flipper->GetOutput());
   converter->GenerateData();
   mitk::Image::Pointer mitk_vec_img = mitk::GrabItkImageMemory( converter->GetOutputImage().GetPointer() );
 
   m_PythonService->Execute("import SimpleITK as sitk");
   m_PythonService->Execute("import SimpleITK._SimpleITK as _SimpleITK");
   m_PythonService->Execute("import numpy");
   m_PythonService->CopyToPythonAsSimpleItkImage( mitk_vec_img, "in_image");
 
   m_PythonService->Execute("sx=" + boost::lexical_cast<std::string>(itk_peaks->GetLargestPossibleRegion().GetSize()[0]));
   m_PythonService->Execute("sy=" + boost::lexical_cast<std::string>(itk_peaks->GetLargestPossibleRegion().GetSize()[1]));
   m_PythonService->Execute("sz=" + boost::lexical_cast<std::string>(itk_peaks->GetLargestPossibleRegion().GetSize()[2]));
 
   if (m_PythonService->DoesVariableExist("segmentation"))
     m_PythonService->Execute("del segmentation");
 
   if(m_Controls->m_ModeBox->currentIndex()==0)
     m_PythonService->Execute("output_type=\"tract_segmentation\"");
   else if(m_Controls->m_ModeBox->currentIndex()==1)
     m_PythonService->Execute("output_type=\"endings_segmentation\"");
 
   if(m_Controls->m_OutputBox->currentIndex()==3)
     m_PythonService->Execute("output_type=\"TOM\"");
 
 
   if (m_Controls->m_CollapseBox->isChecked() && m_Controls->m_OutputBox->currentIndex()==0)
     m_PythonService->Execute("collapse=True");
   else
     m_PythonService->Execute("collapse=False");
 
   m_PythonService->Execute("get_probs=False");
   m_PythonService->Execute("dropout_sampling=False");
 
   if (m_Controls->m_OutputBox->currentIndex()==1)
     m_PythonService->Execute("get_probs=True");
   else if (m_Controls->m_OutputBox->currentIndex()==2)
     m_PythonService->Execute("dropout_sampling=True");
 
   m_PythonService->Execute("threshold=" + boost::lexical_cast<std::string>(m_Controls->m_SegThresholdBox->value()));
 
   m_PythonService->Execute("verbose=False");
   m_PythonService->Execute(data.toStdString(), mitk::IPythonService::MULTI_LINE_COMMAND);
 
   // clean up after running script (better way than deleting individual variables?)
   if(m_PythonService->DoesVariableExist("in_image"))
     m_PythonService->Execute("del in_image");
   if(m_PythonService->DoesVariableExist("collapse"))
     m_PythonService->Execute("del collapse");
 
   // check for errors
   if(!m_PythonService->GetVariable("error_string").empty())
   {
     QMessageBox::warning(nullptr, "Error", QString(m_PythonService->GetVariable("error_string").c_str()), QMessageBox::Ok);
     return;
   }
 
   std::vector<std::string> small_name_list = {"AF_left", "AF_right", "CA", "CST_left", "CST_right", "CG_left", "CG_right",
                      "ICP_left", "ICP_right", "MCP", "SCP_left", "SCP_right", "ILF_left", "ILF_right",
                      "IFO_left", "IFO_right", "OR_left", "OR_right", "UF_left", "UF_right"};
 
   std::vector<std::string> large_name_list = {"AF_left", "AF_right", "ATR_left", "ATR_right", "CA", "CC_1", "CC_2", "CC_3", "CC_4", "CC_5",
                                               "CC_6", "CC_7","CG_left","CG_right","CST_left","CST_right" ,"MLF_left","MLF_right","FPT_left"
                                               ,"FPT_right","FX_left","FX_right","ICP_left","ICP_right","IFO_left","IFO_right"
                                               ,"ILF_left" ,"ILF_right","MCP","OR_left","OR_right","POPT_left","POPT_right"
                                               ,"SCP_left","SCP_right","SLF_I_left","SLF_I_right","SLF_II_left","SLF_II_right"
                                               ,"SLF_III_left","SLF_III_right","STR_left","STR_right","UF_left","UF_right"
                                               ,"CC","T_PREF_left","T_PREF_right","T_PREM_left","T_PREM_right","T_PREC_left"
                                               ,"T_PREC_right","T_POSTC_left","T_POSTC_right","T_PAR_left","T_PAR_right","T_OCC_left"
                                               ,"T_OCC_right","ST_FO_left","ST_FO_right","ST_PREF_left","ST_PREF_right","ST_PREM_left"
                                               ,"ST_PREM_right","ST_PREC_left","ST_PREC_right","ST_POSTC_left","ST_POSTC_right"
                                               ,"ST_PAR_left","ST_PAR_right","ST_OCC_left","ST_OCC_right"};
 
   if (m_PythonService->DoesVariableExist("segmentation"))
   {
     mitk::Image::Pointer out_image = m_PythonService->CopySimpleItkImageFromPython("segmentation");
 
     if (!m_Controls->m_CollapseBox->isChecked() || m_Controls->m_OutputBox->currentIndex()>0)
     {
       if (m_Controls->m_OutputBox->currentIndex()>0)
       {
         itk::VectorImage<float>::Pointer vectorImage = itk::VectorImage<float>::New();
         mitk::CastToItkImage(out_image, vectorImage);
         itk::SplitVectorImageFilter<float>::Pointer splitter = itk::SplitVectorImageFilter<float>::New();
         splitter->SetInputImage(vectorImage);
         splitter->GenerateData();
         int c = 0;
         for (auto itk_seg : splitter->GetOutputImages())
         {
           mitk::DataNode::Pointer seg = mitk::DataNode::New();
           seg->SetData( mitk::GrabItkImageMemory(itk_seg) );
           if (m_Controls->m_ModeBox->currentIndex()==0)
             seg->SetName(large_name_list.at(c));
           else
             seg->SetName(small_name_list.at(c));
 
           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 );
           seg->SetProperty("LookupTable", lut_prop );
           mitk::LevelWindow lw; lw.SetRangeMinMax(0.0,1.0);
           seg->SetProperty( "levelwindow", mitk::LevelWindowProperty::New( lw ) );
 
           GetDataStorage()->Add(seg, node);
           ++c;
         }
       }
       else
       {
         itk::VectorImage<unsigned char>::Pointer vectorImage = itk::VectorImage<unsigned char>::New();
         mitk::CastToItkImage(out_image, vectorImage);
         itk::SplitVectorImageFilter<unsigned char>::Pointer splitter = itk::SplitVectorImageFilter<unsigned char>::New();
         splitter->SetInputImage(vectorImage);
         splitter->GenerateData();
         int c = 0;
         for (auto itk_seg : splitter->GetOutputImages())
         {
           mitk::DataNode::Pointer seg = mitk::DataNode::New();
           seg->SetData( mitk::GrabItkImageMemory(itk_seg) );
           if (m_Controls->m_ModeBox->currentIndex()==0)
           {
             seg->SetName(large_name_list.at(c));
             seg->SetBoolProperty("binary", true);
           }
           else
           {
             mitk::LookupTable::Pointer lut = mitk::LookupTable::New();
             lut->SetType( mitk::LookupTable::MULTILABEL );
             mitk::LookupTableProperty::Pointer lut_prop = mitk::LookupTableProperty::New();
             lut_prop->SetLookupTable( lut );
             seg->SetProperty("LookupTable", lut_prop );
             mitk::LevelWindow lw; lw.SetRangeMinMax(0,2);
             seg->SetProperty( "levelwindow", mitk::LevelWindowProperty::New( lw ) );
 
             seg->SetName(small_name_list.at(c));
           }
           GetDataStorage()->Add(seg, node);
           ++c;
         }
       }
     }
     else
     {
       mitk::DataNode::Pointer seg = mitk::DataNode::New();
       seg->SetData(out_image);
 
       mitk::LevelWindow lw;
       if (m_Controls->m_ModeBox->currentIndex()==0)
       {
         seg->SetName("TractLabels");
         lw.SetRangeMinMax(0, 72);
       }
       else
       {
         seg->SetName("TractEndpointRegionLabels");
         lw.SetRangeMinMax(0, 40);
       }
 
       if (m_Controls->m_OutputBox->currentIndex()==0)
       {
         mitk::LookupTable::Pointer lut = mitk::LookupTable::New();
         lut->SetType( mitk::LookupTable::MULTILABEL );
         mitk::LookupTableProperty::Pointer lut_prop = mitk::LookupTableProperty::New();
         lut_prop->SetLookupTable( lut );
         seg->SetProperty("LookupTable", lut_prop );
         seg->SetProperty( "levelwindow", mitk::LevelWindowProperty::New( lw ) );
       }
 
       GetDataStorage()->Add(seg, node);
     }
 
     m_PythonService->Execute("del segmentation");
   }
   else
   {
     for (int i=0; i<20; ++i)
       if (m_PythonService->DoesVariableExist("tom" + boost::lexical_cast<std::string>(i)))
       {
         mitk::Image::Pointer out_image = m_PythonService->CopySimpleItkImageFromPython("tom" + boost::lexical_cast<std::string>(i));
         itk::VectorImage<float>::Pointer vectorImage = itk::VectorImage<float>::New();
         mitk::CastToItkImage(out_image, vectorImage);
 
         itk::VectorImageToFourDImageFilter< float >::Pointer converter = itk::VectorImageToFourDImageFilter< float >::New();
         converter->SetInputImage(vectorImage);
         converter->GenerateData();
         mitk::PeakImage::ItkPeakImageType::Pointer itk_peaks = converter->GetOutputImage();
 
         mitk::Image::Pointer mitk_peaks = dynamic_cast<mitk::Image*>(mitk::PeakImage::New().GetPointer());
         mitk::CastToMitkImage(itk_peaks, mitk_peaks);
         mitk_peaks->SetVolume(itk_peaks->GetBufferPointer());
 
         mitk::DataNode::Pointer seg = mitk::DataNode::New();
         seg->SetData( mitk_peaks );
         if (!m_Controls->m_CollapseBox->isChecked())
           seg->SetName(small_name_list.at(i) + "_TOM");
         else
           seg->SetName("Collapsed_TOM");
         GetDataStorage()->Add(seg, node);
         m_PythonService->Execute("del tom" + boost::lexical_cast<std::string>(i));
       }
   }
 }