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

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()

melage/dialogs/MaskingDialog.py

@@ -0,0 +1,139 @@
+# -*- coding: utf-8 -*-
+"""
+__AUTHOR__ = 'Bahram Jafrasteh'
+Refactored Code: This script has been cleaned up for better readability,
+simpler UI management, and adherence to modern PyQt practices.
+"""
+import sys
+from typing import List
+
+from PyQt5 import QtCore, QtGui, QtWidgets
+from PyQt5.QtCore import pyqtSignal
+
+
+class Masking(QtWidgets.QDialog):
+    """
+    A dialog to get user choices for applying a segmentation mask.
+
+    It emits the selected view, color index, and whether to keep or remove
+    the masked area.
+    """
+    # Emits [view_index, color_index, keep_flag]
+    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(QtCore.Qt.WA_DeleteOnClose)
+
+    def setupUi(self):
+        """Creates and arranges all the UI widgets."""
+        self.setWindowTitle("Apply Mask")
+        self.setMinimumSize(400, 150)
+
+        # --- Main Layout ---
+        main_layout = QtWidgets.QVBoxLayout(self)
+
+        # --- Options Form ---
+        options_layout = QtWidgets.QFormLayout()
+        options_layout.setContentsMargins(10, 10, 10, 10)
+
+        # Widget for selecting the view
+        self.view_combo = QtWidgets.QComboBox()
+        self.view_combo.addItems(["View 1", "View 2"])
+
+        # Widget for choosing to keep or remove the mask
+        self.action_combo = QtWidgets.QComboBox()
+        self.action_combo.addItems(["Keep", "Remove"])
+
+        # Widget for selecting the mask color/label
+        self.color_combo = QtWidgets.QComboBox()
+
+        # Add widgets to the form layout for a clean, aligned look
+        options_layout.addRow("View:", self.view_combo)
+        options_layout.addRow("Action:", self.action_combo)
+        options_layout.addRow("Mask Color:", self.color_combo)
+
+        # --- Buttons ---
+        self.apply_button = QtWidgets.QPushButton("Apply")
+        self.apply_button.setDefault(True)
+
+        # Use a standard button box for consistent button placement
+        button_box = QtWidgets.QDialogButtonBox()
+        button_box.addButton(self.apply_button, QtWidgets.QDialogButtonBox.AcceptRole)
+
+        # --- Assemble the Main Layout ---
+        main_layout.addLayout(options_layout)
+        main_layout.addWidget(button_box)
+
+    def connect_signals(self):
+        """Connects widget signals to their corresponding slots."""
+        self.apply_button.clicked.connect(self.on_apply)
+
+    def set_color_options(self, color_names: List[str]):
+        """
+        Populates the color selection combobox with a list of names.
+
+        Args:
+            color_names (List[str]): A list of strings representing color or label names.
+        """
+        self.color_combo.clear()
+        self.color_combo.addItems(color_names)
+
+    @QtCore.pyqtSlot()
+    def on_apply(self):
+        """
+        Gathers user selections and emits them in a signal.
+        """
+        view_index = self.view_combo.currentIndex()
+        color_index = self.color_combo.currentIndex()
+
+        # Determine if the user chose to keep the mask area
+        keep_flag = self.action_combo.currentText().lower() == 'keep'
+
+        # Emit all selections in a single list
+        self.apply_pressed.emit([view_index, color_index, keep_flag])
+
+        # Optionally close the dialog after applying
+        self.accept()
+
+    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)
+
+    # Create the dialog window
+    window = Masking()
+
+    # Populate the color options
+    available_colors = ["Region 1 (Red)", "Region 2 (Green)", "Region 3 (Blue)"]
+    window.set_color_options(available_colors)
+
+    # Define a function to receive the results from the dialog
+    def handle_results(params: list):
+        view, color, keep = params
+        action = "Keep" if keep else "Remove"
+        print(f"Applying mask with the following settings:")
+        print(f"  - View Index: {view}")
+        print(f"  - Color/Label Index: {color} ({available_colors[color]})")
+        print(f"  - Action: {action}")
+
+    # Connect the dialog's signal to our handler function
+    window.buttonpressed.connect(handle_results)
+
+    # Show the dialog
+    window.show()
+    sys.exit(app.exec_())
+
+
+if __name__ == '__main__':
+    run_example()

melage/dialogs/RegistrationDialog.py

