diff --git a/Modules/Segmentation/Interactions/mitkEditableContourTool.cpp b/Modules/Segmentation/Interactions/mitkEditableContourTool.cpp
index 81db18aa4a..bb384c2487 100644
--- a/Modules/Segmentation/Interactions/mitkEditableContourTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkEditableContourTool.cpp
@@ -1,459 +1,459 @@
 /*============================================================================
 
 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 "mitkEditableContourTool.h"
 #include <mitkToolManager.h>
 
 
 mitk::EditableContourTool::EditableContourTool() : FeedbackContourTool("EditableContourTool"), m_AutoConfirm(true), m_AddMode(true)
 {}
 
 mitk::EditableContourTool::~EditableContourTool()
 {
   this->ReleaseHelperObjects();
   this->ReleaseInteractors();
 }
 
 
 void mitk::EditableContourTool::ConnectActionsAndFunctions()
 {
   CONNECT_FUNCTION("InitObject", OnInitContour);
   CONNECT_FUNCTION("AddPoint", OnAddPoint);
   CONNECT_FUNCTION("CtrlAddPoint", OnAddPoint);
   CONNECT_FUNCTION("Drawing", OnDrawing);
   CONNECT_FUNCTION("EndDrawing", OnEndDrawing);
   CONNECT_FUNCTION("FinishContour", OnFinish);
   CONNECT_FUNCTION("CtrlMovePoint", OnMouseMoved);
 }
 
 void mitk::EditableContourTool::Activated()
 {
   Superclass::Activated();
   this->ResetToStartState();
   this->EnableContourInteraction(true);
 }
 
 void mitk::EditableContourTool::Deactivated()
 {
-  this->ClearSegmentation();
+  this->ClearContour();
   Superclass::Deactivated();
 }
 
 void mitk::EditableContourTool::ConfirmSegmentation(bool resetStatMachine)
 {
   auto referenceImage = this->GetReferenceData();
   auto workingImage = this->GetWorkingData();
 
   if (nullptr != referenceImage && nullptr != workingImage)
   {
     std::vector<SliceInformation> sliceInfos;
 
     const auto currentTimePoint =
       mitk::RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint();
     TimeStepType workingImageTimeStep = workingImage->GetTimeGeometry()->TimePointToTimeStep(currentTimePoint);
 
     auto contour = this->GetContour();
     if (nullptr == contour || contour->IsEmpty())
       return;
 
     auto workingSlice =
       this->GetAffectedImageSliceAs2DImage(m_PlaneGeometry, workingImage, workingImageTimeStep)->Clone();
     sliceInfos.emplace_back(workingSlice, m_PlaneGeometry, workingImageTimeStep);
 
     auto projectedContour = ContourModelUtils::ProjectContourTo2DSlice(workingSlice, contour);
     int activePixelValue = ContourModelUtils::GetActivePixelValue(workingImage);
     if (!m_AddMode)
     {
       activePixelValue = 0;
     }
 
     ContourModelUtils::FillContourInSlice(projectedContour, workingSlice, workingImage, activePixelValue);
 
     this->WriteBackSegmentationResults(sliceInfos);
   }
 
   this->ReleaseHelperObjects();
   this->ReleaseInteractors();
   if (resetStatMachine) this->ResetToStartState();
 }
 
-void mitk::EditableContourTool::ClearSegmentation() 
+void mitk::EditableContourTool::ClearContour()
 {
   this->ReleaseHelperObjects();
   this->ReleaseInteractors();
   this->ResetToStartState();
 }
 
 bool mitk::EditableContourTool::IsEditingContour() const
 {
   return (nullptr != GetContour()) && !this->IsDrawingContour();
 };
 
 
 bool mitk::EditableContourTool::IsDrawingContour() const
 {
   return m_PreviewContour.IsNotNull();
 };
 
 mitk::Point3D mitk::EditableContourTool::PrepareInitContour(const Point3D& clickedPoint)
 { //default implementation does nothing
   return clickedPoint;
 }
 
 void mitk::EditableContourTool::OnInitContour(StateMachineAction *, InteractionEvent *interactionEvent)
 {
   auto positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
   if (nullptr == positionEvent)
     return;
 
   auto workingDataNode = this->GetWorkingDataNode();
 
   if (nullptr != this->GetContour())
   {
     this->ConfirmSegmentation(false);
   }
 
   if (!IsPositionEventInsideImageRegion(positionEvent, workingDataNode->GetData()))
   {
     this->ResetToStartState();
     return;
   }
 
   m_LastEventSender = positionEvent->GetSender();
   m_LastEventSlice = m_LastEventSender->GetSlice();
 
   auto contour = this->CreateNewContour();
   m_ContourNode = mitk::DataNode::New();
   m_ContourNode->SetData(contour);
   m_ContourNode->SetName("working contour node");
   m_ContourNode->SetProperty("layer", IntProperty::New(100));
   m_ContourNode->AddProperty("fixedLayer", BoolProperty::New(true));
   m_ContourNode->SetProperty("helper object", mitk::BoolProperty::New(true));
   m_ContourNode->AddProperty("contour.color", ColorProperty::New(1.0f, 1.0f, 0.0f), nullptr, true);
   m_ContourNode->AddProperty("contour.points.color", ColorProperty::New(1.0f, 0.0f, 0.1f), nullptr, true);
   m_ContourNode->AddProperty("contour.controlpoints.show", BoolProperty::New(true), nullptr, true);
 
   m_PreviewContour = this->CreateNewContour();
   m_PreviewContourNode = mitk::DataNode::New();
   m_PreviewContourNode->SetData(m_PreviewContour);
   m_PreviewContourNode->SetName("active preview node");
   m_PreviewContourNode->SetProperty("layer", IntProperty::New(101));
   m_PreviewContourNode->AddProperty("fixedLayer", BoolProperty::New(true));
   m_PreviewContourNode->SetProperty("helper object", mitk::BoolProperty::New(true));
   m_PreviewContourNode->AddProperty("contour.color", ColorProperty::New(0.1f, 1.0f, 0.1f), nullptr, true);
   m_PreviewContourNode->AddProperty("contour.width", mitk::FloatProperty::New(4.0f), nullptr, true);
 
 
   m_ClosureContour = this->CreateNewContour();
   m_ClosureContourNode = mitk::DataNode::New();
   m_ClosureContourNode->SetData(m_ClosureContour);
   m_ClosureContourNode->SetName("active closure node");
   m_ClosureContourNode->SetProperty("layer", IntProperty::New(101));
   m_ClosureContourNode->AddProperty("fixedLayer", BoolProperty::New(true));
   m_ClosureContourNode->SetProperty("helper object", mitk::BoolProperty::New(true));
   m_ClosureContourNode->AddProperty("contour.color", ColorProperty::New(0.0f, 1.0f, 0.1f), nullptr, true);
   m_ClosureContourNode->AddProperty("contour.width", mitk::FloatProperty::New(2.0f), nullptr, true);
 
   m_CurrentRestrictedArea = this->CreateNewContour();
 
   auto dataStorage = this->GetToolManager()->GetDataStorage();
   dataStorage->Add(m_ContourNode, workingDataNode);
   dataStorage->Add(m_PreviewContourNode, workingDataNode);
   dataStorage->Add(m_ClosureContourNode, workingDataNode);
 
   m_ReferenceDataSlice = this->GetAffectedReferenceSlice(positionEvent);
 
   auto origin = m_ReferenceDataSlice->GetSlicedGeometry()->GetOrigin();
   m_ReferenceDataSlice->GetSlicedGeometry()->WorldToIndex(origin, origin);
   m_ReferenceDataSlice->GetSlicedGeometry()->IndexToWorld(origin, origin);
   m_ReferenceDataSlice->GetSlicedGeometry()->SetOrigin(origin);
 
   // Remember PlaneGeometry to determine if events were triggered in the same plane
   m_PlaneGeometry = interactionEvent->GetSender()->GetCurrentWorldPlaneGeometry();
 
   // Map click to pixel coordinates
   auto click = positionEvent->GetPositionInWorld();
 
   click = this->PrepareInitContour(click);
 
   this->InitializePreviewContour(click);
   // Set initial start point
   contour->AddVertex(click, true);
   m_PreviewContour->AddVertex(click, false);
   m_ClosureContour->AddVertex(click);
 
   mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
 }
 
 void mitk::EditableContourTool::FinalizePreviewContour(const Point3D& /*clickedPoint*/)
 { // Remove duplicate first vertex, it's already contained in m_ContourNode
   m_PreviewContour->RemoveVertexAt(0);
 
   m_PreviewContour->SetControlVertexAt(m_PreviewContour->GetNumberOfVertices() - 1);
 }
 
 void mitk::EditableContourTool::InitializePreviewContour(const Point3D& clickedPoint)
 { //default implementation only clears the preview and sets the start point
   m_PreviewContour = this->CreateNewContour();
   m_PreviewContour->AddVertex(clickedPoint);
   m_PreviewContourNode->SetData(m_PreviewContour);
 }
 
 void mitk::EditableContourTool::UpdatePreviewContour(const Point3D& clickedPoint)
 { //default implementation draws just a simple line to position
   if (m_PreviewContour->GetNumberOfVertices() > 2)
   {
     auto contour = this->GetContour();
     this->InitializePreviewContour(contour->GetVertexAt(contour->GetNumberOfVertices() - 1)->Coordinates);
   }
 
   if (m_PreviewContour->GetNumberOfVertices() == 2)
   {
     m_PreviewContour->RemoveVertexAt(m_PreviewContour->GetNumberOfVertices()-1);
   }
 
   m_PreviewContour->AddVertex(clickedPoint);
 }
 
 void mitk::EditableContourTool::OnAddPoint(StateMachineAction*, InteractionEvent* interactionEvent)
 {
   auto positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>(interactionEvent);
 
   if (nullptr == positionEvent)
     return;
 
   if (m_PlaneGeometry.IsNotNull())
   {
     // Check if the point is in the correct slice
     if (m_PlaneGeometry->DistanceFromPlane(positionEvent->GetPositionInWorld()) > mitk::sqrteps)
       return;
   }
 
   this->FinalizePreviewContour(positionEvent->GetPositionInWorld());
 
   // Merge contours
   auto contour = this->GetContour();
   contour->Concatenate(m_PreviewContour);
 
   this->InitializePreviewContour(positionEvent->GetPositionInWorld());
 
   mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
 }
 
 void mitk::EditableContourTool::OnDrawing(StateMachineAction*, InteractionEvent* interactionEvent)
 {
   auto* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>(interactionEvent);
   if (!positionEvent)
     return;
 
   m_PreviewContourNode->SetVisibility(false);
 
   auto contour = this->GetContour();
   contour->AddVertex(positionEvent->GetPositionInWorld(), false);
   UpdateClosureContour(positionEvent->GetPositionInWorld());
 
   assert(positionEvent->GetSender()->GetRenderWindow());
   mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
 }
 
 void mitk::EditableContourTool::OnEndDrawing(StateMachineAction*, InteractionEvent* interactionEvent)
 {
   auto* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>(interactionEvent);
   if (!positionEvent)
     return;
 
   auto contour = this->GetContour();
   auto controlVs = contour->GetControlVertices(0);
   if (!controlVs.empty())
   { //add the last control point (after that the draw part start)
     m_CurrentRestrictedArea->AddVertex(controlVs.back()->Coordinates);
   }
   m_PreviewContourNode->SetVisibility(true);
   contour->SetControlVertexAt(contour->GetNumberOfVertices() - 1);
 
   //add the just created/set last control point (with it the draw part ends)
   m_CurrentRestrictedArea->AddVertex(contour->GetVertexAt(contour->GetNumberOfVertices() - 1)->Coordinates);
 
   this->InitializePreviewContour(positionEvent->GetPositionInWorld());
 
   mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
 }
 
 void mitk::EditableContourTool::OnMouseMoved(StateMachineAction*, InteractionEvent* interactionEvent)
 {
   auto positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>(interactionEvent);
 
   if (nullptr == positionEvent)
     return;
 
   if (m_PlaneGeometry.IsNotNull())
   {
     // Check if the point is in the correct slice
     if (m_PlaneGeometry->DistanceFromPlane(positionEvent->GetPositionInWorld()) > mitk::sqrteps)
       return;
   }
 
   this->UpdatePreviewContour(positionEvent->GetPositionInWorld());
   this->UpdateClosureContour(positionEvent->GetPositionInWorld());
 
   RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
 }
 
 void mitk::EditableContourTool::OnFinish(StateMachineAction *, InteractionEvent *interactionEvent)
 {
   auto positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
 
   if (nullptr == positionEvent)
     return;
 
   if (m_PlaneGeometry.IsNotNull())
   {
     // Check if the point is in the correct slice
     if (m_PlaneGeometry->DistanceFromPlane(positionEvent->GetPositionInWorld()) > mitk::sqrteps)
       return;
   }
 
   this->FinalizePreviewContour(positionEvent->GetPositionInWorld());
 
   this->FinishTool();
 
   // Merge contours
   auto contour = this->GetContour();
   contour->Concatenate(m_PreviewContour);
 
   auto numberOfTimesteps = static_cast<int>(contour->GetTimeSteps());
 
   for (int i = 0; i <= numberOfTimesteps; ++i)
     contour->Close(i);
 
   this->ReleaseHelperObjects(false);
 
   if (m_AutoConfirm)
   {
     this->ConfirmSegmentation();
   }
 }
 
 void mitk::EditableContourTool::ReleaseHelperObjects(bool includeWorkingContour)
 {
   this->RemoveHelperObjectsFromDataStorage(includeWorkingContour);
 
   if (includeWorkingContour)
   {
     m_ContourNode = nullptr;
     m_CurrentRestrictedArea = nullptr;
   }
 
   m_PreviewContourNode = nullptr;
   m_PreviewContour = nullptr;
 
   m_ClosureContourNode = nullptr;
   m_ClosureContour = nullptr;
 }
 
 void mitk::EditableContourTool::RemoveHelperObjectsFromDataStorage(bool includeWorkingContour)
 {
   auto dataStorage = this->GetToolManager()->GetDataStorage();
 
   if (nullptr == dataStorage)
     return;
 
   if (includeWorkingContour)
   {
     if (m_ContourNode.IsNotNull())
       dataStorage->Remove(m_ContourNode);
   }
 
   if (m_PreviewContourNode.IsNotNull())
     dataStorage->Remove(m_PreviewContourNode);
 
   if (m_ClosureContourNode.IsNotNull())
     dataStorage->Remove(m_ClosureContourNode);
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 mitk::ContourModel::Pointer mitk::EditableContourTool::CreateNewContour() const
 {
   auto workingData = this->GetWorkingData();
   if (nullptr == workingData)
   {
     this->InteractiveSegmentationBugMessage(
       "Cannot create new contour. No valid working data is set. Application is in invalid state.");
     mitkThrow() << "Cannot create new contour. No valid working data is set. Application is in invalid state.";
   }
 
   auto contour = ContourModel::New();
 
   // generate a time geometry that is always visible as the working contour should always be.
   auto contourTimeGeometry = ProportionalTimeGeometry::New();
   contourTimeGeometry->SetStepDuration(std::numeric_limits<TimePointType>::max());
   contourTimeGeometry->SetTimeStepGeometry(contour->GetTimeGeometry()->GetGeometryForTimeStep(0)->Clone(), 0);
   contour->SetTimeGeometry(contourTimeGeometry);
 
   return contour;
 }
 
 void mitk::EditableContourTool::UpdateClosureContour(mitk::Point3D endpoint) 
 {
   if (m_ClosureContour->GetNumberOfVertices() > 2)
   {
     m_ClosureContour = this->CreateNewContour();
     m_ClosureContourNode->SetData(m_ClosureContour);
   }
 
   if (m_ClosureContour->GetNumberOfVertices() == 0)
   {
     auto contour = this->GetContour();
     m_ClosureContour->AddVertex(contour->GetVertexAt(0)->Coordinates);
     m_ClosureContour->Update();
   }
 
   if (m_ClosureContour->GetNumberOfVertices() == 2)
   {
     m_ClosureContour->RemoveVertexAt(0);
   }
 
   m_ClosureContour->AddVertexAtFront(endpoint);
 }
 
 void mitk::EditableContourTool::EnableContourInteraction(bool on)
 {
   if (m_ContourInteractor.IsNotNull())
   {
     m_ContourInteractor->EnableInteraction(on);
   }
 }
 
 void mitk::EditableContourTool::ReleaseInteractors()
 {
   this->EnableContourInteraction(false);
   m_ContourInteractor = nullptr;
 }
 
 mitk::ContourModel* mitk::EditableContourTool::GetContour()
 {
   if (this->m_ContourNode.IsNotNull())
   {
     return dynamic_cast<ContourModel*>(this->m_ContourNode->GetData());
   }
   return nullptr;
 };
 
 const mitk::ContourModel* mitk::EditableContourTool::GetContour() const
 {
   if (this->m_ContourNode.IsNotNull())
   {
     return dynamic_cast<const ContourModel*>(this->m_ContourNode->GetData());
   }
   return nullptr;
 };
\ No newline at end of file
diff --git a/Modules/Segmentation/Interactions/mitkEditableContourTool.h b/Modules/Segmentation/Interactions/mitkEditableContourTool.h
index 1189e3b406..2ac29f4219 100644
--- a/Modules/Segmentation/Interactions/mitkEditableContourTool.h
+++ b/Modules/Segmentation/Interactions/mitkEditableContourTool.h
@@ -1,125 +1,125 @@
 /*============================================================================
 
 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 mitkEditbaleContourTool_h_Included
 #define mitkEditbaleContourTool_h_Included
 
 #include <mitkFeedbackContourTool.h>
 
 namespace mitk
 {
   /**
   * Base class for lasso like tools that allow to draw closed contours with multiple ancor points.
   * The segments between the ancor points may be freehand contour segments or computed segments
   * (e.g. straight lines or live wire). Derive from the class to implement the computation of the non-freehand
   * segments.
   * @sa LassoTool LivewWireTool2D
   */
   class MITKSEGMENTATION_EXPORT EditableContourTool : public FeedbackContourTool
   {
   public:
     mitkClassMacro(EditableContourTool, FeedbackContourTool);
 
     /// \brief Convert current contour to binary segmentations.
     virtual void ConfirmSegmentation(bool resetStatMachine = true);
 
     /// \brief Delete all current contours.
-    virtual void ClearSegmentation();
+    virtual void ClearContour();
 
     itkBooleanMacro(AutoConfirm);
     itkSetMacro(AutoConfirm, bool);
     itkGetMacro(AutoConfirm, bool);
 
     itkBooleanMacro(AddMode);
     itkSetMacro(AddMode, bool);
     itkGetMacro(AddMode, bool);
 
-    /* Indicated if a contour is drawn, but not confirmed yet. This the tool is in interactor mode
+    /* Indicated if a contour is drawn, but not confirmed yet. This tool is in interactor mode
      to allow users to edit the contour. This state can be reached if AutoConfirm is false, after the finalizing double
      click before the contour is confirmed.*/
     bool IsEditingContour() const;
     /* Indicate if a contour is currently drawn by the user (state between the initializing double click and
      the finalizing double click).*/
     bool IsDrawingContour() const;
 
   protected:
     EditableContourTool();
     ~EditableContourTool() override;
 
     void ConnectActionsAndFunctions() override;
 
     void Activated() override;
     void Deactivated() override;
    
     virtual Point3D PrepareInitContour(const Point3D& clickedPoint);
     virtual void FinalizePreviewContour(const Point3D& clickedPoint);
     virtual void InitializePreviewContour(const Point3D& clickedPoint);
     virtual void UpdatePreviewContour(const Point3D& clickedPoint);
 
     /// \brief Initialize tool.
     virtual void OnInitContour(StateMachineAction *, InteractionEvent *interactionEvent);
 
     /// \brief Add a control point and finish current segment.
     virtual void OnAddPoint(StateMachineAction *, InteractionEvent *interactionEvent);
 
     /// \brief Draw a contour according to the mouse movement when mouse button is pressed and mouse is moved.
     virtual void OnDrawing(StateMachineAction *, InteractionEvent *interactionEvent);
 
     virtual void OnEndDrawing(StateMachineAction *, InteractionEvent *interactionEvent);
 
     /// \brief Computation of the preview contour.
     virtual void OnMouseMoved(StateMachineAction *, InteractionEvent *interactionEvent);
 
     /// \brief Finish EditableContour tool.
     virtual void OnFinish(StateMachineAction *, InteractionEvent *interactionEvent);
 
     /// \brief Finish contour interaction.
     virtual void FinishTool() = 0;
 
     void EnableContourInteraction(bool on);
 
     void ReleaseInteractors();
 
     virtual void ReleaseHelperObjects(bool includeWorkingContour = true);
 
     virtual void RemoveHelperObjectsFromDataStorage(bool includeWorkingContour = true);
 
     ContourModel::Pointer CreateNewContour() const;
 
     virtual void UpdateClosureContour(mitk::Point3D endpoint);
 
     mitk::ContourModel* GetContour();
     const mitk::ContourModel* GetContour() const;
     mitk::DataNode::Pointer m_ContourNode;
 
     mitk::ContourModel::Pointer m_PreviewContour;
     mitk::DataNode::Pointer m_PreviewContourNode;
 
     mitk::ContourModel::Pointer m_ClosureContour;
     mitk::DataNode::Pointer m_ClosureContourNode;
 
     mitk::ContourModel::Pointer m_CurrentRestrictedArea;
 
     /** Slice of the reference data the tool is currently actively working on to
     define contours.*/
     mitk::Image::Pointer m_ReferenceDataSlice;
 
     PlaneGeometry::ConstPointer m_PlaneGeometry;
 
     mitk::DataInteractor::Pointer m_ContourInteractor;
 
     bool m_AutoConfirm;
     bool m_AddMode;
   };
 }
 
 #endif
