diff --git a/Modules/Segmentation/Interactions/mitkOtsuTool3D.cpp b/Modules/Segmentation/Interactions/mitkOtsuTool3D.cpp
index 49e9271c64..a7ce47fcec 100644
--- a/Modules/Segmentation/Interactions/mitkOtsuTool3D.cpp
+++ b/Modules/Segmentation/Interactions/mitkOtsuTool3D.cpp
@@ -1,87 +1,87 @@
 /*============================================================================
 
 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.
 
 ============================================================================*/
 
 // MITK
 #include "mitkOtsuTool3D.h"
 #include "mitkOtsuSegmentationFilter.h"
 
 // us
 #include <usGetModuleContext.h>
 #include <usModule.h>
 #include <usModuleContext.h>
 #include <usModuleResource.h>
 
 #include <mitkImageStatisticsHolder.h>
 
 namespace mitk
 {
   MITK_TOOL_MACRO(MITKSEGMENTATION_EXPORT, OtsuTool3D, "Otsu Segmentation");
 }
 
 void mitk::OtsuTool3D::Activated()
 {
   Superclass::Activated();
 
   m_NumberOfBins = 128;
   m_NumberOfRegions = 2;
   m_UseValley = false;
   this->SetLabelTransferMode(LabelTransferMode::AllLabels);
 }
 
 const char **mitk::OtsuTool3D::GetXPM() const
 {
   return nullptr;
 }
 
 us::ModuleResource mitk::OtsuTool3D::GetIconResource() const
 {
   us::Module *module = us::GetModuleContext()->GetModule();
   us::ModuleResource resource = module->GetResource("Otsu_48x48.png");
   return resource;
 }
 
 const char* mitk::OtsuTool3D::GetName() const
 {
   return "Otsu";
 }
 
-void mitk::OtsuTool3D::DoUpdatePreview(const Image* inputAtTimeStep, const Image* oldSegAtTimeStep, LabelSetImage* previewImage, TimeStepType timeStep)
+void mitk::OtsuTool3D::DoUpdatePreview(const Image* inputAtTimeStep, const Image* /*oldSegAtTimeStep*/, LabelSetImage* previewImage, TimeStepType timeStep)
 {
   int numberOfThresholds = m_NumberOfRegions - 1;
 
   mitk::OtsuSegmentationFilter::Pointer otsuFilter = mitk::OtsuSegmentationFilter::New();
   otsuFilter->SetNumberOfThresholds(numberOfThresholds);
   otsuFilter->SetValleyEmphasis(m_UseValley);
   otsuFilter->SetNumberOfBins(m_NumberOfBins);
   otsuFilter->SetInput(inputAtTimeStep);
   otsuFilter->AddObserver(itk::ProgressEvent(), m_ProgressCommand);
 
   try
   {
     otsuFilter->Update();
   }
   catch (...)
   {
     mitkThrow() << "itkOtsuFilter error (image dimension must be in {2, 3} and image must not be RGB)";
   }
 
   auto otsuResultImage = mitk::LabelSetImage::New();
   otsuResultImage->InitializeByLabeledImage(otsuFilter->GetOutput());
   TransferLabelSetImageContent(otsuResultImage, previewImage, timeStep);
 }
 
 unsigned int mitk::OtsuTool3D::GetMaxNumberOfBins() const
 {
   const auto min = this->GetReferenceData()->GetStatistics()->GetScalarValueMin();
   const auto max = this->GetReferenceData()->GetStatistics()->GetScalarValueMaxNoRecompute();
   return static_cast<unsigned int>(max - min) + 1;
 }
