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

melage/plugins/change_coord/change_coord.py

@@ -0,0 +1,197 @@
+import numpy as np
+from PyQt5.QtWidgets import QMessageBox
+from melage.widgets import MelagePlugin
+from melage.dialogs.dynamic_gui import DynamicDialog
+from .change_coord_schema import get_schema
+from PyQt5.QtCore import Qt
+from PyQt5.QtCore import pyqtSignal
+from .main.utils import changeCoordSystem
+# --- THE LOGIC CLASS ---
+class ChangeCoordLogic(DynamicDialog):
+    """
+    This class handles the BRAIN of the WarpSeg tool.
+    The LOOKS are handled automatically by DynamicDialog + Schema.
+    """
+    completed = pyqtSignal(object)
+    AXIS_GROUPS = [
+        {'R', 'L'},
+        {'A', 'P'},
+        {'S', 'I'}
+    ]
+    ALL_OPTIONS = ['R', 'L', 'A', 'P', 'S', 'I']
+
+    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.update_2nd_combo()
+
+    @property
+    def ui_schema(self):
+        # We call the function to get the dictionary
+        return get_schema()
+
+    def get_axis_group(self, letter):
+        """Helper: Returns the set containing the letter (e.g., 'R' -> {'R', 'L'})"""
+        for group in self.AXIS_GROUPS:
+            if letter in group:
+                return group
+        return set()
+
+    def update_2nd_combo(self):
+        """
+        Filters Combo 2 based on Combo 1 selection.
+        """
+        selection_1 = self.combo_1st.currentText()
+        forbidden_group = self.get_axis_group(selection_1)
+
+        # Calculate allowed options for 2nd box
+        # Logic: All Options MINUS the axis used in box 1
+        allowed = [opt for opt in self.ALL_OPTIONS if opt not in forbidden_group]
+
+        # Repopulate 2nd Combo
+        self._repopulate_combo(self.combo_2nd, allowed)
+
+        # Force update of 3rd combo because 2nd changed
+        self.update_3rd_combo()
+
+    def update_3rd_combo(self):
+        """
+        Filters Combo 3 based on Combo 1 AND Combo 2 selection.
+        """
+        selection_1 = self.combo_1st.currentText()
+        selection_2 = self.combo_2nd.currentText()
+
+        group_1 = self.get_axis_group(selection_1)
+        group_2 = self.get_axis_group(selection_2)
+
+        # Calculate allowed options for 3rd box
+        # Logic: All Options MINUS axis 1 MINUS axis 2
+        allowed = [
+            opt for opt in self.ALL_OPTIONS
+            if opt not in group_1 and opt not in group_2
+        ]
+
+        # Repopulate 3rd Combo
+        self._repopulate_combo(self.combo_3rd, allowed)
+
+    def _repopulate_combo(self, combo_widget, allowed_options):
+        """
+        Safely updates items while trying to preserve the current selection.
+        """
+        current_val = combo_widget.currentText()
+
+        # Block signals to prevent infinite recursion loops during update
+        combo_widget.blockSignals(True)
+        combo_widget.clear()
+        combo_widget.addItems(allowed_options)
+
+        # Try to restore previous selection, otherwise pick index 0
+        index = combo_widget.findText(current_val)
+        if index >= 0:
+            combo_widget.setCurrentIndex(index)
+        else:
+            combo_widget.setCurrentIndex(0)
+
+        combo_widget.blockSignals(False)
+
+    # 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."""
+            self.progress_bar.setValue(10)
+
+            data = data_view.get_fdata().copy()
+            if len(data.shape)<=1:
+                raise ValueError("Input image must be at least 2D NIfTI.")
+
+            el_1 = self.combo_1st.currentText()
+            el_2 = self.combo_2nd.currentText()
+            el_3 = self.combo_3rd.currentText()
+            target = f"{el_1}{el_2}{el_3}"
+            used_axes = [self.get_axis_group(x) for x in [el_1, el_2, el_3]]
+            unique_axes = set(tuple(s) for s in used_axes)
+
+            if len(unique_axes) != 3:
+                raise ValueError(f"Invalid orientation {target}. Axes must be orthogonal.")
+            if np.unique([el_1, el_2, el_3]).shape[0]!=3:
+                QMessageBox.information(self, "INVALID COORDINATION SYSTEM", f"{target} is not a valid coorrdiantion system")
+                self.progress_bar.setValue(0)
+                return
+            im = changeCoordSystem(im=data_view, target=target)
+            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)
+
+    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 ChangeCoordPlugin(MelagePlugin):
+    @property
+    def name(self) -> str: return "Change Coord Sys."
+
+    @property
+    def category(self) -> str: return "Basic"
+
+
+    def get_widget(self, data_context =None,parent=None):
+        logic = ChangeCoordLogic(data_context, parent)
+        return logic

