| 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() |