@logomarks/core 0.1.9 → 0.2.0

package/src/letters/inktrap.d.ts

@@ -0,0 +1,66 @@
+import type { Geom, Point, Polygon, Shape } from '../geometry/types.js';
+
+export { sub, add, mul } from '../util/vec.js';
+
+/** A concave join of a letter, as joins() finds it. */
+export interface TrapJoin {
+	/** The corner. */
+	p: readonly number[];
+	/** The unit directions along its two edges, away from it. */
+	a: number[];
+	b: number[];
+	/** The angle between them, degrees. */
+	ang: number;
+	/** Whether it is a counter's corner. */
+	hole: boolean;
+}
+/** The notch's sizes and the angles it traps. */
+export interface TrapOptions {
+	m?: number;
+	hw?: number;
+	d?: number;
+	dMax?: number;
+	lo?: number;
+	hi?: number;
+}
+
+/** The stem weight: 116. */
+export const TRAP_S: number;
+/** The diagonal weight, square to the stroke: 112. */
+export const TRAP_SD: number;
+/** The bar weight: 104. */
+export const TRAP_SB: number;
+/** The band between the cap line and the baseline, wider than the canvas. */
+export function trapBand(y0?: number, y1?: number): Polygon;
+/** The unit vector along a. */
+export function unit(a: readonly number[]): Point;
+/** A straight stroke a → b, w wide square to it, run ext past both ends. */
+export function str(a: readonly number[], b: readonly number[], w?: number, ext?: number): Polygon;
+/** The horizontal width of a slanted stroke w wide running dx across over dy down. */
+export function hOf(dx: number, dy: number, w: number): number;
+/** A diagonal whose left edge runs (xt, y0) → (xb, y1), w wide square to it. */
+export function para(xt: number, xb: number, w?: number, y0?: number, y1?: number): Polygon;
+/** A shape mirrored about x = C. */
+export function mir(s: Geom): Shape;
+/** A shape turned upside down about y = C. */
+export function flipY(s: Geom): Shape;
+/** The angle (degrees) round circle (c, r) where the tangent from p touches it, on side ±1. */
+export function tangentDeg(c: readonly number[], r: number, p: readonly number[], side: number): number;
+/** The notch's sizes and the counter angles it traps. */
+export const TRAP: { m: number; hw: number; d: number; dMax: number; lo: number; hi: number };
+/** A point dist along a ring from vertex i, walking by step (±1). */
+export function walk(r: readonly (readonly number[])[], i: number, step: number, dist: number): readonly number[];
+/** The angle between two unit vectors, degrees. */
+export function angle(a: readonly number[], b: readonly number[]): number;
+/** Every concave join whose counter angle is between lo and hi degrees. */
+export function joins(shape: Shape, lo?: number, hi?: number): TrapJoin[];
+/** The wedge cut at one join, carrying its tip. */
+export function notch(join: Pick<TrapJoin, 'p' | 'a' | 'b' | 'ang'>, o?: TrapOptions): Polygon & { tip: number[] };
+/** Traps whose tips come nearer than this: the second is dropped. */
+export const TIP_GAP: number;
+/** Every picked join cut by the notch, a counter's corners first. */
+export function traps(shape: Geom, pick?: (join: TrapJoin) => boolean, o?: TrapOptions): Shape;
+/** A pick: the joins within 60 of any point. */
+export function near(...pts: (readonly number[])[]): (join: { p: readonly number[] }) => boolean;
+/** A pick: the joins not within 60 of any point. */
+export function not(...pts: (readonly number[])[]): (join: { p: readonly number[] }) => boolean;

package/src/letters/inktrap.js

