curvy 0.3.1 → 0.3.3

package/dist/curve.mjs

@@ -1,5 +1,5 @@
 import invariant from 'tiny-invariant';
-import { createCurveAxis } from './axis.mjs';
+import { c as computeCubicAntiderivative, a as createCurveAxis } from './shared/curvy.7876e09e.mjs';
 import { r as remap, a as round } from './shared/curvy.9cd8b44c.mjs';
 import { splines } from './splines.mjs';
 
@@ -61,42 +61,193 @@ function createIntervalTree(boundaries) {
   };
 }
 
+function collectPointsOfInterest(axis) {
+  const samples = new Set(Array.from({ length: 33 }, (_, i) => i / 32));
+  const segmentToNormalized = 1 / axis.segments.length;
+  for (const [index, segment] of axis.segments.entries()) {
+    samples.add(index * segmentToNormalized);
+    samples.add((index + 1) * segmentToNormalized);
+    for (const t of segment.extrema) {
+      samples.add((index + t) * segmentToNormalized);
+    }
+    for (const root of segment.roots) {
+      samples.add((index + root) * segmentToNormalized);
+    }
+    for (const root of segment.derivative.roots) {
+      samples.add((index + root) * segmentToNormalized);
+    }
+  }
+  return Array.from(samples).sort((a, b) => a - b);
+}
+function takeLinearIntegral(x1, x2, y1, y2) {
+  const m = (y2 - y1) / (x2 - x1);
+  const b = y1 - m * x1;
+  const s1 = x1 ** 2 * m / 2 + b * x1;
+  const s2 = x2 ** 2 * m / 2 + b * x2;
+  return Math.abs(s2 - s1);
+}
+function takePolynomialIntegral(coefficients, start, end) {
+  let s1 = 0;
+  let s2 = 0;
+  for (let i = 0; i < coefficients.length; i++) {
+    const power = coefficients.length - i;
+    s1 += coefficients[i] * start ** power / power;
+    s2 += coefficients[i] * end ** power / power;
+  }
+  return Math.abs(s2 - s1);
+}
+function* createAxisSampler(key, axis) {
+  const queue = collectPointsOfInterest(axis);
+  let totalLength = 0;
+  const lengthLookup = /* @__PURE__ */ new Map();
+  while (queue.length > 0) {
+    const current = queue[0];
+    const next = queue[1];
+    if (next === void 0) {
+      yield current;
+      lengthLookup.set(totalLength, current);
+      break;
+    }
+    const segment = axis.segments[Math.floor(current * axis.segments.length)];
+    const currentPosition = axis.solvePosition(current);
+    const nextPosition = axis.solvePosition(next);
+    const currentVelocity = axis.solveVelocity(current);
+    const nextVelocity = axis.solveVelocity(next);
+    const lutPositionIntegral = takeLinearIntegral(
+      current,
+      next,
+      currentPosition,
+      nextPosition
+    );
+    const curvePositionIntegral = takePolynomialIntegral(
+      computeCubicAntiderivative(segment.coefficients, 0),
+      current,
+      next
+    );
+    const lutVelocityIntegral = takeLinearIntegral(
+      current,
+      next,
+      currentVelocity,
+      nextVelocity
+    );
+    const curveVelocityIntegral = takePolynomialIntegral(
+      segment.derivative.coefficients,
+      current,
+      next
+    );
+    const error = Math.max(
+      Math.abs(lutPositionIntegral - curvePositionIntegral),
+      Math.abs(lutVelocityIntegral - curveVelocityIntegral)
+    );
+    if (error > 1) {
+      queue.splice(1, 0, (current + next) / 2);
+    } else {
+      yield current;
+      lengthLookup.set(totalLength, current);
+      totalLength += Math.hypot(current - next, currentPosition - nextPosition);
+      queue.shift();
+    }
+  }
+  return [
+    key,
+    {
+      length: totalLength,
+      lookup: lengthLookup
+    }
+  ];
+}
 function distance(a, b) {
-  const keys = Object.keys(a);
-  const deltas = keys.map((key) => a[key] - b[key]);
+  const deltas = [];
+  for (const key of Object.keys(a)) {
+    deltas.push(a[key] - b[key]);
+  }
   return Math.hypot(...deltas);
 }
