@logomarks/core 0.1.11 → 0.2.0

package/src/iso/planes.d.ts

@@ -0,0 +1,27 @@
+import type { Shape } from '../geometry/types.js';
+
+/** A view for planeScene(): its projection, the floor point under a screen point, and the way to the viewer. */
+export interface PlaneView {
+	p: (pt: readonly number[]) => number[];
+	base: (X: number, Y: number) => number[];
+	dir: number[];
+}
+/** 3D points. */
+type Pts3 = readonly (readonly number[])[];
+
+/** A parallelogram from corner o along u and v. */
+export function quad(o: readonly number[], u: readonly number[], v: readonly number[]): number[][];
+/** A plane hinged on a→b, turned deg about it, reaching L. */
+export function hinge(a: readonly number[], b: readonly number[], out: readonly number[], deg: number, L: number): number[][];
+/** A strip folded along a 3D profile, one plane a segment. */
+export function ribbon(pts: Pts3, depth: readonly number[]): number[][][];
+/** The iso view. */
+export const ISO: PlaneView;
+/** An oblique view: depth swept at deg, shortened by k. */
+export function OBL(k?: number, deg?: number): PlaneView;
+/** Planes drawn as one mark, back to front, a mitred gap g round each. */
+export function planeScene(planes: readonly (Pts3 | readonly Pts3[])[], view: PlaneView, g: number): Shape;
+/** A mark from planes in a view, as a build (g) => shape. */
+export function planeMark(planes: readonly (Pts3 | readonly Pts3[])[], view?: PlaneView): (g: number) => Shape;
+/** A plane letter: strokes swept in oblique depth. */
+export function planeGlyph(strokes: readonly Pts3[], deg?: number, d?: number, k?: number): (g: number) => Shape;

package/src/iso/planes.js

