Optimize memory footprint in outline conversion

packages/geometry/src/curve-util.mjs

@@ -67,7 +67,6 @@ function convertContourToArcs(contour) {
 	return newContour;
 }
 
-export const SPIRO_PRECISION = 1 / 2;
 export const OCCURRENT_PRECISION = 1 / 16;
 export const GEOMETRY_PRECISION = 1 / 4;
 export const BOOLE_RESOLUTION = 0x4000;

packages/geometry/src/index.mjs

@@ -6,6 +6,7 @@ import * as TypoGeom from "typo-geom";
 
 import * as CurveUtil from "./curve-util.mjs";
 import { Point } from "./point.mjs";
+import { QuadifySink } from "./quadify.mjs";
 import { SpiroExpander } from "./spiro-expand.mjs";
 import { Transform } from "./transform.mjs";
 
@@ -39,19 +40,15 @@ export class GeometryBase {
 	}
 }
 
-export class ContourGeometry extends GeometryBase {
-	constructor(points) {
+export class InvalidGeometry extends GeometryBase {}
+
+export class ContourSetGeometry extends GeometryBase {
+	constructor(contours) {
 		super();
-		this.m_points = [];
-		for (const z of points) {
-			this.m_points.push(Point.from(z.type, z));
-		}
+		this.m_contours = contours;
 	}
 	asContours() {
-		if (this.isEmpty()) return [];
-		let c1 = [];
-		for (const z of this.m_points) c1.push(Point.from(z.type, z));
-		return [c1];
+		return this.m_contours;
 	}
 	asReferences() {
 		return null;
@@ -63,16 +60,19 @@ export class ContourGeometry extends GeometryBase {
 		return this;
 	}
 	isEmpty() {
-		return !this.m_points.length;
+		return !this.m_contours.length;
 	}
 	measureComplexity() {
-		for (const z of this.m_points) {
+		for (const z of this.m_contours) {
 			if (!isFinite(z.x) || !isFinite(z.y)) return 0xffff;
 		}
-		return this.m_points.length;
+		return this.m_contours.length;
 	}
 	toShapeStringOrNull() {
-		return Format.struct(`ContourGeometry`, Format.list(this.m_points.map(Format.typedPoint)));
+		return Format.struct(
+			`ContourSetGeometry`,
+			Format.list(this.m_contours.map(c => Format.list(c.map(Format.typedPoint))))
+		);
 	}
 }
 
@@ -90,7 +90,12 @@ export class SpiroGeometry extends GeometryBase {
 	asContours() {
 		if (this.m_cachedContours) return this.m_cachedContours;
 		const s = new CurveUtil.BezToContoursSink(this.m_gizmo);
-		SpiroJs.spiroToBezierOnContext(this.m_knots, this.m_closed, s, CurveUtil.SPIRO_PRECISION);
+		SpiroJs.spiroToBezierOnContext(
+			this.m_knots,
+			this.m_closed,
+			s,
+			CurveUtil.GEOMETRY_PRECISION
+		);
 		this.m_cachedContours = s.contours;
 		return this.m_cachedContours;
 	}
@@ -573,6 +578,58 @@ export class BooleanGeometry extends GeometryBase {
 	}
 }
 
+// This special geometry type is used in the finalization phase to create TTF contours.
+export class SimplifyGeometry extends GeometryBase {
+	constructor(g) {
+		super();
+		this.m_geom = g;
+	}
+	asContours() {
+		// Produce simplified arcs
+		let arcs = CurveUtil.convertShapeToArcs(this.m_geom.asContours());
+		if (!this.m_geom.producesSimpleContours()) {
+			arcs = TypoGeom.Boolean.removeOverlap(
+				arcs,
+				TypoGeom.Boolean.PolyFillType.pftNonZero,
+				CurveUtil.BOOLE_RESOLUTION
+			);
+		}
+
+		// Convert to TT curves
+		const sink = new QuadifySink();
+		TypoGeom.ShapeConv.transferGenericShape(
+			TypoGeom.Fairize.fairizeBezierShape(arcs),
+			sink,
+			CurveUtil.GEOMETRY_PRECISION
+		);
+		return sink.contours;
+	}
+	asReferences() {
+		return null;
+	}
+	getDependencies() {
+		return this.m_geom.getDependencies();
+	}
+	unlinkReferences() {
+		return new SimplifyGeometry(this.m_geom.unlinkReferences());
+	}
+	filterTag(fn) {
+		return new SimplifyGeometry(this.m_geom.filterTag(fn));
+	}
+	isEmpty() {
+		return this.m_geom.isEmpty();
+	}
+	measureComplexity() {
+		return this.m_geom.measureComplexity();
+	}
+	toShapeStringOrNull() {
+		const sTarget = this.m_geom.unlinkReferences().toShapeStringOrNull();
+		if (!sTarget) return null;
+		return `SimplifyGeometry{${sTarget}}`;
+	}
+}
+
+// Utility functions
 export function combineWith(a, b) {
 	if (a instanceof CombineGeometry) {
 		return a.with(b);

packages/geometry/src/quadify.mjs

@@ -0,0 +1,282 @@
+import * as TypoGeom from "typo-geom";
+
+import * as CurveUtil from "./curve-util.mjs";
+import { Point } from "./point.mjs";
+
+export class QuadifySink {
+	constructor() {
+		this.contours = [];
+		this.lastContour = [];
+	}
+	beginShape() {}
+	endShape() {
+		if (this.lastContour.length > 2) {
+			let c = this.lastContour;
+			c = this.alignHVKnots(c);
+			c = this.dropDuplicateFirstLast(c);
+			c = this.cleanupOccurrentKnots1(c);
+			c = this.cleanupOccurrentKnots2(c);
+			c = this.cleanupOccurrentKnots1(c);
+			c = this.removeColinearArc(c);
+			c = this.removeColinearCorners(c);
+			c = this.cleanupOccurrentKnots1(c);
+			if (c.length > 2) this.contours.push(c);
+		}
+		this.lastContour = [];
+	}
+	moveTo(x, y) {
+		this.endShape();
+		this.lineTo(x, y);
+	}
+	lineTo(x, y) {
+		this.lastContour.push(Point.fromXY(Point.Type.Corner, x, y));
+	}
+	arcTo(arc, x, y) {
+		const offPoints = TypoGeom.Quadify.auto(arc, 1, 8);
+		for (const z of offPoints) {
+			this.lastContour.push(Point.from(Point.Type.Quadratic, z));
+		}
+		this.lineTo(x, y);
+	}
+
+	// Contour cleaning code
+	alignHVKnots(c0) {
+		const c = c0.slice(0);
+		const alignX = new CoordinateAligner(c, GetX, SetX);
+		const alignY = new CoordinateAligner(c, GetY, SetY);
+
+		for (let i = 0; i < c.length; i++) {
+			const iNext = (i + 1) % c.length,
+				zCurr = c[i],
+				zNext = c[iNext];
+			if (zCurr.type === Point.Type.Quadratic && zNext.type === Point.Type.Corner) {
+				alignX.tryAlign(i, iNext);
+				alignY.tryAlign(i, iNext);
+			} else {
+				alignX.tryAlign(iNext, i);
+				alignY.tryAlign(iNext, i);
+			}
+		}
+
+		alignX.apply();
+		alignY.apply();
+		return c;
+	}
+
+	// Drop the duplicate point (first-last)
+	dropDuplicateFirstLast(c) {
+		while (c.length > 1) {
+			const first = c[0],
+				last = c[c.length - 1];
+			if (
+				first.type === Point.Type.Corner &&
+				last.type === Point.Type.Corner &&
+				isOccurrent(first, last)
+			) {
+				c.pop();
+			} else {
+				break;
+			}
+		}
+		return c;
+	}
+
+	// Occurrent cleanup -- corner-corner
+	cleanupOccurrentKnots1(c0) {
+		let drops = [];
+		for (let i = 0; i < c0.length; i++) drops[i] = false;
+		for (let i = 0; i < c0.length; i++) {
+			const iPost = (i + 1) % c0.length;
+			const pre = c0[i],
+				post = c0[iPost];
+			if (
+				iPost > 0 &&
+				pre.type === Point.Type.Corner &&
+				post.type === Point.Type.Corner &&
+				isOccurrent(pre, post)
+			) {
+				drops[iPost] = true;
+			}
+		}
+
+		return dropBy(c0, drops);
+	}
+
+	// Occurrent cleanup -- off points
+	// This function actually **INSERTS** points for occurrent off knots.
+	cleanupOccurrentKnots2(c0) {
+		let insertAfter = [];
+		for (let i = 0; i < c0.length; i++) insertAfter[i] = false;
+		for (let i = 0; i < c0.length; i++) {
+			const cur = c0[i];
+			if (cur.type !== Point.Type.Quadratic) continue;
+
+			const iPre = (i - 1 + c0.length) % c0.length;
+			const iPost = (i + 1) % c0.length;
+			const pre = c0[iPre];
+			const post = c0[iPost];
+
+			if (isOccurrent(pre, cur) && post.type === Point.Type.Quadratic) {
+				insertAfter[i] = true;
+			}
+			if (isOccurrent(cur, post) && pre.type === Point.Type.Quadratic) {
+				insertAfter[iPre] = true;
+			}
+		}
+
+		let c1 = [];
+		for (let i = 0; i < c0.length; i++) {
+			const cur = c0[i];
+			c1.push(cur);
+			if (insertAfter[i]) {
+				const iPost = (i + 1) % c0.length;
+				const post = c0[iPost];
+				c1.push(Point.mix(Point.Type.Corner, cur, post, 0.5));
+			}
+		}
+
+		return c1;
+	}
+
+	removeColinearCorners(c0) {
+		const c = c0.slice(0);
+		let found = false;
+		do {
+			found = false;
+			for (let i = 0; i < c.length; i++) {
+				const zPrev = c[(i - 1 + c.length) % c.length],
+					zCurr = c[i],
+					zNext = c[(i + 1) % c.length];
+				if (
+					zPrev.type === Point.Type.Corner &&
+					zNext.type === Point.Type.Corner &&
+					(pointsHVColinear(zPrev, zCurr, zNext) || pointsColinear(zPrev, zCurr, zNext))
+				) {
+					found = true;
+					c.splice(i, 1);
+					break;
+				}
+			}
+		} while (found);
+		return c;
+	}
+
+	removeColinearArc(c) {
+		if (c[0].type !== Point.Type.Corner) throw new Error("Unreachable");
+
+		let front = 0,
+			shouldRemove = [],
+			middlePoints = [];
+		for (let rear = 1; rear <= c.length; rear++) {
+			let zFront = c[front],
+				zRear = c[rear % c.length];
+			if (zRear.type === Point.Type.Corner) {
+				let allColinear = true;
+				for (const z of middlePoints) {
+					if (!pointsHVColinear(zFront, z, zRear)) allColinear = false;
+				}
+
+				if (allColinear) for (let i = front + 1; i < rear; i++) shouldRemove[i] = true;
+
+				front = rear;
+				middlePoints.length = 0;
+			} else {
+				middlePoints.push(zRear);
+			}
+		}
+
+		return dropBy(c, shouldRemove);
+	}
+}
+
+// Disjoint set for coordinate alignment
+class CoordinateAligner {
+	constructor(c, lens, lensSet) {
+		this.c = c;
+		this.lens = lens;
+		this.lensSet = lensSet;
+		this.rank = [];
+		this.up = [];
+		for (let i = 0; i < c.length; i++) {
+			const x = lens(c[i]);
+			this.up[i] = i;
+			this.rank[i] = Math.abs(x - Math.round(x));
+		}
+	}
+	find(i) {
+		if (this.up[i] !== i) {
+			this.up[i] = this.find(this.up[i]);
+			return this.up[i];
+		} else {
+			return i;
+		}
+	}
+	tryAlign(i, j) {
+		if (occurrentPrecisionEqual(this.lens(this.c[i]), this.lens(this.c[j]))) {
+			this.align(i, j);
+		}
+	}
+	align(i, j) {
+		i = this.find(i);
+		j = this.find(j);
+		if (this.rank[i] > this.rank[j]) [i, j] = [j, i];
+		this.up[j] = i;
+	}
+	apply() {
+		for (let i = 0; i < this.c.length; i++) {
+			this.lensSet(this.c[i], Math.round(this.lens(this.c[this.find(i)])));
+		}
+	}
+}
+
+// Lenses used by aligner
+const GetX = z => z.x;
+const SetX = (z, x) => (z.x = x);
+const GetY = z => z.y;
+const SetY = (z, y) => (z.y = y);
+
+function isOccurrent(zFirst, zLast) {
+	return zFirst.x === zLast.x && zFirst.y === zLast.y;
+}
+function occurrentPrecisionEqual(a, b) {
+	return Math.abs(a - b) < CurveUtil.OCCURRENT_PRECISION;
+}
+function aligned(a, b, c) {
+	return a === b && b === c;
+}
+
+function pointsHVColinear(zPrev, zCurr, zNext) {
+	// No need to check in-between-ness, we can safely remove the corner
+	if (aligned(zPrev.x, zCurr.x, zNext.x)) return true;
+	if (aligned(zPrev.y, zCurr.y, zNext.y)) return true;
+	return false;
+}
+
+function inBetween(a, b, c) {
+	return (a <= b && b <= c) || (c <= b && b <= a);
+}
+function pointsColinear(zPrev, zCurr, zNext) {
+	// If zCurr is not in between zPrev and zNext, they are not colinear
+	if (!inBetween(zPrev.x, zCurr.x, zNext.x)) return false;
+	if (!inBetween(zPrev.y, zCurr.y, zNext.y)) return false;
+
+	// Measure the distance of zCurr to the line zPrev--zNext
+	// If it is less than OCCURRENT_PRECISION, then we think it is colinear
+	// Use squared distance to avoid sqrt
+	const dx = zNext.x - zPrev.x,
+		dy = zNext.y - zPrev.y;
+	const t = (zCurr.y - zPrev.y) * dx - (zCurr.x - zPrev.x) * dy;
+	return (
+		t * t < CurveUtil.GEOMETRY_PRECISION * CurveUtil.GEOMETRY_PRECISION * (dx * dx + dy * dy)
+	);
+}
+
+// Dropping helper
+function dropBy(c, shouldRemove) {
+	let n = 0;
+	for (let i = 0; i < c.length; i++) {
+		if (!shouldRemove[i]) c[n++] = c[i];
+	}
+	c.length = n;
+	return c;
+}