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

package/esm2022/lib/toolbar/wand/wand.service.mjs

@@ -0,0 +1,921 @@
+import { Injectable } from '@angular/core';
+import { Polygon } from '../../models/region';
+import * as i0 from "@angular/core";
+const DEFAULT_PATCH_SIZE = 149;
+const DEFAULT_SIGMA = 4.0;
+const DEFAULT_SENSITIVITY = 2.0;
+/**
+ * Wand region-growing tool, modelled after QuPath's WandToolEventHandler.
+ *
+ * Given an image and a click position, extracts a square patch around the
+ * click, optionally blurs it, computes a local threshold, runs a fixed-range
+ * flood fill from the centre, closes the resulting mask, and returns the
+ * traced contour as a polygon in image coordinates.
+ */
+export class WandService {
+    /**
+     * @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;
+        // extractPatch always interleaves 1 channel for GRAY, 3 for RGB/LAB_DISTANCE.
+        const inputChannels = (type === 'GRAY') ? 1 : 3;
+        let buf = this.extractPatch(image, cx, cy, W, type);
+        // Flood fill operates on whatever buffer we end up with: the raw patch in
+        // simple mode (so multi-channel exact-match), the blurred patch for
+        // GRAY/RGB, or the single-channel CIELAB distance map for LAB_DISTANCE.
+        let floodChannels;
+        let threshold;
+        if (simple) {
+            // Skip blur + threshold computation. Flood-fill the raw patch at
+            // exact-match per channel — same as QuPath's doSimpleSelection.
+            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') {
+                // Convert blurred 3-channel patch to a single-channel distance map,
+                // then flood-fill on that single channel.
+                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.0 / max;
+                buf = scaled;
+                floodChannels = 1;
+                threshold = [distance.mean * sensitivity * 255.0 / 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];
+        }
+        // Rasterize the polygon's FULL extent (not clamped to the viewport), so a region that's
+        // partially off the visible/zoomed area keeps its off-screen part when the wand/brush extends
+        // it — the coords here are viewport-matrix units and may be negative or exceed the viewport
+        // (jit-ui#102). Memory guard: a region that's enormous at the current zoom would allocate a
+        // giant mask, so only then fall back to the viewport window (rare; accepts the clip).
+        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);
+        // Scanline ring fill — sample each row at its pixel centre, writing `value`
+        // (1 to fill the exterior, 0 to punch a hole back out).
+        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 = [];
+        // No viewport clamp: the trace coords (origin + local) are the region's true coords and may
+        // lie outside the currently-visible window when it was panned/zoomed (jit-ui#102).
+        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) {
+        // Label all 4-connected components, recording each one's pixel count.
+        const labels = new Int32Array(w * h);
+        const sizes = [0]; // sizes[label]; label 0 unused
+        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]); // largest-first
+        // Interior rings (holes) per foreground label — jit-ui#85.
+        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 = [];
+            // No viewport clamp (jit-ui#102): keep the region's true coords even off the visible window.
+            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 = new Map();
+        // 1. Flood-fill background reachable from the grid border ("outside").
+        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);
+        }
+        // 2. Remaining unvisited background pixels are enclosed holes. BFS each,
+        //    tally the bordering foreground label, and trace its boundary.
+        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 = 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;
+            // Reuse the contour tracer; one label is usually a single blob.
+            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) {
+                        // GRAY type forced on RGB image: convert with luminance.
+                        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);
+        // Horizontal pass.
+        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);
+        // Vertical pass.
+        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;
+            // Find left edge of run.
+            let xl = x;
+            while (xl > 0 && !mask[y * W + (xl - 1)] && accept(xl - 1, y))
+                xl--;
+            // Find right edge of run.
+            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;
+            }
+            // Seed runs above and below.
+            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) {
+        // Find the largest connected component (4-connectivity).
+        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;
+        // Build a single-component mask, then trace its outer boundary using
+        // Moore-neighbour following.
+        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) {
+        // Find the first foreground pixel in raster order — guaranteed to lie
+        // on the boundary.
+        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 }];
+        // Single isolated pixel — emit the pixel's four corner points so callers
+        // (which require ≥ 3 vertices to build a polygon) get a valid 1×1 square
+        // instead of a degenerate single-vertex contour.
+        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 },
+            ];
+        }
+        // 8-connected neighbour offsets in clockwise order starting from West.
+        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;
+        // Backtrack direction — start from West (the side we'd be coming from in raster order).
+        let prevDir = 0;
+        const maxSteps = w * h * 8;
+        for (let step = 0; step < maxSteps; step++) {
+            // Standard Moore-neighbour tracing: search clockwise starting one step
+            // after the backtrack direction.
+            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]) {
+                    // Backtrack direction is from new pixel back toward previous pixel.
+                    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;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: WandService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: WandService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: WandService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+// ── sRGB → CIELAB (D65) ───────────────────────────────────────────────
+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);
+    // sRGB → XYZ (D65)
+    const X = R * 0.4124564 + G * 0.3575761 + B * 0.1804375;
+    const Y = R * 0.2126729 + G * 0.7151522 + B * 0.0721750;
+    const Z = R * 0.0193339 + G * 0.1191920 + B * 0.9503041;
+    // Reference white (D65)
+    const Xn = 0.95047, Yn = 1.0, 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;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"wand.service.js","sourceRoot":"","sources":["../../../../../src/lib/toolbar/wand/wand.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Polygon } from '../../models/region';\n\nimport { IWandOptions, WandType } from '../../contracts/display-types';\n\n// Canonical wand option/type shapes moved to contracts/display-types (public\n// API surface); re-exported here so existing internal imports keep working.\nexport type { WandType };\nexport type WandOptions = IWandOptions;\n\nexport interface WandImage {\n  /**\n   * Grayscale: number[][] where data[y][x] is intensity.\n   * RGB: [r,g,b][][] where data[y][x] is a 3-tuple.\n   */\n  data: number[][] | number[][][];\n  width: number;\n  height: number;\n  isGrayscale: boolean;\n}\n\nconst DEFAULT_PATCH_SIZE = 149;\nconst DEFAULT_SIGMA = 4.0;\nconst DEFAULT_SENSITIVITY = 2.0;\n\n/**\n * Wand region-growing tool, modelled after QuPath's WandToolEventHandler.\n *\n * Given an image and a click position, extracts a square patch around the\n * click, optionally blurs it, computes a local threshold, runs a fixed-range\n * flood fill from the centre, closes the resulting mask, and returns the\n * traced contour as a polygon in image coordinates.\n */\n@Injectable({ providedIn: 'root' })\nexport class WandService {\n\n  /**\n   * @param image full-image pixel matrix (already in memory).\n   * @param cx click x in image-pixel coordinates.\n   * @param cy click y in image-pixel coordinates.\n   * @param options wand parameters; missing fields fall back to defaults.\n   * @returns a Polygon in image-pixel coordinates, or null if no region grew.\n   */\n  computeRegion(image: WandImage, cx: number, cy: number, options: WandOptions = {}): Polygon | null {\n    const patch = this.computePatchMask(image, cx, cy, options);\n    if (!patch) return null;\n    return this.maskToPolygon(patch.mask, patch.size, patch.size, image.width, image.height,\n      Math.round(cx) - (patch.size - 1) / 2,\n      Math.round(cy) - (patch.size - 1) / 2);\n  }\n\n  /**\n   * Compute the wand's per-click flood-fill mask in patch-local coordinates.\n   * Same algorithm as `computeRegion` but stops before contour tracing — useful\n   * for accumulating per-tick masks across a brush-style stroke.\n   *\n   * @returns mask of size W*W (0/1) plus W, or null if patchSize is invalid.\n   */\n  public computePatchMask(image: WandImage, cx: number, cy: number,\n                          options: WandOptions = {}): { mask: Uint8Array; size: number } | null {\n    const W = options.patchSize ?? DEFAULT_PATCH_SIZE;\n    if (W % 2 === 0) {\n      throw new Error(`patchSize must be odd, got ${W}`);\n    }\n    const sigma = options.sigma ?? DEFAULT_SIGMA;\n    const sensitivity = options.sensitivity ?? DEFAULT_SENSITIVITY;\n    const isGrayscale = image.isGrayscale;\n    const type: WandType = options.type ?? (isGrayscale ? 'GRAY' : 'RGB');\n    const simple = !!options.simpleMode;\n    // extractPatch always interleaves 1 channel for GRAY, 3 for RGB/LAB_DISTANCE.\n    const inputChannels = (type === 'GRAY') ? 1 : 3;\n\n    let buf = this.extractPatch(image, cx, cy, W, type);\n\n    // Flood fill operates on whatever buffer we end up with: the raw patch in\n    // simple mode (so multi-channel exact-match), the blurred patch for\n    // GRAY/RGB, or the single-channel CIELAB distance map for LAB_DISTANCE.\n    let floodChannels: number;\n    let threshold: number[];\n\n    if (simple) {\n      // Skip blur + threshold computation. Flood-fill the raw patch at\n      // exact-match per channel — same as QuPath's doSimpleSelection.\n      floodChannels = inputChannels;\n      threshold = new Array(floodChannels).fill(0);\n    } else {\n      const blurSigma = Math.max(0.5, sigma);\n      buf = this.gaussianBlur(buf, W, inputChannels, blurSigma);\n\n      if (type === 'LAB_DISTANCE') {\n        // Convert blurred 3-channel patch to a single-channel distance map,\n        // then flood-fill on that single channel.\n        const distance = this.labDistanceMap(buf, W);\n        const max = distance.max > 0 ? distance.max : 1;\n        const scaled = new Float32Array(W * W);\n        for (let i = 0; i < scaled.length; i++) scaled[i] = distance.values[i] * 255.0 / max;\n        buf = scaled;\n        floodChannels = 1;\n        threshold = [distance.mean * sensitivity * 255.0 / max];\n      } else {\n        floodChannels = inputChannels;\n        threshold = this.perChannelThreshold(buf, W, inputChannels, sensitivity);\n      }\n    }\n\n    const mask = this.floodFill(buf, W, floodChannels, threshold);\n    const closed = simple ? mask : this.morphClose(mask, W, 5);\n    return { mask: closed, size: W };\n  }\n\n  /**\n   * Standard ray-cast point-in-polygon test. (px, py) and the polygon\n   * vertices must be in the same coordinate system.\n   */\n  public pointInPolygon(px: number, py: number, xpoints: number[], ypoints: number[]): boolean {\n    const n = xpoints.length;\n    if (n < 3) return false;\n    let inside = false;\n    for (let i = 0, j = n - 1; i < n; j = i++) {\n      const yi = ypoints[i], yj = ypoints[j];\n      const xi = xpoints[i], xj = xpoints[j];\n      const intersect = ((yi > py) !== (yj > py)) &&\n        (px < (xj - xi) * (py - yi) / (yj - yi) + xi);\n      if (intersect) inside = !inside;\n    }\n    return inside;\n  }\n\n  /**\n   * Drop every vertex whose Euclidean distance to (cx, cy) is less than\n   * `radius`. Returns trimmed parallel arrays plus how many vertices were\n   * removed (so the caller can detect a no-op tick and skip the relayout).\n   */\n  public dropVerticesWithinRadius(xpoints: number[], ypoints: number[],\n                                  cx: number, cy: number, radius: number)\n    : { xpoints: number[]; ypoints: number[]; removed: number } {\n    const r2 = radius * radius;\n    const xs: number[] = [];\n    const ys: number[] = [];\n    let removed = 0;\n    for (let i = 0; i < xpoints.length; i++) {\n      const dx = xpoints[i] - cx;\n      const dy = ypoints[i] - cy;\n      if (dx * dx + dy * dy < r2) {\n        removed++;\n        continue;\n      }\n      xs.push(xpoints[i]);\n      ys.push(ypoints[i]);\n    }\n    return { xpoints: xs, ypoints: ys, removed };\n  }\n\n  /**\n   * Rasterize a closed polygon into a bbox-relative mask suitable as a\n   * starting point for a wand stroke accumulator.\n   *\n   * Returns the bbox origin (clamped to the image) plus the filled mask, or\n   * null if the polygon is degenerate or fully outside the image.\n   */\n  public rasterizePolygon(xpoints: number[], ypoints: number[],\n                          imageWidth: number, imageHeight: number,\n                          holes?: number[][][])\n    : { bx: number; by: number; bw: number; bh: number; mask: Uint8Array } | null {\n\n    const n = xpoints.length;\n    if (n < 3) return null;\n\n    let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;\n    for (let i = 0; i < n; i++) {\n      if (xpoints[i] < minX) minX = xpoints[i];\n      if (xpoints[i] > maxX) maxX = xpoints[i];\n      if (ypoints[i] < minY) minY = ypoints[i];\n      if (ypoints[i] > maxY) maxY = ypoints[i];\n    }\n    // Rasterize the polygon's FULL extent (not clamped to the viewport), so a region that's\n    // partially off the visible/zoomed area keeps its off-screen part when the wand/brush extends\n    // it — the coords here are viewport-matrix units and may be negative or exceed the viewport\n    // (jit-ui#102). Memory guard: a region that's enormous at the current zoom would allocate a\n    // giant mask, so only then fall back to the viewport window (rare; accepts the clip).\n    let bx = Math.floor(minX);\n    let by = Math.floor(minY);\n    let bx1 = Math.ceil(maxX) + 1;\n    let by1 = Math.ceil(maxY) + 1;\n    if ((bx1 - bx) * (by1 - by) > 4096 * 4096) {\n      bx = Math.max(0, bx);\n      by = Math.max(0, by);\n      bx1 = Math.min(imageWidth, bx1);\n      by1 = Math.min(imageHeight, by1);\n    }\n    const bw = bx1 - bx;\n    const bh = by1 - by;\n    if (bw <= 0 || bh <= 0) return null;\n\n    const mask = new Uint8Array(bw * bh);\n    // Scanline ring fill — sample each row at its pixel centre, writing `value`\n    // (1 to fill the exterior, 0 to punch a hole back out).\n    const fillRing = (rx: number[], ry: number[], value: number) => {\n      const m = rx.length;\n      if (m < 3) return;\n      for (let py = 0; py < bh; py++) {\n        const y = by + py + 0.5;\n        const xs: number[] = [];\n        for (let i = 0, j = m - 1; i < m; j = i++) {\n          const yi = ry[i], yj = ry[j];\n          if ((yi <= y && yj > y) || (yj <= y && yi > y)) {\n            const t = (y - yi) / (yj - yi);\n            xs.push(rx[i] + t * (rx[j] - rx[i]));\n          }\n        }\n        xs.sort((a, b) => a - b);\n        for (let k = 0; k + 1 < xs.length; k += 2) {\n          const xStart = Math.max(0, Math.ceil(xs[k] - bx));\n          const xEnd = Math.min(bw - 1, Math.floor(xs[k + 1] - bx));\n          for (let x = xStart; x <= xEnd; x++) mask[py * bw + x] = value;\n        }\n      }\n    };\n    fillRing(xpoints, ypoints, 1);\n    if (holes) {\n      for (const ring of holes) {\n        fillRing(ring.map(p => p[0]), ring.map(p => p[1]), 0);\n      }\n    }\n    return { bx, by, bw, bh, mask };\n  }\n\n  /**\n   * Point-in-region test that honours interior rings (holes): inside the\n   * exterior AND outside every hole (even-odd). Coordinates must share the\n   * polygon's frame. With no holes this is exactly {@link pointInPolygon}.\n   */\n  public pointInPolygonWithHoles(px: number, py: number, xpoints: number[], ypoints: number[],\n                                 holes?: number[][][]): boolean {\n    if (!this.pointInPolygon(px, py, xpoints, ypoints)) return false;\n    if (holes) {\n      for (const ring of holes) {\n        if (this.pointInPolygon(px, py, ring.map(p => p[0]), ring.map(p => p[1]))) return false;\n      }\n    }\n    return true;\n  }\n\n  /**\n   * Trace the largest 4-connected blob in `mask` (sized w*h) and return a\n   * Polygon translated into image-pixel coordinates via (originX, originY).\n   * The traced vertices are NOT clamped to the image bounds: a region drawn while\n   * panned/zoomed keeps its true coordinates even where they fall outside the visible\n   * window (jit-ui#102). `imageWidth`/`imageHeight` are kept for signature compatibility\n   * but no longer used.\n   */\n  public maskToPolygon(mask: Uint8Array, w: number, h: number,\n                       _imageWidth: number, _imageHeight: number,\n                       originX: number, originY: number): Polygon | null {\n    const verticesLocal = this.traceContour(mask, w, h);\n    if (!verticesLocal || verticesLocal.length < 3) return null;\n    const xpoints: number[] = [];\n    const ypoints: number[] = [];\n    const coordinates: number[][] = [];\n    // No viewport clamp: the trace coords (origin + local) are the region's true coords and may\n    // lie outside the currently-visible window when it was panned/zoomed (jit-ui#102).\n    for (const v of verticesLocal) {\n      const ix = Math.round(originX + v.x);\n      const iy = Math.round(originY + v.y);\n      xpoints.push(ix);\n      ypoints.push(iy);\n      coordinates.push([ix, iy]);\n    }\n    const poly = new Polygon();\n    poly.npoints = xpoints.length;\n    poly.xpoints = xpoints;\n    poly.ypoints = ypoints;\n    poly.coordinates = coordinates;\n    return poly;\n  }\n\n  /**\n   * Trace EVERY 4-connected blob in `mask` (sized w*h) whose area is at least\n   * `minSize` pixels, returning one Polygon per blob in image-pixel coordinates\n   * (translated via originX/originY, clamped to imageWidth/imageHeight), ordered\n   * largest-first. Unlike {@link maskToPolygon} (largest blob only), this lets\n   * the brush eraser split a region in two when a stroke cuts through it rather\n   * than discarding the smaller piece.\n   */\n  public maskToPolygons(mask: Uint8Array, w: number, h: number,\n                        imageWidth: number, imageHeight: number,\n                        originX: number, originY: number, minSize = 4,\n                        minHoleSize = minSize): Polygon[] {\n    // Label all 4-connected components, recording each one's pixel count.\n    const labels = new Int32Array(w * h);\n    const sizes: number[] = [0]; // sizes[label]; label 0 unused\n    let nextLabel = 0;\n    const queue: number[] = [];\n    for (let y = 0; y < h; y++) {\n      for (let x = 0; x < w; x++) {\n        const idx = y * w + x;\n        if (!mask[idx] || labels[idx]) continue;\n        nextLabel++;\n        labels[idx] = nextLabel;\n        let size = 0;\n        queue.push(idx);\n        while (queue.length) {\n          const i = queue.pop() as number;\n          size++;\n          const px = i % w;\n          const py = (i - px) / w;\n          if (px > 0)     { const j = i - 1;\n            if (mask[j] && !labels[j]) { labels[j] = nextLabel; queue.push(j); } }\n          if (px < w - 1) { const j = i + 1;\n            if (mask[j] && !labels[j]) { labels[j] = nextLabel; queue.push(j); } }\n          if (py > 0)     { const j = i - w;\n            if (mask[j] && !labels[j]) { labels[j] = nextLabel; queue.push(j); } }\n          if (py < h - 1) { const j = i + w;\n            if (mask[j] && !labels[j]) { labels[j] = nextLabel; queue.push(j); } }\n        }\n        sizes[nextLabel] = size;\n      }\n    }\n\n    const wanted: number[] = [];\n    for (let lbl = 1; lbl <= nextLabel; lbl++) {\n      if (sizes[lbl] >= minSize) wanted.push(lbl);\n    }\n    wanted.sort((a, b) => sizes[b] - sizes[a]); // largest-first\n\n    // Interior rings (holes) per foreground label — jit-ui#85.\n    const holesByLabel = this.detectHoles(\n      mask, labels, w, h, originX, originY, imageWidth, imageHeight, minHoleSize);\n\n    const polys: Polygon[] = [];\n    const comp = new Uint8Array(w * h);\n    for (const lbl of wanted) {\n      comp.fill(0);\n      for (let i = 0; i < comp.length; i++) comp[i] = labels[i] === lbl ? 1 : 0;\n      const verts = this.mooreBoundary(comp, w, h);\n      if (!verts || verts.length < 3) continue;\n      const xpoints: number[] = [];\n      const ypoints: number[] = [];\n      const coordinates: number[][] = [];\n      // No viewport clamp (jit-ui#102): keep the region's true coords even off the visible window.\n      for (const v of verts) {\n        const ix = Math.round(originX + v.x);\n        const iy = Math.round(originY + v.y);\n        xpoints.push(ix);\n        ypoints.push(iy);\n        coordinates.push([ix, iy]);\n      }\n      const poly = new Polygon();\n      poly.npoints = xpoints.length;\n      poly.xpoints = xpoints;\n      poly.ypoints = ypoints;\n      poly.coordinates = coordinates;\n      const holes = holesByLabel.get(lbl);\n      if (holes && holes.length) poly.holes = holes;\n      polys.push(poly);\n    }\n    return polys;\n  }\n\n  /**\n   * Find interior rings (holes) of each foreground component in `mask`: a\n   * 4-connected run of background (0) pixels that is fully enclosed — i.e. not\n   * reachable from the grid border through background — is a hole, attributed to\n   * the foreground component that borders it most. Returns `fgLabel → rings`,\n   * each ring a list of `[x, y]` image-pixel pairs (same convention as a\n   * polygon's `coordinates`). Holes smaller than `minHoleSize` are dropped.\n   */\n  private detectHoles(mask: Uint8Array, fgLabels: Int32Array, w: number, h: number,\n                      originX: number, originY: number, imageWidth: number, imageHeight: number,\n                      minHoleSize: number): Map<number, number[][][]> {\n    const result = new Map<number, number[][][]>();\n\n    // 1. Flood-fill background reachable from the grid border (\"outside\").\n    const outside = new Uint8Array(w * h);\n    const stack: number[] = [];\n    const seed = (idx: number) => {\n      if (!mask[idx] && !outside[idx]) { outside[idx] = 1; stack.push(idx); }\n    };\n    for (let x = 0; x < w; x++) { seed(x); seed((h - 1) * w + x); }\n    for (let y = 0; y < h; y++) { seed(y * w); seed(y * w + w - 1); }\n    while (stack.length) {\n      const i = stack.pop() as number;\n      const px = i % w, py = (i - px) / w;\n      if (px > 0) seed(i - 1);\n      if (px < w - 1) seed(i + 1);\n      if (py > 0) seed(i - w);\n      if (py < h - 1) seed(i + w);\n    }\n\n    // 2. Remaining unvisited background pixels are enclosed holes. BFS each,\n    //    tally the bordering foreground label, and trace its boundary.\n    const visited = new Uint8Array(w * h);\n    const holeMask = new Uint8Array(w * h);\n    const queue: number[] = [];\n    for (let start = 0; start < mask.length; start++) {\n      if (mask[start] || outside[start] || visited[start]) continue;\n      let size = 0;\n      const owners = new Map<number, number>();\n      const pixels: number[] = [];\n      visited[start] = 1;\n      queue.length = 0;\n      queue.push(start);\n      while (queue.length) {\n        const i = queue.pop() as number;\n        size++;\n        pixels.push(i);\n        const px = i % w, py = (i - px) / w;\n        const visit = (j: number) => {\n          if (mask[j]) {\n            const lbl = fgLabels[j];\n            if (lbl) owners.set(lbl, (owners.get(lbl) ?? 0) + 1);\n          } else if (!outside[j] && !visited[j]) {\n            visited[j] = 1;\n            queue.push(j);\n          }\n        };\n        if (px > 0) visit(i - 1);\n        if (px < w - 1) visit(i + 1);\n        if (py > 0) visit(i - w);\n        if (py < h - 1) visit(i + w);\n      }\n      if (size < minHoleSize || owners.size === 0) continue;\n      let owner = 0, best = -1;\n      owners.forEach((cnt, lbl) => { if (cnt > best) { best = cnt; owner = lbl; } });\n\n      holeMask.fill(0);\n      for (const i of pixels) holeMask[i] = 1;\n      const verts = this.mooreBoundary(holeMask, w, h);\n      if (!verts || verts.length < 3) continue;\n      const ring: number[][] = [];\n      for (const v of verts) {\n        const ix = Math.max(0, Math.min(imageWidth - 1, Math.round(originX + v.x)));\n        const iy = Math.max(0, Math.min(imageHeight - 1, Math.round(originY + v.y)));\n        ring.push([ix, iy]);\n      }\n      const list = result.get(owner) ?? [];\n      list.push(ring);\n      result.set(owner, list);\n    }\n    return result;\n  }\n\n  /**\n   * Trace each instance in an integer label map (0 = background) into a Polygon\n   * — used to turn a cellpose-style segmentation into region outlines. Labels\n   * with area below `minSize` are skipped. Coords are translated via\n   * originX/originY and clamped to imageWidth/imageHeight.\n   */\n  public labelsToPolygons(labels: Uint32Array, w: number, h: number,\n                          imageWidth: number, imageHeight: number,\n                          originX: number, originY: number, minSize = 10): Polygon[] {\n    let maxLabel = 0;\n    for (let i = 0; i < labels.length; i++) if (labels[i] > maxLabel) maxLabel = labels[i];\n    const out: Polygon[] = [];\n    const bin = new Uint8Array(w * h);\n    for (let lbl = 1; lbl <= maxLabel; lbl++) {\n      let any = false;\n      for (let i = 0; i < labels.length; i++) {\n        const on = labels[i] === lbl; bin[i] = on ? 1 : 0; if (on) any = true;\n      }\n      if (!any) continue;\n      // Reuse the contour tracer; one label is usually a single blob.\n      for (const p of this.maskToPolygons(bin, w, h, imageWidth, imageHeight, originX, originY, minSize)) {\n        out.push(p);\n      }\n    }\n    return out;\n  }\n\n  // ── Patch extraction ────────────────────────────────────────────────\n\n  private extractPatch(image: WandImage, cx: number, cy: number, W: number, type: WandType): Float32Array {\n    const channels = (type === 'GRAY') ? 1 : 3;\n    const half = (W - 1) / 2;\n    const x0 = Math.round(cx) - half;\n    const y0 = Math.round(cy) - half;\n    const buf = new Float32Array(W * W * channels);\n\n    for (let py = 0; py < W; py++) {\n      const iy = y0 + py;\n      if (iy < 0 || iy >= image.height) continue;\n      const row = image.data[iy];\n      if (!row) continue;\n      for (let px = 0; px < W; px++) {\n        const ix = x0 + px;\n        if (ix < 0 || ix >= image.width) continue;\n        const dst = (py * W + px) * channels;\n        if (image.isGrayscale) {\n          const v = row[ix] as number;\n          if (channels === 1) {\n            buf[dst] = v;\n          } else {\n            buf[dst] = v;\n            buf[dst + 1] = v;\n            buf[dst + 2] = v;\n          }\n        } else {\n          const tuple = row[ix] as number[];\n          if (channels === 1) {\n            // GRAY type forced on RGB image: convert with luminance.\n            buf[dst] = 0.299 * tuple[0] + 0.587 * tuple[1] + 0.114 * tuple[2];\n          } else {\n            buf[dst] = tuple[0];\n            buf[dst + 1] = tuple[1];\n            buf[dst + 2] = tuple[2];\n          }\n        }\n      }\n    }\n    return buf;\n  }\n\n  // ── Gaussian blur (separable) ───────────────────────────────────────\n\n  private gaussianBlur(buf: Float32Array, W: number, channels: number, sigma: number): Float32Array {\n    const radius = Math.max(1, Math.ceil(sigma * 2));\n    const size = radius * 2 + 1;\n    const kernel = new Float32Array(size);\n    let sum = 0;\n    const inv2s2 = 1 / (2 * sigma * sigma);\n    for (let i = 0; i < size; i++) {\n      const x = i - radius;\n      kernel[i] = Math.exp(-x * x * inv2s2);\n      sum += kernel[i];\n    }\n    for (let i = 0; i < size; i++) kernel[i] /= sum;\n\n    const horiz = new Float32Array(buf.length);\n    // Horizontal pass.\n    for (let y = 0; y < W; y++) {\n      for (let x = 0; x < W; x++) {\n        for (let c = 0; c < channels; c++) {\n          let acc = 0;\n          for (let k = 0; k < size; k++) {\n            let xx = x + k - radius;\n            if (xx < 0) xx = 0;\n            else if (xx >= W) xx = W - 1;\n            acc += kernel[k] * buf[(y * W + xx) * channels + c];\n          }\n          horiz[(y * W + x) * channels + c] = acc;\n        }\n      }\n    }\n    const out = new Float32Array(buf.length);\n    // Vertical pass.\n    for (let y = 0; y < W; y++) {\n      for (let x = 0; x < W; x++) {\n        for (let c = 0; c < channels; c++) {\n          let acc = 0;\n          for (let k = 0; k < size; k++) {\n            let yy = y + k - radius;\n            if (yy < 0) yy = 0;\n            else if (yy >= W) yy = W - 1;\n            acc += kernel[k] * horiz[(yy * W + x) * channels + c];\n          }\n          out[(y * W + x) * channels + c] = acc;\n        }\n      }\n    }\n    return out;\n  }\n\n  // ── Threshold computation ───────────────────────────────────────────\n\n  private perChannelThreshold(buf: Float32Array, W: number, channels: number, sensitivity: number): number[] {\n    const n = W * W;\n    const sums = new Array(channels).fill(0);\n    const sqs = new Array(channels).fill(0);\n    for (let i = 0; i < n; i++) {\n      for (let c = 0; c < channels; c++) {\n        const v = buf[i * channels + c];\n        sums[c] += v;\n        sqs[c] += v * v;\n      }\n    }\n    const scale = sensitivity > 0 ? 1 / sensitivity : 100;\n    const threshold = new Array(channels);\n    for (let c = 0; c < channels; c++) {\n      const mean = sums[c] / n;\n      const variance = Math.max(0, sqs[c] / n - mean * mean);\n      const stddev = Math.sqrt(variance);\n      threshold[c] = stddev * scale;\n    }\n    return threshold;\n  }\n\n  private labDistanceMap(buf: Float32Array, W: number): { values: Float32Array; mean: number; max: number } {\n    const n = W * W;\n    const lab = new Float32Array(n * 3);\n    for (let i = 0; i < n; i++) {\n      const r = buf[i * 3] / 255;\n      const g = buf[i * 3 + 1] / 255;\n      const b = buf[i * 3 + 2] / 255;\n      const [L, A, B] = srgbToLab(r, g, b);\n      lab[i * 3] = L;\n      lab[i * 3 + 1] = A;\n      lab[i * 3 + 2] = B;\n    }\n    const mid = Math.floor(n / 2);\n    const cL = lab[mid * 3];\n    const cA = lab[mid * 3 + 1];\n    const cB = lab[mid * 3 + 2];\n\n    const values = new Float32Array(n);\n    let max = 0;\n    let sum = 0;\n    for (let i = 0; i < n; i++) {\n      const dL = lab[i * 3] - cL;\n      const dA = lab[i * 3 + 1] - cA;\n      const dB = lab[i * 3 + 2] - cB;\n      const d = Math.sqrt(dL * dL + dA * dA + dB * dB);\n      values[i] = d;\n      if (d > max) max = d;\n      sum += d;\n    }\n    return { values, mean: sum / n, max };\n  }\n\n  // ── Flood fill ──────────────────────────────────────────────────────\n\n  /**\n   * Fixed-range scanline flood fill from the patch centre. A neighbour is\n   * accepted iff for every channel `|p[c] - seed[c]| <= threshold[c]`.\n   */\n  private floodFill(buf: Float32Array, W: number, channels: number, threshold: number[]): Uint8Array {\n    const mask = new Uint8Array(W * W);\n    const seedX = (W - 1) / 2;\n    const seedY = (W - 1) / 2;\n    const seedIdx = (seedY * W + seedX) * channels;\n    const seed = new Array(channels);\n    for (let c = 0; c < channels; c++) seed[c] = buf[seedIdx + c];\n\n    const accept = (x: number, y: number): boolean => {\n      const idx = (y * W + x) * channels;\n      for (let c = 0; c < channels; c++) {\n        const diff = Math.abs(buf[idx + c] - seed[c]);\n        if (diff > threshold[c]) return false;\n      }\n      return true;\n    };\n\n    const stack: number[] = [seedX, seedY];\n    while (stack.length) {\n      const y = stack.pop() as number;\n      const x = stack.pop() as number;\n      if (x < 0 || x >= W || y < 0 || y >= W) continue;\n      if (mask[y * W + x]) continue;\n      if (!accept(x, y)) continue;\n\n      // Find left edge of run.\n      let xl = x;\n      while (xl > 0 && !mask[y * W + (xl - 1)] && accept(xl - 1, y)) xl--;\n      // Find right edge of run.\n      let xr = x;\n      while (xr < W - 1 && !mask[y * W + (xr + 1)] && accept(xr + 1, y)) xr++;\n\n      for (let xi = xl; xi <= xr; xi++) {\n        mask[y * W + xi] = 1;\n      }\n      // Seed runs above and below.\n      if (y > 0) {\n        for (let xi = xl; xi <= xr; xi++) {\n          if (!mask[(y - 1) * W + xi]) {\n            stack.push(xi, y - 1);\n          }\n        }\n      }\n      if (y < W - 1) {\n        for (let xi = xl; xi <= xr; xi++) {\n          if (!mask[(y + 1) * W + xi]) {\n            stack.push(xi, y + 1);\n          }\n        }\n      }\n    }\n    return mask;\n  }\n\n  // ── Morphological close (dilate then erode) ─────────────────────────\n\n  private morphClose(mask: Uint8Array, W: number, kernelSize: number): Uint8Array {\n    const r = (kernelSize - 1) / 2;\n    const dil = this.dilate(mask, W, r);\n    return this.erode(dil, W, r);\n  }\n\n  private dilate(mask: Uint8Array, W: number, r: number): Uint8Array {\n    const out = new Uint8Array(W * W);\n    for (let y = 0; y < W; y++) {\n      for (let x = 0; x < W; x++) {\n        let hit = 0;\n        for (let dy = -r; dy <= r && !hit; dy++) {\n          const yy = y + dy;\n          if (yy < 0 || yy >= W) continue;\n          for (let dx = -r; dx <= r; dx++) {\n            const xx = x + dx;\n            if (xx < 0 || xx >= W) continue;\n            if (mask[yy * W + xx]) { hit = 1; break; }\n          }\n        }\n        out[y * W + x] = hit;\n      }\n    }\n    return out;\n  }\n\n  private erode(mask: Uint8Array, W: number, r: number): Uint8Array {\n    const out = new Uint8Array(W * W);\n    for (let y = 0; y < W; y++) {\n      for (let x = 0; x < W; x++) {\n        let all = 1;\n        for (let dy = -r; dy <= r && all; dy++) {\n          const yy = y + dy;\n          if (yy < 0 || yy >= W) { all = 0; break; }\n          for (let dx = -r; dx <= r; dx++) {\n            const xx = x + dx;\n            if (xx < 0 || xx >= W) { all = 0; break; }\n            if (!mask[yy * W + xx]) { all = 0; break; }\n          }\n        }\n        out[y * W + x] = all;\n      }\n    }\n    return out;\n  }\n\n  // ── Contour tracing (Moore-neighbour boundary follow) ───────────────\n\n  /**\n   * Returns the outer boundary of the largest 4-connected blob in the mask\n   * sized w*h.\n   */\n  private traceContour(mask: Uint8Array, w: number, h: number): { x: number; y: number }[] | null {\n    // Find the largest connected component (4-connectivity).\n    const labels = new Int32Array(w * h);\n    let bestLabel = 0;\n    let bestSize = 0;\n    let nextLabel = 0;\n    const queue: number[] = [];\n    for (let y = 0; y < h; y++) {\n      for (let x = 0; x < w; x++) {\n        const idx = y * w + x;\n        if (!mask[idx] || labels[idx]) continue;\n        nextLabel++;\n        labels[idx] = nextLabel;\n        let size = 0;\n        queue.push(idx);\n        while (queue.length) {\n          const i = queue.pop() as number;\n          size++;\n          const px = i % w;\n          const py = (i - px) / w;\n          if (px > 0)     { const j = i - 1;\n            if (mask[j] && !labels[j]) { labels[j] = nextLabel; queue.push(j); } }\n          if (px < w - 1) { const j = i + 1;\n            if (mask[j] && !labels[j]) { labels[j] = nextLabel; queue.push(j); } }\n          if (py > 0)     { const j = i - w;\n            if (mask[j] && !labels[j]) { labels[j] = nextLabel; queue.push(j); } }\n          if (py < h - 1) { const j = i + w;\n            if (mask[j] && !labels[j]) { labels[j] = nextLabel; queue.push(j); } }\n        }\n        if (size > bestSize) { bestSize = size; bestLabel = nextLabel; }\n      }\n    }\n    if (bestSize === 0) return null;\n\n    // Build a single-component mask, then trace its outer boundary using\n    // Moore-neighbour following.\n    const comp = new Uint8Array(w * h);\n    for (let i = 0; i < comp.length; i++) comp[i] = labels[i] === bestLabel ? 1 : 0;\n\n    return this.mooreBoundary(comp, w, h);\n  }\n\n  private mooreBoundary(mask: Uint8Array, w: number, h: number): { x: number; y: number }[] {\n    // Find the first foreground pixel in raster order — guaranteed to lie\n    // on the boundary.\n    let startIdx = -1;\n    for (let i = 0; i < mask.length; i++) {\n      if (mask[i]) { startIdx = i; break; }\n    }\n    if (startIdx < 0) return [];\n\n    const sx = startIdx % w;\n    const sy = (startIdx - sx) / w;\n    const points: { x: number; y: number }[] = [{ x: sx, y: sy }];\n\n    // Single isolated pixel — emit the pixel's four corner points so callers\n    // (which require ≥ 3 vertices to build a polygon) get a valid 1×1 square\n    // instead of a degenerate single-vertex contour.\n    const singleton = (idx: number): boolean => {\n      const x = idx % w;\n      const y = (idx - x) / w;\n      const at = (xx: number, yy: number) => xx >= 0 && xx < w && yy >= 0 && yy < h && mask[yy * w + xx];\n      return !(at(x - 1, y) || at(x + 1, y) || at(x, y - 1) || at(x, y + 1));\n    };\n    if (singleton(startIdx)) {\n      return [\n        { x: sx,     y: sy     },\n        { x: sx + 1, y: sy     },\n        { x: sx + 1, y: sy + 1 },\n        { x: sx,     y: sy + 1 },\n      ];\n    }\n\n    // 8-connected neighbour offsets in clockwise order starting from West.\n    const dx = [-1, -1,  0,  1, 1, 1, 0, -1];\n    const dy = [ 0, -1, -1, -1, 0, 1, 1,  1];\n\n    let cx = sx, cy = sy;\n    // Backtrack direction — start from West (the side we'd be coming from in raster order).\n    let prevDir = 0;\n    const maxSteps = w * h * 8;\n\n    for (let step = 0; step < maxSteps; step++) {\n      // Standard Moore-neighbour tracing: search clockwise starting one step\n      // after the backtrack direction.\n      let found = false;\n      for (let k = 1; k <= 8; k++) {\n        const dir = (prevDir + k) & 7;\n        const nx = cx + dx[dir];\n        const ny = cy + dy[dir];\n        if (nx < 0 || nx >= w || ny < 0 || ny >= h) continue;\n        if (mask[ny * w + nx]) {\n          // Backtrack direction is from new pixel back toward previous pixel.\n          prevDir = (dir + 4) & 7;\n          cx = nx;\n          cy = ny;\n          points.push({ x: cx, y: cy });\n          found = true;\n          break;\n        }\n      }\n      if (!found) break;\n      if (cx === sx && cy === sy && points.length > 1) {\n        points.pop();\n        break;\n      }\n    }\n\n    return points;\n  }\n}\n\n// ── sRGB → CIELAB (D65) ───────────────────────────────────────────────\n\nfunction srgbToLinear(c: number): number {\n  return c <= 0.04045 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);\n}\n\nfunction srgbToLab(r: number, g: number, b: number): [number, number, number] {\n  const R = srgbToLinear(r);\n  const G = srgbToLinear(g);\n  const B = srgbToLinear(b);\n  // sRGB → XYZ (D65)\n  const X = R * 0.4124564 + G * 0.3575761 + B * 0.1804375;\n  const Y = R * 0.2126729 + G * 0.7151522 + B * 0.0721750;\n  const Z = R * 0.0193339 + G * 0.1191920 + B * 0.9503041;\n  // Reference white (D65)\n  const Xn = 0.95047, Yn = 1.0, Zn = 1.08883;\n  const fx = labF(X / Xn);\n  const fy = labF(Y / Yn);\n  const fz = labF(Z / Zn);\n  const L = 116 * fy - 16;\n  const A = 500 * (fx - fy);\n  const Bv = 200 * (fy - fz);\n  return [L, A, Bv];\n}\n\nfunction labF(t: number): number {\n  const d = 6 / 29;\n  return t > d * d * d ? Math.cbrt(t) : t / (3 * d * d) + 4 / 29;\n}\n"]}