diff --git a/Modules/Segmentation/Interactions/mitknnUnetTool.cpp b/Modules/Segmentation/Interactions/mitknnUnetTool.cpp
index bacb78f4cb..07afb75ef2 100644
--- a/Modules/Segmentation/Interactions/mitknnUnetTool.cpp
+++ b/Modules/Segmentation/Interactions/mitknnUnetTool.cpp
@@ -1,340 +1,345 @@
 /*============================================================================
 
 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();
-  m_InputOutputPair = std::make_pair(nullptr, nullptr);
 }
 
 void mitk::nnUNetTool::UpdateCleanUp()
 {
   // This overriden method is intentionally left out for setting later upon demand
   // in the `RenderOutputBuffer` method.
 }
 
 void mitk::nnUNetTool::RenderOutputBuffer()
 {
+  MITK_INFO << "inn RenderOutputBuffer";
   if (this->m_OutputBuffer != nullptr)
   {
     Superclass::SetNodeProperties(this->m_OutputBuffer);
-    this->ClearOutputBuffer();
     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)
 {
   // This overriden method doesn't set node properties. Intentionally left out for setting later upon demand
   // in the `RenderOutputBuffer` method.
   this->m_OutputBuffer = segmentation;
+  MITK_INFO << "inn derived SetNodeProperties " << this->m_OutputBuffer.GetPointer();
 }
 
 mitk::LabelSetImage::Pointer mitk::nnUNetTool::GetOutputBuffer()
 {
+  MITK_INFO << "inn GetOutputBuffer " << this->m_OutputBuffer.GetPointer();
   return this->m_OutputBuffer;
 }
 
 void mitk::nnUNetTool::ClearOutputBuffer()
 {
+  MITK_INFO << "inn ClearOutputBuffer " << this->m_OutputBuffer.GetPointer();
   this->m_OutputBuffer = nullptr;
 }
 
 us::ModuleResource mitk::nnUNetTool::GetIconResource() const
 {
   us::Module *module = us::GetModuleContext()->GetModule();
   us::ModuleResource resource = module->GetResource("Watershed_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*/)
+mitk::LabelSetImage::Pointer mitk::nnUNetTool::ComputeMLPreview(const Image *inputAtTimeStep, TimeStepType timeStep)
 {
-  if (m_InputOutputPair.first == inputAtTimeStep)
+  MITK_INFO << "IN ComputeMLPreview " << timeStep;
+  if (m_InputBuffer == inputAtTimeStep)
   {
-    return m_InputOutputPair.second;
+    return m_OutputBuffer;
   }
   std::string inDir, outDir, inputImagePath, outputImagePath, scriptPath;
-  std::string templateFilename = "XXXXXX_000_0000.nii.gz";
 
   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, templateFilename, inDir + IOUtil::GetDirectorySeparator());
