fix(csection): compute cross sections of images added or shown again

When an image was added to the plot, or shown again after having been
hidden, while a cross-section marker or shape was active, its X/Y
cross-section curves stayed empty until the marker was moved:
items_changed created the curves after updating the plot, and never
computed them.

- Create the curves of added or shown again images before updating the
  plot, then compute these new curves only (unless the auto-refresh mode
  is disabled), so that the other curves are not computed again
- Compute the shade of the curves from the number of visible images,
  instead of all images (hidden ones included)
- Flush the closing of the previous test windows in the tests, which
  would otherwise hide the cross-section panels

Refs #89

Assisted-by: Claude Opus 5.5

Author: PierreRaybaut

plotpy/panels/csection/csplot.py

@@ -173,34 +173,50 @@ def items_changed(self, plot: BasePlot) -> None:
         make every change cost more as images accumulate in the plot (e.g. an
         application showing one image at a time among many hidden ones).
 
+        The curves of image items which are added or shown again are computed
+        right away from the last marker or shape used for the cross section,
+        unless the auto-refresh mode is disabled.
+
         Args:
             plot: Plot containing the image items to be used for cross section
         """
         new_sources = plot.get_items(item_type=ICSImageItemType)
+        visible_sources = [source for source in new_sources if source.isVisible()]
         # Del cross section items of removed or hidden image items
         for source in self.known_items.copy():
-            if source not in new_sources or not source.isVisible():
+            if source not in visible_sources:
                 curve = self.known_items.pop(source)
                 curve.clear_data()  # useful to emit SIG_CS_CURVE_CHANGED
                 # (eventually notify other panels that the
                 #  cross section curve is now empty)
                 self.del_item(curve)
 
+        # Add cross section items of added or shown again image items
+        # (the shade is applied to the curves when they are created)
+        if visible_sources:
+            self.param.shade = self.SHADE / len(visible_sources)
+        new_curves: list[CrossSectionItem] = []
+        for source in visible_sources:
+            if source not in self.known_items:
+                if not self.single_source or not self.known_items:
+                    self.add_cross_section_item(source=source)
+                    new_curves.append(self.known_items[source])
+
         # Update plot only to show/hide cross section curves according to
         # the associated image item visibility state (hence `refresh=False`)
         self.update_plot(refresh=False)
 
+        # Compute the new curves only: the other curves are already up to date
+        obj = self.get_last_obj()
+        if new_curves and self.autorefresh_mode and obj is not None:
+            if obj.plot() is not None:
+                for curve in new_curves:
+                    curve.update_item(obj)
+
         self.plot_axis_changed(plot)
 
         if not new_sources:
             self.replot()
-            return
-
-        self.param.shade = self.SHADE / len(new_sources)
-        for source in new_sources:
-            if source not in self.known_items and source.isVisible():
-                if not self.single_source or not self.known_items:
-                    self.add_cross_section_item(source=source)
 
     def active_item_changed(self, plot: BasePlot) -> None:
         """Active item has just changed

plotpy/tests/unit/test_cross_section_visible_items.py

@@ -3,24 +3,55 @@
 # Licensed under the terms of the BSD 3-Clause
 # (see plotpy/LICENSE for details)
 
-"""Cross section panels keep curves for visible images only; unchanged axis
-styles do not lay out the plot again."""
+"""Cross section panels keep curves for visible images only, and compute the
+curves of images added or shown again; unchanged axis styles do not lay out the
+plot again."""
 
 from __future__ import annotations
 
 import numpy as np
+import pytest
 from guidata.qthelpers import qt_app_context
 from qtpy import QtWidgets as QW
 
 from plotpy.builder import make
 
 
 def _window():
+    # In unattended mode, leaving a `qt_app_context` schedules the closing of all
+    # top-level widgets: process it now, so that it does not close this window
+    QW.QApplication.processEvents()
     win = make.dialog(type="image", show_xsection=True, show_ysection=True)
     win.show()
     return win
 
 
