editmamei 0.19.0 → 0.22.0

package/dist/perception/grounding-locate.js

@@ -0,0 +1,341 @@
+import { decode } from 'jpeg-js';
+import { ValidationError } from '../utils/validate.js';
+import { detectActiveDoc } from '../detection/detect-active-doc.js';
+import { localizeAnchor } from './grounding-anchors.js';
+import { landmarkAnchor, isLandmarkFeature, LANDMARK_FEATURE_NAMES, } from './grounding-landmarks.js';
+import { gridAnchor, frameBox } from './grounding-grid.js';
+import { findExtremum } from './grounding-extrema.js';
+import { cornerAnchor } from './grounding-corners.js';
+import { traceEdge } from './grounding-edge-trace.js';
+import { resolve, centerOf, } from './grounding-resolver.js';
+import { runGate } from './grounding-gate.js';
+import { boundsOf } from './grounding-geometry.js';
+const POINT_RELATIONS = ['midpoint', 'centroid', 'offset'];
+const REGION_RELATIONS = ['inside', 'gap'];
+const PATH_RELATIONS = ['along', 'offset-curve', 'segment'];
+export const SUPPORTED_RELATIONS = [...POINT_RELATIONS, ...REGION_RELATIONS, ...PATH_RELATIONS];
+const DEFAULT_MIN_EDGE_CONFIDENCE = 40;
+export class LocateError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'LocateError';
+    }
+}
+const scaleBox = (b, s) => ({
+    left: b.left * s,
+    top: b.top * s,
+    right: b.right * s,
+    bottom: b.bottom * s,
+});
+const liftPt = (p, s) => ({ x: p.x / s, y: p.y / s });
+export function parseBox(v, name) {
+    if (!Array.isArray(v) || v.length !== 4 || v.some((n) => !Number.isFinite(n))) {
+        throw new ValidationError(`${name} must be [x1,y1,x2,y2] finite numbers in document pixels`);
+    }
+    const [x1, y1, x2, y2] = v;
+    return {
+        left: Math.min(x1, x2),
+        top: Math.min(y1, y2),
+        right: Math.max(x1, x2),
+        bottom: Math.max(y1, y2),
+    };
+}
+function localizeOne(a, det, exportImg, docW, docH, s, confSink) {
+    const needsImage = () => {
+        if (!exportImg)
+            throw new ValidationError(`anchor '${a.id}' (${a.kind}) needs the document image, which failed to export`);
+        return exportImg;
+    };
+    switch (a.kind) {
+        case 'face':
+            return localizeAnchor(det, {
+                kind: 'face',
+                instance: a.instance,
+                pick: a.pick,
+            });
+        case 'object': {
+            if (typeof a.label !== 'string')
+                throw new ValidationError(`object anchor '${a.id}' needs a 'label'`);
+            return localizeAnchor(det, {
+                kind: 'object',
+                label: a.label,
+                instance: a.instance,
+                pick: a.pick,
+            });
+        }
+        case 'grid': {
+            if (typeof a.at !== 'string')
+                throw new ValidationError(`grid anchor '${a.id}' needs 'at'`);
+            return gridAnchor(frameBox(docW, docH), a.at);
+        }
+        case 'extremum': {
+            const measure = a.measure;
+            if (!['brightest', 'darkest', 'most-saturated'].includes(measure)) {
+                throw new ValidationError(`extremum anchor '${a.id}' needs measure brightest|darkest|most-saturated`);
+            }
+            const region = a.region
+                ? scaleBox(parseBox(a.region, `${a.id}.region`), s)
+                : frameBox(needsImage().width, needsImage().height);
+            const e = findExtremum(needsImage(), region, measure);
+            return { kind: 'point', point: liftPt(e.point, s) };
+        }
+        case 'corner': {
+            if (!a.region)
+                throw new ValidationError(`corner anchor '${a.id}' needs a 'region' [x1,y1,x2,y2]`);
+            const region = scaleBox(parseBox(a.region, `${a.id}.region`), s);
+            let near;
+            if (a.near) {
+                if (!Array.isArray(a.near) ||
+                    a.near.length !== 2 ||
+                    !a.near.every((n) => Number.isFinite(n)))
+                    throw new ValidationError(`${a.id}.near must be [x,y] finite numbers`);
+                near = { x: a.near[0] * s, y: a.near[1] * s };
+            }
+            const c = cornerAnchor(needsImage(), region, { near });
+            return c && c.kind === 'point' ? { kind: 'point', point: liftPt(c.point, s) } : null;
+        }
+        case 'edge': {
+            const orientation = a.orientation;
+            if (orientation !== 'horizontal-edge' && orientation !== 'vertical-edge') {
+                throw new ValidationError(`edge anchor '${a.id}' needs orientation horizontal-edge|vertical-edge`);
+            }
+            if (!a.region)
+                throw new ValidationError(`edge anchor '${a.id}' needs a 'region' [x1,y1,x2,y2]`);
+            const region = scaleBox(parseBox(a.region, `${a.id}.region`), s);
+            const t = traceEdge(needsImage(), {
+                region,
+                orientation: orientation,
+                samples: typeof a.samples === 'number' ? a.samples : undefined,
+            });
+            if (t.polyline.length < 2)
+                return null;
+            confSink[a.id] = t.confidences;
+            return { kind: 'polyline', polyline: t.polyline.map((p) => liftPt(p, s)) };
+        }
+        case 'landmark': {
+            if (typeof a.feature !== 'string')
+                throw new ValidationError(`landmark anchor '${a.id}' needs a 'feature' (one of: ${LANDMARK_FEATURE_NAMES.join(', ')})`);
+            if (!isLandmarkFeature(a.feature))
+                throw new ValidationError(`landmark anchor '${a.id}' feature '${a.feature}' unknown — use one of: ${LANDMARK_FEATURE_NAMES.join(', ')}`);
+            return landmarkAnchor(det, {
+                feature: a.feature,
+                face: typeof a.face === 'number' ? a.face : undefined,
+            });
+        }
+        default:
+            throw new ValidationError(`unknown anchor kind '${a.kind}' (want face|object|grid|extremum|corner|edge|landmark)`);
+    }
+}
+function parseExclusion(relation) {
+    if (!relation.exclusion)
+        return undefined;
+    return { kind: 'box', box: parseBox(relation.exclusion, 'exclusion') };
+}
+function gateResolved(geom, relation, anchors, confSink, anchorKinds, docW, docH) {
+    const canvas = { width: docW, height: docH };
+    if (geom.target === 'region')
+        return runGate({ target: 'region', polygon: geom.polygon, canvas });
+    if (geom.target === 'point') {
+        const spec = { target: 'point', point: geom.point, canvas };
+        if (relation.type === 'midpoint') {
+            spec.anchors = [
+                centerOf(anchors[relation.anchors[0]]),
+                centerOf(anchors[relation.anchors[1]]),
+            ];
+        }
+        return runGate(spec);
+    }
+    const srcId = relation.curve ?? '';
+    const srcPrim = anchors[srcId];
+    const srcCurve = srcPrim && srcPrim.kind === 'polyline' ? srcPrim.polyline : [];
+    let edgeMeasured = {};
+    if (anchorKinds[srcId] === 'edge') {
+        const minConf = typeof relation.min_confidence === 'number'
+            ? relation.min_confidence
+            : DEFAULT_MIN_EDGE_CONFIDENCE;
+        const edgeGate = runGate({
+            target: 'path',
+            kind: 'edge',
+            curve: srcCurve,
+            confidences: confSink[srcId] ?? [],
+            minConfidence: minConf,
+            canvas,
+        });
+        if (!edgeGate.pass)
+            return edgeGate;
+        edgeMeasured = edgeGate.measured;
+    }
+    if (geom.kind === 'along') {
+        const off = geom.curve.some((p) => p.x < 0 || p.y < 0 || p.x > docW || p.y > docH);
+        const measured = {
+            ...edgeMeasured,
+            source: anchorKinds[srcId] ?? 'unknown',
+            points: geom.curve.length,
+        };
+        return off
+            ? { pass: false, reason: 'path runs off canvas', measured }
+            : { pass: true, measured };
+    }
+    const ocGate = runGate({
+        target: 'path',
+        kind: 'offset-curve',
+        curve: geom.curve,
+        source: geom.source,
+        side: geom.side,
+        requiredMargin: 1,
+        exclusion: parseExclusion(relation),
+        canvas,
+    });
+    return {
+        pass: ocGate.pass,
+        ...(ocGate.pass ? {} : { reason: ocGate.reason }),
+        measured: { ...edgeMeasured, ...ocGate.measured },
+    };
+}
+export async function resolveToGeometry(connection, client, input) {
+    const anchorSpecs = input.anchors;
+    const relation = input.relation;
+    if (!Array.isArray(anchorSpecs) || anchorSpecs.length === 0)
+        throw new ValidationError('anchors must be a non-empty array');
+    if (!relation || typeof relation !== 'object' || typeof relation.type !== 'string')
+        throw new ValidationError('relation must be an object with a "type"');
+    if (!SUPPORTED_RELATIONS.includes(relation.type)) {
+        throw new ValidationError(`relation "${relation.type}" not supported yet — use ${SUPPORTED_RELATIONS.join(' | ')}`);
+    }
+    for (const a of anchorSpecs)
+        if (typeof a?.id !== 'string' || typeof a?.kind !== 'string')
+            throw new ValidationError('each anchor needs a string "id" and "kind"');
+    const needFaces = anchorSpecs.some((a) => a.kind === 'face' || a.kind === 'landmark');
+    const needObjects = anchorSpecs.some((a) => a.kind === 'object');
+    const det = await detectActiveDoc(connection, client, {
+        faces: needFaces,
+        objects: needObjects,
+        maxDimension: input.maxDimension,
+    });
+    const docW = det.docWidth;
+    const docH = det.docHeight;
+    let exportImg = null;
+    try {
+        if (det.exportBytes.length > 0)
+            exportImg = decode(det.exportBytes, { useTArray: true, formatAsRGBA: true });
+    }
+    catch {
+        exportImg = null;
+    }
+    const s = exportImg ? exportImg.width / docW : 1;
+    const anchors = {};
+    const anchorMeta = {};
+    const confSink = {};
+    const missing = [];
+    for (const a of anchorSpecs) {
+        const prim = localizeOne(a, det.result, exportImg, docW, docH, s, confSink);
+        if (prim) {
+            anchors[a.id] = prim;
+            anchorMeta[a.id] = { kind: a.kind, center: centerOf(prim) };
+        }
+        else
+            missing.push(`${a.id} (${a.kind})`);
+    }
+    if (missing.length > 0) {
+        throw new LocateError(`Could not localize anchor(s): ${missing.join(', ')}. ` +
+            `Detection found ${det.result.faces?.length ?? 0} face(s), ${det.result.objects?.length ?? 0} object(s). ` +
+            `Try ps_detect to see what's present, or loosen the selector.`);
+    }
+    let geom;
+    try {
+        geom = resolve(relation, anchors, { frame: { width: docW, height: docH } });
+    }
+    catch (e) {
+        throw new LocateError(`Could not resolve the relation: ${e.message}`);
+    }
+    if (input.pathTransform && geom.target === 'path') {
+        const transformed = input.pathTransform(geom.curve);
+        if (Array.isArray(transformed) && transformed.length >= 2) {
+            geom = { ...geom, curve: transformed };
+        }
+    }
+    const anchorKinds = Object.fromEntries(Object.entries(anchorMeta).map(([id, m]) => [id, m.kind]));
+    const gate = gateResolved(geom, relation, anchors, confSink, anchorKinds, docW, docH);
+    return { geom, gate, anchorMeta, context: det.context, exportImg, docW, docH, s };
+}
+export const PLACEMENT_SCHEMA = {
+    type: 'object',
+    description: 'ANCHOR-RELATIONAL placement (preferred over guessing pixels): name anchors + a relation and the ' +
+        'spatial-grounding resolver computes the geometry, verified by an objective gate; the action runs ONLY if the ' +
+        'gate PASSES. For a HARD or ambiguous placement, first concur on ps_resolve_placement (review_crop: true) — a ' +
+        'read-only zoomed crop with a marker at the resolved spot — then pass the SAME anchors + relation here. See ' +
+        'ps_resolve_placement for the full anchors + relation vocabulary.',
+    properties: {
+        anchors: {
+            type: 'array',
+            description: 'Named anchors, same vocabulary as ps_resolve_placement (face/object/grid/extremum/corner/edge/landmark).',
+        },
+        relation: {
+            type: 'object',
+            description: 'The relation, same vocabulary as ps_resolve_placement.',
+        },
+        max_dimension: {
+            type: 'number',
+            minimum: 256,
+            maximum: 4096,
+            description: 'Long-edge px of the export the CV runs on (default 1024).',
+        },
+    },
+};
+const EXPECT_HINT = {
+    point: 'Use a point relation (centroid / midpoint / offset).',
+    region: 'Use a region relation (inside / gap).',
+    path: 'Use a path relation (along / offset-curve).',
+};
+export async function resolveGatedPlacement(connection, client, placement, opts) {
+    const p = (placement ?? {});
+    const loc = await resolveToGeometry(connection, client, {
+        anchors: p.anchors,
+        relation: p.relation,
+        maxDimension: p.max_dimension,
+        pathTransform: opts.pathTransform,
+    });
+    if (!loc.gate.pass) {
+        throw new LocateError(`Placement gate REJECT — ${loc.gate.reason ?? 'failed verification'}. No ${opts.label} performed; re-spec the anchors/relation.`);
+    }
+    const expects = (Array.isArray(opts.expect) ? opts.expect : [opts.expect]);
+    if (!expects.includes(loc.geom.target)) {
+        const want = expects.join(' or ');
+        const hint = expects.map((e) => EXPECT_HINT[e]).join(' ');
+        throw new LocateError(`${opts.label} placement needs a ${want} relation — resolved a '${loc.geom.target}'. ${hint}`);
+    }
+    return loc;
+}
+export async function resolveExpectedPlacement(connection, client, placement, expect, label) {
+    const gated = await resolveGatedPlacement(connection, client, placement, { expect, label });
+    const g = gated.geom;
+    const anchors = gated.anchorMeta;
+    let out;
+    if (g.target === 'point') {
+        const point = { x: Math.round(g.point.x), y: Math.round(g.point.y) };
+        out = { target: 'point', point, anchors, summary: `(${point.x},${point.y})` };
+    }
+    else if (g.target === 'region') {
+        const b = boundsOf(g.polygon);
+        const bbox = {
+            left: Math.round(b.left),
+            top: Math.round(b.top),
+            right: Math.round(b.right),
+            bottom: Math.round(b.bottom),
+        };
+        out = {
+            target: 'region',
+            bbox,
+            anchors,
+            summary: `[${bbox.left},${bbox.top},${bbox.right},${bbox.bottom}]`,
+        };
+    }
+    else {
+        if (g.curve.length < 2) {
+            throw new LocateError(`${label} placement resolved to a degenerate (<2 point) curve.`);
+        }
+        const curve = g.curve.map((pt) => ({ x: Math.round(pt.x), y: Math.round(pt.y) }));
+        out = { target: 'path', curve, anchors, summary: `${curve.length}-point path` };
+    }
+    return out;
+}