@@ -0,0 +1,138 @@
+/**
+ * Planes: flat 3D planes (no thickness) hinged and folded, projected iso or oblique and laid back to front by
+ * planeScene(), each cutting a mitred gap round itself out of what's behind. A plane is a convex 3D polygon, or several
+ * convex pieces of one plane (a wall with a door cut) drawn as one. The plane letters sweep every stroke up and to the
+ * right in oblique depth, so a stem shows its side and a bar its top, and each corner is a fold.
+ * From the Logomarks tools (planeparts.mjs, batch 215, reused by 220).
+ */
+import { C, D, I, U, poly, rad } from '../geometry/index.js';
+import { cross3 as cross, shoelace as area2 } from '../util/vec.js';
+import { mitre, dropThin } from './voxels.js';
+
+/* ---------- vectors (private) ---------- */
+const add = (a, b) => a.map((v, i) => v + b[i]), sub = (a, b) => a.map((v, i) => v - b[i]), mul = (a, k) => a.map((v) => v * k);
+const dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+/** v turned by deg about the unit axis k (Rodrigues). */
+const turn = (v, k, deg) => {
+	const t = rad(deg), c = Math.cos(t), s = Math.sin(t);
+	return add(add(mul(v, c), mul(cross(k, v), s)), mul(k, dot(k, v) * (1 - c)));
+};
+const unit = (v) => mul(v, 1 / Math.hypot(...v));
+
+/* ---------- planes ---------- */
+
+/**
+ * A parallelogram from corner o along u and v.
+ *
+ * @param {readonly number[]} o The corner.
+ * @param {readonly number[]} u One side.
+ * @param {readonly number[]} v The other.
+ * @returns {number[][]} Its four corners, in 3D.
+ */
+export const quad = (o, u, v) => [o, add(o, u), add(add(o, u), v), add(o, v)];
+
+/**
+ * A plane hinged on the edge a→b: it leaves the edge along `out` (a unit vector square to the edge), turned by deg
+ * about the edge, reaching L.
+ *
+ * @param {readonly number[]} a The hinge's start.
+ * @param {readonly number[]} b Its end.
+ * @param {readonly number[]} out The way it leaves the edge before turning (unit, square to the edge).
+ * @param {number} deg The turn about the edge.
+ * @param {number} L How far it reaches.
+ * @returns {number[][]} Its four corners, in 3D.
+ */
+export const hinge = (a, b, out, deg, L) => { const k = unit(sub(b, a)), d = mul(turn(out, k, deg), L); return [a, b, add(b, d), add(a, d)]; };
+
+/**
+ * A strip folded along a profile: each segment of `pts` (3D) swept by `depth` is one plane.
+ *
+ * @param {readonly (readonly number[])[]} pts The profile (3D).
+ * @param {readonly number[]} depth The sweep.
+ * @returns {number[][][]} One plane a segment.
+ */
+export const ribbon = (pts, depth) => pts.slice(1).map((p, i) => quad(pts[i], sub(p, pts[i]), depth));
+
+/* ---------- views ---------- */
+
+const c30 = Math.cos(Math.PI / 6);
+
+/**
+ * The iso view: x runs down-right, y down-left, z up; the viewer looks along −(1, 1, 1). `p` projects a 3D point,
+ * `base(X, Y)` is a point on the floor that projects to (X, Y), `dir` the way toward the viewer.
+ */
+export const ISO = { p: ([x, y, z]) => [(x - y) * c30, (x + y) / 2 - z], base: (X, Y) => { const a = X / c30, b = 2 * Y; return [(a + b) / 2, (b - a) / 2, 0]; }, dir: [1, 1, 1] };
+
+/**
+ * An oblique view: the front (x right, z up) in true shape, depth y swept up and to the right at `deg`, shortened by k.
+ *
+ * @param {number} [k=0.5] How much the depth is shortened.
+ * @param {number} [deg=45] The sweep's angle.
+ * @returns {import('./planes.js').PlaneView} The view.
+ */
+export const OBL = (k = 0.5, deg = 45) => {
+	const c = k * Math.cos(rad(deg)), s = k * Math.sin(rad(deg));
+	return { p: ([x, y, z]) => [x + y * c, -(z + y * s)], base: (X, Y) => [X, 0, -Y], dir: [c, -1, s] };
+};
+
+const centroid = (r) => {
+	let A = 0, x = 0, y = 0;
+	r.forEach((p, i) => { const q = r[(i + 1) % r.length], w = p[0] * q[1] - q[0] * p[1]; A += w; x += (p[0] + q[0]) * w; y += (p[1] + q[1]) * w; });
+	return [x / (3 * A), y / (3 * A)];
+};
+/** How near the viewer plane `pl` is at the screen point s (larger is nearer). */
+const nearness = (pl, view, s) => { const n = cross(sub(pl[1], pl[0]), sub(pl[2], pl[0])), b = view.base(...s); return dot(sub(pl[0], b), n) / dot(view.dir, n); };
+
+/**
+ * Planes (convex 3D polygons, or lists of convex pieces of one plane) drawn as one mark: projected, fitted to 448 and
+ * centred, put in depth order (where two overlap, the one nearer at the middle of the overlap goes in front) and laid
+ * back to front with the gap g, each cutting a mitred gap round itself out of what is behind. A plane seen edge-on is
+ * dropped, and so are slivers thinner than 9 once drawn.
+ *
+ * @param {readonly any[]} planes The planes.
+ * @param {import('./planes.js').PlaneView} view The view (ISO, or OBL()).
+ * @param {number} g The gap.
+ * @returns {import('../geometry/types.js').Shape} The mark.
+ */
+export const planeScene = (planes, view, g) => {
+	// a plane is one convex polygon, or several convex pieces of one plane (a wall with a door cut): drawn as one
+	let list = planes.map((pl) => (typeof pl[0][0] === 'number' ? [pl] : pl)).map((ps) => ({ pl: ps[0], q: ps.map((p) => p.map(view.p)) })).filter((o) => Math.abs(o.q.reduce((s, r) => s + area2(r), 0)) > 1e-4);
+	const xs = list.flatMap((o) => o.q.flat().map((p) => p[0])), ys = list.flatMap((o) => o.q.flat().map((p) => p[1]));
+	const k = 448 / Math.max(Math.max(...xs) - Math.min(...xs), Math.max(...ys) - Math.min(...ys)), cx = (Math.max(...xs) + Math.min(...xs)) / 2, cy = (Math.max(...ys) + Math.min(...ys)) / 2;
+	// a goes behind b when they overlap and b is nearer at the centre of the overlap
+	const behind = list.map(() => new Set());
+	list.forEach((a, i) => list.forEach((b, j) => {
+		if (j <= i) return; const o = I(a.q.map((r) => [r]), b.q.map((r) => [r]));
+		if (!o.length) return; const r = o.map((pg) => pg[0]).sort((p, q) => Math.abs(area2(q)) - Math.abs(area2(p)))[0]; if (Math.abs(area2(r)) < 1e-5) return;
+		const s = centroid(r), na = nearness(a.pl, view, s), nb = nearness(b.pl, view, s); if (na < nb) behind[j].add(i); else behind[i].add(j);
+	}));
+	const done = new Set(), order = [];
+	while (order.length < list.length) { const i = list.findIndex((_, i) => !done.has(i) && [...behind[i]].every((j) => done.has(j))); const at = i < 0 ? list.findIndex((_, i) => !done.has(i)) : i; done.add(at); order.push(at); }
+	const fitted = (r) => r.map(([x, y]) => [C + (x - cx) * k, C + (y - cy) * k]);
+	return dropThin(order.reduce((scene, i) => {
+		const ps = list[i].q.map(fitted);
+		return U(D(scene, ...ps.map((r) => poly(mitre(r, g)))), ...ps.map(poly));
+	}, []), 9);
+};
+
+/**
+ * A mark from planes in a view, as a build `(g) => shape`.
+ *
+ * @param {readonly any[]} planes The planes.
+ * @param {import('./planes.js').PlaneView} [view=ISO] The view.
+ * @returns {(g: number) => import('../geometry/types.js').Shape} The build.
+ */
+export const planeMark = (planes, view = ISO) => (g) => planeScene(planes, view, g);
+
+/**
+ * A plane letter: every stroke ([a, b] points, a across, b up) a strip swept up and to the right in oblique depth d, so
+ * a stem shows its side and a bar its top, and each corner is a fold. At 30° the bars and stems are both chunky; a
+ * diagonal near the sweep's own angle thins out.
+ *
+ * @param {readonly (readonly (readonly number[])[])[]} strokes The strokes.
+ * @param {number} [deg=30] The sweep's angle.
+ * @param {number} [d=0.9] The depth.
+ * @param {number} [k=0.7] The oblique shortening.
+ * @returns {(g: number) => import('../geometry/types.js').Shape} The build.
+ */
+export const planeGlyph = (strokes, deg = 30, d = 0.9, k = 0.7) => planeMark(strokes.flatMap((pts) => ribbon(pts.map(([a, b]) => [a, 0, b]), [0, d, 0])), OBL(k, deg));

