diff --git a/Modules/Segmentation/Interactions/mitkAutoSegmentationTool.cpp b/Modules/Segmentation/Interactions/mitkAutoSegmentationTool.cpp
index fd762377a1..c360e1db47 100644
--- a/Modules/Segmentation/Interactions/mitkAutoSegmentationTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkAutoSegmentationTool.cpp
@@ -1,84 +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 "mitkAutoSegmentationTool.h"
 #include "mitkImage.h"
 #include "mitkToolManager.h"
 #include <mitkImageTimeSelector.h>
 
 mitk::AutoSegmentationTool::AutoSegmentationTool() : Tool("dummy"), m_OverwriteExistingSegmentation(false)
 {
 }
 
 mitk::AutoSegmentationTool::~AutoSegmentationTool()
 {
 }
 
 const char *mitk::AutoSegmentationTool::GetGroup() const
 {
   return "autoSegmentation";
 }
 
-mitk::Image::Pointer mitk::AutoSegmentationTool::Get3DImage(mitk::Image::Pointer image, unsigned int timestep)
+mitk::Image::ConstPointer mitk::AutoSegmentationTool::Get3DImage(const mitk::Image* image, unsigned int timestep) const
 {
+  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::Get3DImageByTimePoint(const mitk::Image* image, TimePointType timePoint) const
+{
+  if (nullptr == image)
+    return image;
+
+  if (!image->GetTimeGeometry()->IsValidTimePoint(timePoint))
+    return nullptr;
+
+  return this->Get3DImage(image, image->GetTimeGeometry()->TimePointToTimeStep(timePoint));
+}
+
 void mitk::AutoSegmentationTool::SetOverwriteExistingSegmentation(bool overwrite)
 {
   m_OverwriteExistingSegmentation = overwrite;
 }
 
 std::string mitk::AutoSegmentationTool::GetCurrentSegmentationName()
 {
   if (m_ToolManager->GetWorkingData(0))
     return m_ToolManager->GetWorkingData(0)->GetName();
   else
     return "";
 }
 
 mitk::DataNode *mitk::AutoSegmentationTool::GetTargetSegmentationNode()
 {
   mitk::DataNode::Pointer emptySegmentation;
   if (m_OverwriteExistingSegmentation)
   {
     emptySegmentation = m_ToolManager->GetWorkingData(0);
   }
   else
   {
     mitk::DataNode::Pointer refNode = m_ToolManager->GetReferenceData(0);
     if (refNode.IsNull())
     {
       // TODO create and use segmentation exceptions instead!!
       MITK_ERROR << "No valid reference data!";
       return nullptr;
     }
     std::string nodename = m_ToolManager->GetReferenceData(0)->GetName() + "_" + this->GetName();
     mitk::Color color;
     color.SetRed(1);
     color.SetBlue(0);
     color.SetGreen(0);
     emptySegmentation = CreateEmptySegmentationNode(dynamic_cast<mitk::Image *>(refNode->GetData()), nodename, color);
     m_ToolManager->GetDataStorage()->Add(emptySegmentation, refNode);
   }
   return emptySegmentation;
 }
diff --git a/Modules/Segmentation/Interactions/mitkAutoSegmentationTool.h b/Modules/Segmentation/Interactions/mitkAutoSegmentationTool.h
index 334a684818..1a2d458950 100644
--- a/Modules/Segmentation/Interactions/mitkAutoSegmentationTool.h
+++ b/Modules/Segmentation/Interactions/mitkAutoSegmentationTool.h
@@ -1,64 +1,65 @@
 /*============================================================================
 
 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 mitkAutoSegmentationTool_h_Included
 #define mitkAutoSegmentationTool_h_Included
 
 #include "mitkCommon.h"
 #include "mitkTool.h"
 #include <MitkSegmentationExports.h>
 
 namespace mitk
 {
   class Image;
 
   /**
     \brief Superclass for tool that create a new segmentation without user interaction in render windows
 
     This class is undocumented. Ask the creator ($Author$) to supply useful comments.
   */
   class MITKSEGMENTATION_EXPORT AutoSegmentationTool : public Tool
   {
   public:
     mitkClassMacro(AutoSegmentationTool, Tool);
 
     void SetOverwriteExistingSegmentation(bool overwrite);
 
     /**
      * @brief Gets the name of the currently selected segmentation node
      * @return the name of the segmentation node or an empty string if
      *         none is selected
      */
     std::string GetCurrentSegmentationName();
 
     /**
      * @brief Depending on the selected mode either returns the currently selected segmentation
      *        or creates a new one from the selected reference data and adds the new segmentation
      *        to the datastorage
      * @return a mitk::DataNode which contains a segmentation image
      */
     virtual mitk::DataNode *GetTargetSegmentationNode();
 
   protected:
     AutoSegmentationTool(); // purposely hidden
     ~AutoSegmentationTool() override;
 
     const char *GetGroup() const override;
 
-    virtual itk::SmartPointer<Image> Get3DImage(itk::SmartPointer<Image> image, unsigned int timestep);
+    virtual Image::ConstPointer Get3DImage(const Image* image, unsigned int timestep) const;
+    virtual Image::ConstPointer Get3DImageByTimePoint(const Image* image, TimePointType timePoint) const;
 
     bool m_OverwriteExistingSegmentation;
   };
 
 } // namespace
 
 #endif
