Merge pull request #31179 from anntzer/tglgt

QuLogic · web-flow · commit 5b41742dfbb4 · 2026-03-03T08:32:33.000-05:00
Remove mpl.text._get_textbox.
diff --git a/lib/matplotlib/offsetbox.py b/lib/matplotlib/offsetbox.py
@@ -799,7 +799,7 @@ def get_bbox(self, renderer):
             ismath="TeX" if self._text.get_usetex() else False,
             dpi=self.get_figure(root=True).dpi)
 
-        bbox, info = self._text._get_layout(renderer)
+        bbox, info, _ = self._text._get_layout(renderer)
         _last_line, (_last_width, _last_ascent, last_descent), _last_xy = info[-1]
         w, h = bbox.size
 
diff --git a/lib/matplotlib/text.py b/lib/matplotlib/text.py
@@ -44,44 +44,6 @@ def _rotate_point(angle, x, y):
     return (cos * x - sin * y, sin * x + cos * y)
 
 
-def _get_textbox(text, renderer):
-    """
-    Calculate the bounding box of the text.
-
-    The bbox position takes text rotation into account, but the width and
-    height are those of the unrotated box (unlike `.Text.get_window_extent`).
-    """
-    # TODO : This function may move into the Text class as a method. As a
-    # matter of fact, the information from the _get_textbox function
-    # should be available during the Text._get_layout() call, which is
-    # called within the _get_textbox. So, it would be better to move this
-    # function as a method with some refactoring of _get_layout method.
-
-    projected_xys = []
-
-    theta = math.radians(text.get_rotation())
-    tr = _rotate(-theta)
-
-    _, parts = text._get_layout(renderer)
-
-    for t, (w, a, d), xy in parts:
-        xt, yt = tr.transform(xy)
-        projected_xys.extend([
-            (xt, yt + a),
-            (xt, yt - d),
-            (xt + w, yt + a),
-            (xt + w, yt - d),
-        ])
-    projected_xs, projected_ys = zip(*projected_xys)
-
-    xt_box, yt_box = min(projected_xs), min(projected_ys)
-    w_box, h_box = max(projected_xs) - xt_box, max(projected_ys) - yt_box
-
-    x_box, y_box = _rotate(theta).transform((xt_box, yt_box))
-
-    return x_box, y_box, w_box, h_box
-
-
 def _get_text_metrics_with_cache(renderer, text, fontprop, ismath, dpi):
     """Call ``renderer.get_text_width_height_descent``, caching the results."""
 
@@ -455,8 +417,11 @@ def _get_layout(self, renderer):
         """
         Return
 
-        - the (rotated) text bbox, and
-        - a list of ``(line, (width, ascent, descent), xy)`` tuples for each line.
+        - the rotated, axis-aligned text bbox;
+        - a list of ``(line, (width, ascent, descent), xy)`` tuples for each line;
+        - a ``(xy, (width, height))` pair of the lower-left corner and size of the
+          rotated, *text-aligned* text box (i.e. describing how to draw the
+          text-surrounding box).
         """
         thisx, thisy = 0.0, 0.0
         lines = self._get_wrapped_text().split("\n")  # Ensures lines is not empty.
@@ -529,7 +494,7 @@ def _get_layout(self, renderer):
 
         # the corners of the unrotated bounding box
         corners_horiz = [(xmin, ymin), (xmin, ymax), (xmax, ymax), (xmax, ymin)]
-
+        size_horiz = (xmax - xmin, ymax - ymin)
         # now rotate the bbox
         angle = self.get_rotation()
         rotate = functools.partial(_rotate_point, angle)
@@ -539,8 +504,8 @@ def _get_layout(self, renderer):
         xs, ys = zip(*corners_rotated)
         xmin, xmax = min(xs), max(xs)
         ymin, ymax = min(ys), max(ys)
-        width = xmax - xmin
-        height = ymax - ymin
+        width_rot = xmax - xmin
+        height_rot = ymax - ymin
 
         # Now move the box to the target position offset the display
         # bbox by alignment
@@ -555,57 +520,47 @@ def _get_layout(self, renderer):
                 valign = self._va_for_angle(angle)
             # compute the text location in display coords and the offsets
             # necessary to align the bbox with that location