package/src/iso/voxels.d.ts

@@ -0,0 +1,43 @@
+import type { Geom, Polygon, Shape } from '../geometry/types.js';
+import type { Piece } from '../parts/iso.js';
+
+/** The runs of '#' in each row: [c0, c1, row], c1 exclusive. */
+export function runs(rows: readonly string[]): number[][];
+/** A sprite on the iso grid's right-hand face, as boxes. */
+export function voxRight(rows: readonly string[], d?: number, x0?: number): Piece[];
+/** A sprite on the iso grid's left-hand face, as boxes. */
+export function voxLeft(rows: readonly string[], d?: number, y0?: number): Piece[];
+/** A plan on the ground raised h, as boxes. */
+export function voxPlan(rows: readonly string[], h?: number, z0?: number): Piece[];
+/** Unit cubes (or boxes of size s) as boxes. */
+export function voxCubes(list: readonly (readonly number[])[], s?: number): Piece[];
+/** Plans stacked bottom up, each h tall. */
+export function voxLayers(layers: readonly (readonly string[])[], h?: number): Piece[];
+/** A pixel sprite as one solid at pitch p. */
+export function pixRuns(rows: readonly string[], p: number, x0?: number, y0?: number): Shape;
+/** A pixel sprite with one stepped depth behind it, centred, longest side 448. */
+export function pixDepth(rows: readonly string[], o?: { dir?: number[]; k?: number; g?: number; min?: number }): Shape;
+/** A rectangle [x, y, w, h] grown squarely by g. */
+export function moat(r: readonly number[], g: number): Polygon;
+/** A convex polygon grown by g, corners mitred. */
+export function mitre(pts: readonly (readonly number[])[], g: number): number[][];
+/** Slabs laid in order, each cut free of the ones before by a square gap. */
+export function slabs(list: readonly (readonly number[] | readonly (readonly number[])[])[], g?: number): Shape;
+/** A unit-grid shape scaled by k and moved. */
+export function onGrid<T extends Geom>(shape: T, k: number, x?: number, y?: number): T;
+/** The pieces of a mark thinner than t dropped. */
+export function dropThin(shape: Shape, t?: number): Shape;
+/** The wall letters: a 5-row block alphabet, one cube a '#'. */
+export const WALL_GLYPH: Record<string, string[]>;
+/** A D with stepped, face-joined corners. */
+export const D_ROUND: string[];
+/** A four-wide S. */
+export const S_WIDE: string[];
+/** A four-wide L. */
+export const L_WIDE: string[];
+/** A five-wide M, its middle stem half height. */
+export const M_HALF: string[];
+/** Two letters on the two walls of a corner, as isoPieces() pieces. */
+export function cornerPieces(a: string | readonly string[], b: string | readonly string[], inside?: boolean, o?: { depth?: number; join?: boolean }): number[][][];
+/** A corner monogram, drawn with an exact 22 gap. */
+export function cornerMark(pair: string | readonly (string | readonly string[])[], inside?: boolean, o?: { depth?: number; join?: boolean }): () => Shape;