melage/plugins/change_coord/change_coord_schema.py

@@ -0,0 +1,31 @@
+
+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": "Enhanced spatial Fuzzy C-Means algorithm ...",
+        "min_width": 500,
+        "layout": "vbox",
+        "items": [
+            #Label(id="lbl_model_info", text="Model Info: Ready for Ifant brain segmentation"),
+            Reference(
+                "<b>Jafrasteh et al. (2024)</b>. <i>'Enhanced Spatial Fuzzy C-Means...'</i>. "
+                '<a href="https://link.springer.com/article/10.1007/s12021-024-09661-x">(paper)</a>'
+
+            ),
+            Group(id="group_mode", layout="hbox", title="Destination",children=[
+                Combo(id="combo_1st", label="", options=["R", "L", "P", "A", "I", "S"], default="R", function_name="update_2nd_combo"),
+                Combo(id="combo_2nd", label="", options=["R", "L", "P", "A", "I", "S"], default="A", function_name="update_3rd_combo"),
+                Combo(id="combo_3rd", label="", options=["R", "L", "P", "A", "I", "S"], default="S"),
+                ]),
+
+            HBox([
+                Progress(id="progress_bar"),
+                Button(id="btn_apply", text="Apply", default=True)
+            ])
+
+        ]
+    }
+    return UI_SCHEMA

melage/plugins/change_coord/main/utils.py

@@ -0,0 +1,15 @@
+from melage.utils.utils import convert_to_ras
+import nibabel as nib
+def changeCoordSystem(im, target):
+    """
+    Changing coordinate system of image
+    :param target:
+    :return:
+    """
+    previous_affine = im.affine
+    previous_header = im.header
+    transform, source_system = convert_to_ras(im.affine, target=target)
+    if source_system == target:
+        return im
+    im = im.as_reoriented(transform)
+    return  nib.Nifti1Image(im.get_fdata(),affine=previous_affine, header=previous_header)

melage/{widgets/Segmentation → plugins/esfcm/main}/FCM.py

@@ -1,8 +1,6 @@
 import numpy as np
 
-from melage.widgets.Segmentation.utils import BiasCorrection
-from melage.widgets.Segmentation.utils import create_window_3D, ssim3D
-from melage.widgets.Segmentation.utils import LargestCC, \
+from .utils import BiasCorrection, create_window_3D, ssim3D, LargestCC, \
     update_according_to_neighbours_conv, neighborhood_conv, axis_based_convolution, adjust_common_structures, \
     compute_sdf, rescale_between_a_b
 from sklearn.preprocessing import PolynomialFeatures
@@ -311,11 +309,11 @@ class esFCM(FCM):
                 if fast_method:
                     if self._is2D:
                         cost_ssim, ssim_map = ssim(s1.squeeze() / s1.max(), s2.squeeze() / s2.max(), full=True,
-                                           win_size=11)
+                                           win_size=11, data_range=1)
                         ssim_map = np.expand_dims(ssim_map, np.where(self._imdim)[0][0])
                     else:
                         cost_ssim, ssim_map = ssim(s1 / s1.max(), s2 / s2.max(), full=True,
-                                           win_size=11)
+                                           win_size=11, data_range=1)
                 else: # faster
                     ssim_map = ssim3D(s1 / s1.max(), s2 / s2.max(), self.window,
                                   self.window.shape[-1], 1, contrast=False)

