diff --git a/Modules/SegmentationUI/Qmitk/QmitkSetupVirtualEnvUtil.cpp b/Modules/SegmentationUI/Qmitk/QmitkSetupVirtualEnvUtil.cpp
index b45d5fd904..46b672240e 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkSetupVirtualEnvUtil.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitkSetupVirtualEnvUtil.cpp
@@ -1,178 +1,183 @@
 /*============================================================================
 
 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
 
 ============================================================================*/
 
 #include "QmitkSetupVirtualEnvUtil.h"
 
 #include "mitkLogMacros.h"
 #include <QStandardPaths>
 #include <itkCommand.h>
 
 QmitkSetupVirtualEnvUtil::QmitkSetupVirtualEnvUtil()
 {
   m_BaseDir = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + QDir::separator() +
               qApp->organizationName() + QDir::separator();
 }
 
 QmitkSetupVirtualEnvUtil::QmitkSetupVirtualEnvUtil(const QString &baseDir)
 {
   m_BaseDir = baseDir;
 }
 
 QString& QmitkSetupVirtualEnvUtil::GetBaseDir()
 {
   return m_BaseDir;
 }
 
-QString& QmitkSetupVirtualEnvUtil::GetVirtualEnvPath()
+QString QmitkSetupVirtualEnvUtil::GetVirtualEnvPath()
 {
   return m_venvPath;
 }
 
 QString& QmitkSetupVirtualEnvUtil::GetSystemPythonPath()
 {
   return m_SysPythonPath;
 }
 
 QString& QmitkSetupVirtualEnvUtil::GetPythonPath()
 {
   return m_PythonPath;
 }
 
 QString& QmitkSetupVirtualEnvUtil::GetPipPath()
 {
   return m_PipPath;
 }
 
 void QmitkSetupVirtualEnvUtil::SetVirtualEnvPath(const QString &path)
 {
   m_venvPath = path;
 }
 
 void QmitkSetupVirtualEnvUtil::SetPipPath(const QString &path)
 {
   m_PipPath = path;
 }
 
 void QmitkSetupVirtualEnvUtil::SetPythonPath(const QString &path)
 {
   if (this->IsPythonPath(path))
   {
     m_PythonPath = path;
   }
   else
   {
     MITK_INFO << "Python was not detected in " + path.toStdString();
   }
 }
 
 void QmitkSetupVirtualEnvUtil::SetSystemPythonPath(const QString &path)
 {
   if (this->IsPythonPath(path))
   {
     m_SysPythonPath = path;
   }
   else
   {
     MITK_INFO << "Python was not detected in " + path.toStdString();
   }
 }
 
 void QmitkSetupVirtualEnvUtil::PrintProcessEvent(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;
   }
 }
 
 void QmitkSetupVirtualEnvUtil::InstallPytorch(const std::string &workingDir,
                                               void (*callback)(itk::Object *, const itk::EventObject &, void *))
 {
   mitk::ProcessExecutor::ArgumentListType args;
   auto spExec = mitk::ProcessExecutor::New();
   auto spCommand = itk::CStyleCommand::New();
   spCommand->SetCallback(callback);
   spExec->AddObserver(mitk::ExternalProcessOutputEvent(), spCommand);
   args.push_back("-m");
   args.push_back("pip");
   args.push_back("install");
   args.push_back("light-the-torch");
   spExec->Execute(workingDir, "python", args);
   PipInstall("torch", workingDir, callback, "ltt");
 }
 
