diff --git a/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkDiffusionCoreIOMimeTypes.cpp b/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkDiffusionCoreIOMimeTypes.cpp
index b05a53cc8d..2f8fd6eeb3 100644
--- a/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkDiffusionCoreIOMimeTypes.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/autoload/IO/mitkDiffusionCoreIOMimeTypes.cpp
@@ -1,515 +1,517 @@
 /*===================================================================
 
 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 "mitkDiffusionCoreIOMimeTypes.h"
 #include "mitkIOMimeTypes.h"
 #include <itksys/SystemTools.hxx>
 #include <itkNrrdImageIO.h>
 #include <itkMetaDataDictionary.h>
 #include <itkMetaDataObject.h>
 #include <mitkLogMacros.h>
 #include <mitkDICOMDCMTKTagScanner.h>
 #include <mitkCustomMimeType.h>
 #include <itkGDCMImageIO.h>
 #include <itkNiftiImageIO.h>
 
 namespace mitk
 {
 
 std::vector<CustomMimeType*> DiffusionCoreIOMimeTypes::Get()
 {
   std::vector<CustomMimeType*> mimeTypes;
 
   // order matters here (descending rank for mime types)
 
   mimeTypes.push_back(DWI_NRRD_MIMETYPE().Clone());
   mimeTypes.push_back(DWI_NIFTI_MIMETYPE().Clone());
   mimeTypes.push_back(DWI_FSL_MIMETYPE().Clone());
   mimeTypes.push_back(DWI_DICOM_MIMETYPE().Clone());
   mimeTypes.push_back(DTI_MIMETYPE().Clone());
   mimeTypes.push_back(ODF_MIMETYPE().Clone());
   mimeTypes.push_back(PEAK_MIMETYPE().Clone());
 
   return mimeTypes;
 }
 
 // Mime Types
 
 DiffusionCoreIOMimeTypes::DiffusionImageNrrdMimeType::DiffusionImageNrrdMimeType()
   : CustomMimeType(DWI_NRRD_MIMETYPE_NAME())
 {
   std::string category = "Diffusion Weighted Images";
   this->SetCategory(category);
   this->SetComment("Diffusion Weighted Images");
 
   this->AddExtension("dwi");
   //this->AddExtension("hdwi"); // saving with detached header does not work out of the box
   this->AddExtension("nrrd");
 }
 
 bool DiffusionCoreIOMimeTypes::DiffusionImageNrrdMimeType::AppliesTo(const std::string &path) const
 {
   bool canRead( CustomMimeType::AppliesTo(path) );
 
   // fix for bug 18572
   // Currently this function is called for writing as well as reading, in that case
   // the image information can of course not be read
   // This is a bug, this function should only be called for reading.
   if( ! itksys::SystemTools::FileExists( path.c_str() ) )
   {
     return canRead;
   }
   //end fix for bug 18572
 
   std::string ext = this->GetExtension( path );
   ext = itksys::SystemTools::LowerCase( ext );
 
   // Simple NRRD files should only be considered for this mime type if they contain
   // corresponding tags
   if( ext == ".nrrd" )
   {
     itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
     io->SetFileName(path);
     try
     {
       io->ReadImageInformation();
 
       itk::MetaDataDictionary imgMetaDictionary = io->GetMetaDataDictionary();
       std::vector<std::string> imgMetaKeys = imgMetaDictionary.GetKeys();
       std::vector<std::string>::const_iterator itKey = imgMetaKeys.begin();
       std::string metaString;
 
       for (; itKey != imgMetaKeys.end(); itKey ++)
       {
         itk::ExposeMetaData<std::string> (imgMetaDictionary, *itKey, metaString);
         if (itKey->find("modality") != std::string::npos)
         {
           if (metaString.find("DWMRI") != std::string::npos)
           {
             return canRead;
           }
         }
       }
 
     }
     catch( const itk::ExceptionObject &e )
     {
       MITK_ERROR << "ITK Exception: " << e.what();
     }
     canRead = false;
   }
 
   return canRead;
 }
 
 DiffusionCoreIOMimeTypes::DiffusionImageNrrdMimeType* DiffusionCoreIOMimeTypes::DiffusionImageNrrdMimeType::Clone() const
 {
   return new DiffusionImageNrrdMimeType(*this);
 }
 
 
 DiffusionCoreIOMimeTypes::DiffusionImageNrrdMimeType DiffusionCoreIOMimeTypes::DWI_NRRD_MIMETYPE()
 {
   return DiffusionImageNrrdMimeType();
 }
 
 DiffusionCoreIOMimeTypes::DiffusionImageNiftiMimeType::DiffusionImageNiftiMimeType()
   : CustomMimeType(DWI_NIFTI_MIMETYPE_NAME())
 {
   std::string category = "Diffusion Weighted Images";
   this->SetCategory(category);
   this->SetComment("Diffusion Weighted Images");
   this->AddExtension("nii.gz");
   this->AddExtension("nii");
 }
 
 bool DiffusionCoreIOMimeTypes::DiffusionImageNiftiMimeType::AppliesTo(const std::string &path) const
 {
   bool canRead(CustomMimeType::AppliesTo(path));
 
   // fix for bug 18572
   // Currently this function is called for writing as well as reading, in that case
   // the image information can of course not be read
   // This is a bug, this function should only be called for reading.
   if (!itksys::SystemTools::FileExists(path.c_str()))
   {
     return canRead;
   }
   //end fix for bug 18572
 
   std::string ext = this->GetExtension(path);
   ext = itksys::SystemTools::LowerCase(ext);
 
   // Nifti files should only be considered for this mime type if they are
   // accompanied by bvecs and bvals files defining the diffusion information
   if (ext == ".nii" || ext == ".nii.gz")
   {
     std::string base_path = itksys::SystemTools::GetFilenamePath(path);
     std::string base = this->GetFilenameWithoutExtension(path);
     std::string filename = base;
     if (!base_path.empty())
     {
         base = base_path + "/" + base;
         base_path += "/";
     }
 
     if (itksys::SystemTools::FileExists(std::string(base + ".bvec").c_str())
       && itksys::SystemTools::FileExists(std::string(base + ".bval").c_str())
       )
     {
       return canRead;
     }
 
     if (itksys::SystemTools::FileExists(std::string(base + ".bvecs").c_str())
       && itksys::SystemTools::FileExists(std::string(base + ".bvals").c_str())
       )
     {
       return canRead;
     }
 
     // hack for HCP data
     if ( filename=="data" && itksys::SystemTools::FileExists(std::string(base_path + "bvec").c_str()) && itksys::SystemTools::FileExists(std::string(base_path + "bval").c_str()) )
     {
         return canRead;
     }
 
     if ( filename=="data" && itksys::SystemTools::FileExists(std::string(base_path + "bvecs").c_str()) && itksys::SystemTools::FileExists(std::string(base_path + "bvals").c_str()) )
     {
         return canRead;
     }
 
         canRead = false;
     }
 
   return canRead;
 }
 
 DiffusionCoreIOMimeTypes::DiffusionImageNiftiMimeType* DiffusionCoreIOMimeTypes::DiffusionImageNiftiMimeType::Clone() const
 {
   return new DiffusionImageNiftiMimeType(*this);
 }
 
 
 DiffusionCoreIOMimeTypes::DiffusionImageNiftiMimeType DiffusionCoreIOMimeTypes::DWI_NIFTI_MIMETYPE()
 {
   return DiffusionImageNiftiMimeType();
 }
 
 DiffusionCoreIOMimeTypes::DiffusionImageFslMimeType::DiffusionImageFslMimeType()
   : CustomMimeType(DWI_FSL_MIMETYPE_NAME())
 {
   std::string category = "Diffusion Weighted Image";
   this->SetCategory(category);
   this->SetComment("Diffusion Weighted Images");
   this->AddExtension("fslgz");
   this->AddExtension("fsl");
 }
 
 bool DiffusionCoreIOMimeTypes::DiffusionImageFslMimeType::AppliesTo(const std::string &path) const
 {
   bool canRead(CustomMimeType::AppliesTo(path));
 
   // fix for bug 18572
   // Currently this function is called for writing as well as reading, in that case
   // the image information can of course not be read
   // This is a bug, this function should only be called for reading.
   if (!itksys::SystemTools::FileExists(path.c_str()))
   {
     return canRead;
   }
   //end fix for bug 18572
 
   std::string ext = this->GetExtension(path);
   ext = itksys::SystemTools::LowerCase(ext);
 
   // Nifti files should only be considered for this mime type if they are
   // accompanied by bvecs and bvals files defining the diffusion information
   if (ext == ".fsl" || ext == ".fslgz")
   {
       std::string base_path = itksys::SystemTools::GetFilenamePath(path);
       std::string base = this->GetFilenameWithoutExtension(path);
       if (!base_path.empty())
           base = base_path + "/" + base;
 
     if (itksys::SystemTools::FileExists(std::string(base + ".bvec").c_str())
       && itksys::SystemTools::FileExists(std::string(base + ".bval").c_str())
       )
     {
       return canRead;
     }
 
     if (itksys::SystemTools::FileExists(std::string(base + ".bvecs").c_str())
       && itksys::SystemTools::FileExists(std::string(base + ".bvals").c_str())
       )
     {
       return canRead;
     }
 
     if (itksys::SystemTools::FileExists(std::string(base + ext + ".bvec").c_str())
       && itksys::SystemTools::FileExists(std::string(base + ext + ".bval").c_str())
       )
     {
       return canRead;
     }
 
     if (itksys::SystemTools::FileExists(std::string(base + ext + ".bvecs").c_str())
       && itksys::SystemTools::FileExists(std::string(base + ext + ".bvals").c_str())
       )
     {
       return canRead;
     }
 
     canRead = false;
   }
 
   return canRead;
 }
 
 DiffusionCoreIOMimeTypes::DiffusionImageFslMimeType* DiffusionCoreIOMimeTypes::DiffusionImageFslMimeType::Clone() const
 {
   return new DiffusionImageFslMimeType(*this);
 }
 
 
 DiffusionCoreIOMimeTypes::DiffusionImageFslMimeType DiffusionCoreIOMimeTypes::DWI_FSL_MIMETYPE()
 {
   return DiffusionImageFslMimeType();
 }
 
 
 DiffusionCoreIOMimeTypes::DiffusionImageDicomMimeType::DiffusionImageDicomMimeType()
   : CustomMimeType(DWI_DICOM_MIMETYPE_NAME())
 {
   std::string category = "Diffusion Weighted Images";
   this->SetCategory(category);
   this->SetComment("Diffusion Weighted Images");
 
   this->AddExtension("gdcm");
   this->AddExtension("dcm");
   this->AddExtension("DCM");
   this->AddExtension("dc3");
   this->AddExtension("DC3");
   this->AddExtension("ima");
   this->AddExtension("img");
 }
 
 bool DiffusionCoreIOMimeTypes::DiffusionImageDicomMimeType::AppliesTo(const std::string &path) const
 {
   itk::GDCMImageIO::Pointer gdcmIO = itk::GDCMImageIO::New();
   bool canRead = gdcmIO->CanReadFile(path.c_str());
 
   if (!canRead)
     return canRead;
 
   mitk::DICOMDCMTKTagScanner::Pointer scanner = mitk::DICOMDCMTKTagScanner::New();
   mitk::DICOMTag ImageTypeTag(0x0008, 0x0008);
+  mitk::DICOMTag SeriesDescriptionTag(0x0008, 0x103E);
 
   mitk::StringList relevantFiles;
   relevantFiles.push_back(path);
 
   scanner->AddTag(ImageTypeTag);
+  scanner->AddTag(SeriesDescriptionTag);
   scanner->SetInputFiles(relevantFiles);
   scanner->Scan();
   mitk::DICOMTagCache::Pointer tagCache = scanner->GetScanCache();
 
   mitk::DICOMImageFrameList imageFrameList = mitk::ConvertToDICOMImageFrameList(tagCache->GetFrameInfoList());
   mitk::DICOMImageFrameInfo *firstFrame = imageFrameList.begin()->GetPointer();
 
   std::string byteString = tagCache->GetTagValue(firstFrame, ImageTypeTag).value;
-
-  if (byteString.empty()) {
+  if (byteString.empty())
     return false;
-  }
 
-  std::size_t found = byteString.find("DIFFUSION");
-  if (found==std::string::npos)
+  std::string byteString2 = tagCache->GetTagValue(firstFrame, SeriesDescriptionTag).value;
+  if (byteString2.empty())
     return false;
-  found = byteString.find("NONE");
-  if (found==std::string::npos)
+
+  if (byteString.find("DIFFUSION")==std::string::npos && byteString2.find("diff")==std::string::npos)
     return false;
+//  if (byteString.find("NONE")==std::string::npos)
+//    return false;
 
   return canRead;
 }
 
 DiffusionCoreIOMimeTypes::DiffusionImageDicomMimeType* DiffusionCoreIOMimeTypes::DiffusionImageDicomMimeType::Clone() const
 {
   return new DiffusionImageDicomMimeType(*this);
 }
 
 
 DiffusionCoreIOMimeTypes::DiffusionImageDicomMimeType DiffusionCoreIOMimeTypes::DWI_DICOM_MIMETYPE()
 {
   return DiffusionImageDicomMimeType();
 }
 
 
 DiffusionCoreIOMimeTypes::PeakImageMimeType::PeakImageMimeType() : CustomMimeType(PEAK_MIMETYPE_NAME())
 {
   std::string category = "Peak Image";
   this->SetCategory(category);
   this->SetComment("Peak Image");
 
   this->AddExtension("nrrd");
   this->AddExtension("nii");
   this->AddExtension("nii.gz");
 }
 
 bool DiffusionCoreIOMimeTypes::PeakImageMimeType::AppliesTo(const std::string &path) const
 {
   {
     itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
     if ( io->CanReadFile( path.c_str() ) )
     {
       io->SetFileName( path.c_str() );
       io->ReadImageInformation();
       if ( io->GetPixelType() == itk::ImageIOBase::SCALAR && io->GetNumberOfDimensions()==4 && io->GetDimensions(3)%3==0)
         return true;
     }
   }
   {
     itk::NiftiImageIO::Pointer io = itk::NiftiImageIO::New();
     if ( io->CanReadFile( path.c_str() ) )
     {
       io->SetFileName( path.c_str() );
       io->ReadImageInformation();
       if ( io->GetPixelType() == itk::ImageIOBase::SCALAR && io->GetNumberOfDimensions()==4 && io->GetDimensions(3)%3==0)
         return true;
     }
   }
 
   return false;
 }
 
 DiffusionCoreIOMimeTypes::PeakImageMimeType* DiffusionCoreIOMimeTypes::PeakImageMimeType::Clone() const
 {
   return new PeakImageMimeType(*this);
 }
 
 
 DiffusionCoreIOMimeTypes::PeakImageMimeType DiffusionCoreIOMimeTypes::PEAK_MIMETYPE()
 {
   return PeakImageMimeType();
 }
 
 
 CustomMimeType DiffusionCoreIOMimeTypes::DTI_MIMETYPE()
 {
   CustomMimeType mimeType(DTI_MIMETYPE_NAME());
   std::string category = "Tensor Images";
   mimeType.SetComment("Diffusion Tensor Images");
   mimeType.SetCategory(category);
   mimeType.AddExtension("dti");
   return mimeType;
 }
 
 CustomMimeType DiffusionCoreIOMimeTypes::ODF_MIMETYPE()
 {
   CustomMimeType mimeType(ODF_MIMETYPE_NAME());
   std::string category = "ODF Images";
   mimeType.SetComment("Diffusion ODF Images");
   mimeType.SetCategory(category);
   mimeType.AddExtension("odf");
   mimeType.AddExtension("qbi"); // legacy support
   return mimeType;
 }
 
 // Names
 std::string DiffusionCoreIOMimeTypes::PEAK_MIMETYPE_NAME()
 {
   static std::string name = IOMimeTypes::DEFAULT_BASE_NAME() + ".nrrd";
   return name;
 }
 
 std::string DiffusionCoreIOMimeTypes::DWI_NRRD_MIMETYPE_NAME()
 {
   static std::string name = IOMimeTypes::DEFAULT_BASE_NAME() + ".dwi";
   return name;
 }
 
 std::string DiffusionCoreIOMimeTypes::DWI_NIFTI_MIMETYPE_NAME()
 {
   static std::string name = IOMimeTypes::DEFAULT_BASE_NAME() + ".nii.gz";
   return name;
 }
 
 std::string DiffusionCoreIOMimeTypes::DWI_FSL_MIMETYPE_NAME()
 {
   static std::string name = IOMimeTypes::DEFAULT_BASE_NAME() + ".fslgz";
   return name;
 }
 
 std::string DiffusionCoreIOMimeTypes::DWI_DICOM_MIMETYPE_NAME()
 {
   static std::string name = IOMimeTypes::DEFAULT_BASE_NAME() + ".IMA";
   return name;
 }
 
 std::string DiffusionCoreIOMimeTypes::DTI_MIMETYPE_NAME()
 {
   static std::string name = IOMimeTypes::DEFAULT_BASE_NAME() + ".dti";
   return name;
 }
 
 std::string DiffusionCoreIOMimeTypes::ODF_MIMETYPE_NAME()
 {
   static std::string name = IOMimeTypes::DEFAULT_BASE_NAME() + ".odf";
   return name;
 }
 
 // Descriptions
 std::string DiffusionCoreIOMimeTypes::PEAK_MIMETYPE_DESCRIPTION()
 {
   static std::string description = "Peak Image";
   return description;
 }
 
 std::string DiffusionCoreIOMimeTypes::DWI_NRRD_MIMETYPE_DESCRIPTION()
 {
   static std::string description = "Diffusion Weighted Images";
   return description;
 }
 
 std::string DiffusionCoreIOMimeTypes::DWI_NIFTI_MIMETYPE_DESCRIPTION()
 {
   static std::string description = "Diffusion Weighted Images";
   return description;
 }
 
 std::string DiffusionCoreIOMimeTypes::DWI_FSL_MIMETYPE_DESCRIPTION()
 {
   static std::string description = "Diffusion Weighted Images";
   return description;
 }
 
 std::string DiffusionCoreIOMimeTypes::DWI_DICOM_MIMETYPE_DESCRIPTION()
 {
   static std::string description = "Diffusion Weighted Images";
   return description;
 }
 
 std::string DiffusionCoreIOMimeTypes::DTI_MIMETYPE_DESCRIPTION()
 {
   static std::string description = "Diffusion Tensor Images";
   return description;
 }
 
 std::string DiffusionCoreIOMimeTypes::ODF_MIMETYPE_DESCRIPTION()
 {
   static std::string description = "ODF Images";
   return description;
 }
 
 }
diff --git a/Modules/DiffusionImaging/DiffusionCore/src/Algorithms/Registration/mitkDWIHeadMotionCorrectionFilter.cpp b/Modules/DiffusionImaging/DiffusionCore/src/Algorithms/Registration/mitkDWIHeadMotionCorrectionFilter.cpp
index 19cc8f7ac4..e02338c015 100644
--- a/Modules/DiffusionImaging/DiffusionCore/src/Algorithms/Registration/mitkDWIHeadMotionCorrectionFilter.cpp
+++ b/Modules/DiffusionImaging/DiffusionCore/src/Algorithms/Registration/mitkDWIHeadMotionCorrectionFilter.cpp
@@ -1,148 +1,148 @@
 /*===================================================================
 
 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 MITKDWIHEADMOTIONCORRECTIONFILTER_CPP
 #define MITKDWIHEADMOTIONCORRECTIONFILTER_CPP
 
 #include "mitkDWIHeadMotionCorrectionFilter.h"
 
 #include "itkSplitDWImageFilter.h"
 #include "itkB0ImageExtractionToSeparateImageFilter.h"
 
 #include "mitkImageTimeSelector.h"
 
 #include <itkExtractDwiChannelFilter.h>
 #include <mitkMultiModalAffineDefaultRegistrationAlgorithm.h>
 #include <mitkAlgorithmHelper.h>
 #include <mitkMaskedAlgorithmHelper.h>
 #include <mitkImageMappingHelper.h>
 #include <mitkRegistrationHelper.h>
 #include <mitkRegistrationWrapper.h>
 #include <mitkRegistrationWrapperMapper3D.h>
 
 #include <itkComposeImageFilter.h>
 #include <mitkDiffusionPropertyHelper.h>
 #include <mitkImageCast.h>
 #include <mitkDiffusionImageCorrectionFilter.h>
 #include <mitkImageWriteAccessor.h>
 #include <mitkProperties.h>
 #include <mitkBValueMapProperty.h>
 
 #include <vector>
 
 #include "mitkIOUtil.h"
 #include <itkImage.h>
 
 typedef mitk::DiffusionPropertyHelper DPH;
 typedef itk::ExtractDwiChannelFilter< short > ExtractorType;
 
 mitk::DWIHeadMotionCorrectionFilter::DWIHeadMotionCorrectionFilter()
 {
 
 }
 
 mitk::Image::Pointer mitk::DWIHeadMotionCorrectionFilter::GetCorrectedImage() const
 {
   return m_CorrectedImage;
 }
 
 void mitk::DWIHeadMotionCorrectionFilter::UpdateOutputInformation()
   {
   Superclass::UpdateOutputInformation();
         }
 
 void mitk::DWIHeadMotionCorrectionFilter::GenerateData()
   {
   InputImageType::Pointer input = const_cast<InputImageType*>(this->GetInput(0));
 
   if (!DPH::IsDiffusionWeightedImage(input))
     mitkThrow() << "Input is not a diffusion-weighted image!";
 
   ITKDiffusionImageType::Pointer itkVectorImagePointer = DPH::GetItkVectorImage(input);
   int num_gradients = itkVectorImagePointer->GetVectorLength();
 
   typedef itk::ComposeImageFilter < ITKDiffusionVolumeType > ComposeFilterType;
   ComposeFilterType::Pointer composer = ComposeFilterType::New();
 
   // Extract unweighted volumes
   mitk::BValueMapProperty::BValueMap bval_map = DPH::GetBValueMap(input);
   int first_unweighted_index = bval_map.at(0).front();
 
   ExtractorType::Pointer filter = ExtractorType::New();
   filter->SetInput( itkVectorImagePointer);
   filter->SetChannelIndex(first_unweighted_index);
   filter->Update();
 
   mitk::Image::Pointer fixedImage = mitk::Image::New();
   fixedImage->InitializeByItk( filter->GetOutput() );
   fixedImage->SetImportChannel( filter->GetOutput()->GetBufferPointer() );
   composer->SetInput(0, filter->GetOutput());
 
   mitk::MultiModalAffineDefaultRegistrationAlgorithm< ITKDiffusionVolumeType >::Pointer algo = mitk::MultiModalAffineDefaultRegistrationAlgorithm< ITKDiffusionVolumeType >::New();
   mitk::MITKAlgorithmHelper helper(algo);
 
   typedef vnl_matrix_fixed< double, 3, 3> TransformMatrixType;
   std::vector< TransformMatrixType > estimated_transforms;
   std::vector< ITKDiffusionVolumeType::Pointer > registered_itk_images;
   for (int i=0; i<num_gradients; ++i)
   {
     if (i==first_unweighted_index)
       continue;
 
     MITK_INFO << "Correcting volume " << i;
 
     ExtractorType::Pointer filter = ExtractorType::New();
     filter->SetInput( itkVectorImagePointer);
     filter->SetChannelIndex(i);
     filter->Update();
 
     mitk::Image::Pointer movingImage = mitk::Image::New();
     movingImage->InitializeByItk( filter->GetOutput() );
     movingImage->SetImportChannel( filter->GetOutput()->GetBufferPointer() );
 
     helper.SetData(movingImage, fixedImage);
     mitk::MAPRegistrationWrapper::Pointer reg = helper.GetMITKRegistrationWrapper();
     mitk::MITKRegistrationHelper::Affine3DTransformType::Pointer affine = mitk::MITKRegistrationHelper::getAffineMatrix(reg, false);
     estimated_transforms.push_back(affine->GetMatrix().GetVnlMatrix());
 
-    mitk::Image::Pointer registered_mitk_image = mitk::ImageMappingHelper::map(movingImage, reg, false, 0, nullptr, false, 0, mitk::ImageMappingInterpolator::WSinc_Hamming);
+    mitk::Image::Pointer registered_mitk_image = mitk::ImageMappingHelper::map(movingImage, reg, false, 0, nullptr, false, 0, mitk::ImageMappingInterpolator::BSpline_3);
     ITKDiffusionVolumeType::Pointer registered_itk_image = ITKDiffusionVolumeType::New();
     mitk::CastToItkImage(registered_mitk_image, registered_itk_image);
     registered_itk_images.push_back(registered_itk_image);
     }
 
   int i=1;
   for (auto image : registered_itk_images)
   {
     composer->SetInput(i, image);
     ++i;
   }
   composer->Update();
 
   m_CorrectedImage = mitk::GrabItkImageMemory( composer->GetOutput() );
   DPH::CopyProperties(input, m_CorrectedImage, true);
 
   typedef mitk::DiffusionImageCorrectionFilter CorrectionFilterType;
   CorrectionFilterType::Pointer corrector = CorrectionFilterType::New();
   corrector->SetImage( m_CorrectedImage );
   corrector->CorrectDirections( estimated_transforms );
 
   DPH propertyHelper( m_CorrectedImage );
   propertyHelper.InitializeImage();
 }
 
 #endif // MITKDWIHEADMOTIONCORRECTIONFILTER_CPP
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFiberExtractionFilter.cpp b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFiberExtractionFilter.cpp
index e73eff0f05..7fef1f4db9 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFiberExtractionFilter.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFiberExtractionFilter.cpp
@@ -1,380 +1,391 @@
 /*===================================================================
 
 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 __itkFiberExtractionFilter_cpp
 #define __itkFiberExtractionFilter_cpp
 
 #include "itkFiberExtractionFilter.h"
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 #include <boost/progress.hpp>
 #include <mitkDiffusionFunctionCollection.h>
 
 namespace itk{
 
 
 template< class PixelType >
 FiberExtractionFilter< PixelType >::FiberExtractionFilter()
   : m_DontResampleFibers(false)
   , m_Mode(MODE::OVERLAP)
   , m_InputType(INPUT::SCALAR_MAP)
   , m_BothEnds(true)
   , m_OverlapFraction(0.8)
   , m_NoNegatives(false)
   , m_NoPositives(false)
   , m_Interpolate(false)
   , m_Threshold(0.5)
   , m_Labels({1})
   , m_SkipSelfConnections(false)
+  , m_OnlySelfConnections(false)
   , m_SplitLabels(false)
   , m_MinFibersPerTract(0)
 {
   m_Interpolator = itk::LinearInterpolateImageFunction< itk::Image< PixelType, 3 >, float >::New();
 }
 
 template< class PixelType >
 FiberExtractionFilter< PixelType >::~FiberExtractionFilter()
 {
 
 }
 
 template< class PixelType >
 void FiberExtractionFilter< PixelType >::SetRoiImages(const std::vector<ItkInputImgType*> &rois)
 {
   for (auto roi : rois)
   {
     if (roi==nullptr)
     {
       MITK_INFO << "ROI image is NULL!";
       return;
     }
   }
   m_RoiImages = rois;
 }
 
 template< class PixelType >
 mitk::FiberBundle::Pointer FiberExtractionFilter< PixelType >::CreateFib(std::vector< long >& ids)
 {
   vtkSmartPointer<vtkFloatArray> weights = vtkSmartPointer<vtkFloatArray>::New();
   vtkSmartPointer<vtkPolyData> pTmp = m_InputFiberBundle->GeneratePolyDataByIds(ids, weights);
   mitk::FiberBundle::Pointer fib = mitk::FiberBundle::New(pTmp);
   fib->SetFiberWeights(weights);
   return fib;
 }
 
 template< class PixelType >
 bool FiberExtractionFilter< PixelType >::IsPositive(const itk::Point<float, 3>& itkP)
 {
   if( m_InputType == INPUT::SCALAR_MAP )
     return mitk::imv::IsInsideMask<PixelType>(itkP, m_Interpolate, m_Interpolator, m_Threshold);
   else if( m_InputType == INPUT::LABEL_MAP )
   {
     auto val = mitk::imv::GetImageValue<PixelType>(itkP, m_Interpolate, m_Interpolator);
     for (auto l : m_Labels)
       if (l==val)
         return true;
   }
   else
     mitkThrow() << "No valid input type selected!";
   return false;
 }
 
 template< class PixelType >
 std::vector< std::pair<unsigned int, unsigned int> > FiberExtractionFilter< PixelType >::GetPositiveLabels() const
 {
   return m_PositiveLabels;
 }
 
 template< class PixelType >
 void FiberExtractionFilter< PixelType >::ExtractOverlap(mitk::FiberBundle::Pointer fib)
 {
   MITK_INFO << "Extracting fibers (min. overlap " << m_OverlapFraction << ")";
   vtkSmartPointer<vtkPolyData> polydata = fib->GetFiberPolyData();
 
   std::vector< std::vector< long > > positive_ids;
   positive_ids.resize(m_RoiImages.size());
 
   std::vector< long > negative_ids; // fibers not overlapping with ANY mask
 
   boost::progress_display disp(m_InputFiberBundle->GetNumFibers());
   for (int i=0; i<m_InputFiberBundle->GetNumFibers(); i++)
   {
     ++disp;
     vtkCell* cell = polydata->GetCell(i);
     int numPoints = cell->GetNumberOfPoints();
     vtkPoints* points = cell->GetPoints();
 
     bool positive = false;
     for (unsigned int m=0; m<m_RoiImages.size(); ++m)
     {
       auto roi = m_RoiImages.at(m);
       m_Interpolator->SetInputImage(roi);
       int inside = 0;
       int outside = 0;
       for (int j=0; j<numPoints; j++)
       {
         double* p = points->GetPoint(j);
 
         itk::Point<float, 3> itkP;
         itkP[0] = p[0]; itkP[1] = p[1]; itkP[2] = p[2];
 
         if ( IsPositive(itkP) )
           inside++;
         else
           outside++;
 
         if ((float)inside/numPoints > m_OverlapFraction)
         {
           positive = true;
           positive_ids[m].push_back(i);
           break;
         }
       }
     }
     if (!positive)
       negative_ids.push_back(i);
   }
 
   if (!m_NoNegatives)
     m_Negatives.push_back(CreateFib(negative_ids));
   if (!m_NoPositives)
     for (auto ids : positive_ids)
       if (ids.size()>=m_MinFibersPerTract)
         m_Positives.push_back(CreateFib(ids));
 }
 
 template< class PixelType >
 void FiberExtractionFilter< PixelType >::ExtractEndpoints(mitk::FiberBundle::Pointer fib)
 {
   MITK_INFO << "Extracting fibers (endpoints in mask)";
   vtkSmartPointer<vtkPolyData> polydata = fib->GetFiberPolyData();
 
   std::vector< std::vector< long > > positive_ids;
   positive_ids.resize(m_RoiImages.size());
 
   std::vector< long > negative_ids; // fibers not overlapping with ANY mask
 
   boost::progress_display disp(m_InputFiberBundle->GetNumFibers());
   for (int i=0; i<m_InputFiberBundle->GetNumFibers(); i++)
   {
     ++disp;
     vtkCell* cell = polydata->GetCell(i);
     int numPoints = cell->GetNumberOfPoints();
     vtkPoints* points = cell->GetPoints();
 
     bool positive = false;
     if (numPoints>1)
       for (unsigned int m=0; m<m_RoiImages.size(); ++m)
       {
         auto roi = m_RoiImages.at(m);
         m_Interpolator->SetInputImage(roi);
 
         int inside = 0;
 
         // check first fiber point
         {
           double* p = points->GetPoint(0);
           itk::Point<float, 3> itkP;
           itkP[0] = p[0]; itkP[1] = p[1]; itkP[2] = p[2];
 
           if ( IsPositive(itkP) )
             inside++;
         }
 
         // check second fiber point
         {
           double* p = points->GetPoint(numPoints-1);
           itk::Point<float, 3> itkP;
           itkP[0] = p[0]; itkP[1] = p[1]; itkP[2] = p[2];
 
           if ( IsPositive(itkP) )
             inside++;
         }
 
         if (inside==2 || (inside==1 && !m_BothEnds))
         {
           positive = true;
           positive_ids[m].push_back(i);
         }
       }
     if (!positive)
       negative_ids.push_back(i);
   }
 
   if (!m_NoNegatives)
     m_Negatives.push_back(CreateFib(negative_ids));
   if (!m_NoPositives)
     for (auto ids : positive_ids)
       if (ids.size()>=m_MinFibersPerTract)
         m_Positives.push_back(CreateFib(ids));
 }
 
 template< class PixelType >
 void FiberExtractionFilter< PixelType >::ExtractLabels(mitk::FiberBundle::Pointer fib)
 {
   MITK_INFO << "Extracting fibers by labels";
   vtkSmartPointer<vtkPolyData> polydata = fib->GetFiberPolyData();
 
-  std::vector< std::map< unsigned int, std::vector< long > > > positive_ids;
+  std::vector< std::map< std::pair< unsigned int, unsigned int >, std::vector< long > > > positive_ids;
   positive_ids.resize(m_RoiImages.size());
 
   std::vector< long > negative_ids; // fibers not overlapping with ANY label
 
   boost::progress_display disp(m_InputFiberBundle->GetNumFibers());
   for (int i=0; i<m_InputFiberBundle->GetNumFibers(); i++)
   {
     ++disp;
     vtkCell* cell = polydata->GetCell(i);
     int numPoints = cell->GetNumberOfPoints();
     vtkPoints* points = cell->GetPoints();
 
     bool positive = false;
     if (numPoints>1)
       for (unsigned int m=0; m<m_RoiImages.size(); ++m)
       {
         auto roi = m_RoiImages.at(m);
         m_Interpolator->SetInputImage(roi);
 
         int inside = 0;
 
         // check first fiber point
         short label1 = -1;
         {
           double* p = points->GetPoint(0);
           itk::Point<float, 3> itkP;
           itkP[0] = p[0]; itkP[1] = p[1]; itkP[2] = p[2];
 
           label1 = mitk::imv::GetImageValue<PixelType>(itkP, m_Interpolate, m_Interpolator);
           for (auto l : m_Labels)
           {
             if (l==label1)
             {
               inside++;
               break;
             }
           }
         }
 
         // check second fiber point
         short label2 = -1;
         {
           double* p = points->GetPoint(numPoints-1);
           itk::Point<float, 3> itkP;
           itkP[0] = p[0]; itkP[1] = p[1]; itkP[2] = p[2];
 
           label2 = mitk::imv::GetImageValue<PixelType>(itkP, m_Interpolate, m_Interpolator);
           for (auto l : m_Labels)
           {
             if (l==label2)
             {
               inside++;
               break;
             }
           }
         }
 
-        if ( inside==2 && (!m_SkipSelfConnections || label1!=label2) )
+        if ( (inside==2 && (!m_SkipSelfConnections || label1!=label2)) || (inside==2 && m_OnlySelfConnections && label1==label2) )
         {
-          unsigned int key;
+          std::pair< unsigned int, unsigned int > key;
           if (label1<label2)
-            key = m_Labels.size()*label1 + label2;
+            key = std::pair< unsigned int, unsigned int >(label1, label2);
           else
-            key = m_Labels.size()*label2 + label1;
+            key = std::pair< unsigned int, unsigned int >(label2, label1);
           positive = true;
           if ( positive_ids[m].count(key)==0 )
-            positive_ids[m].insert( std::pair< unsigned int, std::vector< long > >( key, {i}) );
+            positive_ids[m].insert( std::pair< std::pair< unsigned int, unsigned int >, std::vector< long > >( key, {i}) );
           else
             positive_ids[m][key].push_back(i);
         }
       }
     if (!positive)
       negative_ids.push_back(i);
   }
 
   if (!m_NoNegatives)
     m_Negatives.push_back(CreateFib(negative_ids));
   if (!m_NoPositives)
+  {
     for (auto labels : positive_ids)
       for (auto tuple : labels)
       {
         if (tuple.second.size()>=m_MinFibersPerTract)
         {
           m_Positives.push_back(CreateFib(tuple.second));
-          m_PositiveLabels.push_back(std::pair< unsigned int, unsigned int >( tuple.first/m_Labels.size(), tuple.first%m_Labels.size() ));
+          m_PositiveLabels.push_back(tuple.first);
         }
       }
+    if (!m_SplitLabels)
+    {
+      mitk::FiberBundle::Pointer output = mitk::FiberBundle::New(nullptr);
+      output = output->AddBundles(m_Positives);
+      m_Positives.clear();
+      m_Positives.push_back(output);
+      m_PositiveLabels.clear();
+    }
+  }
 }
 
 template< class PixelType >
 void FiberExtractionFilter< PixelType >::SetLabels(const std::vector<unsigned short> &Labels)
 {
   m_Labels = Labels;
 }
 
 template< class PixelType >
 std::vector<mitk::FiberBundle::Pointer> FiberExtractionFilter< PixelType >::GetNegatives() const
 {
   return m_Negatives;
 }
 
 template< class PixelType >
 std::vector<mitk::FiberBundle::Pointer> FiberExtractionFilter< PixelType >::GetPositives() const
 {
   return m_Positives;
 }
 
 template< class PixelType >
 void FiberExtractionFilter< PixelType >::GenerateData()
 {
   mitk::FiberBundle::Pointer fib = m_InputFiberBundle;
   if (fib->GetNumFibers()<=0)
   {
     MITK_INFO << "No fibers in tractogram!";
     return;
   }
 
   if (m_Mode==MODE::OVERLAP && !m_DontResampleFibers)
   {
     float minSpacing = 1;
     for (auto mask : m_RoiImages)
     {
       for (int i=0; i<3; ++i)
         if(mask->GetSpacing()[i]<minSpacing)
           minSpacing = mask->GetSpacing()[i];
     }
 
     fib = m_InputFiberBundle->GetDeepCopy();
     fib->ResampleLinear(minSpacing/5);
   }
 
   if (m_Mode == MODE::OVERLAP)
     ExtractOverlap(fib);
   else if (m_Mode == MODE::ENDPOINTS)
   {
-    if (m_InputType==INPUT::LABEL_MAP && m_BothEnds && m_SplitLabels)
+    if (m_InputType==INPUT::LABEL_MAP && m_BothEnds)
       ExtractLabels(fib);
     else
       ExtractEndpoints(fib);
   }
 }
 
 }
 
 #endif // __itkFiberExtractionFilter_cpp
 
 
 
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFiberExtractionFilter.h b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFiberExtractionFilter.h
index 243c359e63..53723023bd 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFiberExtractionFilter.h
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkFiberExtractionFilter.h
@@ -1,121 +1,123 @@
 /*===================================================================
 
 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 itkFiberExtractionFilter_h
 #define itkFiberExtractionFilter_h
 
 // MITK
 #include <mitkFiberBundle.h>
 
 // ITK
 #include <itkProcessObject.h>
 #include <itkLinearInterpolateImageFunction.h>
 
 namespace itk{
 
 /**
 * \brief Extract streamlines from tractograms using ROI images */
 
 template< class PixelType >
 class FiberExtractionFilter : public ProcessObject
 {
 public:
 
   enum MODE {
     OVERLAP,
     ENDPOINTS
   };
 
   enum INPUT {
     SCALAR_MAP,  ///< In this case, positive means roi image vlaue > threshold
     LABEL_MAP    ///< In this case, positive means roi image value in labels vector
   };
 
   typedef FiberExtractionFilter Self;
   typedef ProcessObject                   Superclass;
   typedef SmartPointer< Self >            Pointer;
   typedef SmartPointer< const Self >      ConstPointer;
   typedef itk::Image< PixelType , 3>      ItkInputImgType;
 
 
   itkFactorylessNewMacro(Self)
   itkCloneMacro(Self)
   itkTypeMacro( FiberExtractionFilter, ProcessObject )
 
   virtual void Update() override{
     this->GenerateData();
   }
 
   itkSetMacro( InputFiberBundle, mitk::FiberBundle::Pointer )
   itkSetMacro( Mode, MODE )                 ///< Overlap or endpoints
   itkSetMacro( InputType, INPUT )           ///< Scalar map or label image
   itkSetMacro( BothEnds, bool )             ///< Both streamline ends need to be inside of the ROI for the streamline to be considered positive
   itkSetMacro( OverlapFraction, float )     ///< Necessary fraction of streamline points inside the ROI for the streamline to be considered positive
   itkSetMacro( DontResampleFibers, bool )   ///< Don't resample input fibers to ensure coverage
   itkSetMacro( NoNegatives, bool )          ///< Don't create output tractograms from negative streamlines (save the computation)
   itkSetMacro( NoPositives, bool )          ///< Don't create output tractograms from positive streamlines (save the computation)
   itkSetMacro( Interpolate, bool )          ///< Interpolate input ROI image
   itkSetMacro( Threshold, float )           ///< Threshold on input ROI image value to determine positives/negatives
   itkSetMacro( SkipSelfConnections, bool )  ///< Ignore streamlines between two identical labels
+  itkSetMacro( OnlySelfConnections, bool )  ///< Only keep streamlines between two identical labels
   itkSetMacro( SplitLabels, bool )          ///< Output a separate tractogram for each label-->label tract
   itkSetMacro( MinFibersPerTract, unsigned int )  ///< Discard positives with less fibers
 
   void SetRoiImages(const std::vector< ItkInputImgType* > &rois);
   void SetLabels(const std::vector<unsigned short> &Labels);
 
   std::vector<mitk::FiberBundle::Pointer> GetPositives() const; ///< Get positive tracts (filtered by the input ROIs)
   std::vector<mitk::FiberBundle::Pointer> GetNegatives() const; ///< Get negative tracts (not filtered by the ROIs)
   std::vector<std::pair<unsigned int, unsigned int> > GetPositiveLabels() const;  ///< In case of label extraction, this vector contains the labels corresponding to the positive tracts
 
 protected:
 
   void GenerateData() override;
 
   FiberExtractionFilter();
   virtual ~FiberExtractionFilter();
 
   mitk::FiberBundle::Pointer CreateFib(std::vector< long >& ids);
   void ExtractOverlap(mitk::FiberBundle::Pointer fib);
   void ExtractEndpoints(mitk::FiberBundle::Pointer fib);
   void ExtractLabels(mitk::FiberBundle::Pointer fib);
   bool IsPositive(const itk::Point<float, 3>& itkP);
 
   mitk::FiberBundle::Pointer                  m_InputFiberBundle;
   std::vector< mitk::FiberBundle::Pointer >   m_Positives;
   std::vector< mitk::FiberBundle::Pointer >   m_Negatives;
   std::vector< ItkInputImgType* >             m_RoiImages;
   bool                                        m_DontResampleFibers;
   MODE                                        m_Mode;
   INPUT                                       m_InputType;
   bool                                        m_BothEnds;
   float                                       m_OverlapFraction;
   bool                                        m_NoNegatives;
   bool                                        m_NoPositives;
   bool                                        m_Interpolate;
   float                                       m_Threshold;
   std::vector< unsigned short >               m_Labels;
   bool                                        m_SkipSelfConnections;
+  bool                                        m_OnlySelfConnections;
   bool                                        m_SplitLabels;
   unsigned int                                m_MinFibersPerTract;
   std::vector< std::pair< unsigned int, unsigned int > >  m_PositiveLabels;
   typename itk::LinearInterpolateImageFunction< itk::Image< PixelType, 3 >, float >::Pointer   m_Interpolator;
 };
 }
 
 #ifndef ITK_MANUAL_INSTANTIATION
 #include "itkFiberExtractionFilter.cpp"
 #endif
 
 #endif
