PlotPy 2.0.1__tar.gz → 2.0.2__tar.gz

{PlotPy-2.0.1 → PlotPy-2.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PlotPy
-Version: 2.0.1
+Version: 2.0.2
 Summary: Curve and image plotting tools for Python/Qt applications
 Author-email: Codra <p.raybaut@codra.fr>
 License: BSD 3-Clause License

{PlotPy-2.0.1 → PlotPy-2.0.2}/PlotPy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PlotPy
-Version: 2.0.1
+Version: 2.0.2
 Summary: Curve and image plotting tools for Python/Qt applications
 Author-email: Codra <p.raybaut@codra.fr>
 License: BSD 3-Clause License

{PlotPy-2.0.1 → PlotPy-2.0.2}/plotpy/__init__.py

@@ -20,7 +20,7 @@ External resources:
 .. _GitHub: https://github.com/PierreRaybaut/plotpy
 """
 
-__version__ = "2.0.1"
+__version__ = "2.0.2"
 __VERSION__ = tuple([int(number) for number in __version__.split(".")])
 
 # --- Important note: DATAPATH and LOCALEPATH are used by guidata.configtools

{PlotPy-2.0.1 → PlotPy-2.0.2}/plotpy/interfaces/items.py

@@ -489,20 +489,24 @@ class IBaseImageItem:
 
 
 class IHistDataSource:
-    def get_histogram(self, nbins: int) -> tuple[np.ndarray, np.ndarray]:
+    def get_histogram(
+        self, nbins: int, drange: tuple[float, float] | None = None
+    ) -> tuple[np.ndarray, np.ndarray]:
         """
         Return a tuple (hist, bins) where hist is a list of histogram values
 
         Args:
-            nbins (int): number of bins
+            nbins: number of bins
+            drange: lower and upper range of the bins. If not provided, range is
+             simply (data.min(), data.max()). Values outside the range are ignored.
 
         Returns:
-            tuple: (hist, bins)
+            Tuple (hist, bins)
 
         Example of implementation:
 
-        def get_histogram(self, nbins):
+        def get_histogram(self, nbins, drange=None):
             data = self.get_data()
-            return np.histogram(data, nbins)
+            return np.histogram(data, bins=nbins, range=drange)
         """
         pass

{PlotPy-2.0.1 → PlotPy-2.0.2}/plotpy/items/histogram.py

@@ -38,17 +38,21 @@ class HistDataSource:
     def __init__(self, data: np.ndarray) -> None:
         self.data = data
 
-    def get_histogram(self, nbins: int) -> tuple[np.ndarray, np.ndarray]:
+    def get_histogram(
+        self, nbins: int, drange: tuple[float, float] | None = None
+    ) -> tuple[np.ndarray, np.ndarray]:
         """
         Return a tuple (hist, bins) where hist is a list of histogram values
 
         Args:
-            nbins (int): number of bins
+            nbins: number of bins
+            drange: lower and upper range of the bins. If not provided, range is
+             simply (data.min(), data.max()). Values outside the range are ignored.
 
         Returns:
-            tuple: (hist, bins)
+            Tuple (hist, bins)
         """
-        return np.histogram(self.data, nbins)
+        return np.histogram(self.data, bins=nbins, range=drange)
 
 
 assert_interfaces_valid(HistDataSource)
@@ -73,6 +77,7 @@ class HistogramItem(CurveItem):
         self.hist_count = None
         self.hist_bins = None
         self.bins = None
+        self.bin_range = None
         self.old_bins = None
         self.source: BaseImageItem | None = None
         self.logscale: bool | None = None
@@ -157,20 +162,38 @@ class HistogramItem(CurveItem):
         """
         return self.bins
 
+    def set_bin_range(self, bin_range: tuple[float, float] | None) -> None:
+        """Sets the range of the bins
+
+        Args:
+            bin_range: (min, max) or None for automatic range
+        """
+        self.bin_range = bin_range
+        self.update_histogram()
+
+    def get_bin_range(self) -> tuple[float, float] | None:
+        """Returns the range of the bins
+
+        Returns:
+            tuple: (min, max)
+        """
+        return self.bin_range
+
     def compute_histogram(self) -> tuple[np.ndarray, np.ndarray]:
         """Compute histogram data
 
         Returns:
             tuple: (hist, bins)
         """
-        return self.get_hist_source().get_histogram(self.bins)
+        return self.get_hist_source().get_histogram(self.bins, self.bin_range)
 
     def update_histogram(self) -> None:
         """Update histogram data"""
         if self.get_hist_source() is None:
             return
         hist, bin_edges = self.compute_histogram()
-        hist = np.concatenate((hist, [0]))
+        # Duplicate the first `hist` value to get a step-like histogram:
+        hist = np.concatenate(([hist[0]], hist))
         if self.logscale:
             hist = np.log(hist + 1)
 

{PlotPy-2.0.1 → PlotPy-2.0.2}/plotpy/items/image/base.py

@@ -946,22 +946,28 @@ class BaseImageItem(QwtPlotItem):
         """
         return False
 
-    def get_histogram(self, nbins: int) -> tuple[np.ndarray, np.ndarray]:
+    def get_histogram(
+        self, nbins: int, drange: tuple[float, float] | None = None
+    ) -> tuple[np.ndarray, np.ndarray]:
         """
         Return a tuple (hist, bins) where hist is a list of histogram values
 
         Args:
-            nbins (int): number of bins
+            nbins: number of bins
+            drange: lower and upper range of the bins. If not provided, range is
+             simply (data.min(), data.max()). Values outside the range are ignored.
 
         Returns:
-            tuple: (hist, bins)
+            Tuple (hist, bins)
         """
         if self.data is None:
             return [0], [0, 1]
         if self.histogram_cache is None or nbins != self.histogram_cache[0].shape[0]:
             if True:
                 # Note: np.histogram does not accept data with NaN
-                res = np.histogram(self.data[~np.isnan(self.data)], nbins)
+                res = np.histogram(
+                    self.data[~np.isnan(self.data)], bins=nbins, range=drange
+                )
             else:
                 # TODO: _histogram is faster, but caching is buggy in this version
                 _min, _max = get_nan_range(self.data)

{PlotPy-2.0.1 → PlotPy-2.0.2}/plotpy/items/image/misc.py

@@ -405,20 +405,26 @@ class Histogram2DItem(BaseImageItem):
         """
         return True
 
-    def get_histogram(self, nbins: int) -> tuple[np.ndarray, np.ndarray]:
+    def get_histogram(
+        self, nbins: int, drange: tuple[float, float] | None = None
+    ) -> tuple[np.ndarray, np.ndarray]:
         """
         Return a tuple (hist, bins) where hist is a list of histogram values
 
         Args:
-            nbins (int): number of bins
+            nbins: number of bins
+            drange: lower and upper range of the bins. If not provided, range is
+             simply (data.min(), data.max()). Values outside the range are ignored.
 
         Returns:
-            tuple: (hist, bins)
+            Tuple (hist, bins)
         """
         if self.data is None:
             return [0], [0, 1]
         _min, _max = get_nan_range(self.data)
-        if self.data.dtype in (np.float64, np.float32):
+        if drange is not None:
+            bins = np.linspace(drange[0], drange[1], nbins + 1)
+        elif self.data.dtype in (np.float64, np.float32):
             bins = np.unique(
                 np.array(np.linspace(_min, _max, nbins + 1), dtype=self.data.dtype)
             )

{PlotPy-2.0.1 → PlotPy-2.0.2}/plotpy/panels/contrastadjustment.py

@@ -19,6 +19,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
+import numpy as np
 from guidata.configtools import get_icon, get_image_layout
 from guidata.dataset import DataSet, FloatItem
 from guidata.qthelpers import add_actions, create_action
@@ -37,7 +38,7 @@ from plotpy.styles import CurveParam, HistogramParam
 from plotpy.tools import AntiAliasingTool, BasePlotMenuTool, SelectPointTool, SelectTool
 
 if TYPE_CHECKING:  # pragma: no cover
-    from collections.abc import Callable
+    from collections.abc import Callable, Generator
 
     from qtpy.QtWidgets import QWidget
 
@@ -65,14 +66,10 @@ class LevelsHistogram(BasePlot):
         self.antialiased = False
 
         # a dict of dict : plot -> selected items -> HistogramItem
-        self._tracked_items: dict[BasePlot, dict[BaseImageItem, CurveItem]] = {}
+        self._tracked_items: dict[BasePlot, dict[BaseImageItem, HistogramItem]] = {}
         self.param = CurveParam(_("Curve"), icon="curve.png")
         self.param.read_config(CONF, "histogram", "curve")
 
-        self.histparam = HistogramParam(_("Histogram"), icon="histogram.png")
-        self.histparam.logscale = False
-        self.histparam.n_bins = 256
-
         self.range = XRangeSelection(0, 1)
         self.range_mono_color = self.range.shapeparam.sel_line.color
         self.range_multi_color = CONF.get("histogram", "range/multi/color", "red")
@@ -103,11 +100,13 @@ class LevelsHistogram(BasePlot):
         plot.SIG_ITEM_REMOVED.connect(self.item_removed)
         plot.SIG_ACTIVE_ITEM_CHANGED.connect(self.active_item_changed)
 
-    def tracked_items_gen(self) -> tuple[BaseImageItem, CurveItem]:
+    def tracked_items_gen(
+        self,
+    ) -> Generator[tuple[BaseImageItem, HistogramItem], None, None]:
         """Generator of tracked items"""
-        for plot, items in list(self._tracked_items.items()):
-            for item in list(items.items()):
-                yield item  # tuple item,curve
+        for _plot, items in list(self._tracked_items.items()):
+            for item_curve_tuple in list(items.items()):
+                yield item_curve_tuple  # tuple item,curve
 
     def __del_known_items(self, known_items: dict, items: list) -> None:
         """Delete known items
@@ -129,7 +128,9 @@ class LevelsHistogram(BasePlot):
         Args:
             plot: plot whose selection changed
         """
-        items = plot.get_selected_items(item_type=IVoiImageItemType)
+        items: list[BaseImageItem] = plot.get_selected_items(
+            item_type=IVoiImageItemType
+        )
         known_items = self._tracked_items.setdefault(plot, {})
 
         if items:
@@ -153,13 +154,10 @@ class LevelsHistogram(BasePlot):
 
         for item in items:
             if item not in known_items:
-                imin, imax = item.get_lut_range_full()
-                delta = int(float(imax) - float(imin))
-                if delta > 0 and delta < 256:
-                    self.histparam.n_bins = delta
-                else:
-                    self.histparam.n_bins = 256
-                curve = HistogramItem(self.param, self.histparam, keep_weakref=True)
+                histparam = HistogramParam(_("Histogram"), icon="histogram.png")
+                histparam.logscale = False
+                histparam.n_bins = 256
+                curve = HistogramItem(self.param, histparam, keep_weakref=True)
                 curve.set_hist_source(item)
                 self.add_item(curve, z=0)
                 known_items[item] = curve
@@ -170,8 +168,18 @@ class LevelsHistogram(BasePlot):
             return
         self.param.shade = 1.0 / nb_selected
         for item, curve in self.tracked_items_gen():
+            if np.issubdtype(item.data.dtype, np.integer):
+                # For integer data, we use the full range of data type
+                info = np.iinfo(item.data.dtype)
+                curve.histparam.bin_min = info.min
+                curve.histparam.bin_max = info.max
+                curve.histparam.n_bins = min(info.max - info.min + 1, 256)
+            else:
+                curve.histparam.bin_min = None
+                curve.histparam.bin_max = None
+                curve.histparam.n_bins = 256
             self.param.update_item(curve)
-            self.histparam.update_hist(curve)
+            curve.histparam.update_hist(curve)
 
         self.active_item_changed(plot)
 
@@ -467,6 +475,7 @@ class ContrastAdjustment(PanelWidget):
             tip=_("Select minimum level on image"),
             toolbar_id="contrast",
             end_callback=self.apply_min_selection,
+            switch_to_default_tool=True,
         )
         self.max_select_tool = self.manager.add_tool(
             SelectPointTool,
@@ -476,6 +485,7 @@ class ContrastAdjustment(PanelWidget):
             tip=_("Select maximum level on image"),
             toolbar_id="contrast",
             end_callback=self.apply_max_selection,
+            switch_to_default_tool=True,
         )
 
     def get_plot(self) -> BasePlot:
@@ -536,6 +546,7 @@ class ContrastAdjustment(PanelWidget):
         point = self.min_select_tool.get_coordinates()
         z = item.get_data(*point)
         self.histogram.set_min(z)
+        tool.SIG_TOOL_JOB_FINISHED.emit()
 
     def apply_max_selection(self, tool: SelectPointTool) -> None:
         """Apply maximum selection
@@ -547,6 +558,7 @@ class ContrastAdjustment(PanelWidget):
         point = self.max_select_tool.get_coordinates()
         z = item.get_data(*point)
         self.histogram.set_max(z)
+        tool.SIG_TOOL_JOB_FINISHED.emit()
 
     def set_range(self, _min: float, _max: float) -> None:
         """Set contrast panel's histogram range

{PlotPy-2.0.1 → PlotPy-2.0.2}/plotpy/panels/csection/csitem.py

@@ -311,14 +311,6 @@ class CrossSectionItem(ErrorBarCurveItem):
         sectx, secty = self.get_cross_section(obj)
         if secty.size == 0 or np.all(np.isnan(secty)):
             sectx, secty = np.array([]), np.array([])
-        elif self.param.curvestyle != "Steps":
-            # Center the symbols at the middle of pixels
-            # Bugfix, we deactivate warnings only for numpy method call.
-            # (V1.0.10 => V1.0.11)
-            # Deactivate following warnings after 20210218 mail
-            # warnings.filterwarnings('ignore')
-            sectx[:-1] += np.mean(np.diff(sectx) / 2)
-            # warnings.filterwarnings('default')
         if self.orientation() == QC.Qt.Orientation.Vertical:
             self.process_curve_data(secty, sectx)
         else:

{PlotPy-2.0.1 → PlotPy-2.0.2}/plotpy/plot/base.py

@@ -2172,17 +2172,22 @@ class BasePlot(qwt.QwtPlot):
         return x0, x1, y0, y1
 
     # ---- Image scale/aspect ratio -related API -------------------------------
-    def get_current_aspect_ratio(self) -> float:
+    def get_current_aspect_ratio(self) -> float | None:
         """Return current aspect ratio
 
         Returns:
-            float: the current aspect ratio
+            The current aspect ratio or None if the aspect ratio cannot be computed
+            (this happens when the plot has been shrunk to a size so that the
+            width is zero)
         """
         dx = self.axisScaleDiv(self.X_BOTTOM).range()
         dy = self.axisScaleDiv(self.Y_LEFT).range()
         h = self.canvasMap(self.Y_LEFT).pDist()
         w = self.canvasMap(self.X_BOTTOM).pDist()
-        return fabs((h * dx) / (w * dy))
+        try:
+            return fabs((h * dx) / (w * dy))
+        except ZeroDivisionError:
+            return None
 
     def get_aspect_ratio(self) -> float:
         """Return aspect ratio
@@ -2220,7 +2225,9 @@ class BasePlot(qwt.QwtPlot):
         if not self.isVisible():
             return
         current_aspect = self.get_current_aspect_ratio()
-        if abs(current_aspect - self.__aspect_ratio) < self.EPSILON_ASPECT_RATIO:
+        if current_aspect is None or (
+            abs(current_aspect - self.__aspect_ratio) < self.EPSILON_ASPECT_RATIO
+        ):
             return
         ymap = self.canvasMap(self.Y_LEFT)
         xmap = self.canvasMap(self.X_BOTTOM)

{PlotPy-2.0.1 → PlotPy-2.0.2}/plotpy/styles/histogram.py

@@ -1,10 +1,15 @@
 # -*- coding: utf-8 -*-
 
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
 from guidata.dataset import (
     BoolItem,
     ChoiceItem,
     ColorItem,
     DataSet,
+    FloatItem,
     GetAttrProp,
     IntItem,
     StringItem,
@@ -14,26 +19,39 @@ from plotpy.config import _
 from plotpy.styles.base import ItemParameters
 from plotpy.styles.image import BaseImageParam
 
+if TYPE_CHECKING:  # pragma: no cover
+    from plotpy.items import Histogram2DItem, HistogramItem
+
 
 class HistogramParam(DataSet):
     n_bins = IntItem(_("Bins"), default=100, min=1, help=_("Number of bins"))
+    bin_min = FloatItem(_("Min"), default=None, help=_("Minimum value"), check=False)
+    bin_max = FloatItem(_("Max"), default=None, help=_("Maximum value"), check=False)
     logscale = BoolItem(_("logarithmic"), _("Y-axis scale"), default=False)
 
-    def update_param(self, obj):
-        """
+    def update_param(self, item: HistogramItem) -> None:
+        """Update the histogram parameters from the plot item
 
-        :param obj:
+        Args:
+            item: Histogram item
         """
