@logomarks/core 0.1.9 → 0.2.0

package/src/geometry/index.d.ts

@@ -16,6 +16,7 @@ export { signedArea, area, perimeter, ringBox, bbox, winding, dedupe, openRing,
 export { seeded } from './random.js';
 export { circle, ellipse, rect, regular, annulus, sector, arcBand, rotN, bar, ring, roundPoly, rr, lens, drop, squircle, pill, egg } from './shapes.js';
 export { stroke, weave, offsetPts, fillet, tracks, filletClosed, trackLoop, walk, balloon, linePts, arcPts, joinPts } from './stroke.js';
+export { mitreOffset, mitreBand, offsetPolygon } from './mitre.js';
 export { toPath, svg, write } from './path.js';
 export { grow, soften, grown, over, slices } from './offset.js';
 export { iso, cubes, isoPrism, isoBlock, isoRing, isoPile } from './iso.js';

package/src/geometry/index.js

@@ -9,6 +9,7 @@ export { signedArea, area, perimeter, ringBox, bbox, winding, dedupe, openRing,
 export { seeded } from './random.js';
 export { circle, ellipse, rect, regular, annulus, sector, arcBand, rotN, bar, ring, roundPoly, rr, lens, drop, squircle, pill, egg } from './shapes.js';
 export { stroke, weave, offsetPts, fillet, tracks, filletClosed, trackLoop, walk, balloon, linePts, arcPts, joinPts } from './stroke.js';
+export { mitreOffset, mitreBand, offsetPolygon } from './mitre.js';
 export { toPath, svg, write } from './path.js';
 export { grow, soften, grown, over, slices } from './offset.js';
 export { iso, cubes, isoPrism, isoBlock, isoRing, isoPile } from './iso.js';

package/src/geometry/mitre.d.ts

@@ -0,0 +1,8 @@
+import type { Point, Shape } from './types.js';
+
+/** An open polyline offset d to its left (y down), corners mitred so it runs exactly parallel; d < 0 goes right. */
+export function mitreOffset(pts: readonly (readonly number[])[], d: number): Point[];
+/** A solid band w wide along an open polyline, corners mitred, ends square. */
+export function mitreBand(pts: readonly (readonly number[])[], w: number): Shape;
+/** A closed polygon grown (d > 0) or shrunk (d < 0), corners mitred; either winding. */
+export function offsetPolygon(pts: readonly (readonly number[])[], d: number): Point[];

package/src/geometry/mitre.js

@@ -0,0 +1,64 @@
+/**
+ * Exact offsets with mitred corners: a polyline's parallel, a band along it, and a polygon grown or shrunk.
+ */
+import { poly } from './core.js';
+
+/**
+ * The unit left normal (y down) of the step a → b.
+ *
+ * @param {readonly number[]} a From.
+ * @param {readonly number[]} b To.
+ * @returns {number[]} The normal.
+ */
+const leftNormal = (a, b) => {
+	const v = [b[0] - a[0], b[1] - a[1]], l = Math.hypot(...v) || 1;
+	return [v[1] / l, -(v[0] / l)];
+};
+
+/**
+ * An open polyline offset to its left (y down) by d, every corner mitred, so the offset runs exactly parallel to it
+ * (d < 0 offsets to the right). The ends move square to their segments.
+ *
+ * @param {readonly (readonly number[])[]} pts The polyline.
+ * @param {number} d How far.
+ * @returns {number[][]} The offset polyline, a point for each point.
+ */
+export const mitreOffset = (pts, d) => pts.map((p, i) => {
+	const n1 = i > 0 ? leftNormal(pts[i - 1], p) : null, n2 = i < pts.length - 1 ? leftNormal(p, pts[i + 1]) : null;
+	if (!n1) return [p[0] + /** @type {number[]} */ (n2)[0] * d, p[1] + /** @type {number[]} */ (n2)[1] * d];
+	if (!n2) return [p[0] + n1[0] * d, p[1] + n1[1] * d];
+	const s = [n1[0] + n2[0], n1[1] + n2[1]], l = Math.hypot(...s) || 1, m = [s[0] / l, s[1] / l], k = d / (m[0] * n1[0] + m[1] * n1[1]);
+	return [p[0] + m[0] * k, p[1] + m[1] * k];
+});
+
+/**
+ * A solid band w wide along an open polyline, every corner mitred sharp and both ends cut square.
+ *
+ * @param {readonly (readonly number[])[]} pts The polyline (its centre line).
+ * @param {number} w The width.
+ * @returns {import('./types.js').Shape} The band.
+ */
+export const mitreBand = (pts, w) => poly([...mitreOffset(pts, w / 2), ...mitreOffset(pts, -w / 2).reverse()]);
+
+/**
+ * A closed polygon grown (d > 0) or shrunk (d < 0) by d, every corner mitred: each edge moves out along its normal and
+ * neighbouring edges meet where their lines cross. Either winding. Shrinking past a corner's reach turns it inside out,
+ * so keep |d| under the shortest edge's reach.
+ *
+ * @param {readonly (readonly number[])[]} pts The polygon's corners, in order (open: no repeated first point).
+ * @param {number} d How far.
+ * @returns {number[][]} The offset polygon, a corner for each corner.
+ */
+export const offsetPolygon = (pts, d) => {
+	const n = pts.length;
+	let a = 0;
+	for (let i = 0; i < n; i++) { const p = pts[i], q = pts[(i + 1) % n]; a += p[0] * q[1] - q[0] * p[1]; }
+	const sg = a > 0 ? 1 : -1, L = 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), nx = sg * dy / l, ny = -sg * dx / l;
+		return [p[0] + nx * d, p[1] + ny * d, dx, dy];
+	});
+	return L.map((b, i) => {
+		const a2 = L[(i + n - 1) % n], den = a2[2] * b[3] - a2[3] * b[2], t = ((b[0] - a2[0]) * b[3] - (b[1] - a2[1]) * b[2]) / den;
+		return [a2[0] + a2[2] * t, a2[1] + a2[3] * t];
+	});
+};

package/src/geometry/modular.d.ts

@@ -9,6 +9,6 @@ export function isoPieces(pieces: [Point3, Point3][], u?: number, g?: number, ox
 /** Blocks [x, y, w, h] on a W × H grid, scaled to 448 and parted by g. */
 export function blocks(list: [number, number, number, number][], W: number, H: number, g?: number): Shape;
 /** A nested subdivision for blocks(): n − 1 blocks peeled off the sides named in turn (l t r b), each `cut` of what's left. */
-export function nest(W: number, H: number, n: number, sides: string, cut: number | ((i: number) => number)): [number, number, number, number][];
+export function nest(W: number, H: number, n: number, sides: string, cut: (w: number, h: number, side: string) => number): [number, number, number, number][];
 /** Capsules w wide pinned together, back to front, each cut free by g; pin holes at `pins`. */
 export function linkage(bars: [Point, Point][], pins?: Point[], o?: { w?: number; g?: number; pin?: number }): Shape;

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 };