diff --git a/Modules/ContourModel/Algorithms/mitkContourModelSubDivisionFilter.cpp b/Modules/ContourModel/Algorithms/mitkContourModelSubDivisionFilter.cpp
index dec4e7d708..a7840e854f 100644
--- a/Modules/ContourModel/Algorithms/mitkContourModelSubDivisionFilter.cpp
+++ b/Modules/ContourModel/Algorithms/mitkContourModelSubDivisionFilter.cpp
@@ -1,202 +1,202 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkContourModelSubDivisionFilter.h"
 #include <mitkInteractionConst.h>
 #include <mitkPointOperation.h>
 
 mitk::ContourModelSubDivisionFilter::ContourModelSubDivisionFilter()
 {
   OutputType::Pointer output = dynamic_cast<OutputType *>(this->MakeOutput(0).GetPointer());
   this->SetNumberOfRequiredInputs(1);
   this->SetNumberOfIndexedOutputs(1);
   this->SetNthOutput(0, output.GetPointer());
   this->m_InterpolationIterations = 4;
 }
 mitk::ContourModelSubDivisionFilter::~ContourModelSubDivisionFilter()
 {
 }
 
 void mitk::ContourModelSubDivisionFilter::SetInput(const mitk::ContourModelSubDivisionFilter::InputType *input)
 {
   this->SetInput(0, input);
 }
 
 void mitk::ContourModelSubDivisionFilter::SetInput(unsigned int idx,
                                                    const mitk::ContourModelSubDivisionFilter::InputType *input)
 {
   if (idx + 1 > this->GetNumberOfInputs())
   {
     this->SetNumberOfRequiredInputs(idx + 1);
   }
   if (input != static_cast<InputType *>(this->ProcessObject::GetInput(idx)))
   {
     this->ProcessObject::SetNthInput(idx, const_cast<InputType *>(input));
     this->Modified();
   }
 }
 
 const mitk::ContourModelSubDivisionFilter::InputType *mitk::ContourModelSubDivisionFilter::GetInput(void)
 {
   if (this->GetNumberOfInputs() < 1)
     return nullptr;
   return static_cast<const mitk::ContourModelSubDivisionFilter::InputType *>(this->ProcessObject::GetInput(0));
 }
 
 const mitk::ContourModelSubDivisionFilter::InputType *mitk::ContourModelSubDivisionFilter::GetInput(unsigned int idx)
 {
   if (this->GetNumberOfInputs() < 1)
     return nullptr;
   return static_cast<const mitk::ContourModelSubDivisionFilter::InputType *>(this->ProcessObject::GetInput(idx));
 }
 
 void mitk::ContourModelSubDivisionFilter::GenerateData()
 {
   mitk::ContourModel::Pointer input = const_cast<mitk::ContourModel *>(this->GetInput(0));
 
   // mitk::ContourModelSubDivisionFilter::OutputType::Pointer outputContour = this->GetOutput();
 
   mitk::ContourModel::Pointer contour(input);
 
-  auto timestep = static_cast<int>(input->GetTimeSteps());
+  auto timestep = static_cast<TimeStepType>(input->GetTimeSteps());
 
-  for (int currentTimestep = 0; currentTimestep < timestep; currentTimestep++)
+  for (decltype(timestep) currentTimestep = 0; currentTimestep < timestep; currentTimestep++)
   {
     if (input->GetNumberOfVertices(currentTimestep) >= 4)
     {
       for (int iterations = 0; iterations < this->m_InterpolationIterations; iterations++)
       {
         auto it = contour->IteratorBegin();
         auto end = contour->IteratorEnd();
 
         auto first = contour->IteratorBegin();
         auto last = contour->IteratorEnd() - 1;
 
         // tempory contour to store result of a subdivision iteration
         mitk::ContourModel::Pointer tempContour = mitk::ContourModel::New();
 
         // insert subpoints
         while (it != end)
         {
           // add the current point to the temp contour
           tempContour->AddVertex((*it)->Coordinates, (*it)->IsControlPoint, currentTimestep);
 
           // control points for interpolation
           auto Ci = it;
           InputType::VertexIterator CiPlus1;
           InputType::VertexIterator CiPlus2;
           InputType::VertexIterator CiMinus1;
 
           // consider all possible cases
           if (it == first)
           {
             if (input->IsClosed(currentTimestep))
             {
               CiPlus1 = it + 1;
               CiPlus2 = it + 2;
               CiMinus1 = last;
             }
             else
             {
               CiPlus1 = it + 1;
               CiPlus2 = it + 2;
               CiMinus1 = it;
             }
           }
           else if (it == last)
           {
             if (input->IsClosed(currentTimestep))
             {
               CiPlus1 = first;
               CiPlus2 = first + 1;
               CiMinus1 = it - 1;
             }
             else
             {
               // don't add point after last
               break;
             }
           }
           else if (it == (last - 1))
           {
             if (input->IsClosed(currentTimestep))
             {
               CiPlus1 = it + 1;
               CiPlus2 = first;
               CiMinus1 = it - 1;
             }
             else
             {
               CiPlus1 = it + 1;
               CiPlus2 = it + 1;
               CiMinus1 = it - 1;
             }
           }
           else
           {
             CiPlus1 = it + 1;
             CiPlus2 = it + 2;
             CiMinus1 = it - 1;
           }
 
           /* F2i = Ci
           * F2i+1 = -1/16Ci-1 + 9/16Ci + 9/16Ci+1 - 1/16Ci+2
           */
           mitk::Point3D subpoint;
 
           mitk::Point3D a;
           a[0] = (-1.0 / 16.0) * (*CiMinus1)->Coordinates[0];
           a[1] = (-1.0 / 16.0) * (*CiMinus1)->Coordinates[1];
           a[2] = (-1.0 / 16.0) * (*CiMinus1)->Coordinates[2];
 
           mitk::Point3D b;
           b[0] = (9.0 / 16.0) * (*Ci)->Coordinates[0];
           b[1] = (9.0 / 16.0) * (*Ci)->Coordinates[1];
           b[2] = (9.0 / 16.0) * (*Ci)->Coordinates[2];
 
           mitk::Point3D c;
           c[0] = (9.0 / 16.0) * (*CiPlus1)->Coordinates[0];
           c[1] = (9.0 / 16.0) * (*CiPlus1)->Coordinates[1];
           c[2] = (9.0 / 16.0) * (*CiPlus1)->Coordinates[2];
 
           mitk::Point3D d;
           d[0] = (-1.0 / 16.0) * (*CiPlus2)->Coordinates[0];
           d[1] = (-1.0 / 16.0) * (*CiPlus2)->Coordinates[1];
           d[2] = (-1.0 / 16.0) * (*CiPlus2)->Coordinates[2];
 
           subpoint[0] = a[0] + b[0] + c[0] + d[0];
           subpoint[1] = a[1] + b[1] + c[1] + d[1];
           subpoint[2] = a[2] + b[2] + c[2] + d[2];
           InputType::VertexType subdivisionPoint(subpoint, false);
 
           // add the new subdivision point to our tempContour
           tempContour->AddVertex(subdivisionPoint.Coordinates, currentTimestep);
 
           it++;
         }
 
         // set the interpolated contour as the contour for the next iteration
         contour = tempContour;
       }
     }
     else
     {
       // filter not executeable - set input to output
       contour = input;
     }
   }
 
   // somehow the isClosed property is not set via copy constructor
   contour->SetClosed(input->IsClosed());
 
   this->SetNthOutput(0, contour);
 }
diff --git a/Modules/ContourModel/Algorithms/mitkContourModelUtils.cpp b/Modules/ContourModel/Algorithms/mitkContourModelUtils.cpp
index 71702c0e04..ff3ac6b625 100755
--- a/Modules/ContourModel/Algorithms/mitkContourModelUtils.cpp
+++ b/Modules/ContourModel/Algorithms/mitkContourModelUtils.cpp
@@ -1,238 +1,238 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include <mitkContourModelUtils.h>
 
 #include <mitkContourModelToSurfaceFilter.h>
 #include <mitkLabelSetImage.h>
 #include <mitkSurface.h>
 #include <vtkImageStencil.h>
 #include <vtkPointData.h>
 #include <vtkPolyData.h>
 #include <vtkPolyDataToImageStencil.h>
 
 mitk::ContourModelUtils::ContourModelUtils()
 {
 }
 
 mitk::ContourModelUtils::~ContourModelUtils()
 {
 }
 
 mitk::ContourModel::Pointer mitk::ContourModelUtils::ProjectContourTo2DSlice(
   const Image *slice, const ContourModel *contourIn3D, bool, bool)
 {
   if (nullptr == slice || nullptr == contourIn3D)
     return nullptr;
 
   auto projectedContour = ContourModel::New();
   projectedContour->Initialize(*contourIn3D);
 
   auto sliceGeometry = slice->GetGeometry();
-  auto numberOfTimesteps = static_cast<int>(contourIn3D->GetTimeSteps());
+  auto numberOfTimesteps = static_cast<TimeStepType>(contourIn3D->GetTimeSteps());
 
   for (decltype(numberOfTimesteps) t = 0; t < numberOfTimesteps; ++t)
   {
     auto iter = contourIn3D->Begin(t);
     auto end = contourIn3D->End(t);
 
     while (iter != end)
     {
       const auto &currentPointIn3D = (*iter)->Coordinates;
 
       Point3D projectedPointIn2D;
       projectedPointIn2D.Fill(0.0);
 
       sliceGeometry->WorldToIndex(currentPointIn3D, projectedPointIn2D);
 
       projectedContour->AddVertex(projectedPointIn2D, t);
       ++iter;
     }
   }
 
   return projectedContour;
 }
 
 mitk::ContourModel::Pointer mitk::ContourModelUtils::BackProjectContourFrom2DSlice(
   const BaseGeometry *sliceGeometry, const ContourModel *contourIn2D, bool)
 {
   if (nullptr == sliceGeometry || nullptr == contourIn2D)
     return nullptr;
 
   auto worldContour = ContourModel::New();
   worldContour->Initialize(*contourIn2D);
 
-  auto numberOfTimesteps = static_cast<int>(contourIn2D->GetTimeSteps());
+  auto numberOfTimesteps = static_cast<TimeStepType>(contourIn2D->GetTimeSteps());
 
   for (decltype(numberOfTimesteps) t = 0; t < numberOfTimesteps; ++t)
   {
     auto iter = contourIn2D->Begin(t);
     auto end = contourIn2D->End(t);
 
     while (iter != end)
     {
       const auto &currentPointIn2D = (*iter)->Coordinates;
 
       Point3D worldPointIn3D;
       worldPointIn3D.Fill(0.0);
 
       sliceGeometry->IndexToWorld(currentPointIn2D, worldPointIn3D);
 
       worldContour->AddVertex(worldPointIn3D, t);
       ++iter;
     }
   }
 
   return worldContour;
 }
 
 void mitk::ContourModelUtils::FillContourInSlice(
   const ContourModel *projectedContour, Image *sliceImage, const Image* workingImage, int paintingPixelValue)
 {
   FillContourInSlice(projectedContour, 0, sliceImage, workingImage, paintingPixelValue);
 }
 
 void mitk::ContourModelUtils::FillContourInSlice(
   const ContourModel *projectedContour, unsigned int contourTimeStep, Image *sliceImage, const Image* workingImage, int paintingPixelValue)
 {
   if (nullptr == projectedContour)
   {
     mitkThrow() << "Cannot fill contour in slice. Passed contour is invalid";
   }
 
   if (nullptr == sliceImage)
   {
     mitkThrow() << "Cannot fill contour in slice. Passed slice is invalid";
   }
 
   auto contourModelFilter = mitk::ContourModelToSurfaceFilter::New();
   contourModelFilter->SetInput(projectedContour);
   contourModelFilter->Update();
 
   auto surface = mitk::Surface::New();
   surface = contourModelFilter->GetOutput();
 
   if (nullptr == surface->GetVtkPolyData(contourTimeStep))
   {
     MITK_WARN << "Could not create surface from contour model.";
     return;
   }
 
   auto surface2D = vtkSmartPointer<vtkPolyData>::New();
   surface2D->SetPoints(surface->GetVtkPolyData(contourTimeStep)->GetPoints());
   surface2D->SetLines(surface->GetVtkPolyData(contourTimeStep)->GetLines());
 
   auto image = vtkSmartPointer<vtkImageData>::New();
   image->DeepCopy(sliceImage->GetVtkImageData());
 
   const double FOREGROUND_VALUE = 255.0;
   const double BACKGROUND_VALUE = 0.0;
 
   vtkIdType count = image->GetNumberOfPoints();
   for (decltype(count) i = 0; i < count; ++i)
     image->GetPointData()->GetScalars()->SetTuple1(i, FOREGROUND_VALUE);
 
   auto polyDataToImageStencil = vtkSmartPointer<vtkPolyDataToImageStencil>::New();
 
   // Set a minimal tolerance, so that clipped pixels will be added to contour as well.
   polyDataToImageStencil->SetTolerance(mitk::eps);
   polyDataToImageStencil->SetInputData(surface2D);
   polyDataToImageStencil->Update();
 
   auto imageStencil = vtkSmartPointer<vtkImageStencil>::New();
 
   imageStencil->SetInputData(image);
   imageStencil->SetStencilConnection(polyDataToImageStencil->GetOutputPort());
   imageStencil->ReverseStencilOff();
   imageStencil->SetBackgroundValue(BACKGROUND_VALUE);
   imageStencil->Update();
 
   vtkSmartPointer<vtkImageData> filledImage = imageStencil->GetOutput();
   vtkSmartPointer<vtkImageData> resultImage = sliceImage->GetVtkImageData();
   FillSliceInSlice(filledImage, resultImage, workingImage, paintingPixelValue);
 
   sliceImage->SetVolume(resultImage->GetScalarPointer());
 }
 
 void mitk::ContourModelUtils::FillSliceInSlice(
   vtkSmartPointer<vtkImageData> filledImage, vtkSmartPointer<vtkImageData> resultImage, const Image* image, int paintingPixelValue)
 {
   auto labelImage = dynamic_cast<const LabelSetImage *>(image);
   auto numberOfPoints = filledImage->GetNumberOfPoints();
 
   if (nullptr == labelImage)
   {
     for (decltype(numberOfPoints) i = 0; i < numberOfPoints; ++i)
     {
       if (1 < filledImage->GetPointData()->GetScalars()->GetTuple1(i))
         resultImage->GetPointData()->GetScalars()->SetTuple1(i, paintingPixelValue);
     }
   }
   else
   {
     auto backgroundValue = labelImage->GetExteriorLabel()->GetValue();
 
     if (paintingPixelValue != backgroundValue)
     {
       for (decltype(numberOfPoints) i = 0; i < numberOfPoints; ++i)
       {
         if (1 < filledImage->GetPointData()->GetScalars()->GetTuple1(i))
         {
           auto existingValue = resultImage->GetPointData()->GetScalars()->GetTuple1(i);
 
           if (!labelImage->GetLabel(existingValue, labelImage->GetActiveLayer())->GetLocked())
             resultImage->GetPointData()->GetScalars()->SetTuple1(i, paintingPixelValue);
         }
       }
     }
     else
     {
       auto activePixelValue = labelImage->GetActiveLabel(labelImage->GetActiveLayer())->GetValue();
 
       for (decltype(numberOfPoints) i = 0; i < numberOfPoints; ++i)
       {
         if (1 < filledImage->GetPointData()->GetScalars()->GetTuple1(i))
         {
           if (resultImage->GetPointData()->GetScalars()->GetTuple1(i) == activePixelValue)
             resultImage->GetPointData()->GetScalars()->SetTuple1(i, paintingPixelValue);
         }
       }
     }
   }
 }
 
 mitk::ContourModel::Pointer mitk::ContourModelUtils::MoveZerothContourTimeStep(const ContourModel *contour, unsigned int t)
 {
   if (nullptr == contour)
     return nullptr;
 
   auto resultContour = ContourModel::New();
   resultContour->Expand(t + 1);
 
   std::for_each(contour->Begin(), contour->End(), [&resultContour, t](ContourElement::VertexType *vertex) {
     resultContour->AddVertex(vertex, t);
   });
 
   return resultContour;
 }
 
 int mitk::ContourModelUtils::GetActivePixelValue(const Image* workingImage)
 {
-  auto* labelSetImage = dynamic_cast<const LabelSetImage*>(workingImage);
+  auto labelSetImage = dynamic_cast<const LabelSetImage*>(workingImage);
   int activePixelValue = 1;
   if (nullptr != labelSetImage)
   {
     activePixelValue = labelSetImage->GetActiveLabel(labelSetImage->GetActiveLayer())->GetValue();
   }
 
   return activePixelValue;
 }
