diff --git a/Modules/Segmentation/Interactions/mitkAdaptiveRegionGrowingTool.cpp b/Modules/Segmentation/Interactions/mitkAdaptiveRegionGrowingTool.cpp
index d4a109ccfe..579561cfd0 100644
--- a/Modules/Segmentation/Interactions/mitkAdaptiveRegionGrowingTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkAdaptiveRegionGrowingTool.cpp
@@ -1,120 +1,120 @@
 /*============================================================================
 
 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 "mitkAdaptiveRegionGrowingTool.h"
 #include "mitkImage.h"
 #include "mitkProperties.h"
 #include "mitkToolManager.h"
 // us
 #include <usGetModuleContext.h>
 #include <usModule.h>
 #include <usModuleContext.h>
 #include <usModuleResource.h>
 
 namespace mitk
 {
   MITK_TOOL_MACRO(MITKSEGMENTATION_EXPORT, AdaptiveRegionGrowingTool, "AdaptiveRegionGrowingTool");
 }
 
 mitk::AdaptiveRegionGrowingTool::AdaptiveRegionGrowingTool()
 {
   m_PointSetNode = mitk::DataNode::New();
   m_PointSetNode->GetPropertyList()->SetProperty("name", mitk::StringProperty::New("3D_Regiongrowing_Seedpoint"));
   m_PointSetNode->GetPropertyList()->SetProperty("helper object", mitk::BoolProperty::New(true));
   m_PointSet = mitk::PointSet::New();
   m_PointSetNode->SetData(m_PointSet);
 }
 
 mitk::AdaptiveRegionGrowingTool::~AdaptiveRegionGrowingTool()
 {
 }
 
 bool mitk::AdaptiveRegionGrowingTool::CanHandle(const BaseData* referenceData, const BaseData* /*workingData*/) const
 {
   if (referenceData == nullptr)
     return false;
 
   auto *image = dynamic_cast<const Image *>(referenceData);
 
   if (image == nullptr)
     return false;
 
   if (image->GetDimension() < 3)
     return false;
 
   if (image->GetTimeSteps() > 1) //release quickfix for T28275
     return false;
 
   return true;
 }
 
 const char **mitk::AdaptiveRegionGrowingTool::GetXPM() const
 {
   return nullptr;
 }
 
 const char *mitk::AdaptiveRegionGrowingTool::GetName() const
 {
   return "Region Growing 3D";
 }
 
 us::ModuleResource mitk::AdaptiveRegionGrowingTool::GetIconResource() const
 {
   us::Module *module = us::GetModuleContext()->GetModule();
   us::ModuleResource resource = module->GetResource("RegionGrowing_48x48.png");
   return resource;
 }
 
 void mitk::AdaptiveRegionGrowingTool::Activated()
 {
   Superclass::Activated();
 
   if (!GetDataStorage()->Exists(m_PointSetNode))
     GetDataStorage()->Add(m_PointSetNode, GetWorkingData());
   m_SeedPointInteractor = mitk::SinglePointDataInteractor::New();
   m_SeedPointInteractor->LoadStateMachine("PointSet.xml");
   m_SeedPointInteractor->SetEventConfig("PointSetConfig.xml");
   m_SeedPointInteractor->SetDataNode(m_PointSetNode);
 }
 
 void mitk::AdaptiveRegionGrowingTool::Deactivated()
 {
   m_PointSet->Clear();
   GetDataStorage()->Remove(m_PointSetNode);
 
   Superclass::Deactivated();
 }
 
 void mitk::AdaptiveRegionGrowingTool::ConfirmSegmentation()
 {
-  m_ToolManager->ActivateTool(-1);
+  this->GetToolManager()->ActivateTool(-1);
 }
 
 mitk::DataNode *mitk::AdaptiveRegionGrowingTool::GetReferenceData()
 {
-  return this->m_ToolManager->GetReferenceData(0);
+  return this->GetToolManager()->GetReferenceData(0);
 }
 
 mitk::DataStorage *mitk::AdaptiveRegionGrowingTool::GetDataStorage()
 {
-  return this->m_ToolManager->GetDataStorage();
+  return this->GetToolManager()->GetDataStorage();
 }
 
 mitk::DataNode *mitk::AdaptiveRegionGrowingTool::GetWorkingData()
 {
-  return this->m_ToolManager->GetWorkingData(0);
+  return this->GetToolManager()->GetWorkingData(0);
 }
 
 mitk::DataNode::Pointer mitk::AdaptiveRegionGrowingTool::GetPointSetNode()
 {
   return m_PointSetNode;
 }