diff --git a/Modules/Segmentation/Interactions/mitknnUnetTool.cpp b/Modules/Segmentation/Interactions/mitknnUnetTool.cpp
index 6ef6038caa..26047b120e 100644
--- a/Modules/Segmentation/Interactions/mitknnUnetTool.cpp
+++ b/Modules/Segmentation/Interactions/mitknnUnetTool.cpp
@@ -1,326 +1,326 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitknnUnetTool.h"
 
 #include "mitkIOUtil.h"
 #include "mitkProcessExecutor.h"
 #include <itksys/SystemTools.hxx>
 #include <usGetModuleContext.h>
 #include <usModule.h>
 #include <usModuleContext.h>
 #include <usModuleResource.h>
 
 namespace mitk
 {
   MITK_TOOL_MACRO(MITKSEGMENTATION_EXPORT, nnUNetTool, "nnUNet tool");
 }
 
 mitk::nnUNetTool::nnUNetTool()
 {
   this->SetMitkTempDir(IOUtil::CreateTemporaryDirectory("mitk-XXXXXX"));
 }
 
 mitk::nnUNetTool::~nnUNetTool()
 {
   itksys::SystemTools::RemoveADirectory(this->GetMitkTempDir());
 }
 
 void mitk::nnUNetTool::Activated()
 {
   Superclass::Activated();
   this->SetLabelTransferMode(LabelTransferMode::AllLabels);
 }
 
 void mitk::nnUNetTool::RenderOutputBuffer()
 {
   //if (m_OutputBuffer != nullptr)
   //{
   //  Superclass::SetNodeProperties(m_OutputBuffer);
   //  try
   //  {
   //    if (nullptr != this->GetPreviewSegmentationNode())
   //    {
   //      this->GetPreviewSegmentationNode()->SetVisibility(!this->GetSelectedLabels().empty());
   //    }
   //    if (this->GetSelectedLabels().empty())
   //    {
   //      this->ResetPreviewNode();
   //    }
   //  }
   //  catch (const mitk::Exception &e)
   //  {
   //    MITK_INFO << e.GetDescription();
   //  }
   //}
 }
 
 void mitk::nnUNetTool::SetOutputBuffer(LabelSetImage::Pointer segmentation)
 {
   m_OutputBuffer = segmentation;
 }
 
 mitk::LabelSetImage::Pointer mitk::nnUNetTool::GetOutputBuffer()
 {
   return m_OutputBuffer;
 }
 
 void mitk::nnUNetTool::ClearOutputBuffer()
 {
   m_OutputBuffer = nullptr;
 }
 
 us::ModuleResource mitk::nnUNetTool::GetIconResource() const
 {
   us::Module *module = us::GetModuleContext()->GetModule();
   us::ModuleResource resource = module->GetResource("AI_48x48.png");
   return resource;
 }
 
 const char **mitk::nnUNetTool::GetXPM() const
 {
   return nullptr;
 }
 
 const char *mitk::nnUNetTool::GetName() const
 {
   return "nnUNet";
 }
 
 mitk::DataStorage *mitk::nnUNetTool::GetDataStorage()
 {
   return this->GetToolManager()->GetDataStorage();
 }
 
 mitk::DataNode *mitk::nnUNetTool::GetRefNode()
 {
   return this->GetToolManager()->GetReferenceData(0);
 }
 
 namespace
 {
   void onPythonProcessEvent(itk::Object * /*pCaller*/, const itk::EventObject &e, void *)
   {
     std::string testCOUT;
     std::string testCERR;
     const auto *pEvent = dynamic_cast<const mitk::ExternalProcessStdOutEvent *>(&e);
 
     if (pEvent)
     {
       testCOUT = testCOUT + pEvent->GetOutput();
       MITK_INFO << testCOUT;
     }
 
     const auto *pErrEvent = dynamic_cast<const mitk::ExternalProcessStdErrEvent *>(&e);
 
     if (pErrEvent)
     {
       testCERR = testCERR + pErrEvent->GetOutput();
       MITK_ERROR << testCERR;
     }
   }
 } // namespace
 
