Code review updates

Author: scottshambaugh

lib/mpl_toolkits/mplot3d/art3d.py

@@ -337,8 +337,7 @@ def draw(self, renderer):
                                            dtype=float, mask=mask).filled(np.nan)
         else:
             xs3d, ys3d, zs3d = self._verts3d
-        xs, ys, zs, tis = proj3d._scale_proj_transform_clip(
-            xs3d, ys3d, zs3d, self.axes)
+        xs, ys, zs, tis = proj3d._scale_proj_transform_clip(xs3d, ys3d, zs3d, self.axes)
         self.set_data(xs, ys)
         super().draw(renderer)
         self.stale = False
@@ -521,8 +520,7 @@ def do_3d_projection(self):
                 mask = mask | viewlim_mask
 
         xyzs = np.ma.array(
-            proj3d._scale_proj_transform_vectors(segments, self.axes),
-            mask=mask)
+            proj3d._scale_proj_transform_vectors(segments, self.axes), mask=mask)
         segments_2d = xyzs[..., 0:2]
         LineCollection.set_segments(self, segments_2d)
 
@@ -605,8 +603,7 @@ def do_3d_projection(self):
                                      dtype=float, mask=mask).filled(np.nan)
         else:
             xs, ys, zs = zip(*s)
-        vxs, vys, vzs, vis = proj3d._scale_proj_transform_clip(
-            xs, ys, zs, self.axes)
+        vxs, vys, vzs, vis = proj3d._scale_proj_transform_clip(xs, ys, zs, self.axes)
         self._path2d = mpath.Path(np.ma.column_stack([vxs, vys]))
         return min(vzs)
 
@@ -666,8 +663,7 @@ def do_3d_projection(self):
                                      dtype=float, mask=mask).filled(np.nan)
         else:
             xs, ys, zs = zip(*s)
-        vxs, vys, vzs, vis = proj3d._scale_proj_transform_clip(
-            xs, ys, zs, self.axes)
+        vxs, vys, vzs, vis = proj3d._scale_proj_transform_clip(xs, ys, zs, self.axes)
         self._path2d = mpath.Path(np.ma.column_stack([vxs, vys]), self._code3d)
         return min(vzs)
 
@@ -810,8 +806,7 @@ def do_3d_projection(self):
             xs, ys, zs = np.ma.array(self._offsets3d, mask=mask)
         else:
             xs, ys, zs = self._offsets3d
-        vxs, vys, vzs, vis = proj3d._scale_proj_transform_clip(
-            xs, ys, zs, self.axes)
+        vxs, vys, vzs, vis = proj3d._scale_proj_transform_clip(xs, ys, zs, self.axes)
         self._vzs = vzs
         if np.ma.isMA(vxs):
             super().set_offsets(np.ma.column_stack([vxs, vys]))
@@ -1027,8 +1022,7 @@ def do_3d_projection(self):
             xyzs = np.ma.array(self._offsets3d, mask=mask)
         else:
             xyzs = self._offsets3d
-        vxs, vys, vzs, vis = proj3d._scale_proj_transform_clip(
-            *xyzs, self.axes)
+        vxs, vys, vzs, vis = proj3d._scale_proj_transform_clip(*xyzs, self.axes)
         self._data_scale = _get_data_scale(vxs, vys, vzs)
         # Sort the points based on z coordinates
         # Performance optimization: Create a sorted index array and reorder
@@ -1362,8 +1356,7 @@ def do_3d_projection(self):
         # Some faces might contain masked vertices, so we want to ignore any
         # errors that those might cause
         with np.errstate(invalid='ignore', divide='ignore'):
-            pfaces = proj3d._scale_proj_transform_vectors(
-                self._faces, self.axes)
+            pfaces = proj3d._scale_proj_transform_vectors(self._faces, self.axes)
 
         if self._axlim_clip:
             viewlim_mask = _viewlim_mask(self._faces[..., 0], self._faces[..., 1],

lib/mpl_toolkits/mplot3d/axes3d.py

@@ -822,7 +822,8 @@ def set_zbound(self, lower=None, upper=None, view_margin=None):
                           lower, upper, view_margin)
 
     def _set_lim3d(self, axis, lower=None, upper=None, *, emit=True,
-                   auto=False, view_margin=None, axmin=None, axmax=None):
+                   auto=False, view_margin=None, axmin=None, axmax=None,
+                   minpos=np.inf):
         """
         Set 3D axis limits.
         """
