@pixerate/editor 0.209.0 → 0.210.0

package/dist/chunk-XI2NV5U7.js

@@ -0,0 +1,462 @@
+// src/paint/heal.ts
+var TOL = 2e-3;
+var FINE_ITERS = 30;
+var FINE_OMEGA = 1.7;
+function solveMembrane(w, h, unknown, v) {
+  if (unknown.length !== w * h || v.length !== w * h) throw new RangeError(`solveMembrane: expected ${w * h} cells, got ${unknown.length} and ${v.length}.`);
+  const u = new Uint8Array(w * h);
+  for (let i = 0; i < u.length; i++) u[i] = unknown[i] ? 1 : 0;
+  solveLevel(w, h, u, v, 0);
+}
+function solveLevel(w, h, unknown, v, depth) {
+  let nUnknown = 0;
+  let knownSum = 0;
+  let nKnown = 0;
+  for (let i = 0; i < unknown.length; i++) {
+    if (unknown[i]) nUnknown++;
+    else {
+      knownSum += v[i];
+      nKnown++;
+    }
+  }
+  if (nUnknown === 0 || nKnown === 0) return;
+  if (w >= 8 && h >= 8 && nUnknown > 64 && depth < 16) {
+    const cw = Math.ceil(w / 2);
+    const chh = Math.ceil(h / 2);
+    const cu = new Uint8Array(cw * chh).fill(1);
+    const cv = new Float32Array(cw * chh);
+    for (let cy = 0; cy < chh; cy++) {
+      for (let cx = 0; cx < cw; cx++) {
+        let s = 0;
+        let n = 0;
+        for (let k = 0; k < 4; k++) {
+          const x = cx * 2 + (k & 1);
+          const y = cy * 2 + (k >> 1);
+          if (x < w && y < h && !unknown[y * w + x]) {
+            s += v[y * w + x];
+            n++;
+          }
+        }
+        if (n > 0) {
+          cu[cy * cw + cx] = 0;
+          cv[cy * cw + cx] = s / n;
+        }
+      }
+    }
+    solveLevel(cw, chh, cu, cv, depth + 1);
+    for (let y = 0; y < h; y++) {
+      const fy = Math.min(chh - 1, Math.max(0, (y + 0.5) / 2 - 0.5));
+      const y0 = Math.floor(fy);
+      const y1 = Math.min(chh - 1, y0 + 1);
+      const ty = fy - y0;
+      for (let x = 0; x < w; x++) {
+        if (!unknown[y * w + x]) continue;
+        const fx = Math.min(cw - 1, Math.max(0, (x + 0.5) / 2 - 0.5));
+        const x0 = Math.floor(fx);
+        const x1 = Math.min(cw - 1, x0 + 1);
+        const tx = fx - x0;
+        const a = cv[y0 * cw + x0] + (cv[y0 * cw + x1] - cv[y0 * cw + x0]) * tx;
+        const b = cv[y1 * cw + x0] + (cv[y1 * cw + x1] - cv[y1 * cw + x0]) * tx;
+        v[y * w + x] = a + (b - a) * ty;
+      }
+    }
+    sor(w, h, unknown, v, FINE_ITERS, FINE_OMEGA);
+  } else {
+    const mean = knownSum / nKnown;
+    for (let i = 0; i < v.length; i++) if (unknown[i]) v[i] = mean;
+    sor(w, h, unknown, v, 2e3, 1.85);
+  }
+}
+function sor(w, h, unknown, v, maxIter, omega) {
+  let n = 0;
+  for (let i = 0; i < unknown.length; i++) if (unknown[i]) n++;
+  const cells = new Uint32Array(n);
+  const masks = new Uint8Array(n);
+  for (let i = 0, k = 0; i < unknown.length; i++) {
+    if (!unknown[i]) continue;
+    const x = i % w;
+    const y = (i - x) / w;
+    cells[k] = i;
+    masks[k++] = (x > 0 ? 1 : 0) | (x + 1 < w ? 2 : 0) | (y > 0 ? 4 : 0) | (y + 1 < h ? 8 : 0);
+  }
+  for (let it = 0; it < maxIter; it++) {
+    let maxD = 0;
+    for (let k = 0; k < n; k++) {
+      const i = cells[k];
+      const m = masks[k];
+      let s;
+      let c;
+      if (m === 15) {
+        s = v[i - 1] + v[i + 1] + v[i - w] + v[i + w];
+        c = 4;
+      } else {
+        s = 0;
+        c = 0;
+        if (m & 1) s += v[i - 1], c++;
+        if (m & 2) s += v[i + 1], c++;
+        if (m & 4) s += v[i - w], c++;
+        if (m & 8) s += v[i + w], c++;
+        if (c === 0) continue;
+      }
+      const d = omega * (s / c - v[i]);
+      v[i] += d;
+      const ad = d < 0 ? -d : d;
+      if (ad > maxD) maxD = ad;
+    }
+    if (maxD < TOL) break;
+  }
+}
+function seamlessClone(w, h, ch, src, dst, mask) {
+  const n = w * h;
+  if (src.length !== n * ch || dst.length !== n * ch || mask.length !== n) throw new RangeError("seamlessClone: src, dst and mask must cover w \xD7 h pixels.");
+  const out = new Float32Array(n * ch);
+  const hv = new Float32Array(n);
+  for (let c = 0; c < ch; c++) {
+    for (let i = 0; i < n; i++) hv[i] = mask[i] ? 0 : dst[i * ch + c] - src[i * ch + c];
+    solveMembrane(w, h, mask, hv);
+    for (let i = 0; i < n; i++) out[i * ch + c] = mask[i] ? src[i * ch + c] + hv[i] : dst[i * ch + c];
+  }
+  return out;
+}
+function membraneFill(w, h, ch, img, hole) {
+  const n = w * h;
+  const out = new Float32Array(n * ch);
+  const v = new Float32Array(n);
+  for (let c = 0; c < ch; c++) {
+    for (let i = 0; i < n; i++) v[i] = hole[i] ? 0 : img[i * ch + c];
+    solveMembrane(w, h, hole, v);
+    for (let i = 0; i < n; i++) out[i * ch + c] = v[i];
+  }
+  return out;
+}
+function dilateMask(w, h, mask, r) {
+  const tmp = new Uint8Array(w * h);
+  for (let y = 0; y < h; y++) {
+    for (let x = 0; x < w; x++) {
+      if (!mask[y * w + x]) continue;
+      for (let xx = Math.max(0, x - r); xx <= Math.min(w - 1, x + r); xx++) tmp[y * w + xx] = 1;
+    }
+  }
+  const out = new Uint8Array(w * h);
+  for (let y = 0; y < h; y++) {
+    for (let x = 0; x < w; x++) {
+      if (!tmp[y * w + x]) continue;
+      for (let yy = Math.max(0, y - r); yy <= Math.min(h - 1, y + r); yy++) out[yy * w + x] = 1;
+    }
+  }
+  return out;
+}
+var MaskIntegral = class {
+  constructor(w, h, mask) {
+    this.w = w;
+    this.h = h;
+    const W = w + 1;
+    this.s = new Uint32Array(W * (h + 1));
+    for (let y = 0; y < h; y++) {
+      let row = 0;
+      for (let x = 0; x < w; x++) {
+        row += mask[y * w + x] ? 1 : 0;
+        this.s[(y + 1) * W + x + 1] = this.s[y * W + x + 1] + row;
+      }
+    }
+  }
+  w;
+  h;
+  s;
+  /** Masked cells in [x0, x1) × [y0, y1) (clipped to the grid). */
+  count(x0, y0, x1, y1) {
+    const W = this.w + 1;
+    const a = Math.max(0, Math.min(this.w, x0));
+    const b = Math.max(0, Math.min(this.h, y0));
+    const c = Math.max(0, Math.min(this.w, x1));
+    const d = Math.max(0, Math.min(this.h, y1));
+    if (c <= a || d <= b) return 0;
+    return this.s[d * W + c] - this.s[b * W + c] - this.s[d * W + a] + this.s[b * W + a];
+  }
+};
+function maskBounds(w, h, mask) {
+  let x0 = w;
+  let y0 = h;
+  let x1 = -1;
+  let y1 = -1;
+  for (let y = 0; y < h; y++) {
+    for (let x = 0; x < w; x++) {
+      if (!mask[y * w + x]) continue;
+      if (x < x0) x0 = x;
+      if (x > x1) x1 = x;
+      if (y < y0) y0 = y;
+      if (y > y1) y1 = y;
+    }
+  }
+  return x1 < 0 ? null : [x0, y0, x1 + 1, y1 + 1];
+}
+function bestOffset(w, h, ch, img, hole, ring, maxRadius) {
+  const bb = maskBounds(w, h, hole);
+  if (!bb) return null;
+  const extent = Math.max(w, h);
+  const R = Math.max(0, Math.min(extent, Math.floor(maxRadius)));
+  if (R === 0) return null;
+  const rg = Math.max(1, Math.min(extent, Math.floor(ring)));
+  const hs = new MaskIntegral(w, h, hole);
+  const x0 = bb[0] - rg;
+  const y0 = bb[1] - rg;
+  const x1 = bb[2] + rg;
+  const y1 = bb[3] + rg;
+  const pts = [];
+  for (let y = Math.max(0, y0); y < Math.min(h, y1); y++) {
+    for (let x = Math.max(0, x0); x < Math.min(w, x1); x++) {
+      if (hole[y * w + x]) continue;
+      if (hs.count(x - rg, y - rg, x + rg + 1, y + rg + 1) > 0) pts.push(x, y);
+    }
+  }
+  const stride = Math.max(1, Math.floor(pts.length / 2 / 2e3));
+  const sx = [];
+  const sy = [];
+  for (let i = 0; i < pts.length; i += 2 * stride) {
+    sx.push(pts[i]);
+    sy.push(pts[i + 1]);
+  }
+  const n = Math.max(1, sx.length);
+  const evalAt = (dx, dy, cutoff) => {
+    if (dx === 0 && dy === 0) return null;
+    const hx0 = x0 + dx;
+    const hy0 = y0 + dy;
+    const hx1 = x1 + dx;
+    const hy1 = y1 + dy;
+    if (hx0 < 0 || hy0 < 0 || hx1 > w || hy1 > h) return null;
+    if (hs.count(hx0, hy0, hx1, hy1) !== 0) return null;
+    const penalty = 1 + 1e-3 * (Math.hypot(dx, dy) / R);
+    let e = 0;
+    for (let i = 0; i < sx.length; i++) {
+      const a = (sy[i] * w + sx[i]) * ch;
+      const b = ((sy[i] + dy) * w + sx[i] + dx) * ch;
+      for (let c = 0; c < ch; c++) {
+        const d = img[a + c] - img[b + c];
+        e += d * d;
+      }
+      if ((i & 31) === 31 && e / n * penalty >= cutoff) return null;
+    }
+    return e / n * penalty;
+  };
+  const found = { best: null, e: Infinity };
+  const consider = (dx, dy) => {
+    const e = evalAt(dx, dy, found.e);
+    if (e !== null && e < found.e) {
+      found.e = e;
+      found.best = [dx, dy];
+    }
+  };
+  const step = Math.max(1, Math.floor(R / 24));
+  for (let dy = -R; dy <= R; dy += step) for (let dx = -R; dx <= R; dx += step) consider(dx, dy);
+  if (step > 1 && found.best) {
+    const [bx, by] = found.best;
+    for (let dy = by - step; dy <= by + step; dy++) for (let dx = bx - step; dx <= bx + step; dx++) consider(dx, dy);
+  }
+  return found.best;
+}
+var PATCH_R = 3;
+function rng(seed) {
+  let a = seed >>> 0;
+  return () => {
+    a = a + 1831565813 >>> 0;
+    let t = a;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function downsample(l, ch) {
+  const w = Math.max(1, l.w >> 1);
+  const h = Math.max(1, l.h >> 1);
+  const img = new Float32Array(w * h * ch);
+  const hole = new Uint8Array(w * h);
+  const exclude = l.exclude ? new Uint8Array(w * h) : null;
+  for (let y = 0; y < h; y++) {
+    for (let x = 0; x < w; x++) {
+      let n = 0;
+      const o = (y * w + x) * ch;
+      for (let dy = 0; dy < 2; dy++) {
+        for (let dx = 0; dx < 2; dx++) {
+          const sx = Math.min(l.w - 1, 2 * x + dx);
+          const sy = Math.min(l.h - 1, 2 * y + dy);
+          const i = sy * l.w + sx;
+          if (exclude && l.exclude[i]) exclude[y * w + x] = 1;
+          if (l.hole[i]) {
+            hole[y * w + x] = 1;
+            continue;
+          }
+          for (let c = 0; c < ch; c++) img[o + c] += l.img[i * ch + c];
+          n++;
+        }
+      }
+      if (n) for (let c = 0; c < ch; c++) img[o + c] /= n;
+    }
+  }
+  return { w, h, img, hole, exclude };
+}
+function contentAwareFill(w, h, ch, img, hole, options = {}) {
+  const iters = options.iterations ?? 4;
+  const base = {
+    w,
+    h,
+    img: Float32Array.from(img),
+    hole: Uint8Array.from(hole, (v) => v ? 1 : 0),
+    exclude: options.exclude ? Uint8Array.from(options.exclude, (v) => v ? 1 : 0) : null
+  };
+  const levels = [base];
+  while (levels.length < 4) {
+    const top = levels[levels.length - 1];
+    const b = maskBounds(top.w, top.h, top.hole);
+    if (!b || Math.max(b[2] - b[0], b[3] - b[1]) < 4 * PATCH_R || top.w < 8 * PATCH_R || top.h < 8 * PATCH_R) break;
+    levels.push(downsample(top, ch));
+  }
+  const random = rng(options.seed ?? w * 73856093 + h * 19349663);
+  let prevFill = null;
+  let prevNnf = null;
+  let prevW = 0;
+  for (let li = levels.length - 1; li >= 0; li--) {
+    const { w: W, h: H, hole: holeL, exclude: excludeL } = levels[li];
+    const cur = new Float32Array(levels[li].img);
+    if (prevFill) {
+      for (let i = 0; i < W * H; i++) {
+        if (!holeL[i]) continue;
+        const x = Math.min(prevW - 1, i % W >> 1);
+        const y = Math.min(Math.floor(prevFill.length / ch / prevW) - 1, Math.floor(i / W) >> 1);
+        for (let c = 0; c < ch; c++) cur[i * ch + c] = prevFill[(y * prevW + x) * ch + c];
+      }
+    } else cur.set(membraneFill(W, H, ch, cur, holeL));
+    const holeBlocked = dilateMask(W, H, holeL, PATCH_R);
+    let blocked = holeBlocked;
+    if (excludeL) {
+      const off = dilateMask(W, H, excludeL, PATCH_R);
+      const sourceBlocked = new Uint8Array(W * H);
+      for (let i = 0; i < W * H; i++) sourceBlocked[i] = holeBlocked[i] || off[i] ? 1 : 0;
+      blocked = sourceBlocked;
+    }
+    const valid = [];
+    for (let y = PATCH_R; y < H - PATCH_R; y++) for (let x = PATCH_R; x < W - PATCH_R; x++) if (!blocked[y * W + x]) valid.push(y * W + x);
+    if (!valid.length) {
+      prevFill = cur;
+      prevNnf = null;
+      prevW = W;
+      continue;
+    }
+    const targets = [];
+    for (let y = 0; y < H; y++) for (let x = 0; x < W; x++) if (holeBlocked[y * W + x]) targets.push(y * W + x);
+    const nnf = new Int32Array(W * H).fill(-1);
+    const cost = new Float64Array(W * H);
+    const clampC = (v, n) => Math.min(n - 1 - PATCH_R, Math.max(PATCH_R, v));
+    const dist = (t, s, limit) => {
+      const tx = clampC(t % W, W);
+      const ty = clampC(Math.floor(t / W), H);
+      const sx = s % W;
+      const sy = Math.floor(s / W);
+      let d = 0;
+      for (let dy = -PATCH_R; dy <= PATCH_R; dy++) {
+        const tr = (ty + dy) * W;
+        const sr = (sy + dy) * W;
+        for (let dx = -PATCH_R; dx <= PATCH_R; dx++) {
+          const a = (tr + tx + dx) * ch;
+          const b = (sr + sx + dx) * ch;
+          for (let c = 0; c < ch; c++) {
+            const e = cur[a + c] - cur[b + c];
+            d += e * e;
+          }
+        }
+        if (d >= limit) return d;
+      }
+      return d;
+    };
+    const isValid = (s) => {
+      const x = s % W;
+      const y = Math.floor(s / W);
+      return s >= 0 && x >= PATCH_R && y >= PATCH_R && x < W - PATCH_R && y < H - PATCH_R && !blocked[s];
+    };
+    for (const t of targets) {
+      let s = -1;
+      if (prevNnf) {
+        const px = Math.min(prevW - 1, t % W >> 1);
+        const py = Math.floor(t / W) >> 1;
+        const ps = prevNnf[py * prevW + px];
+        if (ps >= 0) {
+          const cand = (Math.floor(ps / prevW) * 2 + (Math.floor(t / W) & 1)) * W + ps % prevW * 2 + (t % W & 1);
+          if (isValid(cand)) s = cand;
+        }
+      }
+      if (s < 0) s = valid[Math.floor(random() * valid.length)];
+      nnf[t] = s;
+    }
+    for (let em = 0; em < iters; em++) {
+      for (const t of targets) cost[t] = dist(t, nnf[t], Infinity);
+      for (let pass = 0; pass < 4; pass++) {
+        const fwd = pass % 2 === 0;
+        const step = fwd ? 1 : -1;
+        for (let k = 0; k < targets.length; k++) {
+          const t = targets[fwd ? k : targets.length - 1 - k];
+          const tx = t % W;
+          const ty = Math.floor(t / W);
+          for (const [nx, ny] of [[tx - step, ty], [tx, ty - step]]) {
+            if (nx < 0 || ny < 0 || nx >= W || ny >= H) continue;
+            const ns = nnf[ny * W + nx];
+            if (ns < 0) continue;
+            const cand = ns + step * (nx === tx ? W : 1);
+            if (!isValid(cand) || cand === nnf[t]) continue;
+            const d = dist(t, cand, cost[t]);
+            if (d < cost[t]) {
+              cost[t] = d;
+              nnf[t] = cand;
+            }
+          }
+          const bx = nnf[t] % W;
+          const by = Math.floor(nnf[t] / W);
+          for (let r = Math.max(W, H); r >= 1; r >>= 1) {
+            const cx = Math.round(bx + (random() * 2 - 1) * r);
+            const cy = Math.round(by + (random() * 2 - 1) * r);
+            const cand = cy * W + cx;
+            if (cx < 0 || cy < 0 || cx >= W || cy >= H || !isValid(cand)) continue;
+            const d = dist(t, cand, cost[t]);
+            if (d < cost[t]) {
+              cost[t] = d;
+              nnf[t] = cand;
+            }
+          }
+        }
+      }
+      const acc = new Float64Array(W * H * ch);
+      const wsum = new Float64Array(W * H);
+      for (const t of targets) {
+        const tx = clampC(t % W, W);
+        const ty = clampC(Math.floor(t / W), H);
+        const s = nnf[t];
+        const sx = s % W;
+        const sy = Math.floor(s / W);
+        for (let dy = -PATCH_R; dy <= PATCH_R; dy++) {
+          for (let dx = -PATCH_R; dx <= PATCH_R; dx++) {
+            const q = (ty + dy) * W + tx + dx;
+            if (!holeL[q]) continue;
+            const src = ((sy + dy) * W + sx + dx) * ch;
+            for (let c = 0; c < ch; c++) acc[q * ch + c] += cur[src + c];
+            wsum[q] += 1;
+          }
+        }
+      }
+      for (let q = 0; q < W * H; q++) if (holeL[q] && wsum[q] > 0) for (let c = 0; c < ch; c++) cur[q * ch + c] = acc[q * ch + c] / wsum[q];
+    }
+    prevFill = cur;
+    prevNnf = nnf;
+    prevW = W;
+  }
+  const out = Float32Array.from(img);
+  for (let i = 0; i < w * h; i++) if (base.hole[i]) for (let c = 0; c < ch; c++) out[i * ch + c] = prevFill[i * ch + c];
+  return out;
+}
+
+export {
+  solveMembrane,
+  seamlessClone,
+  membraneFill,
+  dilateMask,
+  maskBounds,
+  bestOffset,
+  contentAwareFill
+};