diff --git a/Modules/Core/test/mitkPointSetTest.cpp b/Modules/Core/test/mitkPointSetTest.cpp
index 5293985da0..ac84bb6389 100644
--- a/Modules/Core/test/mitkPointSetTest.cpp
+++ b/Modules/Core/test/mitkPointSetTest.cpp
@@ -1,488 +1,488 @@
 /*============================================================================
 
 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 "mitkTestFixture.h"
 #include "mitkTestingMacros.h"
 
 #include <mitkInteractionConst.h>
 #include <mitkNumericTypes.h>
 #include <mitkPointOperation.h>
 #include <mitkPointSet.h>
 
 #include <fstream>
 
 /**
  * TestSuite for PointSet stuff not only operating on an empty PointSet
  */
 class mitkPointSetTestSuite : public mitk::TestFixture
 {
   CPPUNIT_TEST_SUITE(mitkPointSetTestSuite);
 
   MITK_TEST(TestIsNotEmpty);
   MITK_TEST(TestSetSelectInfo);
   MITK_TEST(TestGetNumberOfSelected);
   MITK_TEST(TestSearchSelectedPoint);
   MITK_TEST(TestGetPointIfExists);
   MITK_TEST(TestSwapPointPositionUpwards);
   MITK_TEST(TestSwapPointPositionUpwardsNotPossible);
   MITK_TEST(TestSwapPointPositionDownwards);
   MITK_TEST(TestSwapPointPositionDownwardsNotPossible);
   MITK_TEST(TestCreateHoleInThePointIDs);
   MITK_TEST(TestInsertPointWithPointSpecification);
   MITK_TEST(TestRemovePointInterface);
   MITK_TEST(TestMaxIdAccess);
   MITK_TEST(TestInsertPointAtEnd);
 
   CPPUNIT_TEST_SUITE_END();
 
 private:
   mitk::PointSet::Pointer pointSet;
   static const mitk::PointSet::PointIdentifier selectedPointId = 2;
 
 public:
   void setUp() override
   {
     // Create PointSet
     pointSet = mitk::PointSet::New();
 
     // add some points
     mitk::Point3D point2, point3, point4;
     point2.Fill(3);
     point3.Fill(4);
     point4.Fill(5);
     pointSet->InsertPoint(2, point2);
     pointSet->InsertPoint(3, point3);
     pointSet->InsertPoint(4, point4);
 
     mitk::Point3D point1;
     mitk::FillVector3D(point1, 1.0, 2.0, 3.0);
     pointSet->InsertPoint(1, point1);
 
     mitk::Point3D point0;
     point0.Fill(1);
     pointSet->InsertPoint(0, point0);
 
     // select point with id 2
     pointSet->SetSelectInfo(2, true);
   }
 
   void tearDown() override { pointSet = nullptr; }
   void TestIsNotEmpty()
   {
     // PointSet can not be empty!
     CPPUNIT_ASSERT_EQUAL_MESSAGE("check if the PointSet is not empty ", true, !pointSet->IsEmptyTimeStep(0));
 
     /*
 std::cout << "check if the PointSet is not empty ";
 if (pointSet->IsEmpty(0))
 {
 std::cout<<"[FAILED]"<<std::endl;
 return EXIT_FAILURE;
 }
 std::cout<<"[PASSED]"<<std::endl;
      */
   }
 
   void TestSetSelectInfo()
   {
     // check SetSelectInfo
     pointSet->SetSelectInfo(4, true);
 
     CPPUNIT_ASSERT_EQUAL_MESSAGE("check SetSelectInfo", true, pointSet->GetSelectInfo(4));
     /*
       if (!pointSet->GetSelectInfo(2))
       {
       std::cout<<"[FAILED]"<<std::endl;
       return EXIT_FAILURE;
       }
       delete doOp;
       std::cout<<"[PASSED]"<<std::endl;
      */
   }
 
   void TestSearchSelectedPoint()
   {
     // check SearchSelectedPoint
     CPPUNIT_ASSERT_EQUAL_MESSAGE(
       "check SearchSelectedPoint ", true, pointSet->SearchSelectedPoint() == (int)selectedPointId);
 
     /*
 if( pointSet->SearchSelectedPoint() != 4)
 {
 std::cout<<"[FAILED]"<<std::endl;
 return EXIT_FAILURE;
 }
 std::cout<<"[PASSED]"<<std::endl;
      */
   }
 
   void TestGetNumberOfSelected()
   {
     // check GetNumeberOfSelected
     CPPUNIT_ASSERT_EQUAL_MESSAGE("check GetNumeberOfSelected ", true, pointSet->GetNumberOfSelected() == 1);
 
     /*
 if(pointSet->GetNumberOfSelected() != 1)
 {
 std::cout<<"[FAILED]"<<std::endl;
 return EXIT_FAILURE;
 }
 std::cout<<"[PASSED]"<<std::endl;
      */
   }
 
   void TestGetPointIfExists()
   {
     // check GetPointIfExists
     mitk::Point3D point4;
     mitk::Point3D tempPoint;
     point4.Fill(5);
     mitk::PointSet::PointType tmpPoint;
 
     pointSet->GetPointIfExists(4, &tmpPoint);
 
     CPPUNIT_ASSERT_EQUAL_MESSAGE("check GetPointIfExists: ", true, tmpPoint == point4);
     /*
       if (tmpPoint != point5)
       {
       std::cout<<"[FAILED]"<<std::endl;
       return EXIT_FAILURE;
       }
       std::cout<<"[PASSED]"<<std::endl;
      */
   }
 
   void TestSwapPointPositionUpwards()
   {
     // Check SwapPointPosition upwards
     mitk::Point3D point;
     mitk::Point3D tempPoint;
     point = pointSet->GetPoint(1);
     pointSet->SwapPointPosition(1, true);
     tempPoint = pointSet->GetPoint(0);
 
     CPPUNIT_ASSERT_EQUAL_MESSAGE("check SwapPointPosition upwards", true, point == tempPoint);
 
     /*
       if(point != tempPoint)
       {
       std::cout<<"[FAILED]"<<std::endl;
       return EXIT_FAILURE;
       }
       std::cout<<"[PASSED]"<<std::endl;
      */
   }
 
   void TestSwapPointPositionUpwardsNotPossible()
   {
     // Check SwapPointPosition upwards not possible
     CPPUNIT_ASSERT_EQUAL_MESSAGE(
       "check SwapPointPosition upwards not possible", false, pointSet->SwapPointPosition(0, true));
 
     /*
 if(pointSet->SwapPointPosition(0, true))
 {
 std::cout<<"[FAILED]"<<std::endl;
 return EXIT_FAILURE;
 }
 std::cout<<"[PASSED]"<<std::endl;
      */
   }
 
   void TestSwapPointPositionDownwards()
   {
     // Check SwapPointPosition downwards
     mitk::Point3D point;
     mitk::Point3D tempPoint;
     point = pointSet->GetPoint(0);
     pointSet->SwapPointPosition(0, false);
     tempPoint = pointSet->GetPoint(1);
 
     CPPUNIT_ASSERT_EQUAL_MESSAGE("check SwapPointPosition down", true, point == tempPoint);
 
     /*
 if(point != tempPoint)
 {
 std::cout<<"[FAILED]"<<std::endl;
 return EXIT_FAILURE;
 }
 std::cout<<"[PASSED]"<<std::endl;
      */
   }
 
   void TestSwapPointPositionDownwardsNotPossible()
   {
     mitk::PointSet::Pointer pointSet2 = mitk::PointSet::New();
 
     int id = 0;
     mitk::Point3D point;
     point.Fill(1);
     pointSet2->SetPoint(id, point);
 
     // Check SwapPointPosition downwards not possible
     CPPUNIT_ASSERT_EQUAL_MESSAGE(
       "check SwapPointPosition downwards not possible", false, pointSet2->SwapPointPosition(id, false));
 
     /*
 if(pointSet->SwapPointPosition(1, false))
 {
 std::cout<<"[FAILED]"<<std::endl;
 return EXIT_FAILURE;
 }
 std::cout<<"[PASSED]"<<std::endl;
      */
   }
 
   void TestCreateHoleInThePointIDs()
   {
     // create a hole in the point IDs
     mitk::Point3D point(0.);
     mitk::PointSet::PointType p10, p11, p12;
     p10.Fill(10.0);
     p11.Fill(11.0);
     p12.Fill(12.0);
     pointSet->InsertPoint(10, p10);
     pointSet->InsertPoint(11, p11);
     pointSet->InsertPoint(12, p12);
 
     CPPUNIT_ASSERT_EQUAL_MESSAGE("add points with id 10, 11, 12: ",
                                  true,
                                  (pointSet->IndexExists(10) == true) || (pointSet->IndexExists(11) == true) ||
                                    (pointSet->IndexExists(12) == true));
 
     // check OpREMOVE  ExecuteOperation
     int id = 11;
     auto doOp = new mitk::PointOperation(mitk::OpREMOVE, point, id);
     pointSet->ExecuteOperation(doOp);
 
     CPPUNIT_ASSERT_EQUAL_MESSAGE("remove point id 11: ", false, pointSet->IndexExists(id));
 
     /*
       if(pointSet->IndexExists(id))
       {
       std::cout<<"[FAILED]"<<std::endl;
       return EXIT_FAILURE;
       }
       delete doOp;
       std::cout<<"[PASSED]"<<std::endl;
      */
 
     // mitk::PointOperation* doOp = new mitk::PointOperation(mitk::OpMOVEPOINTUP, p12, 12);
     // pointSet->ExecuteOperation(doOp);
     delete doOp;
 
     // check OpMOVEPOINTUP  ExecuteOperation
     doOp = new mitk::PointOperation(mitk::OpMOVEPOINTUP, p12, 12);
     pointSet->ExecuteOperation(doOp);
     delete doOp;
 
     mitk::PointSet::PointType newP10 = pointSet->GetPoint(10);
     mitk::PointSet::PointType newP12 = pointSet->GetPoint(12);
 
     CPPUNIT_ASSERT_EQUAL_MESSAGE(
       "check PointOperation OpMOVEPOINTUP for point id 12:", true, ((newP10 == p12) && (newP12 == p10)));
 
     // check OpMOVEPOINTDOWN  ExecuteOperation
     doOp = new mitk::PointOperation(mitk::OpMOVEPOINTDOWN, p10, 10);
     pointSet->ExecuteOperation(doOp);
     delete doOp;
     newP10 = pointSet->GetPoint(10);
     newP12 = pointSet->GetPoint(12);
 
     CPPUNIT_ASSERT_EQUAL_MESSAGE(
       "check PointOperation OpMOVEPOINTDOWN for point id 10: ", true, ((newP10 == p10) && (newP12 == p12)));
   }
 
   void TestInsertPointWithPointSpecification()
   {
     // check InsertPoint with PointSpecification
     mitk::Point3D point5;
     mitk::Point3D tempPoint;
     point5.Fill(7);
 
     pointSet->SetPoint(5, point5, mitk::PTEDGE);
     tempPoint = pointSet->GetPoint(5);
 
     CPPUNIT_ASSERT_EQUAL_MESSAGE("check InsertPoint with PointSpecification", true, tempPoint == point5);
     /*
       if (tempPoint != point5)
       {
       std::cout<<"[FAILED]"<<std::endl;
       return EXIT_FAILURE;
       }
       std::cout<<"[PASSED]"<<std::endl;
      */
   }
 
   void TestRemovePointInterface()
   {
     mitk::PointSet::Pointer psClone = pointSet->Clone();
     mitk::PointSet::Pointer refPsLastRemoved = mitk::PointSet::New();
     mitk::Point3D point0, point1, point2, point3, point4;
     point0.Fill(1);
     refPsLastRemoved->InsertPoint(0, point0);
     mitk::FillVector3D(point1, 1.0, 2.0, 3.0);
     refPsLastRemoved->InsertPoint(1, point1);
     point2.Fill(3);
     point3.Fill(4);
     refPsLastRemoved->InsertPoint(2, point2);
     refPsLastRemoved->InsertPoint(3, point3);
 
     mitk::PointSet::Pointer refPsMiddleRemoved = mitk::PointSet::New();
     refPsMiddleRemoved->InsertPoint(0, point0);
     refPsMiddleRemoved->InsertPoint(1, point1);
     refPsMiddleRemoved->InsertPoint(3, point3);
 
     // remove non-existent point
     bool removed = pointSet->RemovePointIfExists(5, 0);
     CPPUNIT_ASSERT_EQUAL_MESSAGE("Remove non-existent point", false, removed);
     MITK_ASSERT_EQUAL(pointSet, psClone, "No changes made");
 
     // remove point from non-existent time-step
     removed = pointSet->RemovePointIfExists(1, 1);
     CPPUNIT_ASSERT_EQUAL_MESSAGE("Remove non-existent point", false, removed);
     MITK_ASSERT_EQUAL(pointSet, psClone, "No changes made");
 
     // remove max id from non-existent time-step
     mitk::PointSet::PointsIterator maxIt = pointSet->RemovePointAtEnd(2);
     CPPUNIT_ASSERT_EQUAL_MESSAGE("Remove max id point from non-existent time step", true, maxIt == pointSet->End(2));
     MITK_ASSERT_EQUAL(pointSet, psClone, "No changes made");
 
     // remove max id from empty point set
     mitk::PointSet::Pointer emptyPS = mitk::PointSet::New();
     maxIt = emptyPS->RemovePointAtEnd(0);
     CPPUNIT_ASSERT_EQUAL_MESSAGE("Remove max id point from non-existent time step", true, maxIt == emptyPS->End(0));
     CPPUNIT_ASSERT_EQUAL_MESSAGE("Nothing removed", true, emptyPS->GetSize(0) == 0 && emptyPS->GetPointSetSeriesSize() == 1);
 
     // remove max id from a point set with one point
     mitk::PointSet::Pointer onePS = mitk::PointSet::New();
     onePS->InsertPoint(0, point0);
     maxIt = onePS->RemovePointAtEnd(0);
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Remove of last point let to invalid state of point set", true, maxIt == onePS->End(0));
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Removal of last point let to invalid state of point set", true, maxIt == onePS->End(0));
     CPPUNIT_ASSERT_EQUAL_MESSAGE("Nothing removed", true, onePS->GetSize(0) == 0 && onePS->GetPointSetSeriesSize() == 1);
 
     // remove max id point
     maxIt = pointSet->RemovePointAtEnd(0);
     CPPUNIT_ASSERT_EQUAL_MESSAGE("Point id 4 removed", false, pointSet->IndexExists(4));
     MITK_ASSERT_EQUAL(pointSet, refPsLastRemoved, "No changes made");
 
     mitk::PointSet::PointIdentifier id = maxIt.Index();
     mitk::PointSet::PointType refPt;
     refPt[0] = 4.0;
     refPt[1] = 4.0;
     refPt[2] = 4.0;
     mitk::PointSet::PointType pt = maxIt.Value();
     bool equal = mitk::Equal(refPt, pt);
     CPPUNIT_ASSERT_EQUAL_MESSAGE("Returned iterator pointing at max id", true, id == 3 && equal);
 
     // remove middle point
     removed = pointSet->RemovePointIfExists(2, 0);
     CPPUNIT_ASSERT_EQUAL_MESSAGE("Remove point id 2", true, removed);
     MITK_ASSERT_EQUAL(pointSet, refPsMiddleRemoved, "Point removed");
   }
 
   void TestMaxIdAccess()
   {
     typedef mitk::PointSet::PointIdentifier IdType;
     typedef mitk::PointSet::PointsIterator PointsIteratorType;
     PointsIteratorType empty;
 
     mitk::Point3D new1, new2, new3, new4, refMaxPt;
     new1.Fill(4);
     new2.Fill(5);
     new3.Fill(6);
     new4.Fill(7);
     refMaxPt.Fill(5);
 
     pointSet->SetPoint(0, new1, 2);
     pointSet->InsertPoint(1, new2, 2);
     pointSet->InsertPoint(3, new3, 2);
     pointSet->InsertPoint(6, new4, 2);
 
     PointsIteratorType maxIt = pointSet->GetMaxId(1);
     empty = pointSet->End(1);
     CPPUNIT_ASSERT_EQUAL_MESSAGE("Check empty time step max id.", true, maxIt == empty);
 
     maxIt = pointSet->GetMaxId(3);
     empty = pointSet->End(3);
     CPPUNIT_ASSERT_EQUAL_MESSAGE("Check non-existent time step max id.", true, maxIt == empty);
 
     maxIt = pointSet->GetMaxId(0);
     empty = pointSet->End(0);
     IdType maxId = maxIt.Index();
     mitk::Point3D maxPt = maxIt.Value();
     bool equal = mitk::Equal(maxPt, refMaxPt);
     CPPUNIT_ASSERT_EQUAL_MESSAGE("Check time step 0 max id iterator.", false, maxIt == empty);
     CPPUNIT_ASSERT_EQUAL_MESSAGE("Check time step 0 max id.", true, maxId == 4);
     CPPUNIT_ASSERT_EQUAL_MESSAGE("Check time step 0 max id point.", true, equal);
 
     maxIt = pointSet->GetMaxId(2);
     empty = pointSet->End(2);
     maxId = maxIt.Index();
     maxPt = maxIt.Value();
     equal = mitk::Equal(maxPt, new4);
     CPPUNIT_ASSERT_EQUAL_MESSAGE("Check time step 2 max id iterator.", false, maxIt == empty);
     CPPUNIT_ASSERT_EQUAL_MESSAGE("Check time step 2 max id.", true, maxId == 6);
     CPPUNIT_ASSERT_EQUAL_MESSAGE("Check time step 2 max id point.", true, equal);
   }
 
   void TestInsertPointAtEnd()
   {
     typedef mitk::PointSet::PointType PointType;
 
     PointType new1, new2, new3, new4, refMaxPt;
     new1.Fill(4);
     new2.Fill(5);
     new3.Fill(6);
     new4.Fill(7);
 
     pointSet->SetPoint(1, new1, 2);
     pointSet->InsertPoint(3, new2, 2);
     pointSet->InsertPoint(4, new3, 2);
     pointSet->InsertPoint(6, new4, 2);
 
     PointType in1, in2, in3, in4;
     in1.Fill(8);
     in2.Fill(9);
     in3.Fill(10);
     in4.Fill(11);
 
     mitk::PointSet::Pointer refPs1 = pointSet->Clone();
     refPs1->SetPoint(5, in1, 0);
     mitk::PointSet::Pointer refPs2 = pointSet->Clone();
     refPs2->SetPoint(5, in1, 0);
     refPs2->SetPoint(0, in2, 1);
     mitk::PointSet::Pointer refPs3 = pointSet->Clone();
     refPs3->SetPoint(5, in1, 0);
     refPs3->SetPoint(0, in2, 1);
     refPs3->SetPoint(7, in3, 2);
     mitk::PointSet::Pointer refPs4 = pointSet->Clone();
     refPs4->SetPoint(5, in1, 0);
     refPs4->SetPoint(0, in2, 1);
     refPs4->SetPoint(7, in3, 2);
     refPs4->SetPoint(0, in4, 7);
 
     pointSet->InsertPoint(in1, 0);
     MITK_ASSERT_EQUAL(pointSet, refPs1, "Check point insertion for time step 0.");
 
     pointSet->InsertPoint(in2, 1);
     MITK_ASSERT_EQUAL(pointSet, refPs2, "Check point insertion for time step 1.");
 
     pointSet->InsertPoint(in3, 2);
     MITK_ASSERT_EQUAL(pointSet, refPs3, "Check point insertion for time step 2.");
 
     pointSet->InsertPoint(in4, 7);
     MITK_ASSERT_EQUAL(pointSet, refPs4, "Check point insertion for time step 7.");
   }
 };
 
 MITK_TEST_SUITE_REGISTRATION(mitkPointSet)
