@pallasoft/ps-file-components 1.2.4 → 1.4.0

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

@@ -0,0 +1,9 @@
+import type { PsScanQuad } from '../models/ps-scan-quad';
+import type { PsScanRaster } from '../models/ps-scan-raster';
+export declare class PsScanEdgeService {
+    static detect(source: PsScanRaster): PsScanQuad | null;
+    private static dilate;
+    private static foreground;
+    private static largestComponent;
+    private static threshold;
+}

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

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PsScanEdgeService = void 0;
+const ps_scan_config_1 = require("../constants/ps-scan-config");
+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_raster_service_1 = require("./ps-scan-raster-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));
+        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)
+            return null;
+        const hull = ps_scan_hull_service_1.PsScanHullService.convexHull(component);
+        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)
+            return null;
+        if (quadArea / imageArea > ps_scan_config_1.PsScanConfig.detectMaxAreaRatio)
+            return null;
+        if (hullArea > 0 && quadArea / hullArea < ps_scan_config_1.PsScanConfig.detectMinHullFill)
+            return null;
+        if (!ps_scan_geometry_service_1.PsScanGeometryService.isConvex(quad))
+            return null;
+        return quad.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;
+    }
+    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));
+    }
+}
+exports.PsScanEdgeService = PsScanEdgeService;

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

@@ -0,0 +1,9 @@
+import { PsScanFilter } from '../constants/ps-scan-filter';
+import type { PsScanRaster } from '../models/ps-scan-raster';
+export declare class PsScanEnhanceService {
+    static apply(source: PsScanRaster, filter: PsScanFilter): PsScanRaster;
+    private static colour;
+    private static document;
+    private static greyscale;
+    private static levels;
+}

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

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PsScanEnhanceService = void 0;
+const ps_scan_config_1 = require("../constants/ps-scan-config");
+const ps_scan_filter_1 = require("../constants/ps-scan-filter");
+const ps_scan_image_filter_service_1 = require("./ps-scan-image-filter-service");
+const ps_scan_raster_service_1 = require("./ps-scan-raster-service");
+class PsScanEnhanceService {
+    static apply(source, filter) {
+        if (filter === ps_scan_filter_1.PsScanFilter.Original)
+            return source;
+        if (filter === ps_scan_filter_1.PsScanFilter.Colour)
+            return PsScanEnhanceService.colour(source);
+        if (filter === ps_scan_filter_1.PsScanFilter.Greyscale)
+            return PsScanEnhanceService.greyscale(source);
+        return PsScanEnhanceService.document(source);
+    }
+    static colour(source) {
+        const gray = ps_scan_image_filter_service_1.PsScanImageFilterService.grayscale(source);
+        const { black, white } = PsScanEnhanceService.levels(gray);
+        const gain = 255 / Math.max(1, white - black);
+        const target = ps_scan_raster_service_1.PsScanRasterService.create(source.width, source.height);
+        for (let at = 0; at < source.data.length; at += 4) {
+            target.data[at] = (source.data[at] - black) * gain;
+            target.data[at + 1] = (source.data[at + 1] - black) * gain;
+            target.data[at + 2] = (source.data[at + 2] - black) * gain;
+            target.data[at + 3] = 255;
+        }
+        return target;
+    }
+    static document(source) {
+        const { height, width } = source;
+        const gray = ps_scan_image_filter_service_1.PsScanImageFilterService.grayscale(source);
+        const integral = new Float64Array((width + 1) * (height + 1));
+        for (let y = 0; y < height; y += 1) {
+            let row = 0;
+            for (let x = 0; x < width; x += 1) {
+                row += gray[y * width + x];
+                integral[(y + 1) * (width + 1) + x + 1] = integral[y * (width + 1) + x + 1] + row;
+            }
+        }
+        const half = Math.max(ps_scan_config_1.PsScanConfig.adaptiveWindowMin, Math.floor(Math.min(width, height) / ps_scan_config_1.PsScanConfig.adaptiveWindowDivisor)) >> 1;
+        const target = ps_scan_raster_service_1.PsScanRasterService.create(width, height);
+        for (let y = 0; y < height; y += 1) {
+            const y0 = Math.max(0, y - half);
+            const y1 = Math.min(height, y + half + 1);
+            for (let x = 0; x < width; x += 1) {
+                const x0 = Math.max(0, x - half);
+                const x1 = Math.min(width, x + half + 1);
+                const sum = integral[y1 * (width + 1) + x1] -
+                    integral[y0 * (width + 1) + x1] -
+                    integral[y1 * (width + 1) + x0] +
+                    integral[y0 * (width + 1) + x0];
+                const mean = sum / ((x1 - x0) * (y1 - y0));
+                const value = gray[y * width + x] < mean * ps_scan_config_1.PsScanConfig.adaptiveRatio ? 0 : 255;
+                const at = (y * width + x) * 4;
+                target.data[at] = value;
+                target.data[at + 1] = value;
+                target.data[at + 2] = value;
+                target.data[at + 3] = 255;
+            }
+        }
+        return target;
+    }
+    static greyscale(source) {
+        const gray = ps_scan_image_filter_service_1.PsScanImageFilterService.grayscale(source);
+        const { black, white } = PsScanEnhanceService.levels(gray);
+        const gain = 255 / Math.max(1, white - black);
+        const target = ps_scan_raster_service_1.PsScanRasterService.create(source.width, source.height);
+        for (let index = 0; index < gray.length; index += 1) {
+            const value = (gray[index] - black) * gain;
+            const at = index * 4;
+            target.data[at] = value;
+            target.data[at + 1] = value;
+            target.data[at + 2] = value;
+            target.data[at + 3] = 255;
+        }
+        return target;
+    }
+    static levels(gray) {
+        const bins = new Uint32Array(256);
+        gray.forEach((value) => {
+            bins[value] += 1;
+        });
+        const find = (fraction) => {
+            const target = gray.length * fraction;
+            let cumulative = 0;
+            for (let bin = 0; bin < 256; bin += 1) {
+                cumulative += bins[bin];
+                if (cumulative >= target)
+                    return bin;
+            }
+            return 255;
+        };
+        return {
+            black: find(ps_scan_config_1.PsScanConfig.levelLowPercentile),
+            white: find(ps_scan_config_1.PsScanConfig.levelHighPercentile),
+        };
+    }
+}
+exports.PsScanEnhanceService = PsScanEnhanceService;

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

