svg-path-simplify 0.4.5 → 0.4.7

package/src/svgii/pathData_remove_collinear.js

@@ -18,66 +18,59 @@ export function pathDataRemoveColinear(pathData, {
     let isClosed = pathData[pathData.length - 1].type.toLowerCase() === 'z'
 
     for (let c = 1, l = pathData.length; c < l; c++) {
-        //let comPrev = pathData[c - 1];
         let com = pathData[c];
+        let { type, values } = com;
         let comN = pathData[c + 1] || pathData[l - 1];
-        //let p1 = comN.type.toLowerCase() === 'z' ? M : { x: comN.values[comN.values.length - 2], y: comN.values[comN.values.length - 1] }
+        let valuesN = comN.values;
         let p1 = comN.type.toLowerCase() === 'z' ? M : { x: comN.values[comN.values.length - 2], y: comN.values[comN.values.length - 1] }
 
 
-        let { type, values } = com;
         let valsL = values.slice(-2)
         p = type !== 'Z' ? { x: valsL[0], y: valsL[1] } : M;
 
+        let nextBezier = type!==comN.type && (comN.type==='C' || comN.type==='Q');
+
 
         let area = p1 ? getPolygonArea([p0, p, p1], true) : Infinity
         let distSquare = getSquareDistance(p0, p1)
         let distMax = distSquare ? distSquare / 333 * tolerance : 0
 
         let isFlat = area < distMax;
-        //let isFlat = false;
         let isFlatBez = false;
+        let cpts = [];
 
 
-        /*
-        // flatness by cross product 
-        let dx0 = Math.abs(p1.x - p0.x)
-        let dy0 = Math.abs(p1.y - p0.y)
-
-        let dx1 = Math.abs(p.x - p0.x)
-        let dy1 = Math.abs(p.y - p0.y)
-
-        let dx2 = Math.abs(p1.x - p.x)
-        let dy2 = Math.abs(p1.y - p.y)
+        //if (comN.type === 'C') isFlat = false;
+        //if (!flatBezierToLinetos && type === 'C') isFlat = false;
 
-        // zero length segments are flat
-        let isZeroLength = (!dy1 && !dx1) || (!dy2 && !dx2)
-        if (isZeroLength) isFlat = true;
+        /**
+         * type change
+         * check flatness
+         */
+        if (nextBezier) {
+            cpts = comN.type === 'C' ?
+                [{ x: valuesN[0], y: valuesN[1] }, { x: valuesN[2], y: valuesN[3] }] :
+                (comN.type === 'Q' ? [{ x: valuesN[0], y: valuesN[1] }] : []);
 
-        // check cross products for colinearity
-        if (!isFlat) {
+            //isFlatBez = commandIsFlat([p0, ...cpts, p], { tolerance });
 
-            let cross0 = Math.abs(dx0 * dy1 - dy0 * dx1);
-            //let cross1 = Math.abs(dx1 * dy2 - dy1 * dx2);
-            //let crossDiff = Math.abs(cross0-cross1)
-            //let cross = Math.max(cross0, cross1)
-            let thresh = (dx0 + dy0) * 0.1
+            isFlat = commandIsFlat([p0, ...cpts, p], { tolerance });
+            //if(isFlat) continue;
 
-            //!cross0 ||
-            if ( cross0 < thresh) {
-                //renderPoint(markers, p)
-                isFlat = true
+            /*
+            //console.log('isFlatBez', isFlatBez);
+            if(!isFlatBez){
+                pathDataN.push(com)
+                continue
             }
-        }
-        */
-
+            */
 
-        if (!flatBezierToLinetos && type === 'C') isFlat = false;
+        }
 
         // convert flat beziers to linetos
         if (flatBezierToLinetos && (type === 'C' || type === 'Q')) {
 
-            let cpts = type === 'C' ?
+            cpts = type === 'C' ?
                 [{ x: values[0], y: values[1] }, { x: values[2], y: values[3] }] :
                 (type === 'Q' ? [{ x: values[0], y: values[1] }] : []);
 
@@ -92,10 +85,13 @@ export function pathDataRemoveColinear(pathData, {
         }
 
 
-        // colinear – exclude arcs (as always =) as semicircles won't have an area
-        //&& comN.type==='L'
-        if (isFlat && c < l - 1 && comN.type !== 'A' && (type === 'L' || (flatBezierToLinetos && isFlatBez))) {
+        /**
+         * colinear = simplification success
+         * exclude arcs (as always =) 
+         * as semicircles won't have an area
+         */
 
+        if (isFlat && c < l - 1 && comN.type !== 'A' && (type === 'L' || (flatBezierToLinetos && isFlatBez))) {
             continue;
         }
 

package/src/svgii/pathData_simplify_refineExtremes.js

@@ -1,5 +1,5 @@
 import { findSplitT, getExtrapolatedCommand } from "../pathData_simplify_cubic";
-import { getCombinedByDominant } from "../pathData_simplify_cubic_extrapolate";
+import { getCombinedByDominant, getCombinedByDominant_back } from "../pathData_simplify_cubic_extrapolate";
 import { bezierhasExtreme, checkLineIntersection, getDistAv, getDistManhattan, getSquareDistance, interpolate } from "./geometry";
 import { getPathArea, getPolygonArea } from "./geometry_area";
 import { getPathDataBBox } from "./geometry_bbox";
@@ -58,9 +58,7 @@ export function refineAdjacentExtremes(pathData, {
                 if (comEx.length === 1) {
 
                     comEx = comEx[0]
-
                     pathData[i + 1] = null;
-
                     pathData[i + 2].values = [comEx.cp1.x, comEx.cp1.y, comEx.cp2.x, comEx.cp2.y, comEx.p.x, comEx.p.y]
                     pathData[i + 2].cp1 = comEx.cp1
                     pathData[i + 2].cp2 = comEx.cp2

package/src/svgii/pathData_stringify.js

@@ -4,7 +4,129 @@
 * d attribute string 
 */
 
-export function pathDataToD(pathData, mode = 0) {
+export function pathDataToD(pathData = [], mode = 0) {
+
+    mode = parseFloat(mode)
+    /*
+    0 = max minification
+    0.5 = safe
+    1 = verbose
+    2 = beautify
+    */
+
+    let len = pathData.length;
+    let d = ''
+
+    // group same types
+    let pathDataGrouped = mode >0.5 ? JSON.parse(JSON.stringify(pathData)) : [];
+    let typePrev = 'M'
+
+    if (mode < 1) {
+        pathDataGrouped = [pathData[0]];
+        //pathDataGrouped = [{type:pathData[0].type, values:[...pathData[0].values]}];
+        let idx = 0;
+
+        for (let i = 1; i < len; i++) {
+            let com = pathData[i];
+            let { type } = com;
+            // decouple from object
+            let values = [...com.values]
+
+            // new type
+            if (type !== typePrev) {
+                pathDataGrouped.push({type, values})
+                idx++
+            } else {
+                pathDataGrouped[idx].values.push(...values)
+            }
+
+            // update type
+            typePrev = type
+        }
+    }
+
+    // stringify grouped
+    len = pathDataGrouped.length;
+    let separator_type = mode < 1 ? '' : ' ';
+    let separator_command = mode < 1 ? '' : (mode === 1 ? ' ' : `\n`);
+
+    typePrev = 'M'
+
+    for (let i = 0; i < len; i++) {
+        let com = pathDataGrouped[i];
+        let { type, values } = com;
+
+        // we're always starting a path with absolute M!
+        let omitType = mode < 1 && ((typePrev === 'M' && type === 'L') || (typePrev === 'm' && type === 'l'))
+
+        // add type
+        if (!omitType) d += type + separator_type;
+
+        // add values
+        let wasSmallFloat = false;
+        let separatorVal = ' ';
+
+        for (let v = 0, vlen = values.length; vlen && v < vlen; v++) {
+            let val = values[v];
+            let valAbs = Math.abs(val);
+            let valStr = val.toString();
+            let isNegative = val < 0;
+            let sign = isNegative ? '-' : ''
+            let isSmallFloat = mode > 0.5 ? false : (val && valAbs < 1);
+            let idxSub = isSmallFloat ? (isNegative ? 2 : 1) : 0
+
+            // we don't need whitespace for first value
+            separatorVal = v === 0 || isNegative ? '' : ' '
+
+            if (mode < 1) {
+                // omit leading zero
+                if (isSmallFloat) valStr = sign + valStr.substring(idxSub)
+
+                // omit whitespace for subsequent small floats
+                separatorVal = (v === 0 && !omitType) || (wasSmallFloat && isSmallFloat) ?
+                    (!mode ? '' : (isNegative ? '' : ' '))
+                    : (isNegative ? '' : ' ');
+
+            }
+
+            // omit separator between large Arc sweep and final x in minify mode
+            if (!mode && (type === 'a' || type === 'A')) {
+                let pos = (v % 7)
+                if (pos > 3 && pos < 6) separatorVal = ''
+            }
+
+            d += `${separatorVal}${valStr}`
+            wasSmallFloat = isSmallFloat;
+
+        }
+
+        // add command separator
+        if (mode) d += separator_command;
+
+        // update previous type
+        typePrev = type
+
+    }
+
+    //console.log('d', d, mode);
+    //console.log('pathDataGrouped', pathDataGrouped);
+    //console.log(pathData);
+
+    return d;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+export function pathDataToD__(pathData, mode = 0) {
 
     mode = parseFloat(mode)
     /*
@@ -79,7 +201,7 @@ export function pathDataToD(pathData, mode = 0) {
             valsString = values.join(' ')
         }
 
-        if(i===len-1) separator_command=''
+        if (i === len - 1) separator_command = ''
         d += `${type}${separator_type}${valsString}${separator_command}`;
     }
 
@@ -87,10 +209,14 @@ export function pathDataToD(pathData, mode = 0) {
     if (mode < 1) {
         d = d
             .replace(/[A-Za-z]0(?=\.)/g, m => m[0])
-            .replace(/ 0\./g, " .") // Space before small decimals
-            .replace(/ -/g, "-")     // Remove space before negatives
-            .replace(/-0\./g, "-.")  // Remove leading zero from negative decimals
-            .replace(/Z/g, "z")    // Convert uppercase 'Z' to lowercase
+            //Space before small decimals
+            .replace(/ 0\./g, " .")
+            // Remove space before negatives
+            .replace(/ -/g, "-")
+            // Remove leading zero from negative decimals
+            .replace(/-0\./g, "-.")
+            // Convert uppercase 'Z' to lowercase
+            .replace(/Z/g, "z")
     }
 
     //console.log(`"${d}"`);

package/src/svgii/pathData_toPolygon.js

@@ -4,8 +4,8 @@ import { simplifyPolyRD } from "../simplify_poly_radial_distance";
 import { getDistAv, getDistManhattan, getSquareDistance, getTatAngles, interpolate, pointAtT } from "./geometry";
 import { getBezierArea, getPolygonArea } from "./geometry_area";
 import { getPolyBBox } from "./geometry_bbox";
-import { addDimensionData, analyzePathData } from "./pathData_analyze";
-import { arcToBezier } from "./pathData_convert";
+import { addDimensionData, analyzePathData, getPathDataVerbose } from "./pathData_analyze";
+import { arcToBezier, convertPathData, pathDataToVerbose } from "./pathData_convert";
 import { pathDataFromPoly } from "./pathData_fromPoly";
 import { addExtremePoints } from "./pathData_split";
 import { pathDataToD } from "./pathData_stringify";
@@ -23,15 +23,24 @@ import { renderPoint } from "./visualize";
  */
 export function pathDataToPolygonOpt(pathData, {
     precisionPoly = 1,
-    autoAccuracy=false,
-    polyFormat='points',
-    decimals=-1,
-    simplifyRD=1,
-simplifyRDP=1,
+    autoAccuracy = false,
+    polyFormat = 'object',
+    decimals = -1,
+    simplifyRD = 1,
+    simplifyRDP = 1,
 } = {}) {
 
     //console.log(pathData);
 
+    pathData = convertPathData(pathData, {toAbsolute:true, toLonghands:true,  arcToCubic:true});
+    pathData = addExtremePoints(pathData);
+
+    //let d2 = pathDataToD(pathData)
+    //console.log(d2);
+
+
+    pathData = getPathDataVerbose(pathData);
+
     let l = pathData.length;
     let M = { x: pathData[0].values[0], y: pathData[0].values[1] }
     let p0 = M
@@ -59,11 +68,10 @@ simplifyRDP=1,
         pts.push(p)
     }
 
-
     let pts2 = [pts[0]]
 
     // adjustments for very small or large paths
-    dims = dims.filter(Boolean).sort()
+    dims = dims.filter(Boolean).sort((a,b)=>a-b)
     let dimMax = dims[dims.length - 1]
 
     let scale = dimMax > 2 && dimMax < 25 ? 1 : (20 / dimMax);
@@ -104,42 +112,44 @@ simplifyRDP=1,
 
 
     // simplify polygon
-    if(simplifyRD>0){
-        pts2 = simplifyPolyRD(pts2, {quality:simplifyRD})
+    if (simplifyRD > 0) {
+        pts2 = simplifyPolyRD(pts2, { quality: simplifyRD })
     }
 
 
-    if(simplifyRDP>0){
-        pts2 = simplifyPolyRDP(pts2, {quality:simplifyRDP})
+    if (simplifyRDP > 0) {
+        pts2 = simplifyPolyRDP(pts2, { quality: simplifyRDP })
     }
 
 
 
-    pathDataPoly = pathDataFromPoly(pts2)
-    pathData = pathDataPoly
-    
-    if(autoAccuracy){
+
+    if (autoAccuracy) {
         decimals = detectAccuracyPoly(pts)
     }
 
-    let poly = decimals>-1 ? pts2.map(pt => { return { x: roundTo(pt.x, decimals), y: roundTo(pt.y, decimals) } }) : pts2.map(pt => { return { x: pt.x, y: pt.y } })
+    let poly = decimals > -1 ? pts2.map(pt => { return { x: roundTo(pt.x, decimals), y: roundTo(pt.y, decimals) } }) : pts2.map(pt => { return { x: pt.x, y: pt.y } })
 
-    if(polyFormat==='array'){
+    pathDataPoly = pathDataFromPoly(poly)
+    pathData = pathDataPoly
+
+
+
+    if (polyFormat === 'array') {
         poly = poly.map(pt => { return [pt.x, pt.y] })
     }
-    else if(polyFormat==='string'){
+    else if (polyFormat === 'string') {
         poly = poly.map(pt => { return [pt.x, pt.y].join(',') }).flat().join(' ')
     }
 
-    //console.log(pathData);
+    let d= pathDataToD(pathData)
 
-    return { pathData, poly }
+    return { pathData, poly, d }
 
 }
 
 
 
-
 /**
  * creates precise polygon 
  * from command end points