@logomarks/core 0.1.7 → 0.1.8

package/CHANGELOG.md

@@ -5,6 +5,23 @@ All notable changes to `@logomarks/core` are documented here.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.1.8] — 2026-11-07
+
+### Fixed
+
+- `shapeTags()` measures each tag from the mark's geometry instead of a few corner and midpoint samples, so the tags agree with what the marks look like. Re-tagging the 4,040 Logomarks marks: `round` 248 → 267 (its old test passed iso cubes and hexagons and missed many discs with a cut), `square` 144 → 283, `symmetric` 1,202 → 968, `radial` 460 → 235, `solid` 984 → 3,395 and `light` 446 → 645 (every mark now gets exactly one of the two). The rules, the measures and their known limits are in [docs/tags.md](docs/tags.md).
+  - **round:** about square, the ink reaching its convex hull all round, and the hull running on a circle (found by a robust circle fit) with a compact hull.
+  - **square:** about square, not round, and its silhouette (gaps up to 60 closed, holes filled) filling its box to every corner.
+  - **symmetric:** the left-right mirror only, by coverage and by outline (so a small asymmetric glyph inside a badge breaks it). A top-bottom mirror alone no longer counts.
+  - **radial:** rotational symmetry of order 3, 4 or 5 about the centre of mass. A half turn alone (an S, a bar) no longer counts.
+  - **solid / light:** light when the pieces are strokes with little mass (under 30% of the ink in parts thicker than 48 units or 12% of the short side); solid otherwise. Density no longer decides it.
+  - The raster's default `size` is now 256 (was 128); the thresholds are tuned there.
+
+### Added
+
+- `shapeMeasures(coverage, { w, h, size }, settings?)` and `MEASURE` in `/analyse`: the numbers the tags are decided on (reach, arc, rim, circularity, closed fill and corners, mirror and turn matches, thickness, elongation).
+- `tagsOf(measures, thresholds?)` and `SHAPE`: the tags from the measures, with the thresholds open to change.
+
 ## [0.1.7] — 2026-11-07
 
 ### Fixed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logomarks/core",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "Geometry, SVG reading, fitting, analysis and similarity for logomarks on a 512 grid: the kit the Logomarks set is drawn with (shapes, real booleans, strokes, tracks, iso solids, badges, letter skeletons), one SVG path parser, the 448 fit, speck and shape-tag analysis, outline signatures, and the industry-symbol parts.",
   "type": "module",
   "main": "src/index.js",

package/src/analyse/index.d.ts

@@ -1,6 +1,8 @@
 export type { Part, PartsRead, SmallOptions, SkipReason } from './specks.js';
 export type { ShapeTag } from './tags.js';
+export type { ShapeMeasures, SelfMatch } from './shape/measures.js';
 export type { RunGroup, WidthSettings } from './widths.js';
 export { SPECKS, vectorParts, rasterParts, markParts, smallParts } from './specks.js';
-export { shapeTags } from './tags.js';
+export { SHAPE, shapeTags, tagsOf } from './tags.js';
+export { MEASURE, shapeMeasures } from './shape/measures.js';
 export { WIDTHS, groupRuns, widths } from './widths.js';

package/src/analyse/index.js

@@ -1,6 +1,8 @@
 /**
- * Analysis of a mark: its pieces and holes (specks, slivers, pin-holes), its stroke and gap widths, and its shape tags.
+ * Analysis of a mark: its pieces and holes (specks, slivers, pin-holes), its stroke and gap widths, and its shape tags
+ * (with the measures they are decided on).
  */
 export { SPECKS, vectorParts, rasterParts, markParts, smallParts } from './specks.js';
-export { shapeTags } from './tags.js';
+export { SHAPE, shapeTags, tagsOf } from './tags.js';
+export { MEASURE, shapeMeasures } from './shape/measures.js';
 export { WIDTHS, groupRuns, widths } from './widths.js';

package/src/analyse/shape/circle.d.ts

@@ -0,0 +1,15 @@
+import type { Pt } from './hull.js';
+
+/** A circle: its centre and radius. */
+export interface Circle {
+	cx: number;
+	cy: number;
+	r: number;
+}
+
+/** The least-squares circle through some points (NaN radius when they are in a line). */
+export function fitCircle(pts: readonly Pt[]): Circle;
+/** The share of points within `tol` × r of a circle's line. */
+export function onCircle(pts: readonly Pt[], c: Circle, tol: number): number;
+/** The circle most of some points lie on, found the same way every time, then refit on the points near it. */
+export function findCircle(pts: readonly Pt[], o?: { tol?: number; refit?: number; tries?: number; largest?: number }): Circle;

package/src/analyse/shape/circle.js

