diff --git a/Modules/SegmentationUI/Qmitk/QmitkMultiLabelInspectorControls.ui b/Modules/SegmentationUI/Qmitk/QmitkMultiLabelInspectorControls.ui
index 867f367d00..b408230b03 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkMultiLabelInspectorControls.ui
+++ b/Modules/SegmentationUI/Qmitk/QmitkMultiLabelInspectorControls.ui
@@ -1,74 +1,98 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkMultiLabelInspector</class>
  <widget class="QWidget" name="QmitkMultiLabelInspector">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>400</width>
-    <height>300</height>
+    <height>120</height>
    </rect>
   </property>
+  <property name="sizePolicy">
+   <sizepolicy hsizetype="Preferred" vsizetype="Maximum">
+    <horstretch>0</horstretch>
+    <verstretch>0</verstretch>
+   </sizepolicy>
+  </property>
   <property name="windowTitle">
    <string>Form</string>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout">
    <property name="spacing">
     <number>0</number>
    </property>
    <property name="leftMargin">
     <number>0</number>
    </property>
    <property name="topMargin">
     <number>0</number>
    </property>
    <property name="rightMargin">
     <number>0</number>
    </property>
    <property name="bottomMargin">
     <number>0</number>
    </property>
    <item>
     <widget class="QmitkMultiLabelTreeView" name="view">
+     <property name="sizePolicy">
+      <sizepolicy hsizetype="Expanding" vsizetype="MinimumExpanding">
+       <horstretch>0</horstretch>
+       <verstretch>0</verstretch>
+      </sizepolicy>
+     </property>
+     <property name="minimumSize">
+      <size>
+       <width>0</width>
+       <height>120</height>
+      </size>
+     </property>
+     <property name="maximumSize">
+      <size>
+       <width>16777215</width>
+       <height>120</height>
+      </size>
+     </property>
      <property name="editTriggers">
       <set>QAbstractItemView::EditKeyPressed|QAbstractItemView::SelectedClicked</set>
      </property>
      <property name="showDropIndicator" stdset="0">
       <bool>false</bool>
      </property>
      <property name="alternatingRowColors">
       <bool>false</bool>
      </property>
      <property name="selectionMode">
       <enum>QAbstractItemView::SingleSelection</enum>
      </property>
      <property name="selectionBehavior">
       <enum>QAbstractItemView::SelectRows</enum>
      </property>
      <attribute name="headerVisible">
       <bool>false</bool>
      </attribute>
      <attribute name="headerMinimumSectionSize">
       <number>10</number>
      </attribute>
      <attribute name="headerDefaultSectionSize">
       <number>50</number>
      </attribute>
      <attribute name="headerStretchLastSection">
       <bool>false</bool>
      </attribute>
     </widget>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>QmitkMultiLabelTreeView</class>
    <extends>QTreeView</extends>
    <header>QmitkMultiLabelTreeView.h</header>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>
