@pixerate/editor 0.197.0 → 0.198.0

package/dist/image-editor/index.js

@@ -3045,7 +3045,7 @@ var GridGraph = class {
   }
 };
 
-// src/image-editor/selection/segment/quick.ts
+// src/image-editor/selection/segment/work.ts
 var WORK_SIZE = 512;
 var workCache = /* @__PURE__ */ new WeakMap();
 function workImage(pixels, maxSide = WORK_SIZE) {
@@ -3082,6 +3082,155 @@ function workImage(pixels, maxSide = WORK_SIZE) {
   workCache.set(pixels.data, { maxSide, work });
   return work;
 }
+var GAMMA = 50;
+var UNITS = 64;
+function smoothnessWeights(work, roi) {
+  const { width: w, rgb } = work;
+  const { x: rx, y: ry, width: rw, height: rh } = roi;
+  const right = new Float64Array(rw * rh);
+  const down = new Float64Array(rw * rh);
+  let sumSq = 0;
+  let pairs = 0;
+  for (let y = 0; y < rh; y++) {
+    for (let x = 0; x < rw; x++) {
+      const p = y * rw + x;
+      const c = ((ry + y) * w + rx + x) * 3;
+      if (x + 1 < rw) {
+        right[p] = (rgb[c] - rgb[c + 3]) ** 2 + (rgb[c + 1] - rgb[c + 4]) ** 2 + (rgb[c + 2] - rgb[c + 5]) ** 2;
+        sumSq += right[p];
+        pairs++;
+      }
+      if (y + 1 < rh) {
+        const k = c + w * 3;
+        down[p] = (rgb[c] - rgb[k]) ** 2 + (rgb[c + 1] - rgb[k + 1]) ** 2 + (rgb[c + 2] - rgb[k + 2]) ** 2;
+        sumSq += down[p];
+        pairs++;
+      }
+    }
+  }
+  const beta = 1 / (2 * Math.max(1e-6, sumSq / Math.max(1, pairs)));
+  for (let p = 0; p < right.length; p++) {
+    right[p] = Math.round(GAMMA * UNITS * Math.exp(-beta * right[p]));
+    down[p] = Math.round(GAMMA * UNITS * Math.exp(-beta * down[p]));
+  }
+  return { right, down };
+}
+function boxBlur(src, w, h, passes) {
+  let a = src;
+  for (let k = 0; k < passes; k++) {
+    const b = new Float32Array(a.length);
+    for (let y = 0; y < h; y++) {
+      for (let x = 0; x < w; x++) {
+        let s = 0;
+        let c = 0;
+        for (let j = Math.max(0, y - 1); j <= Math.min(h - 1, y + 1); j++) {
+          for (let i = Math.max(0, x - 1); i <= Math.min(w - 1, x + 1); i++) {
+            s += a[j * w + i];
+            c++;
+          }
+        }
+        b[y * w + x] = s / c;
+      }
+    }
+    a = b;
+  }
+  return a;
+}
+function upscaleRegion(work, pixels, roi, label, enhance) {
+  const { sourceWidth: W, sourceHeight: H, scale, rgb, width: ww } = work;
+  const { x: rx, y: ry, width: rw, height: rh } = roi;
+  let soft = Float32Array.from(label);
+  if (enhance) {
+    soft = boxBlur(soft, rw, rh, 2);
+    for (let i = 0; i < soft.length; i++) soft[i] = Math.min(1, Math.max(0, (soft[i] - 0.5) * 3 + 0.5));
+  }
+  const X0 = Math.max(0, Math.floor(rx / scale));
+  const Y0 = Math.max(0, Math.floor(ry / scale));
+  const X1 = Math.min(W, Math.ceil((rx + rw) / scale));
+  const Y1 = Math.min(H, Math.ceil((ry + rh) / scale));
+  const RW = X1 - X0;
+  const RH = Y1 - Y0;
+  const out = new Uint8Array(RW * RH);
+  const at = (x, y) => soft[Math.min(rh - 1, Math.max(0, y)) * rw + Math.min(rw - 1, Math.max(0, x))];
+  const data = pixels.data;
+  const colOf = new Int32Array(RW);
+  const fxOf = new Float32Array(RW);
+  for (let X = 0; X < RW; X++) {
+    const u = (X0 + X + 0.5) * scale - 0.5 - rx;
+    colOf[X] = Math.floor(u);
+    fxOf[X] = u - colOf[X];
+  }
+  const cellState = (i, j) => {
+    const a = at(i, j), b = at(i + 1, j), c = at(i, j + 1), d = at(i + 1, j + 1);
+    if (a === 1 && b === 1 && c === 1 && d === 1) return 1;
+    if (a === 0 && b === 0 && c === 0 && d === 0) return 0;
+    return 2;
+  };
+  for (let Y = 0; Y < RH; Y++) {
+    const v = (Y0 + Y + 0.5) * scale - 0.5 - ry;
+    const j = Math.floor(v);
+    const fy = v - j;
+    for (let X = 0; X < RW; X++) {
+      const i = colOf[X];
+      const state = cellState(i, j);
+      if (state !== 2) {
+        let end = X + 1;
+        while (end < RW && colOf[end] === i) end++;
+        if (state === 1) out.fill(255, Y * RW + X, Y * RW + end);
+        X = end - 1;
+        continue;
+      }
+      const fx = fxOf[X];
+      const m = (at(i, j) * (1 - fx) + at(i + 1, j) * fx) * (1 - fy) + (at(i, j + 1) * (1 - fx) + at(i + 1, j + 1) * fx) * fy;
+      if (m <= 1e-3 || m >= 0.999) {
+        out[Y * RW + X] = m >= 0.999 ? 255 : 0;
+        continue;
+      }
+      let fr = 0, fg = 0, fb = 0, fn = 0, br = 0, bg = 0, bb = 0, bn = 0;
+      for (let jj = j - 1; jj <= j + 2; jj++) {
+        for (let ii = i - 1; ii <= i + 2; ii++) {
+          if (ii < 0 || jj < 0 || ii >= rw || jj >= rh) continue;
+          const k = ((ry + jj) * ww + rx + ii) * 3;
+          if (soft[jj * rw + ii] >= 0.5) {
+            fr += rgb[k];
+            fg += rgb[k + 1];
+            fb += rgb[k + 2];
+            fn++;
+          } else {
+            br += rgb[k];
+            bg += rgb[k + 1];
+            bb += rgb[k + 2];
+            bn++;
+          }
+        }
+      }
+      let alpha = m;
+      if (fn && bn) {
+        fr /= fn;
+        fg /= fn;
+        fb /= fn;
+        br /= bn;
+        bg /= bn;
+        bb /= bn;
+        const dr = fr - br, dg = fg - bg, db = fb - bb;
+        const len2 = dr * dr + dg * dg + db * db;
+        if (len2 > 400) {
+          const p = ((Y0 + Y) * W + X0 + X) * 4;
+          const a = data[p + 3] / 255;
+          const cr = data[p] * a + 255 * (1 - a) - br;
+          const cg = data[p + 1] * a + 255 * (1 - a) - bg;
+          const cb = data[p + 2] * a + 255 * (1 - a) - bb;
+          const proj = Math.min(1, Math.max(0, (cr * dr + cg * dg + cb * db) / len2));
+          alpha = Math.min(1, Math.max(0, proj * 0.75 + m * 0.25));
+        } else alpha = Math.min(1, Math.max(0, (m - 0.5) * 2 + 0.5));
+      }
+      out[Y * RW + X] = Math.round(alpha * 255);
+    }
+  }
+  return selectionFromRegion(W, H, { x: X0, y: Y0, width: RW, height: RH }, out);
+}
+
+// src/image-editor/selection/segment/quick.ts
 var BINS = 16;
 var binOf = (rgb, i) => (Math.min(BINS - 1, rgb[i * 3] >> 4) * BINS + Math.min(BINS - 1, rgb[i * 3 + 1] >> 4)) * BINS + Math.min(BINS - 1, rgb[i * 3 + 2] >> 4);
 function costTable(hist, total) {
@@ -3102,8 +3251,6 @@ function costTable(hist, total) {
   for (let i = 0; i < a.length; i++) out[i] = -Math.log((a[i] + floor * Math.max(1, total)) / denom);
   return out;
 }
-var GAMMA = 50;
-var UNITS = 64;
 function strokePixels(points, r, w, h) {
   const mask = new Uint8Array(w * h);
   const list = [];
@@ -3161,23 +3308,7 @@ function segmentStroke(work, stroke, grown, start) {
     }
     const fgCost = costTable(fgHist, fgN);
     const bgCost = costTable(bgHist, bgN);
-    let sumSq = 0;
-    let pairs = 0;
-    for (let y = 0; y < rh; y++) {
-      for (let x = 0; x < rw; x++) {
-        const g = ((ry + y) * w + rx + x) * 3;
-        if (x + 1 < rw) {
-          sumSq += (rgb[g] - rgb[g + 3]) ** 2 + (rgb[g + 1] - rgb[g + 4]) ** 2 + (rgb[g + 2] - rgb[g + 5]) ** 2;
-          pairs++;
-        }
-        if (y + 1 < rh) {
-          const k = g + w * 3;
-          sumSq += (rgb[g] - rgb[k]) ** 2 + (rgb[g + 1] - rgb[k + 1]) ** 2 + (rgb[g + 2] - rgb[k + 2]) ** 2;
-          pairs++;
-        }
-      }
-    }
-    const beta = 1 / (2 * Math.max(1e-6, sumSq / Math.max(1, pairs)));
+    const { right, down } = smoothnessWeights(work, roi);
     const graph = new GridGraph(rw, rh);
     const HARD = 1e9;
     for (let y = 0; y < rh; y++) {
@@ -3189,16 +3320,8 @@ function segmentStroke(work, stroke, grown, start) {
           const bin = binOf(rgb, g);
           graph.addTerminal(p, Math.round(bgCost[bin] * UNITS), Math.round(fgCost[bin] * UNITS));
         }
-        const c = g * 3;
-        if (x + 1 < rw) {
-          const d = (rgb[c] - rgb[c + 3]) ** 2 + (rgb[c + 1] - rgb[c + 4]) ** 2 + (rgb[c + 2] - rgb[c + 5]) ** 2;
-          graph.setEdge(p, 0, Math.round(GAMMA * UNITS * Math.exp(-beta * d)));
-        }
-        if (y + 1 < rh) {
-          const k = c + w * 3;
-          const d = (rgb[c] - rgb[k]) ** 2 + (rgb[c + 1] - rgb[k + 1]) ** 2 + (rgb[c + 2] - rgb[k + 2]) ** 2;
-          graph.setEdge(p, 1, Math.round(GAMMA * UNITS * Math.exp(-beta * d)));
-        }
+        if (x + 1 < rw) graph.setEdge(p, 0, right[p]);
+        if (y + 1 < rh) graph.setEdge(p, 1, down[p]);
       }
     }
     graph.maxflow();
@@ -3239,120 +3362,6 @@ function segmentStroke(work, stroke, grown, start) {
     if (roi.width * roi.height * 2.5 > w * h) roi = { x: 0, y: 0, width: w, height: h };
   }
 }
-function boxBlur(src, w, h, passes) {
-  let a = src;
-  for (let k = 0; k < passes; k++) {
-    const b = new Float32Array(a.length);
-    for (let y = 0; y < h; y++) {
-      for (let x = 0; x < w; x++) {
-        let s = 0;
-        let c = 0;
-        for (let j = Math.max(0, y - 1); j <= Math.min(h - 1, y + 1); j++) {
-          for (let i = Math.max(0, x - 1); i <= Math.min(w - 1, x + 1); i++) {
-            s += a[j * w + i];
-            c++;
-          }
-        }
-        b[y * w + x] = s / c;
-      }
-    }
-    a = b;
-  }
-  return a;
-}
-function upscaleRegion(work, pixels, roi, label, enhance) {
-  const { sourceWidth: W, sourceHeight: H, scale, rgb, width: ww } = work;
-  const { x: rx, y: ry, width: rw, height: rh } = roi;
-  let soft = Float32Array.from(label);
-  if (enhance) {
-    soft = boxBlur(soft, rw, rh, 2);
-    for (let i = 0; i < soft.length; i++) soft[i] = Math.min(1, Math.max(0, (soft[i] - 0.5) * 3 + 0.5));
-  }
-  const X0 = Math.max(0, Math.floor(rx / scale));
-  const Y0 = Math.max(0, Math.floor(ry / scale));
-  const X1 = Math.min(W, Math.ceil((rx + rw) / scale));
-  const Y1 = Math.min(H, Math.ceil((ry + rh) / scale));
-  const RW = X1 - X0;
-  const RH = Y1 - Y0;
-  const out = new Uint8Array(RW * RH);
-  const at = (x, y) => soft[Math.min(rh - 1, Math.max(0, y)) * rw + Math.min(rw - 1, Math.max(0, x))];
-  const data = pixels.data;
-  const colOf = new Int32Array(RW);
-  const fxOf = new Float32Array(RW);
-  for (let X = 0; X < RW; X++) {
-    const u = (X0 + X + 0.5) * scale - 0.5 - rx;
-    colOf[X] = Math.floor(u);
-    fxOf[X] = u - colOf[X];
-  }
-  const cellState = (i, j) => {
-    const a = at(i, j), b = at(i + 1, j), c = at(i, j + 1), d = at(i + 1, j + 1);
-    if (a === 1 && b === 1 && c === 1 && d === 1) return 1;
-    if (a === 0 && b === 0 && c === 0 && d === 0) return 0;
-    return 2;
-  };
-  for (let Y = 0; Y < RH; Y++) {
-    const v = (Y0 + Y + 0.5) * scale - 0.5 - ry;
-    const j = Math.floor(v);
-    const fy = v - j;
-    for (let X = 0; X < RW; X++) {
-      const i = colOf[X];
-      const state = cellState(i, j);
-      if (state !== 2) {
-        let end = X + 1;
-        while (end < RW && colOf[end] === i) end++;
-        if (state === 1) out.fill(255, Y * RW + X, Y * RW + end);
-        X = end - 1;
-        continue;
-      }
-      const fx = fxOf[X];
-      const m = (at(i, j) * (1 - fx) + at(i + 1, j) * fx) * (1 - fy) + (at(i, j + 1) * (1 - fx) + at(i + 1, j + 1) * fx) * fy;
-      if (m <= 1e-3 || m >= 0.999) {
-        out[Y * RW + X] = m >= 0.999 ? 255 : 0;
-        continue;
-      }
-      let fr = 0, fg = 0, fb = 0, fn = 0, br = 0, bg = 0, bb = 0, bn = 0;
-      for (let jj = j - 1; jj <= j + 2; jj++) {
-        for (let ii = i - 1; ii <= i + 2; ii++) {
-          if (ii < 0 || jj < 0 || ii >= rw || jj >= rh) continue;
-          const k = ((ry + jj) * ww + rx + ii) * 3;
-          if (soft[jj * rw + ii] >= 0.5) {
-            fr += rgb[k];
-            fg += rgb[k + 1];
-            fb += rgb[k + 2];
-            fn++;
-          } else {
-            br += rgb[k];
-            bg += rgb[k + 1];
-            bb += rgb[k + 2];
-            bn++;
-          }
-        }
-      }
-      let alpha = m;
-      if (fn && bn) {
-        fr /= fn;
-        fg /= fn;
-        fb /= fn;
-        br /= bn;
-        bg /= bn;
-        bb /= bn;
-        const dr = fr - br, dg = fg - bg, db = fb - bb;
-        const len2 = dr * dr + dg * dg + db * db;
-        if (len2 > 400) {
-          const p = ((Y0 + Y) * W + X0 + X) * 4;
-          const a = data[p + 3] / 255;
-          const cr = data[p] * a + 255 * (1 - a) - br;
-          const cg = data[p + 1] * a + 255 * (1 - a) - bg;
-          const cb = data[p + 2] * a + 255 * (1 - a) - bb;
-          const proj = Math.min(1, Math.max(0, (cr * dr + cg * dg + cb * db) / len2));
-          alpha = Math.min(1, Math.max(0, proj * 0.75 + m * 0.25));
-        } else alpha = Math.min(1, Math.max(0, (m - 0.5) * 2 + 0.5));
-      }
-      out[Y * RW + X] = Math.round(alpha * 255);
-    }
-  }
-  return selectionFromRegion(W, H, { x: X0, y: Y0, width: RW, height: RH }, out);
-}
 function quickSelectStroke(pixels, stroke, options = {}) {
   if (!stroke.length) throw new Error("A stroke needs at least one point.");
   const work = workImage(pixels);
@@ -3386,6 +3395,283 @@ function quickSelectStroke(pixels, stroke, options = {}) {
   return upscaleRegion(work, pixels, done, label, options.enhanceEdge ?? false);
 }
 
+// src/image-editor/selection/segment/grabcut.ts
+var K = 5;
+var ColorGmm = class {
+  logWeight = new Float64Array(K);
+  mean = new Float64Array(K * 3);
+  /** Inverse covariances, row-major 3 × 3. */
+  inv = new Float64Array(K * 9);
+  /** ln(weight) − ½ ln((2π)³ |Σ|) per component; −∞ for an empty one. */
+  logNorm = new Float64Array(K).fill(-Infinity);
+  /** Fits the components to the pixels `ids` of `rgb`, each in component `comp[id]`. */
+  fit(rgb, ids, comp) {
+    const n = new Float64Array(K);
+    const sum = new Float64Array(K * 3);
+    const prod = new Float64Array(K * 9);
+    for (let t = 0; t < ids.length; t++) {
+      const i = ids[t];
+      const k = comp[i];
+      const c = [rgb[i * 3], rgb[i * 3 + 1], rgb[i * 3 + 2]];
+      n[k]++;
+      for (let a = 0; a < 3; a++) {
+        sum[k * 3 + a] += c[a];
+        for (let b = 0; b < 3; b++) prod[k * 9 + a * 3 + b] += c[a] * c[b];
+      }
+    }
+    const total = ids.length || 1;
+    for (let k = 0; k < K; k++) {
+      if (!n[k]) {
+        this.logNorm[k] = -Infinity;
+        continue;
+      }
+      const m = [sum[k * 3] / n[k], sum[k * 3 + 1] / n[k], sum[k * 3 + 2] / n[k]];
+      const cov = new Float64Array(9);
+      for (let a = 0; a < 3; a++) {
+        for (let b = 0; b < 3; b++) cov[a * 3 + b] = prod[k * 9 + a * 3 + b] / n[k] - m[a] * m[b];
+        cov[a * 4] += 4;
+      }
+      const det = cov[0] * (cov[4] * cov[8] - cov[5] * cov[7]) - cov[1] * (cov[3] * cov[8] - cov[5] * cov[6]) + cov[2] * (cov[3] * cov[7] - cov[4] * cov[6]);
+      const d = Math.max(det, 1e-6);
+      const inv = [
+        (cov[4] * cov[8] - cov[5] * cov[7]) / d,
+        (cov[2] * cov[7] - cov[1] * cov[8]) / d,
+        (cov[1] * cov[5] - cov[2] * cov[4]) / d,
+        (cov[5] * cov[6] - cov[3] * cov[8]) / d,
+        (cov[0] * cov[8] - cov[2] * cov[6]) / d,
+        (cov[2] * cov[3] - cov[0] * cov[5]) / d,
+        (cov[3] * cov[7] - cov[4] * cov[6]) / d,
+        (cov[1] * cov[6] - cov[0] * cov[7]) / d,
+        (cov[0] * cov[4] - cov[1] * cov[3]) / d
+      ];
+      this.mean.set(m, k * 3);
+      this.inv.set(inv, k * 9);
+      this.logWeight[k] = Math.log(n[k] / total);
+      this.logNorm[k] = this.logWeight[k] - 0.5 * Math.log(Math.pow(2 * Math.PI, 3) * d);
+    }
+  }
+  /** ln p(colour | component k), up to the shared constant. */
+  componentLog(k, r, g, b) {
+    const ln = this.logNorm[k];
+    if (ln === -Infinity) return -Infinity;
+    const dr = r - this.mean[k * 3];
+    const dg = g - this.mean[k * 3 + 1];
+    const db = b - this.mean[k * 3 + 2];
+    const v = this.inv;
+    const o = k * 9;
+    const q = dr * (v[o] * dr + v[o + 1] * dg + v[o + 2] * db) + dg * (v[o + 3] * dr + v[o + 4] * dg + v[o + 5] * db) + db * (v[o + 6] * dr + v[o + 7] * dg + v[o + 8] * db);
+    return ln - 0.5 * q;
+  }
+  /** −ln p(colour) under the mixture (large for colours the model hasn't seen). */
+  cost(r, g, b) {
+    let best = -Infinity;
+    const logs = new Array(K);
+    for (let k = 0; k < K; k++) {
+      logs[k] = this.componentLog(k, r, g, b);
+      if (logs[k] > best) best = logs[k];
+    }
+    if (best === -Infinity) return 50;
+    let s = 0;
+    for (let k = 0; k < K; k++) if (logs[k] > -Infinity) s += Math.exp(logs[k] - best);
+    return Math.min(50, -(best + Math.log(s)));
+  }
+  /** The component most likely to have produced the colour. */
+  nearest(r, g, b) {
+    let best = 0;
+    let bestLog = -Infinity;
+    for (let k = 0; k < K; k++) {
+      const l = this.componentLog(k, r, g, b);
+      if (l > bestLog) {
+        bestLog = l;
+        best = k;
+      }
+    }
+    return best;
+  }
+};
+function initialComponents(rgb, ids, comp) {
+  if (!ids.length) return;
+  const step = Math.max(1, Math.floor(ids.length / 6e3));
+  const sample = [];
+  for (let t = 0; t < ids.length; t += step) sample.push(ids[t]);
+  const centres = [];
+  const dist2 = (i, c) => (rgb[i * 3] - c[0]) ** 2 + (rgb[i * 3 + 1] - c[1]) ** 2 + (rgb[i * 3 + 2] - c[2]) ** 2;
+  centres.push([rgb[sample[0] * 3], rgb[sample[0] * 3 + 1], rgb[sample[0] * 3 + 2]]);
+  const near = sample.map((i) => dist2(i, centres[0]));
+  while (centres.length < K) {
+    let far = 0;
+    for (let t = 1; t < sample.length; t++) if (near[t] > near[far]) far = t;
+    const i = sample[far];
+    const c = [rgb[i * 3], rgb[i * 3 + 1], rgb[i * 3 + 2]];
+    centres.push(c);
+    for (let t = 0; t < sample.length; t++) near[t] = Math.min(near[t], dist2(sample[t], c));
+  }
+  const closest = (i) => {
+    let best = 0;
+    for (let k = 1; k < K; k++) if (dist2(i, centres[k]) < dist2(i, centres[best])) best = k;
+    return best;
+  };
+  for (let round6 = 0; round6 < 6; round6++) {
+    const sum = Array.from({ length: K }, () => [0, 0, 0, 0]);
+    for (const i of sample) {
+      const s = sum[closest(i)];
+      s[0] += rgb[i * 3];
+      s[1] += rgb[i * 3 + 1];
+      s[2] += rgb[i * 3 + 2];
+      s[3]++;
+    }
+    for (let k = 0; k < K; k++) if (sum[k][3]) centres[k] = [sum[k][0] / sum[k][3], sum[k][1] / sum[k][3], sum[k][2] / sum[k][3]];
+  }
+  for (const i of ids) comp[i] = closest(i);
+}
+function grabCutLabels(work, setup, iterations) {
+  const { width: w, rgb } = work;
+  const { roi, hardBg, hardFg } = setup;
+  const { x: rx, y: ry, width: rw, height: rh } = roi;
+  const n = rw * rh;
+  const label = setup.initial.slice();
+  const global = new Int32Array(n);
+  for (let y = 0; y < rh; y++) for (let x = 0; x < rw; x++) global[y * rw + x] = (ry + y) * w + rx + x;
+  const comp = new Uint8Array(w * work.height);
+  const fg = new ColorGmm();
+  const bg = new ColorGmm();
+  const { right, down } = smoothnessWeights(work, roi);
+  const HARD = 1e9;
+  for (let iter = 0; iter < iterations; iter++) {
+    const fgIds = [];
+    const bgIds = [];
+    for (let p = 0; p < n; p++) (label[p] ? fgIds : bgIds).push(global[p]);
+    if (!fgIds.length) return label;
+    if (iter === 0) {
+      initialComponents(rgb, fgIds, comp);
+      initialComponents(rgb, bgIds, comp);
+    } else {
+      for (const i of fgIds) comp[i] = fg.nearest(rgb[i * 3], rgb[i * 3 + 1], rgb[i * 3 + 2]);
+      for (const i of bgIds) comp[i] = bg.nearest(rgb[i * 3], rgb[i * 3 + 1], rgb[i * 3 + 2]);
+    }
+    fg.fit(rgb, fgIds, comp);
+    bg.fit(rgb, bgIds, comp);
+    const graph = new GridGraph(rw, rh);
+    for (let p = 0; p < n; p++) {
+      if (hardBg[p]) graph.addTerminal(p, 0, HARD);
+      else if (hardFg?.[p]) graph.addTerminal(p, HARD, 0);
+      else {
+        const i = global[p] * 3;
+        graph.addTerminal(p, Math.round(bg.cost(rgb[i], rgb[i + 1], rgb[i + 2]) * UNITS), Math.round(fg.cost(rgb[i], rgb[i + 1], rgb[i + 2]) * UNITS));
+      }
+      if (p % rw + 1 < rw) graph.setEdge(p, 0, right[p]);
+      if (p + rw < n) graph.setEdge(p, 1, down[p]);
+    }
+    graph.maxflow();
+    let changed = 0;
+    for (let p = 0; p < n; p++) {
+      const v = graph.inSource(p) ? 1 : 0;
+      if (v !== label[p]) changed++;
+      label[p] = v;
+    }
+    if (changed <= n * 1e-3) break;
+  }
+  return label;
+}
+function keepMainPieces(label, rw, rh, seed) {
+  const n = rw * rh;
+  const piece = new Int32Array(n).fill(-1);
+  const sizes = [];
+  const stack = [];
+  for (let s = 0; s < n; s++) {
+    if (!label[s] || piece[s] >= 0) continue;
+    const id = sizes.length;
+    let size = 0;
+    piece[s] = id;
+    stack.push(s);
+    while (stack.length) {
+      const p = stack.pop();
+      size++;
+      const x = p % rw;
+      for (const q of [x + 1 < rw ? p + 1 : -1, x > 0 ? p - 1 : -1, p + rw < n ? p + rw : -1, p - rw]) {
+        if (q >= 0 && label[q] && piece[q] < 0) {
+          piece[q] = id;
+          stack.push(q);
+        }
+      }
+    }
+    sizes.push(size);
+  }
+  if (!sizes.length) return;
+  const largest = Math.max(...sizes);
+  const keep = (id) => seed !== null && piece[seed] >= 0 ? id === piece[seed] : sizes[id] * 5 >= largest;
+  for (let p = 0; p < n; p++) if (label[p] && !keep(piece[p])) label[p] = 0;
+}
+function selectObjectIn(pixels, target, options = {}) {
+  const work = workImage(pixels);
+  const { width: w, height: h, scale } = work;
+  const iterations = Math.max(1, Math.round(options.iterations ?? 5));
+  const enhance = options.enhanceEdge ?? false;
+  if ("rect" in target) {
+    const r = target.rect;
+    const bx0 = Math.max(0, Math.floor(r.x * scale));
+    const by0 = Math.max(0, Math.floor(r.y * scale));
+    const bx1 = Math.min(w, Math.ceil((r.x + r.width) * scale));
+    const by1 = Math.min(h, Math.ceil((r.y + r.height) * scale));
+    if (bx1 - bx0 < 2 || by1 - by0 < 2) return createSelectionMask(pixels.width, pixels.height);
+    const m = Math.max(8, Math.round(0.25 * Math.max(bx1 - bx0, by1 - by0)));
+    const rx = Math.max(0, bx0 - m);
+    const ry = Math.max(0, by0 - m);
+    const roi = { x: rx, y: ry, width: Math.min(w, bx1 + m) - rx, height: Math.min(h, by1 + m) - ry };
+    const n = roi.width * roi.height;
+    const initial = new Uint8Array(n);
+    const hardBg = new Uint8Array(n);
+    for (let y = 0; y < roi.height; y++) {
+      for (let x = 0; x < roi.width; x++) {
+        const gx = rx + x;
+        const gy = ry + y;
+        const inside = gx >= bx0 && gx < bx1 && gy >= by0 && gy < by1;
+        initial[y * roi.width + x] = inside ? 1 : 0;
+        hardBg[y * roi.width + x] = inside ? 0 : 1;
+      }
+    }
+    const label = grabCutLabels(work, { roi, initial, hardBg, hardFg: null }, iterations);
+    keepMainPieces(label, roi.width, roi.height, null);
+    return upscaleRegion(work, pixels, roi, label, enhance);
+  }
+  const px2 = Math.min(w - 1, Math.max(0, Math.floor(target.point.x * scale)));
+  const py = Math.min(h - 1, Math.max(0, Math.floor(target.point.y * scale)));
+  let half = Math.max(24, Math.round(0.3 * Math.max(w, h)));
+  for (; ; ) {
+    const rx = Math.max(0, px2 - half);
+    const ry = Math.max(0, py - half);
+    const roi = { x: rx, y: ry, width: Math.min(w, px2 + half + 1) - rx, height: Math.min(h, py + half + 1) - ry };
+    const whole = roi.width === w && roi.height === h;
+    const band = Math.max(4, Math.round(0.15 * half));
+    const n = roi.width * roi.height;
+    const initial = new Uint8Array(n);
+    const hardBg = new Uint8Array(n);
+    const hardFg = new Uint8Array(n);
+    const inBand = (x, y) => rx > 0 && x < band || ry > 0 && y < band || rx + roi.width < w && x >= roi.width - band || ry + roi.height < h && y >= roi.height - band;
+    for (let y = 0; y < roi.height; y++) {
+      for (let x = 0; x < roi.width; x++) {
+        const p = y * roi.width + x;
+        if (inBand(x, y)) hardBg[p] = 1;
+        else initial[p] = 1;
+        if (Math.hypot(rx + x - px2, ry + y - py) <= 1.5) hardFg[p] = 1;
+      }
+    }
+    const label = grabCutLabels(work, { roi, initial, hardBg, hardFg }, iterations);
+    keepMainPieces(label, roi.width, roi.height, (py - ry) * roi.width + (px2 - rx));
+    let touches = false;
+    for (let y = 0; y < roi.height && !touches; y++) {
+      for (let x = 0; x < roi.width; x++) {
+        if (label[y * roi.width + x] && (inBand(x - 1, y) || inBand(x + 1, y) || inBand(x, y - 1) || inBand(x, y + 1))) {
+          touches = true;
+          break;
+        }
+      }
+    }
+    if (!touches || whole) return upscaleRegion(work, pixels, roi, label, enhance);
+    half = Math.round(half * 1.6);
+  }
+}
+
 // src/image-editor/layers/shape-type-ui.ts
 var DEFAULT_SHAPE_TOOL_OPTIONS = {
   kind: "rect",
@@ -9355,6 +9641,28 @@ var ImageEditorController = class {
     this.setSelection(sel, "replace");
     return this.state.selection ?? null;
   }
+  /**
+   * Object Selection: the object inside `target.rect` (natural pixels; what is outside the box is
+   * background) or under `target.point`, found by GrabCut (colour models of object and background
+   * plus a graph cut along edges), combined with the selection by `mode` as one undo step.
+   * Resolves to the resulting selection.
+   */
+  async selectObject(target, options = {}) {
+    const { width, height } = this.naturalSize;
+    if ("rect" in target) {
+      const r = target.rect;
+      if (!(r.width > 0 && r.height > 0)) throw new Error("The box needs a positive width and height.");
+      if (r.x >= width || r.y >= height || r.x + r.width <= 0 || r.y + r.height <= 0) {
+        throw new Error(`The box lies outside the image (0..${width}, 0..${height}); draw it around the object.`);
+      }
+    } else if (!(target.point.x >= 0 && target.point.y >= 0 && target.point.x < width && target.point.y < height)) {
+      throw new Error(`(${target.point.x}, ${target.point.y}) is outside the image (0..${width - 1}, 0..${height - 1}); click on the object.`);
+    }
+    const pixels = await this.requirePixels({ sample: options.sampleAllLayers === false ? "active-layer" : "composite" });
+    const region = selectObjectIn(pixels, target, { enhanceEdge: options.enhanceEdge });
+    this.setSelection(region, options.mode ?? "replace");
+    return this.state.selection ?? null;
+  }
   /**
    * 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)
@@ -12242,7 +12550,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_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_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)$/;
@@ -12365,6 +12673,7 @@ var SELECTION_TOOLS = [
   { id: "polygon", label: "Polygonal Lasso" },
   { id: "magnetic", label: "Magnetic Lasso" },
   { id: "quick", label: "Quick Selection" },
+  { id: "object", label: "Object Selection" },
   { id: "range", label: "Color Range" },
   { id: "type", label: "Type Mask" },
   { id: "type-vertical", label: "Vertical Type Mask" }
@@ -12405,6 +12714,8 @@ var DEFAULT_SELECTION_TOOL_OPTIONS = {
   quickSize: 30,
   quickSampleAll: true,
   quickEnhance: false,
+  objectSampleAll: true,
+  objectEnhance: false,
   typeText: "Type",
   typeSize: 72,
   typeFamily: "sans-serif"
@@ -12840,6 +13151,39 @@ function createImageSelectionTools(controller) {
       return summary(controller);
     }
   };
+  const selectObjectTool = {
+    name: "select_object",
+    title: "Object Selection",
+    description: "Object Selection: selects the object inside rect (a box drawn loosely around it, natural image pixels; what lies outside the box is treated as background) or the object under point, found from the colours of object and background and the edges between them (GrabCut). Combined with the selection by mode. A box is more reliable than a point: make it a little larger than the object on every side. Check with get_selection and capture_view, then fix with quick_select strokes or select_object with mode add / subtract. One undoable step. Returns the selection.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        rect: {
+          type: "object",
+          properties: rectProperties,
+          required: ["x", "y", "width", "height"],
+          additionalProperties: false,
+          description: "A box around the object (x, y, width, height in natural image pixels). Pass this or point."
+        },
+        point: { ...pointSchema, description: "A point on the object (natural image pixels). Pass this or rect." },
+        mode: modeSchema,
+        sampleAllLayers: { type: "boolean", description: "Read every layer (default true); false reads only the active pixel layer." },
+        enhanceEdge: { type: "boolean", description: "Smoother, less blocky edges (Auto-Enhance; default false)." }
+      },
+      additionalProperties: false
+    },
+    annotations: writeAnnotations("Object Selection"),
+    handler: async (args) => {
+      const rect = args.rect;
+      const point = args.point;
+      if (!rect && !point) throw new Error("Pass rect (a box around the object) or point (a point on it).");
+      if (rect && point) throw new Error("Pass rect or point, not both.");
+      const options = { mode: parseSelectionMode(args.mode), sampleAllLayers: args.sampleAllLayers, enhanceEdge: args.enhanceEdge };
+      if (rect) await controller.selectObject({ rect: { x: num2(rect.x, NaN), y: num2(rect.y, NaN), width: num2(rect.width, NaN), height: num2(rect.height, NaN) } }, options);
+      else await controller.selectObject({ point: { x: num2(point.x, NaN), y: num2(point.y, NaN) } }, options);
+      return summary(controller);
+    }
+  };
   const magicWandTool = {
     name: "magic_wand",
     title: "Magic wand",
@@ -13393,6 +13737,7 @@ function createImageSelectionTools(controller) {
     selectEllipse,
     selectPolygonTool,
     quickSelectTool,
+    selectObjectTool,
     lineTool,
     magicWandTool,
     colorRangeTool,
@@ -14784,7 +15129,7 @@ var SelectionGesture = class {
   get active() {
     return this.start !== null || this.polygon !== null || this.magnetic !== null;
   }
-  /** Resolves once a Quick Selection stroke has been applied. */
+  /** Resolves once a Quick Selection stroke or an Object Selection has been applied. */
   get settled() {
     return this.pending;
   }
@@ -14954,6 +15299,20 @@ var SelectionGesture = class {
     if (point) this.move(point);
     const options = this.getOptions();
     const mode = selectionModeFromModifiers(modifiers ?? this.modifiers, options.mode);
+    if (options.tool === "object") {
+      const rect2 = normalizeRect({ x: this.start.x, y: this.start.y, width: this.current.x - this.start.x, height: this.current.y - this.start.y });
+      this.start = null;
+      this.current = null;
+      this.points = [];
+      const target = rect2.width >= 4 && rect2.height >= 4 ? { rect: rect2 } : { point: { x: rect2.x + rect2.width / 2, y: rect2.y + rect2.height / 2 } };
+      this.pending = this.controller.selectObject(target, { mode, sampleAllLayers: options.objectSampleAll ?? true, enhanceEdge: options.objectEnhance ?? false }).then(
+        () => void 0,
+        (err) => {
+          this.error = err instanceof Error ? err.message : String(err);
+        }
+      );
+      return false;
+    }
     if (options.tool === "quick") {
       const stroke = this.points;
       this.start = null;
@@ -19600,6 +19959,7 @@ export {
   COLOR_MODE_OPTIONS,
   COLOR_RANGE_PRESETS,
   COLOR_RANGE_PRESET_LABELS,
+  ColorGmm,
   CoverageMap,
   D50,
   D65,
@@ -19652,6 +20012,7 @@ export {
   FREE_TRANSFORM_MODE_OPTIONS,
   FreeTransformSession,
   FreeTransformTool,
+  GAMMA,
   GRAIN_PATTERNS,
   GRAIN_TILE,
   GUIDED_FILTER_EPS,
@@ -19810,6 +20171,7 @@ export {
   TransformTooLargeError,
   TransformedPixelSource,
   TypeToolGesture,
+  UNITS,
   U_MAX,
   VIBRANCE_GREY,
   W9,
@@ -19893,6 +20255,7 @@ export {
   blenderDab,
   blurFilter,
   borderCoverage,
+  boxBlur,
   boxBlurPixels,
   boxFrameHit,
   boxFrameOverlay,
@@ -20454,6 +20817,7 @@ export {
   segmentToSelection,
   segmentationOutlines,
   segmentsToSelection,
+  selectObjectIn,
   selectSimilar,
   selectionArea,
   selectionFromCoverage,
@@ -20503,6 +20867,7 @@ export {
   smartObjectLayers,
   smoothCoverage,
   smoothPoints,
+  smoothnessWeights,
   smudgeEffect,
   snapPolygonToEdges,
   snapTo45,
@@ -20589,6 +20954,7 @@ export {
   updateShapeLayer,
   updateSmartFilter,
   updateTypeLayer,
+  upscaleRegion,
   userErrorMessage,
   uvToXy,
   validateEffectGradient,