diff --git a/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUI.cpp b/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUI.cpp
index 16a8c9c2e5..ebfddf58d0 100644
--- a/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUI.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUI.cpp
@@ -1,444 +1,456 @@
 /*============================================================================
 
 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 "QmitknnUNetToolGUI.h"
 
 #include "mitknnUnetTool.h"
 #include <QApplication>
 #include <QDir>
 #include <QIcon>
 #include <QtGlobal>
 
 MITK_TOOL_GUI_MACRO(MITKSEGMENTATIONUI_EXPORT, QmitknnUNetToolGUI, "")
 
 QmitknnUNetToolGUI::QmitknnUNetToolGUI() : QmitkAutoMLSegmentationToolGUIBase()
 {
   // Nvidia-smi command returning zero doesn't alway mean lack of GPUs.
   // Pytorch uses its own libraries to communicate to the GPUs. Hence, only a warning can be given.
   if (m_GpuLoader.GetGPUCount() == 0)
   {
     std::string warning = "WARNING: No GPUs were detected on your machine. The nnUNet tool might not work.";
     ShowErrorMessage(warning);
   }
 
   // define predicates for multi modal data selection combobox
   auto imageType = mitk::TNodePredicateDataType<mitk::Image>::New();
   auto labelSetImageType = mitk::NodePredicateNot::New(mitk::TNodePredicateDataType<mitk::LabelSetImage>::New());
   this->m_MultiModalPredicate = mitk::NodePredicateAnd::New(imageType, labelSetImageType).GetPointer();
 }
 
 void QmitknnUNetToolGUI::ConnectNewTool(mitk::AutoSegmentationWithPreviewTool *newTool)
 {
   Superclass::ConnectNewTool(newTool);
   newTool->IsTimePointChangeAwareOff();
 }
 
 void QmitknnUNetToolGUI::InitializeUI(QBoxLayout *mainLayout)
 {
   m_Controls.setupUi(this);
 #ifndef _WIN32
   m_Controls.pythonEnvComboBox->addItem("/usr/bin");
 #endif
   m_Controls.pythonEnvComboBox->addItem("Select");
   AutoParsePythonPaths();
   connect(m_Controls.previewButton, SIGNAL(clicked()), this, SLOT(OnPreviewRequested()));
   connect(m_Controls.modeldirectoryBox,
           SIGNAL(directoryChanged(const QString &)),
           this,
           SLOT(OnDirectoryChanged(const QString &)));
   connect(
     m_Controls.modelBox, SIGNAL(currentTextChanged(const QString &)), this, SLOT(OnModelChanged(const QString &)));
   connect(m_Controls.taskBox, SIGNAL(currentTextChanged(const QString &)), this, SLOT(OnTaskChanged(const QString &)));
   connect(
     m_Controls.plannerBox, SIGNAL(currentTextChanged(const QString &)), this, SLOT(OnTrainerChanged(const QString &)));
   connect(m_Controls.nopipBox, SIGNAL(stateChanged(int)), this, SLOT(OnCheckBoxChanged(int)));
   connect(m_Controls.multiModalBox, SIGNAL(stateChanged(int)), this, SLOT(OnCheckBoxChanged(int)));
   connect(m_Controls.multiModalSpinBox, SIGNAL(valueChanged(int)), this, SLOT(OnModalitiesNumberChanged(int)));
   connect(m_Controls.posSpinBox, SIGNAL(valueChanged(int)), this, SLOT(OnModalPositionChanged(int)));
   connect(m_Controls.pythonEnvComboBox,
 #if QT_VERSION >= 0x050F00 // 5.15
           SIGNAL(textActivated(const QString &)),
 #elif QT_VERSION >= 0x050C00 // 5.12
           SIGNAL(activated(const QString &)),
 #endif
           this,
           SLOT(OnPythonPathChanged(const QString &)));
   connect(m_Controls.refreshdirectoryBox, SIGNAL(clicked()), this, SLOT(OnRefreshPresssed()));
   connect(m_Controls.clearCacheButton, SIGNAL(clicked()), this, SLOT(OnClearCachePressed()));
 
   m_Controls.codedirectoryBox->setVisible(false);
   m_Controls.nnUnetdirLabel->setVisible(false);
   m_Controls.multiModalSpinBox->setVisible(false);
   m_Controls.multiModalSpinLabel->setVisible(false);
   m_Controls.posSpinBoxLabel->setVisible(false);
   m_Controls.posSpinBox->setVisible(false);
   m_Controls.previewButton->setEnabled(false);
 
   QSize sz(16, 16);
   m_Controls.stopButton->setVisible(false);
 
   QIcon refreshIcon;
   refreshIcon.addPixmap(style()->standardIcon(QStyle::SP_BrowserReload).pixmap(sz), QIcon::Normal, QIcon::Off);
   m_Controls.refreshdirectoryBox->setIcon(refreshIcon);
   m_Controls.refreshdirectoryBox->setEnabled(true);
 
   m_Controls.statusLabel->setTextFormat(Qt::RichText);
-  ShowStatusMessage(QString("<b>STATUS: </b><i>Welcome to nnUNet. " + QString::number(m_GpuLoader.GetGPUCount()) +
-                            " GPUs were detected.</i>"));
   if (m_GpuLoader.GetGPUCount() != 0)
   {
     m_Controls.gpuSpinBox->setMaximum(m_GpuLoader.GetGPUCount() - 1);
+    WriteStatusMessage(QString("<b>STATUS: </b><i>Welcome to nnUNet. " + QString::number(m_GpuLoader.GetGPUCount()) +
+                            " GPUs were detected.</i>"));
+  }
+  else
+  {
+    WriteErrorMessage(QString("<b>STATUS: </b><i>Welcome to nnUNet. " + QString::number(m_GpuLoader.GetGPUCount()) +
+                            " GPUs were detected.</i>"));
   }
   mainLayout->addLayout(m_Controls.verticalLayout);
   Superclass::InitializeUI(mainLayout);
   m_UI_ROWS = m_Controls.advancedSettingsLayout->rowCount(); // Must do. Row count is correct only here.
 
   if (nullptr != m_Controls.modeldirectoryBox)
   {
     QString setVal = m_Settings.value("nnUNet/LastRESULTS_FOLDERPath").toString();
     m_Controls.modeldirectoryBox->setDirectory(setVal);
   }
 }
 
 void QmitknnUNetToolGUI::OnPreviewRequested()
 {
   mitk::nnUNetTool::Pointer tool = this->GetConnectedToolAs<mitk::nnUNetTool>();
   if (nullptr != tool)
   {
     try
     {
       size_t hashKey(0);
       m_Controls.previewButton->setEnabled(false); // To prevent misclicked back2back prediction.
       qApp->processEvents();
       tool->PredictOn(); // purposefully placed to make tool->GetMTime different than before.
       QString modelName = m_Controls.modelBox->currentText();
       if (modelName.startsWith("ensemble", Qt::CaseInsensitive))
       {
         ProcessEnsembleModelsParams(tool);
       }
       else
       {
         ProcessModelParams(tool);
       }
       QString pythonPathTextItem = m_Controls.pythonEnvComboBox->currentText();
       QString pythonPath = pythonPathTextItem.mid(pythonPathTextItem.indexOf(" ") + 1);
       bool isNoPip = m_Controls.nopipBox->isChecked();
 #ifdef _WIN32
       if (!isNoPip && !(pythonPath.endsWith("Scripts", Qt::CaseInsensitive) ||
                         pythonPath.endsWith("Scripts/", Qt::CaseInsensitive)))
       {
         pythonPath += QDir::separator() + QString("Scripts");
       }
 #else
       if (!(pythonPath.endsWith("bin", Qt::CaseInsensitive) || pythonPath.endsWith("bin/", Qt::CaseInsensitive)))
       {
         pythonPath += QDir::separator() + QString("bin");
       }
 #endif
       std::string nnUNetDirectory;
       if (isNoPip)
       {
         nnUNetDirectory = m_Controls.codedirectoryBox->directory().toStdString();
       }
       else if (!IsNNUNetInstalled(pythonPath))
       {
         throw std::runtime_error("nnUNet is not detected in the selected python environment. Please select a valid "
                                  "python environment or install nnUNet.");
       }
 
       tool->SetnnUNetDirectory(nnUNetDirectory);
       tool->SetPythonPath(pythonPath.toStdString());
       tool->SetModelDirectory(m_ParentFolder->getResultsFolder().toStdString());
       // checkboxes
       tool->SetMirror(m_Controls.mirrorBox->isChecked());
       tool->SetMixedPrecision(m_Controls.mixedPrecisionBox->isChecked());
       tool->SetNoPip(isNoPip);
       tool->SetMultiModal(m_Controls.multiModalBox->isChecked());
       bool doCache = m_Controls.enableCachingCheckBox->isChecked();
       // Spinboxes
       tool->SetGpuId(static_cast<unsigned int>(m_Controls.gpuSpinBox->value()));
       // Multi-Modal
       tool->MultiModalOff();
       if (m_Controls.multiModalBox->isChecked())
       {
         tool->m_OtherModalPaths.clear();
         tool->m_OtherModalPaths = FetchMultiModalImagesFromUI();
         tool->MultiModalOn();
       }
       if (doCache)
       {
         hashKey = nnUNetCache::GetUniqueHash(tool->m_ParamQ);
         if (this->m_Cache.contains(hashKey))
         {
           tool->PredictOff(); // purposefully placed to make tool->GetMTime different than before.
         }
       }
       if (tool->GetPredict())
       {
         tool->m_InputBuffer = nullptr;
-        ShowStatusMessage(QString("<b>STATUS: </b><i>Starting Segmentation task... This might take a while.</i>"));
+        WriteStatusMessage(QString("<b>STATUS: </b><i>Starting Segmentation task... This might take a while.</i>"));
         tool->UpdatePreview();
         if (nullptr == tool->GetOutputBuffer())
         {
           SegmentationProcessFailed();
         }
         else
         {
           SegmentationResultHandler(tool);
           if (doCache)
           {
             AddToCache(hashKey, tool->GetMLPreview());
           }
         }
         tool->PredictOff(); // purposefully placed to make tool->GetMTime different than before.
       }
       else
       {
         MITK_INFO << "won't do segmentation. Key found: " << QString::number(hashKey).toStdString();
         if (this->m_Cache.contains(hashKey))
         {
           nnUNetCache *cacheObject = this->m_Cache[hashKey];
           MITK_INFO << "fetched pointer " << cacheObject->m_SegCache.GetPointer();
           tool->SetNodeProperties(const_cast<mitk::LabelSetImage *>(cacheObject->m_SegCache.GetPointer()));
           SegmentationResultHandler(tool);
         }
       }
       m_Controls.previewButton->setEnabled(true);
     }
     catch (const std::exception &e)
     {
       std::stringstream errorMsg;
       errorMsg << "Error while processing parameters for nnUNet segmentation. Reason: " << e.what();
       ShowErrorMessage(errorMsg.str());
-      ShowStatusMessage(QString::fromStdString(errorMsg.str()));
+      WriteErrorMessage(QString::fromStdString(errorMsg.str()));
       m_Controls.previewButton->setEnabled(true);
       tool->PredictOff();
       return;
     }
     catch (...)
     {
       std::string errorMsg = "Unkown error occured while generation nnUNet segmentation.";
       ShowErrorMessage(errorMsg);
       m_Controls.previewButton->setEnabled(true);
       tool->PredictOff();
       return;
     }
   }
 }
 
 std::vector<mitk::Image::ConstPointer> QmitknnUNetToolGUI::FetchMultiModalImagesFromUI()
 {
   std::vector<mitk::Image::ConstPointer> paths;
   if (m_Controls.multiModalBox->isChecked() && !m_Modalities.empty())
   {
     for (QmitkDataStorageComboBox *modality : m_Modalities)
     {
       if (modality->objectName() != "multiModal_0")
       {
         paths.push_back(dynamic_cast<const mitk::Image *>(modality->GetSelectedNode()->GetData()));
       }
     }
   }
   return paths;
 }
 
 bool QmitknnUNetToolGUI::IsNNUNetInstalled(const QString &pythonPath)
 {
   QString fullPath = pythonPath;
 #ifdef _WIN32
   if (!(fullPath.endsWith("Scripts", Qt::CaseInsensitive) || fullPath.endsWith("Scripts/", Qt::CaseInsensitive)))
   {
     fullPath += QDir::separator() + QString("Scripts");
   }
 #else
   if (!(fullPath.endsWith("bin", Qt::CaseInsensitive) || fullPath.endsWith("bin/", Qt::CaseInsensitive)))
   {
     fullPath += QDir::separator() + QString("bin");
   }
 #endif
   fullPath = fullPath.mid(fullPath.indexOf(" ") + 1);
   return QFile::exists(fullPath + QDir::separator() + QString("nnUNet_predict"));
 }
 
 void QmitknnUNetToolGUI::ShowErrorMessage(const std::string &message, QMessageBox::Icon icon)
 {
   this->setCursor(Qt::ArrowCursor);
   QMessageBox *messageBox = new QMessageBox(icon, nullptr, message.c_str());
   messageBox->exec();
   delete messageBox;
   MITK_WARN << message;
 }
 
-void QmitknnUNetToolGUI::ShowStatusMessage(const QString &message)
+void QmitknnUNetToolGUI::WriteStatusMessage(const QString &message)
+{
+  m_Controls.statusLabel->setText(message);
+  m_Controls.statusLabel->setStyleSheet("font-weight: bold; color: white");
+}
+
+void QmitknnUNetToolGUI::WriteErrorMessage(const QString &message)
 {
   m_Controls.statusLabel->setText(message);
+  m_Controls.statusLabel->setStyleSheet("font-weight: bold; color: red");
 }
 
 void QmitknnUNetToolGUI::ProcessEnsembleModelsParams(mitk::nnUNetTool::Pointer tool)
 {
   if (m_EnsembleParams[0]->modelBox->currentText() == m_EnsembleParams[1]->modelBox->currentText())
   {
     throw std::runtime_error("Both models you have selected for ensembling are the same.");
   }
   QString taskName = m_Controls.taskBox->currentText();
   bool isPPJson = m_Controls.postProcessingCheckBox->isChecked();
   std::vector<mitk::ModelParams> requestQ;
   QString ppDirFolderNamePart1 = "ensemble_";
   QStringList ppDirFolderNameParts;
   for (std::unique_ptr<QmitknnUNetTaskParamsUITemplate> &layout : m_EnsembleParams)
   {
     QStringList ppDirFolderName;
     QString modelName = layout->modelBox->currentText();
     ppDirFolderName << modelName;
     ppDirFolderName << "__";
     QString trainer = layout->trainerBox->currentText();
     ppDirFolderName << trainer;
     ppDirFolderName << "__";
     QString planId = layout->plannerBox->currentText();
     ppDirFolderName << planId;
 
     if (!IsModelExists(modelName, taskName, QString(trainer + "__" + planId)))
     {
       std::string errorMsg = "The configuration " + modelName.toStdString() +
                              " you have selected doesn't exist. Check your Results Folder again.";
       throw std::runtime_error(errorMsg);
     }
     std::vector<std::string> testfold = FetchSelectedFoldsFromUI(layout->foldBox);
     mitk::ModelParams modelObject = MapToRequest(modelName, taskName, trainer, planId, testfold);
     requestQ.push_back(modelObject);
     ppDirFolderNameParts << ppDirFolderName.join(QString(""));
   }
   tool->EnsembleOn();
   if (isPPJson)
   {
     QString ppJsonFilePossibility1 = QDir::cleanPath(
       m_ParentFolder->getResultsFolder() + QDir::separator() + "nnUNet" + QDir::separator() + "ensembles" +
       QDir::separator() + taskName + QDir::separator() + ppDirFolderNamePart1 + ppDirFolderNameParts.first() + "--" +
       ppDirFolderNameParts.last() + QDir::separator() + "postprocessing.json");
     QString ppJsonFilePossibility2 = QDir::cleanPath(
       m_ParentFolder->getResultsFolder() + QDir::separator() + "nnUNet" + QDir::separator() + "ensembles" +
       QDir::separator() + taskName + QDir::separator() + ppDirFolderNamePart1 + ppDirFolderNameParts.last() + "--" +
       ppDirFolderNameParts.first() + QDir::separator() + "postprocessing.json");
 
     if (QFile(ppJsonFilePossibility1).exists())
     {
       tool->SetPostProcessingJsonDirectory(ppJsonFilePossibility1.toStdString());
       const QString statusMsg = "<i>Post Processing JSON file found: </i>" + ppJsonFilePossibility1;
-      ShowStatusMessage(statusMsg);
+      WriteStatusMessage(statusMsg);
     }
     else if (QFile(ppJsonFilePossibility2).exists())
     {
       tool->SetPostProcessingJsonDirectory(ppJsonFilePossibility2.toStdString());
       const QString statusMsg = "<i>Post Processing JSON file found:</i>" + ppJsonFilePossibility2;
-      ShowStatusMessage(statusMsg);
+      WriteStatusMessage(statusMsg);
     }
     else
     {
       std::string errorMsg =
         "No post processing file was found for the selected ensemble combination. Continuing anyway...";
       ShowErrorMessage(errorMsg);
     }
   }
   tool->m_ParamQ.clear();
   tool->m_ParamQ = requestQ;
 }
 
 void QmitknnUNetToolGUI::ProcessModelParams(mitk::nnUNetTool::Pointer tool)
 {
   tool->EnsembleOff();
   std::vector<mitk::ModelParams> requestQ;
   QString modelName = m_Controls.modelBox->currentText();
   QString taskName = m_Controls.taskBox->currentText();
   QString trainer = m_Controls.trainerBox->currentText();
   QString planId = m_Controls.plannerBox->currentText();
   std::vector<std::string> fetchedFolds = FetchSelectedFoldsFromUI(m_Controls.foldBox);
   mitk::ModelParams modelObject = MapToRequest(modelName, taskName, trainer, planId, fetchedFolds);
   requestQ.push_back(modelObject);
   tool->m_ParamQ.clear();
   tool->m_ParamQ = requestQ;
 }
 
 bool QmitknnUNetToolGUI::IsModelExists(const QString &modelName, const QString &taskName, const QString &trainerPlanner)
 {
   QString modelSearchPath =
     QDir::cleanPath(m_ParentFolder->getResultsFolder() + QDir::separator() + "nnUNet" + QDir::separator() + modelName +
                     QDir::separator() + taskName + QDir::separator() + trainerPlanner);
   if (QDir(modelSearchPath).exists())
   {
     return true;
   }
   return false;
 }
 
 void QmitknnUNetToolGUI::CheckAllInCheckableComboBox(ctkCheckableComboBox *foldBox)
 {
   // Recalling all added items to check-mark it.
   const QAbstractItemModel *qaim = foldBox->checkableModel();
   // for (int i = 0; i < folds.size(); ++i)
   auto rows = qaim->rowCount();
   for (int i = 0; i < rows; ++i)
   {
     const QModelIndex mi = qaim->index(i, 0);
     foldBox->setCheckState(mi, Qt::Checked);
   }
 }
 
 std::pair<QStringList, QStringList> QmitknnUNetToolGUI::ExtractTrainerPlannerFromString(QStringList trainerPlanners)
 {
   QString splitterString = "__";
   QStringList trainers, planners;
   foreach (QString trainerPlanner, trainerPlanners)
   {
     trainers << trainerPlanner.split(splitterString, QString::SplitBehavior::SkipEmptyParts).first();
     planners << trainerPlanner.split(splitterString, QString::SplitBehavior::SkipEmptyParts).last();
   }
   trainers.removeDuplicates();
   planners.removeDuplicates();
   std::pair<QStringList, QStringList> returnPair = {trainers, planners};
   return returnPair;
 }
 
 std::vector<std::string> QmitknnUNetToolGUI::FetchSelectedFoldsFromUI(ctkCheckableComboBox *foldBox)
 {
   std::vector<std::string> folds;
   if (!(foldBox->allChecked() || foldBox->noneChecked()))
   {
     QModelIndexList foldList = foldBox->checkedIndexes();
     foreach (QModelIndex index, foldList)
     {
       QString foldQString = foldBox->itemText(index.row()).split("_", QString::SplitBehavior::SkipEmptyParts).last();
       folds.push_back(foldQString.toStdString());
     }
   }
   return folds;
 }
 
 void QmitknnUNetToolGUI::OnClearCachePressed()
 {
   m_Cache.clear();
   UpdateCacheCountOnUI();
 }
 
 void QmitknnUNetToolGUI::UpdateCacheCountOnUI()
 {
   QString cacheText = m_CACHE_COUNT_BASE_LABEL + QString::number(m_Cache.size());
   m_Controls.cacheCountLabel->setText(cacheText);
 }
 
 void QmitknnUNetToolGUI::AddToCache(size_t &hashKey, mitk::LabelSetImage::ConstPointer mlPreview)
 {
   nnUNetCache *newCacheObj = new nnUNetCache;
   newCacheObj->m_SegCache = mlPreview;
   this->m_Cache.insert(hashKey, newCacheObj);
   MITK_INFO << "New hash: " << hashKey << " " << newCacheObj->m_SegCache.GetPointer();
   UpdateCacheCountOnUI();
 }
diff --git a/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUI.h b/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUI.h
index 4ad8c42d08..3be96ba5e6 100644
--- a/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUI.h
+++ b/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUI.h
@@ -1,282 +1,287 @@
 /*============================================================================
 
 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.s
 
 ============================================================================*/
 
 #ifndef QmitknnUNetToolGUI_h_Included
 #define QmitknnUNetToolGUI_h_Included
 
 #include "QmitkAutoMLSegmentationToolGUIBase.h"
 #include "QmitknnUNetFolderParser.h"
 #include "QmitknnUNetGPU.h"
 #include "mitknnUnetTool.h"
 #include "ui_QmitknnUNetToolGUIControls.h"
 #include <MitkSegmentationUIExports.h>
 #include <QCache>
 #include <QMessageBox>
 #include <QSettings>
 #include <QmitkDataStorageComboBox.h>
 #include <QmitknnUNetEnsembleLayout.h>
 #include <boost/functional/hash.hpp>
 
 class nnUNetCache
 {
 public:
   mitk::LabelSetImage::ConstPointer m_SegCache;
   static size_t GetUniqueHash(std::vector<mitk::ModelParams> &requestQ)
   {
     size_t hashCode = 0;
     for (mitk::ModelParams &request : requestQ)
     {
       boost::hash_combine(hashCode, request.generateHash());
     }
     return hashCode;
   }
 };
 
 class MITKSEGMENTATIONUI_EXPORT QmitknnUNetToolGUI : public QmitkAutoMLSegmentationToolGUIBase
 {
   Q_OBJECT
 
 public:
   mitkClassMacro(QmitknnUNetToolGUI, QmitkAutoMLSegmentationToolGUIBase);
   itkFactorylessNewMacro(Self);
   itkCloneMacro(Self);
 
   QCache<size_t, nnUNetCache> m_Cache;
 
 protected slots:
 
   /**
    * @brief Qt slot
    *
    */
   void OnPreviewRequested();
 
   /**
    * @brief Qt slot
    *
    */
   void OnDirectoryChanged(const QString &);
 
   /**
    * @brief Qt slot
    *
    */
   void OnModelChanged(const QString &);
 
   /**
    * @brief Qt slot
    *
    */
   void OnTaskChanged(const QString &);
 
   /**
    * @brief Qt slot
    *
    */
   void OnTrainerChanged(const QString &);
 
   /**
    * @brief Qt slot
    *
    */
   void OnCheckBoxChanged(int);
 
   /**
    * @brief Qthread slot to capture failures from thread worker and
    * shows error message
    *
    */
   void SegmentationProcessFailed();
 
   /**
    * @brief Qthread to capture sucessfull nnUNet segmentation.
    * Further, renders the LabelSet image
    */
   void SegmentationResultHandler(mitk::nnUNetTool *);
 
   /**
    * @brief Qt Slot
    *
    */
   void OnModalitiesNumberChanged(int);
 
   /**
    * @brief Qt Slot
    *
    */
   void OnPythonPathChanged(const QString &);
 
   /**
    * @brief Qt Slot
    *
    */
   void OnModalPositionChanged(int);
 
   /**
    * @brief Qt slot
    *
    */
   void OnRefreshPresssed();
 
   /**
    * @brief Qt slot
    *
    */
   void OnClearCachePressed();
 
 protected:
   QmitknnUNetToolGUI();
   ~QmitknnUNetToolGUI() = default;
 
   void ConnectNewTool(mitk::AutoSegmentationWithPreviewTool *newTool) override;
   void InitializeUI(QBoxLayout *mainLayout) override;
   void EnableWidgets(bool enabled) override;
 
 private:
 
   /**
    * @brief Inserts the hash and segmentation into cache and
    * updates count on UI.
    */
   void AddToCache(size_t&, mitk::LabelSetImage::ConstPointer);
   
   /**
    * @brief Checks all the entries of the ctkCheckableComboBox ui widget.
    * This feature is not present in ctkCheckableComboBox API.
    */
   void CheckAllInCheckableComboBox(ctkCheckableComboBox *);
 
   /**
    * @brief Parses the folder names containing trainer and planner together and,
    * returns it as separate lists.
    * @return std::pair<QStringList, QStringList>
    */
 
   std::pair<QStringList, QStringList> ExtractTrainerPlannerFromString(QStringList);
   /**
    * @brief Parses the ensemble UI elements and sets to nnUNetTool object pointer.
    *
    */
   void ProcessEnsembleModelsParams(mitk::nnUNetTool::Pointer);
 
   /**
    * @brief Parses the UI elements and sets to nnUNetTool object pointer.
    *
    */
   void ProcessModelParams(mitk::nnUNetTool::Pointer);
 
   /**
    * @brief Creates and renders QmitknnUNetTaskParamsUITemplate layout for ensemble input.
    */
   void ShowEnsembleLayout(bool visible = true);
 
   /**
    * @brief Creates a QMessage object and shows on screen.
    */
   void ShowErrorMessage(const std::string &, QMessageBox::Icon = QMessageBox::Critical);
 
   /**
-   * @brief Shows any message on the tool pane.
+   * @brief Writes any message in white on the tool pane.
    */
-  void ShowStatusMessage(const QString &);
+  void WriteStatusMessage(const QString &);
+  
+  /**
+   * @brief Writes any message in red on the tool pane.
+   */
+  void WriteErrorMessage(const QString &);
 
   /**
    * @brief Searches and parses paths of python virtual enviroments
    * from predefined lookout locations
    */
   void AutoParsePythonPaths();
 
   /**
    * @brief Check if pretrained model sub folder inside RESULTS FOLDER exist.
    *
    */
   bool IsModelExists(const QString &, const QString &, const QString &);
 
   /**
    * @brief Clears all combo boxes
    * Any new combo box added in the future can be featured here for clearance.
    *
    */
   void ClearAllComboBoxes();
 
   /**
    * @brief Checks if nnUNet_predict command is valid in the selected python virtual environment.
    *
    * @return bool
    */
   bool IsNNUNetInstalled(const QString &);
 
   /**
    * @brief Mapper function to map QString entries from UI to ModelParam attributes.
    *
    * @return mitk::ModelParams
    */
   mitk::ModelParams MapToRequest(
     const QString &, const QString &, const QString &, const QString &, const std::vector<std::string> &);
 
   /**
    * @brief Returns checked fold names from the ctk-Checkable-ComboBox.
    *
    * @return std::vector<std::string>
    */
   std::vector<std::string> FetchSelectedFoldsFromUI(ctkCheckableComboBox *);
 
   /**
    * @brief Returns all paths from the dynamically generated ctk-path-line-edit boxes.
    *
    * @return std::vector<std::string>
    */
   std::vector<mitk::Image::ConstPointer> FetchMultiModalImagesFromUI();
 
   void UpdateCacheCountOnUI();
 
   Ui_QmitknnUNetToolGUIControls m_Controls;
   QmitkGPULoader m_GpuLoader;
 
   /**
    * @brief Stores all dynamically added ctk-path-line-edit UI elements.
    *
    */
   std::vector<QmitkDataStorageComboBox *> m_Modalities;
 
   std::vector<std::unique_ptr<QmitknnUNetTaskParamsUITemplate>> m_EnsembleParams;
 
   mitk::NodePredicateBase::Pointer m_MultiModalPredicate;
 
   /**
    * @brief Stores row count of the "advancedSettingsLayout" layout element. This value helps dynamically add
    * ctk-path-line-edit UI elements at the right place. Forced to initialize in the InitializeUI method since there is
    * no guarantee of retrieving exact row count anywhere else.
    *
    */
   int m_UI_ROWS;
 
   /**
    * @brief Stores path of the model director (RESULTS_FOLDER appended by "nnUNet").
    *
    */
   std::shared_ptr<QmitknnUNetFolderParser> m_ParentFolder = nullptr;
 
   /**
    * @brief Valid list of models supported by nnUNet
    *
    */
   const QStringList m_VALID_MODELS = {"2d", "3d_lowres", "3d_fullres", "3d_cascade_fullres", "ensembles"};
 
   const QString m_CACHE_COUNT_BASE_LABEL = "Cached Items: ";
 
   /**
    * @brief For storing values across sessions. Currently, RESULTS_FOLDER value is cached using this.
    */
   QSettings m_Settings;
 };
 #endif
