flo-mat 3.0.14 → 4.0.1

package/src/mat/get-boundary-piece-beziers.ts

@@ -1,67 +1,182 @@
-import { CpNode } from '../cp-node/cp-node.js';
-import { Curve } from '../curve/curve.js';
-import { CurvePiece } from './curve-piece.js';
-import { isPosQuiteSharpCorner } from '../point-on-shape/is-pos-quite-sharp-corner.js';
-import { compareCps } from '../contact-point/contact-point.js';
+import type { Curve } from 'flo-boolean';
+import type { CpNode } from '../cp-node/cp-node.js';
+import type { CurvePiece } from './curve-piece.js';
+import { comparePoss } from '../point-on-shape/compare-poss.js';
 
 
 /**
- * @internal
- * Returns the ordered cubic bezier pieces (i.e a bezier with a t range) 
- * from the given boundary piece.
+ * Returns the ordered bezier pieces between from the given boundary piece.
  * 
  * @param cpNodes - An ordered pair that represents the start and end points of 
  * the boundary piece
+ * 
+ * @internal
  */
-function getBoundaryPieceBeziers(cpNodes: CpNode[]): CurvePiece[] {
+function getBoundaryPieceBeziers(
+        cpNodes: CpNode[]): CurvePiece[] {
+
     let cpThis = cpNodes[0]; 
     const cpEnd  = cpNodes[1];
     
     const curvePieces: CurvePiece[] = [];
 
+    // NOTE❗ Currently removed stichables; we're just checking for duplicates
+    // later in `find2Prong`; KEEP for possible future use.
+    // We have to stich curves together if they're at a hole closer or at the
+    // endpoints of a loop to avoid duplicates later within the code; the map
+    // is from curves
+    // const stichables: Map<Curve, number[]> = new Map();
+
     // As opposed to going around the circle and taking the last exit
     let goStraight = true; 
     do {
+        const posThis = cpThis     .pointOnShape;
+        const posNext = cpThis.next.pointOnShape;
+        const curveThis = posThis.curve;
+        const curveNext = posNext.curve;
+
         if (!goStraight) {
             goStraight = true;
-            cpThis = cpThis.prevOnCircle; // take last exit
+            // NOTE❗ Currently removed stichables; we're just checking for duplicates
+            // later in `find2Prong`; KEEP for possible future use.
+            // const { loop: loopThis } = curveThis;
+            // const cpPrevOnCircle = cpThis.prevOnCircle;
+            // const curvePrevOnCircle = cpPrevOnCircle.pointOnShape.curve;
+            // const { loop: loopNext } = cpPrevOnCircle.pointOnShape.curve;
+            
+
+            // if (loopThis !== loopNext) {
+            //     let idxsThis = stichables.get(curveThis);
+            //     if (idxsThis === undefined) {
+            //         idxsThis = [];
+            //         stichables.set(curveThis, idxsThis);
+            //     }
+            //     idxsThis.push(curvePieces.length - 1);  // last `CurvePiece` idx
+
+            //     let idxsNext = stichables.get(curvePrevOnCircle);
+            //     if (idxsNext === undefined) {
+            //         idxsNext = [];
+            //         stichables.set(curvePrevOnCircle, idxsNext);
+            //     }
+            //     idxsNext.push(curvePieces.length);  // upcoming `CurvePiece` idx
+            // }
+
+            // cpThis = cpPrevOnCircle;  // take last exit
+            cpThis = cpThis.prevOnCircle;  // take last exit
             continue;
         }
 
         goStraight = false;
-        
-        const posThis = cpThis     .cp.pointOnShape;
-        const posNext = cpThis.next.cp.pointOnShape;
-
-        if (posNext.curve === posThis.curve && 
-            isPosQuiteSharpCorner(posThis) && 
-            isPosQuiteSharpCorner(posNext)) {
-
-            // Do nothing
-        } else if (posNext.curve === posThis.curve &&
-                   compareCps(cpThis.next.cp, cpThis.cp) > 0) {
-                
-            curvePieces.push(
-                { curve: posThis.curve, ts: [posThis.t, posNext.t] }
-            );
-        } else {
-            curvePieces.push(
-                { curve: posThis.curve, ts: [posThis.t, 1] }
-            );
-            
-            if (posThis.curve.loop === posNext.curve.loop) {
-                addSkippedBeziers(
-                        curvePieces, 
-                        posThis.curve, 
-                        posNext.curve,
-                        posNext.t
-                );
-            }
+
+        if (curveNext === curveThis &&
+            comparePoss(posNext, posThis) > 0) {
+
+            // The boundary stays on the same curve segment *and* the next pos
+            // is further along the *linear* boundary. If it is *not* further
+            // on the *linear* boundary then this pos precedes the abrupt break
+            // in the ordering and next pos comes after the break so the code in
+            // the next `else` statement is called to skip over the break.
+            // The other case in which `comparePoss(posNext, posThis) <= 0` is
+            // possible for hole closers where the oderering of this and next
+            // are the same except for `order2`
+            curvePieces.push({
+                curve: curveThis, ts: [posThis.t, posNext.t]
+            });
+
+            cpThis = cpThis.next;
+            continue;
         }
-        
+
+        // The segment crosses a curve boundary because either:
+        // 1. `this` and `next` are not on the same curve OR
+        // 2. `this` comes after `next` by ordering
+        // so split at t = 1.
+
+        if (curveThis.loop === curveNext.loop) {
+            const initialCurvePiece = {
+                curve: curveThis, ts: [posThis.t, 1]
+            };
+            curvePieces.push(initialCurvePiece);
+
+            // Fill in any curves skipped between the two points.
+            addSkippedBeziers(curvePieces, curveThis, curveNext, posNext.t);
+
+            // NOTE❗ Currently removed stichables; we're just checking for duplicates
+            // later in `find2Prong`; KEEP for possible future use.
+            // const finalCurvePiece = curvePieces[curvePieces.length - 1];
+            // if (initialCurvePiece.curve === finalCurvePiece!.curve) {
+            //     const { ts: tsS } = initialCurvePiece;
+            //     const { ts: tsE } = finalCurvePiece!;
+
+            //     // If it is a closed loop we must join the endpoints to prevent duplicate
+            //     // antipodal points later
+            //     if (tsS[0] === tsE[1]) {
+            //         initialCurvePiece.ts[0] = tsE[0];
+
+            //         if (curvePieces.length > 1) {
+            //             curvePieces.pop();
+            //         }
+            //         // console.log('was inner closed loop')
+            //     }
+            // }
+        }
+
         cpThis = cpThis.next;
     } while (cpThis !== cpEnd);
 
+    // NOTE❗ Currently removed stichables; we're just checking for duplicates
+    // later in `find2Prong`; KEEP for possible future use.
+    // if (stichables.size > 0) {
+    //     for (const [loop,idxs] of stichables.entries()) {
+    //         if (idxs.length === 2) {
+    //             const curvePieceS = curvePieces[idxs[0]]!;
+    //             const curvePieceE = curvePieces[idxs[1]]!;
+
+    //             if (curvePieceS === undefined || curvePieceE === undefined) {
+    //                 console.log(curvePieceS);
+    //                 console.log(curvePieceE);
+    //                 continue;
+    //             }
+
+    //             const { curve: curveS, ts: tsS } = curvePieceS;
+    //             const { curve: curveE, ts: tsE } = curvePieceE;
+    //             if (curveS !== curveE) {
+    //                 continue;
+    //             }
+
+    //             // If it is a closed loop we must join the endpoints to prevent duplicate
+    //             // antipodal points later
+    //             if (tsS[0] === tsE[1]) {
+    //                 curvePieceS.ts[0] = tsE[0];
+    //                 // console.log('was closed loop 1')
+    //             } else if (tsE[0] === tsS[1]) {
+    //                 curvePieceS.ts[1] = tsE[1];
+    //                 // console.log('was closed loop 2')
+    //             }
+    //             if (idxs[0] !== idxs[1]) {
+    //                 curvePieces[idxs[1]] = undefined;
+    //             }
+    //         }
+    //     }
+    // }
+
+    // NOTE❗ The below endcurve check is not enough for specific cases involving
+    // multiple hole closers; KEEP for now but must use stichables instead
+    // if (curvePieces[0]!.curve === curvePieces[curvePieces.length - 1]!.curve) {
+    //     const { ts: tsS } = curvePieces[0]!;
+    //     const { ts: tsE } = curvePieces[curvePieces.length - 1]!;
+
+    //     // If it is a closed loop we must join the endpoints to prevent duplicate
+    //     // antipodal points later
+    //     if (tsS[0] === tsE[1]) {
+    //         curvePieces[0]!.ts[0] = tsE[0];
+
+    //         if (curvePieces.length > 1) {
+    //             curvePieces.pop();
+    //         }
+    //         // console.log('was closed loop')
+    //     }
+    // }
 
     return curvePieces;
 }
@@ -72,11 +187,12 @@ function getBoundaryPieceBeziers(cpNodes: CpNode[]): CurvePiece[] {
  * Adds pieces of skipped beziers
  */
 function addSkippedBeziers(
-        curvePieces: CurvePiece[], 
+        curvePieces: (CurvePiece | undefined)[], 
         curveStart: Curve, 
         curveEnd: Curve, 
         t1: number) {
 
+    // Walk forward through the loop until the end curve is reached.
     let curveThis = curveStart;
     do {
         curveThis = curveThis.next;

package/src/mat/get-branches.ts

@@ -1,4 +1,4 @@
-import { CpNode } from '../cp-node/cp-node.js';
+import type { CpNode } from '../cp-node/cp-node.js';
 import { getBranch } from '../cp-node/fs/get-branch.js';
 import { getNonTerminatingOnCircle } from '../cp-node/fs/get-non-terminating-on-circle.js';
 

package/src/mat/get-closeby-cp-if-exist.ts

@@ -1,11 +1,9 @@
-import { LlRbTree } from 'flo-ll-rb-tree';
+import type { CpNode } from '../cp-node/cp-node.js';
+import type { PrePointOnShape } from '../point-on-shape/point-on-shape.js';
+import type { Circle } from '../geometry/circle.js';
+import type { MatMeta } from './mat-meta.js';
 import { distanceBetween, toUnitVector, fromTo, dot } from 'flo-vector2d';
-import { Loop } from 'flo-boolean';
-import { CpNode } from '../cp-node/cp-node.js';
-import { PointOnShape } from '../point-on-shape/point-on-shape.js';
-import { Circle } from '../geometry/circle.js';
 import { getCpNodeToLeftOrSame } from './get-cp-node-to-left-or-same.js';
-import { MatMeta } from './mat-meta.js';
 
 
 /** @internal */
@@ -26,16 +24,16 @@ const ANGLE_THRESHOLD = Math.cos(DEGREES * (Math.PI / 180));
  */
 function getCloseByCpIfExist(
         meta: MatMeta,
-        pos: PointOnShape,
+        pos: PrePointOnShape,
         circle: Circle,
         order: number,
         order2: number,
         forProngCount?: number): CpNode | undefined {
 
-    const { cpTrees, maxCoordinate } = meta;
+    const { cpTrees, maxCoordPowerOf2 } = meta;
 
-    const DISTANCE_THRESHOLD = maxCoordinate * 2e-14;
-    const DISTANCE_THRESHOLD_2 = DISTANCE_THRESHOLD * 2e-2;
+    const DISTANCE_THRESHOLD = 2**(maxCoordPowerOf2 - 40);  // approx. 1e-9 for 1024 x 1024 shapes
+    const DISTANCE_THRESHOLD_2 = 2**(maxCoordPowerOf2 - 46);
 
     const cpTree = cpTrees.get(pos.curve.loop)!;
     const cur = getCpNodeToLeftOrSame(cpTree, pos, order, order2);
@@ -44,14 +42,15 @@ function getCloseByCpIfExist(
 
     const { p, t } = pos;
     for (const cpNode of cpNodes) {
-        const pos2 = cpNode.cp.pointOnShape;
+        const pos2 = cpNode.pointOnShape;
         const p2 = pos2.p;
         const d = distanceBetween(p,p2);
         if (d > DISTANCE_THRESHOLD) {
             continue;
         }
+        // return cpNode;
 
-        const v1 = toUnitVector(fromTo(p2, cpNode.cp.circle.center));
+        const v1 = toUnitVector(fromTo(p2, cpNode.pointOnShape.circle.center));
         const v2 = toUnitVector(fromTo(p, circle.center));
         const cosTheta = dot(v1,v2);
 

package/src/mat/get-cp-node-to-left-or-same.ts

@@ -1,6 +1,6 @@
+import type { PrePointOnShape } from '../point-on-shape/point-on-shape.js';
+import type { CpNode } from '../cp-node/cp-node.js';
 import { LlRbTree } from 'flo-ll-rb-tree';
-import { PointOnShape } from '../point-on-shape/point-on-shape.js';
-import { CpNode } from '../cp-node/cp-node.js';
 
 
 /**
@@ -18,12 +18,12 @@ import { CpNode } from '../cp-node/cp-node.js';
  */
 function getCpNodeToLeftOrSame(
         cpTree: LlRbTree<CpNode>,
-        pos: PointOnShape,
+        pos: PrePointOnShape,
         order: number,
         order2: number): CpNode | undefined {
 
-    const cp = { pointOnShape: pos, order, order2 };
-    const cps = cpTree.findBounds({ cp } as unknown as CpNode);
+    const pointOnShape = { ...pos, order, order2 };
+    const cps = cpTree.findBounds({ pointOnShape } as CpNode);
 
     if (cps[0] === undefined && cps[1] === undefined) { 
         // The tree is still empty

package/src/mat/get-largest-3-prong.ts

@@ -1,4 +1,4 @@
-import { CpNode } from '../cp-node/cp-node.js';
+import type { CpNode } from '../cp-node/cp-node.js';
 import { getAllOnLoop } from '../cp-node/fs/get-all-on-loop.js';
 import { getRealProngCount } from '../cp-node/fs/get-real-prong-count.js';
 
@@ -11,7 +11,7 @@ function getLargest3Prong(cpNode: CpNode) {
     if (cpNodes.length === 0) { return undefined; }
 
     return cpNodes.reduce(function(maxCpNode: CpNode, cpNode: CpNode) {
-        return maxCpNode.cp.circle.radius >= cpNode.cp.circle.radius
+        return maxCpNode.pointOnShape.circle.radius >= cpNode.pointOnShape.circle.radius
             ? maxCpNode
             : cpNode
     }, cpNodes[0]);

package/src/mat/get-largest-vertex.ts

@@ -1,4 +1,4 @@
-import { CpNode } from '../cp-node/cp-node.js';
+import type { CpNode } from '../cp-node/cp-node.js';
 import { getAllOnLoop } from '../cp-node/fs/get-all-on-loop.js';
 
 
@@ -7,7 +7,7 @@ function getLargestVertex(cpNode: CpNode) {
     const cpNodes = getAllOnLoop(cpNode);
 
     return cpNodes.reduce(function(maxCpNode: CpNode, cpNode: CpNode) {
-        return maxCpNode.cp.circle.radius >= cpNode.cp.circle.radius
+        return maxCpNode.pointOnShape.circle.radius >= cpNode.pointOnShape.circle.radius
             ? maxCpNode
             : cpNode
     }, cpNodes[0]);

package/src/mat/mat-meta.ts

@@ -1,12 +1,13 @@
+import type { Loop } from 'flo-boolean';
+import type { CpNode } from '../cp-node/cp-node.js';
+import type { Curve } from 'flo-boolean';
+import type { TriMap } from '../utils/tri-map.js';
 import { LlRbTree } from 'flo-ll-rb-tree';
-import { Loop } from 'flo-boolean';
-import { CpNode } from '../cp-node/cp-node.js';
-import { Curve } from '../curve/curve.js';
-import { TriMap } from '../utils/tri-map.js';
 
 
 interface MatMeta {
-    readonly maxCoordinate: number;
+    /** The minimum power of 2 such that `2**maxCoordPowerOf2 >= "the max coordinate"` */
+    readonly maxCoordPowerOf2: number;
     readonly squaredDiagonalLength: number;
     readonly looseBoundingBoxes: number[][][];
     readonly tightBoundingBoxes: number[][][];
@@ -24,7 +25,7 @@ interface MatMeta {
      */
     readonly cpTrees: Map<Loop, LlRbTree<CpNode>>;
     /** A map from a bezier and t value to a `PointOnShape` */
-    readonly pointToCpNode: TriMap<Loop,number,number,CpNode>;
+    // readonly pointToCpNode: TriMap<Loop,number,number,CpNode>;
     /**
      * Stores the last insert id so each `CpNode` can have a unique id for
      * debugging purposes

package/src/mat/mat.ts

@@ -1,5 +1,5 @@
-import { CpNode } from '../cp-node/cp-node.js';
-import { MatMeta } from './mat-meta.js';
+import type { CpNode } from '../cp-node/cp-node.js';
+import type { MatMeta } from './mat-meta.js';
 
 
 /**
@@ -12,15 +12,15 @@ import { MatMeta } from './mat-meta.js';
  */
 interface Mat {
     /** A complete representation of the MAT. See `CpNode`. */
-    cpNode: CpNode;
+    readonly cpNode: CpNode;
     /**
      * Stores additional info about the shape that could be useful for various
      * purposes in post-processing.
      * 
      * Most meta items have a CpNode property to link back to the MAT.
      */
-    meta: MatMeta;
+    readonly meta: MatMeta;
 }
 
 
-export { Mat }
+export type { Mat }

package/src/mat/simplify-mat.ts

@@ -1,30 +1,33 @@
+import type { Mat } from './mat.js';
+import type { CpNode } from '../cp-node/cp-node.js';
 import { hausdorffDistanceOneSided } from 'flo-bezier3';
-import { CpNode } from '../cp-node/cp-node.js';
 import { removeVertex } from '../vertex/remove-vertex.js';
 import { getBranches } from './get-branches.js';
 import { getMatCurveToNext } from '../cp-node/fs/get-mat-curve-to-next.js';
 import { getMatCurveBetween } from '../cp-node/fs/get-mat-curve-between.js';
-import { Mat } from './mat.js';
-import { createNewCpTree } from './create-new-cp-tree.js';
+import { createNewCpTrees } from './create-new-cp-trees.js';
 import { clone } from '../cp-node/fs/clone.js';
 import { findFirst } from '../cp-node/fs/find-first.js';
 import { isTerminating } from '../cp-node/fs/is-terminating.js';
 import { isVertex } from '../cp-node/fs/is-vertex.js';
 import { getProngCount } from '../cp-node/fs/get-prong-count.js';
 
+const { max } = Math;
 
 
-// TODO2 could be made faster by binary "search" on hausdorff curves
+// FUTURE could be made faster by binary "search" on hausdorff curves?
 /**
- * Simplifies the given MAT by replacing the piecewise quad beziers composing 
- * the MAT with fewer ones to within a given tolerance.
- * @param cpNode A representation of the MAT
- * @param anlgeTolerance Tolerance given as the degrees difference of the unit 
+ * Returns a new simplified MAT of the given one by replacing the piecewise
+ * quad beziers composing the MAT with fewer ones to within a given tolerance.
+ * 
+ * @param cpNode a representation of the MAT
+ * @param anlgeTolerance tolerance given as the degrees difference of the unit
  * direction vectors at the interface between curves. A tolerance of zero means
- * perfect smoothness is required - defaults to 15.
- * @param hausdorffTolerance The approximate maximum Hausdorff Distance tolerance -
+ * perfect smoothness is required - defaults to 15
+ * @param hausdorffTolerance the approximate maximum Hausdorff Distance tolerance -
  * defaults to `2**-3`
- * @param maxIterations The max iterations, defaults to `50`
+ * @param maxIterations the max iterations of the Hausdorff Distance calculation,
+ * defaults to `50`
  */
 function simplifyMat(
         mat: Mat,
@@ -60,14 +63,14 @@ function simplifyMat(
                 }
             }
 
-            if (i+1 === j) { 
-                // no simplification occured
-                continue;
+            if (i+1 === j) {
+                continue;  // no simplification occured
             }
         }
     }
 
-    cpNode = findFirst(cpNode_ => isTerminating(cpNode_) ? cpNode_ : undefined, cpNode)!;
+    // cpNode = findFirst(cpNode_ => isTerminating(cpNode_) ? cpNode_ : undefined, cpNode)!;
+    cpNode = findFirst(isTerminating, cpNode)!;
 
     for (const cpNode of canDeletes) {
         if (!isVertex(cpNode =>
@@ -84,7 +87,7 @@ function simplifyMat(
         cpNode,
         meta: {
             ...mat.meta,
-            cpTrees: createNewCpTree(cpNode)
+            cpTrees: createNewCpTrees(cpNode)
         }
     }
 }
@@ -106,7 +109,7 @@ function getTotalHausdorffDistance(
         ));
     }
 
-    return Math.max(...hds);
+    return max(...hds);
 }
 
 

package/src/mat/trim-mat.ts

@@ -1,15 +1,17 @@
-import { Mat } from './mat.js';
-import { createNewCpTree } from './create-new-cp-tree.js';
+import type { Mat } from './mat.js';
+import { createNewCpTrees } from './create-new-cp-trees.js';
 import { cullNonCycles } from '../sat/cull-non-cycles.js';
 import { clone } from '../cp-node/fs/clone.js';
 
 
 /**
  * Trims the given Medial Axis Transform so that only cycles remain. Similar to
- * toScaleAxis(mat, Number.POSITIVE_INFINITY).
+ * toScaleAxis(mat, Infinity).
+ * 
  * @param mat The MAT to trim.
  */
 function trimMat(mat: Mat): Mat {
+    // FUTURE - clone entire `Mat` instead (the function already exists)
     const cpNode = cullNonCycles(clone(mat.cpNode));
 
     if (!cpNode) { return undefined!; }
@@ -18,7 +20,7 @@ function trimMat(mat: Mat): Mat {
         cpNode,
         meta: {
             ...mat.meta,
-            cpTrees: createNewCpTree(cpNode)
+            cpTrees: createNewCpTrees(cpNode)
         }
     }
 }

package/src/point-on-shape/calc-pos-order.ts

@@ -1,31 +1,30 @@
+import type { Curve } from "flo-boolean";
 import { dot, fromTo, rotateNeg90Degrees, toUnitVector } from "flo-vector2d";
-import { Circle } from "../geometry/circle.js";
-import { PointOnShape } from "./point-on-shape.js";
 import { isPosCorner } from './is-pos-corner.js';
-import { getPosCorner } from './get-pos-corner.js';
-
+import { getPosCorner$ } from './get-pos-corner.js';
 
 
 /**
- * @internal
- * 
  * Calculates the order (to distinguish between points lying on top of each 
  * other) of the contact point if it is a dull corner.
  * 
  * @param circle
  * @param pos
+ * 
+ * @internal
  */
 function calcPosOrder(
-        circle: Circle, 
-        pos: PointOnShape): number {
+        circleCenter: number[], 
+        pos: { t: number, curve: Curve, p: number[] }): number {
 
     if (!isPosCorner(pos)) { return 0; }
-    if (!getPosCorner(pos).isDull) { return 0; }
 
-    const corner = getPosCorner(pos);
+    const corner = getPosCorner$(pos);
+
+    if (!corner.isDull) { return 0; }
 
     const n = rotateNeg90Degrees(corner.tangents[0]);
-    const v = toUnitVector( fromTo(pos.p, circle.center) );
+    const v = toUnitVector( fromTo(pos.p, circleCenter) );
 
     return -dot(n, v);
 }

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

@@ -3,9 +3,13 @@ import { PointOnShape } from "./point-on-shape.js";
 
 /**
  * Compares two `PointOnShape`s according to their cyclic ordering imposed
- * by their relative positions on the shape boundary. 
+ * by their relative positions on the shape boundary.
+ * 
+ * * Returns a +tive value if `a` is "further along" the loop
+ * 
  * @param a The first `PointOnShape`.
  * @param b The second `PointOnShape`.
+ * 
  * @internal
  */
 function comparePoss(
@@ -18,6 +22,12 @@ function comparePoss(
     if (res !== 0) { return res; }
 
     res = a.t - b.t;
+    if (res !== 0) { return res; }
+
+    res = a.order - b.order;
+    if (res !== 0) { return res; }
+
+    res = a.order2 - b.order2;
 
     return res;
 }

package/src/point-on-shape/get-osculating-circle.ts

@@ -1,41 +1,38 @@
-import { tangentExact, ddCurvature } from 'flo-bezier3';
-import { Circle } from '../geometry/circle.js';
-import { PointOnShape } from './point-on-shape.js';
+import type { PrePointOnShape } from './point-on-shape.js';
+import { ddCurvature } from 'flo-bezier3';
 
+const { sqrt } = Math;
 
 
 /**
  * Returns the osculating circle at this point of the curve.
  * 
- * @param minCurvature If not Number.POSITIVE_INFINITY then the
- * circle radius will be limited to this value.
- * @param pos The `PointOnShape` identifying the point.
+ * @param minCurvature if not `Infinity` then the circle radius will be limited
+ * to this value
+ * @param pos the `PointOnShape` identifying the point
  * @param useMaxRadius
  */
 function getOsculatingCircle(
-        minCurvature: number, 
-        pos: PointOnShape,
-        // pos: { p: number[], t: number },
-        useMaxRadius = false): Circle {
-
-    const ps = pos.curve.ps;
-    const { p, t } = pos;
-
-    let k = -ddCurvature(ps, t);
-
-    if (k < minCurvature || useMaxRadius) {
-        k = minCurvature;
-    }
-
-    const tangent_ = tangentExact(ps,t).map(c => c[c.length-1]);
-    const normal_ = [-tangent_[1],tangent_[0]];
-    const l = Math.sqrt(normal_[0]**2 + normal_[1]**2);
-    const circleCenter = [
-        p[0] - normal_[0]/(k*l),
-        p[1] - normal_[1]/(k*l)
-    ];
+        maxOsculatingCircleRadius: number, 
+        pos: PrePointOnShape,
+        norm: number[]): [number[],number] {
+
+    const { curve, p, t } = pos;
+    const { ps } = curve;
+
+    const minCurvature = 1/maxOsculatingCircleRadius;
 
-    return { center: circleCenter, radius: 1/k };
+    const k_ = -(ddCurvature(ps, t)[1]);
+    const k = k_ < minCurvature ? minCurvature : k_;
+
+    const [tx, ty] = norm;
+    const l = sqrt(tx*tx + ty*ty);
+    const scale = l*k;
+
+    return [
+        [p[0] + tx/scale, p[1] + ty/scale],
+        1/k
+    ];
 }