Cleanup and consolidation

Author: scottshambaugh

lib/mpl_toolkits/mplot3d/art3d.py

@@ -74,55 +74,27 @@ def get_dir_vector(zdir):
 
 def _apply_scale_transforms(xs, ys, zs, axes):
     """
-    Apply scale transforms to 3D coordinates.
+    Apply axis scale transforms to 3D coordinates.
 
-    This transforms data coordinates through the axis scale transforms
-    (log, symlog, etc.) to get scaled coordinates that can be properly
-    projected through the world transformation.
-
-    Parameters
-    ----------
-    xs, ys, zs : array-like
-        The x, y, z coordinates in data space.
-    axes : Axes3D
-        The axes providing the scale transforms.
-
-    Returns
-    -------
-    xs_scaled, ys_scaled, zs_scaled : np.ndarray
-        The coordinates in scaled space.
+    Transforms data coordinates through scale transforms (log, symlog, etc.)
+    to scaled coordinates for proper 3D projection. Preserves masked arrays.
     """
-    # Use asanyarray to preserve masked arrays
-    xs = np.asanyarray(xs)
-    ys = np.asanyarray(ys)
-    zs = np.asanyarray(zs)
-
-    # Get the scale transforms for each axis
-    x_trans = axes.xaxis.get_transform()
-    y_trans = axes.yaxis.get_transform()
-    z_trans = axes.zaxis.get_transform()
-
-    # Handle masked arrays by preserving the mask
-    x_mask = np.ma.getmask(xs) if np.ma.isMA(xs) else False
-    y_mask = np.ma.getmask(ys) if np.ma.isMA(ys) else False
-    z_mask = np.ma.getmask(zs) if np.ma.isMA(zs) else False
-
-    # Get the data (without mask) for transformation
-    xs_data = np.ma.getdata(xs).ravel() if np.ma.isMA(xs) else xs.ravel()
-    ys_data = np.ma.getdata(ys).ravel() if np.ma.isMA(ys) else ys.ravel()
-    zs_data = np.ma.getdata(zs).ravel() if np.ma.isMA(zs) else zs.ravel()
-
-    # Transform through scale
-    xs_scaled = x_trans.transform(xs_data).reshape(xs.shape)
-    ys_scaled = y_trans.transform(ys_data).reshape(ys.shape)
-    zs_scaled = z_trans.transform(zs_data).reshape(zs.shape)
-
-    # Reapply masks if needed
-    if x_mask is not False or y_mask is not False or z_mask is not False:
-        combined_mask = x_mask | y_mask | z_mask
-        xs_scaled = np.ma.array(xs_scaled, mask=combined_mask)
-        ys_scaled = np.ma.array(ys_scaled, mask=combined_mask)
-        zs_scaled = np.ma.array(zs_scaled, mask=combined_mask)
+    def transform_coord(coord, axis):
+        coord = np.asanyarray(coord)
+        data = np.ma.getdata(coord).ravel()
+        return axis.get_transform().transform(data).reshape(coord.shape)
+
+    xs_scaled = transform_coord(xs, axes.xaxis)
+    ys_scaled = transform_coord(ys, axes.yaxis)
+    zs_scaled = transform_coord(zs, axes.zaxis)
+
+    # Preserve combined mask from any masked input
+    masks = [np.ma.getmask(a) for a in [xs, ys, zs]]
+    if any(m is not np.ma.nomask for m in masks):
+        combined = np.ma.mask_or(np.ma.mask_or(masks[0], masks[1]), masks[2])
+        xs_scaled = np.ma.array(xs_scaled, mask=combined)
+        ys_scaled = np.ma.array(ys_scaled, mask=combined)
+        zs_scaled = np.ma.array(zs_scaled, mask=combined)
 
     return xs_scaled, ys_scaled, zs_scaled
 

lib/mpl_toolkits/mplot3d/axes3d.py

