diff --git a/Modules/Segmentation/Testing/CMakeLists.txt b/Modules/Segmentation/Testing/CMakeLists.txt
index 263e573340..5ce56f7863 100644
--- a/Modules/Segmentation/Testing/CMakeLists.txt
+++ b/Modules/Segmentation/Testing/CMakeLists.txt
@@ -1,2 +1,2 @@
 MITK_CREATE_MODULE_TESTS()
-#mitkAddCustomModuleTest(mitkSegmentationInterpolationTest mitkSegmentationInterpolationTest ${MITK_DATA_DIR}/interpolation_test_manual.nrrd ${MITK_DATA_DIR}/interpolation_test_result.nrrd)
+mitkAddCustomModuleTest(mitkSegmentationInterpolationTest mitkSegmentationInterpolationTest ${MITK_DATA_DIR}/interpolation_test_manual.nrrd ${MITK_DATA_DIR}/interpolation_test_result.nrrd)
diff --git a/Modules/Segmentation/Testing/files.cmake b/Modules/Segmentation/Testing/files.cmake
index 94a3978d29..7a2fb075d2 100644
--- a/Modules/Segmentation/Testing/files.cmake
+++ b/Modules/Segmentation/Testing/files.cmake
@@ -1,24 +1,24 @@
 set(MODULE_TESTS
   mitkContourMapper2DTest.cpp
   mitkContourTest.cpp
   mitkDataNodeSegmentationTest.cpp
-  #mitkSegmentationInterpolationTest.cpp
+  mitkSegmentationInterpolationTest.cpp
   mitkOverwriteSliceFilterTest.cpp
 #  mitkOverwriteSliceFilterObliquePlaneTest.cpp
 )
 
 set(MODULE_IMAGE_TESTS
   mitkManualSegmentationToSurfaceFilterTest.cpp
-  #mitkOverwriteSliceImageFilterTest.cpp
+  mitkOverwriteSliceImageFilterTest.cpp
 )
 set(MODULE_CUSTOM_TESTS
 )
 set(MODULE_TESTIMAGES
   US4DCyl.nrrd
   Pic3D.nrrd
   Pic2DplusT.nrrd
   BallBinary30x30x30.nrrd
   Png2D-bw.png
   binary.stl
   ball.stl
 )
