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

assets/resource/color/LUT_30.txt

@@ -0,0 +1,31 @@
+#Index	R	G	B	Column1	Column2	Column3	Label
+0	0	0	0	1	1	1	Background
+1	0	0	255	1	1	1	GM
+2	245	0	245	1	1	1	Left-Cerebral-White-Matter
+3	0	256	255	1	1	1	Left-Lateral-Ventricle
+4	220	220	220	1	1	1	Left-Cerebellum-White-Matter
+5	205	205	205	1	1	1	Left-Cerebellum-Cortex
+6	200	0	0	1	1	1	Left-Thalamus
+7	255	100	100	1	1	1	Left-Caudate
+8	255	165	0	1	1	1	Left-Putamen
+9	255	215	0	1	1	1	Left-Pallidum
+10	0	0	255	1	1	1	3rd-Ventricle
+11	100	100	255	1	1	1	4th-Ventricle
+12	160	82	45	1	1	1	Brain-Stem
+13	138	43	226	1	1	1	Left-Hippocampus
+14	255	20	147	1	1	1	Left-Amygdala
+15	12	0	0	1	1	1	CSF
+16	128	0	128	1	1	1	Left-Accumbens-area
+17	0	255	255	1	1	1	Left-VentralDC
+18	245	0	245	1	1	1	Right-Cerebral-White-Matter
+19	0	128	255	1	1	1	Right-Lateral-Ventricle
+20	220	220	220	1	1	1	Right-Cerebellum-White-Matter
+21	205	205	205	1	1	1	Right-Cerebellum-Cortex
+22	200	0	0	1	1	1	Right-Thalamus
+23	255	100	100	1	1	1	Right-Caudate
+24	255	165	0	1	1	1	Right-Putamen
+25	255	215	0	1	1	1	Right-Pallidum
+26	138	43	226	1	1	1	Right-Hippocampus
+27	255	20	147	1	1	1	Right-Amygdala
+28	128	0	128	1	1	1	Right-Accumbens-area
+29	0	255	255	1	1	1	Right-VentralDC

assets/resource/color/SynthSeg.txt

@@ -0,0 +1,34 @@
+#Index	 #Color name	 R	 G	 B	 A	
+0	 Background	 0	 0	 0	 1	
+2	 Left-Cerebral-White-Matter	 245	 245	 245	 1	
+3	 Left-Cerebral-Cortex	 205	 62	 78	 1	
+4	 Left-Lateral-Ventricle	 120	 18	 134	 1	
+5	 Left-Inf-Lat-Vent	 196	 58	 250	 1	
+7	 Left-Cerebellum-White-Matter	 220	 248	 164	 1	
+8	 Left-Cerebellum-Cortex	 230	 148	 34	 1	
+10	 Left-Thalamus	 0	 118	 14	 1	
+11	 Left-Caudate	 122	 186	 220	 1	
+12	 Left-Putamen	 236	 13	 176	 1	
+13	 Left-Pallidum	 12	 48	 255	 1	
+14	 3rd-Ventricle	 204	 182	 142	 1	
+15	 4th-Ventricle	 42	 204	 164	 1	
+16	 Brain-Stem	 119	 159	 176	 1	
+17	 Left-Hippocampus	 220	 216	 20	 1	
+18	 Left-Amygdala	 103	 255	 255	 1	
+24	 CSF	 60	 60	 60	 1	
+26	 Left-Accumbens-Area	 255	 165	 0	 1	
+28	 Left-Ventral-DC	 165	 42	 42	 1	
+41	 Right-Cerebral-White-Matter	 0	 225	 0	 1	
+42	 Right-Cerebral-Cortex	 205	 62	 78	 1	
+43	 Right-Lateral-Ventricle	 120	 18	 134	 1	
+44	 Right-Inf-Lat-Vent	 196	 58	 250	 1	
+46	 Right-Cerebellum-White-Matter	 220	 248	 164	 1	
+47	 Right-Cerebellum-Cortex	 230	 148	 34	 1	
+49	 Right-Thalamus	 0	 118	 14	 1	
+50	 Right-Caudate	 122	 186	 220	 1	
+51	 Right-Putamen	 236	 13	 176	 1	
+52	 Right-Pallidum	 12	 48	 255	 1	
+53	 Right-Hippocampus	 220	 216	 20	 1	
+54	 Right-Amygdala	 103	 255	 255	 1	
+58	 Right-Accumbens-Area	 255	 165	 0	 1	
+60	 Right-Ventral-DC	 165	 42	 42	 1

