editmamei 0.20.0 → 0.22.0

package/dist/perception/grounding-gate.js

@@ -0,0 +1,154 @@
+import { boundsOf, dist, minSignedGap, polygonArea, pointInBox, polylineIntersectsRegion, } from './grounding-geometry.js';
+const inCanvas = (p, c) => p.x >= 0 && p.x <= c.width && p.y >= 0 && p.y <= c.height;
+function gatePoint(spec) {
+    const { point: p, canvas, withinBounds, anchors } = spec;
+    const minSep = spec.minAnchorSeparation ?? 2;
+    const sep = anchors ? dist(anchors[0], anchors[1]) : undefined;
+    const measured = { x: p.x, y: p.y };
+    if (sep !== undefined)
+        measured.anchorSeparation = sep;
+    if (!inCanvas(p, canvas)) {
+        return {
+            pass: false,
+            reason: `point (${Math.round(p.x)},${Math.round(p.y)}) outside canvas ${canvas.width}x${canvas.height}`,
+            measured,
+        };
+    }
+    if (sep !== undefined && sep < minSep) {
+        return {
+            pass: false,
+            reason: `degenerate relation — anchors ${sep.toFixed(1)}px apart (< ${minSep}px)`,
+            measured,
+        };
+    }
+    if (withinBounds && !pointInBox(p, withinBounds)) {
+        return { pass: false, reason: 'point outside the expected region for this relation', measured };
+    }
+    return { pass: true, measured };
+}
+function gateOffsetCurve(spec) {
+    const { curve, source, side, requiredMargin, exclusion, canvas } = spec;
+    const minMargin = minSignedGap(curve, source, side);
+    const sideOk = minMargin > 0;
+    const intersects = exclusion ? polylineIntersectsRegion(curve, exclusion) : false;
+    const outOfCanvas = curve.some((p) => !inCanvas(p, canvas));
+    const measured = {
+        minMargin: Math.round(minMargin * 100) / 100,
+        requiredMargin,
+        side,
+        sideOk,
+        intersectsExclusion: intersects,
+    };
+    if (!sideOk) {
+        return {
+            pass: false,
+            reason: `offset-curve on the wrong side of the source (worst gap ${minMargin.toFixed(1)}px on '${side}')`,
+            measured,
+        };
+    }
+    if (minMargin < requiredMargin) {
+        return {
+            pass: false,
+            reason: `offset-curve clearance ${minMargin.toFixed(1)}px < required ${requiredMargin}px (overlaps feature)`,
+            measured,
+        };
+    }
+    if (intersects) {
+        return { pass: false, reason: 'offset-curve enters the exclusion region', measured };
+    }
+    if (outOfCanvas) {
+        return { pass: false, reason: 'offset-curve runs off canvas', measured };
+    }
+    return { pass: true, measured };
+}
+function gateEdge(spec) {
+    const { curve, confidences, minConfidence, canvas } = spec;
+    const minConf = confidences.length ? Math.min(...confidences) : 0;
+    const outOfCanvas = curve.some((p) => !inCanvas(p, canvas));
+    const measured = { minConfidence: minConf, required: minConfidence };
+    if (confidences.length !== curve.length) {
+        return {
+            pass: false,
+            reason: `confidence count ${confidences.length} != curve points ${curve.length}`,
+            measured,
+        };
+    }
+    if (minConf < minConfidence) {
+        return {
+            pass: false,
+            reason: `edge confidence ${minConf} < required ${minConfidence} (weak/absent boundary)`,
+            measured,
+        };
+    }
+    if (outOfCanvas) {
+        return { pass: false, reason: 'edge runs off canvas', measured };
+    }
+    return { pass: true, measured };
+}
+function gateCurve(spec) {
+    const { curve, canvas } = spec;
+    const minLength = spec.minLength ?? 2;
+    let length = 0;
+    for (let k = 0; k < curve.length - 1; k++)
+        length += Math.hypot(curve[k + 1].x - curve[k].x, curve[k + 1].y - curve[k].y);
+    const outOfCanvas = curve.some((p) => !inCanvas(p, canvas));
+    const measured = {
+        points: curve.length,
+        length: Math.round(length),
+        on_canvas: !outOfCanvas,
+    };
+    if (curve.length < 2)
+        return { pass: false, reason: 'curve has fewer than 2 points', measured };
+    if (length < minLength)
+        return {
+            pass: false,
+            reason: `curve length ${Math.round(length)} < required ${minLength} (degenerate)`,
+            measured,
+        };
+    if (outOfCanvas)
+        return { pass: false, reason: 'curve runs off canvas', measured };
+    return { pass: true, measured };
+}
+function gateRegion(spec) {
+    const { polygon, canvas } = spec;
+    const maxFrac = spec.maxAreaFraction ?? 0.9;
+    const area = polygonArea(polygon);
+    const frameArea = canvas.width * canvas.height;
+    const areaFraction = frameArea > 0 ? area / frameArea : 0;
+    const b = polygon.length ? boundsOf(polygon) : undefined;
+    const outOfCanvas = b
+        ? b.left < 0 || b.top < 0 || b.right > canvas.width || b.bottom > canvas.height
+        : true;
+    const measured = {
+        area: Math.round(area),
+        areaFraction: Math.round(areaFraction * 1000) / 1000,
+    };
+    if (area <= 0) {
+        return { pass: false, reason: 'empty region', measured };
+    }
+    if (outOfCanvas) {
+        return { pass: false, reason: 'region extends off canvas', measured };
+    }
+    if (areaFraction > maxFrac) {
+        return {
+            pass: false,
+            reason: `region ${(areaFraction * 100).toFixed(0)}% of frame — implausibly large for the relation`,
+            measured,
+        };
+    }
+    return { pass: true, measured };
+}
+export function runGate(spec) {
+    switch (spec.target) {
+        case 'point':
+            return gatePoint(spec);
+        case 'region':
+            return gateRegion(spec);
+        case 'path':
+            return spec.kind === 'offset-curve'
+                ? gateOffsetCurve(spec)
+                : spec.kind === 'edge'
+                    ? gateEdge(spec)
+                    : gateCurve(spec);
+    }
+}

