@excalidraw/math 0.18.0-2b0e4c9 → 0.18.0-39103bd

package/dist/dev/index.js

@@ -120,7 +120,12 @@ function pointsEqual(a, b, tolerance = PRECISION) {
   const abs = Math.abs;
   return abs(a[0] - b[0]) < tolerance && abs(a[1] - b[1]) < tolerance;
 }
-function pointRotateRads([x, y], [cx, cy], angle) {
+function pointRotateRads(point, center, angle) {
+  if (!angle) {
+    return point;
+  }
+  const [x, y] = point;
+  const [cx, cy] = center;
   return pointFrom(
     (x - cx) * Math.cos(angle) - (y - cy) * Math.sin(angle) + cx,
     (x - cx) * Math.sin(angle) + (y - cy) * Math.cos(angle) + cy
@@ -147,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 = [
@@ -254,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;
   }
@@ -265,16 +280,34 @@ 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];
   }
@@ -311,7 +344,7 @@ function curveClosestPoint(c, p, tolerance = 1e-3) {
     t1,
     (t) => pointDistance(p, bezierEquation(c, t))
   );
-  if (!solution) {
+  if (solution == null) {
     return null;
   }
   return bezierEquation(c, solution);
@@ -319,7 +352,7 @@ function curveClosestPoint(c, p, tolerance = 1e-3) {
 function curvePointDistance(c, p) {
   const closest = curveClosestPoint(c, p);
   if (!closest) {
-    return 0;
+    return Infinity;
   }
   return pointDistance(p, closest);
 }
@@ -605,11 +638,257 @@ function linesIntersectAt(a, b) {
   return null;
 }
 
+// src/pca.ts
+function centroid(points) {
+  let cx = 0;
+  let cy = 0;
+  for (const [x, y] of points) {
+    cx += x;
+    cy += y;
+  }
+  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");
+  }
+  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;
+  }
+  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 {
+    major = m20 >= m02 ? vector(1, 0) : vector(0, 1);
+  }
+  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;
+  }
+  const major = vectorScale(axes.major, -1);
+  return { ...axes, major, minor: vectorNormal(major) };
+}
+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;
+  }
+  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
+function polygon(...points) {
+  return polygonClose(points);
+}
+function polygonFromPoints(points) {
+  return polygonClose(points);
+}
+var polygonIncludesPoint = (point, polygon2) => {
+  const x = point[0];
+  const y = point[1];
+  let inside = false;
+  for (let i = 0, j = polygon2.length - 1; i < polygon2.length; j = i++) {
+    const xi = polygon2[i][0];
+    const yi = polygon2[i][1];
+    const xj = polygon2[j][0];
+    const yj = polygon2[j][1];
+    if ((yi > y && yj <= y || yi <= y && yj > y) && x < (xj - xi) * (y - yi) / (yj - yi) + xi) {
+      inside = !inside;
+    }
+  }
+  return inside;
+};
+var polygonIncludesPointNonZero = (point, polygon2) => {
+  const [x, y] = point;
+  let windingNumber = 0;
+  for (let i = 0; i < polygon2.length; i++) {
+    const j = (i + 1) % polygon2.length;
+    const [xi, yi] = polygon2[i];
+    const [xj, yj] = polygon2[j];
+    if (yi <= y) {
+      if (yj > y) {
+        if ((xj - xi) * (y - yi) - (x - xi) * (yj - yi) > 0) {
+          windingNumber++;
+        }
+      }
+    } else if (yj <= y) {
+      if ((xj - xi) * (y - yi) - (x - xi) * (yj - yi) < 0) {
+        windingNumber--;
+      }
+    }
+  }
+  return windingNumber !== 0;
+};
+function polygonClose(polygon2) {
+  return polygonIsClosed(polygon2) ? polygon2 : [...polygon2, polygon2[0]];
+}
+function polygonIsClosed(polygon2, tolerance = PRECISION) {
+  return pointsEqual(polygon2[0], polygon2[polygon2.length - 1], tolerance);
+}
+function polygonSignedArea(polygon2) {
+  const pts = polygonIsClosed(polygon2) ? 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) {
+  return Math.abs(polygonSignedArea(polygon2));
+}
+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
+import { toBrandedType } from "@excalidraw/common";
+function rangeInclusive(start, end) {
+  return toBrandedType([start, end]);
+}
+function rangeInclusiveFromPair(pair) {
+  return toBrandedType(pair);
+}
+var rangesOverlap = ([a0, a1], [b0, b1]) => {
+  if (a0 <= b0) {
+    return a1 >= b0;
+  }
+  if (a0 >= b0) {
+    return b1 >= a0;
+  }
+  return false;
+};
+var rangeIntersection = ([a0, a1], [b0, b1]) => {
+  const rangeStart = Math.max(a0, b0);
+  const rangeEnd = Math.min(a1, b1);
+  if (rangeStart <= rangeEnd) {
+    return toBrandedType([rangeStart, rangeEnd]);
+  }
+  return null;
+};
+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[0]);
+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),
@@ -694,95 +973,6 @@ function lineSegmentsDistance(s1, s2) {
   );
 }
 
