PlotPy 2.8.1__tar.gz → 2.8.2__tar.gz

{plotpy-2.8.1 → plotpy-2.8.2}/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog #
 
+## Version 2.8.2 ##
+
+🛠️ Bug fixes:
+
+* Fixed `RuntimeWarning` when changing masked image data type from float to integer:
+  * `MaskedImageItem.update_mask()` now handles NaN and None `filling_value` gracefully
+  * When converting to integer dtypes, NaN/None values are replaced with 0 instead of triggering numpy cast warnings
+  * When converting to float dtypes, NaN is preserved as the fill value
+  * Added comprehensive tests to validate dtype conversion scenarios
+
 ## Version 2.8.1 ##
 
 🛠️ Bug fixes:

{plotpy-2.8.1/PlotPy.egg-info → plotpy-2.8.2}/PKG-INFO

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

{plotpy-2.8.1 → plotpy-2.8.2/PlotPy.egg-info}/PKG-INFO

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

{plotpy-2.8.1 → plotpy-2.8.2}/PlotPy.egg-info/SOURCES.txt

@@ -373,6 +373,7 @@ plotpy/tests/vistools.py
 plotpy/tests/benchmarks/__init__.py
 plotpy/tests/benchmarks/test_benchmarks.py
 plotpy/tests/benchmarks/test_bigimages.py
+plotpy/tests/benchmarks/test_large_number_of_annotations.py
 plotpy/tests/benchmarks/test_loadtest.py
 plotpy/tests/data/brain.png
 plotpy/tests/data/brain_cylinder.png
@@ -464,6 +465,7 @@ plotpy/tests/unit/test_line.py
 plotpy/tests/unit/test_line_cross_section_tool.py
 plotpy/tests/unit/test_manipulate_selection.py
 plotpy/tests/unit/test_mask_tool.py
+plotpy/tests/unit/test_masked_dtype_change.py
 plotpy/tests/unit/test_multiline_tools.py
 plotpy/tests/unit/test_oblique_cross_section_tool.py
 plotpy/tests/unit/test_plot_curve.py

{plotpy-2.8.1 → plotpy-2.8.2}/plotpy/__init__.py

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

{plotpy-2.8.1 → plotpy-2.8.2}/plotpy/items/image/masked.py

@@ -150,12 +150,25 @@ class MaskedImageMixin:
     def update_mask(self) -> None:
         """Update mask"""
         if isinstance(self.data, np.ma.MaskedArray):
-            # Casting filling_value to data dtype, otherwise this may raise an error
-            # in future versions of NumPy (at the time of writing, this raises a
-            # DeprecationWarning "NumPy will stop allowing conversion of out-of-bound
-            # Python integers to integer arrays.")
-            val = np.array(self.param.filling_value).astype(self.data.dtype)
-
+            filling_value = self.param.filling_value
+            if filling_value is None or (
+                isinstance(filling_value, float) and np.isnan(filling_value)
+            ):
+                # Use a safe default for integer types when filling_value is None or NaN
+                if np.issubdtype(self.data.dtype, np.integer):
+                    val = np.array(0, dtype=self.data.dtype)
+                else:
+                    val = np.array(np.nan, dtype=self.data.dtype)
+            else:
+                # If filling_value is out of bounds for data dtype, get the default
+                # fill value for that dtype
+                if np.issubdtype(self.data.dtype, np.integer):
+                    info = np.iinfo(self.data.dtype)
+                    if filling_value < info.min or filling_value > info.max:
+                        # Using the default fill value thanks to the get_fill_value()
+                        # method of MaskedArray:
+                        filling_value = self.data.get_fill_value()
+                val = np.array(filling_value).astype(self.data.dtype)
             self.data.set_fill_value(val)
 
     def set_mask(self, mask: ma.MaskedArray) -> None:

{plotpy-2.8.1 → plotpy-2.8.2}/plotpy/plot/manager.py

@@ -718,6 +718,7 @@ class PlotManager:
         self.add_tool(tools.AnnotatedPointTool)
         self.add_tool(tools.AnnotatedSegmentTool)
         self.add_tool(tools.AnnotatedRectangleTool)
+        self.add_tool(tools.AnnotatedPolygonTool)
         self.add_tool(tools.AnnotatedObliqueRectangleTool)
         self.add_tool(tools.AnnotatedCircleTool)
         self.add_tool(tools.AnnotatedEllipseTool)

