svg-path-simplify 0.0.8 → 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,34 +197,10 @@ export function combineCubicPairs(com1, com2, extrapolateDominant = false, toler
     } // end 1st try
 
 
-    
-
-    // 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
@@ -205,8 +219,6 @@ export function combineCubicPairs(com1, com2, extrapolateDominant = false, toler
         //comS.p0 = com1.p0;
         commands = [comS];
 
-        //console.log('commands combined', commands);
-
     }
 
 
@@ -229,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 };
 }
 
 
@@ -271,7 +278,7 @@ export function getBezierCommandArea(commands = [com1, com2], absolute = true) {
 }
 
 
-function findSplitT(com1, com2) {
+export function findSplitT(com1, com2) {
 
     let len3 = getDistance(com1.cp2, com1.p)
     let len4 = getDistance(com1.cp2, com2.cp1)

package/src/pathData_simplify_cubic_extrapolate.js

@@ -21,8 +21,6 @@ export function getCombinedByDominant(com1, com2, maxDist = 0, tolerance = 1, de
         };
     }
 
-
-
     // if combining fails return original commands
     let commands = [com1, com2]
 
@@ -30,12 +28,8 @@ export function getCombinedByDominant(com1, com2, maxDist = 0, tolerance = 1, de
     let dist1 = getDistAv(com1.p0, com1.p)
     let dist2 = getDistAv(com2.p0, com2.p)
 
-
     let reverse = dist1 > dist2;
 
-    //let ang1 = getAngle(com1.p0, com1.cp1)
-    //let ang2 = getAngle(com2.p, com1.cp2)
-
     // backup original commands
     let com1_o = JSON.parse(JSON.stringify(com1))
     let com2_o = JSON.parse(JSON.stringify(com2))
@@ -118,6 +112,7 @@ export function getCombinedByDominant(com1, com2, maxDist = 0, tolerance = 1, de
         cp1: Q1,
         cp2: Q2,
         p: Q3,
+        t0
     };
 
 
@@ -127,14 +122,18 @@ export function getCombinedByDominant(com1, com2, maxDist = 0, tolerance = 1, de
             cp1: Q2,
             cp2: Q1,
             p: Q0,
+            t0
         }
     }
 
 
     let tMid = (1 - t0) * 0.5;
+    //tMid = (1 +t0) * 0.5;
     let tSplit = t0 - 1;
     //tMid = 0.5;
 
+    //console.log(1 - t0);
+
 
     let ptM = pointAtT([result.p0, result.cp1, result.cp2, result.p], tMid, false, true)
     let seg1_cp2 = ptM.cpts[2]
@@ -144,10 +143,10 @@ export function getCombinedByDominant(com1, com2, maxDist = 0, tolerance = 1, de
     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)
@@ -181,8 +180,22 @@ export function getCombinedByDominant(com1, com2, maxDist = 0, tolerance = 1, de
     // 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);
@@ -190,7 +203,7 @@ export function getCombinedByDominant(com1, com2, maxDist = 0, tolerance = 1, de
         //console.log('distS', distS, maxDist );
 
         // not close enough - exit
-        if (distSplit > maxDist * tolerance) {
+        if (distSplit > maxDist * tolerance ) {
             //renderPoint(markers, ptSplit, 'cyan', '1%')
             //renderPoint(markers, com1.p, 'red', '0.5%')
             return commands;
@@ -216,6 +229,7 @@ export function getCombinedByDominant(com1, com2, maxDist = 0, tolerance = 1, de
         result.error = areaDiff * 5 * tolerance;
         //result.error = areaDiff + dist5;
 
+        //debug=true;
 
         if (debug) {
             let d = pathDataToD(pathDataN)