@@ -0,0 +1,77 @@
+/**
+ * @module @logomarks/core/analyse/shape/circle
+ *
+ * The circle that best runs along some points: a least-squares fit, a deterministic search over point triples for the
+ * circle most points lie on (so a cut-off cap or a tail doesn't pull it), then a refit on the points near it.
+ */
+
+/** @typedef {import('./hull.js').Pt} Pt */
+/** @typedef {import('./circle.js').Circle} Circle */
+
+/**
+ * The least-squares circle through some points (Kåsa's algebraic fit).
+ *
+ * @param {readonly Pt[]} pts At least three points.
+ * @returns {Circle} Its centre and radius (NaN when the points are in a line).
+ */
+export function fitCircle(pts) {
+	let sx = 0, sy = 0, sxx = 0, syy = 0, sxy = 0, sxz = 0, syz = 0, sz = 0;
+	for (const [x, y] of pts) {
+		const z = x * x + y * y;
+		sx += x; sy += y; sxx += x * x; syy += y * y; sxy += x * y; sxz += x * z; syz += y * z; sz += z;
+	}
+	// solve [sxx sxy sx; sxy syy sy; sx sy n] · [A B C] = [sxz syz sz]; the circle is (A/2, B/2), r² = C + cx² + cy²
+	const m = [[sxx, sxy, sx, sxz], [sxy, syy, sy, syz], [sx, sy, pts.length, sz]];
+	for (let i = 0; i < 3; i++) {
+		let pivot = i;
+		for (let j = i + 1; j < 3; j++) if (Math.abs(m[j][i]) > Math.abs(m[pivot][i])) pivot = j;
+		[m[i], m[pivot]] = [m[pivot], m[i]];
+		for (let j = 0; j < 3; j++) {
+			if (j === i) continue;
+			const f = m[j][i] / m[i][i];
+			for (let k = i; k < 4; k++) m[j][k] -= f * m[i][k];
+		}
+	}
+	const cx = m[0][3] / m[0][0] / 2, cy = m[1][3] / m[1][1] / 2;
+	return { cx, cy, r: Math.sqrt(m[2][3] / m[2][2] + cx * cx + cy * cy) };
+}
+
+/**
+ * The share of points within `tol` × r of a circle's line.
+ *
+ * @param {readonly Pt[]} pts The points.
+ * @param {Circle} c The circle.
+ * @param {number} tol The tolerance, a fraction of the radius.
+ * @returns {number} 0–1.
+ */
+export function onCircle(pts, { cx, cy, r }, tol) {
+	let n = 0;
+	for (const [x, y] of pts) if (Math.abs(Math.hypot(x - cx, y - cy) - r) < tol * r) n++;
+	return pts.length ? n / pts.length : 0;
+}
+
+/**
+ * The circle most of some points lie on: the least-squares fit, or a better one through three of them (`tries`
+ * triples, picked the same way every time), refit three times on the points within `refit` × r of it.
+ *
+ * @param {readonly Pt[]} pts The points, e.g. along a hull's edge.
+ * @param {{ tol?: number, refit?: number, tries?: number, largest?: number }} [o] Inlier tolerance (0.025 of r),
+ *   refit tolerance (0.04), triples tried (300), and the largest radius worth trying.
+ * @returns {Circle} The circle.
+ */
+export function findCircle(pts, { tol = 0.025, refit = 0.04, tries = 300, largest = Infinity } = {}) {
+	let best = fitCircle(pts), most = onCircle(pts, best, tol);
+	const n = pts.length;
+	for (let k = 0; k < tries && n >= 3; k++) {
+		const c = fitCircle([pts[(k * 7919) % n], pts[(k * 104729 + Math.floor(n / 3)) % n], pts[(k * 1299709 + Math.floor(2 * n / 3)) % n]]);
+		if (!(c.r >= 10 && c.r <= largest)) continue;
+		const on = onCircle(pts, c, tol);
+		if (on > most) { most = on; best = c; }
+	}
+	for (let i = 0; i < 3; i++) {
+		const near = pts.filter(([x, y]) => Math.abs(Math.hypot(x - best.cx, y - best.cy) - best.r) < refit * best.r);
+		if (near.length < 20) break;
+		best = fitCircle(near);
+	}
+	return best;
+}

package/src/analyse/shape/hull.d.ts

@@ -0,0 +1,15 @@
+import type { Ink } from './ink.js';
+
+/** A point, `[x, y]`. */
+export type Pt = [number, number];
+
+/** The convex hull of some points (sorts them in place). */
+export function convexHull(pts: Pt[]): Pt[];
+/** The hull of a raster's ink, in pixels. */
+export function inkHull(ink: Pick<Ink, 'bin' | 'n' | 'box'>): Pt[];
+/** A polygon's area (unsigned), perimeter and centre of area. */
+export function polygonMeasures(poly: readonly Pt[]): { area: number; perimeter: number; centre: Pt };
+/** How far a ray from `c` at angle `t` (radians) runs before it leaves a convex polygon round `c`. */
+export function rayExit(poly: readonly Pt[], c: Pt, t: number): number;
+/** Points along a polygon's edges, `step` (1) apart. */
+export function edgePoints(poly: readonly Pt[], step?: number): Pt[];

package/src/analyse/shape/hull.js

