Merge pull request matplotlib#19623 from ianthomas23/19568_closed_contour_lines

FIX: Contour lines rendered incorrectly when closed loops

Author: QuLogic

lib/matplotlib/contour.py

@@ -823,16 +823,18 @@ def __init__(self, ax, *args,
             self.norm.vmax = vmax
         self._process_colors()
 
-        self.allsegs, self.allkinds = self._get_allsegs_and_allkinds()
+        if getattr(self, 'allsegs', None) is None:
+            self.allsegs, self.allkinds = self._get_allsegs_and_allkinds()
+        elif self.allkinds is None:
+            # allsegs specified in constructor may or may not have allkinds as
+            # well.  Must ensure allkinds can be zipped below.
+            self.allkinds = [None] * len(self.allsegs)
 
         if self.filled:
             if self.linewidths is not None:
                 _api.warn_external('linewidths is ignored by contourf')
             # Lower and upper contour levels.
             lowers, uppers = self._get_lowers_and_uppers()
-            # Ensure allkinds can be zipped below.
-            if self.allkinds is None:
-                self.allkinds = [None] * len(self.allsegs)
             # Default zorder taken from Collection
             self._contour_zorder = kwargs.pop('zorder', 1)
 
@@ -852,21 +854,24 @@ def __init__(self, ax, *args,
             aa = self.antialiased
             if aa is not None:
                 aa = (self.antialiased,)
-            # Default zorder taken from LineCollection
+            # Default zorder taken from LineCollection, which is higher than
+            # for filled contours so that lines are displayed on top.
             self._contour_zorder = kwargs.pop('zorder', 2)
 
             self.collections[:] = [
-                mcoll.LineCollection(
-                    segs,
+                mcoll.PathCollection(
+                    self._make_paths(segs, kinds),
+                    facecolors="none",
                     antialiaseds=aa,
                     linewidths=width,
                     linestyles=[lstyle],
                     alpha=self.alpha,
                     transform=self.get_transform(),
                     zorder=self._contour_zorder,
                     label='_nolegend_')
-                for level, width, lstyle, segs
-                in zip(self.levels, tlinewidths, tlinestyles, self.allsegs)]
+                for level, width, lstyle, segs, kinds
+                in zip(self.levels, tlinewidths, tlinestyles, self.allsegs,
+                       self.allkinds)]
 
         for col in self.collections:
             self.axes.add_collection(col, autolim=False)
@@ -998,11 +1003,23 @@ def _process_args(self, *args, **kwargs):
         return kwargs
 
     def _get_allsegs_and_allkinds(self):
-        """
-        Override in derived classes to create and return allsegs and allkinds.
-        allkinds can be None.
-        """
-        return self.allsegs, self.allkinds
+        """Compute ``allsegs`` and ``allkinds`` using C extension."""
+        allsegs = []
+        allkinds = []
+        if self.filled:
+            lowers, uppers = self._get_lowers_and_uppers()
+            for level, level_upper in zip(lowers, uppers):
+                vertices, kinds = \
+                    self._contour_generator.create_filled_contour(
+                        level, level_upper)
+                allsegs.append(vertices)
+                allkinds.append(kinds)
+        else:
+            for level in self.levels:
+                vertices, kinds = self._contour_generator.create_contour(level)
+                allsegs.append(vertices)
+                allkinds.append(kinds)
+        return allsegs, allkinds
 
     def _get_lowers_and_uppers(self):
         """
@@ -1020,11 +1037,21 @@ def _get_lowers_and_uppers(self):
         return (lowers, uppers)
 
     def _make_paths(self, segs, kinds):
-        if kinds is not None:
-            return [mpath.Path(seg, codes=kind)
-                    for seg, kind in zip(segs, kinds)]
-        else:
+        """
+        Create and return Path objects for the specified segments and optional
+        kind codes.  segs is a list of numpy arrays, each array is either a
+        closed line loop or open line strip of 2D points with a shape of
+        (npoints, 2).  kinds is either None or a list (with the same length as
+        segs) of numpy arrays, each array is of shape (npoints,) and contains
+        the kinds codes for the corresponding line in segs.  If kinds is None
+        then the Path constructor creates the kind codes assuming that the line
+        is an open strip.
+        """
+        if kinds is None:
             return [mpath.Path(seg) for seg in segs]
+        else:
+            return [mpath.Path(seg, codes=kind) for seg, kind
+                    in zip(segs, kinds)]
 
     def changed(self):
         tcolors = [(tuple(rgba),)
@@ -1038,7 +1065,7 @@ def changed(self):
                 # update the collection's hatch (may be None)
                 collection.set_hatch(hatch)
             else:
-                collection.set_color(color)
+                collection.set_edgecolor(color)
         for label, cv in zip(self.labelTexts, self.labelCValues):
             label.set_alpha(self.alpha)
             label.set_color(self.labelMappable.to_rgba(cv))
@@ -1391,25 +1418,6 @@ def _process_args(self, *args, corner_mask=None, **kwargs):
 
         return kwargs
 
-    def _get_allsegs_and_allkinds(self):
-        """Compute ``allsegs`` and ``allkinds`` using C extension."""
-        allsegs = []
-        if self.filled:
-            lowers, uppers = self._get_lowers_and_uppers()
-            allkinds = []
-            for level, level_upper in zip(lowers, uppers):
-                vertices, kinds = \
-                    self._contour_generator.create_filled_contour(
-                        level, level_upper)
-                allsegs.append(vertices)
-                allkinds.append(kinds)
-        else:
-            allkinds = None
-            for level in self.levels:
-                vertices = self._contour_generator.create_contour(level)
-                allsegs.append(vertices)
-        return allsegs, allkinds
-
     def _contour_args(self, args, kwargs):
         if self.filled:
             fn = 'contourf'