datalab-platform 1.0.1__py3-none-any.whl → 1.0.3__py3-none-any.whl

datalab/gui/plothandler.py

@@ -55,7 +55,16 @@ if TYPE_CHECKING:
 
 
 def calc_data_hash(obj: SignalObj | ImageObj) -> str:
-    """Calculate a hash for a SignalObj | ImageObj object's data"""
+    """Calculate a hash for a SignalObj | ImageObj object's data
+
+    For signals, this includes both X and Y data to detect axis changes.
+    For images, this includes only the Z data.
+    """
+    if isinstance(obj, SignalObj):
+        # For signals, hash both X and Y data to detect axis changes
+        # (e.g., when xmin/xmax is modified without changing Y values)
+        return hashlib.sha1(np.ascontiguousarray(obj.xydata)).hexdigest()
+    # For images, hash only the image data
     return hashlib.sha1(np.ascontiguousarray(obj.data)).hexdigest()
 
 
@@ -153,6 +162,7 @@ class BasePlotHandler(Generic[TypeObj, TypePlotItem]):  # type: ignore
         self.__merged_result_adapters = {}
         self.cleanup_dataview()
         self.remove_all_shape_items()
+        self.plot.replot()
 
     def add_shapes(self, oid: str, do_autoscale: bool = False) -> None:
         """Add geometric shape items associated to computed results and annotations,
@@ -382,7 +392,10 @@ class BasePlotHandler(Generic[TypeObj, TypePlotItem]):  # type: ignore
         if what == "selected":
             # Refresh selected objects
             oids = self.panel.objview.get_sel_object_uuids(include_groups=True)
-            if len(oids) == 1:
+            if len(oids) <= 1:
+                # Cleanup data view when there is 0 or 1 selected object.
+                # This removes stray plot items (like XRangeSelection, DataInfoLabel)
+                # that were created by PlotPy tools but are not managed by DataLab.
                 self.cleanup_dataview()
             self.remove_all_shape_items()
             for item in self:
@@ -797,4 +810,9 @@ class ImagePlotHandler(BasePlotHandler[ImageObj, MaskedXYImageItem]):
         options = super().get_plot_options()
         options.zlabel = self.plot.get_axis_title("right")
         options.zunit = self.plot.get_axis_unit("right")
+        # Include aspect ratio configuration so that separate plot dialogs
+        # (e.g. "View in a new window", ROI editors, profile dialogs) use the same
+        # settings as the integrated plot handler:
+        options.aspect_ratio = self.plot.get_aspect_ratio()
+        options.lock_aspect_ratio = self.plot.lock_aspect_ratio
         return options

datalab/gui/processor/base.py

@@ -42,6 +42,7 @@ from datalab.adapters_metadata import (
     TableAdapter,
     show_resultdata,
 )
+from datalab.adapters_plotpy import coordutils
 from datalab.config import Conf, _
 from datalab.gui.processor.catcher import CompOut, wng_err_func
 from datalab.objectmodel import get_short_id, get_uuid, patch_title_with_ids
@@ -194,6 +195,38 @@ def insert_processing_parameters(
         obj.set_metadata_option(PROCESSING_PARAMETERS_OPTION, pp.to_dict())
 
 
+def clear_analysis_parameters(obj: SignalObj | ImageObj) -> None:
+    """Clear analysis parameters from object metadata.
+
+    This removes the stored analysis parameters (1-to-0 operations) from the object.
+    Should be called when all analysis results are deleted to prevent the
+    auto_recompute_analysis function from attempting to recompute deleted analyses.
+
+    Args:
+        obj: Signal or Image object
+    """
+    key = f"__{ANALYSIS_PARAMETERS_OPTION}"
+    if key in obj.metadata:
+        del obj.metadata[key]
+
+
+def run_with_env(func: Callable, args: tuple, env_json: str) -> CompOut:
+    """Wrapper to apply environment config before calling func
+
+    Args:
+        func: function to call
+        args: function arguments
+        env_json: JSON string with environment configuration
+
+    Returns:
+        Computation output object containing the result, error message,
+         or warning message.
+    """
+    sigima_options.set_env(env_json)
+    sigima_options.ensure_loaded_from_env()  # recharge depuis l'env
+    return wng_err_func(func, args)
+
+
 # Enable multiprocessing support for Windows, with frozen executable (e.g. PyInstaller)
 multiprocessing.freeze_support()
 
@@ -220,22 +253,6 @@ COMPUTATION_TIP = _(
 POOL: Pool | None = None
 
 
-def run_with_env(func: Callable, args: tuple, env_json: str) -> CompOut:
-    """Wrapper to apply environment config before calling func
-
-    Args:
-        func: function to call
-        args: function arguments
-
-    Returns:
-        Computation output object containing the result, error message,
-         or warning message.
-    """
-    sigima_options.set_env(env_json)
-    sigima_options.ensure_loaded_from_env()  # recharge depuis l'env
-    return wng_err_func(func, args)
-
-
 class WorkerState(Enum):
     """Worker states for computation lifecycle."""
 
@@ -943,7 +960,9 @@ class BaseProcessor(QC.QObject, Generic[TypeROI, TypeROIParam]):
             TableAdapter.remove_all_from(result_obj)
             GeometryAdapter.remove_all_from(result_obj)
 
-    def auto_recompute_analysis(self, obj: SignalObj | ImageObj) -> None:
+    def auto_recompute_analysis(
+        self, obj: SignalObj | ImageObj, refresh_plot: bool = True
+    ) -> None:
         """Automatically recompute analysis (1-to-0) operations after data changes.
 
         This method checks if the object has 1-to-0 analysis parameters (analysis
@@ -960,6 +979,7 @@ class BaseProcessor(QC.QObject, Generic[TypeROI, TypeROIParam]):
 
         Args:
             obj: The object whose data was modified
+            refresh_plot: Whether to refresh the plot after recomputation
         """
         # Check if object has 1-to-0 analysis parameters (analysis operations)
         proc_params = extract_analysis_parameters(obj)
@@ -972,14 +992,16 @@ class BaseProcessor(QC.QObject, Generic[TypeROI, TypeROIParam]):
         # Get the actual function from the function name
         feature = self.get_feature(proc_params.func_name)
 
-        # Recompute the analysis operation silently
+        # Recompute the analysis operation silently, only for this specific object
+        # (not all selected objects, to avoid O(n²) behavior when called in a loop)
         with Conf.proc.show_result_dialog.temp(False):
-            self.compute_1_to_0(feature.function, param, edit=False)
+            self.compute_1_to_0(feature.function, param, edit=False, target_objs=[obj])
 
         # Update the view
         obj_uuid = get_uuid(obj)
         self.panel.objview.update_item(obj_uuid)
-        self.panel.refresh_plot(obj_uuid, update_items=True, force=True)
+        if refresh_plot:
+            self.panel.refresh_plot(obj_uuid, update_items=True, force=True)
 
     def __exec_func(
         self,
@@ -1121,6 +1143,9 @@ class BaseProcessor(QC.QObject, Generic[TypeROI, TypeROIParam]):
                     )
                     insert_processing_parameters(new_obj, pp)
 
+                    # Mark object as freshly processed to show Processing tab
+                    self.panel.objprop.mark_as_freshly_processed(new_obj)
+
                     new_gid = None
                     if grps:
                         # If groups are selected, then it means that there is no
@@ -1327,12 +1352,14 @@ class BaseProcessor(QC.QObject, Generic[TypeROI, TypeROIParam]):
         title: str | None = None,
         comment: str | None = None,
         edit: bool | None = None,
+        target_objs: list[SignalObj | ImageObj] | None = None,
     ) -> ResultData:
         """Generic processing method: 1 object in → no object out.
 
-        Applies a function to each selected object, returning metadata or measurement
-        results (e.g. peak coordinates, statistical properties) without generating
-        new objects. Results are stored in the object's metadata and returned as a
+        Applies a function to each selected object (or specified target objects),
+        returning metadata or measurement results (e.g. peak coordinates, statistical
+        properties) without generating new objects. Results are stored in the object's
+        metadata and returned as a
         ResultData instance.
 
         Args:
@@ -1344,6 +1371,8 @@ class BaseProcessor(QC.QObject, Generic[TypeROI, TypeROIParam]):
             title: Optional progress bar title.
             comment: Optional comment for parameter dialog.
             edit: Whether to open the parameter editor before execution.
+            target_objs: Optional list of specific objects to process. If None,
+             processes all currently selected objects.
 
         Returns:
             ResultData instance containing the results for all processed objects.
@@ -1360,7 +1389,11 @@ class BaseProcessor(QC.QObject, Generic[TypeROI, TypeROIParam]):
         if param is not None:
             if edit and not param.edit(parent=self.mainwindow):
                 return None
-        objs = self.panel.objview.get_sel_objects(include_groups=True)
+        objs = (
+            target_objs
+            if target_objs is not None
+            else self.panel.objview.get_sel_objects(include_groups=True)
+        )
         current_obj = self.panel.objview.get_current_object()
         title = func.__name__ if title is None else title
         refresh_needed = False
@@ -1416,6 +1449,8 @@ class BaseProcessor(QC.QObject, Generic[TypeROI, TypeROIParam]):
                 rdata.append(adapter, obj)
 
                 if obj is current_obj:
+                    # Mark object as having fresh analysis results to show Analysis tab
+                    self.panel.objprop.mark_as_fresh_analysis(obj)
                     self.panel.selection_changed(update_items=True)
                 else:
                     self.panel.refresh_plot(get_uuid(obj), True, False)
@@ -2374,8 +2409,13 @@ class BaseProcessor(QC.QObject, Generic[TypeROI, TypeROIParam]):
                 )
                 # Auto-recompute analysis operations for objects with modified ROIs
                 if mode == "apply":
