Merge pull request matplotlib#20749 from QuLogic/font-cleanups

Cleanup font subsetting code

Author: jkseppan

lib/matplotlib/backends/_backend_pdf_ps.py

@@ -61,18 +61,11 @@ def __init__(self):
 
     def track(self, font, s):
         """Record that string *s* is being typeset using font *font*."""
-        if isinstance(font, str):
-            # Unused, can be removed after removal of track_characters.
-            fname = font
-        else:
-            fname = font.fname
-        self.used.setdefault(fname, set()).update(map(ord, s))
-
-    # Not public, can be removed when pdf/ps merge_used_characters is removed.
-    def merge(self, other):
-        """Update self with a font path to character codepoints."""
-        for fname, charset in other.items():
-            self.used.setdefault(fname, set()).update(charset)
+        self.used.setdefault(font.fname, set()).update(map(ord, s))
+
+    def track_glyph(self, font, glyph):
+        """Record that codepoint *glyph* is being typeset using font *font*."""
+        self.used.setdefault(font.fname, set()).add(glyph)
 
 
 class RendererPDFPSBase(RendererBase):

lib/matplotlib/backends/backend_pdf.py

@@ -323,18 +323,18 @@ def pdfRepr(obj):
                         .format(type(obj)))
 
 
-def _font_supports_char(fonttype, char):
+def _font_supports_glyph(fonttype, glyph):
     """
-    Returns True if the font is able to provide *char* in a PDF.
+    Returns True if the font is able to provide codepoint *glyph* in a PDF.
 
     For a Type 3 font, this method returns True only for single-byte
-    chars.  For Type 42 fonts this method return True if the char is from
-    the Basic Multilingual Plane.
+    characters. For Type 42 fonts this method return True if the character is
+    from the Basic Multilingual Plane.
     """
     if fonttype == 3:
-        return ord(char) <= 255
+        return glyph <= 255
     if fonttype == 42:
-        return ord(char) <= 65535
+        return glyph <= 65535
     raise NotImplementedError()
 
 
@@ -1227,13 +1227,9 @@ def embedTTFType42(font, characters, descriptor):
             wObject = self.reserveObject('Type 0 widths')
             toUnicodeMapObject = self.reserveObject('ToUnicode map')
 
-            _log.debug(
-                "SUBSET %s characters: %s",
-                filename, "".join(chr(c) for c in characters)
-            )
-            fontdata = _backend_pdf_ps.get_glyphs_subset(
-                filename, "".join(chr(c) for c in characters)
-            )
+            subset_str = "".join(chr(c) for c in characters)
+            _log.debug("SUBSET %s characters: %s", filename, subset_str)
+            fontdata = _backend_pdf_ps.get_glyphs_subset(filename, subset_str)
             _log.debug(
                 "SUBSET %s %d -> %d", filename,
                 os.stat(filename).st_size, fontdata.getbuffer().nbytes
@@ -1327,7 +1323,7 @@ def embedTTFType42(font, characters, descriptor):
             # Add XObjects for unsupported chars
             glyph_ids = []
             for ccode in characters:
-                if not _font_supports_char(fonttype, chr(ccode)):
+                if not _font_supports_glyph(fonttype, ccode):
                     gind = full_font.get_char_index(ccode)
                     glyph_ids.append(gind)
 
@@ -2193,10 +2189,9 @@ def draw_mathtext(self, gc, x, y, s, prop, angle):
 
         self.file.output(Op.begin_text)
         for font, fontsize, num, ox, oy in glyphs:
-            char = chr(num)
-            self.file._character_tracker.track(font, char)
+            self.file._character_tracker.track_glyph(font, num)
             fontname = font.fname
-            if not _font_supports_char(fonttype, char):
+            if not _font_supports_glyph(fonttype, num):
                 # Unsupported chars (i.e. multibyte in Type 3 or beyond BMP in
                 # Type 42) must be emitted separately (below).
                 unsupported_chars.append((font, fontsize, ox, oy, num))
@@ -2383,7 +2378,7 @@ def draw_text(self, gc, x, y, s, prop, angle, ismath=False, mtext=None):
             prev_was_multibyte = True
             for item in _text_helpers.layout(
                     s, font, kern_mode=KERNING_UNFITTED):
-                if _font_supports_char(fonttype, item.char):
+                if _font_supports_glyph(fonttype, ord(item.char)):
                     if prev_was_multibyte:
                         singlebyte_chunks.append((item.x, []))
                     if item.prev_kern:

lib/matplotlib/backends/backend_ps.py

@@ -121,16 +121,16 @@ def _move_path_to_path_or_stream(src, dst):
         shutil.move(src, dst, copy_function=shutil.copyfile)
 
 
-def _font_to_ps_type3(font_path, glyph_ids):
+def _font_to_ps_type3(font_path, chars):
     """
-    Subset *glyph_ids* from the font at *font_path* into a Type 3 font.
+    Subset *chars* from the font at *font_path* into a Type 3 font.
 
     Parameters
     ----------
     font_path : path-like
         Path to the font to be subsetted.
-    glyph_ids : list of int
-        The glyph indices to include in the subsetted font.
+    chars : str
+        The characters to include in the subsetted font.
 
     Returns
     -------
@@ -139,6 +139,7 @@ def _font_to_ps_type3(font_path, glyph_ids):
         verbatim into a PostScript file.
     """
     font = get_font(font_path, hinting_factor=1)
+    glyph_ids = [font.get_char_index(c) for c in chars]
 
     preamble = """\
 %!PS-Adobe-3.0 Resource-Font
@@ -201,6 +202,44 @@ def _font_to_ps_type3(font_path, glyph_ids):
     return preamble + "\n".join(entries) + postamble
 
 
+def _font_to_ps_type42(font_path, chars, fh):
+    """
+    Subset *chars* from the font at *font_path* into a Type 42 font at *fh*.
+
+    Parameters
+    ----------
+    font_path : path-like
+        Path to the font to be subsetted.
+    chars : str
+        The characters to include in the subsetted font.
+    fh : file-like
+        Where to write the font.
+    """
+    subset_str = ''.join(chr(c) for c in chars)
+    _log.debug("SUBSET %s characters: %s", font_path, subset_str)
+    try:
+        fontdata = _backend_pdf_ps.get_glyphs_subset(font_path, subset_str)
+        _log.debug("SUBSET %s %d -> %d", font_path, os.stat(font_path).st_size,
+                   fontdata.getbuffer().nbytes)
+
+        # Give ttconv a subsetted font along with updated glyph_ids.
+        font = FT2Font(fontdata)
+        glyph_ids = [font.get_char_index(c) for c in chars]
+        with TemporaryDirectory() as tmpdir:
+            tmpfile = os.path.join(tmpdir, "tmp.ttf")
+
+            with open(tmpfile, 'wb') as tmp:
+                tmp.write(fontdata.getvalue())
+
+            # TODO: allow convert_ttf_to_ps to input file objects (BytesIO)
+            convert_ttf_to_ps(os.fsencode(tmpfile), fh, 42, glyph_ids)
+    except RuntimeError:
+        _log.warning(
+            "The PostScript backend does not currently "
+            "support the selected font.")
+        raise
+
+
 def _log_if_debug_on(meth):
     """
     Wrap `RendererPS` method *meth* to emit a PS comment with the method name,
@@ -657,7 +696,7 @@ def draw_mathtext(self, gc, x, y, s, prop, angle):
             f"{angle:f} rotate\n")
         lastfont = None
         for font, fontsize, num, ox, oy in glyphs:
-            self._character_tracker.track(font, chr(num))
+            self._character_tracker.track_glyph(font, num)
             if (font.postscript_name, fontsize) != lastfont:
                 lastfont = font.postscript_name, fontsize
                 self._pswriter.write(
@@ -931,56 +970,15 @@ def print_figure_impl(fh):
                         in ps_renderer._character_tracker.used.items():
                     if not chars:
                         continue
-                    font = get_font(font_path)
-                    glyph_ids = [font.get_char_index(c) for c in chars]
                     fonttype = mpl.rcParams['ps.fonttype']
                     # Can't use more than 255 chars from a single Type 3 font.
-                    if len(glyph_ids) > 255:
+                    if len(chars) > 255:
                         fonttype = 42
                     fh.flush()
                     if fonttype == 3:
-                        fh.write(_font_to_ps_type3(font_path, glyph_ids))
-                    else:
-                        try:
-                            _log.debug(
-                                "SUBSET %s characters: %s", font_path,
-                                ''.join(chr(c) for c in chars)
-                            )
-                            fontdata = _backend_pdf_ps.get_glyphs_subset(
-                                font_path, "".join(chr(c) for c in chars)
-                            )
-                            _log.debug(
-                                "SUBSET %s %d -> %d", font_path,
-                                os.stat(font_path).st_size,
-                                fontdata.getbuffer().nbytes
-                            )
-
-                            # give ttconv a subsetted font
-                            # along with updated glyph_ids
-                            with TemporaryDirectory() as tmpdir:
-                                tmpfile = os.path.join(tmpdir, "tmp.ttf")
-                                font = FT2Font(fontdata)
-                                glyph_ids = [
-                                    font.get_char_index(c) for c in chars
-                                ]
-
-                                with open(tmpfile, 'wb') as tmp:
-                                    tmp.write(fontdata.getvalue())
-                                    tmp.flush()
-
-                                # TODO: allow convert_ttf_to_ps
-                                # to input file objects (BytesIO)
-                                convert_ttf_to_ps(
-                                    os.fsencode(tmpfile),
-                                    fh,
-                                    fonttype,
-                                    glyph_ids,
-                                )
-                        except RuntimeError:
-                            _log.warning(
-                                "The PostScript backend does not currently "
-                                "support the selected font.")
-                            raise
+                        fh.write(_font_to_ps_type3(font_path, chars))
+                    else:  # Type 42 only.
+                        _font_to_ps_type42(font_path, chars, fh)
             print("end", file=fh)
             print("%%EndProlog", file=fh)