diff --git a/Modules/Segmentation/Interactions/mitkTotalSegmentatorTool.cpp b/Modules/Segmentation/Interactions/mitkTotalSegmentatorTool.cpp
index e2ff6aa6cd..c26e3457b1 100644
--- a/Modules/Segmentation/Interactions/mitkTotalSegmentatorTool.cpp
+++ b/Modules/Segmentation/Interactions/mitkTotalSegmentatorTool.cpp
@@ -1,265 +1,262 @@
 /*============================================================================
 
 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 "mitkTotalSegmentatorTool.h"
 
 #include "mitkIOUtil.h"
-#include <itksys/SystemTools.hxx>
 #include <filesystem>
+#include <itksys/SystemTools.hxx>
 
 // us
 #include <usGetModuleContext.h>
 #include <usModule.h>
 #include <usModuleContext.h>
 #include <usModuleResource.h>
 #include <usServiceReference.h>
 
 namespace mitk
 {
   MITK_TOOL_MACRO(MITKSEGMENTATION_EXPORT, TotalSegmentatorTool, "Total Segmentator");
 }
 
 mitk::TotalSegmentatorTool::~TotalSegmentatorTool()
 {
   itksys::SystemTools::RemoveADirectory(this->GetMitkTempDir());
 }
 
 void mitk::TotalSegmentatorTool::Activated()
 {
   Superclass::Activated();
   this->SetLabelTransferMode(LabelTransferMode::AllLabels);
 }
 
 const char **mitk::TotalSegmentatorTool::GetXPM() const
 {
   return nullptr;
 }
 
 us::ModuleResource mitk::TotalSegmentatorTool::GetIconResource() const
 {
   us::Module *module = us::GetModuleContext()->GetModule();
   us::ModuleResource resource = module->GetResource("AI.svg");
   return resource;
 }
 
 const char *mitk::TotalSegmentatorTool::GetName() const
 {
   return "Total Segmentator";
 }
 
-namespace
+void mitk::TotalSegmentatorTool::onPythonProcessEvent(itk::Object * /*pCaller*/, const itk::EventObject &e, void *)
 {
-  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);
+  std::string testCOUT;
+  std::string testCERR;
+  const auto *pEvent = dynamic_cast<const mitk::ExternalProcessStdOutEvent *>(&e);
 
-    if (pEvent)
-    {
-      testCOUT = testCOUT + pEvent->GetOutput();
-      MITK_INFO << testCOUT;
-    }
+  if (pEvent)
+  {
+    testCOUT = testCOUT + pEvent->GetOutput();
+    MITK_INFO << testCOUT;
+  }
 
-    const auto *pErrEvent = dynamic_cast<const mitk::ExternalProcessStdErrEvent *>(&e);
+  const auto *pErrEvent = dynamic_cast<const mitk::ExternalProcessStdErrEvent *>(&e);
 
-    if (pErrEvent)
-    {
-      testCERR = testCERR + pErrEvent->GetOutput();
-      MITK_ERROR << testCERR;
-    }
+  if (pErrEvent)
+  {
+    testCERR = testCERR + pErrEvent->GetOutput();
+    MITK_ERROR << testCERR;
   }
-} // namespace
+}
 
 void mitk::TotalSegmentatorTool::DoUpdatePreview(const Image *inputAtTimeStep,
                                                  const Image * /*oldSegAtTimeStep*/,
                                                  LabelSetImage *previewImage,
                                                  TimeStepType timeStep)
 {
   if (!m_IsMitkTempDirAvailable) // create temp directory if not done already
   {
     this->SetMitkTempDir(IOUtil::CreateTemporaryDirectory("mitk-XXXXXX"));
     m_IsMitkTempDirAvailable = true;
   }
   this->ParseLabelNames(this->GetLabelMapPath());
 
   ProcessExecutor::Pointer spExec = ProcessExecutor::New();
   itk::CStyleCommand::Pointer spCommand = itk::CStyleCommand::New();
   spCommand->SetCallback(&onPythonProcessEvent);
   spExec->AddObserver(ExternalProcessOutputEvent(), spCommand);
-  
+
   std::string inDir, outDir, inputImagePath, outputImagePath, scriptPath;
   inDir = IOUtil::CreateTemporaryDirectory("totalseg-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("_"));
   outDir = IOUtil::CreateTemporaryDirectory("totalseg-out-XXXXXX", this->GetMitkTempDir());
   outputImagePath = outDir + IOUtil::GetDirectorySeparator() + token + "_000.nii.gz";
   ProcessExecutor::ArgumentListType args;
 
   IOUtil::Save(inputAtTimeStep, inputImagePath);
 
   std::string *outArg = &outputImagePath;
   bool isSubTask = false;
   if (this->GetSubTask() != m_DEFAULT_TOTAL_TASK)
   {
     isSubTask = true;
     outputImagePath = outDir + IOUtil::GetDirectorySeparator() + this->GetSubTask() + ".nii.gz";
     outArg = &outDir;
   }
 
   this->run_totalsegmentator(
-     spExec, inputImagePath, *outArg, this->GetFast(), !isSubTask, this->GetGpuId(), m_DEFAULT_TOTAL_TASK);
+    spExec, inputImagePath, *outArg, this->GetFast(), !isSubTask, this->GetGpuId(), m_DEFAULT_TOTAL_TASK);
 
   if (isSubTask)
   {
     this->run_totalsegmentator(
       spExec, inputImagePath, *outArg, !isSubTask, !isSubTask, this->GetGpuId(), this->GetSubTask());
   }
 
   Image::Pointer outputImage = IOUtil::Load<Image>(outputImagePath);
   auto outputBuffer = mitk::LabelSetImage::New();
   outputBuffer->InitializeByLabeledImage(outputImage);
   outputBuffer->SetGeometry(inputAtTimeStep->GetGeometry());
   this->MapLabelsToSegmentation(outputBuffer, m_LabelMapTotal);
   TransferLabelSetImageContent(outputBuffer, previewImage, timeStep);
 }
 
 void mitk::TotalSegmentatorTool::run_totalsegmentator(ProcessExecutor::Pointer spExec,
                                                       const std::string &inputImagePath,
                                                       const std::string &outputImagePath,
                                                       bool isFast,
                                                       bool isMultiLabel,
                                                       unsigned int gpuId,
                                                       const std::string &subTask)
 {
   ProcessExecutor::ArgumentListType args;
   std::string command = "TotalSegmentator";
 #ifdef _WIN32
   command = "python";
 #else
   command = "TotalSegmentator";
 #endif
 
   args.clear();
 
 #ifdef _WIN32
   args.push_back("TotalSegmentator");
 #endif
 
   args.push_back("-i");
   args.push_back(inputImagePath);
 
   args.push_back("-o");
   args.push_back(outputImagePath);
 
   if (subTask != m_DEFAULT_TOTAL_TASK)
   {
     args.push_back("-ta");
     args.push_back(subTask);
   }
 
   if (isMultiLabel)
   {
     args.push_back("--ml");
   }
 
   if (isFast)
   {
     args.push_back("--fast");
   }
 
   try
   {
     std::string cudaEnv = "CUDA_VISIBLE_DEVICES=" + std::to_string(gpuId);
     itksys::SystemTools::PutEnv(cudaEnv.c_str());
 
     for (auto &arg : args)
       MITK_INFO << arg;
     MITK_INFO << this->GetPythonPath();
 
     spExec->Execute(this->GetPythonPath(), command, args);
   }
   catch (const mitk::Exception &e)
   {
     MITK_ERROR << e.GetDescription();
     return;
   }
 }
 
 void mitk::TotalSegmentatorTool::ParseLabelNames(const std::string &fileName)
 {
   std::fstream newfile;
   newfile.open(fileName, ios::in);
   std::stringstream buffer;
   if (newfile.is_open())
   {
     int line = 0;
     std::string temp;
     while (std::getline(newfile, temp))
     {
       if (line > 1 && line < 106)
       {
         buffer << temp;
       }
       ++line;
     }
   }
   std::string key, val;
   while (std::getline(std::getline(buffer, key, ':'), val, ','))
   {
     m_LabelMapTotal[std::stoi(key)] = val;
   }
 }
 
 void mitk::TotalSegmentatorTool::MapLabelsToSegmentation(mitk::LabelSetImage::Pointer outputBuffer,
                                                          std::map<int, std::string> &labelMap)
 {
   for (auto const &[key, val] : labelMap)
   {
     mitk::Label *labelptr = outputBuffer->GetLabel(key, 0);
     if (nullptr != labelptr)
     {
       labelptr->SetName(val);
     }
   }
 }
 
 std::string mitk::TotalSegmentatorTool::GetLabelMapPath()
 {
   std::string pythonFileName;
   std::filesystem::path pathToLabelMap(this->GetPythonPath());
   pathToLabelMap = pathToLabelMap.parent_path();
 #ifdef _WIN32
   pythonFileName = pathToLabelMap.string() + "/Lib/site-packages/totalsegmentator/map_to_binary.py";
 #else
   pathToLabelMap.append("lib");
   for (auto const &dir_entry : std::filesystem::directory_iterator{pathToLabelMap})
   {
     if (dir_entry.is_directory())
     {
       auto dirName = dir_entry.path().filename().string();
       if (dirName.rfind("python", 0) == 0)
       {
         pathToLabelMap.append(dir_entry.path().filename().string());
         break;
       }
     }
   }
   pythonFileName = pathToLabelMap.string() + "/site-packages/totalsegmentator/map_to_binary.py";
 #endif
   return pythonFileName;
 }