diff --git a/Modules/SegmentationUI/Qmitk/QmitkEditableContourToolGUIBase.cpp b/Modules/SegmentationUI/Qmitk/QmitkEditableContourToolGUIBase.cpp
index d982301617..15cb4647b8 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkEditableContourToolGUIBase.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitkEditableContourToolGUIBase.cpp
@@ -1,100 +1,100 @@
 /*============================================================================
 
 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 "QmitkEditableContourToolGUIBase.h"
 
 QmitkEditableContourToolGUIBase::QmitkEditableContourToolGUIBase() : QmitkToolGUI()
 {
   m_Controls.setupUi(this);
   m_Controls.m_Information->hide();
   m_Controls.m_AutoCheck->setChecked(true);
   m_Controls.m_ConfirmButton->hide();
   m_Controls.m_AddMode->setChecked(true);
   m_Controls.m_SubtractMode->hide();
   m_Controls.m_AddMode->hide();
 
   m_Controls.m_ClearButton->hide();
 
   connect(m_Controls.m_ConfirmButton, SIGNAL(clicked()), this, SLOT(OnConfirmSegmentation()));
-  connect(m_Controls.m_ClearButton, SIGNAL(clicked()), this, SLOT(OnClearSegmentation()));
+  connect(m_Controls.m_ClearButton, SIGNAL(clicked()), this, SLOT(OnClearContour()));
   connect(this, SIGNAL(NewToolAssociated(mitk::Tool *)), this, SLOT(OnNewToolAssociated(mitk::Tool *)));
   connect(m_Controls.m_InformationCheckBox, SIGNAL(toggled(bool)), this, SLOT(OnShowInformation(bool)));
   connect(m_Controls.m_AutoCheck, SIGNAL(toggled(bool)), this, SLOT(OnAutoConfirm(bool)));
   connect(m_Controls.m_AddMode, SIGNAL(toggled(bool)), this, SLOT(OnAddModeToogled(bool)));
 }
 
 QmitkEditableContourToolGUIBase::~QmitkEditableContourToolGUIBase()
 {
 }
 
 void QmitkEditableContourToolGUIBase::OnNewToolAssociated(mitk::Tool *tool)
 {
   m_NewTool = dynamic_cast<mitk::EditableContourTool *>(tool);
   if (m_NewTool.IsNull())
   {
     mitkThrow() << "Tool is in an invalid state. QmitkEditableContourToolGUIBase needs tools based on EditableContourTool.";
   }
 
   const auto autoConfirm = m_NewTool->GetAutoConfirm();
   m_Controls.m_AutoCheck->setChecked(autoConfirm);
   const auto addMode = m_NewTool->GetAddMode();
   m_Controls.m_AddMode->setChecked(addMode);
   this->OnAutoConfirm(autoConfirm);
 }
 
 void QmitkEditableContourToolGUIBase::OnConfirmSegmentation()
 {
   if (m_NewTool.IsNotNull())
   {
     m_NewTool->ConfirmSegmentation();
   }
 }
 
-void QmitkEditableContourToolGUIBase::OnClearSegmentation()
+void QmitkEditableContourToolGUIBase::OnClearContour()
 {
   if (m_NewTool.IsNotNull())
-    m_NewTool->ClearSegmentation();
+    m_NewTool->ClearContour();
 }
 
 void QmitkEditableContourToolGUIBase::OnShowInformation(bool on)
 {
   m_Controls.m_Information->setVisible(on);
 }
 
 void QmitkEditableContourToolGUIBase::OnAutoConfirm(bool on)
 {
   m_Controls.m_ConfirmButton->setVisible(!on);
   m_Controls.m_ClearButton->setVisible(!on);
   m_Controls.m_AddMode->setVisible(!on);
   if (on)
   {
     m_Controls.m_AddMode->setChecked(true);
   }
   m_Controls.m_SubtractMode->setVisible(!on);
 
   if (m_NewTool.IsNotNull())
   {
     if (on && m_NewTool->IsEditingContour())
     {
       this->OnConfirmSegmentation();
     }
     m_NewTool->SetAutoConfirm(on);
   }
 }
 
 void QmitkEditableContourToolGUIBase::OnAddModeToogled(bool on)
 {
   if (m_NewTool.IsNotNull())
   {
     m_NewTool->SetAddMode(on);
   }
 }
diff --git a/Modules/SegmentationUI/Qmitk/QmitkEditableContourToolGUIBase.h b/Modules/SegmentationUI/Qmitk/QmitkEditableContourToolGUIBase.h
index 8343107799..3b7640ba99 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkEditableContourToolGUIBase.h
+++ b/Modules/SegmentationUI/Qmitk/QmitkEditableContourToolGUIBase.h
@@ -1,59 +1,59 @@
 /*============================================================================
 
 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 QmitkEditableContourToolGUIBase_h_Included
 #define QmitkEditableContourToolGUIBase_h_Included
 
 #include "QmitkToolGUI.h"
 #include "mitkEditableContourTool.h"
 #include "ui_QmitkEditableContourToolGUIControls.h"
 #include <MitkSegmentationUIExports.h>
 
 class QmitkEditableContourToolGUIBaseControls;
 
 /**
 \ingroup org_mitk_gui_qt_interactivesegmentation_internal
 \brief GUI for mitk::EditableContourTool based classes.
 \sa mitk::LassoTool
 */
 class MITKSEGMENTATIONUI_EXPORT QmitkEditableContourToolGUIBase : public QmitkToolGUI
 {
   Q_OBJECT
 
 public:
   mitkClassMacro(QmitkEditableContourToolGUIBase, QmitkToolGUI);
   itkFactorylessNewMacro(Self);
   itkCloneMacro(Self);
 
 protected slots :
 
   void OnNewToolAssociated(mitk::Tool *);
 
   void OnConfirmSegmentation();
 
-  void OnClearSegmentation();
+  void OnClearContour();
 
   void OnAutoConfirm(bool on);
   void OnAddModeToogled(bool on);
 
   void OnShowInformation(bool on);
 
 protected:
   QmitkEditableContourToolGUIBase();
   ~QmitkEditableContourToolGUIBase() override;
 
   Ui::QmitkEditableContourToolGUIControls m_Controls;
 
   mitk::EditableContourTool::Pointer m_NewTool;
 };
 
 #endif