@@ -0,0 +1,113 @@
+/**
+ * @module @logomarks/core/analyse/shape/hull
+ *
+ * The convex hull of a mark's ink, and what is measured on it: area, perimeter, centre, how far it reaches along a
+ * ray, and points along its edge.
+ */
+
+/** @typedef {[number, number]} Pt */
+
+/**
+ * The cross product of `oa` and `ob`.
+ *
+ * @param {Pt} o The origin.
+ * @param {Pt} a One point.
+ * @param {Pt} b The other.
+ * @returns {number} Positive for a left turn.
+ */
+const cross = (o, a, b) => (a[0] - o[0]) * (b[1] - o[1]) - (a[1] - o[1]) * (b[0] - o[0]);
+
+/**
+ * The convex hull of some points (Andrew's monotone chain), counter-clockwise on screen axes.
+ *
+ * @param {Pt[]} pts The points (sorted in place).
+ * @returns {Pt[]} The hull's corners.
+ */
+export function convexHull(pts) {
+	pts.sort((p, q) => p[0] - q[0] || p[1] - q[1]);
+	/** @type {Pt[]} */
+	const lo = [], up = [];
+	for (const p of pts) {
+		while (lo.length >= 2 && cross(lo[lo.length - 2], lo[lo.length - 1], p) <= 0) lo.pop();
+		lo.push(p);
+	}
+	for (let i = pts.length - 1; i >= 0; i--) {
+		const p = pts[i];
+		while (up.length >= 2 && cross(up[up.length - 2], up[up.length - 1], p) <= 0) up.pop();
+		up.push(p);
+	}
+	return lo.slice(0, -1).concat(up.slice(0, -1));
+}
+
+/**
+ * The hull of a raster's ink: the corners of each row's outermost ink pixels.
+ *
+ * @param {import('./ink.js').Ink} ink The ink.
+ * @returns {Pt[]} The hull's corners, in pixels.
+ */
+export function inkHull({ bin, n, box }) {
+	/** @type {Pt[]} */
+	const pts = [];
+	for (let y = box[1]; y < box[3]; y++) {
+		let l = -1, r = -1;
+		for (let x = box[0]; x < box[2]; x++) if (bin[y * n + x]) { if (l < 0) l = x; r = x; }
+		if (l >= 0) pts.push([l, y], [l, y + 1], [r + 1, y], [r + 1, y + 1]);
+	}
+	return convexHull(pts);
+}
+
+/**
+ * A polygon's area, perimeter and centre of area.
+ *
+ * @param {Pt[]} poly The corners.
+ * @returns {{ area: number, perimeter: number, centre: Pt }} Its measures (area unsigned).
+ */
+export function polygonMeasures(poly) {
+	let a = 0, p = 0, cx = 0, cy = 0;
+	for (let i = 0; i < poly.length; i++) {
+		const [x0, y0] = poly[i], [x1, y1] = poly[(i + 1) % poly.length], c = x0 * y1 - x1 * y0;
+		a += c; cx += (x0 + x1) * c; cy += (y0 + y1) * c;
+		p += Math.hypot(x1 - x0, y1 - y0);
+	}
+	a /= 2;
+	return { area: Math.abs(a), perimeter: p, centre: a ? [cx / (6 * a), cy / (6 * a)] : poly[0] ?? [0, 0] };
+}
+
+/**
+ * How far a ray from `c` at angle `t` runs before it leaves a convex polygon round `c`.
+ *
+ * @param {Pt[]} poly The polygon.
+ * @param {Pt} c The ray's start, inside.
+ * @param {number} t Its angle in radians.
+ * @returns {number} The distance to the polygon's edge.
+ */
+export function rayExit(poly, c, t) {
+	const dx = Math.cos(t), dy = Math.sin(t);
+	let far = 0;
+	for (let i = 0; i < poly.length; i++) {
+		const p = poly[i], q = poly[(i + 1) % poly.length], ex = q[0] - p[0], ey = q[1] - p[1];
+		const den = dx * ey - dy * ex;
+		if (Math.abs(den) < 1e-9) continue;
+		const px = p[0] - c[0], py = p[1] - c[1];
+		const s = (px * ey - py * ex) / den, u = (px * dy - py * dx) / den;
+		if (s > 0 && u >= 0 && u <= 1) far = Math.max(far, s);
+	}
+	return far;
+}
+
+/**
+ * Points along a polygon's edges, `step` apart.
+ *
+ * @param {Pt[]} poly The polygon.
+ * @param {number} [step] The spacing (1).
+ * @returns {Pt[]} The points.
+ */
+export function edgePoints(poly, step = 1) {
+	/** @type {Pt[]} */
+	const out = [];
+	for (let i = 0; i < poly.length; i++) {
+		const p = poly[i], q = poly[(i + 1) % poly.length], len = Math.hypot(q[0] - p[0], q[1] - p[1]);
+		for (let t = 0; t < len; t += step) out.push([p[0] + (q[0] - p[0]) * t / len, p[1] + (q[1] - p[1]) * t / len]);
+	}
+	return out;
+}

package/src/analyse/shape/ink.d.ts

@@ -0,0 +1,28 @@
+import type { Bitmap } from '../../raster/scanline.js';
+
+/** A mark's ink on a square coverage raster. */
+export interface Ink {
+	/** The coverage, 0–1, row by row. */
+	a: Float32Array;
+	/** The raster's side in pixels. */
+	n: number;
+	/** 1 where a pixel is over half covered. */
+	bin: Uint8Array;
+	/** How many ink pixels. */
+	count: number;
+	/** The ink's box in pixels, `[x0, y0, x1, y1]`, end-exclusive. */
+	box: [number, number, number, number];
+	/** The coverage's centre of mass, in pixels. */
+	centre: [number, number];
+}
+
+/** A square binary raster as the raster module reads one. */
+export function bitmap(data: Uint8Array, n: number): Bitmap;
+/** The ink of a coverage raster: pixels over half covered, their box and the coverage's centre. */
+export function inkOf(a: Float32Array, n: number): Ink;
+/** The outline: ink pixels on the border or beside an empty pixel. */
+export function outlineOf(ink: Pick<Ink, 'bin' | 'n'>): number[];
+/** A binary raster with its holes filled. */
+export function filled(bin: Uint8Array, n: number): Uint8Array;
+/** The ink closed by a disc of radius `r` pixels: narrower gaps join. */
+export function closed(bin: Uint8Array, n: number, r: number): Uint8Array;

package/src/analyse/shape/ink.js