@@ -852,7 +853,6 @@ def _set_lim3d(self, axis, lower=None, upper=None, *, emit=True,
         if view_margin > 0 and hasattr(axis, '_scale') and axis._scale is not None:
             transform = axis.get_transform()
             inverse_trans = transform.inverted()
-            minpos = max(1e-300, abs(lower) if lower > 0 else 1e-5)
             lower, upper = axis._scale.limit_range_for_scale(lower, upper, minpos)
             lower_t, upper_t = transform.transform([lower, upper])
             delta = (upper_t - lower_t) * view_margin
@@ -935,7 +935,8 @@ def set_xlim(self, left=None, right=None, *, emit=True, auto=False,
         >>> set_xlim(5000, 0)
         """
         return self._set_lim3d(self.xaxis, left, right, emit=emit, auto=auto,
-                               view_margin=view_margin, axmin=xmin, axmax=xmax)
+                               view_margin=view_margin, axmin=xmin, axmax=xmax,
+                               minpos=self.xy_dataLim.minposx)
 
     def set_ylim(self, bottom=None, top=None, *, emit=True, auto=False,
                  view_margin=None, ymin=None, ymax=None):
@@ -1007,7 +1008,8 @@ def set_ylim(self, bottom=None, top=None, *, emit=True, auto=False,
         >>> set_ylim(5000, 0)
         """
         return self._set_lim3d(self.yaxis, bottom, top, emit=emit, auto=auto,
-                               view_margin=view_margin, axmin=ymin, axmax=ymax)
+                               view_margin=view_margin, axmin=ymin, axmax=ymax,
+                               minpos=self.xy_dataLim.minposy)
 
     def set_zlim(self, bottom=None, top=None, *, emit=True, auto=False,
                  view_margin=None, zmin=None, zmax=None):
@@ -1079,7 +1081,8 @@ def set_zlim(self, bottom=None, top=None, *, emit=True, auto=False,
         >>> set_zlim(5000, 0)
         """
         return self._set_lim3d(self.zaxis, bottom, top, emit=emit, auto=auto,
-                               view_margin=view_margin, axmin=zmin, axmax=zmax)
+                               view_margin=view_margin, axmin=zmin, axmax=zmax,
+                               minpos=self.zz_dataLim.minposx)
 
     set_xlim3d = set_xlim
     set_ylim3d = set_ylim
@@ -1118,18 +1121,14 @@ def get_zlim(self):
     get_zscale = _axis_method_wrapper("zaxis", "get_scale")
 
     # Custom scale setters that handle limit validation for non-linear scales
-    def _set_axis_scale(self, axis, get_lim, set_lim, value, **kwargs):
+    def _set_axis_scale(self, axis, value, **kwargs):
         """
         Set scale for an axis and constrain limits to valid range.
 
         Parameters
         ----------
         axis : Axis
             The axis to set the scale on.
-        get_lim : callable
-            Function to get current axis limits.
-        set_lim : callable
-            Function to set axis limits.
         value : str
             The scale name.
         **kwargs
@@ -1142,8 +1141,7 @@ def _set_axis_scale(self, axis, get_lim, set_lim, value, **kwargs):
         # etc.  This must happen before _set_axes_scale because that triggers
         # autoscale_view internally.
         if (axis is self.zaxis and value != 'linear'
-                and np.array_equal(self.zz_dataLim.get_points(),
-                                   [[0, 0], [1, 1]])):
+                and np.array_equal(self.zz_dataLim.get_points(), [[0, 0], [1, 1]])):
             xymargin = 0.05 * 10/11
             self.zz_dataLim = Bbox([[xymargin, xymargin],
                                     [1 - xymargin, 1 - xymargin]])
@@ -1164,8 +1162,7 @@ def set_xscale(self, value, **kwargs):
             Keyword arguments are forwarded to the scale class.
             For example, ``base=2`` can be passed when using a log scale.
         """
-        self._set_axis_scale(self.xaxis, self.get_xlim, self.set_xlim,
-                             value, **kwargs)
+        self._set_axis_scale(self.xaxis, value, **kwargs)
 
     def set_yscale(self, value, **kwargs):
         """
@@ -1181,8 +1178,7 @@ def set_yscale(self, value, **kwargs):
             Keyword arguments are forwarded to the scale class.
             For example, ``base=2`` can be passed when using a log scale.
         """
-        self._set_axis_scale(self.yaxis, self.get_ylim, self.set_ylim,
-                             value, **kwargs)
+        self._set_axis_scale(self.yaxis, value, **kwargs)
 
     def set_zscale(self, value, **kwargs):
         """
@@ -1198,8 +1194,7 @@ def set_zscale(self, value, **kwargs):
             Keyword arguments are forwarded to the scale class.
             For example, ``base=2`` can be passed when using a log scale.
         """
-        self._set_axis_scale(self.zaxis, self.get_zlim, self.set_zlim,
-                             value, **kwargs)
+        self._set_axis_scale(self.zaxis, value, **kwargs)
 
     get_zticks = _axis_method_wrapper("zaxis", "get_ticklocs")
     set_zticks = _axis_method_wrapper("zaxis", "set_ticks")
@@ -1421,10 +1416,7 @@ def get_proj(self):
         # transformation maps transformed coordinates (not data coordinates)
         # to the unit cube
         scaled_limits = self._get_scaled_limits()
-        worldM = proj3d.world_transformation(
-            *scaled_limits,
-            pb_aspect=box_aspect,
-        )
+        worldM = proj3d.world_transformation(*scaled_limits, pb_aspect=box_aspect)
 
         # Look into the middle of the world coordinates:
         R = 0.5 * box_aspect

lib/mpl_toolkits/mplot3d/axis3d.py

@@ -22,7 +22,6 @@ def _move_from_center(coord, centers, deltas, axmask=(True, True, True)):
     return coord + axmask * np.copysign(1, coord - centers) * deltas
 
 
-
 def _tick_update_position(tick, tickxs, tickys, labelpos):
     """Update tick line and label position and style."""
 
@@ -274,7 +273,8 @@ def _get_coord_info(self):
         maxs = np.array([xmax, ymax, zmax])
 
         # Get data-space bounds for _transformed_cube
-        bounds = (*self.axes.get_xbound(), *self.axes.get_ybound(),
+        bounds = (*self.axes.get_xbound(),
+                  *self.axes.get_ybound(),
                   *self.axes.get_zbound())
         bounds_proj = self.axes._transformed_cube(bounds)