flo-mat 4.0.1 → 4.0.3

package/src/reconstruct-from-mat/get-all-on-loop-by-loop.ts

@@ -0,0 +1,52 @@
+import type { CpNode } from '../cp-node/cp-node.js';
+
+
+/**
+ * Returns all `CpNode`s on the MAT that this `CpNode` is part of 
+ * starting from the current one and going anti-clockwise around the shape.
+ */
+function getAllOnLoop_ByLoop(
+        cpNode: CpNode) {
+
+    const cpNodess: CpNode[][] = [];
+
+    const cpStarts: CpNode[] = [cpNode];
+    const cpStartSet = new Set(cpStarts);
+    if (cpNode.isHoleClosing) {
+        cpStartSet.add(cpNode.prevOnCircle.holeCloserTwin!);
+    }
+    cpStartSet.add(cpNode);
+
+    while (cpStarts.length > 0) {
+        const cpNodes: CpNode[] = [];
+
+        const cpStart = cpStarts.pop()!;
+        const _loop = cpStart.pointOnShape.curve.loop;
+        let cpNode = cpStart;
+
+        do {
+            const loop = cpNode.pointOnShape.curve.loop;
+            if (_loop === loop) {
+                cpNodes.push(cpNode);
+                cpNode = cpNode.next;
+                continue;
+            }
+
+            const twin = cpNode.holeCloserTwin!;
+            if (!cpStartSet.has(twin)) {
+                cpStartSet.add(twin);
+                cpStartSet.add(twin.prevOnCircle.holeCloserTwin!);
+                cpStarts.push(twin);
+            }
+
+            cpNode = cpNode.prev.holeCloserTwin!;
+        } while (cpNode !== cpStart);
+
+        cpNodess.push(cpNodes);
+    }
+
+    return cpNodess;
+}
+
+
+export { getAllOnLoop_ByLoop }

package/src/reconstruct-from-mat/get-bezier-piece-length.ts

@@ -0,0 +1,12 @@
+import type { BezierPiece } from "flo-bezier3";
+import { length } from 'flo-bezier3';
+
+
+function getBezierPieceLength(
+        bezierPiece: BezierPiece): number {
+
+    return length(bezierPiece.ts, bezierPiece.ps);
+}
+
+
+export { getBezierPieceLength }

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

@@ -0,0 +1,32 @@
+import type { BezierPiece } from 'flo-bezier3';
+import type { CpNode } from '../cp-node/cp-node.js';
+import { getBoundaryBezierPartsToNext } from '../cp-node/fs/get-boundary-bezier-parts-to-next.js';
+import { filterZeroLength } from "./filter-zero-length.js";
+import { isFullyTerminating } from './is-fully-terminating.js';
+
+
+function getBoundary(
+        cpNode: CpNode): {
+            boundaryBeziers: BezierPiece[];
+            boundaryBeziersOpp: BezierPiece[] | undefined;
+        } {
+
+    const cpNodeOpp = isFullyTerminating(cpNode)
+        ? undefined // no opposite boundary
+        : cpNode.next.prevOnCircle;
+
+    const boundaryBeziers =
+        filterZeroLength(getBoundaryBezierPartsToNext(cpNode));
+
+    const boundaryBeziersOpp = cpNodeOpp === undefined
+        ? undefined
+        : filterZeroLength(getBoundaryBezierPartsToNext(cpNodeOpp));
+
+    return {
+        boundaryBeziers,
+        boundaryBeziersOpp
+    };
+}
+
+
+export { getBoundary }

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

@@ -0,0 +1,24 @@
+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";
+
+
+function getCpNodessForSat(
+        sat: Mat): CpNode[][] {
+
+    let { cpNode } = sat;
+
+    while (!isFullyTerminating(cpNode)) {
+        cpNode = cpNode.next;
+    }
+    if (!isOnSameLoop(cpNode, cpNode.next)) {
+        cpNode = cpNode.holeCloserTwin!;
+    }
+
+    return getAllOnLoop_ByLoop(cpNode);
+}
+
+
+export { getCpNodessForSat }

package/src/reconstruct-from-mat/get-matching-beziers.ts