diff --git a/Modules/Segmentation/Interactions/mitkAutoSegmentationWithPreviewTool.cpp b/Modules/Segmentation/Interactions/mitkAutoSegmentationWithPreviewTool.cpp
index 61bb36e108..0a5b4bb19f 100644
--- a/Modules/Segmentation/Interactions/mitkAutoSegmentationWithPreviewTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkAutoSegmentationWithPreviewTool.cpp
@@ -1,704 +1,704 @@
 /*============================================================================
 
 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 "mitkAutoSegmentationWithPreviewTool.h"
 
 #include "mitkToolManager.h"
 
 #include "mitkColorProperty.h"
 #include "mitkLevelWindowProperty.h"
 #include "mitkProperties.h"
 
 #include "mitkDataStorage.h"
 #include "mitkRenderingManager.h"
 #include <mitkSliceNavigationController.h>
 
 #include "mitkImageAccessByItk.h"
 #include "mitkImageCast.h"
 #include "mitkImageStatisticsHolder.h"
 #include "mitkImageTimeSelector.h"
 #include "mitkLabelSetImage.h"
 #include "mitkMaskAndCutRoiImageFilter.h"
 #include "mitkPadImageFilter.h"
 #include "mitkNodePredicateGeometry.h"
 #include "mitkSegTool2D.h"
 
 #include <itkBinaryFunctorImageFilter.h>
 
 mitk::AutoSegmentationWithPreviewTool::AutoSegmentationWithPreviewTool(bool lazyDynamicPreviews): m_LazyDynamicPreviews(lazyDynamicPreviews)
 {
   m_ProgressCommand = ToolCommand::New();
 }
 
 mitk::AutoSegmentationWithPreviewTool::AutoSegmentationWithPreviewTool(bool lazyDynamicPreviews, const char* interactorType, const us::Module* interactorModule) : AutoSegmentationTool(interactorType, interactorModule), m_LazyDynamicPreviews(lazyDynamicPreviews)
 {
   m_ProgressCommand = ToolCommand::New();
 }
 
 mitk::AutoSegmentationWithPreviewTool::~AutoSegmentationWithPreviewTool()
 {
 }
 
 bool mitk::AutoSegmentationWithPreviewTool::CanHandle(const BaseData* referenceData, const BaseData* workingData) const
 {
   if (!Superclass::CanHandle(referenceData, workingData))
     return false;
 
   if (workingData == nullptr)
     return true;
 
   auto* labelSet = dynamic_cast<const LabelSetImage*>(workingData);
 
   if (labelSet != nullptr)
     return true;
 
   auto* image = dynamic_cast<const Image*>(workingData);
 
   if (image == nullptr)
     return false;
 
   //if it is a normal image and not a label set image is used as working data
   //it must have the same pixel type as a label set.
   return MakeScalarPixelType< DefaultSegmentationDataType >() == image->GetPixelType();
 }
 
 void mitk::AutoSegmentationWithPreviewTool::Activated()
 {
   Superclass::Activated();
 
   this->GetToolManager()->RoiDataChanged +=
     MessageDelegate<AutoSegmentationWithPreviewTool>(this, &AutoSegmentationWithPreviewTool::OnRoiDataChanged);
 
   this->GetToolManager()->SelectedTimePointChanged +=
     MessageDelegate<AutoSegmentationWithPreviewTool>(this, &AutoSegmentationWithPreviewTool::OnTimePointChanged);
 
   m_ReferenceDataNode = this->GetToolManager()->GetReferenceData(0);
   m_SegmentationInputNode = m_ReferenceDataNode;
 
   m_LastTimePointOfUpdate = RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint();
 
   if (m_PreviewSegmentationNode.IsNull())
   {
     m_PreviewSegmentationNode = DataNode::New();
     m_PreviewSegmentationNode->SetProperty("color", ColorProperty::New(0.0, 1.0, 0.0));
     m_PreviewSegmentationNode->SetProperty("name", StringProperty::New(std::string(this->GetName())+" preview"));
     m_PreviewSegmentationNode->SetProperty("opacity", FloatProperty::New(0.3));
     m_PreviewSegmentationNode->SetProperty("binary", BoolProperty::New(true));
     m_PreviewSegmentationNode->SetProperty("helper object", BoolProperty::New(true));
   }
 
   if (m_SegmentationInputNode.IsNotNull())
   {
     this->ResetPreviewNode();
     this->InitiateToolByInput();
   }
   else
   {
     this->GetToolManager()->ActivateTool(-1);
   }
 }
 
 void mitk::AutoSegmentationWithPreviewTool::Deactivated()
 {
   this->GetToolManager()->RoiDataChanged -=
     MessageDelegate<AutoSegmentationWithPreviewTool>(this, &AutoSegmentationWithPreviewTool::OnRoiDataChanged);
 
   this->GetToolManager()->SelectedTimePointChanged -=
     MessageDelegate<AutoSegmentationWithPreviewTool>(this, &AutoSegmentationWithPreviewTool::OnTimePointChanged);
 
   m_SegmentationInputNode = nullptr;
   m_ReferenceDataNode = nullptr;
   m_WorkingPlaneGeometry = nullptr;
 
   try
   {
     if (DataStorage *storage = this->GetToolManager()->GetDataStorage())
     {
       storage->Remove(m_PreviewSegmentationNode);
       RenderingManager::GetInstance()->RequestUpdateAll();
     }
   }
   catch (...)
   {
     // don't care
   }
 
   if (m_PreviewSegmentationNode.IsNotNull())
   {
     m_PreviewSegmentationNode->SetData(nullptr);
   }
 
   Superclass::Deactivated();
 }
 
 void mitk::AutoSegmentationWithPreviewTool::ConfirmSegmentation()
 {
   bool labelChanged = this->EnsureUpToDateUserDefinedActiveLabel();
   if ((m_LazyDynamicPreviews && m_CreateAllTimeSteps) || labelChanged)
   { // The tool should create all time steps but is currently in lazy mode,
     // thus ensure that a preview for all time steps is available.
     this->UpdatePreview(true);
   }
 
 
   CreateResultSegmentationFromPreview();
 
   RenderingManager::GetInstance()->RequestUpdateAll();
 
   if (!m_KeepActiveAfterAccept)
   {
     this->GetToolManager()->ActivateTool(-1);
   }
 }
 
 void  mitk::AutoSegmentationWithPreviewTool::InitiateToolByInput()
 {
   //default implementation does nothing.
   //implement in derived classes to change behavior
 }
 
 mitk::Image* mitk::AutoSegmentationWithPreviewTool::GetPreviewSegmentation()
 {
   if (m_PreviewSegmentationNode.IsNull())
   {
     return nullptr;
   }
 
   return dynamic_cast<Image*>(m_PreviewSegmentationNode->GetData());
 }
 
 mitk::DataNode* mitk::AutoSegmentationWithPreviewTool::GetPreviewSegmentationNode()
 {
   return m_PreviewSegmentationNode;
 }
 
 const mitk::Image* mitk::AutoSegmentationWithPreviewTool::GetSegmentationInput() const
 {
   if (m_SegmentationInputNode.IsNull())
   {
     return nullptr;
   }
 
   return dynamic_cast<const Image*>(m_SegmentationInputNode->GetData());
 }
 
 const mitk::Image* mitk::AutoSegmentationWithPreviewTool::GetReferenceData() const
 {
   if (m_ReferenceDataNode.IsNull())
   {
     return nullptr;
   }
 
   return dynamic_cast<const Image*>(m_ReferenceDataNode->GetData());
 }
 
 void mitk::AutoSegmentationWithPreviewTool::ResetPreviewNode()
 {
   itk::RGBPixel<float> previewColor;
   previewColor[0] = 0.0f;
   previewColor[1] = 1.0f;
   previewColor[2] = 0.0f;
 
   const auto image = this->GetSegmentationInput();
   if (nullptr != image)
   {
     LabelSetImage::ConstPointer workingImage =
       dynamic_cast<const LabelSetImage *>(this->GetToolManager()->GetWorkingData(0)->GetData());
 
     if (workingImage.IsNotNull())
     {
       auto newPreviewImage = workingImage->Clone();
       if (this->GetResetsToEmptyPreview())
       {
         newPreviewImage->ClearBuffer();
       }
 
       if (newPreviewImage.IsNull())
       {
         MITK_ERROR << "Cannot create preview helper objects. Unable to clone working image";
         return;
       }
 
       m_PreviewSegmentationNode->SetData(newPreviewImage);
 
       // Let's paint the feedback node green...
       auto* activeLayer = newPreviewImage->GetActiveLabelSet();
       auto* activeLabel = activeLayer->GetActiveLabel();
       activeLabel->SetColor(previewColor);
       activeLayer->UpdateLookupTable(activeLabel->GetValue());
     }
     else
     {
       Image::ConstPointer workingImageBin = dynamic_cast<const Image*>(this->GetToolManager()->GetWorkingData(0)->GetData());
       if (workingImageBin.IsNotNull())
       {
         Image::Pointer newPreviewImage;
         if (this->GetResetsToEmptyPreview())
         {
           newPreviewImage = Image::New();
           newPreviewImage->Initialize(workingImageBin);
         }
         else
         {
           auto newPreviewImage = workingImageBin->Clone();
         }
         if (newPreviewImage.IsNull())
         {
           MITK_ERROR << "Cannot create preview helper objects. Unable to clone working image";
           return;
         }
         m_PreviewSegmentationNode->SetData(newPreviewImage);
       }
       else
       {
         mitkThrow() << "Tool is an invalid state. Cannot setup preview node. Working data is an unsupported class and should have not been accepted by CanHandle().";
       }
     }
 
     m_PreviewSegmentationNode->SetColor(previewColor);
     m_PreviewSegmentationNode->SetOpacity(0.5);
 
     int layer(50);
     m_ReferenceDataNode->GetIntProperty("layer", layer);
     m_PreviewSegmentationNode->SetIntProperty("layer", layer + 1);
 
     if (DataStorage *ds = this->GetToolManager()->GetDataStorage())
     {
       if (!ds->Exists(m_PreviewSegmentationNode))
         ds->Add(m_PreviewSegmentationNode, m_ReferenceDataNode);
     }
   }
 }
 
 void mitk::AutoSegmentationWithPreviewTool::TransferImageAtTimeStep(const Image* sourceImage, Image* destinationImage, const TimeStepType timeStep)
 {
   try
   {
     Image::ConstPointer sourceImageAtTimeStep = this->GetImageByTimeStep(sourceImage, timeStep);
 
     if (sourceImageAtTimeStep->GetPixelType() != destinationImage->GetPixelType())
     {
       mitkThrow() << "Cannot transfer images. Tool is in an invalid state, source image and destination image do not have the same pixel type. "
         << "Source pixel type: " << sourceImage->GetPixelType().GetTypeAsString()
         << "; destination pixel type: " << destinationImage->GetPixelType().GetTypeAsString();
     }
 
     if (!Equal(*(sourceImage->GetGeometry(timeStep)), *(destinationImage->GetGeometry(timeStep)), NODE_PREDICATE_GEOMETRY_DEFAULT_CHECK_COORDINATE_PRECISION, NODE_PREDICATE_GEOMETRY_DEFAULT_CHECK_DIRECTION_PRECISION, false))
     {
       mitkThrow() << "Cannot transfer images. Tool is in an invalid state, source image and destination image do not have the same geometry.";
     }
 
     if (nullptr != this->GetWorkingPlaneGeometry())
     {
       auto sourceSlice = SegTool2D::GetAffectedImageSliceAs2DImage(this->GetWorkingPlaneGeometry(), sourceImage, timeStep);
       SegTool2D::WriteBackSegmentationResult(this->GetTargetSegmentationNode(), m_WorkingPlaneGeometry, sourceSlice, timeStep);
     }
     else
     { //take care of the full segmentation volume
       auto sourceLSImage = dynamic_cast<const LabelSetImage*>(sourceImage);
       auto destLSImage = dynamic_cast<LabelSetImage*>(destinationImage);
 
       TransferLabelContent(sourceLSImage, destLSImage, { {this->GetUserDefinedActiveLabel(),this->GetUserDefinedActiveLabel()} }, false, timeStep);
     }
   }
   catch (...)
   {
     Tool::ErrorMessage("Error accessing single time steps of the original image. Cannot create segmentation.");
     throw;
   }
 }
 
 void mitk::AutoSegmentationWithPreviewTool::CreateResultSegmentationFromPreview()
 {
   const auto segInput = this->GetSegmentationInput();
   auto previewImage = this->GetPreviewSegmentation();
   if (nullptr != segInput && nullptr != previewImage)
   {
     DataNode::Pointer resultSegmentationNode = GetTargetSegmentationNode();
 
     if (resultSegmentationNode.IsNotNull())
     {
       const auto timePoint = RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint();
       auto resultSegmentation = dynamic_cast<Image*>(resultSegmentationNode->GetData());
 
       // REMARK: the following code in this scope assumes that previewImage and resultSegmentation
       // are clones of the working image (segmentation provided to the tool). Therefore they have
       // the same time geometry.
       if (previewImage->GetTimeSteps() != resultSegmentation->GetTimeSteps())
       {
         mitkThrow() << "Cannot perform threshold. Internal tool state is invalid."
           << " Preview segmentation and segmentation result image have different time geometries.";
       }
 
       if (m_CreateAllTimeSteps)
       {
         for (unsigned int timeStep = 0; timeStep < previewImage->GetTimeSteps(); ++timeStep)
         {
           this->TransferImageAtTimeStep(previewImage, resultSegmentation, timeStep);
         }
       }
       else
       {
         const auto timeStep = resultSegmentation->GetTimeGeometry()->TimePointToTimeStep(timePoint);
         this->TransferImageAtTimeStep(previewImage, resultSegmentation, timeStep);
       }
 
       // since we are maybe working on a smaller image, pad it to the size of the original image
       if (m_ReferenceDataNode.GetPointer() != m_SegmentationInputNode.GetPointer())
       {
         PadImageFilter::Pointer padFilter = PadImageFilter::New();
 
         padFilter->SetInput(0, resultSegmentation);
         padFilter->SetInput(1, dynamic_cast<Image*>(m_ReferenceDataNode->GetData()));
         padFilter->SetBinaryFilter(true);
         padFilter->SetUpperThreshold(1);
         padFilter->SetLowerThreshold(1);
         padFilter->Update();
 
         resultSegmentationNode->SetData(padFilter->GetOutput());
       }
       if (m_OverwriteExistingSegmentation)
       { //if we overwrite the segmentation (and not just store it as a new result
         //in the data storage) we update also the tool manager state.
         this->GetToolManager()->SetWorkingData(resultSegmentationNode);
         this->GetToolManager()->GetWorkingData(0)->Modified();
       }
       this->EnsureTargetSegmentationNodeInDataStorage();
     }
   }
 }
 
 void mitk::AutoSegmentationWithPreviewTool::OnRoiDataChanged()
 {
   DataNode::ConstPointer node = this->GetToolManager()->GetRoiData(0);
 
   if (node.IsNotNull())
   {
     MaskAndCutRoiImageFilter::Pointer roiFilter = MaskAndCutRoiImageFilter::New();
     Image::Pointer image = dynamic_cast<Image *>(m_SegmentationInputNode->GetData());
 
     if (image.IsNull())
       return;
 
     roiFilter->SetInput(image);
     roiFilter->SetRegionOfInterest(node->GetData());
     roiFilter->Update();
 
     DataNode::Pointer tmpNode = DataNode::New();
     tmpNode->SetData(roiFilter->GetOutput());
 
     m_SegmentationInputNode = tmpNode;
   }
   else
     m_SegmentationInputNode = m_ReferenceDataNode;
 
   this->ResetPreviewNode();
   this->InitiateToolByInput();
   this->UpdatePreview();
 }
 
 void mitk::AutoSegmentationWithPreviewTool::OnTimePointChanged()
 {
   if (m_IsTimePointChangeAware && m_PreviewSegmentationNode.IsNotNull() && m_SegmentationInputNode.IsNotNull())
   {
     const auto timePoint = RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint();
 
     const bool isStaticSegOnDynamicImage = m_PreviewSegmentationNode->GetData()->GetTimeSteps() == 1 && m_SegmentationInputNode->GetData()->GetTimeSteps() > 1;
     if (timePoint!=m_LastTimePointOfUpdate && (isStaticSegOnDynamicImage || m_LazyDynamicPreviews))
     { //we only need to update either because we are lazzy
       //or because we have a static segmentation with a dynamic image 
       this->UpdatePreview();
     }
   }
 }
 
 bool mitk::AutoSegmentationWithPreviewTool::EnsureUpToDateUserDefinedActiveLabel()
 {
   bool labelChanged = true;
 
   const auto workingImage = dynamic_cast<const Image*>(this->GetToolManager()->GetWorkingData(0)->GetData());
   if (const auto& labelSetImage = dynamic_cast<const LabelSetImage*>(workingImage))
   {
     // this is a fix for T28131 / T28986, which should be refactored if T28524 is being worked on
     auto newLabel = labelSetImage->GetActiveLabel(labelSetImage->GetActiveLayer())->GetValue();
     labelChanged = newLabel != m_UserDefinedActiveLabel;
     m_UserDefinedActiveLabel = newLabel;
   }
   else
   {
     m_UserDefinedActiveLabel = 1;
     labelChanged = false;
   }
   return labelChanged;
 }
 
 void mitk::AutoSegmentationWithPreviewTool::UpdatePreview(bool ignoreLazyPreviewSetting)
 {
   const auto inputImage = this->GetSegmentationInput();
   auto previewImage = this->GetPreviewSegmentation();
   int progress_steps = 200;
 
   const auto workingImage = dynamic_cast<const Image*>(this->GetToolManager()->GetWorkingData(0)->GetData());
   this->EnsureUpToDateUserDefinedActiveLabel();
 
   this->CurrentlyBusy.Send(true);
   m_IsUpdating = true;
 
   this->UpdatePrepare();
 
   const auto timePoint = RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint();
 
   try
   {
     if (nullptr != inputImage && nullptr != previewImage)
     {
       m_ProgressCommand->AddStepsToDo(progress_steps);
 
       if (previewImage->GetTimeSteps() > 1 && (ignoreLazyPreviewSetting || !m_LazyDynamicPreviews))
       {
         for (unsigned int timeStep = 0; timeStep < previewImage->GetTimeSteps(); ++timeStep)
         {
           Image::ConstPointer feedBackImage;
           Image::ConstPointer currentSegImage;
 
           auto previewTimePoint = previewImage->GetTimeGeometry()->TimeStepToTimePoint(timeStep);
           auto inputTimeStep = inputImage->GetTimeGeometry()->TimePointToTimeStep(previewTimePoint);
 
           if (nullptr != this->GetWorkingPlaneGeometry())
           { //only extract a specific slice defined by the working plane as feedback image.
             feedBackImage = SegTool2D::GetAffectedImageSliceAs2DImage(this->GetWorkingPlaneGeometry(), inputImage, inputTimeStep);
             currentSegImage = SegTool2D::GetAffectedImageSliceAs2DImageByTimePoint(this->GetWorkingPlaneGeometry(), workingImage, previewTimePoint);
           }
           else
           { //work on the whole feedback image
             feedBackImage = this->GetImageByTimeStep(inputImage, inputTimeStep);
             currentSegImage = this->GetImageByTimePoint(workingImage, previewTimePoint);
           }
 
           this->DoUpdatePreview(feedBackImage, currentSegImage, previewImage, timeStep);
         }
       }
       else
       {
         Image::ConstPointer feedBackImage;
         Image::ConstPointer currentSegImage;
 
         if (nullptr != this->GetWorkingPlaneGeometry())
         {
           feedBackImage = SegTool2D::GetAffectedImageSliceAs2DImageByTimePoint(this->GetWorkingPlaneGeometry(), inputImage, timePoint);
           currentSegImage = SegTool2D::GetAffectedImageSliceAs2DImageByTimePoint(this->GetWorkingPlaneGeometry(), workingImage, timePoint);
         }
         else
         {
           feedBackImage = this->GetImageByTimePoint(inputImage, timePoint);
           currentSegImage = this->GetImageByTimePoint(workingImage, timePoint);
         }
 
         auto timeStep = previewImage->GetTimeGeometry()->TimePointToTimeStep(timePoint);
 
         this->DoUpdatePreview(feedBackImage, currentSegImage, previewImage, timeStep);
       }
       RenderingManager::GetInstance()->RequestUpdateAll();
     }
   }
   catch (itk::ExceptionObject & excep)
   {
     MITK_ERROR << "Exception caught: " << excep.GetDescription();
 
     m_ProgressCommand->SetProgress(progress_steps);
 
     std::string msg = excep.GetDescription();
     ErrorMessage.Send(msg);
   }
   catch (...)
   {
     m_ProgressCommand->SetProgress(progress_steps);
     m_IsUpdating = false;
     CurrentlyBusy.Send(false);
     throw;
   }
 
   this->UpdateCleanUp();
   m_LastTimePointOfUpdate = timePoint;
   m_ProgressCommand->SetProgress(progress_steps);
   m_IsUpdating = false;
   CurrentlyBusy.Send(false);
 }
 
 bool mitk::AutoSegmentationWithPreviewTool::IsUpdating() const
 {
   return m_IsUpdating;
 }
 
 void mitk::AutoSegmentationWithPreviewTool::UpdatePrepare()
 {
   // default implementation does nothing
   //reimplement in derived classes for special behavior
 }
 
 void mitk::AutoSegmentationWithPreviewTool::UpdateCleanUp()
 {
   // default implementation does nothing
   //reimplement in derived classes for special behavior
 }
 
 mitk::TimePointType mitk::AutoSegmentationWithPreviewTool::GetLastTimePointOfUpdate() const
 {
   return m_LastTimePointOfUpdate;
 }
 
 /** Functor class that implements the label transfer and is used in conjunction with the itk::BinaryFunctorImageFilter.
 * For details regarding the usage of the filter and the functor patterns, please see info of itk::BinaryFunctorImageFilter.
 */
 template <class TDestinationPixel, class TSourcePixel, class TOutputpixel>
 class LabelTransferFunctor
 {
 
 public:
   LabelTransferFunctor(){};
 
   LabelTransferFunctor(const mitk::LabelSet* destinationLabelSet, mitk::Label::PixelType sourceBackground,
     mitk::Label::PixelType destinationBackground, bool destinationBackgroundLocked,
     mitk::Label::PixelType sourceLabel, mitk::Label::PixelType newDestinationLabel, bool mergeMode) :
     m_DestinationLabelSet(destinationLabelSet), m_SourceBackground(sourceBackground),
     m_DestinationBackground(destinationBackground), m_DestinationBackgroundLocked(destinationBackgroundLocked),
     m_SourceLabel(sourceLabel), m_NewDestinationLabel(newDestinationLabel), m_MergeMode(mergeMode)
   {
   };
 
   ~LabelTransferFunctor() {};
 
   bool operator!=(const LabelTransferFunctor& other)const
   {
     return !(*this == other);
   }
   bool operator==(const LabelTransferFunctor& other) const
   {
     return this->m_SourceBackground == other.m_SourceBackground &&
       this->m_DestinationBackground == other.m_DestinationBackground &&
       this->m_DestinationBackgroundLocked == other.m_DestinationBackgroundLocked &&
       this->m_SourceLabel == other.m_SourceLabel &&
       this->m_NewDestinationLabel == other.m_NewDestinationLabel &&
       this->m_MergeMode == other.m_MergeMode &&
       this->m_DestinationLabelSet == other.m_DestinationLabelSet;
   }
 
   LabelTransferFunctor& operator=(const LabelTransferFunctor& other)
   {
     this->m_DestinationLabelSet = other.m_DestinationLabelSet;
     this->m_SourceBackground = other.m_SourceBackground;
     this->m_DestinationBackground = other.m_DestinationBackground;
     this->m_DestinationBackgroundLocked = other.m_DestinationBackgroundLocked;
     this->m_SourceLabel = other.m_SourceLabel;
     this->m_NewDestinationLabel = other.m_NewDestinationLabel;
     this->m_MergeMode = other.m_MergeMode;
 
     return *this;
   }
 
   inline TOutputpixel operator()(const TDestinationPixel& existingDestinationValue, const TSourcePixel& existingSourceValue)
   {
     if (existingSourceValue == this->m_SourceLabel
       && !this->m_DestinationLabelSet->GetLabel(existingDestinationValue)->GetLocked())
     {
       return this->m_NewDestinationLabel;
     }
     else if (!this->m_MergeMode
       && existingSourceValue == this->m_SourceBackground
       && existingDestinationValue == this->m_NewDestinationLabel
       && !this->m_DestinationBackgroundLocked)
     {
       return this->m_DestinationBackground;
     }
 
     return existingDestinationValue;
   }
 
 private:
   const mitk::LabelSet* m_DestinationLabelSet = nullptr;
   mitk::Label::PixelType m_SourceBackground = 0;
   mitk::Label::PixelType m_DestinationBackground = 0;
   bool m_DestinationBackgroundLocked = false;
   mitk::Label::PixelType m_SourceLabel = 1;
   mitk::Label::PixelType m_NewDestinationLabel = 1;
   bool m_MergeMode = false;
 };
 
