Downsampling: added error bar support, tests, ...

Author: PierreRaybaut

doc/features/tools/overview.rst

@@ -52,6 +52,7 @@ The `tools` module provides the following tools:
 * :py:class:`.tools.HRangeTool`
 * :py:class:`.tools.DummySeparatorTool`
 * :py:class:`.tools.AntiAliasingTool`
+* :py:class:`.tools.DownSamplingTool`
 * :py:class:`.tools.DisplayCoordsTool`
 * :py:class:`.tools.ReverseYAxisTool`
 * :py:class:`.tools.AspectRatioTool`

doc/features/tools/reference.rst

@@ -53,6 +53,8 @@ Reference
    :members:
 .. autoclass:: plotpy.tools.AntiAliasingTool
    :members:
+.. autoclass:: plotpy.tools.DownSamplingTool
+   :members:
 .. autoclass:: plotpy.tools.DisplayCoordsTool
    :members:
 .. autoclass:: plotpy.tools.ReverseYAxisTool

plotpy/builder/curvemarker.py

@@ -121,6 +121,8 @@ def __set_param(
         shade: bool | None = None,
         curvestyle: str | None = None,
         baseline: float | None = None,
+        dsamp_factor: int | None = None,
+        use_dsamp: bool | None = None,
     ) -> None:
         """Apply parameters to a :py:class:`.CurveParam` instance"""
         self.__set_baseparam(
@@ -141,6 +143,10 @@ def __set_param(
             param.curvestyle = curvestyle
         if baseline is not None:
             param.baseline = baseline
+        if dsamp_factor is not None:
+            param.dsamp_factor = dsamp_factor
+        if use_dsamp is not None:
+            param.use_dsamp = use_dsamp
 
     def __get_arg_triple_plot(self, args):
         """Convert MATLAB-like arguments into x, y, style"""
@@ -232,7 +238,7 @@ def mcurve(self, *args, **kwargs) -> CurveItem | list[CurveItem]:
             args: x, y, style
             kwargs: title, color, linestyle, linewidth, marker, markersize,
             markerfacecolor, markeredgecolor, shade, curvestyle, baseline,
-            downsampling_factor, use_downsampling
+            dsamp_factor, use_dsamp
 
         Returns:
             :py:class:`.CurveItem` object
@@ -257,10 +263,10 @@ def mcurve(self, *args, **kwargs) -> CurveItem | list[CurveItem]:
                 global CURVE_COUNT
                 CURVE_COUNT += 1
                 param.label = make_title(basename, CURVE_COUNT)
-            if "downsampling_factor" in kwargs:
-                param.downsampling_factor = kwargs.pop("downsampling_factor")
-            if "use_downsampling" in kwargs:
-                param.use_downsampling = kwargs.pop("use_downsampling")
+            if "dsamp_factor" in kwargs:
+                param.dsamp_factor = kwargs.pop("dsamp_factor")
+            if "use_dsamp" in kwargs:
+                param.use_dsamp = kwargs.pop("use_dsamp")
             update_style_attr(stylei, param)
             curves.append(self.pcurve(x, yi, param, **kwargs))
         if len(curves) == 1:
@@ -314,6 +320,8 @@ def curve(
         baseline: float | None = None,
         xaxis: str = "bottom",
         yaxis: str = "left",
+        dsamp_factor: int | None = None,
+        use_dsamp: bool | None = None,
         dx: numpy.ndarray | None = None,
         dy: numpy.ndarray | None = None,
         errorbarwidth: int | None = None,
@@ -345,6 +353,8 @@ def curve(
             baseline: baseline value. Default is None
             xaxis: x axis name. Default is 'bottom'
             yaxis: y axis name. Default is 'left'
+            dsamp_factor: downsampling factor. Default is None
+            use_dsamp: use downsampling. Default is None
             dx: x error data. Default is None
             dy: y error data. Default is None
             errorbarwidth: error bar width (pixels). Default is None
@@ -388,6 +398,8 @@ def curve(
                 baseline=baseline,
                 xaxis=xaxis,
                 yaxis=yaxis,
+                dsamp_factor=dsamp_factor,
+                use_dsamp=use_dsamp,
             )
 
         basename = _("Curve")
@@ -409,6 +421,8 @@ def curve(
             shade,
             curvestyle,
             baseline,
+            dsamp_factor,
+            use_dsamp,
         )
         return self.pcurve(x, y, param, xaxis, yaxis)
 
@@ -501,6 +515,8 @@ def error(
         baseline: float | None = None,
         xaxis: str = "bottom",
         yaxis: str = "left",
+        dsamp_factor: int | None = None,
+        use_dsamp: bool | None = None,
     ) -> ErrorBarCurveItem:
         """Make an errorbar curve `plot item`
 
@@ -538,6 +554,8 @@ def error(
             baseline: baseline value. Default is None
             xaxis: x axis name. Default is 'bottom'
             yaxis: y axis name. Default is 'left'
+            dsamp_factor: downsampling factor. Default is None
+            use_dsamp: use downsampling. Default is None
 
         Returns:
             :py:class:`.ErrorBarCurveItem` object
@@ -567,6 +585,8 @@ def error(
             shade,
             curvestyle,
             baseline,
+            dsamp_factor,
+            use_dsamp,
         )
         errorbarparam.color = curveparam.line.color
         if errorbarwidth is not None:

plotpy/items/curve/base.py

@@ -365,14 +365,22 @@ def update_data(self):
         if isinstance(self._x, np.ndarray) and isinstance(self._y, np.ndarray):
             self._setData(self._x, self._y)
 
+    def dsamp(self, data: np.ndarray) -> np.ndarray:
+        """Downsample data
+
+        Args:
+            data: Data to downsample
+
+        Returns:
+            Downsampled data
+        """
+        if self.param.use_dsamp and self.param.dsamp_factor > 1:
+            return data[:: self.param.dsamp_factor]
+        return data
+
     def _setData(self, x: np.ndarray, y: np.ndarray):
         """Wrapper around QwtPlotCurve.setData() to handle downsampling"""
-        if not self.param.use_downsampling or self.param.downsampling_factor == 1:
-            return super().setData(x, y)
-        return super().setData(
-            x[:: self.param.downsampling_factor],
-            y[:: self.param.downsampling_factor],
-        )
+        return super().setData(self.dsamp(x), self.dsamp(y))
 
     def set_data(self, x: np.ndarray, y: np.ndarray) -> None:
         """Set curve data
@@ -449,9 +457,7 @@ def hit_test(self, pos: QC.QPointF) -> tuple[float, float, bool, None]:
             p1x = plot.transform(ax, self._x[i + 1])
             p1y = plot.transform(ay, self._y[i + 1])
         distance = seg_dist(QC.QPointF(pos), QC.QPointF(p0x, p0y), QC.QPointF(p1x, p1y))
-        final_index = i // (
-            int(not self.param.use_downsampling) or self.param.downsampling_factor
-        )
+        final_index = i // (int(not self.param.use_dsamp) or self.param.dsamp_factor)
         return distance, final_index, False, None
 
     def get_closest_coordinates(self, x: float, y: float) -> tuple[float, float]:

plotpy/items/curve/errorbar.py

@@ -72,7 +72,7 @@ def __init__(
         super().__init__(curveparam)
         self._dx = None
         self._dy = None
-        self._minmaxarrays: dict[bool, tuple[float, float, float, float]] = {}
+        self.__minmaxarrays: dict[bool, tuple[float, float, float, float]] = {}
         self.setIcon(get_icon("errorbar.png"))
 
     def serialize(
@@ -157,7 +157,7 @@ def set_data(
                 dy = None
         self._dx = dx
         self._dy = dy
-        self._minmaxarrays = {}
+        self.__minmaxarrays = {}
 
     def get_minmax_arrays(self, all_values: bool = True) -> tuple[float, ...]:
         """Get min/max arrays
@@ -168,11 +168,11 @@ def get_minmax_arrays(self, all_values: bool = True) -> tuple[float, ...]:
         Returns:
             tuple[float, ...]: Min/max arrays
         """
-        if self._minmaxarrays.get(all_values) is None:
-            x = self._x
-            y = self._y
-            dx = self._dx
-            dy = self._dy
+        if self.__minmaxarrays.get(all_values) is None:
+            x = self.dsamp(self._x)
+            y = self.dsamp(self._y)
+            dx = self.dsamp(self._dx)
+            dy = self.dsamp(self._dy)
             if all_values:
                 if dx is None:
                     xmin = xmax = x
@@ -182,7 +182,7 @@ def get_minmax_arrays(self, all_values: bool = True) -> tuple[float, ...]:
                     ymin = ymax = y
                 else:
                     ymin, ymax = y - dy, y + dy
-                self._minmaxarrays.setdefault(all_values, (xmin, xmax, ymin, ymax))
+                self.__minmaxarrays.setdefault(all_values, (xmin, xmax, ymin, ymax))
             else:
                 isf = np.logical_and(np.isfinite(x), np.isfinite(y))
                 if dx is not None:
@@ -197,10 +197,10 @@ def get_minmax_arrays(self, all_values: bool = True) -> tuple[float, ...]:
                     ymin = ymax = y[isf]
                 else:
                     ymin, ymax = y[isf] - dy[isf], y[isf] + dy[isf]
-                self._minmaxarrays.setdefault(
+                self.__minmaxarrays.setdefault(
                     all_values, (x[isf], y[isf], xmin, xmax, ymin, ymax)
                 )
-        return self._minmaxarrays[all_values]
+        return self.__minmaxarrays[all_values]
 
     def get_closest_coordinates(self, x: float, y: float) -> tuple[float, float]:
         """
@@ -218,8 +218,8 @@ def get_closest_coordinates(self, x: float, y: float) -> tuple[float, float]:
         xc = plot.transform(self.xAxis(), x)
         yc = plot.transform(self.yAxis(), y)
         _distance, i, _inside, _other = self.hit_test(QC.QPointF(xc, yc))
-        xi = self._x[i]
-        yi = self._y[i]
+        xi = self.dsamp(self._x)[i]
+        yi = self.dsamp(self._y)[i]
         xmin, xmax, ymin, ymax = self.get_minmax_arrays()
         if abs(y - y) > abs(y - ymin[i]):
             yi = ymin[i]
@@ -343,6 +343,11 @@ def draw(
     def update_params(self):
         """Update object properties from item parameters"""
         self.errorbarparam.update_item(self)
+
+        # In case the downsampling factor/state has changed,
+        # we need to invalidate cached data
+        self.__minmaxarrays = {}
+
         CurveItem.update_params(self)
 
     def update_item_parameters(self) -> None:

plotpy/locale/fr/LC_MESSAGES/plotpy.po

@@ -1420,17 +1420,25 @@ msgstr "Marqueurs"
 msgid "MAX resolution"
 msgstr "Résolution MAX"
 
-#: plotpy\tests\tools\test_downsample_curve.py:32
-#: plotpy\tests\tools\test_edit_point.py:51
-#: plotpy\tests\tools\test_get_point.py:31
-#: plotpy\tests\tools\test_get_points.py:32
-msgid "Select one point then press OK to accept"
-msgstr "Sélectionner un point puis cliquer sur OK pour valider"
+#: plotpy\tests\tools\test_downsample_curve.py:35
+msgid "Right-click on the curve to enable/disable downsampling"
+msgstr "Clic droit sur la courbe pour activer/désactiver le sous-échantillonnage"
 
-#: plotpy\tests\tools\test_edit_point.py:45 plotpy\tools\curve.py:814
+#: plotpy\tests\tools\test_edit_point.py:47 plotpy\tools\curve.py:818
 msgid "Insert point"
 msgstr "Insérer un point"
 
+#: plotpy\tests\tools\test_edit_point.py:65
+#: plotpy\tests\tools\test_get_point.py:36
+msgid "Select one point then press OK to accept"
+msgstr "Sélectionner un point puis cliquer sur OK pour valider"
+
+#: plotpy\tests\tools\test_get_points.py:40
+msgid ""
+"Select up to %s points then press OK to accept (hold Ctrl to select multiple "
+"points)"
+msgstr "Sélectionner jusqu'à %s points puis cliquer sur OK pour valider (maintenir Ctrl pour sélectionner plusieurs points)"
+
 #: plotpy\tests\widgets\test_simple_dialog.py:26
 #: plotpy\tests\widgets\test_simple_window.py:47
 msgid "Image width (pixels)"
@@ -1623,10 +1631,9 @@ msgstr "Avant d'insérer un nouveau point, sélectionner un point existant."
 msgid "Insert new value"
 msgstr "Insérer une nouvelle valeur"
 
-#: plotpy\tools\curve.py:853
-#, fuzzy
-msgid "Downsample curves"
-msgstr "Sous-échantillonnage (courbes)"
+#: plotpy\tools\curve.py:1073
+msgid "Downsample"
+msgstr "Sous-échantillonner"
 
 #: plotpy\tools\curve.py:893 plotpy\tools\curve.py:905
 msgid "Export"

plotpy/plot/manager.py

@@ -35,6 +35,7 @@
     DeleteItemTool,
     DisplayCoordsTool,
     DoAutoscaleTool,
+    DownSamplingTool,
     DummySeparatorTool,
     EditItemDataTool,
     ExportItemDataTool,
@@ -575,6 +576,7 @@ def register_curve_tools(self) -> None:
         self.add_tool(CurveStatsTool)
         self.add_tool(AntiAliasingTool)
         self.add_tool(AxisScaleTool)
+        self.add_tool(DownSamplingTool)
 
     def register_image_tools(self) -> None:
         """

plotpy/styles/curve.py

@@ -41,12 +41,12 @@ class CurveParam(DataSet):
     shade = FloatItem(_("Shadow"), default=0, min=0, max=1)
     curvestyle = ImageChoiceItem(_("Curve style"), CURVESTYLE_CHOICES, default="Lines")
     baseline = FloatItem(_("Baseline"), default=0.0)
-    _downsampling_prop = GetAttrProp("use_downsampling")
-    use_downsampling = BoolItem(_("Use downsampling"), default=False).set_prop(
-        "display", store=_downsampling_prop
+    _use_dsamp_prop = GetAttrProp("use_dsamp")
+    use_dsamp = BoolItem(_("Use downsampling"), default=False).set_prop(
+        "display", store=_use_dsamp_prop
     )
-    downsampling_factor = IntItem(_("Downsampling factor"), default=10, min=1).set_prop(
-        "display", active=_downsampling_prop
+    dsamp_factor = IntItem(_("Downsampling factor"), default=10, min=1).set_prop(
+        "display", active=_use_dsamp_prop
     )
 
     def update_param(self, curve: CurveItem | PolygonMapItem):
@@ -88,6 +88,8 @@ def update_item(self, curve: CurveItem | PolygonMapItem):
         # Curve style, type and baseline
         curve.setStyle(getattr(QwtPlotCurve, self.curvestyle))
         curve.setBaseline(self.baseline)
+        # Downsampling
+        curve.update_data()
         if plot is not None:
             plot.blockSignals(False)