flo-mat 4.0.3 → 4.1.0

package/src/get-medial-points/double-double/dd-get-medial-point-coeffs-bez3.ts

@@ -0,0 +1,177 @@
+import { toPowerBasisDd } from 'flo-bezier3';
+import { twoDiff, ddMultDouble2, ddAddDd, ddMultDd, ddNegativeOf, ddMultByNeg2, ddMultBy2, ddDiffDouble } from 'double-double';
+
+const td = twoDiff;
+const qmd = ddMultDouble2;
+const qaq = ddAddDd;
+const qmq = ddMultDd;
+const qno = ddNegativeOf;
+const qmn2 = ddMultByNeg2;
+const qm2 = ddMultBy2;
+const qdd = ddDiffDouble;
+
+
+/**
+ * Returns the polynomial coefficients for the ray parameter `t` and the
+ * curve parameter `s` that encode the medial condition for `q(t) = p + t⋅v`
+ * and a cubic bezier curve `ps`.
+ *
+ * The returned coefficients describe the equations whose common solutions
+ * satisfy:
+ * * `q(t)` is equidistant from `p` and the nearest point on `ps`
+ * * that common distance is locally minimal among such candidates
+ *
+ * More specifically, this function returns:
+ * * `A` and `B`: the coefficients of `E2(s,t) = A(s)⋅t + B(s)`
+ * * `C` and `D`: the coefficients of `E1(s,t) = C(s)⋅t + D(s)`
+ * * `H`: the eliminated polynomial `A(s)⋅D(s) - B(s)⋅C(s)` whose roots are
+ *   candidate `s` values for medial points
+ *
+ * @param p base point
+ * @param v ray direction from `p`
+ * @param ps cubic bezier control points, i.e. an order 3 bezier curve
+ * given as an array of control points, e.g. `[[0,0],[1,1],[2,1],[3,0]]`
+ */
+function ddGetMedialPointCoeffsBez3(
+        p: number[][],
+        v: number[][],
+        ps: number[][]) {
+
+    // -----------------------------------------------------
+    // See get-medial-points.md for implementation details.
+    // -----------------------------------------------------
+
+    const [px, py] = p;
+    const [vx, vy] = v;
+
+    // Cubic bezier in power basis: b(s) = a*s^3 + b*s^2 + c*s + d
+    const [[ax,bx,cx,[,dx]],[ay,by,cy,[,dy]]] = toPowerBasisDd(ps);
+
+    // const u0x = px - dx;
+    // const u0y = py - dy;
+    const u0x = qdd(px,dx);
+    const u0y = qdd(py,dy);
+
+    // Reuse dot products across A, B, C, D, and H.
+    // const va = vx*ax + vy*ay;
+    // const vb = vx*bx + vy*by;
+    // const vc = vx*cx + vy*cy;
+    // const vu0 = vx*u0x + vy*u0y;
+    const va = qaq(qmq(vx,ax),qmq(vy,ay));
+    const vb = qaq(qmq(vx,bx),qmq(vy,by));
+    const vc = qaq(qmq(vx,cx),qmq(vy,cy));
+    const vu0 = qaq(qmq(vx,u0x),qmq(vy,u0y));
+
+    // const b6 = ax*ax + ay*ay;
+    // const ab = ax*bx + ay*by;
+    // const ac = ax*cx + ay*cy;
+    // const bb = bx*bx + by*by;
+    // const bc = bx*cx + by*cy;
+    // const cc = cx*cx + cy*cy;
+    const b6 = qaq(qmq(ax,ax),qmq(ay,ay));
+    const ab = qaq(qmq(ax,bx),qmq(ay,by));
+    const ac = qaq(qmq(ax,cx),qmq(ay,cy));
+    const bb = qaq(qmq(bx,bx),qmq(by,by));
+    const bc = qaq(qmq(bx,cx),qmq(by,cy));
+    const cc = qaq(qmq(cx,cx),qmq(cy,cy));
+
+    // const au0 = ax*u0x + ay*u0y;
+    // const bu0 = bx*u0x + by*u0y;
+    // const d0 = cx*u0x + cy*u0y;
+    // const b0 = u0x*u0x + u0y*u0y;
+    const au0 = qaq(qmq(ax,u0x),qmq(ay,u0y));
+    const bu0 = qaq(qmq(bx,u0x),qmq(by,u0y));
+    const d0 = qaq(qmq(cx,u0x),qmq(cy,u0y));
+    const b0 = qaq(qmq(u0x,u0x),qmq(u0y,u0y));
+
+    // -----------------------------------------------------
+    // E1(s,t): (u(s) + t*v) * b'(s) = 0
+    // => C(s)*t + D(s) = 0
+    // const c2 = 3*va;
+    // const c1 = 2*vb;
+    // const c0 = vc;
+    const c2 = qmd(3,va);
+    const c1 = qm2(vb);
+    const c0 = vc;
+    // -----------------------------------------------------
+
+    // -----------------------------------------------------
+    // const d5 = -3*b6;
+    // const d4 = -5*ab;
+    // const d3 = -4*ac - 2*bb;
+    // const d2 = 3*au0 - 3*bc;
+    // const d1 = 2*bu0 - cc;
+    const d5 = qmd(-3,b6);
+    const d4 = qmd(-5,ab);
+    const d3 = qaq(qmd(-4,ac),qmn2(bb));
+    const d2 = qaq(qmd(3,au0),qmd(-3,bc));
+    const d1 = qaq(qm2(bu0),qno(cc));
+    // -----------------------------------------------------
+
+    // -----------------------------------------------------
+    // E2(s,t): |t*v|^2 - |u(s) + t*v|^2 = 0
+    //         => 2*(v*u(s))*t + |u(s)|^2 = 0
+    //         => A(s)*t + B(s) = 0
+    // const a3 = -2*va;
+    // const a2 = -2*vb;
+    // const a1 = -2*vc;
+    // const a0 = 2*vu0;
+    const a3 = qmn2(va);
+    const a2 = qmn2(vb);
+    const a1 = qmn2(vc);
+    const a0 = qm2(vu0);
+    // -----------------------------------------------------
+
+    // -----------------------------------------------------
+    // const b5 = 2*ab;
+    // const b4 = 2*ac + bb;
+    // const b3 = 2*bc - 2*au0;
+    // const b2 = cc - 2*bu0;
+    // const b1 = -2*d0;
+    const b5 = qm2(ab);
+    const b4 = qaq(qm2(ac),bb);
+    const b3 = qaq(qm2(bc),qmn2(au0));
+    const b2 = qaq(cc,qmn2(bu0));
+    const b1 = qmn2(d0);
+    // -----------------------------------------------------
+
+
+    // Eliminate t from:
+    //   A(s)*t + B(s) = 0
+    //   C(s)*t + D(s) = 0
+    // by taking H(s) = A(s)*D(s) - B(s)*C(s) = 0 (degree <= 8 in s).
+    // Using:
+    //   a2 = -c1, a1 = -2*c0,
+    //   d5 = -3*b6, d4 = -(5/2)*b5, d3 = -2*b4, d2 = -(3/2)*b3,
+    //   d1 = -b2, d0 = -(1/2)*b1,
+    // we can compute H directly with fewer operations.
+    // const H8 = 3*va*b6;
+    // const H7 = 4*(va*ab + vb*b6);
+    // const H6 = va*b4 + 6*vb*ab + 5*vc*b6;
+    // const H5 = 2*vb*b4 + 8*vc*ab - 6*vu0*b6;
+    // const H4 = -va*b2 + vb*b3 + 3*vc*b4 - 10*vu0*ab;
+    // const H3 = -2*va*b1 + 2*vc*b3 - 4*vu0*b4;
+    // const H2 = vc*b2 - vb*b1 - 3*vu0*b3 - 3*va*b0;
+    // const H1 = -2*vu0*b2 - 2*vb*b0;
+    // const H0 = -vu0*b1 - vc*b0;
+    const H8 = qmd(3,qmq(va,b6));
+    const H7 = qm2(qm2(qaq(qmq(va,ab),qmq(vb,b6))));
+    const H6 = qaq(qaq(qmq(va,b4),qmd(6,qmq(vb,ab))),qmd(5,qmq(vc,b6)));
+    const H5 = qaq(qaq(qm2(qmq(vb,b4)),qmd(8,qmq(vc,ab))),qno(qmd(6,qmq(vu0,b6))));
+    const H4 = qaq(qaq(qno(qmq(va,b2)),qmq(vb,b3)),qaq(qmd(3,qmq(vc,b4)),qno(qmd(10,qmq(vu0,ab)))));
+    const H3 = qaq(qaq(qmn2(qmq(va,b1)),qm2(qmq(vc,b3))),qno(qm2(qm2(qmq(vu0,b4)))));
+    const H2 = qaq(qaq(qaq(qmq(vc,b2),qno(qmq(vb,b1))),qno(qmd(3,qmq(vu0,b3)))),qno(qmd(3,qmq(va,b0))));
+    const H1 = qaq(qmn2(qmq(vu0,b2)),qmn2(qmq(vb,b0)));
+    const H0 = qaq(qno(qmq(vu0,b1)),qno(qmq(vc,b0)));
+
+    return {
+        A: [a3, a2, a1, a0],
+        B: [b6, b5, b4, b3, b2, b1, b0],
+        C: [c2, c1, c0],
+        D: [d5, d4, d3, d2, d1, d0],
+        H: [H8, H7, H6, H5, H4, H3, H2, H1, H0]
+    };
+}
+
+
+export { ddGetMedialPointCoeffsBez3 }