diff --git a/Modules/ContourModel/Algorithms/mitkContourModelUtils.h b/Modules/ContourModel/Algorithms/mitkContourModelUtils.h
index a7d8a98a4d..ca18c697a9 100644
--- a/Modules/ContourModel/Algorithms/mitkContourModelUtils.h
+++ b/Modules/ContourModel/Algorithms/mitkContourModelUtils.h
@@ -1,113 +1,113 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef mitkContourModelUtils_h
 #define mitkContourModelUtils_h
 
 #include <mitkContourModel.h>
 #include <mitkImage.h>
 #include <vtkSmartPointer.h>
 
 #include <MitkContourModelExports.h>
 
 namespace mitk
 {
   /**
    * \brief Helpful methods for working with contours and images
    *
    *
    */
   class MITKCONTOURMODEL_EXPORT ContourModelUtils : public itk::Object
   {
   public:
     mitkClassMacroItkParent(ContourModelUtils, itk::Object);
 
     /**
       \brief Projects a contour onto an image point by point. Converts from world to index coordinates.
 
       \param slice
       \param contourIn3D
       \param correctionForIpSegmentation adds 0.5 to x and y index coordinates (difference between ipSegmentation and
       MITK contours)
       \param constrainToInside
     */
     static ContourModel::Pointer ProjectContourTo2DSlice(const Image *slice,
                                                          const ContourModel *contourIn3D,
                                                          bool correctionForIpSegmentation,
                                                          bool constrainToInside);
 
     /**
       \brief Projects a slice index coordinates of a contour back into world coordinates.
 
       \param sliceGeometry
       \param contourIn2D
       \param correctionForIpSegmentation subtracts 0.5 to x and y index coordinates (difference between ipSegmentation
       and MITK contours)
     */
     static ContourModel::Pointer BackProjectContourFrom2DSlice(const BaseGeometry *sliceGeometry,
                                                                const ContourModel *contourIn2D,
                                                                bool correctionForIpSegmentation = false);
 
     /**
     \brief Fill a contour in a 2D slice with a specified pixel value.
     This version always uses the contour of time step 0 and fills the image.
     \pre sliceImage points to a valid instance
     \pre projectedContour points to a valid instance
     */
     static void FillContourInSlice(const ContourModel *projectedContour,
                                    Image *sliceImage,
                                    const Image* workingImage,
                                    int paintingPixelValue = 1);
 
     /**
     \brief Fill a contour in a 2D slice with a specified pixel value.
     This overloaded version uses the contour at the passed contourTimeStep
-    to file the passed image slice.
+    to fill the passed image slice.
     \pre sliceImage points to a valid instance
     \pre projectedContour points to a valid instance
     */
     static void FillContourInSlice(const ContourModel *projectedContour,
                                    unsigned int contourTimeStep,
                                    Image *sliceImage,
                                    const Image* workingImage,
                                    int paintingPixelValue = 1);
 
     /**
     \brief Fills a image (filledImage) into another image (resultImage) by incorporating the rules of LabelSet-Images
     */
     static void FillSliceInSlice(vtkSmartPointer<vtkImageData> filledImage,
                                  vtkSmartPointer<vtkImageData> resultImage,
                                  const Image* image,
                                  int paintingPixelValue);
 
     /**
     \brief Move the contour in time step 0 to to a new contour model at the given time step.
     */
     static ContourModel::Pointer MoveZerothContourTimeStep(const ContourModel *contour, unsigned int timeStep);
 
     /**
     \brief Retrieves the active pixel value of a (labelset) image.
            If the image is basic image, the pixel value 1 (one) will be returned.
            If the image is actually a labelset image, the pixel value of the active label of the active layer will be
            returned.
 
     \param workingImage   The (labelset) image to retrieve the active pixel value of.
     */
     static int GetActivePixelValue(const Image* workingImage);
 
   protected:
     ContourModelUtils();
     ~ContourModelUtils() override;
   };
 }
 
 #endif
diff --git a/Modules/ContourModel/DataManagement/mitkContourModel.cpp b/Modules/ContourModel/DataManagement/mitkContourModel.cpp
index ee68ffbc0c..d4153c9d7a 100644
--- a/Modules/ContourModel/DataManagement/mitkContourModel.cpp
+++ b/Modules/ContourModel/DataManagement/mitkContourModel.cpp
@@ -1,634 +1,624 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 #include <mitkContourModel.h>
 #include <mitkPlaneGeometry.h>
 
 mitk::ContourModel::ContourModel() : m_UpdateBoundingBox(true)
 {
   // set to initial state
   this->InitializeEmpty();
 }
 
-mitk::ContourModel::ContourModel(const mitk::ContourModel &other)
-  : mitk::BaseData(other), m_ContourSeries(other.m_ContourSeries), m_lineInterpolation(other.m_lineInterpolation)
+mitk::ContourModel::ContourModel(const ContourModel &other)
+  : BaseData(other), m_ContourSeries(other.m_ContourSeries), m_lineInterpolation(other.m_lineInterpolation)
 {
   m_SelectedVertex = nullptr;
 }
 
 mitk::ContourModel::~ContourModel()
 {
   m_SelectedVertex = nullptr;
   this->m_ContourSeries.clear(); // TODO check destruction
 }
 
-void mitk::ContourModel::AddVertex(const mitk::Point3D &vertex, int timestep)
+void mitk::ContourModel::AddVertex(const Point3D &vertex, TimeStepType timestep)
 {
   if (!this->IsEmptyTimeStep(timestep))
   {
     this->AddVertex(vertex, false, timestep);
   }
 }
 
-void mitk::ContourModel::AddVertex(const mitk::Point3D &vertex, bool isControlPoint, int timestep)
+void mitk::ContourModel::AddVertex(const Point3D &vertex, bool isControlPoint, TimeStepType timestep)
 {
   if (!this->IsEmptyTimeStep(timestep))
   {
     this->m_ContourSeries[timestep]->AddVertex(vertex, isControlPoint);
     this->InvokeEvent(ContourModelSizeChangeEvent());
     this->Modified();
     this->m_UpdateBoundingBox = true;
   }
 }
 
-void mitk::ContourModel::AddVertex(VertexType &vertex, int timestep)
+void mitk::ContourModel::AddVertex(VertexType &vertex, TimeStepType timestep)
 {
   if (!this->IsEmptyTimeStep(timestep))
   {
     this->m_ContourSeries[timestep]->AddVertex(vertex);
     this->InvokeEvent(ContourModelSizeChangeEvent());
     this->Modified();
     this->m_UpdateBoundingBox = true;
   }
 }
 
-void mitk::ContourModel::AddVertex(const VertexType *vertex, int timestep)
+void mitk::ContourModel::AddVertex(const VertexType *vertex, TimeStepType timestep)
 {
   if (vertex != nullptr)
   {
     this->m_ContourSeries[timestep]->AddVertex(*const_cast<VertexType *>(vertex));
   }
 }
 
-void mitk::ContourModel::AddVertexAtFront(mitk::Point3D &vertex, int timestep)
+void mitk::ContourModel::AddVertexAtFront(Point3D &vertex, TimeStepType timestep)
 {
   if (!this->IsEmptyTimeStep(timestep))
   {
     this->AddVertexAtFront(vertex, false, timestep);
   }
 }
 
-void mitk::ContourModel::AddVertexAtFront(mitk::Point3D &vertex, bool isControlPoint, int timestep)
+void mitk::ContourModel::AddVertexAtFront(Point3D &vertex, bool isControlPoint, TimeStepType timestep)
 {
   if (!this->IsEmptyTimeStep(timestep))
   {
     this->m_ContourSeries[timestep]->AddVertexAtFront(vertex, isControlPoint);
     this->InvokeEvent(ContourModelSizeChangeEvent());
     this->Modified();
     this->m_UpdateBoundingBox = true;
   }
 }
 
-void mitk::ContourModel::AddVertexAtFront(VertexType &vertex, int timestep)
+void mitk::ContourModel::AddVertexAtFront(VertexType &vertex, TimeStepType timestep)
 {
   if (!this->IsEmptyTimeStep(timestep))
   {
     this->m_ContourSeries[timestep]->AddVertexAtFront(vertex);
     this->InvokeEvent(ContourModelSizeChangeEvent());
     this->Modified();
     this->m_UpdateBoundingBox = true;
   }
 }
 
-bool mitk::ContourModel::SetVertexAt(int pointId, const Point3D &point, unsigned int timestep)
+bool mitk::ContourModel::SetVertexAt(int pointId, const Point3D &point, TimeStepType timestep)
 {
   if (!this->IsEmptyTimeStep(timestep))
   {
     if (pointId >= 0 && this->m_ContourSeries[timestep]->GetSize() > pointId)
     {
       this->m_ContourSeries[timestep]->SetVertexAt(pointId, point);
       this->Modified();
       this->m_UpdateBoundingBox = true;
       return true;
     }
     return false;
   }
   return false;
 }
 
-bool mitk::ContourModel::SetVertexAt(int pointId, const VertexType *vertex, unsigned int timestep)
+bool mitk::ContourModel::SetVertexAt(int pointId, const VertexType *vertex, TimeStepType timestep)
 {
   if (vertex == nullptr)
     return false;
 
   if (!this->IsEmptyTimeStep(timestep))
   {
     if (pointId >= 0 && this->m_ContourSeries[timestep]->GetSize() > pointId)
     {
       this->m_ContourSeries[timestep]->SetVertexAt(pointId, vertex);
       this->Modified();
       this->m_UpdateBoundingBox = true;
       return true;
     }
     return false;
   }
   return false;
 }
 
-void mitk::ContourModel::InsertVertexAtIndex(mitk::Point3D &vertex, int index, bool isControlPoint, int timestep)
+void mitk::ContourModel::InsertVertexAtIndex(Point3D &vertex, int index, bool isControlPoint, TimeStepType timestep)
 {
   if (!this->IsEmptyTimeStep(timestep))
   {
     if (index >= 0 && this->m_ContourSeries[timestep]->GetSize() > index)
     {
       this->m_ContourSeries[timestep]->InsertVertexAtIndex(vertex, isControlPoint, index);
       this->InvokeEvent(ContourModelSizeChangeEvent());
       this->Modified();
       this->m_UpdateBoundingBox = true;
     }
   }
 }
 
-bool mitk::ContourModel::IsEmpty(int timestep) const
+bool mitk::ContourModel::IsEmpty(TimeStepType timestep) const
 {
   if (!this->IsEmptyTimeStep(timestep))
   {
     return this->m_ContourSeries[timestep]->IsEmpty();
   }
   return true;
 }
 
 bool mitk::ContourModel::IsEmpty() const
 {
   return this->IsEmpty(0);
 }
 
-int mitk::ContourModel::GetNumberOfVertices(int timestep) const
+int mitk::ContourModel::GetNumberOfVertices(TimeStepType timestep) const
 {
   if (!this->IsEmptyTimeStep(timestep))
   {
     return this->m_ContourSeries[timestep]->GetSize();
   }
   return -1;
 }
 
-const mitk::ContourModel::VertexType *mitk::ContourModel::GetVertexAt(int index, int timestep) const
+const mitk::ContourModel::VertexType *mitk::ContourModel::GetVertexAt(int index, TimeStepType timestep) const
 {
   if (!this->IsEmptyTimeStep(timestep))
   {
     return this->m_ContourSeries[timestep]->GetVertexAt(index);
   }
   return nullptr;
 }
 
-int mitk::ContourModel::GetIndex(const VertexType *vertex, int timestep)
+int mitk::ContourModel::GetIndex(const VertexType *vertex, TimeStepType timestep)
 {
   if (!this->IsEmptyTimeStep(timestep))
   {
     return this->m_ContourSeries[timestep]->GetIndex(vertex);
   }
   return -1;
 }
 
-void mitk::ContourModel::Close(int timestep)
+void mitk::ContourModel::Close(TimeStepType timestep)
 {
   if (!this->IsEmptyTimeStep(timestep))
   {
     this->m_ContourSeries[timestep]->Close();
     this->InvokeEvent(ContourModelClosedEvent());
     this->Modified();
     this->m_UpdateBoundingBox = true;
   }
 }
 
-void mitk::ContourModel::Open(int timestep)
+void mitk::ContourModel::Open(TimeStepType timestep)
 {
   if (!this->IsEmptyTimeStep(timestep))
   {
     this->m_ContourSeries[timestep]->Open();
     this->InvokeEvent(ContourModelClosedEvent());
     this->Modified();
     this->m_UpdateBoundingBox = true;
   }
 }
 
-void mitk::ContourModel::SetClosed(bool isClosed, int timestep)
+void mitk::ContourModel::SetClosed(bool isClosed, TimeStepType timestep)
 {
   if (!this->IsEmptyTimeStep(timestep))
   {
     this->m_ContourSeries[timestep]->SetClosed(isClosed);
     this->InvokeEvent(ContourModelClosedEvent());
     this->Modified();
     this->m_UpdateBoundingBox = true;
   }
 }
 
 bool mitk::ContourModel::IsEmptyTimeStep(unsigned int t) const
 {
   return (this->m_ContourSeries.size() <= t);
 }
 
-bool mitk::ContourModel::IsNearContour(mitk::Point3D &point, float eps, int timestep)
+bool mitk::ContourModel::IsNearContour(Point3D &point, float eps, TimeStepType timestep)
 {
   if (!this->IsEmptyTimeStep(timestep))
   {
     return this->m_ContourSeries[timestep]->IsNearContour(point, eps);
   }
   return false;
 }
 
-void mitk::ContourModel::Concatenate(mitk::ContourModel *other, int timestep, bool check)
+void mitk::ContourModel::Concatenate(ContourModel *other, TimeStepType timestep, bool check)
 {
   if (!this->IsEmptyTimeStep(timestep))
   {
     if (!this->m_ContourSeries[timestep]->IsClosed())
     {
       this->m_ContourSeries[timestep]->Concatenate(other->m_ContourSeries[timestep], check);
       this->InvokeEvent(ContourModelSizeChangeEvent());
       this->Modified();
       this->m_UpdateBoundingBox = true;
     }
   }
 }
 