+  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
   {
     IOUtil::Save(inputAtTimeStep, inputImagePath);
-
     if (this->GetMultiModal())
     {
       std::string outModalFile;
       int len = inDir.length() + token.length() + 1 + 8 + 2 + 7;
       outModalFile.reserve(len);
+      const std::string fileFormat(".nii.gz");
+      const std::string fileNamePart("_000_000");
       for (size_t i = 0; i < this->m_OtherModalPaths.size(); ++i)
       {
         mitk::Image::ConstPointer modalImage = this->m_OtherModalPaths[i];
         outModalFile.append(inDir);
         outModalFile.push_back(IOUtil::GetDirectorySeparator());
         outModalFile.append(token);
-        outModalFile.append("_000_000");
+        outModalFile.append(fileNamePart);
         outModalFile.append(std::to_string(i + 1));
-        outModalFile.append(".nii.gz");
+        outModalFile.append(fileFormat);
         IOUtil::Save(modalImage.GetPointer(), outModalFile);
         outModalFile.clear();
       }
     }
   }
   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)
   {
+    MITK_INFO << "IN ComputeMLPreview Segmenting... ";
     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
     {
-    for (auto arg : args)
-    {
-      MITK_INFO << arg;
-    }
+      // for (auto arg : args)
+      // {
+      //   MITK_INFO << arg;
+      // }
       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());
     }
     for (auto arg : args)
     {
       MITK_INFO << arg;
     }
     spExec->Execute(this->GetPythonPath(), command, args);
   }
   try
   {
+    //outputImagePath = "/Users/ashis/DKFZ/nnUNet/nnUNet/out_dir/heart_single/la_000.nii.gz";
     LabelSetImage::Pointer resultImage = LabelSetImage::New();
     Image::Pointer outputImage = IOUtil::Load<Image>(outputImagePath);
     resultImage->InitializeByLabeledImage(outputImage);
     resultImage->SetGeometry(inputAtTimeStep->GetGeometry());
-    m_InputOutputPair = std::make_pair(inputAtTimeStep, resultImage);
+    m_InputBuffer = inputAtTimeStep;
     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 9e5a31cac3..9185b0f0a7 100644
--- a/Modules/Segmentation/Interactions/mitknnUnetTool.h
+++ b/Modules/Segmentation/Interactions/mitknnUnetTool.h
@@ -1,196 +1,214 @@
 /*============================================================================
 
 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>
 
 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;
 
-    std::pair<const Image *, LabelSetImage::Pointer> m_InputOutputPair;
+    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;
+
   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;
-    void SetNodeProperties(LabelSetImage::Pointer) override;
 
   private:
     std::string m_MitkTempDir;
     std::string m_nnUNetDirectory;
     std::string m_ModelDirectory;
     std::string m_PythonPath;
     std::string m_PostProcessingJsonDirectory;
     // bool m_UseGPU; kept for future
     // bool m_AllInGPU;
     bool m_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/QmitknnUNetToolGUI.cpp b/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUI.cpp
index 64082d4a0f..97e900534a 100644
--- a/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUI.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUI.cpp
@@ -1,385 +1,438 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitknnUNetToolGUI.h"
 
 #include "mitknnUnetTool.h"
 #include <QApplication>
 #include <QDir>
 #include <QIcon>
 #include <QtGlobal>
 
 MITK_TOOL_GUI_MACRO(MITKSEGMENTATIONUI_EXPORT, QmitknnUNetToolGUI, "")
 
 QmitknnUNetToolGUI::QmitknnUNetToolGUI() : QmitkAutoMLSegmentationToolGUIBase()
 {
   // Nvidia-smi command returning zero doesn't alway mean lack of GPUs.
   // Pytorch uses its own libraries to communicate to the GPUs. Hence, only a warning can be given.
   if (m_GpuLoader.GetGPUCount() == 0)
   {
     std::string warning = "WARNING: No GPUs were detected on your machine. The nnUNet tool might not work.";
     ShowErrorMessage(warning);
   }
 
   // define predicates for multi modal data selection combobox
   auto imageType = mitk::TNodePredicateDataType<mitk::Image>::New();
   auto labelSetImageType = mitk::NodePredicateNot::New(mitk::TNodePredicateDataType<mitk::LabelSetImage>::New());
   this->m_MultiModalPredicate = mitk::NodePredicateAnd::New(imageType, labelSetImageType).GetPointer();
 }
 
 void QmitknnUNetToolGUI::ConnectNewTool(mitk::AutoSegmentationWithPreviewTool *newTool)
 {
   Superclass::ConnectNewTool(newTool);
   newTool->IsTimePointChangeAwareOff();
 }
 
 void QmitknnUNetToolGUI::InitializeUI(QBoxLayout *mainLayout)
 {
   m_Controls.setupUi(this);
 #ifndef _WIN32
   m_Controls.pythonEnvComboBox->addItem("/usr/bin");
 #endif
   m_Controls.pythonEnvComboBox->addItem("Select");
   AutoParsePythonPaths();
   connect(m_Controls.previewButton, SIGNAL(clicked()), this, SLOT(OnPreviewRequested()));
   connect(m_Controls.modeldirectoryBox,
           SIGNAL(directoryChanged(const QString &)),
           this,
           SLOT(OnDirectoryChanged(const QString &)));
   connect(
     m_Controls.modelBox, SIGNAL(currentTextChanged(const QString &)), this, SLOT(OnModelChanged(const QString &)));
   connect(m_Controls.taskBox, SIGNAL(currentTextChanged(const QString &)), this, SLOT(OnTaskChanged(const QString &)));
   connect(
     m_Controls.plannerBox, SIGNAL(currentTextChanged(const QString &)), this, SLOT(OnTrainerChanged(const QString &)));
   connect(m_Controls.nopipBox, SIGNAL(stateChanged(int)), this, SLOT(OnCheckBoxChanged(int)));
   connect(m_Controls.multiModalBox, SIGNAL(stateChanged(int)), this, SLOT(OnCheckBoxChanged(int)));
   connect(m_Controls.multiModalSpinBox, SIGNAL(valueChanged(int)), this, SLOT(OnModalitiesNumberChanged(int)));
   connect(m_Controls.posSpinBox, SIGNAL(valueChanged(int)), this, SLOT(OnModalPositionChanged(int)));
   connect(m_Controls.pythonEnvComboBox,
 #if QT_VERSION >= 0x050F00 // 5.15
           SIGNAL(textActivated(const QString &)),
 #elif QT_VERSION >= 0x050C00 // 5.12
           SIGNAL(activated(const QString &)),
 #endif
           this,
           SLOT(OnPythonPathChanged(const QString &)));
   connect(m_Controls.refreshdirectoryBox, SIGNAL(clicked()), this, SLOT(OnRefreshPresssed()));
+  connect(m_Controls.clearCacheButton, SIGNAL(clicked()), this, SLOT(OnClearCachePressed()));
 
   m_Controls.codedirectoryBox->setVisible(false);
   m_Controls.nnUnetdirLabel->setVisible(false);
   m_Controls.multiModalSpinBox->setVisible(false);
   m_Controls.multiModalSpinLabel->setVisible(false);
   m_Controls.posSpinBoxLabel->setVisible(false);
   m_Controls.posSpinBox->setVisible(false);
   m_Controls.previewButton->setEnabled(false);
 
   QSize sz(16, 16);
   m_Controls.stopButton->setVisible(false);
 
   QIcon refreshIcon;
   refreshIcon.addPixmap(style()->standardIcon(QStyle::SP_BrowserReload).pixmap(sz), QIcon::Normal, QIcon::Off);
   m_Controls.refreshdirectoryBox->setIcon(refreshIcon);
   m_Controls.refreshdirectoryBox->setEnabled(true);
 
   m_Controls.statusLabel->setTextFormat(Qt::RichText);
   ShowStatusMessage(QString("<b>STATUS: </b><i>Welcome to nnUNet. " + QString::number(m_GpuLoader.GetGPUCount()) +
                             " GPUs were detected.</i>"));
   if (m_GpuLoader.GetGPUCount() != 0)
   {
     m_Controls.gpuSpinBox->setMaximum(m_GpuLoader.GetGPUCount() - 1);
   }
   mainLayout->addLayout(m_Controls.verticalLayout);
   Superclass::InitializeUI(mainLayout);
   m_UI_ROWS = m_Controls.advancedSettingsLayout->rowCount(); // Must do. Row count is correct only here.
 }
 
 void QmitknnUNetToolGUI::OnPreviewRequested()
 {
   mitk::nnUNetTool::Pointer tool = this->GetConnectedToolAs<mitk::nnUNetTool>();
   if (nullptr != tool)
   {
     try
     {
+      size_t hashKey(0);
       m_Controls.previewButton->setEnabled(false); // To prevent misclicked back2back prediction.
       qApp->processEvents();
       tool->PredictOn(); // purposefully placed to make tool->GetMTime different than before.
       QString modelName = m_Controls.modelBox->currentText();
       if (modelName.startsWith("ensemble", Qt::CaseInsensitive))
       {
         ProcessEnsembleModelsParams(tool);
       }
       else
       {
         ProcessModelParams(tool);
       }
       QString pythonPathTextItem = m_Controls.pythonEnvComboBox->currentText();
       QString pythonPath = pythonPathTextItem.mid(pythonPathTextItem.indexOf(" ") + 1);
       bool isNoPip = m_Controls.nopipBox->isChecked();
 #ifdef _WIN32
       if (!isNoPip && !(pythonPath.endsWith("Scripts", Qt::CaseInsensitive) ||
                         pythonPath.endsWith("Scripts/", Qt::CaseInsensitive)))
       {
         pythonPath += QDir::separator() + QString("Scripts");
       }
 #else
       if (!(pythonPath.endsWith("bin", Qt::CaseInsensitive) || pythonPath.endsWith("bin/", Qt::CaseInsensitive)))
       {
         pythonPath += QDir::separator() + QString("bin");
       }
 #endif
       std::string nnUNetDirectory;
       if (isNoPip)
       {
         nnUNetDirectory = m_Controls.codedirectoryBox->directory().toStdString();
       }
-      else if (!IsNNUNetInstalled(pythonPath))
-      {
-        throw std::runtime_error("nnUNet is not detected in the selected python environment. Please select a valid "
-                                 "python environment or install nnUNet.");
-      }
+      // else if (!IsNNUNetInstalled(pythonPath))
+      // {
+      //   throw std::runtime_error("nnUNet is not detected in the selected python environment. Please select a valid "
+      //                            "python environment or install nnUNet.");
+      // }
 
       tool->SetnnUNetDirectory(nnUNetDirectory);
       tool->SetPythonPath(pythonPath.toStdString());
       tool->SetModelDirectory(m_ParentFolder->getResultsFolder().toStdString());
       // checkboxes
       tool->SetMirror(m_Controls.mirrorBox->isChecked());
       tool->SetMixedPrecision(m_Controls.mixedPrecisionBox->isChecked());
       tool->SetNoPip(isNoPip);
       tool->SetMultiModal(m_Controls.multiModalBox->isChecked());
+      bool doCache = m_Controls.enableCachingCheckBox->isChecked();
       // Spinboxes
       tool->SetGpuId(static_cast<unsigned int>(m_Controls.gpuSpinBox->value()));
       // Multi-Modal
       tool->MultiModalOff();
       if (m_Controls.multiModalBox->isChecked())
       {
         tool->m_OtherModalPaths.clear();
         tool->m_OtherModalPaths = FetchMultiModalImagesFromUI();
         tool->MultiModalOn();
       }
-      tool->m_InputOutputPair = std::make_pair(nullptr, nullptr);
-      ShowStatusMessage(QString("<b>STATUS: </b><i>Starting Segmentation task... This might take a while.</i>"));
-      tool->UpdatePreview();
-      if (tool->GetOutputBuffer() == nullptr)
+      if (doCache)
+      {
+        hashKey = nnUNetCache::GetUniqueHash(tool->m_ParamQ);
+        if (this->m_Cache.contains(hashKey))
+        {
+          tool->PredictOff(); // purposefully placed to make tool->GetMTime different than before.
+        }
+      }
+      if (tool->GetPredict())
       {
-        SegmentationProcessFailed();
+        tool->m_InputBuffer = nullptr;
+        ShowStatusMessage(QString("<b>STATUS: </b><i>Starting Segmentation task... This might take a while.</i>"));
+        tool->UpdatePreview();
+        if (tool->GetOutputBuffer() == nullptr)
+        {
+          SegmentationProcessFailed();
+        }
+        else
+        {
+          SegmentationResultHandler(tool);
+        }
+        if (doCache)
+        {
+          addToCache(hashKey, tool->GetMLPreview());
+        }
+        tool->PredictOff(); // purposefully placed to make tool->GetMTime different than before.
+      }
+      else
+      {
+        MITK_INFO << "won't do segmentation. Key found: " << QString::number(hashKey).toStdString();
+        if (this->m_Cache.contains(hashKey))
+        {
+          nnUNetCache *cacheObject = this->m_Cache[hashKey];
+          MITK_INFO << "fetched pointer " << cacheObject->m_SegCache.GetPointer();
+          tool->SetNodeProperties(const_cast<mitk::LabelSetImage *>(cacheObject->m_SegCache.GetPointer()));
+          SegmentationResultHandler(tool);
+        }
       }
-      SegmentationResultHandler(tool);
-      tool->PredictOff(); // purposefully placed to make tool->GetMTime different than before.
       m_Controls.previewButton->setEnabled(true);
     }
     catch (const std::exception &e)
     {
       std::stringstream errorMsg;
       errorMsg << "Error while processing parameters for nnUNet segmentation. Reason: " << e.what();
       ShowErrorMessage(errorMsg.str());
       ShowStatusMessage(QString::fromStdString(errorMsg.str()));
       m_Controls.previewButton->setEnabled(true);
       tool->PredictOff();
       return;
     }
     catch (...)
     {
       std::string errorMsg = "Unkown error occured while generation nnUNet segmentation.";
       ShowErrorMessage(errorMsg);
       m_Controls.previewButton->setEnabled(true);
       tool->PredictOff();
       return;
     }
   }
 }
 
 std::vector<mitk::Image::ConstPointer> QmitknnUNetToolGUI::FetchMultiModalImagesFromUI()
 {
   std::vector<mitk::Image::ConstPointer> paths;
   if (m_Controls.multiModalBox->isChecked() && !m_Modalities.empty())
   {
     for (QmitkDataStorageComboBox *modality : m_Modalities)
     {
       if (modality->objectName() != "multiModal_0")
       {
         paths.push_back(dynamic_cast<const mitk::Image *>(modality->GetSelectedNode()->GetData()));
       }
     }
   }
   return paths;
 }
 
 bool QmitknnUNetToolGUI::IsNNUNetInstalled(const QString &pythonPath)
 {
   QString fullPath = pythonPath;
 #ifdef _WIN32
   if (!(fullPath.endsWith("Scripts", Qt::CaseInsensitive) || fullPath.endsWith("Scripts/", Qt::CaseInsensitive)))
   {
     fullPath += QDir::separator() + QString("Scripts");
   }
 #else
   if (!(fullPath.endsWith("bin", Qt::CaseInsensitive) || fullPath.endsWith("bin/", Qt::CaseInsensitive)))
   {
     fullPath += QDir::separator() + QString("bin");
   }
 #endif
   fullPath = fullPath.mid(fullPath.indexOf(" ") + 1);
   return QFile::exists(fullPath + QDir::separator() + QString("nnUNet_predict"));
 }
 
 void QmitknnUNetToolGUI::ShowErrorMessage(const std::string &message, QMessageBox::Icon icon)
 {
   this->setCursor(Qt::ArrowCursor);
   QMessageBox *messageBox = new QMessageBox(icon, nullptr, message.c_str());
   messageBox->exec();
   delete messageBox;
   MITK_WARN << message;
 }
 
 void QmitknnUNetToolGUI::ShowStatusMessage(const QString &message)
 {
   m_Controls.statusLabel->setText(message);
 }
 
 void QmitknnUNetToolGUI::ProcessEnsembleModelsParams(mitk::nnUNetTool::Pointer tool)
 {
   if (m_EnsembleParams[0]->modelBox->currentText() == m_EnsembleParams[1]->modelBox->currentText())
   {
     throw std::runtime_error("Both models you have selected for ensembling are the same.");
   }
   QString taskName = m_Controls.taskBox->currentText();
   bool isPPJson = m_Controls.postProcessingCheckBox->isChecked();
   std::vector<mitk::ModelParams> requestQ;
   QString ppDirFolderNamePart1 = "ensemble_";
   QStringList ppDirFolderNameParts;
   for (std::unique_ptr<QmitknnUNetTaskParamsUITemplate> &layout : m_EnsembleParams)
   {
     QStringList ppDirFolderName;
     QString modelName = layout->modelBox->currentText();
     ppDirFolderName << modelName;
     ppDirFolderName << "__";
     QString trainer = layout->trainerBox->currentText();
     ppDirFolderName << trainer;
     ppDirFolderName << "__";
     QString planId = layout->plannerBox->currentText();
     ppDirFolderName << planId;
 
     if (!IsModelExists(modelName, taskName, QString(trainer + "__" + planId)))
     {
       std::string errorMsg = "The configuration " + modelName.toStdString() +
                              " you have selected doesn't exist. Check your Results Folder again.";
       throw std::runtime_error(errorMsg);
     }
     std::vector<std::string> testfold = FetchSelectedFoldsFromUI(layout->foldBox);
     mitk::ModelParams modelObject = MapToRequest(modelName, taskName, trainer, planId, testfold);
     requestQ.push_back(modelObject);
     ppDirFolderNameParts << ppDirFolderName.join(QString(""));
   }
   tool->EnsembleOn();
   if (isPPJson)
   {
     QString ppJsonFilePossibility1 = QDir::cleanPath(
       m_ParentFolder->getResultsFolder() + QDir::separator() + "nnUNet" + QDir::separator() + "ensembles" +
       QDir::separator() + taskName + QDir::separator() + ppDirFolderNamePart1 + ppDirFolderNameParts.first() + "--" +
       ppDirFolderNameParts.last() + QDir::separator() + "postprocessing.json");
     QString ppJsonFilePossibility2 = QDir::cleanPath(
       m_ParentFolder->getResultsFolder() + QDir::separator() + "nnUNet" + QDir::separator() + "ensembles" +
       QDir::separator() + taskName + QDir::separator() + ppDirFolderNamePart1 + ppDirFolderNameParts.last() + "--" +
       ppDirFolderNameParts.first() + QDir::separator() + "postprocessing.json");
 
     if (QFile(ppJsonFilePossibility1).exists())
     {
       tool->SetPostProcessingJsonDirectory(ppJsonFilePossibility1.toStdString());
       const QString statusMsg = "<i>Post Processing JSON file found: </i>" + ppJsonFilePossibility1;
       ShowStatusMessage(statusMsg);
     }
     else if (QFile(ppJsonFilePossibility2).exists())
     {
       tool->SetPostProcessingJsonDirectory(ppJsonFilePossibility2.toStdString());
       const QString statusMsg = "<i>Post Processing JSON file found:</i>" + ppJsonFilePossibility2;
       ShowStatusMessage(statusMsg);
     }
     else
     {
       std::string errorMsg =
         "No post processing file was found for the selected ensemble combination. Continuing anyway...";
       ShowErrorMessage(errorMsg);
     }
   }
   tool->m_ParamQ.clear();
   tool->m_ParamQ = requestQ;
 }
 
 void QmitknnUNetToolGUI::ProcessModelParams(mitk::nnUNetTool::Pointer tool)
 {
   tool->EnsembleOff();
   std::vector<mitk::ModelParams> requestQ;
   QString modelName = m_Controls.modelBox->currentText();
   QString taskName = m_Controls.taskBox->currentText();
   QString trainer = m_Controls.trainerBox->currentText();
   QString planId = m_Controls.plannerBox->currentText();
   std::vector<std::string> fetchedFolds = FetchSelectedFoldsFromUI(m_Controls.foldBox);
   mitk::ModelParams modelObject = MapToRequest(modelName, taskName, trainer, planId, fetchedFolds);
   requestQ.push_back(modelObject);
   tool->m_ParamQ.clear();
   tool->m_ParamQ = requestQ;
 }
 
 bool QmitknnUNetToolGUI::IsModelExists(const QString &modelName, const QString &taskName, const QString &trainerPlanner)
 {
   QString modelSearchPath =
     QDir::cleanPath(m_ParentFolder->getResultsFolder() + QDir::separator() + "nnUNet" + QDir::separator() + modelName +
                     QDir::separator() + taskName + QDir::separator() + trainerPlanner);
   if (QDir(modelSearchPath).exists())
   {
     return true;
   }
   return false;
 }
 
 void QmitknnUNetToolGUI::CheckAllInCheckableComboBox(ctkCheckableComboBox *foldBox)
 {
   // Recalling all added items to check-mark it.
   const QAbstractItemModel *qaim = foldBox->checkableModel();
   // for (int i = 0; i < folds.size(); ++i)
   auto rows = qaim->rowCount();
   for (int i = 0; i < rows; ++i)
   {
     const QModelIndex mi = qaim->index(i, 0);
     foldBox->setCheckState(mi, Qt::Checked);
   }
 }
 
 std::pair<QStringList, QStringList> QmitknnUNetToolGUI::ExtractTrainerPlannerFromString(QStringList trainerPlanners)
 {
   QString splitterString = "__";
   QStringList trainers, planners;
   foreach (QString trainerPlanner, trainerPlanners)
   {
     trainers << trainerPlanner.split(splitterString, QString::SplitBehavior::SkipEmptyParts).first();
     planners << trainerPlanner.split(splitterString, QString::SplitBehavior::SkipEmptyParts).last();
   }
   trainers.removeDuplicates();
   planners.removeDuplicates();
   std::pair<QStringList, QStringList> returnPair = {trainers, planners};
   return returnPair;
 }
 
 std::vector<std::string> QmitknnUNetToolGUI::FetchSelectedFoldsFromUI(ctkCheckableComboBox *foldBox)
 {
   std::vector<std::string> folds;
   if (!(foldBox->allChecked() || foldBox->noneChecked()))
   {
     QModelIndexList foldList = foldBox->checkedIndexes();
     foreach (QModelIndex index, foldList)
     {
       QString foldQString = foldBox->itemText(index.row()).split("_", QString::SplitBehavior::SkipEmptyParts).last();
       folds.push_back(foldQString.toStdString());
     }
   }
   return folds;
 }
+
+void QmitknnUNetToolGUI::OnClearCachePressed()
+{
+  m_Cache.clear();
+  UpdateCacheCountOnUI();
+}
+
+void QmitknnUNetToolGUI::UpdateCacheCountOnUI()
+{
+  QString cacheText = m_CACHE_COUNT_BASE_LABEL + QString::number(m_Cache.size());
+  m_Controls.cacheCountLabel->setText(cacheText);
+}
+
+void QmitknnUNetToolGUI::addToCache(size_t &hashKey, mitk::LabelSetImage::ConstPointer mlPreview)
+{
+  nnUNetCache *newCacheObj = new nnUNetCache;
+  newCacheObj->m_SegCache = mlPreview;
+  this->m_Cache.insert(hashKey, newCacheObj);
+  MITK_INFO << "New hash: " << hashKey << " " << newCacheObj->m_SegCache.GetPointer();
+  UpdateCacheCountOnUI();
+}
diff --git a/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUI.h b/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUI.h
index 6828056fb1..e709800b1b 100644
--- a/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUI.h
+++ b/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUI.h
@@ -1,240 +1,271 @@
 /*============================================================================
 
 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 <QmitkDataStorageComboBox.h>
 #include <QmitknnUNetEnsembleLayout.h>
+#include <boost/functional/hash.hpp>
+
+class nnUNetCache
+{
+public:
+  mitk::LabelSetImage::ConstPointer m_SegCache;
+  static size_t GetUniqueHash(std::vector<mitk::ModelParams> &requestQ)
+  {
+    size_t hashCode = 0;
+    for (mitk::ModelParams &request : requestQ)
+    {
+      boost::hash_combine(hashCode, request.generateHash());
+    }
+    return hashCode;
+  }
+};
 
 class MITKSEGMENTATIONUI_EXPORT QmitknnUNetToolGUI : public QmitkAutoMLSegmentationToolGUIBase
 {
   Q_OBJECT
 
 public:
   mitkClassMacro(QmitknnUNetToolGUI, QmitkAutoMLSegmentationToolGUIBase);
   itkFactorylessNewMacro(Self);
   itkCloneMacro(Self);
 
+  QCache<size_t, nnUNetCache> m_Cache;
+
 protected slots:
 
   /**
    * @brief Qt slot
    *
    */
   void OnPreviewRequested();
 
   /**
    * @brief Qt slot
    *
    */
   void OnDirectoryChanged(const QString &);
 
   /**
    * @brief Qt slot
    *
    */
   void OnModelChanged(const QString &);
 
   /**
    * @brief Qt slot
    *
    */
   void OnTaskChanged(const QString &);
 
   /**
    * @brief Qt slot
    *
    */
   void OnTrainerChanged(const QString &);
 
   /**
    * @brief Qt slot
    *
    */
   void OnCheckBoxChanged(int);
 
   /**
    * @brief Qthread slot to capture failures from thread worker and
    * shows error message
    *
    */
   void SegmentationProcessFailed();
 
   /**
    * @brief Qthread to capture sucessfull nnUNet segmentation.
    * Further, renders the LabelSet image
    */
   void SegmentationResultHandler(mitk::nnUNetTool *);
 
   /**
    * @brief Qt Slot
    *
    */
   void OnModalitiesNumberChanged(int);
 
   /**
    * @brief Qt Slot
    *
    */
   void OnPythonPathChanged(const QString &);
 
   /**
    * @brief Qt Slot
    *
    */
   void OnModalPositionChanged(int);
 
   /**
    * @brief Qt slot
    *
    */
   void OnRefreshPresssed();
 
+  /**
+   * @brief Qt slot
+   *
+   */
+  void OnClearCachePressed();
+
 protected:
   QmitknnUNetToolGUI();
   ~QmitknnUNetToolGUI() = default;
 
   void ConnectNewTool(mitk::AutoSegmentationWithPreviewTool *newTool) override;
   void InitializeUI(QBoxLayout *mainLayout) override;
   void EnableWidgets(bool enabled) override;
 
 private:
+
+  void addToCache(size_t&, mitk::LabelSetImage::ConstPointer);
   /**
    * @brief Checks all the entries of the ctkCheckableComboBox ui widget.
    * This feature is not present in ctkCheckableComboBox API.
    */
   void CheckAllInCheckableComboBox(ctkCheckableComboBox *);
 
   /**
    * @brief Parses the folder names containing trainer and planner together and,
    * returns it as separate lists.
    * @return std::pair<QStringList, QStringList>
    */
 
   std::pair<QStringList, QStringList> ExtractTrainerPlannerFromString(QStringList);
   /**
    * @brief Parses the ensemble UI elements and sets to nnUNetTool object pointer.
    *
    */
   void ProcessEnsembleModelsParams(mitk::nnUNetTool::Pointer);
 
   /**
    * @brief Parses the UI elements and sets to nnUNetTool object pointer.
    *
    */
   void ProcessModelParams(mitk::nnUNetTool::Pointer);
 
   /**
    * @brief Creates and renders QmitknnUNetTaskParamsUITemplate layout for ensemble input.
    */
   void ShowEnsembleLayout(bool visible = true);
 
   /**
    * @brief Creates a QMessage object and shows on screen.
    */
   void ShowErrorMessage(const std::string &, QMessageBox::Icon = QMessageBox::Critical);
 
   /**
    * @brief Shows any message on the tool pane.
    */
   void ShowStatusMessage(const QString &);
 
   /**
    * @brief Searches and parses paths of python virtual enviroments
    * from predefined lookout locations
    */
   void AutoParsePythonPaths();
 
   /**
    * @brief Check if pretrained model sub folder inside RESULTS FOLDER exist.
    *
    */
   bool IsModelExists(const QString &, const QString &, const QString &);
 
   /**
    * @brief Clears all combo boxes
    * Any new combo box added in the future can be featured here for clearance.
    *
    */
   void ClearAllComboBoxes();
 
   /**
    * @brief Checks if nnUNet_predict command is valid in the selected python virtual environment.
    *
    * @return bool
    */
   bool IsNNUNetInstalled(const QString &);
 
   /**
    * @brief Mapper function to map QString entries from UI to ModelParam attributes.
    *
    * @return mitk::ModelParams
    */
   mitk::ModelParams MapToRequest(
     const QString &, const QString &, const QString &, const QString &, const std::vector<std::string> &);
 
   /**
    * @brief Returns checked fold names from the ctk-Checkable-ComboBox.
    *
    * @return std::vector<std::string>
    */
   std::vector<std::string> FetchSelectedFoldsFromUI(ctkCheckableComboBox *);
 
   /**
    * @brief Returns all paths from the dynamically generated ctk-path-line-edit boxes.
    *
    * @return std::vector<std::string>
    */
   std::vector<mitk::Image::ConstPointer> FetchMultiModalImagesFromUI();
 
+  void UpdateCacheCountOnUI();
+
   Ui_QmitknnUNetToolGUIControls m_Controls;
   QmitkGPULoader m_GpuLoader;
 
   /**
    * @brief Stores all dynamically added ctk-path-line-edit UI elements.
    *
    */
   std::vector<QmitkDataStorageComboBox *> m_Modalities;
 
   std::vector<std::unique_ptr<QmitknnUNetTaskParamsUITemplate>> m_EnsembleParams;
 
   mitk::NodePredicateBase::Pointer m_MultiModalPredicate;
 
   /**
    * @brief Stores row count of the "advancedSettingsLayout" layout element. This value helps dynamically add
    * ctk-path-line-edit UI elements at the right place. Forced to initialize in the InitializeUI method since there is
    * no guarantee of retrieving exact row count anywhere else.
    *
    */
   int m_UI_ROWS;
 
   /**
    * @brief Stores path of the model director (RESULTS_FOLDER appended by "nnUNet").
    *
    */
   std::shared_ptr<QmitknnUNetFolderParser> m_ParentFolder = nullptr;
 
   /**
    * @brief Valid list of models supported by nnUNet
    *
    */
   const QStringList m_VALID_MODELS = {"2d", "3d_lowres", "3d_fullres", "3d_cascade_fullres", "ensembles"};
+
+  const QString m_CACHE_COUNT_BASE_LABEL = "Cached Items: ";
 };
 #endif
