@logomarks/core 0.1.11 → 0.2.0

package/src/objects/weapons.js

@@ -0,0 +1,179 @@
+/**
+ * Weapons and blades: the parts a knife, a sword, an axe, an archery or a shooting mark is drawn from. Every part is drawn
+ * about the origin (y down), pointing right (+x) unless it says otherwise, and returns its pieces separately so a mark can
+ * part them with the house gap (`chain()`, `over()`). From the Logomarks tools (weaponparts.mjs, batch 173).
+ */
+import { U, poly, circle, rect, rr, sample, over, move, mapPts, annulus, joinPts as run } from '../geometry/index.js';
+import { turn } from '../parts/index.js';
+
+/**
+ * Turns a shape drawn about the origin by `deg` (clockwise on screen), then moves it by (dx, dy).
+ *
+ * @param {import('../geometry/types.js').Geom} s The shape.
+ * @param {number} deg The turn, in degrees.
+ * @param {number} [dx=0] The move, x.
+ * @param {number} [dy=0] The move, y.
+ * @returns {import('../geometry/types.js').Shape} The placed shape.
+ */
+export const place = (s, deg, dx = 0, dy = 0) => move(turn(s, deg), dx, dy);
+
+/**
+ * Mirrors a shape left to right about x = 0.
+ *
+ * @param {import('../geometry/types.js').Geom} s The shape.
+ * @returns {import('../geometry/types.js').Shape} The mirrored shape.
+ */
+export const flip = (s) => mapPts(s, ([x, y]) => [-x, y]);
+
+/**
+ * A quadratic Bézier from p0 through the control point c to p1, as n + 1 points.
+ *
+ * @param {readonly number[]} p0 The start.
+ * @param {readonly number[]} c The control point.
+ * @param {readonly number[]} p1 The end.
+ * @param {number} [n=24] The steps.
+ * @returns {import('../geometry/types.js').Point[]} The curve.
+ */
+export const bez = (p0, c, p1, n = 24) => sample((t) => [0, 1].map((d) => (1 - t) ** 2 * p0[d] + 2 * (1 - t) * t * c[d] + t * t * p1[d]), 0, 1, n);
+
+/**
+ * A blade from the heel (x = 0) to the tip (x = L), spine on top, H deep at the heel, as a polygon's points: 'chef' (the
+ * spine dropping and the edge's belly rising to a tip a quarter down), 'santoku' (a flat edge, the spine rounding down to
+ * it), 'drop' (spine and edge meeting on the centre line), 'cleaver' (a tall square blade).
+ *
+ * @param {'chef' | 'santoku' | 'drop' | 'cleaver'} kind The blade.
+ * @param {number} L Its length.
+ * @param {number} H Its depth at the heel.
+ * @returns {import('../geometry/types.js').Point[]} The outline.
+ * @throws {Error} For a kind it doesn't know.
+ */
+export const bladePts = (kind, L, H) => {
+	const t = -H / 2, b = H / 2;
+	if (kind === 'chef') return run([[0, b], [0, t], [L * 0.55, t]], bez([L * 0.55, t], [L * 0.86, t], [L, t + H * 0.28]), bez([L, t + H * 0.28], [L * 0.8, b], [L * 0.42, b]));
+	if (kind === 'santoku') return run([[0, b], [0, t], [L * 0.6, t]], bez([L * 0.6, t], [L, t], [L, b]));
+	if (kind === 'drop') return run([[0, b], [0, t], [L * 0.6, t]], bez([L * 0.6, t], [L * 0.9, t + H * 0.1], [L, H * 0.06]), bez([L, H * 0.06], [L * 0.82, b], [L * 0.5, b]));
+	if (kind === 'cleaver') return [[0, b], [0, t], [L, t], [L, b - 18], [L - 18, b]];
+	throw new Error('blade ' + kind);
+};
+
+/**
+ * A knife's grip: a handle from x = x1 back to x = x1 − L, h deep, its top on y = top, the butt rounded.
+ *
+ * @param {number} x1 Its front end.
+ * @param {number} L Its length.
+ * @param {number} top Its top.
+ * @param {number} h Its depth.
+ * @param {number} [r=h/2] The butt's radius.
+ * @returns {import('../geometry/types.js').Polygon} The grip.
+ */
+export const grip = (x1, L, top, h, r = h / 2) => rr(x1 - L, top, L, h, [r, 8, 8, r]);
+
+/**
+ * A knife pointing right: the `kind` blade (L long, H deep) and its handle (HL long, HH deep, sitting `hy` below the
+ * spine), parted by the gap.
+ *
+ * @param {number} g The gap.
+ * @param {{ kind?: 'chef' | 'santoku' | 'drop' | 'cleaver', L?: number, H?: number, HL?: number, HH?: number, hy?: number }} [o] The blade and handle.
+ * @returns {{ blade: import('../geometry/types.js').Polygon, handle: import('../geometry/types.js').Polygon }} The pieces.
+ */
+export const knife = (g, { kind = 'chef', L = 280, H = 100, HL = 170, HH = 56, hy = 6 } = {}) => ({
+	blade: poly(bladePts(kind, L, H)), handle: grip(-g, HL, -H / 2 + hy, HH) });
+
+/**
+ * A straight sword pointing up: a blade W wide (L long, its last `tip` a point), a crossguard bar, a grip and a round
+ * pommel, each parted from the next by the gap, the guard's top on y = 0.
+ *
+ * @param {number} g The gap.
+ * @param {{ L?: number, W?: number, tip?: number, guard?: number[], hilt?: number[], pommel?: number, taper?: number }} [o] The sizes: guard and hilt are [width, height].
+ * @returns {{ blade: import('../geometry/types.js').Polygon, guard: import('../geometry/types.js').Polygon, hilt: import('../geometry/types.js').Polygon, pommel: import('../geometry/types.js').Polygon }} The pieces.
+ */
+export const sword = (g, { L = 300, W = 56, tip = 70, guard = [176, 30], hilt = [36, 92], pommel = 26, taper = 0.78 } = {}) => {
+	const w2 = W / 2, w1 = (W * taper) / 2, blade = poly([[-w2, -g], [-w1, -g - L + tip], [0, -g - L], [w1, -g - L + tip], [w2, -g]]);
+	const gd = rr(-guard[0] / 2, 0, guard[0], guard[1], guard[1] / 2), y1 = guard[1] + g;
+	const h = rect(-hilt[0] / 2, y1, hilt[0], hilt[1]), p = circle(0, y1 + hilt[1] + g + pommel, pommel, 120);
+	return { blade, guard: gd, hilt: h, pommel: p };
+};
+
+/**
+ * Two copies of a shape drawn pointing up, crossed in an X at ±deg about the origin, the right-leaning one in front, cut
+ * free by the gap.
+ *
+ * @param {import('../geometry/types.js').Geom} s The shape.
+ * @param {number} deg The lean, in degrees.
+ * @param {number} g The gap.
+ * @returns {import('../geometry/types.js').Shape} The pair.
+ */
+export const crossed = (s, deg, g) => over(turn(flip(s), -deg), turn(s, deg), g);
+
+/**
+ * A katana pointing right along a gentle curve (the tip rising): the grip (tsuka), the guard (tsuba, a plate seen edge on)
+ * and either the drawn blade with its angled point or the scabbard (saya), each parted by the gap. `bend` is how far the
+ * ends rise over the middle.
+ *
+ * @param {number} g The gap.
+ * @param {{ sheathed?: boolean, L?: number, W?: number, tsukaL?: number, tsuba?: number[], bend?: number }} [o] The sword.
+ * @returns {{ tsuka: import('../geometry/types.js').Shape, tsuba: import('../geometry/types.js').Shape, blade: import('../geometry/types.js').Shape }} The pieces.
+ */
+export const katana = (g, { sheathed = false, L = 448, W = 46, tsukaL = 128, tsuba = [30, 104], bend = 40 } = {}) => {
+	const x0 = -L / 2, xt = x0 + tsukaL, xb = xt + g + tsuba[0] + g, w2 = W / 2;
+	const tsuka = rr(x0, -w2 + 2, tsukaL, W - 4, [20, 4, 4, 20]), guard = rr(xt + g, -tsuba[1] / 2, tsuba[0], tsuba[1], 12);
+	const len = L / 2 - xb, sw = sheathed ? W + 6 : W;
+	const blade = sheathed ? rr(xb, -sw / 2, len, sw, [4, sw / 2, sw / 2, 4])
+		: poly([[xb, -w2], [L / 2, -w2], ...bez([L / 2, -w2], [L / 2 - 14, w2 - 6], [L / 2 - 64, w2]).slice(1), [xb, w2]]);
+	const curve = (s) => mapPts(s, ([x, y]) => [x, y - bend * ((2 * x) / L) ** 2]);
+	return { tsuka: curve(tsuka), tsuba: curve(guard), blade: curve(blade) };
+};
+
+/**
+ * A felling axe pointing up: a haft W wide from y = bottom up into the head, and the head (poll on the left, the bit
+ * flaring to a convex edge on the right), the haft parted from the head by the gap.
+ *
+ * @param {number} g The gap.
+ * @param {{ W?: number, poll?: number, bit?: number, top?: number, bottom?: number, edge?: number }} [o] The sizes.
+ * @returns {{ head: import('../geometry/types.js').Polygon, haft: import('../geometry/types.js').Polygon }} The pieces.
+ */
+export const axe = (g, { W = 46, poll = 64, bit = 196, top = -224, bottom = 224, edge = 1 } = {}) => {
+	const hy = top + 44, head = poly(run([[-poll, hy - 40], [W / 2 + 26, hy - 34]], bez([W / 2 + 26, hy - 34], [bit * 0.62, hy - 30], [bit, top]),
+		bez([bit, top], [bit + 36 * edge, hy + 70], [bit - 8, hy + 168]), bez([bit - 8, hy + 168], [bit * 0.6, hy + 84], [W / 2 + 26, hy + 56]), [[-poll, hy + 50]]));
+	const haft = rr(-W / 2, hy - 20, W, bottom - hy + 20, [0, 0, W / 2, W / 2]);
+	return { head, haft };
+};
+
+/**
+ * The axe as one mark: the head in front of the haft, cut free by the gap.
+ *
+ * @param {number} g The gap.
+ * @param {{ W?: number, poll?: number, bit?: number, top?: number, bottom?: number, edge?: number }} [o] axe()'s sizes.
+ * @returns {import('../geometry/types.js').Shape} The axe.
+ */
+export const axeCut = (g, o) => { const { head, haft } = axe(g, o); return over(haft, head, g); };
+
+/**
+ * An arrow pointing right from x = x0 to x = x1: a shaft w wide, a head `hl` long and `hw` wide parted from the shaft by
+ * the gap, and the fletching, two swept vanes on the tail.
+ *
+ * @param {number} g The gap.
+ * @param {number} x0 The tail.
+ * @param {number} x1 The tip.
+ * @param {{ w?: number, hl?: number, hw?: number, vl?: number, vw?: number }} [o] The shaft's width, the head's length and width, the vanes' length and reach.
+ * @returns {{ shaft: import('../geometry/types.js').Polygon, head: import('../geometry/types.js').Polygon, vanes: import('../geometry/types.js').Shape }} The pieces.
+ */
+export const arrow = (g, x0, x1, { w = 22, hl = 74, hw = 70, vl = 92, vw = 34 } = {}) => {
+	const head = poly([[x1, 0], [x1 - hl, -hw / 2], [x1 - hl * 0.8, 0], [x1 - hl, hw / 2]]);
+	const shaft = rect(x0, -w / 2, x1 - hl * 0.8 - g - x0, w);
+	const vane = (s) => poly([[x0 + vl, s * w / 2 - 1], [x0 + vl - 34, s * (w / 2 + vw)], [x0, s * (w / 2 + vw)], [x0 + 34, s * w / 2 - 1]]);
+	return { shaft, head, vanes: U(vane(-1), vane(1)) };
+};
+
+/**
+ * Target rings about the origin: a bull of radius r0, then n rings `w` wide, each a gap out from the last.
+ *
+ * @param {number} g The gap.
+ * @param {{ r0?: number, w?: number, n?: number }} [o] The bull's radius, the rings' width and how many.
+ * @returns {import('../geometry/types.js').Shape} The target.
+ */
+export const rings = (g, { r0 = 60, w = 50, n = 2 } = {}) => {
+	const out = [circle(0, 0, r0, 240)]; let r = r0;
+	for (let i = 0; i < n; i++) { r += g; out.push(annulus(0, 0, r + w / 2, w)); r += w; }
+	return U(...out);
+};

