diff --git a/Modules/Segmentation/Testing/mitkOverwriteSliceFilterObliquePlaneTest.cpp b/Modules/Segmentation/Testing/mitkOverwriteSliceFilterObliquePlaneTest.cpp
index 04cc20d065..8a8a185471 100644
--- a/Modules/Segmentation/Testing/mitkOverwriteSliceFilterObliquePlaneTest.cpp
+++ b/Modules/Segmentation/Testing/mitkOverwriteSliceFilterObliquePlaneTest.cpp
@@ -1,258 +1,258 @@
 /*===================================================================
 
 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 <mitkTestingMacros.h>
 
 #include <mitkExtractSliceFilter.h>
 #include <mitkGeometry3D.h>
 #include <mitkImageCast.h>
 #include <mitkImagePixelReadAccessor.h>
 #include <mitkInteractionConst.h>
 #include <mitkRotationOperation.h>
 #include <mitkVtkImageOverwrite.h>
 
 #include <itkImage.h>
 #include <itkImageRegionIterator.h>
 
 #include <vtkImageData.h>
 #include <vtkSmartPointer.h>
 
 int ObliquePlaneTestVolumeSize = 128;
 
 static void OverwriteObliquePlaneTest(mitk::Image *workingImage, mitk::Image *refImg)
 {
   /*==============TEST WITHOUT MITK CONVERTION=============================*/
 
   /* ============= setup plane ============*/
   int sliceindex = (int)(ObliquePlaneTestVolumeSize / 2); // rand() % 32;
   bool isFrontside = true;
   bool isRotated = false;
 
   mitk::PlaneGeometry::Pointer obliquePlane = mitk::PlaneGeometry::New();
   obliquePlane->InitializeStandardPlane(
     workingImage->GetGeometry(), mitk::PlaneGeometry::Axial, sliceindex, isFrontside, isRotated);
   mitk::Point3D origin = obliquePlane->GetOrigin();
   mitk::Vector3D normal;
   normal = obliquePlane->GetNormal();
   normal.Normalize();
   origin += normal * 0.5; // pixelspacing is 1, so half the spacing is 0.5
   obliquePlane->SetOrigin(origin);
 
   mitk::Vector3D rotationVector = obliquePlane->GetAxisVector(0);
   rotationVector.Normalize();
 
   float degree = 45.0;
 
   auto op = new mitk::RotationOperation(mitk::OpROTATE, obliquePlane->GetCenter(), rotationVector, degree);
   obliquePlane->ExecuteOperation(op);
   delete op;
 
   /* ============= extract slice ============*/
   mitk::ExtractSliceFilter::Pointer slicer = mitk::ExtractSliceFilter::New();
   slicer->SetInput(workingImage);
   slicer->SetWorldGeometry(obliquePlane);
   slicer->SetVtkOutputRequest(true);
   slicer->Modified();
   slicer->Update();
 
   vtkSmartPointer<vtkImageData> slice = vtkSmartPointer<vtkImageData>::New();
   slice = slicer->GetVtkOutput();
 
   /* ============= overwrite slice ============*/
   vtkSmartPointer<mitkVtkImageOverwrite> resliceIdx = vtkSmartPointer<mitkVtkImageOverwrite>::New();
   mitk::ExtractSliceFilter::Pointer overwriter = mitk::ExtractSliceFilter::New(resliceIdx);
   resliceIdx->SetOverwriteMode(true);
   resliceIdx->SetInputSlice(slice);
   resliceIdx->Modified();
   overwriter->SetInput(workingImage);
   overwriter->SetWorldGeometry(obliquePlane);
   overwriter->SetVtkOutputRequest(true);
   overwriter->Modified();
   overwriter->Update();
 
   typedef mitk::ImagePixelReadAccessor<unsigned short, 3> ReadAccessorType;
   ReadAccessorType refImgReadAccessor(refImg);
   ReadAccessorType workingImgReadAccessor(workingImage);
 
   /* ============= check ref == working ============*/
   bool areSame = true;
   itk::Index<3> id;
   id[0] = id[1] = id[2] = 0;
   for (int x = 0; x < ObliquePlaneTestVolumeSize; ++x)
   {
     id[0] = x;
     for (int y = 0; y < ObliquePlaneTestVolumeSize; ++y)
     {
       id[1] = y;
       for (int z = 0; z < ObliquePlaneTestVolumeSize; ++z)
       {
         id[2] = z;
         areSame = refImgReadAccessor.GetPixelByIndex(id) == workingImgReadAccessor.GetPixelByIndex(id);
         if (!areSame)
           goto stop;
       }
     }
   }
 stop:
   MITK_TEST_CONDITION(areSame, "comparing images (no mitk convertion) [oblique]");
 
   /*==============TEST WITH MITK CONVERTION=============================*/
 
   /* ============= extract slice ============*/
   mitk::ExtractSliceFilter::Pointer slicer2 = mitk::ExtractSliceFilter::New();
   slicer2->SetInput(workingImage);
   slicer2->SetWorldGeometry(obliquePlane);
   slicer2->Modified();
   slicer2->Update();
 
   mitk::Image::Pointer sliceInMitk = slicer2->GetOutput();
   vtkSmartPointer<vtkImageData> slice2 = vtkSmartPointer<vtkImageData>::New();
   slice2 = sliceInMitk->GetVtkImageData();
 
   /* ============= overwrite slice ============*/
   vtkSmartPointer<mitkVtkImageOverwrite> resliceIdx2 = vtkSmartPointer<mitkVtkImageOverwrite>::New();
   mitk::ExtractSliceFilter::Pointer overwriter2 = mitk::ExtractSliceFilter::New(resliceIdx2);
   resliceIdx2->SetOverwriteMode(true);
   resliceIdx2->SetInputSlice(slice2);
   resliceIdx2->Modified();
   overwriter2->SetInput(workingImage);
   overwriter2->SetWorldGeometry(obliquePlane);
   overwriter2->SetVtkOutputRequest(true);
   overwriter2->Modified();
   overwriter2->Update();
 
   /* ============= check ref == working ============*/
   areSame = true;
   id[0] = id[1] = id[2] = 0;
   for (int x = 0; x < ObliquePlaneTestVolumeSize; ++x)
   {
     id[0] = x;
     for (int y = 0; y < ObliquePlaneTestVolumeSize; ++y)
     {
       id[1] = y;
       for (int z = 0; z < ObliquePlaneTestVolumeSize; ++z)
       {
         id[2] = z;
         areSame = refImgReadAccessor.GetPixelByIndex(id) == workingImgReadAccessor.GetPixelByIndex(id);
         if (!areSame)
           goto stop2;
       }
     }
   }
 stop2:
   MITK_TEST_CONDITION(areSame, "comparing images (with mitk convertion) [oblique]");
 
   /*==============TEST EDIT WITHOUT MITK CONVERTION=============================*/
 
   /* ============= edit slice ============*/
   int idX = std::abs(ObliquePlaneTestVolumeSize - 59);
   int idY = std::abs(ObliquePlaneTestVolumeSize - 23);
   int idZ = 0;
   int component = 0;
   double val = 33.0;
 
   slice->SetScalarComponentFromDouble(idX, idY, idZ, component, val);
 
   mitk::Vector3D indx;
   indx[0] = idX;
   indx[1] = idY;
   indx[2] = idZ;
   sliceInMitk->GetGeometry()->IndexToWorld(indx, indx);
 
   /* ============= overwrite slice ============*/
 
   vtkSmartPointer<mitkVtkImageOverwrite> resliceIdx3 = vtkSmartPointer<mitkVtkImageOverwrite>::New();
   resliceIdx3->SetOverwriteMode(true);
   resliceIdx3->SetInputSlice(slice);
   mitk::ExtractSliceFilter::Pointer overwriter3 = mitk::ExtractSliceFilter::New(resliceIdx3);
   overwriter3->SetInput(workingImage);
   overwriter3->SetWorldGeometry(obliquePlane);
   overwriter3->SetVtkOutputRequest(true);
   overwriter3->Modified();
   overwriter3->Update();
 
   /* ============= check ============*/
   areSame = true;
 
