flo-mat 3.0.15 → 4.0.1

package/src/find-2-prong/add-1-prong.ts

@@ -1,11 +1,11 @@
+import type { PrePointOnShape } from '../point-on-shape/point-on-shape.js';
+import type { Circle } from '../geometry/circle.js';
+import type { MatMeta } from '../mat/mat-meta.js';
 import { addToCpTree } from '../mat/add-to-cp-tree.js';
 import { getCloseByCpIfExist } from '../mat/get-closeby-cp-if-exist.js';
-import { PointOnShape } from '../point-on-shape/point-on-shape.js';
 import { calcPosOrder } from '../point-on-shape/calc-pos-order.js';
-import { Circle } from '../geometry/circle.js';
-import { MatMeta } from '../mat/mat-meta.js';
 import { isPosCorner } from '../point-on-shape/is-pos-corner.js';
-import { getPosCorner } from '../point-on-shape/get-pos-corner.js';
+import { getPosCorner$ } from '../point-on-shape/get-pos-corner.js';
 
 
 /**
@@ -18,12 +18,12 @@ function add1Prong(
         meta: MatMeta,
         radius: number,
         center: number[],
-        pos: PointOnShape) {
+        pos: PrePointOnShape) {
 
-    if (isPosCorner(pos) && getPosCorner(pos).isDull) {
+    if (isPosCorner(pos) && getPosCorner$(pos).isDull) {
         // This is a 1-prong at a dull corner.
         
-        // TODO IMPORTANT 
+        // FUTURE
         // Remove this line, uncomment piece below it and implement the 
         // following strategy to find the 3-prongs: if deltas are conjoined due 
         // to dull corner, split the conjoinment by inserting successively 
@@ -43,7 +43,7 @@ function add1Prong(
     
     const circle: Circle = { radius, center };
     
-    const order = calcPosOrder(circle, pos);
+    const order = calcPosOrder(circle.center, pos);
     // Make sure there isn't already a ContactPoint close by - it can cause
     // floating point stability issues.
     if (getCloseByCpIfExist(meta, pos, circle, order, 0, 1)) {

package/src/find-2-prong/add-2-prong.ts

@@ -1,51 +1,61 @@
-import { LlRbTree } from 'flo-ll-rb-tree';
-import { Loop } from 'flo-boolean';
-import { CpNode } from '../cp-node/cp-node.js';
-import { Circle } from '../geometry/circle.js';
-import { PointOnShape } from '../point-on-shape/point-on-shape.js';
+import type { CpNode } from '../cp-node/cp-node.js';
+import type { Circle } from '../geometry/circle.js';
+import type { PointOnShape, PrePointOnShape } from '../point-on-shape/point-on-shape.js';
+import type { MatMeta } from '../mat/mat-meta.js';
+import type { Mutable } from '../utils/mutable.js';
 import { calcPosOrder } from '../point-on-shape/calc-pos-order.js';
-import { createPos } from '../point-on-shape/create-pos.js';
 import { getCloseByCpIfExist } from '../mat/get-closeby-cp-if-exist.js';
-import { MatMeta } from '../mat/mat-meta.js';
 import { insertCpNode } from '../cp-node/fs/insert-cp-node.js';
 import { addToCpTree } from '../mat/add-to-cp-tree.js';
 import { removeCpNode } from '../cp-node/fs/remove-cp-node.js';
 
 
 /**
- * @internal
  * Adds a 2-prong contact circle to the shape.
  *
- * @param cpTrees
+ * @param meta
  * @param circle Circle containing the 2 contact points
- * @param posSource The source point on shape
- * @param posAntipode The found antipodal point on shape
+ * @param pposSource The source point on shape
+ * @param pposAntipode The found antipodal point on shape
  * @param isHoleClosing True if this is a hole-closing 2-prong, false otherwise
- * @param maxCoordinate The maximum coordinate value used to calculate floating point
- * tolerances.
+ * 
+ * @internal
  */
 function add2Prong(
         meta: MatMeta,
         circle: Circle,
-        poss: PointOnShape[],
+        pposSource: PrePointOnShape,
+        pposAntipode: PrePointOnShape,
         isHoleClosing: boolean): CpNode | undefined {
 
-    poss[0] = poss[0].t === 0
-        ? createPos(poss[0].curve.prev, 1, true)
-        : poss[0];
+    pposSource = pposSource.t === 0
+        ? { ...pposSource, curve: pposSource.curve.prev, t: 1 }
+        : pposSource;
 
-    const orders = poss.map(pos => calcPosOrder(circle, pos));
+    const orderSource = calcPosOrder(circle.center, pposSource);
+    const orderAntipode = calcPosOrder(circle.center, pposAntipode);
+
+    const posAntipode: PointOnShape = {
+        ...pposAntipode, circle, order: orderAntipode, order2: 0
+    };
+    const posSource: PointOnShape = {
+        ...pposSource, circle, order: orderSource, order2: 0
+    }
 
     // Make sure there isn't already a ContactPoint close by - it can cause
     // floating point stability issues.
-    for (let i=0; i<poss.length; i++) {
-        if (!!getCloseByCpIfExist(meta, poss[i], circle, orders[i], 0, 2)) {
-            return undefined;
-        }
+    if (!!getCloseByCpIfExist(meta, pposSource, circle, orderSource, 0, 2)) {
+        return undefined;
+    }
+    if (!!getCloseByCpIfExist(meta, pposAntipode, circle, orderAntipode, 0, 2)) {
+        return undefined;
     }
 
     const { anyFailed, cpNodes } = addToCpTree(
-        isHoleClosing, isHoleClosing, circle, orders, meta, poss
+        isHoleClosing, isHoleClosing, circle,
+        [orderSource, orderAntipode],
+        meta,
+        [posSource, posAntipode]
     );
 
     if (anyFailed) {
@@ -57,9 +67,6 @@ function add2Prong(
         return undefined;
     }
 
-    // Get points ordered according to their angle with the x-axis
-    // joinSpokes(circle, cpNodes);
-
     if (isHoleClosing) { 
         closeHole(meta, cpNodes as CpNode[]);
     }
@@ -74,44 +81,43 @@ function closeHole(
 
     const { cpTrees } = meta;
 
-    const [cpNodeA, cpNodeB] = cpNodes;
-    // Duplicate ContactPoints
-    // const antipodeCpNode = cpNodeB[0];
-    const cpAntipode = cpNodeB.cp;
-
-    const cpNodeB2 = insertCpNode(
-        true,
-        true, false,
-        cpTrees.get(cpAntipode.pointOnShape.curve.loop)!,
-        { ...cpAntipode, order2: +1 },
-        cpNodeB,
+    const [cpNodeSource, cpNodeAntipode] = cpNodes as Mutable<CpNode>[];
+
+    // Antipode - create and insert twin
+    const posAntipode = cpNodeAntipode.pointOnShape;
+    const cpNodeAntipodeTwin = insertCpNode(
+        true, true, false,
+        cpTrees.get(posAntipode.curve.loop)!,
+        { ...posAntipode, order2: +1 },
+        cpNodeAntipode,
         meta.lastInsertId
-    )!;
-    cpNodeB2.holeCloserTwin = cpNodeB;
-    cpNodeB.holeCloserTwin = cpNodeB2;
-
-    const cpNodeB1 = insertCpNode(
-        true,
-        true, false,
-        cpTrees.get(cpNodeA.cp.pointOnShape.curve.loop)!,
-        { ...cpNodeA.cp, order2: -1 },
-        cpNodeA.prev,
+    )! as Mutable<CpNode>;
+    cpNodeAntipodeTwin.holeCloserTwin = cpNodeAntipode;
+    cpNodeAntipode.holeCloserTwin = cpNodeAntipodeTwin;
+
+    // Source - create and insert twin
+    const posSource = cpNodeSource.pointOnShape;
+    const cpNodeSourceTwin = insertCpNode(
+        true, true, false,
+        cpTrees.get(posSource.curve.loop)!,
+        { ...cpNodeSource.pointOnShape!, order2: -1 },
+        cpNodeSource.prev,
         meta.lastInsertId
-    )!;
-    cpNodeB1.holeCloserTwin = cpNodeA;
-    cpNodeA.holeCloserTwin = cpNodeB1;
+    )! as Mutable<CpNode>;
+    cpNodeSourceTwin.holeCloserTwin = cpNodeSource;
+    cpNodeSource.holeCloserTwin = cpNodeSourceTwin;
 
     // Connect graph
-    cpNodeB1.prevOnCircle = cpNodeB2;
-    cpNodeB1.nextOnCircle = cpNodeB2;
-    cpNodeB2.prevOnCircle = cpNodeB1;
-    cpNodeB2.nextOnCircle = cpNodeB1;
+    cpNodeSourceTwin.prevOnCircle = cpNodeAntipodeTwin;
+    cpNodeSourceTwin.nextOnCircle = cpNodeAntipodeTwin;
+    cpNodeAntipodeTwin.prevOnCircle = cpNodeSourceTwin;
+    cpNodeAntipodeTwin.nextOnCircle = cpNodeSourceTwin;
 
-    cpNodeB.next = cpNodeA;
-    cpNodeA.prev = cpNodeB;
+    cpNodeAntipode.next = cpNodeSource;
+    cpNodeSource.prev = cpNodeAntipode;
 
-    cpNodeB1.next = cpNodeB2;
-    cpNodeB2.prev = cpNodeB1;
+    cpNodeSourceTwin.next = cpNodeAntipodeTwin;
+    cpNodeAntipodeTwin.prev = cpNodeSourceTwin;
 }
 
 

package/src/find-2-prong/calc-seperation-tolerance.ts

@@ -1,14 +1,11 @@
-import { ddAddDd, ddMultDd, twoSum, twoProduct, ddDiffDd, ddDivDd, twoDiff, ddMultDouble1 } from 'double-double';
+import { ddAddDd, twoProduct, ddDiffDd, ddDivDd, twoDiff, ddMultDouble1 } from 'double-double';
 
-const ts = twoSum;
 const tp = twoProduct;
-const td = twoDiff;
 const qaq = ddAddDd;
-const qmq = ddMultDd;
 const qdq = ddDiffDd;
 const qmd = ddMultDouble1;
 
-const { asin, acos, cos, sqrt, PI: π } = Math;
+const { acos } = Math;
 
 
 /**
@@ -25,10 +22,9 @@ function calcSeperationTolerance(
 
     const a = r + δ;
     if (a >= R) {
-        return Number.POSITIVE_INFINITY;
+        return Infinity;
     }
 
-
     const R_r_ = twoDiff(R,r);
     const A_  = qmd(r,R_r_);  
     const N_ = qdq(qdq(A_, tp(r,δ)), tp(δ,δ/2));
@@ -70,7 +66,7 @@ export { calcSeperationTolerance }
 
 //     const a = r + δ;
 //     if (a >= R) {
-//         return Number.POSITIVE_INFINITY;
+//         return Infinity;
 //     }
 
 //     const b = R - r;

package/src/find-2-prong/cull-bezier-pieces.ts

@@ -1,41 +1,61 @@
+import type { CurvePiece } from '../mat/curve-piece.js';
 import { getClosestSquareDistanceToRect } from '../geometry/get-closest-square-distance-to-rect.js';
-import { CurvePiece } from '../mat/curve-piece.js';
 import { getBoundingBox$ } from '../geometry/get-bounding-box-.js';
+import { memoize } from 'flo-memoize';
+import { getBoundingBoxTight } from 'flo-bezier3';
+import { getClosestSquaredDistanceToRotatedRect } from '../geometry/get-closest-squared-distance-to-rotated-rect.js';
+
+
+const TOLERANCE = 1 + 2**-20;
+const getBoundingBoxTight$ = memoize(getBoundingBoxTight);
 
 
 /**
- * @internal
- * Cull all curvePieces not within given radius of a given point.
+ * Cull all `curvePieces` not within the given radius of a given point.
+ * 
  * @param extreme
  * @param curvePieces
- * @param p
- * @param rSquared
+ * @param xO
+ * @param xy2
+ * 
+ * @internal
  */
-function cullCurvePieces2(
+function cullCurvePieces(
         curvePieces: CurvePiece[], 
-        p: number[], 
-        rSquared: number) {
+        xO: number[], 
+        xy2: number): CurvePiece[] {
 
-    const TOLERANCE = 1 + 2**-10;
-
-    if (curvePieces.length <= 1) {
-        return curvePieces;
+    if (curvePieces.length <= 2) {
+        // Curve pieces can never be less than 2 at this stage since a curve
+        // endpoint will be shared between 2 curves
+        return curvePieces as CurvePiece[];
     }
 
-
-    const newPieces = [];
-    for (const curvePiece of curvePieces) {
-        const ps = curvePiece.curve.ps;
+    let lastIdx = 0;
+    for (let i=0; i<curvePieces.length; i++) {
+        const curvePiece = curvePieces[i];
+        const { ps } = curvePiece.curve;
         
         const rect = getBoundingBox$(ps);
-        const bd = getClosestSquareDistanceToRect(rect, p);
-        if (bd <= TOLERANCE*rSquared) {
-            newPieces.push(curvePiece);
+        const d = getClosestSquareDistanceToRect(rect, xO);
+        if (d <= TOLERANCE*xy2) {
+            const tightBoundingBox = getBoundingBoxTight$(ps);
+            const d2 = getClosestSquaredDistanceToRotatedRect(
+                tightBoundingBox,
+                xO
+            );
+
+            if (d2 <= TOLERANCE*xy2) {
+                curvePieces[lastIdx] = curvePiece;
+                lastIdx++;
+            }
         } 
     }
 
-    return newPieces;
+    curvePieces.length = lastIdx;
+
+    return curvePieces;
 }
 
 
-export { cullCurvePieces2 }
+export { cullCurvePieces }

package/src/find-2-prong/find-2-prong.ts

@@ -1,24 +1,24 @@
-import { distanceBetween, fromTo, interpolate, rotate, translate } from 'flo-vector2d';
-import { Circle } from '../geometry/circle.js';
-import { PointOnShape } from '../point-on-shape/point-on-shape.js';
-import { getOsculatingCircle } from '../point-on-shape/get-osculating-circle.js';
-import { findEquidistantPointOnLineDd } from './find-equidistant-point-on-line-dd.js';
+import type { Circle } from '../geometry/circle.js';
+import type { PrePointOnShape } from '../point-on-shape/point-on-shape.js';
+import type { MatMeta } from '../mat/mat-meta.js';
+import type { AntipodalPoint } from './get-medial/antipodal-point.js';
 import { getInitialCurvePieces } from './get-initial-bezier-pieces.js';
-import { getCloseBoundaryPointsCertified } from '../closest-boundary-point/get-close-boundary-points-certified.js';
+import { getAntipodalPoints } from './get-medial/get-antipodal-points.js';
 import { reduceRadius } from './reduce-radius.js';
 import { squaredDistanceBetweenDd } from './squared-distance-between-dd.js';
-import { cullCurvePieces2 } from './cull-bezier-pieces.js';
+import { cullCurvePieces } from './cull-bezier-pieces.js';
 import { add1Prong } from './add-1-prong.js';
-import { createPos } from '../point-on-shape/create-pos.js';
-import { MatMeta } from '../mat/mat-meta.js';
+import { toP } from '../point-on-shape/to-p.js';
 import { calcSeperationTolerance } from './calc-seperation-tolerance.js';
+import { getInitialX } from './get-initial-x.js';
+import { ddNormal } from 'flo-bezier3';
+import { rotate } from 'flo-vector2d';
 
 
-const { ceil, log2, max, sqrt, abs, sin, cos } = Math;
+const { sin, cos, max, sqrt } = Math;
 
 
 /**
- * @internal
  * Adds a 2-prong to the MAT. The first point on the shape boundary is given and 
  * the second one is found by the algorithm.
  * 
@@ -33,175 +33,126 @@ const { ceil, log2, max, sqrt, abs, sin, cos } = Math;
  *    d of dΩ as in Fig. 19."
  * In fact, we (and they) start by fixing one point on the boundary beforehand.
  * 
- * @param loops A shape represented by path loops
- * @param maxCoordinate The extreme coordinate value of the shape
- * @param squaredDiagonalLength The squared diagonal length of the shape 
- * bounding box.
- * @param y The source point of the 2-prong to be found
- * @param isHoleClosing True if this is a hole-closing two-prong, false otherwise
- * @param loopIdx The loop array index
+ * @param meta
+ * @param isHoleClosing `true` if this is a hole-closing two-prong, `false` otherwise
+ * @param for1Prong
+ * @param angle
+ * @param yPos the source point of the 2-prong to be found
+ * 
+ * @internal
  */
 function find2Prong(
-        meta: MatMeta,
-        isHoleClosing: boolean,
-        for1Prong: boolean,
-        angle: number,
-        y: PointOnShape): { circle: Circle, zs: PointOnShape[] } | undefined {
+        meta: MatMeta) {
 
-    const { loops, maxCoordinate, squaredDiagonalLength } = meta;
+    const { loops, maxCoordPowerOf2, squaredDiagonalLength } = meta;
 
-    const loop = y.curve.loop;
-
-    const MAX_ITERATIONS = 25;
-    const minSquaredSeperationTolerance = ((2**-21)*maxCoordinate)**2;
-    const errorTolerance = (2**-46)*maxCoordinate;
-    // const errorTolerance = (2**-28)*maxCoordinate;
+    //----------------------------
+    // Initialize some tolerances
+    //----------------------------
+    const minSquaredSeperationTolerance = (2**(maxCoordPowerOf2 - 21))**2;
+    const errorTolerance = 2**(maxCoordPowerOf2 - 46);
     const maxOsculatingCircleRadius = sqrt(squaredDiagonalLength);
-    const minCurvature = 1/maxOsculatingCircleRadius;
-    const oneProngTolerance = (2**-16)*maxCoordinate;
-
-    const [xO,rO] = getO(
-        angle, isHoleClosing, maxOsculatingCircleRadius, minCurvature, y
-    );
-
-    const p = y.p;
+    const oneProngTolerance = 2**(maxCoordPowerOf2 - 32);
+
+    return function find2ProngInner(
+            isHoleClosing: boolean,
+            for1Prong: boolean,
+            angle: number,
+            yPos: PrePointOnShape): { circle: Circle, z: PrePointOnShape } | undefined {
+
+        const { curve: { loop, ps }, t, p: y } = yPos;
+        const normDd = ddNormal(ps, t);
+        const _nnorm = [-normDd[0][1], -normDd[1][1]];  // Left-handed system (sorry)
+        const nnorm = isHoleClosing
+            ? [0, -maxOsculatingCircleRadius]
+            : (angle !== 0 ? rotate(sin(angle), cos(angle))(_nnorm) : _nnorm);
+
+        // Get initial kissing circle guess
+        let [xO,rO] = getInitialX(
+            angle, isHoleClosing, maxOsculatingCircleRadius, yPos, nnorm
+        );
+
+
+        // The boundary piece that should contain the other point of 
+        // the 2-prong circle. (Defined by start and end points).
+        const curvePieces = getInitialCurvePieces(
+            angle, isHoleClosing, loop, loops, meta, yPos, xO
+        );
+
+        // The lines below is an optimization.
+        const xy2 = reduceRadius(maxCoordPowerOf2, curvePieces, y, nnorm);
+        const xy = sqrt(xy2);
+
+        if (for1Prong && rO < (1 - oneProngTolerance)*xy) {
+            add1Prong(meta, rO, xO, yPos);
+            return undefined;
+        }
 
-    // The boundary piece that should contain the other point of 
-    // the 2-prong circle. (Defined by start and end points).
-    let curvePieces = getInitialCurvePieces(
-        angle, isHoleClosing, loop, loops, meta, y, { center: xO, radius: rO }
-    );
-    // console.log(curvePieces.length);
+        const l = sqrt(nnorm[0]**2 + nnorm[1]**2);
+        xO = [y[0] + nnorm[0]/l*xy, y[1] + nnorm[1]/l*xy];
 
-    /** The center of the two-prong (successively refined) */
-    let x = xO;
+        cullCurvePieces(curvePieces, xO, xy2);
 
-    // The lines below is an optimization.
-    const r_ = sqrt(reduceRadius(maxCoordinate, curvePieces, p, xO));
-    if (rO > r_) {
-        x = interpolate(p, xO, r_/rO);
-    }
+        const antipodalPoints = getAntipodalPoints(
+            maxCoordPowerOf2, nnorm, yPos,
+            for1Prong, angle,
+            curvePieces
+        );
 
-    /** The antipode of the two-prong (successively refined) */
-    let zs: PointOnShape[] = undefined!;
-    let z: PointOnShape = undefined!;
-
-    let i = 0;
-    while (i < MAX_ITERATIONS) {
-        const xy = squaredDistanceBetweenDd(x, y.p);
-
-        if (i < 2) { curvePieces = cullCurvePieces2(curvePieces, x, xy); }
-        const pow = max(0,ceil(log2(maxCoordinate/xy))) + 1;  // determines accuracy
-        // console.log(pow);
-        const _zs = getCloseBoundaryPointsCertified(
-            pow, curvePieces, x, y.curve, y.t,
-            for1Prong && i == 0 && rO !== 1/minCurvature,
-            angle
-        ).map(info => createPos(info.curve, info.t, false));
-
-        let maxD = Number.NEGATIVE_INFINITY;
-        let maxPos: PointOnShape = undefined!;
-        zs = [];
-        for (const z of _zs) {
-            if (z === undefined) { continue; }
-            const _yz = squaredDistanceBetweenDd(y.p, z.p);
-            if (_yz > maxD) {
-                maxD = _yz;
-                maxPos = z;
-            }
-            if (_yz !== 0) {
-                zs.push(z);
+        if (antipodalPoints.length !== 1) {
+            if (antipodalPoints.length === 0) { return undefined; }
+            if (!areAllAntipodesSame(antipodalPoints)) {
+                // At this point there is multiple antipodal points (zs) for the given
+                // source point so do not add the 2-prong, it will be caught when 
+                // adding 3+-prongs.
+                return undefined;
             }
         }
-        // z = zs[0];
-        const yz = maxD;
-        z = maxPos;
 
-        if (z === undefined || yz === 0) {
-            // addDebugInfo2(isHoleClosing);
-            return undefined;
-        }
+        const { x, d, curve, s } = antipodalPoints[0];
+        const z: PrePointOnShape = {
+            curve, t: s, isSource: false,
+            p: toP(curve.ps, s)
+        };
 
-        const xz = squaredDistanceBetweenDd(x, z.p);
+        const circle = { center: x, radius: d };
 
-        // if on first try
-        if (i === 0) {
-            if (rO < (1 - oneProngTolerance)*sqrt(xz)) {
-                // console.log('1prong');
-                add1Prong(meta, rO, xO, y);
-                return undefined;
-            }
-        }
-        
-        // if (typeof _debug_ !== 'undefined') { xs.push({ x, y, z: createPos(z.curve, z.t, false), t: y.t }); }
+        const yz = squaredDistanceBetweenDd(yPos.p, z.p);
+        const xz = squaredDistanceBetweenDd(x, z.p);
 
-    
         if (!isHoleClosing) {
-            const squaredSeperationTolerance = max(calcSeperationTolerance(
-                rO, sqrt(xz), 2**2*errorTolerance
-            ), minSquaredSeperationTolerance);
+            if (yz === 0) { return undefined; }
+
+            // The lines below eliminate cases where the found 2-prong is too
+            // close to a one-prong
+            const squaredSeperationTolerance = max(
+                calcSeperationTolerance(rO, sqrt(xz), 2**2*errorTolerance),
+                minSquaredSeperationTolerance
+            );
             if (yz <= squaredSeperationTolerance) {
-                // if (typeof _debug_ !== 'undefined') { console.log(`failed: seperation too small - ${sqrt(yz)}`); }
                 return undefined;
             } 
         }
 
-        // Find the point on the line connecting y with x that is
-        // equidistant from y and z. This will be our next x.
-        const nextX = findEquidistantPointOnLineDd(x, y.p, z.p);
-        const error = abs(sqrt(xy) - sqrt(xz));
-        // if (xy < xz) { return undefined; }
-        
-        x = nextX;
-
-        if (error < errorTolerance) {
-            break;
-        } 
-
-        i++;
-        
-        if (i === MAX_ITERATIONS) {
-            // Convergence was too slow.
-            // if (typeof _debug_ !== 'undefined') { console.log('failed (slow): max iterations reached'); }
-            return undefined;
-        }
+        return { circle, z };
     }
+}
 
-    const circle = { center: x, radius: distanceBetween(x, z.p) };
-
-    // if (typeof _debug_ !== 'undefined') { addDebugInfo(curvePieces, false, x, y, z, circle!, δ!, xs, isHoleClosing); }
 
-    // return { circle, zs };
-    // zs = zs.filter(z => z !== undefined)
-    return { circle, zs: [z] };
-}
+/** @internal */
+function areAllAntipodesSame(
+        app: AntipodalPoint[]): boolean {
 
+    const { curve, s: t } = app[0];
+    for (let i=1; i<app.length; i++) {
+        const { curve: curve_, s: t_ } = app[i];
 
-function getO(
-        angle: number,
-        isHoleClosing: boolean,
-        maxOsculatingCircleRadius: number,
-        minCurvature: number,
-        y: PointOnShape) {
-
-    let xO: number[];  // the original x to mitigate drift
-    const p = y.p;
-    let rO: number;
-    if (isHoleClosing) {
-        xO = [p[0], p[1] - maxOsculatingCircleRadius];
-        rO = maxOsculatingCircleRadius;
-    } else {
-        if (angle === 0) {
-            ({ center: xO, radius: rO } = getOsculatingCircle(minCurvature, y));
-        } else {
-            ({ center: xO, radius: rO } = getOsculatingCircle(minCurvature, y, true));
-            const v = fromTo(y.p, xO);
-            const v_ = rotate(sin(angle), cos(angle))(v);
-            xO = translate(y.p)(v_);
+        if (curve !== curve_ || t !== t_) {
+            return false;
         }
     }
 
-    return [xO,rO] as [number[],number];
+    return true;
 }