resource/color/Simple.txt → assets/resource/color/lut_prostate.txt

@@ -1,18 +1,20 @@
-################################################
-# ITK-SnAP Label Description File
-# File format: 
-# IDX   -R-  -G-  -B-  -A--  VIS MSH  LABEL
-# Fields: 
-#    IDX:   Zero-based index 
-#    -R-:   Red color component (0..255)
-#    -G-:   Green color component (0..255)
-#    -B-:   Blue color component (0..255)
-#    -A-:   Label transparency (0.00 .. 1.00)
-#    VIS:   Label visibility (0 or 1)
-#    IDX:   Label mesh visibility (0 or 1)
-#  LABEL:   Label description 
-################################################
-    0     0    0    0        0  0  0    "Clear Label"
-    1   255  255    0        1  1  1    "Brain"
-    2     0  255  255        1  1  1    "Ventricles"
-    3   255    0  255        1  1  1    "Thalamus"
+################################################
+# ITK-SnAP Label Description File
+# File format: 
+# IDX   -R-  -G-  -B-  -A--  VIS MSH  LABEL
+# Fields: 
+#    IDX:   Zero-based index 
+#    -R-:   Red color component (0..255)
+#    -G-:   Green color component (0..255)
+#    -B-:   Blue color component (0..255)
+#    -A-:   Label transparency (0.00 .. 1.00)
+#    VIS:   Label visibility (0 or 1)
+#    IDX:   Label mesh visibility (0 or 1)
+#  LABEL:   Label description 
+################################################
+    0     0    0    0        0  0  0    "Clear Label"
+    1   255  0    0        1  1  1    "Peripheral Zone"
+    2     0  255  0        1  1  1    "Central Zone"
+    3   0    0  255        1  1  1    "Transitional Zone"
+    4   255    255  0        1  1  1    "Anterior Stroma"
+    5   255    255  1        1  1  1    "Urethra"

assets/resource/theme/create_ticks.py

@@ -0,0 +1,85 @@
+from PIL import Image, ImageDraw
+
+# --- Configuration ---
+# You can change these colors and sizes to match your application's theme
+CONFIG = {
+    "size": 16,  # Standard resolution size
+    "colors": {
+        "border": (100, 100, 100),
+        "fill_checked": (40, 120, 255),
+        "fill_pressed": (200, 200, 200),
+        "checkmark": (255, 255, 255),
+        "indeterminate_mark": (255, 255, 255),
+        "focus_glow": (70, 150, 255),
+        "disabled_border": (180, 180, 180),
+        "disabled_fill": (220, 220, 220),
+        "disabled_mark": (140, 140, 140),
+    }
+}
+
+
+def create_checkbox_icon(filename, size, state, sub_state):
+    """Generates and saves a single checkbox icon image."""
+    img = Image.new('RGBA', (size, size), (0, 0, 0, 0))  # Transparent background
+    draw = ImageDraw.Draw(img)
+    c = CONFIG["colors"]
+
+    # Define coordinates for the box
+    box = [(2, 2), (size - 3, size - 3)]
+
+    # --- Draw Focus Glow (if applicable) ---
+    if sub_state == "focus":
+        draw.rectangle([(0, 0), (size - 1, size - 1)], fill=None, outline=c["focus_glow"], width=2)
+
+    # --- Determine Colors based on Disabled State ---
+    border_color = c["disabled_border"] if sub_state == "disabled" else c["border"]
+    fill_color = c["fill_checked"]
+    mark_color = c["checkmark"]
+
+    if sub_state == "disabled":
+        fill_color = c["disabled_fill"]
+        mark_color = c["disabled_mark"]
+
+    # --- Draw Box and Fill based on State ---
+    bg_fill = c["fill_pressed"] if sub_state == "pressed" else None
+
+    if state == "checked":
+        draw.rectangle(box, fill=fill_color, outline=border_color, width=1)
+    else:
+        draw.rectangle(box, fill=bg_fill, outline=border_color, width=1)
+
+    # --- Draw Mark (Checkmark or Dash) ---
+    if state == "checked":
+        # Checkmark points
+        p1 = (size * 0.25, size * 0.5)
+        p2 = (size * 0.45, size * 0.7)
+        p3 = (size * 0.75, size * 0.3)
+        draw.line([p1, p2, p3], fill=mark_color, width=int(size * 0.12))
+
+    elif state == "indeterminate":
+        # Indeterminate dash
+        dash_y = size / 2
+        draw.line([(size * 0.25, dash_y), (size * 0.75, dash_y)], fill=mark_color if state == "checked" else fill_color,
+                  width=int(size * 0.12))
+
+    img.save(filename)
+
+
+if __name__ == '__main__':
+    # List of all states and sub-states to generate
+    states = ["unchecked", "checked", "indeterminate"]
+    sub_states = ["", "_focus", "_pressed", "_disabled"]
+
+    print("Generating checkbox images...")
+
+    for state in states:
+        for sub_state_str in sub_states:
+            # Standard resolution
+            filename_std = f"checkbox_{state}{sub_state_str}.png"
+            create_checkbox_icon(filename_std, CONFIG["size"], state, sub_state_str.strip("_"))
+
+            # High resolution (@2x)
+            filename_2x = f"checkbox_{state}{sub_state_str}@2x.png"
+            create_checkbox_icon(filename_2x, CONFIG["size"] * 2, state, sub_state_str.strip("_"))
+
+    print("Generation complete.")