+void QmitkSetupVirtualEnvUtil::InstallPytorch()
+{
+  this->InstallPytorch(GetPythonPath().toStdString(), &PrintProcessEvent);
+}
+
 void QmitkSetupVirtualEnvUtil::PipInstall(const std::string &library,
                                           const std::string &workingDir,
                                           void (*callback)(itk::Object *, const itk::EventObject &, void *),
                                           const std::string &command)
 {
   mitk::ProcessExecutor::ArgumentListType args;
   auto spExec = mitk::ProcessExecutor::New();
   auto spCommand = itk::CStyleCommand::New();
   spCommand->SetCallback(callback);
   spExec->AddObserver(mitk::ExternalProcessOutputEvent(), spCommand);
   args.push_back("install");
   args.push_back(library);
   spExec->Execute(workingDir, command, args);
 }
 
 void QmitkSetupVirtualEnvUtil::PipInstall(const std::string &library,
   void (*callback)(itk::Object*, const itk::EventObject&, void*),
   const std::string& command)
 {
   this->PipInstall(library, this->GetPipPath().toStdString(), callback, command);
 }
 
 void QmitkSetupVirtualEnvUtil::ExecutePython(const std::string &pythonCode,
                                              const std::string &workingDir,
                                              void (*callback)(itk::Object *, const itk::EventObject &, void *),
                                              const std::string &command)
 {
   mitk::ProcessExecutor::ArgumentListType args;
   auto spExec = mitk::ProcessExecutor::New();
   auto spCommand = itk::CStyleCommand::New();
   spCommand->SetCallback(callback);
   spExec->AddObserver(mitk::ExternalProcessOutputEvent(), spCommand);
   args.push_back("-c");
   args.push_back(pythonCode);
   spExec->Execute(workingDir, command, args);
 }
 
 void QmitkSetupVirtualEnvUtil::ExecutePython(const std::string &args,
                                              void (*callback)(itk::Object *, const itk::EventObject &, void *),
                                              const std::string &command)
 {
   this->ExecutePython(args, this->GetPythonPath().toStdString(), callback, command);
 }
 
 bool QmitkSetupVirtualEnvUtil::IsPythonPath(const QString &pythonPath)
 {
   QString fullPath = pythonPath;
   fullPath = fullPath.mid(fullPath.indexOf(" ") + 1);
   bool isExists =
 #ifdef _WIN32
     QFile::exists(fullPath + QDir::separator() + QString("python.exe"));
 #else
     QFile::exists(fullPath + QDir::separator() + QString("python3"));
 #endif
   return isExists;
-}
\ No newline at end of file
+}
diff --git a/Modules/SegmentationUI/Qmitk/QmitkSetupVirtualEnvUtil.h b/Modules/SegmentationUI/Qmitk/QmitkSetupVirtualEnvUtil.h
index 1a6ae74dea..3adcbae926 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkSetupVirtualEnvUtil.h
+++ b/Modules/SegmentationUI/Qmitk/QmitkSetupVirtualEnvUtil.h
@@ -1,74 +1,76 @@
 /*============================================================================
 
 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 QmitkSetupVirtualEnvUtil_h_Included
 #define QmitkSetupVirtualEnvUtil_h_Included
 
 #include "mitkLogMacros.h"
 #include "mitkProcessExecutor.h"
 #include <MitkSegmentationUIExports.h>
 #include <QString>
 #include <QDir>
 #include <QApplication>
 
 /**
- * @brief Class to ...
+ * @brief Super Class to Setup a python virtual environment and pip install required packages
  */
 class MITKSEGMENTATIONUI_EXPORT QmitkSetupVirtualEnvUtil
 {
 public:
   QmitkSetupVirtualEnvUtil(const QString& baseDir);
   QmitkSetupVirtualEnvUtil();
 
   virtual bool SetupVirtualEnv(const QString& venvName) = 0;
+  virtual QString GetVirtualEnvPath();
+
   void PipInstall(const std::string &library,
                   const std::string &workingDir,
                   void (*callback)(itk::Object *, const itk::EventObject &, void *),
                   const std::string &command = "pip3");
 
   void PipInstall(const std::string &library,
                   void (*callback)(itk::Object *, const itk::EventObject &, void *),
                   const std::string &command = "pip3");
 
 
   void ExecutePython(const std::string &args,
                      const std::string &pythonPath,
                      void (*callback)(itk::Object *, const itk::EventObject &, void *),
                      const std::string &command = "python");
 
   void ExecutePython(const std::string &args,
                      void (*callback)(itk::Object *, const itk::EventObject &, void *),
                      const std::string &command = "python");
 
   void InstallPytorch(const std::string &workingDir, void (*callback)(itk::Object *, const itk::EventObject &, void *));
+  void InstallPytorch();
 
   QString& GetBaseDir();
-  QString& GetVirtualEnvPath();
   QString& GetSystemPythonPath();
   QString& GetPythonPath();
   QString& GetPipPath();
   void SetSystemPythonPath(const QString& path);
   void SetPythonPath(const QString& path);
   void SetPipPath(const QString& path);
   void SetVirtualEnvPath(const QString &path);
 
   bool IsPythonPath(const QString &pythonPath);
   static void PrintProcessEvent(itk::Object * /*pCaller*/, const itk::EventObject &e, void *);
 
 private:
   QString m_PythonPath;
   QString m_PipPath;
   QString m_BaseDir;
   QString m_venvPath;
   QString m_SysPythonPath;
 };
 #endif