diff --git a/Modules/Segmentation/Interactions/mitkTotalSegmentatorTool.h b/Modules/Segmentation/Interactions/mitkTotalSegmentatorTool.h
index 866909c47a..7553739a8c 100644
--- a/Modules/Segmentation/Interactions/mitkTotalSegmentatorTool.h
+++ b/Modules/Segmentation/Interactions/mitkTotalSegmentatorTool.h
@@ -1,128 +1,130 @@
 /*============================================================================
 
 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 MITKTOTALSEGMENTATORTOOL_H
 #define MITKTOTALSEGMENTATORTOOL_H
 
 #include "mitkSegWithPreviewTool.h"
 #include <MitkSegmentationExports.h>
 #include "mitkProcessExecutor.h"
 
 
 namespace us
 {
   class ModuleResource;
 }
 
 namespace mitk
 {
 
   /**
     \brief TotalSegmentator segmentation tool.
 
     \ingroup Interaction
     \ingroup ToolManagerEtAl
 
     \warning Only to be instantiated by mitk::ToolManager.
   */
   class MITKSEGMENTATION_EXPORT TotalSegmentatorTool : public SegWithPreviewTool
   {
   public:
     mitkClassMacro(TotalSegmentatorTool, SegWithPreviewTool);
     itkFactorylessNewMacro(Self);
     itkCloneMacro(Self);
 
     const char *GetName() const override;
     const char **GetXPM() const override;
     us::ModuleResource GetIconResource() const override;
     void Activated() override;
 
     itkSetMacro(MitkTempDir, std::string);
     itkGetConstMacro(MitkTempDir, std::string); 
     
     itkSetMacro(SubTask, std::string);
     itkGetConstMacro(SubTask, std::string);
     
     itkSetMacro(PythonPath, std::string);
     itkGetConstMacro(PythonPath, std::string);
 
     itkSetMacro(GpuId, unsigned int);
     itkGetConstMacro(GpuId, unsigned int);
 
     itkSetMacro(Fast, bool);
     itkGetConstMacro(Fast, bool);
     itkBooleanMacro(Fast);
 
     itkSetMacro(IsMitkTempDirAvailable, bool);
     itkGetConstMacro(IsMitkTempDirAvailable, bool);
     itkBooleanMacro(IsMitkTempDirAvailable);
 
+    static void onPythonProcessEvent(itk::Object * /*pCaller*/, const itk::EventObject &e, void *);
+
   protected:
     TotalSegmentatorTool() = default;
     ~TotalSegmentatorTool();
 
     /**
      * @brief Overriden method from the tool manager to execute the segmentation
      * Implementation:
      * 1. Creates temp directory, if not done already.
      * 2. Parses Label names from map_to_binary.py for using later on.
      * 3. Calls "run_totalsegmentator" method.
      * 4. Expects an output image to be saved in the temporary directory by the python proces. Loads it as
      *    LabelSetImage and sets to previewImage.
      *
      * @param inputAtTimeStep
      * @param oldSegAtTimeStep
      * @param previewImage
      * @param timeStep
      */
     void DoUpdatePreview(const Image* inputAtTimeStep, const Image* oldSegAtTimeStep, LabelSetImage* previewImage, TimeStepType timeStep) override;
    
   private:
 
     /**
      * @brief Runs Totalsegmentator python process with desired arguments
      * 
      */
     void run_totalsegmentator(ProcessExecutor::Pointer, const std::string &, const std::string &, bool, bool, unsigned int, const std::string &);
 
     /**
      * @brief Applies the m_LabelMapTotal lookup table on the output segmentation LabelSetImage.
      * 
      */
     void MapLabelsToSegmentation(mitk::LabelSetImage::Pointer, std::map<int, std::string>&);
 
     /**
      * @brief Parses map_to_binary.py file to extract label ids and names
      * and stores as a map for reference in m_LabelMapTotal
      * 
      * @param filePath
      */
     void ParseLabelNames(const std::string &);
 
     /**
      * @brief Get the Label Map Path from the virtual environment location
      * 
      * @return std::string 
      */
     std::string GetLabelMapPath();
 
     std::string m_MitkTempDir;
     std::string m_PythonPath;
     std::string m_SubTask = "total";
     unsigned int m_GpuId;
     std::map<int, std::string> m_LabelMapTotal;
     bool m_Fast;
     bool m_IsMitkTempDirAvailable = false;
     const std::string m_TEMPLATE_FILENAME = "XXXXXX_000_0000.nii.gz";
     const std::string m_DEFAULT_TOTAL_TASK = "total";
   }; // class
 } // namespace
 #endif
