from fontTools.varLib.models import supportScalar from fontTools.misc.fixedTools import MAX_F2DOT14 from functools import lru_cache __all__ = ["rebaseTent"] EPSILON = 1 / (1 << 14) def _reverse_negate(v): return (-v[2], -v[1], -v[0]) def _solve(tent, axisLimit, negative=False): axisMin, axisDef, axisMax, _distanceNegative, _distancePositive = axisLimit lower, peak, upper = tent # Mirror the problem such that axisDef <= peak if axisDef > peak: return [ (scalar, _reverse_negate(t) if t is not None else None) for scalar, t in _solve( _reverse_negate(tent), axisLimit.reverse_negate(), not negative, ) ] # axisDef <= peak # case 1: The whole deltaset falls outside the new limit; we can drop it # # peak # 1.........................................o.......... # / \ # / \ # / \ # / \ # 0---|-----------|----------|-------- o o----1 # axisMin axisDef axisMax lower upper # if axisMax <= lower and axisMax < peak: return [] # No overlap # case 2: Only the peak and outermost bound fall outside the new limit; # we keep the deltaset, update peak and outermost bound and and scale deltas # by the scalar value for the restricted axis at the new limit, and solve # recursively. # # |peak # 1...............................|.o.......... # |/ \ # / \ # /| \ # / | \ # 0--------------------------- o | o----1 # lower | upper # | # axisMax # # Convert to: # # 1............................................ # | # o peak # /| # /x| # 0--------------------------- o o upper ----1 # lower | # | # axisMax if axisMax < peak: mult = supportScalar({"tag": axisMax}, {"tag": tent}) tent = (lower, axisMax, axisMax) return [(scalar * mult, t) for scalar, t in _solve(tent, axisLimit)] # lower <= axisDef <= peak <= axisMax gain = supportScalar({"tag": axisDef}, {"tag": tent}) out = [(gain, None)] # First, the positive side # outGain is the scalar of axisMax at the tent. outGain = supportScalar({"tag": axisMax}, {"tag": tent}) # Case 3a: Gain is more than outGain. The tent down-slope crosses # the axis into negative. We have to split it into multiples. # # | peak | # 1...................|.o.....|.............. # |/x\_ | # gain................+....+_.|.............. # /| |y\| # ................../.|....|..+_......outGain # / | | | \ # 0---|-----------o | | | o----------1 # axisMin lower | | | upper # | | | # axisDef | axisMax # | # crossing if gain >= outGain: # Note that this is the branch taken if both gain and outGain are 0. # Crossing point on the axis. crossing = peak + (1 - gain) * (upper - peak) loc = (max(lower, axisDef), peak, crossing) scalar = 1 # The part before the crossing point. out.append((scalar - gain, loc)) # The part after the crossing point may use one or two tents, # depending on whether upper is before axisMax or not, in one # case we need to keep it down to eternity. # Case 3a1, similar to case 1neg; just one tent needed, as in # the drawing above. if upper >= axisMax: loc = (crossing, axisMax, axisMax) scalar = outGain out.append((scalar - gain, loc)) # Case 3a2: Similar to case 2neg; two tents needed, to keep # down to eternity. # # | peak | # 1...................|.o................|... # |/ \_ | # gain................+....+_............|... # /| | \xxxxxxxxxxy| # / | | \_xxxxxyyyy| # / | | \xxyyyyyy| # 0---|-----------o | | o-------|--1 # axisMin lower | | upper | # | | | # axisDef | axisMax # | # crossing else: # A tent's peak cannot fall on axis default. Nudge it. if upper == axisDef: upper += EPSILON # Downslope. loc1 = (crossing, upper, axisMax) scalar1 = 0 # Eternity justify. loc2 = (upper, axisMax, axisMax) scalar2 = 0 out.append((scalar1 - gain, loc1)) out.append((scalar2 - gain, loc2)) else: # Special-case if peak is at axisMax. if axisMax == peak: upper = peak # Case 3: # We keep delta as is and only scale the axis upper to achieve # the desired new tent if feasible. # # peak # 1.....................o.................... # / \_| # ..................../....+_.........outGain # / | \ # gain..............+......|..+_............. # /| | | \ # 0---|-----------o | | | o----------1 # axisMin lower| | | upper # | | newUpper # axisDef axisMax # newUpper = peak + (1 - gain) * (upper - peak) assert axisMax <= newUpper # Because outGain > gain if newUpper <= axisDef + (axisMax - axisDef) * 2: upper = newUpper if not negative and axisDef + (axisMax - axisDef) * MAX_F2DOT14 < upper: # we clamp +2.0 to the max F2Dot14 (~1.99994) for convenience upper = axisDef + (axisMax - axisDef) * MAX_F2DOT14 assert peak < upper loc = (max(axisDef, lower), peak, upper) scalar = 1 out.append((scalar - gain, loc)) # Case 4: New limit doesn't fit; we need to chop into two tents, # because the shape of a triangle with part of one side cut off # cannot be represented as a triangle itself. # # | peak | # 1.........|......o.|.................... # ..........|...../x\|.............outGain # | |xxy|\_ # | /xxxy| \_ # | |xxxxy| \_ # | /xxxxy| \_ # 0---|-----|-oxxxxxx| o----------1 # axisMin | lower | upper # | | # axisDef axisMax # else: loc1 = (max(axisDef, lower), peak, axisMax) scalar1 = 1 loc2 = (peak, axisMax, axisMax) scalar2 = outGain out.append((scalar1 - gain, loc1)) # Don't add a dirac delta! if peak < axisMax: out.append((scalar2 - gain, loc2)) # Now, the negative side # Case 1neg: Lower extends beyond axisMin: we chop. Simple. # # | |peak # 1..................|...|.o................. # | |/ \ # gain...............|...+...\............... # |x_/| \ # |/ | \ # _/| | \ # 0---------------o | | o----------1 # lower | | upper # | | # axisMin axisDef # if lower <= axisMin: loc = (axisMin, axisMin, axisDef) scalar = supportScalar({"tag": axisMin}, {"tag": tent}) out.append((scalar - gain, loc)) # Case 2neg: Lower is betwen axisMin and axisDef: we add two # tents to keep it down all the way to eternity. # # | |peak # 1...|...............|.o................. # | |/ \ # gain|...............+...\............... # |yxxxxxxxxxxxxx/| \ # |yyyyyyxxxxxxx/ | \ # |yyyyyyyyyyyx/ | \ # 0---|-----------o | o----------1 # axisMin lower | upper # | # axisDef # else: # A tent's peak cannot fall on axis default. Nudge it. if lower == axisDef: lower -= EPSILON # Downslope. loc1 = (axisMin, lower, axisDef) scalar1 = 0 # Eternity justify. loc2 = (axisMin, axisMin, lower) scalar2 = 0 out.append((scalar1 - gain, loc1)) out.append((scalar2 - gain, loc2)) return out @lru_cache(128) def rebaseTent(tent, axisLimit): """Given a tuple (lower,peak,upper) "tent" and new axis limits (axisMin,axisDefault,axisMax), solves how to represent the tent under the new axis configuration. All values are in normalized -1,0,+1 coordinate system. Tent values can be outside this range. Return value is a list of tuples. Each tuple is of the form (scalar,tent), where scalar is a multipler to multiply any delta-sets by, and tent is a new tent for that output delta-set. If tent value is None, that is a special deltaset that should be always-enabled (called "gain").""" axisMin, axisDef, axisMax, _distanceNegative, _distancePositive = axisLimit assert -1 <= axisMin <= axisDef <= axisMax <= +1 lower, peak, upper = tent assert -2 <= lower <= peak <= upper <= +2 assert peak != 0 sols = _solve(tent, axisLimit) n = lambda v: axisLimit.renormalizeValue(v) sols = [ (scalar, (n(v[0]), n(v[1]), n(v[2])) if v is not None else None) for scalar, v in sols if scalar ] return sols