pdf-raster-cpu 0.0.0 → 1.0.0

package/dist/index.d.cts

@@ -0,0 +1,28 @@
+import { PageRasteriser, RasterDrawOp, RasterPageGeometry } from "pdf-codec/raster";
+//#region src/rasteriser.d.ts
+interface RasterCpuDiagnostic {
+  readonly code: "raster-cpu/jpeg-image-undecoded";
+  readonly message: string;
+}
+interface CpuRasteriserOptions {
+  readonly onDiagnostic?: (diagnostic: RasterCpuDiagnostic) => void;
+}
+declare function createCpuRasteriser(options?: CpuRasteriserOptions): PageRasteriser;
+declare class CpuRasteriser implements PageRasteriser {
+  private readonly onDiagnostic;
+  private buffers;
+  private readonly decodedImages;
+  constructor(options?: CpuRasteriserOptions);
+  beginPage(geometry: RasterPageGeometry): void;
+  draw(op: RasterDrawOp): void;
+  finish(): Uint8Array<ArrayBuffer>;
+  private requirePage;
+  private fillRectOp;
+  private pathOp;
+  private imageOp;
+  private decodeCached;
+  private blendMask;
+  private blendPixel;
+}
+//#endregion
+export { CpuRasteriser, type CpuRasteriserOptions, type RasterCpuDiagnostic, createCpuRasteriser };

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+import { PageRasteriser, RasterDrawOp, RasterPageGeometry } from "pdf-codec/raster";
+//#region src/rasteriser.d.ts
+interface RasterCpuDiagnostic {
+  readonly code: "raster-cpu/jpeg-image-undecoded";
+  readonly message: string;
+}
+interface CpuRasteriserOptions {
+  readonly onDiagnostic?: (diagnostic: RasterCpuDiagnostic) => void;
+}
+declare function createCpuRasteriser(options?: CpuRasteriserOptions): PageRasteriser;
+declare class CpuRasteriser implements PageRasteriser {
+  private readonly onDiagnostic;
+  private buffers;
+  private readonly decodedImages;
+  constructor(options?: CpuRasteriserOptions);
+  beginPage(geometry: RasterPageGeometry): void;
+  draw(op: RasterDrawOp): void;
+  finish(): Uint8Array<ArrayBuffer>;
+  private requirePage;
+  private fillRectOp;
+  private pathOp;
+  private imageOp;
+  private decodeCached;
+  private blendMask;
+  private blendPixel;
+}
+//#endregion
+export { CpuRasteriser, type CpuRasteriserOptions, type RasterCpuDiagnostic, createCpuRasteriser };

package/dist/index.js