-mitk::ContourModel::VertexIterator mitk::ContourModel::Begin(int timestep) const
+mitk::ContourModel::VertexIterator mitk::ContourModel::Begin(TimeStepType timestep) const
 {
   return this->IteratorBegin(timestep);
 }
 
-mitk::ContourModel::VertexIterator mitk::ContourModel::IteratorBegin(int timestep) const
+mitk::ContourModel::VertexIterator mitk::ContourModel::IteratorBegin(TimeStepType timestep) const
 {
   if (!this->IsEmptyTimeStep(timestep))
   {
     return this->m_ContourSeries[timestep]->IteratorBegin();
   }
   else
   {
     mitkThrow() << "No iterator at invalid timestep " << timestep << ". There are only " << this->GetTimeSteps()
                 << " timesteps available.";
   }
 }
 
-mitk::ContourModel::VertexIterator mitk::ContourModel::End(int timestep) const
+mitk::ContourModel::VertexIterator mitk::ContourModel::End(TimeStepType timestep) const
 {
   return this->IteratorEnd(timestep);
 }
 
-mitk::ContourModel::VertexIterator mitk::ContourModel::IteratorEnd(int timestep) const
+mitk::ContourModel::VertexIterator mitk::ContourModel::IteratorEnd(TimeStepType timestep) const
 {
   if (!this->IsEmptyTimeStep(timestep))
   {
     return this->m_ContourSeries[timestep]->IteratorEnd();
   }
   else
   {
     mitkThrow() << "No iterator at invalid timestep " << timestep << ". There are only " << this->GetTimeSteps()
                 << " timesteps available.";
   }
 }
 
 bool mitk::ContourModel::IsClosed(int timestep) const
 {
   if (!this->IsEmptyTimeStep(timestep))
   {
     return this->m_ContourSeries[timestep]->IsClosed();
   }
   return false;
 }
 
-bool mitk::ContourModel::SelectVertexAt(mitk::Point3D &point, float eps, int timestep)
+bool mitk::ContourModel::SelectVertexAt(Point3D &point, float eps, TimeStepType timestep)
 {
   if (!this->IsEmptyTimeStep(timestep))
   {
     this->m_SelectedVertex = this->m_ContourSeries[timestep]->GetVertexAt(point, eps);
   }
   return this->m_SelectedVertex != nullptr;
 }
 
-bool mitk::ContourModel::SelectVertexAt(int index, int timestep)
+bool mitk::ContourModel::SelectVertexAt(int index, TimeStepType timestep)
 {
   if (!this->IsEmptyTimeStep(timestep) && index >= 0)
   {
     return (this->m_SelectedVertex = this->m_ContourSeries[timestep]->GetVertexAt(index));
   }
   return false;
 }
 
-bool mitk::ContourModel::SetControlVertexAt(mitk::Point3D &point, float eps, int timestep)
+bool mitk::ContourModel::SetControlVertexAt(Point3D &point, float eps, TimeStepType timestep)
 {
   if (!this->IsEmptyTimeStep(timestep))
   {
     VertexType *vertex = this->m_ContourSeries[timestep]->GetVertexAt(point, eps);
     if (vertex != nullptr)
     {
       vertex->IsControlPoint = true;
       return true;
     }
   }
   return false;
 }
 
-bool mitk::ContourModel::SetControlVertexAt(int index, int timestep)
+bool mitk::ContourModel::SetControlVertexAt(int index, TimeStepType timestep)
 {
   if (!this->IsEmptyTimeStep(timestep) && index >= 0)
   {
     VertexType *vertex = this->m_ContourSeries[timestep]->GetVertexAt(index);
     if (vertex != nullptr)
     {
       vertex->IsControlPoint = true;
       return true;
     }
   }
   return false;
 }
 
-bool mitk::ContourModel::RemoveVertex(const VertexType *vertex, int timestep)
+bool mitk::ContourModel::RemoveVertex(const VertexType *vertex, TimeStepType timestep)
 {
   if (!this->IsEmptyTimeStep(timestep))
   {
     if (this->m_ContourSeries[timestep]->RemoveVertex(vertex))
     {
       this->Modified();
       this->m_UpdateBoundingBox = true;
       this->InvokeEvent(ContourModelSizeChangeEvent());
       return true;
     }
   }
   return false;
 }
 
-bool mitk::ContourModel::RemoveVertexAt(int index, int timestep)
+bool mitk::ContourModel::RemoveVertexAt(int index, TimeStepType timestep)
 {
   if (!this->IsEmptyTimeStep(timestep))
   {
     if (this->m_ContourSeries[timestep]->RemoveVertexAt(index))
     {
       this->Modified();
       this->m_UpdateBoundingBox = true;
       this->InvokeEvent(ContourModelSizeChangeEvent());
       return true;
     }
   }
   return false;
 }
 
-bool mitk::ContourModel::RemoveVertexAt(mitk::Point3D &point, float eps, int timestep)
+bool mitk::ContourModel::RemoveVertexAt(Point3D &point, float eps, TimeStepType timestep)
 {
   if (!this->IsEmptyTimeStep(timestep))
   {
     if (this->m_ContourSeries[timestep]->RemoveVertexAt(point, eps))
     {
       this->Modified();
       this->m_UpdateBoundingBox = true;
       this->InvokeEvent(ContourModelSizeChangeEvent());
       return true;
     }
   }
   return false;
 }
 
-void mitk::ContourModel::ShiftSelectedVertex(mitk::Vector3D &translate)
+void mitk::ContourModel::ShiftSelectedVertex(Vector3D &translate)
 {
   if (this->m_SelectedVertex)
   {
     this->ShiftVertex(this->m_SelectedVertex, translate);
     this->Modified();
     this->m_UpdateBoundingBox = true;
   }
 }
 
-void mitk::ContourModel::ShiftContour(mitk::Vector3D &translate, int timestep)
+void mitk::ContourModel::ShiftContour(Vector3D &translate, TimeStepType timestep)
 {
   if (!this->IsEmptyTimeStep(timestep))
   {
     VertexListType *vList = this->m_ContourSeries[timestep]->GetVertexList();
     auto it = vList->begin();
     auto end = vList->end();
 
     // shift all vertices
     while (it != end)
     {
       this->ShiftVertex((*it), translate);
       it++;
     }
 
     this->Modified();
     this->m_UpdateBoundingBox = true;
     this->InvokeEvent(ContourModelShiftEvent());
   }
 }
 
-void mitk::ContourModel::ShiftVertex(VertexType *vertex, mitk::Vector3D &vector)
+void mitk::ContourModel::ShiftVertex(VertexType *vertex, Vector3D &vector)
 {
   vertex->Coordinates[0] += vector[0];
   vertex->Coordinates[1] += vector[1];
   vertex->Coordinates[2] += vector[2];
 }
 
-void mitk::ContourModel::Clear(int timestep)
+void mitk::ContourModel::Clear(TimeStepType timestep)
 {
   if (!this->IsEmptyTimeStep(timestep))
   {
     // clear data at timestep
     this->m_ContourSeries[timestep]->Clear();
     this->Modified();
     this->m_UpdateBoundingBox = true;
   }
 }
 
 void mitk::ContourModel::Expand(unsigned int timeSteps)
 {
   std::size_t oldSize = this->m_ContourSeries.size();
 
   if (static_cast<std::size_t>(timeSteps) > oldSize)
   {
     Superclass::Expand(timeSteps);
 
     // insert contours for each new timestep
     for (std::size_t i = oldSize; i < static_cast<std::size_t>(timeSteps); i++)
     {
-      m_ContourSeries.push_back(mitk::ContourElement::New());
+      m_ContourSeries.push_back(ContourElement::New());
     }
 
     this->InvokeEvent(ContourModelExpandTimeBoundsEvent());
   }
 }
 
 void mitk::ContourModel::SetRequestedRegionToLargestPossibleRegion()
 {
   // no support for regions
 }
 
 bool mitk::ContourModel::RequestedRegionIsOutsideOfTheBufferedRegion()
 {
   // no support for regions
   return false;
 }
 
 bool mitk::ContourModel::VerifyRequestedRegion()
 {
   // no support for regions
   return true;
 }
 
-const mitk::BaseGeometry *mitk::ContourModel::GetUpdatedGeometry(int t)
-{
-  return Superclass::GetUpdatedGeometry(t);
-}
-
-mitk::BaseGeometry *mitk::ContourModel::GetGeometry(int t) const
-{
-  return Superclass::GetGeometry(t);
-}
-
 void mitk::ContourModel::SetRequestedRegion(const itk::DataObject * /*data*/)
 {
   // no support for regions
 }
 
 void mitk::ContourModel::Clear()
 {
   // clear data and set to initial state again
   this->ClearData();
   this->InitializeEmpty();
   this->Modified();
   this->m_UpdateBoundingBox = true;
 }
 
-void mitk::ContourModel::RedistributeControlVertices(int period, int timestep)
+void mitk::ContourModel::RedistributeControlVertices(int period, TimeStepType timestep)
 {
   if (!this->IsEmptyTimeStep(timestep))
   {
     this->m_ContourSeries[timestep]->RedistributeControlVertices(this->GetSelectedVertex(), period);
     this->InvokeEvent(ContourModelClosedEvent());
     this->Modified();
     this->m_UpdateBoundingBox = true;
   }
 }
 
 void mitk::ContourModel::ClearData()
 {
   // call the superclass, this releases the data of BaseData
   Superclass::ClearData();
 
   // clear out the time resolved contours
   this->m_ContourSeries.clear();
 }
 
 void mitk::ContourModel::Initialize()
 {
   this->InitializeEmpty();
   this->Modified();
   this->m_UpdateBoundingBox = true;
 }
 
-void mitk::ContourModel::Initialize(const mitk::ContourModel &other)
+void mitk::ContourModel::Initialize(const ContourModel &other)
 {
-  mitk::TimeStepType numberOfTimesteps = other.GetTimeGeometry()->CountTimeSteps();
+  TimeStepType numberOfTimesteps = other.GetTimeGeometry()->CountTimeSteps();
   this->InitializeTimeGeometry(numberOfTimesteps);
 
-  for (mitk::TimeStepType currentTimestep = 0; currentTimestep < numberOfTimesteps; currentTimestep++)
+  for (TimeStepType currentTimestep = 0; currentTimestep < numberOfTimesteps; currentTimestep++)
   {
-    this->m_ContourSeries.push_back(mitk::ContourElement::New());
+    this->m_ContourSeries.push_back(ContourElement::New());
     this->SetClosed(other.IsClosed(currentTimestep), currentTimestep);
   }
 
   m_SelectedVertex = nullptr;
   this->m_lineInterpolation = other.m_lineInterpolation;
   this->Modified();
   this->m_UpdateBoundingBox = true;
 }
 
 void mitk::ContourModel::InitializeEmpty()
 {
   // clear data at timesteps
   this->m_ContourSeries.resize(0);
-  this->m_ContourSeries.push_back(mitk::ContourElement::New());
+  this->m_ContourSeries.push_back(ContourElement::New());
 
   // set number of timesteps to one
   this->InitializeTimeGeometry(1);
 
   m_SelectedVertex = nullptr;
   this->m_lineInterpolation = ContourModel::LINEAR;
 }
 
 void mitk::ContourModel::UpdateOutputInformation()
 {
   if (this->GetSource())
   {
     this->GetSource()->UpdateOutputInformation();
   }
 
   if (this->m_UpdateBoundingBox)
   {
     // update the bounds of the geometry according to the stored vertices
     ScalarType mitkBounds[6];
 
     // calculate the boundingbox at each timestep
     typedef itk::BoundingBox<unsigned long, 3, ScalarType> BoundingBoxType;
     typedef BoundingBoxType::PointsContainer PointsContainer;
 
     int timesteps = this->GetTimeSteps();
 
     // iterate over the timesteps
     for (int currenTimeStep = 0; currenTimeStep < timesteps; currenTimeStep++)
     {
-      if (dynamic_cast<mitk::PlaneGeometry *>(this->GetGeometry(currenTimeStep)))
+      if (dynamic_cast<PlaneGeometry *>(this->GetGeometry(currenTimeStep)))
       {
         // do not update bounds for 2D geometries, as they are unfortunately defined with min bounds 0!
         return;
       }
       else
       { // we have a 3D geometry -> let's update bounds
         // only update bounds if the contour was modified
         if (this->GetMTime() > this->GetGeometry(currenTimeStep)->GetBoundingBox()->GetMTime())
         {
           mitkBounds[0] = 0.0;
           mitkBounds[1] = 0.0;
           mitkBounds[2] = 0.0;
           mitkBounds[3] = 0.0;
           mitkBounds[4] = 0.0;
           mitkBounds[5] = 0.0;
 
           BoundingBoxType::Pointer boundingBox = BoundingBoxType::New();
 
           PointsContainer::Pointer points = PointsContainer::New();
 
           auto it = this->IteratorBegin(currenTimeStep);
           auto end = this->IteratorEnd(currenTimeStep);
 
           // fill the boundingbox with the points
           while (it != end)
           {
             Point3D currentP = (*it)->Coordinates;
             BoundingBoxType::PointType p;
             p.CastFrom(currentP);
             points->InsertElement(points->Size(), p);
 
             it++;
           }
 
           // construct the new boundingBox
           boundingBox->SetPoints(points);
           boundingBox->ComputeBoundingBox();
           BoundingBoxType::BoundsArrayType tmp = boundingBox->GetBounds();
           mitkBounds[0] = tmp[0];
           mitkBounds[1] = tmp[1];
           mitkBounds[2] = tmp[2];
           mitkBounds[3] = tmp[3];
           mitkBounds[4] = tmp[4];
           mitkBounds[5] = tmp[5];
 
           // set boundingBox at current timestep
           BaseGeometry *geometry3d = this->GetGeometry(currenTimeStep);
           geometry3d->SetBounds(mitkBounds);
         }
       }
     }
     this->m_UpdateBoundingBox = false;
   }
   GetTimeGeometry()->Update();
 }
 
-void mitk::ContourModel::ExecuteOperation(mitk::Operation * /*operation*/)
+void mitk::ContourModel::ExecuteOperation(Operation * /*operation*/)
 {
   // not supported yet
 }