melage/__init__.py

@@ -11,6 +11,6 @@ sys.path.append(current_directory)
 from . import utils
 from . import widgets
 from . import widgets
-from .cli import main
+from .melage import main
 __version__ = '0.1.1'
 

melage/config/__init__.py

@@ -0,0 +1,100 @@
+import json
+import os
+from pathlib import Path
+from sys import platform
+
+ADULT_WEIGHTS_FILE = 'New_model_latest_SegMulti_current.pth'
+INFANT_WEIGHTS_FILE = 'New_model_latest_SegMulti_current_neo.pth'
+VERSION = '2.1.1'
+VERSION_DATE = 'Nov 4 2025'
+class SettingsManager:
+    """
+    A singleton class to manage all application settings.
+    It loads defaults, overrides them with user-saved settings,
+    and provides a central point for saving changes.
+    """
+    _instance = None
+
+    @staticmethod
+    def instance():
+        """Returns the single instance of the SettingsManager."""
+        if SettingsManager._instance is None:
+            SettingsManager._instance = SettingsManager()
+        return SettingsManager._instance
+
+    def __init__(self):
+        if SettingsManager._instance is not None:
+            raise Exception("This class is a singleton! Use instance().")
+
+        # --- 1. Define Application-Relative Paths (Should NOT change) ---
+        # We go up two levels: config.py -> melage -> Project Root
+        self.APP_ROOT = Path(__file__).resolve().parent.parent.parent
+        self.ASSETS_DIR = self.APP_ROOT / "assets"
+        self.RESOURCE_DIR = self.ASSETS_DIR / "resource"
+        self.DOCS_DIR = self.APP_ROOT / "docs"
+        self.DEFAULT_MODELS_DIR = self.APP_ROOT / "models" / "NetworkWeights"
+        self.DATA_DIR = self.APP_ROOT / "data"  # e.g., for MNI templates
+        self.PLUGIN_DIR = self.APP_ROOT / "melage"/"plugins"
+
+        self.SCHEME_DIR = str(self.RESOURCE_DIR / "color")
+        self.APP_ROOT = str(self.APP_ROOT)
+        self.ASSETS_DIR = str(self.ASSETS_DIR)
+        self.RESOURCE_DIR = str(self.RESOURCE_DIR)
+        self.DOCS_DIR = str(self.DOCS_DIR)
+        self.DEFAULT_MODELS_DIR = str(self.DEFAULT_MODELS_DIR)
+        self.DATA_DIR = str(self.DATA_DIR)
+
+        # --- 2. Define User-Configurable Settings (with defaults) ---
+        self.auto_save_interval = 10.0
+        #self.models_dir = self.DEFAULT_MODELS_DIR
+
+        if platform == "linux" or platform == "linux2" or platform == "darwin":
+            default_user_dir = Path.home() / "Desktop"
+        else:
+            default_user_dir = Path(os.environ['USERPROFILE']) / "Desktop"
+
+        self.DEFAULT_USE_DIR = str(default_user_dir)
+
+        # --- 3. Define Settings File Path ---
+        # This stores user preferences
+        self.settings_file = Path.home() / ".melage_settings.json"
+
+        # --- 4. Load saved settings ---
+        self.load()
+
+    def load(self):
+        """Loads settings from the JSON file, if it exists."""
+        if not self.settings_file.exists():
+            return  # No settings saved yet, use defaults
+
+        try:
+            with open(self.settings_file, 'r') as f:
+                saved_settings = json.load(f)
+
+            # Update instance variables with saved values
+            self.auto_save_interval = saved_settings.get('auto_save_interval', self.auto_save_interval)
+            self.DEFAULT_MODELS_DIR = str(Path(saved_settings.get('DEFAULT_MODELS_DIR', self.DEFAULT_MODELS_DIR)))
+            self.DEFAULT_USE_DIR = str(Path(saved_settings.get('DEFAULT_USE_DIR', self.DEFAULT_USE_DIR)))
+
+        except Exception as e:
+            print(f"Error loading settings: {e}. Using defaults.")
+
+    def save(self):
+        """Saves the current settings to the JSON file."""
+        settings_to_save = {
+            'auto_save_interval': self.auto_save_interval,
+            'DEFAULT_MODELS_DIR': str(self.DEFAULT_MODELS_DIR),
+            'DEFAULT_USE_DIR': str(self.DEFAULT_USE_DIR),
+        }
+
+        try:
+            with open(self.settings_file, 'w') as f:
+                json.dump(settings_to_save, f, indent=4)
+        except Exception as e:
+            print(f"Error saving settings: {e}")
+
+
+# --- Global Instance ---
+# Any file in your project can now just `from melage.config import settings`
+# to get the one and only settings object.
+settings = SettingsManager.instance()

