@logomarks/core 0.1.11 → 0.2.0

package/src/forms/tech.js

@@ -0,0 +1,293 @@
+/**
+ * Bold tech parts: split sparkles, the folded ribbon (Folio), beads on a lattice, slashes, lens gaps, keyed chevrons and
+ * the Kerf tile. Angles are degrees, 0 right, 90 down. From the Logomarks tools (techparts.mjs, batch 213, "Bold · Tech",
+ * and its editions in batches 220 and 227).
+ */
+import { C, D, I, U, bar, circle, grow, poly, rad, rr, sample } from '../geometry/index.js';
+import { sub, add, mul } from '../util/vec.js';
+
+// A rectangle from its corners, box(x0, y0, x1, y1): the tech marks draw their bars with it.
+export { box } from '../util/vec.js';
+
+/** @typedef {import('../geometry/types.js').Point} Point */
+/** @typedef {import('../geometry/types.js').Polygon} Polygon */
+/** @typedef {import('../geometry/types.js').Shape} Shape */
+/** @typedef {import('../geometry/types.js').Geom} Geom */
+
+/** Far enough to run a half plane off any canvas. */
+const BIG = 3000;
+
+/**
+ * A 2D vector at unit length.
+ *
+ * @param {readonly number[]} a The vector.
+ * @returns {Point} It, unit.
+ */
+const norm = (a) => { const l = Math.hypot(...a); return [a[0] / l, a[1] / l]; };
+
+/**
+ * A 2D vector turned a quarter (to its left on screen, y down).
+ *
+ * @param {readonly number[]} a The vector.
+ * @returns {Point} It, turned.
+ */
+const perp = (a) => [-a[1], a[0]];
+
+/**
+ * The dot product in 2D.
+ *
+ * @param {readonly number[]} a One vector.
+ * @param {readonly number[]} b The other.
+ * @returns {number} a · b.
+ */
+const dot2 = (a, b) => a[0] * b[0] + a[1] * b[1];
+
+/**
+ * The cross product in 2D (its z).
+ *
+ * @param {readonly number[]} a One vector.
+ * @param {readonly number[]} b The other.
+ * @returns {number} a × b.
+ */
+const cross2 = (a, b) => a[0] * b[1] - a[1] * b[0];
+
+/**
+ * The half plane left of the directed line through p along d (left: the side `perp(d)` points to).
+ *
+ * @param {readonly number[]} p A point on the line.
+ * @param {readonly number[]} d Its direction.
+ * @returns {Polygon} The half plane.
+ */
+const half = (p, d) => {
+	const u = norm(d), n = perp(u);
+	return poly([add(p, mul(u, -BIG)), add(p, mul(u, BIG)), add(add(p, mul(u, BIG)), mul(n, BIG)), add(add(p, mul(u, -BIG)), mul(n, BIG))]);
+};
+
+/**
+ * The half plane on the side of the line (p, d) that holds the point q.
+ *
+ * @param {readonly number[]} p A point on the line.
+ * @param {readonly number[]} d Its direction.
+ * @param {readonly number[]} q The point to keep.
+ * @returns {Polygon} The half plane.
+ */
+const halfWith = (p, d, q) => (cross2(norm(d), sub(q, p)) * cross2(norm(d), perp(norm(d))) > 0 ? half(p, d) : half(p, mul(d, -1)));
+
+/**
+ * A parallelogram: its bottom edge from (x, yb) w long, its top edge h higher and shifted dx right.
+ *
+ * @param {number} x The bottom edge's left end.
+ * @param {number} yb The bottom edge's height.
+ * @param {number} w The width.
+ * @param {number} h The height.
+ * @param {number} dx The top edge's shift.
+ * @returns {Polygon} The parallelogram.
+ */
+export const para = (x, yb, w, h, dx) => poly([[x, yb], [x + w, yb], [x + w + dx, yb - h], [x + dx, yb - h]]);
+
+/**
+ * Points of the circle through a, m and b, from a through m to b.
+ *
+ * @param {readonly number[]} a The start.
+ * @param {readonly number[]} m A point on the way.
+ * @param {readonly number[]} b The end.
+ * @param {number} [n=60] Steps.
+ * @returns {Point[]} The arc.
+ */
+export const arc3 = (a, m, b, n = 60) => {
+	const ax = a[0], ay = a[1], bx = m[0], by = m[1], cx = b[0], cy = b[1];
+	const d = 2 * (ax * (by - cy) + bx * (cy - ay) + cx * (ay - by));
+	const ux = ((ax * ax + ay * ay) * (by - cy) + (bx * bx + by * by) * (cy - ay) + (cx * cx + cy * cy) * (ay - by)) / d;
+	const uy = ((ax * ax + ay * ay) * (cx - bx) + (bx * bx + by * by) * (ax - cx) + (cx * cx + cy * cy) * (bx - ax)) / d;
+	const r = Math.hypot(ax - ux, ay - uy), t = (p) => Math.atan2(p[1] - uy, p[0] - ux); let t0 = t(a), t1 = t(m), t2 = t(b);
+	const ccw = (x, y) => ((y - x) % (2 * Math.PI) + 2 * Math.PI) % (2 * Math.PI); // sweep from x to y anticlockwise (in y-down terms, increasing angle)
+	const s = ccw(t0, t1) < ccw(t0, t2) ? ccw(t0, t2) : ccw(t0, t2) - 2 * Math.PI;
+	return sample((u) => [ux + r * Math.cos(t0 + s * u), uy + r * Math.sin(t0 + s * u)], 0, 1, n);
+};
+
+/**
+ * The point at radius r and angle deg from a centre.
+ *
+ * @param {number} r The radius.
+ * @param {number} deg The angle.
+ * @param {readonly number[]} [c=[C, C]] The centre.
+ * @returns {Point} The point.
+ */
+const at = (r, deg, c = [C, C]) => [c[0] + r * Math.cos(rad(deg)), c[1] + r * Math.sin(rad(deg))];
+
+/**
+ * A concave star about the canvas centre: n tips at radius R (`tips` scales single tips), each side a quadratic curve
+ * pulled in towards a control point at radius rc on the mid angle (rc 0 pulls every side to the centre), so the sides meet
+ * the tips without crossing.
+ *
+ * @param {number} n The tips.
+ * @param {number} R Their radius.
+ * @param {number} [rc=0] The sides' control radius.
+ * @param {number} [deg=-90] The first tip's angle.
+ * @param {readonly number[]} [tips=[]] Per-tip radius factors.
+ * @returns {Polygon} The star.
+ */
+export const star = (n, R, rc = 0, deg = -90, tips = []) => {
+	const pts = [];
+	for (let i = 0; i < n; i++) {
+		const a = deg + (i * 360) / n, b = a + 360 / n, p0 = at(R * (tips[i] ?? 1), a), p1 = at(rc, a + 180 / n), p2 = at(R * (tips[(i + 1) % n] ?? 1), b);
+		pts.push(...sample((t) => [(1 - t) ** 2 * p0[0] + 2 * t * (1 - t) * p1[0] + t * t * p2[0], (1 - t) ** 2 * p0[1] + 2 * t * (1 - t) * p1[1] + t * t * p2[1]], 0, 1, 64).slice(0, -1));
+	}
+	return poly(pts);
+};
+
+/**
+ * A gap g wide across a star's arm at angle deg, d from the centre.
+ *
+ * @param {number} deg The arm's angle.
+ * @param {number} d The distance from the centre.
+ * @param {number} g The gap.
+ * @returns {Polygon} The cut.
+ */
+export const armCut = (deg, d, g) => {
+	const p = at(d, deg), u = [Math.cos(rad(deg)), Math.sin(rad(deg))], n = perp(u);
+	return bar(add(p, mul(n, -400)), add(p, mul(n, 400)), g);
+};
+
+/**
+ * A ribbon B wide along the polyline pts, drawn as outlines t wide. Each turn is a fold: the crease runs through the
+ * corner along the bisector of the two directions (so the outer corner is cut on it), and each later facet lies over the
+ * one before, hiding its lines. Ends are cut square. Every facet's outline is drawn t/2 inside it, and the silhouette's
+ * another t/2, so shared folds and the outer edge are all t wide.
+ *
+ * @param {readonly Point[]} pts The ribbon's centreline.
+ * @param {number} B Its width.
+ * @param {number} t The outline's width.
+ * @returns {Shape} The ribbon's lines.
+ */
+export const ribbon = (pts, B, t) => {
+	const n = pts.length - 1, v = [...Array(n)].map((_, i) => norm(sub(pts[i + 1], pts[i])));
+	const crease = (k) => (k === 0 ? perp(v[0]) : k === n ? perp(v[n - 1]) : (Math.hypot(...add(v[k - 1], v[k])) < 1e-6 ? perp(v[k]) : add(v[k - 1], v[k])));
+	const facets = v.map((u, i) => {
+		const a = pts[i], b = pts[i + 1], nn = perp(u);
+		const strip = poly([add(add(a, mul(u, -BIG)), mul(nn, -B / 2)), add(add(a, mul(u, BIG)), mul(nn, -B / 2)), add(add(a, mul(u, BIG)), mul(nn, B / 2)), add(add(a, mul(u, -BIG)), mul(nn, B / 2))]);
+		return I(strip, halfWith(a, crease(i), b), halfWith(b, crease(i + 1), a));
+	});
+	const vis = facets.map((f, i) => (i < n - 1 ? D(f, ...facets.slice(i + 1)) : f)); // what each facet shows under the later ones
+	const all = U(...facets), ring = (s, w) => D(s, grow(s, -w)); // a line w wide just inside the outline (sharp corners kept)
+	return U(ring(all, t / 2), ...vis.map((s) => ring(s, t / 2)));
+};
+
+/**
+ * Equal discs on a lattice of pitch p, the gap g between neighbours: cells as [col, row] in pitch units.
+ *
+ * @param {readonly (readonly number[])[]} cells The lattice points.
+ * @param {number} g The gap.
+ * @param {number} [p=130] The pitch.
+ * @returns {Shape} The beads.
+ */
+export const beads = (cells, g, p = 130) => U(...cells.map(([x, y]) => circle(x * p, y * p, (p - g) / 2, 160)));
+
+/** √3 / 2: a hexagonal lattice's row pitch, in pitch units. */
+export const H3 = Math.sqrt(3) / 2;
+
+/**
+ * A bar w wide leaning `lean`° right of upright, its centreline through (x, ym), cut flat at y0 and y1.
+ *
+ * @param {number} x The centreline's x at ym.
+ * @param {number} ym The height it passes x at.
+ * @param {number} w The width (square to the bar).
+ * @param {number} lean The lean, degrees.
+ * @param {number} y0 The top cut.
+ * @param {number} y1 The bottom cut.
+ * @returns {Polygon} The slash.
+ */
+export const slash = (x, ym, w, lean, y0, y1) => {
+	const t = Math.tan(rad(lean)), xa = (y) => x + (ym - y) * t, hw = w / 2 / Math.cos(rad(lean));
+	return poly([[xa(y1) - hw, y1], [xa(y1) + hw, y1], [xa(y0) + hw, y0], [xa(y0) - hw, y0]]);
+};
+
+/**
+ * The lens marks' disc: radius 224, centred, 720 points.
+ *
+ * @returns {Polygon} The disc.
+ */
+export const DISC = () => circle(C, C, 224, 720);
+
+/**
+ * A lens gap from p to q: two arcs bowing w apart at the middle and meeting at p and q (run it on past the rim).
+ *
+ * @param {readonly number[]} p One end.
+ * @param {readonly number[]} q The other.
+ * @param {number} w Its width at the middle.
+ * @returns {Polygon} The gap.
+ */
+export const lensGap = (p, q, w) => {
+	const m = mul(add(p, q), 0.5), n = perp(norm(sub(q, p)));
+	return poly([...arc3(p, add(m, mul(n, w / 2)), q, 60), ...arc3(q, add(m, mul(n, -w / 2)), p, 60).slice(1, -1)]);
+};
+
+/**
+ * A chevron: outer apex P, arms running out along A and B (directions from P), w wide inward; long, so a box clips the
+ * ends.
+ *
+ * @param {readonly number[]} P The apex.
+ * @param {readonly number[]} A One arm's direction.
+ * @param {readonly number[]} B The other's.
+ * @param {number} w The width.
+ * @param {number} [L=1400] The arms' length.
+ * @returns {Polygon} The chevron.
+ */
+export const techChevron = (P, A, B, w, L = 1400) => {
+	const u1 = norm(A), u2 = norm(B), bis = norm(add(u1, u2)), th = Math.acos(dot2(u1, u2));
+	const side = (u, o) => { const n = perp(u); return dot2(n, o) > 0 ? n : mul(n, -1); }, n1 = side(u1, u2), n2 = side(u2, u1);
+	const Q = add(P, mul(bis, w / Math.sin(th / 2)));
+	return poly([P, add(P, mul(u1, L)), add(add(P, mul(u1, L)), mul(n1, w)), Q, add(add(P, mul(u2, L)), mul(n2, w)), add(P, mul(u2, L))]);
+};
+
+/**
+ * A slab w wide from a to b whose b end is cut to a 90° point (two 45° chamfers): the key of a Keyed letter.
+ *
+ * @param {readonly number[]} a The square end.
+ * @param {readonly number[]} b The point.
+ * @param {number} w The width.
+ * @returns {Polygon} The slab.
+ */
+export const pointed = (a, b, w) => {
+	const u = norm(sub(b, a)), n = perp(u), h = w / 2, back = add(b, mul(u, -h));
+	return poly([add(a, mul(n, h)), add(back, mul(n, h)), b, add(back, mul(n, -h)), add(a, mul(n, -h))]);
+};
+
+/**
+ * Two Keyed slabs parted: the notched slab loses the key grown by g, so the gap is even round the point.
+ *
+ * @param {Geom} notched The slab the key goes into.
+ * @param {Geom} key The key.
+ * @param {number} g The gap.
+ * @returns {Shape} Both.
+ */
+export const keyed = (notched, key, g) => U(D(notched, grow(key, g)), key);
+
+/**
+ * The Kerf tile: a 448 square from the origin, its corners rounded 78 (about 17%: a rounded square, never a squircle).
+ *
+ * @returns {Polygon} The tile.
+ */
+export const TILE = () => rr(0, 0, 448, 448, 78);
+
+/** The folded ribbon letters' width. */
+export const RB = 124;
+
+/** The folded ribbon letters' outline width once fitted. */
+export const RT = 24;
+
+/**
+ * A folded ribbon letter along pts, RB wide, its outline RT wide once fitted.
+ *
+ * @param {readonly Point[]} pts The centreline.
+ * @returns {(g: number) => Shape} The build of the gap.
+ */
+export const rib = (pts) => (g) => ribbon(pts, RB, (g * RT) / 22);
+
+/**
+ * The four-point star both sparkles break: radius 224, its sides pulled to a control point 40 out, so the arms stay
+ * chunky.
+ *
+ * @returns {Polygon} The star.
+ */
+export const SPARK = () => star(4, 224, 40);