diff --git a/Modules/ContourModel/DataManagement/mitkContourModel.h b/Modules/ContourModel/DataManagement/mitkContourModel.h
index a61fc06d60..0811d21613 100644
--- a/Modules/ContourModel/DataManagement/mitkContourModel.h
+++ b/Modules/ContourModel/DataManagement/mitkContourModel.h
@@ -1,453 +1,443 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 #ifndef _MITK_CONTOURMODEL_H_
 #define _MITK_CONTOURMODEL_H_
 
 #include "mitkBaseData.h"
 #include "mitkCommon.h"
 #include <MitkContourModelExports.h>
 
 #include <mitkContourElement.h>
 
 namespace mitk
 {
   /**
   \brief ContourModel is a structure of linked vertices defining a contour in 3D space.
   The vertices are stored in a mitk::ContourElement is stored for each timestep.
   The contour line segments are implicitly defined by the given linked vertices.
   By default two control points are are linked by a straight line.It is possible to add
   vertices at front and end of the contour and to iterate in both directions.
 
   Points are specified containing coordinates and additional (data) information,
   see mitk::ContourElement.
   For accessing a specific vertex either an index or a position in 3D Space can be used.
   The vertices are best accessed by using a VertexIterator.
   Interaction with the contour is thus available without any mitk interactor class using the
   api of ContourModel. It is possible to shift single vertices also as shifting the whole
   contour.
 
   A contour can be either open like a single curved line segment or
   closed. A closed contour can for example represent a jordan curve.
 
   \section mitkContourModelDisplayOptions Display Options
 
   The default mappers for this data structure are mitk::ContourModelGLMapper2D and
   mitk::ContourModelMapper3D. See these classes for display options which can
   can be set via properties.
   */
   class MITKCONTOURMODEL_EXPORT ContourModel : public BaseData
   {
   public:
     mitkClassMacro(ContourModel, BaseData);
 
     itkFactorylessNewMacro(Self);
 
     itkCloneMacro(Self);
 
-      /*+++++++++++++++ typedefs +++++++++++++++++++++++++++++++*/
-      typedef mitk::ContourElement::VertexType VertexType;
-    typedef mitk::ContourElement::VertexListType VertexListType;
-    typedef mitk::ContourElement::VertexIterator VertexIterator;
-    typedef mitk::ContourElement::ConstVertexIterator ConstVertexIterator;
-    typedef std::vector<mitk::ContourElement::Pointer> ContourModelSeries;
+    /*+++++++++++++++ typedefs +++++++++++++++++++++++++++++++*/
+    typedef ContourElement::VertexType VertexType;
+    typedef ContourElement::VertexListType VertexListType;
+    typedef ContourElement::VertexIterator VertexIterator;
+    typedef ContourElement::ConstVertexIterator ConstVertexIterator;
+    typedef std::vector<ContourElement::Pointer> ContourModelSeries;
     /*+++++++++++++++ END typedefs ++++++++++++++++++++++++++++*/
 
     /** \brief Possible interpolation of the line segments between control points */
     enum LineSegmentInterpolation
     {
       LINEAR,
       B_SPLINE
     };
 
     /*++++++++++++++++  inline methods  +++++++++++++++++++++++*/
 
     /** \brief Get the current selected vertex.
     */
     VertexType *GetSelectedVertex() { return this->m_SelectedVertex; }
     /** \brief Deselect vertex.
     */
     void Deselect() { this->m_SelectedVertex = nullptr; }
     /** \brief Set selected vertex as control point
     */
     void SetSelectedVertexAsControlPoint(bool isControlPoint = true)
     {
       if (this->m_SelectedVertex)
       {
         m_SelectedVertex->IsControlPoint = isControlPoint;
         this->Modified();
       }
     }
 
     /** \brief Set the interpolation of the line segments between control points.
     */
     void SetLineSegmentInterpolation(LineSegmentInterpolation interpolation)
     {
       this->m_lineInterpolation = interpolation;
       this->Modified();
     }
 
     /** \brief Get the interpolation of the line segments between control points.
     */
     LineSegmentInterpolation GetLineSegmentInterpolation() { return this->m_lineInterpolation; }
     /*++++++++++++++++  END inline methods  +++++++++++++++++++++++*/
 
     /** \brief Add a vertex to the contour at given timestep.
     The vertex is added at the end of contour.
 
     \param vertex - coordinate representation of a control point
     \param timestep - the timestep at which the vertex will be add ( default 0)
 
     @note Adding a vertex to a timestep which exceeds the timebounds of the contour
     will not be added, the TimeGeometry will not be expanded.
     */
-    void AddVertex(const mitk::Point3D &vertex, int timestep = 0);
+    void AddVertex(const Point3D &vertex, TimeStepType timestep = 0);
 
     /** \brief Add a vertex to the contour at given timestep.
     The vertex is added at the end of contour.
 
     \param vertex - coordinate representation of a control point
     \param timestep - the timestep at which the vertex will be add ( default 0)
 
     @note Adding a vertex to a timestep which exceeds the timebounds of the contour
     will not be added, the TimeGeometry will not be expanded.
     */
-    void AddVertex(VertexType &vertex, int timestep = 0);
+    void AddVertex(VertexType &vertex, TimeStepType timestep = 0);
 
     /** \brief Add a vertex to the contour at given timestep.
     The vertex is added at the end of contour.
 
     \param vertex - coordinate representation of a control point
     \param timestep - the timestep at which the vertex will be add ( default 0)
 
     @note Adding a vertex to a timestep which exceeds the timebounds of the contour
     will not be added, the TimeSlicedGeometry will not be expanded.
     */
-    void AddVertex(const VertexType *vertex, int timestep = 0);
+    void AddVertex(const VertexType *vertex, TimeStepType timestep = 0);
 
     /** \brief Add a vertex to the contour.
 
     \param vertex - coordinate representation of a control point
     \param timestep - the timestep at which the vertex will be add ( default 0)
     \param isControlPoint - specifies the vertex to be handled in a special way (e.g. control points
     will be rendered).
 
 
     @note Adding a vertex to a timestep which exceeds the timebounds of the contour
     will not be added, the TimeGeometry will not be expanded.
     */
-    void AddVertex(const mitk::Point3D &vertex, bool isControlPoint, int timestep = 0);
+    void AddVertex(const Point3D &vertex, bool isControlPoint, TimeStepType timestep = 0);
 
     /** \brief Add a vertex to the contour at given timestep AT THE FRONT of the contour.
     The vertex is added at the FRONT of contour.
 
     \param vertex - coordinate representation of a control point
     \param timestep - the timestep at which the vertex will be add ( default 0)
 
     @note Adding a vertex to a timestep which exceeds the timebounds of the contour
     will not be added, the TimeGeometry will not be expanded.
     */
-    void AddVertexAtFront(mitk::Point3D &vertex, int timestep = 0);
+    void AddVertexAtFront(Point3D &vertex, TimeStepType timestep = 0);
 
     /** \brief Add a vertex to the contour at given timestep AT THE FRONT of the contour.
     The vertex is added at the FRONT of contour.
 
     \param vertex - coordinate representation of a control point
     \param timestep - the timestep at which the vertex will be add ( default 0)
 
     @note Adding a vertex to a timestep which exceeds the timebounds of the contour
     will not be added, the TimeGeometry will not be expanded.
     */
-    void AddVertexAtFront(VertexType &vertex, int timestep = 0);
+    void AddVertexAtFront(VertexType &vertex, TimeStepType timestep = 0);
 
     /** \brief Add a vertex to the contour at given timestep AT THE FRONT of the contour.
 
     \param vertex - coordinate representation of a control point
     \param timestep - the timestep at which the vertex will be add ( default 0)
     \param isControlPoint - specifies the vertex to be handled in a special way (e.g. control points
     will be rendered).
 
 
     @note Adding a vertex to a timestep which exceeds the timebounds of the contour
     will not be added, the TimeGeometry will not be expanded.
     */
-    void AddVertexAtFront(mitk::Point3D &vertex, bool isControlPoint, int timestep = 0);
+    void AddVertexAtFront(Point3D &vertex, bool isControlPoint, TimeStepType timestep = 0);
 
     /** \brief Insert a vertex at given index.
     */
-    void InsertVertexAtIndex(mitk::Point3D &vertex, int index, bool isControlPoint = false, int timestep = 0);
+    void InsertVertexAtIndex(Point3D &vertex, int index, bool isControlPoint = false, TimeStepType timestep = 0);
 
     /** \brief Set a coordinates for point at given index.
     */
-    bool SetVertexAt(int pointId, const mitk::Point3D &point, unsigned int timestep = 0);
+    bool SetVertexAt(int pointId, const Point3D &point, TimeStepType timestep = 0);
 
     /** \brief Set a coordinates for point at given index.
     */
-    bool SetVertexAt(int pointId, const VertexType *vertex, unsigned int timestep = 0);
+    bool SetVertexAt(int pointId, const VertexType *vertex, TimeStepType timestep = 0);
 
     /** \brief Return if the contour is closed or not.
     */
     bool IsClosed(int timestep = 0) const;
 
     /** \brief Concatenate two contours.
     The starting control point of the other will be added at the end of the contour.
     \param other
     \param timestep - the timestep at which the vertex will be add ( default 0)
     \param check - check for intersections ( default false)
     */
-    void Concatenate(mitk::ContourModel *other, int timestep = 0, bool check = false);
+    void Concatenate(ContourModel *other, TimeStepType timestep = 0, bool check = false);
 
     /** \brief Returns a const VertexIterator at the start element of the contour.
     @throw mitk::Exception if the timestep is invalid.
     */
-    VertexIterator Begin(int timestep = 0) const;
+    VertexIterator Begin(TimeStepType timestep = 0) const;
 
     /** \brief Returns a const VertexIterator at the start element of the contour.
     @throw mitk::Exception if the timestep is invalid.
     */
-    VertexIterator IteratorBegin(int timestep = 0) const;
+    VertexIterator IteratorBegin(TimeStepType timestep = 0) const;
 
     /** \brief Returns a const VertexIterator at the end element of the contour.
     @throw mitk::Exception if the timestep is invalid.
     */
-    VertexIterator End(int timestep = 0) const;
+    VertexIterator End(TimeStepType timestep = 0) const;
 
     /** \brief Returns a const VertexIterator at the end element of the contour.
     @throw mitk::Exception if the timestep is invalid.
     */
-    VertexIterator IteratorEnd(int timestep = 0) const;
+    VertexIterator IteratorEnd(TimeStepType timestep = 0) const;
 
     /** \brief Close the contour.
     The last control point will be linked with the first point.
     */
-    virtual void Close(int timestep = 0);
+    virtual void Close(TimeStepType timestep = 0);
 
     /** \brief Set isClosed to false contour.
     The link between the last control point the first point will be removed.
     */
-    virtual void Open(int timestep = 0);
+    virtual void Open(TimeStepType timestep = 0);
 
     /** \brief Set closed property to given boolean.
 
     false - The link between the last control point the first point will be removed.
     true - The last control point will be linked with the first point.
     */
-    virtual void SetClosed(bool isClosed, int timestep = 0);
+    virtual void SetClosed(bool isClosed, TimeStepType timestep = 0);
 
     /** \brief Returns the number of vertices at a given timestep.
     \param timestep - default = 0
     */
-    int GetNumberOfVertices(int timestep = 0) const;
+    int GetNumberOfVertices(TimeStepType timestep = 0) const;
 
     /** \brief Returns whether the contour model is empty at a given timestep.
     \param timestep - default = 0
     */
-    virtual bool IsEmpty(int timestep) const;
+    virtual bool IsEmpty(TimeStepType timestep) const;
 
     /** \brief Returns whether the contour model is empty.
     */
     bool IsEmpty() const override;
 
     /** \brief Returns the vertex at the index position within the container.
     */
-    virtual const VertexType *GetVertexAt(int index, int timestep = 0) const;
+    virtual const VertexType *GetVertexAt(int index, TimeStepType timestep = 0) const;
 
     /** \brief Remove a vertex at given timestep within the container.
 
     \return index of vertex. -1 if not found.
     */
-    int GetIndex(const VertexType *vertex, int timestep = 0);
+    int GetIndex(const VertexType *vertex, TimeStepType timestep = 0);
 
     /** \brief Check if there isn't something at this timestep.
     */
     bool IsEmptyTimeStep(unsigned int t) const override;
 
     /** \brief Check if mouse cursor is near the contour.
     */
-    virtual bool IsNearContour(mitk::Point3D &point, float eps, int timestep);
+    virtual bool IsNearContour(Point3D &point, float eps, TimeStepType timestep);
 
     /** \brief Mark a vertex at an index in the container as selected.
     */
-    bool SelectVertexAt(int index, int timestep = 0);
+    bool SelectVertexAt(int index, TimeStepType timestep = 0);
 
     /** \brief Mark a vertex at an index in the container as control point.
     */
-    bool SetControlVertexAt(int index, int timestep = 0);
+    bool SetControlVertexAt(int index, TimeStepType timestep = 0);
 
     /** \brief Mark a vertex at a given position in 3D space.
 
     \param point - query point in 3D space
     \param eps - radius for nearest neighbour search (error bound).
     \param timestep - search at this timestep
 
     @return true = vertex found;  false = no vertex found
     */
-    bool SelectVertexAt(mitk::Point3D &point, float eps, int timestep = 0);
+    bool SelectVertexAt(Point3D &point, float eps, TimeStepType timestep = 0);
     /*
         \pararm point - query point in 3D space
         \pararm eps - radius for nearest neighbour search (error bound).
         \pararm timestep - search at this timestep
 
         @return true = vertex found;  false = no vertex found
         */
-    bool SetControlVertexAt(mitk::Point3D &point, float eps, int timestep = 0);
+    bool SetControlVertexAt(Point3D &point, float eps, TimeStepType timestep = 0);
 
     /** \brief Remove a vertex at given index within the container.
 
     @return true = the vertex was successfuly removed;  false = wrong index.
     */
-    bool RemoveVertexAt(int index, int timestep = 0);
+    bool RemoveVertexAt(int index, TimeStepType timestep = 0);
 
     /** \brief Remove a vertex at given timestep within the container.
 
     @return true = the vertex was successfuly removed.
     */
-    bool RemoveVertex(const VertexType *vertex, int timestep = 0);
+    bool RemoveVertex(const VertexType *vertex, TimeStepType timestep = 0);
 
     /** \brief Remove a vertex at a query position in 3D space.
 
     The vertex to be removed will be search by nearest neighbour search.
     Note that possibly no vertex at this position and eps is stored inside
     the contour.
 
     @return true = the vertex was successfuly removed;  false = no vertex found.
     */
-    bool RemoveVertexAt(mitk::Point3D &point, float eps, int timestep = 0);
+    bool RemoveVertexAt(Point3D &point, float eps, TimeStepType timestep = 0);
 
     /** \brief Shift the currently selected vertex by a translation vector.
 
     \param translate - the translation vector.
     */
-    void ShiftSelectedVertex(mitk::Vector3D &translate);
+    void ShiftSelectedVertex(Vector3D &translate);
 
     /** \brief Shift the whole contour by a translation vector at given timestep.
 
     \param translate - the translation vector.
     \param timestep - at this timestep the contour will be shifted.
     */
-    void ShiftContour(mitk::Vector3D &translate, int timestep = 0);
+    void ShiftContour(Vector3D &translate, TimeStepType timestep = 0);
 
     /** \brief Clear the storage container at given timestep.
 
     All control points are removed at
     timestep.
     */
-    virtual void Clear(int timestep);
+    virtual void Clear(TimeStepType timestep);
 
     /** \brief Initialize all data objects
     */
     void Initialize() override;
 
     /** \brief Initialize object with specs of other contour.
     Note: No data will be copied.
     */
-    void Initialize(const mitk::ContourModel &other);
+    void Initialize(const ContourModel &other);
 
     /*++++++++++++++++++ method inherit from base data +++++++++++++++++++++++++++*/
     /**
     \brief Inherit from base data - no region support available for contourModel objects.
     */
     void SetRequestedRegionToLargestPossibleRegion() override;
 
     /**
     \brief Inherit from base data - no region support available for contourModel objects.
     */
     bool RequestedRegionIsOutsideOfTheBufferedRegion() override;
 
     /**
     \brief Inherit from base data - no region support available for contourModel objects.
     */
     bool VerifyRequestedRegion() override;
 
-    /**
-    \brief Get the updated geometry with recomputed bounds.
-    */
-    virtual const mitk::BaseGeometry *GetUpdatedGeometry(int t = 0);
-
-    /**
-    \brief Get the BaseGeometry for timestep t.
-    */
-    virtual mitk::BaseGeometry *GetGeometry(int t = 0) const;
-
     /**
     \brief Inherit from base data - no region support available for contourModel objects.
     */
     void SetRequestedRegion(const itk::DataObject *data) override;
 
     /**
     \brief Expand the timebounds of the TimeGeometry to given number of timesteps.
     */
     void Expand(unsigned int timeSteps) override;
 
     /**
     \brief Update the OutputInformation of a ContourModel object
 
     The BoundingBox of the contour will be updated, if necessary.
     */
     void UpdateOutputInformation() override;
 
     /**
     \brief Clear the storage container.
 
     The object is set to initial state. All control points are removed and the number of
     timesteps are set to 1.
     */
     void Clear() override;
 
     /**
     \brief overwrite if the Data can be called by an Interactor (StateMachine).
     */
     void ExecuteOperation(Operation *operation) override;
 
     /** \brief Redistributes ontrol vertices with a given period (as number of vertices)
     \param period - the number of vertices between control points.
     \param timestep - at this timestep all lines will be rebuilt.
     */
-    virtual void RedistributeControlVertices(int period, int timestep);
+    virtual void RedistributeControlVertices(int period, TimeStepType timestep);
 
   protected:
     mitkCloneMacro(Self);
 
     ContourModel();
-    ContourModel(const mitk::ContourModel &other);
+    ContourModel(const ContourModel &other);
     ~ContourModel() override;
 
     // inherit from BaseData. called by Clear()
     void ClearData() override;
 
     // inherit from BaseData. Initial state of a contour with no vertices and a single timestep.
     void InitializeEmpty() override;
 
     // Shift a vertex
-    void ShiftVertex(VertexType *vertex, mitk::Vector3D &vector);
+    void ShiftVertex(VertexType *vertex, Vector3D &vector);
 
     // Storage with time resolved support.
     ContourModelSeries m_ContourSeries;
 
     // The currently selected vertex.
     VertexType *m_SelectedVertex;
 
     // The interpolation of the line segment between control points.
     LineSegmentInterpolation m_lineInterpolation;
 
     // only update the bounding geometry if necessary
     bool m_UpdateBoundingBox;
   };
 
   itkEventMacro(ContourModelEvent, itk::AnyEvent);
   itkEventMacro(ContourModelShiftEvent, ContourModelEvent);
   itkEventMacro(ContourModelSizeChangeEvent, ContourModelEvent);
   itkEventMacro(ContourModelAddEvent, ContourModelSizeChangeEvent);
   itkEventMacro(ContourModelRemoveEvent, ContourModelSizeChangeEvent);
   itkEventMacro(ContourModelExpandTimeBoundsEvent, ContourModelEvent);
   itkEventMacro(ContourModelClosedEvent, ContourModelEvent);
 }
 #endif
