diff --git a/Modules/Segmentation/Interactions/mitkBinaryThresholdBaseTool.h b/Modules/Segmentation/Interactions/mitkBinaryThresholdBaseTool.h
index da610d25f9..dece9ae498 100644
--- a/Modules/Segmentation/Interactions/mitkBinaryThresholdBaseTool.h
+++ b/Modules/Segmentation/Interactions/mitkBinaryThresholdBaseTool.h
@@ -1,88 +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.
 
 ============================================================================*/
 
 #ifndef mitkBinaryThresholdBaseTool_h_Included
 #define mitkBinaryThresholdBaseTool_h_Included
 
 #include "mitkAutoSegmentationTool.h"
 #include "mitkCommon.h"
 #include "mitkDataNode.h"
 #include <MitkSegmentationExports.h>
 
 #include <itkBinaryThresholdImageFilter.h>
 #include <itkImage.h>
 
 namespace mitk
 {
   /**
   \brief Base class for binary threshold tools.
 
   \ingroup ToolManagerEtAl
   \sa mitk::Tool
   \sa QmitkInteractiveSegmentation
   */
   class MITKSEGMENTATION_EXPORT BinaryThresholdBaseTool : public AutoSegmentationTool
   {
   public:
     Message3<double, double, bool> IntervalBordersChanged;
     Message2<mitk::ScalarType, mitk::ScalarType> ThresholdingValuesChanged;
 
     mitkClassMacro(BinaryThresholdBaseTool, AutoSegmentationTool);
 
     void Activated() override;
     void Deactivated() override;
 
     virtual void SetThresholdValues(double lower, double upper);
 
     virtual void AcceptCurrentThresholdValue();
     virtual void CancelThresholding();
 
+    itkSetMacro(CreateAllTimeSteps, bool);
+    itkGetMacro(CreateAllTimeSteps, bool);
+    itkBooleanMacro(CreateAllTimeSteps);
+
   protected:
     BinaryThresholdBaseTool(); // purposely hidden
     ~BinaryThresholdBaseTool() override;
 
     itkSetMacro(LockedUpperThreshold, bool);
     itkGetMacro(LockedUpperThreshold, bool);
     itkBooleanMacro(LockedUpperThreshold);
 
     itkGetMacro(SensibleMinimumThresholdValue, ScalarType);
     itkGetMacro(SensibleMaximumThresholdValue, ScalarType);
 
   private:
     void SetupPreviewNode();
 
     void TransferImageAtTimeStep(const Image* sourceImage, Image* destinationImage, const TimeStepType timeStep);
 
     void CreateNewSegmentationFromThreshold();
 
     void OnRoiDataChanged();
     void OnTimePointChanged();
 
     void UpdatePreview();
 
     DataNode::Pointer m_ThresholdFeedbackNode;
     DataNode::Pointer m_OriginalImageNode;
     DataNode::Pointer m_NodeForThresholding;
 
     ScalarType m_SensibleMinimumThresholdValue;
     ScalarType m_SensibleMaximumThresholdValue;
     ScalarType m_CurrentLowerThresholdValue;
     ScalarType m_CurrentUpperThresholdValue;
 
     bool m_IsOldBinary = false;
+
+    /** Indicates if Accepting the threshold should transfer/create the segmentations
+     of all time steps (true) or only of the currently selected timepoint (false).*/
     bool m_CreateAllTimeSteps = false;
+
+    /** Indicates if the tool should behave like a single threshold tool (true)
+      or like a upper/lower threshold tool (false)*/
     bool m_LockedUpperThreshold = false;
   };
 
 } // namespace
 
 #endif
