First pass at exact 3d plot limits

scottshambaugh · scottshambaugh · commit 3200e5445a19 · 2023-04-29T01:24:07.000-06:00
diff --git a/lib/matplotlib/axis.py b/lib/matplotlib/axis.py
@@ -829,13 +829,14 @@ def _get_autoscale_on(self):
     def _set_autoscale_on(self, b):
         """
         Set whether this Axis is autoscaled when drawing or by
-        `.Axes.autoscale_view`.
+        `.Axes.autoscale_view`. If b is None, then the value is not changed.
 
         Parameters
         ----------
         b : bool
         """
-        self._autoscale_on = b
+        if b is not None:
+            self._autoscale_on = b
 
     def get_children(self):
         return [self.label, self.offsetText,
@@ -1219,8 +1220,7 @@ def _set_lim(self, v0, v1, *, emit=True, auto):
         # Mark viewlims as no longer stale without triggering an autoscale.
         for ax in self._get_shared_axes():
             ax._stale_viewlims[name] = False
-        if auto is not None:
-            self._set_autoscale_on(bool(auto))
+        self._set_autoscale_on(auto)
 
         if emit:
             self.axes.callbacks.process(f"{name}lim_changed", self.axes)
diff --git a/lib/matplotlib/mpl-data/matplotlibrc b/lib/matplotlib/mpl-data/matplotlibrc
@@ -425,8 +425,9 @@
 #axes.autolimit_mode: data  # If "data", use axes.xmargin and axes.ymargin as is.
                             # If "round_numbers", after application of margins, axis
                             # limits are further expanded to the nearest "round" number.
-#polaraxes.grid: True  # display grid on polar axes
-#axes3d.grid:    True  # display grid on 3D axes
+#polaraxes.grid:    True   # display grid on polar axes
+#axes3d.grid:       True   # display grid on 3D axes
+#axes3d.automargin: False  # automatically add margin when manually setting 3D axis limits
 
 #axes3d.xaxis.panecolor:    (0.95, 0.95, 0.95, 0.5)  # background pane on 3D axes
 #axes3d.yaxis.panecolor:    (0.90, 0.90, 0.90, 0.5)  # background pane on 3D axes
diff --git a/lib/matplotlib/mpl-data/stylelib/classic.mplstyle b/lib/matplotlib/mpl-data/stylelib/classic.mplstyle
@@ -223,7 +223,8 @@ axes.spines.left    : True
 axes.spines.right   : True
 axes.spines.top     : True
 polaraxes.grid      : True    # display grid on polar axes
-axes3d.grid         : True    # display grid on 3d axes
+axes3d.grid         : True    # display grid on 3D axes
+axes3d.automargin   : False   # automatically add margin when manually setting 3D axis limits
 
 date.autoformatter.year   : %Y
 date.autoformatter.month  : %b %Y
diff --git a/lib/matplotlib/rcsetup.py b/lib/matplotlib/rcsetup.py
@@ -1016,8 +1016,10 @@ def _convert_validator_spec(key, conv):
     "axes.ymargin": _range_validators["0 <= x <= 1"],  # margin added to yaxis
     'axes.zmargin': _range_validators["0 <= x <= 1"],  # margin added to zaxis
 
-    "polaraxes.grid": validate_bool,  # display polar grid or not
-    "axes3d.grid":    validate_bool,  # display 3d grid
+    "polaraxes.grid":    validate_bool,  # display polar grid or not
+    "axes3d.grid":       validate_bool,  # display 3d grid
+    "axes3d.automargin": validate_bool,  # automatically add margin when
+                                         # manually setting 3D axis limits
 
     "axes3d.xaxis.panecolor":    validate_color,  # 3d background pane
     "axes3d.yaxis.panecolor":    validate_color,  # 3d background pane
diff --git a/lib/matplotlib/ticker.py b/lib/matplotlib/ticker.py
@@ -2076,6 +2076,8 @@ def _raw_ticks(self, vmin, vmax):
             steps = steps[igood]
 
         raw_step = ((_vmax - _vmin) / nbins)
+        if hasattr(self.axis, "axes") and self.axis.axes.name == '3d':
+            raw_step = raw_step * 24/25  # needed to match mpl3.7 appearance
         large_steps = steps >= raw_step
         if mpl.rcParams['axes.autolimit_mode'] == 'round_numbers':
             # Classic round_numbers mode may require a larger step.
diff --git a/lib/mpl_toolkits/mplot3d/axes3d.py b/lib/mpl_toolkits/mplot3d/axes3d.py
@@ -129,7 +129,9 @@ def __init__(
 
         self.xy_viewLim = Bbox.unit()
         self.zz_viewLim = Bbox.unit()
-        self.xy_dataLim = Bbox.unit()
+        xymargin = 0.05 * 10/11  # match mpl3.7 appearance
+        self.xy_dataLim = Bbox([[xymargin, xymargin],
+                                [1 - xymargin, 1 - xymargin]])
         # z-limits are encoded in the x-component of the Bbox, y is un-used
         self.zz_dataLim = Bbox.unit()
 
@@ -157,6 +159,9 @@ def __init__(
         self.set_axis_on()
         self.M = None
 
+        self._view_margin = 1/48  # default value to match mpl3.7
+        self.autoscale_view()
+
         # func used to format z -- fall back on major formatters
         self.fmt_zdata = None
 
@@ -336,7 +341,8 @@ def set_aspect(self, aspect, adjustable=None, anchor=None, share=False):
                                              self.set_ylim3d,
                                              self.set_zlim3d)):
                     if i in ax_indices:
-                        set_lim(mean[i] - deltas[i]/2., mean[i] + deltas[i]/2.)
+                        set_lim(mean[i] - deltas[i]/2., mean[i] + deltas[i]/2.,
+                                auto=None, view_margin=self._view_margin)
             else:  # 'box'
                 # Change the box aspect such that the ratio of the length of
                 # the unmodified axis to the length of the diagonal
@@ -404,8 +410,8 @@ def set_box_aspect(self, aspect, *, zoom=1):
         else:
             aspect = np.asarray(aspect, dtype=float)
             _api.check_shape((3,), aspect=aspect)
-        # default scale tuned to match the mpl32 appearance.
-        aspect *= 1.8294640721620434 * zoom / np.linalg.norm(aspect)
+        # default scale tuned to match the mpl3.2 appearance.
+        aspect *= 1.8294640721620434 * 25/24 * zoom / np.linalg.norm(aspect)
 
         self._box_aspect = aspect
         self.stale = True
@@ -575,17 +581,17 @@ def autoscale(self, enable=True, axis='both', tight=None):
             scalez = True
         else:
             if axis in ['x', 'both']:
-                self.set_autoscalex_on(bool(enable))
+                self.set_autoscalex_on(enable)
                 scalex = self.get_autoscalex_on()
             else:
                 scalex = False
             if axis in ['y', 'both']:
-                self.set_autoscaley_on(bool(enable))
+                self.set_autoscaley_on(enable)
                 scaley = self.get_autoscaley_on()
             else:
                 scaley = False
             if axis in ['z', 'both']:
-                self.set_autoscalez_on(bool(enable))
+                self.set_autoscalez_on(enable)
                 scalez = self.get_autoscalez_on()
             else:
                 scalez = False
@@ -610,8 +616,8 @@ def auto_scale_xyz(self, X, Y, Z=None, had_data=None):
         # Let autoscale_view figure out how to use this data.
         self.autoscale_view()
 
-    def autoscale_view(self, tight=None, scalex=True, scaley=True,
-                       scalez=True):
+    def autoscale_view(self, tight=None,
+                       scalex=True, scaley=True, scalez=True):
         """
         Autoscale the view limits using the data limits.
 
@@ -643,7 +649,7 @@ def autoscale_view(self, tight=None, scalex=True, scaley=True,
                 x1 += delta
             if not _tight:
                 x0, x1 = xlocator.view_limits(x0, x1)
-            self.set_xbound(x0, x1)
+            self.set_xbound(x0, x1, self._view_margin)
 
         if scaley and self.get_autoscaley_on():
             y0, y1 = self.xy_dataLim.intervaly
@@ -655,7 +661,7 @@ def autoscale_view(self, tight=None, scalex=True, scaley=True,
                 y1 += delta
             if not _tight:
                 y0, y1 = ylocator.view_limits(y0, y1)
-            self.set_ybound(y0, y1)
+            self.set_ybound(y0, y1, self._view_margin)
 
         if scalez and self.get_autoscalez_on():
             z0, z1 = self.zz_dataLim.intervalx
@@ -667,7 +673,7 @@ def autoscale_view(self, tight=None, scalex=True, scaley=True,
                 z1 += delta
             if not _tight:
                 z0, z1 = zlocator.view_limits(z0, z1)
-            self.set_zbound(z0, z1)
+            self.set_zbound(z0, z1, self._view_margin)
 
     def get_w_lims(self):
         """Get 3D world limits."""
@@ -676,28 +682,116 @@ def get_w_lims(self):
         minz, maxz = self.get_zlim3d()
         return minx, maxx, miny, maxy, minz, maxz
 
-    # set_xlim, set_ylim are directly inherited from base Axes.
+    def _set_bound3d(self, get_bound, set_lim, axis_inverted,
+                     lower=None, upper=None, view_margin=None):
+        """
+        Set 3D axis bounds.
+        """
+        if upper is None and np.iterable(lower):
+            lower, upper = lower
+
+        old_lower, old_upper = get_bound()
+        if lower is None:
+            lower = old_lower
+        if upper is None:
+            upper = old_upper
+
+        set_lim(sorted((lower, upper), reverse=bool(axis_inverted())),
+                auto=None, view_margin=view_margin)
+
+    def set_xbound(self, lower=None, upper=None, view_margin=None):
+        # docstring inherited
+        self._set_bound3d(self.get_xbound, self.set_xlim, self.xaxis_inverted,
+                          upper, lower, view_margin)
+
+    def set_ybound(self, lower=None, upper=None, view_margin=None):
+        # docstring inherited
+        self._set_bound3d(self.get_ybound, self.set_ylim, self.yaxis_inverted,
+                          upper, lower, view_margin)
+
+    def set_zbound(self, lower=None, upper=None, view_margin=None):
+        """
+        Set the lower and upper numerical bounds of the z-axis.
+        This method will honor axis inversion regardless of parameter order.
+        It will not change the autoscaling setting (`.get_autoscaley_on()`).
+        Parameters
+        ----------
+        lower, upper : float or None
+            The lower and upper bounds. If *None*, the respective axis bound
+            is not modified.
+        view_margin : float or None
+            The margin to apply to the bounds. If *None*, the margin is handled
+            by set_zlim.
+        See Also
+        --------
+        get_zbound
+        get_zlim, set_zlim
+        invert_zaxis, zaxis_inverted
+        """
+        self._set_bound3d(self.get_zbound, self.set_zlim, self.zaxis_inverted,
+                          upper, lower, view_margin)
+
+    def _set_lim3d(self, axis, lower=None, upper=None, *, emit=True,
+                   auto=False, view_margin=None, axmin=None, axmax=None):
+        """
+        Set 3D axis limits.
+        See `.Axes.set_ylim` for full documentation
+        """
+        if upper is None:
+            if np.iterable(lower):
+                lower, upper = lower
+            else:
+                raise ValueError("Must provide an upper bound.")
+        if lower is None:
+            raise ValueError("Must provide a lower bound.")
+        if axmin is not None:
+            if lower is not None:
+                raise TypeError("Cannot pass both 'lower' and 'min'")
+            lower = axmin
+        if axmax is not None:
+            if upper is not None:
+                raise TypeError("Cannot pass both 'upper' and 'max'")
+            upper = axmax
+        if view_margin is None:
+            if mpl.rcParams['axes3d.automargin']:
+                view_margin = self._view_margin
+            else:
+                view_margin = 0
+        delta = (upper - lower) * view_margin
+        lower -= delta
+        upper += delta
+        return axis._set_lim(lower, upper, emit=emit, auto=auto)
+
+    def set_xlim(self, left=None, right=None, *, emit=True, auto=False,
+                 view_margin=None, xmin=None, xmax=None):
+        """
+        Set 3D x limits.
+        See `.Axes.set_xlim` for full documentation
+        """
+        return self._set_lim3d(self.xaxis, left, right, emit=emit, auto=auto,
+                               view_margin=view_margin, axmin=xmin, axmax=xmax)
+
+    def set_ylim(self, bottom=None, top=None, *, emit=True, auto=False,
+                 view_margin=None, ymin=None, ymax=None):
+        """
+        Set 3D y limits.
+        See `.Axes.set_ylim` for full documentation
+        """
+        return self._set_lim3d(self.yaxis, bottom, top, emit=emit, auto=auto,
+                               view_margin=view_margin, axmin=ymin, axmax=ymax)
+
     def set_zlim(self, bottom=None, top=None, *, emit=True, auto=False,
-                 zmin=None, zmax=None):
+                 view_margin=None, zmin=None, zmax=None):
         """
         Set 3D z limits.
 
         See `.Axes.set_ylim` for full documentation
         """
-        if top is None and np.iterable(bottom):
-            bottom, top = bottom
-        if zmin is not None:
-            if bottom is not None:
-                raise TypeError("Cannot pass both 'bottom' and 'zmin'")
-            bottom = zmin
-        if zmax is not None:
-            if top is not None:
-                raise TypeError("Cannot pass both 'top' and 'zmax'")
-            top = zmax
-        return self.zaxis._set_lim(bottom, top, emit=emit, auto=auto)
-
-    set_xlim3d = maxes.Axes.set_xlim
-    set_ylim3d = maxes.Axes.set_ylim
+        return self._set_lim3d(self.zaxis, bottom, top, emit=emit, auto=auto,
+                               view_margin=view_margin, axmin=zmin, axmax=zmax)
+
+    set_xlim3d = set_xlim
+    set_ylim3d = set_ylim
     set_zlim3d = set_zlim
 
     def get_xlim(self):
@@ -982,6 +1076,15 @@ def clear(self):
             self._zmargin = mpl.rcParams['axes.zmargin']
         else:
             self._zmargin = 0.
+
+        xymargin = 0.05 * 10/11  # match mpl3.7 appearance
+        self.xy_dataLim = Bbox([[xymargin, xymargin],
+                                [1 - xymargin, 1 - xymargin]])
+        # z-limits are encoded in the x-component of the Bbox, y is un-used
+        self.zz_dataLim = Bbox.unit()
+        self._view_margin = 1/48  # default value to match mpl3.7
+        self.autoscale_view()
+
         self.grid(mpl.rcParams['axes3d.grid'])
 
     def _button_press(self, event):
@@ -1162,9 +1265,9 @@ def drag_pan(self, button, key, x, y):
         dz = (maxz - minz) * duvw_projected[2]
 
         # Set the new axis limits
-        self.set_xlim3d(minx + dx, maxx + dx)
-        self.set_ylim3d(miny + dy, maxy + dy)
-        self.set_zlim3d(minz + dz, maxz + dz)
+        self.set_xlim3d(minx + dx, maxx + dx, auto=None)
+        self.set_ylim3d(miny + dy, maxy + dy, auto=None)
+        self.set_zlim3d(minz + dz, maxz + dz, auto=None)
 
     def _calc_view_axes(self, eye):
         """
@@ -1301,9 +1404,9 @@ def _scale_axis_limits(self, scale_x, scale_y, scale_z):
         dz = (maxz - minz)*scale_z
 
         # Set the scaled axis limits
-        self.set_xlim3d(cx - dx/2, cx + dx/2)
-        self.set_ylim3d(cy - dy/2, cy + dy/2)
-        self.set_zlim3d(cz - dz/2, cz + dz/2)
+        self.set_xlim3d(cx - dx/2, cx + dx/2, auto=None)
+        self.set_ylim3d(cy - dy/2, cy + dy/2, auto=None)
+        self.set_zlim3d(cz - dz/2, cz + dz/2, auto=None)
 
     def set_zlabel(self, zlabel, fontdict=None, labelpad=None, **kwargs):
         """
@@ -1392,26 +1495,6 @@ def get_zbound(self):
         else:
             return top, bottom
 
-    def set_zbound(self, lower=None, upper=None):
-        """
-        Set the lower and upper numerical bounds of the z-axis.
-
-        This method will honor axes inversion regardless of parameter order.
-        It will not change the autoscaling setting (`.get_autoscalez_on()`).
-        """
-        if upper is None and np.iterable(lower):
-            lower, upper = lower
-
-        old_lower, old_upper = self.get_zbound()
-        if lower is None:
-            lower = old_lower
-        if upper is None:
-            upper = old_upper
-
-        self.set_zlim(sorted((lower, upper),
-                             reverse=bool(self.zaxis_inverted())),
-                      auto=None)
-
     def text(self, x, y, z, s, zdir=None, **kwargs):
         """
         Add text to the plot.
diff --git a/lib/mpl_toolkits/mplot3d/axis3d.py b/lib/mpl_toolkits/mplot3d/axis3d.py
diff --git a/lib/mpl_toolkits/mplot3d/tests/test_axes3d.py b/lib/mpl_toolkits/mplot3d/tests/test_axes3d.py
