diff --git a/Modules/SurfaceRegistration/include/MitkShapeComparisonManager.h b/Modules/SurfaceRegistration/include/MitkSurfaceRegistrationManager.h
similarity index 76%
rename from Modules/SurfaceRegistration/include/MitkShapeComparisonManager.h
rename to Modules/SurfaceRegistration/include/MitkSurfaceRegistrationManager.h
index ff369c6c27..3b6956c05a 100644
--- a/Modules/SurfaceRegistration/include/MitkShapeComparisonManager.h
+++ b/Modules/SurfaceRegistration/include/MitkSurfaceRegistrationManager.h
@@ -1,78 +1,82 @@
 /*===================================================================
 
 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 ShapeComparisonManager_h
-#define ShapeComparisonManager_h
+#ifndef mitkSurfaceRegistrationManager_h
+#define mitkSurfaceRegistrationManager_h
 
 #include "mitkSurface.h"
 #include <mitkWeakPointer.h>
 #include "mitkDataNode.h"
+#include <mitkPlaneGeometry.h>
 
 #include <vtkSmartPointer.h>
 #include <vtkLookupTable.h>
 #include <vtkDoubleArray.h>
 
 #include <mitkShortestDistanceCalculator.h>
 
 #include <vtkPoints.h>
 #include <vtkPolyData.h>
 #include <vtkPointData.h>
 #include <vtkActor.h>
 
 #include <MitkSurfaceRegistrationExports.h>
 
 namespace mitk
 {
-  class MITKSURFACEREGISTRATION_EXPORT ShapeComparisonManager
+  class MITKSURFACEREGISTRATION_EXPORT SurfaceRegistrationManager
   {
   public:
 
-    ShapeComparisonManager(mitk::Surface::Pointer moving, mitk::Surface::Pointer target);
-    ~ShapeComparisonManager();
+    SurfaceRegistrationManager(mitk::Surface::Pointer moving, mitk::Surface::Pointer target);
+    ~SurfaceRegistrationManager();
 
     void execute();
     vtkSmartPointer<vtkLookupTable> getTable();
 
     mitk::DataNode::Pointer getColourTransformedDataNode();
 
     void setMirroring(bool mirroring);
     bool getMirroring();
 
+    mitk::Surface::Pointer getRegisteredSurface();
+
+
+
   private:
 
     void manageICPCalculation();
     void manageCalculateDistances();
-
     void createLookUpTable();
-
-    void printPoints();//for test purposes
+    void printPoints(mitk::Surface::Pointer surfaceA, mitk::Surface::Pointer surfaceB);//for test purposes --> CPD
 
     mitk::Surface::Pointer m_MovingSurface;
     mitk::Surface::Pointer m_TargetSurface;
 
     mitk::Surface::Pointer m_RegisteredSurface;
     mitk::Surface::Pointer m_MirroredSurface;
 
     ShortestDistanceCalculator *m_DistanceCalculator;
 
     vtkSmartPointer<vtkLookupTable> m_LookupTable;
 
     bool m_Mirroring = false;
 
+
   };
 }
 
 #endif
diff --git a/Modules/SurfaceRegistration/include/mitkPointShortestDistanceCalculator.cpp b/Modules/SurfaceRegistration/include/mitkPointShortestDistanceCalculator.cpp
new file mode 100644
index 0000000000..cbac3fd38e
--- /dev/null
+++ b/Modules/SurfaceRegistration/include/mitkPointShortestDistanceCalculator.cpp
@@ -0,0 +1,96 @@
+/*===================================================================
+
+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 "mitkPointShortestDistanceCalculator.h"
+
+#include "vtkCellLocator.h"
+#include "vtkPointData.h"
+#include "vtkImplicitPolyDataDistance.h"
+#include "vtkDoubleArray.h"
+#include <vtkSmartPointer.h>
+#include <vtkPoints.h>
+#include <vtkPolyData.h>
+#include <vtkIdList.h>
+#include <vtkKdTreePointLocator.h>
+#include <vtkMath.h>
+
+
+#include <cmath>        // std::abs
+
+mitk::PointShortestDistanceCalculator::PointShortestDistanceCalculator(vtkSmartPointer<vtkPolyData> moving, vtkSmartPointer<vtkPolyData> target) : ShortestDistanceCalculator(moving, target)
+{
+  m_Moving = moving;
+  m_Target = target;
+}
+
+mitk::PointShortestDistanceCalculator::~PointShortestDistanceCalculator()
+{
+  m_Moving->Delete();
+  m_Target->Delete();
+  m_Distances->Delete();
+}
+
+void mitk::PointShortestDistanceCalculator::calculateShortestDistance()
+{
+  MITK_INFO << "calculate shortest distance between points...";
+  m_Distances = vtkSmartPointer<vtkDoubleArray>::New();
+  double fromPoint[3];
+  double closestPoint[3];
+  int pointSetSize = 0;
+  double mean = 0;
+  double rangeMin = 0;
+  double rangeMax = 0;
+  pointSetSize = m_Moving->GetPoints()->GetNumberOfPoints();
+
+  // Create the tree
+  vtkSmartPointer<vtkKdTreePointLocator> kDTree =
+    vtkSmartPointer<vtkKdTreePointLocator>::New();
+  kDTree->SetDataSet(m_Target);
+  kDTree->BuildLocator();
+
+  for (int i = 0; i < pointSetSize; ++i)
+  {
+    m_Moving->GetPoints()->GetPoint(i, fromPoint);
+    vtkIdType iD = kDTree->FindClosestPoint(fromPoint);
+
+    kDTree->GetDataSet()->GetPoint(iD, closestPoint);
+    double distance = sqrt(vtkMath::Distance2BetweenPoints(fromPoint, closestPoint));
+   /* double distance = std::sqrt(((fromPoint[0] - closestPoint[0])*(fromPoint[0] - closestPoint[0])) +
+      ((fromPoint[1] - closestPoint[1]) * (fromPoint[1] - closestPoint[1])) + ((fromPoint[2] - closestPoint[2]) * (fromPoint[2] - closestPoint[2])));*/
+    m_Distances->InsertNextValue(distance);
+    if (distance < rangeMin)
+    {
+      rangeMin = distance;
+    }
+    else if (distance > rangeMax)
+    {
+      rangeMax = distance;
+    }
+    mean += distance;
+  }
+  mean = mean / pointSetSize;
+  setDistances(m_Distances);
+  double standardDeviation = std::sqrt(calculateVariance(mean, pointSetSize));
+  setStandardDeviation(standardDeviation);
+  MITK_INFO << "Min Value is: " << rangeMin;
+  MITK_INFO << "Max Value is: " << rangeMax;
+  MITK_INFO << "The Mean is: " << mean;
+  MITK_INFO << "STD: " << standardDeviation;
+  setMean(mean);
+
+  setRangeMax(rangeMax);
+  setRangeMax(rangeMin);
+  
+}
diff --git a/Modules/SurfaceRegistration/include/mitkShortestDistanceCalculator.h b/Modules/SurfaceRegistration/include/mitkPointShortestDistanceCalculator.h
similarity index 61%
copy from Modules/SurfaceRegistration/include/mitkShortestDistanceCalculator.h
copy to Modules/SurfaceRegistration/include/mitkPointShortestDistanceCalculator.h
index 67d3c839a7..5a4e8b37f1 100644
--- a/Modules/SurfaceRegistration/include/mitkShortestDistanceCalculator.h
+++ b/Modules/SurfaceRegistration/include/mitkPointShortestDistanceCalculator.h
@@ -1,49 +1,42 @@
 /*===================================================================
 
 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 mitkShortestDistanceCalculator_h
-#define mitkShortestDistanceCalculator_h
+#ifndef mitkPointShortestDistanceCalculator_h
+#define mitkPointShortestDistanceCalculator_h
 
 #include <vtkPolyData.h>
 #include <mitkSurface.h>
+#include <mitkShortestDistanceCalculator.h>
 
-namespace mitk{
-  class ShortestDistanceCalculator
+namespace mitk {
+  class PointShortestDistanceCalculator : public ShortestDistanceCalculator
   {
   public:
-    ShortestDistanceCalculator(vtkSmartPointer<vtkPolyData> moving, vtkSmartPointer<vtkPolyData> target);
-    ~ShortestDistanceCalculator();
+    PointShortestDistanceCalculator(vtkSmartPointer<vtkPolyData> moving, vtkSmartPointer<vtkPolyData> target);
+    ~PointShortestDistanceCalculator();
 
     void calculateShortestDistance();
 
-    double getDistanceRange();
-    
-    vtkSmartPointer<vtkDoubleArray> getDistances();
-
   private:
-    double calculateVariance(double mean, int pointSetSize) const;
 
     vtkSmartPointer<vtkDoubleArray> m_Distances;
 
     vtkSmartPointer<vtkPolyData> m_Moving;
     vtkSmartPointer<vtkPolyData> m_Target;
 
-    double m_RangeMin;
-    double m_RangeMax;
-
   };
 };
 #endif
\ No newline at end of file
diff --git a/Modules/SurfaceRegistration/include/mitkShapeComparisonUtil.h b/Modules/SurfaceRegistration/include/mitkShapeComparisonUtil.h
new file mode 100644
index 0000000000..c060f6b60a
--- /dev/null
+++ b/Modules/SurfaceRegistration/include/mitkShapeComparisonUtil.h
@@ -0,0 +1,55 @@
+/*===================================================================
+
+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 ShapeComparisonUtil_h
+#define ShapeComparisonUtil_h
+
+#include <mitkDataStorage.h>
+
+#include <mitkPlanePositionManager.h>
+#include <MitkSurfaceRegistrationManager.h>
+#include <mitkPlaneGeometry.h>
+#include <mitkSurface.h>
+
+#include <MitkSurfaceRegistrationExports.h>
+
+namespace mitk
+{
+  class MITKSURFACEREGISTRATION_EXPORT ShapeComparisonUtil
+  {
+  public:
+    ShapeComparisonUtil(mitk::Surface::Pointer movedSurface, mitk::Surface::Pointer targetSurface);
+    ~ShapeComparisonUtil();
+    void calculateSliceDifferences(mitk::PlaneGeometry::Pointer planegeo);
+
+    void setMovedSurface(mitk::Surface::Pointer node);
+    void setTargetSurface(mitk::Surface::Pointer node);
+
+  private:
+
+    mitk::Surface::Pointer m_MovedSurface = nullptr;
+    mitk::Surface::Pointer m_TargetSurface = nullptr;
+
+    void printSliceDifferences(std::string outputFile, mitk::ShortestDistanceCalculator *calculator);
+    vtkSmartPointer<vtkPolyData> getPointsOnPlane(vtkSmartPointer<vtkPolyData> pointset, mitk::PlaneGeometry::Pointer planegeo);
+
+    std::ofstream m_OutputFile;
+    unsigned int m_counter = 0;
+  };
+}
+
+#endif
+
diff --git a/Modules/SurfaceRegistration/include/mitkShortestDistanceCalculator.h b/Modules/SurfaceRegistration/include/mitkShortestDistanceCalculator.h
index 67d3c839a7..45df071b4c 100644
--- a/Modules/SurfaceRegistration/include/mitkShortestDistanceCalculator.h
+++ b/Modules/SurfaceRegistration/include/mitkShortestDistanceCalculator.h
@@ -1,49 +1,62 @@
 /*===================================================================
 
 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 mitkShortestDistanceCalculator_h
 #define mitkShortestDistanceCalculator_h
 
 #include <vtkPolyData.h>
 #include <mitkSurface.h>
 
 namespace mitk{
   class ShortestDistanceCalculator
   {
   public:
     ShortestDistanceCalculator(vtkSmartPointer<vtkPolyData> moving, vtkSmartPointer<vtkPolyData> target);
     ~ShortestDistanceCalculator();
 
     void calculateShortestDistance();
 
     double getDistanceRange();
+    double getRangeMin();
+    double getRangeMax();
+    double getMean();
+    double getStandardDeviation();
     
     vtkSmartPointer<vtkDoubleArray> getDistances();
 
-  private:
+  protected:
+    void setDistances(vtkSmartPointer<vtkDoubleArray> distances);
+    void setRangeMin(double rangeMin);
+    void setRangeMax(double rangeMax);
+    void setMean(double mean);
+    void setStandardDeviation(double std);
     double calculateVariance(double mean, int pointSetSize) const;
 
+  private:
+
     vtkSmartPointer<vtkDoubleArray> m_Distances;
 
     vtkSmartPointer<vtkPolyData> m_Moving;
     vtkSmartPointer<vtkPolyData> m_Target;
 
     double m_RangeMin;
     double m_RangeMax;
+    double m_Mean;
+    double m_StandardDeviation;
 
   };
 };
 #endif
\ No newline at end of file
diff --git a/Modules/SurfaceRegistration/src/DataManagement/MitkShortestDistanceCalculator.cpp b/Modules/SurfaceRegistration/src/DataManagement/MitkShortestDistanceCalculator.cpp
index 44645cb32e..3dd1fe502c 100644
--- a/Modules/SurfaceRegistration/src/DataManagement/MitkShortestDistanceCalculator.cpp
+++ b/Modules/SurfaceRegistration/src/DataManagement/MitkShortestDistanceCalculator.cpp
@@ -1,105 +1,151 @@
 /*===================================================================
 
 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 "mitkShortestDistanceCalculator.h"
 
 #include "vtkCellLocator.h"
 #include "vtkPointData.h"
 #include "vtkImplicitPolyDataDistance.h"
 #include "vtkDoubleArray.h"
 
 
 #include <cmath>        // std::abs
 
 mitk::ShortestDistanceCalculator::ShortestDistanceCalculator(vtkSmartPointer<vtkPolyData> moving, vtkSmartPointer<vtkPolyData> target)
 {
   m_Moving = moving;
   m_Target = target;
 }
 
 mitk::ShortestDistanceCalculator::~ShortestDistanceCalculator()
 {
   m_Moving->Delete();
   m_Target->Delete();
   m_Distances->Delete();
 }
 
 void mitk::ShortestDistanceCalculator::calculateShortestDistance()
 {
-  MITK_INFO << "calculate shortest distance ...";
+  MITK_INFO << "calculate shortest distance between cells ...";
   m_Distances = vtkSmartPointer<vtkDoubleArray>::New();
   double fromPoint[3] = { 0, 0, 0 };
   int pointSetSize = 0;
   double mean = 0;
   pointSetSize = m_Moving->GetPoints()->GetNumberOfPoints();
   vtkSmartPointer<vtkImplicitPolyDataDistance> implicitPolyDataDistance =
     vtkSmartPointer<vtkImplicitPolyDataDistance>::New();
   implicitPolyDataDistance->SetInput(m_Target);
   m_RangeMin = 0;
   m_RangeMax = 0;
-  for (int i = 0; i < pointSetSize; ++i)
+ 
+   for (int i = 0; i < pointSetSize; ++i)
   {
     m_Moving->GetPoints()->GetPoint(i, fromPoint);
     double distance = implicitPolyDataDistance->FunctionValue(fromPoint[0], fromPoint[1], fromPoint[2]);
-    // MITK_INFO << distance; 
     m_Distances->InsertNextValue(distance);
     if (distance < m_RangeMin)
     {
       m_RangeMin = distance;
     }
     else if (distance > m_RangeMax)
     {
       m_RangeMax = distance;
     }
     mean += distance;
   }
-  mean = mean / pointSetSize;
+  m_Mean = mean / pointSetSize;
+  m_StandardDeviation = std::sqrt(calculateVariance(m_Mean, pointSetSize));
   MITK_INFO << "Min Value is: " << m_RangeMin;
   MITK_INFO << "Max Value is: " << m_RangeMax;
-  MITK_INFO << "The Mean is: " << mean ;
-  MITK_INFO << "The Variance is:" << calculateVariance(mean, pointSetSize);
-  MITK_INFO << "STD: " << std::sqrt(calculateVariance(mean, pointSetSize));
+  MITK_INFO << "The Mean is: " << m_Mean;
+  MITK_INFO << "STD: " << m_StandardDeviation;
 }
 
 double mitk::ShortestDistanceCalculator::getDistanceRange()
 {
   double value;
   if (std::abs(m_RangeMin) < std::abs(m_RangeMax)) {
     value = std::ceil(std::abs(m_RangeMax));
   }
   else
   {
     value = std::ceil(std::abs(m_RangeMin));
   }
   return value;
 }
 
+double mitk::ShortestDistanceCalculator::getRangeMin()
+{
+  return m_RangeMin;
+}
+
+double mitk::ShortestDistanceCalculator::getRangeMax()
+{
+  return m_RangeMax;
+}
+
+double mitk::ShortestDistanceCalculator::getMean()
+{
+  return m_Mean;
+}
+
+double mitk::ShortestDistanceCalculator::getStandardDeviation()
+{
+  return m_StandardDeviation;
+}
+
 vtkSmartPointer<vtkDoubleArray> mitk::ShortestDistanceCalculator::getDistances()
 {
   return m_Distances;
 }
 
+void mitk::ShortestDistanceCalculator::setDistances(vtkSmartPointer<vtkDoubleArray> distances)
+{
+  this->m_Distances = distances;
+}
+
+
+void mitk::ShortestDistanceCalculator::setRangeMin(double rangeMin)
+{
+  this->m_RangeMin = rangeMin;
+}
+
+void mitk::ShortestDistanceCalculator::setRangeMax(double rangeMax)
+{
+  this->m_RangeMax = rangeMax;
+}
+
+void mitk::ShortestDistanceCalculator::setMean(double mean)
+{
+  this->m_Mean = mean;
+}
+
+void mitk::ShortestDistanceCalculator::setStandardDeviation(double std)
+{
+  m_StandardDeviation = std;
+}
+
 double mitk::ShortestDistanceCalculator::calculateVariance(double mean, int pointSetSize) const
 {
   double variance = 0.0;
   int counter = 0;
   for (int i = 0; i < pointSetSize; ++i)
   {
     variance += (std::abs(m_Distances->GetValueReference(i))- mean)*(std::abs(m_Distances->GetValueReference(i)) - mean);
   }
   variance = variance / (pointSetSize - 1);
   return variance;
 }
 
diff --git a/Modules/SurfaceRegistration/src/DataManagement/mitkPointShortestDistanceCalculator.cpp b/Modules/SurfaceRegistration/src/DataManagement/mitkPointShortestDistanceCalculator.cpp
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/Modules/SurfaceRegistration/src/DataManagement/mitkShapeComparisonUtil.cpp b/Modules/SurfaceRegistration/src/DataManagement/mitkShapeComparisonUtil.cpp
new file mode 100644
index 0000000000..b3274b5370
--- /dev/null
+++ b/Modules/SurfaceRegistration/src/DataManagement/mitkShapeComparisonUtil.cpp
@@ -0,0 +1,100 @@
+/*===================================================================
+
+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 "mitkShapeComparisonUtil.h"
+
+#include <mitkDataNode.h>
+#include <MitkSurfaceRegistrationICP.h>
+#include <mitkSurface.h>
+#include <mitkPointShortestDistanceCalculator.h>
+
+#include <vtkSmartPointer.h>
+#include <vtkPolyData.h>
+
+mitk::ShapeComparisonUtil::ShapeComparisonUtil(mitk::Surface::Pointer movedSurface, mitk::Surface::Pointer targetSurface)
+{
+  m_MovedSurface = movedSurface;
+  m_TargetSurface = targetSurface;
+  //TODO append timestamp
+  m_OutputFile.open("X:/ergebnissse/results.txt");
+}
+
+mitk::ShapeComparisonUtil::~ShapeComparisonUtil()
+{
+  m_OutputFile.close();
+  m_MovedSurface->Delete();
+  m_TargetSurface->Delete();
+}
+
+void mitk::ShapeComparisonUtil::calculateSliceDifferences(mitk::PlaneGeometry::Pointer planegeo)
+{
+
+  m_OutputFile << "/*****************************************************************************/" << std::endl;
+  ++m_counter;
+  m_OutputFile << "Plane Number:   " << m_counter << std::endl;
+
+  vtkSmartPointer<vtkPolyData> movedPointsOnPlane = getPointsOnPlane(m_MovedSurface->GetVtkPolyData(), planegeo);
+  vtkSmartPointer<vtkPolyData> targetPointsOnPlane = getPointsOnPlane(m_TargetSurface->GetVtkPolyData(), planegeo);
+
+  m_OutputFile << "PointsOnPlane:   " << movedPointsOnPlane->GetPoints()->GetNumberOfPoints() << " / " << targetPointsOnPlane->GetPoints()->GetNumberOfPoints() << std::endl;
+    mitk::PointShortestDistanceCalculator *calculator = new PointShortestDistanceCalculator(movedPointsOnPlane, targetPointsOnPlane); 
+    calculator->calculateShortestDistance();
+    
+    m_OutputFile << "   Mean:   " << calculator->getMean() << "   STD:   " << calculator->getStandardDeviation() <<
+     // "   Range   " << calculator->getRangeMin() << 
+      std::endl;
+}
+
+void mitk::ShapeComparisonUtil::setMovedSurface(mitk::Surface::Pointer surface)
+{
+  this->m_MovedSurface = surface;
+}
+
+void mitk::ShapeComparisonUtil::setTargetSurface(mitk::Surface::Pointer surface)
+{
+  this->m_TargetSurface = surface;
+}
+
+void mitk::ShapeComparisonUtil::printSliceDifferences(std::string outputFileName, mitk::ShortestDistanceCalculator *calculator)
+{
+  m_OutputFile <<" ***************************************************************************** "<< std::endl;
+  m_OutputFile << "Mean: " << calculator->getMean() << "STD: " << calculator->getStandardDeviation() << 
+    "Range_Min " << calculator->getRangeMin() << "Range_Max " << calculator->getRangeMax() << std::endl;
+}
+
+vtkSmartPointer<vtkPolyData> mitk::ShapeComparisonUtil::getPointsOnPlane(vtkSmartPointer<vtkPolyData> pointset, mitk::PlaneGeometry::Pointer planegeo)
+{
+  vtkSmartPointer<vtkPolyData> pointsOnPlane = vtkSmartPointer<vtkPolyData>::New();
+  vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
+  double tempPoint[3] = { 0, 0, 0 };
+  int pointcounter = 0;
+  points->InsertPoint(1,tempPoint);
+  int pointSetSize = pointset->GetPoints()->GetNumberOfPoints();
+  for (int i = 0; i < pointSetSize; ++i)
+  {
+    pointset->GetPoints()->GetPoint(i, tempPoint);
+    if(planegeo->Distance(tempPoint) < 0.475)
+    {
+      ++pointcounter;
+      points->InsertNextPoint(tempPoint); //TODO
+    }
+  }
+  MITK_INFO << "Anzahl Points near plane: " << pointcounter;
+  pointsOnPlane->SetPoints(points);
+  return pointsOnPlane; // returns null
+}
+
+
diff --git a/Modules/SurfaceRegistration/src/mitkShapeComparisonManager.cpp b/Modules/SurfaceRegistration/src/mitkSurfaceRegistrationManager.cpp
similarity index 76%
rename from Modules/SurfaceRegistration/src/mitkShapeComparisonManager.cpp
rename to Modules/SurfaceRegistration/src/mitkSurfaceRegistrationManager.cpp
index 15cb56f1d5..b90d6723a9 100644
--- a/Modules/SurfaceRegistration/src/mitkShapeComparisonManager.cpp
+++ b/Modules/SurfaceRegistration/src/mitkSurfaceRegistrationManager.cpp
@@ -1,193 +1,201 @@
 /*===================================================================
 
 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 <mitkShapeComparisonManager.h>
+#include <mitkSurfaceRegistrationManager.h>
 
 #include <mitkShortestDistanceCalculator.h>
 #include <mitkSurfaceRegistrationICP.h>
 #include <mitkSurfaceMirroringHelper.h>
 #include <mitkLookupTable.h>
 #include <mitkLookupTableProperty.h>
 #include <mitkVtkRepresentationProperty.h>
+#include <mitkPlaneGeometry.h>
 
 #include <vtkPoints.h>
 #include <vtkPolyData.h>
 #include <vtkPointData.h>
 #include <vtkSmartPointer.h>
 #include <vtkDoubleArray.h>
 
 #include <iostream>
 #include <fstream>
 
-mitk::ShapeComparisonManager::ShapeComparisonManager(mitk::Surface::Pointer moving, mitk::Surface::Pointer target)
+mitk::SurfaceRegistrationManager::SurfaceRegistrationManager(mitk::Surface::Pointer moving, mitk::Surface::Pointer target)
 {
   this->m_MovingSurface = moving;
   this->m_TargetSurface = target;
   this->m_Mirroring = false;
   createLookUpTable();
 }
 
-mitk::ShapeComparisonManager::~ShapeComparisonManager()
+mitk::SurfaceRegistrationManager::~SurfaceRegistrationManager()
 {
   m_MovingSurface->Delete();
   m_TargetSurface->Delete();
   m_RegisteredSurface->Delete();
   m_LookupTable->Delete();
 }
 
-void mitk::ShapeComparisonManager::execute()
+void mitk::SurfaceRegistrationManager::execute()
 {
-  //printPoints();
+  
   if (m_Mirroring)
   {
     MitkSurfaceMirroringHelper *mirroringHelper = new MitkSurfaceMirroringHelper();
     m_MirroredSurface = mirroringHelper->performMirroring(m_MovingSurface);
   }
-  //printPoints();
+  //printPoints(); //after mirroring
   manageICPCalculation();
+  //printPoints();
+  printPoints(m_RegisteredSurface, m_TargetSurface); //before mirroring
+  MITK_INFO << "Print Points after registration!";
   manageCalculateDistances();
 }
 
-vtkSmartPointer<vtkLookupTable> mitk::ShapeComparisonManager::getTable()
+vtkSmartPointer<vtkLookupTable> mitk::SurfaceRegistrationManager::getTable()
 {
   return m_LookupTable;
 }
 
-mitk::DataNode::Pointer mitk::ShapeComparisonManager::getColourTransformedDataNode()
+mitk::DataNode::Pointer mitk::SurfaceRegistrationManager::getColourTransformedDataNode()
 {
-  // for test purposes
   mitk::Surface::Pointer currentSurface;
   if (m_RegisteredSurface != nullptr)
   {
     currentSurface = m_RegisteredSurface;
   }
   else if(m_MirroredSurface!= nullptr)
   {
     currentSurface = m_MirroredSurface;
   }
   else
   {
     currentSurface = m_MovingSurface;
   }
 
   currentSurface->GetVtkPolyData()->GetPointData()->SetScalars(m_DistanceCalculator->getDistances());
   currentSurface->GetVtkPolyData()->GetPointData()->Update();
 
   //convert m_LookUpTable to mitk LookUpTable
   mitk::LookupTable::Pointer lut = mitk::LookupTable::New();
   lut->SetVtkLookupTable(m_LookupTable);
   mitk::LookupTableProperty::Pointer prop = mitk::LookupTableProperty::New(lut);
   currentSurface->GetVtkPolyData()->GetPointData()->Update();
 
   mitk::DataNode::Pointer transformedNode = mitk::DataNode::New();
   transformedNode->SetProperty("LookupTable", prop);
   transformedNode->SetBoolProperty("scalar visibility", true);
   transformedNode->SetBoolProperty("color mode", true);
   //set Range of Lut
   double range = m_DistanceCalculator->getDistanceRange();
   transformedNode->SetFloatProperty("ScalarsRangeMinimum", range*-1);
   transformedNode->SetFloatProperty("ScalarsRangeMaximum", range);
   //transformedNode->SetFloatProperty("ScalarsRangeMinimum", -5);
   //transformedNode->SetFloatProperty("ScalarsRangeMaximum", 5);
   // Configure material so that only scalar colors are shown
   transformedNode->SetColor(1.0f, 1.0f, 1.0f);
   transformedNode->SetOpacity(1.0f);
   transformedNode->SetFloatProperty("material.wireframeLineWidth", 2.0f);
   //Set view of plane to VTK_SURFACE
   transformedNode->SetProperty("material.representation", mitk::VtkRepresentationProperty::New());//VTK_SURFACE currently default
 
   // save colored surface node
   transformedNode->SetData(currentSurface);
-
   return transformedNode;
 }
 
-void mitk::ShapeComparisonManager::setMirroring(bool mirroring)
+void mitk::SurfaceRegistrationManager::setMirroring(bool mirroring)
 {
   this->m_Mirroring = mirroring;
 }
 
-bool mitk::ShapeComparisonManager::getMirroring()
+bool mitk::SurfaceRegistrationManager::getMirroring()
 {
   return m_Mirroring;
 }
 
-void mitk::ShapeComparisonManager::manageICPCalculation()
+mitk::Surface::Pointer mitk::SurfaceRegistrationManager::getRegisteredSurface()
 {
+  return m_RegisteredSurface;
+}
+
+void mitk::SurfaceRegistrationManager::manageICPCalculation()
+{
+  MITK_INFO << "Starting registration";
   m_RegisteredSurface = mitk::Surface::New();
   mitk::SurfaceRegistrationICP *registrationHelper = new SurfaceRegistrationICP();
   if (m_Mirroring)
   {
     m_RegisteredSurface = registrationHelper->CalculateICP(m_MirroredSurface, m_TargetSurface);
   }
   else
   {
     m_RegisteredSurface = registrationHelper->CalculateICP(m_MovingSurface, m_TargetSurface);
   }
 }
 
-void mitk::ShapeComparisonManager::manageCalculateDistances()
+void mitk::SurfaceRegistrationManager::manageCalculateDistances()
 {
   if (m_RegisteredSurface != nullptr)
   {
    m_DistanceCalculator = new ShortestDistanceCalculator(m_RegisteredSurface->GetVtkPolyData(),
      m_TargetSurface->GetVtkPolyData());
   }
   else if(m_Mirroring)
   {
     m_DistanceCalculator = new ShortestDistanceCalculator(m_MirroredSurface->GetVtkPolyData(),
       m_TargetSurface->GetVtkPolyData());
   }
   else 
   {
     m_DistanceCalculator = new ShortestDistanceCalculator(m_MovingSurface->GetVtkPolyData(),
       m_TargetSurface->GetVtkPolyData());
   }
   m_DistanceCalculator->calculateShortestDistance();
 }
 
-void mitk::ShapeComparisonManager::createLookUpTable()
+void mitk::SurfaceRegistrationManager::createLookUpTable()
 {
   m_LookupTable = vtkSmartPointer<vtkLookupTable>::New();
   m_LookupTable->SetNumberOfTableValues(25);
   m_LookupTable->Build();
 }
 
-void mitk::ShapeComparisonManager::printPoints()
+void mitk::SurfaceRegistrationManager::printPoints(mitk::Surface::Pointer surfaceA, mitk::Surface::Pointer surfaceB)
 {
-  MITK_INFO << "printing";
+  MITK_INFO << "printing Points";
   std::ofstream OutputFileMoving;
   OutputFileMoving.open("movingPoints.txt");
-  int pointNumber = m_MovingSurface->GetVtkPolyData()->GetPoints()->GetNumberOfPoints();
+  int pointNumber = surfaceA->GetVtkPolyData()->GetPoints()->GetNumberOfPoints();
   double printPoint[3] = { 0,0,0 };
   for (int i = 0; i < pointNumber; ++i)
   {
-    m_MovingSurface->GetVtkPolyData()->GetPoints()->GetPoint(i, printPoint);
+    surfaceA->GetVtkPolyData()->GetPoints()->GetPoint(i, printPoint);
     OutputFileMoving << printPoint[0]<<" " << printPoint[1] << " " << printPoint[2] <<std::endl;
   }
   OutputFileMoving.close();
 
   std::ofstream OutputFileTarget;
   OutputFileTarget.open("targetPoints.txt");
-  int pointNumber2 = m_TargetSurface->GetVtkPolyData()->GetPoints()->GetNumberOfPoints();
+  int pointNumber2 = surfaceB->GetVtkPolyData()->GetPoints()->GetNumberOfPoints();
   double printPoint2[3] = { 0,0,0 };
   for (int i = 0; i < pointNumber2; ++i)
   {
-    m_TargetSurface->GetVtkPolyData()->GetPoints()->GetPoint(i, printPoint2);
+    surfaceB->GetVtkPolyData()->GetPoints()->GetPoint(i, printPoint2);
     OutputFileTarget << printPoint2[0] << " " << printPoint2[1] << " " << printPoint2[2] << std::endl;
   }
   OutputFileTarget.close();
-}
+}
\ No newline at end of file