svg-path-simplify 0.2.6 → 0.3.0

package/src/pathSimplify-main.js

@@ -34,6 +34,8 @@ import { pathDataFromPoly } from './svgii/pathData_fromPoly';
 import { simplifyRDP } from './simplify_poly_RDP';
 import { harmonizeCubicCpts } from './pathData_simplify_harmonize_cpts';
 import { pathDataToPolygon } from './svgii/pathData_toPolygon';
+import { pathDataLineToCubic } from './svgii/pathData_line_to_cubic';
+import { fixPathDataDirections } from './svgii/pathData_fix_directions';
 
 //import { installDOMPolyfills } from './dom-polyfill';
 
@@ -66,6 +68,12 @@ export function svgPathSimplify(input = '', {
 
     refineExtremes = true,
     simplifyCorners = false,
+    removeDimensions = false,
+    removeIds = false,
+    removeClassNames = false,
+    omitNamespace = false,
+
+    fixDirections = false,
 
     keepExtremes = true,
     keepCorners = true,
@@ -80,7 +88,6 @@ export function svgPathSimplify(input = '', {
 
 
     removeOrphanSubpaths = false,
-
     simplifyRound = false,
 
     //svg scaling
@@ -90,32 +97,30 @@ export function svgPathSimplify(input = '', {
     alignToOrigin = false,
 
 
-    // svg path optimizations
+    //svg path optimizations
     decimals = 3,
     autoAccuracy = true,
 
     minifyD = 0,
     tolerance = 1,
-    reverse = false,
+    reversePath = false,
 
-    // svg cleanup options
-    cleanupSVGAtts=true,
+    //svg cleanup options
+    cleanupSVGAtts = true,
     removePrologue = true,
     stylesToAttributes = true,
     fixHref = true,
-    removeNameSpaced=true,
-    attributesToGroup=false,
+    removeNameSpaced = true,
+    attributesToGroup = false,
     mergePaths = false,
     removeHidden = true,
     removeUnused = true,
-    shapesToPaths = true,
+    shapesToPaths = false,
+    lineToCubic = false,
 
     tMin = 0,
     tMax = 1,
 
-    // redraw - for messed up paths
-    redraw = false,
-
 
 } = {}) {
 
@@ -145,7 +150,6 @@ export function svgPathSimplify(input = '', {
     svgSize = input.length;
 
 
-
     /**
      * global bbox and viewBox for 
      * path scaling
@@ -179,14 +183,18 @@ export function svgPathSimplify(input = '', {
     else {
         //sanitize
         let returnDom = true
-        svg = cleanUpSVG(input, { cleanupSVGAtts, returnDom, removeHidden, removeUnused, removeNameSpaced, attributesToGroup, stylesToAttributes, removePrologue, fixHref ,mergePaths  }
+        svg = cleanUpSVG(input, { removeIds, removeClassNames, removeDimensions, cleanupSVGAtts, returnDom, removeHidden, removeUnused, removeNameSpaced, stylesToAttributes, removePrologue, fixHref, mergePaths, shapesToPaths }
         );
 
         if (shapesToPaths) {
             let shapes = svg.querySelectorAll('polygon, polyline, line, rect, circle, ellipse');
             shapes.forEach(shape => {
                 let path = shapeElToPath(shape);
+                //console.log('path', path.getAttribute('d'));
                 shape.replaceWith(path)
+                //shape.parentNode.insertBefore(path, shape)
+                //shape.remove()
+                //shape = path
             })
         }
 
@@ -194,8 +202,6 @@ export function svgPathSimplify(input = '', {
         let pathEls = svg.querySelectorAll('path')
 
 
-        //if(mergePaths){}
-
         pathEls.forEach(path => {
             paths.push({ d: path.getAttribute('d'), el: path })
         })
@@ -293,7 +299,6 @@ export function svgPathSimplify(input = '', {
             let pathDataSub = subPathArr[i];
 
 
-
             /**
              * convert cureves to polygon
              * flattening
@@ -361,23 +366,6 @@ export function svgPathSimplify(input = '', {
             // remove zero length linetos
             if (removeColinear || removeZeroLength) pathDataSub = removeZeroLengthLinetos(pathDataSub)
 
-            /**
-             * try to redraw messed up paths
-             * based on significant points suchas
-             * extremes, semi-extremes and corners
-             */
-            if (redraw) {
-                addExtremes = true
-                addSemiExtremes = true
-                simplifyCorners = false
-                keepCorners = true
-                keepExtremes = true
-                optimizeOrder = true
-                //simplifyBezier = false
-                tMin = 0
-                tMax = 0
-            }
-
 
             // sort to top left
             if (optimizeOrder) pathDataSub = pathDataToTopLeft(pathDataSub);
@@ -391,6 +379,12 @@ export function svgPathSimplify(input = '', {
 
 
 
+            // reverse
+            if(reversePath) {
+                pathDataSub = reversePathData(pathDataSub)
+            }
+
+
             // analyze pathdata to add info about signicant properties such as extremes, corners
             let pathDataPlus = analyzePathData(pathDataSub, {
                 detectSemiExtremes: addSemiExtremes,
@@ -408,7 +402,7 @@ export function svgPathSimplify(input = '', {
             if (refineClosing) pathData = refineClosingCommand(pathData, { threshold: dimA * 0.001 })
 
 
-            pathData = simplifyBezier ? simplifyPathDataCubic(pathData, { simplifyBezier, keepInflections, keepExtremes, keepCorners, extrapolateDominant, revertToQuadratics, tolerance, reverse }) : pathData;
+            pathData = simplifyBezier ? simplifyPathDataCubic(pathData, { simplifyBezier, keepInflections, keepExtremes, keepCorners, extrapolateDominant, revertToQuadratics, tolerance }) : pathData;
 
 
             // refine extremes
@@ -419,34 +413,6 @@ export function svgPathSimplify(input = '', {
             }
 
 
-            /**
-              * try redrawing
-              */
-
-            if (redraw) {
-
-                //pathData = pathDataRemoveColinear(pathData, { tolerance, flatBezierToLinetos: false });
-                /*
-                pathData = addExtremePoints(pathData,
-                    { tMin: 0, tMax: 1, addExtremes: true, addSemiExtremes: true })
-    
-                    pathData = analyzePathData(pathDataSub, {
-                        detectSemiExtremes: true,
-                        detectExtremes: true,
-                    }).pathData;
-    
-                    */
-
-
-                let thresholdEx = (bb.width + bb.height) * 0.1
-                //pathData = refineAdjacentExtremes(pathData, { threshold: thresholdEx, tolerance })
-                pathData = redrawPathData(pathData, { tolerance, threshold: dimA * 0.001 })
-
-                //simplifyPathDataCubic(pathData, { simplifyBezier, keepInflections, keepExtremes, keepCorners, extrapolateDominant, revertToQuadratics, tolerance, reverse })
-
-            }
-
-
             // cubic to arcs
             if (cubicToArc) pathData = pathDataCubicsToArc(pathData, { areaThreshold: 2.5 })
 
@@ -464,7 +430,7 @@ export function svgPathSimplify(input = '', {
                 let threshold = (bb.width + bb.height) * 0.1
                 pathData = refineRoundedCorners(pathData, { threshold, tolerance })
             }
-            
+
             // refine round segment sequences
             if (simplifyRound) pathData = refineRoundSegments(pathData);
 
@@ -472,12 +438,14 @@ export function svgPathSimplify(input = '', {
             // simplify to quadratics
             if (revertToQuadratics) pathData = pathDataRevertCubicToQuadratic(pathData, tolerance);
 
+            if (lineToCubic) pathData = pathDataLineToCubic(pathData);
+
+
             // optimize close path
             if (optimizeOrder) pathData = optimizeClosePath(pathData, { autoClose })
 
+
             // update
-            //pathDataFlat.push(...pathData)
-            //subPathArr[i]=pathData
             pathDataPlusArr.push({ pathData, bb })
 
         } // end sup paths
@@ -500,25 +468,28 @@ export function svgPathSimplify(input = '', {
             pathDataPlusArr = isPortrait ? pathDataPlusArr.sort((a, b) => a.bb.y - b.bb.y || a.bb.x - b.bb.x) : pathDataPlusArr.sort((a, b) => a.bb.x - b.bb.x || a.bb.y - b.bb.y)
         }
 
+
+        // fix path directions
+        if (fixDirections) {
+            pathDataPlusArr = fixPathDataDirections(pathDataPlusArr);
+        }
+
+
         // flatten compound paths 
         pathData = [];
         pathDataPlusArr.forEach(sub => {
             pathData.push(...sub.pathData)
         })
 
-        //pathData = pathDataFlat;
-        //pathData = subPathArr.flat();
-        //console.log('pathData', pathData);
 
         if (autoAccuracy) {
             decimals = detectAccuracy(pathData)
             pathOptions.decimals = decimals
-            //console.log('!decimals', decimals);
         }
 
 
         // collect for merged svg paths 
-        mergePaths= false
+        mergePaths = false
         if (el && mergePaths) {
             pathData_merged.push(...pathData)
         }
@@ -574,6 +545,7 @@ export function svgPathSimplify(input = '', {
      */
     if (mode) {
 
+
         if (pathData_merged.length) {
 
             // optimize path data
@@ -584,7 +556,6 @@ export function svgPathSimplify(input = '', {
 
             let dOpt = pathDataToD(pathData, minifyD)
 
-
             // apply new path for svgs
             paths[0].el.setAttribute('d', dOpt)
 
@@ -625,8 +596,19 @@ export function svgPathSimplify(input = '', {
             }
         }
 
+        // remove fill rules
+        if (fixDirections) {
+            let elsFill = svg.querySelectorAll('path[fill-rule], path[clip-rule]');
+            elsFill.forEach(el => {
+                el.removeAttribute('fill-rule')
+                el.removeAttribute('clip-rule')
+            })
+        }
+
+
+        svg = stringifySVG(svg, omitNamespace);
+
 
-        svg = stringifySVG(svg);
         //svgSizeOpt = new Blob([svg]).size
         svgSizeOpt = svg.length;
         //compression = +(100/svgSize * (svgSize-svgSizeOpt)).toFixed(2)

package/src/pathSimplify-only-pathdata.js

@@ -0,0 +1,274 @@
+import { detectInputType } from './detect_input';
+import { simplifyPathDataCubic } from './pathData_simplify_cubic';
+import { analyzePathData } from './svgii/pathData_analyze';
+import { convertPathData } from './svgii/pathData_convert';
+import { parsePathDataNormalized } from './svgii/pathData_parse';
+import { pathDataRemoveColinear } from './svgii/pathData_remove_collinear';
+import { removeOrphanedM } from './svgii/pathData_remove_orphaned';
+import { removeZeroLengthLinetos } from './svgii/pathData_remove_zerolength';
+import { optimizeClosePath, pathDataToTopLeft } from './svgii/pathData_reorder';
+import { addExtremePoints, splitSubpaths } from './svgii/pathData_split';
+import { pathDataToD } from './svgii/pathData_stringify';
+//import { pathDataToPolyPlus, pathDataToPolySingle } from './svgii/pathData_toPolygon';
+import { detectAccuracy } from './svgii/rounding';
+import { refineAdjacentExtremes } from './svgii/pathData_simplify_refineExtremes';
+import { refineRoundedCorners } from './svgii/pathData_simplify_refineCorners';
+import { refineRoundSegments } from './svgii/pathData_refine_round';
+import { refineClosingCommand } from './svgii/pathData_remove_short';
+import { pathDataRevertCubicToQuadratic } from './pathData_simplify_revertToquadratics';
+import { pathDataLineToCubic } from './svgii/pathData_line_to_cubic';
+
+//import { installDOMPolyfills } from './dom-polyfill';
+
+export function simplifyPathData(input = '', {
+
+    toAbsolute = true,
+    toRelative = true,
+    toShorthands = true,
+    //optimize = 0,
+
+    // not necessary unless you need cubics only
+    quadraticToCubic = true,
+
+    // mostly a fallback if arc calculations fail      
+    arcToCubic = false,
+    cubicToArc = false,
+
+
+    simplifyBezier = true,
+    optimizeOrder = true,
+    autoClose = true,
+    removeZeroLength = true,
+    refineClosing = true,
+    removeColinear = true,
+    flatBezierToLinetos = true,
+    revertToQuadratics = true,
+
+    refineExtremes = true,
+    simplifyCorners = false,
+    fixDirections = false,
+
+    keepExtremes = true,
+    keepCorners = true,
+    keepInflections = false,
+    addExtremes = false,
+    addSemiExtremes = false,
+
+    harmonizeCpts = false,
+    toPolygon = false,
+    removeOrphanSubpaths = false,
+    simplifyRound = false,
+
+    //svg path optimizations
+    decimals = 3,
+    autoAccuracy = true,
+
+    minifyD = 0,
+    tolerance = 1,
+
+    lineToCubic = false,
+    // return svg markup or object
+    getObject = false,
+
+} = {}) {
+
+
+    // clamp tolerance and scale
+    tolerance = Math.max(0.1, tolerance);
+
+    let compression = 0;
+    let report = {};
+    let d = '';
+
+    /**
+     * normalize input
+     * switch mode
+     */
+
+
+    /**
+     * global bbox and viewBox for 
+     * path scaling
+     * sorting and cropping
+    */
+    let viewBox = { x: 0, y: 0, width: 0, height: 0 }
+    let bb_global = { x: 0, y: 0, width: 0, height: 0 }
+    let xArr = []
+    let yArr = []
+
+    // mode:0 – single path
+    let inputType = detectInputType(input)
+    if (inputType === 'pathDataString') {
+        d = input
+    } else if (inputType === 'polyString') {
+        d = 'M' + input
+    }
+    else if (inputType === 'pathData') {
+        d = input;
+    }else{
+        return false
+    }
+
+
+    /**
+     * process all paths
+     * try simplifications and removals
+     */
+
+    // SVG optimization options
+    let pathOptions = {
+        toRelative,
+        toShorthands,
+        decimals,
+    }
+
+
+    let pathData = parsePathDataNormalized(d, { quadraticToCubic, toAbsolute, arcToCubic });
+
+
+    // count commands for evaluation
+    let comCount = pathData.length
+
+    if (removeOrphanSubpaths) pathData = removeOrphanedM(pathData);
+
+
+    /**
+     * get sub paths
+     */
+    let subPathArr = splitSubpaths(pathData);
+    let lenSub = subPathArr.length;
+
+
+    // reset array
+    let pathDataPlusArr = []
+
+    // loop sub paths
+    for (let i = 0; i < lenSub; i++) {
+
+        //let { pathData, bb } = subPathArr[i];
+        let pathDataSub = subPathArr[i];
+
+
+        // remove zero length linetos
+        if (removeColinear || removeZeroLength) pathDataSub = removeZeroLengthLinetos(pathDataSub)
+
+
+        // sort to top left
+        if (optimizeOrder) pathDataSub = pathDataToTopLeft(pathDataSub);
+
+
+        // Preprocessing: remove colinear - ignore flat beziers (removed later)
+        if (removeColinear) pathDataSub = pathDataRemoveColinear(pathDataSub, { tolerance, flatBezierToLinetos: false });
+
+        if (addExtremes || addSemiExtremes) pathDataSub = addExtremePoints(pathDataSub,
+            { tMin, tMax, addExtremes, addSemiExtremes, angles: [30] })
+
+
+        // analyze pathdata to add info about signicant properties such as extremes, corners
+        let pathDataPlus = analyzePathData(pathDataSub, {
+            detectSemiExtremes: addSemiExtremes,
+        });
+
+
+        // simplify beziers
+        let { pathData, bb, dimA } = pathDataPlus;
+        xArr.push(bb.x, bb.x + bb.width)
+        yArr.push(bb.y, bb.y + bb.height)
+
+
+        if (refineClosing) pathData = refineClosingCommand(pathData, { threshold: dimA * 0.001 })
+
+        pathData = simplifyBezier ? simplifyPathDataCubic(pathData, { simplifyBezier, keepInflections, keepExtremes, keepCorners, revertToQuadratics, tolerance }) : pathData;
+
+
+        // refine extremes
+        if (refineExtremes) {
+            //let thresholdEx = (bb.width + bb.height) / 2 * 0.05
+            let thresholdEx = (bb.width + bb.height) * 0.05
+            pathData = refineAdjacentExtremes(pathData, { threshold: thresholdEx, tolerance })
+        }
+
+
+
+        // post processing: remove flat beziers
+        if (removeColinear && flatBezierToLinetos) {
+            pathData = pathDataRemoveColinear(pathData, { tolerance, flatBezierToLinetos });
+        }
+
+
+        // refine corners
+        if (simplifyCorners) {
+
+            let threshold = (bb.width + bb.height) * 0.1
+            pathData = refineRoundedCorners(pathData, { threshold, tolerance })
+        }
+
+        // refine round segment sequences
+        if (simplifyRound) pathData = refineRoundSegments(pathData);
+
+
+        // simplify to quadratics
+        if (revertToQuadratics) pathData = pathDataRevertCubicToQuadratic(pathData, tolerance);
+
+        if (lineToCubic) pathData = pathDataLineToCubic(pathData);
+
+
+        // optimize close path
+        if (optimizeOrder) pathData = optimizeClosePath(pathData, { autoClose })
+
+
+        // update
+        pathDataPlusArr.push({ pathData, bb })
+
+    } // end sup paths
+
+    // sort subpaths to top left
+    let xMin = Math.min(...xArr)
+    let yMin = Math.min(...yArr)
+    let xMax = Math.max(...xArr)
+    let yMax = Math.max(...yArr)
+
+    bb_global = { x: xMin, y: yMin, width: xMax - xMin, height: yMax - yMin }
+    let isPortrait = bb_global.height > bb_global.width;
+
+
+    // prefer top to bottom priority for portrait aspect ratios 
+    if (optimizeOrder) {
+        pathDataPlusArr = isPortrait ? pathDataPlusArr.sort((a, b) => a.bb.y - b.bb.y || a.bb.x - b.bb.x) : pathDataPlusArr.sort((a, b) => a.bb.x - b.bb.x || a.bb.y - b.bb.y)
+    }
+
+
+    // flatten compound paths 
+    pathData = [];
+    pathDataPlusArr.forEach(sub => {
+        pathData.push(...sub.pathData)
+    })
+
+
+    if (autoAccuracy) {
+        decimals = detectAccuracy(pathData)
+        pathOptions.decimals = decimals
+    }
+
+
+    // optimize path data
+    pathData = convertPathData(pathData, pathOptions)
+
+    // remove zero-length segments introduced by rounding
+    pathData = removeZeroLengthLinetos(pathData);
+
+    let dOpt = pathDataToD(pathData, minifyD)
+
+    // remove custom properties
+    if(getObject){
+        pathData = pathData.map(com=>{return {type:com.type, values:com.values}});
+    }
+
+    return !getObject ? dOpt : pathData;
+
+}
+
+
+
+
+

package/src/svgii/geometry.js

@@ -117,7 +117,7 @@ export function getDeltaAngle(centerPoint, startPoint, endPoint, largeArc = fals
  * http://jsfiddle.net/justin_c_rounds/Gd2S2/light/
  */
 
-export function checkLineIntersection(p1 = null, p2 = null, p3 = null, p4 = null, exact = true, debug = false) {
+export function checkLineIntersection(p1 = null, p2 = null, p3 = null, p4 = null, exact = true, respectDirection = false, debug = false) {
     // if the lines intersect, the result contains the x and y of the intersection (treating the lines as infinite) and booleans for whether line segment 1 or line segment 2 contain the point
     let denominator, a, b, numerator1, numerator2;
     let intersectionPoint = {}
@@ -129,7 +129,9 @@ export function checkLineIntersection(p1 = null, p2 = null, p3 = null, p4 = null
 
     try {
         denominator = ((p4.y - p3.y) * (p2.x - p1.x)) - ((p4.x - p3.x) * (p2.y - p1.y));
-        if (denominator == 0) {
+
+        // parallel or colinear
+        if (denominator === 0) {
             return false;
         }
     } catch {
@@ -151,7 +153,6 @@ export function checkLineIntersection(p1 = null, p2 = null, p3 = null, p4 = null
         y: p1.y + (a * (p2.y - p1.y))
     }
 
-
     let intersection = false;
     // if line1 is a segment and line2 is infinite, they intersect if:
     if ((a > 0 && a < 1) && (b > 0 && b < 1)) {
@@ -159,8 +160,14 @@ export function checkLineIntersection(p1 = null, p2 = null, p3 = null, p4 = null
         //console.log('line inters');
     }
 
+    // direction
+    if (!exact && respectDirection && ((a > 0 && b < 0) || (a < 0 && b > 0))) {
+        intersection = false;
+        return false
+    }
+
+
     if (exact && !intersection) {
-        //console.log('no line inters');
         return false;
     }
 
@@ -170,6 +177,43 @@ export function checkLineIntersection(p1 = null, p2 = null, p3 = null, p4 = null
 };
 
 
+/** Get relationship between a point and a polygon using ray-casting algorithm
+* based on timepp's answer
+* https://stackoverflow.com/questions/217578/how-can-i-determine-whether-a-2d-point-is-within-a-polygon#63436180
+*/
+export function isPointInPolygon(pt, polygon, bb, skipBB = false) {
+    const between = (p, a, b) => (p >= a && p <= b) || (p <= a && p >= b);
+    let inside = false;
+
+    // not in bbox - quit || no bbox defined
+    if (!skipBB || !bb.bottom) {
+        if (bb.left > pt.x || bb.top > pt.y || bb.bottom < pt.y || bb.right < pt.x) {
+            return false;
+        }
+    }
+
+    let l=polygon.length;
+    for (let i = l - 1, j = 0; j < l; i = j, j++) {
+        const A = polygon[i];
+        const B = polygon[j];
+        // corner cases
+        if ((pt.x == A.x && pt.y == A.y) || (pt.x == B.x && pt.y == B.y))
+            return true;
+        if (A.y == B.y && pt.y == A.y && between(pt.x, A.x, B.x)) return true;
+        if (between(pt.y, A.y, B.y)) {
+            /** 
+             * if pt inside the vertical range filter out "ray pass vertex" problem 
+             * by treating the line a little lower
+             */ 
+            if ((pt.y == A.y && B.y >= A.y) || (pt.y == B.y && A.y >= B.y)) continue;
+            // calc cross product `ptA X ptB`, pt lays on left side of AB if c > 0
+            const c = (A.x - pt.x) * (B.y - pt.y) - (B.x - pt.x) * (A.y - pt.y);
+            if (c == 0) return true;
+            if (A.y < B.y == c > 0) inside = !inside;
+        }
+    }
+    return inside ? true : false;
+}
 
 
 

package/src/svgii/pathData_analyze.js

@@ -1,5 +1,5 @@
 import { splitSubpaths } from './pathData_split.js';
-import { getAngle, bezierhasExtreme, getPathDataVertices, svgArcToCenterParam, getSquareDistance, getDistManhattan, isMultipleOf45, pointAtT, getTatAngles } from "./geometry.js";
+import { getAngle, bezierhasExtreme, getPathDataVertices, svgArcToCenterParam, getSquareDistance, getDistManhattan, isMultipleOf45, pointAtT, getTatAngles, checkLineIntersection } from "./geometry.js";
 import { getPolygonArea, getPathArea } from './geometry_area.js';
 import { getPolyBBox } from './geometry_bbox.js';
 import { renderPoint, renderPath } from "./visualize.js";
@@ -86,6 +86,7 @@ export function analyzePathData(pathData = [], {
         // check flatness of command
         let toleranceFlat = 0.01;
         let thresholdLength = dimA * 0.1
+        let threshold = thresholdLength*0.01
         let areaThresh = squareDist * toleranceFlat;
         let isFlat = Math.abs(cptArea) < areaThresh;
 
@@ -108,10 +109,12 @@ export function analyzePathData(pathData = [], {
             let dx = type === 'C' ? Math.abs(com.cp2.x - com.p.x) : Math.abs(com.cp1.x - com.p.x)
             let dy = type === 'C' ? Math.abs(com.cp2.y - com.p.y) : Math.abs(com.cp1.y - com.p.y)
 
-            let horizontal = dy === 0 && dx > 0
-            let vertical = dx === 0 && dy > 0
+            let horizontal = (dy === 0 || dy<threshold ) && dx > 0
+            let vertical = (dx === 0 || dx<threshold ) && dy > 0
 
-            if (horizontal || vertical) hasExtremes = true;
+            if (horizontal || vertical) {
+                hasExtremes = true;
+            }
 
             // is extreme relative to bounding box 
             if ((p.x === left || p.y === top || p.x === right || p.y === bottom)) {
@@ -123,7 +126,7 @@ export function analyzePathData(pathData = [], {
                 let couldHaveExtremes = bezierhasExtreme(null, commandPts)
                 if (couldHaveExtremes) {
                     let tArr = getTatAngles(commandPts)
-                    if (tArr.length && (tArr[0] > 0.15)) {
+                    if (tArr.length && (tArr[0] > 0.2)) {
                         hasExtremes = true;
                     }
                 }
@@ -183,7 +186,6 @@ export function analyzePathData(pathData = [], {
             }
         }
 
-
         //debug = true;
         if (debug) {
             //if (com.semiExtreme) renderPoint(markers, com.p, 'blue', '2%', '0.5')