svg-path-simplify 0.2.7 → 0.3.4

package/src/simplify_poly_RDP.js

@@ -3,7 +3,105 @@ import { getPolyBBox } from "./svgii/geometry_bbox";
 import { renderPoint } from "./svgii/visualize";
 
 
-export function simplifyRDP(pts, {
+export function simplifyPolyRDP(pts, {quality = 0.9, width = 0, height = 0}={}) {
+
+    /**
+     * switch between absolute or 
+     * quality based relative thresholds
+     */
+    let isAbsolute = false;
+
+    if (typeof quality === 'string') {
+        isAbsolute = true;
+        quality = parseFloat(quality);
+    }
+
+    if (pts.length < 4 || (!isAbsolute && quality) >= 1) return pts;
+
+    // convert quality to squaredistance tolerance
+    let tolerance = quality;
+    //console.log('simplifyRDP', tolerance);
+
+    if (!isAbsolute) {
+        
+        tolerance = 1 - quality;
+
+        // adjust for higher qualities
+        if (quality > 0.5) tolerance /= 2;
+
+        /**
+         * approximate dimensions
+         * adjust tolerance for 
+         * very small polygons e.g geodata
+         */
+        if (!width && !height) {
+            let polyS = reducePoints(pts, 12);
+            ({ width, height } = getPolyBBox(polyS));
+        }
+
+        // average side lengths
+        let dimAvg = (width + height) / 2;
+        let scale = dimAvg / 100;
+        tolerance = (tolerance * (scale)) ** 2
+    }
+
+
+    // Square distance from point to segment
+    const segmentSquareDistance = (p, p1, p2) => {
+        let x = p1.x, y = p1.y;
+        let dx = p2.x - x, dy = p2.y - y;
+
+        if (dx !== 0 || dy !== 0) {
+            let t = ((p.x - x) * dx + (p.y - y) * dy) / (dx * dx + dy * dy);
+            if (t > 1) {
+                x = p2.x;
+                y = p2.y;
+            } else if (t > 0) {
+                x += dx * t;
+                y += dy * t;
+            }
+        }
+
+        return (p.x - x) ** 2 + (p.y - y) ** 2;
+    };
+
+
+    // start collecting ptsSmp polyline
+    let ptsSmp = [pts[0]];
+
+    // create processing stack
+    let stack = [];
+    stack.push([0, pts.length - 1]);
+
+    while (stack.length > 0) {
+        let [first, last] = stack.pop();
+        let maxDist = tolerance;
+        let index = -1;
+
+        // Find point with maximum distance
+        for (let i = first + 1; i < last; i++) {
+            let currentDist = segmentSquareDistance(pts[i], pts[first], pts[last]);
+            if (currentDist > maxDist) {
+                index = i;
+                maxDist = currentDist;
+            }
+        }
+
+        // If max distance > tolerance, split and process
+        if (maxDist > tolerance) {
+            stack.push([index, last]);
+            stack.push([first, index]);
+        } else {
+            ptsSmp.push(pts[last]);
+        }
+
+    }
+
+    return ptsSmp;
+}
+
+
+export function simplifyPolyRDP__(pts, {
     quality = 0.9,
     width = 0,
     height = 0,
@@ -28,6 +126,8 @@ export function simplifyRDP(pts, {
         quality = parseFloat(quality);
     }
 
+    if(absolute && quality===0) return pts;
+
     if (pts.length < 4 || (!absolute && quality) >= 1) return pts;
 
     // convert quality to squaredistance or manhattan tolerance

package/src/simplify_poly_radial_distance.js

@@ -8,7 +8,87 @@ import { getDistManhattan, getSquareDistance, reducePoints } from "./svgii/geome
 import { getPolyBBox } from "./svgii/geometry_bbox";
 import { renderPoint } from "./svgii/visualize";
 
-export function simplifyRD(pts, {
+
+
+/**
+ * radialDistance simplification
+ * sloppy but fast
+ */
+
+export function simplifyPolyRD(pts, {quality = 0.9, width = 0, height = 0}={}) {
+
+
+    /**
+     * switch between absolute or 
+     * quality based relative thresholds
+     */
+    let isAbsolute = false;
+
+    if (typeof quality === 'string') {
+        let value = parseFloat(quality);
+        isAbsolute = true;
+        quality = value;
+    }
+
+    // nothing to do - exit
+    if (pts.length < 4 || (!isAbsolute && quality) >= 1) return pts;
+
+    let p0 = pts[0];
+    let pt;
+    let ptsSmp = [p0];
+
+    // convert quality to squaredistance tolerance
+    let tolerance = quality;
+
+    if (!isAbsolute) {
+
+        // 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));
+        }
+        // average side lengths
+        let dimAvg = (width + height) / 2;
+        let scale = dimAvg / 25;
+        tolerance = (tolerance * (scale)) ** 2
+
+        if (quality > 0.5) tolerance /= 10
+
+    }
+
+    //console.log('simplifyRD', tolerance);
+
+
+    for (let i = 1, l = pts.length; i < l; i++) {
+        pt = pts[i];
+        let dist = getSquareDistance(p0, pt)
+
+        if (dist > tolerance) {
+            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);
+    }
+
+    return ptsSmp;
+
+}
+
+
+export function simplifyPolyRD__(pts, {
     quality = 0.9,
     width = 0,
     height = 0,
@@ -24,11 +104,14 @@ export function simplifyRD(pts, {
      */
 
     if (typeof quality === 'string') {
-        let value = parseFloat(quality);
+        let value = parseFloat(quality)**2;
         absolute = true;
         quality = value;
+        console.log(quality);
     }
 
+    if(absolute && quality===0) return pts;
+
     // nothing to do - exit
     if (pts.length < 4 || (!absolute && quality) >= 1) return pts;
 

package/src/svgii/geometry.js

@@ -1273,6 +1273,7 @@ export function intersectLines(p1, p2, p3, p4) {
  */
 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);

package/src/svgii/pathData_fromPoly.js

@@ -1,12 +1,27 @@
-export function pathDataFromPoly(pts, closed=true){
+export function pathDataFromPoly(pts, closed = true) {
 
-    let pathData = [
-        { type: 'M', values: [pts[0].x, pts[0].y] },
-        ...pts.slice(1).map(pt => { return { type: 'L', values: [pt.x, pt.y] } })
-    ];
+    let pathData = []
+    let subPath = []
 
-    if(closed) pathData.push({type:'Z', values:[]})
 
+    // complex polygon
+    if (Array.isArray(pts[0])) {
+        pts.forEach(sub => {            
+            subPath = [
+                { type: 'M', values: [sub[0].x, sub[0].y] },
+                ...sub.slice(1).map(pt => { return { type: 'L', values: [pt.x, pt.y] } })
+            ];
+            pathData.push(...subPath)
+        })
+    }else{
+        pathData = [
+            { type: 'M', values: [pts[0].x, pts[0].y] },
+            ...pts.slice(1).map(pt => { return { type: 'L', values: [pt.x, pt.y] } })
+        ];
+    }
+
+    if (closed) pathData.push({ type: 'Z', values: [] })
     return pathData
 
-}
+}
+