diff --git a/Modules/Segmentation/Interactions/mitknnUnetTool.cpp b/Modules/Segmentation/Interactions/mitknnUnetTool.cpp
index c6e522a8d4..1245ee2124 100644
--- a/Modules/Segmentation/Interactions/mitknnUnetTool.cpp
+++ b/Modules/Segmentation/Interactions/mitknnUnetTool.cpp
@@ -1,320 +1,320 @@
 /*============================================================================
 
 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 "mitknnUnetTool.h"
 
 #include "mitkIOUtil.h"
 #include "mitkProcessExecutor.h"
 #include <itksys/SystemTools.hxx>
 #include <usGetModuleContext.h>
 #include <usModule.h>
 #include <usModuleContext.h>
 #include <usModuleResource.h>
 
 namespace mitk
 {
   MITK_TOOL_MACRO(MITKSEGMENTATION_EXPORT, nnUNetTool, "nnUNet tool");
 }
 
 mitk::nnUNetTool::nnUNetTool()
 {
   this->SetMitkTempDir(IOUtil::CreateTemporaryDirectory("mitk-XXXXXX"));
 }
 
 mitk::nnUNetTool::~nnUNetTool()
 {
   itksys::SystemTools::RemoveADirectory(this->GetMitkTempDir());
 }
 
 void mitk::nnUNetTool::Activated()
 {
   Superclass::Activated();
   this->SetLabelTransferMode(LabelTransferMode::AllLabels);
 }
 
 void mitk::nnUNetTool::RenderOutputBuffer()
 {
   if (m_OutputBuffer != nullptr)
-  { 
+  {
     try
     {
       if (nullptr != this->GetPreviewSegmentationNode())
       {
         auto previewImage = this->GetPreviewSegmentation();
         previewImage->InitializeByLabeledImage(m_OutputBuffer);
       }
     }
     catch (const mitk::Exception &e)
     {
       MITK_INFO << e.GetDescription();
     }
   }
 }
 
 void mitk::nnUNetTool::SetOutputBuffer(LabelSetImage::Pointer segmentation)
 {
   m_OutputBuffer = segmentation;
 }
 
 mitk::LabelSetImage::Pointer mitk::nnUNetTool::GetOutputBuffer()
 {
   return m_OutputBuffer;
 }
 
 void mitk::nnUNetTool::ClearOutputBuffer()
 {
   m_OutputBuffer = nullptr;
 }
 
 us::ModuleResource mitk::nnUNetTool::GetIconResource() const
 {
   us::Module *module = us::GetModuleContext()->GetModule();
   us::ModuleResource resource = module->GetResource("AI_48x48.png");
   return resource;
 }
 
 const char **mitk::nnUNetTool::GetXPM() const
 {
   return nullptr;
 }
 
 const char *mitk::nnUNetTool::GetName() const
 {
   return "nnUNet";
 }
 
 mitk::DataStorage *mitk::nnUNetTool::GetDataStorage()
 {
   return this->GetToolManager()->GetDataStorage();
 }
 
 mitk::DataNode *mitk::nnUNetTool::GetRefNode()
 {
   return this->GetToolManager()->GetReferenceData(0);
 }
 
 namespace
 {
   void onPythonProcessEvent(itk::Object * /*pCaller*/, const itk::EventObject &e, void *)
   {
     std::string testCOUT;
     std::string testCERR;
     const auto *pEvent = dynamic_cast<const mitk::ExternalProcessStdOutEvent *>(&e);
 
     if (pEvent)
     {
       testCOUT = testCOUT + pEvent->GetOutput();
       MITK_INFO << testCOUT;
     }
 
     const auto *pErrEvent = dynamic_cast<const mitk::ExternalProcessStdErrEvent *>(&e);
 
     if (pErrEvent)
     {
       testCERR = testCERR + pErrEvent->GetOutput();
       MITK_ERROR << testCERR;
     }
   }
 } // namespace
 
 void mitk::nnUNetTool::DoUpdatePreview(const Image* inputAtTimeStep, const Image* /*oldSegAtTimeStep*/, LabelSetImage* previewImage, TimeStepType /*timeStep*/)
 {
   std::string inDir, outDir, inputImagePath, outputImagePath, scriptPath;
 
   ProcessExecutor::Pointer spExec = ProcessExecutor::New();
   itk::CStyleCommand::Pointer spCommand = itk::CStyleCommand::New();
   spCommand->SetCallback(&onPythonProcessEvent);
   spExec->AddObserver(ExternalProcessOutputEvent(), spCommand);
   ProcessExecutor::ArgumentListType args;
 
   inDir = IOUtil::CreateTemporaryDirectory("nnunet-in-XXXXXX", this->GetMitkTempDir());
   std::ofstream tmpStream;
   inputImagePath = IOUtil::CreateTemporaryFile(tmpStream, m_TEMPLATE_FILENAME, inDir + IOUtil::GetDirectorySeparator());
   tmpStream.close();
   std::size_t found = inputImagePath.find_last_of(IOUtil::GetDirectorySeparator());
   std::string fileName = inputImagePath.substr(found + 1);
   std::string token = fileName.substr(0, fileName.find("_"));
 
   if (this->GetNoPip())
   {
     scriptPath = this->GetnnUNetDirectory() + IOUtil::GetDirectorySeparator() + "nnunet" +
                  IOUtil::GetDirectorySeparator() + "inference" + IOUtil::GetDirectorySeparator() + "predict_simple.py";
   }
 
   try
   {
     if (this->GetMultiModal())
     {
       const std::string fileFormat(".nii.gz");
       const std::string fileNamePart("_000_000");
       std::string outModalFile;
       size_t len = inDir.length() + 1 + token.length() + fileNamePart.length() + 1 + fileFormat.length();
       outModalFile.reserve(len); // The 1(s) indicates a directory separator char and an underscore.
       for (size_t i = 0; i < m_OtherModalPaths.size(); ++i)
       {
         mitk::Image::ConstPointer modalImage = m_OtherModalPaths[i];
         outModalFile.append(inDir);
         outModalFile.push_back(IOUtil::GetDirectorySeparator());
         outModalFile.append(token);
         outModalFile.append(fileNamePart);
         outModalFile.append(std::to_string(i));
         outModalFile.append(fileFormat);
         IOUtil::Save(modalImage.GetPointer(), outModalFile);
         outModalFile.clear();
       }
     }
     else
     {
       IOUtil::Save(inputAtTimeStep, inputImagePath);
     }
   }
   catch (const mitk::Exception &e)
   {
     /*
     Can't throw mitk exception to the caller. Refer: T28691
     */
     MITK_ERROR << e.GetDescription();
     return;
   }
   // Code calls external process
   std::string command = "nnUNet_predict";
   if (this->GetNoPip())
   {
 #ifdef _WIN32
     command = "python";
 #else
     command = "python3";
 #endif
   }
   for (ModelParams &modelparam : m_ParamQ)
   {
     outDir = IOUtil::CreateTemporaryDirectory("nnunet-out-XXXXXX", this->GetMitkTempDir());
     outputImagePath = outDir + IOUtil::GetDirectorySeparator() + token + "_000.nii.gz";
     modelparam.outputDir = outDir;
     args.clear();
     if (this->GetNoPip())
     {
       args.push_back(scriptPath);
     }
     args.push_back("-i");
     args.push_back(inDir);
 
     args.push_back("-o");
     args.push_back(outDir);
 
     args.push_back("-t");
     args.push_back(modelparam.task);
 
     if (modelparam.model.find("cascade") != std::string::npos)
     {
       args.push_back("-ctr");
     }
     else
     {
       args.push_back("-tr");
     }
     args.push_back(modelparam.trainer);
 
     args.push_back("-m");
     args.push_back(modelparam.model);
 
     args.push_back("-p");
     args.push_back(modelparam.planId);
 
     if (!modelparam.folds.empty())
     {
       args.push_back("-f");
       for (auto fold : modelparam.folds)
       {
         args.push_back(fold);
       }
     }
 
     args.push_back("--num_threads_nifti_save");
     args.push_back("1"); // fixing to 1
 
     if (!this->GetMirror())
     {
       args.push_back("--disable_tta");
     }
 
     if (!this->GetMixedPrecision())
     {
       args.push_back("--disable_mixed_precision");
     }
 
     if (this->GetEnsemble())
     {
       args.push_back("--save_npz");
     }
 
     try
     {
       std::string resultsFolderEnv = "RESULTS_FOLDER=" + this->GetModelDirectory();
       itksys::SystemTools::PutEnv(resultsFolderEnv.c_str());
       std::string cudaEnv = "CUDA_VISIBLE_DEVICES=" + std::to_string(this->GetGpuId());
       itksys::SystemTools::PutEnv(cudaEnv.c_str());
 
       spExec->Execute(this->GetPythonPath(), command, args);
     }
     catch (const mitk::Exception &e)
     {
       /*
       Can't throw mitk exception to the caller. Refer: T28691
       */
       MITK_ERROR << e.GetDescription();
       return;
     }
   }
   if (this->GetEnsemble() && !this->GetPostProcessingJsonDirectory().empty())
   {
     args.clear();
     command = "nnUNet_ensemble";
     outDir = IOUtil::CreateTemporaryDirectory("nnunet-ensemble-out-XXXXXX", this->GetMitkTempDir());
     outputImagePath = outDir + IOUtil::GetDirectorySeparator() + token + "_000.nii.gz";
 
     args.push_back("-f");
     for (ModelParams &modelparam : m_ParamQ)
     {
       args.push_back(modelparam.outputDir);
     }
 
     args.push_back("-o");
     args.push_back(outDir);
 
     if (!this->GetPostProcessingJsonDirectory().empty())
     {
       args.push_back("-pp");
       args.push_back(this->GetPostProcessingJsonDirectory());
     }
 
     spExec->Execute(this->GetPythonPath(), command, args);
   }
   try
   {
     Image::Pointer outputImage = IOUtil::Load<Image>(outputImagePath);
     previewImage->InitializeByLabeledImage(outputImage);
     previewImage->SetGeometry(inputAtTimeStep->GetGeometry());
     m_InputBuffer = inputAtTimeStep;
     m_OutputBuffer = mitk::LabelSetImage::New();
     m_OutputBuffer->InitializeByLabeledImage(outputImage);
     m_OutputBuffer->SetGeometry(inputAtTimeStep->GetGeometry());
   }
   catch (const mitk::Exception &e)
   {
     /*
     Can't throw mitk exception to the caller. Refer: T28691
     */
     MITK_ERROR << e.GetDescription();
     return;
   }
 }