-/**Helper function used be TransferLabelContent to allow the templating over different image dimensions in conjunction of AccessFixedPixelTypeByItk_n.*/
+/**Helper function used by TransferLabelContent to allow the templating over different image dimensions in conjunction of AccessFixedPixelTypeByItk_n.*/
 template<unsigned int VImageDimension>
 void TransferLabelContentHelper(const itk::Image<mitk::Label::PixelType, VImageDimension>* itkSourceImage, mitk::Image* destinationImage, const mitk::LabelSet* destinationLabelSet, mitk::Label::PixelType sourceBackground, mitk::Label::PixelType destinationBackground, bool destinationBackgroundLocked, mitk::Label::PixelType sourceLabel, mitk::Label::PixelType newDestinationLabel, bool mergeMode)
 {
   typedef itk::Image<mitk::Label::PixelType, VImageDimension> ContentImageType;
   typename ContentImageType::Pointer itkDestinationImage;
   mitk::CastToItkImage(destinationImage, itkDestinationImage);
 
   typedef LabelTransferFunctor <mitk::Label::PixelType, mitk::Label::PixelType, mitk::Label::PixelType> LabelTransferFunctorType;
   typedef itk::BinaryFunctorImageFilter<ContentImageType, ContentImageType, ContentImageType, LabelTransferFunctorType> FilterType;
 
   LabelTransferFunctorType transferFunctor(destinationLabelSet, sourceBackground, destinationBackground,
     destinationBackgroundLocked, sourceLabel, newDestinationLabel, mergeMode);
 
   auto transferFilter = FilterType::New();
 
   transferFilter->SetFunctor(transferFunctor);
   transferFilter->InPlaceOn();
   transferFilter->SetInput1(itkDestinationImage);
   transferFilter->SetInput2(itkSourceImage);
 
   transferFilter->Update();
 }
 
 void mitk::AutoSegmentationWithPreviewTool::TransferLabelContent(
   const LabelSetImage* sourceImage, LabelSetImage* destinationImage, std::vector<std::pair<Label::PixelType, Label::PixelType> > labelMapping, bool mergeMode, const TimeStepType timeStep)
 {
   if (nullptr == sourceImage)
   {
     mitkThrow() << "Invalid call of TransferLabelContent; sourceImage must not be null.";
   }
   if (nullptr == destinationImage)
   {
     mitkThrow() << "Invalid call of TransferLabelContent; destinationImage must not be null.";
   }
 
   const auto sourceBackground = sourceImage->GetExteriorLabel()->GetValue();
   const auto destinationBackground = destinationImage->GetExteriorLabel()->GetValue();
   const auto destinationBackgroundLocked = destinationImage->GetExteriorLabel()->GetLocked();
   const auto destinationLabelSet = destinationImage->GetLabelSet(destinationImage->GetActiveLayer());
 
   Image::ConstPointer sourceImageAtTimeStep = this->GetImageByTimeStep(sourceImage, timeStep);
   Image::Pointer destinationImageAtTimeStep = this->GetImageByTimeStep(destinationImage, timeStep);
 
   if (nullptr == sourceImageAtTimeStep)
   {
     mitkThrow() << "Invalid call of TransferLabelContent; sourceImage does not have the requested time step: "<<timeStep;
   }
   if (nullptr == destinationImageAtTimeStep)
   {
-    mitkThrow() << "Invalid call of TransferLabelContent; destinationImage does has not have the requested time step: " << timeStep;
+    mitkThrow() << "Invalid call of TransferLabelContent; destinationImage does not have the requested time step: " << timeStep;
   }
 
   for (const auto& [sourceLabel, newDestinationLabel] : labelMapping)
   {
     if (!sourceImage->ExistLabel(sourceLabel, sourceImage->GetActiveLayer()))
     {
       mitkThrow() << "Invalid call of TransferLabelContent. Defined source label does not exist in sourceImage. SourceLabel: "<<sourceLabel;
     }
     if (!destinationImage->ExistLabel(newDestinationLabel, destinationImage->GetActiveLayer()))
     {
       mitkThrow() << "Invalid call of TransferLabelContent. Defined destination label does not exist in destinationImage. newDestinationLabel: " << newDestinationLabel;
     }
 
 
     AccessFixedPixelTypeByItk_n(sourceImageAtTimeStep, TransferLabelContentHelper, (Label::PixelType), (destinationImageAtTimeStep, destinationLabelSet, sourceBackground, destinationBackground, destinationBackgroundLocked, sourceLabel, newDestinationLabel, mergeMode));
   }
   destinationImage->Modified();
 }