diff --git a/Modules/SegmentationUI/Qmitk/QmitkBinaryThresholdToolGUI.cpp b/Modules/SegmentationUI/Qmitk/QmitkBinaryThresholdToolGUI.cpp
index 8984c1a21c..28deb4502d 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkBinaryThresholdToolGUI.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitkBinaryThresholdToolGUI.cpp
@@ -1,143 +1,144 @@
 /*============================================================================
 
 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 "QmitkBinaryThresholdToolGUI.h"
-#include "QmitkConfirmSegmentationDialog.h"
-#include "QmitkNewSegmentationDialog.h"
 
 #include <qlabel.h>
 #include <qlayout.h>
 #include <qpushbutton.h>
 #include <qslider.h>
 
 MITK_TOOL_GUI_MACRO(MITKSEGMENTATIONUI_EXPORT, QmitkBinaryThresholdToolGUI, "")
 
 QmitkBinaryThresholdToolGUI::QmitkBinaryThresholdToolGUI()
   : QmitkToolGUI()
 {
   // create the visible widgets
   QBoxLayout *mainLayout = new QVBoxLayout(this);
 
   QLabel *label = new QLabel("Threshold :", this);
   QFont f = label->font();
   f.setBold(false);
   label->setFont(f);
   mainLayout->addWidget(label);
 
   QBoxLayout *layout = new QHBoxLayout();
 
   m_ThresholdSlider = new ctkSliderWidget();
   connect(
     m_ThresholdSlider, SIGNAL(valueChanged(double)), this, SLOT(OnSliderValueChanged(double)));
   layout->addWidget(m_ThresholdSlider);
   mainLayout->addLayout(layout);
   m_ThresholdSlider->setSingleStep(0.01);
 
   QPushButton *okButton = new QPushButton("Confirm Segmentation", this);
   connect(okButton, SIGNAL(clicked()), this, SLOT(OnAcceptThresholdPreview()));
   okButton->setFont(f);
   mainLayout->addWidget(okButton);
 
+  m_CheckProcessAll = new QCheckBox("Process all time steps", this);
+  m_CheckProcessAll->setChecked(false);
+  mainLayout->addWidget(m_CheckProcessAll);
+
+  m_CheckCreateNew = new QCheckBox("Create as new segmentation", this);
+  m_CheckCreateNew->setChecked(false);
+  mainLayout->addWidget(m_CheckCreateNew);
+
   connect(this, SIGNAL(NewToolAssociated(mitk::Tool *)), this, SLOT(OnNewToolAssociated(mitk::Tool *)));
 }
 
 QmitkBinaryThresholdToolGUI::~QmitkBinaryThresholdToolGUI()
 {
-  // !!!
   if (m_BinaryThresholdTool.IsNotNull())
   {
     m_BinaryThresholdTool->IntervalBordersChanged -=
       mitk::MessageDelegate3<QmitkBinaryThresholdToolGUI, double, double, bool>(
         this, &QmitkBinaryThresholdToolGUI::OnThresholdingIntervalBordersChanged);
     m_BinaryThresholdTool->ThresholdingValuesChanged -= mitk::MessageDelegate2<QmitkBinaryThresholdToolGUI, mitk::ScalarType, mitk::ScalarType>(
       this, &QmitkBinaryThresholdToolGUI::OnThresholdingValuesChanged);
   }
 }
 
 void QmitkBinaryThresholdToolGUI::OnNewToolAssociated(mitk::Tool *tool)
 {
   if (m_BinaryThresholdTool.IsNotNull())
   {
     m_BinaryThresholdTool->IntervalBordersChanged -=
       mitk::MessageDelegate3<QmitkBinaryThresholdToolGUI, double, double, bool>(
         this, &QmitkBinaryThresholdToolGUI::OnThresholdingIntervalBordersChanged);
     m_BinaryThresholdTool->ThresholdingValuesChanged -= mitk::MessageDelegate2<QmitkBinaryThresholdToolGUI, mitk::ScalarType, mitk::ScalarType>(
       this, &QmitkBinaryThresholdToolGUI::OnThresholdingValuesChanged);
   }
 
   m_BinaryThresholdTool = dynamic_cast<mitk::BinaryThresholdTool *>(tool);
 
   if (m_BinaryThresholdTool.IsNotNull())
   {
     m_BinaryThresholdTool->IntervalBordersChanged +=
       mitk::MessageDelegate3<QmitkBinaryThresholdToolGUI, double, double, bool>(
         this, &QmitkBinaryThresholdToolGUI::OnThresholdingIntervalBordersChanged);
     m_BinaryThresholdTool->ThresholdingValuesChanged += mitk::MessageDelegate2<QmitkBinaryThresholdToolGUI, mitk::ScalarType, mitk::ScalarType>(
       this, &QmitkBinaryThresholdToolGUI::OnThresholdingValuesChanged);
+
+    m_BinaryThresholdTool->SetOverwriteExistingSegmentation(true);
+    m_CheckProcessAll->setVisible(m_BinaryThresholdTool->GetTargetSegmentationNode()->GetData()->GetTimeSteps()>1);
   }
 }
 
 void QmitkBinaryThresholdToolGUI::OnAcceptThresholdPreview()
 {
-  QmitkConfirmSegmentationDialog dialog;
-  QString segName = QString::fromStdString(m_BinaryThresholdTool->GetCurrentSegmentationName());
-
-  dialog.SetSegmentationName(segName);
-  int result = dialog.exec();
-
-  switch (result)
+  if (m_BinaryThresholdTool.IsNotNull())
   {
-    case QmitkConfirmSegmentationDialog::CREATE_NEW_SEGMENTATION:
+    if (m_CheckCreateNew->isChecked())
+    {
       m_BinaryThresholdTool->SetOverwriteExistingSegmentation(false);
-      break;
-    case QmitkConfirmSegmentationDialog::OVERWRITE_SEGMENTATION:
+    }
+    else
+    {
       m_BinaryThresholdTool->SetOverwriteExistingSegmentation(true);
-      break;
-    case QmitkConfirmSegmentationDialog::CANCEL_SEGMENTATION:
-      return;
-  }
+    }
+
+    m_BinaryThresholdTool->SetCreateAllTimeSteps(m_CheckProcessAll->isChecked());
 
-  if (m_BinaryThresholdTool.IsNotNull())
-  {
     this->thresholdAccepted();
     m_BinaryThresholdTool->AcceptCurrentThresholdValue();
   }
 }
 
 void QmitkBinaryThresholdToolGUI::OnThresholdingIntervalBordersChanged(double lower, double upper, bool isFloat)
 {
   m_InternalUpdate = true;
   if (!isFloat)
   {
     m_ThresholdSlider->setRange(int(lower), int(upper));
     m_ThresholdSlider->setSingleStep(1);
     m_ThresholdSlider->setDecimals(0);
   }
   else
   {
     m_ThresholdSlider->setRange(lower, upper);
   }
   m_InternalUpdate = false;
 }
 
 void QmitkBinaryThresholdToolGUI::OnThresholdingValuesChanged(mitk::ScalarType lower, mitk::ScalarType upper)
 {
   m_ThresholdSlider->setValue(lower);
 }
 
 void QmitkBinaryThresholdToolGUI::OnSliderValueChanged(double value)
 {
   if (m_BinaryThresholdTool.IsNotNull() && !m_InternalUpdate)
   {
     m_BinaryThresholdTool->SetThresholdValue(value);
   }
 }
diff --git a/Modules/SegmentationUI/Qmitk/QmitkBinaryThresholdToolGUI.h b/Modules/SegmentationUI/Qmitk/QmitkBinaryThresholdToolGUI.h
index 3698ba2457..3d1e396cd2 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkBinaryThresholdToolGUI.h
+++ b/Modules/SegmentationUI/Qmitk/QmitkBinaryThresholdToolGUI.h
@@ -1,74 +1,78 @@
 /*============================================================================
 
 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 QmitkBinaryThresholdToolGUI_h_Included
 #define QmitkBinaryThresholdToolGUI_h_Included
 
 #include "QmitkToolGUI.h"
 #include "mitkBinaryThresholdTool.h"
 #include <MitkSegmentationUIExports.h>
 
 #include "ctkSliderWidget.h"
+#include <qcheckbox.h>
 
 /**
   \ingroup org_mitk_gui_qt_interactivesegmentation_internal
   \brief GUI for mitk::BinaryThresholdTool.
 
   This GUI shows a slider to change the tool's threshold and an OK button to accept a preview for actual thresholding.
 
   There is only a slider for INT values in QT. So, if the working image has a float/double pixeltype, we need to convert
   the original float intensity into a respective int value for the slider. The slider range is then between 0 and 99.
 
   If the pixeltype is INT, then we do not need any conversion.
 
   Last contributor: $Author$
 */
 class MITKSEGMENTATIONUI_EXPORT QmitkBinaryThresholdToolGUI : public QmitkToolGUI
 {
   Q_OBJECT
 
 public:
   mitkClassMacro(QmitkBinaryThresholdToolGUI, QmitkToolGUI);
   itkFactorylessNewMacro(Self);
   itkCloneMacro(Self);
 
   void OnThresholdingIntervalBordersChanged(double lower, double upper, bool isFloat);
   void OnThresholdingValuesChanged(mitk::ScalarType lower, mitk::ScalarType upper);
 
 signals:
 
   /// \brief Emitted when threshold Accepted
   void thresholdAccepted();
 
   /// \brief Emitted when threshold Canceled
   void thresholdCanceled();
 
 public slots:
 
 protected slots:
 
   void OnNewToolAssociated(mitk::Tool *);
   void OnAcceptThresholdPreview();
 
   void OnSliderValueChanged(double value);
 
 protected:
   QmitkBinaryThresholdToolGUI();
   ~QmitkBinaryThresholdToolGUI() override;
 
-  ctkSliderWidget* m_ThresholdSlider;
+  ctkSliderWidget* m_ThresholdSlider = nullptr;
+  QCheckBox* m_CheckProcessAll = nullptr;
+  QCheckBox* m_CheckCreateNew = nullptr;
+
   bool m_InternalUpdate = false;
 
   mitk::BinaryThresholdTool::Pointer m_BinaryThresholdTool;
 };
 
 #endif
