svg-path-simplify 0.0.7 → 0.0.9

package/src/pathData_simplify_cubic.js

@@ -5,88 +5,134 @@ import { renderPoint } from "./svgii/visualize";
 
 
 
-function findSplitParameter(com1, com2) {
-
-    let chordLength1 = getDistance(com1.p0, com1.p);
-    let totalChord = getDistance(com1.p0, com2.p);
-
-    let t = chordLength1 / totalChord;
-
-    return refineParameter(com1, com2, t);
-
-    return t
-}
-
-function refineParameter(com1, com2, tEstimate, maxIterations = 10) {
-    let t = tEstimate;
-
-    for (let i = 0; i < maxIterations; i++) {
-        // Calculate error based on Q2 and R1 relationships
-        const P0 = com1.p0;
-        const P3 = com2.p;
-
-        // Reconstruct P1 and P2 at current t
-        const P1 = {
-            x: (com1.cp1.x - (1 - t) * P0.x) / t,
-            y: (com1.cp1.y - (1 - t) * P0.y) / t
-        };
-
-        const P2 = {
-            x: (com2.cp2.x - t * P3.x) / (1 - t),
-            y: (com2.cp2.y - t * P3.y) / (1 - t)
-        };
+export function simplifyPathDataCubic(pathData, {
+    keepExtremes = true,
+    keepInflections = true,
+    keepCorners = true,
+    extrapolateDominant = true,
+    tolerance = 1,
+} = {}) {
+
+    let pathDataN = [pathData[0]];
+    let l = pathData.length;
+
+    for (let i = 2; l && i <= l; i++) {
+        let com = pathData[i - 1];
+        let comN = i < l ? pathData[i] : null;
+        let typeN = comN?.type || null;
+        //let isCornerN = comN?.corner || null;
+        //let isExtremeN = comN?.extreme || null;
+        let isDirChange = com?.directionChange || null;
+        let isDirChangeN = comN?.directionChange || null;
+
+        let { type, values, p0, p, cp1 = null, cp2 = null, extreme = false, corner = false, dimA = 0 } = com;
+
+
+        // next is also cubic
+        if (type === 'C' && typeN === 'C') {
+
+            // cannot be combined as crossing extremes or corners
+            if (
+                (keepInflections && isDirChangeN) ||
+                (keepCorners && corner) ||
+                (!isDirChange && keepExtremes && extreme)
+            ) {
+                //renderPoint(markers, p, 'red', '1%')
+                pathDataN.push(com)
+            }
 
-        // Calculate what Q2 and R1 should be
-        const Q1 = interpolate(P0, P1, t);
-        const P1P2_mid = interpolate(P1, P2, t);
-        const Q2_calc = interpolate(Q1, P1P2_mid, t);
+            // try simplification
+            else {
+                //renderPoint(markers, p, 'magenta', '1%')
+                let combined = combineCubicPairs(com, comN, {tolerance})
+                let error = 0;
+
+                // combining successful! try next segment
+                if (combined.length === 1) {
+                    com = combined[0]
+                    let offset = 1;
+
+                    // add cumulative error to prevent distortions
+                    error += com.error;
+                    //console.log('!error', error);
+
+                    // find next candidates
+                    //offset<2 &&
+                    for (let n = i + 1; error < tolerance && n < l; n++) {
+                        let comN = pathData[n]
+                        if (comN.type !== 'C' ||
+                            (
+                                (keepInflections && comN.directionChange) ||
+                                (keepCorners && com.corner) ||
+                                (keepExtremes && com.extreme)
+                            )
+                        ) {
+                            break
+                        }
+
+                        let combined = combineCubicPairs(com, comN, {tolerance})
+                        if (combined.length === 1) {
+                            // add cumulative error to prevent distortions
+                            //console.log('combined', combined);
+                            error += combined[0].error * 0.5;
+                            //error += combined[0].error * 1;
+                            offset++
+                        }
+                        com = combined[0]
+                    }
+
+                    //com.opt = true
+                    pathDataN.push(com)
+
+                    if (i < l) {
+                        i += offset
+                    }
+
+                } else {
+                    pathDataN.push(com)
+                }
+            }
 
-        const P2P3_mid = interpolate(P2, P3, t);
-        const R1_calc = interpolate(P1P2_mid, P2P3_mid, t);
+        } // end of bezier command
 
-        // Calculate errors
-        const errorQ2 = getDistance(Q2_calc, com1.cp2);
-        const errorR1 = getDistance(R1_calc, com2.cp1);
-        const totalError = errorQ2 + errorR1;
 
-        if (totalError < 1e-9) {
-            break;
+        // other commands
+        else {
+            pathDataN.push(com)
         }
 
-        // Simple adjustment - in practice you'd use proper Newton step
-        t = t * 0.5 + 0.5 * (errorQ2 < errorR1 ? t + 0.01 : t - 0.01);
-        t = Math.max(0.001, Math.min(0.999, t));
-    }
+    } // end command loop
 
-    return t;
+    return pathDataN
 }
 
 
 
-export function combineCubicPairs(com1, com2, extrapolateDominant = false, tolerance = 1) {
+
+export function combineCubicPairs(com1, com2, {
+    tolerance = 1
+} = {}) {
 
     let commands = [com1, com2];
-    let t = findSplitT(com1, com2);
 
-    //threshold = 0.01
+    // assume 2 segments are result of a segment split
+    let t = findSplitT(com1, com2);
 
     let distAv1 = getDistAv(com1.p0, com1.p);
     let distAv2 = getDistAv(com2.p0, com2.p);
-    let distMin = Math.min(distAv1, distAv2)
-    //let distMax = Math.max(distAv1, distAv2)
+    let distMin = Math.max(0, Math.min(distAv1, distAv2))
 
-    let distScale = 0.05
+
+    let distScale = 0.06
     let maxDist = distMin * distScale * tolerance
-    //tolerance = distMax * threshold
 
-    let comS = getExtrapolatedCommand(com1, com2, t, t)
+    // get hypothetical combined command
+    let comS = getExtrapolatedCommand(com1, com2, t)
 
-    // test on path point against original
+    // test new point-at-t against original mid segment starting point
     let pt = pointAtT([comS.p0, comS.cp1, comS.cp2, comS.p], t)
 
 
-    //let tolerance = Math.min(Math.max(com1.dimA, com2.dimA), Math.min(com1.dimA, com2.dimA)) * 0.05
-
     let dist0 = getDistAv(com1.p, pt)
     let dist1 = 0, dist2 = 0;
     let close = dist0 < maxDist;
@@ -97,14 +143,6 @@ export function combineCubicPairs(com1, com2, extrapolateDominant = false, toler
 
 
 
-    /*
-    if (com2.directionChange) {
-        //renderPoint(markers, com2.p0)
-    }
-    */
-
-    //console.log('tolerance', tolerance, close, dist0);
-
     if (close) {
 
         /**
@@ -159,44 +197,10 @@ export function combineCubicPairs(com1, com2, extrapolateDominant = false, toler
     } // end 1st try
 
 
-    
-    /*
-    if (extrapolateDominant && com2.extreme) {
-        renderPoint(markers, com2.p)
-        //renderPoint(markers, com1.p, 'cyan')
-        //extrapolateDominant = false;
-    }
-    */
-
-
-    
-
-    // try extrapolated dominant curve
-    //&& !com2.extreme
-    //  && !com1.extreme
-    if (extrapolateDominant && !success  ) {
-
-        let combinedEx = getCombinedByDominant(com1, com2, maxDist, tolerance);
-
-        //console.log('???combinedEx', combinedEx);
-
-        if(combinedEx.length===1){
-            success = true
-            comS = combinedEx[0]
-            error = comS.error
-
-            //console.log('!!!combinedEx', combinedEx);
-        }
-
-    
-    }
 
     // add meta
     if (success) {
 
-        //comS.dimA = (Math.abs(comS.p0.x - comS.p.x) + Math.abs(comS.p0.y - comS.p.y)) / 2
-
-        
         // correct to exact start and end points
         comS.p0 = com1.p0
         comS.p = com2.p
@@ -215,8 +219,6 @@ export function combineCubicPairs(com1, com2, extrapolateDominant = false, toler
         //comS.p0 = com1.p0;
         commands = [comS];
 
-        //console.log('commands combined', commands);
-
     }
 
 
@@ -239,28 +241,23 @@ export function getError(com, area = 0, threshold = 0) {
 }
 
 
-export function getExtrapolatedCommand(com1, com2, t1 = 0, t2 = 0) {
+export function getExtrapolatedCommand(com1, com2, t = 0) {
 
     let { p0, cp1 } = com1;
     let { p, cp2 } = com2;
 
     // extrapolate control points
-    let cp1_S = {
-        x: (cp1.x - (1 - t1) * p0.x) / t1,
-        y: (cp1.y - (1 - t1) * p0.y) / t1
+    cp1 = {
+        x: (cp1.x - (1 - t) * p0.x) / t,
+        y: (cp1.y - (1 - t) * p0.y) / t
     };
 
-
-    let cp2_S = {
-        x: (cp2.x - t2 * p.x) / (1 - t2),
-        y: (cp2.y - t2 * p.y) / (1 - t2)
+    cp2 = {
+        x: (cp2.x - t * p.x) / (1 - t),
+        y: (cp2.y - t * p.y) / (1 - t)
     };
 
-    let comS = { p0, cp1: cp1_S, cp2: cp2_S, p };
-    //let pt = pointAtT([p0, cp1_S, cp2_S, p], (t1 + t2) / 2);
-
-    return comS
-
+    return { p0, cp1, cp2, p };
 }
 
 
@@ -281,40 +278,14 @@ export function getBezierCommandArea(commands = [com1, com2], absolute = true) {
 }
 
 
-function findSplitT(com1, com2) {
-
-    //let selfIntersecting = false
-
-    // control tangent intersection
-    let pt1 = checkLineIntersection(com1.p0, com1.cp1, com2.cp2, com2.p, false)
-
-    // intersection 2nd cp1 tangent and global tangent intersection
-    let ptI = checkLineIntersection(pt1, com2.p, com2.p0, com2.cp1, false)
-
-
-    let len1 = getDistance(pt1, com2.p)
-    let len2 = getDistance(ptI, com2.p)
-
-    //let t = !t3 ? 1-len2/len1 : (t3+len2/len1)*0.5
-    let t = 1 - len2 / len1
-
-
-    // check self intersections
-    //let ptI2 = checkLineIntersection(com1.cp1, com2.cp2, com1.p0, com2.p, true)
-    //let hasInfliction = ptI2!==null
-
+export function findSplitT(com1, com2) {
 
     let len3 = getDistance(com1.cp2, com1.p)
     let len4 = getDistance(com1.cp2, com2.cp1)
 
-    //let t5 = 1-Math.min(len7, len8)/len9
-    t = Math.min(len3) / len4
-
-    //console.log('???selfIntersecting:', t, hasInfliction, ptI2)
+    let t = Math.min(len3) / len4
 
     return t
-
-
 }
 
 

package/src/pathData_simplify_cubic_extrapolate.js

@@ -3,7 +3,7 @@ import { getPathArea } from "./svgii/geometry_area";
 import { pathDataToD } from "./svgii/pathData_stringify";
 import { renderPath, renderPoint } from "./svgii/visualize";
 
-export function getCombinedByDominant(com1, com2, maxDist = 0, tolerance = 1) {
+export function getCombinedByDominant(com1, com2, maxDist = 0, tolerance = 1, debug = false) {
 
     // cubic Bézier derivative
     const cubicDerivative = (p0, p1, p2, p3, t) => {
@@ -21,18 +21,14 @@ export function getCombinedByDominant(com1, com2, maxDist = 0, tolerance = 1) {
         };
     }
 
-
-
     // if combining fails return original commands
     let commands = [com1, com2]
 
     // detect dominant 
-    let dist1 = getSquareDistance(com1.p0, com1.p)
-    let dist2 = getSquareDistance(com2.p0, com2.p)
-    let reverse = dist1 > dist2;
+    let dist1 = getDistAv(com1.p0, com1.p)
+    let dist2 = getDistAv(com2.p0, com2.p)
 
-    //let ang1 = getAngle(com1.p0, com1.cp1)
-    //let ang2 = getAngle(com2.p, com1.cp2)
+    let reverse = dist1 > dist2;
 
     // backup original commands
     let com1_o = JSON.parse(JSON.stringify(com1))
@@ -42,6 +38,7 @@ export function getCombinedByDominant(com1, com2, maxDist = 0, tolerance = 1) {
 
     if (!ptI) {
         //renderPoint(markers, com1.p, 'purple')
+        //console.log('nope');
         return commands
     }
 
@@ -95,12 +92,10 @@ export function getCombinedByDominant(com1, com2, maxDist = 0, tolerance = 1) {
     let r = sub(P, com1.p0);
 
     //let t0_2 = t0 - dot(r, dP) / dot(dP, dP);
-    
-    t0 -= dot(r, dP) / dot(dP, dP);
 
+    t0 -= dot(r, dP) / dot(dP, dP);
 
     // construct merged cubic over [t0, 1]
-
     let Q0 = pointAtT([com2.p0, com2.cp1, com2.cp2, com2.p], t0);
     let Q3 = com2.p;
 
@@ -117,6 +112,7 @@ export function getCombinedByDominant(com1, com2, maxDist = 0, tolerance = 1) {
         cp1: Q1,
         cp2: Q2,
         p: Q3,
+        t0
     };
 
 
@@ -126,39 +122,46 @@ export function getCombinedByDominant(com1, com2, maxDist = 0, tolerance = 1) {
             cp1: Q2,
             cp2: Q1,
             p: Q0,
+            t0
         }
     }
 
 
-    let tMid = (1 - t0)*0.5 ;
+    let tMid = (1 - t0) * 0.5;
+    //tMid = (1 +t0) * 0.5;
+    let tSplit = t0 - 1;
     //tMid = 0.5;
-    //console.log('t0', t0, tMid);
+
+    //console.log(1 - t0);
+
 
     let ptM = pointAtT([result.p0, result.cp1, result.cp2, result.p], tMid, false, true)
     let seg1_cp2 = ptM.cpts[2]
     //let seg2_cp1 = ptM.cpts[3]
 
-
     let ptI_1 = checkLineIntersection(ptM, seg1_cp2, result.p0, ptI, false)
     let ptI_2 = checkLineIntersection(ptM, seg1_cp2, result.p, ptI, false)
 
 
-    let cp1_2 = interpolate(result.p0, ptI_1, 1.333)
-    let cp2_2 = interpolate(result.p, ptI_2, 1.333)
+    //let tscale =(1 + t0)
+    //console.log('tscale', tscale);
+    let cp1_2 = interpolate(result.p0, ptI_1, 1.333  )
+    let cp2_2 = interpolate(result.p, ptI_2, 1.333  )
 
     // test self intersections and exit 
-    let cp_intersection = checkLineIntersection(com1_o.p0, cp1_2, com2_o.p, cp2_2, true )
-    if(cp_intersection){
+    let cp_intersection = checkLineIntersection(com1_o.p0, cp1_2, com2_o.p, cp2_2, true)
+    if (cp_intersection) {
         //renderPoint(markers, cp_intersection )
         return commands;
     }
 
+    if (debug) renderPoint(markers, ptM, 'purple')
 
     result.cp1 = cp1_2
     result.cp2 = cp2_2
 
-    // check distances
 
+    // check distances between original starting point and extrapolated
     let dist3 = getDistAv(com1_o.p0, result.p0)
     let dist4 = getDistAv(com2_o.p, result.p)
     let dist5 = (dist3 + dist4)
@@ -170,13 +173,43 @@ export function getCombinedByDominant(com1, com2, maxDist = 0, tolerance = 1) {
     result.corner = com2_o.corner
     result.dimA = com2_o.dimA
     result.directionChange = com2_o.directionChange
+    result.type = 'C'
     result.values = [result.cp1.x, result.cp1.y, result.cp2.x, result.cp2.y, result.p.x, result.p.y]
 
 
-
-    // check if completely off
+    // extrapolated starting point is not completely off
     if (dist5 < maxDist) {
 
+        /*
+        let tTotal = 1 + Math.abs(t0);
+        let tSplit = reverse ? 1 + t0 : Math.abs(t0);
+        //tSplit = reverse ? 1 + t0 : Math.abs(t0) / tTotal;
+        //console.log('t0', t0, tMid, 'tSplit', tSplit);
+
+        let pO = pointAtT([com2_o.p0, com2_o.cp1, com2_o.cp2, com2_o.p], t0);
+*/
+
+        // split t to meet original mid segment start point
+        let tSplit = reverse ? 1 + t0 : Math.abs(t0);
+
+        let tTotal = 1 + Math.abs(t0);
+        tSplit = reverse ? 1 + t0 : Math.abs(t0) / tTotal;
+
+
+        //console.log('t0', t0, tMid, 'tSplit', tSplit);
+
+        let ptSplit = pointAtT([result.p0, result.cp1, result.cp2, result.p], tSplit);
+        let distSplit = getDistAv(ptSplit, com1.p)
+        //console.log('distS', distS, maxDist );
+
+        // not close enough - exit
+        if (distSplit > maxDist * tolerance ) {
+            //renderPoint(markers, ptSplit, 'cyan', '1%')
+            //renderPoint(markers, com1.p, 'red', '0.5%')
+            return commands;
+        }
+
+
         // compare combined with original area
         let pathData0 = [
             { type: 'M', values: [com1_o.p0.x, com1_o.p0.y] },
@@ -193,28 +226,24 @@ export function getCombinedByDominant(com1, com2, maxDist = 0, tolerance = 1) {
         let areaN = getPathArea(pathDataN)
         let areaDiff = Math.abs(areaN / area0 - 1)
 
-        result.error = areaDiff * 10 * tolerance;
+        result.error = areaDiff * 5 * tolerance;
         //result.error = areaDiff + dist5;
 
-        let d = pathDataToD(pathDataN)
+        //debug=true;
 
-        // success
-        if (areaDiff < 0.01) {
-            commands = [result];
-            //renderPath(markers, d, 'orange')
-            //console.log('areaDiff', areaDiff);
-
-        } else {
-            // renderPath(markers, d, 'red')
-            // console.log('areaDiff', areaDiff);
+        if (debug) {
+            let d = pathDataToD(pathDataN)
+            renderPath(markers, d, 'orange')
         }
 
-
-        //renderPath(markers, d, 'orange')
+        // success!!!
+        if (areaDiff < 0.05 * tolerance) {
+            commands = [result];
+            //console.log('areaDiff', areaDiff);
+        } 
     }
 
 
-
     //console.log(commands);
 
     return commands