659 lines
23 KiB
Python
659 lines
23 KiB
Python
from fontTools.misc.fixedTools import otRound
|
|
from fontTools.misc.testTools import getXML, parseXML
|
|
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,
|
|
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 io import StringIO
|
|
import itertools
|
|
import pytest
|
|
import re
|
|
import os
|
|
import unittest
|
|
|
|
|
|
class GlyphCoordinatesTest(object):
|
|
|
|
def test_translate(self):
|
|
g = GlyphCoordinates([(1,2)])
|
|
g.translate((.5,0))
|
|
assert g == GlyphCoordinates([(1.5,2.0)])
|
|
|
|
def test_scale(self):
|
|
g = GlyphCoordinates([(1,2)])
|
|
g.scale((.5,0))
|
|
assert g == GlyphCoordinates([(0.5,0.0)])
|
|
|
|
def test_transform(self):
|
|
g = GlyphCoordinates([(1,2)])
|
|
g.transform(((.5,0),(.2,.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([(.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 += (.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 -= (.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,.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 /= (.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)])
|
|
assert bool(g) == True
|
|
g = GlyphCoordinates([(0,0), (1,0)])
|
|
assert bool(g) == True
|
|
g = GlyphCoordinates([(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")
|
|
|
|
|
|
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_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
|
|
self.assertEqual(
|
|
font["glyf"].getPhantomPoints(".notdef", font, 0),
|
|
[(0, 0), (100, 0), (0, 0), (0, -1000)]
|
|
)
|
|
|
|
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
|
|
|
|
|
|
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_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")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
import sys
|
|
sys.exit(unittest.main())
|