diff --git a/Modules/ContourModel/Testing/mitkContourModelTest.cpp b/Modules/ContourModel/Testing/mitkContourModelTest.cpp
index 121971acda..e2e47448f7 100644
--- a/Modules/ContourModel/Testing/mitkContourModelTest.cpp
+++ b/Modules/ContourModel/Testing/mitkContourModelTest.cpp
@@ -1,445 +1,445 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 #include <mitkContourModel.h>
 #include <mitkTestingMacros.h>
 
 // Add a vertex to the contour and see if size changed
 static void TestAddVertex()
 {
   mitk::ContourModel::Pointer contour = mitk::ContourModel::New();
 
   mitk::Point3D p;
   p[0] = p[1] = p[2] = 0;
 
   contour->AddVertex(p);
 
   MITK_TEST_CONDITION(contour->GetNumberOfVertices() > 0, "Add a Vertex, size increased");
 }
 
 // Select a vertex by index. successful if the selected vertex member of the contour is no longer set to null
 static void TestSelectVertexAtIndex()
 {
   mitk::ContourModel::Pointer contour = mitk::ContourModel::New();
 
   mitk::Point3D p;
   p[0] = p[1] = p[2] = 0;
 
   contour->AddVertex(p);
 
   contour->SelectVertexAt(0);
 
   MITK_TEST_CONDITION(contour->GetSelectedVertex() != nullptr, "Vertex was selected at index");
 }
 
 // Select a vertex by worldposition. successful if the selected vertex member of the contour is no longer set to null
 static void TestSelectVertexAtWorldposition()
 {
   mitk::ContourModel::Pointer contour = mitk::ContourModel::New();
 
   mitk::Point3D p;
   p[0] = p[1] = p[2] = 0;
 
   contour->AddVertex(p);
 
   // same point is used here so the epsilon can be chosen very small
   contour->SelectVertexAt(p, 0.01);
 
   MITK_TEST_CONDITION(contour->GetSelectedVertex() != nullptr, "Vertex was selected at position");
 }
 
 // Move a vertex by a translation vector
 static void TestMoveSelectedVertex()
 {
   mitk::ContourModel::Pointer contour = mitk::ContourModel::New();
 
   mitk::Point3D p;
   p[0] = p[1] = p[2] = 0;
 
   contour->AddVertex(p);
 
   // Same point is used here so the epsilon can be chosen very small
   contour->SelectVertexAt(p, 0.01);
 
   mitk::Vector3D v;
   v[0] = 1;
   v[1] = 3;
   v[2] = -1;
 
   contour->ShiftSelectedVertex(v);
 
   const mitk::ContourModel::VertexType *vertex = contour->GetSelectedVertex();
 
   bool correctlyMoved = false;
 
   correctlyMoved =
     (vertex->Coordinates)[0] == (v[0]) && (vertex->Coordinates)[1] == (v[1]) && (vertex->Coordinates)[2] == (v[2]);
 
   MITK_TEST_CONDITION(correctlyMoved, "Vertex has been moved");
 }
 
 // Test to move the whole contour
 /*
 static void TestMoveContour()
 {
   mitk::ContourModel::Pointer contour = mitk::ContourModel::New();
 
   mitk::Point3D p;
   p[0] = p[1] = p[2] = 0;
 
   contour->AddVertex(p);
 
 
   mitk::Point3D p2;
   p2[0] = p2[1] = p2[2] = 0;
 
   contour->AddVertex(p2);
 
 
   mitk::Vector3D v;
   v[0] = 1;
   v[1] = 3;
   v[2] = -1;
 
   contour->ShiftContour(v);
 
   mitk::ContourModel::VertexIterator it = contour->IteratorBegin();
   mitk::ContourModel::VertexIterator end = contour->IteratorEnd();
 
   bool correctlyMoved = false;
 
   while(it != end)
   {
 
     correctlyMoved &= (*it)->Coordinates[0] == (v[0]) &&
       (*it)->Coordinates[1] == (v[1]) &&
       (*it)->Coordinates[2] == (v[2]);
   }
 
   MITK_TEST_CONDITION(correctlyMoved, "Contour has been moved");
 }
 */
 
 // Remove a vertex by index
 static void TestRemoveVertexAtIndex()
 {
   mitk::ContourModel::Pointer contour = mitk::ContourModel::New();
 
   mitk::Point3D p;
   p[0] = p[1] = p[2] = 0;
 
   contour->AddVertex(p);
 
   contour->RemoveVertexAt(0);
 
   MITK_TEST_CONDITION(contour->GetNumberOfVertices() == 0, "removed vertex");
 }
 
 // Remove a vertex by position
 static void TestRemoveVertexAtWorldPosition()
 {
   mitk::ContourModel::Pointer contour = mitk::ContourModel::New();
 
   mitk::Point3D p;
   p[0] = p[1] = p[2] = 0;
 
   contour->AddVertex(p);
 
   contour->RemoveVertexAt(p, 0.01);
 
   MITK_TEST_CONDITION(contour->GetNumberOfVertices() == 0, "removed vertex");
 }
 
 // Check closeable contour
 static void TestIsclosed()
 {
   mitk::ContourModel::Pointer contour = mitk::ContourModel::New();
 
   mitk::Point3D p;
   p[0] = p[1] = p[2] = 0;
 
   contour->AddVertex(p);
 
   mitk::Point3D p2;
   p2[0] = p2[1] = p2[2] = 1;
 
   contour->AddVertex(p2);
 
   contour->Close();
 
   MITK_TEST_CONDITION(contour->IsClosed(), "closed contour");
 
   // no vertices should be added to a closed contour
   int oldNumberOfVertices = contour->GetNumberOfVertices();
 
   mitk::Point3D p3;
   p3[0] = p3[1] = p3[2] = 4;
 
   contour->AddVertex(p3);
 
   int newNumberOfVertices = contour->GetNumberOfVertices();
 
   MITK_TEST_CONDITION(oldNumberOfVertices != newNumberOfVertices, "vertices added to closed contour");
 }
 
 // Test concatenating two contours
 static void TestConcatenate()
 {
   mitk::ContourModel::Pointer contour = mitk::ContourModel::New();
 
   mitk::Point3D p;
   p[0] = p[1] = p[2] = 0;
 
   contour->AddVertex(p);
 
   mitk::Point3D p2;
   p2[0] = p2[1] = p2[2] = 1;
 
   contour->AddVertex(p2);
 
   mitk::ContourModel::Pointer contour2 = mitk::ContourModel::New();
 
   mitk::Point3D p3;
   p3[0] = -2;
   p3[1] = 10;
   p3[2] = 0;
 
   contour2->AddVertex(p3);
 
   mitk::Point3D p4;
   p4[0] = -3;
   p4[1] = 6;
   p4[2] = -5;
 
   contour2->AddVertex(p4);
 
   contour->Concatenate(contour2);
 
   MITK_TEST_CONDITION(contour->GetNumberOfVertices() == 4, "two contours were concatenated");
 }
 
 // Try to select a vertex at position (within a epsilon of course) where no vertex is.
 // So the selected verted member should be null.
 static void TestSelectVertexAtWrongPosition()
 {
   mitk::ContourModel::Pointer contour = mitk::ContourModel::New();
 
   MITK_TEST_CONDITION_REQUIRED(contour->GetSelectedVertex() == nullptr, "selected vertex is nullptr");
   mitk::Point3D p;
   p[0] = p[1] = p[2] = 0;
 
   contour->AddVertex(p);
 
   mitk::Point3D p2;
   p2[0] = p2[1] = p2[2] = 2;
 
   contour->SelectVertexAt(p2, 0.1);
 
   MITK_TEST_CONDITION(contour->GetSelectedVertex() == nullptr, "Vertex was not selected");
 }
 
 static void TestInsertVertex()
 {
   mitk::ContourModel::Pointer contour = mitk::ContourModel::New();
 
   mitk::Point3D p;
   p[0] = p[1] = p[2] = 0;
 
   contour->AddVertex(p);
 
   mitk::Point3D p2;
   p2[0] = p2[1] = p2[2] = 1;
 
   contour->AddVertex(p2);
 
   mitk::Point3D pointToInsert;
   pointToInsert[0] = pointToInsert[1] = pointToInsert[2] = 10;
 
   contour->InsertVertexAtIndex(pointToInsert, 1);
 
   MITK_TEST_CONDITION(contour->GetNumberOfVertices() == 3, "test insert vertex");
 
   MITK_TEST_CONDITION(contour->GetVertexAt(1)->Coordinates == pointToInsert, "compare inserted vertex");
 }
 
 // try to access an invalid timestep
 static void TestInvalidTimeStep()
 {
   mitk::ContourModel::Pointer contour = mitk::ContourModel::New();
   mitk::Point3D p;
   p[0] = p[1] = p[2] = 0;
 
   contour->AddVertex(p);
 
   mitk::Point3D p2;
   p2[0] = p2[1] = p2[2] = 1;
 
   contour->AddVertex(p2);
 
-  int invalidTimeStep = 42;
+  mitk::TimeStepType invalidTimeStep = 42;
 
   MITK_TEST_CONDITION_REQUIRED(contour->IsEmptyTimeStep(invalidTimeStep), "invalid timestep required");
 
   MITK_TEST_FOR_EXCEPTION(std::exception, contour->IteratorBegin(-1));
 
   contour->Close(invalidTimeStep);
   MITK_TEST_CONDITION(contour->IsClosed() == false, "test close for timestep 0");
   MITK_TEST_CONDITION(contour->IsClosed(invalidTimeStep) == false, "test close at invalid timestep");
 
   contour->SetClosed(true, invalidTimeStep);
   MITK_TEST_CONDITION(contour->GetNumberOfVertices(invalidTimeStep) == -1,
                       "test number of vertices at invalid timestep");
 
   contour->AddVertex(p2, invalidTimeStep);
   MITK_TEST_CONDITION(contour->GetNumberOfVertices(invalidTimeStep) == -1, "test add vertex at invalid timestep");
 
   contour->InsertVertexAtIndex(p2, 0, false, invalidTimeStep);
   MITK_TEST_CONDITION(contour->GetNumberOfVertices(invalidTimeStep) == -1, "test insert vertex at invalid timestep");
 
   MITK_TEST_CONDITION(contour->SelectVertexAt(0, invalidTimeStep) == false, "test select vertex at invalid timestep");
 
   MITK_TEST_CONDITION(contour->RemoveVertexAt(0, invalidTimeStep) == false, "test remove vertex at invalid timestep");
 }
 
 static void TestEmptyContour()
 {
   mitk::ContourModel::Pointer contour = mitk::ContourModel::New();
 
   MITK_TEST_CONDITION(contour->IteratorBegin() == contour->IteratorEnd(), "test iterator of emtpy contour");
 
   MITK_TEST_CONDITION(contour->GetNumberOfVertices() == 0, "test numberof vertices of empty contour");
 }
 
 static void TestSetVertices()
 {
   mitk::ContourModel::Pointer contour = mitk::ContourModel::New();
 
   mitk::Point3D p;
   p[0] = p[1] = p[2] = 0;
 
   contour->AddVertex(p);
 
   mitk::Point3D newCoordinates;
 
   newCoordinates[0] = newCoordinates[1] = newCoordinates[2] = 1;
 
   contour->SetVertexAt(0, newCoordinates);
 
   MITK_TEST_CONDITION(mitk::Equal(contour->GetVertexAt(0)->Coordinates, newCoordinates), "set coordinates");
 
   mitk::ContourModel::Pointer contour2 = mitk::ContourModel::New();
 
   mitk::Point3D p3;
   p3[0] = -2;
   p3[1] = 10;
   p3[2] = 0;
 
   contour2->AddVertex(p3);
 
   mitk::Point3D p4;
   p4[0] = -3;
   p4[1] = 6;
   p4[2] = -5;
 
   contour2->AddVertex(p4);
 
   contour->AddVertex(p);
 
   contour->SetVertexAt(1, contour2->GetVertexAt(1));
 
   MITK_TEST_CONDITION(
     mitk::Equal(contour->GetVertexAt(1)->Coordinates, contour2->GetVertexAt(1)->Coordinates), "Use setter and getter combination");
 }
 
 static void TestContourModelAPI()
 {
   mitk::ContourModel::Pointer contour1 = mitk::ContourModel::New();
 
   mitk::Point3D p1;
   p1[0] = -2;
   p1[1] = 10;
   p1[2] = 0;
 
   contour1->AddVertex(p1);
 
   // adding vertices should always copy the content and not store pointers or references.
   MITK_TEST_CONDITION(&p1 != &(contour1->GetVertexAt(0)->Coordinates), "copied point");
 
   mitk::Point3D p2;
   p2[0] = -3;
   p2[1] = 6;
   p2[2] = -5;
 
   contour1->AddVertex(p2);
 
   // test use of setter and getter with const and non-const pointers
   const mitk::ContourModel::VertexType *vertex = contour1->GetVertexAt(1);
 
   MITK_TEST_CONDITION(contour1->GetIndex(vertex) == 1, "Get index");
 
   auto *nonConstVertex = const_cast<mitk::ContourModel::VertexType *>(vertex);
 
   MITK_TEST_CONDITION(contour1->GetIndex(nonConstVertex) == 1, "Get index non-const");
 
   mitk::ContourModel::Pointer contour2 = mitk::ContourModel::New();
 
   contour2->AddVertex(contour1->GetVertexAt(0));
 
   MITK_TEST_CONDITION(contour2->GetNumberOfVertices() == 1, "Add call with another contour");
 }
 
 static void TestClear()
 {
   mitk::ContourModel::Pointer contour = mitk::ContourModel::New();
 
   mitk::Point3D p;
   p[0] = p[1] = p[2] = 0;
   contour->AddVertex(p);
   p[0] = p[1] = p[2] = 1;
-  contour->AddVertex(p, 1);
+  contour->AddVertex(p, mitk::TimeStepType(1));
   p[0] = p[1] = p[2] = 2;
-  contour->AddVertex(p, 2);
+  contour->AddVertex(p, mitk::TimeStepType(2));
 
   contour->Clear(1);
 
   MITK_TEST_CONDITION(contour->GetTimeSteps() == 3, "Check time step count stays 3.");
   MITK_TEST_CONDITION(!contour->IsEmpty(0), "Check time step 0 is not empty.");
   MITK_TEST_CONDITION(contour->IsEmpty(1), "Check time step 1 is empty.");
   MITK_TEST_CONDITION(!contour->IsEmpty(2), "Check time step 2 is not empty.");
   MITK_TEST_CONDITION(contour->GetVertexAt(2)->Coordinates == p, "compare if vertex at t == 2 is still the same");
 
   contour->Clear();
   MITK_TEST_CONDITION(contour->GetTimeSteps() == 1, "Check time step count stays 1.");
   MITK_TEST_CONDITION(contour->IsEmpty(0), "Check time step 0 is empty.");
 }
 
 int mitkContourModelTest(int /*argc*/, char * /*argv*/ [])
 {
   MITK_TEST_BEGIN("mitkContourModelTest")
 
   TestAddVertex();
   TestSelectVertexAtIndex();
   TestSelectVertexAtWorldposition();
   TestMoveSelectedVertex();
   TestRemoveVertexAtIndex();
   TestRemoveVertexAtWorldPosition();
   TestIsclosed();
   TestConcatenate();
   TestInvalidTimeStep();
   TestInsertVertex();
   TestEmptyContour();
   TestSetVertices();
   TestSelectVertexAtWrongPosition();
   TestContourModelAPI();
   TestClear();
 
   MITK_TEST_END()
 }
