Stop using ttconv for pdf.

anntzer · anntzer · commit 586edd9e4a64 · 2020-08-07T09:59:44.000+02:00
Quite a bit of work goes into reproducing quirks of the old ttconv code
in order not to update baseline images, but this can easily be dropped
once the new baseline images system goes in.
diff --git a/lib/matplotlib/backends/backend_pdf.py b/lib/matplotlib/backends/backend_pdf.py
@@ -42,7 +42,6 @@
 from matplotlib.path import Path
 from matplotlib.dates import UTC
 from matplotlib import _path
-from matplotlib import _ttconv
 from . import _backend_pdf_ps
 
 _log = logging.getLogger(__name__)
@@ -556,6 +555,50 @@ def _flush(self):
             self.compressobj = None
 
 
+def _get_pdf_charprocs(font_path, glyph_ids):
+    font = get_font(font_path, hinting_factor=1)
+    conv = 1000 / font.units_per_EM  # Conversion to PS units (1/1000's).
+    procs = {}
+    for glyph_id in glyph_ids:
+        g = font.load_glyph(glyph_id, LOAD_NO_SCALE)
+        # NOTE: We should be using round(), but instead use
+        # "(x+.5).astype(int)" to keep backcompat with the old ttconv code
+        # (this is different for negative x's).
+        d1 = (np.array([g.horiAdvance, 0, *g.bbox]) * conv + .5).astype(int)
+        v, c = font.get_path()
+        v = (v * 64).astype(int)  # Back to TrueType's internal units (1/64's).
+        # Backcompat with old ttconv code: control points between two quads are
+        # omitted if they are exactly at the midpoint between the control of
+        # the quad before and the quad after, but ttconv used to interpolate
+        # *after* conversion to PS units, causing floating point errors.  Here
+        # we reproduce ttconv's logic, detecting these "implicit" points and
+        # re-interpolating them.
+        quads, = np.nonzero(c == 3)
+        quads_on = quads[1::2]
+        quads_mid_on = np.array(
+            sorted({*quads_on} & {*quads - 1} & {*quads + 1}), int)
+        implicit = quads_mid_on[
+            (v[quads_mid_on]  # As above, use astype(int), not // division
+             == ((v[quads_mid_on - 1] + v[quads_mid_on + 1]) / 2).astype(int))
+            .all(axis=1)]
+        if (font.postscript_name, glyph_id) in [
+                ("DejaVuSerif-Italic", 77),  # j
+                ("DejaVuSerif-Italic", 135),  # \AA
+        ]:
+            v[:, 0] -= 1  # Hard-coded backcompat (FreeType shifts glyph by 1).
+        v = (v * conv + .5).astype(int)  # As above re: truncation vs rounding.
+        v[implicit] = ((  # Fix implicit points; again, truncate.
+            (v[implicit - 1] + v[implicit + 1]) / 2).astype(int))
+        procs[font.get_glyph_name(glyph_id)] = (
+            " ".join(map(str, d1)).encode("ascii") + b" d1\n"
+            + _path.convert_to_string(
+                Path(v, c), None, None, False, None, -1,
+                # no code for quad Beziers triggers auto-conversion to cubics.
+                [b"m", b"l", b"", b"c", b"h"], True)
+            + b"f")
+    return procs
+
+
 class PdfFile:
     """PDF file object."""
 
@@ -1089,15 +1132,8 @@ def get_char_width(charcode):
                 differencesArray.append(Name(name))
                 last_c = c
 
-            # Make the charprocs array (using ttconv to generate the
-            # actual outlines)
-            try:
-                rawcharprocs = _ttconv.get_pdf_charprocs(
-                    os.fsencode(filename), glyph_ids)
-            except RuntimeError:
-                _log.warning("The PDF backend does not currently support the "
-                             "selected font.")
-                raise
+            # Make the charprocs array.
+            rawcharprocs = _get_pdf_charprocs(filename, glyph_ids)
             charprocs = {}
             for charname in sorted(rawcharprocs):
                 stream = rawcharprocs[charname]
diff --git a/lib/matplotlib/tests/test_mathtext.py b/lib/matplotlib/tests/test_mathtext.py
@@ -185,6 +185,7 @@ def baseline_images(request, fontset, index):
 @image_comparison(baseline_images=None)
 def test_mathtext_rendering(baseline_images, fontset, index, test):
     mpl.rcParams['mathtext.fontset'] = fontset
+    mpl.rcParams['pdf.compression'] = False
     fig = plt.figure(figsize=(5.25, 0.75))
     fig.text(0.5, 0.5, test,
              horizontalalignment='center', verticalalignment='center')
diff --git a/src/_path.h b/src/_path.h
@@ -1089,35 +1089,39 @@ void quad2cubic(double x0, double y0,
 void __add_number(double val, char format_code, int precision,
                   std::string& buffer)
 {
-    char *str = PyOS_double_to_string(val, format_code, precision, 0, NULL);
-
-    // Delete trailing zeros and decimal point
-    char *q = str;
-    for (; *q != 0; ++q) {
+    if (precision == -1) {
+        // Special-case for compat with old ttconv code, which *truncated*
+        // values with a cast to int instead of rounding them as printf
+        // would do.  The only point where non-integer values arise is from
+        // quad2cubic conversion (as we already perform a first truncation
+        // on Python's side), which can introduce additional floating point
+        // error (by adding 2/3 delta-x and then 1/3 delta-x), so compensate by
+        // first rounding to the closest 1/3 and then truncating.
+        char str[255];
+        PyOS_snprintf(str, 255, "%d", (int)(round(val * 3)) / 3);
+        buffer += str;
+    } else {
+        char *str = PyOS_double_to_string(val, format_code, precision, 0, NULL);
+        // Delete trailing zeros and decimal point
+        char *q = str;
         // Find the end of the string
-    }
-
-    --q;
-    for (; q >= str && *q == '0'; --q) {
-        // Rewind through all the zeros
-    }
-
-    // If the end is a decimal point, delete that too
-    if (q >= str && *q == '.') {
+        while (*q) { ++q; }
         --q;
-    }
-
-    // Truncate the string
-    ++q;
-    *q = 0;
-
-    try {
-        buffer += str;
-    } catch (std::bad_alloc& e) {
+        // Rewind through all the zeros
+        while (q >= str && *q == '0') { --q; }
+        // If the end is a decimal point, delete that too
+        if (q >= str && *q == '.') { --q; }
+        // Truncate the string
+        ++q;
+        *q = 0;
+        try {
+            buffer += str;
+        } catch (std::bad_alloc& e) {
+            PyMem_Free(str);
+            throw e;
+        }
         PyMem_Free(str);
-        throw e;
     }
-    PyMem_Free(str);
 }
 
 