diff --git a/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUIControls.ui b/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUIControls.ui
index 5b019337ed..b5d13b3c8a 100644
--- a/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUIControls.ui
+++ b/Modules/SegmentationUI/Qmitk/QmitknnUNetToolGUIControls.ui
@@ -1,460 +1,502 @@
 <?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>192</width>
         <height>352</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="0" 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="0" column="1" colspan="3">
             <widget class="ctkDirectoryButton" name="modeldirectoryBox" native="true" />
           </item>
-          
+
           <!-- </item> -->
           <item row="1" column="1" colspan="3">
             <widget class="QPushButton" name="refreshdirectoryBox" native="false">
               <property name="text">
                 <string>Refresh Results Folder</string>
               </property>
             </widget>
           </item>
 
           <!-- </item> -->
           <item row="2" column="0">
             <widget class="QLabel" name="modelLabel">
               <property name="text">
                 <string>Configuration:</string>
               </property>
             </widget>
           </item>
           <item row="2" column="1">
             <widget class="ctkComboBox" name="modelBox" native="true" />
           </item>
           <item row="2" column="2">
             <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="2" column="3">
             <widget class="ctkComboBox" name="taskBox" native="true" />
           </item>
 
           <!-- </item> -->
           <item row="3" 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="3" column="1">
             <widget class="ctkComboBox" name="trainerBox" native="true" />
           </item>
 
           <item row="3" 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="3" column="3">
             <widget class="ctkComboBox" name="plannerBox" native="true" />
           </item>
           <!-- </item> -->
           <item row="4" column="0">
             <widget class="QLabel" name="foldLabel">
               <property name="text">
                 <string>Fold:</string>
               </property>
             </widget>
           </item>
           <item row="4" column="1">
             <widget class="ctkCheckableComboBox" name="foldBox" native="true" />
           </item>
           <item row="4" column="3">
             <widget class="QPushButton" name="stopButton" native="false">
               <property name="text">
                 <string>Stop</string>
               </property>
             </widget>
           </item>
           <!-- </item> -->
           <item row="5" 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="5" column="1">
             <widget class="ctkCheckBox" name="multiModalBox" native="true" />
           </item>
           <item row="5" 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="3">
             <widget class="QSpinBox" name="multiModalSpinBox" native="true" />
           </item>
 
           <!-- </item> -->
           <item row="6" column="2">
             <widget class="QLabel" name="posSpinBoxLabel">
               <property name="sizePolicy">
                 <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
                   <horstretch>0</horstretch>
                   <verstretch>0</verstretch>
                 </sizepolicy>
               </property>
               <property name="text">
                 <string>Reference Image Position</string>
               </property>
             </widget>
           </item>
           <item row="6" column="3">
             <widget class="QSpinBox" name="posSpinBox" native="true" />
           </item>
           <!-- </item> -->
         </layout>
       </item>
 
       <!-- start advanced-->
       <item>
         <widget class="ctkCollapsibleGroupBox" name="inputGroupBox" native="true">
           <property name="minimumSize">
             <size>
               <width>0</width>
               <height>0</height>
             </size>
           </property>
           <property name="collapsedHeight">
             <number>5</number>
           </property>
           <property name="title">
             <string>Advanced</string>
           </property>
           <property name="collapsed">
             <bool>true</bool>
           </property>
           <property name="flat">
             <bool>true</bool>
           </property>
           <property name="alignment">
             <set>Qt::AlignRight</set>
           </property>
           <layout class="QVBoxLayout" name="verticalLayout_4">
             <!--  <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="_2">
                 <property name="spacing">
                   <number>6</number>
                 </property>
                 <property name="margin">
                   <number>0</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" native="true" />
                 </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" native="true">
                     <property name="checked">
                       <bool>true</bool>
                     </property>
                   </widget>
                 </item>
                 <!-- </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="QSpinBox" name="gpuSpinBox" native="true" />
                 </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" native="true">
                     <property name="checked">
                       <bool>true</bool>
                     </property>
                   </widget>
                 </item>
                 <!-- </item> -->
                 <item row="2" 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="2" column="1" colspan="3">
                   <widget class="ctkComboBox" name="pythonEnvComboBox" native="true" />
                 </item>
                 <!-- </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> -->
                 <item row="4" 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">
                   <widget class="ctkCheckBox" name="postProcessingCheckBox" native="true">
                     <property name="checked">
                       <bool>true</bool>
                     </property>
                   </widget>
                 </item>