package/src/forms/tracks.d.ts

@@ -0,0 +1,36 @@
+import type { Point, Ring, Polygon, Shape, Geom } from '../geometry/types.js';
+
+/** The source-unit helpers trackKit(K) returns. */
+export interface TrackKit {
+	/** A solid built in source units, drawn K larger. */
+	S(g: Geom): Geom;
+	/** A loop's centreline: a region's boundary, corners rounded r1 (inner) and r2 (outer), resampled evenly. */
+	ring(region: Geom, r1?: number, r2?: number): Point[];
+	/** A solid cut a house gap clear of tracks. */
+	off(sol: Geom, ...tracks: Geom[]): Shape;
+	/** A solid kept only outside a loop's centreline, a gap clear of its outer track. */
+	out(sol: Geom, o: Point[]): Shape;
+	/** A solid kept only inside a loop's centreline, a gap clear of the inner track. */
+	within(sol: Geom, o: Point[]): Shape;
+}
+
+/** Source units to drawing units, for the fixed-K editions (1.6). */
+export const TRACK_K: number;
+/** A closed ring resampled every `step` along its length. */
+export function evenRing(o: readonly Point[], step?: number): Point[];
+/** The source-unit helpers at a fixed K. */
+export function trackKit(K?: number): TrackKit;
+/** A closed region from a radius function round (cx, cy), every 2 degrees. */
+export function radial(cx: number, cy: number, f: (a: number) => number): Polygon;
+/** A drop pointing up: a disc of radius r at (x, y), its point h above the centre. */
+export function drop(x: number, y: number, r: number, h: number): Shape;
+/** A shape's area: outer rings less their holes. */
+export function sArea(s: Shape): number;
+/** Whether a point lies inside a ring (even-odd). */
+export function inRing(r: readonly Point[], p: readonly number[]): boolean;
+/** A ring's box centre. */
+export function mid(r: Ring): Point;
+/** The largest outer ring of a shape, its closing point dropped. */
+export function largest(s: Shape): Point[];
+/** A cut shape's parts, less any piece under `min`. */
+export function parts2(s: Shape, min?: number): Shape;

