@pallasoft/ps-file-components 1.4.0 → 2.0.0

package/dist/esm/hooks/use-ps-scan-live-detection.js

@@ -0,0 +1,41 @@
+import { useEffect, useState } from 'react';
+import { PsScanConfig } from '../constants/ps-scan-config';
+import { PsScanCanvasService } from '../services/ps-scan-canvas-service';
+import { PsScanEdgeService } from '../services/ps-scan-edge-service';
+import { PsScanStabilityService } from '../services/ps-scan-stability-service';
+export const usePsScanLiveDetection = (videoRef, isActive) => {
+    const [detection, setDetection] = useState({ quad: null });
+    useEffect(() => {
+        if (!isActive) {
+            setDetection({ quad: null });
+            return;
+        }
+        let isCancelled = false;
+        let state = PsScanStabilityService.initial();
+        let timer;
+        const tick = async () => {
+            const video = videoRef.current;
+            if (video !== null && video.videoWidth > 0 && document.visibilityState === 'visible') {
+                try {
+                    const raster = PsScanCanvasService.sample(video, PsScanConfig.liveDetectMaxDimension);
+                    const quad = await PsScanEdgeService.detect(raster, PsScanConfig.liveDetectMaxDimension);
+                    if (isCancelled)
+                        return;
+                    state = PsScanStabilityService.next(state, quad);
+                }
+                catch {
+                    state = PsScanStabilityService.initial();
+                }
+                setDetection((current) => (current.quad === state.quad ? current : { quad: state.quad }));
+            }
+            if (!isCancelled)
+                timer = setTimeout(tick, PsScanConfig.liveDetectIntervalMs);
+        };
+        timer = setTimeout(tick, PsScanConfig.liveDetectIntervalMs);
+        return () => {
+            isCancelled = true;
+            clearTimeout(timer);
+        };
+    }, [isActive]);
+    return detection;
+};

package/dist/esm/hooks/use-ps-scan-photo.js

@@ -0,0 +1,42 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { PsScanPipelineService } from '../services/ps-scan-pipeline-service';
+export const usePsScanPhoto = () => {
+    const [photo, setPhoto] = useState(null);
+    const url = useRef('');
+    const release = useCallback(() => {
+        if (url.current !== '')
+            URL.revokeObjectURL(url.current);
+        url.current = '';
+    }, []);
+    useEffect(() => release, [release]);
+    const load = useCallback(async (source) => {
+        const prepared = await PsScanPipelineService.prepare(source);
+        const next = {
+            corners: prepared.corners,
+            height: prepared.height,
+            isDetected: prepared.isDetected,
+            source,
+            sourceUrl: URL.createObjectURL(source),
+            width: prepared.width,
+        };
+        release();
+        url.current = next.sourceUrl;
+        setPhoto(next);
+        return next;
+    }, [release]);
+    const setCorners = useCallback((corners) => setPhoto((current) => (current === null ? current : { ...current, corners })), []);
+    const detectAgain = useCallback(async () => {
+        if (photo === null)
+            return false;
+        const prepared = await PsScanPipelineService.prepare(photo.source);
+        setPhoto((current) => current === null
+            ? current
+            : { ...current, corners: prepared.corners, isDetected: prepared.isDetected });
+        return prepared.isDetected;
+    }, [photo]);
+    const clear = useCallback(() => {
+        release();
+        setPhoto(null);
+    }, [release]);
+    return { clear, detectAgain, load, photo, setCorners };
+};

package/dist/esm/index.js

@@ -71,6 +71,5 @@ export * from './hooks/use-ps-in-view';
 export * from './hooks/use-ps-upload-queue';
 export * from './components/ps-document-scanner';
 export * from './constants/ps-document-scanner-labels';
-export * from './constants/ps-scan-filter';
-export * from './constants/ps-scan-output-format';
 export * from './models/ps-document-scanner-props';
+export * from './models/ps-file-picker-scan';

package/dist/esm/models/ps-scan-region.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/models/ps-scan-result.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/models/ps-scan-stability.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/services/ps-scan-camera-service.js

