@pixerate/editor 0.199.0 → 0.200.0

package/dist/image-editor/index.js

@@ -3049,8 +3049,9 @@ var GridGraph = class {
 var WORK_SIZE = 512;
 var workCache = /* @__PURE__ */ new WeakMap();
 function workImage(pixels, maxSide = WORK_SIZE) {
-  const cached = workCache.get(pixels.data);
-  if (cached && cached.maxSide === maxSide && cached.work.sourceWidth === pixels.width && cached.work.sourceHeight === pixels.height) return cached.work;
+  const sizes = workCache.get(pixels.data);
+  const cached = sizes?.get(maxSide);
+  if (cached && cached.sourceWidth === pixels.width && cached.sourceHeight === pixels.height) return cached;
   const { width: W, height: H, data } = pixels;
   const scale = Math.min(1, maxSide / Math.max(W, H));
   const w = Math.max(1, Math.round(W * scale));
@@ -3079,7 +3080,8 @@ function workImage(pixels, maxSide = WORK_SIZE) {
     rgb[i * 3 + 2] = sum[i * 3 + 2] / c;
   }
   const work = { sourceWidth: W, sourceHeight: H, width: w, height: h, scale: w / W, rgb };
-  workCache.set(pixels.data, { maxSide, work });
+  if (sizes) sizes.set(maxSide, work);
+  else workCache.set(pixels.data, /* @__PURE__ */ new Map([[maxSide, work]]));
   return work;
 }
 var GAMMA = 50;
@@ -3875,6 +3877,342 @@ function findSubject(pixels, options = {}) {
   return { selection: upscaleRegion(work, pixels, roi, label, options.enhanceEdge ?? false) };
 }
 
+// src/image-editor/selection/refine.ts
+var DEFAULT_REFINE_EDGE_PARAMS = {
+  radius: 0,
+  smartRadius: false,
+  smooth: 0,
+  feather: 0,
+  contrast: 0,
+  shiftEdge: 0
+};
+var GUIDED_FILTER_EPS = 1e-4;
+var fin = (v, d) => typeof v === "number" && Number.isFinite(v) ? v : d;
+function normalizeRefineEdgeParams(p = {}) {
+  return {
+    radius: Math.min(250, Math.max(0, fin(p.radius, 0))),
+    smartRadius: p.smartRadius === true,
+    smooth: Math.min(100, Math.max(0, fin(p.smooth, 0))),
+    feather: Math.min(1e3, Math.max(0, fin(p.feather, 0))),
+    contrast: Math.min(100, Math.max(0, fin(p.contrast, 0))),
+    shiftEdge: Math.min(100, Math.max(-100, fin(p.shiftEdge, 0)))
+  };
+}
+var gfRadius = (p) => Math.min(64, Math.max(1, Math.ceil(p.radius)));
+var smoothSigma = (p) => p.smooth / 100 * 4;
+var featherSigma = (p) => p.feather / 2;
+function shiftAmount(p) {
+  const px2 = p.shiftEdge / 100 * Math.max(p.radius, 4);
+  return Number.isFinite(px2) ? Math.min(64, Math.max(-64, px2)) : 0;
+}
+function refineEdgeHalo(params = {}) {
+  const p = normalizeRefineEdgeParams(params);
+  const g = gfRadius(p);
+  const edge = p.radius > 0 ? Math.max(Math.ceil(p.radius), 2 * g + (p.smartRadius ? g + 1 : 0)) : 0;
+  return edge + Math.ceil(3 * smoothSigma(p)) + Math.ceil(3 * featherSigma(p)) + Math.ceil(Math.abs(shiftAmount(p))) + 2;
+}
+function boxMean(src, w, h, r) {
+  const tmp = new Float32Array(w * h);
+  const pre = new Float64Array(Math.max(w, h) + 1);
+  for (let y = 0; y < h; y++) {
+    const row = y * w;
+    for (let x = 0; x < w; x++) pre[x + 1] = pre[x] + src[row + x];
+    for (let x = 0; x < w; x++) {
+      const lo = Math.max(0, x - r);
+      const hi = Math.min(w, x + r + 1);
+      tmp[row + x] = (pre[hi] - pre[lo]) / (hi - lo);
+    }
+  }
+  const out = new Float32Array(w * h);
+  for (let x = 0; x < w; x++) {
+    for (let y = 0; y < h; y++) pre[y + 1] = pre[y] + tmp[y * w + x];
+    for (let y = 0; y < h; y++) {
+      const lo = Math.max(0, y - r);
+      const hi = Math.min(h, y + r + 1);
+      out[y * w + x] = (pre[hi] - pre[lo]) / (hi - lo);
+    }
+  }
+  return out;
+}
+function guidedFilterColor(guide, p, w, h, r, eps = GUIDED_FILTER_EPS) {
+  const n = w * h;
+  const [c0, c1, c2] = guide;
+  const prod = (a, b2) => {
+    const o = new Float32Array(n);
+    for (let i = 0; i < n; i++) o[i] = a[i] * b2[i];
+    return o;
+  };
+  const m0 = boxMean(c0, w, h, r);
+  const m1 = boxMean(c1, w, h, r);
+  const m2 = boxMean(c2, w, h, r);
+  const mp = boxMean(p, w, h, r);
+  const mip0 = boxMean(prod(c0, p), w, h, r);
+  const mip1 = boxMean(prod(c1, p), w, h, r);
+  const mip2 = boxMean(prod(c2, p), w, h, r);
+  const s00 = boxMean(prod(c0, c0), w, h, r);
+  const s01 = boxMean(prod(c0, c1), w, h, r);
+  const s02 = boxMean(prod(c0, c2), w, h, r);
+  const s11 = boxMean(prod(c1, c1), w, h, r);
+  const s12 = boxMean(prod(c1, c2), w, h, r);
+  const s22 = boxMean(prod(c2, c2), w, h, r);
+  const a0 = new Float32Array(n);
+  const a1 = new Float32Array(n);
+  const a2 = new Float32Array(n);
+  const b = new Float32Array(n);
+  for (let i = 0; i < n; i++) {
+    const u0 = m0[i], u1 = m1[i], u2 = m2[i], up = mp[i];
+    const rr = s00[i] - u0 * u0 + eps;
+    const rg = s01[i] - u0 * u1;
+    const rb = s02[i] - u0 * u2;
+    const gg = s11[i] - u1 * u1 + eps;
+    const gb = s12[i] - u1 * u2;
+    const bb = s22[i] - u2 * u2 + eps;
+    const v0 = mip0[i] - u0 * up;
+    const v1 = mip1[i] - u1 * up;
+    const v2 = mip2[i] - u2 * up;
+    const i00 = gg * bb - gb * gb;
+    const i01 = gb * rb - rg * bb;
+    const i02 = rg * gb - gg * rb;
+    const i11 = rr * bb - rb * rb;
+    const i12 = rb * rg - rr * gb;
+    const i22 = rr * gg - rg * rg;
+    const det = rr * i00 + rg * i01 + rb * i02;
+    let x0 = 0, x1 = 0, x2 = 0;
+    if (Math.abs(det) >= 1e-30) {
+      x0 = (i00 * v0 + i01 * v1 + i02 * v2) / det;
+      x1 = (i01 * v0 + i11 * v1 + i12 * v2) / det;
+      x2 = (i02 * v0 + i12 * v1 + i22 * v2) / det;
+    }
+    a0[i] = x0;
+    a1[i] = x1;
+    a2[i] = x2;
+    b[i] = up - x0 * u0 - x1 * u1 - x2 * u2;
+  }
+  const ma0 = boxMean(a0, w, h, r);
+  const ma1 = boxMean(a1, w, h, r);
+  const ma2 = boxMean(a2, w, h, r);
+  const mb = boxMean(b, w, h, r);
+  const out = new Float32Array(n);
+  for (let i = 0; i < n; i++) out[i] = ma0[i] * c0[i] + ma1[i] * c1[i] + ma2[i] * c2[i] + mb[i];
+  return out;
+}
+function edgeWidth(guide, w, h, r) {
+  const n = w * h;
+  const y = new Float32Array(n);
+  for (let i = 0; i < n; i++) y[i] = 0.299 * guide[0][i] + 0.587 * guide[1][i] + 0.114 * guide[2][i];
+  const g = new Float32Array(n);
+  for (let yy = 0; yy < h; yy++) {
+    for (let xx = 0; xx < w; xx++) {
+      const gx = (y[yy * w + Math.min(w - 1, xx + 1)] - y[yy * w + Math.max(0, xx - 1)]) / 2;
+      const gy = (y[Math.min(h - 1, yy + 1) * w + xx] - y[Math.max(0, yy - 1) * w + xx]) / 2;
+      g[yy * w + xx] = Math.sqrt(gx * gx + gy * gy);
+    }
+  }
+  const gm = greyMorphology(g, w, h, r, true);
+  const hi = greyMorphology(y, w, h, r, true);
+  const lo = greyMorphology(y, w, h, r, false);
+  const out = new Float32Array(n);
+  for (let i = 0; i < n; i++) out[i] = (hi[i] - lo[i]) / Math.max(gm[i], 1e-4);
+  return out;
+}
+function refineCoverage(guide, m, w, h, params = {}) {
+  const p = normalizeRefineEdgeParams(params);
+  let a = Float32Array.from(m);
+  if (p.radius > 0 && guide) {
+    const n = w * h;
+    const boundary = new Uint8Array(n);
+    let any = false;
+    for (let y = 0; y < h; y++) {
+      for (let x = 0; x < w; x++) {
+        const i = y * w + x;
+        const v = m[i] >= 0.5;
+        const diff = x > 0 && m[i - 1] >= 0.5 !== v || x + 1 < w && m[i + 1] >= 0.5 !== v || y > 0 && m[i - w] >= 0.5 !== v || y + 1 < h && m[i + w] >= 0.5 !== v;
+        if (diff) {
+          boundary[i] = 1;
+          any = true;
+        }
+      }
+    }
+    if (any) {
+      const dist = distanceTransform(boundary, w, h);
+      const r = gfRadius(p);
+      const q = guidedFilterColor(guide, m, w, h, r);
+      const widths = p.smartRadius ? edgeWidth(guide, w, h, r) : null;
+      for (let i = 0; i < n; i++) {
+        const reff = widths ? Math.min(Math.max(p.radius, 1.5), Math.max(1.5, widths[i])) : p.radius;
+        const wgt = Math.min(1, Math.max(0, reff + 1 - dist[i]));
+        if (wgt > 0) {
+          const qi = Math.min(1, Math.max(0, q[i]));
+          a[i] = m[i] + (qi - m[i]) * wgt;
+        }
+      }
+    }
+  }
+  const ss = smoothSigma(p);
+  if (ss >= 0.3) {
+    a = gaussianBlur(a, w, h, ss, "clamp");
+    const gain = 1 + ss;
+    for (let i = 0; i < a.length; i++) a[i] = Math.min(1, Math.max(0, (a[i] - 0.5) * gain + 0.5));
+  }
+  a = gaussianBlur(a, w, h, featherSigma(p), "clamp");
+  if (p.contrast > 0) {
+    const gain = 1 / (1 - 0.99 * p.contrast / 100);
+    for (let i = 0; i < a.length; i++) a[i] = Math.min(1, Math.max(0, (a[i] - 0.5) * gain + 0.5));
+  }
+  const amount = shiftAmount(p);
+  if (Math.abs(amount) >= 1e-4) a = shiftCoverage(a, w, h, amount);
+  return a;
+}
+function guidePlanes(pixels, win) {
+  const box = win ?? { x: 0, y: 0, width: pixels.width, height: pixels.height };
+  const n = box.width * box.height;
+  const r = new Float32Array(n);
+  const g = new Float32Array(n);
+  const b = new Float32Array(n);
+  const d = pixels.data;
+  for (let y = 0; y < box.height; y++) {
+    for (let x = 0; x < box.width; x++) {
+      const i = y * box.width + x;
+      const p = ((box.y + y) * pixels.width + box.x + x) * 4;
+      r[i] = d[p] / 255;
+      g[i] = d[p + 1] / 255;
+      b[i] = d[p + 2] / 255;
+    }
+  }
+  return [r, g, b];
+}
+function refineSelection(pixels, mask, params = {}) {
+  const p = normalizeRefineEdgeParams(params);
+  if (pixels && (pixels.width !== mask.width || pixels.height !== mask.height)) {
+    throw new Error("Refine Edge needs pixels the size of the selection");
+  }
+  if (!mask.bounds) return mask;
+  const halo = refineEdgeHalo(p);
+  const x0 = Math.max(0, mask.bounds.x - halo);
+  const y0 = Math.max(0, mask.bounds.y - halo);
+  const x1 = Math.min(mask.width, mask.bounds.x + mask.bounds.width + halo);
+  const y1 = Math.min(mask.height, mask.bounds.y + mask.bounds.height + halo);
+  const ww = x1 - x0;
+  const wh = y1 - y0;
+  const m = new Float32Array(ww * wh);
+  for (let y = 0; y < wh; y++) {
+    const src = (y0 + y) * mask.width + x0;
+    for (let x = 0; x < ww; x++) m[y * ww + x] = mask.data[src + x] / 255;
+  }
+  const guide = pixels && p.radius > 0 ? guidePlanes(pixels, { x: x0, y: y0, width: ww, height: wh }) : null;
+  const refined = refineCoverage(guide, m, ww, wh, p);
+  const out = new Uint8Array(mask.width * mask.height);
+  for (let y = 0; y < wh; y++) {
+    const dst = (y0 + y) * mask.width + x0;
+    for (let x = 0; x < ww; x++) out[dst + x] = coverageToByte(refined[y * ww + x]);
+  }
+  return createSelectionMask(mask.width, mask.height, out);
+}
+
+// src/image-editor/selection/segment/guided.ts
+function workPlanes(work) {
+  const n = work.width * work.height;
+  const planes = [new Float32Array(n), new Float32Array(n), new Float32Array(n)];
+  for (let i = 0; i < n; i++) for (let c = 0; c < 3; c++) planes[c][i] = work.rgb[i * 3 + c] / 255;
+  return planes;
+}
+function workLuma(work) {
+  const n = work.width * work.height;
+  const out = new Float32Array(n);
+  const { rgb } = work;
+  for (let i = 0; i < n; i++) out[i] = (0.299 * rgb[i * 3] + 0.587 * rgb[i * 3 + 1] + 0.114 * rgb[i * 3 + 2]) / 255;
+  return out;
+}
+function softMaskToSelection(work, mask) {
+  const { sourceWidth: W, sourceHeight: H, width: w, height: h, scale } = work;
+  const out = new Uint8Array(W * H);
+  const col = new Int32Array(W);
+  const fx = new Float32Array(W);
+  for (let X = 0; X < W; X++) {
+    const u = Math.min(w - 1, Math.max(0, (X + 0.5) * scale - 0.5));
+    col[X] = Math.min(w - 2, Math.floor(u));
+    fx[X] = u - col[X];
+    if (w === 1) {
+      col[X] = 0;
+      fx[X] = 0;
+    }
+  }
+  for (let Y = 0; Y < H; Y++) {
+    const v = Math.min(h - 1, Math.max(0, (Y + 0.5) * scale - 0.5));
+    const j = h === 1 ? 0 : Math.min(h - 2, Math.floor(v));
+    const fy = h === 1 ? 0 : v - j;
+    const r0 = j * w;
+    const r1 = h === 1 ? r0 : r0 + w;
+    for (let X = 0; X < W; X++) {
+      const i = col[X];
+      const i1 = w === 1 ? i : i + 1;
+      const t = fx[X];
+      const m = (mask[r0 + i] * (1 - t) + mask[r0 + i1] * t) * (1 - fy) + (mask[r1 + i] * (1 - t) + mask[r1 + i1] * t) * fy;
+      out[Y * W + X] = Math.round(Math.min(1, Math.max(0, m)) * 255);
+    }
+  }
+  return selectionFromRegion(W, H, { x: 0, y: 0, width: W, height: H }, out);
+}
+
+// src/image-editor/selection/segment/focus.ts
+var FOCUS_SIZE = 1024;
+function estimateNoise(luma2, w, h) {
+  if (w < 3 || h < 3) return 0;
+  let sum = 0;
+  for (let y = 1; y < h - 1; y++) {
+    for (let x = 1; x < w - 1; x++) {
+      const i = y * w + x;
+      const v = luma2[i - w - 1] - 2 * luma2[i - w] + luma2[i - w + 1] - 2 * luma2[i - 1] + 4 * luma2[i] - 2 * luma2[i + 1] + luma2[i + w - 1] - 2 * luma2[i + w] + luma2[i + w + 1];
+      sum += Math.abs(v);
+    }
+  }
+  return Math.sqrt(Math.PI / 2) * sum / (6 * (w - 2) * (h - 2));
+}
+function focusArea(pixels, options = {}) {
+  const work = workImage(pixels, FOCUS_SIZE);
+  const { width: w, height: h, scale } = work;
+  const n = w * h;
+  const luma2 = workLuma(work);
+  const sigma = estimateNoise(luma2, w, h);
+  const noise = Math.min(100, Math.max(0, options.noise ?? 0));
+  const floor = 2 * sigma * (1 + noise / 25);
+  const detail = new Float32Array(n);
+  for (let y = 1; y < h - 1; y++) {
+    for (let x = 1; x < w - 1; x++) {
+      const i = y * w + x;
+      const lap = Math.abs(4 * luma2[i] - luma2[i - 1] - luma2[i + 1] - luma2[i - w] - luma2[i + w]);
+      const d = Math.max(0, lap - floor);
+      detail[i] = d * d;
+    }
+  }
+  const r = Math.max(2, Math.round(0.012 * Math.max(w, h)));
+  const energy = boxMean(detail, w, h, r);
+  const sharp = new Float32Array(n);
+  for (let i = 0; i < n; i++) sharp[i] = Math.log1p(Math.sqrt(energy[i]) * 400);
+  const sorted = Float32Array.from(sharp).sort();
+  const top = sorted[Math.floor(n * 0.995)] || 1;
+  for (let i = 0; i < n; i++) sharp[i] = Math.min(1, sharp[i] / top);
+  const ones = new Float32Array(n).fill(1);
+  const otsu = otsuThreshold(sharp, ones);
+  const range = Math.min(100, Math.max(0, options.range ?? 50));
+  const t = Math.min(0.98, otsu * Math.pow(2, (50 - range) / 25));
+  let mask = new Float32Array(n);
+  for (let i = 0; i < n; i++) mask[i] = sharp[i] >= t ? 1 : 0;
+  const c = 2 * r;
+  const grown = boxMean(mask, w, h, c);
+  for (let i = 0; i < n; i++) grown[i] = grown[i] > 1e-3 ? 1 : 0;
+  const shrunk = boxMean(grown, w, h, c);
+  for (let i = 0; i < n; i++) mask[i] = shrunk[i] >= 0.999 ? 1 : 0;
+  const pulled = boxMean(mask, w, h, Math.max(1, Math.round(r / 2)));
+  for (let i = 0; i < n; i++) mask[i] = pulled[i] >= 0.999 ? 1 : 0;
+  const softness = Math.max(0, options.softness ?? 4) * scale;
+  if (softness > 0) {
+    const fitted = guidedFilterColor(workPlanes(work), mask, w, h, Math.max(1, Math.round(softness * 2)), 1e-3);
+    for (let i = 0; i < n; i++) mask[i] = Math.min(1, Math.max(0, fitted[i]));
+  }
+  return { selection: softMaskToSelection(work, mask), noiseLevel: Math.round(sigma * 255 * 10) / 10 };
+}
+
 // src/image-editor/layers/shape-type-ui.ts
 var DEFAULT_SHAPE_TOOL_OPTIONS = {
   kind: "rect",
@@ -4800,238 +5138,6 @@ function segmentsToSelection(width, height, results) {
   return out;
 }
 
-// src/image-editor/selection/refine.ts
-var DEFAULT_REFINE_EDGE_PARAMS = {
-  radius: 0,
-  smartRadius: false,
-  smooth: 0,
-  feather: 0,
-  contrast: 0,
-  shiftEdge: 0
-};
-var GUIDED_FILTER_EPS = 1e-4;
-var fin = (v, d) => typeof v === "number" && Number.isFinite(v) ? v : d;
-function normalizeRefineEdgeParams(p = {}) {
-  return {
-    radius: Math.min(250, Math.max(0, fin(p.radius, 0))),
-    smartRadius: p.smartRadius === true,
-    smooth: Math.min(100, Math.max(0, fin(p.smooth, 0))),
-    feather: Math.min(1e3, Math.max(0, fin(p.feather, 0))),
-    contrast: Math.min(100, Math.max(0, fin(p.contrast, 0))),
-    shiftEdge: Math.min(100, Math.max(-100, fin(p.shiftEdge, 0)))
-  };
-}
-var gfRadius = (p) => Math.min(64, Math.max(1, Math.ceil(p.radius)));
-var smoothSigma = (p) => p.smooth / 100 * 4;
-var featherSigma = (p) => p.feather / 2;
-function shiftAmount(p) {
-  const px2 = p.shiftEdge / 100 * Math.max(p.radius, 4);
-  return Number.isFinite(px2) ? Math.min(64, Math.max(-64, px2)) : 0;
-}
-function refineEdgeHalo(params = {}) {
-  const p = normalizeRefineEdgeParams(params);
-  const g = gfRadius(p);
-  const edge = p.radius > 0 ? Math.max(Math.ceil(p.radius), 2 * g + (p.smartRadius ? g + 1 : 0)) : 0;
-  return edge + Math.ceil(3 * smoothSigma(p)) + Math.ceil(3 * featherSigma(p)) + Math.ceil(Math.abs(shiftAmount(p))) + 2;
-}
-function boxMean(src, w, h, r) {
-  const tmp = new Float32Array(w * h);
-  const pre = new Float64Array(Math.max(w, h) + 1);
-  for (let y = 0; y < h; y++) {
-    const row = y * w;
-    for (let x = 0; x < w; x++) pre[x + 1] = pre[x] + src[row + x];
-    for (let x = 0; x < w; x++) {
-      const lo = Math.max(0, x - r);
-      const hi = Math.min(w, x + r + 1);
-      tmp[row + x] = (pre[hi] - pre[lo]) / (hi - lo);
-    }
-  }
-  const out = new Float32Array(w * h);
-  for (let x = 0; x < w; x++) {
-    for (let y = 0; y < h; y++) pre[y + 1] = pre[y] + tmp[y * w + x];
-    for (let y = 0; y < h; y++) {
-      const lo = Math.max(0, y - r);
-      const hi = Math.min(h, y + r + 1);
-      out[y * w + x] = (pre[hi] - pre[lo]) / (hi - lo);
-    }
-  }
-  return out;
-}
-function guidedFilterColor(guide, p, w, h, r, eps = GUIDED_FILTER_EPS) {
-  const n = w * h;
-  const [c0, c1, c2] = guide;
-  const prod = (a, b2) => {
-    const o = new Float32Array(n);
-    for (let i = 0; i < n; i++) o[i] = a[i] * b2[i];
-    return o;
-  };
-  const m0 = boxMean(c0, w, h, r);
-  const m1 = boxMean(c1, w, h, r);
-  const m2 = boxMean(c2, w, h, r);
-  const mp = boxMean(p, w, h, r);
-  const mip0 = boxMean(prod(c0, p), w, h, r);
-  const mip1 = boxMean(prod(c1, p), w, h, r);
-  const mip2 = boxMean(prod(c2, p), w, h, r);
-  const s00 = boxMean(prod(c0, c0), w, h, r);
-  const s01 = boxMean(prod(c0, c1), w, h, r);
-  const s02 = boxMean(prod(c0, c2), w, h, r);
-  const s11 = boxMean(prod(c1, c1), w, h, r);
-  const s12 = boxMean(prod(c1, c2), w, h, r);
-  const s22 = boxMean(prod(c2, c2), w, h, r);
-  const a0 = new Float32Array(n);
-  const a1 = new Float32Array(n);
-  const a2 = new Float32Array(n);
-  const b = new Float32Array(n);
-  for (let i = 0; i < n; i++) {
-    const u0 = m0[i], u1 = m1[i], u2 = m2[i], up = mp[i];
-    const rr = s00[i] - u0 * u0 + eps;
-    const rg = s01[i] - u0 * u1;
-    const rb = s02[i] - u0 * u2;
-    const gg = s11[i] - u1 * u1 + eps;
-    const gb = s12[i] - u1 * u2;
-    const bb = s22[i] - u2 * u2 + eps;
-    const v0 = mip0[i] - u0 * up;
-    const v1 = mip1[i] - u1 * up;
-    const v2 = mip2[i] - u2 * up;
-    const i00 = gg * bb - gb * gb;
-    const i01 = gb * rb - rg * bb;
-    const i02 = rg * gb - gg * rb;
-    const i11 = rr * bb - rb * rb;
-    const i12 = rb * rg - rr * gb;
-    const i22 = rr * gg - rg * rg;
-    const det = rr * i00 + rg * i01 + rb * i02;
-    let x0 = 0, x1 = 0, x2 = 0;
-    if (Math.abs(det) >= 1e-30) {
-      x0 = (i00 * v0 + i01 * v1 + i02 * v2) / det;
-      x1 = (i01 * v0 + i11 * v1 + i12 * v2) / det;
-      x2 = (i02 * v0 + i12 * v1 + i22 * v2) / det;
-    }
-    a0[i] = x0;
-    a1[i] = x1;
-    a2[i] = x2;
-    b[i] = up - x0 * u0 - x1 * u1 - x2 * u2;
-  }
-  const ma0 = boxMean(a0, w, h, r);
-  const ma1 = boxMean(a1, w, h, r);
-  const ma2 = boxMean(a2, w, h, r);
-  const mb = boxMean(b, w, h, r);
-  const out = new Float32Array(n);
-  for (let i = 0; i < n; i++) out[i] = ma0[i] * c0[i] + ma1[i] * c1[i] + ma2[i] * c2[i] + mb[i];
-  return out;
-}
-function edgeWidth(guide, w, h, r) {
-  const n = w * h;
-  const y = new Float32Array(n);
-  for (let i = 0; i < n; i++) y[i] = 0.299 * guide[0][i] + 0.587 * guide[1][i] + 0.114 * guide[2][i];
-  const g = new Float32Array(n);
-  for (let yy = 0; yy < h; yy++) {
-    for (let xx = 0; xx < w; xx++) {
-      const gx = (y[yy * w + Math.min(w - 1, xx + 1)] - y[yy * w + Math.max(0, xx - 1)]) / 2;
-      const gy = (y[Math.min(h - 1, yy + 1) * w + xx] - y[Math.max(0, yy - 1) * w + xx]) / 2;
-      g[yy * w + xx] = Math.sqrt(gx * gx + gy * gy);
-    }
-  }
-  const gm = greyMorphology(g, w, h, r, true);
-  const hi = greyMorphology(y, w, h, r, true);
-  const lo = greyMorphology(y, w, h, r, false);
-  const out = new Float32Array(n);
-  for (let i = 0; i < n; i++) out[i] = (hi[i] - lo[i]) / Math.max(gm[i], 1e-4);
-  return out;
-}
-function refineCoverage(guide, m, w, h, params = {}) {
-  const p = normalizeRefineEdgeParams(params);
-  let a = Float32Array.from(m);
-  if (p.radius > 0 && guide) {
-    const n = w * h;
-    const boundary = new Uint8Array(n);
-    let any = false;
-    for (let y = 0; y < h; y++) {
-      for (let x = 0; x < w; x++) {
-        const i = y * w + x;
-        const v = m[i] >= 0.5;
-        const diff = x > 0 && m[i - 1] >= 0.5 !== v || x + 1 < w && m[i + 1] >= 0.5 !== v || y > 0 && m[i - w] >= 0.5 !== v || y + 1 < h && m[i + w] >= 0.5 !== v;
-        if (diff) {
-          boundary[i] = 1;
-          any = true;
-        }
-      }
-    }
-    if (any) {
-      const dist = distanceTransform(boundary, w, h);
-      const r = gfRadius(p);
-      const q = guidedFilterColor(guide, m, w, h, r);
-      const widths = p.smartRadius ? edgeWidth(guide, w, h, r) : null;
-      for (let i = 0; i < n; i++) {
-        const reff = widths ? Math.min(Math.max(p.radius, 1.5), Math.max(1.5, widths[i])) : p.radius;
-        const wgt = Math.min(1, Math.max(0, reff + 1 - dist[i]));
-        if (wgt > 0) {
-          const qi = Math.min(1, Math.max(0, q[i]));
-          a[i] = m[i] + (qi - m[i]) * wgt;
-        }
-      }
-    }
-  }
-  const ss = smoothSigma(p);
-  if (ss >= 0.3) {
-    a = gaussianBlur(a, w, h, ss, "clamp");
-    const gain = 1 + ss;
-    for (let i = 0; i < a.length; i++) a[i] = Math.min(1, Math.max(0, (a[i] - 0.5) * gain + 0.5));
-  }
-  a = gaussianBlur(a, w, h, featherSigma(p), "clamp");
-  if (p.contrast > 0) {
-    const gain = 1 / (1 - 0.99 * p.contrast / 100);
-    for (let i = 0; i < a.length; i++) a[i] = Math.min(1, Math.max(0, (a[i] - 0.5) * gain + 0.5));
-  }
-  const amount = shiftAmount(p);
-  if (Math.abs(amount) >= 1e-4) a = shiftCoverage(a, w, h, amount);
-  return a;
-}
-function guidePlanes(pixels, win) {
-  const box = win ?? { x: 0, y: 0, width: pixels.width, height: pixels.height };
-  const n = box.width * box.height;
-  const r = new Float32Array(n);
-  const g = new Float32Array(n);
-  const b = new Float32Array(n);
-  const d = pixels.data;
-  for (let y = 0; y < box.height; y++) {
-    for (let x = 0; x < box.width; x++) {
-      const i = y * box.width + x;
-      const p = ((box.y + y) * pixels.width + box.x + x) * 4;
-      r[i] = d[p] / 255;
-      g[i] = d[p + 1] / 255;
-      b[i] = d[p + 2] / 255;
-    }
-  }
-  return [r, g, b];
-}
-function refineSelection(pixels, mask, params = {}) {
-  const p = normalizeRefineEdgeParams(params);
-  if (pixels && (pixels.width !== mask.width || pixels.height !== mask.height)) {
-    throw new Error("Refine Edge needs pixels the size of the selection");
-  }
-  if (!mask.bounds) return mask;
-  const halo = refineEdgeHalo(p);
-  const x0 = Math.max(0, mask.bounds.x - halo);
-  const y0 = Math.max(0, mask.bounds.y - halo);
-  const x1 = Math.min(mask.width, mask.bounds.x + mask.bounds.width + halo);
-  const y1 = Math.min(mask.height, mask.bounds.y + mask.bounds.height + halo);
-  const ww = x1 - x0;
-  const wh = y1 - y0;
-  const m = new Float32Array(ww * wh);
-  for (let y = 0; y < wh; y++) {
-    const src = (y0 + y) * mask.width + x0;
-    for (let x = 0; x < ww; x++) m[y * ww + x] = mask.data[src + x] / 255;
-  }
-  const guide = pixels && p.radius > 0 ? guidePlanes(pixels, { x: x0, y: y0, width: ww, height: wh }) : null;
-  const refined = refineCoverage(guide, m, ww, wh, p);
-  const out = new Uint8Array(mask.width * mask.height);
-  for (let y = 0; y < wh; y++) {
-    const dst = (y0 + y) * mask.width + x0;
-    for (let x = 0; x < ww; x++) out[dst + x] = coverageToByte(refined[y * ww + x]);
-  }
-  return createSelectionMask(mask.width, mask.height, out);
-}
-
 // src/image-editor/selection/stroke.ts
 function selectionRing(sel, width, location) {
   const half = location === "center" ? width / 2 : width;
@@ -9866,6 +9972,17 @@ var ImageEditorController = class {
     this.setSelection(region, options.mode ?? "replace");
     return this.state.selection ?? null;
   }
+  /**
+   * Select › Focus Area: selects the parts of the image that are in focus (fine detail above the
+   * image's noise), fitted to its edges, combined with the selection by `mode` as one undo step.
+   * Resolves to the selection and the noise level measured (σ of luminance in levels).
+   */
+  async selectFocusArea(options = {}) {
+    const pixels = await this.requirePixels({ sample: options.sampleAllLayers === false ? "active-layer" : "composite" });
+    const { selection, noiseLevel } = focusArea(pixels, options);
+    this.setSelection(selection, options.mode ?? "replace");
+    return { selection: this.state.selection ?? null, noiseLevel };
+  }
   /**
    * Supplies the pixels the selection tools sample (natural size RGBA), e.g. decoded in a worker
    * or in a test; `null` goes back to reading the source image. Without a canvas (Node, workers)
@@ -12766,7 +12883,7 @@ var DEPTH_MASK_CONTROLS = [
 // src/image-editor/playback.ts
 var IMAGE_PLAYBACK_KIND = "layer";
 var PAINT = /^(paint_stroke|clone_stamp|heal_brush|spot_heal|dodge|burn|sponge|smudge|blur_stroke|sharpen_stroke|history_brush|set_clone_source|set_clone_transform|fill_pixels|clear_pixels|set_paint|set_retouch_options|load_mixer_brush|clean_mixer_brush)$/;
-var SELECT = /^(select_region|select_subject|select_by_color|select_all|deselect|invert_selection|select_rect|select_ellipse|select_polygon|quick_select|select_object|select_line|magic_wand|grow_selection|select_similar|reselect|select_layer_transparency|select_color_range|load_selection_from_image|load_selection_from_mask|set_selection_display|modify_selection|refine_selection|transform_selection|apply_selection_as_mask|layer_via_copy|stroke_selection|content_aware_fill|copy_pixels|cut_pixels|paste_pixels|save_selection|load_selection_from_channel|set_channel_properties|duplicate_channel|delete_channel|load_channel_from_image|set_quick_mask|path_to_selection|select_text_shape)$/;
+var SELECT = /^(select_region|select_subject|select_by_color|select_all|deselect|invert_selection|select_rect|select_ellipse|select_polygon|quick_select|select_object|select_focus_area|select_line|magic_wand|grow_selection|select_similar|reselect|select_layer_transparency|select_color_range|load_selection_from_image|load_selection_from_mask|set_selection_display|modify_selection|refine_selection|transform_selection|apply_selection_as_mask|layer_via_copy|stroke_selection|content_aware_fill|copy_pixels|cut_pixels|paste_pixels|save_selection|load_selection_from_channel|set_channel_properties|duplicate_channel|delete_channel|load_channel_from_image|set_quick_mask|path_to_selection|select_text_shape)$/;
 var ANNOTATE = /^(add_shape_layer|update_shape|add_shape_component|set_shape_component|remove_shape_component|merge_shape_components|add_text_layer|set_text|set_text_style|set_paragraph_style|set_text_frame|set_text_orientation|convert_text_to_shape)$/;
 var CROP = /^(set_crop|crop_to_selection|reset_crop|set_rotation|flip_image|transform_layer|warp_layer|flip_layer|offset_layer)$/;
 var ADJUST = /^(set_adjustments|add_adjustment_layer|update_adjustment_layer|remove_adjustment_layer|move_adjustment_layer)$/;
@@ -12932,6 +13049,9 @@ var DEFAULT_SELECTION_TOOL_OPTIONS = {
   quickEnhance: false,
   objectSampleAll: true,
   objectEnhance: false,
+  focusRange: 50,
+  focusNoise: 0,
+  focusSoftness: 4,
   typeText: "Type",
   typeSize: 72,
   typeFamily: "sans-serif"
@@ -13400,6 +13520,33 @@ function createImageSelectionTools(controller) {
       return summary(controller);
     }
   };
+  const selectFocusAreaTool = {
+    name: "select_focus_area",
+    title: "Select the focus area",
+    description: "Select \u203A Focus Area: selects the parts of the image that are in focus (sharp detail, above the image noise), with the edge fitted to the image, combined with the selection by mode. Use it to separate a sharp subject from a blurred background (shallow depth of field), e.g. before blurring or darkening the background. Raise range to take in less sharp areas, raise noise if grain in the background gets selected. One undoable step. Returns the selection and noiseLevel (\u03C3 of the image noise in levels of 255).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        range: { type: "number", minimum: 0, maximum: 100, description: "In-Focus Range 0..100 (default 50): higher takes in less sharp areas too." },
+        noise: { type: "number", minimum: 0, maximum: 100, description: "Image Noise Level 0..100 (default 0): raise it when grain is selected as detail." },
+        softness: { type: "number", minimum: 0, maximum: 100, description: "Soften the edge over this many natural pixels (default 4; 0 for a hard edge)." },
+        mode: modeSchema,
+        sampleAllLayers: { type: "boolean", description: "Read every layer (default true); false reads only the active pixel layer." }
+      },
+      additionalProperties: false
+    },
+    annotations: writeAnnotations("Select the focus area", true),
+    handler: async (args) => {
+      const { noiseLevel } = await controller.selectFocusArea({
+        range: args.range === void 0 ? void 0 : num2(args.range, 50),
+        noise: args.noise === void 0 ? void 0 : num2(args.noise, 0),
+        softness: args.softness === void 0 ? void 0 : num2(args.softness, 4),
+        mode: parseSelectionMode(args.mode),
+        sampleAllLayers: args.sampleAllLayers
+      });
+      return { ...summary(controller), noiseLevel };
+    }
+  };
   const magicWandTool = {
     name: "magic_wand",
     title: "Magic wand",
@@ -13955,6 +14102,7 @@ function createImageSelectionTools(controller) {
     quickSelectTool,
     selectObjectTool,
     createImageSubjectSelectionTool(controller),
+    selectFocusAreaTool,
     lineTool,
     magicWandTool,
     colorRangeTool,
@@ -20677,6 +20825,7 @@ export {
   flattenPath,
   flipCorners,
   flowField,
+  focusArea,
   followLayerMove,
   fontOf,
   formatControlValue,
@@ -21095,6 +21244,7 @@ export {
   snapPolygonToEdges,
   snapTo45,
   snapToEdge,
+  softMaskToSelection,
   solidPaint,
   solidSurface,
   solveMembrane,
@@ -21209,6 +21359,8 @@ export {
   withImagePlayback,
   withNewIds,
   workImage,
+  workLuma,
+  workPlanes,
   writeAdjustmentBlock,
   writeDeepRegion,
   writeLfx2,