@jax-data-science/sci-image-visualizer 0.8.2 → 0.9.0

package/fesm2022/mask.worker.js

@@ -1,916 +1,37 @@
-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];
+// src/lib/geometry/raster.ts
+import { rasterizePolygon as rasterizeRing } from "napari-js/geometry";
+var MAX_RASTER_PIXELS = 4096 * 4096;
+function flatRing(xs, ys) {
+  const out = new Array(xs.length * 2);
+  for (let i = 0; i < xs.length; i++) {
+    out[i * 2] = xs[i];
+    out[i * 2 + 1] = ys[i];
+  }
+  return out;
 }
-function labF(t) {
-  const d = 6 / 29;
-  return t > d * d * d ? Math.cbrt(t) : t / (3 * d * d) + 4 / 29;
+function rasterizePolygon(xpoints, ypoints, imageWidth, imageHeight, holes) {
+  if (xpoints.length < 3)
+    return null;
+  const outer = flatRing(xpoints, ypoints);
+  const inner = holes?.map(
+    (ring) => flatRing(
+      ring.map((p) => p[0]),
+      ring.map((p) => p[1])
+    )
+  );
+  const bounds = { x: 0, y: 0, width: imageWidth, height: imageHeight };
+  let m;
+  try {
+    m = rasterizeRing(outer, inner, { bounds, maxPixels: MAX_RASTER_PIXELS });
+  } catch (err) {
+    if (!(err instanceof RangeError))
+      throw err;
+    m = rasterizeRing(outer, inner, { bounds, clip: true, maxPixels: Infinity });
+  }
+  return m && { bx: m.x, by: m.y, bw: m.width, bh: m.height, mask: m.data };
 }
 
 // src/lib/region-editor/mask-raster.ts
@@ -931,10 +52,12 @@ function regionsToMask(regions, imageWidth, imageHeight, mode, rasterize, onProg
       if (!m)
         continue;
       painted = true;
-      for (let y = 0; y < m.bh; y++) {
+      const x0 = Math.max(0, -m.bx), x1 = Math.min(m.bw, W - m.bx);
+      const y0 = Math.max(0, -m.by), y1 = Math.min(m.bh, H - m.by);
+      for (let y = y0; y < y1; y++) {
         const srcRow = y * m.bw;
         const dstRow = (m.by + y) * W + m.bx;
-        for (let x = 0; x < m.bw; x++) {
+        for (let x = x0; x < x1; x++) {
           if (m.mask[srcRow + x])
             out[dstRow + x] = value;
         }
@@ -946,7 +69,6 @@ function regionsToMask(regions, imageWidth, imageHeight, mode, rasterize, onProg
 }
 
 // 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;
@@ -955,7 +77,7 @@ addEventListener("message", ({ data }) => {
       width,
       height,
       mode,
-      (xs, ys, w, h, holes) => wand.rasterizePolygon(xs, ys, w, h, holes),
+      rasterizePolygon,
       (done, total) => postMessage({ type: "progress", done, total })
     );
     if (!mask) {
@@ -979,10 +101,7 @@ addEventListener("message", ({ data }) => {
       depth: mask.bitDepth,
       text
     });
-    postMessage(
-      { type: "done", png },
-      [png.buffer]
-    );
+    postMessage({ type: "done", png }, [png.buffer]);
   } catch (err) {
     postMessage({ type: "error", error: err?.message ?? String(err) });
   }