diff --git a/Modules/SegmentationUI/Qmitk/QmitkEditableContourToolGUIControls.ui b/Modules/SegmentationUI/Qmitk/QmitkEditableContourToolGUIControls.ui
index 7c1663d66f..2811de9dd2 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkEditableContourToolGUIControls.ui
+++ b/Modules/SegmentationUI/Qmitk/QmitkEditableContourToolGUIControls.ui
@@ -1,159 +1,156 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkEditableContourToolGUIControls</class>
  <widget class="QWidget" name="QmitkEditableContourToolGUIControls">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>421</width>
     <height>429</height>
    </rect>
   </property>
   <property name="sizePolicy">
    <sizepolicy hsizetype="Ignored" vsizetype="Minimum">
     <horstretch>0</horstretch>
     <verstretch>0</verstretch>
    </sizepolicy>
   </property>
   <property name="minimumSize">
    <size>
     <width>0</width>
     <height>0</height>
    </size>
   </property>
   <property name="windowTitle">
-   <string>QmitkLiveWireTool2DGUIControls</string>
-  </property>
-  <property name="toolTip">
-   <string>Confirm all previous contour.</string>
+   <string>QmitkEditableContourToolGUIControls</string>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout">
    <property name="leftMargin">
     <number>0</number>
    </property>
    <property name="topMargin">
     <number>0</number>
    </property>
    <property name="rightMargin">
     <number>0</number>
    </property>
    <property name="bottomMargin">
     <number>0</number>
    </property>
    <item>
     <layout class="QVBoxLayout" name="verticalLayout_2">
      <item>
       <widget class="QCheckBox" name="m_AutoCheck">
        <property name="text">
         <string>Auto confirm contour</string>
        </property>
        <property name="checked">
         <bool>true</bool>
        </property>
       </widget>
      </item>
      <item>
       <widget class="QRadioButton" name="m_AddMode">
        <property name="toolTip">
         <string>The contour will be added as segmentation for the active label.</string>
        </property>
        <property name="text">
         <string>Add mode</string>
        </property>
        <property name="checked">
         <bool>true</bool>
        </property>
       </widget>
      </item>
      <item>
       <widget class="QRadioButton" name="m_SubtractMode">
        <property name="toolTip">
         <string>If confirmed the contour will be added as background, thus it will be subtracted from the active label.</string>
        </property>
        <property name="text">
         <string>Subtract mode</string>
        </property>
       </widget>
      </item>
      <item>
       <widget class="QPushButton" name="m_ConfirmButton">
        <property name="text">
         <string>Confirm Segmentation</string>
        </property>
       </widget>
      </item>
      <item>
       <widget class="QPushButton" name="m_ClearButton">
        <property name="text">