package/src/get-medial-points/double-double/dd-get-medial-point-coeffs.ts

@@ -0,0 +1,48 @@
+import { ddGetMedialPointCoeffsBez2 } from './dd-get-medial-point-coeffs-bez2.js';
+import { ddGetMedialPointCoeffsBez1 } from './dd-get-medial-point-coeffs-bez1.js';
+import { ddGetMedialPointCoeffsBez3 } from './dd-get-medial-point-coeffs-bez3.js';
+import { ddGetMedialPointCoeffsBez0 } from './dd-get-medial-point-coeffs-bez0.js';
+
+
+const getMedialPointCoeffss = [
+    ,,
+    ddGetMedialPointCoeffsBez1,
+    ddGetMedialPointCoeffsBez2,
+    ddGetMedialPointCoeffsBez3
+];
+
+
+/**
+ * Returns polynomial coefficients for ray parameter values `t`, bezier
+ * parameter values `s` and medial points for points `q(t)` and b(s) (an order
+ * 0, 1, 2 or 3 bezier curve) that satisfy the medial condition with respect to `p` and `ps`:
+ * 
+ * Let `p` be a fixed point in the plane.
+ * Let `v` be a direction vector defining the ray `q(t) = p + t⋅v`.
+ * Let `ps` be a cubic bezier curve.
+ *
+ * * `q(t)` is equidistant from `p` and the nearest point on `ps`
+ * * that common distance is locally minimal among such candidates
+ *
+ * In other words, this function returns candidate ray parameters for the
+ * sought medial point(s). Selecting physically valid solutions (if needed)
+ * is done by the caller or by a later stage of this routine.
+ *
+ * @param p base point
+ * @param v ray direction from `p`
+ * @param ps bezier control points, e.g. `[[0,0],[1,1],[2,1],[3,0]]`
+ */
+function ddGetMedialPointCoeffs(
+        p: number[][],
+        v: number[][],
+        ps: number[][]) {
+
+    if (ps.length === 1) {
+        const { a0, b0 } = ddGetMedialPointCoeffsBez0(p,v,ps[0]);
+        return { A: [a0], B: [b0], C: [], D: [], H: [] };
+    }
+    return getMedialPointCoeffss[ps.length]!(p,v,ps);
+}
+
+
+export { ddGetMedialPointCoeffs }

