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

package/esm2022/lib/toolbar/tool-kit/canvas-tool.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/toolbar/tool-kit/frame-pixels.mjs

@@ -0,0 +1,108 @@
+/**
+ * The pixel frames a backend hands the canvas tools (`CachedImageData.frames`),
+ * and the one accessor every tool reads them through (wand patch extraction,
+ * SAM encoder input, Cellpose crop).
+ *
+ * A frame is either
+ * - **nested** — `[y][x]` rows of grayscale values or `[r, g, b]` tuples, which
+ *   is what the Plotly backend caches (its frames double as the heatmap data and
+ *   may hold raw, non-8-bit intensities), or
+ * - **packed** — a row-major RGBA `Uint8ClampedArray`, which is what a canvas or
+ *   GPU readback already is. OpenSeadragon and napari-js hand theirs over as-is
+ *   instead of building one JS array per pixel (RT-17, OSD-PLOTLY-12,
+ *   NAPARI-SVC-23).
+ */
+/** Whether `frame` is the packed RGBA form. */
+export function isPackedFrame(frame) {
+    return !!frame && !Array.isArray(frame) && frame.data instanceof Uint8ClampedArray;
+}
+/** Wrap a row-major RGBA readback as a frame, without copying it. */
+export function packedFrame(data, width, height) {
+    return { data, width, height, channels: 4 };
+}
+/** The accessor for `frame`; `isGrayscale` describes a nested frame's cells. */
+export function framePixels(frame, isGrayscale) {
+    if (isPackedFrame(frame))
+        return packedPixels(frame);
+    return isGrayscale
+        ? nestedGrayPixels(frame)
+        : nestedRgbPixels(frame);
+}
+function packedPixels(frame) {
+    const { data, width, height } = frame;
+    return {
+        rgb(x, y, out) {
+            if (x < 0 || y < 0 || x >= width || y >= height)
+                return false;
+            const s = (y * width + x) * 4;
+            out[0] = data[s];
+            out[1] = data[s + 1];
+            out[2] = data[s + 2];
+            return true;
+        },
+        rgbaRow(y, x0, w, dst, o) {
+            const inRow = y >= 0 && y < height;
+            for (let x = 0; x < w; x++, o += 4) {
+                const ix = x0 + x;
+                if (inRow && ix >= 0 && ix < width) {
+                    const s = (y * width + ix) * 4;
+                    dst[o] = data[s];
+                    dst[o + 1] = data[s + 1];
+                    dst[o + 2] = data[s + 2];
+                }
+                dst[o + 3] = 255;
+            }
+        },
+    };
+}
+function nestedGrayPixels(frame) {
+    return {
+        rgb(x, y, out) {
+            const v = frame?.[y]?.[x];
+            if (v == null)
+                return false;
+            out[0] = v;
+            out[1] = v;
+            out[2] = v;
+            return true;
+        },
+        rgbaRow(y, x0, w, dst, o) {
+            const row = frame?.[y];
+            for (let x = 0; x < w; x++, o += 4) {
+                const v = row?.[x0 + x];
+                if (v != null) {
+                    dst[o] = v;
+                    dst[o + 1] = v;
+                    dst[o + 2] = v;
+                }
+                dst[o + 3] = 255;
+            }
+        },
+    };
+}
+function nestedRgbPixels(frame) {
+    return {
+        rgb(x, y, out) {
+            const t = frame?.[y]?.[x];
+            if (t == null)
+                return false;
+            out[0] = t[0];
+            out[1] = t[1];
+            out[2] = t[2];
+            return true;
+        },
+        rgbaRow(y, x0, w, dst, o) {
+            const row = frame?.[y];
+            for (let x = 0; x < w; x++, o += 4) {
+                const t = row?.[x0 + x];
+                if (t != null) {
+                    dst[o] = t[0];
+                    dst[o + 1] = t[1];
+                    dst[o + 2] = t[2];
+                }
+                dst[o + 3] = 255;
+            }
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"frame-pixels.js","sourceRoot":"","sources":["../../../../../src/lib/toolbar/tool-kit/frame-pixels.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The pixel frames a backend hands the canvas tools (`CachedImageData.frames`),\n * and the one accessor every tool reads them through (wand patch extraction,\n * SAM encoder input, Cellpose crop).\n *\n * A frame is either\n * - **nested** — `[y][x]` rows of grayscale values or `[r, g, b]` tuples, which\n *   is what the Plotly backend caches (its frames double as the heatmap data and\n *   may hold raw, non-8-bit intensities), or\n * - **packed** — a row-major RGBA `Uint8ClampedArray`, which is what a canvas or\n *   GPU readback already is. OpenSeadragon and napari-js hand theirs over as-is\n *   instead of building one JS array per pixel (RT-17, OSD-PLOTLY-12,\n *   NAPARI-SVC-23).\n */\n\n/** A row-major RGBA readback (alpha is ignored). */\nexport interface PackedFrame {\n  readonly data: Uint8ClampedArray;\n  readonly width: number;\n  readonly height: number;\n  readonly channels: 4;\n}\n\n/** `[y][x]` grayscale values, or `[y][x]` `[r, g, b]` tuples. */\nexport type NestedFrame = number[][] | number[][][];\n\n/** One frame of `CachedImageData.frames`. */\nexport type CachedFrame = NestedFrame | PackedFrame;\n\n/** Whether `frame` is the packed RGBA form. */\nexport function isPackedFrame(frame: unknown): frame is PackedFrame {\n  return !!frame && !Array.isArray(frame) && (frame as PackedFrame).data instanceof Uint8ClampedArray;\n}\n\n/** Wrap a row-major RGBA readback as a frame, without copying it. */\nexport function packedFrame(data: Uint8ClampedArray, width: number, height: number): PackedFrame {\n  return { data, width, height, channels: 4 };\n}\n\n/** Reads one frame's pixels whatever its form. */\nexport interface FramePixels {\n  /**\n   * Pixel (x, y) as RGB in `out[0..2]` (a grayscale value is replicated, and\n   * kept unclamped). False — `out` untouched — outside the frame or for a\n   * missing pixel. A packed frame always reads as RGB.\n   */\n  rgb(x: number, y: number, out: number[]): boolean;\n  /**\n   * `w` pixels of row `y` from column `x0`, as opaque RGBA into `dst` from\n   * offset `o`. Missing pixels become opaque black.\n   */\n  rgbaRow(y: number, x0: number, w: number, dst: Uint8ClampedArray, o: number): void;\n}\n\n/** The accessor for `frame`; `isGrayscale` describes a nested frame's cells. */\nexport function framePixels(frame: CachedFrame | undefined, isGrayscale: boolean): FramePixels {\n  if (isPackedFrame(frame)) return packedPixels(frame);\n  return isGrayscale\n    ? nestedGrayPixels(frame as number[][] | undefined)\n    : nestedRgbPixels(frame as number[][][] | undefined);\n}\n\nfunction packedPixels(frame: PackedFrame): FramePixels {\n  const { data, width, height } = frame;\n  return {\n    rgb(x, y, out) {\n      if (x < 0 || y < 0 || x >= width || y >= height) return false;\n      const s = (y * width + x) * 4;\n      out[0] = data[s];\n      out[1] = data[s + 1];\n      out[2] = data[s + 2];\n      return true;\n    },\n    rgbaRow(y, x0, w, dst, o) {\n      const inRow = y >= 0 && y < height;\n      for (let x = 0; x < w; x++, o += 4) {\n        const ix = x0 + x;\n        if (inRow && ix >= 0 && ix < width) {\n          const s = (y * width + ix) * 4;\n          dst[o] = data[s];\n          dst[o + 1] = data[s + 1];\n          dst[o + 2] = data[s + 2];\n        }\n        dst[o + 3] = 255;\n      }\n    },\n  };\n}\n\nfunction nestedGrayPixels(frame: number[][] | undefined): FramePixels {\n  return {\n    rgb(x, y, out) {\n      const v = frame?.[y]?.[x];\n      if (v == null) return false;\n      out[0] = v;\n      out[1] = v;\n      out[2] = v;\n      return true;\n    },\n    rgbaRow(y, x0, w, dst, o) {\n      const row = frame?.[y];\n      for (let x = 0; x < w; x++, o += 4) {\n        const v = row?.[x0 + x];\n        if (v != null) {\n          dst[o] = v;\n          dst[o + 1] = v;\n          dst[o + 2] = v;\n        }\n        dst[o + 3] = 255;\n      }\n    },\n  };\n}\n\nfunction nestedRgbPixels(frame: number[][][] | undefined): FramePixels {\n  return {\n    rgb(x, y, out) {\n      const t = frame?.[y]?.[x];\n      if (t == null) return false;\n      out[0] = t[0];\n      out[1] = t[1];\n      out[2] = t[2];\n      return true;\n    },\n    rgbaRow(y, x0, w, dst, o) {\n      const row = frame?.[y];\n      for (let x = 0; x < w; x++, o += 4) {\n        const t = row?.[x0 + x];\n        if (t != null) {\n          dst[o] = t[0];\n          dst[o + 1] = t[1];\n          dst[o + 2] = t[2];\n        }\n        dst[o + 3] = 255;\n      }\n    },\n  };\n}\n"]}

package/esm2022/lib/toolbar/tool-kit/mask-stroke-editor.mjs

@@ -0,0 +1,306 @@
+import { MAX_RASTER_PIXELS, masksOverlap, rasterizePolygon, unionMasks } from '../../geometry/raster';
+import { pointInPolygonWithHoles, ringBounds } from '../../geometry/ring';
+import { maskToPolygons } from '../../geometry/contour';
+import { Polygon } from '../../models/region';
+import { makePolygon, replaceBounds } from '../../models/polygon-factory';
+import { MatrixFrame } from './matrix-frame';
+/**
+ * The bbox-relative mask accumulator shared by the wand and the brush: adopt a
+ * region under the cursor, grow the mask, fold touching regions in, then trace
+ * every connected piece (with holes) and commit them.
+ *
+ * The accumulator survives mouseup so the next stroke extends the same region
+ * (QuPath behaviour). It is dropped when the view changes (its matrix coords
+ * are tied to the readback frame, jit-ui#102) and when its regions changed
+ * outside the tool (undo, Region Editor, segmentation, eraser — RT-2).
+ *
+ * Commits never mutate a store instance and never drop metadata: an edited
+ * region is a copy of the original with new bounds (RT-5). An erase that cuts a
+ * region in two keeps both pieces and a donut keeps its holes (RT-3).
+ */
+export class MaskStrokeEditor {
+    constructor() {
+        /** The accumulated mask, in matrix coords of {@link frameSig}'s frame. */
+        this.stroke = null;
+        /** Id of the region the stroke edits (null = a fresh region); for a split,
+         *  the largest piece. */
+        this.regionId = null;
+        /** Ids of the extra pieces an erase split off, reused across ticks so they
+         *  keep stable identities. */
+        this.extraIds = [];
+        /** The bounds objects the stroke last committed or adopted, one per region it
+         *  owns. Once any of them is no longer held by a region, the stroke is stale. */
+        this.lastCommitted = [];
+        /** The region the stroke adopted (or first merged in): its metadata carries
+         *  over to the committed pieces even after a merge removed it from the list. */
+        this.template = null;
+        this.frameSig = null;
+    }
+    /** Drop the stroke and everything tied to it. */
+    reset() {
+        this.stroke = null;
+        this.regionId = null;
+        this.extraIds = [];
+        this.lastCommitted = [];
+        this.template = null;
+    }
+    /**
+     * Start a wand or brush tick at pointer `e`: read the host's readback and
+     * regions, drop a stale stroke ({@link invalidateIfStale}) or one from another
+     * view ({@link syncFrame}), and map the pointer into the readback's matrix.
+     * Null when there is no readback or ready transform, or the pointer is off it.
+     */
+    beginTick(host, e) {
+        const cached = host.getCachedImageData();
+        if (!cached || cached.frames.length === 0)
+            return null;
+        const regions = host.getRegions();
+        this.invalidateIfStale(regions);
+        const transform = host.getCoordinateTransform();
+        if (!transform.isReady())
+            return null;
+        const { x: dataX, y: dataY } = transform.clientToData(e.clientX, e.clientY);
+        if (!Number.isFinite(dataX) || !Number.isFinite(dataY))
+            return null;
+        const frame = MatrixFrame.from(cached);
+        this.syncFrame(frame);
+        const mx = frame.toMatrixX(dataX);
+        const my = frame.toMatrixY(dataY);
+        if (mx < 0 || mx >= cached.width)
+            return null;
+        if (my < 0 || my >= cached.height)
+            return null;
+        return { cached, regions, frame, mx, my };
+    }
+    /** Drop a stroke whose regions were undone, deleted or replaced outside the
+     *  tool: re-committing it would bring the old shapes back (RT-2). */
+    invalidateIfStale(regions) {
+        if (this.stroke && this.lastCommitted.some((b) => !regions.some((r) => r.bounds === b))) {
+            this.reset();
+        }
+    }
+    /** Drop a stroke built at a different view (zoom/pan): re-committing it would
+     *  rescale the region by the zoom factor (jit-ui#102). */
+    syncFrame(frame) {
+        if (this.stroke && this.frameSig !== frame.sig)
+            this.reset();
+        this.frameSig = frame.sig;
+    }
+    /** True if matrix point (mx, my) is painted in the stroke. */
+    contains(mx, my) {
+        const s = this.stroke;
+        if (!s)
+            return false;
+        const x = Math.floor(mx) - s.bx;
+        const y = Math.floor(my) - s.by;
+        if (x < 0 || y < 0 || x >= s.bw || y >= s.bh)
+            return false;
+        return s.mask[y * s.bw + x] === 1;
+    }
+    /**
+     * Make the stroke's bbox cover [x0,x1)×[y0,y1) (matrix px), creating an empty
+     * stroke or growing (and copying) the existing one. False for an empty box.
+     */
+    ensureCovers(x0, y0, x1, y1) {
+        if (x1 - x0 <= 0 || y1 - y0 <= 0)
+            return false;
+        const s = this.stroke;
+        if (!s) {
+            this.stroke = { bx: x0, by: y0, bw: x1 - x0, bh: y1 - y0, mask: new Uint8Array((x1 - x0) * (y1 - y0)) };
+            return true;
+        }
+        const bx = Math.min(s.bx, x0);
+        const by = Math.min(s.by, y0);
+        const bw = Math.max(s.bx + s.bw, x1) - bx;
+        const bh = Math.max(s.by + s.bh, y1) - by;
+        if (bw === s.bw && bh === s.bh && bx === s.bx && by === s.by)
+            return true;
+        const next = new Uint8Array(bw * bh);
+        const dx = s.bx - bx;
+        const dy = s.by - by;
+        for (let row = 0; row < s.bh; row++) {
+            const src = row * s.bw;
+            next.set(s.mask.subarray(src, src + s.bw), (row + dy) * bw + dx);
+        }
+        this.stroke = { bx, by, bw, bh, mask: next };
+        return true;
+    }
+    /**
+     * If matrix point (mx, my) lies inside a region `accept`s (topmost first, not
+     * in a hole), rasterize it into the stroke so this stroke extends it.
+     */
+    adoptAt(regions, mx, my, frame, image, accept = () => true) {
+        for (let i = regions.length - 1; i >= 0; i--) {
+            const region = regions[i];
+            if (!accept(region))
+                continue;
+            const m = this.editableRing(region, frame);
+            if (!m)
+                continue;
+            // Clicking inside a hole must NOT adopt the donut (it's empty there).
+            if (!pointInPolygonWithHoles(mx, my, m.xs, m.ys, m.holes))
+                continue;
+            const raster = rasterizePolygon(m.xs, m.ys, image.width, image.height, m.holes);
+            if (!raster)
+                continue;
+            this.stroke = raster;
+            this.regionId = region.id ?? null;
+            this.template = region;
+            this.extraIds = [];
+            this.lastCommitted = [region.bounds];
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Fold every region `accept`s whose raster overlaps the stroke into it and
+     * remove it from `regions` (merge-on-touch). Repeats until nothing changes so
+     * chained merges resolve. With no region yet, the first merged region's
+     * identity and metadata are adopted.
+     */
+    mergeTouching(regions, frame, image, accept = () => true) {
+        let merged = true;
+        while (merged && this.stroke) {
+            merged = false;
+            for (let i = regions.length - 1; i >= 0; i--) {
+                const region = regions[i];
+                if (region.id != null && region.id === this.regionId)
+                    continue;
+                if (!accept(region))
+                    continue;
+                const m = this.editableRing(region, frame);
+                if (!m)
+                    continue;
+                // Quick bbox reject before rasterizing.
+                const b = ringBounds(m.xs, m.ys);
+                const s = this.stroke;
+                if (b.maxX < s.bx || b.minX > s.bx + s.bw || b.maxY < s.by || b.minY > s.by + s.bh)
+                    continue;
+                const raster = rasterizePolygon(m.xs, m.ys, image.width, image.height, m.holes);
+                if (!raster || !masksOverlap(s, raster))
+                    continue;
+                this.stroke = unionMasks(s, raster);
+                if (this.regionId == null) {
+                    this.regionId = region.id ?? null;
+                    this.template = region;
+                }
+                regions.splice(i, 1);
+                merged = true;
+                break;
+            }
+        }
+    }
+    /**
+     * Trace every connected piece of the stroke (holes included) and commit them:
+     * the largest keeps the stroke's region, further pieces (from an erase that
+     * split it) become their own regions with stable ids across ticks. An erase
+     * that leaves nothing removes the stroke's regions.
+     */
+    commit(regions, frame, host, opts) {
+        const s = this.stroke;
+        if (!s)
+            return;
+        const pieces = maskToPolygons(s.mask, s.bw, s.bh, s.bx, s.by)
+            .filter((p) => p.xpoints.length >= 3)
+            .map((p) => {
+            const ring = frame.ringToData(p.xpoints, p.ypoints);
+            return makePolygon(ring.xs, ring.ys, { holes: frame.holesToData(p.holes) });
+        });
+        if (pieces.length === 0) {
+            if (opts.erase)
+                this.dropActive(regions, host);
+            return;
+        }
+        // Drop previously tracked extras that no longer have a matching piece (the
+        // piece count shrank, e.g. an add stroke bridged the gap).
+        const prevExtras = this.extraIds;
+        for (let k = pieces.length - 1; k < prevExtras.length; k++) {
+            const idx = regions.findIndex((r) => r.id === prevExtras[k]);
+            if (idx >= 0)
+                regions.splice(idx, 1);
+        }
+        const owner = this.owner(regions, this.regionId);
+        const primary = this.upsert(regions, owner, pieces[0], opts);
+        const extras = [];
+        for (let i = 1; i < pieces.length; i++) {
+            const prev = this.owner(regions, prevExtras[i - 1] ?? null);
+            // A new split piece inherits the edited region's class and metadata.
+            extras.push(prev
+                ? this.upsert(regions, prev, pieces[i], opts)
+                : this.insert(regions, owner
+                    ? replaceBounds(owner, pieces[i], {
+                        ...this.patchFor(owner, opts),
+                        id: undefined,
+                        name: undefined,
+                    })
+                    : opts.newRegion(pieces[i])));
+        }
+        host.setRegions(regions);
+        // Ids are minted during setRegions — read them back for the next tick.
+        this.regionId = primary.id ?? this.regionId;
+        this.template = primary;
+        this.extraIds = extras.map((r) => r.id).filter((id) => id != null);
+        this.lastCommitted = [primary, ...extras].map((r) => r.bounds);
+    }
+    /** Remove the stroke's region(s) and reset — an erase deleted every pixel. */
+    dropActive(regions, host) {
+        const ids = [this.regionId, ...this.extraIds].filter((id) => id != null);
+        let changed = false;
+        for (const id of ids) {
+            const idx = regions.findIndex((r) => r.id === id);
+            if (idx >= 0) {
+                regions.splice(idx, 1);
+                changed = true;
+            }
+        }
+        if (changed)
+            host.setRegions(regions);
+        this.reset();
+    }
+    // ── internals ────────────────────────────────────────────────────────
+    /** The region with `id` in `regions`, or the adopted/merged template when a
+     *  merge already removed it from the list. */
+    owner(regions, id) {
+        if (id == null)
+            return null;
+        return regions.find((r) => r.id === id) ?? (this.template?.id === id ? this.template : null);
+    }
+    /** Replace `existing` in place (or append it if a merge removed it). */
+    upsert(regions, existing, bounds, opts) {
+        if (!existing)
+            return this.insert(regions, opts.newRegion(bounds));
+        const region = replaceBounds(existing, bounds, this.patchFor(existing, opts));
+        const idx = regions.findIndex((r) => r.id === existing.id);
+        if (idx >= 0)
+            regions[idx] = region;
+        else
+            regions.push(region);
+        return region;
+    }
+    /** The fields an edit sets on `existing`: the tool's patch, plus a default label. */
+    patchFor(existing, opts) {
+        return existing.label == null ? { label: opts.defaultLabel, ...opts.editPatch } : { ...opts.editPatch };
+    }
+    insert(regions, region) {
+        regions.push(region);
+        return region;
+    }
+    /**
+     * A region's closed ring and holes in matrix coords, or null when it can't be
+     * edited as a mask: not a closed polygon (rectangles, polylines,
+     * multi-polygons), or too large to rasterize faithfully at this zoom — editing
+     * would clip or down-quantize it and bring it back rescaled (jit-ui#102).
+     */
+    editableRing(region, frame) {
+        const b = region?.bounds;
+        if (!(b instanceof Polygon) || b.closed === false || b.xpoints.length < 3)
+            return null;
+        const ring = frame.ringToMatrix(b.xpoints, b.ypoints);
+        const r = ringBounds(ring.xs, ring.ys);
+        const w = r.maxX - r.minX, h = r.maxY - r.minY;
+        if (!(w > 0 && h > 0 && w * h <= MAX_RASTER_PIXELS))
+            return null;
+        return { xs: ring.xs, ys: ring.ys, holes: frame.holesToMatrix(b.holes) };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mask-stroke-editor.js","sourceRoot":"","sources":["../../../../../src/lib/toolbar/tool-kit/mask-stroke-editor.ts"],"names":[],"mappings":"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","sourcesContent":["import { BBoxMask, MAX_RASTER_PIXELS, masksOverlap, rasterizePolygon, unionMasks } from '../../geometry/raster';\nimport { pointInPolygonWithHoles, ringBounds } from '../../geometry/ring';\nimport { maskToPolygons } from '../../geometry/contour';\nimport { IRegionDataHost } from '../../contracts/coordinate-transform.contract';\nimport { Polygon, Region } from '../../models/region';\nimport { makePolygon, replaceBounds } from '../../models/polygon-factory';\nimport { MatrixFrame } from './matrix-frame';\nimport type { CachedImageData, CanvasToolHost } from './canvas-tool';\n\n/** The readback size the stroke is painted against (the rasterizer's clip window). */\nexport interface StrokeImage {\n  width: number;\n  height: number;\n}\n\n/** Where a wand or brush pointer tick lands (see {@link MaskStrokeEditor.beginTick}). */\nexport interface StrokeTick {\n  /** The host's readback. */\n  cached: CachedImageData;\n  /** The current regions, mutated by the tick and committed once. */\n  regions: Region[];\n  /** The readback's data↔matrix frame. */\n  frame: MatrixFrame;\n  /** The matrix point under the pointer, inside the readback. */\n  mx: number;\n  my: number;\n}\n\n/** How a commit turns traced pieces into regions. */\nexport interface StrokeCommitOptions {\n  /** The tick erased (Shift): a stroke erased to nothing removes its regions. */\n  erase: boolean;\n  /** A brand-new region for a piece no existing region owns. */\n  newRegion(bounds: Polygon): Region;\n  /** Fields applied on top of an edited region (e.g. a painted class colour). */\n  editPatch?: Partial<Region>;\n  /** Class label given to an edited region that has none, so tool output is never unlabeled. */\n  defaultLabel: string;\n}\n\n/**\n * The bbox-relative mask accumulator shared by the wand and the brush: adopt a\n * region under the cursor, grow the mask, fold touching regions in, then trace\n * every connected piece (with holes) and commit them.\n *\n * The accumulator survives mouseup so the next stroke extends the same region\n * (QuPath behaviour). It is dropped when the view changes (its matrix coords\n * are tied to the readback frame, jit-ui#102) and when its regions changed\n * outside the tool (undo, Region Editor, segmentation, eraser — RT-2).\n *\n * Commits never mutate a store instance and never drop metadata: an edited\n * region is a copy of the original with new bounds (RT-5). An erase that cuts a\n * region in two keeps both pieces and a donut keeps its holes (RT-3).\n */\nexport class MaskStrokeEditor {\n  /** The accumulated mask, in matrix coords of {@link frameSig}'s frame. */\n  stroke: BBoxMask | null = null;\n  /** Id of the region the stroke edits (null = a fresh region); for a split,\n   *  the largest piece. */\n  regionId: number | null = null;\n  /** Ids of the extra pieces an erase split off, reused across ticks so they\n   *  keep stable identities. */\n  private extraIds: number[] = [];\n  /** The bounds objects the stroke last committed or adopted, one per region it\n   *  owns. Once any of them is no longer held by a region, the stroke is stale. */\n  private lastCommitted: Array<Region['bounds']> = [];\n  /** The region the stroke adopted (or first merged in): its metadata carries\n   *  over to the committed pieces even after a merge removed it from the list. */\n  private template: Region | null = null;\n  private frameSig: string | null = null;\n\n  /** Drop the stroke and everything tied to it. */\n  reset(): void {\n    this.stroke = null;\n    this.regionId = null;\n    this.extraIds = [];\n    this.lastCommitted = [];\n    this.template = null;\n  }\n\n  /**\n   * Start a wand or brush tick at pointer `e`: read the host's readback and\n   * regions, drop a stale stroke ({@link invalidateIfStale}) or one from another\n   * view ({@link syncFrame}), and map the pointer into the readback's matrix.\n   * Null when there is no readback or ready transform, or the pointer is off it.\n   */\n  beginTick(host: CanvasToolHost, e: { clientX: number; clientY: number }): StrokeTick | null {\n    const cached = host.getCachedImageData();\n    if (!cached || cached.frames.length === 0) return null;\n\n    const regions = host.getRegions();\n    this.invalidateIfStale(regions);\n\n    const transform = host.getCoordinateTransform();\n    if (!transform.isReady()) return null;\n    const { x: dataX, y: dataY } = transform.clientToData(e.clientX, e.clientY);\n    if (!Number.isFinite(dataX) || !Number.isFinite(dataY)) return null;\n\n    const frame = MatrixFrame.from(cached);\n    this.syncFrame(frame);\n    const mx = frame.toMatrixX(dataX);\n    const my = frame.toMatrixY(dataY);\n    if (mx < 0 || mx >= cached.width) return null;\n    if (my < 0 || my >= cached.height) return null;\n    return { cached, regions, frame, mx, my };\n  }\n\n  /** Drop a stroke whose regions were undone, deleted or replaced outside the\n   *  tool: re-committing it would bring the old shapes back (RT-2). */\n  invalidateIfStale(regions: Region[]): void {\n    if (this.stroke && this.lastCommitted.some((b) => !regions.some((r) => r.bounds === b))) {\n      this.reset();\n    }\n  }\n\n  /** Drop a stroke built at a different view (zoom/pan): re-committing it would\n   *  rescale the region by the zoom factor (jit-ui#102). */\n  syncFrame(frame: MatrixFrame): void {\n    if (this.stroke && this.frameSig !== frame.sig) this.reset();\n    this.frameSig = frame.sig;\n  }\n\n  /** True if matrix point (mx, my) is painted in the stroke. */\n  contains(mx: number, my: number): boolean {\n    const s = this.stroke;\n    if (!s) return false;\n    const x = Math.floor(mx) - s.bx;\n    const y = Math.floor(my) - s.by;\n    if (x < 0 || y < 0 || x >= s.bw || y >= s.bh) return false;\n    return s.mask[y * s.bw + x] === 1;\n  }\n\n  /**\n   * Make the stroke's bbox cover [x0,x1)×[y0,y1) (matrix px), creating an empty\n   * stroke or growing (and copying) the existing one. False for an empty box.\n   */\n  ensureCovers(x0: number, y0: number, x1: number, y1: number): boolean {\n    if (x1 - x0 <= 0 || y1 - y0 <= 0) return false;\n    const s = this.stroke;\n    if (!s) {\n      this.stroke = { bx: x0, by: y0, bw: x1 - x0, bh: y1 - y0, mask: new Uint8Array((x1 - x0) * (y1 - y0)) };\n      return true;\n    }\n    const bx = Math.min(s.bx, x0);\n    const by = Math.min(s.by, y0);\n    const bw = Math.max(s.bx + s.bw, x1) - bx;\n    const bh = Math.max(s.by + s.bh, y1) - by;\n    if (bw === s.bw && bh === s.bh && bx === s.bx && by === s.by) return true;\n    const next = new Uint8Array(bw * bh);\n    const dx = s.bx - bx;\n    const dy = s.by - by;\n    for (let row = 0; row < s.bh; row++) {\n      const src = row * s.bw;\n      next.set(s.mask.subarray(src, src + s.bw), (row + dy) * bw + dx);\n    }\n    this.stroke = { bx, by, bw, bh, mask: next };\n    return true;\n  }\n\n  /**\n   * If matrix point (mx, my) lies inside a region `accept`s (topmost first, not\n   * in a hole), rasterize it into the stroke so this stroke extends it.\n   */\n  adoptAt(\n    regions: Region[],\n    mx: number,\n    my: number,\n    frame: MatrixFrame,\n    image: StrokeImage,\n    accept: (r: Region) => boolean = () => true,\n  ): boolean {\n    for (let i = regions.length - 1; i >= 0; i--) {\n      const region = regions[i];\n      if (!accept(region)) continue;\n      const m = this.editableRing(region, frame);\n      if (!m) continue;\n      // Clicking inside a hole must NOT adopt the donut (it's empty there).\n      if (!pointInPolygonWithHoles(mx, my, m.xs, m.ys, m.holes)) continue;\n      const raster = rasterizePolygon(m.xs, m.ys, image.width, image.height, m.holes);\n      if (!raster) continue;\n      this.stroke = raster;\n      this.regionId = region.id ?? null;\n      this.template = region;\n      this.extraIds = [];\n      this.lastCommitted = [region.bounds];\n      return true;\n    }\n    return false;\n  }\n\n  /**\n   * Fold every region `accept`s whose raster overlaps the stroke into it and\n   * remove it from `regions` (merge-on-touch). Repeats until nothing changes so\n   * chained merges resolve. With no region yet, the first merged region's\n   * identity and metadata are adopted.\n   */\n  mergeTouching(\n    regions: Region[],\n    frame: MatrixFrame,\n    image: StrokeImage,\n    accept: (r: Region) => boolean = () => true,\n  ): void {\n    let merged = true;\n    while (merged && this.stroke) {\n      merged = false;\n      for (let i = regions.length - 1; i >= 0; i--) {\n        const region = regions[i];\n        if (region.id != null && region.id === this.regionId) continue;\n        if (!accept(region)) continue;\n        const m = this.editableRing(region, frame);\n        if (!m) continue;\n        // Quick bbox reject before rasterizing.\n        const b = ringBounds(m.xs, m.ys);\n        const s = this.stroke;\n        if (b.maxX < s.bx || b.minX > s.bx + s.bw || b.maxY < s.by || b.minY > s.by + s.bh) continue;\n        const raster = rasterizePolygon(m.xs, m.ys, image.width, image.height, m.holes);\n        if (!raster || !masksOverlap(s, raster)) continue;\n\n        this.stroke = unionMasks(s, raster);\n        if (this.regionId == null) {\n          this.regionId = region.id ?? null;\n          this.template = region;\n        }\n        regions.splice(i, 1);\n        merged = true;\n        break;\n      }\n    }\n  }\n\n  /**\n   * Trace every connected piece of the stroke (holes included) and commit them:\n   * the largest keeps the stroke's region, further pieces (from an erase that\n   * split it) become their own regions with stable ids across ticks. An erase\n   * that leaves nothing removes the stroke's regions.\n   */\n  commit(regions: Region[], frame: MatrixFrame, host: IRegionDataHost, opts: StrokeCommitOptions): void {\n    const s = this.stroke;\n    if (!s) return;\n    const pieces = maskToPolygons(s.mask, s.bw, s.bh, s.bx, s.by)\n      .filter((p) => p.xpoints.length >= 3)\n      .map((p) => {\n        const ring = frame.ringToData(p.xpoints, p.ypoints);\n        return makePolygon(ring.xs, ring.ys, { holes: frame.holesToData(p.holes) });\n      });\n    if (pieces.length === 0) {\n      if (opts.erase) this.dropActive(regions, host);\n      return;\n    }\n\n    // Drop previously tracked extras that no longer have a matching piece (the\n    // piece count shrank, e.g. an add stroke bridged the gap).\n    const prevExtras = this.extraIds;\n    for (let k = pieces.length - 1; k < prevExtras.length; k++) {\n      const idx = regions.findIndex((r) => r.id === prevExtras[k]);\n      if (idx >= 0) regions.splice(idx, 1);\n    }\n\n    const owner = this.owner(regions, this.regionId);\n    const primary = this.upsert(regions, owner, pieces[0], opts);\n    const extras: Region[] = [];\n    for (let i = 1; i < pieces.length; i++) {\n      const prev = this.owner(regions, prevExtras[i - 1] ?? null);\n      // A new split piece inherits the edited region's class and metadata.\n      extras.push(\n        prev\n          ? this.upsert(regions, prev, pieces[i], opts)\n          : this.insert(\n              regions,\n              owner\n                ? replaceBounds(owner, pieces[i], {\n                    ...this.patchFor(owner, opts),\n                    id: undefined,\n                    name: undefined,\n                  })\n                : opts.newRegion(pieces[i]),\n            ),\n      );\n    }\n\n    host.setRegions(regions);\n    // Ids are minted during setRegions — read them back for the next tick.\n    this.regionId = primary.id ?? this.regionId;\n    this.template = primary;\n    this.extraIds = extras.map((r) => r.id).filter((id): id is number => id != null);\n    this.lastCommitted = [primary, ...extras].map((r) => r.bounds);\n  }\n\n  /** Remove the stroke's region(s) and reset — an erase deleted every pixel. */\n  dropActive(regions: Region[], host: IRegionDataHost): void {\n    const ids = [this.regionId, ...this.extraIds].filter((id): id is number => id != null);\n    let changed = false;\n    for (const id of ids) {\n      const idx = regions.findIndex((r) => r.id === id);\n      if (idx >= 0) {\n        regions.splice(idx, 1);\n        changed = true;\n      }\n    }\n    if (changed) host.setRegions(regions);\n    this.reset();\n  }\n\n  // ── internals ────────────────────────────────────────────────────────\n\n  /** The region with `id` in `regions`, or the adopted/merged template when a\n   *  merge already removed it from the list. */\n  private owner(regions: Region[], id: number | null): Region | null {\n    if (id == null) return null;\n    return regions.find((r) => r.id === id) ?? (this.template?.id === id ? this.template : null);\n  }\n\n  /** Replace `existing` in place (or append it if a merge removed it). */\n  private upsert(regions: Region[], existing: Region | null, bounds: Polygon, opts: StrokeCommitOptions): Region {\n    if (!existing) return this.insert(regions, opts.newRegion(bounds));\n    const region = replaceBounds(existing, bounds, this.patchFor(existing, opts));\n    const idx = regions.findIndex((r) => r.id === existing.id);\n    if (idx >= 0) regions[idx] = region;\n    else regions.push(region);\n    return region;\n  }\n\n  /** The fields an edit sets on `existing`: the tool's patch, plus a default label. */\n  private patchFor(existing: Region, opts: StrokeCommitOptions): Partial<Region> {\n    return existing.label == null ? { label: opts.defaultLabel, ...opts.editPatch } : { ...opts.editPatch };\n  }\n\n  private insert(regions: Region[], region: Region): Region {\n    regions.push(region);\n    return region;\n  }\n\n  /**\n   * A region's closed ring and holes in matrix coords, or null when it can't be\n   * edited as a mask: not a closed polygon (rectangles, polylines,\n   * multi-polygons), or too large to rasterize faithfully at this zoom — editing\n   * would clip or down-quantize it and bring it back rescaled (jit-ui#102).\n   */\n  private editableRing(\n    region: Region,\n    frame: MatrixFrame,\n  ): { xs: number[]; ys: number[]; holes?: number[][][] } | null {\n    const b = region?.bounds;\n    if (!(b instanceof Polygon) || b.closed === false || b.xpoints.length < 3) return null;\n    const ring = frame.ringToMatrix(b.xpoints, b.ypoints);\n    const r = ringBounds(ring.xs, ring.ys);\n    const w = r.maxX - r.minX,\n      h = r.maxY - r.minY;\n    if (!(w > 0 && h > 0 && w * h <= MAX_RASTER_PIXELS)) return null;\n    return { xs: ring.xs, ys: ring.ys, holes: frame.holesToMatrix(b.holes) };\n  }\n}\n"]}

package/esm2022/lib/toolbar/tool-kit/matrix-frame.mjs

@@ -0,0 +1,61 @@
+/**
+ * The mapping between a backend's data coordinates and the pixel matrix of a
+ * cached readback (`CachedImageData`): `matrix = (data - origin) / ratio` per
+ * axis. OSD and napari publish distinct `[ratioX, ratioY]`, so rows must use
+ * the Y ratio; a single ratio is used for both axes when only one is supplied.
+ */
+export class MatrixFrame {
+    constructor(
+    /** Data units per matrix column. */
+    rx, 
+    /** Data units per matrix row. */
+    ry, 
+    /** Data X of matrix column 0. */
+    ox, 
+    /** Data Y of matrix row 0. */
+    oy) {
+        this.rx = rx;
+        this.ry = ry;
+        this.ox = ox;
+        this.oy = oy;
+    }
+    /** The frame of a readback. Missing/zero ratios fall back to 1, missing origins to 0. */
+    static from(cached) {
+        const rx = cached.ratios[0] || 1;
+        const ry = cached.ratios[1] || cached.ratios[0] || 1;
+        return new MatrixFrame(rx, ry, cached.originX ?? 0, cached.originY ?? 0);
+    }
+    /** Identity of the frame: a stroke built in matrix coords is only valid while this is unchanged. */
+    get sig() {
+        return `${this.rx},${this.ry},${this.ox},${this.oy}`;
+    }
+    toMatrixX(x) {
+        return (x - this.ox) / this.rx;
+    }
+    toMatrixY(y) {
+        return (y - this.oy) / this.ry;
+    }
+    toDataX(mx) {
+        return this.ox + mx * this.rx;
+    }
+    toDataY(my) {
+        return this.oy + my * this.ry;
+    }
+    /** A ring (parallel arrays) from data to matrix coords. */
+    ringToMatrix(xs, ys) {
+        return { xs: xs.map((x) => this.toMatrixX(x)), ys: ys.map((y) => this.toMatrixY(y)) };
+    }
+    /** A ring (parallel arrays) from matrix to data coords. */
+    ringToData(xs, ys) {
+        return { xs: xs.map((x) => this.toDataX(x)), ys: ys.map((y) => this.toDataY(y)) };
+    }
+    /** Hole rings (`[[x, y], …]`) from data to matrix coords. */
+    holesToMatrix(holes) {
+        return holes?.map((ring) => ring.map(([x, y]) => [this.toMatrixX(x), this.toMatrixY(y)]));
+    }
+    /** Hole rings (`[[x, y], …]`) from matrix to data coords. */
+    holesToData(holes) {
+        return holes?.map((ring) => ring.map(([x, y]) => [this.toDataX(x), this.toDataY(y)]));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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