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

melage/dialogs/TransformationDialog.py

@@ -0,0 +1,275 @@
+import sys
+import os
+import ants
+from PyQt5 import QtWidgets, QtCore, QtGui
+from typing import List
+from pathlib import Path
+from PyQt5.QtCore import pyqtSignal
+MNI_FILE = 'mni_icbm152_t1_tal_nlin_sym_09a_masked.nii.gz'
+
+# --- Backend ANTsPy Function (Unchanged) ---
+
+def apply_ants_transforms_from_paths(
+        fixed_path: str,
+        moving_path: str,
+        transform_list: List[str],
+        output_path: str,
+        interpolation: str = 'linear'
+) -> str:
+    """
+    Applies a list of ANTs transforms to a moving image using file paths.
+    Includes robust error checking for file existence.
+
+    Args:
+        fixed_path (str): Path to the fixed (reference) image.
+        moving_path (str): Path to the moving image to be transformed.
+        transform_list (List[str]): A list of paths to the transform files.
+        output_path (str): Path to save the warped output image.
+        interpolation (str): Interpolation method ('linear', 'nearestNeighbor', etc.).
+
+    Returns:
+        str: The path to the saved output image.
+
+    Raises:
+        FileNotFoundError: If any of the input files do not exist.
+        RuntimeError: If the ANTsPy transformation fails for any reason.
+    """
+    for path in [fixed_path, moving_path] + transform_list:
+        if not os.path.exists(path):
+            raise FileNotFoundError(f"Input file not found: {path}")
+
+    print("--- Applying ANTsPy Transformation ---")
+    print(f"Reference (Fixed): {fixed_path}")
+    print(f"Target (Moving): {moving_path}")
+    print(f"Transforms: {transform_list}")
+    print(f"Interpolation: {interpolation}")
+
+    try:
+        fixed_image = ants.image_read(fixed_path)
+        moving_image = ants.image_read(moving_path)
+
+        warped_image = ants.apply_transforms(
+            fixed=fixed_image,
+            moving=moving_image,
+            transformlist=transform_list,
+            interpolator=interpolation,
+            verbose=True
+        )
+
+        ants.image_write(warped_image, output_path)
+        print(f"--- Transformation Complete ---")
+        print(f"Output saved to: {output_path}")
+        return output_path
+
+    except Exception as e:
+        print(f"ERROR: An error occurred during transformation: {e}")
+        raise RuntimeError(f"ANTsPy failed to apply transform. Reason: {e}")
+
+
+# --- PyQt5 Frontend (Updated) ---
+
+class TransformationDialog(QtWidgets.QDialog):
+    """
+    A PyQt5 dialog for applying pre-computed ANTsPy transformations.
+    """
+    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.transform_paths = []
+        self.output_path = None
+        # Get MNI path once on initialization for efficiency
+        self.mni_template_path = ants.get_ants_data('mni')
+
+        self._setup_ui()
+
+    def _setup_ui(self):
+        """Initializes the UI components, layout, and connections."""
+        self.setWindowTitle("Apply ANTsPy Transformation")
+        self.setMinimumSize(700, 280)
+
+        self._create_widgets()
+        self._create_layouts()
+        self._connect_signals()
+
+        # Set the initial state of the MNI checkbox to off
+        self._toggle_mni_template(False)
+    def set_source(self, source_dir):
+        self.source_dir = source_dir
+    def _create_widgets(self):
+        """Creates all the widgets needed for the dialog."""
+        # --- Updated MNI Widgets ---
+        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>2. Input Image (Moving):</b>")
+        self.lineEdit_moving = QtWidgets.QLineEdit("Select the image or label map to transform...")
+        self.lineEdit_moving.setReadOnly(True)
+        self.button_moving = QtWidgets.QPushButton("Browse...")
+
+        self.label_transforms = QtWidgets.QLabel("<b>3. Transform File(s):</b>")
+        self.lineEdit_transforms = QtWidgets.QLineEdit("Select .mat, .h5, or .nii.gz transform files...")
+        self.lineEdit_transforms.setReadOnly(True)
+        self.button_transforms = QtWidgets.QPushButton("Browse...")
+
+        self.label_output = QtWidgets.QLabel("<b>4. Output Warped Image:</b>")
+        self.lineEdit_output = QtWidgets.QLineEdit("Select where to save the output file...")
+        self.lineEdit_output.setReadOnly(True)
+        self.button_output = QtWidgets.QPushButton("Save As...")
+
+        self.label_interp = QtWidgets.QLabel("<b>5. Interpolation Method:</b>")
+        self.combobox_interp = QtWidgets.QComboBox()
+        self.combobox_interp.addItems(['linear', 'nearestNeighbor', 'genericLabel'])
+        self.combobox_interp.setToolTip(
+            "Use 'linear' for anatomical images.\n"
+            "Use 'nearestNeighbor' or 'genericLabel' for label maps."
+        )
+
+        self.button_run = QtWidgets.QPushButton("Run Transformation")
+        self.button_run.setStyleSheet("background-color: #007BFF; color: white; font-weight: bold; padding: 5px;")
+
+    def _create_layouts(self):
+        """Lays out the widgets in a grid."""
+        main_layout = QtWidgets.QVBoxLayout(self)
+        grid_layout = QtWidgets.QGridLayout()
+        grid_layout.setSpacing(10)
+
+        grid_layout.addWidget(self.check_use_mni, 0, 0, 1, 3)
+        grid_layout.addWidget(self.lineEdit_fixed, 1, 0, 1, 2)
+        grid_layout.addWidget(self.button_fixed, 1, 2)
+
+        grid_layout.addWidget(self.label_moving, 2, 0)
+        grid_layout.addWidget(self.lineEdit_moving, 2, 1)
+        grid_layout.addWidget(self.button_moving, 2, 2)
+
+        grid_layout.addWidget(self.label_transforms, 3, 0)
+        grid_layout.addWidget(self.lineEdit_transforms, 3, 1)
+        grid_layout.addWidget(self.button_transforms, 3, 2)
+
+        grid_layout.addWidget(self.label_output, 4, 0)
+        grid_layout.addWidget(self.lineEdit_output, 4, 1)
+        grid_layout.addWidget(self.button_output, 4, 2)
+
+        interp_layout = QtWidgets.QHBoxLayout()
+        interp_layout.addWidget(self.label_interp)
+        interp_layout.addWidget(self.combobox_interp)
+        interp_layout.addStretch()
+        grid_layout.addLayout(interp_layout, 5, 1)
+
+        main_layout.addLayout(grid_layout)
+        main_layout.addStretch()
+        main_layout.addWidget(self.button_run)
+
+    def _connect_signals(self):
+        """Connects widget signals to their corresponding slots."""
+        self.check_use_mni.toggled.connect(self._toggle_mni_template)
+        self.button_fixed.clicked.connect(self._browse_fixed)
+        self.button_moving.clicked.connect(self._browse_moving)
+        self.button_transforms.clicked.connect(self._browse_transforms)
+        self.button_output.clicked.connect(self._browse_output)
+        self.button_run.clicked.connect(self._run_transformation)
+
+    # --- UI Logic Methods ---
+
+    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)
+
+    # --- File Browser Methods ---
+
+    def _browse_fixed(self):
+        path, _ = QtWidgets.QFileDialog.getOpenFileName(self, "Select Reference Image", self.source_dir,
+                                                        "NIfTI Files (*.nii *.nii.gz)")
+        if path:
+            self.fixed_path = path
+            self.lineEdit_fixed.setText(path)
+            self.source_dir = os.path.dirname(path)
+
+    def _browse_moving(self):
+        path, _ = QtWidgets.QFileDialog.getOpenFileName(self, "Select Input Image", self.source_dir,
+                                                        "NIfTI Files (*.nii *.nii.gz)")
+        if path:
+            self.moving_path = path
+            self.lineEdit_moving.setText(path)
+
+    def _browse_transforms(self):
+        paths, _ = QtWidgets.QFileDialog.getOpenFileNames(self, "Select Transform Files", self.source_dir,
+                                                          "Transform Files (*.mat)")
+        if paths:
+            self.transform_paths = paths
+            self.lineEdit_transforms.setText(
+                f"{len(paths)} file(s) selected: {', '.join([os.path.basename(p) for p in paths])}")
+
+    def _browse_output(self):
+        if self.moving_path:
+            moving_name = os.path.basename(self.moving_path).split('.')[0]
+            default_name = os.path.join(self.source_dir, f"{moving_name}_warped.nii.gz")
+        else:
+            default_name = self.source_dir
+        path, _ = QtWidgets.QFileDialog.getSaveFileName(self, "Save Warped Image", default_name,
+                                                        "NIfTI Files (*.nii.gz)")
+        if path:
+            self.output_path = path
+            self.lineEdit_output.setText(path)
+
+    # --- Execution Method ---
+
+    def _run_transformation(self):
+        """Validates inputs and triggers the ANTsPy transformation."""
+        if not all([self.fixed_path, self.moving_path, self.transform_paths, self.output_path]):
+            QtWidgets.QMessageBox.warning(self, "Missing Information",
+                                          "Please select all required files (reference, input, transform(s), and output).")
+            return
+
+        interpolation_method = self.combobox_interp.currentText()
+
+        try:
+            self.button_run.setEnabled(False)
+            self.button_run.setText("Transforming...")
+            QtWidgets.QApplication.processEvents()
+
+            output_file = apply_ants_transforms_from_paths(
+                fixed_path=self.fixed_path,
+                moving_path=self.moving_path,
+                transform_list=self.transform_paths,
+                output_path=self.output_path,
+                interpolation=interpolation_method
+            )
+
+            QtWidgets.QMessageBox.information(
+                self, "Success", f"Transformation complete!\nWarped image saved to:\n{output_file}"
+            )
+
+        except (FileNotFoundError, RuntimeError, Exception) as e:
+            QtWidgets.QMessageBox.critical(self, "Error", f"An error occurred during transformation:\n\n{str(e)}")
+        finally:
+            self.button_run.setEnabled(True)
+            self.button_run.setText("Run Transformation")
+
+
+if __name__ == '__main__':
+    app = QtWidgets.QApplication(sys.argv)
+    dialog = TransformationDialog()
+    dialog.show()
+    sys.exit(app.exec_())

