#!/usr/bin/env python # SPDX-License-Identifier: MIT OR MPL-2.0 OR LGPL-2.1-or-later OR GPL-2.0-or-later # Copyright 2016, SIL International, All rights reserved. from fontTools import ttLib from fontTools.pens.basePen import BasePen from fontTools.misc import arrayTools from argparse import ArgumentParser from xml.etree import cElementTree as ET import json, copy class SVGPen(BasePen) : def __init__(self, glyphSet, scale=1.0) : super(SVGPen, self).__init__(glyphSet); self.__commands = [] self.__scale = scale def __str__(self) : return " ".join(self.__commands) def scale(self, pt) : return (pt[0] * self.__scale, pt[1] * self.__scale) def _moveTo(self, pt): self.__commands.append("M {0[0]} {0[1]}".format(self.scale(pt))) def _lineTo(self, pt): self.__commands.append("L {0[0]} {0[1]}".format(self.scale(pt))) def _curveToOne(self, pt1, pt2, pt3) : 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))) def _closePath(self) : self.__commands.append("Z") def clear(self) : self.__commands = [] class FGlyphs(object) : def __init__(self, font, scale=1.0) : self._font = font self._glyphSet = font.getGlyphSet() self._bbox = (0, 0, 0, 0) self._glyphs = set() self._scale = scale def addGlyph(self, gid, pt) : if gid >= self._font['maxp'].numGlyphs : return gname = self._font.getGlyphName(gid) g = self._glyphSet[gname]._glyph if g is None or not hasattr(g, 'xMin') : gbox = (0, 0, 0, 0) else : gbox = (g.xMin, g.yMin, g.xMax, g.yMax) self._bbox = arrayTools.unionRect(self._bbox, arrayTools.offsetRect(gbox, pt[0], pt[1])) self._glyphs.add(gname) def bbox(self) : # return map(lambda x: x*self._scale, self._bbox) return self._bbox def asSVG(self, scale) : res = "\n" p = SVGPen(self._glyphSet, scale) for k in sorted(self._glyphs) : res = res + '\n'.format(k) g = self._glyphSet[k] p.clear() g.draw(p) res = res + '\n\n' return res + '\n' class Slot(object) : def __init__(self, ident, font, before=None, after=None) : self.ident = ident self.font = font self.before = before self.after = after self.events = [] self.final = 0 def addEvent(self, gid, pt, t) : if gid >= self.font['maxp'].numGlyphs : return self.events.append((gid, pt, t)) if t > self.final : self.final = t def asSVG(self, final, scale, indent=' ', dur=1, trans=.5) : res = '{}\n'.format(indent, self.ident) # res = "" indent += ' ' gid = None currt = 0 finalt = 0 currpos = (0, 0) start = 0 keys = [] valx = [] valy = [] for i, e in enumerate(self.events + [[None, None, None]]): currt = e[2] if gid != e[0] : if gid != None : if len(keys) > 1 : keys.append(1) valx.append(valx[-1]) valy.append(valy[-1]) ks = ';'.join(map(str,keys)) xs = ';'.join(map(str,valx)) ys = ';'.join(map(str,valy)) res += '{0} \n'.format(indent, start * dur, (finalt-start) * dur, ks, xs) res += '{0} \n'.format(indent, start * dur, (finalt-start) * dur, ks, ys) res += '{}\n'.format(indent) if e[0] == None : break gid = e[0] start = e[2] res += '{0}\n'.format(indent, self.font.getGlyphName(gid), e[1][0]*scale, e[1][1]*scale) currpos = e[1] valx = [e[1][0] * scale] valy = [e[1][1] * scale] keys = [0] finalt = self.final + 1 if i < len(self.events) - 1 : for temp in self.events[i+1:] : if temp[0] != gid : finalt = temp[2] break res += '{0} \n'.format(indent, start*dur, (finalt-start)*dur, "freeze" if finalt >= final else "reset") elif e[1] != currpos : valx.append(valx[-1]) valx.append(e[1][0] * scale) valy.append(valy[-1]) valy.append(e[1][1] * scale) currpos = e[1] keys.append((float(currt)-start-trans/dur)/(finalt-start)) keys.append((float(currt)-start)/(finalt-start)) return res + '{0}\n'.format(indent[:-2]) # return res class SlotSequence(object) : def __init__(self, font) : self.allSlots = {} self.slots = [] self.font = font def addRun(self, run, t=0) : for i in range(len(run)) : r = run[i] if r[0] not in self.allSlots : before = run[i-1] if i > 0 else None after = run[i+1] if i < len(run) - 1 else None slot = Slot(r[0], self.font, before=before, after=after) self.allSlots[r[0]] = slot try : pb = self.slots.index(before) except ValueError : pb = -1 try : pa = self.slots.index(after) except ValueError : pa = -1 if pa == -1 : self.slots.append(r[0]) elif pb == -1 : self.slots.insert(0, r[0]) elif pa < pb : raise ValueError('bad slot order') else : self.slots.insert(pa, r[0]) else : slot = self.allSlots[r[0]] slot.addEvent(r[1], r[2], t) def asSVG(self, final, scale, bbox, dur=1, trans=0.5) : res = '\n'.format(-bbox[0], bbox[3] + 10) res += ' \n'.format( bbox[0], bbox[1], bbox[2]-bbox[0], bbox[3] + 10) res += ' \n' for s in self.slots : res += self.allSlots[s].asSVG(final, scale, indent=' ', dur=dur, trans=trans) res += ' \n' res += '' return res def closeEnough(run1, run2, errorx, errory) : if len(run1) != len(run2) : return False for r1, r2 in zip(run1, run2) : if r1[0] != r2[0] or r1[1] != r2[1] : return False if abs(r1[2][0] - r2[2][0]) > errorx or abs(r1[2][1] - r2[2][1]) > errory : return False return True def processrun(ss, fg, curr, lastrun, t, error=0, pseudomap={}) : run = [] for j in curr : gid = int(j['gid']) gid = pseudomap.get(gid, gid) fg.addGlyph(gid, j['origin']) run.append((j['id'], gid, j['origin'])) bbox = fg.bbox() if closeEnough(run, lastrun, bbox[2] * error, bbox[3] * error) : return lastrun, t ss.addRun(run, t=t) return run, t+1 parser = ArgumentParser() parser.add_argument('infile', help='Input trace.json file') parser.add_argument('-f','--font', help='Font to render') parser.add_argument('-o','--output', help='Output file') parser.add_argument('-s','--scale', default=1, type=float, help='Multiplier for all values') parser.add_argument('-d','--duration', default=1, type=float, help='Time between events in s') parser.add_argument('-t','--transition', default=0.5, type=float, help='Transition time in s') parser.add_argument('-e','--error',default=0.04, type=float, help='What constitutes identical?') parser.add_argument('-g','--gdx', help='GDX file for font to help with pseudoglyphs') args = parser.parse_args() def scale(pt) : return (pt[0] * args.scale, pt[1] * args.scale) font = ttLib.TTFont(args.font) fg = FGlyphs(font, scale=args.scale) pseudomap = {} if args.gdx : ingdx = open(args.gdx, "r") et = ET.parse(ingdx) ingdx.close() for e in et.findall('.//glyph') : g = e.get('glyphid', None) p = e.find('glyphAttrValue[@name="*actualForPseudo*"]') if g is not None and p is not None : pseudomap[int(g)] = int(p.get('value', 0)) tracefile = open(args.infile, "r") trace = json.load(tracefile) tracefile.close() fout = open(args.output, "w") fout.write('\n') fout.write('\n') t = 0 ss = SlotSequence(font) lastrun = [] for p in trace[-1]['passes'] : curr = p['slots'][:] lastrun, t = processrun(ss, fg, curr, lastrun, t, error=args.error, pseudomap=pseudomap) if 'rules' in p : for rule in p['rules'] : if rule['output'] is None : continue start = 0 end = len(curr) for i, r in enumerate(curr) : if r['id'] == rule['output']['range']['start'] : start = i if r['id'] == rule['output']['range']['end'] : end = i break curr[start:end] = rule['output']['slots'][:] lastrun, t = processrun(ss, fg, curr, lastrun, t, error=args.error, pseudomap=pseudomap) if 'collisions' in p : base = copy.deepcopy(curr) for coll in p['collisions'] : if 'moves' not in coll : continue for m in coll['moves'] : s = m['slot'] adj = m['result'] for i, r in enumerate(curr) : if r['id'] == s : if 'vectors' in m : r['origin'] = map (lambda x : int(x[0]) + int(x[1]), zip(base[i]['origin'], adj)) elif 'slices' in m : r['origin'] = (int(base[i]['origin'][0]) + int(adj), r['origin'][1]) break lastrun, t = processrun(ss, fg, curr, lastrun, t, error=args.error, pseudomap=pseudomap) strjson = trace[-1]['output'] lastrun, t = processrun(ss, fg, strjson, lastrun, t, error=0, pseudomap=pseudomap) bbox = map(lambda x:x * args.scale, fg.bbox()) fout.write(fg.asSVG(args.scale)) fout.write(ss.asSVG(t, args.scale, bbox, dur=args.duration, trans=args.transition)) fout.write('\n') fout.close()