reamkit 1.29.0 → 1.31.0

package/dist/esm/pdf-reader/figures.js

@@ -0,0 +1,433 @@
+//#region src/pdf-reader/figures.ts
+/** No thicker than this, a path is a line. */
+var THIN_PT = 1.5;
+/**
+* A line longer than this many ems RULES the page: the rule over a caption,
+* the line under a heading, a table's border. A drawing's own strokes are
+* shorter, and a long one inside a drawing — a chart's axis — is taken with
+* the drawing it stands in once that is found.
+*/
+var RULE_EM = 3;
+/** How close, in ems, two paths stand to be parts of one drawing. */
+var JOIN_EM = .5;
+/** The fewest paths a figure is drawn with: a box and a frame are not one. */
+var MIN_PATHS = 6;
+/** Past this share of the sheet, a drawing is the page's ground or frame. */
+var MOST_OF_PAGE = .5;
+/** How far across a figure a line of its words may run and still be a label. */
+var LABEL_FILL = .6;
+/** Past this many lines that run across it, what a drawing holds is prose. */
+var PROSE_LINES = 2;
+/**
+* How far apart, in ems of the text, two parts of one figure may stand. The
+* parts of comments.pdf's Figure 6 stand twenty-six points apart at 9pt.
+*/
+var NEAR_EM = 3;
+/** Type smaller than this share of the text's is a drawing's, not the text's. */
+var SMALL_SHARE = .85;
+/** How much larger than the text a figure's words may be set. */
+var LARGEST_LABEL = 1.2;
+/** How far, in its own ems, small type may stand off a drawing and label it. */
+var CAPTION_EM = 2;
+/** What a glyph mapped to no character reads as (see `UNMAPPED` in ./layout). */
+var UNMAPPED = "�";
+/** Where an annotation's appearance stands in the page's painting order. */
+var ANNOTATION_ORDER = Number.MAX_SAFE_INTEGER;
+/**
+* How many ems of its own type a line of words on a drawing may run before it
+* is a line of prose, however wide the drawing: a label is a word or three.
+*/
+var LABEL_EM = 15;
+/** Past this many paths a page is artwork through and through. */
+var MOST_PATHS = 4e3;
+/**
+* The figures a page draws.
+*
+* A figure is paths that stand together — each within half an em of the next —
+* and DRAW something: a curve or a slanted line among them. Straight lines
+* and boxes alone are a ruling, which is a table's or a form's, and a page
+* reads those as text. It has words set on it, or it is only artwork, which
+* the page anchors as it always has; and none of its words run across it
+* line after line, which is prose set on a ground, not a label.
+*
+* @param vectors The page's paths, where the page shows them.
+* @param images  The page's pictures, likewise.
+* @param runs    The page's text, likewise.
+* @param sheet   The page's size.
+* @returns The figures, top of the page first.
+*/
+function pageFigures(vectors, images, runs, sheet) {
+	const words = runs.filter((r) => r.text.replaceAll(UNMAPPED, "").trim().length > 0);
+	const traced = runs.filter((r) => r.type3 !== true && tracedRun(r));
+	if (words.length === 0 || vectors.length === 0 || vectors.length > MOST_PATHS) return [];
+	const size = median(words.map((r) => r.fontSizePt).filter((s) => s > 0)) || 10;
+	const gap = size * JOIN_EM;
+	const pageArea = Math.max(1, sheet.width * sheet.height);
+	const huge = (b) => (b.maxX - b.minX) * (b.maxY - b.minY) > pageArea * MOST_OF_PAGE;
+	const thin = (v) => Math.min(v.maxX - v.minX, v.maxY - v.minY) <= THIN_PT;
+	const rule = (v) => thin(v) && Math.max(v.maxX - v.minX, v.maxY - v.minY) > size * RULE_EM;
+	const lettering = words.filter((r) => r.type3 === true).map(inkOf);
+	const letter = (v) => v.glyph === true || lettering.some((b) => (v.minX + v.maxX) / 2 >= b.minX - 1 && (v.minX + v.maxX) / 2 <= b.maxX + 1 && (v.minY + v.maxY) / 2 >= b.minY - 1 && (v.minY + v.maxY) / 2 <= b.maxY + 1);
+	const own = vectors.filter((v) => v.orderKey[0] !== ANNOTATION_ORDER);
+	const seeds = own.filter((v) => !rule(v) && !huge(v) && !letter(v));
+	const parent = seeds.map((_, k) => k);
+	const find = (k) => {
+		while (parent[k] !== k) {
+			parent[k] = parent[parent[k]];
+			k = parent[k];
+		}
+		return k;
+	};
+	const order = seeds.map((_, k) => k).sort((a, b) => seeds[a].minX - seeds[b].minX);
+	for (let i = 0; i < order.length; i++) {
+		const a = seeds[order[i]];
+		for (let j = i + 1; j < order.length; j++) {
+			const b = seeds[order[j]];
+			if (b.minX > a.maxX + gap) break;
+			if (b.minY <= a.maxY + gap && b.maxY >= a.minY - gap) parent[find(order[i])] = find(order[j]);
+		}
+	}
+	const clusters = /* @__PURE__ */ new Map();
+	seeds.forEach((v, k) => {
+		const root = find(k);
+		const members = clusters.get(root);
+		if (members) members.push(v);
+		else clusters.set(root, [v]);
+	});
+	const found = [];
+	const pieces = [];
+	for (const members of clusters.values()) {
+		const box = boxOf(members);
+		if (huge(box)) continue;
+		if (members.length < MIN_PATHS || !(members.some(draws) || barChart(members))) pieces.push({
+			box,
+			vectors: members
+		});
+		else found.push({
+			box,
+			vectors: members
+		});
+	}
+	if (found.length === 0) return [];
+	const near = size * NEAR_EM;
+	const text = words.filter((r) => r.type3 !== true && r.fontSizePt >= size * SMALL_SHARE);
+	const textBetween = (a, b) => {
+		const both = union(a, b);
+		return text.some((r) => {
+			const ink = inkOf(r);
+			return touches(both, ink, 0) && !touches(a, ink, 0) && !touches(b, ink, 0);
+		});
+	};
+	const rules = own.filter(rule);
+	const taken = /* @__PURE__ */ new Set();
+	let changed = true;
+	while (changed) {
+		changed = false;
+		for (let i = 0; i < found.length; i++) {
+			for (let j = found.length - 1; j > i; j--) {
+				const [a, b] = [found[i].box, found[j].box];
+				if (!touches(a, b, gap) && !(touches(a, b, near) && !textBetween(a, b))) continue;
+				found[i].vectors.push(...found[j].vectors);
+				found[i].box = union(a, b);
+				found.splice(j, 1);
+				changed = true;
+			}
+			for (let j = pieces.length - 1; j >= 0; j--) {
+				const [a, b] = [found[i].box, pieces[j].box];
+				if (!touches(a, b, gap) && !(touches(a, b, near) && !textBetween(a, b))) continue;
+				found[i].vectors.push(...pieces[j].vectors);
+				found[i].box = union(a, b);
+				pieces.splice(j, 1);
+				changed = true;
+			}
+			for (const r of rules) {
+				if (taken.has(r) || !mostlyWithin(r, found[i].box)) continue;
+				taken.add(r);
+				found[i].vectors.push(r);
+				found[i].box = union(found[i].box, r);
+				changed = true;
+			}
+		}
+	}
+	const figures = [];
+	const labelled = /* @__PURE__ */ new Set();
+	const lettered = /* @__PURE__ */ new Set();
+	for (const f of found) {
+		const free = [...words, ...traced].filter((r) => r.type3 !== true && !labelled.has(r));
+		const labels = free.filter((r) => touches(f.box, inkOf(r), 0));
+		let box = labels.reduce((b, r) => union(b, inkOf(r)), f.box);
+		for (let grown = true; grown;) {
+			grown = false;
+			for (const r of free) {
+				if (labels.includes(r) || r.fontSizePt >= size * SMALL_SHARE) continue;
+				const ink = inkOf(r);
+				if (!touches(box, ink, r.fontSizePt * CAPTION_EM) || ink.minX < box.minX - r.fontSizePt) continue;
+				if (ink.maxX > box.maxX + r.fontSizePt) continue;
+				labels.push(r);
+				box = union(box, ink);
+				grown = true;
+			}
+		}
+		if (labels.length === 0 || runsAcross(labels, box, size)) continue;
+		if (labels.some((r) => r.fontSizePt > size * LARGEST_LABEL)) continue;
+		const spaces = runs.filter((r) => r.text.trim().length === 0 && r.text.length > 0 && touches(box, inkOf(r), 0));
+		for (const r of [...labels, ...spaces]) labelled.add(r);
+		const held = images.filter((img) => mostlyInside(img, box));
+		const letters = lettersOf(labels.filter(tracedRun), vectors).filter((v) => !lettered.has(v));
+		for (const v of letters) lettered.add(v);
+		figures.push({
+			...box,
+			vectors: [...f.vectors, ...letters],
+			images: held,
+			labels: [...labels, ...spaces]
+		});
+	}
+	return figures.sort((a, b) => b.maxY - a.maxY);
+}
+/**
+* Whether a run is lettering the file states no character for: glyphs traced
+* as paths (see `PdfVector.glyph`), and a label only by where they stand.
+*
+* @param run A run of the page's text.
+*/
+function tracedRun(run) {
+	return run.text.includes(UNMAPPED) && run.text.replaceAll(UNMAPPED, "").trim() === "";
+}
+/**
+* The glyphs traced for some runs: the paths traced as glyphs whose middles
+* stand in the runs' ink.
+*
+* @param runs  The traced runs.
+* @param paths The page's paths.
+*/
+function lettersOf(runs, paths) {
+	const inks = runs.map(inkOf);
+	return paths.filter((v) => {
+		if (v.glyph !== true) return false;
+		const x = (v.minX + v.maxX) / 2;
+		const y = (v.minY + v.maxY) / 2;
+		return inks.some((b) => x >= b.minX - 1 && x <= b.maxX + 1 && y >= b.minY - 1 && y <= b.maxY + 1);
+	});
+}
+/**
+* A figure's paths with the traced letters painted one after another joined
+* into one: the letters of a label are one shape, where a shape a letter made
+* a chart of six hundred.
+*
+* @param paths The figure's paths, in the order the page painted them.
+* @returns The paths to draw, in that order.
+*/
+function joinLetters(paths) {
+	const out = [];
+	let letters = [];
+	const flush = () => {
+		const [first, ...rest] = letters;
+		if (first !== void 0) out.push(rest.length === 0 ? first : {
+			...first,
+			...boxOf(letters),
+			segs: letters.flatMap((v) => v.segs)
+		});
+		letters = [];
+	};
+	for (const v of paths) {
+		const last = letters[letters.length - 1];
+		if (last !== void 0 && (!v.glyph || last.fillHex !== v.fillHex || last.alpha !== v.alpha)) flush();
+		if (v.glyph === true) letters.push(v);
+		else out.push(v);
+	}
+	flush();
+	return out;
+}
+/** Whether a path draws: a curve, or a line that is neither level nor upright. */
+function draws(v) {
+	let x = 0;
+	let y = 0;
+	for (const s of v.segs) {
+		if (s.op === "cubic") return true;
+		if (s.op === "line" && Math.abs(s.x - x) > THIN_PT && Math.abs(s.y - y) > THIN_PT) return true;
+		if (s.op !== "close") {
+			x = s.x;
+			y = s.y;
+		}
+	}
+	return false;
+}
+/**
+* Whether paths draw a BAR CHART: filled rectangles, six and more, standing on
+* one line and as long as each other's figures make them — the one drawing
+* made of nothing but straight lines and boxes that a ruling is not. A
+* table's shading stands its boxes on one line too, but each as long as the
+* last.
+*
+* comments.pdf sets Figures 10 and 12 so, bars of gradient and of flat grey.
+* With no curve among them they were taken for a ruling: their labels were
+* read as lines of the text, Figure 12 and the column beside it came back as
+* one table, and Figure 10's caption, the first line left on its page, set
+* the page's top margin 352 points down.
+*
+* @param paths The paths of one cluster.
+*/
+function barChart(paths) {
+	const bars = paths.filter((v) => v.fillHex !== void 0 || v.gradient !== void 0).flatMap(rectanglesOf);
+	const standing = (base, length) => {
+		const lengths = /* @__PURE__ */ new Map();
+		for (const b of bars) {
+			const at = Math.round(base(b) / BAR_LINE_PT);
+			const long = length(b);
+			if (long > THIN_PT) lengths.set(at, [...lengths.get(at) ?? [], long]);
+		}
+		return [...lengths.values()].some((all) => all.length >= MIN_PATHS && Math.max(...all) >= Math.min(...all) * BAR_SPREAD);
+	};
+	return standing((b) => b.minY, (b) => b.maxY - b.minY) || standing((b) => b.minX, (b) => b.maxX - b.minX);
+}
+/** How near, in points, bars' feet stand to stand on one line. */
+var BAR_LINE_PT = .5;
+/** How much longer the longest bar of a chart is than the shortest, at the least. */
+var BAR_SPREAD = 2;
+/** The upright rectangles a path is drawn with, one per subpath that is one. */
+function rectanglesOf(v) {
+	const out = [];
+	let corners = [];
+	let curved = false;
+	const close = () => {
+		const xs = new Set(corners.map((c) => Math.round(c.x * 10)));
+		const ys = new Set(corners.map((c) => Math.round(c.y * 10)));
+		if (!curved && corners.length >= 4 && corners.length <= 5 && xs.size === 2 && ys.size === 2) out.push({
+			minX: Math.min(...corners.map((c) => c.x)),
+			maxX: Math.max(...corners.map((c) => c.x)),
+			minY: Math.min(...corners.map((c) => c.y)),
+			maxY: Math.max(...corners.map((c) => c.y))
+		});
+		corners = [];
+		curved = false;
+	};
+	for (const s of v.segs) if (s.op === "move") {
+		close();
+		corners.push({
+			x: s.x,
+			y: s.y
+		});
+	} else if (s.op === "line") corners.push({
+		x: s.x,
+		y: s.y
+	});
+	else if (s.op === "cubic") curved = true;
+	close();
+	return out;
+}
+/**
+* Whether the words on a drawing are prose: lines that run across most of it,
+* more than a caption's worth. A label is short, a paragraph set on a ground
+* fills it.
+*
+* A line is its words as far as the next gap wider than an em. Two boxes side
+* by side put their labels on one baseline — comments.pdf's "Record" and
+* "Enter" a hundred and twenty points apart — and taken as one line they ran
+* across the figure like a line of its text.
+*/
+function runsAcross(labels, box, size) {
+	const byLine = [];
+	for (const r of labels) {
+		const line = byLine.find((l) => Math.abs(l.y - r.y) <= size * .3);
+		if (line) {
+			line.inks.push(inkOf(r));
+			line.em = Math.max(line.em, r.fontSizePt);
+		} else byLine.push({
+			y: r.y,
+			em: r.fontSizePt,
+			inks: [inkOf(r)]
+		});
+	}
+	const width = box.maxX - box.minX;
+	let across = 0;
+	for (const { em, inks } of byLine) {
+		inks.sort((a, b) => a.minX - b.minX);
+		let from = inks[0].minX;
+		let to = inks[0].maxX;
+		for (const ink of [...inks.slice(1), void 0]) {
+			if (ink !== void 0 && ink.minX - to <= size) {
+				to = Math.max(to, ink.maxX);
+				continue;
+			}
+			if (to - from >= Math.min(width * LABEL_FILL, em * LABEL_EM)) across++;
+			if (ink !== void 0) {
+				from = ink.minX;
+				to = ink.maxX;
+			}
+		}
+	}
+	return across >= PROSE_LINES;
+}
+/** The box a run's glyphs stand in: a fifth of the size below the baseline, the rest above. */
+function inkOf(r) {
+	const s = r.fontSizePt;
+	if (Math.abs(r.angleDeg ?? 0) < .5) return {
+		minX: Math.min(r.x, r.endX),
+		minY: r.y - s * .2,
+		maxX: Math.max(r.x, r.endX),
+		maxY: r.y + s * .8
+	};
+	return {
+		minX: Math.min(r.x, r.endX) - s * .8,
+		minY: Math.min(r.y, r.endY) - s * .8,
+		maxX: Math.max(r.x, r.endX) + s * .8,
+		maxY: Math.max(r.y, r.endY) + s * .8
+	};
+}
+function boxOf(members) {
+	return members.reduce(union, { ...members[0] });
+}
+function union(a, b) {
+	return {
+		minX: Math.min(a.minX, b.minX),
+		minY: Math.min(a.minY, b.minY),
+		maxX: Math.max(a.maxX, b.maxX),
+		maxY: Math.max(a.maxY, b.maxY)
+	};
+}
+function touches(a, b, slack) {
+	return b.minX <= a.maxX + slack && b.maxX >= a.minX - slack && b.minY <= a.maxY + slack && b.maxY >= a.minY - slack;
+}
+/**
+* Whether a rule lies along a drawing rather than meeting it: across it within
+* a point, and at least half its length inside it. A table's border that ends
+* where a figure begins is not the figure's.
+*/
+function mostlyWithin(r, box) {
+	const across = r.maxX - r.minX >= r.maxY - r.minY;
+	const [from, to, lo, hi] = across ? [
+		r.minX,
+		r.maxX,
+		box.minX,
+		box.maxX
+	] : [
+		r.minY,
+		r.maxY,
+		box.minY,
+		box.maxY
+	];
+	const [side, sideEnd, sideLo, sideHi] = across ? [
+		r.minY,
+		r.maxY,
+		box.minY,
+		box.maxY
+	] : [
+		r.minX,
+		r.maxX,
+		box.minX,
+		box.maxX
+	];
+	if (sideEnd < sideLo - 1 || side > sideHi + 1) return false;
+	return Math.min(to, hi) - Math.max(from, lo) >= (to - from) / 2;
+}
+/** Whether most of a picture lies inside a box. */
+function mostlyInside(img, box) {
+	return Math.max(0, Math.min(img.x + img.widthPt, box.maxX) - Math.max(img.x, box.minX)) * Math.max(0, Math.min(img.y + img.heightPt, box.maxY) - Math.max(img.y, box.minY)) > img.widthPt * img.heightPt / 2;
+}
+function median(values) {
+	if (values.length === 0) return 0;
+	const sorted = [...values].sort((a, b) => a - b);
+	return sorted[Math.floor(sorted.length / 2)];
+}
+//#endregion
+export { joinLetters, pageFigures, tracedRun };