@excalidraw/math 0.18.0-9036812b6 → 0.18.0-9ba0f5d

package/dist/dev/index.js

@@ -202,45 +202,152 @@ var LegendreGaussN24CValues = [
   0.0123412297999872
 ];
 
+// src/line.ts
+function line(a, b) {
+  return [a, b];
+}
+function linesIntersectAt(a, b) {
+  const A1 = a[1][1] - a[0][1];
+  const B1 = a[0][0] - a[1][0];
+  const A2 = b[1][1] - b[0][1];
+  const B2 = b[0][0] - b[1][0];
+  const D = A1 * B2 - A2 * B1;
+  if (D !== 0) {
+    const C1 = A1 * a[0][0] + B1 * a[0][1];
+    const C2 = A2 * b[0][0] + B2 * b[0][1];
+    return pointFrom((C1 * B2 - C2 * B1) / D, (A1 * C2 - A2 * C1) / D);
+  }
+  return null;
+}
+
+// src/segment.ts
+function lineSegment(a, b) {
+  return [a, b];
+}
+var isLineSegment = (segment) => Array.isArray(segment) && segment.length === 2 && isPoint(segment[0]) && isPoint(segment[0]);
+var lineSegmentRotate = (l, angle, origin) => {
+  return lineSegment(
+    pointRotateRads(l[0], origin || pointCenter(l[0], l[1]), angle),
+    pointRotateRads(l[1], origin || pointCenter(l[0], l[1]), angle)
+  );
+};
+var segmentsIntersectAt = (a, b) => {
+  const a0 = vectorFromPoint(a[0]);
+  const a1 = vectorFromPoint(a[1]);
+  const b0 = vectorFromPoint(b[0]);
+  const b1 = vectorFromPoint(b[1]);
+  const r = vectorSubtract(a1, a0);
+  const s = vectorSubtract(b1, b0);
+  const denominator = vectorCross(r, s);
+  if (denominator === 0) {
+    return null;
+  }
+  const i = vectorSubtract(vectorFromPoint(b[0]), vectorFromPoint(a[0]));
+  const u = vectorCross(i, r) / denominator;
+  const t = vectorCross(i, s) / denominator;
+  if (u === 0) {
+    return null;
+  }
+  const p = vectorAdd(a0, vectorScale(r, t));
+  if (t >= 0 && t < 1 && u >= 0 && u < 1) {
+    return pointFromVector(p);
+  }
+  return null;
+};
+var pointOnLineSegment = (point, line2, threshold = PRECISION) => {
+  const distance = distanceToLineSegment(point, line2);
+  if (distance === 0) {
+    return true;
+  }
+  return distance < threshold;
+};
+var distanceToLineSegment = (point, line2) => {
+  const [x, y] = point;
+  const [[x1, y1], [x2, y2]] = line2;
+  const A = x - x1;
+  const B = y - y1;
+  const C = x2 - x1;
+  const D = y2 - y1;
+  const dot = A * C + B * D;
+  const len_sq = C * C + D * D;
+  let param = -1;
+  if (len_sq !== 0) {
+    param = dot / len_sq;
+  }
+  let xx;
+  let yy;
+  if (param < 0) {
+    xx = x1;
+    yy = y1;
+  } else if (param > 1) {
+    xx = x2;
+    yy = y2;
+  } else {
+    xx = x1 + param * C;
+    yy = y1 + param * D;
+  }
+  const dx = x - xx;
+  const dy = y - yy;
+  return Math.sqrt(dx * dx + dy * dy);
+};
+function lineSegmentIntersectionPoints(l, s, threshold) {
+  const candidate = linesIntersectAt(line(l[0], l[1]), line(s[0], s[1]));
+  if (!candidate || !pointOnLineSegment(candidate, s, threshold) || !pointOnLineSegment(candidate, l, threshold)) {
+    return null;
+  }
+  return candidate;
+}
+function lineSegmentsDistance(s1, s2) {
+  if (lineSegmentIntersectionPoints(s1, s2)) {
+    return 0;
+  }
+  return Math.min(
+    distanceToLineSegment(s1[0], s2),
+    distanceToLineSegment(s1[1], s2),
+    distanceToLineSegment(s2[0], s1),
+    distanceToLineSegment(s2[1], s1)
+  );
+}
+
 // src/curve.ts
 function curve(a, b, c, d) {
   return [a, b, c, d];
 }
