Merge branch 'libraqm-vector' into libraqm-full

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_idx = 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_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,
+                                  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.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
@@ -2355,7 +2355,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:
@@ -2367,6 +2366,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)
@@ -2394,8 +2394,9 @@ def draw_text(self, gc, x, y, s, prop, angle, ismath=False, mtext=None):
             prev_was_multibyte = True
             prev_font = font
             for item in _text_helpers.layout(s, font, features=features,
-                                             kern_mode=Kerning.UNFITTED,
                                              language=language):
+                self.file._character_tracker.track_glyph(item.ft_object,
+                                                         item.glyph_index)
                 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, []))
@@ -2431,15 +2432,15 @@ def draw_text(self, gc, x, y, s, prop, angle, ismath=False, mtext=None):
                 prev_start_x = start_x
             self.file.output(Op.end_text)
             # Then emit all the multibyte characters, one at a time.
-            for ft_object, start_x, glyph_idx in multibyte_glyphs:
+            for ft_object, start_x, glyph_index in multibyte_glyphs:
                 self._draw_xobject_glyph(
-                    ft_object, fontsize, glyph_idx, start_x, 0
+                    ft_object, fontsize, glyph_index, start_x, 0
                 )
             self.file.output(Op.grestore)
 
-    def _draw_xobject_glyph(self, font, fontsize, glyph_idx, x, y):
+    def _draw_xobject_glyph(self, font, fontsize, glyph_index, x, y):
         """Draw a multibyte character from a Type 3 font as an XObject."""
-        glyph_name = font.get_glyph_name(glyph_idx)
+        glyph_name = font.get_glyph_name(glyph_index)
         name = self.file._get_xobject_glyph_name(font.fname, glyph_name)
         self.file.output(
             Op.gsave,

lib/matplotlib/backends/backend_ps.py

@@ -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/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_ids = []
         for item in _text_helpers.layout(s, font, features=features, language=language):
             glyph_id = self._get_glyph_id(item.ft_object, item.glyph_index)
             glyph_ids.append(glyph_id)
             xpositions.append(item.x)
+            ypositions.append(item.y)
             if glyph_id not in glyph_map:
                 glyph_map_new[glyph_id] = item.ft_object.get_path()
 
-        ypositions = [0] * len(xpositions)
         sizes = [1.] * len(xpositions)
 
         rects = []

src/ft2font.cpp

@@ -318,29 +318,13 @@ void FT2Font::set_kerning_factor(int factor)
     }
 }
 
-void FT2Font::set_text(
-    std::u32string_view text, double angle, FT_Int32 flags,
+std::vector<raqm_glyph_t> FT2Font::layout(
+    std::u32string_view text, FT_Int32 flags,
     std::optional<std::vector<std::string>> features, LanguageType languages,
-    std::vector<double> &xys)
+    std::set<FT_String*>& glyph_seen_fonts)
 {
-    FT_Matrix matrix; /* transformation matrix */
-
-    angle = angle * (2 * M_PI / 360.0);
-
-    // this computes width and height in subpixels so we have to multiply by 64
-    double cosangle = cos(angle) * 0x10000L;
-    double sinangle = sin(angle) * 0x10000L;
-
-    matrix.xx = (FT_Fixed)cosangle;
-    matrix.xy = (FT_Fixed)-sinangle;
-    matrix.yx = (FT_Fixed)sinangle;
-    matrix.yy = (FT_Fixed)cosangle;
-
     clear();
 
-    bbox.xMin = bbox.yMin = 32000;
-    bbox.xMax = bbox.yMax = -32000;
-
     auto rq = raqm_create();
     if (!rq) {
         throw std::runtime_error("failed to compute text layout");
@@ -387,7 +371,6 @@ void FT2Font::set_text(
     }
 
     std::vector<std::pair<size_t, const FT_Face&>> face_substitutions;
-    std::set<FT_String*> glyph_seen_fonts;
     glyph_seen_fonts.insert(face->family_name);
 
     // Attempt to use fallback fonts if necessary.
@@ -474,9 +457,34 @@ void FT2Font::set_text(
     size_t num_glyphs = 0;
     auto const& rq_glyphs = raqm_get_glyphs(rq, &num_glyphs);
 
-    for (size_t i = 0; i < num_glyphs; i++) {
-        auto const& rglyph = rq_glyphs[i];
+    return std::vector<raqm_glyph_t>(rq_glyphs, rq_glyphs + num_glyphs);
+}
+
+void FT2Font::set_text(
+    std::u32string_view text, double angle, FT_Int32 flags,
+    std::optional<std::vector<std::string>> features, LanguageType languages,
+    std::vector<double> &xys)
+{
+    FT_Matrix matrix; /* transformation matrix */
+
+    angle = angle * (2 * M_PI / 360.0);
+
+    // this computes width and height in subpixels so we have to multiply by 64
+    double cosangle = cos(angle) * 0x10000L;
+    double sinangle = sin(angle) * 0x10000L;
+
+    matrix.xx = (FT_Fixed)cosangle;
+    matrix.xy = (FT_Fixed)-sinangle;
+    matrix.yx = (FT_Fixed)sinangle;
+    matrix.yy = (FT_Fixed)cosangle;
+
+    bbox.xMin = bbox.yMin = 32000;
+    bbox.xMax = bbox.yMax = -32000;
+
+    std::set<FT_String*> glyph_seen_fonts;
+    auto rq_glyphs = layout(text, flags, features, languages, glyph_seen_fonts);
 
+    for (auto const& rglyph : rq_glyphs) {
         // Warn for missing glyphs.
         if (rglyph.index == 0) {
             ft_glyph_warn(text[rglyph.cluster], glyph_seen_fonts);

src/ft2font.h

@@ -113,6 +113,10 @@ class FT2Font
     void set_size(double ptsize, double dpi);
     void set_charmap(int i);
     void select_charmap(unsigned long i);
+    std::vector<raqm_glyph_t> layout(std::u32string_view text, FT_Int32 flags,
+                                     std::optional<std::vector<std::string>> features,
+                                     LanguageType languages,
+                                     std::set<FT_String*>& glyph_seen_fonts);
     void set_text(std::u32string_view codepoints, double angle, FT_Int32 flags,
                   std::optional<std::vector<std::string>> features,
                   LanguageType languages, std::vector<double> &xys);