diff --git a/Modules/SegmentationUI/Qmitk/QmitkLabelSetWidget.cpp b/Modules/SegmentationUI/Qmitk/QmitkLabelSetWidget.cpp
index a7c5bf161d..df55ce1800 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkLabelSetWidget.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitkLabelSetWidget.cpp
@@ -1,1338 +1,1295 @@
 /*============================================================================
 
 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 "QmitkLabelSetWidget.h"
 
 // mitk
 #include <mitkAutoCropImageFilter.h>
 #include <mitkCoreObjectFactory.h>
 #include <mitkIOUtil.h>
 #include <mitkLabelSetImage.h>
 #include <mitkLabelSetImageToSurfaceThreadedFilter.h>
 #include <mitkRenderingManager.h>
 #include <mitkShowSegmentationAsSurface.h>
 #include <mitkSliceBasedInterpolationController.h>
 #include <mitkStatusBar.h>
 #include <mitkSurfaceBasedInterpolationController.h>
 #include <mitkToolManagerProvider.h>
 
 // Qmitk
 #include <QmitkDataStorageComboBox.h>
 #include <QmitkNewSegmentationDialog.h>
 #include <QmitkStyleManager.h>
-#include <QmitkSearchLabelDialog.h>
 
 // Qt
 #include <QColorDialog>
 #include <QCompleter>
 #include <QDateTime>
 #include <QFileDialog>
 #include <QMenu>
 #include <QMessageBox>
 #include <QPushButton>
 #include <QStringListModel>
 #include <QWidgetAction>
 
 // itk
 #include <itksys/SystemTools.hxx>
 
 // todo:
 // berry
 //#include <berryIPreferencesService.h>
 
 QmitkLabelSetWidget::QmitkLabelSetWidget(QWidget *parent)
-  : QWidget(parent), m_DataStorage(nullptr), m_Completer(nullptr), m_ToolManager(nullptr)
+  : QWidget(parent), m_DataStorage(nullptr), m_Completer(nullptr), m_ToolManager(nullptr), m_ProcessingManualSelection(false)
 {
   m_Controls.setupUi(this);
 
   m_ColorSequenceRainbow.GoToBegin();
 
   m_ToolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager();
 
   m_Controls.m_LabelSearchBox->setAlwaysShowClearIcon(true);
   m_Controls.m_LabelSearchBox->setShowSearchIcon(true);
 
   QStringList completionList;
   completionList << "";
   m_Completer = new QCompleter(completionList, this);
   m_Completer->setCaseSensitivity(Qt::CaseInsensitive);
   m_Controls.m_LabelSearchBox->setCompleter(m_Completer);
 
   connect(m_Controls.m_LabelSearchBox, SIGNAL(returnPressed()), this, SLOT(OnSearchLabel()));
-  // connect( m_Controls.m_LabelSetTableWidget, SIGNAL(labelListModified(const QStringList&)), this, SLOT(
-  // OnLabelListModified(const QStringList&)) );
-  // connect( m_Controls.m_LabelSetTableWidget, SIGNAL(mergeLabel(int)), this, SLOT( OnMergeLabel(int)) );
 
   QStringListModel *completeModel = static_cast<QStringListModel *>(m_Completer->model());
   completeModel->setStringList(GetLabelStringList());
 
   m_Controls.m_LabelSearchBox->setEnabled(false);
 
   m_Controls.m_lblCaption->setText("");
 
   InitializeTableWidget();
 }
 
 QmitkLabelSetWidget::~QmitkLabelSetWidget() {}
 
 void QmitkLabelSetWidget::OnTableViewContextMenuRequested(const QPoint & /*pos*/)
 {
   int pixelValue = GetPixelValueOfSelectedItem();
 
   if (-1 == pixelValue)
     return;
 
   QMenu *menu = new QMenu(m_Controls.m_LabelSetTableWidget);
 
   if (m_Controls.m_LabelSetTableWidget->selectedItems().size() > 1)
   {
     QAction *mergeAction = new QAction(QIcon(":/Qmitk/MergeLabels.png"), "Merge selection on current label", this);
     mergeAction->setEnabled(true);
     QObject::connect(mergeAction, SIGNAL(triggered(bool)), this, SLOT(OnMergeLabels(bool)));
     menu->addAction(mergeAction);
 
     QAction *removeLabelsAction = new QAction(QIcon(":/Qmitk/RemoveLabel.png"), "Remove selected labels", this);
     removeLabelsAction->setEnabled(true);
     QObject::connect(removeLabelsAction, SIGNAL(triggered(bool)), this, SLOT(OnRemoveLabels(bool)));
     menu->addAction(removeLabelsAction);
 
     QAction *eraseLabelsAction = new QAction(QIcon(":/Qmitk/EraseLabel.png"), "Erase selected labels", this);
     eraseLabelsAction->setEnabled(true);
     QObject::connect(eraseLabelsAction, SIGNAL(triggered(bool)), this, SLOT(OnEraseLabels(bool)));
     menu->addAction(eraseLabelsAction);
 
-    QAction *combineAndCreateSurfaceAction =
+    /*QAction* combineAndCreateSurfaceAction =
       new QAction(QIcon(":/Qmitk/CreateSurface.png"), "Combine and create a surface", this);
     combineAndCreateSurfaceAction->setEnabled(true);
     QObject::connect(
-      combineAndCreateSurfaceAction, SIGNAL(triggered(bool)), this, SLOT(OnCombineAndCreateSurface(bool)));
+      combineAndCreateSurfaceAction, SIGNAL(triggered(bool)), this, SLOT(OnCombineAndCreateSurface(bool)));*/
     // menu->addAction(combineAndCreateSurfaceAction); Not implemented
 
-    QAction *createMasksAction =
+    /*QAction* createMasksAction =
       new QAction(QIcon(":/Qmitk/CreateMask.png"), "Create a mask for each selected label", this);
     createMasksAction->setEnabled(true);
-    QObject::connect(createMasksAction, SIGNAL(triggered(bool)), this, SLOT(OnCreateMasks(bool)));
+    QObject::connect(createMasksAction, SIGNAL(triggered(bool)), this, SLOT(OnCreateMasks(bool)));*/
     // menu->addAction(createMasksAction); Not implemented
 
-    QAction *combineAndCreateMaskAction =
+    /*QAction* combineAndCreateMaskAction =
       new QAction(QIcon(":/Qmitk/CreateMask.png"), "Combine and create a mask", this);
     combineAndCreateMaskAction->setEnabled(true);
-    QObject::connect(combineAndCreateMaskAction, SIGNAL(triggered(bool)), this, SLOT(OnCombineAndCreateMask(bool)));
+    QObject::connect(combineAndCreateMaskAction, SIGNAL(triggered(bool)), this, SLOT(OnCombineAndCreateMask(bool)));*/
     // menu->addAction(combineAndCreateMaskAction); Not implemented
   }
   else
   {
     QAction *renameAction = new QAction(QIcon(":/Qmitk/RenameLabel.png"), "Rename...", this);
     renameAction->setEnabled(true);
     QObject::connect(renameAction, SIGNAL(triggered(bool)), this, SLOT(OnRenameLabel(bool)));
     menu->addAction(renameAction);
 
     QAction *removeAction = new QAction(QIcon(":/Qmitk/RemoveLabel.png"), "Remove...", this);
     removeAction->setEnabled(true);
     QObject::connect(removeAction, SIGNAL(triggered(bool)), this, SLOT(OnRemoveLabel(bool)));
     menu->addAction(removeAction);
 
     QAction *eraseAction = new QAction(QIcon(":/Qmitk/EraseLabel.png"), "Erase...", this);
     eraseAction->setEnabled(true);
     QObject::connect(eraseAction, SIGNAL(triggered(bool)), this, SLOT(OnEraseLabel(bool)));
     menu->addAction(eraseAction);
 
-    QAction *mergeAction = new QAction(QIcon(":/Qmitk/MergeLabels.png"), "Merge...", this);
-    mergeAction->setEnabled(true);
-    QObject::connect(mergeAction, SIGNAL(triggered(bool)), this, SLOT(OnMergeLabel(bool)));
-    menu->addAction(mergeAction);
-
     QAction *randomColorAction = new QAction(QIcon(":/Qmitk/RandomColor.png"), "Random color", this);
     randomColorAction->setEnabled(true);
     QObject::connect(randomColorAction, SIGNAL(triggered(bool)), this, SLOT(OnRandomColor(bool)));
     menu->addAction(randomColorAction);
 
     QAction *viewOnlyAction = new QAction(QIcon(":/Qmitk/visible.png"), "View only", this);
     viewOnlyAction->setEnabled(true);
     QObject::connect(viewOnlyAction, SIGNAL(triggered(bool)), this, SLOT(OnSetOnlyActiveLabelVisible(bool)));
     menu->addAction(viewOnlyAction);
 
     QAction *viewAllAction = new QAction(QIcon(":/Qmitk/visible.png"), "View all", this);
     viewAllAction->setEnabled(true);
     QObject::connect(viewAllAction, SIGNAL(triggered(bool)), this, SLOT(OnSetAllLabelsVisible(bool)));
     menu->addAction(viewAllAction);
 
     QAction *hideAllAction = new QAction(QIcon(":/Qmitk/invisible.png"), "Hide all", this);
     hideAllAction->setEnabled(true);
     QObject::connect(hideAllAction, SIGNAL(triggered(bool)), this, SLOT(OnSetAllLabelsInvisible(bool)));
     menu->addAction(hideAllAction);
 
     QAction *lockAllAction = new QAction(QIcon(":/Qmitk/lock.png"), "Lock all", this);
     lockAllAction->setEnabled(true);
     QObject::connect(lockAllAction, SIGNAL(triggered(bool)), this, SLOT(OnLockAllLabels(bool)));
     menu->addAction(lockAllAction);
 
     QAction *unlockAllAction = new QAction(QIcon(":/Qmitk/unlock.png"), "Unlock all", this);
     unlockAllAction->setEnabled(true);
     QObject::connect(unlockAllAction, SIGNAL(triggered(bool)), this, SLOT(OnUnlockAllLabels(bool)));
     menu->addAction(unlockAllAction);
 
     QAction *createSurfaceAction = new QAction(QIcon(":/Qmitk/CreateSurface.png"), "Create surface", this);
     createSurfaceAction->setEnabled(true);
     createSurfaceAction->setMenu(new QMenu());
 
     QAction *tmp1 = createSurfaceAction->menu()->addAction(QString("Detailed"));
     QAction *tmp2 = createSurfaceAction->menu()->addAction(QString("Smoothed"));
 
     QObject::connect(tmp1, SIGNAL(triggered(bool)), this, SLOT(OnCreateDetailedSurface(bool)));
     QObject::connect(tmp2, SIGNAL(triggered(bool)), this, SLOT(OnCreateSmoothedSurface(bool)));
 
     menu->addAction(createSurfaceAction);
 
     QAction *createMaskAction = new QAction(QIcon(":/Qmitk/CreateMask.png"), "Create mask", this);
     createMaskAction->setEnabled(true);
     QObject::connect(createMaskAction, SIGNAL(triggered(bool)), this, SLOT(OnCreateMask(bool)));
 
     menu->addAction(createMaskAction);
 
     QAction *createCroppedMaskAction = new QAction(QIcon(":/Qmitk/CreateMask.png"), "Create cropped mask", this);
     createCroppedMaskAction->setEnabled(true);
     QObject::connect(createCroppedMaskAction, SIGNAL(triggered(bool)), this, SLOT(OnCreateCroppedMask(bool)));
 
     //    QAction* importAction = new QAction(QIcon(":/Qmitk/RenameLabel.png"), "Import...", this );
     //    importAction->setEnabled(true);
     //    QObject::connect( importAction, SIGNAL( triggered(bool) ), this, SLOT( OnImportSegmentationSession(bool) ) );
     //    menu->addAction(importAction);
 
     menu->addAction(createCroppedMaskAction);
 
     QSlider *opacitySlider = new QSlider;
     opacitySlider->setMinimum(0);
     opacitySlider->setMaximum(100);
     opacitySlider->setOrientation(Qt::Horizontal);
     QObject::connect(opacitySlider, SIGNAL(valueChanged(int)), this, SLOT(OnOpacityChanged(int)));
 
     QLabel *_OpacityLabel = new QLabel("Opacity: ");
     QVBoxLayout *_OpacityWidgetLayout = new QVBoxLayout;
     _OpacityWidgetLayout->setContentsMargins(4, 4, 4, 4);
     _OpacityWidgetLayout->addWidget(_OpacityLabel);
     _OpacityWidgetLayout->addWidget(opacitySlider);
     QWidget *_OpacityWidget = new QWidget;
     _OpacityWidget->setLayout(_OpacityWidgetLayout);
 
     QWidgetAction *OpacityAction = new QWidgetAction(this);
     OpacityAction->setDefaultWidget(_OpacityWidget);
     //  QObject::connect( m_OpacityAction, SIGNAL( changed() ), this, SLOT( OpacityActionChanged() ) );
     auto workingImage = this->GetWorkingImage();
     auto activeLayer = workingImage->GetActiveLayer();
     auto label = workingImage->GetLabel(pixelValue, activeLayer);
 
     if (nullptr != label)
     {
       auto opacity = label->GetOpacity();
       opacitySlider->setValue(static_cast<int>(opacity * 100));
     }
 
     menu->addAction(OpacityAction);
   }
   menu->popup(QCursor::pos());
 }
 
 void QmitkLabelSetWidget::OnUnlockAllLabels(bool /*value*/)
 {
   GetWorkingImage()->GetActiveLabelSet()->SetAllLabelsLocked(false);
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkLabelSetWidget::OnLockAllLabels(bool /*value*/)
 {
   GetWorkingImage()->GetActiveLabelSet()->SetAllLabelsLocked(true);
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkLabelSetWidget::OnSetAllLabelsVisible(bool /*value*/)
 {
   GetWorkingImage()->GetActiveLabelSet()->SetAllLabelsVisible(true);
   UpdateAllTableWidgetItems();
 }
 
 void QmitkLabelSetWidget::OnSetAllLabelsInvisible(bool /*value*/)
 {
   GetWorkingImage()->GetActiveLabelSet()->SetAllLabelsVisible(false);
   UpdateAllTableWidgetItems();
 }
 
 void QmitkLabelSetWidget::OnSetOnlyActiveLabelVisible(bool /*value*/)
 {
   mitk::LabelSetImage *workingImage = GetWorkingImage();
   int pixelValue = GetPixelValueOfSelectedItem();
 
   workingImage->GetActiveLabelSet()->SetAllLabelsVisible(false);
   workingImage->GetLabel(pixelValue, workingImage->GetActiveLayer())->SetVisible(true);
 
   workingImage->GetActiveLabelSet()->UpdateLookupTable(pixelValue);
 
   this->WaitCursorOn();
 
   const mitk::Point3D &pos =
     workingImage->GetLabel(pixelValue, workingImage->GetActiveLayer())->GetCenterOfMassCoordinates();
   this->WaitCursorOff();
   if (pos.GetVnlVector().max_value() > 0.0)
   {
     emit goToLabel(pos);
   }
 
   UpdateAllTableWidgetItems();
 }
 
-void QmitkLabelSetWidget::OnMergeLabel(bool /*value*/)
-{
-  QmitkSearchLabelDialog dialog(this);
-  dialog.setWindowTitle("Select a second label..");
-  dialog.SetLabelSuggestionList(GetLabelStringList());
-  int dialogReturnValue = dialog.exec();
-  if (dialogReturnValue == QDialog::Rejected)
-    return;
-
-  int sourcePixelValue = -1;
-  for (int i = 0; i < m_Controls.m_LabelSetTableWidget->rowCount(); i++)
-  {
-    if (dialog.GetLabelSetWidgetTableCompleteWord() == QString(m_Controls.m_LabelSetTableWidget->item(i, 0)->text()))
-      sourcePixelValue = m_Controls.m_LabelSetTableWidget->item(i, 0)->data(Qt::UserRole).toInt();
-  }
-
-  if (sourcePixelValue == -1)
-  {
-    MITK_INFO << "unknown label";
-    return;
-  }
-
-  int pixelValue = GetPixelValueOfSelectedItem();
-  GetWorkingImage()->MergeLabel(pixelValue, sourcePixelValue, GetWorkingImage()->GetActiveLayer());
-
-  UpdateAllTableWidgetItems();
-}
-
 void QmitkLabelSetWidget::OnEraseLabel(bool /*value*/)
 {
   int pixelValue = GetPixelValueOfSelectedItem();
   QString question = "Do you really want to erase the contents of label \"";
   question.append(
     QString::fromStdString(GetWorkingImage()->GetLabel(pixelValue, GetWorkingImage()->GetActiveLayer())->GetName()));
   question.append("\"?");
 
   QMessageBox::StandardButton answerButton =
     QMessageBox::question(this, "Erase label", question, QMessageBox::Yes | QMessageBox::Cancel, QMessageBox::Yes);
 
   if (answerButton == QMessageBox::Yes)
   {
     this->WaitCursorOn();
     GetWorkingImage()->EraseLabel(pixelValue);
     this->WaitCursorOff();
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 void QmitkLabelSetWidget::OnRemoveLabel(bool /*value*/)
 {
   int pixelValue = GetPixelValueOfSelectedItem();
   QString question = "Do you really want to remove label \"";
   question.append(
     QString::fromStdString(GetWorkingImage()->GetLabel(pixelValue, GetWorkingImage()->GetActiveLayer())->GetName()));
   question.append("\"?");
 
   QMessageBox::StandardButton answerButton =
     QMessageBox::question(this, "Remove label", question, QMessageBox::Yes | QMessageBox::Cancel, QMessageBox::Yes);
 
   if (answerButton == QMessageBox::Yes)
   {
     this->WaitCursorOn();
     GetWorkingImage()->GetActiveLabelSet()->RemoveLabel(pixelValue);
     GetWorkingImage()->EraseLabel(pixelValue);
     this->WaitCursorOff();
   }
 
   ResetAllTableWidgetItems();
 }
 
 void QmitkLabelSetWidget::OnRenameLabel(bool /*value*/)
 {
   int pixelValue = GetPixelValueOfSelectedItem();
   QmitkNewSegmentationDialog dialog(this);
   dialog.setWindowTitle("Rename Label");
   dialog.SetSuggestionList(m_OrganColors);
   dialog.SetColor(GetWorkingImage()->GetActiveLabelSet()->GetLabel(pixelValue)->GetColor());
   dialog.SetSegmentationName(
     QString::fromStdString(GetWorkingImage()->GetActiveLabelSet()->GetLabel(pixelValue)->GetName()));
 
   if (dialog.exec() == QDialog::Rejected)
   {
     return;
   }
   QString segmentationName = dialog.GetSegmentationName();
   if (segmentationName.isEmpty())
   {
     segmentationName = "Unnamed";
   }
 
   GetWorkingImage()->GetActiveLabelSet()->RenameLabel(pixelValue, segmentationName.toStdString(), dialog.GetColor());
   GetWorkingImage()->GetActiveLabelSet()->UpdateLookupTable(pixelValue);
 
   UpdateAllTableWidgetItems();
 }
 
 void QmitkLabelSetWidget::OnCombineAndCreateMask(bool /*value*/)
 {
   m_Controls.m_LabelSetTableWidget->selectedRanges();
   // ...to do... //
 }
 
 void QmitkLabelSetWidget::OnCreateMasks(bool /*value*/)
 {
   m_Controls.m_LabelSetTableWidget->selectedRanges();
   // ..to do.. //
 }
 
 void QmitkLabelSetWidget::OnCombineAndCreateSurface(bool /*value*/)
 {
   m_Controls.m_LabelSetTableWidget->selectedRanges();
   // ..to do.. //
 }
 
 void QmitkLabelSetWidget::OnEraseLabels(bool /*value*/)
 {
   QString question = "Do you really want to erase the selected labels?";
 
   QMessageBox::StandardButton answerButton = QMessageBox::question(
     this, "Erase selected labels", question, QMessageBox::Yes | QMessageBox::Cancel, QMessageBox::Yes);
 
   if (answerButton == QMessageBox::Yes)
   {
     QList<QTableWidgetSelectionRange> ranges = m_Controls.m_LabelSetTableWidget->selectedRanges();
     if (ranges.isEmpty())
       return;
 
     std::vector<mitk::Label::PixelType> VectorOfLablePixelValues;
     foreach (QTableWidgetSelectionRange a, ranges)
       for (int i = a.topRow(); i <= a.bottomRow(); i++)
         VectorOfLablePixelValues.push_back(m_Controls.m_LabelSetTableWidget->item(i, 0)->data(Qt::UserRole).toInt());
 
     this->WaitCursorOn();
     GetWorkingImage()->EraseLabels(VectorOfLablePixelValues, GetWorkingImage()->GetActiveLayer());
     this->WaitCursorOff();
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 void QmitkLabelSetWidget::OnRemoveLabels(bool /*value*/)
 {
   QString question = "Do you really want to remove selected labels?";
   QMessageBox::StandardButton answerButton = QMessageBox::question(
     this, "Remove selected labels", question, QMessageBox::Yes | QMessageBox::Cancel, QMessageBox::Yes);
 
   if (answerButton == QMessageBox::Yes)
   {
     QList<QTableWidgetSelectionRange> ranges = m_Controls.m_LabelSetTableWidget->selectedRanges();
     if (ranges.isEmpty())
     {
       return;
     }
 
     std::vector<mitk::Label::PixelType> VectorOfLablePixelValues;
     foreach (QTableWidgetSelectionRange a, ranges)
     {
       for (int i = a.topRow(); i <= a.bottomRow(); ++i)
       {
         VectorOfLablePixelValues.push_back(m_Controls.m_LabelSetTableWidget->item(i, 0)->data(Qt::UserRole).toInt());
       }
     }
 
     this->WaitCursorOn();
     GetWorkingImage()->RemoveLabels(VectorOfLablePixelValues, GetWorkingImage()->GetActiveLayer());
     this->WaitCursorOff();
   }
 
   ResetAllTableWidgetItems();
 }
 
 void QmitkLabelSetWidget::OnMergeLabels(bool /*value*/)
 {
   int pixelValue = GetPixelValueOfSelectedItem();
   QString question = "Do you really want to merge selected labels into \"";
   question.append(
     QString::fromStdString(GetWorkingImage()->GetLabel(pixelValue, GetWorkingImage()->GetActiveLayer())->GetName()));
   question.append("\"?");
 
   QMessageBox::StandardButton answerButton = QMessageBox::question(
     this, "Merge selected label", question, QMessageBox::Yes | QMessageBox::Cancel, QMessageBox::Yes);
 
   if (answerButton == QMessageBox::Yes)
   {
     QList<QTableWidgetSelectionRange> ranges = m_Controls.m_LabelSetTableWidget->selectedRanges();
     if (ranges.isEmpty())
     {
       return;
     }
 
     std::vector<mitk::Label::PixelType> vectorOfSourcePixelValues;
     foreach (QTableWidgetSelectionRange a, ranges)
     {
       for (int i = a.topRow(); i <= a.bottomRow(); ++i)
       {
         vectorOfSourcePixelValues.push_back(m_Controls.m_LabelSetTableWidget->item(i, 0)->data(Qt::UserRole).toInt());
       }
     }
 
     this->WaitCursorOn();
     GetWorkingImage()->MergeLabels(pixelValue, vectorOfSourcePixelValues, GetWorkingImage()->GetActiveLayer());
     this->WaitCursorOff();
 
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 void QmitkLabelSetWidget::OnLockedButtonClicked()
 {
   int row = -1;
   for (int i = 0; i < m_Controls.m_LabelSetTableWidget->rowCount(); ++i)
   {
     if (sender() == m_Controls.m_LabelSetTableWidget->cellWidget(i, LOCKED_COL))
     {
       row = i;
     }
   }
   if (row >= 0 && row < m_Controls.m_LabelSetTableWidget->rowCount())
   {
     int pixelValue = m_Controls.m_LabelSetTableWidget->item(row, 0)->data(Qt::UserRole).toInt();
     GetWorkingImage()
       ->GetLabel(pixelValue, GetWorkingImage()->GetActiveLayer())
       ->SetLocked(!GetWorkingImage()->GetLabel(pixelValue, GetWorkingImage()->GetActiveLayer())->GetLocked());
   }
 }
 
 void QmitkLabelSetWidget::OnVisibleButtonClicked()
 {
   int row = -1;
   for (int i = 0; i < m_Controls.m_LabelSetTableWidget->rowCount(); ++i)
   {
     if (sender() == m_Controls.m_LabelSetTableWidget->cellWidget(i, VISIBLE_COL))
     {
       row = i;
       break;
     }
   }
 
   if (row >= 0 && row < m_Controls.m_LabelSetTableWidget->rowCount())
   {
     QTableWidgetItem *item = m_Controls.m_LabelSetTableWidget->item(row, 0);
     int pixelValue = item->data(Qt::UserRole).toInt();
     GetWorkingImage()
       ->GetLabel(pixelValue, GetWorkingImage()->GetActiveLayer())
       ->SetVisible(!GetWorkingImage()->GetLabel(pixelValue, GetWorkingImage()->GetActiveLayer())->GetVisible());
     GetWorkingImage()->GetActiveLabelSet()->UpdateLookupTable(pixelValue);
   }
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkLabelSetWidget::OnColorButtonClicked()
 {
   int row = -1;
   for (int i = 0; i < m_Controls.m_LabelSetTableWidget->rowCount(); ++i)
   {
     if (sender() == m_Controls.m_LabelSetTableWidget->cellWidget(i, COLOR_COL))
     {
       row = i;
     }
   }
 
   if (row >= 0 && row < m_Controls.m_LabelSetTableWidget->rowCount())
   {
     int pixelValue = m_Controls.m_LabelSetTableWidget->item(row, 0)->data(Qt::UserRole).toInt();
     const mitk::Color &color = GetWorkingImage()->GetLabel(pixelValue, GetWorkingImage()->GetActiveLayer())->GetColor();
     QColor initial(color.GetRed() * 255, color.GetGreen() * 255, color.GetBlue() * 255);
     QColor qcolor = QColorDialog::getColor(initial, nullptr, QString("Change color"));
     if (!qcolor.isValid())
     {
       return;
     }
 
     QPushButton *button = static_cast<QPushButton *>(m_Controls.m_LabelSetTableWidget->cellWidget(row, COLOR_COL));
     if (!button)
     {
       return;
     }
 
     button->setAutoFillBackground(true);
 
     QString styleSheet = "background-color:rgb(";
     styleSheet.append(QString::number(qcolor.red()));
     styleSheet.append(",");
     styleSheet.append(QString::number(qcolor.green()));
     styleSheet.append(",");
     styleSheet.append(QString::number(qcolor.blue()));
     styleSheet.append("); border: 0;");
     button->setStyleSheet(styleSheet);
 
     mitk::Color newColor;
     newColor.SetRed(qcolor.red() / 255.0);
     newColor.SetGreen(qcolor.green() / 255.0);
     newColor.SetBlue(qcolor.blue() / 255.0);
 
     GetWorkingImage()->GetLabel(pixelValue, GetWorkingImage()->GetActiveLayer())->SetColor(newColor);
 
     GetWorkingImage()->GetActiveLabelSet()->UpdateLookupTable(pixelValue);
   }
 }
 
 void QmitkLabelSetWidget::OnRandomColor(bool /*value*/)
 {
   int pixelValue = GetPixelValueOfSelectedItem();
   GetWorkingImage()
     ->GetLabel(pixelValue, GetWorkingImage()->GetActiveLayer())
     ->SetColor(m_ColorSequenceRainbow.GetNextColor());
   GetWorkingImage()->GetActiveLabelSet()->UpdateLookupTable(pixelValue);
   UpdateAllTableWidgetItems();
 }
 
 void QmitkLabelSetWidget::SetOrganColors(const QStringList &organColors)
 {
   m_OrganColors = organColors;
 }
 
 void QmitkLabelSetWidget::OnActiveLabelChanged(int pixelValue)
 {
   mitk::LabelSetImage *workingImage = GetWorkingImage();
   assert(workingImage);
   workingImage->GetActiveLabelSet()->SetActiveLabel(pixelValue);
   // MITK_INFO << "Active Label set to << " << pixelValue;
 
   mitk::SurfaceBasedInterpolationController *interpolator = mitk::SurfaceBasedInterpolationController::GetInstance();
   if (interpolator)
   {
     interpolator->SetActiveLabel(pixelValue);
   }
 
   workingImage->Modified();
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkLabelSetWidget::OnItemClicked(QTableWidgetItem *item)
 {
   if (!item)
     return;
 
   int pixelValue = item->data(Qt::UserRole).toInt();
 
   QList<QTableWidgetSelectionRange> ranges = m_Controls.m_LabelSetTableWidget->selectedRanges();
   if (!ranges.empty() && ranges.back().rowCount() == 1)
   {
-    SelectLabelByPixelValue(pixelValue);
+    m_ProcessingManualSelection = true;
     OnActiveLabelChanged(pixelValue);
+    m_ProcessingManualSelection = false;
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 void QmitkLabelSetWidget::OnItemDoubleClicked(QTableWidgetItem *item)
 {
   if (!item)
     return;
 
   int pixelValue = item->data(Qt::UserRole).toInt();
   // OnItemClicked(item); <<-- Double click first call OnItemClicked
   WaitCursorOn();
   mitk::LabelSetImage *workingImage = GetWorkingImage();
   workingImage->UpdateCenterOfMass(pixelValue, workingImage->GetActiveLayer());
   const mitk::Point3D &pos =
     workingImage->GetLabel(pixelValue, workingImage->GetActiveLayer())->GetCenterOfMassCoordinates();
   WaitCursorOff();
   if (pos.GetVnlVector().max_value() > 0.0)
   {
     emit goToLabel(pos);
   }
 
   workingImage->Modified();
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkLabelSetWidget::SelectLabelByPixelValue(mitk::Label::PixelType pixelValue)
 {
-  // MITK_INFO << "QmitkLabelSetWidget::SelectLabelByPixelValue " << pixelValue;
-
-  if (!GetWorkingImage()->ExistLabel(pixelValue))
+  if (m_ProcessingManualSelection || !GetWorkingImage()->ExistLabel(pixelValue))
     return;
+
   for (int row = 0; row < m_Controls.m_LabelSetTableWidget->rowCount(); row++)
   {
     if (m_Controls.m_LabelSetTableWidget->item(row, 0)->data(Qt::UserRole).toInt() == pixelValue)
     {
       m_Controls.m_LabelSetTableWidget->clearSelection();
-      m_Controls.m_LabelSetTableWidget->setSelectionMode(QAbstractItemView::SingleSelection);
       m_Controls.m_LabelSetTableWidget->selectRow(row);
       m_Controls.m_LabelSetTableWidget->scrollToItem(m_Controls.m_LabelSetTableWidget->item(row, 0));
-      m_Controls.m_LabelSetTableWidget->setSelectionMode(QAbstractItemView::ExtendedSelection);
       return;
     }
   }
 }
 
 void QmitkLabelSetWidget::InsertTableWidgetItem(mitk::Label *label)
 {
   const mitk::Color &color = label->GetColor();
 
   QString styleSheet = "background-color:rgb(";
   styleSheet.append(QString::number(color[0] * 255));
   styleSheet.append(",");
   styleSheet.append(QString::number(color[1] * 255));
   styleSheet.append(",");
   styleSheet.append(QString::number(color[2] * 255));
   styleSheet.append("); border: 0;");
 
   QTableWidget *tableWidget = m_Controls.m_LabelSetTableWidget;
   int colWidth = (tableWidget->columnWidth(NAME_COL) < 180) ? 180 : tableWidget->columnWidth(NAME_COL) - 2;
   QString text = fontMetrics().elidedText(label->GetName().c_str(), Qt::ElideMiddle, colWidth);
   QTableWidgetItem *nameItem = new QTableWidgetItem(text);
   nameItem->setTextAlignment(Qt::AlignCenter | Qt::AlignLeft);
   // ---!---
   // IMPORTANT: ADD PIXELVALUE TO TABLEWIDGETITEM.DATA
   nameItem->setData(Qt::UserRole, QVariant(label->GetValue()));
   // ---!---
 
   QPushButton *pbColor = new QPushButton(tableWidget);
   pbColor->setFixedSize(24, 24);
   pbColor->setCheckable(false);
   pbColor->setAutoFillBackground(true);
   pbColor->setToolTip("Change label color");
   pbColor->setStyleSheet(styleSheet);
 
   connect(pbColor, SIGNAL(clicked()), this, SLOT(OnColorButtonClicked()));
 
   QString transparentStyleSheet = QLatin1String("background-color: transparent; border: 0;");
 
   QPushButton *pbLocked = new QPushButton(tableWidget);
   pbLocked->setFixedSize(24, 24);
   QIcon *iconLocked = new QIcon();
   auto lockIcon = QmitkStyleManager::ThemeIcon(QLatin1String(":/Qmitk/lock.svg"));
   auto unlockIcon = QmitkStyleManager::ThemeIcon(QLatin1String(":/Qmitk/unlock.svg"));
   iconLocked->addPixmap(lockIcon.pixmap(64), QIcon::Normal, QIcon::Off);
   iconLocked->addPixmap(unlockIcon.pixmap(64), QIcon::Normal, QIcon::On);
   pbLocked->setIcon(*iconLocked);
   pbLocked->setIconSize(QSize(24, 24));
   pbLocked->setCheckable(true);
   pbLocked->setToolTip("Lock/unlock label");
   pbLocked->setChecked(!label->GetLocked());
   pbLocked->setStyleSheet(transparentStyleSheet);
 
   connect(pbLocked, SIGNAL(clicked()), this, SLOT(OnLockedButtonClicked()));
 
   QPushButton *pbVisible = new QPushButton(tableWidget);
   pbVisible->setFixedSize(24, 24);
   pbVisible->setAutoRepeat(false);
   QIcon *iconVisible = new QIcon();
   auto visibleIcon = QmitkStyleManager::ThemeIcon(QLatin1String(":/Qmitk/visible.svg"));
   auto invisibleIcon = QmitkStyleManager::ThemeIcon(QLatin1String(":/Qmitk/invisible.svg"));
   iconVisible->addPixmap(visibleIcon.pixmap(64), QIcon::Normal, QIcon::Off);
   iconVisible->addPixmap(invisibleIcon.pixmap(64), QIcon::Normal, QIcon::On);
   pbVisible->setIcon(*iconVisible);
   pbVisible->setIconSize(QSize(24, 24));
   pbVisible->setCheckable(true);
   pbVisible->setToolTip("Show/hide label");
   pbVisible->setChecked(!label->GetVisible());
   pbVisible->setStyleSheet(transparentStyleSheet);
 
   connect(pbVisible, SIGNAL(clicked()), this, SLOT(OnVisibleButtonClicked()));
 
   int row = tableWidget->rowCount();
   tableWidget->insertRow(row);
   tableWidget->setRowHeight(row, 24);
   tableWidget->setItem(row, 0, nameItem);
   tableWidget->setCellWidget(row, 1, pbLocked);
   tableWidget->setCellWidget(row, 2, pbColor);
   tableWidget->setCellWidget(row, 3, pbVisible);
   tableWidget->selectRow(row);
 
   // m_LabelSetImage->SetActiveLabel(label->GetPixelValue());
   // m_ToolManager->WorkingDataModified.Send();
   // emit activeLabelChanged(label->GetPixelValue());
 
   if (row == 0)
   {
     tableWidget->hideRow(row); // hide exterior label
   }
 }
 
 void QmitkLabelSetWidget::UpdateAllTableWidgetItems()
 {
   mitk::LabelSetImage *workingImage = GetWorkingImage();
   if (!workingImage)
     return;
 
   // add all labels
   QTableWidget *tableWidget = m_Controls.m_LabelSetTableWidget;
   m_LabelStringList.clear();
   for (int i = 0; i < tableWidget->rowCount(); ++i)
   {
     UpdateTableWidgetItem(tableWidget->item(i, 0));
     m_LabelStringList.append(tableWidget->item(i, 0)->text());
   }
 
   OnLabelListModified(m_LabelStringList);
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkLabelSetWidget::UpdateTableWidgetItem(QTableWidgetItem *item)
 {
   mitk::LabelSetImage *workingImage = GetWorkingImage();
   mitk::Label *label = workingImage->GetLabel(item->data(Qt::UserRole).toInt(), workingImage->GetActiveLayer());
 
   const mitk::Color &color = label->GetColor();
 
   QString styleSheet = "background-color:rgb(";
   styleSheet.append(QString::number(color[0] * 255));
   styleSheet.append(",");
   styleSheet.append(QString::number(color[1] * 255));
   styleSheet.append(",");
   styleSheet.append(QString::number(color[2] * 255));
   styleSheet.append("); border: 0;");
 
   QTableWidget *tableWidget = m_Controls.m_LabelSetTableWidget;
   int colWidth = (tableWidget->columnWidth(NAME_COL) < 180) ? 180 : tableWidget->columnWidth(NAME_COL) - 2;
   QString text = fontMetrics().elidedText(label->GetName().c_str(), Qt::ElideMiddle, colWidth);
   item->setText(text);
 
   QPushButton *pbLocked = dynamic_cast<QPushButton *>(tableWidget->cellWidget(item->row(), 1));
   pbLocked->setChecked(!label->GetLocked());
 
   QPushButton *pbColor = dynamic_cast<QPushButton *>(tableWidget->cellWidget(item->row(), 2));
   pbColor->setStyleSheet(styleSheet);
 
   QPushButton *pbVisible = dynamic_cast<QPushButton *>(tableWidget->cellWidget(item->row(), 3));
   pbVisible->setChecked(!label->GetVisible());
 
   if (item->row() == 0)
   {
     tableWidget->hideRow(item->row()); // hide exterior label
   }
 }
 
 void QmitkLabelSetWidget::ResetAllTableWidgetItems()
 {
   QTableWidget *tableWidget = m_Controls.m_LabelSetTableWidget;
   // remove all rows
   while (tableWidget->rowCount())
   {
     tableWidget->removeRow(0);
   }
 
   mitk::DataNode * workingNode = GetWorkingNode();
   auto workingImage = dynamic_cast<mitk::LabelSetImage*>(workingNode->GetData());
   if (nullptr == workingImage)
   {
     return;
   }
 
   // add all labels
   m_LabelStringList.clear();
 
   mitk::LabelSet::LabelContainerConstIteratorType it = workingImage->GetActiveLabelSet()->IteratorConstBegin();
   mitk::LabelSet::LabelContainerConstIteratorType end = workingImage->GetActiveLabelSet()->IteratorConstEnd();
 
   int pixelValue = -1;
   while (it != end)
   {
     InsertTableWidgetItem(it->second);
     if (workingImage->GetActiveLabel() == it->second) // get active
       pixelValue = it->first;
     m_LabelStringList.append(QString(it->second->GetName().c_str()));
     it++;
   }
 
   SelectLabelByPixelValue(pixelValue);
 
   OnLabelListModified(m_LabelStringList);
 
   std::stringstream captionText;
   captionText << "Number of labels: " << workingImage->GetNumberOfLabels(workingImage->GetActiveLayer()) - 1;
   m_Controls.m_lblCaption->setText(captionText.str().c_str());
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
   emit LabelSetWidgetReset();
 }
 
 int QmitkLabelSetWidget::GetPixelValueOfSelectedItem()
 {
   if (m_Controls.m_LabelSetTableWidget->currentItem())
   {
     return m_Controls.m_LabelSetTableWidget->currentItem()->data(Qt::UserRole).toInt();
   }
   return -1;
 }
 
 QStringList &QmitkLabelSetWidget::GetLabelStringList()
 {
   return m_LabelStringList;
 }
 
 void QmitkLabelSetWidget::InitializeTableWidget()
 {
-  QTableWidget *tableWidged = m_Controls.m_LabelSetTableWidget;
-
-  tableWidged->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Maximum);
-  tableWidged->setTabKeyNavigation(false);
-  tableWidged->setAlternatingRowColors(false);
-  tableWidged->setFocusPolicy(Qt::NoFocus);
-  tableWidged->setColumnCount(4);
-  tableWidged->resizeColumnToContents(NAME_COL);
-  tableWidged->setColumnWidth(LOCKED_COL, 25);
-  tableWidged->setColumnWidth(COLOR_COL, 25);
-  tableWidged->setColumnWidth(VISIBLE_COL, 25);
-  tableWidged->horizontalHeader()->setSectionResizeMode(0, QHeaderView::Stretch);
-  tableWidged->setContextMenuPolicy(Qt::CustomContextMenu);
-  tableWidged->horizontalHeader()->hide();
-  tableWidged->setSortingEnabled(false);
-  tableWidged->verticalHeader()->hide();
-  tableWidged->setEditTriggers(QAbstractItemView::NoEditTriggers);
-  tableWidged->setSelectionMode(QAbstractItemView::ExtendedSelection);
-  tableWidged->setSelectionBehavior(QAbstractItemView::SelectRows);
-
-  connect(tableWidged, SIGNAL(itemClicked(QTableWidgetItem *)), this, SLOT(OnItemClicked(QTableWidgetItem *)));
+  QTableWidget *tableWidget = m_Controls.m_LabelSetTableWidget;
+
+  tableWidget->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Maximum);
+  tableWidget->setTabKeyNavigation(false);
+  tableWidget->setAlternatingRowColors(false);
+  tableWidget->setFocusPolicy(Qt::NoFocus);
+  tableWidget->setColumnCount(4);
+  tableWidget->resizeColumnToContents(NAME_COL);
+  tableWidget->setColumnWidth(LOCKED_COL, 25);
+  tableWidget->setColumnWidth(COLOR_COL, 25);
+  tableWidget->setColumnWidth(VISIBLE_COL, 25);
+  tableWidget->horizontalHeader()->setSectionResizeMode(0, QHeaderView::Stretch);
+  tableWidget->setContextMenuPolicy(Qt::CustomContextMenu);
+  tableWidget->horizontalHeader()->hide();
+  tableWidget->setSortingEnabled(false);
+  tableWidget->verticalHeader()->hide();
+  tableWidget->setEditTriggers(QAbstractItemView::NoEditTriggers);
+
+  connect(tableWidget, SIGNAL(itemClicked(QTableWidgetItem *)), this, SLOT(OnItemClicked(QTableWidgetItem *)));
   connect(
-    tableWidged, SIGNAL(itemDoubleClicked(QTableWidgetItem *)), this, SLOT(OnItemDoubleClicked(QTableWidgetItem *)));
-  connect(tableWidged,
+    tableWidget, SIGNAL(itemDoubleClicked(QTableWidgetItem *)), this, SLOT(OnItemDoubleClicked(QTableWidgetItem *)));
+  connect(tableWidget,
           SIGNAL(customContextMenuRequested(const QPoint &)),
           this,
           SLOT(OnTableViewContextMenuRequested(const QPoint &)));
 
   // connect( m_Controls.m_LabelSetTableWidget, SIGNAL(activeLabelChanged(int)), this, SLOT(OnActiveLabelChanged(int))
   // );
   // connect( m_Controls.m_LabelSetTableWidget, SIGNAL(importSegmentation()), this, SLOT( OnImportSegmentation()) );
   // connect( m_Controls.m_LabelSetTableWidget, SIGNAL(importLabeledImage()), this, SLOT( OnImportLabeledImage()) );
   // connect( m_Controls.m_LabelSetTableWidget, SIGNAL(renameLabel(int, const mitk::Color&, const std::string&)), this,
   // SLOT(OnRenameLabel(int, const mitk::Color&, const std::string&)) );
   // connect( m_Controls.m_LabelSetTableWidget, SIGNAL(createSurface(int, bool)), this, SLOT(OnCreateSurface(int, bool))
   // );
   // connect( m_Controls.m_LabelSetTableWidget, SIGNAL(toggleOutline(bool)), this, SLOT(OnToggleOutline(bool)) );
   // connect( m_Controls.m_LabelSetTableWidget, SIGNAL(goToLabel(const mitk::Point3D&)), this, SIGNAL(goToLabel(const
   // mitk::Point3D&)) );
   // connect( m_Controls.m_LabelSetTableWidget, SIGNAL(combineAndCreateSurface( const QList<QTableWidgetSelectionRange>&
   // )),
   //    this, SLOT(OnCombineAndCreateSurface( const QList<QTableWidgetSelectionRange>&)) );
 
   // connect( m_Controls.m_LabelSetTableWidget, SIGNAL(createMask(int)), this, SLOT(OnCreateMask(int)) );
   // connect( m_Controls.m_LabelSetTableWidget, SIGNAL(createCroppedMask(int)), this, SLOT(OnCreateCroppedMask(int)) );
   // connect( m_Controls.m_LabelSetTableWidget, SIGNAL(combineAndCreateMask( const QList<QTableWidgetSelectionRange>&
   // )),
   //    this, SLOT(OnCombineAndCreateMask( const QList<QTableWidgetSelectionRange>&)) );
 }
 
 void QmitkLabelSetWidget::OnOpacityChanged(int value)
 {
   int pixelValue = GetPixelValueOfSelectedItem();
   float opacity = static_cast<float>(value) / 100.0f;
   GetWorkingImage()->GetLabel(pixelValue, GetWorkingImage()->GetActiveLayer())->SetOpacity(opacity);
   GetWorkingImage()->GetActiveLabelSet()->UpdateLookupTable(pixelValue);
 }
 
 void QmitkLabelSetWidget::setEnabled(bool enabled)
 {
   QWidget::setEnabled(enabled);
   UpdateControls();
 }
 
 void QmitkLabelSetWidget::SetDataStorage(mitk::DataStorage *storage)
 {
   m_DataStorage = storage;
 }
 
 void QmitkLabelSetWidget::OnSearchLabel()
 {
   std::string text = m_Controls.m_LabelSearchBox->text().toStdString();
   int pixelValue = -1;
   int row = -1;
   for (int i = 0; i < m_Controls.m_LabelSetTableWidget->rowCount(); ++i)
   {
     if (m_Controls.m_LabelSetTableWidget->item(i, 0)->text().toStdString().compare(text) == 0)
     {
       pixelValue = m_Controls.m_LabelSetTableWidget->item(i, 0)->data(Qt::UserRole).toInt();
       row = i;
       break;
     }
   }
   if (pixelValue == -1)
   {
     return;
   }
 
   GetWorkingImage()->GetActiveLabelSet()->SetActiveLabel(pixelValue);
 
   QTableWidgetItem *nameItem = m_Controls.m_LabelSetTableWidget->item(row, NAME_COL);
   if (!nameItem)
   {
     return;
   }
 
   m_Controls.m_LabelSetTableWidget->clearSelection();
-  m_Controls.m_LabelSetTableWidget->setSelectionMode(QAbstractItemView::SingleSelection);
   m_Controls.m_LabelSetTableWidget->selectRow(row);
   m_Controls.m_LabelSetTableWidget->scrollToItem(nameItem);
-  m_Controls.m_LabelSetTableWidget->setSelectionMode(QAbstractItemView::ExtendedSelection);
 
   GetWorkingImage()->GetActiveLabelSet()->SetActiveLabel(pixelValue);
 
   this->WaitCursorOn();
   mitk::Point3D pos =
     GetWorkingImage()->GetLabel(pixelValue, GetWorkingImage()->GetActiveLayer())->GetCenterOfMassCoordinates();
 
   m_ToolManager->WorkingDataChanged();
 
   if (pos.GetVnlVector().max_value() > 0.0)
   {
     emit goToLabel(pos);
   }
   else
   {
     GetWorkingImage()->UpdateCenterOfMass(pixelValue, GetWorkingImage()->GetActiveLayer());
     mitk::Point3D pos =
       GetWorkingImage()->GetLabel(pixelValue, GetWorkingImage()->GetActiveLayer())->GetCenterOfMassCoordinates();
     emit goToLabel(pos);
   }
 
   this->WaitCursorOff();
 }
 
 void QmitkLabelSetWidget::OnLabelListModified(const QStringList &list)
 {
   QStringListModel *completeModel = static_cast<QStringListModel *>(m_Completer->model());
   completeModel->setStringList(list);
 }
 
 mitk::LabelSetImage *QmitkLabelSetWidget::GetWorkingImage()
 {
   mitk::DataNode *workingNode = GetWorkingNode();
   mitk::LabelSetImage *workingImage = dynamic_cast<mitk::LabelSetImage *>(workingNode->GetData());
   assert(workingImage);
   return workingImage;
 }
 
 mitk::DataNode *QmitkLabelSetWidget::GetWorkingNode()
 {
   mitk::DataNode *workingNode = m_ToolManager->GetWorkingData(0);
   assert(workingNode);
   return workingNode;
 }
 
 void QmitkLabelSetWidget::UpdateControls()
 {
   mitk::DataNode *workingNode = m_ToolManager->GetWorkingData(0);
   bool hasWorkingData = (workingNode != nullptr);
 
   m_Controls.m_LabelSetTableWidget->setEnabled(hasWorkingData);
   m_Controls.m_LabelSearchBox->setEnabled(hasWorkingData);
 
   if (!hasWorkingData)
     return;
 
   QStringListModel *completeModel = static_cast<QStringListModel *>(m_Completer->model());
   completeModel->setStringList(GetLabelStringList());
 }
 
 void QmitkLabelSetWidget::OnCreateCroppedMask(bool)
 {
   m_ToolManager->ActivateTool(-1);
 
   mitk::LabelSetImage *workingImage = GetWorkingImage();
   mitk::Image::Pointer maskImage;
   int pixelValue = GetPixelValueOfSelectedItem();
   try
   {
     this->WaitCursorOn();
 
     mitk::AutoCropImageFilter::Pointer cropFilter = mitk::AutoCropImageFilter::New();
     cropFilter->SetInput(workingImage->CreateLabelMask(pixelValue));
     cropFilter->SetBackgroundValue(0);
     cropFilter->SetMarginFactor(1.15);
     cropFilter->Update();
 
     maskImage = cropFilter->GetOutput();
 
     this->WaitCursorOff();
   }
   catch (mitk::Exception &e)
   {
     this->WaitCursorOff();
     MITK_ERROR << "Exception caught: " << e.GetDescription();
     QMessageBox::information(this, "Create Mask", "Could not create a mask out of the selected label.\n");
     return;
   }
 
   if (maskImage.IsNull())
   {
     QMessageBox::information(this, "Create Mask", "Could not create a mask out of the selected label.\n");
     return;
   }
 
   mitk::DataNode::Pointer maskNode = mitk::DataNode::New();
   std::string name = workingImage->GetLabel(pixelValue, workingImage->GetActiveLayer())->GetName();
   name += "-mask";
   maskNode->SetName(name);
   maskNode->SetData(maskImage);
   maskNode->SetBoolProperty("binary", true);
   maskNode->SetBoolProperty("outline binary", true);
   maskNode->SetBoolProperty("outline binary shadow", true);
   maskNode->SetFloatProperty("outline width", 2.0);
   maskNode->SetColor(workingImage->GetLabel(pixelValue, workingImage->GetActiveLayer())->GetColor());
   maskNode->SetOpacity(1.0);
 
   m_DataStorage->Add(maskNode, GetWorkingNode());
 }
 
 void QmitkLabelSetWidget::OnCreateMask(bool /*triggered*/)
 {
   m_ToolManager->ActivateTool(-1);
 
   mitk::LabelSetImage *workingImage = GetWorkingImage();
   mitk::Image::Pointer maskImage;
   int pixelValue = GetPixelValueOfSelectedItem();
   try
   {
     this->WaitCursorOn();
     maskImage = workingImage->CreateLabelMask(pixelValue);
     this->WaitCursorOff();
   }
   catch (mitk::Exception &e)
   {
     this->WaitCursorOff();
     MITK_ERROR << "Exception caught: " << e.GetDescription();
     QMessageBox::information(this, "Create Mask", "Could not create a mask out of the selected label.\n");
     return;
   }
 
   if (maskImage.IsNull())
   {
     QMessageBox::information(this, "Create Mask", "Could not create a mask out of the selected label.\n");
     return;
   }
 
   mitk::DataNode::Pointer maskNode = mitk::DataNode::New();
   std::string name = workingImage->GetLabel(pixelValue, workingImage->GetActiveLayer())->GetName();
   name += "-mask";
   maskNode->SetName(name);
   maskNode->SetData(maskImage);
   maskNode->SetBoolProperty("binary", true);
   maskNode->SetBoolProperty("outline binary", true);
   maskNode->SetBoolProperty("outline binary shadow", true);
   maskNode->SetFloatProperty("outline width", 2.0);
   maskNode->SetColor(workingImage->GetLabel(pixelValue, workingImage->GetActiveLayer())->GetColor());
   maskNode->SetOpacity(1.0);
 
   m_DataStorage->Add(maskNode, GetWorkingNode());
 }
 
 void QmitkLabelSetWidget::OnToggleOutline(bool value)
 {
   mitk::DataNode *workingNode = m_ToolManager->GetWorkingData(0);
   assert(workingNode);
 
   workingNode->SetBoolProperty("labelset.contour.active", value);
   workingNode->GetData()->Modified(); // fixme: workaround to force data-type rendering (and not only property-type)
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkLabelSetWidget::OnCreateSmoothedSurface(bool /*triggered*/)
 {
   m_ToolManager->ActivateTool(-1);
 
   mitk::DataNode::Pointer workingNode = GetWorkingNode();
   mitk::LabelSetImage *workingImage = GetWorkingImage();
   int pixelValue = GetPixelValueOfSelectedItem();
 
   mitk::LabelSetImageToSurfaceThreadedFilter::Pointer surfaceFilter = mitk::LabelSetImageToSurfaceThreadedFilter::New();
 
   itk::SimpleMemberCommand<QmitkLabelSetWidget>::Pointer successCommand =
     itk::SimpleMemberCommand<QmitkLabelSetWidget>::New();
   successCommand->SetCallbackFunction(this, &QmitkLabelSetWidget::OnThreadedCalculationDone);
   surfaceFilter->AddObserver(mitk::ResultAvailable(), successCommand);
 
   itk::SimpleMemberCommand<QmitkLabelSetWidget>::Pointer errorCommand =
     itk::SimpleMemberCommand<QmitkLabelSetWidget>::New();
   errorCommand->SetCallbackFunction(this, &QmitkLabelSetWidget::OnThreadedCalculationDone);
   surfaceFilter->AddObserver(mitk::ProcessingError(), errorCommand);
 
   mitk::DataNode::Pointer groupNode = workingNode;
   surfaceFilter->SetPointerParameter("Group node", groupNode);
   surfaceFilter->SetPointerParameter("Input", workingImage);
   surfaceFilter->SetParameter("RequestedLabel", pixelValue);
   surfaceFilter->SetParameter("Smooth", true);
   surfaceFilter->SetDataStorage(*m_DataStorage);
 
   mitk::StatusBar::GetInstance()->DisplayText("Surface creation is running in background...");
 
   try
   {
     surfaceFilter->StartAlgorithm();
   }
   catch (mitk::Exception &e)
   {
     MITK_ERROR << "Exception caught: " << e.GetDescription();
     QMessageBox::information(this,
                              "Create Surface",
                              "Could not create a surface mesh out of the selected label. See error log for details.\n");
   }
 }
 
 void QmitkLabelSetWidget::OnCreateDetailedSurface(bool /*triggered*/)
 {
   m_ToolManager->ActivateTool(-1);
 
   mitk::DataNode::Pointer workingNode = GetWorkingNode();
   mitk::LabelSetImage *workingImage = GetWorkingImage();
   int pixelValue = GetPixelValueOfSelectedItem();
 
   mitk::LabelSetImageToSurfaceThreadedFilter::Pointer surfaceFilter = mitk::LabelSetImageToSurfaceThreadedFilter::New();
 
   itk::SimpleMemberCommand<QmitkLabelSetWidget>::Pointer successCommand =
     itk::SimpleMemberCommand<QmitkLabelSetWidget>::New();
   successCommand->SetCallbackFunction(this, &QmitkLabelSetWidget::OnThreadedCalculationDone);
   surfaceFilter->AddObserver(mitk::ResultAvailable(), successCommand);
 
   itk::SimpleMemberCommand<QmitkLabelSetWidget>::Pointer errorCommand =
     itk::SimpleMemberCommand<QmitkLabelSetWidget>::New();
   errorCommand->SetCallbackFunction(this, &QmitkLabelSetWidget::OnThreadedCalculationDone);
   surfaceFilter->AddObserver(mitk::ProcessingError(), errorCommand);
 
   mitk::DataNode::Pointer groupNode = workingNode;
   surfaceFilter->SetPointerParameter("Group node", groupNode);
   surfaceFilter->SetPointerParameter("Input", workingImage);
   surfaceFilter->SetParameter("RequestedLabel", pixelValue);
   surfaceFilter->SetParameter("Smooth", false);
   surfaceFilter->SetDataStorage(*m_DataStorage);
 
   mitk::StatusBar::GetInstance()->DisplayText("Surface creation is running in background...");
 
   try
   {
     surfaceFilter->StartAlgorithm();
   }
   catch (mitk::Exception &e)
   {
     MITK_ERROR << "Exception caught: " << e.GetDescription();
     QMessageBox::information(this,
                              "Create Surface",
                              "Could not create a surface mesh out of the selected label. See error log for details.\n");
   }
 }
 
 void QmitkLabelSetWidget::OnImportLabeledImage()
 {
   /*
     m_ToolManager->ActivateTool(-1);
 
     mitk::DataNode* referenceNode = m_ToolManager->GetReferenceData(0);
     assert(referenceNode);
 
     // Ask the user for a list of files to open
     QStringList fileNames = QFileDialog::getOpenFileNames( this, "Open Image", m_LastFileOpenPath,
                                                           mitk::CoreObjectFactory::GetInstance()->GetFileExtensions());
 
     if (fileNames.empty())
       return;
 
     try
     {
       this->WaitCursorOn();
       mitk::Image::Pointer image = mitk::IOUtil::Load<mitk::Image>( fileNames.front().toStdString() );
       if (image.IsNull())
       {
         this->WaitCursorOff();
         QMessageBox::information(this, "Import Labeled Image", "Could not load the selected segmentation.\n");
         return;
       }
 
       mitk::LabelSetImage::Pointer newImage = mitk::LabelSetImage::New();
       newImage->InitializeByLabeledImage(image);
       this->WaitCursorOff();
 
       mitk::DataNode::Pointer newNode = mitk::DataNode::New();
       std::string newName = referenceNode->GetName();
       newName += "-labels";
       newNode->SetName(newName);
       newNode->SetData(newImage);
       m_DataStorage->Add(newNode, referenceNode);
     }
     catch (mitk::Exception & e)
     {
       this->WaitCursorOff();
       MITK_ERROR << "Exception caught: " << e.GetDescription();
       QMessageBox::information(this, "Import Labeled Image", "Could not load the selected segmentation. See error log
     for details.\n");
       return;
      }
 
     this->UpdateControls();
 
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     */
 }
 
 void QmitkLabelSetWidget::OnImportSegmentation()
 {
   /*
     m_ToolManager->ActivateTool(-1);
 
     mitk::DataNode* workingNode = m_ToolManager->GetWorkingData(0);
     assert(workingNode);
 
     mitk::LabelSetImage* workingImage = dynamic_cast<mitk::LabelSetImage*>( workingNode->GetData() );
     assert(workingImage);
 
     std::string fileExtensions("Segmentation files (*.lset);;");
     QString qfileName = QFileDialog::getOpenFileName(this, "Import Segmentation", m_LastFileOpenPath,
     fileExtensions.c_str() );
     if (qfileName.isEmpty() ) return;
 
     mitk::NrrdLabelSetImageReader::Pointer reader = mitk::NrrdLabelSetImageReader::New();
     reader->SetFileName(qfileName.toLatin1());
 
     try
     {
       this->WaitCursorOn();
       reader->Update();
       mitk::LabelSetImage::Pointer newImage = reader->GetOutput();
       workingImage->Concatenate(newImage);
       this->WaitCursorOff();
     }
     catch ( mitk::Exception& e )
     {
       this->WaitCursorOff();
       MITK_ERROR << "Exception caught: " << e.GetDescription();
       QMessageBox::information(this, "Import Segmentation", "Could not import the selected segmentation session.\n See
     error log for details.\n");
     }
   */
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkLabelSetWidget::WaitCursorOn()
 {
   QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
 }
 
 void QmitkLabelSetWidget::WaitCursorOff()
 {
   this->RestoreOverrideCursor();
 }
 
 void QmitkLabelSetWidget::RestoreOverrideCursor()
 {
   QApplication::restoreOverrideCursor();
 }
 
 void QmitkLabelSetWidget::OnThreadedCalculationDone()
 {
   mitk::StatusBar::GetInstance()->Clear();
 }
diff --git a/Modules/SegmentationUI/Qmitk/QmitkLabelSetWidget.h b/Modules/SegmentationUI/Qmitk/QmitkLabelSetWidget.h
index 690186d7c8..12978f8022 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkLabelSetWidget.h
+++ b/Modules/SegmentationUI/Qmitk/QmitkLabelSetWidget.h
@@ -1,171 +1,171 @@
 /*============================================================================
 
 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 QmitkLabelSetWidget_h
 #define QmitkLabelSetWidget_h
 
 #include "MitkSegmentationUIExports.h"
 
 #include "mitkColorSequenceRainbow.h"
 #include "mitkLabel.h"
 #include "mitkNumericTypes.h"
 #include <ui_QmitkLabelSetWidgetControls.h>
 
 class QmitkDataStorageComboBox;
 class QCompleter;
 
 namespace mitk
 {
   class LabelSetImage;
   class LabelSet;
   class Label;
   class DataStorage;
   class ToolManager;
   class DataNode;
 }
 
 class MITKSEGMENTATIONUI_EXPORT QmitkLabelSetWidget : public QWidget
 {
   Q_OBJECT
 
 public:
   explicit QmitkLabelSetWidget(QWidget *parent = nullptr);
   ~QmitkLabelSetWidget() override;
 
   void SetDataStorage(mitk::DataStorage *storage);
 
   void SetOrganColors(const QStringList &organColors);
 
   void UpdateControls();
 
   virtual void setEnabled(bool enabled);
 
   QStringList &GetLabelStringList();
 
 signals:
 
   /// \brief Send a signal when it was requested to go to a label.
   void goToLabel(const mitk::Point3D &);
   void LabelSetWidgetReset();
 
 public slots:
 
   /**
   * @brief Updates the current labels in the label set widget table. For each label (widget item) the 'UpdateTableWidgetItem' is called.
   *
   *   Updating means setting the color box of the table, setting the column with and fill it with the label name.
   *   Furthermore the two push buttons for locking and showing/hiding the layer are checked/unchecked.
   *   This functions only changes the appearance of the table widget and no render window update is necessary.
   */
   void UpdateAllTableWidgetItems();
   /**
   * @brief Resets the current labels in the label set widget table. For each label a widget item is inserted into the table.
   *
   *   Resetting means removing all rows of the widget table and inserting new rows (labels) from the active label set (= layer) of the current working node.
   *   The currently active label is selected and 'Number of labels' is set.
   *   As this function is typically used after one label has been removed or the reference node has been changed (e.g.) the render windows have to be updated.
   */
   void ResetAllTableWidgetItems();
   void SelectLabelByPixelValue(mitk::Label::PixelType pixelValue);
 
 private slots:
 
   // LabelSet dependent
   void OnOpacityChanged(int);
   void OnUnlockAllLabels(bool);
   void OnLockAllLabels(bool);
   void OnSetAllLabelsVisible(bool);
   void OnSetAllLabelsInvisible(bool);
   void OnSetOnlyActiveLabelVisible(bool);
   void OnRandomColor(bool);
   void OnRemoveLabel(bool);
   void OnRemoveLabels(bool);
   void OnRenameLabel(bool);
   void OnLockedButtonClicked();
   void OnVisibleButtonClicked();
   void OnColorButtonClicked();
   void OnItemClicked(QTableWidgetItem *item);
   void OnItemDoubleClicked(QTableWidgetItem *item);
   void OnTableViewContextMenuRequested(const QPoint &);
   void InsertTableWidgetItem(mitk::Label *label);
   void UpdateTableWidgetItem(QTableWidgetItem *item);
   // reaction to "returnPressed" signal from ...
   void OnSearchLabel();
   // reaction to the button "Change Label"
   void OnActiveLabelChanged(int pixelValue);
 
   // LabelSetImage Dependet
   void OnCreateDetailedSurface(bool);
   void OnCreateSmoothedSurface(bool);
   // reaction to the signal "createMask" from QmitkLabelSetTableWidget
   void OnCreateMask(bool);
   void OnCreateMasks(bool);
   // reaction to the signal "createCroppedMask" from QmitkLabelSetTableWidget
   void OnCreateCroppedMask(bool);
   void OnCombineAndCreateMask(bool);
   void OnCombineAndCreateSurface(bool);
   void OnEraseLabel(bool);
   void OnEraseLabels(bool);
-  // reaction to signal "mergeLabel" from QmitkLabelSetTableWidget
-  void OnMergeLabel(bool);
   void OnMergeLabels(bool);
   // reaction to the button "Import Segmentation"
   void OnImportSegmentation();
   // reaction to the button "Import Labeled Image"
   void OnImportLabeledImage();
 
   // reaction to signal "labelListModified" from QmitkLabelSetTableWidget
   void OnLabelListModified(const QStringList &list);
   // reaction to the signal "toggleOutline" from QmitkLabelSetTableWidget
   void OnToggleOutline(bool);
 
 private:
   enum TableColumns
   {
     NAME_COL = 0,
     LOCKED_COL,
     COLOR_COL,
     VISIBLE_COL
   };
 
   void WaitCursorOn();
 
   void WaitCursorOff();
 
   void RestoreOverrideCursor();
 
   void OnThreadedCalculationDone();
 
   void InitializeTableWidget();
 
   int GetPixelValueOfSelectedItem();
 
   mitk::LabelSetImage *GetWorkingImage();
 
   mitk::DataNode *GetWorkingNode();
 
   Ui::QmitkLabelSetWidgetControls m_Controls;
 
   mitk::ColorSequenceRainbow m_ColorSequenceRainbow;
 
   mitk::DataStorage *m_DataStorage;
 
   QCompleter *m_Completer;
 
   mitk::ToolManager *m_ToolManager;
 
   QStringList m_OrganColors;
 
   QStringList m_LabelStringList;
+
+  bool m_ProcessingManualSelection;
 };
 
 #endif
diff --git a/Modules/SegmentationUI/Qmitk/QmitkLabelSetWidgetControls.ui b/Modules/SegmentationUI/Qmitk/QmitkLabelSetWidgetControls.ui
index a9b4c069a3..0f28e488f2 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkLabelSetWidgetControls.ui
+++ b/Modules/SegmentationUI/Qmitk/QmitkLabelSetWidgetControls.ui
@@ -1,66 +1,70 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkLabelSetWidgetControls</class>
  <widget class="QWidget" name="QmitkLabelSetWidgetControls">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>312</width>
     <height>366</height>
    </rect>
   </property>
   <property name="sizePolicy">
    <sizepolicy hsizetype="Minimum" vsizetype="MinimumExpanding">
     <horstretch>0</horstretch>
     <verstretch>0</verstretch>
    </sizepolicy>
   </property>
   <property name="styleSheet">
    <string notr="true"/>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout">
    <property name="leftMargin">
     <number>6</number>
    </property>
    <property name="topMargin">
     <number>6</number>
    </property>
    <property name="rightMargin">
     <number>6</number>
    </property>
    <property name="bottomMargin">
     <number>6</number>
    </property>
    <item>
     <widget class="QLabel" name="m_lblCaption">
      <property name="text">
       <string>Caption</string>
      </property>
     </widget>
    </item>
    <item>
-    <widget class="QTableWidget" name="m_LabelSetTableWidget"/>
+    <widget class="QTableWidget" name="m_LabelSetTableWidget">
+     <property name="selectionBehavior">
+      <enum>QAbstractItemView::SelectRows</enum>
+     </property>
+    </widget>
    </item>
    <item>
     <widget class="ctkSearchBox" name="m_LabelSearchBox">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
     </widget>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>ctkSearchBox</class>
    <extends>QLineEdit</extends>
    <header location="global">ctkSearchBox.h</header>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>
diff --git a/Modules/SegmentationUI/Qmitk/QmitkSearchLabelDialog.cpp b/Modules/SegmentationUI/Qmitk/QmitkSearchLabelDialog.cpp
deleted file mode 100644
index 0b94020314..0000000000
--- a/Modules/SegmentationUI/Qmitk/QmitkSearchLabelDialog.cpp
+++ /dev/null
@@ -1,74 +0,0 @@
-/*============================================================================
-
-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 "QmitkSearchLabelDialog.h"
-
-#include <itkRGBPixel.h>
-
-#include <QAbstractItemModel>
-#include <QColorDialog>
-#include <QStringListModel>
-#include <qlabel.h>
-#include <qlayout.h>
-#include <qlineedit.h>
-#include <qpushbutton.h>
-
-QmitkSearchLabelDialog::QmitkSearchLabelDialog(QWidget *parent, Qt::WindowFlags f) : QDialog(parent, f)
-{
-  m_Controls = new Ui::QmitkSearchLabelDialogGUI();
-  m_Controls->setupUi(this);
-
-  m_LabelIndex = -1;
-
-  QStringList completionList;
-  completionList << "";
-  m_Completer = new QCompleter(completionList);
-  m_Completer->setCaseSensitivity(Qt::CaseInsensitive);
-  m_Controls->m_LabelName->setCompleter(m_Completer);
-
-  connect(m_Completer, SIGNAL(activated(const QString &)), this, SLOT(OnLabelCompleterChanged(const QString &)));
-  connect(m_Controls->m_pbCancel, SIGNAL(clicked()), this, SLOT(reject()));
-  connect(m_Controls->m_pbAccept, SIGNAL(clicked()), this, SLOT(accept()));
-
-  m_Controls->m_LabelName->setFocus();
-}
-
-QmitkSearchLabelDialog::~QmitkSearchLabelDialog()
-{
-}
-
-int QmitkSearchLabelDialog::GetLabelSetWidgetTableIndex()
-{
-  return m_LabelIndex;
-}
-
-QString QmitkSearchLabelDialog::GetLabelSetWidgetTableCompleteWord()
-{
-  return m_CompleteWord;
-}
-
-void QmitkSearchLabelDialog::SetLabelSuggestionList(QStringList stringList)
-{
-  m_LabelList = stringList;
-  QStringListModel *completeModel = static_cast<QStringListModel *>(m_Completer->model());
-  completeModel->setStringList(m_LabelList);
-}
-
-void QmitkSearchLabelDialog::OnLabelCompleterChanged(const QString &completedWord)
-{
-  if (m_LabelList.contains(completedWord))
-  {
-    m_LabelIndex = m_LabelList.indexOf(completedWord);
-    m_CompleteWord = completedWord;
-    //    emit(goToLabel(m_LabelIndex));
-  }
-}
diff --git a/Modules/SegmentationUI/Qmitk/QmitkSearchLabelDialog.h b/Modules/SegmentationUI/Qmitk/QmitkSearchLabelDialog.h
deleted file mode 100644
index 670a319b96..0000000000
--- a/Modules/SegmentationUI/Qmitk/QmitkSearchLabelDialog.h
+++ /dev/null
@@ -1,59 +0,0 @@
-/*============================================================================
-
-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 QmitkSearchLabelDialog_h_Included
-#define QmitkSearchLabelDialog_h_Included
-
-#include "MitkSegmentationUIExports.h"
-
-#include <ui_QmitkSearchLabelDialogGUI.h>
-
-#include <QCompleter>
-#include <QDialog>
-
-class MITKSEGMENTATIONUI_EXPORT QmitkSearchLabelDialog : public QDialog
-{
-  Q_OBJECT
-
-public:
-  QmitkSearchLabelDialog(QWidget *parent = nullptr, Qt::WindowFlags f = nullptr);
-  ~QmitkSearchLabelDialog() override;
-
-  int GetLabelSetWidgetTableIndex();
-
-  QString GetLabelSetWidgetTableCompleteWord();
-
-  void SetLabelSuggestionList(QStringList stringList);
-
-signals:
-
-  void goToLabel(int);
-
-public slots:
-
-protected slots:
-
-  void OnLabelCompleterChanged(const QString &completedWord);
-
-protected:
-  Ui::QmitkSearchLabelDialogGUI *m_Controls;
-
-  QCompleter *m_Completer;
-
-  QStringList m_LabelList;
-
-  int m_LabelIndex;
-
-  QString m_CompleteWord;
-};
-
-#endif
diff --git a/Modules/SegmentationUI/Qmitk/QmitkSearchLabelDialogGUI.ui b/Modules/SegmentationUI/Qmitk/QmitkSearchLabelDialogGUI.ui
deleted file mode 100644
index f665e53128..0000000000
--- a/Modules/SegmentationUI/Qmitk/QmitkSearchLabelDialogGUI.ui
+++ /dev/null
@@ -1,70 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<ui version="4.0">
- <class>QmitkSearchLabelDialogGUI</class>
- <widget class="QDialog" name="QmitkSearchLabelDialogGUI">
-  <property name="geometry">
-   <rect>
-    <x>0</x>
-    <y>0</y>
-    <width>259</width>
-    <height>71</height>
-   </rect>
-  </property>
-  <property name="sizePolicy">
-   <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
-    <horstretch>0</horstretch>
-    <verstretch>0</verstretch>
-   </sizepolicy>
-  </property>
-  <property name="windowTitle">
-   <string>Search Label</string>
-  </property>
-  <property name="autoFillBackground">
-   <bool>false</bool>
-  </property>
-  <property name="sizeGripEnabled">
-   <bool>false</bool>
-  </property>
-  <property name="modal">
-   <bool>true</bool>
-  </property>
-  <layout class="QVBoxLayout" name="verticalLayout">
-   <item>
-    <widget class="QLineEdit" name="m_LabelName"/>
-   </item>
-   <item>
-    <layout class="QHBoxLayout" name="horizontalLayout_4">
-     <item>
-      <spacer name="horizontalSpacer_2">
-       <property name="orientation">
-        <enum>Qt::Horizontal</enum>
-       </property>
-       <property name="sizeHint" stdset="0">
-        <size>
-         <width>40</width>
-         <height>20</height>
-        </size>
-       </property>
-      </spacer>
-     </item>
-     <item>
-      <widget class="QPushButton" name="m_pbAccept">
-       <property name="text">
-        <string>Accept</string>
-       </property>
-      </widget>
-     </item>
-     <item>
-      <widget class="QPushButton" name="m_pbCancel">
-       <property name="text">
-        <string>Cancel</string>
-       </property>
-      </widget>
-     </item>
-    </layout>
-   </item>
-  </layout>
- </widget>
- <resources/>
- <connections/>
-</ui>
diff --git a/Modules/SegmentationUI/files.cmake b/Modules/SegmentationUI/files.cmake
index 63a50b2923..b3693314f8 100644
--- a/Modules/SegmentationUI/files.cmake
+++ b/Modules/SegmentationUI/files.cmake
@@ -1,97 +1,94 @@
 set( CPP_FILES
 Qmitk/QmitkAdaptiveRegionGrowingToolGUI.cpp
 Qmitk/QmitkAutoSegmentationToolGUIBase.cpp
 Qmitk/QmitkAutoMLSegmentationToolGUIBase.cpp
 Qmitk/QmitkBinaryThresholdToolGUIBase.cpp
 Qmitk/QmitkBinaryThresholdToolGUI.cpp
 Qmitk/QmitkBinaryThresholdULToolGUI.cpp
 Qmitk/QmitkCalculateGrayValueStatisticsToolGUI.cpp
 Qmitk/QmitkConfirmSegmentationDialog.cpp
 Qmitk/QmitkCopyToClipBoardDialog.cpp
 Qmitk/QmitkDrawPaintbrushToolGUI.cpp
 Qmitk/QmitkErasePaintbrushToolGUI.cpp
 Qmitk/QmitkFastMarchingToolGUIBase.cpp
 Qmitk/QmitkFastMarchingTool3DGUI.cpp
 Qmitk/QmitkFastMarchingToolGUI.cpp
 Qmitk/QmitkLiveWireTool2DGUI.cpp
 Qmitk/QmitkNewSegmentationDialog.cpp
 Qmitk/QmitkOtsuTool3DGUI.cpp
 Qmitk/QmitkPaintbrushToolGUI.cpp
 Qmitk/QmitkPickingToolGUI.cpp
 Qmitk/QmitkPixelManipulationToolGUI.cpp
 Qmitk/QmitkSlicesInterpolator.cpp
 Qmitk/QmitkToolGUI.cpp
 Qmitk/QmitkToolGUIArea.cpp
 Qmitk/QmitkToolSelectionBox.cpp
 Qmitk/QmitkWatershedToolGUI.cpp
 Qmitk/QmitknnUNetToolGUI.cpp
 Qmitk/QmitknnUNetToolSlots.cpp
 #Added from ML
 Qmitk/QmitkLabelSetWidget.cpp
 Qmitk/QmitkSurfaceStampWidget.cpp
 Qmitk/QmitkMaskStampWidget.cpp
 Qmitk/QmitkSliceBasedInterpolatorWidget.cpp
 Qmitk/QmitkSurfaceBasedInterpolatorWidget.cpp
-Qmitk/QmitkSearchLabelDialog.cpp
 Qmitk/QmitkSimpleLabelSetListWidget.cpp
 )
 
 set(MOC_H_FILES
 Qmitk/QmitkAdaptiveRegionGrowingToolGUI.h
 Qmitk/QmitkAutoSegmentationToolGUIBase.h
 Qmitk/QmitkAutoMLSegmentationToolGUIBase.h
 Qmitk/QmitkBinaryThresholdToolGUIBase.h
 Qmitk/QmitkBinaryThresholdToolGUI.h
 Qmitk/QmitkBinaryThresholdULToolGUI.h
 Qmitk/QmitkCalculateGrayValueStatisticsToolGUI.h
 Qmitk/QmitkConfirmSegmentationDialog.h
 Qmitk/QmitkCopyToClipBoardDialog.h
 Qmitk/QmitkDrawPaintbrushToolGUI.h
 Qmitk/QmitkErasePaintbrushToolGUI.h
 Qmitk/QmitkFastMarchingToolGUIBase.h
 Qmitk/QmitkFastMarchingTool3DGUI.h
 Qmitk/QmitkFastMarchingToolGUI.h
 Qmitk/QmitkLiveWireTool2DGUI.h
 Qmitk/QmitkNewSegmentationDialog.h
 Qmitk/QmitkOtsuTool3DGUI.h
 Qmitk/QmitkPaintbrushToolGUI.h
 Qmitk/QmitkPickingToolGUI.h
 Qmitk/QmitkPixelManipulationToolGUI.h
 Qmitk/QmitkSlicesInterpolator.h
 Qmitk/QmitkToolGUI.h
 Qmitk/QmitkToolGUIArea.h
 Qmitk/QmitkToolSelectionBox.h
 Qmitk/QmitkWatershedToolGUI.h
 Qmitk/QmitknnUNetToolGUI.h
 Qmitk/QmitknnUNetGPU.h
 Qmitk/QmitknnUNetEnsembleLayout.h
 Qmitk/QmitknnUNetFolderParser.h
 #Added from ML
 Qmitk/QmitkLabelSetWidget.h
 Qmitk/QmitkSurfaceStampWidget.h
 Qmitk/QmitkMaskStampWidget.h
 Qmitk/QmitkSliceBasedInterpolatorWidget.h
 Qmitk/QmitkSurfaceBasedInterpolatorWidget.h
-Qmitk/QmitkSearchLabelDialog.h
 Qmitk/QmitkSimpleLabelSetListWidget.h
 )
 
 set(UI_FILES
 Qmitk/QmitkAdaptiveRegionGrowingToolGUIControls.ui
 Qmitk/QmitkConfirmSegmentationDialog.ui
 Qmitk/QmitkOtsuToolWidgetControls.ui
 Qmitk/QmitkLiveWireTool2DGUIControls.ui
 Qmitk/QmitkWatershedToolGUIControls.ui
 #Added from ML
 Qmitk/QmitkLabelSetWidgetControls.ui
 Qmitk/QmitkSurfaceStampWidgetGUIControls.ui
 Qmitk/QmitkMaskStampWidgetGUIControls.ui
 Qmitk/QmitkSliceBasedInterpolatorWidgetGUIControls.ui
 Qmitk/QmitkSurfaceBasedInterpolatorWidgetGUIControls.ui
-Qmitk/QmitkSearchLabelDialogGUI.ui
 Qmitk/QmitknnUNetToolGUIControls.ui
 )
 
 set(QRC_FILES
   resources/SegmentationUI.qrc
 )
diff --git a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.cpp b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.cpp
index 05ffb06d01..ba0e40eef3 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.cpp
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.cpp
@@ -1,983 +1,987 @@
 /*============================================================================
 
 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 "QmitkSegmentationView.h"
 #include "mitkPluginActivator.h"
 
 // blueberry
 #include <berryIWorkbenchPage.h>
 
 // mitk
 #include <mitkApplicationCursor.h>
 #include <mitkCameraController.h>
 #include <mitkImageTimeSelector.h>
 #include <mitkLabelSetImage.h>
 #include <mitkLabelSetImageHelper.h>
 #include <mitkNodePredicateSubGeometry.h>
 #include <mitkSegmentationObjectFactory.h>
 #include <mitkSegTool2D.h>
 #include <mitkStatusBar.h>
 #include <mitkToolManagerProvider.h>
 #include <mitkVtkResliceInterpolationProperty.h>
 #include <mitkWorkbenchUtil.h>
 
 // Qmitk
 #include <QmitkRenderWindow.h>
 #include <QmitkSegmentationOrganNamesHandling.cpp>
 
 // us
 #include <usModuleResource.h>
 #include <usModuleResourceStream.h>
 
 // Qt
 #include <QMessageBox>
 #include <QShortcut>
 
 #include <regex>
 
 const std::string QmitkSegmentationView::VIEW_ID = "org.mitk.views.segmentation";
 
 QmitkSegmentationView::QmitkSegmentationView()
   : m_Parent(nullptr)
   , m_Controls(nullptr)
   , m_RenderWindowPart(nullptr)
   , m_ToolManager(nullptr)
   , m_ReferenceNode(nullptr)
   , m_WorkingNode(nullptr)
   , m_DrawOutline(true)
   , m_SelectionMode(false)
   , m_MouseCursorSet(false)
 {
   auto isImage = mitk::TNodePredicateDataType<mitk::Image>::New();
   auto isDwi = mitk::NodePredicateDataType::New("DiffusionImage");
   auto isDti = mitk::NodePredicateDataType::New("TensorImage");
   auto isOdf = mitk::NodePredicateDataType::New("OdfImage");
   auto isSegment = mitk::NodePredicateDataType::New("Segment");
 
   auto validImages = mitk::NodePredicateOr::New();
   validImages->AddPredicate(mitk::NodePredicateAnd::New(isImage, mitk::NodePredicateNot::New(isSegment)));
   validImages->AddPredicate(isDwi);
   validImages->AddPredicate(isDti);
   validImages->AddPredicate(isOdf);
 
   auto isBinary = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
   auto isMask = mitk::NodePredicateAnd::New(isBinary, isImage);
 
   auto validSegmentations = mitk::NodePredicateOr::New();
   validSegmentations->AddPredicate(mitk::TNodePredicateDataType<mitk::LabelSetImage>::New());
   validSegmentations->AddPredicate(isMask);
 
   m_SegmentationPredicate = mitk::NodePredicateAnd::New();
   m_SegmentationPredicate->AddPredicate(validSegmentations);
   m_SegmentationPredicate->AddPredicate(mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object")));
   m_SegmentationPredicate->AddPredicate(mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("hidden object")));
 
   m_ReferencePredicate = mitk::NodePredicateAnd::New();
   m_ReferencePredicate->AddPredicate(validImages);
   m_ReferencePredicate->AddPredicate(mitk::NodePredicateNot::New(m_SegmentationPredicate));
   m_ReferencePredicate->AddPredicate(mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object")));
   m_ReferencePredicate->AddPredicate(mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("hidden object")));
 }
 
 QmitkSegmentationView::~QmitkSegmentationView()
 {
   if (nullptr != m_Controls)
   {
     OnLooseLabelSetConnection();
 
     // deactivate all tools
     m_ToolManager->ActivateTool(-1);
 
     // removing all observers
     for (NodeTagMapType::iterator dataIter = m_WorkingDataObserverTags.begin(); dataIter != m_WorkingDataObserverTags.end(); ++dataIter)
     {
       (*dataIter).first->GetProperty("visible")->RemoveObserver((*dataIter).second);
     }
     m_WorkingDataObserverTags.clear();
 
     mitk::RenderingManager::GetInstance()->RemoveObserver(m_RenderingManagerObserverTag);
 
     ctkPluginContext* context = mitk::PluginActivator::getContext();
     ctkServiceReference ppmRef = context->getServiceReference<mitk::PlanePositionManagerService>();
     mitk::PlanePositionManagerService* service = context->getService<mitk::PlanePositionManagerService>(ppmRef);
     service->RemoveAllPlanePositions();
     context->ungetService(ppmRef);
 
     m_ToolManager->SetReferenceData(nullptr);
     m_ToolManager->SetWorkingData(nullptr);
   }
 
   delete m_Controls;
 }
 
 /**********************************************************************/
 /* private Q_SLOTS                                                    */
 /**********************************************************************/
 void QmitkSegmentationView::OnReferenceSelectionChanged(QList<mitk::DataNode::Pointer> nodes)
 {
   m_ToolManager->ActivateTool(-1);
 
   if (nodes.empty())
   {
     m_Controls->workingNodeSelector->SetNodePredicate(m_SegmentationPredicate);
     m_ReferenceNode = nullptr;
     m_ToolManager->SetReferenceData(m_ReferenceNode);
     this->UpdateGUI();
     return;
   }
 
   m_ReferenceNode = nodes.first();
   m_ToolManager->SetReferenceData(m_ReferenceNode);
   if (m_ReferenceNode.IsNotNull())
   {
     // set a predicate such that a segmentation fits the selected reference image geometry
     auto segPredicate = mitk::NodePredicateAnd::New(m_SegmentationPredicate.GetPointer(),
       mitk::NodePredicateSubGeometry::New(m_ReferenceNode->GetData()->GetGeometry()));
 
     m_Controls->workingNodeSelector->SetNodePredicate(segPredicate);
 
     if (m_SelectionMode)
     {
       // hide all image nodes to later show only the automatically selected ones
       mitk::DataStorage::SetOfObjects::ConstPointer imageNodes =
         this->GetDataStorage()->GetSubset(m_ReferencePredicate);
       for (mitk::DataStorage::SetOfObjects::const_iterator iter = imageNodes->begin(); iter != imageNodes->end(); ++iter)
       {
         (*iter)->SetVisibility(false);
       }
     }
     m_ReferenceNode->SetVisibility(true);
   }
 
   this->UpdateGUI();
 }
 
 void QmitkSegmentationView::OnSegmentationSelectionChanged(QList<mitk::DataNode::Pointer> nodes)
 {
   m_ToolManager->ActivateTool(-1);
 
   // Remove observer if one was registered
   auto finding = m_WorkingDataObserverTags.find(m_WorkingNode);
   if (finding != m_WorkingDataObserverTags.end())
   {
     m_WorkingNode->GetProperty("visible")->RemoveObserver(m_WorkingDataObserverTags[m_WorkingNode]);
     m_WorkingDataObserverTags.erase(m_WorkingNode);
   }
 
   if (nodes.empty())
   {
     m_WorkingNode = nullptr;
     m_ToolManager->SetWorkingData(m_WorkingNode);
     this->UpdateGUI();
     return;
   }
 
   if (m_ReferenceNode.IsNull())
   {
     this->UpdateGUI();
     return;
   }
 
   mitk::Image::ConstPointer referenceImage = dynamic_cast<mitk::Image*>(m_ReferenceNode->GetData());
   if (referenceImage.IsNull())
   {
     this->UpdateGUI();
     return;
   }
 
   m_WorkingNode = nodes.first();
   m_ToolManager->SetWorkingData(m_WorkingNode);
   if (m_WorkingNode.IsNotNull())
   {
     if (m_SelectionMode)
     {
       // hide all segmentation nodes to later show only the selected ones
       mitk::DataStorage::SetOfObjects::ConstPointer segmentationNodes =
         this->GetDataStorage()->GetSubset(m_SegmentationPredicate);
       for (mitk::DataStorage::SetOfObjects::const_iterator iter = segmentationNodes->begin(); iter != segmentationNodes->end(); ++iter)
       {
         (*iter)->SetVisibility(false);
       }
     }
     m_WorkingNode->SetVisibility(true);
 
     this->OnEstablishLabelSetConnection();
     m_Controls->labelSetWidget->ResetAllTableWidgetItems();
 
     auto command = itk::SimpleMemberCommand<QmitkSegmentationView>::New();
     command->SetCallbackFunction(this, &QmitkSegmentationView::ValidateSelectionInput);
     m_WorkingDataObserverTags.insert(std::pair<mitk::DataNode*, unsigned long>(m_WorkingNode,
       m_WorkingNode->GetProperty("visible")->AddObserver(itk::ModifiedEvent(), command)));
 
     this->InitializeRenderWindows(referenceImage->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, false);
   }
 
   this->UpdateGUI();
 }
 
 void QmitkSegmentationView::OnVisibilityShortcutActivated()
 {
   if (m_WorkingNode.IsNull())
   {
     return;
   }
 
   bool isVisible = false;
   m_WorkingNode->GetBoolProperty("visible", isVisible);
   m_WorkingNode->SetVisibility(!isVisible);
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkSegmentationView::OnLabelToggleShortcutActivated()
 {
   if (m_WorkingNode.IsNull())
   {
     return;
   }
 
   auto workingImage = dynamic_cast<mitk::LabelSetImage*>(m_WorkingNode->GetData());
   if (nullptr == workingImage)
   {
     return;
   }
 
   this->WaitCursorOn();
   workingImage->GetActiveLabelSet()->SetNextActiveLabel();
   workingImage->Modified();
   this->WaitCursorOff();
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkSegmentationView::OnNewSegmentation()
 {
   m_ToolManager->ActivateTool(-1);
 
   if (m_ReferenceNode.IsNull())
   {
     MITK_ERROR << "'Create new segmentation' button should never be clickable unless a reference image is selected.";
     return;
   }
 
   mitk::Image::ConstPointer referenceImage = dynamic_cast<mitk::Image*>(m_ReferenceNode->GetData());
   if (referenceImage.IsNull())
   {
     QMessageBox::information(
       m_Parent, "New segmentation", "Please load and select an image before starting some action.");
     return;
   }
 
   if (referenceImage->GetDimension() <= 1)
   {
     QMessageBox::information(
       m_Parent, "New segmentation", "Segmentation is currently not supported for 2D images");
     return;
   }
 
   const auto currentTimePoint = mitk::RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint();
   unsigned int imageTimeStep = 0;
   if (referenceImage->GetTimeGeometry()->IsValidTimePoint(currentTimePoint))
   {
     imageTimeStep = referenceImage->GetTimeGeometry()->TimePointToTimeStep(currentTimePoint);
   }
 
   auto segTemplateImage = referenceImage;
   if (referenceImage->GetDimension() > 3)
   {
     auto result = QMessageBox::question(m_Parent,
       tr("Create a static or dynamic segmentation?"),
       tr("The selected image has multiple time steps.\n\nDo you want to create a static "
         "segmentation that is identical for all time steps or do you want to create a "
         "dynamic segmentation to segment individual time steps?"),
       tr("Create static segmentation"), tr("Create dynamic segmentation"),
       QString(), 0, 0);
     if (result == 0)
     {
       auto selector = mitk::ImageTimeSelector::New();
       selector->SetInput(referenceImage);
       selector->SetTimeNr(0);
       selector->Update();
 
       const auto refTimeGeometry = referenceImage->GetTimeGeometry();
       auto newTimeGeometry = mitk::ProportionalTimeGeometry::New();
       newTimeGeometry->SetFirstTimePoint(refTimeGeometry->GetMinimumTimePoint());
       newTimeGeometry->SetStepDuration(refTimeGeometry->GetMaximumTimePoint() - refTimeGeometry->GetMinimumTimePoint());
 
       mitk::Image::Pointer newImage = selector->GetOutput();
       newTimeGeometry->SetTimeStepGeometry(referenceImage->GetGeometry(imageTimeStep), 0);
       newImage->SetTimeGeometry(newTimeGeometry);
       segTemplateImage = newImage;
     }
   }
 
   mitk::DataNode::Pointer newSegmentationNode;
   try
   {
     this->WaitCursorOn();
     newSegmentationNode = mitk::LabelSetImageHelper::CreateNewSegmentationNode(m_ReferenceNode, segTemplateImage);
     this->WaitCursorOff();
   }
   catch (mitk::Exception& e)
   {
     this->WaitCursorOff();
     MITK_ERROR << "Exception caught: " << e.GetDescription();
     QMessageBox::warning(m_Parent, "New segmentation", "Could not create a new segmentation.");
     return;
   }
 
   auto newLabelSetImage = dynamic_cast<mitk::LabelSetImage*>(newSegmentationNode->GetData());
   if (nullptr == newLabelSetImage)
   {
     // something went wrong
     return;
   }
 
   mitk::Label::Pointer newLabel = mitk::LabelSetImageHelper::CreateNewLabel(newLabelSetImage);
   newLabelSetImage->GetActiveLabelSet()->AddLabel(newLabel);
 
   if (!this->GetDataStorage()->Exists(newSegmentationNode))
   {
     this->GetDataStorage()->Add(newSegmentationNode, m_ReferenceNode);
   }
 
   if (m_ToolManager->GetWorkingData(0))
   {
     m_ToolManager->GetWorkingData(0)->SetSelected(false);
   }
 
   newSegmentationNode->SetSelected(true);
   m_Controls->workingNodeSelector->SetCurrentSelectedNode(newSegmentationNode);
 }
 
 void QmitkSegmentationView::OnManualTool2DSelected(int id)
 {
   this->ResetMouseCursor();
   mitk::StatusBar::GetInstance()->DisplayText("");
 
   if (id >= 0)
   {
     std::string text = "Active Tool: \"";
     text += m_ToolManager->GetToolById(id)->GetName();
     text += "\"";
     mitk::StatusBar::GetInstance()->DisplayText(text.c_str());
 
     us::ModuleResource resource = m_ToolManager->GetToolById(id)->GetCursorIconResource();
     this->SetMouseCursor(resource, 0, 0);
   }
 }
 
 void QmitkSegmentationView::OnShowMarkerNodes(bool state)
 {
   mitk::SegTool2D::Pointer manualSegmentationTool;
 
   unsigned int numberOfExistingTools = m_ToolManager->GetTools().size();
 
   for (unsigned int i = 0; i < numberOfExistingTools; i++)
   {
     manualSegmentationTool = dynamic_cast<mitk::SegTool2D*>(m_ToolManager->GetToolById(i));
     if (nullptr == manualSegmentationTool)
     {
       continue;
     }
 
     manualSegmentationTool->SetShowMarkerNodes(state);
   }
 }
 
 void QmitkSegmentationView::OnLayersChanged()
 {
   m_Controls->labelSetWidget->ResetAllTableWidgetItems();
 }
 
 void QmitkSegmentationView::OnLabelsChanged()
 {
   m_Controls->labelSetWidget->ResetAllTableWidgetItems();
 }
 
 void QmitkSegmentationView::OnShowLabelTable(bool value)
 {
   m_Controls->labelSetWidget->setVisible(value);
 }
 
 void QmitkSegmentationView::OnGoToLabel(const mitk::Point3D& pos)
 {
   if (m_RenderWindowPart)
   {
     m_RenderWindowPart->SetSelectedPosition(pos);
   }
 }
 
 void QmitkSegmentationView::OnLabelSetWidgetReset()
 {
   this->UpdateInterpolatorWidget();
 }
 
 /**********************************************************************/
 /* private                                                            */
 /**********************************************************************/
 void QmitkSegmentationView::CreateQtPartControl(QWidget* parent)
 {
    m_Parent = parent;
 
    m_Controls = new Ui::QmitkSegmentationViewControls;
    m_Controls->setupUi(parent);
 
    // *------------------------
    // * SHORTCUTS
    // *------------------------
    QShortcut* visibilityShortcut = new QShortcut(QKeySequence("CTRL+H"), parent);
    connect(visibilityShortcut, &QShortcut::activated, this, &QmitkSegmentationView::OnVisibilityShortcutActivated);
    QShortcut* labelToggleShortcut = new QShortcut(QKeySequence("CTRL+L"), parent);
    connect(labelToggleShortcut, &QShortcut::activated, this, &QmitkSegmentationView::OnLabelToggleShortcutActivated);
 
    // *------------------------
    // * DATA SELECTION WIDGETS
    // *------------------------
    m_Controls->referenceNodeSelector->SetDataStorage(GetDataStorage());
    m_Controls->referenceNodeSelector->SetNodePredicate(m_ReferencePredicate);
    m_Controls->referenceNodeSelector->SetInvalidInfo("Select an image");
    m_Controls->referenceNodeSelector->SetPopUpTitel("Select an image");
    m_Controls->referenceNodeSelector->SetPopUpHint("Select an image that should be used to define the geometry and bounds of the segmentation.");
 
    m_Controls->workingNodeSelector->SetDataStorage(GetDataStorage());
    m_Controls->workingNodeSelector->SetNodePredicate(m_SegmentationPredicate);
    m_Controls->workingNodeSelector->SetInvalidInfo("Select a segmentation");
    m_Controls->workingNodeSelector->SetPopUpTitel("Select a segmentation");
    m_Controls->workingNodeSelector->SetPopUpHint("Select a segmentation that should be modified. Only segmentation with the same geometry and within the bounds of the reference image are selected.");
 
    connect(m_Controls->referenceNodeSelector, &QmitkAbstractNodeSelectionWidget::CurrentSelectionChanged,
            this, &QmitkSegmentationView::OnReferenceSelectionChanged);
    connect(m_Controls->workingNodeSelector, &QmitkAbstractNodeSelectionWidget::CurrentSelectionChanged,
            this, &QmitkSegmentationView::OnSegmentationSelectionChanged);
 
    // *------------------------
    // * TOOLMANAGER
    // *------------------------
    m_ToolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager();
    m_ToolManager->SetDataStorage(*(this->GetDataStorage()));
    m_ToolManager->InitializeTools();
 
    QString segTools2D = tr("Add Subtract Fill Erase Paint Wipe 'Region Growing' 'Live Wire'");
    QString segTools3D = tr("Threshold 'UL Threshold' Otsu 'Region Growing 3D' Picking");
 #ifdef __linux__
    segTools3D.append(" nnUNet"); // plugin not enabled for MacOS / Windows
 #endif
    std::regex extSegTool2DRegEx("SegTool2D$");
    std::regex extSegTool3DRegEx("SegTool3D$");
 
    auto tools = m_ToolManager->GetTools();
    for (const auto &tool : tools)
    {
      if (std::regex_search(tool->GetNameOfClass(), extSegTool2DRegEx))
      {
        segTools2D.append(QString(" '%1'").arg(tool->GetName()));
      }
      else if (std::regex_search(tool->GetNameOfClass(), extSegTool3DRegEx))
      {
        segTools3D.append(QString(" '%1'").arg(tool->GetName()));
      }
    }
 
    // setup 2D tools
    m_Controls->toolSelectionBox2D->SetToolManager(*m_ToolManager);
    m_Controls->toolSelectionBox2D->SetGenerateAccelerators(true);
    m_Controls->toolSelectionBox2D->SetToolGUIArea(m_Controls->toolGUIArea2D);
    m_Controls->toolSelectionBox2D->SetDisplayedToolGroups(segTools2D.toStdString());
    m_Controls->toolSelectionBox2D->SetLayoutColumns(3);
    m_Controls->toolSelectionBox2D->SetEnabledMode(
      QmitkToolSelectionBox::EnabledWithReferenceAndWorkingDataVisible);
    connect(m_Controls->toolSelectionBox2D, &QmitkToolSelectionBox::ToolSelected,
            this, &QmitkSegmentationView::OnManualTool2DSelected);
 
    // setup 3D Tools
    m_Controls->toolSelectionBox3D->SetToolManager(*m_ToolManager);
    m_Controls->toolSelectionBox3D->SetGenerateAccelerators(true);
    m_Controls->toolSelectionBox3D->SetToolGUIArea(m_Controls->toolGUIArea3D);
    m_Controls->toolSelectionBox3D->SetDisplayedToolGroups(segTools3D.toStdString());
    m_Controls->toolSelectionBox3D->SetLayoutColumns(3);
    m_Controls->toolSelectionBox3D->SetEnabledMode(
      QmitkToolSelectionBox::EnabledWithReferenceAndWorkingDataVisible);
 
    m_Controls->slicesInterpolator->SetDataStorage(this->GetDataStorage());
 
    // create general signal / slot connections
    connect(m_Controls->newSegmentationButton, &QToolButton::clicked, this, &QmitkSegmentationView::OnNewSegmentation);
    connect(m_Controls->slicesInterpolator, &QmitkSlicesInterpolator::SignalShowMarkerNodes, this, &QmitkSegmentationView::OnShowMarkerNodes);
 
    connect(m_Controls->layersWidget, &QmitkLayersWidget::LayersChanged, this, &QmitkSegmentationView::OnLayersChanged);
    connect(m_Controls->labelsWidget, &QmitkLabelsWidget::LabelsChanged, this, &QmitkSegmentationView::OnLabelsChanged);
    connect(m_Controls->labelsWidget, &QmitkLabelsWidget::ShowLabelTable, this, &QmitkSegmentationView::OnShowLabelTable);
 
    // *------------------------
    // * LABELSETWIDGET
    // *------------------------
    connect(m_Controls->labelSetWidget, &QmitkLabelSetWidget::goToLabel, this, &QmitkSegmentationView::OnGoToLabel);
    connect(m_Controls->labelSetWidget, &QmitkLabelSetWidget::LabelSetWidgetReset, this, &QmitkSegmentationView::OnLabelSetWidgetReset);
 
    m_Controls->labelSetWidget->SetDataStorage(this->GetDataStorage());
    m_Controls->labelSetWidget->SetOrganColors(mitk::OrganNamesHandling::GetDefaultOrganColorString());
    m_Controls->labelSetWidget->hide();
 
    auto command = itk::SimpleMemberCommand<QmitkSegmentationView>::New();
    command->SetCallbackFunction(this, &QmitkSegmentationView::ValidateSelectionInput);
    m_RenderingManagerObserverTag =
      mitk::RenderingManager::GetInstance()->AddObserver(mitk::RenderingManagerViewsInitializedEvent(), command);
 
    m_RenderWindowPart = this->GetRenderWindowPart();
    if (nullptr != m_RenderWindowPart)
    {
      this->RenderWindowPartActivated(m_RenderWindowPart);
    }
 
    // Make sure the GUI notices if appropriate data is already present on creation.
    // Should be done last, if everything else is configured because it triggers the autoselection of data.
    m_Controls->referenceNodeSelector->SetAutoSelectNewNodes(true);
    m_Controls->workingNodeSelector->SetAutoSelectNewNodes(true);
 
    this->UpdateGUI();
 }
 
 void QmitkSegmentationView::RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart)
 {
   if (m_RenderWindowPart != renderWindowPart)
   {
     m_RenderWindowPart = renderWindowPart;
   }
 
   if (nullptr != m_Parent)
   {
     m_Parent->setEnabled(true);
   }
 
   if (nullptr == m_Controls)
   {
     return;
   }
 
   // tell the interpolation about tool manager, data storage and render window part
   if (nullptr != m_RenderWindowPart)
   {
     QList<mitk::SliceNavigationController*> controllers;
     controllers.push_back(m_RenderWindowPart->GetQmitkRenderWindow("axial")->GetSliceNavigationController());
     controllers.push_back(m_RenderWindowPart->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController());
     controllers.push_back(m_RenderWindowPart->GetQmitkRenderWindow("coronal")->GetSliceNavigationController());
     m_Controls->slicesInterpolator->Initialize(m_ToolManager, controllers);
   }
 }
 
 void QmitkSegmentationView::RenderWindowPartDeactivated(mitk::IRenderWindowPart* /*renderWindowPart*/)
 {
   m_RenderWindowPart = nullptr;
   if (nullptr != m_Parent)
   {
     m_Parent->setEnabled(false);
   }
 }
 
 void QmitkSegmentationView::OnPreferencesChanged(const berry::IBerryPreferences* prefs)
 {
   if (nullptr != m_Controls)
   {
     bool slimView = prefs->GetBool("slim view", false);
     m_Controls->toolSelectionBox2D->SetShowNames(!slimView);
     m_Controls->toolSelectionBox3D->SetShowNames(!slimView);
   }
 
   m_DrawOutline = prefs->GetBool("draw outline", true);
   m_SelectionMode = prefs->GetBool("selection mode", false);
 
   this->ApplyDisplayOptions();
 }
 
 void QmitkSegmentationView::NodeAdded(const mitk::DataNode* node)
 {
   if (m_SegmentationPredicate->CheckNode(node))
   {
     this->ApplyDisplayOptions(const_cast<mitk::DataNode*>(node));
   }
 }
 
 void QmitkSegmentationView::NodeRemoved(const mitk::DataNode* node)
 {
   if (!m_SegmentationPredicate->CheckNode(node))
   {
     return;
   }
 
   // remove all possible contour markers of the segmentation
   mitk::DataStorage::SetOfObjects::ConstPointer allContourMarkers = this->GetDataStorage()->GetDerivations(
     node, mitk::NodePredicateProperty::New("isContourMarker", mitk::BoolProperty::New(true)));
 
   ctkPluginContext* context = mitk::PluginActivator::getContext();
   ctkServiceReference ppmRef = context->getServiceReference<mitk::PlanePositionManagerService>();
   mitk::PlanePositionManagerService* service = context->getService<mitk::PlanePositionManagerService>(ppmRef);
 
   for (mitk::DataStorage::SetOfObjects::ConstIterator it = allContourMarkers->Begin(); it != allContourMarkers->End(); ++it)
   {
     std::string nodeName = node->GetName();
     unsigned int t = nodeName.find_last_of(" ");
     unsigned int id = atof(nodeName.substr(t + 1).c_str()) - 1;
 
     service->RemovePlanePosition(id);
 
     this->GetDataStorage()->Remove(it->Value());
   }
 
   context->ungetService(ppmRef);
   service = nullptr;
 
   mitk::Image* image = dynamic_cast<mitk::Image*>(node->GetData());
   mitk::SurfaceInterpolationController::GetInstance()->RemoveInterpolationSession(image);
 }
 
 void QmitkSegmentationView::OnEstablishLabelSetConnection()
 {
   if (m_WorkingNode.IsNull())
   {
     return;
   }
 
   auto workingImage = dynamic_cast<mitk::LabelSetImage*>(m_WorkingNode->GetData());
   if (nullptr == workingImage)
   {
     return;
   }
 
   workingImage->GetActiveLabelSet()->AddLabelEvent += mitk::MessageDelegate<QmitkLabelSetWidget>(
     m_Controls->labelSetWidget, &QmitkLabelSetWidget::ResetAllTableWidgetItems);
   workingImage->GetActiveLabelSet()->RemoveLabelEvent += mitk::MessageDelegate<QmitkLabelSetWidget>(
     m_Controls->labelSetWidget, &QmitkLabelSetWidget::ResetAllTableWidgetItems);
   workingImage->GetActiveLabelSet()->ModifyLabelEvent += mitk::MessageDelegate<QmitkLabelSetWidget>(
     m_Controls->labelSetWidget, &QmitkLabelSetWidget::UpdateAllTableWidgetItems);
   workingImage->GetActiveLabelSet()->AllLabelsModifiedEvent += mitk::MessageDelegate<QmitkLabelSetWidget>(
     m_Controls->labelSetWidget, &QmitkLabelSetWidget::UpdateAllTableWidgetItems);
   workingImage->GetActiveLabelSet()->ActiveLabelEvent += mitk::MessageDelegate1<QmitkLabelSetWidget,
     mitk::Label::PixelType>(m_Controls->labelSetWidget, &QmitkLabelSetWidget::SelectLabelByPixelValue);
 
   // Removed in T27851 to have a chance to react to AfterChangeLayerEvent. Did it brake something?
   // workingImage->BeforeChangeLayerEvent += mitk::MessageDelegate<QmitkMultiLabelSegmentationView>(
   //   this, &QmitkMultiLabelSegmentationView::OnLooseLabelSetConnection);
 
   workingImage->AfterChangeLayerEvent += mitk::MessageDelegate<QmitkSegmentationView>(
     this, &QmitkSegmentationView::UpdateGUI);
 }
 
 void QmitkSegmentationView::OnLooseLabelSetConnection()
 {
   if (m_WorkingNode.IsNull())
   {
     return;
   }
 
   auto workingImage = dynamic_cast<mitk::LabelSetImage*>(m_WorkingNode->GetData());
   if (nullptr == workingImage)
   {
     return;
   }
 
   // Reset LabelSetWidget Events
   workingImage->GetActiveLabelSet()->AddLabelEvent -= mitk::MessageDelegate<QmitkLabelSetWidget>(
     m_Controls->labelSetWidget, &QmitkLabelSetWidget::ResetAllTableWidgetItems);
   workingImage->GetActiveLabelSet()->RemoveLabelEvent -= mitk::MessageDelegate<QmitkLabelSetWidget>(
     m_Controls->labelSetWidget, &QmitkLabelSetWidget::ResetAllTableWidgetItems);
   workingImage->GetActiveLabelSet()->ModifyLabelEvent -= mitk::MessageDelegate<QmitkLabelSetWidget>(
     m_Controls->labelSetWidget, &QmitkLabelSetWidget::UpdateAllTableWidgetItems);
   workingImage->GetActiveLabelSet()->AllLabelsModifiedEvent -= mitk::MessageDelegate<QmitkLabelSetWidget>(
     m_Controls->labelSetWidget, &QmitkLabelSetWidget::UpdateAllTableWidgetItems);
   workingImage->GetActiveLabelSet()->ActiveLabelEvent -= mitk::MessageDelegate1<QmitkLabelSetWidget,
     mitk::Label::PixelType>(m_Controls->labelSetWidget, &QmitkLabelSetWidget::SelectLabelByPixelValue);
 
   // Removed in T27851 to have a chance to react to AfterChangeLayerEvent. Did it brake something?
   // workingImage->BeforeChangeLayerEvent -= mitk::MessageDelegate<QmitkMultiLabelSegmentationView>(
   //   this, &QmitkMultiLabelSegmentationView::OnLooseLabelSetConnection);
 
   workingImage->AfterChangeLayerEvent -= mitk::MessageDelegate<QmitkSegmentationView>(
     this, &QmitkSegmentationView::UpdateGUI);
 }
 
 void QmitkSegmentationView::ApplyDisplayOptions()
 {
   if (nullptr == m_Parent)
   {
     return;
   }
 
   if (nullptr == m_Controls)
   {
     return; // might happen on initialization (preferences loaded)
   }
 
   mitk::DataStorage::SetOfObjects::ConstPointer allImages = this->GetDataStorage()->GetSubset(m_SegmentationPredicate);
   for (mitk::DataStorage::SetOfObjects::const_iterator iter = allImages->begin(); iter != allImages->end(); ++iter)
   {
     this->ApplyDisplayOptions(*iter);
   }
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkSegmentationView::ApplyDisplayOptions(mitk::DataNode* node)
 {
   if (nullptr == node)
   {
     return;
   }
 
   auto labelSetImage = dynamic_cast<mitk::LabelSetImage*>(node->GetData());
   if (nullptr != labelSetImage)
   {
     // node is a multi label segmentation
     // its outline property can be set in the segmentation preference page
     node->SetProperty("labelset.contour.active", mitk::BoolProperty::New(m_DrawOutline));
 
     // force render window update to show outline
     node->GetData()->Modified();
   }
   else if (nullptr != node->GetData())
   {
     // node is a legacy binary segmentation
     bool isBinary = false;
     node->GetBoolProperty("binary", isBinary);
     if (isBinary)
     {
       node->SetProperty("outline binary", mitk::BoolProperty::New(m_DrawOutline));
       node->SetProperty("outline width", mitk::FloatProperty::New(2.0));
       // force render window update to show outline
       node->GetData()->Modified();
     }
   }
 }
 
 void QmitkSegmentationView::OnContourMarkerSelected(const mitk::DataNode* node)
 {
   QmitkRenderWindow* selectedRenderWindow = nullptr;
   auto* renderWindowPart = this->GetRenderWindowPart(mitk::WorkbenchUtil::OPEN);
   auto* axialRenderWindow = renderWindowPart->GetQmitkRenderWindow("axial");
   auto* sagittalRenderWindow = renderWindowPart->GetQmitkRenderWindow("sagittal");
   auto* coronalRenderWindow = renderWindowPart->GetQmitkRenderWindow("coronal");
   auto* threeDRenderWindow = renderWindowPart->GetQmitkRenderWindow("3d");
   bool PlanarFigureInitializedWindow = false;
 
   // find initialized renderwindow
   if (node->GetBoolProperty("PlanarFigureInitializedWindow",
     PlanarFigureInitializedWindow, axialRenderWindow->GetRenderer()))
   {
     selectedRenderWindow = axialRenderWindow;
   }
   if (!selectedRenderWindow && node->GetBoolProperty(
     "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
     sagittalRenderWindow->GetRenderer()))
   {
     selectedRenderWindow = sagittalRenderWindow;
   }
   if (!selectedRenderWindow && node->GetBoolProperty(
     "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
     coronalRenderWindow->GetRenderer()))
   {
     selectedRenderWindow = coronalRenderWindow;
   }
   if (!selectedRenderWindow && node->GetBoolProperty(
     "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
     threeDRenderWindow->GetRenderer()))
   {
     selectedRenderWindow = threeDRenderWindow;
   }
 
   // make node visible
   if (nullptr != selectedRenderWindow)
   {
     std::string nodeName = node->GetName();
     unsigned int t = nodeName.find_last_of(" ");
     unsigned int id = atof(nodeName.substr(t + 1).c_str()) - 1;
 
     ctkPluginContext* context = mitk::PluginActivator::getContext();
     ctkServiceReference ppmRef = context->getServiceReference<mitk::PlanePositionManagerService>();
     mitk::PlanePositionManagerService* service = context->getService<mitk::PlanePositionManagerService>(ppmRef);
     selectedRenderWindow->GetSliceNavigationController()->ExecuteOperation(service->GetPlanePosition(id));
     context->ungetService(ppmRef);
 
     selectedRenderWindow->GetRenderer()->GetCameraController()->Fit();
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 void QmitkSegmentationView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/, const QList<mitk::DataNode::Pointer>& nodes)
 {
   if (0 == nodes.size())
   {
     return;
   }
 
   std::string markerName = "Position";
   unsigned int numberOfNodes = nodes.size();
   std::string nodeName = nodes.at(0)->GetName();
   if ((numberOfNodes == 1) && (nodeName.find(markerName) == 0))
   {
     this->OnContourMarkerSelected(nodes.at(0));
     return;
   }
 }
 
 void QmitkSegmentationView::ResetMouseCursor()
 {
   if (m_MouseCursorSet)
   {
     mitk::ApplicationCursor::GetInstance()->PopCursor();
     m_MouseCursorSet = false;
   }
 }
 
 void QmitkSegmentationView::SetMouseCursor(const us::ModuleResource& resource, int hotspotX, int hotspotY)
 {
   // Remove previously set mouse cursor
   if (m_MouseCursorSet)
   {
     this->ResetMouseCursor();
   }
 
   if (resource)
   {
     us::ModuleResourceStream cursor(resource, std::ios::binary);
     mitk::ApplicationCursor::GetInstance()->PushCursor(cursor, hotspotX, hotspotY);
     m_MouseCursorSet = true;
   }
 }
 
 void QmitkSegmentationView::UpdateGUI()
 {
   mitk::DataNode* referenceNode = m_ToolManager->GetReferenceData(0);
   bool hasReferenceNode = referenceNode != nullptr;
 
   mitk::DataNode* workingNode = m_ToolManager->GetWorkingData(0);
   bool hasWorkingNode = workingNode != nullptr;
 
   m_Controls->newSegmentationButton->setEnabled(false);
 
   if (hasReferenceNode)
   {
     m_Controls->newSegmentationButton->setEnabled(true);
   }
 
   if (hasWorkingNode && hasReferenceNode)
   {
     int layer = -1;
     referenceNode->GetIntProperty("layer", layer);
     workingNode->SetIntProperty("layer", layer + 1);
   }
 
   this->UpdateInterpolatorWidget();
   m_Controls->layersWidget->UpdateGUI();
   m_Controls->labelsWidget->UpdateGUI();
 
   this->ValidateSelectionInput();
 }
 
 void QmitkSegmentationView::UpdateInterpolatorWidget()
 {
   m_Controls->slicesInterpolator->setEnabled(false);
 
   if (m_WorkingNode.IsNull())
   {
     return;
   }
 
   auto labelSetImage = dynamic_cast<mitk::LabelSetImage*>(m_WorkingNode->GetData());
   if (nullptr == labelSetImage)
   {
     return;
   }
 
   int numberOfLabels = labelSetImage->GetNumberOfLabels(labelSetImage->GetActiveLayer());
   if (2 == numberOfLabels) // fix for T27319: exterior is label 0, first label is label 1
   {
     m_Controls->interpolatorWarningLabel->hide();
     m_Controls->slicesInterpolator->setEnabled(true);
   }
   else
   {
     m_Controls->interpolatorWarningLabel->show();
     m_Controls->interpolatorWarningLabel->setText("<font color=\"red\">Interpolation only works for single label segmentations.</font>");
   }
 }
 
 void QmitkSegmentationView::ValidateSelectionInput()
 {
   this->UpdateWarningLabel("");
 
+  m_Controls->layersWidget->setEnabled(false);
+  m_Controls->labelsWidget->setEnabled(false);
   m_Controls->labelSetWidget->setEnabled(false);
 
   // the argument is actually not used
   // enable status depends on the tool manager selection
   m_Controls->toolSelectionBox2D->setEnabled(false);
   m_Controls->toolSelectionBox3D->setEnabled(false);
 
   mitk::DataNode* referenceNode = m_Controls->referenceNodeSelector->GetSelectedNode();
   mitk::DataNode* workingNode = m_Controls->workingNodeSelector->GetSelectedNode();
 
   if (nullptr == referenceNode)
   {
     return;
   }
 
   if (nullptr == workingNode)
   {
     return;
   }
 
   mitk::IRenderWindowPart* renderWindowPart = this->GetRenderWindowPart();
   auto workingNodeIsVisible = renderWindowPart &&
     workingNode->IsVisible(renderWindowPart->GetQmitkRenderWindow("axial")->GetRenderer());
   if (!workingNodeIsVisible)
   {
     this->UpdateWarningLabel(tr("The selected segmentation is currently not visible!"));
     return;
   }
 
   /*
   * Here we check whether the geometry of the selected segmentation image is aligned with the worldgeometry.
   * At the moment it is not supported to use a geometry different from the selected image for reslicing.
   * For further information see Bug 16063
   */
   const mitk::BaseGeometry* workingNodeGeo = workingNode->GetData()->GetGeometry();
   const mitk::BaseGeometry* worldGeo =
     renderWindowPart->GetQmitkRenderWindow("3d")->GetSliceNavigationController()->GetCurrentGeometry3D();
   if (nullptr != workingNodeGeo && nullptr != worldGeo)
   {
     if (mitk::Equal(*workingNodeGeo->GetBoundingBox(), *worldGeo->GetBoundingBox(), mitk::eps, true))
     {
       m_ToolManager->SetReferenceData(referenceNode);
       m_ToolManager->SetWorkingData(workingNode);
+      m_Controls->layersWidget->setEnabled(true);
+      m_Controls->labelsWidget->setEnabled(true);
       m_Controls->labelSetWidget->setEnabled(true);
       m_Controls->toolSelectionBox2D->setEnabled(true);
       m_Controls->toolSelectionBox3D->setEnabled(true);
       return;
     }
   }
 
   m_ToolManager->SetReferenceData(referenceNode);
   m_ToolManager->SetWorkingData(nullptr);
   this->UpdateWarningLabel(tr("Please perform a reinit on the segmentation image!"));
 }
 
 void QmitkSegmentationView::UpdateWarningLabel(QString text)
 {
   if (text.size() == 0)
   {
     m_Controls->selectionWarningLabel->hide();
   }
   else
   {
     m_Controls->selectionWarningLabel->show();
     m_Controls->selectionWarningLabel->setText("<font color=\"red\">" + text + "</font>");
   }
 }