diff --git a/Modules/Segmentation/Interactions/mitkAutoSegmentationWithPreviewTool.h b/Modules/Segmentation/Interactions/mitkAutoSegmentationWithPreviewTool.h
index 42543a9e02..e27c86fbc2 100644
--- a/Modules/Segmentation/Interactions/mitkAutoSegmentationWithPreviewTool.h
+++ b/Modules/Segmentation/Interactions/mitkAutoSegmentationWithPreviewTool.h
@@ -1,220 +1,220 @@
 /*============================================================================
 
 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 mitkAutoSegmentationWithPreviewTool_h_Included
 #define mitkAutoSegmentationWithPreviewTool_h_Included
 
 #include "mitkAutoSegmentationTool.h"
 #include "mitkCommon.h"
 #include "mitkDataNode.h"
 #include "mitkToolCommand.h"
 #include <MitkSegmentationExports.h>
 
 namespace mitk
 {
   /**
   \brief Base class for any auto segmentation tool that provides a preview of the new segmentation.
 
   This tool class implements a lot basic logic to handle auto segmentation tools with preview,
   Time point and ROI support. Derived classes will ask to update the segmentation preview if needed
   (e.g. because the ROI or the current time point has changed) or because derived tools
   indicated the need to update themselves.
   This class also takes care to properly transfer a confirmed preview into the segementation
   result.
 
   \ingroup ToolManagerEtAl
   \sa mitk::Tool
   \sa QmitkInteractiveSegmentation
   */
   class MITKSEGMENTATION_EXPORT AutoSegmentationWithPreviewTool : public AutoSegmentationTool
   {
   public:
 
     mitkClassMacro(AutoSegmentationWithPreviewTool, AutoSegmentationTool);
 
     void Activated() override;
     void Deactivated() override;
 
     void ConfirmSegmentation();
 
     itkSetMacro(CreateAllTimeSteps, bool);
     itkGetMacro(CreateAllTimeSteps, bool);
     itkBooleanMacro(CreateAllTimeSteps);
 
     itkSetMacro(KeepActiveAfterAccept, bool);
     itkGetMacro(KeepActiveAfterAccept, bool);
     itkBooleanMacro(KeepActiveAfterAccept);
 
     itkSetMacro(IsTimePointChangeAware, bool);
     itkGetMacro(IsTimePointChangeAware, bool);
     itkBooleanMacro(IsTimePointChangeAware);
 
     itkSetMacro(ResetsToEmptyPreview, bool);
     itkGetMacro(ResetsToEmptyPreview, bool);
     itkBooleanMacro(ResetsToEmptyPreview);
 
     bool CanHandle(const BaseData* referenceData, const BaseData* workingData) const override;
 
     /** Triggers the actualization of the preview
      * @param ignoreLazyPreviewSetting If set true UpdatePreview will always
      * generate the preview for all time steps. If set to false, UpdatePreview
      * will regard the setting specified by the constructor.
      * To define the update generation for time steps implement DoUpdatePreview.
      * To alter what should be done directly before or after the update of the preview,
      * reimplement UpdatePrepare() or UpdateCleanUp().*/
     void UpdatePreview(bool ignoreLazyPreviewSetting = false);
 
     /** Indicate if currently UpdatePreview is triggered (true) or not (false).*/
     bool IsUpdating() const;
 
   protected:
     ToolCommand::Pointer m_ProgressCommand;
 
     /** Member is always called if GetSegmentationInput() has changed
      * (e.g. because a new ROI was defined, or on activation) to give derived
      * classes the posibility to initiate their state accordingly.
      * Reimplement this function to implement special behavior.
      */
     virtual void InitiateToolByInput();
 
     /** This member function offers derived classes the possibility to alter what should
     happen directly before the update of the preview is performed. It is called by
     UpdatePreview. Default implementation does nothing.*/
     virtual void UpdatePrepare();
 
     /** This member function offers derived classes the possibility to alter what should
     happen directly after the update of the preview is performed. It is called by
     UpdatePreview. Default implementation does nothing.*/
     virtual void UpdateCleanUp();
 
     /** This function does the real work. Here the preview for a given
      * input image should be computed and stored in the also passed
      * preview image at the passed time step.
      * It also provides the current/old segmentation at the time point,
      * which can be used, if the preview depends on the the segmenation so far.
      */
     virtual void DoUpdatePreview(const Image* inputAtTimeStep, const Image* oldSegAtTimeStep, Image* previewImage, TimeStepType timeStep) = 0;
 
     AutoSegmentationWithPreviewTool(bool lazyDynamicPreviews = false); // purposely hidden
     AutoSegmentationWithPreviewTool(bool lazyDynamicPreviews, const char* interactorType, const us::Module* interactorModule = nullptr); // purposely hidden
 
     ~AutoSegmentationWithPreviewTool() override;
 
     /** Returns the image that contains the preview of the current segmentation.
      * Returns null if the node is not set or does not contain an image.*/
     Image* GetPreviewSegmentation();
     DataNode* GetPreviewSegmentationNode();
 
     /** Returns the input that should be used for any segmentation/preview or tool update.
      * It is either the data of ReferenceDataNode itself or a part of it defined by a ROI mask
      * provided by the tool manager. Derived classes should regard this as the relevant
      * input data for any processing.
      * Returns null if the node is not set or does not contain an image.*/
     const Image* GetSegmentationInput() const;
 
     /** Returns the image that is provided by the ReferenceDataNode.
      * Returns null if the node is not set or does not contain an image.*/
     const Image* GetReferenceData() const;
 
     /** Resets the preview node so it is empty and ready to be filled by the tool*/
     void ResetPreviewNode();
 
     TimePointType GetLastTimePointOfUpdate() const;
 
     itkGetConstMacro(UserDefinedActiveLabel, Label::PixelType);
 
     itkSetObjectMacro(WorkingPlaneGeometry, PlaneGeometry);
     itkGetConstObjectMacro(WorkingPlaneGeometry, PlaneGeometry);
 
   private:
     void TransferImageAtTimeStep(const Image* sourceImage, Image* destinationImage, const TimeStepType timeStep);
 
     /**Helper function that transfers pixels of the specified source label from source image to the destination image by using
     a specified destination label. Function processes the whole image volume of the specified time step.
     @remark in its current implementation the function only transfers contents of the active layer of the passed LabelSetImages.
     @remark the function assumes that it is only called with source and destination image of same geometry.
     @param sourceImage Pointer to the LabelSetImage which active layer should be used as source for the transfer.
     @param destionationImage Pointer to the LabelSetImage which active layer should be used as destination for the transfer.
     @param labelMapping Map that encodes the mappings of all label pixel transfers that should be done. First element is the
     label in the source image. The second element is the label that transferred pixels should become in the destination image.
     @param mergeMode indicates how the transfer should be done. If true, it is performed like a merge/union operation. So only
-    pixels of the label will be added. If false, also background is transfered, if present in the source image where the
+    pixels of the label will be added. If false, also background is transferred, if present in the source image where the
     destinationImage is labeled by the destination label. Therefore in this mode the label in the destinationImage can
     "shrink"/lose pixels to the background.
     @param timeStep indicate the time step that should be transferred.
     @pre sourceImage and destinationImage must be valid
     @pre sourceImage and destinationImage must contain the indicated timeStep
     @pre sourceImage must contain all indicated sourceLabels in its active layer.
     @pre destinationImage must contain all indicated destinationLabels in its active layer.*/
     void TransferLabelContent(const LabelSetImage* sourceImage, LabelSetImage* destinationImage,
       std::vector<std::pair<Label::PixelType, Label::PixelType> > labelMapping = { {1,1} },
       bool mergeMode = false, const TimeStepType timeStep = 0);
 
     void CreateResultSegmentationFromPreview();
 
     void OnRoiDataChanged();
     void OnTimePointChanged();
 
     /**Internal helper that ensures that the stored active label is up to date.
      This is a fix for T28131 / T28986. It should be refactored if T28524 is being worked on.
      On the long run, the active label will be communicated/set by the user/toolmanager as a
      state of the tool and the tool should react accordingly (like it does for other external
      state changes).
      @return indicates if the label has changed (true) or not.
      */
     bool EnsureUpToDateUserDefinedActiveLabel();
 
     /** Node that containes the preview data generated and managed by this class or derived ones.*/
     DataNode::Pointer m_PreviewSegmentationNode;
     /** The reference data recieved from ToolManager::GetReferenceData when tool was activated.*/
     DataNode::Pointer m_ReferenceDataNode;
     /** Node that containes the data that should be used as input for any auto segmentation. It might
      * be the same like m_ReferenceDataNode (if no ROI is set) or a sub region (if ROI is set).*/
     DataNode::Pointer m_SegmentationInputNode;
 
     /** Indicates if Accepting the threshold should transfer/create the segmentations
      of all time steps (true) or only of the currently selected timepoint (false).*/
     bool m_CreateAllTimeSteps = false;
 
     /** Indicates if the tool should kept active after accepting the segmentation or not.*/
     bool m_KeepActiveAfterAccept = false;
 
     /** Relevant if the working data / preview image has multiple time steps (dynamic segmentations).
      * This flag has to be set by derived classes accordingly to there way to generate dynamic previews.
      * If LazyDynamicPreview is true, the tool generates only the preview for the current time step.
      * Therefore it always has to update the preview if current time point has changed and it has to (re)compute
      * all timeframes if ConfirmSegmentation() is called.*/
     bool m_LazyDynamicPreviews = false;
 
     bool m_IsTimePointChangeAware = true;
 
     /** Controls if ResetPreviewNode generates an empty content (true) or clones the current
     segmentation (false).*/
     bool m_ResetsToEmptyPreview = false;
 
     TimePointType m_LastTimePointOfUpdate = 0.;
 
     bool m_IsUpdating = false;
 
     Label::PixelType m_UserDefinedActiveLabel = 1;
 
     /** This variable indicates if for the tool a working plane geometry is defined.
      * If a working plane is defined the tool will only work an the slice of the input
      * and the segmentation. Thus only the relevant input slice will be passed to
      * DoUpdatePreview(...) and only the relevant slice of the preview will be transfered when
      * ConfirmSegmentation() is called.*/
     PlaneGeometry::Pointer m_WorkingPlaneGeometry;
   };
 
 } // namespace
 
 #endif