diff --git a/Modules/SegmentationUI/Qmitk/QmitkTotalSegmentatorToolGUI.cpp b/Modules/SegmentationUI/Qmitk/QmitkTotalSegmentatorToolGUI.cpp
index fe633d2649..97a85f4ad1 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkTotalSegmentatorToolGUI.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitkTotalSegmentatorToolGUI.cpp
@@ -1,391 +1,407 @@
 #include "QmitkTotalSegmentatorToolGUI.h"
 
 #include "mitkProcessExecutor.h"
 #include "mitkTotalSegmentatorTool.h"
 #include <QApplication>
 #include <QDir>
 #include <QDirIterator>
 #include <QFileDialog>
 #include <QIcon>
 #include <QMessageBox>
 #include <QStandardPaths>
 #include <QUrl>
 #include <QtGlobal>
 
 MITK_TOOL_GUI_MACRO(MITKSEGMENTATIONUI_EXPORT, QmitkTotalSegmentatorToolGUI, "")
 
 QmitkTotalSegmentatorToolGUI::QmitkTotalSegmentatorToolGUI()
   : QmitkMultiLabelSegWithPreviewToolGUIBase(), m_SuperclassEnableConfirmSegBtnFnc(m_EnableConfirmSegBtnFnc)
 {
   // Nvidia-smi command returning zero doesn't always imply lack of GPUs.
   // Pytorch uses its own libraries to communicate to the GPUs. Hence, only a warning can be given.
   if (m_GpuLoader.GetGPUCount() == 0)
   {
     std::string warning = "WARNING: No GPUs were detected on your machine. The TotalSegmentator tool can be very slow.";
     this->ShowErrorMessage(warning);
   }
   m_EnableConfirmSegBtnFnc = [this](bool enabled)
   { return !m_FirstPreviewComputation ? m_SuperclassEnableConfirmSegBtnFnc(enabled) : false; };
 }
 
 void QmitkTotalSegmentatorToolGUI::ConnectNewTool(mitk::SegWithPreviewTool *newTool)
 {
   Superclass::ConnectNewTool(newTool);
   newTool->IsTimePointChangeAwareOff();
   m_FirstPreviewComputation = true;
 }
 
 void QmitkTotalSegmentatorToolGUI::InitializeUI(QBoxLayout *mainLayout)
 {
   m_Controls.setupUi(this);
   m_Controls.pythonEnvComboBox->addItem("Select");
   m_Controls.pythonEnvComboBox->setDuplicatesEnabled(false);
   m_Controls.previewButton->setDisabled(true);
   m_Controls.statusLabel->setTextFormat(Qt::RichText);
   m_Controls.subtaskComboBox->addItems(m_VALID_TASKS);
   this->AutoParsePythonPaths();
   this->SetGPUInfo();
   if (m_GpuLoader.GetGPUCount() != 0)
   {
     WriteStatusMessage(QString("<b>STATUS: </b><i>Welcome to Total Segmentator tool. You're in luck: " + QString::number(m_GpuLoader.GetGPUCount()) +
                                " GPU(s) were detected.</i>"));
   }
   else
   {
     WriteErrorMessage(QString("<b>STATUS: </b><i>Welcome to Total Segmentator tool. Sorry, " + QString::number(m_GpuLoader.GetGPUCount()) +
                               " GPUs were detected.</i>"));
   }
   mainLayout->addLayout(m_Controls.verticalLayout);
 
   connect(m_Controls.previewButton, SIGNAL(clicked()), this, SLOT(OnPreviewBtnClicked()));
   connect(m_Controls.installButton, SIGNAL(clicked()), this, SLOT(OnInstallBtnClicked()));
   connect(m_Controls.pythonEnvComboBox,
           SIGNAL(currentTextChanged(const QString &)),
           this,
           SLOT(OnPythonPathChanged(const QString &)));
 
   Superclass::InitializeUI(mainLayout);
 
   QString lastSelectedPyEnv = m_Settings.value("TotalSeg/LastPythonPath").toString();
   m_Controls.pythonEnvComboBox->insertItem(0, lastSelectedPyEnv);
 
   const QString storageDir =
     QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + "/" + qApp->organizationName() + "/";
   MITK_INFO << storageDir.toStdString();
-  this->ToggleEnableEverything(false);
-  if (this->IsTotalSegmentatorInstalled(storageDir + QDir::separator() + m_VENV_NAME))
-  {
-    this->ToggleEnableEverything(true);
-  }
+  m_IsInstalled = this->IsTotalSegmentatorInstalled(storageDir + QDir::separator() + m_VENV_NAME);
+  this->EnableAll(m_IsInstalled);
 }
 
 void QmitkTotalSegmentatorToolGUI::EnableWidgets(bool enabled)
 {
   Superclass::EnableWidgets(enabled);
 }
 
 void QmitkTotalSegmentatorToolGUI::SetGPUInfo()
 {
   std::vector<QmitkGPUSpec> specs = m_GpuLoader.GetAllGPUSpecs();
   for (const QmitkGPUSpec &gpuSpec : specs)
   {
     m_Controls.gpuComboBox->addItem(QString::number(gpuSpec.id) + ": " + gpuSpec.name + " (" + gpuSpec.memory + ")");
   }
   if (specs.empty())
   {
     m_Controls.gpuComboBox->setEditable(true);
     m_Controls.gpuComboBox->addItem(QString::number(0));
     m_Controls.gpuComboBox->setValidator(new QIntValidator(0, 999, this));
   }
 }
 
 unsigned int QmitkTotalSegmentatorToolGUI::FetchSelectedGPUFromUI()
 {
   QString gpuInfo = m_Controls.gpuComboBox->currentText();
   if (m_GpuLoader.GetGPUCount() == 0)
   {
     return static_cast<unsigned int>(gpuInfo.toInt());
   }
   else
   {
     QString gpuId = gpuInfo.split(":", QString::SplitBehavior::SkipEmptyParts).first();
     return static_cast<unsigned int>(gpuId.toInt());
   }
 }
 
