@pallasoft/ps-file-components 1.3.0 → 1.5.0

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

@@ -0,0 +1,120 @@
+"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 cover(container, content) {
+        if (container.width <= 0 || container.height <= 0 || content.width <= 0 || content.height <= 0)
+            return { height: 0, width: 0 };
+        const scale = Math.max(container.width / content.width, container.height / content.height);
+        return { height: content.height * scale, width: content.width * scale };
+    }
+    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 inset(quad, distance) {
+        const centre = {
+            x: quad.reduce((sum, point) => sum + point.x, 0) / quad.length,
+            y: quad.reduce((sum, point) => sum + point.y, 0) / quad.length,
+        };
+        return quad.map((point) => {
+            const length = PsScanGeometryService.distance(point, centre);
+            const ratio = length <= distance ? 0 : (length - distance) / length;
+            return {
+                x: centre.x + (point.x - centre.x) * ratio,
+                y: centre.y + (point.y - centre.y) * ratio,
+            };
+        });
+    }
+    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[]>;
+}

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PsScanOutputService = void 0;
+const ps_scan_output_format_1 = require("../constants/ps-scan-output-format");
+const ps_scan_file_name_service_1 = require("./ps-scan-file-name-service");
+const ps_scan_pdf_service_1 = require("./ps-scan-pdf-service");
+const ps_scan_pipeline_service_1 = require("./ps-scan-pipeline-service");
+class PsScanOutputService {
+    static async build(pages, options) {
+        const rendered = [];
+        for (const page of pages)
+            rendered.push(await ps_scan_pipeline_service_1.PsScanPipelineService.render(page, options.maxDimension, options.jpegQuality));
+        const type = ps_scan_file_name_service_1.PsScanFileNameService.mimeType(options.format);
+        if (options.format === ps_scan_output_format_1.PsScanOutputFormat.Jpeg)
+            return rendered.map((item, index) => new File([item.blob], ps_scan_file_name_service_1.PsScanFileNameService.build(options.fileName, options.format, index, rendered.length), { type }));
+        const jpegs = await Promise.all(rendered.map(async (item) => ({
+            height: item.height,
+            jpeg: new Uint8Array(await item.blob.arrayBuffer()),
+            width: item.width,
+        })));
+        return [
+            new File([ps_scan_pdf_service_1.PsScanPdfService.build(jpegs)], ps_scan_file_name_service_1.PsScanFileNameService.build(options.fileName, options.format, 0, 1), {
+                type,
+            }),
+        ];
+    }
+}
+exports.PsScanOutputService = PsScanOutputService;

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

@@ -0,0 +1,5 @@
+import type { PsScanPdfPage } from '../models/ps-scan-pdf-page';
+export declare class PsScanPdfService {
+    static build(pages: PsScanPdfPage[]): Uint8Array<ArrayBuffer>;
+    private static points;
+}

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

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PsScanPdfService = void 0;
+const ps_scan_config_1 = require("../constants/ps-scan-config");
+class PsScanPdfService {
+    static build(pages) {
+        const encoder = new TextEncoder();
+        const chunks = [];
+        const offsets = [];
+        let length = 0;
+        const push = (chunk) => {
+            chunks.push(chunk);
+            length += chunk.length;
+        };
+        const text = (value) => push(encoder.encode(value));
+        const begin = (id) => {
+            offsets[id] = length;
+            text(`${id} 0 obj\n`);
+        };
+        const kids = pages.map((_, index) => `${3 + index * 3} 0 R`).join(' ');
+        push(Uint8Array.from([
+            0x25, 0x50, 0x44, 0x46, 0x2d, 0x31, 0x2e, 0x34, 0x0a, 0x25, 0xe2, 0xe3, 0xcf, 0xd3, 0x0a,
+        ]));
+        begin(1);
+        text('<< /Type /Catalog /Pages 2 0 R >>\nendobj\n');
+        begin(2);
+        text(`<< /Type /Pages /Kids [${kids}] /Count ${pages.length} >>\nendobj\n`);
+        pages.forEach((page, index) => {
+            const pageId = 3 + index * 3;
+            const widthPt = PsScanPdfService.points(page.width);
+            const heightPt = PsScanPdfService.points(page.height);
+            const content = `q ${widthPt} 0 0 ${heightPt} 0 0 cm /Im0 Do Q`;
+            begin(pageId);
+            text(`<< /Type /Page /Parent 2 0 R /MediaBox [0 0 ${widthPt} ${heightPt}] /Resources << /XObject << /Im0 ${pageId + 2} 0 R >> >> /Contents ${pageId + 1} 0 R >>\nendobj\n`);
+            begin(pageId + 1);
+            text(`<< /Length ${content.length} >>\nstream\n${content}\nendstream\nendobj\n`);
+            begin(pageId + 2);
+            text(`<< /Type /XObject /Subtype /Image /Width ${page.width} /Height ${page.height} /ColorSpace /DeviceRGB /BitsPerComponent 8 /Filter /DCTDecode /Length ${page.jpeg.length} >>\nstream\n`);
+            push(page.jpeg);
+            text('\nendstream\nendobj\n');
+        });
+        const count = 3 + pages.length * 3;
+        const xrefAt = length;
+        text(`xref\n0 ${count}\n0000000000 65535 f \n`);
+        for (let id = 1; id < count; id += 1)
+            text(`${String(offsets[id]).padStart(10, '0')} 00000 n \n`);
+        text(`trailer\n<< /Size ${count} /Root 1 0 R >>\nstartxref\n${xrefAt}\n%%EOF\n`);
+        const out = new Uint8Array(length);
+        let at = 0;
+        chunks.forEach((chunk) => {
+            out.set(chunk, at);
+            at += chunk.length;
+        });
+        return out;
+    }
+    static points(pixels) {
+        return Math.round((pixels * ps_scan_config_1.PsScanConfig.pdfPointsPerInch * 100) / ps_scan_config_1.PsScanConfig.pdfDpi) / 100;
+    }
+}
+exports.PsScanPdfService = PsScanPdfService;

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