diff --git a/Modules/Segmentation/Interactions/mitkOtsuTool3D.cpp b/Modules/Segmentation/Interactions/mitkOtsuTool3D.cpp
index b38f9af9a0..917451a48c 100644
--- a/Modules/Segmentation/Interactions/mitkOtsuTool3D.cpp
+++ b/Modules/Segmentation/Interactions/mitkOtsuTool3D.cpp
@@ -1,307 +1,277 @@
 /*============================================================================
 
 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.
 
 ============================================================================*/
 
 // MITK
 #include "mitkOtsuTool3D.h"
 #include "mitkImageAccessByItk.h"
 #include "mitkLabelSetImage.h"
 #include "mitkOtsuSegmentationFilter.h"
 #include "mitkRenderingManager.h"
 #include "mitkToolManager.h"
 #include <mitkITKImageImport.h>
 #include <mitkImageCast.h>
 #include <mitkLevelWindowProperty.h>
 #include <mitkLookupTableProperty.h>
 #include <mitkRenderingModeProperty.h>
 #include <mitkSliceNavigationController.h>
 
 // ITK
 #include <itkBinaryThresholdImageFilter.h>
 #include <itkOrImageFilter.h>
 #include <itkOtsuMultipleThresholdsImageFilter.h>
 
 // us
 #include <usGetModuleContext.h>
 #include <usModule.h>
 #include <usModuleContext.h>
 #include <usModuleResource.h>
 
 #include <mitkImageStatisticsHolder.h>
 
 namespace mitk
 {
   MITK_TOOL_MACRO(MITKSEGMENTATION_EXPORT, OtsuTool3D, "Otsu Segmentation");
 }
 
 mitk::OtsuTool3D::OtsuTool3D()
 {
 }
 
 mitk::OtsuTool3D::~OtsuTool3D()
 {
 }
 
 void mitk::OtsuTool3D::Activated()
 {
   Superclass::Activated();
 
   if (m_ToolManager)
   {
     m_OriginalImage = dynamic_cast<mitk::Image *>(m_ToolManager->GetReferenceData(0)->GetData());
 
     m_BinaryPreviewNode = mitk::DataNode::New();
     m_BinaryPreviewNode->SetName("Binary_Preview");
     m_BinaryPreviewNode->SetProperty("color", ColorProperty::New(0.0, 1.0, 0.0));
     m_BinaryPreviewNode->SetProperty("opacity", FloatProperty::New(0.3));
     // m_BinaryPreviewNode->SetBoolProperty("helper object", true);
     // m_BinaryPreviewNode->SetProperty("binary", mitk::BoolProperty::New(true));
     m_ToolManager->GetDataStorage()->Add(this->m_BinaryPreviewNode);
 
     m_MultiLabelResultNode = mitk::DataNode::New();
     m_MultiLabelResultNode->SetName("Otsu_Preview");
     // m_MultiLabelResultNode->SetBoolProperty("helper object", true);
     m_MultiLabelResultNode->SetVisibility(true);
 
     m_MaskedImagePreviewNode = mitk::DataNode::New();
     m_MaskedImagePreviewNode->SetName("Volume_Preview");
     // m_MultiLabelResultNode->SetBoolProperty("helper object", true);
     m_MaskedImagePreviewNode->SetVisibility(false);
 
     m_ToolManager->GetDataStorage()->Add(this->m_MultiLabelResultNode);
   }
 }
 
 void mitk::OtsuTool3D::Deactivated()
 {
   m_ToolManager->GetDataStorage()->Remove(this->m_MultiLabelResultNode);
   m_MultiLabelResultNode = nullptr;
   m_ToolManager->GetDataStorage()->Remove(this->m_BinaryPreviewNode);
   m_BinaryPreviewNode = nullptr;
   m_ToolManager->GetDataStorage()->Remove(this->m_MaskedImagePreviewNode);
   m_MaskedImagePreviewNode = nullptr;
 
   Superclass::Deactivated();
 }
 
 const char **mitk::OtsuTool3D::GetXPM() const
 {
   return nullptr;
 }
 
 us::ModuleResource mitk::OtsuTool3D::GetIconResource() const
 {
   us::Module *module = us::GetModuleContext()->GetModule();
   us::ModuleResource resource = module->GetResource("Otsu_48x48.png");
   return resource;
 }
 
 void mitk::OtsuTool3D::RunSegmentation(int regions, bool useValley, int numberOfBins)
 {
-  // this->m_OtsuSegmentationDialog->setCursor(Qt::WaitCursor);
-
   int numberOfThresholds = regions - 1;
 
-  unsigned int timestep = mitk::RenderingManager::GetInstance()->GetTimeNavigationController()->GetTime()->GetPos();
 
-  mitk::Image::Pointer image3D = Get3DImage(m_OriginalImage, timestep);
+  const auto timePoint = mitk::RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint();
+  auto image3D = Get3DImageByTimePoint(m_OriginalImage, timePoint);
+
+  if (nullptr == image3D)
+  {
+    MITK_WARN << "Cannot run segementation. Currently selected timepoint is not in the time bounds of the selected reference image. Time point: " << timePoint;
+    return;
+  }
 
   mitk::OtsuSegmentationFilter::Pointer otsuFilter = mitk::OtsuSegmentationFilter::New();
   otsuFilter->SetNumberOfThresholds(numberOfThresholds);
   otsuFilter->SetValleyEmphasis(useValley);
   otsuFilter->SetNumberOfBins(numberOfBins);
   otsuFilter->SetInput(image3D);
 
   try
   {
     otsuFilter->Update();
   }
   catch (...)
   {
     mitkThrow() << "itkOtsuFilter error (image dimension must be in {2, 3} and image must not be RGB)";
   }
 
   m_ToolManager->GetDataStorage()->Remove(this->m_MultiLabelResultNode);
   m_MultiLabelResultNode = nullptr;
   m_MultiLabelResultNode = mitk::DataNode::New();
   m_MultiLabelResultNode->SetName("Otsu_Preview");
   m_MultiLabelResultNode->SetVisibility(true);
   m_ToolManager->GetDataStorage()->Add(this->m_MultiLabelResultNode);
   m_MultiLabelResultNode->SetOpacity(1.0);
 
   mitk::LabelSetImage::Pointer resultImage = mitk::LabelSetImage::New();
   resultImage->InitializeByLabeledImage(otsuFilter->GetOutput());
   this->m_MultiLabelResultNode->SetData(resultImage);
   m_MultiLabelResultNode->SetProperty("binary", mitk::BoolProperty::New(false));
   mitk::RenderingModeProperty::Pointer renderingMode = mitk::RenderingModeProperty::New();
   renderingMode->SetValue(mitk::RenderingModeProperty::LOOKUPTABLE_LEVELWINDOW_COLOR);
   m_MultiLabelResultNode->SetProperty("Image Rendering.Mode", renderingMode);
   mitk::LookupTable::Pointer lut = mitk::LookupTable::New();
   mitk::LookupTableProperty::Pointer prop = mitk::LookupTableProperty::New(lut);
   vtkSmartPointer<vtkLookupTable> lookupTable = vtkSmartPointer<vtkLookupTable>::New();
   lookupTable->SetHueRange(1.0, 0.0);
   lookupTable->SetSaturationRange(1.0, 1.0);
   lookupTable->SetValueRange(1.0, 1.0);
   lookupTable->SetTableRange(-1.0, 1.0);
   lookupTable->Build();
   lut->SetVtkLookupTable(lookupTable);
   prop->SetLookupTable(lut);
   m_MultiLabelResultNode->SetProperty("LookupTable", prop);
   mitk::LevelWindowProperty::Pointer levWinProp = mitk::LevelWindowProperty::New();
   mitk::LevelWindow levelwindow;
   levelwindow.SetRangeMinMax(0, numberOfThresholds + 1);
   levWinProp->SetLevelWindow(levelwindow);
   m_MultiLabelResultNode->SetProperty("levelwindow", levWinProp);
 
   // m_BinaryPreviewNode->SetVisibility(false);
   //  m_MultiLabelResultNode->SetVisibility(true);
   // this->m_OtsuSegmentationDialog->setCursor(Qt::ArrowCursor);
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void mitk::OtsuTool3D::ConfirmSegmentation()
 {
   mitk::LabelSetImage::Pointer resultImage = mitk::LabelSetImage::New();
   resultImage->InitializeByLabeledImage(dynamic_cast<mitk::Image *>(m_BinaryPreviewNode->GetData()));
   GetTargetSegmentationNode()->SetData(resultImage);
 
   m_ToolManager->ActivateTool(-1);
 }
 
 void mitk::OtsuTool3D::UpdateBinaryPreview(std::vector<int> regionIDs)
 {
   m_MultiLabelResultNode->SetVisibility(false);
   mitk::Image::Pointer multiLabelSegmentation = dynamic_cast<mitk::Image *>(m_MultiLabelResultNode->GetData());
   AccessByItk_1(multiLabelSegmentation, CalculatePreview, regionIDs);
 }
 
 template <typename TPixel, unsigned int VImageDimension>
 void mitk::OtsuTool3D::CalculatePreview(itk::Image<TPixel, VImageDimension> *itkImage, std::vector<int> regionIDs)
 {
   typedef itk::Image<TPixel, VImageDimension> InputImageType;
   typedef itk::Image<mitk::Tool::DefaultSegmentationDataType, VImageDimension> OutputImageType;
 
   typedef itk::BinaryThresholdImageFilter<InputImageType, OutputImageType> FilterType;
 
   typename FilterType::Pointer filter = FilterType::New();
 
   // InputImageType::Pointer itkImage;
   typename OutputImageType::Pointer itkBinaryTempImage1;
   typename OutputImageType::Pointer itkBinaryTempImage2;
   typename OutputImageType::Pointer itkBinaryResultImage;
 
   // mitk::Image::Pointer multiLabelSegmentation = dynamic_cast<mitk::Image*>(m_MultiLabelResultNode->GetData());
   // mitk::CastToItkImage(multiLabelSegmentation, itkImage);
 
   filter->SetInput(itkImage);
   filter->SetLowerThreshold(regionIDs[0]);
   filter->SetUpperThreshold(regionIDs[0]);
   filter->SetInsideValue(1);
   filter->SetOutsideValue(0);
   filter->Update();
   itkBinaryTempImage2 = filter->GetOutput();
 
   typename itk::OrImageFilter<OutputImageType, OutputImageType>::Pointer orFilter =
     itk::OrImageFilter<OutputImageType, OutputImageType>::New();
 
   // if more than one region id is used compute the union of all given binary regions
   for (auto it = regionIDs.begin(); it != regionIDs.end(); ++it)
   {
     filter->SetLowerThreshold(*it);
     filter->SetUpperThreshold(*it);
     filter->SetInsideValue(1);
     filter->SetOutsideValue(0);
     filter->Update();
     itkBinaryTempImage1 = filter->GetOutput();
 
     orFilter->SetInput1(itkBinaryTempImage1);
     orFilter->SetInput2(itkBinaryTempImage2);
 
     orFilter->UpdateLargestPossibleRegion();
     itkBinaryResultImage = orFilter->GetOutput();
     itkBinaryTempImage2 = itkBinaryResultImage;
   }
   //----------------------------------------------------------------------------------------------------
   mitk::Image::Pointer binarySegmentation;
   mitk::CastToMitkImage(itkBinaryResultImage, binarySegmentation);
   m_BinaryPreviewNode->SetData(binarySegmentation);
   m_BinaryPreviewNode->SetVisibility(true);
   m_BinaryPreviewNode->SetProperty("outline binary", mitk::BoolProperty::New(false));
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
-// void mitk::OtsuTool3D::UpdateBinaryPreview(int regionID)
-//{
-//  m_MultiLabelResultNode->SetVisibility(false);
-//  //pixel with regionID -> binary image
-//  const unsigned short dim = 3;
-//  typedef unsigned char PixelType;
-//
-//  typedef itk::Image< PixelType, dim > InputImageType;
-//  typedef itk::Image< PixelType, dim > OutputImageType;
-//
-//  typedef itk::BinaryThresholdImageFilter< InputImageType, OutputImageType > FilterType;
-//
-//  FilterType::Pointer filter = FilterType::New();
-//
-//  InputImageType::Pointer itkImage;
-//
-//  mitk::Image::Pointer multiLabelSegmentation = dynamic_cast<mitk::Image*>(m_MultiLabelResultNode->GetData());
-//  mitk::CastToItkImage(multiLabelSegmentation, itkImage);
-//
-//  filter->SetInput(itkImage);
-//  filter->SetLowerThreshold(regionID);
-//  filter->SetUpperThreshold(regionID);
-//  filter->SetInsideValue(1);
-//  filter->SetOutsideValue(0);
-//  filter->Update();
-//  mitk::Image::Pointer binarySegmentation;
-//  mitk::CastToMitkImage( filter->GetOutput(), binarySegmentation);
-//  m_BinaryPreviewNode->SetData(binarySegmentation);
-//  m_BinaryPreviewNode->SetVisibility(true);
-//  m_BinaryPreviewNode->SetProperty("outline binary", mitk::BoolProperty::New(false));
-//
-//  mitk::RenderingManager::GetInstance()->RequestUpdateAll();
-//}
-
 const char *mitk::OtsuTool3D::GetName() const
 {
   return "Otsu";
 }
 
 void mitk::OtsuTool3D::UpdateVolumePreview(bool volumeRendering)
 {
   if (volumeRendering)
   {
     m_MaskedImagePreviewNode->SetBoolProperty("volumerendering", true);
     m_MaskedImagePreviewNode->SetBoolProperty("volumerendering.uselod", true);
   }
   else
   {
     m_MaskedImagePreviewNode->SetBoolProperty("volumerendering", false);
   }
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void mitk::OtsuTool3D::ShowMultiLabelResultNode(bool show)
 {
   m_MultiLabelResultNode->SetVisibility(show);
   m_BinaryPreviewNode->SetVisibility(!show);
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 int mitk::OtsuTool3D::GetNumberOfBins()
 {
   ScalarType min = m_OriginalImage.GetPointer()->GetStatistics()->GetScalarValueMin();
   ScalarType max = m_OriginalImage.GetPointer()->GetStatistics()->GetScalarValueMaxNoRecompute();
   return static_cast<int>(max - min) + 1;
 }
diff --git a/Modules/Segmentation/Interactions/mitkWatershedTool.cpp b/Modules/Segmentation/Interactions/mitkWatershedTool.cpp
index db48041dee..15fd3ff488 100644
--- a/Modules/Segmentation/Interactions/mitkWatershedTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkWatershedTool.cpp
@@ -1,182 +1,188 @@
 /*============================================================================
 
 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 "mitkWatershedTool.h"
 
 #include "mitkIOUtil.h"
 #include "mitkITKImageImport.h"
 #include "mitkImage.h"
 #include "mitkLabelSetImage.h"
 #include "mitkImageAccessByItk.h"
 #include "mitkImageCast.h"
 #include "mitkImageStatisticsHolder.h"
 #include "mitkLevelWindowManager.h"
 #include "mitkLookupTable.h"
 #include "mitkLookupTableProperty.h"
 #include "mitkProgressBar.h"
 #include "mitkRenderingManager.h"
 #include "mitkRenderingModeProperty.h"
 #include "mitkToolCommand.h"
 #include "mitkToolManager.h"
 #include <mitkSliceNavigationController.h>
 
 #include <usGetModuleContext.h>
 #include <usModule.h>
 #include <usModuleContext.h>
 #include <usModuleResource.h>
 
 #include <vtkLookupTable.h>
 
 #include <itkExceptionObject.h>
 #include <itkGradientMagnitudeRecursiveGaussianImageFilter.h>
 #include <itkWatershedImageFilter.h>
 
 namespace mitk
 {
   MITK_TOOL_MACRO(MITKSEGMENTATION_EXPORT, WatershedTool, "Watershed tool");
 }
 
 mitk::WatershedTool::WatershedTool() : m_Threshold(0.0), m_Level(0.0)
 {
 }
 
 mitk::WatershedTool::~WatershedTool()
 {
 }
 
 void mitk::WatershedTool::Activated()
 {
   Superclass::Activated();
 }
 
 void mitk::WatershedTool::Deactivated()
 {
   Superclass::Deactivated();
 }
 
 us::ModuleResource mitk::WatershedTool::GetIconResource() const
 {
   us::Module *module = us::GetModuleContext()->GetModule();
   us::ModuleResource resource = module->GetResource("Watershed_48x48.png");
   return resource;
 }
 
 const char **mitk::WatershedTool::GetXPM() const
 {
   return nullptr;
 }
 
 const char *mitk::WatershedTool::GetName() const
 {
   return "Watershed";
 }
 
 void mitk::WatershedTool::DoIt()
 {
   // get image from tool manager
   mitk::DataNode::Pointer referenceData = m_ToolManager->GetReferenceData(0);
-  mitk::Image::Pointer input = dynamic_cast<mitk::Image *>(referenceData->GetData());
+  mitk::Image::ConstPointer input = dynamic_cast<const mitk::Image *>(referenceData->GetData());
   if (input.IsNull())
     return;
 
-  unsigned int timestep = mitk::RenderingManager::GetInstance()->GetTimeNavigationController()->GetTime()->GetPos();
-  input = Get3DImage(input, timestep);
+  const auto timePoint = mitk::RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint();
+  input = Get3DImageByTimePoint(input, timePoint);
+
+  if (nullptr == input)
+  {
+    MITK_WARN << "Cannot run segementation. Currently selected timepoint is not in the time bounds of the selected reference image. Time point: " << timePoint;
+    return;
+  }
 
   mitk::Image::Pointer output;
 
   try
   {
     // create and run itk filter pipeline
     AccessByItk_1(input.GetPointer(), ITKWatershed, output);
 
     mitk::LabelSetImage::Pointer labelSetOutput = mitk::LabelSetImage::New();
     labelSetOutput->InitializeByLabeledImage(output);
 
     // create a new datanode for output
     mitk::DataNode::Pointer dataNode = mitk::DataNode::New();
     dataNode->SetData(labelSetOutput);
 
     // set name of data node
     std::string name = referenceData->GetName() + "_Watershed";
     dataNode->SetName(name);
 
     // look, if there is already a node with this name
     mitk::DataStorage::SetOfObjects::ConstPointer children =
       m_ToolManager->GetDataStorage()->GetDerivations(referenceData);
     mitk::DataStorage::SetOfObjects::ConstIterator currentNode = children->Begin();
     mitk::DataNode::Pointer removeNode;
     while (currentNode != children->End())
     {
       if (dataNode->GetName().compare(currentNode->Value()->GetName()) == 0)
       {
         removeNode = currentNode->Value();
       }
       currentNode++;
     }
     // remove node with same name
     if (removeNode.IsNotNull())
       m_ToolManager->GetDataStorage()->Remove(removeNode);
 
     // add output to the data storage
     m_ToolManager->GetDataStorage()->Add(dataNode, referenceData);
   }
   catch (itk::ExceptionObject &e)
   {
     MITK_ERROR << "Watershed Filter Error: " << e.GetDescription();
   }
 
   RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 template <typename TPixel, unsigned int VImageDimension>
-void mitk::WatershedTool::ITKWatershed(itk::Image<TPixel, VImageDimension> *originalImage,
+void mitk::WatershedTool::ITKWatershed(const itk::Image<TPixel, VImageDimension> *originalImage,
                                        mitk::Image::Pointer &segmentation)
 {
   typedef itk::WatershedImageFilter<itk::Image<float, VImageDimension>> WatershedFilter;
   typedef itk::GradientMagnitudeRecursiveGaussianImageFilter<itk::Image<TPixel, VImageDimension>,
                                                              itk::Image<float, VImageDimension>>
     MagnitudeFilter;
 
   // at first add a gradient magnitude filter
   typename MagnitudeFilter::Pointer magnitude = MagnitudeFilter::New();
   magnitude->SetInput(originalImage);
   magnitude->SetSigma(1.0);
 
   // use the progress bar
   mitk::ToolCommand::Pointer command = mitk::ToolCommand::New();
   command->AddStepsToDo(60);
 
   // then add the watershed filter to the pipeline
   typename WatershedFilter::Pointer watershed = WatershedFilter::New();
   watershed->SetInput(magnitude->GetOutput());
   watershed->SetThreshold(m_Threshold);
   watershed->SetLevel(m_Level);
   watershed->AddObserver(itk::ProgressEvent(), command);
   watershed->Update();
 
   // then make sure, that the output has the desired pixel type
   typedef itk::CastImageFilter<typename WatershedFilter::OutputImageType,
                                itk::Image<Tool::DefaultSegmentationDataType, VImageDimension>>
     CastFilter;
   typename CastFilter::Pointer cast = CastFilter::New();
   cast->SetInput(watershed->GetOutput());
 
   // start the whole pipeline
   cast->Update();
 
   // reset the progress bar by setting progress
   command->SetProgress(10);
 
   // since we obtain a new image from our pipeline, we have to make sure, that our mitk::Image::Pointer
   // is responsible for the memory management of the output image
   segmentation = mitk::GrabItkImageMemory(cast->GetOutput());
 }
diff --git a/Modules/Segmentation/Interactions/mitkWatershedTool.h b/Modules/Segmentation/Interactions/mitkWatershedTool.h
index 21e8a3e905..f50734141b 100644
--- a/Modules/Segmentation/Interactions/mitkWatershedTool.h
+++ b/Modules/Segmentation/Interactions/mitkWatershedTool.h
@@ -1,88 +1,88 @@
 /*============================================================================
 
 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 mitkWatershedTool_h_Included
 #define mitkWatershedTool_h_Included
 
 #include "mitkAutoSegmentationTool.h"
 #include "mitkCommon.h"
 #include <MitkSegmentationExports.h>
 #include <itkImage.h>
 
 namespace us
 {
   class ModuleResource;
 }
 
 namespace mitk
 {
   class Image;
 
   /**
     \brief Simple watershed segmentation tool.
 
     \ingroup Interaction
     \ingroup ToolManagerEtAl
 
     Wraps ITK Watershed Filter into tool concept of MITK. For more information look into ITK documentation.
 
     \warning Only to be instantiated by mitk::ToolManager.
 
     $Darth Vader$
   */
   class MITKSEGMENTATION_EXPORT WatershedTool : public AutoSegmentationTool
   {
   public:
     mitkClassMacro(WatershedTool, AutoSegmentationTool);
     itkFactorylessNewMacro(Self);
     itkCloneMacro(Self);
 
       void SetThreshold(double t)
     {
       m_Threshold = t;
     }
 
     void SetLevel(double l) { m_Level = l; }
     /** \brief Grabs the tool reference data and creates an ITK pipeline consisting of a GradientMagnitude
       * image filter followed by a Watershed image filter. The output of the filter pipeline is then added
       * to the data storage. */
     void DoIt();
 
     /** \brief Creates and runs an ITK filter pipeline consisting of the filters: GradientMagnitude-, Watershed- and
      * CastImageFilter.
       *
       * \param originalImage The input image, which is delivered by the AccessByItk macro.
       * \param segmentation A pointer to the output image, which will point to the pipeline output after execution.
       */
     template <typename TPixel, unsigned int VImageDimension>
-    void ITKWatershed(itk::Image<TPixel, VImageDimension> *originalImage, itk::SmartPointer<mitk::Image> &segmentation);
+    void ITKWatershed(const itk::Image<TPixel, VImageDimension> *originalImage, itk::SmartPointer<mitk::Image> &segmentation);
 
     const char **GetXPM() const override;
     const char *GetName() const override;
     us::ModuleResource GetIconResource() const override;
 
   protected:
     WatershedTool(); // purposely hidden
     ~WatershedTool() override;
 
     void Activated() override;
     void Deactivated() override;
 
     /** \brief Threshold parameter of the ITK Watershed Image Filter. See ITK Documentation for more information. */
     double m_Threshold;
     /** \brief Threshold parameter of the ITK Watershed Image Filter. See ITK Documentation for more information. */
     double m_Level;
   };
 
 } // namespace
 
 #endif