package/src/forms/tracks.js

@@ -0,0 +1,121 @@
+/**
+ * Track editions: a mark redrawn as two-track loops (the kit's trackLoop with the house Duo, the gap between the tracks)
+ * round its solid parts. A source is drawn in source units and scaled K into drawing units; trackKit(K) gives the
+ * source-unit helpers at a fixed K, and the rest split a live source into its parts.
+ * From the Logomarks tools (trackparts.mjs, the helpers every Track edition generator had copied; shared since Drop 35).
+ */
+import { U, D, I, poly, circle, grow, scale, soften, area, bbox } from '../geometry/index.js';
+import { inside } from '../objects/animals.js';
+
+/** Source units to drawing units, for the editions drawn at a fixed K. */
+export const TRACK_K = 1.6;
+
+/**
+ * A closed ring resampled every `step` along its length (soften()'s rings crowd points at the arcs, and two points a
+ * hair apart turn a track's offset normals: the loop frays).
+ *
+ * @param {readonly import('../geometry/types.js').Point[]} o The ring (open: its first point not repeated).
+ * @param {number} [step=6] The spacing.
+ * @returns {import('../geometry/types.js').Point[]} The resampled ring.
+ */
+export function evenRing(o, step = 6) {
+	const n = o.length, seg = o.map((p, i) => Math.hypot(o[(i + 1) % n][0] - p[0], o[(i + 1) % n][1] - p[1])), L = seg.reduce((a, b) => a + b, 0), m = Math.round(L / step), out = [];
+	let i = 0, acc = 0;
+	for (let k = 0; k < m; k++) { const d = (k * L) / m; while (acc + seg[i] < d) acc += seg[i++]; const t = seg[i] ? (d - acc) / seg[i] : 0, a = o[i], b = o[(i + 1) % n]; out.push([a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t]); }
+	return out;
+}
+
+/**
+ * The source-unit helpers at a fixed K:
+ *
+ * - `S(g)`: a solid built in source units, drawn K larger;
+ * - `ring(region, r1, r2)`: a loop's centreline, the boundary of a region drawn in source units, its inner corners
+ *   rounded r1 and outer r2 (drawing units, 60 or more): the largest ring, its closing point dropped, resampled evenly;
+ * - `off(sol, ...tracks)`: a solid (source units) cut a house gap clear of tracks (drawing units);
+ * - `out(sol, o)`: a solid (source units) kept only outside a loop's centreline o, a gap clear of its outer track;
+ * - `within(sol, o)`: a solid (source units) kept only inside a loop's centreline o, a gap clear of the inner track.
+ *
+ * @param {number} [K=TRACK_K] Source units to drawing units.
+ * @returns {{ S: (g: import('../geometry/types.js').Geom) => import('../geometry/types.js').Geom, ring: (region: import('../geometry/types.js').Geom, r1?: number, r2?: number) => import('../geometry/types.js').Point[], off: (sol: import('../geometry/types.js').Geom, ...tracks: import('../geometry/types.js').Geom[]) => import('../geometry/types.js').Shape, out: (sol: import('../geometry/types.js').Geom, o: import('../geometry/types.js').Point[]) => import('../geometry/types.js').Shape, within: (sol: import('../geometry/types.js').Geom, o: import('../geometry/types.js').Point[]) => import('../geometry/types.js').Shape }}
+ *   The helpers.
+ */
+export const trackKit = (K = TRACK_K) => {
+	const S = (g) => scale(g, K, 0, 0);
+	const ring = (region, r1 = 64, r2 = 64) => {
+		const g = soften(S(region), r1, r2), area = (r) => Math.abs(r.reduce((s, p, i) => { const q = r[(i + 1) % r.length]; return s + p[0] * q[1] - q[0] * p[1]; }, 0));
+		let best = null; for (const pg of g) if (!best || area(pg[0]) > area(best)) best = pg[0];
+		const o = best.slice(); if (Math.hypot(o[0][0] - o.at(-1)[0], o[0][1] - o.at(-1)[1]) < 0.01) o.pop(); return evenRing(o);
+	};
+	const off = (sol, ...trs) => D(S(sol), grow(U(...trs), 22));
+	const out = (sol, o) => D(S(sol), grow(poly(o), 37 + 22));
+	const within = (sol, o) => I(S(sol), inside(o));
+	return { S, ring, off, out, within };
+};
+
+/**
+ * A closed region from a radius function round (cx, cy), sampled every 2 degrees.
+ *
+ * @param {number} cx The centre.
+ * @param {number} cy The centre.
+ * @param {(a: number) => number} f The radius at the angle a (radians).
+ * @returns {import('../geometry/types.js').Polygon} The region.
+ */
+export const radial = (cx, cy, f) => poly(Array.from({ length: 180 }, (_, i) => { const a = (i * 2 * Math.PI) / 180, r = f(a); return [cx + r * Math.cos(a), cy + r * Math.sin(a)]; }));
+
+/**
+ * A drop pointing up: a disc of radius r at (x, y) and its point h above the centre.
+ *
+ * @param {number} x The disc's centre.
+ * @param {number} y The disc's centre.
+ * @param {number} r Its radius.
+ * @param {number} h How far above the centre the point is.
+ * @returns {import('../geometry/types.js').Shape} The drop.
+ */
+export const drop = (x, y, r, h) => { const t = Math.asin(r / h); return U(circle(x, y, r), poly([[x, y - h], [x + r * Math.cos(t), y - r * Math.sin(t)], [x - r * Math.cos(t), y - r * Math.sin(t)]])); };
+
+/* ---------- splitting a live source ---------- */
+
+/**
+ * A shape's area: its outer rings less their holes.
+ *
+ * @param {import('../geometry/types.js').Shape} s The shape.
+ * @returns {number} The area.
+ */
+export const sArea = (s) => s.reduce((t, pg) => t + area(pg[0]) - pg.slice(1).reduce((h, r) => h + area(r), 0), 0);
+
+/**
+ * Whether a point lies inside a ring (even-odd).
+ *
+ * @param {readonly import('../geometry/types.js').Point[]} r The ring.
+ * @param {readonly number[]} p The point.
+ * @returns {boolean} True inside.
+ */
+export const inRing = (r, [px, py]) => { let c = false; for (let i = 0, j = r.length - 1; i < r.length; j = i++) { const [a, b] = [r[i], r[j]]; if ((a[1] > py) !== (b[1] > py) && px < ((b[0] - a[0]) * (py - a[1])) / (b[1] - a[1]) + a[0]) c = !c; } return c; };
+
+/**
+ * A ring's box centre.
+ *
+ * @param {import('../geometry/types.js').Ring} r The ring.
+ * @returns {import('../geometry/types.js').Point} The centre of its box.
+ */
+export const mid = (r) => { const [x0, y0, x1, y1] = bbox([[r]]); return [(x0 + x1) / 2, (y0 + y1) / 2]; };
+
+/**
+ * The largest outer ring of a shape, its closing point dropped.
+ *
+ * @param {import('../geometry/types.js').Shape} s The shape.
+ * @returns {import('../geometry/types.js').Point[]} The ring.
+ */
+export const largest = (s) => {
+	let best = null; for (const pg of s) if (!best || area(pg[0]) > area(best)) best = pg[0];
+	const o = best.slice(); if (Math.hypot(o[0][0] - o.at(-1)[0], o[0][1] - o.at(-1)[1]) < 0.01) o.pop(); return o;
+};
+
+/**
+ * A cut shape's parts, less any piece under `min` (drawing units): a limb's stub left between two cuts.
+ *
+ * @param {import('../geometry/types.js').Shape} s The cut shape.
+ * @param {number} [min=1000] The smallest piece kept.
+ * @returns {import('../geometry/types.js').Shape} The parts.
+ */
+export const parts2 = (s, min = 1000) => s.filter((pg) => area(pg[0]) >= min);