@@ -0,0 +1,10 @@
+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 { 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>;
+}

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

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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);
+        return {
+            corners: detected === null ? ps_scan_geometry_service_1.PsScanGeometryService.defaultQuad() : detected,
+            height: decoded.naturalHeight,
+            isDetected: detected !== null,
+            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,
+        }), 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,
+            width: raster.width,
+        };
+    }
+}
+exports.PsScanPipelineService = PsScanPipelineService;

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

@@ -0,0 +1,4 @@
+import { PsScanPlatform } from '../constants/ps-scan-platform';
+export declare class PsScanPlatformService {
+    static detect(): PsScanPlatform;
+}

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PsScanPlatformService = void 0;
+const ps_scan_platform_1 = require("../constants/ps-scan-platform");
+class PsScanPlatformService {
+    static detect() {
+        if (typeof navigator === 'undefined')
+            return ps_scan_platform_1.PsScanPlatform.Desktop;
+        const agent = navigator.userAgent;
+        if (/iPhone|iPad|iPod/i.test(agent))
+            return ps_scan_platform_1.PsScanPlatform.Ios;
+        if (/Macintosh/i.test(agent) && navigator.maxTouchPoints > 1)
+            return ps_scan_platform_1.PsScanPlatform.Ios;
+        if (/Android/i.test(agent))
+            return ps_scan_platform_1.PsScanPlatform.Android;
+        return ps_scan_platform_1.PsScanPlatform.Desktop;
+    }
+}
+exports.PsScanPlatformService = PsScanPlatformService;

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

