Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.8/site-packages/fontTools/pens/transformPen.py: 33%

1from fontTools.pens.filterPen import FilterPen, FilterPointPen 

2 

3 

4__all__ = ["TransformPen", "TransformPointPen"] 

5 

6 

7class TransformPen(FilterPen): 

8 

9 """Pen that transforms all coordinates using a Affine transformation, 

10 and passes them to another pen. 

11 """ 

12 

13 def __init__(self, outPen, transformation): 

14 """The 'outPen' argument is another pen object. It will receive the 

15 transformed coordinates. The 'transformation' argument can either 

16 be a six-tuple, or a fontTools.misc.transform.Transform object. 

17 """ 

18 super(TransformPen, self).__init__(outPen) 

19 if not hasattr(transformation, "transformPoint"): 

20 from fontTools.misc.transform import Transform 

21 

22 transformation = Transform(*transformation) 

23 self._transformation = transformation 

24 self._transformPoint = transformation.transformPoint 

25 self._stack = [] 

26 

27 def moveTo(self, pt): 

28 self._outPen.moveTo(self._transformPoint(pt)) 

29 

30 def lineTo(self, pt): 

31 self._outPen.lineTo(self._transformPoint(pt)) 

32 

33 def curveTo(self, *points): 

34 self._outPen.curveTo(*self._transformPoints(points)) 

35 

36 def qCurveTo(self, *points): 

37 if points[-1] is None: 

38 points = self._transformPoints(points[:-1]) + [None] 

39 else: 

40 points = self._transformPoints(points) 

41 self._outPen.qCurveTo(*points) 

42 

43 def _transformPoints(self, points): 

44 transformPoint = self._transformPoint 

45 return [transformPoint(pt) for pt in points] 

46 

47 def closePath(self): 

48 self._outPen.closePath() 

49 

50 def endPath(self): 

51 self._outPen.endPath() 

52 

53 def addComponent(self, glyphName, transformation): 

54 transformation = self._transformation.transform(transformation) 

55 self._outPen.addComponent(glyphName, transformation) 

56 

57 

58class TransformPointPen(FilterPointPen): 

59 """PointPen that transforms all coordinates using a Affine transformation, 

60 and passes them to another PointPen. 

61 

62 >>> from fontTools.pens.recordingPen import RecordingPointPen 

63 >>> rec = RecordingPointPen() 

64 >>> pen = TransformPointPen(rec, (2, 0, 0, 2, -10, 5)) 

65 >>> v = iter(rec.value) 

66 >>> pen.beginPath(identifier="contour-0") 

67 >>> next(v) 

68 ('beginPath', (), {'identifier': 'contour-0'}) 

69 >>> pen.addPoint((100, 100), "line") 

70 >>> next(v) 

71 ('addPoint', ((190, 205), 'line', False, None), {}) 

72 >>> pen.endPath() 

73 >>> next(v) 

74 ('endPath', (), {}) 

75 >>> pen.addComponent("a", (1, 0, 0, 1, -10, 5), identifier="component-0") 

76 >>> next(v) 

77 ('addComponent', ('a', <Transform [2 0 0 2 -30 15]>), {'identifier': 'component-0'}) 

78 """ 

79 

80 def __init__(self, outPointPen, transformation): 

81 """The 'outPointPen' argument is another point pen object. 

82 It will receive the transformed coordinates. 

83 The 'transformation' argument can either be a six-tuple, or a 

84 fontTools.misc.transform.Transform object. 

85 """ 

86 super().__init__(outPointPen) 

87 if not hasattr(transformation, "transformPoint"): 

88 from fontTools.misc.transform import Transform 

89 

90 transformation = Transform(*transformation) 

91 self._transformation = transformation 

92 self._transformPoint = transformation.transformPoint 

93 

94 def addPoint(self, pt, segmentType=None, smooth=False, name=None, **kwargs): 

95 self._outPen.addPoint( 

96 self._transformPoint(pt), segmentType, smooth, name, **kwargs 

97 ) 

98 

99 def addComponent(self, baseGlyphName, transformation, **kwargs): 

100 transformation = self._transformation.transform(transformation) 

101 self._outPen.addComponent(baseGlyphName, transformation, **kwargs) 

102 

103 

104if __name__ == "__main__": 

105 from fontTools.pens.basePen import _TestPen 

106 

107 pen = TransformPen(_TestPen(None), (2, 0, 0.5, 2, -10, 0)) 

108 pen.moveTo((0, 0)) 

109 pen.lineTo((0, 100)) 

110 pen.curveTo((50, 75), (60, 50), (50, 25), (0, 0)) 

111 pen.closePath()