e8146a6d07
Set to True by default. Can be turned to False on the table, or at Glyph() compile time. Also fixes Glyph's draw() to expand the glyph first. Otherwise it was failing.
1040 lines
36 KiB
Python
1040 lines
36 KiB
Python
from fontTools.misc.fixedTools import otRound
|
|
from fontTools.misc.testTools import getXML, parseXML
|
|
from fontTools.misc.transform import Transform
|
|
from fontTools.pens.ttGlyphPen import TTGlyphPen
|
|
from fontTools.pens.recordingPen import RecordingPen, RecordingPointPen
|
|
from fontTools.pens.pointPen import PointToSegmentPen
|
|
from fontTools.ttLib import TTFont, newTable, TTLibError
|
|
from fontTools.ttLib.tables._g_l_y_f import (
|
|
Glyph,
|
|
GlyphCoordinates,
|
|
GlyphComponent,
|
|
dropImpliedOnCurvePoints,
|
|
flagOnCurve,
|
|
flagCubic,
|
|
ARGS_ARE_XY_VALUES,
|
|
SCALED_COMPONENT_OFFSET,
|
|
UNSCALED_COMPONENT_OFFSET,
|
|
WE_HAVE_A_SCALE,
|
|
WE_HAVE_A_TWO_BY_TWO,
|
|
WE_HAVE_AN_X_AND_Y_SCALE,
|
|
)
|
|
from fontTools.ttLib.tables import ttProgram
|
|
import sys
|
|
import array
|
|
from copy import deepcopy
|
|
from io import StringIO, BytesIO
|
|
import itertools
|
|
import pytest
|
|
import re
|
|
import os
|
|
import unittest
|
|
|
|
|
|
class GlyphCoordinatesTest(object):
|
|
def test_translate(self):
|
|
g = GlyphCoordinates([(1, 2)])
|
|
g.translate((0.5, 0))
|
|
assert g == GlyphCoordinates([(1.5, 2.0)])
|
|
|
|
def test_scale(self):
|
|
g = GlyphCoordinates([(1, 2)])
|
|
g.scale((0.5, 0))
|
|
assert g == GlyphCoordinates([(0.5, 0.0)])
|
|
|
|
def test_transform(self):
|
|
g = GlyphCoordinates([(1, 2)])
|
|
g.transform(((0.5, 0), (0.2, 0.5)))
|
|
assert g[0] == GlyphCoordinates([(0.9, 1.0)])[0]
|
|
|
|
def test__eq__(self):
|
|
g = GlyphCoordinates([(1, 2)])
|
|
g2 = GlyphCoordinates([(1.0, 2)])
|
|
g3 = GlyphCoordinates([(1.5, 2)])
|
|
assert g == g2
|
|
assert not g == g3
|
|
assert not g2 == g3
|
|
assert not g == object()
|
|
|
|
def test__ne__(self):
|
|
g = GlyphCoordinates([(1, 2)])
|
|
g2 = GlyphCoordinates([(1.0, 2)])
|
|
g3 = GlyphCoordinates([(1.5, 2)])
|
|
assert not (g != g2)
|
|
assert g != g3
|
|
assert g2 != g3
|
|
assert g != object()
|
|
|
|
def test__pos__(self):
|
|
g = GlyphCoordinates([(1, 2)])
|
|
g2 = +g
|
|
assert g == g2
|
|
|
|
def test__neg__(self):
|
|
g = GlyphCoordinates([(1, 2)])
|
|
g2 = -g
|
|
assert g2 == GlyphCoordinates([(-1, -2)])
|
|
|
|
@pytest.mark.skipif(sys.version_info[0] < 3, reason="__round___ requires Python 3")
|
|
def test__round__(self):
|
|
g = GlyphCoordinates([(-1.5, 2)])
|
|
g2 = round(g)
|
|
assert g2 == GlyphCoordinates([(-1, 2)])
|
|
|
|
def test__add__(self):
|
|
g1 = GlyphCoordinates([(1, 2)])
|
|
g2 = GlyphCoordinates([(3, 4)])
|
|
g3 = GlyphCoordinates([(4, 6)])
|
|
assert g1 + g2 == g3
|
|
assert g1 + (1, 1) == GlyphCoordinates([(2, 3)])
|
|
with pytest.raises(TypeError) as excinfo:
|
|
assert g1 + object()
|
|
assert "unsupported operand" in str(excinfo.value)
|
|
|
|
def test__sub__(self):
|
|
g1 = GlyphCoordinates([(1, 2)])
|
|
g2 = GlyphCoordinates([(3, 4)])
|
|
g3 = GlyphCoordinates([(-2, -2)])
|
|
assert g1 - g2 == g3
|
|
assert g1 - (1, 1) == GlyphCoordinates([(0, 1)])
|
|
with pytest.raises(TypeError) as excinfo:
|
|
assert g1 - object()
|
|
assert "unsupported operand" in str(excinfo.value)
|
|
|
|
def test__rsub__(self):
|
|
g = GlyphCoordinates([(1, 2)])
|
|
# other + (-self)
|
|
assert (1, 1) - g == GlyphCoordinates([(0, -1)])
|
|
|
|
def test__mul__(self):
|
|
g = GlyphCoordinates([(1, 2)])
|
|
assert g * 3 == GlyphCoordinates([(3, 6)])
|
|
assert g * (3, 2) == GlyphCoordinates([(3, 4)])
|
|
assert g * (1, 1) == g
|
|
with pytest.raises(TypeError) as excinfo:
|
|
assert g * object()
|
|
assert "unsupported operand" in str(excinfo.value)
|
|
|
|
def test__truediv__(self):
|
|
g = GlyphCoordinates([(1, 2)])
|
|
assert g / 2 == GlyphCoordinates([(0.5, 1)])
|
|
assert g / (1, 2) == GlyphCoordinates([(1, 1)])
|
|
assert g / (1, 1) == g
|
|
with pytest.raises(TypeError) as excinfo:
|
|
assert g / object()
|
|
assert "unsupported operand" in str(excinfo.value)
|
|
|
|
def test__iadd__(self):
|
|
g = GlyphCoordinates([(1, 2)])
|
|
g += (0.5, 0)
|
|
assert g == GlyphCoordinates([(1.5, 2.0)])
|
|
g2 = GlyphCoordinates([(3, 4)])
|
|
g += g2
|
|
assert g == GlyphCoordinates([(4.5, 6.0)])
|
|
|
|
def test__isub__(self):
|
|
g = GlyphCoordinates([(1, 2)])
|
|
g -= (0.5, 0)
|
|
assert g == GlyphCoordinates([(0.5, 2.0)])
|
|
g2 = GlyphCoordinates([(3, 4)])
|
|
g -= g2
|
|
assert g == GlyphCoordinates([(-2.5, -2.0)])
|
|
|
|
def __test__imul__(self):
|
|
g = GlyphCoordinates([(1, 2)])
|
|
g *= (2, 0.5)
|
|
g *= 2
|
|
assert g == GlyphCoordinates([(4.0, 2.0)])
|
|
g = GlyphCoordinates([(1, 2)])
|
|
g *= 2
|
|
assert g == GlyphCoordinates([(2, 4)])
|
|
|
|
def test__itruediv__(self):
|
|
g = GlyphCoordinates([(1, 3)])
|
|
g /= (0.5, 1.5)
|
|
g /= 2
|
|
assert g == GlyphCoordinates([(1.0, 1.0)])
|
|
|
|
def test__bool__(self):
|
|
g = GlyphCoordinates([])
|
|
assert bool(g) == False
|
|
g = GlyphCoordinates([(0, 0), (0.0, 0)])
|
|
assert bool(g) == True
|
|
g = GlyphCoordinates([(0, 0), (1, 0)])
|
|
assert bool(g) == True
|
|
g = GlyphCoordinates([(0, 0.5), (0, 0)])
|
|
assert bool(g) == True
|
|
|
|
def test_double_precision_float(self):
|
|
# https://github.com/fonttools/fonttools/issues/963
|
|
afloat = 242.50000000000003
|
|
g = GlyphCoordinates([(afloat, 0)])
|
|
g.toInt()
|
|
# this would return 242 if the internal array.array typecode is 'f',
|
|
# since the Python float is truncated to a C float.
|
|
# when using typecode 'd' it should return the correct value 243
|
|
assert g[0][0] == otRound(afloat)
|
|
|
|
def test__checkFloat_overflow(self):
|
|
g = GlyphCoordinates([(1, 1)])
|
|
g.append((0x8000, 0))
|
|
assert list(g.array) == [1.0, 1.0, 32768.0, 0.0]
|
|
|
|
|
|
CURR_DIR = os.path.abspath(os.path.dirname(os.path.realpath(__file__)))
|
|
DATA_DIR = os.path.join(CURR_DIR, "data")
|
|
|
|
GLYF_TTX = os.path.join(DATA_DIR, "_g_l_y_f_outline_flag_bit6.ttx")
|
|
GLYF_BIN = os.path.join(DATA_DIR, "_g_l_y_f_outline_flag_bit6.glyf.bin")
|
|
HEAD_BIN = os.path.join(DATA_DIR, "_g_l_y_f_outline_flag_bit6.head.bin")
|
|
LOCA_BIN = os.path.join(DATA_DIR, "_g_l_y_f_outline_flag_bit6.loca.bin")
|
|
MAXP_BIN = os.path.join(DATA_DIR, "_g_l_y_f_outline_flag_bit6.maxp.bin")
|
|
INST_TTX = os.path.join(DATA_DIR, "_g_l_y_f_instructions.ttx")
|
|
|
|
|
|
def strip_ttLibVersion(string):
|
|
return re.sub(' ttLibVersion=".*"', "", string)
|
|
|
|
|
|
class GlyfTableTest(unittest.TestCase):
|
|
def __init__(self, methodName):
|
|
unittest.TestCase.__init__(self, methodName)
|
|
# Python 3 renamed assertRaisesRegexp to assertRaisesRegex,
|
|
# and fires deprecation warnings if a program uses the old name.
|
|
if not hasattr(self, "assertRaisesRegex"):
|
|
self.assertRaisesRegex = self.assertRaisesRegexp
|
|
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
with open(GLYF_BIN, "rb") as f:
|
|
cls.glyfData = f.read()
|
|
with open(HEAD_BIN, "rb") as f:
|
|
cls.headData = f.read()
|
|
with open(LOCA_BIN, "rb") as f:
|
|
cls.locaData = f.read()
|
|
with open(MAXP_BIN, "rb") as f:
|
|
cls.maxpData = f.read()
|
|
with open(GLYF_TTX, "r") as f:
|
|
cls.glyfXML = strip_ttLibVersion(f.read()).splitlines()
|
|
|
|
def test_toXML(self):
|
|
font = TTFont(sfntVersion="\x00\x01\x00\x00")
|
|
glyfTable = font["glyf"] = newTable("glyf")
|
|
font["head"] = newTable("head")
|
|
font["loca"] = newTable("loca")
|
|
font["maxp"] = newTable("maxp")
|
|
font["maxp"].decompile(self.maxpData, font)
|
|
font["head"].decompile(self.headData, font)
|
|
font["loca"].decompile(self.locaData, font)
|
|
glyfTable.decompile(self.glyfData, font)
|
|
out = StringIO()
|
|
font.saveXML(out)
|
|
glyfXML = strip_ttLibVersion(out.getvalue()).splitlines()
|
|
self.assertEqual(glyfXML, self.glyfXML)
|
|
|
|
def test_fromXML(self):
|
|
font = TTFont(sfntVersion="\x00\x01\x00\x00")
|
|
font.importXML(GLYF_TTX)
|
|
glyfTable = font["glyf"]
|
|
glyfData = glyfTable.compile(font)
|
|
self.assertEqual(glyfData, self.glyfData)
|
|
|
|
def test_instructions_roundtrip(self):
|
|
font = TTFont(sfntVersion="\x00\x01\x00\x00")
|
|
font.importXML(INST_TTX)
|
|
glyfTable = font["glyf"]
|
|
self.glyfData = glyfTable.compile(font)
|
|
out = StringIO()
|
|
font.saveXML(out)
|
|
glyfXML = strip_ttLibVersion(out.getvalue()).splitlines()
|
|
with open(INST_TTX, "r") as f:
|
|
origXML = strip_ttLibVersion(f.read()).splitlines()
|
|
self.assertEqual(glyfXML, origXML)
|
|
|
|
def test_recursiveComponent(self):
|
|
glyphSet = {}
|
|
pen_dummy = TTGlyphPen(glyphSet)
|
|
glyph_dummy = pen_dummy.glyph()
|
|
glyphSet["A"] = glyph_dummy
|
|
glyphSet["B"] = glyph_dummy
|
|
pen_A = TTGlyphPen(glyphSet)
|
|
pen_A.addComponent("B", (1, 0, 0, 1, 0, 0))
|
|
pen_B = TTGlyphPen(glyphSet)
|
|
pen_B.addComponent("A", (1, 0, 0, 1, 0, 0))
|
|
glyph_A = pen_A.glyph()
|
|
glyph_B = pen_B.glyph()
|
|
glyphSet["A"] = glyph_A
|
|
glyphSet["B"] = glyph_B
|
|
with self.assertRaisesRegex(
|
|
TTLibError, "glyph '.' contains a recursive component reference"
|
|
):
|
|
glyph_A.getCoordinates(glyphSet)
|
|
|
|
def test_trim_remove_hinting_composite_glyph(self):
|
|
glyphSet = {"dummy": TTGlyphPen(None).glyph()}
|
|
|
|
pen = TTGlyphPen(glyphSet)
|
|
pen.addComponent("dummy", (1, 0, 0, 1, 0, 0))
|
|
composite = pen.glyph()
|
|
p = ttProgram.Program()
|
|
p.fromAssembly(["SVTCA[0]"])
|
|
composite.program = p
|
|
glyphSet["composite"] = composite
|
|
|
|
glyfTable = newTable("glyf")
|
|
glyfTable.glyphs = glyphSet
|
|
glyfTable.glyphOrder = sorted(glyphSet)
|
|
|
|
composite.compact(glyfTable)
|
|
|
|
self.assertTrue(hasattr(composite, "data"))
|
|
|
|
# remove hinting from the compacted composite glyph, without expanding it
|
|
composite.trim(remove_hinting=True)
|
|
|
|
# check that, after expanding the glyph, we have no instructions
|
|
composite.expand(glyfTable)
|
|
self.assertFalse(hasattr(composite, "program"))
|
|
|
|
# now remove hinting from expanded composite glyph
|
|
composite.program = p
|
|
composite.trim(remove_hinting=True)
|
|
|
|
# check we have no instructions
|
|
self.assertFalse(hasattr(composite, "program"))
|
|
|
|
composite.compact(glyfTable)
|
|
|
|
def test_bit6_draw_to_pen_issue1771(self):
|
|
# https://github.com/fonttools/fonttools/issues/1771
|
|
font = TTFont(sfntVersion="\x00\x01\x00\x00")
|
|
# glyph00003 contains a bit 6 flag on the first point,
|
|
# which triggered the issue
|
|
font.importXML(GLYF_TTX)
|
|
glyfTable = font["glyf"]
|
|
pen = RecordingPen()
|
|
glyfTable["glyph00003"].draw(pen, glyfTable=glyfTable)
|
|
expected = [
|
|
("moveTo", ((501, 1430),)),
|
|
("lineTo", ((683, 1430),)),
|
|
("lineTo", ((1172, 0),)),
|
|
("lineTo", ((983, 0),)),
|
|
("lineTo", ((591, 1193),)),
|
|
("lineTo", ((199, 0),)),
|
|
("lineTo", ((12, 0),)),
|
|
("closePath", ()),
|
|
("moveTo", ((249, 514),)),
|
|
("lineTo", ((935, 514),)),
|
|
("lineTo", ((935, 352),)),
|
|
("lineTo", ((249, 352),)),
|
|
("closePath", ()),
|
|
]
|
|
self.assertEqual(pen.value, expected)
|
|
|
|
def test_bit6_draw_to_pointpen(self):
|
|
# https://github.com/fonttools/fonttools/issues/1771
|
|
font = TTFont(sfntVersion="\x00\x01\x00\x00")
|
|
# glyph00003 contains a bit 6 flag on the first point
|
|
# which triggered the issue
|
|
font.importXML(GLYF_TTX)
|
|
glyfTable = font["glyf"]
|
|
pen = RecordingPointPen()
|
|
glyfTable["glyph00003"].drawPoints(pen, glyfTable=glyfTable)
|
|
expected = [
|
|
("beginPath", (), {}),
|
|
("addPoint", ((501, 1430), "line", False, None), {}),
|
|
("addPoint", ((683, 1430), "line", False, None), {}),
|
|
("addPoint", ((1172, 0), "line", False, None), {}),
|
|
("addPoint", ((983, 0), "line", False, None), {}),
|
|
]
|
|
self.assertEqual(pen.value[: len(expected)], expected)
|
|
|
|
def test_draw_vs_drawpoints(self):
|
|
font = TTFont(sfntVersion="\x00\x01\x00\x00")
|
|
font.importXML(GLYF_TTX)
|
|
glyfTable = font["glyf"]
|
|
pen1 = RecordingPen()
|
|
pen2 = RecordingPen()
|
|
glyfTable["glyph00003"].draw(pen1, glyfTable)
|
|
glyfTable["glyph00003"].drawPoints(PointToSegmentPen(pen2), glyfTable)
|
|
self.assertEqual(pen1.value, pen2.value)
|
|
|
|
def test_compile_empty_table(self):
|
|
font = TTFont(sfntVersion="\x00\x01\x00\x00")
|
|
font.importXML(GLYF_TTX)
|
|
glyfTable = font["glyf"]
|
|
# set all glyphs to zero contours
|
|
glyfTable.glyphs = {glyphName: Glyph() for glyphName in font.getGlyphOrder()}
|
|
glyfData = glyfTable.compile(font)
|
|
self.assertEqual(glyfData, b"\x00")
|
|
self.assertEqual(list(font["loca"]), [0] * (font["maxp"].numGlyphs + 1))
|
|
|
|
def test_decompile_empty_table(self):
|
|
font = TTFont()
|
|
glyphNames = [".notdef", "space"]
|
|
font.setGlyphOrder(glyphNames)
|
|
font["loca"] = newTable("loca")
|
|
font["loca"].locations = [0] * (len(glyphNames) + 1)
|
|
font["glyf"] = newTable("glyf")
|
|
font["glyf"].decompile(b"\x00", font)
|
|
self.assertEqual(len(font["glyf"]), 2)
|
|
self.assertEqual(font["glyf"][".notdef"].numberOfContours, 0)
|
|
self.assertEqual(font["glyf"]["space"].numberOfContours, 0)
|
|
|
|
def test_getPhantomPoints(self):
|
|
# https://github.com/fonttools/fonttools/issues/2295
|
|
font = TTFont()
|
|
glyphNames = [".notdef"]
|
|
font.setGlyphOrder(glyphNames)
|
|
font["loca"] = newTable("loca")
|
|
font["loca"].locations = [0] * (len(glyphNames) + 1)
|
|
font["glyf"] = newTable("glyf")
|
|
font["glyf"].decompile(b"\x00", font)
|
|
font["hmtx"] = newTable("hmtx")
|
|
font["hmtx"].metrics = {".notdef": (100, 0)}
|
|
font["head"] = newTable("head")
|
|
font["head"].unitsPerEm = 1000
|
|
with pytest.deprecated_call():
|
|
self.assertEqual(
|
|
font["glyf"].getPhantomPoints(".notdef", font, 0),
|
|
[(0, 0), (100, 0), (0, 0), (0, -1000)],
|
|
)
|
|
|
|
def test_getGlyphID(self):
|
|
# https://github.com/fonttools/fonttools/pull/3301#discussion_r1360405861
|
|
glyf = newTable("glyf")
|
|
glyf.setGlyphOrder([".notdef", "a", "b"])
|
|
glyf.glyphs = {}
|
|
for glyphName in glyf.glyphOrder:
|
|
glyf[glyphName] = Glyph()
|
|
|
|
assert glyf.getGlyphID("a") == 1
|
|
|
|
with pytest.raises(ValueError):
|
|
glyf.getGlyphID("c")
|
|
|
|
glyf["c"] = Glyph()
|
|
assert glyf.getGlyphID("c") == 3
|
|
|
|
del glyf["b"]
|
|
assert glyf.getGlyphID("c") == 2
|
|
|
|
|
|
class GlyphTest:
|
|
def test_getCoordinates(self):
|
|
glyphSet = {}
|
|
pen = TTGlyphPen(glyphSet)
|
|
pen.moveTo((0, 0))
|
|
pen.lineTo((100, 0))
|
|
pen.lineTo((100, 100))
|
|
pen.lineTo((0, 100))
|
|
pen.closePath()
|
|
# simple contour glyph
|
|
glyphSet["a"] = a = pen.glyph()
|
|
|
|
assert a.getCoordinates(glyphSet) == (
|
|
GlyphCoordinates([(0, 0), (100, 0), (100, 100), (0, 100)]),
|
|
[3],
|
|
array.array("B", [1, 1, 1, 1]),
|
|
)
|
|
|
|
# composite glyph with only XY offset
|
|
pen = TTGlyphPen(glyphSet)
|
|
pen.addComponent("a", (1, 0, 0, 1, 10, 20))
|
|
glyphSet["b"] = b = pen.glyph()
|
|
|
|
assert b.getCoordinates(glyphSet) == (
|
|
GlyphCoordinates([(10, 20), (110, 20), (110, 120), (10, 120)]),
|
|
[3],
|
|
array.array("B", [1, 1, 1, 1]),
|
|
)
|
|
|
|
# composite glyph with a scale (and referencing another composite glyph)
|
|
pen = TTGlyphPen(glyphSet)
|
|
pen.addComponent("b", (0.5, 0, 0, 0.5, 0, 0))
|
|
glyphSet["c"] = c = pen.glyph()
|
|
|
|
assert c.getCoordinates(glyphSet) == (
|
|
GlyphCoordinates([(5, 10), (55, 10), (55, 60), (5, 60)]),
|
|
[3],
|
|
array.array("B", [1, 1, 1, 1]),
|
|
)
|
|
|
|
# composite glyph with unscaled offset (MS-style)
|
|
pen = TTGlyphPen(glyphSet)
|
|
pen.addComponent("a", (0.5, 0, 0, 0.5, 10, 20))
|
|
glyphSet["d"] = d = pen.glyph()
|
|
d.components[0].flags |= UNSCALED_COMPONENT_OFFSET
|
|
|
|
assert d.getCoordinates(glyphSet) == (
|
|
GlyphCoordinates([(10, 20), (60, 20), (60, 70), (10, 70)]),
|
|
[3],
|
|
array.array("B", [1, 1, 1, 1]),
|
|
)
|
|
|
|
# composite glyph with a scaled offset (Apple-style)
|
|
pen = TTGlyphPen(glyphSet)
|
|
pen.addComponent("a", (0.5, 0, 0, 0.5, 10, 20))
|
|
glyphSet["e"] = e = pen.glyph()
|
|
e.components[0].flags |= SCALED_COMPONENT_OFFSET
|
|
|
|
assert e.getCoordinates(glyphSet) == (
|
|
GlyphCoordinates([(5, 10), (55, 10), (55, 60), (5, 60)]),
|
|
[3],
|
|
array.array("B", [1, 1, 1, 1]),
|
|
)
|
|
|
|
# composite glyph where the 2nd and 3rd components use anchor points
|
|
pen = TTGlyphPen(glyphSet)
|
|
pen.addComponent("a", (1, 0, 0, 1, 0, 0))
|
|
glyphSet["f"] = f = pen.glyph()
|
|
|
|
comp1 = GlyphComponent()
|
|
comp1.glyphName = "a"
|
|
# aling the new component's pt 0 to pt 2 of contour points added so far
|
|
comp1.firstPt = 2
|
|
comp1.secondPt = 0
|
|
comp1.flags = 0
|
|
f.components.append(comp1)
|
|
|
|
comp2 = GlyphComponent()
|
|
comp2.glyphName = "a"
|
|
# aling the new component's pt 0 to pt 6 of contour points added so far
|
|
comp2.firstPt = 6
|
|
comp2.secondPt = 0
|
|
comp2.transform = [[0.707107, 0.707107], [-0.707107, 0.707107]] # rotate 45 deg
|
|
comp2.flags = WE_HAVE_A_TWO_BY_TWO
|
|
f.components.append(comp2)
|
|
|
|
coords, end_pts, flags = f.getCoordinates(glyphSet)
|
|
assert end_pts == [3, 7, 11]
|
|
assert flags == array.array("B", [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1])
|
|
assert list(sum(coords, ())) == pytest.approx(
|
|
[
|
|
0,
|
|
0,
|
|
100,
|
|
0,
|
|
100,
|
|
100,
|
|
0,
|
|
100,
|
|
100,
|
|
100,
|
|
200,
|
|
100,
|
|
200,
|
|
200,
|
|
100,
|
|
200,
|
|
200,
|
|
200,
|
|
270.7107,
|
|
270.7107,
|
|
200.0,
|
|
341.4214,
|
|
129.2893,
|
|
270.7107,
|
|
]
|
|
)
|
|
|
|
def test_getCompositeMaxpValues(self):
|
|
# https://github.com/fonttools/fonttools/issues/2044
|
|
glyphSet = {}
|
|
pen = TTGlyphPen(glyphSet) # empty non-composite glyph
|
|
glyphSet["fraction"] = pen.glyph()
|
|
glyphSet["zero.numr"] = pen.glyph()
|
|
pen = TTGlyphPen(glyphSet)
|
|
pen.addComponent("zero.numr", (1, 0, 0, 1, 0, 0))
|
|
glyphSet["zero.dnom"] = pen.glyph()
|
|
pen = TTGlyphPen(glyphSet)
|
|
pen.addComponent("zero.numr", (1, 0, 0, 1, 0, 0))
|
|
pen.addComponent("fraction", (1, 0, 0, 1, 0, 0))
|
|
pen.addComponent("zero.dnom", (1, 0, 0, 1, 0, 0))
|
|
glyphSet["percent"] = pen.glyph()
|
|
pen = TTGlyphPen(glyphSet)
|
|
pen.addComponent("zero.numr", (1, 0, 0, 1, 0, 0))
|
|
pen.addComponent("fraction", (1, 0, 0, 1, 0, 0))
|
|
pen.addComponent("zero.dnom", (1, 0, 0, 1, 0, 0))
|
|
pen.addComponent("zero.dnom", (1, 0, 0, 1, 0, 0))
|
|
glyphSet["perthousand"] = pen.glyph()
|
|
assert glyphSet["zero.dnom"].getCompositeMaxpValues(glyphSet)[2] == 1
|
|
assert glyphSet["percent"].getCompositeMaxpValues(glyphSet)[2] == 2
|
|
assert glyphSet["perthousand"].getCompositeMaxpValues(glyphSet)[2] == 2
|
|
|
|
def test_recalcBounds_empty_components(self):
|
|
glyphSet = {}
|
|
pen = TTGlyphPen(glyphSet)
|
|
# empty simple glyph
|
|
foo = glyphSet["foo"] = pen.glyph()
|
|
# use the empty 'foo' glyph as a component in 'bar' with some x/y offsets
|
|
pen.addComponent("foo", (1, 0, 0, 1, -80, 50))
|
|
bar = glyphSet["bar"] = pen.glyph()
|
|
|
|
foo.recalcBounds(glyphSet)
|
|
bar.recalcBounds(glyphSet)
|
|
|
|
# we expect both the empty simple glyph and the composite referencing it
|
|
# to have empty bounding boxes (0, 0, 0, 0) no matter the component's shift
|
|
assert (foo.xMin, foo.yMin, foo.xMax, foo.yMax) == (0, 0, 0, 0)
|
|
assert (bar.xMin, bar.yMin, bar.xMax, bar.yMax) == (0, 0, 0, 0)
|
|
|
|
|
|
class GlyphComponentTest:
|
|
def test_toXML_no_transform(self):
|
|
comp = GlyphComponent()
|
|
comp.glyphName = "a"
|
|
comp.flags = ARGS_ARE_XY_VALUES
|
|
comp.x, comp.y = 1, 2
|
|
|
|
assert getXML(comp.toXML) == [
|
|
'<component glyphName="a" x="1" y="2" flags="0x2"/>'
|
|
]
|
|
|
|
def test_toXML_transform_scale(self):
|
|
comp = GlyphComponent()
|
|
comp.glyphName = "a"
|
|
comp.flags = ARGS_ARE_XY_VALUES | WE_HAVE_A_SCALE
|
|
comp.x, comp.y = 1, 2
|
|
|
|
comp.transform = [[0.2999878, 0], [0, 0.2999878]]
|
|
assert getXML(comp.toXML) == [
|
|
'<component glyphName="a" x="1" y="2" scale="0.3" flags="0xa"/>'
|
|
]
|
|
|
|
def test_toXML_transform_xy_scale(self):
|
|
comp = GlyphComponent()
|
|
comp.glyphName = "a"
|
|
comp.flags = ARGS_ARE_XY_VALUES | WE_HAVE_AN_X_AND_Y_SCALE
|
|
comp.x, comp.y = 1, 2
|
|
|
|
comp.transform = [[0.5999756, 0], [0, 0.2999878]]
|
|
assert getXML(comp.toXML) == [
|
|
'<component glyphName="a" x="1" y="2" scalex="0.6" '
|
|
'scaley="0.3" flags="0x42"/>'
|
|
]
|
|
|
|
def test_toXML_transform_2x2_scale(self):
|
|
comp = GlyphComponent()
|
|
comp.glyphName = "a"
|
|
comp.flags = ARGS_ARE_XY_VALUES | WE_HAVE_A_TWO_BY_TWO
|
|
comp.x, comp.y = 1, 2
|
|
|
|
comp.transform = [[0.5999756, -0.2000122], [0.2000122, 0.2999878]]
|
|
assert getXML(comp.toXML) == [
|
|
'<component glyphName="a" x="1" y="2" scalex="0.6" scale01="-0.2" '
|
|
'scale10="0.2" scaley="0.3" flags="0x82"/>'
|
|
]
|
|
|
|
def test_fromXML_no_transform(self):
|
|
comp = GlyphComponent()
|
|
for name, attrs, content in parseXML(
|
|
['<component glyphName="a" x="1" y="2" flags="0x2"/>']
|
|
):
|
|
comp.fromXML(name, attrs, content, ttFont=None)
|
|
|
|
assert comp.glyphName == "a"
|
|
assert comp.flags & ARGS_ARE_XY_VALUES != 0
|
|
assert (comp.x, comp.y) == (1, 2)
|
|
assert not hasattr(comp, "transform")
|
|
|
|
def test_fromXML_transform_scale(self):
|
|
comp = GlyphComponent()
|
|
for name, attrs, content in parseXML(
|
|
['<component glyphName="a" x="1" y="2" scale="0.3" flags="0xa"/>']
|
|
):
|
|
comp.fromXML(name, attrs, content, ttFont=None)
|
|
|
|
assert comp.glyphName == "a"
|
|
assert comp.flags & ARGS_ARE_XY_VALUES != 0
|
|
assert comp.flags & WE_HAVE_A_SCALE != 0
|
|
assert (comp.x, comp.y) == (1, 2)
|
|
assert hasattr(comp, "transform")
|
|
for value, expected in zip(
|
|
itertools.chain(*comp.transform), [0.2999878, 0, 0, 0.2999878]
|
|
):
|
|
assert value == pytest.approx(expected)
|
|
|
|
def test_fromXML_transform_xy_scale(self):
|
|
comp = GlyphComponent()
|
|
for name, attrs, content in parseXML(
|
|
[
|
|
'<component glyphName="a" x="1" y="2" scalex="0.6" '
|
|
'scaley="0.3" flags="0x42"/>'
|
|
]
|
|
):
|
|
comp.fromXML(name, attrs, content, ttFont=None)
|
|
|
|
assert comp.glyphName == "a"
|
|
assert comp.flags & ARGS_ARE_XY_VALUES != 0
|
|
assert comp.flags & WE_HAVE_AN_X_AND_Y_SCALE != 0
|
|
assert (comp.x, comp.y) == (1, 2)
|
|
assert hasattr(comp, "transform")
|
|
for value, expected in zip(
|
|
itertools.chain(*comp.transform), [0.5999756, 0, 0, 0.2999878]
|
|
):
|
|
assert value == pytest.approx(expected)
|
|
|
|
def test_fromXML_transform_2x2_scale(self):
|
|
comp = GlyphComponent()
|
|
for name, attrs, content in parseXML(
|
|
[
|
|
'<component glyphName="a" x="1" y="2" scalex="0.6" scale01="-0.2" '
|
|
'scale10="0.2" scaley="0.3" flags="0x82"/>'
|
|
]
|
|
):
|
|
comp.fromXML(name, attrs, content, ttFont=None)
|
|
|
|
assert comp.glyphName == "a"
|
|
assert comp.flags & ARGS_ARE_XY_VALUES != 0
|
|
assert comp.flags & WE_HAVE_A_TWO_BY_TWO != 0
|
|
assert (comp.x, comp.y) == (1, 2)
|
|
assert hasattr(comp, "transform")
|
|
for value, expected in zip(
|
|
itertools.chain(*comp.transform),
|
|
[0.5999756, -0.2000122, 0.2000122, 0.2999878],
|
|
):
|
|
assert value == pytest.approx(expected)
|
|
|
|
def test_toXML_reference_points(self):
|
|
comp = GlyphComponent()
|
|
comp.glyphName = "a"
|
|
comp.flags = 0
|
|
comp.firstPt = 1
|
|
comp.secondPt = 2
|
|
|
|
assert getXML(comp.toXML) == [
|
|
'<component glyphName="a" firstPt="1" secondPt="2" flags="0x0"/>'
|
|
]
|
|
|
|
def test_compile_for_speed(self):
|
|
glyph = Glyph()
|
|
glyph.numberOfContours = 1
|
|
glyph.coordinates = GlyphCoordinates(
|
|
[(0, 0), (1, 0), (1, 0), (1, 1), (1, 1), (0, 1), (0, 1)]
|
|
)
|
|
glyph.flags = array.array("B", [flagOnCurve] + [flagCubic] * 6)
|
|
glyph.endPtsOfContours = [6]
|
|
glyph.program = ttProgram.Program()
|
|
|
|
glyph.expand(None)
|
|
sizeBytes = glyph.compile(None, optimizeSize=True)
|
|
glyph.expand(None)
|
|
speedBytes = glyph.compile(None, optimizeSize=False)
|
|
|
|
assert len(sizeBytes) < len(speedBytes)
|
|
|
|
for data in sizeBytes, speedBytes:
|
|
glyph = Glyph(data)
|
|
|
|
pen = RecordingPen()
|
|
glyph.draw(pen, None)
|
|
|
|
assert pen.value == [
|
|
("moveTo", ((0, 0),)),
|
|
("curveTo", ((1, 0), (1, 0), (1.0, 0.5))),
|
|
("curveTo", ((1, 1), (1, 1), (0.5, 1.0))),
|
|
("curveTo", ((0, 1), (0, 1), (0, 0))),
|
|
("closePath", ()),
|
|
]
|
|
|
|
def test_fromXML_reference_points(self):
|
|
comp = GlyphComponent()
|
|
for name, attrs, content in parseXML(
|
|
['<component glyphName="a" firstPt="1" secondPt="2" flags="0x0"/>']
|
|
):
|
|
comp.fromXML(name, attrs, content, ttFont=None)
|
|
|
|
assert comp.glyphName == "a"
|
|
assert comp.flags == 0
|
|
assert (comp.firstPt, comp.secondPt) == (1, 2)
|
|
assert not hasattr(comp, "transform")
|
|
|
|
|
|
class GlyphCubicTest:
|
|
def test_roundtrip(self):
|
|
font_path = os.path.join(DATA_DIR, "NotoSans-VF-cubic.subset.ttf")
|
|
font = TTFont(font_path)
|
|
tables = [table_tag for table_tag in font.keys() if table_tag not in {"head"}]
|
|
xml = StringIO()
|
|
font.saveXML(xml)
|
|
xml1 = StringIO()
|
|
font.saveXML(xml1, tables=tables)
|
|
xml.seek(0)
|
|
font = TTFont()
|
|
font.importXML(xml)
|
|
ttf = BytesIO()
|
|
font.save(ttf)
|
|
ttf.seek(0)
|
|
font = TTFont(ttf)
|
|
xml2 = StringIO()
|
|
font.saveXML(xml2, tables=tables)
|
|
assert xml1.getvalue() == xml2.getvalue()
|
|
|
|
def test_no_oncurves(self):
|
|
glyph = Glyph()
|
|
glyph.numberOfContours = 1
|
|
glyph.coordinates = GlyphCoordinates(
|
|
[(0, 0), (1, 0), (1, 0), (1, 1), (1, 1), (0, 1), (0, 1), (0, 0)]
|
|
)
|
|
glyph.flags = array.array("B", [flagCubic] * 8)
|
|
glyph.endPtsOfContours = [7]
|
|
glyph.program = ttProgram.Program()
|
|
|
|
for i in range(2):
|
|
if i == 1:
|
|
glyph.compile(None)
|
|
|
|
pen = RecordingPen()
|
|
glyph.draw(pen, None)
|
|
|
|
assert pen.value == [
|
|
("moveTo", ((0, 0),)),
|
|
("curveTo", ((0, 0), (1, 0), (1, 0))),
|
|
("curveTo", ((1, 0), (1, 1), (1, 1))),
|
|
("curveTo", ((1, 1), (0, 1), (0, 1))),
|
|
("curveTo", ((0, 1), (0, 0), (0, 0))),
|
|
("closePath", ()),
|
|
]
|
|
|
|
def test_spline(self):
|
|
glyph = Glyph()
|
|
glyph.numberOfContours = 1
|
|
glyph.coordinates = GlyphCoordinates(
|
|
[(0, 0), (1, 0), (1, 0), (1, 1), (1, 1), (0, 1), (0, 1)]
|
|
)
|
|
glyph.flags = array.array("B", [flagOnCurve] + [flagCubic] * 6)
|
|
glyph.endPtsOfContours = [6]
|
|
glyph.program = ttProgram.Program()
|
|
|
|
for i in range(2):
|
|
if i == 1:
|
|
glyph.compile(None)
|
|
|
|
pen = RecordingPen()
|
|
glyph.draw(pen, None)
|
|
|
|
assert pen.value == [
|
|
("moveTo", ((0, 0),)),
|
|
("curveTo", ((1, 0), (1, 0), (1.0, 0.5))),
|
|
("curveTo", ((1, 1), (1, 1), (0.5, 1.0))),
|
|
("curveTo", ((0, 1), (0, 1), (0, 0))),
|
|
("closePath", ()),
|
|
]
|
|
|
|
|
|
def build_interpolatable_glyphs(contours, *transforms):
|
|
# given a list of lists of (point, flag) tuples (one per contour), build a Glyph
|
|
# then make len(transforms) copies transformed accordingly, and return a
|
|
# list of such interpolatable glyphs.
|
|
glyph1 = Glyph()
|
|
glyph1.numberOfContours = len(contours)
|
|
glyph1.coordinates = GlyphCoordinates(
|
|
[pt for contour in contours for pt, _flag in contour]
|
|
)
|
|
glyph1.flags = array.array(
|
|
"B", [flag for contour in contours for _pt, flag in contour]
|
|
)
|
|
glyph1.endPtsOfContours = [
|
|
sum(len(contour) for contour in contours[: i + 1]) - 1
|
|
for i in range(len(contours))
|
|
]
|
|
result = [glyph1]
|
|
for t in transforms:
|
|
glyph = deepcopy(glyph1)
|
|
glyph.coordinates.transform((t[0:2], t[2:4]))
|
|
glyph.coordinates.translate(t[4:6])
|
|
result.append(glyph)
|
|
return result
|
|
|
|
|
|
def test_dropImpliedOnCurvePoints_all_quad_off_curves():
|
|
# Two interpolatable glyphs with same structure, the coordinates of one are 2x the
|
|
# other; all the on-curve points are impliable in each one, thus are dropped from
|
|
# both, leaving contours with off-curve points only.
|
|
glyph1, glyph2 = build_interpolatable_glyphs(
|
|
[
|
|
[
|
|
((0, 1), flagOnCurve),
|
|
((1, 1), 0),
|
|
((1, 0), flagOnCurve),
|
|
((1, -1), 0),
|
|
((0, -1), flagOnCurve),
|
|
((-1, -1), 0),
|
|
((-1, 0), flagOnCurve),
|
|
((-1, 1), 0),
|
|
],
|
|
[
|
|
((0, 2), flagOnCurve),
|
|
((2, 2), 0),
|
|
((2, 0), flagOnCurve),
|
|
((2, -2), 0),
|
|
((0, -2), flagOnCurve),
|
|
((-2, -2), 0),
|
|
((-2, 0), flagOnCurve),
|
|
((-2, 2), 0),
|
|
],
|
|
],
|
|
Transform().scale(2.0),
|
|
)
|
|
# also add an empty glyph (will be ignored); we use this trick for 'sparse' masters
|
|
glyph3 = Glyph()
|
|
glyph3.numberOfContours = 0
|
|
|
|
assert dropImpliedOnCurvePoints(glyph1, glyph2, glyph3) == {
|
|
0,
|
|
2,
|
|
4,
|
|
6,
|
|
8,
|
|
10,
|
|
12,
|
|
14,
|
|
}
|
|
|
|
assert glyph1.flags == glyph2.flags == array.array("B", [0, 0, 0, 0, 0, 0, 0, 0])
|
|
assert glyph1.coordinates == GlyphCoordinates(
|
|
[(1, 1), (1, -1), (-1, -1), (-1, 1), (2, 2), (2, -2), (-2, -2), (-2, 2)]
|
|
)
|
|
assert glyph2.coordinates == GlyphCoordinates(
|
|
[(2, 2), (2, -2), (-2, -2), (-2, 2), (4, 4), (4, -4), (-4, -4), (-4, 4)]
|
|
)
|
|
assert glyph1.endPtsOfContours == glyph2.endPtsOfContours == [3, 7]
|
|
assert glyph3.numberOfContours == 0
|
|
|
|
|
|
def test_dropImpliedOnCurvePoints_all_cubic_off_curves():
|
|
# same as above this time using cubic curves
|
|
glyph1, glyph2 = build_interpolatable_glyphs(
|
|
[
|
|
[
|
|
((0, 1), flagOnCurve),
|
|
((1, 1), flagCubic),
|
|
((1, 1), flagCubic),
|
|
((1, 0), flagOnCurve),
|
|
((1, -1), flagCubic),
|
|
((1, -1), flagCubic),
|
|
((0, -1), flagOnCurve),
|
|
((-1, -1), flagCubic),
|
|
((-1, -1), flagCubic),
|
|
((-1, 0), flagOnCurve),
|
|
((-1, 1), flagCubic),
|
|
((-1, 1), flagCubic),
|
|
]
|
|
],
|
|
Transform().translate(10.0),
|
|
)
|
|
glyph3 = Glyph()
|
|
glyph3.numberOfContours = 0
|
|
|
|
assert dropImpliedOnCurvePoints(glyph1, glyph2, glyph3) == {0, 3, 6, 9}
|
|
|
|
assert glyph1.flags == glyph2.flags == array.array("B", [flagCubic] * 8)
|
|
assert glyph1.coordinates == GlyphCoordinates(
|
|
[(1, 1), (1, 1), (1, -1), (1, -1), (-1, -1), (-1, -1), (-1, 1), (-1, 1)]
|
|
)
|
|
assert glyph2.coordinates == GlyphCoordinates(
|
|
[(11, 1), (11, 1), (11, -1), (11, -1), (9, -1), (9, -1), (9, 1), (9, 1)]
|
|
)
|
|
assert glyph1.endPtsOfContours == glyph2.endPtsOfContours == [7]
|
|
assert glyph3.numberOfContours == 0
|
|
|
|
|
|
def test_dropImpliedOnCurvePoints_not_all_impliable():
|
|
# same input as in in test_dropImpliedOnCurvePoints_all_quad_off_curves but we
|
|
# perturbate one of the glyphs such that the 2nd on-curve is no longer half-way
|
|
# between the neighboring off-curves.
|
|
glyph1, glyph2, glyph3 = build_interpolatable_glyphs(
|
|
[
|
|
[
|
|
((0, 1), flagOnCurve),
|
|
((1, 1), 0),
|
|
((1, 0), flagOnCurve),
|
|
((1, -1), 0),
|
|
((0, -1), flagOnCurve),
|
|
((-1, -1), 0),
|
|
((-1, 0), flagOnCurve),
|
|
((-1, 1), 0),
|
|
]
|
|
],
|
|
Transform().translate(10.0),
|
|
Transform().translate(10.0).scale(2.0),
|
|
)
|
|
p2 = glyph2.coordinates[2]
|
|
glyph2.coordinates[2] = (p2[0] + 2.0, p2[1] - 2.0)
|
|
|
|
assert dropImpliedOnCurvePoints(glyph1, glyph2, glyph3) == {
|
|
0,
|
|
# 2, this is NOT implied because it's no longer impliable for all glyphs
|
|
4,
|
|
6,
|
|
}
|
|
|
|
assert glyph2.flags == array.array("B", [0, flagOnCurve, 0, 0, 0])
|
|
|
|
|
|
def test_dropImpliedOnCurvePoints_all_empty_glyphs():
|
|
glyph1 = Glyph()
|
|
glyph1.numberOfContours = 0
|
|
glyph2 = Glyph()
|
|
glyph2.numberOfContours = 0
|
|
|
|
assert dropImpliedOnCurvePoints(glyph1, glyph2) == set()
|
|
|
|
|
|
def test_dropImpliedOnCurvePoints_incompatible_number_of_contours():
|
|
glyph1 = Glyph()
|
|
glyph1.numberOfContours = 1
|
|
glyph1.endPtsOfContours = [3]
|
|
glyph1.flags = array.array("B", [1, 1, 1, 1])
|
|
glyph1.coordinates = GlyphCoordinates([(0, 0), (1, 1), (2, 2), (3, 3)])
|
|
|
|
glyph2 = Glyph()
|
|
glyph2.numberOfContours = 2
|
|
glyph2.endPtsOfContours = [1, 3]
|
|
glyph2.flags = array.array("B", [1, 1, 1, 1])
|
|
glyph2.coordinates = GlyphCoordinates([(0, 0), (1, 1), (2, 2), (3, 3)])
|
|
|
|
with pytest.raises(ValueError, match="Incompatible numberOfContours"):
|
|
dropImpliedOnCurvePoints(glyph1, glyph2)
|
|
|
|
|
|
def test_dropImpliedOnCurvePoints_incompatible_flags():
|
|
glyph1 = Glyph()
|
|
glyph1.numberOfContours = 1
|
|
glyph1.endPtsOfContours = [3]
|
|
glyph1.flags = array.array("B", [1, 1, 1, 1])
|
|
glyph1.coordinates = GlyphCoordinates([(0, 0), (1, 1), (2, 2), (3, 3)])
|
|
|
|
glyph2 = Glyph()
|
|
glyph2.numberOfContours = 1
|
|
glyph2.endPtsOfContours = [3]
|
|
glyph2.flags = array.array("B", [0, 0, 0, 0])
|
|
glyph2.coordinates = GlyphCoordinates([(0, 0), (1, 1), (2, 2), (3, 3)])
|
|
|
|
with pytest.raises(ValueError, match="Incompatible flags"):
|
|
dropImpliedOnCurvePoints(glyph1, glyph2)
|
|
|
|
|
|
def test_dropImpliedOnCurvePoints_incompatible_endPtsOfContours():
|
|
glyph1 = Glyph()
|
|
glyph1.numberOfContours = 2
|
|
glyph1.endPtsOfContours = [2, 6]
|
|
glyph1.flags = array.array("B", [1, 1, 1, 1, 1, 1, 1])
|
|
glyph1.coordinates = GlyphCoordinates([(i, i) for i in range(7)])
|
|
|
|
glyph2 = Glyph()
|
|
glyph2.numberOfContours = 2
|
|
glyph2.endPtsOfContours = [3, 6]
|
|
glyph2.flags = array.array("B", [1, 1, 1, 1, 1, 1, 1])
|
|
glyph2.coordinates = GlyphCoordinates([(i, i) for i in range(7)])
|
|
|
|
with pytest.raises(ValueError, match="Incompatible endPtsOfContours"):
|
|
dropImpliedOnCurvePoints(glyph1, glyph2)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
import sys
|
|
|
|
sys.exit(unittest.main())
|