diff --git a/Modules/Classification/CLActiveLearning/include/mitkActiveLearningSuggestRegionFilter.h b/Modules/Classification/CLActiveLearning/include/mitkActiveLearningSuggestRegionFilter.h
index e8fef52cc6..00282a18be 100644
--- a/Modules/Classification/CLActiveLearning/include/mitkActiveLearningSuggestRegionFilter.h
+++ b/Modules/Classification/CLActiveLearning/include/mitkActiveLearningSuggestRegionFilter.h
@@ -1,155 +1,167 @@
 /*===================================================================
 
 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 mitkActiveLearningSuggestRegionFilter_h
 #define mitkActiveLearningSuggestRegionFilter_h
 
 #include <MitkCLActiveLearningExports.h>
 
 // ITK
 #include <itkVectorImage.h>
 #include <itkIndex.h>
 #include <itkImage.h>
 #include <itkImageToImageFilter.h>
 #include <itkThresholdImageFilter.h>
 #include <itkBinaryThresholdImageFilter.h>
 #include <itkIndent.h>
 #include <itkConnectedComponentImageFilter.h>
 #include <itkDiscreteGaussianImageFilter.h>
+#include <itkBinaryMorphologicalOpeningImageFilter.h>
+#include <itkBinaryBallStructuringElement.h>
 
 // MITK
 #include <mitkCommon.h>
 #include <mitkSelectHighestUncertaintyRegionFilter.h>
 
 namespace mitk
 {
     /** \class ActiveLearningSuggestRegionFilter
      * \brief Filter that takes an image of prediction uncertainties and outputs an image (mask) containing only the most uncertain region
      *
      * This is just a composite filter using itkThresholdImageFilter and mitkSelectHighestUncertaintyRegionFilter
      */
 
     template <typename InputImageType, typename OutputImageType>
     class MITKCLACTIVELEARNING_EXPORT ActiveLearningSuggestRegionFilter : public itk::ImageToImageFilter<InputImageType, OutputImageType>
     {
 
     public:
 
         typedef itk::ImageToImageFilter<InputImageType, OutputImageType> SuperClassName;
         mitkClassMacroItkParent(ActiveLearningSuggestRegionFilter, SuperClassName)
         itkNewMacro(Self)
         typedef typename InputImageType::PixelType InputImagePixelType;
         typedef typename OutputImageType::PixelType OutputImagePixelType;
 
         // We're not holding threshold as a member, so no set and get macro
         void SetThreshold(InputImagePixelType threshold)
         {
             if (m_ThresholdFilter->GetLowerThreshold() != threshold)
             {
                 m_ThresholdFilter->SetLowerThreshold(threshold);
                 this->Modified();
             }
         }
 
         InputImagePixelType GetThreshold() const
         {
             return m_ThresholdFilter->GetLowerThreshold();
         }
 
     protected:
 
         ActiveLearningSuggestRegionFilter()
         {
             m_GaussianFilter = itk::DiscreteGaussianImageFilter<InputImageType, InputImageType>::New();
             m_ThresholdFilter = itk::BinaryThresholdImageFilter<InputImageType, OutputImageType>::New();
             m_CCFilter = itk::ConnectedComponentImageFilter<OutputImageType, OutputImageType>::New();
             m_ThresholdOutputFilter = itk::BinaryThresholdImageFilter<OutputImageType, OutputImageType>::New();
+            m_OpeningFilter = itk::BinaryMorphologicalOpeningImageFilter<OutputImageType, OutputImageType, StructuringElementType>::New();
 
             m_ThresholdFilter->SetLowerThreshold(0.5);
             m_ThresholdFilter->SetOutsideValue(0);
             m_ThresholdFilter->SetInsideValue(1);
             m_ThresholdOutputFilter->SetOutsideValue(0);
             m_ThresholdOutputFilter->SetInsideValue(1);
         }
 
         ~ActiveLearningSuggestRegionFilter(){}
 
         virtual void GenerateData() override
         {
             // Let this filter's input be threshold filter's input
             auto input = InputImageType::New();
             input->Graft(const_cast<InputImageType*>(this->GetInput()));
 
             m_GaussianFilter->SetInput(input);
             m_GaussianFilter->Modified();
 
             m_ThresholdFilter->SetInput(m_GaussianFilter->GetOutput());
             m_ThresholdFilter->Modified();
 
+            StructuringElementType structuringElement;
+            structuringElement.SetRadius(5);
+            structuringElement.CreateStructuringElement();
+            m_OpeningFilter->SetKernel(structuringElement);
+            m_OpeningFilter->SetInput(m_ThresholdFilter->GetOutput());
+            m_OPeningFilter->Modified();
+
             // Run pipeline to get image with connected components
-            m_CCFilter->SetInput(m_ThresholdFilter->GetOutput());
+            m_CCFilter->SetInput(m_OpeningFilter->GetOutput());
             m_CCFilter->Update();
 
             // Find sum of uncertainties for all connected components
             int ccCount = static_cast<int>(m_CCFilter->GetObjectCount());
             std::map<OutputImagePixelType, InputImagePixelType> ccSize;
             for (int a=1; a<=ccCount; ++a) {ccSize[a] = 0.0;}
             auto inputIt = itk::ImageRegionConstIterator<InputImageType>(input, input->GetLargestPossibleRegion());
             auto outputIt = itk::ImageRegionConstIterator<OutputImageType>(m_CCFilter->GetOutput(), m_CCFilter->GetOutput()->GetLargestPossibleRegion());
             while (!outputIt.IsAtEnd())
             {
                 OutputImagePixelType ccVal = outputIt.Get();
                 InputImagePixelType pixelVal = inputIt.Get();
                 if (ccVal != 0) {ccSize[ccVal] += pixelVal;}
                 ++outputIt;
                 ++inputIt;
             }
 
             // Find component with largest sum
             typedef typename std::map<OutputImagePixelType, InputImagePixelType>::value_type PairType;
             auto maxComponent = std::max_element(ccSize.begin(), ccSize.end(), [](const PairType& lhs, const PairType& rhs){return lhs.second < rhs.second;});
 
             // Create mask
             m_ThresholdOutputFilter->SetLowerThreshold(maxComponent->first);
             m_ThresholdOutputFilter->SetUpperThreshold(maxComponent->first);
             m_ThresholdOutputFilter->SetInput(m_CCFilter->GetOutput());
             m_ThresholdOutputFilter->GraftOutput(this->GetOutput());
             m_ThresholdOutputFilter->Update();
             this->GraftOutput(m_ThresholdOutputFilter->GetOutput());
         }
 
 //        virtual void PrintSelf(std::ostream & os, itk::Indent indent) const
 //        {
 //            Superclass::PrintSelf(os, indent);
 //            m_ThresholdFilter->PrintSelf(os, indent);
 //            m_RegionFilter->PrintSelf(os, indent);
 //        }
 
     private:
 
         // ITK examples do this...
         ActiveLearningSuggestRegionFilter(const Self&);
         void operator=(const Self&);
 
         typename itk::DiscreteGaussianImageFilter<InputImageType, InputImageType>::Pointer m_GaussianFilter;
         typename itk::BinaryThresholdImageFilter<InputImageType, OutputImageType>::Pointer m_ThresholdFilter;
         typename itk::ConnectedComponentImageFilter<OutputImageType, OutputImageType>::Pointer m_CCFilter;
         typename itk::BinaryThresholdImageFilter<OutputImageType, OutputImageType>::Pointer m_ThresholdOutputFilter;
+        typedef itk::BinaryBallStructuringElement<OutputImageType, OutputImageDimension> StructuringElementType;
+        typename itk::BinaryMorphologicalOpeningImageFilter<OutputImageType, OutputImageType, StructuringElementType>::Pointer m_OpeningFilter;
 
     };
 
 }
 
 #endif