from fontTools.misc.roundTools import noRound, otRound
from fontTools.misc.intTools import bit_count
from fontTools.ttLib.tables import otTables as ot
from fontTools.varLib.models import supportScalar
from fontTools.varLib.builder import (
buildVarRegionList,
buildVarStore,
buildVarRegion,
buildVarData,
)
from functools import partial
from collections import defaultdict
from heapq import heappush, heappop
import itertools
NO_VARIATION_INDEX = ot.NO_VARIATION_INDEX
ot.VarStore.NO_VARIATION_INDEX = NO_VARIATION_INDEX
def _getLocationKey(loc):
return tuple(sorted(loc.items(), key=lambda kv: kv[0]))
[docs]
class OnlineVarStoreBuilder(object):
def __init__(self, axisTags):
self._axisTags = axisTags
self._regionMap = {}
self._regionList = buildVarRegionList([], axisTags)
self._store = buildVarStore(self._regionList, [])
self._data = None
self._model = None
self._supports = None
self._varDataIndices = {}
self._varDataCaches = {}
self._cache = None
[docs]
def setModel(self, model):
self.setSupports(model.supports)
self._model = model
[docs]
def setSupports(self, supports):
self._model = None
self._supports = list(supports)
if self._supports and not self._supports[0]:
del self._supports[0] # Drop base master support
self._cache = None
self._data = None
[docs]
def finish(self, optimize=True):
self._regionList.RegionCount = len(self._regionList.Region)
self._store.VarDataCount = len(self._store.VarData)
for data in self._store.VarData:
data.ItemCount = len(data.Item)
data.calculateNumShorts(optimize=optimize)
return self._store
def _add_VarData(self, num_items=1):
regionMap = self._regionMap
regionList = self._regionList
regions = self._supports
regionIndices = []
for region in regions:
key = _getLocationKey(region)
idx = regionMap.get(key)
if idx is None:
varRegion = buildVarRegion(region, self._axisTags)
idx = regionMap[key] = len(regionList.Region)
regionList.Region.append(varRegion)
regionIndices.append(idx)
# Check if we have one already...
key = tuple(regionIndices)
varDataIdx = self._varDataIndices.get(key)
if varDataIdx is not None:
self._outer = varDataIdx
self._data = self._store.VarData[varDataIdx]
self._cache = self._varDataCaches[key]
if len(self._data.Item) + num_items > 0xFFFF:
# This is full. Need new one.
varDataIdx = None
if varDataIdx is None:
self._data = buildVarData(regionIndices, [], optimize=False)
self._outer = len(self._store.VarData)
self._store.VarData.append(self._data)
self._varDataIndices[key] = self._outer
if key not in self._varDataCaches:
self._varDataCaches[key] = {}
self._cache = self._varDataCaches[key]
[docs]
def storeMasters(self, master_values, *, round=round):
deltas = self._model.getDeltas(master_values, round=round)
base = deltas.pop(0)
return base, self.storeDeltas(deltas, round=noRound)
[docs]
def storeMastersMany(self, master_values_list, *, round=round):
deltas_list = [
self._model.getDeltas(master_values, round=round)
for master_values in master_values_list
]
base_list = [deltas.pop(0) for deltas in deltas_list]
return base_list, self.storeDeltasMany(deltas_list, round=noRound)
[docs]
def storeDeltas(self, deltas, *, round=round):
deltas = [round(d) for d in deltas]
if len(deltas) == len(self._supports) + 1:
deltas = tuple(deltas[1:])
else:
assert len(deltas) == len(self._supports)
deltas = tuple(deltas)
if not self._data:
self._add_VarData()
varIdx = self._cache.get(deltas)
if varIdx is not None:
return varIdx
inner = len(self._data.Item)
if inner == 0xFFFF:
# Full array. Start new one.
self._add_VarData()
return self.storeDeltas(deltas, round=noRound)
self._data.addItem(deltas, round=noRound)
varIdx = (self._outer << 16) + inner
self._cache[deltas] = varIdx
return varIdx
[docs]
def storeDeltasMany(self, deltas_list, *, round=round):
deltas_list = [[round(d) for d in deltas] for deltas in deltas_list]
deltas_list = tuple(tuple(deltas) for deltas in deltas_list)
if not self._data:
self._add_VarData(len(deltas_list))
varIdx = self._cache.get(deltas_list)
if varIdx is not None:
return varIdx
inner = len(self._data.Item)
if inner + len(deltas_list) > 0xFFFF:
# Full array. Start new one.
self._add_VarData(len(deltas_list))
return self.storeDeltasMany(deltas_list, round=noRound)
for i, deltas in enumerate(deltas_list):
self._data.addItem(deltas, round=noRound)
varIdx = (self._outer << 16) + inner + i
self._cache[deltas] = varIdx
varIdx = (self._outer << 16) + inner
self._cache[deltas_list] = varIdx
return varIdx
[docs]
def VarData_addItem(self, deltas, *, round=round):
deltas = [round(d) for d in deltas]
countUs = self.VarRegionCount
countThem = len(deltas)
if countUs + 1 == countThem:
deltas = list(deltas[1:])
else:
assert countUs == countThem, (countUs, countThem)
deltas = list(deltas)
self.Item.append(deltas)
self.ItemCount = len(self.Item)
ot.VarData.addItem = VarData_addItem
[docs]
def VarRegion_get_support(self, fvar_axes):
return {
fvar_axes[i].axisTag: (reg.StartCoord, reg.PeakCoord, reg.EndCoord)
for i, reg in enumerate(self.VarRegionAxis)
if reg.PeakCoord != 0
}
ot.VarRegion.get_support = VarRegion_get_support
[docs]
def VarStore___bool__(self):
return bool(self.VarData)
ot.VarStore.__bool__ = VarStore___bool__
[docs]
class VarStoreInstancer(object):
"""Evaluate a VarStore's deltas at a (mutable via setLocation) location.
Region supports are cached for the lifetime of the instancer: after
mutating the store's regions (or the fvar axes), construct a new
instancer rather than reusing this one via setLocation.
"""
def __init__(self, varstore, fvar_axes, location={}):
self.fvar_axes = fvar_axes
assert varstore is None or varstore.Format == 1
self._varData = varstore.VarData if varstore else []
self._regions = varstore.VarRegionList.Region if varstore else []
# Region supports are location-independent, so cache them for the
# lifetime of the instancer (they survive setLocation); only the
# per-region scalars, which depend on the location, are recomputed.
# This makes reusing one instancer across many locations cheap.
self._supports = {}
self.setLocation(location)
[docs]
def setLocation(self, location):
self.location = dict(location)
self._clearCaches()
def _clearCaches(self):
self._scalars = {}
def _getSupport(self, regionIdx):
support = self._supports.get(regionIdx)
if support is None:
support = self._regions[regionIdx].get_support(self.fvar_axes)
self._supports[regionIdx] = support
return support
def _getScalar(self, regionIdx):
scalar = self._scalars.get(regionIdx)
if scalar is None:
scalar = supportScalar(self.location, self._getSupport(regionIdx))
self._scalars[regionIdx] = scalar
return scalar
[docs]
@staticmethod
def interpolateFromDeltasAndScalars(deltas, scalars):
delta = 0.0
for d, s in zip(deltas, scalars):
if not s:
continue
delta += d * s
return delta
def __getitem__(self, varidx):
major, minor = varidx >> 16, varidx & 0xFFFF
if varidx == NO_VARIATION_INDEX:
return 0.0
varData = self._varData
# Keep full instancing consistent with _effectiveAvar2VarIdx: out-of-range
# delta-set indices contribute zero. HarfBuzz uses the same policy:
# https://github.com/harfbuzz/harfbuzz/blob/d2df3cdcc0836299a163dc0399a6b047d19ac56c/src/hb-ot-layout-common.hh#L2912-L2918
# https://github.com/harfbuzz/harfbuzz/blob/d2df3cdcc0836299a163dc0399a6b047d19ac56c/src/hb-ot-layout-common.hh#L3354-L3363
if major >= len(varData) or minor >= len(varData[major].Item):
return 0.0
scalars = [self._getScalar(ri) for ri in varData[major].VarRegionIndex]
deltas = varData[major].Item[minor]
return self.interpolateFromDeltasAndScalars(deltas, scalars)
[docs]
def interpolateFromDeltas(self, varDataIndex, deltas):
varData = self._varData
scalars = [self._getScalar(ri) for ri in varData[varDataIndex].VarRegionIndex]
return self.interpolateFromDeltasAndScalars(deltas, scalars)
#
# Optimizations
#
# retainFirstMap - If true, major 0 mappings are retained. Deltas for unused indices are zeroed
# advIdxes - Set of major 0 indices for advance deltas to be listed first. Other major 0 indices follow.
[docs]
def VarStore_subset_varidxes(
self,
varIdxes,
optimize=True,
retainFirstMap=False,
advIdxes=set(),
*,
VarData="VarData",
):
# Sort out used varIdxes by major/minor.
used = defaultdict(set)
for varIdx in varIdxes:
if varIdx == NO_VARIATION_INDEX:
continue
major = varIdx >> 16
minor = varIdx & 0xFFFF
used[major].add(minor)
del varIdxes
#
# Subset VarData
#
varData = getattr(self, VarData)
newVarData = []
varDataMap = {NO_VARIATION_INDEX: NO_VARIATION_INDEX}
for major, data in enumerate(varData):
usedMinors = used.get(major)
if usedMinors is None:
continue
newMajor = len(newVarData)
newVarData.append(data)
items = data.Item
newItems = []
if major == 0 and retainFirstMap:
for minor in range(len(items)):
newItems.append(
items[minor] if minor in usedMinors else [0] * len(items[minor])
)
varDataMap[minor] = minor
else:
if major == 0:
minors = sorted(advIdxes) + sorted(usedMinors - advIdxes)
else:
minors = sorted(usedMinors)
for minor in minors:
newMinor = len(newItems)
newItems.append(items[minor])
varDataMap[(major << 16) + minor] = (newMajor << 16) + newMinor
data.Item = newItems
data.ItemCount = len(data.Item)
if VarData == "VarData":
data.calculateNumShorts(optimize=optimize)
setattr(self, VarData, newVarData)
setattr(self, VarData + "Count", len(newVarData))
self.prune_regions()
return varDataMap
ot.VarStore.subset_varidxes = VarStore_subset_varidxes
[docs]
def VarStore_prune_regions(self, *, VarData="VarData", VarRegionList="VarRegionList"):
"""Remove unused VarRegions."""
#
# Subset VarRegionList
#
# Collect.
usedRegions = set()
for data in getattr(self, VarData):
usedRegions.update(data.VarRegionIndex)
# Subset.
regionList = getattr(self, VarRegionList)
regions = regionList.Region
newRegions = []
regionMap = {}
for i in sorted(usedRegions):
regionMap[i] = len(newRegions)
newRegions.append(regions[i])
regionList.Region = newRegions
regionList.RegionCount = len(regionList.Region)
# Map.
for data in getattr(self, VarData):
data.VarRegionIndex = [regionMap[i] for i in data.VarRegionIndex]
ot.VarStore.prune_regions = VarStore_prune_regions
def _visit(self, func):
"""Recurse down from self, if type of an object is ot.Device,
call func() on it. Works on otData-style classes."""
if type(self) == ot.Device:
func(self)
elif isinstance(self, list):
for that in self:
_visit(that, func)
elif hasattr(self, "getConverters") and not hasattr(self, "postRead"):
for conv in self.getConverters():
that = getattr(self, conv.name, None)
if that is not None:
_visit(that, func)
elif isinstance(self, ot.ValueRecord):
for that in self.__dict__.values():
_visit(that, func)
def _Device_recordVarIdx(self, s):
"""Add VarIdx in this Device table (if any) to the set s."""
if self.DeltaFormat == 0x8000:
s.add((self.StartSize << 16) + self.EndSize)
[docs]
def Object_collect_device_varidxes(self, varidxes):
adder = partial(_Device_recordVarIdx, s=varidxes)
_visit(self, adder)
ot.GDEF.collect_device_varidxes = Object_collect_device_varidxes
ot.GPOS.collect_device_varidxes = Object_collect_device_varidxes
def _Device_mapVarIdx(self, mapping, done):
"""Map VarIdx in this Device table (if any) through mapping."""
if id(self) in done:
return
done.add(id(self))
if self.DeltaFormat == 0x8000:
varIdx = mapping[(self.StartSize << 16) + self.EndSize]
self.StartSize = varIdx >> 16
self.EndSize = varIdx & 0xFFFF
[docs]
def Object_remap_device_varidxes(self, varidxes_map):
mapper = partial(_Device_mapVarIdx, mapping=varidxes_map, done=set())
_visit(self, mapper)
ot.GDEF.remap_device_varidxes = Object_remap_device_varidxes
ot.GPOS.remap_device_varidxes = Object_remap_device_varidxes
ot.BASE.remap_device_varidxes = Object_remap_device_varidxes
class _Encoding(object):
def __init__(self, chars):
self.chars = chars
self.width = bit_count(chars)
self.columns = self._columns(chars)
self.overhead = self._characteristic_overhead(self.columns)
self.items = set()
def append(self, row):
self.items.add(row)
def extend(self, lst):
self.items.update(lst)
def width_sort_key(self):
return self.width, self.chars
@staticmethod
def _characteristic_overhead(columns):
"""Returns overhead in bytes of encoding this characteristic
as a VarData."""
c = 4 + 6 # 4 bytes for LOffset, 6 bytes for VarData header
c += bit_count(columns) * 2
return c
@staticmethod
def _columns(chars):
cols = 0
i = 1
while chars:
if chars & 0b1111:
cols |= i
chars >>= 4
i <<= 1
return cols
def gain_from_merging(self, other_encoding):
combined_chars = other_encoding.chars | self.chars
combined_width = bit_count(combined_chars)
combined_columns = self.columns | other_encoding.columns
combined_overhead = _Encoding._characteristic_overhead(combined_columns)
combined_gain = (
+self.overhead
+ other_encoding.overhead
- combined_overhead
- (combined_width - self.width) * len(self.items)
- (combined_width - other_encoding.width) * len(other_encoding.items)
)
return combined_gain
class _EncodingDict(dict):
def __missing__(self, chars):
r = self[chars] = _Encoding(chars)
return r
def add_row(self, row):
chars = self._row_characteristics(row)
self[chars].append(row)
@staticmethod
def _row_characteristics(row):
"""Returns encoding characteristics for a row."""
longWords = False
chars = 0
i = 1
for v in row:
if v:
chars += i
if not (-128 <= v <= 127):
chars += i * 0b0010
if not (-32768 <= v <= 32767):
longWords = True
break
i <<= 4
if longWords:
# Redo; only allow 2byte/4byte encoding
chars = 0
i = 1
for v in row:
if v:
chars += i * 0b0011
if not (-32768 <= v <= 32767):
chars += i * 0b1100
i <<= 4
return chars
[docs]
def VarStore_optimize(self, use_NO_VARIATION_INDEX=True, quantization=1):
"""Optimize storage. Returns mapping from old VarIdxes to new ones."""
# Overview:
#
# For each VarData row, we first extend it with zeroes to have
# one column per region in VarRegionList. We then group the
# rows into _Encoding objects, by their "characteristic" bitmap.
# The characteristic bitmap is a binary number representing how
# many bytes each column of the data takes up to encode. Each
# column is encoded in four bits. For example, if a column has
# only values in the range -128..127, it would only have a single
# bit set in the characteristic bitmap for that column. If it has
# values in the range -32768..32767, it would have two bits set.
# The number of ones in the characteristic bitmap is the "width"
# of the encoding.
#
# Each encoding as such has a number of "active" (ie. non-zero)
# columns. The overhead of encoding the characteristic bitmap
# is 10 bytes, plus 2 bytes per active column.
#
# When an encoding is merged into another one, if the characteristic
# of the old encoding is a subset of the new one, then the overhead
# of the old encoding is completely eliminated. However, each row
# now would require more bytes to encode, to the tune of one byte
# per characteristic bit that is active in the new encoding but not
# in the old one.
#
# The "gain" of merging two encodings is how many bytes we save by doing so.
#
# High-level algorithm:
#
# - Each encoding has a minimal way to encode it. However, because
# of the overhead of encoding the characteristic bitmap, it may
# be beneficial to merge two encodings together, if there is
# gain in doing so. As such, we need to search for the best
# such successive merges.
#
# Algorithm:
#
# - Put all encodings into a "todo" list.
#
# - Sort todo list (for stability) by width_sort_key(), which is a tuple
# of the following items:
# * The "width" of the encoding.
# * The characteristic bitmap of the encoding, with higher-numbered
# columns compared first.
#
# - Make a priority-queue of the gain from combining each two
# encodings in the todo list. The priority queue is sorted by
# decreasing gain. Only positive gains are included.
#
# - While priority queue is not empty:
# - Pop the first item from the priority queue,
# - Merge the two encodings it represents,
# - Remove the two encodings from the todo list,
# - Insert positive gains from combining the new encoding with
# all existing todo list items into the priority queue,
# - If a todo list item with the same characteristic bitmap as
# the new encoding exists, remove it from the todo list and
# merge it into the new encoding.
# - Insert the new encoding into the todo list,
#
# - Encode all remaining items in the todo list.
#
# The output is then sorted for stability, in the following way:
# - The VarRegionList of the input is kept intact.
# - The VarData is sorted by the same width_sort_key() used at the beginning.
# - Within each VarData, the items are sorted as vectors of numbers.
#
# Finally, each VarData is optimized to remove the empty columns and
# reorder columns as needed.
# TODO
# Check that no two VarRegions are the same; if they are, fold them.
n = len(self.VarRegionList.Region) # Number of columns
zeroes = [0] * n
front_mapping = {} # Map from old VarIdxes to full row tuples
encodings = _EncodingDict()
# Collect all items into a set of full rows (with lots of zeroes.)
for major, data in enumerate(self.VarData):
regionIndices = data.VarRegionIndex
for minor, item in enumerate(data.Item):
row = list(zeroes)
if quantization == 1:
for regionIdx, v in zip(regionIndices, item):
row[regionIdx] += v
else:
for regionIdx, v in zip(regionIndices, item):
row[regionIdx] += (
round(v / quantization) * quantization
) # TODO https://github.com/fonttools/fonttools/pull/3126#discussion_r1205439785
row = tuple(row)
if use_NO_VARIATION_INDEX and not any(row):
front_mapping[(major << 16) + minor] = None
continue
encodings.add_row(row)
front_mapping[(major << 16) + minor] = row
# Prepare for the main algorithm.
todo = sorted(encodings.values(), key=_Encoding.width_sort_key)
del encodings
# Repeatedly pick two best encodings to combine, and combine them.
heap = []
for i, encoding in enumerate(todo):
for j in range(i + 1, len(todo)):
other_encoding = todo[j]
combining_gain = encoding.gain_from_merging(other_encoding)
if combining_gain > 0:
heappush(heap, (-combining_gain, i, j))
while heap:
_, i, j = heappop(heap)
if todo[i] is None or todo[j] is None:
continue
encoding, other_encoding = todo[i], todo[j]
todo[i], todo[j] = None, None
# Combine the two encodings
combined_chars = other_encoding.chars | encoding.chars
combined_encoding = _Encoding(combined_chars)
combined_encoding.extend(encoding.items)
combined_encoding.extend(other_encoding.items)
for k, enc in enumerate(todo):
if enc is None:
continue
# In the unlikely event that the same encoding exists already,
# combine it.
if enc.chars == combined_chars:
combined_encoding.extend(enc.items)
todo[k] = None
continue
combining_gain = combined_encoding.gain_from_merging(enc)
if combining_gain > 0:
heappush(heap, (-combining_gain, k, len(todo)))
todo.append(combined_encoding)
encodings = [encoding for encoding in todo if encoding is not None]
# Assemble final store.
back_mapping = {} # Mapping from full rows to new VarIdxes
encodings.sort(key=_Encoding.width_sort_key)
self.VarData = []
for encoding in encodings:
items = sorted(encoding.items)
while items:
major = len(self.VarData)
data = ot.VarData()
self.VarData.append(data)
data.VarRegionIndex = range(n)
data.VarRegionCount = len(data.VarRegionIndex)
# Each major can only encode up to 0xFFFF entries.
data.Item, items = items[:0xFFFF], items[0xFFFF:]
for minor, item in enumerate(data.Item):
back_mapping[item] = (major << 16) + minor
# Compile final mapping.
varidx_map = {NO_VARIATION_INDEX: NO_VARIATION_INDEX}
for k, v in front_mapping.items():
varidx_map[k] = back_mapping[v] if v is not None else NO_VARIATION_INDEX
# Recalculate things and go home.
self.VarRegionList.RegionCount = len(self.VarRegionList.Region)
self.VarDataCount = len(self.VarData)
for data in self.VarData:
data.ItemCount = len(data.Item)
data.optimize()
# Remove unused regions.
self.prune_regions()
return varidx_map
ot.VarStore.optimize = VarStore_optimize
def _tentValue(v, start, peak, end):
"""Per-axis support-scalar factor at coordinate v (supportScalar semantics)."""
if v == peak:
return 1.0
if v <= start or end <= v:
return 0.0
if v < peak:
return (v - start) / (peak - start)
return (end - v) / (end - peak)
# Maximum number of grid vertices VarStore_getExtremes enumerates for the
# exact answer before falling back to the (looser but conservative and cheap)
# interval bound. The grid is authoring-controlled, so a cap is needed to keep
# crafted fonts from hanging the instancer.
_GET_EXTREMES_MAX_GRID = 1 << 14
_F2DOT14_UNIT = 1.0 / (1 << 14)
[docs]
def VarStore_getExtremes(self, varIdx, fvarAxes, axisLimits, identityAxisIndex=None):
"""Conservatively bound the value this VarStore produces for varIdx.
Returns (minV, maxV) in F2Dot14 delta units, guaranteed to cover the
truly reachable range as the input axes vary over their extents:
[-1, +1] per axis, or the [min, max] interval from axisLimits (a dict of
axis tag to a (min, default, max, ...) sequence) for axes listed there.
If identityAxisIndex is not None, that axis's own identity contribution
(its coordinate, in F2Dot14 units) is added to the bound.
Before the final OpenType rounding, the produced value is piecewise
multilinear in the axis coordinates (each region's scalar is a product
of independent per-axis tents), so over the box its exact extremes are
attained at vertices of the grid formed by each axis's tent
breakpoints. One-sided tents (start == peak or peak == end) are
discontinuous at their peak, so the grid also includes the adjacent
F2Dot14 coordinate on the open side. When that grid is small enough
(real fonts) it is enumerated and the result is exact; otherwise the
result falls back to a per-region interval bound, which ignores
correlations between regions and may be wider than the true range —
never narrower. Callers use this to cull provably-unreachable
variation data, so conservativeness is a soundness requirement, not a
nicety. The fallback costs O(regions × axes); the cap on the exact
path keeps crafted fonts from hanging the instancer.
Raw extrema are rounded only after summing the identity and delta terms,
matching avar2 processing.
"""
def axisInterval(axisIdx):
tag = fvarAxes[axisIdx].axisTag
if tag in axisLimits:
limits = axisLimits[tag]
return limits[0], limits[2]
return -1.0, +1.0
if varIdx == NO_VARIATION_INDEX:
activeRegions = []
else:
major = varIdx >> 16
minor = varIdx & 0xFFFF
varData = self.VarData[major]
regions = self.VarRegionList.Region
deltas = varData.Item[minor]
# Per region: (delta, [(axisIndex, start, peak, end), ...]) with the
# axes supportScalar would ignore already dropped.
activeRegions = []
for regionIndex, delta in zip(varData.VarRegionIndex, deltas):
if not delta:
continue
region = regions[regionIndex]
tents = []
for i, regionAxis in enumerate(region.VarRegionAxis):
start = regionAxis.StartCoord
peak = regionAxis.PeakCoord
end = regionAxis.EndCoord
# Mirror supportScalar's OT rules for axes it ignores.
if peak == 0 or start > peak or peak > end:
continue
if start < 0 and end > 0:
continue
tents.append((i, start, peak, end))
activeRegions.append((delta, tents))
# Try the exact path: enumerate the breakpoint grid.
breakpoints = {} # axisIndex -> set of coordinates
if identityAxisIndex is not None:
lo, hi = axisInterval(identityAxisIndex)
breakpoints[identityAxisIndex] = {lo, hi}
for delta, tents in activeRegions:
for i, start, peak, end in tents:
if i not in breakpoints:
lo, hi = axisInterval(i)
breakpoints[i] = {lo, hi}
lo, hi = axisInterval(i)
breakpoints[i].update(min(max(v, lo), hi) for v in (start, peak, end))
if start == peak:
breakpoints[i].add(min(max(peak - _F2DOT14_UNIT, lo), hi))
if peak == end:
breakpoints[i].add(min(max(peak + _F2DOT14_UNIT, lo), hi))
gridSize = 1
for points in breakpoints.values():
gridSize *= len(points)
if gridSize > _GET_EXTREMES_MAX_GRID:
break
if gridSize <= _GET_EXTREMES_MAX_GRID:
# Exact: evaluate at every grid vertex. Within each grid cell every
# region scalar is multilinear, so the extremes lie on vertices.
axisIndices = sorted(breakpoints)
axisPos = {i: n for n, i in enumerate(axisIndices)}
minV = maxV = None
for vertex in itertools.product(*(sorted(breakpoints[i]) for i in axisIndices)):
v = 0.0
for delta, tents in activeRegions:
scalar = 1.0
for i, start, peak, end in tents:
scalar *= _tentValue(vertex[axisPos[i]], start, peak, end)
if scalar == 0:
break
if scalar:
v += delta * scalar
if identityAxisIndex is not None:
v += otRound(vertex[axisPos[identityAxisIndex]] * 16384)
if minV is None:
minV = maxV = v
else:
minV = min(minV, v)
maxV = max(maxV, v)
return otRound(minV), otRound(maxV)
# Fallback: per-region interval arithmetic. Each region's scalar range
# over the box is exact (per-axis tent factors are independent), but
# correlations between regions (and with the identity term) are ignored.
minV = maxV = 0.0
for delta, tents in activeRegions:
scalarMin = scalarMax = 1.0
for i, start, peak, end in tents:
lo, hi = axisInterval(i)
# The tent rises to the peak then falls, so over [lo, hi] the
# maximum is at the clamped peak, the minimum at an endpoint.
scalarMax *= _tentValue(min(max(peak, lo), hi), start, peak, end)
scalarMin *= min(
_tentValue(lo, start, peak, end),
_tentValue(hi, start, peak, end),
)
if scalarMax == 0:
break
if scalarMax == 0:
continue
minV += min(delta * scalarMin, delta * scalarMax)
maxV += max(delta * scalarMin, delta * scalarMax)
if identityAxisIndex is not None:
lo, hi = axisInterval(identityAxisIndex)
minV += otRound(lo * 16384)
maxV += otRound(hi * 16384)
return otRound(minV), otRound(maxV)
ot.VarStore.getExtremes = VarStore_getExtremes
[docs]
def main(args=None):
"""Optimize a font's GDEF variation store"""
from argparse import ArgumentParser
from fontTools import configLogger
from fontTools.ttLib import TTFont
from fontTools.ttLib.tables.otBase import OTTableWriter
parser = ArgumentParser(prog="varLib.varStore", description=main.__doc__)
parser.add_argument("--quantization", type=int, default=1)
parser.add_argument("fontfile")
parser.add_argument("outfile", nargs="?")
options = parser.parse_args(args)
# TODO: allow user to configure logging via command-line options
configLogger(level="INFO")
quantization = options.quantization
fontfile = options.fontfile
outfile = options.outfile
font = TTFont(fontfile)
gdef = font["GDEF"]
store = gdef.table.VarStore
writer = OTTableWriter()
store.compile(writer, font)
size = len(writer.getAllData())
print("Before: %7d bytes" % size)
varidx_map = store.optimize(quantization=quantization)
writer = OTTableWriter()
store.compile(writer, font)
size = len(writer.getAllData())
print("After: %7d bytes" % size)
if outfile is not None:
gdef.table.remap_device_varidxes(varidx_map)
if "GPOS" in font:
font["GPOS"].table.remap_device_varidxes(varidx_map)
font.save(outfile)
if __name__ == "__main__":
import sys
if len(sys.argv) > 1:
sys.exit(main())
import doctest
sys.exit(doctest.testmod().failed)