datalab-platform 1.0.1__tar.gz → 1.0.2__tar.gz

{datalab_platform-1.0.1 → datalab_platform-1.0.2}/MANIFEST.in

@@ -3,7 +3,6 @@ graft resources
 graft macros
 graft plugins
 include conftest.py
-include CHANGELOG.md
 include CONTRIBUTING.md
 include requirements.txt
 include *.desktop

{datalab_platform-1.0.1 → datalab_platform-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datalab-platform
-Version: 1.0.1
+Version: 1.0.2
 Summary: DataLab is a data processing and analysis software for scientific and industrial applications
 Author-email: Pierre Raybaut <p.raybaut@codra.fr>
 Maintainer-email: DataLab Platform Developers <p.raybaut@codra.fr>
@@ -32,9 +32,9 @@ Classifier: Topic :: Software Development :: Widget Sets
 Requires-Python: <4,>=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: guidata>=3.13.3
+Requires-Dist: guidata>=3.13.4
 Requires-Dist: PlotPy>=2.8.2
-Requires-Dist: Sigima>=1.0.2
+Requires-Dist: Sigima>=1.0.3
 Requires-Dist: NumPy>=1.22
 Requires-Dist: SciPy>=1.10.1
 Requires-Dist: scikit-image>=0.19.2

{datalab_platform-1.0.1 → datalab_platform-1.0.2}/datalab/__init__.py

@@ -24,7 +24,7 @@ except RuntimeError:
     # this module is imported more than once, e.g. when running tests)
     pass
 
-__version__ = "1.0.1"
+__version__ = "1.0.2"
 __docurl__ = __homeurl__ = "https://datalab-platform.com/"
 __supporturl__ = "https://github.com/DataLab-Platform/DataLab/issues/new/choose"
 

{datalab_platform-1.0.1 → datalab_platform-1.0.2}/datalab/adapters_plotpy/converters.py

@@ -39,11 +39,13 @@ def plotitem_to_singleroi(
     | AnnotatedRectangle
     | AnnotatedCircle
     | AnnotatedPolygon,
+    obj: SignalObj | ImageObj | None = None,
 ) -> SegmentROI | RectangularROI | CircularROI | PolygonalROI:
     """Create a single ROI from the given PlotPy item to integrate with DataLab
 
     Args:
         plot_item: The PlotPy item for which to create a single ROI
+        obj: Optional signal or image object for coordinate rounding
 
     Returns:
         A single ROI instance
@@ -66,7 +68,7 @@ def plotitem_to_singleroi(
         adapter = PolygonalROIPlotPyAdapter
     else:
         raise TypeError(f"Unsupported PlotPy item type: {type(plot_item)}")
-    return adapter.from_plot_item(plot_item)
+    return adapter.from_plot_item(plot_item, obj)
 
 
 def singleroi_to_plotitem(

datalab_platform-1.0.2/datalab/adapters_plotpy/coordutils.py

@@ -0,0 +1,157 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+ROI Coordinate Utilities
+=========================
+
+This module provides utility functions for rounding ROI coordinates to appropriate
+precision based on the sampling characteristics of signals and images.
+
+These functions are used when converting interactive PlotPy shapes to ROI objects
+to ensure coordinates are displayed with reasonable precision.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+from sigima.objects import ImageObj, ROI1DParam, ROI2DParam, SignalObj
+
+
+def round_signal_coords(
+    obj: SignalObj, coords: list[float], precision_factor: float = 0.1
+) -> list[float]:
+    """Round signal coordinates to appropriate precision based on sampling period.
+
+    Rounds to a fraction of the median sampling period to avoid excessive decimal
+    places while maintaining reasonable precision.
+
+    Args:
+        obj: signal object
+        coords: coordinates to round
+        precision_factor: fraction of sampling period to use as rounding precision.
+            Default is 0.1 (1/10th of sampling period).
+
+    Returns:
+        Rounded coordinates
+    """
+    if len(obj.x) < 2:
+        # Cannot compute sampling period, return coords as-is
+        return coords
+    # Compute median sampling period
+    sampling_period = float(np.median(np.diff(obj.x)))
+    if sampling_period == 0:
+        # Avoid division by zero for constant x arrays
+        return coords
+    # Round to specified fraction of sampling period
+    precision = sampling_period * precision_factor
+    # Determine number of decimal places
+    if precision > 0:
+        decimals = max(0, int(-np.floor(np.log10(precision))))
+        return [round(c, decimals) for c in coords]
+    return coords
+
+
+def round_image_coords(
+    obj: ImageObj, coords: list[float], precision_factor: float = 0.1
+) -> list[float]:
+    """Round image coordinates to appropriate precision based on pixel spacing.
+
+    Rounds to a fraction of the pixel spacing to avoid excessive decimal places
+    while maintaining reasonable precision. Uses separate precision for X and Y.
+
+    Args:
+        obj: image object
+        coords: flat list of coordinates [x0, y0, x1, y1, ...] to round
+        precision_factor: fraction of pixel spacing to use as rounding precision.
+            Default is 0.1 (1/10th of pixel spacing).
+
+    Returns:
+        Rounded coordinates
+
+    Raises:
+        ValueError: if coords does not contain an even number of elements
+    """
+    if len(coords) % 2 != 0:
+        raise ValueError("coords must contain an even number of elements (x, y pairs).")
+    if len(coords) == 0:
+        return coords
+
+    rounded = list(coords)
+    if obj.is_uniform_coords:
+        # Use dx, dy for uniform coordinates
+        precision_x = abs(obj.dx) * precision_factor
+        precision_y = abs(obj.dy) * precision_factor
+    else:
+        # Compute average spacing for non-uniform coordinates
+        if len(obj.xcoords) > 1:
+            avg_dx = float(np.mean(np.abs(np.diff(obj.xcoords))))
+            precision_x = avg_dx * precision_factor
+        else:
+            precision_x = 0
+        if len(obj.ycoords) > 1:
+            avg_dy = float(np.mean(np.abs(np.diff(obj.ycoords))))
+            precision_y = avg_dy * precision_factor
+        else:
+            precision_y = 0
+
+    # Round X coordinates (even indices)
+    if precision_x > 0:
+        decimals_x = max(0, int(-np.floor(np.log10(precision_x))))
+        for i in range(0, len(rounded), 2):
+            rounded[i] = round(rounded[i], decimals_x)
+
+    # Round Y coordinates (odd indices)
+    if precision_y > 0:
+        decimals_y = max(0, int(-np.floor(np.log10(precision_y))))
+        for i in range(1, len(rounded), 2):
+            rounded[i] = round(rounded[i], decimals_y)
+
+    return rounded
+
+
+def round_signal_roi_param(
+    obj: SignalObj, param: ROI1DParam, precision_factor: float = 0.1
+) -> None:
+    """Round signal ROI parameter coordinates in-place.
+
+    Args:
+        obj: signal object
+        param: ROI parameter to round (modified in-place)
+        precision_factor: fraction of sampling period to use as rounding precision
+    """
+    coords = round_signal_coords(obj, [param.xmin, param.xmax], precision_factor)
+    param.xmin, param.xmax = coords
+
+
+def round_image_roi_param(
+    obj: ImageObj, param: ROI2DParam, precision_factor: float = 0.1
+) -> None:
+    """Round image ROI parameter coordinates in-place.
+
+    Args:
+        obj: image object
+        param: ROI parameter to round (modified in-place)
+        precision_factor: fraction of pixel spacing to use as rounding precision
+    """
+    if param.geometry == "rectangle":
+        # Round x0, y0, dx, dy
+        x0, y0, x1, y1 = param.x0, param.y0, param.x0 + param.dx, param.y0 + param.dy
+        coords = round_image_coords(obj, [x0, y0, x1, y1], precision_factor)
+        param.x0, param.y0 = coords[0], coords[1]
+        # Round dx and dy to avoid floating-point errors in subtraction
+        dx_dy_rounded = round_image_coords(
+            obj, [coords[2] - coords[0], coords[3] - coords[1]], precision_factor
+        )
+        param.dx = dx_dy_rounded[0]
+        param.dy = dx_dy_rounded[1]
+    elif param.geometry == "circle":
+        # Round xc, yc, r
+        coords = round_image_coords(obj, [param.xc, param.yc], precision_factor)
+        param.xc, param.yc = coords
+        # Round radius using X precision
+        r_rounded = round_image_coords(obj, [param.r, 0], precision_factor)[0]
+        param.r = r_rounded
+    elif param.geometry == "polygon":
+        # Round polygon points
+        rounded = round_image_coords(obj, param.points.tolist(), precision_factor)
+        param.points = np.array(rounded)

{datalab_platform-1.0.1 → datalab_platform-1.0.2}/datalab/adapters_plotpy/roi/image.py

@@ -13,6 +13,7 @@ from plotpy.items import AnnotatedCircle, AnnotatedPolygon, AnnotatedRectangle
 from sigima.objects import CircularROI, ImageObj, ImageROI, PolygonalROI, RectangularROI
 from sigima.tools import coordinates
 
+from datalab.adapters_plotpy.coordutils import round_image_coords
 from datalab.adapters_plotpy.roi.base import (
     BaseROIPlotPyAdapter,
     BaseSingleROIPlotPyAdapter,
@@ -64,14 +65,21 @@ class PolygonalROIPlotPyAdapter(
         return item
 
     @classmethod
-    def from_plot_item(cls, item: AnnotatedPolygon) -> PolygonalROI:
+    def from_plot_item(
+        cls, item: AnnotatedPolygon, obj: ImageObj | None = None
+    ) -> PolygonalROI:
         """Create ROI from plot item
 
         Args:
             item: plot item
+            obj: image object for coordinate rounding (optional)
         """
+        coords = item.get_points().flatten().tolist()
+        # Round coordinates to appropriate precision
+        if obj is not None:
+            coords = round_image_coords(obj, coords)
         title = str(item.title().text())
-        return PolygonalROI(item.get_points().flatten(), False, title)
+        return PolygonalROI(coords, False, title)
 
 
 class RectangularROIPlotPyAdapter(
@@ -116,15 +124,22 @@ class RectangularROIPlotPyAdapter(
         return item
 
     @classmethod
-    def from_plot_item(cls, item: AnnotatedRectangle) -> RectangularROI:
+    def from_plot_item(
+        cls, item: AnnotatedRectangle, obj: ImageObj | None = None
+    ) -> RectangularROI:
         """Create ROI from plot item
 
         Args:
             item: plot item
+            obj: image object for coordinate rounding (optional)
         """
         rect = item.get_rect()
+        coords = RectangularROI.rect_to_coords(*rect)
+        # Round coordinates to appropriate precision
+        if obj is not None:
+            coords = round_image_coords(obj, coords)
         title = str(item.title().text())
-        return RectangularROI(RectangularROI.rect_to_coords(*rect), False, title)
+        return RectangularROI(coords, False, title)
 
 
 class CircularROIPlotPyAdapter(
@@ -166,15 +181,29 @@ class CircularROIPlotPyAdapter(
         return item
 
     @classmethod
-    def from_plot_item(cls, item: AnnotatedCircle) -> CircularROI:
+    def from_plot_item(
+        cls, item: AnnotatedCircle, obj: ImageObj | None = None
+    ) -> CircularROI:
         """Create ROI from plot item
 
         Args:
             item: plot item
+            obj: image object for coordinate rounding (optional)
         """
         rect = item.get_rect()
+        coords = CircularROI.rect_to_coords(*rect)
+        # Round coordinates to appropriate precision
+        # For circular ROI: [xc, yc, r] - round center (xc, yc) as pair, then radius
+        if obj is not None:
+            xc, yc, r = coords
+            # Round center coordinates
+            xc_rounded, yc_rounded = round_image_coords(obj, [xc, yc])
+            # Round radius using average of X and Y precision
+            # For radius, we use the X precision (could also average X and Y)
+            r_rounded = round_image_coords(obj, [r, 0])[0]
+            coords = [xc_rounded, yc_rounded, r_rounded]
         title = str(item.title().text())
-        return CircularROI(CircularROI.rect_to_coords(*rect), False, title)
+        return CircularROI(coords, False, title)
 
 
 class ImageROIPlotPyAdapter(BaseROIPlotPyAdapter[ImageROI]):

{datalab_platform-1.0.1 → datalab_platform-1.0.2}/datalab/adapters_plotpy/roi/signal.py

@@ -11,6 +11,7 @@ from plotpy.builder import make
 from plotpy.items import AnnotatedXRange
 from sigima.objects import SegmentROI, SignalObj, SignalROI
 
+from datalab.adapters_plotpy.coordutils import round_signal_coords
 from datalab.adapters_plotpy.roi.base import (
     BaseROIPlotPyAdapter,
     BaseSingleROIPlotPyAdapter,
@@ -36,11 +37,14 @@ class SegmentROIPlotPyAdapter(BaseSingleROIPlotPyAdapter[SegmentROI, AnnotatedXR
         return item
 
     @classmethod
-    def from_plot_item(cls, item: AnnotatedXRange) -> SegmentROI:
+    def from_plot_item(
+        cls, item: AnnotatedXRange, obj: SignalObj | None = None
+    ) -> SegmentROI:
         """Create ROI from plot item
 
         Args:
             item: plot item
+            obj: signal object for coordinate rounding (optional)
 
         Returns:
             ROI
@@ -48,6 +52,9 @@ class SegmentROIPlotPyAdapter(BaseSingleROIPlotPyAdapter[SegmentROI, AnnotatedXR
         if not isinstance(item, AnnotatedXRange):
             raise TypeError("Invalid plot item type")
         coords = sorted(item.get_range())
+        # Round coordinates to appropriate precision
+        if obj is not None:
+            coords = round_signal_coords(obj, coords)
         title = str(item.title().text())
         return SegmentROI(coords, False, title)
 

{datalab_platform-1.0.1 → datalab_platform-1.0.2}/datalab/config.py

@@ -301,6 +301,7 @@ class ViewSection(conf.Section, metaclass=conf.SectionMeta):
     ima_def_interpolation = conf.Option()
     ima_def_alpha = conf.Option()
     ima_def_alpha_function = conf.Option()
+    ima_def_keep_lut_range = conf.Option()
 
     # Annotated shape and marker visualization settings for signals
     sig_shape_param = conf.DataSetOption()
@@ -459,6 +460,7 @@ def initialize():
     Conf.view.ima_def_interpolation.get(5)
     Conf.view.ima_def_alpha.get(1.0)
     Conf.view.ima_def_alpha_function.get(LUTAlpha.NONE.value)
+    Conf.view.ima_def_keep_lut_range.get(False)
 
     # Datetime format strings: % must be escaped as %% for ConfigParser
     Conf.view.sig_datetime_format_s.get("%%H:%%M:%%S")

{datalab_platform-1.0.1 → datalab_platform-1.0.2}/datalab/gui/actionhandler.py

@@ -1269,7 +1269,9 @@ class SignalActionHandler(BaseActionHandler):
             with self.new_menu(_("Axis transformation")):
                 self.action_for("transpose")
                 self.action_for("reverse_x")
-                self.action_for("to_cartesian")
+                self.action_for("replace_x_by_other_y")
+                self.action_for("xy_mode")
+                self.action_for("to_cartesian", separator=True)
                 self.action_for("to_polar")
             with self.new_menu(_("Frequency filters"), icon_name="highpass.svg"):
                 self.action_for("lowpass")
@@ -1364,7 +1366,6 @@ class SignalActionHandler(BaseActionHandler):
                     separator=True,
                     tip=_("Compute all stability features"),
                 )
-            self.action_for("xy_mode", separator=True)
 
         # MARK: ANALYSIS
         with self.new_category(ActionCategory.ANALYSIS):

{datalab_platform-1.0.1 → datalab_platform-1.0.2}/datalab/gui/macroeditor.py

@@ -93,6 +93,7 @@ print("All done!")
         self.set_code(self.MACRO_SAMPLE)
         self.editor.modificationChanged.connect(self.modification_changed)
         self.process = None
+        self.__last_exit_code = None
 
     @property
     def title(self) -> str:
@@ -259,7 +260,14 @@ print("All done!")
         self.process = QC.QProcess()
         code = self.get_code().replace('"', "'")
         datalab_path = osp.abspath(osp.join(osp.dirname(datalab.__file__), os.pardir))
-        code = f"import sys; sys.path.append(r'{datalab_path}'){os.linesep}{code}"
+        # Reconfigure stdout/stderr to use UTF-8 encoding to avoid UnicodeEncodeError
+        # on Windows with locales that don't support all Unicode characters
+        # (e.g., cp1252)
+        code = (
+            f"import sys; sys.path.append(r'{datalab_path}'); "
+            f"sys.stdout.reconfigure(encoding='utf-8'); "
+            f"sys.stderr.reconfigure(encoding='utf-8'){os.linesep}{code}"
+        )
         env = QC.QProcessEnvironment()
         env.insert(execenv.XMLRPCPORT_ENV, str(execenv.xmlrpcport))
         sysenv = env.systemEnvironment()
@@ -305,6 +313,15 @@ print("All done!")
             exit_code: Exit code
             exit_status: Exit status
         """
+        self.__last_exit_code = exit_code
         self.print(_("# <== '%s' macro has finished") % self.title, eol_before=False)
         self.FINISHED.emit()
         self.process = None
+
+    def get_exit_code(self) -> int | None:
+        """Return last exit code of the macro process
+
+        Returns:
+            Last exit code or None if process has not finished yet
+        """
+        return self.__last_exit_code

{datalab_platform-1.0.1 → datalab_platform-1.0.2}/datalab/gui/main.py

@@ -1617,6 +1617,8 @@ class DLMainWindow(QW.QMainWindow, AbstractDLControl, metaclass=DLMainWindowMeta
                     )
                     if answer == QW.QMessageBox.Yes:
                         reset_all = True
+                    elif answer == QW.QMessageBox.No:
+                        reset_all = False
                     elif answer == QW.QMessageBox.Ignore:
                         Conf.io.h5_clear_workspace_ask.set(False)
         if h5files is None:

{datalab_platform-1.0.1 → datalab_platform-1.0.2}/datalab/gui/newobject.py

@@ -122,6 +122,13 @@ def create_signal_gui(
         param = NewSignalParam()
         edit = True  # Default to editing if no parameters provided
 
+    # CustomSignalParam requires edit mode to initialize the xyarray.
+    # Without this, if edit=False (the default in new_object), the setup_array
+    # call would be skipped, leaving xyarray as None, which would cause an
+    # AttributeError when trying to access param.xyarray.T later.
+    if isinstance(param, OrigCustomSignalParam):
+        edit = True
+
     if isinstance(param, OrigCustomSignalParam) and edit:
         p_init = NewSignalParam(_("Custom signal"))
         p_init.size = 10  # Set smaller default size for initial input

{datalab_platform-1.0.1 → datalab_platform-1.0.2}/datalab/gui/panel/base.py

@@ -216,6 +216,13 @@ class ObjectProp(QW.QWidget):
         self.analysis_parameters.setReadOnly(True)
         self.analysis_parameters.setFont(font)
 
+        # Track newly created objects to show Creation tab only once
+        self._newly_created_obj_uuid: str | None = None
+        # Track when analysis results were just computed
+        self._fresh_analysis_obj_uuid: str | None = None
+        # Track when object was just processed (1-to-1)
+        self._fresh_processing_obj_uuid: str | None = None
+
         self.tabwidget.addTab(
             self.processing_history, get_icon("history.svg"), _("History")
         )
@@ -370,11 +377,16 @@ class ObjectProp(QW.QWidget):
         self.properties.get()
         self.properties.apply_button.setEnabled(False)
 
-    def update_properties_from(self, obj: SignalObj | ImageObj | None = None) -> None:
+    def update_properties_from(
+        self,
+        obj: SignalObj | ImageObj | None = None,
+        force_tab: Literal["creation", "processing", "analysis", None] | None = None,
+    ) -> None:
         """Update properties panel (properties, creation, processing) from object.
 
         Args:
             obj: Signal or Image object
+            force_tab: Force a specific tab to be current
         """
         self.properties.setDisabled(obj is None)
         if obj is None:
@@ -411,30 +423,56 @@ class ObjectProp(QW.QWidget):
         self.processing_scroll = None
 
         # Setup Creation and Processing tabs (if applicable)
-        has_creation_tab = has_processing_tab = False
+        has_creation_tab = False
+        has_processing_tab = False
         if obj is not None:
             has_creation_tab = self.setup_creation_tab(obj)
-            has_processing_tab = self.setup_processing_tab(obj)
+            has_processing_tab = self.setup_processing_tab(obj)  # Processing tab setup
 
         # Trigger visibility update for History and Analysis parameters tabs
         # (will be called via textChanged signals, but we call explicitly
         # here to ensure initial state is correct)
         self._update_tab_visibility()
 
-        # Handle priority regarding the tab to set as current:
-        # 1. Analysis parameters if content exists
-        # 2. Creation tab if it exists
-        # 3. Processing tab if it exists
-        # 4. Properties tab
-        if has_analysis_parameters:
-            self.tabwidget.setCurrentWidget(self.analysis_parameters)
-        elif has_creation_tab:
+        # Determine which tab to show based on force_tab parameter:
+        # - If force_tab="creation" and Creation tab exists, show it
+        # - If force_tab="processing" and Processing tab exists, show it
+        # - If force_tab="analysis" and Analysis tab has content, show it
+        # - Otherwise, always show Properties tab (default behavior)
+        if force_tab == "creation" and has_creation_tab:
             self.tabwidget.setCurrentWidget(self.creation_scroll)
-        elif has_processing_tab:
+        elif force_tab == "processing" and has_processing_tab:
             self.tabwidget.setCurrentWidget(self.processing_scroll)
+        elif force_tab == "analysis" and has_analysis_parameters:
+            self.tabwidget.setCurrentWidget(self.analysis_parameters)
         else:
+            # Default: always show Properties tab when switching objects
             self.tabwidget.setCurrentWidget(self.properties)
 
+    def mark_as_newly_created(self, obj: SignalObj | ImageObj) -> None:
+        """Mark object to show Creation tab on next selection.
+
+        Args:
+            obj: Object to mark
+        """
+        self._newly_created_obj_uuid = get_uuid(obj)
+
+    def mark_as_freshly_processed(self, obj: SignalObj | ImageObj) -> None:
+        """Mark object to show Processing tab on next selection.
+
+        Args:
+            obj: Object to mark
+        """
+        self._fresh_processing_obj_uuid = get_uuid(obj)
+
+    def mark_as_fresh_analysis(self, obj: SignalObj | ImageObj) -> None:
+        """Mark object to show Analysis tab on next selection.
+
+        Args:
+            obj: Object to mark
+        """
+        self._fresh_analysis_obj_uuid = get_uuid(obj)
+
     def get_changed_properties(self) -> dict[str, Any]:
         """Get dictionary of properties that have changed from original values.
 
@@ -1490,6 +1528,16 @@ class BaseDataPanel(AbstractPanel, Generic[TypeObj, TypeROI, TypeROIEditor]):
         obj.check_data()
         self.objmodel.add_object(obj, group_id)
 
+        # Mark this object as newly created to show Creation tab on first selection
+        # BUT: Don't overwrite if this object is already marked as freshly processed
+        # or has fresh analysis results (those take precedence)
+        obj_uuid = get_uuid(obj)
+        if (
+            obj_uuid != self.objprop._fresh_processing_obj_uuid
+            and obj_uuid != self.objprop._fresh_analysis_obj_uuid
+        ):
+            self.objprop.mark_as_newly_created(obj)
+
         # Block signals to avoid updating the plot (unnecessary refresh)
         self.objview.blockSignals(True)
         self.objview.add_object_item(obj, group_id, set_current=set_current)
@@ -2419,7 +2467,26 @@ class BaseDataPanel(AbstractPanel, Generic[TypeObj, TypeROI, TypeROIEditor]):
         """
         selected_objects = self.objview.get_sel_objects(include_groups=True)
         selected_groups = self.objview.get_sel_groups()
-        self.objprop.update_properties_from(self.objview.get_current_object())
+
+        # Determine which tab to show based on object state
+        current_obj = self.objview.get_current_object()
+        force_tab = None
+        if current_obj is not None:
+            obj_uuid = get_uuid(current_obj)
+            # Show Creation tab for newly created objects (only once)
+            if obj_uuid == self.objprop._newly_created_obj_uuid:
+                force_tab = "creation"
+                self.objprop._newly_created_obj_uuid = None
+            # Show Processing tab for freshly processed objects (only once)
+            elif obj_uuid == self.objprop._fresh_processing_obj_uuid:
+                force_tab = "processing"
+                self.objprop._fresh_processing_obj_uuid = None
+            # Show Analysis tab for objects with fresh analysis results
+            elif obj_uuid == self.objprop._fresh_analysis_obj_uuid:
+                force_tab = "analysis"
+                self.objprop._fresh_analysis_obj_uuid = None
+
+        self.objprop.update_properties_from(current_obj, force_tab=force_tab)
         self.acthandler.selected_objects_changed(selected_groups, selected_objects)
         self.refresh_plot("selected", update_items, False)
 

{datalab_platform-1.0.1 → datalab_platform-1.0.2}/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()