1927 lines
69 KiB
Python
1927 lines
69 KiB
Python
""" Partially instantiate a variable font.
|
|
|
|
The module exports an `instantiateVariableFont` function and CLI that allow to
|
|
create full instances (i.e. static fonts) from variable fonts, as well as "partial"
|
|
variable fonts that only contain a subset of the original variation space.
|
|
|
|
For example, if you wish to pin the width axis to a given location while also
|
|
restricting the weight axis to 400..700 range, you can do:
|
|
|
|
.. code-block:: sh
|
|
|
|
$ fonttools varLib.instancer ./NotoSans-VF.ttf wdth=85 wght=400:700
|
|
|
|
See `fonttools varLib.instancer --help` for more info on the CLI options.
|
|
|
|
The module's entry point is the `instantiateVariableFont` function, which takes
|
|
a TTFont object and a dict specifying either axis coodinates or (min, max) ranges,
|
|
and returns a new TTFont representing either a partial VF, or full instance if all
|
|
the VF axes were given an explicit coordinate.
|
|
|
|
E.g. here's how to pin the wght axis at a given location in a wght+wdth variable
|
|
font, keeping only the deltas associated with the wdth axis:
|
|
.. code-block:: pycon
|
|
|
|
>>>
|
|
>> from fontTools import ttLib
|
|
>> from fontTools.varLib import instancer
|
|
>> varfont = ttLib.TTFont("path/to/MyVariableFont.ttf")
|
|
>> [a.axisTag for a in varfont["fvar"].axes] # the varfont's current axes
|
|
['wght', 'wdth']
|
|
>> partial = instancer.instantiateVariableFont(varfont, {"wght": 300})
|
|
>> [a.axisTag for a in partial["fvar"].axes] # axes left after pinning 'wght'
|
|
['wdth']
|
|
|
|
If the input location specifies all the axes, the resulting instance is no longer
|
|
'variable' (same as using fontools varLib.mutator):
|
|
.. code-block:: pycon
|
|
|
|
>>>
|
|
>> instance = instancer.instantiateVariableFont(
|
|
... varfont, {"wght": 700, "wdth": 67.5}
|
|
... )
|
|
>> "fvar" not in instance
|
|
True
|
|
|
|
If one just want to drop an axis at the default location, without knowing in
|
|
advance what the default value for that axis is, one can pass a `None` value:
|
|
.. code-block:: pycon
|
|
|
|
>>>
|
|
>> instance = instancer.instantiateVariableFont(varfont, {"wght": None})
|
|
>> len(varfont["fvar"].axes)
|
|
1
|
|
|
|
From the console script, this is equivalent to passing `wght=drop` as input.
|
|
|
|
This module is similar to fontTools.varLib.mutator, which it's intended to supersede.
|
|
Note that, unlike varLib.mutator, when an axis is not mentioned in the input
|
|
location, the varLib.instancer will keep the axis and the corresponding deltas,
|
|
whereas mutator implicitly drops the axis at its default coordinate.
|
|
|
|
The module supports all the following "levels" of instancing, which can of
|
|
course be combined:
|
|
|
|
L1
|
|
dropping one or more axes while leaving the default tables unmodified;
|
|
.. code-block:: pycon
|
|
|
|
>>>
|
|
>> font = instancer.instantiateVariableFont(varfont, {"wght": None})
|
|
|
|
L2
|
|
dropping one or more axes while pinning them at non-default locations;
|
|
.. code-block:: pycon
|
|
|
|
>>>
|
|
>> font = instancer.instantiateVariableFont(varfont, {"wght": 700})
|
|
|
|
L3
|
|
restricting the range of variation of one or more axes, by setting either
|
|
a new minimum or maximum, potentially -- though not necessarily -- dropping
|
|
entire regions of variations that fall completely outside this new range.
|
|
.. code-block:: pycon
|
|
|
|
>>>
|
|
>> font = instancer.instantiateVariableFont(varfont, {"wght": (100, 300)})
|
|
|
|
L4
|
|
moving the default location of an axis, by specifying (min,defalt,max) values:
|
|
.. code-block:: pycon
|
|
|
|
>>>
|
|
>> font = instancer.instantiateVariableFont(varfont, {"wght": (100, 300, 700)})
|
|
|
|
Currently only TrueType-flavored variable fonts (i.e. containing 'glyf' table)
|
|
are supported, but support for CFF2 variable fonts will be added soon.
|
|
|
|
The discussion and implementation of these features are tracked at
|
|
https://github.com/fonttools/fonttools/issues/1537
|
|
"""
|
|
|
|
from fontTools.misc.fixedTools import (
|
|
floatToFixedToFloat,
|
|
strToFixedToFloat,
|
|
otRound,
|
|
)
|
|
from fontTools.varLib.models import normalizeValue, piecewiseLinearMap
|
|
from fontTools.ttLib import TTFont, newTable
|
|
from fontTools.ttLib.tables.TupleVariation import TupleVariation
|
|
from fontTools.ttLib.tables import _g_l_y_f
|
|
from fontTools import varLib
|
|
|
|
# we import the `subset` module because we use the `prune_lookups` method on the GSUB
|
|
# table class, and that method is only defined dynamically upon importing `subset`
|
|
from fontTools import subset # noqa: F401
|
|
from fontTools.cffLib import privateDictOperators2
|
|
from fontTools.cffLib.specializer import (
|
|
programToCommands,
|
|
commandsToProgram,
|
|
specializeCommands,
|
|
generalizeCommands,
|
|
)
|
|
from fontTools.varLib import builder
|
|
from fontTools.varLib.mvar import MVAR_ENTRIES
|
|
from fontTools.varLib.merger import MutatorMerger
|
|
from fontTools.varLib.instancer import names
|
|
from .featureVars import instantiateFeatureVariations
|
|
from fontTools.misc.cliTools import makeOutputFileName
|
|
from fontTools.varLib.instancer import solver
|
|
from fontTools.ttLib.tables.otTables import VarComponentFlags
|
|
import collections
|
|
import dataclasses
|
|
from contextlib import contextmanager
|
|
from copy import deepcopy
|
|
from enum import IntEnum
|
|
import logging
|
|
import os
|
|
import re
|
|
from typing import Dict, Iterable, Mapping, Optional, Sequence, Tuple, Union
|
|
import warnings
|
|
|
|
|
|
log = logging.getLogger("fontTools.varLib.instancer")
|
|
|
|
|
|
def AxisRange(minimum, maximum):
|
|
warnings.warn(
|
|
"AxisRange is deprecated; use AxisTriple instead",
|
|
DeprecationWarning,
|
|
stacklevel=2,
|
|
)
|
|
return AxisTriple(minimum, None, maximum)
|
|
|
|
|
|
def NormalizedAxisRange(minimum, maximum):
|
|
warnings.warn(
|
|
"NormalizedAxisRange is deprecated; use AxisTriple instead",
|
|
DeprecationWarning,
|
|
stacklevel=2,
|
|
)
|
|
return NormalizedAxisTriple(minimum, None, maximum)
|
|
|
|
|
|
@dataclasses.dataclass(frozen=True, order=True, repr=False)
|
|
class AxisTriple(Sequence):
|
|
"""A triple of (min, default, max) axis values.
|
|
|
|
Any of the values can be None, in which case the limitRangeAndPopulateDefaults()
|
|
method can be used to fill in the missing values based on the fvar axis values.
|
|
"""
|
|
|
|
minimum: Optional[float]
|
|
default: Optional[float]
|
|
maximum: Optional[float]
|
|
|
|
def __post_init__(self):
|
|
if self.default is None and self.minimum == self.maximum:
|
|
object.__setattr__(self, "default", self.minimum)
|
|
if (
|
|
(
|
|
self.minimum is not None
|
|
and self.default is not None
|
|
and self.minimum > self.default
|
|
)
|
|
or (
|
|
self.default is not None
|
|
and self.maximum is not None
|
|
and self.default > self.maximum
|
|
)
|
|
or (
|
|
self.minimum is not None
|
|
and self.maximum is not None
|
|
and self.minimum > self.maximum
|
|
)
|
|
):
|
|
raise ValueError(
|
|
f"{type(self).__name__} minimum ({self.minimum}), default ({self.default}), maximum ({self.maximum}) must be in sorted order"
|
|
)
|
|
|
|
def __getitem__(self, i):
|
|
fields = dataclasses.fields(self)
|
|
return getattr(self, fields[i].name)
|
|
|
|
def __len__(self):
|
|
return len(dataclasses.fields(self))
|
|
|
|
def _replace(self, **kwargs):
|
|
return dataclasses.replace(self, **kwargs)
|
|
|
|
def __repr__(self):
|
|
return (
|
|
f"({', '.join(format(v, 'g') if v is not None else 'None' for v in self)})"
|
|
)
|
|
|
|
@classmethod
|
|
def expand(
|
|
cls,
|
|
v: Union[
|
|
"AxisTriple",
|
|
float, # pin axis at single value, same as min==default==max
|
|
Tuple[float, float], # (min, max), restrict axis and keep default
|
|
Tuple[float, float, float], # (min, default, max)
|
|
],
|
|
) -> "AxisTriple":
|
|
"""Convert a single value or a tuple into an AxisTriple.
|
|
|
|
If the input is a single value, it is interpreted as a pin at that value.
|
|
If the input is a tuple, it is interpreted as (min, max) or (min, default, max).
|
|
"""
|
|
if isinstance(v, cls):
|
|
return v
|
|
if isinstance(v, (int, float)):
|
|
return cls(v, v, v)
|
|
try:
|
|
n = len(v)
|
|
except TypeError as e:
|
|
raise ValueError(
|
|
f"expected float, 2- or 3-tuple of floats; got {type(v)}: {v!r}"
|
|
) from e
|
|
default = None
|
|
if n == 2:
|
|
minimum, maximum = v
|
|
elif n >= 3:
|
|
return cls(*v)
|
|
else:
|
|
raise ValueError(f"expected sequence of 2 or 3; got {n}: {v!r}")
|
|
return cls(minimum, default, maximum)
|
|
|
|
def limitRangeAndPopulateDefaults(self, fvarTriple) -> "AxisTriple":
|
|
"""Return a new AxisTriple with the default value filled in.
|
|
|
|
Set default to fvar axis default if the latter is within the min/max range,
|
|
otherwise set default to the min or max value, whichever is closer to the
|
|
fvar axis default.
|
|
If the default value is already set, return self.
|
|
"""
|
|
minimum = self.minimum
|
|
if minimum is None:
|
|
minimum = fvarTriple[0]
|
|
default = self.default
|
|
if default is None:
|
|
default = fvarTriple[1]
|
|
maximum = self.maximum
|
|
if maximum is None:
|
|
maximum = fvarTriple[2]
|
|
|
|
minimum = max(minimum, fvarTriple[0])
|
|
maximum = max(maximum, fvarTriple[0])
|
|
minimum = min(minimum, fvarTriple[2])
|
|
maximum = min(maximum, fvarTriple[2])
|
|
default = max(minimum, min(maximum, default))
|
|
|
|
return AxisTriple(minimum, default, maximum)
|
|
|
|
|
|
@dataclasses.dataclass(frozen=True, order=True, repr=False)
|
|
class NormalizedAxisTriple(AxisTriple):
|
|
"""A triple of (min, default, max) normalized axis values."""
|
|
|
|
minimum: float
|
|
default: float
|
|
maximum: float
|
|
|
|
def __post_init__(self):
|
|
if self.default is None:
|
|
object.__setattr__(self, "default", max(self.minimum, min(self.maximum, 0)))
|
|
if not (-1.0 <= self.minimum <= self.default <= self.maximum <= 1.0):
|
|
raise ValueError(
|
|
"Normalized axis values not in -1..+1 range; got "
|
|
f"minimum={self.minimum:g}, default={self.default:g}, maximum={self.maximum:g})"
|
|
)
|
|
|
|
|
|
@dataclasses.dataclass(frozen=True, order=True, repr=False)
|
|
class NormalizedAxisTripleAndDistances(AxisTriple):
|
|
"""A triple of (min, default, max) normalized axis values,
|
|
with distances between min and default, and default and max,
|
|
in the *pre-normalized* space."""
|
|
|
|
minimum: float
|
|
default: float
|
|
maximum: float
|
|
distanceNegative: Optional[float] = 1
|
|
distancePositive: Optional[float] = 1
|
|
|
|
def __post_init__(self):
|
|
if self.default is None:
|
|
object.__setattr__(self, "default", max(self.minimum, min(self.maximum, 0)))
|
|
if not (-1.0 <= self.minimum <= self.default <= self.maximum <= 1.0):
|
|
raise ValueError(
|
|
"Normalized axis values not in -1..+1 range; got "
|
|
f"minimum={self.minimum:g}, default={self.default:g}, maximum={self.maximum:g})"
|
|
)
|
|
|
|
def reverse_negate(self):
|
|
v = self
|
|
return self.__class__(-v[2], -v[1], -v[0], v[4], v[3])
|
|
|
|
def renormalizeValue(self, v, extrapolate=True):
|
|
"""Renormalizes a normalized value v to the range of this axis,
|
|
considering the pre-normalized distances as well as the new
|
|
axis limits."""
|
|
|
|
lower, default, upper, distanceNegative, distancePositive = self
|
|
assert lower <= default <= upper
|
|
|
|
if not extrapolate:
|
|
v = max(lower, min(upper, v))
|
|
|
|
if v == default:
|
|
return 0
|
|
|
|
if default < 0:
|
|
return -self.reverse_negate().renormalizeValue(-v, extrapolate=extrapolate)
|
|
|
|
# default >= 0 and v != default
|
|
|
|
if v > default:
|
|
return (v - default) / (upper - default)
|
|
|
|
# v < default
|
|
|
|
if lower >= 0:
|
|
return (v - default) / (default - lower)
|
|
|
|
# lower < 0 and v < default
|
|
|
|
totalDistance = distanceNegative * -lower + distancePositive * default
|
|
|
|
if v >= 0:
|
|
vDistance = (default - v) * distancePositive
|
|
else:
|
|
vDistance = -v * distanceNegative + distancePositive * default
|
|
|
|
return -vDistance / totalDistance
|
|
|
|
|
|
class _BaseAxisLimits(Mapping[str, AxisTriple]):
|
|
def __getitem__(self, key: str) -> AxisTriple:
|
|
return self._data[key]
|
|
|
|
def __iter__(self) -> Iterable[str]:
|
|
return iter(self._data)
|
|
|
|
def __len__(self) -> int:
|
|
return len(self._data)
|
|
|
|
def __repr__(self) -> str:
|
|
return f"{type(self).__name__}({self._data!r})"
|
|
|
|
def __str__(self) -> str:
|
|
return str(self._data)
|
|
|
|
def defaultLocation(self) -> Dict[str, float]:
|
|
"""Return a dict of default axis values."""
|
|
return {k: v.default for k, v in self.items()}
|
|
|
|
def pinnedLocation(self) -> Dict[str, float]:
|
|
"""Return a location dict with only the pinned axes."""
|
|
return {k: v.default for k, v in self.items() if v.minimum == v.maximum}
|
|
|
|
|
|
class AxisLimits(_BaseAxisLimits):
|
|
"""Maps axis tags (str) to AxisTriple values."""
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
self._data = data = {}
|
|
for k, v in dict(*args, **kwargs).items():
|
|
if v is None:
|
|
# will be filled in by limitAxesAndPopulateDefaults
|
|
data[k] = v
|
|
else:
|
|
try:
|
|
triple = AxisTriple.expand(v)
|
|
except ValueError as e:
|
|
raise ValueError(f"Invalid axis limits for {k!r}: {v!r}") from e
|
|
data[k] = triple
|
|
|
|
def limitAxesAndPopulateDefaults(self, varfont) -> "AxisLimits":
|
|
"""Return a new AxisLimits with defaults filled in from fvar table.
|
|
|
|
If all axis limits already have defaults, return self.
|
|
"""
|
|
fvar = varfont["fvar"]
|
|
fvarTriples = {
|
|
a.axisTag: (a.minValue, a.defaultValue, a.maxValue) for a in fvar.axes
|
|
}
|
|
newLimits = {}
|
|
for axisTag, triple in self.items():
|
|
fvarTriple = fvarTriples[axisTag]
|
|
default = fvarTriple[1]
|
|
if triple is None:
|
|
newLimits[axisTag] = AxisTriple(default, default, default)
|
|
else:
|
|
newLimits[axisTag] = triple.limitRangeAndPopulateDefaults(fvarTriple)
|
|
return type(self)(newLimits)
|
|
|
|
def normalize(self, varfont, usingAvar=True) -> "NormalizedAxisLimits":
|
|
"""Return a new NormalizedAxisLimits with normalized -1..0..+1 values.
|
|
|
|
If usingAvar is True, the avar table is used to warp the default normalization.
|
|
"""
|
|
fvar = varfont["fvar"]
|
|
badLimits = set(self.keys()).difference(a.axisTag for a in fvar.axes)
|
|
if badLimits:
|
|
raise ValueError("Cannot limit: {} not present in fvar".format(badLimits))
|
|
|
|
axes = {
|
|
a.axisTag: (a.minValue, a.defaultValue, a.maxValue)
|
|
for a in fvar.axes
|
|
if a.axisTag in self
|
|
}
|
|
|
|
avarSegments = {}
|
|
if usingAvar and "avar" in varfont:
|
|
avarSegments = varfont["avar"].segments
|
|
|
|
normalizedLimits = {}
|
|
|
|
for axis_tag, triple in axes.items():
|
|
distanceNegative = triple[1] - triple[0]
|
|
distancePositive = triple[2] - triple[1]
|
|
|
|
if self[axis_tag] is None:
|
|
normalizedLimits[axis_tag] = NormalizedAxisTripleAndDistances(
|
|
0, 0, 0, distanceNegative, distancePositive
|
|
)
|
|
continue
|
|
|
|
minV, defaultV, maxV = self[axis_tag]
|
|
|
|
if defaultV is None:
|
|
defaultV = triple[1]
|
|
|
|
avarMapping = avarSegments.get(axis_tag, None)
|
|
normalizedLimits[axis_tag] = NormalizedAxisTripleAndDistances(
|
|
*(normalize(v, triple, avarMapping) for v in (minV, defaultV, maxV)),
|
|
distanceNegative,
|
|
distancePositive,
|
|
)
|
|
|
|
return NormalizedAxisLimits(normalizedLimits)
|
|
|
|
|
|
class NormalizedAxisLimits(_BaseAxisLimits):
|
|
"""Maps axis tags (str) to NormalizedAxisTriple values."""
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
self._data = data = {}
|
|
for k, v in dict(*args, **kwargs).items():
|
|
try:
|
|
triple = NormalizedAxisTripleAndDistances.expand(v)
|
|
except ValueError as e:
|
|
raise ValueError(f"Invalid axis limits for {k!r}: {v!r}") from e
|
|
data[k] = triple
|
|
|
|
|
|
class OverlapMode(IntEnum):
|
|
KEEP_AND_DONT_SET_FLAGS = 0
|
|
KEEP_AND_SET_FLAGS = 1
|
|
REMOVE = 2
|
|
REMOVE_AND_IGNORE_ERRORS = 3
|
|
|
|
|
|
def instantiateVARC(varfont, axisLimits):
|
|
log.info("Instantiating VARC tables")
|
|
|
|
# TODO(behdad) My confidence in this function is rather low;
|
|
# It needs more testing. Specially with partial-instancing,
|
|
# I don't think it currently works.
|
|
|
|
varc = varfont["VARC"].table
|
|
fvarAxes = varfont["fvar"].axes if "fvar" in varfont else []
|
|
|
|
location = axisLimits.pinnedLocation()
|
|
axisMap = [i for i, axis in enumerate(fvarAxes) if axis.axisTag not in location]
|
|
reverseAxisMap = {i: j for j, i in enumerate(axisMap)}
|
|
|
|
if varc.AxisIndicesList:
|
|
axisIndicesList = varc.AxisIndicesList.Item
|
|
for i, axisIndices in enumerate(axisIndicesList):
|
|
if any(fvarAxes[j].axisTag in axisLimits for j in axisIndices):
|
|
raise NotImplementedError(
|
|
"Instancing across VarComponent axes is not supported."
|
|
)
|
|
axisIndicesList[i] = [reverseAxisMap[j] for j in axisIndices]
|
|
|
|
store = varc.MultiVarStore
|
|
if store:
|
|
for region in store.SparseVarRegionList.Region:
|
|
newRegionAxis = []
|
|
for regionRecord in region.SparseVarRegionAxis:
|
|
tag = fvarAxes[regionRecord.AxisIndex].axisTag
|
|
if tag in axisLimits:
|
|
raise NotImplementedError(
|
|
"Instancing across VarComponent axes is not supported."
|
|
)
|
|
regionRecord.AxisIndex = reverseAxisMap[regionRecord.AxisIndex]
|
|
|
|
|
|
def instantiateTupleVariationStore(
|
|
variations, axisLimits, origCoords=None, endPts=None
|
|
):
|
|
"""Instantiate TupleVariation list at the given location, or limit axes' min/max.
|
|
|
|
The 'variations' list of TupleVariation objects is modified in-place.
|
|
The 'axisLimits' (dict) maps axis tags (str) to NormalizedAxisTriple namedtuples
|
|
specifying (minimum, default, maximum) in the -1,0,+1 normalized space. Pinned axes
|
|
have minimum == default == maximum.
|
|
|
|
A 'full' instance (i.e. static font) is produced when all the axes are pinned to
|
|
single coordinates; a 'partial' instance (i.e. a less variable font) is produced
|
|
when some of the axes are omitted, or restricted with a new range.
|
|
|
|
Tuples that do not participate are kept as they are. Those that have 0 influence
|
|
at the given location are removed from the variation store.
|
|
Those that are fully instantiated (i.e. all their axes are being pinned) are also
|
|
removed from the variation store, their scaled deltas accummulated and returned, so
|
|
that they can be added by the caller to the default instance's coordinates.
|
|
Tuples that are only partially instantiated (i.e. not all the axes that they
|
|
participate in are being pinned) are kept in the store, and their deltas multiplied
|
|
by the scalar support of the axes to be pinned at the desired location.
|
|
|
|
Args:
|
|
variations: List[TupleVariation] from either 'gvar' or 'cvar'.
|
|
axisLimits: NormalizedAxisLimits: map from axis tags to (min, default, max)
|
|
normalized coordinates for the full or partial instance.
|
|
origCoords: GlyphCoordinates: default instance's coordinates for computing 'gvar'
|
|
inferred points (cf. table__g_l_y_f._getCoordinatesAndControls).
|
|
endPts: List[int]: indices of contour end points, for inferring 'gvar' deltas.
|
|
|
|
Returns:
|
|
List[float]: the overall delta adjustment after applicable deltas were summed.
|
|
"""
|
|
|
|
newVariations = changeTupleVariationsAxisLimits(variations, axisLimits)
|
|
|
|
mergedVariations = collections.OrderedDict()
|
|
for var in newVariations:
|
|
# compute inferred deltas only for gvar ('origCoords' is None for cvar)
|
|
if origCoords is not None:
|
|
var.calcInferredDeltas(origCoords, endPts)
|
|
|
|
# merge TupleVariations with overlapping "tents"
|
|
axes = frozenset(var.axes.items())
|
|
if axes in mergedVariations:
|
|
mergedVariations[axes] += var
|
|
else:
|
|
mergedVariations[axes] = var
|
|
|
|
# drop TupleVariation if all axes have been pinned (var.axes.items() is empty);
|
|
# its deltas will be added to the default instance's coordinates
|
|
defaultVar = mergedVariations.pop(frozenset(), None)
|
|
|
|
for var in mergedVariations.values():
|
|
var.roundDeltas()
|
|
variations[:] = list(mergedVariations.values())
|
|
|
|
return defaultVar.coordinates if defaultVar is not None else []
|
|
|
|
|
|
def changeTupleVariationsAxisLimits(variations, axisLimits):
|
|
for axisTag, axisLimit in sorted(axisLimits.items()):
|
|
newVariations = []
|
|
for var in variations:
|
|
newVariations.extend(changeTupleVariationAxisLimit(var, axisTag, axisLimit))
|
|
variations = newVariations
|
|
return variations
|
|
|
|
|
|
def changeTupleVariationAxisLimit(var, axisTag, axisLimit):
|
|
assert isinstance(axisLimit, NormalizedAxisTripleAndDistances)
|
|
|
|
# Skip when current axis is missing or peaks at 0 (i.e. doesn't participate)
|
|
lower, peak, upper = var.axes.get(axisTag, (-1, 0, 1))
|
|
if peak == 0:
|
|
# explicitly defined, no-op axes can be omitted
|
|
# https://github.com/fonttools/fonttools/issues/3453
|
|
if axisTag in var.axes:
|
|
del var.axes[axisTag]
|
|
return [var]
|
|
# Drop if the var 'tent' isn't well-formed
|
|
if not (lower <= peak <= upper) or (lower < 0 and upper > 0):
|
|
return []
|
|
|
|
if axisTag not in var.axes:
|
|
return [var]
|
|
|
|
tent = var.axes[axisTag]
|
|
|
|
solutions = solver.rebaseTent(tent, axisLimit)
|
|
|
|
out = []
|
|
for scalar, tent in solutions:
|
|
newVar = (
|
|
TupleVariation(var.axes, var.coordinates) if len(solutions) > 1 else var
|
|
)
|
|
if tent is None:
|
|
newVar.axes.pop(axisTag)
|
|
else:
|
|
assert tent[1] != 0, tent
|
|
newVar.axes[axisTag] = tent
|
|
newVar *= scalar
|
|
out.append(newVar)
|
|
|
|
return out
|
|
|
|
|
|
def instantiateCFF2(
|
|
varfont,
|
|
axisLimits,
|
|
*,
|
|
round=round,
|
|
specialize=True,
|
|
generalize=False,
|
|
downgrade=False,
|
|
):
|
|
# The algorithm here is rather simple:
|
|
#
|
|
# Take all blend operations and store their deltas in the (otherwise empty)
|
|
# CFF2 VarStore. Then, instantiate the VarStore with the given axis limits,
|
|
# and read back the new deltas. This is done for both the CharStrings and
|
|
# the Private dicts.
|
|
#
|
|
# Then prune unused things and possibly drop the VarStore if it's empty.
|
|
# In which case, downgrade to CFF table if requested.
|
|
|
|
log.info("Instantiating CFF2 table")
|
|
|
|
fvarAxes = varfont["fvar"].axes
|
|
|
|
cff = varfont["CFF2"].cff
|
|
topDict = cff.topDictIndex[0]
|
|
varStore = topDict.VarStore.otVarStore
|
|
if not varStore:
|
|
if downgrade:
|
|
from fontTools.cffLib.CFF2ToCFF import convertCFF2ToCFF
|
|
|
|
convertCFF2ToCFF(varfont)
|
|
return
|
|
|
|
cff.desubroutinize()
|
|
|
|
def getNumRegions(vsindex):
|
|
return varStore.VarData[vsindex if vsindex is not None else 0].VarRegionCount
|
|
|
|
charStrings = topDict.CharStrings.values()
|
|
|
|
# Gather all unique private dicts
|
|
uniquePrivateDicts = set()
|
|
privateDicts = []
|
|
for fd in topDict.FDArray:
|
|
if fd.Private not in uniquePrivateDicts:
|
|
uniquePrivateDicts.add(fd.Private)
|
|
privateDicts.append(fd.Private)
|
|
|
|
allCommands = []
|
|
for cs in charStrings:
|
|
assert cs.private.vstore.otVarStore is varStore # Or in many places!!
|
|
commands = programToCommands(cs.program, getNumRegions=getNumRegions)
|
|
if generalize:
|
|
commands = generalizeCommands(commands)
|
|
if specialize:
|
|
commands = specializeCommands(commands, generalizeFirst=not generalize)
|
|
allCommands.append(commands)
|
|
|
|
def storeBlendsToVarStore(arg):
|
|
if not isinstance(arg, list):
|
|
return
|
|
|
|
if any(isinstance(subarg, list) for subarg in arg[:-1]):
|
|
raise NotImplementedError("Nested blend lists not supported (yet)")
|
|
|
|
count = arg[-1]
|
|
assert (len(arg) - 1) % count == 0
|
|
nRegions = (len(arg) - 1) // count - 1
|
|
assert nRegions == getNumRegions(vsindex)
|
|
for i in range(count, len(arg) - 1, nRegions):
|
|
deltas = arg[i : i + nRegions]
|
|
assert len(deltas) == nRegions
|
|
varData = varStore.VarData[vsindex]
|
|
varData.Item.append(deltas)
|
|
varData.ItemCount += 1
|
|
|
|
def fetchBlendsFromVarStore(arg):
|
|
if not isinstance(arg, list):
|
|
return [arg]
|
|
|
|
if any(isinstance(subarg, list) for subarg in arg[:-1]):
|
|
raise NotImplementedError("Nested blend lists not supported (yet)")
|
|
|
|
count = arg[-1]
|
|
assert (len(arg) - 1) % count == 0
|
|
numRegions = getNumRegions(vsindex)
|
|
newDefaults = []
|
|
newDeltas = []
|
|
for i in range(count):
|
|
defaultValue = arg[i]
|
|
|
|
major = vsindex
|
|
minor = varDataCursor[major]
|
|
varDataCursor[major] += 1
|
|
|
|
varIdx = (major << 16) + minor
|
|
|
|
defaultValue += round(defaultDeltas[varIdx])
|
|
newDefaults.append(defaultValue)
|
|
|
|
varData = varStore.VarData[major]
|
|
deltas = varData.Item[minor]
|
|
assert len(deltas) == numRegions
|
|
newDeltas.extend(deltas)
|
|
|
|
if not numRegions:
|
|
return newDefaults # No deltas, just return the defaults
|
|
|
|
return [newDefaults + newDeltas + [count]]
|
|
|
|
# Check VarData's are empty
|
|
for varData in varStore.VarData:
|
|
assert varData.Item == []
|
|
assert varData.ItemCount == 0
|
|
|
|
# Add charstring blend lists to VarStore so we can instantiate them
|
|
for commands in allCommands:
|
|
vsindex = 0
|
|
for command in commands:
|
|
if command[0] == "vsindex":
|
|
vsindex = command[1][0]
|
|
continue
|
|
for arg in command[1]:
|
|
storeBlendsToVarStore(arg)
|
|
|
|
# Add private blend lists to VarStore so we can instantiate values
|
|
vsindex = 0
|
|
for opcode, name, arg_type, default, converter in privateDictOperators2:
|
|
if arg_type not in ("number", "delta", "array"):
|
|
continue
|
|
|
|
vsindex = 0
|
|
for private in privateDicts:
|
|
if not hasattr(private, name):
|
|
continue
|
|
values = getattr(private, name)
|
|
|
|
if name == "vsindex":
|
|
vsindex = values[0]
|
|
continue
|
|
|
|
if arg_type == "number":
|
|
values = [values]
|
|
|
|
for value in values:
|
|
if not isinstance(value, list):
|
|
continue
|
|
|
|
assert len(value) % (getNumRegions(vsindex) + 1) == 0
|
|
count = len(value) // (getNumRegions(vsindex) + 1)
|
|
storeBlendsToVarStore(value + [count])
|
|
|
|
# Instantiate VarStore
|
|
defaultDeltas = instantiateItemVariationStore(varStore, fvarAxes, axisLimits)
|
|
|
|
# Read back new charstring blends from the instantiated VarStore
|
|
varDataCursor = [0] * len(varStore.VarData)
|
|
for commands in allCommands:
|
|
vsindex = 0
|
|
for command in commands:
|
|
if command[0] == "vsindex":
|
|
vsindex = command[1][0]
|
|
continue
|
|
newArgs = []
|
|
for arg in command[1]:
|
|
newArgs.extend(fetchBlendsFromVarStore(arg))
|
|
command[1][:] = newArgs
|
|
|
|
# Read back new private blends from the instantiated VarStore
|
|
for opcode, name, arg_type, default, converter in privateDictOperators2:
|
|
if arg_type not in ("number", "delta", "array"):
|
|
continue
|
|
|
|
for private in privateDicts:
|
|
if not hasattr(private, name):
|
|
continue
|
|
values = getattr(private, name)
|
|
if arg_type == "number":
|
|
values = [values]
|
|
|
|
newValues = []
|
|
for value in values:
|
|
if not isinstance(value, list):
|
|
newValues.append(value)
|
|
continue
|
|
|
|
value.append(1)
|
|
value = fetchBlendsFromVarStore(value)
|
|
newValues.extend(v[:-1] if isinstance(v, list) else v for v in value)
|
|
|
|
if arg_type == "number":
|
|
newValues = newValues[0]
|
|
|
|
setattr(private, name, newValues)
|
|
|
|
# Empty out the VarStore
|
|
for i, varData in enumerate(varStore.VarData):
|
|
assert varDataCursor[i] == varData.ItemCount, (
|
|
varDataCursor[i],
|
|
varData.ItemCount,
|
|
)
|
|
varData.Item = []
|
|
varData.ItemCount = 0
|
|
|
|
# Remove vsindex commands that are no longer needed, collect those that are.
|
|
usedVsindex = set()
|
|
for commands in allCommands:
|
|
if any(isinstance(arg, list) for command in commands for arg in command[1]):
|
|
vsindex = 0
|
|
for command in commands:
|
|
if command[0] == "vsindex":
|
|
vsindex = command[1][0]
|
|
continue
|
|
if any(isinstance(arg, list) for arg in command[1]):
|
|
usedVsindex.add(vsindex)
|
|
else:
|
|
commands[:] = [command for command in commands if command[0] != "vsindex"]
|
|
|
|
# Remove unused VarData and update vsindex values
|
|
vsindexMapping = {v: i for i, v in enumerate(sorted(usedVsindex))}
|
|
varStore.VarData = [
|
|
varData for i, varData in enumerate(varStore.VarData) if i in usedVsindex
|
|
]
|
|
varStore.VarDataCount = len(varStore.VarData)
|
|
for commands in allCommands:
|
|
for command in commands:
|
|
if command[0] == "vsindex":
|
|
command[1][0] = vsindexMapping[command[1][0]]
|
|
|
|
# Remove initial vsindex commands that are implied
|
|
for commands in allCommands:
|
|
if commands and commands[0] == ("vsindex", [0]):
|
|
commands.pop(0)
|
|
|
|
# Ship the charstrings!
|
|
for cs, commands in zip(charStrings, allCommands):
|
|
cs.program = commandsToProgram(commands)
|
|
|
|
# Remove empty VarStore
|
|
if not varStore.VarData:
|
|
if "VarStore" in topDict.rawDict:
|
|
del topDict.rawDict["VarStore"]
|
|
del topDict.VarStore
|
|
del topDict.CharStrings.varStore
|
|
for private in privateDicts:
|
|
del private.vstore
|
|
|
|
if downgrade:
|
|
from fontTools.cffLib.CFF2ToCFF import convertCFF2ToCFF
|
|
|
|
convertCFF2ToCFF(varfont)
|
|
|
|
|
|
def _instantiateGvarGlyph(
|
|
glyphname, glyf, gvar, hMetrics, vMetrics, axisLimits, optimize=True
|
|
):
|
|
coordinates, ctrl = glyf._getCoordinatesAndControls(glyphname, hMetrics, vMetrics)
|
|
endPts = ctrl.endPts
|
|
|
|
# Not every glyph may have variations
|
|
tupleVarStore = gvar.variations.get(glyphname)
|
|
|
|
if tupleVarStore:
|
|
defaultDeltas = instantiateTupleVariationStore(
|
|
tupleVarStore, axisLimits, coordinates, endPts
|
|
)
|
|
|
|
if defaultDeltas:
|
|
coordinates += _g_l_y_f.GlyphCoordinates(defaultDeltas)
|
|
|
|
# _setCoordinates also sets the hmtx/vmtx advance widths and sidebearings from
|
|
# the four phantom points and glyph bounding boxes.
|
|
# We call it unconditionally even if a glyph has no variations or no deltas are
|
|
# applied at this location, in case the glyph's xMin and in turn its sidebearing
|
|
# have changed. E.g. a composite glyph has no deltas for the component's (x, y)
|
|
# offset nor for the 4 phantom points (e.g. it's monospaced). Thus its entry in
|
|
# gvar table is empty; however, the composite's base glyph may have deltas
|
|
# applied, hence the composite's bbox and left/top sidebearings may need updating
|
|
# in the instanced font.
|
|
glyf._setCoordinates(glyphname, coordinates, hMetrics, vMetrics)
|
|
|
|
if not tupleVarStore:
|
|
if glyphname in gvar.variations:
|
|
del gvar.variations[glyphname]
|
|
return
|
|
|
|
if optimize:
|
|
isComposite = glyf[glyphname].isComposite()
|
|
for var in tupleVarStore:
|
|
var.optimize(coordinates, endPts, isComposite=isComposite)
|
|
|
|
|
|
def instantiateGvarGlyph(varfont, glyphname, axisLimits, optimize=True):
|
|
"""Remove?
|
|
https://github.com/fonttools/fonttools/pull/2266"""
|
|
gvar = varfont["gvar"]
|
|
glyf = varfont["glyf"]
|
|
hMetrics = varfont["hmtx"].metrics
|
|
vMetrics = getattr(varfont.get("vmtx"), "metrics", None)
|
|
_instantiateGvarGlyph(
|
|
glyphname, glyf, gvar, hMetrics, vMetrics, axisLimits, optimize=optimize
|
|
)
|
|
|
|
|
|
def instantiateGvar(varfont, axisLimits, optimize=True):
|
|
log.info("Instantiating glyf/gvar tables")
|
|
|
|
gvar = varfont["gvar"]
|
|
glyf = varfont["glyf"]
|
|
hMetrics = varfont["hmtx"].metrics
|
|
vMetrics = getattr(varfont.get("vmtx"), "metrics", None)
|
|
# Get list of glyph names sorted by component depth.
|
|
# If a composite glyph is processed before its base glyph, the bounds may
|
|
# be calculated incorrectly because deltas haven't been applied to the
|
|
# base glyph yet.
|
|
glyphnames = sorted(
|
|
glyf.glyphOrder,
|
|
key=lambda name: (
|
|
(
|
|
glyf[name].getCompositeMaxpValues(glyf).maxComponentDepth
|
|
if glyf[name].isComposite()
|
|
else 0
|
|
),
|
|
name,
|
|
),
|
|
)
|
|
for glyphname in glyphnames:
|
|
_instantiateGvarGlyph(
|
|
glyphname, glyf, gvar, hMetrics, vMetrics, axisLimits, optimize=optimize
|
|
)
|
|
|
|
if not gvar.variations:
|
|
del varfont["gvar"]
|
|
|
|
|
|
def setCvarDeltas(cvt, deltas):
|
|
for i, delta in enumerate(deltas):
|
|
if delta:
|
|
cvt[i] += otRound(delta)
|
|
|
|
|
|
def instantiateCvar(varfont, axisLimits):
|
|
log.info("Instantiating cvt/cvar tables")
|
|
|
|
cvar = varfont["cvar"]
|
|
|
|
defaultDeltas = instantiateTupleVariationStore(cvar.variations, axisLimits)
|
|
|
|
if defaultDeltas:
|
|
setCvarDeltas(varfont["cvt "], defaultDeltas)
|
|
|
|
if not cvar.variations:
|
|
del varfont["cvar"]
|
|
|
|
|
|
def setMvarDeltas(varfont, deltas):
|
|
mvar = varfont["MVAR"].table
|
|
records = mvar.ValueRecord
|
|
for rec in records:
|
|
mvarTag = rec.ValueTag
|
|
if mvarTag not in MVAR_ENTRIES:
|
|
continue
|
|
tableTag, itemName = MVAR_ENTRIES[mvarTag]
|
|
delta = deltas[rec.VarIdx]
|
|
if delta != 0:
|
|
setattr(
|
|
varfont[tableTag],
|
|
itemName,
|
|
getattr(varfont[tableTag], itemName) + otRound(delta),
|
|
)
|
|
|
|
|
|
@contextmanager
|
|
def verticalMetricsKeptInSync(varfont):
|
|
"""Ensure hhea vertical metrics stay in sync with OS/2 ones after instancing.
|
|
|
|
When applying MVAR deltas to the OS/2 table, if the ascender, descender and
|
|
line gap change but they were the same as the respective hhea metrics in the
|
|
original font, this context manager ensures that hhea metrcs also get updated
|
|
accordingly.
|
|
The MVAR spec only has tags for the OS/2 metrics, but it is common in fonts
|
|
to have the hhea metrics be equal to those for compat reasons.
|
|
|
|
https://learn.microsoft.com/en-us/typography/opentype/spec/mvar
|
|
https://googlefonts.github.io/gf-guide/metrics.html#7-hhea-and-typo-metrics-should-be-equal
|
|
https://github.com/fonttools/fonttools/issues/3297
|
|
"""
|
|
current_os2_vmetrics = [
|
|
getattr(varfont["OS/2"], attr)
|
|
for attr in ("sTypoAscender", "sTypoDescender", "sTypoLineGap")
|
|
]
|
|
metrics_are_synced = current_os2_vmetrics == [
|
|
getattr(varfont["hhea"], attr) for attr in ("ascender", "descender", "lineGap")
|
|
]
|
|
|
|
yield metrics_are_synced
|
|
|
|
if metrics_are_synced:
|
|
new_os2_vmetrics = [
|
|
getattr(varfont["OS/2"], attr)
|
|
for attr in ("sTypoAscender", "sTypoDescender", "sTypoLineGap")
|
|
]
|
|
if current_os2_vmetrics != new_os2_vmetrics:
|
|
for attr, value in zip(
|
|
("ascender", "descender", "lineGap"), new_os2_vmetrics
|
|
):
|
|
setattr(varfont["hhea"], attr, value)
|
|
|
|
|
|
def instantiateMVAR(varfont, axisLimits):
|
|
log.info("Instantiating MVAR table")
|
|
|
|
mvar = varfont["MVAR"].table
|
|
fvarAxes = varfont["fvar"].axes
|
|
varStore = mvar.VarStore
|
|
defaultDeltas = instantiateItemVariationStore(varStore, fvarAxes, axisLimits)
|
|
|
|
with verticalMetricsKeptInSync(varfont):
|
|
setMvarDeltas(varfont, defaultDeltas)
|
|
|
|
if varStore.VarRegionList.Region:
|
|
varIndexMapping = varStore.optimize()
|
|
for rec in mvar.ValueRecord:
|
|
rec.VarIdx = varIndexMapping[rec.VarIdx]
|
|
else:
|
|
del varfont["MVAR"]
|
|
|
|
|
|
def _remapVarIdxMap(table, attrName, varIndexMapping, glyphOrder):
|
|
oldMapping = getattr(table, attrName).mapping
|
|
newMapping = [varIndexMapping[oldMapping[glyphName]] for glyphName in glyphOrder]
|
|
setattr(table, attrName, builder.buildVarIdxMap(newMapping, glyphOrder))
|
|
|
|
|
|
# TODO(anthrotype) Add support for HVAR/VVAR in CFF2
|
|
def _instantiateVHVAR(varfont, axisLimits, tableFields, *, round=round):
|
|
location = axisLimits.pinnedLocation()
|
|
tableTag = tableFields.tableTag
|
|
fvarAxes = varfont["fvar"].axes
|
|
|
|
log.info("Instantiating %s table", tableTag)
|
|
vhvar = varfont[tableTag].table
|
|
varStore = vhvar.VarStore
|
|
|
|
if "glyf" in varfont:
|
|
# Deltas from gvar table have already been applied to the hmtx/vmtx. For full
|
|
# instances (i.e. all axes pinned), we can simply drop HVAR/VVAR and return
|
|
if set(location).issuperset(axis.axisTag for axis in fvarAxes):
|
|
log.info("Dropping %s table", tableTag)
|
|
del varfont[tableTag]
|
|
return
|
|
|
|
defaultDeltas = instantiateItemVariationStore(varStore, fvarAxes, axisLimits)
|
|
|
|
if "glyf" not in varfont:
|
|
# CFF2 fonts need hmtx/vmtx updated here. For glyf fonts, the instantiateGvar
|
|
# function already updated the hmtx/vmtx from phantom points. Maybe remove
|
|
# that and do it here for both CFF2 and glyf fonts?
|
|
#
|
|
# Specially, if a font has glyf but not gvar, the hmtx/vmtx will not have been
|
|
# updated by instantiateGvar. Though one can call that a faulty font.
|
|
metricsTag = "vmtx" if tableTag == "VVAR" else "hmtx"
|
|
if metricsTag in varfont:
|
|
advMapping = getattr(vhvar, tableFields.advMapping)
|
|
metricsTable = varfont[metricsTag]
|
|
metrics = metricsTable.metrics
|
|
for glyphName, (advanceWidth, sb) in metrics.items():
|
|
if advMapping:
|
|
varIdx = advMapping.mapping[glyphName]
|
|
else:
|
|
varIdx = varfont.getGlyphID(glyphName)
|
|
metrics[glyphName] = (advanceWidth + round(defaultDeltas[varIdx]), sb)
|
|
|
|
if (
|
|
tableTag == "VVAR"
|
|
and getattr(vhvar, tableFields.vOrigMapping) is not None
|
|
):
|
|
log.warning(
|
|
"VORG table not yet updated to reflect changes in VVAR table"
|
|
)
|
|
|
|
# For full instances (i.e. all axes pinned), we can simply drop HVAR/VVAR and return
|
|
if set(location).issuperset(axis.axisTag for axis in fvarAxes):
|
|
log.info("Dropping %s table", tableTag)
|
|
del varfont[tableTag]
|
|
return
|
|
|
|
if varStore.VarRegionList.Region:
|
|
# Only re-optimize VarStore if the HVAR/VVAR already uses indirect AdvWidthMap
|
|
# or AdvHeightMap. If a direct, implicit glyphID->VariationIndex mapping is
|
|
# used for advances, skip re-optimizing and maintain original VariationIndex.
|
|
if getattr(vhvar, tableFields.advMapping):
|
|
varIndexMapping = varStore.optimize(use_NO_VARIATION_INDEX=False)
|
|
glyphOrder = varfont.getGlyphOrder()
|
|
_remapVarIdxMap(vhvar, tableFields.advMapping, varIndexMapping, glyphOrder)
|
|
if getattr(vhvar, tableFields.sb1): # left or top sidebearings
|
|
_remapVarIdxMap(vhvar, tableFields.sb1, varIndexMapping, glyphOrder)
|
|
if getattr(vhvar, tableFields.sb2): # right or bottom sidebearings
|
|
_remapVarIdxMap(vhvar, tableFields.sb2, varIndexMapping, glyphOrder)
|
|
if tableTag == "VVAR" and getattr(vhvar, tableFields.vOrigMapping):
|
|
_remapVarIdxMap(
|
|
vhvar, tableFields.vOrigMapping, varIndexMapping, glyphOrder
|
|
)
|
|
|
|
|
|
def instantiateHVAR(varfont, axisLimits):
|
|
return _instantiateVHVAR(varfont, axisLimits, varLib.HVAR_FIELDS)
|
|
|
|
|
|
def instantiateVVAR(varfont, axisLimits):
|
|
return _instantiateVHVAR(varfont, axisLimits, varLib.VVAR_FIELDS)
|
|
|
|
|
|
class _TupleVarStoreAdapter(object):
|
|
def __init__(self, regions, axisOrder, tupleVarData, itemCounts):
|
|
self.regions = regions
|
|
self.axisOrder = axisOrder
|
|
self.tupleVarData = tupleVarData
|
|
self.itemCounts = itemCounts
|
|
|
|
@classmethod
|
|
def fromItemVarStore(cls, itemVarStore, fvarAxes):
|
|
axisOrder = [axis.axisTag for axis in fvarAxes]
|
|
regions = [
|
|
region.get_support(fvarAxes) for region in itemVarStore.VarRegionList.Region
|
|
]
|
|
tupleVarData = []
|
|
itemCounts = []
|
|
for varData in itemVarStore.VarData:
|
|
variations = []
|
|
varDataRegions = (regions[i] for i in varData.VarRegionIndex)
|
|
for axes, coordinates in zip(varDataRegions, zip(*varData.Item)):
|
|
variations.append(TupleVariation(axes, list(coordinates)))
|
|
tupleVarData.append(variations)
|
|
itemCounts.append(varData.ItemCount)
|
|
return cls(regions, axisOrder, tupleVarData, itemCounts)
|
|
|
|
def rebuildRegions(self):
|
|
# Collect the set of all unique region axes from the current TupleVariations.
|
|
# We use an OrderedDict to de-duplicate regions while keeping the order.
|
|
uniqueRegions = collections.OrderedDict.fromkeys(
|
|
(
|
|
frozenset(var.axes.items())
|
|
for variations in self.tupleVarData
|
|
for var in variations
|
|
)
|
|
)
|
|
# Maintain the original order for the regions that pre-existed, appending
|
|
# the new regions at the end of the region list.
|
|
newRegions = []
|
|
for region in self.regions:
|
|
regionAxes = frozenset(region.items())
|
|
if regionAxes in uniqueRegions:
|
|
newRegions.append(region)
|
|
del uniqueRegions[regionAxes]
|
|
if uniqueRegions:
|
|
newRegions.extend(dict(region) for region in uniqueRegions)
|
|
self.regions = newRegions
|
|
|
|
def instantiate(self, axisLimits):
|
|
defaultDeltaArray = []
|
|
for variations, itemCount in zip(self.tupleVarData, self.itemCounts):
|
|
defaultDeltas = instantiateTupleVariationStore(variations, axisLimits)
|
|
if not defaultDeltas:
|
|
defaultDeltas = [0] * itemCount
|
|
defaultDeltaArray.append(defaultDeltas)
|
|
|
|
# rebuild regions whose axes were dropped or limited
|
|
self.rebuildRegions()
|
|
|
|
pinnedAxes = set(axisLimits.pinnedLocation())
|
|
self.axisOrder = [
|
|
axisTag for axisTag in self.axisOrder if axisTag not in pinnedAxes
|
|
]
|
|
|
|
return defaultDeltaArray
|
|
|
|
def asItemVarStore(self):
|
|
regionOrder = [frozenset(axes.items()) for axes in self.regions]
|
|
varDatas = []
|
|
for variations, itemCount in zip(self.tupleVarData, self.itemCounts):
|
|
if variations:
|
|
assert len(variations[0].coordinates) == itemCount
|
|
varRegionIndices = [
|
|
regionOrder.index(frozenset(var.axes.items())) for var in variations
|
|
]
|
|
varDataItems = list(zip(*(var.coordinates for var in variations)))
|
|
varDatas.append(
|
|
builder.buildVarData(varRegionIndices, varDataItems, optimize=False)
|
|
)
|
|
else:
|
|
varDatas.append(
|
|
builder.buildVarData([], [[] for _ in range(itemCount)])
|
|
)
|
|
regionList = builder.buildVarRegionList(self.regions, self.axisOrder)
|
|
itemVarStore = builder.buildVarStore(regionList, varDatas)
|
|
# remove unused regions from VarRegionList
|
|
itemVarStore.prune_regions()
|
|
return itemVarStore
|
|
|
|
|
|
def instantiateItemVariationStore(itemVarStore, fvarAxes, axisLimits):
|
|
"""Compute deltas at partial location, and update varStore in-place.
|
|
|
|
Remove regions in which all axes were instanced, or fall outside the new axis
|
|
limits. Scale the deltas of the remaining regions where only some of the axes
|
|
were instanced.
|
|
|
|
The number of VarData subtables, and the number of items within each, are
|
|
not modified, in order to keep the existing VariationIndex valid.
|
|
One may call VarStore.optimize() method after this to further optimize those.
|
|
|
|
Args:
|
|
varStore: An otTables.VarStore object (Item Variation Store)
|
|
fvarAxes: list of fvar's Axis objects
|
|
axisLimits: NormalizedAxisLimits: mapping axis tags to normalized
|
|
min/default/max axis coordinates. May not specify coordinates/ranges for
|
|
all the fvar axes.
|
|
|
|
Returns:
|
|
defaultDeltas: to be added to the default instance, of type dict of floats
|
|
keyed by VariationIndex compound values: i.e. (outer << 16) + inner.
|
|
"""
|
|
tupleVarStore = _TupleVarStoreAdapter.fromItemVarStore(itemVarStore, fvarAxes)
|
|
defaultDeltaArray = tupleVarStore.instantiate(axisLimits)
|
|
newItemVarStore = tupleVarStore.asItemVarStore()
|
|
|
|
itemVarStore.VarRegionList = newItemVarStore.VarRegionList
|
|
if not hasattr(itemVarStore, "VarDataCount"): # Happens fromXML
|
|
itemVarStore.VarDataCount = len(newItemVarStore.VarData)
|
|
assert itemVarStore.VarDataCount == newItemVarStore.VarDataCount
|
|
itemVarStore.VarData = newItemVarStore.VarData
|
|
|
|
defaultDeltas = {
|
|
((major << 16) + minor): delta
|
|
for major, deltas in enumerate(defaultDeltaArray)
|
|
for minor, delta in enumerate(deltas)
|
|
}
|
|
defaultDeltas[itemVarStore.NO_VARIATION_INDEX] = 0
|
|
return defaultDeltas
|
|
|
|
|
|
def instantiateOTL(varfont, axisLimits):
|
|
# TODO(anthrotype) Support partial instancing of JSTF and BASE tables
|
|
|
|
if (
|
|
"GDEF" not in varfont
|
|
or varfont["GDEF"].table.Version < 0x00010003
|
|
or not varfont["GDEF"].table.VarStore
|
|
):
|
|
return
|
|
|
|
if "GPOS" in varfont:
|
|
msg = "Instantiating GDEF and GPOS tables"
|
|
else:
|
|
msg = "Instantiating GDEF table"
|
|
log.info(msg)
|
|
|
|
gdef = varfont["GDEF"].table
|
|
varStore = gdef.VarStore
|
|
fvarAxes = varfont["fvar"].axes
|
|
|
|
defaultDeltas = instantiateItemVariationStore(varStore, fvarAxes, axisLimits)
|
|
|
|
# When VF are built, big lookups may overflow and be broken into multiple
|
|
# subtables. MutatorMerger (which inherits from AligningMerger) reattaches
|
|
# them upon instancing, in case they can now fit a single subtable (if not,
|
|
# they will be split again upon compilation).
|
|
# This 'merger' also works as a 'visitor' that traverses the OTL tables and
|
|
# calls specific methods when instances of a given type are found.
|
|
# Specifically, it adds default deltas to GPOS Anchors/ValueRecords and GDEF
|
|
# LigatureCarets, and optionally deletes all VariationIndex tables if the
|
|
# VarStore is fully instanced.
|
|
merger = MutatorMerger(
|
|
varfont, defaultDeltas, deleteVariations=(not varStore.VarRegionList.Region)
|
|
)
|
|
merger.mergeTables(varfont, [varfont], ["GDEF", "GPOS"])
|
|
|
|
if varStore.VarRegionList.Region:
|
|
varIndexMapping = varStore.optimize()
|
|
gdef.remap_device_varidxes(varIndexMapping)
|
|
if "GPOS" in varfont:
|
|
varfont["GPOS"].table.remap_device_varidxes(varIndexMapping)
|
|
else:
|
|
# 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"]
|
|
|
|
|
|
def _isValidAvarSegmentMap(axisTag, segmentMap):
|
|
if not segmentMap:
|
|
return True
|
|
if not {(-1.0, -1.0), (0, 0), (1.0, 1.0)}.issubset(segmentMap.items()):
|
|
log.warning(
|
|
f"Invalid avar SegmentMap record for axis '{axisTag}': does not "
|
|
"include all required value maps {-1.0: -1.0, 0: 0, 1.0: 1.0}"
|
|
)
|
|
return False
|
|
previousValue = None
|
|
for fromCoord, toCoord in sorted(segmentMap.items()):
|
|
if previousValue is not None and previousValue > toCoord:
|
|
log.warning(
|
|
f"Invalid avar AxisValueMap({fromCoord}, {toCoord}) record "
|
|
f"for axis '{axisTag}': the toCoordinate value must be >= to "
|
|
f"the toCoordinate value of the preceding record ({previousValue})."
|
|
)
|
|
return False
|
|
previousValue = toCoord
|
|
return True
|
|
|
|
|
|
def instantiateAvar(varfont, axisLimits):
|
|
# 'axisLimits' dict must contain user-space (non-normalized) coordinates.
|
|
|
|
avar = varfont["avar"]
|
|
if getattr(avar, "majorVersion", 1) >= 2 and avar.table.VarStore:
|
|
raise NotImplementedError("avar table with VarStore is not supported")
|
|
|
|
segments = avar.segments
|
|
|
|
# drop table if we instantiate all the axes
|
|
pinnedAxes = set(axisLimits.pinnedLocation())
|
|
if pinnedAxes.issuperset(segments):
|
|
log.info("Dropping avar table")
|
|
del varfont["avar"]
|
|
return
|
|
|
|
log.info("Instantiating avar table")
|
|
for axis in pinnedAxes:
|
|
if axis in segments:
|
|
del segments[axis]
|
|
|
|
# First compute the default normalization for axisLimits coordinates: i.e.
|
|
# min = -1.0, default = 0, max = +1.0, and in between values interpolated linearly,
|
|
# without using the avar table's mappings.
|
|
# Then, for each SegmentMap, if we are restricting its axis, compute the new
|
|
# mappings by dividing the key/value pairs by the desired new min/max values,
|
|
# dropping any mappings that fall outside the restricted range.
|
|
# The keys ('fromCoord') are specified in default normalized coordinate space,
|
|
# whereas the values ('toCoord') are "mapped forward" using the SegmentMap.
|
|
normalizedRanges = axisLimits.normalize(varfont, usingAvar=False)
|
|
newSegments = {}
|
|
for axisTag, mapping in segments.items():
|
|
if not _isValidAvarSegmentMap(axisTag, mapping):
|
|
continue
|
|
if mapping and axisTag in normalizedRanges:
|
|
axisRange = normalizedRanges[axisTag]
|
|
mappedMin = floatToFixedToFloat(
|
|
piecewiseLinearMap(axisRange.minimum, mapping), 14
|
|
)
|
|
mappedDef = floatToFixedToFloat(
|
|
piecewiseLinearMap(axisRange.default, mapping), 14
|
|
)
|
|
mappedMax = floatToFixedToFloat(
|
|
piecewiseLinearMap(axisRange.maximum, mapping), 14
|
|
)
|
|
mappedAxisLimit = NormalizedAxisTripleAndDistances(
|
|
mappedMin,
|
|
mappedDef,
|
|
mappedMax,
|
|
axisRange.distanceNegative,
|
|
axisRange.distancePositive,
|
|
)
|
|
newMapping = {}
|
|
for fromCoord, toCoord in mapping.items():
|
|
if fromCoord < axisRange.minimum or fromCoord > axisRange.maximum:
|
|
continue
|
|
fromCoord = axisRange.renormalizeValue(fromCoord)
|
|
|
|
assert mappedMin <= toCoord <= mappedMax
|
|
toCoord = mappedAxisLimit.renormalizeValue(toCoord)
|
|
|
|
fromCoord = floatToFixedToFloat(fromCoord, 14)
|
|
toCoord = floatToFixedToFloat(toCoord, 14)
|
|
newMapping[fromCoord] = toCoord
|
|
newMapping.update({-1.0: -1.0, 0.0: 0.0, 1.0: 1.0})
|
|
newSegments[axisTag] = newMapping
|
|
else:
|
|
newSegments[axisTag] = mapping
|
|
avar.segments = newSegments
|
|
|
|
|
|
def isInstanceWithinAxisRanges(location, axisRanges):
|
|
for axisTag, coord in location.items():
|
|
if axisTag in axisRanges:
|
|
axisRange = axisRanges[axisTag]
|
|
if coord < axisRange.minimum or coord > axisRange.maximum:
|
|
return False
|
|
return True
|
|
|
|
|
|
def instantiateFvar(varfont, axisLimits):
|
|
# 'axisLimits' dict must contain user-space (non-normalized) coordinates
|
|
|
|
location = axisLimits.pinnedLocation()
|
|
|
|
fvar = varfont["fvar"]
|
|
|
|
# drop table if we instantiate all the axes
|
|
if set(location).issuperset(axis.axisTag for axis in fvar.axes):
|
|
log.info("Dropping fvar table")
|
|
del varfont["fvar"]
|
|
return
|
|
|
|
log.info("Instantiating fvar table")
|
|
|
|
axes = []
|
|
for axis in fvar.axes:
|
|
axisTag = axis.axisTag
|
|
if axisTag in location:
|
|
continue
|
|
if axisTag in axisLimits:
|
|
triple = axisLimits[axisTag]
|
|
if triple.default is None:
|
|
triple = (triple.minimum, axis.defaultValue, triple.maximum)
|
|
axis.minValue, axis.defaultValue, axis.maxValue = triple
|
|
axes.append(axis)
|
|
fvar.axes = axes
|
|
|
|
# only keep NamedInstances whose coordinates == pinned axis location
|
|
instances = []
|
|
for instance in fvar.instances:
|
|
if any(instance.coordinates[axis] != value for axis, value in location.items()):
|
|
continue
|
|
for axisTag in location:
|
|
del instance.coordinates[axisTag]
|
|
if not isInstanceWithinAxisRanges(instance.coordinates, axisLimits):
|
|
continue
|
|
instances.append(instance)
|
|
fvar.instances = instances
|
|
|
|
|
|
def instantiateSTAT(varfont, axisLimits):
|
|
# 'axisLimits' dict must contain user-space (non-normalized) coordinates
|
|
|
|
stat = varfont["STAT"].table
|
|
if not stat.DesignAxisRecord or not (
|
|
stat.AxisValueArray and stat.AxisValueArray.AxisValue
|
|
):
|
|
return # STAT table empty, nothing to do
|
|
|
|
log.info("Instantiating STAT table")
|
|
newAxisValueTables = axisValuesFromAxisLimits(stat, axisLimits)
|
|
stat.AxisValueCount = len(newAxisValueTables)
|
|
if stat.AxisValueCount:
|
|
stat.AxisValueArray.AxisValue = newAxisValueTables
|
|
else:
|
|
stat.AxisValueArray = None
|
|
|
|
|
|
def axisValuesFromAxisLimits(stat, axisLimits):
|
|
def isAxisValueOutsideLimits(axisTag, axisValue):
|
|
if axisTag in axisLimits:
|
|
triple = axisLimits[axisTag]
|
|
if axisValue < triple.minimum or axisValue > triple.maximum:
|
|
return True
|
|
return False
|
|
|
|
# only keep AxisValues whose axis is not pinned nor restricted, or is pinned at the
|
|
# exact (nominal) value, or is restricted but the value is within the new range
|
|
designAxes = stat.DesignAxisRecord.Axis
|
|
newAxisValueTables = []
|
|
for axisValueTable in stat.AxisValueArray.AxisValue:
|
|
axisValueFormat = axisValueTable.Format
|
|
if axisValueFormat in (1, 2, 3):
|
|
axisTag = designAxes[axisValueTable.AxisIndex].AxisTag
|
|
if axisValueFormat == 2:
|
|
axisValue = axisValueTable.NominalValue
|
|
else:
|
|
axisValue = axisValueTable.Value
|
|
if isAxisValueOutsideLimits(axisTag, axisValue):
|
|
continue
|
|
elif axisValueFormat == 4:
|
|
# drop 'non-analytic' AxisValue if _any_ AxisValueRecord doesn't match
|
|
# the pinned location or is outside range
|
|
dropAxisValueTable = False
|
|
for rec in axisValueTable.AxisValueRecord:
|
|
axisTag = designAxes[rec.AxisIndex].AxisTag
|
|
axisValue = rec.Value
|
|
if isAxisValueOutsideLimits(axisTag, axisValue):
|
|
dropAxisValueTable = True
|
|
break
|
|
if dropAxisValueTable:
|
|
continue
|
|
else:
|
|
log.warning("Unknown AxisValue table format (%s); ignored", axisValueFormat)
|
|
newAxisValueTables.append(axisValueTable)
|
|
return newAxisValueTables
|
|
|
|
|
|
def setMacOverlapFlags(glyfTable):
|
|
flagOverlapCompound = _g_l_y_f.OVERLAP_COMPOUND
|
|
flagOverlapSimple = _g_l_y_f.flagOverlapSimple
|
|
for glyphName in glyfTable.keys():
|
|
glyph = glyfTable[glyphName]
|
|
# Set OVERLAP_COMPOUND bit for compound glyphs
|
|
if glyph.isComposite():
|
|
glyph.components[0].flags |= flagOverlapCompound
|
|
# Set OVERLAP_SIMPLE bit for simple glyphs
|
|
elif glyph.numberOfContours > 0:
|
|
glyph.flags[0] |= flagOverlapSimple
|
|
|
|
|
|
def normalize(value, triple, avarMapping):
|
|
value = normalizeValue(value, triple)
|
|
if avarMapping:
|
|
value = piecewiseLinearMap(value, avarMapping)
|
|
# Quantize to F2Dot14, to avoid surprise interpolations.
|
|
return floatToFixedToFloat(value, 14)
|
|
|
|
|
|
def sanityCheckVariableTables(varfont):
|
|
if "fvar" not in varfont:
|
|
raise ValueError("Missing required table fvar")
|
|
if "gvar" in varfont:
|
|
if "glyf" not in varfont:
|
|
raise ValueError("Can't have gvar without glyf")
|
|
|
|
|
|
def instantiateVariableFont(
|
|
varfont,
|
|
axisLimits,
|
|
inplace=False,
|
|
optimize=True,
|
|
overlap=OverlapMode.KEEP_AND_SET_FLAGS,
|
|
updateFontNames=False,
|
|
*,
|
|
downgradeCFF2=False,
|
|
):
|
|
"""Instantiate variable font, either fully or partially.
|
|
|
|
Depending on whether the `axisLimits` dictionary references all or some of the
|
|
input varfont's axes, the output font will either be a full instance (static
|
|
font) or a variable font with possibly less variation data.
|
|
|
|
Args:
|
|
varfont: a TTFont instance, which must contain at least an 'fvar' table.
|
|
axisLimits: a dict keyed by axis tags (str) containing the coordinates (float)
|
|
along one or more axes where the desired instance will be located.
|
|
If the value is `None`, the default coordinate as per 'fvar' table for
|
|
that axis is used.
|
|
The limit values can also be (min, max) tuples for restricting an
|
|
axis's variation range. The default axis value must be included in
|
|
the new range.
|
|
inplace (bool): whether to modify input TTFont object in-place instead of
|
|
returning a distinct object.
|
|
optimize (bool): if False, do not perform IUP-delta optimization on the
|
|
remaining 'gvar' table's deltas. Possibly faster, and might work around
|
|
rendering issues in some buggy environments, at the cost of a slightly
|
|
larger file size.
|
|
overlap (OverlapMode): variable fonts usually contain overlapping contours, and
|
|
some font rendering engines on Apple platforms require that the
|
|
`OVERLAP_SIMPLE` and `OVERLAP_COMPOUND` flags in the 'glyf' table be set to
|
|
force rendering using a non-zero fill rule. Thus we always set these flags
|
|
on all glyphs to maximise cross-compatibility of the generated instance.
|
|
You can disable this by passing OverlapMode.KEEP_AND_DONT_SET_FLAGS.
|
|
If you want to remove the overlaps altogether and merge overlapping
|
|
contours and components, you can pass OverlapMode.REMOVE (or
|
|
REMOVE_AND_IGNORE_ERRORS to not hard-fail on tricky glyphs). Note that this
|
|
requires the skia-pathops package (available to pip install).
|
|
The overlap parameter only has effect when generating full static instances.
|
|
updateFontNames (bool): if True, update the instantiated font's name table using
|
|
the Axis Value Tables from the STAT table. The name table and the style bits
|
|
in the head and OS/2 table will be updated so they conform to the R/I/B/BI
|
|
model. If the STAT table is missing or an Axis Value table is missing for
|
|
a given axis coordinate, a ValueError will be raised.
|
|
downgradeCFF2 (bool): if True, downgrade the CFF2 table to CFF table when possible
|
|
ie. full instancing of all axes. This is useful for compatibility with older
|
|
software that does not support CFF2. Defaults to False. Note that this
|
|
operation also removes overlaps within glyph shapes, as CFF does not support
|
|
overlaps but CFF2 does.
|
|
"""
|
|
# 'overlap' used to be bool and is now enum; for backward compat keep accepting bool
|
|
overlap = OverlapMode(int(overlap))
|
|
|
|
sanityCheckVariableTables(varfont)
|
|
|
|
axisLimits = AxisLimits(axisLimits).limitAxesAndPopulateDefaults(varfont)
|
|
|
|
log.info("Restricted limits: %s", axisLimits)
|
|
|
|
normalizedLimits = axisLimits.normalize(varfont)
|
|
|
|
log.info("Normalized limits: %s", normalizedLimits)
|
|
|
|
if not inplace:
|
|
varfont = deepcopy(varfont)
|
|
|
|
if "DSIG" in varfont:
|
|
del varfont["DSIG"]
|
|
|
|
if updateFontNames:
|
|
log.info("Updating name table")
|
|
names.updateNameTable(varfont, axisLimits)
|
|
|
|
if "VARC" in varfont:
|
|
instantiateVARC(varfont, normalizedLimits)
|
|
|
|
if "CFF2" in varfont:
|
|
instantiateCFF2(varfont, normalizedLimits, downgrade=downgradeCFF2)
|
|
|
|
if "gvar" in varfont:
|
|
instantiateGvar(varfont, normalizedLimits, optimize=optimize)
|
|
|
|
if "cvar" in varfont:
|
|
instantiateCvar(varfont, normalizedLimits)
|
|
|
|
if "MVAR" in varfont:
|
|
instantiateMVAR(varfont, normalizedLimits)
|
|
|
|
if "HVAR" in varfont:
|
|
instantiateHVAR(varfont, normalizedLimits)
|
|
|
|
if "VVAR" in varfont:
|
|
instantiateVVAR(varfont, normalizedLimits)
|
|
|
|
instantiateOTL(varfont, normalizedLimits)
|
|
|
|
instantiateFeatureVariations(varfont, normalizedLimits)
|
|
|
|
if "avar" in varfont:
|
|
instantiateAvar(varfont, axisLimits)
|
|
|
|
with names.pruningUnusedNames(varfont):
|
|
if "STAT" in varfont:
|
|
instantiateSTAT(varfont, axisLimits)
|
|
|
|
instantiateFvar(varfont, axisLimits)
|
|
|
|
if "fvar" not in varfont:
|
|
if "glyf" in varfont:
|
|
if overlap == OverlapMode.KEEP_AND_SET_FLAGS:
|
|
setMacOverlapFlags(varfont["glyf"])
|
|
elif overlap in (OverlapMode.REMOVE, OverlapMode.REMOVE_AND_IGNORE_ERRORS):
|
|
from fontTools.ttLib.removeOverlaps import removeOverlaps
|
|
|
|
log.info("Removing overlaps from glyf table")
|
|
removeOverlaps(
|
|
varfont,
|
|
ignoreErrors=(overlap == OverlapMode.REMOVE_AND_IGNORE_ERRORS),
|
|
)
|
|
|
|
if "OS/2" in varfont:
|
|
varfont["OS/2"].recalcAvgCharWidth(varfont)
|
|
|
|
varLib.set_default_weight_width_slant(
|
|
varfont, location=axisLimits.defaultLocation()
|
|
)
|
|
|
|
if updateFontNames:
|
|
# Set Regular/Italic/Bold/Bold Italic bits as appropriate, after the
|
|
# name table has been updated.
|
|
setRibbiBits(varfont)
|
|
|
|
return varfont
|
|
|
|
|
|
def setRibbiBits(font):
|
|
"""Set the `head.macStyle` and `OS/2.fsSelection` style bits
|
|
appropriately."""
|
|
|
|
english_ribbi_style = font["name"].getName(names.NameID.SUBFAMILY_NAME, 3, 1, 0x409)
|
|
if english_ribbi_style is None:
|
|
return
|
|
|
|
styleMapStyleName = english_ribbi_style.toStr().lower()
|
|
if styleMapStyleName not in {"regular", "bold", "italic", "bold italic"}:
|
|
return
|
|
|
|
if styleMapStyleName == "bold":
|
|
font["head"].macStyle = 0b01
|
|
elif styleMapStyleName == "bold italic":
|
|
font["head"].macStyle = 0b11
|
|
elif styleMapStyleName == "italic":
|
|
font["head"].macStyle = 0b10
|
|
|
|
selection = font["OS/2"].fsSelection
|
|
# First clear...
|
|
selection &= ~(1 << 0)
|
|
selection &= ~(1 << 5)
|
|
selection &= ~(1 << 6)
|
|
# ...then re-set the bits.
|
|
if styleMapStyleName == "regular":
|
|
selection |= 1 << 6
|
|
elif styleMapStyleName == "bold":
|
|
selection |= 1 << 5
|
|
elif styleMapStyleName == "italic":
|
|
selection |= 1 << 0
|
|
elif styleMapStyleName == "bold italic":
|
|
selection |= 1 << 0
|
|
selection |= 1 << 5
|
|
font["OS/2"].fsSelection = selection
|
|
|
|
|
|
def parseLimits(limits: Iterable[str]) -> Dict[str, Optional[AxisTriple]]:
|
|
result = {}
|
|
for limitString in limits:
|
|
match = re.match(
|
|
r"^(\w{1,4})=(?:(drop)|(?:([^:]*)(?:[:]([^:]*))?(?:[:]([^:]*))?))$",
|
|
limitString,
|
|
)
|
|
if not match:
|
|
raise ValueError("invalid location format: %r" % limitString)
|
|
tag = match.group(1).ljust(4)
|
|
|
|
if match.group(2): # 'drop'
|
|
result[tag] = None
|
|
continue
|
|
|
|
triple = match.group(3, 4, 5)
|
|
|
|
if triple[1] is None: # "value" syntax
|
|
triple = (triple[0], triple[0], triple[0])
|
|
elif triple[2] is None: # "min:max" syntax
|
|
triple = (triple[0], None, triple[1])
|
|
|
|
triple = tuple(float(v) if v else None for v in triple)
|
|
|
|
result[tag] = AxisTriple(*triple)
|
|
|
|
return result
|
|
|
|
|
|
def parseArgs(args):
|
|
"""Parse argv.
|
|
|
|
Returns:
|
|
3-tuple (infile, axisLimits, options)
|
|
axisLimits is either a Dict[str, Optional[float]], for pinning variation axes
|
|
to specific coordinates along those axes (with `None` as a placeholder for an
|
|
axis' default value); or a Dict[str, Tuple(float, float)], meaning limit this
|
|
axis to min/max range.
|
|
Axes locations are in user-space coordinates, as defined in the "fvar" table.
|
|
"""
|
|
from fontTools import configLogger
|
|
import argparse
|
|
|
|
parser = argparse.ArgumentParser(
|
|
"fonttools varLib.instancer",
|
|
description="Partially instantiate a variable font",
|
|
)
|
|
parser.add_argument("input", metavar="INPUT.ttf", help="Input variable TTF file.")
|
|
parser.add_argument(
|
|
"locargs",
|
|
metavar="AXIS=LOC",
|
|
nargs="*",
|
|
help="List of space separated locations. A location consists of "
|
|
"the tag of a variation axis, followed by '=' and the literal, "
|
|
"string 'drop', or colon-separated list of one to three values, "
|
|
"each of which is the empty string, or a number. "
|
|
"E.g.: wdth=100 or wght=75.0:125.0 or wght=100:400:700 or wght=:500: "
|
|
"or wght=drop",
|
|
)
|
|
parser.add_argument(
|
|
"-o",
|
|
"--output",
|
|
metavar="OUTPUT.ttf",
|
|
default=None,
|
|
help="Output instance TTF file (default: INPUT-instance.ttf).",
|
|
)
|
|
parser.add_argument(
|
|
"--no-optimize",
|
|
dest="optimize",
|
|
action="store_false",
|
|
help="Don't perform IUP optimization on the remaining gvar TupleVariations",
|
|
)
|
|
parser.add_argument(
|
|
"--no-overlap-flag",
|
|
dest="overlap",
|
|
action="store_false",
|
|
help="Don't set OVERLAP_SIMPLE/OVERLAP_COMPOUND glyf flags (only applicable "
|
|
"when generating a full instance)",
|
|
)
|
|
parser.add_argument(
|
|
"--remove-overlaps",
|
|
dest="remove_overlaps",
|
|
action="store_true",
|
|
help="Merge overlapping contours and components (only applicable "
|
|
"when generating a full instance). Requires skia-pathops",
|
|
)
|
|
parser.add_argument(
|
|
"--ignore-overlap-errors",
|
|
dest="ignore_overlap_errors",
|
|
action="store_true",
|
|
help="Don't crash if the remove-overlaps operation fails for some glyphs.",
|
|
)
|
|
parser.add_argument(
|
|
"--update-name-table",
|
|
action="store_true",
|
|
help="Update the instantiated font's `name` table. Input font must have "
|
|
"a STAT table with Axis Value Tables",
|
|
)
|
|
parser.add_argument(
|
|
"--downgrade-cff2",
|
|
action="store_true",
|
|
help="If all axes are pinned, downgrade CFF2 to CFF table format",
|
|
)
|
|
parser.add_argument(
|
|
"--no-recalc-timestamp",
|
|
dest="recalc_timestamp",
|
|
action="store_false",
|
|
help="Don't set the output font's timestamp to the current time.",
|
|
)
|
|
parser.add_argument(
|
|
"--no-recalc-bounds",
|
|
dest="recalc_bounds",
|
|
action="store_false",
|
|
help="Don't recalculate font bounding boxes",
|
|
)
|
|
loggingGroup = parser.add_mutually_exclusive_group(required=False)
|
|
loggingGroup.add_argument(
|
|
"-v", "--verbose", action="store_true", help="Run more verbosely."
|
|
)
|
|
loggingGroup.add_argument(
|
|
"-q", "--quiet", action="store_true", help="Turn verbosity off."
|
|
)
|
|
options = parser.parse_args(args)
|
|
|
|
if options.remove_overlaps:
|
|
if options.ignore_overlap_errors:
|
|
options.overlap = OverlapMode.REMOVE_AND_IGNORE_ERRORS
|
|
else:
|
|
options.overlap = OverlapMode.REMOVE
|
|
else:
|
|
options.overlap = OverlapMode(int(options.overlap))
|
|
|
|
infile = options.input
|
|
if not os.path.isfile(infile):
|
|
parser.error("No such file '{}'".format(infile))
|
|
|
|
configLogger(
|
|
level=("DEBUG" if options.verbose else "ERROR" if options.quiet else "INFO")
|
|
)
|
|
|
|
try:
|
|
axisLimits = parseLimits(options.locargs)
|
|
except ValueError as e:
|
|
parser.error(str(e))
|
|
|
|
if len(axisLimits) != len(options.locargs):
|
|
parser.error("Specified multiple limits for the same axis")
|
|
|
|
return (infile, axisLimits, options)
|
|
|
|
|
|
def main(args=None):
|
|
"""Partially instantiate a variable font"""
|
|
infile, axisLimits, options = parseArgs(args)
|
|
log.info("Restricting axes: %s", axisLimits)
|
|
|
|
log.info("Loading variable font")
|
|
varfont = TTFont(
|
|
infile,
|
|
recalcTimestamp=options.recalc_timestamp,
|
|
recalcBBoxes=options.recalc_bounds,
|
|
)
|
|
|
|
isFullInstance = {
|
|
axisTag
|
|
for axisTag, limit in axisLimits.items()
|
|
if limit is None or limit[0] == limit[2]
|
|
}.issuperset(axis.axisTag for axis in varfont["fvar"].axes)
|
|
|
|
instantiateVariableFont(
|
|
varfont,
|
|
axisLimits,
|
|
inplace=True,
|
|
optimize=options.optimize,
|
|
overlap=options.overlap,
|
|
updateFontNames=options.update_name_table,
|
|
downgradeCFF2=options.downgrade_cff2,
|
|
)
|
|
|
|
suffix = "-instance" if isFullInstance else "-partial"
|
|
outfile = (
|
|
makeOutputFileName(infile, overWrite=True, suffix=suffix)
|
|
if not options.output
|
|
else options.output
|
|
)
|
|
|
|
log.info(
|
|
"Saving %s font %s",
|
|
"instance" if isFullInstance else "partial variable",
|
|
outfile,
|
|
)
|
|
varfont.save(outfile)
|