fix texts and rotation using freetype and correct rotation methods

Author: lionel42

examples/rotation.py

@@ -0,0 +1,78 @@
+"""Script taken from matplotlib examples to test rotation modes in text rendering."""
+import matplotlib.pyplot as plt
+
+import matplotlib
+import logging
+
+logging.basicConfig()
+logger = logging.getLogger("pygame_matplotlib")
+# logger.setLevel(logging.DEBUG)
+matplotlib.use("pygame")
+
+
+def test_rotation_mode(fig, mode):
+    ha_list = ["left", "center", "right"]
+    va_list = ["top", "center", "baseline", "bottom"]
+    axs = fig.subplots(
+        len(va_list),
+        len(ha_list),
+        sharex=True,
+        sharey=True,
+        subplot_kw=dict(aspect=1),
+        gridspec_kw=dict(hspace=0, wspace=0),
+    )
+
+    # labels and title
+    for ha, ax in zip(ha_list, axs[-1, :]):
+        ax.set_xlabel(ha)
+    for va, ax in zip(va_list, axs[:, 0]):
+        ax.set_ylabel(va)
+    axs[0, 1].set_title(f"rotation_mode='{mode}'", size="large")
+
+    kw = (
+        {}
+        if mode == "default"
+        else {"bbox": dict(boxstyle="square,pad=0.", ec="none", fc="C1", alpha=0.3)}
+    )
+
+    texts = {}
+
+    # use a different text alignment in each Axes
+    for i, va in enumerate(va_list):
+        for j, ha in enumerate(ha_list):
+            ax = axs[i, j]
+            # prepare Axes layout
+            ax.set(xticks=[], yticks=[])
+            ax.axvline(0.5, color="skyblue", zorder=0)
+            ax.axhline(0.5, color="skyblue", zorder=0)
+            ax.plot(0.5, 0.5, color="C0", marker="o", zorder=1)
+            # add text with rotation and alignment settings
+            tx = ax.text(
+                0.5,
+                0.5,
+                "Tpg",
+                size="x-large",
+                rotation=90,
+                horizontalalignment=ha,
+                verticalalignment=va,
+                rotation_mode=mode,
+                **kw,
+            )
+            texts[ax] = tx
+
+    if mode == "default":
+        # highlight bbox
+        fig.canvas.draw()
+        for ax, text in texts.items():
+            bb = text.get_window_extent().transformed(ax.transData.inverted())
+            rect = plt.Rectangle(
+                (bb.x0, bb.y0), bb.width, bb.height, facecolor="C1", alpha=0.3, zorder=2
+            )
+            ax.add_patch(rect)
+
+
+fig = plt.figure(figsize=(8, 5))
+subfigs = fig.subfigures(1, 2)
+test_rotation_mode(subfigs[0], "default")
+test_rotation_mode(subfigs[1], "anchor")
+plt.show()

examples/text.py

@@ -0,0 +1,63 @@
+"""Taken from the matplotlib text example."""
+
+import matplotlib.pyplot as plt
+import logging
+
+# Set up logging
+logging.basicConfig()
+logger = logging.getLogger("pygame_matplotlib")
+logger.setLevel(logging.DEBUG)
+
+import matplotlib
+# matplotlib.use("pygame")
+
+fig = plt.figure()
+ax = fig.add_subplot()
+fig.subplots_adjust(top=0.85)
+
+# Set titles for the figure and the subplot respectively
+fig.suptitle("bold figure suptitle", fontsize=14, fontweight="bold")
+ax.set_title("axes title")
+
+ax.set_xlabel("xlabel")
+ax.set_ylabel("ylabel")
+
+# Set both x- and y-axis limits to [0, 10] instead of default [0, 1]
+ax.axis([0, 10, 0, 10])
+
+ax.text(
+    3,
+    8,
+    "boxed italics text in data coords",
+    style="italic",
+    bbox={"facecolor": "red", "alpha": 0.5, "pad": 10},
+)
+
+ax.text(2, 6, r"an equation: $E=mc^2$", fontsize=15)
+
+ax.text(3, 2, "Unicode: Institut für Festkörperphysik")
+
+
+ax.text(3, 5, "aaa", rotation=90)
+ax.text(3, 5, "bbb", rotation=135)
+
+ax.text(
+    0.95,
+    0.01,
+    "colored text in axes coords",
+    verticalalignment="bottom",
+    horizontalalignment="right",
+    transform=ax.transAxes,
+    color="green",
+    fontsize=15,
+)
+
+ax.plot([2], [1], "o")
+ax.annotate(
+    "annotate",
+    xy=(2, 1),
+    xytext=(3, 4),
+    arrowprops=dict(facecolor="black", shrink=0.05),
+)
+
+plt.show()

pygame_matplotlib/backend_pygame.py

@@ -18,6 +18,7 @@
 from matplotlib.transforms import Affine2D
 import pygame
 import pygame.image
+import pygame.freetype
 from pygame import gfxdraw
 from matplotlib._pylab_helpers import Gcf
 from matplotlib.backend_bases import (
@@ -239,55 +240,142 @@ def draw_image(self, gc, x, y, im):
         )
 
     def draw_text(self, gc, x, y, s, prop, angle, ismath=False, mtext=None):
