Fold ColorbarPatch into Colorbar, deprecate colorbar_factory.

anntzer · anntzer · commit 209bf11cbb93 · 2020-09-19T14:49:40.000+02:00
It is easier to have an internal switch on the mappable type, rather
than having a separate "internal" (per the documentation) API to support
hatchings.  Also note that the previous version would fail in obscure
cases where the contourset was changed from not using hatches to using
hatches after the colorbar was created.
diff --git a/doc/api/next_api_changes/deprecations/18527-AL.rst b/doc/api/next_api_changes/deprecations/18527-AL.rst
@@ -0,0 +1,4 @@
+``ColorbarPatch`` and ``colorbar_factory`` are deprecated
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+All the relevant functionality has been moved to the
+`~matplotlib.colorbar.Colorbar` class.
diff --git a/lib/matplotlib/colorbar.py b/lib/matplotlib/colorbar.py
@@ -19,9 +19,6 @@
     On top of `.ColorbarBase` this connects the colorbar with a
     `.ScalarMappable` such as an image or contour plot.
 
-:class:`ColorbarPatch`
-    A specialized `.Colorbar` to support hatched contour plots.
-
 :func:`make_axes`
     Create an `~.axes.Axes` suitable for a colorbar. This functions can be
     used with figures containing a single axes or with freely placed axes.
@@ -472,6 +469,7 @@ def __init__(self, ax, cmap=None,
         self.extendfrac = extendfrac
         self.extendrect = extendrect
         self.solids = None
+        self.solids_patches = []
         self.lines = []
 
         for spine in ax.spines.values():
@@ -807,33 +805,50 @@ def _edges(self, X, Y):
             return [list(zip(Y[i], X[i])) for i in range(1, N - 1)]
 
     def _add_solids(self, X, Y, C):
-        """
-        Draw the colors using `~.axes.Axes.pcolormesh`;
-        optionally add separators.
-        """
-        if self.orientation == 'vertical':
-            args = (X, Y, C)
-        else:
-            args = (np.transpose(Y), np.transpose(X), np.transpose(C))
-        kw = dict(cmap=self.cmap,
-                  norm=self.norm,
-                  alpha=self.alpha,
-                  edgecolors='None')
-        _log.debug('Setting pcolormesh')
-        col = self.ax.pcolormesh(*args, **kw, shading='flat')
-        # self.add_observer(col) # We should observe, not be observed...
-
+        """Draw the colors; optionally add separators."""
+        # Cleanup previously set artists.
         if self.solids is not None:
             self.solids.remove()
-        self.solids = col
-
-        if self.drawedges:
-            self.dividers.set_segments(self._edges(X, Y))
+        for solid in self.solids_patches:
+            solid.remove()
+        # Add new artist(s), based on mappable type.  Use individual patches if
+        # hatching is needed, pcolormesh otherwise.
+        mappable = getattr(self, 'mappable', None)
+        if (isinstance(mappable, contour.ContourSet)
+                and any(hatch is not None for hatch in mappable.hatches)):
+            self._add_solids_patches(X, Y, C, mappable)
         else:
-            self.dividers.set_segments([])
+            self._add_solids_pcolormesh(X, Y, C)
+        self.dividers.set_segments(self._edges(X, Y) if self.drawedges else [])
+
+    def _add_solids_pcolormesh(self, X, Y, C):
+        _log.debug('Setting pcolormesh')
+        args = (X, Y, C) if self.orientation == 'vertical' else (Y.T, X.T, C.T)
+        self.solids = self.ax.pcolormesh(
+            *args, cmap=self.cmap, norm=self.norm, alpha=self.alpha,
+            edgecolors='none', shading='flat')
+        if not self.drawedges:
             if len(self._y) >= self.n_rasterize:
                 self.solids.set_rasterized(True)
 
+    def _add_solids_patches(self, X, Y, C, mappable):
+        hatches = mappable.hatches * len(C)  # Have enough hatches.
+        patches = []
+        for i in range(len(X) - 1):
+            xy = np.array([[X[i, 0], Y[i, 0]],
+                           [X[i, 1], Y[i, 0]],
+                           [X[i + 1, 1], Y[i + 1, 0]],
+                           [X[i + 1, 0], Y[i + 1, 1]]])
+            if self.orientation == 'horizontal':
+                xy = xy[..., ::-1]  # Swap x/y.
+            patch = mpatches.PathPatch(mpath.Path(xy),
+                                       facecolor=self.cmap(self.norm(C[i][0])),
+                                       hatch=hatches[i], linewidth=0,
+                                       antialiased=False, alpha=self.alpha)
+            self.ax.add_patch(patch)
+            patches.append(patch)
+        self.solids_patches = patches
+
     def add_lines(self, levels, colors, linewidths, erase=True):
         """
         Draw lines on the colorbar.
@@ -1082,7 +1097,7 @@ def _proportional_y(self):
 
     def _mesh(self):
         """
-        Return ``(X, Y)``, the coordinate arrays for the colorbar pcolormesh.
+        Return the coordinate arrays for the colorbar pcolormesh/patches.
         These are suitable for a vertical colorbar; swapping and transposition
         for a horizontal colorbar are done outside this function.
 
@@ -1213,6 +1228,10 @@ def __init__(self, ax, mappable, **kwargs):
                 _add_disjoint_kwargs(kwargs, alpha=mappable.get_alpha())
             super().__init__(ax, **kwargs)
 
+        mappable.colorbar = self
+        mappable.colorbar_cid = mappable.callbacksSM.connect(
+            'changed', self.update_normal)
+
     @cbook.deprecated("3.3", alternative="update_normal")
     def on_mappable_changed(self, mappable):
         """
@@ -1550,61 +1569,12 @@ def make_axes_gridspec(parent, *, location=None, orientation=None,
     return cax, kw
 
 
+@cbook.deprecated("3.4", alternative="Colorbar")
 class ColorbarPatch(Colorbar):
-    """
-    A Colorbar that uses a list of `~.patches.Patch` instances rather than the
-    default `~.collections.PatchCollection` created by `~.axes.Axes.pcolor`,
-    because the latter does not allow the hatch pattern to vary among the
-    members of the collection.
-    """
-
-    def __init__(self, ax, mappable, **kw):
-        # we do not want to override the behaviour of solids
-        # so add a new attribute which will be a list of the
-        # colored patches in the colorbar
-        self.solids_patches = []
-        super().__init__(ax, mappable, **kw)
-
-    def _add_solids(self, X, Y, C):
-        """
-        Draw the colors using `~matplotlib.patches.Patch`;
-        optionally add separators.
-        """
-        n_segments = len(C)
-
-        # ensure there are sufficient hatches
-        hatches = self.mappable.hatches * n_segments
-
-        patches = []
-        for i in range(len(X) - 1):
-            val = C[i][0]
-            hatch = hatches[i]
-
-            xy = np.array([[X[i][0], Y[i][0]],
-                           [X[i][1], Y[i][0]],
-                           [X[i + 1][1], Y[i + 1][0]],
-                           [X[i + 1][0], Y[i + 1][1]]])
-
-            if self.orientation == 'horizontal':
-                # if horizontal swap the xs and ys
-                xy = xy[..., ::-1]
-
-            patch = mpatches.PathPatch(mpath.Path(xy),
-                                       facecolor=self.cmap(self.norm(val)),
-                                       hatch=hatch, linewidth=0,
-                                       antialiased=False, alpha=self.alpha)
-            self.ax.add_patch(patch)
-            patches.append(patch)
-
-        if self.solids_patches:
-            for solid in self.solids_patches:
-                solid.remove()
-
-        self.solids_patches = patches
-
-        self.dividers.set_segments(self._edges(X, Y) if self.drawedges else [])
+    pass
 
 
+@cbook.deprecated("3.4", alternative="Colorbar")
 def colorbar_factory(cax, mappable, **kwargs):
     """
     Create a colorbar on the given axes for the given mappable.
@@ -1626,20 +1596,7 @@ def colorbar_factory(cax, mappable, **kwargs):
 
     Returns
     -------
-    `.Colorbar` or `.ColorbarPatch`
-        The created colorbar instance. `.ColorbarPatch` is only used if
-        *mappable* is a `.ContourSet` with hatches.
+    `.Colorbar`
+        The created colorbar instance.
     """
-    # if the given mappable is a contourset with any hatching, use
-    # ColorbarPatch else use Colorbar
-    if (isinstance(mappable, contour.ContourSet)
-            and any(hatch is not None for hatch in mappable.hatches)):
-        cb = ColorbarPatch(cax, mappable, **kwargs)
-    else:
-        cb = Colorbar(cax, mappable, **kwargs)
-
-    cid = mappable.callbacksSM.connect('changed', cb.update_normal)
-    mappable.colorbar = cb
-    mappable.colorbar_cid = cid
-
-    return cb
+    return Colorbar(cax, mappable, **kwargs)
diff --git a/lib/matplotlib/figure.py b/lib/matplotlib/figure.py
@@ -2380,7 +2380,7 @@ def colorbar(self, mappable, cax=None, ax=None, use_gridspec=True, **kw):
         NON_COLORBAR_KEYS = ['fraction', 'pad', 'shrink', 'aspect', 'anchor',
                              'panchor']
         cb_kw = {k: v for k, v in kw.items() if k not in NON_COLORBAR_KEYS}
-        cb = cbar.colorbar_factory(cax, mappable, **cb_kw)
+        cb = cbar.Colorbar(cax, mappable, **cb_kw)
 
         self.sca(current_ax)
         self.stale = True
diff --git a/lib/mpl_toolkits/axes_grid1/axes_grid.py b/lib/mpl_toolkits/axes_grid1/axes_grid.py
@@ -50,7 +50,7 @@ def colorbar(self, mappable, *, ticks=None, **kwargs):
             mappable.colorbar = cb
             self._locator = cb.cbar_axis.get_major_locator()
         else:
-            cb = mpl.colorbar.colorbar_factory(
+            cb = mpl.colorbar.Colorbar(
                 self, mappable, orientation=orientation, ticks=ticks, **kwargs)
             self._cbid = mappable.colorbar_cid  # deprecated.
             self._locator = cb.locator  # deprecated.
