svg-path-simplify 0.4.5 → 0.4.7

package/src/poly-fit-curve-schneider.js

@@ -9,6 +9,7 @@
   */
 
 import { harmonizeCubicCpts, harmonizeCubicCptsThird } from "./pathData_simplify_harmonize_cpts";
+import { adjustTangentAngle, areaDeviationTooLarge } from "./poly-fit-curve-schneider_check_bulge";
 import { checkLineIntersection, getAngle, getDistance, getSquareDistance, pointAtT, reducePoints, rotatePoint } from "./svgii/geometry";
 import { getPolygonArea } from "./svgii/geometry_area";
 import { detectRegularPolygon, getPolyCentroid } from "./svgii/poly_analyze";
@@ -30,6 +31,8 @@ export function fitCurveSchneider(pts, {
     keepCorners = true
 } = {}) {
 
+    //console.log('fitCurveSchneider');
+
     if (pts.length === 1) {
         return [];
     }
@@ -47,112 +50,215 @@ export function fitCurveSchneider(pts, {
     //keepCorners = false
 
     let len = pts.length;
+    let cp1, cp2;
+
+
+    //adjust 1st and last angle
+    let p0 = { x: pts[0].x, y: pts[0].y }
+    let p1 = { x: pts[1].x, y: pts[1].y }
+    cp1 = p1
+
+    let p2 = pts[2] ? { x: pts[2].x, y: pts[2].y } : null
+
+    let pL = { x: pts[len - 1].x, y: pts[len - 1].y }
+    let pL1 = { x: pts[len - 2].x, y: pts[len - 2].y }
+    cp2 = pL1
+    let pL2 = pts[len - 3] ? { x: pts[len - 3].x, y: pts[len - 3].y } : null
+
+
+    // adjust start angles
+    if (p2) {
+        cp1 = adjustTangentAngle(cp1, p0, p1, p2)
+    }
+
+    if (pL2) {
+        cp2 = adjustTangentAngle(cp2, pL, pL1, pL2)
+    }
+
+
+    let leftTangent = createTangent(cp1, pts[0]);
+    let rightTangent = createTangent(cp2, pts[len - 1]);
+
+
+    /*
     let leftTangent = createTangent(pts[1], pts[0]);
     let rightTangent = createTangent(pts[len - 2], pts[len - 1]);
-    let beziers = fitCubic(pts, leftTangent, rightTangent, maxError, keepCorners);
+    */
+
+
+    //let beziers = fitCubic(pts, leftTangent, rightTangent, maxError, keepCorners);
+    let beziers = fitCubicIterative(pts, leftTangent, rightTangent, maxError, keepCorners);
+    //console.log('beziers', JSON.parse(JSON.stringify(beziers)));
+
 
     // create pathdata
     let pathData = bezierPtsToPathData(beziers)
-    let cp1, cp2;
 
     adjustCpts = false
+    // adjustCpts = true;
     //harmonize = false;
-
-    adjustCpts = true;
     //harmonize = true;
 
 
-    if (adjustCpts) {
 
-        //console.log('refine cpts');
+    //console.log('pathData schneider', pathData);
+    return pathData
+}
+
+
+/**
+ * Fit a Bezier curve to a (sub)set of digitized pts.
+ * Your code should not call this function directly. Use fitCurve instead.
+ * control-point-1, control-point-2, second-point] and pts are [x, y]
+ */
+
 
-        let len2 = pathData.length;
-        let com1 = pathData[0]
+function fitCubicIterative(pts = [], leftTangent = { x: 0, y: 0 }, rightTangent = { x: 0, y: 0 }, error = 1) {
 
-        // last cubic segment
-        let com2 = pathData[len2 - 1]
+    //error = 0.01
+    //console.log('error', error);
+    //console.log('fitCubicIterative');
 
-        //adjust 1st and last angle
-        let p0 = { x: pts[0].x, y: pts[0].y }
-        let p1 = { x: pts[1].x, y: pts[1].y }
-        let p2 = pts[2] ? { x: pts[2].x, y: pts[2].y } : null
+    let beziers = [];
 
-        if (p2) {
-            cp1 = { x: com1.values[0], y: com1.values[1] }
-            cp1 = adjustTangentAngle(cp1, p0, p1, p2)
-            com1.values[0] = cp1.x
-            com1.values[1] = cp1.y
-        }
+    // stack holds segments to process
+    let stack = [{
+        pts,
+        leftTangent,
+        rightTangent
+    }];
 
-        let pL = { x: pts[len - 1].x, y: pts[len - 1].y }
-        let pL1 = { x: pts[len - 2].x, y: pts[len - 2].y }
-        let pL2 = pts[len - 3] ? { x: pts[len - 3][0], y: pts[len - 3][1] } : null
+    while (stack.length > 0) {
 
-        if (pL2) {
-            cp2 = { x: com2.values[2], y: com2.values[3] }
-            cp2 = adjustTangentAngle(cp2, pL, pL1, pL2)
-            com2.values[2] = cp2.x
-            com2.values[3] = cp2.y
-        }
+        let current = stack.pop();
+
+        let pts = current.pts;
+        let leftTangent = current.leftTangent;
+        let rightTangent = current.rightTangent;
+
+        let MaxIterations = 20;
+        let bezCurve = [];
+
+        // === same logic as before ===
 
+        let u = chordLengthParameterize(pts);
+        let _generateAndReport = generateAndReport(pts, u, u, leftTangent, rightTangent);
+
+        bezCurve = _generateAndReport[0];
+        let maxError = _generateAndReport[1];
+        let splitPoint = _generateAndReport[2];
+
+        //  BULGE CHECK
         /*
-        // harmonize too tight tangents
-        let harmonize = true;
-         harmonize = false;
-        if (harmonize) {
-            pathData = harmonizeCubicCptsThird([{ type: 'M', values: [pts[0].x, pts[0].y] },
-            ...pathData])
-            pathData.shift()
+        let checkBulge = areaDeviationTooLarge(pts, bezCurve);
+        let { isBulged, bezierNew, ptsN } = checkBulge;
+        isBulged = false
+
+        if (isBulged) {
+            beziers.push(bezierNew);
+            // skip this segment entirely (acts like your "early exit")
+            continue;
         }
         */
 
+        //  ACCEPT
+        if (maxError === 0 || maxError < error) {
+            beziers.push(bezCurve);
+            continue;
+        }
+
+        //  ITERATIVE REFINEMENT
+        if (maxError < error * error) {
+
+            let uPrime = u;
+            let prevErr = maxError;
+            let prevSplit = splitPoint;
+
+            for (let i = 0; i < MaxIterations; i++) {
+
+                uPrime = reparameterize(bezCurve, pts, uPrime);
+
+                let _generateAndReport2 = generateAndReport(pts, u, uPrime, leftTangent, rightTangent);
+
+                bezCurve = _generateAndReport2[0];
+                maxError = _generateAndReport2[1];
+                splitPoint = _generateAndReport2[2];
+
+                if (maxError < error) {
+                    beziers.push(bezCurve);
+                    break;
+                }
+
+                else if (splitPoint === prevSplit) {
+                    let errChange = maxError / prevErr;
+                    if (errChange > .9999 && errChange < 1.0001) {
+                        break;
+                    }
+                }
+
+                prevErr = maxError;
+                prevSplit = splitPoint;
+            }
+
+            if (maxError < error) continue;
+        }
+
+        //  SPLIT (instead of recursion → push onto stack)
+
+        let centerVector = subtract(pts[splitPoint - 1], pts[splitPoint + 1]);
+
+        if (centerVector.x === 0 && centerVector.y === 0) {
+            centerVector = subtract(pts[splitPoint - 1], pts[splitPoint]);
+            centerVector = { x: -centerVector.y, y: centerVector.x };
+        }
+
+        let toCenterTangent = normalize(centerVector);
+        let fromCenterTangent = mulItems(toCenterTangent, -1);
+
+        //  push RIGHT first, so LEFT is processed first (stack = LIFO)
+        stack.push({
+            pts: pts.slice(splitPoint),
+            leftTangent: fromCenterTangent,
+            rightTangent: rightTangent
+        });
+
+        stack.push({
+            pts: pts.slice(0, splitPoint + 1),
+            leftTangent: leftTangent,
+            rightTangent: toCenterTangent
+        });
     }
 
-    //console.log('pathData schneider', pathData);
-    return pathData
+    //console.log(beziers);
+    return beziers;
 }
 
 
-/**
- * Fit a Bezier curve to a (sub)set of digitized pts.
- * Your code should not call this function directly. Use fitCurve instead.
- *control-point-1, control-point-2, second-point] and pts are [x, y]
- */
-function fitCubic(pts, leftTangent, rightTangent, error, keepCorners = false) {
 
+function fitCubic(pts = [], leftTangent = { x: 0, y: 0 }, rightTangent = { x: 0, y: 0 }, error = 1, keepCorners = false) {
 
     //Max times to try iterating (to find an acceptable curve)
     let MaxIterations = 20;
-    let bezCurve;
-
-    /*
-    //Use heuristic if region only has two pts in it
-    if (pts.length === 2) {
-        let dist = getDistance(pts[0], pts[1], false) * 0.333;
-        bezCurve = [pts[0], addArrays(pts[0], mulItems(leftTangent, dist)), addArrays(pts[1], mulItems(rightTangent, dist)), pts[1]];
-        return [bezCurve];
-    }
-    */
+    let bezCurve = [];
+    let beziers = [];
 
 
     //Parameterize pts, and attempt to fit curve
     let u = chordLengthParameterize(pts);
     let _generateAndReport = generateAndReport(pts, u, u, leftTangent, rightTangent);
+    //console.log(leftTangent, u, error);
 
     bezCurve = _generateAndReport[0];
-
     let maxError = _generateAndReport[1];
     let splitPoint = _generateAndReport[2];
 
 
-    // check if curve is bulged
-    if (keepCorners) {
-        let checkBulge = areaDeviationTooLarge(pts, bezCurve);
-        let { isBulged, bezierNew } = checkBulge;
-        if (isBulged) {
-            // return cubic corner segment
-            bezCurve = bezierNew
-        }
+    // check if curve is bulged - quit
+    let checkBulge = areaDeviationTooLarge(pts, bezCurve);
+    let { isBulged, bezierNew } = checkBulge;
+    if (isBulged) {
+        beziers.push(bezierNew)
+        return beziers
     }
 
 
@@ -197,7 +303,6 @@ function fitCubic(pts, leftTangent, rightTangent, error, keepCorners = false) {
     }
 
     //Fitting failed -- split at max error point and fit recursively
-    let beziers = [];
     let centerVector = subtract(pts[splitPoint - 1], pts[splitPoint + 1]);
 
     if (centerVector.x === 0 && centerVector.y === 0) {
@@ -211,9 +316,11 @@ function fitCubic(pts, leftTangent, rightTangent, error, keepCorners = false) {
     //To and from need to point in opposite directions:
     let fromCenterTangent = mulItems(toCenterTangent, -1);
 
+    /*
     if (pts.length === 3) {
         //splitPoint--
     }
+    */
 
     beziers.push(
         ...fitCubic(pts.slice(0, splitPoint + 1), leftTangent, toCenterTangent, error, keepCorners),
@@ -487,66 +594,6 @@ function find_t(param, t_distMap, B_parts) {
 }
 
 
-function areaDeviationTooLarge(pts, bezCurve) {
-
-    let split = 4;
-    let step = 1 / split;
-    let l = pts.length
-
-    // create polygon from curve candidate
-    let poly = [bezCurve[0]];
-    let pt;
-
-    for (let i = 1; i < split; i++) {
-        let t = step * i
-        pt = pointAtT(bezCurve, t)
-        poly.push(pt);
-    }
-
-    poly.push(bezCurve[bezCurve.length - 1]);
-
-    // Original area
-    let polyArea = getPolygonArea(pts, false)
-
-    // flat line
-    if (!polyArea && pts.length === 2) {
-        polyArea = getSquareDistance(pts[0], pts[1]) * 0.01
-    }
-
-    let curveArea = getPolygonArea(poly, false);
-    let rat = curveArea / polyArea;
-
-    let isBulged = rat > 1.1
-    //|| rat < 0.9
-    // isBulged = rat > 2
-    let bezierNew = bezCurve
-    if (isBulged) {
-        let ptMid = pts[Math.floor(l * 0.5)]
-        let p = pts[l - 1];
-        /*
-        let cp1 = pointAtT([pts[0], ptMid], 0.666);
-        let cp2 = pointAtT([p, ptMid], 0.666);
-        //let ptMid2 = pts[Math.floor(pts.length*0.666)]
-        bezierNew = [pts[0], cp1, cp2, p]
-        //bezierNew = [pts[0], ptMid, ptMid, p]
- 
-        //renderPoint(markers, cp1, 'cyan')
-        //renderPoint(markers, cp2, 'cyan')
-        //console.log('bezCurve', bezCurve,  pts);
- 
-        cp1 = pointAtT([bezCurve[0], bezCurve[3]], 0.333);
-        cp2 = pointAtT([bezCurve[0], bezCurve[3]], 0.666);
-        bezCurve = [bezCurve[0], cp1, cp2, bezCurve[3]]
-        */
-
-        //console.log('!!!bulged');
-
-        bezCurve = [pts[0], ptMid, ptMid, p]
-        bezierNew = bezCurve
-    }
-
-    return { isBulged, bezierNew };
-}
 
 
 /**
@@ -630,14 +677,6 @@ function bezierQprime(bez, u, second = false) {
 }
 
 
-function adjustTangentAngle(cp, p0, p1, p2) {
-    let ang1 = getAngle(p0, p1)
-    let ang2 = getAngle(p0, p2)
-    let angDiff = (ang2 - ang1)
-    cp = rotatePoint(cp, p0.x, p0.y, -angDiff)
-    return cp
-}
-
 
 
 // convert to pathdata

package/src/poly-fit-curve-schneider_check_bulge.js

@@ -0,0 +1,131 @@
+import { getAngle, getBezierExtremeT, pointAtT, rotatePoint } from "./svgii/geometry";
+import { getPolygonArea } from "./svgii/geometry_area";
+import { pathDataToD } from "./svgii/pathData_stringify";
+import { renderPath, renderPoint, renderPoly } from "./svgii/visualize";
+
+
+export function checkExtremesInCurve(pts = [], bezCurve) {
+
+    let split = 4;
+    let l = pts.length
+
+    // create polygon from curve candidate
+    let pt;
+    let ptsN = pts;
+    let bezierNew = bezCurve
+
+    /**
+     * check extremes
+     */
+    let [p0, cp1, cp2, p] = bezCurve;
+    let tEx = getBezierExtremeT([p0, cp1, cp2, p])
+    if (tEx.length) {
+        //console.log('bezCurve', 'isBulged', isBulged, bezCurve, 'tEx', tEx);
+
+        tEx = tEx.filter(t => t !== 0 && t !== 1)[0]
+        if (tEx) {
+
+            let pEx = pointAtT(bezCurve, tEx, false, true)
+            let { x, y } = pEx
+            //console.log('pEx', pEx, pts);
+
+            let seg1_p0 = p0;
+            let seg1_cpt1 = pEx.cpts[0];
+            let seg1_cpt2 = pEx.cpts[2];
+            let seg1_p = { x, y };
+
+
+            let seg2_p0 = p0;
+            let seg2_cpt1 = pEx.cpts[3];
+            let seg2_cpt2 = pEx.cpts[1];
+            let seg2_p = p;
+
+            let pathD = [
+                { type: 'M', values: [seg1_p0.x, seg1_p0.y] },
+                { type: 'C', values: [seg1_cpt1.x, seg1_cpt1.y, seg1_cpt2.x, seg1_cpt2.y, seg1_p.x, seg1_p.y] },
+                { type: 'C', values: [seg2_cpt1.x, seg2_cpt1.y, seg2_cpt2.x, seg2_cpt2.y, seg2_p.x, seg2_p.y] },
+            ];
+
+   
+
+            bezierNew = [seg1_p0, seg1_cpt1, seg1_cpt2, seg1_p];
+            //isBulged = true
+
+        }
+    }
+
+
+    return { isBulged, bezierNew, ptsN };
+}
+
+
+
+export function areaDeviationTooLarge(pts = [], bezCurve) {
+
+    let split = 4;
+    let step = 1 / split;
+    let l = pts.length
+
+    // create polygon from curve candidate
+    let poly = [bezCurve[0]];
+    let pt;
+    let ptsN = pts;
+
+    for (let i = 1; i < split; i++) {
+        let t = step * i
+        pt = pointAtT(bezCurve, t)
+        //renderPoint(markers, pt, 'red')
+        poly.push(pt);
+    }
+
+    poly.push(bezCurve[bezCurve.length - 1]);
+
+    // Original area
+    let polyArea = getPolygonArea(pts, true)
+
+    // flat line
+
+    if (!polyArea && pts.length === 2) {
+        polyArea = 0.0000001
+    }
+
+    //renderPoint(markers, pts[0], 'green')
+    //renderPoint(markers, pts[1], 'cyan')
+
+    let curveArea = getPolygonArea(poly, true);
+    //let rat = curveArea / polyArea;
+    let areaDiff = Math.abs(polyArea - curveArea)
+
+    let rat = areaDiff / polyArea;
+    //console.log('rat', rat, curveArea, polyArea);
+
+    let isBulged = rat > 1
+    let bezierNew = bezCurve
+
+
+
+    if (isBulged) {
+        //renderPoint(markers, pts[0], 'green')
+        renderPoint(markers, pts[1], 'magenta')
+        bezierNew = [pts[0], pts[0], pts[1], pts[1]]
+        //return { isBulged, bezierNew };
+    } 
+
+    return { isBulged, bezierNew, ptsN };
+}
+
+
+
+export function adjustTangentAngle(cp, p0, p1, p2) {
+    let ang1 = getAngle(p0, p1)
+    let ang2 = getAngle(p0, p2)
+    let angDiff = (ang2 - ang1)
+    //let ang3 = 
+    let f = 0.666
+    f = 1
+    //f=0
+    //f=0.75
+    //console.log(angDiff);
+    cp = rotatePoint(cp, p0.x, p0.y, -angDiff * f)
+    return cp
+}

package/src/poly-offset.js

@@ -0,0 +1,133 @@
+import { checkLineIntersection } from "./svgii/geometry";
+
+export function getParallelPoly(pts=[], strokeWidth = 1, sweep = 1, closed=false) {
+  let l = pts.length;
+
+  let polyTop_lines = [];
+  let polyBottom_lines = [];
+  let polyTop = [];
+  let polyBottom = [];
+
+  for (let i = 1; i < l; i++) {
+    let p1 = pts[i - 1];
+    let p2 = pts[i];
+    let parralels = getParallels(p1, p2, strokeWidth);
+    let { top, bottom } = parralels;
+    polyTop_lines.push(top);
+    polyBottom_lines.push(bottom);
+  }
+
+  // find line intersections
+  l = polyTop_lines.length;
+
+  // add 1st points
+  polyTop.push(polyTop_lines[0][0]);
+  polyBottom.push(polyBottom_lines[0][0]);
+
+  for (let i = 1; i < l; i++) {
+    let l1_t = polyTop_lines[i - 1];
+    let l2_t = polyTop_lines[i];
+    let ptI_t = checkLineIntersection(
+      l1_t[0],
+      l1_t[1],
+      l2_t[1],
+      l2_t[0],
+      false,
+      true
+    );
+    let ptN_t = ptI_t ? ptI_t : l1_t[1];
+
+    let l1_b = polyBottom_lines[i - 1];
+    let l2_b = polyBottom_lines[i];
+    let ptI_b = checkLineIntersection(
+      l1_b[0],
+      l1_b[1],
+      l2_b[1],
+      l2_b[0],
+      false,
+      true
+    );
+    let ptN_b = ptI_b ? ptI_b : l1_t[1];
+
+    polyTop.push(ptN_t);
+    polyBottom.push(ptN_b);
+  }
+
+  // add last pts
+  polyTop.push(polyTop_lines[l - 1][1]);
+  polyBottom.push(polyBottom_lines[l - 1][1]);
+  
+  if(closed){
+    let l=polyTop.length;
+    let ptI_1 =checkLineIntersection(polyTop[1],polyTop[0], polyTop[l-2],polyTop[l-1], false, true )
+    if(ptI_1){
+      //renderPoint(svg, ptI_1)
+      polyTop[0] = ptI_1
+      polyTop[l-1] = ptI_1
+    }
+    let ptI_2 =checkLineIntersection(polyBottom[1],polyBottom[0], polyBottom[l-2],polyBottom[l-1], false, true )
+    
+    if(ptI_2){
+      //renderPoint(svg, ptI_2, 'green')
+      polyBottom[0] = ptI_2
+      polyBottom[l-1] = ptI_2
+    }
+
+    
+    
+  }
+
+  return sweep
+    ? { polyTop: polyBottom, polyBottom: polyTop }
+    : { polyTop, polyBottom };
+}
+
+export function getParallels(p1, p2, strokeWidth = 1) {
+  let distance = strokeWidth * 0.5;
+  // Get direction vector
+  let dx = p2.x - p1.x;
+  let dy = p2.y - p1.y;
+
+  // Calculate normalized perpendicular vector (rotated 90°)
+  let length = Math.hypot(dx, dy);
+  let perpX = -dy / length; // Left/up perpendicular
+  let perpY = dx / length;
+
+  // Scale by distance once
+  let offsetX = perpX * distance;
+  let offsetY = perpY * distance;
+
+  // Return both parallels in one go
+
+  let bottom = [
+    { x: p1.x - offsetX, y: p1.y - offsetY },
+    { x: p2.x - offsetX, y: p2.y - offsetY }
+  ];
+
+  let top = [
+    { x: p1.x + offsetX, y: p1.y + offsetY },
+    { x: p2.x + offsetX, y: p2.y + offsetY }
+  ];
+
+  //renderPoint(svg, top[0])
+  //renderPoint(svg, bottom[0], 'blue')
+
+  return { top, bottom };
+}
+
+function getExtendedPoint(p1, p2, distance) {
+  // Get direction vector
+  let dx = p2.x - p1.x;
+  let dy = p2.y - p1.y;
+  let length = Math.hypot(dx, dy);
+
+  // Normalize direction
+  let ndx = dx / length;
+  let ndy = dy / length;
+
+  // Extend along the line direction
+  return {
+    x: p2.x + ndx * distance,
+    y: p2.y + ndy * distance
+  };
+}