| 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) |
