#!/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[:-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')
fout.close()