@stabrise/scaledp 0.1.0 → 0.1.1

package/dist/{ocr-OHX2WM3e.js → ocr-Dkkbk0Wl.js}

@@ -1,11 +1,11 @@
 import { h as getConfig, i as Stage, s as DetectionError, u as OcrError } from "./pipeline-DACqGkpN.js";
-import { A as polygonArea, D as boxPoints, S as isRotated, _ as boxFromBBox, a as cropBox, c as encodeImage, i as createCanvas, j as polygonPerimeter, k as minAreaRect, l as imageDataToCanvas, m as toNchwFloat32, n as IMAGENET_STD, o as cropGeometry, p as toImageData, r as context2d, s as decodeImage, t as IMAGENET_MEAN, u as letterbox, v as boxFromPolygon, w as mergeOverlappingBoxes } from "./image-CAH2rLv9.js";
+import { A as minAreaRect, C as isRotated, M as polygonPerimeter, O as boxPoints, T as mergeOverlappingBoxes, a as cropBox, c as encodeImage, f as resize, h as toNchwFloat32, i as createCanvas, j as polygonArea, l as imageDataToCanvas, m as toImageData, n as IMAGENET_STD, o as cropGeometry, p as rotate180, r as context2d, s as decodeImage, t as IMAGENET_MEAN, u as letterbox, v as boxFromBBox, y as boxFromPolygon } from "./image-DRBsbv7G.js";
 import { a as isCached, n as ensureModelFiles, r as evict } from "./model-cache-BEaqqRZ9.js";
 import { i as resolveParams, t as BASE_STAGE_DEFAULTS } from "./params-DapwK9Ns.js";
 import { n as boxesToText, t as boxesToFormattedText } from "./text-ahMLpxN9.js";
 import { t as createDetectorOutput } from "./detector-output-lyF1Mqb8.js";
 import { n as createDocument, t as createImage } from "./image-DoZDJkcR.js";
