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

melage/plugins/resize/resize.py

@@ -0,0 +1,136 @@
+import numpy as np
+from PyQt5.QtWidgets import QMessageBox
+from melage.widgets import MelagePlugin
+from melage.dialogs.dynamic_gui import DynamicDialog
+from .resize_schema import get_schema
+from PyQt5.QtCore import Qt
+from PyQt5.QtCore import pyqtSignal
+import SimpleITK as sitk
+from melage.utils.utils import resample_to_spacing
+
+
+#from .main.utils import changeCoordSystem
+# --- THE LOGIC CLASS ---
+class MainLogic(DynamicDialog):
+    """
+    This class handles the BRAIN of the WarpSeg tool.
+    The LOOKS are handled automatically by DynamicDialog + Schema.
+    """
+    completed = pyqtSignal(object)
+
+
+    def __init__(self, data_context,parent=None):
+        # 1. Initialize DynamicDialog with the Schema
+        # This single line builds the entire window!
+
+        super().__init__(parent)
+        self.create_main_ui(schema=get_schema(), default_items=False)
+        self.setAttribute(Qt.WA_DeleteOnClose)
+        self.data_context = data_context
+
+        # 2. AUTOMATICALLY WIDGET BINDING
+        # Iterate over all widgets created by the schema and bind them to 'self'.
+        for widget_id, widget_obj in self.widgets.items():
+            setattr(self, widget_id, widget_obj)
+
+        # 3. GENERAL PURPOSE SIGNAL CONNECTION (Auto-Connect)
+        # Instead of a hardcoded dictionary, we iterate through every widget from the schema
+        # and look for a matching method in this class named: on_<ID>_<Signal>
+        # This works for ANY schema changes automatically.
+        supported_signals = [
+            "clicked", "toggled", "currentIndexChanged",
+            "textChanged", "valueChanged"
+        ]
+
+        for widget_id, widget_obj in self.widgets.items():
+            for signal_name in supported_signals:
+                # 1. Check if the widget has this signal (e.g., Button has 'clicked')
+                if hasattr(widget_obj, signal_name):
+                    # 2. Check if WE have a handler method (e.g., 'on_btn_apply_clicked')
+                    handler_name = f"on_{widget_id}_{signal_name}"
+                    if hasattr(self, handler_name):
+                        # 3. Connect them!
+                        signal = getattr(widget_obj, signal_name)
+                        handler = getattr(self, handler_name)
+                        # Disconnect first to be safe (idempotent), then connect
+                        try:
+                            signal.disconnect(handler)
+                        except TypeError:
+                            pass
+                        signal.connect(handler)
+                        # print(f"Auto-connected: {widget_id}.{signal_name} -> {handler_name}")
+        self.spin_x.valueChanged.connect(self.synchronizeSpacings)
+        self.spin_y.valueChanged.connect(self.synchronizeSpacings)
+        self.spin_z.valueChanged.connect(self.synchronizeSpacings)
+        self.combo_view.currentIndexChanged.connect(self.compute_current_spcaing)
+        self.compute_current_spcaing()
+
+    def compute_current_spcaing(self, data_view=None):
+        if data_view is None:
+            view = self.combo_view.currentText()
+            data_view = self.data_context[view]
+        try:
+            spacing = data_view.header['pixdim'][1:4]
+            label_text = f"X {spacing[0]:0.2f}, Y {spacing[1]:0.2f}, Z {spacing[2]:0.2f}"
+        except (KeyError, TypeError, AttributeError):
+            label_text = f"Unknown"
+        self.lbl_spacing.setText(label_text)
+
+    def synchronizeSpacings(self, value):
+        if self.check_iso.isChecked():
+            # Set the value of all spin boxes to the changed value
+            self.spin_x.setValue(value)
+            self.spin_y.setValue(value)
+            self.spin_z.setValue(value)
+
+    @property
+    def ui_schema(self):
+        # We call the function to get the dictionary
+        return get_schema()
+
+
+    # Renamed from 'run_process' to match the schema ID 'btn_apply'
+    def on_btn_apply_clicked(self):
+        view = self.combo_view.currentText()
+        data_view = self.data_context[view]
+        if  data_view is None:
+            QMessageBox.information(self, "Error", "No image data available for the selected view.")
+            return
+
+        try:
+            """The main execution function."""
+            x_v = self.spin_x.value()
+            y_v = self.spin_y.value()
+            z_v = self.spin_z.value()
+            method = self.combo_method.currentText().lower()
+            im = resample_to_spacing(data_view, [x_v, y_v, z_v], method)
+            self.compute_current_spcaing(im)
+            result_package = {
+                "image": im.get_fdata(),
+                "affine": im.affine,
+                "label": np.zeros_like(im.get_fdata()),
+                "view": view
+            }
+            self.completed.emit(result_package)
+            self.progress_bar.setValue(100)
+            #QMessageBox.information(self, "Done", "Segmentation Complete")
+
+        except Exception as e:
+            QMessageBox.information(self, "Error", f"{e}")
+            self.progress_bar.setValue(0)
+
+
+
+
+# --- THE PLUGIN WRAPPER ---
+class AuxPlugin(MelagePlugin):
+    @property
+    def name(self) -> str: return "Resize"
+
+    @property
+    def category(self) -> str: return "Basic"
+
+
+    def get_widget(self, data_context =None,parent=None):
+        logic = MainLogic(data_context, parent)
+        return logic