-        <string>Clear Segmentation</string>
+        <string>Clear Contour</string>
        </property>
       </widget>
      </item>
      <item>
       <spacer name="verticalSpacer_2">
        <property name="orientation">
         <enum>Qt::Vertical</enum>
        </property>
        <property name="sizeType">
         <enum>QSizePolicy::Fixed</enum>
        </property>
        <property name="sizeHint" stdset="0">
         <size>
          <width>20</width>
          <height>15</height>
         </size>
        </property>
       </spacer>
      </item>
      <item>
       <widget class="QCheckBox" name="m_InformationCheckBox">
        <property name="text">
         <string>Show usage information</string>
        </property>
       </widget>
      </item>
      <item>
       <widget class="QWidget" name="m_Information" native="true">
        <property name="minimumSize">
         <size>
          <width>0</width>
          <height>150</height>
         </size>
        </property>
        <layout class="QHBoxLayout" name="horizontalLayout">
         <item>
          <widget class="QTextBrowser" name="textBrowser">
           <property name="font">
            <font>
             <pointsize>12</pointsize>
            </font>
           </property>
           <property name="html">
            <string>&lt;!DOCTYPE HTML PUBLIC &quot;-//W3C//DTD HTML 4.0//EN&quot; &quot;http://www.w3.org/TR/REC-html40/strict.dtd&quot;&gt;
 &lt;html&gt;&lt;head&gt;&lt;meta name=&quot;qrichtext&quot; content=&quot;1&quot; /&gt;&lt;style type=&quot;text/css&quot;&gt;
 p, li { white-space: pre-wrap; }
 &lt;/style&gt;&lt;/head&gt;&lt;body style=&quot; font-family:'MS Shell Dlg 2'; font-size:12pt; font-weight:400; font-style:normal;&quot;&gt;
 &lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;span style=&quot; font-family:'Sans'; font-size:10pt;&quot;&gt;The tool is started by a double-click near the object of interest.&lt;/span&gt;&lt;/p&gt;
 &lt;p style=&quot;-qt-paragraph-type:empty; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px; font-family:'Sans'; font-size:10pt;&quot;&gt;&lt;br /&gt;&lt;/p&gt;
 &lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;span style=&quot; font-family:'Sans'; font-size:10pt;&quot;&gt;You can fix preview segments by adding ancor points with a single left mouse button click. When you keep the mouse button pressed, you can manually draw contours (freehand contours) by moving the mouse. To close a contour and finish current segmentation perform a double click.&lt;/span&gt;&lt;/p&gt;
 &lt;p style=&quot;-qt-paragraph-type:empty; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px; font-family:'Sans'; font-size:10pt;&quot;&gt;&lt;br /&gt;&lt;/p&gt;