melage/core/Registration/registration.py

@@ -0,0 +1,54 @@
+import sys
+from PyQt5 import QtWidgets, QtCore, QtGui
+
+
+class RobustCheckTreeDemo(QtWidgets.QMainWindow):
+    def __init__(self):
+        super().__init__()
+        self.setWindowTitle("Signal/Slot Checkbox Demo")
+        self.setGeometry(100, 100, 400, 300)
+
+        # Use the standard QTreeView, no subclassing needed for this
+        self.tree_view = QtWidgets.QTreeView()
+        self.model = QtGui.QStandardItemModel()
+        self.tree_view.setModel(self.model)
+        self.model.setHorizontalHeaderLabels(['Status', 'ID'])
+        self.setCentralWidget(self.tree_view)
+
+        self.populate_data()
+
+        # 1. Connect the view's 'clicked' signal to our logic function
+        self.tree_view.clicked.connect(self.on_row_clicked)
+
+    def populate_data(self):
+        """Adds items with flags set to disable the default toggle behavior."""
+        root = self.model.invisibleRootItem()
+        for i in range(5):
+            item_status = QtGui.QStandardItem(f"{i + 1}")
+            item_status.setCheckable(True)
+
+            # 2. Disable the automatic toggle to give our slot full control
+            flags = item_status.flags() & QtCore.Qt.ItemIsUserCheckable
+            item_status.setFlags(flags)
+
+            root.appendRow([item_status, QtGui.QStandardItem(f"ID-{100 + i}")])
+
+    @QtCore.pyqtSlot(QtCore.QModelIndex)
+    def on_row_clicked(self, index):
+        """
+        This slot is triggered by a click and safely toggles the item's state.
+        """
+        # 3. Get the item in the first column, which has the checkbox
+        item = self.model.itemFromIndex(index.sibling(index.row(), 0))
+
+        if item and item.isCheckable():
+            # 4. Manually toggle the state
+            new_state = QtCore.Qt.Unchecked if item.checkState() == QtCore.Qt.Checked else QtCore.Qt.Checked
+            item.setCheckState(new_state)
+
+
+if __name__ == '__main__':
+    app = QtWidgets.QApplication(sys.argv)
+    window = RobustCheckTreeDemo()
+    window.show()
+    sys.exit(app.exec_())