melage/plugins/resize/resize_schema.py

@@ -0,0 +1,41 @@
+
+from ..ui_helpers import Label, Combo, Check, Radio, Group, Button, Progress, HBox, FilePicker, SpinBox, Reference
+
+# The simplified schema using helper functions.
+# The main layout defaults to 'vbox', so items stack automatically.
+def get_schema():
+
+
+    UI_SCHEMA = {
+        "title": "Image resizing",
+        "min_width": 420,
+        "layout": "vbox",
+        "items": [
+
+
+            HBox(children=[
+                Combo(id="combo_method", label="Select Method:", options=["Spline", "Linear"]),
+                Check(id="check_iso", text="Isotropic", checked=True),  # Connected to activate_advanced
+
+            ]),
+            # 1. Iteration (Splitter 3)
+            HBox(children=[
+                Label(text="New Spacing:"),
+                SpinBox(id="spin_x", value=1, min_val=0.1, max_val=10, decimals=2, step=0.1),
+                SpinBox(id="spin_y", value=1, min_val=0.1, max_val=10, decimals=2, step=0.1),
+                SpinBox(id="spin_z", value=1, min_val=0.1, max_val=10, decimals=2, step=0.1)
+            ]),
+            HBox(children=[
+                Label(text="Current Spacing:"),
+                Label(id="lbl_spacing", text="", visible=True),
+            ]),
+
+
+            # --- Bottom Row: Progress + Apply ---
+            HBox(children=[
+                Progress(id="progress_bar"),
+                Button(id="btn_apply", text="Apply", default=True)
+            ])
+        ]
+    }
+    return UI_SCHEMA

melage/plugins/ui_helpers.py