package/src/index.js

@@ -1,7 +1,8 @@
 /**
  * @logomarks/core: geometry, SVG reading, fitting, analysis, similarity, shape edits and stitch plans for logomarks
  * on a 512 grid. Each area is also its own subpath (`/geometry`, `/svg`, `/fit`, `/raster`, `/analyse`, `/similar`, `/edit`, `/stitch`,
- * and `/parts` for the industry-symbol parts, which needs Node for its batch writer).
+ * and `/parts` for the industry-symbol parts, which needs Node for its batch writer). The parts subpaths (`/iso`, `/letters`,
+ * `/font`, `/pixels`, `/objects`, `/forms`) and `/batch` are imported on their own: their names would clash here.
  */
 export * from './geometry/index.js';
 export { parsePath, bezierAt, arcOf, arcAt, attr, shapes, viewBox, body, outlinePoints, bounds, rings, filledShape } from './svg/index.js';

package/src/iso/index.d.ts

@@ -0,0 +1,5 @@
+export * from './objects.js';
+export * from './planes.js';
+export * from './voxels.js';
+export type { Part, Flat } from './objects.js';
+export type { PlaneView } from './planes.js';

package/src/iso/index.js

@@ -0,0 +1,13 @@
+/**
+ * @module @logomarks/core/iso
+ *
+ * Iso parts on top of the parts' solid engine (`scene()` in /parts): iso objects (cylinders, frustums, lathes, roofs,
+ * shops with their trade feature, openings cut on the fitted faces, cut-outs square to the viewer drawn by isoFlat(),
+ * tipped slabs), flat planes hinged and folded into a scene (planeScene(), iso or oblique), and voxels (sprites and
+ * plans as boxes, a pixel sprite with one step of depth, slabs with square gaps, corner monograms). x runs to the front
+ * right, y to the front left, z up. The 2D outline helpers here (rect, rr, disc, circ, ell, lens, rot, stroke, band)
+ * return point lists for flat() and cuts, not kit shapes.
+ */
+export * from './objects.js';
+export * from './planes.js';
+export * from './voxels.js';

