Keep mathtext boxes in xywh representation throughout.

anntzer · anntzer · commit 535fdaa61e64 · 2026-02-02T11:21:09.000+01:00
Previously, mathtext boxes would swap between xywh and x1y1x2y2
representation in the code: ship() uses xywh, calls Rule.render() which
converts to x1y1x2y2 and stores in Output.rects in that format; then
Output.to_vector() would convert back to xywh (while also swapping
downwards y's to upwards y's).  Instead, stick to xywh representation
throughout (the rectangle always goes from x to x+w and y to y+h,
regardless of whether y is upwards or downwards).  No actual calculation
is changed.

Also remove an incorrect comment in RendererAgg.draw_mathtext: "dy"
(i.e., y) isn't at the rect top side, but actually usually the bottom
one; in any case, again it always goes from dy to dy+h.
diff --git a/lib/matplotlib/_mathtext.py b/lib/matplotlib/_mathtext.py
@@ -127,29 +127,30 @@ class Output:
     def __init__(self, box: Box):
         self.box = box
         self.glyphs: list[tuple[float, float, FontInfo]] = []  # (ox, oy, info)
-        self.rects: list[tuple[float, float, float, float]] = []  # (x1, y1, x2, y2)
+        self.rects: list[tuple[float, float, float, float]] = []  # (x, y, w, h)
 
     def to_vector(self) -> VectorParse:
         w, h, d = map(
             np.ceil, [self.box.width, self.box.height, self.box.depth])
         gs = [(info.font, info.fontsize, info.num, info.glyph_index,
                ox, h - oy + info.offset)
               for ox, oy, info in self.glyphs]
-        rs = [(x1, h - y2, x2 - x1, y2 - y1)
-              for x1, y1, x2, y2 in self.rects]
+        rs = [(bx, h - (by + bh), bw, bh)
+              for bx, by, bw, bh in self.rects]
+        # Output.rects has downwards ys, VectorParse.rects has upwards ys.
         return VectorParse(w, h + d, d, gs, rs)
 
     def to_raster(self, *, antialiased: bool) -> RasterParse:
         # Metrics y's and mathtext y's are oriented in opposite directions,
         # hence the switch between ymin and ymax.
         xmin = min([*[ox + info.metrics.xmin for ox, oy, info in self.glyphs],
-                    *[x1 for x1, y1, x2, y2 in self.rects], 0]) - 1
+                    *[x for x, y, w, h in self.rects], 0]) - 1
         ymin = min([*[oy - info.metrics.ymax for ox, oy, info in self.glyphs],
-                    *[y1 for x1, y1, x2, y2 in self.rects], 0]) - 1
+                    *[y for x, y, w, h in self.rects], 0]) - 1
         xmax = max([*[ox + info.metrics.xmax for ox, oy, info in self.glyphs],
-                    *[x2 for x1, y1, x2, y2 in self.rects], 0]) + 1
+                    *[x + w for x, y, w, h in self.rects], 0]) + 1
         ymax = max([*[oy - info.metrics.ymin for ox, oy, info in self.glyphs],
-                    *[y2 for x1, y1, x2, y2 in self.rects], 0]) + 1
+                    *[y + h for x, y, w, h in self.rects], 0]) + 1
         w = xmax - xmin
         h = ymax - ymin - self.box.depth
         d = ymax - ymin - self.box.height
@@ -165,15 +166,15 @@ def to_raster(self, *, antialiased: bool) -> RasterParse:
             info.font.draw_glyph_to_bitmap(
                 image, int(ox), int(oy - info.metrics.iceberg), info.glyph,
                 antialiased=antialiased)
-        for x1, y1, x2, y2 in shifted.rects:
-            height = max(int(y2 - y1) - 1, 0)
+        for x, y, bw, bh in shifted.rects:
+            height = max(int(bh) - 1, 0)
             if height == 0:
-                center = (y2 + y1) / 2
+                center = y + bh / 2
                 y = int(center - (height + 1) / 2)
             else:
-                y = int(y1)
-            x1 = math.floor(x1)
-            x2 = math.ceil(x2)
+                y = int(y)
+            x1 = math.floor(x)
+            x2 = math.ceil(x + bw)
             image[y:y+height+1, x1:x2+1] = 0xff
         return RasterParse(0, 0, w, h + d, d, image)
 
@@ -299,11 +300,11 @@ def render_glyph(self, output: Output, ox: float, oy: float, font: str,
         output.glyphs.append((ox, oy, info))
 
     def render_rect_filled(self, output: Output,
-                           x1: float, y1: float, x2: float, y2: float) -> None:
+                           x: float, y: float, w: float, h: float) -> None:
         """
-        Draw a filled rectangle from (*x1*, *y1*) to (*x2*, *y2*).
+        Draw a filled rectangle at (*x*, *y*) with size (*w*, *h*).
         """
-        output.rects.append((x1, y1, x2, y2))
+        output.rects.append((x, y, w, h))
 
     def get_xheight(self, font: str, fontsize: float, dpi: float) -> float:
         """
@@ -1385,7 +1386,7 @@ def __init__(self, width: float, height: float, depth: float, state: ParserState
 
     def render(self, output: Output,  # type: ignore[override]
                x: float, y: float, w: float, h: float) -> None:
-        self.fontset.render_rect_filled(output, x, y, x + w, y + h)
+        self.fontset.render_rect_filled(output, x, y, w, h)
 
 
 class Hrule(Rule):
diff --git a/lib/matplotlib/backends/backend_agg.py b/lib/matplotlib/backends/backend_agg.py
@@ -205,7 +205,7 @@ def draw_mathtext(self, gc, x, y, s, prop, angle):
         gc1 = self.new_gc()
         gc1.set_linewidth(0)
         gc1.set_snap(gc.get_snap())
-        for dx, dy, w, h in parse.rects:  # dy is upwards & the rect top side.
+        for dx, dy, w, h in parse.rects:  # dy is upwards.
             if gc1.get_snap() in [None, True]:
                 # Prevent thin bars from disappearing by growing symmetrically.
                 if w < 1:
