diff --git a/Modules/Segmentation/Interactions/mitkSegTool2D.h b/Modules/Segmentation/Interactions/mitkSegTool2D.h
index 56b0759f99..a6a07efe19 100644
--- a/Modules/Segmentation/Interactions/mitkSegTool2D.h
+++ b/Modules/Segmentation/Interactions/mitkSegTool2D.h
@@ -1,181 +1,181 @@
 /*===================================================================
 
 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 mitkSegTool2D_h_Included
 #define mitkSegTool2D_h_Included
 
 #include "mitkCommon.h"
 #include <MitkSegmentationExports.h>
 #include "mitkTool.h"
 #include "mitkImage.h"
 
 #include "mitkStateEvent.h"
 #include "mitkInteractionPositionEvent.h"
 
 #include "mitkPlanePositionManager.h"
 #include "mitkRestorePlanePositionOperation.h"
 #include "mitkInteractionConst.h"
 
 #include <mitkDiffSliceOperation.h>
 
 
 namespace mitk
 {
 
 class BaseRenderer;
 
 /**
   \brief Abstract base class for segmentation tools.
 
   \sa Tool
 
   \ingroup Interaction
   \ingroup ToolManagerEtAl
 
   Implements 2D segmentation specific helper methods, that might be of use to
   all kind of 2D segmentation tools. At the moment these are:
    - Determination of the slice where the user paints upon (DetermineAffectedImageSlice)
    - Projection of a 3D contour onto a 2D plane/slice
 
    SegTool2D tries to structure the interaction a bit. If you pass "PressMoveRelease" as the interaction type
    of your derived tool, you might implement the methods OnMousePressed, OnMouseMoved, and OnMouseReleased.
    Yes, your guess about when they are called is correct.
 
   \warning Only to be instantiated by mitk::ToolManager.
 
   $Author$
 */
 class MitkSegmentation_EXPORT SegTool2D : public Tool
 {
   public:
 
     mitkClassMacro(SegTool2D, Tool);
 
     /**
       \brief Calculates for a given Image and PlaneGeometry, which slice of the image (in index corrdinates) is meant by the plane.
 
       \return false, if no slice direction seems right (e.g. rotated planes)
       \param affectedDimension The image dimension, which is constant for all points in the plane, e.g. Axial --> 2
       \param affectedSlice The index of the image slice
     */
     static bool DetermineAffectedImageSlice( const Image* image, const PlaneGeometry* plane, int& affectedDimension, int& affectedSlice );
 
     /**
      * @brief Updates the surface interpolation by extracting the contour form the given slice.
      * @param slice the slice from which the contour should be extracted
      * @param workingImage the segmentation image
      * @param plane the plane in which the slice lies
      * @param detectIntersection if true the slice is eroded before contour extraction. If the slice is empty after the erosion it is most
      *        likely an intersecting contour an will not be added to the SurfaceInterpolationController
      */
-    static void UpdateSurfaceInterpolation (const Image* slice, const Image* workingImage, PlaneGeometry *plane, bool detectIntersection);
+    static void UpdateSurfaceInterpolation (const Image* slice, const Image* workingImage, const PlaneGeometry *plane, bool detectIntersection);
 
     void SetShowMarkerNodes(bool);
 
     /**
      * \brief Enables or disables the 3D interpolation after writing back the 2D segmentation result, and defaults to true.
      */
     void SetEnable3DInterpolation(bool);
 
   protected:
 
     SegTool2D(); // purposely hidden
     SegTool2D(const char*); // purposely hidden
     virtual ~SegTool2D();
 
     struct SliceInformation
     {
       mitk::Image::Pointer slice;
       mitk::PlaneGeometry* plane;
       unsigned int timestep;
 
       SliceInformation () {}
 
       SliceInformation (mitk::Image* slice, mitk::PlaneGeometry* plane, unsigned int timestep)
       {
         this->slice = slice;
         this->plane = plane;
         this->timestep = timestep;
       }
 
     };
 
     /**
     * \brief Calculates how good the data, this statemachine handles, is hit by the event.
     *
     */
     virtual float CanHandleEvent( InteractionEvent const *stateEvent) const;
 
     /**
       \brief Extract the slice of an image that the user just scribbles on.
       \return NULL if SegTool2D is either unable to determine which slice was affected, or if there was some problem getting the image data at that position.
     */
     Image::Pointer GetAffectedImageSliceAs2DImage(const InteractionPositionEvent*, const Image* image);
 
     /**
       \brief Extract the slice of an image cut by given plane.
       \return NULL if SegTool2D is either unable to determine which slice was affected, or if there was some problem getting the image data at that position.
     */
     Image::Pointer GetAffectedImageSliceAs2DImage(const PlaneGeometry* planeGeometry, const Image* image, unsigned int timeStep);
 
     /**
       \brief Extract the slice of the currently selected working image that the user just scribbles on.
       \return NULL if SegTool2D is either unable to determine which slice was affected, or if there was some problem getting the image data at that position,
                    or just no working image is selected.
     */
     Image::Pointer GetAffectedWorkingSlice(const InteractionPositionEvent*);
 
     /**
       \brief Extract the slice of the currently selected reference image that the user just scribbles on.
       \return NULL if SegTool2D is either unable to determine which slice was affected, or if there was some problem getting the image data at that position,
                    or just no reference image is selected.
     */
     Image::Pointer GetAffectedReferenceSlice(const InteractionPositionEvent*);
 
     void WriteBackSegmentationResult (const InteractionPositionEvent*, Image*);
 
     void WriteBackSegmentationResult (const PlaneGeometry* planeGeometry, Image*, unsigned int timeStep);
 
     void WriteBackSegmentationResult (std::vector<SliceInformation> sliceList);
 
     /**
       \brief Adds a new node called Contourmarker to the datastorage which holds a mitk::PlanarFigure.
              By selecting this node the slicestack will be reoriented according to the PlanarFigure's Geometry
     */
     unsigned int AddContourmarker ();
 
     void InteractiveSegmentationBugMessage( const std::string& message );
 
     BaseRenderer*         m_LastEventSender;
     unsigned int          m_LastEventSlice;
 
   private:
 
     void WriteSliceToVolume (SliceInformation sliceInfo);
 
     //The prefix of the contourmarkername. Suffix is a consecutive number
     const std::string     m_Contourmarkername;
 
     bool m_ShowMarkerNodes;
     static bool m_SurfaceInterpolationEnabled;
 
     DiffSliceOperation* m_doOperation;
     DiffSliceOperation* m_undoOperation;
 };
 
 } // namespace
 
 #endif
