flo-mat 4.0.3 → 4.1.0

package/src/debug/functions/draw-elem/two-prong.ts

@@ -1,50 +0,0 @@
-// import { drawFs } from 'flo-draw';
-// import { TwoProngForDebugging   } from '../../two-prong-for-debugging.js';
-// import { getTwoProngType } from '../../../mat/get-two-prong-type.js';
-
-
-// /** @internal */
-// function twoProng(
-//         g: SVGGElement,
-//         twoProng: TwoProngForDebugging,
-//         classes?: string,
-//         delay = 0,
-//         scaleFactor = 1) {
-
-//     let $failedDot : SVGElement[] = [];
-//     let $center    : SVGElement[] = [];
-//     let $circle    : SVGElement[] = [];
-//     let $cp1       : SVGElement[] = [];
-//     let $cp2       : SVGElement[] = [];
-    
-//     let color;
-//     let thin;
-
-//     switch (getTwoProngType(twoProng)) {
-//         case 'twoProng_regular': {
-//             color = 'red ';
-//             thin = '2';
-//             break;
-//         }
-//         case 'twoProng_holeClosing': {
-//             color = 'cyan ';
-//             thin = '10';
-//             break;
-//         }        
-//     }
-        
-    
-//     if (twoProng.failed) {
-//         $failedDot = drawFs.dot(g, twoProng.pos.p, 1*scaleFactor, 'black', delay);
-//     } else if (!twoProng.failed) {
-//         $center = drawFs.dot   (g, twoProng.circle.center, 0.01*scaleFactor, 'yellow', delay);
-//         $circle = drawFs.circle(g, twoProng.circle, color + 'thin' + thin + ' nofill', delay); 
-//         $cp1    = drawFs.dot   (g, twoProng.pos.p, 0.0175*scaleFactor, color, delay);
-//         $cp2    = drawFs.dot   (g, twoProng.z, 0.035*scaleFactor, color, delay);    
-//     }
-    
-//     return [...$failedDot, ...$center, ...$circle, ...$cp1, ...$cp2];    
-// }
-
-
-// export { twoProng }

package/src/debug/functions/draw-elem/vertex.ts

@@ -1,51 +0,0 @@
-import { drawFs } from 'flo-draw';
-import { CpNode, getCpNodesOnCircle } from '../../../cp-node/cp-node.js';
-
-
-/** @internal */
-function vertex(
-        g: SVGGElement,
-        cpNode: CpNode,
-        classes?: string,
-        delay?: number,/*
-        visible = true*/
-        scaleFactor = 1) {
-
-    // const visibleClass = visible ? '' : ' invisible';
-
-    const circle = cpNode.cp.circle;
-
-    const THIN = 'thin20';
-
-    const cps = getCpNodesOnCircle(cpNode);
-    console.log(cps)
-
-    let $svgs: SVGElement[] = [];
-
-    const $circle = drawFs.circle(g, circle, 'red ' + THIN + ' nofill '/* + visibleClass*/, delay);
-    const $crossHair = drawFs.crossHair(g, circle.center, 'red ' + THIN + ' nofill '/* + visibleClass*/, 3, delay);
-
-    $svgs = [...$circle, ...$crossHair];
-
-    for (let i=0; i<cps.length; i++) {
-        const cp = cps[i];
-        const edgeCircle = cp.next.cp.circle;
-
-        const $circle = drawFs.circle(g, edgeCircle, 'pink ' + THIN + ' nofill '/* + visibleClass*/, delay);
-        const $crossHair = drawFs.crossHair(g, edgeCircle.center, 'pink ' + THIN + ' nofill '/* + visibleClass*/, 3, delay);
-
-        $svgs.push(...$circle, ...$crossHair)
-
-        const p1 = circle.center;
-        const p2 = edgeCircle.center;
-        const thin = i === 0 ? 'thin10' : (i === 1 ? 'thin20' : 'thin35');
-        const $line = drawFs.line(g, [p1, p2], 'yellow ' + thin  + ' nofill '/* + visibleClass*/, delay);
-
-        $svgs.push(...$line);
-    }
-
-    return $svgs;
-}
-
-
-export { vertex }

package/src/find-3-prong/timed-cc.ts

@@ -1,9 +0,0 @@
-import { circumCenter } from 'flo-vector2d';
-import { timeFunctionCalls } from '../utils/time-function-call.js';
-
-
-// const timeCircumCenter = timeFunctionCalls(circumCenter);
-const timeCircumCenter = circumCenter;
-
-
-export { timeCircumCenter as circumCenter }

package/src/reconstruct-from-mat/filter-zero-length.ts

