Added "Plot results" entry in "Computing" menu

Author: PierreRaybaut

CHANGELOG.md

@@ -51,6 +51,10 @@ for future and past milestones.
   * This concerns both 1D (FHWM, ...) and 2D computing results (contours, blobs, ...):
     * Segment results now also show length (L) and center coordinates (Xc, Yc)
     * Circle and ellipse results now also show area (A)
+* Added "Plot results" entry in "Computing" menu:
+  * This feature allows to plot computing results (1D or 2D)
+  * It creates a new signal with X and Y axes corresponding to user-defined
+    parameters (e.g. X = indexes and Y = radius for circle results)
 * Increased default width of the object selection dialog box:
   * The object selection dialog box is now wider by default, so that the full
     signal/image/group titles may be more easily readable

cdl/core/computation/image/__init__.py

@@ -44,7 +44,7 @@
 )
 from cdl.core.model.base import BaseProcParam
 from cdl.core.model.image import ImageObj, RoiDataGeometries, RoiDataItem
-from cdl.core.model.signal import SignalObj
+from cdl.core.model.signal import SignalObj, create_signal
 
 VALID_DTYPES_STRLIST = ImageObj.get_valid_dtypenames()
 
@@ -114,8 +114,9 @@ def dst_11_signal(src: ImageObj, name: str, suffix: str | None = None) -> Signal
         SignalObj: output signal object
     """
     title = f"{name}({src.short_id})"
-    dst = SignalObj(title=title)
-    dst.title = title
+    dst = create_signal(
+        title=title, units=(src.xunit, src.zunit), labels=(src.xlabel, src.zlabel)
+    )
     if suffix is not None:
         dst.title += "|" + suffix
     dst.metadata["source"] = src.metadata["source"]  # Keep track of the source image

cdl/core/gui/actionhandler.py

@@ -669,6 +669,21 @@ def create_last_actions(self):
                 _("Swap X/Y axes"), triggered=self.panel.processor.compute_swap_axes
             )
 
+        with self.new_category(ActionCategory.COMPUTING):
+            self.new_action(
+                _("Show results") + "...",
+                triggered=self.panel.show_results,
+                icon=get_icon("show_results.svg"),
+                separator=True,
+                select_condition=SelectCond.at_least_one_group_or_one_object,
+            )
+            self.new_action(
+                _("Plot results") + "...",
+                triggered=self.panel.plot_results,
+                icon=get_icon("plot_results.svg"),
+                select_condition=SelectCond.at_least_one_group_or_one_object,
+            )
+
 
 class SignalActionHandler(BaseActionHandler):
     """Object handling signal panel GUI interactions: actions, menus, ..."""

cdl/core/gui/panel/base.py

@@ -51,6 +51,7 @@
 import warnings
 from typing import TYPE_CHECKING
 
+import guidata.dataset as gds
 import guidata.dataset.qtwidgets as gdq
 import numpy as np
 import plotpy.io
@@ -68,6 +69,7 @@
 from cdl.core.gui import actionhandler, objectmodel, objectview, roieditor
 from cdl.core.io.base import IOAction
 from cdl.core.model.base import ResultShape, items_to_json
+from cdl.core.model.signal import create_signal
 from cdl.env import execenv
 from cdl.utils.qthelpers import (
     create_progress_bar,
@@ -77,7 +79,6 @@
 )
 
 if TYPE_CHECKING:  # pragma: no cover
-    import guidata.dataset as gds
     from plotpy.plot import PlotWidget
     from plotpy.tools import GuiTool
 
@@ -236,6 +237,15 @@ def remove_all_objects(self):
         self.SIG_OBJECT_REMOVED.emit()
 
 
+@dataclasses.dataclass
+class ResultData:
+    """Result data associated to a shapetype"""
+
+    results: list[ResultShape] = None
+    xlabels: list[str] = None
+    ylabels: list[str] = None
+
+
 class BaseDataPanel(AbstractPanel):
     """Object handling the item list, the selected item properties and plot"""
 
@@ -1010,37 +1020,49 @@ def add_results_button(self) -> None:
             select_condition=actionhandler.SelectCond.at_least_one,
         )
 
-    def show_results(self) -> None:
-        """Show results"""
-
-        @dataclasses.dataclass
-        class ResultData:
-            """Result data associated to a shapetype"""
-
-            results: list[ResultShape] = None
-            xlabels: list[str] = None
-            ylabels: list[str] = None
-
+    def __get_resultdata_dict(
+        self, objs: list[SignalObj | ImageObj]
+    ) -> dict[ShapeTypes, ResultData]:
+        """Return result data dictionary"""
         rdatadict: dict[ShapeTypes, ResultData] = {}
-        objs = self.objview.get_sel_objects(include_groups=True)
         for obj in objs:
             for result in obj.iterate_resultshapes():
                 rdata = rdatadict.setdefault(result.shapetype, ResultData([], None, []))
-                title = f"{result.label}"
                 rdata.results.append(result)
                 rdata.xlabels = result.shown_xlabels
                 for _i_row_res in range(result.array.shape[0]):
                     ylabel = f"{obj.short_id}: {result.label}"
                     rdata.ylabels.append(ylabel)
+        return rdatadict
+
+    def __show_no_result_warning(self):
+        """Show no result warning"""
+        msg = "<br>".join(
+            [
+                _("No result currently available for this object."),
+                "",
+                _(
+                    "This feature leverages the results of previous computations "
+                    "performed on the selected object(s).<br><br>"
+                    "To compute results, select one or more objects and choose "
+                    "a computing feature in the <u>Compute</u> menu."
+                ),
+            ]
+        )
+        QW.QMessageBox.information(self, APP_NAME, msg)
+
+    def show_results(self) -> None:
+        """Show results"""
+        objs = self.objview.get_sel_objects(include_groups=True)
+        rdatadict = self.__get_resultdata_dict(objs)
         if rdatadict:
             with warnings.catch_warnings():
                 warnings.simplefilter("ignore", RuntimeWarning)
                 for rdata in rdatadict.values():
                     dlg = ArrayEditor(self.parent())
-                    title = _("Results")
                     dlg.setup_and_check(
                         np.vstack([result.shown_array for result in rdata.results]),
-                        title,
+                        _("Results"),
                         readonly=True,
                         xlabels=rdata.xlabels,
                         ylabels=rdata.ylabels,
@@ -1049,17 +1071,68 @@ class ResultData:
                     dlg.resize(750, 300)
                     exec_dialog(dlg)
         else:
-            msg = "<br>".join(
-                [
-                    _("No result currently available for this object."),
-                    "",
+            self.__show_no_result_warning()
+
+    def plot_results(self) -> None:
+        """Plot results"""
+        objs = self.objview.get_sel_objects(include_groups=True)
+        rdatadict = self.__get_resultdata_dict(objs)
+        if rdatadict:
+            for shapetype, rdata in rdatadict.items():
+                xchoices = (("indexes", _("Indexes")),)
+                for xlabel in rdata.xlabels[1:]:
+                    xchoices += ((xlabel, xlabel),)
+                ychoices = xchoices[1:]
+
+                class PlotResultParam(gds.DataSet):
+                    """Plot results parameters"""
+
+                    xaxis = gds.ChoiceItem(_("X axis"), xchoices, default="indexes")
+                    yaxis = gds.ChoiceItem(
+                        _("Y axis"), ychoices, default=ychoices[0][0]
+                    )
+
+                comment = (
                     _(
-                        "This feature shows result arrays as displayed after "
-                        'calling one of the computing feature (see "Compute" menu).'
-                    ),
-                ]
-            )
-            QW.QMessageBox.information(self, APP_NAME, msg)
+                        "Plot results obtained from previous computations.<br><br>"
+                        "This plot is based on the results under the form of '%s'."
+                    )
+                    % shapetype.name.lower()
+                )
+                param = PlotResultParam(_("Plot results"), comment=comment)
+                if not param.edit(parent=self):
+                    return
+
+                # Regrouping ResultShape results by their `label` attribute:
+                grouped_results: dict[str, list[ResultShape]] = {}
+                for result in rdata.results:
+                    grouped_results.setdefault(result.label, []).append(result)
+
+                # Plotting each group of results:
+                for label, results in grouped_results.items():
+                    x, y = [], []
+                    for index, result in enumerate(results):
+                        if param.xaxis == "indexes":
+                            x.append(index)
+                        else:
+                            x.append(
+                                result.shown_array[0][rdata.xlabels.index(param.xaxis)]
+                            )
+                        y.append(
+                            result.shown_array[0][rdata.xlabels.index(param.yaxis)]
+                        )
+                    xdata = np.array(x, dtype=float)
+                    ydata = np.array(y, dtype=float)
+
+                    obj = create_signal(
+                        title=f"{label}: {param.yaxis} = f({param.xaxis})",
+                        x=xdata,
+                        y=ydata,
+                        labels=[param.xaxis, param.yaxis],
+                    )
+                    self.mainwindow.signalpanel.add_object(obj)
+        else:
+            self.__show_no_result_warning()
 
     def add_label_with_title(self, title: str | None = None) -> None:
         """Add a label with object title on the associated plot

cdl/core/model/image.py

@@ -717,7 +717,7 @@ def create_image(
     """
     assert isinstance(title, str)
     assert data is None or isinstance(data, np.ndarray)
-    image = ImageObj()
+    image = ImageObj(title=title)
     image.title = title
     image.data = data
     if units is not None:

cdl/core/model/signal.py

@@ -475,7 +475,7 @@ def create_signal(
         SignalObj: signal object
     """
     assert isinstance(title, str)
-    signal = SignalObj()
+    signal = SignalObj(title=title)
     signal.title = title
     signal.set_xydata(x, y, dx=dx, dy=dy)
     if units is not None: