diff --git a/Modules/Segmentation/Interactions/mitknnUnetTool.h b/Modules/Segmentation/Interactions/mitknnUnetTool.h
index 70223a7603..c668d0280d 100644
--- a/Modules/Segmentation/Interactions/mitknnUnetTool.h
+++ b/Modules/Segmentation/Interactions/mitknnUnetTool.h
@@ -1,200 +1,204 @@
 /*============================================================================
 
 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 mitknnUnetTool_h_Included
 #define mitknnUnetTool_h_Included
 
 #include "mitkAutoMLSegmentationWithPreviewTool.h"
 #include "mitkCommon.h"
 #include "mitkToolManager.h"
 #include <MitkSegmentationExports.h>
 #include <mitkStandardFileLocations.h>
 #include <utility>
 
 namespace us
 {
   class ModuleResource;
 }
 
 namespace mitk
 {
   /**
    * @brief nnUNet parameter request object holding all model parameters for input.
    * Also holds output temporary directory path.
    */
   struct ModelParams
   {
     std::string task;
     std::vector<std::string> folds;
     std::string model;
     std::string trainer;
     std::string planId;
-    std::string outputDir; 
+    std::string outputDir;
   };
 
   /**
     \brief nnUNet segmentation tool.
 
     \ingroup Interaction
     \ingroup ToolManagerEtAl
 
     \warning Only to be instantiated by mitk::ToolManager.
   */
   class MITKSEGMENTATION_EXPORT nnUNetTool : public AutoMLSegmentationWithPreviewTool
   {
   public:
     mitkClassMacro(nnUNetTool, AutoMLSegmentationWithPreviewTool);
     itkFactorylessNewMacro(Self);
     itkCloneMacro(Self);
 
     const char **GetXPM() const override;
     const char *GetName() const override;
     us::ModuleResource GetIconResource() const override;
 
     void Activated() override;
 
     itkSetMacro(nnUNetDirectory, std::string);
     itkGetConstMacro(nnUNetDirectory, std::string);
 
     itkSetMacro(ModelDirectory, std::string);
     itkGetConstMacro(ModelDirectory, std::string);
 
     itkSetMacro(PythonPath, std::string);
     itkGetConstMacro(PythonPath, std::string);
 
     itkSetMacro(MitkTempDir, std::string);
     itkGetConstMacro(MitkTempDir, std::string);
 
     itkSetMacro(PostProcessingJsonDirectory, std::string);
     itkGetConstMacro(PostProcessingJsonDirectory, std::string);
     /*
     itkSetMacro(UseGPU, bool);
     itkGetConstMacro(UseGPU, bool);
     itkBooleanMacro(UseGPU);
 
     itkSetMacro(AllInGPU, bool);
     itkGetConstMacro(AllInGPU, bool);
     itkBooleanMacro(AllInGPU);
     */
     itkSetMacro(MixedPrecision, bool);
     itkGetConstMacro(MixedPrecision, bool);
     itkBooleanMacro(MixedPrecision);
 
     itkSetMacro(Mirror, bool);
     itkGetConstMacro(Mirror, bool);
     itkBooleanMacro(Mirror);
 
     itkSetMacro(MultiModal, bool);
     itkGetConstMacro(MultiModal, bool);
     itkBooleanMacro(MultiModal);
 
     itkSetMacro(NoPip, bool);
     itkGetConstMacro(NoPip, bool);
     itkBooleanMacro(NoPip);
 
     itkSetMacro(Ensemble, bool);
     itkGetConstMacro(Ensemble, bool);
     itkBooleanMacro(Ensemble);
 
+    itkSetMacro(Predict, bool);
+    itkGetConstMacro(Predict, bool);
+    itkBooleanMacro(Predict);
+
     itkSetMacro(GpuId, unsigned int);
     itkGetConstMacro(GpuId, unsigned int);
 
     /**
      * @brief vector of ModelParams.
      * Size > 1 only for ensemble prediction.
      */
     std::vector<ModelParams> m_ParamQ;
 
     /**
      * @brief Holds paths to other input image modalities.
-     * 
+     *
      */
     std::vector<mitk::Image::ConstPointer> m_OtherModalPaths;
 
     std::pair<const Image *, LabelSetImage::Pointer> m_InputOutputPair;
 
     /**
      * @brief Renders the output LabelSetImage.
      * To called in the main thread.
      */
     void RenderOutputBuffer();
 
     /**
      * @brief Get the Output Buffer object
-     * 
-     * @return LabelSetImage::Pointer 
+     *
+     * @return LabelSetImage::Pointer
      */
     LabelSetImage::Pointer GetOutputBuffer();
 
     /**
      * @brief Sets the outputBuffer to nullptr
-     * 
+     *
      */
     void ClearOutputBuffer();
 
     /**
-    *  @brief Returns the DataStorage from the ToolManager
-    */
+     *  @brief Returns the DataStorage from the ToolManager
+     */
     mitk::DataStorage *GetDataStorage();
 
     mitk::DataNode *GetRefNode();
+
   protected:
-  
     /**
      * @brief Construct a new nnUNet Tool object and temp directory.
-     * 
+     *
      */
     nnUNetTool();
 
     /**
      * @brief Destroy the nnUNet Tool object and deletes the temp directory.
-     * 
+     *
      */
     ~nnUNetTool();
 
     /**
      * @brief Overriden method from the tool manager to execute the segmentation
      * Implementation:
      * 1. Saves the inputAtTimeStep in a temporary directory.
      * 2. Copies other modalities, renames and saves in the temporary directory, if required.
      * 3. Sets RESULTS_FOLDER and CUDA_VISIBLE_DEVICES variables in the environment.
      * 3. Iterates through the parameter queue (m_ParamQ) and executes "nnUNet_predict" command with the parameters
      * 4. Expects an output image to be saved in the temporary directory by the python proces. Loads it as
      *    LabelSetImage and returns.
-     * 
-     * @param inputAtTimeStep 
-     * @param timeStep 
-     * @return LabelSetImage::Pointer 
+     *
+     * @param inputAtTimeStep
+     * @param timeStep
+     * @return LabelSetImage::Pointer
      */
     LabelSetImage::Pointer ComputeMLPreview(const Image *inputAtTimeStep, TimeStepType timeStep) override;
     void UpdateCleanUp() override;
     void SetNodeProperties(LabelSetImage::Pointer) override;
 
-
   private:
     std::string m_MitkTempDir;
     std::string m_nnUNetDirectory;
     std::string m_ModelDirectory;
     std::string m_PythonPath;
     std::string m_PostProcessingJsonDirectory;
-    //bool m_UseGPU; kept for future
-    //bool m_AllInGPU; 
+    // bool m_UseGPU; kept for future
+    // bool m_AllInGPU;
     bool m_MixedPrecision;
     bool m_Mirror;
     bool m_NoPip;
     bool m_MultiModal;
     bool m_Ensemble = false;
+    bool m_Predict;
     LabelSetImage::Pointer m_OutputBuffer;
     unsigned int m_GpuId;
   };
 } // namespace mitk
 #endif