package/src/pixels/dither.d.ts

@@ -0,0 +1,78 @@
+import type { Box, Geom, Shape } from '../geometry/types.js';
+
+/** Cells: [i, j], or tapered [i, j, f] / [i, j, f, deg] (f the size as a share of the pitch). */
+export type Cells = readonly (readonly number[])[];
+/** A ramp: a cell centre (grid units) to t (≤ 0 solid, 1 gone). */
+export type Ramp = (x: number, y: number) => number;
+/** A threshold mask: (i, j) to a value in (0, 1). */
+export type Mask = (i: number, j: number) => number;
+/** taper()'s settings. */
+export interface TaperOptions {
+	ramp: Ramp;
+	n?: number;
+	size?: boolean;
+	density?: number;
+	mask?: string | Mask;
+	gamma?: number;
+	min?: number;
+	turn?: number;
+}
+
+/** The smallest dither cell once fitted (16). */
+export const MIN_CELL: number;
+/** The smallest gap between dither cells once fitted (22). */
+export const MIN_GAP: number;
+/** The fitted span (448). */
+export const SPAN: number;
+/** The n × n Bayer matrix as thresholds in (0, 1). */
+export function bayer(n: number): number[][];
+/** Threshold masks: bayer4, bayer8 (ordered dither) and r2 (low-discrepancy). */
+export const MASKS: Record<'bayer4' | 'bayer8' | 'r2', Mask>;
+/** The cells a shape (in grid units) covers by at least `min` of a k × k sample. */
+export function raster(shape: Geom, o?: { min?: number; k?: number }): [number, number][];
+/** Cells from rows of text ('#' or 'X' a cell), top-left at (i0, j0). */
+export function fromRows(rows: readonly string[], i0?: number, j0?: number): [number, number][];
+/** A w × h block of cells, top-left at (i, j). */
+export function block(i: number, j: number, w: number, h: number): [number, number][];
+/** The cells of a not in b. */
+export function minus(a: Cells, b: Cells): number[][];
+/** A square frame n cells across, walls w thick, top-left at (i, j). */
+export function squareFrame(i: number, j: number, n: number, w: number): number[][];
+/** A comet: the head's cells and a trail behind them, with the ramp that fades it. */
+export function comet(head: Cells, deg: number, len: number, o?: { narrow?: number; lanes?: boolean; edge?: number | null }): { cells: number[][]; ramp: Ramp };
+/** The cells within `depth` steps of a shape's cells, the shape included. */
+export function dilate(cells: Cells, depth?: number): number[][];
+/** A shape's cells less every cell within `depth` steps of its outside. */
+export function erode(cells: Cells, depth?: number): number[][];
+/** A linear ramp: 0 at distance a along deg from (cx, cy), 1 at distance b. */
+export function linear(deg: number, a: number, b: number, cx?: number, cy?: number): Ramp;
+/** A ramp solid (−1) on the `solid` cells and `ramp` elsewhere. */
+export function solidOn(solid: Cells, ramp: Ramp): Ramp;
+/** A ramp by Chebyshev steps from a core: 0 on it, 1 at `depth` steps out. */
+export function steps(core: Cells, depth: number): Ramp;
+/** The dither zone's cell sizes (shares of the pitch p), largest first, in n steps. */
+export function levels(p: number, n: number, min?: number): number[];
+/** The pitch a set of cells gets once its longest side is fitted to 448. */
+export function pitchOf(cells: Cells): number;
+/** Cells tapered by a ramp: [i, j, f] (or [i, j, f, deg]) per kept cell. */
+export function taper(cells: Cells, o: TaperOptions): number[][];
+/** Cells drawn by hand as rows ('#' full, '1'–'9' a dither size, or a legend's [size, deg]). */
+export function mapCells(rows: readonly string[], o?: { n?: number; min?: number; legend?: Record<string, number[]>; i0?: number; j0?: number }): number[][];
+/** Full cells touching only at a corner: each 2 × 2 checker's top-left. */
+export function corners(cells: Cells): number[][];
+/** Tapered cells drawn on the 512 canvas, fitted to 448, every gap checked. */
+export function sprite(cells: Cells, o?: { round?: boolean; r?: number; push?: number[]; allowCorners?: boolean }): Shape;
+/** The upright box of a square of side s turned by deg. */
+export function turnBox(s: number, deg?: number): number;
+/** The side of a square turned by deg whose upright box is b across. */
+export function turnedSide(b: number, deg?: number): number;
+/** Squares [x, y, s, deg] as one shape. */
+export function squares(list: Cells): Shape;
+/** The bounding box of a square list. */
+export function extent(list: Cells): Box;
+/** A square list moved so its box is centred on the canvas. */
+export function centred(list: Cells): number[][];
+/** A resolution run: columns of 1, 2, 3 … squares, H solved so the run is `span` wide. */
+export function resRun(counts: readonly number[], o?: { span?: number; gap?: number }): { list: number[][]; H: number; side: number };
+/** A single file of squares [side, deg] along x, MIN_GAP apart, on one line. */
+export function file(items: Cells, o?: { gap?: number; align?: 'top' | 'bottom' | 'centre'; span?: number }): number[][];