svg-path-simplify 0.1.3 → 0.2.2

package/src/simplify_poly_radial_distance.js

@@ -0,0 +1,100 @@
+
+/**
+ * radialDistance simplification
+ * sloppy but fast
+ */
+
+import { getDistManhattan, getSquareDistance, reducePoints } from "./svgii/geometry";
+import { getPolyBBox } from "./svgii/geometry_bbox";
+import { renderPoint } from "./svgii/visualize";
+
+export function simplifyRD(pts, {
+    quality = 0.9,
+    width = 0,
+    height = 0,
+    absolute = false,
+    // use square or manhattan distances
+    manhattan = false,
+    exclude = []
+} = {}) {
+
+    /**
+     * switch between absolute or 
+     * quality based relative thresholds
+     */
+
+    if (typeof quality === 'string') {
+        let value = parseFloat(quality);
+        absolute = true;
+        quality = value;
+    }
+
+    // nothing to do - exit
+    if (pts.length < 4 || (!absolute && quality) >= 1) return pts;
+
+
+    // convert quality to squaredistance tolerance
+    let tolerance = quality;
+
+    if (!absolute) {
+
+        // quality to tolerance
+        tolerance = 1 - quality;
+
+        /**
+         * approximate dimensions
+         * adjust tolerance for 
+         * very small polygons e.g geodata
+         */
+
+        if (!width && !height) {
+            let polyS = reducePoints(pts, 12);
+            ({ width, height } = getPolyBBox(polyS));
+        }
+
+        if (!manhattan) {
+            // average side lengths
+            let dimAvg = (width + height) / 2;
+            let scale = dimAvg / 25;
+            tolerance = (tolerance * (scale)) ** 2
+        } else {
+            // use manhattan
+            tolerance = (width + height) * 0.05 * (1 - quality)
+        }
+
+    }
+
+    let p0 = pts[0];
+    let pt;
+
+    // new simplified point array
+    let ptsSmp = [p0];
+    let l = pts.length
+    let lenExclude = exclude.length;
+    let dist = 0
+
+    for (let i = 1; i < l; i++) {
+        pt = pts[i];
+
+        // skip
+        dist = manhattan ? getDistManhattan(p0, pt) : getSquareDistance(p0, pt);
+
+        if ( dist < tolerance && (!lenExclude || !exclude.includes(i)) ) {
+            p0 = pt;
+            continue
+        }
+
+        ptsSmp.push(pt);
+        p0 = pt;
+
+    }
+
+    // add last point - if not coinciding with first point
+    if (p0.x !== pt.x && p0.y !== pt.y) {
+        ptsSmp.push(pt);
+    }
+
+    //console.log('ptsSmp', ptsSmp, l);
+    return ptsSmp;
+
+}

package/src/svg_getViewbox.js

