Use libraqm for text in vector outputs

Author: QuLogic

lib/matplotlib/_text_helpers.py

@@ -4,29 +4,21 @@
 
 from __future__ import annotations
 
-import dataclasses
+from collections.abc import Iterator
 
 from . import _api
-from .ft2font import FT2Font, GlyphIndexType, Kerning, LoadFlags
+from .ft2font import FT2Font, CharacterCodeType, LayoutItem, LoadFlags
 
 
-@dataclasses.dataclass(frozen=True)
-class LayoutItem:
-    ft_object: FT2Font
-    char: str
-    glyph_index: GlyphIndexType
-    x: float
-    prev_kern: float
-
-
-def warn_on_missing_glyph(codepoint, fontnames):
+def warn_on_missing_glyph(codepoint: CharacterCodeType, fontnames: str):
     _api.warn_external(
         f"Glyph {codepoint} "
         f"({chr(codepoint).encode('ascii', 'namereplace').decode('ascii')}) "
         f"missing from font(s) {fontnames}.")
 
 
-def layout(string, font, *, features=None, kern_mode=Kerning.DEFAULT, language=None):
+def layout(string: str, font: FT2Font, *, features=None,
+           language=None) -> Iterator[LayoutItem]:
     """
     Render *string* with *font*.
 
@@ -41,8 +33,6 @@ def layout(string, font, *, features=None, kern_mode=Kerning.DEFAULT, language=N
         The font.
     features : tuple of str, optional
         The font features to apply to the text.
-    kern_mode : Kerning
-        A FreeType kerning mode.
     language : str, optional
         The language of the text in a format accepted by libraqm, namely `a BCP47
         language code <https://www.w3.org/International/articles/language-tags/>`_.
@@ -51,20 +41,8 @@ def layout(string, font, *, features=None, kern_mode=Kerning.DEFAULT, language=N
     ------
     LayoutItem
     """
-    x = 0
-    prev_glyph_index = None
-    char_to_font = font._get_fontmap(string)  # TODO: Pass in features and language.
-    base_font = font
-    for char in string:
-        # This has done the fallback logic
-        font = char_to_font.get(char, base_font)
-        glyph_index = font.get_char_index(ord(char))
-        kern = (
-            base_font.get_kerning(prev_glyph_index, glyph_index, kern_mode) / 64
-            if prev_glyph_index is not None else 0.
-        )
-        x += kern
-        glyph = font.load_glyph(glyph_index, flags=LoadFlags.NO_HINTING)
-        yield LayoutItem(font, char, glyph_index, x, kern)
-        x += glyph.linearHoriAdvance / 65536
-        prev_glyph_index = glyph_index
+    for raqm_item in font._layout(string, LoadFlags.NO_HINTING,
+                                  features=features, language=language):
+        raqm_item.ft_object.load_glyph(raqm_item.glyph_index,
+                                       flags=LoadFlags.NO_HINTING)
+        yield raqm_item

lib/matplotlib/backends/_backend_pdf_ps.py