@@ -0,0 +1,311 @@
+import sys
+import os
+import ants
+from PyQt5 import QtWidgets, QtCore, QtGui
+from typing import Literal, Optional, Tuple
+#from MELAGE.utils.source_folder import *
+from PyQt5.QtCore import pyqtSignal
+from pathlib import Path
+
+MNI_FILE = 'mni_icbm152_t1_tal_nlin_sym_09a_masked.nii.gz'
+
+class StreamRedirector(QtCore.QObject):
+    textWritten = QtCore.pyqtSignal(str)
+
+    def write(self, text):
+        self.textWritten.emit(str(text))
+        # Force the GUI to process events to update the text box in real-time
+        QtWidgets.QApplication.processEvents()
+
+    def flush(self):
+        # This flush method is needed for stream-like objects
+        pass
+
+def run_ants_registration(
+    fixed_path: str,
+    moving_path: str,
+    output_prefix: str,
+    transform_type: Literal['Rigid', 'Affine', 'SyN'] = 'SyN'
+) -> dict:
+    """
+    Performs image registration using ANTsPy with robust default parameters.
+    """
+    print("--- Starting ANTs Registration ---")
+    print(f"Fixed Image: {fixed_path}")
+    print(f"Moving Image: {moving_path}")
+    print(f"Transform Type: {transform_type}")
+
+    fixed_image = ants.image_read(fixed_path, pixeltype='float')
+    moving_image = ants.image_read(moving_path, pixeltype='float')
+
+
+    registration = ants.registration(
+        fixed=fixed_image,
+        moving=moving_image,
+        type_of_transform=transform_type,
+        outprefix=output_prefix,
+        verbose=True
+    )
+    """
+
+    registration = ants.registration(
+        fixed=fixed_image,
+        moving=moving_image,
+        type_of_transform=transform_type,  # Affine includes Rigid + Affine transformations in one step
+        reg_iterations=[1000, 500, 250, 100],  # Corresponds to your iterations [1000x500x250x100]
+        grad_step=0.01,  # Corresponds to the gradient step size [Rigid[0.01], Affine[0.01]]
+        aff_sampling=32,  # Corresponds to the MI sampling points [1,32,Regular,0.25]
+        metric='MI',  # Mutual Information
+        metric_params=[1, 32],  # Matches MI[${file_in_atlas},${file_in_t1},1,32,Regular,0.25]
+        smoothing_sigmas=(3, 2, 1, 0),  # Smoothing at different resolutions
+        shrink_factors=(8, 4, 2, 1),  # Downsampling at different resolutions
+        transform_parameters=(0.01,),  # Corresponds to transform step size for Rigid and Affine
+        output_prefix=output_prefix,
+        verbose = True
+    )
+    """
+
+
+    print(f"--- Registration Complete ---")
+    file_out = output_prefix+'warped.nii.gz'
+    print(f'Transofrmed file {file_out}')
+    print(f"Forward Transforms: {registration['fwdtransforms']}")
+    ants.image_write(registration['warpedmovout'], file_out)
+    return registration, file_out
+
+
+# --- PyQt5 Frontend (Updated) ---
+
+class RegistrationDialog(QtWidgets.QDialog):
+    """
+    A PyQt5 dialog for performing image-to-image registration using ANTsPy.
+    """
+    closeSig = pyqtSignal()
+    datachange = pyqtSignal()
+    def __init__(self, parent=None, source_dir=os.path.expanduser("~")):
+        super().__init__(parent)
+        self.source_dir = source_dir
+        self.fixed_path = None
+        self.moving_path = None
+        self.output_prefix = None
+        #self.mni_template_path = ants.get_ants_data('mni') # Get MNI path once
+        self._curent_weight_dir = os.path.dirname(os.path.join(os.getcwd()))
+        self._setup_ui()
+
+    def _setup_ui(self):
+        self.setWindowTitle("ANTs Image Registration")
+        self.setMinimumSize(650, 250)
+        self._create_widgets()
+        self._create_layouts()
+        self._connect_signals()
+
+        # Set initial UI state
+        self._toggle_mni_template(False)
+        self.combobox_methods.setCurrentIndex(2)
+
+    def _create_widgets(self):
+        # --- Updated MNI Template Widgets ---
+        self.toggle_log_button = QtWidgets.QPushButton("Show Verbose Output ▶")
+        self.toggle_log_button.setCheckable(True)
+        self.toggle_log_button.setChecked(False)
+        # Style the button to look like a section header
+        self.toggle_log_button.setStyleSheet("""
+            QPushButton {
+                text-align: left; padding: 5px; background-color: #E0E0E0;
+                border: 1px solid #C0C0C0; border-radius: 4px;
+                color: green; /* Default text color */
+            }
+            QPushButton:checked {
+                background-color: #D0D0D0;
+                color: red; /* Text color when button is checked */
+            }
+        """)
+        self.log_stack = QtWidgets.QStackedWidget()
+
+        self.log_output = QtWidgets.QPlainTextEdit()
+        self.log_output.setReadOnly(True)
+        self.log_output.setStyleSheet("background-color: #2b2b2b; color: #f0f0f0; font-family: Monospace;")
+        self.log_output.setVisible(True)
+
+        self.check_use_mni = QtWidgets.QCheckBox("Use standard MNI152 template as Fixed Image")
+        self.lineEdit_fixed = QtWidgets.QLineEdit()
+        self.lineEdit_fixed.setReadOnly(True)
+        self.button_fixed = QtWidgets.QPushButton("Browse...")
+
+        self.label_moving = QtWidgets.QLabel("<b>Moving Image:</b>")
+        self.lineEdit_moving = QtWidgets.QLineEdit("Select subject's image...")
+        self.lineEdit_moving.setReadOnly(True)
+        self.button_moving = QtWidgets.QPushButton("Browse...")
+
+        self.label_output = QtWidgets.QLabel("<b>Output Prefix:</b>")
+        self.lineEdit_output = QtWidgets.QLineEdit("Select output location and prefix...")
+        self.lineEdit_output.setReadOnly(True)
+        self.button_output = QtWidgets.QPushButton("Save As...")
+
+        self.label_method = QtWidgets.QLabel("<b>Method:</b>")
+        self.combobox_methods = QtWidgets.QComboBox()
+        self.combobox_methods.addItems(['Rigid', 'Affine', 'SyN'])
+
+
+        self.button_run = QtWidgets.QPushButton("Run Registration")
+        self.button_run.setStyleSheet("background-color: #4CAF50; color: white; font-weight: bold; padding: 5px;")
+
+
+
+    def _create_layouts(self):
+        main_layout = QtWidgets.QVBoxLayout(self)
+        grid_layout = QtWidgets.QGridLayout()
+        grid_layout.setSpacing(10)
+
+        grid_layout.addWidget(self.check_use_mni, 0, 0, 1, 4)
+        grid_layout.addWidget(self.lineEdit_fixed, 1, 0, 1, 3)
+        grid_layout.addWidget(self.button_fixed, 1, 3)
+
+        grid_layout.addWidget(self.label_moving, 2, 0)
+        grid_layout.addWidget(self.lineEdit_moving, 2, 1, 1, 2)
+        grid_layout.addWidget(self.button_moving, 2, 3)
+
+        grid_layout.addWidget(self.label_output, 3, 0)
+        grid_layout.addWidget(self.lineEdit_output, 3, 1, 1, 2)
+        grid_layout.addWidget(self.button_output, 3, 3)
+
+        method_layout = QtWidgets.QHBoxLayout()
+        method_layout.addWidget(self.label_method)
+        method_layout.addWidget(self.combobox_methods)
+        method_layout.addStretch()
+        grid_layout.addLayout(method_layout, 4, 1)
+
+
+
+        self.log_stack.addWidget(QtWidgets.QWidget()) # Page 0: Empty widget for "collapsed"
+        self.log_stack.addWidget(self.log_output)     # Page 1: The log viewer
+
+        # Add components to the main vertical layout
+        main_layout.addLayout(grid_layout)
+        main_layout.addWidget(self.button_run)
+        main_layout.addWidget(self.toggle_log_button) # Add the toggle button
+        main_layout.addWidget(self.log_stack)
+        main_layout.addStretch(1)
+        self.setLayout(main_layout)
+
+    # This is the new slot that will receive text from the redirector
+    @QtCore.pyqtSlot(str)
+    def _append_log_text(self, text):
+        """Appends text to the log viewer."""
+        self.log_output.insertPlainText(text)
+        self.log_output.verticalScrollBar().setValue(self.log_output.verticalScrollBar().maximum())
+
+
+    def _connect_signals(self):
+        self.toggle_log_button.toggled.connect(self._animate_log_toggle)
+        self.button_fixed.clicked.connect(self._browse_fixed)
+        self.button_moving.clicked.connect(self._browse_moving)
+        self.button_output.clicked.connect(self._browse_output)
+        self.button_run.clicked.connect(self._run_registration)
+        self.check_use_mni.toggled.connect(self._toggle_mni_template)
+
+    def _animate_log_toggle(self, checked):
+        """Animates the expansion and collapse of the log container."""
+        # The animation now targets the container, not the text box itself
+        #animation = QtCore.QPropertyAnimation(self.log_container, b"maximumHeight")
+        #animation.setDuration(300)
+
+        if checked:
+            self.log_stack.setCurrentIndex(1) # Show log viewer page
+            self.toggle_log_button.setText("Hide Progress ▼")
+        else:
+            self.log_stack.setCurrentIndex(0) # Show empty page
+            self.toggle_log_button.setText("Show Progress ▶")
+
+
+    def set_source(self, source_dir):
+        self.source_dir = source_dir
+
+    def _toggle_mni_template(self, checked: bool):
+        """Handles using the built-in MNI template."""
+        if checked:
+            try:
+                current_dir = Path(__file__).parent
+                project_root = (current_dir / "../").resolve()
+                mni_file_path = project_root / "MNI" / MNI_FILE
+                self.fixed_path = str(mni_file_path)
+            except Exception:
+                self.fixed_path = []
+                print("Warning: Could not determine model file paths automatically.")
+                return
+            self.lineEdit_fixed.setText(self.fixed_path)
+            self.button_fixed.setEnabled(False)
+        else:
+            self.fixed_path = None
+            self.lineEdit_fixed.setText("Select custom fixed image...")
+            self.button_fixed.setEnabled(True)
+
+
+
+    def _browse_fixed(self):
+        file_path, _ = QtWidgets.QFileDialog.getOpenFileName(self, "Select Custom Fixed Image", self.source_dir, "NIfTI Files (*.nii *.nii.gz)")
+        if file_path:
+            self.fixed_path = file_path
+            self.lineEdit_fixed.setText(file_path)
+            self.source_dir = os.path.dirname(file_path)
+
+    def _browse_moving(self):
+        file_path, _ = QtWidgets.QFileDialog.getOpenFileName(self, "Select Moving Image", self.source_dir, "NIfTI Files (*.nii *.nii.gz)")
+        if file_path:
+            self.moving_path = file_path
+            self.lineEdit_moving.setText(file_path)
+
+    def _browse_output(self):
+        if self.moving_path:
+            moving_name = os.path.basename(self.moving_path).split('.')[0]
+            fixed_name = "MNI152" if self.check_use_mni.isChecked() else "CustomFixed"
+            default_name = os.path.join(self.source_dir, f"{moving_name}_to_{fixed_name}_")
+        else:
+            default_name = self.source_dir
+        file_path, _ = QtWidgets.QFileDialog.getSaveFileName(self, "Set Output Prefix", default_name, "All Files (*)")
+        if file_path:
+            self.output_prefix = file_path
+            self.lineEdit_output.setText(file_path)
+
+    def _run_registration(self):
+        if not all([self.fixed_path, self.moving_path, self.output_prefix]):
+            QtWidgets.QMessageBox.warning(self, "Missing Information", "Please specify fixed, moving, and output files.")
+            return
+        self.toggle_log_button.setChecked(True)
+        # Clear the log viewer before starting
+        self.log_output.clear()
+
+        transform_type = self.combobox_methods.currentText()
+
+        redirector = StreamRedirector()
+        redirector.textWritten.connect(self._append_log_text)
+        original_stdout = sys.stdout
+        sys.stdout = redirector
+
+        try:
+            self.button_run.setEnabled(False)
+            self.button_run.setText("Registration in progress...")
+            QtWidgets.QApplication.processEvents()
+
+            reg_results, file_out = run_ants_registration(
+                fixed_path=self.fixed_path, moving_path=self.moving_path,
+                output_prefix=self.output_prefix, transform_type=transform_type,
+            )
+
+            QtWidgets.QMessageBox.information(
+                self, "Success", f"Registration complete! Warped image saved to:\n{file_out}"
+            )
+        except Exception as e:
+            # Also print the error to the log viewer
+            print(f"\n--- CRITICAL ERROR ---\n{str(e)}")
+            QtWidgets.QMessageBox.critical(self, "Error", f"An error occurred:\n{str(e)}")
+        finally:
+            sys.stdout = original_stdout
+            self.button_run.setEnabled(True)
+            self.button_run.setText("Run Registration")
+
+if __name__ == '__main__':
+    app = QtWidgets.QApplication(sys.argv)
+    dialog = RegistrationDialog()
+    dialog.show()
+    sys.exit(app.exec_())

melage/{widgets/ImageThresholding.py → dialogs/ThresholdingDialog.py}

@@ -7,7 +7,7 @@ from PyQt5.QtCore import Qt
 from PyQt5.QtCore import pyqtSignal
 import random
 import matplotlib
-from melage.widgets.HistImage import FigureCanvas
+from melage.dialogs import FigureCanvas
 matplotlib.use('Agg')
 
 
@@ -130,7 +130,7 @@ class ThresholdingImage(QDialog):
 
         self._a = a
         numc = self._number_class.currentIndex()+2
-        from utils.utils import Threshold_MultiOtsu
+        from melage.utils.utils import Threshold_MultiOtsu
         thresholds = Threshold_MultiOtsu(a, numc)
         return thresholds