modern-path2d 1.8.0 → 1.8.2

package/dist/index.mjs

@@ -485,6 +485,195 @@ function cubicBezier(t, p0, p1, p2, p3) {
   return cubicBezierP0(t, p0) + cubicBezierP1(t, p1) + cubicBezierP2(t, p2) + cubicBezierP3(t, p3);
 }
 
+function isLeft(ax, ay, bx, by, px, py) {
+  return (bx - ax) * (py - ay) - (px - ax) * (by - ay);
+}
+function windingNumber$1(px, py, vertices) {
+  const len = vertices.length;
+  let wn = 0;
+  for (let i = 0; i < len; i += 2) {
+    const ax = vertices[i];
+    const ay = vertices[i + 1];
+    const k = (i + 2) % len;
+    const bx = vertices[k];
+    const by = vertices[k + 1];
+    if (ay <= py) {
+      if (by > py && isLeft(ax, ay, bx, by, px, py) > 0) {
+        wn++;
+      }
+    } else {
+      if (by <= py && isLeft(ax, ay, bx, by, px, py) < 0) {
+        wn--;
+      }
+    }
+  }
+  return wn;
+}
+function crossingNumber(px, py, vertices) {
+  const len = vertices.length;
+  let cn = 0;
+  for (let i = 0; i < len; i += 2) {
+    const ax = vertices[i];
+    const ay = vertices[i + 1];
+    const k = (i + 2) % len;
+    const bx = vertices[k];
+    const by = vertices[k + 1];
+    if (ay <= py && by > py || ay > py && by <= py) {
+      const t = (py - ay) / (by - ay);
+      if (px < ax + t * (bx - ax)) {
+        cn++;
+      }
+    }
+  }
+  return cn;
+}
+function segmentDistance(px, py, ax, ay, bx, by) {
+  const dx = bx - ax;
+  const dy = by - ay;
+  const lenSq = dx * dx + dy * dy;
+  let t = lenSq === 0 ? 0 : ((px - ax) * dx + (py - ay) * dy) / lenSq;
+  if (t < 0) {
+    t = 0;
+  } else if (t > 1) {
+    t = 1;
+  }
+  const cx = ax + t * dx;
+  const cy = ay + t * dy;
+  return Math.hypot(px - cx, py - cy);
+}
+function pointInPolygon(point, vertices, fillRule = "nonzero") {
+  if (vertices.length < 6) {
+    return false;
+  }
+  if (fillRule === "evenodd") {
+    return (crossingNumber(point.x, point.y, vertices) & 1) === 1;
+  }
+  return windingNumber$1(point.x, point.y, vertices) !== 0;
+}
+function pointInPolygons(point, polygons, fillRule = "nonzero") {
+  const { x, y } = point;
+  if (fillRule === "evenodd") {
+    let cn = 0;
+    for (let i = 0, len = polygons.length; i < len; i++) {
+      const ring = polygons[i];
+      if (ring.length >= 6) {
+        cn += crossingNumber(x, y, ring);
+      }
+    }
+    return (cn & 1) === 1;
+  }
+  let wn = 0;
+  for (let i = 0, len = polygons.length; i < len; i++) {
+    const ring = polygons[i];
+    if (ring.length >= 6) {
+      wn += windingNumber$1(x, y, ring);
+    }
+  }
+  return wn !== 0;
+}
+function pointToSegmentDistance(point, a, b) {
+  return segmentDistance(point.x, point.y, a.x, a.y, b.x, b.y);
+}
+function pointToPolylineDistance(point, vertices, closed = false) {
+  const len = vertices.length;
+  if (len < 2) {
+    return Infinity;
+  }
+  const { x: px, y: py } = point;
+  if (len === 2) {
+    return Math.hypot(px - vertices[0], py - vertices[1]);
+  }
+  let min = Infinity;
+  for (let i = 0; i < len - 2; i += 2) {
+    const d = segmentDistance(px, py, vertices[i], vertices[i + 1], vertices[i + 2], vertices[i + 3]);
+    if (d < min) {
+      min = d;
+    }
+  }
+  if (closed && len >= 6) {
+    const d = segmentDistance(px, py, vertices[len - 2], vertices[len - 1], vertices[0], vertices[1]);
+    if (d < min) {
+      min = d;
+    }
+  }
+  return min;
+}
+
+function boundsOf(ring) {
+  if (ring.length < 6) {
+    return null;
+  }
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (let i = 0; i < ring.length; i += 2) {
+    const x = ring[i];
+    const y = ring[i + 1];
+    if (x < minX)
+      minX = x;
+    if (y < minY)
+      minY = y;
+    if (x > maxX)
+      maxX = x;
+    if (y > maxY)
+      maxY = y;
+  }
+  return { minX, minY, maxX, maxY };
+}
+function bboxInside(inner, outer) {
+  return inner.minX >= outer.minX && inner.maxX <= outer.maxX && inner.minY >= outer.minY && inner.maxY <= outer.maxY;
+}
+function ringInsideRing(inner, outer) {
+  const n = inner.length / 2;
+  const step = Math.max(1, Math.floor(n / 9));
+  let tested = 0;
+  let inside = 0;
+  for (let i = 0; i < n; i += step) {
+    tested++;
+    if (pointInPolygon({ x: inner[i * 2], y: inner[i * 2 + 1] }, outer, "evenodd")) {
+      inside++;
+    }
+  }
+  return tested > 0 && inside * 2 > tested;
+}
+function evenoddFillRule(paths) {
+  const len = paths.length;
+  const bboxes = paths.map(boundsOf);
+  const depth = Array.from({ length: len }).fill(0);
+  const containers = paths.map(() => []);
+  for (let i = 0; i < len; i++) {
+    const bi = bboxes[i];
+    if (!bi) {
+      continue;
+    }
+    for (let j = 0; j < len; j++) {
+      if (i === j) {
+        continue;
+      }
+      const bj = bboxes[j];
+      if (!bj || !bboxInside(bi, bj)) {
+        continue;
+      }
+      if (ringInsideRing(paths[i], paths[j])) {
+        depth[i]++;
+        containers[i].push(j);
+      }
+    }
+  }
+  return paths.map((_, i) => {
+    let parentIndex = -1;
+    let bestDepth = -1;
+    for (const j of containers[i]) {
+      if (depth[j] > bestDepth) {
+        bestDepth = depth[j];
+        parentIndex = j;
+      }
+    }
+    return { index: i, depth: depth[i], parentIndex };
+  });
+}
+
 function fillTriangulate(pointArray, options = {}) {
   let {
     vertices = [],
@@ -647,7 +836,7 @@ function getDirectedArea(vertices) {
 function cross(ax, ay, bx, by, cx, cy) {
   return (bx - ax) * (cy - ay) - (by - ay) * (cx - ax);
 }
-function windingNumber$1(px, py, polygon) {
+function windingNumber(px, py, polygon) {
   const polygonLen = polygon.length;
   let wn = 0;
   for (let i = 0, j = polygonLen - 2; i < polygonLen; j = i, i += 2) {
@@ -768,7 +957,7 @@ function nonzeroFillRule(paths) {
       const wnList = [];
       for (let p = 0, pLen = testPoints.length; p < pLen; p++) {
         const [x, y] = testPoints[p];
-        const winding = windingNumber$1(x, y, paths[j]);
+        const winding = windingNumber(x, y, paths[j]);
         wnMap[winding] = (wnMap[winding] ?? 0) + 1;
         wnList.push(winding);
       }
@@ -791,120 +980,6 @@ function nonzeroFillRule(paths) {
   return results;
 }
 
-function isLeft(ax, ay, bx, by, px, py) {
-  return (bx - ax) * (py - ay) - (px - ax) * (by - ay);
-}
-function windingNumber(px, py, vertices) {
-  const len = vertices.length;
-  let wn = 0;
-  for (let i = 0; i < len; i += 2) {
-    const ax = vertices[i];
-    const ay = vertices[i + 1];
-    const k = (i + 2) % len;
-    const bx = vertices[k];
-    const by = vertices[k + 1];
-    if (ay <= py) {
-      if (by > py && isLeft(ax, ay, bx, by, px, py) > 0) {
-        wn++;
-      }
-    } else {
-      if (by <= py && isLeft(ax, ay, bx, by, px, py) < 0) {
-        wn--;
-      }
-    }
-  }
-  return wn;
-}
-function crossingNumber(px, py, vertices) {
-  const len = vertices.length;
-  let cn = 0;
-  for (let i = 0; i < len; i += 2) {
-    const ax = vertices[i];
-    const ay = vertices[i + 1];
-    const k = (i + 2) % len;
-    const bx = vertices[k];
-    const by = vertices[k + 1];
-    if (ay <= py && by > py || ay > py && by <= py) {
-      const t = (py - ay) / (by - ay);
-      if (px < ax + t * (bx - ax)) {
-        cn++;
-      }
-    }
-  }
-  return cn;
-}
-function segmentDistance(px, py, ax, ay, bx, by) {
-  const dx = bx - ax;
-  const dy = by - ay;
-  const lenSq = dx * dx + dy * dy;
-  let t = lenSq === 0 ? 0 : ((px - ax) * dx + (py - ay) * dy) / lenSq;
-  if (t < 0) {
-    t = 0;
-  } else if (t > 1) {
-    t = 1;
-  }
-  const cx = ax + t * dx;
-  const cy = ay + t * dy;
-  return Math.hypot(px - cx, py - cy);
-}
-function pointInPolygon(point, vertices, fillRule = "nonzero") {
-  if (vertices.length < 6) {
-    return false;
-  }
-  if (fillRule === "evenodd") {
-    return (crossingNumber(point.x, point.y, vertices) & 1) === 1;
-  }
-  return windingNumber(point.x, point.y, vertices) !== 0;
-}
-function pointInPolygons(point, polygons, fillRule = "nonzero") {
-  const { x, y } = point;
-  if (fillRule === "evenodd") {
-    let cn = 0;
-    for (let i = 0, len = polygons.length; i < len; i++) {
-      const ring = polygons[i];
-      if (ring.length >= 6) {
-        cn += crossingNumber(x, y, ring);
-      }
-    }
-    return (cn & 1) === 1;
-  }
-  let wn = 0;
-  for (let i = 0, len = polygons.length; i < len; i++) {
-    const ring = polygons[i];
-    if (ring.length >= 6) {
-      wn += windingNumber(x, y, ring);
-    }
-  }
-  return wn !== 0;
-}
-function pointToSegmentDistance(point, a, b) {
-  return segmentDistance(point.x, point.y, a.x, a.y, b.x, b.y);
-}
-function pointToPolylineDistance(point, vertices, closed = false) {
-  const len = vertices.length;
-  if (len < 2) {
-    return Infinity;
-  }
-  const { x: px, y: py } = point;
-  if (len === 2) {
-    return Math.hypot(px - vertices[0], py - vertices[1]);
-  }
-  let min = Infinity;
-  for (let i = 0; i < len - 2; i += 2) {
-    const d = segmentDistance(px, py, vertices[i], vertices[i + 1], vertices[i + 2], vertices[i + 3]);
-    if (d < min) {
-      min = d;
-    }
-  }
-  if (closed && len >= 6) {
-    const d = segmentDistance(px, py, vertices[len - 2], vertices[len - 1], vertices[0], vertices[1]);
-    if (d < min) {
-      min = d;
-    }
-  }
-  return min;
-}
-
 function quadraticBezierP0(t, p) {
   const k = 1 - t;
   return k * k * p;
@@ -952,6 +1027,10 @@ function strokeTriangulate(points, options = {}) {
   if (points.length === 0) {
     return { vertices, indices };
   }
+  points = dedupeConsecutivePoints(points, eps);
+  if (points.length < 4) {
+    return { vertices, indices };
+  }
   const style = lineStyle;
   let alignment = style.alignment;
   if (lineStyle.alignment !== 0.5) {
@@ -1241,6 +1320,17 @@ function strokeTriangulate(points, options = {}) {
     indices
   };
 }
+function dedupeConsecutivePoints(points, eps) {
+  const out = [points[0], points[1]];
+  for (let i = 2; i < points.length; i += 2) {
+    const x = points[i];
+    const y = points[i + 1];
+    if (Math.abs(x - out[out.length - 2]) >= eps || Math.abs(y - out[out.length - 1]) >= eps) {
+      out.push(x, y);
+    }
+  }
+  return out;
+}
 function getOrientationOfPoints(points) {
   const m = points.length;
   if (m < 6) {
@@ -4935,14 +5025,30 @@ class Path2D extends CompositeCurve {
         });
       }
     } else {
-      this.curves.forEach((curve) => {
-        curve.fillTriangulate({
+      const paths = this.curves.map((curve) => curve.getFillVertices(_options));
+      const groups = evenoddFillRule(paths);
+      const groupsLen = groups.length;
+      for (let i = 0; i < groupsLen; i++) {
+        const pointArray = paths[i];
+        if ((groups[i].depth & 1) === 1 || !pointArray.length) {
+          continue;
+        }
+        const _pointArray = pointArray.slice();
+        const holes = [];
+        for (let j = 0; j < groupsLen; j++) {
+          if (groups[j].parentIndex === i && (groups[j].depth & 1) === 1) {
+            holes.push(_pointArray.length / 2);
+            _pointArray.push(...paths[j]);
+          }
+        }
+        fillTriangulate(_pointArray, {
           ...options,
           indices,
           vertices,
+          holes,
           style: { ...this.style }
         });
-      });
+      }
     }
     return { indices, vertices };
   }
@@ -5259,4 +5365,4 @@ function applyFFD(point, grid, width = grid.width, height = grid.height) {
   point.set(x, y);
 }
 
-export { ArcCurve, BoundingBox, CompositeCurve, CubicBezierCurve, Curve, CurvePath, EllipseCurve, EquilateralPolygonCurve, FFDControlGrid, LineCurve, PI, PI_2, Path2D, Path2DSet, PathMeasure, PolygonCurve, QuadraticBezierCurve, RectangleCurve, RoundRectangleCurve, SplineCurve, Transform2D, Vector2, applyFFD, catmullRom, cubicBezier, drawPoint, fillTriangulate, getAdaptiveCubicBezierCurvePoints, getAdaptiveQuadraticBezierCurvePoints, getDirectedArea, getIntersectionPoint, nonzeroFillRule, parseArcCommand, parseCssArg, parseCssArgs, parseCssFunctions, parsePathDataArgs, pointInPolygon, pointInPolygons, pointToPolylineDistance, pointToSegmentDistance, polygonBoolean, quadraticBezier, resolveLineStyle, setCanvasContext, strokeTriangulate, svgPathCommandsAddToPath2D, svgPathCommandsToData, svgPathDataToCommands, svgToDom, svgToPath2DSet, toKebabCase };
+export { ArcCurve, BoundingBox, CompositeCurve, CubicBezierCurve, Curve, CurvePath, EllipseCurve, EquilateralPolygonCurve, FFDControlGrid, LineCurve, PI, PI_2, Path2D, Path2DSet, PathMeasure, PolygonCurve, QuadraticBezierCurve, RectangleCurve, RoundRectangleCurve, SplineCurve, Transform2D, Vector2, applyFFD, catmullRom, cubicBezier, drawPoint, evenoddFillRule, fillTriangulate, getAdaptiveCubicBezierCurvePoints, getAdaptiveQuadraticBezierCurvePoints, getDirectedArea, getIntersectionPoint, nonzeroFillRule, parseArcCommand, parseCssArg, parseCssArgs, parseCssFunctions, parsePathDataArgs, pointInPolygon, pointInPolygons, pointToPolylineDistance, pointToSegmentDistance, polygonBoolean, quadraticBezier, resolveLineStyle, setCanvasContext, strokeTriangulate, svgPathCommandsAddToPath2D, svgPathCommandsToData, svgPathDataToCommands, svgToDom, svgToPath2DSet, toKebabCase };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "modern-path2d",
   "type": "module",
-  "version": "1.8.0",
+  "version": "1.8.2",
   "packageManager": "pnpm@9.15.1",
   "description": "A Path2D library, fully compatible with Web Path2D, with additional support for triangulate、animation、deformation etc.",
   "author": "wxm",