svg-path-simplify 0.1.3 → 0.2.2

package/src/svgii/pathData_split.js

@@ -1,4 +1,4 @@
-import { pointAtT, svgArcToCenterParam, getBezierExtremeT  } from "./geometry";
+import { pointAtT, svgArcToCenterParam, getBezierExtremeT } from "./geometry";
 import { renderPoint, renderPath } from "./visualize";
 
 
@@ -86,7 +86,7 @@ export function getPathDataPlusChunks(pathDataPlus = [], debug = false) {
             //console.log('show chunks', pathDataChunks);
             pathDataChunks.forEach((ch, i) => {
                 let stroke = i % 2 === 0 ? 'green' : 'orange';
-                if(i===pathDataChunks.length-2){
+                if (i === pathDataChunks.length - 2) {
                     stroke = 'magenta'
                 }
 
@@ -156,22 +156,22 @@ export function splitSubpaths0(pathData) {
     //let com
     //console.log(pathData);
 
-    if(!l) return [];
+    if (!l) return [];
 
     //find split segments indices introduced by M commands 
-    for(let i=1; i<l; i++){
-        let type= pathData[i].type.toLowerCase(); 
-        if(type==='m') indices.push(i)
+    for (let i = 1; i < l; i++) {
+        let type = pathData[i].type.toLowerCase();
+        if (type === 'm') indices.push(i)
     }
     //console.log(indices);
 
     // only one sub path
     let len = indices.length;
-    if(len===1) return [pathData];
+    if (len === 1) return [pathData];
 
     let subPathArr = new Array(len);
 
-    for(let i=0; i<len; i++){
+    for (let i = 0; i < len; i++) {
         let idx = indices[i]
         subPathArr[i] = pathData.slice(idx, indices[i + 1]);
     }
@@ -195,7 +195,7 @@ export function splitCommand(points, t) {
     let cp1 = points[1];
     let cp2 = points[points.length - 2];
     let p = points[points.length - 1];
-    let m0,m1,m2,m3,m4, p2
+    let m0, m1, m2, m3, m4, p2
 
 
     // cubic
@@ -270,7 +270,8 @@ export function splitCommand(points, t) {
  * calculate command extremes
  */
 
-export function addExtemesToCommand(p0, values, tMin=0, tMax=1) {
+export function addExtemesToCommand(p0, values,
+    { tMin = 0, tMax = 1, addExtremes = true, addSemiExtremes = false } = {}) {
 
     let pathDataNew = [];
 
@@ -280,56 +281,52 @@ export function addExtemesToCommand(p0, values, tMin=0, tMax=1) {
     let p = { x: values[4], y: values[5] }
 
 
+    /*
     // get inner bbox
     let xMax = Math.max(p.x, p0.x)
     let xMin = Math.min(p.x, p0.x)
     let yMax = Math.max(p.y, p0.y)
     let yMin = Math.min(p.y, p0.y)
+    */
 
     let extremeCount = 0;
 
     //has  extreme - split
-    if (
-        cp1.x < xMin ||
-        cp1.x > xMax ||
-        cp1.y < yMin ||
-        cp1.y > yMax ||
-        cp2.x < xMin ||
-        cp2.x > xMax ||
-        cp2.y < yMin ||
-        cp2.y > yMax
-
-    ) {
-        let pts = type === 'C' ? [p0, cp1, cp2, p] : [p0, cp1, p];
-        let tArr = getBezierExtremeT(pts).sort();
-
-        // avoid t split too close to start or end
-        tArr = tArr.filter(t=>t>tMin && t<tMax)
-
-        if(tArr.length){
-            let commandsSplit = splitCommandAtTValues(p0, values, tArr)
-            //console.log('commandsSplit', commandsSplit);
-
-            pathDataNew.push(...commandsSplit)
-            extremeCount += commandsSplit.length;
-        }else{
-            //console.log('no extreme: ', tArr);
-            pathDataNew.push({ type: type, values: values })
-        }
+    tMin = 0;
+    tMax = 1;
 
-    }
-    // no extremes
-    else {
+    let pts = type === 'C' ? [p0, cp1, cp2, p] : [p0, cp1, p];
+    let tArrEx = addExtremes ? getBezierExtremeT(pts, { addExtremes, addSemiExtremes: false }) : [];
+    let tArrSemi = addSemiExtremes ? getBezierExtremeT(pts, { addExtremes, addSemiExtremes }) : [];
+    let tArr = Array.from(new Set([...tArrEx, ...tArrSemi])).sort();
+
+    // avoid t split too close to start or end
+    tArr = tArr.filter(t => t > tMin && t < tMax)
+
+    if (tArr.length) {
+        let commandsSplit = splitCommandAtTValues(p0, values, tArr)
+        //console.log('commandsSplit', commandsSplit);
+
+        pathDataNew.push(...commandsSplit)
+        extremeCount += commandsSplit.length;
+    } else {
+        //console.log('no extreme: ', tArr);
         pathDataNew.push({ type: type, values: values })
     }
 
+
     return { pathData: pathDataNew, count: extremeCount };
 
 }
 
 
 
-export function addExtremePoints(pathData, tMin=0, tMax=1) {
+export function addExtremePoints(pathData, {
+    tMin = 0,
+    tMax = 1,
+    addExtremes = true,
+    addSemiExtremes = false,
+} = {}) {
     let pathDataNew = [pathData[0]];
     // previous on path point
     let p0 = { x: pathData[0].values[0], y: pathData[0].values[1] };
@@ -350,12 +347,12 @@ export function addExtremePoints(pathData, tMin=0, tMax=1) {
 
         else {
             // add extremes
-            if (type === 'C' || type === 'Q') {
-                let comExt = addExtemesToCommand(p0, values, tMin, tMax).pathData;
-                let comExt2 = com;
+            if ((addExtremes || addSemiExtremes) && (type === 'C' || type === 'Q')) {
+                let comExt = addExtemesToCommand(p0, values, { tMin, tMax, addExtremes, addSemiExtremes }).pathData;
+                //let comExt2 = com;
                 //comExt2.valu
                 //console.log('comExt', comExt);
-                pathDataNew.push(...comExt )
+                pathDataNew.push(...comExt)
             }
         }
 

package/src/svgii/pathData_toPolygon.js

@@ -1,6 +1,10 @@
-import { getDistAv, pointAtT } from "./geometry";
+import { deg2rad, rad2Deg } from "../constants";
+import { simplifyRDP } from "../simplify_poly_RDP";
+import { simplifyRD } from "../simplify_poly_radial_distance";
+import { getDistAv, getTatAngles, pointAtT } from "./geometry";
 import { getPolyBBox } from "./geometry_bbox";
 import { addDimensionData, analyzePathData } from "./pathData_analyze";
+import { pathDataFromPoly } from "./pathData_fromPoly";
 import { addExtremePoints } from "./pathData_split";
 import { pathDataToD } from "./pathData_stringify";
 import { analyzePoly } from "./poly_analyze";
@@ -8,6 +12,128 @@ import { getCurvePathData } from "./poly_to_pathdata";
 import { renderPoint } from "./visualize";
 
 
+
+export function pathDataToPolygon(pathData, {
+    angles = [],
+    split = 0,
+    getPathData = true,
+    width=0,
+    height=0
+} = {}) {
+
+
+    let l = pathData.length;
+    let M = { x: pathData[0].values[0], y: pathData[0].values[1] }
+    let p0 = M
+
+    let minT = 1 / split * 0.5;
+    let maxT = 1 - minT
+
+
+    // collect polygon vertices
+    let pathDataPoly = []
+    let pts = [p0]
+
+    let ptsEnd = [0]
+    let ptCount = 1
+
+    // get max length
+    let minLength = 0;
+
+
+    split = !split ? 1 : split;
+
+    if(width && height){
+        minLength = (width+height) * 0.025 / split
+    }else{
+        //let areas = pathData.map(com => com.cptArea || 0).filter(Boolean).sort()
+        let lengths = pathData.map(com => com.dimA || 0).filter(Boolean).sort()
+        minLength = lengths[0]
+        //console.log('areas', areas, 'lengths', lengths);
+    }
+
+    //minLength*=0.5
+
+    for (let i = 1; i < l; i++) {
+        let com = pathData[i];
+        //let comPrev = pathData[i - 1];
+        let comNext = pathData[i + 1] || null;
+        let { type, values } = com;
+        let valuesL = values.length;
+        let p = valuesL ? { x: values[valuesL - 2], y: values[valuesL - 1] } : M;
+
+        if (type === 'C' || type === 'Q') {
+
+            let cp1 = { x: values[0], y: values[1] }
+            let cp2 = type === 'C' ? { x: values[2], y: values[3] } : cp1
+            let cpts = type === 'C' ? [p0, cp1, cp2, p] : [p0, cp1, p];
+
+
+            // calculate split according to length
+            let length = com.dimA
+            let rat = Math.floor(length / (minLength))
+            split = Math.ceil(length / minLength)
+
+            let tArr = []
+            for(let i=1; i<split; i++){
+                tArr.push(1/split*i)
+            }
+
+            tArr.forEach(t => {
+                let pt = pointAtT(cpts, t)
+                pts.push(pt)
+                ptCount++
+            })
+
+        }
+
+        if (type === 'M') {
+            M = p
+        }
+
+
+        p.area = com.cptArea|| 0
+        p.isExtreme = com.extreme|| false
+        p.isCorner = com.corner|| false 
+        p.isDirChange = com.directionChange || false ;
+
+        // segment end point
+        pts.push(p)
+
+        // exclude for polygon simplification
+        if (com.extreme || com.corner || (comNext && comNext.type !== type) || type === 'L') {
+            //console.log('is ext' , com);
+            ptsEnd.push(ptCount)
+            //renderPoint(markers, p, 'magenta', '2%', '0.5')
+        }
+
+        ptCount++
+
+        p0 = p
+
+    }
+
+    // reduce poly vertices
+    //pts = simplifyRD(pts, { quality: 0.5, exclude: ptsEnd, width, height })
+    pts = simplifyRD(pts, {quality:0.5, width, height})
+    //pts = simplifyRDP(pts, { quality: 0.8, width, height })
+    //console.log(ptsEnd);
+
+    /*
+    pts.forEach(pt => {
+        //renderPoint(markers, pt, 'cyan', '1%', '0.5')
+    })
+    //console.log(pts);
+    */
+
+
+    pathDataPoly = pathDataFromPoly(pts)
+    return getPathData ? pathDataPoly : pts;
+}
+
+
+
+// old function
 export function pathDataToPolySingle(pathData, addExtremes = true) {
 
 
@@ -63,7 +189,7 @@ export function pathDataToPolySingle(pathData, addExtremes = true) {
         dimA = getDistAv(p0, p);
 
 
-        if(extreme){
+        if (extreme) {
             //renderPoint(markers, p, 'cyan')
         }
 
@@ -102,7 +228,7 @@ export function pathDataToPolySingle(pathData, addExtremes = true) {
             let idx = p.extreme ? i : i - 1
             //console.log('remove', idx);
             remove.add(idx)
-        } 
+        }
     }
 
 
@@ -115,7 +241,7 @@ export function pathDataToPolySingle(pathData, addExtremes = true) {
         poly.splice(idx, 1)
     }
 
-    poly.splice(poly.length-1, poly.length)
+    poly.splice(poly.length - 1, poly.length)
 
 
     let polyAtt = poly.map(pt => `${pt.x} ${pt.y} `).join(' ')