rsms/inter
1
1
Fork 0
mirror of https://github.com/rsms/inter.git synced 2024-11-30 11:26:32 +03:00
Code Issues Projects Releases Wiki Activity
a213c92c25
inter/misc/svgsync2.py
Rasmus Andersson 3b1fffade1 Initial public commit
2017-08-22 02:23:08 -07:00

627 lines
17 KiB
Python
Executable File
Raw Blame History

#!/usr/bin/env python
# encoding: utf8
#
# Sync glyph shapes between SVG and UFO, creating a bridge between UFO and Figma.
#
import os
import sys
import argparse
import re
from StringIO import StringIO
from hashlib import sha256
from xml.dom.minidom import parseString as xmlparseString
from svgpathtools import svg2paths, parse_path, Path, Line, CubicBezier
from base64 import b64encode
# from robofab.world import world, RFont, RGlyph, OpenFont, NewFont
from robofab.objects.objectsRF import RFont, RGlyph, OpenFont, NewFont, RContour
from robofab.objects.objectsBase import MOVE, LINE, CORNER, CURVE, QCURVE, OFFCURVE
font = None # RFont
ufopath = ''
svgdir = ''
effectiveAscender = 0
def num(s):
return int(s) if s.find('.') == -1 else float(s)
def glyphToSVGPath(g, yMul=-1):
commands = {'move':'M','line':'L','curve':'Y','offcurve':'X','offCurve':'X'}
svg = ''
contours = []
if len(g.components):
font.newGlyph('__svgsync')
new = font['__svgsync']
new.width = g.width
new.appendGlyph(g)
new.decompose()
g = new
if len(g):
for c in range(len(g)):
contours.append(g[c])
for i in range(len(contours)):
c = contours[i]
contour = end = ''
curve = False
points = c.points
if points[0].type == 'offCurve':
points.append(points.pop(0))
if points[0].type == 'offCurve':
points.append(points.pop(0))
for x in range(len(points)):
p = points[x]
command = commands[str(p.type)]
if command == 'X':
if curve == True:
command = ''
else:
command = 'C'
curve = True
if command == 'Y':
command = ''
curve = False
if x == 0:
command = 'M'
if p.type == 'curve':
end = ' ' + str(p.x) + ' ' + str(p.y * yMul)
contour += ' ' + command + str(p.x) + ' ' + str(p.y * yMul)
svg += ' ' + contour + end + 'z'
if font.has_key('__svgsync'):
font.removeGlyph('__svgsync')
return svg.strip()
def vec2(x, y):
return float(x) + float(y) * 1j
def glyphToPaths(g, yMul=-1):
paths = []
contours = []
yOffs = -font.info.unitsPerEm
# decompose components
if len(g.components):
font.newGlyph('__svgsync')
ng = font['__svgsync']
ng.width = g.width
ng.appendGlyph(g)
ng.decompose()
g = ng
for c in g:
curve = False
points = c.points
path = Path()
currentPos = 0j
controlPoints = []
for x in range(len(points)):
p = points[x]
# print 'p#' + str(x) + '.type = ' + repr(p.type)
if p.type == 'move':
currentPos = vec2(p.x, (p.y + yOffs) * yMul)
elif p.type == 'offcurve':
controlPoints.append(p)
elif p.type == 'curve':
pos = vec2(p.x, (p.y + yOffs) * yMul)
if len(controlPoints) == 2:
cp1, cp2 = controlPoints
path.append(CubicBezier(
currentPos,
vec2(cp1.x, (cp1.y + yOffs) * yMul),
vec2(cp2.x, (cp2.y + yOffs) * yMul),
pos))
else:
if len(controlPoints) != 1:
raise Exception('unexpected number of control points for curve')
cp = controlPoints[0]
path.append(QuadraticBezier(currentPos, vec2(cp.x, (cp.y + yOffs) * yMul), pos))
currentPos = pos
controlPoints = []
elif p.type == 'line':
pos = vec2(p.x, (p.y + yOffs) * yMul)
path.append(Line(currentPos, pos))
currentPos = pos
paths.append(path)
if font.has_key('__svgsync'):
font.removeGlyph('__svgsync')
return paths
def maybeAddMove(contour, x, y, smooth):
if len(contour.segments) == 0:
contour.appendSegment(MOVE, [(x, y)], smooth=smooth)
svgPathDataRegEx = re.compile(r'(?:([A-Z])\s*|)([0-9\.\-\+eE]+)')
def drawSVGPath(g, d, tr):
yMul = -1
xOffs = tr[0]
yOffs = -(font.info.unitsPerEm - tr[1])
for pathd in d.split('M'):
pathd = pathd.strip()
# print 'pathd', pathd
if len(pathd) == 0:
continue
i = 0
closePath = False
if pathd[-1] == 'z':
closePath = True
pathd = pathd[0:-1]
pv = []
for m in svgPathDataRegEx.finditer('M' + pathd):
if m.group(1) is not None:
pv.append(m.group(1) + m.group(2))
else:
pv.append(m.group(2))
initX = 0
initY = 0
pen = g.getPen()
while i < len(pv):
pd = pv[i]; i += 1
cmd = pd[0]
x = num(pd[1:]) + xOffs
y = (num(pv[i]) + yOffs) * yMul; i += 1
if cmd == 'M':
# print cmd, x, y, '/', num(pv[i-2][1:])
initX = x
initY = y
pen.moveTo((x, y))
continue
if cmd == 'C':
# Bezier curve: "C x1 y1, x2 y2, x y"
x1 = x
y1 = y
x2 = num(pv[i]) + xOffs; i += 1
y2 = (num(pv[i]) + yOffs) * yMul; i += 1
x = num(pv[i]) + xOffs; i += 1
y = (num(pv[i]) + yOffs) * yMul; i += 1
pen.curveTo((x1, y1), (x2, y2), (x, y))
# print cmd, x1, y1, x2, y2, x, y
elif cmd == 'L':
pen.lineTo((x, y))
else:
raise Exception('unexpected SVG path command %r' % cmd)
if closePath:
pen.closePath()
else:
pen.endPath()
# print 'path ended. closePath:', closePath
def glyphToSVG(g, path, hash):
width = g.width
height = font.info.unitsPerEm
d = {
'name': g.name,
'width': width,
'height': effectiveAscender - font.info.descender,
'effectiveAscender': effectiveAscender,
'leftMargin': g.leftMargin,
'rightMargin': g.rightMargin,
'd': path.d(use_closed_attrib=True),
'ascender': font.info.ascender,
'descender': font.info.descender,
'baselineOffset': height + font.info.descender,
'unitsPerEm': font.info.unitsPerEm,
'hash': hash,
}
svg = '''
<svg xmlns="http://www.w3.org/2000/svg" width="%(width)d" height="%(height)d" data-svgsync-hash="%(hash)s">
<g id="%(name)s">
<path d="%(d)s" transform="translate(0 %(effectiveAscender)d)" />
<rect x="0" y="0" width="%(width)d" height="%(height)d" fill="" stroke="black" />
</g>
</svg>
''' % d
# print svg
return svg.strip()
def _findPathNodes(n, paths, defs, uses, isDef=False):
for cn in n.childNodes:
if cn.nodeName == 'path':
if isDef:
defs[cn.getAttribute('id')] = cn
else:
paths.append(cn)
elif cn.nodeName == 'use':
uses[cn.getAttribute('xlink:href').lstrip('#')] = {'useNode': cn, 'targetNode': None}
elif cn.nodeName == 'defs':
_findPathNodes(cn, paths, defs, uses, isDef=True)
elif not isinstance(cn, basestring) and cn.childNodes and len(cn.childNodes) > 0:
_findPathNodes(cn, paths, defs, uses, isDef)
# return translate
def findPathNodes(n, isDef=False):
paths = []
defs = {}
uses = {}
# <g id="Canvas" transform="translate(-3677 -24988)">
# <g id="six 2">
# <g id="six">
# <g id="Vector">
# <use xlink:href="#path0_fill" transform="translate(3886 25729)"/>
# ...
# <defs>
# <path id="path0_fill" ...
#
_findPathNodes(n, paths, defs, uses)
# flatten uses & defs
for k in uses.keys():
dfNode = defs.get(k)
if dfNode is not None:
v = uses[k]
v['targetNode'] = dfNode
if dfNode.nodeName == 'path':
useNode = v['useNode']
useNode.parentNode.replaceChild(dfNode, useNode)
attrs = useNode.attributes
for k in attrs.keys():
if k != 'xlink:href':
dfNode.setAttribute(k, attrs[k])
paths.append(dfNode)
else:
del defs[k]
return paths
def nodeTranslation(path, x=0, y=0):
tr = path.getAttribute('transform')
if tr is not None:
if not isinstance(tr, basestring):
tr = tr.value
if len(tr) > 0:
m = re.match(r"translate\s*\(\s*(?P<x>[\-\d\.eE]+)[\s,]*(?P<y>[\-\d\.eE]+)\s*\)", tr)
if m is not None:
x += num(m.group('x'))
y += num(m.group('y'))
else:
raise Exception('Unable to handle transform="%s"' % tr)
# m = re.match(r"matrix\s*\(\s*(?P<a>[\-\d\.eE]+)[\s,]*(?P<b>[\-\d\.eE]+)[\s,]*(?P<c>[\-\d\.eE]+)[\s,]*(?P<d>[\-\d\.eE]+)[\s,]*(?P<e>[\-\d\.eE]+)[\s,]*(?P<f>[\-\d\.eE]+)[\s,]*", tr)
# if m is not None:
# a, b, c = num(m.group('a')), num(m.group('b')), num(m.group('c'))
# d, e, f = num(m.group('d')), num(m.group('e')), num(m.group('f'))
# # matrix -1 0 0 -1 -660.719 31947
# print 'matrix', a, b, c, d, e, f
# # matrix(-1 0 -0 -1 -2553 31943)
pn = path.parentNode
if pn is not None and pn.nodeName != '#document':
x, y = nodeTranslation(pn, x, y)
return (x, y)
def glyphUpdateFromSVG(g, svgCode):
doc = xmlparseString(svgCode)
svg = doc.documentElement
paths = findPathNodes(svg)
if len(paths) == 0:
raise Exception('no <path> found in SVG')
path = paths[0]
if len(paths) != 1:
for p in paths:
id = p.getAttribute('id')
if id is not None and id.find('stroke') == -1:
path = p
break
tr = nodeTranslation(path)
d = path.getAttribute('d')
g.clearContours()
drawSVGPath(g, d, tr)
def stat(path):
try:
return os.stat(path)
except OSError as e:
return None
def writeFile(file, s):
with open(file, 'w') as f:
f.write(s)
def writeFileAndMkDirsIfNeeded(file, s):
try:
writeFile(file, s)
except IOError as e:
if e.errno == 2:
os.makedirs(os.path.dirname(file))
writeFile(file, s)
def findSvgSyncHashInSVG(svgCode):
# with open(svgFile, 'r') as f:
# svgCode = f.readline(512)
r = re.compile(r'^\s*<svg[^>]+data-svgsync-hash="([^"]*)".+')
m = r.match(svgCode)
if m is not None:
return m.group(1)
return None
def computeSVGHashFromSVG(g):
# h = sha256()
return 'abc123'
def encodePath(o, path):
o.write(path.d())
def hashPaths(paths):
h = sha256()
for path in paths:
h.update(path.d()+';')
return b64encode(h.digest(), '-_')
def svgGetPaths(svgCode):
doc = xmlparseString(svgCode)
svg = doc.documentElement
paths = findPathNodes(svg)
isFigmaSVG = svgCode.find('Figma</desc>') != -1
if len(paths) == 0:
return paths, (0,0)
paths2 = []
for path in paths:
id = path.getAttribute('id')
if not isFigmaSVG or (id is None or id.find('stroke') == -1):
tr = nodeTranslation(path)
d = path.getAttribute('d')
paths2.append((d, tr))
return paths2, isFigmaSVG
def translatePath(path, trX, trY):
pass
def parseSVG(svgFile):
svgCode = None
with open(svgFile, 'r') as f:
svgCode = f.read()
existingSvgHash = findSvgSyncHashInSVG(svgCode)
print 'hash in SVG file:', existingSvgHash
svgPathDefs, isFigmaSVG = svgGetPaths(svgCode)
paths = []
for pathDef, tr in svgPathDefs:
print 'pathDef:', pathDef, 'tr:', tr
path = parse_path(pathDef)
if tr[0] != 0 or tr[1] != 0:
path = path.translated(vec2(*tr))
paths.append(path)
return paths, existingSvgHash
def syncGlyphUFOToSVG(g, glyphFile, svgFile, mtime, hasSvgFile):
# # Let's print out the first path object and the color it was in the SVG
# # We'll see it is composed of two CubicBezier objects and, in the SVG file it
# # came from, it was red
# paths, attributes, svg_attributes = svg2paths(svgFile, return_svg_attributes=True)
# print('svg_attributes:', repr(svg_attributes))
# # redpath = paths[0]
# # redpath_attribs = attributes[0]
# print(paths)
# print(attributes)
# wsvg(paths, attributes=attributes, svg_attributes=svg_attributes, filename=svgFile + '-x.svg')
# existingSVGHash = readSVGHash(svgFile)
svgPaths = None
existingSVGHash = None
if hasSvgFile:
svgPaths, existingSVGHash = parseSVG(svgFile)
print 'existingSVGHash:', existingSVGHash
print 'svgPaths:\n', '\n'.join([p.d() for p in svgPaths])
svgHash = hashPaths(svgPaths)
print 'hash(SVG-glyph) =>', svgHash
# computedSVGHash = computeSVGHashFromSVG(svgFile)
# print 'computeSVGHashFromSVG:', computedSVGHash
ufoPaths = glyphToPaths(g)
print 'ufoPaths:\n', '\n'.join([p.d() for p in ufoPaths])
ufoGlyphHash = hashPaths(ufoPaths)
print 'hash(UFO-glyph) =>', ufoGlyphHash
# svg = glyphToSVG(g, ufoGlyphHash)
# with open('/Users/rsms/src/interface/_local/svgPaths.txt', 'w') as f:
# f.write(svgPaths[0].d())
# with open('/Users/rsms/src/interface/_local/ufoPaths.txt', 'w') as f:
# f.write(ufoPaths[0].d())
# print svgPaths[0].d() == ufoPaths[0].d()
# svgHash = hashPaths()
# print 'hash(UFO-glyph) =>', pathHash
sys.exit(1)
if pathHash == existingSVGHash:
return (None, 0) # did not change
svg = glyphToSVG(g, pathHash)
sys.exit(1)
writeFileAndMkDirsIfNeeded(svgFile, svg)
os.utime(svgFile, (mtime, mtime))
print 'svgsync write', svgFile
g.lib['svgsync.hash'] = pathHash
return (glyphFile, mtime)
def syncGlyphSVGToUFO(glyphname, svgFile):
print glyphname + ': SVG -> UFO'
sys.exit(1)
svg = ''
with open(svgFile, 'r') as f:
svg = f.read()
g = font.getGlyph(glyphname)
glyphUpdateFromSVG(g, svg)
def findGlifFile(glyphname):
# glyphname.glif
# glyphname_.glif
# glyphname__.glif
# glyphname___.glif
for underscoreCount in range(0, 5):
fn = os.path.join(ufopath, 'glyphs', glyphname + ('_' * underscoreCount) + '.glif')
st = stat(fn)
if st is not None:
return fn, st
if glyphname.find('.') != -1:
# glyph_.name.glif
# glyph__.name.glif
# glyph___.name.glif
for underscoreCount in range(0, 5):
nv = glyphname.split('.')
nv[0] = nv[0] + ('_' * underscoreCount)
ns = '.'.join(nv)
fn = os.path.join(ufopath, 'glyphs', ns + '.glif')
st = stat(fn)
if st is not None:
return fn, st
if glyphname.find('_') != -1:
# glyph_name.glif
# glyph_name_.glif
# glyph_name__.glif
# glyph__name.glif
# glyph__name_.glif
# glyph__name__.glif
# glyph___name.glif
# glyph___name_.glif
# glyph___name__.glif
for x in range(0, 4):
for y in range(0, 5):
ns = glyphname.replace('_', '__' + ('_' * x))
fn = os.path.join(ufopath, 'glyphs', ns + ('_' * y) + '.glif')
st = stat(fn)
if st is not None:
return fn, st
return ('', None)
def syncGlyph(glyphname, createSVG=False): # => (glyphname, mtime) or (None, 0) if noop
glyphFile, glyphStat = findGlifFile(glyphname)
svgFile = os.path.join(svgdir, glyphname + '.svg')
svgStat = stat(svgFile)
if glyphStat is None and svgStat is None:
raise Exception("glyph %r doesn't exist in UFO or SVG directory" % glyphname)
c = cmp(
0 if glyphStat is None else glyphStat.st_mtime,
0 if svgStat is None else svgStat.st_mtime
)
g = font.getGlyph(glyphname)
ufoPathHash = g.lib['svgsync.hash'] if 'svgsync.hash' in g.lib else None
print '[syncGlyph] g.lib["svgsync.hash"] =', ufoPathHash
c = 1 # XXX DEBUG
if c < 0:
syncGlyphSVGToUFO(glyphname, svgFile)
return (glyphFile, svgStat.st_mtime) # glif file in UFO change + it's new mtime
elif c > 0 and (svgStat is not None or createSVG):
print glyphname + ': UFO -> SVG'
return syncGlyphUFOToSVG(
g,
glyphFile,
svgFile,
glyphStat.st_mtime,
hasSvgFile=svgStat is not None
)
return (None, 0) # UFO did not change
# ————————————————————————————————————————————————————————————————————————
# main
argparser = argparse.ArgumentParser(description='Convert UFO glyphs to SVG')
argparser.add_argument('--svgdir', dest='svgdir', metavar='<dir>', type=str,
default='',
help='Write SVG files to <dir>. If not specified, SVG files are' +
' written to: {dirname(<ufopath>)/svg/<familyname>/<style>')
argparser.add_argument('ufopath', metavar='<ufopath>', type=str,
help='Path to UFO packages')
argparser.add_argument('glyphs', metavar='<glyphname>', type=str, nargs='*',
help='Glyphs to convert. Converts all if none specified.')
args = argparser.parse_args()
ufopath = args.ufopath.rstrip('/')
font = OpenFont(ufopath)
effectiveAscender = max(font.info.ascender, font.info.unitsPerEm)
svgdir = args.svgdir
if len(svgdir) == 0:
svgdir = os.path.join(
os.path.dirname(ufopath),
'svg',
font.info.familyName,
font.info.styleName
)
print 'svgsync sync %s (%s)' % (font.info.familyName, font.info.styleName)
createSVGs = len(args.glyphs) > 0
glyphnames = args.glyphs if len(args.glyphs) else font.keys()
modifiedGlifFiles = []
for glyphname in glyphnames:
glyphFile, mtime = syncGlyph(glyphname, createSVG=createSVGs)
if glyphFile is not None:
modifiedGlifFiles.append((glyphFile, mtime))
if len(modifiedGlifFiles) > 0:
font.save()
for glyphFile, mtime in modifiedGlifFiles:
os.utime(glyphFile, (mtime, mtime))
print 'svgsync write', glyphFile
Reference in New Issue View Git Blame Copy Permalink