@@ -0,0 +1,144 @@
+"""
+Helper functions to make UI schemas simple and readable.
+"""
+
+def Reference(text, title="Reference / Paper"):
+    """
+    Creates a collapsible group containing the citation.
+    """
+    # We use a Label with special flags (handled in the builder next)
+    ref_label = {
+        "type": "label",
+        "text": text,
+        "mode": "reference",
+        "word_wrap": True
+    }
+
+    # Return it wrapped in a Group so it doesn't clutter the UI
+    # 'collapsed=True' requires your Group logic to support it (optional)
+    return Group(title=title, children=[ref_label])
+
+def Label(text, id=None, visible=True):
+    return {"type": "label", "text": text, "id": id, "visible": visible}
+
+def Combo(id, options, label=None, function_name=None, default=None):
+    """
+    Creates a Combobox.
+    If 'label' is provided, it returns a Container with the Label and Combo side-by-side.
+    """
+    combo = {"type": "combobox", "id": id, "options": options,
+             "function_name": function_name, "default": default}
+    if label:
+        return HBox([Label(label), combo])
+    return combo
+
+def Check(id, text, checked=False, context=None):
+    return {
+        "type": "checkbox", "id": id, "text": text,
+        "checked": checked, "context_menu": context
+    }
+
+def Radio(id, text, checked=False, enabled=True):
+    return {
+        "type": "radio", "id": id, "text": text,
+        "checked": checked, "enabled": enabled
+    }
+
+def Group(children, id=None, title="", layout="vbox", enabled=True):
+    return {
+        "type": "groupbox", "id": id, "title": title,
+        "layout": layout, "children": children, "enabled": enabled
+    }
+
+
+def SpinBox(id, label=None, value=0.0, min_val=0.0, max_val=100.0, step=1.0, decimals=2,
+            enabled = True):
+    """
+    Creates a DoubleSpinBox definition.
+    For integers, just set decimals=0.
+    """
+    item = {
+        "type": "spinbox",
+        "id": id,
+        "value": value,
+        "min": min_val,
+        "max": max_val,
+        "step": step,
+        "decimals": decimals,
+        "enabled": enabled
+    }
+
+    # If a label is requested, wrap it in a vertical group
+    if label:
+        return Group(layout="vbox", children=[
+            Label(text=label),
+            item
+        ])
+
+    return item
+
+def Button(id, text, default=False, enabled=True):
+    return {"type": "button", "id": id, "text": text, "default": default, "enabled": enabled}
+
+def Progress(id, min=0, max=100, value=0):
+    return {"type": "progressbar", "id": id, "min": min, "max": max, "value": value}
+
+def HBox(children):
+    """Puts items side-by-side"""
+    return {"type": "container", "layout": "hbox", "children": children}
+
+def VBox(children):
+    """Puts items top-to-bottom"""
+    return {"type": "container", "layout": "vbox", "children": children}
+
+def LineEdit(id=None, text="", placeholder="", read_only=False, width=None):
+    return {
+        "type": "line_edit",
+        "id": id,
+        "text": text,
+        "placeholder": placeholder,
+        "read_only": read_only,
+        "width": width
+    }
+
+
+def FilePicker(id, label=None, check_label =None, placeholder="Select file...", button_text="Browse...", file_filter="All Files (*)"):
+    """
+    Creates a composite widget: Label (optional) + [LineEdit | Button]
+    """
+    # 1. Create unique IDs for the internal parts based on the main ID
+    line_id = f"{id}_path"
+    btn_id = f"{id}_btn"
+    check_id = f"{id}_check"
+    is_enabled = False if check_label else True
+
+    # 2. Define the Browse Button
+    # We add a custom key 'file_filter' here.
+    # Your UI renderer will ignore it, but we will read it in the Python logic.
+    browse_btn = Button(id=btn_id, text=button_text, enabled=is_enabled)
+    browse_btn['special_mode'] = 'file_browse'
+    browse_btn['file_filter'] = file_filter  # <--- Storing the filter string here
+    browse_btn['target_id'] = line_id  # <--- Storing which line edit to update
+
+    # 3. Define the HBox (Line Edit + Button)
+    picker_row = HBox(children=[
+        LineEdit(id=line_id, placeholder=placeholder, read_only=True),
+        browse_btn
+    ])
+
+    # 4. If a label is requested, wrap it all in a VBox (or list), otherwise return just the row
+    if check_label:
+        # We add a custom key 'enable_targets' that our builder will read
+        toggle_check = Check(id=check_id, text=check_label, checked=False)
+        toggle_check['enable_targets'] = [line_id, btn_id]
+        return Group(layout="vbox", children=[
+            toggle_check,
+            picker_row
+        ])
+    if label:
+        return Group(layout="vbox", children=[
+            Label(text=label),
+            picker_row
+        ])
+
+    return picker_row

melage/plugins/warpseg/WarpSeg.py