-  int x, y, z;
+  int x = 0;
+  int y = 0;
+  int z = 0;
 
   for (x = 0; x < ObliquePlaneTestVolumeSize; ++x)
   {
     id[0] = x;
     for (y = 0; y < ObliquePlaneTestVolumeSize; ++y)
     {
       id[1] = y;
       for (z = 0; z < ObliquePlaneTestVolumeSize; ++z)
       {
         id[2] = z;
         areSame = refImgReadAccessor.GetPixelByIndex(id) == workingImgReadAccessor.GetPixelByIndex(id);
         if (!areSame)
           goto stop3;
       }
     }
   }
 stop3:
-  // MITK_INFO << "index: [" << x << ", " << y << ", " << z << "]";
-  // MITK_INFO << indx;
   MITK_TEST_CONDITION(x == idX && y == z, "overwrited the right index [oblique]");
 }
 
 /*================ #BEGIN test main ================*/
 int mitkOverwriteSliceFilterObliquePlaneTest(int, char *[])
 {
   MITK_TEST_BEGIN("mitkOverwriteSliceFilterObliquePlaneTest")
 
   typedef itk::Image<unsigned short, 3> ImageType;
 
   typedef itk::ImageRegionConstIterator<ImageType> ImageIterator;
 
   ImageType::Pointer image = ImageType::New();
 
   ImageType::IndexType start;
   start[0] = start[1] = start[2] = 0;
 
   ImageType::SizeType size;
   size[0] = size[1] = size[2] = ObliquePlaneTestVolumeSize;
 
   ImageType::RegionType imgRegion;
   imgRegion.SetSize(size);
   imgRegion.SetIndex(start);
 
   image->SetRegions(imgRegion);
   image->SetSpacing(1.0);
   image->Allocate();
 
   ImageIterator imageIterator(image, image->GetLargestPossibleRegion());
   imageIterator.GoToBegin();
 
   unsigned short pixelValue = 0;
 
   // fill the image with distinct values
   while (!imageIterator.IsAtEnd())
   {
     image->SetPixel(imageIterator.GetIndex(), pixelValue);
     ++imageIterator;
     ++pixelValue;
   }
   /* end setup itk image */
 
   mitk::Image::Pointer refImage;
   CastToMitkImage(image, refImage);
   mitk::Image::Pointer workingImg;
   CastToMitkImage(image, workingImg);
   OverwriteObliquePlaneTest(workingImg, refImage);
 
   MITK_TEST_END()
 }