diff --git a/Modules/SurfaceInterpolation/Testing/mitkSurfaceInterpolationControllerTest.cpp b/Modules/SurfaceInterpolation/Testing/mitkSurfaceInterpolationControllerTest.cpp
index 0c91adc88b..9dd29fa6a9 100644
--- a/Modules/SurfaceInterpolation/Testing/mitkSurfaceInterpolationControllerTest.cpp
+++ b/Modules/SurfaceInterpolation/Testing/mitkSurfaceInterpolationControllerTest.cpp
@@ -1,388 +1,388 @@
 /*===================================================================
 
 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 <mitkSurfaceInterpolationController.h>
 #include <mitkTestFixture.h>
 #include <mitkTestingMacros.h>
 
 #include <vtkRegularPolygonSource.h>
 
 class mitkSurfaceInterpolationControllerTestSuite : public mitk::TestFixture
 {
   CPPUNIT_TEST_SUITE(mitkSurfaceInterpolationControllerTestSuite);
   MITK_TEST(TestSingleton);
   MITK_TEST(TestSetCurrentInterpolationSession);
   MITK_TEST(TestRemoveAllInterpolationSessions);
   MITK_TEST(TestRemoveInterpolationSession);
   MITK_TEST(TestOnSegmentationDeleted);
   MITK_TEST(TestAddNewContour);
   MITK_TEST(TestRemoveContour);
   CPPUNIT_TEST_SUITE_END();
 
 private:
 
   mitk::SurfaceInterpolationController::Pointer m_Controller;
 
 public:
 
   mitk::Image::Pointer createImage(unsigned int *dimensions)
   {
     mitk::Image::Pointer newImage = mitk::Image::New();
     mitk::PixelType p_type = mitk::MakeScalarPixelType<unsigned char>();
     newImage->Initialize(p_type, 3, dimensions);
     return newImage;
   }
 
-  mitk::PlaneGeometry::Pointer createPlaneForContour(mitk::Geometry3D* geo, vtkPolyData* contour, mitk::PlaneGeometry::PlaneOrientation orientation)
+  const mitk::PlaneGeometry* createPlaneForContour(mitk::Geometry3D* geo, vtkPolyData* contour, mitk::PlaneGeometry::PlaneOrientation orientation)
   {
     mitk::PlaneGeometry::Pointer plane = mitk::PlaneGeometry::New();
     mitk::Point3D p = contour->GetPoint(0);
     geo->WorldToIndex(p,p);
     unsigned int sliceIndex;
     if (orientation == mitk::PlaneGeometry::Axial)
     {
       sliceIndex = p[2];
     }
     else if (orientation == mitk::PlaneGeometry::Sagittal)
     {
       sliceIndex = p[0];
     }
     else
     {
       sliceIndex = p[1];
     }
     plane->InitializeStandardPlane(geo, orientation, sliceIndex, true, false);
     mitk::Point3D origin = plane->GetOrigin();
     mitk::Vector3D normal;
     normal = plane->GetNormal();
     normal.Normalize();
     origin += normal * 0.5;
     plane->SetOrigin(origin);
     return plane;
   }
 
   void setUp()
   {
     m_Controller = mitk::SurfaceInterpolationController::GetInstance();
 
     vtkSmartPointer<vtkRegularPolygonSource> polygonSource = vtkSmartPointer<vtkRegularPolygonSource>::New();
     polygonSource->SetRadius(100);
     polygonSource->SetNumberOfSides(7);
     polygonSource->Update();
     mitk::Surface::Pointer surface = mitk::Surface::New();
     surface->SetVtkPolyData(polygonSource->GetOutput());
   }
 
   void TestSingleton()
   {
     mitk::SurfaceInterpolationController::Pointer controller2 = mitk::SurfaceInterpolationController::GetInstance();
     CPPUNIT_ASSERT_MESSAGE("SurfaceInterpolationController pointers are not equal!", m_Controller.GetPointer() == controller2.GetPointer());
   }
 
   void TestSetCurrentInterpolationSession()
   {
     // Create image for testing
     unsigned int dimensions1[] = {10, 10, 10};
     mitk::Image::Pointer segmentation_1 = createImage(dimensions1);
 
     unsigned int dimensions2[] = {20, 10, 30};
     mitk::Image::Pointer segmentation_2 = createImage(dimensions2);
 
     // Test 1
     m_Controller->SetCurrentInterpolationSession(segmentation_1);
     MITK_ASSERT_EQUAL(m_Controller->GetCurrentSegmentation(), segmentation_1->Clone(), "Segmentation images are not equal");
     CPPUNIT_ASSERT_MESSAGE("Segmentation images are not equal", m_Controller->GetCurrentSegmentation().GetPointer() == segmentation_1.GetPointer());
     CPPUNIT_ASSERT_MESSAGE("Number of interpolation session not 1", m_Controller->GetNumberOfInterpolationSessions() == 1);
 
     // Test 2
     m_Controller->SetCurrentInterpolationSession(segmentation_2);
     MITK_ASSERT_EQUAL(m_Controller->GetCurrentSegmentation(), segmentation_2->Clone(), "Segmentation images are not equal");
     CPPUNIT_ASSERT_MESSAGE("Segmentation images are not equal", m_Controller->GetCurrentSegmentation().GetPointer() == segmentation_2.GetPointer());
     CPPUNIT_ASSERT_MESSAGE("Number of interpolation session not 2", m_Controller->GetNumberOfInterpolationSessions() == 2);
 
     // Test 3
     m_Controller->SetCurrentInterpolationSession(segmentation_1);
     MITK_ASSERT_EQUAL(m_Controller->GetCurrentSegmentation(), segmentation_1->Clone(), "Segmentation images are not equal");
     CPPUNIT_ASSERT_MESSAGE("Segmentation images are not equal", m_Controller->GetCurrentSegmentation().GetPointer() == segmentation_1.GetPointer());
     CPPUNIT_ASSERT_MESSAGE("Number of interpolation session not 2", m_Controller->GetNumberOfInterpolationSessions() == 2);
 
     // Test 4
     m_Controller->SetCurrentInterpolationSession(segmentation_1);
     MITK_ASSERT_EQUAL(m_Controller->GetCurrentSegmentation(), segmentation_1->Clone(), "Segmentation images are not equal");
     CPPUNIT_ASSERT_MESSAGE("Segmentation images are not equal", m_Controller->GetCurrentSegmentation().GetPointer() == segmentation_1.GetPointer());
     CPPUNIT_ASSERT_MESSAGE("Number of interpolation session not 2", m_Controller->GetNumberOfInterpolationSessions() == 2);
 
     // Test 5
     m_Controller->SetCurrentInterpolationSession(0);
     CPPUNIT_ASSERT_MESSAGE("Segmentation images are not equal", m_Controller->GetCurrentSegmentation().IsNull());
     CPPUNIT_ASSERT_MESSAGE("Number of interpolation session not 2", m_Controller->GetNumberOfInterpolationSessions() == 2);
   }
 
   void TestRemoveAllInterpolationSessions()
   {
     // Create image for testing
     unsigned int dimensions1[] = {10, 10, 10};
     mitk::Image::Pointer segmentation_1 = createImage(dimensions1);
 
     unsigned int dimensions2[] = {20, 10, 30};
     mitk::Image::Pointer segmentation_2 = createImage(dimensions2);
 
     // Test 1
     m_Controller->SetCurrentInterpolationSession(segmentation_1);
     m_Controller->SetCurrentInterpolationSession(segmentation_2);
     m_Controller->RemoveAllInterpolationSessions();
     CPPUNIT_ASSERT_MESSAGE("Number of interpolation session not 0", m_Controller->GetNumberOfInterpolationSessions() == 0);
   }
 
   void TestRemoveInterpolationSession()
   {
     // Create image for testing
     unsigned int dimensions1[] = {10, 10, 10};
     mitk::Image::Pointer segmentation_1 = createImage(dimensions1);
 
     unsigned int dimensions2[] = {20, 10, 30};
     mitk::Image::Pointer segmentation_2 = createImage(dimensions2);
 
     // Test 1
     m_Controller->SetCurrentInterpolationSession(segmentation_1);
     m_Controller->SetCurrentInterpolationSession(segmentation_2);
     CPPUNIT_ASSERT_MESSAGE("Number of interpolation session not 2", m_Controller->GetNumberOfInterpolationSessions() == 2);
 
     // Test current segmentation should not be null if another one was removed
     m_Controller->RemoveInterpolationSession(segmentation_1);
     CPPUNIT_ASSERT_MESSAGE("Number of interpolation session not 1", m_Controller->GetNumberOfInterpolationSessions() == 1);
     CPPUNIT_ASSERT_MESSAGE("Segmentation images are not equal", m_Controller->GetCurrentSegmentation().GetPointer() == segmentation_2.GetPointer());
     CPPUNIT_ASSERT_MESSAGE("Current segmentation is null after another one was removed", m_Controller->GetCurrentSegmentation().IsNotNull());
 
     m_Controller->SetCurrentInterpolationSession(segmentation_1);
     CPPUNIT_ASSERT_MESSAGE("Number of interpolation session not 2", m_Controller->GetNumberOfInterpolationSessions() == 2);
 
     // Test current segmentation should not be null if another one was removed
     m_Controller->RemoveInterpolationSession(segmentation_1);
     CPPUNIT_ASSERT_MESSAGE("Number of interpolation session not 1", m_Controller->GetNumberOfInterpolationSessions() == 1);
     CPPUNIT_ASSERT_MESSAGE("Current segmentation is not null after session was removed", m_Controller->GetCurrentSegmentation().IsNull());
   }
 
 
   void TestOnSegmentationDeleted()
   {
     {
       // Create image for testing
       unsigned int dimensions1[] = {10, 10, 10};
       mitk::Image::Pointer segmentation_1 = createImage(dimensions1);
       m_Controller->SetCurrentInterpolationSession(segmentation_1);
     }
     CPPUNIT_ASSERT_MESSAGE("Number of interpolation session not 0", m_Controller->GetNumberOfInterpolationSessions() == 0);
   }
 
 
   void TestAddNewContour()
   {
     // Create segmentation image
     unsigned int dimensions1[] = {10, 10, 10};
     mitk::Image::Pointer segmentation_1 = createImage(dimensions1);
     mitk::Geometry3D* geo_1 = segmentation_1->GetGeometry();
     m_Controller->SetCurrentInterpolationSession(segmentation_1);
 
     // Create some contours
     vtkSmartPointer<vtkRegularPolygonSource> p_source = vtkSmartPointer<vtkRegularPolygonSource>::New();
     p_source->SetNumberOfSides(20);
     p_source->SetCenter(4.0,4.0,4.0);
     p_source->SetRadius(4);
     p_source->SetNormal(0,1,0);
     p_source->Update();
     vtkPolyData* poly_1 = p_source->GetOutput();
     mitk::Surface::Pointer surf_1 = mitk::Surface::New();
     surf_1->SetVtkPolyData(poly_1);
 
     vtkSmartPointer<vtkRegularPolygonSource> p_source_2 = vtkSmartPointer<vtkRegularPolygonSource>::New();
     p_source_2->SetNumberOfSides(80);
     p_source_2->SetCenter(4.0,4.0,4.0);
     p_source_2->SetRadius(4);
     p_source_2->SetNormal(1, 0, 0);
     p_source_2->Update();
     vtkPolyData* poly_2 = p_source_2->GetOutput();
     mitk::Surface::Pointer surf_2 = mitk::Surface::New();
     surf_2->SetVtkPolyData(poly_2);
 
     vtkSmartPointer<vtkRegularPolygonSource> p_source_3 = vtkSmartPointer<vtkRegularPolygonSource>::New();
     p_source_3->SetNumberOfSides(10);
     p_source_3->SetCenter(4.0,4.0,3.0);
     p_source_3->SetRadius(4);
     p_source_3->SetNormal(0,0,1);
     p_source_3->Update();
     vtkPolyData* poly_3 = p_source_3->GetOutput();
     mitk::Surface::Pointer surf_3 = mitk::Surface::New();
     surf_3->SetVtkPolyData(poly_3);
 
     // Create planes for contours
-    mitk::PlaneGeometry::Pointer plane_1 = createPlaneForContour(geo_1, poly_1, mitk::PlaneGeometry::Frontal);
-    mitk::PlaneGeometry::Pointer plane_2 = createPlaneForContour(geo_1, poly_2, mitk::PlaneGeometry::Sagittal);
-    mitk::PlaneGeometry::Pointer plane_3 = createPlaneForContour(geo_1, poly_3, mitk::PlaneGeometry::Axial);
+    mitk::PlaneGeometry::ConstPointer plane_1 = createPlaneForContour(geo_1, poly_1, mitk::PlaneGeometry::Frontal);
+    mitk::PlaneGeometry::ConstPointer plane_2 = createPlaneForContour(geo_1, poly_2, mitk::PlaneGeometry::Sagittal);
+    mitk::PlaneGeometry::ConstPointer plane_3 = createPlaneForContour(geo_1, poly_3, mitk::PlaneGeometry::Axial);
 
     // Add contours
     m_Controller->AddNewContour(surf_1, plane_1);
     m_Controller->AddNewContour(surf_2, plane_2);
     m_Controller->AddNewContour(surf_3, plane_3);
 
     // Check if all contours are there
-    mitk::PlaneGeometry::Pointer plane_1_clone = plane_1->Clone();
-    mitk::PlaneGeometry::Pointer plane_2_clone = plane_2->Clone();
-    mitk::PlaneGeometry::Pointer plane_3_clone = plane_3->Clone();
+    mitk::PlaneGeometry::ConstPointer plane_1_clone = const_cast<const mitk::PlaneGeometry*>(plane_1->Clone().GetPointer());
+    mitk::PlaneGeometry::ConstPointer plane_2_clone = const_cast<const mitk::PlaneGeometry*>(plane_2->Clone().GetPointer());
+    mitk::PlaneGeometry::ConstPointer plane_3_clone = const_cast<const mitk::PlaneGeometry*>(plane_3->Clone().GetPointer());
     mitk::Surface* contour_1 = const_cast<mitk::Surface*>(m_Controller->GetContour(plane_1_clone));
     mitk::Surface* contour_2 = const_cast<mitk::Surface*>(m_Controller->GetContour(plane_2_clone));
     mitk::Surface* contour_3 = const_cast<mitk::Surface*>(m_Controller->GetContour(plane_3_clone));
     CPPUNIT_ASSERT_MESSAGE("Wrong number of contours!", m_Controller->GetNumberOfContours() == 3);
     CPPUNIT_ASSERT_MESSAGE("Contours not equal!", mitk::Equal(*(surf_1->GetVtkPolyData()), *(contour_1->GetVtkPolyData()), 0.000001, true));
     CPPUNIT_ASSERT_MESSAGE("Contours not equal!", mitk::Equal(*(surf_2->GetVtkPolyData()), *(contour_2->GetVtkPolyData()), 0.000001, true));
     CPPUNIT_ASSERT_MESSAGE("Contours not equal!", mitk::Equal(*(surf_3->GetVtkPolyData()), *(contour_3->GetVtkPolyData()), 0.000001, true));
 
 
     // Create another segmentation image
     unsigned int dimensions2[] = {20, 20, 20};
     mitk::Image::Pointer segmentation_2 = createImage(dimensions2);
     mitk::Geometry3D* geo_2 = segmentation_2->GetGeometry();
     m_Controller->SetCurrentInterpolationSession(segmentation_2);
 
     // Create some contours
     p_source->SetNumberOfSides(8);
     p_source->SetCenter(10.0,10.0,10.0);
     p_source->SetRadius(5);
     p_source->SetNormal(0,1,0);
     p_source->Update();
     vtkPolyData* poly_4 = p_source->GetOutput();
     mitk::Surface::Pointer surf_4 = mitk::Surface::New();
     surf_4->SetVtkPolyData(poly_4);
 
     p_source_2->SetNumberOfSides(16);
     p_source_2->SetCenter(3.0,10.0,10.0);
     p_source_2->SetRadius(8);
     p_source_2->SetNormal(1, 0, 0);
     p_source_2->Update();
     vtkPolyData* poly_5 = p_source_2->GetOutput();
     mitk::Surface::Pointer surf_5 = mitk::Surface::New();
     surf_5->SetVtkPolyData(poly_5);
 
     p_source_3->SetNumberOfSides(100);
     p_source_3->SetCenter(10.0,10.0,3.0);
     p_source_3->SetRadius(5);
     p_source_3->SetNormal(0,0,1);
     p_source_3->Update();
     vtkPolyData* poly_6 = p_source_3->GetOutput();
     mitk::Surface::Pointer surf_6 = mitk::Surface::New();
     surf_6->SetVtkPolyData(poly_6);
 
     // Create planes for contours
-    mitk::PlaneGeometry::Pointer plane_4 = createPlaneForContour(geo_2, poly_4, mitk::PlaneGeometry::Frontal);
-    mitk::PlaneGeometry::Pointer plane_5 = createPlaneForContour(geo_2, poly_5, mitk::PlaneGeometry::Sagittal);
-    mitk::PlaneGeometry::Pointer plane_6 = createPlaneForContour(geo_2, poly_6, mitk::PlaneGeometry::Axial);
+    mitk::PlaneGeometry::ConstPointer plane_4 = createPlaneForContour(geo_2, poly_4, mitk::PlaneGeometry::Frontal);
+    mitk::PlaneGeometry::ConstPointer plane_5 = createPlaneForContour(geo_2, poly_5, mitk::PlaneGeometry::Sagittal);
+    mitk::PlaneGeometry::ConstPointer plane_6 = createPlaneForContour(geo_2, poly_6, mitk::PlaneGeometry::Axial);
 
     // Add contours
     m_Controller->AddNewContour(surf_4, plane_4);
     m_Controller->AddNewContour(surf_5, plane_5);
     m_Controller->AddNewContour(surf_6, plane_6);
 
     // Check if all contours are there
-    mitk::PlaneGeometry::Pointer plane_4_clone = plane_4->Clone();
-    mitk::PlaneGeometry::Pointer plane_5_clone = plane_5->Clone();
-    mitk::PlaneGeometry::Pointer plane_6_clone = plane_6->Clone();
+    mitk::PlaneGeometry::ConstPointer plane_4_clone = const_cast<const mitk::PlaneGeometry*>(plane_4->Clone().GetPointer());
+    mitk::PlaneGeometry::ConstPointer plane_5_clone = const_cast<const mitk::PlaneGeometry*>(plane_5->Clone().GetPointer());
+    mitk::PlaneGeometry::ConstPointer plane_6_clone = const_cast<const mitk::PlaneGeometry*>(plane_6->Clone().GetPointer());
     mitk::Surface* contour_4 = const_cast<mitk::Surface*>(m_Controller->GetContour(plane_4_clone));
     mitk::Surface* contour_5 = const_cast<mitk::Surface*>(m_Controller->GetContour(plane_5_clone));
     mitk::Surface* contour_6 = const_cast<mitk::Surface*>(m_Controller->GetContour(plane_6_clone));
     CPPUNIT_ASSERT_MESSAGE("Wrong number of contours!", m_Controller->GetNumberOfContours() == 3);
     CPPUNIT_ASSERT_MESSAGE("Contours not equal!", mitk::Equal(*(surf_4->GetVtkPolyData()), *(contour_4->GetVtkPolyData()), 0.000001, true));
     CPPUNIT_ASSERT_MESSAGE("Contours not equal!", mitk::Equal(*(surf_5->GetVtkPolyData()), *(contour_5->GetVtkPolyData()), 0.000001, true));
     CPPUNIT_ASSERT_MESSAGE("Contours not equal!", mitk::Equal(*(surf_6->GetVtkPolyData()), *(contour_6->GetVtkPolyData()), 0.000001, true));
 
     // Modify some contours
     p_source_2->SetNumberOfSides(200);
     p_source_2->SetCenter(3.0,10.0,10.0);
     p_source_2->SetRadius(5);
     p_source_2->SetNormal(1, 0, 0);
     p_source_2->Update();
     vtkPolyData* poly_7 = p_source_2->GetOutput();
     mitk::Surface::Pointer surf_7 = mitk::Surface::New();
     surf_7->SetVtkPolyData(poly_7);
 
     m_Controller->AddNewContour(surf_7, plane_5);
     mitk::Surface* contour_7 = const_cast<mitk::Surface*>(m_Controller->GetContour(plane_5_clone));
     CPPUNIT_ASSERT_MESSAGE("Contours not equal!", mitk::Equal(*(surf_7->GetVtkPolyData()), *(contour_7->GetVtkPolyData()), 0.000001, true));
 
     // Change session and test if all contours are available
     m_Controller->SetCurrentInterpolationSession(segmentation_1);
     mitk::Surface* contour_8 = const_cast<mitk::Surface*>(m_Controller->GetContour(plane_1_clone));
     mitk::Surface* contour_9 = const_cast<mitk::Surface*>(m_Controller->GetContour(plane_2_clone));
     mitk::Surface* contour_10 = const_cast<mitk::Surface*>(m_Controller->GetContour(plane_3_clone));
     CPPUNIT_ASSERT_MESSAGE("Wrong number of contours!", m_Controller->GetNumberOfContours() == 3);
     CPPUNIT_ASSERT_MESSAGE("Contours not equal!", mitk::Equal(*(surf_1->GetVtkPolyData()), *(contour_8->GetVtkPolyData()), 0.000001, true));
     CPPUNIT_ASSERT_MESSAGE("Contours not equal!", mitk::Equal(*(surf_2->GetVtkPolyData()), *(contour_9->GetVtkPolyData()), 0.000001, true));
     CPPUNIT_ASSERT_MESSAGE("Contours not equal!", mitk::Equal(*(surf_3->GetVtkPolyData()), *(contour_10->GetVtkPolyData()), 0.000001, true));
   }
 
   void TestRemoveContour()
   {
     // Create segmentation image
     unsigned int dimensions1[] = {10, 10, 10};
     mitk::Image::Pointer segmentation_1 = createImage(dimensions1);
     mitk::Geometry3D* geo_1 = segmentation_1->GetGeometry();
     m_Controller->SetCurrentInterpolationSession(segmentation_1);
 
     // Create some contours
     vtkSmartPointer<vtkRegularPolygonSource> p_source = vtkSmartPointer<vtkRegularPolygonSource>::New();
     p_source->SetNumberOfSides(20);
     p_source->SetCenter(4.0,4.0,4.0);
     p_source->SetRadius(4);
     p_source->SetNormal(0,1,0);
     p_source->Update();
     vtkPolyData* poly_1 = p_source->GetOutput();
     mitk::Surface::Pointer surf_1 = mitk::Surface::New();
     surf_1->SetVtkPolyData(poly_1);
 
     vtkSmartPointer<vtkRegularPolygonSource> p_source_2 = vtkSmartPointer<vtkRegularPolygonSource>::New();
     p_source_2->SetNumberOfSides(80);
     p_source_2->SetCenter(4.0,4.0,4.0);
     p_source_2->SetRadius(4);
     p_source_2->SetNormal(1, 0, 0);
     p_source_2->Update();
     vtkPolyData* poly_2 = p_source_2->GetOutput();
     mitk::Surface::Pointer surf_2 = mitk::Surface::New();
     surf_2->SetVtkPolyData(poly_2);
 
     // Create planes for contours
-    mitk::PlaneGeometry::Pointer plane_1 = createPlaneForContour(geo_1, poly_1, mitk::PlaneGeometry::Frontal);
-    mitk::PlaneGeometry::Pointer plane_2 = createPlaneForContour(geo_1, poly_2, mitk::PlaneGeometry::Sagittal);
+    mitk::PlaneGeometry::ConstPointer plane_1 = createPlaneForContour(geo_1, poly_1, mitk::PlaneGeometry::Frontal);
+    mitk::PlaneGeometry::ConstPointer plane_2 = createPlaneForContour(geo_1, poly_2, mitk::PlaneGeometry::Sagittal);
 
     // Add contours
     m_Controller->AddNewContour(surf_1, plane_1);
     m_Controller->AddNewContour(surf_2, plane_2);
     MITK_INFO<<"[NUM CONTOURS]: "<<m_Controller->GetNumberOfContours();
     CPPUNIT_ASSERT_MESSAGE("Wrong number of contours!", m_Controller->GetNumberOfContours() == 2);
 
     // Remove a contour
     bool success = m_Controller->RemoveContour(plane_1);
     CPPUNIT_ASSERT_MESSAGE("Remove failed - contour not removed correctly!", (m_Controller->GetNumberOfContours() == 1) && success);
 
     // Test remove non existing contour
     mitk::PlaneGeometry::Pointer plane_3 = plane_1->Clone();
     mitk::Point3D origin = plane_3->GetOrigin();
     origin += 0.5;
     plane_3->SetOrigin(origin);
 
     success = m_Controller->RemoveContour(plane_3);
     CPPUNIT_ASSERT_MESSAGE("Remove failed - contour was unintentionally removed!", (m_Controller->GetNumberOfContours() == 1) && !success);
   }
 };
 MITK_TEST_SUITE_REGISTRATION(mitkSurfaceInterpolationController)
diff --git a/Modules/SurfaceInterpolation/mitkSurfaceInterpolationController.cpp b/Modules/SurfaceInterpolation/mitkSurfaceInterpolationController.cpp
index e472f43e5b..6d58423c11 100644
--- a/Modules/SurfaceInterpolation/mitkSurfaceInterpolationController.cpp
+++ b/Modules/SurfaceInterpolation/mitkSurfaceInterpolationController.cpp
@@ -1,432 +1,432 @@
 /*===================================================================
 
 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 "mitkSurfaceInterpolationController.h"
 #include "mitkMemoryUtilities.h"
 #include "mitkImageAccessByItk.h"
 #include "mitkImageCast.h"
 
 #include "mitkImageToSurfaceFilter.h"
 
 // TODO Use Equal of BaseGeometry instead after master merge!
-bool PlanesEqual (mitk::PlaneGeometry::Pointer leftHandSide, mitk::PlaneGeometry::Pointer rightHandSide, mitk::ScalarType eps)
+bool PlanesEqual (mitk::PlaneGeometry::ConstPointer leftHandSide, mitk::PlaneGeometry::ConstPointer rightHandSide, mitk::ScalarType eps)
 {
   bool result = true;
 
   //Compare spacings
   if( !mitk::Equal( leftHandSide->GetSpacing(), rightHandSide->GetSpacing(), eps ) )
   {
     result = false;
   }
 
   //Compare Origins
   if( !mitk::Equal( leftHandSide->GetOrigin(), rightHandSide->GetOrigin(), eps ) )
   {
     result = false;
   }
 
   //Compare Axis and Extents
   for( unsigned int i=0; i<3; ++i)
   {
     if( !mitk::Equal( leftHandSide->GetAxisVector(i), rightHandSide->GetAxisVector(i), eps))
     {
       result =  false;
     }
 
     if( !mitk::Equal( leftHandSide->GetExtent(i), rightHandSide->GetExtent(i), eps) )
     {
       result = false;
     }
   }
 
   //Compare ImageGeometry Flag
   if( rightHandSide->GetImageGeometry() != leftHandSide->GetImageGeometry() )
   {
     result = false;
   }
 
   //Compare IndexToWorldTransform Matrix
   if( !mitk::MatrixEqualElementWise( leftHandSide->GetIndexToWorldTransform()->GetMatrix(), rightHandSide->GetIndexToWorldTransform()->GetMatrix(), eps) )
   {
     result = false;
   }
   return result;
 }
 
 mitk::SurfaceInterpolationController::SurfaceInterpolationController()
   :m_SelectedSegmentation(0)
 {
   m_ReduceFilter = ReduceContourSetFilter::New();
   m_NormalsFilter = ComputeContourSetNormalsFilter::New();
   m_InterpolateSurfaceFilter = CreateDistanceImageFromSurfaceFilter::New();
 
   m_ReduceFilter->SetUseProgressBar(false);
   m_NormalsFilter->SetUseProgressBar(false);
   m_InterpolateSurfaceFilter->SetUseProgressBar(false);
 
   m_Contours = Surface::New();
 
   m_PolyData = vtkSmartPointer<vtkPolyData>::New();
   m_PolyData->SetPoints(vtkPoints::New());
 
   m_InterpolationResult = 0;
   m_CurrentNumberOfReducedContours = 0;
 }
 
 mitk::SurfaceInterpolationController::~SurfaceInterpolationController()
 {
   //Removing all observers
   std::map<mitk::Image*, unsigned long>::iterator dataIter = m_SegmentationObserverTags.begin();
   for (; dataIter != m_SegmentationObserverTags.end(); ++dataIter )
   {
     (*dataIter).first->RemoveObserver( (*dataIter).second );
   }
   m_SegmentationObserverTags.clear();
 }
 
 mitk::SurfaceInterpolationController* mitk::SurfaceInterpolationController::GetInstance()
 {
   static mitk::SurfaceInterpolationController* m_Instance;
 
   if ( m_Instance == 0)
   {
     m_Instance = new SurfaceInterpolationController();
   }
   return m_Instance;
 }
 
-void mitk::SurfaceInterpolationController::AddNewContour (mitk::Surface::Pointer newContour, PlaneGeometry::Pointer plane)
+void mitk::SurfaceInterpolationController::AddNewContour (mitk::Surface::Pointer newContour, PlaneGeometry::ConstPointer plane)
 {
   ContourPositionPair pair;
   pair.contour = newContour;
   pair.plane = plane;
   this->AddToInterpolationPipeline(pair);
 
   this->Modified();
 }
 
 void mitk::SurfaceInterpolationController::AddNewContours(ContourPositionPairList newContours)
 {
   for (unsigned int i = 0; i < newContours.size(); ++i)
   {
     this->AddToInterpolationPipeline(newContours.at(i));
   }
   this->Modified();
 }
 
 void mitk::SurfaceInterpolationController::AddToInterpolationPipeline(ContourPositionPair pair)
 {
   int pos (-1);
   ContourPositionPairList currentContourList = m_ListOfInterpolationSessions[m_SelectedSegmentation];
-  mitk::PlaneGeometry* plane = pair.plane;
+  const mitk::PlaneGeometry* plane = pair.plane;
   mitk::Surface* newContour = pair.contour;
   for (unsigned int i = 0; i < currentContourList.size(); i++)
   {
-    mitk::PlaneGeometry::Pointer planeFromList = currentContourList.at(i).plane;
+    mitk::PlaneGeometry::ConstPointer planeFromList = currentContourList.at(i).plane;
     if ( PlanesEqual(plane, planeFromList, mitk::eps) )
     {
       pos = i;
       break;
     }
   }
 
   //Don't save a new empty contour
   if (pos == -1 && newContour->GetVtkPolyData()->GetNumberOfPoints() > 0)
   {
     m_ReduceFilter->SetInput(m_ListOfInterpolationSessions[m_SelectedSegmentation].size(), newContour);
     m_ListOfInterpolationSessions[m_SelectedSegmentation].push_back(pair);
   }
   else if (pos != -1 && newContour->GetVtkPolyData()->GetNumberOfPoints() > 0)
   {
     m_ListOfInterpolationSessions[m_SelectedSegmentation].at(pos) = pair;
     m_ReduceFilter->SetInput(pos, newContour);
   }
   else if (newContour->GetVtkPolyData()->GetNumberOfPoints() == 0)
   {
     this->RemoveContour(plane);
   }
 
   m_ReduceFilter->Update();
   m_CurrentNumberOfReducedContours = m_ReduceFilter->GetNumberOfOutputs();
 
   for (unsigned int i = 0; i < m_CurrentNumberOfReducedContours; i++)
   {
     m_NormalsFilter->SetInput(i, m_ReduceFilter->GetOutput(i));
     m_InterpolateSurfaceFilter->SetInput(i, m_NormalsFilter->GetOutput(i));
   }
 }
 
-bool mitk::SurfaceInterpolationController::RemoveContour(mitk::PlaneGeometry *plane)
+bool mitk::SurfaceInterpolationController::RemoveContour(const mitk::PlaneGeometry *plane)
 {
   ContourPositionPairList::iterator it = m_ListOfInterpolationSessions[m_SelectedSegmentation].begin();
   while (it !=  m_ListOfInterpolationSessions[m_SelectedSegmentation].end())
   {
     ContourPositionPair pair = (*it);
     if (PlanesEqual(plane, pair.plane, mitk::eps))
     {
       m_ListOfInterpolationSessions[m_SelectedSegmentation].erase(it);
       this->ReinitializeInterpolation();
       return true;
     }
     ++it;
   }
   return false;
 }
 
-const mitk::Surface* mitk::SurfaceInterpolationController::GetContour(mitk::PlaneGeometry::Pointer plane)
+const mitk::Surface* mitk::SurfaceInterpolationController::GetContour(mitk::PlaneGeometry::ConstPointer plane)
 {
   ContourPositionPairList contourList = m_ListOfInterpolationSessions[m_SelectedSegmentation];
   for (unsigned int i = 0; i < contourList.size(); ++i)
   {
     ContourPositionPair pair = contourList.at(i);
     if (PlanesEqual(plane, pair.plane, mitk::eps))
       return pair.contour;
   }
   return 0;
 }
 
 unsigned int mitk::SurfaceInterpolationController::GetNumberOfContours()
 {
   return m_ListOfInterpolationSessions[m_SelectedSegmentation].size();
 }
 
 void mitk::SurfaceInterpolationController::Interpolate()
 {
   if (m_CurrentNumberOfReducedContours< 2)
   {
     //If no interpolation is possible reset the interpolation result
     m_InterpolationResult = 0;
     return;
   }
 
   //Setting up progress bar
    /*
     * Removed due to bug 12441. ProgressBar messes around with Qt event queue which is fatal for segmentation
     */
   //mitk::ProgressBar::GetInstance()->AddStepsToDo(8);
 
   // update the filter and get teh resulting distance-image
   m_InterpolateSurfaceFilter->Update();
   Image::Pointer distanceImage = m_InterpolateSurfaceFilter->GetOutput();
 
   // create a surface from the distance-image
   mitk::ImageToSurfaceFilter::Pointer imageToSurfaceFilter = mitk::ImageToSurfaceFilter::New();
   imageToSurfaceFilter->SetInput( distanceImage );
   imageToSurfaceFilter->SetThreshold( 0 );
   imageToSurfaceFilter->SetSmooth(true);
   imageToSurfaceFilter->SetSmoothIteration(20);
   imageToSurfaceFilter->Update();
   m_InterpolationResult = imageToSurfaceFilter->GetOutput();
 
 
   vtkSmartPointer<vtkAppendPolyData> polyDataAppender = vtkSmartPointer<vtkAppendPolyData>::New();
   for (unsigned int i = 0; i < m_ReduceFilter->GetNumberOfOutputs(); i++)
   {
     polyDataAppender->AddInputData(m_ReduceFilter->GetOutput(i)->GetVtkPolyData());
   }
   polyDataAppender->Update();
   m_Contours->SetVtkPolyData(polyDataAppender->GetOutput());
 
   //Last progress step
   /*
    * Removed due to bug 12441. ProgressBar messes around with Qt event queue which is fatal for segmentation
    */
   //mitk::ProgressBar::GetInstance()->Progress(8);
 
   m_InterpolationResult->DisconnectPipeline();
 }
 
 mitk::Surface::Pointer mitk::SurfaceInterpolationController::GetInterpolationResult()
 {
     return m_InterpolationResult;
 }
 
 mitk::Surface* mitk::SurfaceInterpolationController::GetContoursAsSurface()
 {
   return m_Contours;
 }
 
 void mitk::SurfaceInterpolationController::SetDataStorage(DataStorage::Pointer ds)
 {
   m_DataStorage = ds;
 }
 
 void mitk::SurfaceInterpolationController::SetMinSpacing(double minSpacing)
 {
   m_ReduceFilter->SetMinSpacing(minSpacing);
 }
 
 void mitk::SurfaceInterpolationController::SetMaxSpacing(double maxSpacing)
 {
   m_ReduceFilter->SetMaxSpacing(maxSpacing);
   m_NormalsFilter->SetMaxSpacing(maxSpacing);
 }
 
 void mitk::SurfaceInterpolationController::SetDistanceImageVolume(unsigned int distImgVolume)
 {
   m_InterpolateSurfaceFilter->SetDistanceImageVolume(distImgVolume);
 }
 
 mitk::Image::Pointer mitk::SurfaceInterpolationController::GetCurrentSegmentation()
 {
   return m_SelectedSegmentation;
 }
 
 mitk::Image* mitk::SurfaceInterpolationController::GetImage()
 {
   return m_InterpolateSurfaceFilter->GetOutput();
 }
 
 double mitk::SurfaceInterpolationController::EstimatePortionOfNeededMemory()
 {
   double numberOfPointsAfterReduction = m_ReduceFilter->GetNumberOfPointsAfterReduction()*3;
   double sizeOfPoints = pow(numberOfPointsAfterReduction,2)*sizeof(double);
   double totalMem = mitk::MemoryUtilities::GetTotalSizeOfPhysicalRam();
   double percentage = sizeOfPoints/totalMem;
   return percentage;
 }
 
 unsigned int mitk::SurfaceInterpolationController::GetNumberOfInterpolationSessions()
 {
   return m_ListOfInterpolationSessions.size();
 }
 
 template<typename TPixel, unsigned int VImageDimension>
 void mitk::SurfaceInterpolationController::GetImageBase(itk::Image<TPixel, VImageDimension>* input, itk::ImageBase<3>::Pointer& result)
 {
   result->Graft(input);
 }
 
 void mitk::SurfaceInterpolationController::SetCurrentSegmentationInterpolationList(mitk::Image::Pointer segmentation)
 {
   this->SetCurrentInterpolationSession(segmentation);
 }
 
 void mitk::SurfaceInterpolationController::SetCurrentInterpolationSession(mitk::Image::Pointer currentSegmentationImage)
 {
   if (currentSegmentationImage.GetPointer() == m_SelectedSegmentation)
     return;
 
   if (currentSegmentationImage.IsNull())
   {
     m_SelectedSegmentation = 0;
     return;
   }
 
   m_SelectedSegmentation = currentSegmentationImage.GetPointer();
 
   ContourListMap::iterator it = m_ListOfInterpolationSessions.find(currentSegmentationImage.GetPointer());
   // If the session does not exist yet create a new ContourPositionPairList otherwise reinitialize the interpolation pipeline
   if (it == m_ListOfInterpolationSessions.end())
   {
     ContourPositionPairList newList;
     m_ListOfInterpolationSessions.insert(std::pair<mitk::Image*, ContourPositionPairList>(m_SelectedSegmentation, newList));
     m_InterpolationResult = 0;
     m_CurrentNumberOfReducedContours = 0;
 
     itk::MemberCommand<SurfaceInterpolationController>::Pointer command = itk::MemberCommand<SurfaceInterpolationController>::New();
     command->SetCallbackFunction(this, &SurfaceInterpolationController::OnSegmentationDeleted);
     m_SegmentationObserverTags.insert( std::pair<mitk::Image*, unsigned long>( m_SelectedSegmentation, m_SelectedSegmentation->AddObserver( itk::DeleteEvent(), command ) ) );
   }
 
   this->ReinitializeInterpolation();
 }
 
 void mitk::SurfaceInterpolationController::RemoveSegmentationFromContourList(mitk::Image *segmentation)
 {
   this->RemoveInterpolationSession(segmentation);
 }
 
 void mitk::SurfaceInterpolationController::RemoveInterpolationSession(mitk::Image::Pointer segmentationImage)
 {
   if (segmentationImage)
   {
     if (m_SelectedSegmentation == segmentationImage)
     {
       m_NormalsFilter->SetSegmentationBinaryImage(NULL);
       m_SelectedSegmentation = 0;
     }
     m_ListOfInterpolationSessions.erase(segmentationImage);
     // Remove observer
     std::map<mitk::Image*, unsigned long>::iterator pos = m_SegmentationObserverTags.find(segmentationImage);
     if (pos != m_SegmentationObserverTags.end())
     {
       segmentationImage->RemoveObserver((*pos).second);
       m_SegmentationObserverTags.erase(pos);
     }
   }
 }
 
 void mitk::SurfaceInterpolationController::RemoveAllInterpolationSessions()
 {
   //Removing all observers
   std::map<mitk::Image*, unsigned long>::iterator dataIter = m_SegmentationObserverTags.begin();
   while (dataIter != m_SegmentationObserverTags.end())
   {
     mitk::Image* image = (*dataIter).first;
     image->RemoveObserver((*dataIter).second);
     ++dataIter;
   }
 
   m_SegmentationObserverTags.clear();
   m_SelectedSegmentation = 0;
   m_ListOfInterpolationSessions.clear();
 }
 
 void mitk::SurfaceInterpolationController::OnSegmentationDeleted(const itk::Object *caller, const itk::EventObject &/*event*/)
 {
   mitk::Image* tempImage = dynamic_cast<mitk::Image*>(const_cast<itk::Object*>(caller));
   if (tempImage)
   {
     if (m_SelectedSegmentation == tempImage)
     {
       m_NormalsFilter->SetSegmentationBinaryImage(NULL);
       m_SelectedSegmentation = 0;
     }
     m_SegmentationObserverTags.erase(tempImage);
     m_ListOfInterpolationSessions.erase(tempImage);
   }
 }
 
 void mitk::SurfaceInterpolationController::ReinitializeInterpolation()
 {
   m_NormalsFilter->SetSegmentationBinaryImage(m_SelectedSegmentation);
 
   // If session has changed reset the pipeline
   m_ReduceFilter->Reset();
   m_NormalsFilter->Reset();
   m_InterpolateSurfaceFilter->Reset();
 
   itk::ImageBase<3>::Pointer itkImage = itk::ImageBase<3>::New();
   AccessFixedDimensionByItk_1( m_SelectedSegmentation, GetImageBase, 3, itkImage );
   m_InterpolateSurfaceFilter->SetReferenceImage(itkImage.GetPointer());
 
   for (unsigned int i = 0; i < m_ListOfInterpolationSessions[m_SelectedSegmentation].size(); i++)
   {
     m_ReduceFilter->SetInput(i, m_ListOfInterpolationSessions[m_SelectedSegmentation].at(i).contour);
   }
 
   m_ReduceFilter->Update();
 
   m_CurrentNumberOfReducedContours = m_ReduceFilter->GetNumberOfOutputs();
 
   for (unsigned int i = 0; i < m_CurrentNumberOfReducedContours; i++)
   {
     m_NormalsFilter->SetInput(i, m_ReduceFilter->GetOutput(i));
     m_InterpolateSurfaceFilter->SetInput(i, m_NormalsFilter->GetOutput(i));
   }
   Modified();
 }