@@ -0,0 +1,195 @@
+from PyQt5.QtWidgets import QMessageBox
+from melage.widgets import MelagePlugin
+from melage.dialogs.dynamic_gui import DynamicDialog
+from .WarpSeg_schema import get_schema
+from PyQt5 import QtWidgets
+from .warpseg_main.test import build_model, get_inference
+import torch
+from PyQt5.QtCore import Qt
+from melage.config import settings
+import os
+from PyQt5.QtCore import pyqtSignal
+# --- THE LOGIC CLASS ---
+class WarpSegLogic(DynamicDialog):
+    """
+    This class handles the BRAIN of the WarpSeg tool.
+    The LOOKS are handled automatically by DynamicDialog + Schema.
+    """
+    completed = pyqtSignal(object)
+    def __init__(self, data_context,parent=None):
+        # 1. Initialize DynamicDialog with the Schema
+        # This single line builds the entire window!
+
+        super().__init__(parent)
+        self.create_main_ui(schema=get_schema())
+        self.setAttribute(Qt.WA_DeleteOnClose)
+        self.data_context = data_context
+
+        # 2. AUTOMATICALLY WIDGET BINDING
+        # Iterate over all widgets created by the schema and bind them to 'self'.
+        for widget_id, widget_obj in self.widgets.items():
+            setattr(self, widget_id, widget_obj)
+
+        # 3. GENERAL PURPOSE SIGNAL CONNECTION (Auto-Connect)
+        # Instead of a hardcoded dictionary, we iterate through every widget from the schema
+        # and look for a matching method in this class named: on_<ID>_<Signal>
+        # This works for ANY schema changes automatically.
+        supported_signals = [
+            "clicked", "toggled", "currentIndexChanged",
+            "textChanged", "valueChanged"
+        ]
+
+        for widget_id, widget_obj in self.widgets.items():
+            for signal_name in supported_signals:
+                # 1. Check if the widget has this signal (e.g., Button has 'clicked')
+                if hasattr(widget_obj, signal_name):
+                    # 2. Check if WE have a handler method (e.g., 'on_btn_apply_clicked')
+                    handler_name = f"on_{widget_id}_{signal_name}"
+                    if hasattr(self, handler_name):
+                        # 3. Connect them!
+                        signal = getattr(widget_obj, signal_name)
+                        handler = getattr(self, handler_name)
+                        # Disconnect first to be safe (idempotent), then connect
+                        try:
+                            signal.disconnect(handler)
+                        except TypeError:
+                            pass
+                        signal.connect(handler)
+                        # print(f"Auto-connected: {widget_id}.{signal_name} -> {handler_name}")
+
+        # 4. Set Initial State
+        #self.update_ui_state()
+
+    @property
+    def ui_schema(self):
+        # We call the function to get the dictionary
+        return get_schema()
+    # We alias these to 'update_ui_state' so the auto-connector finds them
+    def on_check_adult_toggled(self, checked=None):
+        return None
+        #self.update_ui_state()
+
+    def on_check_infant_toggled(self, checked=None):
+        return None
+        #self.update_ui_state()
+
+    def update_ui_state(self):
+        """Handle the Adult vs Infant mutual exclusion logic."""
+        sender = self.sender()
+
+        # Mutual Exclusion Logic
+        if sender == self.check_adult and self.check_adult.isChecked():
+            self.check_infant.blockSignals(True)
+            self.check_infant.setChecked(False)
+            self.check_infant.blockSignals(False)
+        elif sender == self.check_infant and self.check_infant.isChecked():
+            self.check_adult.blockSignals(True)
+            self.check_adult.setChecked(False)
+            self.check_adult.blockSignals(False)
+
+        # Enable/Disable Groups
+        self.group_adult.setEnabled(self.check_adult.isChecked())
+        self.group_infant.setEnabled(self.check_infant.isChecked())
+
+        # Update Label (using the auto-bound ID 'lbl_model_info')
+        mode = "Adult" if self.check_adult.isChecked() else "Infant"
+        self.lbl_model_info.setText(f"Model Info: Ready for {mode} segmentation")
+
+    def browse_weights(self, widget):
+        """
+        Opens file dialog and updates the LineEdit.
+        """
+        options = QtWidgets.QFileDialog.Options()
+        file_path, _ = QtWidgets.QFileDialog.getOpenFileName(
+            None,
+            "Select Model Weights",
+            "",
+            "PyTorch Models (*.pth *.pt);;All Files (*)",
+            options=options
+        )
+
+        if file_path:
+            # 1. Update the LineEdit text to show the path
+            widget['txt_weights_path'].setText(file_path)
+
+            # 2. Update the status label to give feedback
+            filename = os.path.basename(file_path)
+            widget['lbl_model_info'].setText(f"Selected: {filename}")
+
+
+    # Renamed from 'run_process' to match the schema ID 'btn_apply'
+    def on_btn_apply_clicked(self):
+        view = self.combo_view.currentText()
+        data_view = self.data_context[view]
+        if  data_view is None:
+            QMessageBox.information(self, "Error", "No image data available for the selected view.")
+            return
+
+        try:
+            """The main execution function."""
+            # Get values using auto-bound attributes
+            use_cuda = self.check_cuda.isChecked()
+
+
+            self.progress_bar.setValue(10)
+            print(f"Running WarpSeg: View={view}, CUDA={use_cuda}")
+
+            if use_cuda and torch.cuda.is_available():
+                device = torch.device("cuda")
+                print("Using CUDA for computation.")
+            else:
+                device = torch.device("cpu")
+                print("Using CPU for computation.")
+            #if self.check_adult.isChecked():
+            model_path = getattr(self, 'weights_path_custom', None) or os.path.join(settings.DEFAULT_MODELS_DIR, "WarpSeg_Adult.pth")
+            #else:
+            #    model_path = getattr(self, 'weights_path_custom', None) or os.path.join(settings.DEFAULT_MODELS_DIR, "WarpSeg_Infant.pth")
+            self.progress_bar.setValue(30)
+            # Build model
+            model = build_model(model_path=model_path, device=device)
+            self.progress_bar.setValue(50)
+            # Here you would load pre-trained weights if available
+            # For simplicity, we skip that step
+            # Run inference
+
+            data = data_view.get_fdata().copy()
+            if len(data.shape)<=1:
+                raise ValueError("Input image must be at least 2D NIfTI.")
+            seg_tissue, seg = get_inference(model, data, device, post_processing=False)
+            if self.radio_adult_whole.isChecked():
+                seg = seg
+            else:
+                seg = seg_tissue
+            result_package = {
+                "image": None,
+                "label": seg,
+                "view": view
+            }
+            self.completed.emit(result_package)
+            self.progress_bar.setValue(100)
+            #QMessageBox.information(self, "Done", "Segmentation Complete")
+
+        except Exception as e:
+            QMessageBox.information(self, "Error", f"{e}")
+            self.progress_bar.setValue(0)
+
+    def on_context_action(self, text, widget):
+        """Handle the Right-Click Context Menu defined in schema"""
+        if text == "Reset Adult Options":
+            # Access radio button directly by ID
+            self.radio_adult_whole.setChecked(True)
+            print("Options reset.")
+
+
+# --- THE PLUGIN WRAPPER ---
+class WarpSegPlugin(MelagePlugin):
+    @property
+    def name(self) -> str: return "WarpSeg (Dynamic)"
+
+    @property
+    def category(self) -> str: return "Segmentation"
+
+    def get_widget(self, data_context =None,parent=None):
+        logic = WarpSegLogic(data_context, parent)
+
+        return logic