diff --git a/Modules/Segmentation/Testing/mitkOverwriteSliceFilterTest.cpp b/Modules/Segmentation/Testing/mitkOverwriteSliceFilterTest.cpp
index 3dbef0201e..fe1c4c21b3 100644
--- a/Modules/Segmentation/Testing/mitkOverwriteSliceFilterTest.cpp
+++ b/Modules/Segmentation/Testing/mitkOverwriteSliceFilterTest.cpp
@@ -1,183 +1,185 @@
 /*===================================================================
 
 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 <mitkTestingMacros.h>
 
 #include <mitkExtractSliceFilter.h>
 #include <mitkGeometry3D.h>
 #include <mitkImageCast.h>
 #include <mitkImagePixelReadAccessor.h>
 #include <mitkInteractionConst.h>
 #include <mitkRotationOperation.h>
 #include <mitkVtkImageOverwrite.h>
 
 #include <itkImage.h>
 #include <itkImageRegionIterator.h>
 
 #include <vtkImageData.h>
 #include <vtkSmartPointer.h>
 
 int VolumeSize = 128;
 
 /*================ #BEGIN test main ================*/
 int mitkOverwriteSliceFilterTest(int, char *[])
 {
   MITK_TEST_BEGIN("mitkOverwriteSliceFilterTest")
 
   typedef itk::Image<unsigned short, 3> ImageType;
 
   typedef itk::ImageRegionConstIterator<ImageType> ImageIterator;
 
   ImageType::Pointer image = ImageType::New();
 
   ImageType::IndexType start;
   start[0] = start[1] = start[2] = 0;
 
   ImageType::SizeType size;
   size[0] = size[1] = size[2] = VolumeSize;
 
   ImageType::RegionType imgRegion;
   imgRegion.SetSize(size);
   imgRegion.SetIndex(start);
 
   image->SetRegions(imgRegion);
   image->SetSpacing(1.0);
   image->Allocate();
 
   ImageIterator imageIterator(image, image->GetLargestPossibleRegion());
   imageIterator.GoToBegin();
 
   unsigned short pixelValue = 0;
 
   // fill the image with distinct values
   while (!imageIterator.IsAtEnd())
   {
     image->SetPixel(imageIterator.GetIndex(), pixelValue);
     ++imageIterator;
     ++pixelValue;
   }
   /* end setup itk image */
 
   mitk::Image::Pointer referenceImage;
   CastToMitkImage(image, referenceImage);
   mitk::Image::Pointer workingImage;
   CastToMitkImage(image, workingImage);
 
   typedef mitk::ImagePixelReadAccessor<unsigned short, 3> ReadAccessorType;
   ReadAccessorType refImgReadAccessor(referenceImage);
   ReadAccessorType workingImgReadAccessor(workingImage);
 
   /* ============= setup plane ============*/
   int sliceindex = 55; // rand() % 32;
   bool isFrontside = true;
   bool isRotated = false;
 
   mitk::PlaneGeometry::Pointer plane = mitk::PlaneGeometry::New();
   plane->InitializeStandardPlane(
     workingImage->GetGeometry(), mitk::PlaneGeometry::Axial, sliceindex, isFrontside, isRotated);
   mitk::Point3D origin = plane->GetOrigin();
   mitk::Vector3D normal;
   normal = plane->GetNormal();
   normal.Normalize();
   origin += normal * 0.5; // pixelspacing is 1, so half the spacing is 0.5
   plane->SetOrigin(origin);
 
   /* ============= extract slice ============*/
   vtkSmartPointer<mitkVtkImageOverwrite> resliceIdx = vtkSmartPointer<mitkVtkImageOverwrite>::New();
   mitk::ExtractSliceFilter::Pointer slicer = mitk::ExtractSliceFilter::New(resliceIdx);
   slicer->SetInput(workingImage);
   slicer->SetWorldGeometry(plane);
   slicer->SetVtkOutputRequest(true);
   slicer->Modified();
   slicer->Update();
 
   vtkSmartPointer<vtkImageData> slice = vtkSmartPointer<vtkImageData>::New();
   slice = slicer->GetVtkOutput();
 
   /* ============= overwrite slice ============*/
   resliceIdx->SetOverwriteMode(true);
   resliceIdx->Modified();
   slicer->Modified();
   slicer->Update(); // implicit overwrite
 
   /* ============= check ref == working ============*/
   bool areSame = true;
   itk::Index<3> id;
   id[0] = id[1] = id[2] = 0;
   for (int x = 0; x < VolumeSize; ++x)
   {
     id[0] = x;
     for (int y = 0; y < VolumeSize; ++y)
     {
       id[1] = y;
       for (int z = 0; z < VolumeSize; ++z)
       {
         id[2] = z;
         areSame = refImgReadAccessor.GetPixelByIndex(id) == workingImgReadAccessor.GetPixelByIndex(id);
         if (!areSame)
           goto stop;
       }
     }
   }
 stop:
   MITK_TEST_CONDITION(areSame, "test overwrite unmodified slice");
 
   /* ============= edit slice ============*/
   int idX = std::abs(VolumeSize - 59);
   int idY = std::abs(VolumeSize - 23);
   int idZ = 0;
   int component = 0;
   double val = 33.0;
 
   slice->SetScalarComponentFromDouble(idX, idY, idZ, component, val);
 
   /* ============= overwrite slice ============*/
 
   vtkSmartPointer<mitkVtkImageOverwrite> resliceIdx2 = vtkSmartPointer<mitkVtkImageOverwrite>::New();
   resliceIdx2->SetOverwriteMode(true);
   resliceIdx2->SetInputSlice(slice);
   mitk::ExtractSliceFilter::Pointer slicer2 = mitk::ExtractSliceFilter::New(resliceIdx2);
   slicer2->SetInput(workingImage);
   slicer2->SetWorldGeometry(plane);
   slicer2->SetVtkOutputRequest(true);
   slicer2->Modified();
   slicer2->Update();
 
   /* ============= check ============*/
   areSame = true;
 
-  int xx, yy, zz;
+  int xx = 0;
+  int yy = 0;
+  int zz = 0;
 
   for (xx = 0; xx < VolumeSize; ++xx)
   {
     id[0] = xx;
     for (yy = 0; yy < VolumeSize; ++yy)
     {
       id[1] = yy;
       for (zz = 0; zz < VolumeSize; ++zz)
       {
         id[2] = zz;
         areSame = refImgReadAccessor.GetPixelByIndex(id) == workingImgReadAccessor.GetPixelByIndex(id);
         if (!areSame)
           goto stop2;
       }
     }
   }
 stop2:
   // MITK_INFO << "index: [" << x << ", " << y << ", " << z << "]";
   MITK_TEST_CONDITION(xx == idX && yy == idY && zz == sliceindex, "test overwrite modified slice");
 
   MITK_TEST_END()
 }
