Lib/fontTools/varLib/interpolatable.py - third_party/fonttools - Git at Google

 """
 Tool to find wrong contour order between different masters, and
 other interpolatability (or lack thereof) issues.

 Call as:
 $ fonttools varLib.interpolatable font1 font2 ...
 """

 from fontTools.pens.basePen import AbstractPen, BasePen
 from fontTools.pens.recordingPen import RecordingPen
 from fontTools.pens.statisticsPen import StatisticsPen
 from fontTools.pens.momentsPen import OpenContourError
 from collections import OrderedDict
 import itertools
 import sys


 class PerContourPen(BasePen):
     def __init__(self, Pen, glyphset=None):
         BasePen.__init__(self, glyphset)
         self._glyphset = glyphset
         self._Pen = Pen
         self._pen = None
         self.value = []

     def _moveTo(self, p0):
         self._newItem()
         self._pen.moveTo(p0)

     def _lineTo(self, p1):
         self._pen.lineTo(p1)

     def _qCurveToOne(self, p1, p2):
         self._pen.qCurveTo(p1, p2)

     def _curveToOne(self, p1, p2, p3):
         self._pen.curveTo(p1, p2, p3)

     def _closePath(self):
         self._pen.closePath()
         self._pen = None

     def _endPath(self):
         self._pen.endPath()
         self._pen = None

     def _newItem(self):
         self._pen = pen = self._Pen()
         self.value.append(pen)


 class PerContourOrComponentPen(PerContourPen):
     def addComponent(self, glyphName, transformation):
         self._newItem()
         self.value[-1].addComponent(glyphName, transformation)


 def _vdiff(v0, v1):
     return tuple(b - a for a, b in zip(v0, v1))


 def _vlen(vec):
     v = 0
     for x in vec:
         v += x * x
     return v


 def _matching_cost(G, matching):
     return sum(G[i][j] for i, j in enumerate(matching))


 def min_cost_perfect_bipartite_matching(G):
     n = len(G)
     try:
         from scipy.optimize import linear_sum_assignment

         rows, cols = linear_sum_assignment(G)
         assert (rows == list(range(n))).all()
         return list(cols), _matching_cost(G, cols)
     except ImportError:
         pass

     try:
         from munkres import Munkres

         cols = [None] * n
         for row, col in Munkres().compute(G):
             cols[row] = col
         return cols, _matching_cost(G, cols)
     except ImportError:
         pass

     if n > 6:
         raise Exception("Install Python module 'munkres' or 'scipy >= 0.17.0'")

     # Otherwise just brute-force
     permutations = itertools.permutations(range(n))
     best = list(next(permutations))
     best_cost = _matching_cost(G, best)
     for p in permutations:
         cost = _matching_cost(G, p)
         if cost < best_cost:
             best, best_cost = list(p), cost
     return best, best_cost


 def test(glyphsets, glyphs=None, names=None):

     if names is None:
         names = glyphsets
     if glyphs is None:
         glyphs = glyphsets[0].keys()

     hist = []
     problems = OrderedDict()

     def add_problem(glyphname, problem):
         problems.setdefault(glyphname, []).append(problem)

     for glyph_name in glyphs:
         # print()
         # print(glyph_name)

         try:
             allVectors = []
             allNodeTypes = []
             for glyphset, name in zip(glyphsets, names):
                 # print('.', end='')
                 if glyph_name not in glyphset:
                     add_problem(glyph_name, {"type": "missing", "master": name})
                     continue
                 glyph = glyphset[glyph_name]

                 perContourPen = PerContourOrComponentPen(
                     RecordingPen, glyphset=glyphset
                 )
                 glyph.draw(perContourPen)
                 contourPens = perContourPen.value
                 del perContourPen

                 contourVectors = []
                 nodeTypes = []
                 allNodeTypes.append(nodeTypes)
                 allVectors.append(contourVectors)
                 for ix, contour in enumerate(contourPens):
                     nodeTypes.append(
                         tuple(instruction[0] for instruction in contour.value)
                     )
                     stats = StatisticsPen(glyphset=glyphset)
                     try:
                         contour.replay(stats)
                     except OpenContourError as e:
                         add_problem(
                             glyph_name,
                             {"master": name, "contour": ix, "type": "open_path"},
                         )
                         continue
                     size = abs(stats.area) ** 0.5 * 0.5
                     vector = (
                         int(size),
                         int(stats.meanX),
                         int(stats.meanY),
                         int(stats.stddevX * 2),
                         int(stats.stddevY * 2),
                         int(stats.correlation * size),
                     )
                     contourVectors.append(vector)
                     # print(vector)

             # Check each master against the next one in the list.
             for i, (m0, m1) in enumerate(zip(allNodeTypes[:-1], allNodeTypes[1:])):
                 if len(m0) != len(m1):
                     add_problem(
                         glyph_name,
                         {
                             "type": "path_count",
                             "master_1": names[i],
                             "master_2": names[i + 1],
                             "value_1": len(m0),
                             "value_2": len(m1),
                         },
                     )
                 if m0 == m1:
                     continue
                 for pathIx, (nodes1, nodes2) in enumerate(zip(m0, m1)):
                     if nodes1 == nodes2:
                         continue
                     if len(nodes1) != len(nodes2):
                         add_problem(
                             glyph_name,
                             {
                                 "type": "node_count",
                                 "path": pathIx,
                                 "master_1": names[i],
                                 "master_2": names[i + 1],
                                 "value_1": len(nodes1),
                                 "value_2": len(nodes2),
                             },
                         )
                         continue
                     for nodeIx, (n1, n2) in enumerate(zip(nodes1, nodes2)):
                         if n1 != n2:
                             add_problem(
                                 glyph_name,
                                 {
                                     "type": "node_incompatibility",
                                     "path": pathIx,
                                     "node": nodeIx,
                                     "master_1": names[i],
                                     "master_2": names[i + 1],
                                     "value_1": n1,
                                     "value_2": n2,
                                 },
                             )
                             continue

             for i, (m0, m1) in enumerate(zip(allVectors[:-1], allVectors[1:])):
                 if len(m0) != len(m1):
                     # We already reported this
                     continue
                 if not m0:
                     continue
                 costs = [[_vlen(_vdiff(v0, v1)) for v1 in m1] for v0 in m0]
                 matching, matching_cost = min_cost_perfect_bipartite_matching(costs)
                 if matching != list(range(len(m0))):
                     add_problem(
                         glyph_name,
                         {
                             "type": "contour_order",
                             "master_1": names[i],
                             "master_2": names[i + 1],
                             "value_1": list(range(len(m0))),
                             "value_2": matching,
                         },
                     )
                     break
                 upem = 2048
                 item_cost = round(
                     (matching_cost / len(m0) / len(m0[0])) ** 0.5 / upem * 100
                 )
                 hist.append(item_cost)
                 threshold = 7
                 if item_cost >= threshold:
                     add_problem(
                         glyph_name,
                         {
                             "type": "high_cost",
                             "master_1": names[i],
                             "master_2": names[i + 1],
                             "value_1": item_cost,
                             "value_2": threshold,
                         },
                     )

         except ValueError as e:
             add_problem(
                 glyph_name,
                 {"type": "math_error", "master": name, "error": e},
             )
     return problems


 def main(args=None):
     """Test for interpolatability issues between fonts"""
     import argparse

     parser = argparse.ArgumentParser(
         "fonttools varLib.interpolatable",
         description=main.__doc__,
     )
     parser.add_argument(
         "--json",
         action="store_true",
         help="Output report in JSON format",
     )
     parser.add_argument(
         "inputs", metavar="FILE", type=str, nargs="+", help="Input TTF/UFO files"
     )

     args = parser.parse_args(args)
     glyphs = None
     # glyphs = ['uni08DB', 'uniFD76']
     # glyphs = ['uni08DE', 'uni0034']
     # glyphs = ['uni08DE', 'uni0034', 'uni0751', 'uni0753', 'uni0754', 'uni08A4', 'uni08A4.fina', 'uni08A5.fina']

     from os.path import basename

     names = [basename(filename).rsplit(".", 1)[0] for filename in args.inputs]

     fonts = []
     for filename in args.inputs:
         if filename.endswith(".ufo"):
             from fontTools.ufoLib import UFOReader

             fonts.append(UFOReader(filename))
         else:
             from fontTools.ttLib import TTFont

             fonts.append(TTFont(filename))

     glyphsets = [font.getGlyphSet() for font in fonts]
     problems = test(glyphsets, glyphs=glyphs, names=names)
     if args.json:
         import json

         print(json.dumps(problems))
     else:
         for glyph, glyph_problems in problems.items():
             print(f"Glyph {glyph} was not compatible: ")
             for p in glyph_problems:
                 if p["type"] == "missing":
                     print("    Glyph was missing in master %s" % p["master"])
                 if p["type"] == "open_path":
                     print("    Glyph has an open path in master %s" % p["master"])
                 if p["type"] == "path_count":
                     print(
                         "    Path count differs: %i in %s, %i in %s"
                         % (p["value_1"], p["master_1"], p["value_2"], p["master_2"])
                     )
                 if p["type"] == "node_count":
                     print(
                         "    Node count differs in path %i: %i in %s, %i in %s"
                         % (
                             p["path"],
                             p["value_1"],
                             p["master_1"],
                             p["value_2"],
                             p["master_2"],
                         )
                     )
                 if p["type"] == "node_incompatibility":
                     print(
                         "    Node %o incompatible in path %i: %s in %s, %s in %s"
                         % (
                             p["node"],
                             p["path"],
                             p["value_1"],
                             p["master_1"],
                             p["value_2"],
                             p["master_2"],
                         )
                     )
                 if p["type"] == "contour_order":
                     print(
                         "    Contour order differs: %s in %s, %s in %s"
                         % (
                             p["value_1"],
                             p["master_1"],
                             p["value_2"],
                             p["master_2"],
                         )
                     )
                 if p["type"] == "high_cost":
                     print(
                         "    Interpolation has high cost: cost of %s to %s = %i, threshold %i"
                         % (
                             p["master_1"],
                             p["master_2"],
                             p["value_1"],
                             p["value_2"],
                         )
                     )
     if problems:
         return problems


 if __name__ == "__main__":
     import sys

     problems = main()
     sys.exit(int(bool(problems)))
	"""
	Tool to find wrong contour order between different masters, and
	other interpolatability (or lack thereof) issues.

	Call as:
	$ fonttools varLib.interpolatable font1 font2 ...
	"""

	from fontTools.pens.basePen import AbstractPen, BasePen
	from fontTools.pens.recordingPen import RecordingPen
	from fontTools.pens.statisticsPen import StatisticsPen
	from fontTools.pens.momentsPen import OpenContourError
	from collections import OrderedDict
	import itertools
	import sys


	class PerContourPen(BasePen):
	def __init__(self, Pen, glyphset=None):
	BasePen.__init__(self, glyphset)
	self._glyphset = glyphset
	self._Pen = Pen
	self._pen = None
	self.value = []

	def _moveTo(self, p0):
	self._newItem()
	self._pen.moveTo(p0)

	def _lineTo(self, p1):
	self._pen.lineTo(p1)

	def _qCurveToOne(self, p1, p2):
	self._pen.qCurveTo(p1, p2)

	def _curveToOne(self, p1, p2, p3):
	self._pen.curveTo(p1, p2, p3)

	def _closePath(self):
	self._pen.closePath()
	self._pen = None

	def _endPath(self):
	self._pen.endPath()
	self._pen = None

	def _newItem(self):
	self._pen = pen = self._Pen()
	self.value.append(pen)


	class PerContourOrComponentPen(PerContourPen):
	def addComponent(self, glyphName, transformation):
	self._newItem()
	self.value[-1].addComponent(glyphName, transformation)


	def _vdiff(v0, v1):
	return tuple(b - a for a, b in zip(v0, v1))


	def _vlen(vec):
	v = 0
	for x in vec:
	v += x * x
	return v


	def _matching_cost(G, matching):
	return sum(G[i][j] for i, j in enumerate(matching))


	def min_cost_perfect_bipartite_matching(G):
	n = len(G)
	try:
	from scipy.optimize import linear_sum_assignment

	rows, cols = linear_sum_assignment(G)
	assert (rows == list(range(n))).all()
	return list(cols), _matching_cost(G, cols)
	except ImportError:
	pass

	try:
	from munkres import Munkres

	cols = [None] * n
	for row, col in Munkres().compute(G):
	cols[row] = col
	return cols, _matching_cost(G, cols)
	except ImportError:
	pass

	if n > 6:
	raise Exception("Install Python module 'munkres' or 'scipy >= 0.17.0'")

	# Otherwise just brute-force
	permutations = itertools.permutations(range(n))
	best = list(next(permutations))
	best_cost = _matching_cost(G, best)
	for p in permutations:
	cost = _matching_cost(G, p)
	if cost < best_cost:
	best, best_cost = list(p), cost
	return best, best_cost


	def test(glyphsets, glyphs=None, names=None):

	if names is None:
	names = glyphsets
	if glyphs is None:
	glyphs = glyphsets[0].keys()

	hist = []
	problems = OrderedDict()

	def add_problem(glyphname, problem):
	problems.setdefault(glyphname, []).append(problem)

	for glyph_name in glyphs:
	# print()
	# print(glyph_name)

	try:
	allVectors = []
	allNodeTypes = []
	for glyphset, name in zip(glyphsets, names):
	# print('.', end='')
	if glyph_name not in glyphset:
	add_problem(glyph_name, {"type": "missing", "master": name})
	continue
	glyph = glyphset[glyph_name]

	perContourPen = PerContourOrComponentPen(
	RecordingPen, glyphset=glyphset
	)
	glyph.draw(perContourPen)
	contourPens = perContourPen.value
	del perContourPen

	contourVectors = []
	nodeTypes = []
	allNodeTypes.append(nodeTypes)
	allVectors.append(contourVectors)
	for ix, contour in enumerate(contourPens):
	nodeTypes.append(
	tuple(instruction[0] for instruction in contour.value)
	)
	stats = StatisticsPen(glyphset=glyphset)
	try:
	contour.replay(stats)
	except OpenContourError as e:
	add_problem(
	glyph_name,
	{"master": name, "contour": ix, "type": "open_path"},
	)
	continue
	size = abs(stats.area) ** 0.5 * 0.5
	vector = (
	int(size),
	int(stats.meanX),
	int(stats.meanY),
	int(stats.stddevX * 2),
	int(stats.stddevY * 2),
	int(stats.correlation * size),
	)
	contourVectors.append(vector)
	# print(vector)

	# Check each master against the next one in the list.
	for i, (m0, m1) in enumerate(zip(allNodeTypes[:-1], allNodeTypes[1:])):
	if len(m0) != len(m1):
	add_problem(
	glyph_name,
	{
	"type": "path_count",
	"master_1": names[i],
	"master_2": names[i + 1],
	"value_1": len(m0),
	"value_2": len(m1),
	},
	)
	if m0 == m1:
	continue
	for pathIx, (nodes1, nodes2) in enumerate(zip(m0, m1)):
	if nodes1 == nodes2:
	continue
	if len(nodes1) != len(nodes2):
	add_problem(
	glyph_name,
	{
	"type": "node_count",
	"path": pathIx,
	"master_1": names[i],
	"master_2": names[i + 1],
	"value_1": len(nodes1),
	"value_2": len(nodes2),
	},
	)
	continue
	for nodeIx, (n1, n2) in enumerate(zip(nodes1, nodes2)):
	if n1 != n2:
	add_problem(
	glyph_name,
	{
	"type": "node_incompatibility",
	"path": pathIx,
	"node": nodeIx,
	"master_1": names[i],
	"master_2": names[i + 1],
	"value_1": n1,
	"value_2": n2,
	},
	)
	continue

	for i, (m0, m1) in enumerate(zip(allVectors[:-1], allVectors[1:])):
	if len(m0) != len(m1):
	# We already reported this
	continue
	if not m0:
	continue
	costs = [[_vlen(_vdiff(v0, v1)) for v1 in m1] for v0 in m0]
	matching, matching_cost = min_cost_perfect_bipartite_matching(costs)
	if matching != list(range(len(m0))):
	add_problem(
	glyph_name,
	{
	"type": "contour_order",
	"master_1": names[i],
	"master_2": names[i + 1],
	"value_1": list(range(len(m0))),
	"value_2": matching,
	},
	)
	break
	upem = 2048
	item_cost = round(
	(matching_cost / len(m0) / len(m0[0])) ** 0.5 / upem * 100
	)
	hist.append(item_cost)
	threshold = 7
	if item_cost >= threshold:
	add_problem(
	glyph_name,
	{
	"type": "high_cost",
	"master_1": names[i],
	"master_2": names[i + 1],
	"value_1": item_cost,
	"value_2": threshold,
	},
	)

	except ValueError as e:
	add_problem(
	glyph_name,
	{"type": "math_error", "master": name, "error": e},
	)
	return problems


	def main(args=None):
	"""Test for interpolatability issues between fonts"""
	import argparse

	parser = argparse.ArgumentParser(
	"fonttools varLib.interpolatable",
	description=main.__doc__,
	)
	parser.add_argument(
	"--json",
	action="store_true",
	help="Output report in JSON format",
	)
	parser.add_argument(
	"inputs", metavar="FILE", type=str, nargs="+", help="Input TTF/UFO files"
	)

	args = parser.parse_args(args)
	glyphs = None
	# glyphs = ['uni08DB', 'uniFD76']
	# glyphs = ['uni08DE', 'uni0034']
	# glyphs = ['uni08DE', 'uni0034', 'uni0751', 'uni0753', 'uni0754', 'uni08A4', 'uni08A4.fina', 'uni08A5.fina']

	from os.path import basename

	names = [basename(filename).rsplit(".", 1)[0] for filename in args.inputs]

	fonts = []
	for filename in args.inputs:
	if filename.endswith(".ufo"):
	from fontTools.ufoLib import UFOReader

	fonts.append(UFOReader(filename))
	else:
	from fontTools.ttLib import TTFont

	fonts.append(TTFont(filename))

	glyphsets = [font.getGlyphSet() for font in fonts]
	problems = test(glyphsets, glyphs=glyphs, names=names)
	if args.json:
	import json

	print(json.dumps(problems))
	else:
	for glyph, glyph_problems in problems.items():
	print(f"Glyph {glyph} was not compatible: ")
	for p in glyph_problems:
	if p["type"] == "missing":
	print(" Glyph was missing in master %s" % p["master"])
	if p["type"] == "open_path":
	print(" Glyph has an open path in master %s" % p["master"])
	if p["type"] == "path_count":
	print(
	" Path count differs: %i in %s, %i in %s"
	% (p["value_1"], p["master_1"], p["value_2"], p["master_2"])
	)
	if p["type"] == "node_count":
	print(
	" Node count differs in path %i: %i in %s, %i in %s"
	% (
	p["path"],
	p["value_1"],
	p["master_1"],
	p["value_2"],
	p["master_2"],
	)
	)
	if p["type"] == "node_incompatibility":
	print(
	" Node %o incompatible in path %i: %s in %s, %s in %s"
	% (
	p["node"],
	p["path"],
	p["value_1"],
	p["master_1"],
	p["value_2"],
	p["master_2"],
	)
	)
	if p["type"] == "contour_order":
	print(
	" Contour order differs: %s in %s, %s in %s"
	% (
	p["value_1"],
	p["master_1"],
	p["value_2"],
	p["master_2"],
	)
	)
	if p["type"] == "high_cost":
	print(
	" Interpolation has high cost: cost of %s to %s = %i, threshold %i"
	% (
	p["master_1"],
	p["master_2"],
	p["value_1"],
	p["value_2"],
	)
	)
	if problems:
	return problems


	if __name__ == "__main__":
	import sys

	problems = main()
	sys.exit(int(bool(problems)))