editmamei 0.17.4 → 0.18.0

package/dist/perception/select-recipes.js

@@ -0,0 +1,493 @@
+import { runScript } from '../utils/run-script.js';
+import { jsNum } from '../utils/jsx.js';
+import { getContextInfo, getSelectionInfo } from '../api/extendscript/_helpers.js';
+import { computeSkyMaskFromJpeg } from './sky-ground-flood.js';
+import { loadSkyMaskAsSelection } from './sky-mask-transfer.js';
+import { Logger } from '../utils/logger.js';
+const logger = new Logger('select-recipes');
+import { buildRegionSignals, scoreRegion, } from './region-scorer.js';
+export const FACE_FEATURE_TARGETS = [
+    'face_skin',
+    'face_eyes',
+    'face_brows',
+    'face_lips',
+    'face_teeth',
+    'face_nose',
+    'face_under_eye',
+    'face_cheeks',
+];
+export const SELECT_REFERENCE_TARGETS = [
+    'sky',
+    'ground',
+    'foliage',
+    'subject',
+    'face',
+    'shadows',
+    'highlights',
+    'skin',
+    'above_horizon',
+    ...FACE_FEATURE_TARGETS,
+];
+export function isFaceFeatureTarget(t) {
+    return FACE_FEATURE_TARGETS.includes(t);
+}
+async function measure(connection) {
+    const script = `${getSelectionInfo}\nreturn getSelectionInfo();`;
+    return (await runScript(connection, script));
+}
+const INDOOR_LABELS = new Set([
+    'bed',
+    'couch',
+    'sofa',
+    'dining table',
+    'diningtable',
+    'toilet',
+    'tv',
+    'tvmonitor',
+    'microwave',
+    'oven',
+    'refrigerator',
+    'sink',
+    'laptop',
+]);
+function sceneCtx(model) {
+    let indoorObjectCount = 0;
+    for (const s of model.subjects)
+        if (INDOOR_LABELS.has(s.label))
+            indoorObjectCount++;
+    return {
+        docW: model.doc.width,
+        docH: model.doc.height,
+        horizonY: model.horizon.y,
+        horizonConfidence: model.horizon.confidence,
+        indoorObjectCount,
+    };
+}
+async function measureAndScore(connection, model, kind, composition) {
+    const info = await measure(connection);
+    const signals = buildRegionSignals({
+        has_selection: info.has_selection,
+        bounds: info.bounds ?? null,
+        area_percent: info.area_percent,
+        edge_complexity: info.edge_complexity,
+        bounds_fill_ratio: info.bounds_fill_ratio,
+    }, sceneCtx(model));
+    return { info, score: scoreRegion(kind, signals, composition) };
+}
+async function deselect(connection, snippet) {
+    try {
+        await runScript(connection, await snippet.build('deselect'));
+    }
+    catch {
+    }
+}
+async function gateResult(connection, snippet, target, method, info, score, detail) {
+    if (!score.passed) {
+        await deselect(connection, snippet);
+    }
+    return {
+        target,
+        method,
+        passed: score.passed,
+        confidence: score.confidence,
+        reasons: score.reasons,
+        selection_info: score.passed ? info : undefined,
+        detail,
+    };
+}
+async function bestOf(connection, snippet, model, kind, composition, target, candidates, detail = {}) {
+    let winner = null;
+    for (const c of candidates) {
+        try {
+            await c.produce();
+        }
+        catch {
+            continue;
+        }
+        const { score } = await measureAndScore(connection, model, kind, composition);
+        if (!winner || score.confidence > winner.confidence)
+            winner = { c, confidence: score.confidence };
+    }
+    if (!winner) {
+        await deselect(connection, snippet);
+        return {
+            target,
+            method: 'none',
+            passed: false,
+            confidence: 0,
+            reasons: ['no method produced a selection'],
+            detail,
+        };
+    }
+    await winner.c.produce();
+    const { info, score } = await measureAndScore(connection, model, kind, composition);
+    return gateResult(connection, snippet, target, winner.c.method, info, score, detail);
+}
+function thresholdSkyScript(level, seedX, seedY) {
+    return `
+    // __mcp_scene_thr__ region-select glue
+    ${getContextInfo}
+    function cTID(s){ return app.charIDToTypeID(s); }
+    function sTID(s){ return app.stringIDToTypeID(s); }
+    if (app.documents.length === 0) { throw new Error('No active document'); }
+    var doc = app.activeDocument;
+    var __mk = new ActionDescriptor();
+    var __ref = new ActionReference();
+    __ref.putClass(sTID('adjustmentLayer'));
+    __mk.putReference(cTID('null'), __ref);
+    var __type = new ActionDescriptor();
+    __type.putInteger(cTID('Lvl '), ${jsNum(level, 128)});
+    var __using = new ActionDescriptor();
+    __using.putObject(cTID('Type'), cTID('Thrs'), __type);
+    __mk.putObject(cTID('Usng'), sTID('adjustmentLayer'), __using);
+    app.executeAction(cTID('Mk  '), __mk, DialogModes.NO);
+    var __adj = doc.activeLayer;
+    var __wand = new ActionDescriptor();
+    var __wref = new ActionReference();
+    __wref.putProperty(cTID('Chnl'), cTID('fsel'));
+    __wand.putReference(cTID('null'), __wref);
+    var __pt = new ActionDescriptor();
+    __pt.putUnitDouble(cTID('Hrzn'), cTID('#Pxl'), ${jsNum(seedX, 0)});
+    __pt.putUnitDouble(cTID('Vrtc'), cTID('#Pxl'), ${jsNum(seedY, 0)});
+    __wand.putObject(cTID('T   '), cTID('Pnt '), __pt);
+    __wand.putInteger(cTID('Tlrn'), 32);
+    __wand.putBoolean(cTID('AntA'), true);
+    __wand.putBoolean(cTID('Mrgd'), true);
+    app.executeAction(cTID('setd'), __wand, DialogModes.NO);
+    try { __adj.remove(); } catch (eRm) {}
+    return { ok: true };
+  `;
+}
+function posterizeRegionScript(seedX, seedY) {
+    return `
+    // __mcp_scene_pst__ region-select glue
+    ${getContextInfo}
+    function cTID(s){ return app.charIDToTypeID(s); }
+    function sTID(s){ return app.stringIDToTypeID(s); }
+    if (app.documents.length === 0) { throw new Error('No active document'); }
+    var doc = app.activeDocument;
+    var __mk = new ActionDescriptor();
+    var __ref = new ActionReference();
+    __ref.putClass(sTID('adjustmentLayer'));
+    __mk.putReference(cTID('null'), __ref);
+    var __type = new ActionDescriptor();
+    __type.putInteger(cTID('Lvls'), 3);
+    var __using = new ActionDescriptor();
+    __using.putObject(cTID('Type'), cTID('Pstr'), __type);
+    __mk.putObject(cTID('Usng'), sTID('adjustmentLayer'), __using);
+    app.executeAction(cTID('Mk  '), __mk, DialogModes.NO);
+    var __adj = doc.activeLayer;
+    var __wand = new ActionDescriptor();
+    var __wref = new ActionReference();
+    __wref.putProperty(cTID('Chnl'), cTID('fsel'));
+    __wand.putReference(cTID('null'), __wref);
+    var __pt = new ActionDescriptor();
+    __pt.putUnitDouble(cTID('Hrzn'), cTID('#Pxl'), ${jsNum(seedX, 0)});
+    __pt.putUnitDouble(cTID('Vrtc'), cTID('#Pxl'), ${jsNum(seedY, 0)});
+    __wand.putObject(cTID('T   '), cTID('Pnt '), __pt);
+    __wand.putInteger(cTID('Tlrn'), 32);
+    __wand.putBoolean(cTID('AntA'), true);
+    __wand.putBoolean(cTID('Mrgd'), true);
+    app.executeAction(cTID('setd'), __wand, DialogModes.NO);
+    try { __adj.remove(); } catch (eRm) {}
+    return { ok: true };
+  `;
+}
+function skySeed(model) {
+    return {
+        x: Math.round(model.doc.width / 2),
+        y: Math.max(1, Math.round(model.doc.height * 0.06)),
+    };
+}
+export async function resolveSelection(connection, snippet, model, target, opts = {}) {
+    if (isFaceFeatureTarget(target)) {
+        return resolveFaceFeature(connection, snippet, target, target.slice('face_'.length), opts);
+    }
+    switch (target) {
+        case 'sky':
+            return resolveSky(connection, snippet, model, opts.composition, opts.skyCtx);
+        case 'ground':
+            return resolveGround(connection, snippet, model, opts.composition);
+        case 'foliage':
+            return resolveFoliage(connection, snippet, model, opts.composition);
+        case 'shadows':
+            return resolveLuminance(connection, snippet, model, 'shadows', opts.composition);
+        case 'highlights':
+            return resolveLuminance(connection, snippet, model, 'highlights', opts.composition);
+        case 'skin':
+            return resolveSkin(connection, snippet, model, opts.composition);
+        case 'subject':
+            return resolveSubject(connection, snippet, model, opts);
+        case 'face':
+            return resolveFace(connection, snippet, model, opts);
+        case 'above_horizon':
+            return resolveAboveHorizon(connection, snippet, model, opts.composition);
+        default:
+            throw new Error(`Unknown select-by-reference target: ${String(target)}`);
+    }
+}
+async function produceThresholdSky(connection, model) {
+    const skyRecipe = model.regions.find((r) => r.kind === 'sky');
+    const level = skyRecipe && skyRecipe.recipe.kind === 'threshold_white' ? skyRecipe.recipe.level : 128;
+    const seed = skySeed(model);
+    await runScript(connection, thresholdSkyScript(level, seed.x, seed.y));
+    return { level, seed };
+}
+async function resolveSky(connection, snippet, model, composition, skyCtx) {
+    if (skyCtx) {
+        try {
+            const { mask, width, height } = computeSkyMaskFromJpeg(skyCtx.exportBytes, skyCtx.boxes);
+            await loadSkyMaskAsSelection(connection, mask, width, height, skyCtx.docW, skyCtx.docH);
+            const { info, score } = await measureAndScore(connection, model, 'sky', composition);
+            if (score.passed) {
+                return gateResult(connection, snippet, 'sky', 'sky_ground_flood', info, score, {});
+            }
+        }
+        catch (e) {
+            logger.warn(`sky_ground_flood failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+    return bestOf(connection, snippet, model, 'sky', composition, 'sky', [
+        {
+            method: 'threshold_white',
+            produce: async () => {
+                await produceThresholdSky(connection, model);
+            },
+        },
+        {
+            method: 'sensei_select_sky',
+            produce: async () => {
+                await runScript(connection, await snippet.build('selectSky', { sampleAllLayers: true, selectionType: 'replace' }));
+            },
+        },
+    ]);
+}
+async function resolveGround(connection, snippet, model, composition) {
+    await produceThresholdSky(connection, model);
+    const sky = await measureAndScore(connection, model, 'sky', composition);
+    if (!sky.score.passed) {
+        await deselect(connection, snippet);
+        return {
+            target: 'ground',
+            method: 'invert_sky_minus_subjects',
+            passed: false,
+            confidence: 0,
+            reasons: ['no confident sky to invert', ...sky.score.reasons],
+            detail: { note: 'ground = invert(confident sky) − subjects; no confident sky found' },
+        };
+    }
+    await runScript(connection, await snippet.build('invertSelection'));
+    for (const s of model.subjects) {
+        const [l, t, r, b] = s.bbox;
+        await runScript(connection, await snippet.build('selectRectangle', {
+            left: l,
+            top: t,
+            right: r,
+            bottom: b,
+            featherPx: 0,
+            selectionType: 'subtract',
+        }));
+    }
+    const { info, score } = await measureAndScore(connection, model, 'ground', composition);
+    return gateResult(connection, snippet, 'ground', 'invert_sky_minus_subjects', info, score, {
+        subjects_subtracted: model.subjects.length,
+    });
+}
+async function resolveFoliage(connection, snippet, model, composition) {
+    const seedX = Math.round(model.doc.width / 2);
+    const seedY = Math.round(model.doc.height * 0.8);
+    await runScript(connection, posterizeRegionScript(seedX, seedY));
+    const { info, score } = await measureAndScore(connection, model, 'foliage', composition);
+    return gateResult(connection, snippet, 'foliage', 'posterize_region', info, score, {
+        seed: { x: seedX, y: seedY },
+    });
+}
+async function resolveLuminance(connection, snippet, model, band, composition) {
+    await runScript(connection, await snippet.build('selectLuminanceRange', {
+        mode: band,
+        fuzziness: 40,
+        selectionType: 'replace',
+    }));
+    const { info, score } = await measureAndScore(connection, model, band, composition);
+    return gateResult(connection, snippet, band, 'luminance_range', info, score, { band });
+}
+async function resolveSkin(connection, snippet, model, composition) {
+    await runScript(connection, await snippet.build('selectColorPreset', {
+        preset: 'skin_tones',
+        fuzziness: 40,
+        useFaces: false,
+        selectionType: 'replace',
+    }));
+    const person = model.subjects.find((s) => s.label === 'person');
+    const box = person?.bbox ?? model.faces.find((f) => f.is_primary)?.bbox;
+    let intersected = false;
+    if (box) {
+        const [l, t, r, b] = box;
+        await runScript(connection, await snippet.build('selectRectangle', {
+            left: l,
+            top: t,
+            right: r,
+            bottom: b,
+            featherPx: 0,
+            selectionType: 'intersect',
+        }));
+        intersected = true;
+    }
+    const { info, score } = await measureAndScore(connection, model, 'skin', composition);
+    return gateResult(connection, snippet, 'skin', 'color_range_skin_∩_box', info, score, {
+        intersected_with_box: intersected,
+    });
+}
+async function resolveSubject(connection, snippet, model, opts) {
+    const box = pickSubjectBox(model, opts);
+    if (!box) {
+        const seen = [...new Set(model.subjects.map((s) => s.label))].sort();
+        return {
+            target: 'subject',
+            method: 'none',
+            passed: false,
+            confidence: 0,
+            reasons: [`no subject${opts.label ? ` for label "${opts.label}"` : ''}`],
+            detail: { detected: seen },
+        };
+    }
+    if (opts.proRefine) {
+        const ok = await opts.proRefine({
+            kind: 'subject',
+            label: box.label,
+            instance: labelRelativeInstance(model, box, opts.instance),
+            box: box.bbox,
+        });
+        if (ok) {
+            const { info, score } = await measureAndScore(connection, model, 'subject', opts.composition);
+            return gateResult(connection, snippet, 'subject', 'pro_refine', info, score, {
+                label: box.label,
+                box: box.bbox,
+            });
+        }
+    }
+    const cx = Math.round((box.bbox[0] + box.bbox[2]) / 2);
+    const cy = Math.round((box.bbox[1] + box.bbox[3]) / 2);
+    await runScript(connection, posterizeRegionScript(cx, cy));
+    const { info, score } = await measureAndScore(connection, model, 'subject', opts.composition);
+    return gateResult(connection, snippet, 'subject', 'box_posterize_wand', info, score, {
+        label: box.label,
+        box: box.bbox,
+        seed: { x: cx, y: cy },
+    });
+}
+async function resolveFace(connection, snippet, model, opts) {
+    const face = model.faces.find((f) => f.is_primary) ?? model.faces[0];
+    if (!face) {
+        return {
+            target: 'face',
+            method: 'none',
+            passed: false,
+            confidence: 0,
+            reasons: ['no face detected'],
+            detail: {},
+        };
+    }
+    if (opts.proRefine) {
+        const ok = await opts.proRefine({ kind: 'face', box: face.bbox });
+        if (ok) {
+            const { info, score } = await measureAndScore(connection, model, 'face', opts.composition);
+            return gateResult(connection, snippet, 'face', 'pro_refine', info, score, { box: face.bbox });
+        }
+    }
+    const [l, t, r2, b] = face.bbox;
+    const feather = Math.max(4, Math.round(Math.min(r2 - l, b - t) * 0.08));
+    await runScript(connection, await snippet.build('selectEllipse', {
+        left: l,
+        top: t,
+        right: r2,
+        bottom: b,
+        featherPx: feather,
+        antiAlias: true,
+        selectionType: 'replace',
+    }));
+    const { info, score } = await measureAndScore(connection, model, 'face', opts.composition);
+    return gateResult(connection, snippet, 'face', 'face_box_ellipse', info, score, {
+        box: face.bbox,
+        feather,
+    });
+}
+async function resolveFaceFeature(connection, snippet, target, feature, opts) {
+    if (!opts.proRefine) {
+        return {
+            target,
+            method: 'none',
+            passed: false,
+            confidence: 0,
+            reasons: ['face-feature selection needs the Pro face mesh (not available in this edition)'],
+            detail: { feature },
+        };
+    }
+    const ok = await opts.proRefine({ kind: 'face_feature', feature });
+    if (!ok) {
+        await deselect(connection, snippet);
+        return {
+            target,
+            method: 'face_mesh',
+            passed: false,
+            confidence: 0,
+            reasons: ['no face mesh resolved, or the feature could not be built from the landmarks'],
+            detail: { feature },
+        };
+    }
+    const info = await measure(connection);
+    const passed = info.has_selection === true && (info.area_percent ?? 0) > 0;
+    if (!passed)
+        await deselect(connection, snippet);
+    return {
+        target,
+        method: 'face_mesh',
+        passed,
+        confidence: passed ? 1 : 0,
+        reasons: passed ? ['mesh polygon selection'] : ['mesh produced an empty selection'],
+        selection_info: passed ? info : undefined,
+        detail: { feature },
+    };
+}
+async function resolveAboveHorizon(connection, snippet, model, composition) {
+    const y = Math.max(1, Math.min(model.doc.height, model.horizon.y));
+    await runScript(connection, await snippet.build('selectRectangle', {
+        left: 0,
+        top: 0,
+        right: model.doc.width,
+        bottom: y,
+        featherPx: Math.max(2, Math.round(model.doc.height * 0.01)),
+        selectionType: 'replace',
+    }));
+    const { info, score } = await measureAndScore(connection, model, 'above_horizon', composition);
+    return gateResult(connection, snippet, 'above_horizon', 'rectangle_to_horizon', info, score, {
+        horizon_y: y,
+    });
+}
+function labelRelativeInstance(model, box, requested) {
+    if (typeof requested !== 'number')
+        return undefined;
+    const sameLabel = model.subjects
+        .filter((s) => s.label === box.label)
+        .sort((a, b) => a.bbox[0] - b.bbox[0]);
+    const idx = sameLabel.findIndex((s) => s.bbox === box.bbox);
+    return idx >= 0 ? idx : requested;
+}
+function pickSubjectBox(model, opts) {
+    let pool = model.subjects;
+    if (opts.label)
+        pool = pool.filter((s) => s.label === opts.label);
+    if (pool.length === 0)
+        return null;
+    if (typeof opts.instance === 'number') {
+        const byLeft = [...pool].sort((a, b) => a.bbox[0] - b.bbox[0]);
+        const s = byLeft[opts.instance];
+        return s ? { label: s.label, bbox: s.bbox } : null;
+    }
+    const main = pool.find((s) => s.is_main);
+    const chosen = main ?? [...pool].sort((a, b) => boxAreaOf(b.bbox) - boxAreaOf(a.bbox))[0];
+    return { label: chosen.label, bbox: chosen.bbox };
+}
+function boxAreaOf(b) {
+    return Math.max(0, b[2] - b[0]) * Math.max(0, b[3] - b[1]);
+}