diff --git a/Modules/Segmentation/Interactions/mitkFastMarchingBaseTool.cpp b/Modules/Segmentation/Interactions/mitkFastMarchingBaseTool.cpp
index 765bda5571..6f4e44ccac 100644
--- a/Modules/Segmentation/Interactions/mitkFastMarchingBaseTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkFastMarchingBaseTool.cpp
@@ -1,335 +1,336 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkFastMarchingBaseTool.h"
 #include "mitkToolManager.h"
 
 #include "mitkBaseRenderer.h"
 #include "mitkInteractionConst.h"
 #include "mitkRenderingManager.h"
 #include "mitkInteractionPositionEvent.h"
 
 #include "mitkImageAccessByItk.h"
 
 #include "mitkSegTool2D.h"
 
 #include <mitkImageCast.h>
 
 // itk filter
 #include "itkBinaryThresholdImageFilter.h"
 #include "itkCurvatureAnisotropicDiffusionImageFilter.h"
 #include "itkGradientMagnitudeRecursiveGaussianImageFilter.h"
 #include "itkSigmoidImageFilter.h"
 
 // us
 #include <usGetModuleContext.h>
 #include <usModule.h>
 #include <usModuleContext.h>
 #include <usModuleResource.h>
 
 
-mitk::FastMarchingBaseTool::FastMarchingBaseTool()
+mitk::FastMarchingBaseTool::FastMarchingBaseTool(unsigned int toolDim)
   : AutoSegmentationWithPreviewTool(false, "FastMarchingTool"),
     m_LowerThreshold(0),
     m_UpperThreshold(200),
     m_StoppingValue(100),
     m_Sigma(1.0),
     m_Alpha(-0.5),
-    m_Beta(3.0)
+    m_Beta(3.0),
+    m_ToolDimension(toolDim)
 {
 }
 
 mitk::FastMarchingBaseTool::~FastMarchingBaseTool()
 {
 }
 
 bool mitk::FastMarchingBaseTool::CanHandle(const BaseData* referenceData, const BaseData* workingData) const
 {
   if(!Superclass::CanHandle(referenceData, workingData))
     return false;
 
   if (referenceData == nullptr)
     return false;
 
   auto *image = dynamic_cast<const Image *>(referenceData);
 
   if (image == nullptr)
     return false;
 
   if (image->GetDimension() < 3)
     return false;
 
   return true;
 }
 
 const char **mitk::FastMarchingBaseTool::GetXPM() const
 {
   return nullptr; // mitkFastMarchingBaseTool_xpm;
 }
 
 us::ModuleResource mitk::FastMarchingBaseTool::GetIconResource() const
 {
   us::Module *module = us::GetModuleContext()->GetModule();
   us::ModuleResource resource = module->GetResource("FastMarching_48x48.png");
   return resource;
 }
 
 us::ModuleResource mitk::FastMarchingBaseTool::GetCursorIconResource() const
 {
   us::Module* module = us::GetModuleContext()->GetModule();
   us::ModuleResource resource = module->GetResource("FastMarching_Cursor_32x32.png");
   return resource;
 }
 
 void mitk::FastMarchingBaseTool::SetUpperThreshold(double value)
 {
   m_UpperThreshold = value / 10.0;
 }
 
 void mitk::FastMarchingBaseTool::SetLowerThreshold(double value)
 {
   m_LowerThreshold = value / 10.0;
 }
 
 void mitk::FastMarchingBaseTool::SetBeta(double value)
 {
   if (m_Beta != value)
   {
     m_Beta = value;
   }
 }
 
 void mitk::FastMarchingBaseTool::SetSigma(double value)
 {
   if (m_Sigma != value)
   {
     if (value > 0.0)
     {
       m_Sigma = value;
     }
   }
 }
 
 void mitk::FastMarchingBaseTool::SetAlpha(double value)
 {
   if (m_Alpha != value)
   {
     m_Alpha = value;
   }
 }
 
 void mitk::FastMarchingBaseTool::SetStoppingValue(double value)
 {
   if (m_StoppingValue != value)
   {
     m_StoppingValue = value;
   }
 }
 
 void mitk::FastMarchingBaseTool::Activated()
 {
   Superclass::Activated();
 
   m_SeedsAsPointSet = mitk::PointSet::New();
   //ensure that the seed points are visible for all timepoints.
   dynamic_cast<ProportionalTimeGeometry*>(m_SeedsAsPointSet->GetTimeGeometry())->SetStepDuration(std::numeric_limits<TimePointType>::max());
 
   m_SeedsAsPointSetNode = mitk::DataNode::New();
   m_SeedsAsPointSetNode->SetData(m_SeedsAsPointSet);
   m_SeedsAsPointSetNode->SetName(std::string(this->GetName()) + "_PointSet");
   m_SeedsAsPointSetNode->SetBoolProperty("helper object", true);
   m_SeedsAsPointSetNode->SetColor(0.0, 1.0, 0.0);
   m_SeedsAsPointSetNode->SetVisibility(true);
 
   m_ToolManager->GetDataStorage()->Add(m_SeedsAsPointSetNode, m_ToolManager->GetWorkingData(0));
 }
 
 void mitk::FastMarchingBaseTool::Deactivated()
 {
   this->ClearSeeds();
 
   m_ToolManager->GetDataStorage()->Remove(m_SeedsAsPointSetNode);
   m_SeedsAsPointSetNode = nullptr;
   m_SeedsAsPointSet = nullptr;
 
   Superclass::Deactivated();
 }
 
 void mitk::FastMarchingBaseTool::ConnectActionsAndFunctions()
 {
   CONNECT_FUNCTION("ShiftSecondaryButtonPressed", OnAddPoint);
   CONNECT_FUNCTION("ShiftPrimaryButtonPressed", OnAddPoint);
   CONNECT_FUNCTION("DeletePoint", OnDelete);
 }
 
 void mitk::FastMarchingBaseTool::OnAddPoint(StateMachineAction*, InteractionEvent* interactionEvent)
 {
   if (!this->IsUpdating() && m_SeedsAsPointSet.IsNotNull())
   {
     const auto positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>(interactionEvent);
 
     if (positionEvent != nullptr)
     {
       auto newWorkingPlaneGeometry = positionEvent->GetSender()->GetCurrentWorldPlaneGeometry()->Clone();
 
       // if click was on another plane and we are in 2D mode wie should reset the seeds
-      if (TOOL_DIMENSION == 2 && ( nullptr == this->GetWorkingPlaneGeometry() || !this->GetWorkingPlaneGeometry()->IsOnPlane(newWorkingPlaneGeometry.GetPointer())))
+      if (m_ToolDimension == 2 && ( nullptr == this->GetWorkingPlaneGeometry() || !this->GetWorkingPlaneGeometry()->IsOnPlane(newWorkingPlaneGeometry.GetPointer())))
       {
         this->ClearSeeds();
         this->SetWorkingPlaneGeometry(newWorkingPlaneGeometry);
       }
 
       m_SeedsAsPointSet->InsertPoint(m_SeedsAsPointSet->GetSize(), positionEvent->GetPositionInWorld());
 
       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
       this->UpdatePreview();
     }
   }
 }
 
 void mitk::FastMarchingBaseTool::OnDelete(StateMachineAction*, InteractionEvent* /*interactionEvent*/)
 {
   if (!this->IsUpdating() && m_SeedsAsPointSet.IsNotNull())
   {
     // delete last seed point
     if (this->m_SeedsAsPointSet->GetSize() > 0)
     {
       // delete last point in pointset - somehow ugly
       m_SeedsAsPointSet->GetPointSet()->GetPoints()->DeleteIndex(m_SeedsAsPointSet->GetSize() - 1);
 
       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
       this->UpdatePreview();
     }
   }
 }
 
 void mitk::FastMarchingBaseTool::ClearSeeds()
 {
   if (this->m_SeedsAsPointSet.IsNotNull())
   {
     // renew pointset
     this->m_SeedsAsPointSet = mitk::PointSet::New();
     //ensure that the seed points are visible for all timepoints.
     dynamic_cast<ProportionalTimeGeometry*>(m_SeedsAsPointSet->GetTimeGeometry())->SetStepDuration(std::numeric_limits<TimePointType>::max());
     this->m_SeedsAsPointSetNode->SetData(this->m_SeedsAsPointSet);
   }
 }
 
 template <typename TPixel, unsigned int VImageDimension>
 void mitk::FastMarchingBaseTool::DoITKFastMarching(const itk::Image<TPixel, VImageDimension>* inputImage,
   mitk::Image* previewImage, unsigned int timeStep, const mitk::BaseGeometry* inputGeometry)
 {
   // typedefs for itk pipeline
   typedef itk::Image<TPixel, VImageDimension> InputImageType;
 
   typedef float InternalPixelType;
   typedef itk::Image<InternalPixelType, VImageDimension> InternalImageType;
 
   typedef mitk::Tool::DefaultSegmentationDataType OutputPixelType;
   typedef itk::Image<OutputPixelType, VImageDimension> OutputImageType;
 
   typedef itk::CurvatureAnisotropicDiffusionImageFilter<InputImageType, InternalImageType> SmoothingFilterType;
   typedef itk::GradientMagnitudeRecursiveGaussianImageFilter<InternalImageType, InternalImageType> GradientFilterType;
   typedef itk::SigmoidImageFilter<InternalImageType, InternalImageType> SigmoidFilterType;
   typedef itk::BinaryThresholdImageFilter<InternalImageType, OutputImageType> ThresholdingFilterType;
 
   typedef itk::FastMarchingImageFilter<InternalImageType, InternalImageType> FastMarchingFilterType;
   typedef typename FastMarchingFilterType::NodeContainer NodeContainer;
   typedef typename FastMarchingFilterType::NodeType NodeType;
 
   //convert point set seed into trialpoint
   typename NodeContainer::Pointer trialPoints = NodeContainer::New();
   trialPoints->Initialize();
 
   for (auto pos = m_SeedsAsPointSet->Begin(); pos != m_SeedsAsPointSet->End(); ++pos)
   {
     mitk::Point3D clickInIndex;
 
     inputGeometry->WorldToIndex(pos->Value(), clickInIndex);
     itk::Index<VImageDimension> seedPosition;
     for (unsigned int dim = 0; dim < VImageDimension; ++dim)
     {
       seedPosition[dim] = clickInIndex[dim];
     }
 
     NodeType node;
     const double seedValue = 0.0;
     node.SetValue(seedValue);
     node.SetIndex(seedPosition);
     trialPoints->InsertElement(trialPoints->Size(), node);
   }
 
   // assemble pipeline
   auto smoothFilter = SmoothingFilterType::New();
   smoothFilter->AddObserver(itk::ProgressEvent(), m_ProgressCommand);
   smoothFilter->SetTimeStep(0.05);
   smoothFilter->SetNumberOfIterations(2);
   smoothFilter->SetConductanceParameter(9.0);
 
   auto gradientMagnitudeFilter = GradientFilterType::New();
   gradientMagnitudeFilter->AddObserver(itk::ProgressEvent(), m_ProgressCommand);
   gradientMagnitudeFilter->SetSigma(m_Sigma);
 
   auto sigmoidFilter = SigmoidFilterType::New();
   sigmoidFilter->AddObserver(itk::ProgressEvent(), m_ProgressCommand);
   sigmoidFilter->SetAlpha(m_Alpha);
   sigmoidFilter->SetBeta(m_Beta);
   sigmoidFilter->SetOutputMinimum(0.0);
   sigmoidFilter->SetOutputMaximum(1.0);
 
   auto fastMarchingFilter = FastMarchingFilterType::New();
   fastMarchingFilter->AddObserver(itk::ProgressEvent(), m_ProgressCommand);
   fastMarchingFilter->SetStoppingValue(m_StoppingValue);
   fastMarchingFilter->SetTrialPoints(trialPoints);
 
   auto thresholdFilter = ThresholdingFilterType::New();
   thresholdFilter->SetLowerThreshold(m_LowerThreshold);
   thresholdFilter->SetUpperThreshold(m_UpperThreshold);
   thresholdFilter->SetOutsideValue(0);
   thresholdFilter->SetInsideValue(1.0);
 
   // set up pipeline
   smoothFilter->SetInput(inputImage);
   gradientMagnitudeFilter->SetInput(smoothFilter->GetOutput());
   sigmoidFilter->SetInput(gradientMagnitudeFilter->GetOutput());
   fastMarchingFilter->SetInput(sigmoidFilter->GetOutput());
   thresholdFilter->SetInput(fastMarchingFilter->GetOutput());
   thresholdFilter->Update();
 
   if (nullptr == this->GetWorkingPlaneGeometry())
   {
     previewImage->SetVolume((void*)(thresholdFilter->GetOutput()->GetPixelContainer()->GetBufferPointer()), timeStep);
   }
   else
   {
     mitk::Image::Pointer sliceImage = mitk::Image::New();
     mitk::CastToMitkImage(thresholdFilter->GetOutput(), sliceImage);
     SegTool2D::WriteSliceToVolume(previewImage, this->GetWorkingPlaneGeometry(), sliceImage, timeStep, false);
   }
 }
 
 void mitk::FastMarchingBaseTool::DoUpdatePreview(const Image* inputAtTimeStep, Image* previewImage, TimeStepType timeStep)
 {
   if (nullptr != inputAtTimeStep && nullptr != previewImage && m_SeedsAsPointSet.IsNotNull() && m_SeedsAsPointSet->GetSize()>0)
   {
     if (nullptr == this->GetWorkingPlaneGeometry())
     {
       AccessFixedDimensionByItk_n(inputAtTimeStep, DoITKFastMarching, 3, (previewImage, timeStep, inputAtTimeStep->GetGeometry()));
     }
     else
     {
       AccessFixedDimensionByItk_n(inputAtTimeStep, DoITKFastMarching, 2, (previewImage, timeStep, inputAtTimeStep->GetGeometry()));
     }
   }
 }