@@ -0,0 +1,6 @@
+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 sanitize(base: string): string;
+}

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

@@ -0,0 +1,29 @@
+"use strict";
+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 sanitize(base) {
+        const cleaned = Array.from(base)
+            .filter((char) => char.charCodeAt(0) >= 32)
+            .join('')
+            .replace(/\.(pdf|jpe?g)$/i, '')
+            .replace(/[\\/:*?"<>|]+/g, '-')
+            .replace(/\s+/g, ' ')
+            .replace(/^[\s.-]+|[\s.-]+$/g, '');
+        return cleaned.length === 0 ? ps_scan_config_1.PsScanConfig.defaultFileName : cleaned.slice(0, 80);
+    }
+}
+exports.PsScanFileNameService = PsScanFileNameService;

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

@@ -0,0 +1,18 @@
+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 area(points: PsPoint[]): number;
+    static clamp(point: PsPoint): PsPoint;
+    static defaultQuad(): PsScanQuad;
+    static distance(from: PsPoint, to: PsPoint): number;
+    static fit(container: PsPageSize, content: PsPageSize): PsPageSize;
+    static fitWithin(size: PsPageSize, maxDimension: number): PsPageSize;
+    static isConvex(points: PsPoint[]): boolean;
+    static isUsable(quad: PsScanQuad): boolean;
+    static nudge(quad: PsScanQuad, index: number, dx: number, dy: number): PsScanQuad;
+    static order(points: PsPoint[]): PsScanQuad;
+    static outputSize(quad: PsScanQuad, raster: PsPageSize): PsPageSize;
+    static rotateSize(size: PsPageSize, rotation: number): PsPageSize;
+    static toPixels(quad: PsScanQuad, size: PsPageSize): PsScanQuad;
+}

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

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PsScanGeometryService = void 0;
+const ps_scan_config_1 = require("../constants/ps-scan-config");
+class PsScanGeometryService {
+    static area(points) {
+        let sum = 0;
+        points.forEach((point, index) => {
+            const next = points[(index + 1) % points.length];
+            sum += point.x * next.y - next.x * point.y;
+        });
+        return Math.abs(sum) / 2;
+    }
+    static clamp(point) {
+        return { x: Math.min(1, Math.max(0, point.x)), y: Math.min(1, Math.max(0, point.y)) };
+    }
+    static defaultQuad() {
+        const inset = 0.08;
+        return [
+            { x: inset, y: inset },
+            { x: 1 - inset, y: inset },
+            { x: 1 - inset, y: 1 - inset },
+            { x: inset, y: 1 - inset },
+        ];
+    }
+    static distance(from, to) {
+        return Math.hypot(to.x - from.x, to.y - from.y);
+    }
+    static fit(container, content) {
+        if (container.width <= 0 || container.height <= 0 || content.width <= 0 || content.height <= 0)
+            return { height: 0, width: 0 };
+        const scale = Math.min(container.width / content.width, container.height / content.height);
+        return { height: content.height * scale, width: content.width * scale };
+    }
+    static fitWithin(size, maxDimension) {
+        const longest = Math.max(size.width, size.height);
+        if (longest <= maxDimension)
+            return { height: Math.round(size.height), width: Math.round(size.width) };
+        const scale = maxDimension / longest;
+        return {
+            height: Math.max(1, Math.round(size.height * scale)),
+            width: Math.max(1, Math.round(size.width * scale)),
+        };
+    }
+    static isConvex(points) {
+        let sign = 0;
+        for (let index = 0; index < points.length; index += 1) {
+            const a = points[index];
+            const b = points[(index + 1) % points.length];
+            const c = points[(index + 2) % points.length];
+            const cross = (b.x - a.x) * (c.y - b.y) - (b.y - a.y) * (c.x - b.x);
+            if (Math.abs(cross) < 1e-9)
+                return false;
+            if (sign === 0)
+                sign = Math.sign(cross);
+            else if (Math.sign(cross) !== sign)
+                return false;
+        }
+        return true;
+    }
+    static isUsable(quad) {
+        return (PsScanGeometryService.isConvex(quad) &&
+            PsScanGeometryService.area(quad) > ps_scan_config_1.PsScanConfig.minCornerGap * ps_scan_config_1.PsScanConfig.minCornerGap);
+    }
+    static nudge(quad, index, dx, dy) {
+        const moved = PsScanGeometryService.clamp({ x: quad[index].x + dx, y: quad[index].y + dy });
+        const next = quad.map((point, at) => (at === index ? moved : point));
+        return PsScanGeometryService.isUsable(next) ? next : quad;
+    }
+    static order(points) {
+        const centre = {
+            x: points.reduce((sum, point) => sum + point.x, 0) / points.length,
+            y: points.reduce((sum, point) => sum + point.y, 0) / points.length,
+        };
+        const sorted = [...points].sort((a, b) => Math.atan2(a.y - centre.y, a.x - centre.x) - Math.atan2(b.y - centre.y, b.x - centre.x));
+        const sums = sorted.map((point) => point.x + point.y);
+        const start = sums.indexOf(Math.min(...sums));
+        return [0, 1, 2, 3].map((offset) => sorted[(start + offset) % 4]);
+    }
+    static outputSize(quad, raster) {
+        const pixels = PsScanGeometryService.toPixels(quad, raster);
+        const width = (PsScanGeometryService.distance(pixels[0], pixels[1]) +
+            PsScanGeometryService.distance(pixels[3], pixels[2])) /
+            2;
+        const height = (PsScanGeometryService.distance(pixels[0], pixels[3]) +
+            PsScanGeometryService.distance(pixels[1], pixels[2])) /
+            2;
+        return { height: Math.max(1, Math.round(height)), width: Math.max(1, Math.round(width)) };
+    }
+    static rotateSize(size, rotation) {
+        return rotation % 180 === 0 ? size : { height: size.width, width: size.height };
+    }
+    static toPixels(quad, size) {
+        return quad.map((point) => ({
+            x: point.x * size.width,
+            y: point.y * size.height,
+        }));
+    }
+}
+exports.PsScanGeometryService = PsScanGeometryService;

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

