Use libraqm for text in vector outputs

Author: QuLogic

lib/matplotlib/_text_helpers.py

@@ -4,29 +4,20 @@
 
 from __future__ import annotations
 
-import dataclasses
+from collections.abc import Iterator
 
 from . import _api
-from .ft2font import FT2Font, Kerning, LoadFlags
+from .ft2font import FT2Font, LayoutItem, LoadFlags
 
 
-@dataclasses.dataclass(frozen=True)
-class LayoutItem:
-    ft_object: FT2Font
-    char: str
-    glyph_idx: int
-    x: float
-    prev_kern: float
-
-
-def warn_on_missing_glyph(codepoint, fontnames):
+def warn_on_missing_glyph(codepoint: int, 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, *, kern_mode=Kerning.DEFAULT):
+def layout(string: str, font: FT2Font) -> Iterator[LayoutItem]:
     """
     Render *string* with *font*.
 
@@ -39,27 +30,11 @@ def layout(string, font, *, kern_mode=Kerning.DEFAULT):
         The string to be rendered.
     font : FT2Font
         The font.
-    kern_mode : Kerning
-        A FreeType kerning mode.
 
     Yields
     ------
     LayoutItem
     """
-    x = 0
-    prev_glyph_idx = None
-    char_to_font = font._get_fontmap(string)
-    base_font = font
-    for char in string:
-        # This has done the fallback logic
-        font = char_to_font.get(char, base_font)
-        glyph_idx = font.get_char_index(ord(char))
-        kern = (
-            base_font.get_kerning(prev_glyph_idx, glyph_idx, kern_mode) / 64
-            if prev_glyph_idx is not None else 0.
-        )
-        x += kern
-        glyph = font.load_glyph(glyph_idx, flags=LoadFlags.NO_HINTING)
-        yield LayoutItem(font, char, glyph_idx, x, kern)
-        x += glyph.linearHoriAdvance / 65536
-        prev_glyph_idx = glyph_idx
+    for raqm_item in font._layout(string, LoadFlags.NO_HINTING):
+        raqm_item.ft_object.load_glyph(raqm_item.glyph_idx, flags=LoadFlags.NO_HINTING)
+        yield raqm_item

lib/matplotlib/backends/backend_pdf.py

@@ -35,7 +35,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
@@ -2351,7 +2351,6 @@ def draw_text(self, gc, x, y, s, prop, angle, ismath=False, mtext=None):
             fonttype = 1
         else:
             font = self._get_font_ttf(prop)
-            self.file._character_tracker.track(font, s)
             fonttype = mpl.rcParams['pdf.fonttype']
 
         if gc.get_url() is not None:
@@ -2363,6 +2362,7 @@ 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]:
+            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)
@@ -2389,7 +2389,8 @@ def draw_text(self, gc, x, y, s, prop, angle, ismath=False, mtext=None):
             multibyte_glyphs = []
             prev_was_multibyte = True
             prev_font = font
-            for item in _text_helpers.layout(s, font, kern_mode=Kerning.UNFITTED):
+            for item in _text_helpers.layout(s, font):
+                self.file._character_tracker.track_glyph(font, item.glyph_idx)
                 if _font_supports_glyph(fonttype, ord(item.char)):
                     if prev_was_multibyte or item.ft_object != prev_font:
                         singlebyte_chunks.append((item.ft_object, item.x, []))

lib/matplotlib/backends/backend_ps.py

@@ -795,19 +795,18 @@ def draw_text(self, gc, x, y, s, prop, angle, ismath=False, mtext=None):
 
         else:
             font = self._get_font_ttf(prop)
-            self._character_tracker.track(font, s)
             for item in _text_helpers.layout(s, font):
+                self._character_tracker.track_glyph(item.ft_object, item.glyph_idx)
                 ps_name = (item.ft_object.postscript_name
                            .encode("ascii", "replace").decode("ascii"))
                 glyph_name = item.ft_object.get_glyph_name(item.glyph_idx)
-                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/textpath.py

@@ -144,15 +144,16 @@ def get_glyphs_with_font(self, font, s, glyph_map=None,
             glyph_map_new = glyph_map
 
         xpositions = []
+        ypositions = []
         glyph_ids = []
         for item in _text_helpers.layout(s, font):
-            char_id = self._get_char_id(item.ft_object, ord(item.char))
+            char_id = self._get_char_id(item.ft_object, item.glyph_idx)
             glyph_ids.append(char_id)
             xpositions.append(item.x)
+            ypositions.append(item.y)
             if char_id not in glyph_map:
                 glyph_map_new[char_id] = item.ft_object.get_path()
 
-        ypositions = [0] * len(xpositions)
         sizes = [1.] * len(xpositions)
 
         rects = []

src/ft2font.h

@@ -171,6 +171,16 @@ class FT2Font
         return FT_HAS_KERNING(face);
     }
 
+    void set_parent(void *parent)
+    {
+        _parent = parent;
+    }
+
+    void *get_parent() const
+    {
+        return _parent;
+    }
+
   private:
     WarnFunc ft_glyph_warn;
     bool warn_if_used;
@@ -185,6 +195,9 @@ class FT2Font
     long hinting_factor;
     int kerning_factor;
 
+    // Holds the parent PyFT2Font object.
+    void *_parent;
+
     // prevent copying
     FT2Font(const FT2Font &);
     FT2Font &operator=(const FT2Font &);

src/ft2font_wrapper.cpp