diff --git a/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUI.cpp b/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUI.cpp
index 9275d862a9..3e9ec9419f 100644
--- a/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUI.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUI.cpp
@@ -1,463 +1,465 @@
 /*============================================================================
 
 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 <QDir>
 #include <QIcon>
 #include <QtGlobal>
 #include <QApplication>
 
 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);
   }
 
   /* Disabling QThread and workers
   m_SegmentationThread = new QThread(this);
   m_Worker = new nnUNetSegmentationWorker;
   m_Worker->moveToThread(m_SegmentationThread);
   */
 
   // 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();
 }
 
 /*QmitknnUNetToolGUI::~QmitknnUNetToolGUI()
 {
   this->m_SegmentationThread->quit();
   this->m_SegmentationThread->wait();
 }*/
 
 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.stopButton, SIGNAL(clicked()), this, SLOT(OnStopPressed()));
   connect(m_Controls.refreshdirectoryBox, SIGNAL(clicked()), this, SLOT(OnRefreshDirectory()));
 
   /* Qthreads disabled
   connect(this, &QmitknnUNetToolGUI::Operate, m_Worker, &nnUNetSegmentationWorker::DoWork);
   connect(m_Worker, &nnUNetSegmentationWorker::Finished, this, &QmitknnUNetToolGUI::SegmentationResultHandler);
   connect(m_Worker, &nnUNetSegmentationWorker::Failed, this, &QmitknnUNetToolGUI::SegmentationProcessFailed);
   connect(m_SegmentationThread, &QThread::finished, m_Worker, &QObject::deleteLater);
   */
   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);
 
   /* STOP feature is disabled since processing now happens in the main thread itself.
   QIcon stopIcon;
   stopIcon.addPixmap(style()->standardIcon(QStyle::SP_BrowserStop).pixmap(sz), QIcon::Normal, QIcon::Off);
   m_Controls.stopButton->setIcon(stopIcon);
   m_Controls.stopButton->setEnabled(false);
   */
   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);
   m_Controls.statusLabel->setText("<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);
   }
   mainLayout->addLayout(m_Controls.verticalLayout);
   Superclass::InitializeUI(mainLayout);
   m_UI_ROWS = m_Controls.advancedSettingsLayout->rowCount(); // Must do. Row count is correct only here.
 }
 
 void QmitknnUNetToolGUI::OnPreviewRequested()
 {
   mitk::nnUNetTool::Pointer tool = this->GetConnectedToolAs<mitk::nnUNetTool>();
   if (nullptr != tool)
   {
     try
     {
       m_Controls.previewButton->setEnabled(false); // To prevent misclicked back2back prediction.
       qApp->processEvents();
-      tool->IsTimePointChangeAwareOff(); // purposefully placed to make tool->GetMTime different than before.
+      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());
       // 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();
       }
       tool->m_InputOutputPair = std::make_pair(nullptr, nullptr);
       // if (!m_SegmentationThread->isRunning())
       // {
       //   MITK_DEBUG << "Starting thread...";
       //   m_SegmentationThread->start();
       // }
       // emit Operate(tool);
       // m_Controls.stopButton->setEnabled(true);
       m_Controls.statusLabel->setText("<b>STATUS: </b><i>Starting Segmentation task... This might take a while.</i>");
       tool->UpdatePreview();
       if (tool->GetOutputBuffer() == nullptr)
       {
         mitkThrow() << "An error occured while calling nnUNet process.";
       }
       SegmentationResultHandler(tool);
-      tool->IsTimePointChangeAwareOn();
+      tool->PredictOff(); // purposefully placed to make tool->GetMTime different than before.
       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());
       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;
     }
   }
 }
 
 /*
 void QmitknnUNetToolGUI::OnSettingsAccepted()
 {
   mitk::nnUNetTool::Pointer tool = this->GetConnectedToolAs<mitk::nnUNetTool>();
   if (nullptr != tool)
   {
     try
     {
       QString modelName = m_Controls.modelBox->currentText();
       QString taskName = m_Controls.taskBox->currentText();
       bool isNoPip = m_Controls.nopipBox->isChecked();
 
       QString pythonPathTextItem = m_Controls.pythonEnvComboBox->currentText();
       QString pythonPath = pythonPathTextItem.mid(pythonPathTextItem.indexOf(" ") + 1);
 #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.");
       }
       QString trainerPlanner = m_Controls.trainerBox->currentText();
       QString splitterString = "__";
       tool->EnsembleOff();
 
       if (modelName.startsWith("ensemble", Qt::CaseInsensitive))
       {
         QString ppJsonFile =
           QDir::cleanPath(m_ModelDirectory + QDir::separator() + modelName + QDir::separator() + taskName +
                           QDir::separator() + trainerPlanner + QDir::separator() + "postprocessing.json");
         if (QFile(ppJsonFile).exists())
         {
           tool->EnsembleOn();
           tool->SetPostProcessingJsonDirectory(ppJsonFile.toStdString());
           splitterString = "--";
         }
       }
       QStringList trainerSplitParts = trainerPlanner.split(splitterString, QString::SplitBehavior::SkipEmptyParts);
       std::vector<mitk::ModelParams> requestQ;
       if (tool->GetEnsemble())
       {
         foreach (QString modelSet, trainerSplitParts)
         {
           modelSet.remove("ensemble_", Qt::CaseInsensitive);
           QStringList splitParts = modelSet.split("__", QString::SplitBehavior::SkipEmptyParts);
           QString modelName = splitParts.first();
           QString trainer = splitParts.at(1);
           QString planId = splitParts.at(2);
           auto testfold = std::vector<std::string>(1, "1");
           mitk::ModelParams modelObject = MapToRequest(modelName, taskName, trainer, planId, testfold);
           requestQ.push_back(modelObject);
         }
       }
       else
       {
         QString trainer = m_Controls.trainerBox->currentText();//trainerSplitParts.first();
         QString planId = m_Controls.plannerBox->currentText(); //trainerSplitParts.last();
         std::vector<std::string> fetchedFolds = FetchSelectedFoldsFromUI();
         mitk::ModelParams modelObject = MapToRequest(modelName, taskName, trainer, planId, fetchedFolds);
         requestQ.push_back(modelObject);
       }
 
       tool->m_ParamQ.clear();
       tool->m_ParamQ = requestQ;
 
       tool->SetnnUNetDirectory(nnUNetDirectory);
       tool->SetPythonPath(pythonPath.toStdString());
       tool->SetModelDirectory(m_ModelDirectory.left(m_ModelDirectory.lastIndexOf(QDir::separator())).toStdString());
       // checkboxes
       tool->SetMirror(m_Controls.mirrorBox->isChecked());
       tool->SetMixedPrecision(m_Controls.mixedPrecisionBox->isChecked());
       tool->SetNoPip(isNoPip);
       tool->SetMultiModal(m_Controls.multiModalBox->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 (!m_SegmentationThread->isRunning())
       {
         MITK_DEBUG << "Starting thread...";
         m_SegmentationThread->start();
       }
       m_Controls.statusLabel->setText("<b>STATUS: </b><i>Starting Segmentation task... This might take a while.</i>");
       emit Operate(tool);
     }
     catch (const std::exception &e)
     {
       std::stringstream errorMsg;
       errorMsg << "Error while processing parameters for nnUNet segmentation. Reason: " << e.what();
       ShowErrorMessage(errorMsg.str());
       return;
     }
     catch (...)
     {
       std::string errorMsg = "Unkown error occured while generation nnUNet segmentation.";
       ShowErrorMessage(errorMsg);
       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::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();
   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;
     auto testfold = std::vector<std::string>(1, "1"); // only for test
     mitk::ModelParams modelObject = MapToRequest(modelName, taskName, trainer, planId, testfold);
     requestQ.push_back(modelObject);
     ppDirFolderNameParts << ppDirFolderName.join(QString(""));
   }
   tool->EnsembleOn();
 
   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());
   }
   else if (QFile(ppJsonFilePossibility2).exists())
   {
     tool->SetPostProcessingJsonDirectory(ppJsonFilePossibility2.toStdString());
   }
   else
   {
     // warning message
   }
   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();
   mitk::ModelParams modelObject = MapToRequest(modelName, taskName, trainer, planId, fetchedFolds);
   requestQ.push_back(modelObject);
   tool->m_ParamQ.clear();
   tool->m_ParamQ = requestQ;
 }