diff --git a/Modules/Segmentation/Interactions/mitknnUnetTool.cpp b/Modules/Segmentation/Interactions/mitknnUnetTool.cpp
index 65de25e8cf..99779403d0 100644
--- a/Modules/Segmentation/Interactions/mitknnUnetTool.cpp
+++ b/Modules/Segmentation/Interactions/mitknnUnetTool.cpp
@@ -1,334 +1,327 @@
 /*============================================================================
 
 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();
 }
 
-void mitk::nnUNetTool::UpdateCleanUp()
-{
-  // This overriden method is intentionally left out for setting later upon demand
-  // in the `RenderOutputBuffer` method.
-}
-
 void mitk::nnUNetTool::RenderOutputBuffer()
 {
   if (m_OutputBuffer != nullptr)
   {
     Superclass::SetNodeProperties(m_OutputBuffer);
     try
     {
       if (nullptr != this->GetPreviewSegmentationNode())
       {
         this->GetPreviewSegmentationNode()->SetVisibility(!this->GetSelectedLabels().empty());
       }
       if (this->GetSelectedLabels().empty())
       {
         this->ResetPreviewNode();
       }
     }
     catch (const mitk::Exception &e)
     {
       MITK_INFO << e.GetDescription();
     }
   }
 }
 
-void mitk::nnUNetTool::SetNodeProperties(LabelSetImage::Pointer segmentation)
+void mitk::nnUNetTool::SetOutputBuffer(LabelSetImage::Pointer segmentation)
 {
-  // This overriden method doesn't set node properties. Intentionally left out for setting later upon demand
-  // in the `RenderOutputBuffer` method.
   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
 
 mitk::LabelSetImage::Pointer mitk::nnUNetTool::ComputeMLPreview(const Image *inputAtTimeStep, TimeStepType /*timeStep*/)
 {
   if (m_InputBuffer == inputAtTimeStep)
   {
     return m_OutputBuffer;
   }
   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 nullptr;
   }
   // 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 nullptr;
     }
   }
   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
   {
     LabelSetImage::Pointer resultImage = LabelSetImage::New();
     Image::Pointer outputImage = IOUtil::Load<Image>(outputImagePath);
     resultImage->InitializeByLabeledImage(outputImage);
     resultImage->SetGeometry(inputAtTimeStep->GetGeometry());
     m_InputBuffer = inputAtTimeStep;
+    m_OutputBuffer = resultImage;
     return resultImage;
   }
   catch (const mitk::Exception &e)
   {
     /*
     Can't throw mitk exception to the caller. Refer: T28691
     */
     MITK_ERROR << e.GetDescription();
     return nullptr;
   }
 }
diff --git a/Modules/Segmentation/Interactions/mitknnUnetTool.h b/Modules/Segmentation/Interactions/mitknnUnetTool.h
index 9185b0f0a7..7e0fcffd7a 100644
--- a/Modules/Segmentation/Interactions/mitknnUnetTool.h
+++ b/Modules/Segmentation/Interactions/mitknnUnetTool.h
@@ -1,214 +1,213 @@
 /*============================================================================
 
 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>
 #include <numeric>
+#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 inputName;
     std::string timeStamp;
 
     size_t generateHash() const
-    { 
+    {
       std::string toHash;
       std::string foldsConcatenated = std::accumulate(folds.begin(), folds.end(), std::string(""));
       toHash += this->task;
       toHash += this->model;
       toHash += this->inputName;
       toHash += foldsConcatenated;
       toHash += this->timeStamp;
       size_t hashVal = std::hash<std::string>{}(toHash);
       return hashVal;
     }
   };
 
   /**
     \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(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;
 
     mitk::Image::ConstPointer m_InputBuffer;
 
     /**
      * @brief Renders the output LabelSetImage.
      * To called in the main thread.
      */
     void RenderOutputBuffer();
 
     /**
      * @brief Get the Output Buffer object
      *
      * @return LabelSetImage::Pointer
      */
     LabelSetImage::Pointer GetOutputBuffer();
 
     /**
      * @brief Sets the outputBuffer to nullptr
      *
      */
     void ClearOutputBuffer();
 
     /**
      *  @brief Returns the DataStorage from the ToolManager
      */
     mitk::DataStorage *GetDataStorage();
 
     mitk::DataNode *GetRefNode();
 
-    void SetNodeProperties(LabelSetImage::Pointer) override;
+    void SetOutputBuffer(LabelSetImage::Pointer);
 
   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
      */
     LabelSetImage::Pointer ComputeMLPreview(const Image *inputAtTimeStep, TimeStepType timeStep) override;
-    void UpdateCleanUp() 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_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;
     const std::string m_TEMPLATE_FILENAME = "XXXXXX_000_0000.nii.gz";
   };
 } // namespace mitk
 #endif