-void mitk::nnUNetTool::DoUpdatePreview(const Image* inputAtTimeStep, const Image* oldSegAtTimeStep, LabelSetImage* previewImage, TimeStepType timeStep)
+void mitk::nnUNetTool::DoUpdatePreview(const Image* inputAtTimeStep, const Image* /*oldSegAtTimeStep*/, LabelSetImage* previewImage, TimeStepType /*timeStep*/)
 {
   if (m_InputBuffer == inputAtTimeStep)
   {
     return;
   }
 
   std::string inDir, outDir, inputImagePath, outputImagePath, scriptPath;
 
   ProcessExecutor::Pointer spExec = ProcessExecutor::New();
   itk::CStyleCommand::Pointer spCommand = itk::CStyleCommand::New();
   spCommand->SetCallback(&onPythonProcessEvent);
   spExec->AddObserver(ExternalProcessOutputEvent(), spCommand);
   ProcessExecutor::ArgumentListType args;
 
   inDir = IOUtil::CreateTemporaryDirectory("nnunet-in-XXXXXX", this->GetMitkTempDir());
   std::ofstream tmpStream;
   inputImagePath = IOUtil::CreateTemporaryFile(tmpStream, m_TEMPLATE_FILENAME, inDir + IOUtil::GetDirectorySeparator());
   tmpStream.close();
   std::size_t found = inputImagePath.find_last_of(IOUtil::GetDirectorySeparator());
   std::string fileName = inputImagePath.substr(found + 1);
   std::string token = fileName.substr(0, fileName.find("_"));
 
   if (this->GetNoPip())
   {
     scriptPath = this->GetnnUNetDirectory() + IOUtil::GetDirectorySeparator() + "nnunet" +
                  IOUtil::GetDirectorySeparator() + "inference" + IOUtil::GetDirectorySeparator() + "predict_simple.py";
   }
 
   try
   {
     if (this->GetMultiModal())
     {
       const std::string fileFormat(".nii.gz");
       const std::string fileNamePart("_000_000");
       std::string outModalFile;
       size_t len = inDir.length() + 1 + token.length() + fileNamePart.length() + 1 + fileFormat.length();
       outModalFile.reserve(len); // The 1(s) indicates a directory separator char and an underscore.
       for (size_t i = 0; i < m_OtherModalPaths.size(); ++i)
       {
         mitk::Image::ConstPointer modalImage = m_OtherModalPaths[i];
         outModalFile.append(inDir);
         outModalFile.push_back(IOUtil::GetDirectorySeparator());
         outModalFile.append(token);
         outModalFile.append(fileNamePart);
         outModalFile.append(std::to_string(i));
         outModalFile.append(fileFormat);
         IOUtil::Save(modalImage.GetPointer(), outModalFile);
         outModalFile.clear();
       }
     }
     else
     {
       IOUtil::Save(inputAtTimeStep, inputImagePath);
     }
   }
   catch (const mitk::Exception &e)
   {
     /*
     Can't throw mitk exception to the caller. Refer: T28691
     */
     MITK_ERROR << e.GetDescription();
     return;
   }
   // Code calls external process
   std::string command = "nnUNet_predict";
   if (this->GetNoPip())
   {
 #ifdef _WIN32
     command = "python";
 #else
     command = "python3";
 #endif
   }
   for (ModelParams &modelparam : m_ParamQ)
   {
     outDir = IOUtil::CreateTemporaryDirectory("nnunet-out-XXXXXX", this->GetMitkTempDir());
     outputImagePath = outDir + IOUtil::GetDirectorySeparator() + token + "_000.nii.gz";
     modelparam.outputDir = outDir;
     args.clear();
     if (this->GetNoPip())
     {
       args.push_back(scriptPath);
     }
     args.push_back("-i");
     args.push_back(inDir);
 
     args.push_back("-o");
     args.push_back(outDir);
 
     args.push_back("-t");
     args.push_back(modelparam.task);
 
     if (modelparam.model.find("cascade") != std::string::npos)
     {
       args.push_back("-ctr");
     }
     else
     {
       args.push_back("-tr");
     }
     args.push_back(modelparam.trainer);
 
     args.push_back("-m");
     args.push_back(modelparam.model);
 
     args.push_back("-p");
     args.push_back(modelparam.planId);
 
     if (!modelparam.folds.empty())
     {
       args.push_back("-f");
       for (auto fold : modelparam.folds)
       {
         args.push_back(fold);
       }
     }
 
     args.push_back("--num_threads_nifti_save");
     args.push_back("1"); // fixing to 1
 
     if (!this->GetMirror())
     {
       args.push_back("--disable_tta");
     }
 
     if (!this->GetMixedPrecision())
     {
       args.push_back("--disable_mixed_precision");
     }
 
     if (this->GetEnsemble())
     {
       args.push_back("--save_npz");
     }
 
     try
     {
       std::string resultsFolderEnv = "RESULTS_FOLDER=" + this->GetModelDirectory();
       itksys::SystemTools::PutEnv(resultsFolderEnv.c_str());
       std::string cudaEnv = "CUDA_VISIBLE_DEVICES=" + std::to_string(this->GetGpuId());
       itksys::SystemTools::PutEnv(cudaEnv.c_str());
 
       spExec->Execute(this->GetPythonPath(), command, args);
     }
     catch (const mitk::Exception &e)
     {
       /*
       Can't throw mitk exception to the caller. Refer: T28691
       */
       MITK_ERROR << e.GetDescription();
       return;
     }
   }
   if (this->GetEnsemble() && !this->GetPostProcessingJsonDirectory().empty())
   {
     args.clear();
     command = "nnUNet_ensemble";
     outDir = IOUtil::CreateTemporaryDirectory("nnunet-ensemble-out-XXXXXX", this->GetMitkTempDir());
     outputImagePath = outDir + IOUtil::GetDirectorySeparator() + token + "_000.nii.gz";
 
     args.push_back("-f");
     for (ModelParams &modelparam : m_ParamQ)
     {
       args.push_back(modelparam.outputDir);
     }
 
     args.push_back("-o");
     args.push_back(outDir);
 
     if (!this->GetPostProcessingJsonDirectory().empty())
     {
       args.push_back("-pp");
       args.push_back(this->GetPostProcessingJsonDirectory());
     }
 
     spExec->Execute(this->GetPythonPath(), command, args);
   }
   try
   {
     Image::Pointer outputImage = IOUtil::Load<Image>(outputImagePath);
     previewImage->InitializeByLabeledImage(outputImage);
     m_InputBuffer = inputAtTimeStep;
     m_OutputBuffer = previewImage;
   }
   catch (const mitk::Exception &e)
   {
     /*
     Can't throw mitk exception to the caller. Refer: T28691
     */
     MITK_ERROR << e.GetDescription();
     return;
   }
 }