@@ -0,0 +1,46 @@
+import type { BezierPiece } from 'flo-bezier3';
+import type { CpNode } from '../cp-node/cp-node.js';
+import type { MatchedBeziers } from './matched-beziers.js';
+import { getMatCurveToNext } from '../cp-node/fs/get-mat-curve-to-next.js'
+import { splitTriPath } from './split-tri-path.js';
+import { getBoundary } from './get-boundary.js';
+import { isOnSameLoop } from '../cp-node/fs/is-on-same-loop.js';
+
+
+/**
+ * Returns a correspondence between boundary bezier curves and a medial axis
+ * bezier curve. They will later be interpolated.
+ * 
+ * @param cpNode the start `CpNode`
+ */
+function getMatchingBeziers(
+        cpNode: CpNode): MatchedBeziers[] | undefined {
+
+    const medialBezier: BezierPiece = {
+        ps: getMatCurveToNext(cpNode),
+        ts: [0,1]
+    };
+
+    if (cpNode.isHoleClosing &&  // short-circuit
+        !isOnSameLoop(cpNode, cpNode.next)) {
+
+        // We get here for half of hole-closers, as only half of hole-closers are on a different loop.
+        // This cpNode indicates we should connect the hole
+        // console.log('hole-closing dummy case');
+        return undefined;
+    }
+
+    const r = getBoundary(cpNode);
+    const { boundaryBeziers, boundaryBeziersOpp } = r;
+
+    const matchedBezierss: MatchedBeziers[] = splitTriPath(
+        boundaryBeziers,
+        medialBezier,
+        boundaryBeziersOpp ?? []
+    );
+
+    return matchedBezierss;
+}
+
+
+export { getMatchingBeziers }

package/src/reconstruct-from-mat/get-mbss-by-loop-per-sat.ts

@@ -0,0 +1,19 @@
+import type { Mat } from "../mat/mat.js";
+import { getSats2 } from "./get-sats2.js";
+import { getMbssByLoopWithOppArr } from "./get-mbss-by-loop-with-opp-arr.js";
+import { getCpNodessForSat } from "./get-cp-nodess-for-sat.js";
+
+
+function getMbssByLoopPerSat(
+        mats: Mat[],
+        satScale: number) {
+
+    const sats = getSats2(mats, satScale);
+
+    const cpNodessPerSat = sats.map(getCpNodessForSat);
+
+    return cpNodessPerSat.map(getMbssByLoopWithOppArr);
+}
+
+
+export { getMbssByLoopPerSat }

package/src/reconstruct-from-mat/get-mbss-by-loop-with-opp-arr.ts

@@ -0,0 +1,69 @@
+import type { CpNode } from "../cp-node/cp-node.js";
+import type { MatchedBeziers } from "./matched-beziers.js";
+import { getMatchingBeziers } from "./get-matching-beziers.js";
+import { isFullyTerminating } from "./is-fully-terminating.js";
+
+
+function getMbssByLoopWithOppArr(
+        cpNodess: CpNode[][]) {
+
+    const mbssByLoop: (MatchedBeziers[] | undefined)[][] = [];
+
+    /**
+     * An array with each entry being a pair of indices mapping from
+     * `MatchedBeziers[]` on one side to `MatchedBeziers[]` on the other side
+     */
+    const mbMap: Map<CpNode, [number,number]> = new Map();
+
+    for (let l=0; l<cpNodess.length; l++) {
+        const cpNodes = cpNodess[l];
+
+        const mbss: (MatchedBeziers[] | undefined)[] = [];
+        for (let i=0; i<cpNodes.length; i++) {
+            const cpNode = cpNodes[i];
+
+            mbMap.set(cpNode, [l,i]);
+
+            const mbs = getMatchingBeziers(cpNode);
+
+            mbss.push(mbs);
+        }
+
+        mbssByLoop.push(mbss);
+    }
+
+
+    const oppArr: [[number,number],[number,number]][] = [];
+
+    for (let l=0; l<cpNodess.length; l++) {
+        const cpNodes = cpNodess[l];
+
+        for (let i=0; i<cpNodes.length; i++) {
+            const cpNode = cpNodes[i];
+
+            const cpNodeOpp = isFullyTerminating(cpNode)
+                ? undefined // no opposite boundary
+                : cpNode.next.prevOnCircle;
+            
+            // if (cpNodeOpp === undefined) {
+            //     continue;
+            // }
+
+            const oppIdxs = cpNodeOpp === undefined
+                ? [255,65535] as [number,number]
+                : mbMap.get(cpNodeOpp);
+
+            const mbs = mbssByLoop[l][i];
+            if (oppIdxs !== undefined && mbs !== undefined) {
+                oppArr.push([[l,i], oppIdxs]);
+            } else {
+                oppArr.push([[l,i], [255,65535]]);
+            }
+        }
+    }
+
+    return { mbssByLoop, oppArr };
+}
+
+
+export { getMbssByLoopWithOppArr }

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

@@ -0,0 +1,25 @@
+import type { Mat } from '../mat/mat.js';
+import { findMats } from '../find-mat/find-mats.js';
+import { removeSatInducedTrivial3Prongs } from "./remove-sat-induced-trivial-3prongs.js";
+import { toScaleAxis } from '../sat/to-scale-axis.js';
+
+
+/**
+ * Returns the shape information.
+ * 
+ * @param font$$ the font from which the glyph outlines will be retrieved
+ * @param glyphId the glyph id for which the shape is to be retrieved
+ * @param options the options for SAT computation
+ */
+// TODO
+function getSats2(
+        mats: Mat[],
+        satScale: number): Mat[] {
+
+    const sats = mats.map(mat => toScaleAxis(mat, satScale));
+
+    return sats.map(removeSatInducedTrivial3Prongs);
+}
+
+
+export { getSats2 }

