Fix confusion between text height and ascent in metrics calculations.

anntzer · anntzer · commit a00ff40f98be · 2026-02-06T13:49:13.000+01:00
The text height includes both the ascender and the descender, but the
logic in _get_layout is that multiline texts should be treated as having
an ascent at least as large as "l" and a descent at least as large as
"p" (not a height at least as large as "lp" and a descent at least as
large as "p") to prevent lines from bumping into each other (see changes
to test_text/test_multiline, where the topmost superscript was close to
bumping into the "p" descender previously).
diff --git a/lib/matplotlib/text.py b/lib/matplotlib/text.py
@@ -37,23 +37,22 @@ def _get_textbox(text, renderer):
     # 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_xs = []
-    projected_ys = []
+    projected_xys = []
 
     theta = np.deg2rad(text.get_rotation())
     tr = Affine2D().rotate(-theta)
 
-    _, parts, d = text._get_layout(renderer)
+    _, parts, _ = text._get_layout(renderer)
 
-    for t, wh, x, y in parts:
-        w, h = wh
-
-        xt1, yt1 = tr.transform((x, y))
-        yt1 -= d
-        xt2, yt2 = xt1 + w, yt1 + h
-
-        projected_xs.extend([xt1, xt2])
-        projected_ys.extend([yt1, yt2])
+    for t, (w, a, d), x, y in parts:
+        xt, yt = tr.transform((x, y))
+        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
@@ -441,8 +440,10 @@ def _get_layout(self, renderer):
         thisx, thisy = 0.0, 0.0
         lines = self._get_wrapped_text().split("\n")  # Ensures lines is not empty.
 
-        ws = []
-        hs = []
+        # Reminder:  The ascent (a) goes from the baseline to the top and the
+        # descent (d) from the baseline to the bottom; both are (typically)
+        # nonnegative.  The height h is the sum, h = a + d.
+        wads = []  # (width, ascents, descents)
         xs = []
         ys = []
 
@@ -451,7 +452,8 @@ def _get_layout(self, renderer):
             renderer, "lp", self._fontproperties,
             ismath="TeX" if self.get_usetex() else False,
             dpi=self.get_figure(root=True).dpi)
-        min_dy = (lp_h - lp_d) * self._linespacing
+        lp_a = lp_h - lp_d
+        min_dy = lp_a * self._linespacing
 
         for i, line in enumerate(lines):
             clean_line, ismath = self._preprocess_math(line)
@@ -462,25 +464,21 @@ def _get_layout(self, renderer):
             else:
                 w = h = d = 0
 
-            # For multiline text, increase the line spacing when the text
-            # net-height (excluding baseline) is larger than that of a "l"
-            # (e.g., use of superscripts), which seems what TeX does.
-            h = max(h, lp_h)
+            a = h - d
+            # To ensure good linespacing, pretend that the ascent (resp.
+            # descent) of all lines is at least as large as "l" (resp. "p").
+            a = max(a, lp_a)
             d = max(d, lp_d)
 
-            ws.append(w)
-            hs.append(h)
-
             # Metrics of the last line that are needed later:
-            baseline = (h - d) - thisy
+            baseline = a - thisy
 
-            if i == 0:
-                # position at baseline
-                thisy = -(h - d)
-            else:
-                # put baseline a good distance from bottom of previous line
-                thisy -= max(min_dy, (h - d) * self._linespacing)
+            if i == 0:  # position at baseline
+                thisy = -a
+            else:  # put baseline a good distance from bottom of previous line
+                thisy -= max(min_dy, a * self._linespacing)
 
+            wads.append((w, a, d))
             xs.append(thisx)  # == 0.
             ys.append(thisy)
 
@@ -490,6 +488,7 @@ def _get_layout(self, renderer):
         descent = d
 
         # Bounding box definition:
+        ws = [w for w, a, d in wads]
         width = max(ws)
         xmin = 0
         xmax = width
@@ -587,7 +586,7 @@ def _get_layout(self, renderer):
         # now rotate the positions around the first (x, y) position
         xys = M.transform(offset_layout) - (offsetx, offsety)
 
-        return bbox, list(zip(lines, zip(ws, hs), *xys.T)), descent
+        return bbox, list(zip(lines, wads, *xys.T)), descent
 
     def set_bbox(self, rectprops):
         """
@@ -876,7 +875,7 @@ def draw(self, renderer):
 
             angle = self.get_rotation()
 
-            for line, wh, x, y in info:
+            for line, wad, x, y in info:
 
                 mtext = self if len(info) == 1 else None
                 x = x + posx