diff --git a/Modules/SegmentationUI/Qmitk/QmitkTotalSegmentatorGUIControls.ui b/Modules/SegmentationUI/Qmitk/QmitkTotalSegmentatorGUIControls.ui
index 6520329ae2..116a514004 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkTotalSegmentatorGUIControls.ui
+++ b/Modules/SegmentationUI/Qmitk/QmitkTotalSegmentatorGUIControls.ui
@@ -1,337 +1,356 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkTotalSegmentatorToolGUIControls</class>
  <widget class="QWidget" name="QmitkTotalSegmentatorToolGUIControls">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>699</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>QmitkTotalSegmentatorToolWidget</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="basicSettingsLayout">
      <item row="0" column="0" colspan="4">
       <widget class="QLabel" name="welcomeNote">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Preferred" vsizetype="Minimum">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
        </property>
        <property name="text">
         <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Welcome to Total Segmentator tool in MITK. [Experimental]&lt;/p&gt;&lt;p&gt;Please note that this is only an interface to Total Segmentator. MITK does not ship with Total Segmentator. Make sure to have a working Python environment with TotalSegmentator set up beforehand. Choose that environment in the Python Path before inferencing. &lt;/p&gt;&lt;p&gt;Refer to &lt;a href=&quot;https://github.com/wasserth/TotalSegmentator&quot;&gt;&lt;span style=&quot; text-decoration: underline; color:#0000ff;&quot;&gt;https://github.com/wasserth/TotalSegmentator&lt;/span&gt;&lt;/a&gt; to learn everything about the Total Segmentator.&lt;/p&gt;&lt;p&gt;&lt;br/&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
        </property>
        <property name="textFormat">
         <enum>Qt::RichText</enum>
        </property>
        <property name="wordWrap">
         <bool>true</bool>
        </property>
       </widget>
      </item>
 	 <item row ="1" colspan="4">
 	  <widget class="QPushButton" name="installButton">
 	   <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>Install Total Segmentator</string>
 	   </property>
 	  </widget>
 	 </item>
 		
 	 <item row="2" colspan="4">
 	  <widget class="ctkCollapsibleGroupBox" name="installGroupBox" native="true">
 	   <property name="minimumSize">
 		<size>
 		 <width>0</width>
 		 <height>0</height>
 		</size>
 	   </property>
 	   <property name="title" stdset="0">
 		<string>Install Options</string>
 	   </property>
 	   <property name="flat" stdset="0">
 		<bool>true</bool>
 	   </property>
 	   <property name="collapsedHeight" stdset="0">
 		<number>5</number>
 	    </property>
 		<property name="collapsed" stdset="0">
 		 <bool>true</bool>
 		</property>
 		<layout class="QVBoxLayout" name="verticalLayout_0">
 		<item>
 		 <layout class="QGridLayout" name="_1">
 		  <property name="leftMargin">
 		   <number>0</number>
 		  </property>
 		  <property name="topMargin">
 		   <number>0</number>
 		  </property>
 		  <property name="rightMargin">
 		   <number>0</number>
 		  </property>
 		  <property name="bottomMargin">
 		   <number>0</number>
 		  </property>
 		  <property name="spacing">
 		   <number>6</number>
 		  </property>
 		  <item row="0" column="0">
 		   <widget class="QLabel" name="OverrideLabel">
 			<property name="sizePolicy">
 			 <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
 			  <horstretch>0</horstretch>
 			  <verstretch>0</verstretch>
 			 </sizepolicy>
 			</property>
 			<property name="text">
 				<string>Use Custom Installation</string>
 			</property>
 		   </widget>
 		  </item>
 		  <item row="0" column="1">
 		   <widget class="ctkCheckBox" name="overrideBox" native="true">
 			<property name="checked" stdset="0">
 			 <bool>false</bool>
 			</property>
 		   </widget>
 		  </item>
