PolygonMapItem objects: clean-up code

Author: PierreRaybaut

plotpy/images/items/polygonmap.png

@@ -49,7 +49,7 @@
     RangeInfo,
     SelectedLegendBoxItem,
 )
-from .polygon import PolygonMapItem
+from .polygonmap import PolygonMapItem
 from .shape import (
     AbstractShape,
     Axes,

plotpy/items/__init__.py

@@ -19,14 +19,8 @@
 from qwt import QwtPlotItem
 
 from plotpy.config import _
-from plotpy.interfaces import (
-    IBasePlotItem,
-    ICurveItemType,
-    ISerializableType,
-    ITrackableItemType,
-)
-from plotpy.items.curve.base import SELECTED_SYMBOL
-from plotpy.styles.curve import CurveParam
+from plotpy.interfaces import IBasePlotItem, ISerializableType, ITrackableItemType
+from plotpy.styles import PolygonMapParam
 
 if TYPE_CHECKING:  # pragma: no cover
     import guidata.dataset.io
@@ -40,7 +34,6 @@
 def simplify_poly(pts, off, scale, bounds):
     """Simplify a polygon by removing points outside the canvas"""
     ax, bx, ay, by = scale
-    xm, ym, xM, yM = bounds
     a = np.array([[ax, ay]])
     b = np.array([[bx, by]])
     _pts = a * pts + b
@@ -57,9 +50,10 @@ def simplify_poly(pts, off, scale, bounds):
 
 
 class PolygonMapItem(QwtPlotItem):
-    """
-    Construct a curve `plot item` with the parameters *curveparam*
-    (see :py:class:`.styles.CurveParam`)
+    """Construct a PolygonMapItem object
+
+    Args:
+        param: Polygon parameters
     """
 
     __implements__ = (IBasePlotItem, ISerializableType)
@@ -71,20 +65,20 @@ class PolygonMapItem(QwtPlotItem):
     _can_move = False
     _can_rotate = False
 
-    def __init__(self, curveparam=None):
+    def __init__(self, param: PolygonMapParam | None = None) -> None:
         super().__init__()
-        if curveparam is None:
-            self.param = CurveParam(_("PolygonMap"), icon="curve.png")
+        if param is None:
+            self.param = PolygonMapParam(_("PolygonMap"), icon="polygonmap.png")
         else:
-            self.param = curveparam
+            self.param = param
         self.selected = False
         self.immutable = True  # set to false to allow moving points around
         self._pts = None  # Array of points Mx2
         self._n = None  # Array of polygon offsets/ends Nx1
         #                 (polygon k points are _pts[_n[k-1]:_n[k]])
         self._c = None  # Color of polygon Nx2 [border,background] as RGBA uint32
         self.update_params()
-        self.setIcon(get_icon("curve.png"))
+        self.setIcon(get_icon("polygonmap.png"))
 
     def types(self) -> tuple[type[IItemType], ...]:
         """Returns a group or category for this item.
@@ -93,7 +87,7 @@ def types(self) -> tuple[type[IItemType], ...]:
         Returns:
             tuple: Tuple of class objects inheriting from IItemType
         """
-        return (ICurveItemType, ITrackableItemType, ISerializableType)
+        return (ITrackableItemType, ISerializableType)
 
     def can_select(self) -> bool:
         """
@@ -164,56 +158,6 @@ def set_rotatable(self, state: bool) -> None:
         """
         self._can_rotate = state
 
-    def setPen(self, x):
-        """
-
-        :param x:
-        """
-        pass
-
-    def setBrush(self, x):
-        """
-
-        :param x:
-        """
-        pass
-
-    def setSymbol(self, x):
-        """
-
-        :param x:
-        """
-        pass
-
-    def setCurveAttribute(self, x, y):
-        """
-
-        :param x:
-        :param y:
-        """
-        pass
-
-    def setStyle(self, x):
-        """
-
-        :param x:
-        """
-        pass
-
-    def setCurveType(self, x):
-        """
-
-        :param x:
-        """
-        pass
-
-    def setBaseline(self, x):
-        """
-
-        :param x:
-        """
-        pass
-
     def __reduce__(self):
         state = (self.param, self._pts, self._n, self._c, self.z())
         res = (PolygonMapItem, (), state)
@@ -228,9 +172,11 @@ def __setstate__(self, state):
 
     def serialize(
         self,
-        writer: guidata.dataset.io.HDF5Writer
-        | guidata.dataset.io.INIWriter
-        | guidata.dataset.io.JSONWriter,
+        writer: (
+            guidata.dataset.io.HDF5Writer
+            | guidata.dataset.io.INIWriter
+            | guidata.dataset.io.JSONWriter
+        ),
     ) -> None:
         """Serialize object to HDF5 writer
 
@@ -242,13 +188,15 @@ def serialize(
         writer.write(self._c, group_name="Cdata")
         writer.write(self.z(), group_name="z")
         self.param.update_param(self)
-        writer.write(self.param, group_name="curveparam")
+        writer.write(self.param, group_name="param")
 
     def deserialize(
         self,
-        reader: guidata.dataset.io.HDF5Reader
-        | guidata.dataset.io.INIReader
-        | guidata.dataset.io.JSONReader,
+        reader: (
+            guidata.dataset.io.HDF5Reader
+            | guidata.dataset.io.INIReader
+            | guidata.dataset.io.JSONReader
+        ),
     ) -> None:
         """Deserialize object from HDF5 reader
 
@@ -260,8 +208,8 @@ def deserialize(
         c = reader.read(group_name="Cdata", func=reader.read_array)
         self.set_data(pts, n, c)
         self.setZ(reader.read("z"))
-        self.param = CurveParam(_("PolygonMap"), icon="curve.png")
-        reader.read("curveparam", instance=self.param)
+        self.param = PolygonMapParam(_("PolygonMap"), icon="polygonmap.png")
+        reader.read("param", instance=self.param)
         self.update_params()
 
     def set_readonly(self, state: bool) -> None:
@@ -307,19 +255,12 @@ def select(self) -> None:
         Select the object and eventually change its appearance to highlight the
         fact that it's selected
         """
-        self.selected = True
-        self.setSymbol(SELECTED_SYMBOL)
-        self.invalidate_plot()
 
     def unselect(self) -> None:
         """
         Unselect the object and eventually restore its original appearance to
         highlight the fact that it's not selected anymore
         """
-        self.selected = False
-        # Restoring initial curve parameters:
-        self.param.update_item(self)
-        self.invalidate_plot()
 
     def get_data(self):
         """Return curve data x, y (NumPy arrays)"""
@@ -451,7 +392,7 @@ def set_item_parameters(self, itemparams: ItemParameters) -> None:
         Args:
             itemparams: Item parameters
         """
-        update_dataset(self.param, itemparams.get("CurveParam"), visible_only=True)
+        update_dataset(self.param, itemparams.get("PolygonMapParam"), visible_only=True)
         self.update_params()
 
     def draw(
@@ -469,7 +410,6 @@ def draw(
             yMap: Y axis scale map
             canvasRect: Canvas rectangle
         """
-        # from time import time
         p1x = xMap.p1()
         s1x = xMap.s1()
         ax = (xMap.p2() - p1x) / (xMap.s2() - s1x)
@@ -481,13 +421,9 @@ def draw(
         _n = self._n
         fgcol = QG.QColor()
         bgcol = QG.QColor()
-        # t0 = time()
         polygons = simplify_poly(
             self._pts, _n, (ax, bx, ay, by), canvasRect.getCoords()
         )
-        # t1 = time()
-        # print len(polygons), t1-t0
-        # t2 = time()
         for poly, num in polygons:
             points = []
             for i in range(poly.shape[0]):
@@ -498,7 +434,6 @@ def draw(
             painter.setPen(QG.QPen(fgcol))
             painter.setBrush(QG.QBrush(bgcol))
             painter.drawPolygon(pg)
-        # print "poly:", time()-t2
 
     def boundingRect(self) -> QC.QRectF:
         """Return the bounding rectangle of the shape

plotpy/items/polygon.py plotpy/items/polygonmap.pyplotpy/items/polygon.py renamed to plotpy/items/polygonmap.py

@@ -69,6 +69,7 @@
     LegendParam,
     LegendParam_MS,
 )
+from plotpy.styles.polygonmap import PolygonMapParam, PolygonParam_MS
 from plotpy.styles.shape import (
     AnnotationParam,
     AnnotationParam_MS,

plotpy/styles/__init__.py

@@ -26,11 +26,11 @@
 )
 
 if TYPE_CHECKING:
-    from plotpy.items import CurveItem, PolygonMapItem
+    from plotpy.items import CurveItem
 
 
 class CurveParam(DataSet):
-    """Dataset defining the parameters of a CurveItem or PolygonMapItem"""
+    """Dataset defining the parameters of a CurveItem"""
 
     _multiselection = False
     label = StringItem(_("Title"), default="").set_prop(
@@ -49,23 +49,23 @@ class CurveParam(DataSet):
         "display", active=_use_dsamp_prop
     )
 
-    def update_param(self, curve: CurveItem | PolygonMapItem) -> None:
-        """Updates the parameters using values from a given CurveItem/PolygonMapItem
+    def update_param(self, curve: CurveItem) -> None:
+        """Updates the parameters using values from a given CurveItem
 
         Args:
-            curve: reference CurveItem/PolygonMapItem instance
+            curve: reference CurveItem instance
         """
         self.label = str(curve.title().text())
         self.symbol.update_param(curve.symbol())
         self.line.update_param(curve.pen())
         self.curvestyle = CURVESTYLE_NAME[curve.style()]
         self.baseline = curve.baseline()
 
-    def update_item(self, curve: CurveItem | PolygonMapItem) -> None:
-        """Updates a given CurveItem/PolygonMapItem using the current parameters
+    def update_item(self, curve: CurveItem) -> None:
+        """Updates a given CurveItem using the current parameters
 
         Args:
-            curve: instance of CurveItem/PolygonMapItem to update
+            curve: instance of CurveItem to update
         """
 
         plot = curve.plot()

plotpy/styles/curve.py

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from guidata.dataset import DataSet, GetAttrProp, StringItem
+
+from plotpy.config import _
+from plotpy.styles.base import ItemParameters
+
+if TYPE_CHECKING:
+    from plotpy.items import PolygonMapItem
+
+
+class PolygonMapParam(DataSet):
+    """Dataset defining the parameters of a PolygonMapItem instance"""
+
+    _multiselection = False
+    label = StringItem(_("Title"), default="").set_prop(
+        "display", hide=GetAttrProp("_multiselection")
+    )
+
+    def update_param(self, item: PolygonMapItem) -> None:
+        """Updates the parameters using values from a given PolygonMapItem
+
+        Args:
+            item: reference PolygonMapItem instance
+        """
+        self.label = str(item.title().text())
+
+    def update_item(self, item: PolygonMapItem) -> None:
+        """Updates a given PolygonMapItem using the current parameters
+
+        Args:
+            item: instance of PolygonMapItem to update
+        """
+        plot = item.plot()
+        if plot is not None:
+            plot.blockSignals(True)  # Avoid unwanted calls of update_param
+            # triggered by the setter methods below
+        if not self._multiselection:
+            # Non common parameters
+            item.setTitle(self.label)
+        if plot is not None:
+            plot.blockSignals(False)
+
+
+class PolygonParam_MS(PolygonMapParam):
+    """Same as PolygonParam but for multiselection"""
+
+    _multiselection = True
+
+
+ItemParameters.register_multiselection(PolygonMapParam, PolygonParam_MS)

plotpy/styles/polygonmap.py

@@ -15,7 +15,7 @@
 from guidata.qthelpers import qt_app_context
 
 from plotpy.items import PolygonMapItem
-from plotpy.plot import PlotDialog
+from plotpy.plot import PlotDialog, PlotOptions
 
 # Create a sample dataset consisting of tesselated circles randomly placed
 # in a box
@@ -50,7 +50,12 @@ def create_circle():
 def test_polygons():
     """Test"""
     with qt_app_context(exec_loop=True):
-        win = PlotDialog(edit=True, toolbar=True, title="Sample multi-polygon item")
+        win = PlotDialog(
+            edit=True,
+            toolbar=True,
+            title="Sample multi-polygon item",
+            options=PlotOptions(show_itemlist=True),
+        )
         plot = win.manager.get_plot()
         plot.set_aspect_ratio(lock=True)
         plot.set_antialiasing(False)