melage/{utils/readData.py → core/io.py}

@@ -32,6 +32,7 @@ class readData():
         self.metadata = {}
         self.npEdge = []
         self._npSeg = None
+        self._num_dims = 3
         self.type = type
         #if type=='t1':
         #    self.target_system = target_system#'IPL'
@@ -762,8 +763,8 @@ class readData():
         minSpacing = 1.0#np.min(spacing)
         self.set_metadata()
 
-        if max(abs(np.min(spacing)-spacing))/3.0> 0.01: # check if need resampling
-            self._resampling(spacing, minSpacing)
+        #if max(abs(np.min(spacing)-spacing))/3.0> 0.01: # check if need resampling
+        #    self._resampling(spacing, minSpacing)
 
         transform, self.source_system = convert_to_ras(self.im.affine, target=self.target_system)
         self.header = self.im.header
@@ -787,7 +788,8 @@ class readData():
             imsg = ims.get_fdata()
             imsg = imsg.view((imsg.dtype[0], len(imsg.dtype.names)))
             ims = nib.Nifti1Image(imsg, ims.affine, ims.header)
-
+        if ims.ndim>4:
+            ims = nib.Nifti1Image(ims.get_fdata().squeeze(), ims.affine, ims.header)
         self.ims = ims
 
         if self.ims.ndim==4:
@@ -826,13 +828,17 @@ class readData():
         self.read_pars()
         return [found_meta_data, found_image_data, 'Success']
 
-    def read_pars(self, reset_seg=True, adjust_for_show=True):
+
+    def read_pars(self, reset_seg=True, adjust_for_show=True, im_new = None, seg_new=None):
         """
 
         :param reset_seg: if True segmentation is removed
         :return:
         """
         # assing image parameters
+        if im_new is not None:
+            self.im = im_new
+            self._read_sub_nifti()
         self._imChanged = self.im.__class__(self.im.dataobj[:], self.im.affine, self.im.header)
 
         #self.affine, shape = get_affine_shape(self.im)
@@ -854,6 +860,8 @@ class readData():
         self.npImage = normalize_mri(data).astype(np.uint8)
         if reset_seg:
             self.npSeg = np.zeros_like(self.npImage).astype('int')
+        elif seg_new is not None:
+            self.npSeg = seg_new
         #self.npEdge = np.empty((0,3))
 
         self.ImDirection = nib.aff2axcodes(self.im.affine)

melage/{widgets/melageAbout.py → dialogs/AboutDialog.py}

@@ -6,7 +6,7 @@ from PyQt5.QtMultimedia import QMediaContent, QMediaPlayer, QMediaPlaylist
 from PyQt5.QtMultimediaWidgets import QVideoWidget
 from PyQt5.QtCore import QUrl
 import os