-        self.n_bins = obj.get_bins()
-        self.logscale = obj.get_logscale()
+        self.n_bins = item.get_bins()
+        self.bin_min, self.bin_max = item.get_bin_range()
+        self.logscale = item.get_logscale()
 
-    def update_hist(self, hist):
-        """
+    def update_hist(self, item: HistogramItem) -> None:
+        """Update the histogram plot item from the parameters
 
-        :param hist:
+        Args:
+            item: Histogram item
         """
-        hist.set_bins(self.n_bins)
-        hist.set_logscale(self.logscale)
+        if self.bin_min is None or self.bin_max is None:
+            item.bin_range = None
+        else:
+            item.bin_range = (self.bin_min, self.bin_max)
+        item.bins = self.n_bins
+        item.logscale = self.logscale
+        item.update_histogram()
 
 
 class Histogram2DParam(BaseImageParam):
@@ -79,24 +97,26 @@ class Histogram2DParam(BaseImageParam):
         help=_("Background color when no data is present"),
     )
 
-    def update_param(self, obj):
-        """
+    def update_param(self, item: Histogram2DItem) -> None:
+        """Update the histogram parameters from the plot item
 
-        :param obj:
+        Args:
+            item: 2D Histogram item
         """
-        super().update_param(obj)
-        self.logscale = obj.logscale
-        self.nx_bins, self.ny_bins = obj.nx_bins, obj.ny_bins
+        super().update_param(item)
+        self.logscale = item.logscale
+        self.nx_bins, self.ny_bins = item.nx_bins, item.ny_bins
 
