@excalidraw/math 0.18.0-4a5c9e9 → 0.18.0-4ce38fb

package/dist/dev/index.js

@@ -152,6 +152,9 @@ var pointScaleFromOrigin = (p, mid, multiplier) => pointTranslate(mid, vectorSca
 var isPointWithinBounds = (p, q, r) => {
   return q[0] <= Math.max(p[0], r[0]) && q[0] >= Math.min(p[0], r[0]) && q[1] <= Math.max(p[1], r[1]) && q[1] >= Math.min(p[1], r[1]);
 };
+var isValidPoint = (point) => {
+  return Array.isArray(point) && point.length === 2 && isFiniteNumber(point[0]) && isFiniteNumber(point[1]);
+};
 
 // src/constants.ts
 var LegendreGaussN24TValues = [
@@ -259,8 +262,15 @@ var initial_guesses = [
   [0.2, 0],
   [0.8, 0]
 ];
-var calculate = ([t0, s0], l, c) => {
-  const solution = solveWithAnalyticalJacobian(c, l, t0, s0, 0.01, 4);
+var calculate = ([t0, s0], l, c, tolerance = 0.01, iterLimit = 4) => {
+  const solution = solveWithAnalyticalJacobian(
+    c,
+    l,
+    t0,
+    s0,
+    tolerance,
+    iterLimit
+  );
   if (!solution) {
     return null;
   }
@@ -270,22 +280,40 @@ var calculate = ([t0, s0], l, c) => {
   }
   return bezierEquation(c, t);
 };
-function curveIntersectLineSegment(c, l) {
-  let solution = calculate(initial_guesses[0], l, c);
+function curveIntersectLineSegment(c, l, opts) {
+  let solution = calculate(
+    initial_guesses[0],
+    l,
+    c,
+    opts?.tolerance,
+    opts?.iterLimit
+  );
   if (solution) {
     return [solution];
   }
-  solution = calculate(initial_guesses[1], l, c);
+  solution = calculate(
+    initial_guesses[1],
+    l,
+    c,
+    opts?.tolerance,
+    opts?.iterLimit
+  );
   if (solution) {
     return [solution];
   }
-  solution = calculate(initial_guesses[2], l, c);
+  solution = calculate(
+    initial_guesses[2],
+    l,
+    c,
+    opts?.tolerance,
+    opts?.iterLimit
+  );
   if (solution) {
     return [solution];
   }
   return [];
 }
-function curveClosestPoint(c, p, tolerance = 1e-3) {
+function curveClosestParameter(c, p, tolerance = 1e-3) {
   const localMinimum = (min, max, f, e = tolerance) => {
     let m = min;
     let n = max;
@@ -302,7 +330,7 @@ function curveClosestPoint(c, p, tolerance = 1e-3) {
   };
   const maxSteps = 30;
   let closestStep = 0;
-  for (let min = Infinity, step = 0; step < maxSteps; step++) {
+  for (let min = Infinity, step = 0; step <= maxSteps; step++) {
     const d = pointDistance(p, bezierEquation(c, step / maxSteps));
     if (d < min) {
       min = d;
@@ -311,22 +339,18 @@ function curveClosestPoint(c, p, tolerance = 1e-3) {
   }
   const t0 = Math.max((closestStep - 1) / maxSteps, 0);
   const t1 = Math.min((closestStep + 1) / maxSteps, 1);
-  const solution = localMinimum(
+  const param = localMinimum(
     t0,
     t1,
     (t) => pointDistance(p, bezierEquation(c, t))
   );
-  if (!solution) {
-    return null;
-  }
-  return bezierEquation(c, solution);
+  return param ?? closestStep / maxSteps;
 }
-function curvePointDistance(c, p) {
-  const closest = curveClosestPoint(c, p);
-  if (!closest) {
-    return 0;
-  }
-  return pointDistance(p, closest);
+function curveClosestPoint(c, p, tolerance = 1e-3) {
+  return bezierEquation(c, curveClosestParameter(c, p, tolerance));
+}
+function curvePointDistance(c, p, tolerance = 1e-3) {
+  return pointDistance(p, curveClosestPoint(c, p, tolerance));
 }
 function isCurve(v) {
   return Array.isArray(v) && v.length === 4 && isPoint(v[0]) && isPoint(v[1]) && isPoint(v[2]) && isPoint(v[3]);
@@ -444,14 +468,13 @@ function curveLengthAtParameter(c, t) {
   }
   return z1 * sum;
 }
-function curvePointAtLength(c, percent) {
+function curvePointAtLength(c, percent, totalLength = curveLength(c)) {
   if (percent <= 0) {
     return bezierEquation(c, 0);
   }
   if (percent >= 1) {
     return bezierEquation(c, 1);
   }
-  const totalLength = curveLength(c);
   const targetLength = totalLength * percent;
   let tMin = 0;
   let tMax = 1;
@@ -500,6 +523,9 @@ var ellipseDistanceFromPoint = (p, ellipse2) => {
     vectorFromPoint(p),
     vectorScale(vectorFromPoint(center), -1)
   );
+  if (a === b) {
+    return Math.abs(Math.hypot(translatedPoint[0], translatedPoint[1]) - a);
+  }
   const px = Math.abs(translatedPoint[0]);
   const py = Math.abs(translatedPoint[1]);
   let tx = 0.707;
@@ -515,6 +541,9 @@ var ellipseDistanceFromPoint = (p, ellipse2) => {
     const qy = py - ey;
     const r = Math.hypot(ry, rx);
     const q = Math.hypot(qy, qx);
+    if (q === 0) {
+      break;
+    }
     tx = Math.min(1, Math.max(0, (qx * r / q + ex) / a));
     ty = Math.min(1, Math.max(0, (qy * r / q + ey) / b));
     const t = Math.hypot(ty, tx);
@@ -522,8 +551,8 @@ var ellipseDistanceFromPoint = (p, ellipse2) => {
     ty /= t;
   }
   const [minX, minY] = [
-    a * tx * Math.sign(translatedPoint[0]),
-    b * ty * Math.sign(translatedPoint[1])
+    a * tx * (translatedPoint[0] < 0 ? -1 : 1),
+    b * ty * (translatedPoint[1] < 0 ? -1 : 1)
   ];
   return pointDistance(pointFromVector(translatedPoint), pointFrom(minX, minY));
 };
@@ -610,93 +639,98 @@ function linesIntersectAt(a, b) {
   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[1]);
-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);
+// src/pca.ts
+function centroid(points) {
+  let cx = 0;
+  let cy = 0;
+  for (const [x, y] of points) {
+    cx += x;
+    cy += y;
   }
-  return null;
-};
-var pointOnLineSegment = (point, line2, threshold = PRECISION) => {
-  const distance = distanceToLineSegment(point, line2);
-  if (distance === 0) {
-    return true;
+  return pointFrom(cx / points.length, cy / points.length);
+}
+function principalAxes(points) {
+  if (points.length < 2) {
+    console.error("Degenerate point set: at least two points are required");
   }
-  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;
+  const c = centroid(points);
+  let m20 = 0;
+  let m02 = 0;
+  let m11 = 0;
+  for (const [x, y] of points) {
+    const dx = x - c[0];
+    const dy = y - c[1];
+    m20 += dx * dx;
+    m02 += dy * dy;
+    m11 += dx * dy;
   }
-  let xx;
-  let yy;
-  if (param < 0) {
-    xx = x1;
-    yy = y1;
-  } else if (param > 1) {
-    xx = x2;
-    yy = y2;
+  m20 /= points.length;
+  m02 /= points.length;
+  m11 /= points.length;
+  const trace = m20 + m02;
+  const diff = Math.hypot(m20 - m02, 2 * m11);
+  const majorVariance = (trace + diff) / 2;
+  const minorVariance = (trace - diff) / 2;
+  let major;
+  if (Math.abs(m11) > Number.EPSILON) {
+    major = vectorNormalize(vector(majorVariance - m02, m11));
   } else {
-    xx = x1 + param * C;
-    yy = y1 + param * D;
+    major = m20 >= m02 ? vector(1, 0) : vector(0, 1);
   }
-  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 {
+    centroid: c,
+    major,
+    minor: vectorNormal(major),
+    majorVariance,
+    minorVariance
+  };
+}
+function principalCoords(points, axes, scale = 1) {
+  const { centroid: c, major, minor } = axes;
+  return points.map(([x, y]) => {
+    const dx = x - c[0];
+    const dy = y - c[1];
+    return [
+      (dx * major[0] + dy * major[1]) * scale,
+      (dx * minor[0] + dy * minor[1]) * scale
+    ];
+  });
+}
+function orientPrincipalAxes(points, axes) {
+  const u = principalCoords(points, axes).map(([uu]) => uu);
+  if (skewness(u) <= 0) {
+    return axes;
   }
-  return candidate;
+  const major = vectorScale(axes.major, -1);
+  return { ...axes, major, minor: vectorNormal(major) };
 }
-function lineSegmentsDistance(s1, s2) {
-  if (lineSegmentIntersectionPoints(s1, s2)) {
-    return 0;
+function elongation(axes) {
+  return axes.majorVariance > 0 ? axes.minorVariance / axes.majorVariance : 1;
+}
+function standardizedMoment(values, order) {
+  const n = values.length;
+  let mean = 0;
+  for (const v of values) {
+    mean += v;
   }
-  return Math.min(
-    distanceToLineSegment(s1[0], s2),
-    distanceToLineSegment(s1[1], s2),
-    distanceToLineSegment(s2[0], s1),
-    distanceToLineSegment(s2[1], s1)
-  );
+  mean /= n;
+  let variance = 0;
+  let moment = 0;
+  for (const v of values) {
+    const d = v - mean;
+    variance += d * d;
+    moment += d ** order;
+  }
+  variance /= n;
+  moment /= n;
+  const sigma = Math.sqrt(variance);
+  return sigma > Number.EPSILON ? moment / sigma ** order : 0;
+}
+function skewness(values) {
+  return standardizedMoment(values, 3);
+}
+function kurtosis(values) {
+  return standardizedMoment(values, 4);
 }
 
 // src/polygon.ts
@@ -742,21 +776,84 @@ var polygonIncludesPointNonZero = (point, polygon2) => {
   }
   return windingNumber !== 0;
 };
-var pointOnPolygon = (p, poly, threshold = PRECISION) => {
-  let on = false;
-  for (let i = 0, l = poly.length - 1; i < l; i++) {
-    if (pointOnLineSegment(p, lineSegment(poly[i], poly[i + 1]), threshold)) {
-      on = true;
-      break;
-    }
-  }
-  return on;
-};
 function polygonClose(polygon2) {
   return polygonIsClosed(polygon2) ? polygon2 : [...polygon2, polygon2[0]];
 }
-function polygonIsClosed(polygon2) {
-  return pointsEqual(polygon2[0], polygon2[polygon2.length - 1]);
+function polygonIsClosed(polygon2, tolerance = PRECISION) {
+  return pointsEqual(polygon2[0], polygon2[polygon2.length - 1], tolerance);
+}
+function polygonSignedArea(polygon2, tolerance = PRECISION) {
+  const pts = polygonIsClosed(polygon2, tolerance) ? polygon2.slice(0, -1) : polygon2;
+  let sum = 0;
+  for (let i = 0, j = pts.length - 1; i < pts.length; j = i++) {
+    sum += pts[j][0] * pts[i][1] - pts[i][0] * pts[j][1];
+  }
+  return sum / 2;
+}
+function polygonArea(polygon2, tolerance = PRECISION) {
+  return Math.abs(polygonSignedArea(polygon2, tolerance));
+}
+function convexHull(points) {
+  if (points.length < 3) {
+    return [...points];
+  }
+  const sorted = [...points].sort(
+    (a, b) => a[0] === b[0] ? a[1] - b[1] : a[0] - b[0]
+  );
+  const cross = (o, a, b) => (a[0] - o[0]) * (b[1] - o[1]) - (a[1] - o[1]) * (b[0] - o[0]);
+  const half = (pts) => {
+    const chain = [];
+    for (const p of pts) {
+      while (chain.length >= 2 && cross(chain[chain.length - 2], chain[chain.length - 1], p) <= 0) {
+        chain.pop();
+      }
+      chain.push(p);
+    }
+    chain.pop();
+    return chain;
+  };
+  const hull = [...half(sorted), ...half([...sorted].reverse())];
+  return hull.length >= 3 ? hull : [...points];
+}
+function simplifyConvexPolygon(polygon2, angleThreshold) {
+  if (polygon2.length < 3) {
+    return [...polygon2];
+  }
+  const turnAt = (i) => {
+    const prev = polygon2[(i - 1 + polygon2.length) % polygon2.length];
+    const curr = polygon2[i];
+    const next = polygon2[(i + 1) % polygon2.length];
+    const inAngle = Math.atan2(curr[1] - prev[1], curr[0] - prev[0]);
+    const outAngle = Math.atan2(next[1] - curr[1], next[0] - curr[0]);
+    return Math.abs(normalizeTurn(outAngle - inAngle));
+  };
+  let start = 0;
+  for (let i = 1; i < polygon2.length; i++) {
+    if (turnAt(i) > turnAt(start)) {
+      start = i;
+    }
+  }
+  const simplified = [];
+  let accumulated = 0;
+  for (let k = 0; k < polygon2.length; k++) {
+    const i = (start + k) % polygon2.length;
+    accumulated += turnAt(i);
+    if (accumulated >= angleThreshold) {
+      simplified.push(polygon2[i]);
+      accumulated = 0;
+    }
+  }
+  return simplified.length >= 3 ? simplified : [...polygon2];
+}
+function normalizeTurn(angle) {
+  let a = angle;
+  while (a > Math.PI) {
+    a -= 2 * Math.PI;
+  }
+  while (a < -Math.PI) {
+    a += 2 * Math.PI;
+  }
+  return a;
 }
 
 // src/range.ts
@@ -788,6 +885,91 @@ var rangeIncludesValue = (value, [min, max]) => {
   return value >= min && value <= max;
 };
 
+// src/segment.ts
+function lineSegment(a, b) {
+  return [a, b];
+}
+var isLineSegment = (segment) => Array.isArray(segment) && segment.length === 2 && isPoint(segment[0]) && isPoint(segment[1]);
+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) => {
+  return pointDistance(
+    point,
+    lineSegmentPointAt(line2, lineSegmentClosestParameter(point, line2))
+  );
+};
+function lineSegmentPointAt(line2, t) {
+  const [[x1, y1], [x2, y2]] = line2;
+  return pointFrom(x1 + t * (x2 - x1), y1 + t * (y2 - y1));
+}
+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)
+  );
+}
+function lineSegmentClosestParameter(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 = 0;
+  if (len_sq !== 0) {
+    param = dot / len_sq;
+  }
+  return Math.max(0, Math.min(1, param));
+}
+
 // src/rectangle.ts
 function rectangle(topLeft, bottomRight) {
   return [topLeft, bottomRight];
@@ -824,10 +1006,13 @@ export {
   average,
   bezierEquation,
   cartesian2Polar,
+  centroid,
   clamp,
+  convexHull,
   curve,
   curveCatmullRomCubicApproxPoints,
   curveCatmullRomQuadraticApproxPoints,
+  curveClosestParameter,
   curveClosestPoint,
   curveIntersectLineSegment,
   curveLength,
@@ -844,6 +1029,7 @@ export {
   ellipseLineIntersectionPoints,
   ellipseSegmentInterceptPoints,
   ellipseTouchesPoint,
+  elongation,
   isCloseTo,
   isCurve,
   isFiniteNumber,
@@ -851,15 +1037,20 @@ export {
   isPoint,
   isPointWithinBounds,
   isRightAngleRads,
+  isValidPoint,
   isVector,
+  kurtosis,
   line,
   lineSegment,
+  lineSegmentClosestParameter,
   lineSegmentIntersectionPoints,
+  lineSegmentPointAt,
   lineSegmentRotate,
   lineSegmentsDistance,
   linesIntersectAt,
   normalizeRadians,
   offsetPointsForQuadraticBezier,
+  orientPrincipalAxes,
   pointCenter,
   pointDistance,
   pointDistanceSq,
@@ -868,16 +1059,20 @@ export {
   pointFromPair,
   pointFromVector,
   pointOnLineSegment,
-  pointOnPolygon,
   pointRotateDegs,
   pointRotateRads,
   pointScaleFromOrigin,
   pointTranslate,
   pointsEqual,
   polygon,
+  polygonArea,
   polygonFromPoints,
   polygonIncludesPoint,
   polygonIncludesPointNonZero,
+  polygonIsClosed,
+  polygonSignedArea,
+  principalAxes,
+  principalCoords,
   radiansBetweenAngles,
   radiansDifference,
   radiansToDegrees,
@@ -893,6 +1088,9 @@ export {
   round,
   roundToStep,
   segmentsIntersectAt,
+  simplifyConvexPolygon,
+  skewness,
+  standardizedMoment,
   triangleIncludesPoint,
   vector,
   vectorAdd,