-                    for obj_i in objs:
-                        self.auto_recompute_analysis(obj_i)
+                    with create_progress_bar(
+                        self.panel, _("Recomputing..."), max_=len(objs)
+                    ) as progress:
+                        for idx, obj_i in enumerate(objs):
+                            progress.setValue(idx)
+                            self.auto_recompute_analysis(obj_i, refresh_plot=False)
+                    self.panel.manual_refresh()
         return edited_roi
 
     def edit_roi_numerically(self) -> TypeROI:
@@ -2390,6 +2430,12 @@ class BaseProcessor(QC.QObject, Generic[TypeROI, TypeROIParam]):
         obj = self.panel.objview.get_sel_objects()[0]
         assert obj.roi is not None, _("No ROI selected for editing.")
         params = obj.roi.to_params(obj)
+        # Round coordinates to appropriate precision before displaying
+        for param in params:
+            if isinstance(obj, SignalObj):
+                coordutils.round_signal_roi_param(obj, param)
+            elif isinstance(obj, ImageObj):
+                coordutils.round_image_roi_param(obj, param)
         group = gds.DataSetGroup(params, title=_("Regions of Interest"))
         if group.edit(parent=self.mainwindow):
             edited_roi = obj.roi.__class__.from_params(obj, params)

datalab/gui/processor/image.py