package/src/iso/objects.d.ts

@@ -0,0 +1,168 @@
+import type { Point, Point3, Shape } from '../geometry/types.js';
+import type { FittedProjection, Piece } from '../parts/iso.js';
+
+export { cross3 } from '../util/vec.js';
+
+/** A part: one convex piece, or a list of pieces drawn as one solid. */
+export type Part = Piece | Piece[];
+/** 2D points on a face or a plane. */
+type Pts = readonly (readonly number[])[];
+/** A cut-out square to the viewer, from flat(): its outlines and holes on the facing plane and its depth. */
+export interface Flat {
+	outer: number[][][];
+	holes: number[][][];
+	back: number[];
+}
+
+/** The projection scene() fits round these parts. */
+export function fitOf(parts: readonly Part[]): FittedProjection;
+/** The house gap in model units for these parts. */
+export function gapIn(parts: readonly Part[], g: number): number;
+/** 2D points on the face of axis ax at at, as 3D points. */
+export function onFace(ax: 'x' | 'y' | 'z', at: number, pts: Pts): Point3[];
+/** 2D points on the plane o + a·u + b·v, as 3D points. */
+export function onPlane(o: readonly number[], u: readonly number[], v: readonly number[], pts: Pts): Point3[];
+/** Rectangles [a0, b0, a1, b1] on a face, as 3D quads. */
+export function quads(ax: 'x' | 'y' | 'z', at: number, rects: Pts): Point3[][];
+/** A disc of radius r at (a, b) on a face. */
+export function discOn(ax: 'x' | 'y' | 'z', at: number, a: number, b: number, r: number, n?: number): Point3[];
+/** A 2D shape as 3D outlines on the +x or +y face, f model units a canvas unit, centred on (ca, cb). */
+export function shapeOn(ax: 'x' | 'y', at: number, shape: Shape, f: number, ca: number, cb: number): Point3[][];
+/** Iso parts drawn, the 3D outlines in holes cut through them and those in keep put back. */
+export function isoCut(parts: readonly Part[], g: number, holes?: readonly Pts[], keep?: readonly Pts[]): Shape;
+/** A cylinder along x. */
+export function cylX(cy: number, cz: number, r: number, x0: number, x1: number, n?: number): Piece;
+/** A cylinder along y. */
+export function cylY(cx: number, cz: number, r: number, y0: number, y1: number, n?: number): Piece;
+/** An upright frustum, radius r0 at z0 to r1 at z1, n sides turned deg. */
+export function frustum(cx: number, cy: number, r0: number, r1: number, z0: number, z1: number, n?: number, deg?: number): Piece;
+/** A slab hinged on a line along y, leaning back by deg. */
+export function leaning(x: number, z: number, y0: number, y1: number, h: number, t: number, deg: number): Piece;
+/** A flap hinged on the edge p0–p1, folded out along out by deg. */
+export function flap(p0: readonly number[], p1: readonly number[], out: readonly number[], deg: number, L: number, t: number): Piece;
+/** A square-section bar between two 3D points. */
+export function rod(a: readonly number[], b: readonly number[], w: number): Piece;
+/** A round bar between two 3D points, one smooth side. */
+export function tube(a: readonly number[], b: readonly number[], r: number, n?: number): Piece;
+/** A vehicle's wheels on its +y side at y = W. */
+export function wheels(xs: readonly number[], W: number, r?: number, z?: number): Piece[];
+/** A rectangle on the tangent plane at the front of an upright cylinder. */
+export function cylFront(cx: number, cy: number, r: number, w: number, z0: number, z1: number): Point3[];
+/** A ball as one part: rings of frustums, squashed and cut between two latitudes. */
+export function ball(cx: number, cy: number, cz: number, r: number, o?: { squash?: number; rings?: number; from?: number; to?: number }): Piece[];
+/** A band along an arc in a side profile (x, z), pushed along y. */
+export function arcSide(cx: number, cz: number, r0: number, r1: number, a0: number, a1: number, y0: number, y1: number, n?: number): Piece[];
+/** A band along an arc in a front profile (y, z), pushed along x. */
+export function arcFront(cy: number, cz: number, r0: number, r1: number, a0: number, a1: number, x0: number, x1: number, n?: number): Piece[];
+/** A gable roof, its ridge along y. */
+export function roofY(x0: number, x1: number, y0: number, y1: number, z0: number, rise: number): Piece;
+/** A gable roof, its ridge along x. */
+export function roofX(x0: number, x1: number, y0: number, y1: number, z0: number, rise: number): Piece;
+/** A shop block with its shopfront cuts and its roof's centre. */
+export function shop(W: number, D: number, H: number, o?: { win?: boolean; door?: number | null; dh?: number }): { parts: Piece[]; cuts: Point3[][]; c: Point3 };
+/** A flat convex profile standing on the roof facing +y. */
+export function sign(pts: Pts, yc: number, t?: number): Piece;
+/** A disc on edge facing +y. */
+export function discY(x: number, z: number, r: number, yc: number, t?: number): Piece;
+/** A disc on edge facing +x. */
+export function discX(y: number, z: number, r: number, xc: number, t?: number): Piece;
+/** 3D points scaled about o by k. */
+export function sc3(pts: Pts, o: readonly number[], k: number): number[][];
+/** A part scaled about o by k. */
+export function scalePart<T extends Part>(part: T, o: readonly number[], k: number): T;
+/** A shop with its trade feature, as a build (g) => shape. */
+export function shopMark(size: readonly number[], feat: (c: number[], W: number, D: number, H: number, k: number) => unknown[], o?: { win?: boolean; door?: number | null; dh?: number; big?: number }): (g: number) => Shape;
+/** A box tapering from w × d at z0 to W × D at z1. */
+export function taper(cx: number, cy: number, w: number, d: number, W: number, D: number, z0: number, z1: number): Piece;
+/** An open box's floor and walls. */
+export function tray(x0: number, y0: number, x1: number, y1: number, h: number, t: number, z0?: number): Piece[];
+/** The facing plane's right-hand axis, along (1, −1, 0). */
+export const FU: Point3;
+/** The facing plane's normal, along (1, 1, 0). */
+export const FN: Point3;
+/** 2D points on the facing plane through o, pushed s towards the viewer. */
+export function onFacing(o: readonly number[], pts: Pts, s?: number): Point3[];
+/** A convex profile on the facing plane, t deep. */
+export function facing(o: readonly number[], pts: Pts, t: number, smooth?: boolean): Piece;
+/** An annulus band on the facing plane, t deep, as convex pieces. */
+export function facingArc(o: readonly number[], c: readonly number[], r0: number, r1: number, a0: number, a1: number, t: number, n?: number): Piece[];
+/** A lathe through a [radius, height] profile. */
+export function lathe(cx: number, cy: number, prof: Pts, n?: number): Piece[];
+/** A cut-out square to the viewer, for isoFlat(). */
+export function flat(o: readonly number[], outer: readonly Pts[], t: number, holes?: readonly Pts[]): Flat;
+/** A 2D outline turned anticlockwise. */
+export function ccw<T extends Pts>(pts: T): T;
+/** flat() with every outline and hole turned anticlockwise. */
+export function flatCcw(o: readonly number[], outer: readonly Pts[], t: number, holes?: readonly Pts[]): Flat;
+/** A flat() scaled about o by k. */
+export function scaleFlat(f: Flat, o: readonly number[], k: number): Flat;
+/** A 2D shape swept along the screen vector v. */
+export function sweep(sh: Shape, v: readonly number[]): Shape;
+/** isoCut() with flat() cut-outs in front of the parts. */
+export function isoFlat(parts: readonly Part[], g: number, flats: readonly Flat[], holes?: readonly Pts[], keep?: readonly Pts[]): Shape;
+/** Points round an ellipse from d0 to d1 degrees (2D, both ends). */
+export function arcPts(a: number, b: number, ra: number, rb: number, d0: number, d1: number, n?: number): Point[];
+/** A slot w wide along p–q, as a quad. */
+export function slot2(p: readonly number[], q: readonly number[], w: number): Point[];
+/** A ring of gap w wide at radius r, as small quads. */
+export function ring2(a: number, b: number, r: number, w: number, n?: number): Point[][];
+/** A part re-aimed: each point to T + x·e1 + y·e2 + z·e3. */
+export function turned<T extends Part>(part: T, T: readonly number[], e1: readonly number[], e2: readonly number[], e3: readonly number[]): T;
+/** A capsule's lathe profile. */
+export function capsule(r: number, L: number, both?: boolean): number[][];
+/** A part built up z turned so its z axis runs from a towards b. */
+export function aimed<T extends Part>(part: T, a: readonly number[], b: readonly number[]): T;
+/** A round pole from a to b. */
+export function pole(a: readonly number[], b: readonly number[], r: number): Piece;
+/** A lathe laid along the horizontal unit vector u, its middle at c. */
+export function lying<T extends Part>(part: T, c: readonly number[], u: readonly number[], len: number): T;
+/** The gap in model units for parts plus flat() cut-outs. */
+export function gapWith(parts: readonly Part[], flats: readonly Flat[], g: number): number;
+/** A circle as n 2D points. */
+export function circ(a: number, b: number, r: number, n?: number): Point[];
+/** A quad along an arm at d degrees from r0 to r1. */
+export function arm(cx: number, cy: number, d: number, r0: number, r1: number, w: number, w1?: number): Point[];
+/** 2D points turned deg anticlockwise about c. */
+export function rot(pts: Pts, deg: number, c?: readonly number[]): Point[];
+/** An ellipse as 2D points, turned deg. */
+export function ell(a: number, b: number, ra: number, rb: number, deg?: number, n?: number): Point[];
+/** The facing plane's vertical foreshortening, √(2/3). */
+export const SQ: number;
+/** A circle on the facing plane that projects round. */
+export function rnd(a: number, b: number, r: number, n?: number): Point[];
+/** A disc's outline as 2D points. */
+export function disc(a: number, b: number, r: number, n?: number): Point[];
+/** A rectangle with rounded corners, as 2D points. */
+export function rr(a0: number, b0: number, a1: number, b1: number, r: number, n?: number): Point[];
+/** An almond from p to q, w wide. */
+export function lens(p: readonly number[], q: readonly number[], w: number, n?: number): Point[];
+/** A slot along a polyline, one quad a segment. */
+export function path2(pts: Pts, w: number): Point[][];
+/** 2D outlines as cuts on the front face of a flat(). */
+export function flatCuts(o: readonly number[], t: number, list: readonly Pts[]): Point3[][];
+/** A roof feature of flat() cut-outs, as shopMark()'s feat. */
+export function roofFlats(fn: (o: number[], k: number) => { flats: Flat[]; cuts?: unknown[]; keep?: unknown[] }): (c: number[], W: number, D: number, H: number, k: number) => unknown[];
+/** A spiral slot as 2D quads. */
+export function spiral(a: number, b: number, r0: number, r1: number, turns: number, w: number, n?: number): Point[][];
+/** Pieces whose side faces merge into one surface. */
+export function smooth(ps: readonly Piece[]): Piece[];
+/** A flame outline, about its foot. */
+export function flame(a: number, b: number, h: number): Point[];
+/** A thick 2D stroke as convex pieces. */
+export function stroke(pts: Pts, w: number): Point[][];
+/** An annulus band as convex 2D quads. */
+export function band(a: number, b: number, r0: number, r1: number, d0: number, d1: number, n?: number): Point[][];
+/** 2D points moved by (da, db). */
+export function mv(pts: Pts, da: number, db: number): Point[];
+/** A rectangle a0–a1 × b0–b1, as four 2D points. */
+export function rect(a0: number, b0: number, a1: number, b1: number): Point[];
+/** A kit glyph on a plane: its outlines to cut and counters to keep. */
+export function glyphOn(k: string, o: readonly number[], u: readonly number[], v: readonly number[], h: number, T?: number): { cut: Point3[][]; keep: Point3[][] };
+/** A 3D point moved by k times v. */
+export function add3(p: readonly number[], v: readonly number[], k?: number): number[];
+/** A ring of gap round a 3D outline, measured on the canvas. */
+export function ringIn(parts: readonly Part[], s: Shape, q: Pts, g: number): Shape;
+/** Keys tiling a 3D outline, cut as islands a canvas gap apart. */
+export function keysIn(parts: readonly Part[], s: Shape, area: Pts, keys: readonly Pts[], g: number): Shape;
+/** A slab tipped back by deg from upright. */
+export function slab(o: readonly number[], deg: number, outline: Pts, t: number, o2?: { dir?: 'x' | 'y'; smooth?: boolean }): { part: Piece; on: (pts: Pts) => number[][]; n: Point3 };