diff --git a/Modules/Segmentation/Interactions/mitknnUnetTool.h b/Modules/Segmentation/Interactions/mitknnUnetTool.h
index 4412335c7b..320bfca130 100644
--- a/Modules/Segmentation/Interactions/mitknnUnetTool.h
+++ b/Modules/Segmentation/Interactions/mitknnUnetTool.h
@@ -1,213 +1,213 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef mitknnUnetTool_h_Included
 #define mitknnUnetTool_h_Included
 
 #include "mitkSegWithPreviewTool.h"
 #include "mitkCommon.h"
 #include "mitkToolManager.h"
 #include <MitkSegmentationExports.h>
 #include <mitkStandardFileLocations.h>
 #include <numeric>
 #include <utility>
 
 namespace us
 {
   class ModuleResource;
 }
 
 namespace mitk
 {
   /**
    * @brief nnUNet parameter request object holding all model parameters for input.
    * Also holds output temporary directory path.
    */
   struct ModelParams
   {
     std::string task;
     std::vector<std::string> folds;
     std::string model;
     std::string trainer;
     std::string planId;
     std::string outputDir;
     std::string inputName;
     std::string timeStamp;
 
     size_t generateHash() const
     {
       std::string toHash;
       std::string foldsConcatenated = std::accumulate(folds.begin(), folds.end(), std::string(""));
       toHash += this->task;
       toHash += this->model;
       toHash += this->inputName;
       toHash += foldsConcatenated;
       toHash += this->timeStamp;
       size_t hashVal = std::hash<std::string>{}(toHash);
       return hashVal;
     }
   };
 
   /**
     \brief nnUNet segmentation tool.
 
     \ingroup Interaction
     \ingroup ToolManagerEtAl
 
     \warning Only to be instantiated by mitk::ToolManager.
   */
   class MITKSEGMENTATION_EXPORT nnUNetTool : public SegWithPreviewTool
   {
   public:
     mitkClassMacro(nnUNetTool, SegWithPreviewTool);
     itkFactorylessNewMacro(Self);
     itkCloneMacro(Self);
 
     const char **GetXPM() const override;
     const char *GetName() const override;
     us::ModuleResource GetIconResource() const override;
 
     void Activated() override;
 
     itkSetMacro(nnUNetDirectory, std::string);
     itkGetConstMacro(nnUNetDirectory, std::string);
 
     itkSetMacro(ModelDirectory, std::string);
     itkGetConstMacro(ModelDirectory, std::string);
 
     itkSetMacro(PythonPath, std::string);
     itkGetConstMacro(PythonPath, std::string);
 
     itkSetMacro(MitkTempDir, std::string);
     itkGetConstMacro(MitkTempDir, std::string);
 
     itkSetMacro(PostProcessingJsonDirectory, std::string);
     itkGetConstMacro(PostProcessingJsonDirectory, std::string);
 
     itkSetMacro(MixedPrecision, bool);
     itkGetConstMacro(MixedPrecision, bool);
     itkBooleanMacro(MixedPrecision);
 
     itkSetMacro(Mirror, bool);
     itkGetConstMacro(Mirror, bool);
     itkBooleanMacro(Mirror);
 
     itkSetMacro(MultiModal, bool);
     itkGetConstMacro(MultiModal, bool);
     itkBooleanMacro(MultiModal);
 
     itkSetMacro(NoPip, bool);
     itkGetConstMacro(NoPip, bool);
     itkBooleanMacro(NoPip);
 
     itkSetMacro(Ensemble, bool);
     itkGetConstMacro(Ensemble, bool);
     itkBooleanMacro(Ensemble);
 
     itkSetMacro(Predict, bool);
     itkGetConstMacro(Predict, bool);
     itkBooleanMacro(Predict);
 
     itkSetMacro(GpuId, unsigned int);
     itkGetConstMacro(GpuId, unsigned int);
 
     /**
      * @brief vector of ModelParams.
      * Size > 1 only for ensemble prediction.
      */
     std::vector<ModelParams> m_ParamQ;
 
     /**
      * @brief Holds paths to other input image modalities.
      *
      */
     std::vector<mitk::Image::ConstPointer> m_OtherModalPaths;
 
     mitk::Image::ConstPointer m_InputBuffer;
 
     /**
      * @brief Renders the output LabelSetImage.
      * To called in the main thread.
      */
     void RenderOutputBuffer();
 
     /**
      * @brief Get the Output Buffer object
      *
      * @return LabelSetImage::Pointer
      */
     LabelSetImage::Pointer GetOutputBuffer();
 
     /**
      * @brief Sets the outputBuffer to nullptr
      *
      */
     void ClearOutputBuffer();
 
     /**
      *  @brief Returns the DataStorage from the ToolManager
      */
     mitk::DataStorage *GetDataStorage();
 
     mitk::DataNode *GetRefNode();
 
     void SetOutputBuffer(LabelSetImage::Pointer);
 
   protected:
     /**
      * @brief Construct a new nnUNet Tool object and temp directory.
      *
      */
     nnUNetTool();
 
     /**
      * @brief Destroy the nnUNet Tool object and deletes the temp directory.
      *
      */
     ~nnUNetTool();
 
     /**
      * @brief Overriden method from the tool manager to execute the segmentation
      * Implementation:
      * 1. Saves the inputAtTimeStep in a temporary directory.
      * 2. Copies other modalities, renames and saves in the temporary directory, if required.
      * 3. Sets RESULTS_FOLDER and CUDA_VISIBLE_DEVICES variables in the environment.
      * 3. Iterates through the parameter queue (m_ParamQ) and executes "nnUNet_predict" command with the parameters
      * 4. Expects an output image to be saved in the temporary directory by the python proces. Loads it as
      *    LabelSetImage and returns.
      *
      * @param inputAtTimeStep
      * @param timeStep
      * @return LabelSetImage::Pointer
      */
-    virtual void DoUpdatePreview(const Image* inputAtTimeStep, const Image* oldSegAtTimeStep, LabelSetImage* previewImage, TimeStepType timeStep);
+    void DoUpdatePreview(const Image* inputAtTimeStep, const Image* oldSegAtTimeStep, LabelSetImage* previewImage, TimeStepType timeStep) 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