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

package/lib/toolbar/vertex-eraser/vertex-eraser-tool.service.d.ts

@@ -1,64 +1,57 @@
-import { WandService } from '../wand/wand.service';
-import { IViewportHost, IRegionDataHost } from '../../contracts/coordinate-transform.contract';
-import * as i0 from "@angular/core";
+import { IVertexEraserOptions } from '../../contracts/display-types';
+import { UndoGestureTarget } from '../tool-kit/undo-gesture';
+import { CanvasToolHost, ICanvasTool } from '../tool-kit/canvas-tool';
 /**
- * Collaboration interface the vertex eraser needs from its host backend.
- *
- * Extends {@link IViewportHost} for coordinate conversion + overlay attachment,
- * so the eraser is backend-agnostic (Plotly and OpenSeadragon both satisfy it).
+ * @deprecated One host serves every canvas tool: use {@link CanvasToolHost}.
+ * The eraser converts with its readback's per-axis ratios
+ * (`getCachedImageData().ratios`, RT-14); `getCachedImageRatio()` is gone.
  */
-export interface VertexEraserToolHost extends IViewportHost, IRegionDataHost {
-    /**
-     * Drop the wand's in-progress stroke. Called after the eraser modifies
-     * regions — the wand's accumulator may now reference stale vertices.
-     */
-    invalidateWandRegion(): void;
-    /**
-     * Data-coords-per-image-pixel ratio (== cachedImageRatios[0] || 1). Used to
-     * convert between matrix coordinates (the eraser's native space) and the
-     * backend's data coordinates.
-     */
-    getCachedImageRatio(): number;
-}
+export type VertexEraserToolHost = CanvasToolHost;
 /**
  * Vertex eraser. A custom canvas overlay that, on click/drag, removes any
  * polygon vertex within `radius` matrix-pixels of the cursor from every
- * `type: 'path'` shape on the plot. Polygons that fall below 3 vertices
- * (or polylines below 2) are removed entirely.
+ * annotation polygon/polyline (never an intensity-profile line). The outline is
+ * rejoined where it crosses the eraser's edge, so erasing a corner of a sparse
+ * outline (a traced box is four vertices) trims that corner instead of cutting
+ * to the next corners; a Bezier region's anchors are dropped outright. Polygons
+ * that fall below 3 vertices (or polylines below 2) are removed entirely.
  *
  * The cursor is rendered as a dashed-red circle on the overlay so the user
  * can see the active radius while moving.
  */