@@ -0,0 +1,95 @@
+/**
+ * @module @logomarks/core/analyse/shape/ink
+ *
+ * A mark's ink on a square coverage raster: the binary ink, its box and centre, its outline pixels, and its
+ * silhouette with the holes filled (optionally closed first, so narrow gaps join the pieces).
+ */
+
+import { distance } from '../../raster/distance.js';
+
+/**
+ * A square binary raster as the raster module reads one.
+ *
+ * @param {Uint8Array} data 1 for ink, 0 for empty, row by row.
+ * @param {number} n Its side in pixels.
+ * @returns {import('../../raster/scanline.js').Bitmap} The bitmap.
+ */
+export const bitmap = (data, n) => ({ data, width: n, height: n, x0: 0, y0: 0, scale: 1 });
+
+/**
+ * The ink of a coverage raster: pixels over half covered.
+ *
+ * @param {Float32Array} a Coverage 0–1, `n` × `n`, row by row.
+ * @param {number} n The raster's side.
+ * @returns {import('./ink.js').Ink} The ink, its box and its centre.
+ */
+export function inkOf(a, n) {
+	const bin = new Uint8Array(n * n);
+	let count = 0, mass = 0, mx = 0, my = 0, x0 = n, y0 = n, x1 = -1, y1 = -1;
+	for (let y = 0; y < n; y++) for (let x = 0; x < n; x++) {
+		const v = a[y * n + x];
+		mass += v; mx += v * (x + 0.5); my += v * (y + 0.5);
+		if (v <= 0.5) continue;
+		bin[y * n + x] = 1;
+		count++;
+		if (x < x0) x0 = x;
+		if (x > x1) x1 = x;
+		if (y < y0) y0 = y;
+		if (y > y1) y1 = y;
+	}
+	return { a, n, bin, count, box: [x0, y0, x1 + 1, y1 + 1], centre: mass ? [mx / mass, my / mass] : [n / 2, n / 2] };
+}
+
+/**
+ * The outline: ink pixels on the raster's border or beside an empty pixel (4-connected).
+ *
+ * @param {import('./ink.js').Ink} ink The ink.
+ * @returns {number[]} The outline pixels' indices.
+ */
+export function outlineOf({ bin, n }) {
+	const out = [];
+	for (let y = 0; y < n; y++) for (let x = 0; x < n; x++) {
+		const k = y * n + x;
+		if (bin[k] && (x === 0 || y === 0 || x === n - 1 || y === n - 1 || !bin[k - 1] || !bin[k + 1] || !bin[k - n] || !bin[k + n])) out.push(k);
+	}
+	return out;
+}
+
+/**
+ * Pixels of a binary raster with their holes filled: everything the empty space round the border can't reach.
+ *
+ * @param {Uint8Array} bin 1 for ink.
+ * @param {number} n The raster's side.
+ * @returns {Uint8Array} 1 inside the silhouette.
+ */
+export function filled(bin, n) {
+	const out = new Uint8Array(n * n).fill(1), stack = [];
+	const seed = (/** @type {number} */ k) => { if (!bin[k] && out[k]) { out[k] = 0; stack.push(k); } };
+	for (let i = 0; i < n; i++) { seed(i); seed((n - 1) * n + i); seed(i * n); seed(i * n + n - 1); }
+	while (stack.length) {
+		const k = /** @type {number} */ (stack.pop()), x = k % n, y = (k - x) / n;
+		if (x > 0) seed(k - 1);
+		if (x < n - 1) seed(k + 1);
+		if (y > 0) seed(k - n);
+		if (y < n - 1) seed(k + n);
+	}
+	return out;
+}
+
+/**
+ * The ink closed by a disc (grown, then shrunk, by `r` pixels): gaps narrower than 2r join, outer corners stay.
+ *
+ * @param {Uint8Array} bin 1 for ink.
+ * @param {number} n The raster's side.
+ * @param {number} r The disc's radius in pixels.
+ * @returns {Uint8Array} 1 for the closed ink.
+ */
+export function closed(bin, n, r) {
+	const near = distance(bitmap(bin, n), 0);
+	const grown = new Uint8Array(n * n);
+	for (let k = 0; k < n * n; k++) grown[k] = near[k] <= r ? 1 : 0;
+	const depth = distance(bitmap(grown, n), 1);
+	const out = new Uint8Array(n * n);
+	for (let k = 0; k < n * n; k++) out[k] = depth[k] > r ? 1 : 0;
+	return out;
+}

package/src/analyse/shape/measures.d.ts

@@ -0,0 +1,52 @@
+/** How well a mark maps onto itself, two ways. */
+export interface SelfMatch {
+	/** Coverage overlap over union, 0–1 (a big solid mass dominates it). */
+	coverage: number;
+	/** Share of outline pixels that land on the outline, 0–1 (a small asymmetric detail still breaks it). */
+	outline: number;
+}
+
+/** The measures behind the shape tags. */
+export interface ShapeMeasures {
+	/** The fitted outline's width over its height. */
+	ratio: number;
+	/** Share of rays from the hull's centre on which the ink reaches the hull. */
+	reach: number;
+	/** Share of the hull's edge on its best circle. */
+	arc: number;
+	/** Share of rays from that circle's centre whose outermost ink lies on it. */
+	rim: number;
+	/** The hull's circularity, 4πA / P² (a disc 1, a hexagon about 0.95 on the raster, a square 0.79). */
+	circularity: number;
+	/** The closed silhouette's share of the ink's box. */
+	closedFill: number;
+	/** Its emptiest corner patch's filled share. */
+	closedCorners: number;
+	/** The mirror across the vertical middle. */
+	mirror: SelfMatch;
+	/** Each turn tried (orders 3, 4, 5). */
+	turns: (SelfMatch & { order: number })[];
+	/** Share of the ink in parts thicker than 48 units. */
+	thick: number;
+	/** Share of the ink in parts thicker than 12% of the short side. */
+	thickRelative: number;
+	/** How drawn-out the pieces are (a stroke ≈ length / width, a dot 1.8). */
+	elongation: number;
+}
+
+/** How the measures are taken (units of the 512 canvas, unless a fraction). */
+export const MEASURE: {
+	rays: { reach: number; rim: number };
+	reach: number;
+	arc: number;
+	rim: number;
+	closing: number;
+	corner: number;
+	tolerance: number;
+	orders: number[];
+	thick: number;
+	thickRelative: number;
+};
+
+/** The measures behind the shape tags, from a fitted mark's coverage at `size` px (256). */
+export function shapeMeasures(a: Float32Array, m: { w: number; h: number; size?: number }, o?: Partial<typeof MEASURE>): ShapeMeasures;

package/src/analyse/shape/measures.js