@@ -7,7 +7,7 @@
 export function getViewBox(svg = null, decimals = -1) {
 
     const getUnit=(val)=>{
-        return val && isNaN(val) ? val.match(/[^\d]+/g)[0] : '';
+        return val && isNaN(val) ? val.match(/[^\d|.]+/g)[0] : '';
     }
 
     // browser default

package/src/svgii/geometry.js

@@ -3,6 +3,9 @@ import {abs, acos, asin, atan, atan2, ceil, cos, exp, floor,
     log, max, min, pow, random, round, sin, sqrt, tan, PI} from '/.constants.js';
     */
 
+import { rad2Deg } from "../constants";
+import { renderPoint } from "./visualize";
+
 export const {
     abs, acos, asin, atan, atan2, ceil, cos, exp, floor,
     log, max, min, pow, random, round, sin, sqrt, tan, PI
@@ -18,6 +21,47 @@ export function getAngle(p1, p2, normalize = false) {
 }
 
 
+export function getDeltaAngle2(centerPoint, startPoint, endPoint, largeArc = false) {
+
+    const normalizeAngle = (angle) => {
+        let normalized = angle % (2 * Math.PI);
+
+        if (normalized > Math.PI) {
+            normalized -= 2 * Math.PI;
+        } else if (normalized <= -Math.PI) {
+            normalized += 2 * Math.PI;
+        }
+        return normalized;
+    }
+
+    let startAngle = getAngle(centerPoint, startPoint, false)
+
+    let endAngle = getAngle(centerPoint, endPoint, false)
+
+
+    // Calculate raw delta angle (difference)
+    let deltaAngle = endAngle - startAngle;
+
+    // Normalize the delta angle to range (-π, π]
+    //deltaAngle = normalizeAngle(deltaAngle);
+
+    //if (largeArc) deltaAngle = Math.PI * 2 - Math.abs(deltaAngle);
+
+    let phi = 180 / Math.PI
+    let startAngleDeg = startAngle * phi
+    let endAngleDeg = endAngle * phi
+    let deltaAngleDeg = deltaAngle * phi
+
+    return {
+        startAngle, endAngle, deltaAngle, startAngleDeg,
+        endAngleDeg,
+        deltaAngleDeg
+    };
+
+}
+
+
+
 export function getDeltaAngle(centerPoint, startPoint, endPoint, largeArc = false) {
 
     const normalizeAngle = (angle) => {
@@ -47,7 +91,7 @@ export function getDeltaAngle(centerPoint, startPoint, endPoint, largeArc = fals
     // Normalize the delta angle to range (-π, π]
     deltaAngle = normalizeAngle(deltaAngle);
 
-    if (largeArc) deltaAngle = Math.PI*2 - Math.abs(deltaAngle);
+    if (largeArc) deltaAngle = Math.PI * 2 - Math.abs(deltaAngle);
 
     let phi = 180 / Math.PI
     let startAngleDeg = startAngle * phi
@@ -127,25 +171,7 @@ export function checkLineIntersection(p1 = null, p2 = null, p3 = null, p4 = null
 
 
 
-/**
- * get distance between 2 points
- * pythagorean theorem
- */
-export function getDistance(p1, p2) {
-    return sqrt(
-        (p2.x - p1.x) * (p2.x - p1.x) + (p2.y - p1.y) * (p2.y - p1.y)
-    );
-}
 
-export function getSquareDistance(p1, p2) {
-    return (p2.x - p1.x) ** 2 + (p2.y - p1.y) ** 2
-}
-
-export function lineLength(p1, p2) {
-    return sqrt(
-        (p2.x - p1.x) * (p2.x - p1.x) + (p2.y - p1.y) * (p2.y - p1.y)
-    );
-}
 
 
 /**
@@ -169,7 +195,7 @@ export function interpolate(p1, p2, t, getTangent = false) {
 }
 
 
-export function pointAtT(pts, t = 0.5, getTangent = false, getCpts = false) {
+export function pointAtT(pts, t = 0.5, getTangent = false, getCpts = false, returnArray = false) {
 
     const getPointAtBezierT = (pts, t, getTangent = false) => {
 
@@ -261,6 +287,15 @@ export function pointAtT(pts, t = 0.5, getTangent = false, getCpts = false) {
 
     }
 
+
+    // normalize if input was array not pt object
+    if (Array.isArray(pts[0])) {
+        pts = pts.map(pt => { return { x: pt[0], y: pt[1] } })
+        // also output array if not explicitely defined
+        returnArray = true
+    }
+
+
     let pt;
     if (pts.length > 2) {
         pt = getPointAtBezierT(pts, t, getTangent);
@@ -273,7 +308,7 @@ export function pointAtT(pts, t = 0.5, getTangent = false, getCpts = false) {
     // normalize negative angles
     if (getTangent && pt.angle < 0) pt.angle += PI * 2
 
-    return pt
+    return returnArray ? [pt.x, pt.y] : pt
 }
 
 
@@ -392,8 +427,8 @@ export function svgArcToCenterParam(x1, y1, rx, ry, xAxisRotation, largeArc, swe
     let phi = rx === ry ? 0 : (xAxisRotation * PI) / 180;
     let cx, cy
 
-    let s_phi = !phi ? 0 : sin(phi);
-    let c_phi = !phi ? 1 : cos(phi);
+    let s_phi = !phi ? 0 : Math.sin(phi);
+    let c_phi = !phi ? 1 : Math.cos(phi);
 
     let hd_x = (x1 - x2) / 2;
     let hd_y = (y1 - y2) / 2;
@@ -408,8 +443,8 @@ export function svgArcToCenterParam(x1, y1, rx, ry, xAxisRotation, largeArc, swe
     //   Step 3: Ensure radii are large enough
     let lambda = (x1_ * x1_) / (rx * rx) + (y1_ * y1_) / (ry * ry);
     if (lambda > 1) {
-        rx = rx * sqrt(lambda);
-        ry = ry * sqrt(lambda);
+        rx = rx * Math.sqrt(lambda);
+        ry = ry * Math.sqrt(lambda);
 
         // save real rx/ry
         arcData.rx = rx;
@@ -424,7 +459,7 @@ export function svgArcToCenterParam(x1, y1, rx, ry, xAxisRotation, largeArc, swe
         //console.log('error:', rx, ry, rxy1_, ryx1_);
         throw Error("start point can not be same as end point");
     }
-    let coe = sqrt(abs((rxry * rxry - sum_of_sq) / sum_of_sq));
+    let coe = Math.sqrt(Math.abs((rxry * rxry - sum_of_sq) / sum_of_sq));
     if (largeArc == sweep) {
         coe = -coe;
     }
@@ -596,33 +631,92 @@ export function getTangentAngle(rx, ry, parametricAngle) {
     return tangentAngle;
 }
 
-export function bezierhasExtreme(p0, cpts = [], angleThreshold = 0.05) {
-    let isCubic = cpts.length === 3 ? true : false;
-    let cp1 = cpts[0] || null
-    let cp2 = isCubic ? cpts[1] : null;
-    let p = isCubic ? cpts[2] : cpts[1];
-    let PIquarter = Math.PI * 0.5;
 
-    let extCp1 = false,
-        extCp2 = false;
+export function bezierhasExtreme(p0 = null, cpts = []) {
 
-    //console.log('ang', cp1);
-    let ang1 = cp1 ? getAngle(p, cp1, true) : null;
+    if (!p0) {
+        p0 = cpts[0]
+        cpts = cpts.slice(1, cpts.length)
+    }
 
-    extCp1 = Math.abs((ang1 % PIquarter)) < angleThreshold || Math.abs((ang1 % PIquarter) - PIquarter) < angleThreshold;
+    let l = cpts.length;
+    let p = cpts[l - 1];
+    let cp1 = cpts[0]
+    let cp2 = l === 3 ? cpts[1] : cp1
 
-    if (isCubic) {
-        let ang2 = cp2 ? getAngle(cp2, p, true) : 0;
-        extCp2 = Math.abs((ang2 % PIquarter)) <= angleThreshold ||
-            Math.abs((ang2 % PIquarter) - PIquarter) <= angleThreshold;
+    // get bounding box
+    /**
+     * if control points are within 
+     * bounding box of start and end point 
+     * we cant't have extremes
+     */
+    let top = Math.min(p0.y, p.y)
+    let left = Math.min(p0.x, p.x)
+    let right = Math.max(p0.x, p.x)
+    let bottom = Math.max(p0.y, p.y)
+
+    // within bbox - can't have extremes
+    if (
+        cp1.y >= top && cp1.y <= bottom &&
+        cp2.y >= top && cp2.y <= bottom &&
+        cp1.x >= left && cp1.x <= right &&
+        cp2.x >= left && cp2.x <= right
+    ) {
+        return false
     }
-    return (extCp1 || extCp2)
+
+    return true
+
 }
 
 
+export function getSemiExtremesT(p0, cp1, cp2, p, angleRad = Math.PI / 2) {
+    // Rotate all points by -angleRad
+    let cos = Math.cos(-angleRad);
+    let sin = Math.sin(-angleRad);
+
+    const rotatePoint = (point) => ({
+        x: point.x * cos - point.y * sin,
+        y: point.x * sin + point.y * cos
+    });
+
+    let p0Rot = rotatePoint(p0);
+    let cp1Rot = rotatePoint(cp1);
+    let cp2Rot = rotatePoint(cp2);
+    let pRot = rotatePoint(p);
+
+    // Now find x-extrema in rotated coordinate system
+    // These correspond to points where original tangent angle = angleRad
 
-export function getBezierExtremeT(pts) {
-    let tArr = pts.length === 4 ? cubicBezierExtremeT(pts[0], pts[1], pts[2], pts[3]) : quadraticBezierExtremeT(pts[0], pts[1], pts[2]);
+    let a = -3 * p0Rot.x + 9 * cp1Rot.x - 9 * cp2Rot.x + 3 * pRot.x;
+    let b = 6 * p0Rot.x - 12 * cp1Rot.x + 6 * cp2Rot.x;
+    let c = 3 * cp1Rot.x - 3 * p0Rot.x;
+
+    let extremes = [];
+
+    if (Math.abs(a) < 1e-12) {
+        if (Math.abs(b) > 1e-12) {
+            let t = -c / b;
+            if (t > 0 && t < 1) extremes.push(t);
+        }
+        return extremes;
+    }
+
+    let discriminant = b * b - 4 * a * c;
+    if (discriminant >= 0) {
+        let sqrtDisc = Math.sqrt(discriminant);
+        let t1 = (-b + sqrtDisc) / (2 * a);
+        let t2 = (-b - sqrtDisc) / (2 * a);
+
+        if (t1 > 0 && t1 < 1) extremes.push(t1);
+        if (t2 > 0 && t2 < 1) extremes.push(t2);
+    }
+
+    return extremes;
+}
+
+export function getBezierExtremeT(pts, { addExtremes = true, addSemiExtremes = false } = {}) {
+    let tArr = pts.length === 4 ? cubicBezierExtremeT(pts[0], pts[1], pts[2], pts[3], { addExtremes, addSemiExtremes }) : quadraticBezierExtremeT(pts[0], pts[1], pts[2], { addExtremes, addSemiExtremes });
     return tArr;
 }
 
@@ -737,10 +831,179 @@ export function getArcExtemes(p0, values) {
 
 
 
+export function getTatAngles(cpts = [], angles = []) {
+
+    let l = cpts.length;
+    let isCubic = l === 4;
+    //console.log(angles, isCubic);
+
+    if (!angles.length) angles = [0];
+
+    let anglesL = angles.length;
+    let tArr = []
+
+    for (let i = 0; i < anglesL; i++) {
+
+        let ang = angles[i];
+        let cptsN = ang ? [] : cpts.slice(0)
+
+        // rotate cpts
+        if (ang) {
+            for (let j = 0; j < l; j++) {
+                let pt = cpts[j]
+                cptsN.push(rotatePoint(pt, 0, 0, ang))
+            }
+        }
+
+        // get t arr
+        let tVals = isCubic ? getTatCubicExtreme(...cptsN) : getTatQuadraticExtreme(...cptsN)
+        tArr.push(...tVals)
+
+    }
+
+    // deduplicate and sort
+    tArr = [... new Set(tArr)].sort()
+
+    return tArr;
+
+}
+
+
+
+// t at cubic bezier extreme
+export function getTatCubicExtreme(p0, cp1, cp2, p) {
+
+    /**
+     * if control points are within 
+     * bounding box of start and end point 
+     * we cant't have extremes
+     */
+    if (!bezierhasExtreme(p0, [cp1, cp2, p])) {
+        //console.log('no extreme');
+        return []
+    }
+
+    let [x0, y0, x1, y1, x2, y2, x3, y3] = [p0.x, p0.y, cp1.x, cp1.y, cp2.x, cp2.y, p.x, p.y];
+    let tArr = [], a, b, c, t, t1, t2, b2ac, sqrt_b2ac;
+    let e = 1e-8
+
+    for (let i = 0; i < 2; ++i) {
+
+        if (i == 0) {
+            b = 6 * x0 - 12 * x1 + 6 * x2;
+            a = -3 * x0 + 9 * x1 - 9 * x2 + 3 * x3;
+            c = 3 * x1 - 3 * x0;
+        } else {
+            b = 6 * y0 - 12 * y1 + 6 * y2;
+            a = -3 * y0 + 9 * y1 - 9 * y2 + 3 * y3;
+            c = 3 * y1 - 3 * y0;
+        }
+        if (Math.abs(a) < e) {
+            if (Math.abs(b) < e) {
+                continue;
+            }
+            t = -c / b;
+            if (t > 0 && t < 1) {
+                tArr.push(t);
+            }
+            continue;
+        }
+        b2ac = b * b - 4 * c * a;
+        if (b2ac < 0) {
+            if (Math.abs(b2ac) < e) {
+                t = -b / (2 * a);
+                if (t > 0 && t < 1) {
+                    tArr.push(t);
+                }
+            }
+            continue;
+        }
+        sqrt_b2ac = Math.sqrt(b2ac);
+        t1 = (-b + sqrt_b2ac) / (2 * a);
+        if (t1 > 0 && t1 < 1) {
+            tArr.push(t1);
+        }
+        t2 = (-b - sqrt_b2ac) / (2 * a);
+        if (t2 > 0 && t2 < 1) {
+            tArr.push(t2);
+        }
+    }
+
+    let j = tArr.length;
+    while (j--) {
+        t = tArr[j];
+    }
+
+    return [...new Set(tArr)].sort();
+}
+
+
+
+
+//For quadratic bezier.
+export function getTatQuadraticExtreme(p0, cp1, p) {
+
+    /**
+     * if control points are within 
+     * bounding box of start and end point 
+     * we cant't have extremes
+     */
+    if (!bezierhasExtreme(p0, [cp1, p])) {
+        //console.log('no extreme');
+        return []
+    }
+
+    let a, b, c, t;
+    let [x0, y0, x1, y1, x2, y2] = [p0.x, p0.y, cp1.x, cp1.y, p.x, p.y];
+    let tArr = [];
+
+    for (let i = 0; i < 2; ++i) {
+        a = i == 0 ? x0 - 2 * x1 + x2 : y0 - 2 * y1 + y2;
+        b = i == 0 ? -2 * x0 + 2 * x1 : -2 * y0 + 2 * y1;
+        c = i == 0 ? x0 : y0;
+        if (Math.abs(a) > 1e-12) {
+            t = -b / (2 * a);
+            if (t > 0 && t < 1) {
+                tArr.push(t);
+            }
+        }
+    }
+
+    return [...new Set(tArr)].sort();
+}
+
+
+
 // cubic bezier.
-export function cubicBezierExtremeT(p0, cp1, cp2, p) {
+export function cubicBezierExtremeT(p0, cp1, cp2, p,
+    { addExtremes = true, addSemiExtremes = false } = {}) {
+
+
+    // rotate cpts for semi extremes
+    const rotatePoint = (pt) => {
+
+        const angleRad = Math.PI / 4
+        const cos = Math.cos(angleRad);
+        const sin = Math.sin(angleRad);
+
+        return {
+            x: pt.x * cos - pt.y * sin,
+            y: pt.x * sin + pt.y * cos
+        }
+    };
+
+
+    if (addSemiExtremes) {
+        p0 = rotatePoint(p0)
+        cp1 = rotatePoint(cp1)
+        cp2 = rotatePoint(cp2)
+        p = rotatePoint(p)
+    }
+
+
     let [x0, y0, x1, y1, x2, y2, x3, y3] = [p0.x, p0.y, cp1.x, cp1.y, cp2.x, cp2.y, p.x, p.y];
 
+
     /**
      * if control points are within 
      * bounding box of start and end point 
@@ -760,8 +1023,8 @@ export function cubicBezierExtremeT(p0, cp1, cp2, p) {
         return []
     }
 
-    let tArr = [],
-        a, b, c, t, t1, t2, b2ac, sqrt_b2ac;
+    let tArr = [], a, b, c, t, t1, t2, b2ac, sqrt_b2ac;
+
     for (let i = 0; i < 2; ++i) {
         if (i == 0) {
             b = 6 * x0 - 12 * x1 + 6 * x2;
@@ -772,8 +1035,8 @@ export function cubicBezierExtremeT(p0, cp1, cp2, p) {
             a = -3 * y0 + 9 * y1 - 9 * y2 + 3 * y3;
             c = 3 * y1 - 3 * y0;
         }
-        if (Math.abs(a) < 1e-12) {
-            if (Math.abs(b) < 1e-12) {
+        if (Math.abs(a) < 1e-8) {
+            if (Math.abs(b) < 1e-8) {
                 continue;
             }
             t = -c / b;
@@ -784,7 +1047,7 @@ export function cubicBezierExtremeT(p0, cp1, cp2, p) {
         }
         b2ac = b * b - 4 * c * a;
         if (b2ac < 0) {
-            if (Math.abs(b2ac) < 1e-12) {
+            if (Math.abs(b2ac) < 1e-8) {
                 t = -b / (2 * a);
                 if (0 < t && t < 1) {
                     tArr.push(t);
@@ -807,13 +1070,44 @@ export function cubicBezierExtremeT(p0, cp1, cp2, p) {
     while (j--) {
         t = tArr[j];
     }
+
+    //console.log('addSemiExtremes', addSemiExtremes, addExtremes, tArr);
+
     return tArr;
 }
 
+export function isMultipleOf45(angleRad, epsilon = 0.001) {
+    let rad90 = Math.PI / 2;
+    let rad45 = rad90 / 2;
+    let isRightAngle = Math.abs(angleRad / rad90 - Math.round(angleRad / rad90)) < epsilon
+    return !isRightAngle ? Math.abs(angleRad / rad45 - Math.round(angleRad / rad45)) < epsilon : false;
+}
 
 
 //For quadratic bezier.
-export function quadraticBezierExtremeT(p0, cp1, p) {
+export function quadraticBezierExtremeT(p0, cp1, p, { addExtremes = true, addSemiExtremes = false } = {}) {
+
+
+    // rotate cpts for semi extremes
+    const rotatePoint = (pt) => {
+        const angleRad = -Math.PI / 4
+        const cos = Math.cos(angleRad);
+        const sin = Math.sin(angleRad);
+
+        return {
+            x: pt.x * cos - pt.y * sin,
+            y: pt.x * sin + pt.y * cos
+        }
+    };
+
+
+    if (addSemiExtremes) {
+        p0 = rotatePoint(p0)
+        cp1 = rotatePoint(cp1)
+        p = rotatePoint(p)
+    }
+
+
     /**
      * if control points are within 
      * bounding box of start and end point 
@@ -930,24 +1224,56 @@ export function intersectLines(p1, p2, p3, p4) {
 
 
 /**
- * sloppy distance calculation
- * based on x/y differences
+ * get distance between 2 points
+ * pythagorean theorem
  */
-export function getDistAv(pt1, pt2) {
+export function getDistance(p1, p2, isArray = false) {
+    //if(Array.isArray(p1)) isArray = true;
+    //console.log(p1, p2);
+    let dx = isArray ? p2[0] - p1[0] : (p2.x - p1.x);
+    let dy = isArray ? p2[1] - p1[1] : (p2.y - p1.y);
+
+    //console.log('dx', dx, dy, p1, p2);
+    return sqrt(dx * dx + dy * dy);
+}
 
-    let diffX = Math.abs(pt2.x - pt1.x);
-    let diffY = Math.abs(pt2.y - pt1.y);
-    let diff = (diffX + diffY) / 2;
+// just an alias
+export function lineLength(p1, p2) {
+    return getDistance(p1, p2)
+}
 
-    /*
-    let diffX = pt2.x - pt1.x;
-    let diffY = pt2.y - pt1.y;
-    let diff = Math.abs(diffX + diffY) / 2;
-    */
 
-    return diff;
+export function getSquareDistance(p1, p2) {
+    let dx = (p2.x - p1.x);
+    let dy = (p2.y - p1.y);
+    return dx * dx + dy * dy
+}
+
+
+
+/**
+ * get Manhattan/Cab distance 
+ * based on x/y deltas
+ * sloppy but fast
+ */
+export function getDistManhattan(pt1, pt2) {
+    let dx = Math.abs(pt2.x - pt1.x);
+    let dy = Math.abs(pt2.y - pt1.y);
+    return dx + dy;
 }
 
+/**
+ * sloppy distance calculation
+ * based on "half Manhattan/Cab" distance
+ */
+
+export function getDistAv(pt1, pt2) {
+    let dx = Math.abs(pt2.x - pt1.x);
+    let dy = Math.abs(pt2.y - pt1.y);
+    return (dx + dy) * 0.5;
+}
+
+
 /**
  * get command dimensions 
  * for threshold value

package/src/svgii/geometry_area.js

@@ -253,7 +253,8 @@ export function getBezierArea(pts, absolute=false) {
 
 export function getPolygonArea(points, absolute=false) {
     let area = 0;
-    for (let i = 0, len = points.length; len && i < len; i++) {
+    let l = points.length;
+    for (let i = 0; l && i < l; i++) {
         let addX = points[i].x;
         let addY = points[i === points.length - 1 ? 0 : i + 1].y;
         let subX = points[i === points.length - 1 ? 0 : i + 1].x;