diff --git a/Modules/SegmentationUI/Qmitk/QmitknnUNetFolderParser.h b/Modules/SegmentationUI/Qmitk/QmitknnUNetFolderParser.h
index d005f62eb3..50e188bd8f 100644
--- a/Modules/SegmentationUI/Qmitk/QmitknnUNetFolderParser.h
+++ b/Modules/SegmentationUI/Qmitk/QmitknnUNetFolderParser.h
@@ -1,281 +1,301 @@
 /*============================================================================
 
 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 QmitknnUNetFolderParser_h_Included
 #define QmitknnUNetFolderParser_h_Included
 
 #include "QmitknnUNetToolGUI.h"
 #include <QDirIterator>
 #include <QString>
 #include <vector>
 
 /**
  * @brief Struct to store each (Folder) Node of the hierarchy tree structure.
  * 
  */
 struct FolderNode
 {
   QString name;
   QString path; // parent
   std::vector<std::shared_ptr<FolderNode>> subFolders;
 };
 
 /**
  * @brief Class to store and retreive folder hierarchy information 
  * of RESULTS_FOLDER. Only Root node is explicitly stored in m_RootNode.
  * No. of sub levels in the hierachry is defined in the LEVEL constant.
  * 
  */
 class MITKSEGMENTATIONUI_EXPORT QmitknnUNetFolderParser
 {
 public:
 
   /**
    * @brief Construct a new QmitknnUNetFolderParser object
    * Initializes root folder node object pointer calls
    * @param parentFolder 
    */
   QmitknnUNetFolderParser(const QString parentFolder)
   {
     m_RootNode = std::make_shared<FolderNode>();
     m_RootNode->path = parentFolder;
     m_RootNode->name = QString("nnUNet");
     m_RootNode->subFolders.clear();
     InitDirs(m_RootNode, 0);
   }
 
   /**
    * @brief Destroy the QmitknnUNetFolderParser object
    * 
    */
   ~QmitknnUNetFolderParser() = default; /*{ DeleteDirs(m_RootNode, LEVEL); }*/
 
   /**
    * @brief Returns the "Results Folder" string which is parent path of the root node.
    * 
    * @return QString 
    */
   QString getResultsFolder() { return m_RootNode->path; }
 
   /**
    * @brief Returns the Model Names from root node. Template function, 
    * type can be any of stl or Qt containers which supports push_back call.
    * 
    * @tparam T 
    * @return T (any of stl or Qt containers which supports push_back call)
    */
   template <typename T>
   T getModelNames()
   {
     auto models = GetSubFolderNamesFromNode<T>(m_RootNode);
     return models;
   }
   
   /**
    * @brief Returns the task names for a given model. Template function, 
    * type can be any of stl or Qt containers which supports push_back call.
    * 
    * @tparam T 
    * @param modelName
    * @return T (any of stl or Qt containers which supports push_back call)
    */
   template <typename T>
   T getTasksForModel(const QString &modelName)
   {
     std::shared_ptr<FolderNode> modelNode = GetSubNodeMatchingNameCrietria(modelName, m_RootNode);
     auto tasks = GetSubFolderNamesFromNode<T>(modelNode);
     return tasks;
   }
 
   /**
    * @brief Returns the models names for a given task. Template function, 
    * type can be any of stl or Qt containers which supports push_back call.
    * 
    * @tparam T 
    * @param taskName
    * @return T (any of stl or Qt containers which supports push_back call)
    */
   template <typename T>
   T getModelsForTask(const QString &taskName)
   {
     T modelsForTask;
     auto models = GetSubFolderNamesFromNode<T>(m_RootNode);
     foreach (QString model, models)
     {
       QStringList taskList = getTasksForModel<QStringList>(model);
       if (taskList.contains(taskName, Qt::CaseInsensitive))
       {
         modelsForTask << model;
       }
     }
     return modelsForTask;
   }
 
+  /**
+   * @brief Returns all the task names present in the root node with possible duplicates.
+   * Template function, type can be any of stl or Qt containers which supports push_back call.
+   * 
+   * @tparam T 
+   * @param taskName
+   * @return T (any of stl or Qt containers which supports push_back call)
+   */
+  template <typename T>
+  T getAllTasks()
+  {
+    T allTasks;
+    auto models = GetSubFolderNamesFromNode<T>(m_RootNode);
+    foreach (QString model, models)
+    {
+      allTasks << getTasksForModel<QStringList>(model);
+    }
+    return allTasks;
+  }
+
   /**
    * @brief Returns the trainer / planner names for a given task & model. Template function, 
    * type can be any of stl or Qt containers which supports push_back call.
    * 
    * @tparam T 
    * @param taskName
    * @param modelName
    * @return T (any of stl or Qt containers which supports push_back call)
    */
   template <typename T>
   T getTrainerPlannersForTask(const QString &taskName, const QString &modelName)
   {
     std::shared_ptr<FolderNode> modelNode = GetSubNodeMatchingNameCrietria(modelName, m_RootNode);
     std::shared_ptr<FolderNode> taskNode = GetSubNodeMatchingNameCrietria(taskName, modelNode);
     auto tps = GetSubFolderNamesFromNode<T>(taskNode);
     return tps;
   }
 
   /**
    * @brief Returns the Folds names for a given trainer,planner,task & model name. Template function, 
    * type can be any of stl or Qt containers which supports push_back call.
    * 
    * @tparam T 
    * @param trainer
    * @param planner
    * @param taskName
    * @param modelName
    * @return T (any of stl or Qt containers which supports push_back call)
    */
   template <typename T>
   T getFoldsForTrainerPlanner(const QString &trainer,
                               const QString &planner,
                               const QString &taskName,
                               const QString &modelName)
   {
     std::shared_ptr<FolderNode> modelNode = GetSubNodeMatchingNameCrietria(modelName, m_RootNode);
     std::shared_ptr<FolderNode> taskNode = GetSubNodeMatchingNameCrietria(taskName, modelNode);
     QString trainerPlanner = trainer + QString("__") + planner;
     std::shared_ptr<FolderNode> tpNode = GetSubNodeMatchingNameCrietria(trainerPlanner, taskNode);
     auto folds = GetSubFolderNamesFromNode<T>(tpNode);
     return folds;
   }
 
 private:
   const int m_LEVEL = 4;
   std::shared_ptr<FolderNode> m_RootNode;
 
   /**
    * @brief Iterates through the root node and returns the sub FolderNode object Matching Name Crietria 
    * 
    * @param queryName 
    * @param parentNode 
    * @return std::shared_ptr<FolderNode> 
    */
   std::shared_ptr<FolderNode> GetSubNodeMatchingNameCrietria(const QString &queryName,
                                                              std::shared_ptr<FolderNode> parentNode)
   {
     std::shared_ptr<FolderNode> retNode;
     std::vector<std::shared_ptr<FolderNode>> subNodes = parentNode->subFolders;
     for (std::shared_ptr<FolderNode> node : subNodes)
     {
       if (node->name == queryName)
       {
         retNode = node;
         break;
       }
     }
     return retNode;
   }
 
   /**
    * @brief Returns the sub folder names for a folder node object. Template function, 
    * type can be any of stl or Qt containers which supports push_back call.
    * 
    * @tparam T 
    * @param std::shared_ptr<FolderNode>
    * @return T (any of stl or Qt containers which supports push_back call)
    */
   template <typename T>
   T GetSubFolderNamesFromNode(const std::shared_ptr<FolderNode> parent)
   {
     T folders;
     std::vector<std::shared_ptr<FolderNode>> subNodes = parent->subFolders;
     for (std::shared_ptr<FolderNode> folder : subNodes)
     {
       folders.push_back(folder->name);
     }
     return folders;
   }
 
   /**
    * @brief Iterates through the sub folder hierarchy upto a level provided
    * and create a tree structure.
    * 
    * @param parent 
    * @param level 
    */
   void InitDirs(std::shared_ptr<FolderNode> parent, int level)
   {
     QString searchFolder = parent->path + QDir::separator() + parent->name;
     auto subFolders = FetchFoldersFromDir<QStringList>(searchFolder);
     level++;
     foreach (QString folder, subFolders)
     {
       std::shared_ptr<FolderNode> fp = std::make_shared<FolderNode>();
       fp->path = searchFolder;
       fp->name = folder;
       if (level < this->m_LEVEL)
       {
         InitDirs(fp, level);
       }
       parent->subFolders.push_back(fp);
     }
   }
 
   /**
    * @brief Iterates through the sub folder hierarchy upto a level provided
    * and clears the sub folder std::vector from each node.
    * 
    * @param parent 
    * @param level 
    */
   void DeleteDirs(std::shared_ptr<FolderNode> parent, int level)
   {
     level++;
     for (std::shared_ptr<FolderNode> subFolder : parent->subFolders)
     {
       if (level < m_LEVEL)
       {
         DeleteDirs(subFolder, level);
       }
       parent->subFolders.clear();
     }
   }
 
   /**
    * @brief Template function to fetch all folders inside a given path.
    * The type can be any of stl or Qt containers which supports push_back call.
    * 
    * @tparam T 
    * @param path 
    * @return T 
    */
   template <typename T>
   T FetchFoldersFromDir(const QString &path)
   {
     T folders;
     for (QDirIterator it(path, QDir::AllDirs, QDirIterator::NoIteratorFlags); it.hasNext();)
     {
       it.next();
       if (!it.fileName().startsWith('.'))
       {
         folders.push_back(it.fileName());
       }
     }
     return folders;
   }
 };
 #endif
