diff --git a/Modules/Segmentation/Algorithms/mitkFeatureBasedEdgeDetectionFilter.cpp b/Modules/Segmentation/Algorithms/mitkFeatureBasedEdgeDetectionFilter.cpp
index 0e18d63be6..043596f1f6 100644
--- a/Modules/Segmentation/Algorithms/mitkFeatureBasedEdgeDetectionFilter.cpp
+++ b/Modules/Segmentation/Algorithms/mitkFeatureBasedEdgeDetectionFilter.cpp
@@ -1,126 +1,139 @@
 /*===================================================================
 
 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 "mitkFeatureBasedEdgeDetectionFilter.h"
 
 #include <itkBinaryThresholdImageFilter.h>
 
 #include <SegmentationUtilities/MorphologicalOperations/mitkMorphologicalOperations.h>
 #include <mitkImageAccessByItk.h>
 #include <mitkImageStatisticsCalculator.h>
 #include <mitkImage.h>
 #include <mitkITKImageImport.h>
 #include <mitkMaskImageFilter.h>
 #include <mitkImageToPointCloudFilter.h>
 #include <mitkUnstructuredGrid.h>
 
 mitk::FeatureBasedEdgeDetectionFilter::FeatureBasedEdgeDetectionFilter()
 {
   m_PointGrid = mitk::UnstructuredGrid::New();
   m_SegmentationMask = mitk::Image::New();
   m_thresholdImage = mitk::Image::New();
+  m_morphThreshold = mitk::Image::New();
+  m_EdgeImage = mitk::Image::New();
+  m_EdgePoints = mitk::Image::New();
+  m_MaskedImage = mitk::Image::New();
 
   this->SetNumberOfRequiredInputs(1);
   this->SetNumberOfRequiredOutputs(1);
 
   this->SetNthOutput(0, m_PointGrid);
 }
 
 mitk::FeatureBasedEdgeDetectionFilter::~FeatureBasedEdgeDetectionFilter(){}
 
 void mitk::FeatureBasedEdgeDetectionFilter::GenerateData()
 {
   mitk::Image::ConstPointer image = ImageToUnstructuredGridFilter::GetInput();
   mitk::Image::Pointer ncImage = image->Clone();
 
   //statistics
   mitk::ImageStatisticsCalculator::Pointer statCalc = mitk::ImageStatisticsCalculator::New();
   statCalc->SetImage(image);
   statCalc->SetMaskingModeToImage();
   if(m_SegmentationMask->IsEmpty())
   {
     MITK_WARN << "Please set a segmentation mask first" << std::endl;
     return;
   }
   statCalc->SetImageMask(m_SegmentationMask);
   statCalc->ComputeStatistics();
 
   mitk::ImageStatisticsCalculator::Statistics stats = statCalc->GetStatistics();
   double mean = stats.GetMean();
   double stdDev = stats.GetSigma();
 
   double upperThreshold = mean + stdDev;
   double lowerThreshold = mean - stdDev;
 
   //thresholding
   AccessByItk_2(ncImage.GetPointer(), ITKThresholding, lowerThreshold, upperThreshold)
 
+  m_morphThreshold = m_thresholdImage->Clone();
+
   //fill holes
-  mitk::MorphologicalOperations::FillHoles(m_thresholdImage);
+  mitk::MorphologicalOperations::FillHoles(m_morphThreshold);
+
+//  mitk::MorphologicalOperations::Closing(m_morphThreshold,1,mitk::MorphologicalOperations::Ball);
+//  mitk::MorphologicalOperations::Opening(m_morphThreshold,1,mitk::MorphologicalOperations::Ball);
 
   //masking
   mitk::MaskImageFilter::Pointer maskFilter = mitk::MaskImageFilter::New();
   maskFilter->SetInput(image);
-  maskFilter->SetMask(m_thresholdImage);
+  maskFilter->SetMask(m_morphThreshold);
   maskFilter->OverrideOutsideValueOn();
   maskFilter->SetOutsideValue(0);
   try
   {
     maskFilter->Update();
   }
   catch(itk::ExceptionObject& excpt)
   {
     MITK_ERROR << excpt.GetDescription();
     return;
   }
 
+  m_MaskedImage = maskFilter->GetOutput()->Clone();
   mitk::Image::Pointer resultImage = maskFilter->GetOutput();
 
   //imagetopointcloudfilter
   mitk::ImageToPointCloudFilter::Pointer pclFilter = mitk::ImageToPointCloudFilter::New();
   pclFilter->SetInput(resultImage);
   pclFilter->Update();
 
-  m_PointGrid = pclFilter->GetOutput();
+  m_EdgeImage = pclFilter->GetEdgeImage();
+  m_EdgePoints = pclFilter->GetEdgePoints();
+
+  m_PointGrid->SetVtkUnstructuredGrid( pclFilter->GetOutput()->GetVtkUnstructuredGrid() );
 }
 
 template <typename TPixel, unsigned int VImageDimension>
 void mitk::FeatureBasedEdgeDetectionFilter::ITKThresholding( itk::Image<TPixel, VImageDimension>* originalImage, double lower, double upper)
 {
   typedef itk::Image<TPixel, VImageDimension> ImageType;
   typedef itk::Image<unsigned char, VImageDimension> SegmentationType;
   typedef itk::BinaryThresholdImageFilter<ImageType, SegmentationType> ThresholdFilterType;
 
   typename ThresholdFilterType::Pointer filter = ThresholdFilterType::New();
   filter->SetInput(originalImage);
   filter->SetLowerThreshold(lower);
   filter->SetUpperThreshold(upper);
   filter->SetInsideValue(1);
   filter->SetOutsideValue(0);
   filter->Update();
 
   m_thresholdImage = mitk::ImportItkImage(filter->GetOutput())->Clone();
 }
 
 void mitk::FeatureBasedEdgeDetectionFilter::SetSegmentationMask(mitk::Image::Pointer segmentation)
 {
   this->m_SegmentationMask = segmentation;
 }
 
 void mitk::FeatureBasedEdgeDetectionFilter::GenerateOutputInformation()
 {
   Superclass::GenerateOutputInformation();
 }
diff --git a/Modules/Segmentation/Algorithms/mitkFeatureBasedEdgeDetectionFilter.h b/Modules/Segmentation/Algorithms/mitkFeatureBasedEdgeDetectionFilter.h
index edc5de39e0..5fbbaea82b 100644
--- a/Modules/Segmentation/Algorithms/mitkFeatureBasedEdgeDetectionFilter.h
+++ b/Modules/Segmentation/Algorithms/mitkFeatureBasedEdgeDetectionFilter.h
@@ -1,65 +1,77 @@
 /*===================================================================
 
 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 mitkFeatureBasedEdgeDetectionFilter_h_Included
 #define mitkFeatureBasedEdgeDetectionFilter_h_Included
 
 #include <MitkSegmentationExports.h>
 #include <mitkImageToUnstructuredGridFilter.h>
 #include <mitkUnstructuredGrid.h>
 
 #include <itkImage.h>
 #include <itkImageIterator.h>
 
 namespace mitk
 {
 
-class MitkSegmentation_EXPORT FeatureBasedEdgeDetectionFilter:
+class MITKSEGMENTATION_EXPORT FeatureBasedEdgeDetectionFilter:
     public ImageToUnstructuredGridFilter
 {
 
 public:
 
   mitkClassMacro( FeatureBasedEdgeDetectionFilter, ImageToUnstructuredGridFilter)
 
   itkFactorylessNewMacro(Self)
   itkCloneMacro(Self)
 
+  itkGetMacro(EdgeImage,mitk::Image::Pointer)
+  itkGetMacro(EdgePoints,mitk::Image::Pointer)
+  itkGetMacro(SegmentationMask, mitk::Image::Pointer)
+  itkGetMacro(thresholdImage, mitk::Image::Pointer)
+  itkGetMacro(morphThreshold, mitk::Image::Pointer)
+  itkGetMacro(MaskedImage, mitk::Image::Pointer)
+
   void SetSegmentationMask(mitk::Image::Pointer);
 
 protected:
 
   virtual void GenerateData();
 
   virtual void GenerateOutputInformation();
 
   FeatureBasedEdgeDetectionFilter();
 
   virtual ~FeatureBasedEdgeDetectionFilter();
 
   template <typename TPixel, unsigned int VImageDimension>
   void ITKThresholding( itk::Image<TPixel, VImageDimension>* originalImage, double lower, double upper);
 
 private:
 
   mitk::UnstructuredGrid::Pointer m_PointGrid;
   mitk::Image::Pointer m_SegmentationMask;
   mitk::Image::Pointer m_thresholdImage;
+  mitk::Image::Pointer m_morphThreshold;
+  mitk::Image::Pointer m_MaskedImage;
+
+  mitk::Image::Pointer m_EdgeImage;
+  mitk::Image::Pointer m_EdgePoints;
 
 };
 
 }
 #endif
diff --git a/Modules/SurfaceInterpolation/mitkImageToPointCloudFilter.cpp b/Modules/SurfaceInterpolation/mitkImageToPointCloudFilter.cpp
index d18bfff820..a24aa48843 100644
--- a/Modules/SurfaceInterpolation/mitkImageToPointCloudFilter.cpp
+++ b/Modules/SurfaceInterpolation/mitkImageToPointCloudFilter.cpp
@@ -1,176 +1,180 @@
 /*===================================================================
 
 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 "mitkImageToPointCloudFilter.h"
 
 #include <itkImageIterator.h>
 #include <itkImageRegionIterator.h>
 #include <vtkPolyLine.h>
 #include <vtkPolyVertex.h>
 #include <vtkUnstructuredGrid.h>
 
 #include <mitkDataNode.h>
 #include <mitkImageAccessByItk.h>
 #include <mitkImageCast.h>
 #include <mitkITKImageImport.h>
 #include <mitkImageStatisticsCalculator.h>
 #include <vtkCellArray.h>
 
 mitk::ImageToPointCloudFilter::ImageToPointCloudFilter():
   m_NumberOfExtractedPoints(0)
 {
   m_PointGrid = mitk::UnstructuredGrid::New();
-  m_Method = DetectConstant(0);
+  m_Method = DetectConstant(1);
   m_EdgeImage = mitk::Image::New();
   m_EdgePoints = mitk::Image::New();
 
   this->SetNumberOfRequiredInputs(1);
   this->SetNumberOfRequiredOutputs(1);
 
   this->SetNthOutput(0, m_PointGrid);
 }
 
 mitk::ImageToPointCloudFilter::~ImageToPointCloudFilter(){}
 
 void mitk::ImageToPointCloudFilter::GenerateData()
 {
   mitk::Image::ConstPointer image = ImageToUnstructuredGridFilter::GetInput();
   m_Geometry = image->GetGeometry();
 
   if ( image.IsNull() )
   {
     MITK_ERROR << "mitk::ImageToContourFilter: No input available. "
                   "Please set the input!" << std::endl;
     return;
   }
 
   switch(m_Method)
   {
   case 0:
     this->LaplacianStdDev(image, 2);
     break;
 
   case 1:
     this->LaplacianStdDev(image, 3);
     break;
 
+  case 2:
+    this->LaplacianStdDev(image, 4);
+    break;
+
   default:
-    this->LaplacianStdDev(image, 2);
+    this->LaplacianStdDev(image, 3);
     break;
   }
 }
 
 void mitk::ImageToPointCloudFilter::
                     LaplacianStdDev(mitk::Image::ConstPointer image, int amount)
 {
   mitk::Image::Pointer notConstImage = image->Clone();
   AccessByItk_1(notConstImage.GetPointer(), StdDeviations, amount)
 }
 
 template<typename TPixel, unsigned int VImageDimension>
 void mitk::ImageToPointCloudFilter::
            StdDeviations(itk::Image<TPixel, VImageDimension>* image, int amount)
 {
   typedef itk::Image<TPixel, VImageDimension> InputImageType;
   typedef itk::CastImageFilter< InputImageType, FloatImageType >
           ImagePTypeToFloatPTypeCasterType;
   typename LaplacianFilterType::Pointer lapFilter = LaplacianFilterType::New();
 
   typename ImagePTypeToFloatPTypeCasterType::Pointer caster =
            ImagePTypeToFloatPTypeCasterType::New();
   caster->SetInput( image );
   caster->Update();
   FloatImageType::Pointer fImage = caster->GetOutput();
 
   lapFilter->SetInput(fImage);
   lapFilter->UpdateLargestPossibleRegion();
   m_EdgeImage = mitk::ImportItkImage(lapFilter->GetOutput())->Clone();
 
   mitk::ImageStatisticsCalculator::Pointer statCalc =
                                          mitk::ImageStatisticsCalculator::New();
   statCalc->SetImage(m_EdgeImage);
   statCalc->ComputeStatistics();
   mitk::ImageStatisticsCalculator::Statistics stats = statCalc->GetStatistics();
   double mean = stats.GetMean();
   double stdDev = stats.GetSigma();
 
   double upperThreshold = mean + stdDev * amount;
   double lowerThreshold = mean - stdDev * amount;
 
   typename itk::ImageRegionIterator<FloatImageType> it(lapFilter->GetOutput(),
                                  lapFilter->GetOutput()->GetRequestedRegion());
 
   vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
 
   double greatX=0, greatY=0, greatZ=0;
 
   it.GoToBegin();
   while( !it.IsAtEnd() )
   {
     if(it.Get() > lowerThreshold && it.Get() < upperThreshold)
     {
       it.Set(0);
     }
     else
     {
       it.Set(1);
 
       mitk::Point3D imagePoint;
       mitk::Point3D worldPoint;
 
       imagePoint[0] = it.GetIndex()[0];
       imagePoint[1] = it.GetIndex()[1];
       imagePoint[2] = it.GetIndex()[2];
 
       m_Geometry->IndexToWorld(imagePoint, worldPoint);
 
       if(worldPoint[0]>greatX)
         greatX=worldPoint[0];
       if(worldPoint[1]>greatY)
         greatY=worldPoint[1];
       if(worldPoint[2]>greatZ)
         greatZ=worldPoint[2];
 
       points->InsertNextPoint(worldPoint[0],worldPoint[1],worldPoint[2]);
       m_NumberOfExtractedPoints++;
     }
     ++it;
   }
 
   m_EdgePoints = mitk::ImportItkImage(lapFilter->GetOutput())->Clone();
 
   vtkSmartPointer<vtkPolyVertex> verts = vtkSmartPointer<vtkPolyVertex>::New();
 
   verts->GetPointIds()->SetNumberOfIds(m_NumberOfExtractedPoints);
   for(int i=0; i<m_NumberOfExtractedPoints; i++)
   {
     verts->GetPointIds()->SetId(i,i);
   }
 
   vtkSmartPointer<vtkUnstructuredGrid> uGrid = vtkSmartPointer<vtkUnstructuredGrid>::New();
   uGrid->Allocate(1);
 
   uGrid->InsertNextCell(verts->GetCellType(), verts->GetPointIds());
   uGrid->SetPoints(points);
 
   m_PointGrid->SetVtkUnstructuredGrid(uGrid);
 }
 
 
 void mitk::ImageToPointCloudFilter::GenerateOutputInformation()
 {
   Superclass::GenerateOutputInformation();
 }
diff --git a/Modules/SurfaceInterpolation/mitkImageToPointCloudFilter.h b/Modules/SurfaceInterpolation/mitkImageToPointCloudFilter.h
index 01f33b8d66..1c6bc114b2 100644
--- a/Modules/SurfaceInterpolation/mitkImageToPointCloudFilter.h
+++ b/Modules/SurfaceInterpolation/mitkImageToPointCloudFilter.h
@@ -1,94 +1,93 @@
 /*===================================================================
 
 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 mitkImageToPointCloudFilter_h_Included
 #define mitkImageToPointCloudFilter_h_Included
 
 #include <MitkSurfaceInterpolationExports.h>
 #include <mitkImageToUnstructuredGridFilter.h>
 #include <mitkUnstructuredGrid.h>
 
 #include <itkCastImageFilter.h>
 #include <itkLaplacianImageFilter.h>
 
 namespace mitk
 {
 
-enum MitkSurfaceInterpolation_EXPORT DetectConstant
+enum MITKSURFACEINTERPOLATION_EXPORT DetectConstant
 {
-  LAPLACIAN_STD_DEV2,
-  LAPLACIAN_STD_DEV3,
-  CANNY_EDGE,
-  THRESHOLD
+  LAPLACIAN_STD_DEV2 = 0,
+  LAPLACIAN_STD_DEV3 = 1,
+  LAPLACIAN_STD_DEV4 = 2
 };
 
-class MitkSurfaceInterpolation_EXPORT ImageToPointCloudFilter:
+class MITKSURFACEINTERPOLATION_EXPORT ImageToPointCloudFilter:
     public ImageToUnstructuredGridFilter
 {
 
 public:
 
   mitkClassMacro( ImageToPointCloudFilter, ImageToUnstructuredGridFilter)
 
   itkFactorylessNewMacro(Self)
   itkCloneMacro(Self)
 
   typedef itk::Image<short, 3> ImageType;
   typedef itk::Image<double, 3>  DoubleImageType;
   typedef itk::Image<double, 3> FloatImageType;
   typedef itk::LaplacianImageFilter< FloatImageType, FloatImageType >
           LaplacianFilterType;
   typedef DetectConstant DetectionMethod;
 
   itkGetMacro(Method,DetectionMethod)
   itkGetMacro(EdgeImage,mitk::Image::Pointer)
   itkGetMacro(EdgePoints,mitk::Image::Pointer)
   itkGetMacro(NumberOfExtractedPoints,int)
 
   itkSetMacro(Method,DetectionMethod)
 
 protected:
 
   virtual void GenerateData();
 
   virtual void GenerateOutputInformation();
 
   ImageToPointCloudFilter();
 
   virtual ~ImageToPointCloudFilter();
 
 private:
 
   template<typename TPixel, unsigned int VImageDimension>
   void StdDeviations(itk::Image<TPixel, VImageDimension>* image, int amount);
 
   void LaplacianStdDev(Image::ConstPointer image, int amount);
 
   mitk::UnstructuredGrid::Pointer m_PointGrid;
 
   mitk::BaseGeometry* m_Geometry;
 
   mitk::Image::Pointer m_EdgeImage;
   mitk::Image::Pointer m_EdgePoints;
 
   int m_NumberOfExtractedPoints;
 
   DetectionMethod m_Method;
 
 };
 
 }
 #endif