package/src/get-medial-points/double-double/error-bound-calc.txt

@@ -0,0 +1,72 @@
+
+//--------------------------------------------------------------------------
+// `var` -> a variable
+// `$var` -> the double precision approximation to `var`
+// `_var` -> the absolute value of $var (a prefix underscore on a variable means absolute value)
+// `var_` -> the error in var (a postfix underscore means error bound but should still be multiplied by 3*γ²)
+// `_var_` -> means both absolute value and absolute error bound
+// recall: `a*b`, where both `a` and `b` have errors |a| and |b| we get for the
+//   * error bound of (a*b) === a_|b| + |a|b_ + |a*b|   (when either of a and b is double)
+//   * error bound of (a*b) === a_|b| + |a|b_ + 2|a*b|  (when both a and b is double-double)
+//   * error bound of (a+b) === a_ + b_ + |a+b|         (when a and/or b is double or double-double)
+// * the returned errors need to be multiplied by 3γ² to get the true error
+// * can use either `$var` or `var[var.length-1]` (the approx value) in error calculations
+//   due to multiplication by 3*γ² and not 3*u²
+//--------------------------------------------------------------------------
+// examples: (all?)
+// ----------------
+// let qmd === ddMultDouble2, etc.
+//
+// ---------------
+// 1. double-double X by double
+// ---------------
+// qmd(a,b);  // both `a` and `b` is error-free
+// use: error bound of (a*b) === a_|b| + |a|b_ + |a*b| (by definition)
+//                           === 0|b| + |a|0 + |a*b|
+//                           === |a*b|
+//
+// ---------------
+// 2a. double-double +/- double-double
+// ---------------
+// qdq(a,b);  // error in a === |a|, thus call the error _a_, same with b
+// use: error bound of (a+b) === a_ + b_ + |a+b| (by definition)
+//                           === _a_ + _b_ + |a+b|
+//
+// ---------------
+// 2b. double-double +/- double-double
+// ---------------
+// qaq(a,b);  // error in a === 2|a|, thus the error is 2*_a, same with b
+// use: error bound of (a+b) === a_ + b_ + |a+b| (by definition)
+//                           === 2*_a + 2*_b + |a+b|
+//                           === 2*(_a + _b) + |a+b| OR
+//                           === a_ + b_ + |a+b|
+//
+// ---------------
+// 3a. double-double X double-double
+// ---------------
+// qmq(a,b);  // both `a` and `b` error-free
+// use: error bound of (a*b) === a_|b| + |a|b_ + |a*b| (by definition)
+//                           === 0|b| + |a|0 + 2|a*b|
+//                           === 2|a*b| 
+//
+// ---------------
+// 3b. double-double X double-double
+// ---------------
+// qmq(a,b);  // both `a` and `b` not error-free
+// use: error bound of (a*b) === a_|b| + |a|b_ + 2|a*b| (by definition)
+//
+// ---------------
+// 3b. double-double X double-double
+// ---------------
+// qmq(a,b);  // both `a` not error-free and `b` error-free
+// use: error bound of (a*b) === a_|b| + |a|b_ + 2|a*b| (by definition)
+//                           === a_|b| + 2|a*b| 
+//
+// ---------------
+// 4a. double-double +/- double
+// ---------------
+// qad(a,b);  // both `a` and `b` error-free
+// use: error bound of (a+b) === a_ + b_ + |a+b| (by definition)
+//                           === 0 + 0 + |a+b|
+//                           === |a+b| 
+//--------------------------------------------------------------------------