@@ -0,0 +1,131 @@
+/**
+ * @module @logomarks/core/analyse/shape/measures
+ *
+ * Everything the shape tags are decided on, measured from a fitted mark's coverage raster: how round its outline is,
+ * how square its closed silhouette, how it mirrors and turns onto itself, and how thick its ink is.
+ */
+
+import { distance } from '../../raster/distance.js';
+import { inkOf, outlineOf, filled, closed, bitmap } from './ink.js';
+import { inkHull, polygonMeasures, rayExit, edgePoints } from './hull.js';
+import { findCircle, onCircle } from './circle.js';
+import { coverageMatch, outlineMatcher, mirrorX, turn } from './symmetry.js';
+import { thickShare, elongation } from './thickness.js';
+
+/** How the measures are taken (units of the 512 canvas, unless a fraction): the Logomarks settings. */
+export const MEASURE = {
+	/** Rays cast for `reach` and `rim`. */
+	rays: { reach: 180, rim: 360 },
+	/** The ink reaches the hull on a ray when it gets within this fraction of the hull's edge (less a pixel). */
+	reach: 0.08,
+	/** A hull point is on the circle within this fraction of the radius. */
+	arc: 0.025,
+	/** A ray's outermost ink is on the rim within this fraction of the radius (plus half a pixel). */
+	rim: 0.07,
+	/** The closing that joins a modular mark's pieces before its silhouette is read (bridges gaps up to 60). */
+	closing: 30,
+	/** Each corner patch of the closed silhouette, a fraction of the box's short side. */
+	corner: 0.3,
+	/** How far a mirrored or turned outline pixel may land from the outline. */
+	tolerance: 4,
+	/** The turns tried for rotational symmetry. */
+	orders: [3, 4, 5],
+	/** Ink in parts thicker than this counts as mass… */
+	thick: 48,
+	/** …or thicker than this fraction of the box's short side. */
+	thickRelative: 0.12,
+};
+
+/**
+ * The share of rays from `c` on which the ink's outermost pixel passes `test`.
+ *
+ * @param {import('./ink.js').Ink} ink The ink.
+ * @param {[number, number]} c The rays' start.
+ * @param {number} count How many rays, evenly turned.
+ * @param {(k: number) => number} limit How far to look along ray `k`.
+ * @param {(far: number, k: number) => boolean} test Whether ray `k`'s outermost ink, `far` from `c`, counts.
+ * @returns {number} 0–1.
+ */
+function rayShare({ bin, n }, [cx, cy], count, limit, test) {
+	let hits = 0;
+	for (let k = 0; k < count; k++) {
+		const t = k * 2 * Math.PI / count, dx = Math.cos(t), dy = Math.sin(t), end = limit(k);
+		let far = 0;
+		for (let s = 0; s < end; s += 0.5) {
+			const X = Math.floor(cx + dx * s), Y = Math.floor(cy + dy * s);
+			if (X >= 0 && Y >= 0 && X < n && Y < n && bin[Y * n + X]) far = s;
+		}
+		if (test(far, k)) hits++;
+	}
+	return hits / count;
+}
+
+/**
+ * The share of a box filled by a mask, and its emptiest corner patch's filled share.
+ *
+ * @param {Uint8Array} mask 1 inside.
+ * @param {number} n The raster's side.
+ * @param {[number, number, number, number]} box The box, end-exclusive.
+ * @param {number} corner The corner patch's side, a fraction of the box's short side.
+ * @returns {{ fill: number, corners: number }} Both 0–1.
+ */
+function boxFill(mask, n, [x0, y0, x1, y1], corner) {
+	const count = (/** @type {number} */ ax, /** @type {number} */ ay, /** @type {number} */ bx, /** @type {number} */ by) => {
+		let c = 0;
+		for (let y = ay; y < by; y++) for (let x = ax; x < bx; x++) c += mask[y * n + x];
+		return c;
+	};
+	const w = x1 - x0, h = y1 - y0, c = Math.max(2, Math.round(Math.min(w, h) * corner));
+	const patch = (/** @type {number} */ x, /** @type {number} */ y) => count(x, y, x + c, y + c) / (c * c);
+	return { fill: count(x0, y0, x1, y1) / (w * h), corners: Math.min(patch(x0, y0), patch(x1 - c, y0), patch(x0, y1 - c), patch(x1 - c, y1 - c)) };
+}
+
+/**
+ * The measures behind the shape tags, from a fitted mark's coverage.
+ *
+ * @param {Float32Array} a Coverage 0–1, `size` × `size`, row by row (the 512 canvas, mark centred).
+ * @param {{ w: number, h: number, size?: number }} m The fitted outline's width and height, and the raster's side
+ *   (256: the thresholds are tuned there).
+ * @param {Partial<typeof MEASURE>} [o] The settings (MEASURE by default).
+ * @returns {import('./measures.js').ShapeMeasures} The measures.
+ */
+export function shapeMeasures(a, { w, h, size: n = 256 }, o = {}) {
+	const s = { ...MEASURE, ...o }, unit = n / 512;
+	const ink = inkOf(a, n);
+	const ratio = w / h;
+	if (!ink.count) return { ratio, reach: 0, arc: 0, rim: 0, circularity: 0, closedFill: 0, closedCorners: 0, mirror: { coverage: 0, outline: 0 }, turns: [], thick: 0, thickRelative: 0, elongation: 0 };
+
+	// the outline's hull: how round it is, and whether the ink fills out to it
+	const hull = inkHull(ink), { area, perimeter, centre } = polygonMeasures(hull);
+	const edge = edgePoints(hull);
+	const circle = findCircle(edge, { tol: s.arc, largest: n });
+	const reachTo = Array.from({ length: s.rays.reach }, (_, k) => rayExit(hull, centre, k * 2 * Math.PI / s.rays.reach));
+	const reach = rayShare(ink, centre, s.rays.reach, (k) => reachTo[k] + 2, (far, k) => far >= reachTo[k] * (1 - s.reach) - 1);
+	const rim = rayShare(ink, [circle.cx, circle.cy], s.rays.rim, () => circle.r * 1.3, (far) => Math.abs(far - circle.r) <= s.rim * circle.r + 0.5);
+
+	// the closed silhouette in its box: a square, or a modular tile, fills it to the corners
+	const { fill: closedFill, corners: closedCorners } = boxFill(filled(closed(ink.bin, n, s.closing * unit), n), n, ink.box, s.corner);
+
+	// symmetry: the mirror across the box's middle, and turns about the centre of mass
+	const match = outlineMatcher(ink, outlineOf(ink)), tol = s.tolerance * unit;
+	const axis = mirrorX((ink.box[0] + ink.box[2]) / 2);
+	const mirror = { coverage: coverageMatch(ink, axis), outline: match(axis, tol) };
+	const turns = s.orders.map((order) => { const f = turn(order, ink.centre); return { order, coverage: coverageMatch(ink, f), outline: match(f, tol) }; });
+
+	// weight: mass versus strokes
+	const depth = distance(bitmap(ink.bin, n), 1);
+	return {
+		ratio,
+		reach,
+		arc: onCircle(edge, circle, s.arc),
+		rim,
+		circularity: perimeter ? 4 * Math.PI * area / perimeter ** 2 : 0,
+		closedFill,
+		closedCorners,
+		mirror,
+		turns,
+		thick: thickShare(ink, depth, s.thick / 2 * unit),
+		thickRelative: thickShare(ink, depth, s.thickRelative / 2 * Math.min(w, h) * unit),
+		elongation: elongation(ink, depth),
+	};
+}