melage/plugins/esfcm/main/test.py

@@ -0,0 +1,57 @@
+from .FCM import esFCM, FCM, FCM_pure
+from .utils import remove_zero
+import numpy as np
+def get_inference(model_name, progressBar, im, affine, num_tissues, post_correction, max_iter):
+    if affine is None:
+        affine = np.eye(4) # put identity if affine is None
+    use_ssim = True
+    padding = 0
+    image_range = 1000
+    tissue_labels = None
+    fuzziness = 3
+    constraint = False
+    InitMethod = 'otsu'
+    if num_tissues > 3 and not constraint:
+        post_correction = False
+        InitMethod = "kmeans"
+
+    epsilon = 5e-3
+    shape_init = im.shape
+    image_used, pad_zero = remove_zero(im, 0)
+    if model_name.lower() == 'esfcm':
+
+        model = esFCM(image_used, affine,
+                      image_range, num_tissues, fuzziness,
+                      epsilon=epsilon, max_iter=max_iter,
+                      padding=padding,
+                      tissuelabels=tissue_labels,
+                      mask=image_used > 0, use_ssim=use_ssim)
+        try:
+            model.initialize_fcm(initialization_method=InitMethod)
+        except:
+            model.initialize_fcm(initialization_method='kmeans')
+
+        model.fit(progressBar)
+        seg1 = model.predict(use_softmax=True).astype('int')
+        seg_init2 = np.zeros(shape_init)
+        seg_init2[pad_zero[0][0]:pad_zero[0][1] + 1, pad_zero[1][0]:pad_zero[1][1] + 1,
+        pad_zero[2][0]:pad_zero[2][1] + 1] = seg1
+        return seg_init2
+
+    elif model_name.lower() == 'fcm':
+        from melage.core.Segmentation.FCM import FCM_pure as FCM
+
+        model = FCM(image_used, affine, None,
+                    image_range, num_tissues, fuzziness,
+                    epsilon=epsilon, max_iter=max_iter,
+                    padding=padding, constraint=False, post_correction=post_correction, mask=image_used > 0)
+        try:
+            model.initialize_fcm(initialization_method=InitMethod)
+        except:
+            model.initialize_fcm(initialization_method='kmeans')
+        model.fit(progressBar)
+        seg1 = model.predict(use_softmax=True).astype('int')
+        seg_init2 = np.zeros(shape_init)
+        seg_init2[pad_zero[0][0]:pad_zero[0][1] + 1, pad_zero[1][0]:pad_zero[1][1] + 1,
+        pad_zero[2][0]:pad_zero[2][1] + 1] = seg1
+        return seg_init2

melage/{widgets/Segmentation → plugins/esfcm/main}/utils.py

@@ -12,6 +12,26 @@ from scipy.ndimage import binary_fill_holes
 from scipy.ndimage import distance_transform_edt as edistance
 from scipy.ndimage import distance_transform_cdt as chdistance
 
+def remove_zero(f_data, value=0):
+    """
+    Remove non segmented areas from image
+    :param f_data:
+    :param value:
+    :return:
+    """
+
+    xs, ys, zs = np.where(f_data > value)  # find zero values
+    tol = 4
+
+    min_max = []
+    for x in [xs, ys, zs]:
+        minx = min(x) - tol if min(x) - tol > 1 else min(x)
+        maxx = max(x) + tol if max(x) + tol < f_data.shape[0] - 1 else max(x)
+        min_max.append([minx, maxx])
+    f_data = f_data[min_max[0][0]:min_max[0][1] + 1, min_max[1][0]:min_max[1][1] + 1, min_max[2][0]:min_max[2][1] + 1]
+
+    return f_data, min_max
+
 def compute_sdf(segmentation, distance_use='edt', bounded=True):
     """BY B
     compute the signed distance map of binary mask

melage/plugins/esfcm/tissue_segmentation.py

@@ -0,0 +1,124 @@
+from PyQt5.QtWidgets import QMessageBox
+from melage.widgets import MelagePlugin
+from melage.dialogs.dynamic_gui import DynamicDialog
+from .tissue_segmentation_schema import get_schema
+from PyQt5 import QtWidgets
+from .main.test import 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 esFCMLogic(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}")
+
+
+    @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."""
+            self.progress_bar.setValue(10)
+
+            data = data_view.get_fdata().copy()
+            if len(data.shape)<=1:
+                raise ValueError("Input image must be at least 2D NIfTI.")
+
+            model_name = self.combo_method.currentText()
+            num_tissues = int(self.spin_num_classes.value())
+            max_iter = int(self.spin_max_iter.value())
+            seg = get_inference(model_name, self.progress_bar, data, affine=None, num_tissues=num_tissues,
+                                post_correction=True, max_iter=max_iter)
+            seg = seg.astype('int')
+            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 "FCM"
+
+    @property
+    def category(self) -> str: return "UnSupervised Segmentation"
+
+
+    def get_widget(self, data_context =None,parent=None):
+        logic = esFCMLogic(data_context, parent)
+
+        return logic

