def main(args=None):
if args is None:
import sys
args = sys.argv[1:]
varfilename = args[0]
locargs = args[1:]
outfile = os.path.splitext(varfilename)[0] + '-instance.ttf'
loc = {}
for arg in locargs:
tag, val = arg.split('=')
assert len(tag) <= 4
loc[tag.ljust(4)] = float(val)
print("Location:", loc)
print("Loading variable font")
varfont = TTFont(varfilename)
fvar = varfont['fvar']
axes = {
a.axisTag: (a.minValue, a.defaultValue, a.maxValue)
for a in fvar.axes
}
# TODO Round to F2Dot14?
loc = normalizeLocation(loc, axes)
# Location is normalized now
print("Normalized location:", loc)
gvar = varfont['gvar']
glyf = varfont['glyf']
# get list of glyph names in gvar sorted by component depth
glyphnames = sorted(
gvar.variations.keys(),
key=lambda name:
(glyf[name].getCompositeMaxpValues(glyf).maxComponentDepth
if glyf[name].isComposite() else 0, name))
for glyphname in glyphnames:
variations = gvar.variations[glyphname]
coordinates, _ = _GetCoordinates(varfont, glyphname)
for var in variations:
scalar = supportScalar(loc, var.axes)
if not scalar: continue
# TODO Do IUP / handle None items
coordinates += GlyphCoordinates(var.coordinates) * scalar
_SetCoordinates(varfont, glyphname, coordinates)
print("Removing variable tables")
for tag in ('avar', 'cvar', 'fvar', 'gvar', 'HVAR', 'MVAR', 'VVAR',
'STAT'):
if tag in varfont:
del varfont[tag]
print("Saving instance font", outfile)
varfont.save(outfile)
def main(args=None):
import sys
if args is None:
args = sys.argv[1:]
varfilename = args[0]
locargs = args[1:]
outfile = os.path.splitext(varfilename)[0] + '-instance.ttf'
loc = {}
for arg in locargs:
tag, valstr = arg.split('=')
while len(tag) < 4:
tag += ' '
assert len(tag) <= 4
loc[tag] = float(valstr)
print("Location:", loc)
print("Loading GX font")
varfont = TTFont(varfilename)
fvar = varfont['fvar']
for axis in fvar.axes:
lower, default, upper = axis.minValue, axis.defaultValue, axis.maxValue
v = loc.get(axis.axisTag, default)
if v < lower: v = lower
if v > upper: v = upper
if v == default:
v = 0
elif v < default:
v = (v - default) / (default - lower)
else:
v = (v - default) / (upper - default)
loc[axis.axisTag] = v
# Location is normalized now
print("Normalized location:", loc)
gvar = varfont['gvar']
for glyphname, variations in gvar.variations.items():
coordinates, _ = _GetCoordinates(varfont, glyphname)
for var in variations:
scalar = supportScalar(loc, var.axes)
if not scalar: continue
# TODO Do IUP / handle None items
coordinates += GlyphCoordinates(var.coordinates) * scalar
_SetCoordinates(varfont, glyphname, coordinates)
print("Removing GX tables")
for tag in ('fvar', 'avar', 'gvar'):
if tag in varfont:
del varfont[tag]
print("Saving instance font", outfile)
varfont.save(outfile)
def main(args=None):
import sys
if args is None:
args = sys.argv[1:]
varfilename = args[0]
locargs = args[1:]
outfile = os.path.splitext(varfilename)[0] + '-instance.ttf'
loc = {}
for arg in locargs:
tag,valstr = arg.split('=')
while len(tag) < 4:
tag += ' '
assert len(tag) <= 4
loc[tag] = float(valstr)
print("Location:", loc)
print("Loading GX font")
varfont = TTFont(varfilename)
fvar = varfont['fvar']
for axis in fvar.axes:
lower, default, upper = axis.minValue, axis.defaultValue, axis.maxValue
v = loc.get(axis.axisTag, default)
if v < lower: v = lower
if v > upper: v = upper
if v == default:
v = 0
elif v < default:
v = (v - default) / (default - lower)
else:
v = (v - default) / (upper - default)
loc[axis.axisTag] = v
# Location is normalized now
print("Normalized location:", loc)
gvar = varfont['gvar']
for glyphname,variations in gvar.variations.items():
coordinates,_ = _GetCoordinates(varfont, glyphname)
for var in variations:
scalar = supportScalar(loc, var.axes)
if not scalar: continue
# TODO Do IUP / handle None items
coordinates += GlyphCoordinates(var.coordinates) * scalar
_SetCoordinates(varfont, glyphname, coordinates)
print("Removing GX tables")
for tag in ('fvar','avar','gvar'):
if tag in varfont:
del varfont[tag]
print("Saving instance font", outfile)
varfont.save(outfile)
def main(args=None):
if args is None:
import sys
args = sys.argv[1:]
varfilename = args[0]
locargs = args[1:]
outfile = os.path.splitext(varfilename)[0] + '-instance.ttf'
loc = {}
for arg in locargs:
tag,val = arg.split('=')
assert len(tag) <= 4
loc[tag.ljust(4)] = float(val)
print("Location:", loc)
print("Loading GX font")
varfont = TTFont(varfilename)
fvar = varfont['fvar']
axes = {a.axisTag:(a.minValue,a.defaultValue,a.maxValue) for a in fvar.axes}
# TODO Round to F2Dot14?
loc = normalizeLocation(loc, axes)
# Location is normalized now
print("Normalized location:", loc)
gvar = varfont['gvar']
for glyphname,variations in gvar.variations.items():
coordinates,_ = _GetCoordinates(varfont, glyphname)
for var in variations:
scalar = supportScalar(loc, var.axes)
if not scalar: continue
# TODO Do IUP / handle None items
coordinates += GlyphCoordinates(var.coordinates) * scalar
_SetCoordinates(varfont, glyphname, coordinates)
print("Removing GX tables")
for tag in ('fvar','avar','gvar'):
if tag in varfont:
del varfont[tag]
print("Saving instance font", outfile)
varfont.save(outfile)
def instantiateVariableFont(varfont, location, inplace=False):
""" Generate a static instance from a variable TTFont and a dictionary
defining the desired location along the variable font's axes.
The location values must be specified as user-space coordinates, e.g.:
{'wght': 400, 'wdth': 100}
By default, a new TTFont object is returned. If ``inplace`` is True, the
input varfont is modified and reduced to a static font.
"""
if not inplace:
# make a copy to leave input varfont unmodified
stream = BytesIO()
varfont.save(stream)
stream.seek(0)
varfont = TTFont(stream)
fvar = varfont['fvar']
axes = {a.axisTag:(a.minValue,a.defaultValue,a.maxValue) for a in fvar.axes}
loc = normalizeLocation(location, axes)
if 'avar' in varfont:
maps = varfont['avar'].segments
loc = {k: piecewiseLinearMap(v, maps[k]) for k,v in loc.items()}
# Quantize to F2Dot14, to avoid surprise interpolations.
loc = {k:floatToFixedToFloat(v, 14) for k,v in loc.items()}
# Location is normalized now
log.info("Normalized location: %s", loc)
if 'gvar' in varfont:
log.info("Mutating glyf/gvar tables")
gvar = varfont['gvar']
glyf = varfont['glyf']
# get list of glyph names in gvar sorted by component depth
glyphnames = sorted(
gvar.variations.keys(),
key=lambda name: (
glyf[name].getCompositeMaxpValues(glyf).maxComponentDepth
if glyf[name].isComposite() else 0,
name))
for glyphname in glyphnames:
variations = gvar.variations[glyphname]
coordinates,_ = _GetCoordinates(varfont, glyphname)
origCoords, endPts = None, None
for var in variations:
scalar = supportScalar(loc, var.axes)
if not scalar: continue
delta = var.coordinates
if None in delta:
if origCoords is None:
origCoords,control = _GetCoordinates(varfont, glyphname)
endPts = control[1] if control[0] >= 1 else list(range(len(control[1])))
delta = iup_delta(delta, origCoords, endPts)
coordinates += GlyphCoordinates(delta) * scalar
_SetCoordinates(varfont, glyphname, coordinates)
else:
glyf = None
if 'cvar' in varfont:
log.info("Mutating cvt/cvar tables")
cvar = varfont['cvar']
cvt = varfont['cvt ']
deltas = {}
for var in cvar.variations:
scalar = supportScalar(loc, var.axes)
if not scalar: continue
for i, c in enumerate(var.coordinates):
if c is not None:
deltas[i] = deltas.get(i, 0) + scalar * c
for i, delta in deltas.items():
cvt[i] += otRound(delta)
if 'CFF2' in varfont:
log.info("Mutating CFF2 table")
glyphOrder = varfont.getGlyphOrder()
CFF2 = varfont['CFF2']
topDict = CFF2.cff.topDictIndex[0]
vsInstancer = VarStoreInstancer(topDict.VarStore.otVarStore, fvar.axes, loc)
interpolateFromDeltas = vsInstancer.interpolateFromDeltas
interpolate_cff2_PrivateDict(topDict, interpolateFromDeltas)
CFF2.desubroutinize(varfont)
interpolate_cff2_charstrings(topDict, interpolateFromDeltas, glyphOrder)
interpolate_cff2_metrics(varfont, topDict, glyphOrder, loc)
del topDict.rawDict['VarStore']
del topDict.VarStore
if 'MVAR' in varfont:
log.info("Mutating MVAR table")
mvar = varfont['MVAR'].table
varStoreInstancer = VarStoreInstancer(mvar.VarStore, fvar.axes, loc)
records = mvar.ValueRecord
for rec in records:
mvarTag = rec.ValueTag
if mvarTag not in MVAR_ENTRIES:
continue
tableTag, itemName = MVAR_ENTRIES[mvarTag]
delta = otRound(varStoreInstancer[rec.VarIdx])
if not delta:
continue
setattr(varfont[tableTag], itemName,
getattr(varfont[tableTag], itemName) + delta)
log.info("Mutating FeatureVariations")
for tableTag in 'GSUB','GPOS':
if not tableTag in varfont:
continue
table = varfont[tableTag].table
if not hasattr(table, 'FeatureVariations'):
continue
variations = table.FeatureVariations
for record in variations.FeatureVariationRecord:
applies = True
for condition in record.ConditionSet.ConditionTable:
if condition.Format == 1:
axisIdx = condition.AxisIndex
axisTag = fvar.axes[axisIdx].axisTag
Min = condition.FilterRangeMinValue
Max = condition.FilterRangeMaxValue
v = loc[axisTag]
if not (Min <= v <= Max):
applies = False
else:
applies = False
if not applies:
break
if applies:
assert record.FeatureTableSubstitution.Version == 0x00010000
for rec in record.FeatureTableSubstitution.SubstitutionRecord:
table.FeatureList.FeatureRecord[rec.FeatureIndex].Feature = rec.Feature
break
del table.FeatureVariations
if 'GDEF' in varfont and varfont['GDEF'].table.Version >= 0x00010003:
log.info("Mutating GDEF/GPOS/GSUB tables")
gdef = varfont['GDEF'].table
instancer = VarStoreInstancer(gdef.VarStore, fvar.axes, loc)
merger = MutatorMerger(varfont, loc)
merger.mergeTables(varfont, [varfont], ['GDEF', 'GPOS'])
# Downgrade GDEF.
del gdef.VarStore
gdef.Version = 0x00010002
if gdef.MarkGlyphSetsDef is None:
del gdef.MarkGlyphSetsDef
gdef.Version = 0x00010000
if not (gdef.LigCaretList or
gdef.MarkAttachClassDef or
gdef.GlyphClassDef or
gdef.AttachList or
(gdef.Version >= 0x00010002 and gdef.MarkGlyphSetsDef)):
del varfont['GDEF']
addidef = False
if glyf:
for glyph in glyf.glyphs.values():
if hasattr(glyph, "program"):
instructions = glyph.program.getAssembly()
# If GETVARIATION opcode is used in bytecode of any glyph add IDEF
addidef = any(op.startswith("GETVARIATION") for op in instructions)
if addidef:
break
if addidef:
log.info("Adding IDEF to fpgm table for GETVARIATION opcode")
asm = []
if 'fpgm' in varfont:
fpgm = varfont['fpgm']
asm = fpgm.program.getAssembly()
else:
fpgm = newTable('fpgm')
fpgm.program = ttProgram.Program()
varfont['fpgm'] = fpgm
asm.append("PUSHB[000] 145")
asm.append("IDEF[ ]")
args = [str(len(loc))]
for a in fvar.axes:
args.append(str(floatToFixed(loc[a.axisTag], 14)))
asm.append("NPUSHW[ ] " + ' '.join(args))
asm.append("ENDF[ ]")
fpgm.program.fromAssembly(asm)
# Change maxp attributes as IDEF is added
if 'maxp' in varfont:
maxp = varfont['maxp']
if hasattr(maxp, "maxInstructionDefs"):
maxp.maxInstructionDefs += 1
else:
setattr(maxp, "maxInstructionDefs", 1)
if hasattr(maxp, "maxStackElements"):
maxp.maxStackElements = max(len(loc), maxp.maxStackElements)
else:
setattr(maxp, "maxInstructionDefs", len(loc))
if 'name' in varfont:
log.info("Pruning name table")
exclude = {a.axisNameID for a in fvar.axes}
for i in fvar.instances:
exclude.add(i.subfamilyNameID)
exclude.add(i.postscriptNameID)
varfont['name'].names[:] = [
n for n in varfont['name'].names
if n.nameID not in exclude
]
if "wght" in location and "OS/2" in varfont:
varfont["OS/2"].usWeightClass = otRound(
max(1, min(location["wght"], 1000))
)
if "wdth" in location:
wdth = location["wdth"]
for percent, widthClass in sorted(OS2_WIDTH_CLASS_VALUES.items()):
if wdth < percent:
varfont["OS/2"].usWidthClass = widthClass
break
else:
varfont["OS/2"].usWidthClass = 9
if "slnt" in location and "post" in varfont:
varfont["post"].italicAngle = max(-90, min(location["slnt"], 90))
log.info("Removing variable tables")
for tag in ('avar','cvar','fvar','gvar','HVAR','MVAR','VVAR','STAT'):
if tag in varfont:
del varfont[tag]
return varfont
def instantiateVariableFont(varfont, location, inplace=False):
""" Generate a static instance from a variable TTFont and a dictionary
defining the desired location along the variable font's axes.
The location values must be specified as user-space coordinates, e.g.:
{'wght': 400, 'wdth': 100}
By default, a new TTFont object is returned. If ``inplace`` is True, the
input varfont is modified and reduced to a static font.
"""
if not inplace:
# make a copy to leave input varfont unmodified
stream = BytesIO()
varfont.save(stream)
stream.seek(0)
varfont = TTFont(stream)
fvar = varfont['fvar']
axes = {a.axisTag:(a.minValue,a.defaultValue,a.maxValue) for a in fvar.axes}
loc = normalizeLocation(location, axes)
if 'avar' in varfont:
maps = varfont['avar'].segments
loc = {k: piecewiseLinearMap(v, maps[k]) for k,v in loc.items()}
# Quantize to F2Dot14, to avoid surprise interpolations.
loc = {k:floatToFixedToFloat(v, 14) for k,v in loc.items()}
# Location is normalized now
log.info("Normalized location: %s", loc)
if 'gvar' in varfont:
log.info("Mutating glyf/gvar tables")
gvar = varfont['gvar']
glyf = varfont['glyf']
# get list of glyph names in gvar sorted by component depth
glyphnames = sorted(
gvar.variations.keys(),
key=lambda name: (
glyf[name].getCompositeMaxpValues(glyf).maxComponentDepth
if glyf[name].isComposite() else 0,
name))
for glyphname in glyphnames:
variations = gvar.variations[glyphname]
coordinates,_ = _GetCoordinates(varfont, glyphname)
origCoords, endPts = None, None
for var in variations:
scalar = supportScalar(loc, var.axes)
if not scalar: continue
delta = var.coordinates
if None in delta:
if origCoords is None:
origCoords,control = _GetCoordinates(varfont, glyphname)
endPts = control[1] if control[0] >= 1 else list(range(len(control[1])))
delta = iup_delta(delta, origCoords, endPts)
coordinates += GlyphCoordinates(delta) * scalar
_SetCoordinates(varfont, glyphname, coordinates)
else:
glyf = None
if 'cvar' in varfont:
log.info("Mutating cvt/cvar tables")
cvar = varfont['cvar']
cvt = varfont['cvt ']
deltas = {}
for var in cvar.variations:
scalar = supportScalar(loc, var.axes)
if not scalar: continue
for i, c in enumerate(var.coordinates):
if c is not None:
deltas[i] = deltas.get(i, 0) + scalar * c
for i, delta in deltas.items():
cvt[i] += otRound(delta)
if 'CFF2' in varfont:
log.info("Mutating CFF2 table")
glyphOrder = varfont.getGlyphOrder()
CFF2 = varfont['CFF2']
topDict = CFF2.cff.topDictIndex[0]
vsInstancer = VarStoreInstancer(topDict.VarStore.otVarStore, fvar.axes, loc)
interpolateFromDeltas = vsInstancer.interpolateFromDeltas
interpolate_cff2_PrivateDict(topDict, interpolateFromDeltas)
CFF2.desubroutinize()
interpolate_cff2_charstrings(topDict, interpolateFromDeltas, glyphOrder)
interpolate_cff2_metrics(varfont, topDict, glyphOrder, loc)
del topDict.rawDict['VarStore']
del topDict.VarStore
if 'MVAR' in varfont:
log.info("Mutating MVAR table")
mvar = varfont['MVAR'].table
varStoreInstancer = VarStoreInstancer(mvar.VarStore, fvar.axes, loc)
records = mvar.ValueRecord
for rec in records:
mvarTag = rec.ValueTag
if mvarTag not in MVAR_ENTRIES:
continue
tableTag, itemName = MVAR_ENTRIES[mvarTag]
delta = otRound(varStoreInstancer[rec.VarIdx])
if not delta:
continue
setattr(varfont[tableTag], itemName,
getattr(varfont[tableTag], itemName) + delta)
log.info("Mutating FeatureVariations")
for tableTag in 'GSUB','GPOS':
if not tableTag in varfont:
continue
table = varfont[tableTag].table
if not hasattr(table, 'FeatureVariations'):
continue
variations = table.FeatureVariations
for record in variations.FeatureVariationRecord:
applies = True
for condition in record.ConditionSet.ConditionTable:
if condition.Format == 1:
axisIdx = condition.AxisIndex
axisTag = fvar.axes[axisIdx].axisTag
Min = condition.FilterRangeMinValue
Max = condition.FilterRangeMaxValue
v = loc[axisTag]
if not (Min <= v <= Max):
applies = False
else:
applies = False
if not applies:
break
if applies:
assert record.FeatureTableSubstitution.Version == 0x00010000
for rec in record.FeatureTableSubstitution.SubstitutionRecord:
table.FeatureList.FeatureRecord[rec.FeatureIndex].Feature = rec.Feature
break
del table.FeatureVariations
if 'GDEF' in varfont and varfont['GDEF'].table.Version >= 0x00010003:
log.info("Mutating GDEF/GPOS/GSUB tables")
gdef = varfont['GDEF'].table
instancer = VarStoreInstancer(gdef.VarStore, fvar.axes, loc)
merger = MutatorMerger(varfont, loc)
merger.mergeTables(varfont, [varfont], ['GDEF', 'GPOS'])
# Downgrade GDEF.
del gdef.VarStore
gdef.Version = 0x00010002
if gdef.MarkGlyphSetsDef is None:
del gdef.MarkGlyphSetsDef
gdef.Version = 0x00010000
if not (gdef.LigCaretList or
gdef.MarkAttachClassDef or
gdef.GlyphClassDef or
gdef.AttachList or
(gdef.Version >= 0x00010002 and gdef.MarkGlyphSetsDef)):
del varfont['GDEF']
addidef = False
if glyf:
for glyph in glyf.glyphs.values():
if hasattr(glyph, "program"):
instructions = glyph.program.getAssembly()
# If GETVARIATION opcode is used in bytecode of any glyph add IDEF
addidef = any(op.startswith("GETVARIATION") for op in instructions)
if addidef:
break
if addidef:
log.info("Adding IDEF to fpgm table for GETVARIATION opcode")
asm = []
if 'fpgm' in varfont:
fpgm = varfont['fpgm']
asm = fpgm.program.getAssembly()
else:
fpgm = newTable('fpgm')
fpgm.program = ttProgram.Program()
varfont['fpgm'] = fpgm
asm.append("PUSHB[000] 145")
asm.append("IDEF[ ]")
args = [str(len(loc))]
for a in fvar.axes:
args.append(str(floatToFixed(loc[a.axisTag], 14)))
asm.append("NPUSHW[ ] " + ' '.join(args))
asm.append("ENDF[ ]")
fpgm.program.fromAssembly(asm)
# Change maxp attributes as IDEF is added
if 'maxp' in varfont:
maxp = varfont['maxp']
if hasattr(maxp, "maxInstructionDefs"):
maxp.maxInstructionDefs += 1
else:
setattr(maxp, "maxInstructionDefs", 1)
if hasattr(maxp, "maxStackElements"):
maxp.maxStackElements = max(len(loc), maxp.maxStackElements)
else:
setattr(maxp, "maxInstructionDefs", len(loc))
if 'name' in varfont:
log.info("Pruning name table")
exclude = {a.axisNameID for a in fvar.axes}
for i in fvar.instances:
exclude.add(i.subfamilyNameID)
exclude.add(i.postscriptNameID)
if 'ltag' in varfont:
# Drop the whole 'ltag' table if all its language tags are referenced by
# name records to be pruned.
# TODO: prune unused ltag tags and re-enumerate langIDs accordingly
excludedUnicodeLangIDs = [
n.langID for n in varfont['name'].names
if n.nameID in exclude and n.platformID == 0 and n.langID != 0xFFFF
]
if set(excludedUnicodeLangIDs) == set(range(len((varfont['ltag'].tags)))):
del varfont['ltag']
varfont['name'].names[:] = [
n for n in varfont['name'].names
if n.nameID not in exclude
]
if "wght" in location and "OS/2" in varfont:
varfont["OS/2"].usWeightClass = otRound(
max(1, min(location["wght"], 1000))
)
if "wdth" in location:
wdth = location["wdth"]
for percent, widthClass in sorted(OS2_WIDTH_CLASS_VALUES.items()):
if wdth < percent:
varfont["OS/2"].usWidthClass = widthClass
break
else:
varfont["OS/2"].usWidthClass = 9
if "slnt" in location and "post" in varfont:
varfont["post"].italicAngle = max(-90, min(location["slnt"], 90))
log.info("Removing variable tables")
for tag in ('avar','cvar','fvar','gvar','HVAR','MVAR','VVAR','STAT'):
if tag in varfont:
del varfont[tag]
return varfont
def makeInstance(pathOrVarFont,
location,
dstPath=None,
normalize=True,
cached=True,
lazy=True,
kerning=None):
"""Instantiate an instance of a variable font at the specified location.
Keyword arguments:
- varfilename -- a variable font file path
- location -- a dictionary of axis tag and value {"wght": 0.75, "wdth": -0.5}
>>> vf = findFont('RobotoDelta-VF')
>>> print(vf)
<Font RobotoDelta-VF>
>>> print(len(vf))
188
>>> instance = makeInstance(vf.path, dict(opsz=8), cached=False)
>>> instance
<Font RobotoDelta-VF-opsz8>
>>> len(instance)
241
>>> len(instance['H'].points)
12
>>> instance['Egrave']
<PageBot Glyph Egrave Pts:0/Cnt:0/Cmp:2>
>>> len(instance['Egrave'].components)
2
"""
# make a custom file name from the location e.g.
# VariableFont-wghtXXX-wdthXXX.ttf
instanceName = ""
if isinstance(pathOrVarFont, Font):
pathOrVarFont = pathOrVarFont.path
varFont = Font(pathOrVarFont, lazy=lazy)
ttFont = varFont.ttFont
for k, v in sorted(location.items()):
# TODO better way to normalize the location name to (0, 1000)
v = min(v, 1000)
v = max(v, 0)
instanceName += "-%s%s" % (k, v)
if dstPath is None:
targetFileName = '.'.join(varFont.path.split('/')[-1].split('.')
[:-1]) + instanceName + '.ttf'
targetDirectory = getInstancePath()
if not targetDirectory.endswith('/'):
targetDirectory += '/'
if not os.path.exists(targetDirectory):
os.makedirs(targetDirectory)
dstPath = targetDirectory + targetFileName
# Instance does not exist as file. Create it.
if not cached or not os.path.exists(dstPath):
# Set the instance name IDs in the name table
platforms = ((1, 0, 0), (3, 1, 0x409)) # Macintosh and Windows
for platformID, platEncID, langID in platforms:
familyName = ttFont['name'].getName(1, platformID, platEncID,
langID) # 1 Font Family name
if not familyName:
continue
familyName = familyName.toUnicode() # NameRecord to unicode string
styleName = unicode(
instanceName) # TODO make sure this works in any case
fullFontName = " ".join([familyName, styleName])
postscriptName = fullFontName.replace(" ", "-")
ttFont['name'].setName(styleName, 2, platformID, platEncID,
langID) # 2 Font Subfamily name
ttFont['name'].setName(fullFontName, 4, platformID, platEncID,
langID) # 4 Full font name
ttFont['name'].setName(postscriptName, 6, platformID, platEncID,
langID) # 6 Postscript name for the font
# Other important name IDs
# 3 Unique font identifier (e.g. Version 0.000;NONE;Promise Bold Regular)
# 25 Variables PostScript Name Prefix
fvar = ttFont['fvar']
axes = {
a.axisTag: (a.minValue, a.defaultValue, a.maxValue)
for a in fvar.axes
}
# TODO Apply avar
# TODO Round to F2Dot14?
loc = normalizeLocation(location, axes)
# Location is normalized now
#print("Normalized location:", loc)
gvar = ttFont['gvar']
glyf = ttFont['glyf']
# get list of glyph names in gvar sorted by component depth
glyphNames = sorted(
gvar.variations.keys(),
key=lambda name:
(glyf[name].getCompositeMaxpValues(glyf).maxComponentDepth
if glyf[name].isComposite() else 0, name))
for glyphName in glyphNames:
variations = gvar.variations[glyphName]
coordinates, _ = _GetCoordinates(ttFont, glyphName)
origCoords, endPts = None, None
for var in variations:
scalar = supportScalar(loc, var.axes) #, ot=True)
if not scalar: continue
delta = var.coordinates
if None in delta:
if origCoords is None:
origCoords, control = _GetCoordinates(
ttFont, glyphName)
endPts = control[1] if control[0] >= 1 else list(
range(len(control[1])))
delta = iup_delta(delta, origCoords, endPts)
coordinates += GlyphCoordinates(delta) * scalar
_SetCoordinates(ttFont, glyphName, coordinates)
# Interpolate cvt
if 'cvar' in ttFont:
cvar = ttFont['cvar']
cvt = ttFont['cvt ']
deltas = {}
for var in cvar.variations:
scalar = supportScalar(loc, var.axes)
if not scalar: continue
for i, c in enumerate(var.coordinates):
if c is not None:
deltas[i] = deltas.get(i, 0) + scalar * c
for i, delta in deltas.items():
cvt[i] += int(round(delta))
#print("Removing variable tables")
for tag in ('avar', 'cvar', 'fvar', 'gvar', 'HVAR', 'MVAR', 'VVAR',
'STAT'):
if tag in ttFont:
del ttFont[tag]
if kerning is not None:
for pair, value in kerning.items():
varFont.kerning[pair] = value
#print("Saving instance font", outFile)
varFont.save(dstPath)
# Answer instance.
return Font(dstPath, lazy=lazy)
def instantiateVariableFont(varfont, location, inplace=False):
""" Generate a static instance from a variable TTFont and a dictionary
defining the desired location along the variable font's axes.
The location values must be specified as user-space coordinates, e.g.:
{'wght': 400, 'wdth': 100}
By default, a new TTFont object is returned. If ``inplace`` is True, the
input varfont is modified and reduced to a static font.
"""
if not inplace:
# make a copy to leave input varfont unmodified
stream = BytesIO()
varfont.save(stream)
stream.seek(0)
varfont = TTFont(stream)
fvar = varfont['fvar']
axes = {a.axisTag:(a.minValue,a.defaultValue,a.maxValue) for a in fvar.axes}
loc = normalizeLocation(location, axes)
if 'avar' in varfont:
maps = varfont['avar'].segments
loc = {k:_DesignspaceAxis._map(v, maps[k]) for k,v in loc.items()}
# Quantize to F2Dot14, to avoid surprise interpolations.
loc = {k:floatToFixedToFloat(v, 14) for k,v in loc.items()}
# Location is normalized now
log.info("Normalized location: %s", loc)
log.info("Mutating glyf/gvar tables")
gvar = varfont['gvar']
glyf = varfont['glyf']
# get list of glyph names in gvar sorted by component depth
glyphnames = sorted(
gvar.variations.keys(),
key=lambda name: (
glyf[name].getCompositeMaxpValues(glyf).maxComponentDepth
if glyf[name].isComposite() else 0,
name))
for glyphname in glyphnames:
variations = gvar.variations[glyphname]
coordinates,_ = _GetCoordinates(varfont, glyphname)
origCoords, endPts = None, None
for var in variations:
scalar = supportScalar(loc, var.axes)
if not scalar: continue
delta = var.coordinates
if None in delta:
if origCoords is None:
origCoords,control = _GetCoordinates(varfont, glyphname)
endPts = control[1] if control[0] >= 1 else list(range(len(control[1])))
delta = iup_delta(delta, origCoords, endPts)
coordinates += GlyphCoordinates(delta) * scalar
_SetCoordinates(varfont, glyphname, coordinates)
if 'cvar' in varfont:
log.info("Mutating cvt/cvar tables")
cvar = varfont['cvar']
cvt = varfont['cvt ']
deltas = {}
for var in cvar.variations:
scalar = supportScalar(loc, var.axes)
if not scalar: continue
for i, c in enumerate(var.coordinates):
if c is not None:
deltas[i] = deltas.get(i, 0) + scalar * c
for i, delta in deltas.items():
cvt[i] += otRound(delta)
if 'MVAR' in varfont:
log.info("Mutating MVAR table")
mvar = varfont['MVAR'].table
varStoreInstancer = VarStoreInstancer(mvar.VarStore, fvar.axes, loc)
records = mvar.ValueRecord
for rec in records:
mvarTag = rec.ValueTag
if mvarTag not in MVAR_ENTRIES:
continue
tableTag, itemName = MVAR_ENTRIES[mvarTag]
delta = otRound(varStoreInstancer[rec.VarIdx])
if not delta:
continue
setattr(varfont[tableTag], itemName,
getattr(varfont[tableTag], itemName) + delta)
if 'GDEF' in varfont:
log.info("Mutating GDEF/GPOS/GSUB tables")
merger = MutatorMerger(varfont, loc)
log.info("Building interpolated tables")
merger.instantiate()
if 'name' in varfont:
log.info("Pruning name table")
exclude = {a.axisNameID for a in fvar.axes}
for i in fvar.instances:
exclude.add(i.subfamilyNameID)
exclude.add(i.postscriptNameID)
varfont['name'].names[:] = [
n for n in varfont['name'].names
if n.nameID not in exclude
]
if "wght" in location and "OS/2" in varfont:
varfont["OS/2"].usWeightClass = otRound(
max(1, min(location["wght"], 1000))
)
if "wdth" in location:
wdth = location["wdth"]
for percent, widthClass in sorted(OS2_WIDTH_CLASS_VALUES.items()):
if wdth < percent:
varfont["OS/2"].usWidthClass = widthClass
break
else:
varfont["OS/2"].usWidthClass = 9
if "slnt" in location and "post" in varfont:
varfont["post"].italicAngle = max(-90, min(location["slnt"], 90))
log.info("Removing variable tables")
for tag in ('avar','cvar','fvar','gvar','HVAR','MVAR','VVAR','STAT'):
if tag in varfont:
del varfont[tag]
return varfont
def generateInstance(variableFontPath, location, targetDirectory, normalize=True):
u"""
Instantiate an instance of a variable font at the specified location.
Keyword arguments:
varfilename -- a variable font file path
location -- a dictionary of axis tag and value {"wght": 0.75, "wdth": -0.5}
"""
# make a custom file name from the location e.g. VariableFont-wghtXXX-wdthXXX.ttf
instanceName = ""
for k, v in sorted(location.items()):
# TODO better way to normalize the location name to (0, 1000)
v = min(v, 1000)
v = max(v, 0)
instanceName += "-%s%s" % (k, v)
targetFileName = '.'.join(variableFontPath.split('/')[-1].split('.')[:-1]) + instanceName + '.ttf'
if not targetDirectory.endswith('/'):
targetDirectory += '/'
if not os.path.exists(targetDirectory):
os.makedirs(targetDirectory)
outFile = targetDirectory + targetFileName
if not os.path.exists(outFile):
# Instance does not exist as file. Create it.
# print("Loading GX font")
varFont = TTFont(variableFontPath)
# Set the instance name IDs in the name table
platforms=((1, 0, 0), (3, 1, 0x409)) # Macintosh and Windows
for platformID, platEncID, langID in platforms:
familyName = varFont['name'].getName(1, platformID, platEncID, langID) # 1 Font Family name
if not familyName:
continue
familyName = familyName.toUnicode() # NameRecord to unicode string
styleName = unicode(instanceName) # TODO make sure this works in any case
fullFontName = " ".join([familyName, styleName])
postscriptName = fullFontName.replace(" ", "-")
varFont['name'].setName(styleName, 2, platformID, platEncID, langID) # 2 Font Subfamily name
varFont['name'].setName(fullFontName, 4, platformID, platEncID, langID) # 4 Full font name
varFont['name'].setName(postscriptName, 6, platformID, platEncID, langID) # 6 Postscript name for the font
# Other important name IDs
# 3 Unique font identifier (e.g. Version 0.000;NONE;Promise Bold Regular)
# 25 Variables PostScript Name Prefix
fvar = varFont['fvar']
axes = {a.axisTag: (a.minValue, a.defaultValue, a.maxValue) for a in fvar.axes}
# TODO Round to F2Dot14?
if normalize:
normalizedLoc = normalizeLocation(location, axes)
else:
normalizedLoc = location
# Location is normalized now
if DEBUG:
print("Normalized location:", varFileName, normalizedLoc)
gvar = varFont['gvar']
for glyphName, variations in gvar.variations.items():
coordinates, _ = _GetCoordinates(varFont, glyphName)
for var in variations:
scalar = supportScalar(normalizedLoc, var.axes)
if not scalar: continue
# TODO Do IUP / handle None items
varCoords = []
for coord in var.coordinates:
# TODO temp hack to avoid NoneType
if coord is None:
varCoords.append((0, 0))
else:
varCoords.append(coord)
coordinates += GlyphCoordinates(varCoords) * scalar
# coordinates += GlyphCoordinates(var.coordinates) * scalar
_SetCoordinates(varFont, glyphName, coordinates)
# print("Removing GX tables")
for tag in ('fvar', 'avar', 'gvar'):
if tag in varFont:
del varFont[tag]
# Fix leading bug in drawbot by setting lineGap to 0
varFont['hhea'].lineGap = 0
if DEBUG:
print("Saving instance font", outFile)
varFont.save(outFile)
# Installing the font in DrawBot. Answer font name and path.
return installFont(outFile), outFile
def generateInstance(variableFontPath,
location,
targetDirectory,
normalize=False,
force=False):
instanceName = ""
for k, v in sorted(location.items()):
# TODO better way to normalize the location name to (0, 1000)
v = min(v, 1000)
v = max(v, 0)
instanceName += "-%s%s" % (k, v)
targetFileName = '.'.join(variableFontPath.split('/')[-1].split('.')
[:-1]) + instanceName + '.ttf'
if not targetDirectory.endswith('/'):
targetDirectory += '/'
if not os.path.exists(targetDirectory):
os.makedirs(targetDirectory)
outFile = targetDirectory + targetFileName
if force or not os.path.exists(outFile):
#print location
#print("Loading variable font")
varFont = TTFont(variableFontPath)
fvar = varFont['fvar']
axes = {
a.axisTag: (a.minValue, a.defaultValue, a.maxValue)
for a in fvar.axes
}
# TODO Apply avar
# TODO Round to F2Dot14?
loc = normalizeLocation(location, axes)
# Location is normalized now
#print("Normalized location:", loc, 'from', location)
# Set the instance name IDs in the name table
platforms = ((1, 0, 0), (3, 1, 0x409)) # Macintosh and Windows
for platformID, platEncID, langID in platforms:
familyName = varFont['name'].getName(1, platformID, platEncID,
langID) # 1 Font Family name
if not familyName:
continue
familyName = familyName.toUnicode() # NameRecord to unicode string
styleName = unicode(
instanceName) # TODO make sure this works in any case
fullFontName = " ".join([familyName, styleName])
postscriptName = fullFontName.replace(" ", "-")
varFont['name'].setName(styleName, 2, platformID, platEncID,
langID) # 2 Font Subfamily name
varFont['name'].setName(fullFontName, 4, platformID, platEncID,
langID) # 4 Full font name
varFont['name'].setName(postscriptName, 6, platformID, platEncID,
langID) # 6 Postscript name for the font
# Other important name IDs
# 3 Unique font identifier (e.g. Version 0.000;NONE;Promise Bold Regular)
# 25 Variables PostScript Name Prefix
gvar = varFont['gvar']
glyf = varFont['glyf']
# get list of glyph names in gvar sorted by component depth
glyphnames = sorted(
gvar.variations.keys(),
key=lambda name:
(glyf[name].getCompositeMaxpValues(glyf).maxComponentDepth
if glyf[name].isComposite() else 0, name))
for glyphname in glyphnames:
variations = gvar.variations[glyphname]
coordinates, _ = _GetCoordinates(varFont, glyphname)
origCoords, endPts = None, None
for var in variations:
scalar = supportScalar(loc, var.axes) #, ot=True)
if not scalar: continue
delta = var.coordinates
if None in delta:
if origCoords is None:
origCoords, control = _GetCoordinates(
varFont, glyphname)
endPts = control[1] if control[0] >= 1 else list(
range(len(control[1])))
delta = _iup_delta(delta, origCoords, endPts)
coordinates += GlyphCoordinates(delta) * scalar
_SetCoordinates(varFont, glyphname, coordinates)
#print("Removing variable tables")
for tag in ('avar', 'cvar', 'fvar', 'gvar', 'HVAR', 'MVAR', 'VVAR',
'STAT'):
if tag in varFont:
del varFont[tag]
#print("Saving instance font", outFile)
varFont.save(outFile)
# Installing the font in DrawBot. Answer font name and path.
return c.installFont(outFile), outFile
def generateInstance(variableFontPath,
location,
targetDirectory,
normalize=True,
cached=True,
lazy=True):
"""
D E P R E C A T E D
Use pagebot.fonttoolbox.objects.font.instantiateVariableFont instead
(calling fontTools)
Instantiate an instance of a variable font at the specified location.
Keyword arguments:
varfilename -- a variable font file path
location -- a dictionary of axis tag and value {"wght": 0.75, "wdth":
-0.5}
"""
# make a custom file name from the location e.g. VariableFont-wghtXXX-wdthXXX.ttf
instanceName = ""
for k, v in sorted(location.items()):
# TODO better way to normalize the location name to (0, 1000)
v = min(v, 1000)
v = max(v, 0)
instanceName += "-%s%s" % (k, v)
targetFileName = '.'.join(variableFontPath.split('/')[-1].split('.')
[:-1]) + instanceName + '.ttf'
if not targetDirectory.endswith('/'):
targetDirectory += '/'
if not os.path.exists(targetDirectory):
os.makedirs(targetDirectory)
outFile = targetDirectory + targetFileName
if not cached or not os.path.exists(outFile):
# Instance does not exist as file. Create it.
# print("Loading GX font")
varfont = TTFont(variableFontPath, lazy=lazy)
# Set the instance name IDs in the name table
platforms = ((1, 0, 0), (3, 1, 0x409)) # Macintosh and Windows
for platformID, platEncID, langID in platforms:
familyName = varfont['name'].getName(1, platformID, platEncID,
langID) # 1 Font Family name
if not familyName:
continue
familyName = familyName.toUnicode() # NameRecord to unicode string
styleName = unicode(
instanceName) # TODO make sure this works in any case
fullFontName = " ".join([familyName, styleName])
postscriptName = fullFontName.replace(" ", "-")
varfont['name'].setName(styleName, 2, platformID, platEncID,
langID) # 2 Font Subfamily name
varfont['name'].setName(fullFontName, 4, platformID, platEncID,
langID) # 4 Full font name
varfont['name'].setName(postscriptName, 6, platformID, platEncID,
langID) # 6 Postscript name for the font
# Other important name IDs
# 3 Unique font identifier (e.g. Version 0.000;NONE;Promise Bold Regular)
# 25 Variables PostScript Name Prefix
fvar = varfont['fvar']
axes = {
a.axisTag: (a.minValue, a.defaultValue, a.maxValue)
for a in fvar.axes
}
# TODO Apply avar
# TODO Round to F2Dot14?
loc = normalizeLocation(location, axes)
# Location is normalized now
#print("Normalized location:", loc)
gvar = varfont['gvar']
glyf = varfont['glyf']
# get list of glyph names in gvar sorted by component depth
glyphnames = sorted(
gvar.variations.keys(),
key=lambda name:
(glyf[name].getCompositeMaxpValues(glyf).maxComponentDepth
if glyf[name].isComposite() else 0, name))
for glyphname in glyphnames:
variations = gvar.variations[glyphname]
coordinates, _ = _GetCoordinates(varfont, glyphname)
origCoords, endPts = None, None
for var in variations:
scalar = supportScalar(loc, var.axes) #, ot=True)
if not scalar: continue
delta = var.coordinates
if None in delta:
if origCoords is None:
origCoords, control = _GetCoordinates(
varfont, glyphname)
endPts = control[1] if control[0] >= 1 else list(
range(len(control[1])))
delta = iup_delta(delta, origCoords, endPts)
coordinates += GlyphCoordinates(delta) * scalar
_SetCoordinates(varfont, glyphname, coordinates)
# Interpolate cvt
if 'cvar' in varfont:
cvar = varfont['cvar']
cvt = varfont['cvt ']
deltas = {}
for var in cvar.variations:
scalar = supportScalar(loc, var.axes)
if not scalar: continue
for i, c in enumerate(var.coordinates):
if c is not None:
deltas[i] = deltas.get(i, 0) + scalar * c
for i, delta in deltas.items():
cvt[i] += int(round(delta))
#print("Removing variable tables")
for tag in ('avar', 'cvar', 'fvar', 'gvar', 'HVAR', 'MVAR', 'VVAR',
'STAT'):
if tag in varfont:
del varfont[tag]
#print("Saving instance font", outFile)
varfont.save(outFile)
# Answer the font name path.
return outFile
def main(args=None):
if args is None:
import sys
args = sys.argv[1:]
varfilename = args[0]
locargs = args[1:]
outfile = os.path.splitext(varfilename)[0] + '-instance.ttf'
loc = {}
for arg in locargs:
tag,val = arg.split('=')
assert len(tag) <= 4
loc[tag.ljust(4)] = float(val)
print("Location:", loc)
print("Loading variable font")
varfont = TTFont(varfilename)
fvar = varfont['fvar']
axes = {a.axisTag:(a.minValue,a.defaultValue,a.maxValue) for a in fvar.axes}
# TODO Apply avar
# TODO Round to F2Dot14?
loc = normalizeLocation(loc, axes)
# Location is normalized now
print("Normalized location:", loc)
gvar = varfont['gvar']
glyf = varfont['glyf']
# get list of glyph names in gvar sorted by component depth
glyphnames = sorted(
gvar.variations.keys(),
key=lambda name: (
glyf[name].getCompositeMaxpValues(glyf).maxComponentDepth
if glyf[name].isComposite() else 0,
name))
for glyphname in glyphnames:
variations = gvar.variations[glyphname]
coordinates,_ = _GetCoordinates(varfont, glyphname)
origCoords, endPts = None, None
for var in variations:
scalar = supportScalar(loc, var.axes)
if not scalar: continue
delta = var.coordinates
if None in delta:
if origCoords is None:
origCoords,control = _GetCoordinates(varfont, glyphname)
endPts = control[1] if control[0] >= 1 else list(range(len(control[1])))
delta = _iup_delta(delta, origCoords, endPts)
# TODO Do IUP / handle None items
coordinates += GlyphCoordinates(delta) * scalar
_SetCoordinates(varfont, glyphname, coordinates)
print("Removing variable tables")
for tag in ('avar','cvar','fvar','gvar','HVAR','MVAR','VVAR','STAT'):
if tag in varfont:
del varfont[tag]
print("Saving instance font", outfile)
varfont.save(outfile)
def main(args=None):
if args is None:
import sys
args = sys.argv[1:]
varfilename = args[0]
locargs = args[1:]
outfile = os.path.splitext(varfilename)[0] + '-instance.ttf'
loc = {}
for arg in locargs:
tag, val = arg.split('=')
assert len(tag) <= 4
loc[tag.ljust(4)] = float(val)
print("Location:", loc)
print("Loading variable font")
varfont = TTFont(varfilename)
fvar = varfont['fvar']
axes = {
a.axisTag: (a.minValue, a.defaultValue, a.maxValue)
for a in fvar.axes
}
# TODO Apply avar
# TODO Round to F2Dot14?
loc = normalizeLocation(loc, axes)
# Location is normalized now
print("Normalized location:", loc)
gvar = varfont['gvar']
glyf = varfont['glyf']
# get list of glyph names in gvar sorted by component depth
glyphnames = sorted(
gvar.variations.keys(),
key=lambda name:
(glyf[name].getCompositeMaxpValues(glyf).maxComponentDepth
if glyf[name].isComposite() else 0, name))
for glyphname in glyphnames:
variations = gvar.variations[glyphname]
coordinates, _ = _GetCoordinates(varfont, glyphname)
origCoords, endPts = None, None
for var in variations:
scalar = supportScalar(loc, var.axes, ot=True)
if not scalar: continue
delta = var.coordinates
if None in delta:
if origCoords is None:
origCoords, control = _GetCoordinates(varfont, glyphname)
endPts = control[1] if control[0] >= 1 else list(
range(len(control[1])))
delta = _iup_delta(delta, origCoords, endPts)
coordinates += GlyphCoordinates(delta) * scalar
_SetCoordinates(varfont, glyphname, coordinates)
# Interpolate cvt
if 'cvar' in varfont:
cvar = varfont['cvar']
cvt = varfont['cvt ']
deltas = {}
for var in cvar.variations:
scalar = supportScalar(loc, var.axes)
if not scalar: continue
for i, c in enumerate(var.coordinates):
if c is not None:
deltas[i] = deltas.get(i, 0) + scalar * c
for i, delta in deltas.items():
cvt[i] += int(round(delta))
print("Removing variable tables")
for tag in ('avar', 'cvar', 'fvar', 'gvar', 'HVAR', 'MVAR', 'VVAR',
'STAT'):
if tag in varfont:
del varfont[tag]
print("Saving instance font", outfile)
varfont.save(outfile)