@@ -1,13 +1,45 @@
 import { PsScanCameraStatus } from '../constants/ps-scan-camera-status';
 import { PsScanConfig } from '../constants/ps-scan-config';
 export class PsScanCameraService {
+    static async attach(video, session) {
+        if (video.srcObject !== session.stream)
+            video.srcObject = session.stream;
+        await video.play().catch(() => undefined);
+    }
+    static async check() {
+        if (globalThis.isSecureContext === false)
+            return PsScanCameraStatus.Insecure;
+        if (!PsScanCameraService.isSupported())
+            return PsScanCameraStatus.Unavailable;
+        if (!(await PsScanCameraService.hasCamera()))
+            return PsScanCameraStatus.Unavailable;
+        const permission = await PsScanCameraService.permission();
+        if (permission === null)
+            return PsScanCameraStatus.Prompt;
+        if (permission.state === 'granted')
+            return PsScanCameraStatus.Starting;
+        return permission.state === 'denied' ? PsScanCameraStatus.Denied : PsScanCameraStatus.Prompt;
+    }
     static classify(error) {
         const name = typeof error === 'object' && error !== null && 'name' in error ? String(error.name) : '';
-        return name === 'NotAllowedError' ||
-            name === 'SecurityError' ||
-            name === 'PermissionDeniedError'
-            ? PsScanCameraStatus.Denied
-            : PsScanCameraStatus.Unavailable;
+        if (name === 'NotAllowedError' || name === 'PermissionDeniedError')
+            return PsScanCameraStatus.Denied;
+        if (name === 'SecurityError')
+            return PsScanCameraStatus.Insecure;
+        if (name === 'NotReadableError' || name === 'TrackStartError' || name === 'AbortError')
+            return PsScanCameraStatus.Busy;
+        return PsScanCameraStatus.Unavailable;
+    }
+    static async hasCamera() {
+        if (typeof navigator.mediaDevices.enumerateDevices !== 'function')
+            return true;
+        try {
+            const devices = await navigator.mediaDevices.enumerateDevices();
+            return devices.length === 0 || devices.some((device) => device.kind === 'videoinput');
+        }
+        catch {
+            return true;
+        }
     }
     static isSupported() {
         return (typeof navigator !== 'undefined' &&
@@ -19,13 +51,26 @@ export class PsScanCameraService {
             audio: false,
             video: {
                 facingMode: { ideal: 'environment' },
-                height: { ideal: 1440 },
-                width: { ideal: 1920 },
+                height: { ideal: 2160 },
+                width: { ideal: 3840 },
             },
         });
         const track = stream.getVideoTracks()[0];
         return { canTorch: PsScanCameraService.supportsTorch(track), stream, track };
     }
+    static async permission() {
+        if (typeof navigator.permissions === 'undefined' ||
+            typeof navigator.permissions.query !== 'function')
+            return null;
+        try {
+            return await navigator.permissions.query({
+                name: PsScanConfig.cameraPermission,
+            });
+        }
+        catch {
+            return null;
+        }
+    }
     static async setTorch(track, isOn) {
         try {
             await track.applyConstraints({

package/dist/esm/services/ps-scan-canny-service.js

@@ -0,0 +1,93 @@
+import { PsScanConfig } from '../constants/ps-scan-config';
+export class PsScanCannyService {
+    static edges(gray, width, height) {
+        const gradient = PsScanCannyService.gradient(gray, width, height);
+        const ridges = PsScanCannyService.suppress(gradient, width, height);
+        const high = PsScanCannyService.highThreshold(ridges);
+        return PsScanCannyService.hysteresis(ridges, width, height, high * PsScanConfig.cannyLowRatio, high);
+    }
+    static gradient(gray, width, height) {
+        const magnitude = new Float32Array(width * height);
+        const direction = new Uint8Array(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];
+                const ax = Math.abs(gx);
+                const ay = Math.abs(gy);
+                magnitude[i] = Math.hypot(gx, gy) / 4;
+                if (ay <= ax * 0.41421356)
+                    direction[i] = 0;
+                else if (ay >= ax * 2.41421356)
+                    direction[i] = 2;
+                else
+                    direction[i] = gx * gy > 0 ? 1 : 3;
+            }
+        return { direction, magnitude };
+    }
+    static highThreshold(ridges) {
+        const values = [];
+        for (let index = 0; index < ridges.length; index += 1)
+            if (ridges[index] > 0)
+                values.push(ridges[index]);
+        if (values.length === 0)
+            return PsScanConfig.cannyMinHigh;
+        values.sort((a, b) => a - b);
+        const at = Math.min(values.length - 1, Math.floor(values.length * PsScanConfig.cannyHighPercentile));
+        return Math.max(PsScanConfig.cannyMinHigh, values[at]);
+    }
+    static hysteresis(ridges, width, height, low, high) {
+        const out = new Uint8Array(width * height);
+        const stack = [];
+        for (let index = 0; index < ridges.length; index += 1)
+            if (ridges[index] >= high) {
+                out[index] = 1;
+                stack.push(index);
+            }
+        while (stack.length > 0) {
+            const index = stack.pop();
+            if (index === undefined)
+                break;
+            const x = index % width;
+            const y = (index - x) / width;
+            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)
+                        continue;
+                    const next = ny * width + nx;
+                    if (out[next] === 0 && ridges[next] >= low) {
+                        out[next] = 1;
+                        stack.push(next);
+                    }
+                }
+        }
+        return out;
+    }
+    static suppress(gradient, width, height) {
+        const { direction, magnitude } = gradient;
+        const out = new Float32Array(width * height);
+        const offsets = [1, width + 1, width, width - 1];
+        for (let y = 1; y < height - 1; y += 1)
+            for (let x = 1; x < width - 1; x += 1) {
+                const i = y * width + x;
+                const offset = offsets[direction[i]];
+                const value = magnitude[i];
+                if (value >= magnitude[i - offset] && value > magnitude[i + offset])
+                    out[i] = value;
+            }
+        return out;
+    }
+}

package/dist/esm/services/ps-scan-canvas-service.js

@@ -1,8 +1,14 @@
+import { PsScanConfig } from '../constants/ps-scan-config';
 import { PsScanGeometryService } from './ps-scan-geometry-service';
 export class PsScanCanvasService {
     static async decode(blob, maxDimension) {
         const bitmap = await createImageBitmap(blob, { imageOrientation: 'from-image' });
-        const size = PsScanGeometryService.fitWithin({ height: bitmap.height, width: bitmap.width }, maxDimension);
+        const capped = PsScanGeometryService.fitWithin({ height: bitmap.height, width: bitmap.width }, maxDimension);
+        const shrink = Math.min(1, Math.sqrt(PsScanConfig.decodeMaxPixels / (capped.width * capped.height)));
+        const size = {
+            height: Math.max(1, Math.round(capped.height * shrink)),
+            width: Math.max(1, Math.round(capped.width * shrink)),
+        };
         const context = PsScanCanvasService.context(size.width, size.height);
         context.drawImage(bitmap, 0, 0, size.width, size.height);
         const naturalHeight = bitmap.height;
@@ -27,6 +33,12 @@ export class PsScanCanvasService {
         context.drawImage(video, 0, 0);
         return await PsScanCanvasService.encode(context.getImageData(0, 0, video.videoWidth, video.videoHeight), quality);
     }
+    static sample(video, maxDimension) {
+        const size = PsScanGeometryService.fitWithin({ height: video.videoHeight, width: video.videoWidth }, maxDimension);
+        const context = PsScanCanvasService.context(size.width, size.height);
+        context.drawImage(video, 0, 0, size.width, size.height);
+        return context.getImageData(0, 0, size.width, size.height);
+    }
     static context(width, height) {
         if (typeof OffscreenCanvas !== 'undefined') {
             const context = new OffscreenCanvas(width, height).getContext('2d', {

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

@@ -1,156 +1,92 @@
 import { PsScanConfig } from '../constants/ps-scan-config';
+import { PsScanCannyService } from './ps-scan-canny-service';
 import { PsScanGeometryService } from './ps-scan-geometry-service';
 import { PsScanHullService } from './ps-scan-hull-service';
 import { PsScanImageFilterService } from './ps-scan-image-filter-service';
+import { PsScanMorphologyService } from './ps-scan-morphology-service';
+import { PsScanPolygonService } from './ps-scan-polygon-service';
 import { PsScanRasterService } from './ps-scan-raster-service';
+import { PsScanRegionService } from './ps-scan-region-service';
+import { PsScanYieldService } from './ps-scan-yield-service';
 export class PsScanEdgeService {
-    static detect(source) {
-        const scale = Math.min(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 = PsScanRasterService.resize(source, width, height);
         const gray = PsScanImageFilterService.blur(PsScanImageFilterService.grayscale(raster), width, height);
-        const edges = PsScanImageFilterService.sobel(gray, width, height);
-        let mask = PsScanEdgeService.threshold(edges);
-        for (let step = 0; step < 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 PsScanYieldService.next();
+        const edges = 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 PsScanConfig.closeRadii) {
+            await PsScanYieldService.next();
+            const closed = PsScanMorphologyService.close(edges, width, height, radius);
+            const regions = PsScanRegionService.enclosed(closed, width, height, width * height * PsScanConfig.detectMinAreaRatio * 0.5);
+            for (const region of regions) {
+                const quad = PsScanEdgeService.candidate(region.boundary, width, height);
+                if (quad === null)
+                    continue;
+                const area = PsScanGeometryService.area(quad);
+                if (area > bestArea) {
+                    bestArea = area;
+                    best = quad;
+                }
+            }
+        }
+        if (best === null)
             return null;
-        const hull = 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: 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 = PsScanHullService.convexHull(points);
         if (hull.length < 4)
             return null;
-        const quad = PsScanGeometryService.order(PsScanHullService.bestQuad(hull));
-        const imageArea = width * height;
-        const quadArea = PsScanGeometryService.area(quad);
-        const hullArea = PsScanGeometryService.area(hull);
-        if (quadArea / imageArea < PsScanConfig.detectMinAreaRatio)
+        const corners = PsScanPolygonService.toQuad(hull);
+        if (corners === null)
+            return null;
+        const ordered = PsScanGeometryService.order(corners);
+        const margin = 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 > PsScanConfig.detectMaxAreaRatio)
+        const quad = PsScanGeometryService.expand(ordered, PsScanConfig.detectExpand);
+        const imageArea = width * height;
+        const area = PsScanGeometryService.area(quad);
+        const fill = PsScanGeometryService.area(ordered) / PsScanGeometryService.area(hull);
+        const ratio = area / imageArea;
+        if (ratio < PsScanConfig.detectMinAreaRatio || ratio > PsScanConfig.detectMaxAreaRatio)
             return null;
-        if (hullArea > 0 && quadArea / hullArea < PsScanConfig.detectMinHullFill)
+        if (fill < PsScanConfig.detectMinQuadFill)
             return null;
         if (!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;
+        const shortSide = Math.min(width, height) * PsScanConfig.detectMinSideRatio;
+        const isLongEnough = quad.every((point, index) => PsScanGeometryService.distance(point, quad[(index + 1) % quad.length]) >= shortSide);
+        if (!isLongEnough)
+            return null;
+        const isSane = PsScanGeometryService.angles(quad).every((angle) => angle >= PsScanConfig.detectMinAngle && angle <= 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 * 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(PsScanConfig.detectMinEdgeStrength, high * PsScanConfig.detectRelativeStrength);
-        return Uint8Array.from(edges, (value) => (value >= limit ? 1 : 0));
+    static normalise(quad, width, height) {
+        return quad.map((point) => PsScanGeometryService.clamp({ x: point.x / width, y: point.y / height }));
     }
 }

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

@@ -1,16 +1,7 @@
 import { PsScanConfig } from '../constants/ps-scan-config';
-import { PsScanOutputFormat } from '../constants/ps-scan-output-format';
 export class PsScanFileNameService {
-    static build(base, format, index, count) {
-        const stem = PsScanFileNameService.sanitize(base);
-        if (format === 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 === PsScanOutputFormat.Pdf ? 'application/pdf' : 'image/jpeg';
+    static build(base) {
+        return `${PsScanFileNameService.sanitize(base)}.jpg`;
     }
     static sanitize(base) {
         const cleaned = Array.from(base)

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

@@ -1,5 +1,17 @@
 import { PsScanConfig } from '../constants/ps-scan-config';
 export 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) => {
@@ -11,6 +23,12 @@ export class PsScanGeometryService {
     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 [
@@ -23,6 +41,30 @@ export 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 };
@@ -39,6 +81,20 @@ export class PsScanGeometryService {
             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) {