@logomarks/core 0.1.8 → 0.1.11

package/src/stitch/satin.js

@@ -0,0 +1,86 @@
+/**
+ * @module @logomarks/core/stitch/satin
+ *
+ * Satin stitch: the narrow parts covered by threads laid side by side
+ * straight across them, edge to edge, each following the stroke's local
+ * direction. The threads start on the stroke's middle line (the ridge of
+ * its distance field), spaced evenly along it, and run both ways along the
+ * direction across until the edge. Where the picks along the middle line
+ * leave a gap, and where threads fan apart (the outside of a bend, a
+ * stroke's end), more threads are laid through what's left bare.
+ */
+
+import { acrossField, sample, spaced, reach } from './field.js';
+
+/** How many times the threads are topped up through what's still bare. */
+const PASSES = 2;
+
+/**
+ * Marks the pixels near a stitch as covered.
+ *
+ * @param {Uint8Array} covered The coverage, changed in place.
+ * @param {number} W The width.
+ * @param {number} H The height.
+ * @param {number[]} s The stitch: `x0, y0, x1, y1`.
+ * @param {number} r How near, in pixels.
+ */
+function cover(covered, W, H, [x0, y0, x1, y1], r) {
+	const [dx, dy] = [x1 - x0, y1 - y0];
+	const L2 = Math.max(1e-9, dx * dx + dy * dy);
+	for (let y = Math.max(0, Math.floor(Math.min(y0, y1) - r)); y <= Math.min(H - 1, Math.ceil(Math.max(y0, y1) + r)); y++) {
+		for (let x = Math.max(0, Math.floor(Math.min(x0, x1) - r)); x <= Math.min(W - 1, Math.ceil(Math.max(x0, x1) + r)); x++) {
+			const t = Math.max(0, Math.min(1, ((x - x0) * dx + (y - y0) * dy) / L2));
+			if ((x - x0 - t * dx) ** 2 + (y - y0 - t * dy) ** 2 <= r * r) covered[y * W + x] = 1;
+		}
+	}
+}
+
+/**
+ * The satin stitches over a mask.
+ *
+ * @param {Uint8Array} mask Where (1 inside: the narrow parts).
+ * @param {Float32Array} dist Each ink pixel's distance to the edge of the ink.
+ * @param {number} W The raster's width.
+ * @param {number} H Its height.
+ * @param {object} o How.
+ * @param {number} o.spacing The distance between threads, in pixels.
+ * @param {number} o.half Half the widest satin, in pixels (a thread reaches no farther from where it starts than about this).
+ * @param {number} o.smooth How far the direction is smoothed, in pixels.
+ * @returns {number[]} The stitches, flat: `x0, y0, x1, y1` each, in pixel coordinates.
+ */
+export function satinStitches(mask, dist, W, H, { spacing, half, smooth }) {
+	const field = acrossField(dist, mask, W, H, Math.max(1, Math.round(smooth)));
+	const out = [];
+	const covered = new Uint8Array(W * H);
+	const lay = (i) => {
+		const x = i % W, y = (i - x) / W;
+		const [ax, ay] = [Math.cos(field[i]), Math.sin(field[i])];
+		const max = Math.min(half * 1.6, dist[i] * 1.8) + 1.5;
+		const tp = reach(dist, W, H, x, y, ax, ay, max);
+		const tm = reach(dist, W, H, x, y, -ax, -ay, max);
+		if (tp + tm < 0.8) return;
+		const s = [x - ax * tm, y - ay * tm, x + ax * tp, y + ay * tp];
+		out.push(...s);
+		cover(covered, W, H, s, spacing * 1.1);
+	};
+	// the middle line: pixels at least as far from the edge as their neighbours across
+	const ridge = [];
+	for (let i = 0; i < W * H; i++) {
+		if (!mask[i] || dist[i] < 1) continue;
+		const x = i % W, y = (i - x) / W;
+		const [ax, ay] = [Math.cos(field[i]), Math.sin(field[i])];
+		if (dist[i] >= sample(dist, W, H, x + ax, y + ay) - 1e-3 && dist[i] >= sample(dist, W, H, x - ax, y - ay) - 1e-3) ridge.push(i);
+	}
+	for (const i of spaced(ridge, W, spacing)) lay(i);
+	// where the picks along the middle line met from two sides and left a gap, one more thread
+	const near = new Uint8Array(W * H);
+	for (let k = 0; k < out.length; k += 4) cover(near, W, H, out.slice(k, k + 4), spacing * 0.6);
+	for (const i of spaced(ridge.filter((j) => !near[j]), W, spacing * 0.8)) lay(i);
+	for (let p = 0; p < PASSES; p++) {
+		const bare = [];
+		for (let i = 0; i < W * H; i++) if (mask[i] && !covered[i]) bare.push(i);
+		if (!bare.length) break;
+		for (const i of spaced(bare, W, spacing, (j) => covered[j] === 1)) lay(i);
+	}
+	return out;
+}