diff --git a/Modules/Segmentation/Interactions/mitkAutoSegmentationTool.cpp b/Modules/Segmentation/Interactions/mitkAutoSegmentationTool.cpp
index 647fa8b80d..a206b7c65e 100644
--- a/Modules/Segmentation/Interactions/mitkAutoSegmentationTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkAutoSegmentationTool.cpp
@@ -1,130 +1,130 @@
 /*============================================================================
 
 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 "mitkAutoSegmentationTool.h"
 #include "mitkImage.h"
 #include "mitkToolManager.h"
 #include <mitkImageTimeSelector.h>
 
 mitk::AutoSegmentationTool::AutoSegmentationTool() : Tool("dummy"), m_OverwriteExistingSegmentation(false)
 {
 }
 
 mitk::AutoSegmentationTool::AutoSegmentationTool(const char* interactorType, const us::Module* interactorModule) : Tool(interactorType, interactorModule), m_OverwriteExistingSegmentation(false)
 {
 }
 
 mitk::AutoSegmentationTool::~AutoSegmentationTool()
 {
 }
 
 void mitk::AutoSegmentationTool::Activated()
 {
   Superclass::Activated();
 
   m_NoneOverwriteTargetSegmentationNode = nullptr;
 }
 
 void mitk::AutoSegmentationTool::Deactivated()
 {
   m_NoneOverwriteTargetSegmentationNode = nullptr;
 
   Superclass::Deactivated();
 }
 
 const char *mitk::AutoSegmentationTool::GetGroup() const
 {
   return "autoSegmentation";
 }
 
 mitk::Image::ConstPointer mitk::AutoSegmentationTool::GetImageByTimeStep(const mitk::Image* image, unsigned int timestep)
 {
   if (nullptr == image)
     return image;
 
   if (image->GetDimension() != 4)
     return image;
 
   mitk::ImageTimeSelector::Pointer imageTimeSelector = mitk::ImageTimeSelector::New();
 
   imageTimeSelector->SetInput(image);
   imageTimeSelector->SetTimeNr(static_cast<int>(timestep));
 
   imageTimeSelector->UpdateLargestPossibleRegion();
 
   return imageTimeSelector->GetOutput();
 }
 
 mitk::Image::ConstPointer mitk::AutoSegmentationTool::GetImageByTimePoint(const mitk::Image* image, TimePointType timePoint)
 {
   if (nullptr == image)
     return image;
 
   if (!image->GetTimeGeometry()->IsValidTimePoint(timePoint))
     return nullptr;
 
   return AutoSegmentationTool::GetImageByTimeStep(image, image->GetTimeGeometry()->TimePointToTimeStep(timePoint));
 }
 
 void mitk::AutoSegmentationTool::SetOverwriteExistingSegmentation(bool overwrite)
 {
   if (m_OverwriteExistingSegmentation != overwrite)
   {
     m_OverwriteExistingSegmentation = overwrite;
     m_NoneOverwriteTargetSegmentationNode = nullptr;
   }
 }
 
 std::string mitk::AutoSegmentationTool::GetCurrentSegmentationName()
 {
-  if (m_ToolManager->GetWorkingData(0))
-    return m_ToolManager->GetWorkingData(0)->GetName();
+  if (this->GetToolManager()->GetWorkingData(0))
+    return this->GetToolManager()->GetWorkingData(0)->GetName();
   else
     return "";
 }
 
 mitk::DataNode *mitk::AutoSegmentationTool::GetTargetSegmentationNode() const
 {
-  mitk::DataNode::Pointer segmentationNode = m_ToolManager->GetWorkingData(0);
+  mitk::DataNode::Pointer segmentationNode = this->GetToolManager()->GetWorkingData(0);
   if (!m_OverwriteExistingSegmentation)
   {
     if (m_NoneOverwriteTargetSegmentationNode.IsNull())
     {
-      mitk::DataNode::Pointer refNode = m_ToolManager->GetReferenceData(0);
+      mitk::DataNode::Pointer refNode = this->GetToolManager()->GetReferenceData(0);
       if (refNode.IsNull())
       {
         // TODO create and use segmentation exceptions instead!!
         MITK_ERROR << "No valid reference data!";
         return nullptr;
       }
 
       std::string nodename = refNode->GetName() + "_" + this->GetName();
       mitk::Color color;
       color.SetRed(1);
       color.SetBlue(0);
       color.SetGreen(0);
       //create a new segmentation node based on the current segmentation as template
       m_NoneOverwriteTargetSegmentationNode = CreateEmptySegmentationNode(dynamic_cast<mitk::Image*>(segmentationNode->GetData()), nodename, color);
     }
     segmentationNode = m_NoneOverwriteTargetSegmentationNode;
   }
   return segmentationNode;
 }
 
 void mitk::AutoSegmentationTool::EnsureTargetSegmentationNodeInDataStorage() const
 {
   auto targetNode = this->GetTargetSegmentationNode();
-  if (!m_ToolManager->GetDataStorage()->Exists(targetNode))
+  if (!this->GetToolManager()->GetDataStorage()->Exists(targetNode))
   {
-    m_ToolManager->GetDataStorage()->Add(targetNode, m_ToolManager->GetReferenceData(0));
+    this->GetToolManager()->GetDataStorage()->Add(targetNode, this->GetToolManager()->GetReferenceData(0));
   }
 }
diff --git a/Modules/Segmentation/Interactions/mitkCalculateGrayValueStatisticsTool.cpp b/Modules/Segmentation/Interactions/mitkCalculateGrayValueStatisticsTool.cpp
index 18db43a60a..77eae790c0 100644
--- a/Modules/Segmentation/Interactions/mitkCalculateGrayValueStatisticsTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkCalculateGrayValueStatisticsTool.cpp
@@ -1,332 +1,332 @@
 /*============================================================================
 
 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 "mitkCalculateGrayValueStatisticsTool.h"
 
 #include "mitkCalculateGrayValueStatisticsTool.xpm"
 
 #include "mitkImageAccessByItk.h"
 #include "mitkImageCast.h"
 #include "mitkImageTimeSelector.h"
 #include "mitkProgressBar.h"
 #include "mitkStatusBar.h"
 #include "mitkToolManager.h"
 
 #include <itkCommand.h>
 
 #include <itkHistogram.h>
 
 namespace mitk
 {
   MITK_TOOL_MACRO(MITKSEGMENTATION_EXPORT, CalculateGrayValueStatisticsTool, "Statistics tool");
 }
 
 mitk::CalculateGrayValueStatisticsTool::CalculateGrayValueStatisticsTool()
 {
 }
 
 mitk::CalculateGrayValueStatisticsTool::~CalculateGrayValueStatisticsTool()
 {
 }
 
 const char **mitk::CalculateGrayValueStatisticsTool::GetXPM() const
 {
   return mitkCalculateGrayValueStatisticsTool_xpm;
 }
 
 const char *mitk::CalculateGrayValueStatisticsTool::GetName() const
 {
   return "Statistics";
 }
 
 std::string mitk::CalculateGrayValueStatisticsTool::GetErrorMessage()
 {
   return "No statistics generated for these segmentations:";
 }
 
 void mitk::CalculateGrayValueStatisticsTool::StartProcessingAllData()
 {
   // clear/prepare report
   m_CompleteReport.str("");
 }
 
 bool mitk::CalculateGrayValueStatisticsTool::ProcessOneWorkingData(DataNode *node)
 {
   if (node)
   {
     Image::Pointer image = dynamic_cast<Image *>(node->GetData());
     if (image.IsNull())
       return false;
 
-    DataNode *referencenode = m_ToolManager->GetReferenceData(0);
+    DataNode *referencenode = this->GetToolManager()->GetReferenceData(0);
     if (!referencenode)
       return false;
 
     try
     {
       ProgressBar::GetInstance()->AddStepsToDo(1);
 
       // add to report
       std::string nodename("structure");
       node->GetName(nodename);
 
       std::string message = "Calculating statistics for ";
       message += nodename;
 
       StatusBar::GetInstance()->DisplayText(message.c_str());
 
       Image::Pointer refImage = dynamic_cast<Image *>(referencenode->GetData());
       Image::Pointer image = dynamic_cast<Image *>(node->GetData());
 
       m_CompleteReport << "======== Gray value analysis of " << nodename << " ========\n";
 
       if (image.IsNotNull() && refImage.IsNotNull())
       {
         for (unsigned int timeStep = 0; timeStep < image->GetTimeSteps(); ++timeStep)
         {
           ImageTimeSelector::Pointer timeSelector = ImageTimeSelector::New();
           timeSelector->SetInput(refImage);
           timeSelector->SetTimeNr(timeStep);
           timeSelector->UpdateLargestPossibleRegion();
           Image::Pointer refImage3D = timeSelector->GetOutput();
 
           ImageTimeSelector::Pointer timeSelector2 = ImageTimeSelector::New();
           timeSelector2->SetInput(image);
           timeSelector2->SetTimeNr(timeStep);
           timeSelector2->UpdateLargestPossibleRegion();
           Image::Pointer image3D = timeSelector2->GetOutput();
 
           if (image3D.IsNotNull() && refImage3D.IsNotNull())
           {
             m_CompleteReport << "=== " << nodename << ", time step " << timeStep << " ===\n";
             AccessFixedDimensionByItk_2(refImage3D, ITKHistogramming, 3, image3D, m_CompleteReport);
           }
         }
       }
 
       m_CompleteReport << "======== End of analysis for " << nodename << " ===========\n\n\n";
 
       ProgressBar::GetInstance()->Progress();
     }
     catch (...)
     {
       return false;
     }
   }
 
   return true;
 }
 
 void mitk::CalculateGrayValueStatisticsTool::FinishProcessingAllData()
 {
   SegmentationsProcessingTool::FinishProcessingAllData();
 
   // show/send results
   StatisticsCompleted.Send();
   // MITK_INFO << m_CompleteReport.str() << std::endl;
 }
 
 #define ROUND_P(x) ((int)((x) + 0.5))
 
 template <typename TPixel, unsigned int VImageDimension>
 void mitk::CalculateGrayValueStatisticsTool::CalculateMinMax(itk::Image<TPixel, VImageDimension> *referenceImage,
                                                              Image *segmentation,
                                                              TPixel &minimum,
                                                              TPixel &maximum)
 {
   typedef itk::Image<TPixel, VImageDimension> ImageType;
   typedef itk::Image<Tool::DefaultSegmentationDataType, VImageDimension> SegmentationType;
 
   typename SegmentationType::Pointer segmentationItk;
   CastToItkImage(segmentation, segmentationItk);
 
   typename SegmentationType::RegionType segmentationRegion = segmentationItk->GetLargestPossibleRegion();
 
   segmentationRegion.Crop(referenceImage->GetLargestPossibleRegion());
 
   itk::ImageRegionConstIteratorWithIndex<SegmentationType> segmentationIterator(segmentationItk, segmentationRegion);
   itk::ImageRegionConstIteratorWithIndex<ImageType> referenceIterator(referenceImage, segmentationRegion);
 
   segmentationIterator.GoToBegin();
   referenceIterator.GoToBegin();
 
   minimum = std::numeric_limits<TPixel>::max();
   maximum = std::numeric_limits<TPixel>::min();
 
   while (!segmentationIterator.IsAtEnd())
   {
     itk::Point<float, 3> pt;
     segmentationItk->TransformIndexToPhysicalPoint(segmentationIterator.GetIndex(), pt);
 
     typename ImageType::IndexType ind;
     itk::ContinuousIndex<float, 3> contInd;
     if (referenceImage->TransformPhysicalPointToContinuousIndex(pt, contInd))
     {
       for (unsigned int i = 0; i < 3; ++i)
         ind[i] = ROUND_P(contInd[i]);
 
       referenceIterator.SetIndex(ind);
 
       if (segmentationIterator.Get() > 0)
       {
         if (referenceIterator.Get() < minimum)
           minimum = referenceIterator.Get();
         if (referenceIterator.Get() > maximum)
           maximum = referenceIterator.Get();
       }
     }
 
     ++segmentationIterator;
   }
 }
 
 template <typename TPixel, unsigned int VImageDimension>
 void mitk::CalculateGrayValueStatisticsTool::ITKHistogramming(itk::Image<TPixel, VImageDimension> *referenceImage,
                                                               Image *segmentation,
                                                               std::stringstream &report)
 {
   typedef itk::Image<TPixel, VImageDimension> ImageType;
   typedef itk::Image<Tool::DefaultSegmentationDataType, VImageDimension> SegmentationType;
 
   typename SegmentationType::Pointer segmentationItk;
   CastToItkImage(segmentation, segmentationItk);
 
   // generate histogram
   typename SegmentationType::RegionType segmentationRegion = segmentationItk->GetLargestPossibleRegion();
 
   segmentationRegion.Crop(referenceImage->GetLargestPossibleRegion());
 
   itk::ImageRegionConstIteratorWithIndex<SegmentationType> segmentationIterator(segmentationItk, segmentationRegion);
   itk::ImageRegionConstIteratorWithIndex<ImageType> referenceIterator(referenceImage, segmentationRegion);
 
   segmentationIterator.GoToBegin();
   referenceIterator.GoToBegin();
 
   m_ITKHistogram = HistogramType::New();
 
   TPixel minimum = std::numeric_limits<TPixel>::max();
   TPixel maximum = std::numeric_limits<TPixel>::min();
 
   CalculateMinMax(referenceImage, segmentation, minimum, maximum);
 
   // initialize the histogram to the range of the cropped region
   HistogramType::SizeType size;
 #if defined(ITK_USE_REVIEW_STATISTICS)
   typedef typename HistogramType::SizeType::ValueType HSizeValueType;
 #else
   typedef typename HistogramType::SizeType::SizeValueType HSizeValueType;
 #endif
   size.Fill(static_cast<HSizeValueType>(maximum - minimum + 1));
   HistogramType::MeasurementVectorType lowerBound;
   HistogramType::MeasurementVectorType upperBound;
   lowerBound[0] = minimum;
   upperBound[0] = maximum;
   m_ITKHistogram->Initialize(size, lowerBound, upperBound);
 
   double mean(0.0);
   double sd(0.0);
   double voxelCount(0.0);
 
   // iterate through the cropped region add the values to the histogram
   while (!segmentationIterator.IsAtEnd())
   {
     itk::Point<float, 3> pt;
     segmentationItk->TransformIndexToPhysicalPoint(segmentationIterator.GetIndex(), pt);
 
     typename ImageType::IndexType ind;
     itk::ContinuousIndex<float, 3> contInd;
     if (referenceImage->TransformPhysicalPointToContinuousIndex(pt, contInd))
     {
       for (unsigned int i = 0; i < 3; ++i)
         ind[i] = ROUND_P(contInd[i]);
 
       referenceIterator.SetIndex(ind);
 
       if (segmentationIterator.Get() > 0)
       {
         HistogramType::MeasurementVectorType currentMeasurementVector;
 
         currentMeasurementVector[0] = static_cast<HistogramType::MeasurementType>(referenceIterator.Get());
         m_ITKHistogram->IncreaseFrequencyOfMeasurement(currentMeasurementVector, 1);
 
         mean = (mean * (static_cast<double>(voxelCount) /
                         static_cast<double>(voxelCount + 1))) // 3 points:   old center * 2/3 + currentPoint * 1/3;
                + static_cast<double>(referenceIterator.Get()) / static_cast<double>(voxelCount + 1);
 
         voxelCount += 1.0;
       }
     }
 
     ++segmentationIterator;
   }
 
   // second pass for SD
   segmentationIterator.GoToBegin();
   referenceIterator.GoToBegin();
   while (!segmentationIterator.IsAtEnd())
   {
     itk::Point<float, 3> pt;
     segmentationItk->TransformIndexToPhysicalPoint(segmentationIterator.GetIndex(), pt);
 
     typename ImageType::IndexType ind;
     itk::ContinuousIndex<float, 3> contInd;
     if (referenceImage->TransformPhysicalPointToContinuousIndex(pt, contInd))
     {
       for (unsigned int i = 0; i < 3; ++i)
         ind[i] = ROUND_P(contInd[i]);
 
       referenceIterator.SetIndex(ind);
 
       if (segmentationIterator.Get() > 0)
       {
         sd += ((static_cast<double>(referenceIterator.Get()) - mean) *
                (static_cast<double>(referenceIterator.Get()) - mean));
       }
     }
 
     ++segmentationIterator;
   }
 
   sd /= static_cast<double>(voxelCount - 1);
   sd = sqrt(sd);
 
   // generate quantiles
   TPixel histogramQuantileValues[5];
   histogramQuantileValues[0] = m_ITKHistogram->Quantile(0, 0.05);
   histogramQuantileValues[1] = m_ITKHistogram->Quantile(0, 0.25);
   histogramQuantileValues[2] = m_ITKHistogram->Quantile(0, 0.50);
   histogramQuantileValues[3] = m_ITKHistogram->Quantile(0, 0.75);
   histogramQuantileValues[4] = m_ITKHistogram->Quantile(0, 0.95);
 
   // report histogram values
   std::locale C("C");
   std::locale originalLocale = report.getloc();
   report.imbue(C);
 
   report << "         Minimum:" << minimum << "\n  5% quantile: " << histogramQuantileValues[0]
          << "\n 25% quantile: " << histogramQuantileValues[1] << "\n 50% quantile: " << histogramQuantileValues[2]
          << "\n 75% quantile: " << histogramQuantileValues[3] << "\n 95% quantile: " << histogramQuantileValues[4]
          << "\n      Maximum: " << maximum << "\n         Mean: " << mean << "\n           SD: " << sd << "\n";
 
   report.imbue(originalLocale);
 }
 
 std::string mitk::CalculateGrayValueStatisticsTool::GetReport() const
 {
   return m_CompleteReport.str();
 }
 
 mitk::CalculateGrayValueStatisticsTool::HistogramType::ConstPointer
   mitk::CalculateGrayValueStatisticsTool::GetHistogram()
 {
   return m_ITKHistogram.GetPointer();
 }
diff --git a/Modules/Segmentation/Interactions/mitkCalculateVolumetryTool.cpp b/Modules/Segmentation/Interactions/mitkCalculateVolumetryTool.cpp
index 57e1e69a67..f5b53f6c3a 100644
--- a/Modules/Segmentation/Interactions/mitkCalculateVolumetryTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkCalculateVolumetryTool.cpp
@@ -1,86 +1,86 @@
 /*============================================================================
 
 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 "mitkCalculateVolumetryTool.h"
 
 #include "mitkCalculateVolumetryTool.xpm"
 
 #include "mitkProperties.h"
 #include "mitkToolManager.h"
 #include "mitkVolumeCalculator.h"
 
 namespace mitk
 {
   MITK_TOOL_MACRO(MITKSEGMENTATION_EXPORT, CalculateVolumetryTool, "Volumetry tool");
 }
 
 mitk::CalculateVolumetryTool::CalculateVolumetryTool()
 {
 }
 
 mitk::CalculateVolumetryTool::~CalculateVolumetryTool()
 {
 }
 
 const char **mitk::CalculateVolumetryTool::GetXPM() const
 {
   return mitkCalculateVolumetryTool_xpm;
 }
 
 const char *mitk::CalculateVolumetryTool::GetName() const
 {
   return "Volumetry";
 }
 
 std::string mitk::CalculateVolumetryTool::GetErrorMessage()
 {
   return "Volume could not be calculated for these nodes:";
 }
 
 bool mitk::CalculateVolumetryTool::ProcessOneWorkingData(DataNode *node)
 {
   if (node)
   {
     Image::Pointer image = dynamic_cast<Image *>(node->GetData());
     if (image.IsNull())
       return false;
 
     if (image->GetDimension() == 4)
     {
       Tool::ErrorMessage("Volumetry only valid for timestep 0! Bug #1280");
     }
 
     VolumeCalculator::Pointer volumetryFilter = VolumeCalculator::New();
     volumetryFilter->SetImage(image);
     volumetryFilter->SetThreshold(1); // comparison is >=
     try
     {
       volumetryFilter->ComputeVolume();
 
       float volumeInTimeStep0 = volumetryFilter->GetVolume();
 
       node->SetProperty("volume", FloatProperty::New(volumeInTimeStep0));
     }
     catch (...)
     {
       return false;
     }
   }
 
   return true;
 }
 
 void mitk::CalculateVolumetryTool::FinishProcessingAllData()
 {
   Superclass::FinishProcessingAllData();
-  m_ToolManager->NodePropertiesChanged();
+  this->GetToolManager()->NodePropertiesChanged();
 }
diff --git a/Modules/Segmentation/Interactions/mitkCreateSurfaceTool.cpp b/Modules/Segmentation/Interactions/mitkCreateSurfaceTool.cpp
index 4fa399745d..0e5bcfbe90 100644
--- a/Modules/Segmentation/Interactions/mitkCreateSurfaceTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkCreateSurfaceTool.cpp
@@ -1,98 +1,98 @@
 /*============================================================================
 
 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 "mitkCreateSurfaceTool.h"
 
 #include "mitkCreateSurfaceTool.xpm"
 
 #include "mitkProgressBar.h"
 #include "mitkShowSegmentationAsSurface.h"
 #include "mitkStatusBar.h"
 #include "mitkToolManager.h"
 
 #include "itkCommand.h"
 
 namespace mitk
 {
   MITK_TOOL_MACRO(MITKSEGMENTATION_EXPORT, CreateSurfaceTool, "Surface creation tool");
 }
 
 mitk::CreateSurfaceTool::CreateSurfaceTool()
 {
 }
 
 mitk::CreateSurfaceTool::~CreateSurfaceTool()
 {
 }
 
 const char **mitk::CreateSurfaceTool::GetXPM() const
 {
   return mitkCreateSurfaceTool_xpm;
 }
 
 const char *mitk::CreateSurfaceTool::GetName() const
 {
   return "Surface";
 }
 
 std::string mitk::CreateSurfaceTool::GetErrorMessage()
 {
   return "No surfaces created for these segmentations:";
 }
 
 bool mitk::CreateSurfaceTool::ProcessOneWorkingData(DataNode *node)
 {
   if (node)
   {
     Image::Pointer image = dynamic_cast<Image *>(node->GetData());
     if (image.IsNull())
       return false;
 
     try
     {
       mitk::ShowSegmentationAsSurface::Pointer surfaceFilter = mitk::ShowSegmentationAsSurface::New();
 
       // attach observer to get notified about result
       itk::SimpleMemberCommand<CreateSurfaceTool>::Pointer goodCommand =
         itk::SimpleMemberCommand<CreateSurfaceTool>::New();
       goodCommand->SetCallbackFunction(this, &CreateSurfaceTool::OnSurfaceCalculationDone);
       surfaceFilter->AddObserver(mitk::ResultAvailable(), goodCommand);
       itk::SimpleMemberCommand<CreateSurfaceTool>::Pointer badCommand =
         itk::SimpleMemberCommand<CreateSurfaceTool>::New();
       badCommand->SetCallbackFunction(this, &CreateSurfaceTool::OnSurfaceCalculationDone);
       surfaceFilter->AddObserver(mitk::ProcessingError(), badCommand);
 
       DataNode::Pointer nodepointer = node;
       surfaceFilter->SetPointerParameter("Input", image);
       surfaceFilter->SetPointerParameter("Group node", nodepointer);
       surfaceFilter->SetParameter("Show result", true);
       surfaceFilter->SetParameter("Sync visibility", false);
-      surfaceFilter->SetDataStorage(*m_ToolManager->GetDataStorage());
+      surfaceFilter->SetDataStorage(*this->GetToolManager()->GetDataStorage());
 
       ProgressBar::GetInstance()->AddStepsToDo(1);
       StatusBar::GetInstance()->DisplayText("Surface creation started in background...");
       surfaceFilter->StartAlgorithm();
     }
     catch (...)
     {
       return false;
     }
   }
 
   return true;
 }
 
 void mitk::CreateSurfaceTool::OnSurfaceCalculationDone()
 {
   ProgressBar::GetInstance()->Progress();
-  m_ToolManager->NewNodesGenerated();
+  this->GetToolManager()->NewNodesGenerated();
 }
diff --git a/Modules/Segmentation/Interactions/mitkFeedbackContourTool.cpp b/Modules/Segmentation/Interactions/mitkFeedbackContourTool.cpp
index c6eb82b51a..e37f014527 100644
--- a/Modules/Segmentation/Interactions/mitkFeedbackContourTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkFeedbackContourTool.cpp
@@ -1,278 +1,278 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkFeedbackContourTool.h"
 #include "mitkToolManager.h"
 
 #include "mitkColorProperty.h"
 #include "mitkProperties.h"
 #include "mitkStringProperty.h"
 
 #include "mitkBaseRenderer.h"
 #include "mitkDataStorage.h"
 
 #include "mitkRenderingManager.h"
 
 #include "mitkAbstractTransformGeometry.h"
 
 mitk::FeedbackContourTool::FeedbackContourTool(const char *type) : SegTool2D(type), m_FeedbackContourVisible(false)
 {
   m_FeedbackContourNode = DataNode::New();
   m_FeedbackContourNode->SetProperty("name", StringProperty::New("One of FeedbackContourTool's feedback nodes"));
   m_FeedbackContourNode->SetProperty("visible", BoolProperty::New(true));
   m_FeedbackContourNode->SetProperty("helper object", BoolProperty::New(true));
   m_FeedbackContourNode->SetProperty("layer", IntProperty::New(1000));
   m_FeedbackContourNode->SetProperty("contour.project-onto-plane", BoolProperty::New(false));
   m_FeedbackContourNode->SetProperty("contour.width", FloatProperty::New(1.0));
   // set to max short, max int doesn't work, max value somewhere hardcoded?
   m_FeedbackContourNode->SetProperty("layer", IntProperty::New(std::numeric_limits<short>::max()));
   m_FeedbackContourNode->SetProperty("fixedLayer", BoolProperty::New(true));
   this->InitializeFeedbackContour(true);
   SetFeedbackContourColorDefault();
 }
 
 mitk::FeedbackContourTool::~FeedbackContourTool()
 {
 }
 
 void mitk::FeedbackContourTool::SetFeedbackContourColor(float r, float g, float b)
 {
   m_FeedbackContourNode->SetProperty("contour.color", ColorProperty::New(r, g, b));
 }
 
 void mitk::FeedbackContourTool::SetFeedbackContourColorDefault()
 {
   m_FeedbackContourNode->SetProperty("contour.color", ColorProperty::New(0.0 / 255.0, 255.0 / 255.0, 0.0 / 255.0));
 }
 
 void mitk::FeedbackContourTool::Deactivated()
 {
   Superclass::Deactivated();
-  DataStorage *storage = m_ToolManager->GetDataStorage();
+  DataStorage *storage = this->GetToolManager()->GetDataStorage();
   if (storage && m_FeedbackContourNode.IsNotNull())
   {
     storage->Remove(m_FeedbackContourNode);
     m_FeedbackContour->Clear();
     SetFeedbackContourVisible(false);
   }
 }
 
 void mitk::FeedbackContourTool::Activated()
 {
   Superclass::Activated();
   this->InitializeFeedbackContour(true);
   this->SetFeedbackContourVisible(true);
 }
 
 const mitk::ContourModel *mitk::FeedbackContourTool::GetFeedbackContour() const
 {
   return m_FeedbackContour;
 }
 
 void mitk::FeedbackContourTool::InitializeFeedbackContour(bool isClosed)
 {
   m_FeedbackContour = ContourModel::New();
   m_FeedbackContour->SetClosed(isClosed);
 
   auto workingImage = this->GetWorkingData();
 
   if (nullptr != workingImage)
   {
     m_FeedbackContour->Expand(workingImage->GetTimeSteps());
 
     auto contourTimeGeometry = workingImage->GetTimeGeometry()->Clone();
     contourTimeGeometry->ReplaceTimeStepGeometries(m_FeedbackContour->GetGeometry());
     m_FeedbackContour->SetTimeGeometry(contourTimeGeometry);
 
     for (unsigned int t = 0; t < m_FeedbackContour->GetTimeSteps(); ++t)
     {
       m_FeedbackContour->SetClosed(isClosed, t);
     }
   }
 
   m_FeedbackContourNode->SetData(m_FeedbackContour);
 }
 
 void mitk::FeedbackContourTool::ClearsCurrentFeedbackContour(bool isClosed)
 {
   if (!m_FeedbackContour->GetTimeGeometry()->IsValidTimePoint(this->GetLastTimePointTriggered()))
   {
     MITK_WARN << "Cannot clear feedback contour at current time step. Feedback contour is in invalid state as its time geometry does not support current selected time point. Invalid time point: " << this->GetLastTimePointTriggered();
     return;
   }
 
   auto feedbackTimeStep = m_FeedbackContour->GetTimeGeometry()->TimePointToTimeStep(this->GetLastTimePointTriggered());
   m_FeedbackContour->Clear(feedbackTimeStep);
   m_FeedbackContour->SetClosed(isClosed, feedbackTimeStep);
 }
 
 void mitk::FeedbackContourTool::UpdateCurrentFeedbackContour(const ContourModel* sourceModel, TimeStepType sourceTimeStep)
 {
   if (nullptr == sourceModel)
     return;
 
   if (!m_FeedbackContour->GetTimeGeometry()->IsValidTimePoint(this->GetLastTimePointTriggered()))
   {
     MITK_WARN << "Cannot update feedback contour. Feedback contour is in invalid state as its time geometry does not support current selected time point. Invalid time point: "<<this->GetLastTimePointTriggered();
     return;
   }
 
   auto feedbackTimeStep = m_FeedbackContour->GetTimeGeometry()->TimePointToTimeStep(this->GetLastTimePointTriggered());
   this->UpdateFeedbackContour(sourceModel, feedbackTimeStep, sourceTimeStep);
 }
 
 void mitk::FeedbackContourTool::UpdateFeedbackContour(const ContourModel* sourceModel, TimeStepType feedbackTimeStep, TimeStepType sourceTimeStep)
 {
   if (nullptr == sourceModel)
     return;
 
   if (!sourceModel->GetTimeGeometry()->IsValidTimeStep(sourceTimeStep))
   {
     MITK_WARN << "Cannot update feedback contour. Source contour time geometry does not support passed time step. Invalid time step: " << sourceTimeStep;
     return;
   }
 
   if (!m_FeedbackContour->GetTimeGeometry()->IsValidTimeStep(feedbackTimeStep))
   {
     MITK_WARN << "Cannot update feedback contour. Feedback contour time geometry does not support passed time step. Invalid time step: "<<feedbackTimeStep;
     return;
   }
 
   m_FeedbackContour->UpdateContour(sourceModel, feedbackTimeStep, sourceTimeStep);
 }
 
 void mitk::FeedbackContourTool::AddVertexToCurrentFeedbackContour(const Point3D& point)
 {
   if (!m_FeedbackContour->GetTimeGeometry()->IsValidTimePoint(this->GetLastTimePointTriggered()))
   {
     MITK_WARN << "Cannot add vertex to feedback contour. Feedback contour is in invalid state as its time geometry does not support current selected time point. Invalid time point: " << this->GetLastTimePointTriggered();
     return;
   }
 
   auto feedbackTimeStep = m_FeedbackContour->GetTimeGeometry()->TimePointToTimeStep(this->GetLastTimePointTriggered());
   this->AddVertexToFeedbackContour(point, feedbackTimeStep);
 };
 
 /** Adds a vertex to the feedback contour for the passed time step. If time step is invalid, nothing will be added.*/
 void mitk::FeedbackContourTool::AddVertexToFeedbackContour(const Point3D& point, TimeStepType feedbackTimeStep)
 {
   if (!m_FeedbackContour->GetTimeGeometry()->IsValidTimeStep(feedbackTimeStep))
   {
     MITK_WARN << "Cannot add vertex to feedback contour. Feedback contour time geometry does not support passed time step. Invalid time step: " << feedbackTimeStep;
     return;
   }
 
   m_FeedbackContour->AddVertex(point, feedbackTimeStep);
 }
 
 
 void mitk::FeedbackContourTool::SetFeedbackContourVisible(bool visible)
 {
   if (m_FeedbackContourVisible == visible)
     return; // nothing changed
 
-  if (DataStorage *storage = m_ToolManager->GetDataStorage())
+  if (DataStorage *storage = this->GetToolManager()->GetDataStorage())
   {
     if (visible)
     {
       // Add the feedback contour node as a derived node of the first working data.
       // If there is no working data, the node is added at the top level.
       storage->Add(m_FeedbackContourNode, this->GetWorkingDataNode());
     }
     else
     {
       storage->Remove(m_FeedbackContourNode);
     }
   }
 
   m_FeedbackContourVisible = visible;
 }
 
 mitk::ContourModel::Pointer mitk::FeedbackContourTool::ProjectContourTo2DSlice(const Image *slice,
                                                                                const ContourModel *contourIn3D,
                                                                                bool correctionForIpSegmentation,
                                                                                bool constrainToInside)
 {
   return mitk::ContourModelUtils::ProjectContourTo2DSlice(
     slice, contourIn3D, correctionForIpSegmentation, constrainToInside);
 }
 
 mitk::ContourModel::Pointer mitk::FeedbackContourTool::BackProjectContourFrom2DSlice(const BaseGeometry *sliceGeometry,
                                                                                      const ContourModel *contourIn2D,
                                                                                      bool correctionForIpSegmentation)
 {
   return mitk::ContourModelUtils::BackProjectContourFrom2DSlice(
     sliceGeometry, contourIn2D, correctionForIpSegmentation);
 }
 
 void mitk::FeedbackContourTool::WriteBackFeedbackContourAsSegmentationResult(const InteractionPositionEvent* positionEvent, int paintingPixelValue, bool setInvisibleAfterSuccess)
 {
   if (!positionEvent)
     return;
 
   auto workingImage = this->GetWorkingData();
   const auto planeGeometry((positionEvent->GetSender()->GetCurrentWorldPlaneGeometry()));
 
   if (!workingImage || !planeGeometry)
     return;
 
   const auto* abstractTransformGeometry(
     dynamic_cast<const AbstractTransformGeometry*>(positionEvent->GetSender()->GetCurrentWorldPlaneGeometry()));
   if (nullptr != abstractTransformGeometry)
     return;
 
   Image::Pointer slice = FeedbackContourTool::GetAffectedWorkingSlice(positionEvent);
 
   if (slice.IsNull())
   {
     MITK_ERROR << "Unable to extract slice." << std::endl;
     return;
   }
 
   const auto feedbackContour = FeedbackContourTool::GetFeedbackContour();
   auto contourTimeStep = positionEvent->GetSender()->GetTimeStep(feedbackContour);
 
   ContourModel::Pointer projectedContour = FeedbackContourTool::ProjectContourTo2DSlice(
     slice, feedbackContour, false, false); // false: don't add 0.5 (done by FillContourInSlice)
   // false: don't constrain the contour to the image's inside
 
   if (projectedContour.IsNull())
     return;
 
   auto activePixelValue = ContourModelUtils::GetActivePixelValue(workingImage);
 
   mitk::ContourModelUtils::FillContourInSlice(
     projectedContour, contourTimeStep, slice, workingImage, paintingPixelValue * activePixelValue);
 
   this->WriteBackSegmentationResult(positionEvent, slice);
 
   if (setInvisibleAfterSuccess)
   {
     this->SetFeedbackContourVisible(false);
   }
 }
 
 
 void mitk::FeedbackContourTool::FillContourInSlice(ContourModel *projectedContour,
                                                    Image *sliceImage,
                                                    int paintingPixelValue)
 {
   this->FillContourInSlice(projectedContour, 0, sliceImage, paintingPixelValue);
 }
 
 void mitk::FeedbackContourTool::FillContourInSlice(ContourModel *projectedContour,
                                                    unsigned int timeStep,
                                                    Image *sliceImage,
                                                    int paintingPixelValue)
 {
   mitk::ContourModelUtils::FillContourInSlice(projectedContour, timeStep, sliceImage, sliceImage, paintingPixelValue);
 }