diff --git a/Modules/SegmentationUI/Qmitk/QmitkBinaryThresholdULToolGUI.cpp b/Modules/SegmentationUI/Qmitk/QmitkBinaryThresholdULToolGUI.cpp
index 603fb305db..8f283ae403 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkBinaryThresholdULToolGUI.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitkBinaryThresholdULToolGUI.cpp
@@ -1,138 +1,141 @@
 /*============================================================================
 
 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 "QmitkBinaryThresholdULToolGUI.h"
-#include "QmitkConfirmSegmentationDialog.h"
 
 #include <qlabel.h>
 #include <qlayout.h>
 #include <qpushbutton.h>
 #include <qslider.h>
 
 MITK_TOOL_GUI_MACRO(MITKSEGMENTATIONUI_EXPORT, QmitkBinaryThresholdULToolGUI, "")
 
 QmitkBinaryThresholdULToolGUI::QmitkBinaryThresholdULToolGUI() : QmitkToolGUI()
 {
   // create the visible widgets
   QBoxLayout *mainLayout = new QVBoxLayout(this);
 
   QLabel *label = new QLabel("Threshold :", this);
   QFont f = label->font();
   f.setBold(false);
   label->setFont(f);
   mainLayout->addWidget(label);
 
   QBoxLayout *layout = new QHBoxLayout();
 
   m_DoubleThresholdSlider = new ctkRangeWidget();
   connect(
     m_DoubleThresholdSlider, SIGNAL(valuesChanged(double, double)), this, SLOT(OnThresholdsChanged(double, double)));
   layout->addWidget(m_DoubleThresholdSlider);
   mainLayout->addLayout(layout);
   m_DoubleThresholdSlider->setSingleStep(0.01);
 
   QPushButton *okButton = new QPushButton("Confirm Segmentation", this);
   connect(okButton, SIGNAL(clicked()), this, SLOT(OnAcceptThresholdPreview()));
   okButton->setFont(f);
   mainLayout->addWidget(okButton);
 
+  m_CheckProcessAll = new QCheckBox("Process all time steps", this);
+  m_CheckProcessAll->setChecked(false);
+  mainLayout->addWidget(m_CheckProcessAll);
+
+  m_CheckCreateNew = new QCheckBox("Create as new segmentation", this);
+  m_CheckCreateNew->setChecked(false);
+  mainLayout->addWidget(m_CheckCreateNew);
+
   connect(this, SIGNAL(NewToolAssociated(mitk::Tool *)), this, SLOT(OnNewToolAssociated(mitk::Tool *)));
 }
 
 QmitkBinaryThresholdULToolGUI::~QmitkBinaryThresholdULToolGUI()
 {
   // !!!
   if (m_BinaryThresholdULTool.IsNotNull())
   {
     m_BinaryThresholdULTool->IntervalBordersChanged -=
       mitk::MessageDelegate3<QmitkBinaryThresholdULToolGUI, double, double, bool>(
         this, &QmitkBinaryThresholdULToolGUI::OnThresholdingIntervalBordersChanged);
     m_BinaryThresholdULTool->ThresholdingValuesChanged -=
       mitk::MessageDelegate2<QmitkBinaryThresholdULToolGUI, mitk::ScalarType, mitk::ScalarType>(
         this, &QmitkBinaryThresholdULToolGUI::OnThresholdingValuesChanged);
   }
 }
 
 void QmitkBinaryThresholdULToolGUI::OnNewToolAssociated(mitk::Tool *tool)
 {
   if (m_BinaryThresholdULTool.IsNotNull())
   {
     m_BinaryThresholdULTool->IntervalBordersChanged -=
       mitk::MessageDelegate3<QmitkBinaryThresholdULToolGUI, double, double, bool>(
         this, &QmitkBinaryThresholdULToolGUI::OnThresholdingIntervalBordersChanged);
     m_BinaryThresholdULTool->ThresholdingValuesChanged -=
       mitk::MessageDelegate2<QmitkBinaryThresholdULToolGUI, mitk::ScalarType, mitk::ScalarType>(
         this, &QmitkBinaryThresholdULToolGUI::OnThresholdingValuesChanged);
   }
 
   m_BinaryThresholdULTool = dynamic_cast<mitk::BinaryThresholdULTool *>(tool);
 
   if (m_BinaryThresholdULTool.IsNotNull())
   {
     m_BinaryThresholdULTool->IntervalBordersChanged +=
       mitk::MessageDelegate3<QmitkBinaryThresholdULToolGUI, double, double, bool>(
         this, &QmitkBinaryThresholdULToolGUI::OnThresholdingIntervalBordersChanged);
     m_BinaryThresholdULTool->ThresholdingValuesChanged +=
       mitk::MessageDelegate2<QmitkBinaryThresholdULToolGUI, mitk::ScalarType, mitk::ScalarType>(
         this, &QmitkBinaryThresholdULToolGUI::OnThresholdingValuesChanged);
+
+    m_BinaryThresholdULTool->SetOverwriteExistingSegmentation(true);
+    m_CheckProcessAll->setVisible(m_BinaryThresholdULTool->GetTargetSegmentationNode()->GetData()->GetTimeSteps() > 1);
   }
 }
 
 void QmitkBinaryThresholdULToolGUI::OnAcceptThresholdPreview()
 {
-  QmitkConfirmSegmentationDialog dialog;
-  QString segName = QString::fromStdString(m_BinaryThresholdULTool->GetCurrentSegmentationName());
-
-  dialog.SetSegmentationName(segName);
-  int result = dialog.exec();
-
-  switch (result)
+  if (m_BinaryThresholdULTool.IsNotNull())
   {
-    case QmitkConfirmSegmentationDialog::CREATE_NEW_SEGMENTATION:
+    if (m_CheckCreateNew->isChecked())
+    {
       m_BinaryThresholdULTool->SetOverwriteExistingSegmentation(false);
-      break;
-    case QmitkConfirmSegmentationDialog::OVERWRITE_SEGMENTATION:
+    }
+    else
+    {
       m_BinaryThresholdULTool->SetOverwriteExistingSegmentation(true);
-      break;
-    case QmitkConfirmSegmentationDialog::CANCEL_SEGMENTATION:
-      return;
-  }
+    }
+
+    m_BinaryThresholdULTool->SetCreateAllTimeSteps(m_CheckProcessAll->isChecked());
 
-  if (m_BinaryThresholdULTool.IsNotNull())
-  {
     m_BinaryThresholdULTool->AcceptCurrentThresholdValue();
   }
 }
 
 void QmitkBinaryThresholdULToolGUI::OnThresholdingIntervalBordersChanged(double lower, double upper, bool isFloat)
 {
   if (!isFloat)
   {
     m_DoubleThresholdSlider->setRange(int(lower), int(upper));
     m_DoubleThresholdSlider->setSingleStep(1);
     m_DoubleThresholdSlider->setDecimals(0);
   }
   else
   {
     m_DoubleThresholdSlider->setRange(lower, upper);
   }
 }
 
 void QmitkBinaryThresholdULToolGUI::OnThresholdingValuesChanged(mitk::ScalarType lower, mitk::ScalarType upper)
 {
   m_DoubleThresholdSlider->setValues(lower, upper);
 }
 
 void QmitkBinaryThresholdULToolGUI::OnThresholdsChanged(double min, double max)
 {
   m_BinaryThresholdULTool->SetThresholdValues(min, max);
 }
diff --git a/Modules/SegmentationUI/Qmitk/QmitkBinaryThresholdULToolGUI.h b/Modules/SegmentationUI/Qmitk/QmitkBinaryThresholdULToolGUI.h
index 7e895adc8f..3e178be366 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkBinaryThresholdULToolGUI.h
+++ b/Modules/SegmentationUI/Qmitk/QmitkBinaryThresholdULToolGUI.h
@@ -1,62 +1,66 @@
 /*============================================================================
 
 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 QmitkBinaryThresholdULToolGUI_h_Included
 #define QmitkBinaryThresholdULToolGUI_h_Included
 
 #include "QmitkToolGUI.h"
 #include "ctkRangeWidget.h"
+#include <qcheckbox.h>
 #include "mitkBinaryThresholdULTool.h"
+
 #include <MitkSegmentationUIExports.h>
 
 /**
   \ingroup org_mitk_gui_qt_interactivesegmentation_internal
   \brief GUI for mitk::BinaryThresholdTool.
 
   This GUI shows a slider to change the tool's threshold and an OK button to accept a preview for actual thresholding.
 
   Last contributor: $Author$
 */
 class MITKSEGMENTATIONUI_EXPORT QmitkBinaryThresholdULToolGUI : public QmitkToolGUI
 {
   Q_OBJECT
 
 public:
   mitkClassMacro(QmitkBinaryThresholdULToolGUI, QmitkToolGUI);
   itkFactorylessNewMacro(Self);
   itkCloneMacro(Self);
 
   void OnThresholdingIntervalBordersChanged(double lower, double upper, bool isFloat);
   void OnThresholdingValuesChanged(mitk::ScalarType lower, mitk::ScalarType upper);
 
 signals:
 
 public slots:
 
 protected slots:
 
   void OnNewToolAssociated(mitk::Tool *);
 
   void OnAcceptThresholdPreview();
 
   void OnThresholdsChanged(double min, double max);
 
 protected:
   QmitkBinaryThresholdULToolGUI();
   ~QmitkBinaryThresholdULToolGUI() override;
 
   ctkRangeWidget *m_DoubleThresholdSlider;
+  QCheckBox* m_CheckProcessAll = nullptr;
+  QCheckBox* m_CheckCreateNew = nullptr;
 
   mitk::BinaryThresholdULTool::Pointer m_BinaryThresholdULTool;
 };
 
 #endif