package/dist/perception/grounding-resolver.js

@@ -0,0 +1,202 @@
+import { boundsOf, dist, } from './grounding-geometry.js';
+function need(anchors, id) {
+    const a = anchors[id];
+    if (!a)
+        throw new Error(`resolve: unknown anchor '${id}'`);
+    return a;
+}
+export function centerOf(prim) {
+    if (prim.kind === 'point')
+        return prim.point;
+    const b = prim.kind === 'box' ? prim.box : boundsOf(prim.polyline);
+    return { x: (b.left + b.right) / 2, y: (b.top + b.bottom) / 2 };
+}
+export function bboxOf(prim) {
+    if (prim.kind === 'box')
+        return prim.box;
+    if (prim.kind === 'polyline')
+        return boundsOf(prim.polyline);
+    return { left: prim.point.x, top: prim.point.y, right: prim.point.x, bottom: prim.point.y };
+}
+function asCurve(prim, id) {
+    if (prim.kind !== 'polyline')
+        throw new Error(`resolve: anchor '${id}' must be a polyline for this relation`);
+    return prim.polyline;
+}
+function dimOf(prim, dim) {
+    const b = bboxOf(prim);
+    const w = b.right - b.left, h = b.bottom - b.top;
+    if (dim === 'w')
+        return w;
+    if (dim === 'h')
+        return h;
+    if (dim === 'diag')
+        return Math.hypot(w, h);
+    throw new Error(`resolve: bad frac-of dimension '${dim}' (want w|h|diag)`);
+}
+export function resolveLength(len, anchors, frameDiag) {
+    if (len.unit === 'px')
+        return len.value;
+    if (len.unit === 'frac-diag')
+        return len.value * frameDiag;
+    if (len.unit.startsWith('frac-of:')) {
+        const [, ref, dim] = len.unit.split(':');
+        if (!ref || !dim)
+            throw new Error(`resolve: malformed unit '${len.unit}' (want frac-of:<ref>:<w|h|diag>)`);
+        return len.value * dimOf(need(anchors, ref), dim);
+    }
+    throw new Error(`resolve: unknown length unit '${len.unit}'`);
+}
+const AXIS = {
+    up: { x: 0, y: -1 },
+    down: { x: 0, y: 1 },
+    left: { x: -1, y: 0 },
+    right: { x: 1, y: 0 },
+};
+function unitVector(direction, from, anchors) {
+    if (direction in AXIS)
+        return AXIS[direction];
+    const [kind, arg] = direction.split(':');
+    if (kind === 'angle') {
+        const r = (Number(arg) * Math.PI) / 180;
+        return { x: Math.cos(r), y: Math.sin(r) };
+    }
+    if (kind === 'toward' || kind === 'away') {
+        const target = centerOf(need(anchors, arg));
+        const v = { x: target.x - from.x, y: target.y - from.y };
+        const m = Math.hypot(v.x, v.y) || 1;
+        const u = { x: v.x / m, y: v.y / m };
+        return kind === 'toward' ? u : { x: -u.x, y: -u.y };
+    }
+    throw new Error(`resolve: unknown direction '${direction}'`);
+}
+export function trimByArcLength(curve, from, to) {
+    if (curve.length < 2 || (from <= 0 && to >= 1))
+        return curve;
+    const segLen = [];
+    let total = 0;
+    for (let i = 0; i < curve.length - 1; i++) {
+        const d = dist(curve[i], curve[i + 1]);
+        segLen.push(d);
+        total += d;
+    }
+    const startD = Math.max(0, from) * total, endD = Math.min(1, to) * total;
+    const at = (target) => {
+        let acc = 0;
+        for (let i = 0; i < segLen.length; i++) {
+            if (acc + segLen[i] >= target) {
+                const t = segLen[i] === 0 ? 0 : (target - acc) / segLen[i];
+                return {
+                    x: curve[i].x + t * (curve[i + 1].x - curve[i].x),
+                    y: curve[i].y + t * (curve[i + 1].y - curve[i].y),
+                };
+            }
+            acc += segLen[i];
+        }
+        return curve[curve.length - 1];
+    };
+    const out = [at(startD)];
+    let acc = 0;
+    for (let i = 0; i < curve.length; i++) {
+        if (i > 0)
+            acc += segLen[i - 1];
+        if (acc > startD && acc < endD)
+            out.push(curve[i]);
+    }
+    out.push(at(endD));
+    return out;
+}
+const boxToPolygon = (b) => [
+    { x: b.left, y: b.top },
+    { x: b.right, y: b.top },
+    { x: b.right, y: b.bottom },
+    { x: b.left, y: b.bottom },
+];
+export function resolve(relation, anchors, ctx) {
+    const frameDiag = Math.hypot(ctx.frame.width, ctx.frame.height);
+    switch (relation.type) {
+        case 'midpoint': {
+            const a = centerOf(need(anchors, relation.anchors[0]));
+            const b = centerOf(need(anchors, relation.anchors[1]));
+            const t = relation.t ?? 0.5;
+            return { target: 'point', point: { x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t } };
+        }
+        case 'centroid':
+            return { target: 'point', point: centerOf(need(anchors, relation.anchor)) };
+        case 'offset': {
+            const from = centerOf(need(anchors, relation.from));
+            const d = resolveLength(relation.distance, anchors, frameDiag);
+            const u = unitVector(relation.direction, from, anchors);
+            return { target: 'point', point: { x: from.x + u.x * d, y: from.y + u.y * d } };
+        }
+        case 'along': {
+            const curve = asCurve(need(anchors, relation.curve), relation.curve);
+            return {
+                target: 'path',
+                kind: 'along',
+                curve: trimByArcLength(curve, relation.from ?? 0, relation.to ?? 1),
+            };
+        }
+        case 'offset-curve': {
+            const source = asCurve(need(anchors, relation.curve), relation.curve);
+            const d = resolveLength(relation.distance, anchors, frameDiag);
+            const u = AXIS[relation.side];
+            const curve = source.map((p) => ({ x: p.x + u.x * d, y: p.y + u.y * d }));
+            return {
+                target: 'path',
+                kind: 'offset-curve',
+                curve,
+                source,
+                side: relation.side,
+                margin: d,
+            };
+        }
+        case 'segment': {
+            const a = centerOf(need(anchors, relation.anchors[0]));
+            const b = centerOf(need(anchors, relation.anchors[1]));
+            return { target: 'path', kind: 'along', curve: [a, b] };
+        }
+        case 'inside': {
+            const bb = bboxOf(need(anchors, relation.anchor));
+            const inset = relation.inset ? resolveLength(relation.inset, anchors, frameDiag) : 0;
+            return {
+                target: 'region',
+                polygon: boxToPolygon({
+                    left: bb.left + inset,
+                    top: bb.top + inset,
+                    right: bb.right - inset,
+                    bottom: bb.bottom - inset,
+                }),
+            };
+        }
+        case 'gap': {
+            const a = bboxOf(need(anchors, relation.anchors[0]));
+            const b = bboxOf(need(anchors, relation.anchors[1]));
+            const [l, r] = a.right <= b.left ? [a, b] : [b, a];
+            if (l.right < r.left) {
+                return {
+                    target: 'region',
+                    polygon: boxToPolygon({
+                        left: l.right,
+                        right: r.left,
+                        top: Math.max(a.top, b.top),
+                        bottom: Math.min(a.bottom, b.bottom),
+                    }),
+                };
+            }
+            const [t, bot] = a.bottom <= b.top ? [a, b] : [b, a];
+            if (t.bottom < bot.top) {
+                return {
+                    target: 'region',
+                    polygon: boxToPolygon({
+                        top: t.bottom,
+                        bottom: bot.top,
+                        left: Math.max(a.left, b.left),
+                        right: Math.min(a.right, b.right),
+                    }),
+                };
+            }
+            return { target: 'region', polygon: [] };
+        }
+    }
+}

