| # Copyright 2016 Google Inc. All Rights Reserved. |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| |
| from . import CUBIC_GLYPHS |
| from fontTools.pens.pointPen import PointToSegmentPen, SegmentToPointPen |
| from math import isclose |
| import unittest |
| |
| |
| class BaseDummyPen(object): |
| """Base class for pens that record the commands they are called with.""" |
| |
| def __init__(self, *args, **kwargs): |
| self.commands = [] |
| |
| def __str__(self): |
| """Return the pen commands as a string of python code.""" |
| return _repr_pen_commands(self.commands) |
| |
| def addComponent(self, glyphName, transformation, **kwargs): |
| self.commands.append(('addComponent', (glyphName, transformation), kwargs)) |
| |
| |
| class DummyPen(BaseDummyPen): |
| """A SegmentPen that records the commands it's called with.""" |
| |
| def moveTo(self, pt): |
| self.commands.append(('moveTo', (pt,), {})) |
| |
| def lineTo(self, pt): |
| self.commands.append(('lineTo', (pt,), {})) |
| |
| def curveTo(self, *points): |
| self.commands.append(('curveTo', points, {})) |
| |
| def qCurveTo(self, *points): |
| self.commands.append(('qCurveTo', points, {})) |
| |
| def closePath(self): |
| self.commands.append(('closePath', tuple(), {})) |
| |
| def endPath(self): |
| self.commands.append(('endPath', tuple(), {})) |
| |
| |
| class DummyPointPen(BaseDummyPen): |
| """A PointPen that records the commands it's called with.""" |
| |
| def beginPath(self, **kwargs): |
| self.commands.append(('beginPath', tuple(), kwargs)) |
| |
| def endPath(self): |
| self.commands.append(('endPath', tuple(), {})) |
| |
| def addPoint(self, pt, segmentType=None, smooth=False, name=None, **kwargs): |
| kwargs['segmentType'] = str(segmentType) if segmentType else None |
| kwargs['smooth'] = smooth |
| kwargs['name'] = name |
| self.commands.append(('addPoint', (pt,), kwargs)) |
| |
| |
| class DummyGlyph(object): |
| """Provides a minimal interface for storing a glyph's outline data in a |
| SegmentPen-oriented way. The glyph's outline consists in the list of |
| SegmentPen commands required to draw it. |
| """ |
| |
| # the SegmentPen class used to draw on this glyph type |
| DrawingPen = DummyPen |
| |
| def __init__(self, glyph=None): |
| """If another glyph (i.e. any object having a 'draw' method) is given, |
| its outline data is copied to self. |
| """ |
| self._pen = self.DrawingPen() |
| self.outline = self._pen.commands |
| if glyph: |
| self.appendGlyph(glyph) |
| |
| def appendGlyph(self, glyph): |
| """Copy another glyph's outline onto self.""" |
| glyph.draw(self._pen) |
| |
| def getPen(self): |
| """Return the SegmentPen that can 'draw' on this glyph.""" |
| return self._pen |
| |
| def getPointPen(self): |
| """Return a PointPen adapter that can 'draw' on this glyph.""" |
| return PointToSegmentPen(self._pen) |
| |
| def draw(self, pen): |
| """Use another SegmentPen to replay the glyph's outline commands.""" |
| if self.outline: |
| for cmd, args, kwargs in self.outline: |
| getattr(pen, cmd)(*args, **kwargs) |
| |
| def drawPoints(self, pointPen): |
| """Use another PointPen to replay the glyph's outline commands, |
| indirectly through an adapter. |
| """ |
| pen = SegmentToPointPen(pointPen) |
| self.draw(pen) |
| |
| def __eq__(self, other): |
| """Return True if 'other' glyph's outline is the same as self.""" |
| if hasattr(other, 'outline'): |
| return self.outline == other.outline |
| elif hasattr(other, 'draw'): |
| return self.outline == self.__class__(other).outline |
| return NotImplemented |
| |
| def __ne__(self, other): |
| """Return True if 'other' glyph's outline is different from self.""" |
| return not (self == other) |
| |
| def approx(self, other, rel_tol=1e-12): |
| if hasattr(other, 'outline'): |
| outline2 == other.outline |
| elif hasattr(other, 'draw'): |
| outline2 = self.__class__(other).outline |
| else: |
| raise TypeError(type(other).__name__) |
| outline1 = self.outline |
| if len(outline1) != len(outline2): |
| return False |
| for (cmd1, arg1, kwd1), (cmd2, arg2, kwd2) in zip(outline1, outline2): |
| if cmd1 != cmd2: |
| return False |
| if kwd1 != kwd2: |
| return False |
| if arg1: |
| if isinstance(arg1[0], tuple): |
| if not arg2 or not isinstance(arg2[0], tuple): |
| return False |
| for (x1, y1), (x2, y2) in zip(arg1, arg2): |
| if ( |
| not isclose(x1, x2, rel_tol=rel_tol) or |
| not isclose(y1, y2, rel_tol=rel_tol) |
| ): |
| return False |
| elif arg1 != arg2: |
| return False |
| elif arg2: |
| return False |
| return True |
| |
| def __str__(self): |
| """Return commands making up the glyph's outline as a string.""" |
| return str(self._pen) |
| |
| |
| class DummyPointGlyph(DummyGlyph): |
| """Provides a minimal interface for storing a glyph's outline data in a |
| PointPen-oriented way. The glyph's outline consists in the list of |
| PointPen commands required to draw it. |
| """ |
| |
| # the PointPen class used to draw on this glyph type |
| DrawingPen = DummyPointPen |
| |
| def appendGlyph(self, glyph): |
| """Copy another glyph's outline onto self.""" |
| glyph.drawPoints(self._pen) |
| |
| def getPen(self): |
| """Return a SegmentPen adapter that can 'draw' on this glyph.""" |
| return SegmentToPointPen(self._pen) |
| |
| def getPointPen(self): |
| """Return the PointPen that can 'draw' on this glyph.""" |
| return self._pen |
| |
| def draw(self, pen): |
| """Use another SegmentPen to replay the glyph's outline commands, |
| indirectly through an adapter. |
| """ |
| pointPen = PointToSegmentPen(pen) |
| self.drawPoints(pointPen) |
| |
| def drawPoints(self, pointPen): |
| """Use another PointPen to replay the glyph's outline commands.""" |
| if self.outline: |
| for cmd, args, kwargs in self.outline: |
| getattr(pointPen, cmd)(*args, **kwargs) |
| |
| |
| def _repr_pen_commands(commands): |
| """ |
| >>> print(_repr_pen_commands([ |
| ... ('moveTo', tuple(), {}), |
| ... ('lineTo', ((1.0, 0.1),), {}), |
| ... ('curveTo', ((1.0, 0.1), (2.0, 0.2), (3.0, 0.3)), {}) |
| ... ])) |
| pen.moveTo() |
| pen.lineTo((1, 0.1)) |
| pen.curveTo((1, 0.1), (2, 0.2), (3, 0.3)) |
| |
| >>> print(_repr_pen_commands([ |
| ... ('beginPath', tuple(), {}), |
| ... ('addPoint', ((1.0, 0.1),), |
| ... {"segmentType":"line", "smooth":True, "name":"test", "z":1}), |
| ... ])) |
| pen.beginPath() |
| pen.addPoint((1, 0.1), name='test', segmentType='line', smooth=True, z=1) |
| |
| >>> print(_repr_pen_commands([ |
| ... ('addComponent', ('A', (1, 0, 0, 1, 0, 0)), {}) |
| ... ])) |
| pen.addComponent('A', (1, 0, 0, 1, 0, 0)) |
| """ |
| s = [] |
| for cmd, args, kwargs in commands: |
| if args: |
| if isinstance(args[0], tuple): |
| # cast float to int if there're no digits after decimal point, |
| # and round floats to 12 decimal digits (more than enough) |
| args = [ |
| tuple((int(v) if int(v) == v else round(v, 12)) for v in pt) |
| for pt in args |
| ] |
| args = ", ".join(repr(a) for a in args) |
| if kwargs: |
| kwargs = ", ".join("%s=%r" % (k, v) |
| for k, v in sorted(kwargs.items())) |
| if args and kwargs: |
| s.append("pen.%s(%s, %s)" % (cmd, args, kwargs)) |
| elif args: |
| s.append("pen.%s(%s)" % (cmd, args)) |
| elif kwargs: |
| s.append("pen.%s(%s)" % (cmd, kwargs)) |
| else: |
| s.append("pen.%s()" % cmd) |
| return "\n".join(s) |
| |
| |
| class TestDummyGlyph(unittest.TestCase): |
| |
| def test_equal(self): |
| # verify that the copy and the copy of the copy are equal to |
| # the source glyph's outline, as well as to each other |
| source = CUBIC_GLYPHS['a'] |
| copy = DummyGlyph(source) |
| copy2 = DummyGlyph(copy) |
| self.assertEqual(source, copy) |
| self.assertEqual(source, copy2) |
| self.assertEqual(copy, copy2) |
| # assert equality doesn't hold any more after modification |
| copy.outline.pop() |
| self.assertNotEqual(source, copy) |
| self.assertNotEqual(copy, copy2) |
| |
| |
| class TestDummyPointGlyph(unittest.TestCase): |
| |
| def test_equal(self): |
| # same as above but using the PointPen protocol |
| source = CUBIC_GLYPHS['a'] |
| copy = DummyPointGlyph(source) |
| copy2 = DummyPointGlyph(copy) |
| self.assertEqual(source, copy) |
| self.assertEqual(source, copy2) |
| self.assertEqual(copy, copy2) |
| copy.outline.pop() |
| self.assertNotEqual(source, copy) |
| self.assertNotEqual(copy, copy2) |
| |
| |
| if __name__ == "__main__": |
| unittest.main() |