-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
+//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 QmitkTotalSegmentatorToolGUI::ToggleEnableEverything(bool isEnable) 
+void QmitkTotalSegmentatorToolGUI::EnableAll(bool isEnable) 
 {
   m_Controls.previewButton->setEnabled(isEnable);
   m_Controls.subtaskComboBox->setEnabled(isEnable);
   m_Controls.installButton->setEnabled((!isEnable));
 }
 
 void QmitkTotalSegmentatorToolGUI::OnInstallBtnClicked()
 {
   const QString storageDir =
     QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + "/" + qApp->organizationName() + "/";
   MITK_INFO << storageDir.toStdString();
-  bool isSuccess = false;
+  bool isInstalled = false;
 #ifndef _WIN32
   isSuccess = SetUpTotalSegmentator(storageDir);
 #endif
-  if (isSuccess)
+  if (isInstalled)
   {
-    this->ToggleEnableEverything(true);
+    this->EnableAll(true);
     this->WriteStatusMessage("Successfully installed TotalSegmentator");
   }
   else
   {
     this->WriteErrorMessage("Couldn't find TotalSegmentator");
   }
 }
 
+
+bool QmitkTotalSegmentatorToolGUI::SetUpTotalSegmentatorWIN(const QString& path)
+{
+  return false;
+}
+
+
 bool QmitkTotalSegmentatorToolGUI::SetUpTotalSegmentator(const QString &path)
 {
+  auto tool = this->GetConnectedToolAs<mitk::TotalSegmentatorTool>();
+  if (nullptr == tool)
+  {
+    return false;
+  }
   bool isInstalled = false;
   QDir folderPath(path);
   if (this->IsTotalSegmentatorInstalled(folderPath.absoluteFilePath(m_VENV_NAME)))
   {
     return true;
   }
   folderPath.mkdir(m_VENV_NAME);
   if (!folderPath.cd(m_VENV_NAME))
   {
     return false; // Check if directory creation was successful.
   }
   mitk::ProcessExecutor::ArgumentListType args;
   auto spExec = mitk::ProcessExecutor::New();
-  itk::CStyleCommand::Pointer spCommand = itk::CStyleCommand::New();
-  spCommand->SetCallback(&onPythonProcessEvent);
+  auto spCommand = itk::CStyleCommand::New();
+  spCommand->SetCallback(tool->onPythonProcessEvent);
   spExec->AddObserver(mitk::ExternalProcessOutputEvent(), spCommand);
 
   args.push_back("-m"); 
   args.push_back("venv");
   args.push_back(m_VENV_NAME.toStdString());
   spExec->Execute(path.toStdString(), "/usr/bin/python", args);// Setup local virtual environment
 
   if (folderPath.cd("bin"))
   {
     std::string workingDir;
     workingDir = folderPath.absolutePath().toStdString();
     args.clear();
     args.push_back("install");
-    args.push_back("Totalsegmentator");
+    args.push_back("Totalsegmentator==" + m_TOTALSEGMENTATOR_VERSION);
     spExec->Execute(workingDir, "pip3", args); // Install TotalSegmentator in it.
     if (this->IsTotalSegmentatorInstalled(folderPath.absolutePath())) 
     {
       isInstalled = true; // Check if installation was successful
     }
+    args.clear();
+    args.push_back("-c");
+    std::string pythonCode; // python syntax to check if torch is installed with CUDA.
+    pythonCode.append("import torch;");
+    pythonCode.append("if not torch.cuda.is_available: raise ValueError('PyTorch installed without CUDA');");
+    args.push_back(pythonCode);
+    spExec->Execute(workingDir, "python3", args);
   }
   return isInstalled;
 }
 
 void QmitkTotalSegmentatorToolGUI::OnPreviewBtnClicked()
 {
   auto tool = this->GetConnectedToolAs<mitk::TotalSegmentatorTool>();
   if (nullptr == tool)
   {
     return;
   }
   QString pythonPathTextItem = "";
   try
   {
     m_Controls.previewButton->setEnabled(false);
     qApp->processEvents();
     if (!this->IsTotalSegmentatorInstalled(m_PythonPath))
     {
       throw std::runtime_error(m_WARNING_TOTALSEG_NOT_FOUND);
     }
     pythonPathTextItem = m_Controls.pythonEnvComboBox->currentText();
     bool isFast = m_Controls.fastBox->isChecked();
     QString subTask = m_Controls.subtaskComboBox->currentText();
     if (subTask != m_VALID_TASKS[0])
     {
       isFast = true;
     }
     tool->SetPythonPath(m_PythonPath.toStdString());
     tool->SetGpuId(FetchSelectedGPUFromUI());
     tool->SetFast(isFast);
     tool->SetSubTask(subTask.toStdString());
     this->WriteStatusMessage(QString("<b>STATUS: </b><i>Starting Segmentation task... This might take a while.</i>"));
     tool->UpdatePreview();
     m_Controls.previewButton->setEnabled(true);
   }
   catch (const std::exception &e)
   {
     std::stringstream errorMsg;
     errorMsg << "<b>STATUS: </b>Error while processing parameters for TotalSegmentator segmentation. Reason: "
              << e.what();
     this->ShowErrorMessage(errorMsg.str());
     this->WriteErrorMessage(QString::fromStdString(errorMsg.str()));
     m_Controls.previewButton->setEnabled(true);
     return;
   }
   catch (...)
   {
     std::string errorMsg = "Unkown error occured while generation TotalSegmentator segmentation.";
     this->ShowErrorMessage(errorMsg);
     m_Controls.previewButton->setEnabled(true);
     return;
   }
   this->SetLabelSetPreview(tool->GetPreviewSegmentation());
   tool->IsTimePointChangeAwareOn();
   this->ActualizePreviewLabelVisibility();
   this->WriteStatusMessage("<b>STATUS: </b><i>Segmentation task finished successfully.</i>");
   if (!pythonPathTextItem.isEmpty())// only cache if the prediction ended without errors.
   { 
     QString lastSelectedPyEnv = m_Settings.value("TotalSeg/LastPythonPath").toString();
     if (lastSelectedPyEnv != pythonPathTextItem) 
     {
       m_Settings.setValue("TotalSeg/LastPythonPath", pythonPathTextItem);
     }
   }
 }
 
 void QmitkTotalSegmentatorToolGUI::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 QmitkTotalSegmentatorToolGUI::WriteStatusMessage(const QString &message)
 {
   m_Controls.statusLabel->setText(message);
   m_Controls.statusLabel->setStyleSheet("font-weight: bold; color: white");
 }
 
 void QmitkTotalSegmentatorToolGUI::WriteErrorMessage(const QString &message)
 {
   m_Controls.statusLabel->setText(message);
   m_Controls.statusLabel->setStyleSheet("font-weight: bold; color: red");
 }
 
 bool QmitkTotalSegmentatorToolGUI::IsTotalSegmentatorInstalled(const QString &pythonPath)
 {
   QString fullPath = pythonPath;
 #ifdef _WIN32
   if (!(fullPath.endsWith("Scripts", Qt::CaseInsensitive) || fullPath.endsWith("Scripts/", Qt::CaseInsensitive)))
   {
     fullPath += QDir::separator() + QString("Scripts");
   }
 #else
   if (!(fullPath.endsWith("bin", Qt::CaseInsensitive) || fullPath.endsWith("bin/", Qt::CaseInsensitive)))
   {
     fullPath += QDir::separator() + QString("bin");
   }
 #endif
   fullPath = fullPath.mid(fullPath.indexOf(" ") + 1);
   bool isExists = QFile::exists(fullPath + QDir::separator() + QString("TotalSegmentator")) &&
 #ifdef _WIN32
                   QFile::exists(fullPath + QDir::separator() + QString("python.exe"));
 #else
                   QFile::exists(fullPath + QDir::separator() + QString("python3"));
 #endif
   return isExists;
 }
 
 void QmitkTotalSegmentatorToolGUI::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);
 }
 
 void QmitkTotalSegmentatorToolGUI::OnPythonPathChanged(const QString &pyEnv)
 {
   if (pyEnv == QString("Select"))
   {
     QString path =
       QFileDialog::getExistingDirectory(m_Controls.pythonEnvComboBox->parentWidget(), "Python Path", "dir");
     if (!path.isEmpty())
     {
       this->OnPythonPathChanged(path);                                  // recall same function for new path validation
       bool oldState = m_Controls.pythonEnvComboBox->blockSignals(true); // block signal firing while inserting item
       m_Controls.pythonEnvComboBox->insertItem(0, path);
       m_Controls.pythonEnvComboBox->setCurrentIndex(0);
       m_Controls.pythonEnvComboBox->blockSignals(
         oldState); // unblock signal firing after inserting item. Remove this after Qt6 migration
     }
   }
   else if (!this->IsTotalSegmentatorInstalled(pyEnv))
   {
     this->ShowErrorMessage(m_WARNING_TOTALSEG_NOT_FOUND);
     m_Controls.previewButton->setDisabled(true);
   }
   else
   {
     // Show positive status meeage
     m_Controls.previewButton->setDisabled(false);
     m_PythonPath = pyEnv.mid(pyEnv.indexOf(" ") + 1);
 #ifdef _WIN32
     if (!(m_PythonPath.endsWith("Scripts", Qt::CaseInsensitive) ||
           m_PythonPath.endsWith("Scripts/", Qt::CaseInsensitive)))
     {
       m_PythonPath += QDir::separator() + QString("Scripts");
     }
 #else
     if (!(m_PythonPath.endsWith("bin", Qt::CaseInsensitive) || m_PythonPath.endsWith("bin/", Qt::CaseInsensitive)))
     {
       m_PythonPath += QDir::separator() + QString("bin");
     }
 #endif
   }
 }
