diff --git a/Modules/SurfaceInterpolation/mitkImageToPointCloudFilter.cpp b/Modules/SurfaceInterpolation/mitkImageToPointCloudFilter.cpp
index 5a1758771a..d18bfff820 100644
--- a/Modules/SurfaceInterpolation/mitkImageToPointCloudFilter.cpp
+++ b/Modules/SurfaceInterpolation/mitkImageToPointCloudFilter.cpp
@@ -1,168 +1,176 @@
 /*===================================================================
 
 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_PointSurface = mitk::Surface::New();
+  m_PointGrid = mitk::UnstructuredGrid::New();
   m_Method = DetectConstant(0);
   m_EdgeImage = mitk::Image::New();
   m_EdgePoints = mitk::Image::New();
 
   this->SetNumberOfRequiredInputs(1);
   this->SetNumberOfRequiredOutputs(1);
 
-  this->SetNthOutput(0, m_PointSurface);
+  this->SetNthOutput(0, m_PointGrid);
 }
 
 mitk::ImageToPointCloudFilter::~ImageToPointCloudFilter(){}
 
 void mitk::ImageToPointCloudFilter::GenerateData()
 {
-  mitk::Image::ConstPointer image = ImageToSurfaceFilter::GetInput();
+  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;
 
   default:
     this->LaplacianStdDev(image, 2);
     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;
   }
 
-  vtkSmartPointer<vtkPolyLine> polyLine = vtkSmartPointer<vtkPolyLine>::New();
-  polyLine->GetPointIds()->SetNumberOfIds(m_NumberOfExtractedPoints);
+  m_EdgePoints = mitk::ImportItkImage(lapFilter->GetOutput())->Clone();
+
+  vtkSmartPointer<vtkPolyVertex> verts = vtkSmartPointer<vtkPolyVertex>::New();
 
-  for(unsigned int i = 0; i < m_NumberOfExtractedPoints; i++)
+  verts->GetPointIds()->SetNumberOfIds(m_NumberOfExtractedPoints);
+  for(int i=0; i<m_NumberOfExtractedPoints; i++)
   {
-    polyLine->GetPointIds()->SetId(i,i);
+    verts->GetPointIds()->SetId(i,i);
   }
 
-  vtkSmartPointer<vtkCellArray> cells = vtkSmartPointer<vtkCellArray>::New();
-  cells->InsertNextCell(polyLine);
-
-  vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
-  polyData->SetPoints(points);
-  polyData->SetLines(cells);
+  vtkSmartPointer<vtkUnstructuredGrid> uGrid = vtkSmartPointer<vtkUnstructuredGrid>::New();
+  uGrid->Allocate(1);
 
-  m_EdgePoints = mitk::ImportItkImage(lapFilter->GetOutput())->Clone();
+  uGrid->InsertNextCell(verts->GetCellType(), verts->GetPointIds());
+  uGrid->SetPoints(points);
 
-  polyData->BuildCells();
-  polyData->BuildLinks();
-  m_PointSurface->SetVtkPolyData(polyData);
+  m_PointGrid->SetVtkUnstructuredGrid(uGrid);
 }
 
 
 void mitk::ImageToPointCloudFilter::GenerateOutputInformation()
 {
   Superclass::GenerateOutputInformation();
 }
diff --git a/Modules/SurfaceInterpolation/mitkImageToPointCloudFilter.h b/Modules/SurfaceInterpolation/mitkImageToPointCloudFilter.h
index 3583fb1427..01f33b8d66 100644
--- a/Modules/SurfaceInterpolation/mitkImageToPointCloudFilter.h
+++ b/Modules/SurfaceInterpolation/mitkImageToPointCloudFilter.h
@@ -1,93 +1,94 @@
 /*===================================================================
 
 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 <mitkImageToSurfaceFilter.h>
+#include <mitkImageToUnstructuredGridFilter.h>
+#include <mitkUnstructuredGrid.h>
 
 #include <itkCastImageFilter.h>
 #include <itkLaplacianImageFilter.h>
 
 namespace mitk
 {
 
 enum MitkSurfaceInterpolation_EXPORT DetectConstant
 {
   LAPLACIAN_STD_DEV2,
   LAPLACIAN_STD_DEV3,
   CANNY_EDGE,
   THRESHOLD
 };
 
 class MitkSurfaceInterpolation_EXPORT ImageToPointCloudFilter:
-    public ImageToSurfaceFilter
+    public ImageToUnstructuredGridFilter
 {
 
 public:
 
-  mitkClassMacro( ImageToPointCloudFilter, ImageToSurfaceFilter)
+  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::Surface::Pointer m_PointSurface;
+  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