From 1d28abdb654a9a4e1e46453c7b23bec7a6c0033f Mon Sep 17 00:00:00 2001 From: Sascha Brawer Date: Wed, 4 Jan 2017 12:41:55 +0100 Subject: [PATCH] [gvar] Rename GlyphVariation to TupleVariation In the OpenType 1.8 specification, this is called TupleVariation so let's be consistent with the spec. (The initial implementation in fonttools pre-dates OpenType 1.8). --- Lib/fontTools/ttLib/tables/_g_v_a_r.py | 38 +++---- Lib/fontTools/ttLib/tables/_g_v_a_r_test.py | 106 ++++++++++---------- Lib/fontTools/varLib/__init__.py | 4 +- Snippets/interpolate.py | 6 +- 4 files changed, 77 insertions(+), 77 deletions(-) diff --git a/Lib/fontTools/ttLib/tables/_g_v_a_r.py b/Lib/fontTools/ttLib/tables/_g_v_a_r.py index 8515f2cd8..c98882ee6 100644 --- a/Lib/fontTools/ttLib/tables/_g_v_a_r.py +++ b/Lib/fontTools/ttLib/tables/_g_v_a_r.py @@ -192,7 +192,7 @@ class table__g_v_a_r(DefaultTable.DefaultTable): self.decompileGlyph_(numPointsInGlyph, sharedCoords, axisTags, gvarData) def decompileSharedCoords_(self, axisTags, data): - result, _pos = GlyphVariation.decompileCoords_(axisTags, self.sharedCoordCount, data, self.offsetToCoord) + result, _pos = TupleVariation.decompileCoords_(axisTags, self.sharedCoordCount, data, self.offsetToCoord) return result @staticmethod @@ -250,12 +250,12 @@ class table__g_v_a_r(DefaultTable.DefaultTable): pos = 4 dataPos = offsetToData if (flags & TUPLES_SHARE_POINT_NUMBERS) != 0: - sharedPoints, dataPos = GlyphVariation.decompilePoints_(numPointsInGlyph, data, dataPos) + sharedPoints, dataPos = TupleVariation.decompilePoints_(numPointsInGlyph, data, dataPos) else: sharedPoints = [] for _ in range(flags & TUPLE_COUNT_MASK): dataSize, flags = struct.unpack(">HH", data[pos:pos+4]) - tupleSize = GlyphVariation.getTupleSize_(flags, numAxes) + tupleSize = TupleVariation.getTupleSize_(flags, numAxes) tupleData = data[pos : pos + tupleSize] pointDeltaData = data[dataPos : dataPos + dataSize] tuples.append(self.decompileTuple_(numPointsInGlyph, sharedCoords, sharedPoints, axisTags, tupleData, pointDeltaData)) @@ -271,10 +271,10 @@ class table__g_v_a_r(DefaultTable.DefaultTable): if (flags & EMBEDDED_PEAK_TUPLE) == 0: coord = sharedCoords[flags & TUPLE_INDEX_MASK] else: - coord, pos = GlyphVariation.decompileCoord_(axisTags, data, pos) + coord, pos = TupleVariation.decompileCoord_(axisTags, data, pos) if (flags & INTERMEDIATE_REGION) != 0: - minCoord, pos = GlyphVariation.decompileCoord_(axisTags, data, pos) - maxCoord, pos = GlyphVariation.decompileCoord_(axisTags, data, pos) + minCoord, pos = TupleVariation.decompileCoord_(axisTags, data, pos) + maxCoord, pos = TupleVariation.decompileCoord_(axisTags, data, pos) else: minCoord, maxCoord = table__g_v_a_r.computeMinMaxCoord_(coord) axes = {} @@ -284,16 +284,16 @@ class table__g_v_a_r(DefaultTable.DefaultTable): axes[axis] = coords pos = 0 if (flags & PRIVATE_POINT_NUMBERS) != 0: - points, pos = GlyphVariation.decompilePoints_(numPointsInGlyph, tupleData, pos) + points, pos = TupleVariation.decompilePoints_(numPointsInGlyph, tupleData, pos) else: points = sharedPoints - deltas_x, pos = GlyphVariation.decompileDeltas_(len(points), tupleData, pos) - deltas_y, pos = GlyphVariation.decompileDeltas_(len(points), tupleData, pos) + deltas_x, pos = TupleVariation.decompileDeltas_(len(points), tupleData, pos) + deltas_y, pos = TupleVariation.decompileDeltas_(len(points), tupleData, pos) deltas = [None] * numPointsInGlyph for p, x, y in zip(points, deltas_x, deltas_y): if 0 <= p < numPointsInGlyph: deltas[p] = (x, y) - return GlyphVariation(axes, deltas) + return TupleVariation(axes, deltas) @staticmethod def computeMinMaxCoord_(coord): @@ -337,7 +337,7 @@ class table__g_v_a_r(DefaultTable.DefaultTable): if isinstance(element, tuple): name, attrs, content = element if name == "tuple": - gvar = GlyphVariation({}, [None] * numPointsInGlyph) + gvar = TupleVariation({}, [None] * numPointsInGlyph) glyphVariations.append(gvar) for tupleElement in content: if isinstance(tupleElement, tuple): @@ -355,14 +355,14 @@ class table__g_v_a_r(DefaultTable.DefaultTable): return len(getattr(glyph, "coordinates", [])) + NUM_PHANTOM_POINTS -class GlyphVariation(object): +class TupleVariation(object): def __init__(self, axes, coordinates): self.axes = axes self.coordinates = coordinates def __repr__(self): axes = ",".join(sorted(["%s=%s" % (name, value) for (name, value) in self.axes.items()])) - return "" % (axes, self.coordinates) + return "" % (axes, self.coordinates) def __eq__(self, other): return self.coordinates == other.coordinates and self.axes == other.axes @@ -375,9 +375,9 @@ class GlyphVariation(object): return result def hasImpact(self): - """Returns True if this GlyphVariation has any visible impact. + """Returns True if this TupleVariation has any visible impact. - If the result is False, the GlyphVariation can be omitted from the font + If the result is False, the TupleVariation can be omitted from the font without making any visible difference. """ for c in self.coordinates: @@ -494,7 +494,7 @@ class GlyphVariation(object): result = [] pos = offset for _ in range(numCoords): - coord, pos = GlyphVariation.decompileCoord_(axisTags, data, pos) + coord, pos = TupleVariation.decompileCoord_(axisTags, data, pos) result.append(coord) return result, pos @@ -634,11 +634,11 @@ class GlyphVariation(object): while pos < len(deltas): value = deltas[pos] if value == 0: - pos = GlyphVariation.encodeDeltaRunAsZeroes_(deltas, pos, stream) + pos = TupleVariation.encodeDeltaRunAsZeroes_(deltas, pos, stream) elif value >= -128 and value <= 127: - pos = GlyphVariation.encodeDeltaRunAsBytes_(deltas, pos, stream) + pos = TupleVariation.encodeDeltaRunAsBytes_(deltas, pos, stream) else: - pos = GlyphVariation.encodeDeltaRunAsWords_(deltas, pos, stream) + pos = TupleVariation.encodeDeltaRunAsWords_(deltas, pos, stream) return stream.getvalue() @staticmethod diff --git a/Lib/fontTools/ttLib/tables/_g_v_a_r_test.py b/Lib/fontTools/ttLib/tables/_g_v_a_r_test.py index 546f3c7ce..6cafeeccc 100644 --- a/Lib/fontTools/ttLib/tables/_g_v_a_r_test.py +++ b/Lib/fontTools/ttLib/tables/_g_v_a_r_test.py @@ -4,7 +4,7 @@ from fontTools.misc.testTools import parseXML from fontTools.misc.textTools import deHexStr, hexStr from fontTools.misc.xmlWriter import XMLWriter from fontTools.ttLib import TTLibError -from fontTools.ttLib.tables._g_v_a_r import table__g_v_a_r, GlyphVariation +from fontTools.ttLib.tables._g_v_a_r import table__g_v_a_r, TupleVariation import random import unittest @@ -40,7 +40,7 @@ SKIA_SHARED_COORDS = deHexStr( "C0 00 C0 00 40 00 C0 00 40 00 40 00 C0 00 40 00") -class GlyphVariationTableTest(unittest.TestCase): +class GVARTableTest(unittest.TestCase): def test_compileOffsets_shortFormat(self): self.assertEqual((deHexStr("00 00 00 02 FF C0"), 0), table__g_v_a_r.compileOffsets_([0, 4, 0x1ff80])) @@ -75,9 +75,9 @@ class GlyphVariationTableTest(unittest.TestCase): table = table__g_v_a_r() axes = {"wght": (0.3, 0.4, 0.5), "opsz": (0.7, 0.8, 0.9)} table.variations = {"glyphname": [ - GlyphVariation(axes, [None] * 4), - GlyphVariation(axes, [None] * 4), - GlyphVariation(axes, [None] * 4) + TupleVariation(axes, [None] * 4), + TupleVariation(axes, [None] * 4), + TupleVariation(axes, [None] * 4) ]} self.assertEqual(b"", table.compileGlyph_("glyphname", 8, ["wght", "opsz"], {})) @@ -86,8 +86,8 @@ class GlyphVariationTableTest(unittest.TestCase): axisTags = ["wght", "wdth"] numPointsInGlyph = 4 glyphCoords = [(1,1), (2,2), (3,3), (4,4)] - gvar1 = GlyphVariation({"wght": (0.5, 1.0, 1.0), "wdth": (1.0, 1.0, 1.0)}, glyphCoords) - gvar2 = GlyphVariation({"wght": (1.0, 1.0, 1.0), "wdth": (1.0, 1.0, 1.0)}, glyphCoords) + gvar1 = TupleVariation({"wght": (0.5, 1.0, 1.0), "wdth": (1.0, 1.0, 1.0)}, glyphCoords) + gvar2 = TupleVariation({"wght": (1.0, 1.0, 1.0), "wdth": (1.0, 1.0, 1.0)}, glyphCoords) table.variations = {"oslash": [gvar1, gvar2]} data = table.compileGlyph_("oslash", numPointsInGlyph, axisTags, {}) self.assertEqual([gvar1, gvar2], table.decompileGlyph_(numPointsInGlyph, {}, axisTags, data)) @@ -97,16 +97,16 @@ class GlyphVariationTableTest(unittest.TestCase): table.variations = {} deltas = [None] * 4 table.variations["A"] = [ - GlyphVariation({"wght": (1.0, 1.0, 1.0), "wdth": (0.5, 0.7, 1.0)}, deltas) + TupleVariation({"wght": (1.0, 1.0, 1.0), "wdth": (0.5, 0.7, 1.0)}, deltas) ] table.variations["B"] = [ - GlyphVariation({"wght": (1.0, 1.0, 1.0), "wdth": (0.2, 0.7, 1.0)}, deltas), - GlyphVariation({"wght": (1.0, 1.0, 1.0), "wdth": (0.2, 0.8, 1.0)}, deltas) + TupleVariation({"wght": (1.0, 1.0, 1.0), "wdth": (0.2, 0.7, 1.0)}, deltas), + TupleVariation({"wght": (1.0, 1.0, 1.0), "wdth": (0.2, 0.8, 1.0)}, deltas) ] table.variations["C"] = [ - GlyphVariation({"wght": (1.0, 1.0, 1.0), "wdth": (0.3, 0.7, 1.0)}, deltas), - GlyphVariation({"wght": (1.0, 1.0, 1.0), "wdth": (0.3, 0.8, 1.0)}, deltas), - GlyphVariation({"wght": (1.0, 1.0, 1.0), "wdth": (0.3, 0.9, 1.0)}, deltas) + TupleVariation({"wght": (1.0, 1.0, 1.0), "wdth": (0.3, 0.7, 1.0)}, deltas), + TupleVariation({"wght": (1.0, 1.0, 1.0), "wdth": (0.3, 0.8, 1.0)}, deltas), + TupleVariation({"wght": (1.0, 1.0, 1.0), "wdth": (0.3, 0.9, 1.0)}, deltas) ] # {"wght":1.0, "wdth":0.7} is shared 3 times; {"wght":1.0, "wdth":0.8} is shared twice. # Min and max values are not part of the shared coordinate pool and should get ignored. @@ -159,41 +159,41 @@ class GlyphVariationTableTest(unittest.TestCase): self.assertEqual({"wght": -0.3, "wdth": 0.0}, minCoord) self.assertEqual({"wght": 0.0, "wdth": 0.7}, maxCoord) -class GlyphVariationTest(unittest.TestCase): +class TupleVariationTest(unittest.TestCase): def test_equal(self): - gvar1 = GlyphVariation({"wght":(0.0, 1.0, 1.0)}, [(0,0), (9,8), (7,6)]) - gvar2 = GlyphVariation({"wght":(0.0, 1.0, 1.0)}, [(0,0), (9,8), (7,6)]) + gvar1 = TupleVariation({"wght":(0.0, 1.0, 1.0)}, [(0,0), (9,8), (7,6)]) + gvar2 = TupleVariation({"wght":(0.0, 1.0, 1.0)}, [(0,0), (9,8), (7,6)]) self.assertEqual(gvar1, gvar2) def test_equal_differentAxes(self): - gvar1 = GlyphVariation({"wght":(0.0, 1.0, 1.0)}, [(0,0), (9,8), (7,6)]) - gvar2 = GlyphVariation({"wght":(0.7, 0.8, 0.9)}, [(0,0), (9,8), (7,6)]) + gvar1 = TupleVariation({"wght":(0.0, 1.0, 1.0)}, [(0,0), (9,8), (7,6)]) + gvar2 = TupleVariation({"wght":(0.7, 0.8, 0.9)}, [(0,0), (9,8), (7,6)]) self.assertNotEqual(gvar1, gvar2) def test_equal_differentCoordinates(self): - gvar1 = GlyphVariation({"wght":(0.0, 1.0, 1.0)}, [(0,0), (9,8), (7,6)]) - gvar2 = GlyphVariation({"wght":(0.0, 1.0, 1.0)}, [(0,0), (9,8)]) + gvar1 = TupleVariation({"wght":(0.0, 1.0, 1.0)}, [(0,0), (9,8), (7,6)]) + gvar2 = TupleVariation({"wght":(0.0, 1.0, 1.0)}, [(0,0), (9,8)]) self.assertNotEqual(gvar1, gvar2) def test_hasImpact_someDeltasNotZero(self): axes = {"wght":(0.0, 1.0, 1.0)} - gvar = GlyphVariation(axes, [(0,0), (9,8), (7,6)]) + gvar = TupleVariation(axes, [(0,0), (9,8), (7,6)]) self.assertTrue(gvar.hasImpact()) def test_hasImpact_allDeltasZero(self): axes = {"wght":(0.0, 1.0, 1.0)} - gvar = GlyphVariation(axes, [(0,0), (0,0), (0,0)]) + gvar = TupleVariation(axes, [(0,0), (0,0), (0,0)]) self.assertTrue(gvar.hasImpact()) def test_hasImpact_allDeltasNone(self): axes = {"wght":(0.0, 1.0, 1.0)} - gvar = GlyphVariation(axes, [None, None, None]) + gvar = TupleVariation(axes, [None, None, None]) self.assertFalse(gvar.hasImpact()) def test_toXML(self): writer = XMLWriter(BytesIO()) axes = {"wdth":(0.3, 0.4, 0.5), "wght":(0.0, 1.0, 1.0), "opsz":(-0.7, -0.7, 0.0)} - g = GlyphVariation(axes, [(9,8), None, (7,6), (0,0), (-1,-2), None]) + g = TupleVariation(axes, [(9,8), None, (7,6), (0,0), (-1,-2), None]) g.toXML(writer, ["wdth", "wght", "opsz"]) self.assertEqual([ '', @@ -205,22 +205,22 @@ class GlyphVariationTest(unittest.TestCase): '', '', '' - ], GlyphVariationTest.xml_lines(writer)) + ], TupleVariationTest.xml_lines(writer)) def test_toXML_allDeltasNone(self): writer = XMLWriter(BytesIO()) axes = {"wght":(0.0, 1.0, 1.0)} - g = GlyphVariation(axes, [None] * 5) + g = TupleVariation(axes, [None] * 5) g.toXML(writer, ["wght", "wdth"]) self.assertEqual([ '', '', '', '' - ], GlyphVariationTest.xml_lines(writer)) + ], TupleVariationTest.xml_lines(writer)) def test_fromXML(self): - g = GlyphVariation({}, [None] * 4) + g = TupleVariation({}, [None] * 4) for name, attrs, content in parseXML( '' '' @@ -236,7 +236,7 @@ class GlyphVariationTest(unittest.TestCase): self.assertEqual([None, (33, 44), (-2, 170), None], g.coordinates) def test_compile_sharedCoords_nonIntermediate_sharedPoints(self): - gvar = GlyphVariation({"wght": (0.0, 0.5, 0.5), "wdth": (0.0, 0.8, 0.8)}, + gvar = TupleVariation({"wght": (0.0, 0.5, 0.5), "wdth": (0.0, 0.8, 0.8)}, [(7,4), (8,5), (9,6)]) axisTags = ["wght", "wdth"] sharedCoordIndices = { gvar.compileCoord(axisTags): 0x77 } @@ -249,7 +249,7 @@ class GlyphVariationTest(unittest.TestCase): hexencode(data)) def test_compile_sharedCoords_intermediate_sharedPoints(self): - gvar = GlyphVariation({"wght": (0.3, 0.5, 0.7), "wdth": (0.1, 0.8, 0.9)}, + gvar = TupleVariation({"wght": (0.3, 0.5, 0.7), "wdth": (0.1, 0.8, 0.9)}, [(7,4), (8,5), (9,6)]) axisTags = ["wght", "wdth"] sharedCoordIndices = { gvar.compileCoord(axisTags): 0x77 } @@ -262,7 +262,7 @@ class GlyphVariationTest(unittest.TestCase): hexencode(data)) def test_compile_sharedCoords_nonIntermediate_privatePoints(self): - gvar = GlyphVariation({"wght": (0.0, 0.5, 0.5), "wdth": (0.0, 0.8, 0.8)}, + gvar = TupleVariation({"wght": (0.0, 0.5, 0.5), "wdth": (0.0, 0.8, 0.8)}, [(7,4), (8,5), (9,6)]) axisTags = ["wght", "wdth"] sharedCoordIndices = { gvar.compileCoord(axisTags): 0x77 } @@ -276,7 +276,7 @@ class GlyphVariationTest(unittest.TestCase): hexencode(data)) def test_compile_sharedCoords_intermediate_privatePoints(self): - gvar = GlyphVariation({"wght": (0.0, 0.5, 1.0), "wdth": (0.0, 0.8, 1.0)}, + gvar = TupleVariation({"wght": (0.0, 0.5, 1.0), "wdth": (0.0, 0.8, 1.0)}, [(7,4), (8,5), (9,6)]) axisTags = ["wght", "wdth"] sharedCoordIndices = { gvar.compileCoord(axisTags): 0x77 } @@ -290,7 +290,7 @@ class GlyphVariationTest(unittest.TestCase): hexencode(data)) def test_compile_embeddedCoords_nonIntermediate_sharedPoints(self): - gvar = GlyphVariation({"wght": (0.0, 0.5, 0.5), "wdth": (0.0, 0.8, 0.8)}, + gvar = TupleVariation({"wght": (0.0, 0.5, 0.5), "wdth": (0.0, 0.8, 0.8)}, [(7,4), (8,5), (9,6)]) axisTags = ["wght", "wdth"] tuple, data = gvar.compile(axisTags, sharedCoordIndices={}, sharedPoints={0,1,2}) @@ -302,7 +302,7 @@ class GlyphVariationTest(unittest.TestCase): hexencode(data)) def test_compile_embeddedCoords_intermediate_sharedPoints(self): - gvar = GlyphVariation({"wght": (0.0, 0.5, 1.0), "wdth": (0.0, 0.8, 0.8)}, + gvar = TupleVariation({"wght": (0.0, 0.5, 1.0), "wdth": (0.0, 0.8, 0.8)}, [(7,4), (8,5), (9,6)]) axisTags = ["wght", "wdth"] tuple, data = gvar.compile(axisTags, sharedCoordIndices={}, sharedPoints={0,1,2}) @@ -314,7 +314,7 @@ class GlyphVariationTest(unittest.TestCase): hexencode(data)) def test_compile_embeddedCoords_nonIntermediate_privatePoints(self): - gvar = GlyphVariation({"wght": (0.0, 0.5, 0.5), "wdth": (0.0, 0.8, 0.8)}, + gvar = TupleVariation({"wght": (0.0, 0.5, 0.5), "wdth": (0.0, 0.8, 0.8)}, [(7,4), (8,5), (9,6)]) axisTags = ["wght", "wdth"] tuple, data = gvar.compile(axisTags, sharedCoordIndices={}, sharedPoints=None) @@ -327,7 +327,7 @@ class GlyphVariationTest(unittest.TestCase): hexencode(data)) def test_compile_embeddedCoords_intermediate_privatePoints(self): - gvar = GlyphVariation({"wght": (0.4, 0.5, 0.6), "wdth": (0.7, 0.8, 0.9)}, + gvar = TupleVariation({"wght": (0.4, 0.5, 0.6), "wdth": (0.7, 0.8, 0.9)}, [(7,4), (8,5), (9,6)]) axisTags = ["wght", "wdth"] tuple, data = gvar.compile(axisTags, sharedCoordIndices={}, sharedPoints=None) @@ -340,33 +340,33 @@ class GlyphVariationTest(unittest.TestCase): hexencode(data)) def test_compileCoord(self): - gvar = GlyphVariation({"wght": (-1.0, -1.0, -1.0), "wdth": (0.4, 0.5, 0.6)}, [None] * 4) + gvar = TupleVariation({"wght": (-1.0, -1.0, -1.0), "wdth": (0.4, 0.5, 0.6)}, [None] * 4) self.assertEqual("C0 00 20 00", hexencode(gvar.compileCoord(["wght", "wdth"]))) self.assertEqual("20 00 C0 00", hexencode(gvar.compileCoord(["wdth", "wght"]))) self.assertEqual("C0 00", hexencode(gvar.compileCoord(["wght"]))) def test_compileIntermediateCoord(self): - gvar = GlyphVariation({"wght": (-1.0, -1.0, 0.0), "wdth": (0.4, 0.5, 0.6)}, [None] * 4) + gvar = TupleVariation({"wght": (-1.0, -1.0, 0.0), "wdth": (0.4, 0.5, 0.6)}, [None] * 4) self.assertEqual("C0 00 19 9A 00 00 26 66", hexencode(gvar.compileIntermediateCoord(["wght", "wdth"]))) self.assertEqual("19 9A C0 00 26 66 00 00", hexencode(gvar.compileIntermediateCoord(["wdth", "wght"]))) self.assertEqual(None, gvar.compileIntermediateCoord(["wght"])) self.assertEqual("19 9A 26 66", hexencode(gvar.compileIntermediateCoord(["wdth"]))) def test_decompileCoord(self): - decompileCoord = GlyphVariation.decompileCoord_ + decompileCoord = TupleVariation.decompileCoord_ data = deHexStr("DE AD C0 00 20 00 DE AD") self.assertEqual(({"wght": -1.0, "wdth": 0.5}, 6), decompileCoord(["wght", "wdth"], data, 2)) def test_decompileCoord_roundTrip(self): # Make sure we are not affected by https://github.com/behdad/fonttools/issues/286 data = deHexStr("7F B9 80 35") - values, _ = GlyphVariation.decompileCoord_(["wght", "wdth"], data, 0) + values, _ = TupleVariation.decompileCoord_(["wght", "wdth"], data, 0) axisValues = {axis:(val, val, val) for axis, val in values.items()} - gvar = GlyphVariation(axisValues, [None] * 4) + gvar = TupleVariation(axisValues, [None] * 4) self.assertEqual("7F B9 80 35", hexencode(gvar.compileCoord(["wght", "wdth"]))) def test_decompileCoords(self): - decompileCoords = GlyphVariation.decompileCoords_ + decompileCoords = TupleVariation.decompileCoords_ axes = ["wght", "wdth", "opsz"] coords = [ {"wght": 1.0, "wdth": 0.0, "opsz": 0.5}, @@ -377,7 +377,7 @@ class GlyphVariationTest(unittest.TestCase): self.assertEqual((coords, 20), decompileCoords(axes, numCoords=3, data=data, offset=2)) def test_compilePoints(self): - compilePoints = lambda p: GlyphVariation.compilePoints(set(p), numPointsInGlyph=999) + compilePoints = lambda p: TupleVariation.compilePoints(set(p), numPointsInGlyph=999) self.assertEqual("00", hexencode(compilePoints(range(999)))) # all points in glyph self.assertEqual("01 00 07", hexencode(compilePoints([7]))) self.assertEqual("01 80 FF FF", hexencode(compilePoints([65535]))) @@ -402,7 +402,7 @@ class GlyphVariationTest(unittest.TestCase): numPointsInGlyph = 65536 allPoints = list(range(numPointsInGlyph)) def decompilePoints(data, offset): - points, offset = GlyphVariation.decompilePoints_(numPointsInGlyph, deHexStr(data), offset) + points, offset = TupleVariation.decompilePoints_(numPointsInGlyph, deHexStr(data), offset) # Conversion to list needed for Python 3. return (list(points), offset) # all points in glyph @@ -439,15 +439,15 @@ class GlyphVariationTest(unittest.TestCase): 0)[0])) def test_decompilePoints_shouldAcceptBadPointNumbers(self): - decompilePoints = GlyphVariation.decompilePoints_ + decompilePoints = TupleVariation.decompilePoints_ # 2 points; first run: [3, 9]. numPointsInGlyph = 8 decompilePoints(numPointsInGlyph, deHexStr("02 01 03 06"), 0) def test_decompilePoints_roundTrip(self): numPointsInGlyph = 500 # greater than 255, so we also exercise code path for 16-bit encoding - compile = lambda points: GlyphVariation.compilePoints(points, numPointsInGlyph) - decompile = lambda data: set(GlyphVariation.decompilePoints_(numPointsInGlyph, data, 0)[0]) + compile = lambda points: TupleVariation.compilePoints(points, numPointsInGlyph) + decompile = lambda data: set(TupleVariation.decompilePoints_(numPointsInGlyph, data, 0)[0]) for i in range(50): points = set(random.sample(range(numPointsInGlyph), 30)) self.assertSetEqual(points, decompile(compile(points)), @@ -456,13 +456,13 @@ class GlyphVariationTest(unittest.TestCase): self.assertSetEqual(allPoints, decompile(compile(allPoints))) def test_compileDeltas(self): - gvar = GlyphVariation({}, [(0,0), (1, 0), (2, 0), (3, 3)]) + gvar = TupleVariation({}, [(0,0), (1, 0), (2, 0), (3, 3)]) points = {1, 2} # deltaX for points: [1, 2]; deltaY for points: [0, 0] self.assertEqual("01 01 02 81", hexencode(gvar.compileDeltas(points))) def test_compileDeltaValues(self): - compileDeltaValues = lambda values: hexencode(GlyphVariation.compileDeltaValues_(values)) + compileDeltaValues = lambda values: hexencode(TupleVariation.compileDeltaValues_(values)) # zeroes self.assertEqual("80", compileDeltaValues([0])) self.assertEqual("BF", compileDeltaValues([0] * 64)) @@ -503,7 +503,7 @@ class GlyphVariationTest(unittest.TestCase): self.assertEqual("40 66 66 81", compileDeltaValues([0x6666, 0, 0])) def test_decompileDeltas(self): - decompileDeltas = GlyphVariation.decompileDeltas_ + decompileDeltas = TupleVariation.decompileDeltas_ # 83 = zero values (0x80), count = 4 (1 + 0x83 & 0x3F) self.assertEqual(([0, 0, 0, 0], 1), decompileDeltas(4, deHexStr("83"), 0)) # 41 01 02 FF FF = signed 16-bit values (0x40), count = 2 (1 + 0x41 & 0x3F) @@ -516,8 +516,8 @@ class GlyphVariationTest(unittest.TestCase): def test_decompileDeltas_roundTrip(self): numDeltas = 30 - compile = GlyphVariation.compileDeltaValues_ - decompile = lambda data: GlyphVariation.decompileDeltas_(numDeltas, data, 0)[0] + compile = TupleVariation.compileDeltaValues_ + decompile = lambda data: TupleVariation.decompileDeltas_(numDeltas, data, 0)[0] for i in range(50): deltas = random.sample(range(-128, 127), 10) deltas.extend(random.sample(range(-32768, 32767), 10)) @@ -526,7 +526,7 @@ class GlyphVariationTest(unittest.TestCase): self.assertListEqual(deltas, decompile(compile(deltas))) def test_getTupleSize(self): - getTupleSize = GlyphVariation.getTupleSize_ + getTupleSize = TupleVariation.getTupleSize_ numAxes = 3 self.assertEqual(4 + numAxes * 2, getTupleSize(0x8042, numAxes)) self.assertEqual(4 + numAxes * 4, getTupleSize(0x4077, numAxes)) diff --git a/Lib/fontTools/varLib/__init__.py b/Lib/fontTools/varLib/__init__.py index 52961134a..1fc9e6f2d 100644 --- a/Lib/fontTools/varLib/__init__.py +++ b/Lib/fontTools/varLib/__init__.py @@ -25,7 +25,7 @@ from fontTools.ttLib import TTFont, newTable from fontTools.ttLib.tables._n_a_m_e import NameRecord from fontTools.ttLib.tables._f_v_a_r import Axis, NamedInstance from fontTools.ttLib.tables._g_l_y_f import GlyphCoordinates -from fontTools.ttLib.tables._g_v_a_r import GlyphVariation +from fontTools.ttLib.tables._g_v_a_r import TupleVariation from fontTools.ttLib.tables import otTables as ot from fontTools.ttLib.tables import otBase as otBase from fontTools.varLib import designspace, models, builder @@ -179,7 +179,7 @@ def _add_gvar(font, model, master_ttfs): supports = model.supports assert len(deltas) == len(supports) for i,(delta,support) in enumerate(zip(deltas[1:], supports[1:])): - var = GlyphVariation(support, delta) + var = TupleVariation(support, delta) gvar.variations[glyph].append(var) def _add_HVAR(font, model, master_ttfs, axisTags): diff --git a/Snippets/interpolate.py b/Snippets/interpolate.py index fb13729eb..3a03a613b 100755 --- a/Snippets/interpolate.py +++ b/Snippets/interpolate.py @@ -26,7 +26,7 @@ from fontTools.misc.py23 import * from fontTools.ttLib import TTFont from fontTools.ttLib.tables._n_a_m_e import NameRecord from fontTools.ttLib.tables._f_v_a_r import table__f_v_a_r, Axis, NamedInstance -from fontTools.ttLib.tables._g_v_a_r import table__g_v_a_r, GlyphVariation +from fontTools.ttLib.tables._g_v_a_r import table__g_v_a_r, TupleVariation import logging @@ -89,8 +89,8 @@ def AddGlyphVariations(font, thin, regular, black): zip(regularCoord, blackCoord, thinCoord): thinDelta.append(((thinX - regX, thinY - regY))) blackDelta.append((blackX - regX, blackY - regY)) - thinVar = GlyphVariation({"wght": (-1.0, -1.0, 0.0)}, thinDelta) - blackVar = GlyphVariation({"wght": (0.0, 1.0, 1.0)}, blackDelta) + thinVar = TupleVariation({"wght": (-1.0, -1.0, 0.0)}, thinDelta) + blackVar = TupleVariation({"wght": (0.0, 1.0, 1.0)}, blackDelta) gvar.variations[glyphName] = [thinVar, blackVar]