-// src/polygon.ts
-function polygon(...points) {
-  return polygonClose(points);
-}
-function polygonFromPoints(points) {
-  return polygonClose(points);
-}
-var polygonIncludesPoint = (point, polygon2) => {
-  const x = point[0];
-  const y = point[1];
-  let inside = false;
-  for (let i = 0, j = polygon2.length - 1; i < polygon2.length; j = i++) {
-    const xi = polygon2[i][0];
-    const yi = polygon2[i][1];
-    const xj = polygon2[j][0];
-    const yj = polygon2[j][1];
-    if ((yi > y && yj <= y || yi <= y && yj > y) && x < (xj - xi) * (y - yi) / (yj - yi) + xi) {
-      inside = !inside;
-    }
-  }
-  return inside;
-};
-var polygonIncludesPointNonZero = (point, polygon2) => {
-  const [x, y] = point;
-  let windingNumber = 0;
-  for (let i = 0; i < polygon2.length; i++) {
-    const j = (i + 1) % polygon2.length;
-    const [xi, yi] = polygon2[i];
-    const [xj, yj] = polygon2[j];
-    if (yi <= y) {
-      if (yj > y) {
-        if ((xj - xi) * (y - yi) - (x - xi) * (yj - yi) > 0) {
-          windingNumber++;
-        }
-      }
-    } else if (yj <= y) {
-      if ((xj - xi) * (y - yi) - (x - xi) * (yj - yi) < 0) {
-        windingNumber--;
-      }
-    }
-  }
-  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]);
-}
-
-// src/range.ts
-import { toBrandedType } from "@excalidraw/common";
-function rangeInclusive(start, end) {
-  return toBrandedType([start, end]);
-}
-function rangeInclusiveFromPair(pair) {
-  return toBrandedType(pair);
-}
-var rangesOverlap = ([a0, a1], [b0, b1]) => {
-  if (a0 <= b0) {
-    return a1 >= b0;
-  }
-  if (a0 >= b0) {
-    return b1 >= a0;
-  }
-  return false;
-};
-var rangeIntersection = ([a0, a1], [b0, b1]) => {
-  const rangeStart = Math.max(a0, b0);
-  const rangeEnd = Math.min(a1, b1);
-  if (rangeStart <= rangeEnd) {
-    return toBrandedType([rangeStart, rangeEnd]);
-  }
-  return null;
-};
-var rangeIncludesValue = (value, [min, max]) => {
-  return value >= min && value <= max;
-};
-
 // src/rectangle.ts
 function rectangle(topLeft, bottomRight) {
   return [topLeft, bottomRight];
@@ -819,7 +1009,9 @@ export {
   average,
   bezierEquation,
   cartesian2Polar,
+  centroid,
   clamp,
+  convexHull,
   curve,
   curveCatmullRomCubicApproxPoints,
   curveCatmullRomQuadraticApproxPoints,
@@ -839,6 +1031,7 @@ export {
   ellipseLineIntersectionPoints,
   ellipseSegmentInterceptPoints,
   ellipseTouchesPoint,
+  elongation,
   isCloseTo,
   isCurve,
   isFiniteNumber,
@@ -846,7 +1039,9 @@ export {
   isPoint,
   isPointWithinBounds,
   isRightAngleRads,
+  isValidPoint,
   isVector,
+  kurtosis,
   line,
   lineSegment,
   lineSegmentIntersectionPoints,
@@ -855,6 +1050,7 @@ export {
   linesIntersectAt,
   normalizeRadians,
   offsetPointsForQuadraticBezier,
+  orientPrincipalAxes,
   pointCenter,
   pointDistance,
   pointDistanceSq,
@@ -863,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,
@@ -888,6 +1088,9 @@ export {
   round,
   roundToStep,
   segmentsIntersectAt,
+  simplifyConvexPolygon,
+  skewness,
+  standardizedMoment,
   triangleIncludesPoint,
   vector,
   vectorAdd,