+def _cs_plots(win):
+    """Return the X and Y cross section plots of the window"""
+    return win.manager.get_xcs_panel().cs_plot, win.manager.get_ycs_panel().cs_plot
+
+
+def _add_marker(win, x: float, y: float):
+    """Add a marker to the plot and register it for the cross sections"""
+    plot = win.manager.get_plot()
+    marker = make.marker(position=(x, y))
+    plot.add_item(marker)
+    for cs_plot in _cs_plots(win):
+        cs_plot.register_shape(plot, marker)
+    return marker
+
+
+def _assert_sections(win, image, x: float, y: float) -> None:
+    """Assert that the cross section curves of the image are the sections at
+    (x, y)"""
+    xcs, ycs = _cs_plots(win)
+    xcurve, ycurve = xcs.known_items[image], ycs.known_items[image]
+    assert xcurve.dataSize() > 0 and ycurve.dataSize() > 0
+    # The Y cross section curve is vertical: section values are its X data
+    assert np.array_equal(xcurve.get_data()[1], image.get_xsection(y)[1])
+    assert np.array_equal(ycurve.get_data()[0], image.get_ysection(x)[1])
+
+
 def test_cross_section_curves_follow_visible_images():
     """Hidden images have no cross section curve, until they are shown again."""
     with qt_app_context(exec_loop=False):
@@ -49,6 +80,77 @@ def test_cross_section_curves_follow_visible_images():
         win.close()
 
 
+def test_cross_section_computed_when_image_shown_again():
+    """The cross sections of an image shown again are those at the marker
+    position, even if the marker was moved while the image was hidden."""
+    with qt_app_context(exec_loop=False):
+        win = _window()
+        plot = win.manager.get_plot()
+        image1 = make.image(np.arange(16 * 16, dtype=float).reshape(16, 16))
+        image2 = make.image(np.full((16, 16), 42.0))
+        plot.add_item(image1)
+        plot.add_item(image2)
+        marker = _add_marker(win, 5, 5)
+        _assert_sections(win, image1, 5, 5)
+        plot.set_item_visible(image1, False)
+        marker.set_pos(10, 12)
+        plot.set_item_visible(image1, True)
+        _assert_sections(win, image1, 10, 12)
+        _assert_sections(win, image2, 10, 12)
+        win.close()
+
+
+def test_cross_section_computed_for_added_image():
+    """The cross sections of an image added to the plot are computed at once."""
+    with qt_app_context(exec_loop=False):
+        win = _window()
+        plot = win.manager.get_plot()
+        plot.add_item(make.image(np.full((16, 16), 42.0)))
+        _add_marker(win, 5, 7)
+        image = make.image(np.arange(16 * 16, dtype=float).reshape(16, 16))
+        plot.add_item(image)
+        _assert_sections(win, image, 5, 7)
+        win.close()
+
+
+def test_cross_section_of_shown_image_follows_autorefresh_mode():
+    """With the auto-refresh mode disabled, the cross section curves of an image
+    shown again are computed on the next refresh only."""
+    with qt_app_context(exec_loop=False):
+        win = _window()
+        plot = win.manager.get_plot()
+        xcs, _ycs = _cs_plots(win)
+        image = make.image(np.arange(16 * 16, dtype=float).reshape(16, 16))
+        plot.add_item(image)
+        _add_marker(win, 5, 5)
+        xcs.toggle_autorefresh(False)
+        plot.set_item_visible(image, False)
+        plot.set_item_visible(image, True)
+        assert xcs.known_items[image].dataSize() == 0
+        xcs.update_plot()
+        assert xcs.known_items[image].dataSize() == 16
+        win.close()
+
+
+def test_cross_section_shade_counts_visible_images_only():
+    """The shade of the cross section curves ignores hidden images."""
+    with qt_app_context(exec_loop=False):
+        win = _window()
+        plot = win.manager.get_plot()
+        xcs, _ycs = _cs_plots(win)
+        images = []
+        for _index in range(4):
+            if images:
+                plot.set_item_visible(images[-1], False)
+            image = make.image(np.ones((16, 16)))
+            plot.add_item(image)
+            images.append(image)
+        assert xcs.param.shade == pytest.approx(xcs.SHADE)
+        brush_color = xcs.known_items[images[-1]].brush().color()
+        assert brush_color.alphaF() == pytest.approx(xcs.SHADE, abs=1e-2)
+        win.close()
+
+
 def test_unchanged_axis_style_does_not_relayout():
     """Setting the same titles again neither lays out the plot nor notifies."""
     with qt_app_context(exec_loop=False):
@@ -70,4 +172,8 @@ def test_unchanged_axis_style_does_not_relayout():
 
 if __name__ == "__main__":
     test_cross_section_curves_follow_visible_images()
+    test_cross_section_computed_when_image_shown_again()
+    test_cross_section_computed_for_added_image()
+    test_cross_section_of_shown_image_follows_autorefresh_mode()
+    test_cross_section_shade_counts_visible_images_only()
     test_unchanged_axis_style_does_not_relayout()