svg-path-simplify 0.3.5 → 0.4.0

package/src/svgii/pathData_convert.js

@@ -12,40 +12,56 @@ import { renderPoint, renderPath } from "./visualize";
 
 import { checkLineIntersection, getAngle, getDeltaAngle, getDistance, getDistAv, getDistManhattan, getSquareDistance, interpolate, pointAtT, rotatePoint, toParametricAngle } from './geometry';
 import { getPathArea, getPolygonArea, getRelativeAreaDiff } from './geometry_area';
+import { parsePathDataString } from './pathData_parse';
 import { pathDataToD } from './pathData_stringify';
 import { roundPathData } from './rounding';
 import { renderPoint } from './visualize';
 
-export function revertCubicQuadratic(p0 = {}, cp1 = {}, cp2 = {}, p = {}, tolerance=1) {
 
-    // test if cubic can be simplified to quadratic
-    let cp1X = interpolate(p0, cp1, 1.5)
-    let cp2X = interpolate(p, cp2, 1.5)
+export function parsePathDataNormalized(d,
+    {
+        // necessary for most calculations
+        toAbsolute = true,
+        toLonghands = true,
 
-    let dist0 = getDistManhattan(p0, p)
-    let threshold = dist0 * 0.01 * tolerance;
-    let dist1 = getDistManhattan(cp1X, cp2X)
+        // not necessary unless you need cubics only
+        quadraticToCubic = false,
 
-    let cp1_Q = null;
-    let type = 'C'
-    let values = [cp1.x, cp1.y, cp2.x, cp2.y, p.x, p.y];
-    let comN = { type, values }
+        // mostly a fallback if arc calculations fail      
+        arcToCubic = false,
+        // arc to cubic precision - adds more segments for better precision     
+        arcAccuracy = 4,
+    } = {}
+) {
 
-    if (dist1 < threshold ) {
-        cp1_Q = checkLineIntersection(p0, cp1, p, cp2, false);
-        if (cp1_Q) {
-            //renderPoint(markers, cp1_Q )
-            comN.type = 'Q'
-            comN.values = [cp1_Q.x, cp1_Q.y, p.x, p.y];
-            comN.p0 = p0;
-            comN.cp1 = cp1_Q;
-            comN.cp2 = null;
-            comN.p = p
-        }
+    // is already array
+    let isArray = Array.isArray(d);
+
+    // normalize native pathData to regular array
+    let hasConstructor = isArray && typeof d[0] === 'object' && typeof d[0].constructor === 'function'
+    /*
+    if (hasConstructor) {
+        d = d.map(com => { return { type: com.type, values: com.values } })
+        console.log('hasConstructor', hasConstructor, (typeof d[0].constructor), d);
     }
+    */
 
-    return comN
+    let pathDataObj = isArray ? d : parsePathDataString(d);
+
+    let { hasRelatives = true, hasShorthands = true, hasQuadratics = true, hasArcs = true } = pathDataObj;
+    let pathData = hasConstructor ? pathDataObj : pathDataObj.pathData;
+
+    //console.log('???quadraticToCubic', quadraticToCubic);
 
+    // normalize
+    pathData = normalizePathData(pathData,
+        {
+            toAbsolute, toLonghands, quadraticToCubic, arcToCubic, arcAccuracy,
+            hasRelatives, hasShorthands, hasQuadratics, hasArcs
+        },
+    )
+
+    return pathData;
 }
 
 
@@ -63,11 +79,14 @@ export function convertPathData(pathData, {
     hasShorthands = true,
     hasQuadratics = true,
     hasArcs = true,
+    optimizeArcs = true,
     testTypes = false
 
 
 } = {}) {
 
+
+
     // pathdata properties - test= true adds a manual test 
     if (testTypes) {
         //console.log('test for conversions');
@@ -85,27 +104,178 @@ export function convertPathData(pathData, {
     toShorthands = toLonghands ? false : toShorthands
 
 
-    //console.log(toShorthands, toRelative, decimals);
-    if (hasQuadratics && quadraticToCubic) pathData = pathDataQuadraticToCubic(pathData);
-    if (hasArcs && arcToCubic) pathData = pathDataArcsToCubics(pathData);
+    if (toAbsolute) pathData = pathDataToAbsolute(pathData);
+    if (hasShorthands && toLonghands) pathData = pathDataToLonghands(pathData);
+
+
+    // minify semicircle radii
+    if (optimizeArcs) pathData = optimizeArcPathData(pathData);
+
 
     //if(decimals>-1 && decimals<2) pathData = roundPathData(pathData, decimals);
     if (toShorthands) pathData = pathDataToShorthands(pathData);
-    if (hasShorthands && toLonghands) pathData = pathDataToLonghands(pathData);
 
-    if (toAbsolute) pathData = pathDataToAbsolute(pathData);
+    if (hasArcs && arcToCubic) pathData = pathDataArcsToCubics(pathData)
+
+    //console.log(toShorthands, toRelative, decimals);
+    if (hasQuadratics && quadraticToCubic) pathData = pathDataQuadraticToCubic(pathData);
+
 
     // pre round - before relative conversion to minimize distortions
     if (decimals > -1 && toRelative) pathData = roundPathData(pathData, decimals);
+
+
     if (toRelative) pathData = pathDataToRelative(pathData);
     if (decimals > -1) pathData = roundPathData(pathData, decimals);
 
+    return pathData
+}
 
+/**
+ * 
+ * @param {*} pathData 
+ * @returns 
+ */
 
-    return pathData
+export function optimizeArcPathData(pathData = []) {
+    pathData.forEach((com, i) => {
+        let { type, values } = com;
+        if (type === 'A') {
+            let [rx, ry, largeArc, x, y] = [values[0], values[1], values[3], values[5], values[6]];
+            let comPrev = pathData[i - 1]
+            let [x0, y0] = [comPrev.values[comPrev.values.length - 2], comPrev.values[comPrev.values.length - 1]];
+            let M = { x: x0, y: y0 };
+            let p = { x, y };
+            //largeArc=true
+            //let pMid = {x: Math.abs(x-x0), y:Math.abs(y-y0)}
+
+            // rx and ry are large enough
+            if (rx >= 1 && (x === x0 || y === y0)) {
+                let diff = Math.abs(rx - ry) / rx;
+
+                // rx~==ry 
+                if (diff < 0.01) {
+
+                    // test radius against mid point
+                    let pMid = interpolate(M, p, 0.5)                    
+                    let distM = getDistance(pMid, M)
+                    let rDiff = Math.abs(distM - rx) / rx
+
+                    // half distance between mid and start point should be ~ equal
+                    if(rDiff<0.01){
+                        pathData[i].values[0] = 1;
+                        pathData[i].values[1] = 1;
+                        pathData[i].values[2] = 0;
+                    }
+                }
+            }
+        }
+    })
+    return pathData;
 }
 
 
+
+/**
+ * parse normalized
+ */
+
+export function normalizePathData(pathData = [],
+    {
+        toAbsolute = true,
+        toLonghands = true,
+        quadraticToCubic = false,
+        arcToCubic = false,
+        arcAccuracy = 2,
+
+        // assume we need full normalization
+        hasRelatives = true, hasShorthands = true, hasQuadratics = true, hasArcs = true, testTypes = false
+
+    } = {}
+) {
+
+
+    return convertPathData(pathData, { toAbsolute, toLonghands, quadraticToCubic, arcToCubic, arcAccuracy, hasRelatives, hasShorthands, hasQuadratics, hasArcs, testTypes, decimals: -1 })
+}
+
+/*
+export function normalizePathData(pathData = [],
+    {
+        toAbsolute = true,
+        toLonghands = true,
+        quadraticToCubic = false,
+        arcToCubic = false,
+        arcAccuracy = 2,
+
+        // assume we need full normalization
+        hasRelatives = true, hasShorthands = true, hasQuadratics = true, hasArcs = true, testTypes = false
+
+    } = {}
+) {
+
+    // pathdata properties - test= true adds a manual test 
+    if (testTypes) {
+        //console.log('test for conversions');
+        let commands = Array.from(new Set(pathData.map(com => com.type))).join('');
+        hasRelatives = /[lcqamts]/gi.test(commands);
+        hasQuadratics = /[qt]/gi.test(commands);
+        hasArcs = /[a]/gi.test(commands);
+        hasShorthands = /[vhst]/gi.test(commands);
+        isPoly = /[mlz]/gi.test(commands);
+    }
+
+    if ((hasQuadratics && quadraticToCubic) || (hasArcs && arcToCubic)) {
+        toLonghands = true
+        toAbsolute = true
+    }
+
+    if (hasRelatives && toAbsolute) pathData = pathDataToAbsoluteOrRelative(pathData, false);
+    if (hasShorthands && toLonghands) pathData = pathDataToLonghands(pathData, -1, false);
+    if (hasArcs && arcToCubic) pathData = pathDataArcsToCubics(pathData, arcAccuracy);
+    if (hasQuadratics && quadraticToCubic) pathData = pathDataQuadraticToCubic(pathData);
+
+    return pathData;
+
+}
+*/
+
+
+
+
+export function revertCubicQuadratic(p0 = {}, cp1 = {}, cp2 = {}, p = {}, tolerance = 1) {
+
+    // test if cubic can be simplified to quadratic
+    let cp1X = interpolate(p0, cp1, 1.5)
+    let cp2X = interpolate(p, cp2, 1.5)
+
+    let dist0 = getDistManhattan(p0, p)
+    let threshold = dist0 * 0.01 * tolerance;
+    let dist1 = getDistManhattan(cp1X, cp2X)
+
+    let cp1_Q = null;
+    let type = 'C'
+    let values = [cp1.x, cp1.y, cp2.x, cp2.y, p.x, p.y];
+    let comN = { type, values }
+
+    if (dist1 < threshold) {
+        cp1_Q = checkLineIntersection(p0, cp1, p, cp2, false, true);
+        if (cp1_Q) {
+            //renderPoint(markers, cp1_Q )
+            comN.type = 'Q'
+            comN.values = [cp1_Q.x, cp1_Q.y, p.x, p.y];
+            comN.p0 = p0;
+            comN.cp1 = cp1_Q;
+            comN.cp2 = null;
+            comN.p = p
+        }
+    }
+
+    return comN
+
+}
+
+
+
 /**
  * convert cubic circle approximations
  * to more compact arcs
@@ -218,7 +388,7 @@ export function pathDataToAbsoluteOrRelative(pathData, toRelative = false, decim
         let { type, values } = com;
         let vLen = values.length;
         let typeRel = type.toLowerCase();
-        let typeAbs =type.toUpperCase();
+        let typeAbs = type.toUpperCase();
         let typeNew = toRelative ? typeRel : typeAbs;
 
         if (type !== typeNew) {
@@ -463,7 +633,7 @@ export function pathDataToShorthands(pathData, decimals = -1, test = false) {
             let dy1 = (p0.y - cpPrev.y)
 
             //adjust maxDist
-            maxDist = getDistManhattan(cpPrev, cpFirst) * 0.025
+            maxDist = getDistManhattan(cpPrev, cpFirst) * 0.01
 
             // reflected cp
             let cpR = { x: cpPrev.x + dx1 * 2, y: cpPrev.y + dy1 * 2 }
@@ -495,13 +665,13 @@ export function pathDataToShorthands(pathData, decimals = -1, test = false) {
                 }
 
                 // V
-               if (isVertical) {
+                if (isVertical) {
                     //console.log('is V', w, h);
                     comShort = {
                         type: "V",
                         values: [values[1]]
                     };
-                } 
+                }
                 break;
 
             case "Q":
@@ -522,7 +692,7 @@ export function pathDataToShorthands(pathData, decimals = -1, test = false) {
                         type: "S",
                         values: [values[2], values[3], p.x, p.y]
                     };
-                } 
+                }
                 break;
             default:
                 comShort = {

package/src/svgii/pathData_parse.js

@@ -1,104 +1,7 @@
 //import { arcToBezier, quadratic2Cubic } from './convert.js';
 //import { getAngle, bezierhasExtreme, getDistance  } from "./geometry";
-import { pathDataToAbsoluteOrRelative, pathDataToLonghands, pathDataArcsToCubics, pathDataQuadraticToCubic } from './pathData_convert.js';
-import { pathDataToD } from './pathData_stringify.js';
-
-
-
-/**
- * parse normalized
- */
-
-export function normalizePathData(pathData = [],
-    {
-        toAbsolute = true,
-        toLonghands = true,
-        quadraticToCubic = false,
-        arcToCubic = false,
-        arcAccuracy = 2,
-
-        // assume we need full normalization
-        hasRelatives = true, hasShorthands = true, hasQuadratics = true, hasArcs = true, testTypes = false
-
-    } = {}
-) {
-
-    // pathdata properties - test= true adds a manual test 
-    if (testTypes) {
-        //console.log('test for conversions');
-        let commands = Array.from(new Set(pathData.map(com => com.type))).join('');
-        hasRelatives = /[lcqamts]/gi.test(commands);
-        hasQuadratics = /[qt]/gi.test(commands);
-        hasArcs = /[a]/gi.test(commands);
-        hasShorthands = /[vhst]/gi.test(commands);
-        isPoly = /[mlz]/gi.test(commands);
-    }
-
-
-    /**
-     * normalize:
-     * convert to all absolute
-     * all longhands
-     */
-
-    if ((hasQuadratics && quadraticToCubic) || (hasArcs && arcToCubic)) {
-        toLonghands = true
-        toAbsolute = true
-    }
-
-    if (hasRelatives && toAbsolute) pathData = pathDataToAbsoluteOrRelative(pathData, false);
-    if (hasShorthands && toLonghands) pathData = pathDataToLonghands(pathData, -1, false);
-    if (hasArcs && arcToCubic) pathData = pathDataArcsToCubics(pathData, arcAccuracy);
-    if (hasQuadratics && quadraticToCubic) pathData = pathDataQuadraticToCubic(pathData);
-
-    return pathData;
-
-}
-
-export function parsePathDataNormalized(d,
-    {
-        // necessary for most calculations
-        toAbsolute = true,
-        toLonghands = true,
-
-        // not necessary unless you need cubics only
-        quadraticToCubic = false,
-
-        // mostly a fallback if arc calculations fail      
-        arcToCubic = false,
-        // arc to cubic precision - adds more segments for better precision     
-        arcAccuracy = 4,
-    } = {}
-) {
-
-
-    // is already array
-    let isArray = Array.isArray(d);
-
-    // normalize native pathData to regular array
-    let hasConstructor = isArray && typeof d[0] === 'object' && typeof d[0].constructor === 'function'
-    /*
-    if (hasConstructor) {
-        d = d.map(com => { return { type: com.type, values: com.values } })
-        console.log('hasConstructor', hasConstructor, (typeof d[0].constructor), d);
-    }
-    */
-
-    let pathDataObj = isArray ? d : parsePathDataString(d);
-
-
-    let { hasRelatives = true, hasShorthands = true, hasQuadratics = true, hasArcs = true } = pathDataObj;
-    let pathData = hasConstructor ? pathDataObj : pathDataObj.pathData;
-
-    // normalize
-    pathData = normalizePathData(pathData,
-        { toAbsolute, toLonghands, quadraticToCubic, arcToCubic, arcAccuracy,
-        hasRelatives, hasShorthands, hasQuadratics, hasArcs 
-        },
-    )
-
-    return pathData;
-}
+//import { pathDataToAbsoluteOrRelative, pathDataToLonghands, pathDataArcsToCubics, pathDataQuadraticToCubic } from './pathData_convert.js';
+//import { pathDataToD } from './pathData_stringify.js';
 
 
 const commandSet = new Set([