-function createLengthLookup(positionAt) {
-  const count = 512;
-  const orderedSamples = Array.from({ length: count + 1 }, (_, i) => i / count);
+function createSampleBuffer() {
+  const values = /* @__PURE__ */ new Map();
+  return {
+    get size() {
+      return values.size;
+    },
+    add(key, value) {
+      if (!values.has(key)) {
+        values.set(key, /* @__PURE__ */ new Set());
+      }
+      values.get(key)?.add(value);
+    },
+    get(key) {
+      return values.get(key);
+    },
+    remove(key, value) {
+      values.get(key)?.delete(value);
+      if (values.get(key)?.size === 0) {
+        values.delete(key);
+      }
+    },
+    keys() {
+      return Array.from(values.keys());
+    }
+  };
+}
+function createLengthLookup({
+  length: totalLength,
+  lookup
+}) {
+  const { search } = createIntervalTree(Array.from(lookup.keys()));
+  return (normalized) => {
+    invariant(normalized >= 0 && normalized <= 1, "Length out of bounds");
+    const length = normalized * totalLength;
+    const result = search(length);
+    invariant(result, "Length not found");
+    return remap(
+      length,
+      result[0],
+      result[1],
+      lookup.get(result[0]),
+      lookup.get(result[1])
+    );
+  };
+}
+function createCurveLengthLookups(axes, positionAt) {
   const lengthLookup = /* @__PURE__ */ new Map();
+  const axesLookups = {};
+  const sampleBuffer = createSampleBuffer();
+  for (const [key, axis] of Object.entries(axes)) {
+    const sampler = createAxisSampler(key, axis);
+    const first = sampler.next();
+    if (first.done) {
+      axesLookups[first.value[0]] = createLengthLookup(first.value[1]);
+    } else {
+      sampleBuffer.add(first.value, sampler);
+    }
+  }
   let lastPoint = positionAt(0);
   let length = 0;
   lengthLookup.set(0, 0);
-  for (const t of orderedSamples.slice(1)) {
+  while (sampleBuffer.size > 0) {
+    const t = Math.min(...sampleBuffer.keys());
     const point = positionAt(t);
     length = length + distance(lastPoint, point);
     lengthLookup.set(length, t);
     lastPoint = point;
+    const samplers = sampleBuffer.get(t);
+    for (const sampler of samplers) {
+      const next = sampler.next();
+      if (next.done) {
+        axesLookups[next.value[0]] = createLengthLookup(next.value[1]);
+      } else {
+        sampleBuffer.add(next.value, sampler);
+      }
+      sampleBuffer.remove(t, sampler);
+    }
   }
-  const totalLength = length;
-  const { search } = createIntervalTree(Array.from(lengthLookup.keys()));
-  return (normalized) => {
-    invariant(normalized >= 0 && normalized <= 1, "Length out of bounds");
-    const length2 = normalized * totalLength;
-    const result = search(length2);
-    invariant(result, "Length not found");
-    return remap(
-      length2,
-      result[0],
-      result[1],
-      lengthLookup.get(result[0]),
-      lengthLookup.get(result[1])
-    );
+  return {
+    curve: createLengthLookup({ length, lookup: lengthLookup }),
+    axes: axesLookups
   };
 }
 
-function createCurve(points, spline) {
+function convertPointsToAxes(points, spline) {
   const axisKeys = Object.keys(points[0]);
   const axisPoints = {};
   for (const key of axisKeys) {
@@ -112,6 +263,10 @@ function createCurve(points, spline) {
   for (const key of axisKeys) {
     axes[key] = createCurveAxis(spline.chunkCoefficients(axisPoints[key]));
   }
+  return axes;
+}
+function createCurve(axes) {
+  const axisKeys = Object.keys(axes);
   const solveT = (t, precision = 12) => {
     const rounded = round(t);
     invariant(
@@ -124,7 +279,7 @@ function createCurve(points, spline) {
     }
     return position;
   };
-  const lengthLookup = createLengthLookup(solveT);
+  const lengthLookups = createCurveLengthLookups(axes, solveT);
   const positionAt = (input, normalize = 1, precision = 12) => {
     invariant(
       input >= 0 && input <= 1,
@@ -132,7 +287,23 @@ function createCurve(points, spline) {
     );
     let t = input;
     if (normalize > 0) {
-      const denormalizedT = lengthLookup(input);
+      const denormalizedT = lengthLookups.curve(input);
+      if (normalize === 1) {
+        t = denormalizedT;
+      } else {
+        t = (1 - normalize) * input + normalize * denormalizedT;
+      }
+    }
+    return solveT(t, precision);
+  };
+  const solveAlong = (axis, input, normalize = 1, precision = 12) => {
+    invariant(
+      input >= 0 && input <= 1,
+      `Input must be between 0 and 1, got ${input}`
+    );
+    let t = input;
+    if (normalize > 0) {
+      const denormalizedT = lengthLookups.axes[axis](input);
       if (normalize === 1) {
         t = denormalizedT;
       } else {
@@ -149,34 +320,35 @@ function createCurve(points, spline) {
       typeof t === "number",
       `Could not solve for ${axis} = ${position}`
     );
-    const result = { [axis]: round(position, precision) };
-    for (const key of axisKeys) {
-      if (key !== axis) {
-        result[key] = round(axes[key].solvePosition(t), precision);
-      }
-    }
-    return result;
+    return positionAt(t, 0, precision);
   };
   return {
     axes,
     positionAt,
+    solveAlong,
     solveWhere
   };
 }
 function createBasisCurve(points, triplicateEndpoints = true) {
-  return createCurve(points, splines.basis(triplicateEndpoints));
+  return createCurve(
+    convertPointsToAxes(points, splines.basis(triplicateEndpoints))
+  );
 }
 function createBezierCurve(points) {
-  return createCurve(points, splines.bezier);
+  return createCurve(convertPointsToAxes(points, splines.bezier));
 }
 function createCardinalCurve(points, tension = 0.5, duplicateEndpoints = true) {
-  return createCurve(points, splines.cardinal(tension, duplicateEndpoints));
+  return createCurve(
+    convertPointsToAxes(points, splines.cardinal(tension, duplicateEndpoints))
+  );
 }
 function createCatmullRomCurve(points, duplicateEndpoints = true) {
-  return createCurve(points, splines.catmullRom(duplicateEndpoints));
+  return createCurve(
+    convertPointsToAxes(points, splines.catmullRom(duplicateEndpoints))
+  );
 }
 function createHermiteCurve(points) {
-  return createCurve(points, splines.hermite);
+  return createCurve(convertPointsToAxes(points, splines.hermite));
 }
 
-export { createBasisCurve, createBezierCurve, createCardinalCurve, createCatmullRomCurve, createHermiteCurve };
+export { createBasisCurve, createBezierCurve, createCardinalCurve, createCatmullRomCurve, createCurve, createHermiteCurve };

package/dist/shared/curvy.7876e09e.mjs

@@ -0,0 +1,323 @@
+import invariant from 'tiny-invariant';
+import { splines } from '../splines.mjs';
+
+const UNIT_INTERVAL = [0, 1];
+function createLinearPolynomial(coefficients, domain = UNIT_INTERVAL) {
+  const [a, b] = coefficients;
+  invariant(domain[0] <= domain[1], "invalid domain");
+  let root = a === 0 ? null : b === 0 ? 0 : -b / a;
+  if (root !== null && (root < domain[0] || root > domain[1])) {
+    root = null;
+  }
+  const range = a >= 0 ? [a * domain[0] + b, a * domain[1] + b] : [a * domain[1] + b, a * domain[0] + b];
+  const solve = (x) => {
+    invariant(x >= domain[0] && x <= domain[1], "x out of domain");
+    return a * x + b;
+  };
+  const solveInverse = (y) => {
+    invariant(y >= range[0] && y <= range[1], "y out of range");
+    return a === 0 ? 0 : (y - b) / a;
+  };
+  return {
+    domain,
+    range,
+    monotonicity: a === 0 ? "constant" : a > 0 ? "increasing" : "decreasing",
+    coefficients,
+    root,
+    solve,
+    solveInverse
+  };
+}
+function createQuadraticRootSolver(coefficients, defaultDomain, range) {
+  const [a, b, c] = coefficients;
+  if (a !== 0) {
+    return function solveInverse(y, domain = defaultDomain) {
+      invariant(domain[0] <= domain[1], "invalid domain");
+      invariant(y >= range[0] && y <= range[1], "y out of range");
+      const discriminant = b ** 2 - 4 * a * (c - y);
+      if (discriminant < 0) {
+        return [];
+      }
+      if (discriminant === 0) {
+        const root = -b / (2 * a);
+        return root < domain[0] || root > domain[1] ? [] : [root];
+      }
+      const sqrtDiscriminant = Math.sqrt(discriminant);
+      const denominator = 2 * a;
+      const left = (-b - sqrtDiscriminant) / denominator;
+      const right = (-b + sqrtDiscriminant) / denominator;
+      const leftInDomain = left >= domain[0] && left <= domain[1];
+      const rightInDomain = right >= domain[0] && right <= domain[1];
+      if (leftInDomain && rightInDomain) {
+        return left < right ? [left, right] : [right, left];
+      }
+      if (leftInDomain) {
+        return [left];
+      }
+      if (rightInDomain) {
+        return [right];
+      }
+      return [];
+    };
+  }
+  if (b !== 0) {
+    return function solveInverse(y, domain = defaultDomain) {
+      invariant(domain[0] <= domain[1], "invalid domain");
+      invariant(y >= range[0] && y <= range[1], "y out of range");
+      const root = -(c - y) / b;
+      return root < domain[0] || root > domain[1] ? [] : [root];
+    };
+  }
+  return function solveInverse() {
+    return [];
+  };
+}
+function createQuadraticPolynomial(coefficients, domain = UNIT_INTERVAL) {
+  const [a, b, c] = coefficients;
+  invariant(domain[0] <= domain[1], "invalid domain");
+  const derivative = createLinearPolynomial([2 * a, b], domain);
+  const extreme = derivative.root;
+  const solve = (x) => {
+    invariant(x >= domain[0] && x <= domain[1], "x out of domain");
+    return a * x ** 2 + b * x + c;
+  };
+  const rangeCandidates = extreme === null ? [solve(domain[0]), solve(domain[1])] : [solve(domain[0]), solve(extreme), solve(domain[1])];
+  const range = [
+    Math.min(...rangeCandidates),
+    Math.max(...rangeCandidates)
+  ];
+  const solveInverse = createQuadraticRootSolver(coefficients, domain, range);
+  const roots = range[0] > 0 || range[1] < 0 ? [] : solveInverse(0);
+  return {
+    domain,
+    range,
+    coefficients,
+    monotonicity: a !== 0 ? "none" : b === 0 ? "constant" : b > 0 ? "increasing" : "decreasing",
+    extreme,
+    roots,
+    derivative,
+    solve,
+    solveInverse
+  };
+}
+const TWO_THIRDS_PI = 2 * Math.PI / 3;
+function createCubicRootSolver(coefficients, defaultDomain, range) {
+  if (coefficients[0] === 0) {
+    return createQuadraticRootSolver(
+      [coefficients[1], coefficients[2], coefficients[3]],
+      defaultDomain,
+      range
+    );
+  }
+  const oneOverA = 1 / coefficients[0];
+  const a0 = coefficients[1] * oneOverA;
+  const a1 = coefficients[2] * oneOverA;
+  const a2OverThree = a0 / 3;
+  const q = a1 / 3 - a0 ** 2 / 9;
+  const r0 = a1 * a0 / 6 - a0 ** 3 / 27;
+  return function solveInverse(y, domain = defaultDomain) {
+    invariant(domain[0] <= domain[1], "invalid domain");
+    invariant(y >= range[0] && y <= range[1], "y out of range");
+    const a02 = (coefficients[3] - y) * oneOverA;
+    const r = r0 - a02 * 0.5;
+    const discriminant = q ** 3 + r ** 2;
+    if (discriminant > 0) {
+      const a = Math.cbrt(Math.abs(r) + Math.sqrt(discriminant));
+      const root = (r < 0 ? q / a - a : a - q / a) - a2OverThree;
+      return root < domain[0] || root > domain[1] ? [] : [root];
+    }
+    const theta = Math.acos(r / Math.sqrt((-q) ** 3)) / 3;
+    const twoRootQ = 2 * Math.sqrt(-q);
+    const root1 = twoRootQ * Math.cos(theta - TWO_THIRDS_PI) - a2OverThree;
+    const root2 = twoRootQ * Math.cos(theta) - a2OverThree;
+    const root3 = twoRootQ * Math.cos(theta + TWO_THIRDS_PI) - a2OverThree;
+    const candidates = [root1, root2, root3];
+    const roots = [];
+    for (const candidate of candidates) {
+      if (candidate >= domain[0] && candidate <= domain[1] && !roots.includes(candidate)) {
+        roots.push(candidate);
+      }
+    }
+    roots.sort((a, b) => a - b);
+    return roots;
+  };
+}
+function getMonotonicity(extrema, derivative, domain) {
+  if (derivative.coefficients[0] === 0 && derivative.coefficients[1] === 0 && derivative.coefficients[2] === 0) {
+    return "constant";
+  }
+  let hasInnerExtrema = false;
+  for (const extreme of extrema) {
+    if (extreme > domain[0] && extreme > domain[1]) {
+      hasInnerExtrema = true;
+      break;
+    }
+  }
+  if (hasInnerExtrema) {
+    return "none";
+  }
+  let test = derivative.solve(domain[0]);
+  if (test === 0) {
+    test = derivative.solve((domain[0] + domain[1]) * 0.5);
+  }
+  return Math.sign(test) > 0 ? "increasing" : "decreasing";
+}
+function createCubicPolynomial(coefficients, domain = UNIT_INTERVAL) {
+  invariant(domain[0] <= domain[1], "invalid domain");
+  const [a, b, c, d] = coefficients;
+  const derivative = createQuadraticPolynomial([3 * a, 2 * b, c], domain);
+  const extrema = derivative.roots.length === 1 && derivative.coefficients[0] !== 0 ? [] : derivative.roots;
+  const solve = (x) => {
+    invariant(x >= domain[0] && x <= domain[1], "x out of domain");
+    return a * x ** 3 + b * x ** 2 + c * x + d;
+  };
+  const rangeCandidates = [
+    solve(domain[0]),
+    ...extrema.map((extreme) => solve(extreme)),
+    solve(domain[1])
+  ];
+  const range = [
+    Math.min(...rangeCandidates),
+    Math.max(...rangeCandidates)
+  ];
+  const solveInverse = createCubicRootSolver(coefficients, domain, range);
+  const roots = range[0] > 0 || range[1] < 0 ? [] : solveInverse(0, domain);
+  const monotonicity = getMonotonicity(extrema, derivative, domain);
+  return {
+    domain,
+    range,
+    monotonicity,
+    coefficients,
+    extrema,
+    roots,
+    derivative,
+    solve,
+    solveInverse
+  };
+}
+function computeCubicAntiderivative(coefficients, integrationConstant) {
+  return [
+    coefficients[0] / 4,
+    coefficients[1] / 3,
+    coefficients[2] / 2,
+    coefficients[3],
+    integrationConstant
+  ];
+}
+
+function getCurveExtrema(lookup) {
+  const extremaLookup = new Map(lookup);
+  const extremaCandidates = Array.from(extremaLookup.keys());
+  for (const [index, t] of extremaCandidates.entries()) {
+    if (index === 0 || index === extremaCandidates.length - 1) {
+      continue;
+    }
+    const previous = extremaLookup.get(extremaCandidates[index - 1]);
+    const current = extremaLookup.get(t);
+    const next = extremaLookup.get(extremaCandidates[index + 1]);
+    if (previous <= current && current < next || previous >= current && current > next) {
+      extremaLookup.delete(t);
+    }
+  }
+  const extrema = Array.from(extremaLookup.keys());
+  return extrema;
+}
+function createCurveAxis(coefficients) {
+  invariant(coefficients.length > 0, "Curve must have at least one segment");
+  const segments = [];
+  const extremaLookup = /* @__PURE__ */ new Map();
+  let monotonicity = "none";
+  const normalizedToCurve = coefficients.length;
+  const curveToNormalized = 1 / coefficients.length;
+  for (let i = 0; i < coefficients.length; i++) {
+    const segment = createCubicPolynomial(coefficients[i], UNIT_INTERVAL);
+    segments.push(segment);
+    extremaLookup.set(i * curveToNormalized, segment.solve(0));
+    for (const extreme of segment.extrema) {
+      extremaLookup.set(
+        (i + extreme) * curveToNormalized,
+        segment.solve(extreme)
+      );
+    }
+    if (i === 0) {
+      monotonicity = segment.monotonicity;
+    } else if (monotonicity !== segment.monotonicity) {
+      monotonicity = "none";
+    }
+  }
+  extremaLookup.set(1, segments[segments.length - 1].solve(1));
+  const extrema = getCurveExtrema(extremaLookup);
+  const range = [
+    Math.min(...extremaLookup.values()),
+    Math.max(...extremaLookup.values())
+  ];
+  const getSegmentAndInput = (t) => {
+    invariant(t >= 0 && t <= 1, "t out of range");
+    if (t === 1) {
+      return { segment: segments[segments.length - 1], input: 1 };
+    }
+    const curveT = t * normalizedToCurve;
+    const index = Math.floor(curveT);
+    const segment = segments[index];
+    const input = curveT - index;
+    return { segment, input };
+  };
+  const solvePosition = (t) => {
+    const { segment, input } = getSegmentAndInput(t);
+    return segment.solve(input);
+  };
+  const solveVelocity = (t) => {
+    const { segment, input } = getSegmentAndInput(t);
+    return segment.derivative.solve(input);
+  };
+  const solveT = (position, domain) => {
+    invariant(
+      position >= range[0] && position <= range[1],
+      "position out of range"
+    );
+    invariant(domain[0] <= domain[1], "invalid domain");
+    const result = [];
+    for (const [index, segment] of segments.entries()) {
+      if (position >= segment.range[0] && position <= segment.range[1]) {
+        const t = segment.solveInverse(position, domain);
+        for (const tValue of t) {
+          result.push((index + tValue) * curveToNormalized);
+        }
+      }
+    }
+    return result;
+  };
+  return {
+    domain: UNIT_INTERVAL,
+    range,
+    monotonicity,
+    extrema,
+    segments,
+    solvePosition,
+    solveVelocity,
+    solveT
+  };
+}
+function createBasisAxis(parameters, triplicateEndpoints = true) {
+  return createCurveAxis(
+    splines.basis(triplicateEndpoints).chunkCoefficients(parameters)
+  );
+}
+function createBezierAxis(parameters) {
+  return createCurveAxis(splines.bezier.chunkCoefficients(parameters));
+}
+function createCardinalAxis(parameters, a = 0.5, duplicateEndpoints = true) {
+  return createCurveAxis(
+    splines.cardinal(a, duplicateEndpoints).chunkCoefficients(parameters)
+  );
+}
+function createCatmullRomAxis(parameters, duplicateEndpoints = true) {
+  return createCurveAxis(
+    splines.catmullRom(duplicateEndpoints).chunkCoefficients(parameters)
+  );
+}
+function createHermiteAxis(parameters) {
+  return createCurveAxis(splines.hermite.chunkCoefficients(parameters));
+}
+
+export { createCurveAxis as a, createBasisAxis as b, computeCubicAntiderivative as c, createBezierAxis as d, createCardinalAxis as e, createCatmullRomAxis as f, createHermiteAxis as g };