-export declare class VertexEraserToolService {
-    private wandService;
+export declare class VertexEraserTool implements ICanvasTool<IVertexEraserOptions> {
+    readonly id = "eraseVertex";
     private host;
-    private overlay;
+    private readonly overlay;
     private dragging;
     /** Eraser radius in image-pixel (matrix) coordinates. */
     private radius;
     private cursor;
-    private readonly boundMouseDown;
-    private readonly boundMouseMove;
-    private readonly boundMouseUp;
-    constructor(wandService: WandService);
-    bindHost(host: VertexEraserToolHost): void;
-    setMode(active: boolean): void;
+    /** Makes each drag one undo step, however long the user pauses (RT-12). */
+    private readonly gesture;
+    /** @param gestureTarget the region store, so each drag is one undo step. */
+    constructor(gestureTarget?: UndoGestureTarget | null);
+    /** Arm the eraser on `host`, optionally with a new radius. */
+    activate(host: CanvasToolHost, options?: IVertexEraserOptions): void;
+    /** Disarm: remove the overlay and its cursor. */
+    deactivate(): void;
+    setOptions(options: IVertexEraserOptions): void;
     /** Set eraser radius in matrix-pixel (image pixel) coordinates. */
     setRadius(radius: number): void;
     private createOverlay;
-    private destroyOverlay;
-    private onMouseDown;
-    private onMouseMove;
-    private onMouseUp;
+    private onPointerDown;
+    private onPointerMove;
+    private onPointerUp;
     private updateCursor;
     /** Draw the eraser radius circle at the current cursor position. */
     private drawCursor;
+    /** The data↔matrix frame of the host's readback (identity without one). */
+    private frame;
     /**
-     * Drop every vertex of every path-shape that lies within the eraser's
-     * radius of the cursor. Polygons reduced below 3 vertices (or polylines
-     * below 2) are removed entirely.
+     * Drop every vertex of every annotation polygon/polyline that lies within the
+     * eraser's radius of the cursor, rejoining the outline at the eraser's edge
+     * (see {@link eraseRingWithinRadius}). Polygons reduced below 3 vertices (or
+     * polylines below 2) are removed entirely. Edited regions keep their metadata.
      */
     private applyAtClient;
-    static ɵfac: i0.ɵɵFactoryDeclaration<VertexEraserToolService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<VertexEraserToolService>;
 }

package/lib/toolbar/view-controls/view-controls.component.d.ts

@@ -0,0 +1,54 @@
+import { EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * The toolbar's view group: 2D zoom / pan tools, or for a 3D view the camera
+ * modes and reset, the napari axes and wireframe toggles and the 3D
+ * resolution. Presentational: the host owns every value.
+ */
+export declare class ViewControlsComponent {
+    /** A 2D view (zoom tools) rather than a 3D one (camera controls). */
+    isHeatmap: boolean;
+    /** The host shows the zoom tools. */
+    zoomTools: boolean;
+    /** The OSD Image view (pans natively; no Plotly drag-zoom). */
+    isImageView: boolean;
+    /** The armed zoom/pan tool (`zoom`, `pan`, …), or null. */
+    activeDragMode: string | null;
+    /** The 3D camera mode (`turntable` / `orbit` / …). */
+    activeSurface3dMode: string;
+    /** A napari-js WebGPU view (axes toggle, napari camera). */
+    isNapariMode: boolean;
+    /** The napari-js surface (shows the wireframe toggle). */
+    isNapariSurfaceMode: boolean;
+    /** A napari-js 3D view (shows the Resolution dropdown). */
+    isNapari3dMode: boolean;
+    /** The napari 3D axes gizmo is shown. */
+    axesVisible: boolean;
+    /** The napari surface wireframe is on. */
+    wireframeActive: boolean;
+    /** Active napari 3D decimate factor (1 = Full … 8 = ⅛). */
+    resolutionScale: number;
+    /** A zoom/pan tool button was clicked (its mode). */
+    toggleDragMode: EventEmitter<string>;
+    /** Zoom in one step. */
+    zoomIn: EventEmitter<void>;
+    /** Zoom out one step. */
+    zoomOut: EventEmitter<void>;
+    /** A 3D camera mode button was clicked (its mode). */
+    toggleSurface3dMode: EventEmitter<string>;
+    /** Reset the 3D camera. */
+    resetSurfaceCamera: EventEmitter<void>;
+    /** Toggle the napari 3D axes gizmo. */
+    toggleAxes: EventEmitter<void>;
+    /** Toggle the napari surface wireframe. */
+    toggleWireframe: EventEmitter<void>;
+    /** A napari 3D decimate factor was picked. */
+    selectResolution: EventEmitter<number>;
+    /** Decimate-factor options for the Resolution dropdown. */
+    protected readonly decimateOptions: {
+        label: string;
+        value: number;
+    }[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<ViewControlsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ViewControlsComponent, "toolbar-view-controls", never, { "isHeatmap": { "alias": "isHeatmap"; "required": false; }; "zoomTools": { "alias": "zoomTools"; "required": false; }; "isImageView": { "alias": "isImageView"; "required": false; }; "activeDragMode": { "alias": "activeDragMode"; "required": false; }; "activeSurface3dMode": { "alias": "activeSurface3dMode"; "required": false; }; "isNapariMode": { "alias": "isNapariMode"; "required": false; }; "isNapariSurfaceMode": { "alias": "isNapariSurfaceMode"; "required": false; }; "isNapari3dMode": { "alias": "isNapari3dMode"; "required": false; }; "axesVisible": { "alias": "axesVisible"; "required": false; }; "wireframeActive": { "alias": "wireframeActive"; "required": false; }; "resolutionScale": { "alias": "resolutionScale"; "required": false; }; }, { "toggleDragMode": "toggleDragMode"; "zoomIn": "zoomIn"; "zoomOut": "zoomOut"; "toggleSurface3dMode": "toggleSurface3dMode"; "resetSurfaceCamera": "resetSurfaceCamera"; "toggleAxes": "toggleAxes"; "toggleWireframe": "toggleWireframe"; "selectResolution": "selectResolution"; }, never, never, true, never>;
+}

package/lib/toolbar/wand/wand-region-grow.d.ts

@@ -0,0 +1,49 @@
+import { Polygon } from '../../models/region';
+import { IWandOptions, WandType } from '../../contracts/display-types';
+import { CachedFrame } from '../tool-kit/frame-pixels';
+/**
+ * Wand region-grow pipeline (pure, DOM- and DI-free), modelled after QuPath's
+ * WandToolEventHandler: extract a square patch around the click, optionally
+ * blur it, compute a local threshold (per channel, or a CIELAB distance map),
+ * run a fixed-range flood fill from the centre, close the mask, and (for
+ * {@link computeWandRegion}) trace it to a polygon in image coordinates.
+ *
+ * `WandService` delegates here; workers and new code should import these
+ * functions directly.
+ */
+export type { WandType };
+export type WandOptions = IWandOptions;
+export interface WandImage {
+    /**
+     * Grayscale: number[][] where data[y][x] is intensity.
+     * RGB: [r,g,b][][] where data[y][x] is a 3-tuple.
+     * Or a packed RGBA readback, read as RGB (see `tool-kit/frame-pixels`).
+     */
+    data: CachedFrame;
+    width: number;
+    height: number;
+    isGrayscale: boolean;
+}
+/** A wand patch mask: `size`×`size` 0/1 cells in patch-local coordinates. */
+export interface WandPatchMask {
+    mask: Uint8Array;
+    size: number;
+}
+/**
+ * Grow a region from a click and trace it.
+ *
+ * @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.
+ */
+export declare function computeWandRegion(image: WandImage, cx: number, cy: number, options?: WandOptions): Polygon | null;
+/**
+ * The wand's per-click flood-fill mask in patch-local coordinates: the same
+ * pipeline as {@link computeWandRegion}, stopping before contour tracing (the
+ * tools accumulate per-tick masks across a brush-style stroke).
+ *
+ * @throws when `options.patchSize` is even.
+ */
+export declare function computeWandPatchMask(image: WandImage, cx: number, cy: number, options?: WandOptions): WandPatchMask | null;

package/lib/toolbar/wand/wand-tool.service.d.ts

@@ -1,98 +1,49 @@
 import { WandOptions, WandService } from './wand.service';
-import { IViewportHost, IRegionDataHost } from '../../contracts/coordinate-transform.contract';
-import * as i0 from "@angular/core";
+import { UndoGestureTarget } from '../tool-kit/undo-gesture';
+import { CanvasToolHost, ICanvasTool } from '../tool-kit/canvas-tool';
+export type { CachedImageData } from '../tool-kit/canvas-tool';
+/** @deprecated One host serves every canvas tool: use {@link CanvasToolHost}. */
+export type WandToolHost = CanvasToolHost;
 /**
- * The pixel data and frame state PlotlyService caches for sampling. Returned
- * by `WandToolHost.getCachedImageData()`.
- */
-export interface CachedImageData {
-    /** 2-D matrices, one per stack frame (length 1 for non-stack images). */
-    frames: any[];
-    /** Image-pixel width of each frame matrix. */
-    width: number;
-    /** Image-pixel height of each frame matrix. */
-    height: number;
-    /**
-     * Plot-data-coords-per-image-pixel along x (and y — they're the same
-     * for heatmap and image traces).
-     */
-    ratios: number[];
-    /** Whether each frame is a 2-D scalar matrix (true) or 3-channel RGB (false). */
-    isGrayscale: boolean;
-    /**
-     * Data-coords of matrix pixel (0,0). Lets the matrix be a *crop* of the data
-     * space rather than starting at the origin — e.g. the OSD backend samples the
-     * currently rendered viewport, so when zoomed in the matrix covers only the
-     * visible sub-region at screen resolution. Defaults to 0 (full-frame matrix,
-     * as Plotly provides). matrixIndex = (data - origin) / ratio.
-     */
-    originX?: number;
-    originY?: number;
-}
-/**
- * The collaboration interface the wand tool needs from PlotlyService.
+ * The wand drawing tool. Owns its pointer overlay and stroke accumulator
+ * (shared with the brush, see {@link MaskStrokeEditor}). Reads/writes regions
+ * via its {@link CanvasToolHost} so it stays decoupled from the backends.
  *
- * Keeping it explicit makes the dependency one-way: WandToolService never
- * imports PlotlyService directly. PlotlyService satisfies this interface
- * structurally and binds itself via `bindHost(this)`.
+ * A plain class: each backend's `CanvasToolManager` owns one instance and arms
+ * it with `activate(host, options)` / `deactivate()`.
  */
-export interface WandToolHost extends IViewportHost, IRegionDataHost {
-    /** Pixel data for sampling. null when no image is loaded yet. */
-    getCachedImageData(): CachedImageData | null;
-    /** Index of the currently visible frame in a stack (0 for non-stack). */
-    getActiveFrameIndex(): number;
-    /** Current image's filename — stamped onto new shapes for filtering. */
-    getFileName(): string | undefined;
-    /** Default stroke colour for new shapes. */
-    getShapeColor(): string;
-}
-/**
- * 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 declare class WandToolService {
-    private wandService;
+export declare class WandTool implements ICanvasTool<WandOptions> {
+    private readonly wandService;
+    readonly id = "wand";
     private host;
-    private overlay;
-    private active;
+    private readonly overlay;
     /**
-     * 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.
+     * Accumulated wand region. Every per-tick patch mask is OR'd into the stroke
+     * 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.
      */
-    private stroke;
-    /** Id of the region this wand stroke is editing (null = a fresh region). */
-    private strokeRegionId;
-    /** 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). */
-    private strokeRatioSig;
+    private readonly editor;
     private dragging;
     private options;
-    private readonly boundMouseDown;
-    private readonly boundMouseMove;
-    private readonly boundMouseUp;
-    constructor(wandService: WandService);
-    /** Wire the tool to its host. Must be called once before `setMode(true)`. */
-    bindHost(host: WandToolHost): void;
-    /** Toggle the wand on/off. */
-    setMode(active: boolean, options?: WandOptions): void;
+    /** Makes each drag one undo step, however long the user pauses (RT-12). */
+    private readonly gesture;
+    /** @param gestureTarget the region store, so each drag is one undo step. */
+    constructor(wandService: WandService, gestureTarget?: UndoGestureTarget | null);
+    /** Arm the wand on `host` with `options` (replacing the previous options). */
+    activate(host: CanvasToolHost, options?: WandOptions): void;
+    /** Disarm: remove the overlay and drop the active region. */
+    deactivate(): void;
     /** Merge new options (e.g. live sensitivity slider updates). */
     setOptions(options: WandOptions): void;
     /** Drop the active wand region so the next click starts a new one. */
-    clearActiveRegion(): void;
+    reset(): void;
     private createOverlay;
-    private destroyOverlay;
-    private onMouseDown;
-    private onMouseMove;
-    private onMouseUp;
+    private onPointerDown;
+    private onPointerMove;
+    private onPointerUp;
     private resetStroke;
     /**
      * Sample the cached image at the click location, OR (or AND-NOT) the
@@ -102,48 +53,12 @@ export declare class WandToolService {
      * exact-match flood fill.
      */
     private applyAtClient;
-    /** True if (matrixX, matrixY) lies inside the current stroke accumulator. */
-    private pointInStroke;
-    /**
-     * Remove the region referenced by `strokeRegionId` from the region list and
-     * reset the active stroke — used when an erase stroke deletes every pixel.
-     */
-    private dropActiveShape;
-    /**
-     * 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.
-     */
-    private fitsForEdit;
-    /** A region's closed-polygon vertices (image/data coords), or null when it
-     *  isn't a fillable closed polygon (rectangles, open polylines). */
-    private regionVerts;
-    /** Convert a region's hole rings from image/data coords into matrix coords so
-     *  they line up with the stroke accumulator (jit-ui#85). */
-    private holesToMatrix;
-    /**
-     * 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.
-     */
-    private tryAdoptShapeAt;
-    /**
-     * 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.
-     */
-    private mergeOverlappingShapes;
+    /** The visible frame of the readback, as the region grow reads it. */
+    private wandImage;
     /**
-     * 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.
+     * OR (add) or AND-NOT (erase) the patch mask, centred on matrix point
+     * (cx, cy), into the stroke, growing the stroke to cover it first when
+     * adding. False when a fresh stroke has nothing inside the readback.
      */
-    private commitStroke;
-    static ɵfac: i0.ɵɵFactoryDeclaration<WandToolService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<WandToolService>;
+    private stampPatch;
 }

package/lib/toolbar/wand/wand.service.d.ts

@@ -1,133 +1,39 @@
 import { Polygon } from '../../models/region';
-import { IWandOptions, WandType } from '../../contracts/display-types';
+import { BBoxMask } from '../../geometry/raster';
+import { WandImage, WandOptions, WandPatchMask } from './wand-region-grow';
 import * as i0 from "@angular/core";
-export type { WandType };
-export type WandOptions = IWandOptions;
-export interface WandImage {
-    /**
-     * Grayscale: number[][] where data[y][x] is intensity.
-     * RGB: [r,g,b][][] where data[y][x] is a 3-tuple.
-     */
-    data: number[][] | number[][][];
-    width: number;
-    height: number;
-    isGrayscale: boolean;
-}
+export type { WandImage, WandOptions, WandPatchMask, WandType } from './wand-region-grow';
 /**
- * Wand region-growing tool, modelled after QuPath's WandToolEventHandler.
+ * Thin DI façade over the wand's pure modules, kept for one release so the
+ * injected consumers (the canvas tools, the backends) keep compiling.
+ *
+ * - region grow: `toolbar/wand/wand-region-grow`
+ * - rasterizer: `geometry/raster`; ring tests: `geometry/ring`
+ * - contour tracing: `geometry/contour`
  *
- * 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.
+ * @deprecated Import the pure functions instead; this service will be removed.
  */
 export declare 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.
-     */
+    /** See {@link computeWandRegion} in `toolbar/wand/wand-region-grow`. */
     computeRegion(image: WandImage, cx: number, cy: number, options?: WandOptions): Polygon | null;
-    /**
-     * 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: WandImage, cx: number, cy: number, options?: WandOptions): {
-        mask: Uint8Array;
-        size: number;
-    } | null;
-    /**
-     * Standard ray-cast point-in-polygon test. (px, py) and the polygon
-     * vertices must be in the same coordinate system.
-     */
+    /** See {@link computeWandPatchMask} in `toolbar/wand/wand-region-grow`. */
+    computePatchMask(image: WandImage, cx: number, cy: number, options?: WandOptions): WandPatchMask | null;
+    /** Ray-cast point-in-ring test; see {@link pointInRing}. */
     pointInPolygon(px: number, py: number, xpoints: number[], ypoints: number[]): boolean;
-    /**
-     * 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).
-     */
+    /** See {@link dropVerticesWithinRadius} in `geometry/ring`. */
     dropVerticesWithinRadius(xpoints: number[], ypoints: number[], cx: number, cy: number, radius: number): {
         xpoints: number[];
         ypoints: number[];
         removed: number;
     };
-    /**
-     * 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: number[], ypoints: number[], imageWidth: number, imageHeight: number, holes?: number[][][]): {
-        bx: number;
-        by: number;
-        bw: number;
-        bh: number;
-        mask: Uint8Array;
-    } | null;
-    /**
-     * 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}.
-     */
+    /** See {@link rasterizePolygon} in `geometry/raster`. */
+    rasterizePolygon(xpoints: number[], ypoints: number[], imageWidth: number, imageHeight: number, holes?: number[][][]): BBoxMask | null;
+    /** See {@link pointInPolygonWithHoles} in `geometry/ring`. */
     pointInPolygonWithHoles(px: number, py: number, xpoints: number[], ypoints: number[], holes?: number[][][]): boolean;
-    /**
-     * 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: Uint8Array, w: number, h: number, _imageWidth: number, _imageHeight: number, originX: number, originY: number): Polygon | null;
-    /**
-     * 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: Uint8Array, w: number, h: number, imageWidth: number, imageHeight: number, originX: number, originY: number, minSize?: number, minHoleSize?: number): Polygon[];
-    /**
-     * 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.
-     */
-    private detectHoles;
-    /**
-     * 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: Uint32Array, w: number, h: number, imageWidth: number, imageHeight: number, originX: number, originY: number, minSize?: number): Polygon[];
-    private extractPatch;
-    private gaussianBlur;
-    private perChannelThreshold;
-    private labDistanceMap;
-    /**
-     * Fixed-range scanline flood fill from the patch centre. A neighbour is
-     * accepted iff for every channel `|p[c] - seed[c]| <= threshold[c]`.
-     */
-    private floodFill;
-    private morphClose;
-    private dilate;
-    private erode;
-    /**
-     * Returns the outer boundary of the largest 4-connected blob in the mask
-     * sized w*h.
-     */
-    private traceContour;
-    private mooreBoundary;
+    /** See {@link maskToPolygons} in `geometry/contour`. */
+    maskToPolygons(mask: Uint8Array, w: number, h: number, originX: number, originY: number, minSize?: number, minHoleSize?: number): Polygon[];
+    /** See {@link labelsToPolygons} in `geometry/contour`. */
+    labelsToPolygons(labels: Uint32Array, w: number, h: number, originX: number, originY: number, minSize?: number): Polygon[];
     static ɵfac: i0.ɵɵFactoryDeclaration<WandService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<WandService>;
 }

package/lib/toolbar/zoom-to-box/zoom-to-box-tool.service.d.ts

@@ -1,49 +1,29 @@
-import * as i0 from "@angular/core";
+import { CanvasToolHost, ICanvasTool } from '../tool-kit/canvas-tool';
 /**
- * Collaboration interface the zoom-to-box tool needs from PlotlyService.
+ * @deprecated One host serves every canvas tool: use {@link CanvasToolHost}.
+ * The overlay now attaches to `getOverlayContainer()` (formerly the element
+ * with id `getPlotDiv()`), and `pixelToData` / `applyZoomToBox` are its
+ * optional zoom-to-box members.
  */
-export interface ZoomToBoxToolHost {
-    /** DOM id of the plot element the overlay canvas attaches to. */
-    getPlotDiv(): string;
-    /**
-     * Convert an overlay-pixel point (relative to the plot element's top-left)
-     * into the backend's data coordinates — Plotly axis data for Plotly,
-     * image-pixel coords for OpenSeadragon. Keeps the tool backend-agnostic.
-     */
-    pixelToData(px: number, py: number): {
-        x: number;
-        y: number;
-    };
-    /**
-     * Apply the user-selected zoom rectangle, ordered `[xMin, xMax, yMax, yMin]`.
-     * The host decides what that means: Plotly does a high-def re-fetch / axis
-     * relayout, OpenSeadragon fits the viewport to the image rectangle.
-     */
-    applyZoomToBox(coordinates: number[]): void;
-}
+export type ZoomToBoxToolHost = CanvasToolHost;
 /**
  * Custom canvas overlay for click-and-drag rectangular zoom. Plotly's
  * built-in `dragmode: 'zoom'` works on heatmap/image traces too, but it
  * doesn't drive the high-def zoom pipeline — this overlay does, by handing
  * the selected coordinates back to the host.
  */
-export declare class ZoomToBoxToolService {
+export declare class ZoomToBoxTool implements ICanvasTool<void> {
+    readonly id = "zoomToBox";
     private host;
-    private overlay;
+    private readonly overlay;
     private startPx;
-    private readonly boundMouseDown;
-    private readonly boundMouseMove;
-    private readonly boundMouseUp;
-    constructor();
-    bindHost(host: ZoomToBoxToolHost): void;
-    setMode(active: boolean): void;
-    private createOverlay;
-    private destroyOverlay;
-    private onMouseDown;
-    private onMouseMove;
-    private onMouseUp;
+    /** Lay the selection overlay over `host`'s plot. */
+    activate(host: CanvasToolHost): void;
+    /** Remove the overlay and any half-drawn box. */
+    deactivate(): void;
+    /** Primary button only (the overlay filters the others). */
+    private onPointerDown;
+    private onPointerMove;
+    private onPointerUp;
     private drawSelection;
-    private clearCanvas;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ZoomToBoxToolService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<ZoomToBoxToolService>;
 }

package/lib/util/mark-for-check.d.ts

@@ -0,0 +1,11 @@
+import { ChangeDetectorRef, NgZone } from '@angular/core';
+/**
+ * Mark an OnPush view for check, from wherever the change came from.
+ *
+ * `markForCheck()` only flags the view; a change-detection pass runs when the zone next
+ * settles. A change that arrives outside the zone — a store emission from an overlay's
+ * pointer handler, an OpenSeadragon or napari-js callback, a host stream — settles no
+ * zone, so the view would keep showing stale state until some unrelated event runs
+ * change detection. Re-entering the zone in that case schedules the pass.
+ */
+export declare function markForCheckInZone(cdr: ChangeDetectorRef, zone: NgZone): void;