Debian Codegraph @

tests/trace2svg

raw
1 #!/usr/bin/env python
2 # SPDX-License-Identifier: MIT OR MPL-2.0 OR LGPL-2.1-or-later OR GPL-2.0-or-later
3 # Copyright 2016, SIL International, All rights reserved.
4
5
6 from fontTools import ttLib
7 from fontTools.pens.basePen import BasePen
8 from fontTools.misc import arrayTools
9 from argparse import ArgumentParser
10 from xml.etree import cElementTree as ET
11 import json, copy
12
13 class SVGPen(BasePen) :
14
15 def __init__(self, glyphSet, scale=1.0) :
16 super(SVGPen, self).__init__(glyphSet);
17 self.__commands = []
18 self.__scale = scale
19
20 def __str__(self) :
21 return " ".join(self.__commands)
22
23 def scale(self, pt) :
24 return (pt[0] * self.__scale, pt[1] * self.__scale)
25
26 def _moveTo(self, pt):
27 self.__commands.append("M {0[0]} {0[1]}".format(self.scale(pt)))
28
29 def _lineTo(self, pt):
30 self.__commands.append("L {0[0]} {0[1]}".format(self.scale(pt)))
31
32 def _curveToOne(self, pt1, pt2, pt3) :
33 self.__commands.append("C {0[0]} {0[1]} {1[0]} {1[1]} {2[0]} {2[1]}".format(self.scale(pt1), self.scale(pt2), self.scale(pt3)))
34
35 def _closePath(self) :
36 self.__commands.append("Z")
37
38 def clear(self) :
39 self.__commands = []
40
41 class FGlyphs(object) :
42
43 def __init__(self, font, scale=1.0) :
44 self._font = font
45 self._glyphSet = font.getGlyphSet()
46 self._bbox = (0, 0, 0, 0)
47 self._glyphs = set()
48 self._scale = scale
49
50 def addGlyph(self, gid, pt) :
51 if gid >= self._font['maxp'].numGlyphs : return
52 gname = self._font.getGlyphName(gid)
53 g = self._glyphSet[gname]._glyph
54 if g is None or not hasattr(g, 'xMin') :
55 gbox = (0, 0, 0, 0)
56 else :
57 gbox = (g.xMin, g.yMin, g.xMax, g.yMax)
58 self._bbox = arrayTools.unionRect(self._bbox, arrayTools.offsetRect(gbox, pt[0], pt[1]))
59 self._glyphs.add(gname)
60
61 def bbox(self) :
62 # return map(lambda x: x*self._scale, self._bbox)
63 return self._bbox
64
65 def asSVG(self, scale) :
66 res = "<defs><g>\n"
67 p = SVGPen(self._glyphSet, scale)
68 for k in sorted(self._glyphs) :
69 res = res + '<symbol overflow="visible" id="{}">\n'.format(k)
70 g = self._glyphSet[k]
71 p.clear()
72 g.draw(p)
73 res = res + '<path style="stroke:none;" d="' + str(p) + '"/>\n</symbol>\n'
74 return res + '</g></defs>\n'
75
76 class Slot(object) :
77
78 def __init__(self, ident, font, before=None, after=None) :
79 self.ident = ident
80 self.font = font
81 self.before = before
82 self.after = after
83 self.events = []
84 self.final = 0
85
86 def addEvent(self, gid, pt, t) :
87 if gid >= self.font['maxp'].numGlyphs : return
88 self.events.append((gid, pt, t))
89 if t > self.final : self.final = t
90
91 def asSVG(self, final, scale, indent=' ', dur=1, trans=.5) :
92 res = '{}<g id="{}">\n'.format(indent, self.ident)
93 # res = ""
94 indent += ' '
95 gid = None
96 currt = 0
97 finalt = 0
98 currpos = (0, 0)
99 start = 0
100 keys = []
101 valx = []
102 valy = []
103 for i, e in enumerate(self.events + [[None, None, None]]):
104 currt = e[2]
105 if gid != e[0] :
106 if gid != None :
107 if len(keys) > 1 :
108 keys.append(1)
109 valx.append(valx[-1])
110 valy.append(valy[-1])
111 ks = ';'.join(map(str,keys))
112 xs = ';'.join(map(str,valx))
113 ys = ';'.join(map(str,valy))
114 res += '{0} <animate attributeName="x" attributeType="XML" begin="{1}s" dur="{2}s" keyTimes="{3}" values="{4}" fill="freeze"/>\n'.format(indent, start * dur, (finalt-start) * dur, ks, xs)
115 res += '{0} <animate attributeName="y" attributeType="XML" begin="{1}s" dur="{2}s" keyTimes="{3}" values="{4}" fill="freeze"/>\n'.format(indent, start * dur, (finalt-start) * dur, ks, ys)
116 res += '{}</use>\n'.format(indent)
117
118 if e[0] == None : break
119 gid = e[0]
120 start = e[2]
121 res += '{0}<use xlink:href="#{1}" x="{2}" y="{3}" visibility="hidden">\n'.format(indent,
122 self.font.getGlyphName(gid), e[1][0]*scale, e[1][1]*scale)
123 currpos = e[1]
124 valx = [e[1][0] * scale]
125 valy = [e[1][1] * scale]
126 keys = [0]
127 finalt = self.final + 1
128 if i < len(self.events) - 1 :
129 for temp in self.events[i+1:] :
130 if temp[0] != gid :
131 finalt = temp[2]
132 break
133 res += '{0} <set attributeName="visibility" attributeType="CSS" to="visible" begin="{1}s" dur="{2}s" fill="{3}"/>\n'.format(indent, start*dur, (finalt-start)*dur, "freeze" if finalt >= final else "reset")
134 elif e[1] != currpos :
135 valx.append(valx[-1])
136 valx.append(e[1][0] * scale)
137 valy.append(valy[-1])
138 valy.append(e[1][1] * scale)
139 currpos = e[1]
140 keys.append((float(currt)-start-trans/dur)/(finalt-start))
141 keys.append((float(currt)-start)/(finalt-start))
142 return res + '{0}</g>\n'.format(indent[:-2])
143 # return res
144
145
146 class SlotSequence(object) :
147
148 def __init__(self, font) :
149 self.allSlots = {}
150 self.slots = []
151 self.font = font
152
153 def addRun(self, run, t=0) :
154 for i in range(len(run)) :
155 r = run[i]
156 if r[0] not in self.allSlots :
157 before = run[i-1] if i > 0 else None
158 after = run[i+1] if i < len(run) - 1 else None
159 slot = Slot(r[0], self.font, before=before, after=after)
160 self.allSlots[r[0]] = slot
161 try :
162 pb = self.slots.index(before)
163 except ValueError :
164 pb = -1
165 try :
166 pa = self.slots.index(after)
167 except ValueError :
168 pa = -1
169 if pa == -1 :
170 self.slots.append(r[0])
171 elif pb == -1 :
172 self.slots.insert(0, r[0])
173 elif pa < pb :
174 raise ValueError('bad slot order')
175 else :
176 self.slots.insert(pa, r[0])
177 else :
178 slot = self.allSlots[r[0]]
179 slot.addEvent(r[1], r[2], t)
180
181 def asSVG(self, final, scale, bbox, dur=1, trans=0.5) :
182 res = '<g id="surface1" transform="matrix(1,0,0,-1,{},{})">\n'.format(-bbox[0], bbox[3] + 10)
183 res += ' <rect x="{}" y="{}" width="{}" height="{}" style="fill:white;stroke:none"/>\n'.format(
184 bbox[0], bbox[1], bbox[2]-bbox[0], bbox[3] + 10)
185 res += ' <g style="fill:black">\n'
186 for s in self.slots :
187 res += self.allSlots[s].asSVG(final, scale, indent=' ', dur=dur, trans=trans)
188 res += ' </g>\n'
189 res += '</g>'
190 return res
191
192 def closeEnough(run1, run2, errorx, errory) :
193 if len(run1) != len(run2) : return False
194 for r1, r2 in zip(run1, run2) :
195 if r1[0] != r2[0] or r1[1] != r2[1] : return False
196 if abs(r1[2][0] - r2[2][0]) > errorx or abs(r1[2][1] - r2[2][1]) > errory : return False
197 return True
198
199 def processrun(ss, fg, curr, lastrun, t, error=0, pseudomap={}) :
200 run = []
201 for j in curr :
202 gid = int(j['gid'])
203 gid = pseudomap.get(gid, gid)
204 fg.addGlyph(gid, j['origin'])
205 run.append((j['id'], gid, j['origin']))
206 bbox = fg.bbox()
207 if closeEnough(run, lastrun, bbox[2] * error, bbox[3] * error) :
208 return lastrun, t
209 ss.addRun(run, t=t)
210 return run, t+1
211
212 parser = ArgumentParser()
213 parser.add_argument('infile', help='Input trace.json file')
214 parser.add_argument('-f','--font', help='Font to render')
215 parser.add_argument('-o','--output', help='Output file')
216 parser.add_argument('-s','--scale', default=1, type=float, help='Multiplier for all values')
217 parser.add_argument('-d','--duration', default=1, type=float, help='Time between events in s')
218 parser.add_argument('-t','--transition', default=0.5, type=float, help='Transition time in s')
219 parser.add_argument('-e','--error',default=0.04, type=float, help='What constitutes identical?')
220 parser.add_argument('-g','--gdx', help='GDX file for font to help with pseudoglyphs')
221 args = parser.parse_args()
222
223 def scale(pt) : return (pt[0] * args.scale, pt[1] * args.scale)
224 font = ttLib.TTFont(args.font)
225 fg = FGlyphs(font, scale=args.scale)
226
227 pseudomap = {}
228 if args.gdx :
229 ingdx = open(args.gdx, "r")
230 et = ET.parse(ingdx)
231 ingdx.close()
232 for e in et.findall('.//glyph') :
233 g = e.get('glyphid', None)
234 p = e.find('glyphAttrValue[@name="*actualForPseudo*"]')
235 if g is not None and p is not None :
236 pseudomap[int(g)] = int(p.get('value', 0))
237
238 tracefile = open(args.infile, "r")
239 trace = json.load(tracefile)
240 tracefile.close()
241
242 fout = open(args.output, "w")
243 fout.write('<?xml version="1.0"?>\n')
244 fout.write('<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" version="1.1">\n')
245
246 t = 0
247 ss = SlotSequence(font)
248 lastrun = []
249 for p in trace[-1]['passes'] :
250 curr = p['slots'][:]
251 lastrun, t = processrun(ss, fg, curr, lastrun, t, error=args.error, pseudomap=pseudomap)
252 if 'rules' in p :
253 for rule in p['rules'] :
254 if rule['output'] is None : continue
255 start = 0
256 end = len(curr)
257 for i, r in enumerate(curr) :
258 if r['id'] == rule['output']['range']['start'] :
259 start = i
260 if r['id'] == rule['output']['range']['end'] :
261 end = i
262 break
263 curr[start:end] = rule['output']['slots'][:]
264 lastrun, t = processrun(ss, fg, curr, lastrun, t, error=args.error, pseudomap=pseudomap)
265 if 'collisions' in p :
266 base = copy.deepcopy(curr)
267 for coll in p['collisions'] :
268 if 'moves' not in coll : continue
269 for m in coll['moves'] :
270 s = m['slot']
271 adj = m['result']
272 for i, r in enumerate(curr) :
273 if r['id'] == s :
274 if 'vectors' in m :
275 r['origin'] = map (lambda x : int(x[0]) + int(x[1]), zip(base[i]['origin'], adj))
276 elif 'slices' in m :
277 r['origin'] = (int(base[i]['origin'][0]) + int(adj), r['origin'][1])
278 break
279 lastrun, t = processrun(ss, fg, curr, lastrun, t, error=args.error, pseudomap=pseudomap)
280
281 strjson = trace[-1]['output']
282 lastrun, t = processrun(ss, fg, strjson, lastrun, t, error=0, pseudomap=pseudomap)
283 bbox = map(lambda x:x * args.scale, fg.bbox())
284
285 fout.write(fg.asSVG(args.scale))
286 fout.write(ss.asSVG(t, args.scale, bbox, dur=args.duration, trans=args.transition))
287
288 fout.write('</svg>\n')
289 fout.close()