package/src/reconstruct-from-mat/is-fully-terminating.ts

@@ -0,0 +1,27 @@
+import type { CpNode } from '../cp-node/cp-node.js';
+import { getAllOnCircle } from '../cp-node/fs/get-all-on-circle.js';
+import { isTerminating } from '../cp-node/fs/is-terminating.js';
+import { isTrivial } from '../cp-node/fs/is-trivial.js';
+
+
+// TODO - DUPLICATE! -> likely other version needs fixing
+function isFullyTerminating(cpNode: CpNode) {
+    if (!isTerminating(cpNode)) {
+        return false;
+    }
+
+    if (isTrivial(cpNode)) {
+        return true;
+    }
+
+    while (cpNode.prev === cpNode.prevOnCircle) {
+        cpNode = cpNode.prev;
+    }
+
+    const otherOnCircle = getAllOnCircle(cpNode.prevOnCircle, true);
+
+    return otherOnCircle.every(isTerminating);
+}
+
+
+export { isFullyTerminating }

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

@@ -0,0 +1,14 @@
+import type { BezierPiece } from 'flo-bezier3';
+
+
+/**
+ * A type representing a correspondence between 3 bezier curves (one on the
+ * boundary, one on the medial axis and one on the opposite boundary)
+ */
+interface MatchedBeziers {
+    readonly medialBezier: BezierPiece;
+    readonly boundaryBezier: BezierPiece;
+}
+
+
+export type { MatchedBeziers }

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

@@ -0,0 +1,45 @@
+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';
+
+
+function reconstructFromMats(
+        mats: Mat[]) {
+
+    const loopss: number[][][][] = [];
+
+    const bzs: BezierPiece[] = [];
+
+    const mbssByLoopPerSat = getMbssByLoopPerSat(mats, 1.5)!;
+
+    for (const mbssByLoopPS of mbssByLoopPerSat) {
+        const { mbssByLoop, oppArr } = mbssByLoopPS;
+
+        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];
+
+                if (r === undefined) { continue; }
+
+                const matchedBezierss = r;
+
+                for (let j=0; j<matchedBezierss.length; j++) {
+                    const mb = matchedBezierss[j];
+                    const { boundaryBezier, medialBezier } = mb;
+
+                    bzs.push(boundaryBezier)
+                }
+            }
+        }
+    }
+
+
+    return bzs;
+    // return loopss;
+}
+
+
+export { reconstructFromMats }

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

@@ -0,0 +1,62 @@
+import type { Mutable } from '../utils/mutable.js';
+import type { Mat } from '../mat/mat.js';
+import { isFullyTerminating } from './is-fully-terminating.js';
+
+
+/**
+ * In-place removes trivial 3-prongs from the SAT graph; just to simplify
+ * subsequent processing.
+ * 
+ * These are 3-prongs that are induced by the SAT construction, and do
+ * not correspond to actual 3-prongs in the shape.
+ * 
+ * @param sat the SAT
+ */
+function removeSatInducedTrivial3Prongs(
+        sat: Mat): Mat {
+
+    let { cpNode } = sat;
+
+    let cpStart = cpNode;
+    do {
+        if (isFullyTerminating(cpNode) ||
+            // cpNode.isHoleClosing ||  // hole-closers are fully terminating
+            cpNode.next !== cpNode.nextOnCircle) {
+
+            cpNode = cpNode.next;
+            continue;
+        }
+
+        //-----------------------------
+        // Delete the trivial 3-prong
+        //-----------------------------
+        // console.log('Removing SAT-induced trivial 3-prong');
+
+        const next = cpNode.next;
+        const nextNext = next.next;
+        const nextNextOC = cpNode.next.nextOnCircle;
+
+        //-------------------------------------------------------------
+        // In-place update of links to remove the trivial 3-prong node
+        //-------------------------------------------------------------
+        (cpNode as Mutable<typeof cpNode>).next = nextNext;
+        (cpNode as Mutable<typeof cpNode>).nextOnCircle = nextNextOC;
+        (nextNext as Mutable<typeof nextNext>).prev = cpNode;
+        (nextNextOC as Mutable<typeof nextNextOC>).prevOnCircle = cpNode;
+        //-------------------------------------------------------------
+
+        if (cpStart === next) {
+            cpStart = cpNode;  // ...otherwise the loop will never terminate
+        }
+
+        cpNode = cpNode.next;
+    } while (cpNode !== cpStart)
+
+    // ...otherwise the caller will have a reference to a node that has been removed from the graph
+    (sat as Mutable<Mat>).cpNode = cpNode;
+
+    return sat;
+}
+
+
+export { removeSatInducedTrivial3Prongs }