Initial commit

venv/lib/python3.10/site-packages/fontTools/varLib/instancer/solver.py

@@ -0,0 +1,309 @@
+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
+        # Disabled because ots doesn't like us:
+        # https://github.com/fonttools/fonttools/issues/3350
+        if False and 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