@@ -0,0 +1,561 @@
+import { crc32, decodePng, encodePng } from "byte-codec";
+var CoverageMask = class {
+	widthPx;
+	heightPx;
+	counts;
+	constructor(widthPx, heightPx) {
+		this.widthPx = widthPx;
+		this.heightPx = heightPx;
+		this.counts = new Uint16Array(widthPx * heightPx);
+	}
+	reset() {
+		this.counts.fill(0);
+	}
+	countAt(pixelIndex) {
+		return this.counts[pixelIndex] ?? 0;
+	}
+	fillPolygons(polygons, fillRule) {
+		if (polygons.length === 0) return;
+		let minY = Infinity;
+		let maxY = -Infinity;
+		for (const polygon of polygons) {
+			if (polygon.length < 3) continue;
+			for (const point of polygon) {
+				minY = Math.min(minY, point.y);
+				maxY = Math.max(maxY, point.y);
+			}
+		}
+		if (maxY <= minY) return;
+		const rowMin = Math.max(0, Math.ceil(minY * 4 - .5));
+		const rowMax = Math.min(4 * this.heightPx - 1, Math.floor(maxY * 4 - .5));
+		const crossings = [];
+		for (let row = rowMin; row <= rowMax; row++) {
+			const y = (row + .5) / 4;
+			crossings.length = 0;
+			for (const polygon of polygons) for (let i = 0; i < polygon.length; i++) {
+				const a = polygon[i];
+				const b = polygon[(i + 1) % polygon.length];
+				if (a === void 0 || b === void 0) continue;
+				if (a.y <= y === b.y <= y) continue;
+				const t = (y - a.y) / (b.y - a.y);
+				crossings.push({
+					x: a.x + t * (b.x - a.x),
+					dir: b.y > a.y ? 1 : -1
+				});
+			}
+			if (crossings.length === 0) continue;
+			crossings.sort((p, q) => p.x - q.x);
+			const pixelRowBase = Math.floor(row / 4) * this.widthPx;
+			let spanStartX;
+			let winding = 0;
+			for (const crossing of crossings) {
+				if (fillRule === "evenodd") {
+					if (spanStartX === void 0) spanStartX = crossing.x;
+					else {
+						this.markSpan(pixelRowBase, spanStartX, crossing.x);
+						spanStartX = void 0;
+					}
+					continue;
+				}
+				const previous = winding;
+				winding += crossing.dir;
+				if (previous === 0 && winding !== 0) spanStartX = crossing.x;
+				else if (spanStartX !== void 0 && winding === 0) {
+					this.markSpan(pixelRowBase, spanStartX, crossing.x);
+					spanStartX = void 0;
+				}
+			}
+		}
+	}
+	markSpan(pixelRowBase, startX, endX) {
+		if (endX <= startX) return;
+		const columnFirst = Math.max(0, Math.ceil(startX * 4 - .5));
+		const columnLast = Math.min(4 * this.widthPx - 1, Math.floor(endX * 4 - .5));
+		for (let c = columnFirst; c <= columnLast; c++) {
+			const cellIndex = pixelRowBase + Math.floor(c / 4);
+			const cell = this.counts[cellIndex];
+			if (cell !== void 0) this.counts[cellIndex] = cell + 1;
+		}
+	}
+};
+function flattenCubic(p0, c1, c2, p1) {
+	const points = [];
+	const flatten = (a, b, c, d, depth) => {
+		const chordX = d.x - a.x;
+		const chordY = d.y - a.y;
+		const chordLength = Math.hypot(chordX, chordY) || 1;
+		const dist1 = Math.abs((b.x - a.x) * chordY - (b.y - a.y) * chordX) / chordLength;
+		const dist2 = Math.abs((c.x - a.x) * chordY - (c.y - a.y) * chordX) / chordLength;
+		if (depth >= 16 || Math.max(dist1, dist2) <= .05) {
+			points.push(d);
+			return;
+		}
+		const ab = {
+			x: (a.x + b.x) / 2,
+			y: (a.y + b.y) / 2
+		};
+		const bc = {
+			x: (b.x + c.x) / 2,
+			y: (b.y + c.y) / 2
+		};
+		const cd = {
+			x: (c.x + d.x) / 2,
+			y: (c.y + d.y) / 2
+		};
+		const abc = {
+			x: (ab.x + bc.x) / 2,
+			y: (ab.y + bc.y) / 2
+		};
+		const bcd = {
+			x: (bc.x + cd.x) / 2,
+			y: (bc.y + cd.y) / 2
+		};
+		const mid = {
+			x: (abc.x + bcd.x) / 2,
+			y: (abc.y + bcd.y) / 2
+		};
+		flatten(a, ab, abc, mid, depth + 1);
+		flatten(mid, bcd, cd, d, depth + 1);
+	};
+	flatten(p0, c1, c2, p1, 0);
+	return points;
+}
+function flattenSubpath(subpath) {
+	const points = [{
+		x: subpath.startXPx,
+		y: subpath.startYPx
+	}];
+	for (const segment of subpath.segments) {
+		if (segment.kind === "line") {
+			points.push({
+				x: segment.xPx,
+				y: segment.yPx
+			});
+			continue;
+		}
+		const previous = points[points.length - 1];
+		if (previous === void 0) continue;
+		points.push(...flattenCubic(previous, {
+			x: segment.c1xPx,
+			y: segment.c1yPx
+		}, {
+			x: segment.c2xPx,
+			y: segment.c2yPx
+		}, {
+			x: segment.xPx,
+			y: segment.yPx
+		}));
+	}
+	return {
+		points,
+		closed: subpath.closed
+	};
+}
+function strokeOutlinePolygons(subpaths, widthPx, dashPx) {
+	const half = Math.max(widthPx, 1) / 2;
+	const polygons = [];
+	const emitPiece = (piece) => {
+		for (let i = 0; i + 1 < piece.length; i++) {
+			const p = piece[i];
+			const q = piece[i + 1];
+			if (p === void 0 || q === void 0) continue;
+			const d = unitDirection(p, q);
+			if (d === void 0) continue;
+			const n = {
+				x: -d.y,
+				y: d.x
+			};
+			polygons.push([
+				{
+					x: p.x + n.x * half,
+					y: p.y + n.y * half
+				},
+				{
+					x: q.x + n.x * half,
+					y: q.y + n.y * half
+				},
+				{
+					x: q.x - n.x * half,
+					y: q.y - n.y * half
+				},
+				{
+					x: p.x - n.x * half,
+					y: p.y - n.y * half
+				}
+			]);
+		}
+		for (let i = 1; i + 1 < piece.length; i++) {
+			const vertex = piece[i];
+			const before = piece[i - 1];
+			const after = piece[i + 1];
+			if (vertex === void 0 || before === void 0 || after === void 0) continue;
+			emitJoinWedge(polygons, vertex, before, after, half);
+		}
+	};
+	if (dashPx === void 0) {
+		for (const subpath of subpaths) {
+			const first = subpath.points[0];
+			if (first === void 0) continue;
+			emitPiece(subpath.closed ? [...subpath.points, first] : subpath.points);
+			if (subpath.closed && subpath.points.length >= 3) {
+				const last = subpath.points[subpath.points.length - 1];
+				const second = subpath.points[1];
+				if (last !== void 0 && second !== void 0) emitJoinWedge(polygons, first, last, second, half);
+			}
+		}
+		return polygons;
+	}
+	for (const subpath of subpaths) for (const piece of dashPolyline(subpath, dashPx)) emitPiece(piece);
+	return polygons;
+}
+function emitJoinWedge(polygons, vertex, before, after, half) {
+	const d1 = unitDirection(before, vertex);
+	const d2 = unitDirection(vertex, after);
+	if (d1 === void 0 || d2 === void 0) return;
+	const cross = d1.x * d2.y - d1.y * d2.x;
+	if (Math.abs(cross) < 1e-12) return;
+	const side = cross > 0 ? -1 : 1;
+	const n1 = {
+		x: -d1.y * side,
+		y: d1.x * side
+	};
+	const n2 = {
+		x: -d2.y * side,
+		y: d2.x * side
+	};
+	const a1 = {
+		x: vertex.x + n1.x * half,
+		y: vertex.y + n1.y * half
+	};
+	const a2 = {
+		x: vertex.x + n2.x * half,
+		y: vertex.y + n2.y * half
+	};
+	const dot = n1.x * n2.x + n1.y * n2.y;
+	const denominator = 1 + dot;
+	let wedge;
+	if (denominator > 1e-12 && miterRatio(dot) <= 10) {
+		const scale = half / denominator;
+		wedge = [
+			a1,
+			{
+				x: vertex.x + (n1.x + n2.x) * scale,
+				y: vertex.y + (n1.y + n2.y) * scale
+			},
+			a2,
+			vertex
+		];
+	} else wedge = [
+		a1,
+		vertex,
+		a2
+	];
+	polygons.push(polygonSignedArea(wedge) < 0 ? [...wedge] : [...wedge].reverse());
+}
+function miterRatio(dot) {
+	return Math.sqrt(2 + 2 * dot) / (1 + dot);
+}
+function polygonSignedArea(polygon) {
+	let area = 0;
+	for (let i = 0; i < polygon.length; i++) {
+		const a = polygon[i];
+		const b = polygon[(i + 1) % polygon.length];
+		if (a === void 0 || b === void 0) continue;
+		area += a.x * b.y - b.x * a.y;
+	}
+	return area;
+}
+function unitDirection(p, q) {
+	const dx = q.x - p.x;
+	const dy = q.y - p.y;
+	const length = Math.hypot(dx, dy);
+	if (length === 0) return;
+	return {
+		x: dx / length,
+		y: dy / length
+	};
+}
+function dashPolyline(subpath, dashPx) {
+	if (!dashPx.some((length) => length > 0)) return [];
+	const pattern = dashPx.length % 2 === 1 ? [...dashPx, ...dashPx] : dashPx;
+	const points = subpath.closed ? [...subpath.points, subpath.points[0]] : subpath.points;
+	const start = points[0];
+	if (start === void 0) return [];
+	const pieces = [];
+	const endOnPiece = () => {
+		if (current.length >= 2) pieces.push(current);
+		current = [];
+	};
+	const atBoundary = () => {
+		if (index % 2 === 0) endOnPiece();
+		for (;;) {
+			index = (index + 1) % pattern.length;
+			const entry = pattern[index];
+			if (entry !== void 0 && entry > 0) {
+				remaining = entry;
+				break;
+			}
+		}
+		if (index % 2 === 0) current = [cursor];
+	};
+	let index = 0;
+	let remaining = 0;
+	let cursor = start;
+	let current = [];
+	const firstEntry = pattern[0];
+	if (firstEntry !== void 0 && firstEntry > 0) {
+		remaining = firstEntry;
+		current = [cursor];
+	} else atBoundary();
+	for (let i = 0; i + 1 < points.length; i++) {
+		const from = points[i];
+		const to = points[i + 1];
+		if (from === void 0 || to === void 0) continue;
+		const direction = unitDirection(from, to);
+		if (direction === void 0) continue;
+		cursor = from;
+		let segmentRemaining = Math.hypot(to.x - from.x, to.y - from.y);
+		while (segmentRemaining > 0 && remaining > 0) {
+			const step = Math.min(segmentRemaining, remaining);
+			cursor = {
+				x: cursor.x + direction.x * step,
+				y: cursor.y + direction.y * step
+			};
+			segmentRemaining -= step;
+			remaining -= step;
+			if (current.length > 0) current.push(cursor);
+			if (remaining === 0) atBoundary();
+		}
+	}
+	if (current.length > 0) endOnPiece();
+	return pieces;
+}
+//#endregion
+//#region src/rasteriser.ts
+function createCpuRasteriser(options = {}) {
+	return new CpuRasteriser(options);
+}
+var CpuRasteriser = class {
+	onDiagnostic;
+	buffers;
+	decodedImages = /* @__PURE__ */ new Map();
+	constructor(options = {}) {
+		this.onDiagnostic = options.onDiagnostic;
+	}
+	beginPage(geometry) {
+		this.buffers = {
+			geometry,
+			canvas: new Uint8Array(geometry.widthPx * geometry.heightPx * 3).fill(255),
+			mask: new CoverageMask(geometry.widthPx, geometry.heightPx)
+		};
+		this.decodedImages.clear();
+	}
+	draw(op) {
+		if (op.kind === "fillRect") {
+			this.fillRectOp(op);
+			return;
+		}
+		if (op.kind === "path") {
+			this.pathOp(op);
+			return;
+		}
+		this.imageOp(op);
+	}
+	finish() {
+		const { geometry, canvas } = this.requirePage("finish");
+		const png = encodePng({
+			width: geometry.widthPx,
+			height: geometry.heightPx,
+			channels: 3,
+			data: canvas
+		});
+		this.buffers = void 0;
+		return png;
+	}
+	requirePage(operation) {
+		if (this.buffers === void 0) throw new Error(`CpuRasteriser.${operation}() was called before beginPage(); renderPdfPage (or the caller) drives one page at a time through beginPage, draw..., finish`);
+		return this.buffers;
+	}
+	fillRectOp(op) {
+		const { geometry, canvas } = this.requirePage("draw");
+		const left = Math.max(op.xPx, 0);
+		const right = Math.min(op.xPx + op.widthPx, geometry.widthPx);
+		const top = Math.max(op.yPx, 0);
+		const bottom = Math.min(op.yPx + op.heightPx, geometry.heightPx);
+		if (right <= left || bottom <= top) return;
+		const colour = colourBytes(op.color);
+		const columnStart = Math.floor(left);
+		const columnEnd = Math.ceil(right);
+		const rowStart = Math.floor(top);
+		const rowEnd = Math.ceil(bottom);
+		for (let row = rowStart; row < rowEnd; row++) {
+			const coverageY = pixelOverlap(row, top, bottom);
+			if (coverageY === 0) continue;
+			const rowBase = row * geometry.widthPx;
+			for (let column = columnStart; column < columnEnd; column++) {
+				const coverage = coverageY * pixelOverlap(column, left, right);
+				if (coverage === 0) continue;
+				this.blendPixel(canvas, rowBase + column, colour, coverage);
+			}
+		}
+	}
+	pathOp(op) {
+		const { canvas, mask } = this.requirePage("draw");
+		const flattened = op.subpaths.map(flattenSubpath);
+		if (op.fill !== void 0) {
+			const polygons = flattened.map((subpath) => subpath.points).filter((points) => points.length >= 3);
+			mask.reset();
+			mask.fillPolygons(polygons, op.fill.fillRule);
+			this.blendMask(canvas, mask, op.fill.color);
+		}
+		if (op.stroke !== void 0) {
+			const polygons = strokeOutlinePolygons(flattened, op.stroke.widthPx, op.stroke.dashPx);
+			mask.reset();
+			mask.fillPolygons(polygons, "nonzero");
+			this.blendMask(canvas, mask, op.stroke.color);
+		}
+	}
+	imageOp(op) {
+		const { geometry, canvas, mask } = this.requirePage("draw");
+		if (op.format === "jpeg") {
+			this.onDiagnostic?.({
+				code: "raster-cpu/jpeg-image-undecoded",
+				message: "a JPEG (DCTDecode) image placement was not drawn: this backend decodes PNG images only (byte-codec has no DCT decoder), and approximating the scan's pixels would misrender it; the op's bytes remain available to the caller through the port"
+			});
+			return;
+		}
+		const source = this.decodeCached(op.bytes);
+		const quad = quadCorners(op.matrix);
+		mask.reset();
+		mask.fillPolygons([quad], "nonzero");
+		const inverse = invertMatrix(op.matrix);
+		const rowStart = Math.max(0, Math.floor(Math.min(...quad.map((corner) => corner.y))));
+		const rowEnd = Math.min(geometry.heightPx, Math.ceil(Math.max(...quad.map((corner) => corner.y))));
+		const columnStart = Math.max(0, Math.floor(Math.min(...quad.map((corner) => corner.x))));
+		const columnEnd = Math.min(geometry.widthPx, Math.ceil(Math.max(...quad.map((corner) => corner.x))));
+		for (let row = rowStart; row < rowEnd; row++) {
+			const rowBase = row * geometry.widthPx;
+			for (let column = columnStart; column < columnEnd; column++) {
+				const samples = mask.countAt(rowBase + column);
+				if (samples === 0) continue;
+				const [u, v] = inverse(column + .5, row + .5);
+				const [r, g, b, a] = sampleBilinear(source, u, v);
+				this.blendPixel(canvas, rowBase + column, {
+					r,
+					g,
+					b
+				}, samples / 16 * a);
+			}
+		}
+	}
+	decodeCached(bytes) {
+		const key = `${bytes.length}:${crc32(bytes)}`;
+		const cached = this.decodedImages.get(key);
+		if (cached !== void 0) return cached;
+		const decoded = decodePng(bytes);
+		this.decodedImages.set(key, decoded);
+		return decoded;
+	}
+	blendMask(canvas, mask, color) {
+		const colour = colourBytes(color);
+		const pixels = mask.widthPx * mask.heightPx;
+		for (let i = 0; i < pixels; i++) {
+			const samples = mask.countAt(i);
+			if (samples === 0) continue;
+			this.blendPixel(canvas, i, colour, samples / 16);
+		}
+	}
+	blendPixel(canvas, pixelIndex, colour, alpha) {
+		const base = pixelIndex * 3;
+		canvas[base] = Math.round((canvas[base] ?? 0) + (colour.r - (canvas[base] ?? 0)) * alpha);
+		canvas[base + 1] = Math.round((canvas[base + 1] ?? 0) + (colour.g - (canvas[base + 1] ?? 0)) * alpha);
+		canvas[base + 2] = Math.round((canvas[base + 2] ?? 0) + (colour.b - (canvas[base + 2] ?? 0)) * alpha);
+	}
+};
+function colourBytes(color) {
+	return {
+		r: Math.round(color.r * 255),
+		g: Math.round(color.g * 255),
+		b: Math.round(color.b * 255)
+	};
+}
+function pixelOverlap(index, edgeLow, edgeHigh) {
+	return Math.max(0, Math.min(index + 1, edgeHigh) - Math.max(index, edgeLow));
+}
+function quadCorners(matrix) {
+	const [a, b, c, d, e, f] = matrix;
+	const at = (u, v) => ({
+		x: a * u + c * v + e,
+		y: b * u + d * v + f
+	});
+	return [
+		at(0, 0),
+		at(1, 0),
+		at(1, 1),
+		at(0, 1)
+	];
+}
+function invertMatrix(matrix) {
+	const [a, b, c, d, e, f] = matrix;
+	const determinant = a * d - b * c;
+	return (xPx, yPx) => {
+		const dx = xPx - e;
+		const dy = yPx - f;
+		return [(d * dx - c * dy) / determinant, (-b * dx + a * dy) / determinant];
+	};
+}
+function sampleBilinear(source, u, v) {
+	const clampedU = Math.min(Math.max(u, 0), 1);
+	const clampedV = Math.min(Math.max(v, 0), 1);
+	const sx = Math.min(Math.max(clampedU * source.width - .5, 0), source.width - 1);
+	const sy = Math.min(Math.max(clampedV * source.height - .5, 0), source.height - 1);
+	const x0 = Math.floor(sx);
+	const y0 = Math.floor(sy);
+	const x1 = Math.min(x0 + 1, source.width - 1);
+	const y1 = Math.min(y0 + 1, source.height - 1);
+	const fx = sx - x0;
+	const fy = sy - y0;
+	const channelCount = source.channels === 1 ? 1 : 3;
+	const sample = (x, y, channel) => {
+		const index = (y * source.width + x) * channelCount + channel;
+		return source.data[index] ?? 0;
+	};
+	const lerpChannel = (channel) => {
+		const top0 = sample(x0, y0, channel);
+		const top1 = sample(x1, y0, channel);
+		const bottom0 = sample(x0, y1, channel);
+		const bottom1 = sample(x1, y1, channel);
+		const top = top0 + (top1 - top0) * fx;
+		return top + (bottom0 + (bottom1 - bottom0) * fx - top) * fy;
+	};
+	let r;
+	let g;
+	let b;
+	if (channelCount === 1) {
+		r = lerpChannel(0);
+		g = r;
+		b = r;
+	} else {
+		r = lerpChannel(0);
+		g = lerpChannel(1);
+		b = lerpChannel(2);
+	}
+	const alpha = source.alpha;
+	if (alpha === void 0) return [
+		r,
+		g,
+		b,
+		1
+	];
+	const alphaAt = (x, y) => alpha[y * source.width + x] ?? 0;
+	const alphaTop = alphaAt(x0, y0) + (alphaAt(x1, y0) - alphaAt(x0, y0)) * fx;
+	const alphaBottom = alphaAt(x0, y1) + (alphaAt(x1, y1) - alphaAt(x0, y1)) * fx;
+	return [
+		r,
+		g,
+		b,
+		(alphaTop + (alphaBottom - alphaTop) * fy) / 255
+	];
+}
+//#endregion
+export { CpuRasteriser, createCpuRasteriser };