+		  <item row="0" column="3">
+		   <widget class="QPushButton" name="clearButton">
+			<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>Clear Install</string>
+		    </property>
+		   </widget>
+		  </item>	 
 		  <item row="1" column="0">
 		   <widget class="QLabel" name="pythonEnvLabel">
 			<property name="sizePolicy">
 			 <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
 			  <horstretch>0</horstretch>
 			  <verstretch>0</verstretch>
 			 </sizepolicy>
 			</property>
 			<property name="text">
 			 <string>Custom Env. Path:</string>
 			</property>
 		   </widget>
 		  </item>
 		  <item row="1" column="1" colspan="3">
 		   <widget class="ctkComboBox" name="pythonEnvComboBox"/>
 		  </item>
 		  <item row="2" column="0">
 		   <widget class="QLabel" name="sysPythonLabel">
 			<property name="sizePolicy">
 			 <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
 			  <horstretch>0</horstretch>
 			  <verstretch>0</verstretch>
 			 </sizepolicy>
 			</property>
 			<property name="text">
 			  <string>System Python:</string>
 			</property>
 		   </widget>
 		  </item>
 		  <item row="2" column="1" colspan="3">
 		   <widget class="ctkComboBox" name="sysPythonComboBox"/>
 		  </item>
 		 </layout>
 		</item>
 	   </layout>
 	  </widget>
 	 </item>	
 		
 	 <item row="3" colspan="4">
 	  <widget class="QLabel" name="subtaskLabel">
 	   <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="3" column="1" colspan="3">
 	  <widget class="ctkComboBox" name="subtaskComboBox"/>
 	 </item>
     </layout>
    </item>
    <item>
     <widget class="ctkCollapsibleGroupBox" name="advancedGroupBox" native="true">
      <property name="minimumSize">
       <size>
        <width>0</width>
        <height>0</height>
       </size>
      </property>
      <property name="title" stdset="0">
       <string>Advanced</string>
      </property>
      <property name="flat" stdset="0">
       <bool>true</bool>
      </property>
      <property name="collapsedHeight" stdset="0">
       <number>5</number>
      </property>
      <property name="collapsed" stdset="0">
       <bool>true</bool>
      </property>
      <layout class="QVBoxLayout" name="verticalLayout_4">
       <item>
        <layout class="QGridLayout" name="_2">
         <property name="leftMargin">
          <number>0</number>
         </property>
         <property name="topMargin">
          <number>0</number>
         </property>
         <property name="rightMargin">
          <number>0</number>
         </property>
         <property name="bottomMargin">
          <number>0</number>
         </property>
         <property name="spacing">
          <number>6</number>
         </property>
 		<item row="0" column="0">
 	     <widget class="QLabel" name="fastLabel">
 		  <property name="sizePolicy">
 		   <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
 			<horstretch>0</horstretch>
 			<verstretch>0</verstretch>
 		   </sizepolicy>
 		  </property>
 		  <property name="text">
 	       <string>Fast</string>
 		  </property>
 		 </widget>
 		</item>  
 		<item row="0" column="1">
 	     <widget class="ctkCheckBox" name="fastBox" native="true">
 		  <property name="checked" stdset="0">
 		   <bool>true</bool>
 		  </property>
 		 </widget>
 		</item>
         <item row="2" 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="2" column="1" colspan="3">
          <widget class="ctkComboBox" name="gpuComboBox"/>
         </item>
        </layout>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <widget class="QPushButton" name="previewButton">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <property name="maximumSize">
       <size>
        <width>100000</width>
        <height>16777215</height>
       </size>
      </property>
      <property name="text">
       <string>Run Total Segmentator</string>
      </property>
     </widget>
    </item>
    <item>
     <widget class="QLabel" name="statusLabel">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <property name="wordWrap">
       <bool>true</bool>
      </property>
     </widget>
    </item>
   </layout>
  </widget>
  <layoutdefault spacing="6" margin="11"/>
   <customwidgets>
   <customwidget>
    <class>ctkComboBox</class>
    <extends>QComboBox</extends>
    <header location="global">ctkComboBox.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>ctkCollapsibleGroupBox</class>
    <extends>QWidget</extends>
    <header>ctkCollapsibleGroupBox.h</header>
   </customwidget>
   <customwidget>
    <class>ctkCheckBox</class>
    <extends>QWidget</extends>
    <header>ctkCheckBox.h</header>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>
 