+                <!-- </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" native="true">
+                    <property name="checked">
+                      <bool>true</bool>
+                    </property>
+                  </widget>
+                </item>
+                <item row="5" column="2">
+                  <widget class="QPushButton" name="clearCacheButton" native="false">
+                    <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>
+                <!-- </item> -->
               </layout>
             </item>
           </layout>
         </widget>
       </item>
       <!-- end advanced-->
 
       <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>
         </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>
+</ui>
\ No newline at end of file
diff --git a/Modules/SegmentationUI/Qmitk/QmitknnUNetToolSlots.cpp b/Modules/SegmentationUI/Qmitk/QmitknnUNetToolSlots.cpp
index fc73ada7bd..869b47198a 100644
--- a/Modules/SegmentationUI/Qmitk/QmitknnUNetToolSlots.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitknnUNetToolSlots.cpp
@@ -1,443 +1,447 @@
 #include "QmitknnUNetToolGUI.h"
 #include <QDir>
 #include <QDirIterator>
 #include <QmitknnUNetEnsembleLayout.h>
 #include <algorithm>
 #include <ctkCollapsibleGroupBox.h>
 
 void QmitknnUNetToolGUI::EnableWidgets(bool enabled)
 {
   Superclass::EnableWidgets(enabled);
 }
 
 void QmitknnUNetToolGUI::ClearAllComboBoxes()
 {
   m_Controls.modelBox->clear();
   m_Controls.taskBox->clear();
   m_Controls.foldBox->clear();
   m_Controls.trainerBox->clear();
   for (std::unique_ptr<QmitknnUNetTaskParamsUITemplate> &layout : m_EnsembleParams)
   {
     layout->modelBox->clear();
     layout->trainerBox->clear();
     layout->plannerBox->clear();
     layout->foldBox->clear();
   }
 }
 
 void QmitknnUNetToolGUI::OnRefreshPresssed()
 {
   const QString resultsFolder = m_Controls.modeldirectoryBox->directory();
   OnDirectoryChanged(resultsFolder);
 }
 
 void QmitknnUNetToolGUI::OnDirectoryChanged(const QString &resultsFolder)
 {
   m_Controls.previewButton->setEnabled(false);
   this->ClearAllComboBoxes();
   m_ParentFolder = std::make_shared<QmitknnUNetFolderParser>(resultsFolder);
   auto models = m_ParentFolder->getModelNames<QStringList>();
   std::for_each(models.begin(),
                 models.end(),
                 [this](QString model)
                 {
                   if (m_VALID_MODELS.contains(model, Qt::CaseInsensitive))
                     m_Controls.modelBox->addItem(model);
                 });
 }
 
 void QmitknnUNetToolGUI::OnModelChanged(const QString &model)
 {
   if (model.isEmpty())
   {
     return;
   }
   ctkComboBox *box = qobject_cast<ctkComboBox *>(sender());
   if (box == m_Controls.modelBox)
   {
     m_Controls.taskBox->clear();
     auto tasks = m_ParentFolder->getTasksForModel<QStringList>(model);
     std::for_each(tasks.begin(), tasks.end(), [this](QString task) { m_Controls.taskBox->addItem(task); });
   }
   else if (!m_EnsembleParams.empty())
   {
     for (std::unique_ptr<QmitknnUNetTaskParamsUITemplate> &layout : m_EnsembleParams)
     {
       if (box == layout->modelBox)
       {
         layout->trainerBox->clear();
         layout->plannerBox->clear();
         QStringList trainerPlanners =
           m_ParentFolder->getTrainerPlannersForTask<QStringList>(m_Controls.taskBox->currentText(), model);
         QStringList trainers, planners;
         std::tie(trainers, planners) = ExtractTrainerPlannerFromString(trainerPlanners);
 
         std::for_each(
           trainers.begin(), trainers.end(), [&layout](QString trainer) { layout->trainerBox->addItem(trainer); });
         std::for_each(
           planners.begin(), planners.end(), [&layout](QString planner) { layout->plannerBox->addItem(planner); });
         break;
       }
     }
   }
 }
 
 void QmitknnUNetToolGUI::OnTaskChanged(const QString &task)
 {
   if (task.isEmpty())
   {
     return;
   }
   m_Controls.trainerBox->clear();
   m_Controls.plannerBox->clear();
   if (m_Controls.modelBox->currentText() == m_VALID_MODELS.last())
   {
     m_Controls.trainerBox->setVisible(false);
     m_Controls.trainerLabel->setVisible(false);
     m_Controls.plannerBox->setVisible(false);
     m_Controls.plannerLabel->setVisible(false);
     m_Controls.foldBox->setVisible(false);
     m_Controls.foldLabel->setVisible(false);
     ShowEnsembleLayout(true);
     QStringList models = m_ParentFolder->getModelsForTask<QStringList>(m_Controls.taskBox->currentText());
     models.removeDuplicates();
     models.removeOne(m_VALID_MODELS.last());
 
     for (std::unique_ptr<QmitknnUNetTaskParamsUITemplate> &layout : m_EnsembleParams)
     {
       layout->modelBox->clear();
       layout->trainerBox->clear();
       layout->plannerBox->clear();
       std::for_each(models.begin(),
                     models.end(),
                     [&layout, this](QString model)
                     {
                       if (m_VALID_MODELS.contains(model, Qt::CaseInsensitive))
                         layout->modelBox->addItem(model);
                     });
     }
     m_Controls.previewButton->setEnabled(true);
   }
   else
   {
     m_Controls.trainerBox->setVisible(true);
     m_Controls.trainerLabel->setVisible(true);
     m_Controls.plannerBox->setVisible(true);
     m_Controls.plannerLabel->setVisible(true);
     m_Controls.foldBox->setVisible(true);
     m_Controls.foldLabel->setVisible(true);
     m_Controls.previewButton->setEnabled(false);
     ShowEnsembleLayout(false);
     QStringList trainerPlanners =
       m_ParentFolder->getTrainerPlannersForTask<QStringList>(task, m_Controls.modelBox->currentText());
     QStringList trainers, planners;
     std::tie(trainers, planners) = ExtractTrainerPlannerFromString(trainerPlanners);
     std::for_each(
       trainers.begin(), trainers.end(), [this](QString trainer) { m_Controls.trainerBox->addItem(trainer); });
     std::for_each(
       planners.begin(), planners.end(), [this](QString planner) { m_Controls.plannerBox->addItem(planner); });
   }
 }
 
 void QmitknnUNetToolGUI::OnTrainerChanged(const QString &plannerSelected)
 {
   if (plannerSelected.isEmpty())
   {
     return;
   }
   ctkComboBox *box = qobject_cast<ctkComboBox *>(sender());
   if (box == m_Controls.plannerBox)
   {
     m_Controls.foldBox->clear();
     auto selectedTrainer = m_Controls.trainerBox->currentText();
     auto selectedTask = m_Controls.taskBox->currentText();
     auto selectedModel = m_Controls.modelBox->currentText();
     auto folds = m_ParentFolder->getFoldsForTrainerPlanner<QStringList>(
       selectedTrainer, plannerSelected, selectedTask, selectedModel);
     std::for_each(folds.begin(),
                   folds.end(),
                   [this](QString fold)
                   {
                     if (fold.startsWith("fold_", Qt::CaseInsensitive)) // imposed by nnUNet
                       m_Controls.foldBox->addItem(fold);
                   });
     if (m_Controls.foldBox->count() != 0)
     {
       CheckAllInCheckableComboBox(m_Controls.foldBox);
       m_Controls.previewButton->setEnabled(true);
     }
   }
   else if (!m_EnsembleParams.empty())
   {
     for (std::unique_ptr<QmitknnUNetTaskParamsUITemplate> &layout : m_EnsembleParams)
     {
       if (box == layout->plannerBox)
       {
         layout->foldBox->clear();
         auto selectedTrainer = layout->trainerBox->currentText();
         auto selectedTask = m_Controls.taskBox->currentText();
         auto selectedModel = layout->modelBox->currentText();
         auto folds = m_ParentFolder->getFoldsForTrainerPlanner<QStringList>(
           selectedTrainer, plannerSelected, selectedTask, selectedModel);
         std::for_each(folds.begin(),
                       folds.end(),
                       [&layout](QString fold)
                       {
                         if (fold.startsWith("fold_", Qt::CaseInsensitive)) // imposed by nnUNet
                           layout->foldBox->addItem(fold);
                       });
         if (layout->foldBox->count() != 0)
         {
           CheckAllInCheckableComboBox(layout->foldBox);
           m_Controls.previewButton->setEnabled(true);
         }
         break;
       }
     }
   }
 }
 
 void QmitknnUNetToolGUI::OnPythonPathChanged(const QString &pyEnv)
 {
   if (pyEnv == QString("Select"))
   {
     QString path =
       QFileDialog::getExistingDirectory(m_Controls.pythonEnvComboBox->parentWidget(), "Python Path", "dir");
     if (!path.isEmpty())
     {
       m_Controls.pythonEnvComboBox->insertItem(0, path);
       m_Controls.pythonEnvComboBox->setCurrentIndex(0);
     }
   }
   else if (!IsNNUNetInstalled(pyEnv))
   {
     std::string warning =
       "WARNING: nnUNet is not detected on the Python environment you selected. Please select another "
       "environment or create one. For more info refer https://github.com/MIC-DKFZ/nnUNet";
     ShowErrorMessage(warning);
   }
 }
 
 void QmitknnUNetToolGUI::OnCheckBoxChanged(int state)
 {
   bool visibility = false;
   if (state == Qt::Checked)
   {
     visibility = true;
   }
   ctkCheckBox *box = qobject_cast<ctkCheckBox *>(sender());
   if (box != nullptr)
   {
     if (box->objectName() == QString("nopipBox"))
     {
       m_Controls.codedirectoryBox->setVisible(visibility);
       m_Controls.nnUnetdirLabel->setVisible(visibility);
     }
     else if (box->objectName() == QString("multiModalBox"))
     {
       m_Controls.multiModalSpinLabel->setVisible(visibility);
       m_Controls.multiModalSpinBox->setVisible(visibility);
       m_Controls.posSpinBoxLabel->setVisible(visibility);
       m_Controls.posSpinBox->setVisible(visibility);
       if (visibility)
       {
         QmitkDataStorageComboBox *defaultImage = new QmitkDataStorageComboBox(this, true);
         defaultImage->setObjectName(QString("multiModal_" + QString::number(0)));
         defaultImage->SetPredicate(this->m_MultiModalPredicate);
         defaultImage->setDisabled(true);
         mitk::nnUNetTool::Pointer tool = this->GetConnectedToolAs<mitk::nnUNetTool>();
         if (tool != nullptr)
         {
           defaultImage->SetDataStorage(tool->GetDataStorage());
           defaultImage->SetSelectedNode(tool->GetRefNode());
         }
         m_Controls.advancedSettingsLayout->addWidget(defaultImage, this->m_UI_ROWS + m_Modalities.size() + 1, 1, 1, 3);
         m_Modalities.push_back(defaultImage);
         m_Controls.posSpinBox->setMaximum(this->m_Modalities.size() - 1);
         m_UI_ROWS++;
       }
       else
       {
         OnModalitiesNumberChanged(0);
         m_Controls.multiModalSpinBox->setValue(0);
         m_Controls.posSpinBox->setMaximum(0);
         delete this->m_Modalities[0];
         m_Modalities.pop_back();
       }
     }
   }
 }
 
 void QmitknnUNetToolGUI::OnModalitiesNumberChanged(int num)
 {
   while (num > static_cast<int>(this->m_Modalities.size() - 1))
   {
     QmitkDataStorageComboBox *multiModalBox = new QmitkDataStorageComboBox(this, true);
     mitk::nnUNetTool::Pointer tool = this->GetConnectedToolAs<mitk::nnUNetTool>();
     multiModalBox->SetDataStorage(tool->GetDataStorage());
     multiModalBox->SetPredicate(this->m_MultiModalPredicate);
     multiModalBox->setObjectName(QString("multiModal_" + QString::number(m_Modalities.size() + 1)));
     m_Controls.advancedSettingsLayout->addWidget(multiModalBox, this->m_UI_ROWS + m_Modalities.size() + 1, 1, 1, 3);
     m_Modalities.push_back(multiModalBox);
   }
   while (num < static_cast<int>(this->m_Modalities.size() - 1) && !m_Modalities.empty())
   {
     QmitkDataStorageComboBox *child = m_Modalities.back();
     if (child->objectName() == "multiModal_0")
     {
       std::iter_swap(this->m_Modalities.end() - 2, this->m_Modalities.end() - 1);
       child = m_Modalities.back();
     }
     delete child; // delete the layout item
     m_Modalities.pop_back();
   }
   m_Controls.posSpinBox->setMaximum(this->m_Modalities.size() - 1);
   m_Controls.advancedSettingsLayout->update();
 }
 
 void QmitknnUNetToolGUI::OnModalPositionChanged(int posIdx)
 {
   if (posIdx < static_cast<int>(m_Modalities.size()))
   {
     int currPos = 0;
     bool stopCheck = false;
     // for-loop clears all widgets from the QGridLayout and also, finds the position of loaded-image widget.
     for (QmitkDataStorageComboBox *multiModalBox : m_Modalities)
     {
       m_Controls.advancedSettingsLayout->removeWidget(multiModalBox);
       multiModalBox->setParent(nullptr);
       if (multiModalBox->objectName() != "multiModal_0" && !stopCheck)
       {
         currPos++;
       }
       else
       {
         stopCheck = true;
       }
     }
     // moving the loaded-image widget to the required position
     std::iter_swap(this->m_Modalities.begin() + currPos, m_Modalities.begin() + posIdx);
     // re-adding all widgets in the order
     for (int i = 0; i < static_cast<int>(m_Modalities.size()); ++i)
     {
       QmitkDataStorageComboBox *multiModalBox = m_Modalities[i];
       m_Controls.advancedSettingsLayout->addWidget(multiModalBox, m_UI_ROWS + i + 1, 1, 1, 3);
     }
     m_Controls.advancedSettingsLayout->update();
   }
 }
 
 void QmitknnUNetToolGUI::AutoParsePythonPaths()
 {
   QString homeDir = QDir::homePath();
   std::vector<QString> searchDirs;
 #ifdef _WIN32
   searchDirs.push_back(QString("C:") + QDir::separator() + QString("ProgramData") + QDir::separator() +
                        QString("anaconda3"));
 #else
   // Add search locations for possible standard python paths here
   searchDirs.push_back(homeDir + QDir::separator() + "environments");
   searchDirs.push_back(homeDir + QDir::separator() + "anaconda3");
   searchDirs.push_back(homeDir + QDir::separator() + "miniconda3");
   searchDirs.push_back(homeDir + QDir::separator() + "opt" + QDir::separator() + "miniconda3");
   searchDirs.push_back(homeDir + QDir::separator() + "opt" + QDir::separator() + "anaconda3");
 #endif
   for (QString searchDir : searchDirs)
   {
     if (searchDir.endsWith("anaconda3", Qt::CaseInsensitive))
     {
       if (QDir(searchDir).exists())
       {
         m_Controls.pythonEnvComboBox->insertItem(0, "(base): " + searchDir);
         searchDir.append((QDir::separator() + QString("envs")));
       }
     }
     for (QDirIterator subIt(searchDir, QDir::AllDirs, QDirIterator::NoIteratorFlags); subIt.hasNext();)
     {
       subIt.next();
       QString envName = subIt.fileName();
       if (!envName.startsWith('.')) // Filter out irrelevent hidden folders, if any.
       {
         m_Controls.pythonEnvComboBox->insertItem(0, "(" + envName + "): " + subIt.filePath());
       }
     }
   }
   m_Controls.pythonEnvComboBox->setCurrentIndex(-1);
 }
 
 mitk::ModelParams QmitknnUNetToolGUI::MapToRequest(const QString &modelName,
                                                    const QString &taskName,
                                                    const QString &trainer,
                                                    const QString &planId,
                                                    const std::vector<std::string> &folds)
 {
   mitk::ModelParams requestObject;
   requestObject.model = modelName.toStdString();
   requestObject.trainer = trainer.toStdString();
   requestObject.planId = planId.toStdString();
   requestObject.task = taskName.toStdString();
   requestObject.folds = folds;
+  mitk::nnUNetTool::Pointer tool = this->GetConnectedToolAs<mitk::nnUNetTool>();
+  requestObject.inputName = tool->GetRefNode()->GetName();
+  requestObject.timeStamp = std::to_string(mitk::RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint());
   return requestObject;
 }
 
 void QmitknnUNetToolGUI::SegmentationProcessFailed()
 {
   ShowStatusMessage(
     "<b>STATUS: </b><i>Error in the segmentation process. <br>No resulting segmentation can be loaded.</i>");
   this->setCursor(Qt::ArrowCursor);
   std::stringstream stream;
   stream << "Error in the segmentation process. No resulting segmentation can be loaded.";
   ShowErrorMessage(stream.str());
   m_Controls.stopButton->setEnabled(false);
 }
 
 void QmitknnUNetToolGUI::SegmentationResultHandler(mitk::nnUNetTool *tool)
 {
   tool->RenderOutputBuffer();
   this->SetLabelSetPreview(tool->GetMLPreview());
+  //this->ClearOutputBuffer();
   ShowStatusMessage("<b>STATUS: </b><i>Segmentation task finished successfully. <br>Please Confirm the "
                                   "segmentation else, could result in data loss</i>");
   m_Controls.stopButton->setEnabled(false);
 }
 
 void QmitknnUNetToolGUI::ShowEnsembleLayout(bool visible)
 {
   if (m_EnsembleParams.empty())
   {
     ctkCollapsibleGroupBox *groupBoxModel1 = new ctkCollapsibleGroupBox(this);
     auto lay1 = std::make_unique<QmitknnUNetTaskParamsUITemplate>(groupBoxModel1);
     groupBoxModel1->setObjectName(QString::fromUtf8("model_1_Box"));
     groupBoxModel1->setTitle(QString::fromUtf8("Model 1"));
     groupBoxModel1->setMinimumSize(QSize(0, 0));
     groupBoxModel1->setCollapsedHeight(5);
     groupBoxModel1->setCollapsed(false);
     groupBoxModel1->setFlat(true);
     groupBoxModel1->setAlignment(Qt::AlignRight);
     m_Controls.advancedSettingsLayout->addWidget(groupBoxModel1, 3, 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, 3, 2, 1, 2);
 
     connect(lay2->modelBox, SIGNAL(currentTextChanged(const QString &)), this, SLOT(OnModelChanged(const QString &)));
     connect(
       lay2->plannerBox, SIGNAL(currentTextChanged(const QString &)), this, SLOT(OnTrainerChanged(const QString &)));
     m_EnsembleParams.push_back(std::move(lay2));
   }
   for (std::unique_ptr<QmitknnUNetTaskParamsUITemplate> &layout : m_EnsembleParams)
   {
     layout->setVisible(visible);
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.cpp b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.cpp
index 8fdf537329..6e98bbb4ed 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.cpp
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.cpp
@@ -1,824 +1,824 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "QmitkSegmentationView.h"
 #include "mitkPluginActivator.h"
 
 // blueberry
 #include <berryIWorkbenchPage.h>
 
 // mitk
 #include <mitkApplicationCursor.h>
 #include <mitkCameraController.h>
 #include <mitkImageTimeSelector.h>
 #include <mitkLabelSetImage.h>
 #include <mitkNodePredicateSubGeometry.h>
 #include <mitkSegmentationObjectFactory.h>
 #include <mitkSegTool2D.h>
 #include <mitkStatusBar.h>
 #include <mitkToolManagerProvider.h>
 #include <mitkVtkResliceInterpolationProperty.h>
 #include <mitkWorkbenchUtil.h>
 
 // Qmitk
 #include <QmitkNewSegmentationDialog.h>
 #include <QmitkRenderWindow.h>
 #include <QmitkSegmentationOrganNamesHandling.cpp>
 
 // us
 #include <usModuleResource.h>
 #include <usModuleResourceStream.h>
 
 // Qt
 #include <QMessageBox>
 
 #include <regex>
 
 const std::string QmitkSegmentationView::VIEW_ID = "org.mitk.views.segmentation";
 
 QmitkSegmentationView::QmitkSegmentationView()
   : m_Parent(nullptr)
   , m_Controls(nullptr)
   , m_RenderWindowPart(nullptr)
   , m_ToolManager(nullptr)
   , m_ReferenceNode(nullptr)
   , m_WorkingNode(nullptr)
   , m_AutoSelectionEnabled(false)
   , m_MouseCursorSet(false)
 {
   mitk::TNodePredicateDataType<mitk::Image>::Pointer isImage = mitk::TNodePredicateDataType<mitk::Image>::New();
   auto isDwi = mitk::NodePredicateDataType::New("DiffusionImage");
   auto isDti = mitk::NodePredicateDataType::New("TensorImage");
   auto isOdf = mitk::NodePredicateDataType::New("OdfImage");
   auto isSegment = mitk::NodePredicateDataType::New("Segment");
 
   mitk::NodePredicateOr::Pointer validImages = mitk::NodePredicateOr::New();
   validImages->AddPredicate(mitk::NodePredicateAnd::New(isImage, mitk::NodePredicateNot::New(isSegment)));
   validImages->AddPredicate(isDwi);
   validImages->AddPredicate(isDti);
   validImages->AddPredicate(isOdf);
 
   auto isBinary = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
   auto isMask = mitk::NodePredicateAnd::New(isBinary, isImage);
 
   auto validSegmentations = mitk::NodePredicateOr::New();
   validSegmentations->AddPredicate(mitk::TNodePredicateDataType<mitk::LabelSetImage>::New());
   validSegmentations->AddPredicate(isMask);
 
   m_SegmentationPredicate = mitk::NodePredicateAnd::New();
   m_SegmentationPredicate->AddPredicate(validSegmentations);
   m_SegmentationPredicate->AddPredicate(mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object")));
   m_SegmentationPredicate->AddPredicate(mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("hidden object")));
 
   m_ReferencePredicate = mitk::NodePredicateAnd::New();
   m_ReferencePredicate->AddPredicate(validImages);
   m_ReferencePredicate->AddPredicate(mitk::NodePredicateNot::New(m_SegmentationPredicate));
   m_ReferencePredicate->AddPredicate(mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object")));
   m_ReferencePredicate->AddPredicate(mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("hidden object")));
 }
 
 QmitkSegmentationView::~QmitkSegmentationView()
 {
   if (m_Controls)
   {
     // deactivate all tools
     m_ToolManager->ActivateTool(-1);
 
     // removing all observers
     for (NodeTagMapType::iterator dataIter = m_WorkingDataObserverTags.begin(); dataIter != m_WorkingDataObserverTags.end(); ++dataIter)
     {
       (*dataIter).first->GetProperty("visible")->RemoveObserver((*dataIter).second);
     }
     m_WorkingDataObserverTags.clear();
 
     mitk::RenderingManager::GetInstance()->RemoveObserver(m_RenderingManagerObserverTag);
 
     ctkPluginContext* context = mitk::PluginActivator::getContext();
     ctkServiceReference ppmRef = context->getServiceReference<mitk::PlanePositionManagerService>();
     mitk::PlanePositionManagerService* service = context->getService<mitk::PlanePositionManagerService>(ppmRef);
     service->RemoveAllPlanePositions();
     context->ungetService(ppmRef);
 
     m_ToolManager->SetReferenceData(nullptr);
     m_ToolManager->SetWorkingData(nullptr);
   }
 
   delete m_Controls;
 }
 
 /**********************************************************************/
 /* private Q_SLOTS                                                    */
 /**********************************************************************/
 void QmitkSegmentationView::OnReferenceSelectionChanged(QList<mitk::DataNode::Pointer> nodes)
 {
   m_ToolManager->ActivateTool(-1);
 
   if (nodes.empty())
   {
     m_Controls->segImageSelector->SetNodePredicate(m_SegmentationPredicate);
     m_ReferenceNode = nullptr;
     m_ToolManager->SetReferenceData(m_ReferenceNode);
     this->UpdateGUI();
     return;
   }
 
   m_ReferenceNode = nodes.first();
   m_ToolManager->SetReferenceData(m_ReferenceNode);
   if (m_ReferenceNode.IsNotNull())
   {
     // set a predicate such that a segmentation fits the selected reference image geometry
     auto segPredicate = mitk::NodePredicateAnd::New(m_SegmentationPredicate.GetPointer(),
       mitk::NodePredicateSubGeometry::New(m_ReferenceNode->GetData()->GetGeometry()));
 
     m_Controls->segImageSelector->SetNodePredicate(segPredicate);
 
     if (m_AutoSelectionEnabled)
     {
       // hide all image nodes to later show only the automatically selected ones
       mitk::DataStorage::SetOfObjects::ConstPointer imageNodes =
         this->GetDataStorage()->GetSubset(m_ReferencePredicate);
       for (mitk::DataStorage::SetOfObjects::const_iterator iter = imageNodes->begin(); iter != imageNodes->end(); ++iter)
       {
         (*iter)->SetVisibility(false);
       }
     }
     m_ReferenceNode->SetVisibility(true);
   }
 
   this->UpdateGUI();
 }
 
 void QmitkSegmentationView::OnSegmentationSelectionChanged(QList<mitk::DataNode::Pointer> nodes)
 {
   m_ToolManager->ActivateTool(-1);
 
   if (nodes.empty())
   {
     m_WorkingNode = nullptr;
     m_ToolManager->SetWorkingData(m_WorkingNode);
     this->UpdateGUI();
     return;
   }
 
   if (m_ReferenceNode.IsNull())
   {
     this->UpdateGUI();
     return;
   }
 
   mitk::Image::ConstPointer referenceImage = dynamic_cast<mitk::Image *>(m_ReferenceNode->GetData());
   if (referenceImage.IsNull())
   {
     this->UpdateGUI();
     return;
   }
 
   m_WorkingNode = nodes.first();
   m_ToolManager->SetWorkingData(m_WorkingNode);
   if (m_WorkingNode.IsNotNull())
   {
     if (m_AutoSelectionEnabled)
     {
       // hide all segmentation nodes to later show only the automatically selected ones
       mitk::DataStorage::SetOfObjects::ConstPointer segmentationNodes =
         this->GetDataStorage()->GetSubset(m_SegmentationPredicate);
       for (mitk::DataStorage::SetOfObjects::const_iterator iter = segmentationNodes->begin(); iter != segmentationNodes->end(); ++iter)
       {
         (*iter)->SetVisibility(false);
       }
     }
     m_WorkingNode->SetVisibility(true);
     this->InitializeRenderWindows(referenceImage->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, false);
   }
 
   this->UpdateGUI();
 }
 
 void QmitkSegmentationView::CreateNewSegmentation()
 {
   mitk::DataNode::Pointer referenceNode = m_ToolManager->GetReferenceData(0);
   if (referenceNode.IsNull())
   {
     MITK_ERROR << "'Create new segmentation' button should never be clickable unless a reference image is selected.";
     return;
   }
 
   mitk::Image::ConstPointer referenceImage = dynamic_cast<mitk::Image *>(referenceNode->GetData());
   if (referenceImage.IsNull())
   {
     QMessageBox::information(
       m_Parent, "New segmentation", "Please load and select an image before starting some action.");
     return;
   }
 
   if (referenceImage->GetDimension() <= 1)
   {
     QMessageBox::information(m_Parent, "New segmentation", "Segmentation is currently not supported for 2D images");
     return;
   }
 
   m_ToolManager->ActivateTool(-1);
 
   const auto currentTimePoint = mitk::RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint();
   unsigned int imageTimeStep = 0;
   if (referenceImage->GetTimeGeometry()->IsValidTimePoint(currentTimePoint))
   {
     imageTimeStep = referenceImage->GetTimeGeometry()->TimePointToTimeStep(currentTimePoint);
   }
 
   auto segTemplateImage = referenceImage;
   if (referenceImage->GetDimension() > 3)
   {
     auto result = QMessageBox::question(m_Parent,
       tr("Create a static or dynamic segmentation?"),
       tr("The selected image has multiple time steps.\n\nDo you want to create a static "
         "segmentation that is identical for all time steps or do you want to create a "
         "dynamic segmentation to segment individual time steps?"),
       tr("Create static segmentation"), tr("Create dynamic segmentation"),
       QString(), 0, 0);
     if (result == 0)
     {
       auto selector = mitk::ImageTimeSelector::New();
       selector->SetInput(referenceImage);
       selector->SetTimeNr(0);
       selector->Update();
 
       const auto refTimeGeometry = referenceImage->GetTimeGeometry();
       auto newTimeGeometry = mitk::ProportionalTimeGeometry::New();
       newTimeGeometry->SetFirstTimePoint(refTimeGeometry->GetMinimumTimePoint());
       newTimeGeometry->SetStepDuration(refTimeGeometry->GetMaximumTimePoint() - refTimeGeometry->GetMinimumTimePoint());
 
       mitk::Image::Pointer newImage = selector->GetOutput();
       newTimeGeometry->SetTimeStepGeometry(referenceImage->GetGeometry(imageTimeStep), 0);
       newImage->SetTimeGeometry(newTimeGeometry);
       segTemplateImage = newImage;
     }
   }
 
   QString newName = QString::fromStdString(referenceNode->GetName());
   newName.append("-labels");
 
   // ask about the name and organ type of the new segmentation
   auto dialog = new QmitkNewSegmentationDialog(m_Parent);
   QStringList organColors = mitk::OrganNamesHandling::GetDefaultOrganColorString();
   dialog->SetSuggestionList(organColors);
   dialog->SetSegmentationName(newName);
 
   int dialogReturnValue = dialog->exec();
   if (dialogReturnValue == QDialog::Rejected)
   {
     return;
   }
 
   std::string newNodeName = dialog->GetSegmentationName().toStdString();
   if (newNodeName.empty())
   {
     newNodeName = "Unnamed";
   }
 
   // create a new image of the same dimensions and smallest possible pixel type
   auto firstTool = m_ToolManager->GetToolById(0);
   if (nullptr == firstTool)
   {
     return;
   }
 
   mitk::DataNode::Pointer emptySegmentation = nullptr;
   try
   {
     emptySegmentation = firstTool->CreateEmptySegmentationNode(segTemplateImage, newNodeName, dialog->GetColor());
   }
   catch (const std::bad_alloc &)
   {
     QMessageBox::warning(m_Parent, tr("New segmentation"), tr("Could not allocate memory for new segmentation"));
   }
 
   if (nullptr == emptySegmentation)
   {
     return; // could have been aborted by user
   }
 
   // initialize "showVolume"-property to false to prevent recalculating the volume while working on the segmentation
   emptySegmentation->SetProperty("showVolume", mitk::BoolProperty::New(false));
 
   mitk::OrganNamesHandling::UpdateOrganList(organColors, dialog->GetSegmentationName(), dialog->GetColor());
 
   // escape ';' here (replace by '\;')
   QString stringForStorage = organColors.replaceInStrings(";", "\\;").join(";");
   MITK_DEBUG << "Will store: " << stringForStorage;
   this->GetPreferences()->Put("Organ-Color-List", stringForStorage);
   this->GetPreferences()->Flush();
 
   this->GetDataStorage()->Add(emptySegmentation, referenceNode);
 
   if (m_ToolManager->GetWorkingData(0))
   {
     m_ToolManager->GetWorkingData(0)->SetSelected(false);
   }
   emptySegmentation->SetSelected(true);
   m_Controls->segImageSelector->SetCurrentSelectedNode(emptySegmentation);
 
   this->InitializeRenderWindows(referenceImage->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, false);
 }
 
 void QmitkSegmentationView::OnManualTool2DSelected(int id)
 {
   this->ResetMouseCursor();
   mitk::StatusBar::GetInstance()->DisplayText("");
 
   if (id >= 0)
   {
     std::string text = "Active Tool: \"";
     text += m_ToolManager->GetToolById(id)->GetName();
     text += "\"";
     mitk::StatusBar::GetInstance()->DisplayText(text.c_str());
 
     us::ModuleResource resource = m_ToolManager->GetToolById(id)->GetCursorIconResource();
     this->SetMouseCursor(resource, 0, 0);
   }
 }
 
 void QmitkSegmentationView::OnShowMarkerNodes(bool state)
 {
   mitk::SegTool2D::Pointer manualSegmentationTool;
 
   unsigned int numberOfExistingTools = m_ToolManager->GetTools().size();
 
   for (unsigned int i = 0; i < numberOfExistingTools; i++)
   {
     manualSegmentationTool = dynamic_cast<mitk::SegTool2D*>(m_ToolManager->GetToolById(i));
 
     if (manualSegmentationTool)
     {
       if (state == true)
       {
         manualSegmentationTool->SetShowMarkerNodes(true);
       }
       else
       {
         manualSegmentationTool->SetShowMarkerNodes(false);
       }
     }
   }
 }
 
 /**********************************************************************/
 /* private                                                            */
 /**********************************************************************/
 void QmitkSegmentationView::CreateQtPartControl(QWidget* parent)
 {
    m_Parent = parent;
 
    m_Controls = new Ui::QmitkSegmentationControls;
    m_Controls->setupUi(parent);
 
    m_Controls->patImageSelector->SetDataStorage(GetDataStorage());
    m_Controls->patImageSelector->SetNodePredicate(m_ReferencePredicate);
    m_Controls->patImageSelector->SetInvalidInfo("Select an image");
    m_Controls->patImageSelector->SetPopUpTitel("Select an image");
    m_Controls->patImageSelector->SetPopUpHint("Select an image that should be used to define the geometry and bounds of the segmentation.");
 
    m_Controls->segImageSelector->SetDataStorage(GetDataStorage());
    m_Controls->segImageSelector->SetNodePredicate(m_SegmentationPredicate);
    m_Controls->segImageSelector->SetInvalidInfo("Select a segmentation");
    m_Controls->segImageSelector->SetPopUpTitel("Select a segmentation");
    m_Controls->segImageSelector->SetPopUpHint("Select a segmentation that should be modified. Only segmentation with the same geometry and within the bounds of the reference image are selected.");
 
    connect(m_Controls->patImageSelector, &QmitkAbstractNodeSelectionWidget::CurrentSelectionChanged,
            this, &QmitkSegmentationView::OnReferenceSelectionChanged);
    connect(m_Controls->segImageSelector, &QmitkAbstractNodeSelectionWidget::CurrentSelectionChanged,
            this, &QmitkSegmentationView::OnSegmentationSelectionChanged);
 
    m_ToolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager();
    m_ToolManager->SetDataStorage(*(this->GetDataStorage()));
    m_ToolManager->InitializeTools();
 
    QString segTools2D = tr("Add Subtract Fill Erase Paint Wipe 'Region Growing' 'Live Wire' '2D Fast Marching'");
    QString segTools3D = tr("Threshold 'UL Threshold' Otsu 'Fast Marching 3D' 'Region Growing 3D' Watershed Picking");
-#ifdef __linux__
+//#ifdef __linux__
    segTools3D.append(" nnUNet"); // plugin not enabled for MacOS / Windows
-#endif
+//#endif
    std::regex extSegTool2DRegEx("SegTool2D$");
    std::regex extSegTool3DRegEx("SegTool3D$");
 
    auto tools = m_ToolManager->GetTools();
    for (const auto &tool : tools)
    {
      if (std::regex_search(tool->GetNameOfClass(), extSegTool2DRegEx))
      {
        segTools2D.append(QString(" '%1'").arg(tool->GetName()));
      }
      else if (std::regex_search(tool->GetNameOfClass(), extSegTool3DRegEx))
      {
        segTools3D.append(QString(" '%1'").arg(tool->GetName()));
      }
    }
 
    // all part of open source MITK
    m_Controls->m_ManualToolSelectionBox2D->SetToolManager(*m_ToolManager);
    m_Controls->m_ManualToolSelectionBox2D->SetGenerateAccelerators(true);
    m_Controls->m_ManualToolSelectionBox2D->SetToolGUIArea(m_Controls->m_ManualToolGUIContainer2D);
    m_Controls->m_ManualToolSelectionBox2D->SetDisplayedToolGroups(segTools2D.toStdString());
    m_Controls->m_ManualToolSelectionBox2D->SetLayoutColumns(3);
    m_Controls->m_ManualToolSelectionBox2D->SetEnabledMode(
      QmitkToolSelectionBox::EnabledWithReferenceAndWorkingDataVisible);
    connect(m_Controls->m_ManualToolSelectionBox2D, &QmitkToolSelectionBox::ToolSelected,
            this, &QmitkSegmentationView::OnManualTool2DSelected);
 
    //setup 3D Tools
    m_Controls->m_ManualToolSelectionBox3D->SetToolManager(*m_ToolManager);
    m_Controls->m_ManualToolSelectionBox3D->SetGenerateAccelerators(true);
    m_Controls->m_ManualToolSelectionBox3D->SetToolGUIArea(m_Controls->m_ManualToolGUIContainer3D);
    m_Controls->m_ManualToolSelectionBox3D->SetDisplayedToolGroups(segTools3D.toStdString());
    m_Controls->m_ManualToolSelectionBox3D->SetLayoutColumns(3);
    m_Controls->m_ManualToolSelectionBox3D->SetEnabledMode(
      QmitkToolSelectionBox::EnabledWithReferenceAndWorkingDataVisible);
 
    // create signal/slot connections
    connect(m_Controls->btnNewSegmentation, &QToolButton::clicked, this, &QmitkSegmentationView::CreateNewSegmentation);
    connect(m_Controls->m_SlicesInterpolator, &QmitkSlicesInterpolator::SignalShowMarkerNodes, this, &QmitkSegmentationView::OnShowMarkerNodes);
 
    // set callback function for already existing segmentation nodes
    mitk::DataStorage::SetOfObjects::ConstPointer allSegmentations = GetDataStorage()->GetSubset(m_SegmentationPredicate);
    for (mitk::DataStorage::SetOfObjects::const_iterator iter = allSegmentations->begin(); iter != allSegmentations->end(); ++iter)
    {
      mitk::DataNode* node = *iter;
      auto command = itk::SimpleMemberCommand<QmitkSegmentationView>::New();
      command->SetCallbackFunction(this, &QmitkSegmentationView::ValidateSelectionInput);
      m_WorkingDataObserverTags.insert(std::pair<mitk::DataNode *, unsigned long>(
        node, node->GetProperty("visible")->AddObserver(itk::ModifiedEvent(), command)));
    }
 
    auto command = itk::SimpleMemberCommand<QmitkSegmentationView>::New();
    command->SetCallbackFunction(this, &QmitkSegmentationView::ValidateSelectionInput);
    m_RenderingManagerObserverTag =
      mitk::RenderingManager::GetInstance()->AddObserver(mitk::RenderingManagerViewsInitializedEvent(), command);
 
    m_RenderWindowPart = this->GetRenderWindowPart();
    if (nullptr != m_RenderWindowPart)
    {
      this->RenderWindowPartActivated(m_RenderWindowPart);
    }
 
    // Make sure the GUI notices if appropriate data is already present on creation.
    // Should be done last, if everything else is configured because it triggers the autoselection of data.
    m_Controls->patImageSelector->SetAutoSelectNewNodes(true);
    m_Controls->segImageSelector->SetAutoSelectNewNodes(true);
 
    this->UpdateGUI();
 }
 
 void QmitkSegmentationView::RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart)
 {
   if (m_RenderWindowPart != renderWindowPart)
   {
     m_RenderWindowPart = renderWindowPart;
   }
 
   if (m_Parent)
   {
     m_Parent->setEnabled(true);
   }
 
   // tell the interpolation about tool manager, data storage and render window part
   if (m_Controls)
   {
     m_Controls->m_SlicesInterpolator->SetDataStorage(this->GetDataStorage());
     QList<mitk::SliceNavigationController*> controllers;
     controllers.push_back(renderWindowPart->GetQmitkRenderWindow("axial")->GetSliceNavigationController());
     controllers.push_back(renderWindowPart->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController());
     controllers.push_back(renderWindowPart->GetQmitkRenderWindow("coronal")->GetSliceNavigationController());
     m_Controls->m_SlicesInterpolator->Initialize(m_ToolManager, controllers);
   }
 }
 
 void QmitkSegmentationView::RenderWindowPartDeactivated(mitk::IRenderWindowPart* /*renderWindowPart*/)
 {
   m_RenderWindowPart = nullptr;
   if (m_Parent)
   {
     m_Parent->setEnabled(false);
   }
 }
 
 void QmitkSegmentationView::OnPreferencesChanged(const berry::IBerryPreferences* prefs)
 {
   if (m_Controls != nullptr)
   {
     bool slimView = prefs->GetBool("slim view", false);
     m_Controls->m_ManualToolSelectionBox2D->SetShowNames(!slimView);
     m_Controls->m_ManualToolSelectionBox3D->SetShowNames(!slimView);
   }
 
   m_AutoSelectionEnabled = prefs->GetBool("auto selection", false);
 
   this->ApplyDisplayOptions();
 }
 
 void QmitkSegmentationView::NodeAdded(const mitk::DataNode* node)
 {
   if (!m_SegmentationPredicate->CheckNode(node))
   {
     return;
   }
 
   auto command = itk::SimpleMemberCommand<QmitkSegmentationView>::New();
   command->SetCallbackFunction(this, &QmitkSegmentationView::ValidateSelectionInput);
   m_WorkingDataObserverTags.insert(std::pair<mitk::DataNode *, unsigned long>(
     const_cast<mitk::DataNode *>(node), node->GetProperty("visible")->AddObserver(itk::ModifiedEvent(), command)));
 
   this->ApplyDisplayOptions(const_cast<mitk::DataNode*>(node));
 }
 
 void QmitkSegmentationView::NodeRemoved(const mitk::DataNode* node)
 {
   if (m_SegmentationPredicate->CheckNode(node))
   {
     // remove all possible contour markers of the segmentation
     mitk::DataStorage::SetOfObjects::ConstPointer allContourMarkers = this->GetDataStorage()->GetDerivations(
       node, mitk::NodePredicateProperty::New("isContourMarker", mitk::BoolProperty::New(true)));
 
     ctkPluginContext* context = mitk::PluginActivator::getContext();
     ctkServiceReference ppmRef = context->getServiceReference<mitk::PlanePositionManagerService>();
     mitk::PlanePositionManagerService* service = context->getService<mitk::PlanePositionManagerService>(ppmRef);
 
     for (mitk::DataStorage::SetOfObjects::ConstIterator it = allContourMarkers->Begin(); it != allContourMarkers->End(); ++it)
     {
       std::string nodeName = node->GetName();
       unsigned int t = nodeName.find_last_of(" ");
       unsigned int id = atof(nodeName.substr(t + 1).c_str()) - 1;
 
       service->RemovePlanePosition(id);
 
       this->GetDataStorage()->Remove(it->Value());
     }
 
     context->ungetService(ppmRef);
     service = nullptr;
 
     mitk::Image* image = dynamic_cast<mitk::Image*>(node->GetData());
     mitk::SurfaceInterpolationController::GetInstance()->RemoveInterpolationSession(image);
   }
 
   mitk::DataNode* tempNode = const_cast<mitk::DataNode*>(node);
   //Remove observer if one was registered
   auto finding = m_WorkingDataObserverTags.find(tempNode);
   if (finding != m_WorkingDataObserverTags.end())
   {
     node->GetProperty("visible")->RemoveObserver(m_WorkingDataObserverTags[tempNode]);
     m_WorkingDataObserverTags.erase(tempNode);
   }
 }
 
 void QmitkSegmentationView::ApplyDisplayOptions()
 {
   if (!m_Parent)
   {
     return;
   }
 
   if (!m_Controls)
   {
     return; // might happen on initialization (preferences loaded)
   }
 
   mitk::DataNode::Pointer workingData = m_ToolManager->GetWorkingData(0);
   mitk::DataStorage::SetOfObjects::ConstPointer allImages = this->GetDataStorage()->GetSubset(m_SegmentationPredicate);
   for (mitk::DataStorage::SetOfObjects::const_iterator iter = allImages->begin(); iter != allImages->end(); ++iter)
   {
     this->ApplyDisplayOptions(*iter);
   }
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkSegmentationView::ApplyDisplayOptions(mitk::DataNode* node)
 {
   if (nullptr == node)
   {
     return;
   }
 
   auto drawOutline = mitk::BoolProperty::New(GetPreferences()->GetBool("draw outline", true));
   auto labelSetImage = dynamic_cast<mitk::LabelSetImage*>(node->GetData());
   if (nullptr != labelSetImage)
   {
     // node is actually a multi label segmentation,
     // but its outline property can be set in the 'single label' segmentation preference page as well
     node->SetProperty("labelset.contour.active", drawOutline);
     // force render window update to show outline
     node->GetData()->Modified();
   }
   else
   {
     // node is a 'single label' segmentation
     bool isBinary = false;
     node->GetBoolProperty("binary", isBinary);
     if (isBinary)
     {
       node->SetProperty("outline binary", drawOutline);
       node->SetProperty("outline width", mitk::FloatProperty::New(2.0));
       // force render window update to show outline
       node->GetData()->Modified();
     }
   }
 }
 
 void QmitkSegmentationView::OnContourMarkerSelected(const mitk::DataNode* node)
 {
   QmitkRenderWindow* selectedRenderWindow = nullptr;
   auto* renderWindowPart = this->GetRenderWindowPart(mitk::WorkbenchUtil::OPEN);
   auto* axialRenderWindow = renderWindowPart->GetQmitkRenderWindow("axial");
   auto* sagittalRenderWindow = renderWindowPart->GetQmitkRenderWindow("sagittal");
   auto* coronalRenderWindow = renderWindowPart->GetQmitkRenderWindow("coronal");
   auto* _3DRenderWindow = renderWindowPart->GetQmitkRenderWindow("3d");
   bool PlanarFigureInitializedWindow = false;
 
   // find initialized renderwindow
   if (node->GetBoolProperty("PlanarFigureInitializedWindow",
     PlanarFigureInitializedWindow, axialRenderWindow->GetRenderer()))
   {
     selectedRenderWindow = axialRenderWindow;
   }
   if (!selectedRenderWindow && node->GetBoolProperty(
     "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
     sagittalRenderWindow->GetRenderer()))
   {
     selectedRenderWindow = sagittalRenderWindow;
   }
   if (!selectedRenderWindow && node->GetBoolProperty(
     "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
     coronalRenderWindow->GetRenderer()))
   {
     selectedRenderWindow = coronalRenderWindow;
   }
   if (!selectedRenderWindow && node->GetBoolProperty(
     "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
     _3DRenderWindow->GetRenderer()))
   {
     selectedRenderWindow = _3DRenderWindow;
   }
 
   // make node visible
   if (selectedRenderWindow)
   {
     std::string nodeName = node->GetName();
     unsigned int t = nodeName.find_last_of(" ");
     unsigned int id = atof(nodeName.substr(t + 1).c_str()) - 1;
 
     {
       ctkPluginContext* context = mitk::PluginActivator::getContext();
       ctkServiceReference ppmRef = context->getServiceReference<mitk::PlanePositionManagerService>();
       mitk::PlanePositionManagerService* service = context->getService<mitk::PlanePositionManagerService>(ppmRef);
       selectedRenderWindow->GetSliceNavigationController()->ExecuteOperation(service->GetPlanePosition(id));
       context->ungetService(ppmRef);
     }
 
     selectedRenderWindow->GetRenderer()->GetCameraController()->Fit();
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 void QmitkSegmentationView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/, const QList<mitk::DataNode::Pointer>& nodes)
 {
   if (nodes.size() != 0)
   {
     std::string markerName = "Position";
     unsigned int numberOfNodes = nodes.size();
     std::string nodeName = nodes.at(0)->GetName();
     if ((numberOfNodes == 1) && (nodeName.find(markerName) == 0))
     {
       this->OnContourMarkerSelected(nodes.at(0));
       return;
     }
   }
 }
 
 void QmitkSegmentationView::ResetMouseCursor()
 {
   if (m_MouseCursorSet)
   {
     mitk::ApplicationCursor::GetInstance()->PopCursor();
     m_MouseCursorSet = false;
   }
 }
 
 void QmitkSegmentationView::SetMouseCursor(const us::ModuleResource& resource, int hotspotX, int hotspotY)
 {
   // Remove previously set mouse cursor
   if (m_MouseCursorSet)
     this->ResetMouseCursor();
 
   if (resource)
   {
     us::ModuleResourceStream cursor(resource, std::ios::binary);
     mitk::ApplicationCursor::GetInstance()->PushCursor(cursor, hotspotX, hotspotY);
     m_MouseCursorSet = true;
   }
 }
 
 void QmitkSegmentationView::UpdateGUI()
 {
   mitk::DataNode* referenceNode = m_ToolManager->GetReferenceData(0);
   bool hasReferenceNode = referenceNode != nullptr;
 
   mitk::DataNode* workingNode = m_ToolManager->GetWorkingData(0);
   bool hasWorkingNode = workingNode != nullptr;
 
   m_Controls->btnNewSegmentation->setEnabled(false);
   m_Controls->m_SlicesInterpolator->setEnabled(false);
 
   if (hasReferenceNode)
   {
     m_Controls->btnNewSegmentation->setEnabled(true);
   }
 
   if (hasWorkingNode && hasReferenceNode)
   {
     m_Controls->m_SlicesInterpolator->setEnabled(true);
 
     int layer = -1;
     referenceNode->GetIntProperty("layer", layer);
     workingNode->SetIntProperty("layer", layer + 1);
   }
 
   this->ValidateSelectionInput();
 }
 
 void QmitkSegmentationView::ValidateSelectionInput()
 {
   this->UpdateWarningLabel("");
 
   // the argument is actually not used
   // enable status depends on the tool manager selection
   m_Controls->m_ManualToolSelectionBox2D->setEnabled(false);
   m_Controls->m_ManualToolSelectionBox3D->setEnabled(false);
 
   mitk::DataNode* referenceNode = m_Controls->patImageSelector->GetSelectedNode();
   mitk::DataNode* workingNode = m_Controls->segImageSelector->GetSelectedNode();
 
   if (nullptr == referenceNode)
   {
     return;
   }
 
   if (nullptr == workingNode)
   {
     return;
   }
 
   mitk::IRenderWindowPart* renderWindowPart = this->GetRenderWindowPart();
   auto workingNodeIsVisible = renderWindowPart &&
     workingNode->IsVisible(renderWindowPart->GetQmitkRenderWindow("axial")->GetRenderer());
   if (!workingNodeIsVisible)
   {
     this->UpdateWarningLabel(tr("The selected segmentation is currently not visible!"));
     return;
   }
 
   /*
   * Here we check whether the geometry of the selected segmentation image is aligned with the worldgeometry.
   * At the moment it is not supported to use a geometry different from the selected image for reslicing.
   * For further information see Bug 16063
   */
   const mitk::BaseGeometry *workingNodeGeo = workingNode->GetData()->GetGeometry();
   const mitk::BaseGeometry *worldGeo =
     renderWindowPart->GetQmitkRenderWindow("3d")->GetSliceNavigationController()->GetCurrentGeometry3D();
   if (nullptr != workingNodeGeo && nullptr != worldGeo)
   {
     if (mitk::Equal(*workingNodeGeo->GetBoundingBox(), *worldGeo->GetBoundingBox(), mitk::eps, true))
     {
       m_ToolManager->SetReferenceData(referenceNode);
       m_ToolManager->SetWorkingData(workingNode);
       m_Controls->m_ManualToolSelectionBox2D->setEnabled(true);
       m_Controls->m_ManualToolSelectionBox3D->setEnabled(true);
       return;
     }
   }
 
   m_ToolManager->SetReferenceData(referenceNode);
   m_ToolManager->SetWorkingData(nullptr);
   this->UpdateWarningLabel(tr("Please perform a reinit on the segmentation image!"));
 }
 
 void QmitkSegmentationView::UpdateWarningLabel(QString text)
 {
   if (text.size() == 0)
   {
     m_Controls->lblSegmentationWarnings->hide();
   }
   else
   {
     m_Controls->lblSegmentationWarnings->show();
   }
   m_Controls->lblSegmentationWarnings->setText("<font color=\"red\">" + text + "</font>");
 }