| from fontTools.misc.fixedTools import ( |
| fixedToFloat as fi2fl, |
| floatToFixed as fl2fi, |
| floatToFixedToStr as fl2str, |
| strToFixedToFloat as str2fl, |
| otRound, |
| ) |
| from fontTools.misc.textTools import safeEval |
| import array |
| from collections import Counter, defaultdict |
| import io |
| import logging |
| import struct |
| import sys |
| |
| |
| # https://www.microsoft.com/typography/otspec/otvarcommonformats.htm |
| |
| EMBEDDED_PEAK_TUPLE = 0x8000 |
| INTERMEDIATE_REGION = 0x4000 |
| PRIVATE_POINT_NUMBERS = 0x2000 |
| |
| DELTAS_ARE_ZERO = 0x80 |
| DELTAS_ARE_WORDS = 0x40 |
| DELTA_RUN_COUNT_MASK = 0x3f |
| |
| POINTS_ARE_WORDS = 0x80 |
| POINT_RUN_COUNT_MASK = 0x7f |
| |
| TUPLES_SHARE_POINT_NUMBERS = 0x8000 |
| TUPLE_COUNT_MASK = 0x0fff |
| TUPLE_INDEX_MASK = 0x0fff |
| |
| log = logging.getLogger(__name__) |
| |
| |
| class TupleVariation(object): |
| |
| def __init__(self, axes, coordinates): |
| self.axes = axes.copy() |
| self.coordinates = list(coordinates) |
| |
| def __repr__(self): |
| axes = ",".join(sorted(["%s=%s" % (name, value) for (name, value) in self.axes.items()])) |
| return "<TupleVariation %s %s>" % (axes, self.coordinates) |
| |
| def __eq__(self, other): |
| return self.coordinates == other.coordinates and self.axes == other.axes |
| |
| def getUsedPoints(self): |
| # Empty set means "all points used". |
| if None not in self.coordinates: |
| return frozenset() |
| used = frozenset([i for i,p in enumerate(self.coordinates) if p is not None]) |
| # Return None if no points used. |
| return used if used else None |
| |
| def hasImpact(self): |
| """Returns True if this TupleVariation has any visible impact. |
| |
| If the result is False, the TupleVariation can be omitted from the font |
| without making any visible difference. |
| """ |
| return any(c is not None for c in self.coordinates) |
| |
| def toXML(self, writer, axisTags): |
| writer.begintag("tuple") |
| writer.newline() |
| for axis in axisTags: |
| value = self.axes.get(axis) |
| if value is not None: |
| minValue, value, maxValue = value |
| defaultMinValue = min(value, 0.0) # -0.3 --> -0.3; 0.7 --> 0.0 |
| defaultMaxValue = max(value, 0.0) # -0.3 --> 0.0; 0.7 --> 0.7 |
| if minValue == defaultMinValue and maxValue == defaultMaxValue: |
| writer.simpletag("coord", axis=axis, value=fl2str(value, 14)) |
| else: |
| attrs = [ |
| ("axis", axis), |
| ("min", fl2str(minValue, 14)), |
| ("value", fl2str(value, 14)), |
| ("max", fl2str(maxValue, 14)), |
| ] |
| writer.simpletag("coord", attrs) |
| writer.newline() |
| wrote_any_deltas = False |
| for i, delta in enumerate(self.coordinates): |
| if type(delta) == tuple and len(delta) == 2: |
| writer.simpletag("delta", pt=i, x=delta[0], y=delta[1]) |
| writer.newline() |
| wrote_any_deltas = True |
| elif type(delta) == int: |
| writer.simpletag("delta", cvt=i, value=delta) |
| writer.newline() |
| wrote_any_deltas = True |
| elif delta is not None: |
| log.error("bad delta format") |
| writer.comment("bad delta #%d" % i) |
| writer.newline() |
| wrote_any_deltas = True |
| if not wrote_any_deltas: |
| writer.comment("no deltas") |
| writer.newline() |
| writer.endtag("tuple") |
| writer.newline() |
| |
| def fromXML(self, name, attrs, _content): |
| if name == "coord": |
| axis = attrs["axis"] |
| value = str2fl(attrs["value"], 14) |
| defaultMinValue = min(value, 0.0) # -0.3 --> -0.3; 0.7 --> 0.0 |
| defaultMaxValue = max(value, 0.0) # -0.3 --> 0.0; 0.7 --> 0.7 |
| minValue = str2fl(attrs.get("min", defaultMinValue), 14) |
| maxValue = str2fl(attrs.get("max", defaultMaxValue), 14) |
| self.axes[axis] = (minValue, value, maxValue) |
| elif name == "delta": |
| if "pt" in attrs: |
| point = safeEval(attrs["pt"]) |
| x = safeEval(attrs["x"]) |
| y = safeEval(attrs["y"]) |
| self.coordinates[point] = (x, y) |
| elif "cvt" in attrs: |
| cvt = safeEval(attrs["cvt"]) |
| value = safeEval(attrs["value"]) |
| self.coordinates[cvt] = value |
| else: |
| log.warning("bad delta format: %s" % |
| ", ".join(sorted(attrs.keys()))) |
| |
| def compile(self, axisTags, sharedCoordIndices={}, pointData=None): |
| assert set(self.axes.keys()) <= set(axisTags), ("Unknown axis tag found.", self.axes.keys(), axisTags) |
| |
| tupleData = [] |
| auxData = [] |
| |
| if pointData is None: |
| usedPoints = self.getUsedPoints() |
| if usedPoints is None: # Nothing to encode |
| return b'', b'' |
| pointData = self.compilePoints(usedPoints) |
| |
| coord = self.compileCoord(axisTags) |
| flags = sharedCoordIndices.get(coord) |
| if flags is None: |
| flags = EMBEDDED_PEAK_TUPLE |
| tupleData.append(coord) |
| |
| intermediateCoord = self.compileIntermediateCoord(axisTags) |
| if intermediateCoord is not None: |
| flags |= INTERMEDIATE_REGION |
| tupleData.append(intermediateCoord) |
| |
| # pointData of b'' implies "use shared points". |
| if pointData: |
| flags |= PRIVATE_POINT_NUMBERS |
| auxData.append(pointData) |
| |
| auxData.append(self.compileDeltas()) |
| auxData = b''.join(auxData) |
| |
| tupleData.insert(0, struct.pack('>HH', len(auxData), flags)) |
| return b''.join(tupleData), auxData |
| |
| def compileCoord(self, axisTags): |
| result = bytearray() |
| axes = self.axes |
| for axis in axisTags: |
| triple = axes.get(axis) |
| if triple is None: |
| result.extend(b'\0\0') |
| else: |
| result.extend(struct.pack(">h", fl2fi(triple[1], 14))) |
| return bytes(result) |
| |
| def compileIntermediateCoord(self, axisTags): |
| needed = False |
| for axis in axisTags: |
| minValue, value, maxValue = self.axes.get(axis, (0.0, 0.0, 0.0)) |
| defaultMinValue = min(value, 0.0) # -0.3 --> -0.3; 0.7 --> 0.0 |
| defaultMaxValue = max(value, 0.0) # -0.3 --> 0.0; 0.7 --> 0.7 |
| if (minValue != defaultMinValue) or (maxValue != defaultMaxValue): |
| needed = True |
| break |
| if not needed: |
| return None |
| minCoords = bytearray() |
| maxCoords = bytearray() |
| for axis in axisTags: |
| minValue, value, maxValue = self.axes.get(axis, (0.0, 0.0, 0.0)) |
| minCoords.extend(struct.pack(">h", fl2fi(minValue, 14))) |
| maxCoords.extend(struct.pack(">h", fl2fi(maxValue, 14))) |
| return minCoords + maxCoords |
| |
| @staticmethod |
| def decompileCoord_(axisTags, data, offset): |
| coord = {} |
| pos = offset |
| for axis in axisTags: |
| coord[axis] = fi2fl(struct.unpack(">h", data[pos:pos+2])[0], 14) |
| pos += 2 |
| return coord, pos |
| |
| @staticmethod |
| def compilePoints(points): |
| # If the set consists of all points in the glyph, it gets encoded with |
| # a special encoding: a single zero byte. |
| # |
| # To use this optimization, points passed in must be empty set. |
| # The following two lines are not strictly necessary as the main code |
| # below would emit the same. But this is most common and faster. |
| if not points: |
| return b'\0' |
| |
| # In the 'gvar' table, the packing of point numbers is a little surprising. |
| # It consists of multiple runs, each being a delta-encoded list of integers. |
| # For example, the point set {17, 18, 19, 20, 21, 22, 23} gets encoded as |
| # [6, 17, 1, 1, 1, 1, 1, 1]. The first value (6) is the run length minus 1. |
| # There are two types of runs, with values being either 8 or 16 bit unsigned |
| # integers. |
| points = list(points) |
| points.sort() |
| numPoints = len(points) |
| |
| result = bytearray() |
| # The binary representation starts with the total number of points in the set, |
| # encoded into one or two bytes depending on the value. |
| if numPoints < 0x80: |
| result.append(numPoints) |
| else: |
| result.append((numPoints >> 8) | 0x80) |
| result.append(numPoints & 0xff) |
| |
| MAX_RUN_LENGTH = 127 |
| pos = 0 |
| lastValue = 0 |
| while pos < numPoints: |
| runLength = 0 |
| |
| headerPos = len(result) |
| result.append(0) |
| |
| useByteEncoding = None |
| while pos < numPoints and runLength <= MAX_RUN_LENGTH: |
| curValue = points[pos] |
| delta = curValue - lastValue |
| if useByteEncoding is None: |
| useByteEncoding = 0 <= delta <= 0xff |
| if useByteEncoding and (delta > 0xff or delta < 0): |
| # we need to start a new run (which will not use byte encoding) |
| break |
| # TODO This never switches back to a byte-encoding from a short-encoding. |
| # That's suboptimal. |
| if useByteEncoding: |
| result.append(delta) |
| else: |
| result.append(delta >> 8) |
| result.append(delta & 0xff) |
| lastValue = curValue |
| pos += 1 |
| runLength += 1 |
| if useByteEncoding: |
| result[headerPos] = runLength - 1 |
| else: |
| result[headerPos] = (runLength - 1) | POINTS_ARE_WORDS |
| |
| return result |
| |
| @staticmethod |
| def decompilePoints_(numPoints, data, offset, tableTag): |
| """(numPoints, data, offset, tableTag) --> ([point1, point2, ...], newOffset)""" |
| assert tableTag in ('cvar', 'gvar') |
| pos = offset |
| numPointsInData = data[pos] |
| pos += 1 |
| if (numPointsInData & POINTS_ARE_WORDS) != 0: |
| numPointsInData = (numPointsInData & POINT_RUN_COUNT_MASK) << 8 | data[pos] |
| pos += 1 |
| if numPointsInData == 0: |
| return (range(numPoints), pos) |
| |
| result = [] |
| while len(result) < numPointsInData: |
| runHeader = data[pos] |
| pos += 1 |
| numPointsInRun = (runHeader & POINT_RUN_COUNT_MASK) + 1 |
| point = 0 |
| if (runHeader & POINTS_ARE_WORDS) != 0: |
| points = array.array("H") |
| pointsSize = numPointsInRun * 2 |
| else: |
| points = array.array("B") |
| pointsSize = numPointsInRun |
| points.frombytes(data[pos:pos+pointsSize]) |
| if sys.byteorder != "big": points.byteswap() |
| |
| assert len(points) == numPointsInRun |
| pos += pointsSize |
| |
| result.extend(points) |
| |
| # Convert relative to absolute |
| absolute = [] |
| current = 0 |
| for delta in result: |
| current += delta |
| absolute.append(current) |
| result = absolute |
| del absolute |
| |
| badPoints = {str(p) for p in result if p < 0 or p >= numPoints} |
| if badPoints: |
| log.warning("point %s out of range in '%s' table" % |
| (",".join(sorted(badPoints)), tableTag)) |
| return (result, pos) |
| |
| def compileDeltas(self): |
| deltaX = [] |
| deltaY = [] |
| if self.getCoordWidth() == 2: |
| for c in self.coordinates: |
| if c is None: |
| continue |
| deltaX.append(c[0]) |
| deltaY.append(c[1]) |
| else: |
| for c in self.coordinates: |
| if c is None: |
| continue |
| deltaX.append(c) |
| bytearr = bytearray() |
| self.compileDeltaValues_(deltaX, bytearr) |
| self.compileDeltaValues_(deltaY, bytearr) |
| return bytearr |
| |
| @staticmethod |
| def compileDeltaValues_(deltas, bytearr=None): |
| """[value1, value2, value3, ...] --> bytearray |
| |
| Emits a sequence of runs. Each run starts with a |
| byte-sized header whose 6 least significant bits |
| (header & 0x3F) indicate how many values are encoded |
| in this run. The stored length is the actual length |
| minus one; run lengths are thus in the range [1..64]. |
| If the header byte has its most significant bit (0x80) |
| set, all values in this run are zero, and no data |
| follows. Otherwise, the header byte is followed by |
| ((header & 0x3F) + 1) signed values. If (header & |
| 0x40) is clear, the delta values are stored as signed |
| bytes; if (header & 0x40) is set, the delta values are |
| signed 16-bit integers. |
| """ # Explaining the format because the 'gvar' spec is hard to understand. |
| if bytearr is None: |
| bytearr = bytearray() |
| pos = 0 |
| numDeltas = len(deltas) |
| while pos < numDeltas: |
| value = deltas[pos] |
| if value == 0: |
| pos = TupleVariation.encodeDeltaRunAsZeroes_(deltas, pos, bytearr) |
| elif -128 <= value <= 127: |
| pos = TupleVariation.encodeDeltaRunAsBytes_(deltas, pos, bytearr) |
| else: |
| pos = TupleVariation.encodeDeltaRunAsWords_(deltas, pos, bytearr) |
| return bytearr |
| |
| @staticmethod |
| def encodeDeltaRunAsZeroes_(deltas, offset, bytearr): |
| pos = offset |
| numDeltas = len(deltas) |
| while pos < numDeltas and deltas[pos] == 0: |
| pos += 1 |
| runLength = pos - offset |
| while runLength >= 64: |
| bytearr.append(DELTAS_ARE_ZERO | 63) |
| runLength -= 64 |
| if runLength: |
| bytearr.append(DELTAS_ARE_ZERO | (runLength - 1)) |
| return pos |
| |
| @staticmethod |
| def encodeDeltaRunAsBytes_(deltas, offset, bytearr): |
| pos = offset |
| numDeltas = len(deltas) |
| while pos < numDeltas: |
| value = deltas[pos] |
| if not (-128 <= value <= 127): |
| break |
| # Within a byte-encoded run of deltas, a single zero |
| # is best stored literally as 0x00 value. However, |
| # if are two or more zeroes in a sequence, it is |
| # better to start a new run. For example, the sequence |
| # of deltas [15, 15, 0, 15, 15] becomes 6 bytes |
| # (04 0F 0F 00 0F 0F) when storing the zero value |
| # literally, but 7 bytes (01 0F 0F 80 01 0F 0F) |
| # when starting a new run. |
| if value == 0 and pos+1 < numDeltas and deltas[pos+1] == 0: |
| break |
| pos += 1 |
| runLength = pos - offset |
| while runLength >= 64: |
| bytearr.append(63) |
| bytearr.extend(array.array('b', deltas[offset:offset+64])) |
| offset += 64 |
| runLength -= 64 |
| if runLength: |
| bytearr.append(runLength - 1) |
| bytearr.extend(array.array('b', deltas[offset:pos])) |
| return pos |
| |
| @staticmethod |
| def encodeDeltaRunAsWords_(deltas, offset, bytearr): |
| pos = offset |
| numDeltas = len(deltas) |
| while pos < numDeltas: |
| value = deltas[pos] |
| # Within a word-encoded run of deltas, it is easiest |
| # to start a new run (with a different encoding) |
| # whenever we encounter a zero value. For example, |
| # the sequence [0x6666, 0, 0x7777] needs 7 bytes when |
| # storing the zero literally (42 66 66 00 00 77 77), |
| # and equally 7 bytes when starting a new run |
| # (40 66 66 80 40 77 77). |
| if value == 0: |
| break |
| |
| # Within a word-encoded run of deltas, a single value |
| # in the range (-128..127) should be encoded literally |
| # because it is more compact. For example, the sequence |
| # [0x6666, 2, 0x7777] becomes 7 bytes when storing |
| # the value literally (42 66 66 00 02 77 77), but 8 bytes |
| # when starting a new run (40 66 66 00 02 40 77 77). |
| if (-128 <= value <= 127) and pos+1 < numDeltas and (-128 <= deltas[pos+1] <= 127): |
| break |
| pos += 1 |
| runLength = pos - offset |
| while runLength >= 64: |
| bytearr.append(DELTAS_ARE_WORDS | 63) |
| a = array.array('h', deltas[offset:offset+64]) |
| if sys.byteorder != "big": a.byteswap() |
| bytearr.extend(a) |
| offset += 64 |
| runLength -= 64 |
| if runLength: |
| bytearr.append(DELTAS_ARE_WORDS | (runLength - 1)) |
| a = array.array('h', deltas[offset:pos]) |
| if sys.byteorder != "big": a.byteswap() |
| bytearr.extend(a) |
| return pos |
| |
| @staticmethod |
| def decompileDeltas_(numDeltas, data, offset): |
| """(numDeltas, data, offset) --> ([delta, delta, ...], newOffset)""" |
| result = [] |
| pos = offset |
| while len(result) < numDeltas: |
| runHeader = data[pos] |
| pos += 1 |
| numDeltasInRun = (runHeader & DELTA_RUN_COUNT_MASK) + 1 |
| if (runHeader & DELTAS_ARE_ZERO) != 0: |
| result.extend([0] * numDeltasInRun) |
| else: |
| if (runHeader & DELTAS_ARE_WORDS) != 0: |
| deltas = array.array("h") |
| deltasSize = numDeltasInRun * 2 |
| else: |
| deltas = array.array("b") |
| deltasSize = numDeltasInRun |
| deltas.frombytes(data[pos:pos+deltasSize]) |
| if sys.byteorder != "big": deltas.byteswap() |
| assert len(deltas) == numDeltasInRun |
| pos += deltasSize |
| result.extend(deltas) |
| assert len(result) == numDeltas |
| return (result, pos) |
| |
| @staticmethod |
| def getTupleSize_(flags, axisCount): |
| size = 4 |
| if (flags & EMBEDDED_PEAK_TUPLE) != 0: |
| size += axisCount * 2 |
| if (flags & INTERMEDIATE_REGION) != 0: |
| size += axisCount * 4 |
| return size |
| |
| def getCoordWidth(self): |
| """ Return 2 if coordinates are (x, y) as in gvar, 1 if single values |
| as in cvar, or 0 if empty. |
| """ |
| firstDelta = next((c for c in self.coordinates if c is not None), None) |
| if firstDelta is None: |
| return 0 # empty or has no impact |
| if type(firstDelta) in (int, float): |
| return 1 |
| if type(firstDelta) is tuple and len(firstDelta) == 2: |
| return 2 |
| raise TypeError( |
| "invalid type of delta; expected (int or float) number, or " |
| "Tuple[number, number]: %r" % firstDelta |
| ) |
| |
| def scaleDeltas(self, scalar): |
| if scalar == 1.0: |
| return # no change |
| coordWidth = self.getCoordWidth() |
| self.coordinates = [ |
| None |
| if d is None |
| else d * scalar |
| if coordWidth == 1 |
| else (d[0] * scalar, d[1] * scalar) |
| for d in self.coordinates |
| ] |
| |
| def roundDeltas(self): |
| coordWidth = self.getCoordWidth() |
| self.coordinates = [ |
| None |
| if d is None |
| else otRound(d) |
| if coordWidth == 1 |
| else (otRound(d[0]), otRound(d[1])) |
| for d in self.coordinates |
| ] |
| |
| def calcInferredDeltas(self, origCoords, endPts): |
| from fontTools.varLib.iup import iup_delta |
| |
| if self.getCoordWidth() == 1: |
| raise TypeError( |
| "Only 'gvar' TupleVariation can have inferred deltas" |
| ) |
| if None in self.coordinates: |
| if len(self.coordinates) != len(origCoords): |
| raise ValueError( |
| "Expected len(origCoords) == %d; found %d" |
| % (len(self.coordinates), len(origCoords)) |
| ) |
| self.coordinates = iup_delta(self.coordinates, origCoords, endPts) |
| |
| def optimize(self, origCoords, endPts, tolerance=0.5, isComposite=False): |
| from fontTools.varLib.iup import iup_delta_optimize |
| |
| if None in self.coordinates: |
| return # already optimized |
| |
| deltaOpt = iup_delta_optimize( |
| self.coordinates, origCoords, endPts, tolerance=tolerance |
| ) |
| if None in deltaOpt: |
| if isComposite and all(d is None for d in deltaOpt): |
| # Fix for macOS composites |
| # https://github.com/fonttools/fonttools/issues/1381 |
| deltaOpt = [(0, 0)] + [None] * (len(deltaOpt) - 1) |
| # Use "optimized" version only if smaller... |
| varOpt = TupleVariation(self.axes, deltaOpt) |
| |
| # Shouldn't matter that this is different from fvar...? |
| axisTags = sorted(self.axes.keys()) |
| tupleData, auxData = self.compile(axisTags) |
| unoptimizedLength = len(tupleData) + len(auxData) |
| tupleData, auxData = varOpt.compile(axisTags) |
| optimizedLength = len(tupleData) + len(auxData) |
| |
| if optimizedLength < unoptimizedLength: |
| self.coordinates = varOpt.coordinates |
| |
| def __iadd__(self, other): |
| if not isinstance(other, TupleVariation): |
| return NotImplemented |
| deltas1 = self.coordinates |
| length = len(deltas1) |
| deltas2 = other.coordinates |
| if len(deltas2) != length: |
| raise ValueError( |
| "cannot sum TupleVariation deltas with different lengths" |
| ) |
| # 'None' values have different meanings in gvar vs cvar TupleVariations: |
| # within the gvar, when deltas are not provided explicitly for some points, |
| # they need to be inferred; whereas for the 'cvar' table, if deltas are not |
| # provided for some CVT values, then no adjustments are made (i.e. None == 0). |
| # Thus, we cannot sum deltas for gvar TupleVariations if they contain |
| # inferred inferred deltas (the latter need to be computed first using |
| # 'calcInferredDeltas' method), but we can treat 'None' values in cvar |
| # deltas as if they are zeros. |
| if self.getCoordWidth() == 2: |
| for i, d2 in zip(range(length), deltas2): |
| d1 = deltas1[i] |
| try: |
| deltas1[i] = (d1[0] + d2[0], d1[1] + d2[1]) |
| except TypeError: |
| raise ValueError( |
| "cannot sum gvar deltas with inferred points" |
| ) |
| else: |
| for i, d2 in zip(range(length), deltas2): |
| d1 = deltas1[i] |
| if d1 is not None and d2 is not None: |
| deltas1[i] = d1 + d2 |
| elif d1 is None and d2 is not None: |
| deltas1[i] = d2 |
| # elif d2 is None do nothing |
| return self |
| |
| |
| def decompileSharedTuples(axisTags, sharedTupleCount, data, offset): |
| result = [] |
| for _ in range(sharedTupleCount): |
| t, offset = TupleVariation.decompileCoord_(axisTags, data, offset) |
| result.append(t) |
| return result |
| |
| |
| def compileSharedTuples(axisTags, variations, |
| MAX_NUM_SHARED_COORDS = TUPLE_INDEX_MASK + 1): |
| coordCount = Counter() |
| for var in variations: |
| coord = var.compileCoord(axisTags) |
| coordCount[coord] += 1 |
| # In python < 3.7, most_common() ordering is non-deterministic |
| # so apply a sort to make sure the ordering is consistent. |
| sharedCoords = sorted( |
| coordCount.most_common(MAX_NUM_SHARED_COORDS), |
| key=lambda item: (-item[1], item[0]), |
| ) |
| return [c[0] for c in sharedCoords if c[1] > 1] |
| |
| |
| def compileTupleVariationStore(variations, pointCount, |
| axisTags, sharedTupleIndices, |
| useSharedPoints=True): |
| newVariations = [] |
| pointDatas = [] |
| # Compile all points and figure out sharing if desired |
| sharedPoints = None |
| |
| # Collect, count, and compile point-sets for all variation sets |
| pointSetCount = defaultdict(int) |
| for v in variations: |
| points = v.getUsedPoints() |
| if points is None: # Empty variations |
| continue |
| pointSetCount[points] += 1 |
| newVariations.append(v) |
| pointDatas.append(points) |
| variations = newVariations |
| del newVariations |
| |
| if not variations: |
| return (0, b"", b"") |
| |
| n = len(variations[0].coordinates) |
| assert all(len(v.coordinates) == n for v in variations), "Variation sets have different sizes" |
| |
| compiledPoints = {pointSet:TupleVariation.compilePoints(pointSet) |
| for pointSet in pointSetCount} |
| |
| tupleVariationCount = len(variations) |
| tuples = [] |
| data = [] |
| |
| if useSharedPoints: |
| # Find point-set which saves most bytes. |
| def key(pn): |
| pointSet = pn[0] |
| count = pn[1] |
| return len(compiledPoints[pointSet]) * (count - 1) |
| sharedPoints = max(pointSetCount.items(), key=key)[0] |
| |
| data.append(compiledPoints[sharedPoints]) |
| tupleVariationCount |= TUPLES_SHARE_POINT_NUMBERS |
| |
| # b'' implies "use shared points" |
| pointDatas = [compiledPoints[points] if points != sharedPoints else b'' |
| for points in pointDatas] |
| |
| for v,p in zip(variations, pointDatas): |
| thisTuple, thisData = v.compile(axisTags, sharedTupleIndices, pointData=p) |
| |
| tuples.append(thisTuple) |
| data.append(thisData) |
| |
| tuples = b''.join(tuples) |
| data = b''.join(data) |
| return tupleVariationCount, tuples, data |
| |
| |
| def decompileTupleVariationStore(tableTag, axisTags, |
| tupleVariationCount, pointCount, sharedTuples, |
| data, pos, dataPos): |
| numAxes = len(axisTags) |
| result = [] |
| if (tupleVariationCount & TUPLES_SHARE_POINT_NUMBERS) != 0: |
| sharedPoints, dataPos = TupleVariation.decompilePoints_( |
| pointCount, data, dataPos, tableTag) |
| else: |
| sharedPoints = [] |
| for _ in range(tupleVariationCount & TUPLE_COUNT_MASK): |
| dataSize, flags = struct.unpack(">HH", data[pos:pos+4]) |
| tupleSize = TupleVariation.getTupleSize_(flags, numAxes) |
| tupleData = data[pos : pos + tupleSize] |
| pointDeltaData = data[dataPos : dataPos + dataSize] |
| result.append(decompileTupleVariation_( |
| pointCount, sharedTuples, sharedPoints, |
| tableTag, axisTags, tupleData, pointDeltaData)) |
| pos += tupleSize |
| dataPos += dataSize |
| return result |
| |
| |
| def decompileTupleVariation_(pointCount, sharedTuples, sharedPoints, |
| tableTag, axisTags, data, tupleData): |
| assert tableTag in ("cvar", "gvar"), tableTag |
| flags = struct.unpack(">H", data[2:4])[0] |
| pos = 4 |
| if (flags & EMBEDDED_PEAK_TUPLE) == 0: |
| peak = sharedTuples[flags & TUPLE_INDEX_MASK] |
| else: |
| peak, pos = TupleVariation.decompileCoord_(axisTags, data, pos) |
| if (flags & INTERMEDIATE_REGION) != 0: |
| start, pos = TupleVariation.decompileCoord_(axisTags, data, pos) |
| end, pos = TupleVariation.decompileCoord_(axisTags, data, pos) |
| else: |
| start, end = inferRegion_(peak) |
| axes = {} |
| for axis in axisTags: |
| region = start[axis], peak[axis], end[axis] |
| if region != (0.0, 0.0, 0.0): |
| axes[axis] = region |
| pos = 0 |
| if (flags & PRIVATE_POINT_NUMBERS) != 0: |
| points, pos = TupleVariation.decompilePoints_( |
| pointCount, tupleData, pos, tableTag) |
| else: |
| points = sharedPoints |
| |
| deltas = [None] * pointCount |
| |
| if tableTag == "cvar": |
| deltas_cvt, pos = TupleVariation.decompileDeltas_( |
| len(points), tupleData, pos) |
| for p, delta in zip(points, deltas_cvt): |
| if 0 <= p < pointCount: |
| deltas[p] = delta |
| |
| elif tableTag == "gvar": |
| deltas_x, pos = TupleVariation.decompileDeltas_( |
| len(points), tupleData, pos) |
| deltas_y, pos = TupleVariation.decompileDeltas_( |
| len(points), tupleData, pos) |
| for p, x, y in zip(points, deltas_x, deltas_y): |
| if 0 <= p < pointCount: |
| deltas[p] = (x, y) |
| |
| return TupleVariation(axes, deltas) |
| |
| |
| def inferRegion_(peak): |
| """Infer start and end for a (non-intermediate) region |
| |
| This helper function computes the applicability region for |
| variation tuples whose INTERMEDIATE_REGION flag is not set in the |
| TupleVariationHeader structure. Variation tuples apply only to |
| certain regions of the variation space; outside that region, the |
| tuple has no effect. To make the binary encoding more compact, |
| TupleVariationHeaders can omit the intermediateStartTuple and |
| intermediateEndTuple fields. |
| """ |
| start, end = {}, {} |
| for (axis, value) in peak.items(): |
| start[axis] = min(value, 0.0) # -0.3 --> -0.3; 0.7 --> 0.0 |
| end[axis] = max(value, 0.0) # -0.3 --> 0.0; 0.7 --> 0.7 |
| return (start, end) |