@@ -779,7 +779,8 @@ class ImageProcessor(BaseProcessor[ImageROI, ROI2DParam]):
                 == QW.QMessageBox.No
             ):
                 return
-        editor = ImageGridROIEditor(parent=self.parent(), obj=obj0)
+        options = self.panel.plothandler.get_plot_options()
+        editor = ImageGridROIEditor(parent=self.parent(), obj=obj0, options=options)
         if exec_dialog(editor):
             for obj in self.panel.objview.get_sel_objects():
                 obj.roi = editor.get_roi()
@@ -1014,7 +1015,10 @@ class ImageProcessor(BaseProcessor[ImageROI, ROI2DParam]):
         with :py:func:`sigima.proc.image.offset_correction`"""
         obj = self.panel.objview.get_sel_objects(include_groups=True)[0]
         if param is None:
-            dlg = imagebackground.ImageBackgroundDialog(obj, parent=self.mainwindow)
+            options = self.panel.plothandler.get_plot_options()
+            dlg = imagebackground.ImageBackgroundDialog(
+                obj, parent=self.mainwindow, options=options
+            )
             if exec_dialog(dlg):
                 x0, y0, x1, y1 = dlg.get_rect_coords()
                 param = ROI2DParam.create(

datalab/gui/processor/signal.py

@@ -164,6 +164,16 @@ class SignalProcessor(BaseProcessor[SignalROI, ROI1DParam]):
             icon_name="convolution.svg",
             obj2_name=_("signal to convolve with"),
         )
+        self.register_2_to_1(
+            sips.replace_x_by_other_y,
+            _("Replace X by other signal's Y"),
+            comment=_(
+                "Replace X coordinates using Y values from another signal.\n"
+                "Useful for calibration: plot data vs wavelength scale."
+            ),
+            obj2_name=_("signal providing Y values for X axis"),
+            skip_xarray_compat=True,
+        )
         self.register_2_to_1(
             sips.deconvolution,
             _("Deconvolution"),

datalab/gui/roieditor.py

@@ -186,7 +186,7 @@ class ROIPolygonTool(PolygonTool):
 
     def __init__(self, manager: PlotManager, obj: ImageObj) -> None:
         super().__init__(manager, switch_to_default_tool=False, toolbar_id=None)
-        self.roi = PolygonalROI([[0, 0], [1, 0], [1, 1], [0, 1]], False)
+        self.roi = PolygonalROI([0, 0, 1, 0, 1, 1, 0, 1], False)
         self.obj = obj
 
     def activate(self):
@@ -385,7 +385,7 @@ class BaseROIEditor(
         """Parent dialog was accepted: updating ROI Editor data"""
         self.__roi.empty()
         for roi_item in self.roi_items:
-            self.__roi.add_roi(plotitem_to_singleroi(roi_item))
+            self.__roi.add_roi(plotitem_to_singleroi(roi_item, self.obj))
         if self.singleobj_btn is not None:
             Conf.proc.extract_roi_singleobj.set(self.singleobj_btn.isChecked())