package/dist/perception/grounding-geometry.js

@@ -0,0 +1,132 @@
+export function dist(a, b) {
+    return Math.hypot(a.x - b.x, a.y - b.y);
+}
+export function boundsOf(poly) {
+    if (poly.length === 0)
+        throw new Error('boundsOf: empty polyline');
+    let left = Infinity, top = Infinity, right = -Infinity, bottom = -Infinity;
+    for (const p of poly) {
+        if (p.x < left)
+            left = p.x;
+        if (p.x > right)
+            right = p.x;
+        if (p.y < top)
+            top = p.y;
+        if (p.y > bottom)
+            bottom = p.y;
+    }
+    return { left, top, right, bottom };
+}
+export function interpolateCurveAt(curve, at, axis) {
+    if (curve.length === 0)
+        throw new Error('interpolateCurveAt: empty curve');
+    const other = axis === 'x' ? 'y' : 'x';
+    if (curve.length === 1)
+        return curve[0][other];
+    const sorted = [...curve].sort((a, b) => a[axis] - b[axis]);
+    if (at <= sorted[0][axis])
+        return sorted[0][other];
+    const last = sorted[sorted.length - 1];
+    if (at >= last[axis])
+        return last[other];
+    for (let i = 0; i < sorted.length - 1; i++) {
+        const a = sorted[i], b = sorted[i + 1];
+        if (at >= a[axis] && at <= b[axis]) {
+            const span = b[axis] - a[axis];
+            if (span === 0)
+                return a[other];
+            const t = (at - a[axis]) / span;
+            return a[other] + t * (b[other] - a[other]);
+        }
+    }
+    return last[other];
+}
+export function signedGapToCurve(point, curve, side) {
+    switch (side) {
+        case 'down':
+            return point.y - interpolateCurveAt(curve, point.x, 'x');
+        case 'up':
+            return interpolateCurveAt(curve, point.x, 'x') - point.y;
+        case 'right':
+            return point.x - interpolateCurveAt(curve, point.y, 'y');
+        case 'left':
+            return interpolateCurveAt(curve, point.y, 'y') - point.x;
+    }
+}
+export function minSignedGap(offset, source, side) {
+    if (offset.length === 0)
+        throw new Error('minSignedGap: empty offset curve');
+    let min = Infinity;
+    for (const p of offset) {
+        const g = signedGapToCurve(p, source, side);
+        if (g < min)
+            min = g;
+    }
+    return min;
+}
+export function polygonArea(poly) {
+    if (poly.length < 3)
+        return 0;
+    let sum = 0;
+    for (let i = 0; i < poly.length; i++) {
+        const a = poly[i], b = poly[(i + 1) % poly.length];
+        sum += a.x * b.y - b.x * a.y;
+    }
+    return Math.abs(sum) / 2;
+}
+export function pointInBox(p, box) {
+    return p.x >= box.left && p.x <= box.right && p.y >= box.top && p.y <= box.bottom;
+}
+export function pointInPolygon(p, poly) {
+    let inside = false;
+    for (let i = 0, j = poly.length - 1; i < poly.length; j = i++) {
+        const a = poly[i], b = poly[j];
+        const intersects = a.y > p.y !== b.y > p.y && p.x < ((b.x - a.x) * (p.y - a.y)) / (b.y - a.y) + a.x;
+        if (intersects)
+            inside = !inside;
+    }
+    return inside;
+}
+function pointInRegion(p, region) {
+    return region.kind === 'box' ? pointInBox(p, region.box) : pointInPolygon(p, region.polygon);
+}
+export function segmentsIntersect(p1, p2, p3, p4) {
+    const o = (a, b, c) => Math.sign((b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x));
+    const o1 = o(p1, p2, p3), o2 = o(p1, p2, p4), o3 = o(p3, p4, p1), o4 = o(p3, p4, p2);
+    return o1 !== o2 && o3 !== o4;
+}
+function regionEdges(region) {
+    if (region.kind === 'box') {
+        const { left: l, top: t, right: r, bottom: b } = region.box;
+        const c = [
+            { x: l, y: t },
+            { x: r, y: t },
+            { x: r, y: b },
+            { x: l, y: b },
+        ];
+        return [
+            [c[0], c[1]],
+            [c[1], c[2]],
+            [c[2], c[3]],
+            [c[3], c[0]],
+        ];
+    }
+    const poly = region.polygon;
+    const edges = [];
+    for (let i = 0; i < poly.length; i++)
+        edges.push([poly[i], poly[(i + 1) % poly.length]]);
+    return edges;
+}
+export function polylineIntersectsRegion(poly, region) {
+    for (const p of poly)
+        if (pointInRegion(p, region))
+            return true;
+    const edges = regionEdges(region);
+    for (let i = 0; i < poly.length - 1; i++) {
+        for (const [e1, e2] of edges) {
+            if (segmentsIntersect(poly[i], poly[i + 1], e1, e2))
+                return true;
+        }
+    }
+    return false;
+}

