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

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

@@ -0,0 +1,499 @@
+import { Injectable } from '@angular/core';
+import { WandService } from './wand.service';
+import { masksOverlap, unionMasks } from '../../models/geometry';
+import { Region, Polygon } from '../../models/region';
+import * as i0 from "@angular/core";
+import * as i1 from "./wand.service";
+/**
+ * The wand drawing tool. Owns its own canvas overlay, mouse handlers, and
+ * stroke accumulator. Reads/writes the shape list via the WandToolHost
+ * interface so it stays decoupled from PlotlyService internals.
+ *
+ * Lifecycle: PlotlyService injects this service, calls `bindHost(this)` once
+ * during its own construction, then calls `setMode(true | false, options)` to
+ * activate/deactivate the tool.
+ */
+export class WandToolService {
+    constructor(wandService) {
+        this.wandService = wandService;
+        this.overlay = null;
+        this.active = false;
+        /**
+         * Accumulated wand region. Every per-tick patch mask is OR'd into `mask`
+         * over a bbox that grows with the stroke, so the region keeps expanding
+         * as the user drags. The accumulator persists across mouseup/mousedown so
+         * that subsequent strokes extend the *same* region — matching QuPath's
+         * brush behaviour where the active annotation stays editable until the
+         * user switches tool.
+         */
+        this.stroke = null;
+        /** Id of the region this wand stroke is editing (null = a fresh region). */
+        this.strokeRegionId = null;
+        /** Readback ratio/origin signature the active stroke's matrix coords are tied to; a change
+         *  (zoom/pan) invalidates the stroke so it isn't re-committed at a different scale (jit-ui#102). */
+        this.strokeRatioSig = null;
+        this.dragging = false;
+        this.options = {};
+        this.boundMouseDown = (e) => this.onMouseDown(e);
+        this.boundMouseMove = (e) => this.onMouseMove(e);
+        this.boundMouseUp = (e) => this.onMouseUp(e);
+    }
+    /** Wire the tool to its host. Must be called once before `setMode(true)`. */
+    bindHost(host) {
+        this.host = host;
+    }
+    // ── Public API ──────────────────────────────────────────────────────
+    /** Toggle the wand on/off. */
+    setMode(active, options = {}) {
+        this.active = active;
+        this.options = options;
+        if (active) {
+            this.createOverlay();
+        }
+        else {
+            this.destroyOverlay();
+        }
+    }
+    /** Merge new options (e.g. live sensitivity slider updates). */
+    setOptions(options) {
+        this.options = { ...this.options, ...options };
+    }
+    /** Drop the active wand region so the next click starts a new one. */
+    clearActiveRegion() {
+        this.resetStroke();
+    }
+    // ── Overlay lifecycle ───────────────────────────────────────────────
+    createOverlay() {
+        const plotEl = this.host.getOverlayContainer();
+        if (!plotEl || this.overlay)
+            return;
+        const canvas = document.createElement('canvas');
+        canvas.style.position = 'absolute';
+        canvas.style.top = '0';
+        canvas.style.left = '0';
+        canvas.style.width = '100%';
+        canvas.style.height = '100%';
+        canvas.style.cursor = 'crosshair';
+        canvas.style.zIndex = '100';
+        canvas.width = plotEl.offsetWidth;
+        canvas.height = plotEl.offsetHeight;
+        plotEl.appendChild(canvas);
+        this.overlay = canvas;
+        canvas.addEventListener('mousedown', this.boundMouseDown);
+        canvas.addEventListener('mousemove', this.boundMouseMove);
+        canvas.addEventListener('mouseup', this.boundMouseUp);
+        canvas.addEventListener('mouseleave', this.boundMouseUp);
+    }
+    destroyOverlay() {
+        if (!this.overlay)
+            return;
+        this.overlay.removeEventListener('mousedown', this.boundMouseDown);
+        this.overlay.removeEventListener('mousemove', this.boundMouseMove);
+        this.overlay.removeEventListener('mouseup', this.boundMouseUp);
+        this.overlay.removeEventListener('mouseleave', this.boundMouseUp);
+        this.overlay.remove();
+        this.overlay = null;
+        this.resetStroke();
+    }
+    onMouseDown(e) {
+        if (e.button !== 0)
+            return;
+        this.dragging = true;
+        this.applyAtClient(e, true);
+    }
+    onMouseMove(e) {
+        if (!this.dragging)
+            return;
+        if ((e.buttons & 1) === 0) {
+            this.dragging = false;
+            return;
+        }
+        this.applyAtClient(e, false);
+    }
+    onMouseUp(_) {
+        // Stop accumulating from this drag, but keep the region alive so the
+        // next mousedown extends it instead of starting fresh.
+        this.dragging = false;
+    }
+    resetStroke() {
+        this.stroke = null;
+        this.strokeRegionId = null;
+        this.dragging = false;
+    }
+    // ── Per-tick stroke logic ───────────────────────────────────────────
+    /**
+     * Sample the cached image at the click location, OR (or AND-NOT) the
+     * wand's per-tick patch mask into the active region's bbox-relative mask,
+     * re-trace the boundary, and update the in-progress shape — matching
+     * QuPath's additive brush/wand behaviour. Shift = erase. Cmd/Ctrl =
+     * exact-match flood fill.
+     */
+    applyAtClient(e, isStart = false) {
+        if (!this.overlay)
+            return;
+        const cached = this.host.getCachedImageData();
+        if (!cached || cached.frames.length === 0)
+            return;
+        // The current regions (neutral model). Mutated locally across this tick and
+        // committed once via host.setRegions().
+        const regions = this.host.getRegions();
+        const transform = this.host.getCoordinateTransform();
+        if (!transform.isReady())
+            return;
+        const { x: dataX, y: dataY } = transform.clientToData(e.clientX, e.clientY);
+        if (!Number.isFinite(dataX) || !Number.isFinite(dataY))
+            return;
+        // ratios = [xRatio, yRatio] from both backends. Use the X ratio for the
+        // column and the Y ratio for the row: they differ when the pixel aspect
+        // isn't 1:1 (e.g. a non-square OSD viewport), and reusing ratios[0] for
+        // both would distort the sampled region vertically. Fall back to the X
+        // ratio if only one was supplied.
+        const rx = cached.ratios[0] || 1;
+        const ry = cached.ratios[1] || cached.ratios[0] || 1;
+        const ox = cached.originX ?? 0;
+        const oy = cached.originY ?? 0;
+        // The stroke accumulator is in matrix (viewport-pixel) coordinates tied to the readback's
+        // ratio/origin. If the view changed (zoom/pan) since the stroke was built, those coords no
+        // longer mean the same thing — re-committing would rescale the region by the zoom factor
+        // (jit-ui#102). Drop the stale stroke so a fresh one is built at the current view.
+        const sig = `${rx},${ry},${ox},${oy}`;
+        if (this.stroke && this.strokeRatioSig !== sig) {
+            this.stroke = null;
+            this.strokeRegionId = null;
+        }
+        this.strokeRatioSig = sig;
+        const matrixX = (dataX - ox) / rx;
+        const matrixY = (dataY - oy) / ry;
+        if (matrixX < 0 || matrixX >= cached.width)
+            return;
+        if (matrixY < 0 || matrixY >= cached.height)
+            return;
+        const frameIdx = this.host.getActiveFrameIndex();
+        const frame = cached.frames[frameIdx] ?? cached.frames[0];
+        const wandImage = {
+            data: frame,
+            width: cached.width,
+            height: cached.height,
+            isGrayscale: cached.isGrayscale,
+        };
+        // Shift = erase (subtract pixels from an existing region).
+        // Cmd/Ctrl alone = simple flood fill (no smoothing/threshold).
+        const erase = e.shiftKey;
+        const opts = {
+            ...this.options,
+            simpleMode: this.options.simpleMode || ((e.metaKey || e.ctrlKey) && !erase),
+        };
+        // If this is the first tick of a new drag and the click is NOT inside the
+        // current accumulator and NOT inside any existing path-shape, drop the old
+        // stroke so a brand-new region starts here. Without this, the accumulator
+        // bbox grows to span both areas and `maskToPolygon` keeps only the largest
+        // connected blob — making the new click appear to do nothing.
+        if (isStart && !erase && this.stroke && !this.pointInStroke(matrixX, matrixY)) {
+            // Will fall through to tryAdoptShapeAt below; if that also misses, a
+            // fresh stroke is created from the patch.
+            this.stroke = null;
+            this.strokeRegionId = null;
+        }
+        const patch = this.wandService.computePatchMask(wandImage, matrixX, matrixY, opts);
+        if (!patch)
+            return;
+        const W = patch.size;
+        const half = (W - 1) / 2;
+        const px0 = Math.round(matrixX) - half;
+        const py0 = Math.round(matrixY) - half;
+        const px1 = px0 + W;
+        const py1 = py0 + W;
+        // If there's no active wand region, see if the click landed on an
+        // existing path-shape — adopt it so this stroke extends (or erases
+        // from) it instead of creating a new region.
+        if (!this.stroke) {
+            this.tryAdoptShapeAt(regions, matrixX, matrixY, rx, ry, cached);
+        }
+        // Erasing requires an existing region. Shift-clicking empty space is a
+        // no-op — we don't create a region only to immediately delete from it.
+        if (erase && !this.stroke)
+            return;
+        // Grow the region's accumulated mask only when adding. Erasing never
+        // expands the region beyond its current bbox.
+        if (!this.stroke) {
+            const bx = Math.max(0, px0);
+            const by = Math.max(0, py0);
+            const bx1 = Math.min(cached.width, px1);
+            const by1 = Math.min(cached.height, py1);
+            const bw = Math.max(0, bx1 - bx);
+            const bh = Math.max(0, by1 - by);
+            if (bw === 0 || bh === 0)
+                return;
+            this.stroke = { bx, by, bw, bh, mask: new Uint8Array(bw * bh) };
+        }
+        else if (!erase) {
+            // Don't clamp the accumulator to the viewport: an adopted region may extend off-screen, and
+            // clamping here would discard its off-screen part when the stroke grows (jit-ui#102).
+            const bx = Math.min(this.stroke.bx, px0);
+            const by = Math.min(this.stroke.by, py0);
+            const bx1 = Math.max(this.stroke.bx + this.stroke.bw, px1);
+            const by1 = Math.max(this.stroke.by + this.stroke.bh, py1);
+            const bw = bx1 - bx;
+            const bh = by1 - by;
+            if (bw !== this.stroke.bw || bh !== this.stroke.bh || bx !== this.stroke.bx || by !== this.stroke.by) {
+                // Reallocate the larger mask and copy the previous mask into it.
+                const next = new Uint8Array(bw * bh);
+                const dx = this.stroke.bx - bx;
+                const dy = this.stroke.by - by;
+                for (let row = 0; row < this.stroke.bh; row++) {
+                    const srcOff = row * this.stroke.bw;
+                    const dstOff = (row + dy) * bw + dx;
+                    next.set(this.stroke.mask.subarray(srcOff, srcOff + this.stroke.bw), dstOff);
+                }
+                this.stroke = { bx, by, bw, bh, mask: next };
+            }
+        }
+        // Apply the patch: OR (add) or AND-NOT (erase).
+        const stroke = this.stroke;
+        for (let py = 0; py < W; py++) {
+            const iy = py0 + py;
+            const my = iy - stroke.by;
+            if (my < 0 || my >= stroke.bh)
+                continue;
+            const srcRow = py * W;
+            const dstRow = my * stroke.bw;
+            for (let px = 0; px < W; px++) {
+                if (!patch.mask[srcRow + px])
+                    continue;
+                const ix = px0 + px;
+                const mx = ix - stroke.bx;
+                if (mx < 0 || mx >= stroke.bw)
+                    continue;
+                if (erase)
+                    stroke.mask[dstRow + mx] = 0;
+                else
+                    stroke.mask[dstRow + mx] = 1;
+            }
+        }
+        if (!erase) {
+            // If the grown stroke now overlaps another path-shape, fold those
+            // shapes into this one and drop them — matching QuPath's
+            // merge-on-touch behaviour.
+            this.mergeOverlappingShapes(regions, rx, ry, cached);
+        }
+        // Trace the union boundary in image-pixel coords.
+        const stroke2 = this.stroke;
+        const poly = this.wandService.maskToPolygon(stroke2.mask, stroke2.bw, stroke2.bh, cached.width, cached.height, stroke2.bx, stroke2.by);
+        if (!poly) {
+            // Erased to nothing — remove the shape entirely.
+            if (erase)
+                this.dropActiveShape(regions);
+            return;
+        }
+        // Convert from matrix coords back to plot data coords.
+        const xPlot = poly.xpoints.map((x) => ox + x * rx);
+        const yPlot = poly.ypoints.map((y) => oy + y * ry);
+        this.commitStroke(regions, xPlot, yPlot);
+    }
+    /** True if (matrixX, matrixY) lies inside the current stroke accumulator. */
+    pointInStroke(matrixX, matrixY) {
+        const s = this.stroke;
+        if (!s)
+            return false;
+        const mx = Math.floor(matrixX) - s.bx;
+        const my = Math.floor(matrixY) - s.by;
+        if (mx < 0 || my < 0 || mx >= s.bw || my >= s.bh)
+            return false;
+        return s.mask[my * s.bw + mx] === 1;
+    }
+    /**
+     * Remove the region referenced by `strokeRegionId` from the region list and
+     * reset the active stroke — used when an erase stroke deletes every pixel.
+     */
+    dropActiveShape(regions) {
+        if (this.strokeRegionId != null) {
+            const idx = regions.findIndex((r) => r.id === this.strokeRegionId);
+            if (idx >= 0) {
+                regions.splice(idx, 1);
+                this.host.setRegions(regions);
+            }
+        }
+        this.stroke = null;
+        this.strokeRegionId = null;
+    }
+    /**
+     * Whether a region can be faithfully rasterized into the wand stroke at the current view
+     * resolution (rx/ry = data units per matrix pixel). Editing rasterizes the region to the
+     * viewport grid and re-traces it, so a region whose matrix-space bbox exceeds the rasterizer's
+     * cap would be clipped/down-quantized and come back rescaled/corrupted (jit-ui#102) — e.g. a
+     * whole-slide annotation while zoomed out. Skip adopt/merge for those: leave them untouched and
+     * only edit them near native zoom.
+     */
+    fitsForEdit(verts, rx, ry) {
+        const xs = verts.xpoints;
+        const ys = verts.ypoints;
+        let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
+        for (let i = 0; i < xs.length; i++) {
+            if (xs[i] < minX)
+                minX = xs[i];
+            if (xs[i] > maxX)
+                maxX = xs[i];
+            if (ys[i] < minY)
+                minY = ys[i];
+            if (ys[i] > maxY)
+                maxY = ys[i];
+        }
+        const w = (maxX - minX) / (rx || 1);
+        const h = (maxY - minY) / (ry || 1);
+        return w > 0 && h > 0 && w * h <= 4096 * 4096;
+    }
+    /** A region's closed-polygon vertices (image/data coords), or null when it
+     *  isn't a fillable closed polygon (rectangles, open polylines). */
+    regionVerts(region) {
+        const b = region?.bounds;
+        if (b instanceof Polygon && b.closed !== false && b.xpoints.length >= 3) {
+            return { xpoints: b.xpoints, ypoints: b.ypoints, holes: b.holes };
+        }
+        return null;
+    }
+    /** Convert a region's hole rings from image/data coords into matrix coords so
+     *  they line up with the stroke accumulator (jit-ui#85). */
+    holesToMatrix(holes, ox, oy, rx, ry) {
+        return holes?.map((ring) => ring.map(([x, y]) => [(x - ox) / rx, (y - oy) / ry]));
+    }
+    /**
+     * If (matrixX, matrixY) falls inside an existing region, rasterize it into
+     * the wand stroke accumulator so subsequent wand input extends it rather than
+     * starting a new region.
+     */
+    tryAdoptShapeAt(regions, matrixX, matrixY, rx, ry, cached) {
+        if (!regions || regions.length === 0)
+            return false;
+        // Most-recently-added regions are on top — check them first.
+        for (let i = regions.length - 1; i >= 0; i--) {
+            const verts = this.regionVerts(regions[i]);
+            if (!verts)
+                continue;
+            // Too large to rasterize at this zoom → don't adopt it (editing would rescale/corrupt it).
+            if (!this.fitsForEdit(verts, rx, ry))
+                continue;
+            const ox = cached.originX ?? 0;
+            const oy = cached.originY ?? 0;
+            const xs = verts.xpoints.map((x) => (x - ox) / rx);
+            const ys = verts.ypoints.map((y) => (y - oy) / ry);
+            const holes = this.holesToMatrix(verts.holes, ox, oy, rx, ry);
+            // Clicking inside a hole must NOT adopt the donut (it's empty there).
+            if (!this.wandService.pointInPolygonWithHoles(matrixX, matrixY, xs, ys, holes))
+                continue;
+            const raster = this.wandService.rasterizePolygon(xs, ys, cached.width, cached.height, holes);
+            if (!raster)
+                continue;
+            this.stroke = raster;
+            this.strokeRegionId = regions[i].id ?? null;
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Iterate every region; if its rasterized mask overlaps the wand stroke mask
+     * by at least one pixel, OR it into the stroke and remove it from the list.
+     * Called every tick so chained merges resolve. If the wand has no region id
+     * yet, the merged region's id is adopted so the merged region replaces it.
+     */
+    mergeOverlappingShapes(regions, rx, ry, cached) {
+        if (!this.stroke)
+            return;
+        let didMerge = true;
+        while (didMerge) {
+            didMerge = false;
+            for (let i = regions.length - 1; i >= 0; i--) {
+                const region = regions[i];
+                if (region.id != null && region.id === this.strokeRegionId)
+                    continue;
+                const verts = this.regionVerts(region);
+                if (!verts)
+                    continue;
+                // Too large to rasterize at this zoom → don't merge it (would rescale/corrupt it).
+                if (!this.fitsForEdit(verts, rx, ry))
+                    continue;
+                const ox = cached.originX ?? 0;
+                const oy = cached.originY ?? 0;
+                const xs = verts.xpoints.map((x) => (x - ox) / rx);
+                const ys = verts.ypoints.map((y) => (y - oy) / ry);
+                // Quick bbox reject before rasterizing.
+                let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
+                for (let k = 0; k < xs.length; k++) {
+                    if (xs[k] < minX)
+                        minX = xs[k];
+                    if (xs[k] > maxX)
+                        maxX = xs[k];
+                    if (ys[k] < minY)
+                        minY = ys[k];
+                    if (ys[k] > maxY)
+                        maxY = ys[k];
+                }
+                const wx0 = this.stroke.bx, wy0 = this.stroke.by;
+                const wx1 = wx0 + this.stroke.bw, wy1 = wy0 + this.stroke.bh;
+                if (maxX < wx0 || minX > wx1 || maxY < wy0 || minY > wy1)
+                    continue;
+                const holes = this.holesToMatrix(verts.holes, ox, oy, rx, ry);
+                const raster = this.wandService.rasterizePolygon(xs, ys, cached.width, cached.height, holes);
+                if (!raster)
+                    continue;
+                if (!masksOverlap(this.stroke, raster))
+                    continue;
+                this.stroke = unionMasks(this.stroke, raster);
+                if (this.strokeRegionId == null) {
+                    this.strokeRegionId = region.id ?? null;
+                }
+                regions.splice(i, 1);
+                didMerge = true;
+                break;
+            }
+        }
+    }
+    /**
+     * Commit the in-progress polygon as a region — a new region on the first tick
+     * of a stroke, or an in-place replacement of the active region on later ticks
+     * — then ask the host to render. The store mints an id on the first commit,
+     * which we adopt so subsequent ticks replace the same region.
+     */
+    commitStroke(regions, xPlot, yPlot) {
+        if (xPlot.length < 3)
+            return;
+        const existing = this.strokeRegionId != null
+            ? regions.find((r) => r.id === this.strokeRegionId) : null;
+        const poly = new Polygon();
+        poly.npoints = xPlot.length;
+        poly.xpoints = xPlot;
+        poly.ypoints = yPlot;
+        poly.coordinates = xPlot.map((x, i) => [x, yPlot[i]]);
+        poly.closed = true;
+        const region = new Region();
+        region.bounds = poly;
+        region.color = this.host.getShapeColor();
+        if (existing) {
+            // Preserve identity + class label across the stroke's drag ticks.
+            region.id = existing.id;
+            region.name = existing.name;
+        }
+        // Default class/annotation name, matching the overlay-drawn regions and the
+        // Region Editor's "Add" actions so a wand region isn't left unlabeled.
+        region.label = existing?.label ?? 'Region';
+        if (this.strokeRegionId == null) {
+            regions.push(region);
+        }
+        else {
+            const idx = regions.findIndex((r) => r.id === this.strokeRegionId);
+            if (idx >= 0)
+                regions[idx] = region;
+            else
+                regions.push(region);
+        }
+        this.host.setRegions(regions);
+        // The store assigns an id on the first commit — adopt it.
+        this.strokeRegionId = region.id ?? this.strokeRegionId;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: WandToolService, deps: [{ token: i1.WandService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: WandToolService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: WandToolService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.WandService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"wand-tool.service.js","sourceRoot":"","sources":["../../../../../src/lib/toolbar/wand/wand-tool.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\n\nimport { WandImage, WandOptions, WandService } from './wand.service';\nimport { BBoxMask, masksOverlap, unionMasks } from '../../models/geometry';\nimport { IViewportHost, IRegionDataHost } from '../../contracts/coordinate-transform.contract';\nimport { Region, Polygon } from '../../models/region';\n\n/**\n * The pixel data and frame state PlotlyService caches for sampling. Returned\n * by `WandToolHost.getCachedImageData()`.\n */\nexport interface CachedImageData {\n  /** 2-D matrices, one per stack frame (length 1 for non-stack images). */\n  frames: any[];\n  /** Image-pixel width of each frame matrix. */\n  width: number;\n  /** Image-pixel height of each frame matrix. */\n  height: number;\n  /**\n   * Plot-data-coords-per-image-pixel along x (and y — they're the same\n   * for heatmap and image traces).\n   */\n  ratios: number[];\n  /** Whether each frame is a 2-D scalar matrix (true) or 3-channel RGB (false). */\n  isGrayscale: boolean;\n  /**\n   * Data-coords of matrix pixel (0,0). Lets the matrix be a *crop* of the data\n   * space rather than starting at the origin — e.g. the OSD backend samples the\n   * currently rendered viewport, so when zoomed in the matrix covers only the\n   * visible sub-region at screen resolution. Defaults to 0 (full-frame matrix,\n   * as Plotly provides). matrixIndex = (data - origin) / ratio.\n   */\n  originX?: number;\n  originY?: number;\n}\n\n/**\n * The collaboration interface the wand tool needs from PlotlyService.\n *\n * Keeping it explicit makes the dependency one-way: WandToolService never\n * imports PlotlyService directly. PlotlyService satisfies this interface\n * structurally and binds itself via `bindHost(this)`.\n */\nexport interface WandToolHost extends IViewportHost, IRegionDataHost {\n  /** Pixel data for sampling. null when no image is loaded yet. */\n  getCachedImageData(): CachedImageData | null;\n  /** Index of the currently visible frame in a stack (0 for non-stack). */\n  getActiveFrameIndex(): number;\n\n  /** Current image's filename — stamped onto new shapes for filtering. */\n  getFileName(): string | undefined;\n  /** Default stroke colour for new shapes. */\n  getShapeColor(): string;\n}\n\n/**\n * The wand drawing tool. Owns its own canvas overlay, mouse handlers, and\n * stroke accumulator. Reads/writes the shape list via the WandToolHost\n * interface so it stays decoupled from PlotlyService internals.\n *\n * Lifecycle: PlotlyService injects this service, calls `bindHost(this)` once\n * during its own construction, then calls `setMode(true | false, options)` to\n * activate/deactivate the tool.\n */\n@Injectable({ providedIn: 'root' })\nexport class WandToolService {\n  // ── Tool state ──────────────────────────────────────────────────────\n\n  private host!: WandToolHost;\n  private overlay: HTMLCanvasElement | null = null;\n  private active = false;\n  /**\n   * Accumulated wand region. Every per-tick patch mask is OR'd into `mask`\n   * over a bbox that grows with the stroke, so the region keeps expanding\n   * as the user drags. The accumulator persists across mouseup/mousedown so\n   * that subsequent strokes extend the *same* region — matching QuPath's\n   * brush behaviour where the active annotation stays editable until the\n   * user switches tool.\n   */\n  private stroke: BBoxMask | null = null;\n  /** Id of the region this wand stroke is editing (null = a fresh region). */\n  private strokeRegionId: number | null = null;\n  /** Readback ratio/origin signature the active stroke's matrix coords are tied to; a change\n   *  (zoom/pan) invalidates the stroke so it isn't re-committed at a different scale (jit-ui#102). */\n  private strokeRatioSig: string | null = null;\n  private dragging = false;\n  private options: WandOptions = {};\n\n  private readonly boundMouseDown: (e: MouseEvent) => void;\n  private readonly boundMouseMove: (e: MouseEvent) => void;\n  private readonly boundMouseUp: (e: MouseEvent) => void;\n\n  constructor(private wandService: WandService) {\n    this.boundMouseDown = (e) => this.onMouseDown(e);\n    this.boundMouseMove = (e) => this.onMouseMove(e);\n    this.boundMouseUp = (e) => this.onMouseUp(e);\n  }\n\n  /** Wire the tool to its host. Must be called once before `setMode(true)`. */\n  bindHost(host: WandToolHost) {\n    this.host = host;\n  }\n\n  // ── Public API ──────────────────────────────────────────────────────\n\n  /** Toggle the wand on/off. */\n  setMode(active: boolean, options: WandOptions = {}) {\n    this.active = active;\n    this.options = options;\n    if (active) {\n      this.createOverlay();\n    } else {\n      this.destroyOverlay();\n    }\n  }\n\n  /** Merge new options (e.g. live sensitivity slider updates). */\n  setOptions(options: WandOptions) {\n    this.options = { ...this.options, ...options };\n  }\n\n  /** Drop the active wand region so the next click starts a new one. */\n  clearActiveRegion() {\n    this.resetStroke();\n  }\n\n  // ── Overlay lifecycle ───────────────────────────────────────────────\n\n  private createOverlay() {\n    const plotEl = this.host.getOverlayContainer();\n    if (!plotEl || this.overlay) return;\n\n    const canvas = document.createElement('canvas');\n    canvas.style.position = 'absolute';\n    canvas.style.top = '0';\n    canvas.style.left = '0';\n    canvas.style.width = '100%';\n    canvas.style.height = '100%';\n    canvas.style.cursor = 'crosshair';\n    canvas.style.zIndex = '100';\n    canvas.width = plotEl.offsetWidth;\n    canvas.height = plotEl.offsetHeight;\n\n    plotEl.appendChild(canvas);\n    this.overlay = canvas;\n\n    canvas.addEventListener('mousedown', this.boundMouseDown);\n    canvas.addEventListener('mousemove', this.boundMouseMove);\n    canvas.addEventListener('mouseup', this.boundMouseUp);\n    canvas.addEventListener('mouseleave', this.boundMouseUp);\n  }\n\n  private destroyOverlay() {\n    if (!this.overlay) return;\n    this.overlay.removeEventListener('mousedown', this.boundMouseDown);\n    this.overlay.removeEventListener('mousemove', this.boundMouseMove);\n    this.overlay.removeEventListener('mouseup', this.boundMouseUp);\n    this.overlay.removeEventListener('mouseleave', this.boundMouseUp);\n    this.overlay.remove();\n    this.overlay = null;\n    this.resetStroke();\n  }\n\n  private onMouseDown(e: MouseEvent) {\n    if (e.button !== 0) return;\n    this.dragging = true;\n    this.applyAtClient(e, true);\n  }\n\n  private onMouseMove(e: MouseEvent) {\n    if (!this.dragging) return;\n    if ((e.buttons & 1) === 0) {\n      this.dragging = false;\n      return;\n    }\n    this.applyAtClient(e, false);\n  }\n\n  private onMouseUp(_: MouseEvent) {\n    // Stop accumulating from this drag, but keep the region alive so the\n    // next mousedown extends it instead of starting fresh.\n    this.dragging = false;\n  }\n\n  private resetStroke() {\n    this.stroke = null;\n    this.strokeRegionId = null;\n    this.dragging = false;\n  }\n\n  // ── Per-tick stroke logic ───────────────────────────────────────────\n\n  /**\n   * Sample the cached image at the click location, OR (or AND-NOT) the\n   * wand's per-tick patch mask into the active region's bbox-relative mask,\n   * re-trace the boundary, and update the in-progress shape — matching\n   * QuPath's additive brush/wand behaviour. Shift = erase. Cmd/Ctrl =\n   * exact-match flood fill.\n   */\n  private applyAtClient(e: MouseEvent, isStart = false) {\n    if (!this.overlay) return;\n    const cached = this.host.getCachedImageData();\n    if (!cached || cached.frames.length === 0) return;\n\n    // The current regions (neutral model). Mutated locally across this tick and\n    // committed once via host.setRegions().\n    const regions = this.host.getRegions();\n\n    const transform = this.host.getCoordinateTransform();\n    if (!transform.isReady()) return;\n    const { x: dataX, y: dataY } = transform.clientToData(e.clientX, e.clientY);\n    if (!Number.isFinite(dataX) || !Number.isFinite(dataY)) return;\n\n    // ratios = [xRatio, yRatio] from both backends. Use the X ratio for the\n    // column and the Y ratio for the row: they differ when the pixel aspect\n    // isn't 1:1 (e.g. a non-square OSD viewport), and reusing ratios[0] for\n    // both would distort the sampled region vertically. Fall back to the X\n    // ratio if only one was supplied.\n    const rx = cached.ratios[0] || 1;\n    const ry = cached.ratios[1] || cached.ratios[0] || 1;\n    const ox = cached.originX ?? 0;\n    const oy = cached.originY ?? 0;\n    // The stroke accumulator is in matrix (viewport-pixel) coordinates tied to the readback's\n    // ratio/origin. If the view changed (zoom/pan) since the stroke was built, those coords no\n    // longer mean the same thing — re-committing would rescale the region by the zoom factor\n    // (jit-ui#102). Drop the stale stroke so a fresh one is built at the current view.\n    const sig = `${rx},${ry},${ox},${oy}`;\n    if (this.stroke && this.strokeRatioSig !== sig) {\n      this.stroke = null;\n      this.strokeRegionId = null;\n    }\n    this.strokeRatioSig = sig;\n    const matrixX = (dataX - ox) / rx;\n    const matrixY = (dataY - oy) / ry;\n    if (matrixX < 0 || matrixX >= cached.width) return;\n    if (matrixY < 0 || matrixY >= cached.height) return;\n\n    const frameIdx = this.host.getActiveFrameIndex();\n    const frame = cached.frames[frameIdx] ?? cached.frames[0];\n\n    const wandImage: WandImage = {\n      data: frame,\n      width: cached.width,\n      height: cached.height,\n      isGrayscale: cached.isGrayscale,\n    };\n    // Shift = erase (subtract pixels from an existing region).\n    // Cmd/Ctrl alone = simple flood fill (no smoothing/threshold).\n    const erase = e.shiftKey;\n    const opts: WandOptions = {\n      ...this.options,\n      simpleMode: this.options.simpleMode || ((e.metaKey || e.ctrlKey) && !erase),\n    };\n\n    // If this is the first tick of a new drag and the click is NOT inside the\n    // current accumulator and NOT inside any existing path-shape, drop the old\n    // stroke so a brand-new region starts here. Without this, the accumulator\n    // bbox grows to span both areas and `maskToPolygon` keeps only the largest\n    // connected blob — making the new click appear to do nothing.\n    if (isStart && !erase && this.stroke && !this.pointInStroke(matrixX, matrixY)) {\n      // Will fall through to tryAdoptShapeAt below; if that also misses, a\n      // fresh stroke is created from the patch.\n      this.stroke = null;\n      this.strokeRegionId = null;\n    }\n\n    const patch = this.wandService.computePatchMask(wandImage, matrixX, matrixY, opts);\n    if (!patch) return;\n\n    const W = patch.size;\n    const half = (W - 1) / 2;\n    const px0 = Math.round(matrixX) - half;\n    const py0 = Math.round(matrixY) - half;\n    const px1 = px0 + W;\n    const py1 = py0 + W;\n\n    // If there's no active wand region, see if the click landed on an\n    // existing path-shape — adopt it so this stroke extends (or erases\n    // from) it instead of creating a new region.\n    if (!this.stroke) {\n      this.tryAdoptShapeAt(regions, matrixX, matrixY, rx, ry, cached);\n    }\n\n    // Erasing requires an existing region. Shift-clicking empty space is a\n    // no-op — we don't create a region only to immediately delete from it.\n    if (erase && !this.stroke) return;\n\n    // Grow the region's accumulated mask only when adding. Erasing never\n    // expands the region beyond its current bbox.\n    if (!this.stroke) {\n      const bx = Math.max(0, px0);\n      const by = Math.max(0, py0);\n      const bx1 = Math.min(cached.width, px1);\n      const by1 = Math.min(cached.height, py1);\n      const bw = Math.max(0, bx1 - bx);\n      const bh = Math.max(0, by1 - by);\n      if (bw === 0 || bh === 0) return;\n      this.stroke = { bx, by, bw, bh, mask: new Uint8Array(bw * bh) };\n    } else if (!erase) {\n      // Don't clamp the accumulator to the viewport: an adopted region may extend off-screen, and\n      // clamping here would discard its off-screen part when the stroke grows (jit-ui#102).\n      const bx = Math.min(this.stroke.bx, px0);\n      const by = Math.min(this.stroke.by, py0);\n      const bx1 = Math.max(this.stroke.bx + this.stroke.bw, px1);\n      const by1 = Math.max(this.stroke.by + this.stroke.bh, py1);\n      const bw = bx1 - bx;\n      const bh = by1 - by;\n      if (bw !== this.stroke.bw || bh !== this.stroke.bh || bx !== this.stroke.bx || by !== this.stroke.by) {\n        // Reallocate the larger mask and copy the previous mask into it.\n        const next = new Uint8Array(bw * bh);\n        const dx = this.stroke.bx - bx;\n        const dy = this.stroke.by - by;\n        for (let row = 0; row < this.stroke.bh; row++) {\n          const srcOff = row * this.stroke.bw;\n          const dstOff = (row + dy) * bw + dx;\n          next.set(this.stroke.mask.subarray(srcOff, srcOff + this.stroke.bw), dstOff);\n        }\n        this.stroke = { bx, by, bw, bh, mask: next };\n      }\n    }\n\n    // Apply the patch: OR (add) or AND-NOT (erase).\n    const stroke = this.stroke;\n    for (let py = 0; py < W; py++) {\n      const iy = py0 + py;\n      const my = iy - stroke.by;\n      if (my < 0 || my >= stroke.bh) continue;\n      const srcRow = py * W;\n      const dstRow = my * stroke.bw;\n      for (let px = 0; px < W; px++) {\n        if (!patch.mask[srcRow + px]) continue;\n        const ix = px0 + px;\n        const mx = ix - stroke.bx;\n        if (mx < 0 || mx >= stroke.bw) continue;\n        if (erase) stroke.mask[dstRow + mx] = 0;\n        else stroke.mask[dstRow + mx] = 1;\n      }\n    }\n\n    if (!erase) {\n      // If the grown stroke now overlaps another path-shape, fold those\n      // shapes into this one and drop them — matching QuPath's\n      // merge-on-touch behaviour.\n      this.mergeOverlappingShapes(regions, rx, ry, cached);\n    }\n\n    // Trace the union boundary in image-pixel coords.\n    const stroke2 = this.stroke!;\n    const poly = this.wandService.maskToPolygon(\n      stroke2.mask,\n      stroke2.bw,\n      stroke2.bh,\n      cached.width,\n      cached.height,\n      stroke2.bx,\n      stroke2.by,\n    );\n\n    if (!poly) {\n      // Erased to nothing — remove the shape entirely.\n      if (erase) this.dropActiveShape(regions);\n      return;\n    }\n\n    // Convert from matrix coords back to plot data coords.\n    const xPlot = poly.xpoints.map((x) => ox + x * rx);\n    const yPlot = poly.ypoints.map((y) => oy + y * ry);\n\n    this.commitStroke(regions, xPlot, yPlot);\n  }\n\n  /** True if (matrixX, matrixY) lies inside the current stroke accumulator. */\n  private pointInStroke(matrixX: number, matrixY: number): boolean {\n    const s = this.stroke;\n    if (!s) return false;\n    const mx = Math.floor(matrixX) - s.bx;\n    const my = Math.floor(matrixY) - s.by;\n    if (mx < 0 || my < 0 || mx >= s.bw || my >= s.bh) return false;\n    return s.mask[my * s.bw + mx] === 1;\n  }\n\n  /**\n   * Remove the region referenced by `strokeRegionId` from the region list and\n   * reset the active stroke — used when an erase stroke deletes every pixel.\n   */\n  private dropActiveShape(regions: Region[]) {\n    if (this.strokeRegionId != null) {\n      const idx = regions.findIndex((r) => r.id === this.strokeRegionId);\n      if (idx >= 0) {\n        regions.splice(idx, 1);\n        this.host.setRegions(regions);\n      }\n    }\n    this.stroke = null;\n    this.strokeRegionId = null;\n  }\n\n  /**\n   * Whether a region can be faithfully rasterized into the wand stroke at the current view\n   * resolution (rx/ry = data units per matrix pixel). Editing rasterizes the region to the\n   * viewport grid and re-traces it, so a region whose matrix-space bbox exceeds the rasterizer's\n   * cap would be clipped/down-quantized and come back rescaled/corrupted (jit-ui#102) — e.g. a\n   * whole-slide annotation while zoomed out. Skip adopt/merge for those: leave them untouched and\n   * only edit them near native zoom.\n   */\n  private fitsForEdit(\n    verts: { xpoints: number[]; ypoints: number[] },\n    rx: number,\n    ry: number,\n  ): boolean {\n    const xs = verts.xpoints;\n    const ys = verts.ypoints;\n    let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;\n    for (let i = 0; i < xs.length; i++) {\n      if (xs[i] < minX) minX = xs[i];\n      if (xs[i] > maxX) maxX = xs[i];\n      if (ys[i] < minY) minY = ys[i];\n      if (ys[i] > maxY) maxY = ys[i];\n    }\n    const w = (maxX - minX) / (rx || 1);\n    const h = (maxY - minY) / (ry || 1);\n    return w > 0 && h > 0 && w * h <= 4096 * 4096;\n  }\n\n  /** A region's closed-polygon vertices (image/data coords), or null when it\n   *  isn't a fillable closed polygon (rectangles, open polylines). */\n  private regionVerts(\n    region: Region,\n  ): { xpoints: number[]; ypoints: number[]; holes?: number[][][] } | null {\n    const b = region?.bounds;\n    if (b instanceof Polygon && b.closed !== false && b.xpoints.length >= 3) {\n      return { xpoints: b.xpoints, ypoints: b.ypoints, holes: b.holes };\n    }\n    return null;\n  }\n\n  /** Convert a region's hole rings from image/data coords into matrix coords so\n   *  they line up with the stroke accumulator (jit-ui#85). */\n  private holesToMatrix(\n    holes: number[][][] | undefined, ox: number, oy: number, rx: number, ry: number,\n  ): number[][][] | undefined {\n    return holes?.map((ring) => ring.map(([x, y]) => [(x - ox) / rx, (y - oy) / ry]));\n  }\n\n  /**\n   * If (matrixX, matrixY) falls inside an existing region, rasterize it into\n   * the wand stroke accumulator so subsequent wand input extends it rather than\n   * starting a new region.\n   */\n  private tryAdoptShapeAt(\n    regions: Region[],\n    matrixX: number,\n    matrixY: number,\n    rx: number,\n    ry: number,\n    cached: CachedImageData,\n  ): boolean {\n    if (!regions || regions.length === 0) return false;\n\n    // Most-recently-added regions are on top — check them first.\n    for (let i = regions.length - 1; i >= 0; i--) {\n      const verts = this.regionVerts(regions[i]);\n      if (!verts) continue;\n      // Too large to rasterize at this zoom → don't adopt it (editing would rescale/corrupt it).\n      if (!this.fitsForEdit(verts, rx, ry)) continue;\n\n      const ox = cached.originX ?? 0;\n      const oy = cached.originY ?? 0;\n      const xs = verts.xpoints.map((x) => (x - ox) / rx);\n      const ys = verts.ypoints.map((y) => (y - oy) / ry);\n      const holes = this.holesToMatrix(verts.holes, ox, oy, rx, ry);\n\n      // Clicking inside a hole must NOT adopt the donut (it's empty there).\n      if (!this.wandService.pointInPolygonWithHoles(matrixX, matrixY, xs, ys, holes)) continue;\n\n      const raster = this.wandService.rasterizePolygon(xs, ys, cached.width, cached.height, holes);\n      if (!raster) continue;\n\n      this.stroke = raster;\n      this.strokeRegionId = regions[i].id ?? null;\n      return true;\n    }\n    return false;\n  }\n\n  /**\n   * Iterate every region; if its rasterized mask overlaps the wand stroke mask\n   * by at least one pixel, OR it into the stroke and remove it from the list.\n   * Called every tick so chained merges resolve. If the wand has no region id\n   * yet, the merged region's id is adopted so the merged region replaces it.\n   */\n  private mergeOverlappingShapes(regions: Region[], rx: number, ry: number, cached: CachedImageData) {\n    if (!this.stroke) return;\n    let didMerge = true;\n    while (didMerge) {\n      didMerge = false;\n      for (let i = regions.length - 1; i >= 0; i--) {\n        const region = regions[i];\n        if (region.id != null && region.id === this.strokeRegionId) continue;\n\n        const verts = this.regionVerts(region);\n        if (!verts) continue;\n        // Too large to rasterize at this zoom → don't merge it (would rescale/corrupt it).\n        if (!this.fitsForEdit(verts, rx, ry)) continue;\n\n        const ox = cached.originX ?? 0;\n        const oy = cached.originY ?? 0;\n        const xs = verts.xpoints.map((x) => (x - ox) / rx);\n        const ys = verts.ypoints.map((y) => (y - oy) / ry);\n\n        // Quick bbox reject before rasterizing.\n        let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;\n        for (let k = 0; k < xs.length; k++) {\n          if (xs[k] < minX) minX = xs[k];\n          if (xs[k] > maxX) maxX = xs[k];\n          if (ys[k] < minY) minY = ys[k];\n          if (ys[k] > maxY) maxY = ys[k];\n        }\n        const wx0 = this.stroke.bx, wy0 = this.stroke.by;\n        const wx1 = wx0 + this.stroke.bw, wy1 = wy0 + this.stroke.bh;\n        if (maxX < wx0 || minX > wx1 || maxY < wy0 || minY > wy1) continue;\n\n        const holes = this.holesToMatrix(verts.holes, ox, oy, rx, ry);\n        const raster = this.wandService.rasterizePolygon(xs, ys, cached.width, cached.height, holes);\n        if (!raster) continue;\n\n        if (!masksOverlap(this.stroke, raster)) continue;\n\n        this.stroke = unionMasks(this.stroke, raster);\n\n        if (this.strokeRegionId == null) {\n          this.strokeRegionId = region.id ?? null;\n        }\n        regions.splice(i, 1);\n        didMerge = true;\n        break;\n      }\n    }\n  }\n\n  /**\n   * Commit the in-progress polygon as a region — a new region on the first tick\n   * of a stroke, or an in-place replacement of the active region on later ticks\n   * — then ask the host to render. The store mints an id on the first commit,\n   * which we adopt so subsequent ticks replace the same region.\n   */\n  private commitStroke(regions: Region[], xPlot: number[], yPlot: number[]) {\n    if (xPlot.length < 3) return;\n\n    const existing = this.strokeRegionId != null\n      ? regions.find((r) => r.id === this.strokeRegionId) : null;\n\n    const poly = new Polygon();\n    poly.npoints = xPlot.length;\n    poly.xpoints = xPlot;\n    poly.ypoints = yPlot;\n    poly.coordinates = xPlot.map((x, i) => [x, yPlot[i]]);\n    poly.closed = true;\n\n    const region = new Region();\n    region.bounds = poly;\n    region.color = this.host.getShapeColor();\n    if (existing) {\n      // Preserve identity + class label across the stroke's drag ticks.\n      region.id = existing.id;\n      region.name = existing.name;\n    }\n    // Default class/annotation name, matching the overlay-drawn regions and the\n    // Region Editor's \"Add\" actions so a wand region isn't left unlabeled.\n    region.label = existing?.label ?? 'Region';\n\n    if (this.strokeRegionId == null) {\n      regions.push(region);\n    } else {\n      const idx = regions.findIndex((r) => r.id === this.strokeRegionId);\n      if (idx >= 0) regions[idx] = region;\n      else regions.push(region);\n    }\n\n    this.host.setRegions(regions);\n    // The store assigns an id on the first commit — adopt it.\n    this.strokeRegionId = region.id ?? this.strokeRegionId;\n  }\n}\n"]}