@pallasoft/ps-file-components 1.5.0 → 2.0.1

package/dist/services/ps-scan-edge-service.js

@@ -2,159 +2,95 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PsScanEdgeService = void 0;
 const ps_scan_config_1 = require("../constants/ps-scan-config");
+const ps_scan_canny_service_1 = require("./ps-scan-canny-service");
 const ps_scan_geometry_service_1 = require("./ps-scan-geometry-service");
 const ps_scan_hull_service_1 = require("./ps-scan-hull-service");
 const ps_scan_image_filter_service_1 = require("./ps-scan-image-filter-service");
+const ps_scan_morphology_service_1 = require("./ps-scan-morphology-service");
+const ps_scan_polygon_service_1 = require("./ps-scan-polygon-service");
 const ps_scan_raster_service_1 = require("./ps-scan-raster-service");
+const ps_scan_region_service_1 = require("./ps-scan-region-service");
+const ps_scan_yield_service_1 = require("./ps-scan-yield-service");
 class PsScanEdgeService {
-    static detect(source) {
-        const scale = Math.min(1, ps_scan_config_1.PsScanConfig.detectMaxDimension / Math.max(source.width, source.height));
-        const width = Math.max(8, Math.round(source.width * scale));
-        const height = Math.max(8, Math.round(source.height * scale));
+    static async detect(source, maxDimension) {
+        const scale = Math.min(1, maxDimension / Math.max(source.width, source.height));
+        const width = Math.max(16, Math.round(source.width * scale));
+        const height = Math.max(16, Math.round(source.height * scale));
         const raster = ps_scan_raster_service_1.PsScanRasterService.resize(source, width, height);
         const gray = ps_scan_image_filter_service_1.PsScanImageFilterService.blur(ps_scan_image_filter_service_1.PsScanImageFilterService.grayscale(raster), width, height);
-        const edges = ps_scan_image_filter_service_1.PsScanImageFilterService.sobel(gray, width, height);
-        let mask = PsScanEdgeService.threshold(edges);
-        for (let step = 0; step < ps_scan_config_1.PsScanConfig.detectDilations; step += 1)
-            mask = PsScanEdgeService.dilate(mask, width, height);
-        const foreground = PsScanEdgeService.foreground(mask, width, height);
-        const component = PsScanEdgeService.largestComponent(foreground, width, height);
-        if (component.length < 8)
+        await ps_scan_yield_service_1.PsScanYieldService.next();
+        const edges = ps_scan_canny_service_1.PsScanCannyService.edges(gray, width, height);
+        for (let index = 0; index < width; index += 1) {
+            edges[index] = 1;
+            edges[(height - 1) * width + index] = 1;
+        }
+        for (let index = 0; index < height; index += 1) {
+            edges[index * width] = 1;
+            edges[index * width + width - 1] = 1;
+        }
+        let best = null;
+        let bestArea = 0;
+        for (const radius of ps_scan_config_1.PsScanConfig.closeRadii) {
+            await ps_scan_yield_service_1.PsScanYieldService.next();
+            const closed = ps_scan_morphology_service_1.PsScanMorphologyService.close(edges, width, height, radius);
+            const regions = ps_scan_region_service_1.PsScanRegionService.enclosed(closed, width, height, width * height * ps_scan_config_1.PsScanConfig.detectMinAreaRatio * 0.5);
+            for (const region of regions) {
+                const quad = PsScanEdgeService.candidate(region.boundary, width, height);
+                if (quad === null)
+                    continue;
+                const area = ps_scan_geometry_service_1.PsScanGeometryService.area(quad);
+                if (area > bestArea) {
+                    bestArea = area;
+                    best = quad;
+                }
+            }
+        }
+        if (best === null)
             return null;
-        const hull = ps_scan_hull_service_1.PsScanHullService.convexHull(component);
+        return PsScanEdgeService.normalise(best, width, height);
+    }
+    static async locate(source, maxDimension) {
+        const quad = await PsScanEdgeService.detect(source, maxDimension);
+        return quad === null
+            ? { isDetected: false, quad: ps_scan_geometry_service_1.PsScanGeometryService.defaultQuad() }
+            : { isDetected: true, quad };
+    }
+    static candidate(boundary, width, height) {
+        const points = boundary.map((point) => ({ x: point.x + 0.5, y: point.y + 0.5 }));
+        const hull = ps_scan_hull_service_1.PsScanHullService.convexHull(points);
         if (hull.length < 4)
             return null;
-        const quad = ps_scan_geometry_service_1.PsScanGeometryService.order(ps_scan_hull_service_1.PsScanHullService.bestQuad(hull));
-        const imageArea = width * height;
-        const quadArea = ps_scan_geometry_service_1.PsScanGeometryService.area(quad);
-        const hullArea = ps_scan_geometry_service_1.PsScanGeometryService.area(hull);
-        if (quadArea / imageArea < ps_scan_config_1.PsScanConfig.detectMinAreaRatio)
+        const corners = ps_scan_polygon_service_1.PsScanPolygonService.toQuad(hull);
+        if (corners === null)
+            return null;
+        const ordered = ps_scan_geometry_service_1.PsScanGeometryService.order(corners);
+        const margin = ps_scan_config_1.PsScanConfig.detectBorderMargin;
+        const onBorder = ordered.filter((point) => point.x <= margin ||
+            point.y <= margin ||
+            point.x >= width - margin ||
+            point.y >= height - margin);
+        if (onBorder.length >= 2)
             return null;
-        if (quadArea / imageArea > ps_scan_config_1.PsScanConfig.detectMaxAreaRatio)
+        const quad = ps_scan_geometry_service_1.PsScanGeometryService.expand(ordered, ps_scan_config_1.PsScanConfig.detectExpand);
+        const imageArea = width * height;
+        const area = ps_scan_geometry_service_1.PsScanGeometryService.area(quad);
+        const fill = ps_scan_geometry_service_1.PsScanGeometryService.area(ordered) / ps_scan_geometry_service_1.PsScanGeometryService.area(hull);
+        const ratio = area / imageArea;
+        if (ratio < ps_scan_config_1.PsScanConfig.detectMinAreaRatio || ratio > ps_scan_config_1.PsScanConfig.detectMaxAreaRatio)
             return null;
-        if (hullArea > 0 && quadArea / hullArea < ps_scan_config_1.PsScanConfig.detectMinHullFill)
+        if (fill < ps_scan_config_1.PsScanConfig.detectMinQuadFill)
             return null;
         if (!ps_scan_geometry_service_1.PsScanGeometryService.isConvex(quad))
             return null;
-        return ps_scan_geometry_service_1.PsScanGeometryService.inset(quad, ps_scan_config_1.PsScanConfig.detectInset).map((point) => ({
-            x: Math.min(1, Math.max(0, point.x / (width - 1))),
-            y: Math.min(1, Math.max(0, point.y / (height - 1))),
-        }));
-    }
-    static dilate(mask, width, height) {
-        const out = new Uint8Array(mask.length);
-        for (let y = 0; y < height; y += 1)
-            for (let x = 0; x < width; x += 1) {
-                if (mask[y * width + x] === 0)
-                    continue;
-                for (let dy = -1; dy <= 1; dy += 1)
-                    for (let dx = -1; dx <= 1; dx += 1) {
-                        const nx = x + dx;
-                        const ny = y + dy;
-                        if (nx >= 0 && ny >= 0 && nx < width && ny < height)
-                            out[ny * width + nx] = 1;
-                    }
-            }
-        return out;
-    }
-    static foreground(mask, width, height) {
-        const background = new Uint8Array(mask.length);
-        const stack = [];
-        const seed = (index) => {
-            if (mask[index] === 0 && background[index] === 0) {
-                background[index] = 1;
-                stack.push(index);
-            }
-        };
-        for (let x = 0; x < width; x += 1) {
-            seed(x);
-            seed((height - 1) * width + x);
-        }
-        for (let y = 0; y < height; y += 1) {
-            seed(y * width);
-            seed(y * width + width - 1);
-        }
-        while (stack.length > 0) {
-            const index = stack.pop();
-            if (index === undefined)
-                break;
-            const x = index % width;
-            const y = (index - x) / width;
-            if (x > 0)
-                seed(index - 1);
-            if (x < width - 1)
-                seed(index + 1);
-            if (y > 0)
-                seed(index - width);
-            if (y < height - 1)
-                seed(index + width);
-        }
-        return background.map((value) => 1 - value);
-    }
-    static largestComponent(mask, width, height) {
-        const seen = new Uint8Array(mask.length);
-        let best = [];
-        let bestSize = 0;
-        for (let start = 0; start < mask.length; start += 1) {
-            if (mask[start] === 0 || seen[start] === 1)
-                continue;
-            const members = [];
-            const stack = [start];
-            let size = 0;
-            seen[start] = 1;
-            while (stack.length > 0) {
-                const index = stack.pop();
-                if (index === undefined)
-                    break;
-                const x = index % width;
-                const y = (index - x) / width;
-                let isBoundary = false;
-                size += 1;
-                for (let dy = -1; dy <= 1; dy += 1)
-                    for (let dx = -1; dx <= 1; dx += 1) {
-                        if (dx === 0 && dy === 0)
-                            continue;
-                        const nx = x + dx;
-                        const ny = y + dy;
-                        if (nx < 0 || ny < 0 || nx >= width || ny >= height) {
-                            isBoundary = true;
-                            continue;
-                        }
-                        const next = ny * width + nx;
-                        if (mask[next] === 0)
-                            isBoundary = true;
-                        else if (seen[next] === 0) {
-                            seen[next] = 1;
-                            stack.push(next);
-                        }
-                    }
-                if (isBoundary)
-                    members.push({ x, y });
-            }
-            if (size > bestSize) {
-                bestSize = size;
-                best = members;
-            }
-        }
-        return best;
+        const shortSide = Math.min(width, height) * ps_scan_config_1.PsScanConfig.detectMinSideRatio;
+        const isLongEnough = quad.every((point, index) => ps_scan_geometry_service_1.PsScanGeometryService.distance(point, quad[(index + 1) % quad.length]) >= shortSide);
+        if (!isLongEnough)
+            return null;
+        const isSane = ps_scan_geometry_service_1.PsScanGeometryService.angles(quad).every((angle) => angle >= ps_scan_config_1.PsScanConfig.detectMinAngle && angle <= ps_scan_config_1.PsScanConfig.detectMaxAngle);
+        return isSane ? quad : null;
     }
-    static threshold(edges) {
-        const bins = new Uint32Array(512);
-        edges.forEach((value) => {
-            bins[Math.min(511, value)] += 1;
-        });
-        const target = edges.length * ps_scan_config_1.PsScanConfig.detectPercentile;
-        let cumulative = 0;
-        let high = 0;
-        for (let bin = 0; bin < bins.length; bin += 1) {
-            cumulative += bins[bin];
-            if (cumulative >= target) {
-                high = bin;
-                break;
-            }
-        }
-        const limit = Math.max(ps_scan_config_1.PsScanConfig.detectMinEdgeStrength, high * ps_scan_config_1.PsScanConfig.detectRelativeStrength);
-        return Uint8Array.from(edges, (value) => (value >= limit ? 1 : 0));
+    static normalise(quad, width, height) {
+        return quad.map((point) => ps_scan_geometry_service_1.PsScanGeometryService.clamp({ x: point.x / width, y: point.y / height }));
     }
 }
 exports.PsScanEdgeService = PsScanEdgeService;

package/dist/services/ps-scan-file-name-service.d.ts

@@ -1,6 +1,4 @@
-import { PsScanOutputFormat } from '../constants/ps-scan-output-format';
 export declare class PsScanFileNameService {
-    static build(base: string, format: PsScanOutputFormat, index: number, count: number): string;
-    static mimeType(format: PsScanOutputFormat): string;
+    static build(base: string): string;
     static sanitize(base: string): string;
 }

package/dist/services/ps-scan-file-name-service.js

@@ -2,18 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PsScanFileNameService = void 0;
 const ps_scan_config_1 = require("../constants/ps-scan-config");
-const ps_scan_output_format_1 = require("../constants/ps-scan-output-format");
 class PsScanFileNameService {
-    static build(base, format, index, count) {
-        const stem = PsScanFileNameService.sanitize(base);
-        if (format === ps_scan_output_format_1.PsScanOutputFormat.Pdf)
-            return `${stem}.pdf`;
-        if (count <= 1)
-            return `${stem}.jpg`;
-        return `${stem}-${String(index + 1).padStart(String(count).length, '0')}.jpg`;
-    }
-    static mimeType(format) {
-        return format === ps_scan_output_format_1.PsScanOutputFormat.Pdf ? 'application/pdf' : 'image/jpeg';
+    static build(base) {
+        return `${PsScanFileNameService.sanitize(base)}.jpg`;
     }
     static sanitize(base) {
         const cleaned = Array.from(base)

package/dist/services/ps-scan-geometry-service.d.ts

@@ -2,11 +2,13 @@ import type { PsPageSize } from '../models/ps-page-size';
 import type { PsPoint } from '../models/ps-point';
 import type { PsScanQuad } from '../models/ps-scan-quad';
 export declare class PsScanGeometryService {
+    static angles(quad: PsPoint[]): number[];
     static area(points: PsPoint[]): number;
     static clamp(point: PsPoint): PsPoint;
     static cover(container: PsPageSize, content: PsPageSize): PsPageSize;
     static defaultQuad(): PsScanQuad;
     static distance(from: PsPoint, to: PsPoint): number;
+    static expand(quad: PsScanQuad, distance: number): PsScanQuad;
     static fit(container: PsPageSize, content: PsPageSize): PsPageSize;
     static fitWithin(size: PsPageSize, maxDimension: number): PsPageSize;
     static inset(quad: PsScanQuad, distance: number): PsScanQuad;

package/dist/services/ps-scan-geometry-service.js

@@ -3,6 +3,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PsScanGeometryService = void 0;
 const ps_scan_config_1 = require("../constants/ps-scan-config");
 class PsScanGeometryService {
+    static angles(quad) {
+        return quad.map((point, index) => {
+            const before = quad[(index + quad.length - 1) % quad.length];
+            const after = quad[(index + 1) % quad.length];
+            const ax = before.x - point.x;
+            const ay = before.y - point.y;
+            const bx = after.x - point.x;
+            const by = after.y - point.y;
+            const cosine = (ax * bx + ay * by) / (Math.hypot(ax, ay) * Math.hypot(bx, by));
+            return (Math.acos(Math.min(1, Math.max(-1, cosine))) * 180) / Math.PI;
+        });
+    }
     static area(points) {
         let sum = 0;
         points.forEach((point, index) => {
@@ -32,6 +44,30 @@ class PsScanGeometryService {
     static distance(from, to) {
         return Math.hypot(to.x - from.x, to.y - from.y);
     }
+    static expand(quad, distance) {
+        const lines = quad.map((point, index) => {
+            const next = quad[(index + 1) % quad.length];
+            const length = PsScanGeometryService.distance(point, next);
+            const nx = (next.y - point.y) / length;
+            const ny = -(next.x - point.x) / length;
+            return {
+                dx: next.x - point.x,
+                dy: next.y - point.y,
+                x: point.x + nx * distance,
+                y: point.y + ny * distance,
+            };
+        });
+        return quad.map((point, index) => {
+            const previous = lines[(index + lines.length - 1) % lines.length];
+            const current = lines[index];
+            const denominator = previous.dx * current.dy - previous.dy * current.dx;
+            if (Math.abs(denominator) < 1e-9)
+                return point;
+            const t = ((current.x - previous.x) * current.dy - (current.y - previous.y) * current.dx) /
+                denominator;
+            return { x: previous.x + previous.dx * t, y: previous.y + previous.dy * t };
+        });
+    }
     static fit(container, content) {
         if (container.width <= 0 || container.height <= 0 || content.width <= 0 || content.height <= 0)
             return { height: 0, width: 0 };

package/dist/services/ps-scan-hull-service.d.ts

@@ -1,6 +1,4 @@
 import type { PsPoint } from '../models/ps-point';
 export declare class PsScanHullService {
-    static bestQuad(hull: PsPoint[]): PsPoint[];
     static convexHull(input: PsPoint[]): PsPoint[];
-    private static reduce;
 }

package/dist/services/ps-scan-hull-service.js

@@ -1,28 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PsScanHullService = void 0;
-const ps_scan_config_1 = require("../constants/ps-scan-config");
-const ps_scan_geometry_service_1 = require("./ps-scan-geometry-service");
 class PsScanHullService {
-    static bestQuad(hull) {
-        const points = PsScanHullService.reduce(hull, ps_scan_config_1.PsScanConfig.hullCandidateLimit);
-        if (points.length <= 4)
-            return points;
-        let best = points.slice(0, 4);
-        let bestArea = 0;
-        for (let a = 0; a < points.length - 3; a += 1)
-            for (let b = a + 1; b < points.length - 2; b += 1)
-                for (let c = b + 1; c < points.length - 1; c += 1)
-                    for (let d = c + 1; d < points.length; d += 1) {
-                        const candidate = [points[a], points[b], points[c], points[d]];
-                        const area = ps_scan_geometry_service_1.PsScanGeometryService.area(candidate);
-                        if (area > bestArea) {
-                            bestArea = area;
-                            best = candidate;
-                        }
-                    }
-        return best;
-    }
     static convexHull(input) {
         const points = [...input].sort((a, b) => (a.x === b.x ? a.y - b.y : a.x - b.x));
         if (points.length < 3)
@@ -41,23 +20,5 @@ class PsScanHullService {
         };
         return [...build(points), ...build([...points].reverse())];
     }
-    static reduce(hull, limit) {
-        const points = [...hull];
-        while (points.length > limit) {
-            let weakest = 0;
-            let weakestArea = Infinity;
-            points.forEach((point, index) => {
-                const previous = points[(index - 1 + points.length) % points.length];
-                const next = points[(index + 1) % points.length];
-                const area = ps_scan_geometry_service_1.PsScanGeometryService.area([previous, point, next]);
-                if (area < weakestArea) {
-                    weakestArea = area;
-                    weakest = index;
-                }
-            });
-            points.splice(weakest, 1);
-        }
-        return points;
-    }
 }
 exports.PsScanHullService = PsScanHullService;

package/dist/services/ps-scan-image-filter-service.d.ts

@@ -2,5 +2,4 @@ import type { PsScanRaster } from '../models/ps-scan-raster';
 export declare class PsScanImageFilterService {
     static blur(gray: Uint8ClampedArray, width: number, height: number): Uint8ClampedArray;
     static grayscale(raster: PsScanRaster): Uint8ClampedArray;
-    static sobel(gray: Uint8ClampedArray, width: number, height: number): Uint16Array;
 }

package/dist/services/ps-scan-image-filter-service.js

@@ -31,26 +31,5 @@ class PsScanImageFilterService {
         }
         return out;
     }
-    static sobel(gray, width, height) {
-        const out = new Uint16Array(width * height);
-        for (let y = 1; y < height - 1; y += 1)
-            for (let x = 1; x < width - 1; x += 1) {
-                const i = y * width + x;
-                const gx = -gray[i - width - 1] +
-                    gray[i - width + 1] -
-                    2 * gray[i - 1] +
-                    2 * gray[i + 1] -
-                    gray[i + width - 1] +
-                    gray[i + width + 1];
-                const gy = -gray[i - width - 1] -
-                    2 * gray[i - width] -
-                    gray[i - width + 1] +
-                    gray[i + width - 1] +
-                    2 * gray[i + width] +
-                    gray[i + width + 1];
-                out[i] = Math.hypot(gx, gy) / 4;
-            }
-        return out;
-    }
 }
 exports.PsScanImageFilterService = PsScanImageFilterService;

package/dist/services/ps-scan-morphology-service.d.ts

@@ -0,0 +1,7 @@
+export declare class PsScanMorphologyService {
+    static close(mask: Uint8Array, width: number, height: number, radius: number): Uint8Array;
+    static dilate(mask: Uint8Array, width: number, height: number, radius: number): Uint8Array;
+    static erode(mask: Uint8Array, width: number, height: number, radius: number): Uint8Array;
+    private static horizontal;
+    private static vertical;
+}

package/dist/services/ps-scan-morphology-service.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PsScanMorphologyService = void 0;
+class PsScanMorphologyService {
+    static close(mask, width, height, radius) {
+        return PsScanMorphologyService.erode(PsScanMorphologyService.dilate(mask, width, height, radius), width, height, radius);
+    }
+    static dilate(mask, width, height, radius) {
+        return PsScanMorphologyService.vertical(PsScanMorphologyService.horizontal(mask, width, height, radius, 1), width, height, radius, 1);
+    }
+    static erode(mask, width, height, radius) {
+        return PsScanMorphologyService.vertical(PsScanMorphologyService.horizontal(mask, width, height, radius, 0), width, height, radius, 0);
+    }
+    static horizontal(mask, width, height, radius, target) {
+        const out = new Uint8Array(mask.length);
+        for (let y = 0; y < height; y += 1)
+            for (let x = 0; x < width; x += 1) {
+                const from = Math.max(0, x - radius);
+                const to = Math.min(width - 1, x + radius);
+                let hit = target === 1 ? 0 : 1;
+                for (let at = from; at <= to; at += 1)
+                    if (mask[y * width + at] === target) {
+                        hit = target;
+                        break;
+                    }
+                out[y * width + x] = hit;
+            }
+        return out;
+    }
+    static vertical(mask, width, height, radius, target) {
+        const out = new Uint8Array(mask.length);
+        for (let y = 0; y < height; y += 1) {
+            const from = Math.max(0, y - radius);
+            const to = Math.min(height - 1, y + radius);
+            for (let x = 0; x < width; x += 1) {
+                let hit = target === 1 ? 0 : 1;
+                for (let at = from; at <= to; at += 1)
+                    if (mask[at * width + x] === target) {
+                        hit = target;
+                        break;
+                    }
+                out[y * width + x] = hit;
+            }
+        }
+        return out;
+    }
+}
+exports.PsScanMorphologyService = PsScanMorphologyService;

package/dist/services/ps-scan-pipeline-service.d.ts

@@ -1,10 +1,7 @@
-import type { PsScanPage } from '../models/ps-scan-page';
 import type { PsScanPrepared } from '../models/ps-scan-prepared';
-import type { PsScanRaster } from '../models/ps-scan-raster';
+import type { PsScanQuad } from '../models/ps-scan-quad';
 import type { PsScanRenderedPage } from '../models/ps-scan-rendered-page';
 export declare class PsScanPipelineService {
     static prepare(source: Blob): Promise<PsScanPrepared>;
-    static measure(source: Blob): Promise<PsScanRaster>;
-    static process(page: Pick<PsScanPage, 'corners' | 'filter' | 'rotation'>, raster: PsScanRaster, maxDimension: number): PsScanRaster;
-    static render(page: PsScanPage, maxDimension: number, quality: number): Promise<PsScanRenderedPage>;
+    static render(source: Blob, corners: PsScanQuad, maxDimension: number, quality: number): Promise<PsScanRenderedPage>;
 }

package/dist/services/ps-scan-pipeline-service.js

@@ -4,36 +4,26 @@ exports.PsScanPipelineService = void 0;
 const ps_scan_config_1 = require("../constants/ps-scan-config");
 const ps_scan_canvas_service_1 = require("./ps-scan-canvas-service");
 const ps_scan_edge_service_1 = require("./ps-scan-edge-service");
-const ps_scan_enhance_service_1 = require("./ps-scan-enhance-service");
 const ps_scan_geometry_service_1 = require("./ps-scan-geometry-service");
-const ps_scan_raster_service_1 = require("./ps-scan-raster-service");
 const ps_scan_warp_service_1 = require("./ps-scan-warp-service");
 class PsScanPipelineService {
     static async prepare(source) {
         const decoded = await ps_scan_canvas_service_1.PsScanCanvasService.decode(source, ps_scan_config_1.PsScanConfig.detectMaxDimension * 2);
-        const detected = ps_scan_edge_service_1.PsScanEdgeService.detect(decoded.raster);
+        const located = await ps_scan_edge_service_1.PsScanEdgeService.locate(decoded.raster, ps_scan_config_1.PsScanConfig.detectMaxDimension);
         return {
-            corners: detected === null ? ps_scan_geometry_service_1.PsScanGeometryService.defaultQuad() : detected,
+            corners: located.quad,
             height: decoded.naturalHeight,
-            isDetected: detected !== null,
+            isDetected: located.isDetected,
             width: decoded.naturalWidth,
         };
     }
-    static async measure(source) {
-        const decoded = await ps_scan_canvas_service_1.PsScanCanvasService.decode(source, ps_scan_config_1.PsScanConfig.previewMaxDimension);
-        return decoded.raster;
-    }
-    static process(page, raster, maxDimension) {
-        const size = ps_scan_geometry_service_1.PsScanGeometryService.fitWithin(ps_scan_geometry_service_1.PsScanGeometryService.outputSize(page.corners, raster), maxDimension);
-        const warped = ps_scan_warp_service_1.PsScanWarpService.warp(raster, ps_scan_geometry_service_1.PsScanGeometryService.toPixels(page.corners, {
-            height: raster.height - 1,
-            width: raster.width - 1,
+    static async render(source, corners, maxDimension, quality) {
+        const decoded = await ps_scan_canvas_service_1.PsScanCanvasService.decode(source, Number.MAX_SAFE_INTEGER);
+        const size = ps_scan_geometry_service_1.PsScanGeometryService.fitWithin(ps_scan_geometry_service_1.PsScanGeometryService.outputSize(corners, decoded.raster), maxDimension);
+        const raster = await ps_scan_warp_service_1.PsScanWarpService.warp(decoded.raster, ps_scan_geometry_service_1.PsScanGeometryService.toPixels(corners, {
+            height: decoded.raster.height - 1,
+            width: decoded.raster.width - 1,
         }), size.width, size.height);
-        return ps_scan_raster_service_1.PsScanRasterService.rotate(ps_scan_enhance_service_1.PsScanEnhanceService.apply(warped, page.filter), page.rotation);
-    }
-    static async render(page, maxDimension, quality) {
-        const decoded = await ps_scan_canvas_service_1.PsScanCanvasService.decode(page.source, ps_scan_config_1.PsScanConfig.decodeMaxDimension);
-        const raster = PsScanPipelineService.process(page, decoded.raster, maxDimension);
         return {
             blob: await ps_scan_canvas_service_1.PsScanCanvasService.encode(raster, quality),
             height: raster.height,

package/dist/services/ps-scan-polygon-service.d.ts

@@ -0,0 +1,8 @@
+import type { PsPoint } from '../models/ps-point';
+export declare class PsScanPolygonService {
+    static perimeter(points: PsPoint[]): number;
+    static simplify(points: PsPoint[], epsilon: number): PsPoint[];
+    static toQuad(hull: PsPoint[]): PsPoint[] | null;
+    private static chain;
+    private static lineDistance;
+}

package/dist/services/ps-scan-polygon-service.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PsScanPolygonService = void 0;
+const ps_scan_config_1 = require("../constants/ps-scan-config");
+const ps_scan_geometry_service_1 = require("./ps-scan-geometry-service");
+class PsScanPolygonService {
+    static perimeter(points) {
+        return points.reduce((sum, point, index) => sum + ps_scan_geometry_service_1.PsScanGeometryService.distance(point, points[(index + 1) % points.length]), 0);
+    }
+    static simplify(points, epsilon) {
+        if (points.length < 4)
+            return points;
+        let first = 0;
+        let second = 0;
+        let best = -1;
+        points.forEach((point, index) => {
+            const length = ps_scan_geometry_service_1.PsScanGeometryService.distance(points[0], point);
+            if (length > best) {
+                best = length;
+                second = index;
+            }
+        });
+        best = -1;
+        points.forEach((point, index) => {
+            const length = ps_scan_geometry_service_1.PsScanGeometryService.distance(points[second], point);
+            if (length > best) {
+                best = length;
+                first = index;
+            }
+        });
+        const low = Math.min(first, second);
+        const high = Math.max(first, second);
+        const forward = points.slice(low, high + 1);
+        const backward = [...points.slice(high), ...points.slice(0, low + 1)];
+        const left = PsScanPolygonService.chain(forward, epsilon);
+        const right = PsScanPolygonService.chain(backward, epsilon);
+        return [...left.slice(0, -1), ...right.slice(0, -1)];
+    }
+    static toQuad(hull) {
+        const perimeter = PsScanPolygonService.perimeter(hull);
+        for (const ratio of ps_scan_config_1.PsScanConfig.polygonEpsilons) {
+            const simple = PsScanPolygonService.simplify(hull, ratio * perimeter);
+            if (simple.length === 4)
+                return simple;
+            if (simple.length < 4)
+                return null;
+        }
+        return null;
+    }
+    static chain(points, epsilon) {
+        if (points.length < 3)
+            return points;
+        const start = points[0];
+        const end = points[points.length - 1];
+        let far = 0;
+        let farDistance = -1;
+        for (let index = 1; index < points.length - 1; index += 1) {
+            const length = PsScanPolygonService.lineDistance(points[index], start, end);
+            if (length > farDistance) {
+                farDistance = length;
+                far = index;
+            }
+        }
+        if (farDistance <= epsilon)
+            return [start, end];
+        const left = PsScanPolygonService.chain(points.slice(0, far + 1), epsilon);
+        const right = PsScanPolygonService.chain(points.slice(far), epsilon);
+        return [...left.slice(0, -1), ...right];
+    }
+    static lineDistance(point, from, to) {
+        const dx = to.x - from.x;
+        const dy = to.y - from.y;
+        const length = Math.hypot(dx, dy);
+        if (length === 0)
+            return ps_scan_geometry_service_1.PsScanGeometryService.distance(point, from);
+        return Math.abs(dy * (point.x - from.x) - dx * (point.y - from.y)) / length;
+    }
+}
+exports.PsScanPolygonService = PsScanPolygonService;

package/dist/services/ps-scan-region-service.d.ts

@@ -0,0 +1,4 @@
+import type { PsScanRegion } from '../models/ps-scan-region';
+export declare class PsScanRegionService {
+    static enclosed(mask: Uint8Array, width: number, height: number, minArea: number): PsScanRegion[];
+}