diff --git a/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/AnchorBasedScoring.cpp b/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/AnchorBasedScoring.cpp
index 325afde7dd..7aa4b410ca 100755
--- a/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/AnchorBasedScoring.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/AnchorBasedScoring.cpp
@@ -1,437 +1,437 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include <mitkBaseData.h>
 #include <mitkImageCast.h>
 #include <mitkImageToItk.h>
 #include <metaCommand.h>
 #include <mitkCommandLineParser.h>
 #include <usAny.h>
 #include <mitkIOUtil.h>
 #include <itksys/SystemTools.hxx>
 #include <itkDirectory.h>
 #include <mitkFiberBundle.h>
 #include <mitkPreferenceListReaderOptionsFunctor.h>
 #include <itkImageFileWriter.h>
 #include <mitkPeakImage.h>
 #include <itkFitFibersToImageFilter.h>
 #include <boost/lexical_cast.hpp>
 #include <itkTractDensityImageFilter.h>
 
 typedef itksys::SystemTools ist;
 typedef itk::Point<float, 4> PointType4;
 typedef itk::Image< float, 4 >  PeakImgType;
 typedef itk::Image< unsigned char, 3 >  ItkUcharImageType;
 
 std::vector< mitk::FiberBundle::Pointer > CombineTractograms(std::vector< mitk::FiberBundle::Pointer > reference, std::vector< mitk::FiberBundle::Pointer > candidates, int skip=-1)
 {
   std::vector< mitk::FiberBundle::Pointer > fib;
   for (auto f : reference)
     fib.push_back(f);
 
   int c = 0;
   for (auto f : candidates)
   {
     if (c!=skip)
       fib.push_back(f);
     ++c;
   }
 
   return fib;
 }
 
 /*!
 \brief Fits the tractogram to the input peak image by assigning a weight to each fiber (similar to https://doi.org/10.1016/j.neuroimage.2015.06.092).
 */
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
 
   parser.setTitle("Anchor Based Scoring");
   parser.setCategory("Fiber Tracking Evaluation");
   parser.setDescription("");
   parser.setContributor("MIC");
 
   parser.setArgumentPrefix("--", "-");
   parser.addArgument("", "a", mitkCommandLineParser::InputFile, "Anchor tractogram:", "anchor tracts in one tractogram file", us::Any(), false);
   parser.addArgument("", "p", mitkCommandLineParser::InputFile, "Input peaks:", "input peak image", us::Any(), false);
   parser.addArgument("", "c", mitkCommandLineParser::StringList, "Candidates:", "candidate tracts (separate files)", us::Any(), false);
   parser.addArgument("", "o", mitkCommandLineParser::OutputDirectory, "Output folder:", "output folder", us::Any(), false);
 
   parser.addArgument("anchor_masks", "", mitkCommandLineParser::StringList, "Reference Masks:", "reference tract masks for accuracy evaluation");
   parser.addArgument("mask", "", mitkCommandLineParser::InputFile, "Mask image:", "scoring is only performed inside the mask image");
   parser.addArgument("greedy_add", "", mitkCommandLineParser::Bool, "Greedy:", "if enabled, the candidate tracts are not jointly fitted to the residual image but one after the other employing a greedy scheme", false);
   parser.addArgument("lambda", "", mitkCommandLineParser::Float, "Lambda:", "modifier for regularization", 0.1);
   parser.addArgument("dont_filter_outliers", "", mitkCommandLineParser::Bool, "Don't filter outliers:", "don't perform second optimization run with an upper weight bound based on the first weight estimation (95% quantile)", false);
   parser.addArgument("regu", "", mitkCommandLineParser::String, "Regularization:", "MSM, MSE, LocalMSE (default), NONE");
 
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0)
     return EXIT_FAILURE;
 
   std::string anchors_file = us::any_cast<std::string>(parsedArgs["a"]);
   std::string peak_file_name = us::any_cast<std::string>(parsedArgs["p"]);
   mitkCommandLineParser::StringContainerType candidate_tract_files = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["c"]);
   std::string out_folder = us::any_cast<std::string>(parsedArgs["o"]);
 
   bool greedy_add = false;
   if (parsedArgs.count("greedy_add"))
     greedy_add = us::any_cast<bool>(parsedArgs["greedy_add"]);
 
   float lambda = 0.1;
   if (parsedArgs.count("lambda"))
     lambda = us::any_cast<float>(parsedArgs["lambda"]);
 
   bool filter_outliers = true;
   if (parsedArgs.count("dont_filter_outliers"))
     filter_outliers = !us::any_cast<bool>(parsedArgs["dont_filter_outliers"]);
 
   std::string mask_file = "";
   if (parsedArgs.count("mask"))
     mask_file = us::any_cast<std::string>(parsedArgs["mask"]);
 
   mitkCommandLineParser::StringContainerType anchor_mask_files;
   if (parsedArgs.count("anchor_masks"))
     anchor_mask_files = us::any_cast<mitkCommandLineParser::StringContainerType>(parsedArgs["anchor_masks"]);
 
   std::string regu = "NONE";
   if (parsedArgs.count("regu"))
     regu = us::any_cast<std::string>(parsedArgs["regu"]);
 
   try
   {
     itk::TimeProbe clock;
     clock.Start();
 
     MITK_INFO << "Creating output directory";
     if (ist::PathExists(out_folder))
       ist::RemoveADirectory(out_folder);
     ist::MakeDirectory(out_folder);
 
     MITK_INFO << "Loading data";
     std::streambuf *old = cout.rdbuf(); // <-- save
     std::stringstream ss;
     std::cout.rdbuf (ss.rdbuf());       // <-- redirect
 
     ofstream logfile;
     logfile.open (out_folder + "log.txt");
 
     itk::ImageFileWriter< PeakImgType >::Pointer peak_image_writer = itk::ImageFileWriter< PeakImgType >::New();
     mitk::PreferenceListReaderOptionsFunctor functor = mitk::PreferenceListReaderOptionsFunctor({"Peak Image", "Fiberbundles"}, {});
     mitk::Image::Pointer inputImage = dynamic_cast<mitk::PeakImage*>(mitk::IOUtil::Load(peak_file_name, &functor)[0].GetPointer());
 
     float minSpacing = 1;
     if(inputImage->GetGeometry()->GetSpacing()[0]<inputImage->GetGeometry()->GetSpacing()[1] && inputImage->GetGeometry()->GetSpacing()[0]<inputImage->GetGeometry()->GetSpacing()[2])
       minSpacing = inputImage->GetGeometry()->GetSpacing()[0];
     else if (inputImage->GetGeometry()->GetSpacing()[1] < inputImage->GetGeometry()->GetSpacing()[2])
       minSpacing = inputImage->GetGeometry()->GetSpacing()[1];
     else
       minSpacing = inputImage->GetGeometry()->GetSpacing()[2];
 
     // Load mask file. Fit is only performed inside the mask
     itk::FitFibersToImageFilter::UcharImgType::Pointer mask = nullptr;
     if (mask_file.compare("")!=0)
     {
       mitk::Image::Pointer mitk_mask = dynamic_cast<mitk::Image*>(mitk::IOUtil::Load(mask_file)[0].GetPointer());
       mitk::CastToItkImage(mitk_mask, mask);
     }
 
     // Load masks covering the true positives for evaluation purposes
     std::vector< itk::FitFibersToImageFilter::UcharImgType::Pointer > reference_masks;
     for (auto filename : anchor_mask_files)
     {
       itk::FitFibersToImageFilter::UcharImgType::Pointer ref_mask = nullptr;
       mitk::Image::Pointer ref_mitk_mask = dynamic_cast<mitk::Image*>(mitk::IOUtil::Load(filename)[0].GetPointer());
       mitk::CastToItkImage(ref_mitk_mask, ref_mask);
       reference_masks.push_back(ref_mask);
     }
 
     // Load peak image
     typedef mitk::ImageToItk< PeakImgType > CasterType;
     CasterType::Pointer caster = CasterType::New();
     caster->SetInput(inputImage);
     caster->Update();
     PeakImgType::Pointer peak_image = caster->GetOutput();
 
     // Load all candidate tracts
     std::vector< mitk::FiberBundle::Pointer > input_candidates;
     for (std::string f : candidate_tract_files)
     {
       mitk::FiberBundle::Pointer fib = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::Load(f)[0].GetPointer());
       if (fib.IsNull())
         continue;
       if (fib->GetNumFibers()<=0)
         continue;
       fib->ResampleLinear(minSpacing/10.0);
       input_candidates.push_back(fib);
     }
     std::cout.rdbuf (old);              // <-- restore
 
     double rmse = 0.0;
     int iteration = 0;
     std::string name = "NOANCHOR";
     // Load reference tractogram consisting of all known tracts
     std::vector< mitk::FiberBundle::Pointer > input_reference;
     mitk::FiberBundle::Pointer anchor_tractogram = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::Load(anchors_file)[0].GetPointer());
     if ( !(anchor_tractogram.IsNull() || anchor_tractogram->GetNumFibers()==0) )
     {
       std::streambuf *old = cout.rdbuf(); // <-- save
       std::stringstream ss;
       std::cout.rdbuf (ss.rdbuf());       // <-- redirect
       anchor_tractogram->ResampleLinear(minSpacing/10.0);
       std::cout.rdbuf (old);              // <-- restore
       input_reference.push_back(anchor_tractogram);
 
       // Fit known tracts to peak image to obtain underexplained image
       MITK_INFO << "Fit anchor tracts";
       itk::FitFibersToImageFilter::Pointer fitter = itk::FitFibersToImageFilter::New();
       fitter->SetTractograms(input_reference);
       fitter->SetLambda(lambda);
       fitter->SetFilterOutliers(filter_outliers);
       fitter->SetPeakImage(peak_image);
       fitter->SetVerbose(true);
       fitter->SetResampleFibers(false);
       fitter->SetMaskImage(mask);
 
       if (regu=="MSM")
         fitter->SetRegularization(VnlCostFunction::REGU::MSM);
       else if (regu=="MSE")
         fitter->SetRegularization(VnlCostFunction::REGU::MSE);
       else if (regu=="Local_MSE")
         fitter->SetRegularization(VnlCostFunction::REGU::Local_MSE);
       else if (regu=="NONE")
         fitter->SetRegularization(VnlCostFunction::REGU::NONE);
 
       fitter->Update();
       rmse = fitter->GetRMSE();
 
       name = ist::GetFilenameWithoutExtension(anchors_file);
       mitk::FiberBundle::Pointer anchor_tracts = fitter->GetTractograms().at(0);
       anchor_tracts->SetFiberColors(255,255,255);
       mitk::IOUtil::Save(anchor_tracts, out_folder + "0_" + name + ".fib");
 
       peak_image = fitter->GetUnderexplainedImage();
       peak_image_writer->SetInput(peak_image);
       peak_image_writer->SetFileName(out_folder + boost::lexical_cast<std::string>(iteration) + "_" + name + ".nrrd");
       peak_image_writer->Update();
     }
 
     if (!greedy_add)
     {
       MITK_INFO << "Fit candidate tracts";
       itk::FitFibersToImageFilter::Pointer fitter = itk::FitFibersToImageFilter::New();
       fitter->SetLambda(lambda);
       fitter->SetFilterOutliers(filter_outliers);
       fitter->SetVerbose(true);
       fitter->SetPeakImage(peak_image);
       fitter->SetResampleFibers(false);
       fitter->SetMaskImage(mask);
       fitter->SetTractograms(input_candidates);
       fitter->SetFitIndividualFibers(true);
 
       if (regu=="MSM")
         fitter->SetRegularization(VnlCostFunction::REGU::MSM);
       else if (regu=="MSE")
         fitter->SetRegularization(VnlCostFunction::REGU::MSE);
       else if (regu=="Local_MSE")
         fitter->SetRegularization(VnlCostFunction::REGU::Local_MSE);
       else if (regu=="NONE")
         fitter->SetRegularization(VnlCostFunction::REGU::NONE);
 
       fitter->Update();
       vnl_vector<double> rms_diff = fitter->GetRmsDiffPerBundle();
 
       vnl_vector<double> log_rms_diff = rms_diff-rms_diff.min_value() + 1;
       log_rms_diff = log_rms_diff.apply(std::log);
       log_rms_diff /= log_rms_diff.max_value();
       int c = 0;
       for (auto fib : input_candidates)
       {
         fib->SetFiberWeights( log_rms_diff[c] );
-        fib->ColorFibersByFiberWeights(false, true);
+//        fib->ColorFibersByFiberWeights(false, true);
 
         std::string bundle_name = ist::GetFilenameWithoutExtension(candidate_tract_files.at(c));
 
         std::streambuf *old = cout.rdbuf(); // <-- save
         std::stringstream ss;
         std::cout.rdbuf (ss.rdbuf());       // <-- redirect
         mitk::IOUtil::Save(fib, out_folder + boost::lexical_cast<std::string>((int)(100000*rms_diff[c])) + "_" + bundle_name + ".fib");
 
         float best_overlap = 0;
         int best_overlap_index = -1;
         int m_idx = 0;
         for (auto ref_mask : reference_masks)
         {
           float overlap = fib->GetOverlap(ref_mask, false);
           if (overlap>best_overlap)
           {
             best_overlap = overlap;
             best_overlap_index = m_idx;
           }
           ++m_idx;
         }
 
         unsigned int num_voxels = 0;
         {
           itk::TractDensityImageFilter< ItkUcharImageType >::Pointer masks_filter = itk::TractDensityImageFilter< ItkUcharImageType >::New();
           masks_filter->SetInputImage(mask);
           masks_filter->SetBinaryOutput(true);
           masks_filter->SetFiberBundle(fib);
           masks_filter->SetUseImageGeometry(true);
           masks_filter->Update();
           num_voxels = masks_filter->GetNumCoveredVoxels();
         }
 
         std::cout.rdbuf (old);              // <-- restore
 
         logfile << "RMS_DIFF: " << setprecision(5) << rms_diff[c] << " " << bundle_name << " " << num_voxels << "\n";
         if (best_overlap_index>=0)
           logfile << "Best_overlap: " << setprecision(5) << best_overlap << " " << ist::GetFilenameWithoutExtension(anchor_mask_files.at(best_overlap_index)) << "\n";
         else
           logfile << "No_overlap\n";
 
         ++c;
       }
 
       mitk::FiberBundle::Pointer out_fib = mitk::FiberBundle::New();
       out_fib = out_fib->AddBundles(input_candidates);
-      out_fib->ColorFibersByFiberWeights(false, true);
+//      out_fib->ColorFibersByFiberWeights(false, true);
       mitk::IOUtil::Save(out_fib, out_folder + "AllCandidates.fib");
     }
     else
     {
       MITK_INFO << "RMSE: " << setprecision(5) << rmse;
       //    fitter->SetPeakImage(peak_image);
 
       // Iteratively add candidate bundles in a greedy manner
       while (!input_candidates.empty())
       {
         double next_rmse = rmse;
         double num_peaks = 0;
         mitk::FiberBundle::Pointer best_candidate = nullptr;
         PeakImgType::Pointer best_candidate_peak_image = nullptr;
 
         for (int i=0; i<(int)input_candidates.size(); ++i)
         {
           // WHY NECESSARY AGAIN??
           itk::FitFibersToImageFilter::Pointer fitter = itk::FitFibersToImageFilter::New();
           fitter->SetLambda(lambda);
           fitter->SetFilterOutliers(filter_outliers);
           fitter->SetVerbose(false);
           fitter->SetPeakImage(peak_image);
           fitter->SetResampleFibers(false);
           fitter->SetMaskImage(mask);
           // ******************************
           fitter->SetTractograms({input_candidates.at(i)});
 
           std::streambuf *old = cout.rdbuf(); // <-- save
           std::stringstream ss;
           std::cout.rdbuf (ss.rdbuf());       // <-- redirect
           fitter->Update();
           std::cout.rdbuf (old);              // <-- restore
 
           double candidate_rmse = fitter->GetRMSE();
 
           if (candidate_rmse<next_rmse)
           {
             next_rmse = candidate_rmse;
             num_peaks = fitter->GetNumCoveredDirections();
             best_candidate = fitter->GetTractograms().at(0);
             best_candidate_peak_image = fitter->GetUnderexplainedImage();
           }
         }
 
         if (best_candidate.IsNull())
           break;
 
         //      fitter->SetPeakImage(peak_image);
         peak_image = best_candidate_peak_image;
 
         int i=0;
         std::vector< mitk::FiberBundle::Pointer > remaining_candidates;
         std::vector< std::string > remaining_candidate_files;
         for (auto fib : input_candidates)
         {
           if (fib!=best_candidate)
           {
             remaining_candidates.push_back(fib);
             remaining_candidate_files.push_back(candidate_tract_files.at(i));
           }
           else
             name = ist::GetFilenameWithoutExtension(candidate_tract_files.at(i));
           ++i;
         }
         input_candidates = remaining_candidates;
         candidate_tract_files = remaining_candidate_files;
 
         iteration++;
         std::streambuf *old = cout.rdbuf(); // <-- save
         std::stringstream ss;
         std::cout.rdbuf (ss.rdbuf());       // <-- redirect
         // Save winning candidate
         mitk::IOUtil::Save(best_candidate, out_folder + boost::lexical_cast<std::string>(iteration) + "_" + name + ".fib");
         peak_image_writer->SetInput(peak_image);
         peak_image_writer->SetFileName(out_folder + boost::lexical_cast<std::string>(iteration) + "_" + name + ".nrrd");
         peak_image_writer->Update();
 
         // Calculate best overlap with reference masks for evaluation purposes
         float best_overlap = 0;
         int best_overlap_index = -1;
         i = 0;
         for (auto ref_mask : reference_masks)
         {
           float overlap = best_candidate->GetOverlap(ref_mask, false);
           if (overlap>best_overlap)
           {
             best_overlap = overlap;
             best_overlap_index = i;
           }
           ++i;
         }
         std::cout.rdbuf (old);              // <-- restore
 
         logfile << "RMSE: " << setprecision(5) << rmse << " " << name << " " << num_peaks << "\n";
         if (best_overlap_index>=0)
           logfile << "Best_overlap: " << setprecision(5) << best_overlap << " " << ist::GetFilenameWithoutExtension(anchor_mask_files.at(best_overlap_index)) << "\n";
         else
           logfile << "No_overlap\n";
       }
     }
 
     clock.Stop();
     int h = clock.GetTotal()/3600;
     int m = ((int)clock.GetTotal()%3600)/60;
     int s = (int)clock.GetTotal()%60;
     MITK_INFO << "Plausibility estimation took " << h << "h, " << m << "m and " << s << "s";
     logfile.close();
   }
   catch (itk::ExceptionObject e)
   {
     std::cout << e;
     return EXIT_FAILURE;
   }
   catch (std::exception e)
   {
     std::cout << e.what();
     return EXIT_FAILURE;
   }
   catch (...)
   {
     std::cout << "ERROR!?!";
     return EXIT_FAILURE;
   }
   return EXIT_SUCCESS;
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/ExtractAnchorTracts.cpp b/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/ExtractAnchorTracts.cpp
index 81440ae729..c67164b7d1 100755
--- a/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/ExtractAnchorTracts.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/cmdapps/TractographyEvaluation/ExtractAnchorTracts.cpp
@@ -1,284 +1,277 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include <mitkBaseData.h>
 #include <mitkImageCast.h>
 #include <mitkImageToItk.h>
 #include <metaCommand.h>
 #include <mitkCommandLineParser.h>
 #include <usAny.h>
 #include <mitkIOUtil.h>
 #include <boost/lexical_cast.hpp>
 #include <itksys/SystemTools.hxx>
 #include <itkDirectory.h>
 #include <mitkFiberBundle.h>
 #include <vtkTransformPolyDataFilter.h>
 #include <fstream>
 #include <chrono>
 #include <boost/progress.hpp>
 #include <itkFiberExtractionFilter.h>
 
 typedef itksys::SystemTools ist;
 typedef itk::Image<unsigned char, 3>    ItkFloatImgType;
 typedef std::tuple< ItkFloatImgType::Pointer, std::string > MaskType;
 
 void CreateFolderStructure(const std::string& path)
 {
   if (ist::PathExists(path))
     ist::RemoveADirectory(path);
 
   ist::MakeDirectory(path);
   ist::MakeDirectory(path + "/anchor_tracts/");
   ist::MakeDirectory(path + "/candidate_tracts/");
-  ist::MakeDirectory(path + "/implausible_tracts/");
   ist::MakeDirectory(path + "/skipped_masks/");
 }
 
 ItkFloatImgType::Pointer LoadItkImage(const std::string& filename)
 {
   mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(mitk::IOUtil::Load(filename)[0].GetPointer());
   ItkFloatImgType::Pointer itkMask = ItkFloatImgType::New();
   mitk::CastToItkImage(img, itkMask);
   return itkMask;
 }
 
 std::vector< MaskType > get_file_list(const std::string& path, float anchor_fraction, const std::string& skipped_path, int random_seed)
 {
   if (anchor_fraction<0)
     anchor_fraction = 0;
   else if (anchor_fraction>1.0)
     anchor_fraction = 1.0;
 
   std::chrono::milliseconds ms = std::chrono::duration_cast< std::chrono::milliseconds >(std::chrono::system_clock::now().time_since_epoch());
   if (random_seed<0)
     std::srand(ms.count());
   else
     std::srand(random_seed);
   MITK_INFO << "random_seed: " << random_seed;
 
   std::vector< MaskType > mask_list;
 
   itk::Directory::Pointer dir = itk::Directory::New();
 
   int skipped = 0;
   if (dir->Load(path.c_str()))
   {
     int n = dir->GetNumberOfFiles();
     int num_images = 0;
 
     std::vector< int > im_indices;
     for (int r = 0; r < n; r++)
     {
       const char *filename = dir->GetFile(r);
       std::string ext = ist::GetFilenameExtension(filename);
       if (ext==".nii" || ext==".nii.gz" || ext==".nrrd")
       {
         ++num_images;
         im_indices.push_back(r);
       }
     }
 
     int skipping_num = num_images * (1.0 - anchor_fraction);
     std::random_shuffle(im_indices.begin(), im_indices.end());
     MITK_INFO << "Skipping " << skipping_num << " images";
     MITK_INFO << "Number of anchors: " << num_images-skipping_num;
 
     int c = -1;
     for (int r : im_indices)
     {
       c++;
       const char *filename = dir->GetFile(r);
 
       if (c<skipping_num && (skipping_num==num_images || ist::GetFilenameWithoutExtension(filename)!="CC"))
       {
         MITK_INFO << "Skipping " << ist::GetFilenameWithoutExtension(filename);
         ist::CopyAFile(path + '/' + filename, skipped_path + ist::GetFilenameName(filename));
         skipped++;
         continue;
       }
 
       MITK_INFO << "Loading " << ist::GetFilenameWithoutExtension(filename);
       std::streambuf *old = cout.rdbuf(); // <-- save
       std::stringstream ss;
       std::cout.rdbuf (ss.rdbuf());       // <-- redirect
       MaskType m(LoadItkImage(path + '/' + filename), ist::GetFilenameName(filename));
       mask_list.push_back(m);
       std::cout.rdbuf (old);              // <-- restore
     }
   }
 
   return mask_list;
 }
 
 mitk::FiberBundle::Pointer TransformToMRtrixSpace(mitk::FiberBundle::Pointer fib)
 {
   mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New();
   vtkSmartPointer< vtkMatrix4x4 > matrix = vtkSmartPointer< vtkMatrix4x4 >::New();
   matrix->Identity();
   matrix->SetElement(0,0,-matrix->GetElement(0,0));
   matrix->SetElement(1,1,-matrix->GetElement(1,1));
   geometry->SetIndexToWorldTransformByVtkMatrix(matrix);
 
   vtkSmartPointer<vtkTransformPolyDataFilter> transformFilter = vtkSmartPointer<vtkTransformPolyDataFilter>::New();
   transformFilter->SetInputData(fib->GetFiberPolyData());
   transformFilter->SetTransform(geometry->GetVtkTransform());
   transformFilter->Update();
   mitk::FiberBundle::Pointer transformed_fib = mitk::FiberBundle::New(transformFilter->GetOutput());
   return transformed_fib;
 }
 
 /*!
 \brief
 */
 int main(int argc, char* argv[])
 {
   mitkCommandLineParser parser;
 
   parser.setTitle("Extract Overlapping Tracts");
   parser.setCategory("Fiber Tracking Evaluation");
   parser.setDescription("");
   parser.setContributor("MIC");
 
   parser.setArgumentPrefix("--", "-");
   parser.addArgument("input", "i", mitkCommandLineParser::InputFile, "Input:", "input tractogram (.fib, vtk ascii file format)", us::Any(), false);
   parser.addArgument("out", "o", mitkCommandLineParser::OutputDirectory, "Output:", "output folder", us::Any(), false);
   parser.addArgument("reference_mask_folder", "m", mitkCommandLineParser::String, "Reference Mask Folder:", "reference masks of known bundles", us::Any(), false);
   parser.addArgument("gray_matter_mask", "gm", mitkCommandLineParser::String, "GM mask:", "remove fibers not ending in the gray matter");
   parser.addArgument("anchor_fraction", "", mitkCommandLineParser::Float, "Anchor fraction:", "Fraction of tracts used as anchors", 0.5);
   parser.addArgument("overlap", "", mitkCommandLineParser::Float, "Overlap threshold:", "Overlap threshold used to identify the anchor tracts", 0.8);
   parser.addArgument("subsample", "", mitkCommandLineParser::Float, "Subsampling factor:", "Only use specified fraction of input fibers for the analysis", 1.0);
   parser.addArgument("random_seed", "", mitkCommandLineParser::Int, ":", "", -1);
 
   std::map<std::string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
   if (parsedArgs.size()==0)
     return EXIT_FAILURE;
 
   std::string fibFile = us::any_cast<std::string>(parsedArgs["input"]);
   std::string reference_mask_folder = us::any_cast<std::string>(parsedArgs["reference_mask_folder"]);
   std::string out_folder = us::any_cast<std::string>(parsedArgs["out"]);
 
   std::string gray_matter_mask = "";
   if (parsedArgs.count("gray_matter_mask"))
     gray_matter_mask = us::any_cast<std::string>(parsedArgs["gray_matter_mask"]);
 
   float anchor_fraction = 0.5;
   if (parsedArgs.count("anchor_fraction"))
     anchor_fraction = us::any_cast<float>(parsedArgs["anchor_fraction"]);
 
   int random_seed = -1;
   if (parsedArgs.count("random_seed"))
     random_seed = us::any_cast<int>(parsedArgs["random_seed"]);
 
   float overlap = 0.8;
   if (parsedArgs.count("overlap"))
     overlap = us::any_cast<float>(parsedArgs["overlap"]);
 
   float subsample = 1.0;
   if (parsedArgs.count("subsample"))
     subsample = us::any_cast<float>(parsedArgs["subsample"]);
 
   try
   {
     CreateFolderStructure(out_folder);
     std::vector< MaskType > known_tract_masks = get_file_list(reference_mask_folder, anchor_fraction, out_folder + "/skipped_masks/", random_seed);
     mitk::FiberBundle::Pointer inputTractogram = dynamic_cast<mitk::FiberBundle*>(mitk::IOUtil::Load(fibFile)[0].GetPointer());
 
     if (gray_matter_mask.compare("")!=0)
     {
       MITK_INFO << "Removing fibers not ending inside of GM";
       std::streambuf *old = cout.rdbuf(); // <-- save
       std::stringstream ss;
       std::cout.rdbuf (ss.rdbuf());       // <-- redirect
       ItkFloatImgType::Pointer gm_image = LoadItkImage(gray_matter_mask);
       std::cout.rdbuf (old);              // <-- restore
 
       itk::FiberExtractionFilter<unsigned char>::Pointer extractor = itk::FiberExtractionFilter<unsigned char>::New();
       extractor->SetInputFiberBundle(inputTractogram);
       extractor->SetRoiImages({gm_image});
       extractor->SetBothEnds(true);
+      extractor->SetNoNegatives(true);
       extractor->SetMode(itk::FiberExtractionFilter<unsigned char>::MODE::ENDPOINTS);
       extractor->Update();
-
-      mitk::FiberBundle::Pointer not_gm_fibers = extractor->GetNegatives().at(0);
-
-      old = cout.rdbuf(); // <-- save
-      std::cout.rdbuf (ss.rdbuf());       // <-- redirect
-      mitk::IOUtil::Save(not_gm_fibers, out_folder + "/implausible_tracts/no_gm_endings.trk");
       inputTractogram = extractor->GetPositives().at(0);
-      std::cout.rdbuf (old);              // <-- restore
     }
 
     std::srand(0);
     if (subsample<1.0)
       inputTractogram = inputTractogram->SubsampleFibers(subsample);
 
     mitk::FiberBundle::Pointer anchor_tractogram = mitk::FiberBundle::New(nullptr);
     mitk::FiberBundle::Pointer candidate_tractogram = mitk::FiberBundle::New(nullptr);
     if (!known_tract_masks.empty())
     {
       MITK_INFO << "Find known tracts via overlap match";
       std::vector< ItkFloatImgType::Pointer > mask_images;
       for (auto mask : known_tract_masks)
         mask_images.push_back(std::get<0>(mask));
 
       std::vector< ItkFloatImgType* > roi_images2;
       for (auto roi : mask_images)
         roi_images2.push_back(roi);
 
       itk::FiberExtractionFilter<unsigned char>::Pointer extractor = itk::FiberExtractionFilter<unsigned char>::New();
       extractor->SetInputFiberBundle(inputTractogram);
       extractor->SetRoiImages(roi_images2);
       extractor->SetOverlapFraction(overlap);
       extractor->SetMode(itk::FiberExtractionFilter<unsigned char>::MODE::OVERLAP);
       extractor->Update();
       std::vector< mitk::FiberBundle::Pointer > positives = extractor->GetPositives();
       candidate_tractogram = extractor->GetNegatives().at(0);
 
       for ( unsigned int i=0; i<known_tract_masks.size(); ++i )
       {
         std::streambuf *old = cout.rdbuf(); // <-- save
         std::stringstream ss;
         std::cout.rdbuf (ss.rdbuf());       // <-- redirect
 
         std::string mask_name = std::get<1>(known_tract_masks.at(i));
         mitk::IOUtil::Save(positives.at(i), out_folder + "/anchor_tracts/" + mask_name + ".trk");
 
         std::cout.rdbuf (old);              // <-- restore
       }
       anchor_tractogram = anchor_tractogram->AddBundles(positives);
     }
 
     mitk::IOUtil::Save(anchor_tractogram, out_folder + "/anchor_tracts/anchor_tractogram.trk");
     mitk::IOUtil::Save(candidate_tractogram, out_folder + "/candidate_tracts/candidate_tractogram.trk");
     mitk::IOUtil::Save(inputTractogram, out_folder + "/filtered_tractogram.trk");
   }
   catch (itk::ExceptionObject e)
   {
     std::cout << e;
     return EXIT_FAILURE;
   }
   catch (std::exception e)
   {
     std::cout << e.what();
     return EXIT_FAILURE;
   }
   catch (...)
   {
     std::cout << "ERROR!?!";
     return EXIT_FAILURE;
   }
   return EXIT_SUCCESS;
 }