-
-        logger.info(
+        logger.debug(
             f"Drawing text: {s=} at ({x=}, {y=}) with {angle=} and ismath={ismath} "
             f"{mtext=} {prop=} {gc=}"
         )
+
         # make sure font module is initialized
-        if not pygame.font.get_init():
-            pygame.font.init()
+        if not pygame.freetype.get_init():
+            pygame.freetype.init()
+
         # prop is the font properties
-        font_size = prop.get_size_in_points() * 2
-        myfont = pygame.font.Font(prop.get_file(), int(font_size))
+        # Size must be adjusted
+        font_size = prop.get_size() * 1.42
+        font_file = prop.get_file()
+        logger.debug(f"Font file: {font_file}, size: {font_size}")
+
+        # Set bold
+        # 'light', 'normal', 'regular', 'book',
+        #' medium', 'roman', 'semibold', 'demibold', 'demi', 'bold',
+        # 'heavy', 'extra bold', 'black'
+        font_weight = prop.get_weight()
+        if isinstance(font_weight, int):
+            # If the weight is an int, we assume it is a font weight
+            # in the range 0-1000
+            bold = font_weight >= 600
+        else:
+            bold = font_weight in ["bold", "heavy", "black", "extra bold"]
+        logger.debug(f"Font weight: {font_weight}, bold: {bold}")
+
+        # Set italic
+        # style can be 'normal', 'italic' or 'oblique'
+        font_style = prop.get_style()
+        italic = font_style in ["italic", "oblique"]
+
+        if font_file is None:
+            # Use default matplotlib font
+            font_file = "DejaVuSans"
+
+        pgfont = pygame.freetype.SysFont(
+            font_file, int(font_size), bold=bold, italic=italic
+        )
+
+        logger.debug(f"Font: {pgfont}")
+
         # apply it to text on a label
-        font_surface = myfont.render(
-            s, gc.get_antialiased(), [val * 255 for val in gc.get_rgb()]
+        fg_color = [val * 255 for val in gc.get_rgb()]
+
+        # Use freetype to render the text
+        font_surface, rotated_rect = pgfont.render(
+            s,
+            fg_color,
+            size=font_size,
+            rotation=int(angle),
         )
-        if angle:
-            font_surface = pygame.transform.rotate(font_surface, angle)
-        
+        no_rotation_rect = pgfont.get_rect(s, size=font_size)
+
         # Get the expected size of the font
-        width, height = myfont.size(s)
+        # width, height = (pgfont.get_rect(s).size if USE_FREETYPE else pgfont.size(s))
+        width, height = rotated_rect.size
+
         # Tuple for the position of the font
         font_surf_position = (x, self.surface.get_height() - y)
         if mtext is not None:
             # Use the alignement from mtext or default
             h_alignment = mtext.get_horizontalalignment()
             v_alignment = mtext.get_verticalalignment()
+            rotation_mode = mtext.get_rotation_mode()
         else:
             h_alignment = "center"
             v_alignment = "center"
+
+        logger.debug(
+            f"{h_alignment=}, {v_alignment=}, {rotation_mode=}, {width=}, {height=}"
+        )
         # Use the alignement to know where the font should go
-        if h_alignment == "left":
-            h_offset = 0
-        elif h_alignment == "center":
-            h_offset = -width / 2
-        elif h_alignment == "right":
-            h_offset = -width
-        else:
-            h_offset = 0
-
-        if v_alignment == "top":
-            v_offset = 0
-        elif v_alignment == "center" or v_alignment == "center_baseline":
-            v_offset = -height / 2
-        elif v_alignment == "bottom" or v_alignment == "baseline":
-            v_offset = -height
+        if rotation_mode == "anchor":
+            # Anchor the text to the position
+            sin_a = np.sin(np.radians(angle))
+            cos_a = np.cos(np.radians(angle))
+
+            sub_width, sub_height = no_rotation_rect.size
+
+            if h_alignment == "left":
+                if v_alignment == "top":
+                    h_offset = 0
+                    v_offset = sub_width * sin_a
+                elif v_alignment == "center":
+                    h_offset = sub_height * sin_a / 2
+                    v_offset = height - sub_height * cos_a / 2
+                else:  #  "bottom" or "baseline"
+                    h_offset = sub_height * sin_a
+                    v_offset = height
+            elif h_alignment == "center":
+                if v_alignment == "top":
+                    h_offset = sub_width / 2 * cos_a
+                    v_offset = sub_width / 2 * sin_a
+                elif v_alignment == "center":
+                    h_offset = width / 2
+                    v_offset = height / 2
+                else:
+                    h_offset = width - (sub_width / 2 * cos_a)
+                    v_offset = height - sub_width / 2 * sin_a
+            elif h_alignment == "right":
+                if v_alignment == "top":
+                    h_offset = width - sub_height * sin_a
+                    v_offset = 0
+                elif v_alignment == "center":
+                    h_offset = width - (sub_height / 2 * sin_a)
+                    v_offset = sub_height / 2 * cos_a
+                else:
+                    h_offset = width
+                    v_offset = cos_a * sub_height
+            else:
+                raise ValueError(f"Unknown {h_alignment=}")
+            h_offset, v_offset = -h_offset, -v_offset
+
         else:
-            v_offset = 0
-        # pygame.draw.circle(self.surface, (255, 0, 0), (x, self.surface.get_height() - y), 3)
-        # pygame.draw.lines(self.surface, (0, 255, 0), True, ((x, self.surface.get_height() - y), (x + width, self.surface.get_height() - y), (x + width, self.surface.get_height() - y + height)))
+            # The text box is aligned to the position
+
+            if h_alignment == "left":
+                h_offset = 0
+            elif h_alignment == "center":
+                h_offset = -width / 2
+            elif h_alignment == "right":
+                h_offset = -width
+            else:
+                h_offset = 0
+
+            if v_alignment == "top":
+                v_offset = 0
+            elif v_alignment == "center" or v_alignment == "center_baseline":
+                v_offset = -height / 2
+            elif v_alignment == "bottom" or v_alignment == "baseline":
+                v_offset = -height
+            else:
+                v_offset = 0
+
         # Tuple for the position of the font
         font_surf_position = (
             x + h_offset,