FIX: use set_box_aspect rather than set_aspect

jklymak · jklymak · commit b57366442f99 · 2021-06-30T13:56:31.000-07:00
diff --git a/lib/matplotlib/_constrained_layout.py b/lib/matplotlib/_constrained_layout.py
@@ -575,7 +575,9 @@ def _reposition_colorbar(cbax, renderer, *, offset=None):
     pbcb = trans_fig_to_subfig.transform_bbox(pbcb)
     cbax.set_transform(fig.transSubfigure)
     cbax._set_position(pbcb)
-    cbax.set_aspect(aspect, anchor=anchor, adjustable='box')
+    cbax.set_anchor(anchor)
+    cbax.set_box_aspect(aspect)
+    cbax.set_aspect('auto')
     return offset
 
 
diff --git a/lib/matplotlib/colorbar.py b/lib/matplotlib/colorbar.py
@@ -22,6 +22,7 @@
 import matplotlib.artist as martist
 import matplotlib.patches as mpatches
 import matplotlib.path as mpath
+import matplotlib.scale as mscale
 import matplotlib.spines as mspines
 import matplotlib.transforms as mtransforms
 from matplotlib import docstring
@@ -230,23 +231,13 @@ def draw(self, renderer):
 
 class _ColorbarAxesLocator:
     """
-    Shrink the axes if there are vertical extends.  
+    Shrink the axes if there are vertical extends.
     """
     def __init__(self, cbar):
         self._cbar = cbar
         self._orig_locator = cbar.ax._axes_locator
 
     def __call__(self, ax, renderer):
-
-        # make sure that lims and scales are the same
-        scale = self._cbar._long_axis().get_scale()
-        try:
-            self._cbar._short_axis()._set_scale(scale)
-        except TypeError:
-            pass
-        lim = self._cbar._long_axis().get_view_interval()
-        self._cbar._short_axis().set_view_interval(*lim)
-
         if self._orig_locator is not None:
             pos = self._orig_locator(ax, renderer)
         else:
@@ -272,11 +263,12 @@ def __call__(self, ax, renderer):
         # extend tri/rectangles.
         if self._cbar.orientation == 'vertical':
             if aspect:
-                ax.set_aspect(aspect*shrink)
+                self._cbar.set_aspect(aspect*shrink)
             pos = pos.shrunk(1, shrink).translated(0, offset * pos.height)
         else:
+            self._cbar.ax.set_ylim(0, 1)
             if aspect:
-                ax.set_aspect(aspect/shrink)
+                ax._cbar.set_aspect(aspect*shrink)
             pos = pos.shrunk(shrink, 1).translated(offset * pos.width, 0)
         return pos
 
@@ -549,8 +541,12 @@ def draw_all(self):
         # also adds the outline path to self.outline spine:
         self._do_extends(extendlen)
 
-        self.ax.set_xlim(self.vmin, self.vmax)
-        self.ax.set_ylim(self.vmin, self.vmax)
+        if self.orientation == 'vertical':
+            self.ax.set_xlim(0, 1)
+            self.ax.set_ylim(self.vmin, self.vmax)
+        else:
+            self.ax.set_ylim(0, 1)
+            self.ax.set_xlim(self.vmin, self.vmax)
 
         # set up the tick locators and formatters.  A bit complicated because
         # boundary norms + uniform spacing requires a manual locator.
@@ -915,6 +911,59 @@ def set_alpha(self, alpha):
         """Set the transparency between 0 (transparent) and 1 (opaque)."""
         self.alpha = alpha
 
