svg-path-simplify 0.4.5 → 0.4.6

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