@@ -0,0 +1,244 @@
+/**
+ * Ink Trap letters: a heavy, tight grotesque letter or numeral drawn geometrically (never from a font), stems TRAP_S,
+ * diagonals TRAP_SD square to the stroke, bars TRAP_SB, square terminals, cap 448 (the 448 frame's T, B, H) and never
+ * wider, whose concave joins are cut by ONE notch shape: a sharp wedge from a mouth on the corner's two edges to a tip past
+ * the corner along its bisector (`notch()`). `traps()` cuts it at every join `joins()` finds from the outline (counter
+ * angles 12–100°), a counter's corners first, leaving out any trap whose tip comes within TIP_GAP of one already cut.
+ * From the Logomarks tools (inktrapparts.mjs, batches 338 and 339).
+ */
+import { C, U, D, rect, poly, mapPts } from '../geometry/index.js';
+import { sub, add, mul, shoelace as sArea } from '../util/vec.js';
+import { T, B } from './frame.js';
+
+export { sub, add, mul } from '../util/vec.js';
+
+/* ---------- The letter build ---------- */
+
+/** The stem weight: 116. */
+export const TRAP_S = 116;
+
+/** The diagonal weight, square to the stroke: 112. */
+export const TRAP_SD = 112;
+
+/** The bar weight: 104. */
+export const TRAP_SB = 104;
+
+/**
+ * The band between the cap line and the baseline: strokes are clipped to it, so their ends sit flat on the lines.
+ *
+ * @param {number} [y0] The top line (T).
+ * @param {number} [y1] The bottom line (B).
+ * @returns {import('../geometry/types.js').Polygon} A rectangle wider than the canvas.
+ */
+export const trapBand = (y0 = T, y1 = B) => rect(-600, y0, 1712, y1 - y0);
+
+/**
+ * A vector's length.
+ *
+ * @param {readonly number[]} a The vector.
+ * @returns {number} Its length.
+ */
+const len = (a) => Math.hypot(a[0], a[1]);
+
+/**
+ * The unit vector along a.
+ *
+ * @param {readonly number[]} a The vector.
+ * @returns {import('../geometry/types.js').Point} It, at length 1.
+ */
+export const unit = (a) => mul(a, 1 / len(a));
+
+/**
+ * A straight stroke along the centre line a → b, w wide square to it, run `ext` past both ends (clip it afterwards).
+ *
+ * @param {readonly number[]} a The start of the centre line.
+ * @param {readonly number[]} b Its end.
+ * @param {number} [w] The width, square to the stroke (TRAP_SD).
+ * @param {number} [ext=0] How far it runs on past both ends.
+ * @returns {import('../geometry/types.js').Polygon} The stroke.
+ */
+export const str = (a, b, w = TRAP_SD, ext = 0) => {
+	const dx = b[0] - a[0], dy = b[1] - a[1], L = Math.hypot(dx, dy), ux = dx / L, uy = dy / L,
+		nx = -uy * w / 2, ny = ux * w / 2, A = [a[0] - ux * ext, a[1] - uy * ext], E = [b[0] + ux * ext, b[1] + uy * ext];
+	return poly([[A[0] + nx, A[1] + ny], [E[0] + nx, E[1] + ny], [E[0] - nx, E[1] - ny], [A[0] - nx, A[1] - ny]]);
+};
+
+/**
+ * The horizontal width of a slanted stroke w wide (square to it) that runs dx across over dy down.
+ *
+ * @param {number} dx How far it runs across.
+ * @param {number} dy How far it runs down.
+ * @param {number} w Its width, square to it.
+ * @returns {number} Its width along a horizontal.
+ */
+export const hOf = (dx, dy, w) => w * Math.hypot(dx, dy) / dy;
+
+/**
+ * A diagonal from the cap line to the baseline whose LEFT edge runs (xt, y0) → (xb, y1), w wide square to it.
+ *
+ * @param {number} xt The left edge's x on the top line.
+ * @param {number} xb Its x on the bottom line.
+ * @param {number} [w] The width, square to the stroke (TRAP_SD).
+ * @param {number} [y0] The top line (T).
+ * @param {number} [y1] The bottom line (B).
+ * @returns {import('../geometry/types.js').Polygon} The diagonal.
+ */
+export const para = (xt, xb, w = TRAP_SD, y0 = T, y1 = B) => {
+	const h = hOf(xb - xt, y1 - y0, w);
+	return poly([[xt, y0], [xt + h, y0], [xb + h, y1], [xb, y1]]);
+};
+
+/**
+ * A shape mirrored about the letter's centre line x = C.
+ *
+ * @param {import('../geometry/types.js').Geom} s The shape.
+ * @returns {import('../geometry/types.js').Shape} It, mirrored.
+ */
+export const mir = (s) => U(mapPts(s, ([x, y]) => [2 * C - x, y]));
+
+/**
+ * A shape turned upside down about y = C.
+ *
+ * @param {import('../geometry/types.js').Geom} s The shape.
+ * @returns {import('../geometry/types.js').Shape} It, flipped.
+ */
+export const flipY = (s) => U(mapPts(s, ([x, y]) => [x, 2 * C - y]));
+
+/**
+ * Where the tangent from p touches the circle (centre c, radius r), on the side `side`, as an angle round the circle.
+ *
+ * @param {readonly number[]} c The circle's centre.
+ * @param {number} r Its radius.
+ * @param {readonly number[]} p The point outside it.
+ * @param {number} side +1 or −1.
+ * @returns {number} The touching point's angle, in degrees.
+ */
+export const tangentDeg = (c, r, p, side) => {
+	const dv = sub(p, c), L = len(dv), phi = Math.atan2(dv[1], dv[0]);
+	return (phi + side * Math.acos(r / L)) * 180 / Math.PI;
+};
+
+/* ---------- The ink trap ---------- */
+
+/**
+ * The notch, one for the whole family: its mouth sits m along each edge from the corner (at least hw either side of the
+ * bisector), its tip d past the corner along the bisector, d growing as the corner sharpens (to dMax). Joins whose counter
+ * angle is between lo and hi degrees are trapped. Even so the acute crotches of V, N, M, W and Y only deepen their
+ * counters at 32 px: the trap reads where the join is 45–100°.
+ */
+export const TRAP = { m: 60, hw: 36, d: 84, dMax: 150, lo: 12, hi: 100 };
+
+/**
+ * A point `dist` along a ring from vertex i, walking by `step` (+1 or −1): the edge's direction away from a corner.
+ *
+ * @param {readonly (readonly number[])[]} r The ring.
+ * @param {number} i The vertex.
+ * @param {number} step +1 or −1.
+ * @param {number} dist How far to walk.
+ * @returns {readonly number[]} The point.
+ */
+export const walk = (r, i, step, dist) => {
+	const n = r.length;
+	let j = i, left = dist, p = r[i];
+	for (let k = 0; k < n; k++) {
+		const q = r[(j + step + n) % n], L = len(sub(q, p));
+		if (L >= left) return add(p, mul(unit(sub(q, p)), left));
+		left -= L; p = q; j = (j + step + n) % n;
+	}
+	return p;
+};
+
+/**
+ * The angle between two unit vectors.
+ *
+ * @param {readonly number[]} a The first.
+ * @param {readonly number[]} b The second.
+ * @returns {number} The angle, degrees.
+ */
+export const angle = (a, b) => Math.acos(Math.max(-1, Math.min(1, a[0] * b[0] + a[1] * b[1]))) * 180 / Math.PI;
+
+/**
+ * Every concave join of a shape (a corner where the ink turns in: a crotch, or a counter's corner) whose counter angle is
+ * between lo and hi degrees.
+ *
+ * @param {import('../geometry/types.js').Shape} shape The letter.
+ * @param {number} [lo] The smallest counter angle (TRAP.lo).
+ * @param {number} [hi] The largest (TRAP.hi).
+ * @returns {{ p: readonly number[], a: number[], b: number[], ang: number, hole: boolean }[]} Each join: its corner, the
+ *   unit directions along its two edges (away from it), the angle between them, and whether it is a counter's.
+ */
+export const joins = (shape, lo = TRAP.lo, hi = TRAP.hi) => {
+	const out = [];
+	for (const pg of shape) pg.forEach((r0, ri) => {
+		const r = (r0.length > 1 && r0[0][0] === r0.at(-1)[0] && r0[0][1] === r0.at(-1)[1]) ? r0.slice(0, -1) : r0, n = r.length, sg = Math.sign(sArea(r));
+		for (let i = 0; i < n; i++) {
+			const p = r[i], pv = r[(i - 1 + n) % n], nx = r[(i + 1) % n];
+			const e1 = sub(p, pv), e2 = sub(nx, p);
+			if (len(e1) < 1e-6 || len(e2) < 1e-6) continue;
+			const ringConvex = Math.sign(e1[0] * e2[1] - e1[1] * e2[0]) === sg, reflex = ri === 0 ? !ringConvex : ringConvex;
+			if (!reflex) continue;
+			const ang0 = angle(unit(sub(pv, p)), unit(sub(nx, p)));
+			if (ang0 < lo || ang0 > hi) continue;
+			const a = unit(sub(walk(r, i, -1, 18), p)), b = unit(sub(walk(r, i, 1, 18), p));
+			out.push({ p, a, b, ang: angle(a, b), hole: ri > 0 });
+		}
+	});
+	return out;
+};
+
+/**
+ * The notch at one join: a sharp wedge from its mouth on the two edges to its tip, into the ink.
+ *
+ * @param {{ p: readonly number[], a: readonly number[], b: readonly number[], ang: number }} join The join (joins()).
+ * @param {{ m?: number, hw?: number, d?: number, dMax?: number }} [o] TRAP's sizes, any of them changed.
+ * @returns {import('../geometry/types.js').Polygon & { tip: number[] }} The wedge, carrying its tip.
+ */
+export const notch = ({ p, a, b, ang }, o = {}) => {
+	const { m, hw, d, dMax } = { ...TRAP, ...o }, al = ang / 2 * Math.PI / 180;
+	const u = unit(mul(add(a, b), -1)), v = [-u[1], u[0]], mm = Math.max(m, hw / Math.sin(al)), hb = mm * Math.sin(al) + 2;
+	const back = sub(p, mul(u, mm * Math.cos(al) + 2)), dd = Math.max(d, Math.min(dMax, d * Math.sqrt(Math.SQRT1_2 / Math.sin(al))));
+	const tip = add(p, mul(u, dd));
+	return Object.assign(poly([add(back, mul(v, hb)), tip, sub(back, mul(v, hb))]), { tip });
+};
+
+/**
+ * Two traps whose tips come nearer than this bite through the stroke between them (the bar under P's or R's bowl, trapped
+ * from the counter above and the corner below): the second is dropped.
+ */
+export const TIP_GAP = 70;
+
+/**
+ * The family's one move: every join picked (all of them, or those `pick` keeps) cut by the ink-trap notch, a counter's
+ * corners first, any trap whose tip would meet one already cut left out.
+ *
+ * @param {import('../geometry/types.js').Geom} shape The letter.
+ * @param {(join: { p: readonly number[], a: number[], b: number[], ang: number, hole: boolean }) => boolean} [pick] Which
+ *   joins to trap (all by default; see near() and not()).
+ * @param {{ m?: number, hw?: number, d?: number, dMax?: number, lo?: number, hi?: number }} [o] TRAP's sizes and angles,
+ *   any of them changed.
+ * @returns {import('../geometry/types.js').Shape} The trapped letter.
+ */
+export const traps = (shape, pick = () => true, o = {}) => {
+	const s = U(shape), js = joins(s, o.lo, o.hi).filter(pick), ns = [];
+	for (const j of [...js.filter((j) => j.hole), ...js.filter((j) => !j.hole)]) {
+		const n = notch(j, o); // a counter's traps first
+		if (ns.every((k) => len(sub(k.tip, n.tip)) >= TIP_GAP)) ns.push(n);
+	}
+	return ns.length ? D(s, ...ns) : s;
+};
+
+/**
+ * A pick for traps(): keep the joins within 60 of any of the given points.
+ *
+ * @param {...(readonly number[])} pts The points.
+ * @returns {(join: { p: readonly number[] }) => boolean} The pick.
+ */
+export const near = (...pts) => ({ p }) => pts.some(([x, y]) => Math.hypot(p[0] - x, p[1] - y) < 60);
+
+/**
+ * A pick for traps(): drop the joins within 60 of any of the given points.
+ *
+ * @param {...(readonly number[])} pts The points.
+ * @returns {(join: { p: readonly number[] }) => boolean} The pick.
+ */
+export const not = (...pts) => ({ p }) => !pts.some(([x, y]) => Math.hypot(p[0] - x, p[1] - y) < 60);