-            if halign == 'center':
-                offsetx = (xmin + xmax) / 2
-            elif halign == 'right':
-                offsetx = xmax
-            else:
-                offsetx = xmin
-
-            if valign == 'center':
-                offsety = (ymin + ymax) / 2
-            elif valign == 'top':
-                offsety = ymax
-            elif valign == 'baseline':
-                offsety = ymin + descent
-            elif valign == 'center_baseline':
-                offsety = ymin + height - baseline / 2.0
-            else:
-                offsety = ymin
+            offsetx = (
+                xmin if halign == "left" else
+                xmax if halign == "right" else
+                (xmin + xmax) / 2  # halign == "center"
+            )
+            offsety = (
+                ymin if valign == "bottom" else
+                ymax if valign == "top" else
+                (ymin + ymax) / 2 if valign == "center" else
+                ymin + descent if valign == "baseline" else
+                ymin + height_rot - baseline / 2  # valign == "center_baseline"
+            )
         else:
             xmin1, ymin1 = corners_horiz[0]
             xmax1, ymax1 = corners_horiz[2]
-
-            if halign == 'center':
-                offsetx = (xmin1 + xmax1) / 2.0
-            elif halign == 'right':
-                offsetx = xmax1
-            else:
-                offsetx = xmin1
-
-            if valign == 'center':
-                offsety = (ymin1 + ymax1) / 2.0
-            elif valign == 'top':
-                offsety = ymax1
-            elif valign == 'baseline':
-                offsety = ymax1 - baseline
-            elif valign == 'center_baseline':
-                offsety = ymax1 - baseline / 2.0
-            else:
-                offsety = ymin1
-
+            offsetx = (
+                xmin1 if halign == "left" else
+                xmax1 if halign == "right" else
+                (xmin1 + xmax1) / 2  # halign == "center"
+            )
+            offsety = (
+                ymin1 if valign == "bottom" else
+                ymax1 if valign == "top" else
+                (ymin1 + ymax1) / 2 if valign == "center" else
+                ymax1 - baseline if valign == "baseline" else
+                ymax1 - baseline / 2  # valign == "center_baseline"
+            )
             offsetx, offsety = rotate(offsetx, offsety)
 
         xmin -= offsetx
         ymin -= offsety
 
-        bbox = Bbox.from_bounds(xmin, ymin, width, height)
+        bbox_rot = Bbox.from_bounds(xmin, ymin, width_rot, height_rot)
 
         # now rotate the positions around the first (x, y) position
         xys = [(x - offsetx, y - offsety)
                for x, y in itertools.starmap(rotate, offset_layout)]
+        x, y = corners_rotated[0]
+        xy_corner = (x - offsetx, y - offsety)
 
-        return bbox, list(zip(lines, wads, xys))
+        return bbox_rot, list(zip(lines, wads, xys)), (xy_corner, size_horiz)
 
     def set_bbox(self, rectprops):
         """
@@ -677,7 +632,7 @@ def update_bbox_position_size(self, renderer):
             posy = float(self.convert_yunits(self._y))
             posx, posy = self.get_transform().transform((posx, posy))
 
-            x_box, y_box, w_box, h_box = _get_textbox(self, renderer)
+            _, _, ((x_box, y_box), (w_box, h_box)) = self._get_layout(renderer)
             self._bbox_patch.set_bounds(0., 0., w_box, h_box)
             self._bbox_patch.set_transform(
                 Affine2D()
@@ -857,7 +812,7 @@ def draw(self, renderer):
 
         renderer.open_group('text', self.get_gid())
 
-        bbox, info = self._get_layout(renderer)
+        bbox, info, _ = self._get_layout(renderer)
         trans = self.get_transform()
 
         # don't use self.get_position here, which refers to text
@@ -1080,7 +1035,7 @@ def get_window_extent(self, renderer=None, dpi=None):
                 "want to call 'figure.draw_without_rendering()' first.")
 
         with cbook._setattr_cm(fig, dpi=dpi):
-            bbox, _ = self._get_layout(self._renderer)
+            bbox, _, _ = self._get_layout(self._renderer)
             x, y = self.get_unitless_position()
             x, y = self.get_transform().transform((x, y))
             bbox = bbox.translated(x, y)