-import { i as loadOrt, t as createSession } from "./ort-CXDoPrtw.js";
+import { i as loadOrt, t as createSession } from "./ort-DZEG14nY.js";
 //#region src/ocr/db-postprocess.ts
 /**
 * Differentiable Binarization post-processing.
@@ -484,7 +484,7 @@ const LINE_ORIENTATION_DEFAULTS = Object.freeze({
 	padding: 2,
 	imageType: "png"
 });
-function boxesOf$1(source) {
+function boxesOf$2(source) {
 	if (typeof source !== "object" || source === null) return [];
 	return source.bboxes ?? [];
 }
@@ -508,7 +508,7 @@ var LineOrientationDetector = class extends Stage {
 		if (!image || !(image.data instanceof Uint8Array) || image.data.byteLength === 0) throw new DetectionError("Expected an Image with decoded bytes", this.name);
 		await this.init();
 		const classifier = this.classifier;
-		const boxes = boxesOf$1(row[boxCol]);
+		const boxes = boxesOf$2(row[boxCol]);
 		const bitmap = await decodeImage(image.data);
 		try {
 			const canvas = createCanvas(bitmap.width, bitmap.height);
@@ -698,6 +698,10 @@ const DEFAULT_OCR_PRESET = "v6-small";
 function isKnownPreset(value) {
 	return PADDLE_OCR_PRESETS.some((p) => p.value === value);
 }
+/** Shared by every Paddle stage, so an unknown preset fails at construction. */
+function validatePreset(value) {
+	if (!isKnownPreset(value)) throw new RangeError(`Unknown OCR preset "${value}". See PADDLE_OCR_PRESETS for valid values.`);
+}
 /** Presets able to read a script name as reported by OSD script detection. */
 function presetsForScript(script) {
 	return PADDLE_OCR_PRESETS.filter((p) => p.scripts.includes(script));
@@ -711,6 +715,13 @@ function presetsForScript(script) {
 * ArrayBuffers, rather than letting ppu-paddle-ocr fetch them itself. Its
 * browser build re-downloads ~6 MB on every page load, relying only on the HTTP
 * cache; routing through IndexedDB makes a repeat visit instant and offline-safe.
+*
+* Two entry points, because the two halves of a preset are separable:
+* `getPaddleService` builds the full detect-then-read service, while
+* `getPaddleRecognizer` loads only the recognition model and its dictionary --
+* what `PaddleRecognizer` needs when some other detector already found the
+* boxes. Both key their cache on the same repo, so a pipeline using both pays
+* for each file once.
 */
 let modulePromise = null;
 async function loadPpu() {
@@ -780,6 +791,77 @@ async function getPaddleService(preset = DEFAULT_OCR_PRESET) {
 	services.set(preset, promise);
 	return promise;
 }
+/**
+* The recognition ONNX session and its character dictionary, per preset.
+*
+* Deliberately separate from `services`: a recognizer running behind someone
+* else's detector never needs the detection model, and skipping it saves a
+* download of a few MB. The cache `repo` is the same either way, so the two
+* files are shared with the full service rather than stored twice.
+*/
+const recognitionAssets = /* @__PURE__ */ new Map();
+/**
+* Split a PaddleOCR dictionary into an ordered array, one entry per line.
+*
+* ppu exports `parseDictionary` from a module its `exports` map does not
+* publish, so this reproduces it -- and it is the whole of it. Blank entries
+* are preserved: the index is the class id the model emits, so dropping one
+* would shift every character after it.
+*/
+function parseDictionary(source) {
+	return new TextDecoder("utf-8").decode(source).split(/\r?\n/);
+}
+async function loadRecognitionAssets(preset) {
+	const existing = recognitionAssets.get(preset);
+	if (existing) return existing;
+	const promise = (async () => {
+		await loadPpu();
+		const { spec, roles } = await specForPreset(preset);
+		const wanted = ["recognition", "charactersDictionary"].map((role) => spec.files[roles.indexOf(role)]?.path ?? "");
+		const files = await ensureModelFiles({
+			...spec,
+			files: wanted.map((path) => ({ path }))
+		});
+		const model = files[wanted[0]];
+		const dict = files[wanted[1]];
+		if (!model || !dict) throw new Error(`PaddleOCR preset "${preset}" is missing its recognition model or dictionary.`);
+		const dictionary = parseDictionary(dict);
+		if (dictionary.length === 0) throw new Error(`PaddleOCR preset "${preset}" has an empty character dictionary.`);
+		return {
+			session: await createSession(model, { fallbackToWasm: true }),
+			dictionary
+		};
+	})();
+	promise.catch(() => recognitionAssets.delete(preset));
+	recognitionAssets.set(preset, promise);
+	return promise;
+}
+/**
+* Recognition only: read the regions you hand it, no detection.
+*
+* `minimumConfidence` is pinned to 0 and `maxCropSourceSideLength` is set past
+* any canvas we pass. ppu would otherwise silently drop low-scoring results --
+* breaking the caller's box-to-result mapping, since `run` also sorts what it
+* returns into reading order -- and downscale a tall batch of stacked crops.
+* Filtering is the calling stage's job, where the threshold is a parameter.
+*/
+async function getPaddleRecognizer(preset = DEFAULT_OCR_PRESET, options = {}) {
+	const ppu = await loadPpu();
+	const { session, dictionary } = await loadRecognitionAssets(preset);
+	return new ppu.RecognitionService(session, {
+		charactersDictionary: dictionary,
+		minimumConfidence: 0,
+		maxCropSourceSideLength: Number.MAX_SAFE_INTEGER,
+		...options.recBatchSize === void 0 ? {} : { recBatchSize: options.recBatchSize },
+		...options.spaceRecovery === void 0 ? {} : { spaceRecovery: options.spaceRecovery }
+	});
+}
+async function releaseRecognition(preset) {
+	const pending = recognitionAssets.get(preset);
+	if (!pending) return;
+	recognitionAssets.delete(preset);
+	await pending.then(({ session }) => session.release()).catch(() => void 0);
+}
 async function isPresetCached(preset) {
 	const { spec } = await specForPreset(preset);
 	return isCached(spec);
@@ -793,13 +875,15 @@ async function removePreset(preset) {
 	const service = services.get(preset);
 	services.delete(preset);
 	await service?.then((s) => s.destroy()).catch(() => void 0);
+	await releaseRecognition(preset);
 	await evict(spec);
 }
-/** Tear down every cached service. */
+/** Tear down every cached service, recognition-only sessions included. */
 async function disposePaddleServices() {
 	const pending = [...services.values()];
 	services.clear();
-	await Promise.all(pending.map((p) => p.then((s) => s.destroy()).catch(() => void 0)));
+	const recognition = [...recognitionAssets.keys()];
+	await Promise.all([...pending.map((p) => p.then((s) => s.destroy()).catch(() => void 0)), ...recognition.map((preset) => releaseRecognition(preset))]);
 }
 //#endregion
 //#region src/ocr/paddle.ts
@@ -810,7 +894,7 @@ async function disposePaddleServices() {
 * `PaddleTextRecognizer` mirrors its OCR stages (image -> Document with text
 * and boxes). Both run PP-OCR models through ppu-paddle-ocr on onnxruntime-web.
 */
-const PADDLE_DETECTOR_DEFAULTS = Object.freeze({
+const PADDLE_TEXT_DETECTOR_DEFAULTS = Object.freeze({
 	...BASE_STAGE_DEFAULTS,
 	inputCol: "image",
 	outputCol: "boxes",
@@ -818,9 +902,6 @@ const PADDLE_DETECTOR_DEFAULTS = Object.freeze({
 	preset: DEFAULT_OCR_PRESET,
 	scoreThreshold: 0
 });
-function validatePreset(value) {
-	if (!isKnownPreset(value)) throw new RangeError(`Unknown OCR preset "${value}". See PADDLE_OCR_PRESETS for valid values.`);
-}
 /** Decode a stage input into something ppu-paddle-ocr accepts. */
 async function toCanvas(input) {
 	if (typeof OffscreenCanvas !== "undefined" && input instanceof OffscreenCanvas) return input;
@@ -843,7 +924,7 @@ async function toCanvas(input) {
 var PaddleTextDetector = class extends Stage {
 	name = "PaddleTextDetector";
 	constructor(options = {}) {
-		super(resolveParams(PADDLE_DETECTOR_DEFAULTS, options, { preset: validatePreset }));
+		super(resolveParams(PADDLE_TEXT_DETECTOR_DEFAULTS, options, { preset: validatePreset }));
 	}
 	async init() {
 		await getPaddleService(this.params.preset);
@@ -871,7 +952,7 @@ var PaddleTextDetector = class extends Stage {
 		});
 	}
 };
-const PADDLE_RECOGNIZER_DEFAULTS = Object.freeze({
+const PADDLE_TEXT_RECOGNIZER_DEFAULTS = Object.freeze({
 	...BASE_STAGE_DEFAULTS,
 	inputCol: "image",
 	outputCol: "text",
@@ -886,7 +967,7 @@ const PADDLE_RECOGNIZER_DEFAULTS = Object.freeze({
 var PaddleTextRecognizer = class extends Stage {
 	name = "PaddleTextRecognizer";
 	constructor(options = {}) {
-		super(resolveParams(PADDLE_RECOGNIZER_DEFAULTS, options, { preset: validatePreset }));
+		super(resolveParams(PADDLE_TEXT_RECOGNIZER_DEFAULTS, options, { preset: validatePreset }));
 	}
 	async init() {
 		await getPaddleService(this.params.preset);
@@ -925,6 +1006,192 @@ var PaddleTextRecognizer = class extends Stage {
 	}
 };
 //#endregion
+//#region src/ocr/paddle-recognizer.ts
+/**
+* Read the boxes a detector already found, with a PaddleOCR preset.
+*
+* The Paddle counterpart to `TesseractRecognizer`, and for the same reason:
+* `PaddleTextRecognizer` detects and recognises in a single pass over the page,
+* so boxes produced by a *separate* detector never reach it. This stage takes
+* those boxes, straightens each one, and reads it -- which is what lets DBNet or
+* YOLO feed PaddleOCR recognition, rotated regions included.
+*
+* There is no `strategy` parameter. ppu's 'per-line' and 'cross-line' merge
+* boxes before reading them; the contract here is one result per box handed in,
+* which only 'per-box' can honour.
+*/
+const PADDLE_RECOGNIZER_DEFAULTS = Object.freeze({
+	...BASE_STAGE_DEFAULTS,
+	inputCol: "image",
+	inputCols: ["image", "boxes"],
+	outputCol: "text",
+	keepInputData: true,
+	preset: DEFAULT_OCR_PRESET,
+	scaleFactor: 1,
+	padding: 5,
+	scoreThreshold: .5,
+	keepFormatting: false,
+	lineTolerance: 0,
+	detectLineOrientation: false,
+	onlyRotated: false,
+	oriModel: DEFAULT_ORIENTATION_MODEL,
+	spaceRecovery: false,
+	recBatchSize: 6
+});
+/**
+* Tallest sheet crops are stacked onto.
+*
+* Well under every browser's canvas ceiling, and low enough that a sheet stays
+* cheap to allocate. A single crop taller than this gets a sheet to itself.
+*/
+const MAX_SHEET_HEIGHT = 8192;
+function boxesOf$1(source) {
+	if (typeof source !== "object" || source === null) return [];
+	return source.bboxes ?? [];
+}
+var PaddleRecognizer = class extends Stage {
+	name = "PaddleRecognizer";
+	orientation = null;
+	recognition = null;
+	constructor(options = {}) {
+		super(resolveParams(PADDLE_RECOGNIZER_DEFAULTS, options, {
+			inputCols: (value) => {
+				if (value.length !== 2) throw new RangeError("inputCols must be [imageColumn, boxColumn]");
+			},
+			preset: validatePreset
+		}));
+	}
+	async init() {
+		const { preset, recBatchSize, spaceRecovery, detectLineOrientation, oriModel } = this.params;
+		this.recognition ??= await getPaddleRecognizer(preset, {
+			recBatchSize,
+			spaceRecovery
+		});
+		if (detectLineOrientation) this.orientation ??= new LineOrientationClassifier(oriModel);
+	}
+	async apply(_input, row, ctx) {
+		const { inputCols, scaleFactor, padding, scoreThreshold, keepFormatting, lineTolerance, detectLineOrientation, onlyRotated } = this.params;
+		const [imageCol, boxCol] = inputCols;
+		const image = row[imageCol];
+		if (image?.exception) throw new OcrError(`Upstream stage failed: ${image.exception}`, this.name);
+		if (!image || !(image.data instanceof Uint8Array) || image.data.byteLength === 0) throw new OcrError("Expected an Image with decoded bytes", this.name);
+		const source = row[boxCol];
+		if (source === void 0) throw new OcrError(`No boxes in column "${boxCol}". This stage reads a detector's output; run a text detector before it.`, this.name);
+		await this.init();
+		const recognition = this.recognition;
+		const bitmap = await decodeImage(image.data);
+		const canvas = scaleFactor === 1 ? bitmap : resize(bitmap, scaleFactor);
+		const kept = [];
+		const crops = [];
+		try {
+			for (const box of boxesOf$1(source)) {
+				ctx.signal?.throwIfAborted();
+				let crop = cropBox(canvas, box, {
+					scaleFactor,
+					padding
+				});
+				let inverted = false;
+				if (detectLineOrientation && this.orientation) {
+					inverted = await this.orientation.classify(crop) === "180_degree";
+					if (inverted) crop = rotate180(crop);
+				}
+				if (onlyRotated && !isRotated(box) && !inverted) continue;
+				kept.push(box);
+				crops.push(crop);
+			}
+		} finally {
+			bitmap.close();
+		}
+		const read = await recognizeCrops(recognition, crops, ctx);
+		const bboxes = [];
+		for (const [i, box] of kept.entries()) {
+			const result = read[i];
+			if (!result?.text) continue;
+			if (result.score < scoreThreshold) continue;
+			bboxes.push({
+				...box,
+				text: result.text,
+				score: result.score
+			});
+		}
+		return createDocument({
+			path: String(row[this.params.pathCol] ?? image.path),
+			type: "paddle-recognizer",
+			text: keepFormatting ? boxesToFormattedText(bboxes, lineTolerance) : boxesToText(bboxes),
+			bboxes
+		});
+	}
+	onError(message, row) {
+		return createDocument({
+			path: String(row[this.params.pathCol] ?? "memory"),
+			type: "paddle-recognizer",
+			exception: message
+		});
+	}
+	async dispose() {
+		await this.orientation?.dispose();
+		this.orientation = null;
+		this.recognition = null;
+	}
+};
+/**
+* Read every crop, batching across them.
+*
+* ppu batches `recBatchSize` crops into a single inference, but only within one
+* `run()` call, and `run()` cuts its crops out of the one canvas it is given. So
+* the crops are stacked onto sheet canvases -- each at x 0, one below the last --
+* and handed back as the boxes to read. ppu re-crops exactly those rects, so the
+* unused width beside a narrow crop is never sampled. Calling `run()` once per
+* box would instead pay one inference, and one main-thread yield, per line.
+*
+* Results come back index-aligned to `crops`; a crop ppu rejected or did not
+* return is left `undefined`. `run()` sorts what it returns into reading order,
+* so results are matched on the slot's y offset, never on array position.
+*/
+async function recognizeCrops(recognition, crops, ctx) {
+	const out = new Array(crops.length);
+	for (let start = 0; start < crops.length;) {
+		ctx.signal?.throwIfAborted();
+		let end = start;
+		let height = 0;
+		let width = 0;
+		while (end < crops.length) {
+			const crop = crops[end];
+			if (end > start && height + crop.height > MAX_SHEET_HEIGHT) break;
+			height += crop.height;
+			width = Math.max(width, crop.width);
+			end++;
+		}
+		const sheet = createCanvas(width, height);
+		const sheetCtx = context2d(sheet);
+		const slots = [];
+		const atOffset = /* @__PURE__ */ new Map();
+		let offset = 0;
+		for (let i = start; i < end; i++) {
+			const crop = crops[i];
+			sheetCtx.drawImage(crop, 0, offset);
+			slots.push({
+				x: 0,
+				y: offset,
+				width: crop.width,
+				height: crop.height
+			});
+			atOffset.set(offset, i);
+			offset += crop.height;
+		}
+		const results = await recognition.run(sheet, slots, void 0, "per-box");
+		for (const result of results) {
+			const index = atOffset.get(result.box.y);
+			if (index !== void 0) out[index] = {
+				text: result.text.trim(),
+				score: result.confidence
+			};
+		}
+		start = end;
+	}
+	return out;
+}
+//#endregion
 //#region src/ocr/script-detect.ts
 /**
 * Writing-script detection via Tesseract's OSD model.
@@ -1278,17 +1545,7 @@ function wordBox(rect, geometry, inverted, scaleFactor, text, score) {
 		score
 	});
 }
-/** Turn a crop 180 degrees, so an inverted line reads the right way up. */
-function rotate180(source) {
-	const out = new OffscreenCanvas(source.width, source.height);
-	const ctx = out.getContext("2d");
-	if (!ctx) throw new OcrError("Failed to acquire a 2D context", "TesseractRecognizer");
-	ctx.translate(source.width / 2, source.height / 2);
-	ctx.rotate(Math.PI);
-	ctx.drawImage(source, -source.width / 2, -source.height / 2);
-	return out;
-}
 //#endregion
-export { getDetectorModel as A, quadsFromProbabilityMap as B, LINE_ORIENTATION_DEFAULTS as C, ORIENTATION_INPUT as D, LineOrientationClassifier as E, DB_POSTPROCESS_DEFAULTS as F, boxScore as I, findComponentBoundaries as L, DBNET_INPUT_SIZE as M, DEFAULT_DBNET_MODEL as N, DEFAULT_DETECTOR_ID as O, DbnetOnnxDetector as P, miniBox as R, presetsForScript as S, DEFAULT_ORIENTATION_MODEL as T, unclipRect as V, loadPreset as _, TesseractOcr as a, PADDLE_OCR_PRESETS as b, disposeScriptDetection as c, PADDLE_RECOGNIZER_DEFAULTS as d, PaddleTextDetector as f, isPresetCached as g, getPaddleService as h, TESSERACT_OCR_DEFAULTS as i, DBNET_DETECTOR_DEFAULTS as j, DETECTOR_MODELS as k, suggestPresets as l, disposePaddleServices as m, TesseractRecognizer as n, disposeTesseract as o, PaddleTextRecognizer as p, DEFAULT_TESSDATA_URL as r, detectScript as s, TESSERACT_RECOGNIZER_DEFAULTS as t, PADDLE_DETECTOR_DEFAULTS as u, removePreset as v, LineOrientationDetector as w, isKnownPreset as x, DEFAULT_OCR_PRESET as y, orderPointsClockwise as z };
+export { LineOrientationClassifier as A, boxScore as B, PADDLE_OCR_PRESETS as C, LINE_ORIENTATION_DEFAULTS as D, validatePreset as E, DBNET_DETECTOR_DEFAULTS as F, unclipRect as G, miniBox as H, DBNET_INPUT_SIZE as I, DEFAULT_DBNET_MODEL as L, DEFAULT_DETECTOR_ID as M, DETECTOR_MODELS as N, LineOrientationDetector as O, getDetectorModel as P, DbnetOnnxDetector as R, DEFAULT_OCR_PRESET as S, presetsForScript as T, orderPointsClockwise as U, findComponentBoundaries as V, quadsFromProbabilityMap as W, getPaddleRecognizer as _, TesseractOcr as a, loadPreset as b, disposeScriptDetection as c, PaddleRecognizer as d, PADDLE_TEXT_DETECTOR_DEFAULTS as f, disposePaddleServices as g, PaddleTextRecognizer as h, TESSERACT_OCR_DEFAULTS as i, ORIENTATION_INPUT as j, DEFAULT_ORIENTATION_MODEL as k, suggestPresets as l, PaddleTextDetector as m, TesseractRecognizer as n, disposeTesseract as o, PADDLE_TEXT_RECOGNIZER_DEFAULTS as p, DEFAULT_TESSDATA_URL as r, detectScript as s, TESSERACT_RECOGNIZER_DEFAULTS as t, PADDLE_RECOGNIZER_DEFAULTS as u, getPaddleService as v, isKnownPreset as w, removePreset as x, isPresetCached as y, DB_POSTPROCESS_DEFAULTS as z };
 
-//# sourceMappingURL=ocr-OHX2WM3e.js.map
+//# sourceMappingURL=ocr-Dkkbk0Wl.js.map