melage/plugins/warpseg/WarpSeg_schema.py

@@ -0,0 +1,41 @@
+
+from ..ui_helpers import Label, Combo, Check, Radio, Group, Button, Progress, HBox, FilePicker
+
+# The simplified schema using helper functions.
+# The main layout defaults to 'vbox', so items stack automatically.
+def get_schema():
+    UI_SCHEMA = {
+        "title": "MorphSeg Deep Learning Segmentation",
+        "min_width": 500,
+        "layout": "vbox",
+        "items": [
+
+            # 1. Combobox with a Label
+            # The 'Combo' helper with a 'label' argument automatically creates
+            # an HBox with a Label and the ComboBox inside.
+
+
+            # 2. Adult Section
+            # Context menu allows for extra actions like resetting options
+            #Check(id="check_adult", text="<b>Adult Segmentation</b>", checked=True,
+            #      context=["Reset Adult Options"]),
+            Label(id = "lbl_model_info", text="Model Info: Ready for Adult segmentation"),
+            Group(id="group_adult", layout="hbox", children=[
+                Radio(id="radio_adult_whole", text="Whole Segmentation", checked=True),
+                Radio(id="radio_adult_tissue", text="Tissue Segmentation")
+            ]),
+
+            # 3. Infant Section
+            #Check(id="check_infant", text="<b>Infant Segmentation</b>"),
+
+            # This group starts disabled because Infant mode is not active by default
+            #Group(id="group_infant", layout="hbox", enabled=False, children=[
+            #    Radio(id="radio_infant_whole", text="Whole Segmentation", checked=True),
+            #    Radio(id="radio_infant_tissue", text="Tissue Segmentation", enabled=False)
+            #]),
+
+            # 4. Configuration Section (UPDATED)
+
+        ]
+    }
+    return UI_SCHEMA

melage/plugins/warpseg/__init__.py

@@ -0,0 +1,2 @@
+
+