@pixerate/editor 0.195.0 → 0.197.0

package/dist/image-editor/index.js

@@ -2803,6 +2803,589 @@ function magneticAnchorSpacing(frequency = 57) {
   return 8 + (100 - f);
 }
 
+// src/image-editor/selection/segment/maxflow.ts
+var TERMINAL = -2;
+var NONE = -1;
+var FREE = 0;
+var SOURCE = 1;
+var SINK = 2;
+var GridGraph = class {
+  width;
+  height;
+  /** Residual capacity of the edge leaving node `p` in direction `d`, at `p * 4 + d`. */
+  cap;
+  /** Net terminal capacity: above 0 to the source, below 0 to the sink. */
+  tr;
+  tree;
+  constructor(width, height) {
+    this.width = width;
+    this.height = height;
+    const n = width * height;
+    this.cap = new Float64Array(n * 4);
+    this.tr = new Float64Array(n);
+    this.tree = new Uint8Array(n);
+  }
+  /** Sets the capacity of the edge between `p` and its neighbour in direction `d`, both ways. */
+  setEdge(p, d, capacity) {
+    const q = d === 0 ? p + 1 : p + this.width;
+    this.cap[p * 4 + d] = capacity;
+    this.cap[q * 4 + (d ^ 2)] = capacity;
+  }
+  /** Adds `source` (cost of putting `p` on the sink side) and `sink` (the other way) to `p`. */
+  addTerminal(p, source, sink) {
+    this.tr[p] += source - sink;
+  }
+  /** Whether `p` is on the source side of the minimum cut (after {@link maxflow}). */
+  inSource(p) {
+    return this.tree[p] === SOURCE;
+  }
+  /** Runs max-flow and returns the flow (the cut's cost, less the constant terminal parts). */
+  maxflow() {
+    const { width: w, height: h, cap, tr, tree } = this;
+    const n = w * h;
+    const nb = (p, d) => {
+      const x = p % w;
+      if (d === 0) return x < w - 1 ? p + 1 : -1;
+      if (d === 1) return p + w < n ? p + w : -1;
+      if (d === 2) return x > 0 ? p - 1 : -1;
+      return p - w >= 0 ? p - w : -1;
+    };
+    const parent = new Int8Array(n).fill(NONE);
+    const ts = new Int32Array(n);
+    const dist = new Int32Array(n);
+    const queue = new Int32Array(n + 1);
+    const queued = new Uint8Array(n);
+    let qHead = 0;
+    let qTail = 0;
+    const activate = (p) => {
+      if (queued[p]) return;
+      queued[p] = 1;
+      queue[qTail] = p;
+      qTail = qTail === n ? 0 : qTail + 1;
+    };
+    const nextActive = () => {
+      while (qHead !== qTail) {
+        const p = queue[qHead];
+        qHead = qHead === n ? 0 : qHead + 1;
+        queued[p] = 0;
+        if (tree[p] !== FREE) return p;
+      }
+      return -1;
+    };
+    let orphans = new Int32Array(64);
+    let orphanCount = 0;
+    const orphan = (p) => {
+      parent[p] = NONE;
+      if (orphanCount === orphans.length) {
+        const grown = new Int32Array(orphans.length * 2);
+        grown.set(orphans);
+        orphans = grown;
+      }
+      orphans[orphanCount++] = p;
+    };
+    tree.fill(FREE);
+    for (let p = 0; p < n; p++) {
+      if (tr[p] > 0) tree[p] = SOURCE;
+      else if (tr[p] < 0) tree[p] = SINK;
+      else continue;
+      parent[p] = TERMINAL;
+      dist[p] = 1;
+      activate(p);
+    }
+    let flow = 0;
+    let time = 0;
+    let current = -1;
+    for (; ; ) {
+      if (current < 0 || tree[current] === FREE) {
+        current = nextActive();
+        if (current < 0) break;
+      }
+      const p = current;
+      const side = tree[p];
+      let s = -1;
+      let t = -1;
+      let dir = 0;
+      for (let d = 0; d < 4; d++) {
+        const q = nb(p, d);
+        if (q < 0) continue;
+        if (side === SOURCE ? cap[p * 4 + d] <= 0 : cap[q * 4 + (d ^ 2)] <= 0) continue;
+        if (tree[q] === FREE) {
+          tree[q] = side;
+          parent[q] = d ^ 2;
+          ts[q] = ts[p];
+          dist[q] = dist[p] + 1;
+          activate(q);
+        } else if (tree[q] !== side) {
+          if (side === SOURCE) {
+            s = p;
+            t = q;
+            dir = d;
+          } else {
+            s = q;
+            t = p;
+            dir = d ^ 2;
+          }
+          break;
+        } else if (ts[q] <= ts[p] && dist[q] > dist[p]) {
+          parent[q] = d ^ 2;
+          ts[q] = ts[p];
+          dist[q] = dist[p] + 1;
+        }
+      }
+      if (s < 0) {
+        current = -1;
+        continue;
+      }
+      time++;
+      let f = cap[s * 4 + dir];
+      for (let x = s; ; ) {
+        const a = parent[x];
+        if (a === TERMINAL) {
+          f = Math.min(f, tr[x]);
+          break;
+        }
+        const up = nb(x, a);
+        f = Math.min(f, cap[up * 4 + (a ^ 2)]);
+        x = up;
+      }
+      for (let x = t; ; ) {
+        const a = parent[x];
+        if (a === TERMINAL) {
+          f = Math.min(f, -tr[x]);
+          break;
+        }
+        f = Math.min(f, cap[x * 4 + a]);
+        x = nb(x, a);
+      }
+      cap[s * 4 + dir] -= f;
+      cap[t * 4 + (dir ^ 2)] += f;
+      for (let x = s; ; ) {
+        const a = parent[x];
+        if (a === TERMINAL) {
+          tr[x] -= f;
+          if (tr[x] <= 0) orphan(x);
+          break;
+        }
+        const up = nb(x, a);
+        cap[up * 4 + (a ^ 2)] -= f;
+        cap[x * 4 + a] += f;
+        if (cap[up * 4 + (a ^ 2)] <= 0) orphan(x);
+        x = up;
+      }
+      for (let x = t; ; ) {
+        const a = parent[x];
+        if (a === TERMINAL) {
+          tr[x] += f;
+          if (tr[x] >= 0) orphan(x);
+          break;
+        }
+        const up = nb(x, a);
+        cap[x * 4 + a] -= f;
+        cap[up * 4 + (a ^ 2)] += f;
+        if (cap[x * 4 + a] <= 0) orphan(x);
+        x = up;
+      }
+      flow += f;
+      while (orphanCount) {
+        const o = orphans[--orphanCount];
+        const oSide = tree[o];
+        let best = NONE;
+        let bestDist = Infinity;
+        for (let d = 0; d < 4; d++) {
+          const q = nb(o, d);
+          if (q < 0 || tree[q] !== oSide) continue;
+          if (oSide === SOURCE ? cap[q * 4 + (d ^ 2)] <= 0 : cap[o * 4 + d] <= 0) continue;
+          let k = 0;
+          let x = q;
+          for (; ; ) {
+            if (ts[x] === time) {
+              k += dist[x];
+              break;
+            }
+            const a = parent[x];
+            k++;
+            if (a === TERMINAL) {
+              ts[x] = time;
+              dist[x] = 1;
+              break;
+            }
+            if (a === NONE) {
+              k = Infinity;
+              break;
+            }
+            x = nb(x, a);
+          }
+          if (k === Infinity) continue;
+          if (k < bestDist) {
+            bestDist = k;
+            best = d;
+          }
+          for (let y = q, dd = k; ts[y] !== time; y = nb(y, parent[y]), dd--) {
+            ts[y] = time;
+            dist[y] = dd;
+          }
+        }
+        if (best !== NONE) {
+          parent[o] = best;
+          ts[o] = time;
+          dist[o] = bestDist + 1;
+          continue;
+        }
+        for (let d = 0; d < 4; d++) {
+          const q = nb(o, d);
+          if (q < 0 || tree[q] !== oSide) continue;
+          if (oSide === SOURCE ? cap[q * 4 + (d ^ 2)] > 0 : cap[o * 4 + d] > 0) activate(q);
+          const a = parent[q];
+          if (a !== TERMINAL && a !== NONE && nb(q, a) === o) orphan(q);
+        }
+        tree[o] = FREE;
+      }
+    }
+    return flow;
+  }
+};
+
+// src/image-editor/selection/segment/quick.ts
+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 { 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));
+  const h = Math.max(1, Math.round(H * scale));
+  const sum = new Float64Array(w * h * 3);
+  const count = new Float64Array(w * h);
+  const xs = new Int32Array(W);
+  for (let x = 0; x < W; x++) xs[x] = Math.min(w - 1, Math.floor(x * w / W));
+  for (let y = 0; y < H; y++) {
+    const row = Math.min(h - 1, Math.floor(y * h / H)) * w;
+    for (let x = 0, p = y * W * 4; x < W; x++, p += 4) {
+      const o = row + xs[x];
+      const a = data[p + 3] / 255;
+      const k = o * 3;
+      sum[k] += data[p] * a + 255 * (1 - a);
+      sum[k + 1] += data[p + 1] * a + 255 * (1 - a);
+      sum[k + 2] += data[p + 2] * a + 255 * (1 - a);
+      count[o]++;
+    }
+  }
+  const rgb = new Float32Array(w * h * 3);
+  for (let i = 0; i < w * h; i++) {
+    const c = count[i] || 1;
+    rgb[i * 3] = sum[i * 3] / c;
+    rgb[i * 3 + 1] = sum[i * 3 + 1] / c;
+    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 });
+  return work;
+}
+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) {
+  let a = hist;
+  for (const stride of [1, BINS, BINS * BINS]) {
+    const b = new Float64Array(a.length);
+    for (let i = 0; i < a.length; i++) {
+      const pos = Math.floor(i / stride) % BINS;
+      const lo = pos > 0 ? a[i - stride] : a[i];
+      const hi = pos < BINS - 1 ? a[i + stride] : a[i];
+      b[i] = (lo + 2 * a[i] + hi) / 4;
+    }
+    a = b;
+  }
+  const out = new Float64Array(a.length);
+  const floor = 1e-4;
+  const denom = Math.max(1, total) * (1 + floor * a.length);
+  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 = [];
+  const add2 = (g) => {
+    if (!mask[g]) {
+      mask[g] = 1;
+      list.push(g);
+    }
+  };
+  const segs = points.length === 1 ? [[points[0], points[0]]] : points.slice(1).map((p, i) => [points[i], p]);
+  for (const [a, b] of segs) {
+    const x0 = Math.max(0, Math.floor(Math.min(a.x, b.x) - r));
+    const x1 = Math.min(w - 1, Math.ceil(Math.max(a.x, b.x) + r));
+    const y0 = Math.max(0, Math.floor(Math.min(a.y, b.y) - r));
+    const y1 = Math.min(h - 1, Math.ceil(Math.max(a.y, b.y) + r));
+    const dx = b.x - a.x;
+    const dy = b.y - a.y;
+    const len2 = dx * dx + dy * dy;
+    for (let y = y0; y <= y1; y++) {
+      for (let x = x0; x <= x1; x++) {
+        const px2 = x + 0.5 - a.x;
+        const py = y + 0.5 - a.y;
+        const t = len2 > 0 ? Math.min(1, Math.max(0, (px2 * dx + py * dy) / len2)) : 0;
+        if ((px2 - t * dx) ** 2 + (py - t * dy) ** 2 <= r * r) add2(y * w + x);
+      }
+    }
+  }
+  if (!list.length) {
+    for (const p of points) add2(Math.min(h - 1, Math.max(0, Math.floor(p.y))) * w + Math.min(w - 1, Math.max(0, Math.floor(p.x))));
+  }
+  return { mask, list };
+}
+function segmentStroke(work, stroke, grown, start) {
+  const { width: w, height: h, rgb } = work;
+  let roi = start;
+  for (; ; ) {
+    const { x: rx, y: ry, width: rw, height: rh } = roi;
+    const n = rw * rh;
+    const fgHist = new Float64Array(BINS ** 3);
+    const bgHist = new Float64Array(BINS ** 3);
+    let fgN = 0;
+    let bgN = 0;
+    const atImageEdge = { l: rx === 0, t: ry === 0, r: rx + rw === w, b: ry + rh === h };
+    for (let y = 0; y < rh; y++) {
+      for (let x = 0; x < rw; x++) {
+        const g = (ry + y) * w + (rx + x);
+        const bin = binOf(rgb, g);
+        bgHist[bin]++;
+        bgN++;
+        if (stroke.mask[g] || grown?.[g]) {
+          fgHist[bin]++;
+          fgN++;
+        }
+      }
+    }
+    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 graph = new GridGraph(rw, rh);
+    const HARD = 1e9;
+    for (let y = 0; y < rh; y++) {
+      for (let x = 0; x < rw; x++) {
+        const p = y * rw + x;
+        const g = (ry + y) * w + rx + x;
+        if (stroke.mask[g]) graph.addTerminal(p, HARD, 0);
+        else {
+          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)));
+        }
+      }
+    }
+    graph.maxflow();
+    const label = new Uint8Array(n);
+    const stack = [];
+    for (const g of stroke.list) {
+      const x = g % w - rx;
+      const y = Math.floor(g / w) - ry;
+      if (x < 0 || y < 0 || x >= rw || y >= rh) continue;
+      const p = y * rw + x;
+      if (!label[p]) {
+        label[p] = 1;
+        stack.push(p);
+      }
+    }
+    while (stack.length) {
+      const p = stack.pop();
+      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] && graph.inSource(q)) {
+          label[q] = 1;
+          stack.push(q);
+        }
+      }
+    }
+    let touches = false;
+    for (let y = 0; y < rh; y++) {
+      for (let x = 0; x < rw; x++) {
+        const p = y * rw + x;
+        if (!label[p]) continue;
+        if (!atImageEdge.l && x === 0 || !atImageEdge.t && y === 0 || !atImageEdge.r && x === rw - 1 || !atImageEdge.b && y === rh - 1) touches = true;
+      }
+    }
+    if (!touches || atImageEdge.l && atImageEdge.t && atImageEdge.r && atImageEdge.b) return { roi, label };
+    const nx = Math.max(0, rx - Math.ceil(rw / 2));
+    const ny = Math.max(0, ry - Math.ceil(rh / 2));
+    roi = { x: nx, y: ny, width: Math.min(w, rx + rw + Math.ceil(rw / 2)) - nx, height: Math.min(h, ry + rh + Math.ceil(rh / 2)) - ny };
+    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);
+  const { width: w, height: h, scale } = work;
+  const r = Math.max(0.5, (options.size ?? 30) / 2 * scale);
+  const pts = stroke.map((p) => ({ x: p.x * scale, y: p.y * scale }));
+  const seeds = strokePixels(pts, r, w, h);
+  let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+  for (const p of pts) {
+    x0 = Math.min(x0, p.x);
+    y0 = Math.min(y0, p.y);
+    x1 = Math.max(x1, p.x);
+    y1 = Math.max(y1, p.y);
+  }
+  const margin = Math.max(24, 4 * r);
+  const rx = Math.max(0, Math.floor(x0 - margin));
+  const ry = Math.max(0, Math.floor(y0 - margin));
+  const roi = { x: rx, y: ry, width: Math.min(w, Math.ceil(x1 + margin)) - rx, height: Math.min(h, Math.ceil(y1 + margin)) - ry };
+  let grown = null;
+  const sel = options.grow ? options.selection : null;
+  if (sel?.bounds) {
+    grown = new Uint8Array(w * h);
+    const b = sel.bounds;
+    for (let y = Math.max(0, Math.floor(b.y * scale)); y < Math.min(h, Math.ceil((b.y + b.height) * scale)); y++) {
+      for (let x = Math.max(0, Math.floor(b.x * scale)); x < Math.min(w, Math.ceil((b.x + b.width) * scale)); x++) {
+        if (selectionValueAt(sel, Math.min(sel.width - 1, Math.floor((x + 0.5) / scale)), Math.min(sel.height - 1, Math.floor((y + 0.5) / scale))) >= 0.5) grown[y * w + x] = 1;
+      }
+    }
+  }
+  const { roi: done, label } = segmentStroke(work, seeds, grown, roi);
+  return upscaleRegion(work, pixels, done, label, options.enhanceEdge ?? false);
+}
+
 // src/image-editor/layers/shape-type-ui.ts
 var DEFAULT_SHAPE_TOOL_OPTIONS = {
   kind: "rect",
@@ -8747,6 +9330,31 @@ var ImageEditorController = class {
     const pixels = await this.requirePixels(options);
     return snapPolygonToEdges(pixels, points, options);
   }
+  /**
+   * Quick Selection: each stroke (the brush's path in natural pixels) grows into the region it is
+   * painted on, out to that region's edges, and is combined with the selection by `mode`; with
+   * `replace`, the first stroke replaces it and the rest add, as the brush does. All strokes are
+   * one undo step. Resolves to the resulting selection.
+   */
+  async quickSelect(strokes, options = {}) {
+    if (!strokes.length || strokes.some((s) => !s.length)) throw new Error("Pass at least one stroke, each with at least one point.");
+    const { width, height } = this.naturalSize;
+    for (const s of strokes) {
+      if (!s.some((p) => p.x >= 0 && p.y >= 0 && p.x < width && p.y < height)) {
+        throw new Error(`A stroke lies entirely outside the image (0..${width - 1}, 0..${height - 1}); paint over the area to select.`);
+      }
+    }
+    const pixels = await this.requirePixels({ sample: options.sampleAllLayers === false ? "active-layer" : "composite" });
+    const mode = options.mode ?? "replace";
+    let sel = this.state.selection ?? null;
+    strokes.forEach((stroke, i) => {
+      const m = mode === "replace" && i > 0 ? "add" : mode;
+      const region = quickSelectStroke(pixels, stroke, { size: options.size, selection: sel, grow: m === "add", enhanceEdge: options.enhanceEdge });
+      sel = combineSelections(sel, region, m);
+    });
+    this.setSelection(sel, "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)
@@ -11634,7 +12242,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|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_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)$/;
@@ -11756,6 +12364,7 @@ var SELECTION_TOOLS = [
   { id: "lasso", label: "Lasso" },
   { id: "polygon", label: "Polygonal Lasso" },
   { id: "magnetic", label: "Magnetic Lasso" },
+  { id: "quick", label: "Quick Selection" },
   { id: "range", label: "Color Range" },
   { id: "type", label: "Type Mask" },
   { id: "type-vertical", label: "Vertical Type Mask" }
@@ -11793,6 +12402,9 @@ var DEFAULT_SELECTION_TOOL_OPTIONS = {
   magneticWidth: 10,
   magneticContrast: 10,
   magneticFrequency: 57,
+  quickSize: 30,
+  quickSampleAll: true,
+  quickEnhance: false,
   typeText: "Type",
   typeSize: 72,
   typeFamily: "sans-serif"
@@ -12192,6 +12804,42 @@ function createImageSelectionTools(controller) {
       return { ...summary(controller), outlinePoints: outline.length };
     }
   };
+  const quickSelectTool = {
+    name: "quick_select",
+    title: "Quick Selection",
+    description: "Quick Selection: paints brush strokes (paths in natural image pixels) that each grow into the region they are painted on, out to its edges (a graph cut on colour and edges), combined with the selection by mode. With replace (default) the first stroke replaces the selection and later ones add, as the brush does; use mode subtract to take an area back out. Best for a subject or area that differs from its surroundings: paint inside it, away from the edge, then check with get_selection and capture_view and add or subtract strokes where it leaked or fell short. All strokes are one undoable step. Returns the selection.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        strokes: {
+          type: "array",
+          minItems: 1,
+          items: { type: "array", minItems: 1, items: pointSchema, description: "One stroke: the brush path, in order (one point is a dab)." },
+          description: "Brush strokes in natural image pixels, applied in order."
+        },
+        size: { type: "number", minimum: 1, maximum: 2500, description: "Brush diameter in natural image pixels (default 30). Smaller for a narrow area, larger for a broad one." },
+        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). Use it before masking a smooth-edged subject." }
+      },
+      required: ["strokes"],
+      additionalProperties: false
+    },
+    annotations: writeAnnotations("Quick Selection"),
+    handler: async (args) => {
+      const strokes = Array.isArray(args.strokes) ? args.strokes.map((s) => Array.isArray(s) ? s.map((p) => ({ x: num2(p?.x, NaN), y: num2(p?.y, NaN) })) : []) : [];
+      if (!strokes.length || strokes.some((s) => !s.length || !s.every((p) => Number.isFinite(p.x) && Number.isFinite(p.y)))) {
+        throw new Error("strokes needs at least one stroke of { x, y } points in natural image pixels.");
+      }
+      await controller.quickSelect(strokes, {
+        size: args.size === void 0 ? void 0 : num2(args.size, 30),
+        mode: parseSelectionMode(args.mode),
+        sampleAllLayers: args.sampleAllLayers,
+        enhanceEdge: args.enhanceEdge
+      });
+      return summary(controller);
+    }
+  };
   const magicWandTool = {
     name: "magic_wand",
     title: "Magic wand",
@@ -12744,6 +13392,7 @@ function createImageSelectionTools(controller) {
     selectRect,
     selectEllipse,
     selectPolygonTool,
+    quickSelectTool,
     lineTool,
     magicWandTool,
     colorRangeTool,
@@ -14131,9 +14780,14 @@ var SelectionGesture = class {
   closeRadius = 8;
   /** The last error (e.g. pixels unavailable for the wand), for the UI to show. */
   error = null;
+  pending = Promise.resolve();
   get active() {
     return this.start !== null || this.polygon !== null || this.magnetic !== null;
   }
+  /** Resolves once a Quick Selection stroke has been applied. */
+  get settled() {
+    return this.pending;
+  }
   /** The anchors of a Magnetic Lasso being drawn (empty otherwise). */
   get magneticAnchors() {
     const m = this.magnetic;
@@ -14145,7 +14799,7 @@ var SelectionGesture = class {
     if (this.polygon) return this.current ? [...this.polygon, this.current] : this.polygon.slice();
     if (!this.start || !this.current) return null;
     const { tool } = this.getOptions();
-    if (tool === "lasso") return this.points.length > 1 ? this.points.slice() : null;
+    if (tool === "lasso" || tool === "quick") return this.points.length > 1 ? this.points.slice() : null;
     const rect = normalizeRect({
       x: this.start.x,
       y: this.start.y,
@@ -14279,7 +14933,8 @@ var SelectionGesture = class {
     }
     if (!this.start) return false;
     this.current = point;
-    if (this.getOptions().tool === "lasso") {
+    const drawn = this.getOptions().tool;
+    if (drawn === "lasso" || drawn === "quick") {
       const last = this.points[this.points.length - 1];
       if (Math.hypot(point.x - last.x, point.y - last.y) < 0.5) return false;
       this.points.push(point);
@@ -14299,6 +14954,25 @@ var SelectionGesture = class {
     if (point) this.move(point);
     const options = this.getOptions();
     const mode = selectionModeFromModifiers(modifiers ?? this.modifiers, options.mode);
+    if (options.tool === "quick") {
+      const stroke = this.points;
+      this.start = null;
+      this.current = null;
+      this.points = [];
+      const strokeMode = mode === "replace" && this.controller.getSelection() ? "add" : mode;
+      this.pending = this.controller.quickSelect([stroke], {
+        size: options.quickSize ?? 30,
+        mode: strokeMode,
+        sampleAllLayers: options.quickSampleAll ?? true,
+        enhanceEdge: options.quickEnhance ?? false
+      }).then(
+        () => void 0,
+        (err) => {
+          this.error = err instanceof Error ? err.message : String(err);
+        }
+      );
+      return false;
+    }
     const path = this.draftPath;
     const rect = normalizeRect({
       x: this.start.x,
@@ -15154,7 +15828,7 @@ function checkSource(controller, source) {
   }
   return p;
 }
-var SOURCE = {
+var SOURCE2 = {
   type: "object",
   description: "Source point in document pixels (an Alt-click). Given, it replaces the clone source and the offset starts afresh at this stroke; missing, the current clone source is used (set_clone_source).",
   properties: { x: { type: "number", description: "Source x in px." }, y: { type: "number", description: "Source y in px." } },
@@ -15178,7 +15852,7 @@ function createImageRetouchTools(controller) {
       type: "object",
       properties: {
         points: POINTS,
-        source: SOURCE,
+        source: SOURCE2,
         aligned: { type: "boolean", description: "Keep the offset for the next strokes (default the current option, true)." },
         sample: SAMPLE,
         brush: BRUSH2,
@@ -15198,7 +15872,7 @@ function createImageRetouchTools(controller) {
       type: "object",
       properties: {
         points: POINTS,
-        source: SOURCE,
+        source: SOURCE2,
         aligned: { type: "boolean", description: "Keep the offset for the next strokes (default the current option, true)." },
         sample: SAMPLE,
         brush: BRUSH2,
@@ -18981,6 +19655,7 @@ export {
   GRAIN_PATTERNS,
   GRAIN_TILE,
   GUIDED_FILTER_EPS,
+  GridGraph,
   HIDE,
   HISTOGRAM_BINS,
   HUE_RANGE_LABELS,
@@ -19149,6 +19824,7 @@ export {
   WGSL_SHADE,
   WGSL_STEP,
   WORKING_SPACE_OPTIONS,
+  WORK_SIZE,
   WetGpuEngine,
   WetMedium,
   WetWorkerPool,
@@ -19699,6 +20375,7 @@ export {
   put255,
   quadFrameOverlay,
   quickMaskPixels,
+  quickSelectStroke,
   rand01,
   randSigned,
   rangeLightness,
@@ -19941,6 +20618,7 @@ export {
   withFilterMaskSurface,
   withImagePlayback,
   withNewIds,
+  workImage,
   writeAdjustmentBlock,
   writeDeepRegion,
   writeLfx2,