package/src/iso/voxels.js

@@ -0,0 +1,255 @@
+/**
+ * Iso voxels, pixel depth, brutalist slabs and corner monograms, for the parts' scene() and the kit's booleans.
+ *
+ * - Voxels: rows of text ('#' a cell, the format of PIX7 and the pixel animals) turned into scene() boxes on one plane of
+ *   the iso grid, each row's runs merged into one box, so a sprite is a handful of pieces and its faces in one plane merge.
+ * - Pixel depth: a front-facing pixel sprite with ONE oblique depth step behind it, the depth in whole pixels so the
+ *   sides step with the sprite instead of breaking into specks.
+ * - Slabs: rectangles laid one over another, each cut free of what's under it by a square gap (crisp corners, unlike
+ *   grown()).
+ * - Corner monograms: two initials as one-cube-deep walls meeting at a corner, drawn with isoPieces().
+ * From the Logomarks tools (blockparts.mjs, batch 179; corner monograms batch 181, reused by 198 and 228).
+ */
+import { U, D, poly, rect, move, mapPts, isoPieces } from '../geometry/index.js';
+import { box, exact } from '../parts/index.js';
+
+/* ---------- voxels ---------- */
+
+/**
+ * The runs of '#' (or 'X') in each row: [[c0, c1, r], …], c1 exclusive.
+ *
+ * @param {readonly string[]} rows The rows.
+ * @returns {number[][]} The runs.
+ */
+export const runs = (rows) => rows.flatMap((row, r) => [...row.matchAll(/[#X]+/g)].map((m) => [m.index, m.index + m[0].length, r]));
+
+/**
+ * A sprite standing on the iso grid's right-hand face (+x, the face that runs up to the right), read left to right:
+ * column c at y = w − c, row r at z = h − r (row 0 on top), pushed back `d` along x from x0.
+ *
+ * @param {readonly string[]} rows The sprite.
+ * @param {number} [d=1] Its depth.
+ * @param {number} [x0=0] Where it starts along x.
+ * @returns {import('../parts/iso.js').Piece[]} One box a run, for scene().
+ */
+export const voxRight = (rows, d = 1, x0 = 0) => {
+	const w = Math.max(...rows.map((r) => r.length)), h = rows.length;
+	return runs(rows).map(([c0, c1, r]) => box([x0, w - c1, h - 1 - r], [x0 + d, w - c0, h - r]));
+};
+
+/**
+ * A sprite on the left-hand face (+y, running down to the right): column c at x = c, pushed back `d` along y from y0.
+ *
+ * @param {readonly string[]} rows The sprite.
+ * @param {number} [d=1] Its depth.
+ * @param {number} [y0=0] Where it starts along y.
+ * @returns {import('../parts/iso.js').Piece[]} One box a run.
+ */
+export const voxLeft = (rows, d = 1, y0 = 0) => {
+	const h = rows.length;
+	return runs(rows).map(([c0, c1, r]) => box([c0, y0, h - 1 - r], [c1, y0 + d, h - r]));
+};
+
+/**
+ * A plan lying on the ground, raised `h` from z0: column c at x = c, row r at y = r.
+ *
+ * @param {readonly string[]} rows The plan.
+ * @param {number} [h=1] Its height.
+ * @param {number} [z0=0] Its floor.
+ * @returns {import('../parts/iso.js').Piece[]} One box a run.
+ */
+export const voxPlan = (rows, h = 1, z0 = 0) => runs(rows).map(([c0, c1, r]) => box([c0, r, z0], [c1, r + 1, z0 + h]));
+
+/**
+ * Unit cubes [[i, j, k], …] (or boxes of size s) as scene() boxes: for voxel solids built by rule rather than rows.
+ *
+ * @param {readonly (readonly number[])[]} list The cubes.
+ * @param {number} [s=1] Their size.
+ * @returns {import('../parts/iso.js').Piece[]} One box each.
+ */
+export const voxCubes = (list, s = 1) => list.map(([i, j, k]) => box([i * s, j * s, k * s], [(i + 1) * s, (j + 1) * s, (k + 1) * s]));
+
+/**
+ * Layers of plans stacked bottom up (layers[0] the ground), each `h` tall: a voxel solid drawn floor by floor.
+ *
+ * @param {readonly (readonly string[])[]} layers The plans, bottom up.
+ * @param {number} [h=1] Each layer's height.
+ * @returns {import('../parts/iso.js').Piece[]} The boxes.
+ */
+export const voxLayers = (layers, h = 1) => layers.flatMap((rows, k) => voxPlan(rows, h, k * h));
+
+/* ---------- pixel depth ---------- */
+
+/**
+ * A pixel sprite as one solid on the 512 grid: pitch p, top-left (x0, y0), each run a rect (overlapping by 0.01 as
+ * pixels() does).
+ *
+ * @param {readonly string[]} rows The sprite.
+ * @param {number} p The pitch.
+ * @param {number} [x0=0] Its left.
+ * @param {number} [y0=0] Its top.
+ * @returns {import('../geometry/types.js').Shape} The sprite.
+ */
+export const pixRuns = (rows, p, x0 = 0, y0 = 0) => U(...runs(rows).map(([c0, c1, r]) => rect(x0 + c0 * p, y0 + r * p - 0.01, (c1 - c0) * p, p + 0.02)));
+
+/**
+ * A pixel sprite with one step of depth behind it: the sprite's cells copied up to `k` pixels along `dir` (±1, ±1:
+ * up-right is [1, -1]), so the depth is the sprite's own stepped outline, never a 45° wedge, then the face cut free of
+ * it by a square gap g. Worked in cells, so two kinds of scrap are dropped before drawing: a depth cell squeezed between
+ * two face cells (the depth seen through a one-pixel notch: the two gaps leave a tab about 11 wide), and depth pieces of
+ * less than `min` pixels (beside a one-pixel step the gap leaves a lone square, a speck at 32 px), so the depth shows
+ * only along runs of two pixels or more. The cut is the face grown by g with every squeezed notch filled first, so the
+ * depth stops flush across a notch.
+ *
+ * @param {readonly string[]} rows The sprite.
+ * @param {{ dir?: number[], k?: number, g?: number, min?: number }} [o] The depth's direction ([1, -1]), its length in
+ *   pixels (1), the gap (22) and the smallest depth piece in pixels (2).
+ * @returns {import('../geometry/types.js').Shape} The mark, centred, its longest side 448.
+ */
+export const pixDepth = (rows, { dir = [1, -1], k = 1, g = 22, min = 2 } = {}) => {
+	const w = Math.max(...rows.map((r) => r.length)), h = rows.length, p = 448 / Math.max(w + k, h + k);
+	const face = new Set(runs(rows).flatMap(([c0, c1, r]) => [...Array(c1 - c0)].map((_, q) => `${c0 + q},${r}`))), has = (i, j) => face.has(`${i},${j}`);
+	const deep = new Set();
+	for (const key of face) { const [i, j] = key.split(',').map(Number); for (let a = 0; a <= k; a++) for (let b = 0; b <= k; b++) { const c = `${i + a * dir[0]},${j + b * dir[1]}`; if (!face.has(c)) deep.add(c); } }
+	const squeezed = new Set([...deep].filter((key) => { const [i, j] = key.split(',').map(Number); return (has(i - 1, j) && has(i + 1, j)) || (has(i, j - 1) && has(i, j + 1)); }));
+	for (const key of squeezed) deep.delete(key);
+	const cells = [...face, ...deep].map((c) => c.split(',').map(Number)), i0 = Math.min(...cells.map((c) => c[0])), j0 = Math.min(...cells.map((c) => c[1]));
+	const W = Math.max(...cells.map((c) => c[0])) - i0 + 1, H = Math.max(...cells.map((c) => c[1])) - j0 + 1, x0 = 256 - (W * p) / 2, y0 = 256 - (H * p) / 2;
+	const draw = (set) => (set.size ? U(...[...set].map((c) => { const [i, j] = c.split(',').map(Number); return rect(x0 + (i - i0) * p - 0.01, y0 + (j - j0) * p - 0.01, p + 0.02, p + 0.02); })) : []);
+	// the cut is the face grown by g, with every squeezed notch filled first, so the depth stops flush across a notch
+	const front = draw(face), full = U(front, draw(squeezed)), cut = U(full, ...[[1, 0], [-1, 0], [0, 1], [0, -1], [1, 1], [1, -1], [-1, 1], [-1, -1]].map(([a, b]) => move(full, a * g, b * g)));
+	return U(D(draw(deep), cut).filter((pg) => area(pg) > min * p * (p - g)), front);
+};
+
+/** A polygon's area (its outer ring less its holes). */
+const area = (pg) => pg.reduce((s, ring, i) => { let A = 0; for (let q = 0; q < ring.length; q++) { const [x1, y1] = ring[q], [x2, y2] = ring[(q + 1) % ring.length]; A += x1 * y2 - x2 * y1; } return s + (i ? -1 : 1) * Math.abs(A) / 2; }, 0);
+
+/* ---------- slabs ---------- */
+
+/**
+ * A rectangle [x, y, w, h] grown squarely by g on every side (a slab's moat: crisp corners).
+ *
+ * @param {readonly number[]} r The rectangle [x, y, w, h].
+ * @param {number} g The gap.
+ * @returns {import('../geometry/types.js').Polygon} The moat.
+ */
+export const moat = ([x, y, w, h], g) => rect(x - g, y - g, w + 2 * g, h + 2 * g);
+
+/**
+ * A convex polygon grown by g with mitred corners (a slanted slab's moat), either winding.
+ *
+ * @param {readonly (readonly number[])[]} pts The polygon's corners.
+ * @param {number} g How far.
+ * @returns {number[][]} The grown corners.
+ */
+export const mitre = (pts, g) => {
+	const n = pts.length, A = pts.reduce((s, p, i) => s + p[0] * pts[(i + 1) % n][1] - pts[(i + 1) % n][0] * p[1], 0), sg = Math.sign(A) || 1;
+	const off = pts.map((p, i) => { const q = pts[(i + 1) % n], dx = q[0] - p[0], dy = q[1] - p[1], L = Math.hypot(dx, dy); return [dy / L * sg, -dx / L * sg]; });
+	return pts.map((p, i) => { const a = off[(i - 1 + n) % n], b = off[i], s = 1 + a[0] * b[0] + a[1] * b[1]; return [p[0] + (g * (a[0] + b[0])) / s, p[1] + (g * (a[1] + b[1])) / s]; });
+};
+
+/**
+ * Slabs laid in order, each over the ones before and cut free of them by a square gap g. Each slab is a rect
+ * [x, y, w, h] or a convex polygon [[x, y], …]; the later slab keeps its edge, the earlier gives way.
+ *
+ * @param {readonly any[]} list The slabs, back to front.
+ * @param {number} [g=22] The gap.
+ * @returns {import('../geometry/types.js').Shape} The mark.
+ */
+export const slabs = (list, g = 22) => list.reduce((scene, s) => {
+	const isRect = typeof s[0] === 'number', shape = isRect ? rect(...s) : poly(s);
+	return U(D(scene, isRect ? moat(s, g) : poly(mitre(s, g))), shape);
+}, []);
+
+/**
+ * Scales a shape drawn on a unit grid by k and moves it by (x, y).
+ *
+ * @param {import('../geometry/types.js').Geom} shape The shape.
+ * @param {number} k The scale.
+ * @param {number} [x=0] Along x.
+ * @param {number} [y=0] Along y.
+ * @returns {import('../geometry/types.js').Geom} The shape, placed.
+ */
+export const onGrid = (shape, k, x = 0, y = 0) => mapPts(shape, ([a, b]) => [x + a * k, y + b * k]);
+
+/**
+ * Drops the pieces of a drawn mark thinner than `t` (2 × area ÷ perimeter): the wedge of an inner face that shows only
+ * as a sliver in the corner of a one-cube counter or notch. Its place reads as gap, as it would at 32 px anyway.
+ *
+ * @param {import('../geometry/types.js').Shape} shape The mark.
+ * @param {number} [t=12] The thinnest piece kept.
+ * @returns {import('../geometry/types.js').Shape} The mark without its slivers.
+ */
+export const dropThin = (shape, t = 12) => shape.filter((pg) => { const A = area(pg), P = pg[0].reduce((s, q, i, r) => s + Math.hypot(r[(i + 1) % r.length][0] - q[0], r[(i + 1) % r.length][1] - q[1]), 0); return (2 * A) / P >= t; });
+
+/* ---------- corner monograms ---------- */
+
+/**
+ * The wall letters: a 5-row block alphabet, one cube per '#'. Every letter is drawn for a wall one cube deep: stems and
+ * bars one cube wide, counters one cube, square corners only (a lone diagonal cube turns to crumbs in iso), and a full
+ * stem wherever the letter can share the corner pillar (A, M, H, J, U on the left; B, E, F, H, L, M, P, U on the right).
+ */
+export const WALL_GLYPH = {
+	A: ['###', '#.#', '###', '#.#', '#.#'], B: ['##.', '#.#', '###', '#.#', '###'], C: ['###', '#..', '#..', '#..', '###'],
+	D: ['##.', '#.#', '#.#', '#.#', '##.'], E: ['###', '#..', '###', '#..', '###'], F: ['###', '#..', '###', '#..', '#..'],
+	G: ['###', '#..', '#.#', '#.#', '###'], H: ['#.#', '#.#', '###', '#.#', '#.#'], J: ['..#', '..#', '..#', '#.#', '###'],
+	K: ['#.#', '#.#', '##.', '#.#', '#.#'], L: ['#..', '#..', '#..', '#..', '###'], M: ['#####', '#.#.#', '#.#.#', '#.#.#', '#.#.#'],
+	P: ['###', '#.#', '###', '#..', '#..'], R: ['###', '#.#', '##.', '#.#', '#.#'], S: ['###', '#..', '###', '..#', '###'],
+	T: ['###', '.#.', '.#.', '.#.', '.#.'], U: ['#.#', '#.#', '#.#', '#.#', '###'], W: ['#.#.#', '#.#.#', '#.#.#', '#.#.#', '#####'],
+};
+
+/**
+ * A D rounded off with stepped, face-joined corners (WALL_GLYPH's D, its corner cubes taken off, touches its right stem
+ * only at an edge). Drop the step crumbs in the counter with dropThin(…, 20).
+ */
+export const D_ROUND = ['####.', '#..##', '#...#', '#..##', '####.'];
+
+/** A four-wide S, to balance a five-wide D or M. */
+export const S_WIDE = ['####', '#...', '####', '...#', '####'];
+
+/** A four-wide L, to balance a five-wide D or M. */
+export const L_WIDE = ['#...', '#...', '#...', '#...', '####'];
+
+/** An M five wide with its middle stem half height (five full-height strokes stripe at 32 px). */
+export const M_HALF = ['#####', '#.#.#', '#.#.#', '#...#', '#...#'];
+
+/** The cubes of a glyph as [column, height] pairs (height 0 at the base row). */
+const cellsOf = (rows) => rows.flatMap((row, r) => [...row].flatMap((ch, c) => (ch === '#' ? [[c, rows.length - 1 - r]] : [])));
+/** Whether a glyph's first (side 0) or last (side 1) column is a full stem. */
+const fullStem = (rows, side) => rows.every((row) => row[side ? row.length - 1 : 0] === '#');
+
+/**
+ * Two letters on the two walls of a corner, as isoPieces() pieces: the first letter reads towards the corner, the second
+ * away from it. `inside` false is the outside corner of a block (the first wall's front face is the left-hand face on
+ * screen, the corner nearest the viewer); true is the inside corner of a room (two walls seen from inside, the corner
+ * farthest away, the letters standing in an open book). A shared stem makes the pair one piece, the stem the corner
+ * pillar; otherwise each wall stops short of the corner and is a piece of its own, so the two letters stand a gap apart
+ * round it.
+ *
+ * @param {string | readonly string[]} a The first letter (a WALL_GLYPH key or rows of its own).
+ * @param {string | readonly string[]} b The second.
+ * @param {boolean} [inside=false] An inside corner.
+ * @param {{ depth?: number, join?: boolean }} [o] The walls' depth in cubes (1, each wall thickening behind its front
+ *   face) and `join`, to make the pair one piece round the corner even without two full stems.
+ * @returns {number[][][]} The pieces (lists of cube positions).
+ */
+export const cornerPieces = (a, b, inside = false, { depth = 1, join = false } = {}) => {
+	const A = typeof a === 'string' ? WALL_GLYPH[a] : a, B = typeof b === 'string' ? WALL_GLYPH[b] : b, w1 = A[0].length, w2 = B[0].length;
+	const shared = join || (fullStem(A, 1) && fullStem(B, 0)), s = shared ? 0 : 1, e = depth - 1, deep = (f) => [...Array(depth)].map((_, t) => f(t));
+	const left = cellsOf(A).flatMap(([c, k]) => deep((t) => (inside ? [-t, w1 - 1 - c + s, k] : [c, w2 - 1 + e - t, k])));
+	const right = cellsOf(B).flatMap(([c, k]) => deep((t) => (inside ? [c + s, -t, k] : [w1 - 1 + s + e - t, w2 - 1 + e - c, k])));
+	if (!shared) return [left, right];
+	const seen = new Set(left.map((p) => p.join()));
+	return [[...left, ...right.filter((p) => !seen.has(p.join()))]];
+};
+
+/**
+ * A corner monogram for a pair ("JB", or two glyphs as [rows, rows]), drawn with an exact 22 gap once fitted: a mark
+ * function for a batch's table.
+ *
+ * @param {string | readonly (string | readonly string[])[]} pair The two letters.
+ * @param {boolean} [inside] An inside corner.
+ * @param {{ depth?: number, join?: boolean }} [o] cornerPieces()'s options.
+ * @returns {() => import('../geometry/types.js').Shape} The mark.
+ */
+export const cornerMark = (pair, inside, o) => () => exact((g) => isoPieces(cornerPieces(pair[0], pair[1], inside, o), 60, g));

package/src/letters/blackletter.d.ts

@@ -0,0 +1,31 @@
+import type { Geom, Point, Polygon, Shape } from '../geometry/types.js';
+
+/** A broad nib: its width, thickness (the hairline) and rising angle in degrees. */
+export interface Nib {
+	w?: number;
+	th?: number;
+	deg?: number;
+}
+
+/** The face's nib (width W, hairline TH, angle DEG) and its cap height CAP. */
+export const NIB: { W: number; TH: number; DEG: number; CAP: number };
+/** The nib swept along a polyline. */
+export function nib(pts: readonly (readonly number[])[], o?: Nib): Shape;
+/** Several nib strokes united. */
+export function nibs(list: readonly (readonly (readonly number[])[])[], o?: Nib): Shape;
+/** A square on its corner, s from corner to corner, centred on (x, y). */
+export function lozenge(x: number, y: number, s: number): Polygon;
+/** A cut g wide along the line through a and b, run far past both. */
+export function cutLine(a: readonly number[], b: readonly number[], g: number): Polygon;
+/** A slit g wide down an upright at x from above the cap to depth y. */
+export function splitHead(x: number, y: number, g: number): Polygon;
+/** A slit g wide up an upright at x from below the base to height y. */
+export function splitFoot(x: number, y: number, g: number): Polygon;
+/** An upright from y0 to y1 with a flag head and a lozenge foot, as a polyline for nib(). */
+export function minim(x: number, y0: number, y1: number, o?: { head?: boolean; foot?: boolean; d?: number }): Point[];
+/** A lozenge parted from the ink by the gap g. */
+export function parted(ink: Geom, z: Polygon, g: number): Shape;
+/** The blackletter capitals, each drawn with the gap g on the 440 cap. */
+export const BLACKLETTERS: Record<string, (g: number) => Shape>;
+/** A blackletter capital drawn with the gap g, centred on (256, 256). */
+export function blackLetter(k: string, g: number): Shape;