diff --git a/Modules/SegmentationUI/Qmitk/QmitkTotalSegmentatorToolGUI.h b/Modules/SegmentationUI/Qmitk/QmitkTotalSegmentatorToolGUI.h
index 02ccfed186..2bb4860607 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkTotalSegmentatorToolGUI.h
+++ b/Modules/SegmentationUI/Qmitk/QmitkTotalSegmentatorToolGUI.h
@@ -1,111 +1,113 @@
 #ifndef QmitkTotalSegmentatorToolGUI_h_Included
 #define QmitkTotalSegmentatorToolGUI_h_Included
 
 #include "QmitkMultiLabelSegWithPreviewToolGUIBase.h"
 #include "ui_QmitkTotalSegmentatorGUIControls.h"
 #include <MitkSegmentationUIExports.h>
 #include <QMessageBox>
 #include "QmitknnUNetGPU.h"
 #include <QSettings>
 
 
 class MITKSEGMENTATIONUI_EXPORT QmitkTotalSegmentatorToolGUI : public QmitkMultiLabelSegWithPreviewToolGUIBase
 {
   Q_OBJECT
 
 public:
   mitkClassMacro(QmitkTotalSegmentatorToolGUI, QmitkMultiLabelSegWithPreviewToolGUIBase);
   itkFactorylessNewMacro(Self);
   itkCloneMacro(Self);
 
 protected slots :
  
   /**
    * @brief Qt Slot
    */
   void OnPreviewBtnClicked();
 
   /**
    * @brief Qt Slot
    */
   void OnPythonPathChanged(const QString &);
 
   /**
     @brief Qt Slot
    */
   void OnInstallBtnClicked();
 
 protected:
   QmitkTotalSegmentatorToolGUI();
   ~QmitkTotalSegmentatorToolGUI() = default;
 
   void ConnectNewTool(mitk::SegWithPreviewTool* newTool) override;
   void InitializeUI(QBoxLayout* mainLayout) override;
 
   void EnableWidgets(bool enabled) override;
 
-  void ToggleEnableEverything(bool);
+  void EnableAll(bool);
 
   /**
    * @brief Searches and parses paths of python virtual enviroments
    * from predefined lookout locations
   */
   void AutoParsePythonPaths();
   
   /**
    * @brief Checks if TotalSegmentator command is valid in the selected python virtual environment.
    *
    * @return bool
    */
   bool IsTotalSegmentatorInstalled(const QString &);
 
   /**
    * @brief Creates a QMessage object and shows on screen.
    */
   void ShowErrorMessage(const std::string &, QMessageBox::Icon = QMessageBox::Critical);
 
   /**
    * @brief Writes any message in white on the tool pane.
    */
   void WriteStatusMessage(const QString &);
 
   /**
    * @brief Writes any message in red on the tool pane.
    */
   void WriteErrorMessage(const QString &);
   
   /**
    * @brief Adds GPU information to the gpu combo box.
    * In case, there aren't any GPUs avaialble, the combo box will be
    * rendered editable.
    */
   void SetGPUInfo();
 
   /**
    * @brief Returns GPU id of the selected GPU from the Combo box.
    *
    * @return unsigned int
    */
   unsigned int FetchSelectedGPUFromUI();
 
   bool SetUpTotalSegmentator(const QString &);
+  bool SetUpTotalSegmentatorWIN(const QString &);
   
   /**
    * @brief For storing values like Python path across sessions.
    */
   QSettings m_Settings;
 
   QString m_PythonPath;
   QmitkGPULoader m_GpuLoader;
   Ui_QmitkTotalSegmentatorToolGUIControls m_Controls;
   bool m_FirstPreviewComputation = true;
+  bool m_IsInstalled = false;
   EnableConfirmSegBtnFunctionType m_SuperclassEnableConfirmSegBtnFnc;
 
   const std::string m_WARNING_TOTALSEG_NOT_FOUND = "TotalSegmentator is not detected in the selected python environment.Please select a valid "
                         "python environment or install TotalSegmentator.";
   const QStringList m_VALID_TASKS = {"total", "cerebral_bleed", "hip_implant", "coronary_arteries"};
   const QString m_VENV_NAME = ".totalsegmentator";
-  
+  const std::string m_TOTALSEGMENTATOR_VERSION = "1.5.2";
 };
 
 #endif