@logomarks/core 0.1.3 → 0.1.5

package/CHANGELOG.md

@@ -5,6 +5,18 @@ 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.5] — 2026-11-06
+
+### Added
+
+- `pixelCoverage(paths, grid)` measures how much of each pixel cell a mark covers from its rings, by scanline, so pixelate runs without a canvas (a server, a Worker); `pixelCells(cov, grid)` returns the filled cells themselves, for drawing them one by one (`@arraypress/covers` uses both for its pixel mosaic). `pixelPath` is unchanged.
+
+## [0.1.4] — 2026-11-06
+
+### Fixed
+
+- The generated `fit.mjs` fits several files each in place. Given exactly two files it used to take the second as the output and write the first one's fit into it, so the second mark was lost. A file's fit now goes to another file only with `-o out.svg`, or when the second path doesn't exist yet (`in.svg out.svg`, as before). `--help` prints the usage (it used to crash), and an unknown option, a missing path or `-o` with several inputs exits 2 with the reason.
+
 ## [0.1.3] — 2026-11-06
 
 ### Fixed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logomarks/core",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "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/edit/index.d.ts

@@ -3,4 +3,4 @@ export type { Adjust, Frame, Similarity, AdjustEnv } from './adjust.js';
 export type { PixelGrid } from './pixelate.js';
 export { loadShaper, shaperReady, hasCorners, reshape, pieceCount, shapeInfo, smallSizeInfo } from './reshape.js';
 export { NO_ADJUST, isAdjusted, adjustSuffix, transformPath, adjustPaths } from './adjust.js';
-export { SS, pixelGrid, pixelPath } from './pixelate.js';
+export { SS, pixelGrid, pixelPath, pixelCells, pixelCoverage } from './pixelate.js';

package/src/edit/index.js

@@ -4,4 +4,4 @@
  */
 export { loadShaper, shaperReady, hasCorners, reshape, pieceCount, shapeInfo, smallSizeInfo } from './reshape.js';
 export { NO_ADJUST, isAdjusted, adjustSuffix, transformPath, adjustPaths } from './adjust.js';
-export { SS, pixelGrid, pixelPath } from './pixelate.js';
+export { SS, pixelGrid, pixelPath, pixelCells, pixelCoverage } from './pixelate.js';

package/src/edit/pixelate.d.ts