diff --git a/Modules/SegmentationUI/Qmitk/QmitkMultiLabelManager.cpp b/Modules/SegmentationUI/Qmitk/QmitkMultiLabelManager.cpp
index 5656c8b753..8a54e9fb44 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkMultiLabelManager.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitkMultiLabelManager.cpp
@@ -1,457 +1,459 @@
 /*============================================================================
 
 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 "QmitkMultiLabelManager.h"
+#include <QmitkMultiLabelManager.h>
 
 // mitk
 #include <mitkAutoCropImageFilter.h>
 #include <mitkCoreObjectFactory.h>
 #include <mitkIOUtil.h>
 #include <mitkLabelSetImage.h>
 #include <mitkLabelSetImageToSurfaceThreadedFilter.h>
 #include <mitkRenderingManager.h>
 #include <mitkShowSegmentationAsSurface.h>
 #include <mitkStatusBar.h>
 #include <mitkToolManagerProvider.h>
 
 // Qmitk
 #include <QmitkStyleManager.h>
 
 // Qt
 #include <QLabel>
 #include <QWidgetAction>
 #include <QColorDialog>
 #include <QCompleter>
 #include <QDateTime>
 #include <QFileDialog>
 #include <QMenu>
 #include <QMessageBox>
 #include <QPushButton>
 #include <QShortcut>
 #include <QStringListModel>
 
-
 // itk
 #include <itksys/SystemTools.hxx>
 
-#include "ui_QmitkMultiLabelManagerControls.h"
+#include <ui_QmitkMultiLabelManagerControls.h>
 
 
 QmitkMultiLabelManager::QmitkMultiLabelManager(QWidget *parent)
   : QWidget(parent), m_Controls(new Ui::QmitkMultiLabelManagerControls), m_Completer(nullptr), m_ProcessingManualSelection(false)
 {
   m_Controls->setupUi(this);
 
   m_Controls->labelSearchBox->setAlwaysShowClearIcon(true);
   m_Controls->labelSearchBox->setShowSearchIcon(true);
 
   QStringList completionList;
   completionList << "";
   m_Completer = new QCompleter(completionList, this);
   m_Completer->setCaseSensitivity(Qt::CaseInsensitive);
   m_Controls->labelSearchBox->setCompleter(m_Completer);
 
   m_Controls->labelInspector->SetAllowLabelModification(true);
   connect(m_Controls->labelInspector, &QmitkMultiLabelInspector::CurrentSelectionChanged, this, &QmitkMultiLabelManager::UpdateControls);
 
   connect(m_Controls->labelSearchBox, SIGNAL(returnPressed()), this, SLOT(OnSearchLabel()));
 
   QStringListModel *completeModel = static_cast<QStringListModel *>(m_Completer->model());
   completeModel->setStringList(GetLabelStringList());
 
+  // See T29549
+  m_Controls->labelSearchBox->hide();
+
   m_Controls->btnSavePreset->setIcon(QmitkStyleManager::ThemeIcon(QStringLiteral(":/org_mitk_icons/icons/awesome/scalable/actions/document-save.svg")));
   m_Controls->btnLoadPreset->setIcon(QmitkStyleManager::ThemeIcon(QStringLiteral(":/org_mitk_icons/icons/awesome/scalable/actions/document-open.svg")));
 
   connect(m_Controls->btnAddLabel, &QToolButton::clicked, this->m_Controls->labelInspector, &QmitkMultiLabelInspector::AddNewLabel);
   connect(m_Controls->btnAddInstance, &QToolButton::clicked, this->m_Controls->labelInspector, &QmitkMultiLabelInspector::AddNewLabelInstance);
   connect(m_Controls->btnRemoveLabel, &QToolButton::clicked, this->m_Controls->labelInspector, &QmitkMultiLabelInspector::DeleteLabel);
   connect(m_Controls->btnAddGroup, &QToolButton::clicked, this->m_Controls->labelInspector, &QmitkMultiLabelInspector::AddNewGroup);
   connect(m_Controls->btnRemoveGroup, &QToolButton::clicked, this->m_Controls->labelInspector, &QmitkMultiLabelInspector::RemoveGroup);
   connect(m_Controls->btnSavePreset, &QToolButton::clicked, this, &QmitkMultiLabelManager::OnSavePreset);
   connect(m_Controls->btnSavePreset, &QToolButton::clicked, this, &QmitkMultiLabelManager::OnLoadPreset);
 
   connect(this->m_Controls->labelInspector, &QmitkMultiLabelInspector::GoToLabel, this, &QmitkMultiLabelManager::OnGoToLabel);
   connect(this->m_Controls->labelInspector, &QmitkMultiLabelInspector::LabelRenameRequested, this, &QmitkMultiLabelManager::OnLabelRenameRequested);
   connect(this->m_Controls->labelInspector, &QmitkMultiLabelInspector::CurrentSelectionChanged, this, &QmitkMultiLabelManager::CurrentSelectionChanged);
 
   auto* renameLabelShortcut = new QShortcut(QKeySequence(Qt::CTRL | Qt::Key::Key_L, Qt::CTRL | Qt::Key::Key_R), this);
   connect(renameLabelShortcut, &QShortcut::activated, this, &QmitkMultiLabelManager::OnRenameLabelShortcutActivated);
 
   auto* newLabelShortcut = new QShortcut(QKeySequence(Qt::CTRL | Qt::Key::Key_L, Qt::CTRL | Qt::Key::Key_A), this);
   connect(newLabelShortcut, &QShortcut::activated, this->m_Controls->labelInspector, &QmitkMultiLabelInspector::AddNewLabel);
 
   this->UpdateControls();
 }
 
 QmitkMultiLabelManager::~QmitkMultiLabelManager()
 {
   delete m_Controls;
 }
 
 QmitkMultiLabelManager::LabelValueVectorType QmitkMultiLabelManager::GetSelectedLabels() const
 {
   return m_Controls->labelInspector->GetSelectedLabels();
 }
 
 
 void QmitkMultiLabelManager::OnRenameLabelShortcutActivated()
 {
   auto selectedLabels = this->GetSelectedLabels();
 
   for (auto labelValue : selectedLabels)
   {
     auto currentLabel = this->m_Segmentation->GetLabel(labelValue);
     emit LabelRenameRequested(currentLabel, true);
   }
 }
 
 void QmitkMultiLabelManager::OnSelectedLabelChanged(LabelValueVectorType labels)
 {
   if (labels.empty() || labels.size() > 1) return;
 
   emit CurrentSelectionChanged(labels);
 }
 
 QStringList &QmitkMultiLabelManager::GetLabelStringList()
 {
   return m_LabelStringList;
 }
 
 void QmitkMultiLabelManager::SetDefaultLabelNaming(bool defaultLabelNaming)
 {
   this->m_Controls->labelInspector->SetDefaultLabelNaming(defaultLabelNaming);
 }
 
 void QmitkMultiLabelManager::setEnabled(bool enabled)
 {
   QWidget::setEnabled(enabled);
   UpdateControls();
 }
 
 void QmitkMultiLabelManager::SetSelectedLabels(const LabelValueVectorType& selectedLabels)
 {
   this->m_Controls->labelInspector->SetSelectedLabels(selectedLabels);
   UpdateControls();
 }
 
 void QmitkMultiLabelManager::SetSelectedLabel(mitk::LabelSetImage::LabelValueType selectedLabel)
 {
   this->m_Controls->labelInspector->SetSelectedLabel(selectedLabel);
   UpdateControls();
 }
 
 void QmitkMultiLabelManager::SetMultiLabelSegmentation(mitk::LabelSetImage* segmentation)
 {
   if (segmentation != this->m_Segmentation.GetPointer())
   {
     m_Segmentation = segmentation;
     this->m_Controls->labelInspector->SetMultiLabelSegmentation(segmentation);
     UpdateControls();
   }
 }
 
 void QmitkMultiLabelManager::SetDataStorage(mitk::DataStorage *storage)
 {
   m_DataStorage = storage;
 }
 
 void QmitkMultiLabelManager::OnSearchLabel()
 {
   //std::string text = m_Controls->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->selectRow(row);
   //m_Controls->m_LabelSetTableWidget->scrollToItem(nameItem);
 
   //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 QmitkMultiLabelManager::UpdateControls()
 {
   bool hasWorkingData = m_Segmentation.IsNotNull();
 
   auto labels = this->m_Controls->labelInspector->GetSelectedLabels();
 
   m_Controls->labelSearchBox->setEnabled(hasWorkingData);
   m_Controls->btnAddGroup->setEnabled(hasWorkingData);
   m_Controls->btnAddInstance->setEnabled(hasWorkingData && labels.size()==1);
   m_Controls->btnAddLabel->setEnabled(hasWorkingData);
   m_Controls->btnLoadPreset->setEnabled(hasWorkingData);
   m_Controls->btnRemoveGroup->setEnabled(hasWorkingData && !labels.empty() && m_Segmentation->GetNumberOfLayers()>1);
   m_Controls->btnRemoveLabel->setEnabled(hasWorkingData && !labels.empty());
   m_Controls->btnSavePreset->setEnabled(hasWorkingData);
 
   if (!hasWorkingData)
     return;
 
   QStringListModel *completeModel = dynamic_cast<QStringListModel *>(m_Completer->model());
   completeModel->setStringList(GetLabelStringList());
 }
 
 void QmitkMultiLabelManager::OnCreateCroppedMask(bool)
 {
   mitk::ToolManagerProvider::GetInstance()->GetToolManager()->ActivateTool(-1);
 
   mitk::Image::Pointer maskImage;
   auto currentLabel = this->m_Segmentation->GetLabel(this->GetSelectedLabels().front());
   auto pixelValue = currentLabel->GetValue();
   try
   {
     this->WaitCursorOn();
 
     mitk::AutoCropImageFilter::Pointer cropFilter = mitk::AutoCropImageFilter::New();
     cropFilter->SetInput(this->m_Segmentation->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 = currentLabel->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(currentLabel->GetColor());
   maskNode->SetOpacity(1.0);
 
   m_DataStorage->Add(maskNode, this->m_SegmentationNode);
 }
 
 void QmitkMultiLabelManager::OnCreateMask(bool /*triggered*/)
 {
   mitk::ToolManagerProvider::GetInstance()->GetToolManager()->ActivateTool(-1);
 
   auto currentLabel = this->m_Segmentation->GetLabel(this->GetSelectedLabels().front());
   auto pixelValue = currentLabel->GetValue();
   mitk::Image::Pointer maskImage;
   try
   {
     this->WaitCursorOn();
     maskImage = m_Segmentation->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 = currentLabel->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(currentLabel->GetColor());
   maskNode->SetOpacity(1.0);
 
   m_DataStorage->Add(maskNode, m_SegmentationNode);
 }
 
 void QmitkMultiLabelManager::OnCreateSmoothedSurface(bool /*triggered*/)
 {
   mitk::ToolManagerProvider::GetInstance()->GetToolManager()->ActivateTool(-1);
 
   auto currentLabel = this->m_Segmentation->GetLabel(this->GetSelectedLabels().front());
   auto pixelValue = currentLabel->GetValue();
 
   mitk::LabelSetImageToSurfaceThreadedFilter::Pointer surfaceFilter = mitk::LabelSetImageToSurfaceThreadedFilter::New();
 
   itk::SimpleMemberCommand<QmitkMultiLabelManager>::Pointer successCommand =
     itk::SimpleMemberCommand<QmitkMultiLabelManager>::New();
   successCommand->SetCallbackFunction(this, &QmitkMultiLabelManager::OnThreadedCalculationDone);
   surfaceFilter->AddObserver(mitk::ResultAvailable(), successCommand);
 
   itk::SimpleMemberCommand<QmitkMultiLabelManager>::Pointer errorCommand =
     itk::SimpleMemberCommand<QmitkMultiLabelManager>::New();
   errorCommand->SetCallbackFunction(this, &QmitkMultiLabelManager::OnThreadedCalculationDone);
   surfaceFilter->AddObserver(mitk::ProcessingError(), errorCommand);
 
   mitk::DataNode::Pointer groupNode = m_SegmentationNode;
   surfaceFilter->SetPointerParameter("Group node", groupNode);
   surfaceFilter->SetPointerParameter("Input", m_Segmentation);
   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 QmitkMultiLabelManager::OnCreateDetailedSurface(bool /*triggered*/)
 {
   mitk::ToolManagerProvider::GetInstance()->GetToolManager()->ActivateTool(-1);
 
   auto currentLabel = this->m_Segmentation->GetLabel(this->GetSelectedLabels().front());
   auto pixelValue = currentLabel->GetValue();
 
   mitk::LabelSetImageToSurfaceThreadedFilter::Pointer surfaceFilter = mitk::LabelSetImageToSurfaceThreadedFilter::New();
 
   itk::SimpleMemberCommand<QmitkMultiLabelManager>::Pointer successCommand =
     itk::SimpleMemberCommand<QmitkMultiLabelManager>::New();
   successCommand->SetCallbackFunction(this, &QmitkMultiLabelManager::OnThreadedCalculationDone);
   surfaceFilter->AddObserver(mitk::ResultAvailable(), successCommand);
 
   itk::SimpleMemberCommand<QmitkMultiLabelManager>::Pointer errorCommand =
     itk::SimpleMemberCommand<QmitkMultiLabelManager>::New();
   errorCommand->SetCallbackFunction(this, &QmitkMultiLabelManager::OnThreadedCalculationDone);
   surfaceFilter->AddObserver(mitk::ProcessingError(), errorCommand);
 
   mitk::DataNode::Pointer groupNode = m_SegmentationNode;
   surfaceFilter->SetPointerParameter("Group node", groupNode);
   surfaceFilter->SetPointerParameter("Input", m_Segmentation);
   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 QmitkMultiLabelManager::OnSavePreset()
 {
 
 }
 
 void QmitkMultiLabelManager::OnLoadPreset()
 {
 
 }
 
 void QmitkMultiLabelManager::OnGoToLabel(mitk::LabelSetImage::LabelValueType label, const mitk::Point3D& position) const
 {
   emit GoToLabel(label, position);
 }
 
 void QmitkMultiLabelManager::OnLabelRenameRequested(mitk::Label* label, bool rename) const
 {
   emit LabelRenameRequested(label, rename);
 }
 
 
 void QmitkMultiLabelManager::WaitCursorOn()
 {
   QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
 }
 
 void QmitkMultiLabelManager::WaitCursorOff()
 {
   this->RestoreOverrideCursor();
 }
 
 void QmitkMultiLabelManager::RestoreOverrideCursor()
 {
   QApplication::restoreOverrideCursor();
 }
 
 void QmitkMultiLabelManager::OnThreadedCalculationDone()
 {
   mitk::StatusBar::GetInstance()->Clear();
 }
diff --git a/Modules/SegmentationUI/Qmitk/QmitkMultiLabelManagerControls.ui b/Modules/SegmentationUI/Qmitk/QmitkMultiLabelManagerControls.ui
index 73d3c06203..5e4f256b9a 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkMultiLabelManagerControls.ui
+++ b/Modules/SegmentationUI/Qmitk/QmitkMultiLabelManagerControls.ui
@@ -1,201 +1,201 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkMultiLabelManagerControls</class>
  <widget class="QWidget" name="QmitkMultiLabelManagerControls">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>312</width>
-    <height>366</height>
+    <height>66</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>
     <layout class="QHBoxLayout" name="horizontalLayout">
      <item>
       <widget class="QToolButton" name="btnAddLabel">
        <property name="toolTip">
         <string>Add a new label to the current group.</string>
        </property>
        <property name="text">
         <string>L+</string>
        </property>
        <property name="autoRaise">
         <bool>true</bool>
        </property>
       </widget>
      </item>
      <item>
       <widget class="QToolButton" name="btnAddInstance">
        <property name="toolTip">
         <string>Add a new instance of the current label.</string>
        </property>
        <property name="text">
         <string>I+</string>
        </property>
        <property name="iconSize">
         <size>
          <width>32</width>
          <height>32</height>
         </size>
        </property>
        <property name="autoRaise">
         <bool>true</bool>
        </property>
       </widget>
      </item>
      <item>
       <widget class="QToolButton" name="btnRemoveLabel">
        <property name="toolTip">
         <string>Remove the current label.</string>
        </property>
        <property name="text">
         <string>L-</string>
        </property>
        <property name="autoRaise">
         <bool>true</bool>
        </property>
       </widget>
      </item>
      <item>
       <spacer name="horizontalSpacer">
        <property name="orientation">
         <enum>Qt::Horizontal</enum>
        </property>
        <property name="sizeType">
         <enum>QSizePolicy::Expanding</enum>
        </property>
        <property name="sizeHint" stdset="0">
         <size>
          <width>40</width>
          <height>20</height>
         </size>
        </property>
       </spacer>
      </item>
      <item>
       <widget class="QToolButton" name="btnAddGroup">
        <property name="toolTip">
         <string>Add a new group.</string>
        </property>
        <property name="text">
         <string>G+</string>
        </property>
        <property name="autoRaise">
         <bool>true</bool>
        </property>
       </widget>
      </item>
      <item>
       <widget class="QToolButton" name="btnRemoveGroup">
        <property name="toolTip">
         <string>Remove the current group (including all labels).</string>
        </property>
        <property name="text">
         <string>G-</string>
        </property>
        <property name="autoRaise">
         <bool>true</bool>
        </property>
       </widget>
      </item>
      <item>
       <spacer name="horizontalSpacer_2">
        <property name="orientation">
         <enum>Qt::Horizontal</enum>
        </property>
        <property name="sizeHint" stdset="0">
         <size>
          <width>20</width>
          <height>20</height>
         </size>
        </property>
       </spacer>
      </item>
      <item>
       <widget class="QToolButton" name="btnSavePreset">
        <property name="toolTip">
         <string>Save the labels preset.</string>
        </property>
        <property name="text">
         <string>...</string>
        </property>
        <property name="autoRaise">
         <bool>true</bool>
        </property>
       </widget>
      </item>
      <item>
       <widget class="QToolButton" name="btnLoadPreset">
        <property name="toolTip">
         <string>Load a label preset from file.</string>
        </property>
        <property name="text">
         <string>...</string>
        </property>
        <property name="autoRaise">
         <bool>true</bool>
        </property>
       </widget>
      </item>
     </layout>
    </item>
    <item>
     <widget class="QmitkMultiLabelInspector" name="labelInspector" native="true">
      <property name="sizePolicy">
-      <sizepolicy hsizetype="Preferred" vsizetype="Expanding">
+      <sizepolicy hsizetype="Preferred" vsizetype="Maximum">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
     </widget>
    </item>
    <item>
     <widget class="ctkSearchBox" name="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>
   <customwidget>
    <class>QmitkMultiLabelInspector</class>
    <extends>QWidget</extends>
    <header>QmitkMultiLabelInspector.h</header>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>
diff --git a/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/QmitkSegmentation.dox b/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/QmitkSegmentation.dox
index a49ee5a91c..98bc361bdb 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/QmitkSegmentation.dox
+++ b/Plugins/org.mitk.gui.qt.segmentation/documentation/UserManual/QmitkSegmentation.dox
@@ -1,432 +1,432 @@
 /**
 \page org_mitk_views_segmentation The Segmentation View
 
 \imageMacro{segmentation-dox.svg,"Icon of the segmentation view",2.00}
 
 <i>Some of the features described below are closed source additions to the open source toolkit MITK and are not  available in every application.</i>
 
 \tableofcontents
 
 \section org_mitk_views_segmentationoverview Overview
 
 Segmentation is the act of partitioning an image into subsets by either manual or automated delineation to create i.e. a distinction between foreground and background.
 A multilabel segmentation can contain more than one label and more than one layer.
 This allows you to create different labels for different regions of interest encapsulated in one single image.
 The difference between labels and layers is that labels on one layer cannot overlap but labels on different layers can.
 
 The MITK <b>segmentation plugin</b> allows you to create multilabel segmentations of anatomical and pathological structures in medical images.
 The plugin consists of two views:
 <ul>
   <li> <b>Segmentation View</b>: Manual and (semi-)automatic segmentation
   <li> \subpage org_mitk_views_segmentationutilities : Segmentation post-processing
 </ul>
 In this documentation, the features and usage of the segmentation view will be described.
 For an introduction to the segmentation utilities please be referred to the respective documentation pages.
 
 \imageMacro{QmitkSegmentationPlugin_Overview.png,"Segmentation plugin overview", 16.00}
 
 \section org_mitk_views_segmentationpreferences Preferences
 The segmentation plugin offers a number of preferences which can be set via the MITK Workbench application preferences:
 
 \imageMacro{QmitkSegmentationPreferences.png,"Segmentation preferences", 10.00}
 
 <ul>
-  <li> <b>Slim view:</b> Allows to show or hide the tool button description of the segmentation view
+  <li> <b>Compact view:</b> Allows to show or hide the tool button description of the segmentation view
   <li> <b>2D display:</b> Specify whether the segmentation is drawn as outline or as a transparent overlay
   <li> <b>Show only selected nodes:</b> Enable if only the selected segmentation and the reference image should be visible
   <li> <b>Smoothed surface creation:</b> Set certain smoothing parameters for surface creation
   <li> <b>Default label set preset:</b> Start a new segmentation with this preset instead of a default label
   <li> <b>Label creation:</b> Assign default names and colors to new labels or ask users for them
   <li> <b>Label suggestions:</b> Specify custom suggestions for label names and colors
 </ul>
 
 \section org_mitk_views_segmentationtechnicalissues Technical issues
 
 The segmentation plugin makes a number of assumptions:
 <ul>
   <li> Images must be 2D, 3D, or 3D+t.
   <li> Images must be single-values, i.e. CT, MRI or "normal" ultrasound. Images from color doppler or photographic (RGB) images are only partially supported (please be aware that some tools might not be compatible with this image type).
   <li> Segmentations are handled as multilabel images of the same extent as the original image.
 </ul>
 
 \section org_mitk_views_segmentationdataselection Data selection & creating new segmentations
 
 To select a reference image for the segmentation, click on the <i>Selected image</i> selection widget and choose a suitable image from the selection available in the data manager.
 Once an image is selected, a new segmentation can be created on this reference image by clicking the button to the right of the <i>Selected segmentation</i> selection widget.
 A new multilabel segmentation with an initial label is automatically generated.
 The new segmentation will be added to the data manager as sub-node of the reference image.
 This item is then automatically selected in the data selection, which allows to start editing the new segmentation right away.
 
 \imageMacro{"QmitkSegmentation_DataSelection.png","Data selection",12}
 
 Alternatively to creating a new segmentation, an existing one can be edited as well.
 If a reference image is selected for which a segmentation already exists in the data manager, the auto selection mode will automatically
 select a fitting segmentation.
 Clicking on the segmentation selection widget a drop down list will open, containing all suitable segmentations for the selected reference dataset available in the data manager.
 
 \section org_mitk_views_segmentationlayers Segmentation layers
 
 For each multilabel segmentation different layers can be added or deleted. The layers can be used independently and layers can be switched using the left and right arrows.
 A layer is a set of labels that occupy a non-overlapping anatomical space. The best way to describe them is by a real use case:
 Imagine you are working on a radiotherapy planning application. In the first layer of your segmentation session, you would like to trace the contours of the liver and neighboring organs.
 You can accommodate all these segmentations in separate labels because they all occupy different anatomical regions and do not overlap.
 Now say you would like to segment the arteries and veins inside the liver. If you don't trace them in a different layer, you will overwrite the previous ones.
 You may also need a third layer for segmenting the different irrigation territories in the liver and a fourth layer to contain the lesion you would like to treat.
 
 \imageMacro{"QmitkSegmentation_LayerSelection.png","Layer selection",12}
 
 \section org_mitk_views_segmentationlabels Segmentation labels
 
 For each layer, one or more labels can be added. Pressing the double arrow on the right, all created labels are shown in the 'Label Table'.
 The following label properties are available:
 
 <ul>
   <li><b>Name:</b></li> the name of the label. Can be a predefined one or any other.
   <li><b>Locked:</b></li> whether the label is locked or editable. A locked label cannot be overwritten by another.
   <li><b>Color:</b></li> the color of the label.
   <li><b>Visible:</b></li> whether the label is currently visible or hidden.
 </ul>
 
 \imageMacro{"QmitkSegmentation_LabelTable.png","The 'Label Table' shows all labels in the current segmentation session",12}
 
 The 'New Label' button can be used to add a new label. This will automatically add a new label with a distinct name and color to the list of available labels.\n
 In the current implementation of the plugin, the maximum number of labels is restricted to 255. If you need more, you will have to create a new segmentation session.
 
 \subsection org_mitk_views_segmentationlabelsuggestions Label name and color suggestions
 
 When renaming labels or creating new labels with enforced manual naming in the Segmentation preferences, entering names is supported by auto-completion for common label names.
 The list of predefined label names and colors for the auto-completion feature can be either extented or replaced by a custom list of label name and color suggestions.
 This custom list must be specified as a JSON file, just containing an array of objects, each with a mandatory "name" string and an optional "color" string.
 The JSON file can be set in the Segmentation preferences as well as a few options on how to apply these suggestions.
 
 \subsection org_mitk_views_segmentationlabelpresets Saving and loading label set presets
 
 Label set presets are useful to share a certain style or scheme between different segmentation sessions or to provide templates for new segmentation sessions.
 
 The properties of all labels in all layers like their names, colors, and visibilities are saved as a label set preset by clicking on the 'Save label set preset' button.
 Label set presets are applied to any segmentation session by clicking on the 'Load label set preset' button.
 If a label for a certain value already exists, its properties are overridden by the preset.
 If a label for a certain value does not yet exist, an empty label with the label properties of the preset is created.
 The actual segmentations of labels are unaffected as label set presets only store label properties.
 
 \subsubsection org_mitk_views_segmentationdefaultlabelpresets Applying label set presets by default
 
 If you work on a repetetive segmentation task, manually loading the same label set preset for each and every new segmentation can be tedious.
 To streamline your workflow, you can set a default label set preset in the Segmentation preferences (Ctrl+P). When set, this label set preset will be applied to all new segmentations instead of creating the default red "New label 1" label.
 
 \subsection org_mitk_views_segmentationlabelsearch Searching for a label
 
 It may happen that many labels (e.g. > 200) are present in a segmentation session and therefore manual searching can be time-consuming.
 The 'Label Search' edit box allows for quickly finding a label by providing assistance for label name completion.
 If the label is found, it will become the active one after pressing 'enter'.
 
 To start editing a label needs to be activated by clicking on the corresponding row in the 'Label Table'.
 Only one label can be active at the time. Then the segmentation tools in the toolbox can be used for mask generation.
 
 \subsection org_mitk_views_multilabelsegmentationoperationsonlabels Operations on labels
 Depending on the selection in the 'Label Table', several actions are offered:
 
 \subsubsection org_mitk_views_segmentationoperationssingleselection Operations with single label selection
 
 Right-clicking on any label opens a pop-up menu that offers the following actions to be performed on the selected label:
 
 <ul>
   <li><b>Rename...</b></li> : change the name and / or color of the selected label.
   <li><b>Remove...</b></li> : delete the selected label.
   <li><b>Erase...</b></li> : only clear the contents of the selected label.
   <li><b>Merge...</b></li> : merge two labels by selecting a second label.
   <li><b>Random color </b></li> : assign a random color to the label.
   <li><b>View only </b></li> : make all labels except the current selected label invisible.
   <li><b>View/Hide all </b></li> : make all labels visible / invisible
   <li><b>Lock/Unlock all </b></li> : lock or unlock all labels.
   <li><b>Create surface </b></li> : generate a surface out of the selected label.
     <li><b>Create mask </b></li> : generate a mask out of the selected label. A mask is a binary image with "1" inside and "0" outside.
 	<li><b>Create cropped mask </b></li> : generate a binary mask out of the selected label. Crop changes the extent of the resulting image to the extent of the label.
 </ul>
 
 \imageMacro{"QmitkSegmentation_OperationsSingleSelection.png","Context menu for single label selection",12}
 
 \subsubsection org_mitk_views_segmentationoperationsmultiselection Operations with multiple label selection
 
 Shift-clickink on multiple labels allows to select more than one label. If more than one label is selected, different options will appear in the menu:
 
 <ul>
   <li><b>Merge selection on current label</b></li> : transfer the contents of the selected labels in the 'Label Table' into the current one.
   <li><b>Remove selected labels</b></li> : delete the selected labels.
   <li><b>Erase selected labels</b></li> : only clear the contents of the selected labels.
 </ul>
 
 \imageMacro{"QmitkSegmentation_OperationsMultiSelection.png","Context menu for multiple label selection",12}
 
 \section org_mitk_views_segmentationtooloverview Segmentation tool overview
 
 MITK offers a comprehensive set of slice-based 2D and (semi-)automated 3D segmentation tools.
 The manual 2D tools require some user interaction and can only be applied to a single image slice whereas the 3D tools operate on the whole image.
 The 3D tools usually only require a small amount of user interaction, i.e. placing seed points or setting / adjusting parameters.
 You can switch between the different toolsets by selecting the 2D or 3D tab in the segmentation view.
 
 \imageMacro{QmitkSegmentation_ToolOverview.png,"An overview of the existing 2D and 3D tools in MITK.",5.50}
 
 \section org_mitk_views_segmentation2dsegmentation 2D segmentation tools
 
 With 2D manual contouring you define which voxels are part of the segmentation and which are not. This allows you to create segmentations of any structures of interest in an image.
 You can also use manual contouring to correct segmentations that result from sub-optimal automatic methods.
 The drawback of manual contouring is that you might need to define contours on many 2D slices. However, this is mitigated by the interpolation feature, which will make suggestions for a segmentation.
 
 To start using one of the editing tools, click its button from the displayed toolbox.
 The selected editing tool will be active and its corresponding button will stay pressed until you click the button again.
 Selecting a different tool also deactivates the previous one.\n
 If you have to delineate a lot of images, shortcuts to switch between tools becomes convenient.
 For that, just hit the first letter of each tool to activate it (A for Add, S for Subtract, etc.).
 
 All of the editing tools work by the same principle: using the mouse (left button) to click anywhere in a 2D window (any of the orientations axial, sagittal, or coronal),
 moving the mouse while holding the mouse button and releasing the button to finish the editing action.
 Multi-step undo and redo is fully supported by all editing tools by using the application-wide undo / redo buttons in the toolbar.
 
 <i>Remark</i>: Clicking and moving the mouse in any of the 2D render windows will move the crosshair that defines what part of the image is displayed.
 This behavior is disabled as long as any of the manual segmentation tools are active - otherwise you might have a hard time concentrating on the contour you are drawing.
 
 \subsection org_mitk_views_segmentationaddsubtracttools Add and subtract tools
 \imageMacro{QmitkSegmentation_IMGIconAddSubtract.png,"Add and subtract tools",7.70}
 
 Use the left mouse button to draw a closed contour. When releasing the mouse button, the contour will be added (Add tool) to or removed (Subtract tool) from the current segmentation.
 Adding and subtracting voxels can be iteratively repeated for the same segmentation. Holding CTRL / CMD while drawing will invert the current tool's behavior (i.e. instead of adding voxels, they will be subtracted).
 
 \subsection org_mitk_views_segmentationlassotool Lasso tool
 \imageMacro{QmitkSegmentation_Lasso.png,"Lasso tool",7.70}
 
 The tool is a more advanced version of the add/subtract tool. It offers you the following features:
 <ol>
   <li> Generating a polygon segmentation (click left mouse button to set ancor point)
   <li> Freehand contouring (like the add tool; press left mouse button while moving the mouse)
   <li> Move ancor points (select an ancor point, press left mouse button while moving the mouse)
   <li> Add new ancor points (press CTRL while click left mouse to add an ancor to the contour)
   <li> Delete an ancor point (press Del while ancor point is selected)
   <li> Segmentation can be added to the label (Add mode) or subtracted (Subtract mode)
 </ol>
 To start a segmentation double left click where the first ancor point should be. To end the segmentation double left click where the last ancor point should be.
 Please note that:
 <ul>
   <li> feature 3-6 are only available, if auto confirm is *not* activated
   <li> feature 3-5 is not available for freehand contour segments
 </ul>
 
 \subsection org_mitk_views_segmentationpaintwipetools Paint and wipe tools
 \imageMacro{QmitkSegmentation_IMGIconPaintWipe.png,"Paint and wipe tools",7.68}
 
 Use the <i>Size</i> slider to change the radius of the round paintbrush tool. Move the mouse in any 2D window and press the left button to draw or erase pixels.
 Holding CTRL / CMD while drawing will invert the current tool's behavior (i.e. instead of painting voxels, they will be wiped).
 
 \subsection org_mitk_views_segmentationregiongrowingtool Region growing tool
 \imageMacro{QmitkSegmentation_IMGIconRegionGrowing.png,"Region growing tool",3.81}
 
 Click at one point in a 2D slice widget to add an image region to the segmentation with the region growing tool.
 Region Growing selects all pixels around the mouse cursor that have a similar gray value as the pixel below the mouse cursor.
 This allows to quickly create segmentations of structures that have a good contrast to surrounding tissue.
 The tool operates based on the current level window, so changing the level window to optimize the contrast for the ROI is encouraged.
 Moving the mouse up / down is different from left / right:
 Moving up the cursor while holding the left mouse button widens the range for the included grey values; moving it down narrows it.
 Moving the mouse left and right will shift the range.
 The tool will select more or less pixels, corresponding to the changing gray value range.
 
 \if THISISNOTIMPLEMENTEDATTHEMOMENT
 A common issue with region growing is the so called "leakage" which happens when the structure of interest is connected to other pixels, of similar gray values, through a narrow "bridge" at the border of the structure.
 The Region Growing tool comes with a "leakage detection/removal" feature. If leakage happens, you can left-click into the leakage region and the tool will try to automatically remove this region (see illustration below).
 
 \imageMacro{QmitkSegmentation_Leakage.png,"Leakage correction feature of the region growing tool",11.28}
 \endif
 
 \subsection org_mitk_views_segmentationfilltool Fill tool
 \imageMacro{QmitkSegmentation_IMGIconFill.png,"Fill tool",3.81}
 
 Left-click inside a region/segmentation to flood fill all connected pixels that have the same label with the active label. This tool will only work on regions of unlocked labels or on regions that are not labeled at all.
 
 \subsection org_mitk_views_segmentationerasetool Erase tool
 \imageMacro{QmitkSegmentation_IMGIconErase.png,"Erase tool",3.79}
 
 This tool removes a connected part of pixels that form a segmentation.
 You may use it to remove single segmented regions (left-click on specific segmentation) or to clear a whole slice at once (left-click at the non-labeled background).
 This tool will only work and regions of unlocked labels or on regions of the active label.
 
 \subsection org_mitk_views_segmentationclosetool Close tool
 \imageMacro{QmitkSegmentation_IMGIconClose.png,"Close tool",3.79}
 
 Left-click inside the region/segmentation to fill all "holes" (pixels labelled with another label or no label) inside the region.
 Therefore this tool behaves like a local closing operation. This tool will not work, when a non-labeled region is selected and holes of locked labels will not be filled.
 \remark This tool always uses the label of the selected region (even if this label is not the active label). Therefore you can use this tool on regions of the active label and of none locked labels (without the need to change the active label). 
 
 \subsection org_mitk_views_segmentationlivewiretool Live wire tool
 
 \imageMacro{QmitkSegmentation_IMGIconLiveWire.png,"Live wire tool",3.01}
 
 The Live Wire Tool acts as a magnetic lasso with a contour snapping to edges of objects.
 
 \imageMacro{QmitkSegmentation_IMGLiveWireUsage.PNG,"Steps for using the Live Wire Tool",16.00}
 
 The tool handling is the same like the Lasso tool (see for more info), except it generates live wire contours instead of straight lines.
 
 \subsection org_mitk_views_segmentationinterpolation 2D and 3D Interpolation
 
 Creating segmentations using 2D manual contouring for large image volumes may be very time-consuming, because structures of interest may cover a large range of slices.
 Note: Interpolation is currently disabled for segmentations containing more than one label.
 The segmentation view offers two helpful features to mitigate this drawback:
 
 <ul>
   <li> 2D Interpolation
   <li> 3D Interpolation
 </ul>
 
 The <b>2D Interpolation</b> creates suggestions for a segmentation whenever you have a slice that
 
 <ul>
   <li> has got neighboring slices with segmentations (these do not need to be direct neighbors but could also be a couple of slices away) AND
   <li> is completely clear of a manual segmentation, i.e. there will be no suggestion if there is even only a single pixel of segmentation in the current slice.
 </ul>
 
 \imageMacro{QmitkSegmentation_2DInterpolation.png,"2D interpolation usage",3.01}
 
 Interpolated suggestions are displayed as outlines, until you confirm them as part of the segmentation.
 To confirm single slices, click the <i>Confirm for single slice</i> button below the toolbox. You may also review the interpolations visually and then accept all of them at once by selecting <i>Confirm for all slices</i>.
 
 The <b>3D interpolation</b> creates suggestions for 3D segmentations. That means if you start contouring, from the second contour onwards, the surface of the segmented area will be interpolated based on the given contour information.
 The interpolation works with all available manual tools. Please note that this is currently a pure mathematical interpolation, i.e. image intensity information is not taken into account.
 With each further contour the interpolation result will be improved, but the more contours you provide the longer the recalculation will take.
 To achieve an optimal interpolation result and in this way a most accurate segmentation you should try to describe the surface with sparse contours by segmenting in arbitrary
 oriented planes. The 3D interpolation is not meant to be used for parallel slice-wise segmentation, but rather segmentations in i.e. the axial, coronal and sagittal plane.
 
 \imageMacro{QmitkSegmentation_3DInterpolationWrongRight.png,"3D interpolation usage",16.00}
 
 You can accept the interpolation result by clicking the <i>Confirm</i>-button below the tool buttons.
 In this case the 3D interpolation will be deactivated automatically so that the result can be post-processed without any interpolation running in the background.
 
 Additional to the surface, black contours are shown in the 3D render window, which mark all the drawn contours used for the interpolation.
 You can navigate between the drawn contours by clicking on the corresponding <i>position</i> nodes in the data manager which are stored as sub-nodes of the selected segmentation.
 If you do not want to see these nodes just uncheck the <i>Show Position Nodes</i> checkbox and these nodes will be hidden.
 
 If you want to delete a drawn contour we recommend to use the Erase-Tool since undo / redo is not yet working for 3D interpolation.
 The current state of the 3D interpolation can be saved across application restart. For that, just click on save project during the interpolation is active.
 After restarting the application and load your project you can click on "Reinit Interpolation" within the 3D interpolation GUI area.
 
 \section org_mitk_views_segmentation3dsegmentation 3D segmentation tools
 
 The 3D tools operate on the whole image and require usually a small amount of interaction like placing seed-points or specifying certain parameters. All 3D tools provide
 an immediate segmentation feedback, which is displayed as a transparent green overlay. For accepting a preview you have to press the <i>Confirm</i> button of the selected tool.
 The following 3D tools are available:
 
 \subsection org_mitk_views_segmentation3dthresholdtool 3D Threshold tool
 
 The thresholding tool simply applies a 3D threshold to the patient image. All pixels with values equal or above the selected threshold are labeled as part of the segmentation.
 You can change the threshold by either moving the slider of setting a certain value in the spinbox.
 
 \imageMacro{QmitkSegmentation_3DThresholdTool.png,"3D Threshold tool",10.00}
 
 \subsection org_mitk_views_segmentation3dulthresholdTool 3D upper / lower threshold tool
 
 The Upper/Lower Thresholding tool works similar to the simple 3D threshold tool but allows you to define an upper and lower threshold. All pixels with
 values within this threshold interval will be labeled as part of the segmentation.
 
 \imageMacro{QmitkSegmentation_3DULThresholdTool.png,"3D upper / lower threshold tool",10.00}
 
 \subsection org_mitk_views_segmentation3dotsutool 3D Otsu tool
 
 The 3D Otsu tool provides a more sophisticated thresholding algorithm. It allows you to define a number of regions. Based on the image histogram the pixels will
 then be divided into different regions. The more regions you define the longer the calculation will take. You can select afterwards which of these regions you want to confirm as segmentation.
 \imageMacro{QmitkSegmentation_3DOtsuTool.png,"3D Otsu tool",10.00}
 
 \subsection org_mitk_views_segmentation3dgrowcuttool 3D GrowCut tool
 
 The 3D GrowCut tool uses previously created segmentation labels (e.g. by the "Add"-tool) stored in the segmentation layer 0.
 The GrowCut tool will use these segmentation labels to create a seedimage that will serve as input to the algorithm.
 As an advanced setting option, a Distance penalty can be set, which increases the cohesion in the immediate surroundings of the initial labels.
 Based on the seedimage and the Distance penalty, a growing is started, which includes all areas that are not initially assigned to a specific label.
 During this process, initially unassigned areas are assigned to the best fitting labels.
 After the segmentation process, the user can decide which newly generated labels should be confirmed.
 
 \imageMacro{QmitkSegmentation_3DGrowCutTool.png,"3D GrowCut tool",16.00}
 
 \subsection org_mitk_views_segmentation3drgtool 3D Region growing tool
 
 The 3D Region Growing tool works similar to the 2D pendant. At the beginning you have to place a seedpoint and define a threshold interval. If you press
 <i>Run Segmentation</i> a preview is calculated. By moving the <i>Adapt region growing</i> slider you can interactively adapt the segmentation result.
 
 \imageMacro{QmitkSegmentation_3DRGTool.png,"3D Region growing tool",10.00}
 
 \subsection org_mitk_views_segmentationpickingtool Picking Tool
 
 The Picking tool offers two modes that allow you to manipulate "islands" within your segmentation. This is especially useful if e.g. a thresholding provided you with several areas within
 your image but you are just interested in one special region.
 - Picking mode: Allows you to select certain "islands". When the pick is confirmed, the complete content of the active label will be removed except the pick. This mode is beneficial if you have a lot segmentation noise and want to pick the relevant parts and dismiss the rest. Hint: You can also pick from other labels, but this will only work if these labels are unlocked.
 - Relabel mode: Allows you to select certain "islands". When the pick is confirmed, it will be relabeled and added to the active label content. Hint: This mode ignores the locks of other labels, hence you do not need to unlock them explicitly.
 
 \imageMacro{QmitkSegmentation_PickingTool.png,"Picking tool",10.00}
 
 \subsection org_mitk_views_segmentationnnUNetTool nnU-Net Tool (Ubuntu only)
 
 \imageMacro{QmitkSegmentation_nnUnetTool.png,"nnUNet tool",10.00}
 
 This tool provides a GUI to the deep learning-based segmentation algorithm called the nnUNet. With this tool, you can get a segmentation mask predicted for the loaded image in MITK. Be ready with the pre-trained weights (a.k.a <b>RESULTS_FOLDER</b>)
 for your organ or task concerned, before using the tool. For a detailed explanation of the parameters and pre-trained weights folder structure etc., please refer to https://github.com/MIC-DKFZ/nnUNet. <br>
 Remark: The tool assumes that you have a Python3 environment with nnUNet (pip) installed. Your machine should be also equipped with a CUDA enabled GPU.
 
 \subsubsection org_mitk_views_segmentationnnUNetToolWorkflow Workflow:
     -# Select the "Python Path" drop-down to see if MITK has automatically detected other Python environments.
     Click on a fitting environment for the nnUNet inference or click "Select" in the dropdown to choose an unlisted python environment. Note that, while selecting an arbitrary environment folder, only select the base folder, e.g. "myenv".
     No need to select all the way until "../myenv/bin/python", for example.
     -# Click on the "nnUNet Results Folder" directory icon to navigate to the results folder on your hard disk. This is equivalent to setting the <b>RESULTS_FOLDER</b> environment variable. If your results folder is as
     per the nnUNet required folder structure, the configuration, trainers, tasks and folds are automatically parsed and correspondingly loaded in the drop-down boxes as shown below. Note that MITK automatically checks for the
     <b>RESULTS_FOLDER</b> environment variable value and, if found, auto parses that directory when the tool is started.
     \imageMacro{QmitkSegmentation_nnUNet_Settings.png,"nnUNet Segmentation Settings",10}
     -# Choose your required Task-Configuration-Trainer-Planner-Fold parameters, sequentially. By default, all entries are selected inside the "Fold" dropdown (shown: "All").
     Note that, even if you uncheck all entries from the "Fold" dropdown (shown: "None"), then too,  all folds would be considered for inferencing.
     -# For ensemble predictions, you will get the option to select parameters irrespective on postprocessing files available in the ensembles folder of <b>RESULTS_FOLDER</b>.
     Note that, if a postprocessing json file exists for the selected combination then it will used for ensembling, by default. To choose not to, uncheck the "Use PostProcessing JSON" in the "Advanced" section.
     \imageMacro{QmitkSegmentation_nnUNet_ensemble.png,"nnUNet Segmentation Settings",10}
     -# If your task is trained with multi-modal inputs, then "Multi-Modal" checkbox is checked and the no.of modalities are preloaded and shown next to "Required Modalities".
     Instantly, as much node selectors with corresponding modality names should appear below to select the Data Manager along including a selector with preselected with the reference node.
     Now, select the image nodes in the node selectors accordingly for accurate inferencing.
     \imageMacro{QmitkSegmentation_nnUNet_multimodal.png,"nnUNet Multi Modal Settings",10.00}
     -# Click on "Preview".
     -# In the "Advanced" section, you can also activate other options like "Mixed Precision" and "Enable Mirroring" (for test time data augmentation) pertaining to nnUNet.
     \imageMacro{QmitkSegmentation_nnUNet_Advanced.png,"nnUNet Advanced Settings",10.00}
     -# Use "Advanced" > "GPU Id" combobox to change the preferred GPU for inferencing. This is internally equivalent to setting the <b>CUDA_VISIBLE_DEVICES</b> environment variable.
     -# Every inferred segmentation is cached to prevent a redundant computation. In case, a user doesn't wish to cache a Preview, uncheck the "Enable Caching" in the "Advanced" section. This will ensure that the
     current parameters will neither be checked against the existing cache nor a segmentation be loaded from it when Preview is clicked.
     -# You may always clear all the cached segmentations by clicking "Clear Cache" button.
 
 \subsubsection org_mitk_views_segmentationnnUNetToolMisc Miscellaneous:
     -# In case you want to reload/reparse the folders in the "nnUNet Results Folder", eg. after adding new tasks into it, you may do so without reselecting the folder again by clicking the "Refresh Results Folder" button.
     -# The "Advanced" > "GPU Id" combobox lists the Nvidia GPUs available by parsing the <tt>nvidia-smi</tt> utility output. In case your machine has Nvidia CUDA enabled GPUs but the <tt>nvidia-smi</tt> fails for some reason, the "GPU Id" combobox will show no entries.
     In such a situation, it's still possible to execute inferencing by manually entering the preferred GPU Id, eg. 0 in the combobox.
     -# The "Advanced" > "Available Models" lists the available pre-trained tasks for download. Make sure you have internet connection. Then, choose a Task from the dropdown and click the Download button. The pre-trained models for the selected Task
     will be downloaded and placed to the <b>RESULTS_FOLDER</b> directory automatically.
     -# In the <b>RESULTS_FOLDER</b> directory, inside the trainer-planner folder of every task, MITK keeps a "mitk_export.json" file for fast loading for multi-modal information. It is recommended not to delete this file(s) for a fast responsive UI.
     Tip: If multi-modal information shown on MITK is not correct for a given task, you may modify this JSON file and try again.
 
 \section org_mitk_views_segmentationpostprocessing Additional things you can do with segmentations
 
 Segmentations are never an end in themselves. Consequently, the segmentation view adds a couple of "post-processing" actions, accessible through the context-menu of the data manager.
 
 \imageMacro{QmitkSegmentation_IMGDataManagerContextMenu.png,"Context menu items for segmentations",10.58}
 
 <ul>
 <li> <b>Create polygon %model</b> applies the marching cubes algorithm to the segmentation. This polygon %model can be used for visualization in 3D or other applications such as stereolithography (3D printing).
 <li> <b>Create smoothed polygon %model</b> uses smoothing in addition to the marching cubes algorithm, which creates models that do not follow the exact outlines of the segmentation, but look smoother.
 <li> <b>Autocrop</b> can save memory. Manual segmentations have the same extent as the patient image, even if the segmentation comprises only a small sub-volume. This invisible and meaningless margin is removed by autocropping.
 </ul>
 
 \section org_mitk_views_segmentationof3dtimages Segmentation of 3D+t images
 
 For segmentation of 3D+t images, some tools give you the option to choose between creating dynamic and static masks.
 <ul>
   <li> Dynamic masks can be created on each time frame individually.
   <li> Static masks will be defined on one time frame and will be the same for all other time frames.
 </ul>
 
 In general, segmentation is applied on the time frame that is selected when execution is performed.
 If you alter the time frame, the segmentation preview is adapted.
 
 \section org_mitk_views_segmentationtechnicaldetail Technical information for developers
 
 For technical specifications see \subpage QmitkSegmentationTechnicalPage and for information on the extensions of the tools system \subpage toolextensions.
 
 */
diff --git a/Plugins/org.mitk.gui.qt.segmentation/src/QmitkLabelSetWidget.cpp b/Plugins/org.mitk.gui.qt.segmentation/src/QmitkLabelSetWidget.cpp
index 74607e8b82..4cd0404652 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/src/QmitkLabelSetWidget.cpp
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/QmitkLabelSetWidget.cpp
@@ -1,1166 +1,1191 @@
 /*============================================================================
 
 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 <mitkToolManagerProvider.h>
 
 // Qmitk
 #include <QmitkDataStorageComboBox.h>
 #include <QmitkNewSegmentationDialog.h>
 #include <QmitkStyleManager.h>
 
 // Qt
 #include <QColorDialog>
 #include <QCompleter>
 #include <QDateTime>
 #include <QFileDialog>
 #include <QMenu>
 #include <QMessageBox>
 #include <QPushButton>
 #include <QShortcut>
 #include <QStringListModel>
 #include <QWidgetAction>
 
 // itk
 #include <itksys/SystemTools.hxx>
 
 QmitkLabelSetWidget::QmitkLabelSetWidget(QWidget *parent)
   : 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()));
 
   auto* renameLabelShortcut = new QShortcut(QKeySequence(Qt::CTRL | Qt::Key::Key_L, Qt::CTRL | Qt::Key::Key_R), this);
   connect(renameLabelShortcut, &QShortcut::activated, this, &QmitkLabelSetWidget::OnRenameLabelShortcutActivated);
 
   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);
   }
   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 *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)));
 
     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::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()->RemoveLabel(pixelValue);
     this->WaitCursorOff();
   }
 
   ResetAllTableWidgetItems();
 }
 
 void QmitkLabelSetWidget::OnRenameLabel(bool /*value*/)
 {
   int pixelValue = GetPixelValueOfSelectedItem();
   QmitkNewSegmentationDialog dialog(this, this->GetWorkingImage(), QmitkNewSegmentationDialog::RenameLabel);
   dialog.SetColor(GetWorkingImage()->GetActiveLabelSet()->GetLabel(pixelValue)->GetColor());
   dialog.SetName(QString::fromStdString(GetWorkingImage()->GetActiveLabelSet()->GetLabel(pixelValue)->GetName()));
 
   if (dialog.exec() == QDialog::Rejected)
   {
     return;
   }
   QString segmentationName = dialog.GetName();
   if (segmentationName.isEmpty())
   {
     segmentationName = "Unnamed";
   }
 
   GetWorkingImage()->GetActiveLabelSet()->RenameLabel(pixelValue, segmentationName.toStdString(), dialog.GetColor());
   GetWorkingImage()->GetActiveLabelSet()->UpdateLookupTable(pixelValue);
 
   UpdateAllTableWidgetItems();
 }
 
 void QmitkLabelSetWidget::OnRenameLabelShortcutActivated()
 {
   if (m_Controls.m_LabelSetTableWidget->selectedItems().size() == 1)
     this->OnRenameLabel(true);
 }
 
 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);
     this->WaitCursorOff();
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 void QmitkLabelSetWidget::OnRemoveLabels(bool /*value*/)
 {
   QString question = "Do you really want to remove the 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);
     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::OnActiveLabelChanged(int pixelValue)
 {
   mitk::LabelSetImage *workingImage = GetWorkingImage();
   assert(workingImage);
   workingImage->GetActiveLabelSet()->SetActiveLabel(pixelValue);
   // MITK_INFO << "Active Label set to << " << 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)
   {
     m_ProcessingManualSelection = true;
     OnActiveLabelChanged(pixelValue);
     m_ProcessingManualSelection = false;
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 void QmitkLabelSetWidget::OnItemDoubleClicked(QTableWidgetItem *item)
 {
   if (!item)
     return;
 
   if (QApplication::queryKeyboardModifiers().testFlag(Qt::AltModifier))
   {
     this->OnRenameLabelShortcutActivated();
     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)
 {
   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->selectRow(row);
       m_Controls.m_LabelSetTableWidget->scrollToItem(m_Controls.m_LabelSetTableWidget->item(row, 0));
       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::Label::PixelType /*lv*/)
 {
   this->UpdateAllTableWidgetItems();
 }
 
 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(mitk::Label::PixelType /*lv*/)
 {
   this->ResetAllTableWidgetItems();
 }
 
 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(workingImage->GetActiveLayer()) == 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 *tableWidget = m_Controls.m_LabelSetTableWidget;
+  auto* 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(
-    tableWidget, SIGNAL(itemDoubleClicked(QTableWidgetItem *)), this, SLOT(OnItemDoubleClicked(QTableWidgetItem *)));
-  connect(tableWidget,
-          SIGNAL(customContextMenuRequested(const QPoint &)),
-          this,
-          SLOT(OnTableViewContextMenuRequested(const QPoint &)));
+  using Self = QmitkLabelSetWidget;
+
+  connect(tableWidget, &QTableWidget::itemClicked, this, &Self::OnItemClicked);
+  connect(tableWidget, &QTableWidget::itemDoubleClicked, this, &Self::OnItemDoubleClicked);
+  connect(tableWidget, &QTableWidget::customContextMenuRequested, this, &Self::OnTableViewContextMenuRequested);
+
+  auto* model = tableWidget->model();
+
+  connect(model, &QAbstractItemModel::rowsInserted, this, &Self::OnRowsInserted);
+  connect(model, &QAbstractItemModel::rowsRemoved, this, &Self::OnRowsRemoved);
+}
+
+void QmitkLabelSetWidget::OnRowsInserted(const QModelIndex&, int, int)
+{
+  auto* tableWidget = m_Controls.m_LabelSetTableWidget;
+
+  if (tableWidget->rowCount() > 4)
+  {
+    tableWidget->setMinimumHeight(160);
+    tableWidget->setMaximumHeight(tableWidget->minimumHeight());
+  }
+}
+
+void QmitkLabelSetWidget::OnRowsRemoved(const QModelIndex&, int, int)
+{
+  auto* tableWidget = m_Controls.m_LabelSetTableWidget;
+
+  if (tableWidget->rowCount() <= 4)
+  {
+    tableWidget->setMinimumHeight(80);
+    tableWidget->setMaximumHeight(tableWidget->minimumHeight());
+  }
 }
 
 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->selectRow(row);
   m_Controls.m_LabelSetTableWidget->scrollToItem(nameItem);
 
   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::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/Plugins/org.mitk.gui.qt.segmentation/src/QmitkLabelSetWidget.h b/Plugins/org.mitk.gui.qt.segmentation/src/QmitkLabelSetWidget.h
index 688ed5f9b5..d863238290 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/src/QmitkLabelSetWidget.h
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/QmitkLabelSetWidget.h
@@ -1,169 +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 <org_mitk_gui_qt_segmentation_Export.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 MITK_QT_SEGMENTATION QmitkLabelSetWidget : public QWidget
 {
   Q_OBJECT
 
 public:
   explicit QmitkLabelSetWidget(QWidget *parent = nullptr);
   ~QmitkLabelSetWidget() override;
 
   void SetDataStorage(mitk::DataStorage *storage);
 
   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();
   void UpdateAllTableWidgetItems(mitk::Label::PixelType);
   /**
   * @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 ResetAllTableWidgetItems(mitk::Label::PixelType);
 
   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 OnRenameLabelShortcutActivated();
   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);
   void OnMergeLabels(bool);
 
   // reaction to signal "labelListModified" from QmitkLabelSetTableWidget
   void OnLabelListModified(const QStringList &list);
   // reaction to the signal "toggleOutline" from QmitkLabelSetTableWidget
   void OnToggleOutline(bool);
+  void OnRowsInserted(const QModelIndex&, int, int);
+  void OnRowsRemoved(const QModelIndex&, int, int);
 
 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/Plugins/org.mitk.gui.qt.segmentation/src/QmitkLabelSetWidgetControls.ui b/Plugins/org.mitk.gui.qt.segmentation/src/QmitkLabelSetWidgetControls.ui
index 0f28e488f2..9549002939 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/src/QmitkLabelSetWidgetControls.ui
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/QmitkLabelSetWidgetControls.ui
@@ -1,70 +1,94 @@
 <?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>
+    <height>137</height>
    </rect>
   </property>
   <property name="sizePolicy">
-   <sizepolicy hsizetype="Minimum" vsizetype="MinimumExpanding">
+   <sizepolicy hsizetype="Minimum" vsizetype="Maximum">
     <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="sizePolicy">
+      <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
+       <horstretch>0</horstretch>
+       <verstretch>0</verstretch>
+      </sizepolicy>
+     </property>
      <property name="text">
       <string>Caption</string>
      </property>
     </widget>
    </item>
    <item>
     <widget class="QTableWidget" name="m_LabelSetTableWidget">
+     <property name="sizePolicy">
+      <sizepolicy hsizetype="Expanding" vsizetype="MinimumExpanding">
+       <horstretch>0</horstretch>
+       <verstretch>0</verstretch>
+      </sizepolicy>
+     </property>
+     <property name="minimumSize">
+      <size>
+       <width>0</width>
+       <height>80</height>
+      </size>
+     </property>
+     <property name="maximumSize">
+      <size>
+       <width>16777215</width>
+       <height>80</height>
+      </size>
+     </property>
      <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/Plugins/org.mitk.gui.qt.segmentation/src/QmitkSegmentationPreferencePage.cpp b/Plugins/org.mitk.gui.qt.segmentation/src/QmitkSegmentationPreferencePage.cpp
index 823a33fedb..7ed6b1f9a2 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/src/QmitkSegmentationPreferencePage.cpp
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/QmitkSegmentationPreferencePage.cpp
@@ -1,156 +1,156 @@
 /*============================================================================
 
 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 "QmitkSegmentationPreferencePage.h"
 
 #include <mitkBaseApplication.h>
 #include <mitkCoreServices.h>
 #include <mitkIPreferencesService.h>
 #include <mitkIPreferences.h>
 
 #include <QFileDialog>
 
 #include <ui_QmitkSegmentationPreferencePageControls.h>
 
 namespace
 {
   mitk::IPreferences* GetPreferences()
   {
     auto* preferencesService = mitk::CoreServices::GetPreferencesService();
     return preferencesService->GetSystemPreferences()->Node("org.mitk.views.segmentation");
   }
 }
 
 QmitkSegmentationPreferencePage::QmitkSegmentationPreferencePage()
   : m_Ui(new Ui::QmitkSegmentationPreferencePageControls),
     m_Control(nullptr),
     m_Initializing(false)
 {
 }
 
 QmitkSegmentationPreferencePage::~QmitkSegmentationPreferencePage()
 {
 }
 
 void QmitkSegmentationPreferencePage::Init(berry::IWorkbench::Pointer)
 {
 }
 
 void QmitkSegmentationPreferencePage::CreateQtControl(QWidget* parent)
 {
   m_Initializing = true;
 
   m_Control = new QWidget(parent);
   m_Ui->setupUi(m_Control);
 
   connect(m_Ui->labelSetPresetToolButton, SIGNAL(clicked()), this, SLOT(OnLabelSetPresetButtonClicked()));
   connect(m_Ui->suggestionsToolButton, SIGNAL(clicked()), this, SLOT(OnSuggestionsButtonClicked()));
 
   this->Update();
   m_Initializing = false;
 }
 
 QWidget* QmitkSegmentationPreferencePage::GetQtControl() const
 {
   return m_Control;
 }
 
 bool QmitkSegmentationPreferencePage::PerformOk()
 {
   auto* prefs = GetPreferences();
 
-  prefs->PutBool("slim view", m_Ui->slimViewCheckBox->isChecked());
+  prefs->PutBool("compact view", m_Ui->compactViewCheckBox->isChecked());
   prefs->PutBool("draw outline", m_Ui->outlineRadioButton->isChecked());
   prefs->PutBool("selection mode", m_Ui->selectionModeCheckBox->isChecked());
   prefs->Put("label set preset", m_Ui->labelSetPresetLineEdit->text().toStdString());
   prefs->PutBool("default label naming", m_Ui->defaultNameRadioButton->isChecked());
   prefs->Put("label suggestions", m_Ui->suggestionsLineEdit->text().toStdString());
   prefs->PutBool("replace standard suggestions", m_Ui->replaceStandardSuggestionsCheckBox->isChecked());
   prefs->PutBool("suggest once", m_Ui->suggestOnceCheckBox->isChecked());
   return true;
 }
 
 void QmitkSegmentationPreferencePage::PerformCancel()
 {
 }
 
 void QmitkSegmentationPreferencePage::Update()
 {
   auto* prefs = GetPreferences();
 
-  m_Ui->slimViewCheckBox->setChecked(prefs->GetBool("slim view", false));
+  m_Ui->compactViewCheckBox->setChecked(prefs->GetBool("compact view", false));
 
   if (prefs->GetBool("draw outline", true))
   {
     m_Ui->outlineRadioButton->setChecked(true);
   }
   else
   {
     m_Ui->overlayRadioButton->setChecked(true);
   }
 
   m_Ui->selectionModeCheckBox->setChecked(prefs->GetBool("selection mode", false));
 
   auto labelSetPreset = mitk::BaseApplication::instance().config().getString(mitk::BaseApplication::ARG_SEGMENTATION_LABELSET_PRESET.toStdString(), "");
   bool isOverriddenByCmdLineArg = !labelSetPreset.empty();
 
   if (!isOverriddenByCmdLineArg)
     labelSetPreset = prefs->Get("label set preset", "");
 
   m_Ui->labelSetPresetLineEdit->setDisabled(isOverriddenByCmdLineArg);
   m_Ui->labelSetPresetToolButton->setDisabled(isOverriddenByCmdLineArg);
   m_Ui->labelSetPresetCmdLineArgLabel->setVisible(isOverriddenByCmdLineArg);
 
   m_Ui->labelSetPresetLineEdit->setText(QString::fromStdString(labelSetPreset));
 
   if (prefs->GetBool("default label naming", true))
   {
     m_Ui->defaultNameRadioButton->setChecked(true);
   }
   else
   {
     m_Ui->askForNameRadioButton->setChecked(true);
   }
 
   auto labelSuggestions = mitk::BaseApplication::instance().config().getString(mitk::BaseApplication::ARG_SEGMENTATION_LABEL_SUGGESTIONS.toStdString(), "");
   isOverriddenByCmdLineArg = !labelSuggestions.empty();
 
   if (!isOverriddenByCmdLineArg)
     labelSuggestions = prefs->Get("label suggestions", "");
 
   m_Ui->defaultNameRadioButton->setDisabled(isOverriddenByCmdLineArg);
   m_Ui->askForNameRadioButton->setDisabled(isOverriddenByCmdLineArg);
   m_Ui->suggestionsLineEdit->setDisabled(isOverriddenByCmdLineArg);
   m_Ui->suggestionsToolButton->setDisabled(isOverriddenByCmdLineArg);
   m_Ui->suggestionsCmdLineArgLabel->setVisible(isOverriddenByCmdLineArg);
 
   m_Ui->suggestionsLineEdit->setText(QString::fromStdString(labelSuggestions));
 
   m_Ui->replaceStandardSuggestionsCheckBox->setChecked(prefs->GetBool("replace standard suggestions", true));
   m_Ui->suggestOnceCheckBox->setChecked(prefs->GetBool("suggest once", true));
 }
 
 void QmitkSegmentationPreferencePage::OnLabelSetPresetButtonClicked()
 {
   const auto filename = QFileDialog::getOpenFileName(m_Control, QStringLiteral("Load Label Set Preset"), QString(), QStringLiteral("Label set preset (*.lsetp)"));
 
   if (!filename.isEmpty())
     m_Ui->labelSetPresetLineEdit->setText(filename);
 }
 
 void QmitkSegmentationPreferencePage::OnSuggestionsButtonClicked()
 {
   const auto filename = QFileDialog::getOpenFileName(m_Control, QStringLiteral("Load Label Suggestions"), QString(), QStringLiteral("Label suggestions (*.json)"));
 
   if (!filename.isEmpty())
     m_Ui->suggestionsLineEdit->setText(filename);
 }
diff --git a/Plugins/org.mitk.gui.qt.segmentation/src/QmitkSegmentationPreferencePageControls.ui b/Plugins/org.mitk.gui.qt.segmentation/src/QmitkSegmentationPreferencePageControls.ui
index d465bab8fd..578328a20f 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/src/QmitkSegmentationPreferencePageControls.ui
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/QmitkSegmentationPreferencePageControls.ui
@@ -1,233 +1,233 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkSegmentationPreferencePageControls</class>
  <widget class="QWidget" name="QmitkSegmentationPreferencePageControls">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>656</width>
     <height>779</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string>Form</string>
   </property>
   <layout class="QFormLayout" name="formLayout">
    <item row="0" column="0">
-    <widget class="QLabel" name="slimViewLabel">
+    <widget class="QLabel" name="compactViewLabel">
      <property name="text">
-      <string>Slim view</string>
+      <string>Compact view</string>
      </property>
     </widget>
    </item>
    <item row="0" column="1">
-    <widget class="QCheckBox" name="slimViewCheckBox">
+    <widget class="QCheckBox" name="compactViewCheckBox">
      <property name="text">
       <string>Hide tool button texts and increase icon size</string>
      </property>
     </widget>
    </item>
    <item row="1" column="0">
     <widget class="QLabel" name="displayLabel">
      <property name="text">
       <string>2D display</string>
      </property>
     </widget>
    </item>
    <item row="1" column="1">
     <layout class="QVBoxLayout" name="displayOptionsLayout">
      <item>
       <widget class="QRadioButton" name="outlineRadioButton">
        <property name="text">
         <string>Draw as outline</string>
        </property>
        <property name="checked">
         <bool>true</bool>
        </property>
        <attribute name="buttonGroup">
         <string notr="true">displayButtonGroup</string>
        </attribute>
       </widget>
      </item>
      <item>
       <widget class="QRadioButton" name="overlayRadioButton">
        <property name="text">
         <string>Draw as transparent overlay</string>
        </property>
        <attribute name="buttonGroup">
         <string notr="true">displayButtonGroup</string>
        </attribute>
       </widget>
      </item>
     </layout>
    </item>
    <item row="2" column="0">
     <widget class="QLabel" name="selectionModeLabel">
      <property name="text">
       <string>Data node selection mode</string>
      </property>
     </widget>
    </item>
    <item row="2" column="1">
     <widget class="QCheckBox" name="selectionModeCheckBox">
      <property name="toolTip">
       <string>If checked the segmentation plugin ensures that only the selected segmentation and the reference image are visible at one time.</string>
      </property>
      <property name="text">
       <string>Show only selected nodes</string>
      </property>
     </widget>
    </item>
    <item row="3" column="0">
     <widget class="QLabel" name="labelSetPresetLabel">
      <property name="text">
       <string>Default label set preset</string>
      </property>
     </widget>
    </item>
    <item row="3" column="1">
     <layout class="QGridLayout" name="gridLayout">
      <item row="0" column="0">
       <widget class="QLineEdit" name="labelSetPresetLineEdit">
        <property name="clearButtonEnabled">
         <bool>true</bool>
        </property>
       </widget>
      </item>
      <item row="0" column="1">
       <widget class="QToolButton" name="labelSetPresetToolButton">
        <property name="text">
         <string>...</string>
        </property>
       </widget>
      </item>
      <item row="1" column="0" colspan="2">
       <widget class="QLabel" name="labelSetPresetCmdLineArgLabel">
        <property name="text">
         <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;&lt;span style=&quot; color:#ff0000;&quot;&gt;The default label set preset is currently overriden by the &lt;/span&gt;&lt;span style=&quot; font-family:'Courier New'; color:#ff0000;&quot;&gt;Segmentation.labelSetPreset&lt;/span&gt;&lt;span style=&quot; color:#ff0000;&quot;&gt; command-line argument.&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
        </property>
        <property name="textFormat">
         <enum>Qt::RichText</enum>
        </property>
        <property name="wordWrap">
         <bool>true</bool>
        </property>
       </widget>
      </item>
     </layout>
    </item>
    <item row="4" column="0">
     <widget class="QLabel" name="labelCreationLabel">
      <property name="text">
       <string>Label creation</string>
      </property>
     </widget>
    </item>
    <item row="4" column="1">
     <layout class="QVBoxLayout" name="verticalLayout">
      <item>
       <widget class="QRadioButton" name="defaultNameRadioButton">
        <property name="text">
         <string>Assign default name and color</string>
        </property>
        <property name="checked">
         <bool>true</bool>
        </property>
        <attribute name="buttonGroup">
         <string notr="true">labelCreationButtonGroup</string>
        </attribute>
       </widget>
      </item>
      <item>
       <widget class="QRadioButton" name="askForNameRadioButton">
        <property name="text">
         <string>Ask for name and color</string>
        </property>
        <attribute name="buttonGroup">
         <string notr="true">labelCreationButtonGroup</string>
        </attribute>
       </widget>
      </item>
     </layout>
    </item>
    <item row="5" column="0">
     <widget class="QLabel" name="labelSuggestions">
      <property name="text">
       <string>Label suggestions</string>
      </property>
     </widget>
    </item>
    <item row="5" column="1">
     <layout class="QGridLayout" name="gridLayout_2">
      <item row="0" column="0">
       <widget class="QLineEdit" name="suggestionsLineEdit">
        <property name="clearButtonEnabled">
         <bool>true</bool>
        </property>
       </widget>
      </item>
      <item row="0" column="1">
       <widget class="QToolButton" name="suggestionsToolButton">
        <property name="text">
         <string>...</string>
        </property>
       </widget>
      </item>
      <item row="1" column="0" colspan="2">
       <widget class="QLabel" name="suggestionsCmdLineArgLabel">
        <property name="text">
         <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;&lt;span style=&quot; color:#ff0000;&quot;&gt;Suggestions are currently enforced by the &lt;/span&gt;&lt;span style=&quot; font-family:'Courier New'; color:#ff0000;&quot;&gt;Segmentation.labelSuggestions&lt;/span&gt;&lt;span style=&quot; color:#ff0000;&quot;&gt; command-line argument.&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
        </property>
        <property name="textFormat">
         <enum>Qt::RichText</enum>
        </property>
        <property name="wordWrap">
         <bool>true</bool>
        </property>
       </widget>
      </item>
     </layout>
    </item>
    <item row="6" column="1">
     <widget class="QCheckBox" name="replaceStandardSuggestionsCheckBox">
      <property name="text">
       <string>Replace standard organ suggestions</string>
      </property>
      <property name="checked">
       <bool>true</bool>
      </property>
     </widget>
    </item>
    <item row="7" column="1">
     <widget class="QCheckBox" name="suggestOnceCheckBox">
      <property name="text">
       <string>Suggest once per segmentation</string>
      </property>
      <property name="checked">
       <bool>true</bool>
      </property>
     </widget>
    </item>
    <item row="8" column="1">
     <spacer name="verticalSpacer">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>20</width>
        <height>40</height>
       </size>
      </property>
     </spacer>
    </item>
   </layout>
  </widget>
  <resources/>
  <connections/>
  <buttongroups>
   <buttongroup name="labelCreationButtonGroup"/>
   <buttongroup name="displayButtonGroup"/>
  </buttongroups>
 </ui>
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 982d199410..55c10b90ff 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.cpp
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.cpp
@@ -1,1031 +1,1034 @@
 /*============================================================================
 
 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 <mitkBaseApplication.h>
 #include <mitkBaseRendererHelper.h>
 #include <mitkCameraController.h>
 #include <mitkLabelSetImage.h>
 #include <mitkLabelSetImageHelper.h>
 #include <mitkMultiLabelIOHelper.h>
 #include <mitkManualPlacementAnnotationRenderer.h>
 #include <mitkNodePredicateSubGeometry.h>
 #include <mitkSegmentationObjectFactory.h>
 #include <mitkSegTool2D.h>
 #include <mitkStatusBar.h>
 #include <mitkToolManagerProvider.h>
 #include <mitkVtkResliceInterpolationProperty.h>
 #include <mitkWorkbenchUtil.h>
 #include <mitkIPreferences.h>
 
 // Qmitk
 #include <QmitkRenderWindow.h>
 #include <QmitkStaticDynamicSegmentationDialog.h>
 #include <QmitkNewSegmentationDialog.h>
 #include <QmitkMultiLabelManager.h>
 
 // us
 #include <usModuleResource.h>
 #include <usModuleResourceStream.h>
 
 // Qt
 #include <QMessageBox>
 #include <QShortcut>
 #include <QDir>
 
 // vtk
 #include <vtkQImageToImageSource.h>
 
 #include <regex>
 
 namespace
 {
   QList<QmitkRenderWindow*> Get2DWindows(const QList<QmitkRenderWindow*> allWindows)
   {
     QList<QmitkRenderWindow*> all2DWindows;
     for (auto* window : allWindows)
     {
       if (window->GetRenderer()->GetMapperID() == mitk::BaseRenderer::Standard2D)
       {
         all2DWindows.append(window);
       }
     }
     return all2DWindows;
   }
 }
 
 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)
   , m_DefaultLabelNaming(true)
   , m_SelectionChangeIsAlreadyBeingHandled(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);
 
   m_SegmentationPredicate = mitk::NodePredicateAnd::New();
   m_SegmentationPredicate->AddPredicate(mitk::TNodePredicateDataType<mitk::LabelSetImage>::New());
   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)
   {
     // deactivate all tools
     m_ToolManager->ActivateTool(-1);
 
     // removing all observers from working data
     for (NodeTagMapType::iterator dataIter = m_WorkingDataObserverTags.begin(); dataIter != m_WorkingDataObserverTags.end(); ++dataIter)
     {
       (*dataIter).first->GetProperty("visible")->RemoveObserver((*dataIter).second);
     }
     m_WorkingDataObserverTags.clear();
 
     // removing all observers from reference data
     for (NodeTagMapType::iterator dataIter = m_ReferenceDataObserverTags.begin(); dataIter != m_ReferenceDataObserverTags.end(); ++dataIter)
     {
       (*dataIter).first->GetProperty("visible")->RemoveObserver((*dataIter).second);
     }
     m_ReferenceDataObserverTags.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);
   }
 
   m_ToolManager->ActiveToolChanged -=
     mitk::MessageDelegate<QmitkSegmentationView>(this, &QmitkSegmentationView::ActiveToolChanged);
 
   delete m_Controls;
 }
 
 /**********************************************************************/
 /* private Q_SLOTS                                                    */
 /**********************************************************************/
 void QmitkSegmentationView::OnReferenceSelectionChanged(QList<mitk::DataNode::Pointer>)
 {
   this->OnAnySelectionChanged();
 }
 
 void QmitkSegmentationView::OnSegmentationSelectionChanged(QList<mitk::DataNode::Pointer>)
 {
   this->OnAnySelectionChanged();
 }
 
 void QmitkSegmentationView::OnAnySelectionChanged()
 {
   // When only a segmentation has been selected and the method is then called by a reference image selection,
   // the already selected segmentation may not match the geometry predicate of the new reference image anymore.
   // This will trigger a recursive call of this method further below. While it would be resolved gracefully, we
   // can spare the extra call with an early-out. The original call of this method will handle the segmentation
   // selection change afterwards anyway.
 
   if (m_SelectionChangeIsAlreadyBeingHandled)
     return;
 
   auto selectedReferenceNode = m_Controls->referenceNodeSelector->GetSelectedNode();
   bool referenceNodeChanged = false;
 
   m_ToolManager->ActivateTool(-1);
 
   if (m_ReferenceNode != selectedReferenceNode)
   {
     referenceNodeChanged = true;
 
     // Remove visibility observer for the current reference node
     if (m_ReferenceDataObserverTags.find(m_ReferenceNode) != m_ReferenceDataObserverTags.end())
     {
       m_ReferenceNode->GetProperty("visible")->RemoveObserver(m_ReferenceDataObserverTags[m_ReferenceNode]);
       m_ReferenceDataObserverTags.erase(m_ReferenceNode);
     }
 
     // Set new reference node
     m_ReferenceNode = selectedReferenceNode;
     m_ToolManager->SetReferenceData(m_ReferenceNode);
 
     // Prepare for a potential recursive call when changing node predicates of the working node selector
     m_SelectionChangeIsAlreadyBeingHandled = true;
 
     if (m_ReferenceNode.IsNull())
     {
       // Without a reference image, allow all segmentations to be selected
       m_Controls->workingNodeSelector->SetNodePredicate(m_SegmentationPredicate);
       m_SelectionChangeIsAlreadyBeingHandled = false;
     }
     else
     {
       // With a reference image, only allow segmentations that fit the geometry of the reference image to be selected.
       m_Controls->workingNodeSelector->SetNodePredicate(mitk::NodePredicateAnd::New(
         mitk::NodePredicateSubGeometry::New(m_ReferenceNode->GetData()->GetGeometry()),
         m_SegmentationPredicate.GetPointer()));
 
       m_SelectionChangeIsAlreadyBeingHandled = false;
 
       this->ApplySelectionModeOnReferenceNode();
 
       // Add visibility observer for the new reference node
       auto command = itk::SimpleMemberCommand<QmitkSegmentationView>::New();
       command->SetCallbackFunction(this, &QmitkSegmentationView::ValidateSelectionInput);
 
       m_ReferenceDataObserverTags[m_ReferenceNode] =
         m_ReferenceNode->GetProperty("visible")->AddObserver(itk::ModifiedEvent(), command);
     }
   }
 
   auto selectedWorkingNode = m_Controls->workingNodeSelector->GetSelectedNode();
   bool workingNodeChanged = false;
 
   if (m_WorkingNode != selectedWorkingNode)
   {
     workingNodeChanged = true;
 
     // Remove visibility observer for the current working node
     if (m_WorkingDataObserverTags.find(m_WorkingNode) != m_WorkingDataObserverTags.end())
     {
       m_WorkingNode->GetProperty("visible")->RemoveObserver(m_WorkingDataObserverTags[m_WorkingNode]);
       m_WorkingDataObserverTags.erase(m_WorkingNode);
     }
 
     // Set new working node
     m_WorkingNode = selectedWorkingNode;
     m_ToolManager->SetWorkingData(m_WorkingNode);
 
     if (m_WorkingNode.IsNotNull())
     {
       this->ApplySelectionModeOnWorkingNode();
 
       // Add visibility observer for the new segmentation node
       auto command = itk::SimpleMemberCommand<QmitkSegmentationView>::New();
       command->SetCallbackFunction(this, &QmitkSegmentationView::ValidateSelectionInput);
 
       m_WorkingDataObserverTags[m_WorkingNode] =
         m_WorkingNode->GetProperty("visible")->AddObserver(itk::ModifiedEvent(), command);
     }
   }
 
   // Reset camera if any selection changed but only if both reference node and working node are set
   if ((referenceNodeChanged || workingNodeChanged) && (m_ReferenceNode.IsNotNull() && m_WorkingNode.IsNotNull()))
   {
     if (nullptr != m_RenderWindowPart)
     {
       m_RenderWindowPart->InitializeViews(m_ReferenceNode->GetData()->GetTimeGeometry(), 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;
   }
 
   auto segTemplateImage = referenceImage;
   if (referenceImage->GetDimension() > 3)
   {
     QmitkStaticDynamicSegmentationDialog dialog(m_Parent);
     dialog.SetReferenceImage(referenceImage.GetPointer());
     dialog.exec();
     segTemplateImage = dialog.GetSegmentationTemplate();
   }
 
   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;
   }
 
   const auto labelSetPreset = this->GetDefaultLabelSetPreset();
 
   if (labelSetPreset.empty() || !mitk::MultiLabelIOHelper::LoadLabelSetImagePreset(labelSetPreset, newLabelSetImage))
   {
     auto newLabel = mitk::LabelSetImageHelper::CreateNewLabel(newLabelSetImage);
 
     if (!m_DefaultLabelNaming)
     {
       QmitkNewSegmentationDialog::DoRenameLabel(newLabel,nullptr,m_Parent);
     }
 
     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);
 }
 
 std::string QmitkSegmentationView::GetDefaultLabelSetPreset() const
 {
   auto labelSetPreset = mitk::BaseApplication::instance().config().getString(mitk::BaseApplication::ARG_SEGMENTATION_LABELSET_PRESET.toStdString(), "");
 
   if (labelSetPreset.empty())
     labelSetPreset = m_LabelSetPresetPreference.toStdString();
 
   return labelSetPreset;
 }
 
 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::OnCurrentLabelSelectionChanged(QmitkMultiLabelManager::LabelValueVectorType labels)
 {
   auto segmentation = this->GetCurrentSegmentation();
 
   const auto labelValue = labels.front();
   const auto groupID = segmentation->GetGroupIndexOfLabel(labelValue);
   if (groupID != segmentation->GetActiveLayer()) segmentation->SetActiveLayer(groupID);
   if (labelValue != segmentation->GetActiveLabelSet()->GetActiveLabel()->GetValue()) segmentation->GetActiveLabelSet()->SetActiveLabel(labelValue);
 
   segmentation->Modified();
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkSegmentationView::OnGoToLabel(mitk::LabelSetImage::LabelValueType /*label*/, const mitk::Point3D& pos)
 {
   if (m_RenderWindowPart)
   {
     m_RenderWindowPart->SetSelectedPosition(pos);
   }
 }
 
 void QmitkSegmentationView::OnLabelRenameRequested(mitk::Label* label, bool rename) const
 {
   auto segmentation = this->GetCurrentSegmentation();
 
   if (rename)
   {
     QmitkNewSegmentationDialog::DoRenameLabel(label, segmentation, this->m_Parent, QmitkNewSegmentationDialog::Mode::RenameLabel);
   }
   else
   {
     QmitkNewSegmentationDialog::DoRenameLabel(label, segmentation, this->m_Parent, QmitkNewSegmentationDialog::Mode::NewLabel);
   }
 }
 
 mitk::LabelSetImage* QmitkSegmentationView::GetCurrentSegmentation() const
 {
   auto workingNode = m_Controls->workingNodeSelector->GetSelectedNode();
   if (workingNode.IsNull()) mitkThrow() << "Segmentation view is in an invalid state. Working node is null, but a label selection change has been triggered.";
 
   auto segmentation = dynamic_cast<mitk::LabelSetImage*>(workingNode->GetData());
   if (nullptr == segmentation) mitkThrow() << "Segmentation view is in an invalid state. Working node contains no segmentation, but a label selection change has been triggered.";
 
   return segmentation;
 }
 
 /**********************************************************************/
 /* private                                                            */
 /**********************************************************************/
 void QmitkSegmentationView::CreateQtPartControl(QWidget* parent)
 {
    m_Parent = parent;
 
    m_Controls = new Ui::QmitkSegmentationViewControls;
    m_Controls->setupUi(parent);
 
    // *------------------------
    // * SHORTCUTS
    // *------------------------
    QShortcut* visibilityShortcut = new QShortcut(QKeySequence(Qt::CTRL | Qt::Key::Key_H), parent);
    connect(visibilityShortcut, &QShortcut::activated, this, &QmitkSegmentationView::OnVisibilityShortcutActivated);
    QShortcut* labelToggleShortcut = new QShortcut(QKeySequence(Qt::CTRL | Qt::Key::Key_L, Qt::CTRL | Qt::Key::Key_I), 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 Lasso Fill Erase Close Paint Wipe 'Region Growing' 'Live Wire'");
    QString segTools3D = tr("Threshold 'UL Threshold' Otsu 'Region Growing 3D' Picking GrowCut");
 
 #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);
    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->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->multiLabelWidget, &QmitkMultiLabelManager::CurrentSelectionChanged, this, &QmitkSegmentationView::OnCurrentLabelSelectionChanged);
    connect(m_Controls->multiLabelWidget, &QmitkMultiLabelManager::GoToLabel, this, &QmitkSegmentationView::OnGoToLabel);
    connect(m_Controls->multiLabelWidget, &QmitkMultiLabelManager::LabelRenameRequested, this, &QmitkSegmentationView::OnLabelRenameRequested);
 
    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::ActiveToolChanged()
 {
   if (nullptr == m_RenderWindowPart)
   {
     return;
   }
 
   mitk::TimeGeometry* interactionReferenceGeometry = nullptr;
   auto activeTool = m_ToolManager->GetActiveTool();
   if (nullptr != activeTool && m_ReferenceNode.IsNotNull())
   {
     mitk::Image::ConstPointer referenceImage = dynamic_cast<mitk::Image *>(m_ReferenceNode->GetData());
     if (referenceImage.IsNotNull())
     {
       // tool activated, reference image available: set reference geometry
       interactionReferenceGeometry = m_ReferenceNode->GetData()->GetTimeGeometry();
     }
   }
 
   // set the interaction reference geometry for the render window part (might be nullptr)
   m_RenderWindowPart->SetInteractionReferenceGeometry(interactionReferenceGeometry);
 }
 
 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;
   }
 
   if (nullptr != m_RenderWindowPart)
   {
     auto all2DWindows = Get2DWindows(m_RenderWindowPart->GetQmitkRenderWindows().values());
     m_Controls->slicesInterpolator->Initialize(m_ToolManager, all2DWindows);
 
     if (!m_RenderWindowPart->HasCoupledRenderWindows())
     {
       // react if the active tool changed, only if a render window part with decoupled render windows is used
       m_ToolManager->ActiveToolChanged +=
         mitk::MessageDelegate<QmitkSegmentationView>(this, &QmitkSegmentationView::ActiveToolChanged);
     }
   }
 }
 
 void QmitkSegmentationView::RenderWindowPartDeactivated(mitk::IRenderWindowPart* /*renderWindowPart*/)
 {
   m_RenderWindowPart = nullptr;
   if (nullptr != m_Parent)
   {
     m_Parent->setEnabled(false);
   }
 
   // remove message-connection to make sure no message is processed if no render window part is available
   m_ToolManager->ActiveToolChanged -=
     mitk::MessageDelegate<QmitkSegmentationView>(this, &QmitkSegmentationView::ActiveToolChanged);
 
   m_Controls->slicesInterpolator->Uninitialize();
 }
 
 void QmitkSegmentationView::RenderWindowPartInputChanged(mitk::IRenderWindowPart* /*renderWindowPart*/)
 {
   if (nullptr == m_RenderWindowPart)
   {
     return;
   }
 
   m_Controls->slicesInterpolator->Uninitialize();
   auto all2DWindows = Get2DWindows(m_RenderWindowPart->GetQmitkRenderWindows().values());
   m_Controls->slicesInterpolator->Initialize(m_ToolManager, all2DWindows);
 }
 
 void QmitkSegmentationView::OnPreferencesChanged(const mitk::IPreferences* prefs)
 {
   auto labelSuggestions = mitk::BaseApplication::instance().config().getString(mitk::BaseApplication::ARG_SEGMENTATION_LABEL_SUGGESTIONS.toStdString(), "");
 
   m_DefaultLabelNaming = labelSuggestions.empty()
     ? prefs->GetBool("default label naming", true)
     : false; // No default label naming when label suggestions are enforced via command-line argument
 
   if (nullptr != m_Controls)
   {
     m_Controls->multiLabelWidget->SetDefaultLabelNaming(m_DefaultLabelNaming);
 
-    bool slimView = prefs->GetBool("slim view", false);
-    m_Controls->toolSelectionBox2D->SetShowNames(!slimView);
-    m_Controls->toolSelectionBox3D->SetShowNames(!slimView);
+    bool compactView = prefs->GetBool("compact view", false);
+    int numberOfColumns = compactView ? 6 : 4;
+
+    m_Controls->toolSelectionBox2D->SetLayoutColumns(numberOfColumns);
+    m_Controls->toolSelectionBox2D->SetShowNames(!compactView);
+
+    m_Controls->toolSelectionBox3D->SetLayoutColumns(numberOfColumns);
+    m_Controls->toolSelectionBox3D->SetShowNames(!compactView);
   }
 
   m_DrawOutline = prefs->GetBool("draw outline", true);
   m_SelectionMode = prefs->GetBool("selection mode", false);
 
   m_LabelSetPresetPreference = QString::fromStdString(prefs->Get("label set preset", ""));
 
   this->ApplyDisplayOptions();
   this->ApplySelectionMode();
 }
 
 void QmitkSegmentationView::NodeAdded(const mitk::DataNode* node)
 {
   if (m_SegmentationPredicate->CheckNode(node))
     this->ApplyDisplayOptions(const_cast<mitk::DataNode*>(node));
 
   this->ApplySelectionMode();
 }
 
 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::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)
   {
     return;
   }
 
   // the 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
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkSegmentationView::ApplySelectionMode()
 {
   if (!m_SelectionMode)
     return;
 
   this->ApplySelectionModeOnReferenceNode();
   this->ApplySelectionModeOnWorkingNode();
 }
 
 void QmitkSegmentationView::ApplySelectionModeOnReferenceNode()
 {
   this->ApplySelectionMode(m_ReferenceNode, m_ReferencePredicate);
 }
 
 void QmitkSegmentationView::ApplySelectionModeOnWorkingNode()
 {
   this->ApplySelectionMode(m_WorkingNode, m_SegmentationPredicate);
 }
 
 void QmitkSegmentationView::ApplySelectionMode(mitk::DataNode* node, mitk::NodePredicateBase* predicate)
 {
   if (!m_SelectionMode || node == nullptr || predicate == nullptr)
     return;
 
   auto nodes = this->GetDataStorage()->GetSubset(predicate);
 
   for (auto iter = nodes->begin(); iter != nodes->end(); ++iter)
     (*iter)->SetVisibility(*iter == node);
 }
 
 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->ValidateSelectionInput();
 }
 
 void QmitkSegmentationView::ValidateSelectionInput()
 {
   auto referenceNode = m_Controls->referenceNodeSelector->GetSelectedNode();
   auto workingNode = m_Controls->workingNodeSelector->GetSelectedNode();
 
   bool hasReferenceNode = referenceNode.IsNotNull();
   bool hasWorkingNode = workingNode.IsNotNull();
   bool hasBothNodes = hasReferenceNode && hasWorkingNode;
 
   QString warning;
   bool toolSelectionBoxesEnabled = hasReferenceNode && hasWorkingNode;
   unsigned int numberOfLabels = 0;
 
   m_Controls->multiLabelWidget->setEnabled(hasWorkingNode);
 
   m_Controls->toolSelectionBox2D->setEnabled(hasBothNodes);
   m_Controls->toolSelectionBox3D->setEnabled(hasBothNodes);
 
   m_Controls->slicesInterpolator->setEnabled(false);
   m_Controls->interpolatorWarningLabel->hide();
 
   if (hasReferenceNode)
   {
     if (nullptr != m_RenderWindowPart && m_RenderWindowPart->HasCoupledRenderWindows() && !referenceNode->IsVisible(nullptr))
     {
       warning += tr("The selected reference image is currently not visible!");
       toolSelectionBoxesEnabled = false;
     }
   }
 
   if (hasWorkingNode)
   {
     if (nullptr != m_RenderWindowPart && m_RenderWindowPart->HasCoupledRenderWindows() && !workingNode->IsVisible(nullptr))
     {
       warning += (!warning.isEmpty() ? "<br>" : "") + tr("The selected segmentation is currently not visible!");
       toolSelectionBoxesEnabled = false;
     }
 
     m_ToolManager->SetReferenceData(referenceNode);
     m_ToolManager->SetWorkingData(workingNode);
     m_Controls->multiLabelWidget->setEnabled(true);
     m_Controls->toolSelectionBox2D->setEnabled(true);
     m_Controls->toolSelectionBox3D->setEnabled(true);
 
     auto labelSetImage = dynamic_cast<mitk::LabelSetImage *>(workingNode->GetData());
     auto activeLayer = labelSetImage->GetActiveLayer();
     numberOfLabels = labelSetImage->GetNumberOfLabels(activeLayer);
 
     if (numberOfLabels > 0)
       m_Controls->slicesInterpolator->setEnabled(true);
 
     m_Controls->multiLabelWidget->SetMultiLabelSegmentation(dynamic_cast<mitk::LabelSetImage*>(workingNode->GetData()));
   }
   else
   {
     m_Controls->multiLabelWidget->SetMultiLabelSegmentation(nullptr);
   }
 
   toolSelectionBoxesEnabled &= numberOfLabels > 0;
 
   // Here we need to check whether the geometry of the selected segmentation image (working image geometry)
   // is aligned with the geometry of the 3D render window.
   // It is not allowed to use a geometry different from the working image geometry for segmenting.
   // We only need to this if the tool selection box would be enabled without this check.
   // Additionally this check only has to be performed for render window parts with coupled render windows.
   // For different render window parts the user is given the option to reinitialize each render window individually
   // (see QmitkRenderWindow::ShowOverlayMessage).
   if (toolSelectionBoxesEnabled && nullptr != m_RenderWindowPart && m_RenderWindowPart->HasCoupledRenderWindows())
   {
     const mitk::BaseGeometry* workingNodeGeometry = workingNode->GetData()->GetGeometry();
     const mitk::BaseGeometry* renderWindowGeometry =
       m_RenderWindowPart->GetQmitkRenderWindow("3d")->GetSliceNavigationController()->GetCurrentGeometry3D();
     if (nullptr != workingNodeGeometry && nullptr != renderWindowGeometry)
     {
       if (!mitk::Equal(*workingNodeGeometry->GetBoundingBox(), *renderWindowGeometry->GetBoundingBox(), mitk::eps, true))
       {
         warning += (!warning.isEmpty() ? "<br>" : "") + tr("Please reinitialize the selected segmentation image!");
         toolSelectionBoxesEnabled = false;
       }
     }
   }
 
   m_Controls->toolSelectionBox2D->setEnabled(toolSelectionBoxesEnabled);
   m_Controls->toolSelectionBox3D->setEnabled(toolSelectionBoxesEnabled);
 
   this->UpdateWarningLabel(warning);
 
   m_ToolManager->SetReferenceData(referenceNode);
   m_ToolManager->SetWorkingData(workingNode);
 }
 
 void QmitkSegmentationView::UpdateWarningLabel(QString text)
 {
   if (text.isEmpty())
   {
     m_Controls->selectionWarningLabel->hide();
   }
   else
   {
     m_Controls->selectionWarningLabel->setText("<font color=\"red\">" + text + "</font>");
     m_Controls->selectionWarningLabel->show();
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationViewControls.ui b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationViewControls.ui
index 54eae24ca6..3dfa36dc28 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationViewControls.ui
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationViewControls.ui
@@ -1,312 +1,317 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkSegmentationViewControls</class>
  <widget class="QWidget" name="QmitkSegmentationViewControls">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>300</width>
+    <width>326</width>
     <height>600</height>
    </rect>
   </property>
   <property name="sizePolicy">
    <sizepolicy hsizetype="Minimum" vsizetype="Minimum">
     <horstretch>0</horstretch>
     <verstretch>0</verstretch>
    </sizepolicy>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout">
    <item>
     <widget class="QGroupBox" name="groupBox">
      <property name="sizePolicy">
-      <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
+      <sizepolicy hsizetype="Minimum" vsizetype="Maximum">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <property name="title">
       <string>Data selection</string>
      </property>
      <layout class="QGridLayout" name="gridLayout">
       <item row="0" column="0">
        <widget class="QLabel" name="referenceNodeLabel">
+        <property name="sizePolicy">
+         <sizepolicy hsizetype="Maximum" vsizetype="Preferred">
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
+        </property>
         <property name="text">
-         <string>Selected image</string>
+         <string>Image</string>
+        </property>
+        <property name="textFormat">
+         <enum>Qt::PlainText</enum>
         </property>
        </widget>
       </item>
       <item row="0" column="1">
        <widget class="QmitkSingleNodeSelectionWidget" name="referenceNodeSelector" native="true">
         <property name="minimumSize">
          <size>
           <width>0</width>
           <height>40</height>
          </size>
         </property>
        </widget>
       </item>
       <item row="1" column="0">
        <widget class="QLabel" name="workingNodeLabel">
+        <property name="sizePolicy">
+         <sizepolicy hsizetype="Maximum" vsizetype="Preferred">
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
+        </property>
         <property name="text">
-         <string>Selected segmentation</string>
+         <string>Segmentation</string>
+        </property>
+        <property name="textFormat">
+         <enum>Qt::PlainText</enum>
         </property>
        </widget>
       </item>
       <item row="1" column="1">
        <widget class="QmitkSingleNodeSelectionWidget" name="workingNodeSelector" native="true">
         <property name="minimumSize">
          <size>
           <width>0</width>
           <height>40</height>
          </size>
         </property>
        </widget>
       </item>
       <item row="1" column="2">
        <widget class="QToolButton" name="newSegmentationButton">
         <property name="toolTip">
          <string>Create a new segmentation</string>
         </property>
         <property name="text">
          <string>...</string>
         </property>
         <property name="icon">
          <iconset>
           <normaloff>:/Qmitk/NewSegmentation_48x48.png</normaloff>:/Qmitk/NewSegmentation_48x48.png</iconset>
         </property>
         <property name="iconSize">
          <size>
           <width>28</width>
           <height>28</height>
          </size>
         </property>
         <property name="autoRaise">
          <bool>true</bool>
         </property>
        </widget>
       </item>
       <item row="2" column="0" colspan="3">
        <widget class="QLabel" name="selectionWarningLabel">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="wordWrap">
          <bool>true</bool>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <widget class="QmitkMultiLabelManager" name="multiLabelWidget" native="true">
      <property name="sizePolicy">
-      <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
+      <sizepolicy hsizetype="Minimum" vsizetype="Maximum">
        <horstretch>0</horstretch>
-       <verstretch>0</verstretch>
+       <verstretch>1</verstretch>
       </sizepolicy>
      </property>
     </widget>
    </item>
    <item>
     <widget class="QTabWidget" name="tabWidgetSegmentationTools">
      <property name="sizePolicy">
-      <sizepolicy hsizetype="Preferred" vsizetype="Maximum">
+      <sizepolicy hsizetype="Preferred" vsizetype="Expanding">
        <horstretch>0</horstretch>
-       <verstretch>0</verstretch>
+       <verstretch>4</verstretch>
       </sizepolicy>
      </property>
      <property name="styleSheet">
       <string notr="true">QTabWidget::tab-bar { alignment: middle; }</string>
      </property>
      <property name="currentIndex">
       <number>0</number>
      </property>
      <widget class="QWidget" name="tab2DTools">
       <attribute name="title">
        <string>2D tools</string>
       </attribute>
       <layout class="QVBoxLayout" name="verticalLayout2D">
        <item>
         <widget class="QmitkToolGUIArea" name="toolGUIArea2D" native="true">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Minimum" vsizetype="Minimum">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="font">
           <font>
            <weight>50</weight>
            <bold>false</bold>
           </font>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QmitkToolSelectionBox" name="toolSelectionBox2D" native="true">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="font">
           <font>
            <weight>50</weight>
            <bold>false</bold>
           </font>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QLabel" name="interpolatorWarningLabel">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="text">
           <string/>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QmitkSlicesInterpolator" name="slicesInterpolator" native="true">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="font">
           <font>
            <weight>50</weight>
            <bold>false</bold>
           </font>
          </property>
         </widget>
        </item>
        <item>
         <spacer name="verticalSpacer2D">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
-           <width>20</width>
-           <height>40</height>
+           <width>0</width>
+           <height>0</height>
           </size>
          </property>
         </spacer>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="tab3DTools">
       <attribute name="title">
        <string>3D tools</string>
       </attribute>
       <layout class="QVBoxLayout" name="verticalLayout3D">
        <item>
         <widget class="QmitkToolGUIArea" name="toolGUIArea3D" native="true">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Minimum" vsizetype="Minimum">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="font">
           <font>
            <weight>50</weight>
            <bold>false</bold>
           </font>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QmitkToolSelectionBox" name="toolSelectionBox3D" native="true">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Minimum" vsizetype="Minimum">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="font">
           <font>
            <weight>50</weight>
            <bold>false</bold>
           </font>
          </property>
         </widget>
        </item>
        <item>
         <spacer name="verticalSpacer3D">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
-           <width>20</width>
-           <height>40</height>
+           <width>0</width>
+           <height>0</height>
           </size>
          </property>
         </spacer>
        </item>
       </layout>
      </widget>
     </widget>
    </item>
-   <item>
-    <spacer name="verticalSpacer">
-     <property name="orientation">
-      <enum>Qt::Vertical</enum>
-     </property>
-     <property name="sizeHint" stdset="0">
-      <size>
-       <width>20</width>
-       <height>40</height>
-      </size>
-     </property>
-    </spacer>
-   </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>QmitkSingleNodeSelectionWidget</class>
    <extends>QWidget</extends>
    <header location="global">QmitkSingleNodeSelectionWidget.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>QmitkToolSelectionBox</class>
    <extends>QWidget</extends>
    <header location="global">QmitkToolSelectionBox.h</header>
   </customwidget>
   <customwidget>
    <class>QmitkToolGUIArea</class>
    <extends>QWidget</extends>
    <header location="global">QmitkToolGUIArea.h</header>
   </customwidget>
   <customwidget>
    <class>QmitkSlicesInterpolator</class>
    <extends>QWidget</extends>
    <header location="global">QmitkSlicesInterpolator.h</header>
   </customwidget>
   <customwidget>
    <class>QmitkMultiLabelManager</class>
    <extends>QWidget</extends>
    <header>QmitkMultiLabelManager.h</header>
    <container>1</container>
   </customwidget>
  </customwidgets>
  <resources>
   <include location="../../resources/segmentation.qrc"/>
  </resources>
  <connections/>
 </ui>