svg-path-simplify 0.0.2 → 0.0.5

package/src/svgii/pathData_reorder.js

@@ -7,12 +7,47 @@ import { renderPoint, renderPath } from './visualize.js';
 import { getPolygonArea } from './geometry_area.js';
 
 
+export function pathDataToTopLeft(pathData) {
+
+    let len = pathData.length;
+    let isClosed = pathData[len - 1].type.toLowerCase() === 'z'
+
+    // we can't change starting point for non closed paths
+    if (!isClosed) {
+        return pathData
+    }
+
+    let newIndex = 0;
+
+    //get top most index
+    let indices = [];
+    for (let i = 0; i < len; i++) {
+        let com = pathData[i];
+        let { type, values } = com;
+        let valsLen = values.length
+        if (valsLen) {
+            let p = { type: type, x: values[valsLen-2], y: values[valsLen-1], index: 0}
+            p.index = i
+            indices.push(p)
+        }
+    }
+
+    // reorder  to top left most
+    //|| a.x - b.x
+    indices = indices.sort((a, b) => +a.y.toFixed(3) - +b.y.toFixed(3) );
+    newIndex = indices[0].index
+
+    return  newIndex ? shiftSvgStartingPoint(pathData, newIndex) : pathData;
+}
 
-export function pathDataToTopLeft(pathData, removeFinalLineto = false, reorder = true) {
+
+
+
+export function optimizeClosePath(pathData, removeFinalLineto = true, reorder = true) {
 
     let pathDataNew = [];
     let len = pathData.length;
-    let M = { x: pathData[0].values[0], y: pathData[0].values[1] }
+    let M = { x: +pathData[0].values[0].toFixed(8), y: +pathData[0].values[1].toFixed(8) }
     let isClosed = pathData[len - 1].type.toLowerCase() === 'z'
 
     let linetos = pathData.filter(com => com.type === 'L')
@@ -21,18 +56,18 @@ export function pathDataToTopLeft(pathData, removeFinalLineto = false, reorder =
     // check if order is ideal
     let penultimateCom = pathData[len - 2];
     let penultimateType = penultimateCom.type;
-    let penultimateComCoords = penultimateCom.values.slice(-2).map(val=>+val.toFixed(8))
+    let penultimateComCoords = penultimateCom.values.slice(-2).map(val => +val.toFixed(8))
 
     // last L command ends at M 
-    let isClosingCommand =  penultimateComCoords[0] === M.x && penultimateComCoords[1] === M.y
+    let isClosingCommand = penultimateComCoords[0] === M.x && penultimateComCoords[1] === M.y
 
     // if last segment is not closing or a lineto
-    let skipReorder = pathData[1].type!=='L' && (!isClosingCommand || penultimateType==='L' )
-    skipReorder=false
+    let skipReorder = pathData[1].type !== 'L' && (!isClosingCommand || penultimateType === 'L')
+    skipReorder = false
 
 
     // we can't change starting point for non closed paths
-    if (!isClosed ) {
+    if (!isClosed) {
         return pathData
     }
 
@@ -62,15 +97,15 @@ export function pathDataToTopLeft(pathData, removeFinalLineto = false, reorder =
         // find top most lineto
 
         if (linetos.length) {
-            let curveAfterLine = indices.filter(com => (com.type !== 'L' && com.type !== 'M') && com.prevCom && 
-            com.prevCom === 'L' || com.prevCom==='M' && penultimateType==='L' ).sort((a, b) => a.y - b.y || a.x-b.x)[0]
+            let curveAfterLine = indices.filter(com => (com.type !== 'L' && com.type !== 'M') && com.prevCom &&
+                com.prevCom === 'L' || com.prevCom === 'M' && penultimateType === 'L').sort((a, b) => a.y - b.y || a.x - b.x)[0]
 
             newIndex = curveAfterLine ? curveAfterLine.index - 1 : 0
 
         }
         // use top most command
         else {
-            indices = indices.sort((a, b) => +a.y.toFixed(1) - +b.y.toFixed(1) || a.x - b.x  );
+            indices = indices.sort((a, b) => +a.y.toFixed(1) - +b.y.toFixed(1) || a.x - b.x);
             newIndex = indices[0].index
         }
 
@@ -79,15 +114,19 @@ export function pathDataToTopLeft(pathData, removeFinalLineto = false, reorder =
     }
 
 
+    M = { x: +pathData[0].values[0].toFixed(8), y: +pathData[0].values[1].toFixed(7) }
+
     len = pathData.length
 
     // remove last lineto
     penultimateCom = pathData[len - 2];
     penultimateType = penultimateCom.type;
-    penultimateComCoords = penultimateCom.values.slice(-2)
+    penultimateComCoords = penultimateCom.values.slice(-2).map(val=>+val.toFixed(8))
 
     isClosingCommand = penultimateType === 'L' && penultimateComCoords[0] === M.x && penultimateComCoords[1] === M.y
 
+    //console.log('penultimateCom', isClosingCommand, penultimateCom.values, M);
+
     if (removeFinalLineto && isClosingCommand) {
         pathData.splice(len - 2, 1)
     }

package/src/svgii/pathData_stringify.js

@@ -8,25 +8,27 @@ export function pathDataToD(pathData, optimize = 0) {
 
     optimize = parseFloat(optimize)
 
+
+
+    let len = pathData.length;
     let beautify = optimize > 1;
     let minify = beautify || optimize ? false : true;
 
     // Convert first "M" to "m" if followed by "l" (when minified)
+    /*
     if (pathData[1].type === "l" && minify) {
         pathData[0].type = "m";
     }
+    */
 
     let d = '';
-    let suff = beautify ? `\n` : ' ';
+    let separator_command = beautify ? `\n` : (minify ? '' : ' ');
+    let separator_type =  !minify ? ' ' : '';
 
+    d = `${pathData[0].type}${separator_type}${pathData[0].values.join(" ")}${separator_command}`;
 
-    if (minify) {
-        d = `${pathData[0].type} ${pathData[0].values.join(" ")}`;
-    } else {
-        d = `${pathData[0].type} ${pathData[0].values.join(" ")}${suff}`;
-    }
 
-    for (let i = 1, len = pathData.length; i < len; i++) {
+    for (let i = 1; i < len; i++) {
         let com0 = pathData[i - 1];
         let com = pathData[i];
         let { type, values } = com;
@@ -44,8 +46,6 @@ export function pathDataToD(pathData, optimize = 0) {
         type = (com0.type === com.type && com.type.toLowerCase() !== 'm' && minify)
             ? " "
             : (
-                (com0.type === "m" && com.type === "l") ||
-                (com0.type === "M" && com.type === "l") ||
                 (com0.type === "M" && com.type === "L")
             ) && minify
                 ? " "
@@ -79,17 +79,16 @@ export function pathDataToD(pathData, optimize = 0) {
                 //console.log(isSmallFloat, prevWasFloat, valStr);
 
                 valsString += valStr
-                //.replace(/-0./g, '-.').replace(/ -./g, '-.')
                 prevWasFloat = isSmallFloat;
             }
 
             //console.log('minify', valsString);
-            d += `${type}${valsString}`;
+            d += `${type}${separator_type}${valsString}${separator_command}`;
 
         }
         // regular non-minified output
         else {
-            d += `${type} ${values.join(' ')}${suff}`;
+            d += `${type}${separator_type}${values.join(' ')}${separator_command}`;
         }
     }
 

package/src/svgii/rounding.js

@@ -21,6 +21,8 @@ export function detectAccuracy(pathData) {
 
     //console.log('detectAccuracy');
 
+    let dims = new Set();
+
     // add average distances
     for (let i = 0, len = pathData.length; i < len; i++) {
         let com = pathData[i];
@@ -34,8 +36,10 @@ export function detectAccuracy(pathData) {
         //let dimA = +getDistAv(p0, p).toFixed(8)
         //console.log('dimA', dimA, com.dimA, type);
 
+        if(dimA) dims.add(dimA);
+
         if(dimA && dimA<minDim) minDim = dimA;
-        //if(dimA && dimA>maxDim) maxDim = dimA;
+        if(dimA && dimA>maxDim) maxDim = dimA;
         
 
         if(type==='M'){
@@ -44,9 +48,15 @@ export function detectAccuracy(pathData) {
         p0 = p;
     }
 
-    //minDim = +minDim.toFixed(8)
-    let decimalsAuto = Math.floor(50 / minDim).toString().length
-    //console.log('!!!minDim', minDim, 'maxDim', maxDim, decimalsAuto);
+
+    let dim_min = Array.from(dims).sort()
+    let sliceIdx = Math.ceil(dim_min.length/8);
+    dim_min = dim_min.slice(0, sliceIdx );
+
+    let dimVal = dim_min.reduce((a,b)=>a+b, 0) / sliceIdx;
+
+    let threshold = 50
+    let decimalsAuto = dimVal > threshold ? 0 : Math.floor(threshold / dimVal).toString().length
 
     // clamp
     return Math.min(Math.max(0, decimalsAuto), 8)
@@ -55,8 +65,6 @@ export function detectAccuracy(pathData) {
 
 
 
-
-
 export function detectAccuracy_back(pathData) {
 
     // Reference first MoveTo command (M)

package/src/svgii/svg_cleanup.js

@@ -1,4 +1,8 @@
-export function cleanUpSVG(svgMarkup, removeHidden=true) {
+export function cleanUpSVG(svgMarkup, {
+  returnDom=false, 
+  removeHidden=true,
+  removeUnused=true,
+}={}) {
   svgMarkup = cleanSvgPrologue(svgMarkup);
   
   // replace namespaced refs 
@@ -29,6 +33,8 @@ export function cleanUpSVG(svgMarkup, removeHidden=true) {
     }
   })
 
+  if(returnDom) return svg
+
   let markup = stringifySVG(svg)
   console.log(markup);