diff --git a/Modules/Segmentation/Interactions/mitkFastMarchingBaseTool.h b/Modules/Segmentation/Interactions/mitkFastMarchingBaseTool.h
index eea9bb1d47..60059f84a7 100644
--- a/Modules/Segmentation/Interactions/mitkFastMarchingBaseTool.h
+++ b/Modules/Segmentation/Interactions/mitkFastMarchingBaseTool.h
@@ -1,114 +1,118 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef mitkFastMarchingBaseTool_h_Included
 #define mitkFastMarchingBaseTool_h_Included
 
 #include "mitkAutoSegmentationWithPreviewTool.h"
 #include "mitkDataNode.h"
 #include "mitkPointSet.h"
 #include "mitkPointSetDataInteractor.h"
 #include "mitkToolCommand.h"
 
 #include "itkImage.h"
 #include "itkFastMarchingImageFilter.h"
 
 #include <MitkSegmentationExports.h>
 
 namespace us
 {
   class ModuleResource;
 }
 
 namespace mitk
 {
   /**
     \brief FastMarching semgentation tool base class.
 
     The segmentation is done by setting one or more seed points on the image
     and adapting the time range and threshold. The pipeline is:
       Smoothing->GradientMagnitude->SigmoidFunction->FastMarching->Threshold
     The resulting binary image is seen as a segmentation of an object.
 
     For detailed documentation see ITK Software Guide section 9.3.1 Fast Marching Segmentation.
   */
   class MITKSEGMENTATION_EXPORT FastMarchingBaseTool : public AutoSegmentationWithPreviewTool
   {
   public:
     mitkClassMacro(FastMarchingBaseTool, AutoSegmentationWithPreviewTool);
 
     bool CanHandle(const BaseData* referenceData, const BaseData* workingData) const override;
 
     /* icon stuff */
     const char **GetXPM() const override;
     us::ModuleResource GetCursorIconResource() const override;
     us::ModuleResource GetIconResource() const override;
 
     void Activated() override;
     void Deactivated() override;
 
     /// \brief Set parameter used in Threshold filter.
     void SetUpperThreshold(double);
 
     /// \brief Set parameter used in Threshold filter.
     void SetLowerThreshold(double);
 
     /// \brief Set parameter used in Fast Marching filter.
     void SetStoppingValue(double);
 
     /// \brief Set parameter used in Gradient Magnitude filter.
     void SetSigma(double);
 
     /// \brief Set parameter used in Fast Marching filter.
     void SetAlpha(double);
 
     /// \brief Set parameter used in Fast Marching filter.
     void SetBeta(double);
 
     /// \brief Clear all seed points.
     void ClearSeeds();
 
 
   protected:
-    FastMarchingBaseTool();
+    FastMarchingBaseTool(unsigned int toolDim);
     ~FastMarchingBaseTool() override;
 
-    unsigned int TOOL_DIMENSION = 3;
-
     void ConnectActionsAndFunctions() override;
 
     /// \brief Add point action of StateMachine pattern
     virtual void OnAddPoint(StateMachineAction*, InteractionEvent* interactionEvent);
 
     /// \brief Delete action of StateMachine pattern
     virtual void OnDelete(StateMachineAction*, InteractionEvent* interactionEvent);
 
     void DoUpdatePreview(const Image* inputAtTimeStep, Image* previewImage, TimeStepType timeStep) override;
 
     template <typename TPixel, unsigned int VImageDimension>
     void DoITKFastMarching(const itk::Image<TPixel, VImageDimension>* inputImage,
       mitk::Image* segmentation, unsigned int timeStep, const mitk::BaseGeometry* inputGeometry);
 
     float m_LowerThreshold; // used in Threshold filter
     float m_UpperThreshold; // used in Threshold filter
     float m_StoppingValue;  // used in Fast Marching filter
     float m_Sigma;          // used in GradientMagnitude filter
     float m_Alpha;          // used in Sigmoid filter
     float m_Beta;           // used in Sigmoid filter
 
     mitk::DataNode::Pointer m_SeedsAsPointSetNode; // used to visualize the seed points
     mitk::PointSet::Pointer m_SeedsAsPointSet;
+
+  private:
+    /** Indicating if the tool is used in 2D mode (just segment the current slice)
+     * or 3D mode (segment the whole current volume),*/
+    unsigned int m_ToolDimension;
+
   };
 
 } // namespace
 
 #endif
diff --git a/Modules/Segmentation/Interactions/mitkFastMarchingTool.cpp b/Modules/Segmentation/Interactions/mitkFastMarchingTool.cpp
index 472026f6b7..95eb57c850 100644
--- a/Modules/Segmentation/Interactions/mitkFastMarchingTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkFastMarchingTool.cpp
@@ -1,35 +1,34 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkFastMarchingTool.h"
 
 
 namespace mitk
 {
   MITK_TOOL_MACRO(MITKSEGMENTATION_EXPORT, FastMarchingTool, "FastMarching2D tool");
 }
 
 mitk::FastMarchingTool::FastMarchingTool()
-  : FastMarchingBaseTool()
+  : FastMarchingBaseTool(2)
 {
-  TOOL_DIMENSION = 2;
 }
 
 mitk::FastMarchingTool::~FastMarchingTool()
 {
 }
 
 const char *mitk::FastMarchingTool::GetName() const
 {
   return "2D Fast Marching";
 }
 
diff --git a/Modules/Segmentation/Interactions/mitkFastMarchingTool3D.cpp b/Modules/Segmentation/Interactions/mitkFastMarchingTool3D.cpp
index 4dc155ad03..0de2aacf30 100644
--- a/Modules/Segmentation/Interactions/mitkFastMarchingTool3D.cpp
+++ b/Modules/Segmentation/Interactions/mitkFastMarchingTool3D.cpp
@@ -1,33 +1,32 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkFastMarchingTool3D.h"
 
 namespace mitk
 {
   MITK_TOOL_MACRO(MITKSEGMENTATION_EXPORT, FastMarchingTool3D, "FastMarching3D tool");
 }
 
 mitk::FastMarchingTool3D::FastMarchingTool3D()
-  : FastMarchingBaseTool()
+  : FastMarchingBaseTool(3)
 {
-  TOOL_DIMENSION = 3;
 }
 
 mitk::FastMarchingTool3D::~FastMarchingTool3D()
 {
 }
 
 const char *mitk::FastMarchingTool3D::GetName() const
 {
   return "Fast Marching 3D";
 }
diff --git a/Modules/Segmentation/Interactions/mitkFeedbackContourTool.cpp b/Modules/Segmentation/Interactions/mitkFeedbackContourTool.cpp
index c5d8e7a95a..1a45387bc3 100644
--- a/Modules/Segmentation/Interactions/mitkFeedbackContourTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkFeedbackContourTool.cpp
@@ -1,276 +1,276 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkFeedbackContourTool.h"
 #include "mitkToolManager.h"
 
 #include "mitkColorProperty.h"
 #include "mitkProperties.h"
 #include "mitkStringProperty.h"
 
 #include "mitkBaseRenderer.h"
 #include "mitkDataStorage.h"
 
 #include "mitkRenderingManager.h"
 
 #include "mitkAbstractTransformGeometry.h"
 
 mitk::FeedbackContourTool::FeedbackContourTool(const char *type) : SegTool2D(type), m_FeedbackContourVisible(false)
 {
   m_FeedbackContourNode = DataNode::New();
   m_FeedbackContourNode->SetProperty("name", StringProperty::New("One of FeedbackContourTool's feedback nodes"));
   m_FeedbackContourNode->SetProperty("visible", BoolProperty::New(true));
   m_FeedbackContourNode->SetProperty("helper object", BoolProperty::New(true));
   m_FeedbackContourNode->SetProperty("layer", IntProperty::New(1000));
   m_FeedbackContourNode->SetProperty("contour.project-onto-plane", BoolProperty::New(false));
   m_FeedbackContourNode->SetProperty("contour.width", FloatProperty::New(1.0));
   // set to max short, max int doesn't work, max value somewhere hardcoded?
   m_FeedbackContourNode->SetProperty("layer", IntProperty::New(std::numeric_limits<short>::max()));
   m_FeedbackContourNode->SetProperty("fixedLayer", BoolProperty::New(true));
   this->InitializeFeedbackContour(true);
   SetFeedbackContourColorDefault();
 }
 
 mitk::FeedbackContourTool::~FeedbackContourTool()
 {
 }
 
 void mitk::FeedbackContourTool::SetFeedbackContourColor(float r, float g, float b)
 {
   m_FeedbackContourNode->SetProperty("contour.color", ColorProperty::New(r, g, b));
 }
 
 void mitk::FeedbackContourTool::SetFeedbackContourColorDefault()
 {
   m_FeedbackContourNode->SetProperty("contour.color", ColorProperty::New(0.0 / 255.0, 255.0 / 255.0, 0.0 / 255.0));
 }
 
 void mitk::FeedbackContourTool::Deactivated()
 {
   Superclass::Deactivated();
   DataStorage *storage = m_ToolManager->GetDataStorage();
   if (storage && m_FeedbackContourNode.IsNotNull())
   {
     storage->Remove(m_FeedbackContourNode);
     m_FeedbackContour->Clear();
     SetFeedbackContourVisible(false);
   }
 }
 
 void mitk::FeedbackContourTool::Activated()
 {
   Superclass::Activated();
   this->InitializeFeedbackContour(true);
   this->SetFeedbackContourVisible(true);
 }
 
 const mitk::ContourModel *mitk::FeedbackContourTool::GetFeedbackContour() const
 {
   return m_FeedbackContour;
 }
 
 void mitk::FeedbackContourTool::InitializeFeedbackContour(bool isClosed)
 {
   m_FeedbackContour = ContourModel::New();
   m_FeedbackContour->SetClosed(isClosed);
 
   auto workingImage = this->GetWorkingData();
 
   if (nullptr != workingImage)
   {
     m_FeedbackContour->Expand(workingImage->GetTimeSteps());
 
     auto contourTimeGeometry = workingImage->GetTimeGeometry()->Clone();
     contourTimeGeometry->ReplaceTimeStepGeometries(m_FeedbackContour->GetGeometry());
     m_FeedbackContour->SetTimeGeometry(contourTimeGeometry);
 
     for (unsigned int t = 0; t < m_FeedbackContour->GetTimeSteps(); ++t)
     {
       m_FeedbackContour->SetClosed(isClosed, t);
     }
   }
 
   m_FeedbackContourNode->SetData(m_FeedbackContour);
 }
 
 void mitk::FeedbackContourTool::ClearsCurrentFeedbackContour(bool isClosed)
 {
   if (!m_FeedbackContour->GetTimeGeometry()->IsValidTimePoint(this->GetLastTimePointTriggered()))
   {
     MITK_WARN << "Cannot clear feedback contour at current time step. Feedback contour is in invalid state as its time geometry does not support current selected time point. Invalid time point: " << this->GetLastTimePointTriggered();
     return;
   }
 
   auto feedbackTimeStep = m_FeedbackContour->GetTimeGeometry()->TimePointToTimeStep(this->GetLastTimePointTriggered());
   m_FeedbackContour->Clear(feedbackTimeStep);
   m_FeedbackContour->SetClosed(isClosed, feedbackTimeStep);
 }
 
 void mitk::FeedbackContourTool::UpdateCurrentFeedbackContour(const ContourModel* sourceModel, TimeStepType sourceTimeStep)
 {
   if (nullptr == sourceModel)
     return;
 
   if (!m_FeedbackContour->GetTimeGeometry()->IsValidTimePoint(this->GetLastTimePointTriggered()))
   {
     MITK_WARN << "Cannot update feedback contour. Feedback contour is in invalid state as its time geometry does not support current selected time point. Invalid time point: "<<this->GetLastTimePointTriggered();
     return;
   }
 
   auto feedbackTimeStep = m_FeedbackContour->GetTimeGeometry()->TimePointToTimeStep(this->GetLastTimePointTriggered());
   this->UpdateFeedbackContour(sourceModel, feedbackTimeStep, sourceTimeStep);
 }
 
 void mitk::FeedbackContourTool::UpdateFeedbackContour(const ContourModel* sourceModel, TimeStepType feedbackTimeStep, TimeStepType sourceTimeStep)
 {
   if (nullptr == sourceModel)
     return;
 
   if (!m_FeedbackContour->GetTimeGeometry()->IsValidTimeStep(feedbackTimeStep))
   {
     MITK_WARN << "Cannot update feedback contour. Feedback contour time geometry does not support passed time step. Invalid time step: "<<feedbackTimeStep;
     return;
   }
 
   m_FeedbackContour->Clear(feedbackTimeStep);
 
   std::for_each(sourceModel->Begin(sourceTimeStep), sourceModel->End(sourceTimeStep), [this, feedbackTimeStep](ContourElement::VertexType* vertex) {
     this->m_FeedbackContour->AddVertex(vertex, feedbackTimeStep);
   });
 }
 
 void mitk::FeedbackContourTool::AddVertexToCurrentFeedbackContour(const Point3D& point)
 {
   if (!m_FeedbackContour->GetTimeGeometry()->IsValidTimePoint(this->GetLastTimePointTriggered()))
   {
     MITK_WARN << "Cannot add vertex to feedback contour. Feedback contour is in invalid state as its time geometry does not support current selected time point. Invalid time point: " << this->GetLastTimePointTriggered();
     return;
   }
 
   auto feedbackTimeStep = m_FeedbackContour->GetTimeGeometry()->TimePointToTimeStep(this->GetLastTimePointTriggered());
   this->AddVertexToFeedbackContour(point, feedbackTimeStep);
 };
 
 /** Adds a vertex to the feedback contour for the passed time step. If time step is invalid, nothing will be added.*/
 void mitk::FeedbackContourTool::AddVertexToFeedbackContour(const Point3D& point, TimeStepType feedbackTimeStep)
 {
   if (!m_FeedbackContour->GetTimeGeometry()->IsValidTimeStep(feedbackTimeStep))
   {
     MITK_WARN << "Cannot add vertex to feedback contour. Feedback contour time geometry does not support passed time step. Invalid time step: " << feedbackTimeStep;
     return;
   }
 
-  m_FeedbackContour->AddVertex(point,static_cast<int>(feedbackTimeStep));
+  m_FeedbackContour->AddVertex(point, feedbackTimeStep);
 }
 
 
 void mitk::FeedbackContourTool::SetFeedbackContourVisible(bool visible)
 {
   if (m_FeedbackContourVisible == visible)
     return; // nothing changed
 
   if (DataStorage *storage = m_ToolManager->GetDataStorage())
   {
     if (visible)
     {
       // Add the feedback contour node as a derived node of the first working data.
       // If there is no working data, the node is added at the top level.
       storage->Add(m_FeedbackContourNode, this->GetWorkingDataNode());
     }
     else
     {
       storage->Remove(m_FeedbackContourNode);
     }
   }
 
   m_FeedbackContourVisible = visible;
 }
 
 mitk::ContourModel::Pointer mitk::FeedbackContourTool::ProjectContourTo2DSlice(const Image *slice,
                                                                                const ContourModel *contourIn3D,
                                                                                bool correctionForIpSegmentation,
                                                                                bool constrainToInside)
 {
   return mitk::ContourModelUtils::ProjectContourTo2DSlice(
     slice, contourIn3D, correctionForIpSegmentation, constrainToInside);
 }
 
 mitk::ContourModel::Pointer mitk::FeedbackContourTool::BackProjectContourFrom2DSlice(const BaseGeometry *sliceGeometry,
                                                                                      const ContourModel *contourIn2D,
                                                                                      bool correctionForIpSegmentation)
 {
   return mitk::ContourModelUtils::BackProjectContourFrom2DSlice(
     sliceGeometry, contourIn2D, correctionForIpSegmentation);
 }
 
 void mitk::FeedbackContourTool::WriteBackFeedbackContourAsSegmentationResult(const InteractionPositionEvent* positionEvent, int paintingPixelValue, bool setInvisibleAfterSuccess)
 {
   if (!positionEvent)
     return;
 
   auto workingImage = this->GetWorkingData();
   const auto planeGeometry((positionEvent->GetSender()->GetCurrentWorldPlaneGeometry()));
 
   if (!workingImage || !planeGeometry)
     return;
 
   const auto* abstractTransformGeometry(
     dynamic_cast<const AbstractTransformGeometry*>(positionEvent->GetSender()->GetCurrentWorldPlaneGeometry()));
   if (nullptr != abstractTransformGeometry)
     return;
 
   Image::Pointer slice = FeedbackContourTool::GetAffectedWorkingSlice(positionEvent);
 
   if (slice.IsNull())
   {
     MITK_ERROR << "Unable to extract slice." << std::endl;
     return;
   }
 
   const auto feedbackContour = FeedbackContourTool::GetFeedbackContour();
   auto contourTimeStep = positionEvent->GetSender()->GetTimeStep(feedbackContour);
 
   ContourModel::Pointer projectedContour = FeedbackContourTool::ProjectContourTo2DSlice(
     slice, feedbackContour, false, false); // false: don't add 0.5 (done by FillContourInSlice)
   // false: don't constrain the contour to the image's inside
 
   if (projectedContour.IsNull())
     return;
 
   auto activePixelValue = ContourModelUtils::GetActivePixelValue(workingImage);
 
   mitk::ContourModelUtils::FillContourInSlice(
     projectedContour, contourTimeStep, slice, workingImage, paintingPixelValue * activePixelValue);
 
   this->WriteBackSegmentationResult(positionEvent, slice);
 
   if (setInvisibleAfterSuccess)
   {
     this->SetFeedbackContourVisible(false);
   }
 }
 
 
 void mitk::FeedbackContourTool::FillContourInSlice(ContourModel *projectedContour,
                                                    Image *sliceImage,
                                                    int paintingPixelValue)
 {
   this->FillContourInSlice(projectedContour, 0, sliceImage, paintingPixelValue);
 }
 
 void mitk::FeedbackContourTool::FillContourInSlice(ContourModel *projectedContour,
                                                    unsigned int timeStep,
                                                    Image *sliceImage,
                                                    int paintingPixelValue)
 {
   mitk::ContourModelUtils::FillContourInSlice(projectedContour, timeStep, sliceImage, sliceImage, paintingPixelValue);
 }