package/src/letters/mono.d.ts

@@ -0,0 +1,145 @@
+import type { Geom, Point, Polygon, Shape } from '../geometry/types.js';
+import type { BadgeKind } from '../geometry/badges.js';
+
+/** The Fused stem width: 84. */
+export const W: number;
+/** The Fused cap line: y 76. */
+export const T0: number;
+/** The Fused baseline: y 436. */
+export const T1: number;
+/** Halfway between the cap line and the baseline. */
+export const MID: number;
+/** A Fused stem whose left edge is x. */
+export function stem(x: number, y0?: number, y1?: number): Polygon;
+/** A Fused bar from x0 to x1 whose top edge is y. */
+export function hbar(x0: number, x1: number, y: number): Polygon;
+/** A shape clipped flat at the cap and base lines. */
+export function clipH(g: Geom, y0?: number, y1?: number): Shape;
+/** A D-shaped bowl to the right of a stem whose left edge is x. */
+export function bowl(x: number, y0: number, y1: number, reach?: number): Shape;
+/** A straight run of points, about one every 8. */
+export function L_(a: readonly number[], b: readonly number[], n?: number): Point[];
+/** A circular arc's points (degrees, 0 right, 90 down). */
+export function A_(cx: number, cy: number, r: number, a0: number, a1: number): Point[];
+/** Runs joined end to start. */
+export function J_(...p: Point[][]): Point[];
+/** A polyline with the in-between points of its straight runs dropped. */
+export function straighten(p: readonly Point[]): Point[];
+/** A polyline trimmed by d from its start (or its end). */
+export function trim(p: readonly Point[], d: number, atEnd?: boolean): Point[];
+/** The two tracks' width: 26. */
+export const TW: number;
+/** The two tracks' pitch: 48. */
+export const PITCH: number;
+/** Two tracks along a filleted centreline. */
+export function track2(pts: readonly Point[], r?: number | number[], o?: { n?: number; pitch?: number; w?: number; closed?: boolean }): Shape;
+/** Three tracks (22 wide, 44 apart) along a filleted centreline. */
+export function track3(pts: readonly Point[], r?: number | number[]): Shape;
+/** A monoline stroke with square ends. */
+export function mline(pts: readonly Point[], w: number): Shape;
+/** An ellipse arc's points (degrees). */
+export function E_(cx: number, cy: number, rx: number, ry: number, a0: number, a1: number): Point[];
+/** The top ring of a Fused S's centreline. */
+export function sTop(sx: number, rx: number, a0?: number, ry?: number): Point[];
+/** The lower ring of a Fused S's centreline. */
+export function sLow(sx: number, rx: number, a1?: number, ry?: number): Point[];
+/** A centreline stroked solid, square ends. */
+export function solid(pts: readonly Point[], w?: number): Shape;
+/** A Fused A's two legs, clipped to the cap. */
+export function aLegs(ax: number, w: number): Shape;
+/** A Fused M: two stems and a V meeting in one point. */
+export function mLetter(x: number, xr: number, v?: number): Shape;
+/** A Fused A's crossbar, kept inside the legs. */
+export function aBar(ax: number, aw: number, y: number): Shape;
+/** The Badge letters' monoline width: 52. */
+export const BT: number;
+/** The Badge letters' centreline cap height: 212. */
+export const BH: number;
+/** A Badge J's centreline. */
+export function bJ(x: number, r?: number, H?: number): Point[];
+/** A Badge bowl's centreline off a stem. */
+export function bBowl(x: number, y0: number, y1: number, w: number): Point[];
+/** A Badge B's centrelines. */
+export function bB(x: number, w?: number, H?: number, k?: number): Point[][];
+/** A Badge M's centreline. */
+export function bM(x: number, w?: number, H?: number, v?: number): Point[][];
+/** A Badge H's centrelines. */
+export function bH(x: number, w?: number, H?: number): Point[][];
+/** A Badge S's centreline. */
+export function bS(sx: number, rx?: number, a0?: number, a1?: number, H?: number): Point[][];
+/** A Badge C's centreline. */
+export function bC(cx: number, r?: number, a0?: number, a1?: number): Point[][];
+/** A Badge P's centrelines. */
+export function bP(x: number, w?: number, H?: number): Point[][];
+/** A Badge R's centrelines. */
+export function bR(x: number, w?: number, H?: number): Point[][];
+/** A Badge A's centrelines. */
+export function bA(ax: number, w?: number, H?: number, bar?: number): Point[][];
+/** A Badge D's centreline. */
+export function bD(x: number, w?: number, H?: number): Point[][];
+/** The top-bar ligature: a bar from the J's left across to x1, and the J. */
+export function bJbar(jx: number, x1: number, r?: number): Point[][];
+/** Centrelines as one monoline, square ends, clipped at the cap and base lines. */
+export function mono(parts: readonly (readonly Point[])[], T?: number, H?: number): Shape;
+/** The pair as a monoline knocked out of a house badge. */
+export function badge(kind: BadgeKind, parts: readonly (readonly Point[])[]): Shape;
+/** The Fan cell: 140. */
+export const FC: number;
+/** The Fan gutter: 26. */
+export const FG: number;
+/** A grid of Fan tiles, centred ('S', '.', 'tl', 'tr', 'bl', 'br'). */
+export function fan(rows: readonly (readonly string[])[]): Shape;
+/** A Fused C opening off a stem. */
+export function cStem(x: number, reach?: number, a?: number, y0?: number, y1?: number): Shape;
+/** bowl() kept to the right of its stem's left edge. */
+export function monoBowl(x: number, y0: number, y1: number, reach?: number): Shape;
+/** A Fused A whose right leg stands upright as a stem. */
+export function aUp(sx: number): Shape;
+/** The half-plane right of the line a → b. */
+export function rightOf(a: readonly number[], b: readonly number[]): Polygon;
+/** aUp()'s left leg, foot to apex. */
+export function aUpLeg(sx: number): [Point, Point];
+/** A Fused J's hook off a stem. */
+export function jHook(jx: number): Shape;
+/** The Track cap height: 360. */
+export const TH: number;
+/** The Track S's ring radius. */
+export const TR: number;
+/** Half a two-track band: 37. */
+export const TB2: number;
+/** How far a track's round end reaches past its centreline: 13. */
+export const TCAP: number;
+/** A Track S entered from the left along the base. */
+export function sFromBase(sx: number, r?: number, end?: number): Point[];
+/** A Track S leaving to the right along the cap line. */
+export function sToTop(sx: number, r?: number, start?: number): Point[];
+/** A Track M, foot to foot. */
+export function tM(x: number, w?: number, v?: number): Point[];
+/** A Track R's stem and bowl. */
+export function tRbowl(x: number, bw?: number, bh?: number): Point[];
+/** A Track R's free-standing leg. */
+export function tRleg(x: number, kx?: number, lx?: number, bh?: number): Point[];
+/** A Track house A, foot to foot. */
+export function tA(x: number, aw?: number, k?: number): Point[];
+/** The house A's bar, a gap short of both legs. */
+export function tAbar(x: number, aw?: number, y?: number): Point[];
+/** A Track J, hook tip to stem top. */
+export function tJ(x: number, rj?: number): Point[];
+/** The lowercase x-height: 176. */
+export const XH: number;
+/** A Fused n-arch from the x-height to the base. */
+export function arch(xl: number, rA?: number, xh?: number, both?: boolean): Shape;
+/** A Fused lowercase e. */
+export function eLow(cx: number, cy: number, r: number, open?: number[]): Shape;
+/** Puff letters: balloon strokes. */
+export function puff(...strokes: Point[][]): Shape;
+/** The Linked band's width: 46. */
+export const LBW: number;
+/** The Linked gap at a crossing: 12. */
+export const LBG: number;
+/** A polyline densified to a step. */
+export function dense(pts: readonly Point[], step?: number, closed?: boolean): Point[];
+/** Woven letters. */
+export function linked(strands: readonly (readonly [readonly Point[], boolean?])[], w?: number, g?: number): Shape;
+/** A finished shape with its spike vertices and zero-area rings dropped, every ring closed. */
+export function clean(shape: Shape): Shape;