diff --git a/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUI.cpp b/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUI.cpp
index bdbb5651e4..29114ac8f8 100644
--- a/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUI.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUI.cpp
@@ -1,498 +1,588 @@
 /*============================================================================
 
 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 <QJsonDocument>
+#include <QJsonObject>
 #include <QmitkStyleManager.h>
 #include <QtGlobal>
+#include <itksys/SystemTools.hxx>
 #include <set>
 
 MITK_TOOL_GUI_MACRO(MITKSEGMENTATIONUI_EXPORT, QmitknnUNetToolGUI, "")
 
 QmitknnUNetToolGUI::QmitknnUNetToolGUI() : QmitkAutoMLSegmentationToolGUIBase()
 {
   // 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::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();
   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.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.pythonEnvComboBox,
 #if QT_VERSION >= 0x050F00 // 5.15
           SIGNAL(textActivated(const QString &)),
 #elif QT_VERSION >= 0x050C00 // 5.12
-          SIGNAL(activated(const QString &)),
+          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.codedirectoryBox->setVisible(false);
-  m_Controls.nnUnetdirLabel->setVisible(false);
   m_Controls.multiModalSpinBox->setVisible(false);
+  m_Controls.multiModalSpinBox->setEnabled(false);
   m_Controls.multiModalSpinLabel->setVisible(false);
   m_Controls.previewButton->setEnabled(false);
 
-  m_Controls.stopButton->setVisible(false); // Hidden for future
-
   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.
-
-  if (nullptr != m_Controls.modeldirectoryBox)
-  {
-    QString setVal = m_Settings.value("nnUNet/LastRESULTS_FOLDERPath").toString();
-    m_Controls.modeldirectoryBox->setDirectory(setVal);
-  }
+  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);
       }
-      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))
+      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->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->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->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 (m_Cache.contains(hashKey))
         {
           nnUNetCache *cacheObject = m_Cache[hashKey];
           MITK_INFO << "fetched pointer " << cacheObject->m_SegCache.GetPointer();
-          tool->SetNodeProperties(const_cast<mitk::LabelSetImage *>(cacheObject->m_SegCache.GetPointer()));
-          SegmentationResultHandler(tool);
+          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);
-  return QFile::exists(fullPath + QDir::separator() + QString("nnUNet_predict"));
+  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->allChecked() || foldBox->noneChecked()))
+  if (foldBox->noneChecked())
   {
-    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());
-    }
+    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)
+{
+  if (QFile::exists(jsonPath))
+  {
+    QFile file(jsonPath);
+    if (file.open(QIODevice::ReadOnly | QIODevice::Text))
+    {
+      QByteArray bytes = file.readAll();
+      file.close();
+
+      QJsonParseError jsonError;
+      QJsonDocument document = QJsonDocument::fromJson(bytes, &jsonError);
+      if (jsonError.error != QJsonParseError::NoError)
+      {
+        MITK_INFO << "fromJson failed: " << jsonError.errorString().toStdString() << endl;
+        return;
+      }
+      if (document.isObject())
+      {
+        QJsonObject jsonObj = document.object();
+        int num_mods = jsonObj["num_modalities"].toInt();
+        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();
+          QJsonObject obj = jsonObj.value("modalities").toObject();
+          QStringList keys = obj.keys();
+          int count = 0;
+          for (auto key : keys)
+          {
+            auto value = obj.take(key);
+            QLabel *label = new QLabel("<i>" + value.toString() + "</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);
+        }
+      }
+    }
+  }
+}
diff --git a/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUI.h b/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUI.h
index b5a6106778..601f36453e 100644
--- a/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUI.h
+++ b/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUI.h
@@ -1,298 +1,342 @@
 /*============================================================================
 
 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 *);
+  void SegmentationResultHandler(mitk::nnUNetTool *, bool forceRender = false);
 
   /**
    * @brief Qt Slot
    *
    */
   void OnModalitiesNumberChanged(int);
 
   /**
    * @brief Qt Slot
    *
    */
   void OnPythonPathChanged(const QString &);
 
   /**
    * @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 Clears all displayed modal labels and widgets from GUI.
+   * 
+   */
+  void ClearAllModalities();
+
+  /**
+   * @brief Parses Json file containing modality info and populates
+   * labels and selection widgets accordingly on the GUI.
+   */
+  void DisplayMultiModalInfoFromJSON(const QString&);
+
+  /**
+   * @brief Clears all modality labels previously populated from GUI
+   * 
+   */
+
+  void ClearAllModalLabels();
+
+  /**
+   * @brief Runs a set of python commands to read "plans.pkl" and extract
+   * modality information required for inferencing. This information is exported
+   * as json file : "mitk_export.json".
+   *
+   * @return QString 
+   */
+  QString DumpJSONfromPickle(const QString&);
+
+  /**
+   * @brief Searches RESULTS_FOLDER environment variable. If not found,
+   * returns from the QSettings stored last used path value.
+   * @return QString 
+   */
+  QString FetchResultsFolderFromEnv();
   
   /**
    * @brief Returns GPU id of the selected GPU from the Combo box.
    * 
    * @return unsigned int 
    */
   unsigned int FetchSelectedGPUFromUI();
 
   /**
    * @brief Adds GPU information to the gpu combo box.
    * In case, there aren't any GPUs avaialble, the combo box will be
    * rendered editable. 
    */
   void SetGPUInfo();
 
   /**
    * @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 Writes any message in white on the tool pane.
    */
   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 Disable/deactivates the nnUNet GUI.
