| """Helpers for instancing CFF2 charstrings.""" |
|
|
| from fontTools.cffLib.specializer import blendArgValues, numBlendArgValues |
| from fontTools.misc.roundTools import otRound |
| from fontTools.varLib.models import supportScalar |
|
|
| |
| _PATH_OPERATORS = {"rmoveto", "rlineto", "rrcurveto", "flex"} |
| _STEM_OPERATORS = {"hstem", "hstemhm", "vstem", "vstemhm"} |
|
|
|
|
| def _isStemCommand(commands, i): |
| op, args = commands[i] |
| if op in _STEM_OPERATORS: |
| return True |
| |
| return ( |
| op == "" |
| and i + 1 < len(commands) |
| and commands[i + 1][0] in {"hintmask", "cntrmask"} |
| and not any(isinstance(arg, bytes) for arg in args) |
| ) |
|
|
|
|
| def getRegionScalarRanges(varStore, fvarAxes, pinnedLocation): |
| """Return each region's scalar range after pinning the given axes. |
| |
| These ranges let flex1 generalization determine whether its direction is |
| fixed throughout the remaining design space. |
| """ |
| regionScalarRanges = [] |
| for region in varStore.VarRegionList.Region: |
| support = region.get_support(fvarAxes) |
| pinnedSupport = { |
| axis: triple for axis, triple in support.items() if axis in pinnedLocation |
| } |
| scalar = supportScalar(pinnedLocation, pinnedSupport) |
| |
| if any( |
| lower > peak or peak > upper or lower < 0 < upper |
| for lower, peak, upper in pinnedSupport.values() |
| ): |
| regionScalarRanges.append((0, 1)) |
| elif len(pinnedSupport) == len(support): |
| regionScalarRanges.append((scalar, scalar)) |
| else: |
| regionScalarRanges.append((0, scalar)) |
| return regionScalarRanges |
|
|
|
|
| def convertPrivateDictDeltas(values, numRegions, *, toAbsolute): |
| """Convert a Private DICT delta array's region deltas. |
| |
| Defaults are already absolute; region deltas are relative to the preceding |
| value. Make those absolute before instancing, and relative again afterwards. |
| """ |
| previous = [0] * numRegions |
| result = [] |
| for value in values: |
| if isinstance(value, list): |
| default, *deltas = value |
| else: |
| default, deltas = value, [0] * numRegions |
| assert len(deltas) == numRegions |
| if toAbsolute: |
| deltas = [p + d for p, d in zip(previous, deltas)] |
| result.append([default] + deltas) |
| else: |
| result.append([default] + [d - p for d, p in zip(deltas, previous)]) |
| previous = deltas |
| return result |
|
|
|
|
| def convertToAbsoluteCoordinates(commands, vsIndex, getNumRegions): |
| """Convert generalized CFF2 outline and stem coordinates in place. |
| |
| Return ``None`` on success, or the reason the commands cannot safely be |
| converted. All flex operators must already have been generalized to |
| ``flex``; an ambiguous variable ``flex1`` cannot be made absolute. |
| """ |
| seenBlend = False |
| for op, args in commands: |
| if op == "vsindex": |
| if seenBlend: |
| return "vsindex after a blend" |
| elif op == "flex1": |
| return "flex1 changes direction across the design space" |
| assert op not in {"hflex", "hflex1"} |
| seenBlend = seenBlend or any(isinstance(arg, list) for arg in args) |
|
|
| numValues = getNumRegions(vsIndex) + 1 |
| outline = [[0] * numValues, [0] * numValues] |
| for i, (op, args) in enumerate(commands): |
| if op == "vsindex": |
| |
| vsIndex = args[0] |
| numValues = getNumRegions(vsIndex) + 1 |
| outline = [axis[:1] + [0] * (numValues - 1) for axis in outline] |
| continue |
| if op in _PATH_OPERATORS: |
| positions = outline |
| numCoordinates = 12 if op == "flex" else len(args) |
| elif _isStemCommand(commands, i): |
| positions = [[0] * numValues] |
| numCoordinates = len(args) |
| else: |
| continue |
| for j in range(numCoordinates): |
| k = j % len(positions) |
| values = blendArgValues(args[j], numValues) |
| position = positions[k] = [p + v for p, v in zip(positions[k], values)] |
| args[j] = position + [1] if any(position[1:]) else position[0] |
| return None |
|
|
|
|
| def convertToRelativeCoordinates(commands, round=otRound): |
| """Round absolute CFF2 coordinates and make them relative again in place.""" |
|
|
| def roundArg(arg): |
| if isinstance(arg, list): |
| return [round(arg[0])] + arg[1:] |
| return round(arg) |
|
|
| outline = [[0], [0]] |
| for i, (op, args) in enumerate(commands): |
| if op in _PATH_OPERATORS: |
| positions = outline |
| numCoordinates = 12 if op == "flex" else len(args) |
| elif _isStemCommand(commands, i): |
| positions = [[0]] |
| numCoordinates = len(args) |
| else: |
| continue |
| for j in range(numCoordinates): |
| k = j % len(positions) |
| arg = roundArg(args[j]) |
| numValues = max(len(positions[k]), numBlendArgValues(arg)) |
| values = blendArgValues(arg, numValues) |
| previous = positions[k] + [0] * (numValues - len(positions[k])) |
| diff = [v - p for v, p in zip(values, previous)] |
| positions[k] = values |
| args[j] = diff + [1] if any(diff[1:]) else diff[0] |
| if op == "flex": |
| args[12] = roundArg(args[12]) |
|
|