package/dist/perception/grounding-review-crop.js

@@ -0,0 +1,85 @@
+import { boundsOf } from './grounding-geometry.js';
+function setPx(img, x, y, [r, g, b]) {
+    if (x < 0 || y < 0 || x >= img.width || y >= img.height)
+        return;
+    const i = (y * img.width + x) * 4;
+    img.data[i] = r;
+    img.data[i + 1] = g;
+    img.data[i + 2] = b;
+    img.data[i + 3] = 255;
+}
+function drawRing(img, c, radius, thick, color) {
+    const cx = Math.round(c.x), cy = Math.round(c.y);
+    const outer = radius + thick;
+    for (let dy = -outer; dy <= outer; dy++) {
+        for (let dx = -outer; dx <= outer; dx++) {
+            const d = Math.hypot(dx, dy);
+            if (d >= radius - thick && d <= radius + thick)
+                setPx(img, cx + dx, cy + dy, color);
+        }
+    }
+}
+function disc(img, c, radius, color) {
+    const cx = Math.round(c.x), cy = Math.round(c.y);
+    for (let dy = -radius; dy <= radius; dy++)
+        for (let dx = -radius; dx <= radius; dx++)
+            if (dx * dx + dy * dy <= radius * radius)
+                setPx(img, cx + dx, cy + dy, color);
+}
+function drawPolyline(img, pts, thick, color, closed = false) {
+    const r = Math.max(0, thick - 1);
+    const seq = closed && pts.length > 2 ? [...pts, pts[0]] : pts;
+    for (let i = 0; i < seq.length - 1; i++) {
+        const a = seq[i], b = seq[i + 1];
+        const steps = Math.max(1, Math.ceil(Math.hypot(b.x - a.x, b.y - a.y)));
+        for (let s = 0; s <= steps; s++) {
+            const t = s / steps;
+            disc(img, { x: a.x + t * (b.x - a.x), y: a.y + t * (b.y - a.y) }, r, color);
+        }
+    }
+}
+function placementBBox(p) {
+    const b = p.kind === 'point'
+        ? { left: p.point.x, top: p.point.y, right: p.point.x, bottom: p.point.y }
+        : boundsOf(p.kind === 'curve' ? p.curve : p.polygon);
+    return {
+        center: { x: (b.left + b.right) / 2, y: (b.top + b.bottom) / 2 },
+        extent: Math.max((b.right - b.left) / 2, (b.bottom - b.top) / 2),
+    };
+}
+export function renderReviewCrop(img, placement, opts = {}) {
+    const padding = opts.padding ?? 120;
+    const minHalf = opts.minHalfWindow ?? 140;
+    const maxHalf = opts.maxHalfWindow ?? 600;
+    const color = opts.markerColor ?? [40, 240, 90];
+    const { center, extent } = placementBBox(placement);
+    const half = Math.min(maxHalf, Math.max(minHalf, Math.round(extent + padding)));
+    const size = 2 * half + 1;
+    const ox = Math.round(center.x) - half;
+    const oy = Math.round(center.y) - half;
+    const out = { width: size, height: size, data: new Uint8Array(size * size * 4) };
+    for (let y = 0; y < size; y++) {
+        for (let x = 0; x < size; x++) {
+            const sx = ox + x, sy = oy + y;
+            const di = (y * size + x) * 4;
+            out.data[di + 3] = 255;
+            if (sx < 0 || sy < 0 || sx >= img.width || sy >= img.height)
+                continue;
+            const si = (sy * img.width + sx) * 4;
+            out.data[di] = img.data[si];
+            out.data[di + 1] = img.data[si + 1];
+            out.data[di + 2] = img.data[si + 2];
+        }
+    }
+    const toCrop = (p) => ({ x: p.x - ox, y: p.y - oy });
+    if (placement.kind === 'point') {
+        drawRing(out, toCrop(placement.point), opts.ringRadius ?? 13, opts.ringThickness ?? 2, color);
+    }
+    else if (placement.kind === 'curve') {
+        drawPolyline(out, placement.curve.map(toCrop), opts.strokeThickness ?? 2, color);
+    }
+    else {
+        drawPolyline(out, placement.polygon.map(toCrop), opts.strokeThickness ?? 2, color, true);
+    }
+    return { image: out, origin: { x: ox, y: oy }, size };
+}