melage/plugins/esfcm/tissue_segmentation_schema.py

@@ -0,0 +1,33 @@
+
+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": "Enhanced spatial Fuzzy C-Means algorithm ...",
+        "min_width": 500,
+        "layout": "vbox",
+        "items": [
+            #Label(id="lbl_model_info", text="Model Info: Ready for Ifant brain segmentation"),
+            Reference(
+                "<b>Jafrasteh et al. (2024)</b>. <i>'Enhanced Spatial Fuzzy C-Means...'</i>. "
+                '<a href="https://link.springer.com/article/10.1007/s12021-024-09661-x">(paper)</a>'
+
+            ),
+            Combo(id="combo_method", label="Select Method:", options=["esFCM", "FCM"]),
+            Group(id="group_mode", layout="hbox", children=[
+                SpinBox(id="spin_num_classes", label="Number of classes:", value=3, min_val=2, max_val=50,
+                        step=1, decimals=0),
+                SpinBox(id="spin_max_iter", label="Max No of Iter:", value=50, min_val=2, max_val=500,
+                        step=1, decimals=0),
+            ]),
+
+            HBox([
+                Progress(id="progress_bar"),
+                Button(id="btn_apply", text="Apply", default=True)
+            ])
+
+        ]
+    }
+    return UI_SCHEMA

melage/plugins/masking_operation/mo.py

@@ -0,0 +1,115 @@
+import numpy as np
+from PyQt5.QtWidgets import QMessageBox
+from melage.widgets import MelagePlugin
+from melage.dialogs.dynamic_gui import DynamicDialog
+from .mo_schema import get_schema
+from PyQt5.QtCore import Qt
+from PyQt5.QtCore import pyqtSignal
+import SimpleITK as sitk
+
+
+
+#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}")
+
+
+    @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."""
+            self.progress_bar.setValue(0)
+            max_iters = int(self.iteration.value())
+            numberFittingLevels = int((self.fit_lvl.value()))
+            shrinkFactor = int((self.shrink_fct.value()))
+            status_otsu = self.check_otsu.isChecked()
+            im = N4_bias_correction(data_view, use_otsu=status_otsu, shrinkFactor=shrinkFactor,
+                       numberFittingLevels=numberFittingLevels, max_iter=max_iters)
+            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 "Masking Operation"
+
+    @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/masking_operation/mo_schema.py

@@ -0,0 +1,33 @@
+
+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": "N4 Bias Field Correction",
+        "min_width": 310,
+        "layout": "vbox",
+        "items": [
+
+
+
+            Group(id="group_mode", layout="hbox", title="Operation",children=[
+                Combo(id="combo_1", label="Label 1", options=[],),
+                Combo(id="combo_operation", label="", options=["/", "*", "-", "+"], default="+"),
+                Combo(id="combo_2", label="Label 2", options=[]),
+                ]),
+
+
+
+
+            # --- Bottom Row: Progress + Apply ---
+            HBox(children=[
+                Progress(id="progress_bar"),
+                Button(id="btn_apply", text="Apply", default=True)
+            ])
+        ]
+    }
+    return UI_SCHEMA