diff --git a/Modules/Segmentation/Interactions/mitkLiveWireTool2D.h b/Modules/Segmentation/Interactions/mitkLiveWireTool2D.h
index 01950e5232..dff07f7a0b 100644
--- a/Modules/Segmentation/Interactions/mitkLiveWireTool2D.h
+++ b/Modules/Segmentation/Interactions/mitkLiveWireTool2D.h
@@ -1,139 +1,139 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef mitkLiveWireTool2D_h
 #define mitkLiveWireTool2D_h
 
 #include <mitkSegTool2D.h>
 #include <mitkContourModelLiveWireInteractor.h>
 
 namespace mitk
 {
   /**
     \brief A 2D segmentation tool based on a LiveWire approach.
 
     The contour between the last point and the current mouse position is
     computed by searching the shortest path according to specific features of
     the image. The contour thus tends to snap to the boundary of objects.
 
     The tool always assumes that unconfirmed contours are always defined for the
     current time point. So the time step in which the contours will be stored as
     segmentations will be determined when the contours got confirmed. Then they
     will be transfered to the slices of the currently selected time step.
-    Changing the time point/time step will tool is active will updated the working
-    slice the life wire filter. So the behavior of the active life wire contour is
+    Changing the time point/time step while tool is active will updated the working
+    slice the live wire filter. So the behavior of the active live wire contour is
     always WYSIWYG (What you see is what you get).
 
     \sa SegTool2D
     \sa ImageLiveWireContourModelFilter
 
     \ingroup Interaction
     \ingroup ToolManagerEtAl
 
     \warning Only to be instantiated by mitk::ToolManager.
   */
   class MITKSEGMENTATION_EXPORT LiveWireTool2D : public SegTool2D
   {
   public:
     mitkClassMacro(LiveWireTool2D, SegTool2D);
     itkFactorylessNewMacro(Self);
 
     us::ModuleResource GetCursorIconResource() const override;
     us::ModuleResource GetIconResource() const override;
     const char *GetName() const override;
     const char **GetXPM() const override;
 
     /// \brief Convert all current contours to binary segmentations.
     void ConfirmSegmentation();
 
     /// \brief Delete all current contours.
     void ClearSegmentation();
 
   protected:
     LiveWireTool2D();
     ~LiveWireTool2D() override;
 
     void ConnectActionsAndFunctions() override;
     void Activated() override;
     void Deactivated() override;
     void UpdateLiveWireContour();
     void OnTimePointChanged() override;
 
   private:
     /// \brief Initialize tool.
     void OnInitLiveWire(StateMachineAction *, InteractionEvent *interactionEvent);
 
     /// \brief Add a control point and finish current segment.
     void OnAddPoint(StateMachineAction *, InteractionEvent *interactionEvent);
 
     /// \brief Actual LiveWire computation.
     void OnMouseMoved(StateMachineAction *, InteractionEvent *interactionEvent);
 
     /// \brief Check double click on first control point to finish the LiveWire tool.
     bool OnCheckPoint(const InteractionEvent *interactionEvent);
 
     /// \brief Finish LiveWire tool.
     void OnFinish(StateMachineAction *, InteractionEvent *interactionEvent);
 
     /// \brief Close the contour.
     void OnLastSegmentDelete(StateMachineAction *, InteractionEvent *interactionEvent);
 
     /// \brief Don't use dynamic cost map for LiveWire calculation.
     void OnMouseMoveNoDynamicCosts(StateMachineAction *, InteractionEvent *interactionEvent);
 
     /// \brief Finish contour interaction.
     void FinishTool();
 
     void EnableContourLiveWireInteraction(bool on);
 
     bool IsPositionEventInsideImageRegion(InteractionPositionEvent *positionEvent, BaseData *data);
 
     void ReleaseInteractors();
 
     void ReleaseHelperObjects();
 
     void RemoveHelperObjects();
 
     template <typename TPixel, unsigned int VImageDimension>
     void FindHighestGradientMagnitudeByITK(itk::Image<TPixel, VImageDimension> *inputImage,
                                            itk::Index<3> &index,
                                            itk::Index<3> &returnIndex);
 
     ContourModel::Pointer CreateNewContour() const;
 
     mitk::ContourModel::Pointer m_Contour;
     mitk::DataNode::Pointer m_ContourNode;
 
     mitk::ContourModel::Pointer m_LiveWireContour;
     mitk::DataNode::Pointer m_LiveWireContourNode;
 
     mitk::ContourModel::Pointer m_EditingContour;
     mitk::DataNode::Pointer m_EditingContourNode;
     mitk::ContourModelLiveWireInteractor::Pointer m_ContourInteractor;
 
-    /** Slice of the reference data the tool is currently activaly working on to
+    /** Slice of the reference data the tool is currently actively working on to
     define contours.*/
     mitk::Image::Pointer m_ReferenceDataSlice;
 
     mitk::ImageLiveWireContourModelFilter::Pointer m_LiveWireFilter;
 
     bool m_CreateAndUseDynamicCosts;
 
     std::vector<std::pair<mitk::DataNode::Pointer, mitk::PlaneGeometry::Pointer>> m_WorkingContours;
     std::vector<std::pair<mitk::DataNode::Pointer, mitk::PlaneGeometry::Pointer>> m_EditingContours;
     std::vector<mitk::ContourModelLiveWireInteractor::Pointer> m_LiveWireInteractors;
 
     PlaneGeometry::ConstPointer m_PlaneGeometry;
   };
 }
 
 #endif
diff --git a/Modules/SegmentationUI/Qmitk/QmitkAutoSegmentationToolGUIBase.cpp b/Modules/SegmentationUI/Qmitk/QmitkAutoSegmentationToolGUIBase.cpp
index 36e85d8698..58c966cfd3 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkAutoSegmentationToolGUIBase.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitkAutoSegmentationToolGUIBase.cpp
@@ -1,146 +1,147 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkAutoSegmentationToolGUIBase.h"
 
 #include <qcheckbox.h>
 #include <qpushbutton.h>
 #include <qboxlayout.h>
 #include <qlabel.h>
 #include <QApplication>
 
 bool DefaultEnableConfirmSegBtnFunction(bool enabled)
 {
   return enabled;
 }
 
 QmitkAutoSegmentationToolGUIBase::QmitkAutoSegmentationToolGUIBase(bool mode2D) : QmitkToolGUI(), m_EnableConfirmSegBtnFnc(DefaultEnableConfirmSegBtnFunction), m_Mode2D(mode2D)
 {
   connect(this, SIGNAL(NewToolAssociated(mitk::Tool *)), this, SLOT(OnNewToolAssociated(mitk::Tool *)));
 }
 
 QmitkAutoSegmentationToolGUIBase::~QmitkAutoSegmentationToolGUIBase()
 {
   if (m_Tool.IsNotNull())
   {
     m_Tool->CurrentlyBusy -= mitk::MessageDelegate1<QmitkAutoSegmentationToolGUIBase, bool>(this, &QmitkAutoSegmentationToolGUIBase::BusyStateChanged);
   }
 }
 
 void QmitkAutoSegmentationToolGUIBase::OnNewToolAssociated(mitk::Tool *tool)
 {
   if (m_Tool.IsNotNull())
   {
     this->DisconnectOldTool(m_Tool);
   }
 
   m_Tool = dynamic_cast<mitk::AutoSegmentationWithPreviewTool*>(tool);
 
   if (nullptr == m_MainLayout)
   {
     // create the visible widgets
     m_MainLayout = new QVBoxLayout(this);
     m_ConfirmSegBtn = new QPushButton("Confirm Segmentation", this);
     connect(m_ConfirmSegBtn, SIGNAL(clicked()), this, SLOT(OnAcceptPreview()));
 
     m_CheckProcessAll = new QCheckBox("Process all time steps", this);
     m_CheckProcessAll->setChecked(false);
     m_CheckProcessAll->setToolTip("Process/overwrite all time steps of the dynamic segmentation and not just the currently visible time step.");
     m_CheckProcessAll->setVisible(!m_Mode2D);
 
     m_CheckCreateNew = new QCheckBox("Create as new segmentation", this);
     m_CheckCreateNew->setChecked(false);
     m_CheckCreateNew->setToolTip("Add the confirmed segmentation as a new segmentation instead of overwriting the currently selected.");
     m_CheckCreateNew->setVisible(!m_Mode2D);
 
     this->InitializeUI(m_MainLayout);
 
     m_MainLayout->addWidget(m_ConfirmSegBtn);
     m_MainLayout->addWidget(m_CheckProcessAll);
     m_MainLayout->addWidget(m_CheckCreateNew);
   }
 
   if (m_Tool.IsNotNull())
   {
     this->ConnectNewTool(m_Tool);
   }
 }
 
 void QmitkAutoSegmentationToolGUIBase::OnAcceptPreview()
 {
   if (m_Tool.IsNotNull())
   {
     if (m_CheckCreateNew->isChecked())
     {
       m_Tool->SetOverwriteExistingSegmentation(false);
     }
     else
     {
       m_Tool->SetOverwriteExistingSegmentation(true);
     }
 
     m_Tool->SetCreateAllTimeSteps(m_CheckProcessAll->isChecked());
 
     m_ConfirmSegBtn->setEnabled(false);
     m_Tool->ConfirmSegmentation();
   }
 }
 
 void QmitkAutoSegmentationToolGUIBase::DisconnectOldTool(mitk::AutoSegmentationWithPreviewTool* oldTool)
 {
   oldTool->CurrentlyBusy -= mitk::MessageDelegate1<QmitkAutoSegmentationToolGUIBase, bool>(this, &QmitkAutoSegmentationToolGUIBase::BusyStateChanged);
 }
 
 void QmitkAutoSegmentationToolGUIBase::ConnectNewTool(mitk::AutoSegmentationWithPreviewTool* newTool)
 {
   newTool->CurrentlyBusy +=
     mitk::MessageDelegate1<QmitkAutoSegmentationToolGUIBase, bool>(this, &QmitkAutoSegmentationToolGUIBase::BusyStateChanged);
 
   newTool->SetOverwriteExistingSegmentation(true);
   m_CheckProcessAll->setVisible(newTool->GetTargetSegmentationNode()->GetData()->GetTimeSteps() > 1);
 }
 
-void QmitkAutoSegmentationToolGUIBase::InitializeUI(QBoxLayout* mainLayout)
+void QmitkAutoSegmentationToolGUIBase::InitializeUI(QBoxLayout* /*mainLayout*/)
 {
+  //default implementation does nothing
 }
 
 void QmitkAutoSegmentationToolGUIBase::BusyStateChanged(bool isBusy)
 {
   if (isBusy)
   {
     QApplication::setOverrideCursor(QCursor(Qt::BusyCursor));
   }
   else
   {
     QApplication::restoreOverrideCursor();
   }
   this->EnableWidgets(!isBusy);
  }
 
 void QmitkAutoSegmentationToolGUIBase::EnableWidgets(bool enabled)
 {
   if (nullptr != m_MainLayout)
   {
     if (nullptr != m_ConfirmSegBtn)
     {
       m_ConfirmSegBtn->setEnabled(m_EnableConfirmSegBtnFnc(enabled));
     }
     if (nullptr != m_CheckProcessAll)
     {
       m_CheckProcessAll->setEnabled(enabled);
     }
     if (nullptr != m_CheckCreateNew)
     {
       m_CheckCreateNew->setEnabled(enabled);
     }
   }
 }