@@ -0,0 +1,6 @@
+import type { PsScanRaster } from '../models/ps-scan-raster';
+export declare class PsScanRasterService {
+    static create(width: number, height: number): PsScanRaster;
+    static resize(source: PsScanRaster, width: number, height: number): PsScanRaster;
+    static rotate(source: PsScanRaster, degrees: number): PsScanRaster;
+}

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

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PsScanRasterService = void 0;
+class PsScanRasterService {
+    static create(width, height) {
+        return { data: new Uint8ClampedArray(width * height * 4), height, width };
+    }
+    static resize(source, width, height) {
+        if (width === source.width && height === source.height)
+            return source;
+        const target = PsScanRasterService.create(width, height);
+        const scaleX = source.width / width;
+        const scaleY = source.height / height;
+        for (let y = 0; y < height; y += 1) {
+            const y0 = Math.floor(y * scaleY);
+            const y1 = Math.min(source.height, Math.max(y0 + 1, Math.ceil((y + 1) * scaleY)));
+            for (let x = 0; x < width; x += 1) {
+                const x0 = Math.floor(x * scaleX);
+                const x1 = Math.min(source.width, Math.max(x0 + 1, Math.ceil((x + 1) * scaleX)));
+                let r = 0;
+                let g = 0;
+                let b = 0;
+                let a = 0;
+                let count = 0;
+                for (let sy = y0; sy < y1; sy += 1)
+                    for (let sx = x0; sx < x1; sx += 1) {
+                        const at = (sy * source.width + sx) * 4;
+                        r += source.data[at];
+                        g += source.data[at + 1];
+                        b += source.data[at + 2];
+                        a += source.data[at + 3];
+                        count += 1;
+                    }
+                const out = (y * width + x) * 4;
+                target.data[out] = r / count;
+                target.data[out + 1] = g / count;
+                target.data[out + 2] = b / count;
+                target.data[out + 3] = a / count;
+            }
+        }
+        return target;
+    }
+    static rotate(source, degrees) {
+        const turns = ((Math.round(degrees / 90) % 4) + 4) % 4;
+        if (turns === 0)
+            return source;
+        const swapped = turns % 2 === 1;
+        const width = swapped ? source.height : source.width;
+        const height = swapped ? source.width : source.height;
+        const target = PsScanRasterService.create(width, height);
+        for (let y = 0; y < source.height; y += 1)
+            for (let x = 0; x < source.width; x += 1) {
+                let tx = x;
+                let ty = y;
+                if (turns === 1)
+                    [tx, ty] = [source.height - 1 - y, x];
+                else if (turns === 2)
+                    [tx, ty] = [source.width - 1 - x, source.height - 1 - y];
+                else
+                    [tx, ty] = [y, source.width - 1 - x];
+                const from = (y * source.width + x) * 4;
+                const to = (ty * width + tx) * 4;
+                target.data[to] = source.data[from];
+                target.data[to + 1] = source.data[from + 1];
+                target.data[to + 2] = source.data[from + 2];
+                target.data[to + 3] = source.data[from + 3];
+            }
+        return target;
+    }
+}
+exports.PsScanRasterService = PsScanRasterService;

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

@@ -0,0 +1,9 @@
+import type { PsScanQuad } from '../models/ps-scan-quad';
+import type { PsScanStability } from '../models/ps-scan-stability';
+export declare class PsScanStabilityService {
+    static disarm(state: PsScanStability): PsScanStability;
+    static initial(): PsScanStability;
+    static movement(from: PsScanQuad, to: PsScanQuad): number;
+    static next(state: PsScanStability, detected: PsScanQuad | null, elapsedMs: number): PsScanStability;
+    static progress(state: PsScanStability): number;
+}

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PsScanStabilityService = void 0;
+const ps_scan_config_1 = require("../constants/ps-scan-config");
+const ps_scan_geometry_service_1 = require("./ps-scan-geometry-service");
+class PsScanStabilityService {
+    static disarm(state) {
+        return { ...state, isArmed: false, stableMs: 0 };
+    }
+    static initial() {
+        return { isArmed: true, misses: 0, quad: null, raw: null, stableMs: 0 };
+    }
+    static movement(from, to) {
+        return Math.max(...from.map((point, index) => ps_scan_geometry_service_1.PsScanGeometryService.distance(point, to[index])));
+    }
+    static next(state, detected, elapsedMs) {
+        if (detected === null) {
+            const misses = state.misses + 1;
+            return misses > ps_scan_config_1.PsScanConfig.liveMissLimit
+                ? { isArmed: true, misses, quad: null, raw: null, stableMs: 0 }
+                : { ...state, misses, stableMs: 0 };
+        }
+        if (state.quad === null || state.raw === null)
+            return { ...state, misses: 0, quad: detected, raw: detected, stableMs: 0 };
+        const movement = PsScanStabilityService.movement(state.raw, detected);
+        const weight = ps_scan_config_1.PsScanConfig.liveSmoothing;
+        const quad = state.quad.map((point, index) => ({
+            x: point.x + (detected[index].x - point.x) * weight,
+            y: point.y + (detected[index].y - point.y) * weight,
+        }));
+        return {
+            isArmed: state.isArmed || movement > ps_scan_config_1.PsScanConfig.liveRearmMovement,
+            misses: 0,
+            quad,
+            raw: detected,
+            stableMs: movement <= ps_scan_config_1.PsScanConfig.liveStillMovement ? state.stableMs + elapsedMs : 0,
+        };
+    }
+    static progress(state) {
+        if (!state.isArmed || state.quad === null)
+            return 0;
+        return Math.min(1, state.stableMs / ps_scan_config_1.PsScanConfig.autoCaptureMs);
+    }
+}
+exports.PsScanStabilityService = PsScanStabilityService;