diff --git a/Modules/SurfaceRegistration/files.cmake b/Modules/SurfaceRegistration/files.cmake
index edb3ae299c..3dc367685f 100644
--- a/Modules/SurfaceRegistration/files.cmake
+++ b/Modules/SurfaceRegistration/files.cmake
@@ -1,14 +1,13 @@
 file(GLOB_RECURSE H_FILES RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}/include/*")
 
 set(CPP_FILES
     mitkShapeComparisonManager.cpp
 	DataManagement/mitkShortestDistanceCalculator.cpp
 	DataManagement/mitkSurfaceRegistrationICP.cpp
 	DataManagement/mitkSurfaceMirroringHelper.cpp
+	DataManagement/mitkConvexHullCalculator.cpp
 )
 
 set(RESOURCE_FILES
-	Interactions/Paint.xml
-	Interactions/PaintConfig.xml
 )
 
diff --git a/Modules/SurfaceRegistration/include/MitkShapeComparisonManager.h b/Modules/SurfaceRegistration/include/MitkShapeComparisonManager.h
index e7ec177173..ff369c6c27 100644
--- a/Modules/SurfaceRegistration/include/MitkShapeComparisonManager.h
+++ b/Modules/SurfaceRegistration/include/MitkShapeComparisonManager.h
@@ -1,80 +1,78 @@
 /*===================================================================
 
 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
 
 #include "mitkSurface.h"
 #include <mitkWeakPointer.h>
 #include "mitkDataNode.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 "mitkSurfaceRegistrationICP.h"
-
 #include <MitkSurfaceRegistrationExports.h>
 
 namespace mitk
 {
   class MITKSURFACEREGISTRATION_EXPORT ShapeComparisonManager
   {
   public:
 
     ShapeComparisonManager(mitk::Surface::Pointer moving, mitk::Surface::Pointer target);
     ~ShapeComparisonManager();
 
     void execute();
     vtkSmartPointer<vtkLookupTable> getTable();
 
     mitk::DataNode::Pointer getColourTransformedDataNode();
 
     void setMirroring(bool mirroring);
     bool getMirroring();
 
   private:
 
     void manageICPCalculation();
     void manageCalculateDistances();
 
     void createLookUpTable();
 
     void printPoints();//for test purposes
 
     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/mitkConvexHullCalculator.h b/Modules/SurfaceRegistration/include/mitkConvexHullCalculator.h
new file mode 100644
index 0000000000..588cf33114
--- /dev/null
+++ b/Modules/SurfaceRegistration/include/mitkConvexHullCalculator.h
@@ -0,0 +1,54 @@
+/*===================================================================
+
+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 mitkConvexHullCalculator_h
+#define mitkConvexHullCalculator_h
+
+
+#include <mitkSurface.h>
+
+
+namespace mitk {
+  class MitkConvexHullCalculator
+  {
+  public:
+    MitkConvexHullCalculator();
+    ~MitkConvexHullCalculator();
+
+    void testCalculator();
+
+
+    //int MitkConvexHullCalculator::main(int argc, char* argv[]);
+
+  private:
+
+   //read files (at first try with one, then up to three
+    void filereader();
+
+    void testConvexHullDelaunay3D();
+
+    void testAppendPolyData();
+
+
+    //Data 
+    mitk::Surface::Pointer m_firstNode;
+    mitk::Surface::Pointer m_secondNode;
+    mitk::Surface::Pointer m_thirdNode;
+    mitk::Surface::Pointer m_combinedNode;
+
+  };
+};
+#endif
\ No newline at end of file
diff --git a/Modules/SurfaceRegistration/include/mitkShortestDistanceCalculator.h b/Modules/SurfaceRegistration/include/mitkShortestDistanceCalculator.h
index d95bb1cf68..67d3c839a7 100644
--- a/Modules/SurfaceRegistration/include/mitkShortestDistanceCalculator.h
+++ b/Modules/SurfaceRegistration/include/mitkShortestDistanceCalculator.h
@@ -1,48 +1,49 @@
 /*===================================================================
 
 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();
     
     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/src/DataManagement/MitkShortestDistanceCalculator.cpp b/Modules/SurfaceRegistration/src/DataManagement/MitkShortestDistanceCalculator.cpp
index a51c4cd795..44645cb32e 100644
--- a/Modules/SurfaceRegistration/src/DataManagement/MitkShortestDistanceCalculator.cpp
+++ b/Modules/SurfaceRegistration/src/DataManagement/MitkShortestDistanceCalculator.cpp
@@ -1,86 +1,105 @@
 /*===================================================================
 
 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 ...";
   m_Distances = vtkSmartPointer<vtkDoubleArray>::New();
   double fromPoint[3] = { 0, 0, 0 };
-  int pointNumber = 0;
-  pointNumber = m_Moving->GetPoints()->GetNumberOfPoints();
+  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 < pointNumber; ++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;
   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));
 }
 
 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;
 }
 
 vtkSmartPointer<vtkDoubleArray> mitk::ShortestDistanceCalculator::getDistances()
 {
   return m_Distances;
 }
 
+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/mitkConvexHullCalculator.cpp b/Modules/SurfaceRegistration/src/DataManagement/mitkConvexHullCalculator.cpp
new file mode 100644
index 0000000000..6d36593813
--- /dev/null
+++ b/Modules/SurfaceRegistration/src/DataManagement/mitkConvexHullCalculator.cpp
@@ -0,0 +1,143 @@
+/*===================================================================
+
+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 "mitkConvexHullCalculator.h"
+
+#include <mitkBaseData.h>
+#include <mitkIOUtil.h>
+
+#include <vtkPoints.h>
+#include <vtkPolyData.h>
+#include <vtkDelaunay3D.h>
+#include <vtkUnstructuredGrid.h>
+#include <vtkSmartPointer.h>
+#include <vtkXMLPolyDataWriter.h>
+#include <vtkXMLUnstructuredGridWriter.h>
+#include <vtkCellArray.h>
+#include <vtkDataSetSurfaceFilter.h>
+#include <vtkCleanPolyData.h>
+
+#include <vtkPolyDataMapper.h>
+#include <vtkActor.h>
+#include <vtkProperty.h>
+#include <vtkRenderer.h>
+#include <vtkRenderWindow.h>
+#include <vtkRenderWindowInteractor.h>
+#include <vtkAppendPolyData.h>
+
+mitk::MitkConvexHullCalculator::MitkConvexHullCalculator()
+{
+  m_firstNode = mitk::Surface::New();
+  m_secondNode = mitk::Surface::New();
+  m_thirdNode = mitk::Surface::New();
+  m_combinedNode = mitk::Surface::New();
+}
+
+mitk::MitkConvexHullCalculator::~MitkConvexHullCalculator()
+{
+
+}
+
+void mitk::MitkConvexHullCalculator::testCalculator()
+{
+  filereader();
+  testAppendPolyData();
+  testConvexHullDelaunay3D();
+}
+
+void mitk::MitkConvexHullCalculator::filereader()
+{
+  try {
+    m_firstNode = dynamic_cast<mitk::Surface*> (IOUtil::LoadSurface("X:/data/set/AA246L_Tibia_smoothed.vtp").GetPointer());
+    m_secondNode = dynamic_cast<mitk::Surface*> (IOUtil::LoadSurface("X:/data/set/AA246L_Fibula_smoothed.vtp").GetPointer());
+    m_thirdNode = dynamic_cast<mitk::Surface*> (IOUtil::LoadSurface("X:/data/set/AA246L_Talus_smoothed.vtp").GetPointer());
+  }
+  catch (Exception e)
+  {
+    MITK_INFO << e.GetDescription();
+  }
+}
+
+void mitk::MitkConvexHullCalculator::testConvexHullDelaunay3D()
+{
+  vtkSmartPointer< vtkPolyData> polydata = m_combinedNode->GetVtkPolyData();
+  // Create the convex hull of the pointcloud
+  // Generate a tetrahedral mesh from the input points. By
+  // default, the generated volume is the convex hull of the points
+  vtkSmartPointer<vtkDelaunay3D> delaunay =
+    vtkSmartPointer< vtkDelaunay3D >::New();
+  delaunay->SetInputData(polydata);
+  delaunay->Update();
+ 
+
+  vtkSmartPointer<vtkXMLUnstructuredGridWriter> ugWriter =
+    vtkSmartPointer<vtkXMLUnstructuredGridWriter>::New();
+  ugWriter->SetInputConnection(delaunay->GetOutputPort());
+  ugWriter->SetFileName("delaunay.vtu");
+  ugWriter->Write();
+
+  vtkSmartPointer<vtkDataSetSurfaceFilter> surfaceFilter =
+    vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
+  surfaceFilter->SetInputConnection(delaunay->GetOutputPort());
+  surfaceFilter->Update();
+
+  // Write the file
+  vtkSmartPointer<vtkXMLPolyDataWriter> writer =
+    vtkSmartPointer<vtkXMLPolyDataWriter>::New();
+  writer->SetFileName("X:/data/set/ConvexHullCombined.vtp");
+#if VTK_MAJOR_VERSION <= 5
+  writer->SetInputData(surfaceFilter->GetOutput());
+#else
+  writer->SetInputData(polydata);
+#endif
+  writer->Write();
+}
+
+void mitk::MitkConvexHullCalculator::testAppendPolyData()
+{
+  //Append the two meshes 
+  vtkSmartPointer<vtkAppendPolyData> appendFilter =
+    vtkSmartPointer<vtkAppendPolyData>::New();
+#if VTK_MAJOR_VERSION <= 5
+  appendFilter->AddInputDataObject(m_firstNode->GetVtkPolyData());
+  appendFilter->AddInputDataObject(m_secondNode->GetVtkPolyData());
+  appendFilter->AddInputDataObject(m_thirdNode->GetVtkPolyData());
+#else
+  appendFilter->AddInputData(input1);
+  appendFilter->AddInputData(input2);
+#endif
+  appendFilter->Update();
+  vtkSmartPointer<vtkPolyData> appendData = appendFilter->GetOutput();
+  m_combinedNode->SetVtkPolyData(appendData);
+
+  // Remove any duplicate points.
+  vtkSmartPointer<vtkCleanPolyData> cleanFilter =
+    vtkSmartPointer<vtkCleanPolyData>::New();
+  cleanFilter->SetInputConnection(appendFilter->GetOutputPort());
+  cleanFilter->Update();
+
+
+  // Write the file
+  vtkSmartPointer<vtkXMLPolyDataWriter> writer =
+    vtkSmartPointer<vtkXMLPolyDataWriter>::New();
+  writer->SetFileName("X:/data/set/Combined.vtp");
+#if VTK_MAJOR_VERSION <= 5
+  writer->SetInputData(m_combinedNode->GetVtkPolyData());
+#else
+  writer->SetInputData(polydata);
+#endif
+  writer->Write();
+}
+
diff --git a/Modules/SurfaceRegistration/src/mitkShapeComparisonManager.cpp b/Modules/SurfaceRegistration/src/mitkShapeComparisonManager.cpp
index 1d65242130..15cb56f1d5 100644
--- a/Modules/SurfaceRegistration/src/mitkShapeComparisonManager.cpp
+++ b/Modules/SurfaceRegistration/src/mitkShapeComparisonManager.cpp
@@ -1,190 +1,193 @@
 /*===================================================================
 
 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 <mitkShortestDistanceCalculator.h>
 #include <mitkSurfaceRegistrationICP.h>
 #include <mitkSurfaceMirroringHelper.h>
 #include <mitkLookupTable.h>
 #include <mitkLookupTableProperty.h>
 #include <mitkVtkRepresentationProperty.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)
 {
   this->m_MovingSurface = moving;
   this->m_TargetSurface = target;
   this->m_Mirroring = false;
   createLookUpTable();
 }
 
 mitk::ShapeComparisonManager::~ShapeComparisonManager()
 {
   m_MovingSurface->Delete();
   m_TargetSurface->Delete();
   m_RegisteredSurface->Delete();
   m_LookupTable->Delete();
 }
 
 void mitk::ShapeComparisonManager::execute()
 {
   //printPoints();
   if (m_Mirroring)
   {
     MitkSurfaceMirroringHelper *mirroringHelper = new MitkSurfaceMirroringHelper();
     m_MirroredSurface = mirroringHelper->performMirroring(m_MovingSurface);
   }
+  //printPoints();
   manageICPCalculation();
   manageCalculateDistances();
 }
 
 vtkSmartPointer<vtkLookupTable> mitk::ShapeComparisonManager::getTable()
 {
   return m_LookupTable;
 }
 
 mitk::DataNode::Pointer mitk::ShapeComparisonManager::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)
 {
   this->m_Mirroring = mirroring;
 }
 
 bool mitk::ShapeComparisonManager::getMirroring()
 {
   return m_Mirroring;
 }
 
 void mitk::ShapeComparisonManager::manageICPCalculation()
 {
   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()
 {
   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()
 {
   m_LookupTable = vtkSmartPointer<vtkLookupTable>::New();
   m_LookupTable->SetNumberOfTableValues(25);
   m_LookupTable->Build();
 }
 
 void mitk::ShapeComparisonManager::printPoints()
 {
   MITK_INFO << "printing";
   std::ofstream OutputFileMoving;
   OutputFileMoving.open("movingPoints.txt");
   int pointNumber = m_MovingSurface->GetVtkPolyData()->GetPoints()->GetNumberOfPoints();
   double printPoint[3] = { 0,0,0 };
   for (int i = 0; i < pointNumber; ++i)
   {
     m_MovingSurface->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();
   double printPoint2[3] = { 0,0,0 };
   for (int i = 0; i < pointNumber2; ++i)
   {
     m_TargetSurface->GetVtkPolyData()->GetPoints()->GetPoint(i, printPoint2);
     OutputFileTarget << printPoint2[0] << " " << printPoint2[1] << " " << printPoint2[2] << std::endl;
   }
   OutputFileTarget.close();
 }