@@ -1,3 +1,5 @@
+import type { FillPath } from '../raster/scanline.js';
+
 /** A pixel grid over a mark's box. */
 export interface PixelGrid {
 	cols: number;
@@ -11,5 +13,9 @@ export interface PixelGrid {
 export const SS: 6;
 /** The grid for a box: 48 cells across its longest side at amount 0, 14 at amount 1, centred. */
 export function pixelGrid(amount: number, box: { x: number; y: number; width: number; height: number }): PixelGrid;
+/** How much of each cell the mark's rings cover (0–1, row by row), by scanline at SS × SS samples a cell. */
+export function pixelCoverage(paths: readonly FillPath[], grid: PixelGrid): Float32Array;
+/** The filled cells (1 each, row by row): half covered, or a fifth where a cell stands alone or bridges two. */
+export function pixelCells(cov: ArrayLike<number>, grid: Pick<PixelGrid, 'cols' | 'rows'>): Uint8Array;
 /** The pixelated mark as one path's d, from each cell's coverage; null when nothing is filled. */
 export function pixelPath(cov: ArrayLike<number>, grid: PixelGrid): string | null;

package/src/edit/pixelate.js

@@ -11,7 +11,12 @@
  *   alone (a thin line or a small dot would vanish) or when it bridges two filled cells across it (a diagonal would
  *   break into steps that don't touch).
  * - Filled cells are merged into as few rectangles as possible, so the SVG stays small and clean.
+ *
+ * Where there's no canvas to measure with (a server, a Worker), `pixelCoverage` measures the cells from the mark's
+ * rings by scanline; `pixelCells` gives the filled cells themselves, for drawing them one by one (a mosaic).
  */
+import { fill } from '../raster/scanline.js';
+
 /** Samples a cell is measured at, along each side (6 × 6 a cell). */
 export const SS = 6;
 
@@ -32,20 +37,38 @@ export function pixelGrid(amount, box) {
 }
 
 /**
- * The pixelated mark as one path's d, from how much of each cell the mark covers: cells covered half or more are
- * filled, cells covered a fifth or more too when they stand alone or bridge two filled cells, then merged into as few
- * rectangles as possible. Null when nothing is filled.
+ * How much of each cell the mark covers, measured from its rings by scanline at `SS` × `SS` samples a cell: what a
+ * canvas would measure, without one.
+ *
+ * @param {readonly import('../raster/scanline.js').FillPath[]} paths The mark's paths (rings and fill rules).
+ * @param {import('./index.js').PixelGrid} grid The grid.
+ * @returns {Float32Array} Coverage 0–1 per cell, row by row.
+ */
+export function pixelCoverage(paths, { cols, rows, cell, x0, y0 }) {
+	const bmp = fill(paths, { x0, y0, scale: SS / cell, width: cols * SS, height: rows * SS });
+	const cov = new Float32Array(cols * rows);
+	for (let j = 0; j < bmp.height; j++)
+		for (let i = 0; i < bmp.width; i++)
+			if (bmp.data[j * bmp.width + i])
+				cov[Math.floor(j / SS) * cols + Math.floor(i / SS)]++;
+	for (let k = 0; k < cov.length; k++)
+		cov[k] /= SS * SS;
+	return cov;
+}
+
+/**
+ * The filled cells, from how much of each the mark covers: half or more, or a fifth or more where a cell stands alone
+ * (a thin line or a small dot would vanish) or bridges two filled cells across it (a diagonal would break).
  *
  * @param {ArrayLike<number>} cov Coverage 0–1 per cell, row by row.
  * @param {import('./index.js').PixelGrid} grid The grid.
- * @returns {string | null} The path data.
+ * @returns {Uint8Array} 1 per filled cell, row by row.
  */
-export function pixelPath(cov, { cols, rows, cell, x0, y0 }) {
+export function pixelCells(cov, { cols, rows }) {
 	const at = (m, q, r) => (q >= 0 && r >= 0 && q < cols && r < rows ? m[r * cols + q] : 0);
 	const on = new Uint8Array(cols * rows);
 	for (let i = 0; i < on.length; i++)
 		on[i] = cov[i] >= 0.5 ? 1 : 0;
-	// keep thin lines and small dots, and bridge diagonals
 	const keep = on.slice();
 	for (let r = 0; r < rows; r++)
 		for (let q = 0; q < cols; q++) {
@@ -64,6 +87,20 @@ export function pixelPath(cov, { cols, rows, cell, x0, y0 }) {
 			if (!near || (bridges && cov[i] >= 0.3))
 				keep[i] = 1;
 		}
+	return keep;
+}
+
+/**
+ * The pixelated mark as one path's d, from how much of each cell the mark covers: cells covered half or more are
+ * filled, cells covered a fifth or more too when they stand alone or bridge two filled cells, then merged into as few
+ * rectangles as possible. Null when nothing is filled.
+ *
+ * @param {ArrayLike<number>} cov Coverage 0–1 per cell, row by row.
+ * @param {import('./index.js').PixelGrid} grid The grid.
+ * @returns {string | null} The path data.
+ */
+export function pixelPath(cov, { cols, rows, cell, x0, y0 }) {
+	const keep = pixelCells(cov, { cols, rows });
 	const done = [];
 	let open = new Map();
 	for (let r = 0; r <= rows; r++) {

package/src/skill/bundle.js

@@ -41,8 +41,8 @@ const FIT_HEADER = `#!/usr/bin/env node
 // {{url}} · CC0 · no dependencies
 //
 //   node fit.mjs mark.svg                 fit in place
-//   node fit.mjs in.svg out.svg           fit to a new file
-//   node fit.mjs marks/                   fit every .svg in a folder, in place
+//   node fit.mjs in.svg -o out.svg        fit to another file (in.svg out.svg too, while out.svg doesn't exist)
+//   node fit.mjs a.svg b.svg marks/       fit each file, and every .svg in a folder, in place
 //   node fit.mjs --check mark.svg marks/  only report; exits 1 if anything is off
 //
 // Reads <path d> (with fill-rule), <circle>, <ellipse>, <rect> and <polygon>; nested
@@ -58,16 +58,33 @@ import path from 'node:path';
 const FIT_MAIN = `
 // ---------- command line ----------
 
+const USAGE = \`Usage: node fit.mjs [--check] <file.svg | folder>... [-o out.svg]
+  Fits each file in place (a folder: every .svg in it). -o writes one file's fit to another file;
+  so does a second path that doesn't exist yet (in.svg out.svg). --check only reports.\`;
+
+/** Stops with a message and the usage. */
+const fail = (msg) => { console.error(\`fit.mjs: \${msg}\\n\${USAGE}\`); process.exit(2); };
+
 const args = process.argv.slice(2);
-const checking = args[0] === '--check';
-if (checking) args.shift();
-if (!args.length) {
-	console.log('Usage: node fit.mjs [--check] <file.svg | folder> [out.svg]');
-	process.exit(1);
+if (args.some((a) => a === '--help' || a === '-h')) { console.log(USAGE); process.exit(0); }
+const checking = args.includes('--check');
+let out = null;
+const paths = [];
+for (let i = 0; i < args.length; i++) {
+	if (args[i] === '--check') continue;
+	if (args[i] === '-o' || args[i] === '--out') { out = args[++i] ?? fail(\`\${args[i - 1]} needs a file\`); continue; }
+	if (args[i].startsWith('-')) fail(\`unknown option \${args[i]}\`);
+	paths.push(args[i]);
+}
+if (!paths.length) fail('no file or folder given');
+for (const p of paths) if (!fs.existsSync(p)) {
+	// in.svg out.svg: the second path names the file to write, as -o does
+	if (!checking && !out && paths.length === 2 && p === paths[1] && p.endsWith('.svg')) out = paths.pop();
+	else fail(\`\${p} doesn't exist\`);
 }
+if (out && (checking || paths.length !== 1 || fs.statSync(paths[0]).isDirectory())) fail('-o takes one .svg file to fit, without --check');
 const files = [];
-const out = !checking && args.length === 2 && !fs.statSync(args[0]).isDirectory() && args[1].endsWith('.svg') ? args.pop() : null;
-for (const a of args) {
+for (const a of paths) {
 	if (fs.statSync(a).isDirectory()) for (const f of fs.readdirSync(a)) { if (f.endsWith('.svg')) files.push(path.join(a, f)); }
 	else files.push(a);
 }