package/src/index.ts

@@ -7,14 +7,10 @@ export type { CpNode  } from './cp-node/cp-node.js';
 export type { PointOnShape } from './point-on-shape/point-on-shape.js';
 export type { Circle } from './geometry/circle.js';
 export type { CurvePiece } from './mat/curve-piece.js';
-export type { DrawElemFunctions } from './debug/functions/draw-elem/draw-elem.js';
-export type { Timing as ITiming } from './debug/debug.js';
-export type { DebugElems } from './debug/debug-elem-types.js';
+export type { Timing } from './debug/debug.js';
 export type { Debug } from './debug/debug.js';
-export type { DebugElemKey } from './debug/debug-elem-types.js';
 export type { MatOptions } from './find-mat/mat-options.js';
 
-export { drawBeziersAsSinglePath } from './debug/functions/draw/draw-beziers-as-single-path.js';
 export { floydWarshall } from './floyd-warshall/floyd-warshall.js';
 export { CpNodeFs } from './cp-node/cp-node-fs.js';
 export { isVertexSpecial } from './cp-node/fs/is-vertex-special.js';
@@ -23,13 +19,9 @@ export { trimMat } from './mat/trim-mat.js';
 export { toScaleAxis } from './sat/to-scale-axis.js';
 export { getBranches } from './mat/get-branches.js';
 export { enableDebugForMat } from './debug/debug.js';
-export { drawBranch } from './debug/functions/draw-elem/draw-branch.js';
-export { drawMat } from './debug/functions/draw-elem/draw-mat.js';
-export { debugElemNames, emptyDebugElems } from './debug/debug-elem-types.js';
 export { getShapeBounds } from './svg/get-shape-bounds.js';
 export { getBoundaryPieceBeziers } from './mat/get-boundary-piece-beziers.js';
 export { simplifyMat } from './mat/simplify-mat.js';
-export { drawElemFs, drawElemFsDetailed } from './debug/functions/draw-elem/draw-elem.js';
 export { sweepLine } from './sweep-line/sweep-line.js';
 export { getClosestSquareDistanceToRect } from './geometry/get-closest-square-distance-to-rect.js';
 export { getImpliedBoundaryBezierBetween } from './cp-node/fs/get-implied-boundary-bezier-between.js';
@@ -43,6 +35,8 @@ export { getPotentialClosestPointsOnCurveCertified } from './closest-boundary-po
 export { getCloseBoundaryPointsCertified } from './closest-boundary-point/get-close-boundary-points-certified.js';
 export { getPartialMeta } from './find-mat/get-meta.js';
 export { findAndAddHoleClosing2Prongs } from './find-2-prong/find-and-add-hole-closing-2-prongs.js';
+export { reconstructFromMats } from './reconstruct-from-mat/reconstruct-from-mat.js';
+export { getOsculatingCircle } from './point-on-shape/get-osculating-circle.js';
 
 
 // CpNodeFs functions
@@ -82,4 +76,4 @@ export { getAllVertices } from './cp-node/fs/get-all-vertices.js';
 export { isTrivial } from './cp-node/fs/is-trivial.js';
 export { scaleCircle } from './geometry/circle.js';
 export { isOnSameLoop } from './cp-node/fs/is-on-same-loop.js';
-export { reconstructFromMats } from './reconstruct-from-mat/reconstruct-from-mat.js';
+export { getAllOnLoop_ByLoop } from './cp-node/fs/get-all-on-loop-by-loop.js';

package/src/point-on-shape/point-on-shape.ts

@@ -28,6 +28,9 @@ interface PrePointOnShape {
 
     /** The (cached) point on the shape boundary. */
     readonly p: number[];
+
+    /** The (cached) double-double precision point on the shape boundary. */
+    readonly pDd: number[][];
 }
 
 

package/src/point-on-shape/to-p.ts

@@ -10,9 +10,9 @@ import { evalDeCasteljauDd } from "flo-bezier3";
  */
 function toP(
         ps: number[][],
-        t: number): number[] {
+        t: number): number[][] {
 
-    return evalDeCasteljauDd(ps, [0,t]).map(c => c[0] + c[1]);
+    return evalDeCasteljauDd(ps, [0,t]);
 }
 
 

package/src/reconstruct-from-mat/get-cp-nodess-for-sat.ts

@@ -1,8 +1,8 @@
 import type { CpNode } from "../cp-node/cp-node.js";
 import type { Mat } from '../mat/mat.js';
 import { isOnSameLoop } from "../cp-node/fs/is-on-same-loop.js";