-&lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;span style=&quot; font-family:'Sans'; font-size:10pt;&quot;&gt;If &amp;quot;Auto confirm&amp;quot; is active and the segmentation is finished, the preview will be directly added as segmentation. From there you are free to start a new contour (double click).&lt;/span&gt;&lt;/p&gt;
+&lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;span style=&quot; font-family:'Sans'; font-size:10pt;&quot;&gt;If &amp;quot;Auto confirm&amp;quot; is active and the contour is finished, the preview will be directly added as segmentation. From there you are free to start a new contour (double click).&lt;/span&gt;&lt;/p&gt;
 &lt;p style=&quot;-qt-paragraph-type:empty; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px; font-family:'Sans'; font-size:10pt;&quot;&gt;&lt;br /&gt;&lt;/p&gt;
 &lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;span style=&quot; font-family:'Sans'; font-size:10pt;&quot;&gt;If &amp;quot;Auto confirm&amp;quot; is not active, the contour will be still editable after finishing the segmentation. You can move, insert (CTRL+click on the contour segment) and delete (press DEL while ancor is selected) its ancor points. To confirm the segmentation, push the &amp;quot;Confirm Segmentation&amp;quot; button. Please be aware that freehand contour parts are treated differently: You cannot add an ancor point there, also you are not allowed to select/move/delete an ancor point that is at the beginning or end of a freehand contour part. &lt;/span&gt;&lt;/p&gt;
 &lt;p style=&quot;-qt-paragraph-type:empty; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px; font-family:'Sans'; font-size:10pt;&quot;&gt;&lt;br /&gt;&lt;/p&gt;
 &lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;span style=&quot; font-family:'Sans'; font-size:10pt;&quot;&gt;Push the &amp;quot;Clear Segmentation&amp;quot; button to delete all unconfirmed contours.&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
           </property>
          </widget>
         </item>
        </layout>
       </widget>
      </item>
     </layout>
    </item>
   </layout>
  </widget>
  <layoutdefault spacing="6" margin="11"/>
  <resources/>
  <connections/>
 </ui>