diff --git a/Modules/SurfaceInterpolation/mitkSurfaceInterpolationController.h b/Modules/SurfaceInterpolation/mitkSurfaceInterpolationController.h
index 5066f52894..6bdcc5875f 100644
--- a/Modules/SurfaceInterpolation/mitkSurfaceInterpolationController.h
+++ b/Modules/SurfaceInterpolation/mitkSurfaceInterpolationController.h
@@ -1,222 +1,222 @@
 /*===================================================================
 
 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 mitkSurfaceInterpolationController_h_Included
 #define mitkSurfaceInterpolationController_h_Included
 
 #include "mitkCommon.h"
 #include <MitkSurfaceInterpolationExports.h>
 #include "mitkRestorePlanePositionOperation.h"
 #include "mitkSurface.h"
 #include "mitkInteractionConst.h"
 #include "mitkColorProperty.h"
 #include "mitkProperties.h"
 
 #include "mitkCreateDistanceImageFromSurfaceFilter.h"
 #include "mitkReduceContourSetFilter.h"
 #include "mitkComputeContourSetNormalsFilter.h"
 
 #include "mitkDataNode.h"
 #include "mitkDataStorage.h"
 #include "mitkWeakPointer.h"
 
 #include "vtkPolygon.h"
 #include "vtkPoints.h"
 #include "vtkCellArray.h"
 #include "vtkPolyData.h"
 #include "vtkSmartPointer.h"
 #include "vtkAppendPolyData.h"
 
 #include "vtkMarchingCubes.h"
 #include "vtkImageData.h"
 #include "mitkVtkRepresentationProperty.h"
 #include "vtkProperty.h"
 
 #include "mitkProgressBar.h"
 
 namespace mitk
 {
 
  class MitkSurfaceInterpolation_EXPORT SurfaceInterpolationController : public itk::Object
  {
 
   public:
 
     mitkClassMacro(SurfaceInterpolationController, itk::Object)
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
 
     struct ContourPositionPair {
       Surface::Pointer contour;
-      mitk::PlaneGeometry::Pointer plane;
+      mitk::PlaneGeometry::ConstPointer plane;
     };
 
     typedef std::vector<ContourPositionPair> ContourPositionPairList;
     typedef std::map<mitk::Image*, ContourPositionPairList> ContourListMap;
 
     static SurfaceInterpolationController* GetInstance();
 
     /**
      * @brief Adds a new extracted contour to the list
      * @param newContour the contour to be added
      * @param plane the image plane in which the contour lies. If plane already exists the related
      *        contour will be updated
      */