@@ -158,17 +158,17 @@ def track(self, font: FT2Font, s: str) -> list[tuple[int, CharacterCodeType]]:
             and the character codes will be returned from the string unchanged.
         """
         font_glyphs = []
-        char_to_font = font._get_fontmap(s)
-        for _c, _f in char_to_font.items():
-            charcode = ord(_c)
-            glyph_index = _f.get_char_index(charcode)
+        for raqm_item in font._layout(s, ft2font.LoadFlags.NO_HINTING):
+            font_path = raqm_item.ft_object.fname
+            charcode = ord(raqm_item.char)
+            glyph_index = raqm_item.glyph_index
             if self.subset_size != 0:
                 subset = charcode // self.subset_size
                 subset_charcode = charcode % self.subset_size
             else:
                 subset = 0
                 subset_charcode = charcode
-            self.used.setdefault((_f.fname, subset), {})[subset_charcode] = glyph_index
+            self.used.setdefault((font_path, subset), {})[subset_charcode] = glyph_index
             font_glyphs.append((subset, subset_charcode))
         return font_glyphs
 

lib/matplotlib/backends/backend_pdf.py

@@ -34,7 +34,7 @@
 from matplotlib.figure import Figure
 from matplotlib.font_manager import get_font, fontManager as _fontManager
 from matplotlib._afm import AFM
-from matplotlib.ft2font import FT2Font, FaceFlags, Kerning, LoadFlags, StyleFlags
+from matplotlib.ft2font import FT2Font, FaceFlags, LoadFlags, StyleFlags
 from matplotlib.transforms import Affine2D, BboxBase
 from matplotlib.path import Path
 from matplotlib.dates import UTC
@@ -2286,6 +2286,8 @@ def draw_text(self, gc, x, y, s, prop, angle, ismath=False, mtext=None):
         # If fonttype is neither 3 nor 42, emit the whole string at once
         # without manual kerning.
         if fonttype not in [3, 42]:
+            if not mpl.rcParams['pdf.use14corefonts']:
+                self.file._character_tracker.track(font, s)
             self.file.output(Op.begin_text,
                              self.file.fontName(prop), fontsize, Op.selectfont)
             self._setup_textpos(x, y, angle)

lib/matplotlib/backends/backend_ps.py

@@ -769,7 +769,7 @@ def draw_text(self, gc, x, y, s, prop, angle, ismath=False, mtext=None):
         if ismath:
             return self.draw_mathtext(gc, x, y, s, prop, angle)
 
-        stream = []  # list of (ps_name, x, char_name)
+        stream = []  # list of (ps_name, x, y, char_name)
 
         if mpl.rcParams['ps.useafm']:
             font = self._get_font_afm(prop)
@@ -787,7 +787,7 @@ def draw_text(self, gc, x, y, s, prop, angle, ismath=False, mtext=None):
                 kern = font.get_kern_dist_from_name(last_name, name)
                 last_name = name
                 thisx += kern * scale
-                stream.append((ps_name, thisx, name))
+                stream.append((ps_name, thisx, 0, name))
                 thisx += width * scale
 
         else:
@@ -797,20 +797,19 @@ def draw_text(self, gc, x, y, s, prop, angle, ismath=False, mtext=None):
             else:
                 features = language = None
             font = self._get_font_ttf(prop)
-            self._character_tracker.track(font, s)
             for item in _text_helpers.layout(s, font, features=features,
                                              language=language):
+                self._character_tracker.track_glyph(item.ft_object, item.glyph_index)
                 ps_name = (item.ft_object.postscript_name
                            .encode("ascii", "replace").decode("ascii"))
                 glyph_name = item.ft_object.get_glyph_name(item.glyph_index)
-                stream.append((ps_name, item.x, glyph_name))
+                stream.append((ps_name, item.x, item.y, glyph_name))
         self.set_color(*gc.get_rgb())
 
-        for ps_name, group in itertools. \
-                groupby(stream, lambda entry: entry[0]):
+        for ps_name, group in itertools.groupby(stream, lambda entry: entry[0]):
             self.set_font(ps_name, prop.get_size_in_points(), False)
-            thetext = "\n".join(f"{x:g} 0 m /{name:s} glyphshow"
-                                for _, x, name in group)
+            thetext = "\n".join(f"{x:g} {y:g} m /{name:s} glyphshow"
+                                for _, x, y, name in group)
             self._pswriter.write(f"""\
 gsave
 {self._get_clip_cmd(gc)}

lib/matplotlib/ft2font.pyi

@@ -203,7 +203,6 @@ class FT2Font(Buffer):
     ) -> None: ...
     if sys.version_info[:2] >= (3, 12):
         def __buffer__(self, flags: int) -> memoryview: ...
-    def _get_fontmap(self, string: str) -> dict[str, FT2Font]: ...
     def clear(self) -> None: ...
     def draw_glyph_to_bitmap(
         self, image: NDArray[np.uint8], x: int, y: int, glyph: Glyph, antialiased: bool = ...

lib/matplotlib/tests/test_ft2font.py

@@ -972,7 +972,7 @@ def test_fallback_last_resort(recwarn):
            "Glyph 128579 (\\N{UPSIDE-DOWN FACE}) missing from font(s)")
 
 
-def test__get_fontmap():
+def test__layout():
     fonts, test_str = _gen_multi_font_text()
     # Add some glyphs that don't exist in either font to check the Last Resort fallback.
     missing_glyphs = '\n几个汉字'
@@ -981,11 +981,11 @@ def test__get_fontmap():
     ft = fm.get_font(
         fm.fontManager._find_fonts_by_props(fm.FontProperties(family=fonts))
     )