diff --git a/Modules/Segmentation/Testing/mitkOverwriteSliceImageFilterTest.cpp b/Modules/Segmentation/Testing/mitkOverwriteSliceImageFilterTest.cpp
index 1c77d902e8..f716958e95 100644
--- a/Modules/Segmentation/Testing/mitkOverwriteSliceImageFilterTest.cpp
+++ b/Modules/Segmentation/Testing/mitkOverwriteSliceImageFilterTest.cpp
@@ -1,392 +1,392 @@
 /*===================================================================
 
 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 "mitkExtractImageFilter.h"
 #include "mitkOverwriteSliceImageFilter.h"
 #include "mitkCoreObjectFactory.h"
 #include "mitkDataNodeFactory.h"
 #include "mitkCompareImageSliceTestHelper.h"
 
 unsigned int CompareImageSliceTestHelper::m_Dimension0 = 0;
 unsigned int CompareImageSliceTestHelper::m_Dimension1 = 0;
 unsigned int CompareImageSliceTestHelper::m_SliceDimension = 0;
 unsigned int CompareImageSliceTestHelper::m_SliceIndex = 0;
 bool CompareImageSliceTestHelper::m_ComparisonResult = false;
 mitk::Image* CompareImageSliceTestHelper::m_SliceImage = NULL;
 
 class mitkOverwriteSliceImageFilterTestClass
 {
 
   public:
 
 static void Test3D( mitk::OverwriteSliceImageFilter* filter, mitk::Image* image, unsigned int& numberFailed )
 {
   assert(filter);
   assert(image);
 
   filter->SetInput( image );
   
   unsigned int initialNumberFailed = numberFailed;
   bool exception = false;
   // first extract slices and rewrite them
-  for ( unsigned int sliceDimension = 0; sliceDimension < 6; ++sliceDimension )
+  for ( unsigned int sliceDimension = 0; sliceDimension < 3; ++sliceDimension )
   {
     mitk::ExtractImageFilter::Pointer extractor = mitk::ExtractImageFilter::New();
     extractor->SetInput( image );
     extractor->SetSliceDimension( sliceDimension );
     extractor->SetSliceIndex( 2 ); // third slice in that direction
 
     try 
     {
       extractor->Update();
     }
     catch(...)
     {
       if ( sliceDimension < 3 )
       {
          // probably no sliceindex 2 there or extractor just doesn't work (check the corresponding test)
         std::cout << "  (WW) Couldn't extract slice number 3 from a 3D image. This could be a problem if the image is not only two slices big." << std::endl;
         continue;
       }
       else
       {
         continue; // good
       }
     }
 
-    mitk::Image::Pointer slice = extractor->GetOutput();
+    mitk::Image::Pointer slice = extractor->GetOutput()->Clone();
 
     filter->SetSliceDimension( sliceDimension );
     filter->SetSliceIndex( 1 ); // second slice in that direction
     filter->SetSliceImage( slice );
 
     try
     {
       filter->Update(); // try to overwrite
     }
     catch(...)
     {
       if ( sliceDimension < 3 )
       {
         ++numberFailed;
         std::cerr << "  (EE) Couln't overwrite a slice with data from a neigbor in a " 
                   << image->GetDimension() 
                   << "-dimensional image, sliceDimension " 
                   << sliceDimension 
                   << " sliceIndex 1-2." << "(l. " << __LINE__ << ")" << std::endl;
       }
       else
       {
         // this was expected and is nice to see
         continue;
       }
     }
 
     mitk::Image::Pointer output = filter->GetOutput();
 
     if (output.IsNull())
     {
       ++numberFailed;
       std::cerr << "  (EE) Overwrite filter has output NULL and gave no exception for an "
                 << image->GetDimension() 
                 << "-dimensional image, sliceDimension " 
                 << sliceDimension 
                 << " sliceIndex 1-2." << "(l. " << __LINE__ << ")" << std::endl;
        continue;
     }
 
     if (!CompareImageSliceTestHelper::CompareSlice( image, sliceDimension , 1 , slice ))
     {
       ++numberFailed;
       std::cerr << "  (EE) Overwriting a slice seemed to work, but the pixels are not correct for an "
                 << image->GetDimension() 
                 << "-dimensional image, sliceDimension " 
                 << sliceDimension 
                 << " sliceIndex 1-2." << "(l. " << __LINE__ << ")" << std::endl;
     }
 
 
     // try inserting at a position outside the image
     filter->SetSliceDimension( sliceDimension );
     filter->SetSliceIndex( image->GetDimension(sliceDimension)  ); // last possible slice index + 1
     filter->SetSliceImage( slice );
 
     exception = false;
     try
     {
       filter->Update(); // try to overwrite
     }
     catch(...)
     {
       exception = true;
     }
     
     if (!exception)
     {
       ++numberFailed;
       std::cerr << "  (EE) Inserting a slice outside the 3D volume did NOT throw an exception for an " 
                 << image->GetDimension() 
                 << "-dimensional image, sliceDimension " 
                 << sliceDimension 
                 << " sliceIndex 1-2." << "(l. " << __LINE__ << ")" << std::endl;
     }
 
  
     mitk::Image::Pointer originalSlice = slice;
 
     // now test slices that just don't fit (slice too big)
     {
       unsigned int dim[]={ slice->GetDimension(0) + 2, slice->GetDimension(1) + 2 };
       slice = mitk::Image::New();
       slice-> Initialize(mitk::MakeScalarPixelType<signed int>() , 2, dim);
       unsigned int i;
       signed int *p = (signed int*)slice->GetData();
       unsigned int size = dim[0]*dim[1];
       for(i=0; i<size; ++i, ++p)
         *p= (signed int)i;
 
       // try to insert this bad slice 
       filter->SetSliceImage( slice );
       exception = false;
       try
       {
         filter->Update(); // try to overwrite
       }
       catch(...)
       {
         exception = true;
       }
 
       if (!exception)
       {
         ++numberFailed;
         std::cerr << "  (EE) Trying to insert a slice of bad dimensions (larger) did NOT throw an exception in an "
                   << image->GetDimension() 
                   << "-dimensional image, sliceDimension " 
                   << sliceDimension 
                   << " sliceIndex 1-2." << "(l. " << __LINE__ << ")" << std::endl;
       }
     }
 
     // now test slices that just don't fit (slice too small)
     {
       slice = originalSlice;
       if ( (slice->GetDimension(0) <3) || (slice->GetDimension(1) <3) ) continue; // not possible shrink the image much further
       unsigned int dim[]={ slice->GetDimension(0) - 2, slice->GetDimension(1) - 2 };
       slice = mitk::Image::New();
       slice-> Initialize(mitk::MakeScalarPixelType<signed int>(), 2, dim);
       unsigned int i;
       signed int *p = (signed int*)slice->GetData();
       unsigned int size = dim[0]*dim[1];
       for(i=0; i<size; ++i, ++p)
         *p= (signed int)i;
 
       // try to insert this bad slice 
       filter->SetSliceImage( slice );
       exception = false;
       try
       {
         filter->Update(); // try to overwrite
       }
       catch(...)
       {
         exception = true;
       }
 
       if (!exception)
       {
         ++numberFailed;
         std::cerr << "  (EE) Trying to insert a slice of bad dimensions (smaller) did NOT throw an exception in an "
                   << image->GetDimension() 
                   << "-dimensional image, sliceDimension " 
                   << sliceDimension 
                   << " sliceIndex 1-2." << "(l. " << __LINE__ << ")" << std::endl;
       }
     }
    
   }
   
 
 
   if ( numberFailed == initialNumberFailed )
   {
     std::cout << "  (II) Overwriting works nicely (gives result, pixels are good) "
-              << image->GetDimension() 
+              << image->GetDimension()
               << "-dimensional image." << "(l. " << __LINE__ << ")" << std::endl;
   }
 }
 
 
 static void Test2D( mitk::OverwriteSliceImageFilter* filter, mitk::Image* image, unsigned int& numberFailed )
 {
   assert(filter);
   assert(image);
 
   filter->SetInput( image );
   filter->SetSliceImage( image );
   bool exception = false;
   try
   {
     filter->Update();
   }
   catch(...)
   {
     exception = true;
   }
 
   if (!exception)
   {
     std::cerr << "  (EE) Using OverwriteImageFilter for 2D -> 2D did not throw an exception "
               << "(l. " << __LINE__ << ")" << std::endl;
   }
 
   unsigned int initialNumberFailed = numberFailed;
   if ( numberFailed == initialNumberFailed )
   {
     std::cout << "  (II) Overwriting works nicely (gives result, pixels are good) "
               << image->GetDimension() 
               << "-dimensional image." << "(l. " << __LINE__ << ")" << std::endl;
   }
 }
 
 static void TestOtherD( mitk::OverwriteSliceImageFilter* filter, mitk::Image* image, unsigned int& numberFailed )
 {
   assert(filter);
   assert(image);
 
   filter->SetInput( image );
   filter->SetSliceImage( image );
   bool exception = false;
   try
   {
     filter->Update();
   }
   catch(...)
   {
     exception = true;
   }
 
   if (!exception)
   {
     std::cerr << "  (EE) Using OverwriteImageFilter did not throw an exception "
               << "(l. " << __LINE__ << ")" << std::endl;
   }
 
   unsigned int initialNumberFailed = numberFailed;
   if ( numberFailed == initialNumberFailed )
   {
     std::cout << "  (II) Overwriting works nicely (gives result, pixels are good) "
               << image->GetDimension() 
               << "-dimensional image." << "(l. " << __LINE__ << ")" << std::endl;
   }
 }
 
 
 };
 
 /// ctest entry point
 int mitkOverwriteSliceImageFilterTest(int argc, char* argv[])
 {
   // one big variable to tell if anything went wrong
     unsigned int numberFailed(0);
  
   // need one parameter (image filename)
     if(argc==0)
     {
       std::cerr<<"No file specified [FAILED]"<<std::endl;
       return EXIT_FAILURE;
     }
  
   // load the image
 
     mitk::Image::Pointer image = NULL;
     mitk::DataNodeFactory::Pointer factory = mitk::DataNodeFactory::New();
     try
     {
       std::cout << "Testing with parameter '" << argv[1] << "'" << std::endl;
       factory->SetFileName( argv[1] );
       factory->Update();
 
       if(factory->GetNumberOfOutputs()<1)
       {
         std::cerr<<"File could not be loaded [FAILED]"<<std::endl;
         return EXIT_FAILURE;
       }
       mitk::DataNode::Pointer node = factory->GetOutput( 0 );
       image = dynamic_cast<mitk::Image*>(node->GetData());
       if(image.IsNull())
       {
         std::cout<<"File not an image - test will not be applied [PASSED]"<<std::endl;
         std::cout<<"[TEST DONE]"<<std::endl;
         return EXIT_SUCCESS;
       }
     }
     catch ( itk::ExceptionObject & ex )
     {
       ++numberFailed;
       std::cerr << "Exception: " << ex << "[FAILED]" << std::endl;
       return EXIT_FAILURE;
     }
 
     std::cout << "  (II) Could load image." << std::endl;
     std::cout << "Testing filter instantiation" << std::endl;
 
   // instantiation
     mitk::OverwriteSliceImageFilter::Pointer filter = mitk::OverwriteSliceImageFilter::New();
     if (filter.IsNotNull())
     {
       std::cout << "  (II) Instantiation works." << std::endl;
     }
     else
     {
       ++numberFailed;
       std::cout << "Test failed, and it's the ugliest one!" << std::endl;
       return EXIT_FAILURE;
     }
 
   // some real work
     if ( image->GetDimension() == 2 )
     {
       mitkOverwriteSliceImageFilterTestClass::Test2D( filter, image, numberFailed );
     }
     else if ( image->GetDimension() == 3 )
     {
       mitkOverwriteSliceImageFilterTestClass::Test3D( filter, image, numberFailed );
     }
     else
     {
       mitkOverwriteSliceImageFilterTestClass::TestOtherD( filter, image, numberFailed );
     }
   
     std::cout << "Testing filter destruction" << std::endl;
 
   // freeing
     filter = NULL;
       
     std::cout << "  (II) Freeing works." << std::endl;
 
     if (numberFailed > 0)
     {
       std::cerr << numberFailed << " tests failed." << std::endl;
       return EXIT_FAILURE;
     }
     else
     {
       std::cout << "PASSED all tests." << std::endl;
       return EXIT_SUCCESS;
     }
 }