diff --git a/Modules/SegmentationUI/Qmitk/QmitkTotalSegmentatorToolGUI.cpp b/Modules/SegmentationUI/Qmitk/QmitkTotalSegmentatorToolGUI.cpp
index b2326420de..86c483cd1c 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkTotalSegmentatorToolGUI.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitkTotalSegmentatorToolGUI.cpp
@@ -1,448 +1,459 @@
 #include "QmitkTotalSegmentatorToolGUI.h"
 
 #include "mitkProcessExecutor.h"
 #include "mitkTotalSegmentatorTool.h"
 #include <QApplication>
 #include <QDir>
 #include <QDirIterator>
 #include <QFileDialog>
 #include <QIcon>
 #include <QMessageBox>
 #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);
   this->AutoParsePythonPaths();
 #ifndef _WIN32
   m_Controls.sysPythonComboBox->addItem("/usr/bin");
 #endif
   m_Controls.sysPythonComboBox->addItem("Select");
   m_Controls.pythonEnvComboBox->addItem("Select");
   m_Controls.pythonEnvComboBox->setDuplicatesEnabled(false);
   m_Controls.pythonEnvComboBox->setDisabled(true);
   m_Controls.previewButton->setDisabled(true);
   m_Controls.statusLabel->setTextFormat(Qt::RichText);
   m_Controls.subtaskComboBox->addItems(m_VALID_TASKS);
   QString welcomeText;
   this->SetGPUInfo();
   if (m_GpuLoader.GetGPUCount() != 0)
   {
     welcomeText = "<b>STATUS: </b><i>Welcome to Total Segmentator tool. You're in luck: " +
                                QString::number(m_GpuLoader.GetGPUCount()) + " GPU(s) were detected.</i>";
   }
   else
   {
     welcomeText = "<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.clearButton, SIGNAL(clicked()), this, SLOT(OnClearInstall()));
   connect(m_Controls.installButton, SIGNAL(clicked()), this, SLOT(OnInstallBtnClicked()));
   connect(m_Controls.overrideBox, SIGNAL(stateChanged(int)), this, SLOT(OnOverrideChecked(int)));
   connect(m_Controls.pythonEnvComboBox,
           QOverload<int>::of(&QComboBox::activated),
           [=](int index) { OnPythonPathChanged(m_Controls.pythonEnvComboBox->itemText(index)); });
 
   Superclass::InitializeUI(mainLayout);
   //QString lastSelectedPyEnv = m_Settings.value("TotalSeg/LastPythonPath").toString();
   //m_Controls.pythonEnvComboBox->insertItem(0, lastSelectedPyEnv);
   const QString storageDir = m_Installer.GetVirtualEnvPath();
   m_IsInstalled = this->IsTotalSegmentatorInstalled(storageDir);
   if (m_IsInstalled)
   {
     m_PythonPath = GetPythonPathFromUI(storageDir);
     m_Installer.SetVirtualEnvPath(m_PythonPath);
     this->EnableAll(m_IsInstalled);
     welcomeText += " Totalsegmentator is already found installed."; 
   }
   else
   {
     welcomeText += " Totalsegmentator not installed. Please click on \"Install Totalsegmentator\" above.";
   }
   this->WriteStatusMessage(welcomeText);
 }
 
 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());
   }
 }
 
 void QmitkTotalSegmentatorToolGUI::EnableAll(bool isEnable)
 {
   m_Controls.previewButton->setEnabled(isEnable);
   m_Controls.subtaskComboBox->setEnabled(isEnable);
   m_Controls.installButton->setEnabled((!isEnable));
 }
 
 void QmitkTotalSegmentatorToolGUI::OnInstallBtnClicked()
 {
   bool isInstalled = false;
   MITK_INFO << m_Controls.sysPythonComboBox->currentText().toStdString();
   QString systemPython = GetPythonPathFromUI(m_Controls.sysPythonComboBox->currentText());
   MITK_INFO << systemPython.toStdString();
   if (systemPython.isEmpty())
   {
     this->WriteErrorMessage("Couldn't find Python");
     return;
   }
   else
   {
     m_Installer.SetSystemPythonPath(systemPython);
   }
   
   isInstalled = m_Installer.SetupVirtualEnv(m_Installer.m_VENV_NAME);
   if (isInstalled)
   {
     const QString pythonPath = m_Installer.GetVirtualEnvPath();
     m_PythonPath = GetPythonPathFromUI(m_Installer.GetVirtualEnvPath());
     this->WriteStatusMessage("Successfully installed TotalSegmentator");
   }
   else
   {
     this->WriteErrorMessage("Couldn't find TotalSegmentator");
   }
   this->EnableAll(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);
     }
     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;
   fullPath = fullPath.mid(fullPath.indexOf(" ") + 1);
   bool isPythonExists = false;
 #ifdef _WIN32
   isPythonExists = QFile::exists(fullPath + QDir::separator() + QString("python.exe"));
   if (!(fullPath.endsWith("Scripts", Qt::CaseInsensitive) || fullPath.endsWith("Scripts/", Qt::CaseInsensitive)))
   {
     fullPath += QDir::separator() + QString("Scripts");
     isPythonExists =
       (!isPythonExists) ? QFile::exists(fullPath + QDir::separator() + QString("python.exe")) : isPythonExists;
   }
 #else
   isPythonExists = QFile::exists(fullPath + QDir::separator() + QString("python3"));
   if (!(fullPath.endsWith("bin", Qt::CaseInsensitive) || fullPath.endsWith("bin/", Qt::CaseInsensitive)))
   {
     fullPath += QDir::separator() + QString("bin");
     isPythonExists =
       (!isPythonExists) ? QFile::exists(fullPath + QDir::separator() + QString("python3")) : isPythonExists;
   }
 #endif
   bool isExists = QFile::exists(fullPath + QDir::separator() + QString("TotalSegmentator")) && isPythonExists;
   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.sysPythonComboBox->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.sysPythonComboBox->insertItem(0, "(" + envName + "): " + subIt.filePath());
       }
     }
   }
 }
 
 void QmitkTotalSegmentatorToolGUI::OnPythonPathChanged(const QString &pyEnv)
 {
   if (pyEnv == QString("Select"))
   {
     m_Controls.previewButton->setDisabled(true);
     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 = GetPythonPathFromUI(pyEnv);
   }
 }
 
 QString QmitkTotalSegmentatorToolGUI::GetPythonPathFromUI(const QString &pyEnv)
 {
   QString pythonPath;
   QString fullPath = pyEnv.mid(pyEnv.indexOf(" ") + 1);
   if (fullPath.isEmpty())
   {
     return fullPath;
   }
   bool isPythonExists = false;
 #ifdef _WIN32
   isPythonExists = QFile::exists(fullPath + QDir::separator() + QString("python.exe"));
   if (isPythonExists)
   {
     pythonPath = fullPath;
   }
   else if (!(fullPath.endsWith("Scripts", Qt::CaseInsensitive) || fullPath.endsWith("Scripts/", Qt::CaseInsensitive)))
   {
     fullPath += QDir::separator() + QString("Scripts");
     pythonPath = fullPath;
   }
 #else
   isPythonExists = QFile::exists(fullPath + QDir::separator() + QString("python3"));
   if (isPythonExists)
   {
     pythonPath = fullPath;
   }
   else if (!(fullPath.endsWith("bin", Qt::CaseInsensitive) || fullPath.endsWith("bin/", Qt::CaseInsensitive)))
   {
     fullPath += QDir::separator() + QString("bin");
     pythonPath = fullPath;
   }
 #endif
   return pythonPath;
 }
 
 void QmitkTotalSegmentatorToolGUI::OnOverrideChecked(int state)
 {
   bool isEnabled = false;
   if (state == Qt::Checked)
   {
     isEnabled = true;
     m_Controls.previewButton->setDisabled(true);
     m_PythonPath.clear();
   }
   else
   {
     m_PythonPath.clear();
     m_Controls.previewButton->setDisabled(true);
     if (m_IsInstalled)
     {
       m_PythonPath = m_Installer.GetVirtualEnvPath();
       this->EnableAll(m_IsInstalled);
     }
   }
   m_Controls.pythonEnvComboBox->setEnabled(isEnabled);
 }
 