@@ -1329,35 +1329,6 @@ def _roll_to_vertical(
         else:
             return np.roll(arr, (self._vertical_axis - 2))
 
-    def _get_scale_transform(self, axis):
-        """
-        Return the scale transform for the given axis.
-
-        For non-linear scales (log, symlog, etc.), this returns the
-        transform that maps data coordinates to scaled coordinates.
-        For linear scales, returns an IdentityTransform.
-        """
-        return axis.get_transform()
-
-    def _transform_limit_to_scale(self, limit, transform):
-        """
-        Transform a limit value through the scale transform.
-
-        Parameters
-        ----------
-        limit : float
-            The limit value in data coordinates.
-        transform : Transform
-            The scale transform to apply.
-
-        Returns
-        -------
-        float
-            The limit value in scaled coordinates.
-        """
-        # Transform the limit through the scale
-        return transform.transform([limit])[0]
-
     def _get_scaled_limits(self):
         """
         Get axis limits transformed through their respective scale transforms.
@@ -1368,59 +1339,20 @@ def _get_scaled_limits(self):
             (xmin_scaled, xmax_scaled, ymin_scaled, ymax_scaled,
              zmin_scaled, zmax_scaled)
         """
-        x_trans = self._get_scale_transform(self.xaxis)
-        y_trans = self._get_scale_transform(self.yaxis)
-        z_trans = self._get_scale_transform(self.zaxis)
-
-        xmin, xmax = self.get_xlim3d()
-        ymin, ymax = self.get_ylim3d()
-        zmin, zmax = self.get_zlim3d()
-
-        return (
-            self._transform_limit_to_scale(xmin, x_trans),
-            self._transform_limit_to_scale(xmax, x_trans),
-            self._transform_limit_to_scale(ymin, y_trans),
-            self._transform_limit_to_scale(ymax, y_trans),
-            self._transform_limit_to_scale(zmin, z_trans),
-            self._transform_limit_to_scale(zmax, z_trans),
-        )
+        xmin, xmax = self.xaxis.get_transform().transform(self.get_xlim3d())
+        ymin, ymax = self.yaxis.get_transform().transform(self.get_ylim3d())
+        zmin, zmax = self.zaxis.get_transform().transform(self.get_zlim3d())
+        return xmin, xmax, ymin, ymax, zmin, zmax
 
     def _inverse_scale_transform(self, x, y, z):
         """
-        Apply inverse scale transforms to coordinates.
+        Apply inverse scale transforms to a point.
 
         Converts from scaled space back to data space.
-
-        Parameters
-        ----------
-        x, y, z : float or array-like
-            Coordinates in scaled space.
-
-        Returns
-        -------
-        x_data, y_data, z_data : float or ndarray
-            Coordinates in data space.
         """
-        x_inv = self.xaxis.get_transform().inverted()
-        y_inv = self.yaxis.get_transform().inverted()
-        z_inv = self.zaxis.get_transform().inverted()
-
-        x_arr = np.atleast_1d(x)
-        y_arr = np.atleast_1d(y)
-        z_arr = np.atleast_1d(z)
-
-        x_data = x_inv.transform(x_arr.ravel()).reshape(x_arr.shape)
-        y_data = y_inv.transform(y_arr.ravel()).reshape(y_arr.shape)
-        z_data = z_inv.transform(z_arr.ravel()).reshape(z_arr.shape)
-
-        # Return scalars if input was scalar (check original input)
-        if np.ndim(x) == 0:
-            x_data = float(x_data.flat[0])
-        if np.ndim(y) == 0:
-            y_data = float(y_data.flat[0])
-        if np.ndim(z) == 0:
-            z_data = float(z_data.flat[0])
-
+        x_data = self.xaxis.get_transform().inverted().transform([x])[0]
+        y_data = self.yaxis.get_transform().inverted().transform([y])[0]
+        z_data = self.zaxis.get_transform().inverted().transform([z])[0]
         return x_data, y_data, z_data
 
     def _set_lims_from_scaled(self, xmin_s, xmax_s, ymin_s, ymax_s,

lib/mpl_toolkits/mplot3d/axis3d.py

@@ -268,36 +268,14 @@ def get_rotate_label(self, text):
             return len(text) > 4
 
     def _get_coord_info(self):
-        # Get the data-space bounds
-        data_mins, data_maxs = np.array([
-            self.axes.get_xbound(),
-            self.axes.get_ybound(),
-            self.axes.get_zbound(),
-        ]).T
-
-        # Transform to scaled space for proper positioning with non-linear scales
-        x_trans = self.axes.xaxis.get_transform()
-        y_trans = self.axes.yaxis.get_transform()
-        z_trans = self.axes.zaxis.get_transform()
-
-        mins = np.array([
-            x_trans.transform([data_mins[0]])[0],
-            y_trans.transform([data_mins[1]])[0],
-            z_trans.transform([data_mins[2]])[0],
-        ])
-        maxs = np.array([
-            x_trans.transform([data_maxs[0]])[0],
-            y_trans.transform([data_maxs[1]])[0],
-            z_trans.transform([data_maxs[2]])[0],
-        ])
-
-        # Project the bounds along the current position of the cube:
-        # Note: _transformed_cube expects data-space bounds and transforms them
-        # internally
-        bounds = (data_mins[0], data_maxs[0],
-                  data_mins[1], data_maxs[1],
-                  data_mins[2], data_maxs[2]
-        )
+        # Get scaled limits directly from the axes helper
+        xmin, xmax, ymin, ymax, zmin, zmax = self.axes._get_scaled_limits()
+        mins = np.array([xmin, ymin, zmin])
+        maxs = np.array([xmax, ymax, zmax])
+
+        # Get data-space bounds for _transformed_cube
+        bounds = (*self.axes.get_xbound(), *self.axes.get_ybound(),
+                  *self.axes.get_zbound())
         bounds_proj = self.axes._transformed_cube(bounds)
 
         # Determine which one of the parallel planes are higher up:
@@ -484,25 +462,20 @@ def _draw_ticks(self, renderer, edgep1, centers, deltas, highs,
 
         default_label_offset = 8.  # A rough estimate
         points = deltas_per_point * deltas
+        # All coordinates below are in scaled space for proper projection
         for tick in ticks:
             # Get tick line positions
-            # edgep1 is already in scaled space (from _get_coord_info)
             pos = edgep1.copy()
-            # Transform tick location from data space to scaled space
-            tick_loc_scaled = axis_trans.transform([tick.get_loc()])[0]
-            pos[index] = tick_loc_scaled
+            pos[index] = axis_trans.transform([tick.get_loc()])[0]
             pos[tickdir] = out_tickdir
-            # pos is already in scaled space, project directly
             x1, y1, z1 = proj3d.proj_transform(*pos, self.axes.M)
             pos[tickdir] = in_tickdir
             x2, y2, z2 = proj3d.proj_transform(*pos, self.axes.M)
 
             # Get position of label
             labeldeltas = (tick.get_pad() + default_label_offset) * points
-
             pos[tickdir] = edgep1_tickdir
             pos = _move_from_center(pos, centers, labeldeltas, self._axmask())
-            # pos is already in scaled space, project directly
             lx, ly, lz = proj3d.proj_transform(*pos, self.axes.M)
 
             _tick_update_position(tick, (x1, x2), (y1, y2), (lx, ly))
@@ -528,7 +501,6 @@ def _draw_offset_text(self, renderer, edgep1, edgep2, labeldeltas, centers,
 
         pos = _move_from_center(outeredgep, centers, labeldeltas,
                                 self._axmask())
-        # pos is already in scaled space, project directly
         olx, oly, olz = proj3d.proj_transform(*pos, self.axes.M)
         self.offsetText.set_text(self.major.formatter.get_offset())
         self.offsetText.set_position((olx, oly))
@@ -553,7 +525,6 @@ def _draw_offset_text(self, renderer, edgep1, edgep2, labeldeltas, centers,
         # Three-letters (e.g., TFT, FTT) are short-hand for the array of bools
         # from the variable 'highs'.
         # ---------------------------------------------------------------------
-        # centers is already in scaled space (from _get_coord_info)
         centpt = proj3d.proj_transform(*centers, self.axes.M)
         if centpt[tickdir] > pep[tickdir, outerindex]:
             # if FT and if highs has an even number of Trues
@@ -586,10 +557,8 @@ def _draw_labels(self, renderer, edgep1, edgep2, labeldeltas, centers, dx, dy):
         label = self._axinfo["label"]
 
         # Draw labels
-        # edgep1, edgep2, and centers are already in scaled space
         lxyz = 0.5 * (edgep1 + edgep2)
         lxyz = _move_from_center(lxyz, centers, labeldeltas, self._axmask())
-        # lxyz is in scaled space, project directly
         tlx, tly, tlz = proj3d.proj_transform(*lxyz, self.axes.M)
         self.label.set_position((tlx, tly))
         if self.get_rotate_label(self.label.get_text()):
@@ -625,7 +594,7 @@ def draw(self, renderer):
 
         for edgep1, edgep2, pos in zip(*self._get_all_axis_line_edge_points(
                                            minmax, maxmin, self._tick_position)):
-            # Edge points are already in scaled space (from _get_coord_info)
+            # Project the edge points along the current position
             pep = proj3d._proj_trans_points([edgep1, edgep2], self.axes.M)
             pep = np.asarray(pep)
 
@@ -653,7 +622,7 @@ def draw(self, renderer):
 
         for edgep1, edgep2, pos in zip(*self._get_all_axis_line_edge_points(
                                            minmax, maxmin, self._label_position)):
-            # Edge points are already in scaled space (from _get_coord_info)
+            # See comments above
             pep = proj3d._proj_trans_points([edgep1, edgep2], self.axes.M)
             pep = np.asarray(pep)
             dx, dy = (self.axes.transAxes.transform([pep[0:2, 1]]) -
@@ -678,17 +647,13 @@ def draw_grid(self, renderer):
             info = self._axinfo
             index = info["i"]
 
-            # For grid lines, we need data-space bounds since Line3DCollection
-            # applies scale transforms in do_3d_projection
-            data_mins, data_maxs = np.array([
-                self.axes.get_xbound(),
-                self.axes.get_ybound(),
-                self.axes.get_zbound(),
-            ]).T
-
-            # Get highs from the scaled-space projection
+            # Grid lines use data-space bounds (Line3DCollection applies transforms)
             mins, maxs, tc, highs = self._get_coord_info()
-
+            xlim, ylim, zlim = (self.axes.get_xbound(),
+                                self.axes.get_ybound(),
+                                self.axes.get_zbound())
+            data_mins = np.array([xlim[0], ylim[0], zlim[0]])
+            data_maxs = np.array([xlim[1], ylim[1], zlim[1]])
             minmax = np.where(highs, data_maxs, data_mins)
             maxmin = np.where(~highs, data_maxs, data_mins)