@@ -499,6 +499,7 @@ PyFT2Font_init(py::object filename, long hinting_factor = 8,
 
     self->x = new FT2Font(open_args, hinting_factor, fallback_fonts, ft_glyph_warn,
                           warn_if_used);
+    self->x->set_parent(self);
 
     self->x->set_kerning_factor(kerning_factor);
 
@@ -1467,6 +1468,97 @@ PyFT2Font__get_type1_encoding_vector(PyFT2Font *self)
     return indices;
 }
 
+/**********************************************************************
+ * Layout items
+ * */
+
+struct LayoutItem {
+    PyFT2Font *ft_object;
+    std::u32string character;
+    int glyph_idx;
+    double x;
+    double y;
+    double prev_kern;
+
+    LayoutItem(PyFT2Font *f, std::u32string c, int i, double x, double y, double k) :
+        ft_object(f), character(c), glyph_idx(i), x(x), y(y), prev_kern(k) {}
+
+    std::string to_string()
+    {
+        std::ostringstream out;
+        out << "LayoutItem(ft_object=" << PyFT2Font_fname(ft_object);
+        out << ", char=" << character[0];
+        out << ", glyph_idx=" << glyph_idx;
+        out << ", x=" << x;
+        out << ", y=" << y;
+        out << ", prev_kern=" << prev_kern;
+        out << ")";
+        return out.str();
+    }
+};
+
+const char *PyFT2Font_layout__doc__ = R"""(
+    Layout a string and yield information about each used glyph.
+
+    .. 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
+    -------
+    list[LayoutItem]
+)""";
+
+static auto
+PyFT2Font_layout(PyFT2Font *self, std::u32string text, LoadFlags flags)
+{
+    const auto hinting_factor = self->x->get_hinting_factor();
+    const auto load_flags = static_cast<FT_Int32>(flags);
+
+    std::set<FT_String*> glyph_seen_fonts;
+    std::vector<raqm_glyph_t> glyphs;
+    self->x->layout(text, load_flags, glyph_seen_fonts, glyphs);
+
+    std::vector<LayoutItem> items;
+
+    double x = 0.0;
+    double y = 0.0;
+    std::optional<double> prev_advance = std::nullopt;
+    double prev_x = 0.0;
+    for (auto &glyph : glyphs) {
+        auto ft_object = static_cast<FT2Font *>(glyph.ftface->generic.data);
+        auto pyft_object = static_cast<PyFT2Font *>(ft_object->get_parent());
+
+        ft_object->load_glyph(glyph.index, load_flags);
+
+        double prev_kern = 0.0;
+        if (prev_advance.has_value()) {
+            double actual_advance = (x + glyph.x_offset) - prev_x;
+            prev_kern = actual_advance - prev_advance.value();
+        }
+
+        items.emplace_back(pyft_object, text.substr(glyph.cluster, 1), glyph.index,
+                           (x + glyph.x_offset) / 64.0, (y + glyph.y_offset) / 64.0,
+                           prev_kern / 64.0);
+        prev_x = x + glyph.x_offset;
+        x += glyph.x_advance;
+        y += glyph.y_advance;
+        // Note, linearHoriAdvance is a 16.16 instead of 26.6 fixed-point value.
+        prev_advance = ft_object->get_face()->glyph->linearHoriAdvance / 1024.0 / hinting_factor;
+    }
+
+    return items;
+}
+
+/**********************************************************************
+ * Deprecations
+ * */
+
 static py::object
 ft2font__getattr__(std::string name) {
     auto api = py::module_::import("matplotlib._api");
@@ -1601,8 +1693,23 @@ PYBIND11_MODULE(ft2font, m, py::mod_gil_not_used())
         .def_property_readonly("bbox", &PyGlyph_get_bbox,
                                "The control box of the glyph.");
 
-        auto cls = py::class_<PyFT2Font>(m, "FT2Font", py::is_final(), py::buffer_protocol(),
-                                         PyFT2Font__doc__)
+    py::class_<LayoutItem>(m, "LayoutItem", py::is_final())
+        .def_readonly("ft_object", &LayoutItem::ft_object,
+                      "The FT_Face of the item.")
+        .def_readonly("char", &LayoutItem::character,
+                      "The character code for the item.")
+        .def_readonly("glyph_idx", &LayoutItem::glyph_idx,
+                      "The glyph index for the item.")
+        .def_readonly("x", &LayoutItem::x,
+                      "The x position of the item.")
+        .def_readonly("y", &LayoutItem::y,
+                      "The y position of the item.")
+        .def_readonly("prev_kern", &LayoutItem::prev_kern,
+                      "The kerning between this item and the previous one.")
+        .def("__str__", &LayoutItem::to_string);
+
+    auto cls = py::class_<PyFT2Font>(m, "FT2Font", py::is_final(), py::buffer_protocol(),
+                                     PyFT2Font__doc__)
         .def(py::init(&PyFT2Font_init),
              "filename"_a, "hinting_factor"_a=8, py::kw_only(),
              "_fallback_list"_a=py::none(), "_kerning_factor"_a=0,
@@ -1617,6 +1724,8 @@ PYBIND11_MODULE(ft2font, m, py::mod_gil_not_used())
              PyFT2Font_select_charmap__doc__)
         .def("get_kerning", &PyFT2Font_get_kerning, "left"_a, "right"_a, "mode"_a,
              PyFT2Font_get_kerning__doc__)
+        .def("_layout", &PyFT2Font_layout, "string"_a, "flags"_a,
+             PyFT2Font_layout__doc__)
         .def("set_text", &PyFT2Font_set_text,
              "string"_a, "angle"_a=0.0, "flags"_a=LoadFlags::FORCE_AUTOHINT,
              PyFT2Font_set_text__doc__)