diff --git a/Modules/Segmentation/Interactions/mitkAutoSegmentationTool.cpp b/Modules/Segmentation/Interactions/mitkAutoSegmentationTool.cpp
index a206b7c65e..44e836b3d6 100644
--- a/Modules/Segmentation/Interactions/mitkAutoSegmentationTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkAutoSegmentationTool.cpp
@@ -1,130 +1,148 @@
 /*============================================================================
 
 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::Pointer mitk::AutoSegmentationTool::GetImageByTimeStep(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 (this->GetToolManager()->GetWorkingData(0))
     return this->GetToolManager()->GetWorkingData(0)->GetName();
   else
     return "";
 }
 
 mitk::DataNode *mitk::AutoSegmentationTool::GetTargetSegmentationNode() const
 {
   mitk::DataNode::Pointer segmentationNode = this->GetToolManager()->GetWorkingData(0);
   if (!m_OverwriteExistingSegmentation)
   {
     if (m_NoneOverwriteTargetSegmentationNode.IsNull())
     {
       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 (!this->GetToolManager()->GetDataStorage()->Exists(targetNode))
   {
     this->GetToolManager()->GetDataStorage()->Add(targetNode, this->GetToolManager()->GetReferenceData(0));
   }
 }
diff --git a/Modules/Segmentation/Interactions/mitkAutoSegmentationTool.h b/Modules/Segmentation/Interactions/mitkAutoSegmentationTool.h
index 69624986c8..8665208340 100644
--- a/Modules/Segmentation/Interactions/mitkAutoSegmentationTool.h
+++ b/Modules/Segmentation/Interactions/mitkAutoSegmentationTool.h
@@ -1,84 +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.
 
 ============================================================================*/
 
 #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 Activated() override;
     void Deactivated() override;
 
     /** This function controls wether a confirmed segmentation should replace the old
     * segmentation/working node (true) or if it should be stored as new and additional
     * node (false).
     */
     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 node
      *        or (if overwrite mode is false) creates a new one from the selected reference data.
      * @remark Please keep in mind that new created nodes are not automatically added to the data storage.
      * Derived tools can call EnsureTargetSegmentationNodeInDataStorage to ensure it as soon as it is clear
      * that the target segmentation node will be/is confirmed.
      * @return a mitk::DataNode which contains a segmentation image
      */
     virtual DataNode *GetTargetSegmentationNode() const;
 
   protected:
     AutoSegmentationTool(); // purposely hidden
     AutoSegmentationTool(const char* interactorType, const us::Module* interactorModule = nullptr); // purposely hidden
     ~AutoSegmentationTool() override;
 
     const char *GetGroup() const override;
 
     /** Helper that extracts the image for the passed timestep, if the image has multiple time steps.*/
     static Image::ConstPointer GetImageByTimeStep(const Image* image, unsigned int timestep);
+    /** Helper that extracts the image for the passed timestep, if the image has multiple time steps.*/
+    static Image::Pointer GetImageByTimeStep(Image* image, unsigned int timestep);
     /** Helper that extracts the image for the passed time point, if the image has multiple time steps.*/
     static Image::ConstPointer GetImageByTimePoint(const Image* image, TimePointType timePoint);
 
     void EnsureTargetSegmentationNodeInDataStorage() const;
 
     bool m_OverwriteExistingSegmentation;
 
   private:
     /**Contains the node returned by GetTargetSementationNode if m_OverwriteExistingSegmentation == false. Then
     * GetTargetSegmentation generates a new target segmentation node.*/
     mutable DataNode::Pointer m_NoneOverwriteTargetSegmentationNode;
   };
 
 } // namespace
 
 #endif