+   * Clears any multi modal labels and selection widgets, as well.
+   */
+  void DisableEverything();
+
   /**
    * @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();
 
   /**
    * @brief Updates cache count on UI.
    * 
    */
   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<QLabel*> m_ModalLabels;
 
   std::vector<std::unique_ptr<QmitknnUNetTaskParamsUITemplate>> m_EnsembleParams;
 
   mitk::NodePredicateBase::Pointer m_MultiModalPredicate;
 
+  QString m_PythonPath;
+
   /**
    * @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/QmitknnUNetToolGUIControls.ui b/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUIControls.ui
index 82e12d2b63..a3d0a1ce7f 100644
--- a/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUIControls.ui
+++ b/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUIControls.ui
@@ -1,478 +1,439 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitknnUNetToolGUIControls</class>
  <widget class="QWidget" name="QmitknnUNetToolGUIControls">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>877</width>
     <height>711</height>
    </rect>
   </property>
   <property name="sizePolicy">
    <sizepolicy hsizetype="Ignored" vsizetype="Minimum">
     <horstretch>0</horstretch>
     <verstretch>0</verstretch>
    </sizepolicy>
   </property>
   <property name="minimumSize">
    <size>
     <width>100</width>
     <height>0</height>
    </size>
   </property>
   <property name="maximumSize">
    <size>
     <width>100000</width>
     <height>100000</height>
    </size>
   </property>
   <property name="windowTitle">
    <string>QmitknnUNetToolWidget</string>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout">
    <property name="leftMargin">
     <number>0</number>
    </property>
    <property name="topMargin">
     <number>0</number>
    </property>
    <property name="rightMargin">
     <number>0</number>
    </property>
    <property name="bottomMargin">
     <number>0</number>
    </property>
    <item>
     <layout class="QGridLayout" name="advancedSettingsLayout">
-     <item row="4" column="3">
+     <item row="5" column="3">
       <widget class="ctkComboBox" name="plannerBox"/>
      </item>
-     <item row="4" column="1">
+     <item row="5" column="1">
       <widget class="ctkComboBox" name="trainerBox"/>
      </item>
-     <item row="2" column="1" colspan="3">
+     <item row="3" column="1" colspan="3">
       <widget class="QPushButton" name="refreshdirectoryBox">
        <property name="text">
         <string>Refresh Results Folder</string>
        </property>
       </widget>
      </item>
-     <item row="6" column="0">
+     <item row="1" column="0">
       <widget class="QLabel" name="pythonEnvLabel">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="text">
         <string>Python Path:</string>
        </property>
       </widget>
      </item>
-     <item row="4" column="2">
+     <item row="5" column="2">
       <widget class="QLabel" name="plannerLabel">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="text">
         <string>Plan:</string>
        </property>
       </widget>
      </item>
-     <item row="4" column="0">
+     <item row="5" column="0">
       <widget class="QLabel" name="trainerLabel">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="text">
         <string>Trainer:</string>
        </property>
       </widget>
      </item>
-     <item row="1" column="0">
+     <item row="2" column="0">
       <widget class="QLabel" name="pretraineddirLabel">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="text">
         <string>nnUNet Results Folder:</string>
        </property>
       </widget>
      </item>
-     <item row="3" column="3">
+     <item row="4" column="1">
       <widget class="ctkComboBox" name="taskBox"/>
      </item>
-     <item row="5" column="3">
-      <widget class="QPushButton" name="stopButton">
-       <property name="text">
-        <string>Stop</string>
-       </property>
-      </widget>
-     </item>
      <item row="7" column="1">
       <widget class="ctkCheckBox" name="multiModalBox"/>
      </item>
      <item row="7" column="0">
       <widget class="QLabel" name="multiModalLabel">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="text">
         <string>Multi-Modal:</string>
        </property>
       </widget>
      </item>
      <item row="0" column="0" colspan="4">
       <widget class="QLabel" name="welcomeNote">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Preferred" vsizetype="Minimum">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="text">
-        <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Welcome to nnUNet in MITK. [Experimental]&lt;/p&gt;&lt;p&gt;Please note that this is only an interface to nnUNet. MITK does not ship with nnUNet. Make sure to have a working Python environment with nnUNet set up beforehand. Choose that environment in the Python Path before inferencing.&lt;/p&gt;&lt;p&gt;Refer to &lt;a href=&quot;https://github.com/MIC-DKFZ/nnUNet&quot;&gt;&lt;span style=&quot; text-decoration: underline; color:#0000ff;&quot;&gt;https://github.com/MIC-DKFZ/nnUNet&lt;/span&gt;&lt;/a&gt; to learn everything about the nnUNet.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+        <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Welcome to nnUNet in MITK. [Experimental]&lt;/p&gt;&lt;p&gt;Please note that this is only an interface to nnUNet. MITK does not ship with nnUNet. Make sure to have a working Python environment with nnUNet set up beforehand. Choose that environment in the Python Path before inferencing. &lt;/p&gt;&lt;p&gt;Refer to &lt;a href=&quot;https://github.com/MIC-DKFZ/nnUNet&quot;&gt;&lt;span style=&quot; text-decoration: underline; color:#0000ff;&quot;&gt;https://github.com/MIC-DKFZ/nnUNet&lt;/span&gt;&lt;/a&gt; to learn everything about the nnUNet.&lt;/p&gt;&lt;p&gt;Also, note that if multiple Preview objects are selected to Confirm, they will be merged. &lt;/p&gt;&lt;p&gt;&lt;br/&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
        </property>
        <property name="textFormat">
         <enum>Qt::RichText</enum>
        </property>
        <property name="wordWrap">
         <bool>true</bool>
        </property>
       </widget>
      </item>
-     <item row="1" column="1" colspan="3">
+     <item row="2" column="1" colspan="3">
       <widget class="ctkDirectoryButton" name="modeldirectoryBox" native="true"/>
      </item>
-     <item row="3" column="0">
+     <item row="4" column="2">
       <widget class="QLabel" name="modelLabel">
        <property name="text">
         <string>Configuration:</string>
        </property>
       </widget>
      </item>
-     <item row="3" column="1">
+     <item row="4" column="3">
       <widget class="ctkComboBox" name="modelBox"/>
      </item>
-     <item row="3" column="2">
+     <item row="4" column="0">
       <widget class="QLabel" name="taskLabel">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="text">
         <string>Task:</string>
        </property>
       </widget>
      </item>
-     <item row="5" column="1">
+     <item row="6" column="1">
       <widget class="ctkCheckableComboBox" name="foldBox"/>
      </item>
      <item row="7" column="2">
       <widget class="QLabel" name="multiModalSpinLabel">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="text">
         <string>No. of Extra Modalities:</string>
        </property>
       </widget>
      </item>
-     <item row="5" column="0">
+     <item row="6" column="0">
       <widget class="QLabel" name="foldLabel">
        <property name="text">
         <string>Fold:</string>
        </property>
       </widget>
      </item>
-     <item row="6" column="1" colspan="3">
+     <item row="1" column="1" colspan="3">
       <widget class="ctkComboBox" name="pythonEnvComboBox"/>
      </item>
      <item row="7" column="3">
       <widget class="QSpinBox" name="multiModalSpinBox"/>
      </item>
     </layout>
    </item>
    <item>
     <widget class="ctkCollapsibleGroupBox" name="inputGroupBox">
      <property name="minimumSize">
       <size>
        <width>0</width>
        <height>0</height>
       </size>
      </property>
      <property name="title">
       <string>Advanced</string>
      </property>
      <property name="alignment">
       <set>Qt::AlignRight</set>
      </property>
      <property name="flat">
       <bool>true</bool>
      </property>
      <property name="collapsedHeight" stdset="0">
       <number>5</number>
      </property>
      <property name="collapsed" stdset="0">
       <bool>true</bool>
      </property>
      <layout class="QVBoxLayout" name="verticalLayout_4">
       <item>
        <layout class="QGridLayout" name="_2">
         <property name="leftMargin">
          <number>0</number>
         </property>
         <property name="topMargin">
          <number>0</number>
         </property>
         <property name="rightMargin">
          <number>0</number>
         </property>
         <property name="bottomMargin">
          <number>0</number>
         </property>
         <property name="spacing">
          <number>6</number>
         </property>
-        <item row="0" column="0">
-         <widget class="QLabel" name="nopipLabel">
-          <property name="sizePolicy">
-           <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
-            <horstretch>0</horstretch>
-            <verstretch>0</verstretch>
-           </sizepolicy>
-          </property>
-          <property name="text">
-           <string>No Pip:</string>
-          </property>
-         </widget>
-        </item>
-        <item row="0" column="1">
-         <widget class="ctkCheckBox" name="nopipBox"/>
-        </item>
         <item row="0" column="2">
          <widget class="QLabel" name="mixedPrecisionLabel">
           <property name="sizePolicy">
            <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
             <horstretch>0</horstretch>
             <verstretch>0</verstretch>
            </sizepolicy>
           </property>
           <property name="text">
            <string>Mixed Precision:</string>
           </property>
          </widget>
         </item>
         <item row="0" column="3">
          <widget class="QCheckBox" name="mixedPrecisionBox">
           <property name="checked">
            <bool>true</bool>
           </property>
          </widget>
         </item>
         <item row="1" column="0">
          <widget class="QLabel" name="gpuSpinLabel">
           <property name="sizePolicy">
            <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
             <horstretch>0</horstretch>
             <verstretch>0</verstretch>
            </sizepolicy>
           </property>
           <property name="text">
            <string>GPU Id:</string>
           </property>
          </widget>
         </item>
         <item row="1" column="1">
          <widget class="ctkComboBox" name="gpuComboBox"/>
         </item>
         <item row="1" column="2">
          <widget class="QLabel" name="mirrorLabel">
           <property name="sizePolicy">
            <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
             <horstretch>0</horstretch>
             <verstretch>0</verstretch>
            </sizepolicy>
           </property>
           <property name="text">
            <string>Enable Mirroring:</string>
           </property>
          </widget>
         </item>
         <item row="1" column="3">
          <widget class="ctkCheckBox" name="mirrorBox">
           <property name="checked">
            <bool>true</bool>
           </property>
          </widget>
         </item>
-        <item row="3" column="0">
-         <widget class="QLabel" name="nnUnetdirLabel">
-          <property name="sizePolicy">
-           <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
-            <horstretch>0</horstretch>
-            <verstretch>0</verstretch>
-           </sizepolicy>
-          </property>
-          <property name="text">
-           <string>nnUNet Path:</string>
-          </property>
-         </widget>
-        </item>
-        <item row="3" column="1" colspan="3">
-         <widget class="ctkDirectoryButton" name="codedirectoryBox" native="true"/>
-        </item>
-        <item row="4" column="0">
+        <item row="0" column="0">
          <widget class="QLabel" name="postProcessingLabel">
           <property name="sizePolicy">
            <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
             <horstretch>0</horstretch>
             <verstretch>0</verstretch>
            </sizepolicy>
           </property>
           <property name="text">
            <string>Use Postprocessing JSON:</string>
           </property>
          </widget>
         </item>
-        <item row="4" column="1">
+        <item row="0" column="1">
          <widget class="ctkCheckBox" name="postProcessingCheckBox">
           <property name="checked">
            <bool>true</bool>
           </property>
          </widget>
         </item>
         <item row="5" column="0">
          <widget class="QLabel" name="enableCachingLabel">
           <property name="sizePolicy">
            <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
             <horstretch>0</horstretch>
             <verstretch>0</verstretch>
            </sizepolicy>
           </property>
           <property name="text">
            <string>Enable Caching:</string>
           </property>
          </widget>
         </item>
         <item row="5" column="1">
          <widget class="ctkCheckBox" name="enableCachingCheckBox">
           <property name="checked">
            <bool>true</bool>
           </property>
          </widget>
         </item>
         <item row="5" column="2">
          <widget class="QPushButton" name="clearCacheButton">
           <property name="text">
            <string>Clear Cache</string>
           </property>
          </widget>
         </item>
         <item row="5" column="3">
          <widget class="QLabel" name="cacheCountLabel">
           <property name="sizePolicy">
            <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
             <horstretch>0</horstretch>
             <verstretch>0</verstretch>
            </sizepolicy>
           </property>
           <property name="text">
            <string>Cached Items: 0</string>
           </property>
          </widget>
         </item>
        </layout>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <widget class="QPushButton" name="previewButton">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <property name="maximumSize">
       <size>
        <width>100000</width>
        <height>16777215</height>
       </size>
      </property>
      <property name="text">
       <string>Preview</string>
      </property>
     </widget>
    </item>
    <item>
     <widget class="QLabel" name="statusLabel">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <property name="wordWrap">
       <bool>true</bool>
      </property>
     </widget>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>ctkDirectoryButton</class>
    <extends>QWidget</extends>
    <header location="global">ctkDirectoryButton.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>ctkComboBox</class>
    <extends>QComboBox</extends>
    <header location="global">ctkComboBox.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>ctkCheckableComboBox</class>
    <extends>QComboBox</extends>
    <header location="global">ctkCheckableComboBox.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>ctkCheckBox</class>
    <extends>QCheckBox</extends>
    <header location="global">ctkCheckBox.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>ctkCollapsibleGroupBox</class>
    <extends>QGroupBox</extends>
    <header location="global">ctkCollapsibleGroupBox.h</header>
    <container>1</container>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>
diff --git a/Modules/SegmentationUI/Qmitk/QmitknnUNetToolSlots.cpp b/Modules/SegmentationUI/Qmitk/QmitknnUNetToolSlots.cpp
index 39a386248c..4b82f39ed2 100644
--- a/Modules/SegmentationUI/Qmitk/QmitknnUNetToolSlots.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitknnUNetToolSlots.cpp
@@ -1,409 +1,478 @@
 #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::ClearAllModalities()
+{
+  m_Controls.multiModalSpinBox->setMinimum(0);
+  m_Controls.multiModalBox->setChecked(false);
+  ClearAllModalLabels();
+}
+
+void QmitknnUNetToolGUI::ClearAllModalLabels()
+{
+  for (auto modalLabel : m_ModalLabels)
+  {
+    delete modalLabel; // delete the layout item
+    m_ModalLabels.pop_back();
+  }
+  m_Controls.advancedSettingsLayout->update();
+}
+
+void QmitknnUNetToolGUI::DisableEverything()
+{
+  m_Controls.modeldirectoryBox->setEnabled(false);
+  m_Controls.refreshdirectoryBox->setEnabled(false);
+  m_Controls.previewButton->setEnabled(false);
+  m_Controls.multiModalSpinBox->setVisible(false);
+  m_Controls.multiModalBox->setEnabled(false);
+  ClearAllComboBoxes();
+  ClearAllModalities();
+}
+
 void QmitknnUNetToolGUI::ClearAllComboBoxes()
 {
   m_Controls.modelBox->clear();
   m_Controls.taskBox->clear();
   m_Controls.foldBox->clear();
   m_Controls.trainerBox->clear();
+  m_Controls.plannerBox->clear();
   for (auto &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();
+  ClearAllComboBoxes();
+  ClearAllModalities();
   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);
+  auto tasks = m_ParentFolder->getAllTasks<QStringList>();
+  tasks.removeDuplicates();
+  std::for_each(tasks.begin(), tasks.end(), [this](QString task) { m_Controls.taskBox->addItem(task); });
+  m_Settings.setValue("nnUNet/LastRESULTS_FOLDERPath", resultsFolder);
 }
 
 void QmitknnUNetToolGUI::OnModelChanged(const QString &model)
 {
   if (model.isEmpty())
   {
     return;
   }
+  ClearAllModalities();
+  auto selectedTask = m_Controls.taskBox->currentText();
   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); });
+    if (model == 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);
+      auto models = m_ParentFolder->getModelsForTask<QStringList>(m_Controls.taskBox->currentText());
+      models.removeDuplicates();
+      models.removeOne(m_VALID_MODELS.last());
+      for (auto &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);
+      auto trainerPlanners = m_ParentFolder->getTrainerPlannersForTask<QStringList>(selectedTask, model);
+      QStringList trainers, planners;
+      std::tie(trainers, planners) = ExtractTrainerPlannerFromString(trainerPlanners);
+      m_Controls.trainerBox->clear();
+      m_Controls.plannerBox->clear();
+      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); });
+    }
   }
   else if (!m_EnsembleParams.empty())
   {
     for (auto &layout : m_EnsembleParams)
     {
       if (box == layout->modelBox)
       {
         layout->trainerBox->clear();
         layout->plannerBox->clear();
-        auto trainerPlanners =
-          m_ParentFolder->getTrainerPlannersForTask<QStringList>(m_Controls.taskBox->currentText(), model);
+        auto trainerPlanners = m_ParentFolder->getTrainerPlannersForTask<QStringList>(selectedTask, model);
         QStringList trainers, planners;
         std::tie(trainers, planners) = ExtractTrainerPlannerFromString(trainerPlanners);
-
-        std::for_each(
-          trainers.begin(), trainers.end(), [&layout](const QString& trainer) { layout->trainerBox->addItem(trainer); });
-        std::for_each(
-          planners.begin(), planners.end(), [&layout](const QString& planner) { layout->plannerBox->addItem(planner); });
+        std::for_each(trainers.begin(),
+                      trainers.end(),
+                      [&layout](const QString &trainer) { layout->trainerBox->addItem(trainer); });
+        std::for_each(planners.begin(),
+                      planners.end(),
+                      [&layout](const 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);
-    auto models = m_ParentFolder->getModelsForTask<QStringList>(m_Controls.taskBox->currentText());
-    models.removeDuplicates();
-    models.removeOne(m_VALID_MODELS.last());
-
-    for (auto &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.modelBox->clear();
+  auto models = m_ParentFolder->getModelsForTask<QStringList>(task);
+  models.removeDuplicates();
+  if (!models.contains(m_VALID_MODELS.last(), Qt::CaseInsensitive))
   {
-    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);
-    auto 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); });
+    models << m_VALID_MODELS.last(); // add ensemble even if folder doesn't exist
   }
+  std::for_each(models.begin(),
+                models.end(),
+                [this](QString model)
+                {
+                  if (m_VALID_MODELS.contains(model, Qt::CaseInsensitive))
+                    m_Controls.modelBox->addItem(model);
+                });
 }
 
 void QmitknnUNetToolGUI::OnTrainerChanged(const QString &plannerSelected)
 {
   if (plannerSelected.isEmpty())
   {
     return;
   }
   auto *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);
+      const QString parentPath = QDir::cleanPath(m_ParentFolder->getResultsFolder() + QDir::separator() + "nnUNet" +
+                                                 QDir::separator() + selectedModel + QDir::separator() + selectedTask +
+                                                 QDir::separator() + selectedTrainer + QString("__") + plannerSelected);
+      const QString jsonPath = this->DumpJSONfromPickle(parentPath);
+      if (!jsonPath.isEmpty())
+      {
+        this->DisplayMultiModalInfoFromJSON(jsonPath);
+      }
     }
   }
   else if (!m_EnsembleParams.empty())
   {
     for (auto &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](const QString& fold)
+                      [&layout](const 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);
+          const QString parentPath = QDir::cleanPath(
+            m_ParentFolder->getResultsFolder() + QDir::separator() + "nnUNet" + QDir::separator() + selectedModel +
+            QDir::separator() + selectedTask + QDir::separator() + selectedTrainer + QString("__") + plannerSelected);
+          const QString jsonPath = this->DumpJSONfromPickle(parentPath);
+          if (!jsonPath.isEmpty())
+          {
+            this->DisplayMultiModalInfoFromJSON(jsonPath);
+          }
         }
         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())
     {
+      OnPythonPathChanged(path); // recall same function for new path validation
       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);
+    DisableEverything();
+  }
+  else
+  {
+    m_Controls.modeldirectoryBox->setEnabled(true);
+    m_Controls.previewButton->setEnabled(true);
+    m_Controls.refreshdirectoryBox->setEnabled(true);
+    m_Controls.multiModalBox->setEnabled(true);
+    QString setVal = FetchResultsFolderFromEnv();
+    if (!setVal.isEmpty())
+    {
+      m_Controls.modeldirectoryBox->setDirectory(setVal);
+    }
+    OnRefreshPresssed();
+    m_PythonPath = pyEnv.mid(pyEnv.indexOf(" ") + 1);
+    if (!(m_PythonPath.endsWith("bin", Qt::CaseInsensitive) || m_PythonPath.endsWith("bin/", Qt::CaseInsensitive)))
+    {
+      m_PythonPath += QDir::separator() + QString("bin");
+    }
   }
 }
 
 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"))
+    if (box->objectName() == QString("multiModalBox"))
     {
       m_Controls.multiModalSpinLabel->setVisible(visibility);
       m_Controls.multiModalSpinBox->setVisible(visibility);
       if (visibility)
       {
         QmitkDataStorageComboBox *defaultImage = new QmitkDataStorageComboBox(this, true);
         defaultImage->setObjectName(QString("multiModal_" + QString::number(0)));
         defaultImage->SetPredicate(m_MultiModalPredicate);
         mitk::nnUNetTool::Pointer tool = this->GetConnectedToolAs<mitk::nnUNetTool>();
         if (tool != nullptr)
         {
           defaultImage->SetDataStorage(tool->GetDataStorage());
           defaultImage->SetSelectedNode(tool->GetRefNode());
         }
         m_Controls.advancedSettingsLayout->addWidget(defaultImage, m_UI_ROWS + m_Modalities.size() + 1, 1, 1, 3);
         m_Modalities.push_back(defaultImage);
-        m_UI_ROWS++;
       }
       else
       {
         OnModalitiesNumberChanged(0);
         m_Controls.multiModalSpinBox->setValue(0);
         delete m_Modalities[0];
         m_Modalities.pop_back();
+        ClearAllModalLabels();
       }
     }
   }
 }
 
 void QmitknnUNetToolGUI::OnModalitiesNumberChanged(int num)
 {
   while (num > static_cast<int>(m_Modalities.size() - 1))
   {
     QmitkDataStorageComboBox *multiModalBox = new QmitkDataStorageComboBox(this, true);
     mitk::nnUNetTool::Pointer tool = this->GetConnectedToolAs<mitk::nnUNetTool>();
     multiModalBox->SetDataStorage(tool->GetDataStorage());
     multiModalBox->SetPredicate(m_MultiModalPredicate);
     multiModalBox->setObjectName(QString("multiModal_" + QString::number(m_Modalities.size() + 1)));
     m_Controls.advancedSettingsLayout->addWidget(multiModalBox, m_UI_ROWS + m_Modalities.size() + 1, 1, 1, 3);
     m_Modalities.push_back(multiModalBox);
   }
   while (num < static_cast<int>(m_Modalities.size() - 1) && !m_Modalities.empty())
   {
     QmitkDataStorageComboBox *child = m_Modalities.back();
     if (child->objectName() == "multiModal_0")
     {
       std::iter_swap(m_Modalities.end() - 2, m_Modalities.end() - 1);
       child = m_Modalities.back();
     }
     delete child; // delete the layout item
     m_Modalities.pop_back();
   }
   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());
+  requestObject.timeStamp =
+    std::to_string(mitk::RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint());
   return requestObject;
 }
 
 void QmitknnUNetToolGUI::SegmentationProcessFailed()
 {
   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)
+void QmitknnUNetToolGUI::SegmentationResultHandler(mitk::nnUNetTool *tool, bool forceRender)
 {
-  tool->RenderOutputBuffer();
+  if (forceRender)
+  {
+    tool->RenderOutputBuffer();
+  }
   this->SetLabelSetPreview(tool->GetMLPreview());
-  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);
+  WriteStatusMessage("<b>STATUS: </b><i>Segmentation task finished successfully. <br> If multiple Preview objects are selected to Confirm, "
+  "they will be merged. Any unselected Preview objects will be lost.</i>");
 }
 
 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);
+    m_Controls.advancedSettingsLayout->addWidget(groupBoxModel1, 5, 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);
+    m_Controls.advancedSettingsLayout->addWidget(groupBoxModel2, 5, 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 (auto &layout : m_EnsembleParams)
   {
     layout->setVisible(visible);
   }
 }