diff --git a/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUI.cpp b/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUI.cpp
index f6420e861a..3a8310b850 100644
--- a/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUI.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUI.cpp
@@ -1,579 +1,579 @@
 /*============================================================================
 
 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 "mitkProcessExecutor.h"
 #include "mitknnUnetTool.h"
 #include <QApplication>
 #include <QDir>
 #include <QIcon>
 #include <QmitkStyleManager.h>
 #include <QtGlobal>
 #include <itksys/SystemTools.hxx>
 #include <set>
 
 #include <nlohmann/json.hpp>
 
 MITK_TOOL_GUI_MACRO(MITKSEGMENTATIONUI_EXPORT, QmitknnUNetToolGUI, "")
 
 QmitknnUNetToolGUI::QmitknnUNetToolGUI() : QmitkMultiLabelSegWithPreviewToolGUIBase()
 {
   // Nvidia-smi command returning zero doesn't always imply 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());
   m_MultiModalPredicate = mitk::NodePredicateAnd::New(imageType, labelSetImageType).GetPointer();
 }
 
 void QmitknnUNetToolGUI::ConnectNewTool(mitk::SegWithPreviewTool *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();
   SetGPUInfo();
   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.multiModalBox, SIGNAL(stateChanged(int)), this, SLOT(OnCheckBoxChanged(int)));
   connect(m_Controls.multiModalSpinBox, SIGNAL(valueChanged(int)), this, SLOT(OnModalitiesNumberChanged(int)));
   connect(m_Controls.pythonEnvComboBox,
 #if QT_VERSION >= 0x050F00 // 5.15
           SIGNAL(textActivated(const QString &)),
 #elif QT_VERSION >= 0x050C00 // 5.12
           SIGNAL(currentTextChanged(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.multiModalSpinBox->setVisible(false);
   m_Controls.multiModalSpinBox->setEnabled(false);
   m_Controls.multiModalSpinLabel->setVisible(false);
   m_Controls.previewButton->setEnabled(false);
 
   QIcon refreshIcon =
     QmitkStyleManager::ThemeIcon(QStringLiteral(":/org_mitk_icons/icons/awesome/scalable/actions/view-refresh.svg"));
   m_Controls.refreshdirectoryBox->setIcon(refreshIcon);
   QIcon dirIcon =
     QmitkStyleManager::ThemeIcon(QStringLiteral(":/org_mitk_icons/icons/awesome/scalable/actions/document-open.svg"));
   m_Controls.modeldirectoryBox->setIcon(dirIcon);
   m_Controls.refreshdirectoryBox->setEnabled(true);
 
   m_Controls.statusLabel->setTextFormat(Qt::RichText);
   if (m_GpuLoader.GetGPUCount() != 0)
   {
     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.
   DisableEverything();
   QString lastSelectedPyEnv = m_Settings.value("nnUNet/LastPythonPath").toString();
   m_Controls.pythonEnvComboBox->setCurrentText(lastSelectedPyEnv);
 }
 
 void QmitknnUNetToolGUI::OnPreviewRequested()
 {
   mitk::nnUNetTool::Pointer tool = this->GetConnectedToolAs<mitk::nnUNetTool>();
   if (nullptr != tool)
   {
     QString pythonPathTextItem = "";
     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);
       }
       pythonPathTextItem = m_Controls.pythonEnvComboBox->currentText();
       QString pythonPath = m_PythonPath;
       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->SetPythonPath(pythonPath.toStdString());
       tool->SetModelDirectory(m_ParentFolder->getResultsFolder().toStdString());
       // checkboxes
       tool->SetMirror(m_Controls.mirrorBox->isChecked());
       tool->SetMixedPrecision(m_Controls.mixedPrecisionBox->isChecked());
       tool->SetNoPip(false);
       bool doCache = m_Controls.enableCachingCheckBox->isChecked();
       // Spinboxes
       tool->SetGpuId(FetchSelectedGPUFromUI());
       // Multi-Modal
       tool->MultiModalOff();
       if (m_Controls.multiModalBox->isChecked())
       {
         if (m_Controls.multiModalSpinBox->value() > 0)
         {
           tool->m_OtherModalPaths.clear();
           tool->m_OtherModalPaths = FetchMultiModalImagesFromUI();
           tool->MultiModalOn();
         }
         else
         {
           throw std::runtime_error("Please select more than one modalities for a multi-modal task. If you "
                                    "would like to use only one modality then uncheck the Multi-Modal option.");
         }
       }
       if (doCache)
       {
         hashKey = nnUNetCache::GetUniqueHash(tool->m_ParamQ);
         if (m_Cache.contains(hashKey))
         {
           tool->PredictOff(); // purposefully placed to make tool->GetMTime different than before.
         }
       }
       if (tool->GetPredict())
       {
         tool->m_InputBuffer = nullptr;
         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->GetOutputBuffer());
           }
           tool->ClearOutputBuffer();
         }
         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 (m_Cache.contains(hashKey))
         {
           nnUNetCache *cacheObject = m_Cache[hashKey];
           MITK_INFO << "fetched pointer " << cacheObject->m_SegCache.GetPointer();
           tool->SetOutputBuffer(const_cast<mitk::LabelSetImage *>(cacheObject->m_SegCache.GetPointer()));
           SegmentationResultHandler(tool, true);
         }
       }
       m_Controls.previewButton->setEnabled(true);
     }
     catch (const std::exception &e)
     {
       std::stringstream errorMsg;
       errorMsg << "<b>STATUS: </b>Error while processing parameters for nnUNet segmentation. Reason: " << e.what();
       ShowErrorMessage(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;
     }
     if (!pythonPathTextItem.isEmpty())
     { // only cache if the prediction ended without errors.
       m_Settings.setValue("nnUNet/LastPythonPath", pythonPathTextItem);
     }
   }
 }
 
 std::vector<mitk::Image::ConstPointer> QmitknnUNetToolGUI::FetchMultiModalImagesFromUI()
 {
   std::vector<mitk::Image::ConstPointer> modals;
   if (m_Controls.multiModalBox->isChecked() && !m_Modalities.empty())
   {
     std::set<std::string> nodeNames; // set container for keeping names of all nodes to check if they are added twice.
     for (QmitkDataStorageComboBox *modality : m_Modalities)
     {
       if (nodeNames.find(modality->GetSelectedNode()->GetName()) == nodeNames.end())
       {
         modals.push_back(dynamic_cast<const mitk::Image *>(modality->GetSelectedNode()->GetData()));
         nodeNames.insert(modality->GetSelectedNode()->GetName());
       }
       else
       {
         throw std::runtime_error("Same modality is selected more than once. Please change your selection.");
         break;
       }
     }
   }
   return modals;
 }
 
 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);
   bool isExists = QFile::exists(fullPath + QDir::separator() + QString("nnUNet_predict")) &&
                   QFile::exists(fullPath + QDir::separator() + QString("python3"));
   return isExists;
 }
 
 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::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 (auto &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;
       WriteStatusMessage(statusMsg);
     }
     else if (QFile(ppJsonFilePossibility2).exists())
     {
       tool->SetPostProcessingJsonDirectory(ppJsonFilePossibility2.toStdString());
       const QString statusMsg = "<i>Post Processing JSON file found:</i>" + ppJsonFilePossibility2;
       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();
   auto rows = qaim->rowCount();
   for (std::remove_const_t<decltype(rows)> 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;
   for (const auto &trainerPlanner : trainerPlanners)
   {
     trainers << trainerPlanner.split(splitterString, QString::SplitBehavior::SkipEmptyParts).first();
     planners << trainerPlanner.split(splitterString, QString::SplitBehavior::SkipEmptyParts).last();
   }
   trainers.removeDuplicates();
   planners.removeDuplicates();
   return std::make_pair(trainers, planners);
 }
 
 std::vector<std::string> QmitknnUNetToolGUI::FetchSelectedFoldsFromUI(ctkCheckableComboBox *foldBox)
 {
   std::vector<std::string> folds;
   if (foldBox->noneChecked())
   {
     CheckAllInCheckableComboBox(foldBox);
   }
   QModelIndexList foldList = foldBox->checkedIndexes();
   for (const auto &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;
   m_Cache.insert(hashKey, newCacheObj);
   MITK_INFO << "New hash: " << hashKey << " " << newCacheObj->m_SegCache.GetPointer();
   UpdateCacheCountOnUI();
 }
 
 void QmitknnUNetToolGUI::SetGPUInfo()
 {
   std::vector<QmitkGPUSpec> specs = m_GpuLoader.GetAllGPUSpecs();
   for (const QmitkGPUSpec &gpuSpec : specs)
   {
     m_Controls.gpuComboBox->addItem(QString::number(gpuSpec.id) + ": " + gpuSpec.name + " (" + gpuSpec.memory + ")");
   }
   if (specs.empty())
   {
     m_Controls.gpuComboBox->setEditable(true);
     m_Controls.gpuComboBox->addItem(QString::number(0));
     m_Controls.gpuComboBox->setValidator(new QIntValidator(0, 999, this));
   }
 }
 
 unsigned int QmitknnUNetToolGUI::FetchSelectedGPUFromUI()
 {
   QString gpuInfo = m_Controls.gpuComboBox->currentText();
   if (m_GpuLoader.GetGPUCount() == 0)
   {
     return static_cast<unsigned int>(gpuInfo.toInt());
   }
   else
   {
     QString gpuId = gpuInfo.split(":", QString::SplitBehavior::SkipEmptyParts).first();
     return static_cast<unsigned int>(gpuId.toInt());
   }
 }
 
 QString QmitknnUNetToolGUI::FetchResultsFolderFromEnv()
 {
   const char *pathVal = itksys::SystemTools::GetEnv("RESULTS_FOLDER");
   QString retVal;
   if (pathVal)
   {
     retVal = QString::fromUtf8(pathVal);
   }
   else
   {
     retVal = m_Settings.value("nnUNet/LastRESULTS_FOLDERPath").toString();
   }
   return retVal;
 }
 
 QString QmitknnUNetToolGUI::DumpJSONfromPickle(const QString &parentPath)
 {
   const QString picklePath = parentPath + QDir::separator() + QString("plans.pkl");
   const QString jsonPath = parentPath + QDir::separator() + QString("mitk_export.json");
   if (!QFile::exists(jsonPath))
   {
     mitk::ProcessExecutor::Pointer spExec = mitk::ProcessExecutor::New();
     itk::CStyleCommand::Pointer spCommand = itk::CStyleCommand::New();
     mitk::ProcessExecutor::ArgumentListType args;
     args.push_back("-c");
     std::string pythonCode; // python syntax to parse plans.pkl file and export as Json file.
     pythonCode.append("import pickle;");
     pythonCode.append("import json;");
     pythonCode.append("loaded_pickle = pickle.load(open('");
     pythonCode.append(picklePath.toStdString());
     pythonCode.append("','rb'));");
     pythonCode.append("modal_dict = {key: loaded_pickle[key] for key in loaded_pickle.keys() if key in "
                       "['modalities','num_modalities']};");
     pythonCode.append("json.dump(modal_dict, open('");
     pythonCode.append(jsonPath.toStdString());
     pythonCode.append("', 'w'))");
 
     args.push_back(pythonCode);
     try
     {
       spExec->Execute(m_PythonPath.toStdString(), "python3", args);
     }
     catch (const mitk::Exception &e)
     {
       MITK_ERROR << "Pickle parsing FAILED!" << e.GetDescription(); // SHOW ERROR
       WriteStatusMessage(
         "Parsing failed in backend. Multiple Modalities will now have to be manually entered by the user.");
       return QString("");
     }
   }
   return jsonPath;
 }
 
 void QmitknnUNetToolGUI::DisplayMultiModalInfoFromJSON(const QString &jsonPath)
 {
   std::ifstream file(jsonPath.toStdString());
 
   if (file.is_open())
   {
     auto jsonObj = nlohmann::json::parse(file, nullptr, false);
 
     if (jsonObj.is_discarded() || !jsonObj.is_object())
     {
       MITK_ERROR << "Could not parse \"" << jsonPath.toStdString() << "\" as JSON object!";
       return;
     }
 
     auto num_mods = jsonObj["num_modalities"].get<int>();
     ClearAllModalLabels();
     if (num_mods > 1)
     {
       m_Controls.multiModalBox->setChecked(true);
       m_Controls.multiModalBox->setEnabled(false);
       m_Controls.multiModalSpinBox->setValue(num_mods - 1);
       m_Controls.advancedSettingsLayout->update();
       auto obj = jsonObj["modalities"];
       int count = 0;
       for (const auto& value : obj)
       {
         QLabel *label = new QLabel(QString::fromStdString("<i>" + value.get<std::string>() + "</i>"), this);
         m_ModalLabels.push_back(label);
         m_Controls.advancedSettingsLayout->addWidget(label, m_UI_ROWS + 1 + count, 0);
         count++;
       }
       m_Controls.multiModalSpinBox->setMinimum(num_mods - 1);
       m_Controls.advancedSettingsLayout->update();
     }
     else
     {
       m_Controls.multiModalSpinBox->setMinimum(0);
       m_Controls.multiModalBox->setChecked(false);
     }
   }
 }