package/src/analyse/shape/symmetry.d.ts

@@ -0,0 +1,13 @@
+import type { Ink } from './ink.js';
+
+/** Where a pixel centre's value comes from, in pixel coordinates. */
+export type PixelMap = (x: number, y: number) => [number, number];
+
+/** The coverage's overlap with itself mapped by `f` (intersection over union), 0–1. */
+export function coverageMatch(ink: Pick<Ink, 'a' | 'n'>, f: PixelMap): number;
+/** A matcher for the outline: the share of outline pixels a map lands within `tol` pixels of the outline. */
+export function outlineMatcher(ink: Pick<Ink, 'n'>, outline: readonly number[]): (f: PixelMap, tol: number) => number;
+/** The mirror across the vertical line x = `cx`. */
+export function mirrorX(cx: number): PixelMap;
+/** A turn by a whole circle over `order` about `c`. */
+export function turn(order: number, c: [number, number]): PixelMap;

package/src/analyse/shape/symmetry.js

@@ -0,0 +1,84 @@
+/**
+ * @module @logomarks/core/analyse/shape/symmetry
+ *
+ * How well a mark maps onto itself under a mirror or a turn, measured two ways: its coverage (overlap over union,
+ * which a big solid mass dominates) and its outline (the share of outline pixels that land on the outline, which a
+ * small asymmetric detail inside a badge still breaks).
+ */
+
+import { distance } from '../../raster/distance.js';
+import { bitmap } from './ink.js';
+
+/** @typedef {(x: number, y: number) => [number, number]} PixelMap */
+
+/**
+ * Coverage at a point between pixel centres (bilinear; 0 outside).
+ *
+ * @param {Float32Array} a Coverage, `n` × `n`.
+ * @param {number} n The side.
+ * @param {number} x Pixel coordinates (centres at whole numbers).
+ * @param {number} y
+ * @returns {number} The coverage there.
+ */
+function sample(a, n, x, y) {
+	const x0 = Math.floor(x), y0 = Math.floor(y), fx = x - x0, fy = y - y0;
+	const at = (/** @type {number} */ i, /** @type {number} */ j) => (i < 0 || j < 0 || i >= n || j >= n ? 0 : a[j * n + i]);
+	return at(x0, y0) * (1 - fx) * (1 - fy) + at(x0 + 1, y0) * fx * (1 - fy) + at(x0, y0 + 1) * (1 - fx) * fy + at(x0 + 1, y0 + 1) * fx * fy;
+}
+
+/**
+ * The coverage's overlap with itself mapped by `f` (intersection over union).
+ *
+ * @param {import('./ink.js').Ink} ink The ink.
+ * @param {PixelMap} f Where each pixel centre (x + 0.5, y + 0.5) comes from.
+ * @returns {number} 0–1.
+ */
+export function coverageMatch({ a, n }, f) {
+	let i = 0, u = 0;
+	for (let y = 0; y < n; y++) for (let x = 0; x < n; x++) {
+		const [sx, sy] = f(x + 0.5, y + 0.5), p = a[y * n + x], q = sample(a, n, sx - 0.5, sy - 0.5);
+		i += Math.min(p, q); u += Math.max(p, q);
+	}
+	return u ? i / u : 0;
+}
+
+/**
+ * A matcher for the outline: maps each outline pixel and counts those landing within `tol` pixels of the outline.
+ *
+ * @param {import('./ink.js').Ink} ink The ink.
+ * @param {number[]} outline Its outline pixels (`outlineOf`).
+ * @returns {(f: PixelMap, tol: number) => number} The share matched, 0–1, for a map and a tolerance in pixels.
+ */
+export function outlineMatcher({ n }, outline) {
+	const edge = new Uint8Array(n * n);
+	for (const k of outline) edge[k] = 1;
+	const near = distance(bitmap(edge, n), 0);
+	return (f, tol) => {
+		let ok = 0;
+		for (const k of outline) {
+			const x = k % n, [X, Y] = f(x + 0.5, (k - x) / n + 0.5), i = Math.floor(X), j = Math.floor(Y);
+			if (i >= 0 && j >= 0 && i < n && j < n && near[j * n + i] <= tol) ok++;
+		}
+		return outline.length ? ok / outline.length : 0;
+	};
+}
+
+/**
+ * The mirror across the vertical line x = `cx`.
+ *
+ * @param {number} cx The axis, in pixels.
+ * @returns {PixelMap} The map.
+ */
+export const mirrorX = (cx) => (x, y) => [2 * cx - x, y];
+
+/**
+ * A turn by a whole circle over `order` about `c`.
+ *
+ * @param {number} order How many turns make the circle.
+ * @param {[number, number]} c The centre, in pixels.
+ * @returns {PixelMap} The map.
+ */
+export function turn(order, [cx, cy]) {
+	const t = 2 * Math.PI / order, co = Math.cos(t), si = Math.sin(t);
+	return (x, y) => [cx + (x - cx) * co - (y - cy) * si, cy + (x - cx) * si + (y - cy) * co];
+}

package/src/analyse/shape/thickness.d.ts

@@ -0,0 +1,6 @@
+import type { Ink } from './ink.js';
+
+/** The share of the ink in parts thicker than 2r (covered by discs of radius `r` pixels inside it), 0–1. */
+export function thickShare(ink: Pick<Ink, 'bin' | 'n' | 'count'>, depth: Float32Array, r: number): number;
+/** How drawn-out the pieces are: area over width squared per piece, averaged by area (a stroke ≈ length / width). */
+export function elongation(ink: Pick<Ink, 'bin' | 'n'>, depth: Float32Array): number;

package/src/analyse/shape/thickness.js