-import { isFullyTerminating } from "./is-fully-terminating.js";
-import { getAllOnLoop_ByLoop } from "./get-all-on-loop-by-loop.js";
+import { getAllOnLoop_ByLoop } from "../cp-node/fs/get-all-on-loop-by-loop.js";
+import { isFullyTerminating } from "../cp-node/fs/is-fully-terminating.js";
 
 
 function getCpNodessForSat(

package/src/reconstruct-from-mat/reconstruct-from-mat.ts

@@ -1,44 +1,225 @@
 import type { BezierPiece } from 'flo-bezier3';
 import type { Mat } from '../mat/mat.js';
-import { getMbssByLoopPerSat } from './get-mbss-by-loop-per-sat.js';
-import { getMbssByLoopWithOppArr } from './get-mbss-by-loop-with-opp-arr.js';
+import type { CpNode } from '../cp-node/cp-node.js';
+import {
+    toUnitVector, distanceBetween, fromTo as fromToVec, dot, rotate90Degrees,
+    cross, interpolate, translate, lineLineIntersection
+} from 'flo-vector2d';
+import { tangent as getTangent } from 'flo-bezier3';
+import { mapDeep } from '../utils/map-deep.js';
+import { removeSatInducedTrivial3Prongs } from './remove-sat-induced-trivial-3prongs.js';
+import { getCpNodessForSat } from './get-cp-nodess-for-sat.js';
+import { getRealProngCount } from '../cp-node/fs/get-real-prong-count.js';
 
 
+const { max, abs, round, log2 } = Math;
+
+
+// let ii = 0;
+
+
+/**
+ * * used for debugging only
+ * 
+ * @param mats 
+ * 
+ * @internal
+ */
 function reconstructFromMats(
-        mats: Mat[]) {
+        mats: Mat[],
+        minNumAccurateBits: number | undefined = undefined) {
 
-    const loopss: number[][][][] = [];
+    const maxPO2 = max(...mats.map(mat => mat.meta.maxCoordPowerOf2));
+    const recoverBoundary_ = recoverBoundary(maxPO2, minNumAccurateBits);
 
-    const bzs: BezierPiece[] = [];
+    // Really only required if getSats was called on the `Mat`s
+    const cpNodessPerSat = mats
+        .map(removeSatInducedTrivial3Prongs)
+        .map(getCpNodessForSat);
 
-    const mbssByLoopPerSat = getMbssByLoopPerSat(mats, 1.5)!;
+    const r = mapDeep(3, cpNodessPerSat, recoverBoundary_, true);
+    // ii;//?
 
-    for (const mbssByLoopPS of mbssByLoopPerSat) {
-        const { mbssByLoop, oppArr } = mbssByLoopPS;
+    return r;
+}
 
-        for (let l=0; l<mbssByLoop.length; l++) {
-            const rs = mbssByLoop[l];
 
-            for (let i=0; i<rs.length; i++) {
-                const r = mbssByLoop[l][i];
+const FROM = 0;
+const TO = 1;
 
-                if (r === undefined) { continue; }
+/**
+ * 
+ * @param cpNode 
+ * 
+ * @internal
+ */
+function recoverBoundary(
+        maxPO2: number,
+        minNumAccurateBits: number | undefined) {
 
-                const matchedBezierss = r;
+    return function (cpNode: CpNode) {
+        const cpNode_ = cpNode.next;
 
-                for (let j=0; j<matchedBezierss.length; j++) {
-                    const mb = matchedBezierss[j];
-                    const { boundaryBezier, medialBezier } = mb;
+        const pos = cpNode.pointOnShape; 
+        const pos_ = cpNode_.pointOnShape;
 
-                    bzs.push(boundaryBezier)
-                }
+        const { curve, circle, p } = pos;
+        const { curve: curve_, p: p_ } = pos_;
+
+        if (p[0] === p_[0] && p[1] === p_[1]) {
+            return undefined;
+        }
+
+        if (curve.loop !== curve_.loop) {
+            // It is a hole-closer going over to the other loop
+            // return undefined;
+            return undefined;
+        }
+
+        const d = distanceBetween(circle.center, p);
+        
+        if (getRealProngCount(cpNode)) {
+
+        }
+
+        // DON'T remove these - they tell us the accuracy of the algorithm
+        // if (!closeTo(2**34)(circle.radius, d) && getRealProngCount(cpNode) === 3) {
+        //     ii++;
+        //     circle.center;//?
+        //     circle.radius;//?
+        //     d;            //?
+        //     p;//?
+        //     pos.isSource;//?
+        //     getRealProngCount(cpNode);//?
+        // }
+        // if (!closeTo(2**28)(circle.radius, d) && getRealProngCount(cpNode) !== 3) {
+        //     ii++;
+        //     circle.center;//?
+        //     circle.radius;//?
+        //     d;            //?
+        //     p;//?
+        //     pos.isSource;//?
+        //     getRealProngCount(cpNode);//?
+        // }
+        if (minNumAccurateBits !== undefined) {
+            const TOL = 2**(maxPO2 - minNumAccurateBits);
+
+            if (abs(circle.radius - d) > TOL) {
+                throw new Error(
+                    `Medial circle radius must be about the same (2**${round(log2(TOL))}) ` +
+                    `as distance from medial circle center to point on shape, ` + 
+                    `found: medial radius ${circle.radius}, distance: ${d}`
+                );
             }
         }
+
+        return getBoundaryPiece(cpNode);
+    }
+}
+
+
+/** @internal */
+const TOLERANCE_ADD_2PRONG = 0.01;
+/** @internal */
+const TOLERANCE_USE_LINE = 0.0001; // else cubic
+
+
+function getBoundaryPiece(
+        cpNode: CpNode) {
+
+    const cpNode_ = cpNode.next;
+
+    const pos = cpNode.pointOnShape; 
+    const pos_ = cpNode_.pointOnShape;
+
+    const { p } = pos;
+    const { p: p_ } = pos_;
+
+    const fromCc = p;
+    const fromL = getEdgeDirection(cpNode, FROM);
+
+    const toCc = p_;
+    const toL = getEdgeDirection(cpNode_, TO);
+
+    const mid = lineLineIntersection(fromL, toL);
+
+    const c = fromToVec(fromCc,toCc);
+
+    let twisted: boolean;
+    if (!mid) {
+        twisted = true;
+    } else {
+        const a = fromToVec(fromCc, mid);
+        const b = fromToVec(toCc,   mid);
+        
+        twisted = dot(a,c) < 0 || dot(b,c) > 0;
+    }
+    
+    if (!twisted) {
+        return [fromCc, mid!, toCc];
+    } 
+        
+    const r = rotate90Degrees(c);
+    const w1 = fromToVec(fromL[0], fromL[1]); // This is a unit vector
+    const w2 = fromToVec(toL[0],  toL[1]);  // This is a unit vector
+
+    const d1 = abs(cross(c, w1)) / (3*3); 
+    const d2 = abs(cross(c, w2)) / (3*3); 
+
+    if (d1 > TOLERANCE_ADD_2PRONG || d2 > TOLERANCE_ADD_2PRONG) {
+        // FUTURE - not within tolerance - must add additional 2-prong
+        return [fromCc, toCc];
+    } 
+
+    if (d1 > TOLERANCE_USE_LINE || d2 > TOLERANCE_USE_LINE) {
+        // approximate with cubic bezier
+        const m1 = interpolate(fromCc,toCc,1/3);
+        const m2 = interpolate(fromCc,toCc,2/3);
+        const v1 = translate(r, m1);
+        const v2 = translate(r, m2);
+        const l1 = [m1,v1];
+        const l2 = [m2,v2];
+        const mid1 = lineLineIntersection(fromL, l1)!;
+        const mid2 = lineLineIntersection(toL,   l2)!;
+
+        return [fromCc, mid1, mid2, toCc];
+    } 
+
+    // Within tolerance - approximate with a straight line.
+    return [fromCc, toCc];
+}
+
+
+/**
+ * Returns a line segment of unit length starting at the given point and
+ * being tangent to the shape boundary.
+ * 
+ * @internal
+ */
+function getEdgeDirection(
+        cpNode: CpNode,
+        fromOrTo: typeof FROM | typeof TO) {
+
+    let { pointOnShape } = cpNode;
+    let { curve, t, p } = pointOnShape;
+    let { ps } = curve;
+
+    if (fromOrTo === FROM && t === 1) {
+        t = 0;
+        curve = curve.next;
+        ps = curve.ps;
+    }
+    if (fromOrTo === TO && t === 0 ) {
+        t = 1;
+        curve = curve.prev;
+        ps = curve.ps;
     }
 
+    const tangent = getTangent(ps, t);
+    
+    const v = translate(p, tangent);
 
-    return bzs;
-    // return loopss;
+    return [p,v];
 }
 
 

package/src/reconstruct-from-mat/remove-sat-induced-trivial-3prongs.ts

@@ -1,6 +1,6 @@
 import type { Mutable } from '../utils/mutable.js';
 import type { Mat } from '../mat/mat.js';
-import { isFullyTerminating } from './is-fully-terminating.js';
+import { isFullyTerminating } from '../cp-node/fs/is-fully-terminating.js';
 
 
 /**

package/src/svg/get-loop-bounds.ts

@@ -12,12 +12,20 @@ type Extreme = {
 };
 
 
-function toPrePoint(extreme: Extreme): PrePointOnShape {
+function toPrePoint(
+        extreme: Extreme): PrePointOnShape {
+
+    const { curve, t } = extreme;
+    const { ps } = curve;
+
+    const pDd = toP(ps, t);
+    const p = pDd.map(c => c[0] + c[1]);
+
     return {
-        curve: extreme.curve,
+        curve,
         t: extreme.t,
         isSource: true,
-        p: toP(extreme.curve.ps, extreme.t)
+        p, pDd
     };
 }