-function gradient(f, t0, s0, delta = 1e-6) {
-  return [
-    (f(t0 + delta, s0) - f(t0 - delta, s0)) / (2 * delta),
-    (f(t0, s0 + delta) - f(t0, s0 - delta)) / (2 * delta)
-  ];
-}
-function solve(f, t0, s0, tolerance = 1e-3, iterLimit = 10) {
+function solveWithAnalyticalJacobian(curve2, lineSegment2, t0, s0, tolerance = 1e-3, iterLimit = 10) {
   let error = Infinity;
   let iter = 0;
   while (error >= tolerance) {
     if (iter >= iterLimit) {
       return null;
     }
-    const y0 = f(t0, s0);
-    const jacobian = [
-      gradient((t, s) => f(t, s)[0], t0, s0),
-      gradient((t, s) => f(t, s)[1], t0, s0)
-    ];
-    const b = [[-y0[0]], [-y0[1]]];
-    const det = jacobian[0][0] * jacobian[1][1] - jacobian[0][1] * jacobian[1][0];
-    if (det === 0) {
+    const bt = 1 - t0;
+    const bt2 = bt * bt;
+    const bt3 = bt2 * bt;
+    const t0_2 = t0 * t0;
+    const t0_3 = t0_2 * t0;
+    const bezierX = bt3 * curve2[0][0] + 3 * bt2 * t0 * curve2[1][0] + 3 * bt * t0_2 * curve2[2][0] + t0_3 * curve2[3][0];
+    const bezierY = bt3 * curve2[0][1] + 3 * bt2 * t0 * curve2[1][1] + 3 * bt * t0_2 * curve2[2][1] + t0_3 * curve2[3][1];
+    const lineX = lineSegment2[0][0] + s0 * (lineSegment2[1][0] - lineSegment2[0][0]);
+    const lineY = lineSegment2[0][1] + s0 * (lineSegment2[1][1] - lineSegment2[0][1]);
+    const fx = bezierX - lineX;
+    const fy = bezierY - lineY;
+    error = Math.abs(fx) + Math.abs(fy);
+    if (error < tolerance) {
+      break;
+    }
+    const dfx_dt = -3 * bt2 * curve2[0][0] + 3 * bt2 * curve2[1][0] - 6 * bt * t0 * curve2[1][0] - 3 * t0_2 * curve2[2][0] + 6 * bt * t0 * curve2[2][0] + 3 * t0_2 * curve2[3][0];
+    const dfy_dt = -3 * bt2 * curve2[0][1] + 3 * bt2 * curve2[1][1] - 6 * bt * t0 * curve2[1][1] - 3 * t0_2 * curve2[2][1] + 6 * bt * t0 * curve2[2][1] + 3 * t0_2 * curve2[3][1];
+    const dfx_ds = -(lineSegment2[1][0] - lineSegment2[0][0]);
+    const dfy_ds = -(lineSegment2[1][1] - lineSegment2[0][1]);
+    const det = dfx_dt * dfy_ds - dfx_ds * dfy_dt;
+    if (Math.abs(det) < 1e-12) {
       return null;
     }
-    const iJ = [
-      [jacobian[1][1] / det, -jacobian[0][1] / det],
-      [-jacobian[1][0] / det, jacobian[0][0] / det]
-    ];
-    const h = [
-      [iJ[0][0] * b[0][0] + iJ[0][1] * b[1][0]],
-      [iJ[1][0] * b[0][0] + iJ[1][1] * b[1][0]]
-    ];
-    t0 = t0 + h[0][0];
-    s0 = s0 + h[1][0];
-    const [tErr, sErr] = f(t0, s0);
-    error = Math.max(Math.abs(tErr), Math.abs(sErr));
+    const invDet = 1 / det;
+    const dt = invDet * (dfy_ds * -fx - dfx_ds * -fy);
+    const ds = invDet * (-dfy_dt * -fx + dfx_dt * -fy);
+    t0 += dt;
+    s0 += ds;
     iter += 1;
   }
   return [t0, s0];
@@ -249,50 +356,49 @@ var bezierEquation = (c, t) => pointFrom(
   (1 - t) ** 3 * c[0][0] + 3 * (1 - t) ** 2 * t * c[1][0] + 3 * (1 - t) * t ** 2 * c[2][0] + t ** 3 * c[3][0],
   (1 - t) ** 3 * c[0][1] + 3 * (1 - t) ** 2 * t * c[1][1] + 3 * (1 - t) * t ** 2 * c[2][1] + t ** 3 * c[3][1]
 );
+var initial_guesses = [
+  [0.5, 0],
+  [0.2, 0],
+  [0.8, 0]
+];
+var calculate = ([t0, s0], l, c) => {
+  const solution = solveWithAnalyticalJacobian(c, l, t0, s0, 0.01, 3);
+  if (!solution) {
+    return null;
+  }
+  const [t, s] = solution;
+  if (t < 0 || t > 1 || s < 0 || s > 1) {
+    return null;
+  }
+  return bezierEquation(c, t);
+};
 function curveIntersectLineSegment(c, l) {
-  const line2 = (s) => pointFrom(
-    l[0][0] + s * (l[1][0] - l[0][0]),
-    l[0][1] + s * (l[1][1] - l[0][1])
-  );
-  const initial_guesses = [
-    [0.5, 0],
-    [0.2, 0],
-    [0.8, 0]
-  ];
-  const calculate = ([t0, s0]) => {
-    const solution2 = solve(
-      (t2, s2) => {
-        const bezier_point = bezierEquation(c, t2);
-        const line_point = line2(s2);
-        return [
-          bezier_point[0] - line_point[0],
-          bezier_point[1] - line_point[1]
-        ];
-      },
-      t0,
-      s0
-    );
-    if (!solution2) {
-      return null;
-    }
-    const [t, s] = solution2;
-    if (t < 0 || t > 1 || s < 0 || s > 1) {
-      return null;
-    }
-    return bezierEquation(c, t);
-  };
-  let solution = calculate(initial_guesses[0]);
+  let solution = calculate(initial_guesses[0], l, c);
   if (solution) {
     return [solution];
   }
-  solution = calculate(initial_guesses[1]);
+  solution = calculate(initial_guesses[1], l, c);
   if (solution) {
     return [solution];
   }
-  solution = calculate(initial_guesses[2]);
+  solution = calculate(initial_guesses[2], l, c);
   if (solution) {
     return [solution];
   }
+  const startHit = lineSegmentIntersectionPoints(
+    lineSegment(bezierEquation(c, 0), bezierEquation(c, 1 / 20)),
+    l
+  );
+  if (startHit) {
+    return [startHit];
+  }
+  const endHit = lineSegmentIntersectionPoints(
+    lineSegment(bezierEquation(c, 19 / 20), bezierEquation(c, 1)),
+    l
+  );
+  if (endHit) {
+    return [endHit];
+  }
   return [];
 }
 function curveClosestPoint(c, p, tolerance = 1e-3) {
@@ -602,102 +708,6 @@ function ellipseLineIntersectionPoints({ center, halfWidth, halfHeight }, [g, h]
   return candidates;
 }
 
-// src/line.ts
-function line(a, b) {
-  return [a, b];
-}
-function linesIntersectAt(a, b) {
-  const A1 = a[1][1] - a[0][1];
-  const B1 = a[0][0] - a[1][0];
-  const A2 = b[1][1] - b[0][1];
-  const B2 = b[0][0] - b[1][0];
-  const D = A1 * B2 - A2 * B1;
-  if (D !== 0) {
-    const C1 = A1 * a[0][0] + B1 * a[0][1];
-    const C2 = A2 * b[0][0] + B2 * b[0][1];
-    return pointFrom((C1 * B2 - C2 * B1) / D, (A1 * C2 - A2 * C1) / D);
-  }
-  return null;
-}
-
-// src/segment.ts
-function lineSegment(a, b) {
-  return [a, b];
-}
-var isLineSegment = (segment) => Array.isArray(segment) && segment.length === 2 && isPoint(segment[0]) && isPoint(segment[0]);
-var lineSegmentRotate = (l, angle, origin) => {
-  return lineSegment(
-    pointRotateRads(l[0], origin || pointCenter(l[0], l[1]), angle),
-    pointRotateRads(l[1], origin || pointCenter(l[0], l[1]), angle)
-  );
-};
-var segmentsIntersectAt = (a, b) => {
-  const a0 = vectorFromPoint(a[0]);
-  const a1 = vectorFromPoint(a[1]);
-  const b0 = vectorFromPoint(b[0]);
-  const b1 = vectorFromPoint(b[1]);
-  const r = vectorSubtract(a1, a0);
-  const s = vectorSubtract(b1, b0);
-  const denominator = vectorCross(r, s);
-  if (denominator === 0) {
-    return null;
-  }
-  const i = vectorSubtract(vectorFromPoint(b[0]), vectorFromPoint(a[0]));
-  const u = vectorCross(i, r) / denominator;
-  const t = vectorCross(i, s) / denominator;
-  if (u === 0) {
-    return null;
-  }
-  const p = vectorAdd(a0, vectorScale(r, t));
-  if (t >= 0 && t < 1 && u >= 0 && u < 1) {
-    return pointFromVector(p);
-  }
-  return null;
-};
-var pointOnLineSegment = (point, line2, threshold = PRECISION) => {
-  const distance = distanceToLineSegment(point, line2);
-  if (distance === 0) {
-    return true;
-  }
-  return distance < threshold;
-};
-var distanceToLineSegment = (point, line2) => {
-  const [x, y] = point;
-  const [[x1, y1], [x2, y2]] = line2;
-  const A = x - x1;
-  const B = y - y1;
-  const C = x2 - x1;
-  const D = y2 - y1;
-  const dot = A * C + B * D;
-  const len_sq = C * C + D * D;
-  let param = -1;
-  if (len_sq !== 0) {
-    param = dot / len_sq;
-  }
-  let xx;
-  let yy;
-  if (param < 0) {
-    xx = x1;
-    yy = y1;
-  } else if (param > 1) {
-    xx = x2;
-    yy = y2;
-  } else {
-    xx = x1 + param * C;
-    yy = y1 + param * D;
-  }
-  const dx = x - xx;
-  const dy = y - yy;
-  return Math.sqrt(dx * dx + dy * dy);
-};
-function lineSegmentIntersectionPoints(l, s, threshold) {
-  const candidate = linesIntersectAt(line(l[0], l[1]), line(s[0], s[1]));
-  if (!candidate || !pointOnLineSegment(candidate, s, threshold) || !pointOnLineSegment(candidate, l, threshold)) {
-    return null;
-  }
-  return candidate;
-}
-
 // src/polygon.ts
 function polygon(...points) {
   return polygonClose(points);
@@ -855,6 +865,7 @@ export {
   lineSegment,
   lineSegmentIntersectionPoints,
   lineSegmentRotate,
+  lineSegmentsDistance,
   linesIntersectAt,
   normalizeRadians,
   offsetPointsForQuadraticBezier,