plotpy-2.8.2/plotpy/tests/benchmarks/test_large_number_of_annotations.py

@@ -0,0 +1,122 @@
+# -*- coding: utf-8 -*-
+#
+# Licensed under the terms of the BSD 3-Clause
+# (see plotpy/LICENSE for details)
+
+"""Large number of annotations test"""
+
+# guitest: show
+
+import timeit
+
+import numpy as np
+from guidata.qthelpers import qt_app_context
+
+from plotpy.builder import make
+from plotpy.tests import data as ptd
+from plotpy.tests import vistools as ptv
+
+WIN_REFS = []
+
+
+def plot(items, title):
+    """Plot items"""
+    global WIN_REFS
+    title = f"{title} - #refs: {len(WIN_REFS) + 1}"
+    win = ptv.show_items(items, plot_type="image", wintitle=title, title=title)
+    WIN_REFS.append(win)
+    return win
+
+
+def create_polygon_vertices(
+    x0: float, y0: float, nb_points: int, radius_mean: float, radius_variation: float
+) -> list[tuple[float, float]]:
+    """Generate points for a polygon around (x0, y0)
+
+    Args:
+        x0: x coordinate of the polygon center
+        y0: y coordinate of the polygon center
+        nb_points: number of points to generate
+        radius_mean: mean radius of the polygon
+        radius_variation: variation in radius
+
+    Returns:
+        List of (x, y) points representing the polygon vertices
+    """
+    points = []
+    # Calculate number of NaNs to append (random numbers between 0 and nb_points-10):
+    num_nans = np.random.randint(0, nb_points - 10)
+    for j in range(nb_points - num_nans):
+        angle = j * (2 * np.pi / (nb_points - num_nans))
+        radius = radius_mean + radius_variation * np.random.rand()
+        x = x0 + radius * np.cos(angle)
+        y = y0 + radius * np.sin(angle)
+        points.append((x, y))
+    for _ in range(num_nans):
+        points.append((np.nan, np.nan))
+    return points
+
+
+def create_random_polygons(
+    size: int, nb_polygons: int, nb_points_per_polygon: int
+) -> np.ndarray:
+    """Create random polygons
+
+    Args:
+        size: size of the area in which to create polygons
+        nb_polygons: number of polygons to create
+        nb_points_per_polygon: number of points per polygon
+
+    Returns:
+        Array of shape (nb_polygons, nb_points_per_polygon, 2)
+    """
+    polygons = []
+    for _ in range(nb_polygons):
+        x0 = size * np.random.rand()
+        y0 = size * np.random.rand()
+        points = create_polygon_vertices(
+            x0, y0, nb_points_per_polygon, radius_mean=20, radius_variation=30
+        )
+        # Append the flattened points:
+        polygons.append(points)
+    return np.array(polygons)
+
+
+def test_large_number_of_annotations(measure_execution_time: bool = False):
+    """Test large number of annotations
+
+    Args:
+        measure_execution_time: if True, measure and print the execution time, then
+         quit the application immediately.
+    """
+    title = "Large number of annotations test"
+    size = 2000
+    nb_polygons = 100
+    nb_points_per_polygon = 120
+    with qt_app_context(exec_loop=not measure_execution_time):
+        data = ptd.gen_image4(size, size)
+        x = np.linspace(0, size - 1, size)
+        y = np.linspace(0, size - 1, size)
+        item = make.xyimage(x, y, data)
+        item.set_readonly(True)
+        item.set_selectable(False)
+        items = [item]
+        polygons = create_random_polygons(size, nb_polygons, nb_points_per_polygon)
+        for i, points in enumerate(polygons):
+            polygon = make.annotated_polygon(np.array(points), title=f"Polygon {i + 1}")
+            polygon.set_closed(False)
+            items.append(polygon)
+        if measure_execution_time:
+            exec_time = timeit.timeit(lambda: plot(items, title), number=10) / 10
+            print(
+                f"Execution time with {nb_polygons} polygons "
+                f"({nb_points_per_polygon} points per polygon): "
+                f"{exec_time:.3f} seconds/plot"
+            )
+        else:
+            win = plot(items, title)
+            win.register_annotation_tools()
+
+
+if __name__ == "__main__":
+    test_large_number_of_annotations(measure_execution_time=True)

plotpy-2.8.2/plotpy/tests/unit/test_masked_dtype_change.py