+void QmitkTotalSegmentatorToolGUI::OnClearInstall()
+{
+  QDir folderPath(m_Installer.GetVirtualEnvPath());
+  if (folderPath.removeRecursively())
+  {
+    m_Controls.installButton->setEnabled(true);
+  }
+  else
+  {
+    MITK_ERROR
+      << "The virtual environment couldn't be removed. Please check if you have the required access privileges.";
+  }
+}
 
 bool QmitkTotalSegmentatorToolInstaller::SetupVirtualEnv(const QString& venvName)
 {
-  MITK_INFO << GetSystemPythonPath().toStdString();
   if (GetSystemPythonPath().isEmpty())
   {
     return false;
   }
   QDir folderPath(GetBaseDir());
   folderPath.mkdir(venvName);
   if (!folderPath.cd(venvName))
   {
     return false; // Check if directory creation was successful.
   }
   mitk::ProcessExecutor::ArgumentListType args;
   auto spExec = mitk::ProcessExecutor::New();
   auto spCommand = itk::CStyleCommand::New();
   spCommand->SetCallback(&PrintProcessEvent);
   spExec->AddObserver(mitk::ExternalProcessOutputEvent(), spCommand);
 
   args.push_back("-m");
   args.push_back("venv");
   args.push_back(venvName.toStdString());
 #ifdef _WIN32
   QString pythonFile = GetSystemPythonPath() + QDir::separator() + "python.exe";
   QString pythonExeFolder = "Scripts";
 #else
   QString pythonFile = GetSystemPythonPath() + QDir::separator() + "python3";
   QString pythonExeFolder = "bin";
 #endif
   spExec->Execute(GetBaseDir().toStdString(), pythonFile.toStdString(), args); // Setup local virtual environment
   if (folderPath.cd(pythonExeFolder))
   {
-    SetPythonPath(folderPath.absolutePath());
-    SetPipPath(folderPath.absolutePath());
-    std::string workingDir = GetPythonPath().toStdString();
-    MITK_INFO << "workingDir: " << workingDir;
-    InstallPytorch(workingDir, &PrintProcessEvent);
+    this->SetPythonPath(folderPath.absolutePath());
+    this->SetPipPath(folderPath.absolutePath());
+    this->InstallPytorch();
     for (auto &package : m_PACKAGES)
     {
-      PipInstall(package.toStdString(), &PrintProcessEvent);
+      this->PipInstall(package.toStdString(), &PrintProcessEvent);
     }
     std::string pythonCode; // python syntax to check if torch is installed with CUDA.
     pythonCode.append("import torch;");
     pythonCode.append("print('Pytorch was installed with CUDA') if torch.cuda.is_available() else print('PyTorch was "
                       "installed WITHOUT CUDA');");
-    ExecutePython(pythonCode, &PrintProcessEvent);
+    this->ExecutePython(pythonCode, &PrintProcessEvent);
     return true;
   }
   return false;
 }
 
 QString QmitkTotalSegmentatorToolInstaller::GetVirtualEnvPath() 
 {
   return m_STORAGE_DIR + m_VENV_NAME;
-}
\ No newline at end of file
+}
diff --git a/Modules/SegmentationUI/Qmitk/QmitkTotalSegmentatorToolGUI.h b/Modules/SegmentationUI/Qmitk/QmitkTotalSegmentatorToolGUI.h
index b9d41f1a06..4625b454b2 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkTotalSegmentatorToolGUI.h
+++ b/Modules/SegmentationUI/Qmitk/QmitkTotalSegmentatorToolGUI.h
@@ -1,139 +1,144 @@
 #ifndef QmitkTotalSegmentatorToolGUI_h_Included
 #define QmitkTotalSegmentatorToolGUI_h_Included
 
 #include "QmitkMultiLabelSegWithPreviewToolGUIBase.h"
 #include "QmitkSetupVirtualEnvUtil.h"
 #include "QmitknnUNetGPU.h"
 #include "ui_QmitkTotalSegmentatorGUIControls.h"
 #include <MitkSegmentationUIExports.h>
 #include <QMessageBox>
 #include <QSettings>
 #include <QStandardPaths>
 
 class QmitkTotalSegmentatorToolInstaller : public QmitkSetupVirtualEnvUtil
 {
 public:
   const QString m_VENV_NAME = ".totalsegmentator";
   const QString m_TOTALSEGMENTATOR_VERSION = "1.5.3";
   const std::vector<QString> m_PACKAGES = {QString("Totalsegmentator==") + m_TOTALSEGMENTATOR_VERSION,
                                            QString("scipy==1.9.1")};
   const QString m_STORAGE_DIR;
   inline QmitkTotalSegmentatorToolInstaller(
     const QString baseDir = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + QDir::separator() +
                             qApp->organizationName() + QDir::separator())
     : QmitkSetupVirtualEnvUtil(baseDir), m_STORAGE_DIR(baseDir){};
   bool SetupVirtualEnv(const QString &) override;
-  QString GetVirtualEnvPath();
+  QString GetVirtualEnvPath() override;
 };
 
 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();
 
   /**
    * @brief Qt Slot
    */
   void OnOverrideChecked(int);
 
+  /**
+   * @brief Qt Slot
+   */
+  void OnClearInstall();
+
 protected:
   QmitkTotalSegmentatorToolGUI();
   ~QmitkTotalSegmentatorToolGUI() = default;
 
   void ConnectNewTool(mitk::SegWithPreviewTool *newTool) override;
   void InitializeUI(QBoxLayout *mainLayout) override;
 
   void EnableWidgets(bool enabled) override;
 
   /**
    * @brief Enable (or Disable) GUI elements.
    */
   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 &);
 
   QString GetPythonPathFromUI(const QString &pyEnv);
 
   /**
    * @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"};
   QmitkTotalSegmentatorToolInstaller m_Installer;
 };
 #endif