Prepare for MetaFont/PK font support.

anntzer · LangQi99 · commit e2b7d208dd75 · 2025-09-12T15:32:04.000+08:00
TeX MetaFont (.mf) fonts (e.g., from `\usepackage{concmath}`) need to be
converted to raster (.pk) fonts before usage.  In dvipng or pdftex this
is done by invoking mktexpk via kpsewhich.

This patch ensures that our calls to kpsewhich likewise also generate
and finds the raster files (in Matplotlib's own temporary cache) when
needed.  The resolution (600dpi) is the documented default (see e.g. the
-D option in `man kpsewhich`).  Note that this is only a preliminary
step towards full MF/PK font support, which would also require parsing
the PK file and embedding the glyphs into our final output.
diff --git a/lib/matplotlib/dviread.py b/lib/matplotlib/dviread.py
@@ -32,6 +32,7 @@
 import fontTools.agl
 import numpy as np
 
+import matplotlib as mpl
 from matplotlib import _api, cbook, font_manager
 from matplotlib.ft2font import LoadFlags
 
@@ -127,7 +128,13 @@ def glyph_name_or_index(self):
     def _as_unicode_or_name(self):
         if self.font.subfont:
             raise NotImplementedError("Indexing TTC fonts is not supported yet")
-        face = font_manager.get_font(self.font.resolve_path())
+        path = self.font.resolve_path()
+        if path.name.lower().endswith("pk"):
+            # PK fonts have no encoding information; report glyphs as ASCII but
+            # with a "?" to indicate that this is just a guess.
+            return (f"{chr(self.glyph)}?" if chr(self.glyph).isprintable() else
+                    f"pk{self.glyph:#02x}")
+        face = font_manager.get_font(path)
         glyph_name = face.get_glyph_name(self.index)
         glyph_str = fontTools.agl.toUnicode(glyph_name)
         return glyph_str or glyph_name
@@ -758,13 +765,24 @@ def _height_depth_of(self, char):
 
     def resolve_path(self):
         if self._path is None:
-            psfont = PsfontsMap(find_tex_file("pdftex.map"))[self.texname]
-            if psfont.filename is None:
-                raise ValueError("No usable font file found for {} ({}); "
-                                 "the font may lack a Type-1 version"
-                                 .format(psfont.psname.decode("ascii"),
-                                         psfont.texname.decode("ascii")))
-            self._path = Path(psfont.filename)
+            fontmap = PsfontsMap(find_tex_file("pdftex.map"))
+            try:
+                psfont = fontmap[self.texname]
+            except LookupError as exc:
+                try:
+                    find_tex_file(f"{self.texname.decode('ascii')}.mf")
+                except FileNotFoundError:
+                    raise exc from None
+                else:
+                    self._path = Path(find_tex_file(
+                        f"{self.texname.decode('ascii')}.600pk"))
+            else:
+                if psfont.filename is None:
+                    raise ValueError("No usable font file found for {} ({}); "
+                                     "the font may lack a Type-1 version"
+                                     .format(psfont.psname.decode("ascii"),
+                                             psfont.texname.decode("ascii")))
+                self._path = Path(psfont.filename)
         return self._path
 
     @cached_property
@@ -773,6 +791,8 @@ def subfont(self):
 
     @cached_property
     def effects(self):
+        if self.resolve_path().match("*.600pk"):
+            return {}
         return PsfontsMap(find_tex_file("pdftex.map"))[self.texname].effects
 
     def _index_dvi_to_freetype(self, idx):
@@ -1233,9 +1253,12 @@ def __new__(cls):
 
     def _new_proc(self):
         return subprocess.Popen(
-            ["luatex", "--luaonly",
-             str(cbook._get_data_path("kpsewhich.lua"))],
-            stdin=subprocess.PIPE, stdout=subprocess.PIPE)
+            ["luatex", "--luaonly", str(cbook._get_data_path("kpsewhich.lua"))],
+            # mktexpk logs to stderr; suppress that.
+            stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL,
+            # Store generated pk fonts in our own cache.
+            env={"MT_VARTEXFONTS": str(Path(mpl.get_cachedir(), "vartexfonts")),
+                 **os.environ})
 
     def search(self, filename):
         if self._proc.poll() is not None:  # Dead, restart it.