-    void AddNewContour (Surface::Pointer newContour, PlaneGeometry::Pointer plane);
+    void AddNewContour (Surface::Pointer newContour, PlaneGeometry::ConstPointer plane);
 
     /**
      * @brief Removes the contour for a given plane for the current selected segmenation
      * @param plane the plane for which the contour should be returned
      * @return true if a contour was found and removed, false if no contour was found
      */
-    bool RemoveContour (mitk::PlaneGeometry* plane);
+    bool RemoveContour (const mitk::PlaneGeometry* plane);
 
     /**
      * @brief Adds new extracted contours to the list. If one or more contours at a given position
      *        already exist they will be updated respectively
      * @param newContours the list of the contours and the respective positions
      */
     void AddNewContours (ContourPositionPairList newContours);
 
     /**
     * @brief Returns the contour for a given plane for the current selected segmenation
     * @param plane the plane for which the contour should be returned
     * @return the contour as an mitk::Surface. If no contour is available for the plane NULL is returned
     */
-    const mitk::Surface* GetContour (PlaneGeometry::Pointer plane);
+    const mitk::Surface* GetContour (PlaneGeometry::ConstPointer plane);
 
     /**
     * @brief Returns the number of available contours for the current selected segmentation
     * @return the number of contours
     */
     unsigned int GetNumberOfContours();
 
     /**
      * Interpolates the 3D surface from the given extracted contours
      */
     void Interpolate ();
 
     mitk::Surface::Pointer GetInterpolationResult();
 
     /**
      * Sets the minimum spacing of the current selected segmentation
      * This is needed since the contour points we reduced before they are used to interpolate the surface
      */
     void SetMinSpacing(double minSpacing);
 
     /**
      * Sets the minimum spacing of the current selected segmentation
      * This is needed since the contour points we reduced before they are used to interpolate the surface
      */
     void SetMaxSpacing(double maxSpacing);
 
     /**
      * Sets the volume i.e. the number of pixels that the distance image should have
      * By evaluation we found out that 50.000 pixel delivers a good result
      */
     void SetDistanceImageVolume(unsigned int distImageVolume);
 
     /**
      * @brief Get the current selected segmentation for which the interpolation is performed
      * @return the current segmentation image
      */
     mitk::Image::Pointer GetCurrentSegmentation();
 
     Surface* GetContoursAsSurface();
 
     void SetDataStorage(DataStorage::Pointer ds);
 
     /**
      * Sets the current list of contourpoints which is used for the surface interpolation
      * @param segmentation The current selected segmentation
      * \deprecatedSince{2014_03}
      */
     DEPRECATED (void SetCurrentSegmentationInterpolationList(mitk::Image::Pointer segmentation));
 
     /**
      * Sets the current list of contourpoints which is used for the surface interpolation
      * @param segmentation The current selected segmentation
      */
     void SetCurrentInterpolationSession(mitk::Image::Pointer currentSegmentationImage);
 
     /**
      * Removes the segmentation and all its contours from the list
      * @param segmentation The segmentation to be removed
      * \deprecatedSince{2014_03}
      */
     DEPRECATED (void RemoveSegmentationFromContourList(mitk::Image* segmentation));
 
     /**
      * @brief Remove interpolation session
      * @param segmentationImage the session to be removed
      */
     void RemoveInterpolationSession(mitk::Image::Pointer segmentationImage);
 
     /**
      * @brief Removes all sessions
      */
     void RemoveAllInterpolationSessions();
 
     mitk::Image* GetImage();
 
     /**
      * Estimates the memory which is needed to build up the equationsystem for the interpolation.
      * \returns The percentage of the real memory which will be used by the interpolation
      */
     double EstimatePortionOfNeededMemory();
 
     unsigned int GetNumberOfInterpolationSessions();
 
  protected:
 
    SurfaceInterpolationController();
 
    ~SurfaceInterpolationController();
 
    template<typename TPixel, unsigned int VImageDimension> void GetImageBase(itk::Image<TPixel, VImageDimension>* input, itk::ImageBase<3>::Pointer& result);
 
  private:
 
    void OnSegmentationDeleted(const itk::Object *caller, const itk::EventObject &event);
 
    void ReinitializeInterpolation();
 
    void AddToInterpolationPipeline(ContourPositionPair pair);
 
     ContourPositionPairList::iterator m_Iterator;
 
     ReduceContourSetFilter::Pointer m_ReduceFilter;
     ComputeContourSetNormalsFilter::Pointer m_NormalsFilter;
     CreateDistanceImageFromSurfaceFilter::Pointer m_InterpolateSurfaceFilter;
 
     Surface::Pointer m_Contours;
 
     vtkSmartPointer<vtkPolyData> m_PolyData;
 
     mitk::DataStorage::Pointer m_DataStorage;
 
     ContourListMap m_ListOfInterpolationSessions;
 
     mitk::Surface::Pointer m_InterpolationResult;
 
     unsigned int m_CurrentNumberOfReducedContours;
 
     mitk::Image* m_SelectedSegmentation;
 
     std::map<mitk::Image*, unsigned long> m_SegmentationObserverTags;
  };
 }
 #endif