diff --git a/Modules/Segmentation/Interactions/mitkLiveWireTool2D.cpp b/Modules/Segmentation/Interactions/mitkLiveWireTool2D.cpp
index 5870887320..9ba41907cd 100644
--- a/Modules/Segmentation/Interactions/mitkLiveWireTool2D.cpp
+++ b/Modules/Segmentation/Interactions/mitkLiveWireTool2D.cpp
@@ -1,620 +1,620 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include <mitkContourModelUtils.h>
 #include <mitkLiveWireTool2D.h>
 #include <mitkLiveWireTool2D.xpm>
 #include <mitkToolManager.h>
 
 #include <usGetModuleContext.h>
 #include <usModuleResource.h>
 
 #include <type_traits>
 
 namespace mitk
 {
   MITK_TOOL_MACRO(MITKSEGMENTATION_EXPORT, LiveWireTool2D, "LiveWire tool");
 }
 
 mitk::LiveWireTool2D::LiveWireTool2D()
   : SegTool2D("LiveWireTool"), m_CreateAndUseDynamicCosts(false)
 {
 }
 
 mitk::LiveWireTool2D::~LiveWireTool2D()
 {
   this->ClearSegmentation();
 }
 
 void mitk::LiveWireTool2D::RemoveHelperObjects()
 {
-  auto dataStorage = m_ToolManager->GetDataStorage();
+  auto dataStorage = this->GetToolManager()->GetDataStorage();
 
   if (nullptr == dataStorage)
     return;
 
   for (const auto &editingContour : m_EditingContours)
     dataStorage->Remove(editingContour.first);
 
   for (const auto &workingContour : m_WorkingContours)
     dataStorage->Remove(workingContour.first);
 
   if (m_EditingContourNode.IsNotNull())
     dataStorage->Remove(m_EditingContourNode);
 
   if (m_LiveWireContourNode.IsNotNull())
     dataStorage->Remove(m_LiveWireContourNode);
 
   if (m_ContourNode.IsNotNull())
     dataStorage->Remove(m_ContourNode);
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void mitk::LiveWireTool2D::ReleaseHelperObjects()
 {
   this->RemoveHelperObjects();
 
   m_EditingContours.clear();
   m_WorkingContours.clear();
 
   m_EditingContourNode = nullptr;
   m_EditingContour = nullptr;
 
   m_LiveWireContourNode = nullptr;
   m_LiveWireContour = nullptr;
 
   m_ContourNode = nullptr;
   m_Contour = nullptr;
 }
 
 void mitk::LiveWireTool2D::ReleaseInteractors()
 {
   this->EnableContourLiveWireInteraction(false);
   m_LiveWireInteractors.clear();
 }
 
 void mitk::LiveWireTool2D::ConnectActionsAndFunctions()
 {
   CONNECT_CONDITION("CheckContourClosed", OnCheckPoint);
 
   CONNECT_FUNCTION("InitObject", OnInitLiveWire);
   CONNECT_FUNCTION("AddPoint", OnAddPoint);
   CONNECT_FUNCTION("CtrlAddPoint", OnAddPoint);
   CONNECT_FUNCTION("MovePoint", OnMouseMoveNoDynamicCosts);
   CONNECT_FUNCTION("FinishContour", OnFinish);
   CONNECT_FUNCTION("DeletePoint", OnLastSegmentDelete);
   CONNECT_FUNCTION("CtrlMovePoint", OnMouseMoved);
 }
 
 const char **mitk::LiveWireTool2D::GetXPM() const
 {
   return mitkLiveWireTool2D_xpm;
 }
 
 us::ModuleResource mitk::LiveWireTool2D::GetIconResource() const
 {
   return us::GetModuleContext()->GetModule()->GetResource("LiveWire_48x48.png");
 }
 
 us::ModuleResource mitk::LiveWireTool2D::GetCursorIconResource() const
 {
   return us::GetModuleContext()->GetModule()->GetResource("LiveWire_Cursor_32x32.png");
 }
 
 const char *mitk::LiveWireTool2D::GetName() const
 {
   return "Live Wire";
 }
 
 void mitk::LiveWireTool2D::Activated()
 {
   Superclass::Activated();
   this->ResetToStartState();
   this->EnableContourLiveWireInteraction(true);
 }
 
 void mitk::LiveWireTool2D::Deactivated()
 {
   this->ConfirmSegmentation();
   Superclass::Deactivated();
 }
 
 void mitk::LiveWireTool2D::UpdateLiveWireContour()
 {
   if (m_Contour.IsNotNull())
   {
     auto timeGeometry = m_Contour->GetTimeGeometry()->Clone();
     m_LiveWireContour = this->m_LiveWireFilter->GetOutput();
     m_LiveWireContour->SetTimeGeometry(timeGeometry); //needed because the results of the filter are always from 0 ms to 1 ms and the filter also resets its outputs.
     m_LiveWireContourNode->SetData(this->m_LiveWireContour);
   }
 }
 
 void mitk::LiveWireTool2D::OnTimePointChanged()
 {
   auto reference = this->GetReferenceData();
   if (nullptr == reference || m_PlaneGeometry.IsNull() || m_LiveWireFilter.IsNull() || m_LiveWireContourNode.IsNull())
     return;
 
   auto timeStep = reference->GetTimeGeometry()->TimePointToTimeStep(this->GetLastTimePointTriggered());
 
   m_ReferenceDataSlice = GetAffectedImageSliceAs2DImageByTimePoint(m_PlaneGeometry, reference, timeStep);
   m_LiveWireFilter->SetInput(m_ReferenceDataSlice);
 
   m_LiveWireFilter->Update();
 
   this->UpdateLiveWireContour();
 
   RenderingManager::GetInstance()->RequestUpdateAll();
 };
 
 
 void mitk::LiveWireTool2D::EnableContourLiveWireInteraction(bool on)
 {
   for (const auto &interactor : m_LiveWireInteractors)
     interactor->EnableInteraction(on);
 }
 
 void mitk::LiveWireTool2D::ConfirmSegmentation()
 {
   auto referenceImage = this->GetReferenceData();
   auto workingImage = this->GetWorkingData();
 
   if (nullptr != referenceImage && nullptr != workingImage)
   {
     std::vector<SliceInformation> sliceInfos;
     sliceInfos.reserve(m_WorkingContours.size());
 
     const auto currentTimePoint = mitk::RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint();
     TimeStepType workingImageTimeStep = workingImage->GetTimeGeometry()->TimePointToTimeStep(currentTimePoint);
 
     for (const auto &workingContour : m_WorkingContours)
     {
       auto contour = dynamic_cast<ContourModel *>(workingContour.first->GetData());
 
       if (nullptr == contour || contour->IsEmpty())
         continue;
 
       auto sameSlicePredicate = [&workingContour, workingImageTimeStep](const SliceInformation& si) { return workingContour.second->IsOnPlane(si.plane) && workingImageTimeStep == si.timestep; };
 
       auto finding = std::find_if(sliceInfos.begin(), sliceInfos.end(), sameSlicePredicate);
       if (finding == sliceInfos.end())
       {
         auto workingSlice = this->GetAffectedImageSliceAs2DImage(workingContour.second, workingImage, workingImageTimeStep)->Clone();
         sliceInfos.emplace_back(workingSlice, workingContour.second, workingImageTimeStep);
         finding = std::prev(sliceInfos.end());
       }
 
       //cast const away is OK in this case, because these are all slices created and manipulated
       //localy in this function call. And we want to keep the high constness of SliceInformation for
       //public interfaces.
       auto workingSlice = const_cast<Image*>(finding->slice.GetPointer());
 
       auto projectedContour = ContourModelUtils::ProjectContourTo2DSlice(workingSlice, contour, true, false);
       int activePixelValue = ContourModelUtils::GetActivePixelValue(workingImage);
 
       ContourModelUtils::FillContourInSlice(
         projectedContour, workingSlice, workingImage, activePixelValue);
     }
 
     this->WriteBackSegmentationResults(sliceInfos);
   }
 
   this->ClearSegmentation();
 }
 
 void mitk::LiveWireTool2D::ClearSegmentation()
 {
   this->ReleaseHelperObjects();
   this->ReleaseInteractors();
   this->ResetToStartState();
 }
 
 bool mitk::LiveWireTool2D::IsPositionEventInsideImageRegion(mitk::InteractionPositionEvent *positionEvent,
                                                             mitk::BaseData *data)
 {
   bool isPositionEventInsideImageRegion = nullptr != data && data->GetGeometry()->IsInside(positionEvent->GetPositionInWorld());
 
   if (!isPositionEventInsideImageRegion)
     MITK_WARN("LiveWireTool2D") << "PositionEvent is outside ImageRegion!";
 
   return isPositionEventInsideImageRegion;
 }
 
 mitk::ContourModel::Pointer mitk::LiveWireTool2D::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::LiveWireTool2D::OnInitLiveWire(StateMachineAction *, InteractionEvent *interactionEvent)
 {
   auto positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
 
   if (nullptr == positionEvent)
     return;
 
   auto workingDataNode = this->GetWorkingDataNode();
 
   if (!IsPositionEventInsideImageRegion(positionEvent, workingDataNode->GetData()))
   {
     this->ResetToStartState();
     return;
   }
 
   m_LastEventSender = positionEvent->GetSender();
   m_LastEventSlice = m_LastEventSender->GetSlice();
 
   m_Contour = this->CreateNewContour();
   m_ContourNode = mitk::DataNode::New();
   m_ContourNode->SetData(m_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_LiveWireContour = this->CreateNewContour();
   m_LiveWireContourNode = mitk::DataNode::New();
   m_LiveWireContourNode->SetData(m_LiveWireContour);
   m_LiveWireContourNode->SetName("active livewire node");
   m_LiveWireContourNode->SetProperty("layer", IntProperty::New(101));
   m_LiveWireContourNode->AddProperty("fixedLayer", BoolProperty::New(true));
   m_LiveWireContourNode->SetProperty("helper object", mitk::BoolProperty::New(true));
   m_LiveWireContourNode->AddProperty("contour.color", ColorProperty::New(0.1f, 1.0f, 0.1f), nullptr, true);
   m_LiveWireContourNode->AddProperty("contour.width", mitk::FloatProperty::New(4.0f), nullptr, true);
 
   m_EditingContour = this->CreateNewContour();
   m_EditingContourNode = mitk::DataNode::New();
   m_EditingContourNode->SetData(m_EditingContour);
   m_EditingContourNode->SetName("editing node");
   m_EditingContourNode->SetProperty("layer", IntProperty::New(102));
   m_EditingContourNode->AddProperty("fixedLayer", BoolProperty::New(true));
   m_EditingContourNode->SetProperty("helper object", mitk::BoolProperty::New(true));
   m_EditingContourNode->AddProperty("contour.color", ColorProperty::New(0.1f, 1.0f, 0.1f), nullptr, true);
   m_EditingContourNode->AddProperty("contour.points.color", ColorProperty::New(0.0f, 0.0f, 1.0f), nullptr, true);
   m_EditingContourNode->AddProperty("contour.width", mitk::FloatProperty::New(4.0f), nullptr, true);
 
-  auto dataStorage = m_ToolManager->GetDataStorage();
+  auto dataStorage = this->GetToolManager()->GetDataStorage();
   dataStorage->Add(m_ContourNode, workingDataNode);
   dataStorage->Add(m_LiveWireContourNode, workingDataNode);
   dataStorage->Add(m_EditingContourNode, workingDataNode);
 
   // Set current slice as input for ImageToLiveWireContourFilter
   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);
 
   m_LiveWireFilter = ImageLiveWireContourModelFilter::New();
   m_LiveWireFilter->SetInput(m_ReferenceDataSlice);
 
   // Map click to pixel coordinates
   auto click = positionEvent->GetPositionInWorld();
   itk::Index<3> idx;
   m_ReferenceDataSlice->GetGeometry()->WorldToIndex(click, idx);
 
   // Get the pixel with the highest gradient in a 7x7 region
   itk::Index<3> indexWithHighestGradient;
   AccessFixedDimensionByItk_2(m_ReferenceDataSlice, FindHighestGradientMagnitudeByITK, 2, idx, indexWithHighestGradient);
 
   click[0] = indexWithHighestGradient[0];
   click[1] = indexWithHighestGradient[1];
   click[2] = indexWithHighestGradient[2];
   m_ReferenceDataSlice->GetGeometry()->IndexToWorld(click, click);
 
   // Set initial start point
   m_Contour->AddVertex(click, true);
   m_LiveWireFilter->SetStartPoint(click);
 
   // Remember PlaneGeometry to determine if events were triggered in the same plane
   m_PlaneGeometry = interactionEvent->GetSender()->GetCurrentWorldPlaneGeometry();
 
   m_CreateAndUseDynamicCosts = true;
 
   mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
 }
 
 void mitk::LiveWireTool2D::OnAddPoint(StateMachineAction *, InteractionEvent *interactionEvent)
 {
   // Complete LiveWire interaction for the last segment. Add current LiveWire contour to
   // the finished contour and reset to start a new segment and computation.
 
   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;
   }
 
   // Add repulsive points to avoid getting the same path again
   std::for_each(m_LiveWireContour->IteratorBegin(), m_LiveWireContour->IteratorEnd(), [this](ContourElement::VertexType *vertex) {
     ImageLiveWireContourModelFilter::InternalImageType::IndexType idx;
     this->m_ReferenceDataSlice->GetGeometry()->WorldToIndex(vertex->Coordinates, idx);
     this->m_LiveWireFilter->AddRepulsivePoint(idx);
   });
 
   // Remove duplicate first vertex, it's already contained in m_Contour
   m_LiveWireContour->RemoveVertexAt(0);
 
   // Set last point as control point
   m_LiveWireContour->SetControlVertexAt(m_LiveWireContour->GetNumberOfVertices() - 1);
 
   // Merge contours
   m_Contour->Concatenate(m_LiveWireContour);
 
   // Clear the LiveWire contour and reset the corresponding DataNode
   m_LiveWireContour->Clear();
 
   // Set new start point
   m_LiveWireFilter->SetStartPoint(positionEvent->GetPositionInWorld());
 
   if (m_CreateAndUseDynamicCosts)
   {
     // Use dynamic cost map for next update
     m_LiveWireFilter->CreateDynamicCostMap(m_Contour);
     m_LiveWireFilter->SetUseDynamicCostMap(true);
   }
 
   mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
 }
 
 void mitk::LiveWireTool2D::OnMouseMoved(StateMachineAction *, InteractionEvent *interactionEvent)
 {
   // Compute LiveWire segment from last control point to current mouse position
 
   auto positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
 
   if (nullptr == positionEvent)
     return;
 
   m_LiveWireFilter->SetEndPoint(positionEvent->GetPositionInWorld());
   m_LiveWireFilter->Update();
 
   this->UpdateLiveWireContour();
 
   RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
 }
 
 void mitk::LiveWireTool2D::OnMouseMoveNoDynamicCosts(StateMachineAction *, InteractionEvent *interactionEvent)
 {
   m_LiveWireFilter->SetUseDynamicCostMap(false);
   this->OnMouseMoved(nullptr, interactionEvent);
   m_LiveWireFilter->SetUseDynamicCostMap(true);
 }
 
 bool mitk::LiveWireTool2D::OnCheckPoint(const InteractionEvent *interactionEvent)
 {
   // Check double click on first control point to finish the LiveWire tool
 
   auto positionEvent = dynamic_cast<const mitk::InteractionPositionEvent *>(interactionEvent);
 
   if (nullptr == positionEvent)
     return false;
 
   mitk::Point3D click = positionEvent->GetPositionInWorld();
   mitk::Point3D first = this->m_Contour->GetVertexAt(0)->Coordinates;
 
   return first.EuclideanDistanceTo(click) < 4.5;
 }
 
 void mitk::LiveWireTool2D::OnFinish(StateMachineAction *, InteractionEvent *interactionEvent)
 {
   // Finish LiveWire tool interaction
 
   auto positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
 
   if (nullptr == positionEvent)
     return;
 
   // Remove last control point added by double click
   m_Contour->RemoveVertexAt(m_Contour->GetNumberOfVertices() - 1);
 
   // Save contour and corresponding plane geometry to list
   this->m_WorkingContours.emplace_back(std::make_pair(m_ContourNode, positionEvent->GetSender()->GetCurrentWorldPlaneGeometry()->Clone()));
   this->m_EditingContours.emplace_back(std::make_pair(m_EditingContourNode, positionEvent->GetSender()->GetCurrentWorldPlaneGeometry()->Clone()));
 
   m_LiveWireFilter->SetUseDynamicCostMap(false);
 
   this->FinishTool();
 }
 
 void mitk::LiveWireTool2D::FinishTool()
 {
   auto numberOfTimesteps = static_cast<int>(m_Contour->GetTimeSteps());
 
   for (int i = 0; i <= numberOfTimesteps; ++i)
     m_Contour->Close(i);
 
-  m_ToolManager->GetDataStorage()->Remove(m_LiveWireContourNode);
+  this->GetToolManager()->GetDataStorage()->Remove(m_LiveWireContourNode);
 
   m_LiveWireContourNode = nullptr;
   m_LiveWireContour = nullptr;
 
   m_ContourInteractor = mitk::ContourModelLiveWireInteractor::New();
   m_ContourInteractor->SetDataNode(m_ContourNode);
   m_ContourInteractor->LoadStateMachine("ContourModelModificationInteractor.xml", us::GetModuleContext()->GetModule());
   m_ContourInteractor->SetEventConfig("ContourModelModificationConfig.xml", us::GetModuleContext()->GetModule());
   m_ContourInteractor->SetWorkingImage(this->m_ReferenceDataSlice);
   m_ContourInteractor->SetEditingContourModelNode(this->m_EditingContourNode);
 
   m_ContourNode->SetDataInteractor(m_ContourInteractor.GetPointer());
 
   this->m_LiveWireInteractors.push_back(m_ContourInteractor);
 }
 
 void mitk::LiveWireTool2D::OnLastSegmentDelete(StateMachineAction *, InteractionEvent *interactionEvent)
 {
   // If last point of current contour will be removed go to start state and remove nodes
   if (m_Contour->GetNumberOfVertices() <= 1)
   {
-    auto dataStorage = m_ToolManager->GetDataStorage();
+    auto dataStorage = this->GetToolManager()->GetDataStorage();
 
     dataStorage->Remove(m_LiveWireContourNode);
     dataStorage->Remove(m_ContourNode);
     dataStorage->Remove(m_EditingContourNode);
 
     m_LiveWireContour = this->CreateNewContour();
     m_LiveWireContourNode->SetData(m_LiveWireContour);
 
     m_Contour = this->CreateNewContour();
     m_ContourNode->SetData(m_Contour);
 
     this->ResetToStartState();
   }
   else // Remove last segment from contour and reset LiveWire contour
   {
     m_LiveWireContour = this->CreateNewContour();
     m_LiveWireContourNode->SetData(m_LiveWireContour);
 
     auto newContour = this->CreateNewContour();
 
     auto begin = m_Contour->IteratorBegin();
 
     // Iterate from last point to next active point
     auto newLast = m_Contour->IteratorBegin() + (m_Contour->GetNumberOfVertices() - 1);
 
     // Go at least one down
     if (newLast != begin)
       --newLast;
 
     // Search next active control point
     while (newLast != begin && !((*newLast)->IsControlPoint))
       --newLast;
 
     // Set position of start point for LiveWire filter to coordinates of the new last point
     m_LiveWireFilter->SetStartPoint((*newLast)->Coordinates);
 
     auto it = m_Contour->IteratorBegin();
 
     // Fll new Contour
     while (it <= newLast)
     {
       newContour->AddVertex((*it)->Coordinates, (*it)->IsControlPoint);
       ++it;
     }
 
     newContour->SetClosed(m_Contour->IsClosed());
 
     m_ContourNode->SetData(newContour);
     m_Contour = newContour;
 
     mitk::RenderingManager::GetInstance()->RequestUpdate(interactionEvent->GetSender()->GetRenderWindow());
   }
 }
 
 template <typename TPixel, unsigned int VImageDimension>
 void mitk::LiveWireTool2D::FindHighestGradientMagnitudeByITK(itk::Image<TPixel, VImageDimension> *inputImage,
                                                              itk::Index<3> &index,
                                                              itk::Index<3> &returnIndex)
 {
   typedef itk::Image<TPixel, VImageDimension> InputImageType;
   typedef typename InputImageType::IndexType IndexType;
 
   const auto MAX_X = inputImage->GetLargestPossibleRegion().GetSize()[0];
   const auto MAX_Y = inputImage->GetLargestPossibleRegion().GetSize()[1];
 
   returnIndex[0] = index[0];
   returnIndex[1] = index[1];
   returnIndex[2] = 0.0;
 
   double gradientMagnitude = 0.0;
   double maxGradientMagnitude = 0.0;
 
   // The size and thus the region of 7x7 is only used to calculate the gradient magnitude in that region,
   // not for searching the maximum value.
 
   // Maximum value in each direction for size
   typename InputImageType::SizeType size;
   size[0] = 7;
   size[1] = 7;
 
   // Minimum value in each direction for startRegion
   IndexType startRegion;
   startRegion[0] = index[0] - 3;
   startRegion[1] = index[1] - 3;
   if (startRegion[0] < 0)
     startRegion[0] = 0;
   if (startRegion[1] < 0)
     startRegion[1] = 0;
   if (MAX_X - index[0] < 7)
     startRegion[0] = MAX_X - 7;
   if (MAX_Y - index[1] < 7)
     startRegion[1] = MAX_Y - 7;
 
   index[0] = startRegion[0] + 3;
   index[1] = startRegion[1] + 3;
 
   typename InputImageType::RegionType region;
   region.SetSize(size);
   region.SetIndex(startRegion);
 
   typedef typename itk::GradientMagnitudeImageFilter<InputImageType, InputImageType> GradientMagnitudeFilterType;
   typename GradientMagnitudeFilterType::Pointer gradientFilter = GradientMagnitudeFilterType::New();
   gradientFilter->SetInput(inputImage);
   gradientFilter->GetOutput()->SetRequestedRegion(region);
 
   gradientFilter->Update();
   typename InputImageType::Pointer gradientMagnitudeImage;
   gradientMagnitudeImage = gradientFilter->GetOutput();
 
   IndexType currentIndex;
   currentIndex[0] = 0;
   currentIndex[1] = 0;
 
   // Search max (approximate) gradient magnitude
   for (int x = -1; x <= 1; ++x)
   {
     currentIndex[0] = index[0] + x;
 
     for (int y = -1; y <= 1; ++y)
     {
       currentIndex[1] = index[1] + y;
       gradientMagnitude = gradientMagnitudeImage->GetPixel(currentIndex);
 
       // Check for new max
       if (maxGradientMagnitude < gradientMagnitude)
       {
         maxGradientMagnitude = gradientMagnitude;
         returnIndex[0] = currentIndex[0];
         returnIndex[1] = currentIndex[1];
         returnIndex[2] = 0.0;
       }
     }
 
     currentIndex[1] = index[1];
   }
 }