diff --git a/Modules/SegmentationUI/Qmitk/QmitknnUNetToolSlots.cpp b/Modules/SegmentationUI/Qmitk/QmitknnUNetToolSlots.cpp
index d88312acbd..1b32637bdf 100644
--- a/Modules/SegmentationUI/Qmitk/QmitknnUNetToolSlots.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitknnUNetToolSlots.cpp
@@ -1,448 +1,448 @@
 #include "QmitknnUNetToolGUI.h"
 #include <QDir>
 #include <QDirIterator>
 #include <QmitknnUNetEnsembleLayout.h>
 #include <algorithm>
 #include <ctkCollapsibleGroupBox.h>
 
 void QmitknnUNetToolGUI::EnableWidgets(bool enabled)
 {
   Superclass::EnableWidgets(enabled);
 }
 
 void QmitknnUNetToolGUI::ClearAllComboBoxes()
 {
   m_Controls.modelBox->clear();
   m_Controls.taskBox->clear();
   m_Controls.foldBox->clear();
   m_Controls.trainerBox->clear();
   for (std::unique_ptr<QmitknnUNetTaskParamsUITemplate> &layout : m_EnsembleParams)
   {
     layout->modelBox->clear();
     layout->trainerBox->clear();
     layout->plannerBox->clear();
     layout->foldBox->clear();
   }
 }
 
 void QmitknnUNetToolGUI::OnRefreshPresssed()
 {
   const QString resultsFolder = m_Controls.modeldirectoryBox->directory();
   OnDirectoryChanged(resultsFolder);
 }
 
 void QmitknnUNetToolGUI::OnDirectoryChanged(const QString &resultsFolder)
 {
   m_Controls.previewButton->setEnabled(false);
   this->ClearAllComboBoxes();
   m_ParentFolder = std::make_shared<QmitknnUNetFolderParser>(resultsFolder);
   auto models = m_ParentFolder->getModelNames<QStringList>();
   std::for_each(models.begin(),
                 models.end(),
                 [this](QString model)
                 {
                   if (m_VALID_MODELS.contains(model, Qt::CaseInsensitive))
                     m_Controls.modelBox->addItem(model);
                 });
   m_Settings.setValue("nnUNet/LastRESULTS_FOLDERPath",resultsFolder);
 }
 
 void QmitknnUNetToolGUI::OnModelChanged(const QString &model)
 {
   if (model.isEmpty())
   {
     return;
   }
   ctkComboBox *box = qobject_cast<ctkComboBox *>(sender());
   if (box == m_Controls.modelBox)
   {
     m_Controls.taskBox->clear();
     auto tasks = m_ParentFolder->getTasksForModel<QStringList>(model);
     std::for_each(tasks.begin(), tasks.end(), [this](QString task) { m_Controls.taskBox->addItem(task); });
   }
   else if (!m_EnsembleParams.empty())
   {
     for (std::unique_ptr<QmitknnUNetTaskParamsUITemplate> &layout : m_EnsembleParams)
     {
       if (box == layout->modelBox)
       {
         layout->trainerBox->clear();
         layout->plannerBox->clear();
         QStringList trainerPlanners =
           m_ParentFolder->getTrainerPlannersForTask<QStringList>(m_Controls.taskBox->currentText(), model);
         QStringList trainers, planners;
         std::tie(trainers, planners) = ExtractTrainerPlannerFromString(trainerPlanners);
 
         std::for_each(
           trainers.begin(), trainers.end(), [&layout](QString trainer) { layout->trainerBox->addItem(trainer); });
         std::for_each(
           planners.begin(), planners.end(), [&layout](QString planner) { layout->plannerBox->addItem(planner); });
         break;
       }
     }
   }
 }
 
 void QmitknnUNetToolGUI::OnTaskChanged(const QString &task)
 {
   if (task.isEmpty())
   {
     return;
   }
   m_Controls.trainerBox->clear();
   m_Controls.plannerBox->clear();
   if (m_Controls.modelBox->currentText() == m_VALID_MODELS.last())
   {
     m_Controls.trainerBox->setVisible(false);
     m_Controls.trainerLabel->setVisible(false);
     m_Controls.plannerBox->setVisible(false);
     m_Controls.plannerLabel->setVisible(false);
     m_Controls.foldBox->setVisible(false);
     m_Controls.foldLabel->setVisible(false);
     ShowEnsembleLayout(true);
     QStringList models = m_ParentFolder->getModelsForTask<QStringList>(m_Controls.taskBox->currentText());
     models.removeDuplicates();
     models.removeOne(m_VALID_MODELS.last());
 
     for (std::unique_ptr<QmitknnUNetTaskParamsUITemplate> &layout : m_EnsembleParams)
     {
       layout->modelBox->clear();
       layout->trainerBox->clear();
       layout->plannerBox->clear();
       std::for_each(models.begin(),
                     models.end(),
                     [&layout, this](QString model)
                     {
                       if (m_VALID_MODELS.contains(model, Qt::CaseInsensitive))
                         layout->modelBox->addItem(model);
                     });
     }
     m_Controls.previewButton->setEnabled(true);
   }
   else
   {
     m_Controls.trainerBox->setVisible(true);
     m_Controls.trainerLabel->setVisible(true);
     m_Controls.plannerBox->setVisible(true);
     m_Controls.plannerLabel->setVisible(true);
     m_Controls.foldBox->setVisible(true);
     m_Controls.foldLabel->setVisible(true);
     m_Controls.previewButton->setEnabled(false);
     ShowEnsembleLayout(false);
     QStringList trainerPlanners =
       m_ParentFolder->getTrainerPlannersForTask<QStringList>(task, m_Controls.modelBox->currentText());
     QStringList trainers, planners;
     std::tie(trainers, planners) = ExtractTrainerPlannerFromString(trainerPlanners);
     std::for_each(
       trainers.begin(), trainers.end(), [this](QString trainer) { m_Controls.trainerBox->addItem(trainer); });
     std::for_each(
       planners.begin(), planners.end(), [this](QString planner) { m_Controls.plannerBox->addItem(planner); });
   }
 }
 
 void QmitknnUNetToolGUI::OnTrainerChanged(const QString &plannerSelected)
 {
   if (plannerSelected.isEmpty())
   {
     return;
   }
   ctkComboBox *box = qobject_cast<ctkComboBox *>(sender());
   if (box == m_Controls.plannerBox)
   {
     m_Controls.foldBox->clear();
     auto selectedTrainer = m_Controls.trainerBox->currentText();
     auto selectedTask = m_Controls.taskBox->currentText();
     auto selectedModel = m_Controls.modelBox->currentText();
     auto folds = m_ParentFolder->getFoldsForTrainerPlanner<QStringList>(
       selectedTrainer, plannerSelected, selectedTask, selectedModel);
     std::for_each(folds.begin(),
                   folds.end(),
                   [this](QString fold)
                   {
                     if (fold.startsWith("fold_", Qt::CaseInsensitive)) // imposed by nnUNet
                       m_Controls.foldBox->addItem(fold);
                   });
     if (m_Controls.foldBox->count() != 0)
     {
       CheckAllInCheckableComboBox(m_Controls.foldBox);
       m_Controls.previewButton->setEnabled(true);
     }
   }
   else if (!m_EnsembleParams.empty())
   {
     for (std::unique_ptr<QmitknnUNetTaskParamsUITemplate> &layout : m_EnsembleParams)
     {
       if (box == layout->plannerBox)
       {
         layout->foldBox->clear();
         auto selectedTrainer = layout->trainerBox->currentText();
         auto selectedTask = m_Controls.taskBox->currentText();
         auto selectedModel = layout->modelBox->currentText();
         auto folds = m_ParentFolder->getFoldsForTrainerPlanner<QStringList>(
           selectedTrainer, plannerSelected, selectedTask, selectedModel);
         std::for_each(folds.begin(),
                       folds.end(),
                       [&layout](QString fold)
                       {
                         if (fold.startsWith("fold_", Qt::CaseInsensitive)) // imposed by nnUNet
                           layout->foldBox->addItem(fold);
                       });
         if (layout->foldBox->count() != 0)
         {
           CheckAllInCheckableComboBox(layout->foldBox);
           m_Controls.previewButton->setEnabled(true);
         }
         break;
       }
     }
   }
 }
 
 void QmitknnUNetToolGUI::OnPythonPathChanged(const QString &pyEnv)
 {
   if (pyEnv == QString("Select"))
   {
     QString path =
       QFileDialog::getExistingDirectory(m_Controls.pythonEnvComboBox->parentWidget(), "Python Path", "dir");
     if (!path.isEmpty())
     {
       m_Controls.pythonEnvComboBox->insertItem(0, path);
       m_Controls.pythonEnvComboBox->setCurrentIndex(0);
     }
   }
   else if (!IsNNUNetInstalled(pyEnv))
   {
     std::string warning =
       "WARNING: nnUNet is not detected on the Python environment you selected. Please select another "
       "environment or create one. For more info refer https://github.com/MIC-DKFZ/nnUNet";
     ShowErrorMessage(warning);
   }
 }
 
 void QmitknnUNetToolGUI::OnCheckBoxChanged(int state)
 {
   bool visibility = false;
   if (state == Qt::Checked)
   {
     visibility = true;
   }
   ctkCheckBox *box = qobject_cast<ctkCheckBox *>(sender());
   if (box != nullptr)
   {
     if (box->objectName() == QString("nopipBox"))
     {
       m_Controls.codedirectoryBox->setVisible(visibility);
       m_Controls.nnUnetdirLabel->setVisible(visibility);
     }
     else if (box->objectName() == QString("multiModalBox"))
     {
       m_Controls.multiModalSpinLabel->setVisible(visibility);
       m_Controls.multiModalSpinBox->setVisible(visibility);
       m_Controls.posSpinBoxLabel->setVisible(visibility);
       m_Controls.posSpinBox->setVisible(visibility);
       if (visibility)
       {
         QmitkDataStorageComboBox *defaultImage = new QmitkDataStorageComboBox(this, true);
         defaultImage->setObjectName(QString("multiModal_" + QString::number(0)));
         defaultImage->SetPredicate(this->m_MultiModalPredicate);
         defaultImage->setDisabled(true);
         mitk::nnUNetTool::Pointer tool = this->GetConnectedToolAs<mitk::nnUNetTool>();
         if (tool != nullptr)
         {
           defaultImage->SetDataStorage(tool->GetDataStorage());
           defaultImage->SetSelectedNode(tool->GetRefNode());
         }
         m_Controls.advancedSettingsLayout->addWidget(defaultImage, this->m_UI_ROWS + m_Modalities.size() + 1, 1, 1, 3);
         m_Modalities.push_back(defaultImage);
         m_Controls.posSpinBox->setMaximum(this->m_Modalities.size() - 1);
         m_UI_ROWS++;
       }
       else
       {
         OnModalitiesNumberChanged(0);
         m_Controls.multiModalSpinBox->setValue(0);
         m_Controls.posSpinBox->setMaximum(0);
         delete this->m_Modalities[0];
         m_Modalities.pop_back();
       }
     }
   }
 }
 
 void QmitknnUNetToolGUI::OnModalitiesNumberChanged(int num)
 {
   while (num > static_cast<int>(this->m_Modalities.size() - 1))
   {
     QmitkDataStorageComboBox *multiModalBox = new QmitkDataStorageComboBox(this, true);
     mitk::nnUNetTool::Pointer tool = this->GetConnectedToolAs<mitk::nnUNetTool>();
     multiModalBox->SetDataStorage(tool->GetDataStorage());
     multiModalBox->SetPredicate(this->m_MultiModalPredicate);
     multiModalBox->setObjectName(QString("multiModal_" + QString::number(m_Modalities.size() + 1)));
     m_Controls.advancedSettingsLayout->addWidget(multiModalBox, this->m_UI_ROWS + m_Modalities.size() + 1, 1, 1, 3);
     m_Modalities.push_back(multiModalBox);
   }
   while (num < static_cast<int>(this->m_Modalities.size() - 1) && !m_Modalities.empty())
   {
     QmitkDataStorageComboBox *child = m_Modalities.back();
     if (child->objectName() == "multiModal_0")
     {
       std::iter_swap(this->m_Modalities.end() - 2, this->m_Modalities.end() - 1);
       child = m_Modalities.back();
     }
     delete child; // delete the layout item
     m_Modalities.pop_back();
   }
   m_Controls.posSpinBox->setMaximum(this->m_Modalities.size() - 1);
   m_Controls.advancedSettingsLayout->update();
 }
 
 void QmitknnUNetToolGUI::OnModalPositionChanged(int posIdx)
 {
   if (posIdx < static_cast<int>(m_Modalities.size()))
   {
     int currPos = 0;
     bool stopCheck = false;
     // for-loop clears all widgets from the QGridLayout and also, finds the position of loaded-image widget.
     for (QmitkDataStorageComboBox *multiModalBox : m_Modalities)
     {
       m_Controls.advancedSettingsLayout->removeWidget(multiModalBox);
       multiModalBox->setParent(nullptr);
       if (multiModalBox->objectName() != "multiModal_0" && !stopCheck)
       {
         currPos++;
       }
       else
       {
         stopCheck = true;
       }
     }
     // moving the loaded-image widget to the required position
     std::iter_swap(this->m_Modalities.begin() + currPos, m_Modalities.begin() + posIdx);
     // re-adding all widgets in the order
     for (int i = 0; i < static_cast<int>(m_Modalities.size()); ++i)
     {
       QmitkDataStorageComboBox *multiModalBox = m_Modalities[i];
       m_Controls.advancedSettingsLayout->addWidget(multiModalBox, m_UI_ROWS + i + 1, 1, 1, 3);
     }
     m_Controls.advancedSettingsLayout->update();
   }
 }
 
 void QmitknnUNetToolGUI::AutoParsePythonPaths()
 {
   QString homeDir = QDir::homePath();
   std::vector<QString> searchDirs;
 #ifdef _WIN32
   searchDirs.push_back(QString("C:") + QDir::separator() + QString("ProgramData") + QDir::separator() +
                        QString("anaconda3"));
 #else
   // Add search locations for possible standard python paths here
   searchDirs.push_back(homeDir + QDir::separator() + "environments");
   searchDirs.push_back(homeDir + QDir::separator() + "anaconda3");
   searchDirs.push_back(homeDir + QDir::separator() + "miniconda3");
   searchDirs.push_back(homeDir + QDir::separator() + "opt" + QDir::separator() + "miniconda3");
   searchDirs.push_back(homeDir + QDir::separator() + "opt" + QDir::separator() + "anaconda3");
 #endif
   for (QString searchDir : searchDirs)
   {
     if (searchDir.endsWith("anaconda3", Qt::CaseInsensitive))
     {
       if (QDir(searchDir).exists())
       {
         m_Controls.pythonEnvComboBox->insertItem(0, "(base): " + searchDir);
         searchDir.append((QDir::separator() + QString("envs")));
       }
     }
     for (QDirIterator subIt(searchDir, QDir::AllDirs, QDirIterator::NoIteratorFlags); subIt.hasNext();)
     {
       subIt.next();
       QString envName = subIt.fileName();
       if (!envName.startsWith('.')) // Filter out irrelevent hidden folders, if any.
       {
         m_Controls.pythonEnvComboBox->insertItem(0, "(" + envName + "): " + subIt.filePath());
       }
     }
   }
   m_Controls.pythonEnvComboBox->setCurrentIndex(-1);
 }
 
 mitk::ModelParams QmitknnUNetToolGUI::MapToRequest(const QString &modelName,
                                                    const QString &taskName,
                                                    const QString &trainer,
                                                    const QString &planId,
                                                    const std::vector<std::string> &folds)
 {
   mitk::ModelParams requestObject;
   requestObject.model = modelName.toStdString();
   requestObject.trainer = trainer.toStdString();
   requestObject.planId = planId.toStdString();
   requestObject.task = taskName.toStdString();
   requestObject.folds = folds;
   mitk::nnUNetTool::Pointer tool = this->GetConnectedToolAs<mitk::nnUNetTool>();
   requestObject.inputName = tool->GetRefNode()->GetName();
   requestObject.timeStamp = std::to_string(mitk::RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint());
   return requestObject;
 }
 
 void QmitknnUNetToolGUI::SegmentationProcessFailed()
 {
-  ShowStatusMessage(
+  WriteErrorMessage(
     "<b>STATUS: </b><i>Error in the segmentation process. <br>No resulting segmentation can be loaded.</i>");
   this->setCursor(Qt::ArrowCursor);
   std::stringstream stream;
   stream << "Error in the segmentation process. No resulting segmentation can be loaded.";
   ShowErrorMessage(stream.str());
   m_Controls.stopButton->setEnabled(false);
 }
 
 void QmitknnUNetToolGUI::SegmentationResultHandler(mitk::nnUNetTool *tool)
 {
   tool->RenderOutputBuffer();
   this->SetLabelSetPreview(tool->GetMLPreview());
   //this->ClearOutputBuffer();
-  ShowStatusMessage("<b>STATUS: </b><i>Segmentation task finished successfully. <br>Please Confirm the "
+  WriteStatusMessage("<b>STATUS: </b><i>Segmentation task finished successfully. <br>Please Confirm the "
                                   "segmentation else, could result in data loss</i>");
   m_Controls.stopButton->setEnabled(false);
 }
 
 void QmitknnUNetToolGUI::ShowEnsembleLayout(bool visible)
 {
   if (m_EnsembleParams.empty())
   {
     ctkCollapsibleGroupBox *groupBoxModel1 = new ctkCollapsibleGroupBox(this);
     auto lay1 = std::make_unique<QmitknnUNetTaskParamsUITemplate>(groupBoxModel1);
     groupBoxModel1->setObjectName(QString::fromUtf8("model_1_Box"));
     groupBoxModel1->setTitle(QString::fromUtf8("Model 1"));
     groupBoxModel1->setMinimumSize(QSize(0, 0));
     groupBoxModel1->setCollapsedHeight(5);
     groupBoxModel1->setCollapsed(false);
     groupBoxModel1->setFlat(true);
     groupBoxModel1->setAlignment(Qt::AlignRight);
     m_Controls.advancedSettingsLayout->addWidget(groupBoxModel1, 4, 0, 1, 2);
 
     connect(lay1->modelBox, SIGNAL(currentTextChanged(const QString &)), this, SLOT(OnModelChanged(const QString &)));
     connect(
       lay1->plannerBox, SIGNAL(currentTextChanged(const QString &)), this, SLOT(OnTrainerChanged(const QString &)));
     m_EnsembleParams.push_back(std::move(lay1));
 
     ctkCollapsibleGroupBox *groupBoxModel2 = new ctkCollapsibleGroupBox(this);
     auto lay2 = std::make_unique<QmitknnUNetTaskParamsUITemplate>(groupBoxModel2);
     groupBoxModel2->setObjectName(QString::fromUtf8("model_2_Box"));
     groupBoxModel2->setTitle(QString::fromUtf8("Model 2"));
     groupBoxModel2->setMinimumSize(QSize(0, 0));
     groupBoxModel2->setCollapsedHeight(5);
     groupBoxModel2->setCollapsed(false);
     groupBoxModel2->setFlat(true);
     groupBoxModel2->setAlignment(Qt::AlignLeft);
     m_Controls.advancedSettingsLayout->addWidget(groupBoxModel2, 4, 2, 1, 2);
 
     connect(lay2->modelBox, SIGNAL(currentTextChanged(const QString &)), this, SLOT(OnModelChanged(const QString &)));
     connect(
       lay2->plannerBox, SIGNAL(currentTextChanged(const QString &)), this, SLOT(OnTrainerChanged(const QString &)));
     m_EnsembleParams.push_back(std::move(lay2));
   }
   for (std::unique_ptr<QmitknnUNetTaskParamsUITemplate> &layout : m_EnsembleParams)
   {
     layout->setVisible(visible);
   }
 }