diff --git a/Modules/Segmentation/Interactions/mitkPickingTool.cpp b/Modules/Segmentation/Interactions/mitkPickingTool.cpp
index 97257d68f8..b0a608370b 100644
--- a/Modules/Segmentation/Interactions/mitkPickingTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkPickingTool.cpp
@@ -1,278 +1,279 @@
 /*============================================================================
 
 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 "mitkPickingTool.h"
 
 #include "mitkProperties.h"
 #include "mitkToolManager.h"
 
 #include "mitkInteractionPositionEvent.h"
 // us
 #include <usGetModuleContext.h>
 #include <usModule.h>
 #include <usModuleContext.h>
 #include <usModuleResource.h>
 
 #include "mitkITKImageImport.h"
 #include "mitkImageAccessByItk.h"
 #include "mitkImageCast.h"
 #include "mitkImageTimeSelector.h"
 #include "mitkImageTimeSelector.h"
 
 #include <itkImage.h>
 #include <itkConnectedThresholdImageFilter.h>
 #include <itkOrImageFilter.h>
 #include <mitkLabelSetImage.h>
 
 namespace mitk
 {
   MITK_TOOL_MACRO(MITKSEGMENTATION_EXPORT, PickingTool, "PickingTool");
 }
 
 mitk::PickingTool::PickingTool() : AutoSegmentationWithPreviewTool(false, "PressMoveReleaseAndPointSetting")
 {
   this->ResetsToEmptyPreviewOn();
 }
 
 mitk::PickingTool::~PickingTool()
 {
 }
 
 bool mitk::PickingTool::CanHandle(const BaseData* referenceData, const BaseData* workingData) const
 {
   if (!Superclass::CanHandle(referenceData,workingData))
     return false;
 
   auto* image = dynamic_cast<const Image*>(referenceData);
 
   if (image == nullptr)
     return false;
 
   return true;
 }
 
 const char **mitk::PickingTool::GetXPM() const
 {
   return nullptr;
 }
 
 const char *mitk::PickingTool::GetName() const
 {
   return "Picking";
 }
 
 us::ModuleResource mitk::PickingTool::GetIconResource() const
 {
   us::Module *module = us::GetModuleContext()->GetModule();
   us::ModuleResource resource = module->GetResource("Pick_48x48.png");
   return resource;
 }
 
 void mitk::PickingTool::Activated()
 {
   Superclass::Activated();
 
   m_PointSet = mitk::PointSet::New();
   //ensure that the seed points are visible for all timepoints.
   dynamic_cast<ProportionalTimeGeometry*>(m_PointSet->GetTimeGeometry())->SetStepDuration(std::numeric_limits<TimePointType>::max());
 
   m_PointSetNode = mitk::DataNode::New();
   m_PointSetNode->SetData(m_PointSet);
   m_PointSetNode->SetName(std::string(this->GetName()) + "_PointSet");
   m_PointSetNode->SetBoolProperty("helper object", true);
   m_PointSetNode->SetColor(0.0, 1.0, 0.0);
   m_PointSetNode->SetVisibility(true);
 
   this->GetDataStorage()->Add(m_PointSetNode, this->GetToolManager()->GetWorkingData(0));
 }
 
 void mitk::PickingTool::Deactivated()
 {
   this->ClearSeeds();
 
   // remove from data storage and disable interaction
   GetDataStorage()->Remove(m_PointSetNode);
   m_PointSetNode = nullptr;
   m_PointSet = nullptr;
 
   Superclass::Deactivated();
 }
 
 void mitk::PickingTool::ConnectActionsAndFunctions()
 {
   CONNECT_FUNCTION("ShiftSecondaryButtonPressed", OnAddPoint);
   CONNECT_FUNCTION("ShiftPrimaryButtonPressed", OnAddPoint);
   CONNECT_FUNCTION("DeletePoint", OnDelete);
 }
 
 void mitk::PickingTool::OnAddPoint(StateMachineAction*, InteractionEvent* interactionEvent)
 {
   if (!this->IsUpdating() && m_PointSet.IsNotNull())
   {
     const auto positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>(interactionEvent);
 
     if (positionEvent != nullptr)
     {
       m_PointSet->InsertPoint(m_PointSet->GetSize(), positionEvent->GetPositionInWorld());
       this->UpdatePreview();
     }
   }
 }
 
 void mitk::PickingTool::OnDelete(StateMachineAction*, InteractionEvent* /*interactionEvent*/)
 {
   if (!this->IsUpdating() && m_PointSet.IsNotNull())
   {
     // delete last seed point
     if (this->m_PointSet->GetSize() > 0)
     {
       m_PointSet->RemovePointAtEnd(0);
 
       this->UpdatePreview();
     }
   }
 }
 
 void mitk::PickingTool::ClearPicks()
 {
   this->ClearSeeds();
   this->UpdatePreview();
 }
 
 bool mitk::PickingTool::HasPicks() const
 {
   return this->m_PointSet.IsNotNull() && this->m_PointSet->GetSize()>0;
 }
 
 void mitk::PickingTool::ClearSeeds()
 {
   if (this->m_PointSet.IsNotNull())
   {
     // renew pointset
     this->m_PointSet = mitk::PointSet::New();
     //ensure that the seed points are visible for all timepoints.
     dynamic_cast<ProportionalTimeGeometry*>(m_PointSet->GetTimeGeometry())->SetStepDuration(std::numeric_limits<TimePointType>::max());
     this->m_PointSetNode->SetData(this->m_PointSet);
   }
 }
 
 template <typename TPixel, unsigned int VImageDimension>
 void DoITKRegionGrowing(const itk::Image<TPixel, VImageDimension>* oldSegImage,
   mitk::Image* segmentation,
   const mitk::PointSet* seedPoints,
   unsigned int timeStep, const mitk::BaseGeometry* inputGeometry, const mitk::Label::PixelType outputValue,
   const mitk::Label::PixelType backgroundValue)
 {
   typedef itk::Image<TPixel, VImageDimension> InputImageType;
   typedef itk::Image<mitk::Label::PixelType, VImageDimension> OutputImageType;
   typedef typename InputImageType::IndexType IndexType;
   typedef itk::ConnectedThresholdImageFilter<InputImageType, OutputImageType> RegionGrowingFilterType;
 
   using IndexMapType = std::map < mitk::Label::PixelType, std::vector<IndexType> >;
 
   IndexMapType indexMap;
 
   // convert world coordinates to image indices
   for (auto pos = seedPoints->Begin(); pos != seedPoints->End(); ++pos)
   {
     IndexType seedIndex;
     inputGeometry->WorldToIndex(pos->Value(), seedIndex);
     const auto selectedLabel = oldSegImage->GetPixel(seedIndex);
 
     if (selectedLabel != backgroundValue)
     {
       indexMap[selectedLabel].push_back(seedIndex);
     }
   }
 
   typename OutputImageType::Pointer itkResultImage;
 
   try
   {
     bool first = true;
+    typename RegionGrowingFilterType::Pointer regionGrower = RegionGrowingFilterType::New();
+    regionGrower->SetInput(oldSegImage);
+    regionGrower->SetReplaceValue(outputValue);
+
     for (const auto& [label, indeces] : indexMap)
     {
       // perform region growing in desired segmented region
-      typename RegionGrowingFilterType::Pointer regionGrower = RegionGrowingFilterType::New();
+      regionGrower->ClearSeeds();
       for (const auto& index : indeces)
       {
         regionGrower->AddSeed(index);
       }
 
-      regionGrower->SetInput(oldSegImage);
-
       regionGrower->SetLower(label);
       regionGrower->SetUpper(label);
-      regionGrower->SetReplaceValue(outputValue);
 
       regionGrower->Update();
 
       if (first)
       {
         itkResultImage = regionGrower->GetOutput();
       }
       else
       {
         typename itk::OrImageFilter<OutputImageType, OutputImageType>::Pointer orFilter =
           itk::OrImageFilter<OutputImageType, OutputImageType>::New();
         orFilter->SetInput1(regionGrower->GetOutput());
         orFilter->SetInput2(itkResultImage);
 
         orFilter->Update();
         itkResultImage = orFilter->GetOutput();
       }
       first = false;
       itkResultImage->DisconnectPipeline();
     }
   }
   catch (const itk::ExceptionObject&)
   {
     return; // can't work
   }
   catch (...)
   {
     return;
   }
 
   if (itkResultImage.IsNotNull())
   {
     segmentation->SetVolume((void*)(itkResultImage->GetPixelContainer()->GetBufferPointer()), timeStep);
   }
   else
   {
     mitk::CastToItkImage(segmentation, itkResultImage);
     itkResultImage->FillBuffer(backgroundValue);
   }
 
 }
 
 void mitk::PickingTool::DoUpdatePreview(const Image* /*inputAtTimeStep*/, const Image* oldSegAtTimeStep, Image* previewImage, TimeStepType timeStep)
 {
   if (nullptr != oldSegAtTimeStep && nullptr != previewImage && m_PointSet.IsNotNull())
   {
     if (this->HasPicks())
     {
       Label::PixelType backgroundValue = 0;
       auto labelSetImage = dynamic_cast<const LabelSetImage*>(oldSegAtTimeStep);
       if (nullptr != labelSetImage)
       {
         backgroundValue = labelSetImage->GetExteriorLabel()->GetValue();
       }
 
       AccessFixedDimensionByItk_n(oldSegAtTimeStep, DoITKRegionGrowing, 3, (previewImage, this->m_PointSet, timeStep, oldSegAtTimeStep->GetGeometry(), this->GetUserDefinedActiveLabel(), backgroundValue));
     }
     else
     {
       this->ResetPreviewNode();
     }
   }
 }