@@ -1287,13 +1310,16 @@ def find_tex_file(filename):
             kwargs = {'env': {**os.environ, 'command_line_encoding': 'utf-8'},
                       'encoding': 'utf-8'}
         else:  # On POSIX, run through the equivalent of os.fsdecode().
-            kwargs = {'encoding': sys.getfilesystemencoding(),
+            kwargs = {'env': {**os.environ},
+                      'encoding': sys.getfilesystemencoding(),
                       'errors': 'surrogateescape'}
+        kwargs['env'].update(
+            MT_VARTEXFONTS=str(Path(mpl.get_cachedir(), "vartexfonts")))
 
         try:
-            path = (cbook._check_and_log_subprocess(['kpsewhich', filename],
-                                                    _log, **kwargs)
-                    .rstrip('\n'))
+            path = cbook._check_and_log_subprocess(
+                ['kpsewhich', '-mktex=pk', filename], _log, **kwargs,
+            ).rstrip('\n')
         except (FileNotFoundError, RuntimeError):
             path = None
 
@@ -1327,7 +1353,6 @@ def _print_fields(*args):
         print(" ".join(map("{:>11}".format, args)))
 
     with Dvi(args.filename, args.dpi) as dvi:
-        fontmap = PsfontsMap(find_tex_file('pdftex.map'))
         for page in dvi:
             print(f"=== NEW PAGE === "
                   f"(w: {page.width}, h: {page.height}, d: {page.descent})")
diff --git a/lib/matplotlib/mpl-data/kpsewhich.lua b/lib/matplotlib/mpl-data/kpsewhich.lua
@@ -1,3 +1,4 @@
 -- see dviread._LuatexKpsewhich
 kpse.set_program_name("latex")
-while true do print(kpse.lookup(io.read():gsub("\r", ""))); io.flush(); end
+kpse.init_prog("", 600, "ljfour")
+while true do print(kpse.lookup(io.read():gsub("\r", ""), {mktexpk=true})); io.flush(); end
diff --git a/lib/matplotlib/tests/test_dviread.py b/lib/matplotlib/tests/test_dviread.py
@@ -3,7 +3,7 @@
 import shutil
 
 from matplotlib import cbook, dviread as dr
-from matplotlib.testing import subprocess_run_for_testing
+from matplotlib.testing import subprocess_run_for_testing, _has_tex_package
 import pytest
 
 
@@ -105,3 +105,43 @@ def test_dviread(tmp_path, engine, monkeypatch):
     ]
     correct = json.loads((dirpath / f"{engine}.json").read_text())
     assert data == correct
+
+
+@pytest.mark.skipif(shutil.which("latex") is None, reason="latex is not available")
+@pytest.mark.skipif(not _has_tex_package("concmath"), reason="needs concmath.sty")
+def test_dviread_pk(tmp_path):
+    (tmp_path / "test.tex").write_text(r"""
+        \documentclass{article}
+        \usepackage{concmath}
+        \pagestyle{empty}
+        \begin{document}
+        Hi!
+        \end{document}
+        """)
+    subprocess_run_for_testing(
+        ["latex", "test.tex"], cwd=tmp_path, check=True, capture_output=True)
+    with dr.Dvi(tmp_path / "test.dvi", None) as dvi:
+        pages = [*dvi]
+    data = [
+        {
+            "text": [
+                [
+                    t.x, t.y,
+                    t._as_unicode_or_name(),
+                    t.font.resolve_path().name,
+                    round(t.font.size, 2),
+                    t.font.effects,
+                ] for t in page.text
+            ],
+            "boxes": [[b.x, b.y, b.height, b.width] for b in page.boxes]
+        } for page in pages
+    ]
+    correct = [{
+        'boxes': [],
+        'text': [
+            [5046272, 4128768, 'H?', 'ccr10.600pk', 9.96, {}],
+            [5530510, 4128768, 'i?', 'ccr10.600pk', 9.96, {}],
+            [5716195, 4128768, '!?', 'ccr10.600pk', 9.96, {}],
+        ],
+    }]
+    assert data == correct