@@ -1,23 +0,0 @@
-import type { BezierPiece } from "flo-bezier3";
-import { isBezierPieceZeroLength } from "flo-bezier3";
-
-
-/**
- * Filters out zero-length bezier pieces.
- * 
- * * **note** will return at least one bezier piece, even if all pieces are zero-length.
- * 
- * @param bezierPieces 
- */
-function filterZeroLength(
-        bezierPieces: BezierPiece[]): BezierPiece[] {
-
-    const bezierPieces_ = bezierPieces.filter(
-        bezierPiece => !isBezierPieceZeroLength(bezierPiece)
-    );
-
-    return bezierPieces_.length > 0 ? bezierPieces_ : [bezierPieces[0]];
-}
-
-
-export { filterZeroLength }

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

@@ -1,12 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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-matching-beziers.ts

@@ -1,46 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,69 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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/split-tri-path.ts

@@ -1,280 +0,0 @@
-import type { BezierPiece } from 'flo-bezier3';
-import type { MatchedBeziers } from './matched-beziers.js';
-import { getTAtLength } from 'flo-bezier3';
-import { sum } from '../utils/sum.js';
-import { clip } from '../utils/clip.js';
-import { getBezierPieceLength } from './get-bezier-piece-length.js';
-
-
-const EPS = 1e-9;
-
-
-function splitTriPath(
-        boundaryBeziers: BezierPiece[],
-        medialBezier: BezierPiece,
-        boundaryBeziersOpp: BezierPiece[] | undefined): MatchedBeziers[] {
-
-    const _boundaryBeziersOpp = boundaryBeziersOpp ?? [];
-
-    const boundaryBeziersOpp_ =
-        _boundaryBeziersOpp.map(reverseBezierPiece).toReversed();
-
-    // Importantly, we need to split on boundaryBeziersOpp_ as well, to ensure
-    // the number of returned pieces is the same for both sides, so that they
-    // can be interpolated.
-    const _paths = boundaryBeziersOpp_.length > 0
-        ? [boundaryBeziers, [medialBezier], boundaryBeziersOpp_]
-        : [boundaryBeziers, [medialBezier]];
-
-    const paths = splitTriPath_(_paths);
-
-    const matchedBezierss: MatchedBeziers[] = [];
-    for (let i=0; i<paths.length; i++) {
-        const path = paths[i];
-        // const pathOpp = paths[paths.length - 1 - i];
-
-        const [boundaryBezier, medialBezier] = path;
-        // const boundaryBezierOpp = pathOpp[2];
-        const matchedBeziers: MatchedBeziers = {
-            boundaryBezier,
-            medialBezier,
-            // boundaryBezierOpp
-        };
-        matchedBezierss.push(matchedBeziers);
-    }
-
-    return matchedBezierss;
-}
-
-
-function reverseBezierPiece(
-        bezierPiece: BezierPiece) {
-
-    const { ps, ts: [tS, tE] } = bezierPiece;
-
-    return {
-        ps: ps.toReversed(),
-        ts: [1 - tE, 1 - tS]
-    };
-}
-
-
-/**
- * Returns an array of arrays of `BezierPiece`s, where each inner array
- * contains `BezierPiece`s that correspond to each other across the different
- * paths by normalized length.
- * 
- * For example, if there are 3 paths, then each inner array will contain 3
- * `BezierPiece`s, one from each path, that correspond to each other by normalized
- * length.
- * 
- * @param bezierPiecess 
- */
-function splitTriPath_(
-        bezierPiecess: BezierPiece[][]): BezierPiece[][] {
-
-    const lenss = mapmap(bezierPiecess, getBezierPieceLength);
-    const lens = lenss.map(sum);
-    const cums = lenss.map(getCumLengths);
-
-    const normCums = cums.map((cum,i) => {
-        const len = lens[i];
-        if (len <= EPS) {
-            return cum.map((_,j) => j === 0 ? 0 : 1);
-            // return cum.map(() => Number.POSITIVE_INFINITY);
-        }
-
-        return cum.map(l => l/len);
-    });
-
-
-    /** Current position of start t */
-    let ts = new Array(bezierPiecess.length).fill(0);
-    /** Current position of i */
-    let is = new Array(bezierPiecess.length).fill(0);
-
-    const matchedBezierss: BezierPiece[][] = [];
-
-    normCums;//?
-
-    let ii = 0;
-    const maxIterations = 100;
-    while (ts.some(t => t < 1) && ii++ < maxIterations) {
-        const normCumsNext: number[] = [];
-        for (let k=0; k<bezierPiecess.length; k++) {
-            const i_ = is[k];
-
-            const normCum_ = normCums[k][i_ + 1];//?
-            const normCum = normCum_ === undefined
-                ? Number.POSITIVE_INFINITY
-                : normCum_;
-
-            normCumsNext.push(normCum);
-        }
-
-        normCumsNext;//?
-
-        const minIdx = getMinIdx(normCumsNext)!;//?
-        const idxs = getIdxs(normCumsNext, normCumsNext[minIdx]);//?
-        const curCum = normCumsNext[minIdx];
-
-        // if (idxs.length === 0) {
-        //     throw new Error('splitTriPath_: unable to make progress');
-        // }
-
-        const nextPieces: BezierPiece[] = new Array(bezierPiecess.length).fill([]);
-        for (let m=0; m<bezierPiecess.length; m++) {
-            const bezierPieces = bezierPiecess[m];
-            const _i = is[m];
-
-            // This path is already finished; keep emitting a degenerate tail.
-            if (_i >= bezierPieces.length) {
-                const lastBezierPiece = bezierPieces[bezierPieces.length - 1];
-                nextPieces[m] = {
-                    ps: lastBezierPiece.ps,
-                    ts: [1, 1]
-                };
-                ts[m] = 1;
-                continue;
-            }
-
-            if (idxs.includes(m)) {
-                const _t = ts[m];
-                const bezierPiece = bezierPieces[_i];
-                const [pieceTS, pieceTE] = bezierPiece.ts;
-                const pieceDt = pieceTE - pieceTS;
-
-                nextPieces[m] = {
-                    ps: bezierPiece.ps,
-                    ts: [pieceTS + _t*pieceDt, pieceTE]
-                };
-
-                const nextI = _i + 1;
-                is[m] = nextI;
-                ts[m] = nextI >= bezierPieces.length ? 1 : 0;
-            } else {
-                const _t = ts[m];
-                const bezierPiece = bezierPieces[_i];
-                const [pieceTS, pieceTE] = bezierPiece.ts;
-                const pieceDt = pieceTE - pieceTS;
-                const bezierLen = getBezierPieceLength({ ps: bezierPiece.ps, ts: [0, 1] });
-
-                const normCumStart = normCums[m][_i];
-                const normCumEnd = normCums[m][_i + 1];
-                const normCumDt = normCumEnd - normCumStart;
-                const normWithinPiece = normCumDt <= EPS
-                    ? _t
-                    : clip((curCum - normCumStart) / normCumDt, _t, 1);
-
-                const t1 = bezierLen <= EPS
-                    ? _t
-                    : clip(getTAtLength(bezierPiece.ps, bezierLen * normWithinPiece), _t, 1);
-
-                nextPieces[m] = {
-                    ps: bezierPiece.ps,
-                    ts: [pieceTS + _t*pieceDt, pieceTS + t1*pieceDt]
-                };
-
-                if (closeToEps(t1, 1)) {
-                    const nextI = _i + 1;
-                    is[m] = nextI;
-                    ts[m] = nextI >= bezierPieces.length ? 1 : 0;
-                } else {
-                    is[m] = _i;
-                    ts[m] = t1;
-                }
-            }
-        }
-
-        matchedBezierss.push(nextPieces);
-    }
-
-    if (ts.some(t => t < 1)) {
-        throw new Error('splitTriPath_: exceeded maximum iterations');
-    }
-
-    return matchedBezierss;
-}
-
-
-function getCumLengths(lens: number[]) {
-    const cum: number[] = [0];
-    let cumLen = 0;
-    for (let j=0; j<lens.length; j++) {
-        cumLen += lens[j];
-        cum.push(cumLen);
-    }
-    return cum;
-}
-
-
-/**
- * Returns the index within the given array of the number with the highest
- * value.
- * 
- * * returns `undefined` if the array is empty
- */
-function getMinIdx(
-        vs: number[]): number | undefined {
-
-    let minIdx: number | undefined = undefined;
-    let minVal = Number.POSITIVE_INFINITY;
-    for (let i=0; i<vs.length; i++) {
-        if (vs[i] <= minVal) {
-            minVal = vs[i];
-            minIdx = i;
-        }
-    }
-
-    return minIdx;
-}
-
-
-/**
- * Returns the indices within the given array of the numbers that are equal to
- * the given max value (within an EPS value).
- * 
- * @param vs 
- * @param maxVal 
- */
-function getIdxs(
-        vs: number[],
-        maxVal: number): number[] {
-
-    const maxIdxs: number[] = [];
-    for (let i=0; i<vs.length; i++) {
-        if (vs[i] === maxVal || closeToEps(vs[i], maxVal)) {
-            maxIdxs.push(i);
-        }
-    }
-
-    return maxIdxs;
-}
-
-
-function closeToEps(a: number, b: number) {
-    return Math.abs(a - b) <= EPS;
-}
-
-
-export { splitTriPath, getCumLengths };
-
-
-
-// KEEP FOR TESTING! - one in opentype-ts doesn't work with tests due to aliases
-function mapmap<T,U>(
-        tss: T[][],
-        f: (t: T) => U): U[][] {
-
-    const tss_: U[][] = [];
-    for (let i=0; i<tss.length; i++) {
-        const ts = tss[i];
-        const ts_: U[] = [];
-        for (let j=0; j<ts.length; j++) {
-            ts_.push(f(ts[j]));
-        }
-        tss_.push(ts_);
-    }
-
-    return tss_;
-}