diff --git a/Modules/Segmentation/Testing/mitkImageToContourFilterTest.cpp b/Modules/Segmentation/Testing/mitkImageToContourFilterTest.cpp
index 91102af916..aca004a722 100644
--- a/Modules/Segmentation/Testing/mitkImageToContourFilterTest.cpp
+++ b/Modules/Segmentation/Testing/mitkImageToContourFilterTest.cpp
@@ -1,109 +1,109 @@
 /*===================================================================
 
 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 <mitkImage.h>
 #include <mitkImageToContourFilter.h>
 #include <mitkIOUtil.h>
 #include <mitkSurface.h>
 #include <mitkTestFixture.h>
 #include <mitkTestingMacros.h>
 
 class mitkImageToContourFilterTestSuite : public mitk::TestFixture
 {
   CPPUNIT_TEST_SUITE(mitkImageToContourFilterTestSuite);
   MITK_TEST(TestExtractContoursFromAnEmptySlice);
   MITK_TEST(TestExtractASingleContourFromASlice);
   MITK_TEST(TestExtractTwoContoursFromASingleSlice);
   CPPUNIT_TEST_SUITE_END();
 
 private:
 
   mitk::Image::Pointer m_EmptySlice;
   mitk::Image::Pointer m_SliceWithSingleContour;
   mitk::Image::Pointer m_SliceWithTwoContours;
   mitk::ImageToContourFilter::Pointer m_ContourExtractor;
 
 public:
 
   void setUp()
   {
     //Load the image
     //TODO Move/create segmentation subfolder
     m_EmptySlice = mitk::IOUtil::LoadImage(GetTestDataFilePath("SurfaceInterpolation/ImageToContour/EmptySlice.nrrd"));
     CPPUNIT_ASSERT_MESSAGE("Failed to load image for test: [EmptySlice.nrrd]", m_EmptySlice.IsNotNull());
 
     m_SliceWithSingleContour = mitk::IOUtil::LoadImage(GetTestDataFilePath("SurfaceInterpolation/ImageToContour/SliceWithSingleContour.nrrd"));
     CPPUNIT_ASSERT_MESSAGE("Failed to load image for test: [SliceWithSingleContour.nrrd]", m_SliceWithSingleContour.IsNotNull());
 
     m_SliceWithTwoContours = mitk::IOUtil::LoadImage(GetTestDataFilePath("SurfaceInterpolation/ImageToContour/SliceWithTwoContours.nrrd"));
     CPPUNIT_ASSERT_MESSAGE("Failed to load image for test: [SliceWithTwoContours.nrrd]", m_SliceWithTwoContours.IsNotNull());
 
     m_ContourExtractor = mitk::ImageToContourFilter::New();
     CPPUNIT_ASSERT_MESSAGE("Failed to initialize ImageToContourFilter", m_ContourExtractor.IsNotNull());
   }
 
   // Extract contours from an empty slice
   void TestExtractContoursFromAnEmptySlice()
   {
     m_ContourExtractor->SetInput(m_EmptySlice);
     m_ContourExtractor->Update();
     mitk::Surface::Pointer emptyContour = m_ContourExtractor->GetOutput();
 
     CPPUNIT_ASSERT_MESSAGE("Extracted contour is not empty", emptyContour->GetVtkPolyData()->GetNumberOfPoints() == 0);
   }
 
   // Extract a single contour from a slice
   void TestExtractASingleContourFromASlice()
   {
     m_ContourExtractor->SetInput(m_SliceWithSingleContour);
     m_ContourExtractor->Update();
 
     CPPUNIT_ASSERT_MESSAGE("ImageToContourFilter has wrong number of outputs!", m_ContourExtractor->GetNumberOfOutputs() == 1);
 
     mitk::Surface::Pointer contour = m_ContourExtractor->GetOutput();
 
     mitk::Surface::Pointer referenceContour = mitk::IOUtil::LoadSurface(GetTestDataFilePath("SurfaceInterpolation/Reference/SingleContour.vtk"));
 
     CPPUNIT_ASSERT_MESSAGE("Extracted contour has wrong number of points!", contour->GetVtkPolyData()->GetNumberOfPoints() ==
                            referenceContour->GetVtkPolyData()->GetNumberOfPoints());
 
-    CPPUNIT_ASSERT_MESSAGE("Unequal contours", mitk::Equal(contour->GetVtkPolyData(), referenceContour->GetVtkPolyData(), 0.000001, true));
+    CPPUNIT_ASSERT_MESSAGE("Unequal contours", mitk::Equal(*(contour->GetVtkPolyData()), *(referenceContour->GetVtkPolyData()), 0.000001, true));
   }
 
   // Extract multiple contours from a single slice
   void TestExtractTwoContoursFromASingleSlice()
   {
     m_ContourExtractor->SetInput(m_SliceWithTwoContours);
     m_ContourExtractor->Update();
 
     CPPUNIT_ASSERT_MESSAGE("ImageToContourFilter has wrong number of outputs!", m_ContourExtractor->GetNumberOfOutputs() == 1);
 
     mitk::Surface::Pointer contour = m_ContourExtractor->GetOutput(0);
 
     mitk::Surface::Pointer referenceContour = mitk::IOUtil::LoadSurface(GetTestDataFilePath("SurfaceInterpolation/Reference/TwoContours.vtk"));
 
     CPPUNIT_ASSERT_MESSAGE("Extracted contour1 has wrong number of points!", contour->GetVtkPolyData()->GetNumberOfPoints() ==
                            referenceContour->GetVtkPolyData()->GetNumberOfPoints());
 
     CPPUNIT_ASSERT_MESSAGE("Extracted contour1 has wrong number of points!", contour->GetVtkPolyData()->GetNumberOfPolys() ==
                            referenceContour->GetVtkPolyData()->GetNumberOfPolys());
 
-     CPPUNIT_ASSERT_MESSAGE("Unequal contours", mitk::Equal(contour->GetVtkPolyData(), referenceContour->GetVtkPolyData(), 0.000001, true));
+     CPPUNIT_ASSERT_MESSAGE("Unequal contours", mitk::Equal(*(contour->GetVtkPolyData()), *(referenceContour->GetVtkPolyData()), 0.000001, true));
 
   }
 };
 
 MITK_TEST_SUITE_REGISTRATION(mitkImageToContourFilter)
diff --git a/Modules/SurfaceInterpolation/Testing/mitkComputeContourSetNormalsFilterTest.cpp b/Modules/SurfaceInterpolation/Testing/mitkComputeContourSetNormalsFilterTest.cpp
index b146bb1b38..280234f504 100644
--- a/Modules/SurfaceInterpolation/Testing/mitkComputeContourSetNormalsFilterTest.cpp
+++ b/Modules/SurfaceInterpolation/Testing/mitkComputeContourSetNormalsFilterTest.cpp
@@ -1,88 +1,88 @@
 /*===================================================================
 
 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 <mitkImage.h>
 #include <mitkIOUtil.h>
 #include <mitkComputeContourSetNormalsFilter.h>
 #include <mitkSurface.h>
 #include <mitkTestFixture.h>
 #include <mitkTestingMacros.h>
 
 #include <mitkExtractSliceFilter.h>
 #include <mitkPlaneGeometry.h>
 
 class mitkComputeContourSetNormalsFilterTestSuite : public mitk::TestFixture
 {
   CPPUNIT_TEST_SUITE(mitkComputeContourSetNormalsFilterTestSuite);
   MITK_TEST(TestComputeNormals);
   MITK_TEST(TestComputeNormalsWithHole);
   CPPUNIT_TEST_SUITE_END();
 
 private:
 
   mitk::ComputeContourSetNormalsFilter::Pointer m_ContourNormalsFilter;
 
 public:
 
   void setUp()
   {
     m_ContourNormalsFilter = mitk::ComputeContourSetNormalsFilter::New();
     CPPUNIT_ASSERT_MESSAGE("Failed to initialize ReduceContourSetFilter", m_ContourNormalsFilter.IsNotNull());
   }
 
   // Compute the normals for a regular contour
   void TestComputeNormals()
   {
     mitk::Surface::Pointer contour = mitk::IOUtil::LoadSurface(GetTestDataFilePath("SurfaceInterpolation/Reference/SingleContour.vtk"));
     m_ContourNormalsFilter->SetInput(contour);
     m_ContourNormalsFilter->Update();
     // Get the computed normals (basically lines)
     mitk::Surface::Pointer normals = m_ContourNormalsFilter->GetNormalsAsSurface();
     // Get the actual surface object which has the contours stored as normals internally
     mitk::Surface::Pointer contourWithNormals = m_ContourNormalsFilter->GetOutput();
 
     mitk::Surface::Pointer referenceContour = mitk::IOUtil::LoadSurface(GetTestDataFilePath("SurfaceInterpolation/Reference/ContourWithNormals.vtk"));
     mitk::Surface::Pointer referenceNormals = mitk::IOUtil::LoadSurface(GetTestDataFilePath("SurfaceInterpolation/Reference/ContourNormals.vtk"));
 
-    CPPUNIT_ASSERT_MESSAGE("Unequal contours", mitk::Equal(contourWithNormals->GetVtkPolyData(), referenceContour->GetVtkPolyData(), 0.000001, true));
-    CPPUNIT_ASSERT_MESSAGE("Unequal contours", mitk::Equal(normals->GetVtkPolyData(), referenceNormals->GetVtkPolyData(), 0.000001, true));
+    CPPUNIT_ASSERT_MESSAGE("Unequal contours", mitk::Equal(*(contourWithNormals->GetVtkPolyData()), *(referenceContour->GetVtkPolyData()), 0.000001, true));
+    CPPUNIT_ASSERT_MESSAGE("Unequal contours", mitk::Equal(*(normals->GetVtkPolyData()), *(referenceNormals->GetVtkPolyData()), 0.000001, true));
   }
 
 
 
   // Reduce contours with Douglas Peucker
   void TestComputeNormalsWithHole()
   {
     mitk::Image::Pointer segmentationImage = mitk::IOUtil::LoadImage(GetTestDataFilePath("SurfaceInterpolation/Reference/LiverSegmentation.nrrd"));
 
     mitk::Surface::Pointer contour = mitk::IOUtil::LoadSurface(GetTestDataFilePath("SurfaceInterpolation/ComputeNormals/ContourWithHoles.vtk"));
     m_ContourNormalsFilter->SetInput(contour);
     m_ContourNormalsFilter->SetSegmentationBinaryImage(segmentationImage);
     m_ContourNormalsFilter->Update();
     mitk::Surface::Pointer contourWithNormals = m_ContourNormalsFilter->GetOutput();
     mitk::Surface::Pointer normals = m_ContourNormalsFilter->GetNormalsAsSurface();
 
     mitk::Surface::Pointer contourReference = mitk::IOUtil::LoadSurface(GetTestDataFilePath("SurfaceInterpolation/Reference/ContourWithHolesWithNormals.vtk"));
     mitk::Surface::Pointer normalsReference = mitk::IOUtil::LoadSurface(GetTestDataFilePath("SurfaceInterpolation/Reference/NormalsWithHoles.vtk"));
 
-    CPPUNIT_ASSERT_MESSAGE("Error computing normals", mitk::Equal(normals->GetVtkPolyData(), normalsReference->GetVtkPolyData(), 0.000001, true));
+    CPPUNIT_ASSERT_MESSAGE("Error computing normals", mitk::Equal(*(normals->GetVtkPolyData()), *(normalsReference->GetVtkPolyData()), 0.000001, true));
     CPPUNIT_ASSERT_MESSAGE("Error computing normals",
                            contourWithNormals->GetVtkPolyData()->GetCellData()->GetNormals()->GetNumberOfTuples() == contourReference->GetVtkPolyData()->GetNumberOfPoints());
   }
 
 };
 
 MITK_TEST_SUITE_REGISTRATION(mitkComputeContourSetNormalsFilter)
diff --git a/Modules/SurfaceInterpolation/Testing/mitkCreateDistanceImageFromSurfaceFilterTest.cpp b/Modules/SurfaceInterpolation/Testing/mitkCreateDistanceImageFromSurfaceFilterTest.cpp
index ea429d4a4a..fd7bef3d2c 100644
--- a/Modules/SurfaceInterpolation/Testing/mitkCreateDistanceImageFromSurfaceFilterTest.cpp
+++ b/Modules/SurfaceInterpolation/Testing/mitkCreateDistanceImageFromSurfaceFilterTest.cpp
@@ -1,134 +1,134 @@
 /*===================================================================
 
 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 <mitkImageAccessByItk.h>
 #include <mitkCreateDistanceImageFromSurfaceFilter.h>
 #include <mitkIOUtil.h>
 #include <mitkTestFixture.h>
 #include <mitkTestingMacros.h>
 #include <mitkComputeContourSetNormalsFilter.h>
 
 class mitkCreateDistanceImageFromSurfaceFilterTestSuite : public mitk::TestFixture
 {
   CPPUNIT_TEST_SUITE(mitkCreateDistanceImageFromSurfaceFilterTestSuite);
   MITK_TEST(TestCreateDistanceImageForLiver);
   MITK_TEST(TestCreateDistanceImageForTube);
   CPPUNIT_TEST_SUITE_END();
 
 private:
 
   std::vector<mitk::Surface::Pointer> contourList;
 
 public:
 
   void setUp()
   {
 
   }
 
   template<typename TPixel, unsigned int VImageDimension>
   void GetImageBase(itk::Image<TPixel, VImageDimension>* input, itk::ImageBase<3>::Pointer& result)
   {
     result->Graft(input);
   }
 
   // Interpolate the shape of a liver
   void TestCreateDistanceImageForLiver()
   {
     // That's the number of available liver contours in MITK-Data
     unsigned int NUMBER_OF_LIVER_CONTOURS = 18;
 
     for (unsigned int i = 0; i <= NUMBER_OF_LIVER_CONTOURS; ++i)
     {
       std::stringstream s;
       s << "SurfaceInterpolation/InterpolateLiver/LiverContourWithNormals_";
       s << i;
       s << ".vtk";
       mitk::Surface::Pointer contour = mitk::IOUtil::LoadSurface(GetTestDataFilePath(s.str()));
       contourList.push_back(contour);
     }
 
     mitk::Image::Pointer segmentationImage = mitk::IOUtil::LoadImage(GetTestDataFilePath("SurfaceInterpolation/Reference/LiverSegmentation.nrrd"));
 
     mitk::ComputeContourSetNormalsFilter::Pointer m_NormalsFilter = mitk::ComputeContourSetNormalsFilter::New();
     mitk::CreateDistanceImageFromSurfaceFilter::Pointer m_InterpolateSurfaceFilter = mitk::CreateDistanceImageFromSurfaceFilter::New();
 
     itk::ImageBase<3>::Pointer itkImage = itk::ImageBase<3>::New();
     AccessFixedDimensionByItk_1( segmentationImage, GetImageBase, 3, itkImage );
     m_InterpolateSurfaceFilter->SetReferenceImage( itkImage.GetPointer() );
 
     for (unsigned int j = 0; j < contourList.size(); j++)
     {
       m_NormalsFilter->SetInput(j, contourList.at(j));
       m_InterpolateSurfaceFilter->SetInput(j, m_NormalsFilter->GetOutput(j));
     }
 
     m_InterpolateSurfaceFilter->Update();
 
     mitk::Image::Pointer liverDistanceImage = m_InterpolateSurfaceFilter->GetOutput();
 
     CPPUNIT_ASSERT(liverDistanceImage.IsNotNull());
     mitk::Image::Pointer liverDistanceImageReference = mitk::IOUtil::LoadImage(GetTestDataFilePath("SurfaceInterpolation/Reference/LiverDistanceImage.nrrd"));
 
-    MITK_ASSERT_EQUAL(liverDistanceImageReference, liverDistanceImage, "LiverDistanceImages are not equal!");
+    CPPUNIT_ASSERT_MESSAGE("LiverDistanceImages are not equal!", mitk::Equal(*(liverDistanceImageReference), *(liverDistanceImage), 0.0001, true));
   }
 
 
 
   void TestCreateDistanceImageForTube()
   {
     // That's the number of available contours with holes in MITK-Data
     unsigned int NUMBER_OF_TUBE_CONTOURS = 5;
 
     for (unsigned int i = 0; i < NUMBER_OF_TUBE_CONTOURS; ++i)
     {
       std::stringstream s;
       s << "SurfaceInterpolation/InterpolateWithHoles/ContourWithHoles_";
       s << i;
       s << ".vtk";
       mitk::Surface::Pointer contour = mitk::IOUtil::LoadSurface(GetTestDataFilePath(s.str()));
       contourList.push_back(contour);
     }
 
     mitk::Image::Pointer segmentationImage = mitk::IOUtil::LoadImage(GetTestDataFilePath("SurfaceInterpolation/Reference/SegmentationWithHoles.nrrd"));
 
     mitk::ComputeContourSetNormalsFilter::Pointer m_NormalsFilter = mitk::ComputeContourSetNormalsFilter::New();
     mitk::CreateDistanceImageFromSurfaceFilter::Pointer m_InterpolateSurfaceFilter = mitk::CreateDistanceImageFromSurfaceFilter::New();
 
     m_NormalsFilter->SetSegmentationBinaryImage(segmentationImage);
     itk::ImageBase<3>::Pointer itkImage = itk::ImageBase<3>::New();
     AccessFixedDimensionByItk_1( segmentationImage, GetImageBase, 3, itkImage );
     m_InterpolateSurfaceFilter->SetReferenceImage( itkImage.GetPointer() );
 
     for (unsigned int j = 0; j < contourList.size(); j++)
     {
       m_NormalsFilter->SetInput(j, contourList.at(j));
       m_InterpolateSurfaceFilter->SetInput(j, m_NormalsFilter->GetOutput(j));
     }
 
     m_InterpolateSurfaceFilter->Update();
 
     mitk::Image::Pointer holeDistanceImage = m_InterpolateSurfaceFilter->GetOutput();
 
     CPPUNIT_ASSERT(holeDistanceImage.IsNotNull());
     mitk::Image::Pointer holesDistanceImageReference = mitk::IOUtil::LoadImage(GetTestDataFilePath("SurfaceInterpolation/Reference/HolesDistanceImage.nrrd"));
 
-    MITK_ASSERT_EQUAL(holesDistanceImageReference, holeDistanceImage, "HolesDistanceImages are not equal!");
+    CPPUNIT_ASSERT_MESSAGE("HolesDistanceImages are not equal!", mitk::Equal(*(holesDistanceImageReference), *(holeDistanceImage), 0.0001, true));
   }
 
 };
 
 MITK_TEST_SUITE_REGISTRATION(mitkCreateDistanceImageFromSurfaceFilter)
diff --git a/Modules/SurfaceInterpolation/Testing/mitkReduceContourSetFilterTest.cpp b/Modules/SurfaceInterpolation/Testing/mitkReduceContourSetFilterTest.cpp
index 6ead064e22..ee34878c14 100644
--- a/Modules/SurfaceInterpolation/Testing/mitkReduceContourSetFilterTest.cpp
+++ b/Modules/SurfaceInterpolation/Testing/mitkReduceContourSetFilterTest.cpp
@@ -1,74 +1,74 @@
 /*===================================================================
 
 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 <mitkImage.h>
 #include <mitkIOUtil.h>
 #include <mitkReduceContourSetFilter.h>
 #include <mitkSurface.h>
 #include <mitkTestFixture.h>
 #include <mitkTestingMacros.h>
 
 class mitkReduceContourSetFilterTestSuite : public mitk::TestFixture
 {
   CPPUNIT_TEST_SUITE(mitkReduceContourSetFilterTestSuite);
   MITK_TEST(TestReduceContourWithNthPoint);
   MITK_TEST(TestReduceContourWithDouglasPeuker);
   CPPUNIT_TEST_SUITE_END();
 
 private:
 
   mitk::ReduceContourSetFilter::Pointer m_ContourReducer;
 
 public:
 
   void setUp()
   {
     m_ContourReducer = mitk::ReduceContourSetFilter::New();
     CPPUNIT_ASSERT_MESSAGE("Failed to initialize ReduceContourSetFilter", m_ContourReducer.IsNotNull());
   }
 
   // Reduce contours with nth point
   void TestReduceContourWithNthPoint()
   {
     mitk::Surface::Pointer contour = mitk::IOUtil::LoadSurface(GetTestDataFilePath("SurfaceInterpolation/Reference/SingleContour.vtk"));
     m_ContourReducer->SetInput(contour);
     m_ContourReducer->SetReductionType(mitk::ReduceContourSetFilter::NTH_POINT);
     m_ContourReducer->SetStepSize(20);
     m_ContourReducer->Update();
     mitk::Surface::Pointer reducedContour = m_ContourReducer->GetOutput();
 
     mitk::Surface::Pointer reference = mitk::IOUtil::LoadSurface(GetTestDataFilePath("SurfaceInterpolation/Reference/ReducedContourNthPoint_20.vtk"));
 
-    CPPUNIT_ASSERT_MESSAGE("Unequal contours", mitk::Equal(reducedContour->GetVtkPolyData(), reference->GetVtkPolyData(), 0.000001, true));
+    CPPUNIT_ASSERT_MESSAGE("Unequal contours", mitk::Equal(*(reducedContour->GetVtkPolyData()), *(reference->GetVtkPolyData()), 0.000001, true));
   }
 
   // Reduce contours with Douglas Peucker
   void TestReduceContourWithDouglasPeuker()
   {
     mitk::Surface::Pointer contour = mitk::IOUtil::LoadSurface(GetTestDataFilePath("SurfaceInterpolation/Reference/TwoContours.vtk"));
     m_ContourReducer->SetInput(contour);
     m_ContourReducer->SetReductionType(mitk::ReduceContourSetFilter::DOUGLAS_PEUCKER);
     m_ContourReducer->Update();
     mitk::Surface::Pointer reducedContour = m_ContourReducer->GetOutput();
 
     mitk::Surface::Pointer reference = mitk::IOUtil::LoadSurface(GetTestDataFilePath("SurfaceInterpolation/Reference/ReducedContourDouglasPeucker.vtk"));
 
-    CPPUNIT_ASSERT_MESSAGE("Unequal contours", mitk::Equal(reducedContour->GetVtkPolyData(), reference->GetVtkPolyData(), 0.000001, true));
+    CPPUNIT_ASSERT_MESSAGE("Unequal contours", mitk::Equal(*(reducedContour->GetVtkPolyData()), *(reference->GetVtkPolyData()), 0.000001, true));
   }
 
 };
 
 MITK_TEST_SUITE_REGISTRATION(mitkReduceContourSetFilter)