@pallasoft/ps-file-components 1.5.0 → 2.0.1

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 PsScanGeometryService.inset(quad, 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) * 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) => {
@@ -29,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 };

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

@@ -1,25 +1,4 @@
-import { PsScanConfig } from '../constants/ps-scan-config';
-import { PsScanGeometryService } from './ps-scan-geometry-service';
 export class PsScanHullService {
-    static bestQuad(hull) {
-        const points = PsScanHullService.reduce(hull, 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 = 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)
@@ -38,22 +17,4 @@ export 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 = PsScanGeometryService.area([previous, point, next]);
-                if (area < weakestArea) {
-                    weakestArea = area;
-                    weakest = index;
-                }
-            });
-            points.splice(weakest, 1);
-        }
-        return points;
-    }
 }

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

@@ -28,25 +28,4 @@ export 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;
-    }
 }

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

@@ -0,0 +1,44 @@
+export 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;
+    }
+}

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

@@ -1,36 +1,26 @@
 import { PsScanConfig } from '../constants/ps-scan-config';
 import { PsScanCanvasService } from './ps-scan-canvas-service';
 import { PsScanEdgeService } from './ps-scan-edge-service';
-import { PsScanEnhanceService } from './ps-scan-enhance-service';
 import { PsScanGeometryService } from './ps-scan-geometry-service';
-import { PsScanRasterService } from './ps-scan-raster-service';
 import { PsScanWarpService } from './ps-scan-warp-service';
 export class PsScanPipelineService {
     static async prepare(source) {
         const decoded = await PsScanCanvasService.decode(source, PsScanConfig.detectMaxDimension * 2);
-        const detected = PsScanEdgeService.detect(decoded.raster);
+        const located = await PsScanEdgeService.locate(decoded.raster, PsScanConfig.detectMaxDimension);
         return {
-            corners: detected === null ? 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 PsScanCanvasService.decode(source, PsScanConfig.previewMaxDimension);
-        return decoded.raster;
-    }
-    static process(page, raster, maxDimension) {
-        const size = PsScanGeometryService.fitWithin(PsScanGeometryService.outputSize(page.corners, raster), maxDimension);
-        const warped = PsScanWarpService.warp(raster, PsScanGeometryService.toPixels(page.corners, {
-            height: raster.height - 1,
-            width: raster.width - 1,
+    static async render(source, corners, maxDimension, quality) {
+        const decoded = await PsScanCanvasService.decode(source, Number.MAX_SAFE_INTEGER);
+        const size = PsScanGeometryService.fitWithin(PsScanGeometryService.outputSize(corners, decoded.raster), maxDimension);
+        const raster = await PsScanWarpService.warp(decoded.raster, PsScanGeometryService.toPixels(corners, {
+            height: decoded.raster.height - 1,
+            width: decoded.raster.width - 1,
         }), size.width, size.height);
-        return PsScanRasterService.rotate(PsScanEnhanceService.apply(warped, page.filter), page.rotation);
-    }
-    static async render(page, maxDimension, quality) {
-        const decoded = await PsScanCanvasService.decode(page.source, PsScanConfig.decodeMaxDimension);
-        const raster = PsScanPipelineService.process(page, decoded.raster, maxDimension);
         return {
             blob: await PsScanCanvasService.encode(raster, quality),
             height: raster.height,

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

@@ -0,0 +1,75 @@
+import { PsScanConfig } from '../constants/ps-scan-config';
+import { PsScanGeometryService } from './ps-scan-geometry-service';
+export class PsScanPolygonService {
+    static perimeter(points) {
+        return points.reduce((sum, point, index) => sum + 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 = PsScanGeometryService.distance(points[0], point);
+            if (length > best) {
+                best = length;
+                second = index;
+            }
+        });
+        best = -1;
+        points.forEach((point, index) => {
+            const length = 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 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 PsScanGeometryService.distance(point, from);
+        return Math.abs(dy * (point.x - from.x) - dx * (point.y - from.y)) / length;
+    }
+}

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

@@ -0,0 +1,52 @@
+export class PsScanRegionService {
+    static enclosed(mask, width, height, minArea) {
+        const seen = new Uint8Array(mask.length);
+        const regions = [];
+        for (let start = 0; start < mask.length; start += 1) {
+            if (mask[start] === 1 || seen[start] === 1)
+                continue;
+            const boundary = [];
+            const stack = [start];
+            let area = 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;
+                area += 1;
+                const visit = (next) => {
+                    if (mask[next] === 1)
+                        isBoundary = true;
+                    else if (seen[next] === 0) {
+                        seen[next] = 1;
+                        stack.push(next);
+                    }
+                };
+                if (x > 0)
+                    visit(index - 1);
+                else
+                    isBoundary = true;
+                if (x < width - 1)
+                    visit(index + 1);
+                else
+                    isBoundary = true;
+                if (y > 0)
+                    visit(index - width);
+                else
+                    isBoundary = true;
+                if (y < height - 1)
+                    visit(index + width);
+                else
+                    isBoundary = true;
+                if (isBoundary)
+                    boundary.push({ x, y });
+            }
+            if (area >= minArea)
+                regions.push({ area, boundary });
+        }
+        return regions;
+    }
+}

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

@@ -1,41 +1,28 @@
 import { PsScanConfig } from '../constants/ps-scan-config';
 import { PsScanGeometryService } from './ps-scan-geometry-service';
 export class PsScanStabilityService {
-    static disarm(state) {
-        return { ...state, isArmed: false, stableMs: 0 };
-    }
     static initial() {
-        return { isArmed: true, misses: 0, quad: null, raw: null, stableMs: 0 };
+        return { misses: 0, quad: null };
     }
     static movement(from, to) {
         return Math.max(...from.map((point, index) => PsScanGeometryService.distance(point, to[index])));
     }
-    static next(state, detected, elapsedMs) {
+    static next(state, detected) {
         if (detected === null) {
             const misses = state.misses + 1;
             return misses > PsScanConfig.liveMissLimit
-                ? { isArmed: true, misses, quad: null, raw: null, stableMs: 0 }
-                : { ...state, misses, stableMs: 0 };
+                ? { misses, quad: null }
+                : { misses, quad: state.quad };
         }
-        if (state.quad === null || state.raw === null)
-            return { ...state, misses: 0, quad: detected, raw: detected, stableMs: 0 };
-        const movement = PsScanStabilityService.movement(state.raw, detected);
+        if (state.quad === null)
+            return { misses: 0, quad: detected };
+        if (PsScanStabilityService.movement(state.quad, detected) < PsScanConfig.liveDeadzone)
+            return { misses: 0, quad: state.quad };
         const weight = 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 > PsScanConfig.liveRearmMovement,
-            misses: 0,
-            quad,
-            raw: detected,
-            stableMs: movement <= PsScanConfig.liveStillMovement ? state.stableMs + elapsedMs : 0,
-        };
-    }
-    static progress(state) {
-        if (!state.isArmed || state.quad === null)
-            return 0;
-        return Math.min(1, state.stableMs / PsScanConfig.autoCaptureMs);
+        return { misses: 0, quad };
     }
 }