melage 0.0.65__py3-none-any.whl → 1.0.0__py3-none-any.whl

melage/{widgets/mainwindow_widget.py → mainwindow_widget.py}

@@ -1,32 +1,26 @@
 __AUTHOR__ = 'Bahram Jafrasteh'
 
-
 import os
 import sys
 sys.path.append('..')
 from os.path import join, basename, dirname
 #from PyQt5.QtWidgets import QFileDialog
 from PyQt5 import QtWidgets, QtCore, QtGui
-from melage.widgets.fileDialog_widget import QFileDialogPreview
-from melage.utils.readData import readData
+from melage.dialogs.helpers import QFileDialogPreview, repeatN, screenshot, NewDialog
+from melage.dialogs import iminfo_dialog
+from melage.core.io import readData
 from melage.utils.utils import rhasattr
-from melage.widgets.settings_widget import settingsBN
-from melage.widgets.repeat_widget import repeatN
-from melage.widgets.screenshot_widget import screenshot
-from melage.widgets.enhanceImWidget import enhanceIm
+from melage.widgets import enhanceIm, SettingsDialog, dockWidgets, openglWidgets
 from PyQt5.QtCore import Qt, QSettings
-from melage.widgets.colorwidget import NewDialog
-from melage.widgets.dockWidgets import dockWidgets
-from melage.widgets.openglWidgets import openglWidgets
-from melage.widgets.iminfo import iminfo_dialog
-from melage.widgets.N4Dialog import N4Dialog, Worker
-from melage.utils.utils import select_proper_widgets, setCursorWidget, \
+from melage.utils.utils import select_proper_widgets, setCursorWidget, get_filter_for_file, \
     getCurrentSlice, updateSight, changeCoronalSagittalAxial, setSliceSeg, str_conv, find_avail_widgets,\
      update_last, manually_check_tree_item, update_image_sch, clean_parent_image, compute_volume
-from melage.utils.source_folder import *
+#from melage.config.paths import RESOURCE_FOLDER, DOCS_FOLDER,
+from melage.config import settings, VERSION
 import time
 from functools import partial
 from collections import defaultdict
+from melage.widgets import PluginManager
 
 
 class Ui_Main(dockWidgets, openglWidgets):
@@ -51,6 +45,17 @@ class Ui_Main(dockWidgets, openglWidgets):
         self.format_eco = 'None'
         self.format_mri = 'None'
         self._loaded = False
+        self.readImECO = []
+        self.readImMRI = []
+        self.MRI_RADIO_NAMES = [
+            'radioButton_21', 'radioButton_21_1',
+            'radioButton_21_2', 'radioButton_21_3'
+        ]
+        self.US_RADIO_NAMES = ['radioButton_1', 'radioButton_2',
+                               'radioButton_3', 'radioButton_4']
+        self.MRI_VIEW_INDICES = [4, 5, 6, 12]
+        self.US_VIEW_INDICES = [1, 2, 3, 11]
+        self.current_view = 'horizontal'
         self._num_adapted_points = 0
         self._firstSelection = None
         self._Xtimes = 1
@@ -58,9 +63,9 @@ class Ui_Main(dockWidgets, openglWidgets):
         self._rad_circle_dot = 50
         self.num_measure_area = 0
         self.num_measure_length = 0
-        self.source_dir = os.path.dirname(os.path.dirname(pwd))
-        self.settingsBN = settingsBN(self)
-        self.expectedTime = self.settingsBN.doubleSpinBox.value() * 60
+        #self.source_dir = os.path.dirname(os.path.dirname(pwd))
+        self.settingsBN = SettingsDialog(self)
+        self.expectedTime = self.settingsBN.auto_save_spinbox.value() * 60
         self.iminfo_dialog = iminfo_dialog(self)
         self._points_adapt_eco = []
         self._points_adapt_mri = []
@@ -73,112 +78,16 @@ class Ui_Main(dockWidgets, openglWidgets):
         self.linked = False
         self.filenameEco = ''
         self.filenameMRI = ''
-        self.settingsBN.newConfig.connect(
-            lambda vals: self.setConf(vals))
-
-        self.repeatTimes = repeatN(self)
-        self.repeatTimes.numberN.connect(
-            lambda  value: self.setXTimes(value)
-        )
-
-        self.screenShot = screenshot(self)
-        self.N4_dialog = N4Dialog(self)
-        self.N4_dialog.closeSig.connect(partial(self.maskingClose, 3))
-
-        self.N4_dialog.buttonpressed.connect(
-            lambda  value: self.N4_correction(value)
-        )
-        self.N4_dialog.buttonpressed2.connect(
-            lambda  value: self.N4_back(value)
-        )
-
-        from melage.widgets.ApplyMask import Masking
-        from melage.widgets.ChangeSystem import ChangeCoordSys
-        from melage.widgets.MaskOperations import MaskOperations
-        from melage.widgets.HistImage import HistImage
-        from melage.widgets.ImageThresholding import ThresholdingImage
-        from melage.widgets.brain_extraction import BET
-        from melage.widgets.brain_extraction_dl import BE_DL
-        from melage.widgets.Segmentation import Tissue_Seg
-        from melage.widgets.registrationWidget import RegistrationDialog
-        from melage.widgets.tranformationWidget import TransformationDialog
-        from melage.utils.utils import resize_window
-        self.resizeImage = resize_window(self, use_combobox=True)
-        self.Masking = Masking(self)
-        self.ImageThresholding = ThresholdingImage(self)
-        self.HistImage = HistImage(self)
-
-        self.BET = BET(self)
-        self.BET.set_pars()
-        self.BE_DL = BE_DL(self)
-        self.BE_DL.set_pars()
-
-        self.Tissue_Seg = Tissue_Seg(self)
-        self.Tissue_Seg.set_pars()
-
-        self.registrationD = RegistrationDialog(self, self.source_dir)
-        self.transformationD = TransformationDialog(self, self.source_dir)
-        self.registrationD.datachange.connect(self.updateDataRegistration)
-        self.MaskingOperations = MaskOperations(self)
-        self.ChCoordSys = ChangeCoordSys(self)
-        self.Masking.closeSig.connect(partial(self.maskingClose, 3))
-        self.resizeImage.closeSig.connect(partial(self.maskingClose, 3))
-        self.resizeImage.pushbutton.accepted.connect(partial(self.maskingClose, 3))
-        self.resizeImage.pushbutton.rejected.connect(partial(self.maskingClose, 3))
-        self.resizeImage.resizeim.connect(
-            lambda value: self.resize_image(value, None)
-        )
-        self.resizeImage.comboboxCh.connect(
-            lambda value1, value2: self.resize_image(value1, value2)
-        )
-        self.HistImage.closeSig.connect(partial(self.maskingClose, 3))
-        self.BET.closeSig.connect(partial(self.maskingClose, 4))
-        self.BE_DL.closeSig.connect(partial(self.maskingClose, 5))
-        self.Tissue_Seg.closeSig.connect(partial(self.maskingClose, 10))
 
+        self.create_dialog()
+        self.all_dialog_connect()
 
-        self.ImageThresholding.closeSig.connect(partial(self.maskingClose, 3))
-        self.MaskingOperations.closeSig.connect(partial(self.maskingClose, 3))
-        self.registrationD.closeSig.connect(partial(self.maskingClose, 3))
-        self.transformationD.closeSig.connect(partial(self.maskingClose, 3))
-        self.ChCoordSys.closeSig.connect(partial(self.maskingClose, 3))
-        self.iminfo_dialog.closeSig.connect(partial(self.maskingClose, 3))
-        self.iminfo_dialog.buttonBox.clicked.connect(partial(self.maskingClose, 3))
-        self.BET.betcomp.connect(
-                                 lambda value: self.Thresholding('BET', value))
-        self.BET.datachange.connect(self.updateDataBET)
-        self.BE_DL.betcomp.connect(
-                                   lambda value: self.Thresholding('Deep BET', value))
 
-        self.BE_DL.back_orig.connect(
-                                   lambda value: self.Thresholding('Deep BET', value))
-        self.BE_DL.datachange.connect(partial(self.updateDataBEDL, 0))
-        self.Tissue_Seg.datachange.connect(partial(self.updateDataBEDL, 1))
-        self.Tissue_Seg.betcomp.connect(
-                                   lambda value: self.Thresholding('Segmentation', value))
 
 
-        self.ImageThresholding.applySig.connect(partial(self.Thresholding, 'apply'))
-        self.ImageThresholding.histeqSig.connect(
-                                   lambda value: self.Thresholding('histeq', value))
-        self.ImageThresholding.repltSig.connect(partial(self.Thresholding, 'replot'))
-        self.ChCoordSys.buttonpressed.connect(
-            lambda value: self.applyNewCoordSys(value)
-        )
-        self.ChCoordSys.comboBox_image.currentIndexChanged.connect(
-            self.setCurrentCoordsystem
-        )
-        self.Masking.buttonpressed.connect(
-            lambda  value: self.applyMaskToImage(value, False)
-        )
-
-        self.MaskingOperations.buttonpressed.connect(
-            lambda value: self.applyMaskToImage(value, True)
-        )
-
         self.axis_eco = [0, 0, 1]
         self.axis_mri = [0, 0, 1]
-        self.enhanceIm = enhanceIm(self)
+
         if not os.path.exists('.temp'):
             os.mkdir('.temp')
         self.MouseButtonPress = False
@@ -205,8 +114,82 @@ class Ui_Main(dockWidgets, openglWidgets):
         self.settings = QSettings("./brainNeonatal.ini", QSettings.IniFormat) # setting to save
         self._basefileSave = ''
 
+        ### plugins
+        self.plugin_widgets = []  # To keep references to open plugin dialogs
 
 
+    def create_dialog(self):
+        from melage.dialogs import (Masking,  MaskOperationsDialog, HistImage,
+                                    ThresholdingImage, RegistrationDialog,
+                                    TransformationDialog)
+
+
+
+        self.repeatTimes = repeatN(self)
+        self.screenShot = screenshot(self)
+
+        self.Masking = Masking(self)
+        self.ImageThresholding = ThresholdingImage(self)
+        self.HistImage = HistImage(self)
+
+        self.registrationD = RegistrationDialog(self, settings.DEFAULT_USE_DIR)
+        self.transformationD = TransformationDialog(self, settings.DEFAULT_USE_DIR)
+        self.MaskingOperations = MaskOperationsDialog(self)
+
+        self.enhanceIm = enhanceIm(self)
+        # Group all dialogs that need resizing
+        dialogs_to_resize = [
+            self.repeatTimes, self.screenShot,
+            self.Masking, self.ImageThresholding, self.HistImage,
+            self.registrationD, self.transformationD,
+            self.MaskingOperations, self.enhanceIm
+        ]
+        for dialog in dialogs_to_resize:
+            self.adapt_dialog_size(dialog)
+    def all_dialog_connect(self):
+        self.registrationD.datachange.connect(self.updateDataRegistration)
+
+
+        self.repeatTimes.numberN.connect(
+            lambda value: self.setXTimes(value)
+        )
+        self.Masking.closeSig.connect(partial(self.maskingClose, 3))
+
+        self.HistImage.closeSig.connect(partial(self.maskingClose, 3))
+        self.ImageThresholding.closeSig.connect(partial(self.maskingClose, 3))
+        self.MaskingOperations.closeSig.connect(partial(self.maskingClose, 3))
+        self.registrationD.closeSig.connect(partial(self.maskingClose, 3))
+        self.transformationD.closeSig.connect(partial(self.maskingClose, 3))
+
+        self.iminfo_dialog.closeSig.connect(partial(self.maskingClose, 3))
+        self.iminfo_dialog.buttonBox.clicked.connect(partial(self.maskingClose, 3))
+
+        self.ImageThresholding.applySig.connect(partial(self.Thresholding, 'apply'))
+        self.ImageThresholding.histeqSig.connect(
+                                   lambda value: self.Thresholding('histeq', value))
+        self.ImageThresholding.repltSig.connect(partial(self.Thresholding, 'replot'))
+
+        self.Masking.apply_pressed.connect(
+            lambda  value: self.applyMaskToImage(value, False)
+        )
+        self.MaskingOperations.apply_pressed.connect(
+            lambda value: self.applyMaskToImage(value, True)
+        )
+
+    def adapt_dialog_size(self, dialog):
+        parent_size = self.size()
+        dialog_width = int(parent_size.width()*1.5 )  # e.g., 60% of parent width
+        dialog_height = int(parent_size.height()*1.5 )  # e.g., 50% of parent height
+
+        # Don't let it be smaller than its own minimum size
+        min_size = dialog.minimumSize()
+        if dialog_width < min_size.width():
+            dialog_width = min_size.width()
+        if dialog_height < min_size.height():
+            dialog_height = min_size.height()
+
+        dialog.resize(dialog_width, dialog_height)
+
     def setConf(self, list_vals):
         """
         Configuration of MELAGE
@@ -268,13 +251,13 @@ class Ui_Main(dockWidgets, openglWidgets):
                 screen = QtWidgets.QApplication.primaryScreen()
                 winid = QtWidgets.QApplication.desktop().winId()
                 p = screen.grabWindow(winid)
-                fileObj = QtWidgets.QFileDialog.getSaveFileName(self, "Open File", self.source_dir, filters, options=opts)
+                fileObj = QtWidgets.QFileDialog.getSaveFileName(self, "Open File", settings.DEFAULT_USE_DIR, filters, options=opts)
                 if fileObj[0] == '':
                     return
                 filename = fileObj[0] + '.png'
                 p.save(filename, 'png')
             else:
-                fileObj = QtWidgets.QFileDialog.getSaveFileName(self, "Open File", self.source_dir, filters, options=opts)
+                fileObj = QtWidgets.QFileDialog.getSaveFileName(self, "Open File", settings.DEFAULT_USE_DIR, filters, options=opts)
                 if fileObj[0] == '':
                     return
                 filename = fileObj[0] + '.png'
@@ -304,195 +287,144 @@ class Ui_Main(dockWidgets, openglWidgets):
     def showImInfoWindow(self):
         self.iminfo_dialog.show()
 
-    def setupUi(self, Main):
+    def setupUi0(self, Main):
         """
-
-        :param Main:
-        :return:
+        Sets up the entire user interface by calling logical helper methods.
         """
-        Main.setObjectName("Main")
-        Main.setEnabled(True)
-        Main.resize(851, 733)
-        sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Preferred)
-        sizePolicy.setHorizontalStretch(0)
-        sizePolicy.setVerticalStretch(0)
-        sizePolicy.setHeightForWidth(Main.sizePolicy().hasHeightForWidth())
-        Main.setSizePolicy(sizePolicy)
-        Main.setMinimumSize(QtCore.QSize(800, 800))
-        Main.setBaseSize(QtCore.QSize(1280, 720))
-        ### change geometry
-        availableGeometry = self.screen().availableGeometry()
-        self.resize(availableGeometry.width() , availableGeometry.height() )
-        #self.move((availableGeometry.width() ) // 2, (availableGeometry.height()) // 2)
-        ###
-        font = QtGui.QFont()
-        font.setFamily("Ubuntu")
-        Main.setFont(font)
-        Main.setCursor(QtGui.QCursor(QtCore.Qt.WaitCursor))
-        Main.setDockNestingEnabled(True)
-        self.centralwidget = QtWidgets.QWidget(Main)
-        self.centralwidget.setEnabled(True)
-        sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.MinimumExpanding,
-                                           QtWidgets.QSizePolicy.MinimumExpanding)
-        sizePolicy.setHorizontalStretch(0)
-        sizePolicy.setVerticalStretch(0)
-        sizePolicy.setHeightForWidth(self.centralwidget.sizePolicy().hasHeightForWidth())
-        self.centralwidget.setSizePolicy(sizePolicy)
-        self.centralwidget.setMinimumSize(QtCore.QSize(800, 600))
-        self.centralwidget.setObjectName("centralwidget")
-        self.setContextMenuPolicy(Qt.ActionsContextMenu)
-
-        self.createDockWidget(Main)
-        self.createOpenGLWidgets(self.centralwidget, self.colorsCombinations)
-        self.widgets_mri = [4, 5, 6, 12]
-        self.widgets_eco = [11,1,2,3]
-        #self.table_widget.setFunctionRemove(self.removeTableItem)
-        #self.table_widget_measure.setFunctionRemove(self.removeTableMeasureItem)
+        # A class attribute for the icon path is cleaner
+        # Make sure to define this in your class __init__ or here
+        #self.settings.RESOURCE_DIR = "path/to/your/icons"  # <-- DEFINE THIS
 
+        # --- 1. Basic window and layout setup ---
+        self._setup_main_window(Main)
+        self._setup_central_layout(Main)
 
-        self.horizontalSlider_1.valueChanged.connect(self.changeSight1)
-        self.horizontalSlider_2.valueChanged.connect(self.changeSight2)
-        self.horizontalSlider_3.valueChanged.connect(self.changeSight3)
-        self.horizontalSlider_4.valueChanged.connect(self.changeSight4)
-        self.horizontalSlider_5.valueChanged.connect(self.changeSight5)
-        self.horizontalSlider_6.valueChanged.connect(self.changeSight6)
-        self.horizontalSlider_11.valueChanged.connect(self.changeSightTab3)
-        self.horizontalSlider_12.valueChanged.connect(self.changeSightTab4)
-
-        self.table_update.clicked.connect(self.linkMRIECO)
-        self.table_link.clicked.connect(self.linkBoth)
-
-        self.horizontalSlider_1.setVisible(False)
-        self.horizontalSlider_2.setVisible(False)
-        self.horizontalSlider_3.setVisible(False)
-        self.horizontalSlider_4.setVisible(False)
-        self.horizontalSlider_5.setVisible(False)
-        self.horizontalSlider_6.setVisible(False)
-        self.horizontalSlider_7.setVisible(False)
-        self.horizontalSlider_8.setVisible(False)
-        self.horizontalSlider_9.setVisible(False)
-        self.horizontalSlider_10.setVisible(False)
-        self.horizontalSlider_11.setVisible(False)
-        self.horizontalSlider_12.setVisible(False)
+        # --- 2. Create UI components ---
+        # Create all actions first, so menus and toolbars can share them.
+        self._create_actions(Main)
 
-        self.radioButton_1.setVisible(False)
-        self.radioButton_2.setVisible(False)
-        self.radioButton_3.setVisible(False)
-        self.radioButton_4.setVisible(False)
-        self.radioButton_21_1.setVisible(False)
-        self.radioButton_21_2.setVisible(False)
-        self.radioButton_21_3.setVisible(False)
-        self.radioButton_21.setVisible(False)
+        # Create menus and add actions to them
+        self._setup_menus(Main)
 
-        self.radioButton_1.clicked.connect( partial(self.changeToCoronal, 'eco') )
-        self.radioButton_2.clicked.connect( partial (self.changeToSagittal, 'eco') )
-        self.radioButton_3.clicked.connect( partial( self.changeToAxial, 'eco') )
-        self.radioButton_4.clicked.connect(self.showSegOnWindow)
 
-        self.radioButton_21_1.clicked.connect( partial(self.changeToCoronal, 'mri') )
-        self.radioButton_21_2.clicked.connect( partial (self.changeToSagittal, 'mri') )
-        self.radioButton_21_3.clicked.connect( partial( self.changeToAxial, 'mri') )
-        self.radioButton_21.clicked.connect( self.showSegOnWindow)
+        # Create other widgets (Docks, OpenGL, ComboBox, Logo)
+        self._setup_other_widgets(Main)
 
-        sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.MinimumExpanding, QtWidgets.QSizePolicy.Fixed)
-        sizePolicy.setHorizontalStretch(0)
-        sizePolicy.setVerticalStretch(0)
-        sizePolicy.setHeightForWidth(self.label_2.sizePolicy().hasHeightForWidth())
-        self.label_1.setSizePolicy(sizePolicy)
-        self.label_2.setSizePolicy(sizePolicy)
-        self.label_3.setSizePolicy(sizePolicy)
-        self.label_4.setSizePolicy(sizePolicy)
-        self.label_5.setSizePolicy(sizePolicy)
-        self.label_6.setSizePolicy(sizePolicy)
-        self.label_7.setSizePolicy(sizePolicy)
-        self.label_8.setSizePolicy(sizePolicy)
-        self.label_9.setSizePolicy(sizePolicy)
-        self.label_10.setSizePolicy(sizePolicy)
-        self.label_11.setSizePolicy(sizePolicy)
-        self.label_12.setSizePolicy(sizePolicy)
+        # Create toolbars and add actions/widgets to them
+        # (Must be after _setup_other_widgets to add logo/combobox)
+        self._setup_toolbars(Main)
 
-        Main.setCentralWidget(self.centralwidget)
+        # --- 3. Connect logic ---
+        # Group all signal/slot connections together
+        self._connect_signals()
 
-        #self.createOpenglWidgets()
+        # --- 4. Set initial UI state ---
+        # Group all .setVisible(False), .setDisabled(True), etc.
+        self._set_initial_state()
 
-        
-        #########################   Menus ################################
-        self.menubar = QtWidgets.QMenuBar(Main)
-        self.menubar.setNativeMenuBar(False)
-        self.menubar.setGeometry(QtCore.QRect(0, 0, 1050, 22))
-        self.menubar.setObjectName("menubar")
-        Main.setMenuBar(self.menubar)
+        # --- 5. Finalize ---
+        self.retranslateUi(Main)
+        QtCore.QMetaObject.connectSlotsByName(Main)
 
-        self.menuFile = QtWidgets.QMenu(self.menubar)
-        self.menuFile.setObjectName("menuFile")
-        self.menuAbout = QtWidgets.QMenu(self.menubar)
-        self.menuAbout.setObjectName("menuAbout")
+        # Your other final init steps
+        Main.setFocusPolicy(Qt.StrongFocus)
+        Main.installEventFilter(Main)  # Use Main, not self
+        self.init_state()
+        self.create_cursors()
 
-        self.menuView = QtWidgets.QMenu(self.menubar)
-        self.menuView.setObjectName("menuView")
+        self.Main = Main
 
-        self.menuToolbar = QtWidgets.QMenu(self.menuView)
-        self.menuToolbar.setObjectName("menuToolbar")
+    def _setup_main_window(self, Main):
+        """Sets up the main QMainWindow properties (size, font, statusbar)."""
+        Main.setObjectName("Main")
+        Main.setEnabled(True)
+        Main.setMinimumSize(QtCore.QSize(500, 400))  # Your reasonable minimum size
 
-        self.menuWidgets = QtWidgets.QMenu(self.menuView)
-        self.menuWidgets.setObjectName("menuWidgets")
+        # Set default size relative to user's screen
+        try:
+            availableGeometry = Main.screen().availableGeometry()  # Use Main.screen()
+            default_width = int(availableGeometry.width() * 1)
+            default_height = int(availableGeometry.height() * 1)
+            Main.resize(default_width, default_height)
+        except AttributeError:
+            Main.resize(1024, 768)  # Fallback
+
+        # Set font
+        font = QtGui.QFont()
+        font.setFamily("Ubuntu")  # Note: This font may not exist on all systems
+        Main.setFont(font)
 
-        self.menuTools = QtWidgets.QMenu(self.menubar)
-        self.menuTools.setObjectName("menuTools")
+        Main.setDockNestingEnabled(True)
 
-        self.menuSeg = QtWidgets.QMenu(self.menuTools)
-        self.menuSeg.setObjectName("menuSeg")
+        # Status bar
+        self.statusbar = QtWidgets.QStatusBar(Main)
+        self.statusbar.setObjectName("statusbar")
+        Main.setStatusBar(self.statusbar)
 
-        self.menuCalc = QtWidgets.QMenu(self.menubar)
-        self.menuCalc.setObjectName("menuCalc")
+    def _setup_central_layout(self, Main):
+        """Creates the central widget and its main layout."""
+        self.centralwidget = QtWidgets.QWidget(Main)
+        self.centralwidget.setEnabled(True)
 
-        self.menuPreprocess = QtWidgets.QMenu(self.menuTools)
-        self.menuPreprocess.setObjectName("menuPrep")
+        sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.MinimumExpanding,
+                                           QtWidgets.QSizePolicy.MinimumExpanding)
+        self.centralwidget.setSizePolicy(sizePolicy)
+        self.centralwidget.setObjectName("centralwidget")
 
-        self.menuSegmentation = QtWidgets.QMenu(self.menuTools)
-        self.menuSegmentation.setObjectName("menuSeg")
+        # **CRITICAL FIX**: Removed the line:
+        # self.centralwidget.setMinimumSize(QtCore.QSize(800, 600))
+        # This was preventing your UI from shrinking!
 
-        self.menuRegistration = QtWidgets.QMenu(self.menuTools)
-        self.menuRegistration.setObjectName("menuRegistration")
+        # This single line creates the layout and assigns it.
+        #self.main_layout = QtWidgets.QVBoxLayout(self.centralwidget)
+        #self.main_layout.setObjectName("main_layout")
+        Main.setCentralWidget(self.centralwidget)
 
-        self.menuBasicInfo = QtWidgets.QMenu(self.menuTools)
-        self.menuBasicInfo.setObjectName("MenuBasicInfo")
+        Main.setContextMenuPolicy(Qt.ActionsContextMenu)  # Use Main, not self
 
-        self.menuImport = QtWidgets.QMenu(self.menubar)
-        self.menuImport.setObjectName("menuImport")
+        # Create OpenGL Widgets (fits well here as they are in the central layout)
+        self.widgets_mri = [4, 5, 6, 12]
+        self.widgets_eco = [11, 1, 2, 3]
+        self.createOpenGLWidgets(self.centralwidget, self.colorsCombinations)
 
-        self.menuExport = QtWidgets.QMenu(self.menubar)
-        self.menuExport.setObjectName("menuExport")
+    def _create_actions(self, Main):
+        """Creates all QActions and stores them as class attributes."""
+        # This function will be long, but it has only ONE job: create actions.
 
-        self.menuTV = QtWidgets.QMenu(self.menuCalc)
-        self.menuTV.setObjectName("menuTV")
+        # --- Color Action ---
 
-        ######################### Status Bar ################################
-        self.statusbar = QtWidgets.QStatusBar(Main)
-        self.statusbar.setObjectName("statusbar")
-        Main.setStatusBar(self.statusbar)
+        self.actionColor = QtWidgets.QAction(Main)
+        self.actionColor.setObjectName("actionColor")
+        self._icon_colorXFaded = QtGui.QIcon()
+        self.pixmap_box_color = QtGui.QPixmap(settings.RESOURCE_DIR + "/box.png")
+        colr = [1, 1, 1]
+        self.pixmap_box_color.fill((QtGui.QColor(colr[0] * 255, colr[1] * 255, colr[2] * 255, 1 * 255)))
+        self._icon_colorXFaded.addPixmap(self.pixmap_box_color, QtGui.QIcon.Normal, QtGui.QIcon.On)
+        self._icon_colorX = QtGui.QIcon()
+        colr = [1, 0, 0]
+        self.pixmap_box_color.fill((QtGui.QColor(colr[0] * 255, colr[1] * 255, colr[2] * 255, 1 * 255)))
+        self._icon_colorX.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR + "/box.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
+        self.actionColor.setIcon(self._icon_colorXFaded)
 
-        ######################### Open ################################
+        # --- File Actions ---
         self.actionOpenUS = QtWidgets.QAction(Main)
         self.actionOpenUS.setObjectName("actionOpenUS")
         icon_eco = QtGui.QIcon()
-        icon_eco.addPixmap(QtGui.QPixmap(source_folder+"/view1.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
+        icon_eco.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR + "/view1.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
 
         self.actionOpenUS.setIcon(icon_eco)
         self.actionOpenUS.setIconText('open')
-        self.actionOpenUS.triggered.connect(self.browseUS)
+
         self.actionOpenUS.setDisabled(True)
 
         self.actionOpenMRI = QtWidgets.QAction(Main)
         self.actionOpenMRI.setObjectName("actionOpenMRI")
         icon_mri = QtGui.QIcon()
-        icon_mri.addPixmap(QtGui.QPixmap(source_folder+"/view2.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
+        icon_mri.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR + "/view2.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
         self.actionOpenMRI.setIcon(icon_mri)
         self.actionOpenMRI.setIconText('open')
-        self.actionOpenMRI.triggered.connect(self.browseMRI)
         self.actionOpenMRI.setDisabled(True)
 
-        ######################### Actiton Open MultiSlices ###################
         self.actionComboBox = QtWidgets.QComboBox(Main)
         self.actionComboBox.setObjectName("actionComboBox")
         sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Maximum)
@@ -503,203 +435,138 @@ class Ui_Main(dockWidgets, openglWidgets):
         self.actionComboBox.setMinimumSize(QtCore.QSize(100, 0))
         self.actionComboBox.setSizePolicy(sizePolicy)
         self.actionComboBox.setObjectName("View1")
-        self.actionComboBox.currentTextChanged.connect(self.changeVolume)
+
         self.actionComboBox.setDisabled(True)
         self.actionComboBox.setObjectName("comboBox")
         cbstyle = """