melage/dialogs/__init__.py

@@ -0,0 +1,9 @@
+from .AboutDialog import about_dialog
+from .ActivationDialog import activation_dialog
+from .HistogramDialog import HistImage, FigureCanvas
+from .ImInfoDialog import iminfo_dialog
+from .MaskingDialog import Masking
+from .MaskOperationsDialog import MaskOperationsDialog
+from .RegistrationDialog import RegistrationDialog
+from .ThresholdingDialog import ThresholdingImage
+from .TransformationDialog import TransformationDialog

melage/dialogs/dynamic_gui.py

@@ -0,0 +1,327 @@
+from PyQt5 import QtWidgets, QtCore
+from PyQt5.QtWidgets import (QDialog, QWidget, QLabel, QComboBox, QCheckBox,
+                             QGroupBox, QRadioButton, QPushButton, QProgressBar,
+                             QVBoxLayout, QHBoxLayout, QGridLayout, QMenu, QAction)
+from melage.plugins.ui_helpers import *
+
+class DynamicDialog(QDialog):
+    """
+    A Dialog that builds its own UI based on a dictionary schema.
+
+    It supports:
+    - Recursive layouts (Groups, Containers)
+    - Widget Registry (access widgets by ID)
+    - Automatic Context Menus
+    """
+
+    def __init__(self, schema, parent=None):
+        super().__init__(parent)
+        self.schema = schema
+        self.widgets = {}  # Registry to find widgets by ID: self.widgets["my_id"]
+
+        # 1. Setup Window Properties
+
+    def update_data_context(self, data_context):
+        """
+        Update the data context for the dialog.
+        """
+        self.data_context = data_context
+    def create_main_ui(self, schema, default_items=True):
+        """
+        Main method to create the UI based on the provided schema dictionary.
+        This method can be called from __init__ or overridden in subclasses.
+        """
+        self.setWindowTitle(schema.get("title", "Dynamic Dialog"))
+        if "min_width" in schema:
+            self.setMinimumWidth(schema["min_width"])
+        if "min_height" in schema:
+            self.setMinimumHeight(schema["min_height"])
+        self.layout_type = schema.get("layout", "vbox")
+        self.main_layout = self._create_layout(self.layout_type, self)
+
+        schema["items"].insert(0,
+                Combo(id="combo_view", label="Image View:", options=["view 1", "view 2"], function_name=None),
+                                   )
+
+
+        if default_items:
+            schema["items"].append(
+            Group(title="Configuration", children=[
+                Check(id="check_cuda", text="Use CUDA (GPU) if available"),
+
+                # --- NEW: Custom Weights Loader ---
+                FilePicker(
+                    id="weights",
+                    check_label="Custom Weights (.pth):", # it can be label or check lab
+                    placeholder="Default (Pre-trained)",
+                    file_filter="PyTorch Models (*.pth *.pt);;All Files (*)"
+                ),
+                # ----------------------------------
+
+                #Label(id="lbl_model_info", text="Model Info: Ready")
+            ]))
+            schema["items"].append(
+            # 5. Bottom Row (Progress Bar + Apply Button)
+            HBox([
+                Progress(id="progress_bar"),
+                Button(id="btn_apply", text="Apply", default=True)
+            ])
+            )
+        # 3. Build Items
+        # We iterate through the list of items in the schema and build them
+        for item in schema.get("items", []):
+            self._build_item(item, self.main_layout)
+
+    def get_widget(self, widget_id):
+        """
+        Public method to retrieve a specific widget object by its ID string.
+        Example: self.get_widget("btn_apply")
+        """
+        return self.widgets.get(widget_id)
+
+    def _create_layout(self, layout_type, parent_widget):
+        """Helper to create the correct layout object."""
+        if layout_type == "hbox":
+            l = QHBoxLayout(parent_widget)
+        elif layout_type == "grid":
+            l = QGridLayout(parent_widget)
+        else:
+            # Default to Vertical
+            l = QVBoxLayout(parent_widget)
+
+        # If this layout is inside a generic Container (QWidget), remove margins
+        # so it aligns perfectly with the rest of the UI.
+        # We keep margins if it's the Main Dialog or a GroupBox.
+        if isinstance(parent_widget, QWidget) and \
+                not isinstance(parent_widget, QDialog) and \
+                not isinstance(parent_widget, QGroupBox):
+            l.setContentsMargins(0, 0, 0, 0)
+
+        return l
+
+    # Inside your DynamicDialog class
+
+    def _handle_browse_click(self, target_id, file_filter):
+        """
+        Opens the file dialog and updates the target LineEdit.
+        """
+        # 1. Open the Dialog
+        dir_used = ""
+        if hasattr(self, "_last_dir"):
+            dir_used = self._last_dir
+        path, _ = QtWidgets.QFileDialog.getOpenFileName(
+            self,
+            "Select File",
+            dir_used,
+            file_filter
+        )
+
+        # 2. If user selected a file...
+        if path:
+            # 3. Find the target LineEdit by ID
+            target_widget = self.widgets.get(target_id)
+
+            if isinstance(target_widget, QtWidgets.QLineEdit):
+                target_widget.setText(path)
+                setattr(self, target_id+"_custom", path)
+                # Optional: Move focus away so the text isn't highlighted
+                target_widget.clearFocus()
+            else:
+                print(f"Error: Target widget {target_id} not found or not a LineEdit")
+
+    def _toggle_widgets(self, is_checked, target_ids):
+        """
+        Enables or disables a list of widgets based on a checkbox state.
+        """
+        for tid in target_ids:
+            widget = self.widgets.get(tid)
+            if widget:
+                widget.setEnabled(is_checked)
+            else:
+                # Safe fail: might happen if targets are built AFTER the checkbox
+                # (Though usually not an issue in VBox layouts)
+                pass
+
+
+
+
+    def _build_item(self, item_def, parent_layout):
+        """
+        Recursively builds a widget from a definition dictionary
+        and adds it to the parent_layout.
+        """
+        widget = None
+        w_type = item_def.get("type")
+        w_id = item_def.get("id")
+        #print(w_type)
+        # --- A. Widget Factory ---
+        if w_type == "label":
+            widget = QLabel(item_def.get("text", ""))
+
+            if item_def.get('mode') == 'reference':
+                # 1. Allow HTML links (<a href="...">) to open browser
+                widget.setOpenExternalLinks(True)
+
+                # 2. Allow user to highlight/copy text with mouse
+                widget.setTextInteractionFlags(
+                    QtCore.Qt.TextBrowserInteraction |
+                    QtCore.Qt.TextSelectableByMouse
+                )
+
+                # 3. Optional styling (make it look like a footnote)
+                widget.setStyleSheet("""
+                                QLabel {
+                                    background-color: white;
+                                    color: #555;
+                                    font-style: italic;
+                                    margin: 5px;
+                                    padding: 5px;
+                                    border: 1px solid #ddd; /* Optional: adds a subtle border */
+                                }
+                            """)
+            else:
+                widget.setWordWrap(item_def.get('word_wrap', False))
+            visible = item_def.get("visible", True)
+            widget.setVisible(visible)
+
+
+        elif w_type == "combobox":
+            widget = QComboBox()
+            widget.addItems(item_def.get("options", []))
+            default_option = item_def.get("default", None)
+            if default_option and default_option in item_def.get("options", []):
+                widget.setCurrentIndex(item_def.get("options", []).index(default_option))
+            #func = getattr(self, item_def.get('id'))
+            if item_def.get('function_name') is not None:
+                widget.currentIndexChanged.connect(getattr(self, item_def.get('function_name')))
+
+
+        elif w_type == 'spinbox':
+            # Create QDoubleSpinBox (handles both floats and ints well)
+            widget = QtWidgets.QDoubleSpinBox()
+            # Configure properties
+            enabled = item_def.get('enabled', True)
+            widget.setMinimum(item_def.get('min', 0.0))
+            widget.setMaximum(item_def.get('max', 100.0))
+            widget.setSingleStep(item_def.get('step', 1.0))
+            widget.setValue(item_def.get('value', 0.0))
+
+            # Handle decimals (set to 0 for integer behavior)
+            decimals = item_def.get('decimals', 2)
+            widget.setDecimals(decimals)
+            widget.setEnabled(enabled)
+
+        elif w_type == "checkbox":
+            widget = QCheckBox(item_def.get("text", ""))
+            if item_def.get("checked"):
+                widget.setChecked(True)
+            targets = item_def.get('enable_targets')
+            if targets:
+                # Connect the toggle signal to our helper
+                # rigid=False means: checked=True -> Enabled, checked=False -> Disabled
+                widget.toggled.connect(lambda checked: self._toggle_widgets(checked, targets))
+
+        elif w_type == "radio":
+            widget = QRadioButton(item_def.get("text", ""))
+            if item_def.get("checked"):
+                widget.setChecked(True)
+
+        elif w_type == "button":
+            widget = QPushButton(item_def.get("text", "Button"))
+            if item_def.get("default"):
+                widget.setDefault(True)
+
+            # 2. Handle FILE BROWSE Logic
+            if item_def.get('special_mode') == 'file_browse':
+                target_id = item_def.get('target_id')
+                #w_id = target_id
+                file_filter = item_def.get('file_filter', "All Files (*)")
+
+                # Connect the signal to a generic handler in this class
+                widget.clicked.connect(lambda: self._handle_browse_click(target_id, file_filter))
+        elif w_type=='line_edit':
+            widget = QtWidgets.QLineEdit()
+            widget.setText(item_def.get("text", ""))
+            widget.setPlaceholderText(item_def.get("placeholder", ""))
+            widget.setReadOnly(item_def.get("read_only", False))
+            if "width" in item_def:
+                if item_def['width'] is not None:
+                    widget.setFixedWidth(item_def["width"])
+
+
+        elif w_type == "progressbar":
+            widget = QProgressBar()
+            widget.setRange(item_def.get("min", 0), item_def.get("max", 100))
+            widget.setValue(item_def.get("value", 0))
+
+        # --- B. Container Recursion ---
+        # GroupBoxes and Containers have 'children', so we recurse.
+
+        elif w_type == "groupbox":
+            widget = QGroupBox(item_def.get("title", ""))
+            # Create a layout inside the groupbox
+            layout_str = item_def.get("layout", "vbox")
+            layout = self._create_layout(layout_str, widget)
+            widget.setLayout(layout)
+
+            # Build children into this new layout
+            for child in item_def.get("children", []):
+                self._build_item(child, layout)
+
+        elif w_type == "container":
+            # A generic QWidget used to hold a sub-layout (like HBox inside VBox)
+            widget = QWidget()
+            layout_str = item_def.get("layout", "vbox")
+            layout = self._create_layout(layout_str, widget)
+            widget.setLayout(layout)
+
+            for child in item_def.get("children", []):
+                self._build_item(child, layout)
+
+        # --- C. Common Properties & Registration ---
+        if widget:
+            # 1. Register ID
+            if w_id:
+                widget.setObjectName(w_id)
+                self.widgets[w_id] = widget
+
+            # 2. Handle Enabled/Disabled state
+            if "enabled" in item_def and not item_def["enabled"]:
+                widget.setEnabled(False)
+
+            # 3. Context Menu Wiring
+            if "context_menu" in item_def:
+                widget.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
+                # We use a lambda to pass the specific menu items list to the handler
+                widget.customContextMenuRequested.connect(
+                    lambda pos, w=widget, items=item_def["context_menu"]:
+                    self._show_context_menu(pos, w, items)
+                )
+
+            # 4. Add to Parent Layout
+            # If the parent is a Grid, we look for row/col, otherwise just addWidget
+            if isinstance(parent_layout, QGridLayout):
+                row = item_def.get("row", 0)
+                col = item_def.get("col", 0)
+                row_span = item_def.get("row_span", 1)
+                col_span = item_def.get("col_span", 1)
+                parent_layout.addWidget(widget, row, col, row_span, col_span)
+            else:
+                parent_layout.addWidget(widget)
+
+    def _show_context_menu(self, pos, widget, items):
+        """Internal handler to generate the right-click menu."""
+        menu = QMenu(self)
+        for text in items:
+            action = QAction(text, self)
+            # Connect the action to the overridable method 'on_context_action'
+            action.triggered.connect(lambda _, t=text: self.on_context_action(t, widget))
+            menu.addAction(action)
+        menu.exec_(widget.mapToGlobal(pos))
+
+    def on_context_action(self, text, widget):
+        """
+        Virtual method.
+        Override this in your subclass (e.g., MorphSegLogic) to handle menu clicks.
+        """
+        print(f"DEBUG: Context action '{text}' on widget '{widget.objectName()}'")