-from melage.utils.source_folder import *
+from melage.config import *
 class about_dialog(QtWidgets.QDialog):
     """
     This calss has been implemented to show image info

melage/dialogs/MaskOperationsDialog.py

@@ -0,0 +1,146 @@
+# -*- coding: utf-8 -*-
+"""
+__AUTHOR__ = 'Bahram Jafrasteh'
+Refactored Code: This script has been improved to offer a clearer user
+interface, cleaner code, and more robust logic for mask operations.
+"""
+import sys
+from typing import List
+
+from PyQt5 import QtCore, QtGui, QtWidgets
+from PyQt5.QtCore import pyqtSignal, Qt
+
+
+class MaskOperationsDialog(QtWidgets.QDialog):
+    """
+    A dialog for performing simple arithmetic operations (+, -) between two masks.
+    """
+    # Emits [view_index, mask1_index, mask2_index, operation_str]
+    apply_pressed = pyqtSignal(list)
+    closeSig = pyqtSignal()
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setupUi()
+        self.connect_signals()
+
+        # Ensure the dialog is properly deleted when closed to free memory
+        #self.setAttribute(Qt.WA_DeleteOnClose)
+
+    def setupUi(self):
+        """Creates and arranges all the UI widgets."""
+        self.setWindowTitle("Mask Operations")
+        self.setMinimumSize(450, 150)
+
+        # --- Main Layout ---
+        main_layout = QtWidgets.QVBoxLayout(self)
+
+        # --- Options Widgets ---
+        options_group = QtWidgets.QGroupBox("Operation")
+        options_layout = QtWidgets.QHBoxLayout(options_group)
+
+        self.mask1_combo = QtWidgets.QComboBox()
+        self.mask2_combo = QtWidgets.QComboBox()
+        self.operation_combo = QtWidgets.QComboBox()
+        self.operation_combo.addItems(["+", "-"])
+        self.operation_combo.setFixedWidth(50)  # Keep the operation box small
+
+        # Add widgets to the horizontal layout to create the "Mask1 + Mask2" look
+        options_layout.addWidget(self.mask1_combo)
+        options_layout.addWidget(self.operation_combo)
+        options_layout.addWidget(self.mask2_combo)
+
+        # --- View Selector ---
+        view_layout = QtWidgets.QFormLayout()
+        self.view_combo = QtWidgets.QComboBox()
+        self.view_combo.addItems(["View 1", "View 2"])
+        view_layout.addRow("Apply to View:", self.view_combo)
+
+        # --- Buttons ---
+        self.apply_button = QtWidgets.QPushButton("Apply")
+        self.apply_button.setDefault(True)
+
+        # Use a standard button box for consistent button placement (Apply/Cancel)
+        button_box = QtWidgets.QDialogButtonBox(
+            QtWidgets.QDialogButtonBox.Apply
+        )
+
+        # --- Assemble the Main Layout ---
+        main_layout.addLayout(view_layout)
+        main_layout.addWidget(options_group)
+        main_layout.addStretch()  # Add space
+        main_layout.addWidget(button_box)
+
+    def connect_signals(self):
+        """Connects widget signals to their corresponding slots."""
+        button_box = self.findChild(QtWidgets.QDialogButtonBox)
+        button_box.accepted.connect(self.on_apply)
+        button_box.rejected.connect(self.reject)
+
+    def set_color_options(self, mask_names: List[str]):
+        """
+        Populates both mask selection comboboxes with a list of names.
+
+        Args:
+            mask_names (List[str]): A list of strings representing mask names.
+        """
+        self.mask1_combo.clear()
+        self.mask2_combo.clear()
+
+        self.mask1_combo.addItems(mask_names)
+        self.mask2_combo.addItems(mask_names)
+
+    @QtCore.pyqtSlot()
+    def on_apply(self):
+        """
+        Gathers user selections, validates them, and emits the result.
+        """
+        view_index = self.view_combo.currentIndex()
+        mask1_index = self.mask1_combo.currentIndex()
+        mask2_index = self.mask2_combo.currentIndex()
+        operation = self.operation_combo.currentText()
+
+        # --- Validation ---
+        if mask1_index == mask2_index:
+            self.show_warning_message(
+                "Cannot perform an operation on the same mask. Please select two different masks.")
+            return  # Stop the process
+
+        # --- Emit Signal ---
+        self.apply_pressed.emit([view_index, mask1_index, mask2_index, operation])
+        self.accept()  # Close the dialog with an "OK" status
+
+    def show_warning_message(self, message: str):
+        """Displays a non-critical warning message to the user."""
+        QtWidgets.QMessageBox.warning(self, "Validation Error", message)
+
+    def closeEvent(self, event: QtGui.QCloseEvent):
+        """Emits a signal when the dialog is closed by the user."""
+        self.closeSig.emit()
+        super().closeEvent(event)
+
+
+# --- Example of how to use the dialog ---
+def run_example():
+    app = QtWidgets.QApplication(sys.argv)
+
+    window = MaskOperationsDialog()
+
+    # Populate the mask options
+    available_masks = ["Brain Mask", "Tumor Segmentation", "Ventricles"]
+    window.set_mask_options(available_masks)
+
+    def handle_results(params: list):
+        view, idx1, idx2, op = params
+        print("Applying operation with the following settings:")
+        print(f"  - View: {view + 1}")
+        print(f"  - Formula: {available_masks[idx1]} {op} {available_masks[idx2]}")
+
+    window.apply_pressed.connect(handle_results)
+
+    window.show()
+    sys.exit(app.exec_())
+
+
+if __name__ == '__main__':
+    run_example()