-                    QComboBox QAbstractItemView {border: 1px solid grey;
-                    background: #03211c; 
-                    selection-background-color: #03211c;
-                    "text-align: left;"} 
-                    QComboBox {background: #03211c;margin-right: 1px;}
-                    QComboBox::drop-down {
-                subcontrol-origin: margin;}
-                padding-left
-                    """
+                        QComboBox QAbstractItemView {border: 1px solid grey;
+                        background: #03211c; 
+                        selection-background-color: #03211c;
+                        "text-align: left;"} 
+                        QComboBox {background: #03211c;margin-right: 1px;}
+                        QComboBox::drop-down {
+                    subcontrol-origin: margin;}
+                    padding-left
+                        """
         self.actionComboBox.setStyleSheet(cbstyle)
         for r in range(2):
             self.actionComboBox.addItem("{}".format(r))
         self.actionComboBox.setVisible(False)
 
-
-        ######################### Load MEAN FA ###############################
         self.actionOpenFA = QtWidgets.QAction(Main)
         self.actionOpenFA.setObjectName("actionOpenFA")
         icon = QtGui.QIcon()
-        icon.addPixmap(QtGui.QPixmap(source_folder+"/dti.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
+        icon.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR + "/dti.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
         self.actionOpenFA.setIcon(icon)
         self.actionOpenFA.setIconText('open')
-        self.actionOpenFA.triggered.connect(self.browseFA)
         self.actionOpenFA.setDisabled(True)
 
-        ######################### Load Tractography ###############################
         self.actionOpenTract = QtWidgets.QAction(Main)
         self.actionOpenTract.setObjectName("actionOpenTract")
         icon = QtGui.QIcon()
-        icon.addPixmap(QtGui.QPixmap(source_folder+"/tract.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
+        icon.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR + "/tract.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
         self.actionOpenTract.setIcon(icon)
         self.actionOpenTract.setIconText('open')
-        self.actionOpenTract.triggered.connect(self.browseTractoGraphy)
         self.actionOpenTract.setDisabled(True)
 
-        ######################### New Project ################################
         self.actionNew = QtWidgets.QAction(Main)
         self.actionNew.setObjectName("actionNew")
         icon = QtGui.QIcon()
-        icon.addPixmap(QtGui.QPixmap(source_folder+"/new.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
+        icon.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR + "/new.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
         self.actionNew.setIcon(icon)
         self.actionNew.setIconText('New')
-        self.actionNew.triggered.connect(self.newProject)
 
-        ######################### Close US ################################
+        # ...
+
         self.actionCloseUS = QtWidgets.QAction(Main)
         self.actionCloseUS.setObjectName("actionNew")
-        #icon = QtGui.QIcon()
-        #icon.addPixmap(QtGui.QPixmap(source_folder+"/new.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
-        #self.actionCloseUS.setIcon(icon)
         self.actionCloseUS.setIconText('Close View 1')
-        self.actionCloseUS.triggered.connect(self.CloseUS)
-        #self.actionCloseUS.triggered.connect(self.CloseUS)
 
+        # ...
         ######################### Close MRI ################################
         self.actionCloseMRI = QtWidgets.QAction(Main)
         self.actionCloseMRI.setObjectName("actionNew")
-        #icon = QtGui.QIcon()
-        #icon.addPixmap(QtGui.QPixmap(source_folder+"/new.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
-        #self.actionCloseUS.setIcon(icon)
         self.actionCloseMRI.setIconText('Close View 2')
-        self.actionCloseMRI.triggered.connect(self.CloseMRI)
-        #self.actionCloseMRI.triggered.connect(partial(self.CloseMRI, dialogue=False))
-
-
-
-        ######################### Import ################################
-
-
-
 
         self.actionImportSegMRI = QtWidgets.QAction(Main)
         self.actionImportSegMRI.setObjectName("action SegEco")
-        #icon = QtGui.QIcon()
-        #icon.addPixmap(QtGui.QPixmap(source_folder+"/new.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
-        #self.actionCloseUS.setIcon(icon)
+        # icon = QtGui.QIcon()
+        # icon.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR+"/new.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
+        # self.actionCloseUS.setIcon(icon)
         icon_mriS = QtGui.QIcon()
-        icon_mriS.addPixmap(QtGui.QPixmap(source_folder+"/view2_seg.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
+        icon_mriS.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR + "/view2_seg.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
         self.actionImportSegMRI.setIcon(icon_mriS)
         self.actionImportSegMRI.setIconText('Segmented View 2')
-        self.actionImportSegMRI.triggered.connect(partial(self.importData, 'MRISEG'))
         self.actionImportSegMRI.setDisabled(True)
 
         self.actionImportSegEco = QtWidgets.QAction(Main)
         self.actionImportSegEco.setObjectName("action SegEco")
         icon_ecoS = QtGui.QIcon()
-        icon_ecoS.addPixmap(QtGui.QPixmap(source_folder+"/view1_seg.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
+        icon_ecoS.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR + "/view1_seg.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
         self.actionImportSegEco.setIcon(icon_ecoS)
         self.actionImportSegEco.setIconText('Segmented view 1')
-        self.actionImportSegEco.triggered.connect(partial(self.importData, 'USSEG'))
         self.actionImportSegEco.setDisabled(True)
-        self.menuImport.addAction(self.actionOpenUS)
-        self.menuImport.addAction(self.actionOpenMRI)
-
-
-        self.menuImport.addSeparator()
-        self.menuImport.addAction(self.actionImportSegEco)
-        self.menuImport.addAction(self.actionImportSegMRI)
-
-
-
-
 
         ######################### Export ################################
         self.actionExportImEco = QtWidgets.QAction(Main)
         self.actionExportImEco.setObjectName("action ImEco")
-        #icon = QtGui.QIcon()
-        #icon.addPixmap(QtGui.QPixmap(source_folder+"/new.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
-        #self.actionCloseUS.setIcon(icon)
+        # icon = QtGui.QIcon()
+        # icon.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR+"/new.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
+        # self.actionCloseUS.setIcon(icon)
         self.actionExportImEco.setIcon(icon_eco)
         self.actionExportImEco.setIconText('Image View 1')
-        self.actionExportImEco.triggered.connect(partial(self.exportData, 'USIM'))
-
-
 
         self.actionExportSegEco = QtWidgets.QAction(Main)
         self.actionExportSegEco.setObjectName("action SegEco")
         self.actionExportSegEco.setIcon(icon_ecoS)
-        #icon = QtGui.QIcon()
-        #icon.addPixmap(QtGui.QPixmap(source_folder+"/new.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
-        #self.actionCloseUS.setIcon(icon)
+        # icon = QtGui.QIcon()
+        # icon.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR+"/new.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
+        # self.actionCloseUS.setIcon(icon)
         self.actionExportSegEco.setIconText('Segmented View 1')
-        self.actionExportSegEco.triggered.connect(partial(self.exportData, 'USSEG'))
-
-
-
 
         self.actionExportImMRI = QtWidgets.QAction(Main)
         self.actionExportImMRI.setObjectName("action IMMRI")
         self.actionExportImMRI.setIcon(icon_mri)
-        #icon = QtGui.QIcon()
-        #icon.addPixmap(QtGui.QPixmap(source_folder+"/new.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
-        #self.actionCloseUS.setIcon(icon)
+        # icon = QtGui.QIcon()
+        # icon.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR+"/new.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
+        # self.actionCloseUS.setIcon(icon)
         self.actionExportImMRI.setIconText('Image view 2')
-        self.actionExportImMRI.triggered.connect(partial(self.exportData, 'MRIIM'))
-
 
         self.actionExportSegMRI = QtWidgets.QAction(Main)
         self.actionExportSegMRI.setObjectName("action SegEco")
         self.actionExportSegMRI.setIcon(icon_mriS)
-        #icon = QtGui.QIcon()
-        #icon.addPixmap(QtGui.QPixmap(source_folder+"/new.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
-        #self.actionCloseUS.setIcon(icon)
+        # icon = QtGui.QIcon()
+        # icon.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR+"/new.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
+        # self.actionCloseUS.setIcon(icon)
         self.actionExportSegMRI.setIconText('Segmented View 2')
-        self.actionExportSegMRI.triggered.connect(partial(self.exportData, 'MRISEG'))
-
-        self.menuExport.addAction(self.actionExportImMRI)
-        self.menuExport.addAction(self.actionExportImEco)
-
-
-
-
-        self.menuExport.addSeparator()
-        self.menuExport.addAction(self.actionExportSegEco)
-        self.menuExport.addAction(self.actionExportSegMRI)
 
         self.actionExportImMRI.setDisabled(True)
         self.actionExportSegMRI.setDisabled(True)
-
         self.actionExportImEco.setDisabled(True)
         self.actionExportSegEco.setDisabled(True)
 
-
-        ######################### ScreenShot ################################
         self.actionScreenS = QtWidgets.QAction(Main)
         self.actionScreenS.setObjectName("actionNew")
-        #icon = QtGui.QIcon()
-        #icon.addPixmap(QtGui.QPixmap(source_folder+"/new.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
-        #self.actionCloseUS.setIcon(icon)
+        # icon = QtGui.QIcon()
+        # icon.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR+"/new.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
+        # self.actionCloseUS.setIcon(icon)
         self.actionScreenS.setIconText('Screen Shot')
-        self.actionScreenS.triggered.connect(self.showScreenShotWindow)
-
 
-
-        ######################### Load ################################
         self.actionLoad = QtWidgets.QAction(Main)
         self.actionLoad.setObjectName("actionLoad")
         icon = QtGui.QIcon()
-        icon.addPixmap(QtGui.QPixmap(source_folder+"/load.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
+        icon.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR + "/load.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
         self.actionLoad.setIcon(icon)
         self.actionLoad.setIconText('load')
-        self.actionLoad.triggered.connect(self.loadProject)
 
-        ######################### View -> Main Toolbar ################################
         self.actionMain_Toolbar = QtWidgets.QAction(Main)
         icon1 = QtGui.QIcon()
-        #icon1.addPixmap(QtGui.QPixmap(source_folder+"e/action_check.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
-        #icon1.addPixmap(QtGui.QPixmap(source_folder+"/action_check_OFF.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
-        #self.actionMain_Toolbar.setIcon(icon1)
+        # icon1.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR+"e/action_check.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
+        # icon1.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR+"/action_check_OFF.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
+        # self.actionMain_Toolbar.setIcon(icon1)
         self.actionMain_Toolbar.setObjectName("actionMain_Toolbar")
         self.actionMain_Toolbar.setCheckable(True)
 
-        ######################### View -> GUIDELINES ################################
         self.action_guideLines = QtWidgets.QAction(Main)
         icon1 = QtGui.QIcon()
         self.action_guideLines.setObjectName("Guide lines")
@@ -719,155 +586,137 @@ class Ui_Main(dockWidgets, openglWidgets):
         ######################### File -> INFO ################################
         self.actionFile_info = QtWidgets.QAction(Main)
         icon2 = QtGui.QIcon()
-        icon2.addPixmap(QtGui.QPixmap(source_folder+"/settings.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
+        icon2.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR + "/settings.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
         self.actionFile_info.setIcon(icon2)
         self.actionFile_info.setObjectName("actionFile_info")
-        self.actionFile_info.triggered.connect(self.showInfoWindow)
-
-
         ######################### Tools -> Undo ################################
         self.actionUndo = QtWidgets.QAction(Main)
-        #icon2 = QtGui.QIcon()
-        #icon2.addPixmap(QtGui.QPixmap(source_folder+"/settings.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
-        #self.actionUndo.setIcon(icon2)
+        # icon2 = QtGui.QIcon()
+        # icon2.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR+"/settings.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
+        # self.actionUndo.setIcon(icon2)
         self.actionUndo.setObjectName("action Undo")
-        self.actionUndo.triggered.connect(self.Undo)
-
         ######################### Tools -> Redo ################################
         self.actionRedo = QtWidgets.QAction(Main)
         # icon2 = QtGui.QIcon()
-        # icon2.addPixmap(QtGui.QPixmap(source_folder+"/settings.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
+        # icon2.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR+"/settings.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
         # self.actionUndo.setIcon(icon2)
         self.actionRedo.setObjectName("action Redo")
-        self.actionRedo.triggered.connect(self.Redo)
-        ######################### Tools -> contourGen ################################
-        #self.actionContourGen = QtWidgets.QAction(Main)
-        #self.actionContourGen.setObjectName("action contour generator")
-        #self.actionContourGen.triggered.connect(self.GenerateContour)
 
         ######################### File -> ChangeImage ################################
         self.actionFile_changeIM = QtWidgets.QAction(Main)
         icon2 = QtGui.QIcon()
-        icon2.addPixmap(QtGui.QPixmap(source_folder+"/info.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
+        icon2.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR + "/info.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
         self.actionFile_changeIM.setIcon(icon2)
         self.actionFile_changeIM.setObjectName("actionFile_changeIM")
-        self.actionFile_changeIM.triggered.connect(self.showIMVARSWindow)
 
         ######################### File -> Info ################################
         self.actionfile_iminfo = QtWidgets.QAction(Main)
         self.actionfile_iminfo.setObjectName("actionFile_info")
-        self.actionfile_iminfo.triggered.connect(partial(self.maskingShow, 5))
-
         ######################### File -> convert ################################
         self.actionconvert = QtWidgets.QAction(Main)
         icon = QtGui.QIcon()
-        icon.addPixmap(QtGui.QPixmap(source_folder+"/export.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
+        icon.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR + "/export.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
         self.actionconvert.setIcon(icon)
         self.actionconvert.setObjectName("actionconvert")
-        self.actionconvert.triggered.connect(self.convert)
-
 
         ######################### File -> save to nifti ################################
-        #self.actionsaveModified = QtWidgets.QAction(Main)
-        #icon = QtGui.QIcon()
-        #icon.addPixmap(QtGui.QPixmap(source_folder+"/export.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
-        #self.actionsaveModified.setIcon(icon)
-        #self.actionsaveModified.setObjectName("actionsavemodified")
-        #self.actionsaveModified.triggered.connect(self.save_eco_to_nifti)
+        # self.actionsaveModified = QtWidgets.QAction(Main)
+        # icon = QtGui.QIcon()
+        # icon.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR+"/export.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
+        # self.actionsaveModified.setIcon(icon)
+        # self.actionsaveModified.setObjectName("actionsavemodified")
+        # self.actionsaveModified.triggered.connect(self.save_eco_to_nifti)
 
-        ######################### File -> exit ################################
         self.actionexit = QtWidgets.QAction(Main)
         self.actionexit.setObjectName("actionexit")
         icon = QtGui.QIcon()
-        icon.addPixmap(QtGui.QPixmap(source_folder+"/close.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
+        icon.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR + "/close.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
         self.actionexit.setIcon(icon)
-        self.actionexit.triggered.connect(self.close)
 
         ######################### Logo ################################
         self.logo = QtWidgets.QLabel(Main)
-        self.logo.setPixmap(QtGui.QPixmap(source_folder+"/melage_top.png"))
-        self.logo.resize(100,50)
+        self.logo.setPixmap(QtGui.QPixmap(settings.RESOURCE_DIR + "/melage_top.png"))
+        self.logo.resize(100, 50)
 
         ######################### File -> save ################################
         self.actionsave = QtWidgets.QAction(Main)
         self.actionsave.setObjectName("actionsave")
         icon = QtGui.QIcon()
-        icon.addPixmap(QtGui.QPixmap(source_folder+"/save.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
+        icon.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR + "/save.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
         self.actionsave.setIcon(icon)
-        self.actionsave.triggered.connect(self.save)
+
         self.actionsave.setDisabled(True)
 
         ######################### File -> saveas ################################
         self.actionsaveas = QtWidgets.QAction(Main)
         self.actionsaveas.setObjectName("actionsaveas")
         icon = QtGui.QIcon()
-        icon.addPixmap(QtGui.QPixmap(source_folder+"/saveas.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
+        icon.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR + "/saveas.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
         self.actionsaveas.setIcon(icon)
-        self.actionsaveas.triggered.connect(self.saveas)
+
         self.actionsaveas.setDisabled(True)
 
         ######################### Pan Zoom ################################
         self.actionPan = QtWidgets.QAction(Main)
         self.actionPan.setObjectName("actionPan")
         self._icon_Hand_IXFaded = QtGui.QIcon()
-        self._icon_Hand_IXFaded.addPixmap(QtGui.QPixmap(source_folder+"/Hand_IXFaded.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
-        self._icon_Hand_IX = QtGui.QIcon()
-        self._icon_Hand_IX.addPixmap(QtGui.QPixmap(source_folder+"/Hand_IX.png"), QtGui.QIcon.Normal,
+        self._icon_Hand_IXFaded.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR + "/Hand_IXFaded.png"), QtGui.QIcon.Normal,
                                           QtGui.QIcon.On)
+        self._icon_Hand_IX = QtGui.QIcon()
+        self._icon_Hand_IX.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR + "/Hand_IX.png"), QtGui.QIcon.Normal,
+                                     QtGui.QIcon.On)
 
         self.actionPan.setIcon(self._icon_Hand_IXFaded)
 
         self.actionContour = QtWidgets.QAction(Main)
         self.actionContour.setObjectName("actionContour")
         self._icon_contourFaded = QtGui.QIcon()
-        self._icon_contourFaded.addPixmap(QtGui.QPixmap(source_folder+"/contourFaded.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
+        self._icon_contourFaded.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR + "/contourFaded.png"), QtGui.QIcon.Normal,
+                                          QtGui.QIcon.On)
         self._icon_contour = QtGui.QIcon()
-        self._icon_contour.addPixmap(QtGui.QPixmap(source_folder+"/contour.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
+        self._icon_contour.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR + "/contour.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
 
         self.actionContour.setIcon(self._icon_contourFaded)
 
-
         self.actionPoints = QtWidgets.QAction(Main)
         self.actionPoints.setObjectName("actionPoints")
         self._icon_pointsFaded = QtGui.QIcon()
-        self._icon_pointsFaded.addPixmap(QtGui.QPixmap(source_folder+"/pointsFaded.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
+        self._icon_pointsFaded.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR + "/pointsFaded.png"), QtGui.QIcon.Normal,
+                                         QtGui.QIcon.On)
         self._icon_points = QtGui.QIcon()
-        self._icon_points.addPixmap(QtGui.QPixmap(source_folder+"/points.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
+        self._icon_points.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR + "/points.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
 
         self.actionPoints.setIcon(self._icon_pointsFaded)
 
-
-
         self.actionCircles = QtWidgets.QAction(Main)
         self.actionCircles.setObjectName("action Circles")
         self._icon_CircleFaded = QtGui.QIcon()
-        self._icon_CircleFaded.addPixmap(QtGui.QPixmap(source_folder+"/circle_faded.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
+        self._icon_CircleFaded.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR + "/circle_faded.png"), QtGui.QIcon.Normal,
+                                         QtGui.QIcon.On)
         self._icon_circles = QtGui.QIcon()
-        self._icon_circles.addPixmap(QtGui.QPixmap(source_folder+"/circle.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
+        self._icon_circles.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR + "/circle.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
 
         self.actionCircles.setIcon(self._icon_CircleFaded)
 
-
         self.actionGoTo = QtWidgets.QAction(Main)
         self.actionGoTo.setCheckable(True)
         self.actionGoTo.setObjectName("goto")
         self._icon_gotoFaded = QtGui.QIcon()
-        self._icon_gotoFaded.addPixmap(QtGui.QPixmap(source_folder+"/synchFaded.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
+        self._icon_gotoFaded.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR + "/synchFaded.png"), QtGui.QIcon.Normal,
+                                       QtGui.QIcon.On)
         self._icon_goto = QtGui.QIcon()
-        self._icon_goto.addPixmap(QtGui.QPixmap(source_folder+"/synch.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
+        self._icon_goto.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR + "/synch.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
 
         self.actionGoTo.setIcon(self._icon_gotoFaded)
 
-
-
         self.action3D = QtWidgets.QAction(Main)
         self.action3D.setCheckable(True)
         self.action3D.setChecked(True)
         self.action3D.setObjectName("goto")
         self._icon_3dFaded = QtGui.QIcon()
-        self._icon_3dFaded.addPixmap(QtGui.QPixmap(source_folder+"/3dFaded.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
+        self._icon_3dFaded.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR + "/3dFaded.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
         self._icon_3d = QtGui.QIcon()
-        self._icon_3d.addPixmap(QtGui.QPixmap(source_folder+"/3d.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
+        self._icon_3d.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR + "/3d.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
 
         self.action3D.setIcon(self._icon_3d)
 
@@ -876,172 +725,179 @@ class Ui_Main(dockWidgets, openglWidgets):
         self.actionZoomIn.setChecked(True)
         self.actionZoomIn.setObjectName("goto")
         self._icon_zoomIn = QtGui.QIcon()
-        self._icon_zoomIn.addPixmap(QtGui.QPixmap(source_folder+"/zoom_inFaded.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
+        self._icon_zoomIn.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR + "/zoom_in.png"), QtGui.QIcon.Normal,
+                                    QtGui.QIcon.On)
         self._icon_zoomIn = QtGui.QIcon()
-        self._icon_zoomIn.addPixmap(QtGui.QPixmap(source_folder+"/zoom_in.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
+        self._icon_zoomIn.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR + "/zoom_in.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
 
         self.actionZoomIn.setIcon(self._icon_zoomIn)
 
-
         self.actionZoomOut = QtWidgets.QAction(Main)
         self.actionZoomOut.setCheckable(True)
         self.actionZoomOut.setChecked(True)
         self.actionZoomOut.setObjectName("goto")
         self._icon_zoomOut = QtGui.QIcon()
-        self._icon_zoomOut.addPixmap(QtGui.QPixmap(source_folder+"/zoom_outFaded.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
+        self._icon_zoomOut.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR + "/zoom_out.png"), QtGui.QIcon.Normal,
+                                     QtGui.QIcon.On)
         self._icon_zoomOut = QtGui.QIcon()
-        self._icon_zoomOut.addPixmap(QtGui.QPixmap(source_folder+"/zoom_out.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
+        self._icon_zoomOut.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR + "/zoom_out.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
 
         self.actionZoomOut.setIcon(self._icon_zoomOut)
 
 
+        self.actionZoomNeutral = QtWidgets.QAction(Main)
+        self.actionZoomNeutral.setCheckable(True)
+        self.actionZoomNeutral.setChecked(True)
+        self.actionZoomNeutral.setObjectName("goto")
+        _icon_zoomInN = QtGui.QIcon()
+        _icon_zoomInN.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR + "/zoom_neutral.png"), QtGui.QIcon.Normal,
+                                    QtGui.QIcon.On)
+        self.actionZoomNeutral.setIcon(_icon_zoomInN)
+
+
+
         self.actionContourX = QtWidgets.QAction(Main)
         self.actionContourX.setObjectName("actionContourX")
         self._icon_contourXFaded = QtGui.QIcon()
-        self._icon_contourXFaded.addPixmap(QtGui.QPixmap(source_folder+"/contourXFaded.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
+        self._icon_contourXFaded.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR + "/contourXFaded.png"), QtGui.QIcon.Normal,
+                                           QtGui.QIcon.On)
         self._icon_contourX = QtGui.QIcon()
-        self._icon_contourX.addPixmap(QtGui.QPixmap(source_folder+"/contourX.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
+        self._icon_contourX.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR + "/contourX.png"), QtGui.QIcon.Normal,
+                                      QtGui.QIcon.On)
         self.actionContourX.setIcon(self._icon_contourXFaded)
 
-
-        self.actionColor = QtWidgets.QAction(Main)
-        self.actionColor.setObjectName("actionColor")
-        self._icon_colorXFaded = QtGui.QIcon()
-        self.pixmap_box_color = QtGui.QPixmap(source_folder + "/box.png")
-        colr = [1,1,1]
-        self.pixmap_box_color.fill((QtGui.QColor(colr[0]*255, colr[1]*255, colr[2]*255, 1*255)))
-        self._icon_colorXFaded.addPixmap(self.pixmap_box_color, QtGui.QIcon.Normal, QtGui.QIcon.On)
-        self._icon_colorX = QtGui.QIcon()
-        colr = [1, 0, 0]
-        self.pixmap_box_color.fill((QtGui.QColor(colr[0]*255, colr[1]*255, colr[2]*255, 1*255)))
-        self._icon_colorX.addPixmap(QtGui.QPixmap(source_folder+"/box.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
-        self.actionColor.setIcon(self._icon_colorXFaded)
-        self.actionColor.triggered.connect(self.color_picker)
-        self.newdialog = NewDialog(Main)
-
-        self.pixmap_box_label = QtWidgets.QLabel(Main)
-        self.pixmap_box_label.setText('Combined')
-
-
-
-
-
         self.actionEraseX = QtWidgets.QAction(Main)
         self.actionEraseX.setObjectName("actionEraseX")
         self._icon_eraseXFaded = QtGui.QIcon()
-        self._icon_eraseXFaded.addPixmap(QtGui.QPixmap(source_folder+"/EraserXFaded.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
+        self._icon_eraseXFaded.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR + "/EraserXFaded.png"), QtGui.QIcon.Normal,
+                                         QtGui.QIcon.On)
         self._icon_eraseX = QtGui.QIcon()
-        self._icon_eraseX.addPixmap(QtGui.QPixmap(source_folder+"/EraserX.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
+        self._icon_eraseX.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR + "/EraserX.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
         self.actionEraseX.setIcon(self._icon_eraseXFaded)
 
+        self.actionRuler = QtWidgets.QAction(Main)
+        self.actionRuler.setObjectName("actionMeasure")
+        self._icon_rulerFaded = QtGui.QIcon()
+        self._icon_rulerFaded.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR + "/rulerFaded.png"), QtGui.QIcon.Normal,
+                                        QtGui.QIcon.On)
+        self._icon_ruler = QtGui.QIcon()
+        self._icon_ruler.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR + "/ruler.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
+        self.actionRuler.setIcon(self._icon_ruler)
+
+        ##########################################################
+
+        # --- Horizontal (Axial) View Action ---
+        self.actionHorizontalView = QtWidgets.QAction(Main)
+        self.actionHorizontalView.setObjectName("actionHorizontalView")
+
+        # Icons for horizontal view
+        self._icon_HVFaded = QtGui.QIcon()
+        self._icon_HVFaded.addPixmap(
+            QtGui.QPixmap(settings.RESOURCE_DIR + "/horizontalview.png"),
+            QtGui.QIcon.Normal, QtGui.QIcon.On
+        )
+        self._icon_HV = QtGui.QIcon()
+        self._icon_HV.addPixmap(
+            QtGui.QPixmap(settings.RESOURCE_DIR + "/horizontalview.png"),
+            QtGui.QIcon.Normal, QtGui.QIcon.On
+        )
+
+        self.actionHorizontalView.setIcon(self._icon_HV)
+        self.actionHorizontalView.setCheckable(True)
+        self.actionHorizontalView.setToolTip("Switch to Horizontal (Axial) View")
+        self.actionHorizontalView.triggered.connect(lambda: self.setView("horizontal"))
 
+        # --- Vertical (Coronal/Sagittal) View Action ---
+        self.actionVerticalView = QtWidgets.QAction(Main)
+        self.actionVerticalView.setObjectName("actionVerticalView")
 
-        self.actionRuler = QtWidgets.QAction(Main)
-        self.actionRuler.setObjectName("actionMeasure")
-        self._icon_rulerFaded = QtGui.QIcon()
-        self._icon_rulerFaded.addPixmap(QtGui.QPixmap(source_folder+"/rulerFaded.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
-        self._icon_ruler = QtGui.QIcon()
-        self._icon_ruler.addPixmap(QtGui.QPixmap(source_folder+"/ruler.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
-        self.actionRuler.setIcon(self._icon_ruler)
+        # Icons for vertical view
+        self._icon_VVFaded = QtGui.QIcon()
+        self._icon_VVFaded.addPixmap(
+            QtGui.QPixmap(settings.RESOURCE_DIR + "/verticalview.png"),
+            QtGui.QIcon.Normal, QtGui.QIcon.On
+        )
+        self._icon_VV = QtGui.QIcon()
+        self._icon_VV.addPixmap(
+            QtGui.QPixmap(settings.RESOURCE_DIR + "/verticalview.png"),
+            QtGui.QIcon.Normal, QtGui.QIcon.On
+        )
 
+        self.actionVerticalView.setIcon(self._icon_VV)
+        self.actionVerticalView.setCheckable(True)
+        self.actionVerticalView.setToolTip("Switch to Vertical (Coronal) View")
+        self.actionVerticalView.triggered.connect(lambda: self.setView("vertical"))
 
+        #############################################################
         self.actionLine = QtWidgets.QAction(Main)
         self.actionLine.setObjectName("actionLine")
         self._icon_lineFaded = QtGui.QIcon()
-        self._icon_lineFaded.addPixmap(QtGui.QPixmap(source_folder+"/linefaded.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
+        self._icon_lineFaded.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR + "/linefaded.png"), QtGui.QIcon.Normal,
+                                       QtGui.QIcon.On)
         self._icon_line = QtGui.QIcon()
-        self._icon_line.addPixmap(QtGui.QPixmap(source_folder+"/line.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
+        self._icon_line.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR + "/line.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
         self.actionLine.setIcon(self._icon_line)
 
-
-
         self.actionPaint = QtWidgets.QAction(Main)
         self.actionPaint.setObjectName("actionPaint")
         self._icon_pencilFaded = QtGui.QIcon()
-        self._icon_pencilFaded.addPixmap(QtGui.QPixmap(source_folder+"/pencilFaded.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
+        self._icon_pencilFaded.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR + "/pencilFaded.png"), QtGui.QIcon.Normal,
+                                         QtGui.QIcon.On)
         self._icon_pencil = QtGui.QIcon()
-        self._icon_pencil.addPixmap(QtGui.QPixmap(source_folder+"/pencil.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
+        self._icon_pencil.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR + "/pencil.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
 
         self.actionPaint.setIcon(self._icon_pencilFaded)
 
-
         self.actionErase = QtWidgets.QAction(Main)
         self.actionErase.setObjectName("actionErase")
         self._icon_EraserFaded = QtGui.QIcon()
-        self._icon_EraserFaded.addPixmap(QtGui.QPixmap(source_folder+"/EraserFaded.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
+        self._icon_EraserFaded.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR + "/EraserFaded.png"), QtGui.QIcon.Normal,
+                                         QtGui.QIcon.On)
         self._icon_Eraser = QtGui.QIcon()
-        self._icon_Eraser.addPixmap(QtGui.QPixmap(source_folder+"/Eraser.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
+        self._icon_Eraser.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR + "/Eraser.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
         self.actionErase.setIcon(self._icon_EraserFaded)
 
-
-
-
         self.actionLazyContour = QtWidgets.QAction(Main)
         self.actionLazyContour.setObjectName("actionLazyContour")
         icon = QtGui.QIcon()
-        icon.addPixmap(QtGui.QPixmap(source_folder+"/zoom_out.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
+        icon.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR + "/zoom_out.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
         self.actionLazyContour.setIcon(icon)
 
-
         self.actionArrow = QtWidgets.QAction(Main)
         self.actionArrow.setObjectName("actionArrow")
         self._icon_arrowFaded = QtGui.QIcon()
-        self._icon_arrowFaded.addPixmap(QtGui.QPixmap(source_folder+"/arrowFaded.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
+        self._icon_arrowFaded.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR + "/arrowFaded.png"), QtGui.QIcon.Normal,
+                                        QtGui.QIcon.On)
         self._icon_arrow = QtGui.QIcon()
-        self._icon_arrow.addPixmap(QtGui.QPixmap(source_folder+"/arrow.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
+        self._icon_arrow.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR + "/arrow.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
         self.actionArrow.setIcon(self._icon_arrowFaded)
 
         ######################### Rotate ################################
 
         self.actionrotate = QtWidgets.QAction(Main)
         icon1 = QtGui.QIcon()
-        icon1.addPixmap(QtGui.QPixmap( source_folder+"/action_check.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
-        icon1.addPixmap(QtGui.QPixmap(source_folder+"/action_check_OFF.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
+        icon1.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR + "/action_check.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
+        icon1.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR + "/action_check_OFF.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
         self.actionrotate.setIcon(icon1)
         self.actionrotate.setObjectName("actionrotate")
         self.actionrotate.setCheckable(True)
 
-
-        #self.pushButton = QtWidgets.QPushButton(self.centralwidget)
-        #self.pushButton.setGeometry(QtCore.QRect(50, 330, 89, 25))
-        #self.pushButton.setObjectName("pushButton")
-
+        # self.pushButton = QtWidgets.QPushButton(self.centralwidget)
+        # self.pushButton.setGeometry(QtCore.QRect(50, 330, 89, 25))
+        # self.pushButton.setObjectName("pushButton")
 
 
-        ######################## SEG ########################################
-        self.actionNNVentriclesSagittal = QtWidgets.QAction(Main)
-        self.actionNNVentriclesSagittal.setObjectName("actionSag")
-        self.actionNNVentriclesCoronal = QtWidgets.QAction(Main)
-        self.actionNNVentriclesCoronal.setObjectName("actionCor")
-        self.actionNNVentriclesAxial = QtWidgets.QAction(Main)
-        self.actionNNVentriclesAxial.setObjectName("actionNNVentriclesAxial")
-
-        self.actionNNventricleSegm = QtWidgets.QAction(Main)
-        self.actionNNventricleSegm.setObjectName('Ventricle segmentation')
-
-        self.actionN4Bias = QtWidgets.QAction(Main)
-        self.actionN4Bias.setObjectName('N4 Bias field correction')
-
-        self.actionTissueSeg = QtWidgets.QAction(Main)
-        self.actionTissueSeg.setObjectName('FCM')
-
 
         self.actionHistImage = QtWidgets.QAction(Main)
         self.actionHistImage.setObjectName('Histogram Image')
 
-        self.actionResizeImage = QtWidgets.QAction(Main)
-        self.actionResizeImage.setObjectName('Histogram Image')
 
-        self.actionBET = QtWidgets.QAction(Main)
-        self.actionBET.setObjectName('BET')
 
-        self.actionBEDL = QtWidgets.QAction(Main)
-        self.actionBEDL.setObjectName('Deep BET')
+
 
         self.actionImageThresholding = QtWidgets.QAction(Main)
         self.actionImageThresholding.setObjectName('Image Thresholding')
 
-
         self.actionImageRegistration = QtWidgets.QAction(Main)
         self.actionImageRegistration.setObjectName('Image Registration')
 
@@ -1051,16 +907,13 @@ class Ui_Main(dockWidgets, openglWidgets):
         self.actionMasking = QtWidgets.QAction(Main)
         self.actionMasking.setObjectName('Image Masking')
 
+
+
         self.actionOperationMask = QtWidgets.QAction(Main)
         self.actionOperationMask.setObjectName('Masking Operations')
 
-        self.actionChangeCS = QtWidgets.QAction(Main)
-        self.actionChangeCS.setObjectName('Change CS')
 
 
-        self.actionNNventricleGatherIm = QtWidgets.QAction(Main)
-        self.actionNNventricleGatherIm.setObjectName("actionNNventricleGatherIm")
-
         ######################## CALC ########################################
 
         self.actionTVCor = QtWidgets.QAction(Main)
@@ -1076,17 +929,9 @@ class Ui_Main(dockWidgets, openglWidgets):
         self.actionabout = QtWidgets.QAction(Main)
         self.actionabout.setObjectName("actionabout")
         icon = QtGui.QIcon()
-        icon.addPixmap(QtGui.QPixmap(source_folder+"/about.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
+        icon.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR + "/about.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
         self.actionabout.setIcon(icon)
-        self.actionabout.triggered.connect(self.about)
 
-
-        ######################### Help->Aobut ################################
-        #self.actionVersion = QtWidgets.QAction(self.menubar)
-        #self.actionVersion.setObjectName("actionVersion")
-        #self.actionVersion.setStyleSheet("color: blue;")
-        #self.actionVersion = QtWidgets.QWidgetAction(Main)
-        #self.actionVersion.setForeground(QtGui.QColor('blue'))
         self.actionVersion = QtWidgets.QWidgetAction(self)
         label = QtWidgets.QLabel("Version {}".format(VERSION))
         label.setStyleSheet("color: white;")
@@ -1095,24 +940,85 @@ class Ui_Main(dockWidgets, openglWidgets):
         ######################### Help->Manual ################################
         self.actionmanual = QtWidgets.QAction(Main)
         self.actionmanual.setObjectName("actionabout")
-        #icon = QtGui.QIcon()
-        #icon.addPixmap(QtGui.QPixmap(source_folder+"/about.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
-        #self.actionmanual.setIcon(icon)
-        self.actionmanual.triggered.connect(self.manual)
+        # icon = QtGui.QIcon()
+        # icon.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR+"/about.png"), QtGui.QIcon.Normal, QtGui.QIcon.On)
+        # self.actionmanual.setIcon(icon)
+
+    def _setup_menus(self, Main):
+        """Creates the menubar and menus, then populates them with actions."""
+        self.menubar = QtWidgets.QMenuBar(Main)
+        self.menubar.setNativeMenuBar(False)
+        self.menubar.setGeometry(QtCore.QRect(0, 0, 1050, 22))
+        self.menubar.setObjectName("menubar")
+        Main.setMenuBar(self.menubar)
+
+        self.menuFile = QtWidgets.QMenu(self.menubar)
+        self.menuFile.setObjectName("menuFile")
+        self.menuAbout = QtWidgets.QMenu(self.menubar)
+        self.menuAbout.setObjectName("menuAbout")
+
+        self.menuView = QtWidgets.QMenu(self.menubar)
+        self.menuView.setObjectName("menuView")
+
+        self.menuToolbar = QtWidgets.QMenu(self.menuView)
+        self.menuToolbar.setObjectName("menuToolbar")
+
+        self.menuWidgets = QtWidgets.QMenu(self.menuView)
+        self.menuWidgets.setObjectName("menuWidgets")
+
+        self.menuTools = QtWidgets.QMenu(self.menubar)
+        self.menuTools.setObjectName("menuTools")
+
+        self.menuPlugins = QtWidgets.QMenu(self.menubar)
+        self.menuPlugins.setObjectName("MenuPlugins")
+
+        self.menuSeg = QtWidgets.QMenu(self.menuTools)
+        self.menuSeg.setObjectName("menuSeg")
+
+        self.menuCalc = QtWidgets.QMenu(self.menubar)
+        self.menuCalc.setObjectName("menuCalc")
+
+        self.menuPreprocess = QtWidgets.QMenu(self.menuTools)
+        self.menuPreprocess.setObjectName("menuPrep")
+
 
+        self.menuRegistration = QtWidgets.QMenu(self.menuTools)
+        self.menuRegistration.setObjectName("menuRegistration")
+
+        self.menuBasicInfo = QtWidgets.QMenu(self.menuTools)
+        self.menuBasicInfo.setObjectName("MenuBasicInfo")
+
+        self.menuImport = QtWidgets.QMenu(self.menubar)
+        self.menuImport.setObjectName("menuImport")
+
+        self.menuExport = QtWidgets.QMenu(self.menubar)
+        self.menuExport.setObjectName("menuExport")
+
+        self.menuTV = QtWidgets.QMenu(self.menuCalc)
+        self.menuTV.setObjectName("menuTV")
+
+        self.menuImport.addAction(self.actionOpenUS)
+        self.menuImport.addAction(self.actionOpenMRI)
+
+        self.menuImport.addSeparator()
+        self.menuImport.addAction(self.actionImportSegEco)
+        self.menuImport.addAction(self.actionImportSegMRI)
+
+        self.menuExport.addAction(self.actionExportImMRI)
+        self.menuExport.addAction(self.actionExportImEco)
 
+        self.menuExport.addSeparator()
+        self.menuExport.addAction(self.actionExportSegEco)
+        self.menuExport.addAction(self.actionExportSegMRI)
 
-        ######################### Actions ################################
-        #self.menuFile.addAction(self.actionOpenUS)
-        #self.menuFile.addAction(self.actionOpenMRI)
         self.menuFile.addAction(self.actionNew)
         self.menuFile.addAction(self.actionLoad)
         self.menuFile.addSeparator()
         self.menuFile.addAction(self.actionsave)
         self.menuFile.addAction(self.actionsaveas)
-        #self.menuFile.addAction(self.actionsaveModified)
+        # self.menuFile.addAction(self.actionsaveModified)
         self.menuFile.addSeparator()
-        #self.menuFile.addAction(self.actionconvert)
+        # self.menuFile.addAction(self.actionconvert)
         self.menuFile.addMenu(self.menuImport)
         self.menuFile.addMenu(self.menuExport)
         self.menuFile.addSeparator()
@@ -1130,7 +1036,6 @@ class Ui_Main(dockWidgets, openglWidgets):
         self.menuAbout.addAction(self.actionabout)
         self.menuAbout.addAction(self.actionVersion)
 
-
         self.menuView.addAction(self.actionMain_Toolbar)
         self.menuView.addAction(self.action_interaction_Toolbar)
         self.menuView.addAction(self.action_guideLines)
@@ -1139,19 +1044,19 @@ class Ui_Main(dockWidgets, openglWidgets):
         self.menuToolbar.addAction(self.actionMain_Toolbar)
         self.menuToolbar.addAction(self.action_interaction_Toolbar)
         self.menuView.addMenu(self.menuWidgets)
+
+        # ... (all menuView adds) ...
+        """
+        
         actions_widgets = self.createPopupMenu().actions()
         for action in actions_widgets:
             self.menuWidgets.addAction(action)
-
+        """
         self.menuSeg.addSeparator()
 
-        #self.menuSeg.addAction(self.actionNNVentriclesSagittal)
-        #self.menuSeg.addAction(self.actionNNVentriclesCoronal)
-        #self.menuSeg.addAction(self.actionNNVentriclesAxial)
-        self.menuSeg.addAction(self.actionNNventricleSegm)
 
-        #self.menuSeg.addAction(self.actionNNventricleGatherIm)
 
+        # self.menuSeg.addAction(self.actionNNventricleGatherIm)
 
         self.menuTV.addSeparator()
         self.menuTV.addAction(self.actionTVCor)
@@ -1165,54 +1070,89 @@ class Ui_Main(dockWidgets, openglWidgets):
         self.menuRegistration.addAction(self.actionImageRegistration)
         self.menuRegistration.addAction(self.actionImageTransformation)
 
-
-
         self.menuPreprocess.addAction(self.actionMasking)
         self.menuPreprocess.addAction(self.actionOperationMask)
         self.menuPreprocess.addSeparator()
-        self.menuPreprocess.addAction(self.actionResizeImage)
-        self.menuPreprocess.addAction(self.actionChangeCS)
-        self.menuPreprocess.addSeparator()
-        self.menuPreprocess.addAction(self.actionN4Bias)
+        self.menuPreprocess.addAction(self.actionImageThresholding)
+
 
 
 
-        self.menuSegmentation.addAction(self.actionBEDL)
-        self.menuSegmentation.addAction(self.actionBET)
-        self.menuSegmentation.addSeparator()
-        self.menuSegmentation.addAction(self.actionTissueSeg)
-        self.menuSegmentation.addAction(self.actionImageThresholding)
 
 
         self.menuCalc.addAction(self.menuTV.menuAction())
+        standard_style = """
+                QMenu::separator {
+                    height: 1px;         /* Set the height of the separator line */
+                    background: lightgray; /* Give the line a color */
+                    margin-top: 5px;     /* Add 5 pixels of empty space above the line */
+                    margin-bottom: 5px;  /* Add 5 pixels of empty space below the line */
+                }
+            """
+        self.menuTools.setStyleSheet(standard_style)
+        self.menuPlugins.setStyleSheet(standard_style)
+
+
 
-        #self.menuTools.addAction(self.actionrotate)
-        #self.menuTools.addAction(self.actionPan)
-        #self.menuTools.addAction(self.actionContour)
-        #self.menuTools.addAction(self.actionLazyContour)
-        #self.menuTools.addAction(self.actionNNventricleSegm)
-        #self.menuTools.addAction(self.actionFile_changeIM)
+        # Your existing code to add actions and separators
         self.menuTools.addAction(self.actionUndo)
         self.menuTools.addAction(self.actionRedo)
-        #self.menuTools.addAction(self.actionContourGen)
-        #self.menuTools.addAction(self.menuSeg.menuAction())
         self.menuTools.addSeparator()
         self.menuTools.addAction(self.menuPreprocess.menuAction())
         self.menuTools.addSeparator()
-        self.menuTools.addAction(self.menuSegmentation.menuAction())
+        self.menuTools.addAction(self.menuRegistration.menuAction())
         self.menuTools.addSeparator()
-        #self.menuTools.addAction(self.menuRegistration.menuAction())
         self.menuTools.addAction(self.menuBasicInfo.menuAction())
 
-        #self.menuTools.addAction(self.actionNNventricleGatherIm)
+        # self.menuTools.addAction(self.actionNNventricleGatherIm)
 
         self.menubar.addAction(self.menuFile.menuAction())
         self.menubar.addAction(self.menuView.menuAction())
         self.menubar.addAction(self.menuTools.menuAction())
-        #self.menubar.addAction(self.menuCalc.menuAction())
+        self.menubar.addAction(self.menuPlugins.menuAction())
         self.menubar.addAction(self.menuAbout.menuAction())
-        #self.menubar.addAction(self.actionVersion)
 
+        # self.menubar.addAction(self.actionVersion)
+
+    def _setup_other_widgets(self, Main):
+        """Creates widgets not in menus/toolbars (Docks, ComboBox, Logo)."""
+        self.pixmap_box_label = QtWidgets.QLabel(Main)
+        self.pixmap_box_label.setText('Combined')
+
+        self.createDockWidget(Main)
+
+        # Logo for toolbar
+        self.logo = QtWidgets.QLabel(Main)
+        self.logo.setPixmap(QtGui.QPixmap(settings.DEFAULT_USE_DIR + "/melage_top.png"))
+        self.logo.resize(100, 50)  # This hardcoded size is not ideal
+
+        # NewDialog
+        self.newdialog = NewDialog(Main)  # Assumes NewDialog is imported
+
+        # Label Size Policies (This assumes self.label_1, etc. exist from a .ui file)
+        try:
+
+            sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.MinimumExpanding, QtWidgets.QSizePolicy.Fixed)
+            sizePolicy.setHorizontalStretch(0)
+            sizePolicy.setVerticalStretch(0)
+            sizePolicy.setHeightForWidth(self.label_2.sizePolicy().hasHeightForWidth())
+            self.label_1.setSizePolicy(sizePolicy)
+            self.label_2.setSizePolicy(sizePolicy)
+            self.label_3.setSizePolicy(sizePolicy)
+            self.label_4.setSizePolicy(sizePolicy)
+            self.label_5.setSizePolicy(sizePolicy)
+            self.label_6.setSizePolicy(sizePolicy)
+            self.label_7.setSizePolicy(sizePolicy)
+            self.label_8.setSizePolicy(sizePolicy)
+            self.label_9.setSizePolicy(sizePolicy)
+            self.label_10.setSizePolicy(sizePolicy)
+            self.label_11.setSizePolicy(sizePolicy)
+            self.label_12.setSizePolicy(sizePolicy)
+        except AttributeError:
+            print("Warning: Labels not found. Skipping label size policy setup.")
+
+    def _setup_toolbars(self, Main):
+        """Creates and populates all toolbars."""
 
         self.toolBar = QtWidgets.QToolBar(Main)
         self.toolBar.setObjectName("toolBar")
@@ -1223,26 +1163,26 @@ class Ui_Main(dockWidgets, openglWidgets):
         self.toolBar.addAction(self.actionsave)
 
         self.toolBar.addSeparator()
-        #self.toolBar.addAction(self.actionsaveas)
-        #spacerItem = QtWidgets.QWidget()
-        #spacerItem.setSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Preferred)
-        #self.toolBar.addWidget(spacerItem)
+        # self.toolBar.addAction(self.actionsaveas)
+        # spacerItem = QtWidgets.QWidget()
+        # spacerItem.setSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Preferred)
+        # self.toolBar.addWidget(spacerItem)
         cts = """
-        QToolBar {
-  background-color: #000000;
-  border-bottom: 0px solid #19232D;
-  padding: 0px;
-  font-weight: bold;
-  spacing: 0px;
-}
-QToolBar::separator:horizontal
-{
-	width: 10px;
-	margin-left: 10px;
-		margin-right: 10px;
-}
-QToolButton{margin: 2px 2px;}
-        """
+                QToolBar {
+          background-color: #000000;
+          border-bottom: 0px solid #19232D;
+          padding: 0px;
+          font-weight: bold;
+          spacing: 0px;
+        }
+        QToolBar::separator:horizontal
+        {
+        	width: 10px;
+        	margin-left: 10px;
+        		margin-right: 10px;
+        }
+        QToolButton{margin: 2px 2px;}
+                """
         self.toolBar.setStyleSheet(cts)
 
         self.toolBar.addAction(self.actionOpenUS)
@@ -1251,14 +1191,12 @@ QToolButton{margin: 2px 2px;}
         self.toolBar.addAction(self.actionOpenMRI)
         self.toolBar.addAction(self.actionImportSegMRI)
 
-
-
-        #self.toolBar.addAction(self.actionOpenFA)
-        #self.toolBar.addAction(self.actionOpenTract)
+        # self.toolBar.addAction(self.actionOpenFA)
+        # self.toolBar.addAction(self.actionOpenTract)
         self.toolBar.addSeparator()
         self.actionComboBox_visible = self.toolBar.addWidget(self.actionComboBox)
         self.actionComboBox_visible.setVisible(False)
-        #self.toolBar.addSeparator()
+        # self.toolBar.addSeparator()
         spacerItem = QtWidgets.QWidget()
         spacerItem.setSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Preferred)
 
@@ -1285,10 +1223,7 @@ QToolButton{margin: 2px 2px;}
         self.toolBar2.addSeparator()
         self.toolBar2.addAction(self.actionColor)
         self.toolBar2.addWidget(self.pixmap_box_label)
-        #self.toolBar2.addSeparator()
-
-
-
+        # self.toolBar2.addSeparator()
 
         spacerItem = QtWidgets.QWidget()
         spacerItem.setSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Preferred)
@@ -1299,139 +1234,142 @@ QToolButton{margin: 2px 2px;}
 
         self.toolBar2.addAction(self.actionPoints)
         self.toolBar2.addSeparator()
+        self.toolBar2.addAction(self.actionZoomNeutral)
         self.toolBar2.addAction(self.actionZoomIn)
         self.toolBar2.addAction(self.actionZoomOut)
         self.toolBar2.addSeparator()
+        self.toolBar2.addAction(self.actionVerticalView)
+        self.toolBar2.addAction(self.actionHorizontalView)
         self.toolBar2.addAction(self.actionRuler)
         self.toolBar2.addAction(self.actionGoTo)
         self.toolBar2.addAction(self.action3D)
         self.toolBar2.setDisabled(True)
+        pixel_ratio = self.devicePixelRatio()
+        base_size = 36
+        dynamic_size = int(base_size * pixel_ratio)
+        self.toolBar2.setIconSize(QtCore.QSize(dynamic_size, dynamic_size))
+        self.toolBar.setIconSize(QtCore.QSize(dynamic_size, dynamic_size))
+        # Set fixed size policy
+        sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Fixed)
+        self.toolBar.setSizePolicy(sizePolicy)
+        self.toolBar2.setSizePolicy(sizePolicy)
+
+    def _connect_signals(self):
+        """Connects all signals to slots."""
+
+        # --- Action Connections ---
+        self.actionColor.triggered.connect(self.color_picker)
+        self.horizontalSlider_1.valueChanged.connect(self.changeSight1)
+        self.horizontalSlider_2.valueChanged.connect(self.changeSight2)
+        self.horizontalSlider_3.valueChanged.connect(self.changeSight3)
+        self.horizontalSlider_4.valueChanged.connect(self.changeSight4)
+        self.horizontalSlider_5.valueChanged.connect(self.changeSight5)
+        self.horizontalSlider_6.valueChanged.connect(self.changeSight6)
+        self.horizontalSlider_11.valueChanged.connect(self.changeSightTab3)
+        self.horizontalSlider_12.valueChanged.connect(self.changeSightTab4)
+        self.table_update.clicked.connect(self.linkMRIECO)
+        self.table_link.clicked.connect(self.linkBoth)
+
+        self.radioButton_1.clicked.connect(partial(self.changeToCoronal, 'eco'))
+        self.radioButton_2.clicked.connect(partial(self.changeToSagittal, 'eco'))
+        self.radioButton_3.clicked.connect(partial(self.changeToAxial, 'eco'))
+        self.radioButton_4.clicked.connect(self.showSegOnWindow)
 
+        self.radioButton_21_1.clicked.connect(partial(self.changeToCoronal, 'mri'))
+        self.radioButton_21_2.clicked.connect(partial(self.changeToSagittal, 'mri'))
+        self.radioButton_21_3.clicked.connect(partial(self.changeToAxial, 'mri'))
+        self.radioButton_21.clicked.connect(self.showSegOnWindow)
 
+        self.actionOpenUS.triggered.connect(self.browseUS)
+        self.actionOpenMRI.triggered.connect(self.browseMRI)
+        self.actionComboBox.currentTextChanged.connect(self.changeVolume)
+        self.actionOpenFA.triggered.connect(self.browseFA)
+        self.actionOpenTract.triggered.connect(self.browseTractoGraphy)
+        self.actionNew.triggered.connect(self.newProject)
+        self.actionCloseUS.triggered.connect(self.CloseUS)
+        self.actionCloseMRI.triggered.connect(self.CloseMRI)
+        self.actionImportSegMRI.triggered.connect(partial(self.importData, 'MRISEG'))
+        self.actionImportSegEco.triggered.connect(partial(self.importData, 'USSEG'))
+        self.actionExportImEco.triggered.connect(partial(self.exportData, 'USIM'))
+        self.actionExportSegEco.triggered.connect(partial(self.exportData, 'USSEG'))
+        self.actionExportImMRI.triggered.connect(partial(self.exportData, 'MRIIM'))
+        self.actionExportSegMRI.triggered.connect(partial(self.exportData, 'MRISEG'))
+        self.actionScreenS.triggered.connect(self.showScreenShotWindow)
+        self.actionLoad.triggered.connect(self.loadProject)
+        self.actionFile_info.triggered.connect(self.showInfoWindow)
+        self.actionUndo.triggered.connect(self.Undo)
+        self.actionRedo.triggered.connect(self.Redo)
+        self.actionFile_changeIM.triggered.connect(self.showIMVARSWindow)
+        self.actionfile_iminfo.triggered.connect(partial(self.maskingShow, 5))
+        self.actionconvert.triggered.connect(self.convert)
+        self.actionexit.triggered.connect(self.close)
+        self.actionsave.triggered.connect(self.save)
+        self.actionsaveas.triggered.connect(self.saveas)
+        self.actionabout.triggered.connect(self.about)
+        self.actionmanual.triggered.connect(self.manual)
         self.actionArrow.triggered.connect(partial(self.setCursors, 0))
         self.actionPan.triggered.connect(partial(self.setCursors, 2))
         self.actionPaint.triggered.connect(partial(self.setCursors, 1))
         self.actionErase.triggered.connect(partial(self.setCursors, 3))
-        self.actionRuler.triggered.connect(partial(self.setCursors,6))
+        self.actionRuler.triggered.connect(partial(self.setCursors, 6))
         self.actionLine.triggered.connect(partial(self.setCursors, 8))
         self.actionContour.triggered.connect(partial(self.setCursors, 4))
         self.actionPoints.triggered.connect(partial(self.setCursors, 5))
         self.actionCircles.triggered.connect(partial(self.setCursors, 9, None))
-        #self.actionGoTo.triggered.connect(partial(self.setCursors, 7))
+        # self.actionGoTo.triggered.connect(partial(self.setCursors, 7))
         self.actionGoTo.triggered.connect(self.activateGuidelines)
         self.action3D.triggered.connect(self.activate3d)
         self.actionZoomIn.triggered.connect(partial(self.Zoom, 'In'))
         self.actionZoomOut.triggered.connect(partial(self.Zoom, 'Out'))
+        self.actionZoomNeutral.triggered.connect(partial(self.Zoom, 'Neutral'))
+
         self.actionContourX.triggered.connect(self.showRpeatWindow)
         self.actionContourX.triggered.connect(partial(self.setCursorsX, 4))
         self.actionEraseX.triggered.connect(self.showRpeatWindow)
         self.actionEraseX.triggered.connect(partial(self.setCursorsX, 3))
-        #self.actionSegExportEco.triggered.connect(self.showScreenShotWindow)
-
-
-
-
-        self.retranslateUi(Main)
-        QtCore.QMetaObject.connectSlotsByName(Main)
-
-
-        #self.horizontalSlider.valueChanged.connect(self.openGLWidget.setXRotation)
-        #self.openGLWidget.xRotationChanged.connect(self.horizontalSlider.setValue)
-
-
-        ######################### Visibility ################################
-
+        # self.actionSegExportEco.triggered.connect(self.showScreenShotWindow)
         self.actionMain_Toolbar.triggered.connect(self.toolBar.setVisible)
         self.action_guideLines.triggered.connect(self.activateGuidelines)
         self.action_axisLines.triggered.connect(self.activateAxisLines)
         self.toolBar.visibilityChanged.connect(self.actionMain_Toolbar.setChecked)
-
-        #self.action_interaction_Toolbar.triggered.connect(self.toolBar2.setVisible)
-        #self.toolBar2.visibilityChanged.connect(self.action_interaction_Toolbar.setChecked)
-
-
-        ######################## OPENG GL CONTROL PANNEL ########################
-
-
         self.hs_t1_1.valueChanged.connect(self.changeBrightness)
         self.hs_t1_2.valueChanged.connect(self.changeContrast)
         self.hs_t1_3.valueChanged.connect(self.changeBandPass)
         self.hs_t1_4.valueChanged.connect(self.changeSobel)
         self.hs_t1_5.valueChanged.connect(self.Rotate)
         self.hs_t1_7.valueChanged.connect(self.changeBandPass)
-        #self.hs_t1_8.valueChanged.connect(self.changeColorize)
-        #self.colorize.clicked.connect(self.changeColorize)
         self.toggle1_1.clicked.connect(self.changeHamming)
-
-
         self.hs_t2_1.valueChanged.connect(self.changeBrightness)
         self.hs_t2_2.valueChanged.connect(self.changeContrast)
         self.hs_t2_3.valueChanged.connect(self.changeBandPass)
         self.hs_t2_7.valueChanged.connect(self.changeBandPass)
-        #self.hs_t2_8.valueChanged.connect(self.changeColorize)
-        #self.colorize_MRI.clicked.connect(self.changeColorize)
-
-
         self.hs_t2_4.valueChanged.connect(self.changeSobel)
         self.hs_t2_5.valueChanged.connect(self.Rotate)
         self.toggle2_1.clicked.connect(self.changeHamming)
-
         self.page1_s2c.clicked.connect(self.C2S)
         self.page2_s2c.clicked.connect(self.C2S)
-
-        #self.dw2_cb.currentTextChanged.connect(self.changeColorPen)
-
-        #self.dockWidgetContents_mri_colors.cha
         self.dw2_s2.valueChanged.connect(self.changeSizePen)
         self.dw2_s1.valueChanged.connect(lambda value: self.changeRadiusCircle(value, True))
 
-
-        self.dw4_s1.valueChanged.connect(self.vnetricleSegmentShow)
         self.scroll_intensity.valueChanged.connect(lambda thrsh: self.ColorIntensityChange(thrsh, 'seg'))
         self.scroll_image_intensity.valueChanged.connect(lambda thrsh: self.ColorIntensityChange(thrsh, 'image'))
-
-
-
         self.page1_rot_cor.currentTextChanged.connect(self.changeRotAx)
         self.page2_rot_cor.currentTextChanged.connect(self.changeRotAx)
-
         self.dw5_s1.valueChanged.connect(self.trackDistance)
         self.dw5_s2.valueChanged.connect(self.trackThickness)
 
 
-
-
-
-
-        #self.actionrotate.triggered.connect(self.horizontalSlider.setVisible)
-        #self.actionrotate.triggered.connect(self.label_horizontalSlider.setVisible)
-        self.actionNNventricleSegm.triggered.connect(self.segmentVentricles)
-        self.actionN4Bias.triggered.connect(partial(self.maskingShow, 3))
         self.actionHistImage.triggered.connect(partial(self.maskingShow, 4))
-        self.actionResizeImage.triggered.connect(partial(self.maskingShow, 8))
-        self.actionBET.triggered.connect(partial(self.maskingShow, 7))
-        self.actionBEDL.triggered.connect(partial(self.maskingShow, 9))#masking
-
-        self.actionTissueSeg.triggered.connect(partial(self.maskingShow, 10))  # FCM
- # FCM
 
 
+        # FCM
         self.actionImageThresholding.triggered.connect(partial(self.maskingShow, 6))
         self.actionImageRegistration.triggered.connect(partial(self.registerShow, 0))
         self.actionImageTransformation.triggered.connect(partial(self.registerShow, 1))
         self.actionMasking.triggered.connect(partial(self.maskingShow, 0))
         self.actionOperationMask.triggered.connect(partial(self.maskingShow, 1))
-        self.actionChangeCS.triggered.connect(partial(self.maskingShow, 2))
 
-        self.actionNNVentriclesCoronal.triggered.connect(partial(self.vnetricleSegmentShow, 50))
-        self.actionNNVentriclesAxial.triggered.connect(partial(self.vnetricleSegmentShow, 50))
-        self.actionNNVentriclesSagittal.triggered.connect(partial(self.vnetricleSegmentShow, 50))
 
-        self.actionTVCor.triggered.connect(partial(self.CalcTotalVolume, 'Coronal'))
-        self.actionTVSag.triggered.connect(partial(self.CalcTotalVolume, 'sagittal'))
-        self.actionTVAx.triggered.connect(partial(self.CalcTotalVolume, 'Axial'))
-
-        self.actionNNventricleGatherIm.triggered.connect(self.gatherToIm)
         name = 'openGLWidget_'
         for i in range(12):
 
@@ -1439,8 +1377,9 @@ QToolButton{margin: 2px 2px;}
             if hasattr(self, nameWidget):
                 widget = getattr(self, name + str(i + 1))
                 widget.segChanged.connect(
-                    lambda whiteInd, currentWidnowName, colorInd, sliceNum: self.updateSegmentation(whiteInd, currentWidnowName,
-                                                                                          colorInd, sliceNum))
+                    lambda whiteInd, currentWidnowName, colorInd, sliceNum: self.updateSegmentation(whiteInd,
+                                                                                                    currentWidnowName,
+                                                                                                    colorInd, sliceNum))
 
                 widget.LineChanged.connect(
                     lambda params: self.updateLP(params))
@@ -1467,84 +1406,114 @@ QToolButton{margin: 2px 2px;}
         )
 
         self.openGLWidget_14.point3dpos.connect(
-            lambda pose3d, windowName : self.updateLabelPs(pose3d, windowName, 'eco')
+            lambda pose3d, windowName: self.updateLabelPs(pose3d, windowName, 'eco')
         )
         self.openGLWidget_24.point3dpos.connect(
-            lambda pose3d, windowName : self.updateLabelPs(pose3d, windowName, 'mri')
+            lambda pose3d, windowName: self.updateLabelPs(pose3d, windowName, 'mri')
+        )
+
+        self.openGLWidget_14.update_3dview.connect(
+            lambda map_type, reset: self.update3Dview(map_type, None, 'eco')
+        )
+        self.openGLWidget_24.update_3dview.connect(
+            lambda map_type, reset: self.update3Dview(map_type, None, 'mri')
+        )
+
+        self.openGLWidget_14.update_cmap.connect(
+            lambda map_type, reset: self.update3Dview(map_type, reset, 'eco')
+        )
+        self.openGLWidget_24.update_cmap.connect(
+            lambda map_type, reset: self.update3Dview(map_type, reset, 'mri')
         )
 
+        self.tabWidget.currentChanged.connect(self.changedTab)
+        self.openGLWidget_11.resized.connect(self.changedTab)
+        self.openGLWidget_12.resized.connect(self.changedTab)
+
+
+
+    def _set_initial_state(self):
+        """Sets the initial visibility and enabled state of widgets."""
+
+        # Actions
+        self.actionOpenUS.setDisabled(True)
+        self.actionOpenMRI.setDisabled(True)
+        self.actionComboBox.setDisabled(True)
+        self.actionOpenFA.setDisabled(True)
+        self.actionOpenTract.setDisabled(True)
+        self.actionImportSegMRI.setDisabled(True)
+        self.actionImportSegEco.setDisabled(True)
+        self.actionExportImMRI.setDisabled(True)
+        self.actionExportSegMRI.setDisabled(True)
+        self.actionExportImEco.setDisabled(True)
+        self.actionExportSegEco.setDisabled(True)
+        self.actionsave.setDisabled(True)
+        self.actionsaveas.setDisabled(True)
+
+        # Toolbars
+        self.toolBar2.setDisabled(True)
+        self.actionComboBox_visible.setVisible(False)
+        self.actionComboBox.setVisible(False)  # Also hide the widget itself
+
+        # Sliders
+        self.horizontalSlider_1.setVisible(False)
+        self.horizontalSlider_2.setVisible(False)
+        self.horizontalSlider_3.setVisible(False)
+        self.horizontalSlider_4.setVisible(False)
+        self.horizontalSlider_5.setVisible(False)
+        self.horizontalSlider_6.setVisible(False)
+        self.horizontalSlider_7.setVisible(False)
+        self.horizontalSlider_8.setVisible(False)
+        self.horizontalSlider_9.setVisible(False)
+        self.horizontalSlider_10.setVisible(False)
+        self.horizontalSlider_11.setVisible(False)
+        self.horizontalSlider_12.setVisible(False)
+
+        # Radio Buttons
+        self.radioButton_1.setVisible(False)
+        self.radioButton_2.setVisible(False)
+        self.radioButton_3.setVisible(False)
+        self.radioButton_4.setVisible(False)
+        self.radioButton_21_1.setVisible(False)
+        self.radioButton_21_2.setVisible(False)
+        self.radioButton_21_3.setVisible(False)
+        self.radioButton_21.setVisible(False)
+
 
-        self.openGLWidget_14.update_3dview.connect(
-            lambda map_type, reset : self.update3Dview(map_type, None, 'eco')
-        )
-        self.openGLWidget_24.update_3dview.connect(
-            lambda map_type, reset : self.update3Dview(map_type, None, 'mri')
-        )
 
+    def setupUi(self, Main):
+        """
 
-        self.openGLWidget_14.update_cmap.connect(
-            lambda map_type, reset : self.update3Dview(map_type, reset, 'eco')
-        )
-        self.openGLWidget_24.update_cmap.connect(
-            lambda map_type, reset : self.update3Dview(map_type, reset, 'mri')
-        )
+        :param Main:
+        :return:
+        """
+        self._setup_main_window(Main)
+        self._setup_central_layout(Main)
 
+        self._create_actions(Main)
 
+        self._setup_menus(Main)
+        self.load_plugins()
+        self._setup_other_widgets(Main)
 
-        self.tabWidget.currentChanged.connect(self.changedTab)
-        self.openGLWidget_11.resized.connect(self.changedTab)
-        self.openGLWidget_12.resized.connect(self.changedTab)
+        self._setup_toolbars(Main)
+
+        # Group all signal/slot connections together
+        self._connect_signals()
+
+        # Group all .setVisible(False), .setDisabled(True), etc.
+        self._set_initial_state()
+        self.retranslateUi(Main)
+        QtCore.QMetaObject.connectSlotsByName(Main)
 
         self.setFocusPolicy(Qt.StrongFocus)
         self.installEventFilter(self)
         self.init_state()
         self.create_cursors()
 
-        sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Fixed)
-        self.toolBar2.setSizePolicy(sizePolicy)
-        sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Fixed)
-        self.toolBar.setSizePolicy(sizePolicy)
-
         self.Main = Main
 
 
-    def updateDataBEDL(self, index):
-        """
-        Brain Extraction widget
-        :return:
-        """
-        if index ==0:
-            el = self.BE_DL
-        elif index == 1:
-            el = self.Tissue_Seg
-        ind_image = el.comboBox_image.currentIndex()
-        from melage.utils.utils import make_image_using_affine
-        if ind_image==0:
-            if not hasattr(self, 'readImECO'):
-                return
-            if not hasattr(self.readImECO, 'im'):
-                return
-            affine, header = None, None
-            if hasattr(self.readImECO, 'affine'):
-                affine = self.readImECO.affine
-            if hasattr(self.readImECO, 'header'):
-                header = self.readImECO.header
-            img = make_image_using_affine(self.readImECO.npImage, affine, header)
-            el.setData(img, self.readImECO.ImSpacing)
-        elif ind_image==1:
-            if not hasattr(self, 'readImMRI'):
-                return
-            if not hasattr(self.readImMRI, 'im'):
-                return
-            affine, header = None, None
-            if hasattr(self.readImMRI, 'affine'):
-                affine = self.readImMRI.affine
-            if hasattr(self.readImMRI, 'header'):
-                header = self.readImMRI.header
-            img = make_image_using_affine(self.readImMRI.npImage, affine, header)
-            el.setData(img, self.readImMRI.ImSpacing)
-
-
     def updateDataRegistration(self):
         """
         Image to Image registration window
@@ -1567,86 +1536,13 @@ QToolButton{margin: 2px 2px;}
             val.setData(self.readImMRI.im)
 
 
-    def updateDataBET(self):
-        """
-        Updating Brain Extraction Tools
-        :return:
-        """
-        ind_image = self.BET.comboBox_image.currentIndex()
-        if ind_image==0:
-            if not hasattr(self, 'readImECO'):
-                return
-            if not hasattr(self.readImECO, 'im'):
-                return
-            self.BET.setData(self.readImECO.npImage, self.readImECO.ImSpacing)
-        elif ind_image==1:
-            if not hasattr(self, 'readImMRI'):
-                return
-            if not hasattr(self.readImMRI, 'im'):
-                return
-
-            self.BET.setData(self.readImMRI.npImage, self.readImMRI.ImSpacing)
-
-    def resize_image(self, ind_image, ind=None):
-        """
-        Image resize
-        :param ind_image:
-        :param ind:
-        :return:
-        """
-        hasattr(self.readImMRI, 'im')
-        if ind is not None:
-            if ind == 0 and hasattr(self.readImECO, 'im'):
-                spacing = self.readImECO.ImSpacing
-                txt = '{:.3f},{:.3f},{:.3f}'.format(spacing[0], spacing[1], spacing[2])
-                self.resizeImage.label_current_spc.setText(txt)
-            elif ind == 1 and hasattr(self.readImMRI, 'im'):
-                spacing = self.readImMRI.ImSpacing
-                txt = '{:.3f},{:.3f},{:.3f}'.format(spacing[0], spacing[1], spacing[2])
-                self.resizeImage.label_current_spc.setText(txt)
-            else:
-                txt = '{:.3f},{:.3f},{:.3f}'.format(0, 0, 0)
-                self.resizeImage.label_current_spc.setText(txt)
-            return
-        from melage.utils.utils import resample_to_spacing, convert_to_ras
-        spacing = self.resizeImage.label_new_spc.value()
-        isLinear = self.resizeImage.radioButton_1.isChecked()
-        method = 'spline'
-        if isLinear:
-            method='linear'
-
-        if ind_image==0:
-            if not hasattr(self, 'readImECO'):
-                return
-            if not hasattr(self.readImECO, 'im'):
-                return
-            self.readImECO.im = resample_to_spacing(self.readImECO.im, spacing, method)
-            transform, self.readImECO.source_system = convert_to_ras(self.readImECO.im.affine, target=self.readImECO.target_system)
-            self.readImECO.im = self.readImECO.im.as_reoriented(transform)
-            self.readImECO.set_metadata()
-            self.readImECO.read_pars(reset_seg=True)
-            self.browseUS(fileObj=None, use_dialog=False)
-            self.changedTab()
-        elif ind_image==1:
-            if not hasattr(self, 'readImMRI'):
-                return
-            if not hasattr(self.readImMRI, 'im'):
-                return
-            self.readImMRI.im = resample_to_spacing(self.readImMRI.im, spacing, method)
-            transform, self.readImMRI.source_system = convert_to_ras(self.readImMRI.im.affine, target=self.readImMRI.target_system)
-            self.readImMRI.im = self.readImMRI.im.as_reoriented(transform)
-            self.readImMRI.set_metadata()
-            self.readImMRI.read_pars(reset_seg=True)
-            self.browseMRI(fileObj=None, use_dialog=False)
-            self.changedTab()
-
-
     def applyMaskToImage(self, values, operation=False):
         """
         Apply masks to image
         :param values:
         :return:
         """
+        self.setEnabled(True)
         if len(values)==3:
             ind_image, ind_sel, keep = values
             ind_color = int(float(self.color_name[ind_sel].split('_')[0]))
@@ -1716,24 +1612,6 @@ QToolButton{margin: 2px 2px;}
                 self.browseMRI(fileObj=None, use_dialog=False)
             self.changedTab()
 
-    def setCurrentCoordsystem(self):
-        """
-        Current Coordinate System
-        :return:
-        """
-        from melage.utils.utils import getCurrentCoordSystem
-        current = 'None'
-        if self.ChCoordSys.comboBox_image.currentIndex()==0:
-            try:
-                current = getCurrentCoordSystem(self.readImECO.im.affine)
-            except:
-                pass
-        elif self.ChCoordSys.comboBox_image.currentIndex()==1:
-            try:
-                current = getCurrentCoordSystem(self.readImMRI.im.affine)
-            except:
-                pass
-        self.ChCoordSys.label_current.setText(current)
 
     def applyNewCoordSys(self, values):
         """
@@ -1750,7 +1628,7 @@ QToolButton{margin: 2px 2px;}
 
             status = self.readImECO._changeCoordSystem(targ_system)
             if status:
-                self.setCurrentCoordsystem()
+
                 self.readImECO.source_system = targ_system
                 self.browseUS(fileObj=None, use_dialog=False)
                 self.changedTab()
@@ -1761,7 +1639,7 @@ QToolButton{margin: 2px 2px;}
                 return
             status = self.readImMRI._changeCoordSystem(targ_system)
             if status:
-                self.setCurrentCoordsystem()
+
                 self.browseMRI(fileObj=None, use_dialog=False)
                 self.changedTab()
 
@@ -1771,17 +1649,6 @@ QToolButton{margin: 2px 2px;}
         :param val:
         :return:
         """
-        if val==4:
-            self.BET.clear()
-        elif val==5:
-            self.BE_DL.clear()
-            for ind in range(2):
-                save_var = '_immri_bedl_{}'.format(ind)
-                save_var_seg = '_immri_bedl_seg_{}'.format(ind)
-                setattr(self, save_var, None)
-                setattr(self, save_var_seg, None)
-        elif val==10:
-            self.Tissue_Seg.clear()
         self.setEnabled(True)
 
 
@@ -1835,15 +1702,10 @@ QToolButton{margin: 2px 2px;}
         at_eco = hasattr(self, 'readImECO')
         at_mri = hasattr(self, 'readImMRI')
 
-        if val=='BET' or val=='Deep BET' or val=='histeq' or val=='Segmentation':
-            if val=='BET':
-                alg = self.BET
-            elif val == 'histeq':
+        if val in ('BET', 'Deep BET', 'histeq', 'Segmentation', 'MorphSeg'):
+
+            if val == 'histeq':
                 alg = self.ImageThresholding
-            elif val=='Deep BET':
-                alg = self.BE_DL
-            elif val=='Segmentation':
-                alg = self.Tissue_Seg
             ind = alg.comboBox_image.currentIndex()
             if ind == 0 and at_eco:
                 if hasattr(self.readImECO, 'npImage'):
@@ -1854,17 +1716,17 @@ QToolButton{margin: 2px 2px;}
                         if alg.im_rec is not None:
                             if not hasattr(alg.im_rec, 'get_fdata'):
                                 from melage.utils.utils import make_image
-                                alg.im_rec = make_image(alg.im_rec, reader.im)
+                                alg.im_rec = make_image(alg.im_rec.transpose(2, 1, 0)[::-1, ::-1, ::-1], reader.im)
                             self.reconstruction(reconstruct, ind, reader, alg)
                             if val == 'histeq' and not reconstruct:
                                 alg.plot(self.readImECO.npImage)
                     if self.readImECO.npImage is not None:
                         self.updateDispEco(self.readImECO.npImage, self.readImECO.npSeg, initialState=True)
-                    #self.BET.clear()
+
             elif ind == 1 and at_mri:
                 if hasattr(self.readImMRI, 'npImage'):
                     if val != 'histeq':
-                        self.readImMRI.npSeg = alg.mask
+                        self.readImMRI.npSeg = alg.mask.transpose(2, 1, 0)[::-1, ::-1, ::-1]
                     if hasattr(alg,'im_rec'):
                         reader = self.readImMRI
                         if alg.im_rec is not None:
@@ -1876,7 +1738,7 @@ QToolButton{margin: 2px 2px;}
                                 alg.plot(self.readImMRI.npImage)
                     if self.readImMRI.npImage is not None:
                         self.updateDispMRI(self.readImMRI.npImage, self.readImMRI.npSeg, initialState=True)
-                    #self.BET.clear()
+
             return
 
         ind = self.ImageThresholding.comboBox_image.currentIndex()
@@ -1919,10 +1781,11 @@ QToolButton{margin: 2px 2px;}
         :param val: the parameter that defines type of operation (transformation or registration)
         :return:
         """
-        self.setEnabled(False)
+        #self.setEnabled(False)
 
         if val == 0:
             el = self.registrationD
+            el.set_source(settings.DEFAULT_USE_DIR)
             at_eco = hasattr(self, 'readImECO')
             at_mri = hasattr(self, 'readImMRI')
             if at_eco and at_mri:
@@ -1932,7 +1795,8 @@ QToolButton{margin: 2px 2px;}
                     el.comboBox_image.setCurrentIndex(1)
         elif val == 1:
             el = self.transformationD
-        el.setEnabled(True)
+            el.set_source(settings.DEFAULT_USE_DIR)
+        #el.setEnabled(True)
         el.show()
 
     def maskingShow(self, val=1):
@@ -1946,10 +1810,7 @@ QToolButton{margin: 2px 2px;}
             el = self.Masking
         elif val == 1:
             el = self.MaskingOperations
-        elif val == 2:
-            el = self.ChCoordSys
-        elif val==3:
-            el = self.N4_dialog
+
         elif val == 4:
             el = self.HistImage
         elif val == 5:
@@ -1963,17 +1824,6 @@ QToolButton{margin: 2px 2px;}
 
         elif val == 6:
             el = self.ImageThresholding
-        elif val == 7:
-            el = self.BET
-        elif val == 8:
-            el = self.resizeImage
-            el.label_warning.setText('Image Resizing (isotropic)?')
-        elif val == 9:
-            el = self.BE_DL
-            self.setEnabled(True)
-        elif val==10:
-            el = self.Tissue_Seg
-            self.setEnabled(True)
         try:
             at_eco = hasattr(self, 'readImECO')
             at_mri = hasattr(self, 'readImMRI')
@@ -1983,11 +1833,7 @@ QToolButton{margin: 2px 2px;}
                     el.comboBox_image.setCurrentIndex(1)
                     if hasattr(el, 'comboBox_image_type'):
                         el.comboBox_image_type.setCurrentIndex(1)
-                    if val == 7:
-                        self.BET.setData(self.readImMRI.npImage, self.readImMRI.ImSpacing)
-                        self.BE_DL.comboBox_image.setCurrentIndex(1)
-                        self.updateDataBEDL(index=0)
-                    elif val in [9, 10]:
+                    elif val in [9, 10, 11]:
                         from melage.utils.utils import make_image_using_affine
                         affine = getattr(self.readImMRI, 'affine', None)
                         header = getattr(self.readImMRI, 'header', None)
@@ -1996,9 +1842,7 @@ QToolButton{margin: 2px 2px;}
                         el.comboBox_image.setCurrentIndex(1)
 
                 elif at_eco and hasattr(self.readImECO, 'npImage'):
-                    if val == 7:
-                        self.BET.setData(self.readImECO.npImage, self.readImECO.ImSpacing)
-                    elif val in [9, 10]:
+                    if val in [9, 10, 11]:
                         from melage.utils.utils import make_image_using_affine
                         affine = getattr(self.readImECO, 'affine', None)
                         header = getattr(self.readImECO, 'header', None)
@@ -2028,9 +1872,8 @@ QToolButton{margin: 2px 2px;}
                 self.resize_image(None, ind)
 
             if val in [0, 1]:
-                el.setComboBoxColors(self.color_name)
-            elif val == 2:
-                self.setCurrentCoordsystem()
+                el.set_color_options(self.color_name)
+
 
 
             el.setEnabled(True)
@@ -2119,51 +1962,6 @@ QToolButton{margin: 2px 2px;}
 
 
 
-    def CalcTotalVolume(self, segwnd='sagital'):
-        """
-        Calculate region volume
-        :param segwnd:
-        :return:
-        """
-        from melage.utils.utils import compute_vol_seg
-
-        widgets = select_proper_widgets(self)
-        sender = QtCore.QObject.sender(self)
-        try:
-            #sender_ind = widgets.index(sender)
-            if rhasattr(self, 'readImECO.npSeg'):
-                sender_ind = 1
-            elif rhasattr(self, 'readImMRI.npSeg'):
-                sender_ind = 5
-
-            reader = self.readImECO if sender_ind < 3 else self.readImMRI
-            self.dockWidget_3.setVisible(True)
-            self.setEnabled(False)
-            self.progressBarSaving.setValue(20)
-            selected_points_total = compute_vol_seg(reader.npSeg, segwnd)
-            if sender_ind < 3:
-                self.updateSegmentation(selected_points_total, 'ECO_'+segwnd, self.openGLWidget_1.colorInd, self.openGLWidget_1.sliceNum)
-            else:
-                self.updateSegmentation(selected_points_total, 'MRI_'+segwnd, self.openGLWidget_3.colorInd, self.openGLWidget_3.sliceNum)
-            self.progressBarSaving.setValue(80)
-            selected_points_total = []
-            #if sender_ind < 3 and sender_ind != 11:
-            #    self.openedFileName.setText(
-             #   'File: {}, TV: {}'.format(self.filenameEco,
-             #                             Seg_new.sum() * self.readImECO.ImSpacing[0]**3))
-            #else:
-            #    self.openedFileName.setText(
-            #    'File: {}, TV: {}'.format(self.filenameMRI,
-            #                              Seg_new.sum() * self.readImMRI.ImSpacing[0]**3))
-            self.progressBarSaving.setValue(100)
-            self.setEnabled(True)
-            self.dockWidget_3.setVisible(False)
-        except Exception as e:
-            print('Calculate Total Volume')
-            print(e)
-
-
-
 
     def activateAxisLines(self, val):
         """
@@ -2206,6 +2004,12 @@ QToolButton{margin: 2px 2px;}
                     widget.scaleF = widget.ZOOM_IN_FACTOR
                     if 0.0 < widget.zoom_level_y * widget.scaleF < 5 or 0.0 < widget.zoom_level_x * widget.scaleF < 5:
                         widget.updateScale(0, 0, widget.scaleF, widget.scaleF)
+        else:
+            for widget in widgets:
+                if widget.isVisible():
+                    widget.scaleF = widget.ZOOM_IN_FACTOR
+                    widget.UpdatePaintInfo()
+                    widget.updateScale(0, 0, 1, 1)
     def activate3d(self, val):
         """
         Activate 3D show
@@ -2443,7 +2247,154 @@ QToolButton{margin: 2px 2px;}
         else:
             self.table_link.setChecked(False)
 
+    def load_plugins(self):
+        """
+        Finds and loads all plugins and builds the 'Plugins' menu.
+        """
+        print("Loading plugins...")
+
+        plugin_dir = settings.PLUGIN_DIR
+
+        self.plugin_manager = PluginManager(plugin_dir)
+        self.plugin_manager.discover_plugins()
+
+
+        categories = {}
+        for plugin in self.plugin_manager.get_plugins():
+            if plugin.category not in categories:
+                categories[plugin.category] = []
+            categories[plugin.category].append(plugin)
+
+        for category_name, plugins_in_category in sorted(categories.items()):
+            # Create a sub-menu for the category
+            category_menu = self.menuPlugins.addMenu(category_name)
+            for plugin in plugins_in_category:
+                self.add_plugin_action(category_menu, plugin)
+
+        print(f"Finished loading {len(self.plugin_manager.get_plugins())} plugins.")
+
+    def add_plugin_action(self, menu: QtWidgets.QMenu, plugin):
+        """Helper to create a QAction for a plugin."""
+        action = QtWidgets.QAction(plugin.name, self)
+        action.setToolTip(plugin.description)
+
+        # --- This is the trigger ---
+        # Connect the menu action to our "brain" function
+        action.triggered.connect(lambda: self.launch_plugin(plugin))
+        menu.addAction(action)
+
+    def launch_plugin(self, plugin):
+        """
+        Called when a plugin's menu item is clicked.
+        This "brain" function decides how to launch the plugin.
+        """
+        print(f"Launching plugin: {plugin.name}")
+        try:
+            # --- 1. Give the plugin the current data ---
+            # (You must implement get_current_image_data)
+            data_context = self.get_current_image_data()
+            #data_context = plugin.update_data_context(current_data)
+
+            # --- 2. Path A: CUSTOM UI (like MorphSeg) ---
+            # Check if the plugin has a get_widget() method
+            widget = plugin.get_widget(data_context, parent=self)
+
+            if widget:
+                print("Plugin is 'Custom UI'. Showing widget.")
+                self.plugin_widgets.append(widget)
+                widget.show()
+                #if hasattr(widget, 'finished'):
+                    #widget.finished.connect(lambda: self.plugin_widgets.remove(widget))
+                widget.destroyed.connect(
+                    lambda: self.plugin_widgets.remove(widget) if widget in self.plugin_widgets else None)
+                # Connect the widget's 'completed' signal
+                if hasattr(widget, 'completed'):
+                    widget.completed.connect(self.on_plugin_complete)
+                return
+
+            # --- 3. Path B: AUTO-GUI (Simple Plugin) ---
+            # Plugin has no custom widget, so we build one.
+            param_spec = plugin.get_parameters()
+
+            if param_spec is None:
+                raise ValueError("Plugin provides no get_widget() or get_parameters()")
+
+            print("Plugin is 'Simple UI'. Generating AutoGuiDialog.")
+
+            # ****** HERE IT IS!  ******
+            # This is where the AutoGuiDialog is created and used
+            dialog = AutoGuiDialog(param_spec, self)
+
+            # --- 4. Show the dialog and get results ---
+            if dialog.exec_():
+                # User clicked OK!
+                user_parameters = dialog.get_values()
+
+                print(f"Executing plugin with params: {user_parameters}")
+                # TODO: This is where you should use a QThread
+                # to run the plugin's `execute` method
+                # without freezing the main window.
+
+                # (Simple, non-threaded way for now)
+                results = plugin.execute(user_parameters)
+
+                # --- 5. Handle the plugin's results ---
+                self.on_plugin_complete(results)
+
+        except Exception as e:
+            print(f"Error launching plugin {plugin.name}: {e}")
+            QtWidgets.QMessageBox.critical(self, "Plugin Error", f"Error launching {plugin.name}:\n{e}")
+
+    # --- DATA & RESULTS HANDLING (You must implement these) ---
+
+    def get_current_image_data(self):
+        """
+        (Placeholder) You must implement this.
+        This should return your main data object (e.g., the Nifti image).
+        """
+        result = {"view 1":None, "view 2":None}
+        if hasattr(self.readImECO, 'im'):
+            result["view 1"] = self.readImECO.im
+        if hasattr(self.readImMRI, 'im'):
+            result["view 2"] = self.readImMRI.im
+        return result
+
+    def on_plugin_complete(self, results: dict):
+        """
+        (Placeholder) This is called when a plugin finishes.
+        """
+        print(f"Plugin finished. Results: {results.keys()}")
+        out_image = results.get('image', None)
+        out_affine = results.get('affine', None)
+        out_seg = results.get('label', None)
+        view = results.get('view', None)
+        if view == "view 1":
+            reader = self.readImECO
+            updater = self.updateDispEco
+        elif view == 'view 2':
+            reader = self.readImMRI
+            updater = self.updateDispMRI
+        else:
+            return
+        npSeg = reader.npSeg
+        img = reader.im
+        if out_seg is not None:
+            npSeg = out_seg.transpose(2, 1, 0)[::-1, ::-1, ::-1] # adjustment for show
+
+        if out_image is not None:
+            from melage.utils.utils import make_image, make_image_using_affine
+            if out_affine is None:
+                img = make_image(out_image, reader.im)
+            else:
+                img = make_image_using_affine(out_image, out_affine, None)
+            #reader.im = img
+            #reader.npImage = out_image.transpose(2, 1, 0)[::-1, ::-1, ::-1]
+
+        reader.read_pars(im_new=img, seg_new = npSeg, reset_seg=False)
 
+        if reader.npImage is not None:
+            updater(reader.npImage, reader.npSeg, initialState=True)
+        #self.changedTab()
 
 
     def updateSliceNumber(self, val):
@@ -2697,6 +2648,24 @@ QToolButton{margin: 2px 2px;}
             elif val == 3:
                 self.actionEraseX.setIcon(self._icon_eraseX)
 
+    def setView(self, selected_view):
+        selected_view = selected_view.lower()
+
+        if not hasattr(self, 'current_view'):
+            self.current_view = 'horizontal'  # initialize on first call
+
+        if selected_view == self.current_view:
+            # View is already set, do nothing
+            return
+
+        # Update the view
+        if selected_view == 'horizontal':
+            self.create_horizontal_mutualview()
+        elif selected_view == 'vertical':
+            self.create_vertical_mutualview()
+
+        self.current_view = selected_view  # store the current view
+
     def setCursorsX(self, val):
         """
         Selecting correct cursor with repetition
@@ -2714,7 +2683,7 @@ QToolButton{margin: 2px 2px;}
             #self.table_widget.clear()
 
         #icon = QtGui.QIcon()
-        #icon.addPixmap(QtGui.QPixmap(source_folder+"/contourX.png"), QtGui.QIcon.Selected, QtGui.QIcon.On)
+        #icon.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR+"/contourX.png"), QtGui.QIcon.Selected, QtGui.QIcon.On)
         if abs(self._Xtimes) >1:
             self._setFadedPix(val)
 
@@ -2952,7 +2921,7 @@ QToolButton{margin: 2px 2px;}
                             self._lastChangedWidgest = widgets
                             self._lastReader = readerName
                             #self._lastReaderSegInd, self._lastReaderSegCol = getNoneZeroSeg(reader.npSeg)
-                            print(a)
+                            print(a) # neverused
                             self._lastReaderSegInd.append(whiteIn)
                             self._lastReaderSegCol.append(colorInd)
                             self._lastReaderSegPrevCol.append(widgets[0].colorInd)
@@ -3286,19 +3255,6 @@ QToolButton{margin: 2px 2px;}
 
 
 
-    def gatherToIm(self):
-        """
-        For ventricle segmentation
-        :return:
-        """
-        from melage.utils.utils import findWhiteVoxels
-        if not hasattr(self, 'seg'):
-            return
-        totalPs = self.openGLWidget_11.totalPs[self.segmentShowWindowName]
-        Nseg = findWhiteVoxels(totalPs, self.segmentShowWindowName, self._segNN)
-        setattr(self, 'seg_'+self.segmentShowWindowName, Nseg)
-
-
     def changeRotAx(self, val):
         """
         rotating image
@@ -3393,53 +3349,6 @@ QToolButton{margin: 2px 2px;}
             self.updateDispMRI(self.readImMRI.npImage, self.readImMRI.npSeg, initialState=True, tract=self.readImMRI.tract)
 
 
-    def segmentVentricles(self):
-        """
-        Segmentation of ventricles
-        :return:
-        """
-        try:
-            from Ventriculos.options.options import options as netOpts
-            from Ventriculos.test import test as netEval
-        except:
-            print('We can not segment image. Please check pytorch installation')
-            pass
-
-        if hasattr(self, 'readImECO'):
-            if hasattr(self.readImECO,'npImage'):
-                print('be patient...')
-                opts = netOpts().parse()
-                opts.chkptDir = '../Ventriculos/'+opts.chkptDir
-                opts.modelName = 'Net2D'
-                opts.state = 'train'
-                opts.dataDir = 'dataset'
-                opts.dataset = 'twoD'
-                opts.GPUs = '0'
-                opts.batchSize = 64
-                opts.shuffle = False
-                opts.useAugment = False
-                opts.dir3d = 'Ventriculos/Seg/TestIsa'
-                opts.modelNetG = 'unet2d'
-                opts.numThreads = 8
-                im = self.readImECO.npImage
-                im = im.transpose([0, 2, 1])
-
-                self.dockWidget_3.setVisible(True)
-                self.setEnabled(False)
-                self.progressBarSaving.setValue(20)
-
-                self._segNN = netEval(im, opts).transpose([0, 2, 1])
-                self.progressBarSaving.setValue(80)
-
-
-                self.vnetricleSegmentShow(thrsh=50)
-
-                self.progressBarSaving.setValue(100)
-
-                self.setEnabled(True)
-                self.dockWidget_3.setVisible(False)
-                self.progressBarSaving.setValue(0)
-        pass
 
     def ColorIntensityChange(self, thrsh = 0, dtype='image'):
         """
@@ -3555,31 +3464,6 @@ QToolButton{margin: 2px 2px;}
                 widget.update()
                 widget.show()
 
-
-
-    def vnetricleSegmentShow(self, thrsh = 50):
-        """
-        Show segmentation widget
-        :param thrsh:
-        :return:
-        """
-        if not hasattr(self, '_segNN'):
-            self.dw4_s1.setValue(50)
-            self.dw4lb1.setText('50')
-            #MessageBox = QtWidgets.QMessageBox(self)
-            #MessageBox.setText('Please segment image before using this command')
-            #MessageBox.show()
-            return
-        thrsh /= 100
-        seg = self._segNN/255.0
-        seg[seg>thrsh]=1
-        seg[seg<=thrsh]=0
-        self.openGLWidget_14.clear()
-        self.readImECO.npSeg = seg
-        self.updateDispEco(self.readImECO.npImage, self.readImECO.npSeg, initialState=True)
-
-
-
     def changeMagicToolTo222l(self, value):
         widgets = find_avail_widgets(self)
         for k in widgets:
@@ -3671,6 +3555,46 @@ QToolButton{margin: 2px 2px;}
         self.openGLWidget_12._tol_cricle_tool = val_tol
         self.openGLWidget_12.update()
 
+
+
+    @QtCore.pyqtSlot(QtCore.QModelIndex)
+    def on_row_clicked_image(self, proxy_index):
+        """
+        Handles all logic in response to a user click by toggling the
+        check state of the item in the first column of the clicked row.
+        """
+        # 1. Get the proxy index for the first column in the clicked row.
+        check_proxy_index = proxy_index.sibling(proxy_index.row(), 0)
+
+        # 2. Map this proxy index back to the original source model index.
+        source_index = self.tree_images.model().mapToSource(check_proxy_index)
+
+        # 3. Get the actual QStandardItem from the source model.
+        item = self.tree_images.model().sourceModel().itemFromIndex(source_index)
+
+        # 4. If the item doesn't exist or isn't checkable, do nothing.
+        if not item or not item.isCheckable():
+            return
+
+        # 5. Determine the new state and TOGGLE THE CHECKBOX EXACTLY ONCE.
+        new_state = QtCore.Qt.Unchecked if item.checkState() == QtCore.Qt.Checked else QtCore.Qt.Checked
+        old_state = item.checkState()
+
+
+        # 6. Manually update the styling for all rows.
+
+        cond = self.changeImage(item)
+        try:
+            if cond:
+                item.setCheckState(new_state)
+            else:
+                item.setCheckState(old_state)
+            self.style_all_rows(self.tree_images)
+        except:
+            pass
+
+
+
     def changeImage(self, value):
         """
         Change Image
@@ -3683,7 +3607,7 @@ QToolButton{margin: 2px 2px;}
         [info, _, _, indc] = self.imported_images[index_row]#
         index_view = info[0][2]
         try:
-            if value.checkState()==Qt.Checked:
+            if value.checkState()==Qt.Unchecked:
                 if info[1]<3:#image loading
                     #if info[1]<2: #eco loading
                     if index_view==0:
@@ -3692,14 +3616,14 @@ QToolButton{margin: 2px 2px;}
                             self.imported_images[index_row][2] = True
                             clean_parent_image(self, index_row, [indc, indc+'_Seg'], index_view=index_view)
                         else:
-                            value.setCheckState(Qt.Unchecked)
+                            return cond
                     else:
                         cond = self.browseMRI(info, use_dialog=False)
                         if cond:
                             self.imported_images[index_row][2] = True
                             clean_parent_image(self, index_row, [indc, indc+'_Seg'], index_view=index_view)
                         else:
-                            value.setCheckState(Qt.Unchecked)
+                            return cond
                 else: #segmentation loading
                     #if info[1]<5: #eco loading
                     if index_view == 0:
@@ -3708,14 +3632,14 @@ QToolButton{margin: 2px 2px;}
                             self.imported_images[index_row][2] = True
                             clean_parent_image(self, index_row, [indc], index_view=index_view)
                         else:
-                            value.setCheckState(Qt.Unchecked)
+                            return cond
                     else:
                         cond = self.importData(type_image='mriseg', fileObj=info[0])
                         if cond:
                             self.imported_images[index_row][2] = True
                             clean_parent_image(self, index_row, [indc],index_view=index_view)
                         else:
-                            value.setCheckState(Qt.Unchecked)
+                            return cond
 
             else: #close image
                 if info[1]<3:#image loading
@@ -3723,7 +3647,7 @@ QToolButton{margin: 2px 2px;}
                     if index_view == 0:
                         cond = self.CloseUS(message_box='on')
                         if cond:
-                            if 'US' in info[0][1]:
+                            if '*View 1 (loaded)' in info[0][1]:
                                 self.imported_images.pop(index_row)
                                 parent = self.tree_images.model().sourceModel().invisibleRootItem()
                                 parent.removeRow(index_row)
@@ -3731,11 +3655,11 @@ QToolButton{margin: 2px 2px;}
                                 self.imported_images[index_row][2] = False
                                 clean_parent_image(self, -1, ['Fetal_Seg','US_Seg'], index_view=index_view)
                         else:
-                            value.setCheckState(Qt.Checked)
+                            return cond
                     else:
                         cond = self.CloseMRI(message_box='on', dialogue=True)
                         if cond:
-                            if 'MRI' in info[0][1]:
+                            if '*View 2 (loaded)' in info[0][1]:
                                 self.imported_images.pop(index_row)
                                 parent = self.tree_images.model().sourceModel().invisibleRootItem()
                                 parent.removeRow(index_row)
@@ -3743,7 +3667,7 @@ QToolButton{margin: 2px 2px;}
                                 self.imported_images[index_row][2] = False
                                 clean_parent_image(self, -1, ['MRI_Seg'],index_view)
                         else:
-                            value.setCheckState(Qt.Checked)
+                            return cond
                 else: #segmentation loading
                     #if info[1] < 5:  # eco loading
                     if index_view == 0:
@@ -3754,6 +3678,98 @@ QToolButton{margin: 2px 2px;}
                         self.imported_images[index_row][2] = False
         except Exception as e:
             print(e)
+            return False
+        return True
+
+    # Add these three methods to your class
+
+    @QtCore.pyqtSlot(QtCore.QModelIndex)
+    def on_row_clicked(self, proxy_index):
+        """
+        Handles all logic in response to a user click by toggling the
+        check state of the item in the first column of the clicked row.
+        """
+        # 1. Get the proxy index for the first column in the clicked row.
+        check_proxy_index = proxy_index.sibling(proxy_index.row(), 0)
+
+        # 2. Map this proxy index back to the original source model index.
+        source_index = self.tree_colors.model().mapToSource(check_proxy_index)
+
+        # 3. Get the actual QStandardItem from the source model.
+        item = self.tree_colors.model().sourceModel().itemFromIndex(source_index)
+
+        # 4. If the item doesn't exist or isn't checkable, do nothing.
+        if not item or not item.isCheckable():
+            return
+
+        # 5. Determine the new state and TOGGLE THE CHECKBOX EXACTLY ONCE.
+        new_state = QtCore.Qt.Unchecked if item.checkState() == QtCore.Qt.Checked else QtCore.Qt.Checked
+        item.setCheckState(new_state)
+
+        # 6. Now, use this definitive new state for all follow-up logic.
+        if item.text().startswith('9876'):
+            # If the master was clicked, update all children
+            root = self.tree_colors.model().sourceModel().invisibleRootItem()
+            for row in range(root.rowCount()):
+                child_item = root.child(row, 0)
+                if child_item and child_item.isCheckable() and child_item != item:
+                    child_item.setCheckState(new_state)
+        else:
+            # If a child was clicked, update the master
+            self.update_master_checkbox_state(self.tree_colors)
+
+        # 7. Manually update the styling for all rows.
+        self.style_all_rows(self.tree_colors)
+        self.changeColorPen(item)
+
+    def update_master_checkbox_state(self, tree):
+        """Checks children and updates the master checkbox state."""
+        model = tree.model().sourceModel()
+        root = model.invisibleRootItem()
+
+        master_item = None
+        checkable_children = 0
+        checked_count = 0
+
+        # Find the master item and count checked children
+        for row in range(root.rowCount()):
+            item = root.child(row, 0)
+            if not item or not item.isCheckable():
+                continue
+
+            if item.text().startswith('9876'):
+                master_item = item
+            else:
+                checkable_children += 1
+                if item.checkState() == QtCore.Qt.Checked:
+                    checked_count += 1
+
+        if master_item:
+            # Block signals here to prevent this update from causing a new signal
+            model.blockSignals(True)
+            if checked_count == checkable_children and checkable_children > 0:
+                master_item.setCheckState(QtCore.Qt.Checked)
+            else:
+                master_item.setCheckState(QtCore.Qt.Unchecked)
+            model.blockSignals(False)
+
+    def style_all_rows(self, tree):
+        """Loops through all rows to set the background color."""
+        model = tree.model().sourceModel()
+        root = model.invisibleRootItem()
+        for row in range(root.rowCount()):
+            item = root.child(row, 0)
+            if item:
+                if item.checkState() == QtCore.Qt.Checked:
+                    brush = QtGui.QBrush(QtGui.QColor(212, 237, 218, 60))
+                else:
+                    brush = QtGui.QBrush(QtCore.Qt.transparent)
+
+                for col in range(model.columnCount()):
+                    item_in_row = model.item(row, col)
+                    if item_in_row:
+                        item_in_row.setBackground(brush)
+
 
     def changeColorPen(self,value): # change color pen
         """
@@ -3762,7 +3778,6 @@ QToolButton{margin: 2px 2px;}
         :return: set current color
         """
 
-
         text =''
         if type(value)!=str:
             colrInds = []
@@ -3772,15 +3787,24 @@ QToolButton{margin: 2px 2px;}
             else:
                 ind = None
                 text = ''
-            root = self.tree_colors.model().sourceModel().invisibleRootItem()
+            #root = self.tree_colors.model().sourceModel().invisibleRootItem()
+            model = self.tree_colors.model().sourceModel()
+
+            #if len(colrInds)==0:
+                #colrInds = []
+            #    ind = 9876
+            #    text='Combined'
+
+
+            root = model.invisibleRootItem()
+
             for i in range(root.rowCount()):
                 signal = root.child(i)
                 if signal.checkState()==Qt.Checked:
                     colrInds.append(int(float(signal.text())))
-            if len(colrInds)==0:
-                #colrInds = []
-                ind = 9876
-                text='Combined'
+
+
+
 
 
         try:
@@ -3832,7 +3856,7 @@ QToolButton{margin: 2px 2px;}
                 self.pixmap_box_label.setText(text)
                 self.actionColor.setIcon(self._icon_colorX)
                     #pixmap.fill((QtGui.QColor(colorPen[0] * 255.0, colorPen[1] * 255.0, colorPen[2] * 255.0, 1 * 255.0)))
-                    #self._icon_colorX.addPixmap(QtGui.QPixmap(source_folder + "/box.png"), QtGui.QIcon.Normal,
+                    #self._icon_colorX.addPixmap(QtGui.QPixmap(settings.RESOURCE_DIR + "/box.png"), QtGui.QIcon.Normal,
                     #                            QtGui.QIcon.On)
                     #self._icon_colorX.addPixmap()
 
@@ -4298,28 +4322,28 @@ QToolButton{margin: 2px 2px;}
         Create desired cursors
         :return:
         """
-        bitmap = QtGui.QPixmap(source_folder+"/Hand.png")
+        bitmap = QtGui.QPixmap(settings.RESOURCE_DIR+"/Hand.png")
         self.cursorOpenHand = QtGui.QCursor(bitmap)
 
 
-        bitmap = QtGui.QPixmap(source_folder+"/Handsqueezed.png")
+        bitmap = QtGui.QPixmap(settings.RESOURCE_DIR+"/Handsqueezed.png")
         self.cursorClosedHand = QtGui.QCursor(bitmap)
 
 
-        bitmap = QtGui.QPixmap(source_folder+"/zoom_in.png")
+        bitmap = QtGui.QPixmap(settings.RESOURCE_DIR+"/zoom_in.png")
         self.cursorZoomIn = QtGui.QCursor(bitmap)
 
 
-        bitmap = QtGui.QPixmap(source_folder+"/zoom_out.png")
+        bitmap = QtGui.QPixmap(settings.RESOURCE_DIR+"/zoom_out.png")
         self.cursorZoomOut = QtGui.QCursor(bitmap)
 
 
 
-        bitmap = QtGui.QPixmap(source_folder+"/rotate.png")
+        bitmap = QtGui.QPixmap(settings.RESOURCE_DIR+"/rotate.png")
         self.cursorRotate = QtGui.QCursor(bitmap)
 
 
-        #bitmap = QtGui.QPixmap(source_folder+"/arrow.png")
+        #bitmap = QtGui.QPixmap(settings.RESOURCE_DIR+"/arrow.png")
         self.cursorArrow = QtGui.QCursor(Qt.ArrowCursor)
 
         self.setCursor(self.cursorArrow)
@@ -4363,7 +4387,7 @@ QToolButton{margin: 2px 2px;}
         """
         filters = "BrainNeonatal (*.bn)"
         opts =QtWidgets.QFileDialog.DontUseNativeDialog
-        fileObj = QtWidgets.QFileDialog.getSaveFileName( self, "Open File", self.source_dir, filters, options=opts)
+        fileObj = QtWidgets.QFileDialog.getSaveFileName( self, "Open File", settings.DEFAULT_USE_DIR, filters, options=opts)
         if fileObj[0] == '':
             return
         self._basefileSave, _ = os.path.splitext(fileObj[0])
@@ -4396,7 +4420,7 @@ QToolButton{margin: 2px 2px;}
             self.saveChanges()
 
 
-            status =save_modified_nifti(self.readImECO, self.source_dir, self.filenameEco)
+            status =save_modified_nifti(self.readImECO, settings.DEFAULT_USE_DIR, self.filenameEco)
 
             self.progressBarSaving.setValue(100)
             self.setEnabled(True)
@@ -4417,7 +4441,7 @@ QToolButton{margin: 2px 2px;}
 
         filters = "DICOM (*.dcm);;Nifti (*.nia *.nii *.nii.gz *.hdr *.img *.img.gz *.mgz);;NRRD (*.nrrd *.nhdr)"
         opts =QtWidgets.QFileDialog.DontUseNativeDialog
-        fileObj = QtWidgets.QFileDialog.getSaveFileName( self, "Open File", self.source_dir, filters, options=opts)
+        fileObj = QtWidgets.QFileDialog.getSaveFileName( self, "Open File", settings.DEFAULT_USE_DIR, filters, options=opts)
 
         if  fileObj[1] != '' and hasattr(self, 'readImECO'):
             outfile_format = filters.split(';;').index(fileObj[1])
@@ -4523,7 +4547,8 @@ QToolButton{margin: 2px 2px;}
 
     def eventFilter(self, obj, event):
         from PyQt5.QtCore import QEvent
-
+        """
+        
         if event.type() ==QEvent.Resize: # window resizing
             for k in range(12):
                 name = 'openGLWidget_' + str(k + 1)
@@ -4531,7 +4556,7 @@ QToolButton{margin: 2px 2px;}
                 if widget.imSlice is not None:
                     widget.UpdatePaintInfo()
                     widget.update()
-
+        """
         if event.type() == QEvent.UpdateRequest:
             pass
         elif event.type() == QEvent.MouseButtonRelease:
@@ -4555,7 +4580,7 @@ QToolButton{margin: 2px 2px;}
         HELP MELAGE
         :return:
         """
-        url = os.path.join(os.path.dirname(source_folder), 'README.html')
+        url = os.path.join(settings.DOCS_DIR, 'README.html')
         QtGui.QDesktopServices.openUrl(QtCore.QUrl.fromLocalFile(url))
 
 
@@ -4577,15 +4602,15 @@ QToolButton{margin: 2px 2px;}
         About MELAGE
         :return:
         """
-        from melage.widgets.melageAbout import about_dialog
+        from melage.dialogs import about_dialog
         try:
-            dialog = about_dialog(self, source_folder)
+            dialog = about_dialog(self, settings.RESOURCE_DIR)
             dialog.show()
         except Exception as e:
             print(e)
 
         #MessageBox = QtWidgets.QMessageBox(self)
-        #MessageBox.setText(' MELAGE \n Hospital Puerta del Mar\n March 2021')
+        #MessageBox.setText(' melage \n Hospital Puerta del Mar\n March 2021')
         #MessageBox.show()
 
     def main_toolbar_visibility(self, value):
@@ -4920,298 +4945,7 @@ QToolButton{margin: 2px 2px;}
                 '{} There is something wrong please check the file.'.format(e))
 
 
-    def BEDL_back(self, value, forward=1):
-        """
-        Backtransforming the enhanced image
-        :param value:
-        :return:
-        """
-        if forward:
-            if value == 0:
-                if not hasattr(self, 'readImECO'):
-                    return
-                reader = self.readImECO
-                widgets_num = [0, 1, 2, 10]
-            elif value == 1:
-                if not hasattr(self, 'readImMRI'):
-                    return
-                reader = self.readImMRI
-                widgets_num = [3, 4, 5, 10]
-            else:
-                return
-            if not hasattr(reader, 'npImage'):
-                return
-
-            save_var = '_immri_bedl_{}'.format(value)
-            save_var_seg = '_immri_bedl_seg_{}'.format(value)
-            if not hasattr(self, save_var):
-                setattr(self, save_var, reader.im.__class__(reader.im.dataobj[:], reader.im.affine, reader.im.header))
-                setattr(self, save_var_seg, reader.npSeg)
-            reader.im = out
-            reader.set_metadata()
-            reader.read_pars()
-            if value == 0:
-                self.setNewImage.emit(reader.npImage.shape)
-            elif value == 1:
-                self.setNewImage2.emit(reader.npImage.shape)
-            self.tabWidget.setTabVisible(3, True)
-            self.changedTab()
-            for k in widgets_num:
-                name = 'openGLWidget_' + str(k + 1)
-                widget = getattr(self, name)
-                widget.makeObject()
-                widget.update()
-            if value == 0:
-                self.updateDispEco(reader.npImage, reader.npSeg, initialState=True)
-                if self.N4_dialog._shrinkfactor > 1:
-                    self.reset_page1_eco()
-                    self.toolBar2.setDisabled(False)
-                    self._rotationAngleEco_coronal = 0
-                    self._rotationAngleEco_axial = 0
-                    self._rotationAngleEco_sagittal = 0
-                    self.hs_t1_5.setValue(0)
-
-                    txt = compute_volume(self.readImECO, self.filenameEco, [9876], in_txt=self.openedFileName.text(),
-                                         ind_screen=0)
-                    self.openedFileName.setText(txt)
-
-            if value == 1:
-                self.updateDispMRI(reader.npImage, reader.npSeg, initialState=True, tract=reader.tract)
-                if self.N4_dialog._shrinkfactor > 1:
-                    self.reset_page1_mri()
-                    self.hs_t2_5.setValue(0)
-                    self.toolBar2.setDisabled(False)
-                    txt = compute_volume(reader, self.filenameMRI, [9876], in_txt=self.openedFileName.text(),
-                                         ind_screen=1)
-                    self.openedFileName.setText(txt)
-
-
-                self._rotationAngleMRI_coronal = 0
-                self._rotationAngleMRI_axial = 0
-                self._rotationAngleMRI_sagittal = 0
-            self.BE_DL.backbutton.setVisible(True)
-        else:
-            if value == 0:
-                if not hasattr(self, 'readImECO'):
-                    return
-                reader = self.readImECO
-                widgets_num = [0, 1, 2, 10]
-            elif value==1:
-                if not hasattr(self, 'readImMRI'):
-                    return
-                reader = self.readImMRI
-                widgets_num = [3, 4, 5, 10]
-            else:
-                return
-            if not hasattr(reader, 'npImage'):
-                return
-
-
-            save_var = '_immri_bedl_{}'.format(value)
-            save_var_seg = '_immri_bedl_seg_{}'.format(value)
-            if not hasattr(self, save_var):
-                return
-            #reader.im = self._immri_tmp
-            reader.im = getattr(self, save_var)
-            reader.set_metadata()
-            reader.read_pars()
-            self.setNewImage2.emit(reader.npImage.shape)
-            reader.npSeg = getattr(self, save_var_seg)
-            delattr(self, save_var_seg)
-            delattr(self, save_var)
-
-            self.tabWidget.setTabVisible(3, True)
-
-            for k in widgets_num:
-                name = 'openGLWidget_' + str(k + 1)
-                widget = getattr(self, name)
-                widget.makeObject()
-                widget.update()
-            # self.readImMRI.npImage = standardize(self.readImMRI.npImage)
-            if value==0:
-                self.updateDispEco(reader.npImage, reader.npSeg, initialState=True)
-                self._rotationAngleEco_coronal = 0
-                self._rotationAngleEco_axial = 0
-                self._rotationAngleEco_sagittal=0
-            elif value == 1:
-                self.updateDispMRI(reader.npImage, reader.npSeg, initialState=True, tract=reader.tract)
-                self._rotationAngleMRI_coronal = 0
-                self._rotationAngleMRI_axial = 0
-                self._rotationAngleMRI_sagittal=0
-
-
-    def N4_back(self, value):
-        """
-        N4 image processing
-        :param value:
-        :return:
-        """
-        if value == 0:
-            if not hasattr(self, 'readImECO'):
-                return
-            reader = self.readImECO
-            widgets_num = [0, 1, 2, 10]
-        elif value==1:
-            if not hasattr(self, 'readImMRI'):
-                return
-            reader = self.readImMRI
-            widgets_num = [3, 4, 5, 10]
-        else:
-            return
-        if not hasattr(reader, 'npImage'):
-            return
-
-
-        save_var = '_immri_tmp_{}'.format(value)
-        save_var_seg = '_immri_tmp_seg_{}'.format(value)
-        if not hasattr(self, save_var):
-            return
-        #reader.im = self._immri_tmp
-        reader.im = getattr(self, save_var)
-        reader.set_metadata()
-        reader.read_pars()
-        self.setNewImage2.emit(reader.npImage.shape)
-        reader.npSeg = getattr(self, save_var_seg)
-        delattr(self, save_var_seg)
-        delattr(self, save_var)
-
-        self.tabWidget.setTabVisible(3, True)
-
-        for k in widgets_num:
-            name = 'openGLWidget_' + str(k + 1)
-            widget = getattr(self, name)
-            widget.makeObject()
-            widget.update()
-        # self.readImMRI.npImage = standardize(self.readImMRI.npImage)
-        if value==0:
-            self.updateDispEco(reader.npImage, reader.npSeg, initialState=True)
-            self._rotationAngleEco_coronal = 0
-            self._rotationAngleEco_axial = 0
-            self._rotationAngleEco_sagittal=0
-        elif value == 1:
-            self.updateDispMRI(reader.npImage, reader.npSeg, initialState=True, tract=reader.tract)
-            self._rotationAngleMRI_coronal = 0
-            self._rotationAngleMRI_axial = 0
-            self._rotationAngleMRI_sagittal=0
-
-    def print(self):
-        print('salam')
-
-    def N4_correction(self, value):
-        """
-        N4 correction
-        :param value:
-        :return:
-        """
-        if value == 0:
-            if not hasattr(self, 'readImECO'):
-                return
-            reader = self.readImECO
-            widgets_num = [0, 1, 2, 10]
-        elif value==1:
-            if not hasattr(self, 'readImMRI'):
-                return
-            reader = self.readImMRI
-            widgets_num = [3, 4, 5, 10]
-        else:
-            return
-        if not hasattr(reader, 'npImage'):
-            return
-
-        save_var = '_immri_tmp_{}'.format(value)
-        save_var_seg = '_immri_tmp_seg_{}'.format(value)
-        if not hasattr(self, save_var):
-            setattr(self, save_var, reader.im.__class__(reader.im.dataobj[:], reader.im.affine, reader.im.header))
-            setattr(self, save_var_seg, reader.npSeg)
-
-        self.setEnabled(False)
-        self.N4_dialog.inputimage = reader.im
-        self.N4_dialog.setEnabled(False)
-
-
-        worker = Worker(0)
-        worker.inputimage = reader.im
-        #QtCore.QCoreApplication.processEvents()
-
-        thread = QtCore.QThread()
-        def on_quit():
-            thread.quit()
-            thread.wait()
-        worker.moveToThread(thread)
-        worker.set_params(reader.npImage, self.N4_dialog.params, reader.im.affine)
-        thread.started.connect(worker.run)
-        #worker.finished.connect(worker.deleteLater)
-        worker.finished.connect(on_quit)
-        #thread.finished.connect(thread.deleteLater)
-        thread.start()
-
-        self.N4_dialog.progressBar.setVisible(True)
-
-        self.N4_dialog.progressBar.setValue(10)
-        self.app.processEvents()
-        worker.run()
-        self.setEnabled(True)
-        self.N4_dialog.setEnabled(True)
-        self.N4_dialog.progressBar.setValue(100)
-        self.N4_dialog.progressBar.setVisible(False)
-        if worker.out is not None:
-            out = worker.out
-        else:
-            return
-
-        #out = self.N4_dialog.execute()
-        #self.inputimage = None
-        #self.N4_dialog.setEnabled(True)
-
-        reader.im = out
-        reader.set_metadata()
-        reader.read_pars()
-        if self.N4_dialog._shrinkfactor>1:
-            if value==0:
-                self.setNewImage.emit(reader.npImage.shape)
-            elif value==1:
-                self.setNewImage2.emit(reader.npImage.shape)
-        self.tabWidget.setTabVisible(3, True)
-        self.changedTab()
-        for k in widgets_num:
-            name = 'openGLWidget_' + str(k + 1)
-            widget = getattr(self, name)
-            widget.makeObject()
-            widget.update()
-        if value==0:
-            self.updateDispEco(reader.npImage, reader.npSeg, initialState=True)
-            if self.N4_dialog._shrinkfactor > 1:
-                self.reset_page1_eco()
-                self.toolBar2.setDisabled(False)
-                self._rotationAngleEco_coronal = 0
-                self._rotationAngleEco_axial = 0
-                self._rotationAngleEco_sagittal = 0
-                self.hs_t1_5.setValue(0)
-                # self.openedFileName.setText('Eco: {}, \n MRI: {}'.format(self.filenameEco, self.filenameMRI))
-                #txt = 'File: {}, TV: {}'.format(self.filenameEco,
-                #                                self.readImECO.npSeg.sum() * self.readImECO.ImSpacing[0] ** 3)
-                #self.openedFileName.setText(txt)
-                txt = compute_volume(self.readImECO, self.filenameEco, [9876], in_txt=self.openedFileName.text(),
-                                     ind_screen=1)
-                self.openedFileName.setText(txt)
-
-        if value==1:
-            self.updateDispMRI(reader.npImage, reader.npSeg, initialState=True, tract=reader.tract)
-            if self.N4_dialog._shrinkfactor>1:
-                self.reset_page1_mri()
-                self.hs_t2_5.setValue(0)
-                self.toolBar2.setDisabled(False)
-                txt = compute_volume(reader, self.filenameMRI, [9876], in_txt=self.openedFileName.text(),
-                                     ind_screen=1)
-                self.openedFileName.setText(txt)
-                #self.openedFileName.setText(
-                #    'File: {}, TV: {}'.format(self.filenameMRI,
-                #                              reader.npSeg.sum() * reader.ImSpacing[0]))
 
-            self._rotationAngleMRI_coronal = 0
-            self._rotationAngleMRI_axial = 0
-            self._rotationAngleMRI_sagittal=0
-        self.N4_dialog.pushButton_2.setVisible(True)
 
     def retranslateUi(self, Main):
         self._translate = QtCore.QCoreApplication.translate
@@ -5255,31 +4989,25 @@ QToolButton{margin: 2px 2px;}
         self.actionEraseX.setText(self._translate("Main", "Eraser X times"))
         self.actionPaint.setText(self._translate("Main", "Paint"))
         self.actionErase.setText(self._translate("Main", "Erase"))
-        self.actionNNventricleGatherIm.setText(self._translate("Main", "Gather Current Segmentation to Image"))
         self.actionLazyContour.setText(self._translate("Main", "Zoom Out"))
-        self.actionNNventricleSegm.setText(self._translate("Main", "NN Segmentation"))
-        self.actionN4Bias.setText(self._translate("Main", "N4 Bias Field Correction"))
-        self.actionTissueSeg.setText(self._translate("Main", "Tissue Seg"))
+
+
+
         self.actionHistImage.setText(self._translate("Main", "Image Histogram"))
-        self.actionResizeImage.setText(self._translate("Main", "Resize"))
-        self.actionBET.setText(self._translate("Main", "BET"))
-        self.actionBEDL.setText(self._translate("Main", "DeepBET"))
+
         self.actionImageThresholding.setText(self._translate("Main", "Image Thresholding"))
         self.actionImageRegistration.setText(self._translate("Main", "Image Registration"))
         self.actionImageTransformation.setText(self._translate("Main", "Image Transformation"))
         self.actionMasking.setText(self._translate("Main", "Image Masking"))
         self.actionOperationMask.setText(self._translate("Main", "Masking Operation"))
-        self.actionChangeCS.setText(self._translate("Main", "Change CS"))
-        self.actionNNVentriclesSagittal.setText(self._translate("Main", "Sagittal") )
-        self.actionNNVentriclesCoronal.setText( self._translate("Main", "Coronal") )
-        self.actionNNVentriclesAxial.setText( self._translate("Main", "Axial") )
+
         self.actionrotate.setText(self._translate("Main", "Rotate"))
         self.actionArrow.setText(self._translate("Main", "Arrow"))
         self.menuTools.setTitle(self._translate("Main", "Tools"))
+        self.menuPlugins.setTitle(self._translate("Main", "Plugins"))
         self.menuBasicInfo.setTitle(self._translate("Main", "Basic Info"))
         self.menuCalc.setTitle(self._translate("Main", "Calc"))
         self.menuPreprocess.setTitle(self._translate("Main", "Preprocessing"))
-        self.menuSegmentation.setTitle(self._translate("Main", "Segmentation"))
         self.menuRegistration.setTitle(self._translate("Main", "Registeration"))
 
         self.menuExport.setTitle(self._translate("Main", "Export"))
@@ -5321,17 +5049,46 @@ QToolButton{margin: 2px 2px;}
         #self.actionContourGen.setText(self._translate("Main", "Contour Gen from line"))
         manually_check_tree_item(self,'9876')
 
+    def get_dialog(self, source_dir, filters, opts, title = "Open File"):
+
+        # 1. Create a QFileDialog instance instead of using the static method
+        dialog = QtWidgets.QFileDialog(self, title, source_dir, filters)
+
+        # 2. Set the options you need
+        dialog.setOptions(opts)
+        # Note: If using PyQt5/PySide2, you might need:
+        # dialog.setOption(QtWidgets.QFileDialog.DontUseNativeDialog, True)
+
+        # 3. Get the parent window's size
+        parent_size = self.size()
+        # You can also use self.geometry() for more complex positioning
+
+        # 4. Set the dialog's size relative to the parent's size
+        # For example, 80% of the parent's width and 70% of its height
+        dialog_width = int(parent_size.width() * 0.4)
+        dialog_height = int(parent_size.height() * 0.5)
+        dialog.resize(dialog_width, dialog_height)
+        return dialog
 
     def loadProject(self):
         """
         Loading saved project
         :return:
         """
+        #filters = "BrainNeonatal (*.bn)"
+        #opts =QtWidgets.QFileDialog.DontUseNativeDialog
+        #fileObj = QtWidgets.QFileDialog.getOpenFileName( self, "Open File", settings.DEFAULT_USE_DIR, filters, options=opts)
         filters = "BrainNeonatal (*.bn)"
-        opts =QtWidgets.QFileDialog.DontUseNativeDialog
-        fileObj = QtWidgets.QFileDialog.getOpenFileName( self, "Open File", self.source_dir, filters, options=opts)
-        if fileObj[0] != '':
-
+        opts = QtWidgets.QFileDialog.DontUseNativeDialog
+        dialog = self.get_dialog(settings.DEFAULT_USE_DIR, filters, opts, title="Open File")
+        #if fileObj[0] != '':
+        if dialog.exec() == QtWidgets.QDialog.Accepted:
+            selected_files = dialog.selectedFiles()
+            if selected_files:
+                # getOpenFileName returns a tuple (filepath, filter)
+                fileObj = (selected_files[0], dialog.selectedNameFilter())
+            else:
+                return
             self._basefileSave, _ = os.path.splitext(fileObj[0])
 
             self.dockWidget_3.setVisible(True)
@@ -5374,8 +5131,18 @@ QToolButton{margin: 2px 2px;}
 
     def newProject(self):
         opts = QtWidgets.QFileDialog.DontUseNativeDialog
-        fileObj = QtWidgets.QFileDialog.getSaveFileName(self, "Open File", self.source_dir, options=opts)
-        if fileObj[0] != '':
+        #fileObj = QtWidgets.QFileDialog.getSaveFileName(self, "Open File", settings.DEFAULT_USE_DIR, options=opts)
+
+        dialog = self.get_dialog( settings.DEFAULT_USE_DIR, filters=None, opts=opts, title="Open File")
+        #if fileObj[0] != '':
+        if dialog.exec() == QtWidgets.QDialog.Accepted:
+            selected_files = dialog.selectedFiles()
+            if selected_files:
+                # getOpenFileName returns a tuple (filepath, filter)
+                fileObj = (selected_files[0], dialog.selectedNameFilter())
+            else:
+                return
+        #if fileObj[0] != '':
 
             self._basefileSave, _ = os.path.splitext(fileObj[0])
             if self._openUSEnabled:
@@ -5399,8 +5166,113 @@ QToolButton{margin: 2px 2px;}
             self.Main.setWindowTitle(self._translate("Main", os.path.basename(self._basefileSave)))
             self.save()
 
+    def CloseUS(self, message_box=True):
+        """
+        Closes the Ultrasound (ECO) image and resets the associated UI elements.
+
+        :param show_confirmation: If True, asks the user for confirmation before closing.
+        :return: True if the view was closed, False if the user cancelled.
+        """
+        # 1. Check state: Is there anything to close?
+        if not self.readImECO:
+            # print("Ultrasound view is already closed.")
+            return True  # Already closed
+
+        proceed = False
+        if message_box:
+            # 2. Ask for confirmation
+            qm = QtWidgets.QMessageBox(self)
+            ret = qm.question(self, 'Confirm Close',
+                              "Are you sure you want to close View 1?",
+                              qm.Yes | qm.No)
+            if ret == qm.Yes:
+                proceed = True
+        else:
+            # 3. No confirmation needed
+            proceed = True
+
+        # 4. Perform cleanup only if confirmed
+        if proceed:
+            self._perform_us_cleanup()
+
+        return proceed
+
+    def _set_us_widgets_visible(self, is_visible):
+        """Helper method to show/hide all widgets related to the US view."""
+
+        # Disable actions
+        self.actionImportSegEco.setDisabled(True)
+        self.actionExportImEco.setDisabled(True)
+        self.actionExportSegEco.setDisabled(True)
+
+        # Toggle radio buttons
+        for name in self.US_RADIO_NAMES:
+            radio_button = getattr(self, name)
+            radio_button.setVisible(is_visible)
+
+        # Toggle sliders, labels, and OpenGL widgets
+        for k in self.US_VIEW_INDICES:
+            slider = getattr(self, 'horizontalSlider_' + str(k))
+            label = getattr(self, 'label_' + str(k))
+            widget = getattr(self, 'openGLWidget_' + str(k))
+
+            label.setVisible(is_visible)
+            slider.setVisible(is_visible)
+            widget.setVisible(is_visible)
+
+            if not is_visible:
+                # If hiding, also clear and reset the widget
+                widget.imType = 'eco'
+                widget.clear()
+                widget.resetInit()
+                widget.initialState()
+
+    def _perform_us_cleanup(self):
+        """Helper method to consolidate all cleanup tasks for closing the US view."""
+
+        # 1. Hide all the main US widgets
+        self._set_us_widgets_visible(False)
+
+        # 2. Reset other related UI elements
+        self.reset_page1_eco()
+        self.openGLWidget_14.clear()
+        self.ImageEnh_view1.setVisible(False)
+        # self.tree_colors.setVisible(False) # Removed commented-out code
+
+        # 3. Clear the image data
+        self.readImECO = []
+
+        # 4. Update tab state
+        self.changedTab()
+
+        # 5. Resize other (MRI) widgets
+        for k in self.MRI_VIEW_INDICES:
+            name = 'openGLWidget_' + str(k)
+            widget = getattr(self, name)
+            event = QtGui.QResizeEvent(widget.size(), widget.size())
+            widget.resizeEvent(event)
+            widget.resize(QtCore.QSize(widget.size().width(), widget.size().height() * 2))
+
+        # 6. Reset the ComboBox
+        self.actionComboBox_visible.setVisible(False)
+        self.actionComboBox_visible.setDisabled(True)
+        self.actionComboBox.setObjectName("View1")
+
+        # 7. Safely disconnect the signal
+        try:
+            self.actionComboBox.currentTextChanged.disconnect(self.changeVolume)
+        except (TypeError, RuntimeError):
+            # Catches specific errors if it's not connected
+            pass
 
-    def CloseUS(self, message_box='on'):
+        self.actionComboBox.clear()
+
+        # 8. Call the final cleanup utility
+        clean_parent_image(self, -1, ['View 1'], index_view=0)
+        for plugin in self.plugin_widgets:
+            data_context = self.get_current_image_data()
+            plugin.update_data_context(data_context)
+    def CloseUS2(self, message_box='on'):
         def setVisible(val):
 
             self.actionImportSegEco.setDisabled(True)
@@ -5435,9 +5307,10 @@ QToolButton{margin: 2px 2px;}
             self.readImECO = []
             self.changedTab()
         else:
-            qm = QtWidgets.QMessageBox(self)
-            cond = qm.question(self, '', "Are you sure to close View 1?", qm.Yes | qm.No)
-            if cond==qm.Yes:
+            #qm = QtWidgets.QMessageBox(self)
+            #ret = qm.question(self, '', "Are you sure to close View 1?", qm.Yes | qm.No)
+            cond = True#ret == qm.Yes
+            if cond:
 
                 setVisible(False)
                 self.reset_page1_eco()
@@ -5469,10 +5342,137 @@ QToolButton{margin: 2px 2px;}
                 #self.changedTab()
             return cond
 
+        # --- Assumed imports ---
+        # from PyQt5 import QtWidgets, QtGui, QtCore
+
+        # --- Assumed base class (for context) ---
+        # class YourMainWindow(QtWidgets.QMainWindow):
+        #     def __init__(self):
+        #         super().__init__()
+        #         # Define widget groups as class attributes for clarity and maintenance
+        #         # This is MUCH better than "magic numbers"
+
+
+        #         # ... other init setup ...
+        #         self.readImMRI = [] # Initialize state
+
+    def CloseMRI(self, message_box=True):
+        """
+        Closes the MRI image and resets the associated UI elements.
+
+        :param show_confirmation: If True, asks the user for confirmation before closing.
+        :return: True if the view was closed, False if the user cancelled.
+        """
+        # 1. Check state: Is there anything to close?
+        #    (Assuming self.readImMRI = [] is the "closed" state)
+        if not self.readImMRI:
+            # print("MRI view is already closed.")
+            return True  # Already closed, operation is "successful"
+
+        proceed = False
+        if message_box:
+            # 2. Ask for confirmation
+            # (Uncommented the MessageBox logic)
+            qm = QtWidgets.QMessageBox(self)
+            ret = qm.question(self, 'Confirm Close',
+                              "Are you sure you want to close View 2?",
+                              qm.Yes | qm.No)
+            if ret == qm.Yes:
+                proceed = True
+        else:
+            # 3. No confirmation needed, just proceed
+            proceed = True
+
+        # 4. Perform cleanup only if user confirmed or no confirmation was needed
+        if proceed:
+            self._perform_mri_cleanup()
+
+        return proceed
+
+    def _set_mri_widgets_visible(self, is_visible):
+        """Helper method to show/hide all widgets related to the MRI view."""
+
+        # Disable actions
+        self.actionImportSegMRI.setDisabled(True)
+        self.actionExportImMRI.setDisabled(True)
+        self.actionExportSegMRI.setDisabled(True)
+
+        # Toggle radio buttons
+        for name in self.MRI_RADIO_NAMES:
+            radio_button = getattr(self, name)
+            radio_button.setVisible(is_visible)
+
+        # Clean up the opened file name text
+        txt = self.openedFileName.text()
+        division_ind = txt.find(' ; ')
+        if division_ind != -1:
+            # Use split to robustly get the part before ' ; '
+            kept_part = txt.split(' ; ', 1)[0]
+            self.openedFileName.setText(f'{kept_part} ; ')
+
+        # Toggle sliders, labels, and OpenGL widgets
+        for k in self.MRI_VIEW_INDICES:
+            slider = getattr(self, 'horizontalSlider_' + str(k))
+            label = getattr(self, 'label_' + str(k))
+            widget = getattr(self, 'openGLWidget_' + str(k))
+
+            label.setVisible(is_visible)
+            slider.setVisible(is_visible)
+            widget.setVisible(is_visible)
+
+            if not is_visible:
+                # If hiding, also clear and reset the widget
+                widget.imType = 'mri'
+                widget.clear()
+                widget.resetInit()
+                widget.initialState()
+
+    def _perform_mri_cleanup(self):
+        """Helper method to consolidate all cleanup tasks for closing the MRI view."""
+
+        # 1. Hide all the main MRI widgets
+        self._set_mri_widgets_visible(False)
+
+        # 2. Reset other related UI elements
+        self.reset_page1_mri()
+        self.openGLWidget_24.clear()
+        self.page1_mri.setVisible(False)
+        # self.tree_colors.setVisible(False) # Removed commented-out code
 
+        # 3. Clear the image data
+        self.readImMRI = []
+        # self.save() # Removed commented-out code
 
+        # 4. Resize other widgets
+        for k in self.US_VIEW_INDICES:
+            name = 'openGLWidget_' + str(k)
+            widget = getattr(self, name)
+            event = QtGui.QResizeEvent(widget.size(), widget.size())
+            widget.resizeEvent(event)
+            widget.resize(QtCore.QSize(widget.size().width(), widget.size().height() * 2))
+
+        # 5. Reset the ComboBox
+        self.actionComboBox_visible.setVisible(False)
+        self.actionComboBox_visible.setDisabled(True)
+        self.actionComboBox.setObjectName("View2")
+
+        # 6. Safely disconnect the signal
+        try:
+            self.actionComboBox.currentTextChanged.disconnect(self.changeVolume)
+        except (TypeError, RuntimeError):
+            # This is safer than a bare 'except:'
+            # It catches the specific errors disconnect() might raise
+            pass
+
+        self.actionComboBox.clear()
 
-    def CloseMRI(self, message_box='on', dialogue=True):
+        # 7. Call the final cleanup utility
+        clean_parent_image(self, -1, ['View 2'], index_view=1)
+        for plugin in self.plugin_widgets:
+            data_context = self.get_current_image_data()
+            plugin.update_data_context(data_context)
+
+    def CloseMRI2(self, message_box='on', dialogue=True):
         """
         Closing MRI image
         :param message_box:
@@ -5522,12 +5522,18 @@ QToolButton{margin: 2px 2px;}
 
         else:
             if dialogue:
-                qm = QtWidgets.QMessageBox(self)
-                ret = qm.question(self, '', "Are you sure to close View 2?", qm.Yes | qm.No)
-                cond = ret==qm.Yes
+                #qm = QtWidgets.QMessageBox(self)
+                #ret = qm.question(self, '', "Are you sure to close View 2?", qm.Yes | qm.No)
+                #cond = ret==qm.Yes
+                cond = True
+                if not cond:
+                    return cond
             else:
                 cond = True
             if cond:
+                if not hasattr(self.readImMRI, 'npImage'):
+                    # message image already closed
+                    return
                 setVisible(False)
                 self.reset_page1_mri()
                 self.openGLWidget_24.clear()
@@ -5580,16 +5586,19 @@ QToolButton{margin: 2px 2px;}
         :param currentCS:
         :return:
         """
-        #fileObj = QtWidgets.QFileDialog.getSaveFileName(self, "Open File", self.source_dir+'/'+pref, filters, options=opts)
-        from melage.widgets.fileDialog_widget import QFileSaveDialogPreview
+        #fileObj = QtWidgets.QFileDialog.getSaveFileName(self, "Open File", settings.DEFAULT_USE_DIR+'/'+pref, filters, options=opts)
+        from melage.dialogs.helpers import QFileSaveDialogPreview
         #from melage.utils.utils import getCurrentCoordSystem
         check_save = True
         if hasattr(self, '_last_state_save_csv' ):
             check_save=self._last_state_save_csv
-        dialg = QFileSaveDialogPreview(self, "Open File", self.source_dir+'/'+pref, filters, options=opts, check_state_csv=check_save)
+        dialg = QFileSaveDialogPreview(self, "Open File", settings.DEFAULT_USE_DIR+'/'+pref, filters, options=opts, check_state_csv=check_save)
 
         dialg.setCS(currentCS)
-
+        parent_size = self.size()
+        dialog_width = int(parent_size.width() * 0.6)
+        dialog_height = int(parent_size.height() * 0.7)
+        dialg.resize(dialog_width, dialog_height)
 
         #if dialg.exec_() == QFileSaveDialogPreview.Accepted:
         dialg.exec_()
@@ -5744,10 +5753,20 @@ QToolButton{margin: 2px 2px;}
         update_color_s = False # do not update color scheme
         if fileObj is None or type(fileObj)==bool:
             update_color_s = True
-            opts =QtWidgets.QFileDialog.DontUseNativeDialog
-            fileObj = QtWidgets.QFileDialog.getOpenFileName( self, "Open File", self.source_dir, self._filters, options=opts)
-            if fileObj[0]=='':
+            opts = QtWidgets.QFileDialog.DontUseNativeDialog
+            dialog = self.get_dialog(settings.DEFAULT_USE_DIR, self._filters, opts, title="Open File")
+            if dialog.exec() == QtWidgets.QDialog.Accepted:
+                selected_files = dialog.selectedFiles()
+                if selected_files:
+                    # getOpenFileName returns a tuple (filepath, filter)
+                    fileObj = (selected_files[0], dialog.selectedNameFilter())
+                else:
+                    return False
+            else:
                 return False
+            #if not dialog.exec() == QtWidgets.QDialog.Accepted:
+            #if fileObj[0]=='':
+            #    return False
 
         if type_image.lower()=='usseg':
             if hasattr(self, 'readImECO'):
@@ -6025,7 +6044,7 @@ QToolButton{margin: 2px 2px;}
                             file_out = 'View 1: {}, View 2: {}'.format(self.filenameEco, self.filenameMRI)
                         else:
                             file_out = 'View 2: {}'.format(self.filenameMRI)
-                        info1, color1 = [[[self.filenameMRI], "*MRI_loaded"],2, 1], [1,1,0]
+                        info1, color1 = [[[self.filenameMRI], "*View 2 (loaded)"],2, 1], [1,1,0]
                         update_image_sch(self, info=info1, color=color1, loaded=True)
                         #info1, color1 = [[self.filenameMRI+'_seg', 'MRI_loaded_seg'],5], [0,1,1]
                         #update_image_sch(self, info=info1, color=color1, loaded=True)
@@ -6053,7 +6072,7 @@ QToolButton{margin: 2px 2px;}
 
                 #if not self.dw2_cb.currentText() in self.dw2Text:
                 #self.dw2_cb.currentTextChanged.disconnect(self.changeColorPen)
-                self.tree_colors.model().sourceModel().itemChanged.disconnect(self.changeColorPen)
+                #self.tree_colors.model().sourceModel().itemChanged.disconnect(self.changeColorPen)
                 #color_index_rgb = [[key, self.colorsCombinations[key][0], self.colorsCombinations[key][1],
                 #             self.colorsCombinations[key][2], self.colorsCombinations[key][3]] for key in
                 #            self.colorsCombinations.keys() if len(self.colorsCombinations[key]) > 0]
@@ -6064,7 +6083,7 @@ QToolButton{margin: 2px 2px;}
                 adapt_previous_versions(self)
                 set_new_color_scheme(self)
                 update_widget_color_scheme(self)
-                self.tree_colors.model().sourceModel().itemChanged.connect(self.changeColorPen)
+                #self.tree_colors.model().sourceModel().itemChanged.connect(self.changeColorPen)
                 #self.dw2_cb.currentTextChanged.connect(self.changeColorPen)
                 #elif abs(len(self.colorsCombinations.keys())-len(self.dw2Text))==1:
                 #    self.colorsCombinations[len(self.dw2Text)] = [1, 0, 0, 1]
@@ -6097,9 +6116,10 @@ QToolButton{margin: 2px 2px;}
                 self.progressBarSaving.setVisible(False)
                 self.openGLWidget_14._updatePaint = True
                 self.openGLWidget_24._updatePaint = True
-                self.expectedTime = self.settingsBN.doubleSpinBox.value()*60
+                self.expectedTime = self.settingsBN.auto_save_spinbox.value()*60
                 self.dw2_s1.setValue(int(self.dw2lb1.text()))
                 self.dw2_s2.setValue(int(self.dw2lb2.text()))
+                self.current_view = 'horizontal'
                 #self.changedTab()
         except Exception as e:
             print('Load changes')
@@ -6144,10 +6164,16 @@ QToolButton{margin: 2px 2px;}
             if not isinstance(fileObj, list):
                 fileObj = ['', '']
                 opts = QtWidgets.QFileDialog.DontUseNativeDialog
-                dialg = QFileDialogPreview(self, "Open File", self.source_dir, self._filters, options=opts,
+                dialg = QFileDialogPreview(self, "Open File", settings.DEFAULT_USE_DIR, self._filters, options=opts,
                                            index=self._last_index_select_image_mri, last_state=self._last_state_preview)
                 dialg.setFileMode(QtWidgets.QFileDialog.ExistingFile)
 
+                parent_size = self.size()
+                dialog_width = int(parent_size.width() * 0.6)
+                dialog_height = int(parent_size.height() * 0.7)
+                dialg.resize(dialog_width, dialog_height)
+
+
                 if dialg.exec_() == QFileDialogPreview.Accepted:
                     fileObj = dialg.getFileSelected()
                     fileObj[1] = dialg.selectedNameFilter()
@@ -6277,8 +6303,7 @@ QToolButton{margin: 2px 2px;}
                     widget = getattr(self, widget_name)
                     widget.resetInit()
                     widget.initialState()
-                    if 'Affine' in self.readImECO.im_metadata:
-                        widget.affine = self.readImECO.im_metadata['Affine']
+                    widget.affine = getattr(self.readImECO, "im_metadata", {}).get("Affine", widget.affine)
 
 
                 self.updateDispEco(self.readImECO.npImage, self.readImECO.npSeg, initialState=True)
@@ -6287,10 +6312,10 @@ QToolButton{margin: 2px 2px;}
                 self.reset_page1_eco()
 
                 if use_dialog:
-                    self.setCurrentCoordsystem()
+
                     self.HistImage.UpdateName(self.filenameEco, None)
                     self.iminfo_dialog.UpdateName(self.filenameEco, None)
-                    info1, color1 = [[[fileObj[0]], fileObj[1]], 2, 1], [1, 1, 0]
+                    info1, color1 = [[[fileObj[0]], fileObj[1]], 2, 0], [1, 1, 0]
                     update_image_sch(self, info=info1, color=color1, loaded=True)
 
                     from melage.utils.utils import clean_parent_image2
@@ -6317,15 +6342,12 @@ QToolButton{margin: 2px 2px;}
 
         self.activateGuidelines(self._last_state_guide_lines)
 
-        if self.BE_DL.isVisible():
-            self.updateDataBEDL(index=0)
-        else:
-            self.BE_DL.clear()
 
-        if self.Tissue_Seg.isVisible():
-            self.updateDataBEDL(index=1)
-        else:
-            self.Tissue_Seg.clear()
+        # update data context
+        for plugin in self.plugin_widgets:
+            data_context = self.get_current_image_data()
+            plugin.update_data_context(data_context)
+        ####
 
         for ind in range(2):
             save_var = '_immri_bedl_{}'.format(ind)
@@ -6350,7 +6372,8 @@ QToolButton{margin: 2px 2px;}
             return
         if fileObj is None or type(fileObj) is bool:
             opts =QtWidgets.QFileDialog.DontUseNativeDialog
-            fileObj = QtWidgets.QFileDialog.getOpenFileName( self, "Open File", self.source_dir, 'track(*.trk)', options=opts)
+            fileObj = QtWidgets.QFileDialog.getOpenFileName( self, "Open File", settings.DEFAULT_USE_DIR, 'track(*.trk)', options=opts)
+
         if fileObj[0]=='':
             return
         stk, success = load_trk(fileObj[0])
@@ -6393,7 +6416,7 @@ QToolButton{margin: 2px 2px;}
         # Browse Fractional Anisotropy
         if fileObj is None or type(fileObj) is bool:
             opts =QtWidgets.QFileDialog.DontUseNativeDialog
-            fileObj = QtWidgets.QFileDialog.getOpenFileName( self, "Open File", self.source_dir, self._filters, options=opts)
+            fileObj = QtWidgets.QFileDialog.getOpenFileName( self, "Open File", settings.DEFAULT_USE_DIR, self._filters, options=opts)
         if fileObj[0]=='':
             return
         Img, _ = self.readD(fileObj, type='t1')
@@ -6428,6 +6451,7 @@ QToolButton{margin: 2px 2px;}
                     widget.makeObject()
                     widget.update()
 
+
     def browseMRI(self, fileObj=None, use_dialog=True):
         """
         Browsing MRI
@@ -6436,7 +6460,7 @@ QToolButton{margin: 2px 2px;}
         :return:
         """
 
-        def setVisible(val):
+        def setVisible(val, imtype="mri"):
             self.actionImportSegMRI.setDisabled(False)
             self.actionExportImMRI.setDisabled(False)
             self.actionExportSegMRI.setDisabled(False)
@@ -6447,15 +6471,14 @@ QToolButton{margin: 2px 2px;}
             self.radioButton_21_3.setVisible(val)
 
             for k in [4, 5, 6, 12]:
+                name = 'openGLWidget_' + str(k)
                 slider = getattr(self, 'horizontalSlider_' + str(k))
                 label = getattr(self, 'label_' + str(k))
                 label.setVisible(val)
                 slider.setVisible(val)
-
-                widget_name = 'openGLWidget_' + str(k)
-                widget = getattr(self, widget_name)
+                widget = getattr(self, name)
                 widget.setVisible(val)
-                widget.imType = 'mri'
+                widget.imType = imtype
 
         self.init_state()
 
@@ -6463,10 +6486,16 @@ QToolButton{margin: 2px 2px;}
             if not isinstance(fileObj, list):
                 fileObj = ['', '']
                 opts = QtWidgets.QFileDialog.DontUseNativeDialog
-                dialg = QFileDialogPreview(self, "Open File", self.source_dir, self._filters, options=opts,
+                dialg = QFileDialogPreview(self, "Open File", settings.DEFAULT_USE_DIR, self._filters, options=opts,
                                            index=self._last_index_select_image_mri, last_state=self._last_state_preview)
                 dialg.setFileMode(QtWidgets.QFileDialog.ExistingFile)
 
+                parent_size = self.size()
+                dialog_width = int(parent_size.width() * 0.6)
+                dialog_height = int(parent_size.height() * 0.7)
+                dialg.resize(dialog_width, dialog_height)
+
+
                 if dialg.exec_() == QFileDialogPreview.Accepted:
                     fileObj = dialg.getFileSelected()
                     fileObj[1] = dialg.selectedNameFilter()
@@ -6501,10 +6530,11 @@ QToolButton{margin: 2px 2px;}
 
         if hasattr(self, 'readImECO'):
             if hasattr(self.readImECO, 'npImage'):
-                for k in range(3):
-                    widget_name = 'openGLWidget_' + str(k + 1)
-                    widget = getattr(self, widget_name)
+                for k in [0,1,2]:
+                    name = 'openGLWidget_' + str(k + 1)
+                    widget = getattr(self, name)
                     widget.setVisible(True)
+
                 self.updateDispEco(self.readImECO.npImage, self.readImECO.npSeg, initialState=True)
 
         if use_dialog:
@@ -6587,15 +6617,16 @@ QToolButton{margin: 2px 2px;}
             if self.readImMRI.npImage is not None:
                 self.tabWidget.setTabVisible(3, True)
 
-                widgets_num = [0, 1, 2, 11]
+
                 widgets_num = [4, 5, 6, 11]
                 for k in widgets_num:
                     widget_name = 'openGLWidget_' + str(k)
                     widget = getattr(self, widget_name)
                     widget.resetInit()
                     widget.initialState()
-                    if 'Affine' in self.readImMRI.im_metadata:
-                        widget.affine = self.readImMRI.im_metadata['Affine']
+                    #if 'Affine' in self.readImMRI.im_metadata:
+                    #    widget.affine = self.readImMRI.im_metadata['Affine']
+                    widget.affine = getattr(self.readImMRI, "im_metadata", {}).get("Affine", widget.affine)
 
                 self.updateDispMRI(self.readImMRI.npImage, self.readImMRI.npSeg, initialState=True,
                                    tract=self.readImMRI.tract)
@@ -6603,7 +6634,7 @@ QToolButton{margin: 2px 2px;}
                 self.reset_page1_mri()
 
                 if use_dialog:
-                    self.setCurrentCoordsystem()
+
                     self.HistImage.UpdateName(None, self.filenameMRI)
                     self.iminfo_dialog.UpdateName(None, self.filenameMRI)
                     info1, color1 = [[[fileObj[0]], fileObj[1]], 2, 1], [1, 1, 0]
@@ -6632,16 +6663,10 @@ QToolButton{margin: 2px 2px;}
 
         self.activateGuidelines(self._last_state_guide_lines)
 
-        if self.BE_DL.isVisible():
-            self.updateDataBEDL(index=0)
-        else:
-            self.BE_DL.clear()
-
-        if self.Tissue_Seg.isVisible():
-            self.updateDataBEDL(index=1)
-        else:
-            self.Tissue_Seg.clear()
 
+        for plugin in self.plugin_widgets:
+            data_context = self.get_current_image_data()
+            plugin.update_data_context(data_context)
         for ind in range(2):
             save_var = '_immri_bedl_{}'.format(ind)
             save_var_seg = '_immri_bedl_seg_{}'.format(ind)
@@ -6649,7 +6674,7 @@ QToolButton{margin: 2px 2px;}
             setattr(self, save_var_seg, None)
 
         return True
-
+        
     def warning_msgbox(self, text= None): # warning message box
         if text is None:
             text = 'There is an error.'
@@ -6680,12 +6705,13 @@ QToolButton{margin: 2px 2px;}
             MessageBox.show()
 
     def readD(self, fileObj, type = 'eco', target_system='IPL'):
-
+        if '_loaded' in fileObj[1]:
+            return [], [False, False, 'No file']
         if fileObj[1] != '':
-
-            self.source_dir = dirname(fileObj[0])
+            self.settingsBN.update_use_dir(dirname(fileObj[0]))
+            matched_filter = get_filter_for_file(fileObj[0], self._filters)
             filters = self._filters.split(';;')
-            index_sel = filters.index(fileObj[1])
+            index_sel = filters.index(matched_filter)
             outfile_format = self._filters.split(';;')[index_sel].lower()
             filters[0], filters[index_sel] = filters[index_sel], filters[0]
             self._filters = ';;'.join(filters)
@@ -6702,16 +6728,16 @@ QToolButton{margin: 2px 2px;}
             try:
                 if type == 'eco':
                     if 'vol' in outfile_format: # Kretz data
-                        Info = readIM.readKretz(join(self.source_dir, filename))
+                        Info = readIM.readKretz(join(settings.DEFAULT_USE_DIR, filename))
                         format = 'VOL'
                     elif 'nii' in outfile_format: # read NIFTI
-                        Info = readIM.readNIFTI(join(self.source_dir, filename), type)
+                        Info = readIM.readNIFTI(join(settings.DEFAULT_USE_DIR, filename), type)
                         format = 'NIFTI'
                     elif 'nrrd' in outfile_format: # Read NRRD
-                        Info = readIM.readNRRD(join(self.source_dir, filename), type)
+                        Info = readIM.readNRRD(join(settings.DEFAULT_USE_DIR, filename), type)
                         format = 'NRRD'
                     elif 'dcm' in outfile_format: # READ DICOM
-                        Info = readIM.readDICOM(join(self.source_dir, filename), type)
+                        Info = readIM.readDICOM(join(settings.DEFAULT_USE_DIR, filename), type)
                         format = 'DICOM'
                     else:
                         Info = [False, False, 'No file']
@@ -6720,18 +6746,18 @@ QToolButton{margin: 2px 2px;}
 
                 else:
                     if 'vol' in outfile_format: # Kretz data
-                        Info = readIM.readKretz(join(self.source_dir, filename))
+                        Info = readIM.readKretz(join(settings.DEFAULT_USE_DIR, filename))
                         format = 'VOL'
                     elif 'nii' in outfile_format: # read NIFTI
-                        Info = readIM.readNIFTI(join(self.source_dir, filename), type)
+                        Info = readIM.readNIFTI(join(settings.DEFAULT_USE_DIR, filename), type)
                         format = 'NIFTI'
                     elif 'dicom' in outfile_format: # READ DICOM
-                        Info = readIM.readDICOM(join(self.source_dir, filename), type)
+                        Info = readIM.readDICOM(join(settings.DEFAULT_USE_DIR, filename), type)
                         format = 'DICOM'
                         if hasattr(readIM, '_fileDicom'):
                             self.filenameMRI = readIM._fileDicom
                     elif 'nrrd' in outfile_format: # Read NRRD
-                        Info = readIM.readNRRD(join(self.source_dir, filename), type)
+                        Info = readIM.readNRRD(join(settings.DEFAULT_USE_DIR, filename), type)
                         format = 'NRRD'
                     else:
                         Info = [False, False, 'No file']