diff --git a/Modules/Segmentation/Interactions/mitkPaintbrushTool.cpp b/Modules/Segmentation/Interactions/mitkPaintbrushTool.cpp
index 54231db23f..080fb76ab2 100644
--- a/Modules/Segmentation/Interactions/mitkPaintbrushTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkPaintbrushTool.cpp
@@ -1,566 +1,566 @@
 /*============================================================================
 
 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 "mitkPaintbrushTool.h"
 
 #include "mitkAbstractTransformGeometry.h"
 #include "mitkBaseRenderer.h"
 #include "mitkToolManager.h"
 
 #include "mitkContourModelUtils.h"
 #include "mitkLevelWindowProperty.h"
 
 int mitk::PaintbrushTool::m_Size = 1;
 
 mitk::PaintbrushTool::PaintbrushTool(int paintingPixelValue)
   : FeedbackContourTool("PressMoveReleaseWithCTRLInversionAllMouseMoves"),
     m_PaintingPixelValue(paintingPixelValue),
     m_LastContourSize(0) // other than initial mitk::PaintbrushTool::m_Size (around l. 28)
 {
   m_MasterContour = ContourModel::New();
   m_MasterContour->Initialize();
   m_CurrentPlane = nullptr;
 
   m_WorkingNode = DataNode::New();
   m_WorkingNode->SetProperty("levelwindow", mitk::LevelWindowProperty::New(mitk::LevelWindow(0, 1)));
   m_WorkingNode->SetProperty("binary", mitk::BoolProperty::New(true));
 }
 
 mitk::PaintbrushTool::~PaintbrushTool()
 {
 }
 
 void mitk::PaintbrushTool::ConnectActionsAndFunctions()
 {
   CONNECT_FUNCTION("PrimaryButtonPressed", OnMousePressed);
   CONNECT_FUNCTION("Move", OnPrimaryButtonPressedMoved);
   CONNECT_FUNCTION("MouseMove", OnMouseMoved);
   CONNECT_FUNCTION("Release", OnMouseReleased);
   CONNECT_FUNCTION("InvertLogic", OnInvertLogic);
 }
 
 void mitk::PaintbrushTool::Activated()
 {
   Superclass::Activated();
 
   FeedbackContourTool::SetFeedbackContourVisible(true);
   SizeChanged.Send(m_Size);
-  m_ToolManager->WorkingDataChanged +=
+  this->GetToolManager()->WorkingDataChanged +=
     mitk::MessageDelegate<mitk::PaintbrushTool>(this, &mitk::PaintbrushTool::OnToolManagerWorkingDataModified);
 }
 
 void mitk::PaintbrushTool::Deactivated()
 {
   FeedbackContourTool::SetFeedbackContourVisible(false);
-  if (m_ToolManager->GetDataStorage()->Exists(m_WorkingNode))
-    m_ToolManager->GetDataStorage()->Remove(m_WorkingNode);
+  if (this->GetToolManager()->GetDataStorage()->Exists(m_WorkingNode))
+    this->GetToolManager()->GetDataStorage()->Remove(m_WorkingNode);
   m_WorkingSlice = nullptr;
   m_CurrentPlane = nullptr;
-  m_ToolManager->WorkingDataChanged -=
+  this->GetToolManager()->WorkingDataChanged -=
     mitk::MessageDelegate<mitk::PaintbrushTool>(this, &mitk::PaintbrushTool::OnToolManagerWorkingDataModified);
 
   Superclass::Deactivated();
 }
 
 void mitk::PaintbrushTool::SetSize(int value)
 {
   m_Size = value;
 }
 
 mitk::Point2D mitk::PaintbrushTool::upperLeft(mitk::Point2D p)
 {
   p[0] -= 0.5;
   p[1] += 0.5;
   return p;
 }
 
 void mitk::PaintbrushTool::UpdateContour(const InteractionPositionEvent *positionEvent)
 {
   // MITK_INFO<<"Update...";
   // examine stateEvent and create a contour that matches the pixel mask that we are going to draw
   // mitk::InteractionPositionEvent* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>( interactionEvent );
   // const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
   if (!positionEvent)
     return;
 
   // Get Spacing of current Slice
   // mitk::Vector3D vSpacing = m_WorkingSlice->GetSlicedGeometry()->GetPlaneGeometry(0)->GetSpacing();
 
   //
   // Draw a contour in Square according to selected brush size
   //
   int radius = (m_Size) / 2;
   float fradius = static_cast<float>(m_Size) / 2.0f;
 
   ContourModel::Pointer contourInImageIndexCoordinates = ContourModel::New();
 
   // estimate center point of the brush ( relative to the pixel the mouse points on )
   // -- left upper corner for even sizes,
   // -- midpoint for uneven sizes
   mitk::Point2D centerCorrection;
   centerCorrection.Fill(0);
 
   // even --> correction of [+0.5, +0.5]
   bool evenSize = ((m_Size % 2) == 0);
   if (evenSize)
   {
     centerCorrection[0] += 0.5;
     centerCorrection[1] += 0.5;
   }
 
   // we will compute the control points for the upper left quarter part of a circle contour
   std::vector<mitk::Point2D> quarterCycleUpperRight;
   std::vector<mitk::Point2D> quarterCycleLowerRight;
   std::vector<mitk::Point2D> quarterCycleLowerLeft;
   std::vector<mitk::Point2D> quarterCycleUpperLeft;
 
   mitk::Point2D curPoint;
   bool curPointIsInside = true;
   curPoint[0] = 0;
   curPoint[1] = radius;
   quarterCycleUpperRight.push_back(upperLeft(curPoint));
 
   // to estimate if a pixel is inside the circle, we need to compare against the 'outer radius'
   // i.e. the distance from the midpoint [0,0] to the border of the pixel [0,radius]
   // const float outer_radius = static_cast<float>(radius) + 0.5;
 
   while (curPoint[1] > 0)
   {
     // Move right until pixel is outside circle
     float curPointX_squared = 0.0f;
     float curPointY_squared = (curPoint[1] - centerCorrection[1]) * (curPoint[1] - centerCorrection[1]);
     while (curPointIsInside)
     {
       // increment posX and chec
       curPoint[0]++;
       curPointX_squared = (curPoint[0] - centerCorrection[0]) * (curPoint[0] - centerCorrection[0]);
       const float len = sqrt(curPointX_squared + curPointY_squared);
       if (len > fradius)
       {
         // found first Pixel in this horizontal line, that is outside the circle
         curPointIsInside = false;
       }
     }
     quarterCycleUpperRight.push_back(upperLeft(curPoint));
 
     // Move down until pixel is inside circle
     while (!curPointIsInside)
     {
       // increment posX and chec
       curPoint[1]--;
       curPointY_squared = (curPoint[1] - centerCorrection[1]) * (curPoint[1] - centerCorrection[1]);
       const float len = sqrt(curPointX_squared + curPointY_squared);
       if (len <= fradius)
       {
         // found first Pixel in this horizontal line, that is outside the circle
         curPointIsInside = true;
         quarterCycleUpperRight.push_back(upperLeft(curPoint));
       }
 
       // Quarter cycle is full, when curPoint y position is 0
       if (curPoint[1] <= 0)
         break;
     }
   }
 
   // QuarterCycle is full! Now copy quarter cycle to other quarters.
 
   if (!evenSize)
   {
     std::vector<mitk::Point2D>::const_iterator it = quarterCycleUpperRight.begin();
     while (it != quarterCycleUpperRight.end())
     {
       mitk::Point2D p;
       p = *it;
 
       // the contour points in the lower right corner have same position but with negative y values
       p[1] *= -1;
       quarterCycleLowerRight.push_back(p);
 
       // the contour points in the lower left corner have same position
       // but with both x,y negative
       p[0] *= -1;
       quarterCycleLowerLeft.push_back(p);
 
       // the contour points in the upper left corner have same position
       // but with x negative
       p[1] *= -1;
       quarterCycleUpperLeft.push_back(p);
 
       it++;
     }
   }
   else
   {
     std::vector<mitk::Point2D>::const_iterator it = quarterCycleUpperRight.begin();
     while (it != quarterCycleUpperRight.end())
     {
       mitk::Point2D p, q;
       p = *it;
 
       q = p;
       // the contour points in the lower right corner have same position but with negative y values
       q[1] *= -1;
       // correct for moved offset if size even = the midpoint is not the midpoint of the current pixel
       // but its upper rigt corner
       q[1] += 1;
       quarterCycleLowerRight.push_back(q);
 
       q = p;
       // the contour points in the lower left corner have same position
       // but with both x,y negative
       q[1] = -1.0f * q[1] + 1;
       q[0] = -1.0f * q[0] + 1;
       quarterCycleLowerLeft.push_back(q);
 
       // the contour points in the upper left corner have same position
       // but with x negative
       q = p;
       q[0] *= -1;
       q[0] += 1;
       quarterCycleUpperLeft.push_back(q);
 
       it++;
     }
   }
 
   // fill contour with poins in right ordering, starting with the upperRight block
   mitk::Point3D tempPoint;
   for (unsigned int i = 0; i < quarterCycleUpperRight.size(); i++)
   {
     tempPoint[0] = quarterCycleUpperRight[i][0];
     tempPoint[1] = quarterCycleUpperRight[i][1];
     tempPoint[2] = 0;
     contourInImageIndexCoordinates->AddVertex(tempPoint);
   }
   // the lower right has to be parsed in reverse order
   for (int i = quarterCycleLowerRight.size() - 1; i >= 0; i--)
   {
     tempPoint[0] = quarterCycleLowerRight[i][0];
     tempPoint[1] = quarterCycleLowerRight[i][1];
     tempPoint[2] = 0;
     contourInImageIndexCoordinates->AddVertex(tempPoint);
   }
   for (unsigned int i = 0; i < quarterCycleLowerLeft.size(); i++)
   {
     tempPoint[0] = quarterCycleLowerLeft[i][0];
     tempPoint[1] = quarterCycleLowerLeft[i][1];
     tempPoint[2] = 0;
     contourInImageIndexCoordinates->AddVertex(tempPoint);
   }
   // the upper left also has to be parsed in reverse order
   for (int i = quarterCycleUpperLeft.size() - 1; i >= 0; i--)
   {
     tempPoint[0] = quarterCycleUpperLeft[i][0];
     tempPoint[1] = quarterCycleUpperLeft[i][1];
     tempPoint[2] = 0;
     contourInImageIndexCoordinates->AddVertex(tempPoint);
   }
 
   m_MasterContour = contourInImageIndexCoordinates;
 }
 
 /**
   Just show the contour, get one point as the central point and add surrounding points to the contour.
   */
 void mitk::PaintbrushTool::OnMousePressed(StateMachineAction *, InteractionEvent *interactionEvent)
 {
   if (m_WorkingSlice.IsNull())
     return;
 
   auto *positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
   if (!positionEvent)
     return;
 
   m_WorkingSlice->GetGeometry()->WorldToIndex(positionEvent->GetPositionInWorld(), m_LastPosition);
 
   // create new working node
   // a fresh node is needed to only display the actual drawing process for
   // the undo function
-  if (m_ToolManager->GetDataStorage()->Exists(m_WorkingNode))
-    m_ToolManager->GetDataStorage()->Remove(m_WorkingNode);
+  if (this->GetToolManager()->GetDataStorage()->Exists(m_WorkingNode))
+    this->GetToolManager()->GetDataStorage()->Remove(m_WorkingNode);
   m_WorkingSlice = nullptr;
   m_CurrentPlane = nullptr;
 
   m_WorkingNode = DataNode::New();
   m_WorkingNode->SetProperty("levelwindow", mitk::LevelWindowProperty::New(mitk::LevelWindow(0, 1)));
   m_WorkingNode->SetProperty("binary", mitk::BoolProperty::New(true));
 
   this->m_WorkingNode->SetVisibility(true);
 
   m_LastEventSender = positionEvent->GetSender();
   m_LastEventSlice = m_LastEventSender->GetSlice();
 
   m_MasterContour->SetClosed(true);
   this->MouseMoved(interactionEvent, true);
 }
 
 void mitk::PaintbrushTool::OnMouseMoved(StateMachineAction *, InteractionEvent *interactionEvent)
 {
   MouseMoved(interactionEvent, false);
 }
 
 void mitk::PaintbrushTool::OnPrimaryButtonPressedMoved(StateMachineAction *, InteractionEvent *interactionEvent)
 {
   MouseMoved(interactionEvent, true);
 }
 
 /**
   Insert the point to the feedback contour,finish to build the contour and at the same time the painting function
   */
 void mitk::PaintbrushTool::MouseMoved(mitk::InteractionEvent *interactionEvent, bool leftMouseButtonPressed)
 {
   auto *positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
 
   CheckIfCurrentSliceHasChanged(positionEvent);
 
   if (m_LastContourSize != m_Size)
   {
     UpdateContour(positionEvent);
     m_LastContourSize = m_Size;
   }
 
   Point3D worldCoordinates = positionEvent->GetPositionInWorld();
   Point3D indexCoordinates;
 
   m_WorkingSlice->GetGeometry()->WorldToIndex(worldCoordinates, indexCoordinates);
 
   // round to nearest voxel center (abort if this hasn't changed)
   if (m_Size % 2 == 0) // even
   {
     indexCoordinates[0] = std::round(indexCoordinates[0]);
     indexCoordinates[1] = std::round(indexCoordinates[1]);
   }
   else // odd
   {
     indexCoordinates[0] = std::round(indexCoordinates[0]);
     indexCoordinates[1] = std::round(indexCoordinates[1]);
   }
 
   static Point3D lastPos; // uninitialized: if somebody finds out how this can be initialized in a one-liner, tell me
   if (fabs(indexCoordinates[0] - lastPos[0]) > mitk::eps || fabs(indexCoordinates[1] - lastPos[1]) > mitk::eps ||
       fabs(indexCoordinates[2] - lastPos[2]) > mitk::eps || leftMouseButtonPressed)
   {
     lastPos = indexCoordinates;
   }
   else
   {
     return;
   }
 
   auto contour = ContourModel::New();
   contour->SetClosed(true);
 
   auto it = m_MasterContour->Begin();
   auto end = m_MasterContour->End();
 
   while (it != end)
   {
     auto point = (*it)->Coordinates;
     point[0] += indexCoordinates[0];
     point[1] += indexCoordinates[1];
 
     contour->AddVertex(point);
     ++it;
   }
 
   if (leftMouseButtonPressed)
   {
     const double dist = indexCoordinates.EuclideanDistanceTo(m_LastPosition);
     const double radius = static_cast<double>(m_Size) / 2.0;
 
-    DataNode *workingNode(m_ToolManager->GetWorkingData(0));
+    DataNode *workingNode(this->GetToolManager()->GetWorkingData(0));
     auto workingImage = dynamic_cast<Image*>(workingNode->GetData());
     int activePixelValue = ContourModelUtils::GetActivePixelValue(workingImage);
 
     // m_PaintingPixelValue only decides whether to paint or erase
     mitk::ContourModelUtils::FillContourInSlice(
       contour, m_WorkingSlice, workingImage, m_PaintingPixelValue * activePixelValue);
 
     m_WorkingNode->SetData(m_WorkingSlice);
     m_WorkingNode->Modified();
 
     // if points are >= radius away draw rectangle to fill empty holes
     // in between the 2 points
     if (dist > radius)
     {
       const mitk::Point3D &currentPos = indexCoordinates;
       mitk::Point3D direction;
       mitk::Point3D vertex;
       mitk::Point3D normal;
 
       direction[0] = indexCoordinates[0] - m_LastPosition[0];
       direction[1] = indexCoordinates[1] - m_LastPosition[1];
       direction[2] = indexCoordinates[2] - m_LastPosition[2];
 
       direction[0] = direction.GetVnlVector().normalize()[0];
       direction[1] = direction.GetVnlVector().normalize()[1];
       direction[2] = direction.GetVnlVector().normalize()[2];
 
       // 90 degrees rotation of direction
       normal[0] = -1.0 * direction[1];
       normal[1] = direction[0];
 
       contour->Clear();
 
       // upper left corner
       vertex[0] = m_LastPosition[0] + (normal[0] * radius);
       vertex[1] = m_LastPosition[1] + (normal[1] * radius);
 
       contour->AddVertex(vertex);
 
       // upper right corner
       vertex[0] = currentPos[0] + (normal[0] * radius);
       vertex[1] = currentPos[1] + (normal[1] * radius);
 
       contour->AddVertex(vertex);
 
       // lower right corner
       vertex[0] = currentPos[0] - (normal[0] * radius);
       vertex[1] = currentPos[1] - (normal[1] * radius);
 
       contour->AddVertex(vertex);
 
       // lower left corner
       vertex[0] = m_LastPosition[0] - (normal[0] * radius);
       vertex[1] = m_LastPosition[1] - (normal[1] * radius);
 
       contour->AddVertex(vertex);
 
       mitk::ContourModelUtils::FillContourInSlice(contour, m_WorkingSlice, workingImage, m_PaintingPixelValue * activePixelValue);
       m_WorkingNode->SetData(m_WorkingSlice);
       m_WorkingNode->Modified();
     }
   }
   else
   {
     // switched from different renderwindow
     // no activate hover highlighting. Otherwise undo / redo wont work
     this->m_WorkingNode->SetVisibility(false);
   }
 
   m_LastPosition = indexCoordinates;
 
   // visualize contour
   ContourModel::Pointer tmp =
     FeedbackContourTool::BackProjectContourFrom2DSlice(m_WorkingSlice->GetGeometry(), contour);
 
   this->UpdateCurrentFeedbackContour(tmp);
 
   assert(positionEvent->GetSender()->GetRenderWindow());
   RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
 }
 
 void mitk::PaintbrushTool::OnMouseReleased(StateMachineAction *, InteractionEvent *interactionEvent)
 {
   // When mouse is released write segmentationresult back into image
   auto *positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
   if (!positionEvent)
     return;
 
   this->WriteBackSegmentationResult(positionEvent, m_WorkingSlice->Clone());
 
   // deactivate visibility of helper node
   m_WorkingNode->SetVisibility(false);
 
   RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
 }
 
 /**
   Called when the CTRL key is pressed. Will change the painting pixel value from 0 to 1 or from 1 to 0.
   */
 void mitk::PaintbrushTool::OnInvertLogic(StateMachineAction *, InteractionEvent *)
 {
   // Inversion only for 0 and 1 as painting values
   if (m_PaintingPixelValue == 1)
   {
     m_PaintingPixelValue = 0;
     FeedbackContourTool::SetFeedbackContourColor(1.0, 0.0, 0.0);
   }
   else if (m_PaintingPixelValue == 0)
   {
     m_PaintingPixelValue = 1;
     FeedbackContourTool::SetFeedbackContourColorDefault();
   }
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void mitk::PaintbrushTool::CheckIfCurrentSliceHasChanged(const InteractionPositionEvent *event)
 {
   const PlaneGeometry *planeGeometry((event->GetSender()->GetCurrentWorldPlaneGeometry()));
   const auto *abstractTransformGeometry(
     dynamic_cast<const AbstractTransformGeometry *>(event->GetSender()->GetCurrentWorldPlaneGeometry()));
-  DataNode *workingNode(m_ToolManager->GetWorkingData(0));
+  DataNode *workingNode(this->GetToolManager()->GetWorkingData(0));
 
   if (!workingNode)
     return;
 
   Image::Pointer image = dynamic_cast<Image *>(workingNode->GetData());
 
   if (!image || !planeGeometry || abstractTransformGeometry)
     return;
 
   if (m_CurrentPlane.IsNull() || m_WorkingSlice.IsNull())
   {
     m_CurrentPlane = planeGeometry;
     m_WorkingSlice = SegTool2D::GetAffectedImageSliceAs2DImage(event, image)->Clone();
     m_WorkingNode->ReplaceProperty("color", workingNode->GetProperty("color"));
     m_WorkingNode->SetData(m_WorkingSlice);
   }
   else
   {
     bool isSameSlice(false);
     isSameSlice = mitk::MatrixEqualElementWise(planeGeometry->GetIndexToWorldTransform()->GetMatrix(),
                                                m_CurrentPlane->GetIndexToWorldTransform()->GetMatrix());
     isSameSlice = mitk::Equal(planeGeometry->GetIndexToWorldTransform()->GetOffset(),
                               m_CurrentPlane->GetIndexToWorldTransform()->GetOffset());
     if (!isSameSlice)
     {
-      m_ToolManager->GetDataStorage()->Remove(m_WorkingNode);
+      this->GetToolManager()->GetDataStorage()->Remove(m_WorkingNode);
       m_CurrentPlane = nullptr;
       m_WorkingSlice = nullptr;
       m_WorkingNode = nullptr;
       m_CurrentPlane = planeGeometry;
       m_WorkingSlice = SegTool2D::GetAffectedImageSliceAs2DImage(event, image)->Clone();
 
       m_WorkingNode = mitk::DataNode::New();
       m_WorkingNode->SetProperty("levelwindow", mitk::LevelWindowProperty::New(mitk::LevelWindow(0, 1)));
       m_WorkingNode->SetProperty("binary", mitk::BoolProperty::New(true));
 
       m_WorkingNode->SetData(m_WorkingSlice);
 
       // So that the paintbrush contour vanished in the previous render window
       RenderingManager::GetInstance()->RequestUpdateAll();
     }
   }
 
-  if (!m_ToolManager->GetDataStorage()->Exists(m_WorkingNode))
+  if (!this->GetToolManager()->GetDataStorage()->Exists(m_WorkingNode))
   {
     m_WorkingNode->SetProperty("outline binary", mitk::BoolProperty::New(true));
     m_WorkingNode->SetProperty("color", workingNode->GetProperty("color"));
     m_WorkingNode->SetProperty("name", mitk::StringProperty::New("Paintbrush_Node"));
     m_WorkingNode->SetProperty("helper object", mitk::BoolProperty::New(true));
     m_WorkingNode->SetProperty("opacity", mitk::FloatProperty::New(0.8));
     m_WorkingNode->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
     m_WorkingNode->SetVisibility(
       false, mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget3")));
 
-    m_ToolManager->GetDataStorage()->Add(m_WorkingNode);
+    this->GetToolManager()->GetDataStorage()->Add(m_WorkingNode);
   }
 }
 
 void mitk::PaintbrushTool::OnToolManagerWorkingDataModified()
 {
   // Here we simply set the current working slice to null. The next time the mouse is moved
   // within a renderwindow a new slice will be extracted from the new working data
   m_WorkingSlice = nullptr;
 }
diff --git a/Modules/Segmentation/Interactions/mitkPixelManipulationTool.cpp b/Modules/Segmentation/Interactions/mitkPixelManipulationTool.cpp
index 5a080fe056..1507bbcc3a 100644
--- a/Modules/Segmentation/Interactions/mitkPixelManipulationTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkPixelManipulationTool.cpp
@@ -1,191 +1,191 @@
 /*============================================================================
 
 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 "mitkPixelManipulationTool.h"
 
 #include "mitkBoundingObjectToSegmentationFilter.h"
 #include "mitkImage.h"
 #include "mitkImageAccessByItk.h"
 #include "mitkImageCast.h"
 #include "mitkProperties.h"
 #include "mitkToolManager.h"
 #include <itkImageRegionIterator.h>
 
 #include "mitkPixelManipulationTool.xpm"
 
 namespace mitk
 {
   MITK_TOOL_MACRO(MITKSEGMENTATION_EXPORT, PixelManipulationTool, "Pixel manipulation tool");
 }
 
 mitk::PixelManipulationTool::PixelManipulationTool() : Tool("dummy"), m_Value(0), m_FixedValue(false)
 {
 }
 
 mitk::PixelManipulationTool::~PixelManipulationTool()
 {
 }
 
 void mitk::PixelManipulationTool::Activated()
 {
   Superclass::Activated();
 
-  m_ToolManager->RoiDataChanged +=
+  this->GetToolManager()->RoiDataChanged +=
     mitk::MessageDelegate<mitk::PixelManipulationTool>(this, &mitk::PixelManipulationTool::OnRoiDataChanged);
-  m_OriginalImageNode = m_ToolManager->GetReferenceData(0);
+  m_OriginalImageNode = this->GetToolManager()->GetReferenceData(0);
 
   if (m_OriginalImageNode.IsNotNull())
   {
     mitk::Image::Pointer image = dynamic_cast<mitk::Image *>(m_OriginalImageNode->GetData());
     if (image.IsNotNull())
     {
       // mitk::ScalarType scalar = image->GetScalarValueMax();
     }
   }
   else
-    m_ToolManager->ActivateTool(-1);
+    this->GetToolManager()->ActivateTool(-1);
 }
 
 void mitk::PixelManipulationTool::Deactivated()
 {
-  m_ToolManager->RoiDataChanged -=
+  this->GetToolManager()->RoiDataChanged -=
     mitk::MessageDelegate<mitk::PixelManipulationTool>(this, &mitk::PixelManipulationTool::OnRoiDataChanged);
 
   Superclass::Deactivated();
 }
 
 const char *mitk::PixelManipulationTool::GetName() const
 {
   return "pixelmanipulation";
 }
 
 const char **mitk::PixelManipulationTool::GetXPM() const
 {
   return mitkPixelManipulationTool_xpm;
 }
 
 void mitk::PixelManipulationTool::OnRoiDataChanged()
 {
 }
 
 void mitk::PixelManipulationTool::CalculateImage()
 {
   if (m_OriginalImageNode.IsNotNull())
   {
     mitk::Image::Pointer image = dynamic_cast<mitk::Image *>(m_OriginalImageNode->GetData());
-    mitk::DataNode *maskNode = m_ToolManager->GetRoiData(0);
+    mitk::DataNode *maskNode = this->GetToolManager()->GetRoiData(0);
     mitk::Image::Pointer roi = mitk::Image::New();
 
     if (maskNode)
     {
       auto *boundingObject = dynamic_cast<mitk::BoundingObject *>(maskNode->GetData());
 
       if (boundingObject)
       {
         mitk::BoundingObjectToSegmentationFilter::Pointer filter = mitk::BoundingObjectToSegmentationFilter::New();
         filter->SetBoundingObject(boundingObject);
         filter->SetInput(image);
         filter->Update();
         roi = filter->GetOutput();
       }
       else
         roi = dynamic_cast<mitk::Image *>(maskNode->GetData());
 
       mitk::Image::Pointer newImage = mitk::Image::New();
       newImage->Initialize(image);
 
       if (image)
       {
         AccessByItk_3(image, ITKPixelManipulation, roi, newImage, m_Value);
         this->AddImageToDataStorage(newImage);
       }
     }
   }
 }
 
 template <typename TPixel, unsigned int VImageDimension>
 void mitk::PixelManipulationTool::ITKPixelManipulation(itk::Image<TPixel, VImageDimension> *originalImage,
                                                        Image *maskImage,
                                                        Image *newImage,
                                                        int newValue)
 {
   typedef itk::Image<TPixel, VImageDimension> itkImageType;
   typedef itk::Image<unsigned char, 3> itkMaskType;
   typename itkImageType::Pointer itkImage;
   typename itkMaskType::Pointer itkMask;
   CastToItkImage(newImage, itkImage);
   CastToItkImage(maskImage, itkMask);
 
   typedef itk::ImageRegionConstIterator<itkImageType> InputIteratorType;
   typedef itk::ImageRegionIterator<itkImageType> OutputIteratorType;
   typedef itk::ImageRegionConstIterator<itkMaskType> MaskIteratorType;
 
   MaskIteratorType maskIterator(itkMask, itkMask->GetLargestPossibleRegion());
   InputIteratorType inputIterator(originalImage, originalImage->GetLargestPossibleRegion());
   OutputIteratorType outputIterator(itkImage, itkImage->GetLargestPossibleRegion());
 
   inputIterator.GoToBegin();
   outputIterator.GoToBegin();
   maskIterator.GoToBegin();
 
   while (!outputIterator.IsAtEnd())
   {
     if (maskIterator.Get())
     {
       if (m_FixedValue)
         outputIterator.Set(newValue);
       else
         outputIterator.Set(inputIterator.Get() + newValue);
     }
     else
       outputIterator.Set(inputIterator.Get());
 
     ++inputIterator;
     ++outputIterator;
     ++maskIterator;
   }
 }
 
 void mitk::PixelManipulationTool::AddImageToDataStorage(mitk::Image::Pointer image)
 {
   if (image.IsNotNull())
   {
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     std::string name = m_OriginalImageNode->GetName();
     name.append("_modified");
     node->SetName(name);
     node->SetProperty("binary", mitk::BoolProperty::New(false));
     node->SetData(image);
 
-    if (m_ToolManager)
-      m_ToolManager->GetDataStorage()->Add(node, m_OriginalImageNode);
+    if (nullptr != this->GetToolManager())
+      this->GetToolManager()->GetDataStorage()->Add(node, m_OriginalImageNode);
   }
 }
 
 void mitk::PixelManipulationTool::SetValue(int value)
 {
   m_Value = value;
 }
 
 int mitk::PixelManipulationTool::GetValue()
 {
   return m_Value;
 }
 
 void mitk::PixelManipulationTool::SetFixedValue(int value)
 {
   m_FixedValue = value;
 }
 
 int mitk::PixelManipulationTool::GetFixedValue()
 {
   return m_FixedValue;
 }
diff --git a/Modules/Segmentation/Interactions/mitkRegionGrowingTool.cpp b/Modules/Segmentation/Interactions/mitkRegionGrowingTool.cpp
index 3e2617f963..0fa978346e 100644
--- a/Modules/Segmentation/Interactions/mitkRegionGrowingTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkRegionGrowingTool.cpp
@@ -1,573 +1,573 @@
 /*============================================================================
 
 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 "mitkRegionGrowingTool.h"
 #include "mitkBaseRenderer.h"
 #include "mitkImageToContourModelFilter.h"
 #include "mitkRegionGrowingTool.xpm"
 #include "mitkRenderingManager.h"
 #include "mitkToolManager.h"
 
 // us
 #include <usGetModuleContext.h>
 #include <usModule.h>
 #include <usModuleContext.h>
 #include <usModuleResource.h>
 
 // ITK
 #include "mitkITKImageImport.h"
 #include "mitkImageAccessByItk.h"
 #include <itkConnectedComponentImageFilter.h>
 #include <itkConnectedThresholdImageFilter.h>
 #include <itkNeighborhoodIterator.h>
 
 #include <itkImageDuplicator.h>
 
 #include <limits>
 
 namespace mitk
 {
   MITK_TOOL_MACRO(MITKSEGMENTATION_EXPORT, RegionGrowingTool, "Region growing tool");
 }
 
 #define ROUND(a) ((a) > 0 ? (int)((a) + 0.5) : -(int)(0.5 - (a)))
 
 mitk::RegionGrowingTool::RegionGrowingTool()
   : FeedbackContourTool("PressMoveRelease"),
     m_SeedValue(0),
     m_ScreenYDifference(0),
     m_ScreenXDifference(0),
     m_MouseDistanceScaleFactor(0.5),
     m_PaintingPixelValue(0),
     m_FillFeedbackContour(true),
     m_ConnectedComponentValue(1)
 {
 }
 
 mitk::RegionGrowingTool::~RegionGrowingTool()
 {
 }
 
 void mitk::RegionGrowingTool::ConnectActionsAndFunctions()
 {
   CONNECT_FUNCTION("PrimaryButtonPressed", OnMousePressed);
   CONNECT_FUNCTION("Move", OnMouseMoved);
   CONNECT_FUNCTION("Release", OnMouseReleased);
 }
 
 const char **mitk::RegionGrowingTool::GetXPM() const
 {
   return mitkRegionGrowingTool_xpm;
 }
 
 us::ModuleResource mitk::RegionGrowingTool::GetIconResource() const
 {
   us::Module *module = us::GetModuleContext()->GetModule();
   us::ModuleResource resource = module->GetResource("RegionGrowing_48x48.png");
   return resource;
 }
 
 us::ModuleResource mitk::RegionGrowingTool::GetCursorIconResource() const
 {
   us::Module *module = us::GetModuleContext()->GetModule();
   us::ModuleResource resource = module->GetResource("RegionGrowing_Cursor_32x32.png");
   return resource;
 }
 
 const char *mitk::RegionGrowingTool::GetName() const
 {
   return "Region Growing";
 }
 
 void mitk::RegionGrowingTool::Activated()
 {
   Superclass::Activated();
 }
 
 void mitk::RegionGrowingTool::Deactivated()
 {
   Superclass::Deactivated();
 }
 
 // Get the average pixel value of square/cube with radius=neighborhood around index
 template <typename TPixel, unsigned int imageDimension>
 void mitk::RegionGrowingTool::GetNeighborhoodAverage(const itk::Image<TPixel, imageDimension> *itkImage,
                                                      const itk::Index<imageDimension>& index,
                                                      ScalarType *result,
                                                      unsigned int neighborhood)
 {
   // maybe assert that image dimension is only 2 or 3?
   auto neighborhoodInt = (int)neighborhood;
   TPixel averageValue(0);
   unsigned int numberOfPixels = (2 * neighborhood + 1) * (2 * neighborhood + 1);
   if (imageDimension == 3)
   {
     numberOfPixels *= (2 * neighborhood + 1);
   }
 
   MITK_DEBUG << "Getting neighborhood of " << numberOfPixels << " pixels around " << index;
 
   itk::Index<imageDimension> currentIndex;
 
   for (int i = (0 - neighborhoodInt); i <= neighborhoodInt; ++i)
   {
     currentIndex[0] = index[0] + i;
 
     for (int j = (0 - neighborhoodInt); j <= neighborhoodInt; ++j)
     {
       currentIndex[1] = index[1] + j;
 
       if (imageDimension == 3)
       {
         for (int k = (0 - neighborhoodInt); k <= neighborhoodInt; ++k)
         {
           currentIndex[2] = index[2] + k;
 
           if (itkImage->GetLargestPossibleRegion().IsInside(currentIndex))
           {
             averageValue += itkImage->GetPixel(currentIndex);
           }
           else
           {
             numberOfPixels -= 1;
           }
         }
       }
       else
       {
         if (itkImage->GetLargestPossibleRegion().IsInside(currentIndex))
         {
           averageValue += itkImage->GetPixel(currentIndex);
         }
         else
         {
           numberOfPixels -= 1;
         }
       }
     }
   }
 
   *result = (ScalarType)averageValue;
   *result /= numberOfPixels;
 }
 
 // Check whether index lies inside a segmentation
 template <typename TPixel, unsigned int imageDimension>
 void mitk::RegionGrowingTool::IsInsideSegmentation(const itk::Image<TPixel, imageDimension> *itkImage,
                                                    const itk::Index<imageDimension>& index,
                                                    bool *result)
 {
   if (itkImage->GetPixel(index) > 0)
   {
     *result = true;
   }
   else
   {
     *result = false;
   }
 }
 
 // Do the region growing (i.e. call an ITK filter that does it)
 template <typename TPixel, unsigned int imageDimension>
 void mitk::RegionGrowingTool::StartRegionGrowing(const itk::Image<TPixel, imageDimension> *inputImage,
                                                  const itk::Index<imageDimension>& seedIndex,
                                                  const std::array<ScalarType, 2>& thresholds,
                                                  mitk::Image::Pointer &outputImage)
 {
   MITK_DEBUG << "Starting region growing at index " << seedIndex << " with lower threshold " << thresholds[0]
              << " and upper threshold " << thresholds[1];
 
   typedef itk::Image<TPixel, imageDimension> InputImageType;
   typedef itk::Image<DefaultSegmentationDataType, imageDimension> OutputImageType;
 
   typedef itk::ConnectedThresholdImageFilter<InputImageType, OutputImageType> RegionGrowingFilterType;
   typename RegionGrowingFilterType::Pointer regionGrower = RegionGrowingFilterType::New();
 
   // perform region growing in desired segmented region
   regionGrower->SetInput(inputImage);
   regionGrower->SetSeed(seedIndex);
 
   regionGrower->SetLower(thresholds[0]);
   regionGrower->SetUpper(thresholds[1]);
 
   try
   {
     regionGrower->Update();
   }
   catch (...)
   {
     return; // Should we do something?
   }
 
   typename OutputImageType::Pointer resultImage = regionGrower->GetOutput();
 
   // Smooth result: Every pixel is replaced by the majority of the neighborhood
   typedef itk::NeighborhoodIterator<OutputImageType> NeighborhoodIteratorType;
   typedef itk::ImageRegionIterator<OutputImageType> ImageIteratorType;
 
   typename NeighborhoodIteratorType::RadiusType radius;
   radius.Fill(2); // for now, maybe make this something the user can adjust in the preferences?
 
   typedef itk::ImageDuplicator< OutputImageType > DuplicatorType;
   typename DuplicatorType::Pointer duplicator = DuplicatorType::New();
   duplicator->SetInputImage(resultImage);
   duplicator->Update();
 
   typename OutputImageType::Pointer resultDup = duplicator->GetOutput();
 
   NeighborhoodIteratorType neighborhoodIterator(radius, resultDup, resultDup->GetRequestedRegion());
   ImageIteratorType imageIterator(resultImage, resultImage->GetRequestedRegion());
 
   for (neighborhoodIterator.GoToBegin(), imageIterator.GoToBegin(); !neighborhoodIterator.IsAtEnd();
        ++neighborhoodIterator, ++imageIterator)
   {
     DefaultSegmentationDataType voteYes(0);
     DefaultSegmentationDataType voteNo(0);
 
     for (unsigned int i = 0; i < neighborhoodIterator.Size(); ++i)
     {
       if (neighborhoodIterator.GetPixel(i) > 0)
       {
         voteYes += 1;
       }
       else
       {
         voteNo += 1;
       }
     }
 
     if (voteYes > voteNo)
     {
       imageIterator.Set(1);
     }
     else
     {
       imageIterator.Set(0);
     }
   }
 
   if (resultImage.IsNull())
   {
     MITK_DEBUG << "Region growing result is empty.";
   }
 
   // Can potentially have multiple regions, use connected component image filter to label disjunct regions
   typedef itk::ConnectedComponentImageFilter<OutputImageType, OutputImageType> ConnectedComponentImageFilterType;
   typename ConnectedComponentImageFilterType::Pointer connectedComponentFilter =
     ConnectedComponentImageFilterType::New();
   connectedComponentFilter->SetInput(resultImage);
   connectedComponentFilter->Update();
   typename OutputImageType::Pointer resultImageCC = connectedComponentFilter->GetOutput();
   m_ConnectedComponentValue = resultImageCC->GetPixel(seedIndex);
 
   outputImage = mitk::GrabItkImageMemory(resultImageCC);
 }
 
 template <typename TPixel, unsigned int imageDimension>
 void mitk::RegionGrowingTool::CalculateInitialThresholds(const itk::Image<TPixel, imageDimension>*)
 {
   LevelWindow levelWindow;
-  m_ToolManager->GetReferenceData(0)->GetLevelWindow(levelWindow);
+  this->GetToolManager()->GetReferenceData(0)->GetLevelWindow(levelWindow);
 
   m_ThresholdExtrema[0] = static_cast<ScalarType>(std::numeric_limits<TPixel>::lowest());
   m_ThresholdExtrema[1] = static_cast<ScalarType>(std::numeric_limits<TPixel>::max());
 
   const ScalarType lowerWindowBound = std::max(m_ThresholdExtrema[0], levelWindow.GetLowerWindowBound());
   const ScalarType upperWindowBound = std::min(m_ThresholdExtrema[1], levelWindow.GetUpperWindowBound());
 
   if (m_SeedValue < lowerWindowBound)
   {
     m_InitialThresholds = { m_ThresholdExtrema[0], lowerWindowBound };
   }
   else if (m_SeedValue > upperWindowBound)
   {
     m_InitialThresholds = { upperWindowBound, m_ThresholdExtrema[1] };
   }
   else
   {
     const ScalarType range = 0.1 * (upperWindowBound - lowerWindowBound); // 10% of the visible window
 
     m_InitialThresholds[0] = std::min(std::max(lowerWindowBound, m_SeedValue - 0.5 * range), upperWindowBound - range);
     m_InitialThresholds[1] = m_InitialThresholds[0] + range;
   }
 }
 
 void mitk::RegionGrowingTool::OnMousePressed(StateMachineAction *, InteractionEvent *interactionEvent)
 {
   auto *positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
   if (!positionEvent)
     return;
 
   m_LastEventSender = positionEvent->GetSender();
   m_LastEventSlice = m_LastEventSender->GetSlice();
   m_LastScreenPosition = Point2I(positionEvent->GetPointerPositionOnScreen());
 
   // ReferenceSlice is from the underlying image, WorkingSlice from the active segmentation (can be empty)
   m_ReferenceSlice = FeedbackContourTool::GetAffectedReferenceSlice(positionEvent);
   m_WorkingSlice = FeedbackContourTool::GetAffectedWorkingSlice(positionEvent);
 
   if (m_WorkingSlice.IsNotNull()) // can't do anything without a working slice (i.e. a possibly empty segmentation)
   {
     // 2. Determine if the user clicked inside or outside of the segmentation/working slice (i.e. the whole volume)
     mitk::BaseGeometry::Pointer workingSliceGeometry;
     workingSliceGeometry = m_WorkingSlice->GetGeometry();
     workingSliceGeometry->WorldToIndex(positionEvent->GetPositionInWorld(), m_SeedPoint);
     itk::Index<2> indexInWorkingSlice2D;
     indexInWorkingSlice2D[0] = m_SeedPoint[0];
     indexInWorkingSlice2D[1] = m_SeedPoint[1];
 
     if (workingSliceGeometry->IsIndexInside(m_SeedPoint))
     {
       MITK_DEBUG << "OnMousePressed: point " << positionEvent->GetPositionInWorld() << " (index coordinates "
                  << m_SeedPoint << ") is inside working slice";
 
       // 3. determine the pixel value under the last click to determine what to do
       bool inside(true);
       AccessFixedDimensionByItk_2(m_WorkingSlice, IsInsideSegmentation, 2, indexInWorkingSlice2D, &inside);
       m_PaintingPixelValue = inside ? 0 : 1;
 
       if (inside)
       {
         MITK_DEBUG << "Clicked inside segmentation";
         // For now, we're doing nothing when the user clicks inside the segmentation. Behaviour can be implemented via
         // OnMousePressedInside()
         // When you do, be sure to remove the m_PaintingPixelValue check in OnMouseMoved() and OnMouseReleased()
         return;
       }
       else
       {
         MITK_DEBUG << "Clicked outside of segmentation";
         OnMousePressedOutside(nullptr, interactionEvent);
       }
     }
   }
 }
 
 // Use this to implement a behaviour for when the user clicks inside a segmentation (for example remove something)
 // Old IpPic code is kept as comment for reference
 void mitk::RegionGrowingTool::OnMousePressedInside()
 {
   //    mitk::InteractionPositionEvent* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>( interactionEvent
   //    );
   //    //const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent()); // checked in
   //    OnMousePressed
   //    // 3.1.1. Create a skeletonization of the segmentation and try to find a nice cut
   //    // apply the skeletonization-and-cut algorithm
   //    // generate contour to remove
   //    // set m_ReferenceSlice = nullptr so nothing will happen during mouse move
   //    // remember to fill the contour with 0 in mouserelease
   //    mitkIpPicDescriptor* segmentationHistory = ipMITKSegmentationCreateGrowerHistory( workingPicSlice,
   //    m_LastWorkingSeed, nullptr ); // free again
   //    if (segmentationHistory)
   //    {
   //        tCutResult cutContour = ipMITKSegmentationGetCutPoints( workingPicSlice, segmentationHistory,
   //        initialWorkingOffset ); // tCutResult is a ipSegmentation type
   //        mitkIpPicFree( segmentationHistory );
   //        if (cutContour.cutIt)
   //        {
   //            int timestep = positionEvent->GetSender()->GetTimeStep();
   //            // 3.1.2 copy point from float* to mitk::Contour
   //            ContourModel::Pointer contourInImageIndexCoordinates = ContourModel::New();
   //            contourInImageIndexCoordinates->Expand(timestep + 1);
   //            contourInImageIndexCoordinates->SetClosed(true, timestep);
   //            Point3D newPoint;
   //            for (int index = 0; index < cutContour.deleteSize; ++index)
   //            {
   //                newPoint[0] = cutContour.deleteCurve[ 2 * index + 0 ] - 0.5;//correction is needed because the
   //                output of the algorithm is center based
   //                newPoint[1] = cutContour.deleteCurve[ 2 * index + 1 ] - 0.5;//and we want our contour displayed
   //                corner based.
   //                newPoint[2] = 0.0;
 
   //                contourInImageIndexCoordinates->AddVertex( newPoint, timestep );
   //            }
 
   //            free(cutContour.traceline);
   //            free(cutContour.deleteCurve); // perhaps visualize this for fun?
   //            free(cutContour.onGradient);
 
   //            ContourModel::Pointer contourInWorldCoordinates = FeedbackContourTool::BackProjectContourFrom2DSlice(
   //            m_WorkingSlice->GetGeometry(), contourInImageIndexCoordinates, true ); // true: sub 0.5 for
   //            ipSegmentation correction
 
   //            FeedbackContourTool::SetFeedbackContour( contourInWorldCoordinates );
   //            FeedbackContourTool::SetFeedbackContourVisible(true);
   //            mitk::RenderingManager::GetInstance()->RequestUpdate( positionEvent->GetSender()->GetRenderWindow() );
   //            m_FillFeedbackContour = true;
   //        }
   //        else
   //        {
   //            m_FillFeedbackContour = false;
   //        }
 
   //    }
   //    else
   //    {
   //        m_FillFeedbackContour = false;
   //    }
 
   //    m_ReferenceSlice = nullptr;
 
   //    return true;
 }
 
 void mitk::RegionGrowingTool::OnMousePressedOutside(StateMachineAction *, InteractionEvent *interactionEvent)
 {
   auto *positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
 
   if (positionEvent)
   {
     // Get geometry and indices
     mitk::BaseGeometry::Pointer workingSliceGeometry;
     workingSliceGeometry = m_WorkingSlice->GetGeometry();
     itk::Index<2> indexInWorkingSlice2D;
     indexInWorkingSlice2D[0] = m_SeedPoint[0];
     indexInWorkingSlice2D[1] = m_SeedPoint[1];
 
     mitk::BaseGeometry::Pointer referenceSliceGeometry;
     referenceSliceGeometry =
       m_ReferenceSlice->GetGeometry();
     itk::Index<3> indexInReferenceSlice;
     itk::Index<2> indexInReferenceSlice2D;
     referenceSliceGeometry->WorldToIndex(positionEvent->GetPositionInWorld(), indexInReferenceSlice);
     indexInReferenceSlice2D[0] = indexInReferenceSlice[0];
     indexInReferenceSlice2D[1] = indexInReferenceSlice[1];
 
     // Get seed neighborhood
     ScalarType averageValue(0);
     AccessFixedDimensionByItk_3(m_ReferenceSlice, GetNeighborhoodAverage, 2, indexInReferenceSlice2D, &averageValue, 1);
     m_SeedValue = averageValue;
     MITK_DEBUG << "Seed value is " << m_SeedValue;
 
     // Calculate initial thresholds
     AccessFixedDimensionByItk(m_ReferenceSlice, CalculateInitialThresholds, 2);
     m_Thresholds[0] = m_InitialThresholds[0];
     m_Thresholds[1] = m_InitialThresholds[1];
 
     // Perform region growing
     mitk::Image::Pointer resultImage = mitk::Image::New();
     AccessFixedDimensionByItk_3(
       m_ReferenceSlice, StartRegionGrowing, 2, indexInWorkingSlice2D, m_Thresholds, resultImage);
     resultImage->SetGeometry(workingSliceGeometry);
 
     // Extract contour
     if (resultImage.IsNotNull() && m_ConnectedComponentValue >= 1)
     {
       float isoOffset = 0.33;
 
       mitk::ImageToContourModelFilter::Pointer contourExtractor = mitk::ImageToContourModelFilter::New();
       contourExtractor->SetInput(resultImage);
       contourExtractor->SetContourValue(m_ConnectedComponentValue - isoOffset);
       contourExtractor->Update();
       ContourModel::Pointer resultContour = ContourModel::New();
       resultContour = contourExtractor->GetOutput();
 
       // Show contour
       if (resultContour.IsNotNull())
       {
         ContourModel::Pointer resultContourWorld = FeedbackContourTool::BackProjectContourFrom2DSlice(
           workingSliceGeometry, FeedbackContourTool::ProjectContourTo2DSlice(m_WorkingSlice, resultContour));
 
         FeedbackContourTool::UpdateCurrentFeedbackContour(resultContourWorld);
 
         FeedbackContourTool::SetFeedbackContourVisible(true);
         mitk::RenderingManager::GetInstance()->RequestUpdate(m_LastEventSender->GetRenderWindow());
       }
     }
   }
 }
 
 void mitk::RegionGrowingTool::OnMouseMoved(StateMachineAction *, InteractionEvent *interactionEvent)
 {
   // Until OnMousePressedInside() implements a behaviour, we're just returning here whenever m_PaintingPixelValue is 0,
   // i.e. when the user clicked inside the segmentation
   if (m_PaintingPixelValue == 0)
   {
     return;
   }
 
   auto *positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
 
   if (m_ReferenceSlice.IsNotNull() && positionEvent)
   {
     // Get geometry and indices
     mitk::BaseGeometry::Pointer workingSliceGeometry;
     workingSliceGeometry = m_WorkingSlice->GetGeometry();
     itk::Index<2> indexInWorkingSlice2D;
     indexInWorkingSlice2D[0] = m_SeedPoint[0];
     indexInWorkingSlice2D[1] = m_SeedPoint[1];
 
     m_ScreenYDifference += positionEvent->GetPointerPositionOnScreen()[1] - m_LastScreenPosition[1];
     m_ScreenXDifference += positionEvent->GetPointerPositionOnScreen()[0] - m_LastScreenPosition[0];
     m_LastScreenPosition = Point2I(positionEvent->GetPointerPositionOnScreen());
 
     // Moving the mouse up and down adjusts the width of the threshold window,
     // moving it left and right shifts the threshold window
     m_Thresholds[0] = std::min(m_SeedValue, m_InitialThresholds[0] - (m_ScreenYDifference - m_ScreenXDifference) * m_MouseDistanceScaleFactor);
     m_Thresholds[1] = std::max(m_SeedValue, m_InitialThresholds[1] + (m_ScreenYDifference + m_ScreenXDifference) * m_MouseDistanceScaleFactor);
 
     // Do not exceed the pixel type extrema of the reference slice, though
     m_Thresholds[0] = std::max(m_ThresholdExtrema[0], m_Thresholds[0]);
     m_Thresholds[1] = std::min(m_ThresholdExtrema[1], m_Thresholds[1]);
 
     // Perform region growing again and show the result
     mitk::Image::Pointer resultImage = mitk::Image::New();
     AccessFixedDimensionByItk_3(
       m_ReferenceSlice, StartRegionGrowing, 2, indexInWorkingSlice2D, m_Thresholds, resultImage);
     resultImage->SetGeometry(workingSliceGeometry);
 
     // Update the contour
     if (resultImage.IsNotNull() && m_ConnectedComponentValue >= 1)
     {
       float isoOffset = 0.33;
 
       mitk::ImageToContourModelFilter::Pointer contourExtractor = mitk::ImageToContourModelFilter::New();
       contourExtractor->SetInput(resultImage);
       contourExtractor->SetContourValue(m_ConnectedComponentValue - isoOffset);
       contourExtractor->Update();
       ContourModel::Pointer resultContour = ContourModel::New();
       resultContour = contourExtractor->GetOutput();
 
       // Show contour
       if (resultContour.IsNotNull())
       {
         ContourModel::Pointer resultContourWorld = FeedbackContourTool::BackProjectContourFrom2DSlice(
           workingSliceGeometry, FeedbackContourTool::ProjectContourTo2DSlice(m_WorkingSlice, resultContour));
 
         FeedbackContourTool::UpdateCurrentFeedbackContour(resultContourWorld);
 
         FeedbackContourTool::SetFeedbackContourVisible(true);
         mitk::RenderingManager::GetInstance()->ForceImmediateUpdate(positionEvent->GetSender()->GetRenderWindow());
       }
     }
   }
 }
 
 void mitk::RegionGrowingTool::OnMouseReleased(StateMachineAction *, InteractionEvent *interactionEvent)
 {
   // Until OnMousePressedInside() implements a behaviour, we're just returning here whenever m_PaintingPixelValue is 0,
   // i.e. when the user clicked inside the segmentation
   if (m_PaintingPixelValue == 0)
   {
     return;
   }
 
   auto *positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
 
   if (m_WorkingSlice.IsNotNull() && m_FillFeedbackContour && positionEvent)
   {
     this->WriteBackFeedbackContourAsSegmentationResult(positionEvent, m_PaintingPixelValue);
 
     m_ScreenYDifference = 0;
     m_ScreenXDifference = 0;
   }
 }
diff --git a/Modules/Segmentation/Interactions/mitkSegTool2D.cpp b/Modules/Segmentation/Interactions/mitkSegTool2D.cpp
index 67a2b2e8d3..ab3ce6c2a5 100644
--- a/Modules/Segmentation/Interactions/mitkSegTool2D.cpp
+++ b/Modules/Segmentation/Interactions/mitkSegTool2D.cpp
@@ -1,757 +1,757 @@
 /*============================================================================
 
 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 "mitkSegTool2D.h"
 #include "mitkToolManager.h"
 
 #include "mitkBaseRenderer.h"
 #include "mitkDataStorage.h"
 
 #include "mitkPlaneGeometry.h"
 
 // Include of the new ImageExtractor
 #include "mitkMorphologicalOperations.h"
 #include "mitkPlanarCircle.h"
 
 #include "usGetModuleContext.h"
 
 // Includes for 3DSurfaceInterpolation
 #include "mitkImageTimeSelector.h"
 #include "mitkImageToContourFilter.h"
 #include "mitkSurfaceInterpolationController.h"
 
 // includes for resling and overwriting
 #include <mitkExtractSliceFilter.h>
 #include <mitkVtkImageOverwrite.h>
 #include <vtkImageData.h>
 #include <vtkSmartPointer.h>
 
 #include "mitkOperationEvent.h"
 #include "mitkUndoController.h"
 #include <mitkDiffSliceOperationApplier.h>
 
 #include "mitkAbstractTransformGeometry.h"
 #include "mitkLabelSetImage.h"
 
 #include "mitkContourModelUtils.h"
 
 #include "itkImageRegionIterator.h"
 
 #define ROUND(a) ((a) > 0 ? (int)((a) + 0.5) : -(int)(0.5 - (a)))
 
 bool mitk::SegTool2D::m_SurfaceInterpolationEnabled = true;
 
 mitk::SegTool2D::SliceInformation::SliceInformation(const mitk::Image* aSlice, const mitk::PlaneGeometry* aPlane, mitk::TimeStepType aTimestep) :
   slice(aSlice), plane(aPlane), timestep(aTimestep)
 {
 }
 
 mitk::SegTool2D::SegTool2D(const char *type, const us::Module *interactorModule)
   : Tool(type, interactorModule), m_Contourmarkername("Position")
 {
   Tool::m_EventConfig = "DisplayConfigMITKNoCrosshair.xml";
 }
 
 mitk::SegTool2D::~SegTool2D()
 {
 }
 
 bool mitk::SegTool2D::FilterEvents(InteractionEvent *interactionEvent, DataNode *)
 {
   const auto *positionEvent = dynamic_cast<const InteractionPositionEvent *>(interactionEvent);
 
   bool isValidEvent =
     (positionEvent && // Only events of type mitk::InteractionPositionEvent
      interactionEvent->GetSender()->GetMapperID() == BaseRenderer::Standard2D // Only events from the 2D renderwindows
      );
   return isValidEvent;
 }
 
 bool mitk::SegTool2D::DetermineAffectedImageSlice(const Image *image,
                                                   const PlaneGeometry *plane,
                                                   int &affectedDimension,
                                                   int &affectedSlice)
 {
   assert(image);
   assert(plane);
 
   // compare normal of plane to the three axis vectors of the image
   Vector3D normal = plane->GetNormal();
   Vector3D imageNormal0 = image->GetSlicedGeometry()->GetAxisVector(0);
   Vector3D imageNormal1 = image->GetSlicedGeometry()->GetAxisVector(1);
   Vector3D imageNormal2 = image->GetSlicedGeometry()->GetAxisVector(2);
 
   normal.Normalize();
   imageNormal0.Normalize();
   imageNormal1.Normalize();
   imageNormal2.Normalize();
 
   imageNormal0.SetVnlVector(vnl_cross_3d<ScalarType>(normal.GetVnlVector(), imageNormal0.GetVnlVector()));
   imageNormal1.SetVnlVector(vnl_cross_3d<ScalarType>(normal.GetVnlVector(), imageNormal1.GetVnlVector()));
   imageNormal2.SetVnlVector(vnl_cross_3d<ScalarType>(normal.GetVnlVector(), imageNormal2.GetVnlVector()));
 
   double eps(0.00001);
   // axial
   if (imageNormal2.GetNorm() <= eps)
   {
     affectedDimension = 2;
   }
   // sagittal
   else if (imageNormal1.GetNorm() <= eps)
   {
     affectedDimension = 1;
   }
   // frontal
   else if (imageNormal0.GetNorm() <= eps)
   {
     affectedDimension = 0;
   }
   else
   {
     affectedDimension = -1; // no idea
     return false;
   }
 
   // determine slice number in image
   BaseGeometry *imageGeometry = image->GetGeometry(0);
   Point3D testPoint = imageGeometry->GetCenter();
   Point3D projectedPoint;
   plane->Project(testPoint, projectedPoint);
 
   Point3D indexPoint;
 
   imageGeometry->WorldToIndex(projectedPoint, indexPoint);
   affectedSlice = ROUND(indexPoint[affectedDimension]);
   MITK_DEBUG << "indexPoint " << indexPoint << " affectedDimension " << affectedDimension << " affectedSlice "
              << affectedSlice;
 
   // check if this index is still within the image
   if (affectedSlice < 0 || affectedSlice >= static_cast<int>(image->GetDimension(affectedDimension)))
     return false;
 
   return true;
 }
 
 void mitk::SegTool2D::UpdateSurfaceInterpolation(const Image *slice,
                                                  const Image *workingImage,
                                                  const PlaneGeometry *plane,
                                                  bool detectIntersection)
 {
   std::vector<SliceInformation> slices = { SliceInformation(slice, plane, 0)};
   Self::UpdateSurfaceInterpolation(slices, workingImage, detectIntersection);
 }
 
 void  mitk::SegTool2D::RemoveContourFromInterpolator(const SliceInformation& sliceInfo)
 {
   mitk::SurfaceInterpolationController::ContourPositionInformation contourInfo;
   contourInfo.contourNormal = sliceInfo.plane->GetNormal();
   contourInfo.contourPoint = sliceInfo.plane->GetOrigin();
   mitk::SurfaceInterpolationController::GetInstance()->RemoveContour(contourInfo);
 }
 
 void mitk::SegTool2D::UpdateSurfaceInterpolation(const std::vector<SliceInformation>& sliceInfos,
   const Image* workingImage,
   bool detectIntersection)
 {
   if (!m_SurfaceInterpolationEnabled)
     return;
 
   //Remark: the ImageTimeSelector is just needed to extract a timestep/channel of
   //the image in order to get the image dimension (time dimension and channel dimension
   //stripped away). Therfore it is OK to always use time step 0 and channel 0
   mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
   timeSelector->SetInput(workingImage);
   timeSelector->SetTimeNr(0);
   timeSelector->SetChannelNr(0);
   timeSelector->Update();
   const auto dimRefImg = timeSelector->GetOutput()->GetDimension();
 
   if (dimRefImg != 3)
     return;
 
   std::vector<mitk::Surface::Pointer> contourList;
   contourList.reserve(sliceInfos.size());
 
   ImageToContourFilter::Pointer contourExtractor = ImageToContourFilter::New();
 
   std::vector<SliceInformation> relevantSlices = sliceInfos;
 
   if (detectIntersection)
   {
     relevantSlices.clear();
 
     for (const auto& sliceInfo : sliceInfos)
     {
       // Test whether there is something to extract or whether the slice just contains intersections of others
       mitk::Image::Pointer slice2 = sliceInfo.slice->Clone();
       mitk::MorphologicalOperations::Erode(slice2, 2, mitk::MorphologicalOperations::Ball);
 
       contourExtractor->SetInput(slice2);
       contourExtractor->Update();
       mitk::Surface::Pointer contour = contourExtractor->GetOutput();
 
       if (contour->GetVtkPolyData()->GetNumberOfPoints() == 0)
       {
         Self::RemoveContourFromInterpolator(sliceInfo);
       }
       else
       {
         relevantSlices.push_back(sliceInfo);
       }
     }
   }
 
   if (relevantSlices.empty())
     return;
 
   for (const auto& sliceInfo : relevantSlices)
   {
 
     contourExtractor->SetInput(sliceInfo.slice);
     contourExtractor->Update();
     mitk::Surface::Pointer contour = contourExtractor->GetOutput();
 
     if (contour->GetVtkPolyData()->GetNumberOfPoints() == 0)
     {
       Self::RemoveContourFromInterpolator(sliceInfo);
     }
     else
     {
       contour->DisconnectPipeline();
       contourList.push_back(contour);
     }
   }
   mitk::SurfaceInterpolationController::GetInstance()->AddNewContours(contourList);
 }
 
 
 
 mitk::Image::Pointer mitk::SegTool2D::GetAffectedImageSliceAs2DImage(const InteractionPositionEvent *positionEvent, const Image *image, unsigned int component /*= 0*/)
 {
   if (!positionEvent)
   {
     return nullptr;
   }
 
   assert(positionEvent->GetSender()); // sure, right?
   const auto timeStep = positionEvent->GetSender()->GetTimeStep(image); // get the timestep of the visible part (time-wise) of the image
 
   return GetAffectedImageSliceAs2DImage(positionEvent->GetSender()->GetCurrentWorldPlaneGeometry(), image, timeStep, component);
 }
 
 mitk::Image::Pointer mitk::SegTool2D::GetAffectedImageSliceAs2DImageByTimePoint(const PlaneGeometry* planeGeometry, const Image* image, TimePointType timePoint, unsigned int component /*= 0*/)
 {
   if (!image || !planeGeometry)
   {
     return nullptr;
   }
 
   if (!image->GetTimeGeometry()->IsValidTimePoint(timePoint))
     return nullptr;
 
   return SegTool2D::GetAffectedImageSliceAs2DImage(planeGeometry, image, image->GetTimeGeometry()->TimePointToTimeStep(timePoint), component);
 }
 
 
 mitk::Image::Pointer mitk::SegTool2D::GetAffectedImageSliceAs2DImage(const PlaneGeometry *planeGeometry, const Image *image, TimeStepType timeStep, unsigned int component /*= 0*/)
 {
   if (!image || !planeGeometry)
   {
     return nullptr;
   }
 
   // Make sure that for reslicing and overwriting the same alogrithm is used. We can specify the mode of the vtk reslicer
   vtkSmartPointer<mitkVtkImageOverwrite> reslice = vtkSmartPointer<mitkVtkImageOverwrite>::New();
   // set to false to extract a slice
   reslice->SetOverwriteMode(false);
   reslice->Modified();
 
   // use ExtractSliceFilter with our specific vtkImageReslice for overwriting and extracting
   mitk::ExtractSliceFilter::Pointer extractor = mitk::ExtractSliceFilter::New(reslice);
   extractor->SetInput(image);
   extractor->SetTimeStep(timeStep);
   extractor->SetWorldGeometry(planeGeometry);
   extractor->SetVtkOutputRequest(false);
   extractor->SetResliceTransformByGeometry(image->GetTimeGeometry()->GetGeometryForTimeStep(timeStep));
   // additionally extract the given component
   // default is 0; the extractor checks for multi-component images
   extractor->SetComponent(component);
 
   extractor->Modified();
   extractor->Update();
 
   Image::Pointer slice = extractor->GetOutput();
 
   return slice;
 }
 
 mitk::Image::Pointer mitk::SegTool2D::GetAffectedWorkingSlice(const InteractionPositionEvent *positionEvent) const
 {
   const auto workingNode = this->GetWorkingDataNode();
   if (!workingNode)
   {
     return nullptr;
   }
 
   const auto *workingImage = dynamic_cast<Image *>(workingNode->GetData());
   if (!workingImage)
   {
     return nullptr;
   }
 
   return GetAffectedImageSliceAs2DImage(positionEvent, workingImage);
 }
 
 mitk::Image::Pointer mitk::SegTool2D::GetAffectedReferenceSlice(const InteractionPositionEvent *positionEvent) const
 {
   DataNode* referenceNode = this->GetReferenceDataNode();
   if (!referenceNode)
   {
     return nullptr;
   }
 
   auto *referenceImage = dynamic_cast<Image *>(referenceNode->GetData());
   if (!referenceImage)
   {
     return nullptr;
   }
 
   int displayedComponent = 0;
   if (referenceNode->GetIntProperty("Image.Displayed Component", displayedComponent))
   {
     // found the displayed component
     return GetAffectedImageSliceAs2DImage(positionEvent, referenceImage, displayedComponent);
   }
   else
   {
     return GetAffectedImageSliceAs2DImage(positionEvent, referenceImage);
   }
 }
 
 mitk::Image::Pointer mitk::SegTool2D::GetAffectedReferenceSlice(const PlaneGeometry* planeGeometry, TimeStepType timeStep) const
 {
   DataNode* referenceNode = this->GetReferenceDataNode();
   if (!referenceNode)
   {
     return nullptr;
   }
 
   auto* referenceImage = dynamic_cast<Image*>(referenceNode->GetData());
   if (!referenceImage)
   {
     return nullptr;
   }
 
   int displayedComponent = 0;
   if (referenceNode->GetIntProperty("Image.Displayed Component", displayedComponent))
   {
     // found the displayed component
     return GetAffectedImageSliceAs2DImage(planeGeometry, referenceImage, timeStep, displayedComponent);
   }
   else
   {
     return GetAffectedImageSliceAs2DImage(planeGeometry, referenceImage, timeStep);
   }
 }
 
 void mitk::SegTool2D::Activated()
 {
   Superclass::Activated();
 
-  m_ToolManager->SelectedTimePointChanged +=
+  this->GetToolManager()->SelectedTimePointChanged +=
     mitk::MessageDelegate<mitk::SegTool2D>(this, &mitk::SegTool2D::OnTimePointChangedInternal);
 
   m_LastTimePointTriggered = mitk::RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint();
 }
 
 void mitk::SegTool2D::Deactivated()
 {
-  m_ToolManager->SelectedTimePointChanged -=
+  this->GetToolManager()->SelectedTimePointChanged -=
     mitk::MessageDelegate<mitk::SegTool2D>(this, &mitk::SegTool2D::OnTimePointChangedInternal);
   Superclass::Deactivated();
 }
 
 void mitk::SegTool2D::OnTimePointChangedInternal()
 {
   if (m_IsTimePointChangeAware && nullptr != this->GetWorkingDataNode())
   {
     const auto timePoint = mitk::RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint();
 
     if (timePoint != m_LastTimePointTriggered)
     {
       m_LastTimePointTriggered = timePoint;
       this->OnTimePointChanged();
     }
   }
 }
 
 void mitk::SegTool2D::OnTimePointChanged()
 {
   //default implementation does nothing
 }
 
 mitk::DataNode* mitk::SegTool2D::GetWorkingDataNode() const
 {
-  if (nullptr != m_ToolManager)
+  if (nullptr != this->GetToolManager())
   {
-    return m_ToolManager->GetWorkingData(0);
+    return this->GetToolManager()->GetWorkingData(0);
   }
   return nullptr;
 }
 
 mitk::Image* mitk::SegTool2D::GetWorkingData() const
 {
   auto node = this->GetWorkingDataNode();
   if (nullptr != node)
   {
     return dynamic_cast<Image*>(node->GetData());
   }
   return nullptr;
 }
 
 mitk::DataNode* mitk::SegTool2D::GetReferenceDataNode() const
 {
-  if (nullptr != m_ToolManager)
+  if (nullptr != this->GetToolManager())
   {
-    return m_ToolManager->GetReferenceData(0);
+    return this->GetToolManager()->GetReferenceData(0);
   }
   return nullptr;
 }
 
 mitk::Image* mitk::SegTool2D::GetReferenceData() const
 {
   auto node = this->GetReferenceDataNode();
   if (nullptr != node)
   {
     return dynamic_cast<Image*>(node->GetData());
   }
   return nullptr;
 }
 
 
 void mitk::SegTool2D::WriteBackSegmentationResult(const InteractionPositionEvent *positionEvent, const Image * segmentationResult)
 {
   if (!positionEvent)
     return;
 
   const PlaneGeometry *planeGeometry((positionEvent->GetSender()->GetCurrentWorldPlaneGeometry()));
   const auto *abstractTransformGeometry(
     dynamic_cast<const AbstractTransformGeometry *>(positionEvent->GetSender()->GetCurrentWorldPlaneGeometry()));
 
   if (planeGeometry && segmentationResult && !abstractTransformGeometry)
   {
     const auto workingNode = this->GetWorkingDataNode();
     auto *image = dynamic_cast<Image *>(workingNode->GetData());
     const auto timeStep = positionEvent->GetSender()->GetTimeStep(image);
     this->WriteBackSegmentationResult(planeGeometry, segmentationResult, timeStep);
   }
 }
 
 void mitk::SegTool2D::WriteBackSegmentationResult(const DataNode* workingNode, const PlaneGeometry* planeGeometry, const Image* segmentationResult, TimeStepType timeStep)
 {
   if (!planeGeometry || !segmentationResult)
     return;
 
   SliceInformation sliceInfo(segmentationResult, const_cast<mitk::PlaneGeometry*>(planeGeometry), timeStep);
   Self::WriteBackSegmentationResults(workingNode, { sliceInfo }, true);
 }
 
 void mitk::SegTool2D::WriteBackSegmentationResult(const PlaneGeometry *planeGeometry,
                                                   const Image * segmentationResult,
                                                   TimeStepType timeStep)
 {
   if (!planeGeometry || !segmentationResult)
     return;
 
   SliceInformation sliceInfo(segmentationResult, const_cast<mitk::PlaneGeometry *>(planeGeometry), timeStep);
   WriteBackSegmentationResults({ sliceInfo }, true);
 }
 
 void mitk::SegTool2D::WriteBackSegmentationResults(const std::vector<SegTool2D::SliceInformation> &sliceList,
                                                   bool writeSliceToVolume)
 {
   if (sliceList.empty())
   {
     return;
   }
 
   if (nullptr == m_LastEventSender)
   {
     MITK_WARN << "Cannot write tool results. Tool seems to be in an invalid state, as no interaction event was recieved but is expected.";
     return;
   }
 
   const auto workingNode = this->GetWorkingDataNode();
 
   mitk::SegTool2D::WriteBackSegmentationResults(workingNode, sliceList, writeSliceToVolume);
 
   // the first geometry is needed otherwise restoring the position is not working
   const auto* plane3 =
     dynamic_cast<const PlaneGeometry*>(dynamic_cast<const mitk::SlicedGeometry3D*>(
       m_LastEventSender->GetSliceNavigationController()->GetCurrentGeometry3D())
       ->GetPlaneGeometry(0));
   unsigned int slicePosition = m_LastEventSender->GetSliceNavigationController()->GetSlice()->GetPos();
 
   /* A cleaner solution would be to add a contour marker for each slice info. It currently
    does not work as the contour markers expect that the plane is always the plane of slice 0.
    Had not the time to do it properly no. Should be solved by T28146*/
   this->AddContourmarker(plane3, slicePosition);
 }
 
 void mitk::SegTool2D::WriteBackSegmentationResults(const DataNode* workingNode, const std::vector<SliceInformation>& sliceList, bool writeSliceToVolume)
 {
   if (sliceList.empty())
   {
     return;
   }
 
   if (nullptr == workingNode)
   {
     mitkThrow() << "Cannot write slice to working node. Working node is invalid.";
   }
 
   auto* image = dynamic_cast<Image*>(workingNode->GetData());
 
   if (nullptr == image)
   {
     mitkThrow() << "Cannot write slice to working node. Working node does not contain an image.";
   }
 
   for (const auto& sliceInfo : sliceList)
   {
     if (writeSliceToVolume && nullptr != sliceInfo.plane && sliceInfo.slice.IsNotNull())
     {
       mitk::SegTool2D::WriteSliceToVolume(image, sliceInfo, true);
     }
   }
 
   mitk::SegTool2D::UpdateSurfaceInterpolation(sliceList, image, false);
 
   // also mark its node as modified (T27308). Can be removed if T27307
   // is properly solved
   if (workingNode != nullptr) workingNode->Modified();
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void mitk::SegTool2D::WriteSliceToVolume(Image* workingImage, const PlaneGeometry* planeGeometry, const Image* slice, TimeStepType timeStep, bool allowUndo)
 {
   SliceInformation sliceInfo(slice, planeGeometry, timeStep);
   WriteSliceToVolume(workingImage, sliceInfo , allowUndo);
 }
 
 void mitk::SegTool2D::WriteSliceToVolume(Image* workingImage, const SliceInformation &sliceInfo, bool allowUndo)
 {
   if (nullptr == workingImage)
   {
     mitkThrow() << "Cannot write slice to working node. Working node does not contain an image.";
   }
 
   DiffSliceOperation* undoOperation = nullptr;
 
   if (allowUndo)
   {
     /*============= BEGIN undo/redo feature block ========================*/
     // Create undo operation by caching the not yet modified slices
     mitk::Image::Pointer originalSlice = GetAffectedImageSliceAs2DImage(sliceInfo.plane, workingImage, sliceInfo.timestep);
     undoOperation =
       new DiffSliceOperation(workingImage,
         originalSlice,
         dynamic_cast<SlicedGeometry3D*>(originalSlice->GetGeometry()),
         sliceInfo.timestep,
         sliceInfo.plane);
     /*============= END undo/redo feature block ========================*/
   }
 
   // Make sure that for reslicing and overwriting the same alogrithm is used. We can specify the mode of the vtk
   // reslicer
   vtkSmartPointer<mitkVtkImageOverwrite> reslice = vtkSmartPointer<mitkVtkImageOverwrite>::New();
 
   // Set the slice as 'input'
   // casting const away is needed and OK as long the OverwriteMode of
   // mitkVTKImageOverwrite is true.
   // Reason: because then the input slice is not touched but
   // used to overwrite the input of the ExtractSliceFilter.
   auto noneConstSlice = const_cast<Image*>(sliceInfo.slice.GetPointer());
   reslice->SetInputSlice(noneConstSlice->GetVtkImageData());
 
   // set overwrite mode to true to write back to the image volume
   reslice->SetOverwriteMode(true);
   reslice->Modified();
 
   mitk::ExtractSliceFilter::Pointer extractor = mitk::ExtractSliceFilter::New(reslice);
   extractor->SetInput(workingImage);
   extractor->SetTimeStep(sliceInfo.timestep);
   extractor->SetWorldGeometry(sliceInfo.plane);
   extractor->SetVtkOutputRequest(false);
   extractor->SetResliceTransformByGeometry(workingImage->GetGeometry(sliceInfo.timestep));
 
   extractor->Modified();
   extractor->Update();
 
   // the image was modified within the pipeline, but not marked so
   workingImage->Modified();
   workingImage->GetVtkImageData()->Modified();
 
   if (allowUndo)
   {
     /*============= BEGIN undo/redo feature block ========================*/
     // specify the redo operation with the edited slice
     auto* doOperation =
       new DiffSliceOperation(workingImage,
         extractor->GetOutput(),
         dynamic_cast<SlicedGeometry3D*>(sliceInfo.slice->GetGeometry()),
         sliceInfo.timestep,
         sliceInfo.plane);
 
     // create an operation event for the undo stack
     OperationEvent* undoStackItem =
       new OperationEvent(DiffSliceOperationApplier::GetInstance(), doOperation, undoOperation, "Segmentation");
 
     // add it to the undo controller
     UndoStackItem::IncCurrObjectEventId();
     UndoStackItem::IncCurrGroupEventId();
     UndoController::GetCurrentUndoModel()->SetOperationEvent(undoStackItem);
     /*============= END undo/redo feature block ========================*/
   }
 
 }
 
 
 void mitk::SegTool2D::SetShowMarkerNodes(bool status)
 {
   m_ShowMarkerNodes = status;
 }
 
 void mitk::SegTool2D::SetEnable3DInterpolation(bool enabled)
 {
   m_SurfaceInterpolationEnabled = enabled;
 }
 
 
 int mitk::SegTool2D::AddContourmarker(const PlaneGeometry* planeGeometry, unsigned int sliceIndex)
 {
   if (planeGeometry == nullptr)
     return -1;
 
   us::ServiceReference<PlanePositionManagerService> serviceRef =
     us::GetModuleContext()->GetServiceReference<PlanePositionManagerService>();
   PlanePositionManagerService *service = us::GetModuleContext()->GetService(serviceRef);
 
   unsigned int size = service->GetNumberOfPlanePositions();
   unsigned int id = service->AddNewPlanePosition(planeGeometry, sliceIndex);
 
   mitk::PlanarCircle::Pointer contourMarker = mitk::PlanarCircle::New();
   mitk::Point2D p1;
   planeGeometry->Map(planeGeometry->GetCenter(), p1);
   mitk::Point2D p2 = p1;
   p2[0] -= planeGeometry->GetSpacing()[0];
   p2[1] -= planeGeometry->GetSpacing()[1];
   contourMarker->PlaceFigure(p1);
   contourMarker->SetCurrentControlPoint(p1);
   contourMarker->SetPlaneGeometry(planeGeometry->Clone());
 
   std::stringstream markerStream;
   auto workingNode = this->GetWorkingDataNode();
 
   markerStream << m_Contourmarkername;
   markerStream << " ";
   markerStream << id + 1;
 
   DataNode::Pointer rotatedContourNode = DataNode::New();
 
   rotatedContourNode->SetData(contourMarker);
   rotatedContourNode->SetProperty("name", StringProperty::New(markerStream.str()));
   rotatedContourNode->SetProperty("isContourMarker", BoolProperty::New(true));
   rotatedContourNode->SetBoolProperty("PlanarFigureInitializedWindow", true, m_LastEventSender);
   rotatedContourNode->SetProperty("includeInBoundingBox", BoolProperty::New(false));
   rotatedContourNode->SetProperty("helper object", mitk::BoolProperty::New(!m_ShowMarkerNodes));
   rotatedContourNode->SetProperty("planarfigure.drawcontrolpoints", BoolProperty::New(false));
   rotatedContourNode->SetProperty("planarfigure.drawname", BoolProperty::New(false));
   rotatedContourNode->SetProperty("planarfigure.drawoutline", BoolProperty::New(false));
   rotatedContourNode->SetProperty("planarfigure.drawshadow", BoolProperty::New(false));
 
   if (planeGeometry)
   {
     if (id == size)
     {
-      m_ToolManager->GetDataStorage()->Add(rotatedContourNode, workingNode);
+      this->GetToolManager()->GetDataStorage()->Add(rotatedContourNode, workingNode);
     }
     else
     {
       mitk::NodePredicateProperty::Pointer isMarker =
         mitk::NodePredicateProperty::New("isContourMarker", mitk::BoolProperty::New(true));
 
       mitk::DataStorage::SetOfObjects::ConstPointer markers =
-        m_ToolManager->GetDataStorage()->GetDerivations(workingNode, isMarker);
+        this->GetToolManager()->GetDataStorage()->GetDerivations(workingNode, isMarker);
 
       for (auto iter = markers->begin(); iter != markers->end(); ++iter)
       {
         std::string nodeName = (*iter)->GetName();
         unsigned int t = nodeName.find_last_of(" ");
         unsigned int markerId = atof(nodeName.substr(t + 1).c_str()) - 1;
         if (id == markerId)
         {
           return id;
         }
       }
-      m_ToolManager->GetDataStorage()->Add(rotatedContourNode, workingNode);
+      this->GetToolManager()->GetDataStorage()->Add(rotatedContourNode, workingNode);
     }
   }
   return id;
 }
 
 void mitk::SegTool2D::InteractiveSegmentationBugMessage(const std::string &message) const
 {
   MITK_ERROR << "********************************************************************************" << std::endl
              << " " << message << std::endl
              << "********************************************************************************" << std::endl
              << "  " << std::endl
              << " If your image is rotated or the 2D views don't really contain the patient image, try to press the "
                 "button next to the image selection. "
              << std::endl
              << "  " << std::endl
              << " Please file a BUG REPORT: " << std::endl
              << " https://phabricator.mitk.org/" << std::endl
              << " Contain the following information:" << std::endl
              << "  - What image were you working on?" << std::endl
              << "  - Which region of the image?" << std::endl
              << "  - Which tool did you use?" << std::endl
              << "  - What did you do?" << std::endl
              << "  - What happened (not)? What did you expect?" << std::endl;
 }
 
 void mitk::SegTool2D::WritePreviewOnWorkingImage(
   Image *targetSlice, const Image *sourceSlice, const Image *workingImage, int paintingPixelValue)
 {
   if (nullptr == targetSlice)
   {
     mitkThrow() << "Cannot write preview on working image. Target slice does not point to a valid instance.";
   }
 
   if (nullptr == sourceSlice)
   {
     mitkThrow() << "Cannot write preview on working image. Source slice does not point to a valid instance.";
   }
 
   if (nullptr == workingImage)
   {
     mitkThrow() << "Cannot write preview on working image. Working image does not point to a valid instance.";
   }
 
   auto constVtkSource = sourceSlice->GetVtkImageData();
   /*Need to const cast because Vtk interface does not support const correctly.
    (or I am not experienced enough to use it correctly)*/
   auto nonConstVtkSource = const_cast<vtkImageData*>(constVtkSource);
 
   ContourModelUtils::FillSliceInSlice(nonConstVtkSource, targetSlice->GetVtkImageData(), workingImage, paintingPixelValue, 1.0);
 }
diff --git a/Modules/Segmentation/Interactions/mitkSegmentationsProcessingTool.cpp b/Modules/Segmentation/Interactions/mitkSegmentationsProcessingTool.cpp
index 4e6848a45c..96d82261d6 100644
--- a/Modules/Segmentation/Interactions/mitkSegmentationsProcessingTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkSegmentationsProcessingTool.cpp
@@ -1,103 +1,103 @@
 /*============================================================================
 
 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 "mitkSegmentationsProcessingTool.h"
 #include "mitkProgressBar.h"
 #include "mitkToolManager.h"
 
 mitk::SegmentationsProcessingTool::SegmentationsProcessingTool() : Tool("dummy")
 {
 }
 
 mitk::SegmentationsProcessingTool::~SegmentationsProcessingTool()
 {
 }
 
 const char *mitk::SegmentationsProcessingTool::GetGroup() const
 {
   return "segmentationProcessing";
 }
 
 void mitk::SegmentationsProcessingTool::Activated()
 {
   Superclass::Activated();
 
   ProcessAllObjects();
-  m_ToolManager->ActivateTool(-1);
+  this->GetToolManager()->ActivateTool(-1);
 }
 
 void mitk::SegmentationsProcessingTool::Deactivated()
 {
   Superclass::Deactivated();
 }
 
 void mitk::SegmentationsProcessingTool::ProcessAllObjects()
 {
   m_FailedNodes.clear();
   StartProcessingAllData();
 
-  ToolManager::DataVectorType nodes = m_ToolManager->GetWorkingData();
+  ToolManager::DataVectorType nodes = this->GetToolManager()->GetWorkingData();
   ProgressBar::GetInstance()->AddStepsToDo(nodes.size() + 2);
 
   // for all selected nodes
   for (auto nodeiter = nodes.begin(); nodeiter != nodes.end(); ++nodeiter)
   {
     DataNode::Pointer node = *nodeiter;
 
     if (!ProcessOneWorkingData(node))
     {
       std::string nodeName;
       m_FailedNodes += " '";
       if (node->GetName(nodeName))
       {
         m_FailedNodes += nodeName.c_str();
       }
       else
       {
         m_FailedNodes += "(no name)";
       }
       m_FailedNodes += "'";
     }
 
     ProgressBar::GetInstance()->Progress();
   }
 
   FinishProcessingAllData();
   ProgressBar::GetInstance()->Progress(2);
 }
 
 void mitk::SegmentationsProcessingTool::StartProcessingAllData()
 {
 }
 
 bool mitk::SegmentationsProcessingTool::ProcessOneWorkingData(DataNode *)
 {
   return true;
 }
 
 void mitk::SegmentationsProcessingTool::FinishProcessingAllData()
 {
   SendErrorMessageIfAny();
 }
 
 void mitk::SegmentationsProcessingTool::SendErrorMessageIfAny()
 {
   if (!m_FailedNodes.empty())
   {
     Tool::ErrorMessage(GetErrorMessage() + m_FailedNodes);
   }
 }
 
 std::string mitk::SegmentationsProcessingTool::GetErrorMessage()
 {
   return "Processing of these nodes failed:";
 }
diff --git a/Modules/Segmentation/Interactions/mitkSetRegionTool.cpp b/Modules/Segmentation/Interactions/mitkSetRegionTool.cpp
index da8a94ed20..486679ddaf 100644
--- a/Modules/Segmentation/Interactions/mitkSetRegionTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkSetRegionTool.cpp
@@ -1,138 +1,138 @@
 /*============================================================================
 
 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 "mitkSetRegionTool.h"
 
 #include "mitkToolManager.h"
 
 #include "mitkBaseRenderer.h"
 
 #include <mitkITKImageImport.h>
 #include <mitkImageToContourModelFilter.h>
 
 #include <itkBinaryFillholeImageFilter.h>
 #include <itkConnectedThresholdImageFilter.h>
 
 mitk::SetRegionTool::SetRegionTool(int paintingPixelValue)
   : FeedbackContourTool("PressMoveRelease"), m_PaintingPixelValue(paintingPixelValue)
 {
 }
 
 mitk::SetRegionTool::~SetRegionTool()
 {
 }
 
 void mitk::SetRegionTool::ConnectActionsAndFunctions()
 {
   CONNECT_FUNCTION("PrimaryButtonPressed", OnMousePressed);
   CONNECT_FUNCTION("Release", OnMouseReleased);
   CONNECT_FUNCTION("Move", OnMouseMoved);
 }
 
 void mitk::SetRegionTool::Activated()
 {
   Superclass::Activated();
 }
 
 void mitk::SetRegionTool::Deactivated()
 {
   Superclass::Deactivated();
 }
 
 void mitk::SetRegionTool::OnMousePressed(StateMachineAction *, InteractionEvent *interactionEvent)
 {
   auto *positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
   if (!positionEvent)
     return;
 
   m_LastEventSender = positionEvent->GetSender();
   m_LastEventSlice = m_LastEventSender->GetSlice();
 
   // 1. Get the working image
   Image::Pointer workingSlice = FeedbackContourTool::GetAffectedWorkingSlice(positionEvent);
   if (workingSlice.IsNull())
     return; // can't do anything without the segmentation
 
   // if click was outside the image, don't continue
   const BaseGeometry *sliceGeometry = workingSlice->GetGeometry();
   itk::Index<3> projectedPointIn2D;
   sliceGeometry->WorldToIndex(positionEvent->GetPositionInWorld(), projectedPointIn2D);
   if (!sliceGeometry->IsIndexInside(projectedPointIn2D))
   {
     MITK_WARN << "Point outside of segmentation slice." << std::endl;
     return; // can't use that as a seed point
   }
 
   typedef itk::Image<DefaultSegmentationDataType, 2> InputImageType;
   typedef InputImageType::IndexType IndexType;
   typedef itk::ConnectedThresholdImageFilter<InputImageType, InputImageType> RegionGrowingFilterType;
   RegionGrowingFilterType::Pointer regionGrower = RegionGrowingFilterType::New();
 
   // convert world coordinates to image indices
   IndexType seedIndex;
   sliceGeometry->WorldToIndex(positionEvent->GetPositionInWorld(), seedIndex);
 
   // perform region growing in desired segmented region
   InputImageType::Pointer itkImage = InputImageType::New();
   CastToItkImage(workingSlice, itkImage);
   regionGrower->SetInput(itkImage);
   regionGrower->AddSeed(seedIndex);
 
   InputImageType::PixelType bound = itkImage->GetPixel(seedIndex);
 
   regionGrower->SetLower(bound);
   regionGrower->SetUpper(bound);
   regionGrower->SetReplaceValue(1);
 
   itk::BinaryFillholeImageFilter<InputImageType>::Pointer fillHolesFilter =
     itk::BinaryFillholeImageFilter<InputImageType>::New();
 
   fillHolesFilter->SetInput(regionGrower->GetOutput());
   fillHolesFilter->SetForegroundValue(1);
 
   // Store result and preview
   mitk::Image::Pointer resultImage = mitk::GrabItkImageMemory(fillHolesFilter->GetOutput());
   resultImage->SetGeometry(workingSlice->GetGeometry());
   // Get the current working color
-  DataNode *workingNode(m_ToolManager->GetWorkingData(0));
+  DataNode *workingNode(this->GetToolManager()->GetWorkingData(0));
   if (!workingNode)
     return;
 
   mitk::ImageToContourModelFilter::Pointer contourextractor = mitk::ImageToContourModelFilter::New();
   contourextractor->SetInput(resultImage);
   contourextractor->Update();
 
   mitk::ContourModel::Pointer awesomeContour = contourextractor->GetOutput();
 
   this->UpdateCurrentFeedbackContour(awesomeContour);
 
   FeedbackContourTool::SetFeedbackContourVisible(true);
   mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
 }
 
 void mitk::SetRegionTool::OnMouseReleased(StateMachineAction *, InteractionEvent *interactionEvent)
 {
   auto *positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
   if (!positionEvent)
     return;
 
   assert(positionEvent->GetSender()->GetRenderWindow());
   // 1. Hide the feedback contour, find out which slice the user clicked, find out which slice of the toolmanager's
   // working image corresponds to that
   mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
 
   this->WriteBackFeedbackContourAsSegmentationResult(positionEvent, m_PaintingPixelValue);
 }
 
 void mitk::SetRegionTool::OnMouseMoved(mitk::StateMachineAction *, mitk::InteractionEvent *)
 {
 }
diff --git a/Modules/Segmentation/Interactions/mitkTool.cpp b/Modules/Segmentation/Interactions/mitkTool.cpp
index 5f15bc5dbf..e17746d67a 100644
--- a/Modules/Segmentation/Interactions/mitkTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkTool.cpp
@@ -1,333 +1,348 @@
 /*============================================================================
 
 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 "mitkTool.h"
 
 #include <mitkAnatomicalStructureColorPresets.h>
 #include "mitkDisplayInteractor.h"
 #include "mitkDisplayActionEventBroadcast.h"
 #include "mitkImageReadAccessor.h"
 #include "mitkImageWriteAccessor.h"
 #include "mitkLevelWindowProperty.h"
 #include "mitkLookupTableProperty.h"
 #include "mitkProperties.h"
 #include "mitkVtkResliceInterpolationProperty.h"
 #include <mitkDICOMSegmentationPropertyHelper.cpp>
+#include <mitkToolManager.h>
 
 // us
 #include <usGetModuleContext.h>
 #include <usModuleResource.h>
 
 // itk
 #include <itkObjectFactory.h>
 
 mitk::Tool::Tool(const char *type, const us::Module *interactorModule)
   : m_EventConfig("DisplayConfigMITK.xml"),
     m_ToolManager(nullptr),
     m_PredicateImages(NodePredicateDataType::New("Image")), // for reference images
     m_PredicateDim3(NodePredicateDimension::New(3, 1)),
     m_PredicateDim4(NodePredicateDimension::New(4, 1)),
     m_PredicateDimension(mitk::NodePredicateOr::New(m_PredicateDim3, m_PredicateDim4)),
     m_PredicateImage3D(NodePredicateAnd::New(m_PredicateImages, m_PredicateDimension)),
     m_PredicateBinary(NodePredicateProperty::New("binary", BoolProperty::New(true))),
     m_PredicateNotBinary(NodePredicateNot::New(m_PredicateBinary)),
     m_PredicateSegmentation(NodePredicateProperty::New("segmentation", BoolProperty::New(true))),
     m_PredicateNotSegmentation(NodePredicateNot::New(m_PredicateSegmentation)),
     m_PredicateHelper(NodePredicateProperty::New("helper object", BoolProperty::New(true))),
     m_PredicateNotHelper(NodePredicateNot::New(m_PredicateHelper)),
     m_PredicateImageColorful(NodePredicateAnd::New(m_PredicateNotBinary, m_PredicateNotSegmentation)),
     m_PredicateImageColorfulNotHelper(NodePredicateAnd::New(m_PredicateImageColorful, m_PredicateNotHelper)),
     m_PredicateReference(NodePredicateAnd::New(m_PredicateImage3D, m_PredicateImageColorfulNotHelper)),
     m_IsSegmentationPredicate(
       NodePredicateAnd::New(NodePredicateOr::New(m_PredicateBinary, m_PredicateSegmentation), m_PredicateNotHelper)),
     m_InteractorType(type),
     m_DisplayInteractorConfigs(),
     m_InteractorModule(interactorModule)
 {
 }
 
 mitk::Tool::~Tool()
 {
 }
 
 bool mitk::Tool::CanHandle(const BaseData* referenceData, const BaseData* /*workingData*/) const
 {
   if (referenceData == nullptr)
     return false;
 
   return true;
 }
 
 void mitk::Tool::InitializeStateMachine()
 {
   if (m_InteractorType.empty())
     return;
 
   try
   {
     auto isThisModule = nullptr == m_InteractorModule;
 
     auto module = isThisModule
       ? us::GetModuleContext()->GetModule()
       : m_InteractorModule;
 
     LoadStateMachine(m_InteractorType + ".xml", module);
     SetEventConfig(isThisModule ? "SegmentationToolsConfig.xml" : m_InteractorType + "Config.xml", module);
   }
   catch (const std::exception &e)
   {
     MITK_ERROR << "Could not load statemachine pattern " << m_InteractorType << ".xml with exception: " << e.what();
   }
 }
 
 void mitk::Tool::Notify(InteractionEvent *interactionEvent, bool isHandled)
 {
   // to use the state machine pattern,
   // the event is passed to the state machine interface to be handled
   if (!isHandled)
   {
     this->HandleEvent(interactionEvent, nullptr);
   }
 }
 
 void mitk::Tool::ConnectActionsAndFunctions()
 {
 }
 
 bool mitk::Tool::FilterEvents(InteractionEvent *, DataNode *)
 {
   return true;
 }
 
 const char *mitk::Tool::GetGroup() const
 {
   return "default";
 }
 
 void mitk::Tool::SetToolManager(ToolManager *manager)
 {
   m_ToolManager = manager;
 }
 
+mitk::ToolManager* mitk::Tool::GetToolManager() const
+{
+  return m_ToolManager;
+}
+
+mitk::DataStorage* mitk::Tool::GetDataStorage() const
+{
+  if (nullptr != m_ToolManager)
+  {
+    return m_ToolManager->GetDataStorage();
+  }
+  return nullptr;
+}
+
 void mitk::Tool::Activated()
 {
   // As a legacy solution the display interaction of the new interaction framework is disabled here to avoid conflicts
   // with tools
   // Note: this only affects InteractionEventObservers (formerly known as Listeners) all DataNode specific interaction
   // will still be enabled
   m_DisplayInteractorConfigs.clear();
   std::vector<us::ServiceReference<InteractionEventObserver>> listEventObserver =
     us::GetModuleContext()->GetServiceReferences<InteractionEventObserver>();
   for (auto it = listEventObserver.begin(); it != listEventObserver.end(); ++it)
   {
     auto displayInteractor = dynamic_cast<DisplayInteractor*>(us::GetModuleContext()->GetService<InteractionEventObserver>(*it));
     if (displayInteractor != nullptr)
     {
       // remember the original configuration
       m_DisplayInteractorConfigs.insert(std::make_pair(*it, displayInteractor->GetEventConfig()));
       // here the alternative configuration is loaded
       displayInteractor->SetEventConfig(m_EventConfig.c_str());
     }
 
     auto displayActionEventBroadcast = dynamic_cast<DisplayActionEventBroadcast*>(us::GetModuleContext()->GetService<InteractionEventObserver>(*it));
     if (displayActionEventBroadcast != nullptr)
     {
       // remember the original configuration
       m_DisplayInteractorConfigs.insert(std::make_pair(*it, displayActionEventBroadcast->GetEventConfig()));
       // here the alternative configuration is loaded
       displayActionEventBroadcast->SetEventConfig(m_EventConfig.c_str());
     }
   }
 }
 
 void mitk::Tool::Deactivated()
 {
   // Re-enabling InteractionEventObservers that have been previously disabled for legacy handling of Tools
   // in new interaction framework
   for (auto it = m_DisplayInteractorConfigs.begin(); it != m_DisplayInteractorConfigs.end(); ++it)
   {
     if (it->first)
     {
       auto displayInteractor = static_cast<DisplayInteractor*>(us::GetModuleContext()->GetService<InteractionEventObserver>(it->first));
       if (displayInteractor != nullptr)
       {
         // here the regular configuration is loaded again
         displayInteractor->SetEventConfig(it->second);
       }
 
       auto displayActionEventBroadcast = dynamic_cast<DisplayActionEventBroadcast*>(us::GetModuleContext()->GetService<InteractionEventObserver>(it->first));
       if (displayActionEventBroadcast != nullptr)
       {
         // here the regular configuration is loaded again
         displayActionEventBroadcast->SetEventConfig(it->second);
       }
     }
   }
   m_DisplayInteractorConfigs.clear();
 }
 
 itk::Object::Pointer mitk::Tool::GetGUI(const std::string &toolkitPrefix, const std::string &toolkitPostfix)
 {
   itk::Object::Pointer object;
 
   std::string classname = this->GetNameOfClass();
   std::string guiClassname = toolkitPrefix + classname + toolkitPostfix;
 
   std::list<itk::LightObject::Pointer> allGUIs = itk::ObjectFactoryBase::CreateAllInstance(guiClassname.c_str());
   for (auto iter = allGUIs.begin(); iter != allGUIs.end(); ++iter)
   {
     if (object.IsNull())
     {
       object = dynamic_cast<itk::Object *>(iter->GetPointer());
     }
     else
     {
       MITK_ERROR << "There is more than one GUI for " << classname << " (several factories claim ability to produce a "
                  << guiClassname << " ) " << std::endl;
       return nullptr; // people should see and fix this error
     }
   }
 
   return object;
 }
 
 mitk::NodePredicateBase::ConstPointer mitk::Tool::GetReferenceDataPreference() const
 {
   return m_PredicateReference.GetPointer();
 }
 
 mitk::NodePredicateBase::ConstPointer mitk::Tool::GetWorkingDataPreference() const
 {
   return m_IsSegmentationPredicate.GetPointer();
 }
 
 mitk::DataNode::Pointer mitk::Tool::CreateEmptySegmentationNode(const Image *original,
                                                                 const std::string &organName,
                                                                 const mitk::Color &color) const
 {
   // we NEED a reference image for size etc.
   if (!original)
     return nullptr;
 
   // actually create a new empty segmentation
   PixelType pixelType(mitk::MakeScalarPixelType<DefaultSegmentationDataType>());
   LabelSetImage::Pointer segmentation = LabelSetImage::New();
 
   if (original->GetDimension() == 2)
   {
     const unsigned int dimensions[] = {original->GetDimension(0), original->GetDimension(1), 1};
     segmentation->Initialize(pixelType, 3, dimensions);
     segmentation->AddLayer();
   }
   else
   {
     segmentation->Initialize(original);
   }
 
   mitk::Label::Pointer label = mitk::Label::New();
   label->SetName(organName);
   label->SetColor(color);
   label->SetValue(1);
   segmentation->GetActiveLabelSet()->AddLabel(label);
   segmentation->GetActiveLabelSet()->SetActiveLabel(1);
 
   unsigned int byteSize = sizeof(mitk::Label::PixelType);
 
   if (segmentation->GetDimension() < 4)
   {
     for (unsigned int dim = 0; dim < segmentation->GetDimension(); ++dim)
     {
       byteSize *= segmentation->GetDimension(dim);
     }
 
     mitk::ImageWriteAccessor writeAccess(segmentation.GetPointer(), segmentation->GetVolumeData(0));
 
     memset(writeAccess.GetData(), 0, byteSize);
   }
   else
   {
     // if we have a time-resolved image we need to set memory to 0 for each time step
     for (unsigned int dim = 0; dim < 3; ++dim)
     {
       byteSize *= segmentation->GetDimension(dim);
     }
 
     for (unsigned int volumeNumber = 0; volumeNumber < segmentation->GetDimension(3); volumeNumber++)
     {
       mitk::ImageWriteAccessor writeAccess(segmentation.GetPointer(), segmentation->GetVolumeData(volumeNumber));
 
       memset(writeAccess.GetData(), 0, byteSize);
     }
   }
 
   if (original->GetTimeGeometry())
   {
     TimeGeometry::Pointer originalGeometry = original->GetTimeGeometry()->Clone();
     segmentation->SetTimeGeometry(originalGeometry);
   }
   else
   {
     Tool::ErrorMessage("Original image does not have a 'Time sliced geometry'! Cannot create a segmentation.");
     return nullptr;
   }
 
   return CreateSegmentationNode(segmentation, organName, color);
 }
 
 mitk::DataNode::Pointer mitk::Tool::CreateSegmentationNode(Image *image,
                                                            const std::string &organName,
                                                            const mitk::Color &color) const
 {
   if (!image)
     return nullptr;
 
   // decorate the datatreenode with some properties
   DataNode::Pointer segmentationNode = DataNode::New();
   segmentationNode->SetData(image);
 
   // name
   segmentationNode->SetProperty("name", StringProperty::New(organName));
 
   // visualization properties
   segmentationNode->SetProperty("binary", BoolProperty::New(true));
   segmentationNode->SetProperty("color", ColorProperty::New(color));
   mitk::LookupTable::Pointer lut = mitk::LookupTable::New();
   lut->SetType(mitk::LookupTable::MULTILABEL);
   mitk::LookupTableProperty::Pointer lutProp = mitk::LookupTableProperty::New();
   lutProp->SetLookupTable(lut);
   segmentationNode->SetProperty("LookupTable", lutProp);
   segmentationNode->SetProperty("texture interpolation", BoolProperty::New(false));
   segmentationNode->SetProperty("layer", IntProperty::New(10));
   segmentationNode->SetProperty("levelwindow", LevelWindowProperty::New(LevelWindow(0.5, 1)));
   segmentationNode->SetProperty("opacity", FloatProperty::New(0.3));
   segmentationNode->SetProperty("segmentation", BoolProperty::New(true));
   segmentationNode->SetProperty("reslice interpolation",
                                 VtkResliceInterpolationProperty::New()); // otherwise -> segmentation appears in 2
                                                                          // slices sometimes (only visual effect, not
                                                                          // different data)
   // For MITK-3M3 release, the volume of all segmentations should be shown
   segmentationNode->SetProperty("showVolume", BoolProperty::New(true));
 
   return segmentationNode;
 }
 
 us::ModuleResource mitk::Tool::GetIconResource() const
 {
   // Each specific tool should load its own resource. This one will be invalid
   return us::ModuleResource();
 }
 
 us::ModuleResource mitk::Tool::GetCursorIconResource() const
 {
   // Each specific tool should load its own resource. This one will be invalid
   return us::ModuleResource();
 }
diff --git a/Modules/Segmentation/Interactions/mitkTool.h b/Modules/Segmentation/Interactions/mitkTool.h
index ddc998b8d0..c2b22ab3ad 100644
--- a/Modules/Segmentation/Interactions/mitkTool.h
+++ b/Modules/Segmentation/Interactions/mitkTool.h
@@ -1,269 +1,275 @@
 /*============================================================================
 
 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 mitkTool_h_Included
 #define mitkTool_h_Included
 
 #include "itkObjectFactoryBase.h"
 #include "itkVersion.h"
 #include "mitkCommon.h"
 #include "mitkDataNode.h"
 #include "mitkEventStateMachine.h"
 #include "mitkInteractionEventObserver.h"
 #include "mitkLabelSetImage.h"
 #include "mitkMessage.h"
 #include "mitkNodePredicateAnd.h"
 #include "mitkNodePredicateDataType.h"
 #include "mitkNodePredicateDimension.h"
 #include "mitkNodePredicateNot.h"
 #include "mitkNodePredicateOr.h"
 #include "mitkNodePredicateProperty.h"
 #include "mitkToolEvents.h"
 #include "mitkToolFactoryMacro.h"
 #include <MitkSegmentationExports.h>
 #include <mitkLabel.h>
 
 #include <iostream>
 #include <map>
 #include <string>
 
 #include <itkObject.h>
 
 #include "usServiceRegistration.h"
 
 namespace us
 {
   class ModuleResource;
 }
 
 namespace mitk
 {
   class ToolManager;
 
   /**
   \brief Base class of all tools used by mitk::ToolManager.
 
   \sa ToolManager
   \sa SegTool2D
 
   \ingroup Interaction
   \ingroup ToolManagerEtAl
 
   Every tool is a mitk::StateMachine, which can follow any transition pattern that it likes. One important thing to know
   is, that
   every derived tool should always call SuperClass::Deactivated() at the end of its own implementation of Deactivated,
   because mitk::Tool
   resets the StateMachine in this method. Only if you are very sure that you covered all possible things that might
   happen to your
   own tool, you should consider not to reset the StateMachine from time to time.
 
   To learn about the MITK implementation of state machines in general, have a look at \ref InteractionPage.
 
   To derive a non-abstract tool, you inherit from mitk::Tool (or some other base class further down the inheritance
   tree), and in your
   own parameterless constructor (that is called from the itkFactorylessNewMacro that you use) you pass a StateMachine
   pattern name to the superclass.
   Names for valid patterns can be found in StateMachine.xml (which might be enhanced by you).
 
   You have to implement at least GetXPM() and GetName() to provide some identification.
 
   Each Tool knows its ToolManager, which can provide the data that the tool should work on.
 
   \warning Only to be instantiated by mitk::ToolManager (because SetToolManager has to be called). All other uses are
   unsupported.
 
   $Author$
   */
   class MITKSEGMENTATION_EXPORT Tool : public EventStateMachine, public InteractionEventObserver
   {
   public:
     typedef mitk::Label::PixelType DefaultSegmentationDataType;
 
     /**
      * \brief To let GUI process new events (e.g. qApp->processEvents() )
      */
     Message<> GUIProcessEventsMessage;
 
     /**
      * \brief To send error messages (to be shown by some GUI)
      */
     Message1<std::string> ErrorMessage;
 
     /**
      * \brief To send whether the tool is busy (to be shown by some GUI)
      */
     Message1<bool> CurrentlyBusy;
 
     /**
      * \brief To send general messages (to be shown by some GUI)
      */
     Message1<std::string> GeneralMessage;
 
     mitkClassMacro(Tool, EventStateMachine);
 
     // no New(), there should only be subclasses
 
     /**
     \brief Returns an icon in the XPM format.
 
     This icon has to fit into some kind of button in most applications, so make it smaller than 25x25 pixels.
 
     XPM is e.g. supported by The Gimp. But if you open any XPM file in your text editor, you will see that you could
     also "draw" it with an editor.
     */
     virtual const char **GetXPM() const = 0;
 
     /**
      * \brief Returns the path of an icon.
      *
      * This icon is preferred to the XPM icon.
      */
     virtual std::string GetIconPath() const { return ""; }
     /**
      * \brief Returns the path of a cursor icon.
      *
      */
     virtual us::ModuleResource GetCursorIconResource() const;
 
     /**
      * @brief Returns the tool button icon of the tool wrapped by a usModuleResource
      * @return a valid ModuleResource or an invalid if this function
      *         is not reimplemented
      */
     virtual us::ModuleResource GetIconResource() const;
 
     /**
     \brief Returns the name of this tool. Make it short!
 
     This name has to fit into some kind of button in most applications, so take some time to think of a good name!
     */
     virtual const char *GetName() const = 0;
 
     /**
     \brief Name of a group.
 
     You can group several tools by assigning a group name. Graphical tool selectors might use this information to group
     tools. (What other reason could there be?)
     */
     virtual const char *GetGroup() const;
 
     virtual void InitializeStateMachine();
 
     /**
      * \brief Interface for GUI creation.
      *
      * This is the basic interface for creation of a GUI object belonging to one tool.
      *
      * Tools that support a GUI (e.g. for display/editing of parameters) should follow some rules:
      *
      *  - A Tool and its GUI are two separate classes
      *  - There may be several instances of a GUI at the same time.
      *  - mitk::Tool is toolkit (Qt, wxWidgets, etc.) independent, the GUI part is of course dependent
      *  - The GUI part inherits both from itk::Object and some GUI toolkit class
      *  - The GUI class name HAS to be constructed like "toolkitPrefix" tool->GetClassName() + "toolkitPostfix", e.g.
      * MyTool -> wxMyToolGUI
      *  - For each supported toolkit there is a base class for tool GUIs, which contains some convenience methods
      *  - Tools notify the GUI about changes using ITK events. The GUI must observe interesting events.
      *  - The GUI base class may convert all ITK events to the GUI toolkit's favoured messaging system (Qt -> signals)
      *  - Calling methods of a tool by its GUI is done directly.
      *    In some cases GUIs don't want to be notified by the tool when they cause a change in a tool.
      *    There is a macro CALL_WITHOUT_NOTICE(method()), which will temporarily disable all notifications during a
      * method call.
      */
     virtual itk::Object::Pointer GetGUI(const std::string &toolkitPrefix, const std::string &toolkitPostfix);
 
     virtual NodePredicateBase::ConstPointer GetReferenceDataPreference() const;
     virtual NodePredicateBase::ConstPointer GetWorkingDataPreference() const;
 
     DataNode::Pointer CreateEmptySegmentationNode(const Image *original,
                                                   const std::string &organName,
                                                   const mitk::Color &color) const;
     DataNode::Pointer CreateSegmentationNode(Image *image, const std::string &organName, const mitk::Color &color) const;
 
     /** Function used to check if a tool can handle the referenceData and (if specified) the working data.
      @pre referenceData must be a valid pointer
      @param referenceData Pointer to the data that should be checked as valid reference for the tool.
      @param workingData Pointer to the data that should be checked as valid working data for this tool.
      This parameter can be null if no working data is specified so far.*/
     virtual bool CanHandle(const BaseData *referenceData, const BaseData *workingData) const;
 
   protected:
     friend class ToolManager;
 
     virtual void SetToolManager(ToolManager *);
+    /** Returns the pointer to the tool manager of the tool. May be null.*/
+    ToolManager* GetToolManager() const;
+
+    /** Returns the data storage provided by the toolmanager. May be null (e.g. if
+     Toolmanager is not set).*/
+    mitk::DataStorage* GetDataStorage() const;
 
     void ConnectActionsAndFunctions() override;
 
     /**
     \brief Called when the tool gets activated.
 
     Derived tools should call their parents implementation at the beginning of the overriding function.
     */
     virtual void Activated();
 
     /**
     \brief Called when the tool gets deactivated.
 
     Derived tools should call their parents implementation at the end of the overriding function.
     */
     virtual void Deactivated();
 
     /**
     \brief Let subclasses change their event configuration.
     */
     std::string m_EventConfig;
 
     Tool(const char *, const us::Module *interactorModule = nullptr); // purposely hidden
     ~Tool() override;
 
     void Notify(InteractionEvent *interactionEvent, bool isHandled) override;
 
     bool FilterEvents(InteractionEvent *, DataNode *) override;
 
-    ToolManager *m_ToolManager;
-
   private:
+    ToolManager* m_ToolManager;
+
     // for reference data
     NodePredicateDataType::Pointer m_PredicateImages;
     NodePredicateDimension::Pointer m_PredicateDim3;
     NodePredicateDimension::Pointer m_PredicateDim4;
     NodePredicateOr::Pointer m_PredicateDimension;
     NodePredicateAnd::Pointer m_PredicateImage3D;
 
     NodePredicateProperty::Pointer m_PredicateBinary;
     NodePredicateNot::Pointer m_PredicateNotBinary;
 
     NodePredicateProperty::Pointer m_PredicateSegmentation;
     NodePredicateNot::Pointer m_PredicateNotSegmentation;
 
     NodePredicateProperty::Pointer m_PredicateHelper;
     NodePredicateNot::Pointer m_PredicateNotHelper;
 
     NodePredicateAnd::Pointer m_PredicateImageColorful;
 
     NodePredicateAnd::Pointer m_PredicateImageColorfulNotHelper;
 
     NodePredicateAnd::Pointer m_PredicateReference;
 
     // for working data
     NodePredicateAnd::Pointer m_IsSegmentationPredicate;
 
     std::string m_InteractorType;
 
     std::map<us::ServiceReferenceU, EventConfig> m_DisplayInteractorConfigs;
 
     const us::Module *m_InteractorModule;
   };
 
 } // namespace
 
 #endif