-    fontmap = ft._get_fontmap(test_str)
-    for char, font in fontmap.items():
-        if char in missing_glyphs:
-            assert Path(font.fname).name == 'LastResortHE-Regular.ttf'
-        elif ord(char) > 127:
-            assert Path(font.fname).name == 'DejaVuSans.ttf'
-        else:
-            assert Path(font.fname).name == 'cmr10.ttf'
+    for substr in test_str.split('\n'):
+        for item in ft._layout(substr, ft2font.LoadFlags.DEFAULT):
+            if item.char in missing_glyphs:
+                assert Path(item.ft_object.fname).name == 'LastResortHE-Regular.ttf'
+            elif ord(item.char) > 127:
+                assert Path(item.ft_object.fname).name == 'DejaVuSans.ttf'
+            else:
+                assert Path(item.ft_object.fname).name == 'cmr10.ttf'

lib/matplotlib/textpath.py

@@ -147,15 +147,16 @@ def get_glyphs_with_font(self, font, s, glyph_map=None,
             glyph_map_new = glyph_map
 
         xpositions = []
+        ypositions = []
         glyph_reprs = []
         for item in _text_helpers.layout(s, font, features=features, language=language):
             glyph_repr = self._get_glyph_repr(item.ft_object, item.glyph_index)
             glyph_reprs.append(glyph_repr)
             xpositions.append(item.x)
+            ypositions.append(item.y)
             if glyph_repr not in glyph_map:
                 glyph_map_new[glyph_repr] = item.ft_object.get_path()
 
-        ypositions = [0] * len(xpositions)
         sizes = [1.] * len(xpositions)
 
         rects = []

src/ft2font_wrapper.cpp

@@ -623,54 +623,6 @@ PyFT2Font_get_kerning(PyFT2Font *self, FT_UInt left, FT_UInt right,
     return self->get_kerning(left, right, mode);
 }
 
-const char *PyFT2Font_get_fontmap__doc__ = R"""(
-    Get a mapping between characters and the font that includes them.
-
-    .. warning::
-        This API uses the fallback list and is both private and provisional: do not use
-        it directly.
-
-    Parameters
-    ----------
-    text : str
-        The characters for which to find fonts.
-
-    Returns
-    -------
-    dict[str, FT2Font]
-        A dictionary mapping unicode characters to `.FT2Font` objects.
-)""";
-
-static py::dict
-PyFT2Font_get_fontmap(PyFT2Font *self, std::u32string text)
-{
-    std::set<FT_ULong> codepoints;
-
-    py::dict char_to_font;
-    for (auto code : text) {
-        if (!codepoints.insert(code).second) {
-            continue;
-        }
-
-        py::object target_font;
-        int index;
-        if (self->get_char_fallback_index(code, index)) {
-            if (index >= 0) {
-                target_font = self->fallbacks[index];
-            } else {
-                target_font = py::cast(self);
-            }
-        } else {
-            // TODO Handle recursion!
-            target_font = py::cast(self);
-        }
-
-        auto key = py::cast(std::u32string(1, code));
-        char_to_font[key] = target_font;
-    }
-    return char_to_font;
-}
-
 const char *PyFT2Font_set_text__doc__ = R"""(
     Set the text *string* and *angle*.
 
@@ -1683,15 +1635,12 @@ PYBIND11_MODULE(ft2font, m, py::mod_gil_not_used())
         .def("get_kerning", &PyFT2Font_get_kerning, "left"_a, "right"_a, "mode"_a,
              PyFT2Font_get_kerning__doc__)
         .def("_layout", &PyFT2Font_layout, "string"_a, "flags"_a, py::kw_only(),
-             "features"_a=nullptr,
-             "language"_a=nullptr,
+             "features"_a=nullptr, "language"_a=nullptr,
              PyFT2Font_layout__doc__)
         .def("set_text", &PyFT2Font_set_text,
              "string"_a, "angle"_a=0.0, "flags"_a=LoadFlags::FORCE_AUTOHINT, py::kw_only(),
              "features"_a=nullptr, "language"_a=nullptr,
              PyFT2Font_set_text__doc__)
-        .def("_get_fontmap", &PyFT2Font_get_fontmap, "string"_a,
-             PyFT2Font_get_fontmap__doc__)
         .def("get_num_glyphs", &PyFT2Font::get_num_glyphs,
              PyFT2Font_get_num_glyphs__doc__)
         .def("load_char", &PyFT2Font_load_char,