diff --git a/Modules/Segmentation/Testing/mitkSegmentationInterpolationTest.cpp b/Modules/Segmentation/Testing/mitkSegmentationInterpolationTest.cpp
index 1335704aa0..f5618bd889 100644
--- a/Modules/Segmentation/Testing/mitkSegmentationInterpolationTest.cpp
+++ b/Modules/Segmentation/Testing/mitkSegmentationInterpolationTest.cpp
@@ -1,208 +1,208 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 // Testing
 #include <mitkTestFixture.h>
 #include <mitkTestingMacros.h>
 
 // other
 #include <mitkExtractSliceFilter.h>
 #include <mitkIOUtil.h>
 #include <mitkImage.h>
 #include <mitkImagePixelReadAccessor.h>
 #include <mitkImagePixelWriteAccessor.h>
 #include <mitkSegmentationInterpolationController.h>
 #include <mitkSliceNavigationController.h>
 #include <mitkTool.h>
 #include <mitkVtkImageOverwrite.h>
 
 class mitkSegmentationInterpolationTestSuite : public mitk::TestFixture
 {
   CPPUNIT_TEST_SUITE(mitkSegmentationInterpolationTestSuite);
   MITK_TEST(Equal_Axial_TestInterpolationAndReferenceInterpolation_ReturnsTrue);
   MITK_TEST(Equal_Frontal_TestInterpolationAndReferenceInterpolation_ReturnsTrue);
   MITK_TEST(Equal_Sagittal_TestInterpolationAndReferenceInterpolation_ReturnsTrue);
   CPPUNIT_TEST_SUITE_END();
 
 private:
   // The tests all do the same, only in different directions
   void testRoutine(mitk::SliceNavigationController::ViewDirection viewDirection)
   {
     int dim;
     switch (viewDirection)
     {
       case (mitk::SliceNavigationController::Axial):
         dim = 2;
         break;
       case (mitk::SliceNavigationController::Frontal):
         dim = 1;
         break;
       case (mitk::SliceNavigationController::Sagittal):
         dim = 0;
         break;
-      case (mitk::SliceNavigationController::Original):
+      default: // mitk::SliceNavigationController::Original
         dim = -1;
-        break; // This is just to get rid of a warning
+        break;
     }
 
     /* Fill segmentation
      *
      * 1st slice: 3x3 square segmentation
      * 2nd slice: empty
      * 3rd slice: 1x1 square segmentation in corner
      * -> 2nd slice should become 2x2 square in corner
      *
      * put accessor in scope
      */
 
     itk::Index<3> currentPoint;
     {
       mitk::ImagePixelWriteAccessor<mitk::Tool::DefaultSegmentationDataType, 3> writeAccessor(m_SegmentationImage);
 
       // Fill 3x3 slice
       currentPoint[dim] = m_CenterPoint[dim] - 1;
       for (int i = -1; i <= 1; ++i)
       {
         for (int j = -1; j <= 1; ++j)
         {
           currentPoint[(dim + 1) % 3] = m_CenterPoint[(dim + 1) % 3] + i;
           currentPoint[(dim + 2) % 3] = m_CenterPoint[(dim + 2) % 3] + j;
           writeAccessor.SetPixelByIndexSafe(currentPoint, 1);
         }
       }
       // Now i=j=1, set point two slices up
       currentPoint[dim] = m_CenterPoint[dim] + 1;
       writeAccessor.SetPixelByIndexSafe(currentPoint, 1);
     }
 
     //        mitk::IOUtil::Save(m_SegmentationImage, "SOME PATH");
 
     m_InterpolationController->SetSegmentationVolume(m_SegmentationImage);
     m_InterpolationController->SetReferenceVolume(m_ReferenceImage);
 
     // This could be easier...
     mitk::SliceNavigationController::Pointer navigationController = mitk::SliceNavigationController::New();
     navigationController->SetInputWorldTimeGeometry(m_SegmentationImage->GetTimeGeometry());
     navigationController->Update(viewDirection);
     mitk::Point3D pointMM;
     m_SegmentationImage->GetTimeGeometry()->GetGeometryForTimeStep(0)->IndexToWorld(m_CenterPoint, pointMM);
     navigationController->SelectSliceByPoint(pointMM);
     auto plane = navigationController->GetCurrentPlaneGeometry();
     mitk::Image::Pointer interpolationResult =
       m_InterpolationController->Interpolate(dim, m_CenterPoint[dim], plane, 0);
 
     //        mitk::IOUtil::Save(interpolationResult, "SOME PATH");
 
     // Write result into segmentation image
     vtkSmartPointer<mitkVtkImageOverwrite> reslicer = vtkSmartPointer<mitkVtkImageOverwrite>::New();
     reslicer->SetInputSlice(
       interpolationResult->GetSliceData()->GetVtkImageAccessor(interpolationResult)->GetVtkImageData());
     reslicer->SetOverwriteMode(true);
     reslicer->Modified();
     mitk::ExtractSliceFilter::Pointer extractor = mitk::ExtractSliceFilter::New(reslicer);
     extractor->SetInput(m_SegmentationImage);
     extractor->SetTimeStep(0);
     extractor->SetWorldGeometry(plane);
     extractor->SetVtkOutputRequest(true);
     extractor->SetResliceTransformByGeometry(m_SegmentationImage->GetTimeGeometry()->GetGeometryForTimeStep(0));
     extractor->Modified();
     extractor->Update();
 
     //        mitk::IOUtil::Save(m_SegmentationImage, "SOME PATH");
 
     // Check a 4x4 square, the center of which needs to be filled
     mitk::ImagePixelReadAccessor<mitk::Tool::DefaultSegmentationDataType, 3> readAccess(m_SegmentationImage);
     currentPoint = m_CenterPoint;
 
     for (int i = -1; i <= 2; ++i)
     {
       for (int j = -1; j <= 2; ++j)
       {
         currentPoint[(dim + 1) % 3] = m_CenterPoint[(dim + 1) % 3] + i;
         currentPoint[(dim + 2) % 3] = m_CenterPoint[(dim + 2) % 3] + j;
 
         if (i == -1 || i == 2 || j == -1 || j == 2)
         {
           CPPUNIT_ASSERT_MESSAGE("Have false positive segmentation.",
                                  readAccess.GetPixelByIndexSafe(currentPoint) == 0);
         }
         else
         {
           CPPUNIT_ASSERT_MESSAGE("Have false negative segmentation.",
                                  readAccess.GetPixelByIndexSafe(currentPoint) == 1);
         }
       }
     }
   }
 
   mitk::Image::Pointer m_ReferenceImage;
   mitk::Image::Pointer m_SegmentationImage;
   itk::Index<3> m_CenterPoint;
   mitk::SegmentationInterpolationController::Pointer m_InterpolationController;
 
 public:
   void setUp() override
   {
     m_ReferenceImage = mitk::IOUtil::LoadImage(GetTestDataFilePath("Pic3D.nrrd"));
     CPPUNIT_ASSERT_MESSAGE("Failed to load image for test: [Pic3D.nrrd]", m_ReferenceImage.IsNotNull());
 
     m_InterpolationController = mitk::SegmentationInterpolationController::GetInstance();
 
     // Create empty segmentation
     // Surely there must be a better way to get an image with all zeros?
     m_SegmentationImage = mitk::Image::New();
     const mitk::PixelType pixelType(mitk::MakeScalarPixelType<mitk::Tool::DefaultSegmentationDataType>());
     m_SegmentationImage->Initialize(pixelType, m_ReferenceImage->GetDimension(), m_ReferenceImage->GetDimensions());
     m_SegmentationImage->SetClonedTimeGeometry(m_ReferenceImage->GetTimeGeometry());
     unsigned int size = sizeof(mitk::Tool::DefaultSegmentationDataType);
     for (unsigned int dim = 0; dim < m_SegmentationImage->GetDimension(); ++dim)
     {
       size *= m_SegmentationImage->GetDimension(dim);
     }
     mitk::ImageWriteAccessor imageAccessor(m_SegmentationImage);
     memset(imageAccessor.GetData(), 0, size);
 
     // Work in the center of the image (Pic3D)
     m_CenterPoint = {{127, 127, 25}};
   }
 
   void tearDown() override
   {
     m_ReferenceImage = nullptr;
     m_SegmentationImage = nullptr;
     m_CenterPoint = {{0, 0, 0}};
   }
 
   void Equal_Axial_TestInterpolationAndReferenceInterpolation_ReturnsTrue()
   {
     mitk::SliceNavigationController::ViewDirection viewDirection = mitk::SliceNavigationController::Axial;
     testRoutine(viewDirection);
   }
 
   void Equal_Frontal_TestInterpolationAndReferenceInterpolation_ReturnsTrue() // Coronal
   {
     mitk::SliceNavigationController::ViewDirection viewDirection = mitk::SliceNavigationController::Frontal;
     testRoutine(viewDirection);
   }
 
   void Equal_Sagittal_TestInterpolationAndReferenceInterpolation_ReturnsTrue()
   {
     mitk::SliceNavigationController::ViewDirection viewDirection = mitk::SliceNavigationController::Sagittal;
     testRoutine(viewDirection);
   }
 };
 
 MITK_TEST_SUITE_REGISTRATION(mitkSegmentationInterpolation)