@@ -0,0 +1,7 @@
+import type { PsPoint } from '../models/ps-point';
+import type { PsScanQuad } from '../models/ps-scan-quad';
+export declare class PsScanHomographyService {
+    static apply(matrix: number[], x: number, y: number): PsPoint;
+    static fromUnitSquare(quad: PsScanQuad): number[];
+    private static solve;
+}

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

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PsScanHomographyService = void 0;
+class PsScanHomographyService {
+    static apply(matrix, x, y) {
+        const w = matrix[6] * x + matrix[7] * y + matrix[8];
+        return {
+            x: (matrix[0] * x + matrix[1] * y + matrix[2]) / w,
+            y: (matrix[3] * x + matrix[4] * y + matrix[5]) / w,
+        };
+    }
+    static fromUnitSquare(quad) {
+        const unit = [
+            [0, 0],
+            [1, 0],
+            [1, 1],
+            [0, 1],
+        ];
+        const rows = [];
+        unit.forEach(([u, v], index) => {
+            const { x, y } = quad[index];
+            rows.push([u, v, 1, 0, 0, 0, -u * x, -v * x, x]);
+            rows.push([0, 0, 0, u, v, 1, -u * y, -v * y, y]);
+        });
+        return [...PsScanHomographyService.solve(rows), 1];
+    }
+    static solve(rows) {
+        const size = rows.length;
+        const matrix = rows.map((row) => [...row]);
+        for (let column = 0; column < size; column += 1) {
+            let pivot = column;
+            for (let row = column + 1; row < size; row += 1)
+                if (Math.abs(matrix[row][column]) > Math.abs(matrix[pivot][column]))
+                    pivot = row;
+            [matrix[column], matrix[pivot]] = [matrix[pivot], matrix[column]];
+            const lead = matrix[column][column];
+            if (Math.abs(lead) < 1e-12)
+                return [1, 0, 0, 0, 1, 0, 0, 0];
+            for (let row = 0; row < size; row += 1) {
+                if (row === column)
+                    continue;
+                const factor = matrix[row][column] / lead;
+                for (let at = column; at <= size; at += 1)
+                    matrix[row][at] -= factor * matrix[column][at];
+            }
+        }
+        return matrix.map((row, index) => row[size] / row[index]);
+    }
+}
+exports.PsScanHomographyService = PsScanHomographyService;

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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,63 @@
+"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)
+            return points;
+        const cross = (o, a, b) => (a.x - o.x) * (b.y - o.y) - (a.y - o.y) * (b.x - o.x);
+        const build = (list) => {
+            const chain = [];
+            list.forEach((point) => {
+                while (chain.length >= 2 &&
+                    cross(chain[chain.length - 2], chain[chain.length - 1], point) <= 0)
+                    chain.pop();
+                chain.push(point);
+            });
+            chain.pop();
+            return chain;
+        };
+        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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PsScanImageFilterService = void 0;
+class PsScanImageFilterService {
+    static blur(gray, width, height) {
+        const kernel = [1, 4, 6, 4, 1];
+        const pass = new Float32Array(width * height);
+        const out = new Uint8ClampedArray(width * height);
+        for (let y = 0; y < height; y += 1)
+            for (let x = 0; x < width; x += 1) {
+                let sum = 0;
+                for (let k = -2; k <= 2; k += 1)
+                    sum += gray[y * width + Math.min(width - 1, Math.max(0, x + k))] * kernel[k + 2];
+                pass[y * width + x] = sum / 16;
+            }
+        for (let y = 0; y < height; y += 1)
+            for (let x = 0; x < width; x += 1) {
+                let sum = 0;
+                for (let k = -2; k <= 2; k += 1)
+                    sum += pass[Math.min(height - 1, Math.max(0, y + k)) * width + x] * kernel[k + 2];
+                out[y * width + x] = sum / 16;
+            }
+        return out;
+    }
+    static grayscale(raster) {
+        const out = new Uint8ClampedArray(raster.width * raster.height);
+        for (let index = 0; index < out.length; index += 1) {
+            const at = index * 4;
+            out[index] =
+                0.299 * raster.data[at] + 0.587 * raster.data[at + 1] + 0.114 * raster.data[at + 2];
+        }
+        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-order-service.d.ts

@@ -0,0 +1,4 @@
+export declare class PsScanOrderService {
+    static move<T>(items: T[], from: number, to: number): T[];
+    static step<T>(items: T[], index: number, direction: number): T[];
+}

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PsScanOrderService = void 0;
+class PsScanOrderService {
+    static move(items, from, to) {
+        if (from === to || from < 0 || to < 0 || from >= items.length || to >= items.length)
+            return items;
+        const next = [...items];
+        const [item] = next.splice(from, 1);
+        next.splice(to, 0, item);
+        return next;
+    }
+    static step(items, index, direction) {
+        return PsScanOrderService.move(items, index, index + direction);
+    }
+}
+exports.PsScanOrderService = PsScanOrderService;

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

@@ -0,0 +1,5 @@
+import type { PsScanOutputOptions } from '../models/ps-scan-output-options';
+import type { PsScanPage } from '../models/ps-scan-page';
+export declare class PsScanOutputService {
+    static build(pages: PsScanPage[], options: PsScanOutputOptions): Promise<File[]>;
+}