-    def update_histogram(self, histogram):
-        """
+    def update_histogram(self, item: Histogram2DItem) -> None:
+        """Update the histogram plot item from the parameters
 
-        :param histogram:
+        Args:
+            item: 2D Histogram item
         """
-        histogram.logscale = int(self.logscale)
-        histogram.set_background_color(self.background)
-        histogram.set_bins(self.nx_bins, self.ny_bins)
-        self.update_item(histogram)
+        item.logscale = int(self.logscale)
+        item.set_background_color(self.background)
+        item.set_bins(self.nx_bins, self.ny_bins)
+        self.update_item(item)
 
 
 class Histogram2DParam_MS(Histogram2DParam):

{PlotPy-2.0.1 → PlotPy-2.0.2}/plotpy/tests/features/test_manager.py

@@ -8,6 +8,7 @@
 # guitest: show
 
 from guidata.qthelpers import qt_app_context, win32_fix_title_bar_background
+from qtpy import QtCore as QC
 from qtpy import QtWidgets as QW
 
 from plotpy.builder import make
@@ -45,6 +46,12 @@ class CentralWidget(QW.QWidget):
     def register_tools(self):
         self.manager.register_all_image_tools()
 
+    def minimumSizeHint(self):
+        """Override QWidget method"""
+        # The purpose of this reimplementation is to trigger the issue #3
+        # (see https://github.com/PlotPyStack/PlotPy/issues/3)
+        return QC.QSize(150, 100)
+
 
 class Window(QW.QMainWindow):
     def __init__(self):
@@ -75,5 +82,19 @@ def test_manager():
         win.show()
 
 
+def test_resize_to_minimum_width():
+    """Testing resize window to minimum width"""
+    # This test was failing at the time of Issue #3
+    # (see https://github.com/PlotPyStack/PlotPy/issues/3)
+    with qt_app_context(exec_loop=False):
+        win = Window()
+        win.show()
+        width = 350
+        while width > win.minimumWidth():
+            width -= 1
+            win.resize(width, 100)
+
+
 if __name__ == "__main__":
     test_manager()
+    # test_resize_to_minimum_width()

{PlotPy-2.0.1 → PlotPy-2.0.2}/plotpy/tests/items/test_mandelbrot.py

@@ -15,7 +15,7 @@ from plotpy.builder import make
 from plotpy.config import _
 from plotpy.items import RawImageItem
 from plotpy.mandelbrot import mandelbrot
-from plotpy.tools.base import ToggleTool
+from plotpy.tools import ToggleTool
 
 
 class FullScale(ToggleTool):
@@ -64,20 +64,26 @@ class MandelItem(RawImageItem):
         )
 
 
+def create_mandelbrot_window():
+    """Create a Mandelbrot set window"""
+    win = make.window(
+        toolbar=True,
+        wintitle="Mandelbrot",
+        yreverse=False,
+        type="image",
+    )
+    mandel = MandelItem(-1.5, 0.5, -1.0, 1.0)
+    fstool = win.manager.add_tool(FullScale, mandel)
+    plot = win.get_plot()
+    plot.set_aspect_ratio(lock=False)
+    plot.add_item(mandel)
+    return win, mandel, fstool
+
+
 def test_mandel():
+    """Test Mandelbrot set window"""
     with qt_app_context(exec_loop=True):
-        win = make.dialog(
-            edit=True,
-            toolbar=True,
-            wintitle="Mandelbrot",
-            yreverse=False,
-            type="image",
-        )
-        mandel = MandelItem(-1.5, 0.5, -1.0, 1.0)
-        win.manager.add_tool(FullScale, mandel)
-        plot = win.manager.get_plot()
-        plot.set_aspect_ratio(lock=False)
-        plot.add_item(mandel)
+        win, _mandel, _fstool = create_mandelbrot_window()
         win.show()