fonttools 4.60.2__cp311-cp311-win32.whl

fontTools/varLib/interpolatablePlot.py

@@ -0,0 +1,1269 @@
+from .interpolatableHelpers import *
+from fontTools.ttLib import TTFont
+from fontTools.ttLib.ttGlyphSet import LerpGlyphSet
+from fontTools.pens.recordingPen import (
+    RecordingPen,
+    DecomposingRecordingPen,
+    RecordingPointPen,
+)
+from fontTools.pens.boundsPen import ControlBoundsPen
+from fontTools.pens.cairoPen import CairoPen
+from fontTools.pens.pointPen import (
+    SegmentToPointPen,
+    PointToSegmentPen,
+    ReverseContourPointPen,
+)
+from fontTools.varLib.interpolatableHelpers import (
+    PerContourOrComponentPen,
+    SimpleRecordingPointPen,
+)
+from itertools import cycle
+from functools import wraps
+from io import BytesIO
+import cairo
+import math
+import os
+import logging
+
+log = logging.getLogger("fontTools.varLib.interpolatable")
+
+
+class OverridingDict(dict):
+    def __init__(self, parent_dict):
+        self.parent_dict = parent_dict
+
+    def __missing__(self, key):
+        return self.parent_dict[key]
+
+
+class InterpolatablePlot:
+    width = 8.5 * 72
+    height = 11 * 72
+    pad = 0.1 * 72
+    title_font_size = 24
+    font_size = 16
+    page_number = 1
+    head_color = (0.3, 0.3, 0.3)
+    label_color = (0.2, 0.2, 0.2)
+    border_color = (0.9, 0.9, 0.9)
+    border_width = 0.5
+    fill_color = (0.8, 0.8, 0.8)
+    stroke_color = (0.1, 0.1, 0.1)
+    stroke_width = 1
+    oncurve_node_color = (0, 0.8, 0, 0.7)
+    oncurve_node_diameter = 6
+    offcurve_node_color = (0, 0.5, 0, 0.7)
+    offcurve_node_diameter = 4
+    handle_color = (0, 0.5, 0, 0.7)
+    handle_width = 0.5
+    corrected_start_point_color = (0, 0.9, 0, 0.7)
+    corrected_start_point_size = 7
+    wrong_start_point_color = (1, 0, 0, 0.7)
+    start_point_color = (0, 0, 1, 0.7)
+    start_arrow_length = 9
+    kink_point_size = 7
+    kink_point_color = (1, 0, 1, 0.7)
+    kink_circle_size = 15
+    kink_circle_stroke_width = 1
+    kink_circle_color = (1, 0, 1, 0.7)
+    contour_colors = ((1, 0, 0), (0, 0, 1), (0, 1, 0), (1, 1, 0), (1, 0, 1), (0, 1, 1))
+    contour_alpha = 0.5
+    weight_issue_contour_color = (0, 0, 0, 0.4)
+    no_issues_label = "Your font's good! Have a cupcake..."
+    no_issues_label_color = (0, 0.5, 0)
+    cupcake_color = (0.3, 0, 0.3)
+    cupcake = r"""
+                          ,@.
+                        ,@.@@,.
+                  ,@@,.@@@.  @.@@@,.
+                ,@@. @@@.     @@. @@,.
+        ,@@@.@,.@.              @.  @@@@,.@.@@,.
+   ,@@.@.     @@.@@.            @,.    .@' @'  @@,
+ ,@@. @.          .@@.@@@.  @@'                  @,
+,@.  @@.                                          @,
+@.     @,@@,.     ,                             .@@,
+@,.       .@,@@,.         .@@,.  ,       .@@,  @, @,
+@.                             .@. @ @@,.    ,      @
+ @,.@@.     @,.      @@,.      @.           @,.    @'
+  @@||@,.  @'@,.       @@,.  @@ @,.        @'@@,  @'
+     \\@@@@'  @,.      @'@@@@'   @@,.   @@@' //@@@'
+      |||||||| @@,.  @@' |||||||  |@@@|@||  ||
+       \\\\\\\  ||@@@||  |||||||  |||||||  //
+        |||||||  ||||||  ||||||   ||||||  ||
+         \\\\\\  ||||||  ||||||  ||||||  //
+          ||||||  |||||  |||||   |||||  ||
+           \\\\\  |||||  |||||  |||||  //
+            |||||  ||||  |||||  ||||  ||
+             \\\\  ||||  ||||  ||||  //
+              ||||||||||||||||||||||||
+"""
+    emoticon_color = (0, 0.3, 0.3)
+    shrug = r"""\_(")_/"""
+    underweight = r"""
+ o
+/|\
+/ \
+"""
+    overweight = r"""
+ o
+/O\
+/ \
+"""
+    yay = r""" \o/ """
+
+    def __init__(self, out, glyphsets, names=None, **kwargs):
+        self.out = out
+        self.glyphsets = glyphsets
+        self.names = names or [repr(g) for g in glyphsets]
+        self.toc = {}
+
+        for k, v in kwargs.items():
+            if not hasattr(self, k):
+                raise TypeError("Unknown keyword argument: %s" % k)
+            setattr(self, k, v)
+
+        self.panel_width = self.width / 2 - self.pad * 3
+        self.panel_height = (
+            self.height / 2 - self.pad * 6 - self.font_size * 2 - self.title_font_size
+        )
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, type, value, traceback):
+        pass
+
+    def show_page(self):
+        self.page_number += 1
+
+    def add_title_page(
+        self, files, *, show_tolerance=True, tolerance=None, kinkiness=None
+    ):
+        pad = self.pad
+        width = self.width - 3 * self.pad
+        height = self.height - 2 * self.pad
+        x = y = pad
+
+        self.draw_label(
+            "Problem report for:",
+            x=x,
+            y=y,
+            bold=True,
+            width=width,
+            font_size=self.title_font_size,
+        )
+        y += self.title_font_size
+
+        import hashlib
+
+        for file in files:
+            base_file = os.path.basename(file)
+            y += self.font_size + self.pad
+            self.draw_label(base_file, x=x, y=y, bold=True, width=width)
+            y += self.font_size + self.pad
+
+            try:
+                h = hashlib.sha1(open(file, "rb").read()).hexdigest()
+                self.draw_label("sha1: %s" % h, x=x + pad, y=y, width=width)
+                y += self.font_size
+            except IsADirectoryError:
+                pass
+
+            if file.endswith(".ttf"):
+                ttFont = TTFont(file)
+                name = ttFont["name"] if "name" in ttFont else None
+                if name:
+                    for what, nameIDs in (
+                        ("Family name", (21, 16, 1)),
+                        ("Version", (5,)),
+                    ):
+                        n = name.getFirstDebugName(nameIDs)
+                        if n is None:
+                            continue
+                        self.draw_label(
+                            "%s: %s" % (what, n), x=x + pad, y=y, width=width
+                        )
+                        y += self.font_size + self.pad
+            elif file.endswith((".glyphs", ".glyphspackage")):
+                from glyphsLib import GSFont
+
+                f = GSFont(file)
+                for what, field in (
+                    ("Family name", "familyName"),
+                    ("VersionMajor", "versionMajor"),
+                    ("VersionMinor", "_versionMinor"),
+                ):
+                    self.draw_label(
+                        "%s: %s" % (what, getattr(f, field)),
+                        x=x + pad,
+                        y=y,
+                        width=width,
+                    )
+                    y += self.font_size + self.pad
+
+        self.draw_legend(
+            show_tolerance=show_tolerance, tolerance=tolerance, kinkiness=kinkiness
+        )
+        self.show_page()
+
+    def draw_legend(self, *, show_tolerance=True, tolerance=None, kinkiness=None):
+        cr = cairo.Context(self.surface)
+
+        x = self.pad
+        y = self.height - self.pad - self.font_size * 2
+        width = self.width - 2 * self.pad
+
+        xx = x + self.pad * 2
+        xxx = x + self.pad * 4
+
+        if show_tolerance:
+            self.draw_label(
+                "Tolerance: badness; closer to zero the worse", x=xxx, y=y, width=width
+            )
+            y -= self.pad + self.font_size
+
+        self.draw_label("Underweight contours", x=xxx, y=y, width=width)
+        cr.rectangle(xx - self.pad * 0.7, y, 1.5 * self.pad, self.font_size)
+        cr.set_source_rgb(*self.fill_color)
+        cr.fill_preserve()
+        if self.stroke_color:
+            cr.set_source_rgb(*self.stroke_color)
+            cr.set_line_width(self.stroke_width)
+            cr.stroke_preserve()
+        cr.set_source_rgba(*self.weight_issue_contour_color)
+        cr.fill()
+        y -= self.pad + self.font_size
+
+        self.draw_label(
+            "Colored contours: contours with the wrong order", x=xxx, y=y, width=width
+        )
+        cr.rectangle(xx - self.pad * 0.7, y, 1.5 * self.pad, self.font_size)
+        if self.fill_color:
+            cr.set_source_rgb(*self.fill_color)
+            cr.fill_preserve()
+        if self.stroke_color:
+            cr.set_source_rgb(*self.stroke_color)
+            cr.set_line_width(self.stroke_width)
+            cr.stroke_preserve()
+        cr.set_source_rgba(*self.contour_colors[0], self.contour_alpha)
+        cr.fill()
+        y -= self.pad + self.font_size
+
+        self.draw_label("Kink artifact", x=xxx, y=y, width=width)
+        self.draw_circle(
+            cr,
+            x=xx,
+            y=y + self.font_size * 0.5,
+            diameter=self.kink_circle_size,
+            stroke_width=self.kink_circle_stroke_width,
+            color=self.kink_circle_color,
+        )
+        y -= self.pad + self.font_size
+
+        self.draw_label("Point causing kink in the contour", x=xxx, y=y, width=width)
+        self.draw_dot(
+            cr,
+            x=xx,
+            y=y + self.font_size * 0.5,
+            diameter=self.kink_point_size,
+            color=self.kink_point_color,
+        )
+        y -= self.pad + self.font_size
+
+        self.draw_label("Suggested new contour start point", x=xxx, y=y, width=width)
+        self.draw_dot(
+            cr,
+            x=xx,
+            y=y + self.font_size * 0.5,
+            diameter=self.corrected_start_point_size,
+            color=self.corrected_start_point_color,
+        )
+        y -= self.pad + self.font_size
+
+        self.draw_label(
+            "Contour start point in contours with wrong direction",
+            x=xxx,
+            y=y,
+            width=width,
+        )
+        self.draw_arrow(
+            cr,
+            x=xx - self.start_arrow_length * 0.3,
+            y=y + self.font_size * 0.5,
+            color=self.wrong_start_point_color,
+        )
+        y -= self.pad + self.font_size
+
+        self.draw_label(
+            "Contour start point when the first two points overlap",
+            x=xxx,
+            y=y,
+            width=width,
+        )
+        self.draw_dot(
+            cr,
+            x=xx,
+            y=y + self.font_size * 0.5,
+            diameter=self.corrected_start_point_size,
+            color=self.start_point_color,
+        )
+        y -= self.pad + self.font_size
+
+        self.draw_label("Contour start point and direction", x=xxx, y=y, width=width)
+        self.draw_arrow(
+            cr,
+            x=xx - self.start_arrow_length * 0.3,
+            y=y + self.font_size * 0.5,
+            color=self.start_point_color,
+        )
+        y -= self.pad + self.font_size
+
+        self.draw_label("Legend:", x=x, y=y, width=width, bold=True)
+        y -= self.pad + self.font_size
+
+        if kinkiness is not None:
+            self.draw_label(
+                "Kink-reporting aggressiveness: %g" % kinkiness,
+                x=xxx,
+                y=y,
+                width=width,
+            )
+            y -= self.pad + self.font_size
+
+        if tolerance is not None:
+            self.draw_label(
+                "Error tolerance: %g" % tolerance,
+                x=xxx,
+                y=y,
+                width=width,
+            )
+            y -= self.pad + self.font_size
+
+        self.draw_label("Parameters:", x=x, y=y, width=width, bold=True)
+        y -= self.pad + self.font_size
+
+    def add_summary(self, problems):
+        pad = self.pad
+        width = self.width - 3 * self.pad
+        height = self.height - 2 * self.pad
+        x = y = pad
+
+        self.draw_label(
+            "Summary of problems",
+            x=x,
+            y=y,
+            bold=True,
+            width=width,
+            font_size=self.title_font_size,
+        )
+        y += self.title_font_size
+
+        glyphs_per_problem = defaultdict(set)
+        for glyphname, problems in sorted(problems.items()):
+            for problem in problems:
+                glyphs_per_problem[problem["type"]].add(glyphname)
+
+        if "nothing" in glyphs_per_problem:
+            del glyphs_per_problem["nothing"]
+
+        for problem_type in sorted(
+            glyphs_per_problem, key=lambda x: InterpolatableProblem.severity[x]
+        ):
+            y += self.font_size
+            self.draw_label(
+                "%s: %d" % (problem_type, len(glyphs_per_problem[problem_type])),
+                x=x,
+                y=y,
+                width=width,
+                bold=True,
+            )
+            y += self.font_size
+
+            for glyphname in sorted(glyphs_per_problem[problem_type]):
+                if y + self.font_size > height:
+                    self.show_page()
+                    y = self.font_size + pad
+                self.draw_label(glyphname, x=x + 2 * pad, y=y, width=width - 2 * pad)
+                y += self.font_size
+
+        self.show_page()
+
+    def _add_listing(self, title, items):
+        pad = self.pad
+        width = self.width - 2 * self.pad
+        height = self.height - 2 * self.pad
+        x = y = pad
+
+        self.draw_label(
+            title, x=x, y=y, bold=True, width=width, font_size=self.title_font_size
+        )
+        y += self.title_font_size + self.pad
+
+        last_glyphname = None
+        for page_no, (glyphname, problems) in items:
+            if glyphname == last_glyphname:
+                continue
+            last_glyphname = glyphname
+            if y + self.font_size > height:
+                self.show_page()
+                y = self.font_size + pad
+            self.draw_label(glyphname, x=x + 5 * pad, y=y, width=width - 2 * pad)
+            self.draw_label(str(page_no), x=x, y=y, width=4 * pad, align=1)
+            y += self.font_size
+
+        self.show_page()
+
+    def add_table_of_contents(self):
+        self._add_listing("Table of contents", sorted(self.toc.items()))
+
+    def add_index(self):
+        self._add_listing("Index", sorted(self.toc.items(), key=lambda x: x[1][0]))
+
+    def add_problems(self, problems, *, show_tolerance=True, show_page_number=True):
+        for glyph, glyph_problems in problems.items():
+            last_masters = None
+            current_glyph_problems = []
+            for p in glyph_problems:
+                masters = (
+                    p["master_idx"]
+                    if "master_idx" in p
+                    else (p["master_1_idx"], p["master_2_idx"])
+                )
+                if masters == last_masters:
+                    current_glyph_problems.append(p)
+                    continue
+                # Flush
+                if current_glyph_problems:
+                    self.add_problem(
+                        glyph,
+                        current_glyph_problems,
+                        show_tolerance=show_tolerance,
+                        show_page_number=show_page_number,
+                    )
+                    self.show_page()
+                    current_glyph_problems = []
+                last_masters = masters
+                current_glyph_problems.append(p)
+            if current_glyph_problems:
+                self.add_problem(
+                    glyph,
+                    current_glyph_problems,
+                    show_tolerance=show_tolerance,
+                    show_page_number=show_page_number,
+                )
+                self.show_page()
+
+    def add_problem(
+        self, glyphname, problems, *, show_tolerance=True, show_page_number=True
+    ):
+        if type(problems) not in (list, tuple):
+            problems = [problems]
+
+        self.toc[self.page_number] = (glyphname, problems)
+
+        problem_type = problems[0]["type"]
+        problem_types = set(problem["type"] for problem in problems)
+        if not all(pt == problem_type for pt in problem_types):
+            problem_type = ", ".join(sorted({problem["type"] for problem in problems}))
+
+        log.info("Drawing %s: %s", glyphname, problem_type)
+
+        master_keys = (
+            ("master_idx",)
+            if "master_idx" in problems[0]
+            else ("master_1_idx", "master_2_idx")
+        )
+        master_indices = [problems[0][k] for k in master_keys]
+
+        if problem_type == InterpolatableProblem.MISSING:
+            sample_glyph = next(
+                i for i, m in enumerate(self.glyphsets) if m[glyphname] is not None
+            )
+            master_indices.insert(0, sample_glyph)
+
+        x = self.pad
+        y = self.pad
+
+        self.draw_label(
+            "Glyph name: " + glyphname,
+            x=x,
+            y=y,
+            color=self.head_color,
+            align=0,
+            bold=True,
+            font_size=self.title_font_size,
+        )
+        tolerance = min(p.get("tolerance", 1) for p in problems)
+        if tolerance < 1 and show_tolerance:
+            self.draw_label(
+                "tolerance: %.2f" % tolerance,
+                x=x,
+                y=y,
+                width=self.width - 2 * self.pad,
+                align=1,
+                bold=True,
+            )
+        y += self.title_font_size + self.pad
+        self.draw_label(
+            "Problems: " + problem_type,
+            x=x,
+            y=y,
+            width=self.width - 2 * self.pad,
+            color=self.head_color,
+            bold=True,
+        )
+        y += self.font_size + self.pad * 2
+
+        scales = []
+        for which, master_idx in enumerate(master_indices):
+            glyphset = self.glyphsets[master_idx]
+            name = self.names[master_idx]
+
+            self.draw_label(
+                name,
+                x=x,
+                y=y,
+                color=self.label_color,
+                width=self.panel_width,
+                align=0.5,
+            )
+            y += self.font_size + self.pad
+
+            if glyphset[glyphname] is not None:
+                scales.append(
+                    self.draw_glyph(glyphset, glyphname, problems, which, x=x, y=y)
+                )
+            else:
+                self.draw_emoticon(self.shrug, x=x, y=y)
+            y += self.panel_height + self.font_size + self.pad
+
+        if any(
+            pt
+            in (
+                InterpolatableProblem.NOTHING,
+                InterpolatableProblem.WRONG_START_POINT,
+                InterpolatableProblem.CONTOUR_ORDER,
+                InterpolatableProblem.KINK,
+                InterpolatableProblem.UNDERWEIGHT,
+                InterpolatableProblem.OVERWEIGHT,
+            )
+            for pt in problem_types
+        ):
+            x = self.pad + self.panel_width + self.pad
+            y = self.pad
+            y += self.title_font_size + self.pad * 2
+            y += self.font_size + self.pad
+
+            glyphset1 = self.glyphsets[master_indices[0]]
+            glyphset2 = self.glyphsets[master_indices[1]]
+
+            # Draw the mid-way of the two masters
+
+            self.draw_label(
+                "midway interpolation",
+                x=x,
+                y=y,
+                color=self.head_color,
+                width=self.panel_width,
+                align=0.5,
+            )
+            y += self.font_size + self.pad
+
+            midway_glyphset = LerpGlyphSet(glyphset1, glyphset2)
+            self.draw_glyph(
+                midway_glyphset,
+                glyphname,
+                [{"type": "midway"}]
+                + [
+                    p
+                    for p in problems
+                    if p["type"]
+                    in (
+                        InterpolatableProblem.KINK,
+                        InterpolatableProblem.UNDERWEIGHT,
+                        InterpolatableProblem.OVERWEIGHT,
+                    )
+                ],
+                None,
+                x=x,
+                y=y,
+                scale=min(scales),
+            )
+
+            y += self.panel_height + self.font_size + self.pad
+
+        if any(
+            pt
+            in (
+                InterpolatableProblem.WRONG_START_POINT,
+                InterpolatableProblem.CONTOUR_ORDER,
+                InterpolatableProblem.KINK,
+            )
+            for pt in problem_types
+        ):
+            # Draw the proposed fix
+
+            self.draw_label(
+                "proposed fix",
+                x=x,
+                y=y,
+                color=self.head_color,
+                width=self.panel_width,
+                align=0.5,
+            )
+            y += self.font_size + self.pad
+
+            overriding1 = OverridingDict(glyphset1)
+            overriding2 = OverridingDict(glyphset2)
+            perContourPen1 = PerContourOrComponentPen(
+                RecordingPen, glyphset=overriding1
+            )
+            perContourPen2 = PerContourOrComponentPen(
+                RecordingPen, glyphset=overriding2
+            )
+            glyphset1[glyphname].draw(perContourPen1)
+            glyphset2[glyphname].draw(perContourPen2)
+
+            for problem in problems:
+                if problem["type"] == InterpolatableProblem.CONTOUR_ORDER:
+                    fixed_contours = [
+                        perContourPen2.value[i] for i in problems[0]["value_2"]
+                    ]
+                    perContourPen2.value = fixed_contours
+
+            for problem in problems:
+                if problem["type"] == InterpolatableProblem.WRONG_START_POINT:
+                    # Save the wrong contours
+                    wrongContour1 = perContourPen1.value[problem["contour"]]
+                    wrongContour2 = perContourPen2.value[problem["contour"]]
+
+                    # Convert the wrong contours to point pens
+                    points1 = RecordingPointPen()
+                    converter = SegmentToPointPen(points1, False)
+                    wrongContour1.replay(converter)
+                    points2 = RecordingPointPen()
+                    converter = SegmentToPointPen(points2, False)
+                    wrongContour2.replay(converter)
+
+                    proposed_start = problem["value_2"]
+
+                    # See if we need reversing; fragile but worth a try
+                    if problem["reversed"]:
+                        new_points2 = RecordingPointPen()
+                        reversedPen = ReverseContourPointPen(new_points2)
+                        points2.replay(reversedPen)
+                        points2 = new_points2
+                        proposed_start = len(points2.value) - 2 - proposed_start
+
+                    # Rotate points2 so that the first point is the same as in points1
+                    beginPath = points2.value[:1]
+                    endPath = points2.value[-1:]
+                    pts = points2.value[1:-1]
+                    pts = pts[proposed_start:] + pts[:proposed_start]
+                    points2.value = beginPath + pts + endPath
+
+                    # Convert the point pens back to segment pens
+                    segment1 = RecordingPen()
+                    converter = PointToSegmentPen(segment1, True)
+                    points1.replay(converter)
+                    segment2 = RecordingPen()
+                    converter = PointToSegmentPen(segment2, True)
+                    points2.replay(converter)
+
+                    # Replace the wrong contours
+                    wrongContour1.value = segment1.value
+                    wrongContour2.value = segment2.value
+                    perContourPen1.value[problem["contour"]] = wrongContour1
+                    perContourPen2.value[problem["contour"]] = wrongContour2
+
+            for problem in problems:
+                # If we have a kink, try to fix it.
+                if problem["type"] == InterpolatableProblem.KINK:
+                    # Save the wrong contours
+                    wrongContour1 = perContourPen1.value[problem["contour"]]
+                    wrongContour2 = perContourPen2.value[problem["contour"]]
+
+                    # Convert the wrong contours to point pens
+                    points1 = RecordingPointPen()
+                    converter = SegmentToPointPen(points1, False)
+                    wrongContour1.replay(converter)
+                    points2 = RecordingPointPen()
+                    converter = SegmentToPointPen(points2, False)
+                    wrongContour2.replay(converter)
+
+                    i = problem["value"]
+
+                    # Position points to be around the same ratio
+                    # beginPath / endPath dance
+                    j = i + 1
+                    pt0 = points1.value[j][1][0]
+                    pt1 = points2.value[j][1][0]
+                    j_prev = (i - 1) % (len(points1.value) - 2) + 1
+                    pt0_prev = points1.value[j_prev][1][0]
+                    pt1_prev = points2.value[j_prev][1][0]
+                    j_next = (i + 1) % (len(points1.value) - 2) + 1
+                    pt0_next = points1.value[j_next][1][0]
+                    pt1_next = points2.value[j_next][1][0]
+
+                    pt0 = complex(*pt0)
+                    pt1 = complex(*pt1)
+                    pt0_prev = complex(*pt0_prev)
+                    pt1_prev = complex(*pt1_prev)
+                    pt0_next = complex(*pt0_next)
+                    pt1_next = complex(*pt1_next)
+
+                    # Find the ratio of the distance between the points
+                    r0 = abs(pt0 - pt0_prev) / abs(pt0_next - pt0_prev)
+                    r1 = abs(pt1 - pt1_prev) / abs(pt1_next - pt1_prev)
+                    r_mid = (r0 + r1) / 2
+
+                    pt0 = pt0_prev + r_mid * (pt0_next - pt0_prev)
+                    pt1 = pt1_prev + r_mid * (pt1_next - pt1_prev)
+
+                    points1.value[j] = (
+                        points1.value[j][0],
+                        (((pt0.real, pt0.imag),) + points1.value[j][1][1:]),
+                        points1.value[j][2],
+                    )
+                    points2.value[j] = (
+                        points2.value[j][0],
+                        (((pt1.real, pt1.imag),) + points2.value[j][1][1:]),
+                        points2.value[j][2],
+                    )
+
+                    # Convert the point pens back to segment pens
+                    segment1 = RecordingPen()
+                    converter = PointToSegmentPen(segment1, True)
+                    points1.replay(converter)
+                    segment2 = RecordingPen()
+                    converter = PointToSegmentPen(segment2, True)
+                    points2.replay(converter)
+
+                    # Replace the wrong contours
+                    wrongContour1.value = segment1.value
+                    wrongContour2.value = segment2.value
+
+            # Assemble
+            fixed1 = RecordingPen()
+            fixed2 = RecordingPen()
+            for contour in perContourPen1.value:
+                fixed1.value.extend(contour.value)
+            for contour in perContourPen2.value:
+                fixed2.value.extend(contour.value)
+            fixed1.draw = fixed1.replay
+            fixed2.draw = fixed2.replay
+
+            overriding1[glyphname] = fixed1
+            overriding2[glyphname] = fixed2
+
+            try:
+                midway_glyphset = LerpGlyphSet(overriding1, overriding2)
+                self.draw_glyph(
+                    midway_glyphset,
+                    glyphname,
+                    {"type": "fixed"},
+                    None,
+                    x=x,
+                    y=y,
+                    scale=min(scales),
+                )
+            except ValueError:
+                self.draw_emoticon(self.shrug, x=x, y=y)
+            y += self.panel_height + self.pad
+
+        else:
+            emoticon = self.shrug
+            if InterpolatableProblem.UNDERWEIGHT in problem_types:
+                emoticon = self.underweight
+            elif InterpolatableProblem.OVERWEIGHT in problem_types:
+                emoticon = self.overweight
+            elif InterpolatableProblem.NOTHING in problem_types:
+                emoticon = self.yay
+            self.draw_emoticon(emoticon, x=x, y=y)
+
+        if show_page_number:
+            self.draw_label(
+                str(self.page_number),
+                x=0,
+                y=self.height - self.font_size - self.pad,
+                width=self.width,
+                color=self.head_color,
+                align=0.5,
+            )
+
+    def draw_label(
+        self,
+        label,
+        *,
+        x=0,
+        y=0,
+        color=(0, 0, 0),
+        align=0,
+        bold=False,
+        width=None,
+        height=None,
+        font_size=None,
+    ):
+        if width is None:
+            width = self.width
+        if height is None:
+            height = self.height
+        if font_size is None:
+            font_size = self.font_size
+        cr = cairo.Context(self.surface)
+        cr.select_font_face(
+            "@cairo:",
+            cairo.FONT_SLANT_NORMAL,
+            cairo.FONT_WEIGHT_BOLD if bold else cairo.FONT_WEIGHT_NORMAL,
+        )
+        cr.set_font_size(font_size)
+        font_extents = cr.font_extents()
+        font_size = font_size * font_size / font_extents[2]
+        cr.set_font_size(font_size)
+        font_extents = cr.font_extents()
+
+        cr.set_source_rgb(*color)
+
+        extents = cr.text_extents(label)
+        if extents.width > width:
+            # Shrink
+            font_size *= width / extents.width
+            cr.set_font_size(font_size)
+            font_extents = cr.font_extents()
+            extents = cr.text_extents(label)
+
+        # Center
+        label_x = x + (width - extents.width) * align
+        label_y = y + font_extents[0]
+        cr.move_to(label_x, label_y)
+        cr.show_text(label)
+
+    def draw_glyph(self, glyphset, glyphname, problems, which, *, x=0, y=0, scale=None):
+        if type(problems) not in (list, tuple):
+            problems = [problems]
+
+        midway = any(problem["type"] == "midway" for problem in problems)
+        problem_type = problems[0]["type"]
+        problem_types = set(problem["type"] for problem in problems)
+        if not all(pt == problem_type for pt in problem_types):
+            problem_type = "mixed"
+        glyph = glyphset[glyphname]
+
+        recording = RecordingPen()
+        glyph.draw(recording)
+        decomposedRecording = DecomposingRecordingPen(glyphset)
+        glyph.draw(decomposedRecording)
+
+        boundsPen = ControlBoundsPen(glyphset)
+        decomposedRecording.replay(boundsPen)
+        bounds = boundsPen.bounds
+        if bounds is None:
+            bounds = (0, 0, 0, 0)
+
+        glyph_width = bounds[2] - bounds[0]
+        glyph_height = bounds[3] - bounds[1]
+
+        if glyph_width:
+            if scale is None:
+                scale = self.panel_width / glyph_width
+            else:
+                scale = min(scale, self.panel_height / glyph_height)
+        if glyph_height:
+            if scale is None:
+                scale = self.panel_height / glyph_height
+            else:
+                scale = min(scale, self.panel_height / glyph_height)
+        if scale is None:
+            scale = 1
+
+        cr = cairo.Context(self.surface)
+        cr.translate(x, y)
+        # Center
+        cr.translate(
+            (self.panel_width - glyph_width * scale) / 2,
+            (self.panel_height - glyph_height * scale) / 2,
+        )
+        cr.scale(scale, -scale)
+        cr.translate(-bounds[0], -bounds[3])
+
+        if self.border_color:
+            cr.set_source_rgb(*self.border_color)
+            cr.rectangle(bounds[0], bounds[1], glyph_width, glyph_height)
+            cr.set_line_width(self.border_width / scale)
+            cr.stroke()
+
+        if self.fill_color or self.stroke_color:
+            pen = CairoPen(glyphset, cr)
+            decomposedRecording.replay(pen)
+
+            if self.fill_color and problem_type != InterpolatableProblem.OPEN_PATH:
+                cr.set_source_rgb(*self.fill_color)
+                cr.fill_preserve()
+
+            if self.stroke_color:
+                cr.set_source_rgb(*self.stroke_color)
+                cr.set_line_width(self.stroke_width / scale)
+                cr.stroke_preserve()
+
+            cr.new_path()
+
+        if (
+            InterpolatableProblem.UNDERWEIGHT in problem_types
+            or InterpolatableProblem.OVERWEIGHT in problem_types
+        ):
+            perContourPen = PerContourOrComponentPen(RecordingPen, glyphset=glyphset)
+            recording.replay(perContourPen)
+            for problem in problems:
+                if problem["type"] in (
+                    InterpolatableProblem.UNDERWEIGHT,
+                    InterpolatableProblem.OVERWEIGHT,
+                ):
+                    contour = perContourPen.value[problem["contour"]]
+                    contour.replay(CairoPen(glyphset, cr))
+                    cr.set_source_rgba(*self.weight_issue_contour_color)
+                    cr.fill()
+
+        if any(
+            t in problem_types
+            for t in {
+                InterpolatableProblem.NOTHING,
+                InterpolatableProblem.NODE_COUNT,
+                InterpolatableProblem.NODE_INCOMPATIBILITY,
+            }
+        ):
+            cr.set_line_cap(cairo.LINE_CAP_ROUND)
+
+            # Oncurve nodes
+            for segment, args in decomposedRecording.value:
+                if not args:
+                    continue
+                x, y = args[-1]
+                cr.move_to(x, y)
+                cr.line_to(x, y)
+            cr.set_source_rgba(*self.oncurve_node_color)
+            cr.set_line_width(self.oncurve_node_diameter / scale)
+            cr.stroke()
+
+            # Offcurve nodes
+            for segment, args in decomposedRecording.value:
+                if not args:
+                    continue
+                for x, y in args[:-1]:
+                    cr.move_to(x, y)
+                    cr.line_to(x, y)
+            cr.set_source_rgba(*self.offcurve_node_color)
+            cr.set_line_width(self.offcurve_node_diameter / scale)
+            cr.stroke()
+
+            # Handles
+            for segment, args in decomposedRecording.value:
+                if not args:
+                    pass
+                elif segment in ("moveTo", "lineTo"):
+                    cr.move_to(*args[0])
+                elif segment == "qCurveTo":
+                    for x, y in args:
+                        cr.line_to(x, y)
+                    cr.new_sub_path()
+                    cr.move_to(*args[-1])
+                elif segment == "curveTo":
+                    cr.line_to(*args[0])
+                    cr.new_sub_path()
+                    cr.move_to(*args[1])
+                    cr.line_to(*args[2])
+                    cr.new_sub_path()
+                    cr.move_to(*args[-1])
+                else:
+                    continue
+
+            cr.set_source_rgba(*self.handle_color)
+            cr.set_line_width(self.handle_width / scale)
+            cr.stroke()
+
+        matching = None
+        for problem in problems:
+            if problem["type"] == InterpolatableProblem.CONTOUR_ORDER:
+                matching = problem["value_2"]
+                colors = cycle(self.contour_colors)
+                perContourPen = PerContourOrComponentPen(
+                    RecordingPen, glyphset=glyphset
+                )
+                recording.replay(perContourPen)
+                for i, contour in enumerate(perContourPen.value):
+                    if matching[i] == i:
+                        continue
+                    color = next(colors)
+                    contour.replay(CairoPen(glyphset, cr))
+                    cr.set_source_rgba(*color, self.contour_alpha)
+                    cr.fill()
+
+        for problem in problems:
+            if problem["type"] in (
+                InterpolatableProblem.NOTHING,
+                InterpolatableProblem.WRONG_START_POINT,
+            ):
+                idx = problem.get("contour")
+
+                # Draw suggested point
+                if idx is not None and which == 1 and "value_2" in problem:
+                    perContourPen = PerContourOrComponentPen(
+                        RecordingPen, glyphset=glyphset
+                    )
+                    decomposedRecording.replay(perContourPen)
+                    points = SimpleRecordingPointPen()
+                    converter = SegmentToPointPen(points, False)
+                    perContourPen.value[
+                        idx if matching is None else matching[idx]
+                    ].replay(converter)
+                    targetPoint = points.value[problem["value_2"]][0]
+                    cr.save()
+                    cr.translate(*targetPoint)
+                    cr.scale(1 / scale, 1 / scale)
+                    self.draw_dot(
+                        cr,
+                        diameter=self.corrected_start_point_size,
+                        color=self.corrected_start_point_color,
+                    )
+                    cr.restore()
+
+                # Draw start-point arrow
+                if which == 0 or not problem.get("reversed"):
+                    color = self.start_point_color
+                else:
+                    color = self.wrong_start_point_color
+                first_pt = None
+                i = 0
+                cr.save()
+                for segment, args in decomposedRecording.value:
+                    if segment == "moveTo":
+                        first_pt = args[0]
+                        continue
+                    if first_pt is None:
+                        continue
+                    if segment == "closePath":
+                        second_pt = first_pt
+                    else:
+                        second_pt = args[0]
+
+                    if idx is None or i == idx:
+                        cr.save()
+                        first_pt = complex(*first_pt)
+                        second_pt = complex(*second_pt)
+                        length = abs(second_pt - first_pt)
+                        cr.translate(first_pt.real, first_pt.imag)
+                        if length:
+                            # Draw arrowhead
+                            cr.rotate(
+                                math.atan2(
+                                    second_pt.imag - first_pt.imag,
+                                    second_pt.real - first_pt.real,
+                                )
+                            )
+                            cr.scale(1 / scale, 1 / scale)
+                            self.draw_arrow(cr, color=color)
+                        else:
+                            # Draw circle
+                            cr.scale(1 / scale, 1 / scale)
+                            self.draw_dot(
+                                cr,
+                                diameter=self.corrected_start_point_size,
+                                color=color,
+                            )
+                        cr.restore()
+
+                        if idx is not None:
+                            break
+
+                    first_pt = None
+                    i += 1
+
+                cr.restore()
+
+            if problem["type"] == InterpolatableProblem.KINK:
+                idx = problem.get("contour")
+                perContourPen = PerContourOrComponentPen(
+                    RecordingPen, glyphset=glyphset
+                )
+                decomposedRecording.replay(perContourPen)
+                points = SimpleRecordingPointPen()
+                converter = SegmentToPointPen(points, False)
+                perContourPen.value[idx if matching is None else matching[idx]].replay(
+                    converter
+                )
+
+                targetPoint = points.value[problem["value"]][0]
+                cr.save()
+                cr.translate(*targetPoint)
+                cr.scale(1 / scale, 1 / scale)
+                if midway:
+                    self.draw_circle(
+                        cr,
+                        diameter=self.kink_circle_size,
+                        stroke_width=self.kink_circle_stroke_width,
+                        color=self.kink_circle_color,
+                    )
+                else:
+                    self.draw_dot(
+                        cr,
+                        diameter=self.kink_point_size,
+                        color=self.kink_point_color,
+                    )
+                cr.restore()
+
+        return scale
+
+    def draw_dot(self, cr, *, x=0, y=0, color=(0, 0, 0), diameter=10):
+        cr.save()
+        cr.set_line_width(diameter)
+        cr.set_line_cap(cairo.LINE_CAP_ROUND)
+        cr.move_to(x, y)
+        cr.line_to(x, y)
+        if len(color) == 3:
+            color = color + (1,)
+        cr.set_source_rgba(*color)
+        cr.stroke()
+        cr.restore()
+
+    def draw_circle(
+        self, cr, *, x=0, y=0, color=(0, 0, 0), diameter=10, stroke_width=1
+    ):
+        cr.save()
+        cr.set_line_width(stroke_width)
+        cr.set_line_cap(cairo.LINE_CAP_SQUARE)
+        cr.arc(x, y, diameter / 2, 0, 2 * math.pi)
+        if len(color) == 3:
+            color = color + (1,)
+        cr.set_source_rgba(*color)
+        cr.stroke()
+        cr.restore()
+
+    def draw_arrow(self, cr, *, x=0, y=0, color=(0, 0, 0)):
+        cr.save()
+        if len(color) == 3:
+            color = color + (1,)
+        cr.set_source_rgba(*color)
+        cr.translate(self.start_arrow_length + x, y)
+        cr.move_to(0, 0)
+        cr.line_to(
+            -self.start_arrow_length,
+            -self.start_arrow_length * 0.4,
+        )
+        cr.line_to(
+            -self.start_arrow_length,
+            self.start_arrow_length * 0.4,
+        )
+        cr.close_path()
+        cr.fill()
+        cr.restore()
+
+    def draw_text(self, text, *, x=0, y=0, color=(0, 0, 0), width=None, height=None):
+        if width is None:
+            width = self.width
+        if height is None:
+            height = self.height
+
+        text = text.splitlines()
+        cr = cairo.Context(self.surface)
+        cr.set_source_rgb(*color)
+        cr.set_font_size(self.font_size)
+        cr.select_font_face(
+            "@cairo:monospace", cairo.FONT_SLANT_NORMAL, cairo.FONT_WEIGHT_NORMAL
+        )
+        text_width = 0
+        text_height = 0
+        font_extents = cr.font_extents()
+        font_font_size = font_extents[2]
+        font_ascent = font_extents[0]
+        for line in text:
+            extents = cr.text_extents(line)
+            text_width = max(text_width, extents.x_advance)
+            text_height += font_font_size
+        if not text_width:
+            return
+        cr.translate(x, y)
+        scale = min(width / text_width, height / text_height)
+        # center
+        cr.translate(
+            (width - text_width * scale) / 2, (height - text_height * scale) / 2
+        )
+        cr.scale(scale, scale)
+
+        cr.translate(0, font_ascent)
+        for line in text:
+            cr.move_to(0, 0)
+            cr.show_text(line)
+            cr.translate(0, font_font_size)
+
+    def draw_cupcake(self):
+        self.draw_label(
+            self.no_issues_label,
+            x=self.pad,
+            y=self.pad,
+            color=self.no_issues_label_color,
+            width=self.width - 2 * self.pad,
+            align=0.5,
+            bold=True,
+            font_size=self.title_font_size,
+        )
+
+        self.draw_text(
+            self.cupcake,
+            x=self.pad,
+            y=self.pad + self.font_size,
+            width=self.width - 2 * self.pad,
+            height=self.height - 2 * self.pad - self.font_size,
+            color=self.cupcake_color,
+        )
+
+    def draw_emoticon(self, emoticon, x=0, y=0):
+        self.draw_text(
+            emoticon,
+            x=x,
+            y=y,
+            color=self.emoticon_color,
+            width=self.panel_width,
+            height=self.panel_height,
+        )
+
+
+class InterpolatablePostscriptLike(InterpolatablePlot):
+    def __exit__(self, type, value, traceback):
+        self.surface.finish()
+
+    def show_page(self):
+        super().show_page()
+        self.surface.show_page()
+
+
+class InterpolatablePS(InterpolatablePostscriptLike):
+    def __enter__(self):
+        self.surface = cairo.PSSurface(self.out, self.width, self.height)
+        return self
+
+
+class InterpolatablePDF(InterpolatablePostscriptLike):
+    def __enter__(self):
+        self.surface = cairo.PDFSurface(self.out, self.width, self.height)
+        self.surface.set_metadata(
+            cairo.PDF_METADATA_CREATOR, "fonttools varLib.interpolatable"
+        )
+        self.surface.set_metadata(cairo.PDF_METADATA_CREATE_DATE, "")
+        return self
+
+
+class InterpolatableSVG(InterpolatablePlot):
+    def __enter__(self):
+        self.sink = BytesIO()
+        self.surface = cairo.SVGSurface(self.sink, self.width, self.height)
+        return self
+
+    def __exit__(self, type, value, traceback):
+        if self.surface is not None:
+            self.show_page()
+
+    def show_page(self):
+        super().show_page()
+        self.surface.finish()
+        self.out.append(self.sink.getvalue())
+        self.sink = BytesIO()
+        self.surface = cairo.SVGSurface(self.sink, self.width, self.height)