@@ -0,0 +1,125 @@
+# -*- coding: utf-8 -*-
+#
+# Licensed under the terms of the BSD 3-Clause
+# (see plotpy/LICENSE for details)
+
+"""
+Test for MaskedImageItem dtype changes
+
+This test verifies that changing the data type of a masked image from float to
+integer types (like float64 to uint8) doesn't raise RuntimeWarnings when the
+filling_value is NaN or None.
+"""
+
+from __future__ import annotations
+
+import warnings
+
+import numpy as np
+
+from plotpy.builder import make
+
+
+def test_masked_image_dtype_change_from_float_to_uint8():
+    """Test changing masked image dtype from float64 to uint8 with NaN filling_value"""
+    # Create a float64 masked array with NaN as fill value (the default)
+    data = np.random.rand(10, 10).astype(np.float64)
+    mask = np.zeros_like(data, dtype=bool)
+    mask[3:5, 3:5] = True
+    masked_data = np.ma.masked_array(data, mask=mask)
+
+    # Create masked image item
+    item = make.maskedimage(masked_data, colormap="viridis", show_mask=True)
+
+    # Verify initial state
+    assert item.data.dtype == np.float64
+
+    # Set filling_value to NaN (typical for float images)
+    item.param.filling_value = np.nan
+
+    # Change data dtype to uint8
+    new_data = (masked_data * 255).astype(np.uint8)
+    item.set_data(new_data)
+
+    # This should not raise a RuntimeWarning
+    with warnings.catch_warnings(record=True) as warning_list:
+        warnings.simplefilter("always")
+        item.update_mask()
+
+    # Check that no RuntimeWarning was raised
+    runtime_warnings = [
+        w for w in warning_list if issubclass(w.category, RuntimeWarning)
+    ]
+    assert len(runtime_warnings) == 0, "RuntimeWarning should not be raised"
+
+    # Verify the data type changed
+    assert item.data.dtype == np.uint8
+
+
+def test_masked_image_dtype_change_with_none_filling_value():
+    """Test changing masked image dtype with None filling_value"""
+    # Create a float64 masked array
+    data = np.random.rand(10, 10).astype(np.float64)
+    mask = np.zeros_like(data, dtype=bool)
+    mask[3:5, 3:5] = True
+    masked_data = np.ma.masked_array(data, mask=mask)
+
+    # Create masked image item
+    item = make.maskedimage(masked_data, colormap="viridis", show_mask=True)
+
+    # Set filling_value to None
+    item.param.filling_value = None
+
+    # Change data dtype to uint8
+    new_data = (masked_data * 255).astype(np.uint8)
+    item.set_data(new_data)
+
+    # This should not raise a RuntimeWarning
+    with warnings.catch_warnings(record=True) as warning_list:
+        warnings.simplefilter("always")
+        item.update_mask()
+
+    # Check that no RuntimeWarning was raised
+    runtime_warnings = [
+        w for w in warning_list if issubclass(w.category, RuntimeWarning)
+    ]
+    assert len(runtime_warnings) == 0, "RuntimeWarning should not be raised"
+
+
+def test_masked_image_filling_value_defaults():
+    """Test that filling_value defaults are appropriate for different dtypes"""
+    test_dtypes = [np.uint8, np.uint16, np.int16, np.float32, np.float64]
+
+    for dtype in test_dtypes:
+        data = np.random.rand(5, 5)
+        if np.issubdtype(dtype, np.integer):
+            data = (data * 100).astype(dtype)
+        else:
+            data = data.astype(dtype)
+
+        mask = np.zeros_like(data, dtype=bool)
+        mask[2:3, 2:3] = True
+        masked_data = np.ma.masked_array(data, mask=mask)
+
+        item = make.maskedimage(masked_data, colormap="viridis", show_mask=True)
+
+        # Set filling_value to NaN (typical initial state for float images)
+        item.param.filling_value = np.nan
+
+        # This should handle the conversion gracefully
+        with warnings.catch_warnings(record=True) as warning_list:
+            warnings.simplefilter("always")
+            item.update_mask()
+
+        # Check that no RuntimeWarning was raised
+        runtime_warnings = [
+            w for w in warning_list if issubclass(w.category, RuntimeWarning)
+        ]
+        assert len(runtime_warnings) == 0, f"RuntimeWarning for dtype {dtype}"
+
+
+if __name__ == "__main__":
+    test_masked_image_dtype_change_from_float_to_uint8()
+    test_masked_image_dtype_change_with_none_filling_value()
+    test_masked_image_filling_value_defaults()
+    print("All tests passed!")