+    def set_scale(self, scale,  **kwargs):
+        """
+        Set the colorbar long axis scale.
+
+        Parameters
+        ----------
+        value : {"linear", "log", "symlog", "logit", ...} or `.ScaleBase`
+            The axis scale type to apply.
+
+        **kwargs
+            Different keyword arguments are accepted, depending on the scale.
+            See the respective class keyword arguments:
+
+            - `matplotlib.scale.LinearScale`
+            - `matplotlib.scale.LogScale`
+            - `matplotlib.scale.SymmetricalLogScale`
+            - `matplotlib.scale.LogitScale`
+            - `matplotlib.scale.FuncScale`
+
+        Notes
+        -----
+        By default, Matplotlib supports the above mentioned scales.
+        Additionally, custom scales may be registered using
+        `matplotlib.scale.register_scale`. These scales can then also
+        be used here.
+        """
+        if self.orientation == 'vertical':
+            self.ax.set_yscale(scale, **kwargs)
+        else:
+            self.ax.set_xscale(scale, **kwargs)
+        if isinstance(scale, mscale.ScaleBase):
+            self.__scale = scale.name
+        else:
+            self.__scale = scale
+
+    def get_scale(self):
+        """
+        Return the colorbar's axis scale as a str.
+        """
+        if self.orientation == 'vertical':
+            return self.ax.get_yscale()
+        else:
+            return self.ax.get_xscale()
+
+    def set_aspect(self, aspect):
+        """
+        Set ratio of the long axis to short axis.
+        """
+        if self.orientation == 'horizontal':
+            aspect = 1 / aspect
+        self.ax.set_box_aspect(aspect)
+        self.ax.set_aspect('auto')
+
     def remove(self):
         """
         Remove this colorbar from the figure.
@@ -1037,11 +1086,10 @@ def _mesh(self):
                 (self.__scale == 'manual')):
             # if a norm doesn't have a named scale, or we are not using a norm:
             dv = self.vmax - self.vmin
-            x = x * dv + self.vmin
+            # x = x * dv + self.vmin
             y = y * dv + self.vmin
         else:
             y = norm.inverse(y)
-            x = norm.inverse(x)
         self._y = y
         X, Y = np.meshgrid(x, y)
         if self.orientation == 'vertical':
@@ -1071,34 +1119,25 @@ def _reset_locator_formatter_scale(self):
         self.locator = None
         self.minorlocator = None
         self.formatter = None
+        longax = self._long_axis()
         if (self.boundaries is not None or
                 isinstance(self.norm, colors.BoundaryNorm)):
             if self.spacing == 'uniform':
                 funcs = (self._forward_boundaries, self._inverse_boundaries)
-                self.ax.set_xscale('function', functions=funcs)
-                self.ax.set_yscale('function', functions=funcs)
-                self.__scale = 'function'
+                self.set_scale('function', functions=funcs)
             elif self.spacing == 'proportional':
-                self.__scale = 'linear'
-                self.ax.set_xscale('linear')
-                self.ax.set_yscale('linear')
+                self.set_scale('linear')
         elif hasattr(self.norm, '_scale') and self.norm._scale is not None:
             # use the norm's scale:
-            self.ax.set_xscale(self.norm._scale)
-            self.ax.set_yscale(self.norm._scale)
-            self.__scale = self.norm._scale.name
+            self.set_scale(self.norm._scale)
         elif type(self.norm) is colors.Normalize:
             # plain Normalize:
-            self.ax.set_xscale('linear')
-            self.ax.set_yscale('linear')
-            self.__scale = 'linear'
+            self.set_scale('linear')
         else:
             # norm._scale is None or not an attr: derive the scale from
             # the Norm:
             funcs = (self.norm, self.norm.inverse)
-            self.ax.set_xscale('function', functions=funcs)
-            self.ax.set_yscale('function', functions=funcs)
-            self.__scale = 'function'
+            self.set_scale('function', functions=funcs)
 
     def _locate(self, x):
         """
@@ -1336,7 +1375,9 @@ def make_axes(parents, location=None, orientation=None, fraction=0.15,
         aspect=aspect,
         pad=pad)
     # and we need to set the aspect ratio by hand...
-    cax.set_aspect(aspect, anchor=anchor, adjustable='box')
+    cax.set_anchor(anchor)
+    cax.set_box_aspect(aspect)
+    cax.set_aspect('auto')
 
     return cax, kw
 
@@ -1437,7 +1478,9 @@ def make_axes_gridspec(parent, *, location=None, orientation=None,
 
     fig = parent.get_figure()
     cax = fig.add_subplot(ss_cb, label="<colorbar>")
-    cax.set_aspect(aspect, anchor=loc_settings["anchor"], adjustable='box')
+    cax.set_anchor(anchor)
+    cax.set_box_aspect(aspect)
+    cax.set_aspect('auto')
     cax._colorbar_info = dict(
         location=location,
         parents=[parent],
diff --git a/lib/matplotlib/tests/test_colorbar.py b/lib/matplotlib/tests/test_colorbar.py
@@ -460,15 +460,15 @@ def test_colorbar_lognorm_extension(extend):
     # Test that colorbar with lognorm is extended correctly
     f, ax = plt.subplots()
     cb = Colorbar(ax, norm=LogNorm(vmin=0.1, vmax=1000.0),
-                      orientation='vertical', extend=extend)
+                  orientation='vertical', extend=extend)
     assert cb._values[0] >= 0.0
 
 
 def test_colorbar_powernorm_extension():
     # Test that colorbar with powernorm is extended correctly
     f, ax = plt.subplots()
     cb = Colorbar(ax, norm=PowerNorm(gamma=0.5, vmin=0.0, vmax=1.0),
-                      orientation='vertical', extend='both')
+                  orientation='vertical', extend='both')
     assert cb._values[0] >= 0.0
 
 
@@ -725,12 +725,10 @@ def test_colorbar_change_lim_scale():
     pc = ax[0].pcolormesh(np.arange(100).reshape(10, 10)+1)
     cb = fig.colorbar(pc, ax=ax[0], extend='both')
     cb.ax.set_yscale('log')
-    cb.ax.set_xscale('log')
 
     pc = ax[1].pcolormesh(np.arange(100).reshape(10, 10)+1)
     cb = fig.colorbar(pc, ax=ax[1], extend='both')
     cb.ax.set_ylim([20, 90])
-    cb.ax.set_xlim([20, 90])
 
 
 @check_figures_equal(extensions=["png"])
@@ -745,7 +743,7 @@ def test_axes_handles_same_functions(fig_ref, fig_test):
             caxx = cax
         else:
             caxx = cb.ax
-        caxx.set_yticks(np.arange(20))
+        caxx.set_yticks(np.arange(0, 20))
         caxx.set_yscale('log')
         caxx.set_position([0.92, 0.1, 0.02, 0.7])
 
