Replace internal contour2d by scikit-images's find_contours

Attemp to fix #17

Author: PierreRaybaut

.gitignore

@@ -43,7 +43,6 @@ pylint_report.txt
 docs/build/
 
 # Generated cython c file
-src/contour2d.c
 src/histogram2d.c
 src/mandelbrot.c
 

.pylintrc

@@ -4,7 +4,7 @@
 max-line-length=88
 
 [TYPECHECK]
-ignored-modules=qtpy.QtWidgets,qtpy.QtCore,qtpy.QtGui,qtpy.QtSvg,qtpy.QtPrintSupport,qtpy.QtDesigner,plotpy._scaler,plotpy.mandelbrot,plotpy.contour2d,plotpy.histogram2d,PyQt5.QtWidgets
+ignored-modules=qtpy.QtWidgets,qtpy.QtCore,qtpy.QtGui,qtpy.QtSvg,qtpy.QtPrintSupport,qtpy.QtDesigner,plotpy._scaler,plotpy.mandelbrot,plotpy.histogram2d,PyQt5.QtWidgets
 
 [MESSAGES CONTROL]
 disable=wrong-import-order

CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog #
 
+## Version 2.4.2 ##
+
+In this release, test coverage is 79%.
+
+🛠️ Bug fixes:
+
+* [Issue #17](https://github.com/PlotPyStack/PlotPy/issues/17):
+  * Debian's Python team has reported that the contour unit test was failing on `arm64`
+    architecture
+  * This is the opportunity to replace the `contour2d` Cython extension by scikit-image's
+    `find_contours` function, thus avoiding to reinvent the wheel by relying on a more
+    robust and tested implementation
+  * The `contour2d` Cython extension is removed from the source code
+  * The contour related features remain the same, but the implementation is now based on
+    scikit-image's `find_contours` function
+  * The scikit-image dependency is added to the package requirements
+
 ## Version 2.4.1 ##
 
 In this release, test coverage is 79%.

plotpy/items/contour.py

@@ -26,9 +26,9 @@
 import numpy as np
 from guidata.configtools import get_icon
 from guidata.utils.misc import assert_interfaces_valid
+from skimage import measure
 
 from plotpy.config import _
-from plotpy.contour2d import contour_2d_grid, contour_2d_ortho
 from plotpy.items.shape.polygon import PolygonShape
 from plotpy.styles import ShapeParam
 
@@ -73,64 +73,33 @@ def compute_contours(
         raise TypeError("Input z must be a 2D array.")
     elif z.shape[0] < 2 or z.shape[1] < 2:
         raise TypeError("Input z must be at least a 2x2 array.")
-    else:
-        Ny, Nx = z.shape
-
-    if X is None:
-        X = np.arange(Nx)
-    if Y is None:
-        Y = np.arange(Ny)
-
-    x = np.asarray(X, dtype=np.float64)
-    y = np.asarray(Y, dtype=np.float64)
-
-    if x.ndim != y.ndim:
-        raise TypeError("Number of dimensions of x and y should match.")
-    if x.ndim == 1:
-        (nx,) = x.shape
-        (ny,) = y.shape
-        if nx != Nx:
-            raise TypeError("Length of x must be number of columns in z.")
-        if ny != Ny:
-            raise TypeError("Length of y must be number of rows in z.")
-    elif x.ndim == 2:
-        if x.shape != z.shape:
-            raise TypeError(
-                "Shape of x does not match that of z: found "
-                "{0} instead of {1}.".format(x.shape, z.shape)
-            )
-        if y.shape != z.shape:
-            raise TypeError(
-                "Shape of y does not match that of z: found "
-                "{0} instead of {1}.".format(y.shape, z.shape)
-            )
-    else:
-        raise TypeError("Inputs x and y must be 1D or 2D.")
 
     if isinstance(levels, np.ndarray):
         levels = np.asarray(levels, dtype=np.float64)
     else:
         levels = np.asarray([levels], dtype=np.float64)
 
-    if x.ndim == 2:
-        func = contour_2d_grid
+    if X is None:
+        delta_x, x_origin = 1.0, 0.0
+    else:
+        delta_x, x_origin = X[0, 1] - X[0, 0], X[0, 0]
+    if Y is None:
+        delta_y, y_origin = 1.0, 0.0
     else:
-        func = contour_2d_ortho
-
-    lines = []
-    points, offsets = func(z, x, y, levels)
-    start = 0
-    v = 0
-    for v, index in offsets:
-        if index - start >= 2:
-            cline = ContourLine.create(vertices=points[start:index], level=levels[v])
-            lines.append(cline)
-        start = index
-    last_points = points[start:]
-    if len(last_points) >= 2:
-        cline = ContourLine.create(vertices=last_points, level=levels[v])
-        lines.append(cline)
-    return lines
+        delta_y, y_origin = Y[1, 0] - Y[0, 0], Y[0, 0]
+
+    # Find contours in the binary image for each level
+    clines = []
+    for level in levels:
+        for contour in measure.find_contours(Z, level):
+            contour = contour.squeeze()
+            if len(contour) > 1:  # Avoid single points
+                line = np.zeros_like(contour, dtype=np.float32)
+                line[:, 0] = contour[:, 1] * delta_x + x_origin
+                line[:, 1] = contour[:, 0] * delta_y + y_origin
+                cline = ContourLine.create(vertices=line, level=level)
+                clines.append(cline)
+    return clines
 
 
 class ContourItem(PolygonShape):
@@ -179,11 +148,12 @@ def create_contour_items(
         A list of :py:class:`.ContourItem` instances.
     """
     items = []
-    lines = compute_contours(Z, levels, X, Y)
-    for line in lines:
+
+    contours = compute_contours(Z, levels, X, Y)
+    for cline in contours:
         param = ShapeParam("Contour", icon="contour.png")
-        item = ContourItem(points=line.vertices, shapeparam=param)
+        item = ContourItem(points=cline.vertices, shapeparam=param)
         item.set_style("plot", "shape/contour")
-        item.setTitle(_("Contour") + f"[Z={line.level}]")
+        item.setTitle(_("Contour") + f"[Z={cline.level}]")
         items.append(item)
     return items

plotpy/tests/data.py

@@ -164,3 +164,14 @@ def gen_2d_gaussian(size, dtype, x0=0, y0=0, mu=0.0, sigma=2.0, amp=None):
         amp = np.iinfo(dtype).max * 0.5
     t = (np.sqrt((x - x0) ** 2 + (y - y0) ** 2) - mu) ** 2
     return np.array(amp * np.exp(-t / (2.0 * sigma**2)), dtype=dtype)
+
+
+def gen_xyz_data():
+    """Create a X, Y, Z data set for contour detection features"""
+    delta = 0.025
+    x, y = np.arange(-3.0, 3.0, delta), np.arange(-2.0, 2.0, delta)
+    X, Y = np.meshgrid(x, y)
+    Z1 = np.exp(-(X**2) - Y**2)
+    Z2 = np.exp(-((X - 1) ** 2) - (Y - 1) ** 2)
+    Z = (Z1 - Z2) * 2
+    return X, Y, Z

plotpy/tests/items/test_image_contour.py

@@ -12,22 +12,15 @@
 
 from plotpy.builder import make
 from plotpy.tests import vistools as ptv
+from plotpy.tests.data import gen_xyz_data
 
 
 def test_contour():
     """Contour plotting test"""
     with qt_app_context(exec_loop=True):
-        # compute the image
-        delta = 0.025
-        x, y = np.arange(-3.0, 3.0, delta), np.arange(-2.0, 2.0, delta)
-        X, Y = np.meshgrid(x, y)
-        Z1 = np.exp(-(X**2) - Y**2)
-        Z2 = np.exp(-((X - 1) ** 2) - (Y - 1) ** 2)
-        Z = (Z1 - Z2) * 2
-
-        # show the image
+        _x, _y, z = gen_xyz_data()
         _win = ptv.show_items(
-            [make.image(Z)] + make.contours(Z, np.arange(-2, 2, 0.5)),
+            [make.image(z)] + make.contours(z, np.arange(-2, 2, 0.5)),
             wintitle=test_contour.__doc__,
             curve_antialiasing=False,
             lock_aspect_ratio=True,

plotpy/tests/unit/test_contour.py

@@ -3,6 +3,7 @@
 import numpy as np
 
 from plotpy.items.contour import compute_contours
+from plotpy.tests.data import gen_xyz_data
 
 
 class ContourTest(unittest.TestCase):
@@ -14,18 +15,12 @@ class ContourTest(unittest.TestCase):
     """
 
     def setUp(self):
-        delta = 0.025
-        self.x = np.arange(-3.0, 3.0, delta)
-        self.y = np.arange(-2.0, 2.0, delta)
-        self.X, self.Y = np.meshgrid(self.x, self.y)
-        Z1 = np.exp(-self.X**2 - self.Y**2)
-        Z2 = np.exp(-((self.X - 1) ** 2) - (self.Y - 1) ** 2)
-        self.Z = (Z1 - Z2) * 2
+        self.X, self.Y, self.Z = gen_xyz_data()
 
     def test_contour_level_1(self):
         """Test that contour() returns one closed line when level is 1.0"""
         # Ortho coord
-        lines = compute_contours(self.Z, 1.0, self.x, self.y)
+        lines = compute_contours(self.Z, 1.0, self.X, self.Y)
         assert len(lines) == 1
         assert np.all(np.equal(lines[0].vertices[0], lines[0].vertices[-1]))
         assert lines[0].level == 1.0
@@ -40,21 +35,21 @@ def test_contour_level_diag_0(self):
         """Test that contour() returns opened lines (diagonal) when level is 0.0"""
         lines = compute_contours(self.Z, 0.0, self.X, self.Y)
         assert len(lines) == 1
-        assert np.all(lines[0].vertices[0] != lines[0].vertices[-1])
+        assert np.any(lines[0].vertices[0] != lines[0].vertices[-1])
         assert lines[0].level == 0.0
 
     def test_contour_level_opened_neg_0_5(self):
         """Test that contour() returns opened lines when level is -0.5"""
         lines = compute_contours(self.Z, -0.5, self.X, self.Y)
         assert len(lines) == 1
-        assert np.all(lines[0].vertices[0] != lines[0].vertices[-1])
+        assert np.any(lines[0].vertices[0] != lines[0].vertices[-1])
         assert lines[0].level == -0.5
 
     def test_contour_abs_level_1(self):
         """Test that contour() returns two closed lines when level is 1.0
         and data are absolute.
         """
-        lines = compute_contours(np.abs(self.Z), 1.0, self.x, self.y)
+        lines = compute_contours(np.abs(self.Z), 1.0, self.X, self.Y)
         assert len(lines) == 2
         for line in lines:
             assert np.all(np.equal(line.vertices[0], line.vertices[-1]))

pyproject.toml

@@ -48,6 +48,7 @@ dependencies = [
     "PythonQwt>=0.12.1",
     "NumPy>=1.17",
     "SciPy>=1.3",
+    "scikit-image >= 0.18",
     "Pillow",
     "tifffile",
 ]

setup.py

@@ -71,13 +71,6 @@ def compile_cython_extensions():
             extra_compile_args=CFLAGS_CYTHON,
             define_macros=MACROS_CYTHON,
         ),
-        Extension(
-            name=f"{LIBNAME}.contour2d",
-            sources=[osp.join(SRCPATH, "contour2d.c")],
-            include_dirs=INCLUDE_DIRS,
-            extra_compile_args=CFLAGS_CYTHON,
-            define_macros=MACROS_CYTHON,
-        ),
         Extension(
             name=f"{LIBNAME}._scaler",
             sources=[osp.join(SRCPATH, "scaler.cpp"), osp.join(SRCPATH, "pcolor.cpp")],