diff --git a/Modules/ImageStatistics/Testing/mitkImageStatisticsCalculatorTest.cpp b/Modules/ImageStatistics/Testing/mitkImageStatisticsCalculatorTest.cpp
index 69d7a086a9..9c4f24c6c2 100644
--- a/Modules/ImageStatistics/Testing/mitkImageStatisticsCalculatorTest.cpp
+++ b/Modules/ImageStatistics/Testing/mitkImageStatisticsCalculatorTest.cpp
@@ -1,418 +1,412 @@
 /*===================================================================
 
 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 "mitkTestFixture.h"
-#include "mitkTestingMacros.h"
-
 #include "mitkImageStatisticsCalculator.h"
-#include "mitkPlanarPolygon.h"
-
-#include "mitkClassicDICOMSeriesReader.h"
-
-#include "vtkStreamingDemandDrivenPipeline.h"
-
-#include <mitkDataNodeFactory.h>
+#include <mitkTestFixture.h>
+#include <mitkTestingMacros.h>
+#include <mitkPlanarPolygon.h>
+#include <mitkClassicDICOMSeriesReader.h>
+#include <vtkStreamingDemandDrivenPipeline.h>
 #include <mitkStandaloneDataStorage.h>
 
-
 /**
  * \brief Test class for mitkImageStatisticsCalculator
  *
  * This test covers:
  * - instantiation of an ImageStatisticsCalculator class
  * - correctness of statistics when using PlanarFigures for masking
  */
 class mitkImageStatisticsCalculatorTestSuite : public mitk::TestFixture
 {
   CPPUNIT_TEST_SUITE(mitkImageStatisticsCalculatorTestSuite);
   MITK_TEST(TestUninitializedImage);
   MITK_TEST(TestCase1);
   MITK_TEST(TestCase2);
   MITK_TEST(TestCase3);
   MITK_TEST(TestCase4);
   MITK_TEST(TestCase5);
   MITK_TEST(TestCase6);
   MITK_TEST(TestCase7);
   MITK_TEST(TestCase8);
   MITK_TEST(TestCase9);
   MITK_TEST(TestCase10);
   MITK_TEST(TestCase11);
   MITK_TEST(TestCase12);
   CPPUNIT_TEST_SUITE_END();
 
 public:
 
   void setUp();
 
   void TestUninitializedImage();
 
   void TestCase1();
   void TestCase2();
   void TestCase3();
   void TestCase4();
   void TestCase5();
   void TestCase6();
   void TestCase7();
   void TestCase8();
   void TestCase9();
   void TestCase10();
   void TestCase11();
   void TestCase12();
 
 private:
 
   mitk::Image::Pointer m_Image;
   mitk::PlaneGeometry::Pointer m_Geometry;
 
   // calculate statistics for the given image and planarpolygon
   const mitk::ImageStatisticsCalculator::Statistics ComputeStatistics( mitk::Image::Pointer image,
                                                                        mitk::PlanarFigure::Pointer polygon );
 
   void VerifyStatistics(const mitk::ImageStatisticsCalculator::Statistics& stats,
                         double testMean, double testSD);
 };
 
 void mitkImageStatisticsCalculatorTestSuite::setUp()
 {
   std::string filename = this->GetTestDataFilePath("ImageStatistics/testimage.dcm");
   if (filename.empty())
   {
     MITK_TEST_FAILED_MSG( << "Could not find test file" )
   }
 
   MITK_TEST_OUTPUT(<< "Loading test image '" << filename << "'")
   mitk::StringList files;
   files.push_back( filename );
 
   mitk::ClassicDICOMSeriesReader::Pointer reader = mitk::ClassicDICOMSeriesReader::New();
   reader->SetInputFiles( files );
   reader->AnalyzeInputFiles();
   reader->LoadImages();
   MITK_TEST_CONDITION_REQUIRED( reader->GetNumberOfOutputs() == 1, "Loaded one result from file" );
 
   m_Image = reader->GetOutput(0).GetMitkImage();
   MITK_TEST_CONDITION_REQUIRED( m_Image.IsNotNull(), "Loaded an mitk::Image" );
 
   m_Geometry = m_Image->GetSlicedGeometry()->GetPlaneGeometry(0);
   MITK_TEST_CONDITION_REQUIRED( m_Geometry.IsNotNull(), "Getting image geometry" )
 }
 
 void mitkImageStatisticsCalculatorTestSuite::TestCase1()
 {
   /*****************************
    * one whole white pixel
    * -> mean of 255 expected
    ******************************/
   mitk::PlanarPolygon::Pointer figure1 = mitk::PlanarPolygon::New();
   figure1->SetPlaneGeometry( m_Geometry );
   mitk::Point2D pnt1; pnt1[0] = 10.5 ; pnt1[1] = 3.5;
   figure1->PlaceFigure( pnt1 );
 
   mitk::Point2D pnt2; pnt2[0] = 9.5; pnt2[1] = 3.5;
   figure1->SetControlPoint( 1, pnt2, true );
   mitk::Point2D pnt3; pnt3[0] = 9.5; pnt3[1] = 4.5;
   figure1->SetControlPoint( 2, pnt3, true );
   mitk::Point2D pnt4; pnt4[0] = 10.5; pnt4[1] = 4.5;
   figure1->SetControlPoint( 3, pnt4, true );
   figure1->GetPolyLine(0);
 
   this->VerifyStatistics(ComputeStatistics(m_Image, figure1.GetPointer()), 255.0, 0.0);
 }
 
 void mitkImageStatisticsCalculatorTestSuite::TestCase2()
 {
   /*****************************
    * half pixel in x-direction (white)
    * -> mean of 255 expected
    ******************************/
   mitk::PlanarPolygon::Pointer figure1 = mitk::PlanarPolygon::New();
   figure1->SetPlaneGeometry( m_Geometry );
   mitk::Point2D pnt1; pnt1[0] = 10.0 ; pnt1[1] = 3.5;
   figure1->PlaceFigure( pnt1 );
 
   mitk::Point2D pnt2; pnt2[0] = 9.5; pnt2[1] = 3.5;
   figure1->SetControlPoint( 1, pnt2, true );
   mitk::Point2D pnt3; pnt3[0] = 9.5; pnt3[1] = 4.5;
   figure1->SetControlPoint( 2, pnt3, true );
   mitk::Point2D pnt4; pnt4[0] = 10.0; pnt4[1] = 4.5;
   figure1->SetControlPoint( 3, pnt4, true );
   figure1->GetPolyLine(0);
 
   this->VerifyStatistics(ComputeStatistics(m_Image, figure1.GetPointer()), 255.0, 0.0);
 }
 
 void mitkImageStatisticsCalculatorTestSuite::TestCase3()
 {
   /*****************************
    * half pixel in diagonal-direction (white)
    * -> mean of 255 expected
    ******************************/
   mitk::PlanarPolygon::Pointer figure1 = mitk::PlanarPolygon::New();
   figure1->SetPlaneGeometry( m_Geometry );
   mitk::Point2D pnt1; pnt1[0] = 10.5 ; pnt1[1] = 3.5;
   figure1->PlaceFigure( pnt1 );
 
   mitk::Point2D pnt2; pnt2[0] = 9.5; pnt2[1] = 3.5;
   figure1->SetControlPoint( 1, pnt2, true );
   mitk::Point2D pnt3; pnt3[0] = 9.5; pnt3[1] = 4.5;
   figure1->SetControlPoint( 2, pnt3, true );
   figure1->GetPolyLine(0);
 
   this->VerifyStatistics(ComputeStatistics(m_Image, figure1.GetPointer()), 255.0, 0.0);
 }
 
 void mitkImageStatisticsCalculatorTestSuite::TestCase4()
 {
   /*****************************
    * one pixel (white) + 2 half pixels (white) + 1 half pixel (black)
    * -> mean of 191.25 expected
    ******************************/
   mitk::PlanarPolygon::Pointer figure1 = mitk::PlanarPolygon::New();
   figure1->SetPlaneGeometry( m_Geometry );
   mitk::Point2D pnt1; pnt1[0] = 1.1; pnt1[1] = 1.1;
   figure1->PlaceFigure( pnt1 );
 
   mitk::Point2D pnt2; pnt2[0] = 2.0; pnt2[1] = 2.0;
   figure1->SetControlPoint( 1, pnt2, true );
   mitk::Point2D pnt3; pnt3[0] = 3.0; pnt3[1] = 1.0;
   figure1->SetControlPoint( 2, pnt3, true );
   mitk::Point2D pnt4; pnt4[0] = 2.0; pnt4[1] = 0.0;
   figure1->SetControlPoint( 3, pnt4, true );
   figure1->GetPolyLine(0);
 
   this->VerifyStatistics(ComputeStatistics(m_Image, figure1.GetPointer()), 191.25, 127.5);
 }
 
 void mitkImageStatisticsCalculatorTestSuite::TestCase5()
 {
   /*****************************
    * whole pixel (white) + half pixel (gray) in x-direction
    * -> mean of 191.5 expected
    ******************************/
   mitk::PlanarPolygon::Pointer figure1 = mitk::PlanarPolygon::New();
   figure1->SetPlaneGeometry( m_Geometry );
   mitk::Point2D pnt1; pnt1[0] = 11.0; pnt1[1] = 3.5;
   figure1->PlaceFigure( pnt1 );
 
   mitk::Point2D pnt2; pnt2[0] = 9.5; pnt2[1] = 3.5;
   figure1->SetControlPoint( 1, pnt2, true );
   mitk::Point2D pnt3; pnt3[0] = 9.5; pnt3[1] = 4.5;
   figure1->SetControlPoint( 2, pnt3, true );
   mitk::Point2D pnt4; pnt4[0] = 11.0; pnt4[1] = 4.5;
   figure1->SetControlPoint( 3, pnt4, true );
   figure1->GetPolyLine(0);
 
   this->VerifyStatistics(ComputeStatistics(m_Image, figure1.GetPointer()), 191.50, 89.80);
 }
 
 void mitkImageStatisticsCalculatorTestSuite::TestCase6()
 {
   /*****************************
    * quarter pixel (black) + whole pixel (white) + half pixel (gray) in x-direction
    * -> mean of 191.5 expected
    ******************************/
   mitk::PlanarPolygon::Pointer figure1 = mitk::PlanarPolygon::New();
   figure1->SetPlaneGeometry( m_Geometry );
   mitk::Point2D pnt1; pnt1[0] = 11.0; pnt1[1] = 3.5;
   figure1->PlaceFigure( pnt1 );
 
   mitk::Point2D pnt2; pnt2[0] = 9.25; pnt2[1] = 3.5;
   figure1->SetControlPoint( 1, pnt2, true );
   mitk::Point2D pnt3; pnt3[0] = 9.25; pnt3[1] = 4.5;
   figure1->SetControlPoint( 2, pnt3, true );
   mitk::Point2D pnt4; pnt4[0] = 11.0; pnt4[1] = 4.5;
   figure1->SetControlPoint( 3, pnt4, true );
   figure1->GetPolyLine(0);
 
   this->VerifyStatistics(ComputeStatistics(m_Image, figure1.GetPointer()), 191.5, 89.80);
 }
 
 void mitkImageStatisticsCalculatorTestSuite::TestCase7()
 {
   /*****************************
    * half pixel (black) + whole pixel (white) + half pixel (gray) in x-direction
    * -> mean of 127.66 expected
    ******************************/
   mitk::PlanarPolygon::Pointer figure1 = mitk::PlanarPolygon::New();
   figure1->SetPlaneGeometry( m_Geometry );
   mitk::Point2D pnt1; pnt1[0] = 11.0; pnt1[1] = 3.5;
   figure1->PlaceFigure( pnt1 );
 
   mitk::Point2D pnt2; pnt2[0] = 9.0; pnt2[1] = 3.5;
   figure1->SetControlPoint( 1, pnt2, true );
   mitk::Point2D pnt3; pnt3[0] = 9.0; pnt3[1] = 4.0;
   figure1->SetControlPoint( 2, pnt3, true );
   mitk::Point2D pnt4; pnt4[0] = 11.0; pnt4[1] = 4.0;
   figure1->SetControlPoint( 3, pnt4, true );
   figure1->GetPolyLine(0);
 
   this->VerifyStatistics(ComputeStatistics(m_Image, figure1.GetPointer()), 127.66, 127.5);
 }
 
 void mitkImageStatisticsCalculatorTestSuite::TestCase8()
 {
   /*****************************
    * whole pixel (gray)
    * -> mean of 128 expected
    ******************************/
   mitk::PlanarPolygon::Pointer figure2 = mitk::PlanarPolygon::New();
   figure2->SetPlaneGeometry( m_Geometry );
   mitk::Point2D pnt1; pnt1[0] = 11.5; pnt1[1] = 10.5;
   figure2->PlaceFigure( pnt1 );
 
   mitk::Point2D pnt2; pnt2[0] = 11.5; pnt2[1] = 11.5;
   figure2->SetControlPoint( 1, pnt2, true );
   mitk::Point2D pnt3; pnt3[0] = 12.5; pnt3[1] = 11.5;
   figure2->SetControlPoint( 2, pnt3, true );
   mitk::Point2D pnt4; pnt4[0] = 12.5; pnt4[1] = 10.5;
   figure2->SetControlPoint( 3, pnt4, true );
   figure2->GetPolyLine(0);
 
   this->VerifyStatistics(ComputeStatistics(m_Image, figure2.GetPointer()), 128.0, 0.0);
 }
 
 void mitkImageStatisticsCalculatorTestSuite::TestCase9()
 {
   /*****************************
    * whole pixel (gray) + half pixel (white) in y-direction
    * -> mean of 191.5 expected
    ******************************/
   mitk::PlanarPolygon::Pointer figure2 = mitk::PlanarPolygon::New();
   figure2->SetPlaneGeometry( m_Geometry );
   mitk::Point2D pnt1; pnt1[0] = 11.5; pnt1[1] = 10.5;
   figure2->PlaceFigure( pnt1 );
 
   mitk::Point2D pnt2; pnt2[0] = 11.5; pnt2[1] = 12.0;
   figure2->SetControlPoint( 1, pnt2, true );
   mitk::Point2D pnt3; pnt3[0] = 12.5; pnt3[1] = 12.0;
   figure2->SetControlPoint( 2, pnt3, true );
   mitk::Point2D pnt4; pnt4[0] = 12.5; pnt4[1] = 10.5;
   figure2->SetControlPoint( 3, pnt4, true );
   figure2->GetPolyLine(0);
 
   this->VerifyStatistics(ComputeStatistics(m_Image, figure2.GetPointer()), 191.5, 89.80);
 }
 
 void mitkImageStatisticsCalculatorTestSuite::TestCase10()
 {
   /*****************************
    * 2 whole pixel (white) + 2 whole pixel (black) in y-direction
    * -> mean of 127.66 expected
    ******************************/
   mitk::PlanarPolygon::Pointer figure2 = mitk::PlanarPolygon::New();
   figure2->SetPlaneGeometry( m_Geometry );
   mitk::Point2D pnt1; pnt1[0] = 11.5; pnt1[1] = 10.5;
   figure2->PlaceFigure( pnt1 );
 
   mitk::Point2D pnt2; pnt2[0] = 11.5; pnt2[1] = 13.5;
   figure2->SetControlPoint( 1, pnt2, true );
   mitk::Point2D pnt3; pnt3[0] = 12.5; pnt3[1] = 13.5;
   figure2->SetControlPoint( 2, pnt3, true );
   mitk::Point2D pnt4; pnt4[0] = 12.5; pnt4[1] = 10.5;
   figure2->SetControlPoint( 3, pnt4, true );
   figure2->GetPolyLine(0);
 
   this->VerifyStatistics(ComputeStatistics(m_Image, figure2.GetPointer()), 127.66, 127.5);
 }
 
 void mitkImageStatisticsCalculatorTestSuite::TestCase11()
 {
   /*****************************
    * 9 whole pixels (white) + 3 half pixels (white)
    * + 3 whole pixel (black) [ + 3 slightly less than half pixels (black)]
    * -> mean of 204.0 expected
    ******************************/
   mitk::PlanarPolygon::Pointer figure2 = mitk::PlanarPolygon::New();
   figure2->SetPlaneGeometry( m_Geometry );
   mitk::Point2D pnt1; pnt1[0] = 0.5; pnt1[1] = 0.5;
   figure2->PlaceFigure( pnt1 );
 
   mitk::Point2D pnt2; pnt2[0] = 3.5; pnt2[1] = 3.5;
   figure2->SetControlPoint( 1, pnt2, true );
   mitk::Point2D pnt3; pnt3[0] = 8.4999; pnt3[1] = 3.5;
   figure2->SetControlPoint( 2, pnt3, true );
   mitk::Point2D pnt4; pnt4[0] = 5.4999; pnt4[1] = 0.5;
   figure2->SetControlPoint( 3, pnt4, true );
   figure2->GetPolyLine(0);
 
   this->VerifyStatistics(ComputeStatistics(m_Image, figure2.GetPointer()), 204.0, 105.58 );
 }
 
 void mitkImageStatisticsCalculatorTestSuite::TestCase12()
 {
   /*****************************
    * half pixel (white) + whole pixel (white) + half pixel (black)
    * -> mean of 212.66 expected
    ******************************/
   mitk::PlanarPolygon::Pointer figure2 = mitk::PlanarPolygon::New();
   figure2->SetPlaneGeometry( m_Geometry );
   mitk::Point2D pnt1; pnt1[0] = 9.5; pnt1[1] = 0.5;
   figure2->PlaceFigure( pnt1 );
 
   mitk::Point2D pnt2; pnt2[0] = 9.5; pnt2[1] = 2.5;
   figure2->SetControlPoint( 1, pnt2, true );
   mitk::Point2D pnt3; pnt3[0] = 11.5; pnt3[1] = 2.5;
   figure2->SetControlPoint( 2, pnt3, true );
   figure2->GetPolyLine(0);
 
   this->VerifyStatistics(ComputeStatistics(m_Image, figure2.GetPointer()), 212.66, 73.32);
 }
 
 const mitk::ImageStatisticsCalculator::Statistics
 mitkImageStatisticsCalculatorTestSuite::ComputeStatistics( mitk::Image::Pointer image, mitk::PlanarFigure::Pointer polygon )
 {
   mitk::ImageStatisticsCalculator::Pointer statisticsCalculator = mitk::ImageStatisticsCalculator::New();
   statisticsCalculator->SetImage( image );
   statisticsCalculator->SetMaskingModeToPlanarFigure();
   statisticsCalculator->SetPlanarFigure( polygon );
 
   statisticsCalculator->ComputeStatistics();
 
   return statisticsCalculator->GetStatistics();
 }
 
 void mitkImageStatisticsCalculatorTestSuite::VerifyStatistics(const mitk::ImageStatisticsCalculator::Statistics& stats,
                                                               double testMean, double testSD)
 {
   int tmpMean = stats.GetMean() * 100;
   double calculatedMean = tmpMean / 100.0;
   MITK_TEST_CONDITION( calculatedMean == testMean,
                        "Calculated mean grayvalue '" << calculatedMean <<
                        "'  is equal to the desired value '" << testMean << "'" );
 
   int tmpSD = stats.GetSigma() * 100;
   double calculatedSD = tmpSD / 100.0;
   MITK_TEST_CONDITION( calculatedSD == testSD,
                        "Calculated grayvalue sd '" << calculatedSD <<
                        "'  is equal to the desired value '" << testSD <<"'" );
 }
 
 void mitkImageStatisticsCalculatorTestSuite::TestUninitializedImage()
 {
   /*****************************
   * loading uninitialized image to datastorage
   ******************************/
   MITK_TEST_FOR_EXCEPTION_BEGIN(mitk::Exception)
   mitk::Image::Pointer image = mitk::Image::New();
   mitk::DataNode::Pointer node = mitk::DataNode::New();
   node->SetData(image);
 
   mitk::ImageStatisticsCalculator::Pointer is = mitk::ImageStatisticsCalculator::New();
   is->ComputeStatistics();
   MITK_TEST_FOR_EXCEPTION_END(mitk::Exception)
 }
 
 MITK_TEST_SUITE_REGISTRATION(mitkImageStatisticsCalculator)
diff --git a/Modules/PlanarFigure/CMakeLists.txt b/Modules/PlanarFigure/CMakeLists.txt
index 34264f3cfb..da27294254 100644
--- a/Modules/PlanarFigure/CMakeLists.txt
+++ b/Modules/PlanarFigure/CMakeLists.txt
@@ -1,9 +1,9 @@
 MITK_CREATE_MODULE(
   INCLUDE_DIRS Algorithms DataManagement Interactions IO Rendering
-  DEPENDS MitkLegacyIO MitkSceneSerializationBase MitkLegacyGL MitkOverlays
+  DEPENDS MitkSceneSerializationBase MitkLegacyGL MitkOverlays
   WARNINGS_AS_ERRORS
 )
 
 IF( BUILD_TESTING )
 add_subdirectory(Testing)
 ENDIF()
diff --git a/Modules/PlanarFigureSegmentation/mitkPlanarFigureSegmentationController.cpp b/Modules/PlanarFigureSegmentation/mitkPlanarFigureSegmentationController.cpp
index 6e44b799c5..2e61685e59 100644
--- a/Modules/PlanarFigureSegmentation/mitkPlanarFigureSegmentationController.cpp
+++ b/Modules/PlanarFigureSegmentation/mitkPlanarFigureSegmentationController.cpp
@@ -1,315 +1,301 @@
 /*===================================================================
 
 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 "mitkPlanarFigureSegmentationController.h"
 
-#include "mitkSurfaceToImageFilter.h"
-
 #include <vtkPolyData.h>
 #include <vtkPoints.h>
 #include <vtkPolygon.h>
 #include <vtkCellArray.h>
-
 #include <vtkSmartPointer.h>
 #include <vtkImageData.h>
-#include "mitkImageWriter.h"
-#include "mitkSurfaceVtkWriter.h"
-#include "mitkImageToSurfaceFilter.h"
-
-#include "mitkImageAccessByItk.h"
-
-#include "mitkImageCast.h"
 
+#include <mitkSurfaceToImageFilter.h>
+#include <mitkImageToSurfaceFilter.h>
+#include <mitkImageAccessByItk.h>
+#include <mitkIOUtil.h>
+#include <mitkImageCast.h>
 
 mitk::PlanarFigureSegmentationController::PlanarFigureSegmentationController()
 : itk::Object()
 , m_ReduceFilter( NULL )
 , m_NormalsFilter( NULL )
 , m_DistanceImageCreator( NULL )
 , m_ReferenceImage( NULL )
 , m_SegmentationAsImage( NULL )
 {
   InitializeFilters();
 }
 
 mitk::PlanarFigureSegmentationController::~PlanarFigureSegmentationController()
 {
 }
 
 void mitk::PlanarFigureSegmentationController::SetReferenceImage( mitk::Image::Pointer referenceImage )
 {
   m_ReferenceImage = referenceImage;
 }
 
 void mitk::PlanarFigureSegmentationController::AddPlanarFigure( mitk::PlanarFigure::Pointer planarFigure )
 {
   if ( planarFigure.IsNull() )
     return;
 
   bool newFigure = true;
   std::size_t indexOfFigure = 0;
   for( std::size_t i=0; i<m_PlanarFigureList.size(); i++ )
   {
     if( m_PlanarFigureList.at(i) == planarFigure )
     {
       indexOfFigure = i;
       newFigure = false;
       break;
     }
   }
 
   mitk::Surface::Pointer figureAsSurface = NULL;
 
   if ( newFigure )
   {
     m_PlanarFigureList.push_back( planarFigure );
     figureAsSurface = this->CreateSurfaceFromPlanarFigure( planarFigure );
     m_SurfaceList.push_back( figureAsSurface );
     if (!m_PlanarFigureList.empty())
     {
       indexOfFigure = m_PlanarFigureList.size() -1 ;
     }
   }
   else
   {
     figureAsSurface = this->CreateSurfaceFromPlanarFigure( planarFigure );
     m_SurfaceList.at(indexOfFigure) = figureAsSurface;
   }
 
   if ( m_ReduceFilter.IsNull() )
   {
     InitializeFilters();
   }
 
   m_ReduceFilter->SetInput( indexOfFigure, figureAsSurface );
 
   m_NormalsFilter->SetInput( indexOfFigure, m_ReduceFilter->GetOutput( indexOfFigure ) );
   m_DistanceImageCreator->SetInput( indexOfFigure, m_NormalsFilter->GetOutput( indexOfFigure ) );
 }
 
 void mitk::PlanarFigureSegmentationController::RemovePlanarFigure( mitk::PlanarFigure::Pointer planarFigure )
 {
   if ( planarFigure.IsNull() )
     return;
 
   bool figureFound = false;
   std::size_t indexOfFigure = 0;
   for( std::size_t i=0; i<m_PlanarFigureList.size(); i++ )
   {
     if( m_PlanarFigureList.at(i) == planarFigure )
     {
       indexOfFigure = i;
       figureFound = true;
       break;
     }
   }
 
   if ( !figureFound )
     return;
 
   PlanarFigureListType::iterator whereIter = m_PlanarFigureList.begin();
   whereIter += indexOfFigure;
   m_PlanarFigureList.erase( whereIter );
 
   SurfaceListType::iterator surfaceIter = m_SurfaceList.begin();
   surfaceIter += indexOfFigure;
   m_SurfaceList.erase( surfaceIter );
 
   // TODO: fix this! The following code had to be removed as the method
   // RemoveInputs() has been removed in ITK 4
   // The remaining code works correctly but is slower
   if ( false && indexOfFigure == m_PlanarFigureList.size()-1 )
   {
     // Ff the removed figure was the last one in the list, we can simply
     // remove the last input from each filter.
 //     m_DistanceImageCreator->RemoveInputs( m_NormalsFilter->GetOutput( indexOfFigure ) );
 //     m_NormalsFilter->RemoveInput( m_ReduceFilter->GetOutput( indexOfFigure ) );
 //     m_ReduceFilter->RemoveInput( const_cast<mitk::Surface*>(m_ReduceFilter->GetInput(indexOfFigure)) );
   }
   else
   {
     // this is not very nice! If the figure that has been removed is NOT the last
     // one in the list we have to create new filters and add all remaining
     // inputs again.
     //
     // Has to be done as the filters do not work when removing an input
     // other than the last one.
 
     // create new filters
     InitializeFilters();
 
     // and add all existing surfaces
     SurfaceListType::iterator surfaceIter = m_SurfaceList.begin();
     int index = 0;
     for ( surfaceIter = m_SurfaceList.begin(); surfaceIter!=m_SurfaceList.end(); surfaceIter++ )
     {
       m_ReduceFilter->SetInput( index, (*surfaceIter) );
       m_NormalsFilter->SetInput( index, m_ReduceFilter->GetOutput( index ) );
       m_DistanceImageCreator->SetInput( index, m_NormalsFilter->GetOutput( index ) );
 
       ++index;
     }
   }
 }
 
 template<typename TPixel, unsigned int VImageDimension>
 void mitk::PlanarFigureSegmentationController::GetImageBase(itk::Image<TPixel, VImageDimension>* input, itk::ImageBase<3>::Pointer& result)
 {
   result = input;
 }
 
 mitk::Image::Pointer mitk::PlanarFigureSegmentationController::GetInterpolationResult()
 {
   m_SegmentationAsImage = NULL;
 
   if ( m_PlanarFigureList.size() == 0 )
   {
     m_SegmentationAsImage = mitk::Image::New();
     m_SegmentationAsImage->Initialize(mitk::MakeScalarPixelType<unsigned char>() , *m_ReferenceImage->GetTimeGeometry());
 
     return m_SegmentationAsImage;
   }
 
   itk::ImageBase<3>::Pointer itkImage;
   AccessFixedDimensionByItk_1( m_ReferenceImage.GetPointer(), GetImageBase, 3, itkImage );
   m_DistanceImageCreator->SetReferenceImage( itkImage.GetPointer() );
 
   m_ReduceFilter->Update();
   m_NormalsFilter->Update();
   m_DistanceImageCreator->Update();
 
   mitk::Image::Pointer distanceImage = m_DistanceImageCreator->GetOutput();
 
   // Cleanup the pipeline
   distanceImage->DisconnectPipeline();
   m_DistanceImageCreator = NULL;
   m_NormalsFilter = NULL;
   m_ReduceFilter = NULL;
   itkImage = NULL;
 
   // If this bool flag is true, the distanceImage will be written to the
   // filesystem as nrrd-image and as surface-representation.
   bool debugOutput(false);
   if ( debugOutput )
   {
-    mitk::ImageWriter::Pointer imageWriter = mitk::ImageWriter::New();
-    imageWriter->SetInput( distanceImage );
-    imageWriter->SetExtension( ".nrrd" );
-    imageWriter->SetFileName( "v:/DistanceImage" );
-    imageWriter->Update();
+    mitk::IOUtil::Save(distanceImage, "v:/DistanceImage.nrrd");
   }
 
   mitk::ImageToSurfaceFilter::Pointer imageToSurfaceFilter = mitk::ImageToSurfaceFilter::New();
   imageToSurfaceFilter->SetInput( distanceImage );
   imageToSurfaceFilter->SetThreshold( 0 );
   imageToSurfaceFilter->Update();
 
   mitk::Surface::Pointer segmentationAsSurface = imageToSurfaceFilter->GetOutput();
 
   // Cleanup the pipeline
   segmentationAsSurface->DisconnectPipeline();
   imageToSurfaceFilter = NULL;
 
   if ( debugOutput )
   {
-    mitk::SurfaceVtkWriter<vtkPolyDataWriter>::Pointer surfaceWriter = mitk::SurfaceVtkWriter<vtkPolyDataWriter>::New();
-    surfaceWriter->SetInput( segmentationAsSurface );
-    surfaceWriter->SetExtension( ".vtk" );
-    surfaceWriter->SetFileName( "v:/DistanceImageAsSurface.vtk" );
-    surfaceWriter->Update();
+    mitk::IOUtil::Save( segmentationAsSurface, "v:/DistanceImageAsSurface.vtk" );
   }
 
-
   mitk::SurfaceToImageFilter::Pointer surfaceToImageFilter = mitk::SurfaceToImageFilter::New();
   surfaceToImageFilter->SetInput( segmentationAsSurface );
   surfaceToImageFilter->SetImage( m_ReferenceImage );
   surfaceToImageFilter->SetMakeOutputBinary(true);
   surfaceToImageFilter->Update();
 
   m_SegmentationAsImage = surfaceToImageFilter->GetOutput();
 
   // Cleanup the pipeline
   m_SegmentationAsImage->DisconnectPipeline();
 
   return m_SegmentationAsImage;
 }
 
 
 mitk::Surface::Pointer mitk::PlanarFigureSegmentationController::CreateSurfaceFromPlanarFigure( mitk::PlanarFigure::Pointer figure )
 {
   if ( figure.IsNull() )
   {
     MITK_ERROR << "Given PlanarFigure is NULL. Please provide valid PlanarFigure.";
     return NULL;
   }
 
   mitk::Surface::Pointer newSurface = mitk::Surface::New();
 
   vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
   vtkSmartPointer<vtkPolygon> polygon = vtkSmartPointer<vtkPolygon>::New();
   vtkSmartPointer<vtkCellArray> cells = vtkSmartPointer<vtkCellArray>::New();
   vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
 
   const mitk::PlaneGeometry* figureGeometry = figure->GetPlaneGeometry();
 
   // Get the polyline
   mitk::PlanarFigure::PolyLineType planarPolyLine = figure->GetPolyLine(0);
   mitk::PlanarFigure::PolyLineType::iterator iter;
 
   // iterate over the polyline, ...
   int pointCounter = 0;
   for( iter = planarPolyLine.begin(); iter != planarPolyLine.end(); iter++ )
   {
     // ... determine the world-coordinates
     mitk::Point3D pointInWorldCoordiantes;
     figureGeometry->Map( *iter, pointInWorldCoordiantes );
 
     // and add them as new points to the vtkPoints
     points->InsertNextPoint( pointInWorldCoordiantes[0], pointInWorldCoordiantes[1], pointInWorldCoordiantes[2] );
     ++pointCounter;
   }
 
   // create a polygon with the points of the polyline
   polygon->GetPointIds()->SetNumberOfIds( pointCounter );
   for(int i = 0; i < pointCounter; i++)
   {
     polygon->GetPointIds()->SetId(i,i);
   }
 
   // initialize the vtkCellArray and vtkPolyData
   cells->InsertNextCell(polygon);
   polyData->SetPoints(points);
   polyData->SetPolys( cells );
 
   // set the polydata to the surface
   newSurface->SetVtkPolyData( polyData );
 
   return newSurface;
 }
 
 mitk::PlanarFigureSegmentationController::PlanarFigureListType mitk::PlanarFigureSegmentationController::GetAllPlanarFigures()
 {
   return m_PlanarFigureList;
 }
 
 void mitk::PlanarFigureSegmentationController::InitializeFilters()
 {
   m_ReduceFilter = mitk::ReduceContourSetFilter::New();
   m_ReduceFilter->SetReductionType(ReduceContourSetFilter::NTH_POINT);
   m_ReduceFilter->SetStepSize( 10 );
   m_NormalsFilter = mitk::ComputeContourSetNormalsFilter::New();
   m_DistanceImageCreator = mitk::CreateDistanceImageFromSurfaceFilter::New();
 }