Use contourpy for quad contour calculations

Author: ianthomas23

.github/workflows/tests.yml

@@ -161,7 +161,7 @@ jobs:
 
           # Install dependencies from PyPI.
           python -m pip install --upgrade $PRE \
-            cycler fonttools kiwisolver numpy packaging pillow pyparsing \
+            contourpy>=1.0.1 cycler fonttools kiwisolver numpy packaging pillow pyparsing \
             python-dateutil setuptools-scm \
             -r requirements/testing/all.txt \
             ${{ matrix.extra-requirements }}

doc/api/next_api_changes/behavior/22229-TAC.rst

@@ -1,5 +1,5 @@
-AritistList proxies copy contents on iteration
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ArtistList proxies copy contents on iteration
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 When iterating over the contents of the the dynamically generated proxy lists
 for the Artist-type accessors (see :ref:`Behavioural API Changes 3.5 - Axes

doc/api/next_api_changes/behavior/22567-IT.rst

@@ -0,0 +1,13 @@
+New algorithm keyword argument to contour and contourf
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The contouring functions `~matplotlib.axes.Axes.contour` and
+`~matplotlib.axes.Axes.contourf` have a new keyword argument ``algorithm`` to
+control which algorithm is used to calculate the contours. There is a choice
+of four algorithms to use, and the default is to use ``algorithm='mpl2014'``
+which is the same algorithm that Matplotlib has been using since 2014.
+
+Other possible values of the ``algorithm`` keyword argument are ``'mpl2005'``,
+``'serial'`` and ``'threaded'``; see the
+`ContourPy documentation <https://contourpy.readthedocs.io>`_ for further
+details.

doc/users/next_whats_new/use_contourpy.rst

@@ -0,0 +1,27 @@
+New external dependency ContourPy used for quad contour calculations
+--------------------------------------------------------------------
+
+Previously Matplotlib shipped its own C++ code for calculating the contours of
+quad grids . Now the external library
+`ContourPy <https://github.com/contourpy/contourpy>`_ is used instead. There
+is a choice of four algorithms to use, controlled by the ``algorithm`` keyword
+argument to the functions `~matplotlib.axes.Axes.contour` and
+`~matplotlib.axes.Axes.contourf`. The default behaviour is to use
+``algorithm='mpl2014'`` which is the same algorithm that Matplotlib has been
+using since 2014.
+
+See the `ContourPy documentation <https://contourpy.readthedocs.io>`_ for
+further details of the different algorithms.
+
+.. note::
+
+   Contour lines and polygons produced by ``algorithm='mpl2014'`` will be the
+   same as those produced before this change to within floating-point
+   tolerance. The exception is for duplicate points, i.e. contours containing
+   adjacent (x, y) points that are identical; previously the duplicate points
+   were removed, now they are kept. Contours affected by this will produce the
+   same visual output, but there will be a greater number of points in the
+   contours.
+
+   The locations of contour labels obtained by using
+   `~matplotlib.axes.Axes.clabel` may also be different.

environment.yml

@@ -9,6 +9,7 @@ channels:
   - conda-forge
 dependencies:
   - cairocffi
+  - contourpy>=1.0.1
   - cycler>=0.10.0
   - fonttools>=4.22.0
   - kiwisolver>=1.0.1

lib/matplotlib/contour.py

@@ -1420,7 +1420,7 @@ class QuadContourSet(ContourSet):
     %(contour_set_attributes)s
     """
 
-    def _process_args(self, *args, corner_mask=None, **kwargs):
+    def _process_args(self, *args, corner_mask=None, algorithm=None, **kwargs):
         """
         Process args and kwargs.
         """
@@ -1433,21 +1433,31 @@ def _process_args(self, *args, corner_mask=None, **kwargs):
             contour_generator = args[0]._contour_generator
             self._mins = args[0]._mins
             self._maxs = args[0]._maxs
+            self._algorithm = args[0]._algorithm
         else:
-            import matplotlib._contour as _contour
+            import contourpy
+
+            if algorithm is None:
+                algorithm = mpl.rcParams['contour.algorithm']
+            mpl.rcParams.validate["contour.algorithm"](algorithm)
+            self._algorithm = algorithm
 
             if corner_mask is None:
-                corner_mask = mpl.rcParams['contour.corner_mask']
+                if self._algorithm == "mpl2005":
+                    # mpl2005 does not support corner_mask=True so if not
+                    # specifically requested then disable it.
+                    corner_mask = False
+                else:
+                    corner_mask = mpl.rcParams['contour.corner_mask']
             self._corner_mask = corner_mask
 
             x, y, z = self._contour_args(args, kwargs)
 
-            _mask = ma.getmask(z)
-            if _mask is ma.nomask or not _mask.any():
-                _mask = None
-
-            contour_generator = _contour.QuadContourGenerator(
-                x, y, z.filled(), _mask, self._corner_mask, self.nchunk)
+            contour_generator = contourpy.contour_generator(
+                x, y, z, name=self._algorithm, corner_mask=self._corner_mask,
+                line_type=contourpy.LineType.SeparateCode,
+                fill_type=contourpy.FillType.OuterCode,
+                chunk_size=self.nchunk)
 
             t = self.get_transform()
 
@@ -1772,6 +1782,15 @@ def _initialize_x_y(self, z):
     Hatching is supported in the PostScript, PDF, SVG and Agg
     backends only.
 
+algorithm : {'mpl2005', 'mpl2014', 'serial', 'threaded'}, optional
+    Which contouring algorithm to use to calculate the contour lines and
+    polygons. The algorithms are implemented in
+    `ContourPy <https://github.com/contourpy/contourpy>`_, consult the
+    `ContourPy documentation <https://contourpy.readthedocs.io>`_ for
+    further information.
+
+    The default is taken from :rc:`contour.algorithm`.
+
 data : indexable object, optional
     DATA_PARAMETER_PLACEHOLDER
 
@@ -1792,5 +1811,5 @@ def _initialize_x_y(self, z):
 3. `.contour` and `.contourf` use a `marching squares
    <https://en.wikipedia.org/wiki/Marching_squares>`_ algorithm to
    compute contour locations.  More information can be found in
-   the source ``src/_contour.h``.
+   `ContourPy documentation <https://contourpy.readthedocs.io>`_.
 """)

lib/matplotlib/mpl-data/matplotlibrc

@@ -607,10 +607,11 @@
 ## * CONTOUR PLOTS                                                           *
 ## ***************************************************************************
 #contour.negative_linestyle: dashed  # string or on-off ink sequence
-#contour.corner_mask:        True    # {True, False, legacy}
+#contour.corner_mask:        True    # {True, False}
 #contour.linewidth:          None    # {float, None} Size of the contour line
                                      # widths. If set to None, it falls back to
                                      # `line.linewidth`.
+#contour.algorithm:          mpl2014 # {mpl2005, mpl2014, serial, threaded}
 
 
 ## ***************************************************************************

lib/matplotlib/rcsetup.py

@@ -960,6 +960,7 @@ def _convert_validator_spec(key, conv):
     "contour.negative_linestyle": _validate_linestyle,
     "contour.corner_mask":        validate_bool,
     "contour.linewidth":          validate_float_or_None,
+    "contour.algorithm":          ["mpl2005", "mpl2014", "serial", "threaded"],
 
     # errorbar props
     "errorbar.capsize": validate_float,