@lumen5/lottie-web 5.14.0

package/player/js/utils/PolynomialBezier.js

@@ -0,0 +1,253 @@
+function floatEqual(a, b) {
+  return Math.abs(a - b) * 100000 <= Math.min(Math.abs(a), Math.abs(b));
+}
+
+function floatZero(f) {
+  return Math.abs(f) <= 0.00001;
+}
+
+function lerp(p0, p1, amount) {
+  return p0 * (1 - amount) + p1 * amount;
+}
+
+function lerpPoint(p0, p1, amount) {
+  return [lerp(p0[0], p1[0], amount), lerp(p0[1], p1[1], amount)];
+}
+
+function quadRoots(a, b, c) {
+  // no root
+  if (a === 0) return [];
+  var s = b * b - 4 * a * c;
+  // Complex roots
+  if (s < 0) return [];
+  var singleRoot = -b / (2 * a);
+  // 1 root
+  if (s === 0) return [singleRoot];
+  var delta = Math.sqrt(s) / (2 * a);
+  // 2 roots
+  return [singleRoot - delta, singleRoot + delta];
+}
+
+function polynomialCoefficients(p0, p1, p2, p3) {
+  return [
+    -p0 + 3 * p1 - 3 * p2 + p3,
+    3 * p0 - 6 * p1 + 3 * p2,
+    -3 * p0 + 3 * p1,
+    p0,
+  ];
+}
+
+function singlePoint(p) {
+  return new PolynomialBezier(p, p, p, p, false);
+}
+
+function PolynomialBezier(p0, p1, p2, p3, linearize) {
+  if (linearize && pointEqual(p0, p1)) {
+    p1 = lerpPoint(p0, p3, 1 / 3);
+  }
+  if (linearize && pointEqual(p2, p3)) {
+    p2 = lerpPoint(p0, p3, 2 / 3);
+  }
+  var coeffx = polynomialCoefficients(p0[0], p1[0], p2[0], p3[0]);
+  var coeffy = polynomialCoefficients(p0[1], p1[1], p2[1], p3[1]);
+  this.a = [coeffx[0], coeffy[0]];
+  this.b = [coeffx[1], coeffy[1]];
+  this.c = [coeffx[2], coeffy[2]];
+  this.d = [coeffx[3], coeffy[3]];
+  this.points = [p0, p1, p2, p3];
+}
+PolynomialBezier.prototype.point = function (t) {
+  return [
+    (((this.a[0] * t) + this.b[0]) * t + this.c[0]) * t + this.d[0],
+    (((this.a[1] * t) + this.b[1]) * t + this.c[1]) * t + this.d[1],
+  ];
+};
+PolynomialBezier.prototype.derivative = function (t) {
+  return [
+    (3 * t * this.a[0] + 2 * this.b[0]) * t + this.c[0],
+    (3 * t * this.a[1] + 2 * this.b[1]) * t + this.c[1],
+  ];
+};
+PolynomialBezier.prototype.tangentAngle = function (t) {
+  var p = this.derivative(t);
+  return Math.atan2(p[1], p[0]);
+};
+PolynomialBezier.prototype.normalAngle = function (t) {
+  var p = this.derivative(t);
+  return Math.atan2(p[0], p[1]);
+};
+
+PolynomialBezier.prototype.inflectionPoints = function () {
+  var denom = this.a[1] * this.b[0] - this.a[0] * this.b[1];
+  if (floatZero(denom)) return [];
+  var tcusp = (-0.5 * (this.a[1] * this.c[0] - this.a[0] * this.c[1])) / denom;
+  var square = tcusp * tcusp - ((1 / 3) * (this.b[1] * this.c[0] - this.b[0] * this.c[1])) / denom;
+  if (square < 0) return [];
+  var root = Math.sqrt(square);
+  if (floatZero(root)) {
+    if (root > 0 && root < 1) return [tcusp];
+    return [];
+  }
+  return [tcusp - root, tcusp + root].filter(function (r) { return r > 0 && r < 1; });
+};
+PolynomialBezier.prototype.split = function (t) {
+  if (t <= 0) return [singlePoint(this.points[0]), this];
+  if (t >= 1) return [this, singlePoint(this.points[this.points.length - 1])];
+  var p10 = lerpPoint(this.points[0], this.points[1], t);
+  var p11 = lerpPoint(this.points[1], this.points[2], t);
+  var p12 = lerpPoint(this.points[2], this.points[3], t);
+  var p20 = lerpPoint(p10, p11, t);
+  var p21 = lerpPoint(p11, p12, t);
+  var p3 = lerpPoint(p20, p21, t);
+  return [
+    new PolynomialBezier(this.points[0], p10, p20, p3, true),
+    new PolynomialBezier(p3, p21, p12, this.points[3], true),
+  ];
+};
+function extrema(bez, comp) {
+  var min = bez.points[0][comp];
+  var max = bez.points[bez.points.length - 1][comp];
+  if (min > max) {
+    var e = max;
+    max = min;
+    min = e;
+  }
+  // Derivative roots to find min/max
+  var f = quadRoots(3 * bez.a[comp], 2 * bez.b[comp], bez.c[comp]);
+  for (var i = 0; i < f.length; i += 1) {
+    if (f[i] > 0 && f[i] < 1) {
+      var val = bez.point(f[i])[comp];
+      if (val < min) min = val;
+      else if (val > max) max = val;
+    }
+  }
+  return {
+    min: min,
+    max: max,
+  };
+}
+PolynomialBezier.prototype.bounds = function () {
+  return {
+    x: extrema(this, 0),
+    y: extrema(this, 1),
+  };
+};
+PolynomialBezier.prototype.boundingBox = function () {
+  var bounds = this.bounds();
+  return {
+    left: bounds.x.min,
+    right: bounds.x.max,
+    top: bounds.y.min,
+    bottom: bounds.y.max,
+    width: bounds.x.max - bounds.x.min,
+    height: bounds.y.max - bounds.y.min,
+    cx: (bounds.x.max + bounds.x.min) / 2,
+    cy: (bounds.y.max + bounds.y.min) / 2,
+  };
+};
+
+function intersectData(bez, t1, t2) {
+  var box = bez.boundingBox();
+  return {
+    cx: box.cx,
+    cy: box.cy,
+    width: box.width,
+    height: box.height,
+    bez: bez,
+    t: (t1 + t2) / 2,
+    t1: t1,
+    t2: t2,
+  };
+}
+function splitData(data) {
+  var split = data.bez.split(0.5);
+  return [
+    intersectData(split[0], data.t1, data.t),
+    intersectData(split[1], data.t, data.t2),
+  ];
+}
+
+function boxIntersect(b1, b2) {
+  return Math.abs(b1.cx - b2.cx) * 2 < b1.width + b2.width
+    && Math.abs(b1.cy - b2.cy) * 2 < b1.height + b2.height;
+}
+
+function intersectsImpl(d1, d2, depth, tolerance, intersections, maxRecursion) {
+  if (!boxIntersect(d1, d2)) return;
+  if (depth >= maxRecursion || (d1.width <= tolerance && d1.height <= tolerance && d2.width <= tolerance && d2.height <= tolerance)) {
+    intersections.push([d1.t, d2.t]);
+    return;
+  }
+  var d1s = splitData(d1);
+  var d2s = splitData(d2);
+  intersectsImpl(d1s[0], d2s[0], depth + 1, tolerance, intersections, maxRecursion);
+  intersectsImpl(d1s[0], d2s[1], depth + 1, tolerance, intersections, maxRecursion);
+  intersectsImpl(d1s[1], d2s[0], depth + 1, tolerance, intersections, maxRecursion);
+  intersectsImpl(d1s[1], d2s[1], depth + 1, tolerance, intersections, maxRecursion);
+}
+
+PolynomialBezier.prototype.intersections = function (other, tolerance, maxRecursion) {
+  if (tolerance === undefined) tolerance = 2;
+  if (maxRecursion === undefined) maxRecursion = 7;
+  var intersections = [];
+  intersectsImpl(intersectData(this, 0, 1), intersectData(other, 0, 1), 0, tolerance, intersections, maxRecursion);
+  return intersections;
+};
+
+PolynomialBezier.shapeSegment = function (shapePath, index) {
+  var nextIndex = (index + 1) % shapePath.length();
+  return new PolynomialBezier(shapePath.v[index], shapePath.o[index], shapePath.i[nextIndex], shapePath.v[nextIndex], true);
+};
+
+PolynomialBezier.shapeSegmentInverted = function (shapePath, index) {
+  var nextIndex = (index + 1) % shapePath.length();
+  return new PolynomialBezier(shapePath.v[nextIndex], shapePath.i[nextIndex], shapePath.o[index], shapePath.v[index], true);
+};
+
+function crossProduct(a, b) {
+  return [
+    a[1] * b[2] - a[2] * b[1],
+    a[2] * b[0] - a[0] * b[2],
+    a[0] * b[1] - a[1] * b[0],
+  ];
+}
+
+function lineIntersection(start1, end1, start2, end2) {
+  var v1 = [start1[0], start1[1], 1];
+  var v2 = [end1[0], end1[1], 1];
+  var v3 = [start2[0], start2[1], 1];
+  var v4 = [end2[0], end2[1], 1];
+
+  var r = crossProduct(
+    crossProduct(v1, v2),
+    crossProduct(v3, v4)
+  );
+
+  if (floatZero(r[2])) return null;
+
+  return [r[0] / r[2], r[1] / r[2]];
+}
+
+function polarOffset(p, angle, length) {
+  return [
+    p[0] + Math.cos(angle) * length,
+    p[1] - Math.sin(angle) * length,
+  ];
+}
+
+function pointDistance(p1, p2) {
+  return Math.hypot(p1[0] - p2[0], p1[1] - p2[1]);
+}
+
+function pointEqual(p1, p2) {
+  return floatEqual(p1[0], p2[0]) && floatEqual(p1[1], p2[1]);
+}
+
+export {
+  PolynomialBezier,
+  lineIntersection,
+  polarOffset,
+  pointDistance,
+  pointEqual,
+  floatEqual,
+};