@@ -0,0 +1,62 @@
+/**
+ * @module @logomarks/core/analyse/shape/thickness
+ *
+ * How thick a mark's ink is, from its distance transform: the share of the ink in parts thicker than a width (what
+ * an opening by a disc keeps), and how drawn-out its pieces are (a stroke is long for its width; a dot or a block
+ * isn't).
+ */
+
+import { distance } from '../../raster/distance.js';
+import { bitmap } from './ink.js';
+
+/**
+ * The share of the ink covered by discs of radius `r` that fit inside it: the ink in parts thicker than 2r.
+ *
+ * @param {import('./ink.js').Ink} ink The ink.
+ * @param {Float32Array} depth Each ink pixel's distance to the empty space (`distance(ink, 1)`).
+ * @param {number} r The radius in pixels.
+ * @returns {number} 0–1.
+ */
+export function thickShare({ bin, n, count }, depth, r) {
+	const core = new Uint8Array(n * n);
+	let any = false;
+	for (let k = 0; k < n * n; k++) if (bin[k] && depth[k] >= r) { core[k] = 1; any = true; }
+	if (!any || !count) return 0;
+	const near = distance(bitmap(core, n), 0);
+	let kept = 0;
+	for (let k = 0; k < n * n; k++) if (bin[k] && near[k] <= r) kept++;
+	return kept / count;
+}
+
+/**
+ * How drawn-out the pieces are: each 8-connected piece's area over its width squared (its width four times its mean
+ * depth, exact for a long even stroke), averaged by area. A stroke L long and w wide scores about L / w; a dot about
+ * 1.8, a square block 2.3.
+ *
+ * @param {import('./ink.js').Ink} ink The ink.
+ * @param {Float32Array} depth Each ink pixel's distance to the empty space.
+ * @returns {number} The area-weighted mean.
+ */
+export function elongation({ bin, n }, depth) {
+	const seen = new Uint8Array(n * n), stack = [];
+	let sum = 0, total = 0;
+	for (let s = 0; s < n * n; s++) {
+		if (!bin[s] || seen[s]) continue;
+		let area = 0, deep = 0;
+		seen[s] = 1;
+		stack.push(s);
+		while (stack.length) {
+			const k = /** @type {number} */ (stack.pop()), x = k % n, y = (k - x) / n;
+			area++;
+			deep += depth[k];
+			for (let dy = -1; dy <= 1; dy++) for (let dx = -1; dx <= 1; dx++) {
+				const X = x + dx, Y = y + dy, j = Y * n + X;
+				if (X >= 0 && Y >= 0 && X < n && Y < n && bin[j] && !seen[j]) { seen[j] = 1; stack.push(j); }
+			}
+		}
+		const width = 4 * deep / area;
+		sum += area * area / (width * width);
+		total += area;
+	}
+	return total ? sum / total : 0;
+}

package/src/analyse/tags.d.ts

@@ -1,5 +1,21 @@
+import type { ShapeMeasures } from './shape/measures.js';
+
 /** A shape tag measured from a mark's raster. */
 export type ShapeTag = 'wide' | 'tall' | 'round' | 'square' | 'solid' | 'light' | 'symmetric' | 'radial';
 
-/** A fitted mark's shape tags, from its coverage at `size` px (128) and its outline's width and height. */
+/** The thresholds the tags are decided by. */
+export const SHAPE: {
+	wide: number;
+	tall: number;
+	squarish: number;
+	round: { reach: number; ways: Partial<Record<'arc' | 'rim' | 'circularity', number>>[] };
+	square: { fill: number; corners: number };
+	symmetric: { coverage: number; outline: number };
+	radial: { coverage: number; outline: number };
+	light: { elongation: number; thick: number };
+};
+
+/** The shape tags a mark's measures earn, in a fixed order; exactly one of solid and light. */
+export function tagsOf(ms: ShapeMeasures, t?: typeof SHAPE): ShapeTag[];
+/** A fitted mark's shape tags, from its coverage at `size` px (256) and its outline's width and height. */
 export function shapeTags(a: Float32Array, m: { w: number; h: number; size?: number }): ShapeTag[];

package/src/analyse/tags.js

@@ -2,47 +2,82 @@
  * @module @logomarks/core/analyse/tags
  *
  * Shape tags measured from a mark's coverage: wide or tall, round or square, solid or light, symmetric, radial.
+ * Tuned on the 4,040 Logomarks marks against contact sheets (about 95% read right by eye; see docs/tags.md).
  */
 