package/dist/perception/grounding-grid.js

@@ -0,0 +1,34 @@
+const NAMED = {
+    center: [0.5, 0.5],
+    'upper-left': [1 / 3, 1 / 3],
+    'upper-center': [0.5, 1 / 3],
+    'upper-right': [2 / 3, 1 / 3],
+    'center-left': [1 / 3, 0.5],
+    'center-right': [2 / 3, 0.5],
+    'lower-left': [1 / 3, 2 / 3],
+    'lower-center': [0.5, 2 / 3],
+    'lower-right': [2 / 3, 2 / 3],
+};
+export function frameBox(width, height) {
+    return { left: 0, top: 0, right: width, bottom: height };
+}
+export function gridPoint(box, name) {
+    let fx, fy;
+    if (name.startsWith('frac:')) {
+        const [a, b] = name.slice('frac:'.length).split(',');
+        fx = Number(a);
+        fy = Number(b);
+        if (Number.isNaN(fx) || Number.isNaN(fy))
+            throw new Error(`gridPoint: malformed '${name}' (want frac:fx,fy)`);
+    }
+    else {
+        const f = NAMED[name];
+        if (!f)
+            throw new Error(`gridPoint: unknown position '${name}' (want ${Object.keys(NAMED).join('|')} or frac:fx,fy)`);
+        [fx, fy] = f;
+    }
+    return { x: box.left + fx * (box.right - box.left), y: box.top + fy * (box.bottom - box.top) };
+}
+export function gridAnchor(box, name) {
+    return { kind: 'point', point: gridPoint(box, name) };
+}

package/dist/perception/grounding-landmarks.js

@@ -0,0 +1,40 @@
+import { LANDMARK_GROUPS, LANDMARK_ANCHORS, LANDMARK_COUNT } from '../detection/landmark-spec.js';
+const LEFT_EYE_LOWER = [263, 249, 390, 373, 374, 380, 381, 382, 362];
+const RIGHT_EYE_LOWER = [33, 7, 163, 144, 145, 153, 154, 155, 133];
+const LANDMARK_FEATURES = {
+    left_eye_lower: { as: 'polyline', indices: LEFT_EYE_LOWER },
+    right_eye_lower: { as: 'polyline', indices: RIGHT_EYE_LOWER },
+    left_eye: { as: 'polyline', indices: LANDMARK_GROUPS.leftEye },
+    right_eye: { as: 'polyline', indices: LANDMARK_GROUPS.rightEye },
+    lips_outer: { as: 'polyline', indices: LANDMARK_GROUPS.lipsOuter },
+    nose_tip: { as: 'point', index: LANDMARK_ANCHORS.noseTip },
+    chin: { as: 'point', index: LANDMARK_ANCHORS.chin },
+    between_eyes: { as: 'point', index: LANDMARK_ANCHORS.betweenEyes },
+    upper_lip_top: { as: 'point', index: LANDMARK_ANCHORS.upperLipTop },
+    lower_lip_bottom: { as: 'point', index: LANDMARK_ANCHORS.lowerLipBottom },
+};
+export const LANDMARK_FEATURE_NAMES = Object.keys(LANDMARK_FEATURES);
+export function isLandmarkFeature(feature) {
+    return feature in LANDMARK_FEATURES;
+}
+export function landmarkAnchor(det, sel) {
+    const spec = LANDMARK_FEATURES[sel.feature];
+    if (!spec)
+        return null;
+    const meshed = (det.faces ?? []).filter((f) => f.features && f.features.points.length >= LANDMARK_COUNT);
+    const face = meshed[sel.face ?? 0];
+    if (!face || !face.features)
+        return null;
+    const pts = face.features.points;
+    if (spec.as === 'point') {
+        const p = pts[spec.index];
+        return p ? { kind: 'point', point: { x: p.x, y: p.y } } : null;
+    }
+    const polyline = [];
+    for (const i of spec.indices) {
+        const p = pts[i];
+        if (p)
+            polyline.push({ x: p.x, y: p.y });
+    }
+    return polyline.length >= 2 ? { kind: 'polyline', polyline } : null;
+}