@jax-data-science/sci-image-visualizer 0.1.0

package/fesm2022/mask.worker.js

@@ -0,0 +1,989 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+
+// src/lib/region-editor/mask.worker.ts
+import { encode as encodePng } from "fast-png";
+
+// src/lib/toolbar/wand/wand.service.ts
+import { Injectable } from "@angular/core";
+
+// src/lib/models/region.ts
+var Polygon = class {
+  constructor() {
+    this.npoints = 0;
+    this.xpoints = [];
+    this.ypoints = [];
+    this.coordinates = [];
+    /** false for open polylines; true (default) for closed polygons */
+    this.closed = true;
+    /**
+     * When true the vertices are treated as bezier-spline **anchors** and the
+     * region is rendered/exported as a smooth curve through them. The vertices
+     * stay the editable anchors — toggling this flag is the toBezier
+     * (`true`) / toPolygon (`false`), which only add/remove the curve, never move
+     * the anchors. GeoJSON keeps the flattened curve as the geometry (so QuPath
+     * renders it) plus the anchors + handles + flag in properties (so JIT
+     * round-trips the editable bezier).
+     */
+    this.bezier = false;
+  }
+};
+
+// src/lib/toolbar/wand/wand.service.ts
+var DEFAULT_PATCH_SIZE = 149;
+var DEFAULT_SIGMA = 4;
+var DEFAULT_SENSITIVITY = 2;
+var WandService = class {
+  /**
+   * @param image full-image pixel matrix (already in memory).
+   * @param cx click x in image-pixel coordinates.
+   * @param cy click y in image-pixel coordinates.
+   * @param options wand parameters; missing fields fall back to defaults.
+   * @returns a Polygon in image-pixel coordinates, or null if no region grew.
+   */
+  computeRegion(image, cx, cy, options = {}) {
+    const patch = this.computePatchMask(image, cx, cy, options);
+    if (!patch)
+      return null;
+    return this.maskToPolygon(
+      patch.mask,
+      patch.size,
+      patch.size,
+      image.width,
+      image.height,
+      Math.round(cx) - (patch.size - 1) / 2,
+      Math.round(cy) - (patch.size - 1) / 2
+    );
+  }
+  /**
+   * Compute the wand's per-click flood-fill mask in patch-local coordinates.
+   * Same algorithm as `computeRegion` but stops before contour tracing — useful
+   * for accumulating per-tick masks across a brush-style stroke.
+   *
+   * @returns mask of size W*W (0/1) plus W, or null if patchSize is invalid.
+   */
+  computePatchMask(image, cx, cy, options = {}) {
+    const W = options.patchSize ?? DEFAULT_PATCH_SIZE;
+    if (W % 2 === 0) {
+      throw new Error(`patchSize must be odd, got ${W}`);
+    }
+    const sigma = options.sigma ?? DEFAULT_SIGMA;
+    const sensitivity = options.sensitivity ?? DEFAULT_SENSITIVITY;
+    const isGrayscale = image.isGrayscale;
+    const type = options.type ?? (isGrayscale ? "GRAY" : "RGB");
+    const simple = !!options.simpleMode;
+    const inputChannels = type === "GRAY" ? 1 : 3;
+    let buf = this.extractPatch(image, cx, cy, W, type);
+    let floodChannels;
+    let threshold;
+    if (simple) {
+      floodChannels = inputChannels;
+      threshold = new Array(floodChannels).fill(0);
+    } else {
+      const blurSigma = Math.max(0.5, sigma);
+      buf = this.gaussianBlur(buf, W, inputChannels, blurSigma);
+      if (type === "LAB_DISTANCE") {
+        const distance = this.labDistanceMap(buf, W);
+        const max = distance.max > 0 ? distance.max : 1;
+        const scaled = new Float32Array(W * W);
+        for (let i = 0; i < scaled.length; i++)
+          scaled[i] = distance.values[i] * 255 / max;
+        buf = scaled;
+        floodChannels = 1;
+        threshold = [distance.mean * sensitivity * 255 / max];
+      } else {
+        floodChannels = inputChannels;
+        threshold = this.perChannelThreshold(buf, W, inputChannels, sensitivity);
+      }
+    }
+    const mask = this.floodFill(buf, W, floodChannels, threshold);
+    const closed = simple ? mask : this.morphClose(mask, W, 5);
+    return { mask: closed, size: W };
+  }
+  /**
+   * Standard ray-cast point-in-polygon test. (px, py) and the polygon
+   * vertices must be in the same coordinate system.
+   */
+  pointInPolygon(px, py, xpoints, ypoints) {
+    const n = xpoints.length;
+    if (n < 3)
+      return false;
+    let inside = false;
+    for (let i = 0, j = n - 1; i < n; j = i++) {
+      const yi = ypoints[i], yj = ypoints[j];
+      const xi = xpoints[i], xj = xpoints[j];
+      const intersect = yi > py !== yj > py && px < (xj - xi) * (py - yi) / (yj - yi) + xi;
+      if (intersect)
+        inside = !inside;
+    }
+    return inside;
+  }
+  /**
+   * Drop every vertex whose Euclidean distance to (cx, cy) is less than
+   * `radius`. Returns trimmed parallel arrays plus how many vertices were
+   * removed (so the caller can detect a no-op tick and skip the relayout).
+   */
+  dropVerticesWithinRadius(xpoints, ypoints, cx, cy, radius) {
+    const r2 = radius * radius;
+    const xs = [];
+    const ys = [];
+    let removed = 0;
+    for (let i = 0; i < xpoints.length; i++) {
+      const dx = xpoints[i] - cx;
+      const dy = ypoints[i] - cy;
+      if (dx * dx + dy * dy < r2) {
+        removed++;
+        continue;
+      }
+      xs.push(xpoints[i]);
+      ys.push(ypoints[i]);
+    }
+    return { xpoints: xs, ypoints: ys, removed };
+  }
+  /**
+   * Rasterize a closed polygon into a bbox-relative mask suitable as a
+   * starting point for a wand stroke accumulator.
+   *
+   * Returns the bbox origin (clamped to the image) plus the filled mask, or
+   * null if the polygon is degenerate or fully outside the image.
+   */
+  rasterizePolygon(xpoints, ypoints, imageWidth, imageHeight, holes) {
+    const n = xpoints.length;
+    if (n < 3)
+      return null;
+    let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
+    for (let i = 0; i < n; i++) {
+      if (xpoints[i] < minX)
+        minX = xpoints[i];
+      if (xpoints[i] > maxX)
+        maxX = xpoints[i];
+      if (ypoints[i] < minY)
+        minY = ypoints[i];
+      if (ypoints[i] > maxY)
+        maxY = ypoints[i];
+    }
+    let bx = Math.floor(minX);
+    let by = Math.floor(minY);
+    let bx1 = Math.ceil(maxX) + 1;
+    let by1 = Math.ceil(maxY) + 1;
+    if ((bx1 - bx) * (by1 - by) > 4096 * 4096) {
+      bx = Math.max(0, bx);
+      by = Math.max(0, by);
+      bx1 = Math.min(imageWidth, bx1);
+      by1 = Math.min(imageHeight, by1);
+    }
+    const bw = bx1 - bx;
+    const bh = by1 - by;
+    if (bw <= 0 || bh <= 0)
+      return null;
+    const mask = new Uint8Array(bw * bh);
+    const fillRing = (rx, ry, value) => {
+      const m = rx.length;
+      if (m < 3)
+        return;
+      for (let py = 0; py < bh; py++) {
+        const y = by + py + 0.5;
+        const xs = [];
+        for (let i = 0, j = m - 1; i < m; j = i++) {
+          const yi = ry[i], yj = ry[j];
+          if (yi <= y && yj > y || yj <= y && yi > y) {
+            const t = (y - yi) / (yj - yi);
+            xs.push(rx[i] + t * (rx[j] - rx[i]));
+          }
+        }
+        xs.sort((a, b) => a - b);
+        for (let k = 0; k + 1 < xs.length; k += 2) {
+          const xStart = Math.max(0, Math.ceil(xs[k] - bx));
+          const xEnd = Math.min(bw - 1, Math.floor(xs[k + 1] - bx));
+          for (let x = xStart; x <= xEnd; x++)
+            mask[py * bw + x] = value;
+        }
+      }
+    };
+    fillRing(xpoints, ypoints, 1);
+    if (holes) {
+      for (const ring of holes) {
+        fillRing(ring.map((p) => p[0]), ring.map((p) => p[1]), 0);
+      }
+    }
+    return { bx, by, bw, bh, mask };
+  }
+  /**
+   * Point-in-region test that honours interior rings (holes): inside the
+   * exterior AND outside every hole (even-odd). Coordinates must share the
+   * polygon's frame. With no holes this is exactly {@link pointInPolygon}.
+   */
+  pointInPolygonWithHoles(px, py, xpoints, ypoints, holes) {
+    if (!this.pointInPolygon(px, py, xpoints, ypoints))
+      return false;
+    if (holes) {
+      for (const ring of holes) {
+        if (this.pointInPolygon(px, py, ring.map((p) => p[0]), ring.map((p) => p[1])))
+          return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Trace the largest 4-connected blob in `mask` (sized w*h) and return a
+   * Polygon translated into image-pixel coordinates via (originX, originY).
+   * The traced vertices are NOT clamped to the image bounds: a region drawn while
+   * panned/zoomed keeps its true coordinates even where they fall outside the visible
+   * window (jit-ui#102). `imageWidth`/`imageHeight` are kept for signature compatibility
+   * but no longer used.
+   */
+  maskToPolygon(mask, w, h, _imageWidth, _imageHeight, originX, originY) {
+    const verticesLocal = this.traceContour(mask, w, h);
+    if (!verticesLocal || verticesLocal.length < 3)
+      return null;
+    const xpoints = [];
+    const ypoints = [];
+    const coordinates = [];
+    for (const v of verticesLocal) {
+      const ix = Math.round(originX + v.x);
+      const iy = Math.round(originY + v.y);
+      xpoints.push(ix);
+      ypoints.push(iy);
+      coordinates.push([ix, iy]);
+    }
+    const poly = new Polygon();
+    poly.npoints = xpoints.length;
+    poly.xpoints = xpoints;
+    poly.ypoints = ypoints;
+    poly.coordinates = coordinates;
+    return poly;
+  }
+  /**
+   * Trace EVERY 4-connected blob in `mask` (sized w*h) whose area is at least
+   * `minSize` pixels, returning one Polygon per blob in image-pixel coordinates
+   * (translated via originX/originY, clamped to imageWidth/imageHeight), ordered
+   * largest-first. Unlike {@link maskToPolygon} (largest blob only), this lets
+   * the brush eraser split a region in two when a stroke cuts through it rather
+   * than discarding the smaller piece.
+   */
+  maskToPolygons(mask, w, h, imageWidth, imageHeight, originX, originY, minSize = 4, minHoleSize = minSize) {
+    const labels = new Int32Array(w * h);
+    const sizes = [0];
+    let nextLabel = 0;
+    const queue = [];
+    for (let y = 0; y < h; y++) {
+      for (let x = 0; x < w; x++) {
+        const idx = y * w + x;
+        if (!mask[idx] || labels[idx])
+          continue;
+        nextLabel++;
+        labels[idx] = nextLabel;
+        let size = 0;
+        queue.push(idx);
+        while (queue.length) {
+          const i = queue.pop();
+          size++;
+          const px = i % w;
+          const py = (i - px) / w;
+          if (px > 0) {
+            const j = i - 1;
+            if (mask[j] && !labels[j]) {
+              labels[j] = nextLabel;
+              queue.push(j);
+            }
+          }
+          if (px < w - 1) {
+            const j = i + 1;
+            if (mask[j] && !labels[j]) {
+              labels[j] = nextLabel;
+              queue.push(j);
+            }
+          }
+          if (py > 0) {
+            const j = i - w;
+            if (mask[j] && !labels[j]) {
+              labels[j] = nextLabel;
+              queue.push(j);
+            }
+          }
+          if (py < h - 1) {
+            const j = i + w;
+            if (mask[j] && !labels[j]) {
+              labels[j] = nextLabel;
+              queue.push(j);
+            }
+          }
+        }
+        sizes[nextLabel] = size;
+      }
+    }
+    const wanted = [];
+    for (let lbl = 1; lbl <= nextLabel; lbl++) {
+      if (sizes[lbl] >= minSize)
+        wanted.push(lbl);
+    }
+    wanted.sort((a, b) => sizes[b] - sizes[a]);
+    const holesByLabel = this.detectHoles(
+      mask,
+      labels,
+      w,
+      h,
+      originX,
+      originY,
+      imageWidth,
+      imageHeight,
+      minHoleSize
+    );
+    const polys = [];
+    const comp = new Uint8Array(w * h);
+    for (const lbl of wanted) {
+      comp.fill(0);
+      for (let i = 0; i < comp.length; i++)
+        comp[i] = labels[i] === lbl ? 1 : 0;
+      const verts = this.mooreBoundary(comp, w, h);
+      if (!verts || verts.length < 3)
+        continue;
+      const xpoints = [];
+      const ypoints = [];
+      const coordinates = [];
+      for (const v of verts) {
+        const ix = Math.round(originX + v.x);
+        const iy = Math.round(originY + v.y);
+        xpoints.push(ix);
+        ypoints.push(iy);
+        coordinates.push([ix, iy]);
+      }
+      const poly = new Polygon();
+      poly.npoints = xpoints.length;
+      poly.xpoints = xpoints;
+      poly.ypoints = ypoints;
+      poly.coordinates = coordinates;
+      const holes = holesByLabel.get(lbl);
+      if (holes && holes.length)
+        poly.holes = holes;
+      polys.push(poly);
+    }
+    return polys;
+  }
+  /**
+   * Find interior rings (holes) of each foreground component in `mask`: a
+   * 4-connected run of background (0) pixels that is fully enclosed — i.e. not
+   * reachable from the grid border through background — is a hole, attributed to
+   * the foreground component that borders it most. Returns `fgLabel → rings`,
+   * each ring a list of `[x, y]` image-pixel pairs (same convention as a
+   * polygon's `coordinates`). Holes smaller than `minHoleSize` are dropped.
+   */
+  detectHoles(mask, fgLabels, w, h, originX, originY, imageWidth, imageHeight, minHoleSize) {
+    const result = /* @__PURE__ */ new Map();
+    const outside = new Uint8Array(w * h);
+    const stack = [];
+    const seed = (idx) => {
+      if (!mask[idx] && !outside[idx]) {
+        outside[idx] = 1;
+        stack.push(idx);
+      }
+    };
+    for (let x = 0; x < w; x++) {
+      seed(x);
+      seed((h - 1) * w + x);
+    }
+    for (let y = 0; y < h; y++) {
+      seed(y * w);
+      seed(y * w + w - 1);
+    }
+    while (stack.length) {
+      const i = stack.pop();
+      const px = i % w, py = (i - px) / w;
+      if (px > 0)
+        seed(i - 1);
+      if (px < w - 1)
+        seed(i + 1);
+      if (py > 0)
+        seed(i - w);
+      if (py < h - 1)
+        seed(i + w);
+    }
+    const visited = new Uint8Array(w * h);
+    const holeMask = new Uint8Array(w * h);
+    const queue = [];
+    for (let start = 0; start < mask.length; start++) {
+      if (mask[start] || outside[start] || visited[start])
+        continue;
+      let size = 0;
+      const owners = /* @__PURE__ */ new Map();
+      const pixels = [];
+      visited[start] = 1;
+      queue.length = 0;
+      queue.push(start);
+      while (queue.length) {
+        const i = queue.pop();
+        size++;
+        pixels.push(i);
+        const px = i % w, py = (i - px) / w;
+        const visit = (j) => {
+          if (mask[j]) {
+            const lbl = fgLabels[j];
+            if (lbl)
+              owners.set(lbl, (owners.get(lbl) ?? 0) + 1);
+          } else if (!outside[j] && !visited[j]) {
+            visited[j] = 1;
+            queue.push(j);
+          }
+        };
+        if (px > 0)
+          visit(i - 1);
+        if (px < w - 1)
+          visit(i + 1);
+        if (py > 0)
+          visit(i - w);
+        if (py < h - 1)
+          visit(i + w);
+      }
+      if (size < minHoleSize || owners.size === 0)
+        continue;
+      let owner = 0, best = -1;
+      owners.forEach((cnt, lbl) => {
+        if (cnt > best) {
+          best = cnt;
+          owner = lbl;
+        }
+      });
+      holeMask.fill(0);
+      for (const i of pixels)
+        holeMask[i] = 1;
+      const verts = this.mooreBoundary(holeMask, w, h);
+      if (!verts || verts.length < 3)
+        continue;
+      const ring = [];
+      for (const v of verts) {
+        const ix = Math.max(0, Math.min(imageWidth - 1, Math.round(originX + v.x)));
+        const iy = Math.max(0, Math.min(imageHeight - 1, Math.round(originY + v.y)));
+        ring.push([ix, iy]);
+      }
+      const list = result.get(owner) ?? [];
+      list.push(ring);
+      result.set(owner, list);
+    }
+    return result;
+  }
+  /**
+   * Trace each instance in an integer label map (0 = background) into a Polygon
+   * — used to turn a cellpose-style segmentation into region outlines. Labels
+   * with area below `minSize` are skipped. Coords are translated via
+   * originX/originY and clamped to imageWidth/imageHeight.
+   */
+  labelsToPolygons(labels, w, h, imageWidth, imageHeight, originX, originY, minSize = 10) {
+    let maxLabel = 0;
+    for (let i = 0; i < labels.length; i++)
+      if (labels[i] > maxLabel)
+        maxLabel = labels[i];
+    const out = [];
+    const bin = new Uint8Array(w * h);
+    for (let lbl = 1; lbl <= maxLabel; lbl++) {
+      let any = false;
+      for (let i = 0; i < labels.length; i++) {
+        const on = labels[i] === lbl;
+        bin[i] = on ? 1 : 0;
+        if (on)
+          any = true;
+      }
+      if (!any)
+        continue;
+      for (const p of this.maskToPolygons(bin, w, h, imageWidth, imageHeight, originX, originY, minSize)) {
+        out.push(p);
+      }
+    }
+    return out;
+  }
+  // ── Patch extraction ────────────────────────────────────────────────
+  extractPatch(image, cx, cy, W, type) {
+    const channels = type === "GRAY" ? 1 : 3;
+    const half = (W - 1) / 2;
+    const x0 = Math.round(cx) - half;
+    const y0 = Math.round(cy) - half;
+    const buf = new Float32Array(W * W * channels);
+    for (let py = 0; py < W; py++) {
+      const iy = y0 + py;
+      if (iy < 0 || iy >= image.height)
+        continue;
+      const row = image.data[iy];
+      if (!row)
+        continue;
+      for (let px = 0; px < W; px++) {
+        const ix = x0 + px;
+        if (ix < 0 || ix >= image.width)
+          continue;
+        const dst = (py * W + px) * channels;
+        if (image.isGrayscale) {
+          const v = row[ix];
+          if (channels === 1) {
+            buf[dst] = v;
+          } else {
+            buf[dst] = v;
+            buf[dst + 1] = v;
+            buf[dst + 2] = v;
+          }
+        } else {
+          const tuple = row[ix];
+          if (channels === 1) {
+            buf[dst] = 0.299 * tuple[0] + 0.587 * tuple[1] + 0.114 * tuple[2];
+          } else {
+            buf[dst] = tuple[0];
+            buf[dst + 1] = tuple[1];
+            buf[dst + 2] = tuple[2];
+          }
+        }
+      }
+    }
+    return buf;
+  }
+  // ── Gaussian blur (separable) ───────────────────────────────────────
+  gaussianBlur(buf, W, channels, sigma) {
+    const radius = Math.max(1, Math.ceil(sigma * 2));
+    const size = radius * 2 + 1;
+    const kernel = new Float32Array(size);
+    let sum = 0;
+    const inv2s2 = 1 / (2 * sigma * sigma);
+    for (let i = 0; i < size; i++) {
+      const x = i - radius;
+      kernel[i] = Math.exp(-x * x * inv2s2);
+      sum += kernel[i];
+    }
+    for (let i = 0; i < size; i++)
+      kernel[i] /= sum;
+    const horiz = new Float32Array(buf.length);
+    for (let y = 0; y < W; y++) {
+      for (let x = 0; x < W; x++) {
+        for (let c = 0; c < channels; c++) {
+          let acc = 0;
+          for (let k = 0; k < size; k++) {
+            let xx = x + k - radius;
+            if (xx < 0)
+              xx = 0;
+            else if (xx >= W)
+              xx = W - 1;
+            acc += kernel[k] * buf[(y * W + xx) * channels + c];
+          }
+          horiz[(y * W + x) * channels + c] = acc;
+        }
+      }
+    }
+    const out = new Float32Array(buf.length);
+    for (let y = 0; y < W; y++) {
+      for (let x = 0; x < W; x++) {
+        for (let c = 0; c < channels; c++) {
+          let acc = 0;
+          for (let k = 0; k < size; k++) {
+            let yy = y + k - radius;
+            if (yy < 0)
+              yy = 0;
+            else if (yy >= W)
+              yy = W - 1;
+            acc += kernel[k] * horiz[(yy * W + x) * channels + c];
+          }
+          out[(y * W + x) * channels + c] = acc;
+        }
+      }
+    }
+    return out;
+  }
+  // ── Threshold computation ───────────────────────────────────────────
+  perChannelThreshold(buf, W, channels, sensitivity) {
+    const n = W * W;
+    const sums = new Array(channels).fill(0);
+    const sqs = new Array(channels).fill(0);
+    for (let i = 0; i < n; i++) {
+      for (let c = 0; c < channels; c++) {
+        const v = buf[i * channels + c];
+        sums[c] += v;
+        sqs[c] += v * v;
+      }
+    }
+    const scale = sensitivity > 0 ? 1 / sensitivity : 100;
+    const threshold = new Array(channels);
+    for (let c = 0; c < channels; c++) {
+      const mean = sums[c] / n;
+      const variance = Math.max(0, sqs[c] / n - mean * mean);
+      const stddev = Math.sqrt(variance);
+      threshold[c] = stddev * scale;
+    }
+    return threshold;
+  }
+  labDistanceMap(buf, W) {
+    const n = W * W;
+    const lab = new Float32Array(n * 3);
+    for (let i = 0; i < n; i++) {
+      const r = buf[i * 3] / 255;
+      const g = buf[i * 3 + 1] / 255;
+      const b = buf[i * 3 + 2] / 255;
+      const [L, A, B] = srgbToLab(r, g, b);
+      lab[i * 3] = L;
+      lab[i * 3 + 1] = A;
+      lab[i * 3 + 2] = B;
+    }
+    const mid = Math.floor(n / 2);
+    const cL = lab[mid * 3];
+    const cA = lab[mid * 3 + 1];
+    const cB = lab[mid * 3 + 2];
+    const values = new Float32Array(n);
+    let max = 0;
+    let sum = 0;
+    for (let i = 0; i < n; i++) {
+      const dL = lab[i * 3] - cL;
+      const dA = lab[i * 3 + 1] - cA;
+      const dB = lab[i * 3 + 2] - cB;
+      const d = Math.sqrt(dL * dL + dA * dA + dB * dB);
+      values[i] = d;
+      if (d > max)
+        max = d;
+      sum += d;
+    }
+    return { values, mean: sum / n, max };
+  }
+  // ── Flood fill ──────────────────────────────────────────────────────
+  /**
+   * Fixed-range scanline flood fill from the patch centre. A neighbour is
+   * accepted iff for every channel `|p[c] - seed[c]| <= threshold[c]`.
+   */
+  floodFill(buf, W, channels, threshold) {
+    const mask = new Uint8Array(W * W);
+    const seedX = (W - 1) / 2;
+    const seedY = (W - 1) / 2;
+    const seedIdx = (seedY * W + seedX) * channels;
+    const seed = new Array(channels);
+    for (let c = 0; c < channels; c++)
+      seed[c] = buf[seedIdx + c];
+    const accept = (x, y) => {
+      const idx = (y * W + x) * channels;
+      for (let c = 0; c < channels; c++) {
+        const diff = Math.abs(buf[idx + c] - seed[c]);
+        if (diff > threshold[c])
+          return false;
+      }
+      return true;
+    };
+    const stack = [seedX, seedY];
+    while (stack.length) {
+      const y = stack.pop();
+      const x = stack.pop();
+      if (x < 0 || x >= W || y < 0 || y >= W)
+        continue;
+      if (mask[y * W + x])
+        continue;
+      if (!accept(x, y))
+        continue;
+      let xl = x;
+      while (xl > 0 && !mask[y * W + (xl - 1)] && accept(xl - 1, y))
+        xl--;
+      let xr = x;
+      while (xr < W - 1 && !mask[y * W + (xr + 1)] && accept(xr + 1, y))
+        xr++;
+      for (let xi = xl; xi <= xr; xi++) {
+        mask[y * W + xi] = 1;
+      }
+      if (y > 0) {
+        for (let xi = xl; xi <= xr; xi++) {
+          if (!mask[(y - 1) * W + xi]) {
+            stack.push(xi, y - 1);
+          }
+        }
+      }
+      if (y < W - 1) {
+        for (let xi = xl; xi <= xr; xi++) {
+          if (!mask[(y + 1) * W + xi]) {
+            stack.push(xi, y + 1);
+          }
+        }
+      }
+    }
+    return mask;
+  }
+  // ── Morphological close (dilate then erode) ─────────────────────────
+  morphClose(mask, W, kernelSize) {
+    const r = (kernelSize - 1) / 2;
+    const dil = this.dilate(mask, W, r);
+    return this.erode(dil, W, r);
+  }
+  dilate(mask, W, r) {
+    const out = new Uint8Array(W * W);
+    for (let y = 0; y < W; y++) {
+      for (let x = 0; x < W; x++) {
+        let hit = 0;
+        for (let dy = -r; dy <= r && !hit; dy++) {
+          const yy = y + dy;
+          if (yy < 0 || yy >= W)
+            continue;
+          for (let dx = -r; dx <= r; dx++) {
+            const xx = x + dx;
+            if (xx < 0 || xx >= W)
+              continue;
+            if (mask[yy * W + xx]) {
+              hit = 1;
+              break;
+            }
+          }
+        }
+        out[y * W + x] = hit;
+      }
+    }
+    return out;
+  }
+  erode(mask, W, r) {
+    const out = new Uint8Array(W * W);
+    for (let y = 0; y < W; y++) {
+      for (let x = 0; x < W; x++) {
+        let all = 1;
+        for (let dy = -r; dy <= r && all; dy++) {
+          const yy = y + dy;
+          if (yy < 0 || yy >= W) {
+            all = 0;
+            break;
+          }
+          for (let dx = -r; dx <= r; dx++) {
+            const xx = x + dx;
+            if (xx < 0 || xx >= W) {
+              all = 0;
+              break;
+            }
+            if (!mask[yy * W + xx]) {
+              all = 0;
+              break;
+            }
+          }
+        }
+        out[y * W + x] = all;
+      }
+    }
+    return out;
+  }
+  // ── Contour tracing (Moore-neighbour boundary follow) ───────────────
+  /**
+   * Returns the outer boundary of the largest 4-connected blob in the mask
+   * sized w*h.
+   */
+  traceContour(mask, w, h) {
+    const labels = new Int32Array(w * h);
+    let bestLabel = 0;
+    let bestSize = 0;
+    let nextLabel = 0;
+    const queue = [];
+    for (let y = 0; y < h; y++) {
+      for (let x = 0; x < w; x++) {
+        const idx = y * w + x;
+        if (!mask[idx] || labels[idx])
+          continue;
+        nextLabel++;
+        labels[idx] = nextLabel;
+        let size = 0;
+        queue.push(idx);
+        while (queue.length) {
+          const i = queue.pop();
+          size++;
+          const px = i % w;
+          const py = (i - px) / w;
+          if (px > 0) {
+            const j = i - 1;
+            if (mask[j] && !labels[j]) {
+              labels[j] = nextLabel;
+              queue.push(j);
+            }
+          }
+          if (px < w - 1) {
+            const j = i + 1;
+            if (mask[j] && !labels[j]) {
+              labels[j] = nextLabel;
+              queue.push(j);
+            }
+          }
+          if (py > 0) {
+            const j = i - w;
+            if (mask[j] && !labels[j]) {
+              labels[j] = nextLabel;
+              queue.push(j);
+            }
+          }
+          if (py < h - 1) {
+            const j = i + w;
+            if (mask[j] && !labels[j]) {
+              labels[j] = nextLabel;
+              queue.push(j);
+            }
+          }
+        }
+        if (size > bestSize) {
+          bestSize = size;
+          bestLabel = nextLabel;
+        }
+      }
+    }
+    if (bestSize === 0)
+      return null;
+    const comp = new Uint8Array(w * h);
+    for (let i = 0; i < comp.length; i++)
+      comp[i] = labels[i] === bestLabel ? 1 : 0;
+    return this.mooreBoundary(comp, w, h);
+  }
+  mooreBoundary(mask, w, h) {
+    let startIdx = -1;
+    for (let i = 0; i < mask.length; i++) {
+      if (mask[i]) {
+        startIdx = i;
+        break;
+      }
+    }
+    if (startIdx < 0)
+      return [];
+    const sx = startIdx % w;
+    const sy = (startIdx - sx) / w;
+    const points = [{ x: sx, y: sy }];
+    const singleton = (idx) => {
+      const x = idx % w;
+      const y = (idx - x) / w;
+      const at = (xx, yy) => xx >= 0 && xx < w && yy >= 0 && yy < h && mask[yy * w + xx];
+      return !(at(x - 1, y) || at(x + 1, y) || at(x, y - 1) || at(x, y + 1));
+    };
+    if (singleton(startIdx)) {
+      return [
+        { x: sx, y: sy },
+        { x: sx + 1, y: sy },
+        { x: sx + 1, y: sy + 1 },
+        { x: sx, y: sy + 1 }
+      ];
+    }
+    const dx = [-1, -1, 0, 1, 1, 1, 0, -1];
+    const dy = [0, -1, -1, -1, 0, 1, 1, 1];
+    let cx = sx, cy = sy;
+    let prevDir = 0;
+    const maxSteps = w * h * 8;
+    for (let step = 0; step < maxSteps; step++) {
+      let found = false;
+      for (let k = 1; k <= 8; k++) {
+        const dir = prevDir + k & 7;
+        const nx = cx + dx[dir];
+        const ny = cy + dy[dir];
+        if (nx < 0 || nx >= w || ny < 0 || ny >= h)
+          continue;
+        if (mask[ny * w + nx]) {
+          prevDir = dir + 4 & 7;
+          cx = nx;
+          cy = ny;
+          points.push({ x: cx, y: cy });
+          found = true;
+          break;
+        }
+      }
+      if (!found)
+        break;
+      if (cx === sx && cy === sy && points.length > 1) {
+        points.pop();
+        break;
+      }
+    }
+    return points;
+  }
+};
+WandService = __decorateClass([
+  Injectable({ providedIn: "root" })
+], WandService);
+function srgbToLinear(c) {
+  return c <= 0.04045 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
+}
+function srgbToLab(r, g, b) {
+  const R = srgbToLinear(r);
+  const G = srgbToLinear(g);
+  const B = srgbToLinear(b);
+  const X = R * 0.4124564 + G * 0.3575761 + B * 0.1804375;
+  const Y = R * 0.2126729 + G * 0.7151522 + B * 0.072175;
+  const Z = R * 0.0193339 + G * 0.119192 + B * 0.9503041;
+  const Xn = 0.95047, Yn = 1, Zn = 1.08883;
+  const fx = labF(X / Xn);
+  const fy = labF(Y / Yn);
+  const fz = labF(Z / Zn);
+  const L = 116 * fy - 16;
+  const A = 500 * (fx - fy);
+  const Bv = 200 * (fy - fz);
+  return [L, A, Bv];
+}
+function labF(t) {
+  const d = 6 / 29;
+  return t > d * d * d ? Math.cbrt(t) : t / (3 * d * d) + 4 / 29;
+}
+
+// src/lib/region-editor/mask-raster.ts
+function regionsToMask(regions, imageWidth, imageHeight, mode, rasterize, onProgress) {
+  const W = Math.round(imageWidth);
+  const H = Math.round(imageHeight);
+  if (!Number.isFinite(W) || !Number.isFinite(H) || W <= 0 || H <= 0 || !regions?.length) {
+    return null;
+  }
+  const multiclass = mode === "multiclass";
+  const bitDepth = multiclass && regions.length > 255 ? 16 : 8;
+  const out = bitDepth === 16 ? new Uint16Array(W * H) : new Uint8Array(W * H);
+  let painted = false;
+  for (let i = 0; i < regions.length; i++) {
+    const value = multiclass ? i + 1 : 255;
+    for (const part of regions[i]) {
+      const m = rasterize(part.xpoints, part.ypoints, W, H, part.holes);
+      if (!m)
+        continue;
+      painted = true;
+      for (let y = 0; y < m.bh; y++) {
+        const srcRow = y * m.bw;
+        const dstRow = (m.by + y) * W + m.bx;
+        for (let x = 0; x < m.bw; x++) {
+          if (m.mask[srcRow + x])
+            out[dstRow + x] = value;
+        }
+      }
+    }
+    onProgress?.(i + 1, regions.length);
+  }
+  return painted ? { data: out, bitDepth } : null;
+}
+
+// src/lib/region-editor/mask.worker.ts
+var wand = new WandService();
+addEventListener("message", ({ data }) => {
+  try {
+    const { width, height, originalWidth, originalHeight, scale, mode, sourceName, regions } = data;
+    const mask = regionsToMask(
+      regions,
+      width,
+      height,
+      mode,
+      (xs, ys, w, h, holes) => wand.rasterizePolygon(xs, ys, w, h, holes),
+      (done, total) => postMessage({ type: "progress", done, total })
+    );
+    if (!mask) {
+      postMessage({ type: "error", error: "No regions could be rasterized." });
+      return;
+    }
+    postMessage({ type: "encoding" });
+    const text = {
+      MaskType: mode,
+      OriginalWidth: String(originalWidth),
+      OriginalHeight: String(originalHeight),
+      MaskScale: String(scale)
+    };
+    if (sourceName)
+      text.SourceImage = sourceName;
+    const png = encodePng({
+      width: Math.round(width),
+      height: Math.round(height),
+      data: mask.data,
+      channels: 1,
+      depth: mask.bitDepth,
+      text
+    });
+    postMessage(
+      { type: "done", png },
+      [png.buffer]
+    );
+  } catch (err) {
+    postMessage({ type: "error", error: err?.message ?? String(err) });
+  }
+});