-import { remap, iou } from '../similar/signature.js';
+import { shapeMeasures } from './shape/measures.js';
+
+/** The thresholds the tags are decided by: the Logomarks settings. */
+export const SHAPE = {
+	/** Width over height beyond which a mark is wide, or below which it is tall. */
+	wide: 1.25,
+	tall: 0.8,
+	/** Round and square marks are about as wide as tall: between this and its inverse. */
+	squarish: 0.9,
+	/** Round: the ink reaches the hull all round, and the hull runs on a circle (any one way). */
+	round: {
+		reach: 0.6,
+		ways: [
+			{ arc: 0.74, circularity: 0.89 },
+			{ arc: 0.65, circularity: 0.96 },
+			{ rim: 0.8, circularity: 0.97 },
+		],
+	},
+	/** Square: the closed silhouette fills its box, every corner too (and it isn't round). */
+	square: { fill: 0.88, corners: 0.6 },
+	/** Symmetric: the left-right mirror matches, coverage and outline both. */
+	symmetric: { coverage: 0.95, outline: 0.95 },
+	/** Radial: a turn of order 3, 4 or 5 matches, coverage and outline both. */
+	radial: { coverage: 0.9, outline: 0.9 },
+	/** Light: strokes (drawn-out pieces) with little mass; every other mark is solid. */
+	light: { elongation: 3, thick: 0.3 },
+};
+
+/**
+ * Whether the measures clear every threshold in `need`.
+ *
+ * @param {import('./shape/measures.js').ShapeMeasures} ms The measures.
+ * @param {Partial<Record<'arc' | 'rim' | 'circularity', number>>} need The thresholds, by measure.
+ * @returns {boolean} All met.
+ */
+const meets = (ms, need) => Object.entries(need).every(([k, v]) => ms[/** @type {'arc' | 'rim' | 'circularity'} */ (k)] >= /** @type {number} */ (v));
+
+/**
+ * The shape tags a mark's measures earn.
+ *
+ * @param {import('./shape/measures.js').ShapeMeasures} ms The measures (`shapeMeasures`).
+ * @param {typeof SHAPE} [t] The thresholds (SHAPE by default).
+ * @returns {import('./tags.js').ShapeTag[]} The tags, in a fixed order; exactly one of solid and light.
+ */
+export function tagsOf(ms, t = SHAPE) {
+	/** @type {import('./tags.js').ShapeTag[]} */
+	const tags = [];
+	if (ms.ratio > t.wide) tags.push('wide'); else if (ms.ratio < t.tall) tags.push('tall');
+	const squarish = ms.ratio > t.squarish && ms.ratio < 1 / t.squarish;
+	if (squarish && ms.reach >= t.round.reach && t.round.ways.some((way) => meets(ms, way))) tags.push('round');
+	else if (squarish && ms.closedFill >= t.square.fill && ms.closedCorners >= t.square.corners) tags.push('square');
+	const light = ms.elongation >= t.light.elongation && Math.min(ms.thick, ms.thickRelative) < t.light.thick;
+	tags.push(light ? 'light' : 'solid');
+	if (ms.mirror.coverage >= t.symmetric.coverage && ms.mirror.outline >= t.symmetric.outline) tags.push('symmetric');
+	if (ms.turns.some((r) => r.coverage >= t.radial.coverage && r.outline >= t.radial.outline)) tags.push('radial');
+	return tags;
+}
 
 /**
- * A fitted mark's shape tags, from its coverage at `size` px (128) and its outline's size on the 512 canvas.
+ * A fitted mark's shape tags, from its coverage at `size` px (256) and its outline's size on the 512 canvas.
  * - wide / tall: wider than 1.25 or narrower than 0.8;
- * - round: about square, every corner of its box empty and the silhouette reaching the edge midpoints and diagonals;
- * - square: about square with three corners or more filled;
- * - solid / light: over 62% or under 30% of its box inked;
- * - symmetric: mirrors onto itself (IoU over 0.94); radial: a quarter turn (0.92) or a half turn (0.94) does.
+ * - round: about square (0.9–1.11), the ink reaching its convex hull all round, and the hull running on a circle;
+ * - square: about square, not round, and its silhouette (gaps up to 60 closed, holes filled) filling its box to the
+ *   corners;
+ * - solid / light: light when it's drawn in strokes with little mass (under 30% of the ink in parts thicker than 48
+ *   units, or than 12% of its short side); every other mark is solid;
+ * - symmetric: its left-right mirror matches (coverage and outline 0.95); a top-bottom mirror alone doesn't count;
+ * - radial: a turn by a third, a quarter or a fifth matches (0.9): rotational symmetry of order 3 or more.
  *
  * @param {Float32Array} a Coverage 0–1, `size` × `size`, row by row.
  * @param {{ w: number, h: number, size?: number }} m The outline's width and height (fitted), and the raster's side.
  * @returns {import('./tags.js').ShapeTag[]} The tags, in a fixed order.
  */
-export function shapeTags(a, { w: mw, h: mh, size: N = 128 }) {
-  const tags = new Set();
-  const tf = (/** @type {(x: number, y: number) => number[]} */ f) => remap(a, N, f);
-  // bbox in raster px
-  const s = N / 512, x0 = Math.round((256 - mw / 2) * s), y0 = Math.round((256 - mh / 2) * s), w = Math.round(mw * s), h = Math.round(mh * s);
-  let fill = 0; for (let y = y0; y < y0 + h; y++) for (let x = x0; x < x0 + w; x++) fill += a[y * N + x] || 0;
-  const density = fill / (w * h);
-  const ratio = mw / mh;
-  if (ratio > 1.25) tags.add('wide'); else if (ratio < 0.8) tags.add('tall');
-  // corners of the bbox: empty everywhere → round silhouette; mostly filled → square
-  const c = Math.max(2, Math.round(Math.min(w, h) * 0.1));
-  const corner = (/** @type {number} */ cx, /** @type {number} */ cy) => { let f = 0; for (let y = cy; y < cy + c; y++) for (let x = cx; x < cx + c; x++) f += a[y * N + x] || 0; return f / (c * c); };
-  const cs = [corner(x0, y0), corner(x0 + w - c, y0), corner(x0, y0 + h - c), corner(x0 + w - c, y0 + h - c)];
-  const sq = ratio > 0.92 && ratio < 1.08;
-  if (sq && cs.every((v) => v < 0.04)) {
-    // also require the silhouette to reach the edge midpoints (a disc, not a diamond or a small blob)
-    const mid = (/** @type {number} */ x, /** @type {number} */ y) => a[y * N + x] > 0.5;
-    const r = Math.round(w / 2), cxp = x0 + r, cyp = y0 + r, d = Math.round(w * 0.06);
-    const diag = Math.round(r * 0.70);
-    if ([mid(cxp, y0 + d), mid(cxp, y0 + h - 1 - d), mid(x0 + d, cyp), mid(x0 + w - 1 - d, cyp)].filter(Boolean).length >= 3 &&
-        [mid(cxp - diag + d, cyp - diag + d), mid(cxp + diag - d, cyp - diag + d), mid(cxp - diag + d, cyp + diag - d), mid(cxp + diag - d, cyp + diag - d)].filter(Boolean).length >= 3) tags.add('round');
-  }
-  if (sq && cs.filter((v) => v > 0.6).length >= 3) tags.add('square');
-  if (density > 0.62) tags.add('solid'); else if (density < 0.3) tags.add('light');
-  if (iou(a, tf((x, y) => [N - 1 - x, y])) > 0.94 || iou(a, tf((x, y) => [x, N - 1 - y])) > 0.94) tags.add('symmetric');
-  if (iou(a, tf((x, y) => [y, N - 1 - x])) > 0.92 || iou(a, tf((x, y) => [N - 1 - x, N - 1 - y])) > 0.94) tags.add('radial');
-  return /** @type {import('./tags.js').ShapeTag[]} */ ([...tags]);
+export function shapeTags(a, m) {
+	return tagsOf(shapeMeasures(a, m));
 }